@intlayer/core 9.7.0 → 9.7.1

package/dist/types/dictionaryManipulator/getDefaultNode.d.ts

@@ -1,7 +1,5 @@
 import { ContentNode } from "@intlayer/types/dictionary";
 import { LocalesValues } from "@intlayer/types/module_augmentation";
 import { NodeType } from "@intlayer/types/nodeType";
-//#region src/dictionaryManipulator/getDefaultNode.d.ts
 export declare const getDefaultNode: (nodeType: NodeType, locales: LocalesValues[], content?: ContentNode) => ContentNode;
-//#endregion
 //# sourceMappingURL=getDefaultNode.d.ts.map

package/dist/types/dictionaryManipulator/getDefaultNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getDefaultNode.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/getDefaultNode.ts"],"mappings":";;;;qBAMa,iBAAc,UACf,UAAQ,SACT,iBAAe,UACd,gBACT"}
+{"version":3,"file":"getDefaultNode.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/getDefaultNode.ts"],"mappings":";;;qBAMa,iBAAc,UACf,UAAQ,SACT,iBAAe,UACd,gBACT"}

package/dist/types/dictionaryManipulator/getEmptyNode.d.ts

@@ -1,5 +1,3 @@
 import { ContentNode } from "@intlayer/types/dictionary";
-//#region src/dictionaryManipulator/getEmptyNode.d.ts
 export declare const getEmptyNode: (section: ContentNode) => ContentNode;
-//#endregion
 //# sourceMappingURL=getEmptyNode.d.ts.map

package/dist/types/dictionaryManipulator/getEmptyNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getEmptyNode.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/getEmptyNode.ts"],"mappings":";;qBAIa,eAAY,SAAa,gBAAc"}
+{"version":3,"file":"getEmptyNode.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/getEmptyNode.ts"],"mappings":";qBAIa,eAAY,SAAa,gBAAc"}

package/dist/types/dictionaryManipulator/getNestedDictionaryReferences.d.ts

@@ -1,4 +1,3 @@
-//#region src/dictionaryManipulator/getNestedDictionaryReferences.d.ts
 /**
  * Top-level content fields of a nest target that are referenced through
  * `nest()` nodes.
@@ -57,5 +56,4 @@ export declare const getNestedDictionaryKeys: (dictionaries: Iterable<unknown>)
  * ```
  */
 export declare const getNestedDictionaryGraph: (dictionaries: Iterable<unknown>) => Map<string, Set<string>>;
-//#endregion
 //# sourceMappingURL=getNestedDictionaryReferences.d.ts.map

package/dist/types/dictionaryManipulator/getNestedDictionaryReferences.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getNestedDictionaryReferences.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/getNestedDictionaryReferences.ts"],"mappings":";;;;;;;;;YAUY,wBAAwB;;;;;;;;;;;;;;;;;;;qBAkEvB,gCAA6B,cAC1B,sBACb,YAAY;;;;;;;qBAkDF,0BAAuB,cACpB,sBACb;;;;;;;;;;;;;;;;;;;;;;;qBAyDU,2BAAwB,cACrB,sBACb,YAAY"}
+{"version":3,"file":"getNestedDictionaryReferences.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/getNestedDictionaryReferences.ts"],"mappings":";;;;;;;;YAUY,wBAAwB;;;;;;;;;;;;;;;;;;;qBAkEvB,gCAA6B,cAC1B,sBACb,YAAY;;;;;;;qBAkDF,0BAAuB,cACpB,sBACb;;;;;;;;;;;;;;;;;;;;;;;qBAyDU,2BAAwB,cACrB,sBACb,YAAY"}

package/dist/types/dictionaryManipulator/getNodeChildren.d.ts

@@ -1,5 +1,3 @@
 import { ContentNode } from "@intlayer/types/dictionary";
-//#region src/dictionaryManipulator/getNodeChildren.d.ts
 export declare const getNodeChildren: (section: ContentNode) => ContentNode;
-//#endregion
 //# sourceMappingURL=getNodeChildren.d.ts.map

package/dist/types/dictionaryManipulator/getNodeChildren.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getNodeChildren.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/getNodeChildren.ts"],"mappings":";;qBAIa,kBAAe,SAAa,gBAAc"}
+{"version":3,"file":"getNodeChildren.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/getNodeChildren.ts"],"mappings":";qBAIa,kBAAe,SAAa,gBAAc"}

package/dist/types/dictionaryManipulator/getNodeType.d.ts

@@ -1,6 +1,4 @@
 import { ContentNode } from "@intlayer/types/dictionary";
 import { NodeType } from "@intlayer/types/nodeType";
-//#region src/dictionaryManipulator/getNodeType.d.ts
 export declare const getNodeType: (content: ContentNode) => NodeType;
-//#endregion
 //# sourceMappingURL=getNodeType.d.ts.map

package/dist/types/dictionaryManipulator/getNodeType.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getNodeType.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/getNodeType.ts"],"mappings":";;;qBAsDa,cAAW,SAAa,gBAAc"}
+{"version":3,"file":"getNodeType.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/getNodeType.ts"],"mappings":";;qBAsDa,cAAW,SAAa,gBAAc"}

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

@@ -1,5 +1,3 @@
-import { PlainDynamicLoaderMap, ResolvedDynamicLoader, findPlainDynamicLoader, resolvePlainDynamicLoader } from "./plainDynamicLoader.js";
-import { DynamicDictionaryLoader, QUALIFIER_DYNAMIC_TYPES_KEY, QualifiedDynamicLoaderMap, QualifiedDynamicLoaderTree, isQualifiedDynamicLoaderMap, resolveQualifiedDynamicContent, resolveQualifiedDynamicContentAsync } from "./qualifiedDynamicLoader.js";
 import { editDictionaryByKeyPath } from "./editDictionaryByKeyPath.js";
 import { getContentNodeByKeyPath } from "./getContentNodeByKeyPath.js";
 import { getDefaultNode } from "./getDefaultNode.js";
@@ -11,9 +9,11 @@ import { mergeDictionaries } from "./mergeDictionaries.js";
 import { mergeQualifiedDictionaries } from "./mergeQualifiedDictionaries.js";
 import { normalizeDictionaries, normalizeDictionary } from "./normalizeDictionary.js";
 import { orderDictionaries } from "./orderDictionaries.js";
+import { PlainDynamicLoaderMap, ResolvedDynamicLoader, findPlainDynamicLoader, resolvePlainDynamicLoader } from "./plainDynamicLoader.js";
 import { PRELOADED_DYNAMIC_KEY, PreloadableDynamicLoaderMap, PreloadedDynamicEntry, getPreloadedDictionary } from "./preloadedDynamicLoader.js";
 import { COMPOSITE_ID_SEPARATOR, DEFAULT_VARIANT_ID, getDictionarySelectorCacheKey, isQualifiedDictionaryGroup, parseDictionarySelector, reconstructQualifiedEntry, resolveDictionaryArgument, resolveEffectiveVariantId, resolveProviderVariant, resolveQualifiedDictionary, serializeVariant, serializeVariantChain } from "./qualifiedDictionary.js";
 import { QUALIFIER_ORDER, getDictionaryCompositeIds, getDictionaryQualifierIds, getDictionaryQualifierTypes, getVariantIds } from "./qualifiedDictionaryDeclaration.js";
