preact-intlayer 9.4.3 → 9.4.4

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

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

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

@@ -1,4 +1,3 @@
-import { LocalesValues } from "../intlayer/dist/types/index.js";
 //#region src/format/usePercentage.d.ts
 /**
  * React hook to provide a percentage formatter function
@@ -18,9 +17,8 @@ import { LocalesValues } from "../intlayer/dist/types/index.js";
  * @returns {(value: string | number, options?: Omit<PercentageOptions, "value">) => string}
  * A function that formats numbers or numeric strings into localized percentages.
  */
-declare const usePercentage: () => (value: string | number, args_1?: Intl.NumberFormatOptions & {
-  locale?: LocalesValues;
+export declare const usePercentage: () => (value: string | number, args_1?: Intl.NumberFormatOptions & {
+  locale?: import("@intlayer/types").LocalesValues;
 }) => string;
 //#endregion
-export { usePercentage };
 //# sourceMappingURL=usePercentage.d.ts.map

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

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

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

@@ -1,4 +1,3 @@
-import { LocalesValues } from "../intlayer/dist/types/index.js";
 //#region src/format/useRelativeTime.d.ts
 /**
  * Client-side React hook for accessing a localized relative time formatter.
@@ -18,10 +17,9 @@ import { LocalesValues } from "../intlayer/dist/types/index.js";
  * @returns {ReturnType<typeof createRelativeTime>} A relative time formatting function
  *          bound to the current client locale.
  */
-declare const useRelativeTime: () => (from: string | number | Date, to?: string | number | Date, options?: Intl.RelativeTimeFormatOptions & {
-  locale?: LocalesValues;
+export declare const useRelativeTime: () => (from: string | number | Date, to?: string | number | Date, options?: Intl.RelativeTimeFormatOptions & {
+  locale?: import("@intlayer/types").LocalesValues;
   unit?: Intl.RelativeTimeFormatUnit;
 }) => string;
 //#endregion
-export { useRelativeTime };
 //# sourceMappingURL=useRelativeTime.d.ts.map

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

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

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

@@ -1,4 +1,3 @@
-import { LocalesValues } from "../intlayer/dist/types/index.js";
 //#region src/format/useUnit.d.ts
 /**
  * React hook that provides a unit formatting function
@@ -17,9 +16,8 @@ import { LocalesValues } from "../intlayer/dist/types/index.js";
  *
  * @returns {Function} A unit formatting function that accepts a value and optional formatting options.
  */
-declare const useUnit: () => (value: string | number, options?: Intl.NumberFormatOptions & {
-  locale?: LocalesValues;
+export declare const useUnit: () => (value: string | number, options?: Intl.NumberFormatOptions & {
+  locale?: import("@intlayer/types").LocalesValues;
 }) => string;
 //#endregion
-export { useUnit };
 //# sourceMappingURL=useUnit.d.ts.map

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

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

package/dist/types/getDictionary.d.ts

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

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

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

package/dist/types/getIntlayer.d.ts

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -4,7 +4,7 @@ import { CompileOptions, ParsedMarkdown } from "@intlayer/core/markdown";
  * Options accepted by `compileMarkdown` and `parseMarkdown` to customise
  * rendering behaviour (custom components, sanitizer, slugify, rule hooks, …).
  */
-type MarkdownCompilerOptions = CompileOptions;
+export type MarkdownCompilerOptions = CompileOptions;
 /**
  * **Step 1 of 2 — parse only.**
  * Converts a raw markdown string into a `ParsedMarkdown` AST without rendering
@@ -23,7 +23,7 @@ type MarkdownCompilerOptions = CompileOptions;
  * const element = compileMarkdown(ast, { forceBlock: true });
  * ```
  */
-declare const parseMarkdown: (markdown?: string, options?: MarkdownCompilerOptions) => ParsedMarkdown;
+export declare const parseMarkdown: (markdown?: string, options?: MarkdownCompilerOptions) => ParsedMarkdown;
 /**
  * **Steps 1 + 2 — parse and render in one shot.**
  * Accepts a raw markdown string or a pre-parsed `ParsedMarkdown` AST and
@@ -39,7 +39,7 @@ declare const parseMarkdown: (markdown?: string, options?: MarkdownCompilerOptio
  * const element = compileMarkdown('# Hello **world**', { forceBlock: true });
  * ```
  */
-declare const compileMarkdown: (input?: string | ParsedMarkdown, options?: MarkdownCompilerOptions) => unknown;
+export declare const compileMarkdown: (input?: string | ParsedMarkdown, options?: MarkdownCompilerOptions) => unknown;
 //#endregion
-export { MarkdownCompilerOptions, type ParsedMarkdown, compileMarkdown, parseMarkdown };
+export type { ParsedMarkdown };
 //# sourceMappingURL=compiler.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"compiler.d.ts","names":[],"sources":["../../../src/markdown/compiler.ts"],"mappings":";;;;;;KAkBY,0BAA0B;;;;;;;;;;;;;;;;;;;cA2BzB,gBAAa,mBACR,UACP,4BACR;;;;;;;;;;;;;;;;cAmCU,kBAAe,iBACV,gBAAc,UACrB"}
+{"version":3,"file":"compiler.d.ts","names":[],"sources":["../../../src/markdown/compiler.ts"],"mappings":";;;;;;YAkBY,0BAA0B;;;;;;;;;;;;;;;;;;;qBA2BzB,gBAAa,mBACR,UACP,4BACR;;;;;;;;;;;;;;;;qBAmCU,kBAAe,iBACV,gBAAc,UACrB"}

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

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

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

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

package/dist/types/plugins.d.ts

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

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

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

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

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

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

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

package/package.json

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

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

@@ -1,14 +0,0 @@
-import "@intlayer/core/interpreter";
-import { LocalesValues as LocalesValues$1 } from "@intlayer/types/module_augmentation";
-import { Locale as Locale$1 } from "@intlayer/types/allLocales";
-import "@intlayer/core/transpiler";
-import { Dictionary } from "@intlayer/types/dictionary";
-import "@intlayer/types/config";
-import "@intlayer/types/locales";
-import "@intlayer/config/built";
-import "@intlayer/core/file";
-import "@intlayer/core/formatters";
-import "@intlayer/core/localization";
-import "@intlayer/core/markdown";
-import "@intlayer/core/utils";
-export type { Locale$1 as Locale, LocalesValues$1 as LocalesValues };