react-intlayer 9.6.0 → 9.7.1

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;YAIY,mBAAmB,GAAG,GAAG,UAAU,uBACnC,wBAAwB,GAAG,GAAG;;;;;qBA4D7B,kCAAgB,GAAhB;;;;qBAIA,2BAAkB;;;;YAInB,0BAA0B;;;;qBAIzB,uBAAc;;;;qBAId,4BAAmB;;;;qBAInB,kCAAgB,GAAA;;;;YAIjB,sBAAsB;;;;YAItB,wBAAwB"}
+{"version":3,"file":"index.d.ts","names":["_$__markdown0.MarkdownProviderProps","_useMarkdownContext","_MarkdownProviderOptions","_renderMarkdown","_useMarkdownRenderer","_MarkdownRendererProps","_RenderMarkdownProps"],"sources":["../../src/index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;YAIY,mBAAmB,GAAG,GAAG,UAAU,uBACnC,wBAAwB,GAAG,GAAG;;;;;qBA4D7B,kCAAgB,GAAhBA;;;;qBAIA,2BAAkBC;;;;YAInB,0BAA0BC;;;;qBAIzB,uBAAcC;;;;qBAId,4BAAmBC;;;;qBAInB,kCAAgB,GAAAC;;;;YAIjB,sBAAsBC;;;;YAItB,wBAAwBD"}

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

@@ -1,7 +1,6 @@
 import { HTMLComponents } from "../html/HTMLComponentTypes.js";
 import { ParsedMarkdown } from "./processor.js";
 import { FC, HTMLAttributes, PropsWithChildren, ReactNode } from "react";
-//#region src/markdown/MarkdownProvider.d.ts
 export type MarkdownProviderOptions = {
   /** Forces the compiler to always output content with a block-level wrapper. */
   forceBlock?: boolean;
@@ -54,5 +53,4 @@ export declare const useMarkdownContext: () => MarkdownContextValue;
  * ```
  */
 export declare const MarkdownProvider: FC<MarkdownProviderProps>;
-//#endregion
 //# 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":";;;;YAiBY;;EAEV;;EAEA;;EAEA;;EAEA;;YAGU;EACV,aAAa;EACb,iBACE,mBAAmB,gBACnB,UAAU,yBACV,aAAa,kCACb,UAAU,GAAG,eAAe,kBACzB,YAAY,QAAQ;;YAGf,wBAAwB,kBAClC;EACE,aAAa;EACb,UAAU,GAAG,eAAe;EAC5B,kBACE,mBAAmB,gBACnB,UAAU,yBACV,aAAa,kCACb,UAAU,GAAG,eAAe,kBACzB,YAAY,QAAQ;;;;;;;;;qBAehB,0BAAkB;;;;;;;;;;;;;;;;;;;;;;;;;qBA+ClB,kBAAkB,GAAG"}
+{"version":3,"file":"MarkdownProvider.d.ts","names":[],"sources":["../../../src/markdown/MarkdownProvider.tsx"],"mappings":";;;YAiBY;;EAEV;;EAEA;;EAEA;;EAEA;;YAGU;EACV,aAAa;EACb,iBACE,mBAAmB,gBACnB,UAAU,yBACV,aAAa,kCACb,UAAU,GAAG,eAAe,kBACzB,YAAY,QAAQ;;YAGf,wBAAwB,kBAClC;EACE,aAAa;EACb,UAAU,GAAG,eAAe;EAC5B,kBACE,mBAAmB,gBACnB,UAAU,yBACV,aAAa,kCACb,UAAU,GAAG,eAAe,kBACzB,YAAY,QAAQ;;;;;;;;;qBAehB,0BAAkB;;;;;;;;;;;;;;;;;;;;;;;;;qBA+ClB,kBAAkB,GAAG"}

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

@@ -1,8 +1,7 @@
 import { HTMLComponents } from "../html/HTMLComponentTypes.js";
-import { ParsedMarkdown } from "./processor.js";
 import { MarkdownProviderOptions } from "./MarkdownProvider.js";
+import { ParsedMarkdown } from "./processor.js";
 import { FC, HTMLAttributes, JSX, ReactNode } from "react";
-//#region src/markdown/MarkdownRenderer.d.ts
 /**
  * Props for rendering markdown content.
  *
@@ -238,5 +237,4 @@ export type MarkdownRendererProps = RenderMarkdownProps & {
  * ```
  */
 export declare const MarkdownRenderer: FC<MarkdownRendererProps>;
-//#endregion
 //# 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":";;;;;;;;;;;;;;;;;;;;;;;;YAiCY,sBAAsB;;;;;;;;;;;;;;EAchC,aAAa;;;;;;;;;;EAUb,UAAU,GAAG,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA4BjB,iBAAc,kBACP,kBAAc,YAAA,SAAA,YAAA,aAAA,qBAAA,cAQ7B,wBACF,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA4DM,wBAAmB,YAAA,SAAA,YAAA,aAAA,qBAAA,cAO7B,yBAAmB,kBAGM,wDAAc,IAAA,UAAA,SAAA,aAAA,QAAA;;;;;;;;;;;;;;;;YAyC9B,wBAAwB;;;;;;;;;;;EAWlC,mBAAmB;;;;;;;;;;;;;;;;;;;;;EAqBnB,kBACE,mBAAmB,gBACnB;IACE,aAAa;IACb,UAAU;IACV;IACA;IACA;IACA;QAEC,YAAY,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAgEd,kBAAkB,GAAG"}
+{"version":3,"file":"MarkdownRenderer.d.ts","names":[],"sources":["../../../src/markdown/MarkdownRenderer.tsx"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;YAiCY,sBAAsB;;;;;;;;;;;;;;EAchC,aAAa;;;;;;;;;;EAUb,UAAU,GAAG,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA4BjB,iBAAc,kBACP,kBAAc,YAAA,SAAA,YAAA,aAAA,qBAAA,cAQ7B,wBACF,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA4DM,wBAAmB,YAAA,SAAA,YAAA,aAAA,qBAAA,cAO7B,yBAAmB,kBAGM,wDAAc,IAAA,UAAA,SAAA,aAAA,QAAA;;;;;;;;;;;;;;;;YAyC9B,wBAAwB;;;;;;;;;;;EAWlC,mBAAmB;;;;;;;;;;;;;;;;;;;;;EAqBnB,kBACE,mBAAmB,gBACnB;IACE,aAAa;IACb,UAAU;IACV;IACA;IACA;IACA;QAEC,YAAY,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAgEd,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;
   keyPath: KeyPath[];
@@ -13,5 +12,5 @@ type MarkdownRendererPluginProps = {
   components?: HTMLComponents<'permissive', {}>;
 };
 export declare const MarkdownRendererPlugin: FC<MarkdownRendererPluginProps>;
-//#endregion
+export {};
 //# 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":";;;;;;KAYK;EACH;EACA,SAAS;EACT,SAAS;EACT;EACA,UAAU;EACV,aAAa;;qBAGF,wBAAwB,GAAG"}
+{"version":3,"file":"MarkdownRendererPlugin.d.ts","names":[],"sources":["../../../src/markdown/MarkdownRendererPlugin.tsx"],"mappings":";;;;;KAYK;EACH;EACA,SAAS;EACT,SAAS;EACT;EACA,UAAU;EACV,aAAa;;qBAGF,wBAAwB,GAAG"}

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

@@ -1,4 +1,4 @@
-import { MarkdownRendererOptions, ParsedMarkdown, compileMarkdown, parseMarkdown } from "./processor.js";
 import { MarkdownContextValue, MarkdownProvider, MarkdownProviderOptions, MarkdownProviderProps, useMarkdownContext } from "./MarkdownProvider.js";
 import { MarkdownRenderer, MarkdownRendererProps, RenderMarkdownProps, renderMarkdown, useMarkdownRenderer } from "./MarkdownRenderer.js";
+import { MarkdownRendererOptions, ParsedMarkdown, compileMarkdown, parseMarkdown } from "./processor.js";
 export { type MarkdownContextValue, MarkdownProvider, type MarkdownProviderOptions, type MarkdownProviderProps, MarkdownRenderer, type MarkdownRendererOptions, type MarkdownRendererProps, type ParsedMarkdown, type RenderMarkdownProps, compileMarkdown, parseMarkdown, renderMarkdown, useMarkdownContext, useMarkdownRenderer };

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;
 /**
  * Refined MarkdownRendererOptions type.
@@ -107,6 +106,5 @@ export declare const parseMarkdown: (markdown?: string, options?: MarkdownRender
  * ```
  */
 export declare const compileMarkdown: (input?: string | ParsedMarkdown, options?: MarkdownRendererOptions) => JSX.Element;
-//#endregion
 export type { ParsedMarkdown };
 //# sourceMappingURL=processor.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"processor.d.ts","names":[],"sources":["../../../src/markdown/processor.tsx"],"mappings":";;;;KAmBK,iBAAiB,IAAI;;;;YAKd,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;;;;;;;;;;;;;;;;;;;;qBAgCW,gBAAa,mBACR,UACP,4BACR;;;;;;;;;;;;;;;;qBAuDU,kBAAe,iBACV,gBAAc,UACrB,4BACR,IAAI"}
+{"version":3,"file":"processor.d.ts","names":[],"sources":["../../../src/markdown/processor.tsx"],"mappings":";;;KAmBK,iBAAiB,IAAI;;;;YAKd,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;;;;;;;;;;;;;;;;;;;;qBAgCW,gBAAa,mBACR,UACP,4BACR;;;;;;;;;;;;;;;;qBAuDU,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.
  * Implements the MarkdownRuntime interface using React's primitives.
@@ -13,5 +12,4 @@ export declare const reactRuntime: MarkdownRuntime;
 export declare const createReactRuntime: (options?: {
   onCreateElement?: (type: string | any, props: Record<string, any> | null, children: any[]) => ReactNode;
 }) => MarkdownRuntime;
-//#endregion
 //# 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":";;;;;;;qBA+Ba,cAAc;;;;;qBA2Ed,qBAAkB;EAE3B,mBACE,oBACA,OAAO,4BACP,oBACG;MAEN"}
+{"version":3,"file":"runtime.d.ts","names":[],"sources":["../../../src/markdown/runtime.ts"],"mappings":";;;;;;qBA+Ba,cAAc;;;;;qBA2Ed,qBAAkB;EAE3B,mBACE,oBACA,OAAO,4BACP,oBACG;MAEN"}

package/dist/types/plugins.d.ts

@@ -1,11 +1,10 @@
-import { IntlayerNode } from "./IntlayerNode.js";
 import { HTMLComponents } from "./html/HTMLComponentTypes.js";
+import { IntlayerNode } from "./IntlayerNode.js";
 import { DeepTransformContent as DeepTransformContent$1, IInterpreterPluginState as IInterpreterPluginState$1, Plugins } from "@intlayer/core/interpreter";
 import { DeclaredLocales, LocalesValues } from "@intlayer/types/module_augmentation";
 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
  *  --------------------------------------------- */
@@ -98,5 +97,4 @@ export type DeepTransformContent<T, L extends LocalesValues = DeclaredLocales> =
  * This function is used by both getIntlayer and getDictionary to ensure consistent plugin configuration.
  */
 export declare const getPlugins: (locale?: LocalesValues, fallback?: boolean) => Plugins[];
-//#endregion
 //# 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":";;;;;;;;;;;YAgEY,iBAAiB,KAAK,4BAC9B,aAAa;;qBAIJ,qBAAqB;;;;YA2CtB,cAAc,KAAK;EAC7B;EACA;IAEE;;qBAIS,kBAAkB;;;;YA8CnB,cAAc,KAAK;EAC7B,UAAU;GACT,UAAU,kBAAkB;EAC7B;KAEG,aAAa,KAAK,sBAAsB,cACvC,QAAQ,MACL,mBACD,QAAQ,6BACN,uBACA,aAAa,aACf,qBAAqB;;qBA4BhB,iBAAiB;;;;YAuFlB,mBAAmB,KAAK,mBAChC;EAGI,UAAU;EACV,MAAM,YAAY,qCAAqC;;;qBAiBlD,sBAAsB;YAqEvB,aAAa,KAAK;EAC5B,UAAU;GACT,UAAU,iBAAiB;EAC5B,aAAa;EACb,iBAAiB;IAEf,aACE;EAEE,MAAM,aAAa,6BAA6B,OAAO;EACvD,UAAU,qBAAqB;;qBAK1B,gBAAgB;;;;;;;;;;;;YAsCjB,eAAe,KAAK;EAC9B,UAAU;GACT,UAAU,aAAa;EACxB,aAAa;IAEX,aACE;EAEE,MAAM,aAAa,6BAA6B,OAAO;;;qBAclD,YAAY;;;;YA6Cb,wBAAwB,GAAG,IAAI,WAAW;EACpD,WAAW,cAAc;EACzB,mBAAmB,iBAAiB;EACpC,gBAAgB,cAAc;EAC9B,eAAe,aAAa;EAC5B,WAAW,eAAe;;;;;;;YAQhB,0BAA0B,KACpC;EAGA;EACA;EACA;EACA;EACA;;YAGU,qBACV,GACA,UAAU,gBAAgB,mBACxB,uBAAyB,GAAG,yBAAyB;;;;;qBAQ5C,aAAU,SACZ,eAAa,uBAErB"}
+{"version":3,"file":"plugins.d.ts","names":["IInterpreterPluginStateCore","DeepTransformContentCore"],"sources":["../../src/plugins.tsx"],"mappings":";;;;;;;;;;YAgEY,iBAAiB,KAAK,4BAC9B,aAAa;;qBAIJ,qBAAqB;;;;YA2CtB,cAAc,KAAK;EAC7B;EACA;IAEE;;qBAIS,kBAAkB;;;;YA8CnB,cAAc,KAAK;EAC7B,UAAU;GACT,UAAU,kBAAkB;EAC7B;KAEG,aAAa,KAAK,sBAAsB,cACvC,QAAQ,MACL,mBACD,QAAQ,6BACN,uBACA,aAAa,aACf,qBAAqB;;qBA4BhB,iBAAiB;;;;YAuFlB,mBAAmB,KAAK,mBAChC;EAGI,UAAU;EACV,MAAM,YAAY,qCAAqC;;;qBAiBlD,sBAAsB;YAqEvB,aAAa,KAAK;EAC5B,UAAU;GACT,UAAU,iBAAiB;EAC5B,aAAa;EACb,iBAAiB;IAEf,aACE;EAEE,MAAM,aAAa,6BAA6B,OAAO;EACvD,UAAU,qBAAqB;;qBAK1B,gBAAgB;;;;;;;;;;;;YAsCjB,eAAe,KAAK;EAC9B,UAAU;GACT,UAAU,aAAa;EACxB,aAAa;IAEX,aACE;EAEE,MAAM,aAAa,6BAA6B,OAAO;;;qBAclD,YAAY;;;;YA6Cb,wBAAwB,GAAG,IAAI,WAAW;EACpD,WAAW,cAAc;EACzB,mBAAmB,iBAAiB;EACpC,gBAAgB,cAAc;EAC9B,eAAe,aAAa;EAC5B,WAAW,eAAe;;;;;;;YAQhB,0BAA0B,KACpCA;EAGA;EACA;EACA;EACA;EACA;;YAGU,qBACV,GACA,UAAU,gBAAgB,mBACxBC,uBAAyB,GAAG,yBAAyB;;;;;qBAQ5C,aAAU,SACZ,eAAa,uBAErB"}

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"renderReactElement.d.ts","names":[],"sources":["../../../src/reactElement/renderReactElement.ts"],"mappings":";;qBAGa,qBAAkB,SAAa"}
+{"version":3,"file":"renderReactElement.d.ts","names":[],"sources":["../../../src/reactElement/renderReactElement.ts"],"mappings":";qBAGa,qBAAkB,SAAa"}

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

@@ -1,7 +1,6 @@
 import { ServerContext } from "./serverContext.js";
 import { LocalesValues, ProviderVariant } from "@intlayer/types/module_augmentation";
 import { FC, PropsWithChildren } from "react";
-//#region src/server/IntlayerServerProvider.d.ts
 /**
  * Context that store the current locale on the server side
  */
@@ -59,5 +58,4 @@ export type IntlayerServerProviderProps = PropsWithChildren & {
  * Provider that store the current locale on the server side
  */
 export declare const IntlayerServerProvider: FC<IntlayerServerProviderProps>;
-//#endregion
 //# sourceMappingURL=IntlayerServerProvider.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"IntlayerServerProvider.d.ts","names":[],"sources":["../../../src/server/IntlayerServerProvider.tsx"],"mappings":";;;;;;;qBAea,uBAAqB,cAAA;;;;;;;qBAerB,8BAA4B,cAAA;;;;qBAM5B,mBAAW;;;;qBAKX,QAAM;;;;;;;;;;;;;;;;qBAiBN,YAAS,QAAY;;;;;;qBASrB,aAAU,SAAa;YAIxB,8BAA8B;EACxC,SAAS;;;;;;;;;EAST,UAAU;;;;;qBAMC,wBAAwB,GAAG"}
+{"version":3,"file":"IntlayerServerProvider.d.ts","names":["_$__serverContext0.ServerContext"],"sources":["../../../src/server/IntlayerServerProvider.tsx"],"mappings":";;;;;;qBAea,uBAAqBA,cAAA;;;;;;;qBAerB,8BAA4BA,cAAA;;;;qBAM5B,mBAAW;;;;qBAKX,QAAM;;;;;;;;;;;;;;;;qBAiBN,YAAS,QAAY;;;;;;qBASrB,aAAU,SAAa;YAIxB,8BAA8B;EACxC,SAAS;;;;;;;;;EAST,UAAU;;;;;qBAMC,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
  * bound to the current application locale.
@@ -11,5 +10,4 @@ import { compact } from "@intlayer/core/formatters";
  * ```
  */
 export declare const useCompact: () => (...args: Parameters<typeof compact>) => string;
-//#endregion
 //# sourceMappingURL=useCompact.d.ts.map

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":";;;;;;;;;;;;qBAea,sBAAU,MAGJ,kBAAkB"}
+{"version":3,"file":"useCompact.d.ts","names":[],"sources":["../../../../src/server/format/useCompact.ts"],"mappings":";;;;;;;;;;;qBAea,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
  * bound to the current application locale.
@@ -22,5 +21,4 @@ import { currency } from "@intlayer/core/formatters";
  * ```
  */
 export declare const useCurrency: () => (...args: Parameters<typeof currency>) => string;
-//#endregion
 //# sourceMappingURL=useCurrency.d.ts.map

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":";;;;;;;;;;;;;;;;;;;;;;;qBA0Ba,uBAAW,MAGL,kBAAkB"}
+{"version":3,"file":"useCurrency.d.ts","names":[],"sources":["../../../../src/server/format/useCurrency.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;qBA0Ba,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
  * bound to the current application locale.
@@ -27,5 +26,4 @@ import { date } from "@intlayer/core/formatters";
  * @see createDate
  */
 export declare const useDate: () => (...args: Parameters<typeof date>) => string;
-//#endregion
 //# sourceMappingURL=useDate.d.ts.map

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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA+Ba,mBAAO,MAGD,kBAAkB"}
+{"version":3,"file":"useDate.d.ts","names":[],"sources":["../../../../src/server/format/useDate.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;qBA+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.
  *
@@ -30,5 +29,4 @@ import { WrappedIntl } from "@intlayer/core/formatters";
  * ```
  */
 export declare const useIntl: (locale?: LocalesValues) => WrappedIntl;
-//#endregion
 //# sourceMappingURL=useIntl.d.ts.map

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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAkCa,UAAO,SAAa,kBAAgB"}
+{"version":3,"file":"useIntl.d.ts","names":[],"sources":["../../../../src/server/format/useIntl.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAiCa,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
  * bound to the current application locale.
@@ -19,5 +18,4 @@ import { list } from "@intlayer/core/formatters";
  * ```
  */
 export declare const useList: () => (...args: Parameters<typeof list>) => string;
-//#endregion
 //# sourceMappingURL=useList.d.ts.map

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":";;;;;;;;;;;;;;;;;;;;qBAuBa,mBAAO,MAGD,kBAAkB"}
+{"version":3,"file":"useList.d.ts","names":[],"sources":["../../../../src/server/format/useList.ts"],"mappings":";;;;;;;;;;;;;;;;;;;qBAuBa,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.
  *
@@ -23,5 +22,4 @@ import { number } from "@intlayer/core/formatters";
  * A number formatting function bound to the active locale.
  */
 export declare const useNumber: () => (...args: Parameters<typeof number>) => string;
-//#endregion
 //# sourceMappingURL=useNumber.d.ts.map

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":";;;;;;;;;;;;;;;;;;;;;;;;qBA2Ba,qBAAS,MAGH,kBAAkB"}
+{"version":3,"file":"useNumber.d.ts","names":[],"sources":["../../../../src/server/format/useNumber.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;qBA2Ba,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
  * based on the current application locale.
@@ -19,5 +18,4 @@ import { percentage } from "@intlayer/core/formatters";
  * A function that formats numbers or numeric strings into localized percentages.
  */
 export declare const usePercentage: () => (...args: Parameters<typeof percentage>) => string;
-//#endregion
 //# sourceMappingURL=usePercentage.d.ts.map

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":";;;;;;;;;;;;;;;;;;;;qBAuBa,yBAAa,MAGP,kBAAkB"}
+{"version":3,"file":"usePercentage.d.ts","names":[],"sources":["../../../../src/server/format/usePercentage.ts"],"mappings":";;;;;;;;;;;;;;;;;;;qBAuBa,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.
  *
@@ -19,5 +18,4 @@ import { relativeTime } from "@intlayer/core/formatters";
  *          bound to the current client locale.
  */
 export declare const useRelativeTime: () => (...args: Parameters<typeof relativeTime>) => string;
-//#endregion
 //# sourceMappingURL=useRelativeTime.d.ts.map

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":";;;;;;;;;;;;;;;;;;;;qBAuBa,2BAAe,MAGT,kBAAkB"}
+{"version":3,"file":"useRelativeTime.d.ts","names":[],"sources":["../../../../src/server/format/useRelativeTime.ts"],"mappings":";;;;;;;;;;;;;;;;;;;qBAuBa,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
  * based on the current locale from {@link useLocaleBase}.
@@ -18,5 +17,4 @@ import { units } from "@intlayer/core/formatters";
  * @returns {Function} A unit formatting function that accepts a value and optional formatting options.
  */
 export declare const useUnit: () => (...args: Parameters<typeof units>) => string;
-//#endregion
 //# sourceMappingURL=useUnit.d.ts.map

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":";;;;;;;;;;;;;;;;;;;qBAsBa,mBAAO,MAGD,kBAAkB"}
+{"version":3,"file":"useUnit.d.ts","names":[],"sources":["../../../../src/server/format/useUnit.ts"],"mappings":";;;;;;;;;;;;;;;;;;qBAsBa,mBAAO,MAGD,kBAAkB"}

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

@@ -1,6 +1,6 @@
-import { ServerContext, getServerContext } from "./serverContext.js";
-import { IntlayerServerContext, IntlayerServerProvider, IntlayerServerProviderProps, IntlayerServerVariantContext, locale, setLocale, setVariant } from "./IntlayerServerProvider.js";
 import { useIntl } from "./format/useIntl.js";
+import { IntlayerServerContext, IntlayerServerProvider, IntlayerServerProviderProps, IntlayerServerVariantContext, locale, setLocale, setVariant } from "./IntlayerServerProvider.js";
+import { ServerContext, getServerContext } from "./serverContext.js";
 import { t } from "./t.js";
 import { useDictionary } from "./useDictionary.js";
 import { useDictionaryAsync } from "./useDictionaryAsync.js";

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

@@ -1,5 +1,4 @@
 import { FC, PropsWithChildren, ReactNode } from "react";
-//#region src/server/serverContext.d.ts
 export declare const createServerContext: <T>(defaultValue?: T) => ServerContext<T>;
 /**
  * Fetches a value present in a given server context.
@@ -23,5 +22,4 @@ export type ServerContext<T> = FC<PropsWithChildren<{
   };
   _defaultValue: T | undefined;
 };
-//#endregion
 //# sourceMappingURL=serverContext.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"serverContext.d.ts","names":[],"sources":["../../../src/server/serverContext.tsx"],"mappings":";;qBAiBa,sBAAuB,GAAC,eAAkB,MAAI,cAAc;;;;;;;;qBAqC5D,mBAAoB,KAAC,UAAA,iBAG/B,cAAc,OAAE;YAOP,cAAc,KAAK,GAAG;EAAoB,QAAQ;;EAC5D,UAAU,GAAG;IAAoB,QAAQ;;EACzC,UAAU,GACR;IAAoB,WAAW,SAAS,kBAAkB;;EAE5D;IAAkB,OAAO;;EACzB,eAAe"}
+{"version":3,"file":"serverContext.d.ts","names":[],"sources":["../../../src/server/serverContext.tsx"],"mappings":";qBAiBa,sBAAuB,GAAC,eAAkB,MAAI,cAAc;;;;;;;;qBAqC5D,mBAAoB,KAAC,UAAA,iBAG/B,cAAc,OAAE;YAOP,cAAc,KAAK,GAAG;EAAoB,QAAQ;;EAC5D,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
  *
@@ -22,5 +21,4 @@ import { DeclaredLocales, LocalesValues, StrictModeLocaleMap } from "@intlayer/t
  * - If a locale is missing, it will make each existing locale optional and raise an error if the locale is not found.
  */
 export declare const t: <Content = string, L extends LocalesValues = DeclaredLocales>(multilangContent: StrictModeLocaleMap<Content>, locale?: L) => Content;
-//#endregion
 //# sourceMappingURL=t.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"t.d.ts","names":[],"sources":["../../../src/server/t.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;qBA8Ba,IAAK,kBAAkB,UAAU,gBAAgB,iBAAe,kBACzD,oBAAoB,UAAQ,SACrC,MAAC"}
+{"version":3,"file":"t.d.ts","names":[],"sources":["../../../src/server/t.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;qBA8Ba,IAAK,kBAAkB,UAAU,gBAAgB,iBAAe,kBACzD,oBAAoB,UAAQ,SACrC,MAAC"}

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

@@ -1,7 +1,6 @@
 import { IInterpreterPluginState } from "../plugins.js";
 import { DeclaredLocales, LocalesValues } from "@intlayer/types/module_augmentation";
 import { Dictionary, DictionarySelectorForGroup, QualifiedDictionaryGroup } from "@intlayer/types/dictionary";
-//#region src/server/useDictionary.d.ts
 /**
  * On the server side, Hook that transform a dictionary (or qualified
  * dictionary group) and return the content
@@ -10,5 +9,4 @@ import { Dictionary, DictionarySelectorForGroup, QualifiedDictionaryGroup } from
  * use the locale from the server context
  */
 export 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
 //# 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":";;;;;;;;;;;qBAyBa,sBACL,UAAU,aAAa,gCACvB,UACF,gBACA,2BAA2B,KAAK,iBAAe,YAEvC,GAAC,mBACM,GAAC,iBACH,yDAAe,+CAAA,kCAAA,GAAA,IAAA,mDAAA,sBAAA"}
+{"version":3,"file":"useDictionary.d.ts","names":["_$___plugins0.IInterpreterPluginState"],"sources":["../../../src/server/useDictionary.ts"],"mappings":";;;;;;;;;;qBAyBa,sBACL,UAAU,aAAa,gCACvB,UACF,gBACA,2BAA2B,KAAK,iBAAe,YAEvC,GAAC,mBACM,GAAC,iBACH,yDAAe,+CAAA,kCAAA,GAAA,IAAAA,mDAAA,sBAAA"}

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

@@ -1,12 +1,10 @@
 import { IInterpreterPluginState } from "../plugins.js";
 import { DeclaredLocales, LocalesValues, StrictModeLocaleMap } from "@intlayer/types/module_augmentation";
 import { Dictionary } from "@intlayer/types/dictionary";
-//#region src/server/useDictionaryAsync.d.ts
 /**
  * On the server side, Hook that transform a dictionary and return the content
  *
  * If the locale is not provided, it will use the locale from the server context
  */
 export declare const useDictionaryAsync: <const T extends Dictionary, const L extends LocalesValues = DeclaredLocales>(dictionaryPromise: StrictModeLocaleMap<() => Promise<T>>, locale?: L, fallbackLocale?: DeclaredLocales) => Promise<import("@intlayer/core/interpreter").DeepTransformContent<import("@intlayer/types").ResolveQualifiedDictionaryContent<T, L>, IInterpreterPluginState, import("@intlayer/types").ExtractSelectorLocale<L>>>;
-//#endregion
 //# sourceMappingURL=useDictionaryAsync.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"useDictionaryAsync.d.ts","names":[],"sources":["../../../src/server/useDictionaryAsync.ts"],"mappings":";;;;;;;;;qBAgBa,2BACL,UAAU,kBACV,UAAU,gBAAgB,iBAAe,mBAE5B,0BAA0B,QAAQ,KAAG,SAC/C,GAAC,iBACO,oBAAe,6CAAA,+CAAA,kCAAA,GAAA,IAAA,mDAAA,sBAAA"}
+{"version":3,"file":"useDictionaryAsync.d.ts","names":["_$___plugins0.IInterpreterPluginState"],"sources":["../../../src/server/useDictionaryAsync.ts"],"mappings":";;;;;;;;qBAgBa,2BACL,UAAU,kBACV,UAAU,gBAAgB,iBAAe,mBAE5B,0BAA0B,QAAQ,KAAG,SAC/C,GAAC,iBACO,oBAAe,6CAAA,+CAAA,kCAAA,GAAA,IAAAA,mDAAA,sBAAA"}

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

@@ -1,7 +1,6 @@
 import { DeclaredLocales, LocalesValues, StrictModeLocaleMap } from "@intlayer/types/module_augmentation";
 import { Dictionary, DictionarySelector } from "@intlayer/types/dictionary";
 import { QualifiedDynamicLoaderMap } from "@intlayer/core/dictionaryManipulator";
-//#region src/server/useDictionaryDynamic.d.ts
 /**
  * Server-side hook that lazily loads a dictionary and returns its content.
  *
@@ -14,5 +13,4 @@ import { QualifiedDynamicLoaderMap } from "@intlayer/core/dictionaryManipulator"
  * context locale is used.
  */
 export declare const useDictionaryDynamic: <const T extends Dictionary, const A extends LocalesValues | DictionarySelector = DeclaredLocales>(dictionaryPromise: StrictModeLocaleMap<() => Promise<T>> | QualifiedDynamicLoaderMap, key: string, localeOrSelector?: A, fallbackLocale?: DeclaredLocales) => any;
-//#endregion
 //# sourceMappingURL=useDictionaryDynamic.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"useDictionaryDynamic.d.ts","names":[],"sources":["../../../src/server/useDictionaryDynamic.ts"],"mappings":";;;;;;;;;;;;;;;qBAwCa,6BACL,UAAU,kBACV,UAAU,gBAAgB,qBAAqB,iBAAe,mBAGhE,0BAA0B,QAAQ,MAClC,2BAAyB,aAClB,mBACQ,GAAC,iBACH"}
+{"version":3,"file":"useDictionaryDynamic.d.ts","names":[],"sources":["../../../src/server/useDictionaryDynamic.ts"],"mappings":";;;;;;;;;;;;;;qBAwCa,6BACL,UAAU,kBACV,UAAU,gBAAgB,qBAAqB,iBAAe,mBAGhE,0BAA0B,QAAQ,MAClC,2BAAyB,aAClB,mBACQ,GAAC,iBACH"}

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

@@ -2,7 +2,6 @@ import { DeepTransformContent } from "../plugins.js";
 import { DictionaryKeys, DictionaryRegistryContent, LocalesValues } from "@intlayer/types/module_augmentation";
 import { ValidDotPathsFor } from "@intlayer/core/transpiler";
 import { GetSubPath } from "@intlayer/types/dictionary";
-//#region src/server/useI18n.d.ts
 /**
  * Hook that provides a translation function `t()` for accessing nested content by key.
  * This hook mimics the pattern found in libraries like i18next, next-intl, and vue-i18n.
@@ -19,5 +18,4 @@ import { GetSubPath } from "@intlayer/types/dictionary";
  * ```
  */
 export declare const useI18n: <T extends DictionaryKeys>(namespace: T, locale?: LocalesValues) => <P extends ValidDotPathsFor<T>>(path: P) => GetSubPath<DeepTransformContent<DictionaryRegistryContent<T>>, P>;
-//#endregion
 //# sourceMappingURL=useI18n.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"useI18n.d.ts","names":[],"sources":["../../../src/server/useI18n.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;qBA2Ba,UAAW,UAAU,gBAAc,WACnC,GAAC,SACH,mBAUE,UAAU,iBAAiB,IAAE,MAChC,MACL,WAAW,qBAAqB,0BAA0B,KAAK"}
+{"version":3,"file":"useI18n.d.ts","names":[],"sources":["../../../src/server/useI18n.ts"],"mappings":";;;;;;;;;;;;;;;;;;;qBA2Ba,UAAW,UAAU,gBAAc,WACnC,GAAC,SACH,mBAUE,UAAU,iBAAiB,IAAE,MAChC,MACL,WAAW,qBAAqB,0BAA0B,KAAK"}

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

@@ -1,6 +1,5 @@
 import { IInterpreterPluginState } from "../plugins.js";
 import { DeclaredLocales, DictionaryKeys, DictionarySelectorForKey, LocalesValues } from "@intlayer/types/module_augmentation";
-//#region src/server/useIntlayer.d.ts
 /**
  * On the server side, Hook that picking one dictionary by its key and return the content
  *
@@ -10,5 +9,4 @@ import { DeclaredLocales, DictionaryKeys, DictionarySelectorForKey, LocalesValue
  * If the locale is not provided, it will use the locale from the server context
  */
 export declare const useIntlayer: <const T extends DictionaryKeys, const A extends LocalesValues | DictionarySelectorForKey<T> = DeclaredLocales>(key: T, localeOrSelector?: A, fallbackLocale?: DeclaredLocales) => import("@intlayer/core/interpreter").DeepTransformContent<import("@intlayer/types").DictionaryRegistryResult<T, A>, IInterpreterPluginState, import("@intlayer/types").ExtractSelectorLocale<A>>;
-//#endregion
 //# sourceMappingURL=useIntlayer.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"useIntlayer.d.ts","names":[],"sources":["../../../src/server/useIntlayer.ts"],"mappings":";;;;;;;;;;;qBAuBa,oBACL,UAAU,sBACV,UAAU,gBAAgB,yBAAyB,KAAK,iBAAe,KAExE,GAAC,mBACa,GAAC,iBACH,yDAAe,+CAAA,yBAAA,GAAA,IAAA,mDAAA,sBAAA"}
+{"version":3,"file":"useIntlayer.d.ts","names":["_$___plugins0.IInterpreterPluginState"],"sources":["../../../src/server/useIntlayer.ts"],"mappings":";;;;;;;;;;qBAuBa,oBACL,UAAU,sBACV,UAAU,gBAAgB,yBAAyB,KAAK,iBAAe,KAExE,GAAC,mBACa,GAAC,iBACH,yDAAe,+CAAA,yBAAA,GAAA,IAAAA,mDAAA,sBAAA"}

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

@@ -1,4 +1,2 @@
-//#region src/server/useLoadDynamic.d.ts
 export declare const useLoadDynamic: <T>(_key: string, promise: Promise<T>) => T;
-//#endregion
 //# sourceMappingURL=useLoadDynamic.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"useLoadDynamic.d.ts","names":[],"sources":["../../../src/server/useLoadDynamic.ts"],"mappings":";qBAEa,iBAAkB,GAAC,cAAc,SAAW,QAAQ,OAAK"}
+{"version":3,"file":"useLoadDynamic.d.ts","names":[],"sources":["../../../src/server/useLoadDynamic.ts"],"mappings":"A,qBAEa,iBAAkB,GAAC,cAAc,SAAW,QAAQ,OAAK"}

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

@@ -1,5 +1,4 @@
 import { DeclaredLocales } from "@intlayer/types/module_augmentation";
-//#region src/server/useLocale.d.ts
 export type UseLocaleResult = {
   locale: DeclaredLocales;
   defaultLocale: DeclaredLocales;
@@ -11,5 +10,4 @@ export type UseLocaleResult = {
  * If the locale is not provided, it will use the locale from the server context
  */
 export declare const useLocale: () => UseLocaleResult;
-//#endregion
 //# sourceMappingURL=useLocale.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"useLocale.d.ts","names":[],"sources":["../../../src/server/useLocale.ts"],"mappings":";;YAKY;EACV,QAAQ;EACR,eAAe;EACf,kBAAkB;;;;;;;qBAUP,iBAAgB"}
+{"version":3,"file":"useLocale.d.ts","names":[],"sources":["../../../src/server/useLocale.ts"],"mappings":";YAKY;EACV,QAAQ;EACR,eAAe;EACf,kBAAkB;;;;;;;qBAUP,iBAAgB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-intlayer",
-  "version": "9.6.0",
+  "version": "9.7.1",
   "private": false,
   "description": "Easily internationalize i18n your React applications with type-safe multilingual content management.",
   "keywords": [
@@ -133,33 +133,33 @@
     "typecheck": "tsc --noEmit --project tsconfig.types.json"
   },
   "dependencies": {
-    "@intlayer/api": "9.6.0",
-    "@intlayer/config": "9.6.0",
-    "@intlayer/core": "9.6.0",
-    "@intlayer/dictionaries-entry": "9.6.0",
-    "@intlayer/editor": "9.6.0",
-    "@intlayer/types": "9.6.0"
+    "@intlayer/api": "9.7.1",
+    "@intlayer/config": "9.7.1",
+    "@intlayer/core": "9.7.1",
+    "@intlayer/dictionaries-entry": "9.7.1",
+    "@intlayer/editor": "9.7.1",
+    "@intlayer/types": "9.7.1"
   },
   "devDependencies": {
     "@craco/types": "7.1.0",
     "@testing-library/react": "16.3.3",
-    "@types/node": "^22",
+    "@types/node": "^26",
     "@types/react": ">=16.0.0",
     "@types/react-dom": ">=16.0.0",
     "@utils/ts-config": "1.0.4",
     "@utils/ts-config-types": "1.0.4",
     "@utils/tsdown-config": "1.0.4",
     "rimraf": "6.1.3",
-    "tsdown": "0.23.0",
+    "tsdown": "0.23.4",
     "typescript": "7.0.2",
-    "vitest": "5.0.3"
+    "vitest": "5.1.0"
   },
   "peerDependencies": {
     "react": ">=16.0.0",
     "react-dom": ">=16.0.0"
   },
   "optionalDependencies": {
-    "@intlayer/analytics": "9.6.0"
+    "@intlayer/analytics": "9.7.1"
   },
   "engines": {
     "node": ">=14.18"