preact-intlayer 9.4.3 → 9.4.4

package/dist/types/IntlayerNode.d.ts

@@ -2,7 +2,7 @@ import { NodeProps } from "@intlayer/core/interpreter";
 import { ResolvedEditor } from "@intlayer/types/module_augmentation";
 import { ComponentChildren, VNode } from "preact";
 //#region src/IntlayerNode.d.ts
-type IntlayerNode<T = NodeProps['children'], AdditionalProps = {}> = ResolvedEditor<T, VNode> & {
+export type IntlayerNode<T = NodeProps['children'], AdditionalProps = {}> = ResolvedEditor<T, VNode> & {
   value: T;
 } & AdditionalProps & T;
 type RenderIntlayerNodeProps<T> = {
@@ -12,7 +12,6 @@ type RenderIntlayerNodeProps<T> = {
     [key: string]: any;
   };
 };
-declare const renderIntlayerNode: <T>({ children, value, additionalProps }: RenderIntlayerNodeProps<T>) => IntlayerNode<T>;
+export declare const renderIntlayerNode: <T>({ children, value, additionalProps }: RenderIntlayerNodeProps<T>) => IntlayerNode<T>;
 //#endregion
-export { IntlayerNode, renderIntlayerNode };
 //# sourceMappingURL=IntlayerNode.d.ts.map

package/dist/types/IntlayerNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"IntlayerNode.d.ts","names":[],"sources":["../../src/IntlayerNode.tsx"],"mappings":";;;;KAUY,aACV,IAAI,uBACJ,wBACE,eAAe,GAAG;EACpB,OAAO;IACL,kBACF;KAEG,wBAAwB;EAC3B,OAAO;EACP,UAAU;EACV;KAAqB;;;cAGV,qBACX,KAAC,UAAA,OAAA,mBAKA,wBAAwB,OAAK,aAAa"}
+{"version":3,"file":"IntlayerNode.d.ts","names":[],"sources":["../../src/IntlayerNode.tsx"],"mappings":";;;;YAUY,aACV,IAAI,uBACJ,wBACE,eAAe,GAAG;EACpB,OAAO;IACL,kBACF;KAEG,wBAAwB;EAC3B,OAAO;EACP,UAAU;EACV;KAAqB;;;qBAGV,qBACX,KAAC,UAAA,OAAA,mBAKA,wBAAwB,OAAK,aAAa"}

package/dist/types/UI/ContentSelector.d.ts

@@ -8,7 +8,6 @@ type ContentSelectorProps = {
   pressDuration?: number;
   isSelecting?: boolean;
 } & Omit<JSX.HTMLAttributes<HTMLDivElement>, 'content'>;
-declare const ContentSelector: FunctionalComponent<ContentSelectorProps>;
+export declare const ContentSelector: FunctionalComponent<ContentSelectorProps>;
 //#endregion
-export { ContentSelector };
 //# sourceMappingURL=ContentSelector.d.ts.map

package/dist/types/UI/ContentSelector.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ContentSelector.d.ts","names":[],"sources":["../../../src/UI/ContentSelector.tsx"],"mappings":";;KAKK;EACH;EACA;EACA;EACA;EACA;EACA;IACE,KAAK,IAAI,eAAe;cAEf,iBAAiB,oBAAoB"}
+{"version":3,"file":"ContentSelector.d.ts","names":[],"sources":["../../../src/UI/ContentSelector.tsx"],"mappings":";;KAKK;EACH;EACA;EACA;EACA;EACA;EACA;IACE,KAAK,IAAI,eAAe;qBAEf,iBAAiB,oBAAoB"}

package/dist/types/analytics/AnalyticsProvider.d.ts

@@ -4,9 +4,8 @@ import { ComponentChildren, FunctionComponent } from "preact";
  * Runs {@link useAnalytics} and renders its children unchanged. Mounted inside
  * {@link IntlayerProvider} alongside `EditorProvider`.
  */
-declare const AnalyticsProvider: FunctionComponent<{
+export declare const AnalyticsProvider: FunctionComponent<{
   children?: ComponentChildren;
 }>;
 //#endregion
-export { AnalyticsProvider };
 //# sourceMappingURL=AnalyticsProvider.d.ts.map

package/dist/types/analytics/AnalyticsProvider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AnalyticsProvider.d.ts","names":[],"sources":["../../../src/analytics/AnalyticsProvider.tsx"],"mappings":";;;;;;cAOa,mBAAmB;EAC9B,WAAW"}
+{"version":3,"file":"AnalyticsProvider.d.ts","names":[],"sources":["../../../src/analytics/AnalyticsProvider.tsx"],"mappings":";;;;;;qBAOa,mBAAmB;EAC9B,WAAW"}

package/dist/types/analytics/exposureSink.d.ts

@@ -5,28 +5,27 @@ import { KeyPath } from "@intlayer/types/keyPath";
  * only) so the interpreter hot path in `plugins.tsx` never statically imports
  * `@intlayer/analytics` — the package stays optional and tree-shakeable.
  */
