@scalar/code-highlight 0.3.3 → 0.3.5

package/dist/chunks/rehype-highlight.js

@@ -0,0 +1,2987 @@
+import { i as convert, t as visit } from "./lib2.js";
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+//#region ../../node_modules/.pnpm/devlop@1.1.0/node_modules/devlop/lib/default.js
+function ok() {}
+//#endregion
+//#region src/constants.ts
+/** Map common markdown language shortcuts to lowlight languages */
+var lowlightLanguageMappings = {
+	"ts": "typescript",
+	"js": "javascript",
+	"py": "python",
+	"py3": "python",
+	"c#": "csharp",
+	"c++": "cpp",
+	"node": "javascript"
+};
+//#endregion
+//#region ../../node_modules/.pnpm/unist-util-find-after@5.0.0/node_modules/unist-util-find-after/lib/index.js
+/**
+* @typedef {import('unist').Node} UnistNode
+* @typedef {import('unist').Parent} UnistParent
+*/
+/**
+* @typedef {Exclude<import('unist-util-is').Test, undefined> | undefined} Test
+*   Test from `unist-util-is`.
+*
+*   Note: we have remove and add `undefined`, because otherwise when generating
+*   automatic `.d.ts` files, TS tries to flatten paths from a local perspective,
+*   which doesn’t work when publishing on npm.
+*/
+/**
+* @typedef {(
+*   Fn extends (value: any) => value is infer Thing
+*   ? Thing
+*   : Fallback
+* )} Predicate
+*   Get the value of a type guard `Fn`.
+* @template Fn
+*   Value; typically function that is a type guard (such as `(x): x is Y`).
+* @template Fallback
+*   Value to yield if `Fn` is not a type guard.
+*/
+/**
+* @typedef {(
+*   Check extends null | undefined // No test.
+*   ? Value
+*   : Value extends {type: Check} // String (type) test.
+*   ? Value
+*   : Value extends Check // Partial test.
+*   ? Value
+*   : Check extends Function // Function test.
+*   ? Predicate<Check, Value> extends Value
+*     ? Predicate<Check, Value>
+*     : never
+*   : never // Some other test?
+* )} MatchesOne
+*   Check whether a node matches a primitive check in the type system.
+* @template Value
+*   Value; typically unist `Node`.
+* @template Check
+*   Value; typically `unist-util-is`-compatible test, but not arrays.
+*/
+/**
+* @typedef {(
+*   Check extends Array<any>
+*   ? MatchesOne<Value, Check[keyof Check]>
+*   : MatchesOne<Value, Check>
+* )} Matches
+*   Check whether a node matches a check in the type system.
+* @template Value
+*   Value; typically unist `Node`.
+* @template Check
+*   Value; typically `unist-util-is`-compatible test.
+*/
+/**
+* @typedef {(
+*   Kind extends {children: Array<infer Child>}
+*   ? Child
+*   : never
+* )} Child
+*   Collect nodes that can be parents of `Child`.
+* @template {UnistNode} Kind
+*   All node types.
+*/
+/**
+* Find the first node in `parent` after another `node` or after an index,
+* that passes `test`.
+*
+* @param parent
+*   Parent node.
+* @param index
+*   Child node or index.
+* @param [test=undefined]
+*   Test for child to look for (optional).
+* @returns
+*   A child (matching `test`, if given) or `undefined`.
+*/
+var findAfter = (function(parent, index, test) {
+	const is = convert(test);
+	if (!parent || !parent.type || !parent.children) throw new Error("Expected parent node");
+	if (typeof index === "number") {
+		if (index < 0 || index === Number.POSITIVE_INFINITY) throw new Error("Expected positive finite number as index");
+	} else {
+		index = parent.children.indexOf(index);
+		if (index < 0) throw new Error("Expected child node or index");
+	}
+	while (++index < parent.children.length) if (is(parent.children[index], index, parent)) return parent.children[index];
+});
+//#endregion
+//#region ../../node_modules/.pnpm/hast-util-is-element@3.0.0/node_modules/hast-util-is-element/lib/index.js
+/**
+* @typedef {import('hast').Element} Element
+* @typedef {import('hast').Parents} Parents
+*/
+/**
+* @template Fn
+* @template Fallback
+* @typedef {Fn extends (value: any) => value is infer Thing ? Thing : Fallback} Predicate
+*/
+/**
+* @callback Check
+*   Check that an arbitrary value is an element.
+* @param {unknown} this
+*   Context object (`this`) to call `test` with
+* @param {unknown} [element]
+*   Anything (typically a node).
+* @param {number | null | undefined} [index]
+*   Position of `element` in its parent.
+* @param {Parents | null | undefined} [parent]
+*   Parent of `element`.
+* @returns {boolean}
+*   Whether this is an element and passes a test.
+*
+* @typedef {Array<TestFunction | string> | TestFunction | string | null | undefined} Test
+*   Check for an arbitrary element.
+*
+*   * when `string`, checks that the element has that tag name
+*   * when `function`, see `TestFunction`
+*   * when `Array`, checks if one of the subtests pass
+*
+* @callback TestFunction
+*   Check if an element passes a test.
+* @param {unknown} this
+*   The given context.
+* @param {Element} element
+*   An element.
+* @param {number | undefined} [index]
+*   Position of `element` in its parent.
+* @param {Parents | undefined} [parent]
+*   Parent of `element`.
+* @returns {boolean | undefined | void}
+*   Whether this element passes the test.
+*
+*   Note: `void` is included until TS sees no return as `undefined`.
+*/
+/**
+* Check if `element` is an `Element` and whether it passes the given test.
+*
+* @param element
+*   Thing to check, typically `element`.
+* @param test
+*   Check for a specific element.
+* @param index
+*   Position of `element` in its parent.
+* @param parent
+*   Parent of `element`.
+* @param context
+*   Context object (`this`) to call `test` with.
+* @returns
+*   Whether `element` is an `Element` and passes a test.
+* @throws
+*   When an incorrect `test`, `index`, or `parent` is given; there is no error
+*   thrown when `element` is not a node or not an element.
+*/
+var isElement = (function(element, test, index, parent, context) {
+	const check = convertElement(test);
+	if (index !== null && index !== void 0 && (typeof index !== "number" || index < 0 || index === Number.POSITIVE_INFINITY)) throw new Error("Expected positive finite `index`");
+	if (parent !== null && parent !== void 0 && (!parent.type || !parent.children)) throw new Error("Expected valid `parent`");
+	if ((index === null || index === void 0) !== (parent === null || parent === void 0)) throw new Error("Expected both `index` and `parent`");
+	return looksLikeAnElement(element) ? check.call(context, element, index, parent) : false;
+});
+/**
+* Generate a check from a test.
+*
+* Useful if you’re going to test many nodes, for example when creating a
+* utility where something else passes a compatible test.
+*
+* The created function is a bit faster because it expects valid input only:
+* an `element`, `index`, and `parent`.
+*
+* @param test
+*   A test for a specific element.
+* @returns
+*   A check.
+*/
+var convertElement = (function(test) {
+	if (test === null || test === void 0) return element;
+	if (typeof test === "string") return tagNameFactory(test);
+	if (typeof test === "object") return anyFactory(test);
+	if (typeof test === "function") return castFactory(test);
+	throw new Error("Expected function, string, or array as `test`");
+});
+/**
+* Handle multiple tests.
+*
+* @param {Array<TestFunction | string>} tests
+* @returns {Check}
+*/
+function anyFactory(tests) {
+	/** @type {Array<Check>} */
+	const checks = [];
+	let index = -1;
+	while (++index < tests.length) checks[index] = convertElement(tests[index]);
+	return castFactory(any);
+	/**
+	* @this {unknown}
+	* @type {TestFunction}
+	*/
+	function any(...parameters) {
+		let index = -1;
+		while (++index < checks.length) if (checks[index].apply(this, parameters)) return true;
+		return false;
+	}
+}
+/**
+* Turn a string into a test for an element with a certain type.
+*
+* @param {string} check
+* @returns {Check}
+*/
+function tagNameFactory(check) {
+	return castFactory(tagName);
+	/**
+	* @param {Element} element
+	* @returns {boolean}
+	*/
+	function tagName(element) {
+		return element.tagName === check;
+	}
+}
+/**
+* Turn a custom test into a test for an element that passes that test.
+*
+* @param {TestFunction} testFunction
+* @returns {Check}
+*/
+function castFactory(testFunction) {
+	return check;
+	/**
+	* @this {unknown}
+	* @type {Check}
+	*/
+	function check(value, index, parent) {
+		return Boolean(looksLikeAnElement(value) && testFunction.call(this, value, typeof index === "number" ? index : void 0, parent || void 0));
+	}
+}
+/**
+* Make sure something is an element.
+*
+* @param {unknown} element
+* @returns {element is Element}
+*/
+function element(element) {
+	return Boolean(element && typeof element === "object" && "type" in element && element.type === "element" && "tagName" in element && typeof element.tagName === "string");
+}
+/**
+* @param {unknown} value
+* @returns {value is Element}
+*/
+function looksLikeAnElement(value) {
+	return value !== null && typeof value === "object" && "type" in value && "tagName" in value;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/hast-util-to-text@4.0.2/node_modules/hast-util-to-text/lib/index.js
+/**
+* @typedef {import('hast').Comment} Comment
+* @typedef {import('hast').Element} Element
+* @typedef {import('hast').Nodes} Nodes
+* @typedef {import('hast').Parents} Parents
+* @typedef {import('hast').Text} Text
+* @typedef {import('hast-util-is-element').TestFunction} TestFunction
+*/
+/**
+* @typedef {'normal' | 'nowrap' | 'pre' | 'pre-wrap'} Whitespace
+*   Valid and useful whitespace values (from CSS).
+*
+* @typedef {0 | 1 | 2} BreakNumber
+*   Specific break:
+*
+*   *   `0` — space
+*   *   `1` — line ending
+*   *   `2` — blank line
+*
+* @typedef {'\n'} BreakForce
+*   Forced break.
+*
+* @typedef {boolean} BreakValue
+*   Whether there was a break.
+*
+* @typedef {BreakNumber | BreakValue | undefined} BreakBefore
+*   Any value for a break before.
+*
+* @typedef {BreakForce | BreakNumber | BreakValue | undefined} BreakAfter
+*   Any value for a break after.
+*
+* @typedef CollectionInfo
+*   Info on current collection.
+* @property {BreakAfter} breakAfter
+*   Whether there was a break after.
+* @property {BreakBefore} breakBefore
+*   Whether there was a break before.
+* @property {Whitespace} whitespace
+*   Current whitespace setting.
+*
+* @typedef Options
+*   Configuration.
+* @property {Whitespace | null | undefined} [whitespace='normal']
+*   Initial CSS whitespace setting to use (default: `'normal'`).
+*/
+var searchLineFeeds = /\n/g;
+var searchTabOrSpaces = /[\t ]+/g;
+var br = convertElement("br");
+var cell = convertElement(isCell);
+var p = convertElement("p");
+var row = convertElement("tr");
+var notRendered = convertElement([
+	"datalist",
+	"head",
+	"noembed",
+	"noframes",
+	"noscript",
+	"rp",
+	"script",
+	"style",
+	"template",
+	"title",
+	hidden,
+	closedDialog
+]);
+var blockOrCaption = convertElement([
+	"address",
+	"article",
+	"aside",
+	"blockquote",
+	"body",
+	"caption",
+	"center",
+	"dd",
+	"dialog",
+	"dir",
+	"dl",
+	"dt",
+	"div",
+	"figure",
+	"figcaption",
+	"footer",
+	"form,",
+	"h1",
+	"h2",
+	"h3",
+	"h4",
+	"h5",
+	"h6",
+	"header",
+	"hgroup",
+	"hr",
+	"html",
+	"legend",
+	"li",
+	"listing",
+	"main",
+	"menu",
+	"nav",
+	"ol",
+	"p",
+	"plaintext",
+	"pre",
+	"section",
+	"ul",
+	"xmp"
+]);
+/**
+* Get the plain-text value of a node.
+*
+* ###### Algorithm
+*
+* *   if `tree` is a comment, returns its `value`
+* *   if `tree` is a text, applies normal whitespace collapsing to its
+*     `value`, as defined by the CSS Text spec
+* *   if `tree` is a root or element, applies an algorithm similar to the
+*     `innerText` getter as defined by HTML
+*
+* ###### Notes
+*
+* > 👉 **Note**: the algorithm acts as if `tree` is being rendered, and as if
+* > we’re a CSS-supporting user agent, with scripting enabled.
+*
+* *   if `tree` is an element that is not displayed (such as a `head`), we’ll
+*     still use the `innerText` algorithm instead of switching to `textContent`
+* *   if descendants of `tree` are elements that are not displayed, they are
+*     ignored
+* *   CSS is not considered, except for the default user agent style sheet
+* *   a line feed is collapsed instead of ignored in cases where Fullwidth, Wide,
+*     or Halfwidth East Asian Width characters are used, the same goes for a case
+*     with Chinese, Japanese, or Yi writing systems
+* *   replaced elements (such as `audio`) are treated like non-replaced elements
+*
+* @param {Nodes} tree
+*   Tree to turn into text.
+* @param {Readonly<Options> | null | undefined} [options]
+*   Configuration (optional).
+* @returns {string}
+*   Serialized `tree`.
+*/
+function toText(tree, options) {
+	const options_ = options || {};
+	const children = "children" in tree ? tree.children : [];
+	const block = blockOrCaption(tree);
+	const whitespace = inferWhitespace(tree, {
+		whitespace: options_.whitespace || "normal",
+		breakBefore: false,
+		breakAfter: false
+	});
+	/** @type {Array<BreakNumber | string>} */
+	const results = [];
+	if (tree.type === "text" || tree.type === "comment") results.push(...collectText(tree, {
+		whitespace,
+		breakBefore: true,
+		breakAfter: true
+	}));
+	let index = -1;
+	while (++index < children.length) results.push(...renderedTextCollection(children[index], tree, {
+		whitespace,
+		breakBefore: index ? void 0 : block,
+		breakAfter: index < children.length - 1 ? br(children[index + 1]) : block
+	}));
+	/** @type {Array<string>} */
+	const result = [];
+	/** @type {number | undefined} */
+	let count;
+	index = -1;
+	while (++index < results.length) {
+		const value = results[index];
+		if (typeof value === "number") {
+			if (count !== void 0 && value > count) count = value;
+		} else if (value) {
+			if (count !== void 0 && count > -1) result.push("\n".repeat(count) || " ");
+			count = -1;
+			result.push(value);
+		}
+	}
+	return result.join("");
+}
+/**
+* <https://html.spec.whatwg.org/multipage/dom.html#rendered-text-collection-steps>
+*
+* @param {Nodes} node
+* @param {Parents} parent
+* @param {CollectionInfo} info
+* @returns {Array<BreakNumber | string>}
+*/
+function renderedTextCollection(node, parent, info) {
+	if (node.type === "element") return collectElement(node, parent, info);
+	if (node.type === "text") return info.whitespace === "normal" ? collectText(node, info) : collectPreText(node);
+	return [];
+}
+/**
+* Collect an element.
+*
+* @param {Element} node
+*   Element node.
+* @param {Parents} parent
+* @param {CollectionInfo} info
+*   Info on current collection.
+* @returns {Array<BreakNumber | string>}
+*/
+function collectElement(node, parent, info) {
+	const whitespace = inferWhitespace(node, info);
+	const children = node.children || [];
+	let index = -1;
+	/** @type {Array<BreakNumber | string>} */
+	let items = [];
+	if (notRendered(node)) return items;
+	/** @type {BreakNumber | undefined} */
+	let prefix;
+	/** @type {BreakForce | BreakNumber | undefined} */
+	let suffix;
+	if (br(node)) suffix = "\n";
+	else if (row(node) && findAfter(parent, node, row)) suffix = "\n";
+	else if (p(node)) {
+		prefix = 2;
+		suffix = 2;
+	} else if (blockOrCaption(node)) {
+		prefix = 1;
+		suffix = 1;
+	}
+	while (++index < children.length) items = items.concat(renderedTextCollection(children[index], node, {
+		whitespace,
+		breakBefore: index ? void 0 : prefix,
+		breakAfter: index < children.length - 1 ? br(children[index + 1]) : suffix
+	}));
+	if (cell(node) && findAfter(parent, node, cell)) items.push("	");
+	if (prefix) items.unshift(prefix);
+	if (suffix) items.push(suffix);
+	return items;
+}
+/**
+* 4.  If node is a Text node, then for each CSS text box produced by node,
+*     in content order, compute the text of the box after application of the
+*     CSS `white-space` processing rules and `text-transform` rules, set
+*     items to the list of the resulting strings, and return items.
+*     The CSS `white-space` processing rules are slightly modified:
+*     collapsible spaces at the end of lines are always collapsed, but they
+*     are only removed if the line is the last line of the block, or it ends
+*     with a br element.
+*     Soft hyphens should be preserved.
+*
+*     Note: See `collectText` and `collectPreText`.
+*     Note: we don’t deal with `text-transform`, no element has that by
+*     default.
+*
+* See: <https://drafts.csswg.org/css-text/#white-space-phase-1>
+*
+* @param {Comment | Text} node
+*   Text node.
+* @param {CollectionInfo} info
+*   Info on current collection.
+* @returns {Array<BreakNumber | string>}
+*   Result.
+*/
+function collectText(node, info) {
+	const value = String(node.value);
+	/** @type {Array<string>} */
+	const lines = [];
+	/** @type {Array<BreakNumber | string>} */
+	const result = [];
+	let start = 0;
+	while (start <= value.length) {
+		searchLineFeeds.lastIndex = start;
+		const match = searchLineFeeds.exec(value);
+		const end = match && "index" in match ? match.index : value.length;
+		lines.push(trimAndCollapseSpacesAndTabs(value.slice(start, end).replace(/[\u061C\u200E\u200F\u202A-\u202E\u2066-\u2069]/g, ""), start === 0 ? info.breakBefore : true, end === value.length ? info.breakAfter : true));
+		start = end + 1;
+	}
+	let index = -1;
+	/** @type {BreakNumber | undefined} */
+	let join;
+	while (++index < lines.length) if (lines[index].charCodeAt(lines[index].length - 1) === 8203 || index < lines.length - 1 && lines[index + 1].charCodeAt(0) === 8203) {
+		result.push(lines[index]);
+		join = void 0;
+	} else if (lines[index]) {
+		if (typeof join === "number") result.push(join);
+		result.push(lines[index]);
+		join = 0;
+	} else if (index === 0 || index === lines.length - 1) result.push(0);
+	return result;
+}
+/**
+* Collect a text node as “pre” whitespace.
+*
+* @param {Text} node
+*   Text node.
+* @returns {Array<BreakNumber | string>}
+*   Result.
+*/
+function collectPreText(node) {
+	return [String(node.value)];
+}
+/**
+* 3.  Every collapsible tab is converted to a collapsible space (U+0020).
+* 4.  Any collapsible space immediately following another collapsible
+*     space—even one outside the boundary of the inline containing that
+*     space, provided both spaces are within the same inline formatting
+*     context—is collapsed to have zero advance width. (It is invisible,
+*     but retains its soft wrap opportunity, if any.)
+*
+* @param {string} value
+*   Value to collapse.
+* @param {BreakBefore} breakBefore
+*   Whether there was a break before.
+* @param {BreakAfter} breakAfter
+*   Whether there was a break after.
+* @returns {string}
+*   Result.
+*/
+function trimAndCollapseSpacesAndTabs(value, breakBefore, breakAfter) {
+	/** @type {Array<string>} */
+	const result = [];
+	let start = 0;
+	/** @type {number | undefined} */
+	let end;
+	while (start < value.length) {
+		searchTabOrSpaces.lastIndex = start;
+		const match = searchTabOrSpaces.exec(value);
+		end = match ? match.index : value.length;
+		if (!start && !end && match && !breakBefore) result.push("");
+		if (start !== end) result.push(value.slice(start, end));
+		start = match ? end + match[0].length : end;
+	}
+	if (start !== end && !breakAfter) result.push("");
+	return result.join(" ");
+}
+/**
+* Figure out the whitespace of a node.
+*
+* We don’t support void elements here (so `nobr wbr` -> `normal` is ignored).
+*
+* @param {Nodes} node
+*   Node (typically `Element`).
+* @param {CollectionInfo} info
+*   Info on current collection.
+* @returns {Whitespace}
+*   Applied whitespace.
+*/
+function inferWhitespace(node, info) {
+	if (node.type === "element") {
+		const properties = node.properties || {};
+		switch (node.tagName) {
+			case "listing":
+			case "plaintext":
+			case "xmp": return "pre";
+			case "nobr": return "nowrap";
+			case "pre": return properties.wrap ? "pre-wrap" : "pre";
+			case "td":
+			case "th": return properties.noWrap ? "nowrap" : info.whitespace;
+			case "textarea": return "pre-wrap";
+			default:
+		}
+	}
+	return info.whitespace;
+}
+/**
+* @type {TestFunction}
+* @param {Element} node
+* @returns {node is {properties: {hidden: true}}}
+*/
+function hidden(node) {
+	return Boolean((node.properties || {}).hidden);
+}
+/**
+* @type {TestFunction}
+* @param {Element} node
+* @returns {node is {tagName: 'td' | 'th'}}
+*/
+function isCell(node) {
+	return node.tagName === "td" || node.tagName === "th";
+}
+/**
+* @type {TestFunction}
+*/
+function closedDialog(node) {
+	return node.tagName === "dialog" && !(node.properties || {}).open;
+}
+var core_default = (/* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
+	function deepFreeze(obj) {
+		if (obj instanceof Map) obj.clear = obj.delete = obj.set = function() {
+			throw new Error("map is read-only");
+		};
+		else if (obj instanceof Set) obj.add = obj.clear = obj.delete = function() {
+			throw new Error("set is read-only");
+		};
+		Object.freeze(obj);
+		Object.getOwnPropertyNames(obj).forEach((name) => {
+			const prop = obj[name];
+			const type = typeof prop;
+			if ((type === "object" || type === "function") && !Object.isFrozen(prop)) deepFreeze(prop);
+		});
+		return obj;
+	}
+	/** @typedef {import('highlight.js').CallbackResponse} CallbackResponse */
+	/** @typedef {import('highlight.js').CompiledMode} CompiledMode */
+	/** @implements CallbackResponse */
+	var Response = class {
+		/**
+		* @param {CompiledMode} mode
+		*/
+		constructor(mode) {
+			if (mode.data === void 0) mode.data = {};
+			this.data = mode.data;
+			this.isMatchIgnored = false;
+		}
+		ignoreMatch() {
+			this.isMatchIgnored = true;
+		}
+	};
+	/**
+	* @param {string} value
+	* @returns {string}
+	*/
+	function escapeHTML(value) {
+		return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#x27;");
+	}
+	/**
+	* performs a shallow merge of multiple objects into one
+	*
+	* @template T
+	* @param {T} original
+	* @param {Record<string,any>[]} objects
+	* @returns {T} a single new object
+	*/
+	function inherit$1(original, ...objects) {
+		/** @type Record<string,any> */
+		const result = Object.create(null);
+		for (const key in original) result[key] = original[key];
+		objects.forEach(function(obj) {
+			for (const key in obj) result[key] = obj[key];
+		});
+		return result;
+	}
+	/**
+	* @typedef {object} Renderer
+	* @property {(text: string) => void} addText
+	* @property {(node: Node) => void} openNode
+	* @property {(node: Node) => void} closeNode
+	* @property {() => string} value
+	*/
+	/** @typedef {{scope?: string, language?: string, sublanguage?: boolean}} Node */
+	/** @typedef {{walk: (r: Renderer) => void}} Tree */
+	/** */
+	var SPAN_CLOSE = "</span>";
+	/**
+	* Determines if a node needs to be wrapped in <span>
+	*
+	* @param {Node} node */
+	var emitsWrappingTags = (node) => {
+		return !!node.scope;
+	};
+	/**
+	*
+	* @param {string} name
+	* @param {{prefix:string}} options
+	*/
+	var scopeToCSSClass = (name, { prefix }) => {
+		if (name.startsWith("language:")) return name.replace("language:", "language-");
+		if (name.includes(".")) {
+			const pieces = name.split(".");
+			return [`${prefix}${pieces.shift()}`, ...pieces.map((x, i) => `${x}${"_".repeat(i + 1)}`)].join(" ");
+		}
+		return `${prefix}${name}`;
+	};
+	/** @type {Renderer} */
+	var HTMLRenderer = class {
+		/**
+		* Creates a new HTMLRenderer
+		*
+		* @param {Tree} parseTree - the parse tree (must support `walk` API)
+		* @param {{classPrefix: string}} options
+		*/
+		constructor(parseTree, options) {
+			this.buffer = "";
+			this.classPrefix = options.classPrefix;
+			parseTree.walk(this);
+		}
+		/**
+		* Adds texts to the output stream
+		*
+		* @param {string} text */
+		addText(text) {
+			this.buffer += escapeHTML(text);
+		}
+		/**
+		* Adds a node open to the output stream (if needed)
+		*
+		* @param {Node} node */
+		openNode(node) {
+			if (!emitsWrappingTags(node)) return;
+			const className = scopeToCSSClass(node.scope, { prefix: this.classPrefix });
+			this.span(className);
+		}
+		/**
+		* Adds a node close to the output stream (if needed)
+		*
+		* @param {Node} node */
+		closeNode(node) {
+			if (!emitsWrappingTags(node)) return;
+			this.buffer += SPAN_CLOSE;
+		}
+		/**
+		* returns the accumulated buffer
+		*/
+		value() {
+			return this.buffer;
+		}
+		/**
+		* Builds a span element
+		*
+		* @param {string} className */
+		span(className) {
+			this.buffer += `<span class="${className}">`;
+		}
+	};
+	/** @typedef {{scope?: string, language?: string, children: Node[]} | string} Node */
+	/** @typedef {{scope?: string, language?: string, children: Node[]} } DataNode */
+	/** @typedef {import('highlight.js').Emitter} Emitter */
+	/**  */
+	/** @returns {DataNode} */
+	var newNode = (opts = {}) => {
+		/** @type DataNode */
+		const result = { children: [] };
+		Object.assign(result, opts);
+		return result;
+	};
+	var TokenTree = class TokenTree {
+		constructor() {
+			/** @type DataNode */
+			this.rootNode = newNode();
+			this.stack = [this.rootNode];
+		}
+		get top() {
+			return this.stack[this.stack.length - 1];
+		}
+		get root() {
+			return this.rootNode;
+		}
+		/** @param {Node} node */
+		add(node) {
+			this.top.children.push(node);
+		}
+		/** @param {string} scope */
+		openNode(scope) {
+			/** @type Node */
+			const node = newNode({ scope });
+			this.add(node);
+			this.stack.push(node);
+		}
+		closeNode() {
+			if (this.stack.length > 1) return this.stack.pop();
+		}
+		closeAllNodes() {
+			while (this.closeNode());
+		}
+		toJSON() {
+			return JSON.stringify(this.rootNode, null, 4);
+		}
+		/**
+		* @typedef { import("./html_renderer").Renderer } Renderer
+		* @param {Renderer} builder
+		*/
+		walk(builder) {
+			return this.constructor._walk(builder, this.rootNode);
+		}
+		/**
+		* @param {Renderer} builder
+		* @param {Node} node
+		*/
+		static _walk(builder, node) {
+			if (typeof node === "string") builder.addText(node);
+			else if (node.children) {
+				builder.openNode(node);
+				node.children.forEach((child) => this._walk(builder, child));
+				builder.closeNode(node);
+			}
+			return builder;
+		}
+		/**
+		* @param {Node} node
+		*/
+		static _collapse(node) {
+			if (typeof node === "string") return;
+			if (!node.children) return;
+			if (node.children.every((el) => typeof el === "string")) node.children = [node.children.join("")];
+			else node.children.forEach((child) => {
+				TokenTree._collapse(child);
+			});
+		}
+	};
+	/**
+	Currently this is all private API, but this is the minimal API necessary
+	that an Emitter must implement to fully support the parser.
+	
+	Minimal interface:
+	
+	- addText(text)
+	- __addSublanguage(emitter, subLanguageName)
+	- startScope(scope)
+	- endScope()
+	- finalize()
+	- toHTML()
+	
+	*/
+	/**
+	* @implements {Emitter}
+	*/
+	var TokenTreeEmitter = class extends TokenTree {
+		/**
+		* @param {*} options
+		*/
+		constructor(options) {
+			super();
+			this.options = options;
+		}
+		/**
+		* @param {string} text
+		*/
+		addText(text) {
+			if (text === "") return;
+			this.add(text);
+		}
+		/** @param {string} scope */
+		startScope(scope) {
+			this.openNode(scope);
+		}
+		endScope() {
+			this.closeNode();
+		}
+		/**
+		* @param {Emitter & {root: DataNode}} emitter
+		* @param {string} name
+		*/
+		__addSublanguage(emitter, name) {
+			/** @type DataNode */
+			const node = emitter.root;
+			if (name) node.scope = `language:${name}`;
+			this.add(node);
+		}
+		toHTML() {
+			return new HTMLRenderer(this, this.options).value();
+		}
+		finalize() {
+			this.closeAllNodes();
+			return true;
+		}
+	};
+	/**
+	* @param {string} value
+	* @returns {RegExp}
+	* */
+	/**
+	* @param {RegExp | string } re
+	* @returns {string}
+	*/
+	function source(re) {
+		if (!re) return null;
+		if (typeof re === "string") return re;
+		return re.source;
+	}
+	/**
+	* @param {RegExp | string } re
+	* @returns {string}
+	*/
+	function lookahead(re) {
+		return concat("(?=", re, ")");
+	}
+	/**
+	* @param {RegExp | string } re
+	* @returns {string}
+	*/
+	function anyNumberOfTimes(re) {
+		return concat("(?:", re, ")*");
+	}
+	/**
+	* @param {RegExp | string } re
+	* @returns {string}
+	*/
+	function optional(re) {
+		return concat("(?:", re, ")?");
+	}
+	/**
+	* @param {...(RegExp | string) } args
+	* @returns {string}
+	*/
+	function concat(...args) {
+		return args.map((x) => source(x)).join("");
+	}
+	/**
+	* @param { Array<string | RegExp | Object> } args
+	* @returns {object}
+	*/
+	function stripOptionsFromArgs(args) {
+		const opts = args[args.length - 1];
+		if (typeof opts === "object" && opts.constructor === Object) {
+			args.splice(args.length - 1, 1);
+			return opts;
+		} else return {};
+	}
+	/** @typedef { {capture?: boolean} } RegexEitherOptions */
+	/**
+	* Any of the passed expresssions may match
+	*
+	* Creates a huge this | this | that | that match
+	* @param {(RegExp | string)[] | [...(RegExp | string)[], RegexEitherOptions]} args
+	* @returns {string}
+	*/
+	function either(...args) {
+		return "(" + (stripOptionsFromArgs(args).capture ? "" : "?:") + args.map((x) => source(x)).join("|") + ")";
+	}
+	/**
+	* @param {RegExp | string} re
+	* @returns {number}
+	*/
+	function countMatchGroups(re) {
+		return new RegExp(re.toString() + "|").exec("").length - 1;
+	}
+	/**
+	* Does lexeme start with a regular expression match at the beginning
+	* @param {RegExp} re
+	* @param {string} lexeme
+	*/
+	function startsWith(re, lexeme) {
+		const match = re && re.exec(lexeme);
+		return match && match.index === 0;
+	}
+	var BACKREF_RE = /\[(?:[^\\\]]|\\.)*\]|\(\??|\\([1-9][0-9]*)|\\./;
+	/**
+	* @param {(string | RegExp)[]} regexps
+	* @param {{joinWith: string}} opts
+	* @returns {string}
+	*/
+	function _rewriteBackreferences(regexps, { joinWith }) {
+		let numCaptures = 0;
+		return regexps.map((regex) => {
+			numCaptures += 1;
+			const offset = numCaptures;
+			let re = source(regex);
+			let out = "";
+			while (re.length > 0) {
+				const match = BACKREF_RE.exec(re);
+				if (!match) {
+					out += re;
+					break;
+				}
+				out += re.substring(0, match.index);
+				re = re.substring(match.index + match[0].length);
+				if (match[0][0] === "\\" && match[1]) out += "\\" + String(Number(match[1]) + offset);
+				else {
+					out += match[0];
+					if (match[0] === "(") numCaptures++;
+				}
+			}
+			return out;
+		}).map((re) => `(${re})`).join(joinWith);
+	}
+	/** @typedef {import('highlight.js').Mode} Mode */
+	/** @typedef {import('highlight.js').ModeCallback} ModeCallback */
+	var MATCH_NOTHING_RE = /\b\B/;
+	var IDENT_RE = "[a-zA-Z]\\w*";
+	var UNDERSCORE_IDENT_RE = "[a-zA-Z_]\\w*";
+	var NUMBER_RE = "\\b\\d+(\\.\\d+)?";
+	var C_NUMBER_RE = "(-?)(\\b0[xX][a-fA-F0-9]+|(\\b\\d+(\\.\\d*)?|\\.\\d+)([eE][-+]?\\d+)?)";
+	var BINARY_NUMBER_RE = "\\b(0b[01]+)";
+	var RE_STARTERS_RE = "!|!=|!==|%|%=|&|&&|&=|\\*|\\*=|\\+|\\+=|,|-|-=|/=|/|:|;|<<|<<=|<=|<|===|==|=|>>>=|>>=|>=|>>>|>>|>|\\?|\\[|\\{|\\(|\\^|\\^=|\\||\\|=|\\|\\||~";
+	/**
+	* @param { Partial<Mode> & {binary?: string | RegExp} } opts
+	*/
+	var SHEBANG = (opts = {}) => {
+		const beginShebang = /^#![ ]*\//;
+		if (opts.binary) opts.begin = concat(beginShebang, /.*\b/, opts.binary, /\b.*/);
+		return inherit$1({
+			scope: "meta",
+			begin: beginShebang,
+			end: /$/,
+			relevance: 0,
+			"on:begin": (m, resp) => {
+				if (m.index !== 0) resp.ignoreMatch();
+			}
+		}, opts);
+	};
+	var BACKSLASH_ESCAPE = {
+		begin: "\\\\[\\s\\S]",
+		relevance: 0
+	};
+	var APOS_STRING_MODE = {
+		scope: "string",
+		begin: "'",
+		end: "'",
+		illegal: "\\n",
+		contains: [BACKSLASH_ESCAPE]
+	};
+	var QUOTE_STRING_MODE = {
+		scope: "string",
+		begin: "\"",
+		end: "\"",
+		illegal: "\\n",
+		contains: [BACKSLASH_ESCAPE]
+	};
+	var PHRASAL_WORDS_MODE = { 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/ };
+	/**
+	* Creates a comment mode
+	*
+	* @param {string | RegExp} begin
+	* @param {string | RegExp} end
+	* @param {Mode | {}} [modeOptions]
+	* @returns {Partial<Mode>}
+	*/
+	var COMMENT = function(begin, end, modeOptions = {}) {
+		const mode = inherit$1({
+			scope: "comment",
+			begin,
+			end,
+			contains: []
+		}, modeOptions);
+		mode.contains.push({
+			scope: "doctag",
+			begin: "[ ]*(?=(TODO|FIXME|NOTE|BUG|OPTIMIZE|HACK|XXX):)",
+			end: /(TODO|FIXME|NOTE|BUG|OPTIMIZE|HACK|XXX):/,
+			excludeBegin: true,
+			relevance: 0
+		});
+		const ENGLISH_WORD = either("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,}/);
+		mode.contains.push({ begin: concat(/[ ]+/, "(", ENGLISH_WORD, /[.]?[:]?([.][ ]|[ ])/, "){3}") });
+		return mode;
+	};
+	var C_LINE_COMMENT_MODE = COMMENT("//", "$");
+	var C_BLOCK_COMMENT_MODE = COMMENT("/\\*", "\\*/");
+	var HASH_COMMENT_MODE = COMMENT("#", "$");
+	var NUMBER_MODE = {
+		scope: "number",
+		begin: NUMBER_RE,
+		relevance: 0
+	};
+	var C_NUMBER_MODE = {
+		scope: "number",
+		begin: C_NUMBER_RE,
+		relevance: 0
+	};
+	var BINARY_NUMBER_MODE = {
+		scope: "number",
+		begin: BINARY_NUMBER_RE,
+		relevance: 0
+	};
+	var REGEXP_MODE = {
+		scope: "regexp",
+		begin: /\/(?=[^/\n]*\/)/,
+		end: /\/[gimuy]*/,
+		contains: [BACKSLASH_ESCAPE, {
+			begin: /\[/,
+			end: /\]/,
+			relevance: 0,
+			contains: [BACKSLASH_ESCAPE]
+		}]
+	};
+	var TITLE_MODE = {
+		scope: "title",
+		begin: IDENT_RE,
+		relevance: 0
+	};
+	var UNDERSCORE_TITLE_MODE = {
+		scope: "title",
+		begin: UNDERSCORE_IDENT_RE,
+		relevance: 0
+	};
+	var METHOD_GUARD = {
+		begin: "\\.\\s*" + UNDERSCORE_IDENT_RE,
+		relevance: 0
+	};
+	/**
+	* Adds end same as begin mechanics to a mode
+	*
+	* Your mode must include at least a single () match group as that first match
+	* group is what is used for comparison
+	* @param {Partial<Mode>} mode
+	*/
+	var END_SAME_AS_BEGIN = function(mode) {
+		return Object.assign(mode, {
+			"on:begin": (m, resp) => {
+				resp.data._beginMatch = m[1];
+			},
+			"on:end": (m, resp) => {
+				if (resp.data._beginMatch !== m[1]) resp.ignoreMatch();
+			}
+		});
+	};
+	var MODES = /* @__PURE__ */ Object.freeze({
+		__proto__: null,
+		APOS_STRING_MODE,
+		BACKSLASH_ESCAPE,
+		BINARY_NUMBER_MODE,
+		BINARY_NUMBER_RE,
+		COMMENT,
+		C_BLOCK_COMMENT_MODE,
+		C_LINE_COMMENT_MODE,
+		C_NUMBER_MODE,
+		C_NUMBER_RE,
+		END_SAME_AS_BEGIN,
+		HASH_COMMENT_MODE,
+		IDENT_RE,
+		MATCH_NOTHING_RE,
+		METHOD_GUARD,
+		NUMBER_MODE,
+		NUMBER_RE,
+		PHRASAL_WORDS_MODE,
+		QUOTE_STRING_MODE,
+		REGEXP_MODE,
+		RE_STARTERS_RE,
+		SHEBANG,
+		TITLE_MODE,
+		UNDERSCORE_IDENT_RE,
+		UNDERSCORE_TITLE_MODE
+	});
+	/**
+	@typedef {import('highlight.js').CallbackResponse} CallbackResponse
+	@typedef {import('highlight.js').CompilerExt} CompilerExt
+	*/
+	/**
+	* Skip a match if it has a preceding dot
+	*
+	* This is used for `beginKeywords` to prevent matching expressions such as
+	* `bob.keyword.do()`. The mode compiler automatically wires this up as a
+	* special _internal_ 'on:begin' callback for modes with `beginKeywords`
+	* @param {RegExpMatchArray} match
+	* @param {CallbackResponse} response
+	*/
+	function skipIfHasPrecedingDot(match, response) {
+		if (match.input[match.index - 1] === ".") response.ignoreMatch();
+	}
+	/**
+	*
+	* @type {CompilerExt}
+	*/
+	function scopeClassName(mode, _parent) {
+		if (mode.className !== void 0) {
+			mode.scope = mode.className;
+			delete mode.className;
+		}
+	}
+	/**
+	* `beginKeywords` syntactic sugar
+	* @type {CompilerExt}
+	*/
+	function beginKeywords(mode, parent) {
+		if (!parent) return;
+		if (!mode.beginKeywords) return;
+		mode.begin = "\\b(" + mode.beginKeywords.split(" ").join("|") + ")(?!\\.)(?=\\b|\\s)";
+		mode.__beforeBegin = skipIfHasPrecedingDot;
+		mode.keywords = mode.keywords || mode.beginKeywords;
+		delete mode.beginKeywords;
+		if (mode.relevance === void 0) mode.relevance = 0;
+	}
+	/**
+	* Allow `illegal` to contain an array of illegal values
+	* @type {CompilerExt}
+	*/
+	function compileIllegal(mode, _parent) {
+		if (!Array.isArray(mode.illegal)) return;
+		mode.illegal = either(...mode.illegal);
+	}
+	/**
+	* `match` to match a single expression for readability
+	* @type {CompilerExt}
+	*/
+	function compileMatch(mode, _parent) {
+		if (!mode.match) return;
+		if (mode.begin || mode.end) throw new Error("begin & end are not supported with match");
+		mode.begin = mode.match;
+		delete mode.match;
+	}
+	/**
+	* provides the default 1 relevance to all modes
+	* @type {CompilerExt}
+	*/
+	function compileRelevance(mode, _parent) {
+		if (mode.relevance === void 0) mode.relevance = 1;
+	}
+	var beforeMatchExt = (mode, parent) => {
+		if (!mode.beforeMatch) return;
+		if (mode.starts) throw new Error("beforeMatch cannot be used with starts");
+		const originalMode = Object.assign({}, mode);
+		Object.keys(mode).forEach((key) => {
+			delete mode[key];
+		});
+		mode.keywords = originalMode.keywords;
+		mode.begin = concat(originalMode.beforeMatch, lookahead(originalMode.begin));
+		mode.starts = {
+			relevance: 0,
+			contains: [Object.assign(originalMode, { endsParent: true })]
+		};
+		mode.relevance = 0;
+		delete originalMode.beforeMatch;
+	};
+	var COMMON_KEYWORDS = [
+		"of",
+		"and",
+		"for",
+		"in",
+		"not",
+		"or",
+		"if",
+		"then",
+		"parent",
+		"list",
+		"value"
+	];
+	var DEFAULT_KEYWORD_SCOPE = "keyword";
+	/**
+	* Given raw keywords from a language definition, compile them.
+	*
+	* @param {string | Record<string,string|string[]> | Array<string>} rawKeywords
+	* @param {boolean} caseInsensitive
+	*/
+	function compileKeywords(rawKeywords, caseInsensitive, scopeName = DEFAULT_KEYWORD_SCOPE) {
+		/** @type {import("highlight.js/private").KeywordDict} */
+		const compiledKeywords = Object.create(null);
+		if (typeof rawKeywords === "string") compileList(scopeName, rawKeywords.split(" "));
+		else if (Array.isArray(rawKeywords)) compileList(scopeName, rawKeywords);
+		else Object.keys(rawKeywords).forEach(function(scopeName) {
+			Object.assign(compiledKeywords, compileKeywords(rawKeywords[scopeName], caseInsensitive, scopeName));
+		});
+		return compiledKeywords;
+		/**
+		* Compiles an individual list of keywords
+		*
+		* Ex: "for if when while|5"
+		*
+		* @param {string} scopeName
+		* @param {Array<string>} keywordList
+		*/
+		function compileList(scopeName, keywordList) {
+			if (caseInsensitive) keywordList = keywordList.map((x) => x.toLowerCase());
+			keywordList.forEach(function(keyword) {
+				const pair = keyword.split("|");
+				compiledKeywords[pair[0]] = [scopeName, scoreForKeyword(pair[0], pair[1])];
+			});
+		}
+	}
+	/**
+	* Returns the proper score for a given keyword
+	*
+	* Also takes into account comment keywords, which will be scored 0 UNLESS
+	* another score has been manually assigned.
+	* @param {string} keyword
+	* @param {string} [providedScore]
+	*/
+	function scoreForKeyword(keyword, providedScore) {
+		if (providedScore) return Number(providedScore);
+		return commonKeyword(keyword) ? 0 : 1;
+	}
+	/**
+	* Determines if a given keyword is common or not
+	*
+	* @param {string} keyword */
+	function commonKeyword(keyword) {
+		return COMMON_KEYWORDS.includes(keyword.toLowerCase());
+	}
+	/**
+	* @type {Record<string, boolean>}
+	*/
+	var seenDeprecations = {};
+	/**
+	* @param {string} message
+	*/
+	var error = (message) => {
+		console.error(message);
+	};
+	/**
+	* @param {string} message
+	* @param {any} args
+	*/
+	var warn = (message, ...args) => {
+		console.log(`WARN: ${message}`, ...args);
+	};
+	/**
+	* @param {string} version
+	* @param {string} message
+	*/
+	var deprecated = (version, message) => {
+		if (seenDeprecations[`${version}/${message}`]) return;
+		console.log(`Deprecated as of ${version}. ${message}`);
+		seenDeprecations[`${version}/${message}`] = true;
+	};
+	/**
+	@typedef {import('highlight.js').CompiledMode} CompiledMode
+	*/
+	var MultiClassError = /* @__PURE__ */ new Error();
+	/**
+	* Renumbers labeled scope names to account for additional inner match
+	* groups that otherwise would break everything.
+	*
+	* Lets say we 3 match scopes:
+	*
+	*   { 1 => ..., 2 => ..., 3 => ... }
+	*
+	* So what we need is a clean match like this:
+	*
+	*   (a)(b)(c) => [ "a", "b", "c" ]
+	*
+	* But this falls apart with inner match groups:
+	*
+	* (a)(((b)))(c) => ["a", "b", "b", "b", "c" ]
+	*
+	* Our scopes are now "out of alignment" and we're repeating `b` 3 times.
+	* What needs to happen is the numbers are remapped:
+	*
+	*   { 1 => ..., 2 => ..., 5 => ... }
+	*
+	* We also need to know that the ONLY groups that should be output
+	* are 1, 2, and 5.  This function handles this behavior.
+	*
+	* @param {CompiledMode} mode
+	* @param {Array<RegExp | string>} regexes
+	* @param {{key: "beginScope"|"endScope"}} opts
+	*/
+	function remapScopeNames(mode, regexes, { key }) {
+		let offset = 0;
+		const scopeNames = mode[key];
+		/** @type Record<number,boolean> */
+		const emit = {};
+		/** @type Record<number,string> */
+		const positions = {};
+		for (let i = 1; i <= regexes.length; i++) {
+			positions[i + offset] = scopeNames[i];
+			emit[i + offset] = true;
+			offset += countMatchGroups(regexes[i - 1]);
+		}
+		mode[key] = positions;
+		mode[key]._emit = emit;
+		mode[key]._multi = true;
+	}
+	/**
+	* @param {CompiledMode} mode
+	*/
+	function beginMultiClass(mode) {
+		if (!Array.isArray(mode.begin)) return;
+		if (mode.skip || mode.excludeBegin || mode.returnBegin) {
+			error("skip, excludeBegin, returnBegin not compatible with beginScope: {}");
+			throw MultiClassError;
+		}
+		if (typeof mode.beginScope !== "object" || mode.beginScope === null) {
+			error("beginScope must be object");
+			throw MultiClassError;
+		}
+		remapScopeNames(mode, mode.begin, { key: "beginScope" });
+		mode.begin = _rewriteBackreferences(mode.begin, { joinWith: "" });
+	}
+	/**
+	* @param {CompiledMode} mode
+	*/
+	function endMultiClass(mode) {
+		if (!Array.isArray(mode.end)) return;
+		if (mode.skip || mode.excludeEnd || mode.returnEnd) {
+			error("skip, excludeEnd, returnEnd not compatible with endScope: {}");
+			throw MultiClassError;
+		}
+		if (typeof mode.endScope !== "object" || mode.endScope === null) {
+			error("endScope must be object");
+			throw MultiClassError;
+		}
+		remapScopeNames(mode, mode.end, { key: "endScope" });
+		mode.end = _rewriteBackreferences(mode.end, { joinWith: "" });
+	}
+	/**
+	* this exists only to allow `scope: {}` to be used beside `match:`
+	* Otherwise `beginScope` would necessary and that would look weird
+	
+	{
+	match: [ /def/, /\w+/ ]
+	scope: { 1: "keyword" , 2: "title" }
+	}
+	
+	* @param {CompiledMode} mode
+	*/
+	function scopeSugar(mode) {
+		if (mode.scope && typeof mode.scope === "object" && mode.scope !== null) {
+			mode.beginScope = mode.scope;
+			delete mode.scope;
+		}
+	}
+	/**
+	* @param {CompiledMode} mode
+	*/
+	function MultiClass(mode) {
+		scopeSugar(mode);
+		if (typeof mode.beginScope === "string") mode.beginScope = { _wrap: mode.beginScope };
+		if (typeof mode.endScope === "string") mode.endScope = { _wrap: mode.endScope };
+		beginMultiClass(mode);
+		endMultiClass(mode);
+	}
+	/**
+	@typedef {import('highlight.js').Mode} Mode
+	@typedef {import('highlight.js').CompiledMode} CompiledMode
+	@typedef {import('highlight.js').Language} Language
+	@typedef {import('highlight.js').HLJSPlugin} HLJSPlugin
+	@typedef {import('highlight.js').CompiledLanguage} CompiledLanguage
+	*/
+	/**
+	* Compiles a language definition result
+	*
+	* Given the raw result of a language definition (Language), compiles this so
+	* that it is ready for highlighting code.
+	* @param {Language} language
+	* @returns {CompiledLanguage}
+	*/
+	function compileLanguage(language) {
+		/**
+		* Builds a regex with the case sensitivity of the current language
+		*
+		* @param {RegExp | string} value
+		* @param {boolean} [global]
+		*/
+		function langRe(value, global) {
+			return new RegExp(source(value), "m" + (language.case_insensitive ? "i" : "") + (language.unicodeRegex ? "u" : "") + (global ? "g" : ""));
+		}
+		/**
+		Stores multiple regular expressions and allows you to quickly search for
+		them all in a string simultaneously - returning the first match.  It does
+		this by creating a huge (a|b|c) regex - each individual item wrapped with ()
+		and joined by `|` - using match groups to track position.  When a match is
+		found checking which position in the array has content allows us to figure
+		out which of the original regexes / match groups triggered the match.
+		
+		The match object itself (the result of `Regex.exec`) is returned but also
+		enhanced by merging in any meta-data that was registered with the regex.
+		This is how we keep track of which mode matched, and what type of rule
+		(`illegal`, `begin`, end, etc).
+		*/
+		class MultiRegex {
+			constructor() {
+				this.matchIndexes = {};
+				this.regexes = [];
+				this.matchAt = 1;
+				this.position = 0;
+			}
+			addRule(re, opts) {
+				opts.position = this.position++;
+				this.matchIndexes[this.matchAt] = opts;
+				this.regexes.push([opts, re]);
+				this.matchAt += countMatchGroups(re) + 1;
+			}
+			compile() {
+				if (this.regexes.length === 0) this.exec = () => null;
+				this.matcherRe = langRe(_rewriteBackreferences(this.regexes.map((el) => el[1]), { joinWith: "|" }), true);
+				this.lastIndex = 0;
+			}
+			/** @param {string} s */
+			exec(s) {
+				this.matcherRe.lastIndex = this.lastIndex;
+				const match = this.matcherRe.exec(s);
+				if (!match) return null;
+				const i = match.findIndex((el, i) => i > 0 && el !== void 0);
+				const matchData = this.matchIndexes[i];
+				match.splice(0, i);
+				return Object.assign(match, matchData);
+			}
+		}
+		class ResumableMultiRegex {
+			constructor() {
+				this.rules = [];
+				this.multiRegexes = [];
+				this.count = 0;
+				this.lastIndex = 0;
+				this.regexIndex = 0;
+			}
+			getMatcher(index) {
+				if (this.multiRegexes[index]) return this.multiRegexes[index];
+				const matcher = new MultiRegex();
+				this.rules.slice(index).forEach(([re, opts]) => matcher.addRule(re, opts));
+				matcher.compile();
+				this.multiRegexes[index] = matcher;
+				return matcher;
+			}
+			resumingScanAtSamePosition() {
+				return this.regexIndex !== 0;
+			}
+			considerAll() {
+				this.regexIndex = 0;
+			}
+			addRule(re, opts) {
+				this.rules.push([re, opts]);
+				if (opts.type === "begin") this.count++;
+			}
+			/** @param {string} s */
+			exec(s) {
+				const m = this.getMatcher(this.regexIndex);
+				m.lastIndex = this.lastIndex;
+				let result = m.exec(s);
+				if (this.resumingScanAtSamePosition()) if (result && result.index === this.lastIndex);
+				else {
+					const m2 = this.getMatcher(0);
+					m2.lastIndex = this.lastIndex + 1;
+					result = m2.exec(s);
+				}
+				if (result) {
+					this.regexIndex += result.position + 1;
+					if (this.regexIndex === this.count) this.considerAll();
+				}
+				return result;
+			}
+		}
+		/**
+		* Given a mode, builds a huge ResumableMultiRegex that can be used to walk
+		* the content and find matches.
+		*
+		* @param {CompiledMode} mode
+		* @returns {ResumableMultiRegex}
+		*/
+		function buildModeRegex(mode) {
+			const mm = new ResumableMultiRegex();
+			mode.contains.forEach((term) => mm.addRule(term.begin, {
+				rule: term,
+				type: "begin"
+			}));
+			if (mode.terminatorEnd) mm.addRule(mode.terminatorEnd, { type: "end" });
+			if (mode.illegal) mm.addRule(mode.illegal, { type: "illegal" });
+			return mm;
+		}
+		/** skip vs abort vs ignore
+		*
+		* @skip   - The mode is still entered and exited normally (and contains rules apply),
+		*           but all content is held and added to the parent buffer rather than being
+		*           output when the mode ends.  Mostly used with `sublanguage` to build up
+		*           a single large buffer than can be parsed by sublanguage.
+		*
+		*             - The mode begin ands ends normally.
+		*             - Content matched is added to the parent mode buffer.
+		*             - The parser cursor is moved forward normally.
+		*
+		* @abort  - A hack placeholder until we have ignore.  Aborts the mode (as if it
+		*           never matched) but DOES NOT continue to match subsequent `contains`
+		*           modes.  Abort is bad/suboptimal because it can result in modes
+		*           farther down not getting applied because an earlier rule eats the
+		*           content but then aborts.
+		*
+		*             - The mode does not begin.
+		*             - Content matched by `begin` is added to the mode buffer.
+		*             - The parser cursor is moved forward accordingly.
+		*
+		* @ignore - Ignores the mode (as if it never matched) and continues to match any
+		*           subsequent `contains` modes.  Ignore isn't technically possible with
+		*           the current parser implementation.
+		*
+		*             - The mode does not begin.
+		*             - Content matched by `begin` is ignored.
+		*             - The parser cursor is not moved forward.
+		*/
+		/**
+		* Compiles an individual mode
+		*
+		* This can raise an error if the mode contains certain detectable known logic
+		* issues.
+		* @param {Mode} mode
+		* @param {CompiledMode | null} [parent]
+		* @returns {CompiledMode | never}
+		*/
+		function compileMode(mode, parent) {
+			const cmode = mode;
+			if (mode.isCompiled) return cmode;
+			[
+				scopeClassName,
+				compileMatch,
+				MultiClass,
+				beforeMatchExt
+			].forEach((ext) => ext(mode, parent));
+			language.compilerExtensions.forEach((ext) => ext(mode, parent));
+			mode.__beforeBegin = null;
+			[
+				beginKeywords,
+				compileIllegal,
+				compileRelevance
+			].forEach((ext) => ext(mode, parent));
+			mode.isCompiled = true;
+			let keywordPattern = null;
+			if (typeof mode.keywords === "object" && mode.keywords.$pattern) {
+				mode.keywords = Object.assign({}, mode.keywords);
+				keywordPattern = mode.keywords.$pattern;
+				delete mode.keywords.$pattern;
+			}
+			keywordPattern = keywordPattern || /\w+/;
+			if (mode.keywords) mode.keywords = compileKeywords(mode.keywords, language.case_insensitive);
+			cmode.keywordPatternRe = langRe(keywordPattern, true);
+			if (parent) {
+				if (!mode.begin) mode.begin = /\B|\b/;
+				cmode.beginRe = langRe(cmode.begin);
+				if (!mode.end && !mode.endsWithParent) mode.end = /\B|\b/;
+				if (mode.end) cmode.endRe = langRe(cmode.end);
+				cmode.terminatorEnd = source(cmode.end) || "";
+				if (mode.endsWithParent && parent.terminatorEnd) cmode.terminatorEnd += (mode.end ? "|" : "") + parent.terminatorEnd;
+			}
+			if (mode.illegal) cmode.illegalRe = langRe(mode.illegal);
+			if (!mode.contains) mode.contains = [];
+			mode.contains = [].concat(...mode.contains.map(function(c) {
+				return expandOrCloneMode(c === "self" ? mode : c);
+			}));
+			mode.contains.forEach(function(c) {
+				compileMode(c, cmode);
+			});
+			if (mode.starts) compileMode(mode.starts, parent);
+			cmode.matcher = buildModeRegex(cmode);
+			return cmode;
+		}
+		if (!language.compilerExtensions) language.compilerExtensions = [];
+		if (language.contains && language.contains.includes("self")) throw new Error("ERR: contains `self` is not supported at the top-level of a language.  See documentation.");
+		language.classNameAliases = inherit$1(language.classNameAliases || {});
+		return compileMode(language);
+	}
+	/**
+	* Determines if a mode has a dependency on it's parent or not
+	*
+	* If a mode does have a parent dependency then often we need to clone it if
+	* it's used in multiple places so that each copy points to the correct parent,
+	* where-as modes without a parent can often safely be re-used at the bottom of
+	* a mode chain.
+	*
+	* @param {Mode | null} mode
+	* @returns {boolean} - is there a dependency on the parent?
+	* */
+	function dependencyOnParent(mode) {
+		if (!mode) return false;
+		return mode.endsWithParent || dependencyOnParent(mode.starts);
+	}
+	/**
+	* Expands a mode or clones it if necessary
+	*
+	* This is necessary for modes with parental dependenceis (see notes on
+	* `dependencyOnParent`) and for nodes that have `variants` - which must then be
+	* exploded into their own individual modes at compile time.
+	*
+	* @param {Mode} mode
+	* @returns {Mode | Mode[]}
+	* */
+	function expandOrCloneMode(mode) {
+		if (mode.variants && !mode.cachedVariants) mode.cachedVariants = mode.variants.map(function(variant) {
+			return inherit$1(mode, { variants: null }, variant);
+		});
+		if (mode.cachedVariants) return mode.cachedVariants;
+		if (dependencyOnParent(mode)) return inherit$1(mode, { starts: mode.starts ? inherit$1(mode.starts) : null });
+		if (Object.isFrozen(mode)) return inherit$1(mode);
+		return mode;
+	}
+	var version = "11.11.1";
+	var HTMLInjectionError = class extends Error {
+		constructor(reason, html) {
+			super(reason);
+			this.name = "HTMLInjectionError";
+			this.html = html;
+		}
+	};
+	/**
+	@typedef {import('highlight.js').Mode} Mode
+	@typedef {import('highlight.js').CompiledMode} CompiledMode
+	@typedef {import('highlight.js').CompiledScope} CompiledScope
+	@typedef {import('highlight.js').Language} Language
+	@typedef {import('highlight.js').HLJSApi} HLJSApi
+	@typedef {import('highlight.js').HLJSPlugin} HLJSPlugin
+	@typedef {import('highlight.js').PluginEvent} PluginEvent
+	@typedef {import('highlight.js').HLJSOptions} HLJSOptions
+	@typedef {import('highlight.js').LanguageFn} LanguageFn
+	@typedef {import('highlight.js').HighlightedHTMLElement} HighlightedHTMLElement
+	@typedef {import('highlight.js').BeforeHighlightContext} BeforeHighlightContext
+	@typedef {import('highlight.js/private').MatchType} MatchType
+	@typedef {import('highlight.js/private').KeywordData} KeywordData
+	@typedef {import('highlight.js/private').EnhancedMatch} EnhancedMatch
+	@typedef {import('highlight.js/private').AnnotatedError} AnnotatedError
+	@typedef {import('highlight.js').AutoHighlightResult} AutoHighlightResult
+	@typedef {import('highlight.js').HighlightOptions} HighlightOptions
+	@typedef {import('highlight.js').HighlightResult} HighlightResult
+	*/
+	var escape = escapeHTML;
+	var inherit = inherit$1;
+	var NO_MATCH = Symbol("nomatch");
+	var MAX_KEYWORD_HITS = 7;
+	/**
+	* @param {any} hljs - object that is extended (legacy)
+	* @returns {HLJSApi}
+	*/
+	var HLJS = function(hljs) {
+		/** @type {Record<string, Language>} */
+		const languages = Object.create(null);
+		/** @type {Record<string, string>} */
+		const aliases = Object.create(null);
+		/** @type {HLJSPlugin[]} */
+		const plugins = [];
+		let SAFE_MODE = true;
+		const LANGUAGE_NOT_FOUND = "Could not find the language '{}', did you forget to load/include a language module?";
+		/** @type {Language} */
+		const PLAINTEXT_LANGUAGE = {
+			disableAutodetect: true,
+			name: "Plain text",
+			contains: []
+		};
+		/** @type HLJSOptions */
+		let options = {
+			ignoreUnescapedHTML: false,
+			throwUnescapedHTML: false,
+			noHighlightRe: /^(no-?highlight)$/i,
+			languageDetectRe: /\blang(?:uage)?-([\w-]+)\b/i,
+			classPrefix: "hljs-",
+			cssSelector: "pre code",
+			languages: null,
+			__emitter: TokenTreeEmitter
+		};
+		/**
+		* Tests a language name to see if highlighting should be skipped
+		* @param {string} languageName
+		*/
+		function shouldNotHighlight(languageName) {
+			return options.noHighlightRe.test(languageName);
+		}
+		/**
+		* @param {HighlightedHTMLElement} block - the HTML element to determine language for
+		*/
+		function blockLanguage(block) {
+			let classes = block.className + " ";
+			classes += block.parentNode ? block.parentNode.className : "";
+			const match = options.languageDetectRe.exec(classes);
+			if (match) {
+				const language = getLanguage(match[1]);
+				if (!language) {
+					warn(LANGUAGE_NOT_FOUND.replace("{}", match[1]));
+					warn("Falling back to no-highlight mode for this block.", block);
+				}
+				return language ? match[1] : "no-highlight";
+			}
+			return classes.split(/\s+/).find((_class) => shouldNotHighlight(_class) || getLanguage(_class));
+		}
+		/**
+		* Core highlighting function.
+		*
+		* OLD API
+		* highlight(lang, code, ignoreIllegals, continuation)
+		*
+		* NEW API
+		* highlight(code, {lang, ignoreIllegals})
+		*
+		* @param {string} codeOrLanguageName - the language to use for highlighting
+		* @param {string | HighlightOptions} optionsOrCode - the code to highlight
+		* @param {boolean} [ignoreIllegals] - whether to ignore illegal matches, default is to bail
+		*
+		* @returns {HighlightResult} Result - an object that represents the result
+		* @property {string} language - the language name
+		* @property {number} relevance - the relevance score
+		* @property {string} value - the highlighted HTML code
+		* @property {string} code - the original raw code
+		* @property {CompiledMode} top - top of the current mode stack
+		* @property {boolean} illegal - indicates whether any illegal matches were found
+		*/
+		function highlight(codeOrLanguageName, optionsOrCode, ignoreIllegals) {
+			let code = "";
+			let languageName = "";
+			if (typeof optionsOrCode === "object") {
+				code = codeOrLanguageName;
+				ignoreIllegals = optionsOrCode.ignoreIllegals;
+				languageName = optionsOrCode.language;
+			} else {
+				deprecated("10.7.0", "highlight(lang, code, ...args) has been deprecated.");
+				deprecated("10.7.0", "Please use highlight(code, options) instead.\nhttps://github.com/highlightjs/highlight.js/issues/2277");
+				languageName = codeOrLanguageName;
+				code = optionsOrCode;
+			}
+			if (ignoreIllegals === void 0) ignoreIllegals = true;
+			/** @type {BeforeHighlightContext} */
+			const context = {
+				code,
+				language: languageName
+			};
+			fire("before:highlight", context);
+			const result = context.result ? context.result : _highlight(context.language, context.code, ignoreIllegals);
+			result.code = context.code;
+			fire("after:highlight", result);
+			return result;
+		}
+		/**
+		* private highlight that's used internally and does not fire callbacks
+		*
+		* @param {string} languageName - the language to use for highlighting
+		* @param {string} codeToHighlight - the code to highlight
+		* @param {boolean?} [ignoreIllegals] - whether to ignore illegal matches, default is to bail
+		* @param {CompiledMode?} [continuation] - current continuation mode, if any
+		* @returns {HighlightResult} - result of the highlight operation
+		*/
+		function _highlight(languageName, codeToHighlight, ignoreIllegals, continuation) {
+			const keywordHits = Object.create(null);
+			/**
+			* Return keyword data if a match is a keyword
+			* @param {CompiledMode} mode - current mode
+			* @param {string} matchText - the textual match
+			* @returns {KeywordData | false}
+			*/
+			function keywordData(mode, matchText) {
+				return mode.keywords[matchText];
+			}
+			function processKeywords() {
+				if (!top.keywords) {
+					emitter.addText(modeBuffer);
+					return;
+				}
+				let lastIndex = 0;
+				top.keywordPatternRe.lastIndex = 0;
+				let match = top.keywordPatternRe.exec(modeBuffer);
+				let buf = "";
+				while (match) {
+					buf += modeBuffer.substring(lastIndex, match.index);
+					const word = language.case_insensitive ? match[0].toLowerCase() : match[0];
+					const data = keywordData(top, word);
+					if (data) {
+						const [kind, keywordRelevance] = data;
+						emitter.addText(buf);
+						buf = "";
+						keywordHits[word] = (keywordHits[word] || 0) + 1;
+						if (keywordHits[word] <= MAX_KEYWORD_HITS) relevance += keywordRelevance;
+						if (kind.startsWith("_")) buf += match[0];
+						else {
+							const cssClass = language.classNameAliases[kind] || kind;
+							emitKeyword(match[0], cssClass);
+						}
+					} else buf += match[0];
+					lastIndex = top.keywordPatternRe.lastIndex;
+					match = top.keywordPatternRe.exec(modeBuffer);
+				}
+				buf += modeBuffer.substring(lastIndex);
+				emitter.addText(buf);
+			}
+			function processSubLanguage() {
+				if (modeBuffer === "") return;
+				/** @type HighlightResult */
+				let result = null;
+				if (typeof top.subLanguage === "string") {
+					if (!languages[top.subLanguage]) {
+						emitter.addText(modeBuffer);
+						return;
+					}
+					result = _highlight(top.subLanguage, modeBuffer, true, continuations[top.subLanguage]);
+					continuations[top.subLanguage] = result._top;
+				} else result = highlightAuto(modeBuffer, top.subLanguage.length ? top.subLanguage : null);
+				if (top.relevance > 0) relevance += result.relevance;
+				emitter.__addSublanguage(result._emitter, result.language);
+			}
+			function processBuffer() {
+				if (top.subLanguage != null) processSubLanguage();
+				else processKeywords();
+				modeBuffer = "";
+			}
+			/**
+			* @param {string} text
+			* @param {string} scope
+			*/
+			function emitKeyword(keyword, scope) {
+				if (keyword === "") return;
+				emitter.startScope(scope);
+				emitter.addText(keyword);
+				emitter.endScope();
+			}
+			/**
+			* @param {CompiledScope} scope
+			* @param {RegExpMatchArray} match
+			*/
+			function emitMultiClass(scope, match) {
+				let i = 1;
+				const max = match.length - 1;
+				while (i <= max) {
+					if (!scope._emit[i]) {
+						i++;
+						continue;
+					}
+					const klass = language.classNameAliases[scope[i]] || scope[i];
+					const text = match[i];
+					if (klass) emitKeyword(text, klass);
+					else {
+						modeBuffer = text;
+						processKeywords();
+						modeBuffer = "";
+					}
+					i++;
+				}
+			}
+			/**
+			* @param {CompiledMode} mode - new mode to start
+			* @param {RegExpMatchArray} match
+			*/
+			function startNewMode(mode, match) {
+				if (mode.scope && typeof mode.scope === "string") emitter.openNode(language.classNameAliases[mode.scope] || mode.scope);
+				if (mode.beginScope) {
+					if (mode.beginScope._wrap) {
+						emitKeyword(modeBuffer, language.classNameAliases[mode.beginScope._wrap] || mode.beginScope._wrap);
+						modeBuffer = "";
+					} else if (mode.beginScope._multi) {
+						emitMultiClass(mode.beginScope, match);
+						modeBuffer = "";
+					}
+				}
+				top = Object.create(mode, { parent: { value: top } });
+				return top;
+			}
+			/**
+			* @param {CompiledMode } mode - the mode to potentially end
+			* @param {RegExpMatchArray} match - the latest match
+			* @param {string} matchPlusRemainder - match plus remainder of content
+			* @returns {CompiledMode | void} - the next mode, or if void continue on in current mode
+			*/
+			function endOfMode(mode, match, matchPlusRemainder) {
+				let matched = startsWith(mode.endRe, matchPlusRemainder);
+				if (matched) {
+					if (mode["on:end"]) {
+						const resp = new Response(mode);
+						mode["on:end"](match, resp);
+						if (resp.isMatchIgnored) matched = false;
+					}
+					if (matched) {
+						while (mode.endsParent && mode.parent) mode = mode.parent;
+						return mode;
+					}
+				}
+				if (mode.endsWithParent) return endOfMode(mode.parent, match, matchPlusRemainder);
+			}
+			/**
+			* Handle matching but then ignoring a sequence of text
+			*
+			* @param {string} lexeme - string containing full match text
+			*/
+			function doIgnore(lexeme) {
+				if (top.matcher.regexIndex === 0) {
+					modeBuffer += lexeme[0];
+					return 1;
+				} else {
+					resumeScanAtSamePosition = true;
+					return 0;
+				}
+			}
+			/**
+			* Handle the start of a new potential mode match
+			*
+			* @param {EnhancedMatch} match - the current match
+			* @returns {number} how far to advance the parse cursor
+			*/
+			function doBeginMatch(match) {
+				const lexeme = match[0];
+				const newMode = match.rule;
+				const resp = new Response(newMode);
+				const beforeCallbacks = [newMode.__beforeBegin, newMode["on:begin"]];
+				for (const cb of beforeCallbacks) {
+					if (!cb) continue;
+					cb(match, resp);
+					if (resp.isMatchIgnored) return doIgnore(lexeme);
+				}
+				if (newMode.skip) modeBuffer += lexeme;
+				else {
+					if (newMode.excludeBegin) modeBuffer += lexeme;
+					processBuffer();
+					if (!newMode.returnBegin && !newMode.excludeBegin) modeBuffer = lexeme;
+				}
+				startNewMode(newMode, match);
+				return newMode.returnBegin ? 0 : lexeme.length;
+			}
+			/**
+			* Handle the potential end of mode
+			*
+			* @param {RegExpMatchArray} match - the current match
+			*/
+			function doEndMatch(match) {
+				const lexeme = match[0];
+				const matchPlusRemainder = codeToHighlight.substring(match.index);
+				const endMode = endOfMode(top, match, matchPlusRemainder);
+				if (!endMode) return NO_MATCH;
+				const origin = top;
+				if (top.endScope && top.endScope._wrap) {
+					processBuffer();
+					emitKeyword(lexeme, top.endScope._wrap);
+				} else if (top.endScope && top.endScope._multi) {
+					processBuffer();
+					emitMultiClass(top.endScope, match);
+				} else if (origin.skip) modeBuffer += lexeme;
+				else {
+					if (!(origin.returnEnd || origin.excludeEnd)) modeBuffer += lexeme;
+					processBuffer();
+					if (origin.excludeEnd) modeBuffer = lexeme;
+				}
+				do {
+					if (top.scope) emitter.closeNode();
+					if (!top.skip && !top.subLanguage) relevance += top.relevance;
+					top = top.parent;
+				} while (top !== endMode.parent);
+				if (endMode.starts) startNewMode(endMode.starts, match);
+				return origin.returnEnd ? 0 : lexeme.length;
+			}
+			function processContinuations() {
+				const list = [];
+				for (let current = top; current !== language; current = current.parent) if (current.scope) list.unshift(current.scope);
+				list.forEach((item) => emitter.openNode(item));
+			}
+			/** @type {{type?: MatchType, index?: number, rule?: Mode}}} */
+			let lastMatch = {};
+			/**
+			*  Process an individual match
+			*
+			* @param {string} textBeforeMatch - text preceding the match (since the last match)
+			* @param {EnhancedMatch} [match] - the match itself
+			*/
+			function processLexeme(textBeforeMatch, match) {
+				const lexeme = match && match[0];
+				modeBuffer += textBeforeMatch;
+				if (lexeme == null) {
+					processBuffer();
+					return 0;
+				}
+				if (lastMatch.type === "begin" && match.type === "end" && lastMatch.index === match.index && lexeme === "") {
+					modeBuffer += codeToHighlight.slice(match.index, match.index + 1);
+					if (!SAFE_MODE) {
+						/** @type {AnnotatedError} */
+						const err = /* @__PURE__ */ new Error(`0 width match regex (${languageName})`);
+						err.languageName = languageName;
+						err.badRule = lastMatch.rule;
+						throw err;
+					}
+					return 1;
+				}
+				lastMatch = match;
+				if (match.type === "begin") return doBeginMatch(match);
+				else if (match.type === "illegal" && !ignoreIllegals) {
+					/** @type {AnnotatedError} */
+					const err = /* @__PURE__ */ new Error("Illegal lexeme \"" + lexeme + "\" for mode \"" + (top.scope || "<unnamed>") + "\"");
+					err.mode = top;
+					throw err;
+				} else if (match.type === "end") {
+					const processed = doEndMatch(match);
+					if (processed !== NO_MATCH) return processed;
+				}
+				if (match.type === "illegal" && lexeme === "") {
+					modeBuffer += "\n";
+					return 1;
+				}
+				if (iterations > 1e5 && iterations > match.index * 3) throw /* @__PURE__ */ new Error("potential infinite loop, way more iterations than matches");
+				modeBuffer += lexeme;
+				return lexeme.length;
+			}
+			const language = getLanguage(languageName);
+			if (!language) {
+				error(LANGUAGE_NOT_FOUND.replace("{}", languageName));
+				throw new Error("Unknown language: \"" + languageName + "\"");
+			}
+			const md = compileLanguage(language);
+			let result = "";
+			/** @type {CompiledMode} */
+			let top = continuation || md;
+			/** @type Record<string,CompiledMode> */
+			const continuations = {};
+			const emitter = new options.__emitter(options);
+			processContinuations();
+			let modeBuffer = "";
+			let relevance = 0;
+			let index = 0;
+			let iterations = 0;
+			let resumeScanAtSamePosition = false;
+			try {
+				if (!language.__emitTokens) {
+					top.matcher.considerAll();
+					for (;;) {
+						iterations++;
+						if (resumeScanAtSamePosition) resumeScanAtSamePosition = false;
+						else top.matcher.considerAll();
+						top.matcher.lastIndex = index;
+						const match = top.matcher.exec(codeToHighlight);
+						if (!match) break;
+						const processedCount = processLexeme(codeToHighlight.substring(index, match.index), match);
+						index = match.index + processedCount;
+					}
+					processLexeme(codeToHighlight.substring(index));
+				} else language.__emitTokens(codeToHighlight, emitter);
+				emitter.finalize();
+				result = emitter.toHTML();
+				return {
+					language: languageName,
+					value: result,
+					relevance,
+					illegal: false,
+					_emitter: emitter,
+					_top: top
+				};
+			} catch (err) {
+				if (err.message && err.message.includes("Illegal")) return {
+					language: languageName,
+					value: escape(codeToHighlight),
+					illegal: true,
+					relevance: 0,
+					_illegalBy: {
+						message: err.message,
+						index,
+						context: codeToHighlight.slice(index - 100, index + 100),
+						mode: err.mode,
+						resultSoFar: result
+					},
+					_emitter: emitter
+				};
+				else if (SAFE_MODE) return {
+					language: languageName,
+					value: escape(codeToHighlight),
+					illegal: false,
+					relevance: 0,
+					errorRaised: err,
+					_emitter: emitter,
+					_top: top
+				};
+				else throw err;
+			}
+		}
+		/**
+		* returns a valid highlight result, without actually doing any actual work,
+		* auto highlight starts with this and it's possible for small snippets that
+		* auto-detection may not find a better match
+		* @param {string} code
+		* @returns {HighlightResult}
+		*/
+		function justTextHighlightResult(code) {
+			const result = {
+				value: escape(code),
+				illegal: false,
+				relevance: 0,
+				_top: PLAINTEXT_LANGUAGE,
+				_emitter: new options.__emitter(options)
+			};
+			result._emitter.addText(code);
+			return result;
+		}
+		/**
+		Highlighting with language detection. Accepts a string with the code to
+		highlight. Returns an object with the following properties:
+		
+		- language (detected language)
+		- relevance (int)
+		- value (an HTML string with highlighting markup)
+		- secondBest (object with the same structure for second-best heuristically
+		detected language, may be absent)
+		
+		@param {string} code
+		@param {Array<string>} [languageSubset]
+		@returns {AutoHighlightResult}
+		*/
+		function highlightAuto(code, languageSubset) {
+			languageSubset = languageSubset || options.languages || Object.keys(languages);
+			const plaintext = justTextHighlightResult(code);
+			const results = languageSubset.filter(getLanguage).filter(autoDetection).map((name) => _highlight(name, code, false));
+			results.unshift(plaintext);
+			const [best, secondBest] = results.sort((a, b) => {
+				if (a.relevance !== b.relevance) return b.relevance - a.relevance;
+				if (a.language && b.language) {
+					if (getLanguage(a.language).supersetOf === b.language) return 1;
+					else if (getLanguage(b.language).supersetOf === a.language) return -1;
+				}
+				return 0;
+			});
+			/** @type {AutoHighlightResult} */
+			const result = best;
+			result.secondBest = secondBest;
+			return result;
+		}
+		/**
+		* Builds new class name for block given the language name
+		*
+		* @param {HTMLElement} element
+		* @param {string} [currentLang]
+		* @param {string} [resultLang]
+		*/
+		function updateClassName(element, currentLang, resultLang) {
+			const language = currentLang && aliases[currentLang] || resultLang;
+			element.classList.add("hljs");
+			element.classList.add(`language-${language}`);
+		}
+		/**
+		* Applies highlighting to a DOM node containing code.
+		*
+		* @param {HighlightedHTMLElement} element - the HTML element to highlight
+		*/
+		function highlightElement(element) {
+			/** @type HTMLElement */
+			let node = null;
+			const language = blockLanguage(element);
+			if (shouldNotHighlight(language)) return;
+			fire("before:highlightElement", {
+				el: element,
+				language
+			});
+			if (element.dataset.highlighted) {
+				console.log("Element previously highlighted. To highlight again, first unset `dataset.highlighted`.", element);
+				return;
+			}
+			if (element.children.length > 0) {
+				if (!options.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(element);
+				}
+				if (options.throwUnescapedHTML) throw new HTMLInjectionError("One of your code blocks includes unescaped HTML.", element.innerHTML);
+			}
+			node = element;
+			const text = node.textContent;
+			const result = language ? highlight(text, {
+				language,
+				ignoreIllegals: true
+			}) : highlightAuto(text);
+			element.innerHTML = result.value;
+			element.dataset.highlighted = "yes";
+			updateClassName(element, language, result.language);
+			element.result = {
+				language: result.language,
+				re: result.relevance,
+				relevance: result.relevance
+			};
+			if (result.secondBest) element.secondBest = {
+				language: result.secondBest.language,
+				relevance: result.secondBest.relevance
+			};
+			fire("after:highlightElement", {
+				el: element,
+				result,
+				text
+			});
+		}
+		/**
+		* Updates highlight.js global options with the passed options
+		*
+		* @param {Partial<HLJSOptions>} userOptions
+		*/
+		function configure(userOptions) {
+			options = inherit(options, userOptions);
+		}
+		const initHighlighting = () => {
+			highlightAll();
+			deprecated("10.6.0", "initHighlighting() deprecated.  Use highlightAll() now.");
+		};
+		function initHighlightingOnLoad() {
+			highlightAll();
+			deprecated("10.6.0", "initHighlightingOnLoad() deprecated.  Use highlightAll() now.");
+		}
+		let wantsHighlight = false;
+		/**
+		* auto-highlights all pre>code elements on the page
+		*/
+		function highlightAll() {
+			function boot() {
+				highlightAll();
+			}
+			if (document.readyState === "loading") {
+				if (!wantsHighlight) window.addEventListener("DOMContentLoaded", boot, false);
+				wantsHighlight = true;
+				return;
+			}
+			document.querySelectorAll(options.cssSelector).forEach(highlightElement);
+		}
+		/**
+		* Register a language grammar module
+		*
+		* @param {string} languageName
+		* @param {LanguageFn} languageDefinition
+		*/
+		function registerLanguage(languageName, languageDefinition) {
+			let lang = null;
+			try {
+				lang = languageDefinition(hljs);
+			} catch (error$1) {
+				error("Language definition for '{}' could not be registered.".replace("{}", languageName));
+				if (!SAFE_MODE) throw error$1;
+				else error(error$1);
+				lang = PLAINTEXT_LANGUAGE;
+			}
+			if (!lang.name) lang.name = languageName;
+			languages[languageName] = lang;
+			lang.rawDefinition = languageDefinition.bind(null, hljs);
+			if (lang.aliases) registerAliases(lang.aliases, { languageName });
+		}
+		/**
+		* Remove a language grammar module
+		*
+		* @param {string} languageName
+		*/
+		function unregisterLanguage(languageName) {
+			delete languages[languageName];
+			for (const alias of Object.keys(aliases)) if (aliases[alias] === languageName) delete aliases[alias];
+		}
+		/**
+		* @returns {string[]} List of language internal names
+		*/
+		function listLanguages() {
+			return Object.keys(languages);
+		}
+		/**
+		* @param {string} name - name of the language to retrieve
+		* @returns {Language | undefined}
+		*/
+		function getLanguage(name) {
+			name = (name || "").toLowerCase();
+			return languages[name] || languages[aliases[name]];
+		}
+		/**
+		*
+		* @param {string|string[]} aliasList - single alias or list of aliases
+		* @param {{languageName: string}} opts
+		*/
+		function registerAliases(aliasList, { languageName }) {
+			if (typeof aliasList === "string") aliasList = [aliasList];
+			aliasList.forEach((alias) => {
+				aliases[alias.toLowerCase()] = languageName;
+			});
+		}
+		/**
+		* Determines if a given language has auto-detection enabled
+		* @param {string} name - name of the language
+		*/
+		function autoDetection(name) {
+			const lang = getLanguage(name);
+			return lang && !lang.disableAutodetect;
+		}
+		/**
+		* Upgrades the old highlightBlock plugins to the new
+		* highlightElement API
+		* @param {HLJSPlugin} plugin
+		*/
+		function upgradePluginAPI(plugin) {
+			if (plugin["before:highlightBlock"] && !plugin["before:highlightElement"]) plugin["before:highlightElement"] = (data) => {
+				plugin["before:highlightBlock"](Object.assign({ block: data.el }, data));
+			};
+			if (plugin["after:highlightBlock"] && !plugin["after:highlightElement"]) plugin["after:highlightElement"] = (data) => {
+				plugin["after:highlightBlock"](Object.assign({ block: data.el }, data));
+			};
+		}
+		/**
+		* @param {HLJSPlugin} plugin
+		*/
+		function addPlugin(plugin) {
+			upgradePluginAPI(plugin);
+			plugins.push(plugin);
+		}
+		/**
+		* @param {HLJSPlugin} plugin
+		*/
+		function removePlugin(plugin) {
+			const index = plugins.indexOf(plugin);
+			if (index !== -1) plugins.splice(index, 1);
+		}
+		/**
+		*
+		* @param {PluginEvent} event
+		* @param {any} args
+		*/
+		function fire(event, args) {
+			const cb = event;
+			plugins.forEach(function(plugin) {
+				if (plugin[cb]) plugin[cb](args);
+			});
+		}
+		/**
+		* DEPRECATED
+		* @param {HighlightedHTMLElement} el
+		*/
+		function deprecateHighlightBlock(el) {
+			deprecated("10.7.0", "highlightBlock will be removed entirely in v12.0");
+			deprecated("10.7.0", "Please use highlightElement now.");
+			return highlightElement(el);
+		}
+		Object.assign(hljs, {
+			highlight,
+			highlightAuto,
+			highlightAll,
+			highlightElement,
+			highlightBlock: deprecateHighlightBlock,
+			configure,
+			initHighlighting,
+			initHighlightingOnLoad,
+			registerLanguage,
+			unregisterLanguage,
+			listLanguages,
+			getLanguage,
+			registerAliases,
+			autoDetection,
+			inherit,
+			addPlugin,
+			removePlugin
+		});
+		hljs.debugMode = function() {
+			SAFE_MODE = false;
+		};
+		hljs.safeMode = function() {
+			SAFE_MODE = true;
+		};
+		hljs.versionString = version;
+		hljs.regex = {
+			concat,
+			lookahead,
+			either,
+			optional,
+			anyNumberOfTimes
+		};
+		for (const key in MODES) if (typeof MODES[key] === "object") deepFreeze(MODES[key]);
+		Object.assign(hljs, MODES);
+		return hljs;
+	};
+	var highlight = HLJS({});
+	highlight.newInstance = () => HLJS({});
+	module.exports = highlight;
+	highlight.HighlightJS = highlight;
+	highlight.default = highlight;
+})))())).default;
+//#endregion
+//#region ../../node_modules/.pnpm/lowlight@3.3.0/node_modules/lowlight/lib/index.js
+/**
+* @import {ElementContent, Element, RootData, Root} from 'hast'
+* @import {Emitter, HLJSOptions as HljsOptions, HighlightResult, LanguageFn} from 'highlight.js'
+*/
+/**
+* @typedef {Object} ExtraOptions
+*   Extra fields.
+* @property {ReadonlyArray<string> | null | undefined} [subset]
+*   List of allowed languages (default: all registered languages).
+*
+* @typedef Options
+*   Configuration for `highlight`.
+* @property {string | null | undefined} [prefix='hljs-']
+*   Class prefix (default: `'hljs-'`).
+*
+* @typedef {Options & ExtraOptions} AutoOptions
+*   Configuration for `highlightAuto`.
+*/
+/** @type {AutoOptions} */
+var emptyOptions$1 = {};
+var defaultPrefix = "hljs-";
+/**
+* Create a `lowlight` instance.
+*
+* @param {Readonly<Record<string, LanguageFn>> | null | undefined} [grammars]
+*   Grammars to add (optional).
+* @returns
+*   Lowlight.
+*/
+function createLowlight(grammars) {
+	const high = core_default.newInstance();
+	if (grammars) register(grammars);
+	return {
+		highlight,
+		highlightAuto,
+		listLanguages,
+		register,
+		registerAlias,
+		registered
+	};
+	/**
+	* Highlight `value` (code) as `language` (name).
+	*
+	* @example
+	*   ```js
+	*   import {common, createLowlight} from 'lowlight'
+	*
+	*   const lowlight = createLowlight(common)
+	*
+	*   console.log(lowlight.highlight('css', 'em { color: red }'))
+	*   ```
+	*
+	*   Yields:
+	*
+	*   ```js
+	*   {type: 'root', children: [Array], data: {language: 'css', relevance: 3}}
+	*   ```
+	*
+	* @param {string} language
+	*   Programming language name.
+	* @param {string} value
+	*   Code to highlight.
+	* @param {Readonly<Options> | null | undefined} [options={}]
+	*   Configuration (optional).
+	* @returns {Root}
+	*   Tree; with the following `data` fields: `language` (`string`), detected
+	*   programming language name; `relevance` (`number`), how sure lowlight is
+	*   that the given code is in the language.
+	*/
+	function highlight(language, value, options) {
+		const settings = options || emptyOptions$1;
+		const prefix = typeof settings.prefix === "string" ? settings.prefix : defaultPrefix;
+		if (!high.getLanguage(language)) throw new Error("Unknown language: `" + language + "` is not registered");
+		high.configure({
+			__emitter: HastEmitter,
+			classPrefix: prefix
+		});
+		const result = high.highlight(value, {
+			ignoreIllegals: true,
+			language
+		});
+		/* c8 ignore next 5 */
+		if (result.errorRaised) throw new Error("Could not highlight with `Highlight.js`", { cause: result.errorRaised });
+		const root = result._emitter.root;
+		const data = root.data;
+		data.language = result.language;
+		data.relevance = result.relevance;
+		return root;
+	}
+	/**
+	* Highlight `value` (code) and guess its programming language.
+	*
+	* @example
+	*   ```js
+	*   import {common, createLowlight} from 'lowlight'
+	*
+	*   const lowlight = createLowlight(common)
+	*
+	*   console.log(lowlight.highlightAuto('"hello, " + name + "!"'))
+	*   ```
+	*
+	*   Yields:
+	*
+	*   ```js
+	*   {type: 'root', children: [Array], data: {language: 'arduino', relevance: 2}}
+	*   ```
+	*
+	* @param {string} value
+	*   Code to highlight.
+	* @param {Readonly<AutoOptions> | null | undefined} [options={}]
+	*   Configuration (optional).
+	* @returns {Root}
+	*   Tree; with the following `data` fields: `language` (`string`), detected
+	*   programming language name; `relevance` (`number`), how sure lowlight is
+	*   that the given code is in the language.
+	*/
+	function highlightAuto(value, options) {
+		const subset = (options || emptyOptions$1).subset || listLanguages();
+		let index = -1;
+		let relevance = 0;
+		/** @type {Root | undefined} */
+		let result;
+		while (++index < subset.length) {
+			const name = subset[index];
+			if (!high.getLanguage(name)) continue;
+			const current = highlight(name, value, options);
+			if (current.data && current.data.relevance !== void 0 && current.data.relevance > relevance) {
+				relevance = current.data.relevance;
+				result = current;
+			}
+		}
+		return result || {
+			type: "root",
+			children: [],
+			data: {
+				language: void 0,
+				relevance
+			}
+		};
+	}
+	/**
+	* List registered languages.
+	*
+	* @example
+	*   ```js
+	*   import {createLowlight} from 'lowlight'
+	*   import markdown from 'highlight.js/lib/languages/markdown'
+	*
+	*   const lowlight = createLowlight()
+	*
+	*   console.log(lowlight.listLanguages()) // => []
+	*
+	*   lowlight.register({markdown})
+	*
+	*   console.log(lowlight.listLanguages()) // => ['markdown']
+	*   ```
+	*
+	* @returns {Array<string>}
+	*   Names of registered language.
+	*/
+	function listLanguages() {
+		return high.listLanguages();
+	}
+	/**
+	* Register languages.
+	*
+	* @example
+	*   ```js
+	*   import {createLowlight} from 'lowlight'
+	*   import xml from 'highlight.js/lib/languages/xml'
+	*
+	*   const lowlight = createLowlight()
+	*
+	*   lowlight.register({xml})
+	*
+	*   // Note: `html` is an alias for `xml`.
+	*   console.log(lowlight.highlight('html', '<em>Emphasis</em>'))
+	*   ```
+	*
+	*   Yields:
+	*
+	*   ```js
+	*   {type: 'root', children: [Array], data: {language: 'html', relevance: 2}}
+	*   ```
+	*
+	* @overload
+	* @param {Readonly<Record<string, LanguageFn>>} grammars
+	* @returns {undefined}
+	*
+	* @overload
+	* @param {string} name
+	* @param {LanguageFn} grammar
+	* @returns {undefined}
+	*
+	* @param {Readonly<Record<string, LanguageFn>> | string} grammarsOrName
+	*   Grammars or programming language name.
+	* @param {LanguageFn | undefined} [grammar]
+	*   Grammar, if with name.
+	* @returns {undefined}
+	*   Nothing.
+	*/
+	function register(grammarsOrName, grammar) {
+		if (typeof grammarsOrName === "string") high.registerLanguage(grammarsOrName, grammar);
+		else {
+			/** @type {string} */
+			let name;
+			for (name in grammarsOrName) if (Object.hasOwn(grammarsOrName, name)) high.registerLanguage(name, grammarsOrName[name]);
+		}
+	}
+	/**
+	* Register aliases.
+	*
+	* @example
+	*   ```js
+	*   import {createLowlight} from 'lowlight'
+	*   import markdown from 'highlight.js/lib/languages/markdown'
+	*
+	*   const lowlight = createLowlight()
+	*
+	*   lowlight.register({markdown})
+	*
+	*   // lowlight.highlight('mdown', '<em>Emphasis</em>')
+	*   // ^ would throw: Error: Unknown language: `mdown` is not registered
+	*
+	*   lowlight.registerAlias({markdown: ['mdown', 'mkdn', 'mdwn', 'ron']})
+	*   lowlight.highlight('mdown', '<em>Emphasis</em>')
+	*   // ^ Works!
+	*   ```
+	*
+	* @overload
+	* @param {Readonly<Record<string, ReadonlyArray<string> | string>>} aliases
+	* @returns {undefined}
+	*
+	* @overload
+	* @param {string} language
+	* @param {ReadonlyArray<string> | string} alias
+	* @returns {undefined}
+	*
+	* @param {Readonly<Record<string, ReadonlyArray<string> | string>> | string} aliasesOrName
+	*   Map of programming language names to one or more aliases, or programming
+	*   language name.
+	* @param {ReadonlyArray<string> | string | undefined} [alias]
+	*   One or more aliases for the programming language, if with `name`.
+	* @returns {undefined}
+	*   Nothing.
+	*/
+	function registerAlias(aliasesOrName, alias) {
+		if (typeof aliasesOrName === "string") high.registerAliases(typeof alias === "string" ? alias : [...alias], { languageName: aliasesOrName });
+		else {
+			/** @type {string} */
+			let key;
+			for (key in aliasesOrName) if (Object.hasOwn(aliasesOrName, key)) {
+				const aliases = aliasesOrName[key];
+				high.registerAliases(typeof aliases === "string" ? aliases : [...aliases], { languageName: key });
+			}
+		}
+	}
+	/**
+	* Check whether an alias or name is registered.
+	*
+	* @example
+	*   ```js
+	*   import {createLowlight} from 'lowlight'
+	*   import javascript from 'highlight.js/lib/languages/javascript'
+	*
+	*   const lowlight = createLowlight({javascript})
+	*
+	*   console.log(lowlight.registered('funkyscript')) // => `false`
+	*
+	*   lowlight.registerAlias({javascript: 'funkyscript'})
+	*   console.log(lowlight.registered('funkyscript')) // => `true`
+	*   ```
+	*
+	* @param {string} aliasOrName
+	*   Name of a language or alias for one.
+	* @returns {boolean}
+	*   Whether `aliasOrName` is registered.
+	*/
+	function registered(aliasOrName) {
+		return Boolean(high.getLanguage(aliasOrName));
+	}
+}
+/** @type {Emitter} */
+var HastEmitter = class {
+	/**
+	* @param {Readonly<HljsOptions>} options
+	*   Configuration.
+	* @returns
+	*   Instance.
+	*/
+	constructor(options) {
+		/** @type {HljsOptions} */
+		this.options = options;
+		/** @type {Root} */
+		this.root = {
+			type: "root",
+			children: [],
+			data: {
+				language: void 0,
+				relevance: 0
+			}
+		};
+		/** @type {[Root, ...Array<Element>]} */
+		this.stack = [this.root];
+	}
+	/**
+	* @param {string} value
+	*   Text to add.
+	* @returns {undefined}
+	*   Nothing.
+	*
+	*/
+	addText(value) {
+		if (value === "") return;
+		const current = this.stack[this.stack.length - 1];
+		const tail = current.children[current.children.length - 1];
+		if (tail && tail.type === "text") tail.value += value;
+		else current.children.push({
+			type: "text",
+			value
+		});
+	}
+	/**
+	*
+	* @param {unknown} rawName
+	*   Name to add.
+	* @returns {undefined}
+	*   Nothing.
+	*/
+	startScope(rawName) {
+		this.openNode(String(rawName));
+	}
+	/**
+	* @returns {undefined}
+	*   Nothing.
+	*/
+	endScope() {
+		this.closeNode();
+	}
+	/**
+	* @param {HastEmitter} other
+	*   Other emitter.
+	* @param {string} name
+	*   Name of the sublanguage.
+	* @returns {undefined}
+	*   Nothing.
+	*/
+	__addSublanguage(other, name) {
+		const current = this.stack[this.stack.length - 1];
+		const results = other.root.children;
+		if (name) current.children.push({
+			type: "element",
+			tagName: "span",
+			properties: { className: [name] },
+			children: results
+		});
+		else current.children.push(...results);
+	}
+	/**
+	* @param {string} name
+	*   Name to add.
+	* @returns {undefined}
+	*   Nothing.
+	*/
+	openNode(name) {
+		const self = this;
+		const className = name.split(".").map(function(d, i) {
+			return i ? d + "_".repeat(i) : self.options.classPrefix + d;
+		});
+		const current = this.stack[this.stack.length - 1];
+		/** @type {Element} */
+		const child = {
+			type: "element",
+			tagName: "span",
+			properties: { className },
+			children: []
+		};
+		current.children.push(child);
+		this.stack.push(child);
+	}
+	/**
+	* @returns {undefined}
+	*   Nothing.
+	*/
+	closeNode() {
+		this.stack.pop();
+	}
+	/**
+	* @returns {undefined}
+	*   Nothing.
+	*/
+	finalize() {}
+	/**
+	* @returns {string}
+	*   Nothing.
+	*/
+	toHTML() {
+		return "";
+	}
+};
+//#endregion
+//#region src/rehype-highlight/rehype-highlight.ts
+var emptyOptions = {};
+/**
+* Lowlight syntax highlighting plugin for rehype pipelines
+*
+* Derived from: @url https://github.com/rehypejs/rehype-highlight/blob/main/lib/index.js
+*/
+function rehypeHighlight(options) {
+	const settings = options || emptyOptions;
+	const aliases = settings.aliases;
+	const detect = options?.detect ?? false;
+	const languages = settings.languages;
+	const plainText = settings.plainText;
+	const prefix = settings.prefix;
+	const subset = settings.subset;
+	let name = "hljs";
+	const lowlight = options?.lowlight ?? createLowlight(languages);
+	if (aliases) lowlight.registerAlias(aliases);
+	if (prefix) {
+		const pos = prefix.indexOf("-");
+		name = pos > -1 ? prefix.slice(0, pos) : prefix;
+	}
+	/** Transform.*/
+	return (tree, file) => {
+		visit(tree, "element", (node, _, parent) => {
+			if (node.tagName !== "code" || !parent || parent.type !== "element" || parent.tagName !== "pre") return;
+			const lang = language(node);
+			if (lang === "no-highlight" || !lang && !detect || lang && plainText?.includes(lang)) return;
+			if (!Array.isArray(node.properties.className)) node.properties.className = [];
+			if (!node.properties.className.includes(name)) node.properties.className.unshift(name);
+			let result;
+			try {
+				result = lang ? lowlight.highlight(lang, toText(parent), { prefix }) : lowlight.highlightAuto(toText(parent), {
+					prefix,
+					subset
+				});
+			} catch (error) {
+				const cause = error;
+				if (lang && /Unknown language/.test(cause.message)) {
+					file.message(`Cannot highlight as \`${lang}\`, it's not registered`, {
+						ancestors: [parent, node],
+						cause,
+						place: node.position,
+						ruleId: "missing-language",
+						source: "rehype-highlight"
+					});
+					/* c8 ignore next 5 -- throw arbitrary hljs errors */
+					return;
+				}
+				throw cause;
+			}
+			if (!lang && result.data?.language) node.properties.className.push("language-" + result.data.language);
+			if (result.children.length > 0) node.children = result.children;
+		});
+	};
+}
+/** Get the programming language of `node` or an empty string */
+function language(node) {
+	const list = node.properties.className;
+	if (!Array.isArray(list)) return "";
+	const name = list.reduce((result, _item) => {
+		if (result) return result;
+		const item = String(_item);
+		if (item === "no-highlight" || item === "nohighlight") return "no-highlight";
+		if (item.slice(0, 5) === "lang-") return item.slice(5);
+		if (item.slice(0, 9) === "language-") return item.slice(9);
+		return result;
+	}, "");
+	return lowlightLanguageMappings[name || ""] || name;
+}
+//#endregion
+export { ok as a, __toESM as c, lowlightLanguageMappings as i, convertElement as n, __commonJSMin as o, isElement as r, __exportAll as s, rehypeHighlight as t };
+
+//# sourceMappingURL=rehype-highlight.js.map