intlayer-editor 8.4.9 → 8.5.0

package/client/dist/assets/markdown-B_VAQu_B.js

@@ -1,1836 +0,0 @@
-import { r as __exportAll } from "./chunk-C0u3WHrm.js";
-//#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 (_e) {
-		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 = (...args) => args.filter(Boolean).join(" ");
-/**
-* Get a nested property from an object using dot notation.
-*/
-var get = (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 = (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 = (tag, components) => {
-	if (typeof tag !== "string") return tag;
-	let override = get(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(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(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(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) : slugify(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) : slugify(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(components, "p.props", {}) ?? {};
-					const mergedClassName = cx(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 ../@intlayer/core/dist/esm/markdown/index.mjs
-var markdown_exports = /* @__PURE__ */ __exportAll({
-	DURATION_DELAY_TRIGGER: () => 20,
-	INLINE_SKIP_R: () => INLINE_SKIP_R,
-	ORDERED: () => 1,
-	ORDERED_LIST_BULLET: () => ORDERED_LIST_BULLET,
-	UNORDERED: () => 2,
-	UNORDERED_LIST_BULLET: () => UNORDERED_LIST_BULLET,
-	getMarkdownMetadata: () => getMarkdownMetadata
-});
-//#endregion
-export { RuleType as a, slugify as i, compile as n, sanitizer as r, markdown_exports as t };