react-intlayer 9.7.0 → 9.7.1

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

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

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

@@ -1,4 +1,3 @@
-//#region src/client/format/useRelativeTime.d.ts
 /**
  * Client-side React hook for accessing a localized relative time formatter.
  *
@@ -21,5 +20,4 @@ export declare const useRelativeTime: () => (from: string | number | Date, to?:
   locale?: import("@intlayer/types").LocalesValues;
   unit?: Intl.RelativeTimeFormatUnit;
 }) => string;
-//#endregion
 //# sourceMappingURL=useRelativeTime.d.ts.map

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

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

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

@@ -1,4 +1,3 @@
-//#region src/client/format/useUnit.d.ts
 /**
  * React hook that provides a unit formatting function
  * based on the current locale from {@link useLocaleBase}.
@@ -19,5 +18,4 @@
 export declare const useUnit: () => (value: string | number, options?: Intl.NumberFormatOptions & {
   locale?: import("@intlayer/types").LocalesValues;
 }) => string;
-//#endregion
 //# sourceMappingURL=useUnit.d.ts.map

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

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

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

@@ -1,5 +1,4 @@
 import { LocalesValues, StrictModeLocaleMap } from "@intlayer/types/module_augmentation";
-//#region src/client/t.d.ts
 /**
  * Client-side translation function that returns the translation of the provided multilang content.
  *
@@ -25,5 +24,4 @@ import { LocalesValues, StrictModeLocaleMap } from "@intlayer/types/module_augme
  * ```
  */
 export declare const t: <Content = string>(multilangContent: StrictModeLocaleMap<Content>, locale?: LocalesValues) => Content;
-//#endregion
 //# sourceMappingURL=t.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"t.d.ts","names":[],"sources":["../../../src/client/t.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;qBAkCa,IAAK,kBAAgB,kBACd,oBAAoB,UAAQ,SACrC,kBAAa"}
