preact-intlayer 9.4.3 → 9.5.1

package/README.md

@@ -69,8 +69,6 @@ With **per-locale content files**, **TypeScript autocompletion**, **tree-shakabl
 | <img src="https://github.com/aymericzip/intlayer/blob/main/docs/assets/interoperability.png?raw=true" alt="Feature" width="700">                    | **Interoperability**<br><br>Allow interoperability with react-i18next, next-i18next, next-intl, react-intl, vue-i18n. <br><br> - [Intlayer and react-intl](https://intlayer.org/blog/intlayer-with-react-intl) <br> - [Intlayer and next-intl](https://intlayer.org/blog/intlayer-with-next-intl) <br> - [Intlayer and next-i18next](https://intlayer.org/blog/intlayer-with-next-i18next) <br> - [Intlayer and vue-i18n](https://intlayer.org/blog/intlayer-with-vue-i18n) <br> - [Intlayer compat adapters](https://intlayer.org/doc/compatibility) |
 | <img src="https://github.com/aymericzip/intlayer/blob/main/docs/assets/benchmark.png?raw=true" alt="Feature" width="700">                           | **Performances & Benchmark**<br><br>Uses advanced tree-shaking and dynamic loading to boost performances and keep the solution as light as possible. <br><br> - [Performances & Benchmark](https://intlayer.org/doc/benchmark)                                                                                                                                                                                                                                                                                                                        |
 
----
-
 ## 📦 Installation
 
 Start your journey with Intlayer today and experience a smoother, more powerful approach to internationalization.

package/dist/cjs/client/useLocale.cjs

@@ -5,6 +5,7 @@ let _intlayer_config_built = require("@intlayer/config/built");
 let preact_hooks = require("preact/hooks");
 
 //#region src/client/useLocale.ts
+const { defaultLocale, locales: availableLocales } = _intlayer_config_built.internationalization ?? {};
 /**
 * Preact hook to get the current locale and related locale management functions.
 *
@@ -29,7 +30,6 @@ let preact_hooks = require("preact/hooks");
 * ```
 */
 const useLocale = ({ isCookieEnabled, onLocaleChange } = {}) => {
-	const { defaultLocale, locales: availableLocales } = _intlayer_config_built.internationalization ?? {};
 	const { locale, setLocale: setLocaleState, isCookieEnabled: isCookieEnabledContext } = (0, preact_hooks.useContext)(require_client_IntlayerProvider.IntlayerClientContext) ?? {};
 	const setLocale = (locale) => {
 		if (!availableLocales?.map(String).includes(locale)) {

package/dist/cjs/client/useLocale.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"useLocale.cjs","names":["internationalization","useContext","IntlayerClientContext"],"sources":["../../../src/client/useLocale.ts"],"sourcesContent":["import { internationalization } from '@intlayer/config/built';\nimport type {\n  DeclaredLocales,\n  LocalesValues,\n} from '@intlayer/types/module_augmentation';\nimport { useContext } from 'preact/hooks';\nimport { IntlayerClientContext } from './IntlayerProvider';\nimport { setLocaleInStorage } from './useLocaleStorage';\n\ntype UseLocaleProps = {\n  isCookieEnabled?: boolean;\n  onLocaleChange?: (locale: DeclaredLocales) => void;\n};\n\ntype UseLocaleResult = {\n  locale: DeclaredLocales;\n  defaultLocale: DeclaredLocales;\n  availableLocales: DeclaredLocales[];\n  setLocale: (locale: LocalesValues) => void;\n};\n\n/**\n * Preact hook to get the current locale and related locale management functions.\n *\n * @param props - Optional properties for the hook.\n * @returns An object containing the current locale, default locale, available locales, and a function to update the locale.\n *\n * @example\n * ```tsx\n * import { useLocale } from 'preact-intlayer';\n *\n * const LocaleSwitcher = () => {\n *   const { locale, setLocale, availableLocales } = useLocale();\n *\n *   return (\n *     <select value={locale} onChange={(e) => setLocale(e.target.value)}>\n *       {availableLocales.map((loc) => (\n *         <option key={loc} value={loc}>{loc}</option>\n *       ))}\n *     </select>\n *   );\n * };\n * ```\n */\nexport const useLocale = ({\n  isCookieEnabled,\n  onLocaleChange,\n}: UseLocaleProps = {}): UseLocaleResult => {\n  const { defaultLocale, locales: availableLocales } =\n    internationalization ?? {};\n\n  const {\n    locale,\n    setLocale: setLocaleState,\n    isCookieEnabled: isCookieEnabledContext,\n  } = useContext(IntlayerClientContext) ?? {};\n\n  const setLocale = (locale: LocalesValues) => {\n    if (!availableLocales?.map(String).includes(locale)) {\n      console.error(`Locale ${locale} is not available`);\n      return;\n    }\n\n    setLocaleState(locale);\n\n    setLocaleInStorage(\n      locale,\n      isCookieEnabled ?? isCookieEnabledContext ?? true\n    );\n\n    onLocaleChange?.(locale as DeclaredLocales);\n  };\n\n  return {\n    locale, // Current locale\n    defaultLocale, // Principal locale defined in config\n    availableLocales, // List of the available locales defined in config\n    setLocale, // Function to set the locale\n  } as UseLocaleResult;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4CA,MAAa,aAAa,EACxB,iBACA,mBACkB,CAAC,MAAuB;CAC1C,MAAM,EAAE,eAAe,SAAS,qBAC9BA,+CAAwB,CAAC;CAE3B,MAAM,EACJ,QACA,WAAW,gBACX,iBAAiB,+BACfC,yBAAWC,qDAAqB,KAAK,CAAC;CAE1C,MAAM,aAAa,WAA0B;EAC3C,IAAI,CAAC,kBAAkB,IAAI,MAAM,CAAC,CAAC,SAAS,MAAM,GAAG;GACnD,QAAQ,MAAM,UAAU,OAAO,kBAAkB;GACjD;EACF;EAEA,eAAe,MAAM;EAErB,mDACE,QACA,mBAAmB,0BAA0B,IAC/C;EAEA,iBAAiB,MAAyB;CAC5C;CAEA,OAAO;EACL;EACA;EACA;EACA;CACF;AACF"}
+{"version":3,"file":"useLocale.cjs","names":["internationalization","useContext","IntlayerClientContext"],"sources":["../../../src/client/useLocale.ts"],"sourcesContent":["import { internationalization } from '@intlayer/config/built';\nimport type {\n  DeclaredLocales,\n  LocalesValues,\n} from '@intlayer/types/module_augmentation';\nimport { useContext } from 'preact/hooks';\nimport { IntlayerClientContext } from './IntlayerProvider';\nimport { setLocaleInStorage } from './useLocaleStorage';\n\ntype UseLocaleProps = {\n  isCookieEnabled?: boolean;\n  onLocaleChange?: (locale: DeclaredLocales) => void;\n};\n\ntype UseLocaleResult = {\n  locale: DeclaredLocales;\n  defaultLocale: DeclaredLocales;\n  availableLocales: DeclaredLocales[];\n  setLocale: (locale: LocalesValues) => void;\n};\n\nconst { defaultLocale, locales: availableLocales } = internationalization ?? {};\n\n/**\n * Preact hook to get the current locale and related locale management functions.\n *\n * @param props - Optional properties for the hook.\n * @returns An object containing the current locale, default locale, available locales, and a function to update the locale.\n *\n * @example\n * ```tsx\n * import { useLocale } from 'preact-intlayer';\n *\n * const LocaleSwitcher = () => {\n *   const { locale, setLocale, availableLocales } = useLocale();\n *\n *   return (\n *     <select value={locale} onChange={(e) => setLocale(e.target.value)}>\n *       {availableLocales.map((loc) => (\n *         <option key={loc} value={loc}>{loc}</option>\n *       ))}\n *     </select>\n *   );\n * };\n * ```\n */\nexport const useLocale = ({\n  isCookieEnabled,\n  onLocaleChange,\n}: UseLocaleProps = {}): UseLocaleResult => {\n  const {\n    locale,\n    setLocale: setLocaleState,\n    isCookieEnabled: isCookieEnabledContext,\n  } = useContext(IntlayerClientContext) ?? {};\n\n  const setLocale = (locale: LocalesValues) => {\n    if (!availableLocales?.map(String).includes(locale)) {\n      console.error(`Locale ${locale} is not available`);\n      return;\n    }\n\n    setLocaleState(locale);\n\n    setLocaleInStorage(\n      locale,\n      isCookieEnabled ?? isCookieEnabledContext ?? true\n    );\n\n    onLocaleChange?.(locale as DeclaredLocales);\n  };\n\n  return {\n    locale, // Current locale\n    defaultLocale, // Principal locale defined in config\n    availableLocales, // List of the available locales defined in config\n    setLocale, // Function to set the locale\n  } as UseLocaleResult;\n};\n"],"mappings":";;;;;;;AAqBA,MAAM,EAAE,eAAe,SAAS,qBAAqBA,+CAAwB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;AAyB9E,MAAa,aAAa,EACxB,iBACA,mBACkB,CAAC,MAAuB;CAC1C,MAAM,EACJ,QACA,WAAW,gBACX,iBAAiB,+BACfC,yBAAWC,qDAAqB,KAAK,CAAC;CAE1C,MAAM,aAAa,WAA0B;EAC3C,IAAI,CAAC,kBAAkB,IAAI,MAAM,CAAC,CAAC,SAAS,MAAM,GAAG;GACnD,QAAQ,MAAM,UAAU,OAAO,kBAAkB;GACjD;EACF;EAEA,eAAe,MAAM;EAErB,mDACE,QACA,mBAAmB,0BAA0B,IAC/C;EAEA,iBAAiB,MAAyB;CAC5C;CAEA,OAAO;EACL;EACA;EACA;EACA;CACF;AACF"}

package/dist/esm/client/useLocale.mjs

@@ -4,6 +4,7 @@ import { internationalization } from "@intlayer/config/built";
 import { useContext } from "preact/hooks";
 
 //#region src/client/useLocale.ts
+const { defaultLocale, locales: availableLocales } = internationalization ?? {};
 /**
 * Preact hook to get the current locale and related locale management functions.
 *
@@ -28,7 +29,6 @@ import { useContext } from "preact/hooks";
 * ```
 */
 const useLocale = ({ isCookieEnabled, onLocaleChange } = {}) => {
-	const { defaultLocale, locales: availableLocales } = internationalization ?? {};
 	const { locale, setLocale: setLocaleState, isCookieEnabled: isCookieEnabledContext } = useContext(IntlayerClientContext) ?? {};
 	const setLocale = (locale) => {
 		if (!availableLocales?.map(String).includes(locale)) {

package/dist/esm/client/useLocale.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"useLocale.mjs","names":[],"sources":["../../../src/client/useLocale.ts"],"sourcesContent":["import { internationalization } from '@intlayer/config/built';\nimport type {\n  DeclaredLocales,\n  LocalesValues,\n} from '@intlayer/types/module_augmentation';\nimport { useContext } from 'preact/hooks';\nimport { IntlayerClientContext } from './IntlayerProvider';\nimport { setLocaleInStorage } from './useLocaleStorage';\n\ntype UseLocaleProps = {\n  isCookieEnabled?: boolean;\n  onLocaleChange?: (locale: DeclaredLocales) => void;\n};\n\ntype UseLocaleResult = {\n  locale: DeclaredLocales;\n  defaultLocale: DeclaredLocales;\n  availableLocales: DeclaredLocales[];\n  setLocale: (locale: LocalesValues) => void;\n};\n\n/**\n * Preact hook to get the current locale and related locale management functions.\n *\n * @param props - Optional properties for the hook.\n * @returns An object containing the current locale, default locale, available locales, and a function to update the locale.\n *\n * @example\n * ```tsx\n * import { useLocale } from 'preact-intlayer';\n *\n * const LocaleSwitcher = () => {\n *   const { locale, setLocale, availableLocales } = useLocale();\n *\n *   return (\n *     <select value={locale} onChange={(e) => setLocale(e.target.value)}>\n *       {availableLocales.map((loc) => (\n *         <option key={loc} value={loc}>{loc}</option>\n *       ))}\n *     </select>\n *   );\n * };\n * ```\n */\nexport const useLocale = ({\n  isCookieEnabled,\n  onLocaleChange,\n}: UseLocaleProps = {}): UseLocaleResult => {\n  const { defaultLocale, locales: availableLocales } =\n    internationalization ?? {};\n\n  const {\n    locale,\n    setLocale: setLocaleState,\n    isCookieEnabled: isCookieEnabledContext,\n  } = useContext(IntlayerClientContext) ?? {};\n\n  const setLocale = (locale: LocalesValues) => {\n    if (!availableLocales?.map(String).includes(locale)) {\n      console.error(`Locale ${locale} is not available`);\n      return;\n    }\n\n    setLocaleState(locale);\n\n    setLocaleInStorage(\n      locale,\n      isCookieEnabled ?? isCookieEnabledContext ?? true\n    );\n\n    onLocaleChange?.(locale as DeclaredLocales);\n  };\n\n  return {\n    locale, // Current locale\n    defaultLocale, // Principal locale defined in config\n    availableLocales, // List of the available locales defined in config\n    setLocale, // Function to set the locale\n  } as UseLocaleResult;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4CA,MAAa,aAAa,EACxB,iBACA,mBACkB,CAAC,MAAuB;CAC1C,MAAM,EAAE,eAAe,SAAS,qBAC9B,wBAAwB,CAAC;CAE3B,MAAM,EACJ,QACA,WAAW,gBACX,iBAAiB,2BACf,WAAW,qBAAqB,KAAK,CAAC;CAE1C,MAAM,aAAa,WAA0B;EAC3C,IAAI,CAAC,kBAAkB,IAAI,MAAM,CAAC,CAAC,SAAS,MAAM,GAAG;GACnD,QAAQ,MAAM,UAAU,OAAO,kBAAkB;GACjD;EACF;EAEA,eAAe,MAAM;EAErB,mBACE,QACA,mBAAmB,0BAA0B,IAC/C;EAEA,iBAAiB,MAAyB;CAC5C;CAEA,OAAO;EACL;EACA;EACA;EACA;CACF;AACF"}
+{"version":3,"file":"useLocale.mjs","names":[],"sources":["../../../src/client/useLocale.ts"],"sourcesContent":["import { internationalization } from '@intlayer/config/built';\nimport type {\n  DeclaredLocales,\n  LocalesValues,\n} from '@intlayer/types/module_augmentation';\nimport { useContext } from 'preact/hooks';\nimport { IntlayerClientContext } from './IntlayerProvider';\nimport { setLocaleInStorage } from './useLocaleStorage';\n\ntype UseLocaleProps = {\n  isCookieEnabled?: boolean;\n  onLocaleChange?: (locale: DeclaredLocales) => void;\n};\n\ntype UseLocaleResult = {\n  locale: DeclaredLocales;\n  defaultLocale: DeclaredLocales;\n  availableLocales: DeclaredLocales[];\n  setLocale: (locale: LocalesValues) => void;\n};\n\nconst { defaultLocale, locales: availableLocales } = internationalization ?? {};\n\n/**\n * Preact hook to get the current locale and related locale management functions.\n *\n * @param props - Optional properties for the hook.\n * @returns An object containing the current locale, default locale, available locales, and a function to update the locale.\n *\n * @example\n * ```tsx\n * import { useLocale } from 'preact-intlayer';\n *\n * const LocaleSwitcher = () => {\n *   const { locale, setLocale, availableLocales } = useLocale();\n *\n *   return (\n *     <select value={locale} onChange={(e) => setLocale(e.target.value)}>\n *       {availableLocales.map((loc) => (\n *         <option key={loc} value={loc}>{loc}</option>\n *       ))}\n *     </select>\n *   );\n * };\n * ```\n */\nexport const useLocale = ({\n  isCookieEnabled,\n  onLocaleChange,\n}: UseLocaleProps = {}): UseLocaleResult => {\n  const {\n    locale,\n    setLocale: setLocaleState,\n    isCookieEnabled: isCookieEnabledContext,\n  } = useContext(IntlayerClientContext) ?? {};\n\n  const setLocale = (locale: LocalesValues) => {\n    if (!availableLocales?.map(String).includes(locale)) {\n      console.error(`Locale ${locale} is not available`);\n      return;\n    }\n\n    setLocaleState(locale);\n\n    setLocaleInStorage(\n      locale,\n      isCookieEnabled ?? isCookieEnabledContext ?? true\n    );\n\n    onLocaleChange?.(locale as DeclaredLocales);\n  };\n\n  return {\n    locale, // Current locale\n    defaultLocale, // Principal locale defined in config\n    availableLocales, // List of the available locales defined in config\n    setLocale, // Function to set the locale\n  } as UseLocaleResult;\n};\n"],"mappings":";;;;;;AAqBA,MAAM,EAAE,eAAe,SAAS,qBAAqB,wBAAwB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;AAyB9E,MAAa,aAAa,EACxB,iBACA,mBACkB,CAAC,MAAuB;CAC1C,MAAM,EACJ,QACA,WAAW,gBACX,iBAAiB,2BACf,WAAW,qBAAqB,KAAK,CAAC;CAE1C,MAAM,aAAa,WAA0B;EAC3C,IAAI,CAAC,kBAAkB,IAAI,MAAM,CAAC,CAAC,SAAS,MAAM,GAAG;GACnD,QAAQ,MAAM,UAAU,OAAO,kBAAkB;GACjD;EACF;EAEA,eAAe,MAAM;EAErB,mBACE,QACA,mBAAmB,0BAA0B,IAC/C;EAEA,iBAAiB,MAAyB;CAC5C;CAEA,OAAO;EACL;EACA;EACA;EACA;CACF;AACF"}

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;;;;;;;;;;;;;;;;;;;;;;;;;qBA4BT,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;
-  defaultLocale: any;
-  availableLocales: any;
-  setLocale: (newLocale: LocalesValues) => void;
+export declare const useLocaleBase: () => {
+  locale: import("@intlayer/types").LocalesValues;
+  defaultLocale: import("@intlayer/types").Locale;
+  availableLocales: import("@intlayer/types").Locale[];
+  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"}