feat(vanilla): add testing infrastructure and tests (NK-wjnczv)

1 files changed, 5538 insertions, 0 deletions

diff --git a/vanilla/node_modules/vite/dist/node/chunks/build2.js b/vanilla/node_modules/vite/dist/node/chunks/build2.js
new file mode 100644
index 0000000..c7ecfa3
--- /dev/null
+++ b/vanilla/node_modules/vite/dist/node/chunks/build2.js
@@ -0,0 +1,5538 @@
+import { i as __require, t as __commonJSMin } from "./chunk.js";
+import { t as require_lib } from "./lib.js";
+
+//#region ../../node_modules/.pnpm/postcss-modules@6.0.1_postcss@8.5.6/node_modules/postcss-modules/build/fs.js
+var require_fs = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.getFileSystem = getFileSystem;
+	exports.setFileSystem = setFileSystem;
+	let fileSystem = {
+		readFile: () => {
+			throw Error("readFile not implemented");
+		},
+		writeFile: () => {
+			throw Error("writeFile not implemented");
+		}
+	};
+	function setFileSystem(fs) {
+		fileSystem.readFile = fs.readFile;
+		fileSystem.writeFile = fs.writeFile;
+	}
+	function getFileSystem() {
+		return fileSystem;
+	}
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-modules@6.0.1_postcss@8.5.6/node_modules/postcss-modules/build/unquote.js
+var require_unquote = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.default = unquote;
+	const reg = /['"]/;
+	function unquote(str$1) {
+		if (!str$1) return "";
+		if (reg.test(str$1.charAt(0))) str$1 = str$1.substr(1);
+		if (reg.test(str$1.charAt(str$1.length - 1))) str$1 = str$1.substr(0, str$1.length - 1);
+		return str$1;
+	}
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/icss-utils@5.1.0_postcss@8.5.6/node_modules/icss-utils/src/replaceValueSymbols.js
+var require_replaceValueSymbols = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const matchValueName = /[$]?[\w-]+/g;
+	const replaceValueSymbols$2 = (value, replacements) => {
+		let matches;
+		while (matches = matchValueName.exec(value)) {
+			const replacement = replacements[matches[0]];
+			if (replacement) {
+				value = value.slice(0, matches.index) + replacement + value.slice(matchValueName.lastIndex);
+				matchValueName.lastIndex -= matches[0].length - replacement.length;
+			}
+		}
+		return value;
+	};
+	module.exports = replaceValueSymbols$2;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/icss-utils@5.1.0_postcss@8.5.6/node_modules/icss-utils/src/replaceSymbols.js
+var require_replaceSymbols = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const replaceValueSymbols$1 = require_replaceValueSymbols();
+	const replaceSymbols$1 = (css, replacements) => {
+		css.walk((node) => {
+			if (node.type === "decl" && node.value) node.value = replaceValueSymbols$1(node.value.toString(), replacements);
+			else if (node.type === "rule" && node.selector) node.selector = replaceValueSymbols$1(node.selector.toString(), replacements);
+			else if (node.type === "atrule" && node.params) node.params = replaceValueSymbols$1(node.params.toString(), replacements);
+		});
+	};
+	module.exports = replaceSymbols$1;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/icss-utils@5.1.0_postcss@8.5.6/node_modules/icss-utils/src/extractICSS.js
+var require_extractICSS = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const importPattern = /^:import\(("[^"]*"|'[^']*'|[^"']+)\)$/;
+	const balancedQuotes = /^("[^"]*"|'[^']*'|[^"']+)$/;
+	const getDeclsObject = (rule) => {
+		const object = {};
+		rule.walkDecls((decl) => {
+			const before = decl.raws.before ? decl.raws.before.trim() : "";
+			object[before + decl.prop] = decl.value;
+		});
+		return object;
+	};
+	/**
+	*
+	* @param {string} css
+	* @param {boolean} removeRules
+	* @param {'auto' | 'rule' | 'at-rule'} mode
+	*/
+	const extractICSS$2 = (css, removeRules = true, mode = "auto") => {
+		const icssImports = {};
+		const icssExports = {};
+		function addImports(node, path$2) {
+			const unquoted = path$2.replace(/'|"/g, "");
+			icssImports[unquoted] = Object.assign(icssImports[unquoted] || {}, getDeclsObject(node));
+			if (removeRules) node.remove();
+		}
+		function addExports(node) {
+			Object.assign(icssExports, getDeclsObject(node));
+			if (removeRules) node.remove();
+		}
+		css.each((node) => {
+			if (node.type === "rule" && mode !== "at-rule") {
+				if (node.selector.slice(0, 7) === ":import") {
+					const matches = importPattern.exec(node.selector);
+					if (matches) addImports(node, matches[1]);
+				}
+				if (node.selector === ":export") addExports(node);
+			}
+			if (node.type === "atrule" && mode !== "rule") {
+				if (node.name === "icss-import") {
+					const matches = balancedQuotes.exec(node.params);
+					if (matches) addImports(node, matches[1]);
+				}
+				if (node.name === "icss-export") addExports(node);
+			}
+		});
+		return {
+			icssImports,
+			icssExports
+		};
+	};
+	module.exports = extractICSS$2;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/icss-utils@5.1.0_postcss@8.5.6/node_modules/icss-utils/src/createICSSRules.js
+var require_createICSSRules = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const createImports = (imports, postcss, mode = "rule") => {
+		return Object.keys(imports).map((path$2) => {
+			const aliases = imports[path$2];
+			const declarations = Object.keys(aliases).map((key) => postcss.decl({
+				prop: key,
+				value: aliases[key],
+				raws: { before: "\n  " }
+			}));
+			const hasDeclarations = declarations.length > 0;
+			const rule = mode === "rule" ? postcss.rule({
+				selector: `:import('${path$2}')`,
+				raws: { after: hasDeclarations ? "\n" : "" }
+			}) : postcss.atRule({
+				name: "icss-import",
+				params: `'${path$2}'`,
+				raws: { after: hasDeclarations ? "\n" : "" }
+			});
+			if (hasDeclarations) rule.append(declarations);
+			return rule;
+		});
+	};
+	const createExports = (exports$1, postcss, mode = "rule") => {
+		const declarations = Object.keys(exports$1).map((key) => postcss.decl({
+			prop: key,
+			value: exports$1[key],
+			raws: { before: "\n  " }
+		}));
+		if (declarations.length === 0) return [];
+		const rule = mode === "rule" ? postcss.rule({
+			selector: `:export`,
+			raws: { after: "\n" }
+		}) : postcss.atRule({
+			name: "icss-export",
+			raws: { after: "\n" }
+		});
+		rule.append(declarations);
+		return [rule];
+	};
+	const createICSSRules$1 = (imports, exports$1, postcss, mode) => [...createImports(imports, postcss, mode), ...createExports(exports$1, postcss, mode)];
+	module.exports = createICSSRules$1;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/icss-utils@5.1.0_postcss@8.5.6/node_modules/icss-utils/src/index.js
+var require_src$4 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const replaceValueSymbols = require_replaceValueSymbols();
+	const replaceSymbols = require_replaceSymbols();
+	const extractICSS$1 = require_extractICSS();
+	const createICSSRules = require_createICSSRules();
+	module.exports = {
+		replaceValueSymbols,
+		replaceSymbols,
+		extractICSS: extractICSS$1,
+		createICSSRules
+	};
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-modules@6.0.1_postcss@8.5.6/node_modules/postcss-modules/build/Parser.js
+var require_Parser = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.default = void 0;
+	var _icssUtils = require_src$4();
+	const importRegexp = /^:import\((.+)\)$/;
+	var Parser$1 = class {
+		constructor(pathFetcher, trace) {
+			this.pathFetcher = pathFetcher;
+			this.plugin = this.plugin.bind(this);
+			this.exportTokens = {};
+			this.translations = {};
+			this.trace = trace;
+		}
+		plugin() {
+			const parser$1 = this;
+			return {
+				postcssPlugin: "css-modules-parser",
+				async OnceExit(css) {
+					await Promise.all(parser$1.fetchAllImports(css));
+					parser$1.linkImportedSymbols(css);
+					return parser$1.extractExports(css);
+				}
+			};
+		}
+		fetchAllImports(css) {
+			let imports = [];
+			css.each((node) => {
+				if (node.type == "rule" && node.selector.match(importRegexp)) imports.push(this.fetchImport(node, css.source.input.from, imports.length));
+			});
+			return imports;
+		}
+		linkImportedSymbols(css) {
+			(0, _icssUtils.replaceSymbols)(css, this.translations);
+		}
+		extractExports(css) {
+			css.each((node) => {
+				if (node.type == "rule" && node.selector == ":export") this.handleExport(node);
+			});
+		}
+		handleExport(exportNode) {
+			exportNode.each((decl) => {
+				if (decl.type == "decl") {
+					Object.keys(this.translations).forEach((translation) => {
+						decl.value = decl.value.replace(translation, this.translations[translation]);
+					});
+					this.exportTokens[decl.prop] = decl.value;
+				}
+			});
+			exportNode.remove();
+		}
+		async fetchImport(importNode, relativeTo, depNr) {
+			const file = importNode.selector.match(importRegexp)[1];
+			const depTrace = this.trace + String.fromCharCode(depNr);
+			const exports$1 = await this.pathFetcher(file, relativeTo, depTrace);
+			try {
+				importNode.each((decl) => {
+					if (decl.type == "decl") this.translations[decl.prop] = exports$1[decl.value];
+				});
+				importNode.remove();
+			} catch (err) {
+				console.log(err);
+			}
+		}
+	};
+	exports.default = Parser$1;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-modules@6.0.1_postcss@8.5.6/node_modules/postcss-modules/build/saveJSON.js
+var require_saveJSON = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.default = saveJSON;
+	var _fs$2 = require_fs();
+	function saveJSON(cssFile, json) {
+		return new Promise((resolve, reject) => {
+			const { writeFile } = (0, _fs$2.getFileSystem)();
+			writeFile(`${cssFile}.json`, JSON.stringify(json), (e) => e ? reject(e) : resolve(json));
+		});
+	}
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash.camelcase@4.3.0/node_modules/lodash.camelcase/index.js
+var require_lodash = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* lodash (Custom Build) <https://lodash.com/>
+	* Build: `lodash modularize exports="npm" -o ./`
+	* Copyright jQuery Foundation and other contributors <https://jquery.org/>
+	* Released under MIT license <https://lodash.com/license>
+	* Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
+	* Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+	*/
+	/** Used as references for various `Number` constants. */
+	var INFINITY = Infinity;
+	/** `Object#toString` result references. */
+	var symbolTag = "[object Symbol]";
+	/** Used to match words composed of alphanumeric characters. */
+	var reAsciiWord = /[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g;
+	/** Used to match Latin Unicode letters (excluding mathematical operators). */
+	var reLatin = /[\xc0-\xd6\xd8-\xf6\xf8-\xff\u0100-\u017f]/g;
+	/** Used to compose unicode character classes. */
+	var rsAstralRange = "\\ud800-\\udfff", rsComboMarksRange = "\\u0300-\\u036f\\ufe20-\\ufe23", rsComboSymbolsRange = "\\u20d0-\\u20f0", rsDingbatRange = "\\u2700-\\u27bf", rsLowerRange = "a-z\\xdf-\\xf6\\xf8-\\xff", rsMathOpRange = "\\xac\\xb1\\xd7\\xf7", rsNonCharRange = "\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf", rsPunctuationRange = "\\u2000-\\u206f", rsSpaceRange = " \\t\\x0b\\f\\xa0\\ufeff\\n\\r\\u2028\\u2029\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000", rsUpperRange = "A-Z\\xc0-\\xd6\\xd8-\\xde", rsVarRange = "\\ufe0e\\ufe0f", rsBreakRange = rsMathOpRange + rsNonCharRange + rsPunctuationRange + rsSpaceRange;
+	/** Used to compose unicode capture groups. */
+	var rsApos = "['’]", rsAstral = "[" + rsAstralRange + "]", rsBreak = "[" + rsBreakRange + "]", rsCombo = "[" + rsComboMarksRange + rsComboSymbolsRange + "]", rsDigits = "\\d+", rsDingbat = "[" + rsDingbatRange + "]", rsLower = "[" + rsLowerRange + "]", rsMisc = "[^" + rsAstralRange + rsBreakRange + rsDigits + rsDingbatRange + rsLowerRange + rsUpperRange + "]", rsFitz = "\\ud83c[\\udffb-\\udfff]", rsModifier = "(?:" + rsCombo + "|" + rsFitz + ")", rsNonAstral = "[^" + rsAstralRange + "]", rsRegional = "(?:\\ud83c[\\udde6-\\uddff]){2}", rsSurrPair = "[\\ud800-\\udbff][\\udc00-\\udfff]", rsUpper = "[" + rsUpperRange + "]", rsZWJ = "\\u200d";
+	/** Used to compose unicode regexes. */
+	var rsLowerMisc = "(?:" + rsLower + "|" + rsMisc + ")", rsUpperMisc = "(?:" + rsUpper + "|" + rsMisc + ")", rsOptLowerContr = "(?:" + rsApos + "(?:d|ll|m|re|s|t|ve))?", rsOptUpperContr = "(?:" + rsApos + "(?:D|LL|M|RE|S|T|VE))?", reOptMod = rsModifier + "?", rsOptVar = "[" + rsVarRange + "]?", rsOptJoin = "(?:" + rsZWJ + "(?:" + [
+		rsNonAstral,
+		rsRegional,
+		rsSurrPair
+	].join("|") + ")" + rsOptVar + reOptMod + ")*", rsSeq = rsOptVar + reOptMod + rsOptJoin, rsEmoji = "(?:" + [
+		rsDingbat,
+		rsRegional,
+		rsSurrPair
+	].join("|") + ")" + rsSeq, rsSymbol = "(?:" + [
+		rsNonAstral + rsCombo + "?",
+		rsCombo,
+		rsRegional,
+		rsSurrPair,
+		rsAstral
+	].join("|") + ")";
+	/** Used to match apostrophes. */
+	var reApos = RegExp(rsApos, "g");
+	/**
+	* Used to match [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks) and
+	* [combining diacritical marks for symbols](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks_for_Symbols).
+	*/
+	var reComboMark = RegExp(rsCombo, "g");
+	/** Used to match [string symbols](https://mathiasbynens.be/notes/javascript-unicode). */
+	var reUnicode = RegExp(rsFitz + "(?=" + rsFitz + ")|" + rsSymbol + rsSeq, "g");
+	/** Used to match complex or compound words. */
+	var reUnicodeWord = RegExp([
+		rsUpper + "?" + rsLower + "+" + rsOptLowerContr + "(?=" + [
+			rsBreak,
+			rsUpper,
+			"$"
+		].join("|") + ")",
+		rsUpperMisc + "+" + rsOptUpperContr + "(?=" + [
+			rsBreak,
+			rsUpper + rsLowerMisc,
+			"$"
+		].join("|") + ")",
+		rsUpper + "?" + rsLowerMisc + "+" + rsOptLowerContr,
+		rsUpper + "+" + rsOptUpperContr,
+		rsDigits,
+		rsEmoji
+	].join("|"), "g");
+	/** Used to detect strings with [zero-width joiners or code points from the astral planes](http://eev.ee/blog/2015/09/12/dark-corners-of-unicode/). */
+	var reHasUnicode = RegExp("[" + rsZWJ + rsAstralRange + rsComboMarksRange + rsComboSymbolsRange + rsVarRange + "]");
+	/** Used to detect strings that need a more robust regexp to match words. */
+	var reHasUnicodeWord = /[a-z][A-Z]|[A-Z]{2,}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/;
+	/** Used to map Latin Unicode letters to basic Latin letters. */
+	var deburredLetters = {
+		"À": "A",
+		"Á": "A",
+		"Â": "A",
+		"Ã": "A",
+		"Ä": "A",
+		"Å": "A",
+		"à": "a",
+		"á": "a",
+		"â": "a",
+		"ã": "a",
+		"ä": "a",
+		"å": "a",
+		"Ç": "C",
+		"ç": "c",
+		"Ð": "D",
+		"ð": "d",
+		"È": "E",
+		"É": "E",
+		"Ê": "E",
+		"Ë": "E",
+		"è": "e",
+		"é": "e",
+		"ê": "e",
+		"ë": "e",
+		"Ì": "I",
+		"Í": "I",
+		"Î": "I",
+		"Ï": "I",
+		"ì": "i",
+		"í": "i",
+		"î": "i",
+		"ï": "i",
+		"Ñ": "N",
+		"ñ": "n",
+		"Ò": "O",
+		"Ó": "O",
+		"Ô": "O",
+		"Õ": "O",
+		"Ö": "O",
+		"Ø": "O",
+		"ò": "o",
+		"ó": "o",
+		"ô": "o",
+		"õ": "o",
+		"ö": "o",
+		"ø": "o",
+		"Ù": "U",
+		"Ú": "U",
+		"Û": "U",
+		"Ü": "U",
+		"ù": "u",
+		"ú": "u",
+		"û": "u",
+		"ü": "u",
+		"Ý": "Y",
+		"ý": "y",
+		"ÿ": "y",
+		"Æ": "Ae",
+		"æ": "ae",
+		"Þ": "Th",
+		"þ": "th",
+		"ß": "ss",
+		"Ā": "A",
+		"Ă": "A",
+		"Ą": "A",
+		"ā": "a",
+		"ă": "a",
+		"ą": "a",
+		"Ć": "C",
+		"Ĉ": "C",
+		"Ċ": "C",
+		"Č": "C",
+		"ć": "c",
+		"ĉ": "c",
+		"ċ": "c",
+		"č": "c",
+		"Ď": "D",
+		"Đ": "D",
+		"ď": "d",
+		"đ": "d",
+		"Ē": "E",
+		"Ĕ": "E",
+		"Ė": "E",
+		"Ę": "E",
+		"Ě": "E",
+		"ē": "e",
+		"ĕ": "e",
+		"ė": "e",
+		"ę": "e",
+		"ě": "e",
+		"Ĝ": "G",
+		"Ğ": "G",
+		"Ġ": "G",
+		"Ģ": "G",
+		"ĝ": "g",
+		"ğ": "g",
+		"ġ": "g",
+		"ģ": "g",
+		"Ĥ": "H",
+		"Ħ": "H",
+		"ĥ": "h",
+		"ħ": "h",
+		"Ĩ": "I",
+		"Ī": "I",
+		"Ĭ": "I",
+		"Į": "I",
+		"İ": "I",
+		"ĩ": "i",
+		"ī": "i",
+		"ĭ": "i",
+		"į": "i",
+		"ı": "i",
+		"Ĵ": "J",
+		"ĵ": "j",
+		"Ķ": "K",
+		"ķ": "k",
+		"ĸ": "k",
+		"Ĺ": "L",
+		"Ļ": "L",
+		"Ľ": "L",
+		"Ŀ": "L",
+		"Ł": "L",
+		"ĺ": "l",
+		"ļ": "l",
+		"ľ": "l",
+		"ŀ": "l",
+		"ł": "l",
+		"Ń": "N",
+		"Ņ": "N",
+		"Ň": "N",
+		"Ŋ": "N",
+		"ń": "n",
+		"ņ": "n",
+		"ň": "n",
+		"ŋ": "n",
+		"Ō": "O",
+		"Ŏ": "O",
+		"Ő": "O",
+		"ō": "o",
+		"ŏ": "o",
+		"ő": "o",
+		"Ŕ": "R",
+		"Ŗ": "R",
+		"Ř": "R",
+		"ŕ": "r",
+		"ŗ": "r",
+		"ř": "r",
+		"Ś": "S",
+		"Ŝ": "S",
+		"Ş": "S",
+		"Š": "S",
+		"ś": "s",
+		"ŝ": "s",
+		"ş": "s",
+		"š": "s",
+		"Ţ": "T",
+		"Ť": "T",
+		"Ŧ": "T",
+		"ţ": "t",
+		"ť": "t",
+		"ŧ": "t",
+		"Ũ": "U",
+		"Ū": "U",
+		"Ŭ": "U",
+		"Ů": "U",
+		"Ű": "U",
+		"Ų": "U",
+		"ũ": "u",
+		"ū": "u",
+		"ŭ": "u",
+		"ů": "u",
+		"ű": "u",
+		"ų": "u",
+		"Ŵ": "W",
+		"ŵ": "w",
+		"Ŷ": "Y",
+		"ŷ": "y",
+		"Ÿ": "Y",
+		"Ź": "Z",
+		"Ż": "Z",
+		"Ž": "Z",
+		"ź": "z",
+		"ż": "z",
+		"ž": "z",
+		"IJ": "IJ",
+		"ij": "ij",
+		"Œ": "Oe",
+		"œ": "oe",
+		"ʼn": "'n",
+		"ſ": "ss"
+	};
+	/** Detect free variable `global` from Node.js. */
+	var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
+	/** Detect free variable `self`. */
+	var freeSelf = typeof self == "object" && self && self.Object === Object && self;
+	/** Used as a reference to the global object. */
+	var root$1 = freeGlobal || freeSelf || Function("return this")();
+	/**
+	* A specialized version of `_.reduce` for arrays without support for
+	* iteratee shorthands.
+	*
+	* @private
+	* @param {Array} [array] The array to iterate over.
+	* @param {Function} iteratee The function invoked per iteration.
+	* @param {*} [accumulator] The initial value.
+	* @param {boolean} [initAccum] Specify using the first element of `array` as
+	*  the initial value.
+	* @returns {*} Returns the accumulated value.
+	*/
+	function arrayReduce(array, iteratee, accumulator, initAccum) {
+		var index = -1, length = array ? array.length : 0;
+		if (initAccum && length) accumulator = array[++index];
+		while (++index < length) accumulator = iteratee(accumulator, array[index], index, array);
+		return accumulator;
+	}
+	/**
+	* Converts an ASCII `string` to an array.
+	*
+	* @private
+	* @param {string} string The string to convert.
+	* @returns {Array} Returns the converted array.
+	*/
+	function asciiToArray(string$1) {
+		return string$1.split("");
+	}
+	/**
+	* Splits an ASCII `string` into an array of its words.
+	*
+	* @private
+	* @param {string} The string to inspect.
+	* @returns {Array} Returns the words of `string`.
+	*/
+	function asciiWords(string$1) {
+		return string$1.match(reAsciiWord) || [];
+	}
+	/**
+	* The base implementation of `_.propertyOf` without support for deep paths.
+	*
+	* @private
+	* @param {Object} object The object to query.
+	* @returns {Function} Returns the new accessor function.
+	*/
+	function basePropertyOf(object) {
+		return function(key) {
+			return object == null ? void 0 : object[key];
+		};
+	}
+	/**
+	* Used by `_.deburr` to convert Latin-1 Supplement and Latin Extended-A
+	* letters to basic Latin letters.
+	*
+	* @private
+	* @param {string} letter The matched letter to deburr.
+	* @returns {string} Returns the deburred letter.
+	*/
+	var deburrLetter = basePropertyOf(deburredLetters);
+	/**
+	* Checks if `string` contains Unicode symbols.
+	*
+	* @private
+	* @param {string} string The string to inspect.
+	* @returns {boolean} Returns `true` if a symbol is found, else `false`.
+	*/
+	function hasUnicode(string$1) {
+		return reHasUnicode.test(string$1);
+	}
+	/**
+	* Checks if `string` contains a word composed of Unicode symbols.
+	*
+	* @private
+	* @param {string} string The string to inspect.
+	* @returns {boolean} Returns `true` if a word is found, else `false`.
+	*/
+	function hasUnicodeWord(string$1) {
+		return reHasUnicodeWord.test(string$1);
+	}
+	/**
+	* Converts `string` to an array.
+	*
+	* @private
+	* @param {string} string The string to convert.
+	* @returns {Array} Returns the converted array.
+	*/
+	function stringToArray(string$1) {
+		return hasUnicode(string$1) ? unicodeToArray(string$1) : asciiToArray(string$1);
+	}
+	/**
+	* Converts a Unicode `string` to an array.
+	*
+	* @private
+	* @param {string} string The string to convert.
+	* @returns {Array} Returns the converted array.
+	*/
+	function unicodeToArray(string$1) {
+		return string$1.match(reUnicode) || [];
+	}
+	/**
+	* Splits a Unicode `string` into an array of its words.
+	*
+	* @private
+	* @param {string} The string to inspect.
+	* @returns {Array} Returns the words of `string`.
+	*/
+	function unicodeWords(string$1) {
+		return string$1.match(reUnicodeWord) || [];
+	}
+	/**
+	* Used to resolve the
+	* [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+	* of values.
+	*/
+	var objectToString = Object.prototype.toString;
+	/** Built-in value references. */
+	var Symbol$1 = root$1.Symbol;
+	/** Used to convert symbols to primitives and strings. */
+	var symbolProto = Symbol$1 ? Symbol$1.prototype : void 0, symbolToString = symbolProto ? symbolProto.toString : void 0;
+	/**
+	* The base implementation of `_.slice` without an iteratee call guard.
+	*
+	* @private
+	* @param {Array} array The array to slice.
+	* @param {number} [start=0] The start position.
+	* @param {number} [end=array.length] The end position.
+	* @returns {Array} Returns the slice of `array`.
+	*/
+	function baseSlice(array, start, end) {
+		var index = -1, length = array.length;
+		if (start < 0) start = -start > length ? 0 : length + start;
+		end = end > length ? length : end;
+		if (end < 0) end += length;
+		length = start > end ? 0 : end - start >>> 0;
+		start >>>= 0;
+		var result = Array(length);
+		while (++index < length) result[index] = array[index + start];
+		return result;
+	}
+	/**
+	* The base implementation of `_.toString` which doesn't convert nullish
+	* values to empty strings.
+	*
+	* @private
+	* @param {*} value The value to process.
+	* @returns {string} Returns the string.
+	*/
+	function baseToString(value) {
+		if (typeof value == "string") return value;
+		if (isSymbol(value)) return symbolToString ? symbolToString.call(value) : "";
+		var result = value + "";
+		return result == "0" && 1 / value == -INFINITY ? "-0" : result;
+	}
+	/**
+	* Casts `array` to a slice if it's needed.
+	*
+	* @private
+	* @param {Array} array The array to inspect.
+	* @param {number} start The start position.
+	* @param {number} [end=array.length] The end position.
+	* @returns {Array} Returns the cast slice.
+	*/
+	function castSlice(array, start, end) {
+		var length = array.length;
+		end = end === void 0 ? length : end;
+		return !start && end >= length ? array : baseSlice(array, start, end);
+	}
+	/**
+	* Creates a function like `_.lowerFirst`.
+	*
+	* @private
+	* @param {string} methodName The name of the `String` case method to use.
+	* @returns {Function} Returns the new case function.
+	*/
+	function createCaseFirst(methodName) {
+		return function(string$1) {
+			string$1 = toString(string$1);
+			var strSymbols = hasUnicode(string$1) ? stringToArray(string$1) : void 0;
+			var chr = strSymbols ? strSymbols[0] : string$1.charAt(0);
+			var trailing = strSymbols ? castSlice(strSymbols, 1).join("") : string$1.slice(1);
+			return chr[methodName]() + trailing;
+		};
+	}
+	/**
+	* Creates a function like `_.camelCase`.
+	*
+	* @private
+	* @param {Function} callback The function to combine each word.
+	* @returns {Function} Returns the new compounder function.
+	*/
+	function createCompounder(callback) {
+		return function(string$1) {
+			return arrayReduce(words(deburr(string$1).replace(reApos, "")), callback, "");
+		};
+	}
+	/**
+	* Checks if `value` is object-like. A value is object-like if it's not `null`
+	* and has a `typeof` result of "object".
+	*
+	* @static
+	* @memberOf _
+	* @since 4.0.0
+	* @category Lang
+	* @param {*} value The value to check.
+	* @returns {boolean} Returns `true` if `value` is object-like, else `false`.
+	* @example
+	*
+	* _.isObjectLike({});
+	* // => true
+	*
+	* _.isObjectLike([1, 2, 3]);
+	* // => true
+	*
+	* _.isObjectLike(_.noop);
+	* // => false
+	*
+	* _.isObjectLike(null);
+	* // => false
+	*/
+	function isObjectLike(value) {
+		return !!value && typeof value == "object";
+	}
+	/**
+	* Checks if `value` is classified as a `Symbol` primitive or object.
+	*
+	* @static
+	* @memberOf _
+	* @since 4.0.0
+	* @category Lang
+	* @param {*} value The value to check.
+	* @returns {boolean} Returns `true` if `value` is a symbol, else `false`.
+	* @example
+	*
+	* _.isSymbol(Symbol.iterator);
+	* // => true
+	*
+	* _.isSymbol('abc');
+	* // => false
+	*/
+	function isSymbol(value) {
+		return typeof value == "symbol" || isObjectLike(value) && objectToString.call(value) == symbolTag;
+	}
+	/**
+	* Converts `value` to a string. An empty string is returned for `null`
+	* and `undefined` values. The sign of `-0` is preserved.
+	*
+	* @static
+	* @memberOf _
+	* @since 4.0.0
+	* @category Lang
+	* @param {*} value The value to process.
+	* @returns {string} Returns the string.
+	* @example
+	*
+	* _.toString(null);
+	* // => ''
+	*
+	* _.toString(-0);
+	* // => '-0'
+	*
+	* _.toString([1, 2, 3]);
+	* // => '1,2,3'
+	*/
+	function toString(value) {
+		return value == null ? "" : baseToString(value);
+	}
+	/**
+	* Converts `string` to [camel case](https://en.wikipedia.org/wiki/CamelCase).
+	*
+	* @static
+	* @memberOf _
+	* @since 3.0.0
+	* @category String
+	* @param {string} [string=''] The string to convert.
+	* @returns {string} Returns the camel cased string.
+	* @example
+	*
+	* _.camelCase('Foo Bar');
+	* // => 'fooBar'
+	*
+	* _.camelCase('--foo-bar--');
+	* // => 'fooBar'
+	*
+	* _.camelCase('__FOO_BAR__');
+	* // => 'fooBar'
+	*/
+	var camelCase = createCompounder(function(result, word$1, index) {
+		word$1 = word$1.toLowerCase();
+		return result + (index ? capitalize(word$1) : word$1);
+	});
+	/**
+	* Converts the first character of `string` to upper case and the remaining
+	* to lower case.
+	*
+	* @static
+	* @memberOf _
+	* @since 3.0.0
+	* @category String
+	* @param {string} [string=''] The string to capitalize.
+	* @returns {string} Returns the capitalized string.
+	* @example
+	*
+	* _.capitalize('FRED');
+	* // => 'Fred'
+	*/
+	function capitalize(string$1) {
+		return upperFirst(toString(string$1).toLowerCase());
+	}
+	/**
+	* Deburrs `string` by converting
+	* [Latin-1 Supplement](https://en.wikipedia.org/wiki/Latin-1_Supplement_(Unicode_block)#Character_table)
+	* and [Latin Extended-A](https://en.wikipedia.org/wiki/Latin_Extended-A)
+	* letters to basic Latin letters and removing
+	* [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks).
+	*
+	* @static
+	* @memberOf _
+	* @since 3.0.0
+	* @category String
+	* @param {string} [string=''] The string to deburr.
+	* @returns {string} Returns the deburred string.
+	* @example
+	*
+	* _.deburr('déjà vu');
+	* // => 'deja vu'
+	*/
+	function deburr(string$1) {
+		string$1 = toString(string$1);
+		return string$1 && string$1.replace(reLatin, deburrLetter).replace(reComboMark, "");
+	}
+	/**
+	* Converts the first character of `string` to upper case.
+	*
+	* @static
+	* @memberOf _
+	* @since 4.0.0
+	* @category String
+	* @param {string} [string=''] The string to convert.
+	* @returns {string} Returns the converted string.
+	* @example
+	*
+	* _.upperFirst('fred');
+	* // => 'Fred'
+	*
+	* _.upperFirst('FRED');
+	* // => 'FRED'
+	*/
+	var upperFirst = createCaseFirst("toUpperCase");
+	/**
+	* Splits `string` into an array of its words.
+	*
+	* @static
+	* @memberOf _
+	* @since 3.0.0
+	* @category String
+	* @param {string} [string=''] The string to inspect.
+	* @param {RegExp|string} [pattern] The pattern to match words.
+	* @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
+	* @returns {Array} Returns the words of `string`.
+	* @example
+	*
+	* _.words('fred, barney, & pebbles');
+	* // => ['fred', 'barney', 'pebbles']
+	*
+	* _.words('fred, barney, & pebbles', /[^, ]+/g);
+	* // => ['fred', 'barney', '&', 'pebbles']
+	*/
+	function words(string$1, pattern, guard) {
+		string$1 = toString(string$1);
+		pattern = guard ? void 0 : pattern;
+		if (pattern === void 0) return hasUnicodeWord(string$1) ? unicodeWords(string$1) : asciiWords(string$1);
+		return string$1.match(pattern) || [];
+	}
+	module.exports = camelCase;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-modules@6.0.1_postcss@8.5.6/node_modules/postcss-modules/build/localsConvention.js
+var require_localsConvention = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.makeLocalsConventionReducer = makeLocalsConventionReducer;
+	var _lodash = _interopRequireDefault$22(require_lodash());
+	function _interopRequireDefault$22(obj) {
+		return obj && obj.__esModule ? obj : { default: obj };
+	}
+	function dashesCamelCase(string$1) {
+		return string$1.replace(/-+(\w)/g, (_, firstLetter) => firstLetter.toUpperCase());
+	}
+	function makeLocalsConventionReducer(localsConvention, inputFile) {
+		const isFunc = typeof localsConvention === "function";
+		return (tokens$1, [className$1, value]) => {
+			if (isFunc) {
+				const convention = localsConvention(className$1, value, inputFile);
+				tokens$1[convention] = value;
+				return tokens$1;
+			}
+			switch (localsConvention) {
+				case "camelCase":
+					tokens$1[className$1] = value;
+					tokens$1[(0, _lodash.default)(className$1)] = value;
+					break;
+				case "camelCaseOnly":
+					tokens$1[(0, _lodash.default)(className$1)] = value;
+					break;
+				case "dashes":
+					tokens$1[className$1] = value;
+					tokens$1[dashesCamelCase(className$1)] = value;
+					break;
+				case "dashesOnly":
+					tokens$1[dashesCamelCase(className$1)] = value;
+					break;
+			}
+			return tokens$1;
+		};
+	}
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-modules@6.0.1_postcss@8.5.6/node_modules/postcss-modules/build/FileSystemLoader.js
+var require_FileSystemLoader = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.default = void 0;
+	var _postcss$1 = _interopRequireDefault$21(__require("postcss"));
+	var _path = _interopRequireDefault$21(__require("path"));
+	var _Parser$1 = _interopRequireDefault$21(require_Parser());
+	var _fs$1 = require_fs();
+	function _interopRequireDefault$21(obj) {
+		return obj && obj.__esModule ? obj : { default: obj };
+	}
+	var Core = class Core {
+		constructor(plugins) {
+			this.plugins = plugins || Core.defaultPlugins;
+		}
+		async load(sourceString, sourcePath, trace, pathFetcher) {
+			const parser$1 = new _Parser$1.default(pathFetcher, trace);
+			const plugins = this.plugins.concat([parser$1.plugin()]);
+			return {
+				injectableSource: (await (0, _postcss$1.default)(plugins).process(sourceString, { from: sourcePath })).css,
+				exportTokens: parser$1.exportTokens
+			};
+		}
+	};
+	const traceKeySorter = (a, b) => {
+		if (a.length < b.length) return a < b.substring(0, a.length) ? -1 : 1;
+		if (a.length > b.length) return a.substring(0, b.length) <= b ? -1 : 1;
+		return a < b ? -1 : 1;
+	};
+	var FileSystemLoader = class {
+		constructor(root$2, plugins, fileResolve) {
+			if (root$2 === "/" && process.platform === "win32") {
+				const cwdDrive = process.cwd().slice(0, 3);
+				if (!/^[A-Za-z]:\\$/.test(cwdDrive)) throw new Error(`Failed to obtain root from "${process.cwd()}".`);
+				root$2 = cwdDrive;
+			}
+			this.root = root$2;
+			this.fileResolve = fileResolve;
+			this.sources = {};
+			this.traces = {};
+			this.importNr = 0;
+			this.core = new Core(plugins);
+			this.tokensByFile = {};
+			this.fs = (0, _fs$1.getFileSystem)();
+		}
+		async fetch(_newPath, relativeTo, _trace) {
+			const newPath = _newPath.replace(/^["']|["']$/g, "");
+			const trace = _trace || String.fromCharCode(this.importNr++);
+			const useFileResolve = typeof this.fileResolve === "function";
+			const fileResolvedPath = useFileResolve ? await this.fileResolve(newPath, relativeTo) : await Promise.resolve();
+			if (fileResolvedPath && !_path.default.isAbsolute(fileResolvedPath)) throw new Error("The returned path from the \"fileResolve\" option must be absolute.");
+			const relativeDir = _path.default.dirname(relativeTo);
+			const rootRelativePath = fileResolvedPath || _path.default.resolve(relativeDir, newPath);
+			let fileRelativePath = fileResolvedPath || _path.default.resolve(_path.default.resolve(this.root, relativeDir), newPath);
+			if (!useFileResolve && newPath[0] !== "." && !_path.default.isAbsolute(newPath)) try {
+				fileRelativePath = __require.resolve(newPath);
+			} catch (e) {}
+			const tokens$1 = this.tokensByFile[fileRelativePath];
+			if (tokens$1) return tokens$1;
+			return new Promise((resolve, reject) => {
+				this.fs.readFile(fileRelativePath, "utf-8", async (err, source) => {
+					if (err) reject(err);
+					const { injectableSource, exportTokens } = await this.core.load(source, rootRelativePath, trace, this.fetch.bind(this));
+					this.sources[fileRelativePath] = injectableSource;
+					this.traces[trace] = fileRelativePath;
+					this.tokensByFile[fileRelativePath] = exportTokens;
+					resolve(exportTokens);
+				});
+			});
+		}
+		get finalSource() {
+			const traces = this.traces;
+			const sources = this.sources;
+			let written = /* @__PURE__ */ new Set();
+			return Object.keys(traces).sort(traceKeySorter).map((key) => {
+				const filename = traces[key];
+				if (written.has(filename)) return null;
+				written.add(filename);
+				return sources[filename];
+			}).join("");
+		}
+	};
+	exports.default = FileSystemLoader;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-modules-extract-imports@3.1.0_postcss@8.5.6/node_modules/postcss-modules-extract-imports/src/topologicalSort.js
+var require_topologicalSort = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const PERMANENT_MARKER = 2;
+	const TEMPORARY_MARKER = 1;
+	function createError(node, graph) {
+		const er = /* @__PURE__ */ new Error("Nondeterministic import's order");
+		er.nodes = [node, graph[node].find((relatedNode) => graph[relatedNode].indexOf(node) > -1)];
+		return er;
+	}
+	function walkGraph(node, graph, state, result, strict) {
+		if (state[node] === PERMANENT_MARKER) return;
+		if (state[node] === TEMPORARY_MARKER) {
+			if (strict) return createError(node, graph);
+			return;
+		}
+		state[node] = TEMPORARY_MARKER;
+		const children = graph[node];
+		const length = children.length;
+		for (let i$1 = 0; i$1 < length; ++i$1) {
+			const error = walkGraph(children[i$1], graph, state, result, strict);
+			if (error instanceof Error) return error;
+		}
+		state[node] = PERMANENT_MARKER;
+		result.push(node);
+	}
+	function topologicalSort$1(graph, strict) {
+		const result = [];
+		const state = {};
+		const nodes = Object.keys(graph);
+		const length = nodes.length;
+		for (let i$1 = 0; i$1 < length; ++i$1) {
+			const er = walkGraph(nodes[i$1], graph, state, result, strict);
+			if (er instanceof Error) return er;
+		}
+		return result;
+	}
+	module.exports = topologicalSort$1;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-modules-extract-imports@3.1.0_postcss@8.5.6/node_modules/postcss-modules-extract-imports/src/index.js
+var require_src$3 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const topologicalSort = require_topologicalSort();
+	const matchImports$1 = /^(.+?)\s+from\s+(?:"([^"]+)"|'([^']+)'|(global))$/;
+	const icssImport = /^:import\((?:"([^"]+)"|'([^']+)')\)/;
+	const VISITED_MARKER = 1;
+	/**
+	* :import('G') {}
+	*
+	* Rule
+	*   composes: ... from 'A'
+	*   composes: ... from 'B'
+	
+	* Rule
+	*   composes: ... from 'A'
+	*   composes: ... from 'A'
+	*   composes: ... from 'C'
+	*
+	* Results in:
+	*
+	* graph: {
+	*   G: [],
+	*   A: [],
+	*   B: ['A'],
+	*   C: ['A'],
+	* }
+	*/
+	function addImportToGraph(importId, parentId, graph, visited) {
+		const siblingsId = parentId + "_siblings";
+		const visitedId = parentId + "_" + importId;
+		if (visited[visitedId] !== VISITED_MARKER) {
+			if (!Array.isArray(visited[siblingsId])) visited[siblingsId] = [];
+			const siblings = visited[siblingsId];
+			if (Array.isArray(graph[importId])) graph[importId] = graph[importId].concat(siblings);
+			else graph[importId] = siblings.slice();
+			visited[visitedId] = VISITED_MARKER;
+			siblings.push(importId);
+		}
+	}
+	module.exports = (options = {}) => {
+		let importIndex = 0;
+		const createImportedName = typeof options.createImportedName !== "function" ? (importName) => `i__imported_${importName.replace(/\W/g, "_")}_${importIndex++}` : options.createImportedName;
+		const failOnWrongOrder = options.failOnWrongOrder;
+		return {
+			postcssPlugin: "postcss-modules-extract-imports",
+			prepare() {
+				const graph = {};
+				const visited = {};
+				const existingImports = {};
+				const importDecls = {};
+				const imports = {};
+				return { Once(root$2, postcss) {
+					root$2.walkRules((rule) => {
+						const matches = icssImport.exec(rule.selector);
+						if (matches) {
+							const [, doubleQuotePath, singleQuotePath] = matches;
+							const importPath = doubleQuotePath || singleQuotePath;
+							addImportToGraph(importPath, "root", graph, visited);
+							existingImports[importPath] = rule;
+						}
+					});
+					root$2.walkDecls(/^composes$/, (declaration) => {
+						const multiple = declaration.value.split(",");
+						const values = [];
+						multiple.forEach((value) => {
+							const matches = value.trim().match(matchImports$1);
+							if (!matches) {
+								values.push(value);
+								return;
+							}
+							let tmpSymbols;
+							let [, symbols, doubleQuotePath, singleQuotePath, global$1] = matches;
+							if (global$1) tmpSymbols = symbols.split(/\s+/).map((s) => `global(${s})`);
+							else {
+								const importPath = doubleQuotePath || singleQuotePath;
+								let parent = declaration.parent;
+								let parentIndexes = "";
+								while (parent.type !== "root") {
+									parentIndexes = parent.parent.index(parent) + "_" + parentIndexes;
+									parent = parent.parent;
+								}
+								const { selector: selector$1 } = declaration.parent;
+								addImportToGraph(importPath, `_${parentIndexes}${selector$1}`, graph, visited);
+								importDecls[importPath] = declaration;
+								imports[importPath] = imports[importPath] || {};
+								tmpSymbols = symbols.split(/\s+/).map((s) => {
+									if (!imports[importPath][s]) imports[importPath][s] = createImportedName(s, importPath);
+									return imports[importPath][s];
+								});
+							}
+							values.push(tmpSymbols.join(" "));
+						});
+						declaration.value = values.join(", ");
+					});
+					const importsOrder = topologicalSort(graph, failOnWrongOrder);
+					if (importsOrder instanceof Error) throw importDecls[importsOrder.nodes.find((importPath) => importDecls.hasOwnProperty(importPath))].error("Failed to resolve order of composed modules " + importsOrder.nodes.map((importPath) => "`" + importPath + "`").join(", ") + ".", {
+						plugin: "postcss-modules-extract-imports",
+						word: "composes"
+					});
+					let lastImportRule;
+					importsOrder.forEach((path$2) => {
+						const importedSymbols = imports[path$2];
+						let rule = existingImports[path$2];
+						if (!rule && importedSymbols) {
+							rule = postcss.rule({
+								selector: `:import("${path$2}")`,
+								raws: { after: "\n" }
+							});
+							if (lastImportRule) root$2.insertAfter(lastImportRule, rule);
+							else root$2.prepend(rule);
+						}
+						lastImportRule = rule;
+						if (!importedSymbols) return;
+						Object.keys(importedSymbols).forEach((importedSymbol) => {
+							rule.append(postcss.decl({
+								value: importedSymbol,
+								prop: importedSymbols[importedSymbol],
+								raws: { before: "\n  " }
+							}));
+						});
+					});
+				} };
+			}
+		};
+	};
+	module.exports.postcss = true;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/loader-utils@3.3.1/node_modules/loader-utils/lib/hash/wasm-hash.js
+var require_wasm_hash = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const MAX_SHORT_STRING$1 = Math.floor(65472 / 4) & -4;
+	var WasmHash = class {
+		/**
+		* @param {WebAssembly.Instance} instance wasm instance
+		* @param {WebAssembly.Instance[]} instancesPool pool of instances
+		* @param {number} chunkSize size of data chunks passed to wasm
+		* @param {number} digestSize size of digest returned by wasm
+		*/
+		constructor(instance, instancesPool, chunkSize, digestSize) {
+			const exports$1 = instance.exports;
+			exports$1.init();
+			this.exports = exports$1;
+			this.mem = Buffer.from(exports$1.memory.buffer, 0, 65536);
+			this.buffered = 0;
+			this.instancesPool = instancesPool;
+			this.chunkSize = chunkSize;
+			this.digestSize = digestSize;
+		}
+		reset() {
+			this.buffered = 0;
+			this.exports.init();
+		}
+		/**
+		* @param {Buffer | string} data data
+		* @param {BufferEncoding=} encoding encoding
+		* @returns {this} itself
+		*/
+		update(data, encoding) {
+			if (typeof data === "string") {
+				while (data.length > MAX_SHORT_STRING$1) {
+					this._updateWithShortString(data.slice(0, MAX_SHORT_STRING$1), encoding);
+					data = data.slice(MAX_SHORT_STRING$1);
+				}
+				this._updateWithShortString(data, encoding);
+				return this;
+			}
+			this._updateWithBuffer(data);
+			return this;
+		}
+		/**
+		* @param {string} data data
+		* @param {BufferEncoding=} encoding encoding
+		* @returns {void}
+		*/
+		_updateWithShortString(data, encoding) {
+			const { exports: exports$1, buffered, mem, chunkSize } = this;
+			let endPos;
+			if (data.length < 70) if (!encoding || encoding === "utf-8" || encoding === "utf8") {
+				endPos = buffered;
+				for (let i$1 = 0; i$1 < data.length; i$1++) {
+					const cc = data.charCodeAt(i$1);
+					if (cc < 128) mem[endPos++] = cc;
+					else if (cc < 2048) {
+						mem[endPos] = cc >> 6 | 192;
+						mem[endPos + 1] = cc & 63 | 128;
+						endPos += 2;
+					} else {
+						endPos += mem.write(data.slice(i$1), endPos, encoding);
+						break;
+					}
+				}
+			} else if (encoding === "latin1") {
+				endPos = buffered;
+				for (let i$1 = 0; i$1 < data.length; i$1++) {
+					const cc = data.charCodeAt(i$1);
+					mem[endPos++] = cc;
+				}
+			} else endPos = buffered + mem.write(data, buffered, encoding);
+			else endPos = buffered + mem.write(data, buffered, encoding);
+			if (endPos < chunkSize) this.buffered = endPos;
+			else {
+				const l = endPos & ~(this.chunkSize - 1);
+				exports$1.update(l);
+				const newBuffered = endPos - l;
+				this.buffered = newBuffered;
+				if (newBuffered > 0) mem.copyWithin(0, l, endPos);
+			}
+		}
+		/**
+		* @param {Buffer} data data
+		* @returns {void}
+		*/
+		_updateWithBuffer(data) {
+			const { exports: exports$1, buffered, mem } = this;
+			const length = data.length;
+			if (buffered + length < this.chunkSize) {
+				data.copy(mem, buffered, 0, length);
+				this.buffered += length;
+			} else {
+				const l = buffered + length & ~(this.chunkSize - 1);
+				if (l > 65536) {
+					let i$1 = 65536 - buffered;
+					data.copy(mem, buffered, 0, i$1);
+					exports$1.update(65536);
+					const stop = l - buffered - 65536;
+					while (i$1 < stop) {
+						data.copy(mem, 0, i$1, i$1 + 65536);
+						exports$1.update(65536);
+						i$1 += 65536;
+					}
+					data.copy(mem, 0, i$1, l - buffered);
+					exports$1.update(l - buffered - i$1);
+				} else {
+					data.copy(mem, buffered, 0, l - buffered);
+					exports$1.update(l);
+				}
+				const newBuffered = length + buffered - l;
+				this.buffered = newBuffered;
+				if (newBuffered > 0) data.copy(mem, 0, length - newBuffered, length);
+			}
+		}
+		digest(type) {
+			const { exports: exports$1, buffered, mem, digestSize } = this;
+			exports$1.final(buffered);
+			this.instancesPool.push(this);
+			const hex$1 = mem.toString("latin1", 0, digestSize);
+			if (type === "hex") return hex$1;
+			if (type === "binary" || !type) return Buffer.from(hex$1, "hex");
+			return Buffer.from(hex$1, "hex").toString(type);
+		}
+	};
+	const create$2 = (wasmModule, instancesPool, chunkSize, digestSize) => {
+		if (instancesPool.length > 0) {
+			const old = instancesPool.pop();
+			old.reset();
+			return old;
+		} else return new WasmHash(new WebAssembly.Instance(wasmModule), instancesPool, chunkSize, digestSize);
+	};
+	module.exports = create$2;
+	module.exports.MAX_SHORT_STRING = MAX_SHORT_STRING$1;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/loader-utils@3.3.1/node_modules/loader-utils/lib/hash/xxhash64.js
+var require_xxhash64 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const create$1 = require_wasm_hash();
+	const xxhash64 = new WebAssembly.Module(Buffer.from("AGFzbQEAAAABCAJgAX8AYAAAAwQDAQAABQMBAAEGGgV+AUIAC34BQgALfgFCAAt+AUIAC34BQgALByIEBGluaXQAAAZ1cGRhdGUAAQVmaW5hbAACBm1lbW9yeQIACrUIAzAAQtbrgu7q/Yn14AAkAELP1tO+0ser2UIkAUIAJAJC+erQ0OfJoeThACQDQgAkBAvUAQIBfwR+IABFBEAPCyMEIACtfCQEIwAhAiMBIQMjAiEEIwMhBQNAIAIgASkDAELP1tO+0ser2UJ+fEIfiUKHla+vmLbem55/fiECIAMgASkDCELP1tO+0ser2UJ+fEIfiUKHla+vmLbem55/fiEDIAQgASkDEELP1tO+0ser2UJ+fEIfiUKHla+vmLbem55/fiEEIAUgASkDGELP1tO+0ser2UJ+fEIfiUKHla+vmLbem55/fiEFIAAgAUEgaiIBSw0ACyACJAAgAyQBIAQkAiAFJAMLqwYCAX8EfiMEQgBSBH4jACICQgGJIwEiA0IHiXwjAiIEQgyJfCMDIgVCEol8IAJCz9bTvtLHq9lCfkIfiUKHla+vmLbem55/foVCh5Wvr5i23puef35CnaO16oOxjYr6AH0gA0LP1tO+0ser2UJ+Qh+JQoeVr6+Ytt6bnn9+hUKHla+vmLbem55/fkKdo7Xqg7GNivoAfSAEQs/W077Sx6vZQn5CH4lCh5Wvr5i23puef36FQoeVr6+Ytt6bnn9+Qp2jteqDsY2K+gB9IAVCz9bTvtLHq9lCfkIfiUKHla+vmLbem55/foVCh5Wvr5i23puef35CnaO16oOxjYr6AH0FQsXP2bLx5brqJwsjBCAArXx8IQIDQCABQQhqIABNBEAgAiABKQMAQs/W077Sx6vZQn5CH4lCh5Wvr5i23puef36FQhuJQoeVr6+Ytt6bnn9+Qp2jteqDsY2K+gB9IQIgAUEIaiEBDAELCyABQQRqIABNBEACfyACIAE1AgBCh5Wvr5i23puef36FQheJQs/W077Sx6vZQn5C+fPd8Zn2masWfCECIAFBBGoLIQELA0AgACABRwRAIAIgATEAAELFz9my8eW66id+hUILiUKHla+vmLbem55/fiECIAFBAWohAQwBCwtBACACIAJCIYiFQs/W077Sx6vZQn4iAiACQh2IhUL5893xmfaZqxZ+IgIgAkIgiIUiAkIgiCIDQv//A4NCIIYgA0KAgPz/D4NCEIiEIgNC/4GAgPAfg0IQhiADQoD+g4CA4D+DQgiIhCIDQo+AvIDwgcAHg0IIhiADQvCBwIeAnoD4AINCBIiEIgNChoyYsODAgYMGfEIEiEKBgoSIkKDAgAGDQid+IANCsODAgYOGjJgwhHw3AwBBCCACQv////8PgyICQv//A4NCIIYgAkKAgPz/D4NCEIiEIgJC/4GAgPAfg0IQhiACQoD+g4CA4D+DQgiIhCICQo+AvIDwgcAHg0IIhiACQvCBwIeAnoD4AINCBIiEIgJChoyYsODAgYMGfEIEiEKBgoSIkKDAgAGDQid+IAJCsODAgYOGjJgwhHw3AwAL", "base64"));
+	module.exports = create$1.bind(null, xxhash64, [], 32, 16);
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/loader-utils@3.3.1/node_modules/loader-utils/lib/hash/BatchedHash.js
+var require_BatchedHash = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const MAX_SHORT_STRING = require_wasm_hash().MAX_SHORT_STRING;
+	var BatchedHash$1 = class {
+		constructor(hash$1) {
+			this.string = void 0;
+			this.encoding = void 0;
+			this.hash = hash$1;
+		}
+		/**
+		* Update hash {@link https://nodejs.org/api/crypto.html#crypto_hash_update_data_inputencoding}
+		* @param {string|Buffer} data data
+		* @param {string=} inputEncoding data encoding
+		* @returns {this} updated hash
+		*/
+		update(data, inputEncoding) {
+			if (this.string !== void 0) {
+				if (typeof data === "string" && inputEncoding === this.encoding && this.string.length + data.length < MAX_SHORT_STRING) {
+					this.string += data;
+					return this;
+				}
+				this.hash.update(this.string, this.encoding);
+				this.string = void 0;
+			}
+			if (typeof data === "string") if (data.length < MAX_SHORT_STRING && (!inputEncoding || !inputEncoding.startsWith("ba"))) {
+				this.string = data;
+				this.encoding = inputEncoding;
+			} else this.hash.update(data, inputEncoding);
+			else this.hash.update(data);
+			return this;
+		}
+		/**
+		* Calculates the digest {@link https://nodejs.org/api/crypto.html#crypto_hash_digest_encoding}
+		* @param {string=} encoding encoding of the return value
+		* @returns {string|Buffer} digest
+		*/
+		digest(encoding) {
+			if (this.string !== void 0) this.hash.update(this.string, this.encoding);
+			return this.hash.digest(encoding);
+		}
+	};
+	module.exports = BatchedHash$1;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/loader-utils@3.3.1/node_modules/loader-utils/lib/hash/md4.js
+var require_md4 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const create = require_wasm_hash();
+	const md4 = new WebAssembly.Module(Buffer.from("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", "base64"));
+	module.exports = create.bind(null, md4, [], 64, 32);
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/loader-utils@3.3.1/node_modules/loader-utils/lib/hash/BulkUpdateDecorator.js
+var require_BulkUpdateDecorator = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const BULK_SIZE = 2e3;
+	const digestCaches = {};
+	var BulkUpdateDecorator$1 = class {
+		/**
+		* @param {Hash | function(): Hash} hashOrFactory function to create a hash
+		* @param {string=} hashKey key for caching
+		*/
+		constructor(hashOrFactory, hashKey) {
+			this.hashKey = hashKey;
+			if (typeof hashOrFactory === "function") {
+				this.hashFactory = hashOrFactory;
+				this.hash = void 0;
+			} else {
+				this.hashFactory = void 0;
+				this.hash = hashOrFactory;
+			}
+			this.buffer = "";
+		}
+		/**
+		* Update hash {@link https://nodejs.org/api/crypto.html#crypto_hash_update_data_inputencoding}
+		* @param {string|Buffer} data data
+		* @param {string=} inputEncoding data encoding
+		* @returns {this} updated hash
+		*/
+		update(data, inputEncoding) {
+			if (inputEncoding !== void 0 || typeof data !== "string" || data.length > BULK_SIZE) {
+				if (this.hash === void 0) this.hash = this.hashFactory();
+				if (this.buffer.length > 0) {
+					this.hash.update(this.buffer);
+					this.buffer = "";
+				}
+				this.hash.update(data, inputEncoding);
+			} else {
+				this.buffer += data;
+				if (this.buffer.length > BULK_SIZE) {
+					if (this.hash === void 0) this.hash = this.hashFactory();
+					this.hash.update(this.buffer);
+					this.buffer = "";
+				}
+			}
+			return this;
+		}
+		/**
+		* Calculates the digest {@link https://nodejs.org/api/crypto.html#crypto_hash_digest_encoding}
+		* @param {string=} encoding encoding of the return value
+		* @returns {string|Buffer} digest
+		*/
+		digest(encoding) {
+			let digestCache;
+			const buffer = this.buffer;
+			if (this.hash === void 0) {
+				const cacheKey = `${this.hashKey}-${encoding}`;
+				digestCache = digestCaches[cacheKey];
+				if (digestCache === void 0) digestCache = digestCaches[cacheKey] = /* @__PURE__ */ new Map();
+				const cacheEntry = digestCache.get(buffer);
+				if (cacheEntry !== void 0) return cacheEntry;
+				this.hash = this.hashFactory();
+			}
+			if (buffer.length > 0) this.hash.update(buffer);
+			const digestResult = this.hash.digest(encoding);
+			if (digestCache !== void 0) digestCache.set(buffer, digestResult);
+			return digestResult;
+		}
+	};
+	module.exports = BulkUpdateDecorator$1;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/loader-utils@3.3.1/node_modules/loader-utils/lib/getHashDigest.js
+var require_getHashDigest = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const baseEncodeTables = {
+		26: "abcdefghijklmnopqrstuvwxyz",
+		32: "123456789abcdefghjkmnpqrstuvwxyz",
+		36: "0123456789abcdefghijklmnopqrstuvwxyz",
+		49: "abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ",
+		52: "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ",
+		58: "123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ",
+		62: "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ",
+		64: "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-_"
+	};
+	/**
+	* @param {Uint32Array} uint32Array Treated as a long base-0x100000000 number, little endian
+	* @param {number} divisor The divisor
+	* @return {number} Modulo (remainder) of the division
+	*/
+	function divmod32(uint32Array, divisor) {
+		let carry = 0;
+		for (let i$1 = uint32Array.length - 1; i$1 >= 0; i$1--) {
+			const value = carry * 4294967296 + uint32Array[i$1];
+			carry = value % divisor;
+			uint32Array[i$1] = Math.floor(value / divisor);
+		}
+		return carry;
+	}
+	function encodeBufferToBase(buffer, base, length) {
+		const encodeTable = baseEncodeTables[base];
+		if (!encodeTable) throw new Error("Unknown encoding base" + base);
+		const limit = Math.ceil(buffer.length * 8 / Math.log2(base));
+		length = Math.min(length, limit);
+		const uint32Array = new Uint32Array(Math.ceil(buffer.length / 4));
+		buffer.copy(Buffer.from(uint32Array.buffer));
+		let output = "";
+		for (let i$1 = 0; i$1 < length; i$1++) output = encodeTable[divmod32(uint32Array, base)] + output;
+		return output;
+	}
+	let crypto = void 0;
+	let createXXHash64 = void 0;
+	let createMd4 = void 0;
+	let BatchedHash = void 0;
+	let BulkUpdateDecorator = void 0;
+	function getHashDigest$1(buffer, algorithm, digestType, maxLength) {
+		algorithm = algorithm || "xxhash64";
+		maxLength = maxLength || 9999;
+		let hash$1;
+		if (algorithm === "xxhash64") {
+			if (createXXHash64 === void 0) {
+				createXXHash64 = require_xxhash64();
+				if (BatchedHash === void 0) BatchedHash = require_BatchedHash();
+			}
+			hash$1 = new BatchedHash(createXXHash64());
+		} else if (algorithm === "md4") {
+			if (createMd4 === void 0) {
+				createMd4 = require_md4();
+				if (BatchedHash === void 0) BatchedHash = require_BatchedHash();
+			}
+			hash$1 = new BatchedHash(createMd4());
+		} else if (algorithm === "native-md4") {
+			if (typeof crypto === "undefined") {
+				crypto = __require("crypto");
+				if (BulkUpdateDecorator === void 0) BulkUpdateDecorator = require_BulkUpdateDecorator();
+			}
+			hash$1 = new BulkUpdateDecorator(() => crypto.createHash("md4"), "md4");
+		} else {
+			if (typeof crypto === "undefined") {
+				crypto = __require("crypto");
+				if (BulkUpdateDecorator === void 0) BulkUpdateDecorator = require_BulkUpdateDecorator();
+			}
+			hash$1 = new BulkUpdateDecorator(() => crypto.createHash(algorithm), algorithm);
+		}
+		hash$1.update(buffer);
+		if (digestType === "base26" || digestType === "base32" || digestType === "base36" || digestType === "base49" || digestType === "base52" || digestType === "base58" || digestType === "base62" || digestType === "base64safe") return encodeBufferToBase(hash$1.digest(), digestType === "base64safe" ? 64 : digestType.substr(4), maxLength);
+		return hash$1.digest(digestType || "hex").substr(0, maxLength);
+	}
+	module.exports = getHashDigest$1;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/loader-utils@3.3.1/node_modules/loader-utils/lib/interpolateName.js
+var require_interpolateName = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const path$1 = __require("path");
+	const getHashDigest = require_getHashDigest();
+	function interpolateName$1(loaderContext, name, options = {}) {
+		let filename;
+		const hasQuery = loaderContext.resourceQuery && loaderContext.resourceQuery.length > 1;
+		if (typeof name === "function") filename = name(loaderContext.resourcePath, hasQuery ? loaderContext.resourceQuery : void 0);
+		else filename = name || "[hash].[ext]";
+		const context = options.context;
+		const content = options.content;
+		const regExp = options.regExp;
+		let ext = "bin";
+		let basename = "file";
+		let directory = "";
+		let folder = "";
+		let query = "";
+		if (loaderContext.resourcePath) {
+			const parsed = path$1.parse(loaderContext.resourcePath);
+			let resourcePath = loaderContext.resourcePath;
+			if (parsed.ext) ext = parsed.ext.substr(1);
+			if (parsed.dir) {
+				basename = parsed.name;
+				resourcePath = parsed.dir + path$1.sep;
+			}
+			if (typeof context !== "undefined") {
+				directory = path$1.relative(context, resourcePath + "_").replace(/\\/g, "/").replace(/\.\.(\/)?/g, "_$1");
+				directory = directory.substr(0, directory.length - 1);
+			} else directory = resourcePath.replace(/\\/g, "/").replace(/\.\.(\/)?/g, "_$1");
+			if (directory.length <= 1) directory = "";
+			else folder = path$1.basename(directory);
+		}
+		if (loaderContext.resourceQuery && loaderContext.resourceQuery.length > 1) {
+			query = loaderContext.resourceQuery;
+			const hashIdx = query.indexOf("#");
+			if (hashIdx >= 0) query = query.substr(0, hashIdx);
+		}
+		let url = filename;
+		if (content) url = url.replace(/\[(?:([^[:\]]+):)?(?:hash|contenthash)(?::([a-z]+\d*(?:safe)?))?(?::(\d+))?\]/gi, (all, hashType, digestType, maxLength) => getHashDigest(content, hashType, digestType, parseInt(maxLength, 10)));
+		url = url.replace(/\[ext\]/gi, () => ext).replace(/\[name\]/gi, () => basename).replace(/\[path\]/gi, () => directory).replace(/\[folder\]/gi, () => folder).replace(/\[query\]/gi, () => query);
+		if (regExp && loaderContext.resourcePath) {
+			const match = loaderContext.resourcePath.match(new RegExp(regExp));
+			match && match.forEach((matched, i$1) => {
+				url = url.replace(new RegExp("\\[" + i$1 + "\\]", "ig"), matched);
+			});
+		}
+		if (typeof loaderContext.options === "object" && typeof loaderContext.options.customInterpolateName === "function") url = loaderContext.options.customInterpolateName.call(loaderContext, url, name, options);
+		return url;
+	}
+	module.exports = interpolateName$1;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/generic-names@4.0.0/node_modules/generic-names/index.js
+var require_generic_names = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var interpolateName = require_interpolateName();
+	var path = __require("path");
+	/**
+	* @param  {string} pattern
+	* @param  {object} options
+	* @param  {string} options.context
+	* @param  {string} options.hashPrefix
+	* @return {function}
+	*/
+	module.exports = function createGenerator(pattern, options) {
+		options = options || {};
+		var context = options && typeof options.context === "string" ? options.context : process.cwd();
+		var hashPrefix = options && typeof options.hashPrefix === "string" ? options.hashPrefix : "";
+		/**
+		* @param  {string} localName Usually a class name
+		* @param  {string} filepath  Absolute path
+		* @return {string}
+		*/
+		return function generate(localName, filepath) {
+			var name = pattern.replace(/\[local\]/gi, localName);
+			return interpolateName({ resourcePath: filepath }, name, {
+				content: hashPrefix + path.relative(context, filepath).replace(/\\/g, "/") + "\0" + localName,
+				context
+			}).replace(new RegExp("[^a-zA-Z0-9\\-_\xA0-￿]", "g"), "-").replace(/^((-?[0-9])|--)/, "_$1");
+		};
+	};
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-selector-parser@7.1.0/node_modules/postcss-selector-parser/dist/util/unesc.js
+var require_unesc = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	exports.__esModule = true;
+	exports["default"] = unesc;
+	/**
+	* 
+	* @param {string} str 
+	* @returns {[string, number]|undefined}
+	*/
+	function gobbleHex(str$1) {
+		var lower = str$1.toLowerCase();
+		var hex$1 = "";
+		var spaceTerminated = false;
+		for (var i$1 = 0; i$1 < 6 && lower[i$1] !== void 0; i$1++) {
+			var code = lower.charCodeAt(i$1);
+			var valid = code >= 97 && code <= 102 || code >= 48 && code <= 57;
+			spaceTerminated = code === 32;
+			if (!valid) break;
+			hex$1 += lower[i$1];
+		}
+		if (hex$1.length === 0) return;
+		var codePoint = parseInt(hex$1, 16);
+		if (codePoint >= 55296 && codePoint <= 57343 || codePoint === 0 || codePoint > 1114111) return ["�", hex$1.length + (spaceTerminated ? 1 : 0)];
+		return [String.fromCodePoint(codePoint), hex$1.length + (spaceTerminated ? 1 : 0)];
+	}
+	var CONTAINS_ESCAPE = /\\/;
+	function unesc(str$1) {
+		if (!CONTAINS_ESCAPE.test(str$1)) return str$1;
+		var ret = "";
+		for (var i$1 = 0; i$1 < str$1.length; i$1++) {
+			if (str$1[i$1] === "\\") {
+				var gobbled = gobbleHex(str$1.slice(i$1 + 1, i$1 + 7));
+				if (gobbled !== void 0) {
+					ret += gobbled[0];
+					i$1 += gobbled[1];
+					continue;
+				}
+				if (str$1[i$1 + 1] === "\\") {
+					ret += "\\";
+					i$1++;
+					continue;
+				}
+				if (str$1.length === i$1 + 1) ret += str$1[i$1];
+				continue;
+			}
+			ret += str$1[i$1];
+		}
+		return ret;
+	}
+	module.exports = exports.default;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-selector-parser@7.1.0/node_modules/postcss-selector-parser/dist/util/getProp.js
+var require_getProp = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	exports.__esModule = true;
+	exports["default"] = getProp;
+	function getProp(obj) {
+		for (var _len = arguments.length, props = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) props[_key - 1] = arguments[_key];
+		while (props.length > 0) {
+			var prop = props.shift();
+			if (!obj[prop]) return;
+			obj = obj[prop];
+		}
+		return obj;
+	}
+	module.exports = exports.default;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-selector-parser@7.1.0/node_modules/postcss-selector-parser/dist/util/ensureObject.js
+var require_ensureObject = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	exports.__esModule = true;
+	exports["default"] = ensureObject;
+	function ensureObject(obj) {
+		for (var _len = arguments.length, props = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) props[_key - 1] = arguments[_key];
+		while (props.length > 0) {
+			var prop = props.shift();
+			if (!obj[prop]) obj[prop] = {};
+			obj = obj[prop];
+		}
+	}
+	module.exports = exports.default;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-selector-parser@7.1.0/node_modules/postcss-selector-parser/dist/util/stripComments.js
+var require_stripComments = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	exports.__esModule = true;
+	exports["default"] = stripComments;
+	function stripComments(str$1) {
+		var s = "";
+		var commentStart = str$1.indexOf("/*");
+		var lastEnd = 0;
+		while (commentStart >= 0) {
+			s = s + str$1.slice(lastEnd, commentStart);
+			var commentEnd = str$1.indexOf("*/", commentStart + 2);
+			if (commentEnd < 0) return s;
+			lastEnd = commentEnd + 2;
+			commentStart = str$1.indexOf("/*", lastEnd);
+		}
+		s = s + str$1.slice(lastEnd);
+		return s;
+	}
+	module.exports = exports.default;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-selector-parser@7.1.0/node_modules/postcss-selector-parser/dist/util/index.js
+var require_util = /* @__PURE__ */ __commonJSMin(((exports) => {
+	exports.__esModule = true;
+	exports.unesc = exports.stripComments = exports.getProp = exports.ensureObject = void 0;
+	var _unesc$1 = _interopRequireDefault$20(require_unesc());
+	exports.unesc = _unesc$1["default"];
+	var _getProp = _interopRequireDefault$20(require_getProp());
+	exports.getProp = _getProp["default"];
+	var _ensureObject = _interopRequireDefault$20(require_ensureObject());
+	exports.ensureObject = _ensureObject["default"];
+	var _stripComments = _interopRequireDefault$20(require_stripComments());
+	exports.stripComments = _stripComments["default"];
+	function _interopRequireDefault$20(obj) {
+		return obj && obj.__esModule ? obj : { "default": obj };
+	}
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-selector-parser@7.1.0/node_modules/postcss-selector-parser/dist/selectors/node.js
+var require_node$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	exports.__esModule = true;
+	exports["default"] = void 0;
+	var _util$3 = require_util();
+	function _defineProperties$6(target, props) {
+		for (var i$1 = 0; i$1 < props.length; i$1++) {
+			var descriptor = props[i$1];
+			descriptor.enumerable = descriptor.enumerable || false;
+			descriptor.configurable = true;
+			if ("value" in descriptor) descriptor.writable = true;
+			Object.defineProperty(target, descriptor.key, descriptor);
+		}
+	}
+	function _createClass$6(Constructor, protoProps, staticProps) {
+		if (protoProps) _defineProperties$6(Constructor.prototype, protoProps);
+		if (staticProps) _defineProperties$6(Constructor, staticProps);
+		Object.defineProperty(Constructor, "prototype", { writable: false });
+		return Constructor;
+	}
+	var cloneNode = function cloneNode$1(obj, parent) {
+		if (typeof obj !== "object" || obj === null) return obj;
+		var cloned = new obj.constructor();
+		for (var i$1 in obj) {
+			if (!obj.hasOwnProperty(i$1)) continue;
+			var value = obj[i$1];
+			if (i$1 === "parent" && typeof value === "object") {
+				if (parent) cloned[i$1] = parent;
+			} else if (value instanceof Array) cloned[i$1] = value.map(function(j) {
+				return cloneNode$1(j, cloned);
+			});
+			else cloned[i$1] = cloneNode$1(value, cloned);
+		}
+		return cloned;
+	};
+	var Node = /* @__PURE__ */ function() {
+		function Node$1(opts) {
+			if (opts === void 0) opts = {};
+			Object.assign(this, opts);
+			this.spaces = this.spaces || {};
+			this.spaces.before = this.spaces.before || "";
+			this.spaces.after = this.spaces.after || "";
+		}
+		var _proto = Node$1.prototype;
+		_proto.remove = function remove() {
+			if (this.parent) this.parent.removeChild(this);
+			this.parent = void 0;
+			return this;
+		};
+		_proto.replaceWith = function replaceWith() {
+			if (this.parent) {
+				for (var index in arguments) this.parent.insertBefore(this, arguments[index]);
+				this.remove();
+			}
+			return this;
+		};
+		_proto.next = function next() {
+			return this.parent.at(this.parent.index(this) + 1);
+		};
+		_proto.prev = function prev() {
+			return this.parent.at(this.parent.index(this) - 1);
+		};
+		_proto.clone = function clone(overrides) {
+			if (overrides === void 0) overrides = {};
+			var cloned = cloneNode(this);
+			for (var name in overrides) cloned[name] = overrides[name];
+			return cloned;
+		};
+		_proto.appendToPropertyAndEscape = function appendToPropertyAndEscape(name, value, valueEscaped) {
+			if (!this.raws) this.raws = {};
+			var originalValue = this[name];
+			var originalEscaped = this.raws[name];
+			this[name] = originalValue + value;
+			if (originalEscaped || valueEscaped !== value) this.raws[name] = (originalEscaped || originalValue) + valueEscaped;
+			else delete this.raws[name];
+		};
+		_proto.setPropertyAndEscape = function setPropertyAndEscape(name, value, valueEscaped) {
+			if (!this.raws) this.raws = {};
+			this[name] = value;
+			this.raws[name] = valueEscaped;
+		};
+		_proto.setPropertyWithoutEscape = function setPropertyWithoutEscape(name, value) {
+			this[name] = value;
+			if (this.raws) delete this.raws[name];
+		};
+		_proto.isAtPosition = function isAtPosition(line, column) {
+			if (this.source && this.source.start && this.source.end) {
+				if (this.source.start.line > line) return false;
+				if (this.source.end.line < line) return false;
+				if (this.source.start.line === line && this.source.start.column > column) return false;
+				if (this.source.end.line === line && this.source.end.column < column) return false;
+				return true;
+			}
+		};
+		_proto.stringifyProperty = function stringifyProperty(name) {
+			return this.raws && this.raws[name] || this[name];
+		};
+		_proto.valueToString = function valueToString() {
+			return String(this.stringifyProperty("value"));
+		};
+		_proto.toString = function toString$1() {
+			return [
+				this.rawSpaceBefore,
+				this.valueToString(),
+				this.rawSpaceAfter
+			].join("");
+		};
+		_createClass$6(Node$1, [{
+			key: "rawSpaceBefore",
+			get: function get() {
+				var rawSpace = this.raws && this.raws.spaces && this.raws.spaces.before;
+				if (rawSpace === void 0) rawSpace = this.spaces && this.spaces.before;
+				return rawSpace || "";
+			},
+			set: function set(raw) {
+				(0, _util$3.ensureObject)(this, "raws", "spaces");
+				this.raws.spaces.before = raw;
+			}
+		}, {
+			key: "rawSpaceAfter",
+			get: function get() {
+				var rawSpace = this.raws && this.raws.spaces && this.raws.spaces.after;
+				if (rawSpace === void 0) rawSpace = this.spaces.after;
+				return rawSpace || "";
+			},
+			set: function set(raw) {
+				(0, _util$3.ensureObject)(this, "raws", "spaces");
+				this.raws.spaces.after = raw;
+			}
+		}]);
+		return Node$1;
+	}();
+	exports["default"] = Node;
+	module.exports = exports.default;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-selector-parser@7.1.0/node_modules/postcss-selector-parser/dist/selectors/types.js
+var require_types = /* @__PURE__ */ __commonJSMin(((exports) => {
+	exports.__esModule = true;
+	exports.UNIVERSAL = exports.TAG = exports.STRING = exports.SELECTOR = exports.ROOT = exports.PSEUDO = exports.NESTING = exports.ID = exports.COMMENT = exports.COMBINATOR = exports.CLASS = exports.ATTRIBUTE = void 0;
+	var TAG = "tag";
+	exports.TAG = TAG;
+	var STRING = "string";
+	exports.STRING = STRING;
+	var SELECTOR = "selector";
+	exports.SELECTOR = SELECTOR;
+	var ROOT = "root";
+	exports.ROOT = ROOT;
+	var PSEUDO = "pseudo";
+	exports.PSEUDO = PSEUDO;
+	var NESTING = "nesting";
+	exports.NESTING = NESTING;
+	var ID$1 = "id";
+	exports.ID = ID$1;
+	var COMMENT = "comment";
+	exports.COMMENT = COMMENT;
+	var COMBINATOR = "combinator";
+	exports.COMBINATOR = COMBINATOR;
+	var CLASS = "class";
+	exports.CLASS = CLASS;
+	var ATTRIBUTE = "attribute";
+	exports.ATTRIBUTE = ATTRIBUTE;
+	var UNIVERSAL = "universal";
+	exports.UNIVERSAL = UNIVERSAL;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-selector-parser@7.1.0/node_modules/postcss-selector-parser/dist/selectors/container.js
+var require_container = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	exports.__esModule = true;
+	exports["default"] = void 0;
+	var _node$7 = _interopRequireDefault$19(require_node$1());
+	var types$1 = _interopRequireWildcard$3(require_types());
+	function _getRequireWildcardCache$3(nodeInterop) {
+		if (typeof WeakMap !== "function") return null;
+		var cacheBabelInterop = /* @__PURE__ */ new WeakMap();
+		var cacheNodeInterop = /* @__PURE__ */ new WeakMap();
+		return (_getRequireWildcardCache$3 = function _getRequireWildcardCache$4(nodeInterop$1) {
+			return nodeInterop$1 ? cacheNodeInterop : cacheBabelInterop;
+		})(nodeInterop);
+	}
+	function _interopRequireWildcard$3(obj, nodeInterop) {
+		if (!nodeInterop && obj && obj.__esModule) return obj;
+		if (obj === null || typeof obj !== "object" && typeof obj !== "function") return { "default": obj };
+		var cache = _getRequireWildcardCache$3(nodeInterop);
+		if (cache && cache.has(obj)) return cache.get(obj);
+		var newObj = {};
+		var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+		for (var key in obj) if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+			var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+			if (desc && (desc.get || desc.set)) Object.defineProperty(newObj, key, desc);
+			else newObj[key] = obj[key];
+		}
+		newObj["default"] = obj;
+		if (cache) cache.set(obj, newObj);
+		return newObj;
+	}
+	function _interopRequireDefault$19(obj) {
+		return obj && obj.__esModule ? obj : { "default": obj };
+	}
+	function _createForOfIteratorHelperLoose(o, allowArrayLike) {
+		var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
+		if (it) return (it = it.call(o)).next.bind(it);
+		if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
+			if (it) o = it;
+			var i$1 = 0;
+			return function() {
+				if (i$1 >= o.length) return { done: true };
+				return {
+					done: false,
+					value: o[i$1++]
+				};
+			};
+		}
+		throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+	}
+	function _unsupportedIterableToArray(o, minLen) {
+		if (!o) return;
+		if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+		var n = Object.prototype.toString.call(o).slice(8, -1);
+		if (n === "Object" && o.constructor) n = o.constructor.name;
+		if (n === "Map" || n === "Set") return Array.from(o);
+		if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+	}
+	function _arrayLikeToArray(arr, len) {
+		if (len == null || len > arr.length) len = arr.length;
+		for (var i$1 = 0, arr2 = new Array(len); i$1 < len; i$1++) arr2[i$1] = arr[i$1];
+		return arr2;
+	}
+	function _defineProperties$5(target, props) {
+		for (var i$1 = 0; i$1 < props.length; i$1++) {
+			var descriptor = props[i$1];
+			descriptor.enumerable = descriptor.enumerable || false;
+			descriptor.configurable = true;
+			if ("value" in descriptor) descriptor.writable = true;
+			Object.defineProperty(target, descriptor.key, descriptor);
+		}
+	}
+	function _createClass$5(Constructor, protoProps, staticProps) {
+		if (protoProps) _defineProperties$5(Constructor.prototype, protoProps);
+		if (staticProps) _defineProperties$5(Constructor, staticProps);
+		Object.defineProperty(Constructor, "prototype", { writable: false });
+		return Constructor;
+	}
+	function _inheritsLoose$13(subClass, superClass) {
+		subClass.prototype = Object.create(superClass.prototype);
+		subClass.prototype.constructor = subClass;
+		_setPrototypeOf$13(subClass, superClass);
+	}
+	function _setPrototypeOf$13(o, p) {
+		_setPrototypeOf$13 = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf$14(o$1, p$1) {
+			o$1.__proto__ = p$1;
+			return o$1;
+		};
+		return _setPrototypeOf$13(o, p);
+	}
+	var Container = /* @__PURE__ */ function(_Node) {
+		_inheritsLoose$13(Container$1, _Node);
+		function Container$1(opts) {
+			var _this = _Node.call(this, opts) || this;
+			if (!_this.nodes) _this.nodes = [];
+			return _this;
+		}
+		var _proto = Container$1.prototype;
+		_proto.append = function append(selector$1) {
+			selector$1.parent = this;
+			this.nodes.push(selector$1);
+			return this;
+		};
+		_proto.prepend = function prepend(selector$1) {
+			selector$1.parent = this;
+			this.nodes.unshift(selector$1);
+			for (var id$1 in this.indexes) this.indexes[id$1]++;
+			return this;
+		};
+		_proto.at = function at$1(index) {
+			return this.nodes[index];
+		};
+		_proto.index = function index(child) {
+			if (typeof child === "number") return child;
+			return this.nodes.indexOf(child);
+		};
+		_proto.removeChild = function removeChild(child) {
+			child = this.index(child);
+			this.at(child).parent = void 0;
+			this.nodes.splice(child, 1);
+			var index;
+			for (var id$1 in this.indexes) {
+				index = this.indexes[id$1];
+				if (index >= child) this.indexes[id$1] = index - 1;
+			}
+			return this;
+		};
+		_proto.removeAll = function removeAll() {
+			for (var _iterator = _createForOfIteratorHelperLoose(this.nodes), _step; !(_step = _iterator()).done;) {
+				var node = _step.value;
+				node.parent = void 0;
+			}
+			this.nodes = [];
+			return this;
+		};
+		_proto.empty = function empty() {
+			return this.removeAll();
+		};
+		_proto.insertAfter = function insertAfter(oldNode, newNode) {
+			var _this$nodes;
+			newNode.parent = this;
+			var oldIndex = this.index(oldNode);
+			var resetNode = [];
+			for (var i$1 = 2; i$1 < arguments.length; i$1++) resetNode.push(arguments[i$1]);
+			(_this$nodes = this.nodes).splice.apply(_this$nodes, [
+				oldIndex + 1,
+				0,
+				newNode
+			].concat(resetNode));
+			newNode.parent = this;
+			var index;
+			for (var id$1 in this.indexes) {
+				index = this.indexes[id$1];
+				if (oldIndex < index) this.indexes[id$1] = index + arguments.length - 1;
+			}
+			return this;
+		};
+		_proto.insertBefore = function insertBefore(oldNode, newNode) {
+			var _this$nodes2;
+			newNode.parent = this;
+			var oldIndex = this.index(oldNode);
+			var resetNode = [];
+			for (var i$1 = 2; i$1 < arguments.length; i$1++) resetNode.push(arguments[i$1]);
+			(_this$nodes2 = this.nodes).splice.apply(_this$nodes2, [
+				oldIndex,
+				0,
+				newNode
+			].concat(resetNode));
+			newNode.parent = this;
+			var index;
+			for (var id$1 in this.indexes) {
+				index = this.indexes[id$1];
+				if (index >= oldIndex) this.indexes[id$1] = index + arguments.length - 1;
+			}
+			return this;
+		};
+		_proto._findChildAtPosition = function _findChildAtPosition(line, col) {
+			var found = void 0;
+			this.each(function(node) {
+				if (node.atPosition) {
+					var foundChild = node.atPosition(line, col);
+					if (foundChild) {
+						found = foundChild;
+						return false;
+					}
+				} else if (node.isAtPosition(line, col)) {
+					found = node;
+					return false;
+				}
+			});
+			return found;
+		};
+		_proto.atPosition = function atPosition(line, col) {
+			if (this.isAtPosition(line, col)) return this._findChildAtPosition(line, col) || this;
+			else return;
+		};
+		_proto._inferEndPosition = function _inferEndPosition() {
+			if (this.last && this.last.source && this.last.source.end) {
+				this.source = this.source || {};
+				this.source.end = this.source.end || {};
+				Object.assign(this.source.end, this.last.source.end);
+			}
+		};
+		_proto.each = function each(callback) {
+			if (!this.lastEach) this.lastEach = 0;
+			if (!this.indexes) this.indexes = {};
+			this.lastEach++;
+			var id$1 = this.lastEach;
+			this.indexes[id$1] = 0;
+			if (!this.length) return;
+			var index, result;
+			while (this.indexes[id$1] < this.length) {
+				index = this.indexes[id$1];
+				result = callback(this.at(index), index);
+				if (result === false) break;
+				this.indexes[id$1] += 1;
+			}
+			delete this.indexes[id$1];
+			if (result === false) return false;
+		};
+		_proto.walk = function walk(callback) {
+			return this.each(function(node, i$1) {
+				var result = callback(node, i$1);
+				if (result !== false && node.length) result = node.walk(callback);
+				if (result === false) return false;
+			});
+		};
+		_proto.walkAttributes = function walkAttributes(callback) {
+			var _this2 = this;
+			return this.walk(function(selector$1) {
+				if (selector$1.type === types$1.ATTRIBUTE) return callback.call(_this2, selector$1);
+			});
+		};
+		_proto.walkClasses = function walkClasses(callback) {
+			var _this3 = this;
+			return this.walk(function(selector$1) {
+				if (selector$1.type === types$1.CLASS) return callback.call(_this3, selector$1);
+			});
+		};
+		_proto.walkCombinators = function walkCombinators(callback) {
+			var _this4 = this;
+			return this.walk(function(selector$1) {
+				if (selector$1.type === types$1.COMBINATOR) return callback.call(_this4, selector$1);
+			});
+		};
+		_proto.walkComments = function walkComments(callback) {
+			var _this5 = this;
+			return this.walk(function(selector$1) {
+				if (selector$1.type === types$1.COMMENT) return callback.call(_this5, selector$1);
+			});
+		};
+		_proto.walkIds = function walkIds(callback) {
+			var _this6 = this;
+			return this.walk(function(selector$1) {
+				if (selector$1.type === types$1.ID) return callback.call(_this6, selector$1);
+			});
+		};
+		_proto.walkNesting = function walkNesting(callback) {
+			var _this7 = this;
+			return this.walk(function(selector$1) {
+				if (selector$1.type === types$1.NESTING) return callback.call(_this7, selector$1);
+			});
+		};
+		_proto.walkPseudos = function walkPseudos(callback) {
+			var _this8 = this;
+			return this.walk(function(selector$1) {
+				if (selector$1.type === types$1.PSEUDO) return callback.call(_this8, selector$1);
+			});
+		};
+		_proto.walkTags = function walkTags(callback) {
+			var _this9 = this;
+			return this.walk(function(selector$1) {
+				if (selector$1.type === types$1.TAG) return callback.call(_this9, selector$1);
+			});
+		};
+		_proto.walkUniversals = function walkUniversals(callback) {
+			var _this10 = this;
+			return this.walk(function(selector$1) {
+				if (selector$1.type === types$1.UNIVERSAL) return callback.call(_this10, selector$1);
+			});
+		};
+		_proto.split = function split(callback) {
+			var _this11 = this;
+			var current = [];
+			return this.reduce(function(memo, node, index) {
+				var split$1 = callback.call(_this11, node);
+				current.push(node);
+				if (split$1) {
+					memo.push(current);
+					current = [];
+				} else if (index === _this11.length - 1) memo.push(current);
+				return memo;
+			}, []);
+		};
+		_proto.map = function map(callback) {
+			return this.nodes.map(callback);
+		};
+		_proto.reduce = function reduce(callback, memo) {
+			return this.nodes.reduce(callback, memo);
+		};
+		_proto.every = function every(callback) {
+			return this.nodes.every(callback);
+		};
+		_proto.some = function some(callback) {
+			return this.nodes.some(callback);
+		};
+		_proto.filter = function filter(callback) {
+			return this.nodes.filter(callback);
+		};
+		_proto.sort = function sort(callback) {
+			return this.nodes.sort(callback);
+		};
+		_proto.toString = function toString$1() {
+			return this.map(String).join("");
+		};
+		_createClass$5(Container$1, [
+			{
+				key: "first",
+				get: function get() {
+					return this.at(0);
+				}
+			},
+			{
+				key: "last",
+				get: function get() {
+					return this.at(this.length - 1);
+				}
+			},
+			{
+				key: "length",
+				get: function get() {
+					return this.nodes.length;
+				}
+			}
+		]);
+		return Container$1;
+	}(_node$7["default"]);
+	exports["default"] = Container;
+	module.exports = exports.default;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-selector-parser@7.1.0/node_modules/postcss-selector-parser/dist/selectors/root.js
+var require_root = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	exports.__esModule = true;
+	exports["default"] = void 0;
+	var _container$2 = _interopRequireDefault$18(require_container());
+	var _types$13 = require_types();
+	function _interopRequireDefault$18(obj) {
+		return obj && obj.__esModule ? obj : { "default": obj };
+	}
+	function _defineProperties$4(target, props) {
+		for (var i$1 = 0; i$1 < props.length; i$1++) {
+			var descriptor = props[i$1];
+			descriptor.enumerable = descriptor.enumerable || false;
+			descriptor.configurable = true;
+			if ("value" in descriptor) descriptor.writable = true;
+			Object.defineProperty(target, descriptor.key, descriptor);
+		}
+	}
+	function _createClass$4(Constructor, protoProps, staticProps) {
+		if (protoProps) _defineProperties$4(Constructor.prototype, protoProps);
+		if (staticProps) _defineProperties$4(Constructor, staticProps);
+		Object.defineProperty(Constructor, "prototype", { writable: false });
+		return Constructor;
+	}
+	function _inheritsLoose$12(subClass, superClass) {
+		subClass.prototype = Object.create(superClass.prototype);
+		subClass.prototype.constructor = subClass;
+		_setPrototypeOf$12(subClass, superClass);
+	}
+	function _setPrototypeOf$12(o, p) {
+		_setPrototypeOf$12 = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf$14(o$1, p$1) {
+			o$1.__proto__ = p$1;
+			return o$1;
+		};
+		return _setPrototypeOf$12(o, p);
+	}
+	var Root = /* @__PURE__ */ function(_Container) {
+		_inheritsLoose$12(Root$1, _Container);
+		function Root$1(opts) {
+			var _this = _Container.call(this, opts) || this;
+			_this.type = _types$13.ROOT;
+			return _this;
+		}
+		var _proto = Root$1.prototype;
+		_proto.toString = function toString$1() {
+			var str$1 = this.reduce(function(memo, selector$1) {
+				memo.push(String(selector$1));
+				return memo;
+			}, []).join(",");
+			return this.trailingComma ? str$1 + "," : str$1;
+		};
+		_proto.error = function error(message, options) {
+			if (this._error) return this._error(message, options);
+			else return new Error(message);
+		};
+		_createClass$4(Root$1, [{
+			key: "errorGenerator",
+			set: function set(handler) {
+				this._error = handler;
+			}
+		}]);
+		return Root$1;
+	}(_container$2["default"]);
+	exports["default"] = Root;
+	module.exports = exports.default;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-selector-parser@7.1.0/node_modules/postcss-selector-parser/dist/selectors/selector.js
+var require_selector = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	exports.__esModule = true;
+	exports["default"] = void 0;
+	var _container$1 = _interopRequireDefault$17(require_container());
+	var _types$12 = require_types();
+	function _interopRequireDefault$17(obj) {
+		return obj && obj.__esModule ? obj : { "default": obj };
+	}
+	function _inheritsLoose$11(subClass, superClass) {
+		subClass.prototype = Object.create(superClass.prototype);
+		subClass.prototype.constructor = subClass;
+		_setPrototypeOf$11(subClass, superClass);
+	}
+	function _setPrototypeOf$11(o, p) {
+		_setPrototypeOf$11 = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf$14(o$1, p$1) {
+			o$1.__proto__ = p$1;
+			return o$1;
+		};
+		return _setPrototypeOf$11(o, p);
+	}
+	var Selector = /* @__PURE__ */ function(_Container) {
+		_inheritsLoose$11(Selector$1, _Container);
+		function Selector$1(opts) {
+			var _this = _Container.call(this, opts) || this;
+			_this.type = _types$12.SELECTOR;
+			return _this;
+		}
+		return Selector$1;
+	}(_container$1["default"]);
+	exports["default"] = Selector;
+	module.exports = exports.default;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/cssesc@3.0.0/node_modules/cssesc/cssesc.js
+/*! https://mths.be/cssesc v3.0.0 by @mathias */
+var require_cssesc = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var hasOwnProperty$1 = {}.hasOwnProperty;
+	var merge = function merge$1(options, defaults) {
+		if (!options) return defaults;
+		var result = {};
+		for (var key in defaults) result[key] = hasOwnProperty$1.call(options, key) ? options[key] : defaults[key];
+		return result;
+	};
+	var regexAnySingleEscape = /[ -,\.\/:-@\[-\^`\{-~]/;
+	var regexSingleEscape = /[ -,\.\/:-@\[\]\^`\{-~]/;
+	var regexExcessiveSpaces = /(^|\\+)?(\\[A-F0-9]{1,6})\x20(?![a-fA-F0-9\x20])/g;
+	var cssesc = function cssesc$1(string$1, options) {
+		options = merge(options, cssesc$1.options);
+		if (options.quotes != "single" && options.quotes != "double") options.quotes = "single";
+		var quote = options.quotes == "double" ? "\"" : "'";
+		var isIdentifier$1 = options.isIdentifier;
+		var firstChar = string$1.charAt(0);
+		var output = "";
+		var counter = 0;
+		var length = string$1.length;
+		while (counter < length) {
+			var character = string$1.charAt(counter++);
+			var codePoint = character.charCodeAt();
+			var value = void 0;
+			if (codePoint < 32 || codePoint > 126) {
+				if (codePoint >= 55296 && codePoint <= 56319 && counter < length) {
+					var extra = string$1.charCodeAt(counter++);
+					if ((extra & 64512) == 56320) codePoint = ((codePoint & 1023) << 10) + (extra & 1023) + 65536;
+					else counter--;
+				}
+				value = "\\" + codePoint.toString(16).toUpperCase() + " ";
+			} else if (options.escapeEverything) if (regexAnySingleEscape.test(character)) value = "\\" + character;
+			else value = "\\" + codePoint.toString(16).toUpperCase() + " ";
+			else if (/[\t\n\f\r\x0B]/.test(character)) value = "\\" + codePoint.toString(16).toUpperCase() + " ";
+			else if (character == "\\" || !isIdentifier$1 && (character == "\"" && quote == character || character == "'" && quote == character) || isIdentifier$1 && regexSingleEscape.test(character)) value = "\\" + character;
+			else value = character;
+			output += value;
+		}
+		if (isIdentifier$1) {
+			if (/^-[-\d]/.test(output)) output = "\\-" + output.slice(1);
+			else if (/\d/.test(firstChar)) output = "\\3" + firstChar + " " + output.slice(1);
+		}
+		output = output.replace(regexExcessiveSpaces, function($0, $1, $2) {
+			if ($1 && $1.length % 2) return $0;
+			return ($1 || "") + $2;
+		});
+		if (!isIdentifier$1 && options.wrap) return quote + output + quote;
+		return output;
+	};
+	cssesc.options = {
+		"escapeEverything": false,
+		"isIdentifier": false,
+		"quotes": "single",
+		"wrap": false
+	};
+	cssesc.version = "3.0.0";
+	module.exports = cssesc;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-selector-parser@7.1.0/node_modules/postcss-selector-parser/dist/selectors/className.js
+var require_className = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	exports.__esModule = true;
+	exports["default"] = void 0;
+	var _cssesc$2 = _interopRequireDefault$16(require_cssesc());
+	var _util$2 = require_util();
+	var _node$6 = _interopRequireDefault$16(require_node$1());
+	var _types$11 = require_types();
+	function _interopRequireDefault$16(obj) {
+		return obj && obj.__esModule ? obj : { "default": obj };
+	}
+	function _defineProperties$3(target, props) {
+		for (var i$1 = 0; i$1 < props.length; i$1++) {
+			var descriptor = props[i$1];
+			descriptor.enumerable = descriptor.enumerable || false;
+			descriptor.configurable = true;
+			if ("value" in descriptor) descriptor.writable = true;
+			Object.defineProperty(target, descriptor.key, descriptor);
+		}
+	}
+	function _createClass$3(Constructor, protoProps, staticProps) {
+		if (protoProps) _defineProperties$3(Constructor.prototype, protoProps);
+		if (staticProps) _defineProperties$3(Constructor, staticProps);
+		Object.defineProperty(Constructor, "prototype", { writable: false });
+		return Constructor;
+	}
+	function _inheritsLoose$10(subClass, superClass) {
+		subClass.prototype = Object.create(superClass.prototype);
+		subClass.prototype.constructor = subClass;
+		_setPrototypeOf$10(subClass, superClass);
+	}
+	function _setPrototypeOf$10(o, p) {
+		_setPrototypeOf$10 = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf$14(o$1, p$1) {
+			o$1.__proto__ = p$1;
+			return o$1;
+		};
+		return _setPrototypeOf$10(o, p);
+	}
+	var ClassName = /* @__PURE__ */ function(_Node) {
+		_inheritsLoose$10(ClassName$1, _Node);
+		function ClassName$1(opts) {
+			var _this = _Node.call(this, opts) || this;
+			_this.type = _types$11.CLASS;
+			_this._constructed = true;
+			return _this;
+		}
+		var _proto = ClassName$1.prototype;
+		_proto.valueToString = function valueToString() {
+			return "." + _Node.prototype.valueToString.call(this);
+		};
+		_createClass$3(ClassName$1, [{
+			key: "value",
+			get: function get() {
+				return this._value;
+			},
+			set: function set(v) {
+				if (this._constructed) {
+					var escaped = (0, _cssesc$2["default"])(v, { isIdentifier: true });
+					if (escaped !== v) {
+						(0, _util$2.ensureObject)(this, "raws");
+						this.raws.value = escaped;
+					} else if (this.raws) delete this.raws.value;
+				}
+				this._value = v;
+			}
+		}]);
+		return ClassName$1;
+	}(_node$6["default"]);
+	exports["default"] = ClassName;
+	module.exports = exports.default;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-selector-parser@7.1.0/node_modules/postcss-selector-parser/dist/selectors/comment.js
+var require_comment = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	exports.__esModule = true;
+	exports["default"] = void 0;
+	var _node$5 = _interopRequireDefault$15(require_node$1());
+	var _types$10 = require_types();
+	function _interopRequireDefault$15(obj) {
+		return obj && obj.__esModule ? obj : { "default": obj };
+	}
+	function _inheritsLoose$9(subClass, superClass) {
+		subClass.prototype = Object.create(superClass.prototype);
+		subClass.prototype.constructor = subClass;
+		_setPrototypeOf$9(subClass, superClass);
+	}
+	function _setPrototypeOf$9(o, p) {
+		_setPrototypeOf$9 = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf$14(o$1, p$1) {
+			o$1.__proto__ = p$1;
+			return o$1;
+		};
+		return _setPrototypeOf$9(o, p);
+	}
+	var Comment = /* @__PURE__ */ function(_Node) {
+		_inheritsLoose$9(Comment$1, _Node);
+		function Comment$1(opts) {
+			var _this = _Node.call(this, opts) || this;
+			_this.type = _types$10.COMMENT;
+			return _this;
+		}
+		return Comment$1;
+	}(_node$5["default"]);
+	exports["default"] = Comment;
+	module.exports = exports.default;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-selector-parser@7.1.0/node_modules/postcss-selector-parser/dist/selectors/id.js
+var require_id = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	exports.__esModule = true;
+	exports["default"] = void 0;
+	var _node$4 = _interopRequireDefault$14(require_node$1());
+	var _types$9 = require_types();
+	function _interopRequireDefault$14(obj) {
+		return obj && obj.__esModule ? obj : { "default": obj };
+	}
+	function _inheritsLoose$8(subClass, superClass) {
+		subClass.prototype = Object.create(superClass.prototype);
+		subClass.prototype.constructor = subClass;
+		_setPrototypeOf$8(subClass, superClass);
+	}
+	function _setPrototypeOf$8(o, p) {
+		_setPrototypeOf$8 = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf$14(o$1, p$1) {
+			o$1.__proto__ = p$1;
+			return o$1;
+		};
+		return _setPrototypeOf$8(o, p);
+	}
+	var ID = /* @__PURE__ */ function(_Node) {
+		_inheritsLoose$8(ID$2, _Node);
+		function ID$2(opts) {
+			var _this = _Node.call(this, opts) || this;
+			_this.type = _types$9.ID;
+			return _this;
+		}
+		var _proto = ID$2.prototype;
+		_proto.valueToString = function valueToString() {
+			return "#" + _Node.prototype.valueToString.call(this);
+		};
+		return ID$2;
+	}(_node$4["default"]);
+	exports["default"] = ID;
+	module.exports = exports.default;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-selector-parser@7.1.0/node_modules/postcss-selector-parser/dist/selectors/namespace.js
+var require_namespace = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	exports.__esModule = true;
+	exports["default"] = void 0;
+	var _cssesc$1 = _interopRequireDefault$13(require_cssesc());
+	var _util$1 = require_util();
+	var _node$3 = _interopRequireDefault$13(require_node$1());
+	function _interopRequireDefault$13(obj) {
+		return obj && obj.__esModule ? obj : { "default": obj };
+	}
+	function _defineProperties$2(target, props) {
+		for (var i$1 = 0; i$1 < props.length; i$1++) {
+			var descriptor = props[i$1];
+			descriptor.enumerable = descriptor.enumerable || false;
+			descriptor.configurable = true;
+			if ("value" in descriptor) descriptor.writable = true;
+			Object.defineProperty(target, descriptor.key, descriptor);
+		}
+	}
+	function _createClass$2(Constructor, protoProps, staticProps) {
+		if (protoProps) _defineProperties$2(Constructor.prototype, protoProps);
+		if (staticProps) _defineProperties$2(Constructor, staticProps);
+		Object.defineProperty(Constructor, "prototype", { writable: false });
+		return Constructor;
+	}
+	function _inheritsLoose$7(subClass, superClass) {
+		subClass.prototype = Object.create(superClass.prototype);
+		subClass.prototype.constructor = subClass;
+		_setPrototypeOf$7(subClass, superClass);
+	}
+	function _setPrototypeOf$7(o, p) {
+		_setPrototypeOf$7 = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf$14(o$1, p$1) {
+			o$1.__proto__ = p$1;
+			return o$1;
+		};
+		return _setPrototypeOf$7(o, p);
+	}
+	var Namespace = /* @__PURE__ */ function(_Node) {
+		_inheritsLoose$7(Namespace$1, _Node);
+		function Namespace$1() {
+			return _Node.apply(this, arguments) || this;
+		}
+		var _proto = Namespace$1.prototype;
+		_proto.qualifiedName = function qualifiedName(value) {
+			if (this.namespace) return this.namespaceString + "|" + value;
+			else return value;
+		};
+		_proto.valueToString = function valueToString() {
+			return this.qualifiedName(_Node.prototype.valueToString.call(this));
+		};
+		_createClass$2(Namespace$1, [
+			{
+				key: "namespace",
+				get: function get() {
+					return this._namespace;
+				},
+				set: function set(namespace) {
+					if (namespace === true || namespace === "*" || namespace === "&") {
+						this._namespace = namespace;
+						if (this.raws) delete this.raws.namespace;
+						return;
+					}
+					var escaped = (0, _cssesc$1["default"])(namespace, { isIdentifier: true });
+					this._namespace = namespace;
+					if (escaped !== namespace) {
+						(0, _util$1.ensureObject)(this, "raws");
+						this.raws.namespace = escaped;
+					} else if (this.raws) delete this.raws.namespace;
+				}
+			},
+			{
+				key: "ns",
+				get: function get() {
+					return this._namespace;
+				},
+				set: function set(namespace) {
+					this.namespace = namespace;
+				}
+			},
+			{
+				key: "namespaceString",
+				get: function get() {
+					if (this.namespace) {
+						var ns = this.stringifyProperty("namespace");
+						if (ns === true) return "";
+						else return ns;
+					} else return "";
+				}
+			}
+		]);
+		return Namespace$1;
+	}(_node$3["default"]);
+	exports["default"] = Namespace;
+	module.exports = exports.default;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-selector-parser@7.1.0/node_modules/postcss-selector-parser/dist/selectors/tag.js
+var require_tag = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	exports.__esModule = true;
+	exports["default"] = void 0;
+	var _namespace$2 = _interopRequireDefault$12(require_namespace());
+	var _types$8 = require_types();
+	function _interopRequireDefault$12(obj) {
+		return obj && obj.__esModule ? obj : { "default": obj };
+	}
+	function _inheritsLoose$6(subClass, superClass) {
+		subClass.prototype = Object.create(superClass.prototype);
+		subClass.prototype.constructor = subClass;
+		_setPrototypeOf$6(subClass, superClass);
+	}
+	function _setPrototypeOf$6(o, p) {
+		_setPrototypeOf$6 = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf$14(o$1, p$1) {
+			o$1.__proto__ = p$1;
+			return o$1;
+		};
+		return _setPrototypeOf$6(o, p);
+	}
+	var Tag = /* @__PURE__ */ function(_Namespace) {
+		_inheritsLoose$6(Tag$1, _Namespace);
+		function Tag$1(opts) {
+			var _this = _Namespace.call(this, opts) || this;
+			_this.type = _types$8.TAG;
+			return _this;
+		}
+		return Tag$1;
+	}(_namespace$2["default"]);
+	exports["default"] = Tag;
+	module.exports = exports.default;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-selector-parser@7.1.0/node_modules/postcss-selector-parser/dist/selectors/string.js
+var require_string = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	exports.__esModule = true;
+	exports["default"] = void 0;
+	var _node$2 = _interopRequireDefault$11(require_node$1());
+	var _types$7 = require_types();
+	function _interopRequireDefault$11(obj) {
+		return obj && obj.__esModule ? obj : { "default": obj };
+	}
+	function _inheritsLoose$5(subClass, superClass) {
+		subClass.prototype = Object.create(superClass.prototype);
+		subClass.prototype.constructor = subClass;
+		_setPrototypeOf$5(subClass, superClass);
+	}
+	function _setPrototypeOf$5(o, p) {
+		_setPrototypeOf$5 = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf$14(o$1, p$1) {
+			o$1.__proto__ = p$1;
+			return o$1;
+		};
+		return _setPrototypeOf$5(o, p);
+	}
+	var String$1 = /* @__PURE__ */ function(_Node) {
+		_inheritsLoose$5(String$2, _Node);
+		function String$2(opts) {
+			var _this = _Node.call(this, opts) || this;
+			_this.type = _types$7.STRING;
+			return _this;
+		}
+		return String$2;
+	}(_node$2["default"]);
+	exports["default"] = String$1;
+	module.exports = exports.default;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-selector-parser@7.1.0/node_modules/postcss-selector-parser/dist/selectors/pseudo.js
+var require_pseudo = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	exports.__esModule = true;
+	exports["default"] = void 0;
+	var _container = _interopRequireDefault$10(require_container());
+	var _types$6 = require_types();
+	function _interopRequireDefault$10(obj) {
+		return obj && obj.__esModule ? obj : { "default": obj };
+	}
+	function _inheritsLoose$4(subClass, superClass) {
+		subClass.prototype = Object.create(superClass.prototype);
+		subClass.prototype.constructor = subClass;
+		_setPrototypeOf$4(subClass, superClass);
+	}
+	function _setPrototypeOf$4(o, p) {
+		_setPrototypeOf$4 = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf$14(o$1, p$1) {
+			o$1.__proto__ = p$1;
+			return o$1;
+		};
+		return _setPrototypeOf$4(o, p);
+	}
+	var Pseudo = /* @__PURE__ */ function(_Container) {
+		_inheritsLoose$4(Pseudo$1, _Container);
+		function Pseudo$1(opts) {
+			var _this = _Container.call(this, opts) || this;
+			_this.type = _types$6.PSEUDO;
+			return _this;
+		}
+		var _proto = Pseudo$1.prototype;
+		_proto.toString = function toString$1() {
+			var params = this.length ? "(" + this.map(String).join(",") + ")" : "";
+			return [
+				this.rawSpaceBefore,
+				this.stringifyProperty("value"),
+				params,
+				this.rawSpaceAfter
+			].join("");
+		};
+		return Pseudo$1;
+	}(_container["default"]);
+	exports["default"] = Pseudo;
+	module.exports = exports.default;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/util-deprecate@1.0.2/node_modules/util-deprecate/node.js
+var require_node = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* For Node.js, simply re-export the core `util.deprecate` function.
+	*/
+	module.exports = __require("util").deprecate;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-selector-parser@7.1.0/node_modules/postcss-selector-parser/dist/selectors/attribute.js
+var require_attribute = /* @__PURE__ */ __commonJSMin(((exports) => {
+	exports.__esModule = true;
+	exports["default"] = void 0;
+	exports.unescapeValue = unescapeValue;
+	var _cssesc = _interopRequireDefault$9(require_cssesc());
+	var _unesc = _interopRequireDefault$9(require_unesc());
+	var _namespace$1 = _interopRequireDefault$9(require_namespace());
+	var _types$5 = require_types();
+	var _CSSESC_QUOTE_OPTIONS;
+	function _interopRequireDefault$9(obj) {
+		return obj && obj.__esModule ? obj : { "default": obj };
+	}
+	function _defineProperties$1(target, props) {
+		for (var i$1 = 0; i$1 < props.length; i$1++) {
+			var descriptor = props[i$1];
+			descriptor.enumerable = descriptor.enumerable || false;
+			descriptor.configurable = true;
+			if ("value" in descriptor) descriptor.writable = true;
+			Object.defineProperty(target, descriptor.key, descriptor);
+		}
+	}
+	function _createClass$1(Constructor, protoProps, staticProps) {
+		if (protoProps) _defineProperties$1(Constructor.prototype, protoProps);
+		if (staticProps) _defineProperties$1(Constructor, staticProps);
+		Object.defineProperty(Constructor, "prototype", { writable: false });
+		return Constructor;
+	}
+	function _inheritsLoose$3(subClass, superClass) {
+		subClass.prototype = Object.create(superClass.prototype);
+		subClass.prototype.constructor = subClass;
+		_setPrototypeOf$3(subClass, superClass);
+	}
+	function _setPrototypeOf$3(o, p) {
+		_setPrototypeOf$3 = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf$14(o$1, p$1) {
+			o$1.__proto__ = p$1;
+			return o$1;
+		};
+		return _setPrototypeOf$3(o, p);
+	}
+	var deprecate = require_node();
+	var WRAPPED_IN_QUOTES = /^('|")([^]*)\1$/;
+	var warnOfDeprecatedValueAssignment = deprecate(function() {}, "Assigning an attribute a value containing characters that might need to be escaped is deprecated. Call attribute.setValue() instead.");
+	var warnOfDeprecatedQuotedAssignment = deprecate(function() {}, "Assigning attr.quoted is deprecated and has no effect. Assign to attr.quoteMark instead.");
+	var warnOfDeprecatedConstructor = deprecate(function() {}, "Constructing an Attribute selector with a value without specifying quoteMark is deprecated. Note: The value should be unescaped now.");
+	function unescapeValue(value) {
+		var deprecatedUsage = false;
+		var quoteMark = null;
+		var unescaped = value;
+		var m = unescaped.match(WRAPPED_IN_QUOTES);
+		if (m) {
+			quoteMark = m[1];
+			unescaped = m[2];
+		}
+		unescaped = (0, _unesc["default"])(unescaped);
+		if (unescaped !== value) deprecatedUsage = true;
+		return {
+			deprecatedUsage,
+			unescaped,
+			quoteMark
+		};
+	}
+	function handleDeprecatedContructorOpts(opts) {
+		if (opts.quoteMark !== void 0) return opts;
+		if (opts.value === void 0) return opts;
+		warnOfDeprecatedConstructor();
+		var _unescapeValue = unescapeValue(opts.value), quoteMark = _unescapeValue.quoteMark, unescaped = _unescapeValue.unescaped;
+		if (!opts.raws) opts.raws = {};
+		if (opts.raws.value === void 0) opts.raws.value = opts.value;
+		opts.value = unescaped;
+		opts.quoteMark = quoteMark;
+		return opts;
+	}
+	var Attribute = /* @__PURE__ */ function(_Namespace) {
+		_inheritsLoose$3(Attribute$1, _Namespace);
+		function Attribute$1(opts) {
+			var _this;
+			if (opts === void 0) opts = {};
+			_this = _Namespace.call(this, handleDeprecatedContructorOpts(opts)) || this;
+			_this.type = _types$5.ATTRIBUTE;
+			_this.raws = _this.raws || {};
+			Object.defineProperty(_this.raws, "unquoted", {
+				get: deprecate(function() {
+					return _this.value;
+				}, "attr.raws.unquoted is deprecated. Call attr.value instead."),
+				set: deprecate(function() {
+					return _this.value;
+				}, "Setting attr.raws.unquoted is deprecated and has no effect. attr.value is unescaped by default now.")
+			});
+			_this._constructed = true;
+			return _this;
+		}
+		/**
+		* Returns the Attribute's value quoted such that it would be legal to use
+		* in the value of a css file. The original value's quotation setting
+		* used for stringification is left unchanged. See `setValue(value, options)`
+		* if you want to control the quote settings of a new value for the attribute.
+		*
+		* You can also change the quotation used for the current value by setting quoteMark.
+		*
+		* Options:
+		*   * quoteMark {'"' | "'" | null} - Use this value to quote the value. If this
+		*     option is not set, the original value for quoteMark will be used. If
+		*     indeterminate, a double quote is used. The legal values are:
+		*     * `null` - the value will be unquoted and characters will be escaped as necessary.
+		*     * `'` - the value will be quoted with a single quote and single quotes are escaped.
+		*     * `"` - the value will be quoted with a double quote and double quotes are escaped.
+		*   * preferCurrentQuoteMark {boolean} - if true, prefer the source quote mark
+		*     over the quoteMark option value.
+		*   * smart {boolean} - if true, will select a quote mark based on the value
+		*     and the other options specified here. See the `smartQuoteMark()`
+		*     method.
+		**/
+		var _proto = Attribute$1.prototype;
+		_proto.getQuotedValue = function getQuotedValue(options) {
+			if (options === void 0) options = {};
+			var cssescopts = CSSESC_QUOTE_OPTIONS[this._determineQuoteMark(options)];
+			return (0, _cssesc["default"])(this._value, cssescopts);
+		};
+		_proto._determineQuoteMark = function _determineQuoteMark(options) {
+			return options.smart ? this.smartQuoteMark(options) : this.preferredQuoteMark(options);
+		};
+		_proto.setValue = function setValue(value, options) {
+			if (options === void 0) options = {};
+			this._value = value;
+			this._quoteMark = this._determineQuoteMark(options);
+			this._syncRawValue();
+		};
+		_proto.smartQuoteMark = function smartQuoteMark(options) {
+			var v = this.value;
+			var numSingleQuotes = v.replace(/[^']/g, "").length;
+			var numDoubleQuotes = v.replace(/[^"]/g, "").length;
+			if (numSingleQuotes + numDoubleQuotes === 0) {
+				var escaped = (0, _cssesc["default"])(v, { isIdentifier: true });
+				if (escaped === v) return Attribute$1.NO_QUOTE;
+				else {
+					var pref = this.preferredQuoteMark(options);
+					if (pref === Attribute$1.NO_QUOTE) {
+						var quote = this.quoteMark || options.quoteMark || Attribute$1.DOUBLE_QUOTE;
+						var opts = CSSESC_QUOTE_OPTIONS[quote];
+						if ((0, _cssesc["default"])(v, opts).length < escaped.length) return quote;
+					}
+					return pref;
+				}
+			} else if (numDoubleQuotes === numSingleQuotes) return this.preferredQuoteMark(options);
+			else if (numDoubleQuotes < numSingleQuotes) return Attribute$1.DOUBLE_QUOTE;
+			else return Attribute$1.SINGLE_QUOTE;
+		};
+		_proto.preferredQuoteMark = function preferredQuoteMark(options) {
+			var quoteMark = options.preferCurrentQuoteMark ? this.quoteMark : options.quoteMark;
+			if (quoteMark === void 0) quoteMark = options.preferCurrentQuoteMark ? options.quoteMark : this.quoteMark;
+			if (quoteMark === void 0) quoteMark = Attribute$1.DOUBLE_QUOTE;
+			return quoteMark;
+		};
+		_proto._syncRawValue = function _syncRawValue() {
+			var rawValue = (0, _cssesc["default"])(this._value, CSSESC_QUOTE_OPTIONS[this.quoteMark]);
+			if (rawValue === this._value) {
+				if (this.raws) delete this.raws.value;
+			} else this.raws.value = rawValue;
+		};
+		_proto._handleEscapes = function _handleEscapes(prop, value) {
+			if (this._constructed) {
+				var escaped = (0, _cssesc["default"])(value, { isIdentifier: true });
+				if (escaped !== value) this.raws[prop] = escaped;
+				else delete this.raws[prop];
+			}
+		};
+		_proto._spacesFor = function _spacesFor(name) {
+			var attrSpaces = {
+				before: "",
+				after: ""
+			};
+			var spaces = this.spaces[name] || {};
+			var rawSpaces = this.raws.spaces && this.raws.spaces[name] || {};
+			return Object.assign(attrSpaces, spaces, rawSpaces);
+		};
+		_proto._stringFor = function _stringFor(name, spaceName, concat) {
+			if (spaceName === void 0) spaceName = name;
+			if (concat === void 0) concat = defaultAttrConcat;
+			var attrSpaces = this._spacesFor(spaceName);
+			return concat(this.stringifyProperty(name), attrSpaces);
+		};
+		_proto.offsetOf = function offsetOf(name) {
+			var count = 1;
+			var attributeSpaces = this._spacesFor("attribute");
+			count += attributeSpaces.before.length;
+			if (name === "namespace" || name === "ns") return this.namespace ? count : -1;
+			if (name === "attributeNS") return count;
+			count += this.namespaceString.length;
+			if (this.namespace) count += 1;
+			if (name === "attribute") return count;
+			count += this.stringifyProperty("attribute").length;
+			count += attributeSpaces.after.length;
+			var operatorSpaces = this._spacesFor("operator");
+			count += operatorSpaces.before.length;
+			var operator = this.stringifyProperty("operator");
+			if (name === "operator") return operator ? count : -1;
+			count += operator.length;
+			count += operatorSpaces.after.length;
+			var valueSpaces = this._spacesFor("value");
+			count += valueSpaces.before.length;
+			var value = this.stringifyProperty("value");
+			if (name === "value") return value ? count : -1;
+			count += value.length;
+			count += valueSpaces.after.length;
+			var insensitiveSpaces = this._spacesFor("insensitive");
+			count += insensitiveSpaces.before.length;
+			if (name === "insensitive") return this.insensitive ? count : -1;
+			return -1;
+		};
+		_proto.toString = function toString$1() {
+			var _this2 = this;
+			var selector$1 = [this.rawSpaceBefore, "["];
+			selector$1.push(this._stringFor("qualifiedAttribute", "attribute"));
+			if (this.operator && (this.value || this.value === "")) {
+				selector$1.push(this._stringFor("operator"));
+				selector$1.push(this._stringFor("value"));
+				selector$1.push(this._stringFor("insensitiveFlag", "insensitive", function(attrValue, attrSpaces) {
+					if (attrValue.length > 0 && !_this2.quoted && attrSpaces.before.length === 0 && !(_this2.spaces.value && _this2.spaces.value.after)) attrSpaces.before = " ";
+					return defaultAttrConcat(attrValue, attrSpaces);
+				}));
+			}
+			selector$1.push("]");
+			selector$1.push(this.rawSpaceAfter);
+			return selector$1.join("");
+		};
+		_createClass$1(Attribute$1, [
+			{
+				key: "quoted",
+				get: function get() {
+					var qm = this.quoteMark;
+					return qm === "'" || qm === "\"";
+				},
+				set: function set(value) {
+					warnOfDeprecatedQuotedAssignment();
+				}
+			},
+			{
+				key: "quoteMark",
+				get: function get() {
+					return this._quoteMark;
+				},
+				set: function set(quoteMark) {
+					if (!this._constructed) {
+						this._quoteMark = quoteMark;
+						return;
+					}
+					if (this._quoteMark !== quoteMark) {
+						this._quoteMark = quoteMark;
+						this._syncRawValue();
+					}
+				}
+			},
+			{
+				key: "qualifiedAttribute",
+				get: function get() {
+					return this.qualifiedName(this.raws.attribute || this.attribute);
+				}
+			},
+			{
+				key: "insensitiveFlag",
+				get: function get() {
+					return this.insensitive ? "i" : "";
+				}
+			},
+			{
+				key: "value",
+				get: function get() {
+					return this._value;
+				},
+				set: function set(v) {
+					if (this._constructed) {
+						var _unescapeValue2 = unescapeValue(v), deprecatedUsage = _unescapeValue2.deprecatedUsage, unescaped = _unescapeValue2.unescaped, quoteMark = _unescapeValue2.quoteMark;
+						if (deprecatedUsage) warnOfDeprecatedValueAssignment();
+						if (unescaped === this._value && quoteMark === this._quoteMark) return;
+						this._value = unescaped;
+						this._quoteMark = quoteMark;
+						this._syncRawValue();
+					} else this._value = v;
+				}
+			},
+			{
+				key: "insensitive",
+				get: function get() {
+					return this._insensitive;
+				},
+				set: function set(insensitive) {
+					if (!insensitive) {
+						this._insensitive = false;
+						if (this.raws && (this.raws.insensitiveFlag === "I" || this.raws.insensitiveFlag === "i")) this.raws.insensitiveFlag = void 0;
+					}
+					this._insensitive = insensitive;
+				}
+			},
+			{
+				key: "attribute",
+				get: function get() {
+					return this._attribute;
+				},
+				set: function set(name) {
+					this._handleEscapes("attribute", name);
+					this._attribute = name;
+				}
+			}
+		]);
+		return Attribute$1;
+	}(_namespace$1["default"]);
+	exports["default"] = Attribute;
+	Attribute.NO_QUOTE = null;
+	Attribute.SINGLE_QUOTE = "'";
+	Attribute.DOUBLE_QUOTE = "\"";
+	var CSSESC_QUOTE_OPTIONS = (_CSSESC_QUOTE_OPTIONS = {
+		"'": {
+			quotes: "single",
+			wrap: true
+		},
+		"\"": {
+			quotes: "double",
+			wrap: true
+		}
+	}, _CSSESC_QUOTE_OPTIONS[null] = { isIdentifier: true }, _CSSESC_QUOTE_OPTIONS);
+	function defaultAttrConcat(attrValue, attrSpaces) {
+		return "" + attrSpaces.before + attrValue + attrSpaces.after;
+	}
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-selector-parser@7.1.0/node_modules/postcss-selector-parser/dist/selectors/universal.js
+var require_universal = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	exports.__esModule = true;
+	exports["default"] = void 0;
+	var _namespace = _interopRequireDefault$8(require_namespace());
+	var _types$4 = require_types();
+	function _interopRequireDefault$8(obj) {
+		return obj && obj.__esModule ? obj : { "default": obj };
+	}
+	function _inheritsLoose$2(subClass, superClass) {
+		subClass.prototype = Object.create(superClass.prototype);
+		subClass.prototype.constructor = subClass;
+		_setPrototypeOf$2(subClass, superClass);
+	}
+	function _setPrototypeOf$2(o, p) {
+		_setPrototypeOf$2 = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf$14(o$1, p$1) {
+			o$1.__proto__ = p$1;
+			return o$1;
+		};
+		return _setPrototypeOf$2(o, p);
+	}
+	var Universal = /* @__PURE__ */ function(_Namespace) {
+		_inheritsLoose$2(Universal$1, _Namespace);
+		function Universal$1(opts) {
+			var _this = _Namespace.call(this, opts) || this;
+			_this.type = _types$4.UNIVERSAL;
+			_this.value = "*";
+			return _this;
+		}
+		return Universal$1;
+	}(_namespace["default"]);
+	exports["default"] = Universal;
+	module.exports = exports.default;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-selector-parser@7.1.0/node_modules/postcss-selector-parser/dist/selectors/combinator.js
+var require_combinator = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	exports.__esModule = true;
+	exports["default"] = void 0;
+	var _node$1 = _interopRequireDefault$7(require_node$1());
+	var _types$3 = require_types();
+	function _interopRequireDefault$7(obj) {
+		return obj && obj.__esModule ? obj : { "default": obj };
+	}
+	function _inheritsLoose$1(subClass, superClass) {
+		subClass.prototype = Object.create(superClass.prototype);
+		subClass.prototype.constructor = subClass;
+		_setPrototypeOf$1(subClass, superClass);
+	}
+	function _setPrototypeOf$1(o, p) {
+		_setPrototypeOf$1 = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf$14(o$1, p$1) {
+			o$1.__proto__ = p$1;
+			return o$1;
+		};
+		return _setPrototypeOf$1(o, p);
+	}
+	var Combinator = /* @__PURE__ */ function(_Node) {
+		_inheritsLoose$1(Combinator$1, _Node);
+		function Combinator$1(opts) {
+			var _this = _Node.call(this, opts) || this;
+			_this.type = _types$3.COMBINATOR;
+			return _this;
+		}
+		return Combinator$1;
+	}(_node$1["default"]);
+	exports["default"] = Combinator;
+	module.exports = exports.default;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-selector-parser@7.1.0/node_modules/postcss-selector-parser/dist/selectors/nesting.js
+var require_nesting = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	exports.__esModule = true;
+	exports["default"] = void 0;
+	var _node = _interopRequireDefault$6(require_node$1());
+	var _types$2 = require_types();
+	function _interopRequireDefault$6(obj) {
+		return obj && obj.__esModule ? obj : { "default": obj };
+	}
+	function _inheritsLoose(subClass, superClass) {
+		subClass.prototype = Object.create(superClass.prototype);
+		subClass.prototype.constructor = subClass;
+		_setPrototypeOf(subClass, superClass);
+	}
+	function _setPrototypeOf(o, p) {
+		_setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf$14(o$1, p$1) {
+			o$1.__proto__ = p$1;
+			return o$1;
+		};
+		return _setPrototypeOf(o, p);
+	}
+	var Nesting = /* @__PURE__ */ function(_Node) {
+		_inheritsLoose(Nesting$1, _Node);
+		function Nesting$1(opts) {
+			var _this = _Node.call(this, opts) || this;
+			_this.type = _types$2.NESTING;
+			_this.value = "&";
+			return _this;
+		}
+		return Nesting$1;
+	}(_node["default"]);
+	exports["default"] = Nesting;
+	module.exports = exports.default;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-selector-parser@7.1.0/node_modules/postcss-selector-parser/dist/sortAscending.js
+var require_sortAscending = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	exports.__esModule = true;
+	exports["default"] = sortAscending;
+	function sortAscending(list) {
+		return list.sort(function(a, b) {
+			return a - b;
+		});
+	}
+	module.exports = exports.default;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-selector-parser@7.1.0/node_modules/postcss-selector-parser/dist/tokenTypes.js
+var require_tokenTypes = /* @__PURE__ */ __commonJSMin(((exports) => {
+	exports.__esModule = true;
+	exports.word = exports.tilde = exports.tab = exports.str = exports.space = exports.slash = exports.singleQuote = exports.semicolon = exports.plus = exports.pipe = exports.openSquare = exports.openParenthesis = exports.newline = exports.greaterThan = exports.feed = exports.equals = exports.doubleQuote = exports.dollar = exports.cr = exports.comment = exports.comma = exports.combinator = exports.colon = exports.closeSquare = exports.closeParenthesis = exports.caret = exports.bang = exports.backslash = exports.at = exports.asterisk = exports.ampersand = void 0;
+	var ampersand = 38;
+	exports.ampersand = ampersand;
+	var asterisk = 42;
+	exports.asterisk = asterisk;
+	var at = 64;
+	exports.at = at;
+	var comma = 44;
+	exports.comma = comma;
+	var colon = 58;
+	exports.colon = colon;
+	var semicolon = 59;
+	exports.semicolon = semicolon;
+	var openParenthesis = 40;
+	exports.openParenthesis = openParenthesis;
+	var closeParenthesis = 41;
+	exports.closeParenthesis = closeParenthesis;
+	var openSquare = 91;
+	exports.openSquare = openSquare;
+	var closeSquare = 93;
+	exports.closeSquare = closeSquare;
+	var dollar = 36;
+	exports.dollar = dollar;
+	var tilde = 126;
+	exports.tilde = tilde;
+	var caret = 94;
+	exports.caret = caret;
+	var plus = 43;
+	exports.plus = plus;
+	var equals = 61;
+	exports.equals = equals;
+	var pipe = 124;
+	exports.pipe = pipe;
+	var greaterThan = 62;
+	exports.greaterThan = greaterThan;
+	var space = 32;
+	exports.space = space;
+	var singleQuote = 39;
+	exports.singleQuote = singleQuote;
+	var doubleQuote = 34;
+	exports.doubleQuote = doubleQuote;
+	var slash = 47;
+	exports.slash = slash;
+	var bang = 33;
+	exports.bang = bang;
+	var backslash = 92;
+	exports.backslash = backslash;
+	var cr = 13;
+	exports.cr = cr;
+	var feed = 12;
+	exports.feed = feed;
+	var newline = 10;
+	exports.newline = newline;
+	var tab = 9;
+	exports.tab = tab;
+	var str = singleQuote;
+	exports.str = str;
+	var comment$1 = -1;
+	exports.comment = comment$1;
+	var word = -2;
+	exports.word = word;
+	var combinator$1 = -3;
+	exports.combinator = combinator$1;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-selector-parser@7.1.0/node_modules/postcss-selector-parser/dist/tokenize.js
+var require_tokenize = /* @__PURE__ */ __commonJSMin(((exports) => {
+	exports.__esModule = true;
+	exports.FIELDS = void 0;
+	exports["default"] = tokenize;
+	var t = _interopRequireWildcard$2(require_tokenTypes());
+	var _unescapable, _wordDelimiters;
+	function _getRequireWildcardCache$2(nodeInterop) {
+		if (typeof WeakMap !== "function") return null;
+		var cacheBabelInterop = /* @__PURE__ */ new WeakMap();
+		var cacheNodeInterop = /* @__PURE__ */ new WeakMap();
+		return (_getRequireWildcardCache$2 = function _getRequireWildcardCache$4(nodeInterop$1) {
+			return nodeInterop$1 ? cacheNodeInterop : cacheBabelInterop;
+		})(nodeInterop);
+	}
+	function _interopRequireWildcard$2(obj, nodeInterop) {
+		if (!nodeInterop && obj && obj.__esModule) return obj;
+		if (obj === null || typeof obj !== "object" && typeof obj !== "function") return { "default": obj };
+		var cache = _getRequireWildcardCache$2(nodeInterop);
+		if (cache && cache.has(obj)) return cache.get(obj);
+		var newObj = {};
+		var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+		for (var key in obj) if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+			var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+			if (desc && (desc.get || desc.set)) Object.defineProperty(newObj, key, desc);
+			else newObj[key] = obj[key];
+		}
+		newObj["default"] = obj;
+		if (cache) cache.set(obj, newObj);
+		return newObj;
+	}
+	var unescapable = (_unescapable = {}, _unescapable[t.tab] = true, _unescapable[t.newline] = true, _unescapable[t.cr] = true, _unescapable[t.feed] = true, _unescapable);
+	var wordDelimiters = (_wordDelimiters = {}, _wordDelimiters[t.space] = true, _wordDelimiters[t.tab] = true, _wordDelimiters[t.newline] = true, _wordDelimiters[t.cr] = true, _wordDelimiters[t.feed] = true, _wordDelimiters[t.ampersand] = true, _wordDelimiters[t.asterisk] = true, _wordDelimiters[t.bang] = true, _wordDelimiters[t.comma] = true, _wordDelimiters[t.colon] = true, _wordDelimiters[t.semicolon] = true, _wordDelimiters[t.openParenthesis] = true, _wordDelimiters[t.closeParenthesis] = true, _wordDelimiters[t.openSquare] = true, _wordDelimiters[t.closeSquare] = true, _wordDelimiters[t.singleQuote] = true, _wordDelimiters[t.doubleQuote] = true, _wordDelimiters[t.plus] = true, _wordDelimiters[t.pipe] = true, _wordDelimiters[t.tilde] = true, _wordDelimiters[t.greaterThan] = true, _wordDelimiters[t.equals] = true, _wordDelimiters[t.dollar] = true, _wordDelimiters[t.caret] = true, _wordDelimiters[t.slash] = true, _wordDelimiters);
+	var hex = {};
+	var hexChars = "0123456789abcdefABCDEF";
+	for (var i = 0; i < hexChars.length; i++) hex[hexChars.charCodeAt(i)] = true;
+	/**
+	*  Returns the last index of the bar css word
+	* @param {string} css The string in which the word begins
+	* @param {number} start The index into the string where word's first letter occurs
+	*/
+	function consumeWord(css, start) {
+		var next = start;
+		var code;
+		do {
+			code = css.charCodeAt(next);
+			if (wordDelimiters[code]) return next - 1;
+			else if (code === t.backslash) next = consumeEscape(css, next) + 1;
+			else next++;
+		} while (next < css.length);
+		return next - 1;
+	}
+	/**
+	*  Returns the last index of the escape sequence
+	* @param {string} css The string in which the sequence begins
+	* @param {number} start The index into the string where escape character (`\`) occurs.
+	*/
+	function consumeEscape(css, start) {
+		var next = start;
+		var code = css.charCodeAt(next + 1);
+		if (unescapable[code]) {} else if (hex[code]) {
+			var hexDigits = 0;
+			do {
+				next++;
+				hexDigits++;
+				code = css.charCodeAt(next + 1);
+			} while (hex[code] && hexDigits < 6);
+			if (hexDigits < 6 && code === t.space) next++;
+		} else next++;
+		return next;
+	}
+	var FIELDS = {
+		TYPE: 0,
+		START_LINE: 1,
+		START_COL: 2,
+		END_LINE: 3,
+		END_COL: 4,
+		START_POS: 5,
+		END_POS: 6
+	};
+	exports.FIELDS = FIELDS;
+	function tokenize(input) {
+		var tokens$1 = [];
+		var css = input.css.valueOf();
+		var length = css.length;
+		var offset = -1;
+		var line = 1;
+		var start = 0;
+		var end = 0;
+		var code, content, endColumn, endLine, escaped, escapePos, last, lines, next, nextLine, nextOffset, quote, tokenType;
+		function unclosed(what, fix) {
+			if (input.safe) {
+				css += fix;
+				next = css.length - 1;
+			} else throw input.error("Unclosed " + what, line, start - offset, start);
+		}
+		while (start < length) {
+			code = css.charCodeAt(start);
+			if (code === t.newline) {
+				offset = start;
+				line += 1;
+			}
+			switch (code) {
+				case t.space:
+				case t.tab:
+				case t.newline:
+				case t.cr:
+				case t.feed:
+					next = start;
+					do {
+						next += 1;
+						code = css.charCodeAt(next);
+						if (code === t.newline) {
+							offset = next;
+							line += 1;
+						}
+					} while (code === t.space || code === t.newline || code === t.tab || code === t.cr || code === t.feed);
+					tokenType = t.space;
+					endLine = line;
+					endColumn = next - offset - 1;
+					end = next;
+					break;
+				case t.plus:
+				case t.greaterThan:
+				case t.tilde:
+				case t.pipe:
+					next = start;
+					do {
+						next += 1;
+						code = css.charCodeAt(next);
+					} while (code === t.plus || code === t.greaterThan || code === t.tilde || code === t.pipe);
+					tokenType = t.combinator;
+					endLine = line;
+					endColumn = start - offset;
+					end = next;
+					break;
+				case t.asterisk:
+				case t.ampersand:
+				case t.bang:
+				case t.comma:
+				case t.equals:
+				case t.dollar:
+				case t.caret:
+				case t.openSquare:
+				case t.closeSquare:
+				case t.colon:
+				case t.semicolon:
+				case t.openParenthesis:
+				case t.closeParenthesis:
+					next = start;
+					tokenType = code;
+					endLine = line;
+					endColumn = start - offset;
+					end = next + 1;
+					break;
+				case t.singleQuote:
+				case t.doubleQuote:
+					quote = code === t.singleQuote ? "'" : "\"";
+					next = start;
+					do {
+						escaped = false;
+						next = css.indexOf(quote, next + 1);
+						if (next === -1) unclosed("quote", quote);
+						escapePos = next;
+						while (css.charCodeAt(escapePos - 1) === t.backslash) {
+							escapePos -= 1;
+							escaped = !escaped;
+						}
+					} while (escaped);
+					tokenType = t.str;
+					endLine = line;
+					endColumn = start - offset;
+					end = next + 1;
+					break;
+				default:
+					if (code === t.slash && css.charCodeAt(start + 1) === t.asterisk) {
+						next = css.indexOf("*/", start + 2) + 1;
+						if (next === 0) unclosed("comment", "*/");
+						content = css.slice(start, next + 1);
+						lines = content.split("\n");
+						last = lines.length - 1;
+						if (last > 0) {
+							nextLine = line + last;
+							nextOffset = next - lines[last].length;
+						} else {
+							nextLine = line;
+							nextOffset = offset;
+						}
+						tokenType = t.comment;
+						line = nextLine;
+						endLine = nextLine;
+						endColumn = next - nextOffset;
+					} else if (code === t.slash) {
+						next = start;
+						tokenType = code;
+						endLine = line;
+						endColumn = start - offset;
+						end = next + 1;
+					} else {
+						next = consumeWord(css, start);
+						tokenType = t.word;
+						endLine = line;
+						endColumn = next - offset;
+					}
+					end = next + 1;
+					break;
+			}
+			tokens$1.push([
+				tokenType,
+				line,
+				start - offset,
+				endLine,
+				endColumn,
+				start,
+				end
+			]);
+			if (nextOffset) {
+				offset = nextOffset;
+				nextOffset = null;
+			}
+			start = end;
+		}
+		return tokens$1;
+	}
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-selector-parser@7.1.0/node_modules/postcss-selector-parser/dist/parser.js
+var require_parser = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	exports.__esModule = true;
+	exports["default"] = void 0;
+	var _root$1 = _interopRequireDefault$5(require_root());
+	var _selector$1 = _interopRequireDefault$5(require_selector());
+	var _className$1 = _interopRequireDefault$5(require_className());
+	var _comment$1 = _interopRequireDefault$5(require_comment());
+	var _id$1 = _interopRequireDefault$5(require_id());
+	var _tag$1 = _interopRequireDefault$5(require_tag());
+	var _string$1 = _interopRequireDefault$5(require_string());
+	var _pseudo$1 = _interopRequireDefault$5(require_pseudo());
+	var _attribute$1 = _interopRequireWildcard$1(require_attribute());
+	var _universal$1 = _interopRequireDefault$5(require_universal());
+	var _combinator$1 = _interopRequireDefault$5(require_combinator());
+	var _nesting$1 = _interopRequireDefault$5(require_nesting());
+	var _sortAscending = _interopRequireDefault$5(require_sortAscending());
+	var _tokenize = _interopRequireWildcard$1(require_tokenize());
+	var tokens = _interopRequireWildcard$1(require_tokenTypes());
+	var types = _interopRequireWildcard$1(require_types());
+	var _util = require_util();
+	var _WHITESPACE_TOKENS, _Object$assign;
+	function _getRequireWildcardCache$1(nodeInterop) {
+		if (typeof WeakMap !== "function") return null;
+		var cacheBabelInterop = /* @__PURE__ */ new WeakMap();
+		var cacheNodeInterop = /* @__PURE__ */ new WeakMap();
+		return (_getRequireWildcardCache$1 = function _getRequireWildcardCache$4(nodeInterop$1) {
+			return nodeInterop$1 ? cacheNodeInterop : cacheBabelInterop;
+		})(nodeInterop);
+	}
+	function _interopRequireWildcard$1(obj, nodeInterop) {
+		if (!nodeInterop && obj && obj.__esModule) return obj;
+		if (obj === null || typeof obj !== "object" && typeof obj !== "function") return { "default": obj };
+		var cache = _getRequireWildcardCache$1(nodeInterop);
+		if (cache && cache.has(obj)) return cache.get(obj);
+		var newObj = {};
+		var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+		for (var key in obj) if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+			var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+			if (desc && (desc.get || desc.set)) Object.defineProperty(newObj, key, desc);
+			else newObj[key] = obj[key];
+		}
+		newObj["default"] = obj;
+		if (cache) cache.set(obj, newObj);
+		return newObj;
+	}
+	function _interopRequireDefault$5(obj) {
+		return obj && obj.__esModule ? obj : { "default": obj };
+	}
+	function _defineProperties(target, props) {
+		for (var i$1 = 0; i$1 < props.length; i$1++) {
+			var descriptor = props[i$1];
+			descriptor.enumerable = descriptor.enumerable || false;
+			descriptor.configurable = true;
+			if ("value" in descriptor) descriptor.writable = true;
+			Object.defineProperty(target, descriptor.key, descriptor);
+		}
+	}
+	function _createClass(Constructor, protoProps, staticProps) {
+		if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+		if (staticProps) _defineProperties(Constructor, staticProps);
+		Object.defineProperty(Constructor, "prototype", { writable: false });
+		return Constructor;
+	}
+	var WHITESPACE_TOKENS = (_WHITESPACE_TOKENS = {}, _WHITESPACE_TOKENS[tokens.space] = true, _WHITESPACE_TOKENS[tokens.cr] = true, _WHITESPACE_TOKENS[tokens.feed] = true, _WHITESPACE_TOKENS[tokens.newline] = true, _WHITESPACE_TOKENS[tokens.tab] = true, _WHITESPACE_TOKENS);
+	var WHITESPACE_EQUIV_TOKENS = Object.assign({}, WHITESPACE_TOKENS, (_Object$assign = {}, _Object$assign[tokens.comment] = true, _Object$assign));
+	function tokenStart(token) {
+		return {
+			line: token[_tokenize.FIELDS.START_LINE],
+			column: token[_tokenize.FIELDS.START_COL]
+		};
+	}
+	function tokenEnd(token) {
+		return {
+			line: token[_tokenize.FIELDS.END_LINE],
+			column: token[_tokenize.FIELDS.END_COL]
+		};
+	}
+	function getSource(startLine, startColumn, endLine, endColumn) {
+		return {
+			start: {
+				line: startLine,
+				column: startColumn
+			},
+			end: {
+				line: endLine,
+				column: endColumn
+			}
+		};
+	}
+	function getTokenSource(token) {
+		return getSource(token[_tokenize.FIELDS.START_LINE], token[_tokenize.FIELDS.START_COL], token[_tokenize.FIELDS.END_LINE], token[_tokenize.FIELDS.END_COL]);
+	}
+	function getTokenSourceSpan(startToken, endToken) {
+		if (!startToken) return;
+		return getSource(startToken[_tokenize.FIELDS.START_LINE], startToken[_tokenize.FIELDS.START_COL], endToken[_tokenize.FIELDS.END_LINE], endToken[_tokenize.FIELDS.END_COL]);
+	}
+	function unescapeProp(node, prop) {
+		var value = node[prop];
+		if (typeof value !== "string") return;
+		if (value.indexOf("\\") !== -1) {
+			(0, _util.ensureObject)(node, "raws");
+			node[prop] = (0, _util.unesc)(value);
+			if (node.raws[prop] === void 0) node.raws[prop] = value;
+		}
+		return node;
+	}
+	function indexesOf(array, item) {
+		var i$1 = -1;
+		var indexes = [];
+		while ((i$1 = array.indexOf(item, i$1 + 1)) !== -1) indexes.push(i$1);
+		return indexes;
+	}
+	function uniqs() {
+		var list = Array.prototype.concat.apply([], arguments);
+		return list.filter(function(item, i$1) {
+			return i$1 === list.indexOf(item);
+		});
+	}
+	var Parser = /* @__PURE__ */ function() {
+		function Parser$2(rule, options) {
+			if (options === void 0) options = {};
+			this.rule = rule;
+			this.options = Object.assign({
+				lossy: false,
+				safe: false
+			}, options);
+			this.position = 0;
+			this.css = typeof this.rule === "string" ? this.rule : this.rule.selector;
+			this.tokens = (0, _tokenize["default"])({
+				css: this.css,
+				error: this._errorGenerator(),
+				safe: this.options.safe
+			});
+			var rootSource = getTokenSourceSpan(this.tokens[0], this.tokens[this.tokens.length - 1]);
+			this.root = new _root$1["default"]({ source: rootSource });
+			this.root.errorGenerator = this._errorGenerator();
+			var selector$1 = new _selector$1["default"]({
+				source: { start: {
+					line: 1,
+					column: 1
+				} },
+				sourceIndex: 0
+			});
+			this.root.append(selector$1);
+			this.current = selector$1;
+			this.loop();
+		}
+		var _proto = Parser$2.prototype;
+		_proto._errorGenerator = function _errorGenerator() {
+			var _this = this;
+			return function(message, errorOptions) {
+				if (typeof _this.rule === "string") return new Error(message);
+				return _this.rule.error(message, errorOptions);
+			};
+		};
+		_proto.attribute = function attribute$1() {
+			var attr = [];
+			var startingToken = this.currToken;
+			this.position++;
+			while (this.position < this.tokens.length && this.currToken[_tokenize.FIELDS.TYPE] !== tokens.closeSquare) {
+				attr.push(this.currToken);
+				this.position++;
+			}
+			if (this.currToken[_tokenize.FIELDS.TYPE] !== tokens.closeSquare) return this.expected("closing square bracket", this.currToken[_tokenize.FIELDS.START_POS]);
+			var len = attr.length;
+			var node = {
+				source: getSource(startingToken[1], startingToken[2], this.currToken[3], this.currToken[4]),
+				sourceIndex: startingToken[_tokenize.FIELDS.START_POS]
+			};
+			if (len === 1 && !~[tokens.word].indexOf(attr[0][_tokenize.FIELDS.TYPE])) return this.expected("attribute", attr[0][_tokenize.FIELDS.START_POS]);
+			var pos = 0;
+			var spaceBefore = "";
+			var commentBefore = "";
+			var lastAdded = null;
+			var spaceAfterMeaningfulToken = false;
+			while (pos < len) {
+				var token = attr[pos];
+				var content = this.content(token);
+				var next = attr[pos + 1];
+				switch (token[_tokenize.FIELDS.TYPE]) {
+					case tokens.space:
+						spaceAfterMeaningfulToken = true;
+						if (this.options.lossy) break;
+						if (lastAdded) {
+							(0, _util.ensureObject)(node, "spaces", lastAdded);
+							var prevContent = node.spaces[lastAdded].after || "";
+							node.spaces[lastAdded].after = prevContent + content;
+							var existingComment = (0, _util.getProp)(node, "raws", "spaces", lastAdded, "after") || null;
+							if (existingComment) node.raws.spaces[lastAdded].after = existingComment + content;
+						} else {
+							spaceBefore = spaceBefore + content;
+							commentBefore = commentBefore + content;
+						}
+						break;
+					case tokens.asterisk:
+						if (next[_tokenize.FIELDS.TYPE] === tokens.equals) {
+							node.operator = content;
+							lastAdded = "operator";
+						} else if ((!node.namespace || lastAdded === "namespace" && !spaceAfterMeaningfulToken) && next) {
+							if (spaceBefore) {
+								(0, _util.ensureObject)(node, "spaces", "attribute");
+								node.spaces.attribute.before = spaceBefore;
+								spaceBefore = "";
+							}
+							if (commentBefore) {
+								(0, _util.ensureObject)(node, "raws", "spaces", "attribute");
+								node.raws.spaces.attribute.before = spaceBefore;
+								commentBefore = "";
+							}
+							node.namespace = (node.namespace || "") + content;
+							if ((0, _util.getProp)(node, "raws", "namespace") || null) node.raws.namespace += content;
+							lastAdded = "namespace";
+						}
+						spaceAfterMeaningfulToken = false;
+						break;
+					case tokens.dollar: if (lastAdded === "value") {
+						var oldRawValue = (0, _util.getProp)(node, "raws", "value");
+						node.value += "$";
+						if (oldRawValue) node.raws.value = oldRawValue + "$";
+						break;
+					}
+					case tokens.caret:
+						if (next[_tokenize.FIELDS.TYPE] === tokens.equals) {
+							node.operator = content;
+							lastAdded = "operator";
+						}
+						spaceAfterMeaningfulToken = false;
+						break;
+					case tokens.combinator:
+						if (content === "~" && next[_tokenize.FIELDS.TYPE] === tokens.equals) {
+							node.operator = content;
+							lastAdded = "operator";
+						}
+						if (content !== "|") {
+							spaceAfterMeaningfulToken = false;
+							break;
+						}
+						if (next[_tokenize.FIELDS.TYPE] === tokens.equals) {
+							node.operator = content;
+							lastAdded = "operator";
+						} else if (!node.namespace && !node.attribute) node.namespace = true;
+						spaceAfterMeaningfulToken = false;
+						break;
+					case tokens.word:
+						if (next && this.content(next) === "|" && attr[pos + 2] && attr[pos + 2][_tokenize.FIELDS.TYPE] !== tokens.equals && !node.operator && !node.namespace) {
+							node.namespace = content;
+							lastAdded = "namespace";
+						} else if (!node.attribute || lastAdded === "attribute" && !spaceAfterMeaningfulToken) {
+							if (spaceBefore) {
+								(0, _util.ensureObject)(node, "spaces", "attribute");
+								node.spaces.attribute.before = spaceBefore;
+								spaceBefore = "";
+							}
+							if (commentBefore) {
+								(0, _util.ensureObject)(node, "raws", "spaces", "attribute");
+								node.raws.spaces.attribute.before = commentBefore;
+								commentBefore = "";
+							}
+							node.attribute = (node.attribute || "") + content;
+							if ((0, _util.getProp)(node, "raws", "attribute") || null) node.raws.attribute += content;
+							lastAdded = "attribute";
+						} else if (!node.value && node.value !== "" || lastAdded === "value" && !(spaceAfterMeaningfulToken || node.quoteMark)) {
+							var _unescaped = (0, _util.unesc)(content);
+							var _oldRawValue = (0, _util.getProp)(node, "raws", "value") || "";
+							var oldValue = node.value || "";
+							node.value = oldValue + _unescaped;
+							node.quoteMark = null;
+							if (_unescaped !== content || _oldRawValue) {
+								(0, _util.ensureObject)(node, "raws");
+								node.raws.value = (_oldRawValue || oldValue) + content;
+							}
+							lastAdded = "value";
+						} else {
+							var insensitive = content === "i" || content === "I";
+							if ((node.value || node.value === "") && (node.quoteMark || spaceAfterMeaningfulToken)) {
+								node.insensitive = insensitive;
+								if (!insensitive || content === "I") {
+									(0, _util.ensureObject)(node, "raws");
+									node.raws.insensitiveFlag = content;
+								}
+								lastAdded = "insensitive";
+								if (spaceBefore) {
+									(0, _util.ensureObject)(node, "spaces", "insensitive");
+									node.spaces.insensitive.before = spaceBefore;
+									spaceBefore = "";
+								}
+								if (commentBefore) {
+									(0, _util.ensureObject)(node, "raws", "spaces", "insensitive");
+									node.raws.spaces.insensitive.before = commentBefore;
+									commentBefore = "";
+								}
+							} else if (node.value || node.value === "") {
+								lastAdded = "value";
+								node.value += content;
+								if (node.raws.value) node.raws.value += content;
+							}
+						}
+						spaceAfterMeaningfulToken = false;
+						break;
+					case tokens.str:
+						if (!node.attribute || !node.operator) return this.error("Expected an attribute followed by an operator preceding the string.", { index: token[_tokenize.FIELDS.START_POS] });
+						var _unescapeValue = (0, _attribute$1.unescapeValue)(content), unescaped = _unescapeValue.unescaped, quoteMark = _unescapeValue.quoteMark;
+						node.value = unescaped;
+						node.quoteMark = quoteMark;
+						lastAdded = "value";
+						(0, _util.ensureObject)(node, "raws");
+						node.raws.value = content;
+						spaceAfterMeaningfulToken = false;
+						break;
+					case tokens.equals:
+						if (!node.attribute) return this.expected("attribute", token[_tokenize.FIELDS.START_POS], content);
+						if (node.value) return this.error("Unexpected \"=\" found; an operator was already defined.", { index: token[_tokenize.FIELDS.START_POS] });
+						node.operator = node.operator ? node.operator + content : content;
+						lastAdded = "operator";
+						spaceAfterMeaningfulToken = false;
+						break;
+					case tokens.comment:
+						if (lastAdded) if (spaceAfterMeaningfulToken || next && next[_tokenize.FIELDS.TYPE] === tokens.space || lastAdded === "insensitive") {
+							var lastComment = (0, _util.getProp)(node, "spaces", lastAdded, "after") || "";
+							var rawLastComment = (0, _util.getProp)(node, "raws", "spaces", lastAdded, "after") || lastComment;
+							(0, _util.ensureObject)(node, "raws", "spaces", lastAdded);
+							node.raws.spaces[lastAdded].after = rawLastComment + content;
+						} else {
+							var lastValue = node[lastAdded] || "";
+							var rawLastValue = (0, _util.getProp)(node, "raws", lastAdded) || lastValue;
+							(0, _util.ensureObject)(node, "raws");
+							node.raws[lastAdded] = rawLastValue + content;
+						}
+						else commentBefore = commentBefore + content;
+						break;
+					default: return this.error("Unexpected \"" + content + "\" found.", { index: token[_tokenize.FIELDS.START_POS] });
+				}
+				pos++;
+			}
+			unescapeProp(node, "attribute");
+			unescapeProp(node, "namespace");
+			this.newNode(new _attribute$1["default"](node));
+			this.position++;
+		};
+		_proto.parseWhitespaceEquivalentTokens = function parseWhitespaceEquivalentTokens(stopPosition) {
+			if (stopPosition < 0) stopPosition = this.tokens.length;
+			var startPosition = this.position;
+			var nodes = [];
+			var space$1 = "";
+			var lastComment = void 0;
+			do
+				if (WHITESPACE_TOKENS[this.currToken[_tokenize.FIELDS.TYPE]]) {
+					if (!this.options.lossy) space$1 += this.content();
+				} else if (this.currToken[_tokenize.FIELDS.TYPE] === tokens.comment) {
+					var spaces = {};
+					if (space$1) {
+						spaces.before = space$1;
+						space$1 = "";
+					}
+					lastComment = new _comment$1["default"]({
+						value: this.content(),
+						source: getTokenSource(this.currToken),
+						sourceIndex: this.currToken[_tokenize.FIELDS.START_POS],
+						spaces
+					});
+					nodes.push(lastComment);
+				}
+			while (++this.position < stopPosition);
+			if (space$1) {
+				if (lastComment) lastComment.spaces.after = space$1;
+				else if (!this.options.lossy) {
+					var firstToken = this.tokens[startPosition];
+					var lastToken = this.tokens[this.position - 1];
+					nodes.push(new _string$1["default"]({
+						value: "",
+						source: getSource(firstToken[_tokenize.FIELDS.START_LINE], firstToken[_tokenize.FIELDS.START_COL], lastToken[_tokenize.FIELDS.END_LINE], lastToken[_tokenize.FIELDS.END_COL]),
+						sourceIndex: firstToken[_tokenize.FIELDS.START_POS],
+						spaces: {
+							before: space$1,
+							after: ""
+						}
+					}));
+				}
+			}
+			return nodes;
+		};
+		_proto.convertWhitespaceNodesToSpace = function convertWhitespaceNodesToSpace(nodes, requiredSpace) {
+			var _this2 = this;
+			if (requiredSpace === void 0) requiredSpace = false;
+			var space$1 = "";
+			var rawSpace = "";
+			nodes.forEach(function(n) {
+				var spaceBefore = _this2.lossySpace(n.spaces.before, requiredSpace);
+				var rawSpaceBefore = _this2.lossySpace(n.rawSpaceBefore, requiredSpace);
+				space$1 += spaceBefore + _this2.lossySpace(n.spaces.after, requiredSpace && spaceBefore.length === 0);
+				rawSpace += spaceBefore + n.value + _this2.lossySpace(n.rawSpaceAfter, requiredSpace && rawSpaceBefore.length === 0);
+			});
+			if (rawSpace === space$1) rawSpace = void 0;
+			return {
+				space: space$1,
+				rawSpace
+			};
+		};
+		_proto.isNamedCombinator = function isNamedCombinator(position) {
+			if (position === void 0) position = this.position;
+			return this.tokens[position + 0] && this.tokens[position + 0][_tokenize.FIELDS.TYPE] === tokens.slash && this.tokens[position + 1] && this.tokens[position + 1][_tokenize.FIELDS.TYPE] === tokens.word && this.tokens[position + 2] && this.tokens[position + 2][_tokenize.FIELDS.TYPE] === tokens.slash;
+		};
+		_proto.namedCombinator = function namedCombinator() {
+			if (this.isNamedCombinator()) {
+				var nameRaw = this.content(this.tokens[this.position + 1]);
+				var name = (0, _util.unesc)(nameRaw).toLowerCase();
+				var raws = {};
+				if (name !== nameRaw) raws.value = "/" + nameRaw + "/";
+				var node = new _combinator$1["default"]({
+					value: "/" + name + "/",
+					source: getSource(this.currToken[_tokenize.FIELDS.START_LINE], this.currToken[_tokenize.FIELDS.START_COL], this.tokens[this.position + 2][_tokenize.FIELDS.END_LINE], this.tokens[this.position + 2][_tokenize.FIELDS.END_COL]),
+					sourceIndex: this.currToken[_tokenize.FIELDS.START_POS],
+					raws
+				});
+				this.position = this.position + 3;
+				return node;
+			} else this.unexpected();
+		};
+		_proto.combinator = function combinator$2() {
+			var _this3 = this;
+			if (this.content() === "|") return this.namespace();
+			var nextSigTokenPos = this.locateNextMeaningfulToken(this.position);
+			if (nextSigTokenPos < 0 || this.tokens[nextSigTokenPos][_tokenize.FIELDS.TYPE] === tokens.comma || this.tokens[nextSigTokenPos][_tokenize.FIELDS.TYPE] === tokens.closeParenthesis) {
+				var nodes = this.parseWhitespaceEquivalentTokens(nextSigTokenPos);
+				if (nodes.length > 0) {
+					var last = this.current.last;
+					if (last) {
+						var _this$convertWhitespa = this.convertWhitespaceNodesToSpace(nodes), space$1 = _this$convertWhitespa.space, rawSpace = _this$convertWhitespa.rawSpace;
+						if (rawSpace !== void 0) last.rawSpaceAfter += rawSpace;
+						last.spaces.after += space$1;
+					} else nodes.forEach(function(n) {
+						return _this3.newNode(n);
+					});
+				}
+				return;
+			}
+			var firstToken = this.currToken;
+			var spaceOrDescendantSelectorNodes = void 0;
+			if (nextSigTokenPos > this.position) spaceOrDescendantSelectorNodes = this.parseWhitespaceEquivalentTokens(nextSigTokenPos);
+			var node;
+			if (this.isNamedCombinator()) node = this.namedCombinator();
+			else if (this.currToken[_tokenize.FIELDS.TYPE] === tokens.combinator) {
+				node = new _combinator$1["default"]({
+					value: this.content(),
+					source: getTokenSource(this.currToken),
+					sourceIndex: this.currToken[_tokenize.FIELDS.START_POS]
+				});
+				this.position++;
+			} else if (WHITESPACE_TOKENS[this.currToken[_tokenize.FIELDS.TYPE]]) {} else if (!spaceOrDescendantSelectorNodes) this.unexpected();
+			if (node) {
+				if (spaceOrDescendantSelectorNodes) {
+					var _this$convertWhitespa2 = this.convertWhitespaceNodesToSpace(spaceOrDescendantSelectorNodes), _space = _this$convertWhitespa2.space, _rawSpace = _this$convertWhitespa2.rawSpace;
+					node.spaces.before = _space;
+					node.rawSpaceBefore = _rawSpace;
+				}
+			} else {
+				var _this$convertWhitespa3 = this.convertWhitespaceNodesToSpace(spaceOrDescendantSelectorNodes, true), _space2 = _this$convertWhitespa3.space, _rawSpace2 = _this$convertWhitespa3.rawSpace;
+				if (!_rawSpace2) _rawSpace2 = _space2;
+				var spaces = {};
+				var raws = { spaces: {} };
+				if (_space2.endsWith(" ") && _rawSpace2.endsWith(" ")) {
+					spaces.before = _space2.slice(0, _space2.length - 1);
+					raws.spaces.before = _rawSpace2.slice(0, _rawSpace2.length - 1);
+				} else if (_space2.startsWith(" ") && _rawSpace2.startsWith(" ")) {
+					spaces.after = _space2.slice(1);
+					raws.spaces.after = _rawSpace2.slice(1);
+				} else raws.value = _rawSpace2;
+				node = new _combinator$1["default"]({
+					value: " ",
+					source: getTokenSourceSpan(firstToken, this.tokens[this.position - 1]),
+					sourceIndex: firstToken[_tokenize.FIELDS.START_POS],
+					spaces,
+					raws
+				});
+			}
+			if (this.currToken && this.currToken[_tokenize.FIELDS.TYPE] === tokens.space) {
+				node.spaces.after = this.optionalSpace(this.content());
+				this.position++;
+			}
+			return this.newNode(node);
+		};
+		_proto.comma = function comma$1() {
+			if (this.position === this.tokens.length - 1) {
+				this.root.trailingComma = true;
+				this.position++;
+				return;
+			}
+			this.current._inferEndPosition();
+			var selector$1 = new _selector$1["default"]({
+				source: { start: tokenStart(this.tokens[this.position + 1]) },
+				sourceIndex: this.tokens[this.position + 1][_tokenize.FIELDS.START_POS]
+			});
+			this.current.parent.append(selector$1);
+			this.current = selector$1;
+			this.position++;
+		};
+		_proto.comment = function comment$2() {
+			var current = this.currToken;
+			this.newNode(new _comment$1["default"]({
+				value: this.content(),
+				source: getTokenSource(current),
+				sourceIndex: current[_tokenize.FIELDS.START_POS]
+			}));
+			this.position++;
+		};
+		_proto.error = function error(message, opts) {
+			throw this.root.error(message, opts);
+		};
+		_proto.missingBackslash = function missingBackslash() {
+			return this.error("Expected a backslash preceding the semicolon.", { index: this.currToken[_tokenize.FIELDS.START_POS] });
+		};
+		_proto.missingParenthesis = function missingParenthesis() {
+			return this.expected("opening parenthesis", this.currToken[_tokenize.FIELDS.START_POS]);
+		};
+		_proto.missingSquareBracket = function missingSquareBracket() {
+			return this.expected("opening square bracket", this.currToken[_tokenize.FIELDS.START_POS]);
+		};
+		_proto.unexpected = function unexpected() {
+			return this.error("Unexpected '" + this.content() + "'. Escaping special characters with \\ may help.", this.currToken[_tokenize.FIELDS.START_POS]);
+		};
+		_proto.unexpectedPipe = function unexpectedPipe() {
+			return this.error("Unexpected '|'.", this.currToken[_tokenize.FIELDS.START_POS]);
+		};
+		_proto.namespace = function namespace() {
+			var before = this.prevToken && this.content(this.prevToken) || true;
+			if (this.nextToken[_tokenize.FIELDS.TYPE] === tokens.word) {
+				this.position++;
+				return this.word(before);
+			} else if (this.nextToken[_tokenize.FIELDS.TYPE] === tokens.asterisk) {
+				this.position++;
+				return this.universal(before);
+			}
+			this.unexpectedPipe();
+		};
+		_proto.nesting = function nesting$1() {
+			if (this.nextToken) {
+				if (this.content(this.nextToken) === "|") {
+					this.position++;
+					return;
+				}
+			}
+			var current = this.currToken;
+			this.newNode(new _nesting$1["default"]({
+				value: this.content(),
+				source: getTokenSource(current),
+				sourceIndex: current[_tokenize.FIELDS.START_POS]
+			}));
+			this.position++;
+		};
+		_proto.parentheses = function parentheses() {
+			var last = this.current.last;
+			var unbalanced = 1;
+			this.position++;
+			if (last && last.type === types.PSEUDO) {
+				var selector$1 = new _selector$1["default"]({
+					source: { start: tokenStart(this.tokens[this.position]) },
+					sourceIndex: this.tokens[this.position][_tokenize.FIELDS.START_POS]
+				});
+				var cache = this.current;
+				last.append(selector$1);
+				this.current = selector$1;
+				while (this.position < this.tokens.length && unbalanced) {
+					if (this.currToken[_tokenize.FIELDS.TYPE] === tokens.openParenthesis) unbalanced++;
+					if (this.currToken[_tokenize.FIELDS.TYPE] === tokens.closeParenthesis) unbalanced--;
+					if (unbalanced) this.parse();
+					else {
+						this.current.source.end = tokenEnd(this.currToken);
+						this.current.parent.source.end = tokenEnd(this.currToken);
+						this.position++;
+					}
+				}
+				this.current = cache;
+			} else {
+				var parenStart = this.currToken;
+				var parenValue = "(";
+				var parenEnd;
+				while (this.position < this.tokens.length && unbalanced) {
+					if (this.currToken[_tokenize.FIELDS.TYPE] === tokens.openParenthesis) unbalanced++;
+					if (this.currToken[_tokenize.FIELDS.TYPE] === tokens.closeParenthesis) unbalanced--;
+					parenEnd = this.currToken;
+					parenValue += this.parseParenthesisToken(this.currToken);
+					this.position++;
+				}
+				if (last) last.appendToPropertyAndEscape("value", parenValue, parenValue);
+				else this.newNode(new _string$1["default"]({
+					value: parenValue,
+					source: getSource(parenStart[_tokenize.FIELDS.START_LINE], parenStart[_tokenize.FIELDS.START_COL], parenEnd[_tokenize.FIELDS.END_LINE], parenEnd[_tokenize.FIELDS.END_COL]),
+					sourceIndex: parenStart[_tokenize.FIELDS.START_POS]
+				}));
+			}
+			if (unbalanced) return this.expected("closing parenthesis", this.currToken[_tokenize.FIELDS.START_POS]);
+		};
+		_proto.pseudo = function pseudo$1() {
+			var _this4 = this;
+			var pseudoStr = "";
+			var startingToken = this.currToken;
+			while (this.currToken && this.currToken[_tokenize.FIELDS.TYPE] === tokens.colon) {
+				pseudoStr += this.content();
+				this.position++;
+			}
+			if (!this.currToken) return this.expected(["pseudo-class", "pseudo-element"], this.position - 1);
+			if (this.currToken[_tokenize.FIELDS.TYPE] === tokens.word) this.splitWord(false, function(first, length) {
+				pseudoStr += first;
+				_this4.newNode(new _pseudo$1["default"]({
+					value: pseudoStr,
+					source: getTokenSourceSpan(startingToken, _this4.currToken),
+					sourceIndex: startingToken[_tokenize.FIELDS.START_POS]
+				}));
+				if (length > 1 && _this4.nextToken && _this4.nextToken[_tokenize.FIELDS.TYPE] === tokens.openParenthesis) _this4.error("Misplaced parenthesis.", { index: _this4.nextToken[_tokenize.FIELDS.START_POS] });
+			});
+			else return this.expected(["pseudo-class", "pseudo-element"], this.currToken[_tokenize.FIELDS.START_POS]);
+		};
+		_proto.space = function space$1() {
+			var content = this.content();
+			if (this.position === 0 || this.prevToken[_tokenize.FIELDS.TYPE] === tokens.comma || this.prevToken[_tokenize.FIELDS.TYPE] === tokens.openParenthesis || this.current.nodes.every(function(node) {
+				return node.type === "comment";
+			})) {
+				this.spaces = this.optionalSpace(content);
+				this.position++;
+			} else if (this.position === this.tokens.length - 1 || this.nextToken[_tokenize.FIELDS.TYPE] === tokens.comma || this.nextToken[_tokenize.FIELDS.TYPE] === tokens.closeParenthesis) {
+				this.current.last.spaces.after = this.optionalSpace(content);
+				this.position++;
+			} else this.combinator();
+		};
+		_proto.string = function string$1() {
+			var current = this.currToken;
+			this.newNode(new _string$1["default"]({
+				value: this.content(),
+				source: getTokenSource(current),
+				sourceIndex: current[_tokenize.FIELDS.START_POS]
+			}));
+			this.position++;
+		};
+		_proto.universal = function universal$1(namespace) {
+			var nextToken = this.nextToken;
+			if (nextToken && this.content(nextToken) === "|") {
+				this.position++;
+				return this.namespace();
+			}
+			var current = this.currToken;
+			this.newNode(new _universal$1["default"]({
+				value: this.content(),
+				source: getTokenSource(current),
+				sourceIndex: current[_tokenize.FIELDS.START_POS]
+			}), namespace);
+			this.position++;
+		};
+		_proto.splitWord = function splitWord(namespace, firstCallback) {
+			var _this5 = this;
+			var nextToken = this.nextToken;
+			var word$1 = this.content();
+			while (nextToken && ~[
+				tokens.dollar,
+				tokens.caret,
+				tokens.equals,
+				tokens.word
+			].indexOf(nextToken[_tokenize.FIELDS.TYPE])) {
+				this.position++;
+				var current = this.content();
+				word$1 += current;
+				if (current.lastIndexOf("\\") === current.length - 1) {
+					var next = this.nextToken;
+					if (next && next[_tokenize.FIELDS.TYPE] === tokens.space) {
+						word$1 += this.requiredSpace(this.content(next));
+						this.position++;
+					}
+				}
+				nextToken = this.nextToken;
+			}
+			var hasClass = indexesOf(word$1, ".").filter(function(i$1) {
+				var escapedDot = word$1[i$1 - 1] === "\\";
+				var isKeyframesPercent = /^\d+\.\d+%$/.test(word$1);
+				return !escapedDot && !isKeyframesPercent;
+			});
+			var hasId = indexesOf(word$1, "#").filter(function(i$1) {
+				return word$1[i$1 - 1] !== "\\";
+			});
+			var interpolations = indexesOf(word$1, "#{");
+			if (interpolations.length) hasId = hasId.filter(function(hashIndex) {
+				return !~interpolations.indexOf(hashIndex);
+			});
+			var indices = (0, _sortAscending["default"])(uniqs([0].concat(hasClass, hasId)));
+			indices.forEach(function(ind, i$1) {
+				var index = indices[i$1 + 1] || word$1.length;
+				var value = word$1.slice(ind, index);
+				if (i$1 === 0 && firstCallback) return firstCallback.call(_this5, value, indices.length);
+				var node;
+				var current$1 = _this5.currToken;
+				var sourceIndex = current$1[_tokenize.FIELDS.START_POS] + indices[i$1];
+				var source = getSource(current$1[1], current$1[2] + ind, current$1[3], current$1[2] + (index - 1));
+				if (~hasClass.indexOf(ind)) {
+					var classNameOpts = {
+						value: value.slice(1),
+						source,
+						sourceIndex
+					};
+					node = new _className$1["default"](unescapeProp(classNameOpts, "value"));
+				} else if (~hasId.indexOf(ind)) {
+					var idOpts = {
+						value: value.slice(1),
+						source,
+						sourceIndex
+					};
+					node = new _id$1["default"](unescapeProp(idOpts, "value"));
+				} else {
+					var tagOpts = {
+						value,
+						source,
+						sourceIndex
+					};
+					unescapeProp(tagOpts, "value");
+					node = new _tag$1["default"](tagOpts);
+				}
+				_this5.newNode(node, namespace);
+				namespace = null;
+			});
+			this.position++;
+		};
+		_proto.word = function word$1(namespace) {
+			var nextToken = this.nextToken;
+			if (nextToken && this.content(nextToken) === "|") {
+				this.position++;
+				return this.namespace();
+			}
+			return this.splitWord(namespace);
+		};
+		_proto.loop = function loop() {
+			while (this.position < this.tokens.length) this.parse(true);
+			this.current._inferEndPosition();
+			return this.root;
+		};
+		_proto.parse = function parse(throwOnParenthesis) {
+			switch (this.currToken[_tokenize.FIELDS.TYPE]) {
+				case tokens.space:
+					this.space();
+					break;
+				case tokens.comment:
+					this.comment();
+					break;
+				case tokens.openParenthesis:
+					this.parentheses();
+					break;
+				case tokens.closeParenthesis:
+					if (throwOnParenthesis) this.missingParenthesis();
+					break;
+				case tokens.openSquare:
+					this.attribute();
+					break;
+				case tokens.dollar:
+				case tokens.caret:
+				case tokens.equals:
+				case tokens.word:
+					this.word();
+					break;
+				case tokens.colon:
+					this.pseudo();
+					break;
+				case tokens.comma:
+					this.comma();
+					break;
+				case tokens.asterisk:
+					this.universal();
+					break;
+				case tokens.ampersand:
+					this.nesting();
+					break;
+				case tokens.slash:
+				case tokens.combinator:
+					this.combinator();
+					break;
+				case tokens.str:
+					this.string();
+					break;
+				case tokens.closeSquare: this.missingSquareBracket();
+				case tokens.semicolon: this.missingBackslash();
+				default: this.unexpected();
+			}
+		};
+		_proto.expected = function expected(description, index, found) {
+			if (Array.isArray(description)) {
+				var last = description.pop();
+				description = description.join(", ") + " or " + last;
+			}
+			var an = /^[aeiou]/.test(description[0]) ? "an" : "a";
+			if (!found) return this.error("Expected " + an + " " + description + ".", { index });
+			return this.error("Expected " + an + " " + description + ", found \"" + found + "\" instead.", { index });
+		};
+		_proto.requiredSpace = function requiredSpace(space$1) {
+			return this.options.lossy ? " " : space$1;
+		};
+		_proto.optionalSpace = function optionalSpace(space$1) {
+			return this.options.lossy ? "" : space$1;
+		};
+		_proto.lossySpace = function lossySpace(space$1, required) {
+			if (this.options.lossy) return required ? " " : "";
+			else return space$1;
+		};
+		_proto.parseParenthesisToken = function parseParenthesisToken(token) {
+			var content = this.content(token);
+			if (token[_tokenize.FIELDS.TYPE] === tokens.space) return this.requiredSpace(content);
+			else return content;
+		};
+		_proto.newNode = function newNode(node, namespace) {
+			if (namespace) {
+				if (/^ +$/.test(namespace)) {
+					if (!this.options.lossy) this.spaces = (this.spaces || "") + namespace;
+					namespace = true;
+				}
+				node.namespace = namespace;
+				unescapeProp(node, "namespace");
+			}
+			if (this.spaces) {
+				node.spaces.before = this.spaces;
+				this.spaces = "";
+			}
+			return this.current.append(node);
+		};
+		_proto.content = function content(token) {
+			if (token === void 0) token = this.currToken;
+			return this.css.slice(token[_tokenize.FIELDS.START_POS], token[_tokenize.FIELDS.END_POS]);
+		};
+		/**
+		* returns the index of the next non-whitespace, non-comment token.
+		* returns -1 if no meaningful token is found.
+		*/
+		_proto.locateNextMeaningfulToken = function locateNextMeaningfulToken(startPosition) {
+			if (startPosition === void 0) startPosition = this.position + 1;
+			var searchPosition = startPosition;
+			while (searchPosition < this.tokens.length) if (WHITESPACE_EQUIV_TOKENS[this.tokens[searchPosition][_tokenize.FIELDS.TYPE]]) {
+				searchPosition++;
+				continue;
+			} else return searchPosition;
+			return -1;
+		};
+		_createClass(Parser$2, [
+			{
+				key: "currToken",
+				get: function get() {
+					return this.tokens[this.position];
+				}
+			},
+			{
+				key: "nextToken",
+				get: function get() {
+					return this.tokens[this.position + 1];
+				}
+			},
+			{
+				key: "prevToken",
+				get: function get() {
+					return this.tokens[this.position - 1];
+				}
+			}
+		]);
+		return Parser$2;
+	}();
+	exports["default"] = Parser;
+	module.exports = exports.default;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-selector-parser@7.1.0/node_modules/postcss-selector-parser/dist/processor.js
+var require_processor = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	exports.__esModule = true;
+	exports["default"] = void 0;
+	var _parser = _interopRequireDefault$4(require_parser());
+	function _interopRequireDefault$4(obj) {
+		return obj && obj.__esModule ? obj : { "default": obj };
+	}
+	var Processor = /* @__PURE__ */ function() {
+		function Processor$1(func, options) {
+			this.func = func || function noop() {};
+			this.funcRes = null;
+			this.options = options;
+		}
+		var _proto = Processor$1.prototype;
+		_proto._shouldUpdateSelector = function _shouldUpdateSelector(rule, options) {
+			if (options === void 0) options = {};
+			if (Object.assign({}, this.options, options).updateSelector === false) return false;
+			else return typeof rule !== "string";
+		};
+		_proto._isLossy = function _isLossy(options) {
+			if (options === void 0) options = {};
+			if (Object.assign({}, this.options, options).lossless === false) return true;
+			else return false;
+		};
+		_proto._root = function _root$2(rule, options) {
+			if (options === void 0) options = {};
+			return new _parser["default"](rule, this._parseOptions(options)).root;
+		};
+		_proto._parseOptions = function _parseOptions(options) {
+			return { lossy: this._isLossy(options) };
+		};
+		_proto._run = function _run(rule, options) {
+			var _this = this;
+			if (options === void 0) options = {};
+			return new Promise(function(resolve, reject) {
+				try {
+					var root$2 = _this._root(rule, options);
+					Promise.resolve(_this.func(root$2)).then(function(transform) {
+						var string$1 = void 0;
+						if (_this._shouldUpdateSelector(rule, options)) {
+							string$1 = root$2.toString();
+							rule.selector = string$1;
+						}
+						return {
+							transform,
+							root: root$2,
+							string: string$1
+						};
+					}).then(resolve, reject);
+				} catch (e) {
+					reject(e);
+					return;
+				}
+			});
+		};
+		_proto._runSync = function _runSync(rule, options) {
+			if (options === void 0) options = {};
+			var root$2 = this._root(rule, options);
+			var transform = this.func(root$2);
+			if (transform && typeof transform.then === "function") throw new Error("Selector processor returned a promise to a synchronous call.");
+			var string$1 = void 0;
+			if (options.updateSelector && typeof rule !== "string") {
+				string$1 = root$2.toString();
+				rule.selector = string$1;
+			}
+			return {
+				transform,
+				root: root$2,
+				string: string$1
+			};
+		};
+		_proto.ast = function ast(rule, options) {
+			return this._run(rule, options).then(function(result) {
+				return result.root;
+			});
+		};
+		_proto.astSync = function astSync(rule, options) {
+			return this._runSync(rule, options).root;
+		};
+		_proto.transform = function transform(rule, options) {
+			return this._run(rule, options).then(function(result) {
+				return result.transform;
+			});
+		};
+		_proto.transformSync = function transformSync(rule, options) {
+			return this._runSync(rule, options).transform;
+		};
+		_proto.process = function process$1(rule, options) {
+			return this._run(rule, options).then(function(result) {
+				return result.string || result.root.toString();
+			});
+		};
+		_proto.processSync = function processSync(rule, options) {
+			var result = this._runSync(rule, options);
+			return result.string || result.root.toString();
+		};
+		return Processor$1;
+	}();
+	exports["default"] = Processor;
+	module.exports = exports.default;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-selector-parser@7.1.0/node_modules/postcss-selector-parser/dist/selectors/constructors.js
+var require_constructors = /* @__PURE__ */ __commonJSMin(((exports) => {
+	exports.__esModule = true;
+	exports.universal = exports.tag = exports.string = exports.selector = exports.root = exports.pseudo = exports.nesting = exports.id = exports.comment = exports.combinator = exports.className = exports.attribute = void 0;
+	var _attribute = _interopRequireDefault$3(require_attribute());
+	var _className = _interopRequireDefault$3(require_className());
+	var _combinator = _interopRequireDefault$3(require_combinator());
+	var _comment = _interopRequireDefault$3(require_comment());
+	var _id = _interopRequireDefault$3(require_id());
+	var _nesting = _interopRequireDefault$3(require_nesting());
+	var _pseudo = _interopRequireDefault$3(require_pseudo());
+	var _root = _interopRequireDefault$3(require_root());
+	var _selector = _interopRequireDefault$3(require_selector());
+	var _string = _interopRequireDefault$3(require_string());
+	var _tag = _interopRequireDefault$3(require_tag());
+	var _universal = _interopRequireDefault$3(require_universal());
+	function _interopRequireDefault$3(obj) {
+		return obj && obj.__esModule ? obj : { "default": obj };
+	}
+	var attribute = function attribute$1(opts) {
+		return new _attribute["default"](opts);
+	};
+	exports.attribute = attribute;
+	var className = function className$1(opts) {
+		return new _className["default"](opts);
+	};
+	exports.className = className;
+	var combinator = function combinator$2(opts) {
+		return new _combinator["default"](opts);
+	};
+	exports.combinator = combinator;
+	var comment = function comment$2(opts) {
+		return new _comment["default"](opts);
+	};
+	exports.comment = comment;
+	var id = function id$1(opts) {
+		return new _id["default"](opts);
+	};
+	exports.id = id;
+	var nesting = function nesting$1(opts) {
+		return new _nesting["default"](opts);
+	};
+	exports.nesting = nesting;
+	var pseudo = function pseudo$1(opts) {
+		return new _pseudo["default"](opts);
+	};
+	exports.pseudo = pseudo;
+	var root = function root$2(opts) {
+		return new _root["default"](opts);
+	};
+	exports.root = root;
+	var selector = function selector$1(opts) {
+		return new _selector["default"](opts);
+	};
+	exports.selector = selector;
+	var string = function string$1(opts) {
+		return new _string["default"](opts);
+	};
+	exports.string = string;
+	var tag = function tag$1(opts) {
+		return new _tag["default"](opts);
+	};
+	exports.tag = tag;
+	var universal = function universal$1(opts) {
+		return new _universal["default"](opts);
+	};
+	exports.universal = universal;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-selector-parser@7.1.0/node_modules/postcss-selector-parser/dist/selectors/guards.js
+var require_guards = /* @__PURE__ */ __commonJSMin(((exports) => {
+	exports.__esModule = true;
+	exports.isComment = exports.isCombinator = exports.isClassName = exports.isAttribute = void 0;
+	exports.isContainer = isContainer;
+	exports.isIdentifier = void 0;
+	exports.isNamespace = isNamespace;
+	exports.isNesting = void 0;
+	exports.isNode = isNode;
+	exports.isPseudo = void 0;
+	exports.isPseudoClass = isPseudoClass;
+	exports.isPseudoElement = isPseudoElement;
+	exports.isUniversal = exports.isTag = exports.isString = exports.isSelector = exports.isRoot = void 0;
+	var _types$1 = require_types();
+	var _IS_TYPE;
+	var IS_TYPE = (_IS_TYPE = {}, _IS_TYPE[_types$1.ATTRIBUTE] = true, _IS_TYPE[_types$1.CLASS] = true, _IS_TYPE[_types$1.COMBINATOR] = true, _IS_TYPE[_types$1.COMMENT] = true, _IS_TYPE[_types$1.ID] = true, _IS_TYPE[_types$1.NESTING] = true, _IS_TYPE[_types$1.PSEUDO] = true, _IS_TYPE[_types$1.ROOT] = true, _IS_TYPE[_types$1.SELECTOR] = true, _IS_TYPE[_types$1.STRING] = true, _IS_TYPE[_types$1.TAG] = true, _IS_TYPE[_types$1.UNIVERSAL] = true, _IS_TYPE);
+	function isNode(node) {
+		return typeof node === "object" && IS_TYPE[node.type];
+	}
+	function isNodeType(type, node) {
+		return isNode(node) && node.type === type;
+	}
+	var isAttribute = isNodeType.bind(null, _types$1.ATTRIBUTE);
+	exports.isAttribute = isAttribute;
+	var isClassName = isNodeType.bind(null, _types$1.CLASS);
+	exports.isClassName = isClassName;
+	var isCombinator = isNodeType.bind(null, _types$1.COMBINATOR);
+	exports.isCombinator = isCombinator;
+	var isComment = isNodeType.bind(null, _types$1.COMMENT);
+	exports.isComment = isComment;
+	var isIdentifier = isNodeType.bind(null, _types$1.ID);
+	exports.isIdentifier = isIdentifier;
+	var isNesting = isNodeType.bind(null, _types$1.NESTING);
+	exports.isNesting = isNesting;
+	var isPseudo = isNodeType.bind(null, _types$1.PSEUDO);
+	exports.isPseudo = isPseudo;
+	var isRoot = isNodeType.bind(null, _types$1.ROOT);
+	exports.isRoot = isRoot;
+	var isSelector = isNodeType.bind(null, _types$1.SELECTOR);
+	exports.isSelector = isSelector;
+	var isString = isNodeType.bind(null, _types$1.STRING);
+	exports.isString = isString;
+	var isTag = isNodeType.bind(null, _types$1.TAG);
+	exports.isTag = isTag;
+	var isUniversal = isNodeType.bind(null, _types$1.UNIVERSAL);
+	exports.isUniversal = isUniversal;
+	function isPseudoElement(node) {
+		return isPseudo(node) && node.value && (node.value.startsWith("::") || node.value.toLowerCase() === ":before" || node.value.toLowerCase() === ":after" || node.value.toLowerCase() === ":first-letter" || node.value.toLowerCase() === ":first-line");
+	}
+	function isPseudoClass(node) {
+		return isPseudo(node) && !isPseudoElement(node);
+	}
+	function isContainer(node) {
+		return !!(isNode(node) && node.walk);
+	}
+	function isNamespace(node) {
+		return isAttribute(node) || isTag(node);
+	}
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-selector-parser@7.1.0/node_modules/postcss-selector-parser/dist/selectors/index.js
+var require_selectors = /* @__PURE__ */ __commonJSMin(((exports) => {
+	exports.__esModule = true;
+	var _types = require_types();
+	Object.keys(_types).forEach(function(key) {
+		if (key === "default" || key === "__esModule") return;
+		if (key in exports && exports[key] === _types[key]) return;
+		exports[key] = _types[key];
+	});
+	var _constructors = require_constructors();
+	Object.keys(_constructors).forEach(function(key) {
+		if (key === "default" || key === "__esModule") return;
+		if (key in exports && exports[key] === _constructors[key]) return;
+		exports[key] = _constructors[key];
+	});
+	var _guards = require_guards();
+	Object.keys(_guards).forEach(function(key) {
+		if (key === "default" || key === "__esModule") return;
+		if (key in exports && exports[key] === _guards[key]) return;
+		exports[key] = _guards[key];
+	});
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-selector-parser@7.1.0/node_modules/postcss-selector-parser/dist/index.js
+var require_dist = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	exports.__esModule = true;
+	exports["default"] = void 0;
+	var _processor = _interopRequireDefault$2(require_processor());
+	var selectors = _interopRequireWildcard(require_selectors());
+	function _getRequireWildcardCache(nodeInterop) {
+		if (typeof WeakMap !== "function") return null;
+		var cacheBabelInterop = /* @__PURE__ */ new WeakMap();
+		var cacheNodeInterop = /* @__PURE__ */ new WeakMap();
+		return (_getRequireWildcardCache = function _getRequireWildcardCache$4(nodeInterop$1) {
+			return nodeInterop$1 ? cacheNodeInterop : cacheBabelInterop;
+		})(nodeInterop);
+	}
+	function _interopRequireWildcard(obj, nodeInterop) {
+		if (!nodeInterop && obj && obj.__esModule) return obj;
+		if (obj === null || typeof obj !== "object" && typeof obj !== "function") return { "default": obj };
+		var cache = _getRequireWildcardCache(nodeInterop);
+		if (cache && cache.has(obj)) return cache.get(obj);
+		var newObj = {};
+		var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+		for (var key in obj) if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+			var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+			if (desc && (desc.get || desc.set)) Object.defineProperty(newObj, key, desc);
+			else newObj[key] = obj[key];
+		}
+		newObj["default"] = obj;
+		if (cache) cache.set(obj, newObj);
+		return newObj;
+	}
+	function _interopRequireDefault$2(obj) {
+		return obj && obj.__esModule ? obj : { "default": obj };
+	}
+	var parser = function parser$1(processor) {
+		return new _processor["default"](processor);
+	};
+	Object.assign(parser, selectors);
+	var _default = parser;
+	exports["default"] = _default;
+	module.exports = exports.default;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-modules-local-by-default@4.2.0_postcss@8.5.6/node_modules/postcss-modules-local-by-default/src/index.js
+var require_src$2 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const selectorParser$1 = require_dist();
+	const valueParser = require_lib();
+	const { extractICSS } = require_src$4();
+	const IGNORE_FILE_MARKER = "cssmodules-pure-no-check";
+	const IGNORE_NEXT_LINE_MARKER = "cssmodules-pure-ignore";
+	const isSpacing = (node) => node.type === "combinator" && node.value === " ";
+	const isPureCheckDisabled = (root$2) => {
+		for (const node of root$2.nodes) {
+			if (node.type !== "comment") return false;
+			if (node.text.trim().startsWith(IGNORE_FILE_MARKER)) return true;
+		}
+		return false;
+	};
+	function getIgnoreComment(node) {
+		if (!node.parent) return;
+		const indexInParent = node.parent.index(node);
+		for (let i$1 = indexInParent - 1; i$1 >= 0; i$1--) {
+			const prevNode = node.parent.nodes[i$1];
+			if (prevNode.type === "comment") {
+				if (prevNode.text.trimStart().startsWith(IGNORE_NEXT_LINE_MARKER)) return prevNode;
+			} else break;
+		}
+	}
+	function normalizeNodeArray(nodes) {
+		const array = [];
+		nodes.forEach((x) => {
+			if (Array.isArray(x)) normalizeNodeArray(x).forEach((item) => {
+				array.push(item);
+			});
+			else if (x) array.push(x);
+		});
+		if (array.length > 0 && isSpacing(array[array.length - 1])) array.pop();
+		return array;
+	}
+	const isPureSelectorSymbol = Symbol("is-pure-selector");
+	function localizeNode(rule, mode, localAliasMap) {
+		const transform = (node, context) => {
+			if (context.ignoreNextSpacing && !isSpacing(node)) throw new Error("Missing whitespace after " + context.ignoreNextSpacing);
+			if (context.enforceNoSpacing && isSpacing(node)) throw new Error("Missing whitespace before " + context.enforceNoSpacing);
+			let newNodes;
+			switch (node.type) {
+				case "root": {
+					let resultingGlobal;
+					context.hasPureGlobals = false;
+					newNodes = node.nodes.map((n) => {
+						const nContext = {
+							global: context.global,
+							lastWasSpacing: true,
+							hasLocals: false,
+							explicit: false
+						};
+						n = transform(n, nContext);
+						if (typeof resultingGlobal === "undefined") resultingGlobal = nContext.global;
+						else if (resultingGlobal !== nContext.global) throw new Error("Inconsistent rule global/local result in rule \"" + node + "\" (multiple selectors must result in the same mode for the rule)");
+						if (!nContext.hasLocals) context.hasPureGlobals = true;
+						return n;
+					});
+					context.global = resultingGlobal;
+					node.nodes = normalizeNodeArray(newNodes);
+					break;
+				}
+				case "selector":
+					newNodes = node.map((childNode) => transform(childNode, context));
+					node = node.clone();
+					node.nodes = normalizeNodeArray(newNodes);
+					break;
+				case "combinator":
+					if (isSpacing(node)) {
+						if (context.ignoreNextSpacing) {
+							context.ignoreNextSpacing = false;
+							context.lastWasSpacing = false;
+							context.enforceNoSpacing = false;
+							return null;
+						}
+						context.lastWasSpacing = true;
+						return node;
+					}
+					break;
+				case "pseudo": {
+					let childContext;
+					const isNested = !!node.length;
+					const isScoped = node.value === ":local" || node.value === ":global";
+					if (node.value === ":import" || node.value === ":export") context.hasLocals = true;
+					else if (isNested) {
+						if (isScoped) {
+							if (node.nodes.length === 0) throw new Error(`${node.value}() can't be empty`);
+							if (context.inside) throw new Error(`A ${node.value} is not allowed inside of a ${context.inside}(...)`);
+							childContext = {
+								global: node.value === ":global",
+								inside: node.value,
+								hasLocals: false,
+								explicit: true
+							};
+							newNodes = node.map((childNode) => transform(childNode, childContext)).reduce((acc, next) => acc.concat(next.nodes), []);
+							if (newNodes.length) {
+								const { before, after } = node.spaces;
+								const first = newNodes[0];
+								const last = newNodes[newNodes.length - 1];
+								first.spaces = {
+									before,
+									after: first.spaces.after
+								};
+								last.spaces = {
+									before: last.spaces.before,
+									after
+								};
+							}
+							node = newNodes;
+							break;
+						} else {
+							childContext = {
+								global: context.global,
+								inside: context.inside,
+								lastWasSpacing: true,
+								hasLocals: false,
+								explicit: context.explicit
+							};
+							newNodes = node.map((childNode) => {
+								const newContext = {
+									...childContext,
+									enforceNoSpacing: false
+								};
+								const result = transform(childNode, newContext);
+								childContext.global = newContext.global;
+								childContext.hasLocals = newContext.hasLocals;
+								return result;
+							});
+							node = node.clone();
+							node.nodes = normalizeNodeArray(newNodes);
+							if (childContext.hasLocals) context.hasLocals = true;
+						}
+						break;
+					} else if (isScoped) {
+						if (context.inside) throw new Error(`A ${node.value} is not allowed inside of a ${context.inside}(...)`);
+						const addBackSpacing = !!node.spaces.before;
+						context.ignoreNextSpacing = context.lastWasSpacing ? node.value : false;
+						context.enforceNoSpacing = context.lastWasSpacing ? false : node.value;
+						context.global = node.value === ":global";
+						context.explicit = true;
+						return addBackSpacing ? selectorParser$1.combinator({ value: " " }) : null;
+					}
+					break;
+				}
+				case "id":
+				case "class": {
+					if (!node.value) throw new Error("Invalid class or id selector syntax");
+					if (context.global) break;
+					const isImportedValue = localAliasMap.has(node.value);
+					if (!isImportedValue || isImportedValue && context.explicit) {
+						const innerNode = node.clone();
+						innerNode.spaces = {
+							before: "",
+							after: ""
+						};
+						node = selectorParser$1.pseudo({
+							value: ":local",
+							nodes: [innerNode],
+							spaces: node.spaces
+						});
+						context.hasLocals = true;
+					}
+					break;
+				}
+				case "nesting": if (node.value === "&") context.hasLocals = rule.parent[isPureSelectorSymbol];
+			}
+			context.lastWasSpacing = false;
+			context.ignoreNextSpacing = false;
+			context.enforceNoSpacing = false;
+			return node;
+		};
+		const rootContext = {
+			global: mode === "global",
+			hasPureGlobals: false
+		};
+		rootContext.selector = selectorParser$1((root$2) => {
+			transform(root$2, rootContext);
+		}).processSync(rule, {
+			updateSelector: false,
+			lossless: true
+		});
+		return rootContext;
+	}
+	function localizeDeclNode(node, context) {
+		switch (node.type) {
+			case "word":
+				if (context.localizeNextItem) {
+					if (!context.localAliasMap.has(node.value)) {
+						node.value = ":local(" + node.value + ")";
+						context.localizeNextItem = false;
+					}
+				}
+				break;
+			case "function":
+				if (context.options && context.options.rewriteUrl && node.value.toLowerCase() === "url") node.nodes.map((nestedNode) => {
+					if (nestedNode.type !== "string" && nestedNode.type !== "word") return;
+					let newUrl = context.options.rewriteUrl(context.global, nestedNode.value);
+					switch (nestedNode.type) {
+						case "string":
+							if (nestedNode.quote === "'") newUrl = newUrl.replace(/(\\)/g, "\\$1").replace(/'/g, "\\'");
+							if (nestedNode.quote === "\"") newUrl = newUrl.replace(/(\\)/g, "\\$1").replace(/"/g, "\\\"");
+							break;
+						case "word":
+							newUrl = newUrl.replace(/("|'|\)|\\)/g, "\\$1");
+							break;
+					}
+					nestedNode.value = newUrl;
+				});
+				break;
+		}
+		return node;
+	}
+	const specialKeywords = [
+		"none",
+		"inherit",
+		"initial",
+		"revert",
+		"revert-layer",
+		"unset"
+	];
+	function localizeDeclarationValues(localize, declaration, context) {
+		const valueNodes = valueParser(declaration.value);
+		valueNodes.walk((node, index, nodes) => {
+			if (node.type === "function" && (node.value.toLowerCase() === "var" || node.value.toLowerCase() === "env")) return false;
+			if (node.type === "word" && specialKeywords.includes(node.value.toLowerCase())) return;
+			nodes[index] = localizeDeclNode(node, {
+				options: context.options,
+				global: context.global,
+				localizeNextItem: localize && !context.global,
+				localAliasMap: context.localAliasMap
+			});
+		});
+		declaration.value = valueNodes.toString();
+	}
+	const validIdent = /^-?([a-z\u0080-\uFFFF_]|(\\[^\r\n\f])|-(?![0-9]))((\\[^\r\n\f])|[a-z\u0080-\uFFFF_0-9-])*$/i;
+	const animationKeywords = {
+		$normal: 1,
+		$reverse: 1,
+		$alternate: 1,
+		"$alternate-reverse": 1,
+		$forwards: 1,
+		$backwards: 1,
+		$both: 1,
+		$infinite: 1,
+		$paused: 1,
+		$running: 1,
+		$ease: 1,
+		"$ease-in": 1,
+		"$ease-out": 1,
+		"$ease-in-out": 1,
+		$linear: 1,
+		"$step-end": 1,
+		"$step-start": 1,
+		$none: Infinity,
+		$initial: Infinity,
+		$inherit: Infinity,
+		$unset: Infinity,
+		$revert: Infinity,
+		"$revert-layer": Infinity
+	};
+	function localizeDeclaration(declaration, context) {
+		if (/animation(-name)?$/i.test(declaration.prop)) {
+			let parsedAnimationKeywords = {};
+			declaration.value = valueParser(declaration.value).walk((node) => {
+				if (node.type === "div") {
+					parsedAnimationKeywords = {};
+					return;
+				} else if (node.type === "function" && node.value.toLowerCase() === "local" && node.nodes.length === 1) {
+					node.type = "word";
+					node.value = node.nodes[0].value;
+					return localizeDeclNode(node, {
+						options: context.options,
+						global: context.global,
+						localizeNextItem: true,
+						localAliasMap: context.localAliasMap
+					});
+				} else if (node.type === "function") {
+					if (node.value.toLowerCase() === "global" && node.nodes.length === 1) {
+						node.type = "word";
+						node.value = node.nodes[0].value;
+					}
+					return false;
+				} else if (node.type !== "word") return;
+				const value = node.type === "word" ? node.value.toLowerCase() : null;
+				let shouldParseAnimationName = false;
+				if (value && validIdent.test(value)) if ("$" + value in animationKeywords) {
+					parsedAnimationKeywords["$" + value] = "$" + value in parsedAnimationKeywords ? parsedAnimationKeywords["$" + value] + 1 : 0;
+					shouldParseAnimationName = parsedAnimationKeywords["$" + value] >= animationKeywords["$" + value];
+				} else shouldParseAnimationName = true;
+				return localizeDeclNode(node, {
+					options: context.options,
+					global: context.global,
+					localizeNextItem: shouldParseAnimationName && !context.global,
+					localAliasMap: context.localAliasMap
+				});
+			}).toString();
+			return;
+		}
+		if (/url\(/i.test(declaration.value)) return localizeDeclarationValues(false, declaration, context);
+	}
+	const isPureSelector = (context, rule) => {
+		if (!rule.parent || rule.type === "root") return !context.hasPureGlobals;
+		if (rule.type === "rule" && rule[isPureSelectorSymbol]) return rule[isPureSelectorSymbol] || isPureSelector(context, rule.parent);
+		return !context.hasPureGlobals || isPureSelector(context, rule.parent);
+	};
+	const isNodeWithoutDeclarations = (rule) => {
+		if (rule.nodes.length > 0) return !rule.nodes.every((item) => item.type === "rule" || item.type === "atrule" && !isNodeWithoutDeclarations(item));
+		return true;
+	};
+	module.exports = (options = {}) => {
+		if (options && options.mode && options.mode !== "global" && options.mode !== "local" && options.mode !== "pure") throw new Error("options.mode must be either \"global\", \"local\" or \"pure\" (default \"local\")");
+		const pureMode = options && options.mode === "pure";
+		const globalMode = options && options.mode === "global";
+		return {
+			postcssPlugin: "postcss-modules-local-by-default",
+			prepare() {
+				const localAliasMap = /* @__PURE__ */ new Map();
+				return { Once(root$2) {
+					const { icssImports } = extractICSS(root$2, false);
+					const enforcePureMode = pureMode && !isPureCheckDisabled(root$2);
+					Object.keys(icssImports).forEach((key) => {
+						Object.keys(icssImports[key]).forEach((prop) => {
+							localAliasMap.set(prop, icssImports[key][prop]);
+						});
+					});
+					root$2.walkAtRules((atRule) => {
+						if (/keyframes$/i.test(atRule.name)) {
+							const globalMatch = /^\s*:global\s*\((.+)\)\s*$/.exec(atRule.params);
+							const localMatch = /^\s*:local\s*\((.+)\)\s*$/.exec(atRule.params);
+							let globalKeyframes = globalMode;
+							if (globalMatch) {
+								if (enforcePureMode) {
+									const ignoreComment = getIgnoreComment(atRule);
+									if (!ignoreComment) throw atRule.error("@keyframes :global(...) is not allowed in pure mode");
+									else ignoreComment.remove();
+								}
+								atRule.params = globalMatch[1];
+								globalKeyframes = true;
+							} else if (localMatch) {
+								atRule.params = localMatch[0];
+								globalKeyframes = false;
+							} else if (atRule.params && !globalMode && !localAliasMap.has(atRule.params)) atRule.params = ":local(" + atRule.params + ")";
+							atRule.walkDecls((declaration) => {
+								localizeDeclaration(declaration, {
+									localAliasMap,
+									options,
+									global: globalKeyframes
+								});
+							});
+						} else if (/scope$/i.test(atRule.name)) {
+							if (atRule.params) {
+								const ignoreComment = pureMode ? getIgnoreComment(atRule) : void 0;
+								if (ignoreComment) ignoreComment.remove();
+								atRule.params = atRule.params.split("to").map((item) => {
+									const selector$1 = item.trim().slice(1, -1).trim();
+									const context = localizeNode(selector$1, options.mode, localAliasMap);
+									context.options = options;
+									context.localAliasMap = localAliasMap;
+									if (enforcePureMode && context.hasPureGlobals && !ignoreComment) throw atRule.error("Selector in at-rule\"" + selector$1 + "\" is not pure (pure selectors must contain at least one local class or id)");
+									return `(${context.selector})`;
+								}).join(" to ");
+							}
+							atRule.nodes.forEach((declaration) => {
+								if (declaration.type === "decl") localizeDeclaration(declaration, {
+									localAliasMap,
+									options,
+									global: globalMode
+								});
+							});
+						} else if (atRule.nodes) atRule.nodes.forEach((declaration) => {
+							if (declaration.type === "decl") localizeDeclaration(declaration, {
+								localAliasMap,
+								options,
+								global: globalMode
+							});
+						});
+					});
+					root$2.walkRules((rule) => {
+						if (rule.parent && rule.parent.type === "atrule" && /keyframes$/i.test(rule.parent.name)) return;
+						const context = localizeNode(rule, options.mode, localAliasMap);
+						context.options = options;
+						context.localAliasMap = localAliasMap;
+						const ignoreComment = enforcePureMode ? getIgnoreComment(rule) : void 0;
+						const isNotPure = enforcePureMode && !isPureSelector(context, rule);
+						if (isNotPure && isNodeWithoutDeclarations(rule) && !ignoreComment) throw rule.error("Selector \"" + rule.selector + "\" is not pure (pure selectors must contain at least one local class or id)");
+						else if (ignoreComment) ignoreComment.remove();
+						if (pureMode) rule[isPureSelectorSymbol] = !isNotPure;
+						rule.selector = context.selector;
+						if (rule.nodes) rule.nodes.forEach((declaration) => localizeDeclaration(declaration, context));
+					});
+				} };
+			}
+		};
+	};
+	module.exports.postcss = true;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-modules-scope@3.2.1_postcss@8.5.6/node_modules/postcss-modules-scope/src/index.js
+var require_src$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const selectorParser = require_dist();
+	const hasOwnProperty = Object.prototype.hasOwnProperty;
+	function isNestedRule(rule) {
+		if (!rule.parent || rule.parent.type === "root") return false;
+		if (rule.parent.type === "rule") return true;
+		return isNestedRule(rule.parent);
+	}
+	function getSingleLocalNamesForComposes(root$2, rule) {
+		if (isNestedRule(rule)) throw new Error(`composition is not allowed in nested rule \n\n${rule}`);
+		return root$2.nodes.map((node) => {
+			if (node.type !== "selector" || node.nodes.length !== 1) throw new Error(`composition is only allowed when selector is single :local class name not in "${root$2}"`);
+			node = node.nodes[0];
+			if (node.type !== "pseudo" || node.value !== ":local" || node.nodes.length !== 1) throw new Error("composition is only allowed when selector is single :local class name not in \"" + root$2 + "\", \"" + node + "\" is weird");
+			node = node.first;
+			if (node.type !== "selector" || node.length !== 1) throw new Error("composition is only allowed when selector is single :local class name not in \"" + root$2 + "\", \"" + node + "\" is weird");
+			node = node.first;
+			if (node.type !== "class") throw new Error("composition is only allowed when selector is single :local class name not in \"" + root$2 + "\", \"" + node + "\" is weird");
+			return node.value;
+		});
+	}
+	const unescapeRegExp = new RegExp("\\\\([\\da-f]{1,6}[\\x20\\t\\r\\n\\f]?|([\\x20\\t\\r\\n\\f])|.)", "ig");
+	function unescape(str$1) {
+		return str$1.replace(unescapeRegExp, (_, escaped, escapedWhitespace) => {
+			const high = "0x" + escaped - 65536;
+			return high !== high || escapedWhitespace ? escaped : high < 0 ? String.fromCharCode(high + 65536) : String.fromCharCode(high >> 10 | 55296, high & 1023 | 56320);
+		});
+	}
+	const plugin = (options = {}) => {
+		const generateScopedName = options && options.generateScopedName || plugin.generateScopedName;
+		const generateExportEntry = options && options.generateExportEntry || plugin.generateExportEntry;
+		const exportGlobals = options && options.exportGlobals;
+		return {
+			postcssPlugin: "postcss-modules-scope",
+			Once(root$2, { rule }) {
+				const exports$1 = Object.create(null);
+				function exportScopedName(name, rawName, node) {
+					const scopedName = generateScopedName(rawName ? rawName : name, root$2.source.input.from, root$2.source.input.css, node);
+					const { key, value } = generateExportEntry(rawName ? rawName : name, scopedName, root$2.source.input.from, root$2.source.input.css, node);
+					exports$1[key] = exports$1[key] || [];
+					if (exports$1[key].indexOf(value) < 0) exports$1[key].push(value);
+					return scopedName;
+				}
+				function localizeNode$1(node) {
+					switch (node.type) {
+						case "selector":
+							node.nodes = node.map((item) => localizeNode$1(item));
+							return node;
+						case "class": return selectorParser.className({ value: exportScopedName(node.value, node.raws && node.raws.value ? node.raws.value : null, node) });
+						case "id": return selectorParser.id({ value: exportScopedName(node.value, node.raws && node.raws.value ? node.raws.value : null, node) });
+						case "attribute": if (node.attribute === "class" && node.operator === "=") return selectorParser.attribute({
+							attribute: node.attribute,
+							operator: node.operator,
+							quoteMark: "'",
+							value: exportScopedName(node.value, null, null)
+						});
+					}
+					throw new Error(`${node.type} ("${node}") is not allowed in a :local block`);
+				}
+				function traverseNode(node) {
+					switch (node.type) {
+						case "pseudo": if (node.value === ":local") {
+							if (node.nodes.length !== 1) throw new Error("Unexpected comma (\",\") in :local block");
+							const selector$1 = localizeNode$1(node.first);
+							selector$1.first.spaces = node.spaces;
+							const nextNode = node.next();
+							if (nextNode && nextNode.type === "combinator" && nextNode.value === " " && /\\[A-F0-9]{1,6}$/.test(selector$1.last.value)) selector$1.last.spaces.after = " ";
+							node.replaceWith(selector$1);
+							return;
+						}
+						case "root":
+						case "selector":
+							node.each((item) => traverseNode(item));
+							break;
+						case "id":
+						case "class":
+							if (exportGlobals) exports$1[node.value] = [node.value];
+							break;
+					}
+					return node;
+				}
+				const importedNames = {};
+				root$2.walkRules(/^:import\(.+\)$/, (rule$1) => {
+					rule$1.walkDecls((decl) => {
+						importedNames[decl.prop] = true;
+					});
+				});
+				root$2.walkRules((rule$1) => {
+					let parsedSelector = selectorParser().astSync(rule$1);
+					rule$1.selector = traverseNode(parsedSelector.clone()).toString();
+					rule$1.walkDecls(/^(composes|compose-with)$/i, (decl) => {
+						const localNames = getSingleLocalNamesForComposes(parsedSelector, decl.parent);
+						decl.value.split(",").forEach((value) => {
+							value.trim().split(/\s+/).forEach((className$1) => {
+								const global$1 = /^global\(([^)]+)\)$/.exec(className$1);
+								if (global$1) localNames.forEach((exportedName) => {
+									exports$1[exportedName].push(global$1[1]);
+								});
+								else if (hasOwnProperty.call(importedNames, className$1)) localNames.forEach((exportedName) => {
+									exports$1[exportedName].push(className$1);
+								});
+								else if (hasOwnProperty.call(exports$1, className$1)) localNames.forEach((exportedName) => {
+									exports$1[className$1].forEach((item) => {
+										exports$1[exportedName].push(item);
+									});
+								});
+								else throw decl.error(`referenced class name "${className$1}" in ${decl.prop} not found`);
+							});
+						});
+						decl.remove();
+					});
+					rule$1.walkDecls((decl) => {
+						if (!/:local\s*\((.+?)\)/.test(decl.value)) return;
+						let tokens$1 = decl.value.split(/(,|'[^']*'|"[^"]*")/);
+						tokens$1 = tokens$1.map((token, idx) => {
+							if (idx === 0 || tokens$1[idx - 1] === ",") {
+								let result = token;
+								const localMatch = /:local\s*\((.+?)\)/.exec(token);
+								if (localMatch) {
+									const input = localMatch.input;
+									const matchPattern = localMatch[0];
+									const matchVal = localMatch[1];
+									const newVal = exportScopedName(matchVal);
+									result = input.replace(matchPattern, newVal);
+								} else return token;
+								return result;
+							} else return token;
+						});
+						decl.value = tokens$1.join("");
+					});
+				});
+				root$2.walkAtRules(/keyframes$/i, (atRule) => {
+					const localMatch = /^\s*:local\s*\((.+?)\)\s*$/.exec(atRule.params);
+					if (!localMatch) return;
+					atRule.params = exportScopedName(localMatch[1]);
+				});
+				root$2.walkAtRules(/scope$/i, (atRule) => {
+					if (atRule.params) atRule.params = atRule.params.split("to").map((item) => {
+						const selector$1 = item.trim().slice(1, -1).trim();
+						if (!/^\s*:local\s*\((.+?)\)\s*$/.exec(selector$1)) return `(${selector$1})`;
+						return `(${traverseNode(selectorParser().astSync(selector$1)).toString()})`;
+					}).join(" to ");
+				});
+				const exportedNames = Object.keys(exports$1);
+				if (exportedNames.length > 0) {
+					const exportRule = rule({ selector: ":export" });
+					exportedNames.forEach((exportedName) => exportRule.append({
+						prop: exportedName,
+						value: exports$1[exportedName].join(" "),
+						raws: { before: "\n  " }
+					}));
+					root$2.append(exportRule);
+				}
+			}
+		};
+	};
+	plugin.postcss = true;
+	plugin.generateScopedName = function(name, path$2) {
+		return `_${path$2.replace(/\.[^./\\]+$/, "").replace(/[\W_]+/g, "_").replace(/^_|_$/g, "")}__${name}`.trim();
+	};
+	plugin.generateExportEntry = function(name, scopedName) {
+		return {
+			key: unescape(name),
+			value: unescape(scopedName)
+		};
+	};
+	module.exports = plugin;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/string-hash@1.1.3/node_modules/string-hash/index.js
+var require_string_hash = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	function hash(str$1) {
+		var hash$1 = 5381, i$1 = str$1.length;
+		while (i$1) hash$1 = hash$1 * 33 ^ str$1.charCodeAt(--i$1);
+		return hash$1 >>> 0;
+	}
+	module.exports = hash;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-modules-values@4.0.0_postcss@8.5.6/node_modules/postcss-modules-values/src/index.js
+var require_src = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const ICSSUtils = require_src$4();
+	const matchImports = /^(.+?|\([\s\S]+?\))\s+from\s+("[^"]*"|'[^']*'|[\w-]+)$/;
+	const matchValueDefinition = /(?:\s+|^)([\w-]+):?(.*?)$/;
+	const matchImport = /^([\w-]+)(?:\s+as\s+([\w-]+))?/;
+	module.exports = (options) => {
+		let importIndex = 0;
+		const createImportedName = options && options.createImportedName || ((importName) => `i__const_${importName.replace(/\W/g, "_")}_${importIndex++}`);
+		return {
+			postcssPlugin: "postcss-modules-values",
+			prepare(result) {
+				const importAliases = [];
+				const definitions = {};
+				return { Once(root$2, postcss) {
+					root$2.walkAtRules(/value/i, (atRule) => {
+						const matches = atRule.params.match(matchImports);
+						if (matches) {
+							let [, aliases, path$2] = matches;
+							if (definitions[path$2]) path$2 = definitions[path$2];
+							const imports = aliases.replace(/^\(\s*([\s\S]+)\s*\)$/, "$1").split(/\s*,\s*/).map((alias) => {
+								const tokens$1 = matchImport.exec(alias);
+								if (tokens$1) {
+									const [, theirName, myName = theirName] = tokens$1;
+									const importedName = createImportedName(myName);
+									definitions[myName] = importedName;
+									return {
+										theirName,
+										importedName
+									};
+								} else throw new Error(`@import statement "${alias}" is invalid!`);
+							});
+							importAliases.push({
+								path: path$2,
+								imports
+							});
+							atRule.remove();
+							return;
+						}
+						if (atRule.params.indexOf("@value") !== -1) result.warn("Invalid value definition: " + atRule.params);
+						let [, key, value] = `${atRule.params}${atRule.raws.between}`.match(matchValueDefinition);
+						const normalizedValue = value.replace(/\/\*((?!\*\/).*?)\*\//g, "");
+						if (normalizedValue.length === 0) {
+							result.warn("Invalid value definition: " + atRule.params);
+							atRule.remove();
+							return;
+						}
+						if (!/^\s+$/.test(normalizedValue)) value = value.trim();
+						definitions[key] = ICSSUtils.replaceValueSymbols(value, definitions);
+						atRule.remove();
+					});
+					if (!Object.keys(definitions).length) return;
+					ICSSUtils.replaceSymbols(root$2, definitions);
+					const exportDeclarations = Object.keys(definitions).map((key) => postcss.decl({
+						value: definitions[key],
+						prop: key,
+						raws: { before: "\n  " }
+					}));
+					if (exportDeclarations.length > 0) {
+						const exportRule = postcss.rule({
+							selector: ":export",
+							raws: { after: "\n" }
+						});
+						exportRule.append(exportDeclarations);
+						root$2.prepend(exportRule);
+					}
+					importAliases.reverse().forEach(({ path: path$2, imports }) => {
+						const importRule = postcss.rule({
+							selector: `:import(${path$2})`,
+							raws: { after: "\n" }
+						});
+						imports.forEach(({ theirName, importedName }) => {
+							importRule.append({
+								value: theirName,
+								prop: importedName,
+								raws: { before: "\n  " }
+							});
+						});
+						root$2.prepend(importRule);
+					});
+				} };
+			}
+		};
+	};
+	module.exports.postcss = true;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-modules@6.0.1_postcss@8.5.6/node_modules/postcss-modules/build/scoping.js
+var require_scoping = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.behaviours = void 0;
+	exports.getDefaultPlugins = getDefaultPlugins;
+	exports.getDefaultScopeBehaviour = getDefaultScopeBehaviour;
+	exports.getScopedNameGenerator = getScopedNameGenerator;
+	var _postcssModulesExtractImports = _interopRequireDefault$1(require_src$3());
+	var _genericNames = _interopRequireDefault$1(require_generic_names());
+	var _postcssModulesLocalByDefault = _interopRequireDefault$1(require_src$2());
+	var _postcssModulesScope = _interopRequireDefault$1(require_src$1());
+	var _stringHash = _interopRequireDefault$1(require_string_hash());
+	var _postcssModulesValues = _interopRequireDefault$1(require_src());
+	function _interopRequireDefault$1(obj) {
+		return obj && obj.__esModule ? obj : { default: obj };
+	}
+	const behaviours = {
+		LOCAL: "local",
+		GLOBAL: "global"
+	};
+	exports.behaviours = behaviours;
+	function getDefaultPlugins({ behaviour, generateScopedName, exportGlobals }) {
+		const scope = (0, _postcssModulesScope.default)({
+			generateScopedName,
+			exportGlobals
+		});
+		return {
+			[behaviours.LOCAL]: [
+				_postcssModulesValues.default,
+				(0, _postcssModulesLocalByDefault.default)({ mode: "local" }),
+				_postcssModulesExtractImports.default,
+				scope
+			],
+			[behaviours.GLOBAL]: [
+				_postcssModulesValues.default,
+				(0, _postcssModulesLocalByDefault.default)({ mode: "global" }),
+				_postcssModulesExtractImports.default,
+				scope
+			]
+		}[behaviour];
+	}
+	function isValidBehaviour(behaviour) {
+		return Object.keys(behaviours).map((key) => behaviours[key]).indexOf(behaviour) > -1;
+	}
+	function getDefaultScopeBehaviour(scopeBehaviour) {
+		return scopeBehaviour && isValidBehaviour(scopeBehaviour) ? scopeBehaviour : behaviours.LOCAL;
+	}
+	function generateScopedNameDefault(name, filename, css) {
+		const i$1 = css.indexOf(`.${name}`);
+		const lineNumber = css.substr(0, i$1).split(/[\r\n]/).length;
+		return `_${name}_${(0, _stringHash.default)(css).toString(36).substr(0, 5)}_${lineNumber}`;
+	}
+	function getScopedNameGenerator(generateScopedName, hashPrefix) {
+		const scopedNameGenerator = generateScopedName || generateScopedNameDefault;
+		if (typeof scopedNameGenerator === "function") return scopedNameGenerator;
+		return (0, _genericNames.default)(scopedNameGenerator, {
+			context: process.cwd(),
+			hashPrefix
+		});
+	}
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-modules@6.0.1_postcss@8.5.6/node_modules/postcss-modules/build/pluginFactory.js
+var require_pluginFactory = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.makePlugin = makePlugin;
+	var _postcss = _interopRequireDefault(__require("postcss"));
+	var _unquote = _interopRequireDefault(require_unquote());
+	var _Parser = _interopRequireDefault(require_Parser());
+	var _saveJSON = _interopRequireDefault(require_saveJSON());
+	var _localsConvention = require_localsConvention();
+	var _FileSystemLoader = _interopRequireDefault(require_FileSystemLoader());
+	var _scoping = require_scoping();
+	function _interopRequireDefault(obj) {
+		return obj && obj.__esModule ? obj : { default: obj };
+	}
+	const PLUGIN_NAME = "postcss-modules";
+	function isGlobalModule(globalModules, inputFile) {
+		return globalModules.some((regex) => inputFile.match(regex));
+	}
+	function getDefaultPluginsList(opts, inputFile) {
+		const globalModulesList = opts.globalModulePaths || null;
+		const exportGlobals = opts.exportGlobals || false;
+		const defaultBehaviour = (0, _scoping.getDefaultScopeBehaviour)(opts.scopeBehaviour);
+		const generateScopedName = (0, _scoping.getScopedNameGenerator)(opts.generateScopedName, opts.hashPrefix);
+		if (globalModulesList && isGlobalModule(globalModulesList, inputFile)) return (0, _scoping.getDefaultPlugins)({
+			behaviour: _scoping.behaviours.GLOBAL,
+			generateScopedName,
+			exportGlobals
+		});
+		return (0, _scoping.getDefaultPlugins)({
+			behaviour: defaultBehaviour,
+			generateScopedName,
+			exportGlobals
+		});
+	}
+	function getLoader(opts, plugins) {
+		const root$2 = typeof opts.root === "undefined" ? "/" : opts.root;
+		return typeof opts.Loader === "function" ? new opts.Loader(root$2, plugins, opts.resolve) : new _FileSystemLoader.default(root$2, plugins, opts.resolve);
+	}
+	function isOurPlugin(plugin$1) {
+		return plugin$1.postcssPlugin === PLUGIN_NAME;
+	}
+	function makePlugin(opts) {
+		return {
+			postcssPlugin: PLUGIN_NAME,
+			async OnceExit(css, { result }) {
+				const getJSON = opts.getJSON || _saveJSON.default;
+				const inputFile = css.source.input.file;
+				const pluginList = getDefaultPluginsList(opts, inputFile);
+				const resultPluginIndex = result.processor.plugins.findIndex((plugin$1) => isOurPlugin(plugin$1));
+				if (resultPluginIndex === -1) throw new Error("Plugin missing from options.");
+				const loader = getLoader(opts, [...result.processor.plugins.slice(0, resultPluginIndex), ...pluginList]);
+				const fetcher = async (file, relativeTo, depTrace) => {
+					const unquoteFile = (0, _unquote.default)(file);
+					return loader.fetch.call(loader, unquoteFile, relativeTo, depTrace);
+				};
+				const parser$1 = new _Parser.default(fetcher);
+				await (0, _postcss.default)([...pluginList, parser$1.plugin()]).process(css, { from: inputFile });
+				const out = loader.finalSource;
+				if (out) css.prepend(out);
+				if (opts.localsConvention) {
+					const reducer = (0, _localsConvention.makeLocalsConventionReducer)(opts.localsConvention, inputFile);
+					parser$1.exportTokens = Object.entries(parser$1.exportTokens).reduce(reducer, {});
+				}
+				result.messages.push({
+					type: "export",
+					plugin: "postcss-modules",
+					exportTokens: parser$1.exportTokens
+				});
+				return getJSON(css.source.input.file, parser$1.exportTokens, result.opts.to);
+			}
+		};
+	}
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/postcss-modules@6.0.1_postcss@8.5.6/node_modules/postcss-modules/build/index.js
+var require_build = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var _fs = __require("fs");
+	var _fs2 = require_fs();
+	var _pluginFactory = require_pluginFactory();
+	(0, _fs2.setFileSystem)({
+		readFile: _fs.readFile,
+		writeFile: _fs.writeFile
+	});
+	module.exports = (opts = {}) => (0, _pluginFactory.makePlugin)(opts);
+	module.exports.postcss = true;
+}));
+
+//#endregion
+export default require_build();
+
+export {  };
\ No newline at end of file