@intlayer/core 8.4.0-canary.0 → 8.4.1

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

@@ -1,140 +1,2 @@
-import { NestedParser, ParseState, ParserResult, Rule } from "./types.js";
-
-//#region src/markdown/utils.d.ts
-/**
- * Trim trailing whitespace from a string.
- */
-declare const trimEnd: (str: string) => string;
-/**
- * Check if string starts with prefix.
- */
-declare const startsWith: (str: string, prefix: string) => boolean;
-/**
- * Remove symmetrical leading and trailing quotes.
- */
-declare const unquote: (str: string) => string;
-/**
- * Unescape backslash-escaped characters.
- */
-declare const unescapeString: (rawString: string) => string;
-/**
- * Join class names, filtering out falsy values.
- */
-declare const cx: (...args: any[]) => string;
-/**
- * Get a nested property from an object using dot notation.
- */
-declare const get: (src: any, path: string, fb?: any) => any;
-/**
- * Convert a string to a URL-safe slug.
- * Based on https://stackoverflow.com/a/18123682/1141611
- */
-declare const slugify: (str: string) => string;
-/**
- * Sanitize URLs to prevent XSS attacks.
- * Returns null if the URL is unsafe.
- */
-declare const sanitizer: (input: string) => string | null;
-/**
- * Normalize whitespace in source string.
- */
-declare const normalizeWhitespace: (source: string) => string;
-/**
- * Safely remove a uniform leading indentation from lines, but do NOT touch
- * the content inside fenced code blocks (``` or ~~~).
- */
-declare const trimLeadingWhitespaceOutsideFences: (text: string, whitespace: string) => string;
-/**
- * Normalize HTML attribute key to JSX prop name.
- */
-declare const normalizeAttributeKey: (key: string) => string;
-type StyleTuple = [key: string, value: string];
-/**
- * Parse a CSS style string into an array of [key, value] tuples.
- */
-declare const parseStyleAttribute: (styleString: string) => StyleTuple[];
-/**
- * Convert an attribute value to a Node prop value.
- */
-declare const attributeValueToNodePropValue: (tag: string, key: string, value: string, sanitizeUrlFn: (value: string, tag: string, attribute: string) => string | null) => any;
-/**
- * Parse table alignment from a separator row.
- */
-declare const parseTableAlignCapture: (alignCapture: string) => "left" | "right" | "center";
-/**
- * Parse table alignment row.
- */
-declare const parseTableAlign: (source: string) => ("left" | "right" | "center")[];
-/**
- * Parse a single table row.
- */
-declare const parseTableRow: (source: string, parse: NestedParser, state: ParseState, tableOutput: boolean) => ParserResult[][];
-/**
- * Parse table cells (multiple rows).
- */
-declare const parseTableCells: (source: string, parse: NestedParser, state: ParseState) => ParserResult[][][];
-/**
- * Check if a rule qualifies for the current source and state.
- */
-declare const qualifies: (source: string, state: ParseState, qualify: NonNullable<Rule<any>["_qualify"]>) => boolean;
-/**
- * Marks a matcher function as eligible for being run inside an inline context.
- */
-declare const allowInline: <T extends (...args: any[]) => any>(fn: T) => T & {
-  inline: 1;
-};
-/**
- * Creates a match function for an inline scoped element from a regex.
- */
-declare const inlineRegex: (regex: RegExp) => ((source: string, state: ParseState) => RegExpMatchArray | null) & {
-  inline: 1;
-};
-/**
- * Creates a match function for inline elements except links.
- */
-declare const simpleInlineRegex: (regex: RegExp) => ((source: string, state: ParseState) => RegExpMatchArray | null) & {
-  inline: 1;
-};
-/**
- * Creates a match function for a block scoped element from a regex.
- */
-declare const blockRegex: (regex: RegExp) => (source: string, state: ParseState) => RegExpMatchArray | null;
-/**
- * Creates a match function from a regex, ignoring block/inline scope.
- */
-declare const anyScopeRegex: (fn: RegExp | ((source: string, state: ParseState) => RegExpMatchArray | null)) => ((source: string, state: ParseState) => RegExpMatchArray | null) & {
-  inline: 1;
-};
-/**
- * Parse inline content (including links).
- */
-declare const parseInline: (parse: NestedParser, children: string, state: ParseState) => ParserResult[];
-/**
- * Parse simple inline content (no links).
- */
-declare const parseSimpleInline: (parse: NestedParser, children: string, state: ParseState) => ParserResult[];
-/**
- * Parse block content.
- */
-declare const parseBlock: (parse: NestedParser, children: string, state?: ParseState) => ParserResult[];
-/**
- * Helper to parse capture group 2 as inline content.
- */
-declare const parseCaptureInline: (capture: RegExpMatchArray, parse: NestedParser, state: ParseState) => {
-  children: ParserResult[];
-};
-/**
- * Helper that captures nothing (empty object).
- */
-declare const captureNothing: () => Record<string, never>;
-/**
- * Helper that renders nothing (null).
- */
-declare const renderNothing: () => null;
-/**
- * Check if any regex in a list matches the input.
- */
-declare const some: (regexes: RegExp[], input: string) => boolean;
-//#endregion
-export { 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 };
-//# sourceMappingURL=utils.d.ts.map
+import { A as unquote, C as simpleInlineRegex, D as trimEnd, E as startsWith, O as trimLeadingWhitespaceOutsideFences, S as sanitizer, T as some, _ as parseTableAlignCapture, a as captureNothing, b as qualifies, c as inlineRegex, d as parseBlock, f as parseCaptureInline, g as parseTableAlign, h as parseStyleAttribute, i as blockRegex, k as unescapeString, l as normalizeAttributeKey, m as parseSimpleInline, n as anyScopeRegex, o as cx, p as parseInline, r as attributeValueToNodePropValue, s as get, t as allowInline, u as normalizeWhitespace, v as parseTableCells, w as slugify, x as renderNothing, y as parseTableRow } from "../utils-Dcmgh_80.js";
+export { 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 };

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

