@intlayer/core 8.4.0-canary.0 → 8.4.1

package/dist/types/types-C2Om0aEM.d.ts

@@ -0,0 +1,333 @@
+//#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)
+ */
+type ElementType = string | any;
+/**
+ * Simple HTML tag type - no need to enumerate all tags
+ */
+type HTMLTag = string;
+/**
+ * Runtime interface that framework adapters must implement.
+ * This allows the markdown compiler to work with any framework.
+ */
+type MarkdownRuntime = {
+  /**
+   * Create an element. Signature matches common UI runtimes.
+   * @param type - Tag name or component
+   * @param props - Element properties
+   * @param children - Child elements
+   */
+  createElement: (type: ElementType, props: Record<string, any> | null, ...children: any[]) => unknown;
+  /**
+   * Fragment component for grouping without wrapper DOM node.
+   * Optional - falls back to array if not provided.
+   */
+  Fragment?: any;
+  /**
+   * Normalize props for runtime differences.
+   * Called before createElement with (tag, props).
+   *
+   * Examples:
+   * - { className } -> { className } (no change needed)
+   * - { className } -> { class }
+   * - { htmlFor } -> { for }
+   */
+  normalizeProps?: (tag: HTMLTag, props: Record<string, any>) => Record<string, any>;
+  /**
+   * Adapter-specific helpers can be exposed without coupling core.
+   */
+  [key: string]: unknown;
+};
+/**
+ * Context passed to the compiler containing runtime and configuration.
+ */
+type MarkdownContext<T> = {
+  /** Framework runtime (createElement, etc.) */runtime: MarkdownRuntime; /** Component components for HTML tags */
+  components?: ComponentOverrides<T>; /** Custom URL sanitizer */
+  sanitizer?: (url: string, tag: HTMLTag, attr: string) => string | null; /** Custom slugify function for heading IDs */
+  slugify?: (text: string, defaultFn: (input: string) => string) => string; /** Custom named codes to unicode mappings */
+  namedCodesToUnicode?: Record<string, string>;
+};
+/**
+ * Parser state passed through parsing and rendering.
+ */
+type ParseState = {
+  /** true if the current content is inside anchor link grammar */inAnchor?: boolean; /** true if parsing in an HTML context */
+  inHTML?: boolean; /** true if parsing in an inline context (subset of rules around formatting and links) */
+  inline?: boolean; /** true if in a table */
+  inTable?: boolean; /** use this for the `key` prop */
+  key?: string | number; /** true if in a list */
+  list?: boolean; /** used for lookbacks */
+  prevCapture?: string; /** true if parsing in inline context w/o links */
+  simple?: boolean;
+};
+type BlockQuoteNode = {
+  type: string;
+  alert?: string;
+  children: ParserResult[];
+};
+type BreakLineNode = {
+  type: string;
+};
+type BreakThematicNode = {
+  type: string;
+};
+type CodeBlockNode = {
+  type: string;
+  attrs?: Record<string, any>;
+  lang?: string;
+  text: string;
+};
+type CodeFencedNode = {
+  type: string;
+};
+type CodeInlineNode = {
+  type: string;
+  text: string;
+};
+type FootnoteNode = {
+  type: string;
+};
+type FootnoteReferenceNode = {
+  type: string;
+  target: string;
+  text: string;
+};
+type GFMTaskNode = {
+  type: string;
+  completed: boolean;
+};
+type HeadingNode = {
+  type: string;
+  children: ParserResult[];
+  id: string;
+  level: 1 | 2 | 3 | 4 | 5 | 6;
+};
+type HeadingSetextNode = {
+  type: string;
+};
+type HTMLCommentNode = {
+  type: string;
+};
+type ImageNode = {
+  type: string;
+  alt?: string;
+  target: string;
+  title?: string;
+};
+type LinkNode = {
+  type: string;
+  children: ParserResult[];
+  target: string;
+  title?: string;
+};
+type LinkAngleBraceNode = {
+  type: string;
+};
+type LinkBareURLNode = {
+  type: string;
+};
+type OrderedListNode = {
+  type: string;
+  items: ParserResult[][];
+  ordered: true;
+  start?: number;
+};
+type UnorderedListNode = {
+  type: string;
+  items: ParserResult[][];
+  ordered: false;
+};
+type NewlineNode = {
+  type: string;
+};
+type ParagraphNode = {
+  type: string;
+  children: ParserResult[];
+};
+type ReferenceNode = {
+  type: string;
+};
+type ReferenceImageNode = {
+  type: string;
+  alt?: string;
+  ref: string;
+};
+type ReferenceLinkNode = {
+  type: string;
+  children: ParserResult[];
+  fallbackChildren: string;
+  ref: string;
+};
+type TableNode = {
+  type: string;
+  align: ('left' | 'right' | 'center')[];
+  cells: ParserResult[][][];
+  header: ParserResult[][];
+};
+type TableSeparatorNode = {
+  type: string;
+};
+type TextNode = {
+  type: string;
+  text: string;
+};
+type BoldTextNode = {
+  type: string;
+  children: ParserResult[];
+};
+type ItalicTextNode = {
+  type: string;
+  children: ParserResult[];
+};
+type EscapedTextNode = {
+  type: string;
+};
+type MarkedTextNode = {
+  type: string;
+  children: ParserResult[];
+};
+type StrikethroughTextNode = {
+  type: string;
+  children: ParserResult[];
+};
+type HTMLNode = {
+  type: string;
+  attrs: Record<string, any> | null;
+  children?: ParserResult[];
+  noInnerParse: boolean;
+  tag: HTMLTag;
+  text?: string;
+};
+type HTMLSelfClosingNode = {
+  type: string;
+  attrs: Record<string, any> | null;
+  tag: string;
+};
+type CustomComponentNode = {
+  type: string;
+  attrs: Record<string, any> | null;
+  children?: ParserResult[];
+  noInnerParse: boolean;
+  tag: string;
+  text?: string;
+};
+/**
+ * Union of all possible parser result node types.
+ */
+type ParserResult = BlockQuoteNode | BreakLineNode | BreakThematicNode | CodeBlockNode | CodeFencedNode | CodeInlineNode | CustomComponentNode | FootnoteNode | FootnoteReferenceNode | GFMTaskNode | HeadingNode | HeadingSetextNode | HTMLCommentNode | ImageNode | LinkNode | LinkAngleBraceNode | LinkBareURLNode | OrderedListNode | UnorderedListNode | NewlineNode | ParagraphNode | ReferenceNode | ReferenceImageNode | ReferenceLinkNode | TableNode | TableSeparatorNode | TextNode | BoldTextNode | ItalicTextNode | EscapedTextNode | MarkedTextNode | StrikethroughTextNode | HTMLNode | HTMLSelfClosingNode;
+/**
+ * Nested parser function type.
+ */
+type NestedParser = (input: string, state: ParseState) => ParserResult[];
+/**
+ * Parser function type for a rule.
+ */
+type Parser<ParserOutput> = (capture: RegExpMatchArray, nestedParse: NestedParser, state: ParseState) => ParserOutput;
+/**
+ * Output function type for rendering.
+ */
+type RuleOutput = (ast: ParserResult | ParserResult[], state: ParseState) => unknown;
+/**
+ * Rule definition for parsing and rendering markdown.
+ */
+type Rule<ParserOutput = ParserResult> = {
+  /** Match function - returns regex match or null */_match: (source: string, state: ParseState, prevCapturedString?: string) => RegExpMatchArray | null; /** Priority order for rule application */
+  _order: number; /** Parse function - converts regex capture to AST node */
+  _parse: Parser<Omit<ParserOutput, 'type'>>;
+  /**
+   * Optional fast check that can quickly determine if this rule
+   * should even be attempted.
+   */
+  _qualify?: string[] | ((source: string, state: ParseState) => boolean);
+  /**
+   * Render function - converts AST node to output.
+   * Uses context's runtime.createElement for element creation.
+   */
+  _render?: (node: ParserOutput, render: RuleOutput, state: ParseState) => unknown;
+};
+/**
+ * Map of all rules keyed by rule type.
+ */
+type Rules = {
+  [key: string]: Rule<any>;
+};
+/**
+ * Map of tag overrides.
+ */
+type ComponentOverrides<T> = {
+  [tag: string]: T;
+};
+/**
+ * Render rule hook for custom rendering logic.
+ */
+type RenderRuleHook = (/** Resume normal processing, call this function as a fallback */
+
+next: () => unknown, /** The current AST node */
+
+node: ParserResult, /** Use as renderChildren(node.children) for block nodes */
+
+renderChildren: RuleOutput, /** Contains key which should be supplied to the topmost element */
+
+state: ParseState) => unknown;
+/**
+ * Options for the markdown compiler.
+ * This is the framework-agnostic version of MarkdownRendererOptions.
+ */
+type MarkdownOptions = {
+  /**
+   * Disable automatic link detection for bare URLs.
+   */
+  disableAutoLink?: boolean;
+  /**
+   * Disable parsing of raw HTML in markdown.
+   */
+  disableParsingRawHTML?: boolean;
+  /**
+   * Force ATX-compliant headings (require space after #).
+   */
+  enforceAtxHeadings?: boolean;
+  /**
+   * Force block-level output.
+   */
+  forceBlock?: boolean;
+  /**
+   * Force inline output.
+   */
+  forceInline?: boolean;
+  /**
+   * Force wrapper element even for single children.
+   */
+  forceWrapper?: boolean;
+  /**
+   * Custom render rule hook for full control over rendering.
+   */
+  renderRule?: RenderRuleHook;
+  /**
+   * Wrapper element type, or null for no wrapper.
+   */
+  wrapper?: HTMLTag | null;
+  /**
+   * Whether to preserve frontmatter.
+   */
+  preserveFrontmatter?: boolean;
+  /**
+   * Whether to use tag filter.
+   */
+  tagfilter?: boolean;
+};
+/**
+ * Combined options including context and compiler options.
+ * Used by framework adapters.
+ */
+type CompileOptions<T = any> = MarkdownOptions & {
+  /** Component components */components?: ComponentOverrides<T>; /** Custom named codes to unicode mappings */
+  namedCodesToUnicode?: Record<string, string>; /** Custom sanitizer function */
+  sanitizer?: (value: string, tag: HTMLTag, attribute: string) => string | null; /** Custom slugify function */
+  slugify?: (input: string, defaultFn: (input: string) => string) => string;
+};
+//#endregion
+export { MarkedTextNode as A, ReferenceNode as B, ItalicTextNode as C, MarkdownContext as D, LinkNode as E, ParseState as F, StrikethroughTextNode as G, Rule as H, Parser as I, TextNode as J, TableNode as K, ParserResult as L, NewlineNode as M, OrderedListNode as N, MarkdownOptions as O, ParagraphNode as P, ReferenceImageNode as R, ImageNode as S, LinkBareURLNode as T, RuleOutput as U, RenderRuleHook as V, Rules as W, UnorderedListNode as Y, HTMLNode as _, CodeBlockNode as a, HeadingNode as b, CompileOptions as c, ElementType as d, EscapedTextNode as f, HTMLCommentNode as g, GFMTaskNode as h, BreakThematicNode as i, NestedParser as j, MarkdownRuntime as k, ComponentOverrides as l, FootnoteReferenceNode as m, BoldTextNode as n, CodeFencedNode as o, FootnoteNode as p, TableSeparatorNode as q, BreakLineNode as r, CodeInlineNode as s, BlockQuoteNode as t, CustomComponentNode as u, HTMLSelfClosingNode as v, LinkAngleBraceNode as w, HeadingSetextNode as x, HTMLTag as y, ReferenceLinkNode as z };
+//# sourceMappingURL=types-C2Om0aEM.d.ts.map

