@intlayer/core 9.4.3 → 9.4.4

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"}

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

@@ -13,7 +13,7 @@
  * - `'disabled'` — the option was explicitly set to `false`. The proxy is not
  *   registered at all (Vite) or becomes a pass-through (Next.js).
  */
-type ProxyMode = 'auto' | 'forced' | 'disabled';
+export type ProxyMode = 'auto' | 'forced' | 'disabled';
 /**
  * Resolves the effective {@link ProxyMode} from the `routing.enableProxy`
  * configuration value.
@@ -34,7 +34,7 @@ type ProxyMode = 'auto' | 'forced' | 'disabled';
  * resolveProxyMode(false);     // 'disabled'
  * ```
  */
-declare const resolveProxyMode: (enableProxy?: boolean) => ProxyMode;
+export declare const resolveProxyMode: (enableProxy?: boolean) => ProxyMode;
 /**
  * Indicates whether the proxy may use the locale held in storage (cookie or
  * header) as a source when deciding which locale a request resolves to.
@@ -59,7 +59,7 @@ declare const resolveProxyMode: (enableProxy?: boolean) => ProxyMode;
  * isProxyStorageLocaleEnabled('forced', true);  // true  — explicitly opted in
  * ```
  */
-declare const isProxyStorageLocaleEnabled: (proxyMode: ProxyMode, isDevServer: boolean) => boolean;
+export declare const isProxyStorageLocaleEnabled: (proxyMode: ProxyMode, isDevServer: boolean) => boolean;
 /**
  * Builds the line announcing that a server has mounted the locale-routing
  * proxy.
@@ -86,7 +86,6 @@ declare const isProxyStorageLocaleEnabled: (proxyMode: ProxyMode, isDevServer: b
  * // Intlayer proxy enabled
  * ```
  */
-declare const formatProxyEnabledMessage: (isStorageLocaleSuppressed: boolean) => string;
+export declare const formatProxyEnabledMessage: (isStorageLocaleSuppressed: boolean) => string;
 //#endregion
-export { ProxyMode, formatProxyEnabledMessage, isProxyStorageLocaleEnabled, resolveProxyMode };
 //# sourceMappingURL=proxyMode.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"proxyMode.d.ts","names":[],"sources":["../../../src/localization/proxyMode.ts"],"mappings":";;;;;;;;;;;;;;;KAiBY;;;;;;;;;;;;;;;;;;;;;cAsBC,mBAAgB,0BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;cAkC5C,8BAA2B,WAC3B,WAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;cA8BT,4BAAyB"}
+{"version":3,"file":"proxyMode.d.ts","names":[],"sources":["../../../src/localization/proxyMode.ts"],"mappings":";;;;;;;;;;;;;;;YAiBY;;;;;;;;;;;;;;;;;;;;;qBAsBC,mBAAgB,0BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;qBAkC5C,8BAA2B,WAC3B,WAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA8BT,4BAAyB"}

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

@@ -15,7 +15,7 @@ import { LocalesValues } from "@intlayer/types/module_augmentation";
  * @param options - Routing overrides, defaulting to the built configuration.
  * @returns The resolved locale, falling back to the default locale off-browser.
  */
-declare const resolveBrowserLocale: (options?: RoutingOptions) => LocalesValues;
+export declare const resolveBrowserLocale: (options?: RoutingOptions) => LocalesValues;
 /**
  * {@link resolveBrowserLocale}, memoized for the current URL.
  *
@@ -29,7 +29,6 @@ declare const resolveBrowserLocale: (options?: RoutingOptions) => LocalesValues;
  * chunks with that locale, instead of preloading the old one and silently
  * falling back to an asynchronous read.
  */
-declare const getPreloadLocale: () => LocalesValues;
+export declare const getPreloadLocale: () => LocalesValues;
 //#endregion
-export { getPreloadLocale, resolveBrowserLocale };
 //# sourceMappingURL=resolveBrowserLocale.d.ts.map

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

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

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

@@ -6,15 +6,14 @@ import { RewriteObject, RewriteRules, RoutingConfig } from "@intlayer/types/conf
  * Idempotent: already-normalized rules are handed back untouched, so a caller
  * holding resolved rules can pass them on without re-normalizing.
  */