@@ -0,0 +1,26 @@
+import { NodeType, TypedNodeModel } from "@intlayer/types/nodeType";
+
+//#region src/transpiler/markdown/markdown.d.ts
+type PropsType = 'number' | 'string' | 'node';
+type ComponentName = string;
+type MarkdownContentConstructor<T extends Record<string, any> = {}, Content = unknown> = TypedNodeModel<NodeType.Markdown, Content, T>;
+type MarkdownContent<Content = unknown, Components extends Record<ComponentName, PropsType> = Record<ComponentName, PropsType>> = MarkdownContentConstructor<{
+  metadata?: Record<string, any>;
+  tags?: string[] | Components;
+}, Content>;
+/**
+ * Function intended to be used to build intlayer dictionaries.
+ *
+ * Allow to pick a content based on a quantity.
+ *
+ * Usage:
+ *
+ * ```ts
+ * markdown('## Hello world!');
+ * ```
+ *
+ */
+declare const markdown: <Components extends Record<string, any> = Record<string, any>, Content = unknown>(content: Content, components?: Components) => MarkdownContent<Content, Components>;
+//#endregion
+export { MarkdownContentConstructor as n, markdown as r, MarkdownContent as t };
+//# sourceMappingURL=markdown-MzfikrI1.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"markdown-MzfikrI1.d.ts","names":[],"sources":["../../src/transpiler/markdown/markdown.ts"],"mappings":";;;KAOK,SAAA;AAAA,KAEA,aAAA;AAAA,KAEO,0BAAA,WACA,MAAA,yCAER,cAAA,CAAe,QAAA,CAAS,QAAA,EAAU,OAAA,EAAS,CAAA;AAAA,KAEnC,eAAA,uCAES,MAAA,CAAO,aAAA,EAAe,SAAA,IAAa,MAAA,CACpD,aAAA,EACA,SAAA,KAEA,0BAAA;EAEA,QAAA,GAAW,MAAA;EACX,IAAA,cAAkB,UAAA;AAAA,GAEpB,OAAA;;;;;AAhBF;;;;;;;;cA4CM,QAAA,sBACe,MAAA,gBAAsB,MAAA,kCAGzC,OAAA,EAAS,OAAA,EACT,UAAA,GAAa,UAAA,KACZ,eAAA,CAAgB,OAAA,EAAS,UAAA"}

package/dist/types/mergeDictionaries-D6WUMQN5.d.ts

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

package/dist/types/mergeDictionaries-D6WUMQN5.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mergeDictionaries-D6WUMQN5.d.ts","names":[],"sources":["../../src/dictionaryManipulator/mergeDictionaries.ts"],"mappings":";;;cAiKa,iBAAA,GAAqB,YAAA,EAAc,UAAA,OAAe,UAAA"}

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

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

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

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

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

