@intlayer/core 9.6.0 → 9.7.1

package/dist/types/localization/getLocalizedPath.d.ts

@@ -1,6 +1,5 @@
 import { RoutingOptions } from "./getPrefix.js";
 import { LocalesValues, LocalizedPathname, ResolvedDefaultLocale } from "@intlayer/types/module_augmentation";
-//#region src/localization/getLocalizedPath.d.ts
 /**
  * Localizes an application path for a locale: resolves the `routing.rewrite`
  * rules, then applies the locale representation of the routing mode — a path
@@ -45,5 +44,4 @@ import { LocalesValues, LocalizedPathname, ResolvedDefaultLocale } from "@intlay
  * @returns The localized path for the target locale.
  */
 export declare const getLocalizedPath: <const CanonicalPath extends string, const CurrentLocale extends LocalesValues = ResolvedDefaultLocale>(canonicalPath: CanonicalPath, locale?: CurrentLocale, options?: RoutingOptions) => LocalizedPathname<CanonicalPath, CurrentLocale>;
-//#endregion
 //# sourceMappingURL=getLocalizedPath.d.ts.map

package/dist/types/localization/getLocalizedPath.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getLocalizedPath.d.ts","names":[],"sources":["../../../src/localization/getLocalizedPath.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA4Da,yBACL,oCACA,sBAAsB,gBAAgB,uBAAqB,eAElD,eAAa,SACpB,eAAa,UACZ,mBACR,kBAAkB,eAAe"}
+{"version":3,"file":"getLocalizedPath.d.ts","names":[],"sources":["../../../src/localization/getLocalizedPath.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA4Da,yBACL,oCACA,sBAAsB,gBAAgB,uBAAqB,eAElD,eAAa,SACpB,eAAa,UACZ,mBACR,kBAAkB,eAAe"}

package/dist/types/localization/getLocalizedUrl.d.ts

@@ -1,6 +1,5 @@
 import { RoutingOptions } from "./getPrefix.js";
 import { LocalesValues, LocalizedUrl, ResolvedDefaultLocale } from "@intlayer/types/module_augmentation";
-//#region src/localization/getLocalizedUrl.d.ts
 /**
  * Generate URL by prefixing the given URL with the referenced locale or adding search parameters
  * based on the routing mode. Handles both absolute and relative URLs appropriately.
@@ -58,5 +57,4 @@ import { LocalesValues, LocalizedUrl, ResolvedDefaultLocale } from "@intlayer/ty
  * and the relative one it returns when the current page already lives there.
  */
 export declare const getLocalizedUrl: <const T extends string, const L extends LocalesValues = ResolvedDefaultLocale>(url: T, currentLocale?: L, options?: RoutingOptions) => LocalizedUrl<T, L>;
-//#endregion
 //# sourceMappingURL=getLocalizedUrl.d.ts.map

package/dist/types/localization/getLocalizedUrl.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getLocalizedUrl.d.ts","names":[],"sources":["../../../src/localization/getLocalizedUrl.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAmEa,wBACL,wBACA,UAAU,gBAAgB,uBAAqB,KAEhD,GAAC,gBACS,GAAC,UACP,mBACR,aAAa,GAAG"}
+{"version":3,"file":"getLocalizedUrl.d.ts","names":[],"sources":["../../../src/localization/getLocalizedUrl.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAmEa,wBACL,wBACA,UAAU,gBAAgB,uBAAqB,KAEhD,GAAC,gBACS,GAAC,UACP,mBACR,aAAa,GAAG"}

package/dist/types/localization/getMultilingualUrls.d.ts

@@ -1,6 +1,5 @@
 import { RoutingOptions } from "./getPrefix.js";
 import { StrictModeLocaleMap } from "@intlayer/types/module_augmentation";
-//#region src/localization/getMultilingualUrls.d.ts
 /**
  * Generates multilingual URLs by prefixing the given URL with each supported locale
  * or adding search parameters based on the routing mode.
@@ -36,5 +35,4 @@ import { StrictModeLocaleMap } from "@intlayer/types/module_augmentation";
  * @returns An object mapping each locale to its corresponding multilingual URL.
  */
 export declare const getMultilingualUrls: (url: string, options?: RoutingOptions) => StrictModeLocaleMap<string>;
-//#endregion
 //# sourceMappingURL=getMultilingualUrls.d.ts.map

package/dist/types/localization/getMultilingualUrls.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getMultilingualUrls.d.ts","names":[],"sources":["../../../src/localization/getMultilingualUrls.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAsCa,sBAAmB,aACnB,UACF,mBACR"}
+{"version":3,"file":"getMultilingualUrls.d.ts","names":[],"sources":["../../../src/localization/getMultilingualUrls.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAsCa,sBAAmB,aACnB,UACF,mBACR"}

package/dist/types/localization/getPathWithoutLocale.d.ts

@@ -1,5 +1,4 @@
 import { DeclaredLocales, LocalesValues, PathWithoutLocale } from "@intlayer/types/module_augmentation";
-//#region src/localization/getPathWithoutLocale.d.ts
 /**
  * Removes the locale segment from the given URL or pathname if present.
  * Also removes locale from search parameters if present.
@@ -30,5 +29,4 @@ import { DeclaredLocales, LocalesValues, PathWithoutLocale } from "@intlayer/typ
  * back to `string`.
  */
 export declare const getPathWithoutLocale: <const T extends string, const L extends LocalesValues = DeclaredLocales>(inputUrl: T, locales?: L[]) => PathWithoutLocale<T, L>;
-//#endregion
 //# sourceMappingURL=getPathWithoutLocale.d.ts.map

package/dist/types/localization/getPathWithoutLocale.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getPathWithoutLocale.d.ts","names":[],"sources":["../../../src/localization/getPathWithoutLocale.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA0Da,6BACL,wBACA,UAAU,gBAAgB,iBAAe,UAErC,GAAC,UACF,QACR,kBAAkB,GAAG"}
+{"version":3,"file":"getPathWithoutLocale.d.ts","names":[],"sources":["../../../src/localization/getPathWithoutLocale.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA0Da,6BACL,wBACA,UAAU,gBAAgB,iBAAe,UAErC,GAAC,UACF,QACR,kBAAkB,GAAG"}

package/dist/types/localization/getPrefix.d.ts

@@ -1,6 +1,5 @@
 import { DeclaredLocales, DomainRuleMap, IsDomainExclusive, LocalesValues, ResolvedDefaultLocale, ResolvedDomains, ResolvedRoutingMode } from "@intlayer/types/module_augmentation";
 import { RewriteRules, RoutingConfig } from "@intlayer/types/config";
-//#region src/localization/getPrefix.d.ts
 /**
  * Shared routing options used across all URL localization functions.
  */
@@ -124,5 +123,4 @@ export type GetPrefixResultNarrowed<L extends LocalesValues | undefined, Mode ex
  * @returns An object containing pathPrefix, prefix, and localePrefix for the given locale.
  */
 export declare const getPrefix: <const L extends LocalesValues | undefined>(locale: L, options?: RoutingOptions) => GetPrefixResultNarrowed<L>;
-//#endregion
 //# sourceMappingURL=getPrefix.d.ts.map

package/dist/types/localization/getPrefix.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getPrefix.d.ts","names":[],"sources":["../../../src/localization/getPrefix.ts"],"mappings":";;;;;;YAqBY;EACV,UAAU;EACV,gBAAgB;EAChB,OAAO;EACP,UAAU,2BAA2B;EACrC,UAAU;;;;;;;;;;;;EAYV;;;;;;qBAOW,uBAAoB,UACtB,mBACR,KAAK;EACN,eAAe;EACf,MAAM;EACN,SAAS;;;;;;;;;;;;;;qBA0BE,mBAAgB,OACpB,kCAAgC,mBACpB,oBAClB,SAAS;YAGA;EACV,gBAAgB;EAChB,OAAO;;YAGG;;;;;EAKV;;;;EAIA,cAAc;;;;;;;;;;;;;YAcJ,wBACV,UAAU,2BACV,sBAAsB,qBACtB,gBAAgB,gBAAgB,uBAChC,gBAAgB,gBAAgB,mBAC9B,qCACkB,KAChB,wBAAwB,iBAAiB,MAAM,SAAS,WACxD,kBAAkB,GAAG;EACjB;EAAY;sBACI,QAChB,kBACA;EACI,WAAW;EAAM,cAAc;IACjC,mCACE,UAAU;EACN;EAAY;;EACZ,WAAW;EAAM,cAAc;;EACjC;EAAY;;EACtB;EAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAmCL,kBAAmB,UAAU,2BAAyB,QACzD,GAAC,UACA,mBACR,wBAAwB"}
+{"version":3,"file":"getPrefix.d.ts","names":[],"sources":["../../../src/localization/getPrefix.ts"],"mappings":";;;;;YAqBY;EACV,UAAU;EACV,gBAAgB;EAChB,OAAO;EACP,UAAU,2BAA2B;EACrC,UAAU;;;;;;;;;;;;EAYV;;;;;;qBAOW,uBAAoB,UACtB,mBACR,KAAK;EACN,eAAe;EACf,MAAM;EACN,SAAS;;;;;;;;;;;;;;qBA0BE,mBAAgB,OACpB,kCAAgC,mBACpB,oBAClB,SAAS;YAGA;EACV,gBAAgB;EAChB,OAAO;;YAGG;;;;;EAKV;;;;EAIA,cAAc;;;;;;;;;;;;;YAcJ,wBACV,UAAU,2BACV,sBAAsB,qBACtB,gBAAgB,gBAAgB,uBAChC,gBAAgB,gBAAgB,mBAC9B,qCACkB,KAChB,wBAAwB,iBAAiB,MAAM,SAAS,WACxD,kBAAkB,GAAG;EACjB;EAAY;sBACI,QAChB,kBACA;EACI,WAAW;EAAM,cAAc;IACjC,mCACE,UAAU;EACN;EAAY;;EACZ,WAAW;EAAM,cAAc;;EACjC;EAAY;;EACtB;EAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAmCL,kBAAmB,UAAU,2BAAyB,QACzD,GAAC,UACA,mBACR,wBAAwB"}

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

@@ -5,7 +5,6 @@ import { getBrowserLocale } from "./getBrowserLocale.js";
 import { getCanonicalPath } from "./getCanonicalPath.js";
 import { getHTMLTextDir } from "./getHTMLTextDir.js";
 import { getLocale } from "./getLocale.js";
-import { GetPrefixOptions, GetPrefixResult, getPrefix, isDeclaredLocale } from "./getPrefix.js";
 import { getLocaleFromPath } from "./getLocaleFromPath.js";
 import { LocaleRequest, getLocaleFromRequest } from "./getLocaleFromRequest.js";
 import { getLocaleLang } from "./getLocaleLang.js";
@@ -14,6 +13,7 @@ import { getLocalizedPath } from "./getLocalizedPath.js";
 import { getLocalizedUrl } from "./getLocalizedUrl.js";
 import { getMultilingualUrls } from "./getMultilingualUrls.js";
 import { getPathWithoutLocale } from "./getPathWithoutLocale.js";
+import { GetPrefixOptions, GetPrefixResult, getPrefix, isDeclaredLocale } from "./getPrefix.js";
 import { localeDetector } from "./localeDetector.js";
 import { localeFlatMap, localeMap, localeRecord } from "./localeMapper.js";
 import { localeResolver } from "./localeResolver.js";

package/dist/types/localization/localeDetector.d.ts

@@ -1,6 +1,5 @@
 import { DeclaredLocales } from "@intlayer/types/module_augmentation";
 import { Locale } from "@intlayer/types/allLocales";
-//#region src/localization/localeDetector.d.ts
 /**
  * Derives the list of preferred languages based on the Accept-Language header
  * and an optional list of available languages.
@@ -15,5 +14,4 @@ export declare const getPreferredLanguages: (acceptHeader: string | undefined, a
  * The result is memoized, as it only depends on its arguments.
  */
 export declare const localeDetector: (headers: Record<string, string | undefined>, availableLocales?: Locale[], defaultLocale?: Locale) => DeclaredLocales;
-//#endregion
 //# sourceMappingURL=localeDetector.d.ts.map

package/dist/types/localization/localeDetector.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"localeDetector.d.ts","names":[],"sources":["../../../src/localization/localeDetector.ts"],"mappings":";;;;;;;qBAuQa,wBAAqB,kCACA;;;;;;;;;qBAuCrB,iBAAc,SAChB,oCAAkC,mBACxB,UAAQ,gBACX,WACf"}
+{"version":3,"file":"localeDetector.d.ts","names":[],"sources":["../../../src/localization/localeDetector.ts"],"mappings":";;;;;;qBAuQa,wBAAqB,kCACA;;;;;;;;;qBAuCrB,iBAAc,SAChB,oCAAkC,mBACxB,UAAQ,gBACX,WACf"}

package/dist/types/localization/localeMapper.d.ts

@@ -1,5 +1,4 @@
 import { DeclaredLocales, LocalesValues } from "@intlayer/types/module_augmentation";
-//#region src/localization/localeMapper.d.ts
 export type LocaleData = {
   locale: DeclaredLocales;
   defaultLocale: DeclaredLocales;
@@ -85,5 +84,4 @@ export declare const localeFlatMap: <T>(mapper: (locale: LocaleData) => T[], loc
  * @returns Record mapping locale codes to mapped values
  */
 export declare const localeRecord: <T>(mapper: (locale: LocaleData) => T, locales?: LocalesValues[], defaultLocale?: LocalesValues, mode?: 'prefix-no-default' | 'prefix-all' | 'no-prefix' | 'search-params') => Record<LocalesValues, T>;
-//#endregion
 //# sourceMappingURL=localeMapper.d.ts.map

package/dist/types/localization/localeMapper.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"localeMapper.d.ts","names":[],"sources":["../../../src/localization/localeMapper.ts"],"mappings":";;YAQY;EACV,QAAQ;EACR,eAAe;EACf;EACA,SAAS;EACT;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA6BW,YAAa,GAAC,SAChB,QAAQ,eAAe,GAAC,UACxB,iBAAe,gBACT,eAAa,8EAO3B;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAwCU,gBAAiB,GAAC,SACpB,QAAQ,eAAe,KAAG,UAC1B,iBAAe,gBACT,eAAa,8EAO3B;;;;;;;;;;;;;;;;;;;;;;;;qBAqCU,eAAgB,GAAC,SACnB,QAAQ,eAAe,GAAC,UACxB,iBAAe,gBACT,eAAa,8EAO3B,OAAO,eAAe"}
+{"version":3,"file":"localeMapper.d.ts","names":[],"sources":["../../../src/localization/localeMapper.ts"],"mappings":";YAQY;EACV,QAAQ;EACR,eAAe;EACf;EACA,SAAS;EACT;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA6BW,YAAa,GAAC,SAChB,QAAQ,eAAe,GAAC,UACxB,iBAAe,gBACT,eAAa,8EAO3B;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAwCU,gBAAiB,GAAC,SACpB,QAAQ,eAAe,KAAG,UAC1B,iBAAe,gBACT,eAAa,8EAO3B;;;;;;;;;;;;;;;;;;;;;;;;qBAqCU,eAAgB,GAAC,SACnB,QAAQ,eAAe,GAAC,UACxB,iBAAe,gBACT,eAAa,8EAO3B,OAAO,eAAe"}

package/dist/types/localization/localeResolver.d.ts

@@ -1,9 +1,7 @@
 import { DeclaredLocales, LocalesValues } from "@intlayer/types/module_augmentation";
-//#region src/localization/localeResolver.d.ts
 /**
  * Resolves the most specific locale from a user-provided list,
  * or falls back to the default locale if no match is found.
  */
 export declare const localeResolver: (selectedLocale: LocalesValues | LocalesValues[], locales?: LocalesValues[], defaultLocale?: LocalesValues) => DeclaredLocales;
-//#endregion
 //# sourceMappingURL=localeResolver.d.ts.map

package/dist/types/localization/localeResolver.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"localeResolver.d.ts","names":[],"sources":["../../../src/localization/localeResolver.ts"],"mappings":";;;;;;qBAUa,iBAAc,gBACT,gBAAgB,iBAAe,UACtC,iBAAe,gBACT,kBACd"}
+{"version":3,"file":"localeResolver.d.ts","names":[],"sources":["../../../src/localization/localeResolver.ts"],"mappings":";;;;;qBAUa,iBAAc,gBACT,gBAAgB,iBAAe,UACtC,iBAAe,gBACT,kBACd"}

package/dist/types/localization/proxyMode.d.ts

@@ -1,4 +1,3 @@
-//#region src/localization/proxyMode.d.ts
 /**
  * Effective mode of the Intlayer locale-routing proxy, resolved from the
  * `routing.enableProxy` configuration option.
@@ -98,5 +97,4 @@ export type ProxyStorageSuppressionPurpose = 'dev' | 'build';
  * ```
  */
 export declare const formatProxyEnabledMessage: (isStorageLocaleSuppressed: boolean, purpose?: ProxyStorageSuppressionPurpose) => string;
-//#endregion
 //# sourceMappingURL=proxyMode.d.ts.map

package/dist/types/localization/proxyMode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"proxyMode.d.ts","names":[],"sources":["../../../src/localization/proxyMode.ts"],"mappings":";;;;;;;;;;;;;;;YAiBY;;;;;;;;;;;;;;;;;;;;;qBAsBC,mBAAgB,0BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;qBAkC5C,8BAA2B,WAC3B,WAAS;;;;;;;;YAWV;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA+BC,4BAAyB,oCACF,UACzB"}
+{"version":3,"file":"proxyMode.d.ts","names":[],"sources":["../../../src/localization/proxyMode.ts"],"mappings":";;;;;;;;;;;;;;YAiBY;;;;;;;;;;;;;;;;;;;;;qBAsBC,mBAAgB,0BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;qBAkC5C,8BAA2B,WAC3B,WAAS;;;;;;;;YAWV;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA+BC,4BAAyB,oCACF,UACzB"}

package/dist/types/localization/resolveBrowserLocale.d.ts

@@ -1,6 +1,5 @@
 import { RoutingOptions } from "./getPrefix.js";
 import { LocalesValues } from "@intlayer/types/module_augmentation";
-//#region src/localization/resolveBrowserLocale.d.ts
 /**
  * Resolves the locale of the current document outside of React.
  *
@@ -30,5 +29,4 @@ export declare const resolveBrowserLocale: (options?: RoutingOptions) => Locales
  * falling back to an asynchronous read.
  */
 export declare const getPreloadLocale: () => LocalesValues;
-//#endregion
 //# sourceMappingURL=resolveBrowserLocale.d.ts.map

package/dist/types/localization/resolveBrowserLocale.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resolveBrowserLocale.d.ts","names":[],"sources":["../../../src/localization/resolveBrowserLocale.ts"],"mappings":";;;;;;;;;;;;;;;;;qBAoBa,uBAAoB,UACrB,mBACT;;;;;;;;;;;;;;qBAqDU,wBAAuB"}
+{"version":3,"file":"resolveBrowserLocale.d.ts","names":[],"sources":["../../../src/localization/resolveBrowserLocale.ts"],"mappings":";;;;;;;;;;;;;;;;qBAoBa,uBAAoB,UACrB,mBACT;;;;;;;;;;;;;;qBAqDU,wBAAuB"}

package/dist/types/localization/rewriteMatch.d.ts

@@ -1,5 +1,4 @@
 import { RewriteObject, RewriteRules, RoutingConfig } from "@intlayer/types/config";
-//#region src/localization/rewriteMatch.d.ts
 /**
  * Normalizes legacy Record format or extracts specialized rules from RewriteObject.
  *
@@ -15,5 +14,4 @@ export declare const fillPath: (pattern: string, params: string[]) => string;
  * Extract values from a URL based on a pattern.
  */
 export declare const extractParams: (url: string, pattern: string) => string[] | null;
-//#endregion
 //# sourceMappingURL=rewriteMatch.d.ts.map

package/dist/types/localization/rewriteMatch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rewriteMatch.d.ts","names":[],"sources":["../../../src/localization/rewriteMatch.ts"],"mappings":";;;;;;;;qBAYa,wBACL,sBAAsB,uBAAqB,SAExC,2BAA2B,cAAY,UACvC,YACR;;;;qBA6EU,WAAQ,iBAAmB;;;;qBAa3B,gBAAa,aACb"}
+{"version":3,"file":"rewriteMatch.d.ts","names":[],"sources":["../../../src/localization/rewriteMatch.ts"],"mappings":";;;;;;;qBAYa,wBACL,sBAAsB,uBAAqB,SAExC,2BAA2B,cAAY,UACvC,YACR;;;;qBA6EU,WAAQ,iBAAmB;;;;qBAa3B,gBAAa,aACb"}

package/dist/types/localization/rewriteUtils.d.ts

@@ -1,6 +1,5 @@
 import { LocalesValues, ResolvedDefaultLocale } from "@intlayer/types/module_augmentation";
 import { RewriteRules, RoutingConfig } from "@intlayer/types/config";
-//#region src/localization/rewriteUtils.d.ts
 /**
  * Outcome of resolving a canonical path against the rewrite rules.
  *
@@ -56,5 +55,5 @@ export declare const getInternalPath: <const Path extends string, const Locale e
  * Given a current pathname and locale, returns the pretty localized path if a rewrite rule exists and the path is not already localized.
  */
 export declare const getRewritePath: <const Path extends string, const Locale extends LocalesValues = ResolvedDefaultLocale>(pathname: Path, locale: Locale, rewrite?: RoutingConfig['rewrite']) => string | undefined;
-//#endregion
+export {};
 //# sourceMappingURL=rewriteUtils.d.ts.map

package/dist/types/localization/rewriteUtils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rewriteUtils.d.ts","names":[],"sources":["../../../src/localization/rewriteUtils.ts"],"mappings":";;;;;;;;;;YAgBY,oBAAoB;EAC1B,MAAM;EAAe;;EACrB;EAAc;;;KAGf,iBAAiB,uBAAuB,4BACzC,WACI;;;;;;;;;;;;;;;YAgBI,aACV,qBACA,wCACiB,gBAEf,iBAAiB,qBAAoB,2BACnC,qBAAqB,eAAe,qBAClC,WACA,2BACM,eACA,SAAS;;;;;;;;;;;;;;;qBAiBV,6BACL,oCACA,eAAe,gBAAgB,uBAAqB,eAE3C,eAAa,SACnB,QAAM,eACA,iBACd,oBAAoB;;;;;qBAkCV,wBACL,2BACA,eAAe,eAAa,eAEnB,MAAI,QACX,WACP,aAAa,MAAM;;;;qBAoBT,uBACL,2BACA,eAAe,gBAAgB,uBAAqB,UAEhD,MAAI,QACN,QAAM,UACJ"}
+{"version":3,"file":"rewriteUtils.d.ts","names":[],"sources":["../../../src/localization/rewriteUtils.ts"],"mappings":";;;;;;;;;YAgBY,oBAAoB;EAC1B,MAAM;EAAe;;EACrB;EAAc;;;KAGf,iBAAiB,uBAAuB,4BACzC,WACI;;;;;;;;;;;;;;;YAgBI,aACV,qBACA,wCACiB,gBAEf,iBAAiB,qBAAoB,2BACnC,qBAAqB,eAAe,qBAClC,WACA,2BACM,eACA,SAAS;;;;;;;;;;;;;;;qBAiBV,6BACL,oCACA,eAAe,gBAAgB,uBAAqB,eAE3C,eAAa,SACnB,QAAM,eACA,iBACd,oBAAoB;;;;;qBAkCV,wBACL,2BACA,eAAe,eAAa,eAEnB,MAAI,QACX,WACP,aAAa,MAAM;;;;qBAoBT,uBACL,2BACA,eAAe,gBAAgB,uBAAqB,UAEhD,MAAI,QACN,QAAM,UACJ"}

package/dist/types/localization/validatePrefix.d.ts

@@ -1,6 +1,5 @@
 import { RoutingOptions } from "./getPrefix.js";
 import { LocalesValues } from "@intlayer/types/module_augmentation";
-//#region src/localization/validatePrefix.d.ts
 export type ValidatePrefixResult = {
   isValid: boolean;
   localePrefix: string | undefined;
@@ -28,5 +27,4 @@ export type ValidatePrefixResult = {
  * });
  */
 export declare const validatePrefix: (locale: LocalesValues | undefined | null, options?: RoutingOptions) => ValidatePrefixResult;
-//#endregion
 //# sourceMappingURL=validatePrefix.d.ts.map

package/dist/types/localization/validatePrefix.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validatePrefix.d.ts","names":[],"sources":["../../../src/localization/validatePrefix.ts"],"mappings":";;;YAyBY;EACV;EACA;;;;;;;;;;;;;;;;;;;;;;;;qBAyBW,iBAAc,QACjB,kCAAgC,UAC9B,mBACT"}
+{"version":3,"file":"validatePrefix.d.ts","names":[],"sources":["../../../src/localization/validatePrefix.ts"],"mappings":";;YAyBY;EACV;EACA;;;;;;;;;;;;;;;;;;;;;;;;qBAyBW,iBAAc,QACjB,kCAAgC,UAC9B,mBACT"}

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

@@ -1,7 +1,6 @@
-import { CompileOptions, MarkdownContext, MarkdownOptions, MarkdownRuntime } from "./types.js";
 import { parserFor } from "./parser.js";
 import { renderFor } from "./renderer.js";
-//#region src/markdown/compiler.d.ts
+import { CompileOptions, MarkdownContext, MarkdownOptions, MarkdownRuntime } from "./types.js";
 type CreateElementFunction = (tag: any, props: Record<string, any> | null, ...children: any[]) => unknown;
 type FootnoteDef = {
   footnote: string;
@@ -69,5 +68,5 @@ export declare const renderMarkdownAst: (parsed: ParsedMarkdown, ctx: MarkdownCo
 export declare const compile: (markdown: string, ctx: MarkdownContext<any>, options?: MarkdownOptions) => unknown;
 export declare const createCompiler: (ctx: MarkdownContext<any>) => (markdown: string, options?: MarkdownOptions) => unknown;
 export declare const compileWithOptions: (markdown: string, runtime: MarkdownRuntime, options?: CompileOptions<any>) => unknown;
-//#endregion
+export {};
 //# sourceMappingURL=compiler.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"compiler.d.ts","names":[],"sources":["../../../src/markdown/compiler.ts"],"mappings":";;;;KAiHK,yBACH,UACA,OAAO,+BACJ;KAGA;EAAgB;EAAkB;;;;;;;KA2KlC;EACH,WAAW;EACX,YAAY;EACZ,aAAa;;KAGV;EAAqB,SAAS;;;;;;;KAa9B,iBAAiB,kBAAkB;KACnC,kBAAkB,kBAAkB;KAEpC;;EAEH,KAAK;EACL,SAAS;EACT;EACA,eAAe;EACf,OAAO;;;;;;;EAOP,OAAO;EACP,MAAM;;;;;;qBAsCK,aAAU,KAChB,sBAAoB,SAChB,iBAAe,uBAEvB;;YA+hCS,qBAAqB;EAE7B;EAAgB;;YAGR;EACV;EACA,WAAW;;;;;;EAMX,YAAY;EACZ;;qBAwSW,gBAAa,kBACR,KACX,sBAAoB,UAChB,oBACR;qBAiBU,oBAAiB,QACpB,gBAAc,KACjB,sBAAoB,UAChB;qBAaE,UAAO,kBACF,KACX,sBAAoB,UAChB;qBA8BE,iBAAc,KACnB,0BAAoB,kBACT,UAAY;qBAGlB,qBAAkB,kBACb,SACP,iBAAe,UACf"}
+{"version":3,"file":"compiler.d.ts","names":[],"sources":["../../../src/markdown/compiler.ts"],"mappings":";;;KAiHK,yBACH,UACA,OAAO,+BACJ;KAGA;EAAgB;EAAkB;;;;;;;KA2KlC;EACH,WAAW;EACX,YAAY;EACZ,aAAa;;KAGV;EAAqB,SAAS;;;;;;;KAa9B,iBAAiB,kBAAkB;KACnC,kBAAkB,kBAAkB;KAEpC;;EAEH,KAAK;EACL,SAAS;EACT;EACA,eAAe;EACf,OAAO;;;;;;;EAOP,OAAO;EACP,MAAM;;;;;;qBAsCK,aAAU,KAChB,sBAAoB,SAChB,iBAAe,uBAEvB;;YA+hCS,qBAAqB;EAE7B;EAAgB;;YAGR;EACV;EACA,WAAW;;;;;;EAMX,YAAY;EACZ;;qBAwSW,gBAAa,kBACR,KACX,sBAAoB,UAChB,oBACR;qBAiBU,oBAAiB,QACpB,gBAAc,KACjB,sBAAoB,UAChB;qBAaE,UAAO,kBACF,KACX,sBAAoB,UAChB;qBA8BE,iBAAc,KACnB,0BAAoB,kBACT,UAAY;qBAGlB,qBAAkB,kBACb,SACP,iBAAe,UACf"}

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

@@ -1,4 +1,3 @@
-//#region src/markdown/constants.d.ts
 /**
  * Analogous to `node.type`. Please note that the values here may change at any time,
  * so do not hard code against the value directly.
@@ -90,7 +89,10 @@ export declare const NAMED_CODES_TO_UNICODE: Record<string, string>;
 export declare const DO_NOT_PROCESS_HTML_ELEMENTS: string[];
 /** Attributes that require URL sanitization */
 export declare const ATTRIBUTES_TO_SANITIZE: string[];
-/** Attribute extractor regex */
+/**
+ * Attribute extractor regex. Values may be double/single quoted, `{…}`
+ * expressions, or unquoted `[…]` arrays (`codeFormat=["typescript", "esm"]`).
+ */
 export declare const ATTR_EXTRACTOR_R: RegExp;
 /** First character of a valid attribute name (a letter, `_` or `:`). */
 export declare const ATTRIBUTE_NAME_START_R: RegExp;
@@ -201,5 +203,4 @@ export declare const UNORDERED_LIST_ITEM_R: RegExp;
 export declare const generateListRegex: (type: ListType) => RegExp;
 export declare const ORDERED_LIST_R: RegExp;
 export declare const UNORDERED_LIST_R: RegExp;
-//#endregion
 //# sourceMappingURL=constants.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","names":[],"sources":["../../../src/markdown/constants.ts"],"mappings":";;;;;qBAQa;WACX;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;;WAEA;WACA;;WAEA;;WAEA;WACA;WACA;;WAEA;;WAEA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;;YAUU,wBAAwB,uBAAuB;;;;qBAS9C;;WAEX;;WAEA;;WAEA;;WAEA;;WAEA;;YAGU,wBAAwB,uBAAuB;;;;;;;;qBAa9C;WACX;WACA;WACA;;qBAGW;qBACA;qBACA;YAED,yBACA,wBAAwB;;;;;qBAavB,4BAA4B;;;;qBAsD5B,wBAAwB;;qBAcxB;;qBAGA;;qBAcA,kBAAgB;;qBAIhB,wBAAsB;;qBAGtB,aAAW;;qBAGX,cAAY;qBACZ,kCAAgC;qBAChC,oBAAkB;;qBAGlB,cAAY;qBACZ,kBAAgB;;qBAOhB,qBAAmB;qBAEnB,cAAY;;qBAEZ,mBAAiB;qBACjB,eAAa;;qBAGb,uBAAqB;qBACrB,cAAY;;qBAGZ,YAAU;qBACV,sBAAoB;;qBAGpB,YAAU;;qBAGV,gBAAc;;qBAGd,YAAU;;qBAGV,WAAS;qBACT,yBAAuB;qBAEvB,kBAAgB;;qBAIhB,kBAAgB;qBAEhB,gBAAc;qBACd,oBAAkB;;qBAGlB,iBAAe;;qBAGf,0BAAwB;qBACxB,iBAAe;qBACf,6BAA2B;;;;;;;;;qBAU3B,YAAU;qBAEV,kBAAgB;qBAChB,oBAAkB;qBAClB,kBAAgB;qBAChB,mBAAiB;;qBAGjB,aAAW;;qBAGX,yBAAuB;qBAEvB,mBAAiB;qBACjB,kBAAgB;;qBAGhB,0BAAwB;;qBAGxB,OAAK;qBACL,wBAAsB;qBACtB,yBAAuB;;qBAGvB;qBACA;;qBAGA,gBAAc;qBACd,YAAU;;qBAGV,aAAW;YAMZ;qBACC,SAAS;qBACT,WAAW;;;;;qBAUX,YAAS;;;;;qBAOT;;qBAIA,aAAW;;qBAKX,mBAAiB;;qBAKjB,eAAa;;qBAKb,wBAAsB;qBAQtB,yBAAsB,MAAU;qBAQhC;qBACA;qBAEA,8BAA2B,MAAU,aAAW;qBAOhD,4BAA0B;qBAC1B,8BAA4B;qBAG5B,wBAAqB,MAAU,aAAW;qBAc1C,qBAAmB;qBACnB,uBAAqB;qBAErB,oBAAiB,MAAU,aAAW;qBA4BtC,gBAAc;qBACd,kBAAgB"}
+{"version":3,"file":"constants.d.ts","names":[],"sources":["../../../src/markdown/constants.ts"],"mappings":";;;;qBAQa;WACX;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;;WAEA;WACA;;WAEA;;WAEA;WACA;WACA;;WAEA;;WAEA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;;YAUU,wBAAwB,uBAAuB;;;;qBAS9C;;WAEX;;WAEA;;WAEA;;WAEA;;WAEA;;YAGU,wBAAwB,uBAAuB;;;;;;;;qBAa9C;WACX;WACA;WACA;;qBAGW;qBACA;qBACA;YAED,yBACA,wBAAwB;;;;;qBAavB,4BAA4B;;;;qBAsD5B,wBAAwB;;qBAcxB;;qBAGA;;;;;qBAiBA,kBAAgB;;qBAIhB,wBAAsB;;qBAGtB,aAAW;;qBAGX,cAAY;qBACZ,kCAAgC;qBAChC,oBAAkB;;qBAGlB,cAAY;qBACZ,kBAAgB;;qBAOhB,qBAAmB;qBAEnB,cAAY;;qBAEZ,mBAAiB;qBACjB,eAAa;;qBAGb,uBAAqB;qBACrB,cAAY;;qBAGZ,YAAU;qBACV,sBAAoB;;qBAGpB,YAAU;;qBAGV,gBAAc;;qBAGd,YAAU;;qBAGV,WAAS;qBACT,yBAAuB;qBAEvB,kBAAgB;;qBAIhB,kBAAgB;qBAEhB,gBAAc;qBACd,oBAAkB;;qBAGlB,iBAAe;;qBAGf,0BAAwB;qBACxB,iBAAe;qBACf,6BAA2B;;;;;;;;;qBAU3B,YAAU;qBAEV,kBAAgB;qBAChB,oBAAkB;qBAClB,kBAAgB;qBAChB,mBAAiB;;qBAGjB,aAAW;;qBAGX,yBAAuB;qBAEvB,mBAAiB;qBACjB,kBAAgB;;qBAGhB,0BAAwB;;qBAGxB,OAAK;qBACL,wBAAsB;qBACtB,yBAAuB;;qBAGvB;qBACA;;qBAGA,gBAAc;qBACd,YAAU;;qBAGV,aAAW;YAMZ;qBACC,SAAS;qBACT,WAAW;;;;;qBAUX,YAAS;;;;;qBAOT;;qBAIA,aAAW;;qBAKX,mBAAiB;;qBAKjB,eAAa;;qBAKb,wBAAsB;qBAQtB,yBAAsB,MAAU;qBAQhC;qBACA;qBAEA,8BAA2B,MAAU,aAAW;qBAOhD,4BAA0B;qBAC1B,8BAA4B;qBAG5B,wBAAqB,MAAU,aAAW;qBAc1C,qBAAmB;qBACnB,uBAAqB;qBAErB,oBAAiB,MAAU,aAAW;qBA4BtC,gBAAc;qBACd,kBAAgB"}

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

@@ -1,4 +1,3 @@
-//#region src/markdown/elementScanner.d.ts
 /**
  * Lean, non-backtracking element scanner for HTML blocks, custom components, and self-closing tags.
  */
@@ -10,5 +9,4 @@ export declare const startsWithHtmlBlockElement: (source: string) => boolean;
 export declare const startsWithSelfClosingElement: (source: string) => boolean;
 export declare const startsWithCustomComponent: (source: string) => boolean;
 export declare const startsWithElement: (source: string) => boolean;
-//#endregion
 //# sourceMappingURL=elementScanner.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"elementScanner.d.ts","names":[],"sources":["../../../src/markdown/elementScanner.ts"],"mappings":";;;;qBA+Ga,eAAY,gBACT,6BAEb;qBAkHU,0BAAuB,mBAEjC;qBA4DU,wBAAqB,mBAAkB;qBAEvC,uBAAoB,mBAAkB;qBAEtC,6BAA0B;qBAE1B,+BAA4B;qBAE5B,4BAAyB;qBAEzB,oBAAiB"}
+{"version":3,"file":"elementScanner.d.ts","names":[],"sources":["../../../src/markdown/elementScanner.ts"],"mappings":";;;qBA+Ga,eAAY,gBACT,6BAEb;qBAkHU,0BAAuB,mBAEjC;qBA4DU,wBAAqB,mBAAkB;qBAEvC,uBAAoB,mBAAkB;qBAEtC,6BAA0B;qBAE1B,+BAA4B;qBAE5B,4BAAyB;qBAEzB,oBAAiB"}

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

@@ -3,10 +3,10 @@ import { getMarkdownMetadata } from "../transpiler/markdown/getMarkdownMetadata.
 import { MarkdownContent, MarkdownContentConstructor, md as markdown } from "../transpiler/markdown/markdown.js";
 import { MarkdownValidationResult, validateMarkdown } from "../transpiler/markdown/validateMarkdown.js";
 import "../transpiler/markdown/index.js";
+import { MarkdownReferences, ParsedMarkdown, compile, compileWithOptions, createCompiler, getRuleSet, parseMarkdown, renderMarkdownAst } from "./compiler.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 "./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 "./types.js";
 import { parserFor } from "./parser.js";
 import { createRenderer, renderFor } from "./renderer.js";
-import { MarkdownReferences, ParsedMarkdown, compile, compileWithOptions, createCompiler, getRuleSet, parseMarkdown, renderMarkdownAst } from "./compiler.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 "./types.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 "./utils.js";
 export { 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, type BlockQuoteNode, BlockSyntaxProbe, type BoldTextNode, type BreakLineNode, type BreakThematicNode, CAPTURE_LETTER_AFTER_HYPHEN, CODE_BLOCK_FENCED_R, CODE_BLOCK_R, CODE_INLINE_R, CONSECUTIVE_NEWLINE_R, CR_NEWLINE_R, type CodeBlockNode, type CodeFencedNode, type CodeInlineNode, type CompileOptions, type ComponentOverrides, type CustomComponentNode, DO_NOT_PROCESS_HTML_ELEMENTS, type ElementType, type EscapedTextNode, FENCE_DELIMITER_R, FOOTNOTE_R, FOOTNOTE_REFERENCE_R, FORMFEED_R, FRONT_MATTER_R, type FootnoteNode, type FootnoteReferenceNode, type GFMTaskNode, GFM_TASK_R, HEADING_ATX_COMPLIANT_R, HEADING_R, HEADING_SETEXT_R, type HTMLCommentNode, type HTMLNode, type HTMLSelfClosingNode, type HTMLTag, HTML_CHAR_CODE_R, HTML_COMMENT_R, HTML_CUSTOM_ATTR_R, HTML_LEFT_TRIM_AMOUNT_R, type HeadingNode, type HeadingSetextNode, INLINE_SKIP_R, INTERPOLATION_R, type ImageNode, type ItalicTextNode, LINK_AUTOLINK_BARE_URL_R, LINK_AUTOLINK_R, LOOKAHEAD, type LinkAngleBraceNode, type LinkBareURLNode, type LinkNode, ListType, MarkdownContent, MarkdownContentConstructor, type MarkdownContext, type MarkdownOptions, MarkdownReferences, type MarkdownRuntime, type HTMLValidationIssue as MarkdownValidationIssue, MarkdownValidationResult, type MarkedTextNode, NAMED_CODES_TO_UNICODE, NP_TABLE_R, type NestedParser, type NewlineNode, ORDERED, ORDERED_LIST_BULLET, ORDERED_LIST_ITEM_PREFIX, ORDERED_LIST_ITEM_PREFIX_R, ORDERED_LIST_ITEM_R, ORDERED_LIST_R, type OrderedListNode, PARAGRAPH_R, type ParagraphNode, type ParseState, ParsedMarkdown, type Parser, type ParserResult, Priority, PriorityValue, REFERENCE_IMAGE_OR_LINK, REFERENCE_IMAGE_R, REFERENCE_LINK_R, type ReferenceImageNode, type ReferenceLinkNode, type ReferenceNode, type RenderRuleHook, type Rule, type RuleOutput, RuleScope, RuleScopeValue, RuleType, RuleTypeValue, type Rules, SCOPE_BLOCK, SCOPE_BOTH, SCOPE_INLINE, SHORTCODE_R, SHOULD_RENDER_AS_BLOCK_R, type StrikethroughTextNode, 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, type TableNode, type TableSeparatorNode, type TextNode, UNESCAPE_R, UNORDERED, UNORDERED_LIST_BULLET, UNORDERED_LIST_ITEM_PREFIX, UNORDERED_LIST_ITEM_PREFIX_R, UNORDERED_LIST_ITEM_R, UNORDERED_LIST_R, type UnorderedListNode, allowInline, anyScopeRegex, attributeValueToNodePropValue, blockRegex, captureNothing, compile, compileWithOptions, createCompiler, createRenderer, cx, generateListItemPrefix, generateListItemPrefixRegex, generateListItemRegex, generateListRegex, get, getMarkdownMetadata, getRuleSet, inlineRegex, markdown as md, normalizeAttributeKey, normalizeWhitespace, parseBlock, parseCaptureInline, parseInline, parseMarkdown, parseSimpleInline, parseStyleAttribute, parseTableAlign, parseTableAlignCapture, parseTableCells, parseTableRow, parserFor, qualifies, renderFor, renderMarkdownAst, renderNothing, sanitizer, simpleInlineRegex, slugify, some, startsWith, trimEnd, trimLeadingWhitespaceOutsideFences, unescapeString, unquote, validateMarkdown };

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

@@ -1,9 +1,7 @@
 import { ParseState, ParserResult, Rules } from "./types.js";
-//#region src/markdown/parser.d.ts
 /**
  * Creates a parser for a given set of rules, with the precedence
  * specified as a list of rules.
  */
 export declare const parserFor: (rules: Rules) => ((source: string, state: ParseState) => ParserResult[]);
-//#endregion
 //# sourceMappingURL=parser.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"parser.d.ts","names":[],"sources":["../../../src/markdown/parser.ts"],"mappings":";;;;;;qBAoEa,YAAS,OACb,YACJ,gBAAgB,OAAO,eAAe"}
+{"version":3,"file":"parser.d.ts","names":[],"sources":["../../../src/markdown/parser.ts"],"mappings":";;;;;qBAoEa,YAAS,OACb,YACJ,gBAAgB,OAAO,eAAe"}

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

@@ -1,5 +1,4 @@
 import { ParseState, ParserResult, RenderRuleHook, RuleOutput, Rules } from "./types.js";
-//#region src/markdown/renderer.d.ts
 /**
  * Creates a renderer for AST nodes.
  * Renamed from `reactFor` to be framework-agnostic.
@@ -12,5 +11,4 @@ export declare const renderFor: (render: (ast: ParserResult, render: RuleOutput,
  * Creates a renderer from rules with optional custom render hook.
  */
 export declare const createRenderer: (rules: Rules, userRender?: RenderRuleHook) => (ast: ParserResult, render: RuleOutput, state: ParseState) => unknown;
-//#endregion
 //# sourceMappingURL=renderer.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"renderer.d.ts","names":[],"sources":["../../../src/markdown/renderer.ts"],"mappings":";;;;;;;;;qBAiBa,YAAS,SACX,KAAK,cAAc,QAAQ,YAAY,OAAO,4BAAsB,KAGtE,eAAe,gBAAc,QAC3B;;;;qBA0CE,iBAAc,OAAW,OAAK,aAAe,oBAAc,KAM7D,cAAY,QACT,YAAU,OACX"}
+{"version":3,"file":"renderer.d.ts","names":[],"sources":["../../../src/markdown/renderer.ts"],"mappings":";;;;;;;;qBAiBa,YAAS,SACX,KAAK,cAAc,QAAQ,YAAY,OAAO,4BAAsB,KAGtE,eAAe,gBAAc,QAC3B;;;;qBA0CE,iBAAc,OAAW,OAAK,aAAe,oBAAc,KAM7D,cAAY,QACT,YAAU,OACX"}

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

@@ -1,5 +1,4 @@
 import { RuleScopeValue } from "./constants.js";
-//#region src/markdown/types.d.ts
 /**
  * Permissive element type - core doesn't care what frameworks accept.
  * Can be a string tag ('div', 'span') or any component (function, object, class)
@@ -367,5 +366,4 @@ export type CompileOptions<T = any> = MarkdownOptions & {
   /** Custom slugify function */
   slugify?: (input: string, defaultFn: (input: string) => string) => string;
 };
-//#endregion
 //# sourceMappingURL=types.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","names":[],"sources":["../../../src/markdown/types.ts"],"mappings":";;;;;;YAUY;;;;YAKA;;;;;YAMA;;;;;;;EAOV,gBACE,MAAM,aACN,OAAO,+BACJ;;;;;EAOL;;;;;;;;;;EAWA,kBACE,KAAK,SACL,OAAO,wBACJ;;;;GAKJ;;;;;YAMS,gBAAgB;;EAE1B,SAAS;;EAET,aAAa,mBAAmB;;EAEhC,aAAa,aAAa,KAAK,SAAS;;EAExC,WAAW,cAAc,YAAY;;EAErC,sBAAsB;;;;;YAUZ;;EAEV;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;;;;;EAMA;;EAEA;;EAEA;;YAOU;EACV;EACA;EACA,UAAU;;YAGA;EACV;;YAGU;EACV;;YAGU;EACV;EACA,QAAQ;EACR;EACA;;YAGU;EACV;;YAGU;EACV;EACA;;YAGU;EACV;;YAGU;EACV;EACA;EACA;;YAGU;EACV;EACA;;YAGU;EACV;EACA,UAAU;EACV;EACA;;YAGU;EACV;;YAGU;EACV;;YAGU;EACV;EACA;EACA;EACA;;YAGU;EACV;EACA,UAAU;EACV;EACA;;YAGU;EACV;;YAGU;EACV;;YAGU;EACV;EACA,OAAO;EACP;EACA;;YAGU;EACV;EACA,OAAO;EACP;;YAGU;EACV;;YAGU;EACV;EACA,UAAU;;YAGA;EACV;;YAGU;EACV;EACA;EACA;;YAGU;EACV;EACA,UAAU;EACV;EACA;;YAGU;EACV;EACA;EACA,OAAO;EACP,QAAQ;;YAGE;EACV;;YAGU;EACV;EACA;;YAGU;EACV;EACA,UAAU;;YAGA;EACV;EACA,UAAU;;YAGA;EACV;;YAGU;EACV;EACA,UAAU;;YAGA;EACV;EACA,UAAU;;YAGA;EACV;EACA,OAAO;EACP,WAAW;EACX;EACA,KAAK;EACL;;YAGU;EACV;EACA,OAAO;EACP;;YAGU;EACV;EACA,OAAO;EACP,WAAW;EACX;EACA;EACA;;;;;YAMU,eACR,iBACA,gBACA,oBACA,gBACA,iBACA,iBACA,sBACA,eACA,wBACA,cACA,cACA,oBACA,kBACA,YACA,WACA,qBACA,kBACA,kBACA,oBACA,cACA,gBACA,gBACA,qBACA,oBACA,YACA,qBACA,WACA,eACA,iBACA,kBACA,iBACA,wBACA,WACA;;;;YASQ,gBAAgB,eAAe,OAAO,eAAe;;;;YAKrD,OAAO,iBACjB,SAAS,kBACT,aAAa,cACb,OAAO,eACJ;;;;YAKO,cACV,KAAK,eAAe,gBACpB,OAAO;;;;YAMG,KAAK,eAAe;;EAE9B,SACE,gBACA,OAAO,YACP,gCACG;;EAGL;;EAGA,QAAQ,OAAO,KAAK;;;;;EAMpB,wBAAwB,gBAAgB,OAAO;;;;;EAM/C;;;;;;;EAQA,SAAS;;;;;EAMT,WACE,MAAM,cACN,QAAQ,YACR,OAAO;;;;;YAOC;GACT,cAAc;;;;;YAUL,mBAAmB;GAC5B,cAAc;;;;;YAUL,kBAEV;;AAAA,qBAEA;;AAAA,MAAM,cAEN;;AAAA,gBAAgB,YAEhB;;AAAA,OAAO;;;;;YAOG;;;;EAIV;;;;EAKA;;;;EAKA;;;;EAKA;;;;EAKA;;;;EAKA;;;;EAKA,aAAa;;;;EAKb,UAAU;;;;EAKV;;;;EAKA;;;;;;YAOU,eAAe,WAAW;;EAEpC,aAAa,mBAAmB;;EAEhC,sBAAsB;;EAEtB,aAAa,eAAe,KAAK,SAAS;;EAE1C,WAAW,eAAe,YAAY"}
+{"version":3,"file":"types.d.ts","names":[],"sources":["../../../src/markdown/types.ts"],"mappings":";;;;;YAUY;;;;YAKA;;;;;YAMA;;;;;;;EAOV,gBACE,MAAM,aACN,OAAO,+BACJ;;;;;EAOL;;;;;;;;;;EAWA,kBACE,KAAK,SACL,OAAO,wBACJ;;;;GAKJ;;;;;YAMS,gBAAgB;;EAE1B,SAAS;;EAET,aAAa,mBAAmB;;EAEhC,aAAa,aAAa,KAAK,SAAS;;EAExC,WAAW,cAAc,YAAY;;EAErC,sBAAsB;;;;;YAUZ;;EAEV;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;;;;;EAMA;;EAEA;;EAEA;;YAOU;EACV;EACA;EACA,UAAU;;YAGA;EACV;;YAGU;EACV;;YAGU;EACV;EACA,QAAQ;EACR;EACA;;YAGU;EACV;;YAGU;EACV;EACA;;YAGU;EACV;;YAGU;EACV;EACA;EACA;;YAGU;EACV;EACA;;YAGU;EACV;EACA,UAAU;EACV;EACA;;YAGU;EACV;;YAGU;EACV;;YAGU;EACV;EACA;EACA;EACA;;YAGU;EACV;EACA,UAAU;EACV;EACA;;YAGU;EACV;;YAGU;EACV;;YAGU;EACV;EACA,OAAO;EACP;EACA;;YAGU;EACV;EACA,OAAO;EACP;;YAGU;EACV;;YAGU;EACV;EACA,UAAU;;YAGA;EACV;;YAGU;EACV;EACA;EACA;;YAGU;EACV;EACA,UAAU;EACV;EACA;;YAGU;EACV;EACA;EACA,OAAO;EACP,QAAQ;;YAGE;EACV;;YAGU;EACV;EACA;;YAGU;EACV;EACA,UAAU;;YAGA;EACV;EACA,UAAU;;YAGA;EACV;;YAGU;EACV;EACA,UAAU;;YAGA;EACV;EACA,UAAU;;YAGA;EACV;EACA,OAAO;EACP,WAAW;EACX;EACA,KAAK;EACL;;YAGU;EACV;EACA,OAAO;EACP;;YAGU;EACV;EACA,OAAO;EACP,WAAW;EACX;EACA;EACA;;;;;YAMU,eACR,iBACA,gBACA,oBACA,gBACA,iBACA,iBACA,sBACA,eACA,wBACA,cACA,cACA,oBACA,kBACA,YACA,WACA,qBACA,kBACA,kBACA,oBACA,cACA,gBACA,gBACA,qBACA,oBACA,YACA,qBACA,WACA,eACA,iBACA,kBACA,iBACA,wBACA,WACA;;;;YASQ,gBAAgB,eAAe,OAAO,eAAe;;;;YAKrD,OAAO,iBACjB,SAAS,kBACT,aAAa,cACb,OAAO,eACJ;;;;YAKO,cACV,KAAK,eAAe,gBACpB,OAAO;;;;YAMG,KAAK,eAAe;;EAE9B,SACE,gBACA,OAAO,YACP,gCACG;;EAGL;;EAGA,QAAQ,OAAO,KAAK;;;;;EAMpB,wBAAwB,gBAAgB,OAAO;;;;;EAM/C;;;;;;;EAQA,SAAS;;;;;EAMT,WACE,MAAM,cACN,QAAQ,YACR,OAAO;;;;;YAOC;GACT,cAAc;;;;;YAUL,mBAAmB;GAC5B,cAAc;;;;;YAUL;;AAEV;;AAEA,MAAM;;AAEN,gBAAgB;;AAEhB,OAAO;;;;;YAOG;;;;EAIV;;;;EAKA;;;;EAKA;;;;EAKA;;;;EAKA;;;;EAKA;;;;EAKA,aAAa;;;;EAKb,UAAU;;;;EAKV;;;;EAKA;;;;;;YAOU,eAAe,WAAW;;EAEpC,aAAa,mBAAmB;;EAEhC,sBAAsB;;EAEtB,aAAa,eAAe,KAAK,SAAS;;EAE1C,WAAW,eAAe,YAAY"}

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

@@ -1,5 +1,4 @@
 import { NestedParser, ParseState, ParserResult, Rule } from "./types.js";
-//#region src/markdown/utils.d.ts
 /**
  * Trim trailing whitespace from a string.
  */
@@ -141,5 +140,5 @@ export declare const renderNothing: () => null;
  */
 export type BlockSyntaxProbe = RegExp | ((input: string) => boolean);
 export declare const some: (probes: BlockSyntaxProbe[], input: string) => boolean;
-//#endregion
+export {};
 //# sourceMappingURL=utils.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","names":[],"sources":["../../../src/markdown/utils.ts"],"mappings":";;;;;qBAwBa,UAAO;;;;qBAWP,aAAU,aAAe;;;;qBAOzB,UAAO;;;;qBAiBP,iBAAkB,8BAA4B,WAAa,MAAI;;;;qBAQ/D,QAAE;;;;qBAKF,MAAG,UAAY,cAAc;qBAyC7B,UAAO;;;;;qBA4BP,YAAS;;;;qBAqCT,sBAAmB;;;;;;;;;;;qBA+BnB,qCAAkC,cACjC;;;;qBAwCD,wBAAqB;KAY7B,cAAc,aAAa;;;;qBAKnB,sBAAmB,wBAA0B;;;;qBA+D7C,gCAA6B,aAC7B,aACA,eACE,gBAEX,eACA,aACA;;;;qBA0CS,yBAAsB;;;;qBAqBtB,kBAAe;;;;qBAUf,gBAAa,gBACV,OACP,cAAY,OACZ,YAAU,yBAEhB;;;;qBA4HU,kBAAe,gBACZ,OACP,cAAY,OACZ,eACN;;;;qBAqCU,YAAS,gBACN,OACP,YAAU,SACR,YAAY;;;;qBAmBV,cAAe,cAAc,qBAAmB,IACvD,MACH;EAAM;;;;;qBAQI,cAAW,OAAW,aAAM,gBACZ,OAAS,eAAa;EATlC;;;;;qBAoBJ,oBAAiB,OAAW,aAAM,gBAClB,OAAS,eAAa;EArBlC;;;;;qBAgCJ,aAAU,OACb,YAAM,gBACC,OAAS,eAAa;;;;qBAW1B,gBAAa,IACpB,WAAW,gBAAgB,OAAO,eAAe,+BAAwB,gBAElD,OAAS,eAAa;EAhDlC;;;;;qBA0DJ,cAAW,OACf,cAAY,kBACH,OACT,eACN;;;;qBAeU,oBAAiB,OACrB,cAAY,kBACH,OACT,eACN;;;;qBAgBU,aAAU,OACd,cAAY,kBACH,QACT,eACN;;;;qBAoBU,qBAAkB,SACpB,kBAAgB,OAClB,cAAY,OACZ;EACJ,UAAU;;;;;qBASF,sBAAqB;;;;qBAKrB;;;;;;;;YASD,mBAAmB,WAAW;qBAE7B,OAAI,QAAY,oBAAkB"}
+{"version":3,"file":"utils.d.ts","names":[],"sources":["../../../src/markdown/utils.ts"],"mappings":";;;;qBAwBa,UAAO;;;;qBAWP,aAAU,aAAe;;;;qBAOzB,UAAO;;;;qBAiBP,iBAAkB,8BAA4B,WAAa,MAAI;;;;qBAQ/D,QAAE;;;;qBAKF,MAAG,UAAY,cAAc;qBAyC7B,UAAO;;;;;qBA4BP,YAAS;;;;qBAqCT,sBAAmB;;;;;;;;;;;qBA+BnB,qCAAkC,cACjC;;;;qBAwCD,wBAAqB;KAY7B,cAAc,aAAa;;;;qBAKnB,sBAAmB,wBAA0B;;;;qBA+D7C,gCAA6B,aAC7B,aACA,eACE,gBAEX,eACA,aACA;;;;qBA0CS,yBAAsB;;;;qBAqBtB,kBAAe;;;;qBAUf,gBAAa,gBACV,OACP,cAAY,OACZ,YAAU,yBAEhB;;;;qBA4HU,kBAAe,gBACZ,OACP,cAAY,OACZ,eACN;;;;qBAqCU,YAAS,gBACN,OACP,YAAU,SACR,YAAY;;;;qBAmBV,cAAe,cAAc,qBAAmB,IACvD,MACH;EAAM;;;;;qBAQI,cAAW,OAAW,aAAM,gBACZ,OAAS,eAAa;EATlC;;;;;qBAoBJ,oBAAiB,OAAW,aAAM,gBAClB,OAAS,eAAa;EArBlC;;;;;qBAgCJ,aAAU,OACb,YAAM,gBACC,OAAS,eAAa;;;;qBAW1B,gBAAa,IACpB,WAAW,gBAAgB,OAAO,eAAe,+BAAwB,gBAElD,OAAS,eAAa;EAhDlC;;;;;qBA0DJ,cAAW,OACf,cAAY,kBACH,OACT,eACN;;;;qBAeU,oBAAiB,OACrB,cAAY,kBACH,OACT,eACN;;;;qBAgBU,aAAU,OACd,cAAY,kBACH,QACT,eACN;;;;qBAoBU,qBAAkB,SACpB,kBAAgB,OAClB,cAAY,OACZ;EACJ,UAAU;;;;;qBASF,sBAAqB;;;;qBAKrB;;;;;;;;YASD,mBAAmB,WAAW;qBAE7B,OAAI,QAAY,oBAAkB"}

package/dist/types/messageFormat/ICU.d.ts

@@ -1,9 +1,7 @@
 import { Dictionary } from "@intlayer/types/dictionary";
-//#region src/messageFormat/ICU.d.ts
 export type JsonValue = string | number | boolean | null | JsonValue[] | {
   [key: string]: JsonValue;
 };
 export declare const intlayerToICUFormatter: (message: Dictionary['content']) => JsonValue;
 export declare const icuToIntlayerFormatter: (message: Dictionary['content']) => JsonValue;
-//#endregion
 //# sourceMappingURL=ICU.d.ts.map

package/dist/types/messageFormat/ICU.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ICU.d.ts","names":[],"sources":["../../../src/messageFormat/ICU.ts"],"mappings":";;YAkDY,+CAKR;GACG,cAAc;;qBAmnBR,yBAAsB,SACxB,0BACR;qBAQU,yBAAsB,SACxB,0BACR"}
+{"version":3,"file":"ICU.d.ts","names":[],"sources":["../../../src/messageFormat/ICU.ts"],"mappings":";YAkDY,+CAKR;GACG,cAAc;;qBAmnBR,yBAAsB,SACxB,0BACR;qBAQU,yBAAsB,SACxB,0BACR"}

package/dist/types/messageFormat/i18next.d.ts

@@ -1,7 +1,5 @@
 import { JsonValue } from "./ICU.js";
 import { Dictionary } from "@intlayer/types/dictionary";
-//#region src/messageFormat/i18next.d.ts
 export declare const intlayerToI18nextFormatter: (message: Dictionary['content']) => JsonValue;
 export declare const i18nextToIntlayerFormatter: (message: JsonValue) => Dictionary['content'];
-//#endregion
 //# sourceMappingURL=i18next.d.ts.map

package/dist/types/messageFormat/i18next.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"i18next.d.ts","names":[],"sources":["../../../src/messageFormat/i18next.ts"],"mappings":";;;qBAmlBa,6BAA0B,SAC5B,0BACR;qBAQU,6BAA0B,SAC5B,cACR"}
+{"version":3,"file":"i18next.d.ts","names":[],"sources":["../../../src/messageFormat/i18next.ts"],"mappings":";;qBAmlBa,6BAA0B,SAC5B,0BACR;qBAQU,6BAA0B,SAC5B,cACR"}

package/dist/types/messageFormat/navigatePath.d.ts

@@ -1,4 +1,3 @@
-//#region src/messageFormat/navigatePath.d.ts
 /**
  * Reads a dotted `path` (e.g. `counter.label`) out of a nested content value.
  *
@@ -17,5 +16,4 @@
  * @returns The value found at `path`, or `undefined` when any segment is absent.
  */
 export declare const navigatePath: (contentValue: unknown, path: string, keySeparator?: string | false) => unknown;
-//#endregion
 //# sourceMappingURL=navigatePath.d.ts.map

package/dist/types/messageFormat/navigatePath.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"navigatePath.d.ts","names":[],"sources":["../../../src/messageFormat/navigatePath.ts"],"mappings":";;;;;;;;;;;;;;;;;;qBAiBa,eAAY,uBACF,cACT"}
+{"version":3,"file":"navigatePath.d.ts","names":[],"sources":["../../../src/messageFormat/navigatePath.ts"],"mappings":";;;;;;;;;;;;;;;;;qBAiBa,eAAY,uBACF,cACT"}

package/dist/types/messageFormat/po.d.ts

@@ -1,6 +1,5 @@
 import { JsonValue } from "./ICU.js";
 import { Dictionary } from "@intlayer/types/dictionary";
-//#region src/messageFormat/po.d.ts
 export type PortableObject = {
   msgid: string;
   msgctxt?: string;
@@ -9,5 +8,4 @@ export type PortableObject = {
 };
 export declare const intlayerToPortableObjectFormatter: (dictionary: Dictionary['content']) => JsonValue;
 export declare const portableObjectToIntlayerFormatter: (message: JsonValue) => Dictionary['content'];
-//#endregion
 //# sourceMappingURL=po.d.ts.map

package/dist/types/messageFormat/po.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"po.d.ts","names":[],"sources":["../../../src/messageFormat/po.ts"],"mappings":";;;YAMY;EACV;EACA;EACA;EACA;;qBAgPW,oCAAiC,YAChC,0BACX;qBAQU,oCAAiC,SACnC,cACR"}
+{"version":3,"file":"po.d.ts","names":[],"sources":["../../../src/messageFormat/po.ts"],"mappings":";;YAMY;EACV;EACA;EACA;EACA;;qBAgPW,oCAAiC,YAChC,0BACX;qBAQU,oCAAiC,SACnC,cACR"}

package/dist/types/messageFormat/resolveMessage.d.ts

@@ -1,5 +1,4 @@
 import { LocalesValues } from "@intlayer/types/module_augmentation";
-//#region src/messageFormat/resolveMessage.d.ts
 /**
  * Runtime counterpart of the `messageFormat` converters.
  *
@@ -101,5 +100,4 @@ export type TaggedMessageToken = string | {
  * `<i18n-t>` slots) to map tags to framework elements.
  */
 export declare const parseTaggedMessage: (message: string) => TaggedMessageToken[];
-//#endregion
 //# sourceMappingURL=resolveMessage.d.ts.map

package/dist/types/messageFormat/resolveMessage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resolveMessage.d.ts","names":[],"sources":["../../../src/messageFormat/resolveMessage.ts"],"mappings":";;;;;;;;;;;;;;;YAyBY;;YAGA,gBAAgB;;;;;;;;;;qBAuFf,qBAAkB,kBACb,SACR,eAAa,SACb;;;;;;;;;qBAwCG,qBAAkB,eAChB,SACL,eAAa,SACb;;;;;;;;;;qBAyIG,6BAA0B,eACxB,SACL,eAAa,SACb;;YAQE,oBAAoB;;;;;YAMpB,mBACV,kBACA,SAAS,eACT,SAAS;;;;;;;;;;;;;;qBAgBE,wBAAqB,WACpB,qBAAmB;;;;;;;;;;;;;;;;;;;;;;qBAmCpB,iBAAc,kBACT,SACR,eAAa,SACb,eAAa,UACZ;;YAKC;EAEN;EAAa,UAAU;;;;;;;;;qBAShB,qBAAkB,oBAAsB"}
+{"version":3,"file":"resolveMessage.d.ts","names":[],"sources":["../../../src/messageFormat/resolveMessage.ts"],"mappings":";;;;;;;;;;;;;;YAyBY;;YAGA,gBAAgB;;;;;;;;;;qBAuFf,qBAAkB,kBACb,SACR,eAAa,SACb;;;;;;;;;qBAwCG,qBAAkB,eAChB,SACL,eAAa,SACb;;;;;;;;;;qBAyIG,6BAA0B,eACxB,SACL,eAAa,SACb;;YAQE,oBAAoB;;;;;YAMpB,mBACV,kBACA,SAAS,eACT,SAAS;;;;;;;;;;;;;;qBAgBE,wBAAqB,WACpB,qBAAmB;;;;;;;;;;;;;;;;;;;;;;qBAmCpB,iBAAc,kBACT,SACR,eAAa,SACb,eAAa,UACZ;;YAKC;EAEN;EAAa,UAAU;;;;;;;;;qBAShB,qBAAkB,oBAAsB"}

package/dist/types/messageFormat/vue-i18n.d.ts

@@ -1,7 +1,5 @@
 import { JsonValue } from "./ICU.js";
 import { Dictionary } from "@intlayer/types/dictionary";
-//#region src/messageFormat/vue-i18n.d.ts
 export declare const intlayerToVueI18nFormatter: (message: Dictionary['content']) => JsonValue;
 export declare const vueI18nToIntlayerFormatter: (message: JsonValue) => Dictionary['content'];
-//#endregion
 //# sourceMappingURL=vue-i18n.d.ts.map

package/dist/types/messageFormat/vue-i18n.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vue-i18n.d.ts","names":[],"sources":["../../../src/messageFormat/vue-i18n.ts"],"mappings":";;;qBAqVa,6BAA0B,SAC5B,0BACR;qBAQU,6BAA0B,SAC5B,cACR"}
+{"version":3,"file":"vue-i18n.d.ts","names":[],"sources":["../../../src/messageFormat/vue-i18n.ts"],"mappings":";;qBAqVa,6BAA0B,SAC5B,0BACR;qBAQU,6BAA0B,SAC5B,cACR"}

package/dist/types/transpiler/condition/condition.d.ts

@@ -1,5 +1,4 @@
 import { CONDITION, TypedNodeModel } from "@intlayer/types/nodeType";
-//#region src/transpiler/condition/condition.d.ts
 export type ConditionContentStates<Content> = Record<`${boolean}`, Content> & {
   fallback?: Content;
 };
@@ -22,6 +21,5 @@ export type ConditionContent<Content = unknown> = TypedNodeModel<typeof CONDITIO
  *
  */
 declare const condition: <Content>(content?: ConditionContentStates<Content>) => ConditionContent<Content>;
-//#endregion
 export { condition as cond };
 //# sourceMappingURL=condition.d.ts.map

package/dist/types/transpiler/condition/condition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"condition.d.ts","names":[],"sources":["../../../../src/transpiler/condition/condition.ts"],"mappings":";;YAGY,uBAAuB,WAAW,qBAAqB;EACjE,WAAW;;YAGD,iBAAiB,qBAAqB,sBACzC,WACP,uBAAuB;;;;;;;;;;;;;;;;;;cAoBnB,YAAa,SAAO,UACd,uBAAuB,aAChC,iBAAiB"}
+{"version":3,"file":"condition.d.ts","names":[],"sources":["../../../../src/transpiler/condition/condition.ts"],"mappings":";YAGY,uBAAuB,WAAW,qBAAqB;EACjE,WAAW;;YAGD,iBAAiB,qBAAqB,sBACzC,WACP,uBAAuB;;;;;;;;;;;;;;;;;;cAoBnB,YAAa,SAAO,UACd,uBAAuB,aAChC,iBAAiB"}