-declare const getRewriteRules: <const Context extends keyof RewriteObject = 'url'>(rewrite: RoutingConfig['rewrite'] | RewriteRules, context?: Context) => RewriteRules | undefined;
+export declare const getRewriteRules: <const Context extends keyof RewriteObject = 'url'>(rewrite: RoutingConfig['rewrite'] | RewriteRules, context?: Context) => RewriteRules | undefined;
 /**
  * Replaces route parameters in a path with provided values.
  */
-declare const fillPath: (pattern: string, params: string[]) => string;
+export declare const fillPath: (pattern: string, params: string[]) => string;
 /**
  * Extract values from a URL based on a pattern.
  */
-declare const extractParams: (url: string, pattern: string) => string[] | null;
+export declare const extractParams: (url: string, pattern: string) => string[] | null;
 //#endregion
-export { extractParams, fillPath, getRewriteRules };
 //# sourceMappingURL=rewriteMatch.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"rewriteMatch.d.ts","names":[],"sources":["../../../src/localization/rewriteMatch.ts"],"mappings":";;;;;;;;cAYa,wBACL,sBAAsB,uBAAqB,SAExC,2BAA2B,cAAY,UACvC,YACR;;;;cA+DU,WAAQ,iBAAmB;;;;cAa3B,gBAAa,aACb"}
+{"version":3,"file":"rewriteMatch.d.ts","names":[],"sources":["../../../src/localization/rewriteMatch.ts"],"mappings":";;;;;;;;qBAYa,wBACL,sBAAsB,uBAAqB,SAExC,2BAA2B,cAAY,UACvC,YACR;;;;qBA+DU,WAAQ,iBAAmB;;;;qBAa3B,gBAAa,aACb"}

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

@@ -8,7 +8,7 @@ import { RewriteRules, RoutingConfig } from "@intlayer/types/config";
  * input that was passed in, so a literal input keeps its literal type. Only a
  * rewritten path is computed at runtime and therefore widens to `string`.
  */
