vanilla-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

@@ -4,6 +4,7 @@ const require_client_useLocaleStorage = require('./useLocaleStorage.cjs');
 let _intlayer_config_built = require("@intlayer/config/built");
 
 //#region src/client/useLocale.ts
+const { defaultLocale, locales: availableLocales } = _intlayer_config_built.internationalization ?? {};
 /**
 * Get the current locale state and locale management utilities.
 *
@@ -33,7 +34,6 @@ let _intlayer_config_built = require("@intlayer/config/built");
 */
 const useLocale = (props = {}) => {
 	const client = require_client_installIntlayer.getIntlayerClient();
-	const { defaultLocale, locales: availableLocales } = _intlayer_config_built.internationalization ?? {};
 	const setLocale = (newLocale) => {
 		if (!(availableLocales ?? []).map(String).includes(newLocale)) {
 			console.error(`Locale "${newLocale}" is not available.`);

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

@@ -1 +1 @@
-{"version":3,"file":"useLocale.cjs","names":["getIntlayerClient","internationalization"],"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 { getIntlayerClient } from './installIntlayer';\nimport { setLocaleInStorage } from './useLocaleStorage';\n\nexport type UseLocaleProps = {\n  isCookieEnabled?: boolean;\n  onLocaleChange?: (locale: DeclaredLocales) => void;\n};\n\nexport type UseLocaleResult = {\n  locale: DeclaredLocales;\n  defaultLocale: DeclaredLocales;\n  availableLocales: DeclaredLocales[];\n  setLocale: (locale: LocalesValues) => void;\n  subscribe: (callback: (locale: LocalesValues) => void) => () => void;\n};\n\n/**\n * Get the current locale state and locale management utilities.\n *\n * Returns a plain object with the current `locale`, `defaultLocale`,\n * `availableLocales`, a `setLocale` function, and a `subscribe` function\n * to react to locale changes.\n *\n * @param props - Optional configuration.\n * @returns Locale state and management utilities.\n *\n * @example\n * ```ts\n * import { installIntlayer, useLocale } from 'vanilla-intlayer';\n *\n * installIntlayer('en');\n *\n * const { locale, availableLocales, setLocale, subscribe } = useLocale();\n *\n * const unsubscribe = subscribe((newLocale) => {\n *   console.log('Locale changed to', newLocale);\n * });\n *\n * document.querySelector('#lang-switcher').addEventListener('change', (e) => {\n *   setLocale(e.target.value);\n * });\n * ```\n */\nexport const useLocale = (props: UseLocaleProps = {}): UseLocaleResult => {\n  const client = getIntlayerClient();\n  const { defaultLocale, locales: availableLocales } =\n    internationalization ?? {};\n\n  const setLocale = (newLocale: LocalesValues): void => {\n    if (!(availableLocales ?? []).map(String).includes(newLocale)) {\n      console.error(`Locale \"${newLocale}\" is not available.`);\n      return;\n    }\n\n    client.setLocale(newLocale);\n\n    setLocaleInStorage(\n      newLocale,\n      props.isCookieEnabled ?? client.isCookieEnabled ?? true\n    );\n\n    props.onLocaleChange?.(newLocale as DeclaredLocales);\n  };\n\n  return {\n    locale: client.locale as DeclaredLocales,\n    defaultLocale: defaultLocale as DeclaredLocales,\n    availableLocales: (availableLocales ?? []) as DeclaredLocales[],\n    setLocale,\n    subscribe: (callback) => client.subscribe(callback),\n  };\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgDA,MAAa,aAAa,QAAwB,CAAC,MAAuB;CACxE,MAAM,SAASA,iDAAkB;CACjC,MAAM,EAAE,eAAe,SAAS,qBAC9BC,+CAAwB,CAAC;CAE3B,MAAM,aAAa,cAAmC;EACpD,IAAI,EAAE,oBAAoB,CAAC,EAAC,CAAE,IAAI,MAAM,CAAC,CAAC,SAAS,SAAS,GAAG;GAC7D,QAAQ,MAAM,WAAW,UAAU,oBAAoB;GACvD;EACF;EAEA,OAAO,UAAU,SAAS;EAE1B,mDACE,WACA,MAAM,mBAAmB,OAAO,mBAAmB,IACrD;EAEA,MAAM,iBAAiB,SAA4B;CACrD;CAEA,OAAO;EACL,QAAQ,OAAO;EACA;EACf,kBAAmB,oBAAoB,CAAC;EACxC;EACA,YAAY,aAAa,OAAO,UAAU,QAAQ;CACpD;AACF"}
+{"version":3,"file":"useLocale.cjs","names":["internationalization","getIntlayerClient"],"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 { getIntlayerClient } from './installIntlayer';\nimport { setLocaleInStorage } from './useLocaleStorage';\n\nexport type UseLocaleProps = {\n  isCookieEnabled?: boolean;\n  onLocaleChange?: (locale: DeclaredLocales) => void;\n};\n\nexport type UseLocaleResult = {\n  locale: DeclaredLocales;\n  defaultLocale: DeclaredLocales;\n  availableLocales: DeclaredLocales[];\n  setLocale: (locale: LocalesValues) => void;\n  subscribe: (callback: (locale: LocalesValues) => void) => () => void;\n};\n\nconst { defaultLocale, locales: availableLocales } = internationalization ?? {};\n\n/**\n * Get the current locale state and locale management utilities.\n *\n * Returns a plain object with the current `locale`, `defaultLocale`,\n * `availableLocales`, a `setLocale` function, and a `subscribe` function\n * to react to locale changes.\n *\n * @param props - Optional configuration.\n * @returns Locale state and management utilities.\n *\n * @example\n * ```ts\n * import { installIntlayer, useLocale } from 'vanilla-intlayer';\n *\n * installIntlayer('en');\n *\n * const { locale, availableLocales, setLocale, subscribe } = useLocale();\n *\n * const unsubscribe = subscribe((newLocale) => {\n *   console.log('Locale changed to', newLocale);\n * });\n *\n * document.querySelector('#lang-switcher').addEventListener('change', (e) => {\n *   setLocale(e.target.value);\n * });\n * ```\n */\nexport const useLocale = (props: UseLocaleProps = {}): UseLocaleResult => {\n  const client = getIntlayerClient();\n\n  const setLocale = (newLocale: LocalesValues): void => {\n    if (!(availableLocales ?? []).map(String).includes(newLocale)) {\n      console.error(`Locale \"${newLocale}\" is not available.`);\n      return;\n    }\n\n    client.setLocale(newLocale);\n\n    setLocaleInStorage(\n      newLocale,\n      props.isCookieEnabled ?? client.isCookieEnabled ?? true\n    );\n\n    props.onLocaleChange?.(newLocale as DeclaredLocales);\n  };\n\n  return {\n    locale: client.locale as DeclaredLocales,\n    defaultLocale: defaultLocale as DeclaredLocales,\n    availableLocales: (availableLocales ?? []) as DeclaredLocales[],\n    setLocale,\n    subscribe: (callback) => client.subscribe(callback),\n  };\n};\n"],"mappings":";;;;;;AAqBA,MAAM,EAAE,eAAe,SAAS,qBAAqBA,+CAAwB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6B9E,MAAa,aAAa,QAAwB,CAAC,MAAuB;CACxE,MAAM,SAASC,iDAAkB;CAEjC,MAAM,aAAa,cAAmC;EACpD,IAAI,EAAE,oBAAoB,CAAC,EAAC,CAAE,IAAI,MAAM,CAAC,CAAC,SAAS,SAAS,GAAG;GAC7D,QAAQ,MAAM,WAAW,UAAU,oBAAoB;GACvD;EACF;EAEA,OAAO,UAAU,SAAS;EAE1B,mDACE,WACA,MAAM,mBAAmB,OAAO,mBAAmB,IACrD;EAEA,MAAM,iBAAiB,SAA4B;CACrD;CAEA,OAAO;EACL,QAAQ,OAAO;EACA;EACf,kBAAmB,oBAAoB,CAAC;EACxC;EACA,YAAY,aAAa,OAAO,UAAU,QAAQ;CACpD;AACF"}

package/dist/esm/client/useLocale.mjs

@@ -3,6 +3,7 @@ import { setLocaleInStorage } from "./useLocaleStorage.mjs";
 import { internationalization } from "@intlayer/config/built";
 
 //#region src/client/useLocale.ts
+const { defaultLocale, locales: availableLocales } = internationalization ?? {};
 /**
 * Get the current locale state and locale management utilities.
 *
@@ -32,7 +33,6 @@ import { internationalization } from "@intlayer/config/built";
 */
 const useLocale = (props = {}) => {
 	const client = getIntlayerClient();
-	const { defaultLocale, locales: availableLocales } = internationalization ?? {};
 	const setLocale = (newLocale) => {
 		if (!(availableLocales ?? []).map(String).includes(newLocale)) {
 			console.error(`Locale "${newLocale}" is not available.`);

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 { getIntlayerClient } from './installIntlayer';\nimport { setLocaleInStorage } from './useLocaleStorage';\n\nexport type UseLocaleProps = {\n  isCookieEnabled?: boolean;\n  onLocaleChange?: (locale: DeclaredLocales) => void;\n};\n\nexport type UseLocaleResult = {\n  locale: DeclaredLocales;\n  defaultLocale: DeclaredLocales;\n  availableLocales: DeclaredLocales[];\n  setLocale: (locale: LocalesValues) => void;\n  subscribe: (callback: (locale: LocalesValues) => void) => () => void;\n};\n\n/**\n * Get the current locale state and locale management utilities.\n *\n * Returns a plain object with the current `locale`, `defaultLocale`,\n * `availableLocales`, a `setLocale` function, and a `subscribe` function\n * to react to locale changes.\n *\n * @param props - Optional configuration.\n * @returns Locale state and management utilities.\n *\n * @example\n * ```ts\n * import { installIntlayer, useLocale } from 'vanilla-intlayer';\n *\n * installIntlayer('en');\n *\n * const { locale, availableLocales, setLocale, subscribe } = useLocale();\n *\n * const unsubscribe = subscribe((newLocale) => {\n *   console.log('Locale changed to', newLocale);\n * });\n *\n * document.querySelector('#lang-switcher').addEventListener('change', (e) => {\n *   setLocale(e.target.value);\n * });\n * ```\n */\nexport const useLocale = (props: UseLocaleProps = {}): UseLocaleResult => {\n  const client = getIntlayerClient();\n  const { defaultLocale, locales: availableLocales } =\n    internationalization ?? {};\n\n  const setLocale = (newLocale: LocalesValues): void => {\n    if (!(availableLocales ?? []).map(String).includes(newLocale)) {\n      console.error(`Locale \"${newLocale}\" is not available.`);\n      return;\n    }\n\n    client.setLocale(newLocale);\n\n    setLocaleInStorage(\n      newLocale,\n      props.isCookieEnabled ?? client.isCookieEnabled ?? true\n    );\n\n    props.onLocaleChange?.(newLocale as DeclaredLocales);\n  };\n\n  return {\n    locale: client.locale as DeclaredLocales,\n    defaultLocale: defaultLocale as DeclaredLocales,\n    availableLocales: (availableLocales ?? []) as DeclaredLocales[],\n    setLocale,\n    subscribe: (callback) => client.subscribe(callback),\n  };\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgDA,MAAa,aAAa,QAAwB,CAAC,MAAuB;CACxE,MAAM,SAAS,kBAAkB;CACjC,MAAM,EAAE,eAAe,SAAS,qBAC9B,wBAAwB,CAAC;CAE3B,MAAM,aAAa,cAAmC;EACpD,IAAI,EAAE,oBAAoB,CAAC,EAAC,CAAE,IAAI,MAAM,CAAC,CAAC,SAAS,SAAS,GAAG;GAC7D,QAAQ,MAAM,WAAW,UAAU,oBAAoB;GACvD;EACF;EAEA,OAAO,UAAU,SAAS;EAE1B,mBACE,WACA,MAAM,mBAAmB,OAAO,mBAAmB,IACrD;EAEA,MAAM,iBAAiB,SAA4B;CACrD;CAEA,OAAO;EACL,QAAQ,OAAO;EACA;EACf,kBAAmB,oBAAoB,CAAC;EACxC;EACA,YAAY,aAAa,OAAO,UAAU,QAAQ;CACpD;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 { getIntlayerClient } from './installIntlayer';\nimport { setLocaleInStorage } from './useLocaleStorage';\n\nexport type UseLocaleProps = {\n  isCookieEnabled?: boolean;\n  onLocaleChange?: (locale: DeclaredLocales) => void;\n};\n\nexport type UseLocaleResult = {\n  locale: DeclaredLocales;\n  defaultLocale: DeclaredLocales;\n  availableLocales: DeclaredLocales[];\n  setLocale: (locale: LocalesValues) => void;\n  subscribe: (callback: (locale: LocalesValues) => void) => () => void;\n};\n\nconst { defaultLocale, locales: availableLocales } = internationalization ?? {};\n\n/**\n * Get the current locale state and locale management utilities.\n *\n * Returns a plain object with the current `locale`, `defaultLocale`,\n * `availableLocales`, a `setLocale` function, and a `subscribe` function\n * to react to locale changes.\n *\n * @param props - Optional configuration.\n * @returns Locale state and management utilities.\n *\n * @example\n * ```ts\n * import { installIntlayer, useLocale } from 'vanilla-intlayer';\n *\n * installIntlayer('en');\n *\n * const { locale, availableLocales, setLocale, subscribe } = useLocale();\n *\n * const unsubscribe = subscribe((newLocale) => {\n *   console.log('Locale changed to', newLocale);\n * });\n *\n * document.querySelector('#lang-switcher').addEventListener('change', (e) => {\n *   setLocale(e.target.value);\n * });\n * ```\n */\nexport const useLocale = (props: UseLocaleProps = {}): UseLocaleResult => {\n  const client = getIntlayerClient();\n\n  const setLocale = (newLocale: LocalesValues): void => {\n    if (!(availableLocales ?? []).map(String).includes(newLocale)) {\n      console.error(`Locale \"${newLocale}\" is not available.`);\n      return;\n    }\n\n    client.setLocale(newLocale);\n\n    setLocaleInStorage(\n      newLocale,\n      props.isCookieEnabled ?? client.isCookieEnabled ?? true\n    );\n\n    props.onLocaleChange?.(newLocale as DeclaredLocales);\n  };\n\n  return {\n    locale: client.locale as DeclaredLocales,\n    defaultLocale: defaultLocale as DeclaredLocales,\n    availableLocales: (availableLocales ?? []) as DeclaredLocales[],\n    setLocale,\n    subscribe: (callback) => client.subscribe(callback),\n  };\n};\n"],"mappings":";;;;;AAqBA,MAAM,EAAE,eAAe,SAAS,qBAAqB,wBAAwB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6B9E,MAAa,aAAa,QAAwB,CAAC,MAAuB;CACxE,MAAM,SAAS,kBAAkB;CAEjC,MAAM,aAAa,cAAmC;EACpD,IAAI,EAAE,oBAAoB,CAAC,EAAC,CAAE,IAAI,MAAM,CAAC,CAAC,SAAS,SAAS,GAAG;GAC7D,QAAQ,MAAM,WAAW,UAAU,oBAAoB;GACvD;EACF;EAEA,OAAO,UAAU,SAAS;EAE1B,mBACE,WACA,MAAM,mBAAmB,OAAO,mBAAmB,IACrD;EAEA,MAAM,iBAAiB,SAA4B;CACrD;CAEA,OAAO;EACL,QAAQ,OAAO;EACA;EACf,kBAAmB,oBAAoB,CAAC;EACxC;EACA,YAAY,aAAa,OAAO,UAAU,QAAQ;CACpD;AACF"}

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

@@ -1,7 +1,7 @@
 import { LocalesValues, ProviderVariant } from "@intlayer/types/module_augmentation";
 //#region src/client/installIntlayer.d.ts
 type LocaleListener = (locale: LocalesValues) => void;
-declare class IntlayerClient {
+export declare class IntlayerClient {
   private _locale;
   private _variant;
   private _listeners;
@@ -25,11 +25,11 @@ declare class IntlayerClient {
 /**
  * Create and return a single IntlayerClient instance.
  */
-declare const createIntlayerClient: (locale?: LocalesValues, isCookieEnabled?: boolean, variant?: ProviderVariant) => IntlayerClient;
+export declare const createIntlayerClient: (locale?: LocalesValues, isCookieEnabled?: boolean, variant?: ProviderVariant) => IntlayerClient;
 /**
  * Get the current IntlayerClient instance, creating one with defaults if needed.
  */
-declare const getIntlayerClient: () => IntlayerClient;
+export declare const getIntlayerClient: () => IntlayerClient;
 /**
  * Install Intlayer into your vanilla JS application.
  *
@@ -66,11 +66,10 @@ declare const getIntlayerClient: () => IntlayerClient;
  * installIntlayer('en');
  * ```
  */
-declare const installIntlayer: ({ locale, isCookieEnabled, variant }?: {
+export declare const installIntlayer: ({ locale, isCookieEnabled, variant }?: {
   locale?: LocalesValues;
   isCookieEnabled?: boolean;
   variant?: ProviderVariant;
 }) => IntlayerClient;
 //#endregion
-export { IntlayerClient, createIntlayerClient, getIntlayerClient, installIntlayer };
 //# sourceMappingURL=installIntlayer.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"installIntlayer.d.ts","names":[],"sources":["../../../src/client/installIntlayer.ts"],"mappings":";;KAQK,kBAAkB,QAAQ;cAElB;UACH;UACA;UACA;EACR;EAEA,YACE,SAAS,eACT,2BACA,UAAU;MAYR,UAAU;;;;;MAQV,WAAW;EAIf,UAAU,WAAW;EAOrB,WAAW,YAAY;EAKvB,UAAU,UAAU;;;;;EAWpB;;;;;cAeW,uBAAoB,SACtB,eAAa,2BAAA,UAEZ,oBACT;;;;cAUU,yBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA2CxB,oBAAe,QAAA,iBAAA;EAK1B,SAAS;EACT;EACA,UAAU;MACH"}
+{"version":3,"file":"installIntlayer.d.ts","names":[],"sources":["../../../src/client/installIntlayer.ts"],"mappings":";;KAQK,kBAAkB,QAAQ;qBAElB;UACH;UACA;UACA;EACR;EAEA,YACE,SAAS,eACT,2BACA,UAAU;MAYR,UAAU;;;;;MAQV,WAAW;EAIf,UAAU,WAAW;EAOrB,WAAW,YAAY;EAKvB,UAAU,UAAU;;;;;EAWpB;;;;;qBAeW,uBAAoB,SACtB,eAAa,2BAAA,UAEZ,oBACT;;;;qBAUU,yBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA2CxB,oBAAe,QAAA,iBAAA;EAK1B,SAAS;EACT;EACA,UAAU;MACH"}

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

@@ -2,7 +2,7 @@ import { DeepTransformContent } from "../plugins.js";
 import { DeclaredLocales, ExtractSelectorLocale, LocalesValues } from "@intlayer/types/module_augmentation";
 import { Dictionary, DictionarySelectorForGroup, QualifiedDictionaryGroup, ResolveQualifiedDictionaryContent } from "@intlayer/types/dictionary";
 //#region src/client/useDictionary.d.ts
-type WithOnChange<T> = T & {
+export type WithOnChange<T> = T & {
   /**
    * Subscribe to locale changes. The callback receives the fresh content
    * whenever the active locale changes. Returns the content object itself
@@ -28,7 +28,6 @@ type WithOnChange<T> = T & {
  * @param localeOrSelector - Optional locale or selector.
  * @returns The current content with an `.onChange()` method.
  */
-declare const useDictionary: <const T extends Dictionary | QualifiedDictionaryGroup, const A extends LocalesValues | DictionarySelectorForGroup<T> = DeclaredLocales>(dictionary: T, localeOrSelector?: A) => WithOnChange<DeepTransformContent<ResolveQualifiedDictionaryContent<T, A>, ExtractSelectorLocale<A>>>;
+export declare const useDictionary: <const T extends Dictionary | QualifiedDictionaryGroup, const A extends LocalesValues | DictionarySelectorForGroup<T> = DeclaredLocales>(dictionary: T, localeOrSelector?: A) => WithOnChange<DeepTransformContent<ResolveQualifiedDictionaryContent<T, A>, ExtractSelectorLocale<A>>>;
 //#endregion
-export { WithOnChange, 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":";;;;KAiBY,aAAa,KAAK;;;;;;;;;;;;EAY5B,WAAW,WAAW,0BAA0B,aAAa;;;;;;;;;;;;;;cAelD,sBACL,UAAU,aAAa,gCACvB,UACF,gBACA,2BAA2B,KAAK,iBAAe,YAEvC,GAAC,mBACM,MAClB,aACD,qBACE,kCAAkC,GAAG,IACrC,sBAAsB"}
+{"version":3,"file":"useDictionary.d.ts","names":[],"sources":["../../../src/client/useDictionary.ts"],"mappings":";;;;YAiBY,aAAa,KAAK;;;;;;;;;;;;EAY5B,WAAW,WAAW,0BAA0B,aAAa;;;;;;;;;;;;;;qBAelD,sBACL,UAAU,aAAa,gCACvB,UACF,gBACA,2BAA2B,KAAK,iBAAe,YAEvC,GAAC,mBACM,MAClB,aACD,qBACE,kCAAkC,GAAG,IACrC,sBAAsB"}

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

@@ -17,7 +17,6 @@ import { QualifiedDynamicLoaderMap } from "@intlayer/core/dictionaryManipulator"
  * @param key               - Dictionary key (used for cache namespacing).
  * @param localeOrSelector  - Optional locale or selector.
  */
-declare const useDictionaryDynamic: <const T extends Dictionary, const K extends DictionaryKeys, const A extends LocalesValues | DictionarySelectorForKey<K> = DeclaredLocales>(dictionaryLoaders: StrictModeLocaleMap<() => Promise<T>> | QualifiedDynamicLoaderMap, key: K, localeOrSelector?: A) => WithOnChange<DeepTransformContent<T['content']>>;
+export declare const useDictionaryDynamic: <const T extends Dictionary, const K extends DictionaryKeys, const A extends LocalesValues | DictionarySelectorForKey<K> = DeclaredLocales>(dictionaryLoaders: StrictModeLocaleMap<() => Promise<T>> | QualifiedDynamicLoaderMap, key: K, localeOrSelector?: A) => WithOnChange<DeepTransformContent<T['content']>>;
 //#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":";;;;;;;;;;;;;;;;;;;cA2Ea,6BACL,UAAU,kBACV,UAAU,sBACV,UAAU,gBAAgB,yBAAyB,KAAK,iBAAe,mBAGzE,0BAA0B,QAAQ,MAClC,2BAAyB,KACxB,GAAC,mBACa,MAClB,aAAa,qBAAqB"}
+{"version":3,"file":"useDictionaryDynamic.d.ts","names":[],"sources":["../../../src/client/useDictionaryDynamic.ts"],"mappings":";;;;;;;;;;;;;;;;;;;qBA2Ea,6BACL,UAAU,kBACV,UAAU,sBACV,UAAU,gBAAgB,yBAAyB,KAAK,iBAAe,mBAGzE,0BAA0B,QAAQ,MAClC,2BAAyB,KACxB,GAAC,mBACa,MAClB,aAAa,qBAAqB"}

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

@@ -29,7 +29,6 @@ import { DeclaredLocales, DictionaryKeys, DictionaryRegistryResult, DictionarySe
  * const faq2 = useIntlayer('faq', { item: 2 });
  * ```
  */
-declare const useIntlayer: <const T extends DictionaryKeys, const A extends LocalesValues | DictionarySelectorForKey<T> = DeclaredLocales>(key: T, localeOrSelector?: A) => WithOnChange<DeepTransformContent<DictionaryRegistryResult<T, A>, ExtractSelectorLocale<A>>>;
+export declare const useIntlayer: <const T extends DictionaryKeys, const A extends LocalesValues | DictionarySelectorForKey<T> = DeclaredLocales>(key: T, localeOrSelector?: A) => WithOnChange<DeepTransformContent<DictionaryRegistryResult<T, A>, 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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA0Ca,oBACL,UAAU,sBACV,UAAU,gBAAgB,yBAAyB,KAAK,iBAAe,KAExE,GAAC,mBACa,MAClB,aACD,qBAAqB,yBAAyB,GAAG,IAAI,sBAAsB"}
+{"version":3,"file":"useIntlayer.d.ts","names":[],"sources":["../../../src/client/useIntlayer.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA0Ca,oBACL,UAAU,sBACV,UAAU,gBAAgB,yBAAyB,KAAK,iBAAe,KAExE,GAAC,mBACa,MAClB,aACD,qBAAqB,yBAAyB,GAAG,IAAI,sBAAsB"}

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

@@ -1,10 +1,10 @@
 import { DeclaredLocales, LocalesValues } from "@intlayer/types/module_augmentation";
 //#region src/client/useLocale.d.ts
-type UseLocaleProps = {
+export type UseLocaleProps = {
   isCookieEnabled?: boolean;
   onLocaleChange?: (locale: DeclaredLocales) => void;
 };
-type UseLocaleResult = {
+export type UseLocaleResult = {
   locale: DeclaredLocales;
   defaultLocale: DeclaredLocales;
   availableLocales: DeclaredLocales[];
@@ -38,7 +38,6 @@ type UseLocaleResult = {
  * });
  * ```
  */
-declare const useLocale: (props?: UseLocaleProps) => UseLocaleResult;
+export declare const useLocale: (props?: UseLocaleProps) => UseLocaleResult;
 //#endregion
-export { UseLocaleProps, UseLocaleResult, 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":";;KAQY;EACV;EACA,kBAAkB,QAAQ;;KAGhB;EACV,QAAQ;EACR,eAAe;EACf,kBAAkB;EAClB,YAAY,QAAQ;EACpB,YAAY,WAAW,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA8BpB,YAAS,QAAW,mBAAsB"}
+{"version":3,"file":"useLocale.d.ts","names":[],"sources":["../../../src/client/useLocale.ts"],"mappings":";;YAQY;EACV;EACA,kBAAkB,QAAQ;;YAGhB;EACV,QAAQ;EACR,eAAe;EACf,kBAAkB;EAClB,YAAY,QAAQ;EACpB,YAAY,WAAW,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAgCpB,YAAS,QAAW,mBAAsB"}

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

@@ -3,30 +3,29 @@ import { LocalesValues } from "@intlayer/types/module_augmentation";
 /**
  * Get the current locale from storage (cookie or localStorage).
  */
-declare const localeInStorage: import("intlayer").Locale;
+export declare const localeInStorage: import("@intlayer/types").Locale;
 /**
  * @deprecated Use localeInStorage instead.
  */
-declare const localeCookie: import("intlayer").Locale;
+export declare const localeCookie: import("@intlayer/types").Locale;
 /**
  * Persist the locale to storage (cookie and/or localStorage).
  */
-declare const setLocaleInStorage: (locale: LocalesValues, isCookieEnabled: boolean) => void;
+export declare const setLocaleInStorage: (locale: LocalesValues, isCookieEnabled: boolean) => void;
 /**
  * @deprecated Use setLocaleInStorage instead.
  */
-declare const setLocaleCookie: typeof setLocaleInStorage;
+export declare const setLocaleCookie: typeof setLocaleInStorage;
 /**
  * Returns the current locale from storage and a setter.
  */
-declare const useLocaleStorage: (isCookieEnabled?: boolean) => {
-  localeStorage: import("intlayer").Locale;
+export declare const useLocaleStorage: (isCookieEnabled?: boolean) => {
+  localeStorage: import("@intlayer/types").Locale;
   setLocaleStorage: (locale: LocalesValues) => void;
 };
 /**
  * @deprecated Use useLocaleStorage instead.
  */
-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":";;;;;cAWa,oCAAe;;;;cAKf,iCAAY;;;;cAKZ,qBAAkB,QACrB,eAAa;;;;cAWV,wBAAe;;;;cAKf,mBAAgB;EAOzB,kCAAa;EACb,mBAAgB,QAAA;;;;;cAOP,wBAAe"}
+{"version":3,"file":"useLocaleStorage.d.ts","names":[],"sources":["../../../src/client/useLocaleStorage.ts"],"mappings":";;;;;qBAWa,2CAAe;;;;qBAKf,wCAAY;;;;qBAKZ,qBAAkB,QACrB,eAAa;;;;qBAWV,wBAAe;;;;qBAKf,mBAAgB;EAOzB,yCAAa;EACb,mBAAgB,QAAA;;;;;qBAOP,wBAAe"}

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

@@ -1,5 +1,5 @@
 //#region src/client/usePathname.d.ts
-type UsePathnameResult = {
+export type UsePathnameResult = {
   /** Current pathname without the locale prefix. */
   pathname: string;
   /**
@@ -30,7 +30,6 @@ type UsePathnameResult = {
  * });
  * ```
  */
-declare const usePathname: () => UsePathnameResult;
+export declare const usePathname: () => UsePathnameResult;
 //#endregion
-export { UsePathnameResult, 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":";KAEY;;EAEV;;;;;;;EAOA,YAAY,WAAW;;;;;;;;;;;;;;;;;;;;;;cAuBZ,mBAAkB"}
+{"version":3,"file":"usePathname.d.ts","names":[],"sources":["../../../src/client/usePathname.ts"],"mappings":";YAEY;;EAEV;;;;;;;EAOA,YAAY,WAAW;;;;;;;;;;;;;;;;;;;;;;qBAuBZ,mBAAkB"}

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

@@ -21,7 +21,6 @@
  * unsubscribe();
  * ```
  */
-declare const useRewriteURL: () => (() => void);
+export declare const useRewriteURL: () => (() => void);
 //#endregion
-export { useRewriteURL };
 //# sourceMappingURL=useRewriteURL.d.ts.map

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

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

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

@@ -17,7 +17,6 @@
  * const stopEditor = useEditor();
  * ```
  */
-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.ts"],"mappings":";;;;;;;;;;;;;;;;;;;cAwBa"}
+{"version":3,"file":"useEditor.d.ts","names":[],"sources":["../../../src/editor/useEditor.ts"],"mappings":";;;;;;;;;;;;;;;;;;;qBAwBa"}

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

@@ -1,6 +1,5 @@
 import { compact } from "@intlayer/core/formatters";
 //#region src/format/useCompact.d.ts
-declare const useCompact: () => (...args: Parameters<typeof compact>) => string;
+export declare const useCompact: () => (...args: Parameters<typeof compact>) => 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":";;cAGa,sBAAU,MAGJ,kBAAkB"}
+{"version":3,"file":"useCompact.d.ts","names":[],"sources":["../../../src/format/useCompact.ts"],"mappings":";;qBAGa,sBAAU,MAGJ,kBAAkB"}

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

@@ -1,6 +1,5 @@
 import { currency } from "@intlayer/core/formatters";
 //#region src/format/useCurrency.d.ts
-declare const useCurrency: () => (...args: Parameters<typeof currency>) => string;
+export declare const useCurrency: () => (...args: Parameters<typeof currency>) => 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":";;cAGa,uBAAW,MAGL,kBAAkB"}
+{"version":3,"file":"useCurrency.d.ts","names":[],"sources":["../../../src/format/useCurrency.ts"],"mappings":";;qBAGa,uBAAW,MAGL,kBAAkB"}

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

@@ -3,7 +3,6 @@ import { date } from "@intlayer/core/formatters";
 /**
  * Vanilla JS hook that provides a localized date/time formatter.
  */
-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":";;;;;cAMa,mBAAO,MAGD,kBAAkB"}
+{"version":3,"file":"useDate.d.ts","names":[],"sources":["../../../src/format/useDate.ts"],"mappings":";;;;;qBAMa,mBAAO,MAGD,kBAAkB"}

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

@@ -26,10 +26,9 @@ import { WrappedIntl } from "@intlayer/core/utils";
  * });
  * ```
  */
-declare const useIntl: (locale?: LocalesValues) => {
+export declare const useIntl: (locale?: LocalesValues) => {
   intl: WrappedIntl;
   subscribe: (callback: (intl: WrappedIntl) => void) => () => void;
 };
 //#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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;cA6Ba,UAAO,SACT;EAET,MAAM;EACN,YAAY,WAAW,MAAM"}
+{"version":3,"file":"useIntl.d.ts","names":[],"sources":["../../../src/format/useIntl.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA6Ba,UAAO,SACT;EAET,MAAM;EACN,YAAY,WAAW,MAAM"}

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

@@ -1,6 +1,5 @@
 import { list } from "@intlayer/core/formatters";
 //#region src/format/useList.d.ts
-declare const useList: () => (...args: Parameters<typeof list>) => string;
+export declare const useList: () => (...args: Parameters<typeof list>) => 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":";;cAGa,mBAAO,MAGD,kBAAkB"}
+{"version":3,"file":"useList.d.ts","names":[],"sources":["../../../src/format/useList.ts"],"mappings":";;qBAGa,mBAAO,MAGD,kBAAkB"}

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

@@ -3,7 +3,6 @@ import { number } from "@intlayer/core/formatters";
 /**
  * Vanilla JS hook that provides a localized number formatter.
  */
-declare const useNumber: () => (...args: Parameters<typeof number>) => string;
+export declare const useNumber: () => (...args: Parameters<typeof number>) => 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":";;;;;cAMa,qBAAS,MAGH,kBAAkB"}
+{"version":3,"file":"useNumber.d.ts","names":[],"sources":["../../../src/format/useNumber.ts"],"mappings":";;;;;qBAMa,qBAAS,MAGH,kBAAkB"}

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

@@ -1,6 +1,5 @@
 import { percentage } from "@intlayer/core/formatters";
 //#region src/format/usePercentage.d.ts
-declare const usePercentage: () => (...args: Parameters<typeof percentage>) => string;
+export declare const usePercentage: () => (...args: Parameters<typeof percentage>) => 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":";;cAGa,yBAAa,MAGP,kBAAkB"}
+{"version":3,"file":"usePercentage.d.ts","names":[],"sources":["../../../src/format/usePercentage.ts"],"mappings":";;qBAGa,yBAAa,MAGP,kBAAkB"}

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

@@ -1,6 +1,5 @@
 import { relativeTime } from "@intlayer/core/formatters";
 //#region src/format/useRelativeTime.d.ts
-declare const useRelativeTime: () => (...args: Parameters<typeof relativeTime>) => string;
+export declare const useRelativeTime: () => (...args: Parameters<typeof relativeTime>) => 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":";;cAGa,2BAAe,MAGT,kBAAkB"}
+{"version":3,"file":"useRelativeTime.d.ts","names":[],"sources":["../../../src/format/useRelativeTime.ts"],"mappings":";;qBAGa,2BAAe,MAGT,kBAAkB"}

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

@@ -1,6 +1,5 @@
 import { units } from "@intlayer/core/formatters";
 //#region src/format/useUnit.d.ts
-declare const useUnit: () => (...args: Parameters<typeof units>) => string;
+export declare const useUnit: () => (...args: Parameters<typeof units>) => 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":";;cAGa,mBAAO,MAGD,kBAAkB"}
+{"version":3,"file":"useUnit.d.ts","names":[],"sources":["../../../src/format/useUnit.ts"],"mappings":";;qBAGa,mBAAO,MAGD,kBAAkB"}

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/HTMLRenderer.d.ts

@@ -1,18 +1,17 @@
 import { HTMLComponents } from "./types.js";
 //#region src/html/HTMLRenderer.d.ts
-type RenderHTMLProps = {
+export type RenderHTMLProps = {
   components?: HTMLComponents<'permissive', {}>;
 };
 /**
  * Renders an HTML string directly, without a global provider.
  * Returns the raw string unchanged.
  */
-declare const renderHTML: (content: string, _props?: RenderHTMLProps) => string;
+export declare const renderHTML: (content: string, _props?: RenderHTMLProps) => string;
 /**
  * Returns a render function that uses the global provider's configuration
  * (installed via `installIntlayerHTML`), falling back to identity.
  */
-declare const useHTMLRenderer: ({ components }?: RenderHTMLProps) => ((content: string) => string);
+export declare const useHTMLRenderer: ({ components }?: RenderHTMLProps) => ((content: string) => string);
 //#endregion
-export { 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.ts"],"mappings":";;KAGY;EACV,aAAa;;;;;;cAOF,aAAU,iBACN,SACP;;;;;cAOG,oBAAe,eAEzB,sBAAyB"}
+{"version":3,"file":"HTMLRenderer.d.ts","names":[],"sources":["../../../src/html/HTMLRenderer.ts"],"mappings":";;YAGY;EACV,aAAa;;;;;;qBAOF,aAAU,iBACN,SACP;;;;;qBAOG,oBAAe,eAEzB,sBAAyB"}

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

@@ -1,20 +1,20 @@
 import { HTMLComponents } from "./types.js";
 //#region src/html/installIntlayerHTML.d.ts
-type RenderHTMLOptions = {
+export type RenderHTMLOptions = {
   components?: HTMLComponents<'permissive', {}>;
 };
-type RenderHTMLFunction = (html: string, overrides?: HTMLComponents<'permissive', {}> | RenderHTMLOptions) => string;
-type IntlayerHTMLProvider = {
+export type RenderHTMLFunction = (html: string, overrides?: HTMLComponents<'permissive', {}> | RenderHTMLOptions) => string;
+export type IntlayerHTMLProvider = {
   renderHTML: RenderHTMLFunction;
 };
-type IntlayerHTMLPluginOptions = {
+export type IntlayerHTMLPluginOptions = {
   components?: HTMLComponents<'permissive', {}>;
   renderHTML?: RenderHTMLFunction;
 };
 /**
  * Create and return a single IntlayerHTMLProvider instance.
  */
-declare const createIntlayerHTMLClient: (renderHTML: RenderHTMLFunction) => IntlayerHTMLProvider;
+export declare const createIntlayerHTMLClient: (renderHTML: RenderHTMLFunction) => IntlayerHTMLProvider;
 /**
  * Install the Intlayer HTML provider for your vanilla JS application.
  *
@@ -29,13 +29,13 @@ declare const createIntlayerHTMLClient: (renderHTML: RenderHTMLFunction) => Intl
  * });
  * ```
  */
-declare const installIntlayerHTML: (pluginOptions?: IntlayerHTMLPluginOptions | RenderHTMLFunction) => IntlayerHTMLProvider;
+export declare const installIntlayerHTML: (pluginOptions?: IntlayerHTMLPluginOptions | RenderHTMLFunction) => IntlayerHTMLProvider;
 /**
  * Access the installed IntlayerHTMLProvider.
  * Returns a fallback renderer that outputs the raw HTML string if no
  * provider has been installed.
  */
-declare const useHTML: () => IntlayerHTMLProvider;
+export declare const useHTML: () => IntlayerHTMLProvider;
 /**
  * Asynchronously install an HTML renderer whose implementation is loaded
  * via a dynamic `import()`.
@@ -60,7 +60,6 @@ declare const useHTML: () => IntlayerHTMLProvider;
  * });
  * ```
  */
-declare const installIntlayerHTMLDynamic: (loader: () => Promise<IntlayerHTMLPluginOptions | RenderHTMLFunction>) => Promise<IntlayerHTMLProvider>;
+export declare const installIntlayerHTMLDynamic: (loader: () => Promise<IntlayerHTMLPluginOptions | RenderHTMLFunction>) => Promise<IntlayerHTMLProvider>;
 //#endregion
-export { IntlayerHTMLPluginOptions, IntlayerHTMLProvider, RenderHTMLFunction, RenderHTMLOptions, createIntlayerHTMLClient, installIntlayerHTML, installIntlayerHTMLDynamic, useHTML };
 //# sourceMappingURL=installIntlayerHTML.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"installIntlayerHTML.d.ts","names":[],"sources":["../../../src/html/installIntlayerHTML.ts"],"mappings":";;KAEY;EACV,aAAa;;KAGH,sBACV,cACA,YAAY,mCAAmC;KAQrC;EACV,YAAY;;KAGF;EACV,aAAa;EACb,aAAa;;;;;cAMF,2BAAwB,YACvB,uBACX;;;;;;;;;;;;;;;cAoBU,sBAAmB,gBACd,4BAA4B,uBAC3C;;;;;;cA2CU,eAAc;;;;;;;;;;;;;;;;;;;;;;;;;cA6Bd,6BAA0B,cACvB,QAAQ,4BAA4B,wBACjD,QAAQ"}
+{"version":3,"file":"installIntlayerHTML.d.ts","names":[],"sources":["../../../src/html/installIntlayerHTML.ts"],"mappings":";;YAEY;EACV,aAAa;;YAGH,sBACV,cACA,YAAY,mCAAmC;YAQrC;EACV,YAAY;;YAGF;EACV,aAAa;EACb,aAAa;;;;;qBAMF,2BAAwB,YACvB,uBACX;;;;;;;;;;;;;;;qBAoBU,sBAAmB,gBACd,4BAA4B,uBAC3C;;;;;;qBA2CU,eAAc;;;;;;;;;;;;;;;;;;;;;;;;;qBA6Bd,6BAA0B,cACvB,QAAQ,4BAA4B,wBACjD,QAAQ"}

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

@@ -26,14 +26,13 @@ type RestHTMLComponents<T> = { [K in Exclude<keyof HTMLTagsType, keyof T>]?: Van
 /**
  * The supported modes for the HTMLComponents type.
  */
-type HTMLComponentMode = 'permissive' | 'optional' | 'inclusive' | 'strict';
+export type HTMLComponentMode = 'permissive' | 'optional' | 'inclusive' | 'strict';
 /**
  * Component map for HTML rendering in vanilla JS.
  * Each component receives props and children and returns an HTML string.
  */
-type HTMLComponents<Mode extends HTMLComponentMode = 'optional', T = {}> = Mode extends 'strict' ? DefinedComponents<T, true> : Mode extends 'inclusive' ? DefinedComponents<T, true> & RestHTMLComponents<T> : Mode extends 'permissive' ? DefinedComponents<T, false> & RestHTMLComponents<T> & {
+export type HTMLComponents<Mode extends HTMLComponentMode = 'optional', T = {}> = Mode extends 'strict' ? DefinedComponents<T, true> : Mode extends 'inclusive' ? DefinedComponents<T, true> & RestHTMLComponents<T> : Mode extends 'permissive' ? DefinedComponents<T, false> & RestHTMLComponents<T> & {
   [key: string]: VanillaHTMLComponent;
 } : 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":";;;;;KAKK,gBAAgB,SAAS,0BAE1B,uBACE;;;;;KAOD,eAAe;EAClB;;;;;KAMG,qBAAqB,WAAW,OAAO,IAAI;;;;KAK3C,kBAAkB,GAAG,8BAA8B,6BAEjD,WAAW,IAAI,qBAAqB,gBAAgB,EAAE,aAGtD,WAAW,KAAK,qBAAqB,gBAAgB,EAAE;;;;KAMzD,mBAAmB,QACrB,KAAK,cAAc,oBAAoB,MAAM;;;;KAMpC;;;;;KAUA,eACV,aAAa,gCACb,UACE,wBACA,kBAAkB,WAClB,2BACE,kBAAkB,WAAW,mBAAmB,KAChD,4BACE,kBAAkB,YAChB,mBAAmB;GAChB,cAAc;IAEnB,kBAAkB,YAAY,mBAAmB"}
+{"version":3,"file":"types.d.ts","names":[],"sources":["../../../src/html/types.ts"],"mappings":";;;;;KAKK,gBAAgB,SAAS,0BAE1B,uBACE;;;;;KAOD,eAAe;EAClB;;;;;KAMG,qBAAqB,WAAW,OAAO,IAAI;;;;KAK3C,kBAAkB,GAAG,8BAA8B,6BAEjD,WAAW,IAAI,qBAAqB,gBAAgB,EAAE,aAGtD,WAAW,KAAK,qBAAqB,gBAAgB,EAAE;;;;KAMzD,mBAAmB,QACrB,KAAK,cAAc,oBAAoB,MAAM;;;;YAMpC;;;;;YAUA,eACV,aAAa,gCACb,UACE,wBACA,kBAAkB,WAClB,2BACE,kBAAkB,WAAW,mBAAmB,KAChD,4BACE,kBAAkB,YAChB,mBAAmB;GAChB,cAAc;IAEnB,kBAAkB,YAAY,mBAAmB"}

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

@@ -2,7 +2,7 @@ import { HTMLComponents } from "../html/types.js";
 import { ParsedMarkdown } from "./compiler.js";
 import { MarkdownProviderOptions } from "./installIntlayerMarkdown.js";
 //#region src/markdown/MarkdownRenderer.d.ts
-type RenderMarkdownProps = MarkdownProviderOptions & {
+export type RenderMarkdownProps = MarkdownProviderOptions & {
   components?: HTMLComponents<'permissive', {}>;
   wrapper?: string;
 };
@@ -16,12 +16,11 @@ type RenderMarkdownProps = MarkdownProviderOptions & {
  * document.querySelector('#content').innerHTML = renderMarkdown('# Hello **World**');
  * ```
  */
-declare const renderMarkdown: (content: string | ParsedMarkdown, { forceBlock, forceInline, preserveFrontmatter, tagfilter }?: RenderMarkdownProps) => string;
+export declare const renderMarkdown: (content: string | ParsedMarkdown, { forceBlock, forceInline, preserveFrontmatter, tagfilter }?: RenderMarkdownProps) => string;
 /**
  * Returns a render function that uses the global provider's configuration
  * (installed via `installIntlayerMarkdown`), falling back to `compileMarkdown`.
  */
-declare const useMarkdownRenderer: (props?: RenderMarkdownProps) => ((content: string | ParsedMarkdown) => string | Promise<string>);
+export declare const useMarkdownRenderer: (props?: RenderMarkdownProps) => ((content: string | ParsedMarkdown) => string | Promise<string>);
 //#endregion
-export { 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.ts"],"mappings":";;;;KAYY,sBAAsB;EAChC,aAAa;EACb;;;;;;;;;;;;cAaW,iBAAc,kBACP,kBAAc,YAAA,aAAA,qBAAA,cAM7B;;;;;cAeQ,sBAAmB,QACvB,0BACJ,kBAAkB,4BAA4B"}
+{"version":3,"file":"MarkdownRenderer.d.ts","names":[],"sources":["../../../src/markdown/MarkdownRenderer.ts"],"mappings":";;;;YAYY,sBAAsB;EAChC,aAAa;EACb;;;;;;;;;;;;qBAaW,iBAAc,kBACP,kBAAc,YAAA,aAAA,qBAAA,cAM7B;;;;;qBAeQ,sBAAmB,QACvB,0BACJ,kBAAkB,4BAA4B"}

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;
  * document.querySelector('#content').innerHTML = compileMarkdown(ast);
  * ```
  */
-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
@@ -40,7 +40,7 @@ declare const parseMarkdown: (markdown?: string, options?: MarkdownCompilerOptio
  *   compileMarkdown('# Hello **World**');
  * ```
  */
-declare const compileMarkdown: (input?: string | ParsedMarkdown, options?: MarkdownCompilerOptions) => string;
+export declare const compileMarkdown: (input?: string | ParsedMarkdown, options?: MarkdownCompilerOptions) => string;
 //#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":";;;;;;KAqBY,0BAA0B;;;;;;;;;;;;;;;;;;;cA2BzB,gBAAa,mBACR,UACP,4BACR;;;;;;;;;;;;;;;;;cAoCU,kBAAe,iBACV,gBAAc,UACrB"}
+{"version":3,"file":"compiler.d.ts","names":[],"sources":["../../../src/markdown/compiler.ts"],"mappings":";;;;;;YAqBY,0BAA0B;;;;;;;;;;;;;;;;;;;qBA2BzB,gBAAa,mBACR,UACP,4BACR;;;;;;;;;;;;;;;;;qBAoCU,kBAAe,iBACV,gBAAc,UACrB"}

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

@@ -1,7 +1,7 @@
 import { HTMLComponents } from "../html/types.js";
 import { ParsedMarkdown } from "./compiler.js";
 //#region src/markdown/installIntlayerMarkdown.d.ts
-type MarkdownProviderOptions = {
+export type MarkdownProviderOptions = {
   /** Forces the compiler to always output content with a block-level wrapper. */
   forceBlock?: boolean;
   /** Forces the compiler to always output content with an inline wrapper. */
@@ -11,16 +11,16 @@ type MarkdownProviderOptions = {
   /** Whether to use the GitHub Tag Filter. */
   tagfilter?: boolean;
 };
-type RenderMarkdownOptions = MarkdownProviderOptions & {
+export type RenderMarkdownOptions = MarkdownProviderOptions & {
   components?: HTMLComponents<'permissive', {}>;
   wrapper?: string;
 };
-type RenderMarkdownFunction = (markdown: string | ParsedMarkdown, options?: MarkdownProviderOptions, components?: HTMLComponents<'permissive', {}>, wrapper?: string) => string | Promise<string>;
-type IntlayerMarkdownProvider = {
+export type RenderMarkdownFunction = (markdown: string | ParsedMarkdown, options?: MarkdownProviderOptions, components?: HTMLComponents<'permissive', {}>, wrapper?: string) => string | Promise<string>;
+export type IntlayerMarkdownProvider = {
   components?: HTMLComponents<'permissive', {}>;
   renderMarkdown: RenderMarkdownFunction;
 };
-type IntlayerMarkdownPluginOptions = MarkdownProviderOptions & {
+export type IntlayerMarkdownPluginOptions = MarkdownProviderOptions & {
   components?: HTMLComponents<'permissive', {}>;
   wrapper?: string;
   renderMarkdown?: RenderMarkdownFunction;
@@ -28,7 +28,7 @@ type IntlayerMarkdownPluginOptions = MarkdownProviderOptions & {
 /**
  * Create and return a single IntlayerMarkdownProvider instance.
  */
-declare const createIntlayerMarkdownClient: (renderMarkdown: RenderMarkdownFunction, components?: HTMLComponents<'permissive', {}>) => IntlayerMarkdownProvider;
+export declare const createIntlayerMarkdownClient: (renderMarkdown: RenderMarkdownFunction, components?: HTMLComponents<'permissive', {}>) => IntlayerMarkdownProvider;
 /**
  * Install the Intlayer Markdown provider for your vanilla JS application.
  *
@@ -39,13 +39,13 @@ declare const createIntlayerMarkdownClient: (renderMarkdown: RenderMarkdownFunct
  * installIntlayerMarkdown({ forceBlock: true });
  * ```
  */
-declare const installIntlayerMarkdown: (pluginOptions?: IntlayerMarkdownPluginOptions | RenderMarkdownFunction) => IntlayerMarkdownProvider;
+export declare const installIntlayerMarkdown: (pluginOptions?: IntlayerMarkdownPluginOptions | RenderMarkdownFunction) => IntlayerMarkdownProvider;
 /**
  * Access the installed IntlayerMarkdownProvider.
  * Returns a fallback renderer that compiles with default options if no
  * provider has been installed.
  */
-declare const useMarkdown: () => IntlayerMarkdownProvider;
+export declare const useMarkdown: () => IntlayerMarkdownProvider;
 /**
  * Asynchronously install a markdown renderer whose implementation is loaded
  * via a dynamic `import()`.
@@ -69,7 +69,6 @@ declare const useMarkdown: () => IntlayerMarkdownProvider;
  * });
  * ```
  */
-declare const installIntlayerMarkdownDynamic: (loader: () => Promise<IntlayerMarkdownPluginOptions | RenderMarkdownFunction>) => Promise<IntlayerMarkdownProvider>;
+export declare const installIntlayerMarkdownDynamic: (loader: () => Promise<IntlayerMarkdownPluginOptions | RenderMarkdownFunction>) => Promise<IntlayerMarkdownProvider>;
 //#endregion
-export { IntlayerMarkdownPluginOptions, IntlayerMarkdownProvider, MarkdownProviderOptions, RenderMarkdownFunction, RenderMarkdownOptions, createIntlayerMarkdownClient, installIntlayerMarkdown, installIntlayerMarkdownDynamic, useMarkdown };
 //# sourceMappingURL=installIntlayerMarkdown.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"installIntlayerMarkdown.d.ts","names":[],"sources":["../../../src/markdown/installIntlayerMarkdown.ts"],"mappings":";;;KAOY;;EAEV;;EAEA;;EAEA;;EAEA;;KAGU,wBAAwB;EAClC,aAAa;EACb;;KAGU,0BACV,mBAAmB,gBACnB,UAAU,yBACV,aAAa,kCACb,8BACY;KAOF;EACV,aAAa;EACb,gBAAgB;;KAGN,gCAAgC;EAC1C,aAAa;EACb;EACA,iBAAiB;;;;;cAMN,+BAA4B,gBACvB,wBAAsB,aACzB,qCACZ;;;;;;;;;;;cAiBU,0BAAuB,gBAClB,gCAAgC,2BAC/C;;;;;;cAsDU,mBAAkB;;;;;;;;;;;;;;;;;;;;;;;;cAgClB,iCAA8B,cAC3B,QAAQ,gCAAgC,4BACrD,QAAQ"}
+{"version":3,"file":"installIntlayerMarkdown.d.ts","names":[],"sources":["../../../src/markdown/installIntlayerMarkdown.ts"],"mappings":";;;YAOY;;EAEV;;EAEA;;EAEA;;EAEA;;YAGU,wBAAwB;EAClC,aAAa;EACb;;YAGU,0BACV,mBAAmB,gBACnB,UAAU,yBACV,aAAa,kCACb,8BACY;YAOF;EACV,aAAa;EACb,gBAAgB;;YAGN,gCAAgC;EAC1C,aAAa;EACb;EACA,iBAAiB;;;;;qBAMN,+BAA4B,gBACvB,wBAAsB,aACzB,qCACZ;;;;;;;;;;;qBAiBU,0BAAuB,gBAClB,gCAAgC,2BAC/C;;;;;;qBAsDU,mBAAkB;;;;;;;;;;;;;;;;;;;;;;;;qBAgClB,iCAA8B,cAC3B,QAAQ,gCAAgC,4BACrD,QAAQ"}

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

@@ -3,13 +3,13 @@ import { MarkdownRuntime } from "@intlayer/core/markdown";
 /**
  * Vanilla-specific MarkdownRuntime that produces HTML strings.
  */
-declare const vanillaRuntime: MarkdownRuntime;
+export declare const vanillaRuntime: MarkdownRuntime;
 /**
  * Creates a vanilla runtime with a custom createElement for advanced use cases.
  */
-declare const createVanillaRuntime: (options?: {
+export declare const createVanillaRuntime: (options?: {
   onCreateElement?: (type: any, props: Record<string, any> | null, children: any[]) => string;
 }) => MarkdownRuntime;
 //#endregion
-export { createVanillaRuntime, vanillaRuntime as default, vanillaRuntime };
+export { vanillaRuntime 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":";;;;;cA6Ca,gBAAgB;;;;cA6EhB,uBAAoB;EAE7B,mBACE,WACA,OAAO,4BACP;MAGH"}
+{"version":3,"file":"runtime.d.ts","names":[],"sources":["../../../src/markdown/runtime.ts"],"mappings":";;;;;qBA6Ca,gBAAgB;;;;qBA6EhB,uBAAoB;EAE7B,mBACE,WACA,OAAO,4BACP;MAGH"}

package/dist/types/plugins.d.ts

@@ -8,25 +8,25 @@ import { NodeType } from "@intlayer/types/nodeType";
 /** ---------------------------------------------
  * INTLAYER NODE PLUGIN
  * --------------------------------------------- */
-type IntlayerNodeCond<T> = T extends number | string ? IntlayerNode<T> : never;
-type IntlayerNode<T, P = {}> = IntlayerNode$1<T> & P;
-declare const intlayerNodePlugins: Plugins;
+export type IntlayerNodeCond<T> = T extends number | string ? IntlayerNode<T> : never;
+export type IntlayerNode<T, P = {}> = IntlayerNode$1<T> & P;
+export declare const intlayerNodePlugins: 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; }>(values: V) => I extends string ? IntlayerNode<string> : DeepTransformContent<I, L> : never;
-declare const insertionPlugin: Plugins;
-type MarkdownStringCond<T> = T extends string ? IntlayerNode<string, {
+export declare const insertionPlugin: Plugins;
+export type MarkdownStringCond<T> = T extends string ? IntlayerNode<string, {
   metadata: DeepTransformContent<string>;
   /** Returns the rendered markdown; render with .use(). */
   use: (components?: HTMLComponents<'permissive', {}>) => string;
 }> : never;
-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;
@@ -35,22 +35,22 @@ type MarkdownCond<T> = T extends {
   use: (components?: HTMLComponents<'permissive', U>) => IntlayerNode<M>;
   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;
 } ? {
   use: (components?: HTMLComponents<'permissive', U>) => IntlayerNode<I>;
 } : never;
-declare const htmlPlugin: Plugins;
+export declare const htmlPlugin: Plugins;
 /** ---------------------------------------------
  * PLUGINS RESULT
  * --------------------------------------------- */
-interface IInterpreterPluginVanilla<T, S, L extends LocalesValues> {
+export interface IInterpreterPluginVanilla<T, S, L extends LocalesValues> {
   vanillaIntlayerNode: IntlayerNodeCond<T>;
   vanillaInsertion: InsertionCond<T, S, L>;
   vanillaMarkdown: MarkdownCond<T>;
@@ -63,18 +63,17 @@ interface IInterpreterPluginVanilla<T, S, L extends LocalesValues> {
  * Use `getIntlayer` from `vanilla-intlayer` (not from `intlayer`) to get properly typed
  * `IntlayerNode` wrappers with `.value` access on string/number content.
  */
-type IInterpreterPluginState = Omit<IInterpreterPluginState$1, 'insertion'> & {
+export type IInterpreterPluginState = Omit<IInterpreterPluginState$1, 'insertion'> & {
   vanillaIntlayerNode: true;
   vanillaInsertion: true;
   vanillaMarkdown: true;
   vanillaHtml: 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 Vanilla 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, IInterpreterPluginState, IInterpreterPluginVanilla, InsertionCond, IntlayerNode, IntlayerNodeCond, MarkdownCond, MarkdownStringCond, getPlugins, htmlPlugin, insertionPlugin, intlayerNodePlugins, markdownPlugin, markdownStringPlugin };
 //# sourceMappingURL=plugins.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"plugins.d.ts","names":[],"sources":["../../src/plugins.ts"],"mappings":";;;;;;;;;;KA6CY,iBAAiB,KAAK,4BAC9B,aAAa;KAGL,aAAa,GAAG,UAAU,eAAiB,KAAK;cAQ/C,qBAAqB;;;;KAmDtB,cAAc,GAAG,IAAI,UAAU,iBAAiB;EAC1D,UAAU;GACT,UAAU,kBAAkB;EAC7B,wBAAwB;KAErB,aAAa,KAAK,QAAQ,iCACzB,QAAQ,MACL,mBAAmB,uBAAuB,qBAAqB,GAAG;cAG9D,iBAAiB;KA+HlB,mBAAmB,KAAK,mBAChC;EAGI,UAAU;;EAEV,MAAM,aAAa;;cAKd,sBAAsB;KAuEvB,aAAa,KAAK;EAC5B,UAAU;GACT,UAAU,iBAAiB;EAC5B,iBAAiB;EACjB,aAAa;;EAGT,MAAM,aAAa,6BAA6B,OAAO,aAAa;EACpE,UAAU,qBAAqB;;cAIxB,gBAAgB;;;;KA2BjB,eAAe,KAAK;EAC9B,UAAU;GACT,UAAU,aAAa;EACxB,aAAa;;EAGT,MAAM,aAAa,6BAA6B,OAAO,aAAa;;cAI7D,YAAY;;;;UAqER,0BAA0B,GAAG,GAAG,UAAU;EACzD,qBAAqB,iBAAiB;EACtC,kBAAkB,cAAc,GAAG,GAAG;EACtC,iBAAiB,aAAa;EAC9B,aAAa,eAAe;;;;;;;;;KAUlB,0BAA0B,KACpC;EAGA;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.ts"],"mappings":";;;;;;;;;;YA6CY,iBAAiB,KAAK,4BAC9B,aAAa;YAGL,aAAa,GAAG,UAAU,eAAiB,KAAK;qBAQ/C,qBAAqB;;;;YAmDtB,cAAc,GAAG,IAAI,UAAU,iBAAiB;EAC1D,UAAU;GACT,UAAU,kBAAkB;EAC7B,wBAAwB;KAErB,aAAa,KAAK,QAAQ,iCACzB,QAAQ,MACL,mBAAmB,uBAAuB,qBAAqB,GAAG;qBAG9D,iBAAiB;YA+HlB,mBAAmB,KAAK,mBAChC;EAGI,UAAU;;EAEV,MAAM,aAAa;;qBAKd,sBAAsB;YAuEvB,aAAa,KAAK;EAC5B,UAAU;GACT,UAAU,iBAAiB;EAC5B,iBAAiB;EACjB,aAAa;;EAGT,MAAM,aAAa,6BAA6B,OAAO,aAAa;EACpE,UAAU,qBAAqB;;qBAIxB,gBAAgB;;;;YA2BjB,eAAe,KAAK;EAC9B,UAAU;GACT,UAAU,aAAa;EACxB,aAAa;;EAGT,MAAM,aAAa,6BAA6B,OAAO,aAAa;;qBAI7D,YAAY;;;;iBAqER,0BAA0B,GAAG,GAAG,UAAU;EACzD,qBAAqB,iBAAiB;EACtC,kBAAkB,cAAc,GAAG,GAAG;EACtC,iBAAiB,aAAa;EAC9B,aAAa,eAAe;;;;;;;;;YAUlB,0BAA0B,KACpC;EAGA;EACA;EACA;EACA;;YAGU,qBACV,GACA,UAAU,gBAAgB,mBACxB,uBAAyB,GAAG,yBAAyB;;;;;qBAQ5C,aAAU,SACZ,eAAa,uBAErB"}

package/dist/types/renderIntlayerNode.d.ts

@@ -1,6 +1,6 @@
 import { ResolvedEditor } from "@intlayer/types/module_augmentation";
 //#region src/renderIntlayerNode.d.ts
-type IntlayerNode<T = string> = ResolvedEditor<T & {
+export type IntlayerNode<T = string> = ResolvedEditor<T & {
   raw: T;
   value: T;
   toString: () => string;
@@ -15,12 +15,11 @@ type IntlayerNode<T = string> = ResolvedEditor<T & {
   toJSON: () => T;
   __update: (next: IntlayerNode<T>) => void;
 }> & T;
-declare const renderIntlayerNode: <T>({ value, children, additionalProps }: {
+export declare const renderIntlayerNode: <T>({ value, children, additionalProps }: {
   value: T;
   children?: any;
   additionalProps?: Record<string, unknown>;
   [key: string]: unknown;
 }) => IntlayerNode<T>;
 //#endregion
-export { IntlayerNode, renderIntlayerNode };
 //# sourceMappingURL=renderIntlayerNode.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"renderIntlayerNode.d.ts","names":[],"sources":["../../src/renderIntlayerNode.ts"],"mappings":";;KAEY,aAAa,cAAc,eACrC;EACE,KAAK;EACL,OAAO;EACP;EACA,eAAe;EACf,cAAc;EACd,WAAW,MAAM,aAAa;;EAG9B,KAAK;EACL,OAAO;EACP;EACA,eAAe;EACf,cAAc;EACd,WAAW,MAAM,aAAa;KAGhC;cAEW,qBACX,KAAC,OAAA,UAAA;EAMD,OAAO;EACP;EACA,kBAAkB;GACjB;MACC,aAAa"}
+{"version":3,"file":"renderIntlayerNode.d.ts","names":[],"sources":["../../src/renderIntlayerNode.ts"],"mappings":";;YAEY,aAAa,cAAc,eACrC;EACE,KAAK;EACL,OAAO;EACP;EACA,eAAe;EACf,cAAc;EACd,WAAW,MAAM,aAAa;;EAG9B,KAAK;EACL,OAAO;EACP;EACA,eAAe;EACf,cAAc;EACd,WAAW,MAAM,aAAa;KAGhC;qBAEW,qBACX,KAAC,OAAA,UAAA;EAMD,OAAO;EACP;EACA,kBAAkB;GACjB;MACC,aAAa"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vanilla-intlayer",
-  "version": "9.4.3",
+  "version": "9.5.1",
   "private": false,
   "description": "Easily internationalize i18n your Vanilla JS, HTML, and PHP applications with type-safe multilingual content management.",
   "keywords": [
@@ -101,24 +101,24 @@
     "typecheck": "tsc --noEmit --project tsconfig.types.json"
   },
   "dependencies": {
-    "@intlayer/api": "9.4.3",
-    "@intlayer/config": "9.4.3",
-    "@intlayer/core": "9.4.3",
-    "@intlayer/editor": "9.4.3",
-    "@intlayer/types": "9.4.3"
+    "@intlayer/api": "9.5.1",
+    "@intlayer/config": "9.5.1",
+    "@intlayer/core": "9.5.1",
+    "@intlayer/editor": "9.5.1",
+    "@intlayer/types": "9.5.1"
   },
   "devDependencies": {
-    "@types/node": "26.4.1",
+    "@types/node": "26.5.0",
     "@utils/ts-config": "1.0.4",
     "@utils/ts-config-types": "1.0.4",
     "@utils/tsdown-config": "1.0.4",
     "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": {
-    "intlayer": "9.4.3"
+    "intlayer": "9.5.1"
   },
   "peerDependenciesMeta": {
     "intlayer": {