package/dist/types/types-C2Om0aEM.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-C2Om0aEM.d.ts","names":[],"sources":["../../src/markdown/types.ts"],"mappings":";;AAQA;;;KAAY,WAAA;;AAKZ;;KAAY,OAAA;;;AAMZ;;KAAY,eAAA;EAQF;;;;;;EADR,aAAA,GACE,IAAA,EAAM,WAAA,EACN,KAAA,EAAO,MAAA,yBACJ,QAAA;EAHL;;;;EAUA,QAAA;EAPK;;;;;;;;;EAkBL,cAAA,IACE,GAAA,EAAK,OAAA,EACL,KAAA,EAAO,MAAA,kBACJ,MAAA;EAKO;AAMd;;EANc,CAAX,GAAA;AAAA;;;;KAMS,eAAA;EAUkB,8CAR5B,OAAA,EAAS,eAAA,EAFiB;EAI1B,UAAA,GAAa,kBAAA,CAAmB,CAAA,GAFvB;EAIT,SAAA,IAAa,GAAA,UAAa,GAAA,EAAK,OAAA,EAAS,IAAA,4BAF3B;EAIb,OAAA,IAAW,IAAA,UAAc,SAAA,GAAY,KAAA,gCAFrC;EAIA,mBAAA,GAAsB,MAAA;AAAA;;;;KAUZ,UAAA;EAZ2B,gEAcrC,QAAA,YAZA;EAcA,MAAA,YAd4B;EAgB5B,MAAA,YANU;EAQV,OAAA;EAEA,GAAA,oBARA;EAUA,IAAA,YANA;EAQA,WAAA,WAJA;EAMA,MAAA;AAAA;AAAA,KAOU,cAAA;EACV,IAAA;EACA,KAAA;EACA,QAAA,EAAU,YAAA;AAAA;AAAA,KAGA,aAAA;EACV,IAAA;AAAA;AAAA,KAGU,iBAAA;EACV,IAAA;AAAA;AAAA,KAGU,aAAA;EACV,IAAA;EACA,KAAA,GAAQ,MAAA;EACR,IAAA;EACA,IAAA;AAAA;AAAA,KAGU,cAAA;EACV,IAAA;AAAA;AAAA,KAGU,cAAA;EACV,IAAA;EACA,IAAA;AAAA;AAAA,KAGU,YAAA;EACV,IAAA;AAAA;AAAA,KAGU,qBAAA;EACV,IAAA;EACA,MAAA;EACA,IAAA;AAAA;AAAA,KAGU,WAAA;EACV,IAAA;EACA,SAAA;AAAA;AAAA,KAGU,WAAA;EACV,IAAA;EACA,QAAA,EAAU,YAAA;EACV,EAAA;EACA,KAAA;AAAA;AAAA,KAGU,iBAAA;EACV,IAAA;AAAA;AAAA,KAGU,eAAA;EACV,IAAA;AAAA;AAAA,KAGU,SAAA;EACV,IAAA;EACA,GAAA;EACA,MAAA;EACA,KAAA;AAAA;AAAA,KAGU,QAAA;EACV,IAAA;EACA,QAAA,EAAU,YAAA;EACV,MAAA;EACA,KAAA;AAAA;AAAA,KAGU,kBAAA;EACV,IAAA;AAAA;AAAA,KAGU,eAAA;EACV,IAAA;AAAA;AAAA,KAGU,eAAA;EACV,IAAA;EACA,KAAA,EAAO,YAAA;EACP,OAAA;EACA,KAAA;AAAA;AAAA,KAGU,iBAAA;EACV,IAAA;EACA,KAAA,EAAO,YAAA;EACP,OAAA;AAAA;AAAA,KAGU,WAAA;EACV,IAAA;AAAA;AAAA,KAGU,aAAA;EACV,IAAA;EACA,QAAA,EAAU,YAAA;AAAA;AAAA,KAGA,aAAA;EACV,IAAA;AAAA;AAAA,KAGU,kBAAA;EACV,IAAA;EACA,GAAA;EACA,GAAA;AAAA;AAAA,KAGU,iBAAA;EACV,IAAA;EACA,QAAA,EAAU,YAAA;EACV,gBAAA;EACA,GAAA;AAAA;AAAA,KAGU,SAAA;EACV,IAAA;EACA,KAAA;EACA,KAAA,EAAO,YAAA;EACP,MAAA,EAAQ,YAAA;AAAA;AAAA,KAGE,kBAAA;EACV,IAAA;AAAA;AAAA,KAGU,QAAA;EACV,IAAA;EACA,IAAA;AAAA;AAAA,KAGU,YAAA;EACV,IAAA;EACA,QAAA,EAAU,YAAA;AAAA;AAAA,KAGA,cAAA;EACV,IAAA;EACA,QAAA,EAAU,YAAA;AAAA;AAAA,KAGA,eAAA;EACV,IAAA;AAAA;AAAA,KAGU,cAAA;EACV,IAAA;EACA,QAAA,EAAU,YAAA;AAAA;AAAA,KAGA,qBAAA;EACV,IAAA;EACA,QAAA,EAAU,YAAA;AAAA;AAAA,KAGA,QAAA;EACV,IAAA;EACA,KAAA,EAAO,MAAA;EACP,QAAA,GAAW,YAAA;EACX,YAAA;EACA,GAAA,EAAK,OAAA;EACL,IAAA;AAAA;AAAA,KAGU,mBAAA;EACV,IAAA;EACA,KAAA,EAAO,MAAA;EACP,GAAA;AAAA;AAAA,KAGU,mBAAA;EACV,IAAA;EACA,KAAA,EAAO,MAAA;EACP,QAAA,GAAW,YAAA;EACX,YAAA;EACA,GAAA;EACA,IAAA;AAAA;;;;KAMU,YAAA,GACR,cAAA,GACA,aAAA,GACA,iBAAA,GACA,aAAA,GACA,cAAA,GACA,cAAA,GACA,mBAAA,GACA,YAAA,GACA,qBAAA,GACA,WAAA,GACA,WAAA,GACA,iBAAA,GACA,eAAA,GACA,SAAA,GACA,QAAA,GACA,kBAAA,GACA,eAAA,GACA,eAAA,GACA,iBAAA,GACA,WAAA,GACA,aAAA,GACA,aAAA,GACA,kBAAA,GACA,iBAAA,GACA,SAAA,GACA,kBAAA,GACA,QAAA,GACA,YAAA,GACA,cAAA,GACA,eAAA,GACA,cAAA,GACA,qBAAA,GACA,QAAA,GACA,mBAAA;AAlHJ;;;AAAA,KA2HY,YAAA,IAAgB,KAAA,UAAe,KAAA,EAAO,UAAA,KAAe,YAAA;;;;KAKrD,MAAA,kBACV,OAAA,EAAS,gBAAA,EACT,WAAA,EAAa,YAAA,EACb,KAAA,EAAO,UAAA,KACJ,YAAA;;AA9HL;;KAmIY,UAAA,IACV,GAAA,EAAK,YAAA,GAAe,YAAA,IACpB,KAAA,EAAO,UAAA;;;;KAMG,IAAA,gBAAoB,YAAA;EAxI9B,mDA0IA,MAAA,GACE,MAAA,UACA,KAAA,EAAO,UAAA,EACP,kBAAA,cACG,gBAAA,SA7IF;EAgJH,MAAA,UA7IU;EAgJV,MAAA,EAAQ,MAAA,CAAO,IAAA,CAAK,YAAA;;;;;EAMpB,QAAA,gBAAwB,MAAA,UAAgB,KAAA,EAAO,UAAA;EAnJxC;;;;EAyJP,OAAA,IACE,IAAA,EAAM,YAAA,EACN,MAAA,EAAQ,UAAA,EACR,KAAA,EAAO,UAAA;AAAA;;;;KAOC,KAAA;EAAA,CACT,GAAA,WAAc,IAAA;AAAA;;;;KAUL,kBAAA;EAAA,CACT,GAAA,WAAc,CAAA;AAAA;;;;KAUL,cAAA;;AAEV,IAAA,iBAzKF;;AA2KE,IAAA,EAAM,YAAA;;AAEN,cAAA,EAAgB,UAAA;;AAEhB,KAAA,EAAO,UAAA;;;;AA1KT;KAiLY,eAAA;;;;EAIV,eAAA;EAjLwB;;;EAsLxB,qBAAA;EApLA;;;EAyLA,kBAAA;EAtLU;;;EA2LV,UAAA;EA1LA;;;EA+LA,WAAA;EA9LsB;AAGxB;;EAgME,YAAA;EA9LO;;;EAmMP,UAAA,GAAa,cAAA;EAhMD;;;EAqMZ,OAAA,GAAU,OAAA;EAvMV;;;EA4MA,mBAAA;EA1MK;;;EA+ML,SAAA;AAAA;;;;;KAOU,cAAA,YAA0B,eAAA;EAhN7B,2BAkNP,UAAA,GAAa,kBAAA,CAAmB,CAAA,GAjN7B;EAmNH,mBAAA,GAAsB,MAAA,kBAhNZ;EAkNV,SAAA,IAAa,KAAA,UAAe,GAAA,EAAK,OAAA,EAAS,SAAA;EAE1C,OAAA,IAAW,KAAA,UAAe,SAAA,GAAY,KAAA;AAAA"}

