vanilla-intlayer 8.8.0 → 8.9.1

package/dist/{client → types/client}/useDictionaryDynamic.d.ts

@@ -1,7 +1,9 @@
-import { Dictionary } from '@intlayer/types/dictionary';
-import { DictionaryKeys, LocalesValues, StrictModeLocaleMap } from '@intlayer/types/module_augmentation';
-import { DeepTransformContent } from '../plugins';
-import { WithOnChange } from './useDictionary';
+import { DeepTransformContent } from "../plugins.js";
+import { WithOnChange } from "./useDictionary.js";
+import { DictionaryKeys, LocalesValues, StrictModeLocaleMap } from "@intlayer/types/module_augmentation";
+import { Dictionary } from "@intlayer/types/dictionary";
+
+//#region src/client/useDictionaryDynamic.d.ts
 /**
  * Dynamically load and transform a locale-keyed dictionary.
  *
@@ -32,4 +34,7 @@ import { WithOnChange } from './useDictionary';
  * getIntlayerClient().subscribe(() => render());
  * ```
  */
-export declare const useDictionaryDynamic: <T extends Dictionary, K extends DictionaryKeys, L extends LocalesValues = LocalesValues>(dictionaryLoaders: StrictModeLocaleMap<() => Promise<T>>, key: K, locale?: L) => WithOnChange<DeepTransformContent<T["content"], L>>;
+declare const useDictionaryDynamic: <T extends Dictionary, K extends DictionaryKeys, L extends LocalesValues = LocalesValues>(dictionaryLoaders: StrictModeLocaleMap<() => Promise<T>>, key: K, locale?: L) => WithOnChange<DeepTransformContent<T["content"], L>>;
+//#endregion
+export { useDictionaryDynamic };
+//# sourceMappingURL=useDictionaryDynamic.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useDictionaryDynamic.d.ts","names":[],"sources":["../../../src/client/useDictionaryDynamic.ts"],"mappings":";;;;;;;;AAgEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAa,oBAAA,aACD,UAAA,YACA,cAAA,YACA,aAAA,GAAgB,aAAA,EAE1B,iBAAA,EAAmB,mBAAA,OAA0B,OAAA,CAAQ,CAAA,IACrD,GAAA,EAAK,CAAA,EACL,MAAA,GAAS,CAAA,KACR,YAAA,CAAa,oBAAA,CAAqB,CAAA,aAAc,CAAA"}

package/dist/{client → types/client}/useIntlayer.d.ts

@@ -1,6 +1,8 @@
-import { DictionaryKeys, DictionaryRegistryContent, LocalesValues } from '@intlayer/types/module_augmentation';
-import { DeepTransformContent } from '../plugins';
-import { WithOnChange } from './useDictionary';
+import { DeepTransformContent } from "../plugins.js";
+import { WithOnChange } from "./useDictionary.js";
+import { DictionaryKeys, DictionaryRegistryContent, LocalesValues } from "@intlayer/types/module_augmentation";
+
+//#region src/client/useIntlayer.d.ts
 /**
  * Get the translated content for the given key and optionally subscribe to
  * locale changes via the chainable `.onChange()` method — mirroring the API
@@ -46,4 +48,7 @@ import { WithOnChange } from './useDictionary';
  * });
  * ```
  */
-export declare const useIntlayer: <T extends DictionaryKeys>(key: T, locale?: LocalesValues) => WithOnChange<DeepTransformContent<DictionaryRegistryContent<T>>>;
+declare const useIntlayer: <T extends DictionaryKeys>(key: T, locale?: LocalesValues) => WithOnChange<DeepTransformContent<DictionaryRegistryContent<T>>>;
+//#endregion
+export { useIntlayer };
+//# sourceMappingURL=useIntlayer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useIntlayer.d.ts","names":[],"sources":["../../../src/client/useIntlayer.ts"],"mappings":";;;;;;;AAuDA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAa,WAAA,aAAyB,cAAA,EACpC,GAAA,EAAK,CAAA,EACL,MAAA,GAAS,aAAA,KACR,YAAA,CAAa,oBAAA,CAAqB,yBAAA,CAA0B,CAAA"}

package/dist/{client → types/client}/useLocale.d.ts