@@ -1,4 +1,4 @@
-import { JsonValue, icuToIntlayerFormatter, intlayerToICUFormatter } from "./ICU.js";
-import { i18nextToIntlayerFormatter, intlayerToI18nextFormatter } from "./i18next.js";
-import { intlayerToVueI18nFormatter, vueI18nToIntlayerFormatter } from "./vue-i18n.js";
+import { n as icuToIntlayerFormatter, r as intlayerToICUFormatter, t as JsonValue } from "../ICU-tA3ZHN5U.js";
+import { n as intlayerToI18nextFormatter, t as i18nextToIntlayerFormatter } from "../i18next-qY0AixrB.js";
+import { n as vueI18nToIntlayerFormatter, t as intlayerToVueI18nFormatter } from "../vue-i18n-JtUB7N_m.js";
 export { JsonValue, i18nextToIntlayerFormatter, icuToIntlayerFormatter, intlayerToI18nextFormatter, intlayerToICUFormatter, intlayerToVueI18nFormatter, vueI18nToIntlayerFormatter };

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

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

package/dist/types/normalizeDictionary-coviIGTW.d.ts

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

package/dist/types/normalizeDictionary-coviIGTW.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalizeDictionary-coviIGTW.d.ts","names":[],"sources":["../../src/dictionaryManipulator/normalizeDictionary.ts"],"mappings":";;;;cAOa,mBAAA,GACX,UAAA,EAAY,UAAA,EACZ,aAAA,EAAe,cAAA,KACd,UAAA;AAAA,cAmCU,qBAAA,GACX,YAAA,EAAc,UAAA,IACd,aAAA,EAAe,cAAA,KACd,UAAA"}

package/dist/types/number-C8izkCmU.d.ts

@@ -0,0 +1,16 @@
+import { LocalesValues } from "@intlayer/types/module_augmentation";
+
+//#region src/formatters/number.d.ts
+/**
+ * Formats a numeric value using locale-aware formatting.
+ *
+ * @example
+ * number({ value: 123456.789 }); // "123,456.789"
+ * number({ value: "1000000", locale: Locales.FRENCH }); // "1 000 000"
+ */
+declare const number: (value: string | number, options?: Intl.NumberFormatOptions & {
+  locale?: LocalesValues;
+}) => string;
+//#endregion
+export { number as t };
+//# sourceMappingURL=number-C8izkCmU.d.ts.map

package/dist/types/number-C8izkCmU.d.ts.map

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

package/dist/types/orderDictionaries-SSCMY6qG.d.ts

@@ -0,0 +1,15 @@
+import { Dictionary } from "@intlayer/types/dictionary";
+import * as _intlayer_types_config0 from "@intlayer/types/config";
+
+//#region src/dictionaryManipulator/orderDictionaries.d.ts
+/**
+ * Orders dictionaries based on the dictionary priority strategy.
+ *
+ * @param dictionaries - Array of dictionaries to order
+ * @param priorityStrategy - The priority strategy ('local_first' or 'distant_first')
+ * @returns Ordered array of dictionaries
+ */
+declare const orderDictionaries: (dictionaries: Dictionary[], configuration?: _intlayer_types_config0.IntlayerConfig) => Dictionary[];
+//#endregion
+export { orderDictionaries as t };
+//# sourceMappingURL=orderDictionaries-SSCMY6qG.d.ts.map

package/dist/types/orderDictionaries-SSCMY6qG.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"orderDictionaries-SSCMY6qG.d.ts","names":[],"sources":["../../src/dictionaryManipulator/orderDictionaries.ts"],"mappings":";;;;;;;AAUA;;;;cAAa,iBAAA,GACX,YAAA,EAAc,UAAA,IACd,aAAA,GADwB,uBAAA,CACxB,cAAA,KACC,UAAA"}

package/dist/types/parseYaml-D5gxutvA.d.ts

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

package/dist/types/parseYaml-D5gxutvA.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseYaml-D5gxutvA.d.ts","names":[],"sources":["../../src/utils/parseYaml.ts"],"mappings":";cAAa,SAAA,YAAsB,KAAA,aAAgB,CAAA"}

package/dist/types/parser-BVwR6Tjw.d.ts