package/dist/types/transpiler/enumeration/enumeration.d.ts

@@ -1,5 +1,4 @@
 import { ENUMERATION, TypedNodeModel } from "@intlayer/types/nodeType";
-//#region src/transpiler/enumeration/enumeration.d.ts
 type Positive = number | `${number}`;
 type Negative = `-${number}`;
 type Numbers = Positive | Negative;
@@ -34,6 +33,5 @@ export type EnumerationContent<Content = unknown> = TypedNodeModel<typeof ENUMER
  *
  */
 declare const enumeration: <Content = unknown>(content?: EnumerationContentState<Content>) => EnumerationContent<Content>;
-//#endregion
 export { enumeration as enu };
 //# sourceMappingURL=enumeration.d.ts.map

package/dist/types/transpiler/enumeration/enumeration.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"enumeration.d.ts","names":[],"sources":["../../../../src/transpiler/enumeration/enumeration.ts"],"mappings":";;KAGK;KACA;KACA,UAAU,WAAW;KAErB,QAAQ;KACR,kBAAkB;KAClB,eAAe;KACf,uBAAuB;KACvB,eAAe;KACf,uBAAuB;YAEhB,cACR,QACA,cACA,WACA,kBACA,WACA;YAEQ,wBAAwB,WAAW,QAC7C,OAAO,aAAa;EAEpB,WAAW;;YAGD,mBAAmB,qBAAqB,sBAC3C,aACP,wBAAwB;;;;;;;;;;;;;;;;;;;;cAsBpB,cAAe,mBAAiB,UAC1B,wBAAwB,aACjC,mBAAmB"}
+{"version":3,"file":"enumeration.d.ts","names":[],"sources":["../../../../src/transpiler/enumeration/enumeration.ts"],"mappings":";KAGK;KACA;KACA,UAAU,WAAW;KAErB,QAAQ;KACR,kBAAkB;KAClB,eAAe;KACf,uBAAuB;KACvB,eAAe;KACf,uBAAuB;YAEhB,cACR,QACA,cACA,WACA,kBACA,WACA;YAEQ,wBAAwB,WAAW,QAC7C,OAAO,aAAa;EAEpB,WAAW;;YAGD,mBAAmB,qBAAqB,sBAC3C,aACP,wBAAwB;;;;;;;;;;;;;;;;;;;;cAsBpB,cAAe,mBAAiB,UAC1B,wBAAwB,aACjC,mBAAmB"}

package/dist/types/transpiler/file/file.d.ts

@@ -1,5 +1,4 @@
 import { FILE, TypedNodeModel } from "@intlayer/types/nodeType";
-//#region src/transpiler/file/file.d.ts
 export type FileContentConstructor<T extends Record<string, any> = {}> = TypedNodeModel<typeof FILE, string, T>;
 export type FileContent = FileContentConstructor<{
   content: string;
@@ -22,5 +21,4 @@ export declare const fileContent: (path: string, callerDir: string, baseDir: str
  * ```
  */
 export declare const file: (path: string) => FileContent;
-//#endregion
 //# sourceMappingURL=file.d.ts.map