-type ExposureInput = {
+export type ExposureInput = {
   dictionaryKey: string;
   keyPath: KeyPath[];
   locale?: string;
   nodeType?: string;
 };
 /** Consumer of exposure reports, installed by `useAnalytics` after init. */
-type ExposureSink = (input: ExposureInput) => void;
+export type ExposureSink = (input: ExposureInput) => void;
 /**
  * Installs (or clears) the exposure sink. `useAnalytics` sets this once the
  * analytics client has loaded, and clears it on unmount.
  *
  * @param next - The sink to install, or `null` to clear.
  */
-declare const setExposureSink: (next: ExposureSink | null) => void;
+export declare const setExposureSink: (next: ExposureSink | null) => void;
 /**
  * Forwards a content exposure to the installed sink. A cheap null-check when
  * analytics is not running, so it is safe to call from every node resolution.
  *
  * @param input - The node metadata to report.
  */
-declare const reportExposure: (input: ExposureInput) => void;
+export declare const reportExposure: (input: ExposureInput) => void;
 //#endregion
-export { ExposureInput, ExposureSink, reportExposure, setExposureSink };
 //# sourceMappingURL=exposureSink.d.ts.map

package/dist/types/analytics/exposureSink.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"exposureSink.d.ts","names":[],"sources":["../../../src/analytics/exposureSink.ts"],"mappings":";;;;;;;KAOY;EACV;EACA,SAAS;EACT;EACA;;;KAIU,gBAAgB,OAAO;;;;;;;cAUtB,kBAAe,MAAU;;;;;;;cAUzB,iBAAc,OAAW"}
+{"version":3,"file":"exposureSink.d.ts","names":[],"sources":["../../../src/analytics/exposureSink.ts"],"mappings":";;;;;;;YAOY;EACV;EACA,SAAS;EACT;EACA;;;YAIU,gBAAgB,OAAO;;;;;;;qBAUtB,kBAAe,MAAU;;;;;;;qBAUzB,iBAAc,OAAW"}

package/dist/types/analytics/useAnalytics.d.ts

@@ -9,7 +9,6 @@
  * guarded by `INTLAYER_ANALYTICS_ENABLED` and dead-code-eliminated at build
  * time.
  */
-declare const useAnalytics: () => void;
+export declare const useAnalytics: () => void;
 //#endregion
-export { useAnalytics };
 //# sourceMappingURL=useAnalytics.d.ts.map

package/dist/types/analytics/useAnalytics.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useAnalytics.d.ts","names":[],"sources":["../../../src/analytics/useAnalytics.tsx"],"mappings":";;;;;;;;;;;cAgBa"}
+{"version":3,"file":"useAnalytics.d.ts","names":[],"sources":["../../../src/analytics/useAnalytics.tsx"],"mappings":";;;;;;;;;;;qBAgBa"}

package/dist/types/analytics/useConversion.d.ts

@@ -2,7 +2,7 @@
 /**
  * Parameters describing a conversion to record.
  */
-type ConversionParams = {
+export type ConversionParams = {
   /** The experiment this conversion is attributed to. */
   experimentKey: string;
   /** The variant the session was assigned. */
@@ -25,7 +25,6 @@ type ConversionParams = {
  * })}>Get started</button>
  * ```
  */
-declare const useConversion: () => (params: ConversionParams) => void;
+export declare const useConversion: () => (params: ConversionParams) => void;
 //#endregion
-export { ConversionParams, useConversion };
 //# sourceMappingURL=useConversion.d.ts.map

package/dist/types/analytics/useConversion.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useConversion.d.ts","names":[],"sources":["../../../src/analytics/useConversion.ts"],"mappings":";;;;KAMY;;EAEV;;EAEA;;EAEA;;EAEA;;;;;;;;;;;;;;;cAgBW,sBAAa,QACI"}
+{"version":3,"file":"useConversion.d.ts","names":[],"sources":["../../../src/analytics/useConversion.ts"],"mappings":";;;;YAMY;;EAEV;;EAEA;;EAEA;;EAEA;;;;;;;;;;;;;;;qBAgBW,sBAAa,QACI"}

package/dist/types/analytics/useExperiment.d.ts

@@ -2,7 +2,7 @@
 /**
  * The state of an A/B experiment for the current session.
  */
-type ExperimentState = {
+export type ExperimentState = {
   /**
    * The variant assigned to this session. Until assignment resolves (and on
    * the server, or when analytics is disabled), this is the first variant —
@@ -35,7 +35,6 @@ type ExperimentState = {
  * const content = useIntlayer(variant === 'b' ? 'hero-b' : 'hero');
  * ```
  */
-declare const useExperiment: (experimentKey: string, variants: string[], weights?: number[]) => ExperimentState;
+export declare const useExperiment: (experimentKey: string, variants: string[], weights?: number[]) => ExperimentState;
 //#endregion
-export { ExperimentState, useExperiment };
 //# sourceMappingURL=useExperiment.d.ts.map

package/dist/types/analytics/useExperiment.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useExperiment.d.ts","names":[],"sources":["../../../src/analytics/useExperiment.ts"],"mappings":";;;;KAMY;;;;;;EAMV;;;;;;EAMA;;;;;;;;;;;;;;;;;;;;;cAsBW,gBAAa,uBACH,oBACH,uBAEjB"}
+{"version":3,"file":"useExperiment.d.ts","names":[],"sources":["../../../src/analytics/useExperiment.ts"],"mappings":";;;;YAMY;;;;;;EAMV;;;;;;EAMA;;;;;;;;;;;;;;;;;;;;;qBAsBW,gBAAa,uBACH,oBACH,uBAEjB"}