@@ -0,0 +1,16 @@
+import { F as ParseState, L as ParserResult, W as Rules } from "./types-C2Om0aEM.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.
+ *
+ * @param rules - An object containing rule type -> {match, order, parse} objects
+ *                (lower order is higher precedence)
+ *
+ * @returns The resulting parse function
+ */
+declare const parserFor: (rules: Rules) => ((source: string, state: ParseState) => ParserResult[]);
+//#endregion
+export { parserFor as t };
+//# sourceMappingURL=parser-BVwR6Tjw.d.ts.map

package/dist/types/parser-BVwR6Tjw.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser-BVwR6Tjw.d.ts","names":[],"sources":["../../src/markdown/parser.ts"],"mappings":";;;;;AAaA;;;;;;;cAAa,SAAA,GACX,KAAA,EAAO,KAAA,OACJ,MAAA,UAAgB,KAAA,EAAO,UAAA,KAAe,YAAA"}

package/dist/types/percentage-BqsvW0Zw.d.ts

@@ -0,0 +1,16 @@
+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%").
+ *
+ * @example
+ * percentage({ value: 0.25 }) // "25%"
+ * percentage({ value: 0.25, minimumFractionDigits: 2 }) // "25.00%"
+ */
+declare const percentage: (value: string | number, options?: Intl.NumberFormatOptions & {
+  locale?: LocalesValues;
+}) => string;
+//#endregion
+export { percentage as t };
+//# sourceMappingURL=percentage-BqsvW0Zw.d.ts.map

package/dist/types/percentage-BqsvW0Zw.d.ts.map

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

package/dist/types/relativeTime-mJaYEq7H.d.ts

@@ -0,0 +1,11 @@
+import { LocalesValues } from "@intlayer/types/module_augmentation";
+
+//#region src/formatters/relativeTime.d.ts
+type RelativeTimeUnit = Intl.RelativeTimeFormatUnit;
+declare const relativeTime: (from: Date | string | number, to?: Date | string | number, options?: Intl.RelativeTimeFormatOptions & {
+  locale?: LocalesValues;
+  unit?: RelativeTimeUnit;
+}) => string;
+//#endregion
+export { relativeTime as t };
+//# sourceMappingURL=relativeTime-mJaYEq7H.d.ts.map

package/dist/types/relativeTime-mJaYEq7H.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"relativeTime-mJaYEq7H.d.ts","names":[],"sources":["../../src/formatters/relativeTime.ts"],"mappings":";;;KAIK,gBAAA,GAAmB,IAAA,CAAK,sBAAA;AAAA,cA6BhB,YAAA,GACX,IAAA,EAAM,IAAA,oBACN,EAAA,GAAI,IAAA,oBACJ,OAAA,GAAU,IAAA,CAAK,yBAAA;EACb,MAAA,GAAS,aAAA;EACT,IAAA,GAAO,gBAAA;AAAA"}

package/dist/types/removeContentNodeByKeyPath-CotCOOsD.d.ts

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

package/dist/types/removeContentNodeByKeyPath-CotCOOsD.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"removeContentNodeByKeyPath-CotCOOsD.d.ts","names":[],"sources":["../../src/dictionaryManipulator/removeContentNodeByKeyPath.ts"],"mappings":";;;;cAIa,0BAAA,GACX,iBAAA,EAAmB,WAAA,EACnB,OAAA,EAAS,OAAA,OACR,WAAA"}

package/dist/types/renameContentNodeByKeyPath-BuyH5gOr.d.ts

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

package/dist/types/renameContentNodeByKeyPath-BuyH5gOr.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"renameContentNodeByKeyPath-BuyH5gOr.d.ts","names":[],"sources":["../../src/dictionaryManipulator/renameContentNodeByKeyPath.ts"],"mappings":";;;;cAIa,0BAAA,GACX,iBAAA,EAAmB,WAAA,EACnB,MAAA,EAAQ,OAAA,SACR,OAAA,EAAS,OAAA,OACR,WAAA"}

package/dist/types/renderer-C06x2Orf.d.ts

