intlayer-editor 8.4.10 → 8.5.0

package/client/dist/assets/{index-C5gyL3b-.js → index-CDOIYDRk.js}

@@ -1,9 +1,8 @@
-const __vite__mapDeps=(i,m=__vite__mapDeps,d=(m.f||(m.f=["assets/markdown-B_VAQu_B.js","assets/chunk-C0u3WHrm.js","assets/markdown-DJYH1etf.js","assets/html-CC2iD1GB.js","assets/react-BI_C_976.js","assets/CodeBlockShiki-CjD7FtGt.js","assets/preload-helper-B4JcPOPd.js","assets/jsx-runtime-BkWmzJHO.js","assets/dist-B9LA40uC.js"])))=>i.map(i=>d[i]);
+const __vite__mapDeps=(i,m=__vite__mapDeps,d=(m.f||(m.f=["assets/HTMLRendererPlugin-B6Eld7in.js","assets/chunk-C0u3WHrm.js","assets/react-BI_C_976.js","assets/CodeBlockShiki-D9plzEFQ.js","assets/preload-helper-B4JcPOPd.js","assets/jsx-runtime-BkWmzJHO.js","assets/dist-D8J9DkzO.js"])))=>i.map(i=>d[i]);
 import { a as __toESM, i as __toCommonJS, n as __esmMin, r as __exportAll, t as __commonJSMin } from "./chunk-C0u3WHrm.js";
 import { t as require_react } from "./react-BI_C_976.js";
 import { t as require_jsx_runtime } from "./jsx-runtime-BkWmzJHO.js";
 import { t as __vitePreload } from "./preload-helper-B4JcPOPd.js";