package/dist/types/units-CouGqa8j.d.ts

@@ -0,0 +1,16 @@
+import { LocalesValues } from "@intlayer/types/module_augmentation";
+
+//#region src/formatters/units.d.ts
+/**
+ * Formats a numeric value as a localized unit string.
+ *
+ * @example
+ * units({ value: 5, unit: "kilometer", unitDisplay: "long", locale: "en-GB" })
+ * // "5 kilometers"
+ */
+declare const units: (value: number | string, options?: Intl.NumberFormatOptions & {
+  locale?: LocalesValues;
+}) => string;
+//#endregion
+export { units as t };
+//# sourceMappingURL=units-CouGqa8j.d.ts.map

package/dist/types/units-CouGqa8j.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"units-CouGqa8j.d.ts","names":[],"sources":["../../src/formatters/units.ts"],"mappings":";;;;;AAWA;;;;;cAAa,KAAA,GACX,KAAA,mBACA,OAAA,GAAU,IAAA,CAAK,mBAAA;EAAwB,MAAA,GAAS,aAAA;AAAA"}

package/dist/types/updateNodeChildren-B5Tu1UBZ.d.ts

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

package/dist/types/updateNodeChildren-B5Tu1UBZ.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"updateNodeChildren-B5Tu1UBZ.d.ts","names":[],"sources":["../../src/dictionaryManipulator/updateNodeChildren.ts"],"mappings":";;;cAGa,kBAAA,aACD,WAAA,YACA,WAAA,EAEV,OAAA,EAAS,CAAA,EACT,WAAA,EAAa,CAAA,KACZ,WAAA"}

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