+import { DynamicDictionaryLoader, QUALIFIER_DYNAMIC_TYPES_KEY, QualifiedDynamicLoaderMap, QualifiedDynamicLoaderTree, isQualifiedDynamicLoaderMap, resolveQualifiedDynamicContent, resolveQualifiedDynamicContentAsync } from "./qualifiedDynamicLoader.js";
 import { removeContentNodeByKeyPath } from "./removeContentNodeByKeyPath.js";
 import { renameContentNodeByKeyPath } from "./renameContentNodeByKeyPath.js";
 import { updateNodeChildren } from "./updateNodeChildren.js";

package/dist/types/dictionaryManipulator/mergeDictionaries.d.ts

@@ -1,5 +1,3 @@
 import { Dictionary } from "@intlayer/types/dictionary";
-//#region src/dictionaryManipulator/mergeDictionaries.d.ts
 export declare const mergeDictionaries: (dictionaries: Dictionary[]) => Dictionary;
-//#endregion
 //# sourceMappingURL=mergeDictionaries.d.ts.map

package/dist/types/dictionaryManipulator/mergeDictionaries.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mergeDictionaries.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/mergeDictionaries.ts"],"mappings":";;qBAqKa,oBAAiB,cAAkB,iBAAe"}
+{"version":3,"file":"mergeDictionaries.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/mergeDictionaries.ts"],"mappings":";qBAqKa,oBAAiB,cAAkB,iBAAe"}

package/dist/types/dictionaryManipulator/mergeQualifiedDictionaries.d.ts

@@ -1,5 +1,4 @@
 import { Dictionary, QualifiedDictionaryGroup } from "@intlayer/types/dictionary";
-//#region src/dictionaryManipulator/mergeQualifiedDictionaries.d.ts
 /**
  * Merges sibling dictionaries sharing the same key, honouring qualifiers.
  *
@@ -19,5 +18,4 @@ import { Dictionary, QualifiedDictionaryGroup } from "@intlayer/types/dictionary
  * declares only a subset is ambiguous and is rejected with an error log.
  */
 export declare const mergeQualifiedDictionaries: (dictionaries: Dictionary[]) => Dictionary | QualifiedDictionaryGroup;
-//#endregion
 //# sourceMappingURL=mergeQualifiedDictionaries.d.ts.map

package/dist/types/dictionaryManipulator/mergeQualifiedDictionaries.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mergeQualifiedDictionaries.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/mergeQualifiedDictionaries.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;qBAoCa,6BAA0B,cACvB,iBACb,aAAa"}
+{"version":3,"file":"mergeQualifiedDictionaries.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/mergeQualifiedDictionaries.ts"],"mappings":";;;;;;;;;;;;;;;;;;;qBAoCa,6BAA0B,cACvB,iBACb,aAAa"}

package/dist/types/dictionaryManipulator/normalizeDictionary.d.ts

@@ -1,7 +1,5 @@
 import { Dictionary } from "@intlayer/types/dictionary";
 import { IntlayerConfig } from "@intlayer/types/config";
-//#region src/dictionaryManipulator/normalizeDictionary.d.ts
 export declare const normalizeDictionary: (dictionary: Dictionary, configuration: IntlayerConfig) => Dictionary;
 export declare const normalizeDictionaries: (dictionaries: Dictionary[], configuration: IntlayerConfig) => Dictionary[];
-//#endregion
 //# sourceMappingURL=normalizeDictionary.d.ts.map

package/dist/types/dictionaryManipulator/normalizeDictionary.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"normalizeDictionary.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/normalizeDictionary.ts"],"mappings":";;;qBAOa,sBAAmB,YAClB,YAAU,eACP,mBACd;qBAmCU,wBAAqB,cAClB,cAAY,eACX,mBACd"}
+{"version":3,"file":"normalizeDictionary.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/normalizeDictionary.ts"],"mappings":";;qBAOa,sBAAmB,YAClB,YAAU,eACP,mBACd;qBAmCU,wBAAqB,cAClB,cAAY,eACX,mBACd"}

package/dist/types/dictionaryManipulator/orderDictionaries.d.ts

@@ -1,5 +1,4 @@
 import { Dictionary } from "@intlayer/types/dictionary";
-//#region src/dictionaryManipulator/orderDictionaries.d.ts
 /**
  * Orders dictionaries based on the dictionary priority strategy.
  *
@@ -12,5 +11,4 @@ export declare const orderDictionaries: (dictionaries: Dictionary[], config?: {
     dictionaryPriorityStrategy: 'local_first' | 'distant_first';
   };
 }) => Dictionary[];
-//#endregion
 //# sourceMappingURL=orderDictionaries.d.ts.map

package/dist/types/dictionaryManipulator/orderDictionaries.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"orderDictionaries.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/orderDictionaries.ts"],"mappings":";;;;;;;;;qBAUa,oBAAiB,cACd,cAAY;EAExB;IACE;;MAGH"}
+{"version":3,"file":"orderDictionaries.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/orderDictionaries.ts"],"mappings":";;;;;;;;qBAUa,oBAAiB,cACd,cAAY;EAExB;IACE;;MAGH"}

package/dist/types/dictionaryManipulator/plainDynamicLoader.d.ts

@@ -1,6 +1,5 @@
 import { Dictionary } from "@intlayer/types/dictionary";
 import { LocalesValues } from "@intlayer/types/module_augmentation";
-//#region src/dictionaryManipulator/plainDynamicLoader.d.ts
 /**
  * Default export shape of a generated dynamic entry point for a plain (non
  * qualified) key: one lazy chunk loader per emitted locale.
@@ -45,5 +44,4 @@ export declare const findPlainDynamicLoader: <T extends Dictionary>(loaderMap: P
  *         only happens on a malformed or empty entry point.
  */
 export declare const resolvePlainDynamicLoader: <T extends Dictionary>(loaderMap: PlainDynamicLoaderMap<T>, key: string, locale: LocalesValues) => ResolvedDynamicLoader<T>;
-//#endregion
 //# sourceMappingURL=plainDynamicLoader.d.ts.map