-type LocalizedPathResult<CanonicalPath extends string = string> = {
+export type LocalizedPathResult<CanonicalPath extends string = string> = {
   path: CanonicalPath;
   isRewritten: false;
 } | {
@@ -31,7 +31,7 @@ type WithLeadingSlash<Path extends string> = Path extends `/${string}` ? Path :
  * type B = InternalPath<'/', 'fr'>;         // '/fr'
  * type C = InternalPath<'/fr/about', 'fr'>; // '/fr/about' (already prefixed)
  */
-type InternalPath<Path extends string, Locale extends string> = string extends Path ? string : WithLeadingSlash<Path> extends (infer Prefixed extends string) ? Prefixed extends `/${Locale}` | `/${Locale}/${string}` ? Prefixed : Prefixed extends '/' ? `/${Locale}` : `/${Locale}${Prefixed}` : never;
+export type InternalPath<Path extends string, Locale extends string> = string extends Path ? string : WithLeadingSlash<Path> extends (infer Prefixed extends string) ? Prefixed extends `/${Locale}` | `/${Locale}/${string}` ? Prefixed : Prefixed extends '/' ? `/${Locale}` : `/${Locale}${Prefixed}` : never;
 /**
  * Given a canonical path (e.g., "/products/123"), finds the localized URL pattern
  * (e.g., "/produits/123") and reports whether a rule actually matched.
@@ -46,16 +46,15 @@ type InternalPath<Path extends string, Locale extends string> = string extends P
  * @param rewriteRules - Normalized rules, as returned by {@link getRewriteRules}.
  * @returns The localized path, discriminated on whether a rewrite rule matched.
  */
-declare const resolveLocalizedPath: <const CanonicalPath extends string, const Locale extends LocalesValues = ResolvedDefaultLocale>(canonicalPath: CanonicalPath, locale?: Locale, rewriteRules?: RewriteRules) => LocalizedPathResult<CanonicalPath>;
+export declare const resolveLocalizedPath: <const CanonicalPath extends string, const Locale extends LocalesValues = ResolvedDefaultLocale>(canonicalPath: CanonicalPath, locale?: Locale, rewriteRules?: RewriteRules) => LocalizedPathResult<CanonicalPath>;
 /**
  * Returns the internal path for a given canonical path and locale.
  * Ensures the locale prefix is present exactly once.
  */
-declare const getInternalPath: <const Path extends string, const Locale extends LocalesValues>(canonicalPath: Path, locale: Locale) => InternalPath<Path, Locale>;
+export declare const getInternalPath: <const Path extends string, const Locale extends LocalesValues>(canonicalPath: Path, locale: Locale) => InternalPath<Path, Locale>;
 /**
  * Given a current pathname and locale, returns the pretty localized path if a rewrite rule exists and the path is not already localized.
  */
-declare const getRewritePath: <const Path extends string, const Locale extends LocalesValues = ResolvedDefaultLocale>(pathname: Path, locale: Locale, rewrite?: RoutingConfig['rewrite']) => string | undefined;
+export declare const getRewritePath: <const Path extends string, const Locale extends LocalesValues = ResolvedDefaultLocale>(pathname: Path, locale: Locale, rewrite?: RoutingConfig['rewrite']) => string | undefined;
 //#endregion
-export { InternalPath, LocalizedPathResult, getInternalPath, getRewritePath, resolveLocalizedPath };
 //# sourceMappingURL=rewriteUtils.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"rewriteUtils.d.ts","names":[],"sources":["../../../src/localization/rewriteUtils.ts"],"mappings":";;;;;;;;;;KAgBY,oBAAoB;EAC1B,MAAM;EAAe;;EACrB;EAAc;;;KAGf,iBAAiB,uBAAuB,4BACzC,WACI;;;;;;;;;;;;;;;KAgBI,aACV,qBACA,wCACiB,gBAEf,iBAAiB,qBAAoB,2BACnC,qBAAqB,eAAe,qBAClC,WACA,2BACM,eACA,SAAS;;;;;;;;;;;;;;;cAiBV,6BACL,oCACA,eAAe,gBAAgB,uBAAqB,eAE3C,eAAa,SACnB,QAAM,eACA,iBACd,oBAAoB;;;;;cAkCV,wBACL,2BACA,eAAe,eAAa,eAEnB,MAAI,QACX,WACP,aAAa,MAAM;;;;cAoBT,uBACL,2BACA,eAAe,gBAAgB,uBAAqB,UAEhD,MAAI,QACN,QAAM,UACJ"}
+{"version":3,"file":"rewriteUtils.d.ts","names":[],"sources":["../../../src/localization/rewriteUtils.ts"],"mappings":";;;;;;;;;;YAgBY,oBAAoB;EAC1B,MAAM;EAAe;;EACrB;EAAc;;;KAGf,iBAAiB,uBAAuB,4BACzC,WACI;;;;;;;;;;;;;;;YAgBI,aACV,qBACA,wCACiB,gBAEf,iBAAiB,qBAAoB,2BACnC,qBAAqB,eAAe,qBAClC,WACA,2BACM,eACA,SAAS;;;;;;;;;;;;;;;qBAiBV,6BACL,oCACA,eAAe,gBAAgB,uBAAqB,eAE3C,eAAa,SACnB,QAAM,eACA,iBACd,oBAAoB;;;;;qBAkCV,wBACL,2BACA,eAAe,eAAa,eAEnB,MAAI,QACX,WACP,aAAa,MAAM;;;;qBAoBT,uBACL,2BACA,eAAe,gBAAgB,uBAAqB,UAEhD,MAAI,QACN,QAAM,UACJ"}

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

@@ -1,7 +1,7 @@
 import { RoutingOptions } from "./getPrefix.js";
 import { LocalesValues } from "@intlayer/types/module_augmentation";
 //#region src/localization/validatePrefix.d.ts
-type ValidatePrefixResult = {
+export type ValidatePrefixResult = {
   isValid: boolean;
   localePrefix: string | undefined;
 };
@@ -27,7 +27,6 @@ type ValidatePrefixResult = {
  *   mode: 'prefix-all',
  * });
  */
-declare const validatePrefix: (locale: LocalesValues | undefined | null, options?: RoutingOptions) => ValidatePrefixResult;
+export declare const validatePrefix: (locale: LocalesValues | undefined | null, options?: RoutingOptions) => ValidatePrefixResult;
 //#endregion
-export { ValidatePrefixResult, validatePrefix };
 //# sourceMappingURL=validatePrefix.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"validatePrefix.d.ts","names":[],"sources":["../../../src/localization/validatePrefix.ts"],"mappings":";;;KAyBY;EACV;EACA;;;;;;;;;;;;;;;;;;;;;;;;cAyBW,iBAAc,QACjB,kCAAgC,UAC9B,mBACT"}
+{"version":3,"file":"validatePrefix.d.ts","names":[],"sources":["../../../src/localization/validatePrefix.ts"],"mappings":";;;YAyBY;EACV;EACA;;;;;;;;;;;;;;;;;;;;;;;;qBAyBW,iBAAc,QACjB,kCAAgC,UAC9B,mBACT"}

package/dist/types/markdown/compiler.d.ts

@@ -5,11 +5,11 @@ type FootnoteDef = {
   identifier: string;
 };
 /** Link/image reference definitions (`[id]: target "title"`) collected while parsing. */
-type MarkdownReferences = Record<string, {
+export type MarkdownReferences = Record<string, {
   target: string;
   title?: string;
 }>;
-type ParsedMarkdown = {
+export type ParsedMarkdown = {
   ast: any[];
   footnotes: FootnoteDef[];
   /**
@@ -20,11 +20,10 @@ type ParsedMarkdown = {
   references: MarkdownReferences;
   inline: boolean;
 };
-declare const parseMarkdown: (markdown: string, ctx: MarkdownContext<any>, options?: MarkdownOptions) => ParsedMarkdown;
-declare const renderMarkdownAst: (parsed: ParsedMarkdown, ctx: MarkdownContext<any>, options?: MarkdownOptions) => unknown;
-declare const compile: (markdown: string, ctx: MarkdownContext<any>, options?: MarkdownOptions) => unknown;
-declare const createCompiler: (ctx: MarkdownContext<any>) => (markdown: string, options?: MarkdownOptions) => unknown;
-declare const compileWithOptions: (markdown: string, runtime: MarkdownRuntime, options?: CompileOptions<any>) => unknown;
+export declare const parseMarkdown: (markdown: string, ctx: MarkdownContext<any>, options?: MarkdownOptions) => ParsedMarkdown;
+export declare const renderMarkdownAst: (parsed: ParsedMarkdown, ctx: MarkdownContext<any>, options?: MarkdownOptions) => unknown;
+export declare const compile: (markdown: string, ctx: MarkdownContext<any>, options?: MarkdownOptions) => unknown;
+export declare const createCompiler: (ctx: MarkdownContext<any>) => (markdown: string, options?: MarkdownOptions) => unknown;
+export declare const compileWithOptions: (markdown: string, runtime: MarkdownRuntime, options?: CompileOptions<any>) => unknown;
 //#endregion
-export { MarkdownReferences, ParsedMarkdown, compile, compileWithOptions, createCompiler, parseMarkdown, renderMarkdownAst };
 //# sourceMappingURL=compiler.d.ts.map

package/dist/types/markdown/compiler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compiler.d.ts","names":[],"sources":["../../../src/markdown/compiler.ts"],"mappings":";;KA+GK;EAAgB;EAAkB;;;KAu6B3B,qBAAqB;EAE7B;EAAgB;;KAGR;EACV;EACA,WAAW;;;;;;EAMX,YAAY;EACZ;;cAqPW,gBAAa,kBACR,KACX,sBAAoB,UAChB,oBACR;cAcU,oBAAiB,QACpB,gBAAc,KACjB,sBAAoB,UAChB;cAcE,UAAO,kBACF,KACX,sBAAoB,UAChB;cA8BE,iBAAc,KACnB,0BAAoB,kBACT,UAAY;cAGlB,qBAAkB,kBACb,SACP,iBAAe,UACf"}
+{"version":3,"file":"compiler.d.ts","names":[],"sources":["../../../src/markdown/compiler.ts"],"mappings":";;KA+GK;EAAgB;EAAkB;;;YAu6B3B,qBAAqB;EAE7B;EAAgB;;YAGR;EACV;EACA,WAAW;;;;;;EAMX,YAAY;EACZ;;qBAqPW,gBAAa,kBACR,KACX,sBAAoB,UAChB,oBACR;qBAcU,oBAAiB,QACpB,gBAAc,KACjB,sBAAoB,UAChB;qBAcE,UAAO,kBACF,KACX,sBAAoB,UAChB;qBA8BE,iBAAc,KACnB,0BAAoB,kBACT,UAAY;qBAGlB,qBAAkB,kBACb,SACP,iBAAe,UACf"}