@@ -1,5 +1,2 @@
-//#region src/utils/checkIsURLAbsolute.d.ts
-declare const checkIsURLAbsolute: (url: string) => boolean;
-//#endregion
-export { checkIsURLAbsolute };
-//# sourceMappingURL=checkIsURLAbsolute.d.ts.map
+import { t as checkIsURLAbsolute } from "../checkIsURLAbsolute-CTf3JFU6.js";
+export { checkIsURLAbsolute };

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

@@ -1,11 +1,2 @@
-//#region src/utils/getCookie.d.ts
-/**
- * Retrieves a cookie by name from a cookie string or document.cookie
- * @param name - The name of the cookie to retrieve
- * @param cookieString - Optional cookie string to parse (defaults to document.cookie in browser)
- * @returns The cookie value or undefined if not found
- */
-declare const getCookie: (name: string, cookieString?: string) => string | undefined;
-//#endregion
-export { getCookie };
-//# sourceMappingURL=getCookie.d.ts.map
+import { t as getCookie } from "../getCookie-DPOvVv_h.js";
+export { getCookie };

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

@@ -1,8 +1,8 @@
-import { CachedIntl, bindIntl, createCachedIntl } from "./intl.js";
-import { LocaleStorage, LocaleStorageOptions, getLocaleFromStorage, setLocaleInStorage } from "./localeStorage.js";
-import { checkIsURLAbsolute } from "./checkIsURLAbsolute.js";
-import { getCookie } from "./getCookie.js";
-import { isSameKeyPath } from "./isSameKeyPath.js";
-import { isValidElement } from "./isValidReactElement.js";
-import { parseYaml } from "./parseYaml.js";
-export { CachedIntl, CachedIntl as Intl, LocaleStorage, LocaleStorageOptions, bindIntl, checkIsURLAbsolute, createCachedIntl, getCookie, getLocaleFromStorage, isSameKeyPath, isValidElement, parseYaml, setLocaleInStorage };
+import { i as createCachedIntl, n as WrappedIntl, r as bindIntl, t as CachedIntl } from "../intl-B2Ap8I5x.js";
+import { i as setLocaleInStorage, n as LocaleStorageOptions, r as getLocaleFromStorage, t as LocaleStorage } from "../localeStorage-CZHwY0u3.js";
+import { t as checkIsURLAbsolute } from "../checkIsURLAbsolute-CTf3JFU6.js";
+import { t as getCookie } from "../getCookie-DPOvVv_h.js";
+import { t as isSameKeyPath } from "../isSameKeyPath-CkH8NdJh.js";
+import { t as isValidElement } from "../isValidReactElement-BsoJ01oP.js";
+import { t as parseYaml } from "../parseYaml-D5gxutvA.js";
+export { CachedIntl, CachedIntl as Intl, LocaleStorage, LocaleStorageOptions, WrappedIntl, bindIntl, checkIsURLAbsolute, createCachedIntl, getCookie, getLocaleFromStorage, isSameKeyPath, isValidElement, parseYaml, setLocaleInStorage };

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

