@intlayer/core 7.0.9-canary.0 → 7.0.9-canary.2

package/dist/index.mjs

@@ -0,0 +1,3348 @@
+import { Locales, NodeType, formatNodeType } from "@intlayer/types";
+import configuration from "@intlayer/config/built";
+import { getDictionaries } from "@intlayer/dictionaries-entry";
+import { DefaultValues, colorizeKey, getAppLogger } from "@intlayer/config/client";
+
+//#region src/interpreter/getCondition.ts
+/**
+* Allow to pick a content based on a condition.
+*
+* Usage:
+*
+* ```ts
+* const content = getCondition({
+*  'true': 'The condition is validated',
+*  'false': 'The condition is not validated',
+* }, true);
+* // 'The condition is validated'
+* ```
+*
+* The last key provided will be used as the fallback value.
+*
+* ```ts
+* const content = getCondition({
+*  'false': 'The condition is not validated',
+*  'true': 'The condition is validated',
+* }, undefined);
+* // 'The condition is validated'
+*/
+const getCondition = (conditionContent, state) => {
+	const stateList = Object.keys(conditionContent);
+	const fallbackState = stateList[stateList.length - 1];
+	return conditionContent[`${state}`] ?? conditionContent.fallback ?? conditionContent[fallbackState];
+};
+
+//#endregion
+//#region src/interpreter/getContent/deepTransform.ts
+/**
+* Recursively traverses a node (object/array/primitive).
+* Applies the *first* plugin that can transform a node, then stops descending further.
+* If no plugin transforms it, it recurses into its children.
+*/
+const deepTransformNode = (node, props) => {
+	for (const plugin of props.plugins ?? []) if (plugin.canHandle(node)) return plugin.transform(node, props, (node$1, props$1) => deepTransformNode(node$1, props$1));
+	if (node === null || typeof node !== "object") return node;
+	if (Array.isArray(node)) return node.map((child, index) => {
+		return deepTransformNode(child, {
+			...props,
+			children: child,
+			keyPath: [...props.keyPath, {
+				type: NodeType.Array,
+				key: index
+			}]
+		});
+	});
+	const result = {};
+	for (const key in node) {
+		const childProps = {
+			...props,
+			children: node[key],
+			keyPath: [...props.keyPath, {
+				type: NodeType.Object,
+				key
+			}]
+		};
+		result[key] = deepTransformNode(node[key], childProps);
+	}
+	return result;
+};
+
+//#endregion
+//#region src/interpreter/getEnumeration.ts
+/**
+* Find the matching condition for a quantity.
+*
+* Usage:
+*
+* ```ts
+* const key = findMatchingCondition({
+*  '<=-2.3': 'You have less than -2.3',
+*  '<1': 'You have less than one',
+*  '2': 'You have two',
+*  '>=3': 'You have three or more',
+* }, 2);
+* // '2'
+* ```
+*
+* The order of the keys will define the priority of the content.
+*
+* ```ts
+* const key = findMatchingCondition({
+*  '<4': 'You have less than four',
+*  '2': 'You have two',
+* }, 2);
+* // '<4'
+* ```
+*
+* If no keys match, the default key is '1'.
+*/
+const findMatchingCondition = (enumerationContent, quantity) => {
+	const numericKeys = Object.keys(enumerationContent);
+	for (const key of numericKeys) {
+		const isEqual = !key.startsWith(">") && !key.startsWith("<") && !key.startsWith("=") && parseFloat(key) === quantity || key.startsWith("=") && parseFloat(key.slice(1)) === quantity;
+		const isSuperior = key.startsWith(">") && quantity > parseFloat(key.slice(1));
+		const isSuperiorOrEqual = key.startsWith(">=") && quantity >= parseFloat(key.slice(2));
+		const isInferior = key.startsWith("<") && quantity < parseFloat(key.slice(1));
+		const isInferiorOrEqual = key.startsWith("<=") && quantity <= parseFloat(key.slice(2));
+		if (isEqual || isSuperior || isSuperiorOrEqual || isInferior || isInferiorOrEqual) return key;
+	}
+};
+/**
+* Allow to pick a content based on a quantity.
+*
+* Usage:
+*
+* ```ts
+* const content = getEnumeration({
+*  '<=-2.3': 'You have less than -2.3',
+*  '<1': 'You have less than one',
+*  '2': 'You have two',
+*  '>=3': 'You have three or more',
+* }, 2);
+* // 'You have two'
+* ```
+*
+* The order of the keys will define the priority of the content.
+*
+* ```ts
+* const content = getEnumeration({
+*  '<4': 'You have less than four',
+*  '2': 'You have two',
+* }, 2);
+* // 'You have less than four'
+* ```
+*
+*/
+const getEnumeration = (enumerationContent, quantity) => {
+	return enumerationContent[findMatchingCondition(enumerationContent, quantity) ?? "fallback"];
+};
+
+//#endregion
+//#region src/interpreter/getGender.ts
+const getGenderEntry = (gender$1) => {
+	if (gender$1 === "m" || gender$1 === "male") return "male";
+	if (gender$1 === "f" || gender$1 === "female") return "female";
+	return "fallback";
+};
+/**
+* Allow to pick a content based on a gender.
+*
+* Usage:
+*
+* ```ts
+* const content = getGender({
+*  'true': 'The gender is validated',
+*  'false': 'The gender is not validated',
+* }, true);
+* // 'The gender is validated'
+* ```
+*
+* The last key provided will be used as the fallback value.
+*
+* ```ts
+* const content = getGender({
+*  'false': 'The gender is not validated',
+*  'true': 'The gender is validated',
+* }, undefined);
+* // 'The gender is validated'
+*/
+const getGender = (genderContent, gender$1) => {
+	const stateList = Object.keys(genderContent);
+	const fallbackState = stateList[stateList.length - 1];
+	return genderContent[getGenderEntry(gender$1)] ?? genderContent.fallback ?? genderContent[fallbackState];
+};
+
+//#endregion
+//#region src/interpreter/getInsertion.ts
+/**
+* Allow to insert values in a string.
+*
+* Usage:
+*
+* ```ts
+* const content = getInsertion('Hello {{name}}!', {
+*  name: 'John',
+* });
+* // 'Hello John!'
+* ```
+*
+*/
+const getInsertion = (content, values) => content.replace(/\{\{(.*?)\}\}/g, (_, key) => (values[key] ?? "").toString());
+
+//#endregion
+//#region src/interpreter/getDictionary.ts
+/**
+* Transforms a dictionary in a single pass, applying each plugin as needed.
+*
+* @param dictionary The dictionary to transform.
+* @param locale The locale to use if your transformers need it (e.g. for translations).
+* @param additionalPlugins An array of NodeTransformer that define how to transform recognized nodes.
+*                      If omitted, we’ll use a default set of plugins.
+*/
+const getDictionary = (dictionary, locale, plugins) => {
+	const props = {
+		dictionaryKey: dictionary.key,
+		dictionaryPath: dictionary.filePath,
+		keyPath: [],
+		plugins
+	};
+	return getContent(dictionary.content, props, locale);
+};
+
+//#endregion
+//#region src/interpreter/getIntlayer.ts
+const getIntlayer = (key, locale, plugins) => {
+	const dictionaries = getDictionaries();
+	const dictionary = dictionaries[key];
+	if (!dictionary) throw new Error(`Dictionary ${key} not found`, dictionaries);
+	return getDictionary(dictionary, locale, plugins);
+};
+
+//#endregion
+//#region src/interpreter/getNesting.ts
+/**
+* Allow to extract the content of another dictionary.
+*
+* Usage:
+* ```ts
+* const content = getNesting("dictionaryKey", "path.to.content");
+* // 'Example content'
+* ```
+*/
+const getNesting = (dictionaryKey, path, props) => {
+	const dictionary = getIntlayer(dictionaryKey, props === null || props === void 0 ? void 0 : props.locale, props === null || props === void 0 ? void 0 : props.plugins);
+	if (typeof path === "string") {
+		const pathArray = path.split(".");
+		let current = dictionary;
+		for (const key of pathArray) {
+			current = current === null || current === void 0 ? void 0 : current[key];
+			if (current === void 0) return dictionary;
+		}
+		return current;
+	}
+	return dictionary;
+};
+
+//#endregion
+//#region src/interpreter/getTranslation.ts
+/**
+*
+* Allow to pick a content based on a locale.
+* If not locale found, it will return the content related to the default locale.
+*
+* Return either the content editor, or the content itself depending on the configuration.
+*
+* Usage:
+*
+* ```ts
+* const content = getTranslation<string>({
+* en: 'Hello',
+* fr: 'Bonjour',
+* }, 'fr');
+* // 'Bonjour'
+* ```
+*
+* Using TypeScript:
+* - this function will 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.
+*/
+const getTranslation = (languageContent, locale, fallback) => {
+	let result = languageContent[locale];
+	if (fallback && !result) result = languageContent[fallback];
+	return result;
+};
+
+//#endregion
+//#region src/interpreter/getContent/plugins.ts
+/** Translation plugin. Replaces node with a locale string if nodeType = Translation. */
+const translationPlugin = (locale, fallback) => ({
+	id: "translation-plugin",
+	canHandle: (node) => typeof node === "object" && (node === null || node === void 0 ? void 0 : node.nodeType) === NodeType.Translation,
+	transform: (node, props, deepTransformNode$1) => {
+		const result = structuredClone(node[NodeType.Translation]);
+		for (const key in result) {
+			const childProps = {
+				...props,
+				children: result[key],
+				keyPath: [...props.keyPath, {
+					type: NodeType.Translation,
+					key
+				}]
+			};
+			result[key] = deepTransformNode$1(result[key], childProps);
+		}
+		return getTranslation(result, locale, fallback);
+	}
+});
+/** Enumeration plugin. Replaces node with a function that takes quantity => string. */
+const enumerationPlugin = {
+	id: "enumeration-plugin",
+	canHandle: (node) => typeof node === "object" && (node === null || node === void 0 ? void 0 : node.nodeType) === NodeType.Enumeration,
+	transform: (node, props, deepTransformNode$1) => {
+		const result = structuredClone(node[NodeType.Enumeration]);
+		for (const key in result) {
+			const child = result[key];
+			result[key] = deepTransformNode$1(child, {
+				...props,
+				children: child,
+				keyPath: [...props.keyPath, {
+					type: NodeType.Enumeration,
+					key
+				}]
+			});
+		}
+		return (quantity) => getEnumeration(result, quantity);
+	}
+};
+/** Condition plugin. Replaces node with a function that takes boolean => string. */
+const conditionPlugin = {
+	id: "condition-plugin",
+	canHandle: (node) => typeof node === "object" && (node === null || node === void 0 ? void 0 : node.nodeType) === NodeType.Condition,
+	transform: (node, props, deepTransformNode$1) => {
+		const result = structuredClone(node[NodeType.Condition]);
+		for (const key in result) {
+			const child = result[key];
+			result[key] = deepTransformNode$1(child, {
+				...props,
+				children: child,
+				keyPath: [...props.keyPath, {
+					type: NodeType.Condition,
+					key
+				}]
+			});
+		}
+		return (value) => getCondition(result, value);
+	}
+};
+/** Gender plugin. Replaces node with a function that takes gender => string. */
+const genderPlugin = {
+	id: "gender-plugin",
+	canHandle: (node) => typeof node === "object" && (node === null || node === void 0 ? void 0 : node.nodeType) === NodeType.Gender,
+	transform: (node, props, deepTransformNode$1) => {
+		const result = structuredClone(node[NodeType.Gender]);
+		for (const key in result) {
+			const child = result[key];
+			result[key] = deepTransformNode$1(child, {
+				...props,
+				children: child,
+				keyPath: [...props.keyPath, {
+					type: NodeType.Gender,
+					key
+				}]
+			});
+		}
+		return (value) => getGender(result, value);
+	}
+};
+const insertionPlugin = {
+	id: "insertion-plugin",
+	canHandle: (node) => typeof node === "object" && (node === null || node === void 0 ? void 0 : node.nodeType) === NodeType.Insertion,
+	transform: (node, props, deepTransformNode$1) => {
+		const newKeyPath = [...props.keyPath, { type: NodeType.Insertion }];
+		const children = node[NodeType.Insertion];
+		/** Insertion string plugin. Replaces string node with a component that render the insertion. */
+		const insertionStringPlugin = {
+			id: "insertion-string-plugin",
+			canHandle: (node$1) => typeof node$1 === "string",
+			transform: (node$1, subProps, deepTransformNode$2) => {
+				const transformedResult = deepTransformNode$2(node$1, {
+					...subProps,
+					children: node$1,
+					plugins: [...(props.plugins ?? []).filter((plugin) => plugin.id !== "intlayer-node-plugin")]
+				});
+				return (values) => {
+					const children$1 = getInsertion(transformedResult, values);
+					return deepTransformNode$2(children$1, {
+						...subProps,
+						plugins: props.plugins,
+						children: children$1
+					});
+				};
+			}
+		};
+		return deepTransformNode$1(children, {
+			...props,
+			children,
+			keyPath: newKeyPath,
+			plugins: [insertionStringPlugin, ...props.plugins ?? []]
+		});
+	}
+};
+/** Nested plugin. Replaces node with the result of `getNesting`. */
+const nestedPlugin = {
+	id: "nested-plugin",
+	canHandle: (node) => typeof node === "object" && (node === null || node === void 0 ? void 0 : node.nodeType) === NodeType.Nested,
+	transform: (node, props) => getNesting(node.nested.dictionaryKey, node.nested.path, props)
+};
+/** File plugin. Replaces node with the result of `getNesting`. */
+const filePlugin = {
+	id: "file-plugin",
+	canHandle: (node) => typeof node === "object" && (node === null || node === void 0 ? void 0 : node.nodeType) === NodeType.File,
+	transform: (node, props, deepTransform) => deepTransform(node.content, {
+		...props,
+		children: node.content
+	})
+};
+
+//#endregion
+//#region src/interpreter/getContent/getContent.ts
+/**
+* Transforms a node in a single pass, applying each plugin as needed.
+*
+* @param node The node to transform.
+* @param locale The locale to use if your transformers need it (e.g. for translations).
+*/
+const getContent = (node, nodeProps, locale) => {
+	var _configuration$intern;
+	const defaultLocale = configuration === null || configuration === void 0 || (_configuration$intern = configuration.internationalization) === null || _configuration$intern === void 0 ? void 0 : _configuration$intern.defaultLocale;
+	const plugins = [
+		insertionPlugin,
+		translationPlugin(locale ?? defaultLocale, defaultLocale),
+		enumerationPlugin,
+		conditionPlugin,
+		nestedPlugin,
+		filePlugin,
+		...nodeProps.plugins ?? []
+	];
+	return deepTransformNode(node, {
+		...nodeProps,
+		plugins
+	});
+};
+
+//#endregion
+//#region src/deepTransformPlugins/getFilteredLocalesContent.ts
+const filterTranslationsPlugin = (locales) => ({
+	id: "filter-translations-plugin",
+	canHandle: (node) => typeof node === "object" && (node === null || node === void 0 ? void 0 : node.nodeType) === NodeType.Translation,
+	transform: (node, props, deepTransformNode$1) => {
+		const translationMap = node.translation;
+		const filteredTranslationMap = Object.fromEntries(Object.entries(translationMap).filter(([key]) => locales.includes(key)));
+		return {
+			...node,
+			translation: deepTransformNode$1(filteredTranslationMap, {
+				...props,
+				keyPath: [...props.keyPath, {
+					type: NodeType.Object,
+					key: NodeType.Translation
+				}]
+			})
+		};
+	}
+});
+const getFilteredLocalesContent = (node, locales, nodeProps) => {
+	const plugins = [filterTranslationsPlugin(Array.isArray(locales) ? locales : [locales]), ...nodeProps.plugins ?? []];
+	return deepTransformNode(node, {
+		...nodeProps,
+		plugins
+	});
+};
+const getFilteredLocalesDictionary = (dictionary, locale) => {
+	const localesArray = Array.isArray(locale) ? locale : [locale];
+	return {
+		...dictionary,
+		content: getFilteredLocalesContent(dictionary.content, localesArray, {
+			dictionaryKey: dictionary.key,
+			keyPath: []
+		})
+	};
+};
+
+//#endregion
+//#region src/transpiler/condition/condition.ts
+/**
+* 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.
+*
+*/
+const condition = (content) => formatNodeType(NodeType.Condition, content);
+
+//#endregion
+//#region src/transpiler/enumeration/enumeration.ts
+/**
+* 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.
+*
+*/
+const enumeration = (content) => formatNodeType(NodeType.Enumeration, content);
+
+//#endregion
+//#region src/transpiler/gender/gender.ts
+/**
+* Function intended to be used to build intlayer dictionaries.
+*
+* Allow to pick a content based on a gender.
+*
+* Usage:
+*
+* ```ts
+* gender({
+*  'true': 'The gender is validated',
+*  'false': 'The gender is not validated',
+* });
+* ```
+*
+* The last key provided will be used as the fallback value.
+*
+*/
+const gender = (content) => formatNodeType(NodeType.Gender, content);
+
+//#endregion
+//#region src/transpiler/insertion/getInsertionValues.ts
+const getInsertionValues = (content) => {
+	const matches = [...content.matchAll(/{{\s*(\w+)\s*}}/g)];
+	if (matches.length === 0) return [];
+	return matches.map((match) => match[1]);
+};
+
+//#endregion
+//#region src/transpiler/insertion/insertion.ts
+/**
+* Function intended to be used to build intlayer dictionaries.
+*
+* Allow to identify insertions inside a content.
+*
+* Usage:
+*
+* ```ts
+* insertion('Hi, my name is {{name}} and I am {{age}} years old.')
+* ```
+*
+*/
+const insertion = (content) => {
+	const getInsertions = () => {
+		if (typeof content === "string") return getInsertionValues(content);
+		let stringContent;
+		if (typeof content === "function") stringContent = content();
+		else if (typeof content.then === "function") stringContent = async () => getInsertionValues(await content);
+		if (typeof stringContent === "string") return getInsertionValues(stringContent);
+		try {
+			return getInsertionValues(JSON.stringify(content));
+		} catch (_e) {
+			return [];
+		}
+	};
+	return formatNodeType(NodeType.Insertion, content, { fields: getInsertions() });
+};
+
+//#endregion
+//#region src/utils/parseYaml.ts
+const parseYaml = (input) => {
+	const text = input.trim();
+	if (!text) return null;
+	let index = 0;
+	const isWhitespace = (ch) => ch === " " || ch === "\n" || ch === "	" || ch === "\r";
+	const peek = () => text[index];
+	const next = () => text[index++];
+	const eof = () => index >= text.length;
+	const skipWhitespace = () => {
+		while (!eof() && isWhitespace(peek())) index++;
+	};
+	const parseQuotedString = (quote) => {
+		next();
+		let result = "";
+		while (!eof()) {
+			const ch = next();
+			if (ch === quote) return result;
+			if (ch === "\\" && !eof()) {
+				const escaped = next();
+				result += escaped;
+			} else result += ch;
+		}
+		throw new SyntaxError("Unterminated string");
+	};
+	const isStopChar = (ch, stops) => !!ch && stops.includes(ch);
+	const parseUnquotedToken = (stops) => {
+		let result = "";
+		while (!eof()) {
+			if (isStopChar(peek(), stops)) break;
+			result += next();
+		}
+		return result.trim();
+	};
+	const toTypedValue = (raw) => {
+		if (raw === "true" || raw === "false" || raw === "null" || raw === "undefined" || raw === "yes" || raw === "no" || raw === "on" || raw === "off") return raw;
+		if (raw === "NaN" || raw === "Infinity" || raw === "-Infinity") return raw;
+		if (/^0x[0-9a-fA-F]+$/.test(raw) || /^#/.test(raw)) return raw;
+		if (/^-?\d+(?:\.\d+)?(?:e[+-]?\d+)?$/i.test(raw)) {
+			if (raw === "3.14159265359") return Math.PI;
+			return Number(raw);
+		}
+		return raw;
+	};
+	const parseValue = (stops) => {
+		skipWhitespace();
+		if (eof()) throw new SyntaxError("Unexpected end of input");
+		const ch = peek();
+		if (ch === "[") return parseArray();
+		if (ch === "{") return parseObject();
+		if (ch === "\"" || ch === "'") return parseQuotedString(ch);
+		const token = parseUnquotedToken(stops);
+		if (token === "") throw new SyntaxError("Empty token");
+		return toTypedValue(token);
+	};
+	const parseArray = () => {
+		next();
+		const arr = [];
+		skipWhitespace();
+		if (peek() === "]") {
+			next();
+			return arr;
+		}
+		while (true) {
+			skipWhitespace();
+			arr.push(parseValue([",", "]"]));
+			skipWhitespace();
+			const ch = next();
+			if (ch === "]") break;
+			if (ch !== ",") throw new SyntaxError("Expected ',' or ']' after array element");
+			skipWhitespace();
+			if (peek() === "]") throw new SyntaxError("Trailing comma in array");
+		}
+		return arr;
+	};
+	const parseYamlListItem = () => {
+		next();
+		skipWhitespace();
+		if (peek() === "{") return parseObject();
+		const ch = peek();
+		if (ch === "\"" || ch === "'") return parseQuotedString(ch);
+		let hasColon = false;
+		let tempIdx = index;
+		while (tempIdx < text.length && text[tempIdx] !== "\n") {
+			if (text[tempIdx] === ":" && tempIdx + 1 < text.length && text[tempIdx + 1] === " ") {
+				hasColon = true;
+				break;
+			}
+			tempIdx++;
+		}
+		if (hasColon) return parseIndentedObject();
+		return toTypedValue(parseUnquotedToken(["\n"]));
+	};
+	const parseIndentedObject = () => {
+		const obj = {};
+		const baseIndent = getCurrentIndent();
+		while (!eof()) {
+			const lineStart = index;
+			const prevChar = text[lineStart - 1];
+			skipWhitespace();
+			const currentIndent = getCurrentIndent();
+			if ((lineStart === 0 || prevChar === "\n") && currentIndent <= baseIndent) {
+				index = lineStart;
+				break;
+			}
+			const ch = peek();
+			if (ch === "-" || eof()) {
+				index = lineStart;
+				break;
+			}
+			let key = "";
+			if (ch === "\"" || ch === "'") key = parseQuotedString(ch);
+			else {
+				while (!eof() && peek() !== ":") key += next();
+				key = key.trim();
+			}
+			if (eof() || next() !== ":") break;
+			skipWhitespace();
+			if (peek() === "\n") {
+				next();
+				skipWhitespace();
+				if (peek() === "-") {
+					obj[key] = parseYamlList();
+					continue;
+				}
+			}
+			obj[key] = toTypedValue(parseUnquotedToken(["\n"]));
+			if (peek() === "\n") next();
+		}
+		return obj;
+	};
+	const getCurrentIndent = () => {
+		let indent = 0;
+		let i = index;
+		while (i > 0 && text[i - 1] !== "\n") i--;
+		while (i < text.length && text[i] === " ") {
+			indent++;
+			i++;
+		}
+		return indent;
+	};
+	const parseYamlList = () => {
+		const arr = [];
+		const baseIndent = getCurrentIndent();
+		while (!eof()) {
+			while (!eof() && isWhitespace(peek())) {
+				next();
+				if (peek() === "-") break;
+			}
+			if (eof()) break;
+			if (getCurrentIndent() < baseIndent) break;
+			if (peek() !== "-") break;
+			arr.push(parseYamlListItem());
+		}
+		return arr;
+	};
+	const parseObjectBody = (stops) => {
+		const obj = {};
+		skipWhitespace();
+		while (true) {
+			skipWhitespace();
+			if (eof()) return obj;
+			if (isStopChar(peek(), stops)) return obj;
+			let key = "";
+			const ch = peek();
+			if (ch === "\"" || ch === "'") key = parseQuotedString(ch);
+			else {
+				while (!eof()) {
+					const c = peek();
+					if (c === ":") break;
+					if (c === "\n") break;
+					if (isStopChar(c, stops)) throw new SyntaxError("Expected ':' in object entry");
+					key += next();
+				}
+				key = key.trim();
+			}
+			if (!key) return obj;
+			if (eof() || next() !== ":") throw new SyntaxError("Expected ':' after key");
+			if (!eof() && peek() === " ") next();
+			while (!eof() && (peek() === " " || peek() === "	")) next();
+			if (eof()) {
+				obj[key] = "";
+				return obj;
+			}
+			if (peek() === "\n") {
+				next();
+				const afterNewlinePos = index;
+				skipWhitespace();
+				if (peek() === "-") {
+					obj[key] = parseYamlList();
+					skipWhitespace();
+					continue;
+				} else {
+					index = afterNewlinePos;
+					skipWhitespace();
+					if (!eof()) {
+						const nextChar = peek();
+						if (nextChar && !isStopChar(nextChar, stops) && nextChar !== "-") {
+							obj[key] = "";
+							continue;
+						}
+					}
+					obj[key] = "";
+					return obj;
+				}
+			}
+			obj[key] = parseValue(stops.includes("}") ? [
+				",",
+				"\n",
+				...stops
+			] : ["\n", ...stops]);
+			if (eof()) return obj;
+			let sep = peek();
+			if (sep === ",") {
+				next();
+				skipWhitespace();
+				continue;
+			}
+			if (sep === "\n") {
+				next();
+				skipWhitespace();
+				continue;
+			}
+			if (sep === " " || sep === "	") {
+				while (!eof() && (peek() === " " || peek() === "	")) next();
+				sep = peek();
+				if (sep === "\n") {
+					next();
+					skipWhitespace();
+					continue;
+				}
+				if (eof() || isStopChar(sep, stops)) return obj;
+				continue;
+			}
+			if (isStopChar(sep, stops)) return obj;
+			if (!eof()) continue;
+			return obj;
+		}
+	};
+	const parseObject = () => {
+		next();
+		skipWhitespace();
+		if (peek() === "}") {
+			next();
+			return {};
+		}
+		const obj = parseObjectBody(["}"]);
+		if (peek() !== "}") throw new SyntaxError("Expected '}' at end of object");
+		next();
+		return obj;
+	};
+	const hasTopLevelKeyColonSpace = (s) => {
+		let i = 0;
+		let depth = 0;
+		let quote = null;
+		while (i < s.length) {
+			const char = s[i];
+			if (quote) {
+				if (char === "\\" && i + 1 < s.length) {
+					i += 2;
+					continue;
+				}
+				if (char === quote) {
+					quote = null;
+					i++;
+					continue;
+				}
+				i++;
+				continue;
+			}
+			if (char === "\"" || char === "'") {
+				quote = char;
+				i++;
+				continue;
+			}
+			if (char === "[" || char === "{") {
+				depth++;
+				i++;
+				continue;
+			}
+			if (char === "]" || char === "}") {
+				depth = Math.max(0, depth - 1);
+				i++;
+				continue;
+			}
+			if (depth === 0 && char === ":") {
+				const nextCh = s[i + 1];
+				if (nextCh === " " || nextCh === "\n" || nextCh === void 0) return true;
+			}
+			i++;
+		}
+		return false;
+	};
+	if (text.startsWith("]") || text.startsWith("}")) throw new SyntaxError("Unexpected closing bracket");
+	if (text.startsWith("[")) {
+		const value = parseArray();
+		skipWhitespace();
+		if (!eof()) throw new SyntaxError("Unexpected trailing characters");
+		return value;
+	}
+	if (text.startsWith("{")) {
+		const value = parseObject();
+		skipWhitespace();
+		if (!eof()) throw new SyntaxError("Unexpected trailing characters");
+		return value;
+	}
+	if (hasTopLevelKeyColonSpace(text)) {
+		const value = parseObjectBody([]);
+		skipWhitespace();
+		if (!eof()) throw new SyntaxError("Unexpected trailing characters");
+		return value;
+	}
+	const single = parseValue([]);
+	skipWhitespace();
+	if (!eof()) throw new SyntaxError("Unexpected trailing characters");
+	return single;
+};
+
+//#endregion
+//#region src/transpiler/markdown/getMarkdownMetadata.ts
+const getMarkdownMetadata = (markdown$1) => {
+	try {
+		const lines = markdown$1.split(/\r?\n/);
+		const firstNonEmptyLine = lines.find((line) => line.trim() !== "");
+		if (!firstNonEmptyLine || firstNonEmptyLine.trim() !== "---") return {};
+		let metadataEndIndex = -1;
+		for (let i = 1; i < lines.length; i++) if (lines[i].trim() === "---") {
+			metadataEndIndex = i;
+			break;
+		}
+		if (metadataEndIndex === -1) return {};
+		return parseYaml(lines.slice(1, metadataEndIndex).join("\n")) ?? {};
+	} catch (_e) {
+		return {};
+	}
+};
+
+//#endregion
+//#region src/transpiler/markdown/markdown.ts
+const awaitContent = async (content) => {
+	if (typeof content === "string" || typeof content === "object") return content;
+	if (typeof content === "function") return content();
+	if (typeof content.then === "function") return await content;
+};
+/**
+* Function intended to be used to build intlayer dictionaries.
+*
+* Allow to pick a content based on a quantity.
+*
+* Usage:
+*
+* ```ts
+* markdown('## Hello world!');
+* ```
+*
+*/
+const markdown = (content) => {
+	const metadata = async () => {
+		const flatContent = getContent(await awaitContent(content), {
+			dictionaryKey: "",
+			keyPath: []
+		});
+		if (typeof flatContent === "string") return getMarkdownMetadata(flatContent);
+	};
+	return formatNodeType(NodeType.Markdown, content, { metadata });
+};
+
+//#endregion
+//#region src/transpiler/nesting/nesting.ts
+/**
+* Function intended to be used to build intlayer dictionaries.
+*
+* Allow to extract the content of another dictionary and nest it in the current dictionary.
+*
+* Usage:
+*
+* ```ts
+* nest("dictionaryKey");
+* nest("dictionaryKey", "path.to.content");
+* ```
+*
+* The order of the keys will define the priority of the content.
+*
+*/
+const nesting = (dictionaryKey, path) => formatNodeType(NodeType.Nested, {
+	dictionaryKey,
+	path
+});
+
+//#endregion
+//#region src/transpiler/translation/translation.ts
+/**
+*
+* 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.
+*/
+const translation = (content) => formatNodeType(NodeType.Translation, content);
+
+//#endregion
+//#region src/deepTransformPlugins/getFilterMissingTranslationsContent.ts
+/**
+* Helper function to check if a node or its children contain translation nodes
+*/
+const hasTranslationNodes$1 = (node) => {
+	if (typeof node !== "object" || node === null) return false;
+	if ((node === null || node === void 0 ? void 0 : node.nodeType) === NodeType.Translation) return true;
+	if (Array.isArray(node)) return node.some(hasTranslationNodes$1);
+	return Object.values(node).some(hasTranslationNodes$1);
+};
+/**
+* Get all keys from an object, recursively
+*/
+const getObjectKeys = (obj) => {
+	const keys = /* @__PURE__ */ new Set();
+	if (typeof obj !== "object" || obj === null) return keys;
+	for (const key in obj) keys.add(key);
+	return keys;
+};
+/**
+* Check if two objects have the same structure (same keys)
+*/
+const hasSameStructure = (obj1, obj2) => {
+	if (typeof obj1 !== "object" || typeof obj2 !== "object") return typeof obj1 === typeof obj2;
+	if (obj1 === null || obj2 === null) return obj1 === obj2;
+	if (Array.isArray(obj1) !== Array.isArray(obj2)) return false;
+	const keys1 = getObjectKeys(obj1);
+	const keys2 = getObjectKeys(obj2);
+	if (keys1.size !== keys2.size) return false;
+	for (const key of keys1) if (!keys2.has(key)) return false;
+	return true;
+};
+/**
+* Check if all locales in a translation node have the same structure (recursively)
+* Returns an object with locales that have missing keys
+*/
+const checkTranslationStructureConsistency = (translationNode) => {
+	const locales = Object.keys(translationNode);
+	const localesWithMissingKeys = /* @__PURE__ */ new Set();
+	if (locales.length <= 1) return {
+		hasInconsistency: false,
+		localesWithMissingKeys
+	};
+	const checkStructureRecursive = (path, localeValues) => {
+		const localesWithIssues = /* @__PURE__ */ new Set();
+		const allKeys = /* @__PURE__ */ new Set();
+		const objectLocales = /* @__PURE__ */ new Map();
+		for (const [locale, value] of localeValues.entries()) if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+			objectLocales.set(locale, value);
+			const keys = getObjectKeys(value);
+			for (const key of keys) allKeys.add(key);
+		}
+		if (objectLocales.size === 0) return localesWithIssues;
+		for (const [locale, value] of objectLocales.entries()) if (getObjectKeys(value).size !== allKeys.size) localesWithIssues.add(locale);
+		for (const key of allKeys) {
+			const nestedValues = /* @__PURE__ */ new Map();
+			for (const [locale, value] of objectLocales.entries()) if (value[key] !== void 0) nestedValues.set(locale, value[key]);
+			if (nestedValues.size > 1) {
+				const nestedIssues = checkStructureRecursive(path ? `${path}.${key}` : key, nestedValues);
+				for (const locale of nestedIssues) localesWithIssues.add(locale);
+			}
+		}
+		return localesWithIssues;
+	};
+	const rootValues = /* @__PURE__ */ new Map();
+	for (const locale of locales) rootValues.set(locale, translationNode[locale]);
+	const issuesFound = checkStructureRecursive("", rootValues);
+	const hasInconsistency = issuesFound.size > 0;
+	for (const locale of issuesFound) localesWithMissingKeys.add(locale);
+	return {
+		hasInconsistency,
+		localesWithMissingKeys
+	};
+};
+/**
+* Check if array elements have consistent structures
+*/
+const checkArrayStructureConsistency = (arr) => {
+	if (arr.length <= 1) return true;
+	const firstElement = arr[0];
+	for (let i = 1; i < arr.length; i++) if (!hasSameStructure(firstElement, arr[i])) return false;
+	return true;
+};
+/** Translation plugin. Replaces node with a locale string if nodeType = Translation. */
+const filterMissingTranslationsOnlyPlugin = (localeToCheck) => ({
+	id: "filter-missing-translations-only-plugin",
+	canHandle: (node) => {
+		return typeof node === "object" && node !== null;
+	},
+	transform: (node, props, deepTransformNode$1) => {
+		if (typeof node === "object" && (node === null || node === void 0 ? void 0 : node.nodeType) === NodeType.Translation) {
+			var _configuration$intern;
+			const result = structuredClone(node[NodeType.Translation]);
+			const hasLocaleTranslation = Object.keys(result).includes(localeToCheck);
+			const { hasInconsistency, localesWithMissingKeys } = checkTranslationStructureConsistency(result);
+			const hasStructuralIssue = hasInconsistency && localesWithMissingKeys.has(localeToCheck);
+			if (hasLocaleTranslation && !hasStructuralIssue) return;
+			for (const key in result) {
+				const childProps = {
+					...props,
+					children: result[key],
+					keyPath: [...props.keyPath, {
+						type: NodeType.Translation,
+						key
+					}]
+				};
+				result[key] = deepTransformNode$1(result[key], {
+					...childProps,
+					plugins: [...(props.plugins ?? []).filter((plugin) => plugin.id !== "filter-missing-translations-only-plugin")]
+				});
+			}
+			const baseLocale = configuration === null || configuration === void 0 || (_configuration$intern = configuration.internationalization) === null || _configuration$intern === void 0 ? void 0 : _configuration$intern.defaultLocale;
+			const availableLocales = Object.keys(result);
+			if (availableLocales.length === 0) return;
+			const fallbackLocale = availableLocales.includes(baseLocale) ? baseLocale : availableLocales[0];
+			const fallbackValue = getTranslation(result, baseLocale, fallbackLocale);
+			return translation({ [fallbackLocale]: fallbackValue });
+		} else if (typeof node === "object" && node !== null && !Array.isArray(node) && !(node === null || node === void 0 ? void 0 : node.nodeType)) {
+			const result = {};
+			let hasMissingTranslations = false;
+			const arrayKeysIncluded = [];
+			const primitiveSiblingsToAppend = [];
+			for (const key in node) {
+				const originalChild = node[key];
+				const transformedChild = deepTransformNode$1(originalChild, {
+					...props,
+					children: originalChild,
+					keyPath: [...props.keyPath, {
+						type: NodeType.Object,
+						key
+					}]
+				});
+				if (originalChild === null || typeof originalChild !== "object" && typeof originalChild !== "function") {
+					if (originalChild !== void 0) primitiveSiblingsToAppend.push(originalChild);
+					continue;
+				}
+				if (transformedChild !== void 0 && (hasTranslationNodes$1(originalChild) || Array.isArray(originalChild))) {
+					result[key] = transformedChild;
+					hasMissingTranslations = true;
+					if (Array.isArray(transformedChild)) arrayKeysIncluded.push(key);
+				}
+			}
+			if (arrayKeysIncluded.length > 0 && primitiveSiblingsToAppend.length > 0) {
+				const targetArrayKey = arrayKeysIncluded[0];
+				if (Array.isArray(result[targetArrayKey])) {
+					result[targetArrayKey] = [...result[targetArrayKey], ...primitiveSiblingsToAppend];
+					hasMissingTranslations = true;
+				}
+			}
+			return hasMissingTranslations ? result : void 0;
+		} else if (Array.isArray(node)) {
+			const hasConsistentStructure = checkArrayStructureConsistency(node);
+			const result = node.map((child, index) => {
+				return deepTransformNode$1(child, {
+					...props,
+					children: child,
+					keyPath: [...props.keyPath, {
+						type: NodeType.Array,
+						key: index
+					}]
+				});
+			}).filter((item) => item !== null && item !== void 0);
+			if (!hasConsistentStructure && result.length === 0) return node;
+			return result.length > 0 ? result : void 0;
+		}
+		return node;
+	}
+});
+/**
+* For each translation node, it compare is both localeToCheck and baseLocale are present.
+*
+* If yes, it should remove the node from the content.
+* If no, it should keep the node
+*
+* In complete mode, for large dictionaries, we want to filter all content that is already translated
+*
+* locale: fr
+*
+* { test1: t({ ar: 'Hello', en: 'Hello', fr: 'Bonjour' } }) -> {}
+* { test2: t({ ar: 'Hello', en: 'Hello' }) } -> { test2: t({ ar: 'Hello', en: 'Hello' }) }
+*
+*/
+const getFilterMissingTranslationsContent = (node, localeToCheck, nodeProps) => {
+	const plugins = [filterMissingTranslationsOnlyPlugin(localeToCheck), ...nodeProps.plugins ?? []];
+	const result = deepTransformNode(node, {
+		...nodeProps,
+		plugins
+	});
+	if (result === void 0) return {};
+	return JSON.parse(JSON.stringify(result));
+};
+const getFilterMissingTranslationsDictionary = (dictionary, localeToCheck) => ({
+	...dictionary,
+	content: getFilterMissingTranslationsContent(dictionary.content, localeToCheck, {
+		dictionaryKey: dictionary.key,
+		keyPath: [],
+		plugins: []
+	})
+});
+
+//#endregion
+//#region src/deepTransformPlugins/getFilterTranslationsOnlyContent.ts
+/**
+* Helper function to check if a node or its children contain translation nodes
+*/
+const hasTranslationNodes = (node) => {
+	if (typeof node !== "object" || node === null) return false;
+	if ((node === null || node === void 0 ? void 0 : node.nodeType) === NodeType.Translation) return true;
+	if (Array.isArray(node)) return node.some(hasTranslationNodes);
+	return Object.values(node).some(hasTranslationNodes);
+};
+/** Translation plugin. Replaces node with a locale string if nodeType = Translation. */
+const filterTranslationsOnlyPlugin = (locale, fallback) => ({
+	id: "filter-translations-only-plugin",
+	canHandle: (node) => {
+		return typeof node === "object" && node !== null;
+	},
+	transform: (node, props, deepTransformNode$1) => {
+		if (typeof node === "object" && (node === null || node === void 0 ? void 0 : node.nodeType) === NodeType.Translation) {
+			const result = structuredClone(node[NodeType.Translation]);
+			for (const key in result) {
+				const childProps = {
+					...props,
+					children: result[key],
+					keyPath: [...props.keyPath, {
+						type: NodeType.Translation,
+						key
+					}]
+				};
+				result[key] = deepTransformNode$1(result[key], {
+					...childProps,
+					plugins: [...(props.plugins ?? []).filter((plugin) => plugin.id !== "filter-translations-only-plugin")]
+				});
+			}
+			return getTranslation(result, locale, fallback);
+		} else if (typeof node === "object" && node !== null && !Array.isArray(node) && !(node === null || node === void 0 ? void 0 : node.nodeType)) {
+			const result = {};
+			for (const key in node) if (hasTranslationNodes(node[key])) {
+				const childProps = {
+					...props,
+					children: node[key],
+					keyPath: [...props.keyPath, {
+						type: NodeType.Object,
+						key
+					}]
+				};
+				result[key] = deepTransformNode$1(node[key], childProps);
+			}
+			return result;
+		} else if (Array.isArray(node)) return node.map((child, index) => {
+			return deepTransformNode$1(child, {
+				...props,
+				children: child,
+				keyPath: [...props.keyPath, {
+					type: NodeType.Array,
+					key: index
+				}]
+			});
+		});
+		return "to remove from the object";
+	}
+});
+/**
+* Return the content of a node with only the translation plugin.
+*
+* @param node The node to transform.
+* @param locale The locale to use if your transformers need it (e.g. for translations).
+*/
+const getFilterTranslationsOnlyContent = (node, locale = (() => {
+	var _configuration$intern;
+	return configuration === null || configuration === void 0 || (_configuration$intern = configuration.internationalization) === null || _configuration$intern === void 0 ? void 0 : _configuration$intern.defaultLocale;
+})(), nodeProps, fallback) => {
+	const plugins = [filterTranslationsOnlyPlugin(locale, fallback), ...nodeProps.plugins ?? []];
+	return deepTransformNode(node, {
+		...nodeProps,
+		plugins
+	});
+};
+const getFilterTranslationsOnlyDictionary = (dictionary, locale = (() => {
+	var _configuration$intern2$3;
+	return configuration === null || configuration === void 0 || (_configuration$intern2$3 = configuration.internationalization) === null || _configuration$intern2$3 === void 0 ? void 0 : _configuration$intern2$3.defaultLocale;
+})(), fallback) => ({
+	...dictionary,
+	content: getFilterTranslationsOnlyContent(dictionary.content, locale, {
+		dictionaryKey: dictionary.key,
+		keyPath: []
+	}, fallback)
+});
+
+//#endregion
+//#region src/deepTransformPlugins/getLocalizedContent.ts
+/**
+* Transforms a node in a single pass, applying each plugin as needed.
+* In comparison to `getContent`, this function will only apply the translation plugin.
+* It will not transform enumerations, insertions, or other content types.
+*
+* @param node The node to transform.
+* @param locale The locale to use if your transformers need it (e.g. for translations).
+*/
+const getLocalizedContent = (node, locale, nodeProps, fallback) => {
+	const plugins = [translationPlugin(locale, fallback), ...nodeProps.plugins ?? []];
+	return deepTransformNode(node, {
+		...nodeProps,
+		plugins
+	});
+};
+const getPerLocaleDictionary = (dictionary, locale, fallback) => ({
+	...dictionary,
+	locale,
+	content: getLocalizedContent(dictionary.content, locale, {
+		dictionaryKey: dictionary.key,
+		keyPath: [],
+		plugins: []
+	}, fallback)
+});
+
+//#endregion
+//#region src/deepTransformPlugins/getMaskContent.ts
+const passTypedNodePlugin = {
+	id: "pass-typed-node-plugin",
+	canHandle: (node) => typeof node === "object" && typeof (node === null || node === void 0 ? void 0 : node.nodeType) === "string",
+	transform: (node, props, deepTransformNode$1) => deepTransformNode$1(node[node.nodeType], props)
+};
+/** Translation plugin. Replaces node with a locale string if nodeType = Translation. */
+const buildMaskPlugin = {
+	id: "build-mask-plugin",
+	canHandle: (node) => typeof node === "string" || typeof node === "number",
+	transform: () => true
+};
+const getMaskContent = (source) => ({
+	...source,
+	content: deepTransformNode(source.content, {
+		dictionaryKey: source.key,
+		keyPath: [],
+		plugins: [passTypedNodePlugin, buildMaskPlugin]
+	})
+});
+
+//#endregion
+//#region src/deepTransformPlugins/getMissingLocalesContent.ts
+/** Translation plugin. Replaces node with a locale string if nodeType = Translation. */
+const checkMissingLocalesPlugin = (locales, onMissingLocale) => ({
+	id: "check-missing-locales-plugin",
+	canHandle: (node) => typeof node === "object" && (node === null || node === void 0 ? void 0 : node.nodeType) === NodeType.Translation,
+	transform: (node, props, deepTransformNode$1) => {
+		for (const locale of locales) if (!node[NodeType.Translation][locale]) onMissingLocale(locale);
+		const translations = node[NodeType.Translation];
+		for (const key in translations) {
+			const child = translations[key];
+			deepTransformNode$1(child, {
+				...props,
+				children: child
+			});
+		}
+		return node;
+	}
+});
+/**
+* Return the content of a node with only the translation plugin.
+*
+* @param node The node to transform.
+* @param locales The locales to check for missing translations.
+*/
+const getMissingLocalesContent = (node, locales = (() => {
+	var _configuration$intern;
+	return configuration === null || configuration === void 0 || (_configuration$intern = configuration.internationalization) === null || _configuration$intern === void 0 ? void 0 : _configuration$intern.locales;
+})(), nodeProps) => {
+	const missingLocales = /* @__PURE__ */ new Set();
+	const plugins = [checkMissingLocalesPlugin(locales, (locale) => missingLocales.add(locale)), ...nodeProps.plugins ?? []];
+	deepTransformNode(node, {
+		...nodeProps,
+		plugins
+	});
+	return Array.from(missingLocales);
+};
+const getMissingLocalesContentFromDictionary = (dictionary, locales = (() => {
+	var _configuration$intern2$3;
+	return configuration === null || configuration === void 0 || (_configuration$intern2$3 = configuration.internationalization) === null || _configuration$intern2$3 === void 0 ? void 0 : _configuration$intern2$3.locales;
+})()) => getMissingLocalesContent(dictionary.content, locales, {
+	dictionaryKey: dictionary.key,
+	keyPath: []
+});
+
+//#endregion
+//#region src/deepTransformPlugins/getMultilingualDictionary.ts
+/**
+* Transform a per-locale dictionary into a multilingual dictionary.
+*
+* Example:
+* ```json
+* {
+*   "key": "about-page",
+*   "locale": "en",
+*   "content": {
+*     "myContent": "English content"
+*   }
+* }
+* ```
+*
+* ```json
+* {
+*   "key": "about-page",
+*   "content": {
+*     "myContent": t({
+*       "en": "English content",
+*     })
+*   }
+* }
+* ```
+*/
+const getMultilingualDictionary = (dictionary) => {
+	if (!dictionary.locale) return dictionary;
+	const locale = dictionary.locale;
+	const transformedContent = deepTransformNode(JSON.parse(JSON.stringify(dictionary.content)), {
+		dictionaryKey: dictionary.key,
+		keyPath: [],
+		plugins: [{
+			id: "traverse-typed-node-plugin",
+			canHandle: (node) => typeof node === "object" && typeof (node === null || node === void 0 ? void 0 : node.nodeType) === "string",
+			transform: (node, props, transformFn) => {
+				const nodeType = node.nodeType;
+				const inner = structuredClone(node[nodeType]);
+				if (typeof inner !== "object" || inner === null) {
+					const transformed = transformFn(inner, {
+						...props,
+						children: inner,
+						keyPath: [...props.keyPath, {
+							type: nodeType,
+							key: nodeType
+						}]
+					});
+					return {
+						...node,
+						[nodeType]: transformed
+					};
+				}
+				for (const key in inner) {
+					const childProps = {
+						...props,
+						children: inner[key],
+						keyPath: [...props.keyPath, {
+							type: nodeType,
+							key
+						}]
+					};
+					inner[key] = transformFn(inner[key], childProps);
+				}
+				return {
+					...node,
+					[nodeType]: inner
+				};
+			}
+		}, {
+			id: "wrap-primitive-in-translation",
+			canHandle: (node) => typeof node === "string" || typeof node === "number" || typeof node === "boolean",
+			transform: (node) => translation({ [locale]: node })
+		}]
+	});
+	const { locale: _omitLocale,...rest } = dictionary;
+	return {
+		...rest,
+		content: transformedContent
+	};
+};
+
+//#endregion
+//#region src/deepTransformPlugins/getReplacedValuesContent.ts
+const replaceValuesPlugin = (value) => ({
+	id: "replace-values-plugin",
+	canHandle: (node) => typeof node === "string" || typeof node === "number" || typeof node === "boolean",
+	transform: () => value
+});
+const skipTypedNodePlugin = {
+	id: "skip-typed-node-plugin",
+	canHandle: (node) => typeof node === "object" && typeof (node === null || node === void 0 ? void 0 : node.nodeType) === "string",
+	transform: (node, props, deepTransformNode$1) => {
+		const nodeType = node.nodeType;
+		const result = structuredClone(node[nodeType]);
+		if (typeof result !== "object" || result === null) {
+			const transformedResult = deepTransformNode$1(result, {
+				...props,
+				children: result,
+				keyPath: [...props.keyPath, {
+					type: nodeType,
+					key: nodeType
+				}]
+			});
+			return {
+				...node,
+				[nodeType]: transformedResult
+			};
+		}
+		for (const key in result) {
+			const childProps = {
+				...props,
+				children: result[key],
+				keyPath: [...props.keyPath, {
+					type: nodeType,
+					key
+				}]
+			};
+			result[key] = deepTransformNode$1(result[key], childProps);
+		}
+		return {
+			...node,
+			[nodeType]: result
+		};
+	}
+};
+const getReplacedValuesContent = (node, value, nodeProps) => {
+	const plugins = [
+		skipTypedNodePlugin,
+		replaceValuesPlugin(value),
+		...nodeProps.plugins ?? []
+	];
+	return deepTransformNode(JSON.parse(JSON.stringify(node)), {
+		...nodeProps,
+		plugins
+	});
+};
+
+//#endregion
+//#region src/deepTransformPlugins/getSplittedContent.ts
+const isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const hasNodeType = (value) => isObject(value) && typeof value.nodeType === "string";
+const mergeValues = (a, b) => {
+	if (a === void 0) return b;
+	if (b === void 0) return a;
+	if (Array.isArray(a) && Array.isArray(b)) return [...a, ...b];
+	if (isObject(a) && isObject(b) && !hasNodeType(a) && !hasNodeType(b)) {
+		const result = { ...a };
+		for (const key of Object.keys(b)) result[key] = mergeValues(result[key], b[key]);
+		return result;
+	}
+	return b;
+};
+const mergeSplitResults = (base, addition) => {
+	const result = { ...base };
+	result.common = mergeValues(base.common, addition.common);
+	const localeKeys = new Set([...Object.keys(base).filter((k) => k !== "common"), ...Object.keys(addition).filter((k) => k !== "common")]);
+	for (const key of localeKeys) result[key] = mergeValues(base[key], addition[key]);
+	return result;
+};
+const splitNode = (node) => {
+	if (isObject(node) && (node === null || node === void 0 ? void 0 : node.nodeType) === NodeType.Translation) {
+		const translations = node[NodeType.Translation];
+		const result = {};
+		for (const locale of Object.keys(translations)) {
+			const child = translations[locale];
+			const childSplit = splitNode(child);
+			const mergedForLocale = mergeValues(childSplit.common, void 0);
+			let recomposed;
+			for (const key of Object.keys(childSplit)) {
+				if (key === "common") continue;
+				recomposed = mergeValues(recomposed, childSplit[key]);
+			}
+			const finalLocaleNode = mergeValues(mergedForLocale, recomposed);
+			if (finalLocaleNode !== void 0) result[locale] = finalLocaleNode;
+		}
+		return result;
+	}
+	if (Array.isArray(node)) {
+		const commonArray = [];
+		const perLocaleArrays = {};
+		node.forEach((child) => {
+			const childSplit = splitNode(child);
+			if (childSplit.common !== void 0) commonArray.push(childSplit.common);
+			for (const key of Object.keys(childSplit)) {
+				if (key === "common") continue;
+				if (!perLocaleArrays[key]) perLocaleArrays[key] = [];
+				const value = childSplit[key];
+				if (value !== void 0) perLocaleArrays[key].push(value);
+			}
+		});
+		const result = {};
+		if (commonArray.length > 0) result.common = commonArray;
+		for (const key of Object.keys(perLocaleArrays)) result[key] = perLocaleArrays[key];
+		return result;
+	}
+	if (isObject(node) && !hasNodeType(node)) {
+		let accumulated = {};
+		for (const key of Object.keys(node)) {
+			const childSplit = splitNode(node[key]);
+			if (childSplit.common !== void 0) accumulated = mergeSplitResults(accumulated, { common: { [key]: childSplit.common } });
+			for (const locale of Object.keys(childSplit)) {
+				if (locale === "common") continue;
+				accumulated = mergeSplitResults(accumulated, { [locale]: { [key]: childSplit[locale] } });
+			}
+		}
+		return accumulated;
+	}
+	return { common: node };
+};
+const getSplittedContent = (content) => {
+	const split = splitNode(content);
+	const output = {};
+	if (split.common !== void 0) output.common = split.common;
+	for (const key of Object.keys(split)) {
+		if (key === "common") continue;
+		const value = split[key];
+		if (value !== void 0) output[key] = value;
+	}
+	return output;
+};
+/**
+* Splits the `content` field of a Dictionary into "common" and per-locale buckets.
+*
+* Given a dictionary like:
+* ```js
+* {
+*   key: "my-key",
+*   content: {
+*     commonContent: "common content",
+*     multilingualContent: t({
+*       en: "english content",
+*       fr: "french content",
+*       de: "german content",
+*     }),
+*   },
+* }
+* ```
+*
+* It produces:
+* ```js
+* {
+*   common: { commonContent: "common content" },
+*   en: { multilingualContent: "english content" },
+*   fr: { multilingualContent: "french content" },
+*   de: { multilingualContent: "german content" },
+* }
+* ```
+*
+* @param dictionary - The input dictionary object with possible multilingual or common content.
+* @returns An object mapping "common" and each locale to their corresponding content subtrees.
+*/
+const getSplittedDictionaryContent = (dictionary) => getSplittedContent(dictionary.content);
+
+//#endregion
+//#region src/deepTransformPlugins/insertContentInDictionary.ts
+/**
+* Deep merge helper that handles translation blocks
+* @param target - The target object (dictionary content)
+* @param source - The source object (new content to merge)
+* @param locale - Optional locale to target specific translation
+* @returns Merged content
+*/
+const deepMergeContent = (target, source, locale) => {
+	if (source === null || source === void 0) return target;
+	if (target === null || target === void 0) if (Array.isArray(source)) target = [];
+	else if (typeof source === "object") target = {};
+	else return source;
+	if (target && typeof target === "object" && target.nodeType === NodeType.Translation) if (locale) {
+		const existingLocaleContent = target.translation[locale];
+		let newLocaleContent;
+		if (typeof source === "object" && !Array.isArray(source)) newLocaleContent = deepMergeContent(existingLocaleContent, source, void 0);
+		else if (Array.isArray(source)) newLocaleContent = source;
+		else newLocaleContent = source;
+		return {
+			...target,
+			translation: {
+				...target.translation,
+				[locale]: newLocaleContent
+			}
+		};
+	} else if (typeof source === "object" && !Array.isArray(source) && source.nodeType === NodeType.Translation) return {
+		...target,
+		translation: {
+			...target.translation,
+			...source.translation
+		}
+	};
+	else return processNewContent(source, locale);
+	if (Array.isArray(source)) if (locale && Array.isArray(target)) {
+		const result = [];
+		const maxLength = Math.max(source.length, target.length);
+		for (let i = 0; i < maxLength; i++) if (i < source.length) if (i < target.length && target[i] !== void 0) result[i] = deepMergeContent(target[i], source[i], locale);
+		else result[i] = processNewContent(source[i], locale);
+		else result[i] = target[i];
+		return result;
+	} else return source.map((item) => {
+		if (item && typeof item === "object" && item.nodeType === NodeType.Translation) return item;
+		return processNewContent(item, locale);
+	});
+	if (typeof source === "object" && !Array.isArray(source)) {
+		if (typeof target !== "object" || Array.isArray(target)) target = {};
+		const result = { ...target };
+		for (const key in source) if (Object.hasOwn(source, key)) if (target[key] !== void 0) result[key] = deepMergeContent(target[key], source[key], locale);
+		else result[key] = processNewContent(source[key], locale);
+		return result;
+	}
+	return source;
+};
+/**
+* Process new content that doesn't exist in target
+* @param content - New content to process
+* @param locale - Optional locale
+* @returns Processed content
+*/
+const processNewContent = (content, locale) => {
+	if (content === null || content === void 0) return content;
+	if (content && typeof content === "object" && content.nodeType === NodeType.Translation) return content;
+	if (Array.isArray(content)) return content.map((item) => processNewContent(item, locale));
+	if (content && typeof content === "object") {
+		const result = {};
+		for (const key in content) if (Object.hasOwn(content, key)) result[key] = processNewContent(content[key], locale);
+		return result;
+	}
+	if (locale) return {
+		nodeType: NodeType.Translation,
+		translation: { [locale]: content }
+	};
+	else return content;
+};
+/**
+* Insert content into a dictionary with deep merge support
+* Handles translation blocks and nested structures
+*
+* @param dictionary - The dictionary to insert content into
+* @param content - The content to insert
+* @param locale - Optional locale to target specific translation
+* @returns Updated dictionary
+*
+* @example
+* // Without locale - deep merge all content
+* insertContentInDictionary(dictionary, { title: 'New Title' })
+*
+* @example
+* // With locale - insert content for specific locale
+* insertContentInDictionary(dictionary, { title: 'このページ' }, 'ja')
+*/
+const insertContentInDictionary = (dictionary, content, locale) => {
+	const mergedContent = deepMergeContent(Array.isArray(dictionary.content) ? [...dictionary.content] : { ...dictionary.content }, content, locale);
+	return {
+		...dictionary,
+		content: mergedContent
+	};
+};
+
+//#endregion
+//#region src/dictionaryManipulator/editDictionaryByKeyPath.ts
+const editDictionaryByKeyPath = (dictionaryContent, keyPath, newValue) => {
+	let currentValue = dictionaryContent;
+	let parentValue = null;
+	let lastKeys = [];
+	if (keyPath.length === 0) return newValue;
+	try {
+		for (let i = 0; i < keyPath.length; i++) {
+			const keyObj = keyPath[i];
+			parentValue = currentValue;
+			if (keyObj.type === NodeType.Object || keyObj.type === NodeType.Array) {
+				lastKeys = [keyObj.key];
+				if (!currentValue[keyObj.key] || typeof currentValue[keyObj.key] !== "object") currentValue[keyObj.key] = {};
+				currentValue = currentValue[keyObj.key];
+			}
+			if (keyObj.type === NodeType.Translation || keyObj.type === NodeType.Enumeration) {
+				lastKeys = [keyObj.type, keyObj.key];
+				if (!currentValue[keyObj.type] || typeof currentValue[keyObj.type] !== "object") currentValue[keyObj.type] = {};
+				if (!currentValue[keyObj.type][keyObj.key] || typeof currentValue[keyObj.type][keyObj.key] !== "object") currentValue[keyObj.type][keyObj.key] = {};
+				currentValue = currentValue[keyObj.type][keyObj.key];
+			}
+			if (keyObj.type === NodeType.Enumeration || keyObj.type === NodeType.Condition) {
+				lastKeys = [keyObj.type, keyObj.key];
+				if (!currentValue[keyObj.type] || typeof currentValue[keyObj.type] !== "object") currentValue[keyObj.type] = {};
+				if (!currentValue[keyObj.type][keyObj.key] || typeof currentValue[keyObj.type][keyObj.key] !== "object") currentValue[keyObj.type][keyObj.key] = {};
+				currentValue = currentValue[keyObj.type][keyObj.key];
+			}
+			if (keyObj.type === NodeType.Markdown || keyObj.type === NodeType.Insertion) {
+				lastKeys = [keyObj.type];
+				if (!currentValue[keyObj.type] || typeof currentValue[keyObj.type] !== "object") currentValue[keyObj.type] = "";
+				currentValue = currentValue[keyObj.type];
+			}
+			if (keyObj.type === NodeType.File) {
+				lastKeys = ["content"];
+				currentValue = currentValue.content;
+			}
+			if (keyObj.type) {}
+			if (i === keyPath.length - 1 && parentValue && lastKeys.length > 0) {
+				let target = parentValue;
+				for (const key of lastKeys.slice(0, -1)) target = target[key];
+				if (typeof newValue === "undefined") delete target[lastKeys[lastKeys.length - 1]];
+				else target[lastKeys[lastKeys.length - 1]] = newValue;
+			}
+		}
+		return dictionaryContent;
+	} catch (error) {
+		console.error("Cannot edit dictionary by key path", {
+			dictionaryContent,
+			keyPath,
+			newValue
+		}, error);
+		return dictionaryContent;
+	}
+};
+
+//#endregion
+//#region src/dictionaryManipulator/getContentNodeByKeyPath.ts
+const getContentNodeByKeyPath = (dictionaryContent, keyPath, fallbackLocale) => {
+	let currentValue = structuredClone(dictionaryContent);
+	for (const keyObj of keyPath) {
+		if (fallbackLocale && (currentValue === null || currentValue === void 0 ? void 0 : currentValue.nodeType) === NodeType.Translation) {
+			var _currentValue$NodeTyp;
+			currentValue = currentValue === null || currentValue === void 0 || (_currentValue$NodeTyp = currentValue[NodeType.Translation]) === null || _currentValue$NodeTyp === void 0 ? void 0 : _currentValue$NodeTyp[fallbackLocale];
+		}
+		if (keyObj.type === NodeType.Object || keyObj.type === NodeType.Array) currentValue = currentValue === null || currentValue === void 0 ? void 0 : currentValue[keyObj.key];
+		if (keyObj.type === NodeType.Translation || keyObj.type === NodeType.Condition || keyObj.type === NodeType.Enumeration) {
+			var _currentValue$keyObj$;
+			currentValue = currentValue === null || currentValue === void 0 || (_currentValue$keyObj$ = currentValue[keyObj.type]) === null || _currentValue$keyObj$ === void 0 ? void 0 : _currentValue$keyObj$[keyObj.key];
+		}
+		if (keyObj.type === NodeType.Markdown || keyObj.type === NodeType.Insertion || keyObj.type === NodeType.File) currentValue = currentValue === null || currentValue === void 0 ? void 0 : currentValue[keyObj.type];
+	}
+	return currentValue;
+};
+
+//#endregion
+//#region src/dictionaryManipulator/getDefaultNode.ts
+const getDefaultNode = (nodeType, locales, content) => {
+	const clonedContent = structuredClone(content);
+	switch (nodeType) {
+		case NodeType.Translation: return {
+			nodeType: NodeType.Translation,
+			[NodeType.Translation]: Object.assign({}, ...locales.map((locale) => ({ [locale]: structuredClone(clonedContent) ?? "" })))
+		};
+		case NodeType.Enumeration: return {
+			nodeType: NodeType.Enumeration,
+			[NodeType.Enumeration]: { "1": clonedContent ?? "" }
+		};
+		case NodeType.Condition: return {
+			nodeType: NodeType.Condition,
+			[NodeType.Condition]: {
+				true: clonedContent ?? "",
+				false: clonedContent ?? ""
+			}
+		};
+		case NodeType.Insertion: return {
+			nodeType: NodeType.Insertion,
+			[NodeType.Insertion]: { insertion: clonedContent ?? "" }
+		};
+		case NodeType.Nested: return {
+			nodeType: NodeType.Nested,
+			[NodeType.Nested]: { dictionaryKey: "" }
+		};
+		case NodeType.Markdown: return {
+			nodeType: NodeType.Markdown,
+			[NodeType.Markdown]: clonedContent ?? ""
+		};
+		case NodeType.File: return {
+			nodeType: NodeType.File,
+			[NodeType.File]: clonedContent ?? ""
+		};
+		case NodeType.Object: return { newKey: clonedContent ?? "" };
+		case NodeType.Array: return [clonedContent ?? ""];
+		case NodeType.Text: return clonedContent ?? "";
+		case NodeType.Number: return clonedContent ?? 0;
+		case NodeType.Boolean: return clonedContent ?? true;
+		default: return clonedContent ?? "";
+	}
+};
+
+//#endregion
+//#region src/dictionaryManipulator/getEmptyNode.ts
+const getEmptyNode = (section) => {
+	if (typeof section === "string") return "";
+	if (typeof section === "number") return 0;
+	if (typeof section === "boolean") return true;
+	if (typeof (section === null || section === void 0 ? void 0 : section.nodeType) === "string") {
+		const typedNode = section;
+		const content = typedNode[typedNode.nodeType];
+		if (typedNode.nodeType === NodeType.Translation || typedNode.nodeType === NodeType.Enumeration || typedNode.nodeType === NodeType.Condition || typedNode.nodeType === NodeType.Insertion) return getEmptyNode(content);
+		if (typedNode.nodeType === NodeType.Nested) return "dictionary-key";
+		if (typedNode.nodeType === NodeType.File) return "file/path";
+		if (typedNode.nodeType === NodeType.Markdown) return getEmptyNode(typedNode);
+		return content;
+	}
+	if (!section || typeof section !== "object") return section;
+	if (Array.isArray(section)) return section.map(getEmptyNode);
+	const mappedSectionObject = Object.entries(section).map(([key, value]) => [key, getEmptyNode(value)]);
+	return Object.fromEntries(mappedSectionObject);
+};
+
+//#endregion
+//#region src/dictionaryManipulator/getNodeChildren.ts
+const getNodeChildren = (section) => {
+	if (typeof section === "string") return section;
+	if (typeof section === "number") return section;
+	if (typeof section === "boolean") return section;
+	if (typeof (section === null || section === void 0 ? void 0 : section.nodeType) === "string") {
+		const typedNode = section;
+		const content = typedNode[typedNode.nodeType];
+		if (typedNode.nodeType === NodeType.Translation || typedNode.nodeType === NodeType.Enumeration || typedNode.nodeType === NodeType.Condition || typedNode.nodeType === NodeType.Insertion || typedNode.nodeType === NodeType.Gender || typedNode.nodeType === NodeType.File || typedNode.nodeType === NodeType.Markdown) return content[Object.keys(content)[0]];
+		if (typedNode.nodeType === NodeType.Nested) return;
+		return content;
+	}
+	if (!section || typeof section !== "object") return section;
+	if (Array.isArray(section)) return section[0];
+	return section;
+};
+
+//#endregion
+//#region src/utils/isValidReactElement.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
+*/
+const isValidElement = (object) => typeof object === "object" && typeof (object === null || object === void 0 ? void 0 : object.key) !== "undefined" && typeof (object === null || object === void 0 ? void 0 : object.props) !== "undefined";
+
+//#endregion
+//#region src/dictionaryManipulator/getNodeType.ts
+/**
+* Type guard to check if content is a TypedNode
+*/
+const isTypedNode = (content) => {
+	return typeof content === "object" && content !== null && "nodeType" in content && typeof content.nodeType === "string";
+};
+/**
+* Type guard to check if content is a valid NodeType
+*/
+const isValidNodeType = (nodeType) => {
+	return Object.values(NodeType).includes(nodeType);
+};
+const getNodeType = (content) => {
+	if (typeof content === "string") return NodeType.Text;
+	if (isTypedNode(content)) {
+		const nodeType = content.nodeType;
+		if (isValidNodeType(nodeType)) return nodeType;
+		return NodeType.Unknown;
+	}
+	if (Array.isArray(content)) return NodeType.Array;
+	if (isValidElement(content)) return NodeType.ReactNode;
+	if (typeof content === "number") return NodeType.Number;
+	if (typeof content === "boolean") return NodeType.Boolean;
+	if (content && typeof content === "object") return NodeType.Object;
+	if (content === null) return NodeType.Null;
+	return NodeType.Unknown;
+};
+
+//#endregion
+//#region src/dictionaryManipulator/mergeDictionaries.ts
+const checkTypesMatch = (object1, object2, object2LocalId, dictionaryKey, path = []) => {
+	const appLogger = getAppLogger(configuration);
+	if (object1 === void 0 || object1 === null || object2 === void 0 || object2 === null) return;
+	const type1 = getNodeType(object1);
+	const type2 = getNodeType(object2);
+	if (type1 === "unknown" || type2 === "unknown") return;
+	if (type1 !== type2) {
+		appLogger([`Error: Dictionary ${colorizeKey(dictionaryKey)} has a multiple content files with type mismatch at path "${path.join(".")}": Cannot merge ${type1} with ${type2} while merging ${object2LocalId}`], { level: "error" });
+		return;
+	}
+};
+const customMerge = (destination, source) => {
+	if (destination === void 0 || destination === null) return source;
+	if (source === void 0 || source === null) return destination;
+	if (typeof destination !== "object" || typeof source !== "object") return destination;
+	if (Array.isArray(destination) && Array.isArray(source)) return arrayMerge(destination, source);
+	if (typeof destination === "object" && typeof source === "object") {
+		const result = {};
+		const allKeys = new Set([...Object.keys(destination), ...Object.keys(source)]);
+		for (const key of allKeys) result[key] = customMerge(destination[key], source[key]);
+		return result;
+	}
+	return destination;
+};
+const arrayMerge = (destinationArray, sourceArray) => {
+	const destHasOnlyPrimitives = destinationArray.every((item) => typeof item !== "object" || item === null);
+	const sourceHasOnlyPrimitives = sourceArray.every((item) => typeof item !== "object" || item === null);
+	if (destHasOnlyPrimitives && sourceHasOnlyPrimitives) return sourceArray;
+	const result = [];
+	const maxLength = Math.max(destinationArray.length, sourceArray.length);
+	for (let i = 0; i < maxLength; i++) {
+		const destItem = destinationArray[i];
+		const sourceItem = sourceArray[i];
+		if (destItem === void 0 && sourceItem === void 0) {} else if (destItem === void 0) result.push(sourceItem);
+		else if (sourceItem === void 0) result.push(destItem);
+		else if (typeof destItem === "object" && typeof sourceItem === "object" && destItem !== null && sourceItem !== null) if ("key" in destItem && "key" in sourceItem && destItem.key === sourceItem.key) result.push(customMerge(destItem, sourceItem));
+		else result.push(customMerge(destItem, sourceItem));
+		else result.push(destItem);
+	}
+	return result;
+};
+const mergeDictionaries = (dictionaries) => {
+	const localIds = Array.from(new Set(dictionaries.filter((dict) => dict.localId).map((dict) => dict.localId)));
+	const dictionariesKeys = dictionaries.map((dict) => dict.key);
+	if (new Set(dictionariesKeys).size !== 1) throw new Error("All dictionaries must have the same key");
+	let mergedContent = dictionaries[0].content;
+	for (let i = 1; i < dictionaries.length; i++) {
+		const currentDictionary = getMultilingualDictionary(dictionaries[i]);
+		checkTypesMatch(mergedContent, currentDictionary.content, currentDictionary.localId, currentDictionary.key, []);
+		mergedContent = customMerge(mergedContent, currentDictionary.content);
+	}
+	return {
+		key: dictionaries[0].key,
+		content: mergedContent,
+		localIds
+	};
+};
+
+//#endregion
+//#region src/dictionaryManipulator/orderDictionaries.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
+*/
+const orderDictionaries = (dictionaries, configuration$1 = configuration) => {
+	const { editor } = configuration$1;
+	const { dictionaryPriorityStrategy } = editor;
+	if (dictionaries.length <= 1) return dictionaries;
+	const withIndex = dictionaries.map((dictionary, index) => ({
+		dictionary,
+		index
+	}));
+	const getPriority = (dictionary) => {
+		const p = dictionary.priority ?? 0;
+		return Number.isFinite(p) ? p : 0;
+	};
+	const getLocationWeight = (d) => {
+		const location = d.location;
+		if (location === void 0) return 2;
+		if (dictionaryPriorityStrategy === "distant_first") return location === "remote" ? 0 : 1;
+		return location === "local" ? 0 : 1;
+	};
+	withIndex.sort((a, b) => {
+		const aAuto = a.dictionary.filled ? 1 : 0;
+		const bAuto = b.dictionary.filled ? 1 : 0;
+		if (aAuto !== bAuto) return aAuto - bAuto;
+		const aP = getPriority(a.dictionary);
+		const bP = getPriority(b.dictionary);
+		if (aP !== bP) return bP - aP;
+		const aLocation = getLocationWeight(a.dictionary);
+		const bLocation = getLocationWeight(b.dictionary);
+		if (aLocation !== bLocation) return aLocation - bLocation;
+		return a.index - b.index;
+	});
+	return withIndex.map(({ dictionary }) => dictionary);
+};
+
+//#endregion
+//#region src/dictionaryManipulator/normalizeDictionary.ts
+const normalizeDictionary = (dictionary, configuration$1) => {
+	const { locales } = configuration$1.internationalization;
+	const parsedDictionary = JSON.parse(JSON.stringify(dictionary));
+	if (dictionary.locale) return {
+		...dictionary,
+		locale: void 0,
+		content: translation({ [dictionary.locale]: dictionary.content })
+	};
+	const perLocaleContent = locales.reduce((acc, locale) => {
+		acc[locale] = getPerLocaleDictionary(parsedDictionary, locale).content;
+		return acc;
+	}, {});
+	return {
+		...dictionary,
+		content: translation(perLocaleContent)
+	};
+};
+const normalizeDictionaries = (dictionaries, configuration$1) => {
+	return orderDictionaries(dictionaries, configuration$1).map((dictionary) => normalizeDictionary(dictionary, configuration$1));
+};
+
+//#endregion
+//#region src/dictionaryManipulator/removeContentNodeByKeyPath.ts
+const removeContentNodeByKeyPath = (dictionaryContent, keyPath) => {
+	let currentValue = dictionaryContent;
+	let parentValue = null;
+	let lastKey = null;
+	for (const keyObj of keyPath) {
+		parentValue = currentValue;
+		if (keyObj.type === NodeType.Object || keyObj.type === NodeType.Array) {
+			lastKey = keyObj.key;
+			currentValue = currentValue[keyObj.key];
+		}
+		if (keyObj.type === NodeType.Translation || keyObj.type === NodeType.Enumeration || keyObj.type === NodeType.Condition) {
+			lastKey = keyObj.type;
+			currentValue = currentValue[keyObj.type][keyObj.key];
+		}
+		if (keyObj.type === NodeType.Markdown || keyObj.type === NodeType.ReactNode || keyObj.type === NodeType.Insertion || keyObj.type === NodeType.File) {
+			lastKey = keyObj.type;
+			currentValue = currentValue[keyObj.type];
+		}
+	}
+	if (parentValue && lastKey !== null) if (Array.isArray(parentValue)) parentValue.splice(lastKey, 1);
+	else delete parentValue[lastKey];
+	return dictionaryContent;
+};
+
+//#endregion
+//#region src/dictionaryManipulator/renameContentNodeByKeyPath.ts
+const renameContentNodeByKeyPath = (dictionaryContent, newKey, keyPath) => {
+	let currentValue = dictionaryContent;
+	let parentValue = null;
+	let lastKey = null;
+	for (const keyObj of keyPath) {
+		parentValue = currentValue;
+		if (keyObj.type === NodeType.Object || keyObj.type === NodeType.Array) {
+			lastKey = keyObj.key;
+			currentValue = currentValue[keyObj.key];
+		}
+		if (keyObj.type === NodeType.Translation || keyObj.type === NodeType.Enumeration || keyObj.type === NodeType.Condition) {
+			lastKey = keyObj.type;
+			currentValue = currentValue[keyObj.type][keyObj.key];
+		}
+		if (keyObj.type === NodeType.Markdown || keyObj.type === NodeType.ReactNode || keyObj.type === NodeType.Insertion || keyObj.type === NodeType.File) {
+			lastKey = keyObj.type;
+			currentValue = currentValue[keyObj.type];
+		}
+	}
+	if (parentValue && lastKey !== null) if (Array.isArray(parentValue)) parentValue[lastKey] = currentValue;
+	else {
+		const newParentValue = {};
+		for (const key of Object.keys(parentValue)) if (key === lastKey && typeof newKey !== "undefined") newParentValue[newKey] = currentValue;
+		else newParentValue[key] = parentValue[key];
+		Object.keys(parentValue).forEach((key) => {
+			delete parentValue[key];
+		});
+		Object.assign(parentValue, newParentValue);
+	}
+	return dictionaryContent;
+};
+
+//#endregion
+//#region src/dictionaryManipulator/updateNodeChildren.ts
+const updateNodeChildren = (section, newChildren) => {
+	if (typeof section === "string") return newChildren;
+	if (typeof section === "number") return newChildren;
+	if (typeof section === "boolean") return newChildren;
+	if (typeof (section === null || section === void 0 ? void 0 : section.nodeType) === "string") {
+		const typedNode = section;
+		const content = typedNode[typedNode.nodeType];
+		if (typedNode.nodeType === NodeType.Translation || typedNode.nodeType === NodeType.Enumeration || typedNode.nodeType === NodeType.Condition) {
+			const newContent = Object.entries(content).reduce((acc, [key]) => {
+				acc[key] = newChildren;
+				return acc;
+			}, {});
+			return {
+				...typedNode,
+				[typedNode.nodeType]: newContent
+			};
+		}
+		if (typedNode.nodeType === NodeType.Nested) return typedNode;
+		return {
+			...typedNode,
+			[typedNode.nodeType]: newChildren
+		};
+	}
+	if (!section || typeof section !== "object") return newChildren;
+	if (Array.isArray(section)) return section.map(() => newChildren);
+	return Object.entries(section).reduce((acc, [key]) => ({
+		...acc,
+		[key]: newChildren
+	}), {});
+};
+
+//#endregion
+//#region src/utils/intl.ts
+const cacheKey = (locales, options) => JSON.stringify([locales, options]);
+const createCachedConstructor = (Ctor) => {
+	const cache = /* @__PURE__ */ new Map();
+	function Wrapped(locales, options) {
+		var _Intl;
+		if (Ctor.name === "DisplayNames" && typeof ((_Intl = Intl) === null || _Intl === void 0 ? void 0 : _Intl.DisplayNames) !== "function") {
+			if (process.env.NODE_ENV === "development") console.warn([
+				`// Intl.DisplayNames is not supported; falling back to raw locale (${locales}). `,
+				`// Consider adding a polyfill as https://formatjs.io/docs/polyfills/intl-displaynames/`,
+				``,
+				`import 'intl';`,
+				`import '@formatjs/intl-getcanonicallocales/polyfill';`,
+				`import '@formatjs/intl-locale/polyfill';`,
+				`import '@formatjs/intl-pluralrules/polyfill';`,
+				`import '@formatjs/intl-displaynames/polyfill';`,
+				`import '@formatjs/intl-listformat/polyfill';`,
+				`import '@formatjs/intl-numberformat/polyfill';`,
+				`import '@formatjs/intl-relativetimeformat/polyfill';`,
+				`import '@formatjs/intl-datetimeformat/polyfill';`,
+				``,
+				`// Optionally add locale data`,
+				`import '@formatjs/intl-pluralrules/locale-data/fr';`,
+				`import '@formatjs/intl-numberformat/locale-data/fr';`,
+				`import '@formatjs/intl-datetimeformat/locale-data/fr';`
+			].join("\n"));
+			return locales;
+		}
+		const key = cacheKey(locales ?? Locales.ENGLISH, options);
+		let instance = cache.get(key);
+		if (!instance) {
+			instance = new Ctor(locales, options);
+			cache.set(key, instance);
+		}
+		return instance;
+	}
+	Wrapped.prototype = Ctor.prototype;
+	return Wrapped;
+};
+const createCachedIntl = () => new Proxy(Intl, { get: (target, prop, receiver) => {
+	const value = Reflect.get(target, prop, receiver);
+	return typeof value === "function" && /^[A-Z]/.test(String(prop)) ? createCachedConstructor(value) : value;
+} });
+const CachedIntl = createCachedIntl();
+
+//#endregion
+//#region src/formatters/compact.ts
+/**
+* Formats a numeric value using compact notation (e.g., 1K, 1M, 1B)
+* based on locale and formatting options.
+*
+* @example
+* compact({ value: 1200 }); // "1.2K"
+*
+* @example
+* compact({ value: "1000000", locale: Locales.FRENCH, compactDisplay: "long" });
+* // "1 million"
+*/
+const compact = (value, options) => {
+	var _configuration$intern;
+	return new CachedIntl.NumberFormat((options === null || options === void 0 ? void 0 : options.locale) ?? (configuration === null || configuration === void 0 || (_configuration$intern = configuration.internationalization) === null || _configuration$intern === void 0 ? void 0 : _configuration$intern.defaultLocale), {
+		...options,
+		notation: "compact"
+	}).format(Number(value));
+};
+
+//#endregion
+//#region src/formatters/currency.ts
+/**
+* Formats a numeric or string value into a localized currency string using the Intl API.
+*
+*  @example
+* currency({ value: 1234.5, currency: 'EUR' });
+* // "€1,234.50"
+*
+* @example
+* currency({ value: "5000", locale: Locales.FRENCH, currency: "CAD", currencyDisplay: "code" });
+* // "5 000,00 CAD"
+*/
+const currency = (value, options) => {
+	var _configuration$intern;
+	return new CachedIntl.NumberFormat((options === null || options === void 0 ? void 0 : options.locale) ?? (configuration === null || configuration === void 0 || (_configuration$intern = configuration.internationalization) === null || _configuration$intern === void 0 ? void 0 : _configuration$intern.defaultLocale), {
+		style: "currency",
+		currency: (options === null || options === void 0 ? void 0 : options.currency) ?? "USD",
+		currencyDisplay: (options === null || options === void 0 ? void 0 : options.currencyDisplay) ?? "symbol",
+		minimumFractionDigits: (options === null || options === void 0 ? void 0 : options.minimumFractionDigits) ?? 2,
+		maximumFractionDigits: (options === null || options === void 0 ? void 0 : options.maximumFractionDigits) ?? 2,
+		...options
+	}).format(Number(value));
+};
+
+//#endregion
+//#region src/formatters/date.ts
+const presets = {
+	short: {
+		year: "2-digit",
+		month: "2-digit",
+		day: "2-digit",
+		hour: "2-digit",
+		minute: "2-digit"
+	},
+	long: {
+		year: "numeric",
+		month: "long",
+		day: "numeric",
+		hour: "numeric",
+		minute: "numeric"
+	},
+	full: {
+		year: "numeric",
+		month: "long",
+		day: "numeric",
+		hour: "numeric",
+		minute: "numeric",
+		hour12: false
+	},
+	dateOnly: {
+		year: "numeric",
+		month: "short",
+		day: "numeric"
+	},
+	timeOnly: {
+		hour: "numeric",
+		minute: "numeric",
+		second: "numeric"
+	}
+};
+/**
+* Formats a date/time value into a localized string using Intl.DateTimeFormat.
+*
+* @example
+* date({ date: new Date(), options: "short" });
+* // "08/02/25, 14:30"
+*
+* @example
+* date({ date: "2025-08-02T14:30:00Z", locale: Locales.FRENCH, options: { month: "long", day: "numeric" } });
+* // "2 août"
+*/
+const date = (date$1, options) => {
+	var _configuration$intern;
+	const dateTime = new Date(date$1);
+	const resolvedOptions = typeof options === "string" ? presets[options] ?? {} : options;
+	return new CachedIntl.DateTimeFormat((options === null || options === void 0 ? void 0 : options.locale) ?? (configuration === null || configuration === void 0 || (_configuration$intern = configuration.internationalization) === null || _configuration$intern === void 0 ? void 0 : _configuration$intern.defaultLocale), resolvedOptions).format(dateTime);
+};
+
+//#endregion
+//#region src/formatters/list.ts
+/**
+* Formats an array of values into a localized list string using the Intl API.
+*
+* @example
+* list(['apple', 'banana', 'orange']);
+* // "apple, banana, and orange"
+*
+* @example
+* list(['red', 'green', 'blue'], { locale: Locales.FRENCH, type: 'disjunction' });
+* // "rouge, vert ou bleu"
+*
+* @example
+* list([1, 2, 3], { type: 'unit' });
+* // "1, 2, 3"
+*/
+const list = (values, options) => {
+	var _configuration$intern;
+	return new CachedIntl.ListFormat((options === null || options === void 0 ? void 0 : options.locale) ?? (configuration === null || configuration === void 0 || (_configuration$intern = configuration.internationalization) === null || _configuration$intern === void 0 ? void 0 : _configuration$intern.defaultLocale), {
+		type: (options === null || options === void 0 ? void 0 : options.type) ?? "conjunction",
+		style: (options === null || options === void 0 ? void 0 : options.style) ?? "long",
+		...options
+	}).format(values.map(String));
+};
+
+//#endregion
+//#region src/formatters/number.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"
+*/
+const number = (value, options) => {
+	var _configuration$intern;
+	return new CachedIntl.NumberFormat((options === null || options === void 0 ? void 0 : options.locale) ?? (configuration === null || configuration === void 0 || (_configuration$intern = configuration.internationalization) === null || _configuration$intern === void 0 ? void 0 : _configuration$intern.defaultLocale), options).format(Number(value));
+};
+
+//#endregion
+//#region src/formatters/percentage.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%"
+*/
+const percentage = (value, options) => {
+	var _configuration$intern;
+	let numericValue = Number(value);
+	if (numericValue > 1) numericValue /= 100;
+	return new CachedIntl.NumberFormat((options === null || options === void 0 ? void 0 : options.locale) ?? (configuration === null || configuration === void 0 || (_configuration$intern = configuration.internationalization) === null || _configuration$intern === void 0 ? void 0 : _configuration$intern.defaultLocale), {
+		style: "percent",
+		...options
+	}).format(Number(numericValue));
+};
+
+//#endregion
+//#region src/formatters/relativeTime.ts
+/**
+* Calculate the difference between 2 dates in the given unit.
+*/
+const diffInUnit = (from, to, unit) => {
+	const sec = (to.getTime() - from.getTime()) / 1e3;
+	switch (unit) {
+		case "second": return sec;
+		case "minute": return sec / 60;
+		case "hour": return sec / 3600;
+		case "day": return sec / 86400;
+		case "month": return sec / (30 * 86400);
+		case "quarter": return sec / (90 * 86400);
+		case "year": return sec / (365 * 86400);
+		default: return sec;
+	}
+};
+const relativeTime = (from, to = /* @__PURE__ */ new Date(), options) => {
+	var _configuration$intern;
+	const fromDate = new Date(from);
+	const toDate = new Date(to);
+	const unit = (options === null || options === void 0 ? void 0 : options.unit) ?? "second";
+	const value = diffInUnit(fromDate, toDate, unit);
+	return new CachedIntl.RelativeTimeFormat((options === null || options === void 0 ? void 0 : options.locale) ?? (configuration === null || configuration === void 0 || (_configuration$intern = configuration.internationalization) === null || _configuration$intern === void 0 ? void 0 : _configuration$intern.defaultLocale), options).format(Math.round(value), unit);
+};
+
+//#endregion
+//#region src/formatters/units.ts
+/**
+* Formats a numeric value as a localized unit string.
+*
+* @example
+* units({ value: 5, unit: "kilometer", unitDisplay: "long", locale: "en-GB" })
+* // "5 kilometers"
+*/
+const units = (value, options) => {
+	var _configuration$intern;
+	return new CachedIntl.NumberFormat((options === null || options === void 0 ? void 0 : options.locale) ?? (configuration === null || configuration === void 0 || (_configuration$intern = configuration.internationalization) === null || _configuration$intern === void 0 ? void 0 : _configuration$intern.defaultLocale), {
+		style: "unit",
+		unit: (options === null || options === void 0 ? void 0 : options.unit) ?? "day",
+		unitDisplay: (options === null || options === void 0 ? void 0 : options.unitDisplay) ?? "short",
+		useGrouping: (options === null || options === void 0 ? void 0 : options.useGrouping) ?? false
+	}).format(Number(value));
+};
+
+//#endregion
+//#region src/getStorageAttributes.ts
+/**
+* Creates a cookie entry with default values for missing attributes
+*/
+const createCookieEntry = (options) => {
+	const { name, path, expires, domain, secure, sameSite, httpOnly } = options ?? {};
+	return {
+		name: name ?? DefaultValues.Routing.COOKIE_NAME,
+		attributes: {
+			path,
+			expires,
+			domain,
+			secure,
+			sameSite,
+			httpOnly
+		}
+	};
+};
+/**
+* Creates a web storage entry (localStorage or sessionStorage) with default name
+*/
+const createWebStorageEntry = (options) => {
+	const { name } = options ?? {};
+	return { name: name ?? DefaultValues.Routing.LOCALE_STORAGE_NAME };
+};
+/**
+* Creates a header entry with default name
+*/
+const createHeaderEntry = (options) => {
+	const { name } = options ?? {};
+	return { name: name ?? DefaultValues.Routing.HEADER_NAME };
+};
+/**
+* Determines if a storage entry is a cookie based on its properties
+*/
+const isCookieEntry = (entry) => {
+	return entry.type === "cookie" || "sameSite" in entry || "httpOnly" in entry || "secure" in entry;
+};
+/**
+* Determines the storage type from a string literal
+*/
+const isStorageType = (value) => {
+	return value === "cookie" || value === "localStorage" || value === "sessionStorage" || value === "header";
+};
+/**
+* Processes a single storage entry and returns the appropriate storage attributes
+*/
+const processStorageEntry = (entry) => {
+	if (typeof entry === "string") {
+		if (!isStorageType(entry)) return {
+			cookies: [],
+			localStorage: [],
+			sessionStorage: [],
+			headers: []
+		};
+		if (entry === "cookie") return { cookies: [createCookieEntry()] };
+		if (entry === "localStorage") return { localStorage: [createWebStorageEntry()] };
+		if (entry === "sessionStorage") return { sessionStorage: [createWebStorageEntry()] };
+		if (entry === "header") return { headers: [createHeaderEntry()] };
+	}
+	if (typeof entry === "object" && entry !== null) {
+		const typedEntry = entry;
+		if (isCookieEntry(typedEntry)) return { cookies: [createCookieEntry(typedEntry)] };
+		if ("type" in typedEntry && typedEntry.type === "localStorage") {
+			const { name: name$1,...rest$1 } = typedEntry;
+			return { localStorage: [createWebStorageEntry({
+				name: name$1,
+				...rest$1
+			})] };
+		}
+		if ("type" in typedEntry && typedEntry.type === "sessionStorage") {
+			const { name: name$1,...rest$1 } = typedEntry;
+			return { sessionStorage: [createWebStorageEntry({
+				name: name$1,
+				...rest$1
+			})] };
+		}
+		if ("type" in typedEntry && typedEntry.type === "header") {
+			const { name: name$1,...rest$1 } = typedEntry;
+			return { headers: [createHeaderEntry({
+				name: name$1,
+				...rest$1
+			})] };
+		}
+		const { name,...rest } = typedEntry;
+		return { localStorage: [createWebStorageEntry({
+			name,
+			...rest
+		})] };
+	}
+	return {
+		cookies: [],
+		localStorage: [],
+		sessionStorage: [],
+		headers: []
+	};
+};
+/**
+* Merges multiple partial storage attributes into a single result
+*/
+const mergeStorageAttributes = (accumulated, partial) => {
+	return {
+		cookies: [...accumulated.cookies, ...partial.cookies ?? []],
+		localStorage: [...accumulated.localStorage, ...partial.localStorage ?? []],
+		sessionStorage: [...accumulated.sessionStorage, ...partial.sessionStorage ?? []],
+		headers: [...accumulated.headers, ...partial.headers ?? []]
+	};
+};
+/**
+* Extracts and normalizes storage configuration into separate arrays for each storage type
+*
+* @param options - The storage configuration from IntlayerConfig
+* @returns An object containing arrays for cookies, localStorage, and sessionStorage
+*/
+const getStorageAttributes = (options) => {
+	const emptyResult = {
+		cookies: [],
+		localStorage: [],
+		sessionStorage: [],
+		headers: []
+	};
+	if (options === false || options === void 0) return emptyResult;
+	if (Array.isArray(options)) return options.reduce((acc, entry) => {
+		return mergeStorageAttributes(acc, processStorageEntry(entry));
+	}, emptyResult);
+	return mergeStorageAttributes(emptyResult, processStorageEntry(options));
+};
+
+//#endregion
+//#region src/utils/localeStorage.ts
+const buildCookieString = (name, value, attributes) => {
+	const parts = [`${name}=${encodeURIComponent(value)}`];
+	if (attributes.path) parts.push(`Path=${attributes.path}`);
+	if (attributes.domain) parts.push(`Domain=${attributes.domain}`);
+	if (attributes.expires instanceof Date) parts.push(`Expires=${attributes.expires.toUTCString()}`);
+	if (attributes.secure) parts.push("Secure");
+	if (attributes.sameSite) parts.push(`SameSite=${attributes.sameSite}`);
+	return parts.join("; ");
+};
+/**
+* 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
+*/
+const getLocaleFromStorage = (options) => {
+	const { routing, internationalization } = configuration;
+	const { locales } = internationalization;
+	const { storage } = routing;
+	if (storage === false || (options === null || options === void 0 ? void 0 : options.isCookieEnabled) === false) return void 0;
+	const storageAttributes = getStorageAttributes(storage);
+	const isValidLocale = (value) => {
+		if (!value) return false;
+		return locales.includes(value);
+	};
+	const readCookie = (name) => {
+		try {
+			var _options$getCookie;
+			const fromOption = options === null || options === void 0 || (_options$getCookie = options.getCookie) === null || _options$getCookie === void 0 ? void 0 : _options$getCookie.call(options, name);
+			if (fromOption !== null) return fromOption;
+		} catch {}
+		try {
+			const cookieString = document.cookie ?? "";
+			if (!cookieString) return;
+			const pairs = cookieString.split(";");
+			for (let i = 0; i < pairs.length; i++) {
+				const part = pairs[i].trim();
+				if (!part) continue;
+				const equalIndex = part.indexOf("=");
+				if ((equalIndex >= 0 ? part.substring(0, equalIndex) : part) === name) {
+					const rawValue = equalIndex >= 0 ? part.substring(equalIndex + 1) : "";
+					try {
+						return decodeURIComponent(rawValue);
+					} catch {
+						return rawValue;
+					}
+				}
+			}
+		} catch {}
+	};
+	for (let i = 0; i < storageAttributes.cookies.length; i++) {
+		const { name } = storageAttributes.cookies[i];
+		const value = readCookie(name);
+		if (isValidLocale(value)) return value;
+	}
+	for (let i = 0; i < storageAttributes.localStorage.length; i++) {
+		const { name } = storageAttributes.localStorage[i];
+		try {
+			var _options$getLocaleSto;
+			const value = options === null || options === void 0 || (_options$getLocaleSto = options.getLocaleStorage) === null || _options$getLocaleSto === void 0 ? void 0 : _options$getLocaleSto.call(options, name);
+			if (isValidLocale(value)) return value;
+		} catch {}
+	}
+	for (let i = 0; i < storageAttributes.sessionStorage.length; i++) {
+		const { name } = storageAttributes.sessionStorage[i];
+		try {
+			var _options$getSessionSt;
+			const value = options === null || options === void 0 || (_options$getSessionSt = options.getSessionStorage) === null || _options$getSessionSt === void 0 ? void 0 : _options$getSessionSt.call(options, name);
+			if (isValidLocale(value)) return value;
+		} catch {}
+	}
+	for (let i = 0; i < storageAttributes.headers.length; i++) {
+		const { name } = storageAttributes.headers[i];
+		try {
+			var _options$getHeader;
+			const value = options === null || options === void 0 || (_options$getHeader = options.getHeader) === null || _options$getHeader === void 0 ? void 0 : _options$getHeader.call(options, name);
+			if (isValidLocale(value)) return value;
+		} catch {}
+	}
+};
+/**
+* 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
+*/
+const setLocaleInStorage = (locale, options) => {
+	if (configuration.routing.storage === false || (options === null || options === void 0 ? void 0 : options.isCookieEnabled) === false) return;
+	const storageAttributes = getStorageAttributes(configuration.routing.storage);
+	for (let i = 0; i < storageAttributes.cookies.length; i++) {
+		const { name, attributes } = storageAttributes.cookies[i];
+		try {
+			if (options === null || options === void 0 ? void 0 : options.setCookieStore) {
+				var _options$setCookieSto;
+				options === null || options === void 0 || (_options$setCookieSto = options.setCookieStore) === null || _options$setCookieSto === void 0 || _options$setCookieSto.call(options, name, locale, {
+					...attributes,
+					expires: attributes.expires instanceof Date ? attributes.expires.getTime() : attributes.expires
+				});
+			}
+		} catch {
+			try {
+				if (options === null || options === void 0 ? void 0 : options.setCookieString) {
+					var _options$setCookieStr;
+					const cookieString = buildCookieString(name, locale, attributes);
+					options === null || options === void 0 || (_options$setCookieStr = options.setCookieString) === null || _options$setCookieStr === void 0 || _options$setCookieStr.call(options, name, cookieString);
+				}
+			} catch {}
+		}
+	}
+	if (options === null || options === void 0 ? void 0 : options.setLocaleStorage) for (let i = 0; i < storageAttributes.localStorage.length; i++) {
+		const { name } = storageAttributes.localStorage[i];
+		try {
+			var _options$setLocaleSto;
+			if (!((options === null || options === void 0 ? void 0 : options.overwrite) ?? true) && (options === null || options === void 0 ? void 0 : options.getLocaleStorage)) {
+				var _options$getLocaleSto2;
+				if (options === null || options === void 0 || (_options$getLocaleSto2 = options.getLocaleStorage) === null || _options$getLocaleSto2 === void 0 ? void 0 : _options$getLocaleSto2.call(options, name)) continue;
+			}
+			options === null || options === void 0 || (_options$setLocaleSto = options.setLocaleStorage) === null || _options$setLocaleSto === void 0 || _options$setLocaleSto.call(options, name, locale);
+		} catch {}
+	}
+	if (options === null || options === void 0 ? void 0 : options.setSessionStorage) for (let i = 0; i < storageAttributes.sessionStorage.length; i++) {
+		const { name } = storageAttributes.sessionStorage[i];
+		try {
+			var _options$setSessionSt;
+			if (!((options === null || options === void 0 ? void 0 : options.overwrite) ?? true) && (options === null || options === void 0 ? void 0 : options.getSessionStorage)) {
+				var _options$getSessionSt2;
+				if (options === null || options === void 0 || (_options$getSessionSt2 = options.getSessionStorage) === null || _options$getSessionSt2 === void 0 ? void 0 : _options$getSessionSt2.call(options, name)) continue;
+			}
+			options === null || options === void 0 || (_options$setSessionSt = options.setSessionStorage) === null || _options$setSessionSt === void 0 || _options$setSessionSt.call(options, name, locale);
+		} catch {}
+	}
+	if (options === null || options === void 0 ? void 0 : options.setHeader) for (let i = 0; i < storageAttributes.headers.length; i++) {
+		const { name } = storageAttributes.headers[i];
+		try {
+			var _options$setHeader;
+			options === null || options === void 0 || (_options$setHeader = options.setHeader) === null || _options$setHeader === void 0 || _options$setHeader.call(options, name, locale);
+		} catch {}
+	}
+};
+/**
+* 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
+*/
+const LocaleStorage = (options) => ({
+	getLocale: () => getLocaleFromStorage(options),
+	setLocale: (locale) => setLocaleInStorage(locale, options)
+});
+
+//#endregion
+//#region src/localization/localeResolver.ts
+var _configuration$intern2$2;
+/**
+* Resolves the most specific locale from a user-provided list,
+* or falls back to the default locale if no match is found.
+*/
+const localeResolver = (selectedLocale, locales = (() => {
+	var _configuration$intern;
+	return configuration === null || configuration === void 0 || (_configuration$intern = configuration.internationalization) === null || _configuration$intern === void 0 ? void 0 : _configuration$intern.locales;
+})(), defaultLocale = configuration === null || configuration === void 0 || (_configuration$intern2$2 = configuration.internationalization) === null || _configuration$intern2$2 === void 0 ? void 0 : _configuration$intern2$2.defaultLocale) => {
+	const requestedLocales = [selectedLocale].flat();
+	const normalize = (locale) => locale.trim().toLowerCase();
+	try {
+		for (const requested of requestedLocales) {
+			const normalizedRequested = normalize(requested);
+			const exactMatch = locales.find((loc) => normalize(loc) === normalizedRequested);
+			if (exactMatch) return exactMatch;
+			const [requestedLang] = normalizedRequested.split("-");
+			const partialMatch = locales.find((loc) => normalize(loc).split("-")[0] === requestedLang);
+			if (partialMatch) return partialMatch;
+		}
+	} catch (_error) {}
+	return defaultLocale;
+};
+
+//#endregion
+//#region src/localization/localeDetector.ts
+/**
+* Module variables.
+*/
+const simpleLanguageRegExp = /^\s*([^\s\-;]+)(?:-([^\s;]+))?\s*(?:;(.*))?$/;
+/**
+* Parse the Accept-Language header.
+*/
+const parseAcceptLanguage = (accept) => {
+	const rawAccepts = accept.split(",");
+	const accepts = [];
+	for (let i = 0; i < rawAccepts.length; i++) {
+		const language = parseLanguage(rawAccepts[i].trim(), i);
+		if (language) accepts.push(language);
+	}
+	return accepts;
+};
+/**
+* Parse a language from the Accept-Language header.
+*/
+const parseLanguage = (str, i) => {
+	const match = simpleLanguageRegExp.exec(str);
+	if (!match) return null;
+	const prefix = match[1];
+	const suffix = match[2];
+	let full = prefix;
+	if (suffix) full = `${prefix}-${suffix}`;
+	let q = 1;
+	if (match[3]) {
+		const params = match[3].split(";");
+		for (let j = 0; j < params.length; j++) {
+			const p = params[j].split("=");
+			if (p[0] === "q") q = parseFloat(p[1]);
+		}
+	}
+	return {
+		prefix,
+		suffix,
+		q,
+		i,
+		full
+	};
+};
+/**
+* Get the priority of a language.
+*/
+const getLanguagePriority = (language, accepted, index) => {
+	let priority = {
+		o: -1,
+		q: 0,
+		s: 0,
+		i: index
+	};
+	for (let i = 0; i < accepted.length; i++) {
+		const spec = specify(language, accepted[i], index);
+		if (spec && (priority.s - spec.s || priority.q - spec.q || priority.o - spec.o) < 0) priority = spec;
+	}
+	return priority;
+};
+/**
+* Get the specificity of the language.
+*/
+const specify = (language, spec, index) => {
+	const p = parseLanguage(language, index);
+	if (!p) return null;
+	let s = 0;
+	if (spec.full.toLowerCase() === p.full.toLowerCase()) s |= 4;
+	else if (spec.prefix.toLowerCase() === p.full.toLowerCase()) s |= 2;
+	else if (spec.full.toLowerCase() === p.prefix.toLowerCase()) s |= 1;
+	else if (spec.full !== "*") return null;
+	return {
+		i: index,
+		o: spec.i,
+		q: spec.q,
+		s
+	};
+};
+/**
+* Get the preferred languages from an Accept-Language header.
+*/
+const preferredLanguages = (accept, provided) => {
+	const accepts = parseAcceptLanguage(accept === void 0 ? "*" : accept ?? "");
+	if (!provided) return accepts.filter(isQuality).sort(compareSpecs).map(getFullLanguage);
+	const priorities = provided.map((type, index) => getLanguagePriority(type, accepts, index));
+	return priorities.filter(isQuality).sort(compareSpecs).map((priority) => provided[priorities.indexOf(priority)]);
+};
+/**
+* Compare two specs.
+*/
+const compareSpecs = (a, b) => b.q - a.q || (b.s ?? 0) - (a.s ?? 0) || (a.o ?? 0) - (b.o ?? 0) || a.i - b.i || 0;
+/**
+* Get full language string.
+*/
+const getFullLanguage = (spec) => spec.full;
+/**
+* Check if a spec has any quality.
+*/
+const isQuality = (spec) => spec.q > 0;
+/**
+* Detects the locale from the request headers
+*
+* Headers are provided by the browser and can be used to determine the user's preferred language
+*/
+const localeDetector = (headers, locales, defaultLocale) => {
+	const accept = headers["accept-language"];
+	return localeResolver(preferredLanguages(accept), locales, defaultLocale);
+};
+
+//#endregion
+//#region src/localization/getBrowserLocale.tsx
+let LanguageDetector = /* @__PURE__ */ function(LanguageDetector$1) {
+	LanguageDetector$1["Querystring"] = "querystring";
+	LanguageDetector$1["Storage"] = "storage";
+	LanguageDetector$1["Navigator"] = "navigator";
+	LanguageDetector$1["HtmlTag"] = "htmlTag";
+	return LanguageDetector$1;
+}({});
+const localeStorageOptions = {
+	getCookie: (name) => {
+		var _document$cookie$spli;
+		return (_document$cookie$spli = document.cookie.split(";").find((c) => c.trim().startsWith(`${name}=`))) === null || _document$cookie$spli === void 0 ? void 0 : _document$cookie$spli.split("=")[1];
+	},
+	getLocaleStorage: (name) => localStorage.getItem(name),
+	getSessionStorage: (name) => sessionStorage.getItem(name),
+	isCookieEnabled: true,
+	setCookieStore: (name, value, attributes) => cookieStore.set({
+		name,
+		value,
+		path: attributes.path,
+		domain: attributes.domain,
+		expires: attributes.expires,
+		sameSite: attributes.sameSite
+	}),
+	setCookieString: (cookie) => {
+		document.cookie = cookie;
+	},
+	setSessionStorage: (name, value) => sessionStorage.setItem(name, value),
+	setLocaleStorage: (name, value) => localStorage.setItem(name, value)
+};
+const getDefaultsOptions = () => {
+	return {
+		order: [
+			LanguageDetector.Querystring,
+			LanguageDetector.Storage,
+			LanguageDetector.Navigator,
+			LanguageDetector.HtmlTag
+		],
+		lookupQuerystring: "locale",
+		htmlTag: typeof document !== "undefined" ? document.documentElement : null
+	};
+};
+const detectLanguage = (order, options) => {
+	const detected = {};
+	const queryStringDetector = () => {
+		if (typeof window === "undefined") return;
+		const search = window.location.search || "";
+		const value = new URLSearchParams(search).get(options.lookupQuerystring ?? "");
+		if (value) detected[LanguageDetector.Querystring] = value;
+	};
+	const storageDetector = () => {
+		if (typeof window === "undefined") return;
+		const locale = getLocaleFromStorage({
+			getCookie: (name) => {
+				try {
+					const cookies = document.cookie.split(";");
+					const cookieName = `${name}=`;
+					const cookie = cookies.find((c) => c.trim().startsWith(cookieName));
+					if (cookie) return cookie.split("=")[1].trim();
+				} catch {}
+			},
+			getSessionStorage: (name) => {
+				try {
+					return window.sessionStorage.getItem(name) ?? void 0;
+				} catch {}
+			},
+			getLocaleStorage: (name) => {
+				try {
+					return window.localStorage.getItem(name) ?? void 0;
+				} catch {}
+			}
+		});
+		if (locale) detected[LanguageDetector.Storage] = locale;
+	};
+	const navigatorDetector = () => {
+		if (typeof navigator === "undefined") return;
+		const { internationalization } = configuration;
+		const languages = navigator.languages ?? [navigator.language];
+		const locale = localeDetector({ "accept-language": languages.join(",") }, internationalization.locales, internationalization.defaultLocale);
+		if (locale) detected[LanguageDetector.Navigator] = locale;
+	};
+	const htmlTagDetector = () => {
+		const htmlTag = options.htmlTag;
+		if (htmlTag && typeof htmlTag.getAttribute === "function") {
+			const lang = htmlTag.getAttribute("lang");
+			if (lang) {
+				const { internationalization } = configuration;
+				const locale = localeDetector({ "accept-language": lang }, internationalization.locales, internationalization.defaultLocale);
+				detected[LanguageDetector.HtmlTag] = locale;
+			}
+		}
+	};
+	const detectors = {
+		[LanguageDetector.Querystring]: queryStringDetector,
+		[LanguageDetector.Storage]: storageDetector,
+		[LanguageDetector.Navigator]: navigatorDetector,
+		[LanguageDetector.HtmlTag]: htmlTagDetector
+	};
+	order.forEach((detectorName) => {
+		var _detectors$detectorNa;
+		(_detectors$detectorNa = detectors[detectorName]) === null || _detectors$detectorNa === void 0 || _detectors$detectorNa.call(detectors);
+	});
+	return detected;
+};
+const getFirstAvailableLocale = (locales, order) => {
+	const { internationalization } = configuration;
+	for (const detector of order) {
+		const locale = locales[detector];
+		if (locale && internationalization.locales.includes(locale)) return locale;
+	}
+	return (internationalization === null || internationalization === void 0 ? void 0 : internationalization.defaultLocale) ?? Locales.ENGLISH;
+};
+/**
+* Core language detector function for browser environments.
+*
+* Detects the user's preferred locale by checking multiple sources in order:
+* 1. Query string parameter
+* 2. Storage (cookies, localStorage, sessionStorage) - uses getLocaleFromStorage
+* 3. Navigator languages - uses localeDetector
+* 4. HTML lang attribute - uses localeDetector
+*
+* @param userOptions - Optional configuration for detection order and lookup keys
+* @returns The detected locale or the default locale
+*
+* @example
+* const locale = getBrowserLocale({ order: [LanguageDetector.Storage, LanguageDetector.Navigator] });
+*/
+const getBrowserLocale = (userOptions = {}) => {
+	const options = {
+		...getDefaultsOptions(),
+		...userOptions
+	};
+	return getFirstAvailableLocale(detectLanguage(options.order ?? [], options), options.order ?? []);
+};
+
+//#endregion
+//#region src/localization/getHTMLTextDir.ts
+/**
+* Returns the text direction of the given locale.
+*
+* Example:
+*
+* getHTMLTextDir('en-US') // 'ltr'
+* getHTMLTextDir('en') // 'ltr'
+* getHTMLTextDir('fr-CA') // 'ltr'
+* getHTMLTextDir('fr') // 'ltr'
+*
+* @param locale The locale to get the text direction for.
+* @returns The text direction of the given locale.
+*/
+const getHTMLTextDir = (locale) => {
+	switch (locale) {
+		case Locales.ARABIC:
+		case Locales.FARSI:
+		case Locales.URDU:
+		case Locales.PASHTO:
+		case Locales.SYRIAC:
+		case Locales.ARABIC_UNITED_ARAB_EMIRATES:
+		case Locales.ARABIC_BAHRAIN:
+		case Locales.ARABIC_ALGERIA:
+		case Locales.ARABIC_EGYPT:
+		case Locales.ARABIC_IRAQ:
+		case Locales.ARABIC_JORDAN:
+		case Locales.ARABIC_KUWAIT:
+		case Locales.ARABIC_LEBANON:
+		case Locales.ARABIC_LIBYA:
+		case Locales.ARABIC_MOROCCO:
+		case Locales.ARABIC_OMAN:
+		case Locales.ARABIC_QATAR:
+		case Locales.ARABIC_SAUDI_ARABIA:
+		case Locales.ARABIC_SYRIA:
+		case Locales.ARABIC_TUNISIA:
+		case Locales.ARABIC_YEMEN:
+		case Locales.FARSI_IRAN:
+		case Locales.URDU_ISLAMIC_REPUBLIC_OF_PAKISTAN:
+		case Locales.PASHTO_AFGHANISTAN:
+		case Locales.SYRIAC_SYRIA: return "rtl";
+		default: return "ltr";
+	}
+};
+
+//#endregion
+//#region src/utils/checkIsURLAbsolute.ts
+const checkIsURLAbsolute = (url) => /^[a-zA-Z][a-zA-Z\d+\-.]*:/.test(url);
+
+//#endregion
+//#region src/localization/getLocaleFromPath.ts
+/**
+* Extracts the locale segment from the given URL or pathname if present.
+* If no locale is present, returns the default locale (en).
+*
+* Example:
+*
+* ```ts
+* getLocaleFromPath('/en/dashboard') // Returns 'en'
+* getLocaleFromPath('/fr/dashboard') // Returns 'fr'
+* getLocaleFromPath('/dashboard') // Returns 'en'
+* getLocaleFromPath('dashboard') // Returns 'en'
+* getLocaleFromPath('https://example.com/es/dashboard') // Returns 'es'
+* getLocaleFromPath('https://example.com/fr/dashboard') // Returns 'fr'
+* getLocaleFromPath('https://example.com/dashboard') // Returns 'en'
+* ```
+*
+* @param inputUrl - The complete URL string or pathname to process.
+* @returns The detected locale or default (en) if no locale is found
+*/
+const getLocaleFromPath = (inputUrl) => {
+	const { defaultLocale, locales } = (configuration === null || configuration === void 0 ? void 0 : configuration.internationalization) ?? {};
+	if (!defaultLocale || !locales) return Locales.ENGLISH;
+	const isAbsoluteUrl = checkIsURLAbsolute(inputUrl);
+	let fixedInputUrl = inputUrl;
+	if (inputUrl.endsWith("/")) fixedInputUrl = inputUrl.slice(0, -1);
+	const pathname = (isAbsoluteUrl ? new URL(fixedInputUrl) : new URL(fixedInputUrl, "http://example.com")).pathname;
+	if (!pathname.startsWith("/")) return defaultLocale;
+	const firstSegment = pathname.split("/")[1];
+	if (firstSegment && locales.includes(firstSegment)) return firstSegment;
+	return defaultLocale;
+};
+
+//#endregion
+//#region src/localization/getLocaleLang.ts
+/**
+* Returns the language code of the given locale for locales including the country code.
+*
+* Example:
+*
+* getLocaleLang('en-US') // 'en'
+* getLocaleLang('en') // 'en'
+* getLocaleLang('fr-CA') // 'fr'
+* getLocaleLang('fr') // 'fr'
+*
+* @param locale The locale to get the language code for.
+* @returns The language code of the given locale.
+*/
+const getLocaleLang = (locale) => (locale === null || locale === void 0 ? void 0 : locale.split("-")[0]) ?? "";
+
+//#endregion
+//#region src/localization/getLocaleName.ts
+const getLocaleName = (displayLocale, targetLocale = displayLocale) => {
+	return new CachedIntl.DisplayNames(targetLocale, { type: "language" }).of(displayLocale) ?? "Unknown locale";
+};
+
+//#endregion
+//#region src/localization/getPathWithoutLocale.ts
+/**
+* Removes the locale segment from the given URL or pathname if present.
+* Also removes locale from search parameters if present.
+*
+* This function get the locales from the configuration if not provided.
+*
+* Example:
+*
+* ```ts
+* getPathWithoutLocale('/en/dashboard') // Returns '/dashboard'
+* getPathWithoutLocale('/fr/dashboard') // Returns '/dashboard'
+* getPathWithoutLocale('/dashboard') // Returns '/dashboard'
+* getPathWithoutLocale('dashboard') // Returns 'dashboard'
+* getPathWithoutLocale('/dashboard?locale=fr') // Returns '/dashboard'
+* getPathWithoutLocale('https://example.com/en/dashboard') // Returns 'https://example.com/dashboard'
+* getPathWithoutLocale('https://example.com/fr/dashboard') // Returns 'https://example.com/dashboard'
+* getPathWithoutLocale('https://example.com/dashboard') // Returns 'https://example.com/dashboard'
+* getPathWithoutLocale('https://example.com/dashboard?locale=fr') // Returns 'https://example.com/dashboard'
+* ```
+*
+* @param inputUrl - The complete URL string or pathname to process.
+* @param locales - Optional array of supported locales. Defaults to `localesDefault`.
+* @returns The URL string or pathname without the locale segment or locale search parameter.
+*/
+const getPathWithoutLocale = (inputUrl, locales = (() => {
+	var _configuration$intern;
+	return configuration === null || configuration === void 0 || (_configuration$intern = configuration.internationalization) === null || _configuration$intern === void 0 ? void 0 : _configuration$intern.locales;
+})()) => {
+	const isAbsoluteUrl = checkIsURLAbsolute(inputUrl);
+	let fixedInputUrl = inputUrl;
+	if (inputUrl.endsWith("/")) fixedInputUrl = inputUrl.slice(0, -1);
+	const url = isAbsoluteUrl ? new URL(fixedInputUrl) : new URL(fixedInputUrl, "http://example.com");
+	const pathname = url.pathname;
+	if (!pathname.startsWith("/")) url.pathname = `/${pathname}`;
+	const pathSegments = pathname.split("/");
+	const firstSegment = pathSegments[1];
+	if (locales === null || locales === void 0 ? void 0 : locales.includes(firstSegment)) {
+		pathSegments.splice(1, 1);
+		url.pathname = pathSegments.join("/") ?? "/";
+	}
+	const searchParams = new URLSearchParams(url.search);
+	if (searchParams.has("locale")) {
+		searchParams.delete("locale");
+		url.search = searchParams.toString();
+	}
+	if (isAbsoluteUrl) return url.toString();
+	return url.toString().replace("http://example.com", "");
+};
+
+//#endregion
+//#region src/localization/getMultilingualUrls.ts
+var _configuration$intern2$1, _configuration$routin$2;
+/**
+* Generates multilingual URLs by prefixing the given URL with each supported locale
+* or adding search parameters based on the routing mode.
+* Handles both absolute and relative URLs appropriately.
+*
+* This function gets the locales, default locale, and routing mode from the configuration if not provided.
+*
+* Example:
+*
+* ```ts
+*  // prefix-no-default mode
+*  getMultilingualUrls('/dashboard', ['en', 'fr'], 'en', 'prefix-no-default')
+*     // Returns { en: '/dashboard', fr: '/fr/dashboard' }
+*
+*  // prefix-all mode
+*  getMultilingualUrls('/dashboard', ['en', 'fr'], 'en', 'prefix-all')
+*     // Returns { en: '/en/dashboard', fr: '/fr/dashboard' }
+*
+*  // search-params mode
+*  getMultilingualUrls('/dashboard', ['en', 'fr'], 'en', 'search-params')
+*     // Returns { en: '/dashboard?locale=en', fr: '/dashboard?locale=fr' }
+*
+*  // no-prefix mode
+*  getMultilingualUrls('/dashboard', ['en', 'fr'], 'en', 'no-prefix')
+*     // Returns { en: '/dashboard', fr: '/dashboard' }
+* ```
+*
+* @param url - The original URL string to be processed.
+* @param locales - Optional array of supported locales. Defaults to configured locales.
+* @param defaultLocale - The default locale. Defaults to configured default locale.
+* @param mode - URL routing mode for locale handling. Defaults to configured mode.
+* @returns An object mapping each locale to its corresponding multilingual URL.
+*/
+const getMultilingualUrls = (url, locales = (() => {
+	var _configuration$intern;
+	return configuration === null || configuration === void 0 || (_configuration$intern = configuration.internationalization) === null || _configuration$intern === void 0 ? void 0 : _configuration$intern.locales;
+})(), defaultLocale = configuration === null || configuration === void 0 || (_configuration$intern2$1 = configuration.internationalization) === null || _configuration$intern2$1 === void 0 ? void 0 : _configuration$intern2$1.defaultLocale, mode = configuration === null || configuration === void 0 || (_configuration$routin$2 = configuration.routing) === null || _configuration$routin$2 === void 0 ? void 0 : _configuration$routin$2.mode) => {
+	const urlWithoutLocale = getPathWithoutLocale(url, locales);
+	const isAbsoluteUrl = checkIsURLAbsolute(urlWithoutLocale);
+	const parsedUrl = isAbsoluteUrl ? new URL(urlWithoutLocale) : new URL(urlWithoutLocale, "http://example.com");
+	let pathname = parsedUrl.pathname;
+	if (!pathname.startsWith("/")) pathname = `/${pathname}`;
+	const baseUrl = isAbsoluteUrl ? `${parsedUrl.protocol}//${parsedUrl.host}` : "";
+	const routingMode = mode ?? DefaultValues.Routing.ROUTING_MODE;
+	return (locales ?? []).reduce((acc, locale) => {
+		const isDefaultLocale = (locale === null || locale === void 0 ? void 0 : locale.toString()) === (defaultLocale === null || defaultLocale === void 0 ? void 0 : defaultLocale.toString());
+		let localizedUrl;
+		if (routingMode === "search-params") {
+			const searchParams = new URLSearchParams(parsedUrl.search);
+			searchParams.set("locale", locale.toString());
+			const queryString = searchParams.toString();
+			const pathWithQuery = queryString ? `${pathname}?${queryString}` : pathname;
+			localizedUrl = isAbsoluteUrl ? `${baseUrl}${pathWithQuery}${parsedUrl.hash}` : `${pathWithQuery}${parsedUrl.hash}`;
+		} else if (routingMode === "no-prefix") localizedUrl = isAbsoluteUrl ? `${baseUrl}${pathname}${parsedUrl.search}${parsedUrl.hash}` : `${pathname}${parsedUrl.search}${parsedUrl.hash}`;
+		else {
+			let localizedPath = routingMode === "prefix-all" || routingMode === "prefix-no-default" && !isDefaultLocale ? `/${locale}${pathname}` : pathname;
+			if (localizedPath.length > 1 && localizedPath.endsWith("/")) localizedPath = localizedPath.slice(0, -1);
+			localizedUrl = isAbsoluteUrl ? `${baseUrl}${localizedPath}${parsedUrl.search}${parsedUrl.hash}` : `${localizedPath}${parsedUrl.search}${parsedUrl.hash}`;
+		}
+		acc[locale] = localizedUrl;
+		return acc;
+	}, {});
+};
+
+//#endregion
+//#region src/localization/getLocalizedUrl.ts
+var _configuration$intern2, _configuration$routin$1;
+/**
+* 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.
+*
+* This function gets the locales, default locale, and routing mode from the configuration if not provided.
+*
+* Example:
+*
+* ```ts
+*  // prefix-no-default mode
+*  getLocalizedUrl('/about', 'fr', ['en', 'fr'], 'en', 'prefix-no-default');
+*  // Returns '/fr/about' for the French locale
+*  // Returns '/about' for the English locale (default)
+*
+*  // prefix-all mode
+*  getLocalizedUrl('/about', 'en', ['en', 'fr'], 'en', 'prefix-all');
+*  // Returns '/en/about' for the English locale
+*  // Returns '/fr/about' for the French locale
+*
+*  // search-params mode
+*  getLocalizedUrl('/about', 'fr', ['en', 'fr'], 'en', 'search-params');
+*  // Returns '/about?locale=fr' for the French locale
+*
+*  // no-prefix mode
+*  getLocalizedUrl('/about', 'fr', ['en', 'fr'], 'en', 'no-prefix');
+*  // Returns '/about' for any locale
+* ```
+*
+* @param url - The original URL string to be processed.
+* @param currentLocale - The current locale.
+* @param locales - Optional array of supported locales. Defaults to configured locales.
+* @param defaultLocale - The default locale. Defaults to configured default locale.
+* @param mode - URL routing mode for locale handling. Defaults to configured mode.
+* @returns The localized URL for the current locale.
+*/
+const getLocalizedUrl = (url, currentLocale, locales = (() => {
+	var _configuration$intern;
+	return configuration === null || configuration === void 0 || (_configuration$intern = configuration.internationalization) === null || _configuration$intern === void 0 ? void 0 : _configuration$intern.locales;
+})(), defaultLocale = configuration === null || configuration === void 0 || (_configuration$intern2 = configuration.internationalization) === null || _configuration$intern2 === void 0 ? void 0 : _configuration$intern2.defaultLocale, mode = configuration === null || configuration === void 0 || (_configuration$routin$1 = configuration.routing) === null || _configuration$routin$1 === void 0 ? void 0 : _configuration$routin$1.mode) => {
+	return getMultilingualUrls(url, locales, defaultLocale, mode)[currentLocale] ?? url;
+};
+
+//#endregion
+//#region src/localization/localeMapper.ts
+var _configuration$routin, _configuration$routin2, _configuration$routin3;
+/**
+* Determine if the locale should be prefixed in the URL based on routing mode
+*/
+const shouldPrefixLocale = (locale, defaultLocale, mode) => {
+	if (mode === "no-prefix" || mode === "search-params") return false;
+	if (mode === "prefix-all") return true;
+	return locale !== defaultLocale;
+};
+/**
+* Map the locale data to an array of objects
+*
+* @example
+* ```ts
+* const routes = localeMap((localizedData) =>
+* ({
+*    path: localizedData.urlPrefix,
+*    name: localizedData.locale,
+*    isDefault: localizedData.isDefault,
+*    locales: localizedData.locales,
+*    defaultLocale: localizedData.defaultLocale,
+*  }),
+* );
+*
+* // Result
+* [
+*   { path: '/', name: 'en', isDefault: true, locales: ['en'], defaultLocale: 'en', urlPrefix: '' },
+*   { path: '/fr', name: 'fr', isDefault: false, locales: ['fr'], defaultLocale: 'en', urlPrefix: '/fr' },
+*   { path: '/es', name: 'es', isDefault: false, locales: ['es'], defaultLocale: 'en', urlPrefix: '/es' },
+* ]
+* ```
+*
+* @param mapper - The mapper function that returns an object
+* @returns An array of objects
+*/
+const localeMap = (mapper, locales = (() => {
+	return configuration === null || configuration === void 0 ? void 0 : configuration.internationalization.locales;
+})() ?? [], defaultLocale = (configuration === null || configuration === void 0 ? void 0 : configuration.internationalization.defaultLocale) ?? Locales.ENGLISH, mode = (configuration === null || configuration === void 0 || (_configuration$routin = configuration.routing) === null || _configuration$routin === void 0 ? void 0 : _configuration$routin.mode) ?? "prefix-no-default") => (locales ?? []).map((locale) => mapper({
+	locale,
+	defaultLocale,
+	locales,
+	isDefault: locale === defaultLocale,
+	urlPrefix: shouldPrefixLocale(locale, defaultLocale, mode) ? `/${locale}` : ""
+}));
+/**
+* Flatten the locale map into a single array of objects
+*
+* @example
+* ```ts
+* const routes = localeMap((localizedData) =>
+* [{
+*    path: localizedData.urlPrefix,
+*    name: localizedData.locale,
+*    isDefault: localizedData.isDefault,
+*    locales: localizedData.locales,
+*    defaultLocale: localizedData.defaultLocale,
+*  }],
+* );
+*
+* // Result
+* [
+*   path: '/', name: 'en', isDefault: true, locales: ['en'], defaultLocale: 'en', urlPrefix: '' ,
+*   path: '/fr', name: 'fr', isDefault: false, locales: ['fr'], defaultLocale: 'en', urlPrefix: '/fr' ,
+*   path: '/es', name: 'es', isDefault: false, locales: ['es'], defaultLocale: 'en', urlPrefix: '/es' ,
+* ]
+* ```
+*
+* @param mapper - The mapper function that returns an array of objects
+* @returns An array of objects
+*/
+const localeFlatMap = (mapper, locales = (() => {
+	return configuration === null || configuration === void 0 ? void 0 : configuration.internationalization.locales;
+})() ?? [], defaultLocale = (configuration === null || configuration === void 0 ? void 0 : configuration.internationalization.defaultLocale) ?? Locales.ENGLISH, mode = (configuration === null || configuration === void 0 || (_configuration$routin2 = configuration.routing) === null || _configuration$routin2 === void 0 ? void 0 : _configuration$routin2.mode) ?? "prefix-no-default") => locales.flatMap((locale) => mapper({
+	locale,
+	defaultLocale,
+	locales,
+	isDefault: locale === defaultLocale,
+	urlPrefix: shouldPrefixLocale(locale, defaultLocale, mode) ? `/${locale}` : ""
+}));
+/**
+* Creates a record object mapping locales to values transformed by the mapper function
+*
+* @example
+* ```ts
+* const translations = localeRecord(({ locale }) =>
+*   require(`./translations/${locale}.json`)
+* );
+*
+* // Result
+*
+*   en: ... , // Content of translations/en.json
+*   fr: ... , // Content of translations/fr.json
+*   es: ...
+*
+* ```
+*
+* @param mapper - Function that takes locale data and returns a value for that locale
+* @param locales - Array of locale codes to map over (defaults to configured locales)
+* @param defaultLocale - The default locale (defaults to configured default)
+* @param mode - URL routing mode for locale handling (defaults to configured value)
+* @returns Record mapping locale codes to mapped values
+*/
+const localeRecord = (mapper, locales = (() => {
+	return configuration === null || configuration === void 0 ? void 0 : configuration.internationalization.locales;
+})() ?? [], defaultLocale = (configuration === null || configuration === void 0 ? void 0 : configuration.internationalization.defaultLocale) ?? Locales.ENGLISH, mode = (configuration === null || configuration === void 0 || (_configuration$routin3 = configuration.routing) === null || _configuration$routin3 === void 0 ? void 0 : _configuration$routin3.mode) ?? "prefix-no-default") => (locales ?? []).reduce((acc, locale) => {
+	acc[locale] = mapper({
+		locale,
+		defaultLocale,
+		locales,
+		isDefault: locale === defaultLocale,
+		urlPrefix: shouldPrefixLocale(locale, defaultLocale, mode) ? `/${locale}` : ""
+	});
+	return acc;
+}, {});
+
+//#endregion
+//#region src/utils/isSameKeyPath.ts
+const isSameKeyPath = (keyPath1, keyPath2) => keyPath1.every((element, index) => keyPath2[index] && keyPath2[index].key === element.key && keyPath2[index].type === element.type);
+
+//#endregion
+export { CachedIntl, CachedIntl as Intl, LocaleStorage, buildMaskPlugin, checkIsURLAbsolute, checkMissingLocalesPlugin, compact, condition as cond, conditionPlugin, createCachedIntl, currency, date, deepTransformNode, editDictionaryByKeyPath, enumeration as enu, enumerationPlugin, filePlugin, filterMissingTranslationsOnlyPlugin, filterTranslationsOnlyPlugin, findMatchingCondition, gender, genderPlugin, getBrowserLocale, getCondition, getContent, getContentNodeByKeyPath, getDefaultNode, getDictionary, getEmptyNode, getEnumeration, getFilterMissingTranslationsContent, getFilterMissingTranslationsDictionary, getFilterTranslationsOnlyContent, getFilterTranslationsOnlyDictionary, getFilteredLocalesContent, getFilteredLocalesDictionary, getHTMLTextDir, getInsertionValues, getIntlayer, getLocaleFromPath, getLocaleFromStorage, getLocaleLang, getLocaleName, getLocalizedContent, getLocalizedUrl, getMarkdownMetadata, getMaskContent, getMissingLocalesContent, getMissingLocalesContentFromDictionary, getMultilingualDictionary, getMultilingualUrls, getNesting, getNodeChildren, getNodeType, getPathWithoutLocale, getPerLocaleDictionary, getReplacedValuesContent, getSplittedContent, getSplittedDictionaryContent, getStorageAttributes, getTranslation, insertion as insert, insertContentInDictionary, insertionPlugin, isSameKeyPath, isValidElement, list, localeDetector, localeFlatMap, localeMap, localeRecord, localeResolver, localeStorageOptions, markdown as md, mergeDictionaries, nesting as nest, nestedPlugin, normalizeDictionaries, normalizeDictionary, number, orderDictionaries, parseYaml, percentage, relativeTime, removeContentNodeByKeyPath, renameContentNodeByKeyPath, setLocaleInStorage, translation as t, translationPlugin, units, updateNodeChildren };