-import { n as compile } from "./markdown-B_VAQu_B.js";
 //#region \0vite/modulepreload-polyfill.js
 (function polyfill() {
 	const relList = document.createElement("link").relList;
@@ -9516,8 +9515,8 @@ var require_react_dom_client_production = /* @__PURE__ */ __commonJSMin(((export
 	};
 }));
 //#endregion
-//#region ../../node_modules/.bun/react-dom@19.2.4+b1ab299f0a400331/node_modules/react-dom/client.js
-var require_client = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+//#region .intlayer/config/configuration.mjs
+var import_client = (/* @__PURE__ */ __commonJSMin(((exports, module) => {
 	function checkDCE() {
 		if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ === "undefined" || typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE !== "function") return;
 		try {
@@ -9528,8 +9527,9 @@ var require_client = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	}
 	checkDCE();
 	module.exports = require_react_dom_client_production();
-}));
-var configuration_default = {
+})))();
+var import_react = /* @__PURE__ */ __toESM(require_react(), 1);
+var configuration = {
 	internationalization: {
 		"locales": [
 			"en",
@@ -9548,6 +9548,11 @@ var configuration_default = {
 		],
 		"defaultLocale": "en"
 	},
+	routing: {
+		"mode": "prefix-no-default",
+		"storage": ["cookie", "header"],
+		"basePath": ""
+	},
 	editor: {
 		"editorURL": "http://localhost:8000",
 		"cmsURL": "https://app.intlayer.org",
@@ -9563,28 +9568,15 @@ var configuration_default = {
 		"mode": "default",
 		"prefix": "\x1B[38;5;239m[intlayer] \x1B[0m"
 	},
-	routing: {
-		"mode": "prefix-no-default",
-		"storage": ["cookie", "header"],
-		"basePath": ""
-	},
 	metadata: {
 		"name": "Intlayer",
-		"version": "8.4.10",
+		"version": "8.5.0",
 		"doc": "https://intlayer.org/docs"
 	}
 };
 //#endregion
-//#region ../@intlayer/editor/dist/esm/isEnabled.mjs
-var isEnabled = configuration_default.editor?.enabled && typeof window !== "undefined" && window.self !== window.top;
-//#endregion
 //#region ../react-intlayer/dist/esm/editor/ContentSelector.mjs
-var import_react = /* @__PURE__ */ __toESM(require_react(), 1);
 var ContentSelector = ({ children, dictionaryKey, keyPath }) => {
-	if (isEnabled) return (0, import_react.createElement)("intlayer-content-selector-wrapper", {
-		"key-path": JSON.stringify(keyPath),
-		"dictionary-key": dictionaryKey
-	}, children);
 	return children;
 };
 //#endregion
@@ -9916,7 +9908,7 @@ var createSafeFallback = (path = "") => {
 var getIntlayer = (key, locale, plugins) => {
 	const dictionary = getDictionaries()[key];
 	if (!dictionary) {
-		getAppLogger(configuration_default)(`Dictionary ${colorizeKey(key)} was not found. Using fallback proxy.`, {
+		getAppLogger(configuration)(`Dictionary ${colorizeKey(key)} was not found. Using fallback proxy.`, {
 			level: "warn",
 			isVerbose: true
 		});
@@ -10184,11 +10176,11 @@ var filePlugin = {
 //#endregion
 //#region ../@intlayer/core/dist/esm/interpreter/getContent/getContent.mjs
 var getBasePlugins = (locale, fallback = true) => [
-	translationPlugin(locale ?? configuration_default.internationalization.defaultLocale, fallback ? configuration_default.internationalization.defaultLocale : void 0),
+	translationPlugin(locale ?? configuration.internationalization.defaultLocale, fallback ? configuration.internationalization.defaultLocale : void 0),
 	enumerationPlugin,
 	conditionPlugin,
 	insertionPlugin$1,
-	nestedPlugin(locale ?? configuration_default.internationalization.defaultLocale),
+	nestedPlugin(locale ?? configuration.internationalization.defaultLocale),
 	filePlugin,
 	genderPlugin
 ];
@@ -10273,13 +10265,1832 @@ var splitInsertionTemplate = (template, values = {}) => {
 	};
 };
 //#endregion
+//#region ../@intlayer/core/dist/esm/utils/parseYaml.mjs
+var 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 ../@intlayer/core/dist/esm/transpiler/markdown/getMarkdownMetadata.mjs
+var getMarkdownMetadata = (markdown) => {
+	try {
+		const lines = markdown.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 {
+		return {};
+	}
+};
+//#endregion
+//#region ../@intlayer/core/dist/esm/markdown/constants.mjs
+/**
+* Analogous to `node.type`. Please note that the values here may change at any time,
+* so do not hard code against the value directly.
+*/
+var RuleType = {
+	blockQuote: "0",
+	breakLine: "1",
+	breakThematic: "2",
+	codeBlock: "3",
+	codeFenced: "4",
+	codeInline: "5",
+	footnote: "6",
+	footnoteReference: "7",
+	gfmTask: "8",
+	heading: "9",
+	headingSetext: "10",
+	htmlBlock: "11",
+	htmlComment: "12",
+	htmlSelfClosing: "13",
+	customComponent: "34",
+	image: "14",
+	link: "15",
+	linkAngleBraceStyleDetector: "16",
+	linkBareUrlDetector: "17",
+	newlineCoalescer: "19",
+	orderedList: "20",
+	paragraph: "21",
+	ref: "22",
+	refImage: "23",
+	refLink: "24",
+	table: "25",
+	tableSeparator: "26",
+	text: "27",
+	textBolded: "28",
+	textEmphasized: "29",
+	textEscaped: "30",
+	textMarked: "31",
+	textStrikethroughed: "32",
+	unorderedList: "33"
+};
+/**
+* Priority levels for rule ordering.
+*/
+var Priority = {
+	MAX: 0,
+	HIGH: 1,
+	MED: 2,
+	LOW: 3,
+	MIN: 4
+};
+/**
+* Map of HTML attributes to their JSX prop equivalents.
+* Some renderers use camelCase for certain attributes.
+*/
+var ATTRIBUTE_TO_NODE_PROP_MAP = [
+	"allowFullScreen",
+	"allowTransparency",
+	"autoComplete",
+	"autoFocus",
+	"autoPlay",
+	"cellPadding",
+	"cellSpacing",
+	"charSet",
+	"classId",
+	"colSpan",
+	"contentEditable",
+	"contextMenu",
+	"crossOrigin",
+	"encType",
+	"formAction",
+	"formEncType",
+	"formMethod",
+	"formNoValidate",
+	"formTarget",
+	"frameBorder",
+	"hrefLang",
+	"inputMode",
+	"keyParams",
+	"keyType",
+	"marginHeight",
+	"marginWidth",
+	"maxLength",
+	"mediaGroup",
+	"minLength",
+	"noValidate",
+	"radioGroup",
+	"readOnly",
+	"rowSpan",
+	"spellCheck",
+	"srcDoc",
+	"srcLang",
+	"srcSet",
+	"tabIndex",
+	"useMap"
+].reduce((obj, x) => {
+	obj[x.toLowerCase()] = x;
+	return obj;
+}, {
+	class: "className",
+	for: "htmlFor"
+});
+/**
+* Default HTML entity to unicode mappings.
+*/
+var NAMED_CODES_TO_UNICODE = {
+	amp: "&",
+	apos: "'",
+	gt: ">",
+	lt: "<",
+	nbsp: "\xA0",
+	quot: "“"
+};
+/** HTML elements that should not have their content processed */
+var DO_NOT_PROCESS_HTML_ELEMENTS = [
+	"style",
+	"script",
+	"pre"
+];
+/** Attributes that require URL sanitization */
+var ATTRIBUTES_TO_SANITIZE = [
+	"src",
+	"href",
+	"data",
+	"formAction",
+	"srcDoc",
+	"action"
+];
+/** Attribute extractor regex */
+var ATTR_EXTRACTOR_R = /([-A-Z0-9_:]+)(?:\s*=\s*(?:(?:"((?:\\.|[^"])*)")|(?:'((?:\\.|[^'])*)')|(?:\{((?:\\.|{[^}]*?}|[^}])*)\})))?/gi;
+/** Block end detection */
+var BLOCK_END_R = /\n{2,}$/;
+/** Blockquote patterns */
+var BLOCKQUOTE_R = /^(\s*>[\s\S]*?)(?=\n\n|$)/;
+var BLOCKQUOTE_TRIM_LEFT_MULTILINE_R = /^ *> ?/gm;
+var BLOCKQUOTE_ALERT_R = /^(?:\[!([^\]]*)\]\n)?([\s\S]*)/;
+/** Line break patterns */
+var BREAK_LINE_R = /^ {2,}\n/;
+var BREAK_THEMATIC_R = /^(?:([-*_])( *\1){2,}) *(?:\n *)+\n/;
+/** Code block patterns */
+var CODE_BLOCK_FENCED_R = /^(?: {1,3})?(`{3,}|~{3,}) *(\S+)? *([^\n]*?)?\n([\s\S]*?)(?:\1\n?|$)/;
+var CODE_BLOCK_R = /^(?: {4}[^\n]+\n*)+(?:\n *)+\n?/;
+var CODE_INLINE_R = /^(`+)((?:\\`|(?!\1)`|[^`])+)\1/;
+/** Newline patterns */
+var CONSECUTIVE_NEWLINE_R = /^(?:\n *)*\n/;
+var CR_NEWLINE_R = /\r\n?/g;
+/** Footnote patterns */
+var FOOTNOTE_R = /^\[\^([^\]]+)](:(.*)((\n+ {4,}.*)|(\n(?!\[\^).+))*)/;
+var FOOTNOTE_REFERENCE_R = /^\[\^([^\]]+)]/;
+/** Form feed */
+var FORMFEED_R = /\f/g;
+/** Front matter */
+var FRONT_MATTER_R = /^---[ \t]*\n(.|\n)*?\n---[ \t]*\n/;
+/** GFM task */
+var GFM_TASK_R = /^\s*?\[(x|\s)\]/;
+/** Heading patterns */
+var HEADING_R = /^ *(#{1,6}) *([^\n]+?)(?: +#*)?(?:\n *)*(?:\n|$)/;
+var HEADING_ATX_COMPLIANT_R = /^ *(#{1,6}) +([^\n]+?)(?: +#*)?(?:\n *)*(?:\n|$)/;
+var HEADING_SETEXT_R = /^([^\n]+)\n *(=|-)\2{2,} *\n/;
+/** HTML patterns */
+var HTML_BLOCK_ELEMENT_R = /^ *(?!<[a-zA-Z][^ >/]* ?\/>)<([a-zA-Z][^ >/]*) ?((?:[^>]*[^/])?)>\n?(\s*(?:<\1[^>]*?>[\s\S]*?<\/\1>|(?!<\1\b)[\s\S])*?)<\/\1>(?!<\/\1>)\n*/i;
+var HTML_CHAR_CODE_R = /&([a-z0-9]+|#[0-9]{1,6}|#x[0-9a-fA-F]{1,6});/gi;
+var HTML_COMMENT_R = /^<!--[\s\S]*?(?:-->)/;
+var HTML_CUSTOM_ATTR_R = /^(data|aria|x)-[a-z_][a-z\d_.-]*$/;
+var HTML_SELF_CLOSING_ELEMENT_R = /^ *<([a-zA-Z][a-zA-Z0-9:]*)(?:\s+((?:<.*?>|[^>])*))?\/?>(?!<\/\1>)(\s*\n)?/i;
+/** Custom component pattern */
+var CUSTOM_COMPONENT_R = /^ *<([A-Z][a-zA-Z0-9]*)(?:\s+((?:<.*?>|[^>])*))?>\n?(\s*(?:<\1[^>]*?>[\s\S]*?<\/\1>|(?!<\1\b)[\s\S])*?)<\/\1>(?!<\/\1>)\n*/;
+/** Interpolation */
+var INTERPOLATION_R = /^\{.*\}$/;
+/** Link patterns */
+var LINK_AUTOLINK_BARE_URL_R = /^(https?:\/\/[^\s<]+[^<.,:;"')\]\s])/;
+var LINK_AUTOLINK_R = /^<([^ >]+[:@/][^ >]+)>/;
+var CAPTURE_LETTER_AFTER_HYPHEN = /-([a-z])?/gi;
+/** Table patterns */
+var NP_TABLE_R = /^(\|.*)\n(?: *(\|? *[-:]+ *\|[-| :]*)\n((?:.*\|.*\n)*))?\n?/;
+var TABLE_TRIM_PIPES = /(^ *\||\| *$)/g;
+var TABLE_CENTER_ALIGN = /^ *:-+: *$/;
+var TABLE_LEFT_ALIGN = /^ *:-+ *$/;
+var TABLE_RIGHT_ALIGN = /^ *-+: *$/;
+/** Paragraph */
+var PARAGRAPH_R = /^[^\n]+(?: {2}\n|\n{2,})/;
+/** Reference patterns */
+var REFERENCE_IMAGE_OR_LINK = /^\[([^\]]*)\]:\s+<?([^\s>]+)>?\s*("([^"]*)")?/;
+var REFERENCE_IMAGE_R = /^!\[([^\]]*)\] ?\[([^\]]*)\]/;
+var REFERENCE_LINK_R = /^\[([^\]]*)\] ?\[([^\]]*)\]/;
+/** Block detection */
+var SHOULD_RENDER_AS_BLOCK_R = /(\n|^[-*]\s|^#|^ {2,}|^-{2,}|^>\s)/;
+/** Tab and whitespace */
+var TAB_R = /\t/g;
+var TRIM_STARTING_NEWLINES = /^\n+/;
+var HTML_LEFT_TRIM_AMOUNT_R = /^\n*([ \t]*)/;
+/** List patterns */
+var LIST_LOOKBEHIND_R = /(?:^|\n)( *)$/;
+var ORDERED_LIST_BULLET = "(?:\\d+\\.)";
+var UNORDERED_LIST_BULLET = "(?:[*+-])";
+/** Text formatting patterns */
+var TEXT_ESCAPED_R = /^\\([^0-9A-Za-z\s])/;
+var UNESCAPE_R = /\\([^0-9A-Za-z\s])/g;
+var TEXT_PLAIN_R = /^[\s\S](?:(?! {2}\n|[0-9]\.|http)[^=*_~\-\n:<`\\[!])*/;
+/** Shortcode pattern */
+var SHORTCODE_R = /^(:[a-zA-Z0-9-_]+:)/;
+/**
+* Ensure there's at least one more instance of the delimiter later
+* in the current sequence.
+*/
+var LOOKAHEAD = (double) => `(?=[\\s\\S]+?\\1${double ? "\\1" : ""})`;
+/**
+* For inline formatting, this partial attempts to ignore characters that
+* may appear in nested formatting.
+*/
+var INLINE_SKIP_R = "((?:\\[.*?\\][([].*?[)\\]]|<.*?>(?:.*?<.*?>)?|`.*?`|\\\\[^\\s]|[\\s\\S])+?)";
+/** Bold text pattern */
+var TEXT_BOLD_R = new RegExp(`^([*_])\\1${LOOKAHEAD(1)}${INLINE_SKIP_R}\\1\\1(?!\\1)`);
+/** Emphasized text pattern */
+var TEXT_EMPHASIZED_R = new RegExp(`^([*_])${LOOKAHEAD(0)}${INLINE_SKIP_R}\\1(?!\\1)`);
+/** Marked text pattern */
+var TEXT_MARKED_R = new RegExp(`^(==)${LOOKAHEAD(0)}${INLINE_SKIP_R}\\1`);
+/** Strikethrough text pattern */
+var TEXT_STRIKETHROUGHED_R = new RegExp(`^(~~)${LOOKAHEAD(0)}${INLINE_SKIP_R}\\1`);
+var generateListItemPrefix = (type) => {
+	return "( *)(" + (type === 1 ? ORDERED_LIST_BULLET : UNORDERED_LIST_BULLET) + ") +";
+};
+var ORDERED_LIST_ITEM_PREFIX = generateListItemPrefix(1);
+var UNORDERED_LIST_ITEM_PREFIX = generateListItemPrefix(2);
+var generateListItemPrefixRegex = (type) => {
+	return new RegExp("^" + (type === 1 ? ORDERED_LIST_ITEM_PREFIX : UNORDERED_LIST_ITEM_PREFIX));
+};
+var ORDERED_LIST_ITEM_PREFIX_R = generateListItemPrefixRegex(1);
+var UNORDERED_LIST_ITEM_PREFIX_R = generateListItemPrefixRegex(2);
+var generateListItemRegex = (type) => {
+	return new RegExp("^" + (type === 1 ? ORDERED_LIST_ITEM_PREFIX : UNORDERED_LIST_ITEM_PREFIX) + "[^\\n]*(?:\\n(?!\\1" + (type === 1 ? ORDERED_LIST_BULLET : UNORDERED_LIST_BULLET) + " )[^\\n]*)*(\\n|$)", "gm");
+};
+var ORDERED_LIST_ITEM_R = generateListItemRegex(1);
+var UNORDERED_LIST_ITEM_R = generateListItemRegex(2);
+var generateListRegex = (type) => {
+	const bullet = type === 1 ? ORDERED_LIST_BULLET : UNORDERED_LIST_BULLET;
+	return new RegExp("^( *)(" + bullet + ") [\\s\\S]+?(?:\\n{2,}(?! )(?!\\1" + bullet + " (?!" + bullet + " ))\\n*|\\s*\\n*$)");
+};
+var ORDERED_LIST_R = generateListRegex(1);
+var UNORDERED_LIST_R = generateListRegex(2);
+//#endregion
+//#region ../@intlayer/core/dist/esm/markdown/utils.mjs
+/**
+* Trim trailing whitespace from a string.
+*/
+var trimEnd = (str) => {
+	let end = str.length;
+	while (end > 0 && str[end - 1] <= " ") end--;
+	return str.slice(0, end);
+};
+/**
+* Check if string starts with prefix.
+*/
+var startsWith = (str, prefix) => {
+	return str.startsWith(prefix);
+};
+/**
+* Remove symmetrical leading and trailing quotes.
+*/
+var unquote = (str) => {
+	const first = str[0];
+	if ((first === "\"" || first === "'") && str.length >= 2 && str[str.length - 1] === first) return str.slice(1, -1);
+	return str;
+};
+/**
+* Unescape backslash-escaped characters.
+*/
+var unescapeString = (rawString) => rawString ? rawString.replace(UNESCAPE_R, "$1") : rawString;
+/**
+* Join class names, filtering out falsy values.
+*/
+var cx$1 = (...args) => args.filter(Boolean).join(" ");
+/**
+* Get a nested property from an object using dot notation.
+*/
+var get$2 = (src, path, fb) => {
+	let ptr = src;
+	const frags = path.split(".");
+	while (frags.length) {
+		ptr = ptr[frags[0]];
+		if (ptr === void 0) break;
+		else frags.shift();
+	}
+	return ptr ?? fb;
+};
+/**
+* Convert a string to a URL-safe slug.
+* Based on https://stackoverflow.com/a/18123682/1141611
+*/
+var slugify$1 = (str) => str.replace(/[ÀÁÂÃÄÅàáâãäåæÆ]/g, "a").replace(/[çÇ]/g, "c").replace(/[ðÐ]/g, "d").replace(/[ÈÉÊËéèêë]/g, "e").replace(/[ÏïÎîÍíÌì]/g, "i").replace(/[Ññ]/g, "n").replace(/[øØœŒÕõÔôÓóÒò]/g, "o").replace(/[ÜüÛûÚúÙù]/g, "u").replace(/[ŸÿÝý]/g, "y").replace(/[^a-z0-9- ]/gi, "").replace(/ /gi, "-").toLowerCase();
+var SANITIZE_R = /(javascript|vbscript|data(?!:image)):/i;
+/**
+* Sanitize URLs to prevent XSS attacks.
+* Returns null if the URL is unsafe.
+*/
+var sanitizer = (input) => {
+	try {
+		const decoded = decodeURIComponent(input).replace(/[^A-Za-z0-9/:]/g, "");
+		if (SANITIZE_R.test(decoded)) {
+			console.warn("Input contains an unsafe JavaScript/VBScript/data expression, it will not be rendered.", decoded);
+			return null;
+		}
+	} catch (_e) {
+		console.warn("Input could not be decoded due to malformed syntax or characters, it will not be rendered.", input);
+		return null;
+	}
+	return input;
+};
+/**
+* Normalize whitespace in source string.
+*/
+var normalizeWhitespace = (source) => {
+	const start = performance.now();
+	const result = source.replace(CR_NEWLINE_R, "\n").replace(FORMFEED_R, "").replace(TAB_R, "    ");
+	const duration = performance.now() - start;
+	if (duration > 20) console.log(`normalizeWhitespace: ${duration.toFixed(3)}ms, source length: ${source.length}`);
+	return result;
+};
+/**
+* Safely remove a uniform leading indentation from lines, but do NOT touch
+* the content inside fenced code blocks (``` or ~~~).
+*/
+var trimLeadingWhitespaceOutsideFences = (text, whitespace) => {
+	const start = performance.now();
+	if (!whitespace) return text;
+	const lines = text.split("\n");
+	let inFence = false;
+	let fenceToken = null;
+	const isFenceLine = (line) => line.match(/^\s*(`{3,}|~{3,})/);
+	const maybeToggleFence = (line) => {
+		const m = isFenceLine(line);
+		if (!m) return;
+		const token = m[1];
+		if (!inFence) {
+			inFence = true;
+			fenceToken = token;
+		} else if (fenceToken && line.includes(fenceToken)) {
+			inFence = false;
+			fenceToken = null;
+		}
+	};
+	const result = lines.map((line) => {
+		if (isFenceLine(line)) {
+			const trimmedFenceLine = line.startsWith(whitespace) ? line.slice(whitespace.length) : line;
+			maybeToggleFence(line);
+			return trimmedFenceLine;
+		}
+		if (inFence) return line;
+		return line.startsWith(whitespace) ? line.slice(whitespace.length) : line;
+	}).join("\n");
+	const duration = performance.now() - start;
+	if (duration > 20) console.log(`trimLeadingWhitespaceOutsideFences: ${duration.toFixed(3)}ms, text length: ${text.length}, lines count: ${lines.length}`);
+	return result;
+};
+/**
+* Normalize HTML attribute key to JSX prop name.
+*/
+var normalizeAttributeKey = (key) => {
+	if (key.indexOf("-") !== -1 && key.match(HTML_CUSTOM_ATTR_R) === null) key = key.replace(CAPTURE_LETTER_AFTER_HYPHEN, (_, letter) => {
+		return letter.toUpperCase();
+	});
+	return key;
+};
+/**
+* Parse a CSS style string into an array of [key, value] tuples.
+*/
+var parseStyleAttribute = (styleString) => {
+	const start = performance.now();
+	const styles = [];
+	let buffer = "";
+	let inUrl = false;
+	let inQuotes = false;
+	let quoteChar = "";
+	if (!styleString) return styles;
+	for (let i = 0; i < styleString.length; i++) {
+		const char = styleString[i];
+		if ((char === "\"" || char === "'") && !inUrl) {
+			if (!inQuotes) {
+				inQuotes = true;
+				quoteChar = char;
+			} else if (char === quoteChar) {
+				inQuotes = false;
+				quoteChar = "";
+			}
+		}
+		if (char === "(" && buffer.endsWith("url")) inUrl = true;
+		else if (char === ")" && inUrl) inUrl = false;
+		if (char === ";" && !inQuotes && !inUrl) {
+			const declaration = buffer.trim();
+			if (declaration) {
+				const colonIndex = declaration.indexOf(":");
+				if (colonIndex > 0) {
+					const key = declaration.slice(0, colonIndex).trim();
+					const value = declaration.slice(colonIndex + 1).trim();
+					styles.push([key, value]);
+				}
+			}
+			buffer = "";
+		} else buffer += char;
+	}
+	const declaration = buffer.trim();
+	if (declaration) {
+		const colonIndex = declaration.indexOf(":");
+		if (colonIndex > 0) {
+			const key = declaration.slice(0, colonIndex).trim();
+			const value = declaration.slice(colonIndex + 1).trim();
+			styles.push([key, value]);
+		}
+	}
+	const duration = performance.now() - start;
+	if (duration > 20) console.log(`parseStyleAttribute: ${duration.toFixed(3)}ms, styleString length: ${styleString.length}, styles count: ${styles.length}`);
+	return styles;
+};
+/**
+* Convert an attribute value to a Node prop value.
+*/
+var attributeValueToNodePropValue = (tag, key, value, sanitizeUrlFn) => {
+	if (key === "style") return parseStyleAttribute(value).reduce((styles, [styleKey, styleValue]) => {
+		const camelCasedKey = styleKey.replace(/(-[a-z])/g, (substr) => substr[1].toUpperCase());
+		styles[camelCasedKey] = sanitizeUrlFn(styleValue, tag, styleKey);
+		return styles;
+	}, {});
+	else if (ATTRIBUTES_TO_SANITIZE.indexOf(key) !== -1) return sanitizeUrlFn(unescapeString(value), tag, key);
+	else if (value.match(INTERPOLATION_R)) value = unescapeString(value.slice(1, value.length - 1));
+	if (value === "true") return true;
+	else if (value === "false") return false;
+	return value;
+};
+/**
+* Parse table alignment from a separator row.
+*/
+var parseTableAlignCapture = (alignCapture) => {
+	if (TABLE_RIGHT_ALIGN.test(alignCapture)) return "right";
+	else if (TABLE_CENTER_ALIGN.test(alignCapture)) return "center";
+	else if (TABLE_LEFT_ALIGN.test(alignCapture)) return "left";
+	return "left";
+};
+/**
+* Parse table alignment row.
+*/
+var parseTableAlign = (source) => {
+	return source.replace(TABLE_TRIM_PIPES, "").split("|").map(parseTableAlignCapture);
+};
+/**
+* Parse a single table row.
+*/
+var parseTableRow = (source, parse, state, tableOutput) => {
+	const start = performance.now();
+	const prevInTable = state.inTable;
+	state.inTable = true;
+	const cells = [[]];
+	let acc = "";
+	const flush = () => {
+		if (!acc) return;
+		const cell = cells[cells.length - 1];
+		cell.push.apply(cell, parse(acc, state));
+		acc = "";
+	};
+	source.trim().split(/(`[^`]*`|\\\||\|)/).filter(Boolean).forEach((fragment, i, arr) => {
+		if (fragment.trim() === "|") {
+			flush();
+			if (tableOutput) {
+				if (i !== 0 && i !== arr.length - 1) cells.push([]);
+				return;
+			}
+		}
+		acc += fragment;
+	});
+	flush();
+	state.inTable = prevInTable;
+	const duration = performance.now() - start;
+	if (duration > 20) console.log(`parseTableRow: ${duration.toFixed(3)}ms, source length: ${source.length}, cells count: ${cells.length}`);
+	return cells;
+};
+/**
+* Parse table cells (multiple rows).
+*/
+var parseTableCells = (source, parse, state) => {
+	const start = performance.now();
+	const rowsText = source.trim().split("\n");
+	const result = rowsText.map((rowText) => parseTableRow(rowText, parse, state, true));
+	const duration = performance.now() - start;
+	if (duration > 20) console.log(`parseTableCells: ${duration.toFixed(3)}ms, source length: ${source.length}, rows count: ${rowsText.length}`);
+	return result;
+};
+/**
+* Check if a rule qualifies for the current source and state.
+*/
+var qualifies = (source, state, qualify) => {
+	if (Array.isArray(qualify)) {
+		for (let i = 0; i < qualify.length; i++) if (startsWith(source, qualify[i])) return true;
+		return false;
+	}
+	return qualify(source, state);
+};
+/**
+* Marks a matcher function as eligible for being run inside an inline context.
+*/
+var allowInline = (fn) => {
+	fn.inline = 1;
+	return fn;
+};
+/**
+* Creates a match function for an inline scoped element from a regex.
+*/
+var inlineRegex = (regex) => allowInline((source, state) => {
+	if (state.inline) return regex.exec(source);
+	else return null;
+});
+/**
+* Creates a match function for inline elements except links.
+*/
+var simpleInlineRegex = (regex) => allowInline((source, state) => {
+	if (state.inline || state.simple) return regex.exec(source);
+	else return null;
+});
+/**
+* Creates a match function for a block scoped element from a regex.
+*/
+var blockRegex = (regex) => (source, state) => {
+	if (state.inline || state.simple) return null;
+	else return regex.exec(source);
+};
+/**
+* Creates a match function from a regex, ignoring block/inline scope.
+*/
+var anyScopeRegex = (fn) => allowInline((source, state) => {
+	if (typeof fn === "function") return fn(source, state);
+	return fn.exec(source);
+});
+/**
+* Parse inline content (including links).
+*/
+var parseInline = (parse, children, state) => {
+	const start = performance.now();
+	const isCurrentlyInline = state.inline ?? false;
+	const isCurrentlySimple = state.simple ?? false;
+	state.inline = true;
+	state.simple = true;
+	const result = parse(children, state);
+	state.inline = isCurrentlyInline;
+	state.simple = isCurrentlySimple;
+	const duration = performance.now() - start;
+	if (duration > 20) console.log(`parseInline: ${duration.toFixed(3)}ms, children length: ${children.length}, result count: ${result.length}`);
+	return result;
+};
+/**
+* Parse simple inline content (no links).
+*/
+var parseSimpleInline = (parse, children, state) => {
+	const start = performance.now();
+	const isCurrentlyInline = state.inline ?? false;
+	const isCurrentlySimple = state.simple ?? false;
+	state.inline = false;
+	state.simple = true;
+	const result = parse(children, state);
+	state.inline = isCurrentlyInline;
+	state.simple = isCurrentlySimple;
+	const duration = performance.now() - start;
+	if (duration > 20) console.log(`parseSimpleInline: ${duration.toFixed(3)}ms, children length: ${children.length}, result count: ${result.length}`);
+	return result;
+};
+/**
+* Parse block content.
+*/
+var parseBlock = (parse, children, state = {}) => {
+	const start = performance.now();
+	const isCurrentlyInline = state.inline || false;
+	state.inline = false;
+	const normalizedChildren = trimEnd(children);
+	const result = parse(/\n\n$/.test(normalizedChildren) === false ? normalizedChildren.endsWith("\n") ? `${normalizedChildren}\n` : `${normalizedChildren}\n\n` : normalizedChildren, state);
+	state.inline = isCurrentlyInline;
+	const duration = performance.now() - start;
+	if (duration > 20) console.log(`parseBlock: ${duration.toFixed(3)}ms, children length: ${children.length}, result count: ${result.length}`);
+	return result;
+};
+/**
+* Helper to parse capture group 2 as inline content.
+*/
+var parseCaptureInline = (capture, parse, state) => {
+	return { children: parseInline(parse, capture[2], state) };
+};
+/**
+* Helper that captures nothing (empty object).
+*/
+var captureNothing = () => ({});
+/**
+* Helper that renders nothing (null).
+*/
+var renderNothing = () => null;
+/**
+* Check if any regex in a list matches the input.
+*/
+var some = (regexes, input) => {
+	for (let i = 0; i < regexes.length; i++) if (regexes[i].test(input)) return true;
+	return false;
+};
+//#endregion
+//#region ../@intlayer/core/dist/esm/markdown/parser.mjs
+/**
+* Creates a parser for a given set of rules, with the precedence
+* specified as a list of rules.
+*
+* @param rules - An object containing rule type -> {match, order, parse} objects
+*                (lower order is higher precedence)
+*
+* @returns The resulting parse function
+*/
+var parserFor = (rules) => {
+	const start = performance.now();
+	const ruleList = Object.keys(rules);
+	ruleList.forEach((type) => {
+		const order = rules[type]._order;
+		if (typeof order !== "number" || !Number.isFinite(order)) console.warn(`intlayer: Invalid order for rule \`${type}\`: ${order}`);
+	});
+	ruleList.sort((a, b) => {
+		return rules[a]._order - rules[b]._order || (a < b ? -1 : 1);
+	});
+	const nestedParse = (source, state = {}) => {
+		const parseStart = performance.now();
+		const result = [];
+		state.prevCapture = state.prevCapture || "";
+		if (source.trim()) while (source) {
+			let i = 0;
+			while (i < ruleList.length) {
+				const ruleType = ruleList[i];
+				const rule = rules[ruleType];
+				if (rule._qualify && !qualifies(source, state, rule._qualify)) {
+					i++;
+					continue;
+				}
+				const matchStart = performance.now();
+				const capture = rule._match(source, state);
+				const matchDuration = performance.now() - matchStart;
+				if (matchDuration > 1) console.log(`${ruleType}._match: ${matchDuration.toFixed(3)}ms, source length: ${source.length}`);
+				if (capture?.[0]) {
+					source = source.substring(capture[0].length);
+					const ruleParseStart = performance.now();
+					const parsedAny = rule._parse(capture, nestedParse, state);
+					const ruleParseDuration = performance.now() - ruleParseStart;
+					if (ruleParseDuration > 1) console.log(`${ruleType}._parse: ${ruleParseDuration.toFixed(3)}ms, capture length: ${capture[0].length}`);
+					state.prevCapture = (state.prevCapture || "") + capture[0];
+					if (!parsedAny.type) parsedAny.type = ruleType;
+					result.push(parsedAny);
+					break;
+				}
+				i++;
+			}
+		}
+		const parseDuration = performance.now() - parseStart;
+		if (parseDuration > 1) console.log(`nestedParse: ${parseDuration.toFixed(3)}ms, source length: ${source.length}, result count: ${result.length}`);
+		return result;
+	};
+	const duration = performance.now() - start;
+	if (duration > 20) console.log(`parserFor: ${duration.toFixed(3)}ms, rules count: ${ruleList.length}`);
+	return (source, state) => nestedParse(normalizeWhitespace(source), state);
+};
+//#endregion
+//#region ../@intlayer/core/dist/esm/markdown/renderer.mjs
+/**
+* Creates a renderer for AST nodes.
+* Renamed from `reactFor` to be framework-agnostic.
+*
+* @param render - The render function to call for each node
+* @returns A function that renders AST to output
+*/
+var renderFor = (render) => (ast, state = {}) => {
+	const start = performance.now();
+	const patchedRender = (ast, state = {}) => renderFor(render)(ast, state);
+	if (Array.isArray(ast)) {
+		const oldKey = state.key;
+		const result = [];
+		let lastWasString = false;
+		let renderedIndex = 0;
+		for (let i = 0; i < ast.length; i++) {
+			const nodeOut = patchedRender(ast[i], {
+				...state,
+				key: renderedIndex
+			});
+			const isString = typeof nodeOut === "string";
+			if (isString && lastWasString) result[result.length - 1] = result[result.length - 1] + nodeOut;
+			else if (nodeOut !== null) {
+				result.push(nodeOut);
+				renderedIndex++;
+			}
+			lastWasString = isString;
+		}
+		state.key = oldKey;
+		const duration = performance.now() - start;
+		if (duration > 20) console.log(`renderFor (array): ${duration.toFixed(3)}ms, ast length: ${ast.length}`);
+		return result;
+	}
+	const result = render(ast, patchedRender, state);
+	const duration = performance.now() - start;
+	if (duration > 20) console.log(`renderFor (single): ${duration.toFixed(3)}ms, ast type: ${ast.type}`);
+	return result;
+};
+/**
+* Creates a renderer from rules with optional custom render hook.
+*
+* @param rules - The rules object containing _render functions
+* @param userRender - Optional custom render hook for full control
+* @returns A render function for AST nodes
+*/
+var createRenderer = (rules, userRender) => (ast, render, state) => {
+	const start = performance.now();
+	const renderer = rules[ast.type]?._render;
+	const result = userRender ? userRender(() => renderer?.(ast, render, state), ast, render, state) : renderer?.(ast, render, state);
+	const duration = performance.now() - start;
+	if (duration > 20) console.log(`createRenderer: ${duration.toFixed(3)}ms, ast type: ${ast.type}, hasUserRender: ${!!userRender}`);
+	return result;
+};
+//#endregion
+//#region ../@intlayer/core/dist/esm/markdown/compiler.mjs
+var IMAGE_R = /^!\[(.*?)\]\( *((?:\([^)]*\)|[^() ])*) *"?([^)"]*)?"?\)/;
+var LINK_R = new RegExp(`^\\[((?:\\[[^\\[\\]]*(?:\\[[^\\[\\]]*\\][^\\[\\]]*)*\\]|[^\\[\\]])*)\\]\\(\\s*<?((?:\\([^)]*\\)|[^\\s\\\\]|\\\\.)*?)>?(?:\\s+['"]([\\s\\S]*?)['"])?\\s*\\)`);
+var getTag$1 = (tag, components) => {
+	if (typeof tag !== "string") return tag;
+	let override = get$2(components, tag);
+	if (!override && typeof tag === "string") {
+		const lowercaseTag = tag.toLowerCase();
+		const key = Object.keys(components).find((k) => k.toLowerCase() === lowercaseTag);
+		if (key) override = get$2(components, key);
+	}
+	if (!override) return tag;
+	return override;
+};
+var createElementFactory = (ctx, options) => {
+	const { runtime, components = {} } = ctx;
+	const filteredTags = options.tagfilter ? [
+		"title",
+		"textarea",
+		"style",
+		"xmp",
+		"iframe",
+		"noembed",
+		"noframes",
+		"script",
+		"plaintext"
+	] : [];
+	return (tag, props, ...children) => {
+		if (typeof tag === "string" && filteredTags.includes(tag.toLowerCase())) return null;
+		const isStringTag = typeof tag === "string";
+		const className = cx$1(props?.className, props?.class);
+		const mergedProps = {};
+		let classNameHandled = false;
+		if (props) for (const key in props) {
+			const value = props[key];
+			if (value === void 0 || value === null) continue;
+			if (key === "className" || key === "class") {
+				if (!classNameHandled) {
+					if (className) mergedProps.className = className;
+					classNameHandled = true;
+				}
+			} else mergedProps[key] = value;
+		}
+		if (!classNameHandled && className) mergedProps.className = className;
+		let finalProps = mergedProps;
+		if (runtime.normalizeProps && isStringTag) finalProps = runtime.normalizeProps(tag, mergedProps);
+		const component = getTag$1(tag, components);
+		return runtime.createElement(component, finalProps, ...children.length === 1 ? [children[0]] : children);
+	};
+};
+var createRules = (createElement, ctx, options, footnotes, refs, attrStringToMap, containsBlockSyntax, nonParagraphBlockSyntaxes) => {
+	const slug = (input) => {
+		return ctx.slugify ? ctx.slugify(input, slugify$1) : slugify$1(input);
+	};
+	const sanitize = ctx.sanitizer ?? sanitizer;
+	const namedCodesToUnicode = ctx.namedCodesToUnicode ? {
+		...NAMED_CODES_TO_UNICODE,
+		...ctx.namedCodesToUnicode
+	} : NAMED_CODES_TO_UNICODE;
+	const generateListRule = (type) => {
+		const ordered = type === 1;
+		const LIST_R = ordered ? ORDERED_LIST_R : UNORDERED_LIST_R;
+		const LIST_ITEM_R = ordered ? ORDERED_LIST_ITEM_R : UNORDERED_LIST_ITEM_R;
+		const LIST_ITEM_PREFIX_R = ordered ? ORDERED_LIST_ITEM_PREFIX_R : UNORDERED_LIST_ITEM_PREFIX_R;
+		return {
+			_qualify: (source) => LIST_ITEM_PREFIX_R.test(source),
+			_match: allowInline((source, state) => {
+				const isStartOfLine = LIST_LOOKBEHIND_R.exec(state.prevCapture ?? "");
+				const isListAllowed = state.list ?? (!state.inline && !state.simple);
+				if (isStartOfLine && isListAllowed) {
+					const matchSource = (isStartOfLine[1] || "") + source;
+					return LIST_R.exec(matchSource);
+				}
+				return null;
+			}),
+			_order: Priority.HIGH,
+			_parse(capture, parse, state) {
+				const bullet = capture[2];
+				const startValue = ordered ? +bullet.slice(0, -1) : void 0;
+				const items = capture[0].replace(BLOCK_END_R, "\n").match(LIST_ITEM_R);
+				if (!items) return {
+					items: [],
+					ordered,
+					start: startValue
+				};
+				let lastItemWasAParagraph = false;
+				return {
+					items: items.map((item, i) => {
+						const prefixCapture = LIST_ITEM_PREFIX_R.exec(item);
+						const space = prefixCapture ? prefixCapture[0].length : 0;
+						const spaceRegex = new RegExp(`^ {1,${space}}`, "gm");
+						const content = item.replace(spaceRegex, "").replace(LIST_ITEM_PREFIX_R, "");
+						const isLastItem = i === items.length - 1;
+						const thisItemIsAParagraph = content.indexOf("\n\n") !== -1 || isLastItem && lastItemWasAParagraph;
+						lastItemWasAParagraph = thisItemIsAParagraph;
+						const oldStateInline = state.inline;
+						const oldStateList = state.list;
+						state.list = true;
+						let adjustedContent;
+						if (thisItemIsAParagraph) {
+							state.inline = false;
+							adjustedContent = `${trimEnd(content)}\n\n`;
+						} else {
+							state.inline = true;
+							adjustedContent = trimEnd(content);
+						}
+						const parsed = parse(adjustedContent, state);
+						state.inline = oldStateInline;
+						state.list = oldStateList;
+						return parsed;
+					}),
+					ordered,
+					start: startValue
+				};
+			},
+			_render(node, output, state = {}) {
+				const Tag = node.ordered ? "ol" : "ul";
+				const props = { key: state.key };
+				if (node.ordered && node.start != null) props.start = node.start;
+				return createElement(Tag, props, ...node.items.map((item, i) => createElement("li", { key: i }, output(item, state))));
+			}
+		};
+	};
+	const matchParagraph = (source, state) => {
+		if (state.inline || state.simple || state.inHTML && source.indexOf("\n\n") === -1 && state.prevCapture?.indexOf("\n\n") === -1) return null;
+		let start = 0;
+		while (true) {
+			const newlineIndex = source.indexOf("\n", start);
+			const line = source.slice(start, newlineIndex === -1 ? void 0 : newlineIndex + 1);
+			if (some(nonParagraphBlockSyntaxes, line)) break;
+			if (newlineIndex === -1 || !line.trim()) break;
+			start = newlineIndex + 1;
+		}
+		const match = source.slice(0, start);
+		if (match === "") return null;
+		const captured = trimEnd(match);
+		if (captured === "") return null;
+		return [
+			match,
+			void 0,
+			captured
+		];
+	};
+	return {
+		[RuleType.blockQuote]: {
+			_qualify: [">"],
+			_match: blockRegex(BLOCKQUOTE_R),
+			_order: Priority.HIGH,
+			_parse(capture, parse, state) {
+				const matchAlert = capture[0].replace(BLOCKQUOTE_TRIM_LEFT_MULTILINE_R, "").match(BLOCKQUOTE_ALERT_R);
+				const alert = matchAlert?.[1];
+				const content = matchAlert?.[2] ?? "";
+				return {
+					alert,
+					children: content.indexOf("\n") !== -1 ? parseBlock(parse, content, state) : parseInline(parse, content, state)
+				};
+			},
+			_render(node, output, state = {}) {
+				const props = { key: state.key };
+				if (node.alert) {
+					props.className = `markdown-alert-${slug(node.alert.toLowerCase())}`;
+					node.children.unshift({
+						attrs: {},
+						children: [{
+							type: RuleType.text,
+							text: node.alert
+						}],
+						noInnerParse: true,
+						type: RuleType.htmlBlock,
+						tag: "header"
+					});
+				}
+				return createElement("blockquote", props, output(node.children, state));
+			}
+		},
+		[RuleType.breakLine]: {
+			_qualify: ["  "],
+			_match: anyScopeRegex(BREAK_LINE_R),
+			_order: Priority.HIGH,
+			_parse: captureNothing,
+			_render(_, __, state = {}) {
+				return createElement("br", { key: state.key });
+			}
+		},
+		[RuleType.breakThematic]: {
+			_qualify: [
+				"--",
+				"__",
+				"**",
+				"- ",
+				"* ",
+				"_ "
+			],
+			_match: blockRegex(BREAK_THEMATIC_R),
+			_order: Priority.HIGH,
+			_parse: captureNothing,
+			_render(_, __, state = {}) {
+				return createElement("hr", { key: state.key });
+			}
+		},
+		[RuleType.codeBlock]: {
+			_qualify: ["    "],
+			_match: blockRegex(CODE_BLOCK_R),
+			_order: Priority.MAX,
+			_parse(capture) {
+				return {
+					type: RuleType.codeBlock,
+					lang: void 0,
+					text: unescapeString(trimEnd(capture[0].replace(/^ {4}/gm, "")))
+				};
+			},
+			_render(node, _, state = {}) {
+				const attrs = { ...node.attrs ?? {} };
+				const langClass = node.lang ? `lang-${node.lang}` : "lang-plaintext";
+				attrs.className = attrs.className ? `${attrs.className} ${langClass}` : langClass;
+				if (node.lang && !attrs.lang) attrs.lang = node.lang;
+				return createElement("pre", { key: state.key }, createElement("code", attrs, node.text));
+			}
+		},
+		[RuleType.codeFenced]: {
+			_qualify: ["```", "~~~"],
+			_match: blockRegex(CODE_BLOCK_FENCED_R),
+			_order: Priority.MAX,
+			_parse(capture) {
+				return {
+					attrs: attrStringToMap("code", capture[3] ?? ""),
+					lang: capture[2] || void 0,
+					text: capture[4],
+					type: RuleType.codeBlock
+				};
+			}
+		},
+		[RuleType.codeInline]: {
+			_qualify: ["`"],
+			_match: simpleInlineRegex(CODE_INLINE_R),
+			_order: Priority.LOW,
+			_parse(capture) {
+				return { text: unescapeString(capture[2]) };
+			},
+			_render(node, _, state = {}) {
+				return createElement("code", { key: state.key }, node.text);
+			}
+		},
+		[RuleType.footnote]: {
+			_qualify: ["[^"],
+			_match: blockRegex(FOOTNOTE_R),
+			_order: Priority.MAX,
+			_parse(capture) {
+				footnotes.push({
+					footnote: capture[2],
+					identifier: capture[1]
+				});
+				return {};
+			},
+			_render: renderNothing
+		},
+		[RuleType.footnoteReference]: {
+			_qualify: ["[^"],
+			_match: inlineRegex(FOOTNOTE_REFERENCE_R),
+			_order: Priority.HIGH,
+			_parse(capture) {
+				return {
+					target: `#${slug(capture[1])}`,
+					text: capture[1]
+				};
+			},
+			_render(node, _, state = {}) {
+				return createElement("a", {
+					key: state.key,
+					href: sanitize(node.target, "a", "href") ?? void 0
+				}, createElement("sup", { key: state.key }, node.text));
+			}
+		},
+		[RuleType.gfmTask]: {
+			_qualify: ["[ ]", "[x]"],
+			_match: inlineRegex(GFM_TASK_R),
+			_order: Priority.HIGH,
+			_parse(capture) {
+				return { completed: capture[1].toLowerCase() === "x" };
+			},
+			_render(node, _, state = {}) {
+				return createElement("input", {
+					checked: node.completed,
+					key: state.key,
+					readOnly: true,
+					type: "checkbox"
+				});
+			}
+		},
+		[RuleType.heading]: {
+			_qualify: ["#"],
+			_match: blockRegex(options.enforceAtxHeadings ? HEADING_ATX_COMPLIANT_R : HEADING_R),
+			_order: Priority.HIGH,
+			_parse(capture, parse, state) {
+				return {
+					children: parseInline(parse, capture[2], state),
+					id: slug(capture[2]),
+					level: capture[1].length
+				};
+			},
+			_render(node, output, state = {}) {
+				return createElement(`h${node.level}`, {
+					id: node.id,
+					key: state.key
+				}, output(node.children, state));
+			}
+		},
+		[RuleType.headingSetext]: {
+			_qualify: (source) => {
+				const nlIndex = source.indexOf("\n");
+				return nlIndex > 0 && nlIndex < source.length - 1 && (source[nlIndex + 1] === "=" || source[nlIndex + 1] === "-");
+			},
+			_match: blockRegex(HEADING_SETEXT_R),
+			_order: Priority.MAX,
+			_parse(capture, parse, state) {
+				return {
+					children: parseInline(parse, capture[1], state),
+					level: capture[2] === "=" ? 1 : 2,
+					type: RuleType.heading
+				};
+			}
+		},
+		[RuleType.htmlBlock]: {
+			_qualify: (source) => {
+				if (options.disableParsingRawHTML) return false;
+				const match = source.match(/^ *<([a-z][a-z0-9:-]*)\b/i);
+				if (!match) return false;
+				const tag = match[1];
+				return source.toLowerCase().indexOf(`</${tag.toLowerCase()}>`) !== -1;
+			},
+			_match: anyScopeRegex(HTML_BLOCK_ELEMENT_R),
+			_order: Priority.HIGH,
+			_parse(capture, parse, state) {
+				const whitespace = capture[3].match(HTML_LEFT_TRIM_AMOUNT_R)?.[1] ?? "";
+				const trimmed = trimLeadingWhitespaceOutsideFences(capture[3], whitespace);
+				const parseFunc = containsBlockSyntax(trimmed) ? parseBlock : parseInline;
+				const tagName = capture[1].trim();
+				const noInnerParse = DO_NOT_PROCESS_HTML_ELEMENTS.indexOf(tagName.toLowerCase()) !== -1;
+				const tag = noInnerParse ? tagName.toLowerCase() : tagName;
+				const ast = {
+					attrs: attrStringToMap(tag, capture[2] ?? ""),
+					noInnerParse,
+					tag
+				};
+				state.inAnchor = state.inAnchor || tagName.toLowerCase() === "a";
+				if (noInnerParse) ast.text = capture[3];
+				else {
+					const prevInHTML = state.inHTML;
+					state.inHTML = true;
+					ast.children = parseFunc(parse, trimmed, state);
+					state.inHTML = prevInHTML;
+				}
+				state.inAnchor = false;
+				return ast;
+			},
+			_render(node, output, state = {}) {
+				return createElement(node.tag, {
+					key: state.key,
+					...node.attrs ?? {}
+				}, node.text ?? (node.children ? output(node.children, state) : ""));
+			}
+		},
+		[RuleType.htmlComment]: {
+			_qualify: ["<!"],
+			_match: anyScopeRegex(HTML_COMMENT_R),
+			_order: Priority.HIGH,
+			_parse: captureNothing,
+			_render: renderNothing
+		},
+		[RuleType.htmlSelfClosing]: {
+			_qualify: (source) => {
+				if (options.disableParsingRawHTML) return false;
+				return /^ *<([a-zA-Z][a-zA-Z0-9:]*)[\s>/]/.test(source);
+			},
+			_match: anyScopeRegex(HTML_SELF_CLOSING_ELEMENT_R),
+			_order: Priority.HIGH,
+			_parse(capture) {
+				const tag = capture[1].trim();
+				return {
+					attrs: attrStringToMap(tag, capture[2] || ""),
+					tag
+				};
+			},
+			_render(node, _, state = {}) {
+				return createElement(node.tag, {
+					key: state.key,
+					...node.attrs ?? {}
+				});
+			}
+		},
+		[RuleType.customComponent]: {
+			_qualify: (source) => /^ *<([A-Z][a-zA-Z0-9]*)/.test(source),
+			_match: anyScopeRegex(CUSTOM_COMPONENT_R),
+			_order: Priority.MAX,
+			_parse(capture, parse, state) {
+				const whitespace = capture[3].match(HTML_LEFT_TRIM_AMOUNT_R)?.[1] ?? "";
+				const trimmed = trimLeadingWhitespaceOutsideFences(capture[3], whitespace);
+				const parseFunc = containsBlockSyntax(trimmed) ? parseBlock : parseInline;
+				const tag = capture[1].trim();
+				const ast = {
+					attrs: attrStringToMap(tag, capture[2] ?? ""),
+					noInnerParse: false,
+					tag
+				};
+				const prevInHTML = state.inHTML;
+				state.inHTML = true;
+				ast.children = parseFunc(parse, trimmed, state);
+				state.inHTML = prevInHTML;
+				return ast;
+			},
+			_render(node, output, state = {}) {
+				return createElement(node.tag, {
+					key: state.key,
+					...node.attrs ?? {}
+				}, node.text ?? (node.children ? output(node.children, state) : ""));
+			}
+		},
+		[RuleType.paragraph]: {
+			_match: matchParagraph,
+			_order: Priority.LOW,
+			_parse: parseCaptureInline,
+			_render(node, output, state = {}) {
+				return createElement("p", { key: state.key }, output(node.children, state));
+			}
+		},
+		[RuleType.image]: {
+			_qualify: ["!["],
+			_match: simpleInlineRegex(IMAGE_R),
+			_order: Priority.HIGH,
+			_parse(capture) {
+				return {
+					alt: unescapeString(capture[1]),
+					target: unescapeString(capture[2]),
+					title: unescapeString(capture[3])
+				};
+			},
+			_render(node, _, state = {}) {
+				return createElement("img", {
+					key: state.key,
+					alt: node.alt ?? void 0,
+					title: node.title ?? void 0,
+					src: sanitize(node.target, "img", "src") ?? void 0
+				});
+			}
+		},
+		[RuleType.link]: {
+			_qualify: ["["],
+			_match: inlineRegex(LINK_R),
+			_order: Priority.LOW,
+			_parse(capture, parse, state) {
+				return {
+					children: parseSimpleInline(parse, capture[1], state),
+					target: unescapeString(capture[2]),
+					title: unescapeString(capture[3])
+				};
+			},
+			_render(node, output, state = {}) {
+				const sanitizedHref = sanitize(node.target, "a", "href");
+				return createElement("a", {
+					key: state.key,
+					href: sanitizedHref ?? void 0,
+					title: node.title ?? void 0
+				}, output(node.children, state));
+			}
+		},
+		[RuleType.linkAngleBraceStyleDetector]: {
+			_qualify: ["<"],
+			_match: inlineRegex(LINK_AUTOLINK_R),
+			_order: Priority.MAX,
+			_parse(capture) {
+				let target = capture[1];
+				let isEmail = false;
+				if (target.indexOf("@") !== -1 && target.indexOf("//") === -1) {
+					isEmail = true;
+					target = target.replace("mailto:", "");
+				}
+				return {
+					children: [{
+						text: target,
+						type: RuleType.text
+					}],
+					target: isEmail ? `mailto:${target}` : target,
+					type: RuleType.link
+				};
+			}
+		},
+		[RuleType.linkBareUrlDetector]: {
+			_qualify: (source, state) => !!(state.inline && !state.inAnchor && !options.disableAutoLink && (startsWith(source, "http://") || startsWith(source, "https://"))),
+			_match: inlineRegex(LINK_AUTOLINK_BARE_URL_R),
+			_order: Priority.MAX,
+			_parse(capture) {
+				return {
+					children: [{
+						text: capture[1],
+						type: RuleType.text
+					}],
+					target: capture[1],
+					type: RuleType.link
+				};
+			}
+		},
+		[RuleType.newlineCoalescer]: {
+			_match: blockRegex(CONSECUTIVE_NEWLINE_R),
+			_order: Priority.LOW,
+			_parse: captureNothing,
+			_render() {
+				return "\n";
+			}
+		},
+		[RuleType.orderedList]: generateListRule(1),
+		[RuleType.unorderedList]: generateListRule(2),
+		[RuleType.ref]: {
+			_qualify: ["["],
+			_match: anyScopeRegex(REFERENCE_IMAGE_OR_LINK),
+			_order: Priority.MAX,
+			_parse(capture) {
+				refs[capture[1]] = {
+					target: capture[2],
+					title: capture[4]
+				};
+				return {};
+			},
+			_render: renderNothing
+		},
+		[RuleType.refImage]: {
+			_qualify: ["!["],
+			_match: simpleInlineRegex(REFERENCE_IMAGE_R),
+			_order: Priority.MAX,
+			_parse(capture) {
+				return {
+					alt: capture[1] ? unescapeString(capture[1]) : void 0,
+					ref: capture[2]
+				};
+			},
+			_render(node, _, state = {}) {
+				const ref = refs[node.ref];
+				if (!ref) return null;
+				return createElement("img", {
+					key: state.key,
+					alt: node.alt,
+					src: sanitize(ref.target, "img", "src") ?? void 0,
+					title: ref.title
+				});
+			}
+		},
+		[RuleType.refLink]: {
+			_qualify: (source) => source[0] === "[" && source.indexOf("](") === -1,
+			_match: inlineRegex(REFERENCE_LINK_R),
+			_order: Priority.MAX,
+			_parse(capture, parse, state) {
+				return {
+					children: parseSimpleInline(parse, capture[1], state),
+					fallbackChildren: capture[0],
+					ref: capture[2]
+				};
+			},
+			_render(node, output, state = {}) {
+				const ref = refs[node.ref];
+				if (!ref) return createElement("span", { key: state.key }, node.fallbackChildren);
+				return createElement("a", {
+					key: state.key,
+					href: sanitize(ref.target, "a", "href") ?? void 0,
+					title: ref.title
+				}, output(node.children, state));
+			}
+		},
+		[RuleType.table]: {
+			_qualify: ["|"],
+			_match: blockRegex(NP_TABLE_R),
+			_order: Priority.HIGH,
+			_parse(capture, parse, state) {
+				state.inline = true;
+				const align = capture[2] ? parseTableAlign(capture[2]) : [];
+				const cells = capture[3] ? parseTableCells(capture[3], parse, state) : [];
+				const header = parseTableRow(capture[1], parse, state, !!cells.length);
+				state.inline = false;
+				return cells.length ? {
+					align,
+					cells,
+					header,
+					type: RuleType.table
+				} : {
+					children: header.flat(),
+					type: RuleType.paragraph
+				};
+			},
+			_render(node, output, state = {}) {
+				const table = node;
+				const getStyle = (i) => table.align[i] && table.align[i] !== "left" ? { textAlign: table.align[i] } : {};
+				return createElement("table", { key: state.key }, createElement("thead", null, createElement("tr", null, ...table.header.map((c, i) => createElement("th", {
+					key: i,
+					style: getStyle(i)
+				}, output(c, state))))), createElement("tbody", null, ...table.cells.map((row, i) => createElement("tr", { key: i }, ...row.map((c, j) => createElement("td", {
+					key: j,
+					style: getStyle(j)
+				}, output(c, state)))))));
+			}
+		},
+		[RuleType.tableSeparator]: {
+			_match: (source, state) => state.inTable && source[0] === "|" ? /^\|/.exec(source) : null,
+			_order: Priority.HIGH,
+			_parse() {
+				return { type: RuleType.tableSeparator };
+			},
+			_render() {
+				return " | ";
+			}
+		},
+		[RuleType.text]: {
+			_match: allowInline((source, _state) => {
+				const shortMatch = SHORTCODE_R.exec(source);
+				if (shortMatch) return shortMatch;
+				return TEXT_PLAIN_R.exec(source) || /^[\s\S]/.exec(source);
+			}),
+			_order: Priority.MIN,
+			_parse(capture) {
+				const text = capture[0];
+				return { text: text.indexOf("&") === -1 ? text : text.replace(HTML_CHAR_CODE_R, (f, i) => {
+					if (i.startsWith("#x")) return String.fromCharCode(parseInt(i.slice(2), 16));
+					if (i.startsWith("#")) return String.fromCharCode(parseInt(i.slice(1), 10));
+					return namedCodesToUnicode[i] || f;
+				}) };
+			},
+			_render(node) {
+				return node.text;
+			}
+		},
+		[RuleType.textBolded]: {
+			_qualify: ["**", "__"],
+			_match: simpleInlineRegex(TEXT_BOLD_R),
+			_order: Priority.MED,
+			_parse(capture, parse, state) {
+				return { children: parse(capture[2], state) };
+			},
+			_render(node, output, state = {}) {
+				return createElement("strong", { key: state.key }, output(node.children, state));
+			}
+		},
+		[RuleType.textEmphasized]: {
+			_qualify: ["*", "_"],
+			_match: simpleInlineRegex(TEXT_EMPHASIZED_R),
+			_order: Priority.LOW,
+			_parse(capture, parse, state) {
+				return { children: parse(capture[2], state) };
+			},
+			_render(node, output, state = {}) {
+				return createElement("em", { key: state.key }, output(node.children, state));
+			}
+		},
+		[RuleType.textEscaped]: {
+			_qualify: ["\\"],
+			_match: simpleInlineRegex(TEXT_ESCAPED_R),
+			_order: Priority.HIGH,
+			_parse(capture) {
+				return {
+					text: capture[1],
+					type: RuleType.text
+				};
+			}
+		},
+		[RuleType.textMarked]: {
+			_qualify: ["=="],
+			_match: simpleInlineRegex(TEXT_MARKED_R),
+			_order: Priority.LOW,
+			_parse: parseCaptureInline,
+			_render(node, output, state = {}) {
+				return createElement("mark", { key: state.key }, output(node.children, state));
+			}
+		},
+		[RuleType.textStrikethroughed]: {
+			_qualify: ["~~"],
+			_match: simpleInlineRegex(TEXT_STRIKETHROUGHED_R),
+			_order: Priority.LOW,
+			_parse: parseCaptureInline,
+			_render(node, output, state = {}) {
+				return createElement("del", { key: state.key }, output(node.children, state));
+			}
+		}
+	};
+};
+var compile = (markdown = "", ctx, options = {}) => {
+	const components = ctx.components ?? {};
+	const slug = (input) => {
+		return ctx.slugify ? ctx.slugify(input, slugify$1) : slugify$1(input);
+	};
+	const createElement = createElementFactory(ctx, options);
+	const footnotes = [];
+	const refs = {};
+	const attrStringToMap = (tag, str) => {
+		if (!str || !str.trim()) return null;
+		const attributes = str.match(ATTR_EXTRACTOR_R);
+		if (!attributes) return null;
+		return attributes.reduce((map, raw) => {
+			const delimiterIdx = raw.indexOf("=");
+			if (delimiterIdx !== -1) {
+				const key = normalizeAttributeKey(raw.slice(0, delimiterIdx)).trim();
+				const value = unquote(raw.slice(delimiterIdx + 1).trim());
+				const mappedKey = ATTRIBUTE_TO_NODE_PROP_MAP[key] ?? key;
+				if (mappedKey === "ref") return map;
+				map[mappedKey] = attributeValueToNodePropValue(tag, key, value, ctx.sanitizer ?? sanitizer);
+				if (typeof map[mappedKey] === "string" && (HTML_BLOCK_ELEMENT_R.test(map[mappedKey]) || HTML_SELF_CLOSING_ELEMENT_R.test(map[mappedKey]))) map[mappedKey] = compileInner(map[mappedKey].trim());
+			} else if (raw !== "style") map[ATTRIBUTE_TO_NODE_PROP_MAP[raw] ?? raw] = true;
+			return map;
+		}, {});
+	};
+	const nonParagraphBlockSyntaxes = [
+		BLOCKQUOTE_R,
+		CODE_BLOCK_FENCED_R,
+		CODE_BLOCK_R,
+		options.enforceAtxHeadings ? HEADING_ATX_COMPLIANT_R : HEADING_R,
+		HEADING_SETEXT_R,
+		NP_TABLE_R,
+		ORDERED_LIST_R,
+		UNORDERED_LIST_R,
+		CUSTOM_COMPONENT_R
+	];
+	const containsBlockSyntax = (input) => {
+		const cleaned = input.replace(TRIM_STARTING_NEWLINES, "");
+		const slice = cleaned.length > 2048 ? cleaned.slice(0, 2048) : cleaned;
+		return some(options.disableParsingRawHTML ? nonParagraphBlockSyntaxes : [
+			...nonParagraphBlockSyntaxes,
+			PARAGRAPH_R,
+			HTML_BLOCK_ELEMENT_R,
+			HTML_COMMENT_R,
+			HTML_SELF_CLOSING_ELEMENT_R,
+			CUSTOM_COMPONENT_R
+		], slice);
+	};
+	const baseRules = createRules(createElement, ctx, options, footnotes, refs, attrStringToMap, containsBlockSyntax, nonParagraphBlockSyntaxes);
+	const rules = options.disableParsingRawHTML ? Object.keys(baseRules).reduce((acc, key) => {
+		if (key !== RuleType.htmlBlock && key !== RuleType.htmlSelfClosing) acc[key] = baseRules[key];
+		return acc;
+	}, {}) : baseRules;
+	const parser = parserFor(rules);
+	const emitter = renderFor(createRenderer(rules, options.renderRule));
+	const compileInner = (input) => {
+		const result = options.preserveFrontmatter ? input : input.replace(FRONT_MATTER_R, "");
+		const inline = options.forceInline || !options.forceBlock && SHOULD_RENDER_AS_BLOCK_R.test(result.replace(TRIM_STARTING_NEWLINES, "")) === false;
+		const arr = emitter(parser(inline ? result : `${trimEnd(result).replace(TRIM_STARTING_NEWLINES, "")}\n\n`, { inline }), { inline });
+		while (typeof arr[arr.length - 1] === "string" && !arr[arr.length - 1].trim()) arr.pop();
+		if (options.wrapper === null) return arr;
+		const wrapper = options.wrapper ?? (inline ? "span" : "div");
+		if (arr.length > 1 || options.forceWrapper) return createElement(wrapper, { key: "outer" }, arr);
+		if (arr.length === 1) {
+			const node = arr[0];
+			if (typeof node === "string") {
+				const spanProps = { key: "outer" };
+				if (!inline && components) {
+					const pOverrideProps = get$2(components, "p.props", {}) ?? {};
+					const mergedClassName = cx$1(spanProps.className, pOverrideProps.className);
+					const finalSpanProps = {
+						...spanProps,
+						...pOverrideProps
+					};
+					if (mergedClassName) finalSpanProps.className = mergedClassName;
+					return createElement("span", finalSpanProps, node);
+				}
+				return createElement("span", spanProps, node);
+			}
+			return node;
+		}
+		return createElement(wrapper, { key: "outer" }, null);
+	};
+	if (typeof markdown !== "string") {
+		console.error("intlayer: the first argument must be a string. Received", typeof markdown);
+		throw new Error("intlayer: the first argument must be a string");
+	}
+	const node = compileInner(markdown);
+	return footnotes.length ? createElement("div", null, node, createElement("footer", { key: "footer" }, ...footnotes.map((def) => createElement("div", {
+		id: slug(def.identifier),
+		key: def.identifier
+	}, def.identifier, emitter(parser(def.footnote, { inline: true }), { inline: true }))))) : node;
+};
+//#endregion
 //#region ../react-intlayer/dist/esm/plugins.mjs
-var _getMarkdownMetadata = null;
-__vitePreload(() => import("./markdown-B_VAQu_B.js").then((n) => n.t).then((m) => {
-	_getMarkdownMetadata = m.getMarkdownMetadata;
-}), __vite__mapDeps([0,1]));
-var LazyMarkdownRendererPlugin = (0, import_react.lazy)(() => __vitePreload(() => import("./markdown-DJYH1etf.js").then((m) => ({ default: m.MarkdownRendererPlugin })), __vite__mapDeps([2,1,0])));
-var LazyHTMLRendererPlugin = (0, import_react.lazy)(() => __vitePreload(() => import("./html-CC2iD1GB.js").then((m) => ({ default: m.HTMLRendererPlugin })), __vite__mapDeps([3,1,4])));
+var LazyMarkdownRendererPlugin = (0, import_react.lazy)(() => __vitePreload(() => import("./MarkdownRendererPlugin-Dp6Cig6u.js").then((m) => ({ default: m.MarkdownRendererPlugin })), []));
+var LazyHTMLRendererPlugin = (0, import_react.lazy)(() => __vitePreload(() => import("./HTMLRendererPlugin-B6Eld7in.js").then((m) => ({ default: m.HTMLRendererPlugin })), __vite__mapDeps([0,1,2])));
 /** Translation plugin. Replaces node with a locale string if nodeType = Translation. */
 var intlayerNodePlugins = {
 	id: "intlayer-node-plugin",
@@ -10287,10 +12098,7 @@ var intlayerNodePlugins = {
 	transform: (_node, { plugins, ...rest }) => renderIntlayerNode({
 		...rest,
 		value: rest.children,
-		children: configuration_default?.editor.enabled ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(ContentSelector, {
-			...rest,
-			children: rest.children
-		}) : rest.children
+		children: rest.children
 	})
 };
 /** Translation plugin. Replaces node with a locale string if nodeType = Translation. */
@@ -10300,10 +12108,7 @@ var reactNodePlugins = {
 	transform: (node, { plugins, ...rest }) => renderIntlayerNode({
 		...rest,
 		value: "[[react-element]]",
-		children: configuration_default?.editor.enabled ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(ContentSelector, {
-			...rest,
-			children: renderReactElement(node)
-		}) : renderReactElement(node)
+		children: renderReactElement(node)
 	})
 };
 /**
@@ -10361,17 +12166,14 @@ var markdownStringPlugin = {
 	canHandle: (node) => typeof node === "string",
 	transform: (node, props, deepTransformNode) => {
 		const { plugins, ...rest } = props;
-		const metadataNodes = deepTransformNode(_getMarkdownMetadata?.(node) ?? {}, {
+		const metadataNodes = deepTransformNode(getMarkdownMetadata(node) ?? {}, {
 			plugins: [{
 				id: "markdown-metadata-plugin",
 				canHandle: (metadataNode) => typeof metadataNode === "string" || typeof metadataNode === "number" || typeof metadataNode === "boolean" || !metadataNode,
 				transform: (metadataNode, props) => renderIntlayerNode({
 					...props,
 					value: metadataNode,
-					children: configuration_default?.editor.enabled ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(ContentSelector, {
-						...rest,
-						children: node
-					}) : node
+					children: node
 				})
 			}],
 			dictionaryKey: rest.dictionaryKey,
@@ -10380,7 +12182,7 @@ var markdownStringPlugin = {
 		const render = (components) => renderIntlayerNode({
 			...props,
 			value: node,
-			children: configuration_default.editor.enabled ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(ContentSelector, {
+			children: configuration.editor.enabled ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(ContentSelector, {
 				...rest,
 				children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react.Suspense, {
 					fallback: node,
@@ -10448,10 +12250,10 @@ var htmlPlugin = {
 * This function is used by both getIntlayer and getDictionary to ensure consistent plugin configuration.
 */
 var getPlugins = (locale, fallback = true) => [
-	translationPlugin(locale ?? configuration_default.internationalization.defaultLocale, fallback ? configuration_default.internationalization.defaultLocale : void 0),
+	translationPlugin(locale ?? configuration.internationalization.defaultLocale, fallback ? configuration.internationalization.defaultLocale : void 0),
 	enumerationPlugin,
 	conditionPlugin,
-	nestedPlugin(locale ?? configuration_default.internationalization.defaultLocale),
+	nestedPlugin(locale ?? configuration.internationalization.defaultLocale),
 	filePlugin,
 	genderPlugin,
 	intlayerNodePlugins,
@@ -10604,7 +12406,7 @@ var getStorageAttributes = (options) => {
 * Resolves the most specific locale from a user-provided list,
 * or falls back to the default locale if no match is found.
 */
-var localeResolver = (selectedLocale, locales = configuration_default?.internationalization?.locales, defaultLocale = configuration_default?.internationalization?.defaultLocale) => {
+var localeResolver = (selectedLocale, locales = configuration?.internationalization?.locales, defaultLocale = configuration?.internationalization?.defaultLocale) => {
 	const requestedLocales = [selectedLocale].flat();
 	const normalize = (locale) => locale.trim().toLowerCase();
 	try {
@@ -10665,7 +12467,7 @@ var buildCookieString = (name, value, attributes) => {
 * @returns The locale if found in any storage, or undefined if not found
 */
 var getLocaleFromStorage = (options) => {
-	const { routing, internationalization } = configuration_default;
+	const { routing, internationalization } = configuration;
 	const { locales } = internationalization;
 	const { storage } = routing;
 	if (storage === false || options?.isCookieEnabled === false) return void 0;
@@ -10716,8 +12518,8 @@ var getLocaleFromStorage = (options) => {
 * @param locale - The locale to store
 */
 var setLocaleInStorage$1 = (locale, options) => {
-	if (configuration_default.routing.storage === false || options?.isCookieEnabled === false) return;
-	const storageAttributes = getStorageAttributes(configuration_default.routing.storage);
+	if (configuration.routing.storage === false || 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 {
@@ -10823,7 +12625,7 @@ var getHTMLTextDir = (locale) => {
 * Single source of truth for default routing config resolution across all localization functions.
 */
 var resolveRoutingConfig = (options = {}) => {
-	const { internationalization, routing } = configuration_default ?? {};
+	const { internationalization, routing } = configuration ?? {};
 	return {
 		defaultLocale: internationalization?.defaultLocale ?? DEFAULT_LOCALE,
 		mode: routing?.mode ?? "prefix-no-default",
@@ -10971,7 +12773,7 @@ var getLocaleName = (displayLocale, targetLocale = displayLocale) => {
 * @param locales - Optional array of supported locales. Defaults to `localesDefault`.
 * @returns The URL string or pathname without the locale segment or locale search parameter.
 */
-var getPathWithoutLocale = (inputUrl, locales = configuration_default?.internationalization?.locales) => {
+var getPathWithoutLocale = (inputUrl, locales = configuration?.internationalization?.locales) => {
 	const isAbsoluteUrl = checkIsURLAbsolute(inputUrl);
 	let fixedInputUrl = inputUrl;
 	if (inputUrl?.endsWith("/")) fixedInputUrl = inputUrl.slice(0, -1);
@@ -11114,7 +12916,7 @@ var getLocalizedPath = (canonicalPath, locale, rewriteRules) => {
 * @param options.mode - URL routing mode for locale handling. Defaults to configured mode.
 * @returns The localized URL for the current locale.
 */
-var getLocalizedUrl = (url, currentLocale = configuration_default?.internationalization?.defaultLocale, options = {}) => {
+var getLocalizedUrl = (url, currentLocale = configuration?.internationalization?.defaultLocale, options = {}) => {
 	const { defaultLocale, mode, locales, rewrite } = resolveRoutingConfig(options);
 	const urlWithoutLocale = getPathWithoutLocale(url, locales);
 	const rewriteRules = getRewriteRules(rewrite, "url");
@@ -11173,7 +12975,7 @@ var setLocaleInStorage = (locale, isCookieEnabled) => setLocaleInStorage$1(local
 * Context that stores the current locale on the client side.
 */
 var IntlayerClientContext = (0, import_react.createContext)({
-	locale: localeInStorage ?? configuration_default?.internationalization?.defaultLocale,
+	locale: localeInStorage ?? configuration?.internationalization?.defaultLocale,
 	setLocale: () => null,
 	isCookieEnabled: true
 });
@@ -11186,7 +12988,7 @@ var IntlayerClientContext = (0, import_react.createContext)({
 * @returns The provider component.
 */
 var IntlayerProviderContent = ({ locale: localeProp, defaultLocale: defaultLocaleProp, children, setLocale: setLocaleProp, disableEditor, isCookieEnabled }) => {
-	const { internationalization } = configuration_default ?? {};
+	const { internationalization } = configuration ?? {};
 	const { locales: availableLocales, defaultLocale: defaultLocaleConfig } = internationalization ?? {};
 	const [currentLocale, setCurrentLocale] = (0, import_react.useState)(localeProp ?? localeInStorage ?? defaultLocaleProp ?? defaultLocaleConfig);
 	(0, import_react.useEffect)(() => {
@@ -11255,7 +13057,7 @@ var useDictionary = (dictionary, locale) => {
 * ```
 */
 var useLocale = ({ isCookieEnabled, onLocaleChange } = {}) => {
-	const { defaultLocale, locales: availableLocales } = configuration_default?.internationalization ?? {};
+	const { defaultLocale, locales: availableLocales } = configuration?.internationalization ?? {};
 	const { locale, setLocale: setLocaleState, isCookieEnabled: isCookieEnabledContext } = (0, import_react.useContext)(IntlayerClientContext);
 	return {
 		locale,
@@ -11353,7 +13155,7 @@ var useMarkdownContext = () => (0, import_react.useContext)(MarkdownContext);
 * });
 * ```
 */
-var renderMarkdown = (content, { components, wrapper, forceBlock, forceInline, preserveFrontmatter, tagfilter } = {}) => {
+var renderMarkdown$1 = (content, { components, wrapper, forceBlock, forceInline, preserveFrontmatter, tagfilter } = {}) => {
 	return compiler(content, {
 		components,
 		forceBlock,
@@ -11365,6 +13167,12 @@ var renderMarkdown = (content, { components, wrapper, forceBlock, forceInline, p
 	});
 };
 //#endregion
+//#region ../react-intlayer/dist/esm/index.mjs
+/**
+* @deprecated import from react-intlayer/markdown instead
+*/
+var renderMarkdown = renderMarkdown$1;
+//#endregion
 //#region ../../node_modules/.bun/react-router@7.13.1+bf16f8eded5e12ee/node_modules/react-router/dist/development/chunk-LFPYN7LY.mjs
 var PopStateEventType = "popstate";
 function isLocation(obj) {
@@ -13206,7 +15014,6 @@ function useViewTransitionState(to, { relative } = {}) {
 }
 //#endregion
 //#region ../../node_modules/.bun/clsx@2.1.1/node_modules/clsx/dist/clsx.mjs
-var import_client = require_client();
 function r$6(e) {
 	var t, f, n = "";
 	if ("string" == typeof e || "number" == typeof e) n += e;
@@ -25258,7 +27065,7 @@ var EditorStateManager = class {
 	async _loadDictionaries() {
 		try {
 			const unmergedDictionaries = (await __vitePreload(async () => {
-				const { getUnmergedDictionaries } = await import("./unmerged_dictionaries-DXosh8mi.js");
+				const { getUnmergedDictionaries } = await import("./unmerged_dictionaries-DFHIR2QQ.js");
 				return { getUnmergedDictionaries };
 			}, [])).getUnmergedDictionaries();
 			const dictionariesList = Object.fromEntries(Object.values(unmergedDictionaries).flat().map((dictionary) => [dictionary.localId, dictionary]));
@@ -25502,7 +27309,7 @@ var defineIntlayerElements = () => {
 //#endregion
 //#region ../@intlayer/editor/dist/esm/core/initEditorClient.mjs
 var buildClientMessengerConfig = () => {
-	const { editor } = configuration_default ?? {};
+	const { editor } = configuration ?? {};
 	return {
 		allowedOrigins: [editor?.editorURL, editor?.cmsURL].filter(Boolean),
 		postMessageFn: (payload, origin) => {
@@ -25527,7 +27334,7 @@ var initEditorClient = () => {
 	const manager = new EditorStateManager({
 		mode: "client",
 		messenger: buildClientMessengerConfig(),
-		configuration: configuration_default
+		configuration
 	});
 	setGlobalEditorManager(manager);
 	defineIntlayerElements();
@@ -28369,7 +30176,7 @@ var CodeDefault = ({ children }) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
 		}, `line-${index}-${line.slice(0, 10)}`)) : children })
 	})
 });
-var CodeBlockShiki = (0, import_react.lazy)(() => __vitePreload(() => import("./CodeBlockShiki-CjD7FtGt.js").then((mod) => ({ default: mod.CodeBlockShiki })), __vite__mapDeps([5,1,6,7,4])));
+var CodeBlockShiki = (0, import_react.lazy)(() => __vitePreload(() => import("./CodeBlockShiki-D9plzEFQ.js").then((mod) => ({ default: mod.CodeBlockShiki })), __vite__mapDeps([3,1,4,5,2])));
 var CodeBlock = ({ className, onChange, isEditable, children, lang, isDarkMode, ...props }) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", {
 	className: cn$2("flex w-full min-w-0 max-w-full overflow-x-auto", className),
 	...props,
@@ -46699,7 +48506,7 @@ var getSearchAPI = (authAPIOptions = {}, intlayerConfig) => {
 };
 //#endregion
 //#region ../@intlayer/api/dist/esm/getIntlayerAPI/stripe.mjs
-var getStripeAPI = (authAPIOptions = {}, intlayerConfig = configuration_default) => {
+var getStripeAPI = (authAPIOptions = {}, intlayerConfig = configuration) => {
 	const STRIPE_API_ROUTE = `${intlayerConfig?.editor?.backendURL}/api/stripe`;
 	/**
 	* Get a pricing plan calculated for a given promotion code.
@@ -46936,7 +48743,7 @@ createDefu((object, key, currentValue) => {
 //#endregion
 //#region ../@intlayer/api/dist/esm/getIntlayerAPI/index.mjs
 var getIntlayerAPI = (authAPIOptions = {}, intlayerConfig) => {
-	const resolvedConfig = defu(intlayerConfig ?? {}, configuration_default);
+	const resolvedConfig = defu(intlayerConfig ?? {}, configuration);
 	return {
 		organization: getOrganizationAPI(authAPIOptions, resolvedConfig),
 		project: getProjectAPI(authAPIOptions, resolvedConfig),
@@ -46960,7 +48767,7 @@ var getIntlayerAPI = (authAPIOptions = {}, intlayerConfig) => {
 //#region ../@intlayer/design-system/dist/esm/hooks/useAuth/useOAuth2.mjs
 var useOAuth2 = (intlayerConfiguration) => {
 	const configuration$1 = useConfiguration();
-	const config = intlayerConfiguration ?? configuration$1 ?? configuration_default;
+	const config = intlayerConfiguration ?? configuration$1 ?? configuration;
 	const { data } = useQuery({
 		queryKey: ["oAuth2AccessToken"],
 		queryFn: getOAuthAPI(config).getOAuth2AccessToken,
@@ -46985,7 +48792,7 @@ function defineErrorCodes(codes) {
 	}]));
 }
 //#endregion
-//#region ../../node_modules/.bun/@better-auth+passkey@1.5.5+06b9efb931663ad4/node_modules/@better-auth/passkey/dist/error-codes-Dvu2mv33.mjs
+//#region ../../node_modules/.bun/@better-auth+passkey@1.5.5+97f5c57d9a1a38cb/node_modules/@better-auth/passkey/dist/error-codes-Dvu2mv33.mjs
 var PASSKEY_ERROR_CODES = defineErrorCodes({
 	CHALLENGE_NOT_FOUND: "Challenge not found",
 	YOU_ARE_NOT_ALLOWED_TO_REGISTER_THIS_PASSKEY: "You are not allowed to register this passkey",
@@ -47447,7 +49254,7 @@ async function startAuthentication(options) {
 	};
 }
 //#endregion
-//#region ../../node_modules/.bun/better-auth@1.5.5+e56975f313122268/node_modules/better-auth/dist/client/broadcast-channel.mjs
+//#region ../../node_modules/.bun/better-auth@1.5.5+40b259e98b9c70b8/node_modules/better-auth/dist/client/broadcast-channel.mjs
 var kBroadcastChannel = Symbol.for("better-auth:broadcast-channel");
 var now$1 = () => Math.floor(Date.now() / 1e3);
 var WindowBroadcastChannel = class {
@@ -47490,7 +49297,7 @@ function getGlobalBroadcastChannel(name = "better-auth.message") {
 	return globalThis[kBroadcastChannel];
 }
 //#endregion
-//#region ../../node_modules/.bun/better-auth@1.5.5+e56975f313122268/node_modules/better-auth/dist/client/focus-manager.mjs
+//#region ../../node_modules/.bun/better-auth@1.5.5+40b259e98b9c70b8/node_modules/better-auth/dist/client/focus-manager.mjs
 var kFocusManager = Symbol.for("better-auth:focus-manager");
 var WindowFocusManager = class {
 	listeners = /* @__PURE__ */ new Set();
@@ -47519,7 +49326,7 @@ function getGlobalFocusManager() {
 	return globalThis[kFocusManager];
 }
 //#endregion
-//#region ../../node_modules/.bun/better-auth@1.5.5+e56975f313122268/node_modules/better-auth/dist/client/online-manager.mjs
+//#region ../../node_modules/.bun/better-auth@1.5.5+40b259e98b9c70b8/node_modules/better-auth/dist/client/online-manager.mjs
 var kOnlineManager = Symbol.for("better-auth:online-manager");
 var WindowOnlineManager = class {
 	listeners = /* @__PURE__ */ new Set();
@@ -47551,7 +49358,7 @@ function getGlobalOnlineManager() {
 	return globalThis[kOnlineManager];
 }
 //#endregion
-//#region ../../node_modules/.bun/better-auth@1.5.5+e56975f313122268/node_modules/better-auth/dist/client/parser.mjs
+//#region ../../node_modules/.bun/better-auth@1.5.5+40b259e98b9c70b8/node_modules/better-auth/dist/client/parser.mjs
 var PROTO_POLLUTION_PATTERNS = {
 	proto: /"(?:_|\\u0{2}5[Ff]){2}(?:p|\\u0{2}70)(?:r|\\u0{2}72)(?:o|\\u0{2}6[Ff])(?:t|\\u0{2}74)(?:o|\\u0{2}6[Ff])(?:_|\\u0{2}5[Ff]){2}"\s*:/,
 	constructor: /"(?:c|\\u0063)(?:o|\\u006[Ff])(?:n|\\u006[Ee])(?:s|\\u0073)(?:t|\\u0074)(?:r|\\u0072)(?:u|\\u0075)(?:c|\\u0063)(?:t|\\u0074)(?:o|\\u006[Ff])(?:r|\\u0072)"\s*:/,
@@ -47733,7 +49540,7 @@ var onMount = ($store, initialize) => {
 	});
 };
 //#endregion
-//#region ../../node_modules/.bun/better-auth@1.5.5+e56975f313122268/node_modules/better-auth/dist/client/query.mjs
+//#region ../../node_modules/.bun/better-auth@1.5.5+40b259e98b9c70b8/node_modules/better-auth/dist/client/query.mjs
 var isServer = () => typeof window === "undefined";
 var useAuthQuery = (initializedAtom, path, $fetch, options) => {
 	const value = /* @__PURE__ */ atom({
@@ -47827,7 +49634,7 @@ var useAuthQuery = (initializedAtom, path, $fetch, options) => {
 	return value;
 };
 //#endregion
-//#region ../../node_modules/.bun/better-auth@1.5.5+e56975f313122268/node_modules/better-auth/dist/client/session-refresh.mjs
+//#region ../../node_modules/.bun/better-auth@1.5.5+40b259e98b9c70b8/node_modules/better-auth/dist/client/session-refresh.mjs
 var now = () => Math.floor(Date.now() / 1e3);
 /**
 * Rate limit: don't refetch on focus if a session request was made within this many seconds
@@ -48026,7 +49833,7 @@ var BetterAuthError = class extends Error {
 	}
 };
 //#endregion
-//#region ../../node_modules/.bun/better-auth@1.5.5+e56975f313122268/node_modules/better-auth/dist/utils/url.mjs
+//#region ../../node_modules/.bun/better-auth@1.5.5+40b259e98b9c70b8/node_modules/better-auth/dist/utils/url.mjs
 function checkHasPath(url) {
 	try {
 		return (new URL(url).pathname.replace(/\/+$/, "") || "/") !== "/";
@@ -48098,7 +49905,7 @@ function getOrigin(url) {
 	}
 }
 //#endregion
-//#region ../../node_modules/.bun/better-auth@1.5.5+e56975f313122268/node_modules/better-auth/dist/client/fetch-plugins.mjs
+//#region ../../node_modules/.bun/better-auth@1.5.5+40b259e98b9c70b8/node_modules/better-auth/dist/client/fetch-plugins.mjs
 var redirectPlugin = {
 	id: "redirect",
 	name: "Redirect",
@@ -48113,7 +49920,7 @@ var redirectPlugin = {
 	} }
 };
 //#endregion
-//#region ../../node_modules/.bun/better-auth@1.5.5+e56975f313122268/node_modules/better-auth/dist/client/session-atom.mjs
+//#region ../../node_modules/.bun/better-auth@1.5.5+40b259e98b9c70b8/node_modules/better-auth/dist/client/session-atom.mjs
 function getSessionAtom($fetch, options) {
 	const $signal = /* @__PURE__ */ atom(false);
 	const session = useAuthQuery($signal, "/get-session", $fetch, { method: "GET" });
@@ -48572,7 +50379,7 @@ var betterFetch = async (url, options) => {
 	};
 };
 //#endregion
-//#region ../../node_modules/.bun/better-auth@1.5.5+e56975f313122268/node_modules/better-auth/dist/client/config.mjs
+//#region ../../node_modules/.bun/better-auth@1.5.5+40b259e98b9c70b8/node_modules/better-auth/dist/client/config.mjs
 var resolvePublicAuthUrl = (basePath) => {
 	if (typeof process === "undefined") return void 0;
 	const path = basePath ?? "/api/auth";
@@ -48670,12 +50477,12 @@ var getClientConfig = (options, loadEnv) => {
 	};
 };
 //#endregion
-//#region ../../node_modules/.bun/better-auth@1.5.5+e56975f313122268/node_modules/better-auth/dist/utils/is-atom.mjs
+//#region ../../node_modules/.bun/better-auth@1.5.5+40b259e98b9c70b8/node_modules/better-auth/dist/utils/is-atom.mjs
 function isAtom(value) {
 	return typeof value === "object" && value !== null && "get" in value && typeof value.get === "function" && "lc" in value && typeof value.lc === "number";
 }
 //#endregion
-//#region ../../node_modules/.bun/better-auth@1.5.5+e56975f313122268/node_modules/better-auth/dist/client/proxy.mjs
+//#region ../../node_modules/.bun/better-auth@1.5.5+40b259e98b9c70b8/node_modules/better-auth/dist/client/proxy.mjs
 function getMethod(path, knownPathMethods, args) {
 	const method = knownPathMethods[path];
 	const { fetchOptions, query: _query, ...body } = args || {};
@@ -48755,7 +50562,7 @@ function capitalizeFirstLetter(str) {
 	return str.charAt(0).toUpperCase() + str.slice(1);
 }
 //#endregion
-//#region ../../node_modules/.bun/better-auth@1.5.5+e56975f313122268/node_modules/better-auth/dist/client/vanilla.mjs
+//#region ../../node_modules/.bun/better-auth@1.5.5+40b259e98b9c70b8/node_modules/better-auth/dist/client/vanilla.mjs
 function createAuthClient(options) {
 	const { pluginPathMethods, pluginsActions, pluginsAtoms, $fetch, atomListeners, $store } = getClientConfig(options);
 	const resolvedHooks = {};
@@ -48768,7 +50575,7 @@ function createAuthClient(options) {
 	}, $fetch, pluginPathMethods, pluginsAtoms, atomListeners);
 }
 //#endregion
-//#region ../../node_modules/.bun/@better-auth+passkey@1.5.5+06b9efb931663ad4/node_modules/@better-auth/passkey/dist/client.mjs
+//#region ../../node_modules/.bun/@better-auth+passkey@1.5.5+97f5c57d9a1a38cb/node_modules/@better-auth/passkey/dist/client.mjs
 var getPasskeyActions = ($fetch, { $listPasskeys, $store }) => {
 	const signInPasskey = async (opts, options) => {
 		const response = await $fetch("/passkey/generate-authenticate-options", {
@@ -48910,7 +50717,7 @@ var passkeyClient = () => {
 	};
 };
 //#endregion
-//#region ../../node_modules/.bun/@better-auth+sso@1.5.5+c13bcbbab381f6fe/node_modules/@better-auth/sso/dist/client.mjs
+//#region ../../node_modules/.bun/@better-auth+sso@1.5.5+9a386bd0a1ca2f57/node_modules/@better-auth/sso/dist/client.mjs
 var ssoClient = (options) => {
 	return {
 		id: "sso-client",
@@ -48922,7 +50729,7 @@ var ssoClient = (options) => {
 	};
 };
 //#endregion
-//#region ../../node_modules/.bun/better-auth@1.5.5+e56975f313122268/node_modules/better-auth/dist/plugins/magic-link/client.mjs
+//#region ../../node_modules/.bun/better-auth@1.5.5+40b259e98b9c70b8/node_modules/better-auth/dist/plugins/magic-link/client.mjs
 var magicLinkClient = () => {
 	return {
 		id: "magic-link",
@@ -48930,7 +50737,7 @@ var magicLinkClient = () => {
 	};
 };
 //#endregion
-//#region ../../node_modules/.bun/better-auth@1.5.5+e56975f313122268/node_modules/better-auth/dist/plugins/two-factor/error-code.mjs
+//#region ../../node_modules/.bun/better-auth@1.5.5+40b259e98b9c70b8/node_modules/better-auth/dist/plugins/two-factor/error-code.mjs
 var TWO_FACTOR_ERROR_CODES = defineErrorCodes({
 	OTP_NOT_ENABLED: "OTP not enabled",
 	OTP_HAS_EXPIRED: "OTP has expired",
@@ -48943,7 +50750,7 @@ var TWO_FACTOR_ERROR_CODES = defineErrorCodes({
 	INVALID_TWO_FACTOR_COOKIE: "Invalid two factor cookie"
 });
 //#endregion
-//#region ../../node_modules/.bun/better-auth@1.5.5+e56975f313122268/node_modules/better-auth/dist/plugins/two-factor/client.mjs
+//#region ../../node_modules/.bun/better-auth@1.5.5+40b259e98b9c70b8/node_modules/better-auth/dist/plugins/two-factor/client.mjs
 var twoFactorClient = (options) => {
 	return {
 		id: "two-factor",
@@ -48991,12 +50798,12 @@ var getAuthClient = (backendURL) => createAuthClient({
 	]
 });
 var getAuthAPI = (intlayerConfig) => {
-	let backendURL = intlayerConfig?.editor?.backendURL ?? configuration_default?.editor?.backendURL;
+	let backendURL = intlayerConfig?.editor?.backendURL ?? configuration?.editor?.backendURL;
 	if (!backendURL) {
 		backendURL = BACKEND_URL;
 		console.dir({
 			intlayerConfig,
-			configuration: configuration_default
+			configuration
 		}, { depth: null });
 		console.error("Backend URL is not defined in the Intlayer configuration.");
 	}
@@ -49153,7 +50960,7 @@ var getAuthAPI = (intlayerConfig) => {
 //#region ../@intlayer/design-system/dist/esm/hooks/useAuth/useSession.mjs
 var useSession = (sessionProp, intlayerConfiguration) => {
 	const configuration$1 = useConfiguration();
-	const config = intlayerConfiguration ?? configuration$1 ?? configuration_default;
+	const config = intlayerConfiguration ?? configuration$1 ?? configuration;
 	const queryClient = useQueryClient();
 	const { data, isFetched, refetch } = useQuery({
 		queryKey: ["session"],
@@ -50194,7 +52001,7 @@ var getIsEditableSection = (section) => {
 //#endregion
 //#region ../@intlayer/design-system/dist/esm/components/DictionaryFieldEditor/NavigationView/NavigationViewNode.mjs
 var NavigationViewNode = ({ section: sectionProp, keyPath, dictionary }) => {
-	const { locales } = configuration_default.internationalization;
+	const { locales } = configuration.internationalization;
 	const section = getContentNodeByKeyPath(sectionProp, keyPath, useEditorLocale());
 	const { addEditedContent } = useEditedContentActions();
 	const { setFocusedContentKeyPath, focusedContent } = useFocusUnmergedDictionary();
@@ -50407,7 +52214,7 @@ var FormItem = ({ id: idProp, ...props }) => {
 };
 var FormItemContext = (0, import_react.createContext)({});
 //#endregion
-//#region ../../node_modules/.bun/react-hook-form@7.71.2+b1ab299f0a400331/node_modules/react-hook-form/dist/index.esm.mjs
+//#region ../../node_modules/.bun/react-hook-form@7.72.0+b1ab299f0a400331/node_modules/react-hook-form/dist/index.esm.mjs
 var isCheckBoxInput = (element) => element.type === "checkbox";
 var isDateObject = (value) => value instanceof Date;
 var isNullOrUndefined = (value) => value == null;
@@ -50462,7 +52269,10 @@ var set = (object, path, value) => {
 var EVENTS = {
 	BLUR: "blur",
 	FOCUS_OUT: "focusout",
-	CHANGE: "change"
+	CHANGE: "change",
+	SUBMIT: "submit",
+	TRIGGER: "trigger",
+	VALID: "valid"
 };
 var VALIDATION_MODE = {
 	onBlur: "onBlur",
@@ -50480,6 +52290,8 @@ var INPUT_VALIDATION_RULES = {
 	required: "required",
 	validate: "validate"
 };
+var FORM_ERROR_TYPE = "form";
+var ROOT_ERROR_TYPE = "root";
 /**
 * Separate context for `control` to prevent unnecessary rerenders.
 * Internal hooks that only need control use this instead of full form context.
@@ -51215,7 +53027,7 @@ var skipValidation = (isBlurEvent, isTouched, isSubmitted, reValidateMode, mode)
 var unsetEmptyArray = (ref, name) => !compact(get(ref, name)).length && unset(ref, name);
 var updateFieldArrayRootError = (errors, error, name) => {
 	const fieldArrayErrors = convertToArrayPayload(get(errors, name));
-	set(fieldArrayErrors, "root", error[name]);
+	set(fieldArrayErrors, ROOT_ERROR_TYPE, error[name]);
 	set(errors, name, fieldArrayErrors);
 	return errors;
 };
@@ -51437,7 +53249,11 @@ function createFormControl(props = {}) {
 			if (_options.resolver) {
 				isValid = isEmptyObject((await _runSchema()).errors);
 				_updateIsValidating();
-			} else isValid = await executeBuiltInValidation(_fields, true);
+			} else isValid = await executeBuiltInValidation({
+				fields: _fields,
+				onlyCheckValid: true,
+				eventType: EVENTS.VALID
+			});
 			if (isValid !== _formState.isValid) _subjects.state.next({ isValid });
 		}
 	};
@@ -51468,7 +53284,11 @@ function createFormControl(props = {}) {
 				const touchedFields = method(get(_formState.touchedFields, name), args.argA, args.argB);
 				shouldSetValues && set(_formState.touchedFields, name, touchedFields);
 			}
-			if (_proxyFormState.dirtyFields || _proxySubscribeFormState.dirtyFields) _formState.dirtyFields = getDirtyFields(_defaultValues, _formValues);
+			if (_proxyFormState.dirtyFields || _proxySubscribeFormState.dirtyFields) {
+				const fullDirtyFields = getDirtyFields(_defaultValues, _formValues);
+				const rootName = getNodeParentName(name);
+				set(_formState.dirtyFields, rootName, get(fullDirtyFields, rootName));
+			}
 			_subjects.state.next({
 				name,
 				isDirty: _getDirty(name, values),
@@ -51565,7 +53385,42 @@ function createFormControl(props = {}) {
 		else _formState.errors = errors;
 		return errors;
 	};
-	const executeBuiltInValidation = async (fields, shouldOnlyCheckValid, context = { valid: true }) => {
+	const validateForm = async ({ name, eventType }) => {
+		if (props.validate) {
+			const result = await props.validate({
+				formValues: _formValues,
+				formState: _formState,
+				name,
+				eventType
+			});
+			if (isObject$1(result)) {
+				for (const key in result) if (result[key]) setError(`${FORM_ERROR_TYPE}.${key}`, {
+					message: isString(result.message) ? result.message : "",
+					type: INPUT_VALIDATION_RULES.validate
+				});
+			} else if (isString(result) || !result) setError(FORM_ERROR_TYPE, {
+				message: result || "",
+				type: INPUT_VALIDATION_RULES.validate
+			});
+			else clearErrors(FORM_ERROR_TYPE);
+			return result;
+		}
+		return true;
+	};
+	const executeBuiltInValidation = async ({ fields, onlyCheckValid, name, eventType, context = {
+		valid: true,
+		runRootValidation: false
+	} }) => {
+		if (props.validate) {
+			context.runRootValidation = true;
+			if (!await validateForm({
+				name,
+				eventType
+			})) {
+				context.valid = false;
+				if (onlyCheckValid) return context.valid;
+			}
+		}
 		for (const name in fields) {
 			const field = fields[name];
 			if (field) {
@@ -51574,15 +53429,22 @@ function createFormControl(props = {}) {
 					const isFieldArrayRoot = _names.array.has(_f.name);
 					const isPromiseFunction = field._f && hasPromiseValidation(field._f);
 					if (isPromiseFunction && _proxyFormState.validatingFields) _updateIsValidating([_f.name], true);
-					const fieldError = await validateField(field, _names.disabled, _formValues, shouldDisplayAllAssociatedErrors, _options.shouldUseNativeValidation && !shouldOnlyCheckValid, isFieldArrayRoot);
+					const fieldError = await validateField(field, _names.disabled, _formValues, shouldDisplayAllAssociatedErrors, _options.shouldUseNativeValidation && !onlyCheckValid, isFieldArrayRoot);
 					if (isPromiseFunction && _proxyFormState.validatingFields) _updateIsValidating([_f.name]);
 					if (fieldError[_f.name]) {
 						context.valid = false;
-						if (shouldOnlyCheckValid || props.shouldUseNativeValidation) break;
+						if (onlyCheckValid) break;
 					}
-					!shouldOnlyCheckValid && (get(fieldError, _f.name) ? isFieldArrayRoot ? updateFieldArrayRootError(_formState.errors, fieldError, _f.name) : set(_formState.errors, _f.name, fieldError[_f.name]) : unset(_formState.errors, _f.name));
+					!onlyCheckValid && (get(fieldError, _f.name) ? isFieldArrayRoot ? updateFieldArrayRootError(_formState.errors, fieldError, _f.name) : set(_formState.errors, _f.name, fieldError[_f.name]) : unset(_formState.errors, _f.name));
+					if (props.shouldUseNativeValidation && fieldError[_f.name]) break;
 				}
-				!isEmptyObject(fieldValue) && await executeBuiltInValidation(fieldValue, shouldOnlyCheckValid, context);
+				!isEmptyObject(fieldValue) && await executeBuiltInValidation({
+					context,
+					onlyCheckValid,
+					fields: fieldValue,
+					name,
+					eventType
+				});
 			}
 		}
 		return context.valid;
@@ -51675,7 +53537,7 @@ function createFormControl(props = {}) {
 			let isValid;
 			const fieldValue = target.type ? getFieldValue(field._f) : getEventValue(event);
 			const isBlurEvent = event.type === EVENTS.BLUR || event.type === EVENTS.FOCUS_OUT;
-			const shouldSkipValidation = !hasValidation(field._f) && !_options.resolver && !get(_formState.errors, name) && !field._f.deps || skipValidation(isBlurEvent, get(_formState.touchedFields, name), _formState.isSubmitted, validationModeAfterSubmit, validationModeBeforeSubmit);
+			const shouldSkipValidation = !hasValidation(field._f) && !props.validate && !_options.resolver && !get(_formState.errors, name) && !field._f.deps || skipValidation(isBlurEvent, get(_formState.touchedFields, name), _formState.isSubmitted, validationModeAfterSubmit, validationModeBeforeSubmit);
 			const watched = isWatched(name, _names, isBlurEvent);
 			set(_formValues, name, fieldValue);
 			if (isBlurEvent) {
@@ -51702,6 +53564,10 @@ function createFormControl(props = {}) {
 					...watched ? {} : fieldState
 				});
 			}
+			if (!_options.resolver && props.validate) await validateForm({
+				name,
+				eventType: event.type
+			});
 			!isBlurEvent && watched && _subjects.state.next({ ..._formState });
 			if (_options.resolver) {
 				const { errors } = await _runSchema([name]);
@@ -51721,7 +53587,12 @@ function createFormControl(props = {}) {
 				_updateIsFieldValueUpdated(fieldValue);
 				if (isFieldValueUpdated) {
 					if (error) isValid = false;
-					else if (_proxyFormState.isValid || _proxySubscribeFormState.isValid) isValid = await executeBuiltInValidation(_fields, true);
+					else if (_proxyFormState.isValid || _proxySubscribeFormState.isValid) isValid = await executeBuiltInValidation({
+						fields: _fields,
+						onlyCheckValid: true,
+						name,
+						eventType: event.type
+					});
 				}
 			}
 			if (isFieldValueUpdated) {
@@ -51747,10 +53618,17 @@ function createFormControl(props = {}) {
 		} else if (name) {
 			validationResult = (await Promise.all(fieldNames.map(async (fieldName) => {
 				const field = get(_fields, fieldName);
-				return await executeBuiltInValidation(field && field._f ? { [fieldName]: field } : field);
+				return await executeBuiltInValidation({
+					fields: field && field._f ? { [fieldName]: field } : field,
+					eventType: EVENTS.TRIGGER
+				});
 			}))).every(Boolean);
 			!(!validationResult && !_formState.isValid) && _setValid();
-		} else validationResult = isValid = await executeBuiltInValidation(_fields);
+		} else validationResult = isValid = await executeBuiltInValidation({
+			fields: _fields,
+			name,
+			eventType: EVENTS.TRIGGER
+		});
 		_subjects.state.next({
 			...!isString(name) || (_proxyFormState.isValid || _proxySubscribeFormState.isValid) && isValid !== _formState.isValid ? {} : { name },
 			..._options.resolver || !name ? { isValid } : {},
@@ -51938,9 +53816,12 @@ function createFormControl(props = {}) {
 			_updateIsValidating();
 			_formState.errors = errors;
 			fieldValues = cloneObject(values);
-		} else await executeBuiltInValidation(_fields);
+		} else await executeBuiltInValidation({
+			fields: _fields,
+			eventType: EVENTS.SUBMIT
+		});
 		if (_names.disabled.size) for (const name of _names.disabled) unset(fieldValues, name);
-		unset(_formState.errors, "root");
+		unset(_formState.errors, ROOT_ERROR_TYPE);
 		if (isEmptyObject(_formState.errors)) {
 			_subjects.state.next({ errors: {} });
 			try {
@@ -52375,7 +54256,7 @@ var InformationTag = ({ className, children, ...props }) => /* @__PURE__ */ (0,
 	children: ["ⓘ ", children]
 });
 //#endregion
-//#region ../../node_modules/.bun/@hookform+resolvers@5.2.2+e54cb81c12bc0246/node_modules/@hookform/resolvers/dist/resolvers.mjs
+//#region ../../node_modules/.bun/@hookform+resolvers@5.2.2+b828ecb606cdb5bc/node_modules/@hookform/resolvers/dist/resolvers.mjs
 var r = (t, r, o) => {
 	if (t && "reportValidity" in t) {
 		const s = get(o, r);
@@ -55160,7 +57041,7 @@ var optionalProcessor = (schema, ctx, _json, params) => {
 	seen.ref = def.innerType;
 };
 //#endregion
-//#region ../../node_modules/.bun/@hookform+resolvers@5.2.2+e54cb81c12bc0246/node_modules/@hookform/resolvers/zod/dist/zod.mjs
+//#region ../../node_modules/.bun/@hookform+resolvers@5.2.2+b828ecb606cdb5bc/node_modules/@hookform/resolvers/zod/dist/zod.mjs
 function t(r, e) {
 	try {
 		var o = r();
@@ -57004,7 +58885,7 @@ var DictionaryDetailsForm = ({ dictionary, mode }) => {
 };
 //#endregion
 //#region ../@intlayer/design-system/dist/esm/components/IDE/MonacoCode.mjs
-var Editor = (0, import_react.lazy)(() => __vitePreload(() => import("./dist-B9LA40uC.js").then((mod) => ({ default: mod.Editor })), __vite__mapDeps([8,1,4])));
+var Editor = (0, import_react.lazy)(() => __vitePreload(() => import("./dist-D8J9DkzO.js").then((mod) => ({ default: mod.Editor })), __vite__mapDeps([6,1,2])));
 var MonacoCode = ({ children, language, isDarkMode, showLineNumbers, showCopyButton = true, isReadOnly = false, onChange }) => {
 	const containerRef = (0, import_react.useRef)(null);
 	const ideRef = (0, import_react.useRef)(null);
@@ -59560,4 +61441,4 @@ var App = () => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(AppRouter, { childre
 //#region client/src/main.tsx
 (0, import_client.createRoot)(document.getElementById("root")).render(/* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react.StrictMode, { children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(App, {}) }));
 //#endregion
-export { compiler as a, compileMarkdown as i, renderMarkdown as n, useMarkdownContext as r, CodeDefault as t };
+export { useMarkdownContext as n, CodeDefault as t };