@@ -0,0 +1,22 @@
+import { F as ParseState, L as ParserResult, U as RuleOutput, V as RenderRuleHook, W as Rules } from "./types-C2Om0aEM.js";
+
+//#region src/markdown/renderer.d.ts
+/**
+ * Creates a renderer for AST nodes.
+ * Renamed from `reactFor` to be framework-agnostic.
+ *
+ * @param render - The render function to call for each node
+ * @returns A function that renders AST to output
+ */
+declare const renderFor: (render: (ast: ParserResult, render: RuleOutput, state: ParseState) => unknown) => (ast: ParserResult | ParserResult[], state?: ParseState) => any;
+/**
+ * Creates a renderer from rules with optional custom render hook.
+ *
+ * @param rules - The rules object containing _render functions
+ * @param userRender - Optional custom render hook for full control
+ * @returns A render function for AST nodes
+ */
+declare const createRenderer: (rules: Rules, userRender?: RenderRuleHook) => (ast: ParserResult, render: RuleOutput, state: ParseState) => unknown;
+//#endregion
+export { renderFor as n, createRenderer as t };
+//# sourceMappingURL=renderer-C06x2Orf.d.ts.map

package/dist/types/renderer-C06x2Orf.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderer-C06x2Orf.d.ts","names":[],"sources":["../../src/markdown/renderer.ts"],"mappings":";;;;;AAgBA;;;;;cAAa,SAAA,GAET,MAAA,GACE,GAAA,EAAK,YAAA,EACL,MAAA,EAAQ,UAAA,EACR,KAAA,EAAO,UAAA,kBAGV,GAAA,EAAK,YAAA,GAAe,YAAA,IAAgB,KAAA,GAAO,UAAA;;;;;;;;cAiEjC,cAAA,GACV,KAAA,EAAO,KAAA,EAAO,UAAA,GAAa,cAAA,MAC3B,GAAA,EAAK,YAAA,EAAc,MAAA,EAAQ,UAAA,EAAY,KAAA,EAAO,UAAA"}

package/dist/types/rewriteUtils-Bd82NiGR.d.ts

@@ -0,0 +1,34 @@
+import { LocalesValues } from "@intlayer/types/module_augmentation";
+import { Locale } from "@intlayer/types/allLocales";
+import { RewriteObject, RewriteRules, RoutingConfig } from "@intlayer/types/config";
+
+//#region src/localization/rewriteUtils.d.ts
+type LocalizedPathResult = {
+  path: string;
+  isRewritten: boolean;
+};
+/**
+ * Normalizes legacy Record format or extracts specialized rules from RewriteObject.
+ */
+declare const getRewriteRules: (rewrite: RoutingConfig["rewrite"], context?: keyof RewriteObject) => RewriteRules | undefined;
+/**
+ * Given a localized URL (e.g., "/produits/123"), finds the canonical internal path (e.g., "/products/123").
+ * If locale is provided, only check for that locale. Otherwise, check for all locales.
+ */
+declare const getCanonicalPath: (localizedPath: string, locale?: Locale, rewriteRules?: RewriteRules) => string;
+/**
+ * Given a canonical path (e.g., "/products/123"), finds the localized URL pattern (e.g., "/produits/123").
+ */
+declare const getLocalizedPath: (canonicalPath: string, locale: LocalesValues, rewriteRules?: RewriteRules) => LocalizedPathResult;
+/**
+ * Returns the internal path for a given canonical path and locale.
+ * Ensures the locale prefix is present exactly once.
+ */
+declare const getInternalPath: (canonicalPath: string, locale: Locale) => string;
+/**
+ * Given a current pathname and locale, returns the pretty localized path if a rewrite rule exists and the path is not already localized.
+ */
+declare const getRewritePath: (pathname: string, locale: Locale, rewrite?: RoutingConfig["rewrite"]) => string | undefined;
+//#endregion
+export { getRewritePath as a, getLocalizedPath as i, getCanonicalPath as n, getRewriteRules as o, getInternalPath as r, LocalizedPathResult as t };
+//# sourceMappingURL=rewriteUtils-Bd82NiGR.d.ts.map

package/dist/types/rewriteUtils-Bd82NiGR.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rewriteUtils-Bd82NiGR.d.ts","names":[],"sources":["../../src/localization/rewriteUtils.ts"],"mappings":";;;;;KAIY,mBAAA;EACV,IAAA;EACA,WAAA;AAAA;;;;cAMW,eAAA,GACX,OAAA,EAAS,aAAA,aACT,OAAA,SAAe,aAAA,KACd,YAAA;;;;;cA2EU,gBAAA,GACX,aAAA,UACA,MAAA,GAAS,MAAA,EACT,YAAA,GAAe,YAAA;;;;cA2BJ,gBAAA,GACX,aAAA,UACA,MAAA,EAAQ,aAAA,EACR,YAAA,GAAe,YAAA,KACd,mBAAA;;;;;cA4BU,eAAA,GACX,aAAA,UACA,MAAA,EAAQ,MAAA;AAhEV;;;AAAA,cAmFa,cAAA,GACX,QAAA,UACA,MAAA,EAAQ,MAAA,EACR,OAAA,GAAU,aAAA"}

