@pubinfo/devtools 2.1.10 → 2.1.12

package/dist/client/assets/{core-D6JqxgYq.js → core-CrqZ8qrs.js}

@@ -1,3 +1,4 @@
+//#region \0rolldown/runtime.js
 var __defProp = Object.defineProperty;
 var __exportAll = (all, no_symbols) => {
 	let target = {};
@@ -8,12 +9,16 @@ var __exportAll = (all, no_symbols) => {
 	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
 	return target;
 };
+//#endregion
+//#region ../../node_modules/.pnpm/@shikijs+types@3.22.0/node_modules/@shikijs/types/dist/index.mjs
 var ShikiError = class extends Error {
 	constructor(message) {
 		super(message);
 		this.name = "ShikiError";
 	}
 };
+//#endregion
+//#region ../../node_modules/.pnpm/@shikijs+vscode-textmate@10.0.2/node_modules/@shikijs/vscode-textmate/dist/index.js
 function clone(something) {
 	return doClone(something);
 }
@@ -487,6 +492,10 @@ var EncodedTokenMetadata = class _EncodedTokenMetadata {
 	static getBackground(encodedTokenAttributes) {
 		return (encodedTokenAttributes & 4278190080) >>> 24;
 	}
+	/**
+	* Updates the fields in `metadata`.
+	* A value of `0`, `NotSet` or `null` indicates that the corresponding field should be left as is.
+	*/
 	static set(encodedTokenAttributes, languageId, tokenType, containsBalancedBrackets, fontStyle, foreground, background) {
 		let _languageId = _EncodedTokenMetadata.getLanguageId(encodedTokenAttributes);
 		let _tokenType = _EncodedTokenMetadata.getTokenType(encodedTokenAttributes);
@@ -1346,6 +1355,10 @@ var BasicScopeAttributesProvider = class _BasicScopeAttributesProvider {
 	_getBasicScopeAttributes = new CachedFn((scopeName) => {
 		return new BasicScopeAttributes(this._scopeToLanguage(scopeName), this._toStandardTokenType(scopeName));
 	});
+	/**
+	* Given a produced TM scope, return the language that token describes or null if unknown.
+	* e.g. source.html => html, source.css.embedded.html => css, punctuation.definition.tag.html => null
+	*/
 	_scopeToLanguage(scope) {
 		return this._embeddedLanguagesMatcher.match(scope) || 0;
 	}
@@ -1843,6 +1856,14 @@ function initGrammar(grammar, base) {
 	return grammar;
 }
 var AttributedScopeStack = class _AttributedScopeStack {
+	/**
+	* Invariant:
+	* ```
+	* if (parent && !scopePath.extends(parent.scopePath)) {
+	* 	throw new Error();
+	* }
+	* ```
+	*/
 	constructor(parent, scopePath, tokenAttributes) {
 		this.parent = parent;
 		this.scopePath = scopePath;
@@ -1927,6 +1948,17 @@ var AttributedScopeStack = class _AttributedScopeStack {
 	}
 };
 var StateStackImpl = class _StateStackImpl {
+	/**
+	* Invariant:
+	* ```
+	* if (contentNameScopesList !== nameScopesList && contentNameScopesList?.parent !== nameScopesList) {
+	* 	throw new Error();
+	* }
+	* if (this.parent && !nameScopesList.extends(this.parent.contentNameScopesList)) {
+	* 	throw new Error();
+	* }
+	* ```
+	*/
 	constructor(parent, ruleId, enterPos, anchorPos, beginRuleCapturedEOL, endRule, nameScopesList, contentNameScopesList) {
 		this.parent = parent;
 		this.ruleId = ruleId;
@@ -1940,8 +1972,21 @@ var StateStackImpl = class _StateStackImpl {
 	}
 	_stackElementBrand = void 0;
 	static NULL = new _StateStackImpl(null, 0, 0, 0, false, null, null, null);
+	/**
+	* The position on the current line where this state was pushed.
+	* This is relevant only while tokenizing a line, to detect endless loops.
+	* Its value is meaningless across lines.
+	*/
 	_enterPos;
+	/**
+	* The captured anchor position when this stack element was pushed.
+	* This is relevant only while tokenizing a line, to restore the anchor position when popping.
+	* Its value is meaningless across lines.
+	*/
 	_anchorPos;
+	/**
+	* The depth of the stack.
+	*/
 	depth;
 	equals(other) {
 		if (other === null) return false;
@@ -1952,6 +1997,9 @@ var StateStackImpl = class _StateStackImpl {
 		if (!this._structuralEquals(a, b)) return false;
 		return AttributedScopeStack.equals(a.contentNameScopesList, b.contentNameScopesList);
 	}
+	/**
+	* A structural equals check. Does not take into account `scopes`.
+	*/
 	static _structuralEquals(a, b) {
 		do {
 			if (a === b) return true;
@@ -2071,8 +2119,17 @@ var LineTokens = class {
 		this._lastTokenEndIndex = 0;
 	}
 	_emitBinaryTokens;
+	/**
+	* defined only if `false`.
+	*/
 	_lineText;
+	/**
+	* used only if `_emitBinaryTokens` is false.
+	*/
 	_tokens;
+	/**
+	* used only if `_emitBinaryTokens` is true.
+	*/
 	_binaryTokens;
 	_lastTokenEndIndex;
 	_tokenTypeOverrides;
@@ -2150,22 +2207,40 @@ var SyncRegistry = class {
 	getColorMap() {
 		return this._theme.getColorMap();
 	}
+	/**
+	* Add `grammar` to registry and return a list of referenced scope names
+	*/
 	addGrammar(grammar, injectionScopeNames) {
 		this._rawGrammars.set(grammar.scopeName, grammar);
 		if (injectionScopeNames) this._injectionGrammars.set(grammar.scopeName, injectionScopeNames);
 	}
+	/**
+	* Lookup a raw grammar.
+	*/
 	lookup(scopeName) {
 		return this._rawGrammars.get(scopeName);
 	}
+	/**
+	* Returns the injections for the given grammar
+	*/
 	injections(targetScope) {
 		return this._injectionGrammars.get(targetScope);
 	}
+	/**
+	* Get the default theme settings
+	*/
 	getDefaults() {
 		return this._theme.getDefaults();
 	}
+	/**
+	* Match a scope in the theme.
+	*/
 	themeMatch(scopePath) {
 		return this._theme.match(scopePath);
 	}
+	/**
+	* Lookup a grammar.
+	*/
 	grammarForScopeName(scopeName, initialLanguage, embeddedLanguages, tokenTypes, balancedBracketSelectors) {
 		if (!this._grammars.has(scopeName)) {
 			let rawGrammar = this._rawGrammars.get(scopeName);
@@ -2187,18 +2262,35 @@ var Registry$1 = class {
 	dispose() {
 		this._syncRegistry.dispose();
 	}
+	/**
+	* Change the theme. Once called, no previous `ruleStack` should be used anymore.
+	*/
 	setTheme(theme, colorMap) {
 		this._syncRegistry.setTheme(Theme.createFromRawTheme(theme, colorMap));
 	}
+	/**
+	* Returns a lookup array for color ids.
+	*/
 	getColorMap() {
 		return this._syncRegistry.getColorMap();
 	}
+	/**
+	* Load the grammar for `scopeName` and all referenced included grammars asynchronously.
+	* Please do not use language id 0.
+	*/
 	loadGrammarWithEmbeddedLanguages(initialScopeName, initialLanguage, embeddedLanguages) {
 		return this.loadGrammarWithConfiguration(initialScopeName, initialLanguage, { embeddedLanguages });
 	}
+	/**
+	* Load the grammar for `scopeName` and all referenced included grammars asynchronously.
+	* Please do not use language id 0.
+	*/
 	loadGrammarWithConfiguration(initialScopeName, initialLanguage, configuration) {
 		return this._loadGrammar(initialScopeName, initialLanguage, configuration.embeddedLanguages, configuration.tokenTypes, new BalancedBracketSelectors(configuration.balancedBracketSelectors || [], configuration.unbalancedBracketSelectors || []));
 	}
+	/**
+	* Load the grammar for `scopeName` and all referenced included grammars asynchronously.
+	*/
 	loadGrammar(initialScopeName) {
 		return this._loadGrammar(initialScopeName, 0, null, null, null);
 	}
@@ -2223,16 +2315,29 @@ var Registry$1 = class {
 			this._syncRegistry.addGrammar(grammar, injections);
 		}
 	}
+	/**
+	* Adds a rawGrammar.
+	*/
 	addGrammar(rawGrammar, injections = [], initialLanguage = 0, embeddedLanguages = null) {
 		this._syncRegistry.addGrammar(rawGrammar, injections);
 		return this._grammarForScopeName(rawGrammar.scopeName, initialLanguage, embeddedLanguages);
 	}
+	/**
+	* Get the grammar for `scopeName`. The grammar must first be created via `loadGrammar` or `addGrammar`.
+	*/
 	_grammarForScopeName(scopeName, initialLanguage = 0, embeddedLanguages = null, tokenTypes = null, balancedBracketSelectors = null) {
 		return this._syncRegistry.grammarForScopeName(scopeName, initialLanguage, embeddedLanguages, tokenTypes, balancedBracketSelectors);
 	}
 };
 var INITIAL = StateStackImpl.NULL;
-const htmlVoidElements = [
+//#endregion
+//#region ../../node_modules/.pnpm/html-void-elements@3.0.0/node_modules/html-void-elements/index.js
+/**
+* List of HTML void tag names.
+*
+* @type {Array<string>}
+*/
+var htmlVoidElements = [
 	"area",
 	"base",
 	"basefont",
@@ -2254,7 +2359,23 @@ const htmlVoidElements = [
 	"track",
 	"wbr"
 ];
+//#endregion
+//#region ../../node_modules/.pnpm/property-information@7.1.0/node_modules/property-information/lib/util/schema.js
+/**
+* @import {Schema as SchemaType, Space} from 'property-information'
+*/
+/** @type {SchemaType} */
 var Schema = class {
+	/**
+	* @param {SchemaType['property']} property
+	*   Property.
+	* @param {SchemaType['normal']} normal
+	*   Normal.
+	* @param {Space | undefined} [space]
+	*   Space.
+	* @returns
+	*   Schema.
+	*/
 	constructor(property, normal, space) {
 		this.normal = normal;
 		this.property = property;
@@ -2264,8 +2385,23 @@ var Schema = class {
 Schema.prototype.normal = {};
 Schema.prototype.property = {};
 Schema.prototype.space = void 0;
+//#endregion
+//#region ../../node_modules/.pnpm/property-information@7.1.0/node_modules/property-information/lib/util/merge.js
+/**
+* @import {Info, Space} from 'property-information'
+*/
+/**
+* @param {ReadonlyArray<Schema>} definitions
+*   Definitions.
+* @param {Space | undefined} [space]
+*   Space.
+* @returns {Schema}
+*   Schema.
+*/
 function merge(definitions, space) {
+	/** @type {Record<string, Info>} */
 	const property = {};
+	/** @type {Record<string, string>} */
 	const normal = {};
 	for (const definition of definitions) {
 		Object.assign(property, definition.property);
@@ -2273,10 +2409,35 @@ function merge(definitions, space) {
 	}
 	return new Schema(property, normal, space);
 }
+//#endregion
+//#region ../../node_modules/.pnpm/property-information@7.1.0/node_modules/property-information/lib/normalize.js
+/**
+* Get the cleaned case insensitive form of an attribute or property.
+*
+* @param {string} value
+*   An attribute-like or property-like name.
+* @returns {string}
+*   Value that can be used to look up the properly cased property on a
+*   `Schema`.
+*/
 function normalize(value) {
 	return value.toLowerCase();
 }
+//#endregion
+//#region ../../node_modules/.pnpm/property-information@7.1.0/node_modules/property-information/lib/util/info.js
+/**
+* @import {Info as InfoType} from 'property-information'
+*/
+/** @type {InfoType} */
 var Info = class {
+	/**
+	* @param {string} property
+	*   Property.
+	* @param {string} attribute
+	*   Attribute.
+	* @returns
+	*   Info.
+	*/
 	constructor(property, attribute) {
 		this.attribute = attribute;
 		this.property = property;
@@ -2294,6 +2455,8 @@ Info.prototype.overloadedBoolean = false;
 Info.prototype.property = "";
 Info.prototype.spaceSeparated = false;
 Info.prototype.space = void 0;
+//#endregion
+//#region ../../node_modules/.pnpm/property-information@7.1.0/node_modules/property-information/lib/util/types.js
 var types_exports = /* @__PURE__ */ __exportAll({
 	boolean: () => boolean,
 	booleanish: () => booleanish,
@@ -2304,18 +2467,36 @@ var types_exports = /* @__PURE__ */ __exportAll({
 	spaceSeparated: () => spaceSeparated
 });
 var powers = 0;
-const boolean = increment();
-const booleanish = increment();
-const overloadedBoolean = increment();
-const number = increment();
-const spaceSeparated = increment();
-const commaSeparated = increment();
-const commaOrSpaceSeparated = increment();
+var boolean = increment();
+var booleanish = increment();
+var overloadedBoolean = increment();
+var number = increment();
+var spaceSeparated = increment();
+var commaSeparated = increment();
+var commaOrSpaceSeparated = increment();
 function increment() {
 	return 2 ** ++powers;
 }
+//#endregion
+//#region ../../node_modules/.pnpm/property-information@7.1.0/node_modules/property-information/lib/util/defined-info.js
+/**
+* @import {Space} from 'property-information'
+*/
 var checks = Object.keys(types_exports);
 var DefinedInfo = class extends Info {
+	/**
+	* @constructor
+	* @param {string} property
+	*   Property.
+	* @param {string} attribute
+	*   Attribute.
+	* @param {number | null | undefined} [mask]
+	*   Mask.
+	* @param {Space | undefined} [space]
+	*   Space.
+	* @returns
+	*   Info.
+	*/
 	constructor(property, attribute, mask, space) {
 		let index = -1;
 		super(property, attribute);
@@ -2327,11 +2508,60 @@ var DefinedInfo = class extends Info {
 	}
 };
 DefinedInfo.prototype.defined = true;
+/**
+* @template {keyof DefinedInfo} Key
+*   Key type.
+* @param {DefinedInfo} values
+*   Info.
+* @param {Key} key
+*   Key.
+* @param {DefinedInfo[Key]} value
+*   Value.
+* @returns {undefined}
+*   Nothing.
+*/
 function mark(values, key, value) {
 	if (value) values[key] = value;
 }
+//#endregion
+//#region ../../node_modules/.pnpm/property-information@7.1.0/node_modules/property-information/lib/util/create.js
+/**
+* @import {Info, Space} from 'property-information'
+*/
+/**
+* @typedef Definition
+*   Definition of a schema.
+* @property {Record<string, string> | undefined} [attributes]
+*   Normalzed names to special attribute case.
+* @property {ReadonlyArray<string> | undefined} [mustUseProperty]
+*   Normalized names that must be set as properties.
+* @property {Record<string, number | null>} properties
+*   Property names to their types.
+* @property {Space | undefined} [space]
+*   Space.
+* @property {Transform} transform
+*   Transform a property name.
+*/
+/**
+* @callback Transform
+*   Transform.
+* @param {Record<string, string>} attributes
+*   Attributes.
+* @param {string} property
+*   Property.
+* @returns {string}
+*   Attribute.
+*/
+/**
+* @param {Definition} definition
+*   Definition.
+* @returns {Schema}
+*   Schema.
+*/
 function create(definition) {
+	/** @type {Record<string, Info>} */
 	const properties = {};
+	/** @type {Record<string, string>} */
 	const normals = {};
 	for (const [property, value] of Object.entries(definition.properties)) {
 		const info = new DefinedInfo(property, definition.transform(definition.attributes || {}, property), value, definition.space);
@@ -2342,7 +2572,9 @@ function create(definition) {
 	}
 	return new Schema(properties, normals, definition.space);
 }
-const aria = create({
+//#endregion
+//#region ../../node_modules/.pnpm/property-information@7.1.0/node_modules/property-information/lib/aria.js
+var aria = create({
 	properties: {
 		ariaActiveDescendant: null,
 		ariaAtomic: booleanish,
@@ -2398,13 +2630,35 @@ const aria = create({
 		return property === "role" ? property : "aria-" + property.slice(4).toLowerCase();
 	}
 });
+//#endregion
+//#region ../../node_modules/.pnpm/property-information@7.1.0/node_modules/property-information/lib/util/case-sensitive-transform.js
+/**
+* @param {Record<string, string>} attributes
+*   Attributes.
+* @param {string} attribute
+*   Attribute.
+* @returns {string}
+*   Transformed attribute.
+*/
 function caseSensitiveTransform(attributes, attribute) {
 	return attribute in attributes ? attributes[attribute] : attribute;
 }
+//#endregion
+//#region ../../node_modules/.pnpm/property-information@7.1.0/node_modules/property-information/lib/util/case-insensitive-transform.js
+/**
+* @param {Record<string, string>} attributes
+*   Attributes.
+* @param {string} property
+*   Property.
+* @returns {string}
+*   Transformed property.
+*/
 function caseInsensitiveTransform(attributes, property) {
 	return caseSensitiveTransform(attributes, property.toLowerCase());
 }
-const html$3 = create({
+//#endregion
+//#region ../../node_modules/.pnpm/property-information@7.1.0/node_modules/property-information/lib/html.js
+var html$3 = create({
 	attributes: {
 		acceptcharset: "accept-charset",
 		classname: "class",
@@ -2714,7 +2968,9 @@ const html$3 = create({
 	space: "html",
 	transform: caseInsensitiveTransform
 });
-const svg$1 = create({
+//#endregion
+//#region ../../node_modules/.pnpm/property-information@7.1.0/node_modules/property-information/lib/svg.js
+var svg$1 = create({
 	attributes: {
 		accentHeight: "accent-height",
 		alignmentBaseline: "alignment-baseline",
@@ -3270,7 +3526,9 @@ const svg$1 = create({
 	space: "svg",
 	transform: caseSensitiveTransform
 });
-const xlink = create({
+//#endregion
+//#region ../../node_modules/.pnpm/property-information@7.1.0/node_modules/property-information/lib/xlink.js
+var xlink = create({
 	properties: {
 		xLinkActuate: null,
 		xLinkArcRole: null,
@@ -3285,7 +3543,9 @@ const xlink = create({
 		return "xlink:" + property.slice(5).toLowerCase();
 	}
 });
-const xmlns = create({
+//#endregion
+//#region ../../node_modules/.pnpm/property-information@7.1.0/node_modules/property-information/lib/xmlns.js
+var xmlns = create({
 	attributes: { xmlnsxlink: "xmlns:xlink" },
 	properties: {
 		xmlnsXLink: null,
@@ -3294,7 +3554,9 @@ const xmlns = create({
 	space: "xmlns",
 	transform: caseInsensitiveTransform
 });
-const xml = create({
+//#endregion
+//#region ../../node_modules/.pnpm/property-information@7.1.0/node_modules/property-information/lib/xml.js
+var xml = create({
 	properties: {
 		xmlBase: null,
 		xmlLang: null,
@@ -3305,9 +3567,44 @@ const xml = create({
 		return "xml:" + property.slice(3).toLowerCase();
 	}
 });
+//#endregion
+//#region ../../node_modules/.pnpm/property-information@7.1.0/node_modules/property-information/lib/find.js
+/**
+* @import {Schema} from 'property-information'
+*/
 var cap = /[A-Z]/g;
 var dash = /-[a-z]/g;
 var valid = /^data[-\w.:]+$/i;
+/**
+* Look up info on a property.
+*
+* In most cases the given `schema` contains info on the property.
+* All standard,
+* most legacy,
+* and some non-standard properties are supported.
+* For these cases,
+* the returned `Info` has hints about the value of the property.
+*
+* `name` can also be a valid data attribute or property,
+* in which case an `Info` object with the correctly cased `attribute` and
+* `property` is returned.
+*
+* `name` can be an unknown attribute,
+* in which case an `Info` object with `attribute` and `property` set to the
+* given name is returned.
+* It is not recommended to provide unsupported legacy or recently specced
+* properties.
+*
+*
+* @param {Schema} schema
+*   Schema;
+*   either the `html` or `svg` export.
+* @param {string} value
+*   An attribute-like or property-like name;
+*   it will be passed through `normalize` to hopefully find the correct info.
+* @returns {Info}
+*   Info.
+*/
 function find(schema, value) {
 	const normal = normalize(value);
 	let property = value;
@@ -3329,30 +3626,132 @@ function find(schema, value) {
 	}
 	return new Type(property, value);
 }
+/**
+* @param {string} $0
+*   Value.
+* @returns {string}
+*   Kebab.
+*/
 function kebab($0) {
 	return "-" + $0.toLowerCase();
 }
+/**
+* @param {string} $0
+*   Value.
+* @returns {string}
+*   Camel.
+*/
 function camelcase($0) {
 	return $0.charAt(1).toUpperCase();
 }
-const html$2 = merge([
+//#endregion
+//#region ../../node_modules/.pnpm/property-information@7.1.0/node_modules/property-information/index.js
+var html$2 = merge([
 	aria,
 	html$3,
 	xlink,
 	xmlns,
 	xml
 ], "html");
-const svg = merge([
+var svg = merge([
 	aria,
 	svg$1,
 	xlink,
 	xmlns,
 	xml
 ], "svg");
+//#endregion
+//#region ../../node_modules/.pnpm/zwitch@2.0.4/node_modules/zwitch/index.js
+/**
+* @callback Handler
+*   Handle a value, with a certain ID field set to a certain value.
+*   The ID field is passed to `zwitch`, and it’s value is this function’s
+*   place on the `handlers` record.
+* @param {...any} parameters
+*   Arbitrary parameters passed to the zwitch.
+*   The first will be an object with a certain ID field set to a certain value.
+* @returns {any}
+*   Anything!
+*/
+/**
+* @callback UnknownHandler
+*   Handle values that do have a certain ID field, but it’s set to a value
+*   that is not listed in the `handlers` record.
+* @param {unknown} value
+*   An object with a certain ID field set to an unknown value.
+* @param {...any} rest
+*   Arbitrary parameters passed to the zwitch.
+* @returns {any}
+*   Anything!
+*/
+/**
+* @callback InvalidHandler
+*   Handle values that do not have a certain ID field.
+* @param {unknown} value
+*   Any unknown value.
+* @param {...any} rest
+*   Arbitrary parameters passed to the zwitch.
+* @returns {void|null|undefined|never}
+*   This should crash or return nothing.
+*/
+/**
+* @template {InvalidHandler} [Invalid=InvalidHandler]
+* @template {UnknownHandler} [Unknown=UnknownHandler]
+* @template {Record<string, Handler>} [Handlers=Record<string, Handler>]
+* @typedef Options
+*   Configuration (required).
+* @property {Invalid} [invalid]
+*   Handler to use for invalid values.
+* @property {Unknown} [unknown]
+*   Handler to use for unknown values.
+* @property {Handlers} [handlers]
+*   Handlers to use.
+*/
 var own$2 = {}.hasOwnProperty;
+/**
+* Handle values based on a field.
+*
+* @template {InvalidHandler} [Invalid=InvalidHandler]
+* @template {UnknownHandler} [Unknown=UnknownHandler]
+* @template {Record<string, Handler>} [Handlers=Record<string, Handler>]
+* @param {string} key
+*   Field to switch on.
+* @param {Options<Invalid, Unknown, Handlers>} [options]
+*   Configuration (required).
+* @returns {{unknown: Unknown, invalid: Invalid, handlers: Handlers, (...parameters: Parameters<Handlers[keyof Handlers]>): ReturnType<Handlers[keyof Handlers]>, (...parameters: Parameters<Unknown>): ReturnType<Unknown>}}
+*/
 function zwitch(key, options) {
 	const settings = options || {};
+	/**
+	* Handle one value.
+	*
+	* Based on the bound `key`, a respective handler will be called.
+	* If `value` is not an object, or doesn’t have a `key` property, the special
+	* “invalid” handler will be called.
+	* If `value` has an unknown `key`, the special “unknown” handler will be
+	* called.
+	*
+	* All arguments, and the context object, are passed through to the handler,
+	* and it’s result is returned.
+	*
+	* @this {unknown}
+	*   Any context object.
+	* @param {unknown} [value]
+	*   Any value.
+	* @param {...unknown} parameters
+	*   Arbitrary parameters passed to the zwitch.
+	* @property {Handler} invalid
+	*   Handle for values that do not have a certain ID field.
+	* @property {Handler} unknown
+	*   Handle values that do have a certain ID field, but it’s set to a value
+	*   that is not listed in the `handlers` record.
+	* @property {Handlers} handlers
+	*   Record of handlers.
+	* @returns {unknown}
+	*   Anything.
+	*/
 	function one(value, ...parameters) {
+		/** @type {Handler|undefined} */
 		let fn = one.invalid;
 		const handlers = one.handlers;
 		if (value && own$2.call(value, key)) {
@@ -3366,22 +3765,64 @@ function zwitch(key, options) {
 	one.unknown = settings.unknown;
 	return one;
 }
+//#endregion
+//#region ../../node_modules/.pnpm/stringify-entities@4.0.4/node_modules/stringify-entities/lib/core.js
+/**
+* @typedef CoreOptions
+* @property {ReadonlyArray<string>} [subset=[]]
+*   Whether to only escape the given subset of characters.
+* @property {boolean} [escapeOnly=false]
+*   Whether to only escape possibly dangerous characters.
+*   Those characters are `"`, `&`, `'`, `<`, `>`, and `` ` ``.
+*
+* @typedef FormatOptions
+* @property {(code: number, next: number, options: CoreWithFormatOptions) => string} format
+*   Format strategy.
+*
+* @typedef {CoreOptions & FormatOptions & import('./util/format-smart.js').FormatSmartOptions} CoreWithFormatOptions
+*/
 var defaultSubsetRegex = /["&'<>`]/g;
 var surrogatePairsRegex = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
 var controlCharactersRegex = /[\x01-\t\v\f\x0E-\x1F\x7F\x81\x8D\x8F\x90\x9D\xA0-\uFFFF]/g;
 var regexEscapeRegex = /[|\\{}()[\]^$+*?.]/g;
+/** @type {WeakMap<ReadonlyArray<string>, RegExp>} */
 var subsetToRegexCache = /* @__PURE__ */ new WeakMap();
+/**
+* Encode certain characters in `value`.
+*
+* @param {string} value
+* @param {CoreWithFormatOptions} options
+* @returns {string}
+*/
 function core(value, options) {
 	value = value.replace(options.subset ? charactersToExpressionCached(options.subset) : defaultSubsetRegex, basic);
 	if (options.subset || options.escapeOnly) return value;
 	return value.replace(surrogatePairsRegex, surrogate).replace(controlCharactersRegex, basic);
+	/**
+	* @param {string} pair
+	* @param {number} index
+	* @param {string} all
+	*/
 	function surrogate(pair, index, all) {
 		return options.format((pair.charCodeAt(0) - 55296) * 1024 + pair.charCodeAt(1) - 56320 + 65536, all.charCodeAt(index + 2), options);
 	}
+	/**
+	* @param {string} character
+	* @param {number} index
+	* @param {string} all
+	*/
 	function basic(character, index, all) {
 		return options.format(character.charCodeAt(0), all.charCodeAt(index + 1), options);
 	}
 }
+/**
+* A wrapper function that caches the result of `charactersToExpression` with a WeakMap.
+* This can improve performance when tooling calls `charactersToExpression` repeatedly
+* with the same subset.
+*
+* @param {ReadonlyArray<string>} subset
+* @returns {RegExp}
+*/
 function charactersToExpressionCached(subset) {
 	let cached = subsetToRegexCache.get(subset);
 	if (!cached) {
@@ -3390,23 +3831,55 @@ function charactersToExpressionCached(subset) {
 	}
 	return cached;
 }
+/**
+* @param {ReadonlyArray<string>} subset
+* @returns {RegExp}
+*/
 function charactersToExpression(subset) {
+	/** @type {Array<string>} */
 	const groups = [];
 	let index = -1;
 	while (++index < subset.length) groups.push(subset[index].replace(regexEscapeRegex, "\\$&"));
 	return new RegExp("(?:" + groups.join("|") + ")", "g");
 }
+//#endregion
+//#region ../../node_modules/.pnpm/stringify-entities@4.0.4/node_modules/stringify-entities/lib/util/to-hexadecimal.js
 var hexadecimalRegex = /[\dA-Fa-f]/;
+/**
+* Configurable ways to encode characters as hexadecimal references.
+*
+* @param {number} code
+* @param {number} next
+* @param {boolean|undefined} omit
+* @returns {string}
+*/
 function toHexadecimal(code, next, omit) {
 	const value = "&#x" + code.toString(16).toUpperCase();
 	return omit && next && !hexadecimalRegex.test(String.fromCharCode(next)) ? value : value + ";";
 }
+//#endregion
+//#region ../../node_modules/.pnpm/stringify-entities@4.0.4/node_modules/stringify-entities/lib/util/to-decimal.js
 var decimalRegex = /\d/;
+/**
+* Configurable ways to encode characters as decimal references.
+*
+* @param {number} code
+* @param {number} next
+* @param {boolean|undefined} omit
+* @returns {string}
+*/
 function toDecimal(code, next, omit) {
 	const value = "&#" + String(code);
 	return omit && next && !decimalRegex.test(String.fromCharCode(next)) ? value : value + ";";
 }
-const characterEntitiesLegacy = [
+//#endregion
+//#region ../../node_modules/.pnpm/character-entities-legacy@3.0.0/node_modules/character-entities-legacy/index.js
+/**
+* List of legacy HTML named character references that don’t need a trailing semicolon.
+*
+* @type {Array<string>}
+*/
+var characterEntitiesLegacy = [
 	"AElig",
 	"AMP",
 	"Aacute",
@@ -3514,7 +3987,14 @@ const characterEntitiesLegacy = [
 	"yen",
 	"yuml"
 ];
-const characterEntitiesHtml4 = {
+//#endregion
+//#region ../../node_modules/.pnpm/character-entities-html4@2.1.0/node_modules/character-entities-html4/index.js
+/**
+* Map of named character references from HTML 4.
+*
+* @type {Record<string, string>}
+*/
+var characterEntitiesHtml4 = {
 	nbsp: "\xA0",
 	iexcl: "¡",
 	cent: "¢",
@@ -3768,7 +4248,15 @@ const characterEntitiesHtml4 = {
 	rsaquo: "›",
 	euro: "€"
 };
-const dangerous = [
+//#endregion
+//#region ../../node_modules/.pnpm/stringify-entities@4.0.4/node_modules/stringify-entities/lib/constant/dangerous.js
+/**
+* List of legacy (that don’t need a trailing `;`) named references which could,
+* depending on what follows them, turn into a different meaning
+*
+* @type {Array<string>}
+*/
+var dangerous = [
 	"cent",
 	"copy",
 	"divide",
@@ -3778,11 +4266,28 @@ const dangerous = [
 	"para",
 	"times"
 ];
+//#endregion
+//#region ../../node_modules/.pnpm/stringify-entities@4.0.4/node_modules/stringify-entities/lib/util/to-named.js
 var own$1 = {}.hasOwnProperty;
+/**
+* `characterEntitiesHtml4` but inverted.
+*
+* @type {Record<string, string>}
+*/
 var characters = {};
+/** @type {string} */
 var key;
 for (key in characterEntitiesHtml4) if (own$1.call(characterEntitiesHtml4, key)) characters[characterEntitiesHtml4[key]] = key;
 var notAlphanumericRegex = /[^\dA-Za-z]/;
+/**
+* Configurable ways to encode characters as named references.
+*
+* @param {number} code
+* @param {number} next
+* @param {boolean|undefined} omit
+* @param {boolean|undefined} attribute
+* @returns {string}
+*/
 function toNamed(code, next, omit, attribute) {
 	const character = String.fromCharCode(code);
 	if (own$1.call(characters, character)) {
@@ -3793,8 +4298,35 @@ function toNamed(code, next, omit, attribute) {
 	}
 	return "";
 }
+//#endregion
+//#region ../../node_modules/.pnpm/stringify-entities@4.0.4/node_modules/stringify-entities/lib/util/format-smart.js
+/**
+* @typedef FormatSmartOptions
+* @property {boolean} [useNamedReferences=false]
+*   Prefer named character references (`&amp;`) where possible.
+* @property {boolean} [useShortestReferences=false]
+*   Prefer the shortest possible reference, if that results in less bytes.
+*   **Note**: `useNamedReferences` can be omitted when using `useShortestReferences`.
+* @property {boolean} [omitOptionalSemicolons=false]
+*   Whether to omit semicolons when possible.
+*   **Note**: This creates what HTML calls “parse errors” but is otherwise still valid HTML — don’t use this except when building a minifier.
+*   Omitting semicolons is possible for certain named and numeric references in some cases.
+* @property {boolean} [attribute=false]
+*   Create character references which don’t fail in attributes.
+*   **Note**: `attribute` only applies when operating dangerously with
+*   `omitOptionalSemicolons: true`.
+*/
+/**
+* Configurable ways to encode a character yielding pretty or small results.
+*
+* @param {number} code
+* @param {number} next
+* @param {FormatSmartOptions} options
+* @returns {string}
+*/
 function formatSmart(code, next, options) {
 	let numeric = toHexadecimal(code, next, options.omitOptionalSemicolons);
+	/** @type {string|undefined} */
 	let named;
 	if (options.useNamedReferences || options.useShortestReferences) named = toNamed(code, next, options.omitOptionalSemicolons, options.attribute);
 	if ((options.useShortestReferences || !named) && options.useShortestReferences) {
@@ -3803,21 +4335,92 @@ function formatSmart(code, next, options) {
 	}
 	return named && (!options.useShortestReferences || named.length < numeric.length) ? named : numeric;
 }
+//#endregion
+//#region ../../node_modules/.pnpm/stringify-entities@4.0.4/node_modules/stringify-entities/lib/index.js
+/**
+* @typedef {import('./core.js').CoreOptions & import('./util/format-smart.js').FormatSmartOptions} Options
+* @typedef {import('./core.js').CoreOptions} LightOptions
+*/
+/**
+* Encode special characters in `value`.
+*
+* @param {string} value
+*   Value to encode.
+* @param {Options} [options]
+*   Configuration.
+* @returns {string}
+*   Encoded value.
+*/
 function stringifyEntities(value, options) {
 	return core(value, Object.assign({ format: formatSmart }, options));
 }
+//#endregion
+//#region ../../node_modules/.pnpm/hast-util-to-html@9.0.5/node_modules/hast-util-to-html/lib/handle/comment.js
+/**
+* @import {Comment, Parents} from 'hast'
+* @import {State} from '../index.js'
+*/
 var htmlCommentRegex = /^>|^->|<!--|-->|--!>|<!-$/g;
 var bogusCommentEntitySubset = [">"];
 var commentEntitySubset = ["<", ">"];
+/**
+* Serialize a comment.
+*
+* @param {Comment} node
+*   Node to handle.
+* @param {number | undefined} _1
+*   Index of `node` in `parent.
+* @param {Parents | undefined} _2
+*   Parent of `node`.
+* @param {State} state
+*   Info passed around about the current state.
+* @returns {string}
+*   Serialized node.
+*/
 function comment(node, _1, _2, state) {
 	return state.settings.bogusComments ? "<?" + stringifyEntities(node.value, Object.assign({}, state.settings.characterReferences, { subset: bogusCommentEntitySubset })) + ">" : "<!--" + node.value.replace(htmlCommentRegex, encode) + "-->";
+	/**
+	* @param {string} $0
+	*/
 	function encode($0) {
 		return stringifyEntities($0, Object.assign({}, state.settings.characterReferences, { subset: commentEntitySubset }));
 	}
 }
+//#endregion
+//#region ../../node_modules/.pnpm/hast-util-to-html@9.0.5/node_modules/hast-util-to-html/lib/handle/doctype.js
+/**
+* @import {Doctype, Parents} from 'hast'
+* @import {State} from '../index.js'
+*/
+/**
+* Serialize a doctype.
+*
+* @param {Doctype} _1
+*   Node to handle.
+* @param {number | undefined} _2
+*   Index of `node` in `parent.
+* @param {Parents | undefined} _3
+*   Parent of `node`.
+* @param {State} state
+*   Info passed around about the current state.
+* @returns {string}
+*   Serialized node.
+*/
 function doctype(_1, _2, _3, state) {
 	return "<!" + (state.settings.upperDoctype ? "DOCTYPE" : "doctype") + (state.settings.tightDoctype ? "" : " ") + "html>";
 }
+//#endregion
+//#region ../../node_modules/.pnpm/ccount@2.0.1/node_modules/ccount/index.js
+/**
+* Count how often a character (or substring) is used in a string.
+*
+* @param {string} value
+*   Value to search in.
+* @param {string} character
+*   Character (or substring) to look for.
+* @return {number}
+*   Number of times `character` occurred in `value`.
+*/
 function ccount(value, character) {
 	const source = String(value);
 	if (typeof character !== "string") throw new TypeError("Expected character");
@@ -3829,25 +4432,92 @@ function ccount(value, character) {
 	}
 	return count;
 }
+//#endregion
+//#region ../../node_modules/.pnpm/comma-separated-tokens@2.0.3/node_modules/comma-separated-tokens/index.js
+/**
+* Serialize an array of strings or numbers to comma-separated tokens.
+*
+* @param {Array<string|number>} values
+*   List of tokens.
+* @param {Options} [options]
+*   Configuration for `stringify` (optional).
+* @returns {string}
+*   Comma-separated tokens.
+*/
 function stringify$2(values, options) {
 	const settings = options || {};
 	return (values[values.length - 1] === "" ? [...values, ""] : values).join((settings.padRight ? " " : "") + "," + (settings.padLeft === false ? "" : " ")).trim();
 }
+//#endregion
+//#region ../../node_modules/.pnpm/space-separated-tokens@2.0.2/node_modules/space-separated-tokens/index.js
+/**
+* Serialize an array of strings as space separated-tokens.
+*
+* @param {Array<string|number>} values
+*   List of tokens.
+* @returns {string}
+*   Space-separated tokens.
+*/
 function stringify$1(values) {
 	return values.join(" ").trim();
 }
+//#endregion
+//#region ../../node_modules/.pnpm/hast-util-whitespace@3.0.0/node_modules/hast-util-whitespace/lib/index.js
+/**
+* @typedef {import('hast').Nodes} Nodes
+*/
 var re = /[ \t\n\f\r]/g;
+/**
+* Check if the given value is *inter-element whitespace*.
+*
+* @param {Nodes | string} thing
+*   Thing to check (`Node` or `string`).
+* @returns {boolean}
+*   Whether the `value` is inter-element whitespace (`boolean`): consisting of
+*   zero or more of space, tab (`\t`), line feed (`\n`), carriage return
+*   (`\r`), or form feed (`\f`); if a node is passed it must be a `Text` node,
+*   whose `value` field is checked.
+*/
 function whitespace(thing) {
 	return typeof thing === "object" ? thing.type === "text" ? empty(thing.value) : false : empty(thing);
 }
+/**
+* @param {string} value
+* @returns {boolean}
+*/
 function empty(value) {
 	return value.replace(re, "") === "";
 }
-const siblingAfter = siblings(1);
-const siblingBefore = siblings(-1);
+//#endregion
+//#region ../../node_modules/.pnpm/hast-util-to-html@9.0.5/node_modules/hast-util-to-html/lib/omission/util/siblings.js
+/**
+* @import {Parents, RootContent} from 'hast'
+*/
+var siblingAfter = siblings(1);
+var siblingBefore = siblings(-1);
+/** @type {Array<RootContent>} */
 var emptyChildren$1 = [];
+/**
+* Factory to check siblings in a direction.
+*
+* @param {number} increment
+*/
 function siblings(increment) {
 	return sibling;
+	/**
+	* Find applicable siblings in a direction.
+	*
+	* @template {Parents} Parent
+	*   Parent type.
+	* @param {Parent | undefined} parent
+	*   Parent.
+	* @param {number | undefined} index
+	*   Index of child in `parent`.
+	* @param {boolean | undefined} [includeWhitespace=false]
+	*   Whether to include whitespace (default: `false`).
+	* @returns {Parent extends {children: Array<infer Child>} ? Child | undefined : never}
+	*   Child of parent.
+	*/
 	function sibling(parent, index, includeWhitespace) {
 		const siblings = parent ? parent.children : emptyChildren$1;
 		let offset = (index || 0) + increment;
@@ -3859,14 +4529,51 @@ function siblings(increment) {
 		return next;
 	}
 }
+//#endregion
+//#region ../../node_modules/.pnpm/hast-util-to-html@9.0.5/node_modules/hast-util-to-html/lib/omission/omission.js
+/**
+* @import {Element, Parents} from 'hast'
+*/
+/**
+* @callback OmitHandle
+*   Check if a tag can be omitted.
+* @param {Element} element
+*   Element to check.
+* @param {number | undefined} index
+*   Index of element in parent.
+* @param {Parents | undefined} parent
+*   Parent of element.
+* @returns {boolean}
+*   Whether to omit a tag.
+*
+*/
 var own = {}.hasOwnProperty;
+/**
+* Factory to check if a given node can have a tag omitted.
+*
+* @param {Record<string, OmitHandle>} handlers
+*   Omission handlers, where each key is a tag name, and each value is the
+*   corresponding handler.
+* @returns {OmitHandle}
+*   Whether to omit a tag of an element.
+*/
 function omission(handlers) {
 	return omit;
+	/**
+	* Check if a given node can have a tag omitted.
+	*
+	* @type {OmitHandle}
+	*/
 	function omit(node, index, parent) {
 		return own.call(handlers, node.tagName) && handlers[node.tagName](node, index, parent);
 	}
 }
-const closing = omission({
+//#endregion
+//#region ../../node_modules/.pnpm/hast-util-to-html@9.0.5/node_modules/hast-util-to-html/lib/omission/closing.js
+/**
+* @import {Element, Parents} from 'hast'
+*/
+var closing = omission({
 	body: body$1,
 	caption: headOrColgroupOrCaption,
 	colgroup: headOrColgroupOrCaption,
@@ -3887,77 +4594,279 @@ const closing = omission({
 	thead,
 	tr
 });
+/**
+* Macro for `</head>`, `</colgroup>`, and `</caption>`.
+*
+* @param {Element} _
+*   Element.
+* @param {number | undefined} index
+*   Index of element in parent.
+* @param {Parents | undefined} parent
+*   Parent of element.
+* @returns {boolean}
+*   Whether the closing tag can be omitted.
+*/
 function headOrColgroupOrCaption(_, index, parent) {
 	const next = siblingAfter(parent, index, true);
 	return !next || next.type !== "comment" && !(next.type === "text" && whitespace(next.value.charAt(0)));
 }
+/**
+* Whether to omit `</html>`.
+*
+* @param {Element} _
+*   Element.
+* @param {number | undefined} index
+*   Index of element in parent.
+* @param {Parents | undefined} parent
+*   Parent of element.
+* @returns {boolean}
+*   Whether the closing tag can be omitted.
+*/
 function html$1(_, index, parent) {
 	const next = siblingAfter(parent, index);
 	return !next || next.type !== "comment";
 }
+/**
+* Whether to omit `</body>`.
+*
+* @param {Element} _
+*   Element.
+* @param {number | undefined} index
+*   Index of element in parent.
+* @param {Parents | undefined} parent
+*   Parent of element.
+* @returns {boolean}
+*   Whether the closing tag can be omitted.
+*/
 function body$1(_, index, parent) {
 	const next = siblingAfter(parent, index);
 	return !next || next.type !== "comment";
 }
+/**
+* Whether to omit `</p>`.
+*
+* @param {Element} _
+*   Element.
+* @param {number | undefined} index
+*   Index of element in parent.
+* @param {Parents | undefined} parent
+*   Parent of element.
+* @returns {boolean}
+*   Whether the closing tag can be omitted.
+*/
 function p(_, index, parent) {
 	const next = siblingAfter(parent, index);
 	return next ? next.type === "element" && (next.tagName === "address" || next.tagName === "article" || next.tagName === "aside" || next.tagName === "blockquote" || next.tagName === "details" || next.tagName === "div" || next.tagName === "dl" || next.tagName === "fieldset" || next.tagName === "figcaption" || next.tagName === "figure" || next.tagName === "footer" || next.tagName === "form" || next.tagName === "h1" || next.tagName === "h2" || next.tagName === "h3" || next.tagName === "h4" || next.tagName === "h5" || next.tagName === "h6" || next.tagName === "header" || next.tagName === "hgroup" || next.tagName === "hr" || next.tagName === "main" || next.tagName === "menu" || next.tagName === "nav" || next.tagName === "ol" || next.tagName === "p" || next.tagName === "pre" || next.tagName === "section" || next.tagName === "table" || next.tagName === "ul") : !parent || !(parent.type === "element" && (parent.tagName === "a" || parent.tagName === "audio" || parent.tagName === "del" || parent.tagName === "ins" || parent.tagName === "map" || parent.tagName === "noscript" || parent.tagName === "video"));
 }
+/**
+* Whether to omit `</li>`.
+*
+* @param {Element} _
+*   Element.
+* @param {number | undefined} index
+*   Index of element in parent.
+* @param {Parents | undefined} parent
+*   Parent of element.
+* @returns {boolean}
+*   Whether the closing tag can be omitted.
+*/
 function li(_, index, parent) {
 	const next = siblingAfter(parent, index);
 	return !next || next.type === "element" && next.tagName === "li";
 }
+/**
+* Whether to omit `</dt>`.
+*
+* @param {Element} _
+*   Element.
+* @param {number | undefined} index
+*   Index of element in parent.
+* @param {Parents | undefined} parent
+*   Parent of element.
+* @returns {boolean}
+*   Whether the closing tag can be omitted.
+*/
 function dt(_, index, parent) {
 	const next = siblingAfter(parent, index);
 	return Boolean(next && next.type === "element" && (next.tagName === "dt" || next.tagName === "dd"));
 }
+/**
+* Whether to omit `</dd>`.
+*
+* @param {Element} _
+*   Element.
+* @param {number | undefined} index
+*   Index of element in parent.
+* @param {Parents | undefined} parent
+*   Parent of element.
+* @returns {boolean}
+*   Whether the closing tag can be omitted.
+*/
 function dd(_, index, parent) {
 	const next = siblingAfter(parent, index);
 	return !next || next.type === "element" && (next.tagName === "dt" || next.tagName === "dd");
 }
+/**
+* Whether to omit `</rt>` or `</rp>`.
+*
+* @param {Element} _
+*   Element.
+* @param {number | undefined} index
+*   Index of element in parent.
+* @param {Parents | undefined} parent
+*   Parent of element.
+* @returns {boolean}
+*   Whether the closing tag can be omitted.
+*/
 function rubyElement(_, index, parent) {
 	const next = siblingAfter(parent, index);
 	return !next || next.type === "element" && (next.tagName === "rp" || next.tagName === "rt");
 }
+/**
+* Whether to omit `</optgroup>`.
+*
+* @param {Element} _
+*   Element.
+* @param {number | undefined} index
+*   Index of element in parent.
+* @param {Parents | undefined} parent
+*   Parent of element.
+* @returns {boolean}
+*   Whether the closing tag can be omitted.
+*/
 function optgroup(_, index, parent) {
 	const next = siblingAfter(parent, index);
 	return !next || next.type === "element" && next.tagName === "optgroup";
 }
+/**
+* Whether to omit `</option>`.
+*
+* @param {Element} _
+*   Element.
+* @param {number | undefined} index
+*   Index of element in parent.
+* @param {Parents | undefined} parent
+*   Parent of element.
+* @returns {boolean}
+*   Whether the closing tag can be omitted.
+*/
 function option(_, index, parent) {
 	const next = siblingAfter(parent, index);
 	return !next || next.type === "element" && (next.tagName === "option" || next.tagName === "optgroup");
 }
+/**
+* Whether to omit `</thead>`.
+*
+* @param {Element} _
+*   Element.
+* @param {number | undefined} index
+*   Index of element in parent.
+* @param {Parents | undefined} parent
+*   Parent of element.
+* @returns {boolean}
+*   Whether the closing tag can be omitted.
+*/
 function thead(_, index, parent) {
 	const next = siblingAfter(parent, index);
 	return Boolean(next && next.type === "element" && (next.tagName === "tbody" || next.tagName === "tfoot"));
 }
+/**
+* Whether to omit `</tbody>`.
+*
+* @param {Element} _
+*   Element.
+* @param {number | undefined} index
+*   Index of element in parent.
+* @param {Parents | undefined} parent
+*   Parent of element.
+* @returns {boolean}
+*   Whether the closing tag can be omitted.
+*/
 function tbody$1(_, index, parent) {
 	const next = siblingAfter(parent, index);
 	return !next || next.type === "element" && (next.tagName === "tbody" || next.tagName === "tfoot");
 }
+/**
+* Whether to omit `</tfoot>`.
+*
+* @param {Element} _
+*   Element.
+* @param {number | undefined} index
+*   Index of element in parent.
+* @param {Parents | undefined} parent
+*   Parent of element.
+* @returns {boolean}
+*   Whether the closing tag can be omitted.
+*/
 function tfoot(_, index, parent) {
 	return !siblingAfter(parent, index);
 }
+/**
+* Whether to omit `</tr>`.
+*
+* @param {Element} _
+*   Element.
+* @param {number | undefined} index
+*   Index of element in parent.
+* @param {Parents | undefined} parent
+*   Parent of element.
+* @returns {boolean}
+*   Whether the closing tag can be omitted.
+*/
 function tr(_, index, parent) {
 	const next = siblingAfter(parent, index);
 	return !next || next.type === "element" && next.tagName === "tr";
 }
+/**
+* Whether to omit `</td>` or `</th>`.
+*
+* @param {Element} _
+*   Element.
+* @param {number | undefined} index
+*   Index of element in parent.
+* @param {Parents | undefined} parent
+*   Parent of element.
+* @returns {boolean}
+*   Whether the closing tag can be omitted.
+*/
 function cells(_, index, parent) {
 	const next = siblingAfter(parent, index);
 	return !next || next.type === "element" && (next.tagName === "td" || next.tagName === "th");
 }
-const opening = omission({
+//#endregion
+//#region ../../node_modules/.pnpm/hast-util-to-html@9.0.5/node_modules/hast-util-to-html/lib/omission/opening.js
+/**
+* @import {Element, Parents} from 'hast'
+*/
+var opening = omission({
 	body,
 	colgroup,
 	head,
 	html,
 	tbody
 });
+/**
+* Whether to omit `<html>`.
+*
+* @param {Element} node
+*   Element.
+* @returns {boolean}
+*   Whether the opening tag can be omitted.
+*/
 function html(node) {
 	const head = siblingAfter(node, -1);
 	return !head || head.type !== "comment";
 }
+/**
+* Whether to omit `<head>`.
+*
+* @param {Element} node
+*   Element.
+* @returns {boolean}
+*   Whether the opening tag can be omitted.
+*/
 function head(node) {
+	/** @type {Set<string>} */
 	const seen = /* @__PURE__ */ new Set();
 	for (const child of node.children) if (child.type === "element" && (child.tagName === "base" || child.tagName === "title")) {
 		if (seen.has(child.tagName)) return false;
@@ -3966,33 +4875,99 @@ function head(node) {
 	const child = node.children[0];
 	return !child || child.type === "element";
 }
+/**
+* Whether to omit `<body>`.
+*
+* @param {Element} node
+*   Element.
+* @returns {boolean}
+*   Whether the opening tag can be omitted.
+*/
 function body(node) {
 	const head = siblingAfter(node, -1, true);
 	return !head || head.type !== "comment" && !(head.type === "text" && whitespace(head.value.charAt(0))) && !(head.type === "element" && (head.tagName === "meta" || head.tagName === "link" || head.tagName === "script" || head.tagName === "style" || head.tagName === "template"));
 }
+/**
+* Whether to omit `<colgroup>`.
+* The spec describes some logic for the opening tag, but it’s easier to
+* implement in the closing tag, to the same effect, so we handle it there
+* instead.
+*
+* @param {Element} node
+*   Element.
+* @param {number | undefined} index
+*   Index of element in parent.
+* @param {Parents | undefined} parent
+*   Parent of element.
+* @returns {boolean}
+*   Whether the opening tag can be omitted.
+*/
 function colgroup(node, index, parent) {
 	const previous = siblingBefore(parent, index);
 	const head = siblingAfter(node, -1, true);
 	if (parent && previous && previous.type === "element" && previous.tagName === "colgroup" && closing(previous, parent.children.indexOf(previous), parent)) return false;
 	return Boolean(head && head.type === "element" && head.tagName === "col");
 }
+/**
+* Whether to omit `<tbody>`.
+*
+* @param {Element} node
+*   Element.
+* @param {number | undefined} index
+*   Index of element in parent.
+* @param {Parents | undefined} parent
+*   Parent of element.
+* @returns {boolean}
+*   Whether the opening tag can be omitted.
+*/
 function tbody(node, index, parent) {
 	const previous = siblingBefore(parent, index);
 	const head = siblingAfter(node, -1);
 	if (parent && previous && previous.type === "element" && (previous.tagName === "thead" || previous.tagName === "tbody") && closing(previous, parent.children.indexOf(previous), parent)) return false;
 	return Boolean(head && head.type === "element" && head.tagName === "tr");
 }
+//#endregion
+//#region ../../node_modules/.pnpm/hast-util-to-html@9.0.5/node_modules/hast-util-to-html/lib/handle/element.js
+/**
+* @import {Element, Parents, Properties} from 'hast'
+* @import {State} from '../index.js'
+*/
+/**
+* Maps of subsets.
+*
+* Each value is a matrix of tuples.
+* The value at `0` causes parse errors, the value at `1` is valid.
+* Of both, the value at `0` is unsafe, and the value at `1` is safe.
+*
+* @type {Record<'double' | 'name' | 'single' | 'unquoted', Array<[Array<string>, Array<string>]>>}
+*/
 var constants = {
 	name: [["	\n\f\r &/=>".split(""), "	\n\f\r \"&'/=>`".split("")], ["\0	\n\f\r \"&'/<=>".split(""), "\0	\n\f\r \"&'/<=>`".split("")]],
 	unquoted: [["	\n\f\r &>".split(""), "\0	\n\f\r \"&'<=>`".split("")], ["\0	\n\f\r \"&'<=>`".split(""), "\0	\n\f\r \"&'<=>`".split("")]],
 	single: [["&'".split(""), "\"&'`".split("")], ["\0&'".split(""), "\0\"&'`".split("")]],
 	double: [["\"&".split(""), "\"&'`".split("")], ["\0\"&".split(""), "\0\"&'`".split("")]]
 };
+/**
+* Serialize an element node.
+*
+* @param {Element} node
+*   Node to handle.
+* @param {number | undefined} index
+*   Index of `node` in `parent.
+* @param {Parents | undefined} parent
+*   Parent of `node`.
+* @param {State} state
+*   Info passed around about the current state.
+* @returns {string}
+*   Serialized node.
+*/
 function element(node, index, parent, state) {
 	const schema = state.schema;
 	const omit = schema.space === "svg" ? false : state.settings.omitOptionalTags;
 	let selfClosing = schema.space === "svg" ? state.settings.closeEmptyElements : state.settings.voids.includes(node.tagName.toLowerCase());
+	/** @type {Array<string>} */
 	const parts = [];
+	/** @type {string} */
 	let last;
 	if (schema.space === "html" && node.tagName === "svg") state.schema = svg;
 	const attributes = serializeAttributes(state, node.properties);
@@ -4012,9 +4987,16 @@ function element(node, index, parent, state) {
 	if (!selfClosing && (!omit || !closing(node, index, parent))) parts.push("</" + node.tagName + ">");
 	return parts.join("");
 }
+/**
+* @param {State} state
+* @param {Properties | null | undefined} properties
+* @returns {string}
+*/
 function serializeAttributes(state, properties) {
+	/** @type {Array<string>} */
 	const values = [];
 	let index = -1;
+	/** @type {string} */
 	let key;
 	if (properties) {
 		for (key in properties) if (properties[key] !== null && properties[key] !== void 0) {
@@ -4028,11 +5010,18 @@ function serializeAttributes(state, properties) {
 	}
 	return values.join("");
 }
+/**
+* @param {State} state
+* @param {string} key
+* @param {Properties[keyof Properties]} value
+* @returns {string}
+*/
 function serializeAttribute(state, key, value) {
 	const info = find(state.schema, key);
 	const x = state.settings.allowParseErrors && state.schema.space === "html" ? 0 : 1;
 	const y = state.settings.allowDangerousCharacters ? 0 : 1;
 	let quote = state.quote;
+	/** @type {string | undefined} */
 	let result;
 	if (info.overloadedBoolean && (value === info.attribute || value === "")) value = true;
 	else if ((info.boolean || info.overloadedBoolean) && (typeof value !== "string" || value === info.attribute || value === "")) value = Boolean(value);
@@ -4054,17 +5043,88 @@ function serializeAttribute(state, key, value) {
 	}
 	return name + (result ? "=" + result : result);
 }
+//#endregion
+//#region ../../node_modules/.pnpm/hast-util-to-html@9.0.5/node_modules/hast-util-to-html/lib/handle/text.js
+/**
+* @import {Parents, Text} from 'hast'
+* @import {Raw} from 'mdast-util-to-hast'
+* @import {State} from '../index.js'
+*/
 var textEntitySubset = ["<", "&"];
+/**
+* Serialize a text node.
+*
+* @param {Raw | Text} node
+*   Node to handle.
+* @param {number | undefined} _
+*   Index of `node` in `parent.
+* @param {Parents | undefined} parent
+*   Parent of `node`.
+* @param {State} state
+*   Info passed around about the current state.
+* @returns {string}
+*   Serialized node.
+*/
 function text(node, _, parent, state) {
 	return parent && parent.type === "element" && (parent.tagName === "script" || parent.tagName === "style") ? node.value : stringifyEntities(node.value, Object.assign({}, state.settings.characterReferences, { subset: textEntitySubset }));
 }
+//#endregion
+//#region ../../node_modules/.pnpm/hast-util-to-html@9.0.5/node_modules/hast-util-to-html/lib/handle/raw.js
+/**
+* @import {Parents} from 'hast'
+* @import {Raw} from 'mdast-util-to-hast'
+* @import {State} from '../index.js'
+*/
+/**
+* Serialize a raw node.
+*
+* @param {Raw} node
+*   Node to handle.
+* @param {number | undefined} index
+*   Index of `node` in `parent.
+* @param {Parents | undefined} parent
+*   Parent of `node`.
+* @param {State} state
+*   Info passed around about the current state.
+* @returns {string}
+*   Serialized node.
+*/
 function raw(node, index, parent, state) {
 	return state.settings.allowDangerousHtml ? node.value : text(node, index, parent, state);
 }
+//#endregion
+//#region ../../node_modules/.pnpm/hast-util-to-html@9.0.5/node_modules/hast-util-to-html/lib/handle/root.js
+/**
+* @import {Parents, Root} from 'hast'
+* @import {State} from '../index.js'
+*/
+/**
+* Serialize a root.
+*
+* @param {Root} node
+*   Node to handle.
+* @param {number | undefined} _1
+*   Index of `node` in `parent.
+* @param {Parents | undefined} _2
+*   Parent of `node`.
+* @param {State} state
+*   Info passed around about the current state.
+* @returns {string}
+*   Serialized node.
+*/
 function root(node, _1, _2, state) {
 	return state.all(node);
 }
-const handle = zwitch("type", {
+//#endregion
+//#region ../../node_modules/.pnpm/hast-util-to-html@9.0.5/node_modules/hast-util-to-html/lib/handle/index.js
+/**
+* @import {Nodes, Parents} from 'hast'
+* @import {State} from '../index.js'
+*/
+/**
+* @type {(node: Nodes, index: number | undefined, parent: Parents | undefined, state: State) => string}
+*/
+var handle = zwitch("type", {
 	invalid,
 	unknown,
 	handlers: {
@@ -4076,16 +5136,195 @@ const handle = zwitch("type", {
 		text
 	}
 });
+/**
+* Fail when a non-node is found in the tree.
+*
+* @param {unknown} node
+*   Unknown value.
+* @returns {never}
+*   Never.
+*/
 function invalid(node) {
 	throw new Error("Expected node, not `" + node + "`");
 }
+/**
+* Fail when a node with an unknown type is found in the tree.
+*
+* @param {unknown} node_
+*  Unknown node.
+* @returns {never}
+*   Never.
+*/
 function unknown(node_) {
 	const node = node_;
 	throw new Error("Cannot compile unknown node `" + node.type + "`");
 }
+//#endregion
+//#region ../../node_modules/.pnpm/hast-util-to-html@9.0.5/node_modules/hast-util-to-html/lib/index.js
+/**
+* @import {Nodes, Parents, RootContent} from 'hast'
+* @import {Schema} from 'property-information'
+* @import {Options as StringifyEntitiesOptions} from 'stringify-entities'
+*/
+/**
+* @typedef {Omit<StringifyEntitiesOptions, 'attribute' | 'escapeOnly' | 'subset'>} CharacterReferences
+*
+* @typedef Options
+*   Configuration.
+* @property {boolean | null | undefined} [allowDangerousCharacters=false]
+*   Do not encode some characters which cause XSS vulnerabilities in older
+*   browsers (default: `false`).
+*
+*   > ⚠️ **Danger**: only set this if you completely trust the content.
+* @property {boolean | null | undefined} [allowDangerousHtml=false]
+*   Allow `raw` nodes and insert them as raw HTML (default: `false`).
+*
+*   When `false`, `Raw` nodes are encoded.
+*
+*   > ⚠️ **Danger**: only set this if you completely trust the content.
+* @property {boolean | null | undefined} [allowParseErrors=false]
+*   Do not encode characters which cause parse errors (even though they work),
+*   to save bytes (default: `false`).
+*
+*   Not used in the SVG space.
+*
+*   > 👉 **Note**: intentionally creates parse errors in markup (how parse
+*   > errors are handled is well defined, so this works but isn’t pretty).
+* @property {boolean | null | undefined} [bogusComments=false]
+*   Use “bogus comments” instead of comments to save byes: `<?charlie>`
+*   instead of `<!--charlie-->` (default: `false`).
+*
+*   > 👉 **Note**: intentionally creates parse errors in markup (how parse
+*   > errors are handled is well defined, so this works but isn’t pretty).
+* @property {CharacterReferences | null | undefined} [characterReferences]
+*   Configure how to serialize character references (optional).
+* @property {boolean | null | undefined} [closeEmptyElements=false]
+*   Close SVG elements without any content with slash (`/`) on the opening tag
+*   instead of an end tag: `<circle />` instead of `<circle></circle>`
+*   (default: `false`).
+*
+*   See `tightSelfClosing` to control whether a space is used before the
+*   slash.
+*
+*   Not used in the HTML space.
+* @property {boolean | null | undefined} [closeSelfClosing=false]
+*   Close self-closing nodes with an extra slash (`/`): `<img />` instead of
+*   `<img>` (default: `false`).
+*
+*   See `tightSelfClosing` to control whether a space is used before the
+*   slash.
+*
+*   Not used in the SVG space.
+* @property {boolean | null | undefined} [collapseEmptyAttributes=false]
+*   Collapse empty attributes: get `class` instead of `class=""` (default:
+*   `false`).
+*
+*   Not used in the SVG space.
+*
+*   > 👉 **Note**: boolean attributes (such as `hidden`) are always collapsed.
+* @property {boolean | null | undefined} [omitOptionalTags=false]
+*   Omit optional opening and closing tags (default: `false`).
+*
+*   For example, in `<ol><li>one</li><li>two</li></ol>`, both `</li>` closing
+*   tags can be omitted.
+*   The first because it’s followed by another `li`, the last because it’s
+*   followed by nothing.
+*
+*   Not used in the SVG space.
+* @property {boolean | null | undefined} [preferUnquoted=false]
+*   Leave attributes unquoted if that results in less bytes (default: `false`).
+*
+*   Not used in the SVG space.
+* @property {boolean | null | undefined} [quoteSmart=false]
+*   Use the other quote if that results in less bytes (default: `false`).
+* @property {Quote | null | undefined} [quote='"']
+*   Preferred quote to use (default: `'"'`).
+* @property {Space | null | undefined} [space='html']
+*   When an `<svg>` element is found in the HTML space, this package already
+*   automatically switches to and from the SVG space when entering and exiting
+*   it (default: `'html'`).
+*
+*   > 👉 **Note**: hast is not XML.
+*   > It supports SVG as embedded in HTML.
+*   > It does not support the features available in XML.
+*   > Passing SVG might break but fragments of modern SVG should be fine.
+*   > Use [`xast`][xast] if you need to support SVG as XML.
+* @property {boolean | null | undefined} [tightAttributes=false]
+*   Join attributes together, without whitespace, if possible: get
+*   `class="a b"title="c d"` instead of `class="a b" title="c d"` to save
+*   bytes (default: `false`).
+*
+*   Not used in the SVG space.
+*
+*   > 👉 **Note**: intentionally creates parse errors in markup (how parse
+*   > errors are handled is well defined, so this works but isn’t pretty).
+* @property {boolean | null | undefined} [tightCommaSeparatedLists=false]
+*   Join known comma-separated attribute values with just a comma (`,`),
+*   instead of padding them on the right as well (`,␠`, where `␠` represents a
+*   space) (default: `false`).
+* @property {boolean | null | undefined} [tightDoctype=false]
+*   Drop unneeded spaces in doctypes: `<!doctypehtml>` instead of
+*   `<!doctype html>` to save bytes (default: `false`).
+*
+*   > 👉 **Note**: intentionally creates parse errors in markup (how parse
+*   > errors are handled is well defined, so this works but isn’t pretty).
+* @property {boolean | null | undefined} [tightSelfClosing=false]
+*   Do not use an extra space when closing self-closing elements: `<img/>`
+*   instead of `<img />` (default: `false`).
+*
+*   > 👉 **Note**: only used if `closeSelfClosing: true` or
+*   > `closeEmptyElements: true`.
+* @property {boolean | null | undefined} [upperDoctype=false]
+*   Use a `<!DOCTYPE…` instead of `<!doctype…` (default: `false`).
+*
+*   Useless except for XHTML.
+* @property {ReadonlyArray<string> | null | undefined} [voids]
+*   Tag names of elements to serialize without closing tag (default: `html-void-elements`).
+*
+*   Not used in the SVG space.
+*
+*   > 👉 **Note**: It’s highly unlikely that you want to pass this, because
+*   > hast is not for XML, and HTML will not add more void elements.
+*
+* @typedef {'"' | "'"} Quote
+*   HTML quotes for attribute values.
+*
+* @typedef {Omit<Required<{[key in keyof Options]: Exclude<Options[key], null | undefined>}>, 'space' | 'quote'>} Settings
+*
+* @typedef {'html' | 'svg'} Space
+*   Namespace.
+*
+* @typedef State
+*   Info passed around about the current state.
+* @property {(node: Parents | undefined) => string} all
+*   Serialize the children of a parent node.
+* @property {Quote} alternative
+*   Alternative quote.
+* @property {(node: Nodes, index: number | undefined, parent: Parents | undefined) => string} one
+*   Serialize one node.
+* @property {Quote} quote
+*   Preferred quote.
+* @property {Schema} schema
+*   Current schema.
+* @property {Settings} settings
+*   User configuration.
+*/
+/** @type {Options} */
 var emptyOptions = {};
+/** @type {CharacterReferences} */
 var emptyCharacterReferences = {};
+/** @type {Array<never>} */
 var emptyChildren = [];
+/**
+* Serialize hast as HTML.
+*
+* @param {Array<RootContent> | Nodes} tree
+*   Tree to serialize.
+* @param {Options | null | undefined} [options]
+*   Configuration (optional).
+* @returns {string}
+*   Serialized HTML.
+*/
 function toHtml(tree, options) {
 	const options_ = options || emptyOptions;
 	const quote = options_.quote || "\"";
@@ -4121,16 +5360,42 @@ function toHtml(tree, options) {
 		children: tree
 	} : tree, void 0, void 0);
 }
+/**
+* Serialize a node.
+*
+* @this {State}
+*   Info passed around about the current state.
+* @param {Nodes} node
+*   Node to handle.
+* @param {number | undefined} index
+*   Index of `node` in `parent.
+* @param {Parents | undefined} parent
+*   Parent of `node`.
+* @returns {string}
+*   Serialized node.
+*/
 function one(node, index, parent) {
 	return handle(node, index, parent, this);
 }
+/**
+* Serialize all children of `parent`.
+*
+* @this {State}
+*   Info passed around about the current state.
+* @param {Parents | undefined} parent
+*   Parent whose children to serialize.
+* @returns {string}
+*/
 function all(parent) {
+	/** @type {Array<string>} */
 	const results = [];
 	const children = parent && parent.children || emptyChildren;
 	let index = -1;
 	while (++index < children.length) results[index] = this.one(children[index], index, parent);
 	return results.join("");
 }
+//#endregion
+//#region ../../node_modules/.pnpm/@shikijs+core@3.22.0/node_modules/@shikijs/core/dist/index.mjs
 function resolveColorReplacements(theme, options) {
 	const replacements = typeof theme === "string" ? {} : { ...theme.colorReplacements };
 	const themeName = typeof theme === "string" ? theme : theme.name;
@@ -4328,6 +5593,9 @@ function getLastGrammarStateFromMap(keys) {
 	return _grammarStateMap.get(keys);
 }
 var GrammarState = class GrammarState {
+	/**
+	* Theme to Stack mapping
+	*/
 	_stacks = {};
 	lang;
 	get themes() {
@@ -4339,6 +5607,9 @@ var GrammarState = class GrammarState {
 	get _stack() {
 		return this._stacks[this.theme];
 	}
+	/**
+	* Static method to create a initial grammar state.
+	*/
 	static initial(lang, themes) {
 		return new GrammarState(Object.fromEntries(toArray(themes).map((theme) => [theme, INITIAL])), lang);
 	}
@@ -4353,6 +5624,10 @@ var GrammarState = class GrammarState {
 			this._stacks = { [theme]: stack };
 		}
 	}
+	/**
+	* Get the internal stack object.
+	* @internal
+	*/
 	getInternalStack(theme = this.theme) {
 		return this._stacks[theme];
 	}
@@ -6113,4 +7388,5 @@ function createCssVariablesTheme(options = {}) {
 	});
 	return theme;
 }
+//#endregion
 export { ShikiError, addClassToHast, applyColorReplacements, codeToHast, codeToHtml, codeToTokens, codeToTokensBase, codeToTokensWithThemes, createBundledHighlighter, createCssVariablesTheme, createHighlighterCore, createHighlighterCoreSync, createPositionConverter, createShikiInternal, createShikiInternalSync, createSingletonShorthands, createdBundledHighlighter, enableDeprecationWarnings, flatTokenVariants, getSingletonHighlighterCore, getTokenStyleObject, guessEmbeddedLanguages, hastToHtml, isNoneTheme, isPlainLang, isSpecialLang, isSpecialTheme, makeSingletonHighlighter, makeSingletonHighlighterCore, normalizeGetter, normalizeTheme, resolveColorReplacements, splitLines, splitToken, splitTokens, stringifyTokenStyle, toArray, tokenizeAnsiWithTheme, tokenizeWithTheme, tokensToHast, transformerDecorations, warnDeprecated };