@@ -1,33 +1,2 @@
-import { LocalesValues } from "@intlayer/types/module_augmentation";
-
-//#region src/utils/intl.d.ts
-type IntlConstructors = { [K in keyof typeof Intl as (typeof Intl)[K] extends (new (...args: any) => any) ? K : never]: (typeof Intl)[K] };
-type ReplaceLocaleWithLocalesValues<T> = T extends (new (locales: any, options?: infer Options) => infer Instance) ? {
-  new (locales?: LocalesValues, options?: Options): Instance;
-  new (options?: Options & {
-    locale?: LocalesValues;
-  }): Instance;
-} : T extends (new (locales: any) => infer Instance) ? {
-  new (locales?: LocalesValues): Instance;
-  new (options?: {
-    locale?: LocalesValues;
-  }): Instance;
-} : T;
-type WrappedIntl = { [K in keyof typeof Intl]: K extends keyof IntlConstructors ? ReplaceLocaleWithLocalesValues<(typeof Intl)[K]> : (typeof Intl)[K] };
-/**
- * Factory that turns the global `Intl` into a cached clone.
- */
-declare const createCachedIntl: () => WrappedIntl;
-declare const CachedIntl: WrappedIntl;
-/**
- * Creates a proxied Intl object with a preset locale.
- *
- * @example
- * const intl = bindIntl(Locales.FRENCH);
- * new intl.NumberFormat(undefined, { style: 'currency', currency: 'EUR' }).format(10);
- * // Uses 'fr' automatically
- */
-declare const bindIntl: (locale: LocalesValues) => WrappedIntl;
-//#endregion
-export { CachedIntl, CachedIntl as Intl, bindIntl, createCachedIntl };
-//# sourceMappingURL=intl.d.ts.map
+import { i as createCachedIntl, n as WrappedIntl, r as bindIntl, t as CachedIntl } from "../intl-B2Ap8I5x.js";
+export { CachedIntl, CachedIntl as Intl, WrappedIntl, bindIntl, createCachedIntl };

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

