rj-editor 1.3.0 → 1.3.1

package/dist/LexicalCodePrism.prod-aiocbvfq.js

@@ -0,0 +1,1416 @@
+import { a as e, c as t, d as n, f as r, h as i, i as a, l as o, m as s, n as c, o as l, p as u, r as d, s as f, t as p, u as m } from "./prism-2TqtsDnJ.js";
+import { $createLineBreakNode as h, $createPoint as g, $createTabNode as _, $createTextNode as v, $getCaretRange as y, $getCaretRangeInDirection as ee, $getNodeByKey as b, $getRoot as x, $getSelection as S, $getSiblingCaret as C, $getTextPointCaret as w, $insertNodes as T, $isLineBreakNode as E, $isRangeSelection as D, $isTabNode as O, $isTextNode as te, $normalizeCaret as ne, $onUpdate as re, $setSelectionFromCaretRange as ie, COMMAND_PRIORITY_LOW as k, INDENT_CONTENT_COMMAND as A, INSERT_TAB_COMMAND as j, KEY_ARROW_DOWN_COMMAND as M, KEY_ARROW_UP_COMMAND as N, KEY_TAB_COMMAND as P, MOVE_TO_END as F, MOVE_TO_START as I, OUTDENT_CONTENT_COMMAND as L, TextNode as R, defineExtension as z, mergeRegister as ae, safeCast as oe } from "lexical";
+//#endregion
+//#region node_modules/prismjs/components/prism-cpp.js
+p(), globalThis.Prism.languages.clike = {
+	comment: [{
+		pattern: /(^|[^\\])\/\*[\s\S]*?(?:\*\/|$)/,
+		lookbehind: !0,
+		greedy: !0
+	}, {
+		pattern: /(^|[^\\:])\/\/.*/,
+		lookbehind: !0,
+		greedy: !0
+	}],
+	string: {
+		pattern: /(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
+		greedy: !0
+	},
+	"class-name": {
+		pattern: /(\b(?:class|extends|implements|instanceof|interface|new|trait)\s+|\bcatch\s+\()[\w.\\]+/i,
+		lookbehind: !0,
+		inside: { punctuation: /[.\\]/ }
+	},
+	keyword: /\b(?:break|catch|continue|do|else|finally|for|function|if|in|instanceof|new|null|return|throw|try|while)\b/,
+	boolean: /\b(?:false|true)\b/,
+	function: /\b\w+(?=\()/,
+	number: /\b0x[\da-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?/i,
+	operator: /[<>]=?|[!=]=?=?|--?|\+\+?|&&?|\|\|?|[?*/~^%]/,
+	punctuation: /[{}[\];(),.:]/
+}, globalThis.Prism.languages.javascript = globalThis.Prism.languages.extend("clike", {
+	"class-name": [globalThis.Prism.languages.clike["class-name"], {
+		pattern: /(^|[^$\w\xA0-\uFFFF])(?!\s)[_$A-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\.(?:constructor|prototype))/,
+		lookbehind: !0
+	}],
+	keyword: [{
+		pattern: /((?:^|\})\s*)catch\b/,
+		lookbehind: !0
+	}, {
+		pattern: /(^|[^.]|\.\.\.\s*)\b(?:as|assert(?=\s*\{)|async(?=\s*(?:function\b|\(|[$\w\xA0-\uFFFF]|$))|await|break|case|class|const|continue|debugger|default|delete|do|else|enum|export|extends|finally(?=\s*(?:\{|$))|for|from(?=\s*(?:['"]|$))|function|(?:get|set)(?=\s*(?:[#\[$\w\xA0-\uFFFF]|$))|if|implements|import|in|instanceof|interface|let|new|null|of|package|private|protected|public|return|static|super|switch|this|throw|try|typeof|undefined|var|void|while|with|yield)\b/,
+		lookbehind: !0
+	}],
+	function: /#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*(?:\.\s*(?:apply|bind|call)\s*)?\()/,
+	number: {
+		pattern: RegExp("(^|[^\\w$])(?:NaN|Infinity|0[bB][01]+(?:_[01]+)*n?|0[oO][0-7]+(?:_[0-7]+)*n?|0[xX][\\dA-Fa-f]+(?:_[\\dA-Fa-f]+)*n?|\\d+(?:_\\d+)*n|(?:\\d+(?:_\\d+)*(?:\\.(?:\\d+(?:_\\d+)*)?)?|\\.\\d+(?:_\\d+)*)(?:[Ee][+-]?\\d+(?:_\\d+)*)?)(?![\\w$])"),
+		lookbehind: !0
+	},
+	operator: /--|\+\+|\*\*=?|=>|&&=?|\|\|=?|[!=]==|<<=?|>>>?=?|[-+*/%&|^!=<>]=?|\.{3}|\?\?=?|\?\.?|[~:]/
+}), globalThis.Prism.languages.javascript["class-name"][0].pattern = /(\b(?:class|extends|implements|instanceof|interface|new)\s+)[\w.\\]+/, globalThis.Prism.languages.insertBefore("javascript", "keyword", {
+	regex: {
+		pattern: RegExp("((?:^|[^$\\w\\xA0-\\uFFFF.\"'\\])\\s]|\\b(?:return|yield))\\s*)\\/(?:(?:\\[(?:[^\\]\\\\\\r\\n]|\\\\.)*\\]|\\\\.|[^/\\\\\\[\\r\\n])+\\/[dgimyus]{0,7}|(?:\\[(?:[^[\\]\\\\\\r\\n]|\\\\.|\\[(?:[^[\\]\\\\\\r\\n]|\\\\.|\\[(?:[^[\\]\\\\\\r\\n]|\\\\.)*\\])*\\])*\\]|\\\\.|[^/\\\\\\[\\r\\n])+\\/[dgimyus]{0,7}v[dgimyus]{0,7})(?=(?:\\s|\\/\\*(?:[^*]|\\*(?!\\/))*\\*\\/)*(?:$|[\\r\\n,.;:})\\]]|\\/\\/))"),
+		lookbehind: !0,
+		greedy: !0,
+		inside: {
+			"regex-source": {
+				pattern: /^(\/)[\s\S]+(?=\/[a-z]*$)/,
+				lookbehind: !0,
+				alias: "language-regex",
+				inside: globalThis.Prism.languages.regex
+			},
+			"regex-delimiter": /^\/|\/$/,
+			"regex-flags": /^[a-z]+$/
+		}
+	},
+	"function-variable": {
+		pattern: /#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*[=:]\s*(?:async\s*)?(?:\bfunction\b|(?:\((?:[^()]|\([^()]*\))*\)|(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*)\s*=>))/,
+		alias: "function"
+	},
+	parameter: [
+		{
+			pattern: /(function(?:\s+(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*)?\s*\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\))/,
+			lookbehind: !0,
+			inside: globalThis.Prism.languages.javascript
+		},
+		{
+			pattern: /(^|[^$\w\xA0-\uFFFF])(?!\s)[_$a-z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*=>)/i,
+			lookbehind: !0,
+			inside: globalThis.Prism.languages.javascript
+		},
+		{
+			pattern: /(\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\)\s*=>)/,
+			lookbehind: !0,
+			inside: globalThis.Prism.languages.javascript
+		},
+		{
+			pattern: /((?:\b|\s|^)(?!(?:as|async|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|finally|for|from|function|get|if|implements|import|in|instanceof|interface|let|new|null|of|package|private|protected|public|return|set|static|super|switch|this|throw|try|typeof|undefined|var|void|while|with|yield)(?![$\w\xA0-\uFFFF]))(?:(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*\s*)\(\s*|\]\s*\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\)\s*\{)/,
+			lookbehind: !0,
+			inside: globalThis.Prism.languages.javascript
+		}
+	],
+	constant: /\b[A-Z](?:[A-Z_]|\dx?)*\b/
+}), globalThis.Prism.languages.insertBefore("javascript", "string", {
+	hashbang: {
+		pattern: /^#!.*/,
+		greedy: !0,
+		alias: "comment"
+	},
+	"template-string": {
+		pattern: /`(?:\\[\s\S]|\$\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})+\}|(?!\$\{)[^\\`])*`/,
+		greedy: !0,
+		inside: {
+			"template-punctuation": {
+				pattern: /^`|`$/,
+				alias: "string"
+			},
+			interpolation: {
+				pattern: /((?:^|[^\\])(?:\\{2})*)\$\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})+\}/,
+				lookbehind: !0,
+				inside: {
+					"interpolation-punctuation": {
+						pattern: /^\$\{|\}$/,
+						alias: "punctuation"
+					},
+					rest: globalThis.Prism.languages.javascript
+				}
+			},
+			string: /[\s\S]+/
+		}
+	},
+	"string-property": {
+		pattern: /((?:^|[,{])[ \t]*)(["'])(?:\\(?:\r\n|[\s\S])|(?!\2)[^\\\r\n])*\2(?=\s*:)/m,
+		lookbehind: !0,
+		greedy: !0,
+		alias: "property"
+	}
+}), globalThis.Prism.languages.insertBefore("javascript", "operator", { "literal-property": {
+	pattern: /((?:^|[,{])[ \t]*)(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*:)/m,
+	lookbehind: !0,
+	alias: "property"
+} }), globalThis.Prism.languages.markup && (globalThis.Prism.languages.markup.tag.addInlined("script", "javascript"), globalThis.Prism.languages.markup.tag.addAttribute("on(?:abort|blur|change|click|composition(?:end|start|update)|dblclick|error|focus(?:in|out)?|key(?:down|up)|load|mouse(?:down|enter|leave|move|out|over|up)|reset|resize|scroll|select|slotchange|submit|unload|wheel)", "javascript")), globalThis.Prism.languages.js = globalThis.Prism.languages.javascript, globalThis.Prism.languages.markup = {
+	comment: {
+		pattern: /<!--(?:(?!<!--)[\s\S])*?-->/,
+		greedy: !0
+	},
+	prolog: {
+		pattern: /<\?[\s\S]+?\?>/,
+		greedy: !0
+	},
+	doctype: {
+		pattern: /<!DOCTYPE(?:[^>"'[\]]|"[^"]*"|'[^']*')+(?:\[(?:[^<"'\]]|"[^"]*"|'[^']*'|<(?!!--)|<!--(?:[^-]|-(?!->))*-->)*\]\s*)?>/i,
+		greedy: !0,
+		inside: {
+			"internal-subset": {
+				pattern: /(^[^\[]*\[)[\s\S]+(?=\]>$)/,
+				lookbehind: !0,
+				greedy: !0,
+				inside: null
+			},
+			string: {
+				pattern: /"[^"]*"|'[^']*'/,
+				greedy: !0
+			},
+			punctuation: /^<!|>$|[[\]]/,
+			"doctype-tag": /^DOCTYPE/i,
+			name: /[^\s<>'"]+/
+		}
+	},
+	cdata: {
+		pattern: /<!\[CDATA\[[\s\S]*?\]\]>/i,
+		greedy: !0
+	},
+	tag: {
+		pattern: /<\/?(?!\d)[^\s>\/=$<%]+(?:\s(?:\s*[^\s>\/=]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))|(?=[\s/>])))+)?\s*\/?>/,
+		greedy: !0,
+		inside: {
+			tag: {
+				pattern: /^<\/?[^\s>\/]+/,
+				inside: {
+					punctuation: /^<\/?/,
+					namespace: /^[^\s>\/:]+:/
+				}
+			},
+			"special-attr": [],
+			"attr-value": {
+				pattern: /=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+)/,
+				inside: { punctuation: [{
+					pattern: /^=/,
+					alias: "attr-equals"
+				}, {
+					pattern: /^(\s*)["']|["']$/,
+					lookbehind: !0
+				}] }
+			},
+			punctuation: /\/?>/,
+			"attr-name": {
+				pattern: /[^\s>\/]+/,
+				inside: { namespace: /^[^\s>\/:]+:/ }
+			}
+		}
+	},
+	entity: [{
+		pattern: /&[\da-z]{1,8};/i,
+		alias: "named-entity"
+	}, /&#x?[\da-f]{1,8};/i]
+}, globalThis.Prism.languages.markup.tag.inside["attr-value"].inside.entity = globalThis.Prism.languages.markup.entity, globalThis.Prism.languages.markup.doctype.inside["internal-subset"].inside = globalThis.Prism.languages.markup, globalThis.Prism.hooks.add("wrap", function(e) {
+	e.type === "entity" && (e.attributes.title = e.content.replace(/&amp;/, "&"));
+}), Object.defineProperty(globalThis.Prism.languages.markup.tag, "addInlined", { value: function(e, t) {
+	var n = {};
+	n["language-" + t] = {
+		pattern: /(^<!\[CDATA\[)[\s\S]+?(?=\]\]>$)/i,
+		lookbehind: !0,
+		inside: globalThis.Prism.languages[t]
+	}, n.cdata = /^<!\[CDATA\[|\]\]>$/i;
+	var r = { "included-cdata": {
+		pattern: /<!\[CDATA\[[\s\S]*?\]\]>/i,
+		inside: n
+	} };
+	r["language-" + t] = {
+		pattern: /[\s\S]+/,
+		inside: globalThis.Prism.languages[t]
+	};
+	var i = {};
+	i[e] = {
+		pattern: RegExp("(<__[^>]*>)(?:<!\\[CDATA\\[(?:[^\\]]|\\](?!\\]>))*\\]\\]>|(?!<!\\[CDATA\\[)[\\s\\S])*?(?=<\\/__>)".replace(/__/g, function() {
+			return e;
+		}), "i"),
+		lookbehind: !0,
+		greedy: !0,
+		inside: r
+	}, globalThis.Prism.languages.insertBefore("markup", "cdata", i);
+} }), Object.defineProperty(globalThis.Prism.languages.markup.tag, "addAttribute", { value: function(e, t) {
+	globalThis.Prism.languages.markup.tag.inside["special-attr"].push({
+		pattern: RegExp("(^|[\"'\\s])(?:" + e + ")\\s*=\\s*(?:\"[^\"]*\"|'[^']*'|[^\\s'\">=]+(?=[\\s>]))", "i"),
+		lookbehind: !0,
+		inside: {
+			"attr-name": /^[^\s=]+/,
+			"attr-value": {
+				pattern: /=[\s\S]+/,
+				inside: {
+					value: {
+						pattern: /(^=\s*(["']|(?!["'])))\S[\s\S]*(?=\2$)/,
+						lookbehind: !0,
+						alias: [t, "language-" + t],
+						inside: globalThis.Prism.languages[t]
+					},
+					punctuation: [{
+						pattern: /^=/,
+						alias: "attr-equals"
+					}, /"|'/]
+				}
+			}
+		}
+	});
+} }), globalThis.Prism.languages.html = globalThis.Prism.languages.markup, globalThis.Prism.languages.mathml = globalThis.Prism.languages.markup, globalThis.Prism.languages.svg = globalThis.Prism.languages.markup, globalThis.Prism.languages.xml = globalThis.Prism.languages.extend("markup", {}), globalThis.Prism.languages.ssml = globalThis.Prism.languages.xml, globalThis.Prism.languages.atom = globalThis.Prism.languages.xml, globalThis.Prism.languages.rss = globalThis.Prism.languages.xml, (function(e) {
+	var t = "(?:\\\\.|[^\\\\\\n\\r]|(?:\\n|\\r\\n?)(?![\\r\\n]))";
+	function n(e) {
+		return e = e.replace(/<inner>/g, function() {
+			return t;
+		}), RegExp("((?:^|[^\\\\])(?:\\\\{2})*)(?:" + e + ")");
+	}
+	var r = "(?:\\\\.|``(?:[^`\\r\\n]|`(?!`))+``|`[^`\\r\\n]+`|[^\\\\|\\r\\n`])+", i = "\\|?__(?:\\|__)+\\|?(?:(?:\\n|\\r\\n?)|(?![\\s\\S]))".replace(/__/g, function() {
+		return r;
+	}), a = "\\|?[ \\t]*:?-{3,}:?[ \\t]*(?:\\|[ \\t]*:?-{3,}:?[ \\t]*)+\\|?(?:\\n|\\r\\n?)";
+	globalThis.Prism.languages.markdown = globalThis.Prism.languages.extend("markup", {}), globalThis.Prism.languages.insertBefore("markdown", "prolog", {
+		"front-matter-block": {
+			pattern: /(^(?:\s*[\r\n])?)---(?!.)[\s\S]*?[\r\n]---(?!.)/,
+			lookbehind: !0,
+			greedy: !0,
+			inside: {
+				punctuation: /^---|---$/,
+				"front-matter": {
+					pattern: /\S+(?:\s+\S+)*/,
+					alias: ["yaml", "language-yaml"],
+					inside: globalThis.Prism.languages.yaml
+				}
+			}
+		},
+		blockquote: {
+			pattern: /^>(?:[\t ]*>)*/m,
+			alias: "punctuation"
+		},
+		table: {
+			pattern: RegExp("^" + i + a + "(?:" + i + ")*", "m"),
+			inside: {
+				"table-data-rows": {
+					pattern: RegExp("^(" + i + a + ")(?:" + i + ")*$"),
+					lookbehind: !0,
+					inside: {
+						"table-data": {
+							pattern: RegExp(r),
+							inside: globalThis.Prism.languages.markdown
+						},
+						punctuation: /\|/
+					}
+				},
+				"table-line": {
+					pattern: RegExp("^(" + i + ")" + a + "$"),
+					lookbehind: !0,
+					inside: { punctuation: /\||:?-{3,}:?/ }
+				},
+				"table-header-row": {
+					pattern: RegExp("^" + i + "$"),
+					inside: {
+						"table-header": {
+							pattern: RegExp(r),
+							alias: "important",
+							inside: globalThis.Prism.languages.markdown
+						},
+						punctuation: /\|/
+					}
+				}
+			}
+		},
+		code: [{
+			pattern: /((?:^|\n)[ \t]*\n|(?:^|\r\n?)[ \t]*\r\n?)(?: {4}|\t).+(?:(?:\n|\r\n?)(?: {4}|\t).+)*/,
+			lookbehind: !0,
+			alias: "keyword"
+		}, {
+			pattern: /^```[\s\S]*?^```$/m,
+			greedy: !0,
+			inside: {
+				"code-block": {
+					pattern: /^(```.*(?:\n|\r\n?))[\s\S]+?(?=(?:\n|\r\n?)^```$)/m,
+					lookbehind: !0
+				},
+				"code-language": {
+					pattern: /^(```).+/,
+					lookbehind: !0
+				},
+				punctuation: /```/
+			}
+		}],
+		title: [{
+			pattern: /\S.*(?:\n|\r\n?)(?:==+|--+)(?=[ \t]*$)/m,
+			alias: "important",
+			inside: { punctuation: /==+$|--+$/ }
+		}, {
+			pattern: /(^\s*)#.+/m,
+			lookbehind: !0,
+			alias: "important",
+			inside: { punctuation: /^#+|#+$/ }
+		}],
+		hr: {
+			pattern: /(^\s*)([*-])(?:[\t ]*\2){2,}(?=\s*$)/m,
+			lookbehind: !0,
+			alias: "punctuation"
+		},
+		list: {
+			pattern: /(^\s*)(?:[*+-]|\d+\.)(?=[\t ].)/m,
+			lookbehind: !0,
+			alias: "punctuation"
+		},
+		"url-reference": {
+			pattern: /!?\[[^\]]+\]:[\t ]+(?:\S+|<(?:\\.|[^>\\])+>)(?:[\t ]+(?:"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|\((?:\\.|[^)\\])*\)))?/,
+			inside: {
+				variable: {
+					pattern: /^(!?\[)[^\]]+/,
+					lookbehind: !0
+				},
+				string: /(?:"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|\((?:\\.|[^)\\])*\))$/,
+				punctuation: /^[\[\]!:]|[<>]/
+			},
+			alias: "url"
+		},
+		bold: {
+			pattern: n("\\b__(?:(?!_)<inner>|_(?:(?!_)<inner>)+_)+__\\b|\\*\\*(?:(?!\\*)<inner>|\\*(?:(?!\\*)<inner>)+\\*)+\\*\\*"),
+			lookbehind: !0,
+			greedy: !0,
+			inside: {
+				content: {
+					pattern: /(^..)[\s\S]+(?=..$)/,
+					lookbehind: !0,
+					inside: {}
+				},
+				punctuation: /\*\*|__/
+			}
+		},
+		italic: {
+			pattern: n("\\b_(?:(?!_)<inner>|__(?:(?!_)<inner>)+__)+_\\b|\\*(?:(?!\\*)<inner>|\\*\\*(?:(?!\\*)<inner>)+\\*\\*)+\\*"),
+			lookbehind: !0,
+			greedy: !0,
+			inside: {
+				content: {
+					pattern: /(^.)[\s\S]+(?=.$)/,
+					lookbehind: !0,
+					inside: {}
+				},
+				punctuation: /[*_]/
+			}
+		},
+		strike: {
+			pattern: n("(~~?)(?:(?!~)<inner>)+\\2"),
+			lookbehind: !0,
+			greedy: !0,
+			inside: {
+				content: {
+					pattern: /(^~~?)[\s\S]+(?=\1$)/,
+					lookbehind: !0,
+					inside: {}
+				},
+				punctuation: /~~?/
+			}
+		},
+		"code-snippet": {
+			pattern: /(^|[^\\`])(?:``[^`\r\n]+(?:`[^`\r\n]+)*``(?!`)|`[^`\r\n]+`(?!`))/,
+			lookbehind: !0,
+			greedy: !0,
+			alias: ["code", "keyword"]
+		},
+		url: {
+			pattern: n("!?\\[(?:(?!\\])<inner>)+\\](?:\\([^\\s)]+(?:[\\t ]+\"(?:\\\\.|[^\"\\\\])*\")?\\)|[ \\t]?\\[(?:(?!\\])<inner>)+\\])"),
+			lookbehind: !0,
+			greedy: !0,
+			inside: {
+				operator: /^!/,
+				content: {
+					pattern: /(^\[)[^\]]+(?=\])/,
+					lookbehind: !0,
+					inside: {}
+				},
+				variable: {
+					pattern: /(^\][ \t]?\[)[^\]]+(?=\]$)/,
+					lookbehind: !0
+				},
+				url: {
+					pattern: /(^\]\()[^\s)]+/,
+					lookbehind: !0
+				},
+				string: {
+					pattern: /(^[ \t]+)"(?:\\.|[^"\\])*"(?=\)$)/,
+					lookbehind: !0
+				}
+			}
+		}
+	}), [
+		"url",
+		"bold",
+		"italic",
+		"strike"
+	].forEach(function(e) {
+		[
+			"url",
+			"bold",
+			"italic",
+			"strike",
+			"code-snippet"
+		].forEach(function(t) {
+			e !== t && (globalThis.Prism.languages.markdown[e].inside.content.inside[t] = globalThis.Prism.languages.markdown[t]);
+		});
+	}), globalThis.Prism.hooks.add("after-tokenize", function(e) {
+		if (e.language !== "markdown" && e.language !== "md") return;
+		function t(e) {
+			if (!(!e || typeof e == "string")) for (var n = 0, r = e.length; n < r; n++) {
+				var i = e[n];
+				if (i.type !== "code") {
+					t(i.content);
+					continue;
+				}
+				var a = i.content[1], o = i.content[3];
+				if (a && o && a.type === "code-language" && o.type === "code-block" && typeof a.content == "string") {
+					var s = a.content.replace(/\b#/g, "sharp").replace(/\b\+\+/g, "pp");
+					s = (/[a-z][\w-]*/i.exec(s) || [""])[0].toLowerCase();
+					var c = "language-" + s;
+					o.alias ? typeof o.alias == "string" ? o.alias = [o.alias, c] : o.alias.push(c) : o.alias = [c];
+				}
+			}
+		}
+		t(e.tokens);
+	}), globalThis.Prism.hooks.add("wrap", function(e) {
+		if (e.type === "code-block") {
+			for (var t = "", n = 0, r = e.classes.length; n < r; n++) {
+				var i = e.classes[n], a = /language-(.+)/.exec(i);
+				if (a) {
+					t = a[1];
+					break;
+				}
+			}
+			var o = globalThis.Prism.languages[t];
+			if (o) e.content = globalThis.Prism.highlight(l(e.content), o, t);
+			else if (t && t !== "none" && globalThis.Prism.plugins.autoloader) {
+				var s = "md-" + (/* @__PURE__ */ new Date()).valueOf() + "-" + Math.floor(Math.random() * 0x2386f26fc10000);
+				e.attributes.id = s, globalThis.Prism.plugins.autoloader.loadLanguages(t, function() {
+					var e = document.getElementById(s);
+					e && (e.innerHTML = globalThis.Prism.highlight(e.textContent, globalThis.Prism.languages[t], t));
+				});
+			}
+		}
+	});
+	var o = RegExp(globalThis.Prism.languages.markup.tag.pattern.source, "gi"), s = {
+		amp: "&",
+		lt: "<",
+		gt: ">",
+		quot: "\""
+	}, c = String.fromCodePoint || String.fromCharCode;
+	function l(e) {
+		var t = e.replace(o, "");
+		return t = t.replace(/&(\w{1,8}|#x?[\da-f]{1,8});/gi, function(e, t) {
+			return t = t.toLowerCase(), t[0] === "#" ? c(t[1] === "x" ? parseInt(t.slice(2), 16) : Number(t.slice(1))) : s[t] || e;
+		}), t;
+	}
+	globalThis.Prism.languages.md = globalThis.Prism.languages.markdown;
+})(globalThis.Prism), globalThis.Prism.languages.c = globalThis.Prism.languages.extend("clike", {
+	comment: {
+		pattern: /\/\/(?:[^\r\n\\]|\\(?:\r\n?|\n|(?![\r\n])))*|\/\*[\s\S]*?(?:\*\/|$)/,
+		greedy: !0
+	},
+	string: {
+		pattern: /"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"/,
+		greedy: !0
+	},
+	"class-name": {
+		pattern: /(\b(?:enum|struct)\s+(?:__attribute__\s*\(\([\s\S]*?\)\)\s*)?)\w+|\b[a-z]\w*_t\b/,
+		lookbehind: !0
+	},
+	keyword: /\b(?:_Alignas|_Alignof|_Atomic|_Bool|_Complex|_Generic|_Imaginary|_Noreturn|_Static_assert|_Thread_local|__attribute__|asm|auto|break|case|char|const|continue|default|do|double|else|enum|extern|float|for|goto|if|inline|int|long|register|return|short|signed|sizeof|static|struct|switch|typedef|typeof|union|unsigned|void|volatile|while)\b/,
+	function: /\b[a-z_]\w*(?=\s*\()/i,
+	number: /(?:\b0x(?:[\da-f]+(?:\.[\da-f]*)?|\.[\da-f]+)(?:p[+-]?\d+)?|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?)[ful]{0,4}/i,
+	operator: />>=?|<<=?|->|([-+&|:])\1|[?:~]|[-+*/%&|^!=<>]=?/
+}), globalThis.Prism.languages.insertBefore("c", "string", { char: {
+	pattern: /'(?:\\(?:\r\n|[\s\S])|[^'\\\r\n]){0,32}'/,
+	greedy: !0
+} }), globalThis.Prism.languages.insertBefore("c", "string", { macro: {
+	pattern: /(^[\t ]*)#\s*[a-z](?:[^\r\n\\/]|\/(?!\*)|\/\*(?:[^*]|\*(?!\/))*\*\/|\\(?:\r\n|[\s\S]))*/im,
+	lookbehind: !0,
+	greedy: !0,
+	alias: "property",
+	inside: {
+		string: [{
+			pattern: /^(#\s*include\s*)<[^>]+>/,
+			lookbehind: !0
+		}, globalThis.Prism.languages.c.string],
+		char: globalThis.Prism.languages.c.char,
+		comment: globalThis.Prism.languages.c.comment,
+		"macro-name": [{
+			pattern: /(^#\s*define\s+)\w+\b(?!\()/i,
+			lookbehind: !0
+		}, {
+			pattern: /(^#\s*define\s+)\w+\b(?=\()/i,
+			lookbehind: !0,
+			alias: "function"
+		}],
+		directive: {
+			pattern: /^(#\s*)[a-z]+/,
+			lookbehind: !0,
+			alias: "keyword"
+		},
+		"directive-hash": /^#/,
+		punctuation: /##|\\(?=[\r\n])/,
+		expression: {
+			pattern: /\S[\s\S]*/,
+			inside: globalThis.Prism.languages.c
+		}
+	}
+} }), globalThis.Prism.languages.insertBefore("c", "function", { constant: /\b(?:EOF|NULL|SEEK_CUR|SEEK_END|SEEK_SET|__DATE__|__FILE__|__LINE__|__TIMESTAMP__|__TIME__|__func__|stderr|stdin|stdout)\b/ }), delete globalThis.Prism.languages.c.boolean, (function(e) {
+	var t = /(?:"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"|'(?:\\(?:\r\n|[\s\S])|[^'\\\r\n])*')/;
+	globalThis.Prism.languages.css = {
+		comment: /\/\*[\s\S]*?\*\//,
+		atrule: {
+			pattern: RegExp("@[\\w-](?:[^;{\\s\"']|\\s+(?!\\s)|" + t.source + ")*?(?:;|(?=\\s*\\{))"),
+			inside: {
+				rule: /^@[\w-]+/,
+				"selector-function-argument": {
+					pattern: /(\bselector\s*\(\s*(?![\s)]))(?:[^()\s]|\s+(?![\s)])|\((?:[^()]|\([^()]*\))*\))+(?=\s*\))/,
+					lookbehind: !0,
+					alias: "selector"
+				},
+				keyword: {
+					pattern: /(^|[^\w-])(?:and|not|only|or)(?![\w-])/,
+					lookbehind: !0
+				}
+			}
+		},
+		url: {
+			pattern: RegExp("\\burl\\((?:" + t.source + "|(?:[^\\\\\\r\\n()\"']|\\\\[\\s\\S])*)\\)", "i"),
+			greedy: !0,
+			inside: {
+				function: /^url/i,
+				punctuation: /^\(|\)$/,
+				string: {
+					pattern: RegExp("^" + t.source + "$"),
+					alias: "url"
+				}
+			}
+		},
+		selector: {
+			pattern: RegExp("(^|[{}\\s])[^{}\\s](?:[^{};\"'\\s]|\\s+(?![\\s{])|" + t.source + ")*(?=\\s*\\{)"),
+			lookbehind: !0
+		},
+		string: {
+			pattern: t,
+			greedy: !0
+		},
+		property: {
+			pattern: /(^|[^-\w\xA0-\uFFFF])(?!\s)[-_a-z\xA0-\uFFFF](?:(?!\s)[-\w\xA0-\uFFFF])*(?=\s*:)/i,
+			lookbehind: !0
+		},
+		important: /!important\b/i,
+		function: {
+			pattern: /(^|[^-a-z0-9])[-a-z0-9]+(?=\()/i,
+			lookbehind: !0
+		},
+		punctuation: /[(){};:,]/
+	}, globalThis.Prism.languages.css.atrule.inside.rest = globalThis.Prism.languages.css;
+	var n = globalThis.Prism.languages.markup;
+	n && (n.tag.addInlined("style", "css"), n.tag.addAttribute("style", "css"));
+})(globalThis.Prism), globalThis.Prism.languages.objectivec = globalThis.Prism.languages.extend("c", {
+	string: {
+		pattern: /@?"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"/,
+		greedy: !0
+	},
+	keyword: /\b(?:asm|auto|break|case|char|const|continue|default|do|double|else|enum|extern|float|for|goto|if|in|inline|int|long|register|return|self|short|signed|sizeof|static|struct|super|switch|typedef|typeof|union|unsigned|void|volatile|while)\b|(?:@interface|@end|@implementation|@protocol|@class|@public|@protected|@private|@property|@try|@catch|@finally|@throw|@synthesize|@dynamic|@selector)\b/,
+	operator: /-[->]?|\+\+?|!=?|<<?=?|>>?=?|==?|&&?|\|\|?|[~^%?*\/@]/
+}), delete globalThis.Prism.languages.objectivec["class-name"], globalThis.Prism.languages.objc = globalThis.Prism.languages.objectivec, globalThis.Prism.languages.sql = {
+	comment: {
+		pattern: /(^|[^\\])(?:\/\*[\s\S]*?\*\/|(?:--|\/\/|#).*)/,
+		lookbehind: !0
+	},
+	variable: [{
+		pattern: /@(["'`])(?:\\[\s\S]|(?!\1)[^\\])+\1/,
+		greedy: !0
+	}, /@[\w.$]+/],
+	string: {
+		pattern: /(^|[^@\\])("|')(?:\\[\s\S]|(?!\2)[^\\]|\2\2)*\2/,
+		greedy: !0,
+		lookbehind: !0
+	},
+	identifier: {
+		pattern: /(^|[^@\\])`(?:\\[\s\S]|[^`\\]|``)*`/,
+		greedy: !0,
+		lookbehind: !0,
+		inside: { punctuation: /^`|`$/ }
+	},
+	function: /\b(?:AVG|COUNT|FIRST|FORMAT|LAST|LCASE|LEN|MAX|MID|MIN|MOD|NOW|ROUND|SUM|UCASE)(?=\s*\()/i,
+	keyword: /\b(?:ACTION|ADD|AFTER|ALGORITHM|ALL|ALTER|ANALYZE|ANY|APPLY|AS|ASC|AUTHORIZATION|AUTO_INCREMENT|BACKUP|BDB|BEGIN|BERKELEYDB|BIGINT|BINARY|BIT|BLOB|BOOL|BOOLEAN|BREAK|BROWSE|BTREE|BULK|BY|CALL|CASCADED?|CASE|CHAIN|CHAR(?:ACTER|SET)?|CHECK(?:POINT)?|CLOSE|CLUSTERED|COALESCE|COLLATE|COLUMNS?|COMMENT|COMMIT(?:TED)?|COMPUTE|CONNECT|CONSISTENT|CONSTRAINT|CONTAINS(?:TABLE)?|CONTINUE|CONVERT|CREATE|CROSS|CURRENT(?:_DATE|_TIME|_TIMESTAMP|_USER)?|CURSOR|CYCLE|DATA(?:BASES?)?|DATE(?:TIME)?|DAY|DBCC|DEALLOCATE|DEC|DECIMAL|DECLARE|DEFAULT|DEFINER|DELAYED|DELETE|DELIMITERS?|DENY|DESC|DESCRIBE|DETERMINISTIC|DISABLE|DISCARD|DISK|DISTINCT|DISTINCTROW|DISTRIBUTED|DO|DOUBLE|DROP|DUMMY|DUMP(?:FILE)?|DUPLICATE|ELSE(?:IF)?|ENABLE|ENCLOSED|END|ENGINE|ENUM|ERRLVL|ERRORS|ESCAPED?|EXCEPT|EXEC(?:UTE)?|EXISTS|EXIT|EXPLAIN|EXTENDED|FETCH|FIELDS|FILE|FILLFACTOR|FIRST|FIXED|FLOAT|FOLLOWING|FOR(?: EACH ROW)?|FORCE|FOREIGN|FREETEXT(?:TABLE)?|FROM|FULL|FUNCTION|GEOMETRY(?:COLLECTION)?|GLOBAL|GOTO|GRANT|GROUP|HANDLER|HASH|HAVING|HOLDLOCK|HOUR|IDENTITY(?:COL|_INSERT)?|IF|IGNORE|IMPORT|INDEX|INFILE|INNER|INNODB|INOUT|INSERT|INT|INTEGER|INTERSECT|INTERVAL|INTO|INVOKER|ISOLATION|ITERATE|JOIN|KEYS?|KILL|LANGUAGE|LAST|LEAVE|LEFT|LEVEL|LIMIT|LINENO|LINES|LINESTRING|LOAD|LOCAL|LOCK|LONG(?:BLOB|TEXT)|LOOP|MATCH(?:ED)?|MEDIUM(?:BLOB|INT|TEXT)|MERGE|MIDDLEINT|MINUTE|MODE|MODIFIES|MODIFY|MONTH|MULTI(?:LINESTRING|POINT|POLYGON)|NATIONAL|NATURAL|NCHAR|NEXT|NO|NONCLUSTERED|NULLIF|NUMERIC|OFF?|OFFSETS?|ON|OPEN(?:DATASOURCE|QUERY|ROWSET)?|OPTIMIZE|OPTION(?:ALLY)?|ORDER|OUT(?:ER|FILE)?|OVER|PARTIAL|PARTITION|PERCENT|PIVOT|PLAN|POINT|POLYGON|PRECEDING|PRECISION|PREPARE|PREV|PRIMARY|PRINT|PRIVILEGES|PROC(?:EDURE)?|PUBLIC|PURGE|QUICK|RAISERROR|READS?|REAL|RECONFIGURE|REFERENCES|RELEASE|RENAME|REPEAT(?:ABLE)?|REPLACE|REPLICATION|REQUIRE|RESIGNAL|RESTORE|RESTRICT|RETURN(?:ING|S)?|REVOKE|RIGHT|ROLLBACK|ROUTINE|ROW(?:COUNT|GUIDCOL|S)?|RTREE|RULE|SAVE(?:POINT)?|SCHEMA|SECOND|SELECT|SERIAL(?:IZABLE)?|SESSION(?:_USER)?|SET(?:USER)?|SHARE|SHOW|SHUTDOWN|SIMPLE|SMALLINT|SNAPSHOT|SOME|SONAME|SQL|START(?:ING)?|STATISTICS|STATUS|STRIPED|SYSTEM_USER|TABLES?|TABLESPACE|TEMP(?:ORARY|TABLE)?|TERMINATED|TEXT(?:SIZE)?|THEN|TIME(?:STAMP)?|TINY(?:BLOB|INT|TEXT)|TOP?|TRAN(?:SACTIONS?)?|TRIGGER|TRUNCATE|TSEQUAL|TYPES?|UNBOUNDED|UNCOMMITTED|UNDEFINED|UNION|UNIQUE|UNLOCK|UNPIVOT|UNSIGNED|UPDATE(?:TEXT)?|USAGE|USE|USER|USING|VALUES?|VAR(?:BINARY|CHAR|CHARACTER|YING)|VIEW|WAITFOR|WARNINGS|WHEN|WHERE|WHILE|WITH(?: ROLLUP|IN)?|WORK|WRITE(?:TEXT)?|YEAR)\b/i,
+	boolean: /\b(?:FALSE|NULL|TRUE)\b/i,
+	number: /\b0x[\da-f]+\b|\b\d+(?:\.\d*)?|\B\.\d+\b/i,
+	operator: /[-+*\/=%^~]|&&?|\|\|?|!=?|<(?:=>?|<|>)?|>[>=]?|\b(?:AND|BETWEEN|DIV|ILIKE|IN|IS|LIKE|NOT|OR|REGEXP|RLIKE|SOUNDS LIKE|XOR)\b/i,
+	punctuation: /[;[\]()`,.]/
+}, (function(e) {
+	var t = globalThis.Prism.languages.powershell = {
+		comment: [{
+			pattern: /(^|[^`])<#[\s\S]*?#>/,
+			lookbehind: !0
+		}, {
+			pattern: /(^|[^`])#.*/,
+			lookbehind: !0
+		}],
+		string: [{
+			pattern: /"(?:`[\s\S]|[^`"])*"/,
+			greedy: !0,
+			inside: null
+		}, {
+			pattern: /'(?:[^']|'')*'/,
+			greedy: !0
+		}],
+		namespace: /\[[a-z](?:\[(?:\[[^\]]*\]|[^\[\]])*\]|[^\[\]])*\]/i,
+		boolean: /\$(?:false|true)\b/i,
+		variable: /\$\w+\b/,
+		function: [/\b(?:Add|Approve|Assert|Backup|Block|Checkpoint|Clear|Close|Compare|Complete|Compress|Confirm|Connect|Convert|ConvertFrom|ConvertTo|Copy|Debug|Deny|Disable|Disconnect|Dismount|Edit|Enable|Enter|Exit|Expand|Export|Find|ForEach|Format|Get|Grant|Group|Hide|Import|Initialize|Install|Invoke|Join|Limit|Lock|Measure|Merge|Move|New|Open|Optimize|Out|Ping|Pop|Protect|Publish|Push|Read|Receive|Redo|Register|Remove|Rename|Repair|Request|Reset|Resize|Resolve|Restart|Restore|Resume|Revoke|Save|Search|Select|Send|Set|Show|Skip|Sort|Split|Start|Step|Stop|Submit|Suspend|Switch|Sync|Tee|Test|Trace|Unblock|Undo|Uninstall|Unlock|Unprotect|Unpublish|Unregister|Update|Use|Wait|Watch|Where|Write)-[a-z]+\b/i, /\b(?:ac|cat|chdir|clc|cli|clp|clv|compare|copy|cp|cpi|cpp|cvpa|dbp|del|diff|dir|ebp|echo|epal|epcsv|epsn|erase|fc|fl|ft|fw|gal|gbp|gc|gci|gcs|gdr|gi|gl|gm|gp|gps|group|gsv|gu|gv|gwmi|iex|ii|ipal|ipcsv|ipsn|irm|iwmi|iwr|kill|lp|ls|measure|mi|mount|move|mp|mv|nal|ndr|ni|nv|ogv|popd|ps|pushd|pwd|rbp|rd|rdr|ren|ri|rm|rmdir|rni|rnp|rp|rv|rvpa|rwmi|sal|saps|sasv|sbp|sc|select|set|shcm|si|sl|sleep|sls|sort|sp|spps|spsv|start|sv|swmi|tee|trcm|type|write)\b/i],
+		keyword: /\b(?:Begin|Break|Catch|Class|Continue|Data|Define|Do|DynamicParam|Else|ElseIf|End|Exit|Filter|Finally|For|ForEach|From|Function|If|InlineScript|Parallel|Param|Process|Return|Sequence|Switch|Throw|Trap|Try|Until|Using|Var|While|Workflow)\b/i,
+		operator: {
+			pattern: /(^|\W)(?:!|-(?:b?(?:and|x?or)|as|(?:Not)?(?:Contains|In|Like|Match)|eq|ge|gt|is(?:Not)?|Join|le|lt|ne|not|Replace|sh[lr])\b|-[-=]?|\+[+=]?|[*\/%]=?)/i,
+			lookbehind: !0
+		},
+		punctuation: /[|{}[\];(),.]/
+	};
+	t.string[0].inside = {
+		function: {
+			pattern: /(^|[^`])\$\((?:\$\([^\r\n()]*\)|(?!\$\()[^\r\n)])*\)/,
+			lookbehind: !0,
+			inside: t
+		},
+		boolean: t.boolean,
+		variable: t.variable
+	};
+})(globalThis.Prism), globalThis.Prism.languages.python = {
+	comment: {
+		pattern: /(^|[^\\])#.*/,
+		lookbehind: !0,
+		greedy: !0
+	},
+	"string-interpolation": {
+		pattern: /(?:f|fr|rf)(?:("""|''')[\s\S]*?\1|("|')(?:\\.|(?!\2)[^\\\r\n])*\2)/i,
+		greedy: !0,
+		inside: {
+			interpolation: {
+				pattern: /((?:^|[^{])(?:\{\{)*)\{(?!\{)(?:[^{}]|\{(?!\{)(?:[^{}]|\{(?!\{)(?:[^{}])+\})+\})+\}/,
+				lookbehind: !0,
+				inside: {
+					"format-spec": {
+						pattern: /(:)[^:(){}]+(?=\}$)/,
+						lookbehind: !0
+					},
+					"conversion-option": {
+						pattern: /![sra](?=[:}]$)/,
+						alias: "punctuation"
+					},
+					rest: null
+				}
+			},
+			string: /[\s\S]+/
+		}
+	},
+	"triple-quoted-string": {
+		pattern: /(?:[rub]|br|rb)?("""|''')[\s\S]*?\1/i,
+		greedy: !0,
+		alias: "string"
+	},
+	string: {
+		pattern: /(?:[rub]|br|rb)?("|')(?:\\.|(?!\1)[^\\\r\n])*\1/i,
+		greedy: !0
+	},
+	function: {
+		pattern: /((?:^|\s)def[ \t]+)[a-zA-Z_]\w*(?=\s*\()/g,
+		lookbehind: !0
+	},
+	"class-name": {
+		pattern: /(\bclass\s+)\w+/i,
+		lookbehind: !0
+	},
+	decorator: {
+		pattern: /(^[\t ]*)@\w+(?:\.\w+)*/m,
+		lookbehind: !0,
+		alias: ["annotation", "punctuation"],
+		inside: { punctuation: /\./ }
+	},
+	keyword: /\b(?:_(?=\s*:)|and|as|assert|async|await|break|case|class|continue|def|del|elif|else|except|exec|finally|for|from|global|if|import|in|is|lambda|match|nonlocal|not|or|pass|print|raise|return|try|while|with|yield)\b/,
+	builtin: /\b(?:__import__|abs|all|any|apply|ascii|basestring|bin|bool|buffer|bytearray|bytes|callable|chr|classmethod|cmp|coerce|compile|complex|delattr|dict|dir|divmod|enumerate|eval|execfile|file|filter|float|format|frozenset|getattr|globals|hasattr|hash|help|hex|id|input|int|intern|isinstance|issubclass|iter|len|list|locals|long|map|max|memoryview|min|next|object|oct|open|ord|pow|property|range|raw_input|reduce|reload|repr|reversed|round|set|setattr|slice|sorted|staticmethod|str|sum|super|tuple|type|unichr|unicode|vars|xrange|zip)\b/,
+	boolean: /\b(?:False|None|True)\b/,
+	number: /\b0(?:b(?:_?[01])+|o(?:_?[0-7])+|x(?:_?[a-f0-9])+)\b|(?:\b\d+(?:_\d+)*(?:\.(?:\d+(?:_\d+)*)?)?|\B\.\d+(?:_\d+)*)(?:e[+-]?\d+(?:_\d+)*)?j?(?!\w)/i,
+	operator: /[-+%=]=?|!=|:=|\*\*?=?|\/\/?=?|<[<=>]?|>[=>]?|[&|^~]/,
+	punctuation: /[{}[\];(),.:]/
+}, globalThis.Prism.languages.python["string-interpolation"].inside.interpolation.inside.rest = globalThis.Prism.languages.python, globalThis.Prism.languages.py = globalThis.Prism.languages.python, (function(e) {
+	for (var t = "\\/\\*(?:[^*/]|\\*(?!\\/)|\\/(?!\\*)|<self>)*\\*\\/", n = 0; n < 2; n++) t = t.replace(/<self>/g, function() {
+		return t;
+	});
+	t = t.replace(/<self>/g, function() {
+		return "[^\\s\\S]";
+	}), globalThis.Prism.languages.rust = {
+		comment: [{
+			pattern: RegExp("(^|[^\\\\])" + t),
+			lookbehind: !0,
+			greedy: !0
+		}, {
+			pattern: /(^|[^\\:])\/\/.*/,
+			lookbehind: !0,
+			greedy: !0
+		}],
+		string: {
+			pattern: /b?"(?:\\[\s\S]|[^\\"])*"|b?r(#*)"(?:[^"]|"(?!\1))*"\1/,
+			greedy: !0
+		},
+		char: {
+			pattern: /b?'(?:\\(?:x[0-7][\da-fA-F]|u\{(?:[\da-fA-F]_*){1,6}\}|.)|[^\\\r\n\t'])'/,
+			greedy: !0
+		},
+		attribute: {
+			pattern: /#!?\[(?:[^\[\]"]|"(?:\\[\s\S]|[^\\"])*")*\]/,
+			greedy: !0,
+			alias: "attr-name",
+			inside: { string: null }
+		},
+		"closure-params": {
+			pattern: /([=(,:]\s*|\bmove\s*)\|[^|]*\||\|[^|]*\|(?=\s*(?:\{|->))/,
+			lookbehind: !0,
+			greedy: !0,
+			inside: {
+				"closure-punctuation": {
+					pattern: /^\||\|$/,
+					alias: "punctuation"
+				},
+				rest: null
+			}
+		},
+		"lifetime-annotation": {
+			pattern: /'\w+/,
+			alias: "symbol"
+		},
+		"fragment-specifier": {
+			pattern: /(\$\w+:)[a-z]+/,
+			lookbehind: !0,
+			alias: "punctuation"
+		},
+		variable: /\$\w+/,
+		"function-definition": {
+			pattern: /(\bfn\s+)\w+/,
+			lookbehind: !0,
+			alias: "function"
+		},
+		"type-definition": {
+			pattern: /(\b(?:enum|struct|trait|type|union)\s+)\w+/,
+			lookbehind: !0,
+			alias: "class-name"
+		},
+		"module-declaration": [{
+			pattern: /(\b(?:crate|mod)\s+)[a-z][a-z_\d]*/,
+			lookbehind: !0,
+			alias: "namespace"
+		}, {
+			pattern: /(\b(?:crate|self|super)\s*)::\s*[a-z][a-z_\d]*\b(?:\s*::(?:\s*[a-z][a-z_\d]*\s*::)*)?/,
+			lookbehind: !0,
+			alias: "namespace",
+			inside: { punctuation: /::/ }
+		}],
+		keyword: [/\b(?:Self|abstract|as|async|await|become|box|break|const|continue|crate|do|dyn|else|enum|extern|final|fn|for|if|impl|in|let|loop|macro|match|mod|move|mut|override|priv|pub|ref|return|self|static|struct|super|trait|try|type|typeof|union|unsafe|unsized|use|virtual|where|while|yield)\b/, /\b(?:bool|char|f(?:32|64)|[ui](?:8|16|32|64|128|size)|str)\b/],
+		function: /\b[a-z_]\w*(?=\s*(?:::\s*<|\())/,
+		macro: {
+			pattern: /\b\w+!/,
+			alias: "property"
+		},
+		constant: /\b[A-Z_][A-Z_\d]+\b/,
+		"class-name": /\b[A-Z]\w*\b/,
+		namespace: {
+			pattern: /(?:\b[a-z][a-z_\d]*\s*::\s*)*\b[a-z][a-z_\d]*\s*::(?!\s*<)/,
+			inside: { punctuation: /::/ }
+		},
+		number: /\b(?:0x[\dA-Fa-f](?:_?[\dA-Fa-f])*|0o[0-7](?:_?[0-7])*|0b[01](?:_?[01])*|(?:(?:\d(?:_?\d)*)?\.)?\d(?:_?\d)*(?:[Ee][+-]?\d+)?)(?:_?(?:f32|f64|[iu](?:8|16|32|64|size)?))?\b/,
+		boolean: /\b(?:false|true)\b/,
+		punctuation: /->|\.\.=|\.{1,3}|::|[{}[\];(),:]/,
+		operator: /[-+*\/%!^]=?|=[=>]?|&[&=]?|\|[|=]?|<<?=?|>>?=?|[@?]/
+	}, globalThis.Prism.languages.rust["closure-params"].inside.rest = globalThis.Prism.languages.rust, globalThis.Prism.languages.rust.attribute.inside.string = globalThis.Prism.languages.rust.string;
+})(globalThis.Prism), globalThis.Prism.languages.swift = {
+	comment: {
+		pattern: /(^|[^\\:])(?:\/\/.*|\/\*(?:[^/*]|\/(?!\*)|\*(?!\/)|\/\*(?:[^*]|\*(?!\/))*\*\/)*\*\/)/,
+		lookbehind: !0,
+		greedy: !0
+	},
+	"string-literal": [{
+		pattern: RegExp("(^|[^\"#])(?:\"(?:\\\\(?:\\((?:[^()]|\\([^()]*\\))*\\)|\\r\\n|[^(])|[^\\\\\\r\\n\"])*\"|\"\"\"(?:\\\\(?:\\((?:[^()]|\\([^()]*\\))*\\)|[^(])|[^\\\\\"]|\"(?!\"\"))*\"\"\")(?![\"#])"),
+		lookbehind: !0,
+		greedy: !0,
+		inside: {
+			interpolation: {
+				pattern: /(\\\()(?:[^()]|\([^()]*\))*(?=\))/,
+				lookbehind: !0,
+				inside: null
+			},
+			"interpolation-punctuation": {
+				pattern: /^\)|\\\($/,
+				alias: "punctuation"
+			},
+			punctuation: /\\(?=[\r\n])/,
+			string: /[\s\S]+/
+		}
+	}, {
+		pattern: RegExp("(^|[^\"#])(#+)(?:\"(?:\\\\(?:#+\\((?:[^()]|\\([^()]*\\))*\\)|\\r\\n|[^#])|[^\\\\\\r\\n])*?\"|\"\"\"(?:\\\\(?:#+\\((?:[^()]|\\([^()]*\\))*\\)|[^#])|[^\\\\])*?\"\"\")\\2"),
+		lookbehind: !0,
+		greedy: !0,
+		inside: {
+			interpolation: {
+				pattern: /(\\#+\()(?:[^()]|\([^()]*\))*(?=\))/,
+				lookbehind: !0,
+				inside: null
+			},
+			"interpolation-punctuation": {
+				pattern: /^\)|\\#+\($/,
+				alias: "punctuation"
+			},
+			string: /[\s\S]+/
+		}
+	}],
+	directive: {
+		pattern: RegExp("#(?:(?:elseif|if)\\b(?:[ 	]*(?:![ \\t]*)?(?:\\b\\w+\\b(?:[ \\t]*\\((?:[^()]|\\([^()]*\\))*\\))?|\\((?:[^()]|\\([^()]*\\))*\\))(?:[ \\t]*(?:&&|\\|\\|))?)+|(?:else|endif)\\b)"),
+		alias: "property",
+		inside: {
+			"directive-name": /^#\w+/,
+			boolean: /\b(?:false|true)\b/,
+			number: /\b\d+(?:\.\d+)*\b/,
+			operator: /!|&&|\|\||[<>]=?/,
+			punctuation: /[(),]/
+		}
+	},
+	literal: {
+		pattern: /#(?:colorLiteral|column|dsohandle|file(?:ID|Literal|Path)?|function|imageLiteral|line)\b/,
+		alias: "constant"
+	},
+	"other-directive": {
+		pattern: /#\w+\b/,
+		alias: "property"
+	},
+	attribute: {
+		pattern: /@\w+/,
+		alias: "atrule"
+	},
+	"function-definition": {
+		pattern: /(\bfunc\s+)\w+/,
+		lookbehind: !0,
+		alias: "function"
+	},
+	label: {
+		pattern: /\b(break|continue)\s+\w+|\b[a-zA-Z_]\w*(?=\s*:\s*(?:for|repeat|while)\b)/,
+		lookbehind: !0,
+		alias: "important"
+	},
+	keyword: /\b(?:Any|Protocol|Self|Type|actor|as|assignment|associatedtype|associativity|async|await|break|case|catch|class|continue|convenience|default|defer|deinit|didSet|do|dynamic|else|enum|extension|fallthrough|fileprivate|final|for|func|get|guard|higherThan|if|import|in|indirect|infix|init|inout|internal|is|isolated|lazy|left|let|lowerThan|mutating|none|nonisolated|nonmutating|open|operator|optional|override|postfix|precedencegroup|prefix|private|protocol|public|repeat|required|rethrows|return|right|safe|self|set|some|static|struct|subscript|super|switch|throw|throws|try|typealias|unowned|unsafe|var|weak|where|while|willSet)\b/,
+	boolean: /\b(?:false|true)\b/,
+	nil: {
+		pattern: /\bnil\b/,
+		alias: "constant"
+	},
+	"short-argument": /\$\d+\b/,
+	omit: {
+		pattern: /\b_\b/,
+		alias: "keyword"
+	},
+	number: /\b(?:[\d_]+(?:\.[\de_]+)?|0x[a-f0-9_]+(?:\.[a-f0-9p_]+)?|0b[01_]+|0o[0-7_]+)\b/i,
+	"class-name": /\b[A-Z](?:[A-Z_\d]*[a-z]\w*)?\b/,
+	function: /\b[a-z_]\w*(?=\s*\()/i,
+	constant: /\b(?:[A-Z_]{2,}|k[A-Z][A-Za-z_]+)\b/,
+	operator: /[-+*/%=!<>&|^~?]+|\.[.\-+*/%=!<>&|^~?]+/,
+	punctuation: /[{}[\]();,.:\\]/
+}, globalThis.Prism.languages.swift["string-literal"].forEach(function(e) {
+	e.inside.interpolation.inside = globalThis.Prism.languages.swift;
+}), (function(e) {
+	globalThis.Prism.languages.typescript = globalThis.Prism.languages.extend("javascript", {
+		"class-name": {
+			pattern: /(\b(?:class|extends|implements|instanceof|interface|new|type)\s+)(?!keyof\b)(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?:\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>)?/,
+			lookbehind: !0,
+			greedy: !0,
+			inside: null
+		},
+		builtin: /\b(?:Array|Function|Promise|any|boolean|console|never|number|string|symbol|unknown)\b/
+	}), globalThis.Prism.languages.typescript.keyword.push(/\b(?:abstract|declare|is|keyof|readonly|require)\b/, /\b(?:asserts|infer|interface|module|namespace|type)\b(?=\s*(?:[{_$a-zA-Z\xA0-\uFFFF]|$))/, /\btype\b(?=\s*(?:[\{*]|$))/), delete globalThis.Prism.languages.typescript.parameter, delete globalThis.Prism.languages.typescript["literal-property"];
+	var t = globalThis.Prism.languages.extend("typescript", {});
+	delete t["class-name"], globalThis.Prism.languages.typescript["class-name"].inside = t, globalThis.Prism.languages.insertBefore("typescript", "function", {
+		decorator: {
+			pattern: /@[$\w\xA0-\uFFFF]+/,
+			inside: {
+				at: {
+					pattern: /^@/,
+					alias: "operator"
+				},
+				function: /^[\s\S]+/
+			}
+		},
+		"generic-function": {
+			pattern: /#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>(?=\s*\()/,
+			greedy: !0,
+			inside: {
+				function: /^#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*/,
+				generic: {
+					pattern: /<[\s\S]+/,
+					alias: "class-name",
+					inside: t
+				}
+			}
+		}
+	}), globalThis.Prism.languages.ts = globalThis.Prism.languages.typescript;
+})(globalThis.Prism), (function(e) {
+	var t = /\b(?:abstract|assert|boolean|break|byte|case|catch|char|class|const|continue|default|do|double|else|enum|exports|extends|final|finally|float|for|goto|if|implements|import|instanceof|int|interface|long|module|native|new|non-sealed|null|open|opens|package|permits|private|protected|provides|public|record(?!\s*[(){}[\]<>=%~.:,;?+\-*/&|^])|requires|return|sealed|short|static|strictfp|super|switch|synchronized|this|throw|throws|to|transient|transitive|try|uses|var|void|volatile|while|with|yield)\b/, n = "(?:[a-z]\\w*\\s*\\.\\s*)*(?:[A-Z]\\w*\\s*\\.\\s*)*", r = {
+		pattern: RegExp("(^|[^\\w.])" + n + "[A-Z](?:[\\d_A-Z]*[a-z]\\w*)?\\b"),
+		lookbehind: !0,
+		inside: {
+			namespace: {
+				pattern: /^[a-z]\w*(?:\s*\.\s*[a-z]\w*)*(?:\s*\.)?/,
+				inside: { punctuation: /\./ }
+			},
+			punctuation: /\./
+		}
+	};
+	globalThis.Prism.languages.java = globalThis.Prism.languages.extend("clike", {
+		string: {
+			pattern: /(^|[^\\])"(?:\\.|[^"\\\r\n])*"/,
+			lookbehind: !0,
+			greedy: !0
+		},
+		"class-name": [
+			r,
+			{
+				pattern: RegExp("(^|[^\\w.])" + n + "[A-Z]\\w*(?=\\s+\\w+\\s*[;,=()]|\\s*(?:\\[[\\s,]*\\]\\s*)?::\\s*new\\b)"),
+				lookbehind: !0,
+				inside: r.inside
+			},
+			{
+				pattern: RegExp("(\\b(?:class|enum|extends|implements|instanceof|interface|new|record|throws)\\s+)" + n + "[A-Z]\\w*\\b"),
+				lookbehind: !0,
+				inside: r.inside
+			}
+		],
+		keyword: t,
+		function: [globalThis.Prism.languages.clike.function, {
+			pattern: /(::\s*)[a-z_]\w*/,
+			lookbehind: !0
+		}],
+		number: /\b0b[01][01_]*L?\b|\b0x(?:\.[\da-f_p+-]+|[\da-f_]+(?:\.[\da-f_p+-]+)?)\b|(?:\b\d[\d_]*(?:\.[\d_]*)?|\B\.\d[\d_]*)(?:e[+-]?\d[\d_]*)?[dfl]?/i,
+		operator: {
+			pattern: /(^|[^.])(?:<<=?|>>>?=?|->|--|\+\+|&&|\|\||::|[?:~]|[-+*/%&|^!=<>]=?)/m,
+			lookbehind: !0
+		},
+		constant: /\b[A-Z][A-Z_\d]+\b/
+	}), globalThis.Prism.languages.insertBefore("java", "string", {
+		"triple-quoted-string": {
+			pattern: /"""[ \t]*[\r\n](?:(?:"|"")?(?:\\.|[^"\\]))*"""/,
+			greedy: !0,
+			alias: "string"
+		},
+		char: {
+			pattern: /'(?:\\.|[^'\\\r\n]){1,6}'/,
+			greedy: !0
+		}
+	}), globalThis.Prism.languages.insertBefore("java", "class-name", {
+		annotation: {
+			pattern: /(^|[^.])@\w+(?:\s*\.\s*\w+)*/,
+			lookbehind: !0,
+			alias: "punctuation"
+		},
+		generics: {
+			pattern: /<(?:[\w\s,.?]|&(?!&)|<(?:[\w\s,.?]|&(?!&)|<(?:[\w\s,.?]|&(?!&)|<(?:[\w\s,.?]|&(?!&))*>)*>)*>)*>/,
+			inside: {
+				"class-name": r,
+				keyword: t,
+				punctuation: /[<>(),.:]/,
+				operator: /[?&|]/
+			}
+		},
+		import: [{
+			pattern: RegExp("(\\bimport\\s+)" + n + "(?:[A-Z]\\w*|\\*)(?=\\s*;)"),
+			lookbehind: !0,
+			inside: {
+				namespace: r.inside.namespace,
+				punctuation: /\./,
+				operator: /\*/,
+				"class-name": /\w+/
+			}
+		}, {
+			pattern: RegExp("(\\bimport\\s+static\\s+)" + n + "(?:\\w+|\\*)(?=\\s*;)"),
+			lookbehind: !0,
+			alias: "static",
+			inside: {
+				namespace: r.inside.namespace,
+				static: /\b\w+$/,
+				punctuation: /\./,
+				operator: /\*/,
+				"class-name": /\w+/
+			}
+		}],
+		namespace: {
+			pattern: RegExp("(\\b(?:exports|import(?:\\s+static)?|module|open|opens|package|provides|requires|to|transitive|uses|with)\\s+)(?!<keyword>)[a-z]\\w*(?:\\.[a-z]\\w*)*\\.?".replace(/<keyword>/g, function() {
+				return t.source;
+			})),
+			lookbehind: !0,
+			inside: { punctuation: /\./ }
+		}
+	});
+})(globalThis.Prism), (function(e) {
+	var t = /\b(?:alignas|alignof|asm|auto|bool|break|case|catch|char|char16_t|char32_t|char8_t|class|co_await|co_return|co_yield|compl|concept|const|const_cast|consteval|constexpr|constinit|continue|decltype|default|delete|do|double|dynamic_cast|else|enum|explicit|export|extern|final|float|for|friend|goto|if|import|inline|int|int16_t|int32_t|int64_t|int8_t|long|module|mutable|namespace|new|noexcept|nullptr|operator|override|private|protected|public|register|reinterpret_cast|requires|return|short|signed|sizeof|static|static_assert|static_cast|struct|switch|template|this|thread_local|throw|try|typedef|typeid|typename|uint16_t|uint32_t|uint64_t|uint8_t|union|unsigned|using|virtual|void|volatile|wchar_t|while)\b/, n = "\\b(?!<keyword>)\\w+(?:\\s*\\.\\s*\\w+)*\\b".replace(/<keyword>/g, function() {
+		return t.source;
+	});
+	globalThis.Prism.languages.cpp = globalThis.Prism.languages.extend("c", {
+		"class-name": [
+			{
+				pattern: RegExp("(\\b(?:class|concept|enum|struct|typename)\\s+)(?!<keyword>)\\w+".replace(/<keyword>/g, function() {
+					return t.source;
+				})),
+				lookbehind: !0
+			},
+			/\b[A-Z]\w*(?=\s*::\s*\w+\s*\()/,
+			/\b[A-Z_]\w*(?=\s*::\s*~\w+\s*\()/i,
+			/\b\w+(?=\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>\s*::\s*\w+\s*\()/
+		],
+		keyword: t,
+		number: {
+			pattern: /(?:\b0b[01']+|\b0x(?:[\da-f']+(?:\.[\da-f']*)?|\.[\da-f']+)(?:p[+-]?[\d']+)?|(?:\b[\d']+(?:\.[\d']*)?|\B\.[\d']+)(?:e[+-]?[\d']+)?)[ful]{0,4}/i,
+			greedy: !0
+		},
+		operator: />>=?|<<=?|->|--|\+\+|&&|\|\||[?:~]|<=>|[-+*/%&|^!=<>]=?|\b(?:and|and_eq|bitand|bitor|not|not_eq|or|or_eq|xor|xor_eq)\b/,
+		boolean: /\b(?:false|true)\b/
+	}), globalThis.Prism.languages.insertBefore("cpp", "string", {
+		module: {
+			pattern: RegExp("(\\b(?:import|module)\\s+)(?:\"(?:\\\\(?:\\r\\n|[\\s\\S])|[^\"\\\\\\r\\n])*\"|<[^<>\\r\\n]*>|" + "<mod-name>(?:\\s*:\\s*<mod-name>)?|:\\s*<mod-name>".replace(/<mod-name>/g, function() {
+				return n;
+			}) + ")"),
+			lookbehind: !0,
+			greedy: !0,
+			inside: {
+				string: /^[<"][\s\S]+/,
+				operator: /:/,
+				punctuation: /\./
+			}
+		},
+		"raw-string": {
+			pattern: /R"([^()\\ ]{0,16})\([\s\S]*?\)\1"/,
+			alias: "string",
+			greedy: !0
+		}
+	}), globalThis.Prism.languages.insertBefore("cpp", "keyword", { "generic-function": {
+		pattern: /\b(?!operator\b)[a-z_]\w*\s*<(?:[^<>]|<[^<>]*>)*>(?=\s*\()/i,
+		inside: {
+			function: /^\w+/,
+			generic: {
+				pattern: /<[\s\S]+/,
+				alias: "class-name",
+				inside: globalThis.Prism.languages.cpp
+			}
+		}
+	} }), globalThis.Prism.languages.insertBefore("cpp", "operator", { "double-colon": {
+		pattern: /::/,
+		alias: "punctuation"
+	} }), globalThis.Prism.languages.insertBefore("cpp", "class-name", { "base-clause": {
+		pattern: /(\b(?:class|struct)\s+\w+\s*:\s*)[^;{}"'\s]+(?:\s+[^;{}"'\s]+)*(?=\s*[;{])/,
+		lookbehind: !0,
+		greedy: !0,
+		inside: globalThis.Prism.languages.extend("cpp", {})
+	} }), globalThis.Prism.languages.insertBefore("inside", "double-colon", { "class-name": /\b[a-z_]\w*\b(?!\s*::)/i }, globalThis.Prism.languages.cpp["base-clause"]);
+})(globalThis.Prism);
+//#endregion
+//#region node_modules/@lexical/code-prism/LexicalCodePrism.prod.mjs
+function B(e, ...t) {
+	let n = new URL("https://lexical.dev/docs/error"), r = new URLSearchParams();
+	r.append("code", e);
+	for (let e of t) r.append("v", e);
+	throw n.search = r.toString(), Error(`Minified Lexical error #${e}; visit ${n.toString()} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`);
+}
+(function(e) {
+	e.languages.diff = { coord: [
+		/^(?:\*{3}|-{3}|\+{3}).*$/m,
+		/^@@.*@@$/m,
+		/^\d.*$/m
+	] };
+	var t = {
+		"deleted-sign": "-",
+		"deleted-arrow": "<",
+		"inserted-sign": "+",
+		"inserted-arrow": ">",
+		unchanged: " ",
+		diff: "!"
+	};
+	Object.keys(t).forEach(function(n) {
+		var r = t[n], i = [];
+		/^\w+$/.test(n) || i.push(/\w+/.exec(n)[0]), n === "diff" && i.push("bold"), e.languages.diff[n] = {
+			pattern: RegExp("^(?:[" + r + "].*(?:\r\n?|\n|(?![\\s\\S])))+", "m"),
+			alias: i,
+			inside: {
+				line: {
+					pattern: /(.)(?=[\s\S]).*(?:\r\n?|\n)?/,
+					lookbehind: !0
+				},
+				prefix: {
+					pattern: /[\s\S]/,
+					alias: /\w+/.exec(n)[0]
+				}
+			}
+		};
+	}), Object.defineProperty(e.languages.diff, "PREFIXES", { value: t });
+})(globalThis.Prism);
+var V = globalThis.Prism || window.Prism;
+function se(e) {
+	let t = function(e) {
+		let t = /^diff-([\w-]+)/i.exec(e);
+		return t ? t[1] : null;
+	}(e) || e;
+	try {
+		return !!t && V.languages.hasOwnProperty(t);
+	} catch {
+		return !1;
+	}
+}
+async function ce(e, t, n) {}
+function H(e) {
+	return typeof e == "string" ? e : Array.isArray(e) ? e.map(H).join("") : H(e.content);
+}
+function le(e, t) {
+	let n = /^diff-([\w-]+)/i.exec(t), r = e.getTextContent(), i = V.tokenize(r, V.languages[n ? "diff" : t]);
+	return n && (i = function(e, t) {
+		let n = t, r = V.languages[n], i = { tokens: e }, a = V.languages.diff.PREFIXES;
+		for (let e of i.tokens) {
+			if (typeof e == "string" || !(e.type in a) || !Array.isArray(e.content)) continue;
+			let t = e.type, n = 0, i = () => (n++, new V.Token("prefix", a[t], t.replace(/^(\w+).*/, "$1"))), o = e.content.filter((e) => typeof e == "string" || e.type !== "prefix"), s = e.content.length - o.length, c = V.tokenize(H(o), r);
+			c.unshift(i());
+			let l = /\r\n|\n/g, u = (e) => {
+				let t = [];
+				l.lastIndex = 0;
+				let r, a = 0;
+				for (; n < s && (r = l.exec(e));) {
+					let n = r.index + r[0].length;
+					t.push(e.slice(a, n)), a = n, t.push(i());
+				}
+				if (t.length !== 0) return a < e.length && t.push(e.slice(a)), t;
+			}, d = (e) => {
+				for (let t = 0; t < e.length && n < s; t++) {
+					let n = e[t];
+					if (typeof n == "string") {
+						let r = u(n);
+						r && (e.splice(t, 1, ...r), t += r.length - 1);
+					} else if (typeof n.content == "string") {
+						let e = u(n.content);
+						e && (n.content = e);
+					} else Array.isArray(n.content) ? d(n.content) : d([n.content]);
+				}
+			};
+			d(c), n < s && c.push(i()), e.content = c;
+		}
+		return i.tokens;
+	}(i, n[1])), U(i);
+}
+function U(e, t) {
+	let n = [];
+	for (let r of e) if (typeof r == "string") {
+		let e = r.split(/(\n|\t)/), i = e.length;
+		for (let r = 0; r < i; r++) {
+			let i = e[r];
+			i === "\n" || i === "\r\n" ? n.push(h()) : i === "	" ? n.push(_()) : i.length > 0 && n.push(o(i, t));
+		}
+	} else {
+		let { content: e, alias: t } = r;
+		typeof e == "string" ? n.push(...U([e], r.type === "prefix" && typeof t == "string" ? t : r.type)) : Array.isArray(e) && n.push(...U(e, r.type === "unchanged" ? void 0 : r.type));
+	}
+	return n;
+}
+var W = {
+	$tokenize(e, t) {
+		return le(e, t || this.defaultLanguage);
+	},
+	defaultLanguage: e,
+	tokenize(e, t) {
+		return V.tokenize(e, V.languages[t || ""] || V.languages[this.defaultLanguage]);
+	}
+};
+function G(e, t, r, i) {
+	let a = i.getParent();
+	m(a) ? K(e, t, r, a) : n(i) && i.replace(v(i.__text));
+}
+function ue(e, t) {
+	let n = t.getElementByKey(e.getKey());
+	if (n === null) return;
+	let r = e.getChildren(), i = r.length;
+	if (i === n.__cachedChildrenLength) return;
+	n.__cachedChildrenLength = i;
+	let a = "1", o = 1;
+	for (let e = 0; e < i; e++) E(r[e]) && (a += "\n" + ++o);
+	n.setAttribute("data-gutter", a);
+}
+function K(e, t, n, r) {
+	let { nodesCurrentlyHighlighting: i } = n, a = r.getKey();
+	if (r.getLanguage() === void 0 && r.setLanguage(t.defaultLanguage), !se(r.getLanguage() || t.defaultLanguage)) return r.getIsSyntaxHighlightSupported() && r.setIsSyntaxHighlightSupported(!1), void ce();
+	r.getIsSyntaxHighlightSupported() || r.setIsSyntaxHighlightSupported(!0), i.has(a) || (i.add(a), n.didTransform || (n.didTransform = !0, re(() => {
+		n.didTransform = !1, i.clear();
+	})), function(e, t) {
+		let n = b(e);
+		if (!m(n) || !n.isAttached()) return;
+		let r = S();
+		if (!D(r)) return void t();
+		let i = r.anchor, a = i.offset, o = i.type === "element" && E(n.getChildAtIndex(i.offset - 1)), s = 0;
+		if (o || (s = a + i.getNode().getPreviousSiblings().reduce((e, t) => e + t.getTextContentSize(), 0)), t()) {
+			if (o) return void i.getNode().select(a, a);
+			n.getChildren().some((e) => {
+				let t = te(e);
+				if (t || E(e)) {
+					let n = e.getTextContentSize();
+					if (t && n >= s) return e.select(s, s), !0;
+					s -= n;
+				}
+				return !1;
+			});
+		}
+	}(a, () => {
+		let e = b(a);
+		if (!m(e) || !e.isAttached()) return !1;
+		let n = e.getLanguage() || t.defaultLanguage, i = t.$tokenize(e, n), { from: o, to: s, nodesForReplacement: c } = function(e, t) {
+			let n = 0;
+			for (; n < e.length && q(e[n], t[n]);) n++;
+			let r = e.length, i = t.length, a = Math.min(r, i) - n, o = 0;
+			for (; o < a;) if (o++, !q(e[r - o], t[i - o])) {
+				o--;
+				break;
+			}
+			let s = n, c = r - o;
+			return {
+				from: s,
+				nodesForReplacement: t.slice(n, i - o),
+				to: c
+			};
+		}(e.getChildren(), i);
+		return !(o === s && !c.length) && (r.splice(o, s - o, c), !0);
+	}));
+}
+function q(e, t) {
+	return n(e) && n(t) && e.__text === t.__text && e.__highlightType === t.__highlightType || O(e) && O(t) || E(e) && E(t);
+}
+function J(e) {
+	if (!D(e)) return !1;
+	let t = e.anchor.getNode(), n = m(t) ? t : t.getParent(), r = e.focus.getNode(), i = m(r) ? r : r.getParent();
+	return m(n) && n.is(i);
+}
+function Y(e) {
+	let t = e.getNodes(), r = [];
+	if (t.length === 1 && m(t[0])) return r;
+	let i = [];
+	for (let e = 0; e < t.length; e++) {
+		let a = t[e];
+		n(a) || O(a) || E(a) || B(169), E(a) ? i.length > 0 && (r.push(i), i = []) : i.push(a);
+	}
+	if (i.length > 0) {
+		let t = e.isBackward() ? e.anchor : e.focus, n = g(i[0].getKey(), 0, "text");
+		t.is(n) || r.push(i);
+	}
+	return r;
+}
+function X(e) {
+	let n = S();
+	if (!D(n) || !J(n)) return !1;
+	let r = Y(n), i = r.length;
+	if (i === 0 && n.isCollapsed()) return e === A && n.insertNodes([_()]), !0;
+	if (i === 0 && e === A && n.getTextContent() === "\n") {
+		let e = _(), t = h(), r = n.isBackward() ? "previous" : "next";
+		return n.insertNodes([e, t]), ie(ee(y(w(e, "next", 0), ne(C(t, "next"))), r)), !0;
+	}
+	for (let a = 0; a < i; a++) {
+		let i = r[a];
+		if (i.length > 0) {
+			let r = i[0];
+			if (a === 0 && (r = t(r)), e === A) {
+				let e = _();
+				if (r.insertBefore(e), a === 0) {
+					let t = n.isBackward() ? "focus" : "anchor", i = g(r.getKey(), 0, "text");
+					n[t].is(i) && n[t].set(e.getKey(), 0, "text");
+				}
+			} else O(r) && r.remove();
+		}
+	}
+	return !0;
+}
+function Z(e, r) {
+	let i = S();
+	if (!D(i)) return !1;
+	let { anchor: a, focus: o } = i, s = a.offset, l = o.offset, u = a.getNode(), d = o.getNode(), f = e === N;
+	if (!J(i) || !n(u) && !O(u) || !n(d) && !O(d)) return !1;
+	if (!r.altKey) {
+		if (i.isCollapsed()) {
+			let e = u.getParentOrThrow();
+			if (f && s === 0 && u.getPreviousSibling() === null) {
+				if (e.getPreviousSibling() === null) return e.selectPrevious(), r.preventDefault(), !0;
+			} else if (!f && s === u.getTextContentSize() && u.getNextSibling() === null && e.getNextSibling() === null) return e.selectNext(), r.preventDefault(), !0;
+		}
+		return !1;
+	}
+	let p, m;
+	if (u.isBefore(d) ? (p = t(u), m = c(d)) : (p = t(d), m = c(u)), p == null || m == null) return !1;
+	let h = p.getNodesBetween(m);
+	for (let e = 0; e < h.length; e++) {
+		let t = h[e];
+		if (!n(t) && !O(t) && !E(t)) return !1;
+	}
+	r.preventDefault(), r.stopPropagation();
+	let g = f ? p.getPreviousSibling() : m.getNextSibling();
+	if (!E(g)) return !0;
+	let _ = f ? g.getPreviousSibling() : g.getNextSibling();
+	if (_ == null) return !0;
+	let v = (n(_) || O(_) || E(_) ? f ? t(_) : c(_) : null) ?? _;
+	return g.remove(), h.forEach((e) => e.remove()), e === N ? (h.forEach((e) => v.insertBefore(e)), v.insertBefore(g)) : (v.insertAfter(g), v = g, h.forEach((e) => {
+		v.insertAfter(e), v = e;
+	})), i.setTextNodeRange(u, s, d, l), !0;
+}
+function Q(e, t) {
+	let r = S();
+	if (!D(r)) return !1;
+	let { anchor: i, focus: o } = r, s = i.getNode(), c = o.getNode(), l = e === I;
+	if (!J(r) || !n(s) && !O(s) || !n(c) && !O(c)) return !1;
+	let u = c;
+	if (a(u) === "rtl" ? !l : l) {
+		let e = f(u, o.offset);
+		if (e !== null) {
+			let { node: t, offset: n } = e;
+			E(t) ? t.selectNext(0, 0) : r.setTextNodeRange(t, n, t, n);
+		} else u.getParentOrThrow().selectStart();
+	} else d(u).select();
+	return t.preventDefault(), t.stopPropagation(), !0;
+}
+function $(e, n) {
+	if (!e.hasNodes([u, l])) throw Error("CodeHighlightPlugin: CodeNode or CodeHighlightNode not registered on editor");
+	n ??= W;
+	let r = [];
+	!0 !== e._headless && r.push(e.registerMutationListener(u, (t) => {
+		e.getEditorState().read(() => {
+			for (let [n, r] of t) if (r !== "destroyed") {
+				let t = b(n);
+				t !== null && ue(t, e);
+			}
+		});
+	}, { skipInitialization: !1 }));
+	let i = {
+		didTransform: !1,
+		nodesCurrentlyHighlighting: /* @__PURE__ */ new Set()
+	};
+	return r.push(e.registerNodeTransform(u, K.bind(null, e, n, i)), e.registerNodeTransform(R, G.bind(null, e, n, i)), e.registerNodeTransform(l, G.bind(null, e, n, i)), e.registerCommand(P, (n) => {
+		let r = function(e) {
+			let n = S();
+			if (!D(n) || !J(n)) return null;
+			let r = e ? L : A, i = e ? L : j, a = n.anchor, o = n.focus;
+			if (a.is(o)) return i;
+			let s = Y(n);
+			if (s.length !== 1) return r;
+			let l = s[0], u, d;
+			l.length === 0 && B(285), n.isBackward() ? (u = o, d = a) : (u = a, d = o);
+			let f = t(l[0]), p = c(l[0]), m = g(f.getKey(), 0, "text"), h = g(p.getKey(), p.getTextContentSize(), "text");
+			return u.isBefore(m) || h.isBefore(d) ? r : m.isBefore(u) || d.isBefore(h) ? i : r;
+		}(n.shiftKey);
+		return r !== null && (n.preventDefault(), e.dispatchCommand(r, void 0), !0);
+	}, k), e.registerCommand(j, () => !!J(S()) && (T([_()]), !0), k), e.registerCommand(A, (e) => X(A), k), e.registerCommand(L, (e) => X(L), k), e.registerCommand(N, (e) => {
+		let t = S();
+		if (!D(t) || !J(t)) return !1;
+		let n = x().getFirstDescendant(), { anchor: r } = t, i = r.getNode();
+		return (!n || !i || n.getKey() !== i.getKey()) && Z(N, e);
+	}, k), e.registerCommand(M, (e) => {
+		let t = S();
+		if (!D(t) || !J(t)) return !1;
+		let n = x().getLastDescendant(), { anchor: r } = t, i = r.getNode();
+		return (!n || !i || n.getKey() !== i.getKey()) && Z(M, e);
+	}, k), e.registerCommand(I, (e) => Q(I, e), k), e.registerCommand(F, (e) => Q(F, e), k)), ae(...r);
+}
+z({
+	build: (e, t) => i(t),
+	config: oe({
+		disabled: !1,
+		tokenizer: W
+	}),
+	dependencies: [r],
+	name: "@lexical/code-prism",
+	register: (e, t, n) => {
+		let r = n.getOutput();
+		return s(() => {
+			if (!r.disabled.value) return $(e, r.tokenizer.value);
+		});
+	}
+});
+//#endregion
+export { $ as registerCodeHighlighting };