@@ -1,7 +1,9 @@
-import { DeclaredLocales, LocalesValues } from '@intlayer/types/module_augmentation';
+import { DeclaredLocales, LocalesValues } from "@intlayer/types/module_augmentation";
+
+//#region src/client/useLocale.d.ts
 type UseLocaleProps = {
-    isCookieEnabled?: boolean;
-    onLocaleChange?: (locale: LocalesValues) => void;
+  isCookieEnabled?: boolean;
+  onLocaleChange?: (locale: LocalesValues) => void;
 };
 /**
  * Get the current locale state and locale management utilities.
@@ -30,11 +32,13 @@ type UseLocaleProps = {
  * });
  * ```
  */
-export declare const useLocale: (props?: UseLocaleProps) => {
-    locale: DeclaredLocales;
-    defaultLocale: DeclaredLocales;
-    availableLocales: DeclaredLocales[];
-    setLocale: (newLocale: LocalesValues) => void;
-    subscribe: (callback: (locale: LocalesValues) => void) => () => void;
+declare const useLocale: (props?: UseLocaleProps) => {
+  locale: DeclaredLocales;
+  defaultLocale: DeclaredLocales;
+  availableLocales: DeclaredLocales[];
+  setLocale: (newLocale: LocalesValues) => void;
+  subscribe: (callback: (locale: LocalesValues) => void) => () => void;
 };
-export {};
+//#endregion
+export { useLocale };
+//# sourceMappingURL=useLocale.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useLocale.d.ts","names":[],"sources":["../../../src/client/useLocale.ts"],"mappings":";;;KAQK,cAAA;EACH,eAAA;EACA,cAAA,IAAkB,MAAA,EAAQ,aAAA;AAAA;;;;;;;;;AA8B5B;;;;;;;;;;;;;;;;;;;cAAa,SAAA,GACX,KAAA,GAAO,cAAA;EAEP,MAAA,EAAQ,eAAA;EACR,aAAA,EAAe,eAAA;EACf,gBAAA,EAAkB,eAAA;EAClB,SAAA,GAAY,SAAA,EAAW,aAAA;EACvB,SAAA,GAAY,QAAA,GAAW,MAAA,EAAQ,aAAA;AAAA"}

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

@@ -0,0 +1,37 @@
+import { LocalesValues } from "@intlayer/types/module_augmentation";
+import * as _$intlayer from "intlayer";
+
+//#region src/client/useLocaleStorage.d.ts
+/**
+ * Get the current locale from storage (cookie or localStorage).
+ */
+declare const localeInStorage: _$intlayer.Locale;
+/**
+ * @deprecated Use localeInStorage instead.
+ */
+declare const localeCookie: _$intlayer.Locale;
+/**
+ * Persist the locale to storage (cookie and/or localStorage).
+ */
+declare const setLocaleInStorage: (locale: LocalesValues, isCookieEnabled: boolean) => void;
+/**
+ * @deprecated Use setLocaleInStorage instead.
+ */
+declare const setLocaleCookie: (locale: LocalesValues, isCookieEnabled: boolean) => void;
+/**
+ * Returns the current locale from storage and a setter.
+ */
+declare const useLocaleStorage: (isCookieEnabled?: boolean) => {
+  localeStorage: _$intlayer.Locale;
+  setLocaleStorage: (locale: LocalesValues) => void;
+};
+/**
+ * @deprecated Use useLocaleStorage instead.
+ */
+declare const useLocaleCookie: (isCookieEnabled?: boolean) => {
+  localeStorage: _$intlayer.Locale;
+  setLocaleStorage: (locale: LocalesValues) => void;
+};
+//#endregion
+export { localeCookie, localeInStorage, setLocaleCookie, setLocaleInStorage, useLocaleCookie, useLocaleStorage };
+//# sourceMappingURL=useLocaleStorage.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useLocaleStorage.d.ts","names":[],"sources":["../../../src/client/useLocaleStorage.ts"],"mappings":";;;;;;;cAWa,eAAA,EAAkE,UAAA,CAAnD,MAAA;;;;cAKf,YAAA,EAA8B,UAAA,CAAlB,MAAA;AAAzB;;;AAAA,cAKa,kBAAA,GACX,MAAA,EAAQ,aAAA,EACR,eAAA;;AAFF;;cAYa,eAAA,GAAe,MAAA,EAXlB,aAAA,EAAa,eAAA;;;;cAgBV,gBAAA,GAAoB,eAAA;iBAUhC,UAAA,CAAA,MAAA;6BAAA,aAAA;AAAA;;;;cAKY,eAAA,GAAe,eAAA;iBAAmB,UAAA,CAAA,MAAA;6BAAA,aAAA;AAAA"}

package/dist/{client → types/client}/useRewriteURL.d.ts

@@ -1,3 +1,4 @@
+//#region src/client/useRewriteURL.d.ts
 /**
  * Keep the browser URL in sync with the current locale.
  *
@@ -20,4 +21,7 @@
  * unsubscribe();
  * ```
  */
-export declare const useRewriteURL: () => (() => void);
+declare const useRewriteURL: () => (() => void);
+//#endregion
+export { useRewriteURL };
+//# sourceMappingURL=useRewriteURL.d.ts.map

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

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

package/dist/{editor → types/editor}/useEditor.d.ts

@@ -1,3 +1,4 @@
+//#region src/editor/useEditor.d.ts
 /**
  * Initialises the Intlayer visual editor client.
  *
@@ -16,4 +17,7 @@
  * const stopEditor = useEditor();
  * ```
  */
-export declare const useEditor: () => (() => void);
+declare const useEditor: () => (() => void);
+//#endregion
+export { useEditor };
+//# sourceMappingURL=useEditor.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useEditor.d.ts","names":[],"sources":["../../../src/editor/useEditor.ts"],"mappings":";;AAwBA;;;;;;;;;;;;;;;;;cAAa,SAAA"}

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

@@ -0,0 +1,10 @@
+import { useCompact } from "./useCompact.js";
+import { useCurrency } from "./useCurrency.js";
+import { useDate } from "./useDate.js";
+import { useIntl } from "./useIntl.js";
+import { useList } from "./useList.js";
+import { useNumber } from "./useNumber.js";
+import { usePercentage } from "./usePercentage.js";
+import { useRelativeTime } from "./useRelativeTime.js";
+import { useUnit } from "./useUnit.js";
+export { useCompact, useCurrency, useDate, useIntl, useList, useNumber, usePercentage, useRelativeTime, useUnit };

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

@@ -0,0 +1,7 @@
+import { compact } from "@intlayer/core/formatters";
+
+//#region src/format/useCompact.d.ts
+declare const useCompact: () => (...args: Parameters<typeof compact>) => string;
+//#endregion
+export { useCompact };
+//# sourceMappingURL=useCompact.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useCompact.d.ts","names":[],"sources":["../../../src/format/useCompact.ts"],"mappings":";;;cAGa,UAAA,YAGA,IAAA,EAAM,UAAA,QAAkB,OAAA"}

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

@@ -0,0 +1,7 @@
+import { currency } from "@intlayer/core/formatters";
+
+//#region src/format/useCurrency.d.ts
+declare const useCurrency: () => (...args: Parameters<typeof currency>) => string;
+//#endregion
+export { useCurrency };
+//# sourceMappingURL=useCurrency.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useCurrency.d.ts","names":[],"sources":["../../../src/format/useCurrency.ts"],"mappings":";;;cAGa,WAAA,YAGA,IAAA,EAAM,UAAA,QAAkB,QAAA"}

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

@@ -0,0 +1,10 @@
+import { date } from "@intlayer/core/formatters";
+
+//#region src/format/useDate.d.ts
+/**
+ * Vanilla JS hook that provides a localized date/time formatter.
+ */
+declare const useDate: () => (...args: Parameters<typeof date>) => string;
+//#endregion
+export { useDate };
+//# sourceMappingURL=useDate.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useDate.d.ts","names":[],"sources":["../../../src/format/useDate.ts"],"mappings":";;;;;AAMA;cAAa,OAAA,YAGA,IAAA,EAAM,UAAA,QAAkB,IAAA"}

package/dist/{format → types/format}/useIntl.d.ts

@@ -1,5 +1,7 @@
-import { WrappedIntl } from '@intlayer/core/utils';
-import { LocalesValues } from '@intlayer/types/module_augmentation';
+import { LocalesValues } from "@intlayer/types/module_augmentation";
+import { WrappedIntl } from "@intlayer/core/utils";
+
+//#region src/format/useIntl.d.ts
 /**
  * Get a locale-bound `Intl` object and subscribe to locale changes.
  *
@@ -25,7 +27,10 @@ import { LocalesValues } from '@intlayer/types/module_augmentation';
  * });
  * ```
  */
-export declare const useIntl: (locale?: LocalesValues) => {
-    intl: WrappedIntl;
-    subscribe: (callback: (intl: WrappedIntl) => void) => () => void;
+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

@@ -0,0 +1 @@
+{"version":3,"file":"useIntl.d.ts","names":[],"sources":["../../../src/format/useIntl.ts"],"mappings":";;;;;;AA6BA;;;;;;;;;;;;;;;;;;;;;;;cAAa,OAAA,GACX,MAAA,GAAS,aAAA;EAET,IAAA,EAAM,WAAA;EACN,SAAA,GAAY,QAAA,GAAW,IAAA,EAAM,WAAA;AAAA"}

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

@@ -0,0 +1,7 @@
+import { list } from "@intlayer/core/formatters";
+
+//#region src/format/useList.d.ts
+declare const useList: () => (...args: Parameters<typeof list>) => string;
+//#endregion
+export { useList };
+//# sourceMappingURL=useList.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useList.d.ts","names":[],"sources":["../../../src/format/useList.ts"],"mappings":";;;cAGa,OAAA,YAGA,IAAA,EAAM,UAAA,QAAkB,IAAA"}

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

@@ -0,0 +1,10 @@
+import { number } from "@intlayer/core/formatters";
+
+//#region src/format/useNumber.d.ts
+/**
+ * Vanilla JS hook that provides a localized number formatter.
+ */
+declare const useNumber: () => (...args: Parameters<typeof number>) => string;
+//#endregion
+export { useNumber };
+//# sourceMappingURL=useNumber.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useNumber.d.ts","names":[],"sources":["../../../src/format/useNumber.ts"],"mappings":";;;;;AAMA;cAAa,SAAA,YAGA,IAAA,EAAM,UAAA,QAAkB,MAAA"}

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

@@ -0,0 +1,7 @@
+import { percentage } from "@intlayer/core/formatters";
+
+//#region src/format/usePercentage.d.ts
+declare const usePercentage: () => (...args: Parameters<typeof percentage>) => string;
+//#endregion
+export { usePercentage };
+//# sourceMappingURL=usePercentage.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"usePercentage.d.ts","names":[],"sources":["../../../src/format/usePercentage.ts"],"mappings":";;;cAGa,aAAA,YAGA,IAAA,EAAM,UAAA,QAAkB,UAAA"}

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

@@ -0,0 +1,7 @@
+import { relativeTime } from "@intlayer/core/formatters";
+
+//#region src/format/useRelativeTime.d.ts
+declare const useRelativeTime: () => (...args: Parameters<typeof relativeTime>) => string;
+//#endregion
+export { useRelativeTime };
+//# sourceMappingURL=useRelativeTime.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useRelativeTime.d.ts","names":[],"sources":["../../../src/format/useRelativeTime.ts"],"mappings":";;;cAGa,eAAA,YAGA,IAAA,EAAM,UAAA,QAAkB,YAAA"}

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

@@ -0,0 +1,7 @@
+import { units } from "@intlayer/core/formatters";
+
+//#region src/format/useUnit.d.ts
+declare const useUnit: () => (...args: Parameters<typeof units>) => string;
+//#endregion
+export { useUnit };
+//# sourceMappingURL=useUnit.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useUnit.d.ts","names":[],"sources":["../../../src/format/useUnit.ts"],"mappings":";;;cAGa,OAAA,YAGA,IAAA,EAAM,UAAA,QAAkB,KAAA"}

package/dist/types/getDictionary.d.ts

@@ -0,0 +1,9 @@
+import { DeepTransformContent } from "./plugins.js";
+import { DeclaredLocales, LocalesValues } from "@intlayer/types/module_augmentation";
+import { Dictionary } from "@intlayer/types/dictionary";
+
+//#region src/getDictionary.d.ts
+declare const getDictionary: <T extends Dictionary, L extends LocalesValues = DeclaredLocales>(dictionary: T, locale?: L) => DeepTransformContent<T["content"], L>;
+//#endregion
+export { getDictionary };
+//# sourceMappingURL=getDictionary.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getDictionary.d.ts","names":[],"sources":["../../src/getDictionary.ts"],"mappings":";;;;;cAQa,aAAA,aACD,UAAA,YACA,aAAA,GAAgB,eAAA,EAE1B,UAAA,EAAY,CAAA,EACZ,MAAA,GAAS,CAAA,KACR,oBAAA,CAAqB,CAAA,aAAc,CAAA"}

package/dist/types/getIntlayer.d.ts

@@ -0,0 +1,8 @@
+import { DeepTransformContent } from "./plugins.js";
+import { DeclaredLocales, DictionaryKeys, DictionaryRegistryContent, LocalesValues } from "@intlayer/types/module_augmentation";
+
+//#region src/getIntlayer.d.ts
+declare const getIntlayer: <T extends DictionaryKeys, L extends LocalesValues = DeclaredLocales>(key: T, locale?: L) => DeepTransformContent<DictionaryRegistryContent<T>, L>;
+//#endregion
+export { getIntlayer };
+//# sourceMappingURL=getIntlayer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getIntlayer.d.ts","names":[],"sources":["../../src/getIntlayer.ts"],"mappings":";;;;cASa,WAAA,aACD,cAAA,YACA,aAAA,GAAgB,eAAA,EAE1B,GAAA,EAAK,CAAA,EACL,MAAA,GAAS,CAAA,KACR,oBAAA,CAAqB,yBAAA,CAA0B,CAAA,GAAI,CAAA"}

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

@@ -0,0 +1,21 @@
+import { HTMLComponents } from "./types.js";
+
+//#region src/html/HTMLRenderer.d.ts
+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;
+/**
+ * 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);
+//#endregion
+export { RenderHTMLProps, renderHTML, useHTMLRenderer };
+//# sourceMappingURL=HTMLRenderer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"HTMLRenderer.d.ts","names":[],"sources":["../../../src/html/HTMLRenderer.ts"],"mappings":";;;KAGY,eAAA;EACV,UAAA,GAAa,cAAA;AAAA;;;;;cAOF,UAAA,GACX,OAAA,UACA,MAAA,GAAQ,eAAA;;;;;cAOG,eAAA;EAAmB;AAAA,IAE7B,eAAA,OAAyB,OAAA"}

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

@@ -0,0 +1,4 @@
+import { HTMLComponents } from "./types.js";
+import { RenderHTMLProps, renderHTML, useHTMLRenderer } from "./HTMLRenderer.js";
+import { IntlayerHTMLPluginOptions, IntlayerHTMLProvider, RenderHTMLFunction, RenderHTMLOptions, installIntlayerHTML, installIntlayerHTMLDynamic, useHTML } from "./installIntlayerHTML.js";
+export { type HTMLComponents, type IntlayerHTMLPluginOptions, type IntlayerHTMLProvider, type RenderHTMLFunction, type RenderHTMLOptions, type RenderHTMLProps, installIntlayerHTML, installIntlayerHTMLDynamic, renderHTML, useHTML, useHTMLRenderer };

package/dist/{html → types/html}/installIntlayerHTML.d.ts

@@ -1,19 +1,21 @@
-import { HTMLComponents } from './types';
-export type RenderHTMLOptions = {
-    components?: HTMLComponents<'permissive', {}>;
+import { HTMLComponents } from "./types.js";
+
+//#region src/html/installIntlayerHTML.d.ts
+type RenderHTMLOptions = {
+  components?: HTMLComponents<'permissive', {}>;
 };
-export type RenderHTMLFunction = (html: string, overrides?: HTMLComponents<'permissive', {}> | RenderHTMLOptions) => string;
-export type IntlayerHTMLProvider = {
-    renderHTML: RenderHTMLFunction;
+type RenderHTMLFunction = (html: string, overrides?: HTMLComponents<'permissive', {}> | RenderHTMLOptions) => string;
+type IntlayerHTMLProvider = {
+  renderHTML: RenderHTMLFunction;
 };
-export type IntlayerHTMLPluginOptions = {
-    components?: HTMLComponents<'permissive', {}>;
-    renderHTML?: RenderHTMLFunction;
+type IntlayerHTMLPluginOptions = {
+  components?: HTMLComponents<'permissive', {}>;
+  renderHTML?: RenderHTMLFunction;
 };
 /**
  * Create and return a single IntlayerHTMLProvider instance.
  */
-export declare const createIntlayerHTMLClient: (renderHTML: RenderHTMLFunction) => IntlayerHTMLProvider;
+declare const createIntlayerHTMLClient: (renderHTML: RenderHTMLFunction) => IntlayerHTMLProvider;
 /**
  * Install the Intlayer HTML provider for your vanilla JS application.
  *
@@ -28,13 +30,13 @@ export declare const createIntlayerHTMLClient: (renderHTML: RenderHTMLFunction)
  * });
  * ```
  */
-export declare const installIntlayerHTML: (pluginOptions?: IntlayerHTMLPluginOptions | RenderHTMLFunction) => IntlayerHTMLProvider;
+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.
  */
-export declare const useHTML: () => IntlayerHTMLProvider;
+declare const useHTML: () => IntlayerHTMLProvider;
 /**
  * Asynchronously install an HTML renderer whose implementation is loaded
  * via a dynamic `import()`.
@@ -59,4 +61,7 @@ export declare const useHTML: () => IntlayerHTMLProvider;
  * });
  * ```
  */
-export declare const installIntlayerHTMLDynamic: (loader: () => Promise<IntlayerHTMLPluginOptions | RenderHTMLFunction>) => Promise<IntlayerHTMLProvider>;
+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

@@ -0,0 +1 @@
+{"version":3,"file":"installIntlayerHTML.d.ts","names":[],"sources":["../../../src/html/installIntlayerHTML.ts"],"mappings":";;;KAEY,iBAAA;EACV,UAAA,GAAa,cAAA;AAAA;AAAA,KAGH,kBAAA,IACV,IAAA,UACA,SAAA,GAAY,cAAA,qBAAmC,iBAAA;AAAA,KAQrC,oBAAA;EACV,UAAA,EAAY,kBAAA;AAAA;AAAA,KAGF,yBAAA;EACV,UAAA,GAAa,cAAA;EACb,UAAA,GAAa,kBAAA;AAAA;;;;cAMF,wBAAA,GACX,UAAA,EAAY,kBAAA,KACX,oBAAA;;;AAdH;;;;;AAIA;;;;;;;cA8Ba,mBAAA,GACX,aAAA,GAAgB,yBAAA,GAA4B,kBAAA,KAC3C,oBAAA;;;AAxBH;;;cAmEa,OAAA,QAAc,oBAAA;;;;;;AA7C3B;;;;;;;;;;;;;;AA6CA;;;;;cA6Ba,0BAAA,GACX,MAAA,QAAc,OAAA,CAAQ,yBAAA,GAA4B,kBAAA,MACjD,OAAA,CAAQ,oBAAA"}

package/dist/{html → types/html}/types.d.ts

@@ -1,4 +1,6 @@
-import { HTMLTagsType } from '@intlayer/core/transpiler';
+import { HTMLTagsType } from "@intlayer/core/transpiler";
+
+//#region src/html/types.d.ts
 /**
  * Helper to extract specific props from the configuration value.
  */
@@ -8,7 +10,7 @@ type PropsFromConfig<Value> = Value extends true ? {} : Value extends object ? V
  * Components receive these as a plain object and return an HTML string.
  */
 type ElementProps = Record<string, unknown> & {
-    children?: string;
+  children?: string;
 };
 /**
  * Vanilla component type — a function that takes props and returns a string of HTML.
@@ -17,26 +19,22 @@ type VanillaHTMLComponent<P = {}> = (props: P & ElementProps) => string;
 /**
  * Helper: Defines the mapping for the explicitly listed keys in T.
  */
-type DefinedComponents<T, IsRequired extends boolean> = IsRequired extends true ? {
-    [K in keyof T]: VanillaHTMLComponent<PropsFromConfig<T[K]>>;
-} : {
-    [K in keyof T]?: VanillaHTMLComponent<PropsFromConfig<T[K]>>;
-};
+type DefinedComponents<T, IsRequired extends boolean> = IsRequired extends true ? { [K in keyof T]: VanillaHTMLComponent<PropsFromConfig<T[K]>> } : { [K in keyof T]?: VanillaHTMLComponent<PropsFromConfig<T[K]>> };
 /**
  * Helper: Defines the standard HTML tags NOT listed in T.
  */
-type RestHTMLComponents<T> = {
-    [K in Exclude<keyof HTMLTagsType, keyof T>]?: VanillaHTMLComponent;
-};
+type RestHTMLComponents<T> = { [K in Exclude<keyof HTMLTagsType, keyof T>]?: VanillaHTMLComponent };
 /**
  * The supported modes for the HTMLComponents type.
  */
-export type HTMLComponentMode = 'permissive' | 'optional' | 'inclusive' | 'strict';
+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.
  */
-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;
+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>;
-export {};
+//#endregion
+export { HTMLComponentMode, HTMLComponents };
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","names":[],"sources":["../../../src/html/types.ts"],"mappings":";;;;;AAA8D;KAKzD,eAAA,UAAyB,KAAA,qBAE1B,KAAA,kBACE,KAAA;;;;;KAOD,YAAA,GAAe,MAAA;EAClB,QAAA;AAAA;;;;KAMG,oBAAA,YAAgC,KAAA,EAAO,CAAA,GAAI,YAAA;;AAdrC;;KAmBN,iBAAA,kCAAmD,UAAA,8BAEtC,CAAA,GAAI,oBAAA,CAAqB,eAAA,CAAgB,CAAA,CAAE,CAAA,sBAG3C,CAAA,IAAK,oBAAA,CAAqB,eAAA,CAAgB,CAAA,CAAE,CAAA;;;;KAMzD,kBAAA,cACG,OAAA,OAAc,YAAA,QAAoB,CAAA,KAAM,oBAAA;;;AAjBY;KAuBhD,iBAAA;;;;;KAUA,cAAA,cACG,iBAAA,yBAEX,IAAA,oBACA,iBAAA,CAAkB,CAAA,UAClB,IAAA,uBACE,iBAAA,CAAkB,CAAA,UAAW,kBAAA,CAAmB,CAAA,IAChD,IAAA,wBACE,iBAAA,CAAkB,CAAA,WAChB,kBAAA,CAAmB,CAAA;EAAA,CAChB,GAAA,WAAc,oBAAA;AAAA,IAEnB,iBAAA,CAAkB,CAAA,WAAY,kBAAA,CAAmB,CAAA"}

package/dist/types/index.d.ts

@@ -0,0 +1,20 @@
+import { IntlayerClient, createIntlayerClient, getIntlayerClient, installIntlayer } from "./client/installIntlayer.js";
+import { DeepTransformContent, HTMLPluginCond, IInterpreterPluginState, IInterpreterPluginVanilla, InsertionCond, IntlayerNode, IntlayerNodeCond, MarkdownCond, MarkdownStringCond, getPlugins, htmlPlugin, insertionPlugin, intlayerNodePlugins, markdownPlugin, markdownStringPlugin } from "./plugins.js";
+import { WithOnChange, useDictionary } from "./client/useDictionary.js";
+import { useDictionaryDynamic } from "./client/useDictionaryDynamic.js";
+import { useIntlayer } from "./client/useIntlayer.js";
+import { useLocale } from "./client/useLocale.js";
+import { localeCookie, localeInStorage, setLocaleCookie, setLocaleInStorage, useLocaleCookie, useLocaleStorage } from "./client/useLocaleStorage.js";
+import { useRewriteURL } from "./client/useRewriteURL.js";
+import { useEditor } from "./editor/useEditor.js";
+import { getDictionary } from "./getDictionary.js";
+import { getIntlayer } from "./getIntlayer.js";
+import { LocalesValues } from "@intlayer/types/module_augmentation";
+
+//#region src/index.d.ts
+declare module '@intlayer/core/interpreter' {
+  interface IInterpreterPlugin<T, S, L extends LocalesValues> extends IInterpreterPluginVanilla<T, S, L> {}
+}
+//#endregion
+export { DeepTransformContent, HTMLPluginCond, IInterpreterPluginState, IInterpreterPluginVanilla, InsertionCond, IntlayerClient, IntlayerNode, IntlayerNodeCond, MarkdownCond, MarkdownStringCond, WithOnChange, createIntlayerClient, getDictionary, getIntlayer, getIntlayerClient, getPlugins, htmlPlugin, insertionPlugin, installIntlayer, intlayerNodePlugins, localeCookie, localeInStorage, markdownPlugin, markdownStringPlugin, setLocaleCookie, setLocaleInStorage, useDictionary, useDictionaryDynamic, useEditor, useIntlayer, useLocale, useLocaleCookie, useLocaleStorage, useRewriteURL };
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/index.ts"],"mappings":";;;;;;;;;;;;;;;YAIY,kBAAA,iBAAmC,aAAA,UACnC,yBAAA,CAA0B,CAAA,EAAG,CAAA,EAAG,CAAA;AAAA"}

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

@@ -0,0 +1,32 @@
+import { HTMLComponents } from "../html/types.js";
+import { MarkdownProviderOptions } from "./installIntlayerMarkdown.js";
+
+//#region src/markdown/MarkdownRenderer.d.ts
+type RenderMarkdownProps = MarkdownProviderOptions & {
+  components?: HTMLComponents<'permissive', {}>;
+  wrapper?: string;
+};
+/**
+ * Renders markdown to an HTML string without using the global provider.
+ *
+ * @example
+ * ```ts
+ * import { renderMarkdown } from 'vanilla-intlayer/markdown';
+ *
+ * document.querySelector('#content').innerHTML = renderMarkdown('# Hello **World**');
+ * ```
+ */
+declare const renderMarkdown: (content: string, {
+  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) => string | Promise<string>);
+//#endregion
+export { RenderMarkdownProps, renderMarkdown, useMarkdownRenderer };
+//# sourceMappingURL=MarkdownRenderer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"MarkdownRenderer.d.ts","names":[],"sources":["../../../src/markdown/MarkdownRenderer.ts"],"mappings":";;;;KAQY,mBAAA,GAAsB,uBAAA;EAChC,UAAA,GAAa,cAAA;EACb,OAAA;AAAA;;;;;;;;;AAaF;;cAAa,cAAA,GACX,OAAA;EACA,UAAA;EAAA,WAAA;EAAA,mBAAA;EAAA;AAAA,IAKG,mBAAA;;;;;cAeQ,mBAAA,GACX,KAAA,GAAO,mBAAA,OACJ,OAAA,sBAA6B,OAAA"}

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

@@ -0,0 +1,23 @@
+import { CompileOptions, RuleType, sanitizer as defaultSanitizer, slugify as defaultSlugify } from "@intlayer/core/markdown";
+
+//#region src/markdown/compiler.d.ts
+type MarkdownCompilerOptions = CompileOptions;
+/**
+ * Compile markdown to an HTML string.
+ *
+ * The resulting string can be inserted into the DOM via `element.innerHTML`
+ * or the `renderMarkdown` helper.
+ *
+ * @example
+ * ```ts
+ * import { compileMarkdown } from 'vanilla-intlayer/markdown';
+ *
+ * document.querySelector('#content').innerHTML = compileMarkdown('# Hello **World**');
+ * ```
+ */
+declare const compileMarkdown: (markdown?: string, options?: MarkdownCompilerOptions) => string;
+declare const compiler: (markdown?: string, options?: MarkdownCompilerOptions) => string;
+declare const compile: (markdown?: string, options?: MarkdownCompilerOptions) => string;
+//#endregion
+export { MarkdownCompilerOptions, RuleType, compile, compileMarkdown, compiler, defaultSanitizer as sanitizer, defaultSlugify as slugify };
+//# sourceMappingURL=compiler.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"compiler.d.ts","names":[],"sources":["../../../src/markdown/compiler.ts"],"mappings":";;;KAmBY,uBAAA,GAA0B,cAAA;;;;;;;;;AAqBtC;;;;;cANa,eAAA,GACX,QAAA,WACA,OAAA,GAAS,uBAAA;AAAA,cAIE,QAAA,GAAQ,QAAA,WAAA,OAAA,GAJV,uBAAA;AAAA,cAKE,OAAA,GAAO,QAAA,WAAA,OAAA,GALT,uBAAA"}

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

@@ -0,0 +1,4 @@
+import { IntlayerMarkdownPluginOptions, IntlayerMarkdownProvider, MarkdownProviderOptions, RenderMarkdownFunction, installIntlayerMarkdown, installIntlayerMarkdownDynamic, useMarkdown } from "./installIntlayerMarkdown.js";
+import { RenderMarkdownProps, renderMarkdown, useMarkdownRenderer } from "./MarkdownRenderer.js";
+import { compileMarkdown } from "./compiler.js";
+export { type IntlayerMarkdownPluginOptions, type IntlayerMarkdownProvider, type MarkdownProviderOptions, type RenderMarkdownFunction, type RenderMarkdownProps, compileMarkdown, installIntlayerMarkdown, installIntlayerMarkdownDynamic, renderMarkdown, useMarkdown, useMarkdownRenderer };