package/dist/types/splitAndJoinInsertion-bkuLa7o2.d.ts

@@ -0,0 +1,25 @@
+//#region src/interpreter/splitAndJoinInsertion.d.ts
+/**
+ * Core logic for splitting insertion strings and joining with values.
+ * Returns an array of parts that can be wrapped by framework-specific Fragment implementations.
+ *
+ * @param template - The template string with {{ placeholder }} syntax
+ * @param values - Map of placeholder names to their replacement values
+ * @returns Object with `isSimple` flag and `parts` array
+ *
+ * @example
+ * ```ts
+ * const result = splitInsertionTemplate('Hello {{ name }}!', { name: 'World' });
+ * // { isSimple: true, parts: 'Hello World!' }
+ *
+ * const result = splitInsertionTemplate('Hello {{ name }}!', { name: <Component /> });
+ * // { isSimple: false, parts: ['Hello ', <Component />, '!'] }
+ * ```
+ */
+declare const splitInsertionTemplate: <T = any>(template: string, values?: Record<string, T>) => {
+  isSimple: boolean;
+  parts: string | T[];
+};
+//#endregion
+export { splitInsertionTemplate as t };
+//# sourceMappingURL=splitAndJoinInsertion-bkuLa7o2.d.ts.map

package/dist/types/splitAndJoinInsertion-bkuLa7o2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"splitAndJoinInsertion-bkuLa7o2.d.ts","names":[],"sources":["../../src/interpreter/splitAndJoinInsertion.ts"],"mappings":";;AA+BA;;;;;;;;;;;;;;;;cAAa,sBAAA,YACX,QAAA,UACA,MAAA,GAAQ,MAAA,SAAe,CAAA;EACpB,QAAA;EAAmB,KAAA,WAAgB,CAAA;AAAA"}

package/dist/types/translation-CiC-Avxc.d.ts

@@ -0,0 +1,33 @@
+import { StrictModeLocaleMap } from "@intlayer/types/module_augmentation";
+import { NodeType, TypedNodeModel } from "@intlayer/types/nodeType";
+
+//#region src/transpiler/translation/translation.d.ts
+type TranslationContent<Content = unknown, RecordContent extends StrictModeLocaleMap<Content> = StrictModeLocaleMap<Content>> = TypedNodeModel<NodeType.Translation, RecordContent>;
+/**
+ *
+ * Function intended to be used to build intlayer dictionaries.
+ *
+ * Get the content of a translation based on the locale.
+ *
+ * Usage:
+ *
+ * ```ts
+ * translation<string>({
+ *   "en": "Hello",
+ *   "fr": "Bonjour",
+ *   // ... any other available locale
+ * })
+ * ```
+ *
+ * Using TypeScript:
+ * - this function require each locale to be defined if defined in the project configuration.
+ * - If a locale is missing, it will make each existing locale optional and raise an error if the locale is not found.
+ */
+declare const translation: <Content = unknown, ContentRecord extends StrictModeLocaleMap<Content> = StrictModeLocaleMap<Content>>(content: ContentRecord) => TypedNodeModel<NodeType.Translation, ContentRecord, {
+  nodeType: NodeType.Translation | "translation";
+} & {
+  translation: ContentRecord;
+}>;
+//#endregion
+export { translation as n, TranslationContent as t };
+//# sourceMappingURL=translation-CiC-Avxc.d.ts.map

package/dist/types/translation-CiC-Avxc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"translation-CiC-Avxc.d.ts","names":[],"sources":["../../src/transpiler/translation/translation.ts"],"mappings":";;;;KAIY,kBAAA,0CAGR,mBAAA,CAAoB,OAAA,IAAW,mBAAA,CAAoB,OAAA,KACnD,cAAA,CAAe,QAAA,CAAS,WAAA,EAAa,aAAA;AAJzC;;;;;;;;;;;;;;;;;;;;AAAA,cA0BM,WAAA,4CAGF,mBAAA,CAAoB,OAAA,IAAW,mBAAA,CAAoB,OAAA,GAErD,OAAA,EAAS,aAAA,KAAa,cAAA,CAAA,QAAA,CAAA,WAAA,EAAA,aAAA"}

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

