react-intlayer 9.0.0-canary.16 → 9.0.0-canary.18

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

@@ -1,6 +1,5 @@
 import { ComponentProps, FC, HTMLAttributes, JSX } from "react";
 import { HTMLTagsType } from "@intlayer/core/transpiler";
-
 //#region src/html/HTMLComponentTypes.d.ts
 /**
  * Helper to map string types from dictionary to TypeScript types
@@ -9,7 +8,7 @@ type PropTypeMap<T> = T extends 'string' ? string : T extends 'number' ? number
 /**
  * Helper to extract specific props from the configuration value.
  */
-type PropsFromConfig<Value> = Value extends true ? {} : Value extends object ? { [K in Exclude<keyof Value, 'children'>]?: PropTypeMap<Value[K]> } : {};
+type PropsFromConfig<Value> = Value extends true ? {} : Value extends object ? { [K in Exclude<keyof Value, 'children'>]?: PropTypeMap<Value[K]>; } : {};
 /**
  * Smart Type to resolve props based on the key K.
  */
@@ -18,12 +17,12 @@ type ElementProps<K> = K extends keyof JSX.IntrinsicElements ? ComponentProps<K>
  * Helper: Defines the mapping for the explicitly listed keys in T.
  * Handles whether they are Required or Optional.
  */
-type DefinedComponents<T, IsRequired extends boolean> = IsRequired extends true ? { [K in keyof T]: FC<ElementProps<K> & PropsFromConfig<T[K]>> } : { [K in keyof T]?: FC<ElementProps<K> & PropsFromConfig<T[K]>> };
+type DefinedComponents<T, IsRequired extends boolean> = IsRequired extends true ? { [K in keyof T]: FC<ElementProps<K> & PropsFromConfig<T[K]>>; } : { [K in keyof T]?: FC<ElementProps<K> & PropsFromConfig<T[K]>>; };
 /**
  * Helper: Defines the standard HTML tags NOT listed in T.
  * These are always optional when included.
  */
-type RestHTMLComponents<T> = { [K in Exclude<keyof HTMLTagsType, keyof T>]?: FC<K extends keyof JSX.IntrinsicElements ? ComponentProps<K> : HTMLAttributes<HTMLElement>> };
+type RestHTMLComponents<T> = { [K in Exclude<keyof HTMLTagsType, keyof T>]?: FC<K extends keyof JSX.IntrinsicElements ? ComponentProps<K> : HTMLAttributes<HTMLElement>>; };
 /**
  * The supported modes for the HTMLComponents type.
  */
@@ -31,12 +30,12 @@ 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.
-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> & {
+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]: FC<any>;
-} : // Optional (Default): Keys in T optional. Rest of HTML optional.
-DefinedComponents<T, false> & RestHTMLComponents<T>;
+} // Optional (Default): Keys in T optional. Rest of HTML optional.
+ : DefinedComponents<T, false> & RestHTMLComponents<T>;
 //#endregion
 export { HTMLComponentMode, HTMLComponents };
 //# sourceMappingURL=HTMLComponentTypes.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"HTMLComponentTypes.d.ts","names":[],"sources":["../../../src/html/HTMLComponentTypes.tsx"],"mappings":";;;;;;AACqE;KAKhE,WAAA,MAAiB,CAAA,6BAElB,CAAA,6BAEE,CAAA,+BAEE,CAAA;;;;KAKH,eAAA,UAAyB,KAAA,qBAE1B,KAAA,0BACU,OAAA,OAAc,KAAA,iBAAsB,WAAA,CAAY,KAAA,CAAM,CAAA;;;;KAM/D,YAAA,MAAkB,CAAA,eAAgB,GAAA,CAAI,iBAAA,GACvC,cAAA,CAAe,CAAA,IACf,cAAA,CAAe,WAAA;;;;;KAMd,iBAAA,kCAAmD,UAAA,8BAGtC,CAAA,GAAI,EAAA,CAAG,YAAA,CAAa,CAAA,IAAK,eAAA,CAAgB,CAAA,CAAE,CAAA,sBAI3C,CAAA,IAAK,EAAA,CAAG,YAAA,CAAa,CAAA,IAAK,eAAA,CAAgB,CAAA,CAAE,CAAA;;;;;KAOzD,kBAAA,cACG,OAAA,OAAc,YAAA,QAAoB,CAAA,KAAM,EAAA,CAC5C,CAAA,eAAgB,GAAA,CAAI,iBAAA,GAChB,cAAA,CAAe,CAAA,IACf,cAAA,CAAe,WAAA;;;;KAOX,iBAAA;;;;KASA,cAAA,cACG,iBAAA,yBAEX,IAAA,oBAEA,iBAAA,CAAkB,CAAA,UAClB,IAAA;AAEE,iBAAA,CAAkB,CAAA,UAAW,kBAAA,CAAmB,CAAA,IAChD,IAAA;AAEE,iBAAA,CAAkB,CAAA,WAChB,kBAAA,CAAmB,CAAA;EAAA,CAChB,GAAA,WAAc,EAAA;AAAA;AAGnB,iBAAA,CAAkB,CAAA,WAAY,kBAAA,CAAmB,CAAA"}
+{"version":3,"file":"HTMLComponentTypes.d.ts","names":[],"sources":["../../../src/html/HTMLComponentTypes.tsx"],"mappings":";;;;;;KAMK,YAAY,KAAK,8BAElB,8BAEE,gCAEE;;;;KAKH,gBAAgB,SAAS,0BAE1B,0BACK,KAAK,cAAc,sBAAsB,YAAY,MAAM;;;;KAM/D,aAAa,KAAK,gBAAgB,IAAI,oBACvC,eAAe,KACf,eAAe;;;;;KAMd,kBAAkB,GAAG,8BAA8B,6BAGjD,WAAW,IAAI,GAAG,aAAa,KAAK,gBAAgB,EAAE,aAItD,WAAW,KAAK,GAAG,aAAa,KAAK,gBAAgB,EAAE;;;;;KAOzD,mBAAmB,QACrB,KAAK,cAAc,oBAAoB,MAAM,GAC5C,gBAAgB,IAAI,oBAChB,eAAe,KACf,eAAe;;;;KAOX;;;;KASA,eACV,aAAa,gCACb,UACE,wBAEA,kBAAkB,WAClB;GAEE,kBAAkB,WAAW,mBAAmB,KAChD;GAEE,kBAAkB,YAChB,mBAAmB;GAChB,cAAc;;GAGnB,kBAAkB,YAAY,mBAAmB"}

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

@@ -1,6 +1,5 @@
 import { HTMLComponents } from "./HTMLComponentTypes.js";
 import { FC, PropsWithChildren } from "react";
