@webskill/chatbot 0.15.0 → 0.17.0

package/dist/core-D3Tq37jA.js

@@ -0,0 +1,3063 @@
+import { n as __exportAll } from "./rolldown-runtime-DZ8SGSJo.js";
+
+//#region ../../node_modules/.pnpm/comma-separated-tokens@2.0.3/node_modules/comma-separated-tokens/index.js
+/**
+* @typedef Options
+*   Configuration for `stringify`.
+* @property {boolean} [padLeft=true]
+*   Whether to pad a space before a token.
+* @property {boolean} [padRight=false]
+*   Whether to pad a space after a token.
+*/
+/**
+* @typedef {Options} StringifyOptions
+*   Please use `StringifyOptions` instead.
+*/
+/**
+* Parse comma-separated tokens to an array.
+*
+* @param {string} value
+*   Comma-separated tokens.
+* @returns {Array<string>}
+*   List of tokens.
+*/
+function parse$1(value) {
+	/** @type {Array<string>} */
+	const tokens = [];
+	const input = String(value || "");
+	let index = input.indexOf(",");
+	let start = 0;
+	/** @type {boolean} */
+	let end = false;
+	while (!end) {
+		if (index === -1) {
+			index = input.length;
+			end = true;
+		}
+		const token = input.slice(start, index).trim();
+		if (token || !end) tokens.push(token);
+		start = index + 1;
+		index = input.indexOf(",", start);
+	}
+	return tokens;
+}
+/**
+* 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/property-information@7.2.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;
+		if (space) this.space = space;
+	}
+};
+Schema.prototype.normal = {};
+Schema.prototype.property = {};
+Schema.prototype.space = void 0;
+
+//#endregion
+//#region ../../node_modules/.pnpm/property-information@7.2.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);
+		Object.assign(normal, definition.normal);
+	}
+	return new Schema(property, normal, space);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/property-information@7.2.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.2.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;
+	}
+};
+Info.prototype.attribute = "";
+Info.prototype.booleanish = false;
+Info.prototype.boolean = false;
+Info.prototype.commaOrSpaceSeparated = false;
+Info.prototype.commaSeparated = false;
+Info.prototype.defined = false;
+Info.prototype.mustUseProperty = false;
+Info.prototype.number = false;
+Info.prototype.overloadedBoolean = false;
+Info.prototype.property = "";
+Info.prototype.spaceSeparated = false;
+Info.prototype.space = void 0;
+
+//#endregion
+//#region ../../node_modules/.pnpm/property-information@7.2.0/node_modules/property-information/lib/util/types.js
+var types_exports = /* @__PURE__ */ __exportAll({
+	boolean: () => boolean,
+	booleanish: () => booleanish,
+	commaOrSpaceSeparated: () => commaOrSpaceSeparated,
+	commaSeparated: () => commaSeparated,
+	number: () => number,
+	overloadedBoolean: () => overloadedBoolean,
+	spaceSeparated: () => spaceSeparated
+});
+let powers = 0;
+const boolean = increment();
+const booleanish = increment();
+const overloadedBoolean = increment();
+const number = increment();
+const spaceSeparated = increment();
+const commaSeparated = increment();
+const commaOrSpaceSeparated = increment();
+function increment() {
+	return 2 ** ++powers;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/property-information@7.2.0/node_modules/property-information/lib/util/defined-info.js
+/**
+* @import {Space} from 'property-information'
+*/
+const 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);
+		mark(this, "space", space);
+		if (typeof mask === "number") while (++index < checks.length) {
+			const check = checks[index];
+			mark(this, checks[index], (mask & types_exports[check]) === types_exports[check]);
+		}
+	}
+};
+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.2.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);
+		if (definition.mustUseProperty && definition.mustUseProperty.includes(property)) info.mustUseProperty = true;
+		properties[property] = info;
+		normals[normalize(property)] = property;
+		normals[normalize(info.attribute)] = property;
+	}
+	return new Schema(properties, normals, definition.space);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/property-information@7.2.0/node_modules/property-information/lib/aria.js
+const aria = create({
+	properties: {
+		ariaActiveDescendant: null,
+		ariaAtomic: booleanish,
+		ariaAutoComplete: null,
+		ariaBusy: booleanish,
+		ariaChecked: booleanish,
+		ariaColCount: number,
+		ariaColIndex: number,
+		ariaColSpan: number,
+		ariaControls: spaceSeparated,
+		ariaCurrent: null,
+		ariaDescribedBy: spaceSeparated,
+		ariaDetails: null,
+		ariaDisabled: booleanish,
+		ariaDropEffect: spaceSeparated,
+		ariaErrorMessage: null,
+		ariaExpanded: booleanish,
+		ariaFlowTo: spaceSeparated,
+		ariaGrabbed: booleanish,
+		ariaHasPopup: null,
+		ariaHidden: booleanish,
+		ariaInvalid: null,
+		ariaKeyShortcuts: null,
+		ariaLabel: null,
+		ariaLabelledBy: spaceSeparated,
+		ariaLevel: number,
+		ariaLive: null,
+		ariaModal: booleanish,
+		ariaMultiLine: booleanish,
+		ariaMultiSelectable: booleanish,
+		ariaOrientation: null,
+		ariaOwns: spaceSeparated,
+		ariaPlaceholder: null,
+		ariaPosInSet: number,
+		ariaPressed: booleanish,
+		ariaReadOnly: booleanish,
+		ariaRelevant: null,
+		ariaRequired: booleanish,
+		ariaRoleDescription: spaceSeparated,
+		ariaRowCount: number,
+		ariaRowIndex: number,
+		ariaRowSpan: number,
+		ariaSelected: booleanish,
+		ariaSetSize: number,
+		ariaSort: null,
+		ariaValueMax: number,
+		ariaValueMin: number,
+		ariaValueNow: number,
+		ariaValueText: null,
+		role: null
+	},
+	transform(_, property) {
+		return property === "role" ? property : "aria-" + property.slice(4).toLowerCase();
+	}
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/property-information@7.2.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.2.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());
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/property-information@7.2.0/node_modules/property-information/lib/html.js
+const html$1 = create({
+	attributes: {
+		acceptcharset: "accept-charset",
+		classname: "class",
+		htmlfor: "for",
+		httpequiv: "http-equiv"
+	},
+	mustUseProperty: [
+		"checked",
+		"multiple",
+		"muted",
+		"selected"
+	],
+	properties: {
+		abbr: null,
+		accept: commaSeparated,
+		acceptCharset: spaceSeparated,
+		accessKey: spaceSeparated,
+		action: null,
+		allow: null,
+		allowFullScreen: boolean,
+		allowPaymentRequest: boolean,
+		allowUserMedia: boolean,
+		alpha: boolean,
+		alt: null,
+		as: null,
+		async: boolean,
+		autoCapitalize: null,
+		autoComplete: spaceSeparated,
+		autoFocus: boolean,
+		autoPlay: boolean,
+		blocking: spaceSeparated,
+		capture: null,
+		charSet: null,
+		checked: boolean,
+		cite: null,
+		className: spaceSeparated,
+		closedBy: null,
+		colorSpace: null,
+		cols: number,
+		colSpan: number,
+		command: null,
+		commandFor: null,
+		content: null,
+		contentEditable: booleanish,
+		controls: boolean,
+		controlsList: spaceSeparated,
+		coords: number | commaSeparated,
+		crossOrigin: null,
+		data: null,
+		dateTime: null,
+		decoding: null,
+		default: boolean,
+		defer: boolean,
+		dir: null,
+		dirName: null,
+		disabled: boolean,
+		download: overloadedBoolean,
+		draggable: booleanish,
+		encType: null,
+		enterKeyHint: null,
+		fetchPriority: null,
+		form: null,
+		formAction: null,
+		formEncType: null,
+		formMethod: null,
+		formNoValidate: boolean,
+		formTarget: null,
+		headers: spaceSeparated,
+		height: number,
+		hidden: overloadedBoolean,
+		high: number,
+		href: null,
+		hrefLang: null,
+		htmlFor: spaceSeparated,
+		httpEquiv: spaceSeparated,
+		id: null,
+		imageSizes: null,
+		imageSrcSet: null,
+		inert: boolean,
+		inputMode: null,
+		integrity: null,
+		is: null,
+		isMap: boolean,
+		itemId: null,
+		itemProp: spaceSeparated,
+		itemRef: spaceSeparated,
+		itemScope: boolean,
+		itemType: spaceSeparated,
+		kind: null,
+		label: null,
+		lang: null,
+		language: null,
+		list: null,
+		loading: null,
+		loop: boolean,
+		low: number,
+		manifest: null,
+		max: null,
+		maxLength: number,
+		media: null,
+		method: null,
+		min: null,
+		minLength: number,
+		multiple: boolean,
+		muted: boolean,
+		name: null,
+		nonce: null,
+		noModule: boolean,
+		noValidate: boolean,
+		onAbort: null,
+		onAfterPrint: null,
+		onAuxClick: null,
+		onBeforeMatch: null,
+		onBeforePrint: null,
+		onBeforeToggle: null,
+		onBeforeUnload: null,
+		onBlur: null,
+		onCancel: null,
+		onCanPlay: null,
+		onCanPlayThrough: null,
+		onChange: null,
+		onClick: null,
+		onClose: null,
+		onContextLost: null,
+		onContextMenu: null,
+		onContextRestored: null,
+		onCopy: null,
+		onCueChange: null,
+		onCut: null,
+		onDblClick: null,
+		onDrag: null,
+		onDragEnd: null,
+		onDragEnter: null,
+		onDragExit: null,
+		onDragLeave: null,
+		onDragOver: null,
+		onDragStart: null,
+		onDrop: null,
+		onDurationChange: null,
+		onEmptied: null,
+		onEnded: null,
+		onError: null,
+		onFocus: null,
+		onFormData: null,
+		onHashChange: null,
+		onInput: null,
+		onInvalid: null,
+		onKeyDown: null,
+		onKeyPress: null,
+		onKeyUp: null,
+		onLanguageChange: null,
+		onLoad: null,
+		onLoadedData: null,
+		onLoadedMetadata: null,
+		onLoadEnd: null,
+		onLoadStart: null,
+		onMessage: null,
+		onMessageError: null,
+		onMouseDown: null,
+		onMouseEnter: null,
+		onMouseLeave: null,
+		onMouseMove: null,
+		onMouseOut: null,
+		onMouseOver: null,
+		onMouseUp: null,
+		onOffline: null,
+		onOnline: null,
+		onPageHide: null,
+		onPageShow: null,
+		onPaste: null,
+		onPause: null,
+		onPlay: null,
+		onPlaying: null,
+		onPopState: null,
+		onProgress: null,
+		onRateChange: null,
+		onRejectionHandled: null,
+		onReset: null,
+		onResize: null,
+		onScroll: null,
+		onScrollEnd: null,
+		onSecurityPolicyViolation: null,
+		onSeeked: null,
+		onSeeking: null,
+		onSelect: null,
+		onSlotChange: null,
+		onStalled: null,
+		onStorage: null,
+		onSubmit: null,
+		onSuspend: null,
+		onTimeUpdate: null,
+		onToggle: null,
+		onUnhandledRejection: null,
+		onUnload: null,
+		onVolumeChange: null,
+		onWaiting: null,
+		onWheel: null,
+		open: boolean,
+		optimum: number,
+		pattern: null,
+		ping: spaceSeparated,
+		placeholder: null,
+		playsInline: boolean,
+		popover: null,
+		popoverTarget: null,
+		popoverTargetAction: null,
+		poster: null,
+		preload: null,
+		readOnly: boolean,
+		referrerPolicy: null,
+		rel: spaceSeparated,
+		required: boolean,
+		reversed: boolean,
+		rows: number,
+		rowSpan: number,
+		sandbox: spaceSeparated,
+		scope: null,
+		scoped: boolean,
+		seamless: boolean,
+		selected: boolean,
+		shadowRootClonable: boolean,
+		shadowRootCustomElementRegistry: boolean,
+		shadowRootDelegatesFocus: boolean,
+		shadowRootMode: null,
+		shadowRootSerializable: boolean,
+		shape: null,
+		size: number,
+		sizes: null,
+		slot: null,
+		span: number,
+		spellCheck: booleanish,
+		src: null,
+		srcDoc: null,
+		srcLang: null,
+		srcSet: null,
+		start: number,
+		step: null,
+		style: null,
+		tabIndex: number,
+		target: null,
+		title: null,
+		translate: null,
+		type: null,
+		typeMustMatch: boolean,
+		useMap: null,
+		value: booleanish,
+		width: number,
+		wrap: null,
+		writingSuggestions: null,
+		align: null,
+		aLink: null,
+		archive: spaceSeparated,
+		axis: null,
+		background: null,
+		bgColor: null,
+		border: number,
+		borderColor: null,
+		bottomMargin: number,
+		cellPadding: null,
+		cellSpacing: null,
+		char: null,
+		charOff: null,
+		classId: null,
+		clear: null,
+		code: null,
+		codeBase: null,
+		codeType: null,
+		color: null,
+		compact: boolean,
+		declare: boolean,
+		event: null,
+		face: null,
+		frame: null,
+		frameBorder: null,
+		hSpace: number,
+		leftMargin: number,
+		link: null,
+		longDesc: null,
+		lowSrc: null,
+		marginHeight: number,
+		marginWidth: number,
+		noResize: boolean,
+		noHref: boolean,
+		noShade: boolean,
+		noWrap: boolean,
+		object: null,
+		profile: null,
+		prompt: null,
+		rev: null,
+		rightMargin: number,
+		rules: null,
+		scheme: null,
+		scrolling: booleanish,
+		standby: null,
+		summary: null,
+		text: null,
+		topMargin: number,
+		valueType: null,
+		version: null,
+		vAlign: null,
+		vLink: null,
+		vSpace: number,
+		allowTransparency: null,
+		autoCorrect: null,
+		autoSave: null,
+		credentialless: boolean,
+		disablePictureInPicture: boolean,
+		disableRemotePlayback: boolean,
+		exportParts: commaSeparated,
+		part: spaceSeparated,
+		prefix: null,
+		property: null,
+		results: number,
+		security: null,
+		unselectable: null
+	},
+	space: "html",
+	transform: caseInsensitiveTransform
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/property-information@7.2.0/node_modules/property-information/lib/svg.js
+const svg$1 = create({
+	attributes: {
+		accentHeight: "accent-height",
+		alignmentBaseline: "alignment-baseline",
+		arabicForm: "arabic-form",
+		baselineShift: "baseline-shift",
+		capHeight: "cap-height",
+		className: "class",
+		clipPath: "clip-path",
+		clipRule: "clip-rule",
+		colorInterpolation: "color-interpolation",
+		colorInterpolationFilters: "color-interpolation-filters",
+		colorProfile: "color-profile",
+		colorRendering: "color-rendering",
+		crossOrigin: "crossorigin",
+		dataType: "datatype",
+		dominantBaseline: "dominant-baseline",
+		enableBackground: "enable-background",
+		fillOpacity: "fill-opacity",
+		fillRule: "fill-rule",
+		floodColor: "flood-color",
+		floodOpacity: "flood-opacity",
+		fontFamily: "font-family",
+		fontSize: "font-size",
+		fontSizeAdjust: "font-size-adjust",
+		fontStretch: "font-stretch",
+		fontStyle: "font-style",
+		fontVariant: "font-variant",
+		fontWeight: "font-weight",
+		glyphName: "glyph-name",
+		glyphOrientationHorizontal: "glyph-orientation-horizontal",
+		glyphOrientationVertical: "glyph-orientation-vertical",
+		hrefLang: "hreflang",
+		horizAdvX: "horiz-adv-x",
+		horizOriginX: "horiz-origin-x",
+		horizOriginY: "horiz-origin-y",
+		imageRendering: "image-rendering",
+		letterSpacing: "letter-spacing",
+		lightingColor: "lighting-color",
+		markerEnd: "marker-end",
+		markerMid: "marker-mid",
+		markerStart: "marker-start",
+		maskType: "mask-type",
+		navDown: "nav-down",
+		navDownLeft: "nav-down-left",
+		navDownRight: "nav-down-right",
+		navLeft: "nav-left",
+		navNext: "nav-next",
+		navPrev: "nav-prev",
+		navRight: "nav-right",
+		navUp: "nav-up",
+		navUpLeft: "nav-up-left",
+		navUpRight: "nav-up-right",
+		onAbort: "onabort",
+		onActivate: "onactivate",
+		onAfterPrint: "onafterprint",
+		onBeforePrint: "onbeforeprint",
+		onBegin: "onbegin",
+		onCancel: "oncancel",
+		onCanPlay: "oncanplay",
+		onCanPlayThrough: "oncanplaythrough",
+		onChange: "onchange",
+		onClick: "onclick",
+		onClose: "onclose",
+		onCopy: "oncopy",
+		onCueChange: "oncuechange",
+		onCut: "oncut",
+		onDblClick: "ondblclick",
+		onDrag: "ondrag",
+		onDragEnd: "ondragend",
+		onDragEnter: "ondragenter",
+		onDragExit: "ondragexit",
+		onDragLeave: "ondragleave",
+		onDragOver: "ondragover",
+		onDragStart: "ondragstart",
+		onDrop: "ondrop",
+		onDurationChange: "ondurationchange",
+		onEmptied: "onemptied",
+		onEnd: "onend",
+		onEnded: "onended",
+		onError: "onerror",
+		onFocus: "onfocus",
+		onFocusIn: "onfocusin",
+		onFocusOut: "onfocusout",
+		onHashChange: "onhashchange",
+		onInput: "oninput",
+		onInvalid: "oninvalid",
+		onKeyDown: "onkeydown",
+		onKeyPress: "onkeypress",
+		onKeyUp: "onkeyup",
+		onLoad: "onload",
+		onLoadedData: "onloadeddata",
+		onLoadedMetadata: "onloadedmetadata",
+		onLoadStart: "onloadstart",
+		onMessage: "onmessage",
+		onMouseDown: "onmousedown",
+		onMouseEnter: "onmouseenter",
+		onMouseLeave: "onmouseleave",
+		onMouseMove: "onmousemove",
+		onMouseOut: "onmouseout",
+		onMouseOver: "onmouseover",
+		onMouseUp: "onmouseup",
+		onMouseWheel: "onmousewheel",
+		onOffline: "onoffline",
+		onOnline: "ononline",
+		onPageHide: "onpagehide",
+		onPageShow: "onpageshow",
+		onPaste: "onpaste",
+		onPause: "onpause",
+		onPlay: "onplay",
+		onPlaying: "onplaying",
+		onPopState: "onpopstate",
+		onProgress: "onprogress",
+		onRateChange: "onratechange",
+		onRepeat: "onrepeat",
+		onReset: "onreset",
+		onResize: "onresize",
+		onScroll: "onscroll",
+		onSeeked: "onseeked",
+		onSeeking: "onseeking",
+		onSelect: "onselect",
+		onShow: "onshow",
+		onStalled: "onstalled",
+		onStorage: "onstorage",
+		onSubmit: "onsubmit",
+		onSuspend: "onsuspend",
+		onTimeUpdate: "ontimeupdate",
+		onToggle: "ontoggle",
+		onUnload: "onunload",
+		onVolumeChange: "onvolumechange",
+		onWaiting: "onwaiting",
+		onZoom: "onzoom",
+		overlinePosition: "overline-position",
+		overlineThickness: "overline-thickness",
+		paintOrder: "paint-order",
+		panose1: "panose-1",
+		pointerEvents: "pointer-events",
+		referrerPolicy: "referrerpolicy",
+		renderingIntent: "rendering-intent",
+		shapeRendering: "shape-rendering",
+		stopColor: "stop-color",
+		stopOpacity: "stop-opacity",
+		strikethroughPosition: "strikethrough-position",
+		strikethroughThickness: "strikethrough-thickness",
+		strokeDashArray: "stroke-dasharray",
+		strokeDashOffset: "stroke-dashoffset",
+		strokeLineCap: "stroke-linecap",
+		strokeLineJoin: "stroke-linejoin",
+		strokeMiterLimit: "stroke-miterlimit",
+		strokeOpacity: "stroke-opacity",
+		strokeWidth: "stroke-width",
+		tabIndex: "tabindex",
+		textAnchor: "text-anchor",
+		textDecoration: "text-decoration",
+		textRendering: "text-rendering",
+		transformOrigin: "transform-origin",
+		typeOf: "typeof",
+		underlinePosition: "underline-position",
+		underlineThickness: "underline-thickness",
+		unicodeBidi: "unicode-bidi",
+		unicodeRange: "unicode-range",
+		unitsPerEm: "units-per-em",
+		vAlphabetic: "v-alphabetic",
+		vHanging: "v-hanging",
+		vIdeographic: "v-ideographic",
+		vMathematical: "v-mathematical",
+		vectorEffect: "vector-effect",
+		vertAdvY: "vert-adv-y",
+		vertOriginX: "vert-origin-x",
+		vertOriginY: "vert-origin-y",
+		wordSpacing: "word-spacing",
+		writingMode: "writing-mode",
+		xHeight: "x-height",
+		playbackOrder: "playbackorder",
+		timelineBegin: "timelinebegin"
+	},
+	properties: {
+		about: commaOrSpaceSeparated,
+		accentHeight: number,
+		accumulate: null,
+		additive: null,
+		alignmentBaseline: null,
+		alphabetic: number,
+		amplitude: number,
+		arabicForm: null,
+		ascent: number,
+		attributeName: null,
+		attributeType: null,
+		azimuth: number,
+		bandwidth: null,
+		baselineShift: null,
+		baseFrequency: null,
+		baseProfile: null,
+		bbox: null,
+		begin: null,
+		bias: number,
+		by: null,
+		calcMode: null,
+		capHeight: number,
+		className: spaceSeparated,
+		clip: null,
+		clipPath: null,
+		clipPathUnits: null,
+		clipRule: null,
+		color: null,
+		colorInterpolation: null,
+		colorInterpolationFilters: null,
+		colorProfile: null,
+		colorRendering: null,
+		content: null,
+		contentScriptType: null,
+		contentStyleType: null,
+		crossOrigin: null,
+		cursor: null,
+		cx: null,
+		cy: null,
+		d: null,
+		dataType: null,
+		defaultAction: null,
+		descent: number,
+		diffuseConstant: number,
+		direction: null,
+		display: null,
+		dur: null,
+		divisor: number,
+		dominantBaseline: null,
+		download: boolean,
+		dx: null,
+		dy: null,
+		edgeMode: null,
+		editable: null,
+		elevation: number,
+		enableBackground: null,
+		end: null,
+		event: null,
+		exponent: number,
+		externalResourcesRequired: null,
+		fill: null,
+		fillOpacity: number,
+		fillRule: null,
+		filter: null,
+		filterRes: null,
+		filterUnits: null,
+		floodColor: null,
+		floodOpacity: null,
+		focusable: null,
+		focusHighlight: null,
+		fontFamily: null,
+		fontSize: null,
+		fontSizeAdjust: null,
+		fontStretch: null,
+		fontStyle: null,
+		fontVariant: null,
+		fontWeight: null,
+		format: null,
+		fr: null,
+		from: null,
+		fx: null,
+		fy: null,
+		g1: commaSeparated,
+		g2: commaSeparated,
+		glyphName: commaSeparated,
+		glyphOrientationHorizontal: null,
+		glyphOrientationVertical: null,
+		glyphRef: null,
+		gradientTransform: null,
+		gradientUnits: null,
+		handler: null,
+		hanging: number,
+		hatchContentUnits: null,
+		hatchUnits: null,
+		height: null,
+		href: null,
+		hrefLang: null,
+		horizAdvX: number,
+		horizOriginX: number,
+		horizOriginY: number,
+		id: null,
+		ideographic: number,
+		imageRendering: null,
+		initialVisibility: null,
+		in: null,
+		in2: null,
+		intercept: number,
+		k: number,
+		k1: number,
+		k2: number,
+		k3: number,
+		k4: number,
+		kernelMatrix: commaOrSpaceSeparated,
+		kernelUnitLength: null,
+		keyPoints: null,
+		keySplines: null,
+		keyTimes: null,
+		kerning: null,
+		lang: null,
+		lengthAdjust: null,
+		letterSpacing: null,
+		lightingColor: null,
+		limitingConeAngle: number,
+		local: null,
+		markerEnd: null,
+		markerMid: null,
+		markerStart: null,
+		markerHeight: null,
+		markerUnits: null,
+		markerWidth: null,
+		mask: null,
+		maskContentUnits: null,
+		maskType: null,
+		maskUnits: null,
+		mathematical: null,
+		max: null,
+		media: null,
+		mediaCharacterEncoding: null,
+		mediaContentEncodings: null,
+		mediaSize: number,
+		mediaTime: null,
+		method: null,
+		min: null,
+		mode: null,
+		name: null,
+		navDown: null,
+		navDownLeft: null,
+		navDownRight: null,
+		navLeft: null,
+		navNext: null,
+		navPrev: null,
+		navRight: null,
+		navUp: null,
+		navUpLeft: null,
+		navUpRight: null,
+		numOctaves: null,
+		observer: null,
+		offset: null,
+		onAbort: null,
+		onActivate: null,
+		onAfterPrint: null,
+		onBeforePrint: null,
+		onBegin: null,
+		onCancel: null,
+		onCanPlay: null,
+		onCanPlayThrough: null,
+		onChange: null,
+		onClick: null,
+		onClose: null,
+		onCopy: null,
+		onCueChange: null,
+		onCut: null,
+		onDblClick: null,
+		onDrag: null,
+		onDragEnd: null,
+		onDragEnter: null,
+		onDragExit: null,
+		onDragLeave: null,
+		onDragOver: null,
+		onDragStart: null,
+		onDrop: null,
+		onDurationChange: null,
+		onEmptied: null,
+		onEnd: null,
+		onEnded: null,
+		onError: null,
+		onFocus: null,
+		onFocusIn: null,
+		onFocusOut: null,
+		onHashChange: null,
+		onInput: null,
+		onInvalid: null,
+		onKeyDown: null,
+		onKeyPress: null,
+		onKeyUp: null,
+		onLoad: null,
+		onLoadedData: null,
+		onLoadedMetadata: null,
+		onLoadStart: null,
+		onMessage: null,
+		onMouseDown: null,
+		onMouseEnter: null,
+		onMouseLeave: null,
+		onMouseMove: null,
+		onMouseOut: null,
+		onMouseOver: null,
+		onMouseUp: null,
+		onMouseWheel: null,
+		onOffline: null,
+		onOnline: null,
+		onPageHide: null,
+		onPageShow: null,
+		onPaste: null,
+		onPause: null,
+		onPlay: null,
+		onPlaying: null,
+		onPopState: null,
+		onProgress: null,
+		onRateChange: null,
+		onRepeat: null,
+		onReset: null,
+		onResize: null,
+		onScroll: null,
+		onSeeked: null,
+		onSeeking: null,
+		onSelect: null,
+		onShow: null,
+		onStalled: null,
+		onStorage: null,
+		onSubmit: null,
+		onSuspend: null,
+		onTimeUpdate: null,
+		onToggle: null,
+		onUnload: null,
+		onVolumeChange: null,
+		onWaiting: null,
+		onZoom: null,
+		opacity: null,
+		operator: null,
+		order: null,
+		orient: null,
+		orientation: null,
+		origin: null,
+		overflow: null,
+		overlay: null,
+		overlinePosition: number,
+		overlineThickness: number,
+		paintOrder: null,
+		panose1: null,
+		path: null,
+		pathLength: number,
+		patternContentUnits: null,
+		patternTransform: null,
+		patternUnits: null,
+		phase: null,
+		ping: spaceSeparated,
+		pitch: null,
+		playbackOrder: null,
+		pointerEvents: null,
+		points: null,
+		pointsAtX: number,
+		pointsAtY: number,
+		pointsAtZ: number,
+		preserveAlpha: null,
+		preserveAspectRatio: null,
+		primitiveUnits: null,
+		propagate: null,
+		property: commaOrSpaceSeparated,
+		r: null,
+		radius: null,
+		referrerPolicy: null,
+		refX: null,
+		refY: null,
+		rel: commaOrSpaceSeparated,
+		rev: commaOrSpaceSeparated,
+		renderingIntent: null,
+		repeatCount: null,
+		repeatDur: null,
+		requiredExtensions: commaOrSpaceSeparated,
+		requiredFeatures: commaOrSpaceSeparated,
+		requiredFonts: commaOrSpaceSeparated,
+		requiredFormats: commaOrSpaceSeparated,
+		resource: null,
+		restart: null,
+		result: null,
+		rotate: null,
+		rx: null,
+		ry: null,
+		scale: null,
+		seed: null,
+		shapeRendering: null,
+		side: null,
+		slope: null,
+		snapshotTime: null,
+		specularConstant: number,
+		specularExponent: number,
+		spreadMethod: null,
+		spacing: null,
+		startOffset: null,
+		stdDeviation: null,
+		stemh: null,
+		stemv: null,
+		stitchTiles: null,
+		stopColor: null,
+		stopOpacity: null,
+		strikethroughPosition: number,
+		strikethroughThickness: number,
+		string: null,
+		stroke: null,
+		strokeDashArray: commaOrSpaceSeparated,
+		strokeDashOffset: null,
+		strokeLineCap: null,
+		strokeLineJoin: null,
+		strokeMiterLimit: number,
+		strokeOpacity: number,
+		strokeWidth: null,
+		style: null,
+		surfaceScale: number,
+		syncBehavior: null,
+		syncBehaviorDefault: null,
+		syncMaster: null,
+		syncTolerance: null,
+		syncToleranceDefault: null,
+		systemLanguage: commaOrSpaceSeparated,
+		tabIndex: number,
+		tableValues: null,
+		target: null,
+		targetX: number,
+		targetY: number,
+		textAnchor: null,
+		textDecoration: null,
+		textRendering: null,
+		textLength: null,
+		timelineBegin: null,
+		title: null,
+		transformBehavior: null,
+		type: null,
+		typeOf: commaOrSpaceSeparated,
+		to: null,
+		transform: null,
+		transformOrigin: null,
+		u1: null,
+		u2: null,
+		underlinePosition: number,
+		underlineThickness: number,
+		unicode: null,
+		unicodeBidi: null,
+		unicodeRange: null,
+		unitsPerEm: number,
+		values: null,
+		vAlphabetic: number,
+		vMathematical: number,
+		vectorEffect: null,
+		vHanging: number,
+		vIdeographic: number,
+		version: null,
+		vertAdvY: number,
+		vertOriginX: number,
+		vertOriginY: number,
+		viewBox: null,
+		viewTarget: null,
+		visibility: null,
+		width: null,
+		widths: null,
+		wordSpacing: null,
+		writingMode: null,
+		x: null,
+		x1: null,
+		x2: null,
+		xChannelSelector: null,
+		xHeight: number,
+		y: null,
+		y1: null,
+		y2: null,
+		yChannelSelector: null,
+		z: null,
+		zoomAndPan: null
+	},
+	space: "svg",
+	transform: caseSensitiveTransform
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/property-information@7.2.0/node_modules/property-information/lib/xlink.js
+const xlink = create({
+	properties: {
+		xLinkActuate: null,
+		xLinkArcRole: null,
+		xLinkHref: null,
+		xLinkRole: null,
+		xLinkShow: null,
+		xLinkTitle: null,
+		xLinkType: null
+	},
+	space: "xlink",
+	transform(_, property) {
+		return "xlink:" + property.slice(5).toLowerCase();
+	}
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/property-information@7.2.0/node_modules/property-information/lib/xmlns.js
+const xmlns = create({
+	attributes: { xmlnsxlink: "xmlns:xlink" },
+	properties: {
+		xmlnsXLink: null,
+		xmlns: null
+	},
+	space: "xmlns",
+	transform: caseInsensitiveTransform
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/property-information@7.2.0/node_modules/property-information/lib/xml.js
+const xml = create({
+	properties: {
+		xmlBase: null,
+		xmlLang: null,
+		xmlSpace: null
+	},
+	space: "xml",
+	transform(_, property) {
+		return "xml:" + property.slice(3).toLowerCase();
+	}
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/property-information@7.2.0/node_modules/property-information/lib/find.js
+/**
+* @import {Schema} from 'property-information'
+*/
+const cap = /[A-Z]/g;
+const dash = /-[a-z]/g;
+const 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;
+	let Type = Info;
+	if (normal in schema.normal) return schema.property[schema.normal[normal]];
+	if (normal.length > 4 && normal.slice(0, 4) === "data" && valid.test(value)) {
+		if (value.charAt(4) === "-") {
+			const rest = value.slice(5).replace(dash, camelcase);
+			property = "data" + rest.charAt(0).toUpperCase() + rest.slice(1);
+		} else {
+			const rest = value.slice(4);
+			if (!dash.test(rest)) {
+				let dashes = rest.replace(cap, kebab);
+				if (dashes.charAt(0) !== "-") dashes = "-" + dashes;
+				value = "data" + dashes;
+			}
+		}
+		Type = DefinedInfo;
+	}
+	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();
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/property-information@7.2.0/node_modules/property-information/index.js
+const html = merge([
+	aria,
+	html$1,
+	xlink,
+	xmlns,
+	xml
+], "html");
+const svg = merge([
+	aria,
+	svg$1,
+	xlink,
+	xmlns,
+	xml
+], "svg");
+
+//#endregion
+//#region ../../node_modules/.pnpm/space-separated-tokens@2.0.2/node_modules/space-separated-tokens/index.js
+/**
+* Parse space-separated tokens to an array of strings.
+*
+* @param {string} value
+*   Space-separated tokens.
+* @returns {Array<string>}
+*   List of tokens.
+*/
+function parse(value) {
+	const input = String(value || "").trim();
+	return input ? input.split(/[ \t\n\r\f]+/g) : [];
+}
+/**
+* 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-parse-selector@4.0.0/node_modules/hast-util-parse-selector/lib/index.js
+/**
+* @typedef {import('hast').Element} Element
+* @typedef {import('hast').Properties} Properties
+*/
+/**
+* @template {string} SimpleSelector
+*   Selector type.
+* @template {string} DefaultTagName
+*   Default tag name.
+* @typedef {(
+*   SimpleSelector extends ''
+*     ? DefaultTagName
+*     : SimpleSelector extends `${infer TagName}.${infer Rest}`
+*     ? ExtractTagName<TagName, DefaultTagName>
+*     : SimpleSelector extends `${infer TagName}#${infer Rest}`
+*     ? ExtractTagName<TagName, DefaultTagName>
+*     : SimpleSelector extends string
+*     ? SimpleSelector
+*     : DefaultTagName
+* )} ExtractTagName
+*   Extract tag name from a simple selector.
+*/
+const search = /[#.]/g;
+/**
+* Create a hast element from a simple CSS selector.
+*
+* @template {string} Selector
+*   Type of selector.
+* @template {string} [DefaultTagName='div']
+*   Type of default tag name (default: `'div'`).
+* @param {Selector | null | undefined} [selector]
+*   Simple CSS selector (optional).
+*
+*   Can contain a tag name (`foo`), classes (`.bar`), and an ID (`#baz`).
+*   Multiple classes are allowed.
+*   Uses the last ID if multiple IDs are found.
+* @param {DefaultTagName | null | undefined} [defaultTagName='div']
+*   Tag name to use if `selector` does not specify one (default: `'div'`).
+* @returns {Element & {tagName: ExtractTagName<Selector, DefaultTagName>}}
+*   Built element.
+*/
+function parseSelector(selector, defaultTagName) {
+	const value = selector || "";
+	/** @type {Properties} */
+	const props = {};
+	let start = 0;
+	/** @type {string | undefined} */
+	let previous;
+	/** @type {string | undefined} */
+	let tagName;
+	while (start < value.length) {
+		search.lastIndex = start;
+		const match = search.exec(value);
+		const subvalue = value.slice(start, match ? match.index : value.length);
+		if (subvalue) {
+			if (!previous) tagName = subvalue;
+			else if (previous === "#") props.id = subvalue;
+			else if (Array.isArray(props.className)) props.className.push(subvalue);
+			else props.className = [subvalue];
+			start += subvalue.length;
+		}
+		if (match) {
+			previous = match[0];
+			start++;
+		}
+	}
+	return {
+		type: "element",
+		tagName: tagName || defaultTagName || "div",
+		properties: props,
+		children: []
+	};
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/hastscript@9.0.1/node_modules/hastscript/lib/create-h.js
+/**
+* @import {Element, Nodes, RootContent, Root} from 'hast'
+* @import {Info, Schema} from 'property-information'
+*/
+/**
+* @typedef {Array<Nodes | PrimitiveChild>} ArrayChildNested
+*   List of children (deep).
+*/
+/**
+* @typedef {Array<ArrayChildNested | Nodes | PrimitiveChild>} ArrayChild
+*   List of children.
+*/
+/**
+* @typedef {Array<number | string>} ArrayValue
+*   List of property values for space- or comma separated values (such as `className`).
+*/
+/**
+* @typedef {ArrayChild | Nodes | PrimitiveChild} Child
+*   Acceptable child value.
+*/
+/**
+* @typedef {number | string | null | undefined} PrimitiveChild
+*   Primitive children, either ignored (nullish), or turned into text nodes.
+*/
+/**
+* @typedef {boolean | number | string | null | undefined} PrimitiveValue
+*   Primitive property value.
+*/
+/**
+* @typedef {Record<string, PropertyValue | Style>} Properties
+*   Acceptable value for element properties.
+*/
+/**
+* @typedef {ArrayValue | PrimitiveValue} PropertyValue
+*   Primitive value or list value.
+*/
+/**
+* @typedef {Element | Root} Result
+*   Result from a `h` (or `s`) call.
+*/
+/**
+* @typedef {number | string} StyleValue
+*   Value for a CSS style field.
+*/
+/**
+* @typedef {Record<string, StyleValue>} Style
+*   Supported value of a `style` prop.
+*/
+/**
+* @param {Schema} schema
+*   Schema to use.
+* @param {string} defaultTagName
+*   Default tag name.
+* @param {ReadonlyArray<string> | undefined} [caseSensitive]
+*   Case-sensitive tag names (default: `undefined`).
+* @returns
+*   `h`.
+*/
+function createH(schema, defaultTagName, caseSensitive) {
+	const adjust = caseSensitive ? createAdjustMap(caseSensitive) : void 0;
+	/**
+	* Hyperscript compatible DSL for creating virtual hast trees.
+	*
+	* @overload
+	* @param {null | undefined} [selector]
+	* @param {...Child} children
+	* @returns {Root}
+	*
+	* @overload
+	* @param {string} selector
+	* @param {Properties} properties
+	* @param {...Child} children
+	* @returns {Element}
+	*
+	* @overload
+	* @param {string} selector
+	* @param {...Child} children
+	* @returns {Element}
+	*
+	* @param {string | null | undefined} [selector]
+	*   Selector.
+	* @param {Child | Properties | null | undefined} [properties]
+	*   Properties (or first child) (default: `undefined`).
+	* @param {...Child} children
+	*   Children.
+	* @returns {Result}
+	*   Result.
+	*/
+	function h(selector, properties, ...children) {
+		/** @type {Result} */
+		let node;
+		if (selector === null || selector === void 0) {
+			node = {
+				type: "root",
+				children: []
+			};
+			const child = properties;
+			children.unshift(child);
+		} else {
+			node = parseSelector(selector, defaultTagName);
+			const lower = node.tagName.toLowerCase();
+			const adjusted = adjust ? adjust.get(lower) : void 0;
+			node.tagName = adjusted || lower;
+			if (isChild(properties)) children.unshift(properties);
+			else for (const [key, value] of Object.entries(properties)) addProperty(schema, node.properties, key, value);
+		}
+		for (const child of children) addChild(node.children, child);
+		if (node.type === "element" && node.tagName === "template") {
+			node.content = {
+				type: "root",
+				children: node.children
+			};
+			node.children = [];
+		}
+		return node;
+	}
+	return h;
+}
+/**
+* Check if something is properties or a child.
+*
+* @param {Child | Properties} value
+*   Value to check.
+* @returns {value is Child}
+*   Whether `value` is definitely a child.
+*/
+function isChild(value) {
+	if (value === null || typeof value !== "object" || Array.isArray(value)) return true;
+	if (typeof value.type !== "string") return false;
+	const record = value;
+	const keys = Object.keys(value);
+	for (const key of keys) {
+		const value = record[key];
+		if (value && typeof value === "object") {
+			if (!Array.isArray(value)) return true;
+			const list = value;
+			for (const item of list) if (typeof item !== "number" && typeof item !== "string") return true;
+		}
+	}
+	if ("children" in value && Array.isArray(value.children)) return true;
+	return false;
+}
+/**
+* @param {Schema} schema
+*   Schema.
+* @param {Properties} properties
+*   Properties object.
+* @param {string} key
+*   Property name.
+* @param {PropertyValue | Style} value
+*   Property value.
+* @returns {undefined}
+*   Nothing.
+*/
+function addProperty(schema, properties, key, value) {
+	const info = find(schema, key);
+	/** @type {PropertyValue} */
+	let result;
+	if (value === null || value === void 0) return;
+	if (typeof value === "number") {
+		if (Number.isNaN(value)) return;
+		result = value;
+	} else if (typeof value === "boolean") result = value;
+	else if (typeof value === "string") if (info.spaceSeparated) result = parse(value);
+	else if (info.commaSeparated) result = parse$1(value);
+	else if (info.commaOrSpaceSeparated) result = parse(parse$1(value).join(" "));
+	else result = parsePrimitive(info, info.property, value);
+	else if (Array.isArray(value)) result = [...value];
+	else result = info.property === "style" ? style(value) : String(value);
+	if (Array.isArray(result)) {
+		/** @type {Array<number | string>} */
+		const finalResult = [];
+		for (const item of result) finalResult.push(parsePrimitive(info, info.property, item));
+		result = finalResult;
+	}
+	if (info.property === "className" && Array.isArray(properties.className)) result = properties.className.concat(result);
+	properties[info.property] = result;
+}
+/**
+* @param {Array<RootContent>} nodes
+*   Children.
+* @param {Child} value
+*   Child.
+* @returns {undefined}
+*   Nothing.
+*/
+function addChild(nodes, value) {
+	if (value === null || value === void 0) {} else if (typeof value === "number" || typeof value === "string") nodes.push({
+		type: "text",
+		value: String(value)
+	});
+	else if (Array.isArray(value)) for (const child of value) addChild(nodes, child);
+	else if (typeof value === "object" && "type" in value) if (value.type === "root") addChild(nodes, value.children);
+	else nodes.push(value);
+	else throw new Error("Expected node, nodes, or string, got `" + value + "`");
+}
+/**
+* Parse a single primitives.
+*
+* @param {Info} info
+*   Property information.
+* @param {string} name
+*   Property name.
+* @param {PrimitiveValue} value
+*   Property value.
+* @returns {PrimitiveValue}
+*   Property value.
+*/
+function parsePrimitive(info, name, value) {
+	if (typeof value === "string") {
+		if (info.number && value && !Number.isNaN(Number(value))) return Number(value);
+		if ((info.boolean || info.overloadedBoolean) && (value === "" || normalize(value) === normalize(name))) return true;
+	}
+	return value;
+}
+/**
+* Serialize a `style` object as a string.
+*
+* @param {Style} styles
+*   Style object.
+* @returns {string}
+*   CSS string.
+*/
+function style(styles) {
+	/** @type {Array<string>} */
+	const result = [];
+	for (const [key, value] of Object.entries(styles)) result.push([key, value].join(": "));
+	return result.join("; ");
+}
+/**
+* Create a map to adjust casing.
+*
+* @param {ReadonlyArray<string>} values
+*   List of properly cased keys.
+* @returns {Map<string, string>}
+*   Map of lowercase keys to uppercase keys.
+*/
+function createAdjustMap(values) {
+	/** @type {Map<string, string>} */
+	const result = /* @__PURE__ */ new Map();
+	for (const value of values) result.set(value.toLowerCase(), value);
+	return result;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/hastscript@9.0.1/node_modules/hastscript/lib/svg-case-sensitive-tag-names.js
+/**
+* List of case-sensitive SVG tag names.
+*
+* @type {ReadonlyArray<string>}
+*/
+const svgCaseSensitiveTagNames = [
+	"altGlyph",
+	"altGlyphDef",
+	"altGlyphItem",
+	"animateColor",
+	"animateMotion",
+	"animateTransform",
+	"clipPath",
+	"feBlend",
+	"feColorMatrix",
+	"feComponentTransfer",
+	"feComposite",
+	"feConvolveMatrix",
+	"feDiffuseLighting",
+	"feDisplacementMap",
+	"feDistantLight",
+	"feDropShadow",
+	"feFlood",
+	"feFuncA",
+	"feFuncB",
+	"feFuncG",
+	"feFuncR",
+	"feGaussianBlur",
+	"feImage",
+	"feMerge",
+	"feMergeNode",
+	"feMorphology",
+	"feOffset",
+	"fePointLight",
+	"feSpecularLighting",
+	"feSpotLight",
+	"feTile",
+	"feTurbulence",
+	"foreignObject",
+	"glyphRef",
+	"linearGradient",
+	"radialGradient",
+	"solidColor",
+	"textArea",
+	"textPath"
+];
+
+//#endregion
+//#region ../../node_modules/.pnpm/hastscript@9.0.1/node_modules/hastscript/lib/index.js
+/**
+* @typedef {import('./jsx-classic.js').Element} h.JSX.Element
+* @typedef {import('./jsx-classic.js').ElementChildrenAttribute} h.JSX.ElementChildrenAttribute
+* @typedef {import('./jsx-classic.js').IntrinsicAttributes} h.JSX.IntrinsicAttributes
+* @typedef {import('./jsx-classic.js').IntrinsicElements} h.JSX.IntrinsicElements
+*/
+/**
+* @typedef {import('./jsx-classic.js').Element} s.JSX.Element
+* @typedef {import('./jsx-classic.js').ElementChildrenAttribute} s.JSX.ElementChildrenAttribute
+* @typedef {import('./jsx-classic.js').IntrinsicAttributes} s.JSX.IntrinsicAttributes
+* @typedef {import('./jsx-classic.js').IntrinsicElements} s.JSX.IntrinsicElements
+*/
+/** @type {ReturnType<createH>} */
+const h = createH(html, "div");
+/** @type {ReturnType<createH>} */
+const s = createH(svg, "g", svgCaseSensitiveTagNames);
+
+//#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>}
+*/
+const characterEntitiesLegacy = [
+	"AElig",
+	"AMP",
+	"Aacute",
+	"Acirc",
+	"Agrave",
+	"Aring",
+	"Atilde",
+	"Auml",
+	"COPY",
+	"Ccedil",
+	"ETH",
+	"Eacute",
+	"Ecirc",
+	"Egrave",
+	"Euml",
+	"GT",
+	"Iacute",
+	"Icirc",
+	"Igrave",
+	"Iuml",
+	"LT",
+	"Ntilde",
+	"Oacute",
+	"Ocirc",
+	"Ograve",
+	"Oslash",
+	"Otilde",
+	"Ouml",
+	"QUOT",
+	"REG",
+	"THORN",
+	"Uacute",
+	"Ucirc",
+	"Ugrave",
+	"Uuml",
+	"Yacute",
+	"aacute",
+	"acirc",
+	"acute",
+	"aelig",
+	"agrave",
+	"amp",
+	"aring",
+	"atilde",
+	"auml",
+	"brvbar",
+	"ccedil",
+	"cedil",
+	"cent",
+	"copy",
+	"curren",
+	"deg",
+	"divide",
+	"eacute",
+	"ecirc",
+	"egrave",
+	"eth",
+	"euml",
+	"frac12",
+	"frac14",
+	"frac34",
+	"gt",
+	"iacute",
+	"icirc",
+	"iexcl",
+	"igrave",
+	"iquest",
+	"iuml",
+	"laquo",
+	"lt",
+	"macr",
+	"micro",
+	"middot",
+	"nbsp",
+	"not",
+	"ntilde",
+	"oacute",
+	"ocirc",
+	"ograve",
+	"ordf",
+	"ordm",
+	"oslash",
+	"otilde",
+	"ouml",
+	"para",
+	"plusmn",
+	"pound",
+	"quot",
+	"raquo",
+	"reg",
+	"sect",
+	"shy",
+	"sup1",
+	"sup2",
+	"sup3",
+	"szlig",
+	"thorn",
+	"times",
+	"uacute",
+	"ucirc",
+	"ugrave",
+	"uml",
+	"uuml",
+	"yacute",
+	"yen",
+	"yuml"
+];
+
+//#endregion
+//#region ../../node_modules/.pnpm/character-reference-invalid@2.0.1/node_modules/character-reference-invalid/index.js
+/**
+* Map of invalid numeric character references to their replacements, according to HTML.
+*
+* @type {Record<number, string>}
+*/
+const characterReferenceInvalid = {
+	0: "�",
+	128: "€",
+	130: "‚",
+	131: "ƒ",
+	132: "„",
+	133: "…",
+	134: "†",
+	135: "‡",
+	136: "ˆ",
+	137: "‰",
+	138: "Š",
+	139: "‹",
+	140: "Œ",
+	142: "Ž",
+	145: "‘",
+	146: "’",
+	147: "“",
+	148: "”",
+	149: "•",
+	150: "–",
+	151: "—",
+	152: "˜",
+	153: "™",
+	154: "š",
+	155: "›",
+	156: "œ",
+	158: "ž",
+	159: "Ÿ"
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/is-decimal@2.0.1/node_modules/is-decimal/index.js
+/**
+* Check if the given character code, or the character code at the first
+* character, is decimal.
+*
+* @param {string|number} character
+* @returns {boolean} Whether `character` is a decimal
+*/
+function isDecimal(character) {
+	const code = typeof character === "string" ? character.charCodeAt(0) : character;
+	return code >= 48 && code <= 57;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/is-hexadecimal@2.0.1/node_modules/is-hexadecimal/index.js
+/**
+* Check if the given character code, or the character code at the first
+* character, is hexadecimal.
+*
+* @param {string|number} character
+* @returns {boolean} Whether `character` is hexadecimal
+*/
+function isHexadecimal(character) {
+	const code = typeof character === "string" ? character.charCodeAt(0) : character;
+	return code >= 97 && code <= 102 || code >= 65 && code <= 70 || code >= 48 && code <= 57;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/is-alphabetical@2.0.1/node_modules/is-alphabetical/index.js
+/**
+* Check if the given character code, or the character code at the first
+* character, is alphabetical.
+*
+* @param {string|number} character
+* @returns {boolean} Whether `character` is alphabetical.
+*/
+function isAlphabetical(character) {
+	const code = typeof character === "string" ? character.charCodeAt(0) : character;
+	return code >= 97 && code <= 122 || code >= 65 && code <= 90;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/is-alphanumerical@2.0.1/node_modules/is-alphanumerical/index.js
+/**
+* Check if the given character code, or the character code at the first
+* character, is alphanumerical.
+*
+* @param {string|number} character
+* @returns {boolean} Whether `character` is alphanumerical.
+*/
+function isAlphanumerical(character) {
+	return isAlphabetical(character) || isDecimal(character);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/decode-named-character-reference@1.3.0/node_modules/decode-named-character-reference/index.dom.js
+const element = document.createElement("i");
+/**
+* @param {string} value
+* @returns {string | false}
+*/
+function decodeNamedCharacterReference(value) {
+	const characterReference = "&" + value + ";";
+	element.innerHTML = characterReference;
+	const character = element.textContent;
+	if (character.charCodeAt(character.length - 1) === 59 && value !== "semi") return false;
+	return character === characterReference ? false : character;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/parse-entities@4.0.2/node_modules/parse-entities/lib/index.js
+/**
+* @import {Point} from 'unist'
+* @import {Options} from '../index.js'
+*/
+const messages = [
+	"",
+	"Named character references must be terminated by a semicolon",
+	"Numeric character references must be terminated by a semicolon",
+	"Named character references cannot be empty",
+	"Numeric character references cannot be empty",
+	"Named character references must be known",
+	"Numeric character references cannot be disallowed",
+	"Numeric character references cannot be outside the permissible Unicode range"
+];
+/**
+* Parse HTML character references.
+*
+* @param {string} value
+* @param {Readonly<Options> | null | undefined} [options]
+*/
+function parseEntities(value, options) {
+	const settings = options || {};
+	const additional = typeof settings.additional === "string" ? settings.additional.charCodeAt(0) : settings.additional;
+	/** @type {Array<string>} */
+	const result = [];
+	let index = 0;
+	let lines = -1;
+	let queue = "";
+	/** @type {Point | undefined} */
+	let point;
+	/** @type {Array<number>|undefined} */
+	let indent;
+	if (settings.position) if ("start" in settings.position || "indent" in settings.position) {
+		indent = settings.position.indent;
+		point = settings.position.start;
+	} else point = settings.position;
+	let line = (point ? point.line : 0) || 1;
+	let column = (point ? point.column : 0) || 1;
+	let previous = now();
+	/** @type {number|undefined} */
+	let character;
+	index--;
+	while (++index <= value.length) {
+		if (character === 10) column = (indent ? indent[lines] : 0) || 1;
+		character = value.charCodeAt(index);
+		if (character === 38) {
+			const following = value.charCodeAt(index + 1);
+			if (following === 9 || following === 10 || following === 12 || following === 32 || following === 38 || following === 60 || Number.isNaN(following) || additional && following === additional) {
+				queue += String.fromCharCode(character);
+				column++;
+				continue;
+			}
+			const start = index + 1;
+			let begin = start;
+			let end = start;
+			/** @type {string} */
+			let type;
+			if (following === 35) {
+				end = ++begin;
+				const following = value.charCodeAt(end);
+				if (following === 88 || following === 120) {
+					type = "hexadecimal";
+					end = ++begin;
+				} else type = "decimal";
+			} else type = "named";
+			let characterReferenceCharacters = "";
+			let characterReference = "";
+			let characters = "";
+			const test = type === "named" ? isAlphanumerical : type === "decimal" ? isDecimal : isHexadecimal;
+			end--;
+			while (++end <= value.length) {
+				const following = value.charCodeAt(end);
+				if (!test(following)) break;
+				characters += String.fromCharCode(following);
+				if (type === "named" && characterEntitiesLegacy.includes(characters)) {
+					characterReferenceCharacters = characters;
+					characterReference = decodeNamedCharacterReference(characters);
+				}
+			}
+			let terminated = value.charCodeAt(end) === 59;
+			if (terminated) {
+				end++;
+				const namedReference = type === "named" ? decodeNamedCharacterReference(characters) : false;
+				if (namedReference) {
+					characterReferenceCharacters = characters;
+					characterReference = namedReference;
+				}
+			}
+			let diff = 1 + end - start;
+			let reference = "";
+			if (!terminated && settings.nonTerminated === false) {} else if (!characters) {
+				if (type !== "named") warning(4, diff);
+			} else if (type === "named") {
+				if (terminated && !characterReference) warning(5, 1);
+				else {
+					if (characterReferenceCharacters !== characters) {
+						end = begin + characterReferenceCharacters.length;
+						diff = 1 + end - begin;
+						terminated = false;
+					}
+					if (!terminated) {
+						const reason = characterReferenceCharacters ? 1 : 3;
+						if (settings.attribute) {
+							const following = value.charCodeAt(end);
+							if (following === 61) {
+								warning(reason, diff);
+								characterReference = "";
+							} else if (isAlphanumerical(following)) characterReference = "";
+							else warning(reason, diff);
+						} else warning(reason, diff);
+					}
+				}
+				reference = characterReference;
+			} else {
+				if (!terminated) warning(2, diff);
+				let referenceCode = Number.parseInt(characters, type === "hexadecimal" ? 16 : 10);
+				if (prohibited(referenceCode)) {
+					warning(7, diff);
+					reference = String.fromCharCode(65533);
+				} else if (referenceCode in characterReferenceInvalid) {
+					warning(6, diff);
+					reference = characterReferenceInvalid[referenceCode];
+				} else {
+					let output = "";
+					if (disallowed(referenceCode)) warning(6, diff);
+					if (referenceCode > 65535) {
+						referenceCode -= 65536;
+						output += String.fromCharCode(referenceCode >>> 10 | 55296);
+						referenceCode = 56320 | referenceCode & 1023;
+					}
+					reference = output + String.fromCharCode(referenceCode);
+				}
+			}
+			if (reference) {
+				flush();
+				previous = now();
+				index = end - 1;
+				column += end - start + 1;
+				result.push(reference);
+				const next = now();
+				next.offset++;
+				if (settings.reference) settings.reference.call(settings.referenceContext || void 0, reference, {
+					start: previous,
+					end: next
+				}, value.slice(start - 1, end));
+				previous = next;
+			} else {
+				characters = value.slice(start - 1, end);
+				queue += characters;
+				column += characters.length;
+				index = end - 1;
+			}
+		} else {
+			if (character === 10) {
+				line++;
+				lines++;
+				column = 0;
+			}
+			if (Number.isNaN(character)) flush();
+			else {
+				queue += String.fromCharCode(character);
+				column++;
+			}
+		}
+	}
+	return result.join("");
+	function now() {
+		return {
+			line,
+			column,
+			offset: index + ((point ? point.offset : 0) || 0)
+		};
+	}
+	/**
+	* Handle the warning.
+	*
+	* @param {1|2|3|4|5|6|7} code
+	* @param {number} offset
+	*/
+	function warning(code, offset) {
+		/** @type {ReturnType<now>} */
+		let position;
+		if (settings.warning) {
+			position = now();
+			position.column += offset;
+			position.offset += offset;
+			settings.warning.call(settings.warningContext || void 0, messages[code], position, code);
+		}
+	}
+	/**
+	* Flush `queue` (normal text).
+	* Macro invoked before each reference and at the end of `value`.
+	* Does nothing when `queue` is empty.
+	*/
+	function flush() {
+		if (queue) {
+			result.push(queue);
+			if (settings.text) settings.text.call(settings.textContext || void 0, queue, {
+				start: previous,
+				end: now()
+			});
+			queue = "";
+		}
+	}
+}
+/**
+* Check if `character` is outside the permissible unicode range.
+*
+* @param {number} code
+* @returns {boolean}
+*/
+function prohibited(code) {
+	return code >= 55296 && code <= 57343 || code > 1114111;
+}
+/**
+* Check if `character` is disallowed.
+*
+* @param {number} code
+* @returns {boolean}
+*/
+function disallowed(code) {
+	return code >= 1 && code <= 8 || code === 11 || code >= 13 && code <= 31 || code >= 127 && code <= 159 || code >= 64976 && code <= 65007 || (code & 65535) === 65535 || (code & 65535) === 65534;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lib/prism-core.js
+var uniqueId = 0;
+var plainTextGrammar = {};
+var _ = {
+	/**
+	* A namespace for utility methods.
+	*
+	* All function in this namespace that are not explicitly marked as _public_ are for __internal use only__ and may
+	* change or disappear at any time.
+	*
+	* @namespace
+	* @memberof Prism
+	*/
+	util: {
+		/**
+		* Returns the name of the type of the given value.
+		*
+		* @param {any} o
+		* @returns {string}
+		* @example
+		* type(null)      === 'Null'
+		* type(undefined) === 'Undefined'
+		* type(123)       === 'Number'
+		* type('foo')     === 'String'
+		* type(true)      === 'Boolean'
+		* type([1, 2])    === 'Array'
+		* type({})        === 'Object'
+		* type(String)    === 'Function'
+		* type(/abc+/)    === 'RegExp'
+		*/
+		type: function(o) {
+			return Object.prototype.toString.call(o).slice(8, -1);
+		},
+		/**
+		* Returns a unique number for the given object. Later calls will still return the same number.
+		*
+		* @param {Object} obj
+		* @returns {number}
+		*/
+		objId: function(obj) {
+			if (!obj["__id"]) Object.defineProperty(obj, "__id", { value: ++uniqueId });
+			return obj["__id"];
+		},
+		/**
+		* Creates a deep clone of the given object.
+		*
+		* The main intended use of this function is to clone language definitions.
+		*
+		* @param {T} o
+		* @param {Record<number, any>} [visited]
+		* @returns {T}
+		* @template T
+		*/
+		clone: function deepClone(o, visited) {
+			visited = visited || {};
+			var clone;
+			var id;
+			switch (_.util.type(o)) {
+				case "Object":
+					id = _.util.objId(o);
+					if (visited[id]) return visited[id];
+					clone = {};
+					visited[id] = clone;
+					for (var key in o) if (o.hasOwnProperty(key)) clone[key] = deepClone(o[key], visited);
+					return clone;
+				case "Array":
+					id = _.util.objId(o);
+					if (visited[id]) return visited[id];
+					clone = [];
+					visited[id] = clone;
+					/** @type {Array} */ o.forEach(function(v, i) {
+						clone[i] = deepClone(v, visited);
+					});
+					return clone;
+				default: return o;
+			}
+		}
+	},
+	/**
+	* This namespace contains all currently loaded languages and the some helper functions to create and modify languages.
+	*
+	* @namespace
+	* @memberof Prism
+	* @public
+	*/
+	languages: {
+		/**
+		* The grammar for plain, unformatted text.
+		*/
+		plain: plainTextGrammar,
+		plaintext: plainTextGrammar,
+		text: plainTextGrammar,
+		txt: plainTextGrammar,
+		/**
+		* Creates a deep copy of the language with the given id and appends the given tokens.
+		*
+		* If a token in `redef` also appears in the copied language, then the existing token in the copied language
+		* will be overwritten at its original position.
+		*
+		* ## Best practices
+		*
+		* Since the position of overwriting tokens (token in `redef` that overwrite tokens in the copied language)
+		* doesn't matter, they can technically be in any order. However, this can be confusing to others that trying to
+		* understand the language definition because, normally, the order of tokens matters in Prism grammars.
+		*
+		* Therefore, it is encouraged to order overwriting tokens according to the positions of the overwritten tokens.
+		* Furthermore, all non-overwriting tokens should be placed after the overwriting ones.
+		*
+		* @param {string} id The id of the language to extend. This has to be a key in `Prism.languages`.
+		* @param {Grammar} redef The new tokens to append.
+		* @returns {Grammar} The new language created.
+		* @public
+		* @example
+		* Prism.languages['css-with-colors'] = Prism.languages.extend('css', {
+		*     // Prism.languages.css already has a 'comment' token, so this token will overwrite CSS' 'comment' token
+		*     // at its original position
+		*     'comment': { ... },
+		*     // CSS doesn't have a 'color' token, so this token will be appended
+		*     'color': /\b(?:red|green|blue)\b/
+		* });
+		*/
+		extend: function(id, redef) {
+			var lang = _.util.clone(_.languages[id]);
+			for (var key in redef) lang[key] = redef[key];
+			return lang;
+		},
+		/**
+		* Inserts tokens _before_ another token in a language definition or any other grammar.
+		*
+		* ## Usage
+		*
+		* This helper method makes it easy to modify existing languages. For example, the CSS language definition
+		* not only defines CSS highlighting for CSS documents, but also needs to define highlighting for CSS embedded
+		* in HTML through `<style>` elements. To do this, it needs to modify `Prism.languages.markup` and add the
+		* appropriate tokens. However, `Prism.languages.markup` is a regular JavaScript object literal, so if you do
+		* this:
+		*
+		* ```js
+		* Prism.languages.markup.style = {
+		*     // token
+		* };
+		* ```
+		*
+		* then the `style` token will be added (and processed) at the end. `insertBefore` allows you to insert tokens
+		* before existing tokens. For the CSS example above, you would use it like this:
+		*
+		* ```js
+		* Prism.languages.insertBefore('markup', 'cdata', {
+		*     'style': {
+		*         // token
+		*     }
+		* });
+		* ```
+		*
+		* ## Special cases
+		*
+		* If the grammars of `inside` and `insert` have tokens with the same name, the tokens in `inside`'s grammar
+		* will be ignored.
+		*
+		* This behavior can be used to insert tokens after `before`:
+		*
+		* ```js
+		* Prism.languages.insertBefore('markup', 'comment', {
+		*     'comment': Prism.languages.markup.comment,
+		*     // tokens after 'comment'
+		* });
+		* ```
+		*
+		* ## Limitations
+		*
+		* The main problem `insertBefore` has to solve is iteration order. Since ES2015, the iteration order for object
+		* properties is guaranteed to be the insertion order (except for integer keys) but some browsers behave
+		* differently when keys are deleted and re-inserted. So `insertBefore` can't be implemented by temporarily
+		* deleting properties which is necessary to insert at arbitrary positions.
+		*
+		* To solve this problem, `insertBefore` doesn't actually insert the given tokens into the target object.
+		* Instead, it will create a new object and replace all references to the target object with the new one. This
+		* can be done without temporarily deleting properties, so the iteration order is well-defined.
+		*
+		* However, only references that can be reached from `Prism.languages` or `insert` will be replaced. I.e. if
+		* you hold the target object in a variable, then the value of the variable will not change.
+		*
+		* ```js
+		* var oldMarkup = Prism.languages.markup;
+		* var newMarkup = Prism.languages.insertBefore('markup', 'comment', { ... });
+		*
+		* assert(oldMarkup !== Prism.languages.markup);
+		* assert(newMarkup === Prism.languages.markup);
+		* ```
+		*
+		* @param {string} inside The property of `root` (e.g. a language id in `Prism.languages`) that contains the
+		* object to be modified.
+		* @param {string} before The key to insert before.
+		* @param {Grammar} insert An object containing the key-value pairs to be inserted.
+		* @param {Object<string, any>} [root] The object containing `inside`, i.e. the object that contains the
+		* object to be modified.
+		*
+		* Defaults to `Prism.languages`.
+		* @returns {Grammar} The new grammar object.
+		* @public
+		*/
+		insertBefore: function(inside, before, insert, root) {
+			root = root || _.languages;
+			var grammar = root[inside];
+			/** @type {Grammar} */
+			var ret = {};
+			for (var token in grammar) if (grammar.hasOwnProperty(token)) {
+				if (token == before) {
+					for (var newToken in insert) if (insert.hasOwnProperty(newToken)) ret[newToken] = insert[newToken];
+				}
+				if (!insert.hasOwnProperty(token)) ret[token] = grammar[token];
+			}
+			var old = root[inside];
+			root[inside] = ret;
+			_.languages.DFS(_.languages, function(key, value) {
+				if (value === old && key != inside) this[key] = ret;
+			});
+			return ret;
+		},
+		DFS: function DFS(o, callback, type, visited) {
+			visited = visited || {};
+			var objId = _.util.objId;
+			for (var i in o) if (o.hasOwnProperty(i)) {
+				callback.call(o, i, o[i], type || i);
+				var property = o[i];
+				var propertyType = _.util.type(property);
+				if (propertyType === "Object" && !visited[objId(property)]) {
+					visited[objId(property)] = true;
+					DFS(property, callback, null, visited);
+				} else if (propertyType === "Array" && !visited[objId(property)]) {
+					visited[objId(property)] = true;
+					DFS(property, callback, i, visited);
+				}
+			}
+		}
+	},
+	plugins: {},
+	/**
+	* Low-level function, only use if you know what you’re doing. It accepts a string of text as input
+	* and the language definitions to use, and returns a string with the HTML produced.
+	*
+	* The following hooks will be run:
+	* 1. `before-tokenize`
+	* 2. `after-tokenize`
+	* 3. `wrap`: On each {@link Token}.
+	*
+	* @param {string} text A string with the code to be highlighted.
+	* @param {Grammar} grammar An object containing the tokens to use.
+	*
+	* Usually a language definition like `Prism.languages.markup`.
+	* @param {string} language The name of the language definition passed to `grammar`.
+	* @returns {string} The highlighted HTML.
+	* @memberof Prism
+	* @public
+	* @example
+	* Prism.highlight('var foo = true;', Prism.languages.javascript, 'javascript');
+	*/
+	highlight: function(text, grammar, language) {
+		var env = {
+			code: text,
+			grammar,
+			language
+		};
+		_.hooks.run("before-tokenize", env);
+		if (!env.grammar) throw new Error("The language \"" + env.language + "\" has no grammar.");
+		env.tokens = _.tokenize(env.code, env.grammar);
+		_.hooks.run("after-tokenize", env);
+		return Token.stringify(_.util.encode(env.tokens), env.language);
+	},
+	/**
+	* This is the heart of Prism, and the most low-level function you can use. It accepts a string of text as input
+	* and the language definitions to use, and returns an array with the tokenized code.
+	*
+	* When the language definition includes nested tokens, the function is called recursively on each of these tokens.
+	*
+	* This method could be useful in other contexts as well, as a very crude parser.
+	*
+	* @param {string} text A string with the code to be highlighted.
+	* @param {Grammar} grammar An object containing the tokens to use.
+	*
+	* Usually a language definition like `Prism.languages.markup`.
+	* @returns {TokenStream} An array of strings and tokens, a token stream.
+	* @memberof Prism
+	* @public
+	* @example
+	* let code = `var foo = 0;`;
+	* let tokens = Prism.tokenize(code, Prism.languages.javascript);
+	* tokens.forEach(token => {
+	*     if (token instanceof Prism.Token && token.type === 'number') {
+	*         console.log(`Found numeric literal: ${token.content}`);
+	*     }
+	* });
+	*/
+	tokenize: function(text, grammar) {
+		var rest = grammar.rest;
+		if (rest) {
+			for (var token in rest) grammar[token] = rest[token];
+			delete grammar.rest;
+		}
+		var tokenList = new LinkedList();
+		addAfter(tokenList, tokenList.head, text);
+		matchGrammar(text, tokenList, grammar, tokenList.head, 0);
+		return toArray(tokenList);
+	},
+	/**
+	* @namespace
+	* @memberof Prism
+	* @public
+	*/
+	hooks: {
+		all: {},
+		/**
+		* Adds the given callback to the list of callbacks for the given hook.
+		*
+		* The callback will be invoked when the hook it is registered for is run.
+		* Hooks are usually directly run by a highlight function but you can also run hooks yourself.
+		*
+		* One callback function can be registered to multiple hooks and the same hook multiple times.
+		*
+		* @param {string} name The name of the hook.
+		* @param {HookCallback} callback The callback function which is given environment variables.
+		* @public
+		*/
+		add: function(name, callback) {
+			var hooks = _.hooks.all;
+			hooks[name] = hooks[name] || [];
+			hooks[name].push(callback);
+		},
+		/**
+		* Runs a hook invoking all registered callbacks with the given environment variables.
+		*
+		* Callbacks will be invoked synchronously and in the order in which they were registered.
+		*
+		* @param {string} name The name of the hook.
+		* @param {Object<string, any>} env The environment variables of the hook passed to all callbacks registered.
+		* @public
+		*/
+		run: function(name, env) {
+			var callbacks = _.hooks.all[name];
+			if (!callbacks || !callbacks.length) return;
+			for (var i = 0, callback; callback = callbacks[i++];) callback(env);
+		}
+	},
+	Token
+};
+/**
+* Creates a new token.
+*
+* @param {string} type See {@link Token#type type}
+* @param {string | TokenStream} content See {@link Token#content content}
+* @param {string|string[]} [alias] The alias(es) of the token.
+* @param {string} [matchedStr=""] A copy of the full string this token was created from.
+* @class
+* @global
+* @public
+*/
+function Token(type, content, alias, matchedStr) {
+	/**
+	* The type of the token.
+	*
+	* This is usually the key of a pattern in a {@link Grammar}.
+	*
+	* @type {string}
+	* @see GrammarToken
+	* @public
+	*/
+	this.type = type;
+	/**
+	* The strings or tokens contained by this token.
+	*
+	* This will be a token stream if the pattern matched also defined an `inside` grammar.
+	*
+	* @type {string | TokenStream}
+	* @public
+	*/
+	this.content = content;
+	/**
+	* The alias(es) of the token.
+	*
+	* @type {string|string[]}
+	* @see GrammarToken
+	* @public
+	*/
+	this.alias = alias;
+	this.length = (matchedStr || "").length | 0;
+}
+/**
+* A token stream is an array of strings and {@link Token Token} objects.
+*
+* Token streams have to fulfill a few properties that are assumed by most functions (mostly internal ones) that process
+* them.
+*
+* 1. No adjacent strings.
+* 2. No empty strings.
+*
+*    The only exception here is the token stream that only contains the empty string and nothing else.
+*
+* @typedef {Array<string | Token>} TokenStream
+* @global
+* @public
+*/
+/**
+* @param {RegExp} pattern
+* @param {number} pos
+* @param {string} text
+* @param {boolean} lookbehind
+* @returns {RegExpExecArray | null}
+*/
+function matchPattern(pattern, pos, text, lookbehind) {
+	pattern.lastIndex = pos;
+	var match = pattern.exec(text);
+	if (match && lookbehind && match[1]) {
+		var lookbehindLength = match[1].length;
+		match.index += lookbehindLength;
+		match[0] = match[0].slice(lookbehindLength);
+	}
+	return match;
+}
+/**
+* @param {string} text
+* @param {LinkedList<string | Token>} tokenList
+* @param {any} grammar
+* @param {LinkedListNode<string | Token>} startNode
+* @param {number} startPos
+* @param {RematchOptions} [rematch]
+* @returns {void}
+* @private
+*
+* @typedef RematchOptions
+* @property {string} cause
+* @property {number} reach
+*/
+function matchGrammar(text, tokenList, grammar, startNode, startPos, rematch) {
+	for (var token in grammar) {
+		if (!grammar.hasOwnProperty(token) || !grammar[token]) continue;
+		var patterns = grammar[token];
+		patterns = Array.isArray(patterns) ? patterns : [patterns];
+		for (var j = 0; j < patterns.length; ++j) {
+			if (rematch && rematch.cause == token + "," + j) return;
+			var patternObj = patterns[j];
+			var inside = patternObj.inside;
+			var lookbehind = !!patternObj.lookbehind;
+			var greedy = !!patternObj.greedy;
+			var alias = patternObj.alias;
+			if (greedy && !patternObj.pattern.global) {
+				var flags = patternObj.pattern.toString().match(/[imsuy]*$/)[0];
+				patternObj.pattern = RegExp(patternObj.pattern.source, flags + "g");
+			}
+			/** @type {RegExp} */
+			var pattern = patternObj.pattern || patternObj;
+			for (var currentNode = startNode.next, pos = startPos; currentNode !== tokenList.tail; pos += currentNode.value.length, currentNode = currentNode.next) {
+				if (rematch && pos >= rematch.reach) break;
+				var str = currentNode.value;
+				if (tokenList.length > text.length) return;
+				if (str instanceof Token) continue;
+				var removeCount = 1;
+				var match;
+				if (greedy) {
+					match = matchPattern(pattern, pos, text, lookbehind);
+					if (!match || match.index >= text.length) break;
+					var from = match.index;
+					var to = match.index + match[0].length;
+					var p = pos;
+					p += currentNode.value.length;
+					while (from >= p) {
+						currentNode = currentNode.next;
+						p += currentNode.value.length;
+					}
+					p -= currentNode.value.length;
+					pos = p;
+					if (currentNode.value instanceof Token) continue;
+					for (var k = currentNode; k !== tokenList.tail && (p < to || typeof k.value === "string"); k = k.next) {
+						removeCount++;
+						p += k.value.length;
+					}
+					removeCount--;
+					str = text.slice(pos, p);
+					match.index -= pos;
+				} else {
+					match = matchPattern(pattern, 0, str, lookbehind);
+					if (!match) continue;
+				}
+				var from = match.index;
+				var matchStr = match[0];
+				var before = str.slice(0, from);
+				var after = str.slice(from + matchStr.length);
+				var reach = pos + str.length;
+				if (rematch && reach > rematch.reach) rematch.reach = reach;
+				var removeFrom = currentNode.prev;
+				if (before) {
+					removeFrom = addAfter(tokenList, removeFrom, before);
+					pos += before.length;
+				}
+				removeRange(tokenList, removeFrom, removeCount);
+				var wrapped = new Token(token, inside ? _.tokenize(matchStr, inside) : matchStr, alias, matchStr);
+				currentNode = addAfter(tokenList, removeFrom, wrapped);
+				if (after) addAfter(tokenList, currentNode, after);
+				if (removeCount > 1) {
+					/** @type {RematchOptions} */
+					var nestedRematch = {
+						cause: token + "," + j,
+						reach
+					};
+					matchGrammar(text, tokenList, grammar, currentNode.prev, pos, nestedRematch);
+					if (rematch && nestedRematch.reach > rematch.reach) rematch.reach = nestedRematch.reach;
+				}
+			}
+		}
+	}
+}
+/**
+* @typedef LinkedListNode
+* @property {T} value
+* @property {LinkedListNode<T> | null} prev The previous node.
+* @property {LinkedListNode<T> | null} next The next node.
+* @template T
+* @private
+*/
+/**
+* @template T
+* @private
+*/
+function LinkedList() {
+	/** @type {LinkedListNode<T>} */
+	var head = {
+		value: null,
+		prev: null,
+		next: null
+	};
+	/** @type {LinkedListNode<T>} */
+	var tail = {
+		value: null,
+		prev: head,
+		next: null
+	};
+	head.next = tail;
+	/** @type {LinkedListNode<T>} */
+	this.head = head;
+	/** @type {LinkedListNode<T>} */
+	this.tail = tail;
+	this.length = 0;
+}
+/**
+* Adds a new node with the given value to the list.
+*
+* @param {LinkedList<T>} list
+* @param {LinkedListNode<T>} node
+* @param {T} value
+* @returns {LinkedListNode<T>} The added node.
+* @template T
+*/
+function addAfter(list, node, value) {
+	var next = node.next;
+	var newNode = {
+		value,
+		prev: node,
+		next
+	};
+	node.next = newNode;
+	next.prev = newNode;
+	list.length++;
+	return newNode;
+}
+/**
+* Removes `count` nodes after the given node. The given node will not be removed.
+*
+* @param {LinkedList<T>} list
+* @param {LinkedListNode<T>} node
+* @param {number} count
+* @template T
+*/
+function removeRange(list, node, count) {
+	var next = node.next;
+	for (var i = 0; i < count && next !== list.tail; i++) next = next.next;
+	node.next = next;
+	next.prev = node;
+	list.length -= i;
+}
+/**
+* @param {LinkedList<T>} list
+* @returns {T[]}
+* @template T
+*/
+function toArray(list) {
+	var array = [];
+	var node = list.head.next;
+	while (node !== list.tail) {
+		array.push(node.value);
+		node = node.next;
+	}
+	return array;
+}
+const Prism = _;
+
+//#endregion
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lib/core.js
+/**
+* @import {Element, Root, Text} from 'hast'
+* @import {Grammar, Languages} from 'prismjs'
+*/
+/**
+* @typedef _Token
+*   Hidden Prism token.
+* @property {string} alias
+*   Alias.
+* @property {string} content
+*   Content.
+* @property {number} length
+*   Length.
+* @property {string} type
+*   Type.
+*/
+/**
+* @typedef _Env
+*   Hidden Prism environment.
+* @property {Record<string, string>} attributes
+*   Attributes.
+* @property {Array<string>} classes
+*   Classes.
+* @property {Array<Element | Text> | Element | Text} content
+*   Content.
+* @property {string} language
+*   Language.
+* @property {string} tag
+*   Tag.
+* @property {string} type
+*   Type.
+*/
+/**
+* @typedef {((prism: Refractor) => undefined | void) & {aliases?: Array<string> | undefined, displayName: string}} Syntax
+*   Refractor syntax function.
+*/
+/**
+* @typedef Refractor
+*   Virtual syntax highlighting
+* @property {typeof alias} alias
+* @property {Languages} languages
+* @property {typeof listLanguages} listLanguages
+* @property {typeof highlight} highlight
+* @property {typeof registered} registered
+* @property {typeof register} register
+*/
+var core_exports = /* @__PURE__ */ __exportAll({ refractor: () => refractor });
+function Refractor() {}
+Refractor.prototype = Prism;
+/** @type {Refractor} */
+const refractor = new Refractor();
+refractor.highlight = highlight;
+refractor.register = register;
+refractor.alias = alias;
+refractor.registered = registered;
+refractor.listLanguages = listLanguages;
+refractor.util.encode = encode;
+refractor.Token.stringify = stringify;
+/**
+* Highlight `value` (code) as `language` (programming language).
+*
+* @param {string} value
+*   Code to highlight.
+* @param {Grammar | string} language
+*   Programming language name, alias, or grammar.
+* @returns {Root}
+*   Node representing highlighted code.
+*/
+function highlight(value, language) {
+	if (typeof value !== "string") throw new TypeError("Expected `string` for `value`, got `" + value + "`");
+	/** @type {Grammar} */
+	let grammar;
+	/** @type {string | undefined} */
+	let name;
+	/* c8 ignore next 2 */
+	if (language && typeof language === "object") grammar = language;
+	else {
+		name = language;
+		if (typeof name !== "string") throw new TypeError("Expected `string` for `name`, got `" + name + "`");
+		if (Object.hasOwn(refractor.languages, name)) grammar = refractor.languages[name];
+		else throw new Error("Unknown language: `" + name + "` is not registered");
+	}
+	return {
+		type: "root",
+		children: Prism.highlight.call(refractor, value, grammar, name)
+	};
+}
+/**
+* Register a syntax.
+*
+* @param {Syntax} syntax
+*   Language function made for refractor, as in, the files in
+*   `refractor/lang/*.js`.
+* @returns {undefined}
+*   Nothing.
+*/
+function register(syntax) {
+	if (typeof syntax !== "function" || !syntax.displayName) throw new Error("Expected `function` for `syntax`, got `" + syntax + "`");
+	if (!Object.hasOwn(refractor.languages, syntax.displayName)) syntax(refractor);
+}
+/**
+* Register aliases for already registered languages.
+*
+* @param {Record<string, ReadonlyArray<string> | string> | string} language
+*   Language to alias.
+* @param {ReadonlyArray<string> | string | null | undefined} [alias]
+*   Aliases.
+* @returns {undefined}
+*   Nothing.
+*/
+function alias(language, alias) {
+	const languages = refractor.languages;
+	/** @type {Record<string, ReadonlyArray<string> | string>} */
+	let map = {};
+	if (typeof language === "string") {
+		if (alias) map[language] = alias;
+	} else map = language;
+	/** @type {string} */
+	let key;
+	for (key in map) if (Object.hasOwn(map, key)) {
+		const value = map[key];
+		const list = typeof value === "string" ? [value] : value;
+		let index = -1;
+		while (++index < list.length) languages[list[index]] = languages[key];
+	}
+}
+/**
+* Check whether an `alias` or `language` is registered.
+*
+* @param {string} aliasOrLanguage
+*   Language or alias to check.
+* @returns {boolean}
+*   Whether the language is registered.
+*/
+function registered(aliasOrLanguage) {
+	if (typeof aliasOrLanguage !== "string") throw new TypeError("Expected `string` for `aliasOrLanguage`, got `" + aliasOrLanguage + "`");
+	return Object.hasOwn(refractor.languages, aliasOrLanguage);
+}
+/**
+* List all registered languages (names and aliases).
+*
+* @returns {Array<string>}
+*   List of language names.
+*/
+function listLanguages() {
+	const languages = refractor.languages;
+	/** @type {Array<string>} */
+	const list = [];
+	/** @type {string} */
+	let language;
+	for (language in languages) if (Object.hasOwn(languages, language) && typeof languages[language] === "object") list.push(language);
+	return list;
+}
+/**
+* @param {Array<_Token | string> | _Token | string} value
+*   Token to stringify.
+* @param {string} language
+*   Language of the token.
+* @returns {Array<Element | Text> | Element | Text}
+*   Node representing the token.
+*/
+function stringify(value, language) {
+	if (typeof value === "string") return {
+		type: "text",
+		value
+	};
+	if (Array.isArray(value)) {
+		/** @type {Array<Element | Text>} */
+		const result = [];
+		let index = -1;
+		while (++index < value.length) if (value[index] !== null && value[index] !== void 0 && value[index] !== "") result.push(stringify(value[index], language));
+		return result;
+	}
+	/** @type {_Env} */
+	const env = {
+		attributes: {},
+		classes: ["token", value.type],
+		content: stringify(value.content, language),
+		language,
+		tag: "span",
+		type: value.type
+	};
+	if (value.alias) env.classes.push(...typeof value.alias === "string" ? [value.alias] : value.alias);
+	refractor.hooks.run("wrap", env);
+	return h(env.tag + "." + env.classes.join("."), attributes(env.attributes), env.content);
+}
+/**
+* @template {unknown} T
+*   Tokens.
+* @param {T} tokens
+*   Input.
+* @returns {T}
+*   Output, same as input.
+*/
+function encode(tokens) {
+	return tokens;
+}
+/**
+* @param {Record<string, string>} record
+*   Attributes.
+* @returns {Record<string, string>}
+*   Attributes.
+*/
+function attributes(record) {
+	/** @type {string} */
+	let key;
+	for (key in record) if (Object.hasOwn(record, key)) record[key] = parseEntities(record[key]);
+	return record;
+}
+
+//#endregion
+export { svg as a, html as i, refractor as n, find as o, stringify$1 as r, stringify$2 as s, core_exports as t };