@@ -1,28 +1,2 @@
-import { NodeType, TypedNodeModel } from "@intlayer/types/nodeType";
-
-//#region src/transpiler/condition/condition.d.ts
-type ConditionContentStates<Content> = Record<`${boolean}`, Content> & {
-  fallback?: Content;
-};
-type ConditionContent<Content = unknown> = TypedNodeModel<NodeType.Condition, ConditionContentStates<Content>>;
-/**
- * Function intended to be used to build intlayer dictionaries.
- *
- * Allow to pick a content based on a condition.
- *
- * Usage:
- *
- * ```ts
- * cond({
- *  'true': 'The condition is validated',
- *  'false': 'The condition is not validated',
- * });
- * ```
- *
- * The last key provided will be used as the fallback value.
- *
- */
-declare const condition: <Content>(content?: ConditionContentStates<Content>) => TypedNodeModel<NodeType.Condition, ConditionContentStates<Content>, {}>;
-//#endregion
-export { ConditionContent, ConditionContentStates, condition as cond };
-//# sourceMappingURL=condition.d.ts.map
+import { n as ConditionContentStates, r as condition, t as ConditionContent } from "../../condition-BDUtoh_1.js";
+export { ConditionContent, ConditionContentStates, condition as cond };

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

@@ -1,2 +1,2 @@
-import { ConditionContent, ConditionContentStates, cond as condition } from "./condition.js";
+import { n as ConditionContentStates, r as condition, t as ConditionContent } from "../../condition-BDUtoh_1.js";
 export { ConditionContent, ConditionContentStates, condition as cond };

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

@@ -1,40 +1,2 @@
-import { NodeType, TypedNodeModel } from "@intlayer/types/nodeType";
-
-//#region src/transpiler/enumeration/enumeration.d.ts
-type Positive = number | `${number}`;
-type Negative = `-${number}`;
-type Numbers = Positive | Negative;
-type Equal = Numbers;
-type EqualString = `=${Numbers}`;
-type Superior = `>${Numbers}`;
-type SuperiorOrEqual = `>=${Numbers}`;
-type Inferior = `<${Numbers}`;
-type InferiorOrEqual = `<=${Numbers}`;
-type EnterFormat = Equal | EqualString | Superior | SuperiorOrEqual | Inferior | InferiorOrEqual;
-type EnumerationContentState<Content> = Partial<Record<EnterFormat, Content>> & {
-  fallback?: Content;
-};
-type EnumerationContent<Content = unknown> = TypedNodeModel<NodeType.Enumeration, EnumerationContentState<Content>>;
-/**
- * Function intended to be used to build intlayer dictionaries.
- *
- * Allow to pick a content based on a quantity.
- *
- * Usage:
- *
- * ```ts
- * enu({
- *  '<=-2.3': 'You have less than -2.3',
- *  '<1': 'You have less than one',
- *  '2': 'You have two',
- *  '>=3': 'You have three or more',
- * });
- * ```
- *
- * > The order of the keys will define the priority of the content.
- *
- */
-declare const enumeration: <Content = unknown>(content?: EnumerationContentState<Content>) => TypedNodeModel<NodeType.Enumeration, EnumerationContentState<Content>, {}>;
-//#endregion
-export { EnterFormat, EnumerationContent, EnumerationContentState, enumeration as enu };
-//# sourceMappingURL=enumeration.d.ts.map
+import { i as enumeration, n as EnumerationContent, r as EnumerationContentState, t as EnterFormat } from "../../enumeration-CtuvB5Zz.js";
+export { EnterFormat, EnumerationContent, EnumerationContentState, enumeration as enu };

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

@@ -1,2 +1,2 @@
-import { EnterFormat, EnumerationContent, EnumerationContentState, enu as enumeration } from "./enumeration.js";
+import { i as enumeration, n as EnumerationContent, r as EnumerationContentState, t as EnterFormat } from "../../enumeration-CtuvB5Zz.js";
 export { EnterFormat, EnumerationContent, EnumerationContentState, enumeration as enu };