-
 //#region src/html/HTMLProvider.d.ts
 type HTMLContextValue = {
   components?: HTMLComponents<'permissive', {}>;

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

@@ -1 +1 @@
-{"version":3,"file":"HTMLProvider.d.ts","names":[],"sources":["../../../src/html/HTMLProvider.tsx"],"mappings":";;;;KAUK,gBAAA;EACH,UAAA,GAAa,cAAA;AAAA;AAAA,KAGV,iBAAA,GAAoB,iBAAA;;;;EAIvB,UAAA,GAAa,cAAA;AAAA;AAAA,cAKF,cAAA,QAAc,gBAAA;AAAA,cAEd,YAAA,EAAc,EAAA,CAAG,iBAAA"}
+{"version":3,"file":"HTMLProvider.d.ts","names":[],"sources":["../../../src/html/HTMLProvider.tsx"],"mappings":";;;KAUK;EACH,aAAa;;KAGV,oBAAoB;;;;EAIvB,aAAa;;cAKF,sBAAc;cAEd,cAAc,GAAG"}

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

@@ -1,6 +1,5 @@
 import { HTMLComponents } from "./HTMLComponentTypes.js";
 import { FC, JSX } from "react";
-
 //#region src/html/HTMLRenderer.d.ts
 type RenderHTMLProps = {
   /**
@@ -15,18 +14,14 @@ 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;
+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;
+declare const useHTMLRenderer: ({ components }?: RenderHTMLProps) => (content: string) => JSX.Element;
 type HTMLRendererProps = RenderHTMLProps & {
   /**
    * The HTML content to render as a string.

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

@@ -1 +1 @@
-{"version":3,"file":"HTMLRenderer.d.ts","names":[],"sources":["../../../src/html/HTMLRenderer.tsx"],"mappings":";;;;KAQY,eAAA;;AAAZ;;;EAKE,UAAA,GAAa,cAAA;AAAA;AASf;;;;;;AAAA,cAAa,UAAA,GACX,OAAA;EACA;AAAA,IAAqB,eAAA,KACpB,GAAA,CAAI,OAAA;;;;;;;cAuCM,eAAA;EAAmB;AAAA,IAAgB,eAAA,MAGtC,OAAA,aAAe,GAAA,CAAA,OAAA;AAAA,KAUb,iBAAA,GAAoB,eAAA;EArB/B;AAQD;;EAiBE,QAAA;AAAA;;;;;;;cASW,YAAA,EAAc,EAAA,CAAG,iBAAA"}
+{"version":3,"file":"HTMLRenderer.d.ts","names":[],"sources":["../../../src/html/HTMLRenderer.tsx"],"mappings":";;;KAQY;;;;;EAKV,aAAa;;;;;;;;cASF,aAAU,mBACN,eACM,oBACpB,IAAI;;;;;;;cAuCM,oBAAe,eAAoB,qBAAe,oBAGtC,IAAA;KAUb,oBAAoB;;;;EAI9B;;;;;;;;cASW,cAAc,GAAG"}

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

@@ -1,5 +1,4 @@
 import { FC } from "react";
-
 //#region src/html/HTMLRendererPlugin.d.ts
 type HTMLRendererPluginProps = {
   html: string;

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

@@ -1 +1 @@
-{"version":3,"file":"HTMLRendererPlugin.d.ts","names":[],"sources":["../../../src/html/HTMLRendererPlugin.tsx"],"mappings":";;;KAIK,uBAAA;EACH,IAAA;EACA,cAAA,GAAiB,MAAA;AAAA;AAAA,cAGN,kBAAA,EAAoB,EAAA,CAAG,uBAAA"}
+{"version":3,"file":"HTMLRendererPlugin.d.ts","names":[],"sources":["../../../src/html/HTMLRendererPlugin.tsx"],"mappings":";;KAIK;EACH;EACA,iBAAiB;;cAGN,oBAAoB,GAAG"}

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

@@ -1,5 +1,4 @@
 import { ReactNode } from "react";
-
 //#region src/html/types.d.ts
 type ReactComponentProps = {
   children?: ReactNode;

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

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","names":[],"sources":["../../../src/html/types.ts"],"mappings":";;;KAEY,mBAAA;EACV,QAAA,GAAW,SAAA;EAAA,CACV,GAAA;AAAA"}
+{"version":3,"file":"types.d.ts","names":[],"sources":["../../../src/html/types.ts"],"mappings":";;KAEY;EACV,WAAW;GACV"}

package/dist/types/index.d.ts

@@ -20,12 +20,11 @@ import { localeCookie, localeInStorage, setLocaleCookie, setLocaleInStorage, use
 import { useRewriteURL } from "./client/useRewriteURL.js";
 import { getDictionary } from "./getDictionary.js";
 import { getIntlayer } from "./getIntlayer.js";
-import { MarkdownProviderOptions as MarkdownProviderOptions$1 } from "./markdown/MarkdownProvider.js";
-import { MarkdownRendererProps as MarkdownRendererProps$1, RenderMarkdownProps as RenderMarkdownProps$1 } from "./markdown/MarkdownRenderer.js";
+import "./html/index.js";
+import { MarkdownProviderOptions as MarkdownProviderOptions$1, useMarkdownContext as useMarkdownContext$1 } from "./markdown/MarkdownProvider.js";
+import { MarkdownRendererProps as MarkdownRendererProps$1, RenderMarkdownProps as RenderMarkdownProps$1, renderMarkdown as renderMarkdown$1, useMarkdownRenderer as useMarkdownRenderer$1 } from "./markdown/MarkdownRenderer.js";
+import "./markdown/index.js";
 import { LocalesValues } from "@intlayer/types/module_augmentation";
-import * as _$react from "react";
-import * as _$_intlayer_core_markdown0 from "@intlayer/core/markdown";
-
 //#region src/index.d.ts
 declare module '@intlayer/core/interpreter' {
   interface IInterpreterPlugin<T, S, L extends LocalesValues> extends IInterpreterPluginReact<T, S, L> {}
@@ -33,20 +32,17 @@ declare module '@intlayer/core/interpreter' {
 /**
  * @deprecated import from react-intlayer/markdown instead
  */
-declare const MarkdownProvider: _$react.FC<MarkdownProviderOptions$1 & {
-  components?: HTMLComponents<"permissive", {}>;
-  wrapper?: _$react.FC<_$react.HTMLAttributes<HTMLElement>>;
-  renderMarkdown?: (markdown: string | _$_intlayer_core_markdown0.ParsedMarkdown, options?: MarkdownProviderOptions$1, components?: HTMLComponents<"permissive", {}>, wrapper?: _$react.FC<_$react.HTMLAttributes<HTMLElement>>) => _$react.ReactNode | Promise<_$react.ReactNode>;
+declare const MarkdownProvider: import("react").FC<MarkdownProviderOptions$1 & {
+  components?: HTMLComponents<'permissive', {}>;
+  wrapper?: import("react").FC<import("react").HTMLAttributes<HTMLElement>>;
+  renderMarkdown?: (markdown: string | import("@intlayer/core/markdown").ParsedMarkdown, options?: MarkdownProviderOptions$1, components?: HTMLComponents<'permissive', {}>, wrapper?: import("react").FC<import("react").HTMLAttributes<HTMLElement>>) => import("react").ReactNode | Promise<import("react").ReactNode>;
 } & {
-  children?: _$react.ReactNode | undefined;
+  children?: import("react").ReactNode | undefined;
 }>;
 /**
  * @deprecated import from react-intlayer/markdown instead
  */
-declare const useMarkdownContext: () => {
-  components?: HTMLComponents<"permissive", {}>;
-  renderMarkdown: (markdown: string | _$_intlayer_core_markdown0.ParsedMarkdown, options?: MarkdownProviderOptions$1, components?: HTMLComponents<"permissive", {}>, wrapper?: _$react.FC<_$react.HTMLAttributes<HTMLElement>>) => _$react.ReactNode | Promise<_$react.ReactNode>;
-};
+declare const useMarkdownContext: typeof useMarkdownContext$1;
 /**
  * @deprecated import from react-intlayer/markdown instead
  */
@@ -54,29 +50,15 @@ type MarkdownProviderOptions = MarkdownProviderOptions$1;
 /**
  * @deprecated import from react-intlayer/markdown instead
  */
-declare const renderMarkdown: (content: string | _$_intlayer_core_markdown0.ParsedMarkdown, {
-  components,
-  wrapper,
-  forceBlock,
-  forceInline,
-  preserveFrontmatter,
-  tagfilter
-}?: RenderMarkdownProps$1) => _$react.JSX.Element;
+declare const renderMarkdown: typeof renderMarkdown$1;
 /**
  * @deprecated import from react-intlayer/markdown instead
  */
-declare const useMarkdownRenderer: ({
-  components,
-  wrapper,
-  forceBlock,
-  forceInline,
-  preserveFrontmatter,
-  tagfilter
-}?: RenderMarkdownProps$1) => (content: string | _$_intlayer_core_markdown0.ParsedMarkdown) => string | number | bigint | boolean | Iterable<_$react.ReactNode> | _$react.JSX.Element | Promise<_$react.ReactNode>;
+declare const useMarkdownRenderer: typeof useMarkdownRenderer$1;
 /**
  * @deprecated import from react-intlayer/markdown instead
  */
-declare const MarkdownRenderer: _$react.FC<MarkdownRendererProps$1>;
+declare const MarkdownRenderer: import("react").FC<MarkdownRendererProps$1>;
 /**
  * @deprecated import from react-intlayer/markdown instead
  */

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAIY,kBAAA,iBAAmC,aAAA,UACnC,uBAAA,CAAwB,CAAA,EAAG,CAAA,EAAG,CAAA;AAAA;;;;cA2D7B,gBAAA,UAAgB,EAAA,CAAA,yBAAA;eAAA,cAAA;;4FAlCG,yBAAA,EAAA,UAAA,GAAA,cAAA,oBACA,OAAA,GACF,OAAA,CAAA,EAAA,CAAA,OAAA,CAAA,cAAA,CAAA,WAAA,OAAA,OAAA,CAAA,SAAA,GAAA,OAAA,CAAA,OAAA,CAAA,SAAA;AAAA;aAAA,OAAA,CAAA,SAAA;AAAA;;;;cAoCjB,kBAAA;eAAwC,cAAA;2FAjDP,yBAAA,EAAA,UAAA,GAAA,cAAA,oBAEvC,OAAA,GAEG,OAAA,CAAA,EAAA,CAAA,OAAA,CAAA,cAAA,CAAA,WAAA,OAAA,OAAA,CAAA,SAAA,GAAA,OAAA,CAAA,OAAA,CAAA,SAAA;AAAA;;;AAyCV;KAQY,uBAAA,GAA0B,yBAAA;;;;cAIzB,cAAA,GAAc,OAAA,WAAkB,0BAAA,CAAlB,cAAA;EAAA,UAAA;EAAA,OAAA;EAAA,UAAA;EAAA,WAAA;EAAA,mBAAA;EAAA;AAAA,IAAA,qBAAA,KAAA,OAAA,CAAA,GAAA,CAAA,OAAA;;;;cAId,mBAAA;EAAmB,UAAA;EAAA,OAAA;EAAA,UAAA;EAAA,WAAA;EAAA,mBAAA;EAAA;AAAA,IAAA,qBAAA,MAa29B,OAAA,WAb39B,0BAAA,CAa29B,cAAA,0CAAgC,QAAA,CAAA,OAAA,CAAA,SAAA,IAAA,OAAA,CAAA,GAAA,CAAA,OAAA,GAAA,OAAA,CAAA,OAAA,CAAA,SAAA;;;;cAT9gC,gBAAA,EAAgB,OAAA,CAAA,EAAA,CAAA,uBAAA;;;;KAIjB,mBAAA,GAAsB,qBAAA;;;;KAItB,qBAAA,GAAwB,uBAAA"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAIY,mBAAmB,GAAG,GAAG,UAAU,uBACnC,wBAAwB,GAAG,GAAG;;;;;cA2D7B,kCAAgB,GAAA;eAAA;;;;;;;;;cAIhB,2BAAkB;;;;KAInB,0BAA0B;;;;cAIzB,uBAAc;;;;cAId,4BAAmB;;;;cAInB,kCAAgB,GAAA;;;;KAIjB,sBAAsB;;;;KAItB,wBAAwB"}

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

@@ -1,12 +1,15 @@
 import { HTMLComponents } from "../html/HTMLComponentTypes.js";
 import { ParsedMarkdown } from "./processor.js";
 import { FC, HTMLAttributes, PropsWithChildren, ReactNode } from "react";
-
 //#region src/markdown/MarkdownProvider.d.ts
 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. */
-  forceInline?: boolean; /** Whether to preserve frontmatter in the markdown content. */
-  preserveFrontmatter?: boolean; /** Whether to use the GitHub Tag Filter for security. */
+  /** 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. */
+  forceInline?: boolean;
+  /** Whether to preserve frontmatter in the markdown content. */
+  preserveFrontmatter?: boolean;
+  /** Whether to use the GitHub Tag Filter for security. */
   tagfilter?: boolean;
 };
 type MarkdownContextValue = {

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

@@ -1 +1 @@
-{"version":3,"file":"MarkdownProvider.d.ts","names":[],"sources":["../../../src/markdown/MarkdownProvider.tsx"],"mappings":";;;;;KAiBY,uBAAA;iFAEV,UAAA,YAFiC;EAIjC,WAAA,YAJiC;EAMjC,mBAAA,YAFA;EAIA,SAAA;AAAA;AAAA,KAGG,oBAAA;EACH,UAAA,GAAa,cAAA;EACb,cAAA,GACE,QAAA,WAAmB,cAAA,EACnB,OAAA,GAAU,uBAAA,EACV,UAAA,GAAa,cAAA,oBACb,OAAA,GAAU,EAAA,CAAG,cAAA,CAAe,WAAA,OACzB,SAAA,GAAY,OAAA,CAAQ,SAAA;AAAA;AAAA,KAGtB,qBAAA,GAAwB,iBAAA,CAC3B,uBAAA;EACE,UAAA,GAAa,cAAA;EACb,OAAA,GAAU,EAAA,CAAG,cAAA,CAAe,WAAA;EAC5B,cAAA,IACE,QAAA,WAAmB,cAAA,EACnB,OAAA,GAAU,uBAAA,EACV,UAAA,GAAa,cAAA,oBACb,OAAA,GAAU,EAAA,CAAG,cAAA,CAAe,WAAA,OACzB,SAAA,GAAY,OAAA,CAAQ,SAAA;AAAA;;;;;;;;cAehB,kBAAA,QAAkB,oBAAA;;;;;;;;;;;;;;;;;;;AA3BK;;;;;;cA0EvB,gBAAA,EAAkB,EAAA,CAAG,qBAAA"}
+{"version":3,"file":"MarkdownProvider.d.ts","names":[],"sources":["../../../src/markdown/MarkdownProvider.tsx"],"mappings":";;;;KAiBY;;EAEV;;EAEA;;EAEA;;EAEA;;KAGG;EACH,aAAa;EACb,iBACE,mBAAmB,gBACnB,UAAU,yBACV,aAAa,kCACb,UAAU,GAAG,eAAe,kBACzB,YAAY,QAAQ;;KAGtB,wBAAwB,kBAC3B;EACE,aAAa;EACb,UAAU,GAAG,eAAe;EAC5B,kBACE,mBAAmB,gBACnB,UAAU,yBACV,aAAa,kCACb,UAAU,GAAG,eAAe,kBACzB,YAAY,QAAQ;;;;;;;;;cAehB,0BAAkB;;;;;;;;;;;;;;;;;;;;;;;;;cA+ClB,kBAAkB,GAAG"}

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

@@ -2,7 +2,6 @@ import { HTMLComponents } from "../html/HTMLComponentTypes.js";
 import { ParsedMarkdown } from "./processor.js";
 import { MarkdownProviderOptions } from "./MarkdownProvider.js";
 import { FC, HTMLAttributes, JSX, ReactNode } from "react";
-
 //#region src/markdown/MarkdownRenderer.d.ts
 /**
  * Props for rendering markdown content.
@@ -74,14 +73,7 @@ type RenderMarkdownProps = MarkdownProviderOptions & {
  * });
  * ```
  */
-declare const renderMarkdown: (content: string | ParsedMarkdown, {
-  components,
-  wrapper,
-  forceBlock,
-  forceInline,
-  preserveFrontmatter,
-  tagfilter
-}?: RenderMarkdownProps) => JSX.Element;
+declare const renderMarkdown: (content: string | ParsedMarkdown, { components, wrapper, forceBlock, forceInline, preserveFrontmatter, tagfilter }?: RenderMarkdownProps) => JSX.Element;
 /**
  * Hook that returns a function to render markdown content.
  *
@@ -127,14 +119,7 @@ declare const renderMarkdown: (content: string | ParsedMarkdown, {
  * }
  * ```
  */
-declare const useMarkdownRenderer: ({
-  components,
-  wrapper,
-  forceBlock,
-  forceInline,
-  preserveFrontmatter,
-  tagfilter
-}?: RenderMarkdownProps) => (content: string | ParsedMarkdown) => string | number | bigint | boolean | Iterable<ReactNode> | JSX.Element | Promise<ReactNode>;
+declare const useMarkdownRenderer: ({ components, wrapper, forceBlock, forceInline, preserveFrontmatter, tagfilter }?: RenderMarkdownProps) => (content: string | ParsedMarkdown) => string | number | bigint | boolean | JSX.Element | Iterable<ReactNode> | Promise<ReactNode>;
 /**
  * Props for the MarkdownRenderer component.
  *

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

@@ -1 +1 @@
-{"version":3,"file":"MarkdownRenderer.d.ts","names":[],"sources":["../../../src/markdown/MarkdownRenderer.tsx"],"mappings":";;;;;;;;AAiCA;;;;;;;;;;;;;;;;;KAAY,mBAAA,GAAsB,uBAAA;EAwBO;AA4BzC;;;;;;;;;;;;EAtCE,UAAA,GAAa,cAAA;EA6Dd;;;;;;;;;EAnDC,OAAA,GAAU,EAAA,CAAG,cAAA,CAAe,WAAA;AAAA;;;;;;;;;;AAkG9B;;;;;;;;;;;;;;;;cAtEa,cAAA,GACX,OAAA,WAAkB,cAAA;EAClB,UAAA;EAAA,OAAA;EAAA,UAAA;EAAA,WAAA;EAAA,mBAAA;EAAA;AAAA,IAOG,mBAAA,KACF,GAAA,CAAI,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;AA+GP;;;;;;;;;;;;;;;;;;;;;cAnDa,mBAAA;EAAuB,UAAA;EAAA,OAAA;EAAA,UAAA;EAAA,WAAA;EAAA,mBAAA;EAAA;AAAA,IAOjC,mBAAA,MAGO,OAAA,WAAkB,cAAA,0CAAc,QAAA,CAAA,SAAA,IAAA,GAAA,CAAA,OAAA,GAAA,OAAA,CAAA,SAAA;;;;;;;;;;;;AAmJ1C;;;;KA1GY,qBAAA,GAAwB,mBAAA;;;;;;;;;;;EAWlC,QAAA,WAAmB,cAAA;;;;;;;;;;;;;;;;;;;;;EAqBnB,cAAA,IACE,QAAA,WAAmB,cAAA,EACnB,OAAA;IACE,UAAA,GAAa,cAAA;IACb,OAAA,GAAU,EAAA;IACV,UAAA;IACA,WAAA;IACA,mBAAA;IACA,SAAA;EAAA,MAEC,SAAA,GAAY,OAAA,CAAQ,SAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAgEd,gBAAA,EAAkB,EAAA,CAAG,qBAAA"}
+{"version":3,"file":"MarkdownRenderer.d.ts","names":[],"sources":["../../../src/markdown/MarkdownRenderer.tsx"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;KAiCY,sBAAsB;;;;;;;;;;;;;;EAchC,aAAa;;;;;;;;;;EAUb,UAAU,GAAG,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;cA4BjB,iBAAc,kBACP,kBAAc,YAAA,SAAA,YAAA,aAAA,qBAAA,cAQ7B,wBACF,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA4DM,wBAAmB,YAAA,SAAA,YAAA,aAAA,qBAAA,cAO7B,yBAAmB,kBAGM,wDAAc,IAAA,UAAA,SAAA,aAAA,QAAA;;;;;;;;;;;;;;;;KAyC9B,wBAAwB;;;;;;;;;;;EAWlC,mBAAmB;;;;;;;;;;;;;;;;;;;;;EAqBnB,kBACE,mBAAmB,gBACnB;IACE,aAAa;IACb,UAAU;IACV;IACA;IACA;IACA;QAEC,YAAY,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAgEd,kBAAkB,GAAG"}

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

@@ -3,7 +3,6 @@ import { MarkdownProviderOptions } from "./MarkdownProvider.js";
 import { LocalesValues } from "@intlayer/types/module_augmentation";
 import { FC } from "react";
 import { KeyPath } from "@intlayer/types/keyPath";
-
 //#region src/markdown/MarkdownRendererPlugin.d.ts
 type MarkdownRendererPluginProps = {
   dictionaryKey: string;

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

@@ -1 +1 @@
-{"version":3,"file":"MarkdownRendererPlugin.d.ts","names":[],"sources":["../../../src/markdown/MarkdownRendererPlugin.tsx"],"mappings":";;;;;;;KAYK,2BAAA;EACH,aAAA;EACA,OAAA,EAAS,OAAA;EACT,MAAA,GAAS,aAAA;EACT,QAAA;EACA,OAAA,GAAU,uBAAA;EACV,UAAA,GAAa,cAAA;AAAA;AAAA,cAGF,sBAAA,EAAwB,EAAA,CAAG,2BAAA"}
+{"version":3,"file":"MarkdownRendererPlugin.d.ts","names":[],"sources":["../../../src/markdown/MarkdownRendererPlugin.tsx"],"mappings":";;;;;;KAYK;EACH;EACA,SAAS;EACT,SAAS;EACT;EACA,UAAU;EACV,aAAa;;cAGF,wBAAwB,GAAG"}

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

@@ -1,7 +1,6 @@
 import { HTMLComponents } from "../html/HTMLComponentTypes.js";
 import { JSX, ReactNode, createElement } from "react";
 import { ParsedMarkdown, RenderRuleHook } from "@intlayer/core/markdown";
-
 //#region src/markdown/processor.d.ts
 type HTMLTags = keyof JSX.IntrinsicElements;
 /**

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

@@ -1 +1 @@
-{"version":3,"file":"processor.d.ts","names":[],"sources":["../../../src/markdown/processor.tsx"],"mappings":";;;;;KAyBK,QAAA,SAAiB,GAAA,CAAI,iBAAA;;AAK1B;;KAAY,uBAAA,GAA0B,OAAA;EAKX;;;EADzB,aAAA,GACE,GAAA,EAAK,UAAA,QAAkB,aAAA,MACvB,KAAA,EAAO,GAAA,CAAI,mBAAA,KACR,QAAA,EAAU,SAAA,OACV,SAAA;EAAA;;;;EAML,eAAA;EAd2C;;;;EAoB3C,qBAAA;EAfyB;;;EAoBzB,kBAAA;EAnBE;;;EAwBF,UAAA;EAhBA;;;EAqBA,WAAA;EAAA;;;EAKA,YAAA;EAYA;;;EAPA,mBAAA;IAAA,CACG,GAAA;EAAA;EAgB6B;;;EAVhC,UAAA,EAAY,cAAA;EAeF;;;EAVV,UAAA,EAAY,cAAA;EAyBH;;AAsCX;EA1DE,SAAA,GAAY,KAAA,UAAe,GAAA,EAAK,QAAA,EAAU,SAAA;;;;EAK1C,OAAA,GAAU,KAAA;EAuDV;;;EAlDA,OAAA;EA0GW;;;EArGX,mBAAA;EAuGS;;;EAlGT,SAAA;AAAA;;;;;;;;;;;;;;;;;;;cAsCW,aAAA,GACX,QAAA,WACA,OAAA,GAAS,uBAAA,KACR,cAAA;;;;;;;;;;;;;;;;cAuDU,eAAA,GACX,KAAA,YAAgB,cAAA,EAChB,OAAA,GAAS,uBAAA,KACR,GAAA,CAAI,OAAA"}
+{"version":3,"file":"processor.d.ts","names":[],"sources":["../../../src/markdown/processor.tsx"],"mappings":";;;;KAyBK,iBAAiB,IAAI;;;;KAKd,0BAA0B;;;;EAIpC,gBACE,KAAK,kBAAkB,mBACvB,OAAO,IAAI,wBACR,UAAU,gBACV;;;;;EAML;;;;;EAMA;;;;EAKA;;;;EAKA;;;;EAKA;;;;EAKA;;;;EAKA;KACG;;;;;EAMH,YAAY;;;;EAKZ,YAAY;;;;EAKZ,YAAY,eAAe,KAAK,UAAU;;;;EAK1C,UAAU;;;;EAKV;;;;EAKA;;;;EAKA;;;;;;;;;;;;;;;;;;;;cAsCW,gBAAa,mBACR,UACP,4BACR;;;;;;;;;;;;;;;;cAuDU,kBAAe,iBACV,gBAAc,UACrB,4BACR,IAAI"}

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

@@ -1,6 +1,5 @@
 import { ReactNode } from "react";
 import { MarkdownRuntime } from "@intlayer/core/markdown";
-
 //#region src/markdown/runtime.d.ts
 /**
  * React-specific runtime for the markdown processor.

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

@@ -1 +1 @@
-{"version":3,"file":"runtime.d.ts","names":[],"sources":["../../../src/markdown/runtime.ts"],"mappings":";;;;;;AAaA;;cAAa,YAAA,EAAc,eAAA;;;AA6D3B;;cAAa,kBAAA,GACX,OAAA;EACE,eAAA,IACE,IAAA,gBACA,KAAA,EAAO,MAAA,sBACP,QAAA,YACG,SAAA;AAAA,MAEN,eAAA"}
+{"version":3,"file":"runtime.d.ts","names":[],"sources":["../../../src/markdown/runtime.ts"],"mappings":";;;;;;;cAaa,cAAc;;;;;cA6Dd,qBAAkB;EAE3B,mBACE,oBACA,OAAO,4BACP,oBACG;MAEN"}

package/dist/types/plugins.d.ts

@@ -5,7 +5,6 @@ import { DeclaredLocales, LocalesValues } from "@intlayer/types/module_augmentat
 import { ReactNode } from "react";
 import * as NodeTypes from "@intlayer/types/nodeType";
 import { NodeType } from "@intlayer/types/nodeType";
-
 //#region src/plugins.d.ts
 /** ---------------------------------------------
  *  INTLAYER NODE PLUGIN
@@ -29,7 +28,7 @@ type InsertionCond<T> = T extends {
   nodeType: NodeType | string;
   [NodeTypes.INSERTION]: infer I;
   fields: readonly string[];
-} ? <V extends { [K in T['fields'][number]]: ReactNode }>(values: V) => I extends string ? V[keyof V] extends string | number ? IntlayerNode<string> : IntlayerNode<ReactNode> : DeepTransformContent<I> : never;
+} ? <V extends { [K in T['fields'][number]]: ReactNode; }>(values: V) => I extends string ? V[keyof V] extends string | number ? IntlayerNode<string> : IntlayerNode<ReactNode> : DeepTransformContent<I> : never;
 /** Insertion plugin for React. Handles component/node insertion. */
 declare const insertionPlugin: Plugins;
 /**

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

@@ -1 +1 @@
-{"version":3,"file":"plugins.d.ts","names":[],"sources":["../../src/plugins.tsx"],"mappings":";;;;;;;;;;;AA0DA;KAAY,gBAAA,MAAsB,CAAA,2BAC9B,YAAA,CAAa,CAAA;;cAIJ,mBAAA,EAAqB,OAAA;;;;KAyCtB,aAAA,MAAmB,CAAA;EAC7B,KAAA;EACA,GAAA;AAAA,IAEE,SAAA;;cAIS,gBAAA,EAAkB,OAAA;;AAjD/B;;KA+FY,aAAA,MAAmB,CAAA;EAC7B,QAAA,EAAU,QAAA;EAAA,CACT,SAAA,CAAU,SAAA;EACX,MAAA;AAAA,uBAEqB,CAAA,qBAAsB,SAAA,IACvC,MAAA,EAAQ,CAAA,KACL,CAAA,kBACD,CAAA,OAAQ,CAAA,4BACN,YAAA,WACA,YAAA,CAAa,SAAA,IACf,oBAAA,CAAqB,CAAA;;cA4BhB,eAAA,EAAiB,OAAA;;;;KAuFlB,kBAAA,MAAwB,CAAA,kBAChC,YAAA;EAGI,QAAA,EAAU,oBAAA;EACV,GAAA,GAAM,UAAA,EAAY,cAAA,uBAAqC,SAAA;AAAA;;cAiBlD,oBAAA,EAAsB,OAAA;AAAA,KAqFvB,YAAA,MAAkB,CAAA;EAC5B,QAAA,EAAU,QAAA;EAAA,CACT,SAAA,CAAU,QAAA;EACX,IAAA;EACA,QAAA;AAAA,IAEE,YAAA,CACE,CAAA;EAEE,GAAA,GAAM,UAAA,GAAa,cAAA,eAA6B,CAAA,MAAO,SAAA;EACvD,QAAA,EAAU,oBAAA,CAAqB,CAAA;AAAA;AAAA,cAK1B,cAAA,EAAgB,OAAA;;;;;;;;;;;;KAsCjB,cAAA,MAAoB,CAAA;EAC9B,QAAA,EAAU,QAAA;EAAA,CACT,SAAA,CAAU,IAAA;EACX,IAAA;AAAA,IAEE,YAAA,CACE,CAAA;EAEE,GAAA,GAAM,UAAA,GAAa,cAAA,eAA6B,CAAA,MAAO,SAAA;AAAA;;cAclD,UAAA,EAAY,OAAA;;;;KA6Db,uBAAA,mBAA0C,aAAA;EACpD,SAAA,EAAW,aAAA,CAAc,CAAA;EACzB,iBAAA,EAAmB,gBAAA,CAAiB,CAAA;EACpC,cAAA,EAAgB,aAAA,CAAc,CAAA;EAC9B,aAAA,EAAe,YAAA,CAAa,CAAA;EAC5B,SAAA,EAAW,cAAA,CAAe,CAAA;AAAA;;;;;AA/U5B;KAuVY,uBAAA,GAA0B,IAAA,CACpC,yBAAA;EAGA,SAAA;EACA,iBAAA;EACA,aAAA;EACA,SAAA;EACA,cAAA;AAAA;AAAA,KAGU,oBAAA,cAEA,aAAA,GAAgB,eAAA,IACxB,sBAAA,CAAyB,CAAA,EAAG,uBAAA,EAAyB,CAAA;;;;;cAQ5C,UAAA,GACX,MAAA,GAAS,aAAA,EACT,QAAA,eACC,OAAA"}
+{"version":3,"file":"plugins.d.ts","names":[],"sources":["../../src/plugins.tsx"],"mappings":";;;;;;;;;;;KA0DY,iBAAiB,KAAK,4BAC9B,aAAa;;cAIJ,qBAAqB;;;;KAyCtB,cAAc,KAAK;EAC7B;EACA;IAEE;;cAIS,kBAAkB;;;;KA8CnB,cAAc,KAAK;EAC7B,UAAU;GACT,UAAU,kBAAkB;EAC7B;KAEG,aAAa,KAAK,sBAAsB,cACvC,QAAQ,MACL,mBACD,QAAQ,6BACN,uBACA,aAAa,aACf,qBAAqB;;cA4BhB,iBAAiB;;;;KAuFlB,mBAAmB,KAAK,mBAChC;EAGI,UAAU;EACV,MAAM,YAAY,qCAAqC;;;cAiBlD,sBAAsB;KAqFvB,aAAa,KAAK;EAC5B,UAAU;GACT,UAAU,iBAAiB;EAC5B,aAAa;EACb,iBAAiB;IAEf,aACE;EAEE,MAAM,aAAa,6BAA6B,OAAO;EACvD,UAAU,qBAAqB;;cAK1B,gBAAgB;;;;;;;;;;;;KAsCjB,eAAe,KAAK;EAC9B,UAAU;GACT,UAAU,aAAa;EACxB,aAAa;IAEX,aACE;EAEE,MAAM,aAAa,6BAA6B,OAAO;;;cAclD,YAAY;;;;KA6Db,wBAAwB,GAAG,IAAI,WAAW;EACpD,WAAW,cAAc;EACzB,mBAAmB,iBAAiB;EACpC,gBAAgB,cAAc;EAC9B,eAAe,aAAa;EAC5B,WAAW,eAAe;;;;;;;KAQhB,0BAA0B,KACpC;EAGA;EACA;EACA;EACA;EACA;;KAGU,qBACV,GACA,UAAU,gBAAgB,mBACxB,uBAAyB,GAAG,yBAAyB;;;;;cAQ5C,aAAU,SACZ,eAAa,uBAErB"}

package/dist/types/reactElement/renderReactElement.d.ts

@@ -1,5 +1,4 @@
 import { ReactElement } from "react";
-
 //#region src/reactElement/renderReactElement.d.ts
 declare const renderReactElement: (element: ReactElement<any>) => any;
 //#endregion

package/dist/types/reactElement/renderReactElement.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"renderReactElement.d.ts","names":[],"sources":["../../../src/reactElement/renderReactElement.ts"],"mappings":";;;cAGa,kBAAA,GAAsB,OAAA,EAAS,YAAA"}
+{"version":3,"file":"renderReactElement.d.ts","names":[],"sources":["../../../src/reactElement/renderReactElement.ts"],"mappings":";;cAGa,qBAAkB,SAAa"}

package/dist/types/server/IntlayerServerProvider.d.ts

@@ -1,7 +1,5 @@
 import { LocalesValues } from "@intlayer/types/module_augmentation";
-import * as _$react from "react";
 import { FC, PropsWithChildren } from "react";
-
 //#region src/server/IntlayerServerProvider.d.ts
 /**
  * Context that store the current locale on the server side
@@ -13,7 +11,7 @@ declare const IntlayerServerContext: FC<PropsWithChildren<{
     value?: LocalesValues;
   }>>;
   Consumer: FC<PropsWithChildren<{
-    children: (context: LocalesValues) => _$react.ReactNode;
+    children: (context: LocalesValues) => import("react").ReactNode;
   }>>;
   _storage: () => {
     value: LocalesValues;

package/dist/types/server/IntlayerServerProvider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"IntlayerServerProvider.d.ts","names":[],"sources":["../../../src/server/IntlayerServerProvider.tsx"],"mappings":";;;;;;;;cAWa,qBAAA,EAAqB,EAAA,CAAA,iBAAA;;;;;;;;;;;;;;;;;cAMrB,WAAA,QAAW,aAAA;;;;cAKX,MAAA,EAAM,aAAA;AAAA,KAEP,2BAAA,GAA8B,iBAAA;EACxC,MAAA,GAAS,aAAA;AAAA;;;;cAME,sBAAA,EAAwB,EAAA,CAAG,2BAAA"}
+{"version":3,"file":"IntlayerServerProvider.d.ts","names":[],"sources":["../../../src/server/IntlayerServerProvider.tsx"],"mappings":";;;;;;cAWa,uBAAqB,GAAA;;;;;;;;;;;;;;;;;cAMrB,mBAAW;;;;cAKX,QAAM;KAEP,8BAA8B;EACxC,SAAS;;;;;cAME,wBAAwB,GAAG"}

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

@@ -1,5 +1,4 @@
 import { compact } from "@intlayer/core/formatters";
-
 //#region src/server/format/useCompact.d.ts
 /**
  * React client hook that provides a compact number formatter

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

@@ -1 +1 @@
-{"version":3,"file":"useCompact.d.ts","names":[],"sources":["../../../../src/server/format/useCompact.ts"],"mappings":";;;;;AAeA;;;;;;;;cAAa,UAAA,YAGA,IAAA,EAAM,UAAA,QAAkB,OAAA"}
+{"version":3,"file":"useCompact.d.ts","names":[],"sources":["../../../../src/server/format/useCompact.ts"],"mappings":";;;;;;;;;;;;cAea,sBAAU,MAGJ,kBAAkB"}

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

@@ -1,5 +1,4 @@
 import { currency } from "@intlayer/core/formatters";
-
 //#region src/server/format/useCurrency.d.ts
 /**
  * React client hook that provides a currency formatter

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

@@ -1 +1 @@
-{"version":3,"file":"useCurrency.d.ts","names":[],"sources":["../../../../src/server/format/useCurrency.ts"],"mappings":";;;;;AA0BA;;;;;;;;;;;;;;;;;;;cAAa,WAAA,YAGA,IAAA,EAAM,UAAA,QAAkB,QAAA"}
+{"version":3,"file":"useCurrency.d.ts","names":[],"sources":["../../../../src/server/format/useCurrency.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;cA0Ba,uBAAW,MAGL,kBAAkB"}

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

@@ -1,5 +1,4 @@
 import { date } from "@intlayer/core/formatters";
-
 //#region src/server/format/useDate.d.ts
 /**
  * React client hook that provides a localized date/time formatter

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

@@ -1 +1 @@
-{"version":3,"file":"useDate.d.ts","names":[],"sources":["../../../../src/server/format/useDate.ts"],"mappings":";;;;;AA+BA;;;;;;;;;;;;;;;;;;;;;;;;cAAa,OAAA,YAGA,IAAA,EAAM,UAAA,QAAkB,IAAA"}
+{"version":3,"file":"useDate.d.ts","names":[],"sources":["../../../../src/server/format/useDate.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;cA+Ba,mBAAO,MAGD,kBAAkB"}

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

@@ -1,6 +1,5 @@
 import { LocalesValues } from "@intlayer/types/module_augmentation";
 import { WrappedIntl } from "@intlayer/core/formatters";
-
 //#region src/server/format/useIntl.d.ts
 /**
  * React client hook that provides a locale-bound `Intl` object.

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

@@ -1 +1 @@
-{"version":3,"file":"useIntl.d.ts","names":[],"sources":["../../../../src/server/format/useIntl.ts"],"mappings":";;;;;;AAkCA;;;;;;;;;;;;;;;;;;;;;;;;;;cAAa,OAAA,GAAW,MAAA,GAAS,aAAA,KAAgB,WAAA"}
+{"version":3,"file":"useIntl.d.ts","names":[],"sources":["../../../../src/server/format/useIntl.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAkCa,UAAO,SAAa,kBAAgB"}

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

@@ -1,5 +1,4 @@
 import { list } from "@intlayer/core/formatters";
-
 //#region src/server/format/useList.d.ts
 /**
  * React server hook that provides a list formatter

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

@@ -1 +1 @@
-{"version":3,"file":"useList.d.ts","names":[],"sources":["../../../../src/server/format/useList.ts"],"mappings":";;;;;AAuBA;;;;;;;;;;;;;;;;cAAa,OAAA,YAGA,IAAA,EAAM,UAAA,QAAkB,IAAA"}
+{"version":3,"file":"useList.d.ts","names":[],"sources":["../../../../src/server/format/useList.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;cAuBa,mBAAO,MAGD,kBAAkB"}

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

@@ -1,5 +1,4 @@
 import { number } from "@intlayer/core/formatters";
-
 //#region src/server/format/useNumber.d.ts
 /**
  * React client hook that provides a localized number formatter.

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

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

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

@@ -1,5 +1,4 @@
 import { percentage } from "@intlayer/core/formatters";
-
 //#region src/server/format/usePercentage.d.ts
 /**
  * React hook to provide a percentage formatter function

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

@@ -1 +1 @@
-{"version":3,"file":"usePercentage.d.ts","names":[],"sources":["../../../../src/server/format/usePercentage.ts"],"mappings":";;;;;AAuBA;;;;;;;;;;;;;;;;cAAa,aAAA,YAGA,IAAA,EAAM,UAAA,QAAkB,UAAA"}
+{"version":3,"file":"usePercentage.d.ts","names":[],"sources":["../../../../src/server/format/usePercentage.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;cAuBa,yBAAa,MAGP,kBAAkB"}

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

@@ -1,5 +1,4 @@
 import { relativeTime } from "@intlayer/core/formatters";
-
 //#region src/server/format/useRelativeTime.d.ts
 /**
  * Client-side React hook for accessing a localized relative time formatter.

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

@@ -1 +1 @@
-{"version":3,"file":"useRelativeTime.d.ts","names":[],"sources":["../../../../src/server/format/useRelativeTime.ts"],"mappings":";;;;;AAuBA;;;;;;;;;;;;;;;;cAAa,eAAA,YAGA,IAAA,EAAM,UAAA,QAAkB,YAAA"}
+{"version":3,"file":"useRelativeTime.d.ts","names":[],"sources":["../../../../src/server/format/useRelativeTime.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;cAuBa,2BAAe,MAGT,kBAAkB"}

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

@@ -1,5 +1,4 @@
 import { units } from "@intlayer/core/formatters";
-
 //#region src/server/format/useUnit.d.ts
 /**
  * React hook that provides a unit formatting function

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

@@ -1 +1 @@
-{"version":3,"file":"useUnit.d.ts","names":[],"sources":["../../../../src/server/format/useUnit.ts"],"mappings":";;;;;AAsBA;;;;;;;;;;;;;;;cAAa,OAAA,YAGA,IAAA,EAAM,UAAA,QAAkB,KAAA"}
+{"version":3,"file":"useUnit.d.ts","names":[],"sources":["../../../../src/server/format/useUnit.ts"],"mappings":";;;;;;;;;;;;;;;;;;;cAsBa,mBAAO,MAGD,kBAAkB"}

package/dist/types/server/serverContext.d.ts

@@ -1,5 +1,4 @@
 import { FC, PropsWithChildren, ReactNode } from "react";
-
 //#region src/server/serverContext.d.ts
 declare const createServerContext: <T>(defaultValue?: T) => ServerContext<T>;
 /**
@@ -9,10 +8,7 @@ declare const createServerContext: <T>(defaultValue?: T) => ServerContext<T>;
  * @example
  * getServerContext(IntlayerServer);
  */
-declare const getServerContext: <T>({
-  _storage,
-  _defaultValue
-}: ServerContext<T>) => T;
+declare const getServerContext: <T>({ _storage, _defaultValue }: ServerContext<T>) => T;
 type ServerContext<T> = FC<PropsWithChildren<{
   value?: T;
 }>> & {

package/dist/types/server/serverContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"serverContext.d.ts","names":[],"sources":["../../../src/server/serverContext.tsx"],"mappings":";;;cAiBa,mBAAA,MAA2B,YAAA,GAAe,CAAA,KAAI,aAAA,CAAc,CAAA;;;;;;AAqCzE;;cAAa,gBAAA;EAAwB,QAAA;EAAA;AAAA,GAGlC,aAAA,CAAc,CAAA,MAAE,CAAA;AAAA,KAOd,aAAA,MAAmB,EAAA,CAAG,iBAAA;EAAoB,KAAA,GAAQ,CAAA;AAAA;EACrD,QAAA,EAAU,EAAA,CAAG,iBAAA;IAAoB,KAAA,GAAQ,CAAA;EAAA;EACzC,QAAA,EAAU,EAAA,CACR,iBAAA;IAAoB,QAAA,GAAW,OAAA,EAAS,CAAA,iBAAkB,SAAA;EAAA;EAE5D,QAAA;IAAkB,KAAA,EAAO,CAAA;EAAA;EACzB,aAAA,EAAe,CAAA;AAAA"}
+{"version":3,"file":"serverContext.d.ts","names":[],"sources":["../../../src/server/serverContext.tsx"],"mappings":";;cAiBa,sBAAuB,GAAC,eAAkB,MAAI,cAAc;;;;;;;;cAqC5D,mBAAoB,KAAC,UAAA,iBAG/B,cAAc,OAAE;KAOd,cAAc,KAAK,GAAG;EAAoB,QAAQ;;EACrD,UAAU,GAAG;IAAoB,QAAQ;;EACzC,UAAU,GACR;IAAoB,WAAW,SAAS,kBAAkB;;EAE5D;IAAkB,OAAO;;EACzB,eAAe"}

package/dist/types/server/t.d.ts

@@ -1,5 +1,4 @@
 import { DeclaredLocales, LocalesValues, StrictModeLocaleMap } from "@intlayer/types/module_augmentation";
-
 //#region src/server/t.d.ts
 /**
  * On the server side, hook to get the translation content based on the locale

package/dist/types/server/t.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"t.d.ts","names":[],"sources":["../../../src/server/t.ts"],"mappings":";;;;;AA8BA;;;;;;;;;;;;;;;;;;;cAAa,CAAA,+BAAiC,aAAA,GAAgB,eAAA,EAC5D,gBAAA,EAAkB,mBAAA,CAAoB,OAAA,GACtC,MAAA,GAAS,CAAA,KAAC,OAAA"}
+{"version":3,"file":"t.d.ts","names":[],"sources":["../../../src/server/t.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;cA8Ba,IAAK,kBAAkB,UAAU,gBAAgB,iBAAe,kBACzD,oBAAoB,UAAQ,SACrC,MAAC"}

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

@@ -1,9 +1,6 @@
-import { IInterpreterPluginState as IInterpreterPluginState$1 } from "../plugins.js";
-import * as _$_intlayer_core_interpreter0 from "@intlayer/core/interpreter";
+import { IInterpreterPluginState } from "../plugins.js";
 import { DeclaredLocales, LocalesValues } from "@intlayer/types/module_augmentation";
 import { Dictionary, DictionarySelectorForGroup, QualifiedDictionaryGroup } from "@intlayer/types/dictionary";
-import * as _$_intlayer_types0 from "@intlayer/types";
-
 //#region src/server/useDictionary.d.ts
 /**
  * On the server side, Hook that transform a dictionary (or qualified
@@ -12,7 +9,7 @@ import * as _$_intlayer_types0 from "@intlayer/types";
  * If the locale is not provided (directly or through the selector), it will
  * use the locale from the server context
  */
-declare const useDictionary: <const T extends Dictionary | QualifiedDictionaryGroup, const A extends LocalesValues | DictionarySelectorForGroup<T> = DeclaredLocales>(dictionary: T, localeOrSelector?: A, fallbackLocale?: DeclaredLocales) => _$_intlayer_core_interpreter0.DeepTransformContent<_$_intlayer_types0.ResolveQualifiedDictionaryContent<T, A>, IInterpreterPluginState$1, _$_intlayer_types0.ExtractSelectorLocale<A>>;
+declare const useDictionary: <const T extends Dictionary | QualifiedDictionaryGroup, const A extends LocalesValues | DictionarySelectorForGroup<T> = DeclaredLocales>(dictionary: T, localeOrSelector?: A, fallbackLocale?: DeclaredLocales) => import("@intlayer/core/interpreter").DeepTransformContent<import("@intlayer/types").ResolveQualifiedDictionaryContent<T, A>, IInterpreterPluginState, import("@intlayer/types").ExtractSelectorLocale<A>>;
 //#endregion
 export { useDictionary };
 //# sourceMappingURL=useDictionary.d.ts.map

package/dist/types/server/useDictionary.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useDictionary.d.ts","names":[],"sources":["../../../src/server/useDictionary.ts"],"mappings":";;;;;;;;;;;;AAoBA;;cAAa,aAAA,mBACK,UAAA,GAAa,wBAAA,kBAEzB,aAAA,GACA,0BAAA,CAA2B,CAAA,IAAK,eAAA,EAEpC,UAAA,EAAY,CAAA,EACZ,gBAAA,GAAmB,CAAA,EACnB,cAAA,GAAiB,eAAA,KAAe,6BAAA,CAAA,oBAAA,CAAA,kBAAA,CAAA,iCAAA,CAAA,CAAA,EAAA,CAAA,GAAA,yBAAA,EAAA,kBAAA,CAAA,qBAAA,CAAA,CAAA"}
+{"version":3,"file":"useDictionary.d.ts","names":[],"sources":["../../../src/server/useDictionary.ts"],"mappings":";;;;;;;;;;;cAoBa,sBACL,UAAU,aAAa,gCACvB,UACF,gBACA,2BAA2B,KAAK,iBAAe,YAEvC,GAAC,mBACM,GAAC,iBACH,yDAAe,+CAAA,kCAAA,GAAA,IAAA,mDAAA,sBAAA"}