package/dist/types/client/IntlayerProvider.d.ts

@@ -14,12 +14,12 @@ type IntlayerValue = {
 /**
  * Context that store the current locale on the client side
  */
-declare const IntlayerClientContext: import("preact").Context<IntlayerValue>;
+export declare const IntlayerClientContext: import("preact").Context<IntlayerValue>;
 /**
  * Hook that provides the current locale
  */
-declare const useIntlayerContext: () => {};
-type IntlayerProviderProps = {
+export declare const useIntlayerContext: () => {};
+export type IntlayerProviderProps = {
   children?: ComponentChild;
   locale?: LocalesValues;
   defaultLocale?: LocalesValues;
@@ -47,7 +47,7 @@ type IntlayerProviderProps = {
 /**
  * Provider that store the current locale on the client side
  */
-declare const IntlayerProviderContent: FunctionComponent<IntlayerProviderProps>;
+export declare const IntlayerProviderContent: FunctionComponent<IntlayerProviderProps>;
 /**
  * Main provider for Intlayer in Preact applications.
  *
@@ -68,7 +68,6 @@ declare const IntlayerProviderContent: FunctionComponent<IntlayerProviderProps>;
  * );
  * ```
  */
-declare const IntlayerProvider: FunctionComponent<IntlayerProviderProps>;
+export declare const IntlayerProvider: FunctionComponent<IntlayerProviderProps>;
 //#endregion
-export { IntlayerClientContext, IntlayerProvider, IntlayerProviderContent, IntlayerProviderProps, useIntlayerContext };
 //# sourceMappingURL=IntlayerProvider.d.ts.map

package/dist/types/client/IntlayerProvider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"IntlayerProvider.d.ts","names":[],"sources":["../../../src/client/IntlayerProvider.tsx"],"mappings":";;;KAiBK;EACH,QAAQ;EACR,YAAY,WAAW;;;;;EAKvB,UAAU;EACV;;;;;cAMW,wCAAqB,QAAA;;;;cAQrB;KAED;EACV,WAAW;EACX,SAAS;EACT,gBAAgB;;;;;;;;;;;;;;;;;;EAkBhB,UAAU;EACV,aAAa,QAAQ;EACrB;;;;;cAMW,yBAAyB,kBACpC;;;;;;;;;;;;;;;;;;;;;cA+EW,kBAAkB,kBAAkB"}
+{"version":3,"file":"IntlayerProvider.d.ts","names":[],"sources":["../../../src/client/IntlayerProvider.tsx"],"mappings":";;;KAiBK;EACH,QAAQ;EACR,YAAY,WAAW;;;;;EAKvB,UAAU;EACV;;;;;qBAMW,wCAAqB,QAAA;;;;qBAQrB;YAED;EACV,WAAW;EACX,SAAS;EACT,gBAAgB;;;;;;;;;;;;;;;;;;EAkBhB,UAAU;EACV,aAAa,QAAQ;EACrB;;;;;qBAMW,yBAAyB,kBACpC;;;;;;;;;;;;;;;;;;;;;qBA+EW,kBAAkB,kBAAkB"}

package/dist/types/client/t.d.ts

@@ -6,7 +6,6 @@ import { Locale } from "@intlayer/types/allLocales";
  *
  * If the locale is not provided, it will use the locale from the client context
  */
-declare const t: <Content = string>(multilangContent: StrictModeLocaleMap<Content>, locale?: Locale) => Content;
+export declare const t: <Content = string>(multilangContent: StrictModeLocaleMap<Content>, locale?: Locale) => Content;
 //#endregion
-export { t };
 //# sourceMappingURL=t.d.ts.map

package/dist/types/client/t.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"t.d.ts","names":[],"sources":["../../../src/client/t.ts"],"mappings":";;;;;;;;cAWa,IAAK,kBAAgB,kBACd,oBAAoB,UAAQ,SACrC,WAAM"}
+{"version":3,"file":"t.d.ts","names":[],"sources":["../../../src/client/t.ts"],"mappings":";;;;;;;;qBAWa,IAAK,kBAAgB,kBACd,oBAAoB,UAAQ,SACrC,WAAM"}

package/dist/types/client/useContent.d.ts

@@ -1,15 +1,13 @@
-import { LocalesValues as LocalesValues$1 } from "../intlayer/dist/types/index.js";
 import { useTranslation } from "./useTraduction.js";
 import { StrictModeLocaleMap } from "@intlayer/types/module_augmentation";
 //#region src/client/useContent.d.ts
 /**
  * On the client side, hook to get the translation content based on the locale
  */
-declare const useContent: <Content>(languageContent: StrictModeLocaleMap<Content>) => {
-  locale: LocalesValues$1;
+export declare const useContent: <Content>(languageContent: StrictModeLocaleMap<Content>) => {
+  locale: import("@intlayer/types").LocalesValues;
   content: Content;
   t: typeof useTranslation;
 };
 //#endregion
-export { useContent };
 //# sourceMappingURL=useContent.d.ts.map

package/dist/types/client/useContent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useContent.d.ts","names":[],"sources":["../../../src/client/useContent.ts"],"mappings":";;;;;;;cAOa,aAAc,SAAO,iBACf,oBAAoB;UAApB"}
+{"version":3,"file":"useContent.d.ts","names":[],"sources":["../../../src/client/useContent.ts"],"mappings":";;;;;;qBAOa,aAAc,SAAO,iBACf,oBAAoB"}

package/dist/types/client/useDictionary.d.ts

@@ -9,7 +9,6 @@ import { Dictionary, DictionarySelectorForGroup, QualifiedDictionaryGroup } from
  * If the locale is not provided (directly or through the selector), it will use
  * the locale from the client context.
  */
-declare const useDictionary: <const T extends Dictionary | QualifiedDictionaryGroup, const A extends LocalesValues | DictionarySelectorForGroup<T> = DeclaredLocales>(dictionary: T, localeOrSelector?: A) => import("@intlayer/core/interpreter").DeepTransformContent<import("@intlayer/types").ResolveQualifiedDictionaryContent<T, A>, IInterpreterPluginState, import("@intlayer/types").ExtractSelectorLocale<A>>;
+export declare const useDictionary: <const T extends Dictionary | QualifiedDictionaryGroup, const A extends LocalesValues | DictionarySelectorForGroup<T> = DeclaredLocales>(dictionary: T, localeOrSelector?: A) => import("@intlayer/core/interpreter").DeepTransformContent<import("@intlayer/types").ResolveQualifiedDictionaryContent<T, A>, IInterpreterPluginState, import("@intlayer/types").ExtractSelectorLocale<A>>;
 //#endregion
-export { useDictionary };
 //# sourceMappingURL=useDictionary.d.ts.map

package/dist/types/client/useDictionary.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useDictionary.d.ts","names":[],"sources":["../../../src/client/useDictionary.ts"],"mappings":";;;;;;;;;;;cAwBa,sBACL,UAAU,aAAa,gCACvB,UACF,gBACA,2BAA2B,KAAK,iBAAe,YAEvC,GAAC,mBACM,2CAAC,+CAAA,kCAAA,GAAA,IAAA,mDAAA,sBAAA"}
+{"version":3,"file":"useDictionary.d.ts","names":[],"sources":["../../../src/client/useDictionary.ts"],"mappings":";;;;;;;;;;;qBAwBa,sBACL,UAAU,aAAa,gCACvB,UACF,gBACA,2BAA2B,KAAK,iBAAe,YAEvC,GAAC,mBACM,2CAAC,+CAAA,kCAAA,GAAA,IAAA,mDAAA,sBAAA"}

package/dist/types/client/useDictionaryAsync.d.ts

@@ -6,7 +6,6 @@ import { Dictionary } from "@intlayer/types/dictionary";
  *
  * If the locale is not provided, it will use the locale from the client context
  */
-declare const useDictionaryAsync: <const T extends Dictionary>(dictionaryPromise: StrictModeLocaleMap<() => Promise<T>>, locale?: LocalesValues) => Promise<T>;
+export declare const useDictionaryAsync: <const T extends Dictionary>(dictionaryPromise: StrictModeLocaleMap<() => Promise<T>>, locale?: LocalesValues) => Promise<T>;
 //#endregion
-export { useDictionaryAsync };
 //# sourceMappingURL=useDictionaryAsync.d.ts.map

package/dist/types/client/useDictionaryAsync.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useDictionaryAsync.d.ts","names":[],"sources":["../../../src/client/useDictionaryAsync.ts"],"mappings":";;;;;;;;cAea,2BAAkC,UAAU,YAAU,mBAC9C,0BAA0B,QAAQ,KAAG,SAC/C,kBACR,QAAQ"}
+{"version":3,"file":"useDictionaryAsync.d.ts","names":[],"sources":["../../../src/client/useDictionaryAsync.ts"],"mappings":";;;;;;;;qBAea,2BAAkC,UAAU,YAAU,mBAC9C,0BAA0B,QAAQ,KAAG,SAC/C,kBACR,QAAQ"}

package/dist/types/client/useDictionaryDynamic.d.ts

@@ -13,7 +13,6 @@ import { QualifiedDynamicLoaderMap } from "@intlayer/core/dictionaryManipulator"
  * If the locale is not provided (directly or through the selector), the client
  * context locale is used.
  */
-declare const useDictionaryDynamic: <const T extends Dictionary, const K extends DictionaryKeys, const A extends LocalesValues | DictionarySelectorForKey<K> = DeclaredLocales>(dictionaryPromise: StrictModeLocaleMap<() => Promise<T>> | QualifiedDynamicLoaderMap, key: K, localeOrSelector?: A) => any;
+export declare const useDictionaryDynamic: <const T extends Dictionary, const K extends DictionaryKeys, const A extends LocalesValues | DictionarySelectorForKey<K> = DeclaredLocales>(dictionaryPromise: StrictModeLocaleMap<() => Promise<T>> | QualifiedDynamicLoaderMap, key: K, localeOrSelector?: A) => any;
 //#endregion
-export { useDictionaryDynamic };
 //# sourceMappingURL=useDictionaryDynamic.d.ts.map

package/dist/types/client/useDictionaryDynamic.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useDictionaryDynamic.d.ts","names":[],"sources":["../../../src/client/useDictionaryDynamic.ts"],"mappings":";;;;;;;;;;;;;;;cAmCa,6BACL,UAAU,kBACV,UAAU,sBACV,UAAU,gBAAgB,yBAAyB,KAAK,iBAAe,mBAGzE,0BAA0B,QAAQ,MAClC,2BAAyB,KACxB,GAAC,mBACa"}
+{"version":3,"file":"useDictionaryDynamic.d.ts","names":[],"sources":["../../../src/client/useDictionaryDynamic.ts"],"mappings":";;;;;;;;;;;;;;;qBAmCa,6BACL,UAAU,kBACV,UAAU,sBACV,UAAU,gBAAgB,yBAAyB,KAAK,iBAAe,mBAGzE,0BAA0B,QAAQ,MAClC,2BAAyB,KACxB,GAAC,mBACa"}

package/dist/types/client/useIntlayer.d.ts

@@ -25,7 +25,6 @@ import { DeclaredLocales, DictionaryKeys, DictionarySelectorForKey, LocalesValue
  * };
  * ```
  */
-declare const useIntlayer: <const T extends DictionaryKeys, const A extends LocalesValues | DictionarySelectorForKey<T> = DeclaredLocales>(key: T, localeOrSelector?: A) => import("@intlayer/core/interpreter").DeepTransformContent<import("@intlayer/types").DictionaryRegistryResult<T, A>, IInterpreterPluginState, import("@intlayer/types").ExtractSelectorLocale<A>>;
+export declare const useIntlayer: <const T extends DictionaryKeys, const A extends LocalesValues | DictionarySelectorForKey<T> = DeclaredLocales>(key: T, localeOrSelector?: A) => import("@intlayer/core/interpreter").DeepTransformContent<import("@intlayer/types").DictionaryRegistryResult<T, A>, IInterpreterPluginState, import("@intlayer/types").ExtractSelectorLocale<A>>;
 //#endregion
-export { useIntlayer };
 //# sourceMappingURL=useIntlayer.d.ts.map

package/dist/types/client/useIntlayer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useIntlayer.d.ts","names":[],"sources":["../../../src/client/useIntlayer.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;cAsCa,oBACL,UAAU,sBACV,UAAU,gBAAgB,yBAAyB,KAAK,iBAAe,KAExE,GAAC,mBACa,2CAAC,+CAAA,yBAAA,GAAA,IAAA,mDAAA,sBAAA"}
+{"version":3,"file":"useIntlayer.d.ts","names":[],"sources":["../../../src/client/useIntlayer.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;qBAsCa,oBACL,UAAU,sBACV,UAAU,gBAAgB,yBAAyB,KAAK,iBAAe,KAExE,GAAC,mBACa,2CAAC,+CAAA,yBAAA,GAAA,IAAA,mDAAA,sBAAA"}

package/dist/types/client/useLoadDynamic.d.ts

@@ -1,5 +1,4 @@
 //#region src/client/useLoadDynamic.d.ts
-declare const useLoadDynamic: <T>(key: string, promise: Promise<T>) => T;
+export declare const useLoadDynamic: <T>(key: string, promise: Promise<T>) => T;
 //#endregion
-export { useLoadDynamic };
 //# sourceMappingURL=useLoadDynamic.d.ts.map

package/dist/types/client/useLoadDynamic.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useLoadDynamic.d.ts","names":[],"sources":["../../../src/client/useLoadDynamic.ts"],"mappings":";cA2Ba,iBAAkB,GAAC,aAAa,SAAW,QAAQ,OAAK"}
+{"version":3,"file":"useLoadDynamic.d.ts","names":[],"sources":["../../../src/client/useLoadDynamic.ts"],"mappings":";qBA2Ba,iBAAkB,GAAC,aAAa,SAAW,QAAQ,OAAK"}

package/dist/types/client/useLocale.d.ts

@@ -33,7 +33,6 @@ type UseLocaleResult = {
  * };
  * ```
  */
-declare const useLocale: ({ isCookieEnabled, onLocaleChange }?: UseLocaleProps) => UseLocaleResult;
+export declare const useLocale: ({ isCookieEnabled, onLocaleChange }?: UseLocaleProps) => UseLocaleResult;
 //#endregion
-export { useLocale };
 //# sourceMappingURL=useLocale.d.ts.map

package/dist/types/client/useLocale.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useLocale.d.ts","names":[],"sources":["../../../src/client/useLocale.ts"],"mappings":";;KASK;EACH;EACA,kBAAkB,QAAQ;;KAGvB;EACH,QAAQ;EACR,eAAe;EACf,kBAAkB;EAClB,YAAY,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;cA0BT,cAAS,iBAAA,mBAGnB,mBAAsB"}
+{"version":3,"file":"useLocale.d.ts","names":[],"sources":["../../../src/client/useLocale.ts"],"mappings":";;KASK;EACH;EACA,kBAAkB,QAAQ;;KAGvB;EACH,QAAQ;EACR,eAAe;EACf,kBAAkB;EAClB,YAAY,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;qBA0BT,cAAS,iBAAA,mBAGnB,mBAAsB"}

package/dist/types/client/useLocaleBase.d.ts

@@ -1,14 +1,12 @@
-import { LocalesValues } from "../intlayer/dist/types/index.js";
 //#region src/client/useLocaleBase.d.ts
 /**
  * On the client side, hook to get the current locale and all related fields
  */
-declare const useLocaleBase: () => {
-  locale: LocalesValues;
+export declare const useLocaleBase: () => {
+  locale: import("@intlayer/types").LocalesValues;
   defaultLocale: any;
   availableLocales: any;
-  setLocale: (newLocale: LocalesValues) => void;
+  setLocale: (newLocale: import("@intlayer/types").LocalesValues) => void;
 };
 //#endregion
-export { useLocaleBase };
 //# sourceMappingURL=useLocaleBase.d.ts.map

package/dist/types/client/useLocaleBase.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useLocaleBase.d.ts","names":[],"sources":["../../../src/client/useLocaleBase.ts"],"mappings":";;;;;cASa;UAAA;;;yBAAA"}
+{"version":3,"file":"useLocaleBase.d.ts","names":[],"sources":["../../../src/client/useLocaleBase.ts"],"mappings":";;;;qBASa"}

package/dist/types/client/useLocaleStorage.d.ts

@@ -1,31 +1,30 @@
-import { Locale } from "../intlayer/dist/types/index.js";
 import { LocalesValues } from "@intlayer/types/module_augmentation";
 //#region src/client/useLocaleStorage.d.ts
 /**
  * Get the locale cookie
  */
-declare const localeInStorage: Locale;
+export declare const localeInStorage: import("@intlayer/types").Locale;
 /**
  * @deprecated Use localeInStorage instead
  *
  * Get the locale cookie
  */
-declare const localeCookie: Locale;
+export declare const localeCookie: import("@intlayer/types").Locale;
 /**
  * Set the locale cookie
  */
-declare const setLocaleInStorage: (locale: LocalesValues, isCookieEnabled: boolean) => void;
+export declare const setLocaleInStorage: (locale: LocalesValues, isCookieEnabled: boolean) => void;
 /**
  * @deprecated Use setLocaleInStorage instead
  *
  * Set the locale cookie
  */
-declare const setLocaleCookie: typeof setLocaleInStorage;
+export declare const setLocaleCookie: typeof setLocaleInStorage;
 /**
  * Hook that provides the locale storage and a function to set it
  */
-declare const useLocaleStorage: (isCookieEnabled?: boolean) => {
-  getLocale: () => Locale;
+export declare const useLocaleStorage: (isCookieEnabled?: boolean) => {
+  getLocale: () => import("@intlayer/types").Locale;
   setLocale: (locale: LocalesValues) => void;
 };
 /**
@@ -35,7 +34,6 @@ declare const useLocaleStorage: (isCookieEnabled?: boolean) => {
  *
  * Hook that provides the locale cookie and a function to set it
  */
-declare const useLocaleCookie: typeof useLocaleStorage;
+export declare const useLocaleCookie: typeof useLocaleStorage;
 //#endregion
-export { localeCookie, localeInStorage, setLocaleCookie, setLocaleInStorage, useLocaleCookie, useLocaleStorage };
 //# sourceMappingURL=useLocaleStorage.d.ts.map

package/dist/types/client/useLocaleStorage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useLocaleStorage.d.ts","names":[],"sources":["../../../src/client/useLocaleStorage.ts"],"mappings":";;;;;;cAYa,iBAAA;;;;;;cAMA,cAAA;;;;cAKA,qBAAkB,QACrB,eAAa;;;;;;cAaV,wBAAe;;;;cAKf,mBAAgB;mBAAhB;sBAAA;;;;;;;;;cAiBA,wBAAe"}
+{"version":3,"file":"useLocaleStorage.d.ts","names":[],"sources":["../../../src/client/useLocaleStorage.ts"],"mappings":";;;;;qBAYa,2CAAe;;;;;;qBAMf,wCAAY;;;;qBAKZ,qBAAkB,QACrB,eAAa;;;;;;qBAaV,wBAAe;;;;qBAKf,mBAAgB;;sBAAhB;;;;;;;;;qBAiBA,wBAAe"}

package/dist/types/client/usePathname.d.ts

@@ -17,7 +17,6 @@
  * };
  * ```
  */
-declare const usePathname: () => string;
+export declare const usePathname: () => string;
 //#endregion
-export { usePathname };
 //# sourceMappingURL=usePathname.d.ts.map

package/dist/types/client/usePathname.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"usePathname.d.ts","names":[],"sources":["../../../src/client/usePathname.ts"],"mappings":";;;;;;;;;;;;;;;;;;;cAqBa"}
+{"version":3,"file":"usePathname.d.ts","names":[],"sources":["../../../src/client/usePathname.ts"],"mappings":";;;;;;;;;;;;;;;;;;;qBAqBa"}

package/dist/types/client/useTraduction.d.ts

@@ -21,7 +21,6 @@ import { StrictModeLocaleMap } from "@intlayer/types/module_augmentation";
  * - this function will require each locale to be defined if defined in the project configuration.
  * - If a locale is missing, it will make each existing locale optional and raise an error if the locale is not found.
  */
-declare const useTranslation: <Content = string>(languageContent: StrictModeLocaleMap<Content>) => Content;
+export declare const useTranslation: <Content = string>(languageContent: StrictModeLocaleMap<Content>) => Content;
 //#endregion
-export { useTranslation };
 //# sourceMappingURL=useTraduction.d.ts.map

package/dist/types/client/useTraduction.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useTraduction.d.ts","names":[],"sources":["../../../src/client/useTraduction.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;cA0Ba,iBAAkB,kBAAgB,iBAC5B,oBAAoB,aACpC"}
+{"version":3,"file":"useTraduction.d.ts","names":[],"sources":["../../../src/client/useTraduction.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;qBA0Ba,iBAAkB,kBAAgB,iBAC5B,oBAAoB,aACpC"}

package/dist/types/editor/ContentSelector.d.ts

@@ -11,8 +11,7 @@ declare module 'preact' {
     }
   }
 }
-type ContentSelectorWrapperProps = NodeProps & Omit<HTMLAttributes<HTMLDivElement>, 'children'>;
-declare const ContentSelector: FunctionalComponent<ContentSelectorWrapperProps>;
+export type ContentSelectorWrapperProps = NodeProps & Omit<HTMLAttributes<HTMLDivElement>, 'children'>;
+export declare const ContentSelector: FunctionalComponent<ContentSelectorWrapperProps>;
 //#endregion
-export { ContentSelector, ContentSelectorWrapperProps };
 //# sourceMappingURL=ContentSelector.d.ts.map

package/dist/types/editor/ContentSelector.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ContentSelector.d.ts","names":[],"sources":["../../../src/editor/ContentSelector.tsx"],"mappings":";;;;YAOY;cACE;MACR,qCAAqC,eAAe;QAClD;QACA;;;;;KAMI,8BAA8B,YACxC,KAAK,eAAe;cAET,iBAAiB,oBAC5B"}
+{"version":3,"file":"ContentSelector.d.ts","names":[],"sources":["../../../src/editor/ContentSelector.tsx"],"mappings":";;;;YAOY;cACE;MACR,qCAAqC,eAAe;QAClD;QACA;;;;;YAMI,8BAA8B,YACxC,KAAK,eAAe;qBAET,iBAAiB,oBAC5B"}

package/dist/types/editor/EditorProvider.d.ts

@@ -1,8 +1,7 @@
 import { ComponentChild, FunctionComponent } from "preact";
 //#region src/editor/EditorProvider.d.ts
-declare const EditorProvider: FunctionComponent<{
+export declare const EditorProvider: FunctionComponent<{
   children?: ComponentChild;
 }>;
 //#endregion
-export { EditorProvider };
 //# sourceMappingURL=EditorProvider.d.ts.map

package/dist/types/editor/EditorProvider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"EditorProvider.d.ts","names":[],"sources":["../../../src/editor/EditorProvider.tsx"],"mappings":";;cAGa,gBAAgB;EAC3B,WAAW"}
+{"version":3,"file":"EditorProvider.d.ts","names":[],"sources":["../../../src/editor/EditorProvider.tsx"],"mappings":";;qBAGa,gBAAgB;EAC3B,WAAW"}

package/dist/types/editor/useEditor.d.ts

@@ -4,7 +4,6 @@
  * Syncs the current locale from the Intlayer context into the editor manager so
  * the editor always knows which locale the app is displaying.
  */
-declare const useEditor: () => void;
+export declare const useEditor: () => void;
 //#endregion
-export { useEditor };
 //# sourceMappingURL=useEditor.d.ts.map

package/dist/types/editor/useEditor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useEditor.d.ts","names":[],"sources":["../../../src/editor/useEditor.tsx"],"mappings":";;;;;;cAWa"}
+{"version":3,"file":"useEditor.d.ts","names":[],"sources":["../../../src/editor/useEditor.tsx"],"mappings":";;;;;;qBAWa"}

package/dist/types/format/useCompact.d.ts

@@ -1,4 +1,3 @@
-import { LocalesValues } from "../intlayer/dist/types/index.js";
 //#region src/format/useCompact.d.ts
 /**
  * React client hook that provides a compact number formatter
@@ -10,9 +9,8 @@ import { LocalesValues } from "../intlayer/dist/types/index.js";
  * formatCompact(1500); // "1.5K"
  * ```
  */
-declare const useCompact: () => (value: string | number, options?: Intl.NumberFormatOptions & {
-  locale?: LocalesValues;
+export declare const useCompact: () => (value: string | number, options?: Intl.NumberFormatOptions & {
+  locale?: import("@intlayer/types").LocalesValues;
 }) => string;
 //#endregion
-export { useCompact };
 //# sourceMappingURL=useCompact.d.ts.map

package/dist/types/format/useCompact.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useCompact.d.ts","names":[],"sources":["../../../src/format/useCompact.ts"],"mappings":";;;;;;;;;;;;cAca,mBAAU,wBAAA,UAAA,KAAA;WAAA"}
+{"version":3,"file":"useCompact.d.ts","names":[],"sources":["../../../src/format/useCompact.ts"],"mappings":";;;;;;;;;;;qBAca,mBAAU,wBAAA,UAAA,KAAA"}

package/dist/types/format/useCurrency.d.ts

@@ -1,4 +1,3 @@
-import { LocalesValues } from "../intlayer/dist/types/index.js";
 //#region src/format/useCurrency.d.ts
 /**
  * React client hook that provides a currency formatter
@@ -24,9 +23,8 @@ import { LocalesValues } from "../intlayer/dist/types/index.js";
  * // "¥9,876,543"
  * ```
  */
-declare const useCurrency: () => (value: string | number, options?: Intl.NumberFormatOptions & {
-  locale?: LocalesValues;
+export declare const useCurrency: () => (value: string | number, options?: Intl.NumberFormatOptions & {
+  locale?: import("@intlayer/types").LocalesValues;
 }) => string;
 //#endregion
-export { useCurrency };
 //# sourceMappingURL=useCurrency.d.ts.map

package/dist/types/format/useCurrency.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useCurrency.d.ts","names":[],"sources":["../../../src/format/useCurrency.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;cA4Ba,oBAAW,wBAAA,UAAA,KAAA;WAAA"}
+{"version":3,"file":"useCurrency.d.ts","names":[],"sources":["../../../src/format/useCurrency.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;qBA4Ba,oBAAW,wBAAA,UAAA,KAAA"}

package/dist/types/format/useDate.d.ts

@@ -26,7 +26,6 @@ import { date } from "@intlayer/core/formatters";
  *
  * @see createDate
  */
-declare const useDate: () => (...args: Parameters<typeof date>) => string;
+export declare const useDate: () => (...args: Parameters<typeof date>) => string;
 //#endregion
-export { useDate };
 //# sourceMappingURL=useDate.d.ts.map

package/dist/types/format/useDate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useDate.d.ts","names":[],"sources":["../../../src/format/useDate.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;cA8Ba,mBAAO,MAGD,kBAAkB"}
+{"version":3,"file":"useDate.d.ts","names":[],"sources":["../../../src/format/useDate.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA8Ba,mBAAO,MAGD,kBAAkB"}

package/dist/types/format/useIntl.d.ts

@@ -19,7 +19,6 @@ import { WrappedIntl } from "@intlayer/core/formatters";
  * }).format(123.45);
  * ```
  */
-declare const useIntl: (locale?: LocalesValues) => WrappedIntl;
+export declare const useIntl: (locale?: LocalesValues) => WrappedIntl;
 //#endregion
-export { useIntl };
 //# sourceMappingURL=useIntl.d.ts.map

package/dist/types/format/useIntl.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useIntl.d.ts","names":[],"sources":["../../../src/format/useIntl.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;cAuBa,UAAO,SAAa,kBAAa"}
+{"version":3,"file":"useIntl.d.ts","names":[],"sources":["../../../src/format/useIntl.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;qBAuBa,UAAO,SAAa,kBAAa"}

package/dist/types/format/useList.d.ts

@@ -1,4 +1,3 @@
-import { LocalesValues } from "../intlayer/dist/types/index.js";
 //#region src/format/useList.d.ts
 /**
  * React client hook that provides a list formatter
@@ -21,13 +20,8 @@ import { LocalesValues } from "../intlayer/dist/types/index.js";
  * // "1, 2 und 3"
  * ```
  */
-declare const useList: () => (values: (string | number)[], options?: {
-  localeMatcher?: 'lookup' | 'best fit';
-  type?: 'conjunction' | 'disjunction' | 'unit';
-  style?: 'long' | 'short' | 'narrow';
-} & {
-  locale?: LocalesValues;
+export declare const useList: () => (values: (string | number)[], options?: import("@intlayer/core/formatters").ListFormatOptions & {
+  locale?: import("@intlayer/types").LocalesValues;
 }) => string;
 //#endregion
-export { useList };
 //# sourceMappingURL=useList.d.ts.map

package/dist/types/format/useList.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useList.d.ts","names":[],"sources":["../../../src/format/useList.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;cAyBa,gBAAO,6BAAA;;;;;WAAP"}
+{"version":3,"file":"useList.d.ts","names":[],"sources":["../../../src/format/useList.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;qBAyBa,gBAAO,6BAAA,8CAAA"}

package/dist/types/format/useNumber.d.ts

@@ -1,4 +1,3 @@
-import { LocalesValues } from "../intlayer/dist/types/index.js";
 //#region src/format/useNumber.d.ts
 /**
  * React client hook that provides a localized number formatter.
@@ -22,9 +21,8 @@ import { LocalesValues } from "../intlayer/dist/types/index.js";
  * @returns {(value: string | number, options?: import("../createNumber").NumberProps) => string}
  * A number formatting function bound to the active locale.
  */
-declare const useNumber: () => (value: string | number, args_1?: Intl.NumberFormatOptions & {
-  locale?: LocalesValues;
+export declare const useNumber: () => (value: string | number, args_1?: Intl.NumberFormatOptions & {
+  locale?: import("@intlayer/types").LocalesValues;
 }) => string;
 //#endregion
-export { useNumber };
 //# sourceMappingURL=useNumber.d.ts.map