package/dist/types/dictionaryManipulator/plainDynamicLoader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"plainDynamicLoader.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/plainDynamicLoader.ts"],"mappings":";;;;;;;YAUY,sBAAsB,UAAU,aAAa;GACtD,wBAAwB,QAAQ;;;YAIvB,sBAAsB,UAAU,aAAa;;;;;EAKvD,QAAQ;EACR,cAAc,QAAQ;;;;;;;;;;;;;;;;qBA4CX,yBAA0B,UAAU,YAAU,WAC9C,sBAAsB,IAAE,QAC3B,kBACP,sBAAsB;;;;;;;;;;;;;qBAgCZ,4BAA6B,UAAU,YAAU,WACjD,sBAAsB,IAAE,aACxB,QACH,kBACP,sBAAsB"}
+{"version":3,"file":"plainDynamicLoader.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/plainDynamicLoader.ts"],"mappings":";;;;;;YAUY,sBAAsB,UAAU,aAAa;GACtD,wBAAwB,QAAQ;;;YAIvB,sBAAsB,UAAU,aAAa;;;;;EAKvD,QAAQ;EACR,cAAc,QAAQ;;;;;;;;;;;;;;;;qBA4CX,yBAA0B,UAAU,YAAU,WAC9C,sBAAsB,IAAE,QAC3B,kBACP,sBAAsB;;;;;;;;;;;;;qBAgCZ,4BAA6B,UAAU,YAAU,WACjD,sBAAsB,IAAE,aACxB,QACH,kBACP,sBAAsB"}

package/dist/types/dictionaryManipulator/preloadedDynamicLoader.d.ts

@@ -1,7 +1,6 @@
 import { Dictionary } from "@intlayer/types/dictionary";
 import { LocalesValues } from "@intlayer/types/module_augmentation";
 import { PRELOADED_DYNAMIC_KEY } from "@intlayer/config/defaultValues";
-//#region src/dictionaryManipulator/preloadedDynamicLoader.d.ts
 /**
  * The value attached under {@link PRELOADED_DYNAMIC_KEY}.
  *
@@ -33,6 +32,5 @@ export type PreloadableDynamicLoaderMap = {
  * @returns The dictionary when it was preloaded for `locale`, else `undefined`.
  */
 export declare const getPreloadedDictionary: (loaderMap: unknown, locale: LocalesValues) => Dictionary | undefined;
-//#endregion
 export { PRELOADED_DYNAMIC_KEY };
 //# sourceMappingURL=preloadedDynamicLoader.d.ts.map

package/dist/types/dictionaryManipulator/preloadedDynamicLoader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"preloadedDynamicLoader.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/preloadedDynamicLoader.ts"],"mappings":";;;;;;;;;;;;YAoBY;EACV,QAAQ;EACR,YAAY;;;YAIF;GACT,yBAAyB;;;;;;;;;;;;;;;;qBAiBf,yBAAsB,oBACf,QACV,kBACP"}
+{"version":3,"file":"preloadedDynamicLoader.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/preloadedDynamicLoader.ts"],"mappings":";;;;;;;;;;;YAoBY;EACV,QAAQ;EACR,YAAY;;;YAIF;GACT,yBAAyB;;;;;;;;;;;;;;;;qBAiBf,yBAAsB,oBACf,QACV,kBACP"}

package/dist/types/dictionaryManipulator/qualifiedDictionary.d.ts

@@ -1,6 +1,5 @@
 import { Dictionary, DictionarySelector, DictionaryVariantChain, DictionaryVariantValue, ProviderVariantBase, QualifiedDictionaryGroup } from "@intlayer/types/dictionary";
 import { LocalesValues } from "@intlayer/types/module_augmentation";
-//#region src/dictionaryManipulator/qualifiedDictionary.d.ts
 /**
  * Separator joining per-dimension ids into a composite entry id. Also used as
  * the chunk path separator in dynamic mode.
@@ -143,5 +142,4 @@ export declare const resolveDictionaryArgument: (params: {
  * for cache keys and memoization dependencies.
  */
 export declare const getDictionarySelectorCacheKey: (selector?: DictionarySelector) => string;
-//#endregion
 //# sourceMappingURL=qualifiedDictionary.d.ts.map

package/dist/types/dictionaryManipulator/qualifiedDictionary.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"qualifiedDictionary.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/qualifiedDictionary.ts"],"mappings":";;;;;;;qBAgBa;;;;;;qBAOA;;;;;;;;;;;;;;;;;;;qBAqDA,mBAAgB,SAClB;;;;;;;;;;;;;qBA4BE,wBAAqB,SACvB;;;;;;;;;;;;;;;;qBA0BE,4BAAyB,+BACP,sBACP;;;;;;qBA4CX,6BAA0B,mBAEpC,SAAS;;;;;;;;;;;;qBAkBC,4BAAyB,OAC7B,0BAAwB,wBAE9B;;;;;;;;;;;;;;;;qBAkCU,6BAA0B,mBAClB,aAAa,0BAAwB,WAC7C,uBACV,aAAa;;;;;qBAoDH,0BAA2B,UAAU,eAAa,mBAC1C,IAAI;EACpB,SAAS;EAAG,WAAW;;;;;;;;;;;;;;;;;qBA0Bf,yBAAsB,iBAChB,iCAA+B,0BAE/C;;;;;;;;;;;;;;;qBA0BU,4BAAyB;EACpC,mBAAmB,gBAAgB;EACnC,gBAAgB;EAChB,iBAAiB;EACjB;MACE,gBAAgB;;;;;qBAqCP,gCAA6B,WAC7B"}
+{"version":3,"file":"qualifiedDictionary.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/qualifiedDictionary.ts"],"mappings":";;;;;;qBAgBa;;;;;;qBAOA;;;;;;;;;;;;;;;;;;;qBAqDA,mBAAgB,SAClB;;;;;;;;;;;;;qBA4BE,wBAAqB,SACvB;;;;;;;;;;;;;;;;qBA0BE,4BAAyB,+BACP,sBACP;;;;;;qBA4CX,6BAA0B,mBAEpC,SAAS;;;;;;;;;;;;qBAkBC,4BAAyB,OAC7B,0BAAwB,wBAE9B;;;;;;;;;;;;;;;;qBAkCU,6BAA0B,mBAClB,aAAa,0BAAwB,WAC7C,uBACV,aAAa;;;;;qBAoDH,0BAA2B,UAAU,eAAa,mBAC1C,IAAI;EACpB,SAAS;EAAG,WAAW;;;;;;;;;;;;;;;;;qBA0Bf,yBAAsB,iBAChB,iCAA+B,0BAE/C;;;;;;;;;;;;;;;qBA0BU,4BAAyB;EACpC,mBAAmB,gBAAgB;EACnC,gBAAgB;EAChB,iBAAiB;EACjB;MACE,gBAAgB;;;;;qBAqCP,gCAA6B,WAC7B"}

package/dist/types/dictionaryManipulator/qualifiedDictionaryDeclaration.d.ts

@@ -1,5 +1,4 @@
 import { Dictionary, DictionaryQualifierType } from "@intlayer/types/dictionary";
-//#region src/dictionaryManipulator/qualifiedDictionaryDeclaration.d.ts
 /**
  * Canonical order of qualifier dimensions. A key that declares both dimensions
  * always nests them in this order, with `item` innermost so it can act as the
@@ -36,5 +35,4 @@ export declare const getDictionaryQualifierIds: (dictionary: Dictionary, qualifi
  * into one id per element. `undefined` when a dimension of the set is missing.
  */
 export declare const getDictionaryCompositeIds: (dictionary: Dictionary, qualifierTypes: DictionaryQualifierType[]) => string[] | undefined;