@@ -1,7 +1,2 @@
-import { KeyPath } from "@intlayer/types/keyPath";
-
-//#region src/utils/isSameKeyPath.d.ts
-declare const isSameKeyPath: (keyPath1: KeyPath[], keyPath2: KeyPath[]) => boolean;
-//#endregion
-export { isSameKeyPath };
-//# sourceMappingURL=isSameKeyPath.d.ts.map
+import { t as isSameKeyPath } from "../isSameKeyPath-CkH8NdJh.js";
+export { isSameKeyPath };

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

@@ -1,12 +1,2 @@
-//#region src/utils/isValidReactElement.d.ts
-/**
- * Verifies the object is a ReactElement.
- * See https://reactjs.org/docs/react-api.html#isvalidelement
- * @param object
- * @return True if `object` is a ReactElement.
- * @final
- */
-declare const isValidElement: (object: any) => boolean;
-//#endregion
-export { isValidElement };
-//# sourceMappingURL=isValidReactElement.d.ts.map
+import { t as isValidElement } from "../isValidReactElement-BsoJ01oP.js";
+export { isValidElement };

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

@@ -1,108 +1,2 @@
-import { LocalesValues } from "@intlayer/types/module_augmentation";
-import { Locale } from "@intlayer/types/allLocales";
-
-//#region src/utils/localeStorage.d.ts
-type CookieBuildAttributes = {
-  /**
-   * Cookie domain to store the locale information
-   *
-   * Default: undefined
-   *
-   * Define the domain where the cookie is available. Defaults to
-   * the domain of the page where the cookie was created.
-   */
-  domain?: string;
-  /**
-   * Cookie path to store the locale information
-   *
-   * Default: undefined
-   *
-   * Define the path where the cookie is available. Defaults to '/'
-   */
-  path?: string;
-  /**
-   * Cookie secure to store the locale information
-   *
-   * Default: undefined
-   *
-   * A Boolean indicating if the cookie transmission requires a
-   * secure protocol (https). Defaults to false.
-   */
-  secure?: boolean;
-  /**
-   * Cookie httpOnly to store the locale information
-   *
-   * Default: undefined
-   *
-   * The cookie httpOnly where the locale information is stored.
-   */
-  httpOnly?: boolean;
-  /**
-   * Cookie sameSite to store the locale information
-   *
-   * Default: undefined
-   *
-   * Asserts that a cookie must not be sent with cross-origin requests,
-   * providing some protection against cross-site request forgery
-   * attacks (CSRF)
-   */
-  sameSite?: 'strict' | 'lax' | 'none';
-  /**
-   * Cookie expires to store the locale information
-   *
-   * Default: undefined
-   *
-   * Define when the cookie will be removed. Value can be a Number
-   * which will be interpreted as days from time of creation or a
-   * Date instance. If omitted, the cookie becomes a session cookie.
-   */
-  expires?: number | undefined;
-};
-type LocaleStorageOptions = {
-  overwrite?: boolean;
-  isCookieEnabled?: boolean;
-  setCookieStore?: (name: string, value: string, cookie: CookieBuildAttributes) => void;
-  setCookieString?: (name: string, cookie: string) => void;
-  getCookie?: (name: string) => string | undefined | null;
-  setSessionStorage?: (name: string, value: string) => void;
-  getSessionStorage?: (name: string) => string | undefined | null;
-  setLocaleStorage?: (name: string, value: string) => void;
-  getLocaleStorage?: (name: string) => string | undefined | null;
-  getHeader?: (name: string) => string | undefined | null;
-  setHeader?: (name: string, value: string) => void;
-};
-/**
- * Retrieves the locale from various storage mechanisms (cookies, localStorage, sessionStorage, headers).
- * The function checks storage locations in order of priority as defined in the configuration.
- *
- * @returns The locale if found in any storage, or undefined if not found
- */
-declare const getLocaleFromStorage: (options: Pick<LocaleStorageOptions, "getCookie" | "getSessionStorage" | "getLocaleStorage" | "getHeader" | "isCookieEnabled">) => Locale | undefined;
-/**
- * Stores the locale in various storage mechanisms (cookies, localStorage, sessionStorage, headers).
- * The function writes to all configured storage locations according to their attributes.
- * Respects overwrite flags for localStorage and sessionStorage.
- *
- * @param locale - The locale to store
- */
-declare const setLocaleInStorage: (locale: LocalesValues, options?: LocaleStorageOptions) => void;
-/**
- * Utility object to get and set the locale in the storage by considering the configuration
- *
- * @property getLocale - Retrieves the locale from various storage mechanisms (cookies, localStorage, sessionStorage, headers).
- * Retrieves the locale from various storage mechanisms (cookies, localStorage, sessionStorage, headers).
- * The function checks storage locations in order of priority as defined in the configuration.
- *
- * @property setLocale - Stores the locale in various storage mechanisms (cookies, localStorage, sessionStorage, headers).
- * The function writes to all configured storage locations according to their attributes.
- * Respects overwrite flags for localStorage and sessionStorage.
- *
- * @returns The locale if found in any storage, or undefined if not found
- */
-declare const LocaleStorage: (options: LocaleStorageOptions) => {
-  getLocale: () => Locale;
-  setLocale: (locale: LocalesValues) => void;
-};
-//#endregion
-export { LocaleStorage, LocaleStorageOptions, getLocaleFromStorage, setLocaleInStorage };
-//# sourceMappingURL=localeStorage.d.ts.map
+import { i as setLocaleInStorage, n as LocaleStorageOptions, r as getLocaleFromStorage, t as LocaleStorage } from "../localeStorage-CZHwY0u3.js";
+export { LocaleStorage, LocaleStorageOptions, getLocaleFromStorage, setLocaleInStorage };

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

@@ -1,5 +1,2 @@
-//#region src/utils/parseYaml.d.ts
-declare const parseYaml: <T = any>(input: string) => T | null;
-//#endregion
-export { parseYaml };
-//# sourceMappingURL=parseYaml.d.ts.map
+import { t as parseYaml } from "../parseYaml-D5gxutvA.js";
+export { parseYaml };