@openstage/glyph-element 0.2.0

package/dist/chunks/highlight-core-C0K6BIzZ.js

@@ -0,0 +1,967 @@
+import { n as e, t } from "./rolldown-runtime-BE9Pkid1.js";
+var n = (/* @__PURE__ */ e((/* @__PURE__ */ t(((e, t) => {
+	function n(e) {
+		return e instanceof Map ? e.clear = e.delete = e.set = function() {
+			throw Error("map is read-only");
+		} : e instanceof Set && (e.add = e.clear = e.delete = function() {
+			throw Error("set is read-only");
+		}), Object.freeze(e), Object.getOwnPropertyNames(e).forEach((t) => {
+			let r = e[t], i = typeof r;
+			(i === "object" || i === "function") && !Object.isFrozen(r) && n(r);
+		}), e;
+	}
+	var r = class {
+		constructor(e) {
+			e.data === void 0 && (e.data = {}), this.data = e.data, this.isMatchIgnored = !1;
+		}
+		ignoreMatch() {
+			this.isMatchIgnored = !0;
+		}
+	};
+	function i(e) {
+		return e.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#x27;");
+	}
+	function a(e, ...t) {
+		let n = Object.create(null);
+		for (let t in e) n[t] = e[t];
+		return t.forEach(function(e) {
+			for (let t in e) n[t] = e[t];
+		}), n;
+	}
+	var o = "</span>", s = (e) => !!e.scope, c = (e, { prefix: t }) => {
+		if (e.startsWith("language:")) return e.replace("language:", "language-");
+		if (e.includes(".")) {
+			let n = e.split(".");
+			return [`${t}${n.shift()}`, ...n.map((e, t) => `${e}${"_".repeat(t + 1)}`)].join(" ");
+		}
+		return `${t}${e}`;
+	}, l = class {
+		constructor(e, t) {
+			this.buffer = "", this.classPrefix = t.classPrefix, e.walk(this);
+		}
+		addText(e) {
+			this.buffer += i(e);
+		}
+		openNode(e) {
+			if (!s(e)) return;
+			let t = c(e.scope, { prefix: this.classPrefix });
+			this.span(t);
+		}
+		closeNode(e) {
+			s(e) && (this.buffer += o);
+		}
+		value() {
+			return this.buffer;
+		}
+		span(e) {
+			this.buffer += `<span class="${e}">`;
+		}
+	}, u = (e = {}) => {
+		let t = { children: [] };
+		return Object.assign(t, e), t;
+	}, d = class e {
+		constructor() {
+			this.rootNode = u(), this.stack = [this.rootNode];
+		}
+		get top() {
+			return this.stack[this.stack.length - 1];
+		}
+		get root() {
+			return this.rootNode;
+		}
+		add(e) {
+			this.top.children.push(e);
+		}
+		openNode(e) {
+			let t = u({ scope: e });
+			this.add(t), this.stack.push(t);
+		}
+		closeNode() {
+			if (this.stack.length > 1) return this.stack.pop();
+		}
+		closeAllNodes() {
+			for (; this.closeNode(););
+		}
+		toJSON() {
+			return JSON.stringify(this.rootNode, null, 4);
+		}
+		walk(e) {
+			return this.constructor._walk(e, this.rootNode);
+		}
+		static _walk(e, t) {
+			return typeof t == "string" ? e.addText(t) : t.children && (e.openNode(t), t.children.forEach((t) => this._walk(e, t)), e.closeNode(t)), e;
+		}
+		static _collapse(t) {
+			typeof t != "string" && t.children && (t.children.every((e) => typeof e == "string") ? t.children = [t.children.join("")] : t.children.forEach((t) => {
+				e._collapse(t);
+			}));
+		}
+	}, f = class extends d {
+		constructor(e) {
+			super(), this.options = e;
+		}
+		addText(e) {
+			e !== "" && this.add(e);
+		}
+		startScope(e) {
+			this.openNode(e);
+		}
+		endScope() {
+			this.closeNode();
+		}
+		__addSublanguage(e, t) {
+			let n = e.root;
+			t && (n.scope = `language:${t}`), this.add(n);
+		}
+		toHTML() {
+			return new l(this, this.options).value();
+		}
+		finalize() {
+			return this.closeAllNodes(), !0;
+		}
+	};
+	function p(e) {
+		return e ? typeof e == "string" ? e : e.source : null;
+	}
+	function m(e) {
+		return _("(?=", e, ")");
+	}
+	function h(e) {
+		return _("(?:", e, ")*");
+	}
+	function g(e) {
+		return _("(?:", e, ")?");
+	}
+	function _(...e) {
+		return e.map((e) => p(e)).join("");
+	}
+	function v(e) {
+		let t = e[e.length - 1];
+		return typeof t == "object" && t.constructor === Object ? (e.splice(e.length - 1, 1), t) : {};
+	}
+	function y(...e) {
+		return "(" + (v(e).capture ? "" : "?:") + e.map((e) => p(e)).join("|") + ")";
+	}
+	function b(e) {
+		return RegExp(e.toString() + "|").exec("").length - 1;
+	}
+	function ee(e, t) {
+		let n = e && e.exec(t);
+		return n && n.index === 0;
+	}
+	var x = /\[(?:[^\\\]]|\\.)*\]|\(\??|\\([1-9][0-9]*)|\\./;
+	function S(e, { joinWith: t }) {
+		let n = 0;
+		return e.map((e) => {
+			n += 1;
+			let t = n, r = p(e), i = "";
+			for (; r.length > 0;) {
+				let e = x.exec(r);
+				if (!e) {
+					i += r;
+					break;
+				}
+				i += r.substring(0, e.index), r = r.substring(e.index + e[0].length), e[0][0] === "\\" && e[1] ? i += "\\" + String(Number(e[1]) + t) : (i += e[0], e[0] === "(" && n++);
+			}
+			return i;
+		}).map((e) => `(${e})`).join(t);
+	}
+	var C = /\b\B/, w = "[a-zA-Z]\\w*", T = "[a-zA-Z_]\\w*", E = "\\b\\d+(\\.\\d+)?", D = "(-?)(\\b0[xX][a-fA-F0-9]+|(\\b\\d+(\\.\\d*)?|\\.\\d+)([eE][-+]?\\d+)?)", O = "\\b(0b[01]+)", k = "!|!=|!==|%|%=|&|&&|&=|\\*|\\*=|\\+|\\+=|,|-|-=|/=|/|:|;|<<|<<=|<=|<|===|==|=|>>>=|>>=|>=|>>>|>>|>|\\?|\\[|\\{|\\(|\\^|\\^=|\\||\\|=|\\|\\||~", A = (e = {}) => {
+		let t = /^#![ ]*\//;
+		return e.binary && (e.begin = _(t, /.*\b/, e.binary, /\b.*/)), a({
+			scope: "meta",
+			begin: t,
+			end: /$/,
+			relevance: 0,
+			"on:begin": (e, t) => {
+				e.index !== 0 && t.ignoreMatch();
+			}
+		}, e);
+	}, j = {
+		begin: "\\\\[\\s\\S]",
+		relevance: 0
+	}, M = {
+		scope: "string",
+		begin: "'",
+		end: "'",
+		illegal: "\\n",
+		contains: [j]
+	}, N = {
+		scope: "string",
+		begin: "\"",
+		end: "\"",
+		illegal: "\\n",
+		contains: [j]
+	}, P = { begin: /\b(a|an|the|are|I'm|isn't|don't|doesn't|won't|but|just|should|pretty|simply|enough|gonna|going|wtf|so|such|will|you|your|they|like|more)\b/ }, F = function(e, t, n = {}) {
+		let r = a({
+			scope: "comment",
+			begin: e,
+			end: t,
+			contains: []
+		}, n);
+		r.contains.push({
+			scope: "doctag",
+			begin: "[ ]*(?=(TODO|FIXME|NOTE|BUG|OPTIMIZE|HACK|XXX):)",
+			end: /(TODO|FIXME|NOTE|BUG|OPTIMIZE|HACK|XXX):/,
+			excludeBegin: !0,
+			relevance: 0
+		});
+		let i = y("I", "a", "is", "so", "us", "to", "at", "if", "in", "it", "on", /[A-Za-z]+['](d|ve|re|ll|t|s|n)/, /[A-Za-z]+[-][a-z]+/, /[A-Za-z][a-z]{2,}/);
+		return r.contains.push({ begin: _(/[ ]+/, "(", i, /[.]?[:]?([.][ ]|[ ])/, "){3}") }), r;
+	}, I = F("//", "$"), L = F("/\\*", "\\*/"), R = F("#", "$"), z = {
+		scope: "number",
+		begin: E,
+		relevance: 0
+	}, te = {
+		scope: "number",
+		begin: D,
+		relevance: 0
+	}, ne = {
+		scope: "number",
+		begin: O,
+		relevance: 0
+	}, re = {
+		scope: "regexp",
+		begin: /\/(?=[^/\n]*\/)/,
+		end: /\/[gimuy]*/,
+		contains: [j, {
+			begin: /\[/,
+			end: /\]/,
+			relevance: 0,
+			contains: [j]
+		}]
+	}, ie = {
+		scope: "title",
+		begin: w,
+		relevance: 0
+	}, ae = {
+		scope: "title",
+		begin: T,
+		relevance: 0
+	}, oe = {
+		begin: "\\.\\s*" + T,
+		relevance: 0
+	}, B = /* @__PURE__ */ Object.freeze({
+		__proto__: null,
+		APOS_STRING_MODE: M,
+		BACKSLASH_ESCAPE: j,
+		BINARY_NUMBER_MODE: ne,
+		BINARY_NUMBER_RE: O,
+		COMMENT: F,
+		C_BLOCK_COMMENT_MODE: L,
+		C_LINE_COMMENT_MODE: I,
+		C_NUMBER_MODE: te,
+		C_NUMBER_RE: D,
+		END_SAME_AS_BEGIN: function(e) {
+			return Object.assign(e, {
+				"on:begin": (e, t) => {
+					t.data._beginMatch = e[1];
+				},
+				"on:end": (e, t) => {
+					t.data._beginMatch !== e[1] && t.ignoreMatch();
+				}
+			});
+		},
+		HASH_COMMENT_MODE: R,
+		IDENT_RE: w,
+		MATCH_NOTHING_RE: C,
+		METHOD_GUARD: oe,
+		NUMBER_MODE: z,
+		NUMBER_RE: E,
+		PHRASAL_WORDS_MODE: P,
+		QUOTE_STRING_MODE: N,
+		REGEXP_MODE: re,
+		RE_STARTERS_RE: k,
+		SHEBANG: A,
+		TITLE_MODE: ie,
+		UNDERSCORE_IDENT_RE: T,
+		UNDERSCORE_TITLE_MODE: ae
+	});
+	function se(e, t) {
+		e.input[e.index - 1] === "." && t.ignoreMatch();
+	}
+	function ce(e, t) {
+		e.className !== void 0 && (e.scope = e.className, delete e.className);
+	}
+	function le(e, t) {
+		t && e.beginKeywords && (e.begin = "\\b(" + e.beginKeywords.split(" ").join("|") + ")(?!\\.)(?=\\b|\\s)", e.__beforeBegin = se, e.keywords = e.keywords || e.beginKeywords, delete e.beginKeywords, e.relevance === void 0 && (e.relevance = 0));
+	}
+	function ue(e, t) {
+		Array.isArray(e.illegal) && (e.illegal = y(...e.illegal));
+	}
+	function de(e, t) {
+		if (e.match) {
+			if (e.begin || e.end) throw Error("begin & end are not supported with match");
+			e.begin = e.match, delete e.match;
+		}
+	}
+	function fe(e, t) {
+		e.relevance === void 0 && (e.relevance = 1);
+	}
+	var pe = (e, t) => {
+		if (!e.beforeMatch) return;
+		if (e.starts) throw Error("beforeMatch cannot be used with starts");
+		let n = Object.assign({}, e);
+		Object.keys(e).forEach((t) => {
+			delete e[t];
+		}), e.keywords = n.keywords, e.begin = _(n.beforeMatch, m(n.begin)), e.starts = {
+			relevance: 0,
+			contains: [Object.assign(n, { endsParent: !0 })]
+		}, e.relevance = 0, delete n.beforeMatch;
+	}, me = [
+		"of",
+		"and",
+		"for",
+		"in",
+		"not",
+		"or",
+		"if",
+		"then",
+		"parent",
+		"list",
+		"value"
+	], he = "keyword";
+	function V(e, t, n = he) {
+		let r = Object.create(null);
+		return typeof e == "string" ? i(n, e.split(" ")) : Array.isArray(e) ? i(n, e) : Object.keys(e).forEach(function(n) {
+			Object.assign(r, V(e[n], t, n));
+		}), r;
+		function i(e, n) {
+			t && (n = n.map((e) => e.toLowerCase())), n.forEach(function(t) {
+				let n = t.split("|");
+				r[n[0]] = [e, ge(n[0], n[1])];
+			});
+		}
+	}
+	function ge(e, t) {
+		return t ? Number(t) : +!_e(e);
+	}
+	function _e(e) {
+		return me.includes(e.toLowerCase());
+	}
+	var H = {}, U = (e) => {
+		console.error(e);
+	}, W = (e, ...t) => {
+		console.log(`WARN: ${e}`, ...t);
+	}, G = (e, t) => {
+		H[`${e}/${t}`] || (console.log(`Deprecated as of ${e}. ${t}`), H[`${e}/${t}`] = !0);
+	}, K = /* @__PURE__ */ Error();
+	function q(e, t, { key: n }) {
+		let r = 0, i = e[n], a = {}, o = {};
+		for (let e = 1; e <= t.length; e++) o[e + r] = i[e], a[e + r] = !0, r += b(t[e - 1]);
+		e[n] = o, e[n]._emit = a, e[n]._multi = !0;
+	}
+	function ve(e) {
+		if (Array.isArray(e.begin)) {
+			if (e.skip || e.excludeBegin || e.returnBegin) throw U("skip, excludeBegin, returnBegin not compatible with beginScope: {}"), K;
+			if (typeof e.beginScope != "object" || e.beginScope === null) throw U("beginScope must be object"), K;
+			q(e, e.begin, { key: "beginScope" }), e.begin = S(e.begin, { joinWith: "" });
+		}
+	}
+	function ye(e) {
+		if (Array.isArray(e.end)) {
+			if (e.skip || e.excludeEnd || e.returnEnd) throw U("skip, excludeEnd, returnEnd not compatible with endScope: {}"), K;
+			if (typeof e.endScope != "object" || e.endScope === null) throw U("endScope must be object"), K;
+			q(e, e.end, { key: "endScope" }), e.end = S(e.end, { joinWith: "" });
+		}
+	}
+	function be(e) {
+		e.scope && typeof e.scope == "object" && e.scope !== null && (e.beginScope = e.scope, delete e.scope);
+	}
+	function xe(e) {
+		be(e), typeof e.beginScope == "string" && (e.beginScope = { _wrap: e.beginScope }), typeof e.endScope == "string" && (e.endScope = { _wrap: e.endScope }), ve(e), ye(e);
+	}
+	function Se(e) {
+		function t(t, n) {
+			return new RegExp(p(t), "m" + (e.case_insensitive ? "i" : "") + (e.unicodeRegex ? "u" : "") + (n ? "g" : ""));
+		}
+		class n {
+			constructor() {
+				this.matchIndexes = {}, this.regexes = [], this.matchAt = 1, this.position = 0;
+			}
+			addRule(e, t) {
+				t.position = this.position++, this.matchIndexes[this.matchAt] = t, this.regexes.push([t, e]), this.matchAt += b(e) + 1;
+			}
+			compile() {
+				this.regexes.length === 0 && (this.exec = () => null);
+				let e = this.regexes.map((e) => e[1]);
+				this.matcherRe = t(S(e, { joinWith: "|" }), !0), this.lastIndex = 0;
+			}
+			exec(e) {
+				this.matcherRe.lastIndex = this.lastIndex;
+				let t = this.matcherRe.exec(e);
+				if (!t) return null;
+				let n = t.findIndex((e, t) => t > 0 && e !== void 0), r = this.matchIndexes[n];
+				return t.splice(0, n), Object.assign(t, r);
+			}
+		}
+		class r {
+			constructor() {
+				this.rules = [], this.multiRegexes = [], this.count = 0, this.lastIndex = 0, this.regexIndex = 0;
+			}
+			getMatcher(e) {
+				if (this.multiRegexes[e]) return this.multiRegexes[e];
+				let t = new n();
+				return this.rules.slice(e).forEach(([e, n]) => t.addRule(e, n)), t.compile(), this.multiRegexes[e] = t, t;
+			}
+			resumingScanAtSamePosition() {
+				return this.regexIndex !== 0;
+			}
+			considerAll() {
+				this.regexIndex = 0;
+			}
+			addRule(e, t) {
+				this.rules.push([e, t]), t.type === "begin" && this.count++;
+			}
+			exec(e) {
+				let t = this.getMatcher(this.regexIndex);
+				t.lastIndex = this.lastIndex;
+				let n = t.exec(e);
+				if (this.resumingScanAtSamePosition() && !(n && n.index === this.lastIndex)) {
+					let t = this.getMatcher(0);
+					t.lastIndex = this.lastIndex + 1, n = t.exec(e);
+				}
+				return n && (this.regexIndex += n.position + 1, this.regexIndex === this.count && this.considerAll()), n;
+			}
+		}
+		function i(e) {
+			let t = new r();
+			return e.contains.forEach((e) => t.addRule(e.begin, {
+				rule: e,
+				type: "begin"
+			})), e.terminatorEnd && t.addRule(e.terminatorEnd, { type: "end" }), e.illegal && t.addRule(e.illegal, { type: "illegal" }), t;
+		}
+		function o(n, r) {
+			let a = n;
+			if (n.isCompiled) return a;
+			[
+				ce,
+				de,
+				xe,
+				pe
+			].forEach((e) => e(n, r)), e.compilerExtensions.forEach((e) => e(n, r)), n.__beforeBegin = null, [
+				le,
+				ue,
+				fe
+			].forEach((e) => e(n, r)), n.isCompiled = !0;
+			let s = null;
+			return typeof n.keywords == "object" && n.keywords.$pattern && (n.keywords = Object.assign({}, n.keywords), s = n.keywords.$pattern, delete n.keywords.$pattern), s ||= /\w+/, n.keywords &&= V(n.keywords, e.case_insensitive), a.keywordPatternRe = t(s, !0), r && (n.begin ||= /\B|\b/, a.beginRe = t(a.begin), !n.end && !n.endsWithParent && (n.end = /\B|\b/), n.end && (a.endRe = t(a.end)), a.terminatorEnd = p(a.end) || "", n.endsWithParent && r.terminatorEnd && (a.terminatorEnd += (n.end ? "|" : "") + r.terminatorEnd)), n.illegal && (a.illegalRe = t(n.illegal)), n.contains ||= [], n.contains = [].concat(...n.contains.map(function(e) {
+				return Ce(e === "self" ? n : e);
+			})), n.contains.forEach(function(e) {
+				o(e, a);
+			}), n.starts && o(n.starts, r), a.matcher = i(a), a;
+		}
+		if (e.compilerExtensions ||= [], e.contains && e.contains.includes("self")) throw Error("ERR: contains `self` is not supported at the top-level of a language.  See documentation.");
+		return e.classNameAliases = a(e.classNameAliases || {}), o(e);
+	}
+	function J(e) {
+		return e ? e.endsWithParent || J(e.starts) : !1;
+	}
+	function Ce(e) {
+		return e.variants && !e.cachedVariants && (e.cachedVariants = e.variants.map(function(t) {
+			return a(e, { variants: null }, t);
+		})), e.cachedVariants ? e.cachedVariants : J(e) ? a(e, { starts: e.starts ? a(e.starts) : null }) : Object.isFrozen(e) ? a(e) : e;
+	}
+	var we = "11.11.1", Te = class extends Error {
+		constructor(e, t) {
+			super(e), this.name = "HTMLInjectionError", this.html = t;
+		}
+	}, Y = i, X = a, Z = Symbol("nomatch"), Ee = 7, Q = function(e) {
+		let t = Object.create(null), i = Object.create(null), a = [], o = !0, s = "Could not find the language '{}', did you forget to load/include a language module?", c = {
+			disableAutodetect: !0,
+			name: "Plain text",
+			contains: []
+		}, l = {
+			ignoreUnescapedHTML: !1,
+			throwUnescapedHTML: !1,
+			noHighlightRe: /^(no-?highlight)$/i,
+			languageDetectRe: /\blang(?:uage)?-([\w-]+)\b/i,
+			classPrefix: "hljs-",
+			cssSelector: "pre code",
+			languages: null,
+			__emitter: f
+		};
+		function u(e) {
+			return l.noHighlightRe.test(e);
+		}
+		function d(e) {
+			let t = e.className + " ";
+			t += e.parentNode ? e.parentNode.className : "";
+			let n = l.languageDetectRe.exec(t);
+			if (n) {
+				let t = M(n[1]);
+				return t || (W(s.replace("{}", n[1])), W("Falling back to no-highlight mode for this block.", e)), t ? n[1] : "no-highlight";
+			}
+			return t.split(/\s+/).find((e) => u(e) || M(e));
+		}
+		function p(e, t, n) {
+			let r = "", i = "";
+			typeof t == "object" ? (r = e, n = t.ignoreIllegals, i = t.language) : (G("10.7.0", "highlight(lang, code, ...args) has been deprecated."), G("10.7.0", "Please use highlight(code, options) instead.\nhttps://github.com/highlightjs/highlight.js/issues/2277"), i = e, r = t), n === void 0 && (n = !0);
+			let a = {
+				code: r,
+				language: i
+			};
+			R("before:highlight", a);
+			let o = a.result ? a.result : v(a.language, a.code, n);
+			return o.code = a.code, R("after:highlight", o), o;
+		}
+		function v(e, n, i, a) {
+			let c = Object.create(null);
+			function u(e, t) {
+				return e.keywords[t];
+			}
+			function d() {
+				if (!k.keywords) {
+					j.addText(N);
+					return;
+				}
+				let e = 0;
+				k.keywordPatternRe.lastIndex = 0;
+				let t = k.keywordPatternRe.exec(N), n = "";
+				for (; t;) {
+					n += N.substring(e, t.index);
+					let r = E.case_insensitive ? t[0].toLowerCase() : t[0], i = u(k, r);
+					if (i) {
+						let [e, a] = i;
+						if (j.addText(n), n = "", c[r] = (c[r] || 0) + 1, c[r] <= Ee && (P += a), e.startsWith("_")) n += t[0];
+						else {
+							let n = E.classNameAliases[e] || e;
+							m(t[0], n);
+						}
+					} else n += t[0];
+					e = k.keywordPatternRe.lastIndex, t = k.keywordPatternRe.exec(N);
+				}
+				n += N.substring(e), j.addText(n);
+			}
+			function f() {
+				if (N === "") return;
+				let e = null;
+				if (typeof k.subLanguage == "string") {
+					if (!t[k.subLanguage]) {
+						j.addText(N);
+						return;
+					}
+					e = v(k.subLanguage, N, !0, A[k.subLanguage]), A[k.subLanguage] = e._top;
+				} else e = x(N, k.subLanguage.length ? k.subLanguage : null);
+				k.relevance > 0 && (P += e.relevance), j.__addSublanguage(e._emitter, e.language);
+			}
+			function p() {
+				k.subLanguage == null ? d() : f(), N = "";
+			}
+			function m(e, t) {
+				e !== "" && (j.startScope(t), j.addText(e), j.endScope());
+			}
+			function h(e, t) {
+				let n = 1, r = t.length - 1;
+				for (; n <= r;) {
+					if (!e._emit[n]) {
+						n++;
+						continue;
+					}
+					let r = E.classNameAliases[e[n]] || e[n], i = t[n];
+					r ? m(i, r) : (N = i, d(), N = ""), n++;
+				}
+			}
+			function g(e, t) {
+				return e.scope && typeof e.scope == "string" && j.openNode(E.classNameAliases[e.scope] || e.scope), e.beginScope && (e.beginScope._wrap ? (m(N, E.classNameAliases[e.beginScope._wrap] || e.beginScope._wrap), N = "") : e.beginScope._multi && (h(e.beginScope, t), N = "")), k = Object.create(e, { parent: { value: k } }), k;
+			}
+			function _(e, t, n) {
+				let i = ee(e.endRe, n);
+				if (i) {
+					if (e["on:end"]) {
+						let n = new r(e);
+						e["on:end"](t, n), n.isMatchIgnored && (i = !1);
+					}
+					if (i) {
+						for (; e.endsParent && e.parent;) e = e.parent;
+						return e;
+					}
+				}
+				if (e.endsWithParent) return _(e.parent, t, n);
+			}
+			function y(e) {
+				return k.matcher.regexIndex === 0 ? (N += e[0], 1) : (L = !0, 0);
+			}
+			function b(e) {
+				let t = e[0], n = e.rule, i = new r(n), a = [n.__beforeBegin, n["on:begin"]];
+				for (let n of a) if (n && (n(e, i), i.isMatchIgnored)) return y(t);
+				return n.skip ? N += t : (n.excludeBegin && (N += t), p(), !n.returnBegin && !n.excludeBegin && (N = t)), g(n, e), n.returnBegin ? 0 : t.length;
+			}
+			function S(e) {
+				let t = e[0], r = n.substring(e.index), i = _(k, e, r);
+				if (!i) return Z;
+				let a = k;
+				k.endScope && k.endScope._wrap ? (p(), m(t, k.endScope._wrap)) : k.endScope && k.endScope._multi ? (p(), h(k.endScope, e)) : a.skip ? N += t : (a.returnEnd || a.excludeEnd || (N += t), p(), a.excludeEnd && (N = t));
+				do
+					k.scope && j.closeNode(), !k.skip && !k.subLanguage && (P += k.relevance), k = k.parent;
+				while (k !== i.parent);
+				return i.starts && g(i.starts, e), a.returnEnd ? 0 : t.length;
+			}
+			function C() {
+				let e = [];
+				for (let t = k; t !== E; t = t.parent) t.scope && e.unshift(t.scope);
+				e.forEach((e) => j.openNode(e));
+			}
+			let w = {};
+			function T(t, r) {
+				let a = r && r[0];
+				if (N += t, a == null) return p(), 0;
+				if (w.type === "begin" && r.type === "end" && w.index === r.index && a === "") {
+					if (N += n.slice(r.index, r.index + 1), !o) {
+						let t = /* @__PURE__ */ Error(`0 width match regex (${e})`);
+						throw t.languageName = e, t.badRule = w.rule, t;
+					}
+					return 1;
+				}
+				if (w = r, r.type === "begin") return b(r);
+				if (r.type === "illegal" && !i) {
+					let e = /* @__PURE__ */ Error("Illegal lexeme \"" + a + "\" for mode \"" + (k.scope || "<unnamed>") + "\"");
+					throw e.mode = k, e;
+				} else if (r.type === "end") {
+					let e = S(r);
+					if (e !== Z) return e;
+				}
+				if (r.type === "illegal" && a === "") return N += "\n", 1;
+				if (I > 1e5 && I > r.index * 3) throw /* @__PURE__ */ Error("potential infinite loop, way more iterations than matches");
+				return N += a, a.length;
+			}
+			let E = M(e);
+			if (!E) throw U(s.replace("{}", e)), Error("Unknown language: \"" + e + "\"");
+			let D = Se(E), O = "", k = a || D, A = {}, j = new l.__emitter(l);
+			C();
+			let N = "", P = 0, F = 0, I = 0, L = !1;
+			try {
+				if (E.__emitTokens) E.__emitTokens(n, j);
+				else {
+					for (k.matcher.considerAll();;) {
+						I++, L ? L = !1 : k.matcher.considerAll(), k.matcher.lastIndex = F;
+						let e = k.matcher.exec(n);
+						if (!e) break;
+						let t = T(n.substring(F, e.index), e);
+						F = e.index + t;
+					}
+					T(n.substring(F));
+				}
+				return j.finalize(), O = j.toHTML(), {
+					language: e,
+					value: O,
+					relevance: P,
+					illegal: !1,
+					_emitter: j,
+					_top: k
+				};
+			} catch (t) {
+				if (t.message && t.message.includes("Illegal")) return {
+					language: e,
+					value: Y(n),
+					illegal: !0,
+					relevance: 0,
+					_illegalBy: {
+						message: t.message,
+						index: F,
+						context: n.slice(F - 100, F + 100),
+						mode: t.mode,
+						resultSoFar: O
+					},
+					_emitter: j
+				};
+				if (o) return {
+					language: e,
+					value: Y(n),
+					illegal: !1,
+					relevance: 0,
+					errorRaised: t,
+					_emitter: j,
+					_top: k
+				};
+				throw t;
+			}
+		}
+		function b(e) {
+			let t = {
+				value: Y(e),
+				illegal: !1,
+				relevance: 0,
+				_top: c,
+				_emitter: new l.__emitter(l)
+			};
+			return t._emitter.addText(e), t;
+		}
+		function x(e, n) {
+			n = n || l.languages || Object.keys(t);
+			let r = b(e), i = n.filter(M).filter(P).map((t) => v(t, e, !1));
+			i.unshift(r);
+			let [a, o] = i.sort((e, t) => {
+				if (e.relevance !== t.relevance) return t.relevance - e.relevance;
+				if (e.language && t.language) {
+					if (M(e.language).supersetOf === t.language) return 1;
+					if (M(t.language).supersetOf === e.language) return -1;
+				}
+				return 0;
+			}), s = a;
+			return s.secondBest = o, s;
+		}
+		function S(e, t, n) {
+			let r = t && i[t] || n;
+			e.classList.add("hljs"), e.classList.add(`language-${r}`);
+		}
+		function C(e) {
+			let t = null, n = d(e);
+			if (u(n)) return;
+			if (R("before:highlightElement", {
+				el: e,
+				language: n
+			}), e.dataset.highlighted) {
+				console.log("Element previously highlighted. To highlight again, first unset `dataset.highlighted`.", e);
+				return;
+			}
+			if (e.children.length > 0 && (l.ignoreUnescapedHTML || (console.warn("One of your code blocks includes unescaped HTML. This is a potentially serious security risk."), console.warn("https://github.com/highlightjs/highlight.js/wiki/security"), console.warn("The element with unescaped HTML:"), console.warn(e)), l.throwUnescapedHTML)) throw new Te("One of your code blocks includes unescaped HTML.", e.innerHTML);
+			t = e;
+			let r = t.textContent, i = n ? p(r, {
+				language: n,
+				ignoreIllegals: !0
+			}) : x(r);
+			e.innerHTML = i.value, e.dataset.highlighted = "yes", S(e, n, i.language), e.result = {
+				language: i.language,
+				re: i.relevance,
+				relevance: i.relevance
+			}, i.secondBest && (e.secondBest = {
+				language: i.secondBest.language,
+				relevance: i.secondBest.relevance
+			}), R("after:highlightElement", {
+				el: e,
+				result: i,
+				text: r
+			});
+		}
+		function w(e) {
+			l = X(l, e);
+		}
+		let T = () => {
+			O(), G("10.6.0", "initHighlighting() deprecated.  Use highlightAll() now.");
+		};
+		function E() {
+			O(), G("10.6.0", "initHighlightingOnLoad() deprecated.  Use highlightAll() now.");
+		}
+		let D = !1;
+		function O() {
+			function e() {
+				O();
+			}
+			if (document.readyState === "loading") {
+				D || window.addEventListener("DOMContentLoaded", e, !1), D = !0;
+				return;
+			}
+			document.querySelectorAll(l.cssSelector).forEach(C);
+		}
+		function k(n, r) {
+			let i = null;
+			try {
+				i = r(e);
+			} catch (e) {
+				if (U("Language definition for '{}' could not be registered.".replace("{}", n)), o) U(e);
+				else throw e;
+				i = c;
+			}
+			i.name ||= n, t[n] = i, i.rawDefinition = r.bind(null, e), i.aliases && N(i.aliases, { languageName: n });
+		}
+		function A(e) {
+			delete t[e];
+			for (let t of Object.keys(i)) i[t] === e && delete i[t];
+		}
+		function j() {
+			return Object.keys(t);
+		}
+		function M(e) {
+			return e = (e || "").toLowerCase(), t[e] || t[i[e]];
+		}
+		function N(e, { languageName: t }) {
+			typeof e == "string" && (e = [e]), e.forEach((e) => {
+				i[e.toLowerCase()] = t;
+			});
+		}
+		function P(e) {
+			let t = M(e);
+			return t && !t.disableAutodetect;
+		}
+		function F(e) {
+			e["before:highlightBlock"] && !e["before:highlightElement"] && (e["before:highlightElement"] = (t) => {
+				e["before:highlightBlock"](Object.assign({ block: t.el }, t));
+			}), e["after:highlightBlock"] && !e["after:highlightElement"] && (e["after:highlightElement"] = (t) => {
+				e["after:highlightBlock"](Object.assign({ block: t.el }, t));
+			});
+		}
+		function I(e) {
+			F(e), a.push(e);
+		}
+		function L(e) {
+			let t = a.indexOf(e);
+			t !== -1 && a.splice(t, 1);
+		}
+		function R(e, t) {
+			let n = e;
+			a.forEach(function(e) {
+				e[n] && e[n](t);
+			});
+		}
+		function z(e) {
+			return G("10.7.0", "highlightBlock will be removed entirely in v12.0"), G("10.7.0", "Please use highlightElement now."), C(e);
+		}
+		Object.assign(e, {
+			highlight: p,
+			highlightAuto: x,
+			highlightAll: O,
+			highlightElement: C,
+			highlightBlock: z,
+			configure: w,
+			initHighlighting: T,
+			initHighlightingOnLoad: E,
+			registerLanguage: k,
+			unregisterLanguage: A,
+			listLanguages: j,
+			getLanguage: M,
+			registerAliases: N,
+			autoDetection: P,
+			inherit: X,
+			addPlugin: I,
+			removePlugin: L
+		}), e.debugMode = function() {
+			o = !1;
+		}, e.safeMode = function() {
+			o = !0;
+		}, e.versionString = we, e.regex = {
+			concat: _,
+			lookahead: m,
+			either: y,
+			optional: g,
+			anyNumberOfTimes: h
+		};
+		for (let e in B) typeof B[e] == "object" && n(B[e]);
+		return Object.assign(e, B), e;
+	}, $ = Q({});
+	$.newInstance = () => Q({}), t.exports = $, $.HighlightJS = $, $.default = $;
+})))())).default, r = {}, i = "hljs-";
+function a(e) {
+	let t = n.newInstance();
+	return e && l(e), {
+		highlight: a,
+		highlightAuto: s,
+		listLanguages: c,
+		register: l,
+		registerAlias: u,
+		registered: d
+	};
+	function a(e, n, a) {
+		let s = a || r, c = typeof s.prefix == "string" ? s.prefix : i;
+		if (!t.getLanguage(e)) throw Error("Unknown language: `" + e + "` is not registered");
+		t.configure({
+			__emitter: o,
+			classPrefix: c
+		});
+		let l = t.highlight(n, {
+			ignoreIllegals: !0,
+			language: e
+		});
+		/* c8 ignore next 5 */
+		if (l.errorRaised) throw Error("Could not highlight with `Highlight.js`", { cause: l.errorRaised });
+		let u = l._emitter.root, d = u.data;
+		return d.language = l.language, d.relevance = l.relevance, u;
+	}
+	function s(e, n) {
+		let i = (n || r).subset || c(), o = -1, s = 0, l;
+		for (; ++o < i.length;) {
+			let r = i[o];
+			if (!t.getLanguage(r)) continue;
+			let c = a(r, e, n);
+			c.data && c.data.relevance !== void 0 && c.data.relevance > s && (s = c.data.relevance, l = c);
+		}
+		return l || {
+			type: "root",
+			children: [],
+			data: {
+				language: void 0,
+				relevance: s
+			}
+		};
+	}
+	function c() {
+		return t.listLanguages();
+	}
+	function l(e, n) {
+		if (typeof e == "string") t.registerLanguage(e, n);
+		else {
+			let n;
+			for (n in e) Object.hasOwn(e, n) && t.registerLanguage(n, e[n]);
+		}
+	}
+	function u(e, n) {
+		if (typeof e == "string") t.registerAliases(typeof n == "string" ? n : [...n], { languageName: e });
+		else {
+			let n;
+			for (n in e) if (Object.hasOwn(e, n)) {
+				let r = e[n];
+				t.registerAliases(typeof r == "string" ? r : [...r], { languageName: n });
+			}
+		}
+	}
+	function d(e) {
+		return !!t.getLanguage(e);
+	}
+}
+var o = class {
+	constructor(e) {
+		this.options = e, this.root = {
+			type: "root",
+			children: [],
+			data: {
+				language: void 0,
+				relevance: 0
+			}
+		}, this.stack = [this.root];
+	}
+	addText(e) {
+		if (e === "") return;
+		let t = this.stack[this.stack.length - 1], n = t.children[t.children.length - 1];
+		n && n.type === "text" ? n.value += e : t.children.push({
+			type: "text",
+			value: e
+		});
+	}
+	startScope(e) {
+		this.openNode(String(e));
+	}
+	endScope() {
+		this.closeNode();
+	}
+	__addSublanguage(e, t) {
+		let n = this.stack[this.stack.length - 1], r = e.root.children;
+		t ? n.children.push({
+			type: "element",
+			tagName: "span",
+			properties: { className: [t] },
+			children: r
+		}) : n.children.push(...r);
+	}
+	openNode(e) {
+		let t = this, n = e.split(".").map(function(e, n) {
+			return n ? e + "_".repeat(n) : t.options.classPrefix + e;
+		}), r = this.stack[this.stack.length - 1], i = {
+			type: "element",
+			tagName: "span",
+			properties: { className: n },
+			children: []
+		};
+		r.children.push(i), this.stack.push(i);
+	}
+	closeNode() {
+		this.stack.pop();
+	}
+	finalize() {}
+	toHTML() {
+		return "";
+	}
+};
+//#endregion
+export { n, a as t };
+
+//# sourceMappingURL=highlight-core-C0K6BIzZ.js.map