-//#endregion
 //# sourceMappingURL=qualifiedDictionaryDeclaration.d.ts.map

package/dist/types/dictionaryManipulator/qualifiedDictionaryDeclaration.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"qualifiedDictionaryDeclaration.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/qualifiedDictionaryDeclaration.ts"],"mappings":";;;;;;;qBAca;;;;;;;;qBAYA,gBAAa,SACf;;;;;;qBAeE,8BAA2B,YAC1B,eACX;;;;;;;;;qBAmBU,4BAAyB,YACxB,YAAU,eACP;;;;;;;qBAcJ,4BAAyB,YACxB,YAAU,gBACN"}
+{"version":3,"file":"qualifiedDictionaryDeclaration.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/qualifiedDictionaryDeclaration.ts"],"mappings":";;;;;;qBAca;;;;;;;;qBAYA,gBAAa,SACf;;;;;;qBAeE,8BAA2B,YAC1B,eACX;;;;;;;;;qBAmBU,4BAAyB,YACxB,YAAU,eACP;;;;;;;qBAcJ,4BAAyB,YACxB,YAAU,gBACN"}

package/dist/types/dictionaryManipulator/qualifiedDynamicLoader.d.ts

@@ -1,6 +1,5 @@
 import { Dictionary, DictionaryQualifierType, DictionarySelector } from "@intlayer/types/dictionary";
 import { QUALIFIER_DYNAMIC_TYPES_KEY } from "@intlayer/config/defaultValues";
-//#region src/dictionaryManipulator/qualifiedDynamicLoader.d.ts
 /**
  * A lazily-imported per-locale dictionary chunk loader.
  */
@@ -82,6 +81,5 @@ export declare const resolveQualifiedDynamicContentAsync: <Content>(params: {
   selector: DictionarySelector | undefined;
   transform: (dictionary: Dictionary) => Content;
 }) => Promise<Content | Content[] | null>;
-//#endregion
 export { QUALIFIER_DYNAMIC_TYPES_KEY };
 //# sourceMappingURL=qualifiedDynamicLoader.d.ts.map

package/dist/types/dictionaryManipulator/qualifiedDynamicLoader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"qualifiedDynamicLoader.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/qualifiedDynamicLoader.ts"],"mappings":";;;;;;YAuBY,gCAAgC,QAAQ;;;;;YAMxC;GACT,kBAAkB,6BAA6B;;;;;;;;;;;;;;YAetC;GACT,8BAA8B;GAC9B,iBAAiB,6BAA6B;;;;;;qBAOpC,8BAA2B,mBAErC,SAAS;;;;;;;;;;;;;;;;;;;;;;;;qBAiHC,iCAAkC,SAAO;EACpD,WAAW;EACX;EACA;EACA,UAAU;EACV,YAAY,kBAAkB,SAAS,QAAQ,gBAAgB;EAC/D,YAAY,YAAY,eAAe;MACrC,UAAU;;;;;;;;;;;;qBAkCD,sCAA6C,SAAO;EAC/D,WAAW;EACX;EACA;EACA,UAAU;EACV,YAAY,YAAY,eAAe;MACrC,QAAQ,UAAU"}
+{"version":3,"file":"qualifiedDynamicLoader.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/qualifiedDynamicLoader.ts"],"mappings":";;;;;YAuBY,gCAAgC,QAAQ;;;;;YAMxC;GACT,kBAAkB,6BAA6B;;;;;;;;;;;;;;YAetC;GACT,8BAA8B;GAC9B,iBAAiB,6BAA6B;;;;;;qBAOpC,8BAA2B,mBAErC,SAAS;;;;;;;;;;;;;;;;;;;;;;;;qBAiHC,iCAAkC,SAAO;EACpD,WAAW;EACX;EACA;EACA,UAAU;EACV,YAAY,kBAAkB,SAAS,QAAQ,gBAAgB;EAC/D,YAAY,YAAY,eAAe;MACrC,UAAU;;;;;;;;;;;;qBAkCD,sCAA6C,SAAO;EAC/D,WAAW;EACX;EACA;EACA,UAAU;EACV,YAAY,YAAY,eAAe;MACrC,QAAQ,UAAU"}

package/dist/types/dictionaryManipulator/removeContentNodeByKeyPath.d.ts

@@ -1,6 +1,4 @@
 import { ContentNode } from "@intlayer/types/dictionary";
 import { KeyPath } from "@intlayer/types/keyPath";
-//#region src/dictionaryManipulator/removeContentNodeByKeyPath.d.ts
 export declare const removeContentNodeByKeyPath: (dictionaryContent: ContentNode, keyPath: KeyPath[]) => ContentNode;
-//#endregion
 //# sourceMappingURL=removeContentNodeByKeyPath.d.ts.map

package/dist/types/dictionaryManipulator/removeContentNodeByKeyPath.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"removeContentNodeByKeyPath.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/removeContentNodeByKeyPath.ts"],"mappings":";;;qBAKa,6BAA0B,mBAClB,aAAW,SACrB,cACR"}
+{"version":3,"file":"removeContentNodeByKeyPath.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/removeContentNodeByKeyPath.ts"],"mappings":";;qBAKa,6BAA0B,mBAClB,aAAW,SACrB,cACR"}

package/dist/types/dictionaryManipulator/renameContentNodeByKeyPath.d.ts

@@ -1,6 +1,4 @@
 import { ContentNode } from "@intlayer/types/dictionary";
 import { KeyPath } from "@intlayer/types/keyPath";
-//#region src/dictionaryManipulator/renameContentNodeByKeyPath.d.ts
 export declare const renameContentNodeByKeyPath: (dictionaryContent: ContentNode, newKey: KeyPath['key'], keyPath: KeyPath[]) => ContentNode;
-//#endregion
 //# sourceMappingURL=renameContentNodeByKeyPath.d.ts.map

package/dist/types/dictionaryManipulator/renameContentNodeByKeyPath.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"renameContentNodeByKeyPath.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/renameContentNodeByKeyPath.ts"],"mappings":";;;qBAKa,6BAA0B,mBAClB,aAAW,QACtB,gBAAc,SACb,cACR"}
+{"version":3,"file":"renameContentNodeByKeyPath.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/renameContentNodeByKeyPath.ts"],"mappings":";;qBAKa,6BAA0B,mBAClB,aAAW,QACtB,gBAAc,SACb,cACR"}

package/dist/types/dictionaryManipulator/updateNodeChildren.d.ts

@@ -1,5 +1,3 @@
 import { ContentNode } from "@intlayer/types/dictionary";
-//#region src/dictionaryManipulator/updateNodeChildren.d.ts
 export declare const updateNodeChildren: <T extends ContentNode, U extends ContentNode>(section: T, newChildren: U) => ContentNode;
-//#endregion
 //# sourceMappingURL=updateNodeChildren.d.ts.map