+{"version":3,"file":"t.d.ts","names":[],"sources":["../../../src/client/t.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;qBAkCa,IAAK,kBAAgB,kBACd,oBAAoB,UAAQ,SACrC,kBAAa"}

package/dist/types/client/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/client/useDictionary.d.ts
 /**
  * Client-side hook that transforms a dictionary (or qualified dictionary
  * group) and returns the content.
@@ -11,5 +10,4 @@ import { Dictionary, DictionarySelectorForGroup, QualifiedDictionaryGroup } from
  * which falls back to the provider's ambient `variant`.
  */
 export declare const useDictionary: <const T extends Dictionary | QualifiedDictionaryGroup, const A extends LocalesValues | DictionarySelectorForGroup<T> = DeclaredLocales>(dictionary: T, localeOrSelector?: A) => 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/client/useDictionary.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useDictionary.d.ts","names":[],"sources":["../../../src/client/useDictionary.ts"],"mappings":";;;;;;;;;;;;qBA2Ba,sBACL,UAAU,aAAa,gCACvB,UACF,gBACA,2BAA2B,KAAK,iBAAe,YAEvC,GAAC,mBACM,2CAAC,+CAAA,kCAAA,GAAA,IAAA,mDAAA,sBAAA"}
+{"version":3,"file":"useDictionary.d.ts","names":["_$___plugins0.IInterpreterPluginState"],"sources":["../../../src/client/useDictionary.ts"],"mappings":";;;;;;;;;;;qBA2Ba,sBACL,UAAU,aAAa,gCACvB,UACF,gBACA,2BAA2B,KAAK,iBAAe,YAEvC,GAAC,mBACM,2CAAC,+CAAA,kCAAA,GAAA,IAAAA,mDAAA,sBAAA"}

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

@@ -1,11 +1,9 @@
 import { DeclaredLocales, LocalesValues, StrictModeLocaleMap } from "@intlayer/types/module_augmentation";
 import { Dictionary } from "@intlayer/types/dictionary";
-//#region src/client/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 client context
  */
 export declare const useDictionaryAsync: <const T extends Dictionary, const L extends LocalesValues = DeclaredLocales>(dictionaryPromise: StrictModeLocaleMap<() => Promise<T>>, locale?: L) => Promise<T>;
-//#endregion
 //# sourceMappingURL=useDictionaryAsync.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"useDictionaryAsync.d.ts","names":[],"sources":["../../../src/client/useDictionaryAsync.ts"],"mappings":";;;;;;;;qBAkBa,2BACL,UAAU,kBACV,UAAU,gBAAgB,iBAAe,mBAE5B,0BAA0B,QAAQ,KAAG,SAC/C,MACR,QAAQ"}
+{"version":3,"file":"useDictionaryAsync.d.ts","names":[],"sources":["../../../src/client/useDictionaryAsync.ts"],"mappings":";;;;;;;qBAkBa,2BACL,UAAU,kBACV,UAAU,gBAAgB,iBAAe,mBAE5B,0BAA0B,QAAQ,KAAG,SAC/C,MACR,QAAQ"}

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

@@ -1,7 +1,6 @@
 import { DeclaredLocales, DictionaryKeys, DictionarySelectorForKey, LocalesValues, StrictModeLocaleMap } from "@intlayer/types/module_augmentation";
 import { Dictionary } from "@intlayer/types/dictionary";
 import { QualifiedDynamicLoaderMap } from "@intlayer/core/dictionaryManipulator";
-//#region src/client/useDictionaryDynamic.d.ts
 /**
  * Client-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 K extends DictionaryKeys, const A extends LocalesValues | DictionarySelectorForKey<K> = DeclaredLocales>(dictionaryPromise: StrictModeLocaleMap<() => Promise<T>> | QualifiedDynamicLoaderMap, key: K, localeOrSelector?: A) => any;
-//#endregion
 //# sourceMappingURL=useDictionaryDynamic.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"useDictionaryDynamic.d.ts","names":[],"sources":["../../../src/client/useDictionaryDynamic.ts"],"mappings":";;;;;;;;;;;;;;;qBAsCa,6BACL,UAAU,kBACV,UAAU,sBACV,UAAU,gBAAgB,yBAAyB,KAAK,iBAAe,mBAGzE,0BAA0B,QAAQ,MAClC,2BAAyB,KACxB,GAAC,mBACa"}
+{"version":3,"file":"useDictionaryDynamic.d.ts","names":[],"sources":["../../../src/client/useDictionaryDynamic.ts"],"mappings":";;;;;;;;;;;;;;qBAsCa,6BACL,UAAU,kBACV,UAAU,sBACV,UAAU,gBAAgB,yBAAyB,KAAK,iBAAe,mBAGzE,0BAA0B,QAAQ,MAClC,2BAAyB,KACxB,GAAC,mBACa"}

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

@@ -2,7 +2,6 @@ import { DeepTransformContent } from "../plugins.js";
 import { DeclaredLocales, DictionaryKeys, DictionaryRegistryContent } from "@intlayer/types/module_augmentation";
 import { ValidDotPathsFor } from "@intlayer/core/transpiler";
 import { GetSubPath } from "@intlayer/types/dictionary";
-//#region src/client/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.
@@ -21,5 +20,4 @@ import { GetSubPath } from "@intlayer/types/dictionary";
  * ```
  */
 export declare const useI18n: <T extends DictionaryKeys, L extends DeclaredLocales = DeclaredLocales>(namespace: T, locale?: L) => <P extends ValidDotPathsFor<T>>(path: P) => GetSubPath<DeepTransformContent<DictionaryRegistryContent<T>>, P>;
-//#endregion
 //# sourceMappingURL=useI18n.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"useI18n.d.ts","names":[],"sources":["../../../src/client/useI18n.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;qBA+Ba,UACX,UAAU,gBACV,UAAU,kBAAkB,iBAAe,WAEhC,GAAC,SACH,OAkBE,UAAU,iBAAiB,IAAE,MAChC,MAEL,WAAW,qBAAqB,0BAA0B,KAAK"}
+{"version":3,"file":"useI18n.d.ts","names":[],"sources":["../../../src/client/useI18n.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;qBA+Ba,UACX,UAAU,gBACV,UAAU,kBAAkB,iBAAe,WAEhC,GAAC,SACH,OAkBE,UAAU,iBAAiB,IAAE,MAChC,MAEL,WAAW,qBAAqB,0BAA0B,KAAK"}

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

@@ -1,6 +1,5 @@
 import { IInterpreterPluginState } from "../plugins.js";
 import { DeclaredLocales, DictionaryKeys, DictionarySelectorForKey, LocalesValues } from "@intlayer/types/module_augmentation";
-//#region src/client/useIntlayer.d.ts
 /**
  * Client-side hook that picks one dictionary by its key and returns its content.
  *
@@ -30,5 +29,4 @@ import { DeclaredLocales, DictionaryKeys, DictionarySelectorForKey, LocalesValue
  * ```
  */
 export declare const useIntlayer: <const T extends DictionaryKeys, const A extends LocalesValues | DictionarySelectorForKey<T> = DeclaredLocales>(key: T, localeOrSelector?: A) => 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/client/useIntlayer.d.ts.map

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

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

@@ -1,4 +1,3 @@
-//#region src/client/useLoadDynamic.d.ts
 export declare const useLoadDynamic: <T>(key: string, promise: Promise<T>) => T;
 /**
  * Fills the same cache {@link useLoadDynamic} reads, ahead of render.
@@ -20,5 +19,4 @@ export declare const useLoadDynamic: <T>(key: string, promise: Promise<T>) => T;
  * @returns A promise that settles — never rejects — once the entry is readable.
  */
 export declare const preloadDynamic: <T>(key: string, loader: () => Promise<T>) => Promise<void>;
-//#endregion
 //# sourceMappingURL=useLoadDynamic.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"useLoadDynamic.d.ts","names":[],"sources":["../../../src/client/useLoadDynamic.ts"],"mappings":";qBAqCa,iBAAkB,GAAC,aAAa,SAAW,QAAQ,OAAK;;;;;;;;;;;;;;;;;;;;qBA2BxD,iBAAkB,GAAC,aACnB,cACG,QAAQ,OACrB"}
+{"version":3,"file":"useLoadDynamic.d.ts","names":[],"sources":["../../../src/client/useLoadDynamic.ts"],"mappings":"A,qBAqCa,iBAAkB,GAAC,aAAa,SAAW,QAAQ,OAAK;;;;;;;;;;;;;;;;;;;;qBA2BxD,iBAAkB,GAAC,aACnB,cACG,QAAQ,OACrB"}

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

@@ -1,5 +1,4 @@
 import { DeclaredLocales, LocalesValues } from "@intlayer/types/module_augmentation";
-//#region src/client/useLocale.d.ts
 export type UseLocaleProps = {
   isCookieEnabled?: boolean;
   onLocaleChange?: (locale: DeclaredLocales) => void;
@@ -34,5 +33,4 @@ export type UseLocaleResult = {
  * ```
  */
 export declare const useLocale: ({ isCookieEnabled, onLocaleChange }?: UseLocaleProps) => UseLocaleResult;
-//#endregion
 //# sourceMappingURL=useLocale.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"useLocale.d.ts","names":[],"sources":["../../../src/client/useLocale.ts"],"mappings":";;YAWY;EACV;EACA,kBAAkB,QAAQ;;YAGhB;EACV,QAAQ;EACR,eAAe;EACf,kBAAkB;EAClB,YAAY,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;qBA4BT,cAAS,iBAAA,mBAGnB,mBAAsB"}
+{"version":3,"file":"useLocale.d.ts","names":[],"sources":["../../../src/client/useLocale.ts"],"mappings":";YAWY;EACV;EACA,kBAAkB,QAAQ;;YAGhB;EACV,QAAQ;EACR,eAAe;EACf,kBAAkB;EAClB,YAAY,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;qBA4BT,cAAS,iBAAA,mBAGnB,mBAAsB"}

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

@@ -1,4 +1,3 @@
-//#region src/client/useLocaleBase.d.ts
 /**
  * On the client side, hook to get the current locale and all related fields
  */
@@ -8,5 +7,4 @@ export declare const useLocaleBase: () => {
   availableLocales: import("@intlayer/types").Locale[];
   setLocale: (newLocale: import("@intlayer/types").LocalesValues) => void;
 };
-//#endregion
 //# sourceMappingURL=useLocaleBase.d.ts.map

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

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

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

@@ -1,5 +1,4 @@
 import { LocalesValues } from "@intlayer/types/module_augmentation";
-//#region src/client/useLocaleStorage.d.ts
 /**
  * Reads the locale persisted in the browser storage (cookie, localStorage…).
  *
@@ -45,5 +44,4 @@ export declare const useLocaleStorage: (isCookieEnabled?: boolean) => {
  * Hook that provides the locale cookie and a function to set it
  */
 export declare const useLocaleCookie: typeof useLocaleStorage;
-//#endregion
 //# sourceMappingURL=useLocaleStorage.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"useLocaleStorage.d.ts","names":[],"sources":["../../../src/client/useLocaleStorage.ts"],"mappings":";;;;;;;;qBAgBa,oDAAkB;;;;;;;qBAQlB,2CAAe;;;;;;qBAOf,wCAAY;;;;qBAKZ,qBAAkB,QACrB,eAAa;;;;;;qBAaV,wBAAe;;;;qBAKf,mBAAgB;;sBAAhB;;;;;;;;;qBAiBA,wBAAe"}
+{"version":3,"file":"useLocaleStorage.d.ts","names":[],"sources":["../../../src/client/useLocaleStorage.ts"],"mappings":";;;;;;;qBAgBa,oDAAkB;;;;;;;qBAQlB,2CAAe;;;;;;qBAOf,wCAAY;;;;qBAKZ,qBAAkB,QACrB,eAAa;;;;;;qBAaV,wBAAe;;;;qBAKf,mBAAgB;;;;;;;;;;;qBAiBhB,wBAAe"}

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

@@ -1,4 +1,3 @@
-//#region src/client/usePathname.d.ts
 /**
  * React hook that returns the current pathname with the locale segment removed.
  *
@@ -18,5 +17,4 @@
  * ```
  */
 export declare const usePathname: () => string;
-//#endregion
 //# sourceMappingURL=usePathname.d.ts.map

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

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

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

@@ -1,4 +1,3 @@
-//#region src/client/useRewriteURL.d.ts
 /**
  * Client-side hook to manage URL rewrites without triggering a router navigation.
  * It uses `window.history.replaceState` to update the URL in the address bar.
@@ -18,5 +17,4 @@
  * ```
  */
 export declare const useRewriteURL: () => void;
-//#endregion
 //# sourceMappingURL=useRewriteURL.d.ts.map

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

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

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

@@ -1,5 +1,4 @@
 import { StrictModeLocaleMap } from "@intlayer/types/module_augmentation";
-//#region src/client/useTraduction.d.ts
 /**
  * On the client side, Hook that picking one dictionary by its id and return the content.
  *
@@ -22,5 +21,4 @@ import { StrictModeLocaleMap } from "@intlayer/types/module_augmentation";
  * - 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 useTranslation: <const Content = string>(languageContent: StrictModeLocaleMap<Content>) => Content;
-//#endregion
 //# sourceMappingURL=useTraduction.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"useTraduction.d.ts","names":[],"sources":["../../../src/client/useTraduction.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;qBA0Ba,uBAAwB,kBAAgB,iBAClC,oBAAoB,aACpC"}
+{"version":3,"file":"useTraduction.d.ts","names":[],"sources":["../../../src/client/useTraduction.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;qBA0Ba,uBAAwB,kBAAgB,iBAClC,oBAAoB,aACpC"}

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

@@ -1,7 +1,5 @@
 import { NodeProps } from "@intlayer/core/interpreter";
 import { FC, HTMLAttributes } from "react";
-//#region src/editor/ContentSelector.d.ts
 export type ContentSelectorProps = NodeProps & Omit<HTMLAttributes<HTMLDivElement>, 'children'>;
 export declare const ContentSelector: FC<ContentSelectorProps>;
-//#endregion
 //# sourceMappingURL=ContentSelector.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"ContentSelector.d.ts","names":[],"sources":["../../../src/editor/ContentSelector.tsx"],"mappings":";;;YAMY,uBAAuB,YACjC,KAAK,eAAe;qBAET,iBAAiB,GAAG"}
+{"version":3,"file":"ContentSelector.d.ts","names":[],"sources":["../../../src/editor/ContentSelector.tsx"],"mappings":";;YAMY,uBAAuB,YACjC,KAAK,eAAe;qBAET,iBAAiB,GAAG"}

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

@@ -1,5 +1,3 @@
 import { FC, PropsWithChildren } from "react";
-//#region src/editor/EditorProvider.d.ts
 export declare const EditorProvider: FC<PropsWithChildren>;
-//#endregion
 //# sourceMappingURL=EditorProvider.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"EditorProvider.d.ts","names":[],"sources":["../../../src/editor/EditorProvider.tsx"],"mappings":";;qBAGa,gBAAgB,GAAG"}
+{"version":3,"file":"EditorProvider.d.ts","names":[],"sources":["../../../src/editor/EditorProvider.tsx"],"mappings":";qBAGa,gBAAgB,GAAG"}

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

@@ -1,9 +1,7 @@
-//#region src/editor/useEditor.d.ts
 /**
  * Initializes the Intlayer editor client singleton when the editor is enabled.
  * Syncs the current locale from the Intlayer context into the editor manager so
  * the editor always knows which locale the app is displaying.
  */
 export declare const useEditor: () => void;
-//#endregion
 //# sourceMappingURL=useEditor.d.ts.map

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

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

package/dist/types/getDictionary.d.ts

@@ -1,12 +1,10 @@
 import { DeepTransformContent } from "./plugins.js";
 import { DeclaredLocales, ExtractSelectorLocale, LocalesValues } from "@intlayer/types/module_augmentation";
 import { Dictionary, DictionarySelectorForGroup, QualifiedDictionaryGroup, ResolveQualifiedDictionaryContent } from "@intlayer/types/dictionary";
-//#region src/getDictionary.d.ts
 /**
  * Transforms a dictionary (or qualified dictionary group) and returns its
  * content for the given locale or selector (`{ item }`, `{ variant }`,
  * optionally combined with `locale`).
  */
 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
 //# 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":";;;;;;;;;qBAmBa,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

@@ -1,11 +1,9 @@
 import { DeepTransformContent } from "./plugins.js";
 import { DeclaredLocales, DictionaryKeys, DictionaryRegistryResult, DictionarySelectorForKey, ExtractSelectorLocale, LocalesValues } from "@intlayer/types/module_augmentation";
-//#region src/getIntlayer.d.ts
 /**
  * Picks one dictionary by its key and returns its content for the given
  * locale or selector (`{ item }`, `{ variant }`,
  * optionally combined with `locale`).
  */
 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
 //# 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":";;;;;;;;qBAgBa,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/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
  */
@@ -36,5 +35,5 @@ export type HTMLComponents<Mode extends HTMLComponentMode = 'optional', T = {}>
   [key: string]: FC<any>;
 } // Optional (Default): Keys in T optional. Rest of HTML optional.
  : DefinedComponents<T, false> & RestHTMLComponents<T>;
-//#endregion
+export {};
 //# 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":";;;;;;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;;;;YAOX;;;;YASA,eACV,aAAa,gCACb,UACE,wBAEA,kBAAkB,WAClB;GAEE,kBAAkB,WAAW,mBAAmB,KAChD;GAEE,kBAAkB,YAChB,mBAAmB;GAChB,cAAc;;GAGnB,kBAAkB,YAAY,mBAAmB"}
+{"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;;;;YAOX;;;;YASA,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', {}>;
 };
@@ -12,5 +11,5 @@ type HTMLProviderProps = PropsWithChildren<{
 }>;
 export declare const useHTMLContext: () => HTMLContextValue;
 export declare const HTMLProvider: FC<HTMLProviderProps>;
-//#endregion
+export {};
 //# 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":";;;KAUK;EACH,aAAa;;KAGV,oBAAoB;;;;EAIvB,aAAa;;qBAKF,sBAAc;qBAEd,cAAc,GAAG"}
+{"version":3,"file":"HTMLProvider.d.ts","names":[],"sources":["../../../src/html/HTMLProvider.tsx"],"mappings":";;KAUK;EACH,aAAa;;KAGV,oBAAoB;;;;EAIvB,aAAa;;qBAKF,sBAAc;qBAEd,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
 export type RenderHTMLProps = {
   /**
    * Component overrides for HTML tags.
@@ -35,5 +34,4 @@ export type HTMLRendererProps = RenderHTMLProps & {
  * if available.
  */
 export declare const HTMLRenderer: FC<HTMLRendererProps>;
-//#endregion
 //# 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":";;;YAQY;;;;;EAKV,aAAa;;;;;;;;qBASF,aAAU,mBACN,eACM,oBACpB,IAAI;;;;;;;qBAuCM,oBAAe,eAAoB,qBAAe,oBAGtC,IAAA;YAUb,oBAAoB;;;;EAI9B;;;;;;;;qBASW,cAAc,GAAG"}
+{"version":3,"file":"HTMLRenderer.d.ts","names":[],"sources":["../../../src/html/HTMLRenderer.tsx"],"mappings":";;YAQY;;;;;EAKV,aAAa;;;;;;;;qBASF,aAAU,mBACN,eACM,oBACpB,IAAI;;;;;;;qBAuCM,oBAAe,eAAoB,qBAAe,oBAGtC,IAAA;YAUb,oBAAoB;;;;EAI9B;;;;;;;;qBASW,cAAc,GAAG"}

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

@@ -1,9 +1,8 @@
 import { FC } from "react";
-//#region src/html/HTMLRendererPlugin.d.ts
 type HTMLRendererPluginProps = {
   html: string;
   userComponents?: Record<string, any>;
 };
 export declare const HTMLRendererPlugin: FC<HTMLRendererPluginProps>;
-//#endregion
+export {};
 //# sourceMappingURL=HTMLRendererPlugin.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"HTMLRendererPlugin.d.ts","names":[],"sources":["../../../src/html/HTMLRendererPlugin.tsx"],"mappings":";;KAIK;EACH;EACA,iBAAiB;;qBAGN,oBAAoB,GAAG"}
+{"version":3,"file":"HTMLRendererPlugin.d.ts","names":[],"sources":["../../../src/html/HTMLRendererPlugin.tsx"],"mappings":";KAIK;EACH;EACA,iBAAiB;;qBAGN,oBAAoB,GAAG"}

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

@@ -1,8 +1,6 @@
 import { ReactNode } from "react";
-//#region src/html/types.d.ts
 export type ReactComponentProps = {
   children?: ReactNode;
   [key: string]: any;
 };
-//#endregion
 //# 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":";;YAEY;EACV,WAAW;GACV"}
+{"version":3,"file":"types.d.ts","names":[],"sources":["../../../src/html/types.ts"],"mappings":";YAEY;EACV,WAAW;GACV"}

package/dist/types/index.d.ts

@@ -1,12 +1,12 @@
-import { IntlayerNode } from "./IntlayerNode.js";
+import "./markdown/index.js";
+import { IInterpreterPluginReact } from "./plugins.js";
 import { AnalyticsProvider } from "./analytics/AnalyticsProvider.js";
 import { useAnalytics } from "./analytics/useAnalytics.js";
 import { ConversionParams, useConversion } from "./analytics/useConversion.js";
 import { ExperimentState, useExperiment } from "./analytics/useExperiment.js";
-import { IntlayerClientContext, IntlayerProvider, IntlayerProviderContent, IntlayerProviderProps, useIntlayerContext } from "./client/IntlayerProvider.js";
 import { useIntl } from "./client/format/useIntl.js";
+import { IntlayerClientContext, IntlayerProvider, IntlayerProviderContent, IntlayerProviderProps, useIntlayerContext } from "./client/IntlayerProvider.js";
 import { t } from "./client/t.js";
-import { IInterpreterPluginReact } from "./plugins.js";
 import { useDictionary } from "./client/useDictionary.js";
 import { useDictionaryAsync } from "./client/useDictionaryAsync.js";
 import { useDictionaryDynamic } from "./client/useDictionaryDynamic.js";
@@ -22,9 +22,8 @@ import { getDictionary } from "./getDictionary.js";
 import { getIntlayer } from "./getIntlayer.js";
 import { MarkdownProviderOptions as MarkdownProviderOptions$1, MarkdownProviderProps, 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 { IntlayerNode } from "./IntlayerNode.js";
 import { LocalesValues } from "@intlayer/types/module_augmentation";
-//#region src/index.d.ts
 declare module '@intlayer/core/interpreter' {
   interface IInterpreterPlugin<T, S, L extends LocalesValues> extends IInterpreterPluginReact<T, S, L> {}
 }
@@ -60,6 +59,5 @@ export type RenderMarkdownProps = RenderMarkdownProps$1;
  * @deprecated import from react-intlayer/markdown instead
  */
 export type MarkdownRendererProps = MarkdownRendererProps$1;
-//#endregion
 export { AnalyticsProvider, type ConversionParams, type ExperimentState, IntlayerClientContext, type IntlayerNode, IntlayerProvider, IntlayerProviderContent, type IntlayerProviderProps, type UseLocaleProps, type UseLocaleResult, getDictionary, getIntlayer, localeCookie, localeInStorage, setLocaleCookie, setLocaleInStorage, t, useAnalytics, useConversion, useDictionary, useDictionaryAsync, useDictionaryDynamic, useExperiment, useI18n, useIntl, useIntlayer, useIntlayerContext, useLoadDynamic, useLocale, useLocaleBase, useLocaleCookie, useLocaleStorage, usePathname, useRewriteURL };
 //# sourceMappingURL=index.d.ts.map

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