preact-intlayer 9.4.2 → 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

@@ -4,11 +4,10 @@ import { StrictModeLocaleMap } from "@intlayer/types/module_augmentation";
 /**
  * On the client side, hook to get the translation content based on the locale
  */
-declare const useContent: <Content>(languageContent: StrictModeLocaleMap<Content>) => {
+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"}
+{"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

@@ -2,12 +2,11 @@
 /**
  * On the client side, hook to get the current locale and all related fields
  */
-declare const useLocaleBase: () => {
+export declare const useLocaleBase: () => {
   locale: import("@intlayer/types").LocalesValues;
   defaultLocale: any;
   availableLocales: any;
   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"}
+{"version":3,"file":"useLocaleBase.d.ts","names":[],"sources":["../../../src/client/useLocaleBase.ts"],"mappings":";;;;qBASa"}

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

@@ -3,27 +3,27 @@ import { LocalesValues } from "@intlayer/types/module_augmentation";
 /**
  * Get the locale cookie
  */
-declare const localeInStorage: import("@intlayer/types").Locale;
+export declare const localeInStorage: import("@intlayer/types").Locale;
 /**
  * @deprecated Use localeInStorage instead
  *
  * Get the locale cookie
  */
-declare const localeCookie: import("@intlayer/types").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) => {
+export declare const useLocaleStorage: (isCookieEnabled?: boolean) => {
   getLocale: () => import("@intlayer/types").Locale;
   setLocale: (locale: LocalesValues) => void;
 };
@@ -34,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,2CAAe;;;;;;cAMf,wCAAY;;;;cAKZ,qBAAkB,QACrB,eAAa;;;;;;cAaV,wBAAe;;;;cAKf,mBAAgB;;sBAAhB;;;;;;;;;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

@@ -9,9 +9,8 @@
  * formatCompact(1500); // "1.5K"
  * ```
  */
-declare const useCompact: () => (value: string | number, options?: Intl.NumberFormatOptions & {
+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"}
+{"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

@@ -23,9 +23,8 @@
  * // "¥9,876,543"
  * ```
  */
-declare const useCurrency: () => (value: string | number, options?: Intl.NumberFormatOptions & {
+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"}
+{"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

@@ -20,13 +20,8 @@
  * // "1, 2 und 3"
  * ```
  */
-declare const useList: () => (values: (string | number)[], options?: {
-  localeMatcher?: 'lookup' | 'best fit';
-  type?: 'conjunction' | 'disjunction' | 'unit';
-  style?: 'long' | 'short' | 'narrow';
-} & {
+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"}
+{"version":3,"file":"useList.d.ts","names":[],"sources":["../../../src/format/useList.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;qBAyBa,gBAAO,6BAAA,8CAAA"}

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

@@ -21,9 +21,8 @@
  * @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 & {
+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

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

@@ -1 +1 @@
-{"version":3,"file":"useNumber.d.ts","names":[],"sources":["../../../src/format/useNumber.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;cA0Ba,kBAAS,wBAAA,SAAA,KAAA"}
+{"version":3,"file":"useNumber.d.ts","names":[],"sources":["../../../src/format/useNumber.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;qBA0Ba,kBAAS,wBAAA,SAAA,KAAA"}

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

@@ -17,9 +17,8 @@
  * @returns {(value: string | number, options?: Omit<PercentageOptions, "value">) => string}
  * A function that formats numbers or numeric strings into localized percentages.
  */
-declare const usePercentage: () => (value: string | number, args_1?: Intl.NumberFormatOptions & {
+export declare const usePercentage: () => (value: string | number, args_1?: Intl.NumberFormatOptions & {
   locale?: import("@intlayer/types").LocalesValues;
 }) => string;
 //#endregion
-export { usePercentage };
 //# sourceMappingURL=usePercentage.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"usePercentage.d.ts","names":[],"sources":["../../../src/format/usePercentage.ts"],"mappings":";;;;;;;;;;;;;;;;;;;cAsBa,sBAAa,wBAAA,SAAA,KAAA"}
+{"version":3,"file":"usePercentage.d.ts","names":[],"sources":["../../../src/format/usePercentage.ts"],"mappings":";;;;;;;;;;;;;;;;;;;qBAsBa,sBAAa,wBAAA,SAAA,KAAA"}

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

@@ -17,10 +17,9 @@
  * @returns {ReturnType<typeof createRelativeTime>} A relative time formatting function
  *          bound to the current client locale.
  */
-declare const useRelativeTime: () => (from: string | number | Date, to?: string | number | Date, options?: Intl.RelativeTimeFormatOptions & {
+export declare const useRelativeTime: () => (from: string | number | Date, to?: string | number | Date, options?: Intl.RelativeTimeFormatOptions & {
   locale?: import("@intlayer/types").LocalesValues;
   unit?: Intl.RelativeTimeFormatUnit;
 }) => string;
 //#endregion
-export { useRelativeTime };
 //# sourceMappingURL=useRelativeTime.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"useRelativeTime.d.ts","names":[],"sources":["../../../src/format/useRelativeTime.ts"],"mappings":";;;;;;;;;;;;;;;;;;;cAsBa,wBAAe,wBAAA,MAAA,uBAAA,MAAA,UAAA,KAAA"}
+{"version":3,"file":"useRelativeTime.d.ts","names":[],"sources":["../../../src/format/useRelativeTime.ts"],"mappings":";;;;;;;;;;;;;;;;;;;qBAsBa,wBAAe,wBAAA,MAAA,uBAAA,MAAA,UAAA,KAAA"}

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

@@ -16,9 +16,8 @@
  *
  * @returns {Function} A unit formatting function that accepts a value and optional formatting options.
  */
-declare const useUnit: () => (value: string | number, options?: Intl.NumberFormatOptions & {
+export declare const useUnit: () => (value: string | number, options?: Intl.NumberFormatOptions & {
   locale?: import("@intlayer/types").LocalesValues;
 }) => string;
 //#endregion
-export { useUnit };
 //# sourceMappingURL=useUnit.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"useUnit.d.ts","names":[],"sources":["../../../src/format/useUnit.ts"],"mappings":";;;;;;;;;;;;;;;;;;cAqBa,gBAAO,wBAAA,UAAA,KAAA"}
+{"version":3,"file":"useUnit.d.ts","names":[],"sources":["../../../src/format/useUnit.ts"],"mappings":";;;;;;;;;;;;;;;;;;qBAqBa,gBAAO,wBAAA,UAAA,KAAA"}

package/dist/types/getDictionary.d.ts

@@ -7,7 +7,6 @@ import { Dictionary, DictionarySelectorForGroup, QualifiedDictionaryGroup, Resol
  * content for the given locale or selector (`{ item }`, `{ variant }`,
  * optionally combined with `locale`).
  */
-declare const getDictionary: <const T extends Dictionary | QualifiedDictionaryGroup, const A extends LocalesValues | DictionarySelectorForGroup<T> = DeclaredLocales>(dictionary: T, localeOrSelector?: A) => DeepTransformContent<ResolveQualifiedDictionaryContent<T, A>, ExtractSelectorLocale<A>>;
+export declare const getDictionary: <const T extends Dictionary | QualifiedDictionaryGroup, const A extends LocalesValues | DictionarySelectorForGroup<T> = DeclaredLocales>(dictionary: T, localeOrSelector?: A) => DeepTransformContent<ResolveQualifiedDictionaryContent<T, A>, ExtractSelectorLocale<A>>;
 //#endregion
-export { getDictionary };
 //# sourceMappingURL=getDictionary.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"getDictionary.d.ts","names":[],"sources":["../../src/getDictionary.ts"],"mappings":";;;;;;;;;cAmBa,sBACL,UAAU,aAAa,gCACvB,UACF,gBACA,2BAA2B,KAAK,iBAAe,YAEvC,GAAC,mBACM,MAClB,qBACD,kCAAkC,GAAG,IACrC,sBAAsB"}
+{"version":3,"file":"getDictionary.d.ts","names":[],"sources":["../../src/getDictionary.ts"],"mappings":";;;;;;;;;qBAmBa,sBACL,UAAU,aAAa,gCACvB,UACF,gBACA,2BAA2B,KAAK,iBAAe,YAEvC,GAAC,mBACM,MAClB,qBACD,kCAAkC,GAAG,IACrC,sBAAsB"}

package/dist/types/getIntlayer.d.ts

@@ -6,7 +6,6 @@ import { DeclaredLocales, DictionaryKeys, DictionaryRegistryResult, DictionarySe
  * locale or selector (`{ item }`, `{ variant }`,
  * optionally combined with `locale`).
  */
-declare const getIntlayer: <const T extends DictionaryKeys, const A extends LocalesValues | DictionarySelectorForKey<T> = DeclaredLocales>(key: T, localeOrSelector?: A) => DeepTransformContent<DictionaryRegistryResult<T, A>, ExtractSelectorLocale<A>>;
+export declare const getIntlayer: <const T extends DictionaryKeys, const A extends LocalesValues | DictionarySelectorForKey<T> = DeclaredLocales>(key: T, localeOrSelector?: A) => DeepTransformContent<DictionaryRegistryResult<T, A>, ExtractSelectorLocale<A>>;
 //#endregion
-export { getIntlayer };
 //# sourceMappingURL=getIntlayer.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"getIntlayer.d.ts","names":[],"sources":["../../src/getIntlayer.ts"],"mappings":";;;;;;;;cAgBa,oBACL,UAAU,sBACV,UAAU,gBAAgB,yBAAyB,KAAK,iBAAe,KAExE,GAAC,mBACa,MAClB,qBACD,yBAAyB,GAAG,IAC5B,sBAAsB"}
+{"version":3,"file":"getIntlayer.d.ts","names":[],"sources":["../../src/getIntlayer.ts"],"mappings":";;;;;;;;qBAgBa,oBACL,UAAU,sBACV,UAAU,gBAAgB,yBAAyB,KAAK,iBAAe,KAExE,GAAC,mBACa,MAClB,qBACD,yBAAyB,GAAG,IAC5B,sBAAsB"}

package/dist/types/html/HTMLProvider.d.ts

@@ -10,8 +10,7 @@ type HTMLProviderProps = RenderableProps<{
    */
   components?: HTMLComponents<'permissive', {}>;
 }>;
-declare const useHTMLContext: () => HTMLContextValue;
-declare const HTMLProvider: FunctionalComponent<HTMLProviderProps>;
+export declare const useHTMLContext: () => HTMLContextValue;
+export declare const HTMLProvider: FunctionalComponent<HTMLProviderProps>;
 //#endregion
-export { HTMLProvider, useHTMLContext };
 //# sourceMappingURL=HTMLProvider.d.ts.map

package/dist/types/html/HTMLProvider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"HTMLProvider.d.ts","names":[],"sources":["../../../src/html/HTMLProvider.tsx"],"mappings":";;;KAQK;EACH,aAAa;;KAGV,oBAAoB;;;;EAIvB,aAAa;;cAKF,sBAAc;cAEd,cAAc,oBAAoB"}
+{"version":3,"file":"HTMLProvider.d.ts","names":[],"sources":["../../../src/html/HTMLProvider.tsx"],"mappings":";;;KAQK;EACH,aAAa;;KAGV,oBAAoB;;;;EAIvB,aAAa;;qBAKF,sBAAc;qBAEd,cAAc,oBAAoB"}

package/dist/types/html/HTMLRenderer.d.ts

@@ -2,7 +2,7 @@ import { HTMLComponents } from "./types.js";
 import { FunctionComponent, JSX } from "preact";
 import { KeyPath } from "@intlayer/types/keyPath";
 //#region src/html/HTMLRenderer.d.ts
-type RenderHTMLProps = {
+export type RenderHTMLProps = {
   /**
    * Component overrides for HTML tags.
    * Allows you to customize how specific HTML elements are rendered.
@@ -15,15 +15,15 @@ type RenderHTMLProps = {
  * This function does not use context from HTMLProvider. Use `useHTMLRenderer`
  * hook if you want to leverage provider context.
  */
-declare const renderHTML: (content: string, { components }?: RenderHTMLProps) => JSX.Element;
+export declare const renderHTML: (content: string, { components }?: RenderHTMLProps) => JSX.Element;
 /**
  * Hook that returns a function to render HTML content.
  *
  * This hook considers the configuration from the `HTMLProvider` context if available,
  * falling back to the provided components.
  */
-declare const useHTMLRenderer: ({ components }?: RenderHTMLProps) => (content: string) => JSX.Element;
-type HTMLRendererProps = RenderHTMLProps & {
+export declare const useHTMLRenderer: ({ components }?: RenderHTMLProps) => (content: string) => JSX.Element;
+export type HTMLRendererProps = RenderHTMLProps & {
   /**
    * The HTML content to render as a string.
    */
@@ -42,7 +42,6 @@ type HTMLRendererProps = RenderHTMLProps & {
 /**
  * Preact component that renders HTML-like content to JSX.
  */
-declare const HTMLRenderer: FunctionComponent<HTMLRendererProps>;
+export declare const HTMLRenderer: FunctionComponent<HTMLRendererProps>;
 //#endregion
-export { HTMLRenderer, HTMLRendererProps, RenderHTMLProps, renderHTML, useHTMLRenderer };
 //# sourceMappingURL=HTMLRenderer.d.ts.map

package/dist/types/html/HTMLRenderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"HTMLRenderer.d.ts","names":[],"sources":["../../../src/html/HTMLRenderer.tsx"],"mappings":";;;;KAOY;;;;;EAKV,aAAa;;;;;;;;cASF,aAAU,mBACN,eACM,oBACpB,IAAI;;;;;;;cAuCM,oBAAe,eAAoB,qBAAe,oBAGtC,IAAA;KAUb,oBAAoB;;;;EAI9B;;;;EAIA;;;;EAIA,aAAa;EACb;EACA,UAAU;;;;;cAMC,cAAc,kBAAkB"}
+{"version":3,"file":"HTMLRenderer.d.ts","names":[],"sources":["../../../src/html/HTMLRenderer.tsx"],"mappings":";;;;YAOY;;;;;EAKV,aAAa;;;;;;;;qBASF,aAAU,mBACN,eACM,oBACpB,IAAI;;;;;;;qBAuCM,oBAAe,eAAoB,qBAAe,oBAGtC,IAAA;YAUb,oBAAoB;;;;EAI9B;;;;EAIA;;;;EAIA,aAAa;EACb;EACA,UAAU;;;;;qBAMC,cAAc,kBAAkB"}

package/dist/types/html/types.d.ts

@@ -22,16 +22,15 @@ type RestHTMLComponents<T> = { [K in Exclude<keyof HTMLTagsType, keyof T>]?: Fun
 /**
  * The supported modes for the HTMLComponents type.
  */
-type HTMLComponentMode = 'permissive' | 'optional' | 'inclusive' | 'strict';
+export type HTMLComponentMode = 'permissive' | 'optional' | 'inclusive' | 'strict';
 /**
  * The main component definition with Mode support.
  */
-type HTMLComponents<Mode extends HTMLComponentMode = 'optional', T = {}> = Mode extends 'strict' ? DefinedComponents<T, true> : Mode extends 'inclusive' // Inclusive: Keys in T are required. Rest of HTML is optional.
+export type HTMLComponents<Mode extends HTMLComponentMode = 'optional', T = {}> = Mode extends 'strict' ? DefinedComponents<T, true> : Mode extends 'inclusive' // Inclusive: Keys in T are required. Rest of HTML is optional.
  ? DefinedComponents<T, true> & RestHTMLComponents<T> : Mode extends 'permissive' // Permissive: Keys in T optional. Rest of HTML optional. Any other string allowed.
  ? DefinedComponents<T, false> & RestHTMLComponents<T> & {
   [key: string]: FunctionalComponent<JSX.HTMLAttributes<HTMLElement>>;
 } // Optional (Default): Keys in T optional. Rest of HTML optional.
  : DefinedComponents<T, false> & RestHTMLComponents<T>;
 //#endregion
-export { HTMLComponentMode, HTMLComponents };
 //# sourceMappingURL=types.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","names":[],"sources":["../../../src/html/types.ts"],"mappings":";;;;;;KAMK,gBAAgB,SAAS,0BAE1B,uBACE;;;;KAMD,aAAa,KAAK,gBAAgB,IAAI,oBACvC,IAAI,kBAAkB,KACtB,IAAI,eAAe;;;;;KAMlB,kBAAkB,GAAG,8BAA8B,6BAGjD,WAAW,IAAI,oBACd,aAAa,KAAK,gBAAgB,EAAE,aAKrC,WAAW,KAAK,oBACf,aAAa,KAAK,gBAAgB,EAAE;;;;;KAQvC,mBAAmB,QACrB,KAAK,cAAc,oBAAoB,MAAM,oBAC5C,gBAAgB,IAAI,oBAChB,IAAI,kBAAkB,KACtB,IAAI,eAAe;;;;KAOf;;;;KASA,eACV,aAAa,gCACb,UACE,wBAEA,kBAAkB,WAClB;GAEE,kBAAkB,WAAW,mBAAmB,KAChD;GAEE,kBAAkB,YAChB,mBAAmB;GAChB,cAAc,oBAAoB,IAAI,eAAe;;GAG1D,kBAAkB,YAAY,mBAAmB"}
+{"version":3,"file":"types.d.ts","names":[],"sources":["../../../src/html/types.ts"],"mappings":";;;;;;KAMK,gBAAgB,SAAS,0BAE1B,uBACE;;;;KAMD,aAAa,KAAK,gBAAgB,IAAI,oBACvC,IAAI,kBAAkB,KACtB,IAAI,eAAe;;;;;KAMlB,kBAAkB,GAAG,8BAA8B,6BAGjD,WAAW,IAAI,oBACd,aAAa,KAAK,gBAAgB,EAAE,aAKrC,WAAW,KAAK,oBACf,aAAa,KAAK,gBAAgB,EAAE;;;;;KAQvC,mBAAmB,QACrB,KAAK,cAAc,oBAAoB,MAAM,oBAC5C,gBAAgB,IAAI,oBAChB,IAAI,kBAAkB,KACtB,IAAI,eAAe;;;;YAOf;;;;YASA,eACV,aAAa,gCACb,UACE,wBAEA,kBAAkB,WAClB;GAEE,kBAAkB,WAAW,mBAAmB,KAChD;GAEE,kBAAkB,YAChB,mBAAmB;GAChB,cAAc,oBAAoB,IAAI,eAAe;;GAG1D,kBAAkB,YAAY,mBAAmB"}

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

@@ -8,7 +8,7 @@ type PropsWithChildren<P = {}> = P & {
 /**
  * Refined options for the MarkdownProvider.
  */
-type MarkdownProviderOptions = {
+export type MarkdownProviderOptions = {
   /**
    * Forces the compiler to always output content with a block-level wrapper.
    */
@@ -45,8 +45,7 @@ type MarkdownProviderProps = PropsWithChildren<MarkdownProviderOptions & {
    */
   renderMarkdown?: (markdown: string | ParsedMarkdown, options?: MarkdownProviderOptions, components?: HTMLComponents<'permissive', {}>, wrapper?: ComponentType<any> | keyof JSX.IntrinsicElements) => ComponentChildren | Promise<ComponentChildren>;
 }>;
-declare const useMarkdownContext: () => MarkdownContextValue;
-declare const MarkdownProvider: FunctionComponent<MarkdownProviderProps>;
+export declare const useMarkdownContext: () => MarkdownContextValue;
+export declare const MarkdownProvider: FunctionComponent<MarkdownProviderProps>;
 //#endregion
-export { MarkdownProvider, MarkdownProviderOptions, useMarkdownContext };
 //# sourceMappingURL=MarkdownProvider.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"MarkdownProvider.d.ts","names":[],"sources":["../../../src/markdown/MarkdownProvider.tsx"],"mappings":";;;;KAWK,kBAAkB,UAAU;EAAM,WAAW;;;;;KAKtC;;;;EAIV;;;;EAIA;;;;EAIA;;;;EAIA;;KASG;EACH,aAAa;EACb,iBACE,mBAAmB,gBACnB,UAAU,yBACV,aAAa,kCACb,UAAU,2BAA2B,IAAI,sBACtC,oBAAoB,QAAQ;;KAG9B,wBAAwB,kBAC3B;;;;EAIE,aAAa;;;;EAIb,UAAU,2BAA2B,IAAI;;;;;EAKzC,kBACE,mBAAmB,gBACnB,UAAU,yBACV,aAAa,kCACb,UAAU,2BAA2B,IAAI,sBACtC,oBAAoB,QAAQ;;cAQxB,0BAAkB;cAuBlB,kBAAkB,kBAAkB"}
+{"version":3,"file":"MarkdownProvider.d.ts","names":[],"sources":["../../../src/markdown/MarkdownProvider.tsx"],"mappings":";;;;KAWK,kBAAkB,UAAU;EAAM,WAAW;;;;;YAKtC;;;;EAIV;;;;EAIA;;;;EAIA;;;;EAIA;;KASG;EACH,aAAa;EACb,iBACE,mBAAmB,gBACnB,UAAU,yBACV,aAAa,kCACb,UAAU,2BAA2B,IAAI,sBACtC,oBAAoB,QAAQ;;KAG9B,wBAAwB,kBAC3B;;;;EAIE,aAAa;;;;EAIb,UAAU,2BAA2B,IAAI;;;;;EAKzC,kBACE,mBAAmB,gBACnB,UAAU,yBACV,aAAa,kCACb,UAAU,2BAA2B,IAAI,sBACtC,oBAAoB,QAAQ;;qBAQxB,0BAAkB;qBAuBlB,kBAAkB,kBAAkB"}

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

@@ -3,7 +3,7 @@ import { ParsedMarkdown } from "./compiler.js";
 import { MarkdownProviderOptions } from "./MarkdownProvider.js";
 import { ComponentChildren, ComponentType, FunctionComponent, JSX } from "preact";
 //#region src/markdown/MarkdownRenderer.d.ts
-type RenderMarkdownProps = MarkdownProviderOptions & {
+export type RenderMarkdownProps = MarkdownProviderOptions & {
   /**
    * Component overrides for HTML tags.
    * Only used if not wrapped in a MarkdownProvider.
@@ -15,9 +15,9 @@ type RenderMarkdownProps = MarkdownProviderOptions & {
    */
   wrapper?: ComponentType<any> | keyof JSX.IntrinsicElements;
 };
-declare const renderMarkdown: (content: string | ParsedMarkdown, { components, wrapper, forceBlock, forceInline, preserveFrontmatter, tagfilter }?: RenderMarkdownProps) => JSX.Element;
-declare const useMarkdownRenderer: ({ components, wrapper, forceBlock, forceInline, preserveFrontmatter, tagfilter }?: RenderMarkdownProps) => (content: string | ParsedMarkdown) => ComponentChildren;
-type MarkdownRendererProps = RenderMarkdownProps & {
+export declare const renderMarkdown: (content: string | ParsedMarkdown, { components, wrapper, forceBlock, forceInline, preserveFrontmatter, tagfilter }?: RenderMarkdownProps) => JSX.Element;
+export declare const useMarkdownRenderer: ({ components, wrapper, forceBlock, forceInline, preserveFrontmatter, tagfilter }?: RenderMarkdownProps) => (content: string | ParsedMarkdown) => ComponentChildren;
+export type MarkdownRendererProps = RenderMarkdownProps & {
   /**
    * The markdown content to render.
    */
@@ -41,7 +41,6 @@ type MarkdownRendererProps = RenderMarkdownProps & {
  * It uses the renderMarkdown function from the MarkdownProvider context if available.
  * Otherwise, it falls back to the default compiler with provided components and options.
  */
-declare const MarkdownRenderer: FunctionComponent<MarkdownRendererProps>;
+export declare const MarkdownRenderer: FunctionComponent<MarkdownRendererProps>;
 //#endregion
-export { MarkdownRenderer, MarkdownRendererProps, RenderMarkdownProps, renderMarkdown, useMarkdownRenderer };
 //# sourceMappingURL=MarkdownRenderer.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"MarkdownRenderer.d.ts","names":[],"sources":["../../../src/markdown/MarkdownRenderer.tsx"],"mappings":";;;;;KAiBY,sBAAsB;;;;;EAKhC,aAAa;;;;;EAKb,UAAU,2BAA2B,IAAI;;cAG9B,iBAAc,kBACP,kBAAc,YAAA,SAAA,YAAA,aAAA,qBAAA,cAQ7B,wBACF,IAAI;cAeM,wBAAmB,YAAA,SAAA,YAAA,aAAA,qBAAA,cAO7B,yBAAmB,kBAGM,mBAAc;KA0B9B,wBAAwB;;;;EAIlC,mBAAmB;;;;;EAKnB,kBACE,mBAAmB,gBACnB;IACE,aAAa;IACb,UAAU,2BAA2B,IAAI;IACzC;IACA;IACA;IACA;QAEC,oBAAoB,QAAQ;;;;;;;;cAStB,kBAAkB,kBAAkB"}
+{"version":3,"file":"MarkdownRenderer.d.ts","names":[],"sources":["../../../src/markdown/MarkdownRenderer.tsx"],"mappings":";;;;;YAiBY,sBAAsB;;;;;EAKhC,aAAa;;;;;EAKb,UAAU,2BAA2B,IAAI;;qBAG9B,iBAAc,kBACP,kBAAc,YAAA,SAAA,YAAA,aAAA,qBAAA,cAQ7B,wBACF,IAAI;qBAeM,wBAAmB,YAAA,SAAA,YAAA,aAAA,qBAAA,cAO7B,yBAAmB,kBAGM,mBAAc;YA0B9B,wBAAwB;;;;EAIlC,mBAAmB;;;;;EAKnB,kBACE,mBAAmB,gBACnB;IACE,aAAa;IACb,UAAU,2BAA2B,IAAI;IACzC;IACA;IACA;IACA;QAEC,oBAAoB,QAAQ;;;;;;;;qBAStB,kBAAkB,kBAAkB"}

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

@@ -12,11 +12,10 @@ type MarkdownRendererPluginProps = {
   options?: MarkdownProviderOptions;
   components?: HTMLComponents<'permissive', {}>;
 };
-declare const MarkdownRendererPlugin: FunctionComponent<MarkdownRendererPluginProps>;
+export declare const MarkdownRendererPlugin: FunctionComponent<MarkdownRendererPluginProps>;
 type MarkdownMetadataRendererProps = MarkdownRendererPluginProps & {
   metadataKeyPath: KeyPath[];
 };
-declare const MarkdownMetadataRenderer: FunctionComponent<MarkdownMetadataRendererProps>;
+export declare const MarkdownMetadataRenderer: FunctionComponent<MarkdownMetadataRendererProps>;
 //#endregion
-export { MarkdownMetadataRenderer, MarkdownRendererPlugin };
 //# sourceMappingURL=MarkdownRendererPlugin.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"MarkdownRendererPlugin.d.ts","names":[],"sources":["../../../src/markdown/MarkdownRendererPlugin.tsx"],"mappings":";;;;;;KAeK;EACH;EACA,SAAS;EACT,SAAS;EACT;EACA,UAAU;EACV,aAAa;;cAGF,wBAAwB,kBACnC;KAYG,gCAAgC;EACnC,iBAAiB;;cAGN,0BAA0B,kBACrC"}
+{"version":3,"file":"MarkdownRendererPlugin.d.ts","names":[],"sources":["../../../src/markdown/MarkdownRendererPlugin.tsx"],"mappings":";;;;;;KAeK;EACH;EACA,SAAS;EACT,SAAS;EACT;EACA,UAAU;EACV,aAAa;;qBAGF,wBAAwB,kBACnC;KAYG,gCAAgC;EACnC,iBAAiB;;qBAGN,0BAA0B,kBACrC"}

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

@@ -4,7 +4,7 @@ import { CompileOptions, ParsedMarkdown } from "@intlayer/core/markdown";
  * Options accepted by `compileMarkdown` and `parseMarkdown` to customise
  * rendering behaviour (custom components, sanitizer, slugify, rule hooks, …).
  */
-type MarkdownCompilerOptions = CompileOptions;
+export type MarkdownCompilerOptions = CompileOptions;
 /**
  * **Step 1 of 2 — parse only.**
  * Converts a raw markdown string into a `ParsedMarkdown` AST without rendering
@@ -23,7 +23,7 @@ type MarkdownCompilerOptions = CompileOptions;
  * const element = compileMarkdown(ast, { forceBlock: true });
  * ```
  */
-declare const parseMarkdown: (markdown?: string, options?: MarkdownCompilerOptions) => ParsedMarkdown;
+export declare const parseMarkdown: (markdown?: string, options?: MarkdownCompilerOptions) => ParsedMarkdown;
 /**
  * **Steps 1 + 2 — parse and render in one shot.**
  * Accepts a raw markdown string or a pre-parsed `ParsedMarkdown` AST and
@@ -39,7 +39,7 @@ declare const parseMarkdown: (markdown?: string, options?: MarkdownCompilerOptio
  * const element = compileMarkdown('# Hello **world**', { forceBlock: true });
  * ```
  */
-declare const compileMarkdown: (input?: string | ParsedMarkdown, options?: MarkdownCompilerOptions) => unknown;
+export declare const compileMarkdown: (input?: string | ParsedMarkdown, options?: MarkdownCompilerOptions) => unknown;
 //#endregion
-export { MarkdownCompilerOptions, type ParsedMarkdown, compileMarkdown, parseMarkdown };
+export type { ParsedMarkdown };
 //# 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":";;;;;;KAkBY,0BAA0B;;;;;;;;;;;;;;;;;;;cA2BzB,gBAAa,mBACR,UACP,4BACR;;;;;;;;;;;;;;;;cAmCU,kBAAe,iBACV,gBAAc,UACrB"}
+{"version":3,"file":"compiler.d.ts","names":[],"sources":["../../../src/markdown/compiler.ts"],"mappings":";;;;;;YAkBY,0BAA0B;;;;;;;;;;;;;;;;;;;qBA2BzB,gBAAa,mBACR,UACP,4BACR;;;;;;;;;;;;;;;;qBAmCU,kBAAe,iBACV,gBAAc,UACrB"}

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

@@ -3,7 +3,7 @@ import { MarkdownRuntime } from "@intlayer/core/markdown";
 /**
  * Preact-specific runtime for the markdown processor.
  */
-declare const preactRuntime: MarkdownRuntime;
+export declare const preactRuntime: MarkdownRuntime;
 //#endregion
-export { preactRuntime as default, preactRuntime };
+export { preactRuntime as default };
 //# sourceMappingURL=runtime.d.ts.map

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

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

package/dist/types/plugins.d.ts

@@ -9,38 +9,38 @@ import { NodeType } from "@intlayer/types/nodeType";
 /** ---------------------------------------------
  * INTLAYER NODE PLUGIN
  * --------------------------------------------- */
-type IntlayerNodeCond<T> = T extends number | string ? IntlayerNode<T> : never;
+export type IntlayerNodeCond<T> = T extends number | string ? IntlayerNode<T> : never;
 /** Translation plugin. Replaces node with a locale string if nodeType = Translation. */
-declare const intlayerNodePlugins: Plugins;
+export declare const intlayerNodePlugins: Plugins;
 /** ---------------------------------------------
  * PREACT NODE PLUGIN
  * --------------------------------------------- */
-type PreactNodeCond<T> = T extends {
+export type PreactNodeCond<T> = T extends {
   props: any;
   key: any;
 } ? VNode : never;
 /** Translation plugin. Replaces node with a locale string if nodeType = Translation. */
-declare const preactNodePlugins: Plugins;
+export declare const preactNodePlugins: Plugins;
 /** ---------------------------------------------
  * INSERTION PLUGIN
  * --------------------------------------------- */
-type InsertionCond<T, _S, L extends LocalesValues> = T extends {
+export type InsertionCond<T, _S, L extends LocalesValues> = T extends {
   nodeType: NodeType | string;
   [NodeTypes.INSERTION]: infer I;
   fields: readonly (infer F)[];
 } ? <V extends { [K in Extract<F, string>]: string | number | VNode; }>(values: V) => I extends string ? V[keyof V] extends string | number ? IntlayerNode<string> : IntlayerNode<VNode> : DeepTransformContent<I, L> : never;
 /** Insertion plugin for Preact. Handles component/node insertion. */
-declare const insertionPlugin: Plugins;
+export declare const insertionPlugin: Plugins;
 /**
  * MARKDOWN PLUGIN
  */
-type MarkdownStringCond<T> = T extends string ? IntlayerNode<string, {
+export type MarkdownStringCond<T> = T extends string ? IntlayerNode<string, {
   metadata: DeepTransformContent<string>;
   use: (components?: HTMLComponents<'permissive', {}>) => VNode;
 }> : never;
 /** Markdown string plugin. Replaces string node with a component that render the markdown. */
-declare const markdownStringPlugin: Plugins;
-type MarkdownCond<T> = T extends {
+export declare const markdownStringPlugin: Plugins;
+export type MarkdownCond<T> = T extends {
   nodeType: NodeType | string;
   [NodeTypes.MARKDOWN]: infer _M;
   metadata?: infer U;
@@ -49,11 +49,11 @@ type MarkdownCond<T> = T extends {
   use: (components?: HTMLComponents<'permissive', U>) => VNode;
   metadata: DeepTransformContent<U>;
 } : never;
-declare const markdownPlugin: Plugins;
+export declare const markdownPlugin: Plugins;
 /** ---------------------------------------------
  * HTML PLUGIN
  * --------------------------------------------- */
-type HTMLPluginCond<T> = T extends {
+export type HTMLPluginCond<T> = T extends {
   nodeType: NodeType | string;
   [NodeTypes.HTML]: infer I;
   tags?: infer U;
@@ -61,11 +61,11 @@ type HTMLPluginCond<T> = T extends {
   use: (components?: HTMLComponents<'permissive', U>) => IntlayerNode<I>;
 } : never;
 /** HTML plugin. Replaces node with a function that takes components => VNode. */
-declare const htmlPlugin: Plugins;
+export declare const htmlPlugin: Plugins;
 /** ---------------------------------------------
  * PLUGINS RESULT
  * --------------------------------------------- */
-interface IInterpreterPluginPreact<T, S, L extends LocalesValues> {
+export interface IInterpreterPluginPreact<T, S, L extends LocalesValues> {
   preactNode: PreactNodeCond<T>;
   preactIntlayerNode: IntlayerNodeCond<T>;
   preactInsertion: InsertionCond<T, S, L>;
@@ -77,19 +77,18 @@ interface IInterpreterPluginPreact<T, S, L extends LocalesValues> {
  *
  * Otherwise the the `preact-intlayer` plugins will override the types of `intlayer` functions.
  */
-type IInterpreterPluginState = Omit<IInterpreterPluginState$1, 'insertion'> & {
+export type IInterpreterPluginState = Omit<IInterpreterPluginState$1, 'insertion'> & {
   preactNode: true;
   preactIntlayerNode: true;
   preactInsertion: true;
   preactMarkdown: true;
   preactHtml: true;
 };
-type DeepTransformContent<T, L extends LocalesValues = DeclaredLocales> = DeepTransformContent$1<T, IInterpreterPluginState, L>;
+export type DeepTransformContent<T, L extends LocalesValues = DeclaredLocales> = DeepTransformContent$1<T, IInterpreterPluginState, L>;
 /**
  * Get the plugins array for Preact content transformation.
  * This function is used by both getIntlayer and getDictionary to ensure consistent plugin configuration.
  */
-declare const getPlugins: (locale?: LocalesValues, fallback?: boolean) => Plugins[];
+export declare const getPlugins: (locale?: LocalesValues, fallback?: boolean) => Plugins[];
 //#endregion
-export { DeepTransformContent, HTMLPluginCond, IInterpreterPluginPreact, IInterpreterPluginState, InsertionCond, IntlayerNodeCond, MarkdownCond, MarkdownStringCond, PreactNodeCond, getPlugins, htmlPlugin, insertionPlugin, intlayerNodePlugins, markdownPlugin, markdownStringPlugin, preactNodePlugins };
 //# sourceMappingURL=plugins.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"plugins.d.ts","names":[],"sources":["../../src/plugins.tsx"],"mappings":";;;;;;;;;;;KA8DY,iBAAiB,KAAK,4BAC9B,aAAa;;cAIJ,qBAAqB;;;;KA2CtB,eAAe,KAAK;EAC9B;EACA;IAEE;;cAIS,mBAAmB;;;;KA8CpB,cAAc,GAAG,IAAI,UAAU,iBAAiB;EAC1D,UAAU;GACT,UAAU,kBAAkB;EAC7B,wBAAwB;KAErB,aAAa,KAAK,QAAQ,+BAA+B,UACxD,QAAQ,MACL,mBACD,QAAQ,6BACN,uBACA,aAAa,SACf,qBAAqB,GAAG;;cAuEnB,iBAAiB;;;;KA4GlB,mBAAmB,KAAK,mBAChC;EAGI,UAAU;EACV,MAAM,aAAa,qCAAqC;;;cA4BnD,sBAAsB;KAiGvB,aAAa,KAAK;EAC5B,UAAU;GACT,UAAU,iBAAiB;EAC5B,iBAAiB;EACjB,aAAa;;EAGT,MAAM,aAAa,6BAA6B,OAAO;EACvD,UAAU,qBAAqB;;cAIxB,gBAAgB;;;;KA8BjB,eAAe,KAAK;EAC9B,UAAU;GACT,UAAU,aAAa;EACxB,aAAa;;EAGT,MAAM,aAAa,6BAA6B,OAAO,aAAa;;;cAW7D,YAAY;;;;UAkER,yBAAyB,GAAG,GAAG,UAAU;EACxD,YAAY,eAAe;EAC3B,oBAAoB,iBAAiB;EACrC,iBAAiB,cAAc,GAAG,GAAG;EACrC,gBAAgB,aAAa;EAC7B,YAAY,eAAe;;;;;;;KAQjB,0BAA0B,KACpC;EAGA;EACA;EACA;EACA;EACA;;KAGU,qBACV,GACA,UAAU,gBAAgB,mBACxB,uBAAyB,GAAG,yBAAyB;;;;;cAQ5C,aAAU,SACZ,eAAa,uBAErB"}
+{"version":3,"file":"plugins.d.ts","names":[],"sources":["../../src/plugins.tsx"],"mappings":";;;;;;;;;;;YA8DY,iBAAiB,KAAK,4BAC9B,aAAa;;qBAIJ,qBAAqB;;;;YA2CtB,eAAe,KAAK;EAC9B;EACA;IAEE;;qBAIS,mBAAmB;;;;YA8CpB,cAAc,GAAG,IAAI,UAAU,iBAAiB;EAC1D,UAAU;GACT,UAAU,kBAAkB;EAC7B,wBAAwB;KAErB,aAAa,KAAK,QAAQ,+BAA+B,UACxD,QAAQ,MACL,mBACD,QAAQ,6BACN,uBACA,aAAa,SACf,qBAAqB,GAAG;;qBAuEnB,iBAAiB;;;;YA4GlB,mBAAmB,KAAK,mBAChC;EAGI,UAAU;EACV,MAAM,aAAa,qCAAqC;;;qBA4BnD,sBAAsB;YAiGvB,aAAa,KAAK;EAC5B,UAAU;GACT,UAAU,iBAAiB;EAC5B,iBAAiB;EACjB,aAAa;;EAGT,MAAM,aAAa,6BAA6B,OAAO;EACvD,UAAU,qBAAqB;;qBAIxB,gBAAgB;;;;YA8BjB,eAAe,KAAK;EAC9B,UAAU;GACT,UAAU,aAAa;EACxB,aAAa;;EAGT,MAAM,aAAa,6BAA6B,OAAO,aAAa;;;qBAW7D,YAAY;;;;iBAkER,yBAAyB,GAAG,GAAG,UAAU;EACxD,YAAY,eAAe;EAC3B,oBAAoB,iBAAiB;EACrC,iBAAiB,cAAc,GAAG,GAAG;EACrC,gBAAgB,aAAa;EAC7B,YAAY,eAAe;;;;;;;YAQjB,0BAA0B,KACpC;EAGA;EACA;EACA;EACA;EACA;;YAGU,qBACV,GACA,UAAU,gBAAgB,mBACxB,uBAAyB,GAAG,yBAAyB;;;;;qBAQ5C,aAAU,SACZ,eAAa,uBAErB"}

package/dist/types/preactElement/renderPreactElement.d.ts

@@ -1,6 +1,5 @@
 import { VNode } from "preact";
 //#region src/preactElement/renderPreactElement.d.ts
-declare const renderPreactElement: (element: VNode<any>) => any;
+export declare const renderPreactElement: (element: VNode<any>) => any;
 //#endregion
-export { renderPreactElement };
 //# sourceMappingURL=renderPreactElement.d.ts.map

package/dist/types/preactElement/renderPreactElement.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"renderPreactElement.d.ts","names":[],"sources":["../../../src/preactElement/renderPreactElement.ts"],"mappings":";;cAGa,sBAAmB,SAAa"}
+{"version":3,"file":"renderPreactElement.d.ts","names":[],"sources":["../../../src/preactElement/renderPreactElement.ts"],"mappings":";;qBAGa,sBAAmB,SAAa"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "preact-intlayer",
-  "version": "9.4.2",
+  "version": "9.4.4",
   "private": false,
   "description": "Easily internationalize i18n your Preact applications with type-safe multilingual content management.",
   "keywords": [
@@ -100,12 +100,12 @@
     "typecheck": "tsc --noEmit --project tsconfig.types.json"
   },
   "dependencies": {
-    "@intlayer/api": "9.4.2",
-    "@intlayer/config": "9.4.2",
-    "@intlayer/core": "9.4.2",
-    "@intlayer/editor": "9.4.2",
-    "@intlayer/engine": "9.4.2",
-    "@intlayer/types": "9.4.2"
+    "@intlayer/api": "9.4.4",
+    "@intlayer/config": "9.4.4",
+    "@intlayer/core": "9.4.4",
+    "@intlayer/editor": "9.4.4",
+    "@intlayer/engine": "9.4.4",
+    "@intlayer/types": "9.4.4"
   },
   "devDependencies": {
     "@types/node": "26.4.1",
@@ -114,15 +114,15 @@
     "@utils/tsdown-config": "1.0.4",
     "preact": "10.29.8",
     "rimraf": "6.1.3",
-    "tsdown": "0.22.14",
+    "tsdown": "0.23.0",
     "typescript": "7.0.2",
-    "vitest": "4.1.11"
+    "vitest": "5.0.0"
   },
   "peerDependencies": {
     "preact": ">=8.0.0"
   },
   "optionalDependencies": {
-    "@intlayer/analytics": "9.4.2"
+    "@intlayer/analytics": "9.4.4"
   },
   "engines": {
     "node": ">=14.18"