package/dist/types/dictionaryManipulator/updateNodeChildren.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"updateNodeChildren.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/updateNodeChildren.ts"],"mappings":";;qBAIa,qBACX,UAAU,aACV,UAAU,aAAW,SAEZ,GAAC,aACG,MACZ"}
+{"version":3,"file":"updateNodeChildren.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/updateNodeChildren.ts"],"mappings":";qBAIa,qBACX,UAAU,aACV,UAAU,aAAW,SAEZ,GAAC,aACG,MACZ"}

package/dist/types/formatters/compact.d.ts

@@ -1,5 +1,4 @@
 import { LocalesValues } from "@intlayer/types/module_augmentation";
-//#region src/formatters/compact.d.ts
 /**
  * Formats a numeric value using compact notation (e.g., 1K, 1M, 1B)
  * based on locale and formatting options.
@@ -14,5 +13,4 @@ import { LocalesValues } from "@intlayer/types/module_augmentation";
 export declare const compact: (value: string | number, options?: Intl.NumberFormatOptions & {
   locale?: LocalesValues;
 }) => string;
-//#endregion
 //# sourceMappingURL=compact.d.ts.map

package/dist/types/formatters/compact.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compact.d.ts","names":[],"sources":["../../../src/formatters/compact.ts"],"mappings":";;;;;;;;;;;;;qBAca,UAAO,wBACI,UACZ,KAAK;EAAwB,SAAS"}
+{"version":3,"file":"compact.d.ts","names":[],"sources":["../../../src/formatters/compact.ts"],"mappings":";;;;;;;;;;;;qBAca,UAAO,wBACI,UACZ,KAAK;EAAwB,SAAS"}

package/dist/types/formatters/currency.d.ts

@@ -1,5 +1,4 @@
 import { LocalesValues } from "@intlayer/types/module_augmentation";
-//#region src/formatters/currency.d.ts
 /**
  * Formats a numeric or string value into a localized currency string using the Intl API.
  *
@@ -14,5 +13,4 @@ import { LocalesValues } from "@intlayer/types/module_augmentation";
 export declare const currency: (value: string | number, options?: Intl.NumberFormatOptions & {
   locale?: LocalesValues;
 }) => string;
-//#endregion
 //# sourceMappingURL=currency.d.ts.map

package/dist/types/formatters/currency.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"currency.d.ts","names":[],"sources":["../../../src/formatters/currency.ts"],"mappings":";;;;;;;;;;;;;qBAca,WAAQ,wBACG,UACZ,KAAK;EAAwB,SAAS"}
+{"version":3,"file":"currency.d.ts","names":[],"sources":["../../../src/formatters/currency.ts"],"mappings":";;;;;;;;;;;;qBAca,WAAQ,wBACG,UACZ,KAAK;EAAwB,SAAS"}

package/dist/types/formatters/date.d.ts

@@ -1,5 +1,4 @@
 import { LocalesValues } from "@intlayer/types/module_augmentation";
-//#region src/formatters/date.d.ts
 export type DateTimePreset = 'short' | 'long' | 'dateOnly' | 'timeOnly' | 'full';
 export declare const presets: Record<DateTimePreset, Intl.DateTimeFormatOptions>;
 /**
@@ -16,5 +15,4 @@ export declare const presets: Record<DateTimePreset, Intl.DateTimeFormatOptions>
 export declare const date: (date: Date | string | number, options?: (Intl.DateTimeFormatOptions & {
   locale?: LocalesValues;
 }) | DateTimePreset) => string;
-//#endregion
 //# sourceMappingURL=date.d.ts.map

package/dist/types/formatters/date.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"date.d.ts","names":[],"sources":["../../../src/formatters/date.ts"],"mappings":";;YAGY;qBAOC,SAAS,OAAO,gBAAgB,KAAK;;;;;;;;;;;;qBA8CrC,OAAI,MACT,wBAAsB,WAEvB,KAAK;EAA0B,SAAS;KACzC"}
+{"version":3,"file":"date.d.ts","names":[],"sources":["../../../src/formatters/date.ts"],"mappings":";YAGY;qBAOC,SAAS,OAAO,gBAAgB,KAAK;;;;;;;;;;;;qBA8CrC,OAAI,MACT,wBAAsB,WAEvB,KAAK;EAA0B,SAAS;KACzC"}

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

@@ -1,7 +1,7 @@
+import { CachedIntl, IntlConstructorName, WrappedIntl, bindIntl, getCachedIntl } from "../utils/intl.js";
 import { compact } from "./compact.js";
 import { currency } from "./currency.js";
 import { DateTimePreset, date, presets } from "./date.js";
-import { CachedIntl, IntlConstructorName, WrappedIntl, bindIntl, getCachedIntl } from "../utils/intl.js";
 import { ListFormatOptions, list } from "./list.js";
 import { number } from "./number.js";
 import { percentage } from "./percentage.js";

package/dist/types/formatters/list.d.ts

@@ -1,5 +1,4 @@
 import { LocalesValues } from "@intlayer/types/module_augmentation";
-//#region src/formatters/list.d.ts
 /** Locally defined subset of Intl.ListFormatOptions so consumers don't need ES2021.Intl in their lib. */
 export type ListFormatOptions = {
   localeMatcher?: 'lookup' | 'best fit';
@@ -24,5 +23,4 @@ export type ListFormatOptions = {
 export declare const list: (values: (string | number)[], options?: ListFormatOptions & {
   locale?: LocalesValues;
 }) => string;
-//#endregion
 //# sourceMappingURL=list.d.ts.map

package/dist/types/formatters/list.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"list.d.ts","names":[],"sources":["../../../src/formatters/list.ts"],"mappings":";;;YAIY;EACV;EACA;EACA;;;;;;;;;;;;;;;;;qBAkBW,OAAI,6BACY,UACjB;EAAsB,SAAS"}
+{"version":3,"file":"list.d.ts","names":[],"sources":["../../../src/formatters/list.ts"],"mappings":";;YAIY;EACV;EACA;EACA;;;;;;;;;;;;;;;;;qBAkBW,OAAI,6BACY,UACjB;EAAsB,SAAS"}

package/dist/types/formatters/number.d.ts

@@ -1,5 +1,4 @@
 import { LocalesValues } from "@intlayer/types/module_augmentation";
-//#region src/formatters/number.d.ts
 /**
  * Formats a numeric value using locale-aware formatting.
  *
@@ -12,5 +11,4 @@ import { LocalesValues } from "@intlayer/types/module_augmentation";
 export declare const number: (value: string | number, { locale, ...options }?: Intl.NumberFormatOptions & {
   locale?: LocalesValues;
 }) => string;
-//#endregion
 //# sourceMappingURL=number.d.ts.map

package/dist/types/formatters/number.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"number.d.ts","names":[],"sources":["../../../src/formatters/number.ts"],"mappings":";;;;;;;;;;;qBAYa,SAAM,0BACK,WAAA,YAInB,KAAK;EAAwB,SAAS"}
+{"version":3,"file":"number.d.ts","names":[],"sources":["../../../src/formatters/number.ts"],"mappings":";;;;;;;;;;qBAYa,SAAM,0BACK,WAAA,YAInB,KAAK;EAAwB,SAAS"}

package/dist/types/formatters/percentage.d.ts

@@ -1,5 +1,4 @@
 import { LocalesValues } from "@intlayer/types/module_augmentation";
-//#region src/formatters/percentage.d.ts
 /**
  * Formats a number as a percentage string (e.g., 0.25 → "25%").
  *
@@ -12,5 +11,4 @@ import { LocalesValues } from "@intlayer/types/module_augmentation";
 export declare const percentage: (value: string | number, { locale, ...options }?: Intl.NumberFormatOptions & {
   locale?: LocalesValues;
 }) => string;
-//#endregion
 //# sourceMappingURL=percentage.d.ts.map

package/dist/types/formatters/percentage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"percentage.d.ts","names":[],"sources":["../../../src/formatters/percentage.ts"],"mappings":";;;;;;;;;;;qBAYa,aAAU,0BACC,WAAA,YAInB,KAAK;EAAwB,SAAS"}
+{"version":3,"file":"percentage.d.ts","names":[],"sources":["../../../src/formatters/percentage.ts"],"mappings":";;;;;;;;;;qBAYa,aAAU,0BACC,WAAA,YAInB,KAAK;EAAwB,SAAS"}

package/dist/types/formatters/relativeTime.d.ts

@@ -1,5 +1,4 @@
 import { LocalesValues } from "@intlayer/types/module_augmentation";
-//#region src/formatters/relativeTime.d.ts
 type RelativeTimeUnit = Intl.RelativeTimeFormatUnit;
 /**
  * Formats the difference between two dates as a localized relative time string.
@@ -15,5 +14,5 @@ export declare const relativeTime: (from: Date | string | number, to?: Date | st
   locale?: LocalesValues;
   unit?: RelativeTimeUnit;
 }) => string;
-//#endregion
+export {};
 //# sourceMappingURL=relativeTime.d.ts.map

package/dist/types/formatters/relativeTime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"relativeTime.d.ts","names":[],"sources":["../../../src/formatters/relativeTime.ts"],"mappings":";;KAGK,mBAAmB,KAAK;;;;;;;;;;;qBAuChB,eAAY,MACjB,wBAAsB,KACxB,wBAAsB,UAChB,KAAK;EACb,SAAS;EACT,OAAO"}
+{"version":3,"file":"relativeTime.d.ts","names":[],"sources":["../../../src/formatters/relativeTime.ts"],"mappings":";KAGK,mBAAmB,KAAK;;;;;;;;;;;qBAuChB,eAAY,MACjB,wBAAsB,KACxB,wBAAsB,UAChB,KAAK;EACb,SAAS;EACT,OAAO"}

package/dist/types/formatters/units.d.ts

@@ -1,5 +1,4 @@
 import { LocalesValues } from "@intlayer/types/module_augmentation";
-//#region src/formatters/units.d.ts
 /**
  * Formats a numeric value as a localized unit string.
  *
@@ -10,5 +9,4 @@ import { LocalesValues } from "@intlayer/types/module_augmentation";
 export declare const units: (value: number | string, options?: Intl.NumberFormatOptions & {
   locale?: LocalesValues;
 }) => string;
-//#endregion
 //# sourceMappingURL=units.d.ts.map

package/dist/types/formatters/units.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"units.d.ts","names":[],"sources":["../../../src/formatters/units.ts"],"mappings":";;;;;;;;;qBAUa,QAAK,wBACM,UACZ,KAAK;EAAwB,SAAS"}
+{"version":3,"file":"units.d.ts","names":[],"sources":["../../../src/formatters/units.ts"],"mappings":";;;;;;;;qBAUa,QAAK,wBACM,UACZ,KAAK;EAAwB,SAAS"}

package/dist/types/index.d.ts

@@ -15,7 +15,7 @@ import { DotPath, NestedContent, NestedContentState, ValidDotPathsFor, nest as n
 import { DEFAULT_PLURAL_VARIABLE, PluralCategory, PluralContent, PluralContentState, PluralOptions, plural } from "./transpiler/plural/plural.js";
 import { SelectContent, SelectContentStates, select } from "./transpiler/select/select.js";
 import { TranslationContent, t as translation } from "./transpiler/translation/translation.js";
-import "./transpiler/index.js";
+import "./deepTransformPlugins/index.js";
 import { GetNestingResult, getNesting } from "./interpreter/getNesting.js";
 import { ConditionCond, DeepTransformContent, EnumerationCond, FileCond, GenderCond, IInterpreterPlugin, IInterpreterPluginState, InsertionCond, IsAny, NestedCond, NodeProps, Plugins, PluralCond, SelectCond, SelectSelector, TranslationCond, UnionKeys, ValueAtKey, bindInsertedValues, conditionPlugin, enumerationPlugin, fallbackPlugin, filePlugin, genderPlugin, insertionPlugin, nestedPlugin, pluralPlugin, resolveInsertedSelector, selectPlugin, translationPlugin } from "./interpreter/getContent/plugins.js";
 import { deepTransformNode } from "./interpreter/getContent/deepTransform.js";
@@ -38,7 +38,7 @@ import { getTranslation } from "./interpreter/getTranslation.js";
 import { InterpolableNode, getInterpolableContent, isInterpolableWrapperNode, rebuildInterpolableContent, transformInterpolableNode } from "./interpreter/interpolableNode.js";
 import { AmbientLocaleResolver, AsyncAmbientLocaleResolver, registerAmbientLocaleResolver, registerAsyncAmbientLocaleResolver, resolveInterpreterLocale, resolveInterpreterLocaleAsync } from "./interpreter/resolveInterpreterLocale.js";
 import { splitInsertionTemplate } from "./interpreter/splitAndJoinInsertion.js";
-import "./interpreter/index.js";
+import "./dictionaryManipulator/index.js";
 import { filterMissingTranslationsOnlyPlugin, getFilterMissingTranslationsContent, getFilterMissingTranslationsDictionary } from "./deepTransformPlugins/getFilterMissingTranslationsContent.js";
 import { filterTranslationsOnlyPlugin, getFilterTranslationsOnlyContent, getFilterTranslationsOnlyDictionary } from "./deepTransformPlugins/getFilterTranslationsOnlyContent.js";
 import { getFilteredLocalesContent, getFilteredLocalesDictionary } from "./deepTransformPlugins/getFilteredLocalesContent.js";
@@ -49,7 +49,7 @@ import { getMultilingualDictionary } from "./deepTransformPlugins/getMultilingua
 import { getReplacedValuesContent } from "./deepTransformPlugins/getReplacedValuesContent.js";
 import { getSplittedContent, getSplittedDictionaryContent } from "./deepTransformPlugins/getSplittedContent.js";
 import { insertContentInDictionary } from "./deepTransformPlugins/insertContentInDictionary.js";
-import "./deepTransformPlugins/index.js";
+import "./formatters/index.js";
 import { editDictionaryByKeyPath } from "./dictionaryManipulator/editDictionaryByKeyPath.js";
 import { getContentNodeByKeyPath } from "./dictionaryManipulator/getContentNodeByKeyPath.js";
 import { getDefaultNode } from "./dictionaryManipulator/getDefaultNode.js";
@@ -67,7 +67,7 @@ import { QUALIFIER_ORDER, getDictionaryCompositeIds, getDictionaryQualifierIds,
 import { removeContentNodeByKeyPath } from "./dictionaryManipulator/removeContentNodeByKeyPath.js";
 import { renameContentNodeByKeyPath } from "./dictionaryManipulator/renameContentNodeByKeyPath.js";
 import { updateNodeChildren } from "./dictionaryManipulator/updateNodeChildren.js";
-import "./dictionaryManipulator/index.js";
+import "./interpreter/index.js";
 import { compact } from "./formatters/compact.js";
 import { currency } from "./formatters/currency.js";
 import { DateTimePreset, date, presets } from "./formatters/date.js";
@@ -77,7 +77,7 @@ import { number } from "./formatters/number.js";
 import { percentage } from "./formatters/percentage.js";
 import { relativeTime } from "./formatters/relativeTime.js";
 import { units } from "./formatters/units.js";
-import "./formatters/index.js";
+import "./localization/index.js";
 import { comparePaths, normalizePath } from "./localization/comparePaths.js";
 import { LocaleDomainMap, getDomainHostname, getDomainOrigin, getLocaleFromDomain, isLocaleExclusiveOnDomain } from "./localization/domainUtils.js";
 import { GenerateSitemapOptions, SitemapUrlEntry, generateSitemap, generateSitemapUrl } from "./localization/generateSitemap.js";
@@ -102,21 +102,21 @@ import { getPreloadLocale, resolveBrowserLocale } from "./localization/resolveBr
 import { getRewriteRules } from "./localization/rewriteMatch.js";
 import { LocalizedPathResult, getInternalPath, getRewritePath, resolveLocalizedPath } from "./localization/rewriteUtils.js";
 import { validatePrefix } from "./localization/validatePrefix.js";
-import "./localization/index.js";
+import "./markdown/index.js";
 import { ATTRIBUTES_TO_SANITIZE, ATTRIBUTE_NAME_START_R, ATTRIBUTE_TO_NODE_PROP_MAP, ATTR_EXTRACTOR_R, BLOCKQUOTE_ALERT_R, BLOCKQUOTE_R, BLOCKQUOTE_TRIM_LEFT_MULTILINE_R, BLOCK_END_R, BREAK_LINE_R, BREAK_THEMATIC_R, CAPTURE_LETTER_AFTER_HYPHEN, CODE_BLOCK_FENCED_R, CODE_BLOCK_R, CODE_INLINE_R, CONSECUTIVE_NEWLINE_R, CR_NEWLINE_R, DO_NOT_PROCESS_HTML_ELEMENTS, FENCE_DELIMITER_R, FOOTNOTE_R, FOOTNOTE_REFERENCE_R, FORMFEED_R, FRONT_MATTER_R, GFM_TASK_R, HEADING_ATX_COMPLIANT_R, HEADING_R, HEADING_SETEXT_R, HTML_CHAR_CODE_R, HTML_COMMENT_R, HTML_CUSTOM_ATTR_R, HTML_LEFT_TRIM_AMOUNT_R, INLINE_SKIP_R, INTERPOLATION_R, LINK_AUTOLINK_BARE_URL_R, LINK_AUTOLINK_R, LOOKAHEAD, ListType, NAMED_CODES_TO_UNICODE, NP_TABLE_R, ORDERED, ORDERED_LIST_BULLET, ORDERED_LIST_ITEM_PREFIX, ORDERED_LIST_ITEM_PREFIX_R, ORDERED_LIST_ITEM_R, ORDERED_LIST_R, PARAGRAPH_R, Priority, PriorityValue, REFERENCE_IMAGE_OR_LINK, REFERENCE_IMAGE_R, REFERENCE_LINK_R, RuleScope, RuleScopeValue, RuleType, RuleTypeValue, SCOPE_BLOCK, SCOPE_BOTH, SCOPE_INLINE, SHORTCODE_R, SHOULD_RENDER_AS_BLOCK_R, TABLE_CENTER_ALIGN, TABLE_LEFT_ALIGN, TABLE_RIGHT_ALIGN, TABLE_TRIM_PIPES, TAB_R, TEXT_BOLD_R, TEXT_EMPHASIZED_R, TEXT_ESCAPED_R, TEXT_MARKED_R, TEXT_STRIKETHROUGHED_R, TRIM_STARTING_NEWLINES, UNESCAPE_R, UNORDERED, UNORDERED_LIST_BULLET, UNORDERED_LIST_ITEM_PREFIX, UNORDERED_LIST_ITEM_PREFIX_R, UNORDERED_LIST_ITEM_R, UNORDERED_LIST_R, generateListItemPrefix, generateListItemPrefixRegex, generateListItemRegex, generateListRegex } from "./markdown/constants.js";
 import { BlockQuoteNode, BoldTextNode, BreakLineNode, BreakThematicNode, CodeBlockNode, CodeFencedNode, CodeInlineNode, CompileOptions, ComponentOverrides, CustomComponentNode, ElementType, EscapedTextNode, FootnoteNode, FootnoteReferenceNode, GFMTaskNode, HTMLCommentNode, HTMLNode, HTMLSelfClosingNode, HTMLTag, HeadingNode, HeadingSetextNode, ImageNode, ItalicTextNode, LinkAngleBraceNode, LinkBareURLNode, LinkNode, MarkdownContext, MarkdownOptions, MarkdownRuntime, MarkedTextNode, NestedParser, NewlineNode, OrderedListNode, ParagraphNode, ParseState, Parser, ParserResult, ReferenceImageNode, ReferenceLinkNode, ReferenceNode, RenderRuleHook, Rule, RuleOutput, Rules, StrikethroughTextNode, TableNode, TableSeparatorNode, TextNode, UnorderedListNode } from "./markdown/types.js";
 import { parserFor } from "./markdown/parser.js";
 import { createRenderer, renderFor } from "./markdown/renderer.js";
 import { MarkdownReferences, ParsedMarkdown, compile, compileWithOptions, createCompiler, getRuleSet, parseMarkdown, renderMarkdownAst } from "./markdown/compiler.js";
 import { BlockSyntaxProbe, allowInline, anyScopeRegex, attributeValueToNodePropValue, blockRegex, captureNothing, cx, get, inlineRegex, normalizeAttributeKey, normalizeWhitespace, parseBlock, parseCaptureInline, parseInline, parseSimpleInline, parseStyleAttribute, parseTableAlign, parseTableAlignCapture, parseTableCells, parseTableRow, qualifies, renderNothing, sanitizer, simpleInlineRegex, slugify, some, startsWith, trimEnd, trimLeadingWhitespaceOutsideFences, unescapeString, unquote } from "./markdown/utils.js";
-import "./markdown/index.js";
+import "./messageFormat/index.js";
 import { JsonValue, icuToIntlayerFormatter, intlayerToICUFormatter } from "./messageFormat/ICU.js";
 import { i18nextToIntlayerFormatter, intlayerToI18nextFormatter } from "./messageFormat/i18next.js";
 import { navigatePath } from "./messageFormat/navigatePath.js";
 import { PortableObject, intlayerToPortableObjectFormatter, portableObjectToIntlayerFormatter } from "./messageFormat/po.js";
 import { MessageFormatDialect, MessageFormatter, MessageResolver, MessageValues, TaggedMessageToken, createMessageResolver, interpolateMessage, parseTaggedMessage, resolveMessage, resolveMessageNode, resolveMessageNodeToString } from "./messageFormat/resolveMessage.js";
 import { intlayerToVueI18nFormatter, vueI18nToIntlayerFormatter } from "./messageFormat/vue-i18n.js";
-import "./messageFormat/index.js";
+import "./transpiler/index.js";
 import { checkIsURLAbsolute } from "./utils/checkIsURLAbsolute.js";
 import { getCookie } from "./utils/getCookie.js";
 import { getIntlayerNodePrototype } from "./utils/intlayerNodePrototype.js";

package/dist/types/interpreter/dictionaryTransformCache.d.ts

@@ -2,7 +2,6 @@ import { Plugins } from "./getContent/plugins.js";
 import "./getContent/index.js";
 import { Dictionary } from "@intlayer/types/dictionary";
 import { LocalesValues } from "@intlayer/types/module_augmentation";
-//#region src/interpreter/dictionaryTransformCache.d.ts
 /**
  * Returns the cache-key fragment identifying a plugin array.
  *
@@ -37,5 +36,4 @@ export declare const readTransformCache: <Content>(dictionary: Dictionary | obje
  * @returns The stored content, so callers can `return writeTransformCache(...)`.
  */
 export declare const writeTransformCache: <Content>(dictionary: Dictionary | object, cacheKey: string, content: Content) => Content;
-//#endregion
 //# sourceMappingURL=dictionaryTransformCache.d.ts.map

package/dist/types/interpreter/dictionaryTransformCache.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dictionaryTransformCache.d.ts","names":[],"sources":["../../../src/interpreter/dictionaryTransformCache.ts"],"mappings":";;;;;;;;;;;qBA2Ba,qBAAkB,UAAc;;;;;;;;qBAwDhC,iCAA8B,QACjC,eAAa,0BACG,UACd;;;;;;;;qBAUC,qBAAsB,SAAO,YAC5B,qBAAmB;EAE5B;EAAW,SAAS;;EAAc;;;;;;;qBAe1B,sBAAuB,SAAO,YAC7B,qBAAmB,kBACf,SACP,YACR"}
+{"version":3,"file":"dictionaryTransformCache.d.ts","names":[],"sources":["../../../src/interpreter/dictionaryTransformCache.ts"],"mappings":";;;;;;;;;;qBA2Ba,qBAAkB,UAAc;;;;;;;;qBAwDhC,iCAA8B,QACjC,eAAa,0BACG,UACd;;;;;;;;qBAUC,qBAAsB,SAAO,YAC5B,qBAAmB;EAE5B;EAAW,SAAS;;EAAc;;;;;;;qBAe1B,sBAAuB,SAAO,YAC7B,qBAAmB,kBACf,SACP,YACR"}

package/dist/types/interpreter/getCondition.d.ts

@@ -1,6 +1,5 @@
 import { ConditionContentStates } from "../transpiler/condition/condition.js";
 import "../transpiler/index.js";
-//#region src/interpreter/getCondition.d.ts
 /**
  * Picks content based on a boolean condition.
  *
@@ -18,5 +17,4 @@ import "../transpiler/index.js";
  * ```
  */
 export declare const getCondition: <const Content>(conditionContent: ConditionContentStates<Content>, state?: boolean) => Content;
-//#endregion
 //# sourceMappingURL=getCondition.d.ts.map

package/dist/types/interpreter/getCondition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getCondition.d.ts","names":[],"sources":["../../../src/interpreter/getCondition.ts"],"mappings":";;;;;;;;;;;;;;;;;;;qBAkBa,qBAAsB,SAAO,kBACtB,uBAAuB,UAAQ,oBAEhD"}
+{"version":3,"file":"getCondition.d.ts","names":[],"sources":["../../../src/interpreter/getCondition.ts"],"mappings":";;;;;;;;;;;;;;;;;;qBAkBa,qBAAsB,SAAO,kBACtB,uBAAuB,UAAQ,oBAEhD"}

package/dist/types/interpreter/getContent/deepTransform.d.ts

@@ -1,10 +1,8 @@
 import { NodeProps } from "./plugins.js";
-//#region src/interpreter/getContent/deepTransform.d.ts
 /**
  * Recursively traverses a node (object/array/primitive).
  * Applies the *first* plugin that can transform a node, then stops descending further.
  * If no plugin transforms it, it recurses into its children.
  */
 export declare const deepTransformNode: (node: any, props: NodeProps) => any;
-//#endregion
 //# sourceMappingURL=deepTransform.d.ts.map

package/dist/types/interpreter/getContent/deepTransform.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"deepTransform.d.ts","names":[],"sources":["../../../../src/interpreter/getContent/deepTransform.ts"],"mappings":";;;;;;;qBAoBa,oBAAiB,WAAa,OAAS"}
+{"version":3,"file":"deepTransform.d.ts","names":[],"sources":["../../../../src/interpreter/getContent/deepTransform.ts"],"mappings":";;;;;;qBAoBa,oBAAiB,WAAa,OAAS"}

package/dist/types/interpreter/getContent/getContent.d.ts

@@ -1,7 +1,6 @@
 import { DeepTransformContent, IInterpreterPluginState, NodeProps, Plugins } from "./plugins.js";
 import { ContentNode } from "@intlayer/types/dictionary";
 import { DeclaredLocales, LocalesValues } from "@intlayer/types/module_augmentation";
-//#region src/interpreter/getContent/getContent.d.ts
 export declare const getBasePlugins: (locale?: LocalesValues, fallback?: boolean) => Plugins[];
 /**
  * Transforms a node in a single pass, applying each plugin as needed.
@@ -10,5 +9,4 @@ export declare const getBasePlugins: (locale?: LocalesValues, fallback?: boolean
  * @param locale The locale to use if your transformers need it (e.g. for translations).
  */
 export declare const getContent: <const T extends ContentNode, const L extends LocalesValues = DeclaredLocales>(node: T, nodeProps: NodeProps, plugins?: Plugins[]) => DeepTransformContent<T, IInterpreterPluginState, L>;
-//#endregion
 //# sourceMappingURL=getContent.d.ts.map