gemi 0.53.0 → 0.54.0

package/dist/vite/postcss-hCXrlC4m.mjs

@@ -0,0 +1,3515 @@
+import { i as __toESM, t as __commonJSMin } from "./rolldown-runtime-B4lejLz5.mjs";
+import { t as require___vite_browser_external } from "./__vite-browser-external-S5EYS4bz.mjs";
+//#region ../../node_modules/.bun/picocolors@1.1.1/node_modules/picocolors/picocolors.browser.js
+var require_picocolors_browser = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var x = String;
+	var create = function() {
+		return {
+			isColorSupported: false,
+			reset: x,
+			bold: x,
+			dim: x,
+			italic: x,
+			underline: x,
+			inverse: x,
+			hidden: x,
+			strikethrough: x,
+			black: x,
+			red: x,
+			green: x,
+			yellow: x,
+			blue: x,
+			magenta: x,
+			cyan: x,
+			white: x,
+			gray: x,
+			bgBlack: x,
+			bgRed: x,
+			bgGreen: x,
+			bgYellow: x,
+			bgBlue: x,
+			bgMagenta: x,
+			bgCyan: x,
+			bgWhite: x,
+			blackBright: x,
+			redBright: x,
+			greenBright: x,
+			yellowBright: x,
+			blueBright: x,
+			magentaBright: x,
+			cyanBright: x,
+			whiteBright: x,
+			bgBlackBright: x,
+			bgRedBright: x,
+			bgGreenBright: x,
+			bgYellowBright: x,
+			bgBlueBright: x,
+			bgMagentaBright: x,
+			bgCyanBright: x,
+			bgWhiteBright: x
+		};
+	};
+	module.exports = create();
+	module.exports.createColors = create;
+}));
+//#endregion
+//#region ../../node_modules/.bun/postcss@8.5.19/node_modules/postcss/lib/css-syntax-error.js
+var require_css_syntax_error = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var pico = require_picocolors_browser();
+	var terminalHighlight = require___vite_browser_external();
+	var CssSyntaxError = class CssSyntaxError extends Error {
+		constructor(message, line, column, source, file, plugin) {
+			super(message);
+			this.name = "CssSyntaxError";
+			this.reason = message;
+			if (file) this.file = file;
+			if (source) this.source = source;
+			if (plugin) this.plugin = plugin;
+			if (typeof line !== "undefined" && typeof column !== "undefined") if (typeof line === "number") {
+				this.line = line;
+				this.column = column;
+			} else {
+				this.line = line.line;
+				this.column = line.column;
+				this.endLine = column.line;
+				this.endColumn = column.column;
+			}
+			this.setMessage();
+			if (Error.captureStackTrace) Error.captureStackTrace(this, CssSyntaxError);
+		}
+		setMessage() {
+			this.message = this.plugin ? this.plugin + ": " : "";
+			this.message += this.file ? this.file : "<css input>";
+			if (typeof this.line !== "undefined") this.message += ":" + this.line + ":" + this.column;
+			this.message += ": " + this.reason;
+		}
+		showSourceCode(color) {
+			if (!this.source) return "";
+			let css = this.source;
+			if (color == null) color = pico.isColorSupported;
+			let aside = (text) => text;
+			let mark = (text) => text;
+			let highlight = (text) => text;
+			if (color) {
+				let { bold, gray, red } = pico.createColors(true);
+				mark = (text) => bold(red(text));
+				aside = (text) => gray(text);
+				if (terminalHighlight) highlight = (text) => terminalHighlight(text);
+			}
+			let lines = css.split(/\r?\n/);
+			let start = Math.max(this.line - 3, 0);
+			let end = Math.min(this.line + 2, lines.length);
+			let maxWidth = String(end).length;
+			return lines.slice(start, end).map((line, index) => {
+				let number = start + 1 + index;
+				let gutter = " " + (" " + number).slice(-maxWidth) + " | ";
+				if (number === this.line) {
+					if (line.length > 160) {
+						let padding = 20;
+						let subLineStart = Math.max(0, this.column - padding);
+						let subLineEnd = Math.max(this.column + padding, this.endColumn + padding);
+						let subLine = line.slice(subLineStart, subLineEnd);
+						let spacing = aside(gutter.replace(/\d/g, " ")) + line.slice(0, Math.min(this.column - 1, padding - 1)).replace(/[^\t]/g, " ");
+						return mark(">") + aside(gutter) + highlight(subLine) + "\n " + spacing + mark("^");
+					}
+					let spacing = aside(gutter.replace(/\d/g, " ")) + line.slice(0, this.column - 1).replace(/[^\t]/g, " ");
+					return mark(">") + aside(gutter) + highlight(line) + "\n " + spacing + mark("^");
+				}
+				return " " + aside(gutter) + highlight(line);
+			}).join("\n");
+		}
+		toString() {
+			let code = this.showSourceCode();
+			if (code) code = "\n\n" + code + "\n";
+			return this.name + ": " + this.message + code;
+		}
+	};
+	module.exports = CssSyntaxError;
+	CssSyntaxError.default = CssSyntaxError;
+}));
+//#endregion
+//#region ../../node_modules/.bun/postcss@8.5.19/node_modules/postcss/lib/stringifier.js
+var require_stringifier = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var STYLE_TAG = /(<)(\/?style\b)/gi;
+	var COMMENT_OPEN = /(<)(!--)/g;
+	function escapeHTMLInCSS(str) {
+		if (typeof str !== "string") return str;
+		if (!str.includes("<")) return str;
+		return str.replace(STYLE_TAG, "\\3c $2").replace(COMMENT_OPEN, "\\3c $2");
+	}
+	var DEFAULT_RAW = {
+		after: "\n",
+		beforeClose: "\n",
+		beforeComment: "\n",
+		beforeDecl: "\n",
+		beforeOpen: " ",
+		beforeRule: "\n",
+		colon: ": ",
+		commentLeft: " ",
+		commentRight: " ",
+		emptyBody: "",
+		indent: "    ",
+		semicolon: false
+	};
+	function capitalize(str) {
+		return str[0].toUpperCase() + str.slice(1);
+	}
+	function atruleStart(str, node) {
+		let name = "@" + node.name;
+		let params = node.params ? str.rawValue(node, "params") : "";
+		if (typeof node.raws.afterName !== "undefined") name += node.raws.afterName;
+		else if (params) name += " ";
+		return name + params;
+	}
+	function pushBody(str, stack, node) {
+		let nodes = node.nodes;
+		let last = nodes.length - 1;
+		while (last > 0) {
+			if (nodes[last].type !== "comment") break;
+			last -= 1;
+		}
+		let semicolon = str.raw(node, "semicolon");
+		let isDocument = node.type === "document";
+		for (let i = nodes.length - 1; i >= 0; i--) stack.push({
+			document: isDocument,
+			node: nodes[i],
+			semicolon: last !== i || semicolon
+		});
+	}
+	function pushBlock(str, stack, node, start) {
+		let between = str.raw(node, "between", "beforeOpen");
+		str.builder(escapeHTMLInCSS(start + between) + "{", node, "start");
+		let hasNodes = node.nodes && node.nodes.length;
+		let close = () => {
+			let after = hasNodes ? str.raw(node, "after") : str.raw(node, "after", "emptyBody");
+			if (after) str.builder(escapeHTMLInCSS(after));
+			str.builder("}", node, "end");
+			if (node.type === "rule" && node.raws.ownSemicolon) str.builder(escapeHTMLInCSS(node.raws.ownSemicolon), node, "end");
+		};
+		if (hasNodes) {
+			stack.push(close);
+			pushBody(str, stack, node);
+		} else close();
+	}
+	var Stringifier = class Stringifier {
+		constructor(builder) {
+			this.builder = builder;
+		}
+		atrule(node, semicolon) {
+			let start = atruleStart(this, node);
+			if (node.nodes) this.block(node, start);
+			else {
+				let end = (node.raws.between || "") + (semicolon ? ";" : "");
+				this.builder(escapeHTMLInCSS(start + end), node);
+			}
+		}
+		beforeAfter(node, detect) {
+			let value;
+			if (node.type === "decl") value = this.raw(node, null, "beforeDecl");
+			else if (node.type === "comment") value = this.raw(node, null, "beforeComment");
+			else if (detect === "before") value = this.raw(node, null, "beforeRule");
+			else value = this.raw(node, null, "beforeClose");
+			let buf = node.parent;
+			let depth = 0;
+			while (buf && buf.type !== "root") {
+				depth += 1;
+				buf = buf.parent;
+			}
+			if (value.includes("\n")) {
+				let indent = this.raw(node, null, "indent");
+				if (indent.length) for (let step = 0; step < depth; step++) value += indent;
+			}
+			return value;
+		}
+		block(node, start) {
+			let between = this.raw(node, "between", "beforeOpen");
+			this.builder(escapeHTMLInCSS(start + between) + "{", node, "start");
+			let after;
+			if (node.nodes && node.nodes.length) {
+				this.body(node);
+				after = this.raw(node, "after");
+			} else after = this.raw(node, "after", "emptyBody");
+			if (after) this.builder(escapeHTMLInCSS(after));
+			this.builder("}", node, "end");
+		}
+		body(node) {
+			let proto = Stringifier.prototype;
+			let expandable = [
+				"atrule",
+				"block",
+				"body",
+				"rule",
+				"stringify"
+			].every((method) => this[method] === proto[method]);
+			let stack = [];
+			pushBody(this, stack, node);
+			while (stack.length > 0) {
+				let entry = stack.pop();
+				if (typeof entry === "function") {
+					entry();
+					continue;
+				}
+				let child = entry.node;
+				let before = this.raw(child, "before");
+				if (before) this.builder(entry.document ? before : escapeHTMLInCSS(before));
+				if (expandable && child.type === "rule") pushBlock(this, stack, child, this.rawValue(child, "selector"));
+				else if (expandable && child.type === "atrule" && child.nodes) pushBlock(this, stack, child, atruleStart(this, child));
+				else this.stringify(child, entry.semicolon);
+			}
+		}
+		comment(node) {
+			let left = this.raw(node, "left", "commentLeft");
+			let right = this.raw(node, "right", "commentRight");
+			this.builder(escapeHTMLInCSS("/*" + left + node.text + right + "*/"), node);
+		}
+		decl(node, semicolon) {
+			let raws = node.raws;
+			let between = this.raw(node, "between", "colon");
+			let string = node.prop + between + this.rawValue(node, "value");
+			if (node.important) string += raws.important || " !important";
+			if (semicolon) string += ";";
+			this.builder(escapeHTMLInCSS(string), node);
+		}
+		document(node) {
+			this.body(node);
+		}
+		raw(node, own, detect) {
+			let value;
+			if (!detect) detect = own;
+			if (own) {
+				value = node.raws[own];
+				if (typeof value !== "undefined") return value;
+			}
+			let parent = node.parent;
+			if (detect === "before") {
+				if (!parent || parent.type === "root" && parent.first === node) return "";
+				if (parent && parent.type === "document") return "";
+			}
+			if (!parent) return DEFAULT_RAW[detect];
+			let root = node.root();
+			let cache = root.rawCache || (root.rawCache = {});
+			if (typeof cache[detect] !== "undefined") return cache[detect];
+			if (detect === "before" || detect === "after") return this.beforeAfter(node, detect);
+			else {
+				let method = "raw" + capitalize(detect);
+				if (this[method]) value = this[method](root, node);
+				else root.walk((i) => {
+					value = i.raws[own];
+					if (typeof value !== "undefined") return false;
+				});
+			}
+			if (typeof value === "undefined") value = DEFAULT_RAW[detect];
+			cache[detect] = value;
+			return value;
+		}
+		rawBeforeClose(root) {
+			let value;
+			root.walk((i) => {
+				if (i.nodes && i.nodes.length > 0) {
+					if (typeof i.raws.after !== "undefined") {
+						value = i.raws.after;
+						if (value.includes("\n")) value = value.replace(/[^\n]+$/, "");
+						return false;
+					}
+				}
+			});
+			if (value) value = value.replace(/\S/g, "");
+			return value;
+		}
+		rawBeforeComment(root, node) {
+			let value;
+			root.walkComments((i) => {
+				if (typeof i.raws.before !== "undefined") {
+					value = i.raws.before;
+					if (value.includes("\n")) value = value.replace(/[^\n]+$/, "");
+					return false;
+				}
+			});
+			if (typeof value === "undefined") value = this.raw(node, null, "beforeDecl");
+			else if (value) value = value.replace(/\S/g, "");
+			return value;
+		}
+		rawBeforeDecl(root, node) {
+			let value;
+			root.walkDecls((i) => {
+				if (typeof i.raws.before !== "undefined") {
+					value = i.raws.before;
+					if (value.includes("\n")) value = value.replace(/[^\n]+$/, "");
+					return false;
+				}
+			});
+			if (typeof value === "undefined") value = this.raw(node, null, "beforeRule");
+			else if (value) value = value.replace(/\S/g, "");
+			return value;
+		}
+		rawBeforeOpen(root) {
+			let value;
+			root.walk((i) => {
+				if (i.type !== "decl") {
+					value = i.raws.between;
+					if (typeof value !== "undefined") return false;
+				}
+			});
+			return value;
+		}
+		rawBeforeRule(root) {
+			let value;
+			root.walk((i) => {
+				if (i.nodes && (i.parent !== root || root.first !== i)) {
+					if (typeof i.raws.before !== "undefined") {
+						value = i.raws.before;
+						if (value.includes("\n")) value = value.replace(/[^\n]+$/, "");
+						return false;
+					}
+				}
+			});
+			if (value) value = value.replace(/\S/g, "");
+			return value;
+		}
+		rawColon(root) {
+			let value;
+			root.walkDecls((i) => {
+				if (typeof i.raws.between !== "undefined") {
+					value = i.raws.between.replace(/[^\s:]/g, "");
+					return false;
+				}
+			});
+			return value;
+		}
+		rawEmptyBody(root) {
+			let value;
+			root.walk((i) => {
+				if (i.nodes && i.nodes.length === 0) {
+					value = i.raws.after;
+					if (typeof value !== "undefined") return false;
+				}
+			});
+			return value;
+		}
+		rawIndent(root) {
+			if (root.raws.indent) return root.raws.indent;
+			let value;
+			root.walk((i) => {
+				let p = i.parent;
+				if (p && p !== root && p.parent && p.parent === root) {
+					if (typeof i.raws.before !== "undefined") {
+						let parts = i.raws.before.split("\n");
+						value = parts[parts.length - 1];
+						value = value.replace(/\S/g, "");
+						return false;
+					}
+				}
+			});
+			return value;
+		}
+		rawSemicolon(root) {
+			let value;
+			root.walk((i) => {
+				if (i.nodes && i.nodes.length && i.last.type === "decl") {
+					value = i.raws.semicolon;
+					if (typeof value !== "undefined") return false;
+				}
+			});
+			return value;
+		}
+		rawValue(node, prop) {
+			let value = node[prop];
+			let raw = node.raws[prop];
+			if (raw && raw.value === value) return raw.raw;
+			return value;
+		}
+		root(node) {
+			this.body(node);
+			if (node.raws.after) {
+				let after = node.raws.after;
+				let isDocument = node.parent && node.parent.type === "document";
+				this.builder(isDocument ? after : escapeHTMLInCSS(after));
+			}
+		}
+		rule(node) {
+			this.block(node, this.rawValue(node, "selector"));
+			if (node.raws.ownSemicolon) this.builder(escapeHTMLInCSS(node.raws.ownSemicolon), node, "end");
+		}
+		stringify(node, semicolon) {
+			/* c8 ignore start */
+			if (!this[node.type]) throw new Error("Unknown AST node type " + node.type + ". Maybe you need to change PostCSS stringifier.");
+			/* c8 ignore stop */
+			this[node.type](node, semicolon);
+		}
+	};
+	module.exports = Stringifier;
+	Stringifier.default = Stringifier;
+}));
+//#endregion
+//#region ../../node_modules/.bun/postcss@8.5.19/node_modules/postcss/lib/stringify.js
+var require_stringify = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var Stringifier = require_stringifier();
+	function stringify(node, builder) {
+		new Stringifier(builder).stringify(node);
+	}
+	module.exports = stringify;
+	stringify.default = stringify;
+}));
+//#endregion
+//#region ../../node_modules/.bun/postcss@8.5.19/node_modules/postcss/lib/symbols.js
+var require_symbols = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports.isClean = Symbol("isClean");
+	module.exports.my = Symbol("my");
+}));
+//#endregion
+//#region ../../node_modules/.bun/postcss@8.5.19/node_modules/postcss/lib/node.js
+var require_node = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var CssSyntaxError = require_css_syntax_error();
+	var Stringifier = require_stringifier();
+	var stringify = require_stringify();
+	var { isClean, my } = require_symbols();
+	function cloneNode(obj, parent) {
+		let cloned = new obj.constructor();
+		let stack = [[
+			obj,
+			cloned,
+			parent
+		]];
+		while (stack.length > 0) {
+			let [source, target, targetParent] = stack.pop();
+			for (let i in source) {
+				if (!Object.prototype.hasOwnProperty.call(source, i))
+ /* c8 ignore next 2 */
+				continue;
+				if (i === "proxyCache") continue;
+				let value = source[i];
+				let type = typeof value;
+				if (i === "parent" && type === "object") {
+					if (targetParent) target[i] = targetParent;
+				} else if (i === "source") target[i] = value;
+				else if (Array.isArray(value)) {
+					let children = [];
+					target[i] = children;
+					for (let j of value) {
+						let childClone = new j.constructor();
+						children.push(childClone);
+						stack.push([
+							j,
+							childClone,
+							target
+						]);
+					}
+				} else {
+					if (type === "object" && value !== null) {
+						let valueClone = new value.constructor();
+						stack.push([
+							value,
+							valueClone,
+							void 0
+						]);
+						value = valueClone;
+					}
+					target[i] = value;
+				}
+			}
+		}
+		return cloned;
+	}
+	function sourceOffset(inputCSS, position) {
+		if (position && typeof position.offset !== "undefined") return position.offset;
+		let column = 1;
+		let line = 1;
+		let offset = 0;
+		for (let i = 0; i < inputCSS.length; i++) {
+			if (line === position.line && column === position.column) {
+				offset = i;
+				break;
+			}
+			if (inputCSS[i] === "\n") {
+				column = 1;
+				line += 1;
+			} else column += 1;
+		}
+		return offset;
+	}
+	var Node = class Node {
+		get proxyOf() {
+			return this;
+		}
+		constructor(defaults = {}) {
+			this.raws = {};
+			this[isClean] = false;
+			this[my] = true;
+			for (let name of Object.keys(defaults)) {
+				if (name === "__proto__") continue;
+				if (name === "nodes") {
+					this.nodes = [];
+					for (let node of defaults[name]) if (typeof node.clone === "function" && node.parent) this.append(node.clone());
+					else this.append(node);
+				} else this[name] = defaults[name];
+			}
+		}
+		addToError(error) {
+			error.postcssNode = this;
+			if (error.stack && this.source && /\n\s{4}at /.test(error.stack)) {
+				let s = this.source;
+				error.stack = error.stack.replace(/\n\s{4}at /, `$&${s.input.from}:${s.start.line}:${s.start.column}$&`);
+			}
+			return error;
+		}
+		after(add) {
+			this.parent.insertAfter(this, add);
+			return this;
+		}
+		assign(overrides = {}) {
+			for (let name in overrides) this[name] = overrides[name];
+			return this;
+		}
+		before(add) {
+			this.parent.insertBefore(this, add);
+			return this;
+		}
+		cleanRaws(keepBetween) {
+			delete this.raws.before;
+			delete this.raws.after;
+			if (!keepBetween) delete this.raws.between;
+		}
+		clone(overrides = {}) {
+			let cloned = cloneNode(this);
+			for (let name in overrides) cloned[name] = overrides[name];
+			return cloned;
+		}
+		cloneAfter(overrides = {}) {
+			let cloned = this.clone(overrides);
+			this.parent.insertAfter(this, cloned);
+			return cloned;
+		}
+		cloneBefore(overrides = {}) {
+			let cloned = this.clone(overrides);
+			this.parent.insertBefore(this, cloned);
+			return cloned;
+		}
+		error(message, opts = {}) {
+			if (this.source) {
+				let { end, start } = this.rangeBy(opts);
+				return this.source.input.error(message, {
+					column: start.column,
+					line: start.line
+				}, {
+					column: end.column,
+					line: end.line
+				}, opts);
+			}
+			return new CssSyntaxError(message);
+		}
+		getProxyProcessor() {
+			return {
+				get(node, prop) {
+					if (prop === "proxyOf") return node;
+					else if (prop === "root") return () => node.root().toProxy();
+					else return node[prop];
+				},
+				set(node, prop, value) {
+					if (node[prop] === value) return true;
+					node[prop] = value;
+					if (prop === "prop" || prop === "value" || prop === "name" || prop === "params" || prop === "important" || prop === "text") node.markDirty();
+					return true;
+				}
+			};
+		}
+		/* c8 ignore next 3 */
+		markClean() {
+			this[isClean] = true;
+		}
+		markDirty() {
+			if (this[isClean]) {
+				this[isClean] = false;
+				let next = this;
+				while (next = next.parent) next[isClean] = false;
+			}
+		}
+		next() {
+			if (!this.parent) return void 0;
+			let index = this.parent.index(this);
+			return this.parent.nodes[index + 1];
+		}
+		positionBy(opts = {}) {
+			let inputString = "document" in this.source.input ? this.source.input.document : this.source.input.css;
+			let pos = {
+				column: this.source.start.column,
+				line: this.source.start.line,
+				offset: sourceOffset(inputString, this.source.start)
+			};
+			if (opts.index) pos = this.positionInside(opts.index);
+			else if (opts.word) {
+				let index = inputString.slice(sourceOffset(inputString, this.source.start), sourceOffset(inputString, this.source.end)).indexOf(opts.word);
+				if (index !== -1) pos = this.positionInside(index);
+			}
+			return pos;
+		}
+		positionInside(index) {
+			let column = this.source.start.column;
+			let line = this.source.start.line;
+			let inputString = "document" in this.source.input ? this.source.input.document : this.source.input.css;
+			let offset = sourceOffset(inputString, this.source.start);
+			let end = offset + index;
+			for (let i = offset; i < end; i++) if (inputString[i] === "\n") {
+				column = 1;
+				line += 1;
+			} else column += 1;
+			return {
+				column,
+				line,
+				offset: end
+			};
+		}
+		prev() {
+			if (!this.parent) return void 0;
+			let index = this.parent.index(this);
+			return this.parent.nodes[index - 1];
+		}
+		rangeBy(opts = {}) {
+			let inputString = "document" in this.source.input ? this.source.input.document : this.source.input.css;
+			let start = {
+				column: this.source.start.column,
+				line: this.source.start.line,
+				offset: sourceOffset(inputString, this.source.start)
+			};
+			let end = this.source.end ? {
+				column: this.source.end.column + 1,
+				line: this.source.end.line,
+				offset: typeof this.source.end.offset === "number" ? this.source.end.offset : sourceOffset(inputString, this.source.end) + 1
+			} : {
+				column: start.column + 1,
+				line: start.line,
+				offset: start.offset + 1
+			};
+			if (opts.word) {
+				let index = inputString.slice(sourceOffset(inputString, this.source.start), sourceOffset(inputString, this.source.end)).indexOf(opts.word);
+				if (index !== -1) {
+					start = this.positionInside(index);
+					end = this.positionInside(index + opts.word.length);
+				}
+			} else {
+				if (opts.start) start = {
+					column: opts.start.column,
+					line: opts.start.line,
+					offset: sourceOffset(inputString, opts.start)
+				};
+				else if (typeof opts.index === "number") start = this.positionInside(opts.index);
+				if (opts.end) end = {
+					column: opts.end.column,
+					line: opts.end.line,
+					offset: sourceOffset(inputString, opts.end)
+				};
+				else if (typeof opts.endIndex === "number") end = this.positionInside(opts.endIndex);
+				else if (typeof opts.index === "number") end = this.positionInside(opts.index + 1);
+			}
+			if (end.line < start.line || end.line === start.line && end.column <= start.column) end = {
+				column: start.column + 1,
+				line: start.line,
+				offset: start.offset + 1
+			};
+			return {
+				end,
+				start
+			};
+		}
+		raw(prop, defaultType) {
+			return new Stringifier().raw(this, prop, defaultType);
+		}
+		remove() {
+			if (this.parent) this.parent.removeChild(this);
+			this.parent = void 0;
+			return this;
+		}
+		replaceWith(...nodes) {
+			if (this.parent) {
+				let bookmark = this;
+				let foundSelf = false;
+				for (let node of nodes) if (node === this) foundSelf = true;
+				else if (foundSelf) {
+					this.parent.insertAfter(bookmark, node);
+					bookmark = node;
+				} else this.parent.insertBefore(bookmark, node);
+				if (!foundSelf) this.remove();
+			}
+			return this;
+		}
+		root() {
+			let result = this;
+			while (result.parent && result.parent.type !== "document") result = result.parent;
+			return result;
+		}
+		toJSON(_, inputs) {
+			let emitInputs = inputs == null;
+			inputs = inputs || /* @__PURE__ */ new Map();
+			let holderOfRoot = [];
+			let queue = [[
+				this,
+				holderOfRoot,
+				0
+			]];
+			for (let step = 0; step < queue.length; step++) {
+				let [node, holder, key] = queue[step];
+				let fixed = {};
+				holder[key] = fixed;
+				for (let name in node) {
+					if (!Object.prototype.hasOwnProperty.call(node, name))
+ /* c8 ignore next 2 */
+					continue;
+					if (name === "parent" || name === "proxyCache") continue;
+					let value = node[name];
+					if (Array.isArray(value)) {
+						let fixedArray = [];
+						fixed[name] = fixedArray;
+						for (let i = 0; i < value.length; i++) {
+							let item = value[i];
+							if (typeof item === "object" && item.toJSON) if (item.toJSON === Node.prototype.toJSON) queue.push([
+								item,
+								fixedArray,
+								i
+							]);
+							else fixedArray[i] = item.toJSON(null, inputs);
+							else fixedArray[i] = item;
+						}
+					} else if (typeof value === "object" && value.toJSON) if (value.toJSON === Node.prototype.toJSON) queue.push([
+						value,
+						fixed,
+						name
+					]);
+					else fixed[name] = value.toJSON(null, inputs);
+					else if (name === "source") {
+						if (value == null) continue;
+						let inputId = inputs.get(value.input);
+						if (inputId == null) {
+							inputId = inputs.size;
+							inputs.set(value.input, inputId);
+						}
+						fixed[name] = {
+							end: value.end,
+							inputId,
+							start: value.start
+						};
+					} else fixed[name] = value;
+				}
+			}
+			let fixed = holderOfRoot[0];
+			if (emitInputs) fixed.inputs = [...inputs.keys()].map((input) => input.toJSON());
+			return fixed;
+		}
+		toProxy() {
+			if (!this.proxyCache) this.proxyCache = new Proxy(this, this.getProxyProcessor());
+			return this.proxyCache;
+		}
+		toString(stringifier = stringify) {
+			if (stringifier.stringify) stringifier = stringifier.stringify;
+			let result = "";
+			stringifier(this, (i) => {
+				result += i;
+			});
+			return result;
+		}
+		warn(result, text, opts = {}) {
+			let data = { node: this };
+			for (let i in opts) data[i] = opts[i];
+			return result.warn(text, data);
+		}
+	};
+	module.exports = Node;
+	Node.default = Node;
+}));
+//#endregion
+//#region ../../node_modules/.bun/postcss@8.5.19/node_modules/postcss/lib/comment.js
+var require_comment = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var Node = require_node();
+	var Comment = class extends Node {
+		constructor(defaults) {
+			super(defaults);
+			this.type = "comment";
+		}
+	};
+	module.exports = Comment;
+	Comment.default = Comment;
+}));
+//#endregion
+//#region ../../node_modules/.bun/postcss@8.5.19/node_modules/postcss/lib/declaration.js
+var require_declaration = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var Node = require_node();
+	var Declaration = class extends Node {
+		get variable() {
+			return this.prop.startsWith("--") || this.prop[0] === "$";
+		}
+		constructor(defaults) {
+			if (defaults && typeof defaults.value !== "undefined" && typeof defaults.value !== "string") defaults = {
+				...defaults,
+				value: String(defaults.value)
+			};
+			super(defaults);
+			this.type = "decl";
+		}
+	};
+	module.exports = Declaration;
+	Declaration.default = Declaration;
+}));
+//#endregion
+//#region ../../node_modules/.bun/postcss@8.5.19/node_modules/postcss/lib/container.js
+var require_container = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var Comment = require_comment();
+	var Declaration = require_declaration();
+	var Node = require_node();
+	var { isClean, my } = require_symbols();
+	var AtRule;
+	var parse;
+	var Root;
+	var Rule;
+	function cleanSource(nodes) {
+		let stack = nodes.slice();
+		while (stack.length > 0) {
+			let node = stack.pop();
+			delete node.source;
+			if (node.nodes) {
+				node.nodes = node.nodes.slice();
+				for (let i of node.nodes) stack.push(i);
+			}
+		}
+		return nodes.slice();
+	}
+	function markTreeDirty(node) {
+		let stack = [node];
+		while (stack.length > 0) {
+			let next = stack.pop();
+			next[isClean] = false;
+			if (next.proxyOf.nodes) for (let i of next.proxyOf.nodes) stack.push(i);
+		}
+	}
+	var Container = class Container extends Node {
+		get first() {
+			if (!this.proxyOf.nodes) return void 0;
+			return this.proxyOf.nodes[0];
+		}
+		get last() {
+			if (!this.proxyOf.nodes) return void 0;
+			return this.proxyOf.nodes[this.proxyOf.nodes.length - 1];
+		}
+		append(...children) {
+			for (let child of children) {
+				let nodes = this.normalize(child, this.last);
+				for (let node of nodes) this.proxyOf.nodes.push(node);
+			}
+			this.markDirty();
+			return this;
+		}
+		cleanRaws(keepBetween) {
+			let stack = [this];
+			while (stack.length > 0) {
+				let node = stack.pop();
+				if (node !== this && node.cleanRaws !== Container.prototype.cleanRaws) {
+					node.cleanRaws(keepBetween);
+					continue;
+				}
+				Node.prototype.cleanRaws.call(node, keepBetween);
+				if (node.nodes) for (let child of node.nodes) stack.push(child);
+			}
+		}
+		each(callback) {
+			if (!this.proxyOf.nodes) return void 0;
+			let iterator = this.getIterator();
+			let index, result;
+			while (this.indexes[iterator] < this.proxyOf.nodes.length) {
+				index = this.indexes[iterator];
+				result = callback(this.proxyOf.nodes[index], index);
+				if (result === false) break;
+				this.indexes[iterator] += 1;
+			}
+			delete this.indexes[iterator];
+			return result;
+		}
+		every(condition) {
+			return this.nodes.every(condition);
+		}
+		getIterator() {
+			if (!this.lastEach) this.lastEach = 0;
+			if (!this.indexes) this.indexes = {};
+			this.lastEach += 1;
+			let iterator = this.lastEach;
+			this.indexes[iterator] = 0;
+			return iterator;
+		}
+		getProxyProcessor() {
+			return {
+				get(node, prop) {
+					if (prop === "proxyOf") return node;
+					else if (!node[prop]) return node[prop];
+					else if (prop === "each" || typeof prop === "string" && prop.startsWith("walk")) return (...args) => {
+						return node[prop](...args.map((i) => {
+							if (typeof i === "function") return (child, index) => i(child.toProxy(), index);
+							else return i;
+						}));
+					};
+					else if (prop === "every" || prop === "some") return (cb) => {
+						return node[prop]((child, ...other) => cb(child.toProxy(), ...other));
+					};
+					else if (prop === "root") return () => node.root().toProxy();
+					else if (prop === "nodes") return node.nodes.map((i) => i.toProxy());
+					else if (prop === "first" || prop === "last") return node[prop].toProxy();
+					else return node[prop];
+				},
+				set(node, prop, value) {
+					if (node[prop] === value) return true;
+					node[prop] = value;
+					if (prop === "name" || prop === "params" || prop === "selector") node.markDirty();
+					return true;
+				}
+			};
+		}
+		index(child) {
+			if (typeof child === "number") return child;
+			if (child.proxyOf) child = child.proxyOf;
+			return this.proxyOf.nodes.indexOf(child);
+		}
+		insertAfter(exist, add) {
+			let existIndex = this.index(exist);
+			let nodes = this.normalize(add, this.proxyOf.nodes[existIndex]).reverse();
+			existIndex = this.index(exist);
+			for (let node of nodes) this.proxyOf.nodes.splice(existIndex + 1, 0, node);
+			let index;
+			for (let id in this.indexes) {
+				index = this.indexes[id];
+				if (existIndex < index) this.indexes[id] = index + nodes.length;
+			}
+			this.markDirty();
+			return this;
+		}
+		insertBefore(exist, add) {
+			let existIndex = this.index(exist);
+			let type = existIndex === 0 ? "prepend" : false;
+			let nodes = this.normalize(add, this.proxyOf.nodes[existIndex], type).reverse();
+			existIndex = this.index(exist);
+			for (let node of nodes) this.proxyOf.nodes.splice(existIndex, 0, node);
+			let index;
+			for (let id in this.indexes) {
+				index = this.indexes[id];
+				if (existIndex <= index) this.indexes[id] = index + nodes.length;
+			}
+			this.markDirty();
+			return this;
+		}
+		normalize(nodes, sample) {
+			if (typeof nodes === "string") nodes = cleanSource(parse(nodes).nodes);
+			else if (typeof nodes === "undefined") nodes = [];
+			else if (Array.isArray(nodes)) {
+				nodes = nodes.slice(0);
+				for (let i of nodes) if (i.parent) i.parent.removeChild(i, "ignore");
+			} else if (nodes.type === "root" && this.type !== "document") {
+				nodes = nodes.nodes.slice(0);
+				for (let i of nodes) if (i.parent) i.parent.removeChild(i, "ignore");
+			} else if (nodes.type) nodes = [nodes];
+			else if (nodes.prop) {
+				if (typeof nodes.value === "undefined") throw new Error("Value field is missed in node creation");
+				else if (typeof nodes.value !== "string") nodes.value = String(nodes.value);
+				nodes = [new Declaration(nodes)];
+			} else if (nodes.selector || nodes.selectors) nodes = [new Rule(nodes)];
+			else if (nodes.name) nodes = [new AtRule(nodes)];
+			else if (nodes.text) nodes = [new Comment(nodes)];
+			else throw new Error("Unknown node type in node creation");
+			return nodes.map((i) => {
+				/* c8 ignore next */
+				if (!i[my]) Container.rebuild(i);
+				i = i.proxyOf;
+				if (i.parent) i.parent.removeChild(i);
+				if (i[isClean]) markTreeDirty(i);
+				if (!i.raws) i.raws = {};
+				if (typeof i.raws.before === "undefined") {
+					if (sample && typeof sample.raws.before !== "undefined") i.raws.before = sample.raws.before.replace(/\S/g, "");
+				}
+				i.parent = this.proxyOf;
+				return i;
+			});
+		}
+		prepend(...children) {
+			children = children.reverse();
+			for (let child of children) {
+				let nodes = this.normalize(child, this.first, "prepend").reverse();
+				for (let node of nodes) this.proxyOf.nodes.unshift(node);
+				for (let id in this.indexes) this.indexes[id] = this.indexes[id] + nodes.length;
+			}
+			this.markDirty();
+			return this;
+		}
+		push(child) {
+			child.parent = this;
+			this.proxyOf.nodes.push(child);
+			return this;
+		}
+		removeAll() {
+			for (let node of this.proxyOf.nodes) node.parent = void 0;
+			this.proxyOf.nodes = [];
+			this.markDirty();
+			return this;
+		}
+		removeChild(child) {
+			child = this.index(child);
+			this.proxyOf.nodes[child].parent = void 0;
+			this.proxyOf.nodes.splice(child, 1);
+			let index;
+			for (let id in this.indexes) {
+				index = this.indexes[id];
+				if (index >= child) this.indexes[id] = index - 1;
+			}
+			this.markDirty();
+			return this;
+		}
+		replaceValues(pattern, opts, callback) {
+			if (!callback) {
+				callback = opts;
+				opts = {};
+			}
+			this.walkDecls((decl) => {
+				if (opts.props && !opts.props.includes(decl.prop)) return;
+				if (opts.fast && !decl.value.includes(opts.fast)) return;
+				decl.value = decl.value.replace(pattern, callback);
+			});
+			this.markDirty();
+			return this;
+		}
+		some(condition) {
+			return this.nodes.some(condition);
+		}
+		walk(callback) {
+			if (!this.proxyOf.nodes) return void 0;
+			let stack = [{
+				iterator: this.getIterator(),
+				node: this.proxyOf
+			}];
+			while (stack.length > 0) {
+				let { iterator, node } = stack[stack.length - 1];
+				let index = node.indexes[iterator];
+				if (index >= node.proxyOf.nodes.length) {
+					delete node.indexes[iterator];
+					stack.pop();
+					let parent = stack[stack.length - 1];
+					if (parent) parent.node.indexes[parent.iterator] += 1;
+					continue;
+				}
+				let child = node.proxyOf.nodes[index];
+				let result;
+				try {
+					result = callback(child, index);
+				} catch (e) {
+					throw child.addToError(e);
+				}
+				if (result === false) {
+					for (let opened of stack) delete opened.node.indexes[opened.iterator];
+					return false;
+				}
+				if (child.walk && child.proxyOf.nodes) stack.push({
+					iterator: child.getIterator(),
+					node: child
+				});
+				else node.indexes[iterator] += 1;
+			}
+		}
+		walkAtRules(name, callback) {
+			if (!callback) {
+				callback = name;
+				return this.walk((child, i) => {
+					if (child.type === "atrule") return callback(child, i);
+				});
+			}
+			if (name instanceof RegExp) return this.walk((child, i) => {
+				if (child.type === "atrule" && name.test(child.name)) return callback(child, i);
+			});
+			return this.walk((child, i) => {
+				if (child.type === "atrule" && child.name === name) return callback(child, i);
+			});
+		}
+		walkComments(callback) {
+			return this.walk((child, i) => {
+				if (child.type === "comment") return callback(child, i);
+			});
+		}
+		walkDecls(prop, callback) {
+			if (!callback) {
+				callback = prop;
+				return this.walk((child, i) => {
+					if (child.type === "decl") return callback(child, i);
+				});
+			}
+			if (prop instanceof RegExp) return this.walk((child, i) => {
+				if (child.type === "decl" && prop.test(child.prop)) return callback(child, i);
+			});
+			return this.walk((child, i) => {
+				if (child.type === "decl" && child.prop === prop) return callback(child, i);
+			});
+		}
+		walkRules(selector, callback) {
+			if (!callback) {
+				callback = selector;
+				return this.walk((child, i) => {
+					if (child.type === "rule") return callback(child, i);
+				});
+			}
+			if (selector instanceof RegExp) return this.walk((child, i) => {
+				if (child.type === "rule" && selector.test(child.selector)) return callback(child, i);
+			});
+			return this.walk((child, i) => {
+				if (child.type === "rule" && child.selector === selector) return callback(child, i);
+			});
+		}
+	};
+	Container.registerParse = (dependant) => {
+		parse = dependant;
+	};
+	Container.registerRule = (dependant) => {
+		Rule = dependant;
+	};
+	Container.registerAtRule = (dependant) => {
+		AtRule = dependant;
+	};
+	Container.registerRoot = (dependant) => {
+		Root = dependant;
+	};
+	module.exports = Container;
+	Container.default = Container;
+	/* c8 ignore start */
+	Container.rebuild = (node) => {
+		let stack = [node];
+		while (stack.length > 0) {
+			let next = stack.pop();
+			if (next.type === "atrule") Object.setPrototypeOf(next, AtRule.prototype);
+			else if (next.type === "rule") Object.setPrototypeOf(next, Rule.prototype);
+			else if (next.type === "decl") Object.setPrototypeOf(next, Declaration.prototype);
+			else if (next.type === "comment") Object.setPrototypeOf(next, Comment.prototype);
+			else if (next.type === "root") Object.setPrototypeOf(next, Root.prototype);
+			next[my] = true;
+			if (next.nodes) for (let child of next.nodes) stack.push(child);
+		}
+	};
+}));
+/* c8 ignore stop */
+//#endregion
+//#region ../../node_modules/.bun/postcss@8.5.19/node_modules/postcss/lib/at-rule.js
+var require_at_rule = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var Container = require_container();
+	var AtRule = class extends Container {
+		constructor(defaults) {
+			super(defaults);
+			this.type = "atrule";
+		}
+		append(...children) {
+			if (!this.proxyOf.nodes) this.nodes = [];
+			return super.append(...children);
+		}
+		prepend(...children) {
+			if (!this.proxyOf.nodes) this.nodes = [];
+			return super.prepend(...children);
+		}
+	};
+	module.exports = AtRule;
+	AtRule.default = AtRule;
+	Container.registerAtRule(AtRule);
+}));
+//#endregion
+//#region ../../node_modules/.bun/postcss@8.5.19/node_modules/postcss/lib/document.js
+var require_document = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var Container = require_container();
+	var LazyResult;
+	var Processor;
+	var Document = class extends Container {
+		constructor(defaults) {
+			super({
+				type: "document",
+				...defaults
+			});
+			if (!this.nodes) this.nodes = [];
+		}
+		toResult(opts = {}) {
+			return new LazyResult(new Processor(), this, opts).stringify();
+		}
+	};
+	Document.registerLazyResult = (dependant) => {
+		LazyResult = dependant;
+	};
+	Document.registerProcessor = (dependant) => {
+		Processor = dependant;
+	};
+	module.exports = Document;
+	Document.default = Document;
+}));
+//#endregion
+//#region ../../node_modules/.bun/nanoid@3.3.16/node_modules/nanoid/non-secure/index.cjs
+var require_non_secure = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+	var customAlphabet = (alphabet, defaultSize = 21) => {
+		return (size = defaultSize) => {
+			let id = "";
+			let i = size | 0;
+			while (i-- > 0) id += alphabet[Math.random() * alphabet.length | 0];
+			return id;
+		};
+	};
+	var nanoid = (size = 21) => {
+		let id = "";
+		let i = size | 0;
+		while (i-- > 0) id += urlAlphabet[Math.random() * 64 | 0];
+		return id;
+	};
+	module.exports = {
+		nanoid,
+		customAlphabet
+	};
+}));
+//#endregion
+//#region ../../node_modules/.bun/postcss@8.5.19/node_modules/postcss/lib/previous-map.js
+var require_previous_map = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var { existsSync, readFileSync } = require___vite_browser_external();
+	var { dirname, isAbsolute, join, relative, sep } = require___vite_browser_external();
+	var { SourceMapConsumer, SourceMapGenerator } = require___vite_browser_external();
+	function fromBase64(str) {
+		if (Buffer) return Buffer.from(str, "base64").toString();
+		else
+ /* c8 ignore next 2 */
+		return window.atob(str);
+	}
+	var PreviousMap = class {
+		constructor(css, opts) {
+			if (opts.map === false) return;
+			if (opts.unsafeMap) this.unsafeMap = true;
+			this.loadAnnotation(css);
+			this.inline = this.startWith(this.annotation, "data:");
+			let prev = opts.map ? opts.map.prev : void 0;
+			let text = this.loadMap(opts.from, prev);
+			if (!this.mapFile && opts.from) this.mapFile = opts.from;
+			if (this.mapFile) this.root = dirname(this.mapFile);
+			if (text) this.text = text;
+		}
+		consumer() {
+			if (!this.consumerCache) this.consumerCache = new SourceMapConsumer(this.json || this.text);
+			return this.consumerCache;
+		}
+		decodeInline(text) {
+			let baseCharsetUri = /^data:application\/json;charset=utf-?8;base64,/;
+			let baseUri = /^data:application\/json;base64,/;
+			let uriMatch = text.match(/^data:application\/json;charset=utf-?8,/) || text.match(/^data:application\/json,/);
+			if (uriMatch) return decodeURIComponent(text.substr(uriMatch[0].length));
+			let baseUriMatch = text.match(baseCharsetUri) || text.match(baseUri);
+			if (baseUriMatch) return fromBase64(text.substr(baseUriMatch[0].length));
+			let encoding = text.slice(22);
+			encoding = encoding.slice(0, encoding.indexOf(","));
+			throw new Error("Unsupported source map encoding " + encoding);
+		}
+		getAnnotationURL(sourceMapString) {
+			return sourceMapString.replace(/^\/\*\s*# sourceMappingURL=/, "").trim();
+		}
+		isMap(map) {
+			if (typeof map !== "object") return false;
+			return typeof map.mappings === "string" || typeof map._mappings === "string" || Array.isArray(map.sections);
+		}
+		loadAnnotation(css) {
+			let comments = css.match(/\/\*\s*# sourceMappingURL=/g);
+			if (!comments) return;
+			let start = css.lastIndexOf(comments.pop());
+			let end = css.indexOf("*/", start);
+			if (start > -1 && end > -1) this.annotation = this.getAnnotationURL(css.substring(start, end));
+		}
+		loadFile(path, cssFile, trusted) {
+			if (!trusted && !this.unsafeMap) {
+				if (!/\.map$/i.test(path)) return;
+				if (cssFile) {
+					let relativePath = relative(dirname(cssFile), path);
+					if (relativePath === ".." || relativePath.startsWith(".." + sep) || isAbsolute(relativePath)) return;
+				}
+			}
+			this.root = dirname(path);
+			if (existsSync(path)) {
+				this.mapFile = path;
+				return readFileSync(path, "utf-8").toString().trim();
+			}
+		}
+		loadMap(file, prev) {
+			if (prev === false) return false;
+			if (prev) if (typeof prev === "string") return prev;
+			else if (typeof prev === "function") {
+				let prevPath = prev(file);
+				if (prevPath) {
+					let map = this.loadFile(prevPath, file, true);
+					if (!map) throw new Error("Unable to load previous source map: " + prevPath.toString());
+					return map;
+				}
+			} else if (prev instanceof SourceMapConsumer) return SourceMapGenerator.fromSourceMap(prev).toString();
+			else if (prev instanceof SourceMapGenerator) return prev.toString();
+			else if (this.isMap(prev)) return JSON.stringify(prev);
+			else throw new Error("Unsupported previous source map format: " + prev.toString());
+			else if (this.inline) return this.decodeInline(this.annotation);
+			else if (this.annotation) {
+				let map = this.annotation;
+				if (file) map = join(dirname(file), map);
+				let unknown = this.loadFile(map, file, false);
+				if (unknown) try {
+					/* c8 ignore next 4 */
+					this.json = JSON.parse(unknown.replace(/^\)]}'[^\n]*\n/, ""));
+				} catch {
+					return;
+				}
+				return unknown;
+			}
+		}
+		startWith(string, start) {
+			if (!string) return false;
+			return string.substr(0, start.length) === start;
+		}
+		withContent() {
+			return !!(this.consumer().sourcesContent && this.consumer().sourcesContent.length > 0);
+		}
+	};
+	module.exports = PreviousMap;
+	PreviousMap.default = PreviousMap;
+}));
+//#endregion
+//#region ../../node_modules/.bun/postcss@8.5.19/node_modules/postcss/lib/input.js
+var require_input = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var { nanoid } = require_non_secure();
+	var { isAbsolute, resolve } = require___vite_browser_external();
+	var { SourceMapConsumer, SourceMapGenerator } = require___vite_browser_external();
+	var { fileURLToPath, pathToFileURL } = require___vite_browser_external();
+	var CssSyntaxError = require_css_syntax_error();
+	var PreviousMap = require_previous_map();
+	var terminalHighlight = require___vite_browser_external();
+	var lineToIndexCache = Symbol("lineToIndexCache");
+	var sourceMapAvailable = Boolean(SourceMapConsumer && SourceMapGenerator);
+	var pathAvailable = Boolean(resolve && isAbsolute);
+	function getLineToIndex(input) {
+		if (input[lineToIndexCache]) return input[lineToIndexCache];
+		let lines = input.css.split("\n");
+		let lineToIndex = new Array(lines.length);
+		let prevIndex = 0;
+		for (let i = 0, l = lines.length; i < l; i++) {
+			lineToIndex[i] = prevIndex;
+			prevIndex += lines[i].length + 1;
+		}
+		input[lineToIndexCache] = lineToIndex;
+		return lineToIndex;
+	}
+	var Input = class {
+		get from() {
+			return this.file || this.id;
+		}
+		constructor(css, opts = {}) {
+			if (css === null || typeof css === "undefined" || typeof css === "object" && !css.toString) throw new Error(`PostCSS received ${css} instead of CSS string`);
+			this.css = css.toString();
+			if (this.css[0] === "" || this.css[0] === "￾") {
+				this.hasBOM = true;
+				this.css = this.css.slice(1);
+			} else this.hasBOM = false;
+			this.document = this.css;
+			if (opts.document) this.document = opts.document.toString();
+			if (opts.from) if (!pathAvailable || /^\w+:\/\//.test(opts.from) || isAbsolute(opts.from)) this.file = opts.from;
+			else this.file = resolve(opts.from);
+			if (pathAvailable && sourceMapAvailable) {
+				let map = new PreviousMap(this.css, opts);
+				if (map.text) {
+					this.map = map;
+					let file = map.consumer().file;
+					if (!this.file && file) this.file = this.mapResolve(file);
+				}
+			}
+			if (!this.file) this.id = "<input css " + nanoid(6) + ">";
+			if (this.map) this.map.file = this.from;
+		}
+		error(message, line, column, opts = {}) {
+			let endColumn, endLine, endOffset, offset, result;
+			if (line && typeof line === "object") {
+				let start = line;
+				let end = column;
+				if (typeof start.offset === "number") {
+					offset = start.offset;
+					let pos = this.fromOffset(offset);
+					line = pos.line;
+					column = pos.col;
+				} else {
+					line = start.line;
+					column = start.column;
+					offset = this.fromLineAndColumn(line, column);
+				}
+				if (typeof end.offset === "number") {
+					endOffset = end.offset;
+					let pos = this.fromOffset(endOffset);
+					endLine = pos.line;
+					endColumn = pos.col;
+				} else {
+					endLine = end.line;
+					endColumn = end.column;
+					endOffset = this.fromLineAndColumn(end.line, end.column);
+				}
+			} else if (!column) {
+				offset = line;
+				let pos = this.fromOffset(offset);
+				line = pos.line;
+				column = pos.col;
+			} else offset = this.fromLineAndColumn(line, column);
+			let origin = this.origin(line, column, endLine, endColumn);
+			if (origin) result = new CssSyntaxError(message, origin.endLine === void 0 ? origin.line : {
+				column: origin.column,
+				line: origin.line
+			}, origin.endLine === void 0 ? origin.column : {
+				column: origin.endColumn,
+				line: origin.endLine
+			}, origin.source, origin.file, opts.plugin);
+			else result = new CssSyntaxError(message, endLine === void 0 ? line : {
+				column,
+				line
+			}, endLine === void 0 ? column : {
+				column: endColumn,
+				line: endLine
+			}, this.css, this.file, opts.plugin);
+			result.input = {
+				column,
+				endColumn,
+				endLine,
+				endOffset,
+				line,
+				offset,
+				source: this.css
+			};
+			if (this.file) {
+				if (pathToFileURL) result.input.url = pathToFileURL(this.file).toString();
+				result.input.file = this.file;
+			}
+			return result;
+		}
+		fromLineAndColumn(line, column) {
+			return getLineToIndex(this)[line - 1] + column - 1;
+		}
+		fromOffset(offset) {
+			let lineToIndex = getLineToIndex(this);
+			let lastLine = lineToIndex[lineToIndex.length - 1];
+			let min = 0;
+			if (offset >= lastLine) min = lineToIndex.length - 1;
+			else {
+				let max = lineToIndex.length - 2;
+				let mid;
+				while (min < max) {
+					mid = min + (max - min >> 1);
+					if (offset < lineToIndex[mid]) max = mid - 1;
+					else if (offset >= lineToIndex[mid + 1]) min = mid + 1;
+					else {
+						min = mid;
+						break;
+					}
+				}
+			}
+			return {
+				col: offset - lineToIndex[min] + 1,
+				line: min + 1
+			};
+		}
+		mapResolve(file) {
+			if (/^\w+:\/\//.test(file)) return file;
+			return resolve(this.map.consumer().sourceRoot || this.map.root || ".", file);
+		}
+		origin(line, column, endLine, endColumn) {
+			if (!this.map) return false;
+			let consumer = this.map.consumer();
+			let from = consumer.originalPositionFor({
+				column: column - 1,
+				line
+			});
+			if (!from.source) return false;
+			let to;
+			if (typeof endLine === "number") {
+				let toPosition = consumer.originalPositionFor({
+					column: endColumn - 1,
+					line: endLine
+				});
+				if (toPosition.source) to = toPosition;
+			}
+			let fromUrl;
+			if (isAbsolute(from.source)) fromUrl = pathToFileURL(from.source);
+			else fromUrl = new URL(from.source, this.map.consumer().sourceRoot || pathToFileURL(this.map.mapFile));
+			let result = {
+				column: from.column + 1,
+				endColumn: to && to.column + 1,
+				endLine: to && to.line,
+				line: from.line,
+				url: fromUrl.toString()
+			};
+			if (fromUrl.protocol === "file:") if (fileURLToPath) result.file = fileURLToPath(fromUrl);
+			else
+ /* c8 ignore next 2 */
+			throw new Error(`file: protocol is not available in this PostCSS build`);
+			let source = consumer.sourceContentFor(from.source);
+			if (source) result.source = source;
+			return result;
+		}
+		toJSON() {
+			let json = {};
+			for (let name of [
+				"hasBOM",
+				"css",
+				"file",
+				"id"
+			]) if (this[name] != null) json[name] = this[name];
+			if (this.map) {
+				json.map = { ...this.map };
+				if (json.map.consumerCache) json.map.consumerCache = void 0;
+			}
+			return json;
+		}
+	};
+	module.exports = Input;
+	Input.default = Input;
+	if (terminalHighlight && terminalHighlight.registerInput) terminalHighlight.registerInput(Input);
+}));
+//#endregion
+//#region ../../node_modules/.bun/postcss@8.5.19/node_modules/postcss/lib/root.js
+var require_root = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var Container = require_container();
+	var LazyResult;
+	var Processor;
+	var Root = class extends Container {
+		constructor(defaults) {
+			super(defaults);
+			this.type = "root";
+			if (!this.nodes) this.nodes = [];
+		}
+		normalize(child, sample, type) {
+			let keepBefore = /* @__PURE__ */ new Set();
+			for (let node of Array.isArray(child) ? child : [child]) if (node && typeof node === "object" && !node.parent && node.raws && typeof node.raws.before !== "undefined") keepBefore.add(node.raws);
+			let nodes = super.normalize(child);
+			if (sample) {
+				if (type === "prepend") if (this.nodes.length > 1) sample.raws.before = this.nodes[1].raws.before;
+				else delete sample.raws.before;
+				else if (this.first !== sample) {
+					for (let node of nodes) if (!keepBefore.has(node.raws)) node.raws.before = sample.raws.before;
+				}
+			}
+			return nodes;
+		}
+		removeChild(child, ignore) {
+			let index = this.index(child);
+			if (!ignore && index === 0 && this.nodes.length > 1) this.nodes[1].raws.before = this.nodes[index].raws.before;
+			return super.removeChild(child);
+		}
+		toResult(opts = {}) {
+			return new LazyResult(new Processor(), this, opts).stringify();
+		}
+	};
+	Root.registerLazyResult = (dependant) => {
+		LazyResult = dependant;
+	};
+	Root.registerProcessor = (dependant) => {
+		Processor = dependant;
+	};
+	module.exports = Root;
+	Root.default = Root;
+	Container.registerRoot(Root);
+}));
+//#endregion
+//#region ../../node_modules/.bun/postcss@8.5.19/node_modules/postcss/lib/list.js
+var require_list = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var list = {
+		comma(string) {
+			return list.split(string, [","], true);
+		},
+		space(string) {
+			return list.split(string, [
+				" ",
+				"\n",
+				"	"
+			]);
+		},
+		split(string, separators, last) {
+			let array = [];
+			let current = "";
+			let split = false;
+			let func = 0;
+			let inQuote = false;
+			let prevQuote = "";
+			let escape = false;
+			for (let letter of string) {
+				if (escape) escape = false;
+				else if (letter === "\\") escape = true;
+				else if (inQuote) {
+					if (letter === prevQuote) inQuote = false;
+				} else if (letter === "\"" || letter === "'") {
+					inQuote = true;
+					prevQuote = letter;
+				} else if (letter === "(") func += 1;
+				else if (letter === ")") {
+					if (func > 0) func -= 1;
+				} else if (func === 0) {
+					if (separators.includes(letter)) split = true;
+				}
+				if (split) {
+					if (current !== "") array.push(current.trim());
+					current = "";
+					split = false;
+				} else current += letter;
+			}
+			if (last || current !== "") array.push(current.trim());
+			return array;
+		}
+	};
+	module.exports = list;
+	list.default = list;
+}));
+//#endregion
+//#region ../../node_modules/.bun/postcss@8.5.19/node_modules/postcss/lib/rule.js
+var require_rule = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var Container = require_container();
+	var list = require_list();
+	var Rule = class extends Container {
+		get selectors() {
+			return list.comma(this.selector);
+		}
+		set selectors(values) {
+			let match = this.selector ? this.selector.match(/,\s*/) : null;
+			let sep = match ? match[0] : "," + this.raw("between", "beforeOpen");
+			this.selector = values.join(sep);
+		}
+		constructor(defaults) {
+			super(defaults);
+			this.type = "rule";
+			if (!this.nodes) this.nodes = [];
+		}
+	};
+	module.exports = Rule;
+	Rule.default = Rule;
+	Container.registerRule(Rule);
+}));
+//#endregion
+//#region ../../node_modules/.bun/postcss@8.5.19/node_modules/postcss/lib/fromJSON.js
+var require_fromJSON = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var AtRule = require_at_rule();
+	var Comment = require_comment();
+	var Declaration = require_declaration();
+	var Input = require_input();
+	var PreviousMap = require_previous_map();
+	var Root = require_root();
+	var Rule = require_rule();
+	function hydrateInputs(json, inputs) {
+		if (!json.inputs) return inputs;
+		return json.inputs.map((input) => {
+			let inputHydrated = {
+				...input,
+				__proto__: Input.prototype
+			};
+			if (inputHydrated.map) inputHydrated.map = {
+				...inputHydrated.map,
+				__proto__: PreviousMap.prototype
+			};
+			return inputHydrated;
+		});
+	}
+	function constructNode(json, inputs, children) {
+		let defaults = { ...json };
+		delete defaults.inputs;
+		delete defaults.nodes;
+		if (defaults.source) {
+			let { inputId, ...source } = defaults.source;
+			defaults.source = source;
+			if (inputId != null) defaults.source.input = inputs[inputId];
+		}
+		let node;
+		if (defaults.type === "root") node = new Root(defaults);
+		else if (defaults.type === "decl") node = new Declaration(defaults);
+		else if (defaults.type === "rule") node = new Rule(defaults);
+		else if (defaults.type === "comment") node = new Comment(defaults);
+		else if (defaults.type === "atrule") node = new AtRule(defaults);
+		else throw new Error("Unknown node type: " + json.type);
+		if (children) {
+			node.nodes = children;
+			for (let child of children) child.parent = node;
+		}
+		return node;
+	}
+	function fromJSON(json, inputs) {
+		if (Array.isArray(json)) return json.map((n) => fromJSON(n));
+		let result;
+		let stack = [{
+			childIndex: 0,
+			children: [],
+			inputs: hydrateInputs(json, inputs),
+			json
+		}];
+		while (stack.length > 0) {
+			let frame = stack[stack.length - 1];
+			let jsonNodes = frame.json.nodes;
+			if (jsonNodes && frame.childIndex < jsonNodes.length) {
+				let childJson = jsonNodes[frame.childIndex];
+				frame.childIndex += 1;
+				stack.push({
+					childIndex: 0,
+					children: [],
+					inputs: hydrateInputs(childJson, frame.inputs),
+					json: childJson
+				});
+				continue;
+			}
+			stack.pop();
+			let node = constructNode(frame.json, frame.inputs, jsonNodes ? frame.children : void 0);
+			if (stack.length > 0) stack[stack.length - 1].children.push(node);
+			else result = node;
+		}
+		return result;
+	}
+	module.exports = fromJSON;
+	fromJSON.default = fromJSON;
+}));
+//#endregion
+//#region ../../node_modules/.bun/postcss@8.5.19/node_modules/postcss/lib/map-generator.js
+var require_map_generator = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var { dirname, relative, resolve, sep } = require___vite_browser_external();
+	var { SourceMapConsumer, SourceMapGenerator } = require___vite_browser_external();
+	var { pathToFileURL } = require___vite_browser_external();
+	var Input = require_input();
+	var sourceMapAvailable = Boolean(SourceMapConsumer && SourceMapGenerator);
+	var pathAvailable = Boolean(dirname && resolve && relative && sep);
+	var MapGenerator = class {
+		constructor(stringify, root, opts, cssString) {
+			this.stringify = stringify;
+			this.mapOpts = opts.map || {};
+			this.root = root;
+			this.opts = opts;
+			this.css = cssString;
+			this.originalCSS = cssString;
+			this.usesFileUrls = !this.mapOpts.from && this.mapOpts.absolute;
+			this.memoizedFileURLs = /* @__PURE__ */ new Map();
+			this.memoizedPaths = /* @__PURE__ */ new Map();
+			this.memoizedURLs = /* @__PURE__ */ new Map();
+		}
+		addAnnotation() {
+			let content;
+			if (this.isInline()) content = "data:application/json;base64," + this.toBase64(this.map.toString());
+			else if (typeof this.mapOpts.annotation === "string") content = this.mapOpts.annotation;
+			else if (typeof this.mapOpts.annotation === "function") content = this.mapOpts.annotation(this.opts.to, this.root);
+			else content = this.outputFile() + ".map";
+			let eol = "\n";
+			if (this.css.includes("\r\n")) eol = "\r\n";
+			this.css += eol + "/*# sourceMappingURL=" + content + " */";
+		}
+		applyPrevMaps() {
+			for (let prev of this.previous()) {
+				let from = this.toUrl(this.path(prev.file));
+				let root = prev.root || dirname(prev.file);
+				let map;
+				if (this.mapOpts.sourcesContent === false) {
+					map = new SourceMapConsumer(prev.text);
+					if (map.sourcesContent) map.sourcesContent = null;
+				} else map = prev.consumer();
+				this.map.applySourceMap(map, from, this.toUrl(this.path(root)));
+			}
+		}
+		clearAnnotation() {
+			if (this.mapOpts.annotation === false) return;
+			if (this.root) {
+				let node;
+				for (let i = this.root.nodes.length - 1; i >= 0; i--) {
+					node = this.root.nodes[i];
+					if (node.type !== "comment") continue;
+					if (node.text.startsWith("# sourceMappingURL=")) this.root.removeChild(i);
+				}
+			} else if (this.css) {
+				let startIndex;
+				while ((startIndex = this.css.lastIndexOf("/*#")) !== -1) {
+					let endIndex = this.css.indexOf("*/", startIndex + 3);
+					if (endIndex === -1) break;
+					while (startIndex > 0 && this.css[startIndex - 1] === "\n") startIndex--;
+					this.css = this.css.slice(0, startIndex) + this.css.slice(endIndex + 2);
+				}
+			}
+		}
+		generate() {
+			this.clearAnnotation();
+			if (pathAvailable && sourceMapAvailable && this.isMap()) return this.generateMap();
+			else {
+				let result = "";
+				this.stringify(this.root, (i) => {
+					result += i;
+				});
+				return [result];
+			}
+		}
+		generateMap() {
+			if (this.root) this.generateString();
+			else if (this.previous().length === 1) {
+				let prev = this.previous()[0].consumer();
+				prev.file = this.outputFile();
+				this.map = SourceMapGenerator.fromSourceMap(prev, { ignoreInvalidMapping: true });
+			} else {
+				this.map = new SourceMapGenerator({
+					file: this.outputFile(),
+					ignoreInvalidMapping: true
+				});
+				this.map.addMapping({
+					generated: {
+						column: 0,
+						line: 1
+					},
+					original: {
+						column: 0,
+						line: 1
+					},
+					source: this.opts.from ? this.toUrl(this.path(this.opts.from)) : "<no source>"
+				});
+			}
+			if (this.isSourcesContent()) this.setSourcesContent();
+			if (this.root && this.previous().length > 0) this.applyPrevMaps();
+			if (this.isAnnotation()) this.addAnnotation();
+			if (this.isInline()) return [this.css];
+			else return [this.css, this.map];
+		}
+		generateString() {
+			this.css = "";
+			this.map = new SourceMapGenerator({
+				file: this.outputFile(),
+				ignoreInvalidMapping: true
+			});
+			let line = 1;
+			let column = 1;
+			let noSource = "<no source>";
+			let mapping = {
+				generated: {
+					column: 0,
+					line: 0
+				},
+				original: {
+					column: 0,
+					line: 0
+				},
+				source: ""
+			};
+			let last, lines;
+			this.stringify(this.root, (str, node, type) => {
+				this.css += str;
+				if (node && type !== "end") {
+					mapping.generated.line = line;
+					mapping.generated.column = column - 1;
+					if (node.source && node.source.start) {
+						mapping.source = this.sourcePath(node);
+						mapping.original.line = node.source.start.line;
+						mapping.original.column = node.source.start.column - 1;
+						this.map.addMapping(mapping);
+					} else {
+						mapping.source = noSource;
+						mapping.original.line = 1;
+						mapping.original.column = 0;
+						this.map.addMapping(mapping);
+					}
+				}
+				lines = str.match(/\n/g);
+				if (lines) {
+					line += lines.length;
+					last = str.lastIndexOf("\n");
+					column = str.length - last;
+				} else column += str.length;
+				if (node && type !== "start") {
+					let p = node.parent || { raws: {} };
+					if (!(node.type === "decl" || node.type === "atrule" && !node.nodes) || node !== p.last || p.raws.semicolon) if (node.source && node.source.end) {
+						mapping.source = this.sourcePath(node);
+						mapping.original.line = node.source.end.line;
+						mapping.original.column = node.source.end.column - 1;
+						mapping.generated.line = line;
+						mapping.generated.column = column - 2;
+						this.map.addMapping(mapping);
+					} else {
+						mapping.source = noSource;
+						mapping.original.line = 1;
+						mapping.original.column = 0;
+						mapping.generated.line = line;
+						mapping.generated.column = column - 1;
+						this.map.addMapping(mapping);
+					}
+				}
+			});
+		}
+		isAnnotation() {
+			if (this.isInline()) return true;
+			if (typeof this.mapOpts.annotation !== "undefined") return this.mapOpts.annotation;
+			if (this.previous().length) return this.previous().some((i) => i.annotation);
+			return true;
+		}
+		isInline() {
+			if (typeof this.mapOpts.inline !== "undefined") return this.mapOpts.inline;
+			let annotation = this.mapOpts.annotation;
+			if (typeof annotation !== "undefined" && annotation !== true) return false;
+			if (this.previous().length) return this.previous().some((i) => i.inline);
+			return true;
+		}
+		isMap() {
+			if (typeof this.opts.map !== "undefined") return !!this.opts.map;
+			return this.previous().length > 0;
+		}
+		isSourcesContent() {
+			if (typeof this.mapOpts.sourcesContent !== "undefined") return this.mapOpts.sourcesContent;
+			if (this.previous().length) return this.previous().some((i) => i.withContent());
+			return true;
+		}
+		outputFile() {
+			if (this.opts.to) return this.path(this.opts.to);
+			else if (this.opts.from) return this.path(this.opts.from);
+			else return "to.css";
+		}
+		path(file) {
+			if (this.mapOpts.absolute) return file;
+			if (file.charCodeAt(0) === 60) return file;
+			if (/^\w+:\/\//.test(file)) return file;
+			let cached = this.memoizedPaths.get(file);
+			if (cached) return cached;
+			let from = this.opts.to ? dirname(this.opts.to) : ".";
+			if (typeof this.mapOpts.annotation === "string") from = dirname(resolve(from, this.mapOpts.annotation));
+			let path = relative(from, file);
+			this.memoizedPaths.set(file, path);
+			return path;
+		}
+		previous() {
+			if (!this.previousMaps) {
+				this.previousMaps = [];
+				if (this.root) this.root.walk((node) => {
+					if (node.source && node.source.input.map) {
+						let map = node.source.input.map;
+						if (!this.previousMaps.includes(map)) this.previousMaps.push(map);
+					}
+				});
+				else {
+					let input = new Input(this.originalCSS, this.opts);
+					if (input.map) this.previousMaps.push(input.map);
+				}
+			}
+			return this.previousMaps;
+		}
+		setSourcesContent() {
+			let already = {};
+			if (this.root) this.root.walk((node) => {
+				if (node.source) {
+					let from = node.source.input.from;
+					if (from && !already[from]) {
+						already[from] = true;
+						let fromUrl = this.usesFileUrls ? this.toFileUrl(from) : this.toUrl(this.path(from));
+						this.map.setSourceContent(fromUrl, node.source.input.css);
+					}
+				}
+			});
+			else if (this.css) {
+				let from = this.opts.from ? this.toUrl(this.path(this.opts.from)) : "<no source>";
+				this.map.setSourceContent(from, this.css);
+			}
+		}
+		sourcePath(node) {
+			if (this.mapOpts.from) return this.toUrl(this.mapOpts.from);
+			else if (this.usesFileUrls) return this.toFileUrl(node.source.input.from);
+			else return this.toUrl(this.path(node.source.input.from));
+		}
+		toBase64(str) {
+			if (Buffer) return Buffer.from(str).toString("base64");
+			else return window.btoa(unescape(encodeURIComponent(str)));
+		}
+		toFileUrl(path) {
+			let cached = this.memoizedFileURLs.get(path);
+			if (cached) return cached;
+			if (pathToFileURL) {
+				let fileURL = pathToFileURL(path).toString();
+				this.memoizedFileURLs.set(path, fileURL);
+				return fileURL;
+			} else throw new Error("`map.absolute` option is not available in this PostCSS build");
+		}
+		toUrl(path) {
+			let cached = this.memoizedURLs.get(path);
+			if (cached) return cached;
+			if (sep === "\\") path = path.replace(/\\/g, "/");
+			let url = encodeURI(path).replace(/[#?]/g, encodeURIComponent);
+			this.memoizedURLs.set(path, url);
+			return url;
+		}
+	};
+	module.exports = MapGenerator;
+}));
+//#endregion
+//#region ../../node_modules/.bun/postcss@8.5.19/node_modules/postcss/lib/tokenize.js
+var require_tokenize = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var SINGLE_QUOTE = "'".charCodeAt(0);
+	var DOUBLE_QUOTE = "\"".charCodeAt(0);
+	var BACKSLASH = "\\".charCodeAt(0);
+	var SLASH = "/".charCodeAt(0);
+	var NEWLINE = "\n".charCodeAt(0);
+	var SPACE = " ".charCodeAt(0);
+	var FEED = "\f".charCodeAt(0);
+	var TAB = "	".charCodeAt(0);
+	var CR = "\r".charCodeAt(0);
+	var OPEN_SQUARE = "[".charCodeAt(0);
+	var CLOSE_SQUARE = "]".charCodeAt(0);
+	var OPEN_PARENTHESES = "(".charCodeAt(0);
+	var CLOSE_PARENTHESES = ")".charCodeAt(0);
+	var OPEN_CURLY = "{".charCodeAt(0);
+	var CLOSE_CURLY = "}".charCodeAt(0);
+	var SEMICOLON = ";".charCodeAt(0);
+	var ASTERISK = "*".charCodeAt(0);
+	var COLON = ":".charCodeAt(0);
+	var AT = "@".charCodeAt(0);
+	var RE_AT_END = /[\t\n\f\r "#'()/;[\\\]{}]/g;
+	var RE_WORD_END = /[\t\n\f\r !"#'():;@[\\\]{}]|\/(?=\*)/g;
+	var RE_BAD_BRACKET = /.[\r\n"'(/\\]/;
+	var RE_HEX_ESCAPE = /[\da-f]/i;
+	module.exports = function tokenizer(input, options = {}) {
+		let css = input.css.valueOf();
+		let ignore = options.ignoreErrors;
+		let code, content, escape, next, quote;
+		let currentToken, escaped, escapePos, n, prev;
+		let length = css.length;
+		let pos = 0;
+		let buffer = [];
+		let returned = [];
+		let lastBadParen = -1;
+		function position() {
+			return pos;
+		}
+		function unclosed(what) {
+			throw input.error("Unclosed " + what, pos);
+		}
+		function endOfFile() {
+			return returned.length === 0 && pos >= length;
+		}
+		function nextToken(opts) {
+			if (returned.length) return returned.pop();
+			if (pos >= length) return;
+			let ignoreUnclosed = opts ? opts.ignoreUnclosed : false;
+			code = css.charCodeAt(pos);
+			switch (code) {
+				case NEWLINE:
+				case SPACE:
+				case TAB:
+				case CR:
+				case FEED:
+					next = pos;
+					do {
+						next += 1;
+						code = css.charCodeAt(next);
+					} while (code === SPACE || code === NEWLINE || code === TAB || code === CR || code === FEED);
+					currentToken = ["space", css.slice(pos, next)];
+					pos = next - 1;
+					break;
+				case OPEN_SQUARE:
+				case CLOSE_SQUARE:
+				case OPEN_CURLY:
+				case CLOSE_CURLY:
+				case COLON:
+				case SEMICOLON:
+				case CLOSE_PARENTHESES: {
+					let controlChar = String.fromCharCode(code);
+					currentToken = [
+						controlChar,
+						controlChar,
+						pos
+					];
+					break;
+				}
+				case OPEN_PARENTHESES:
+					prev = buffer.length ? buffer.pop()[1] : "";
+					n = css.charCodeAt(pos + 1);
+					if (prev === "url" && n !== SINGLE_QUOTE && n !== DOUBLE_QUOTE && n !== SPACE && n !== NEWLINE && n !== TAB && n !== FEED && n !== CR) {
+						next = pos;
+						do {
+							escaped = false;
+							next = css.indexOf(")", next + 1);
+							if (next === -1) if (ignore || ignoreUnclosed) {
+								next = pos;
+								break;
+							} else unclosed("bracket");
+							escapePos = next;
+							while (css.charCodeAt(escapePos - 1) === BACKSLASH) {
+								escapePos -= 1;
+								escaped = !escaped;
+							}
+						} while (escaped);
+						currentToken = [
+							"brackets",
+							css.slice(pos, next + 1),
+							pos,
+							next
+						];
+						pos = next;
+					} else if (pos <= lastBadParen) currentToken = [
+						"(",
+						"(",
+						pos
+					];
+					else {
+						next = css.indexOf(")", pos + 1);
+						content = css.slice(pos, next + 1);
+						if (next === -1 || RE_BAD_BRACKET.test(content)) {
+							lastBadParen = next === -1 ? length : next;
+							currentToken = [
+								"(",
+								"(",
+								pos
+							];
+						} else {
+							currentToken = [
+								"brackets",
+								content,
+								pos,
+								next
+							];
+							pos = next;
+						}
+					}
+					break;
+				case SINGLE_QUOTE:
+				case DOUBLE_QUOTE:
+					quote = code === SINGLE_QUOTE ? "'" : "\"";
+					next = pos;
+					do {
+						escaped = false;
+						next = css.indexOf(quote, next + 1);
+						if (next === -1) if (ignore || ignoreUnclosed) {
+							next = pos + 1;
+							break;
+						} else unclosed("string");
+						escapePos = next;
+						while (css.charCodeAt(escapePos - 1) === BACKSLASH) {
+							escapePos -= 1;
+							escaped = !escaped;
+						}
+					} while (escaped);
+					currentToken = [
+						"string",
+						css.slice(pos, next + 1),
+						pos,
+						next
+					];
+					pos = next;
+					break;
+				case AT:
+					RE_AT_END.lastIndex = pos + 1;
+					RE_AT_END.test(css);
+					if (RE_AT_END.lastIndex === 0) next = css.length - 1;
+					else next = RE_AT_END.lastIndex - 2;
+					currentToken = [
+						"at-word",
+						css.slice(pos, next + 1),
+						pos,
+						next
+					];
+					pos = next;
+					break;
+				case BACKSLASH:
+					next = pos;
+					escape = true;
+					while (css.charCodeAt(next + 1) === BACKSLASH) {
+						next += 1;
+						escape = !escape;
+					}
+					code = css.charCodeAt(next + 1);
+					if (escape && code !== SLASH && code !== SPACE && code !== NEWLINE && code !== TAB && code !== CR && code !== FEED) {
+						next += 1;
+						if (RE_HEX_ESCAPE.test(css.charAt(next))) {
+							while (RE_HEX_ESCAPE.test(css.charAt(next + 1))) next += 1;
+							if (css.charCodeAt(next + 1) === SPACE) next += 1;
+						}
+					}
+					currentToken = [
+						"word",
+						css.slice(pos, next + 1),
+						pos,
+						next
+					];
+					pos = next;
+					break;
+				default:
+					if (code === SLASH && css.charCodeAt(pos + 1) === ASTERISK) {
+						next = css.indexOf("*/", pos + 2) + 1;
+						if (next === 0) if (ignore || ignoreUnclosed) next = css.length;
+						else unclosed("comment");
+						currentToken = [
+							"comment",
+							css.slice(pos, next + 1),
+							pos,
+							next
+						];
+						pos = next;
+					} else {
+						RE_WORD_END.lastIndex = pos + 1;
+						RE_WORD_END.test(css);
+						if (RE_WORD_END.lastIndex === 0) next = css.length - 1;
+						else next = RE_WORD_END.lastIndex - 2;
+						currentToken = [
+							"word",
+							css.slice(pos, next + 1),
+							pos,
+							next
+						];
+						buffer.push(currentToken);
+						pos = next;
+					}
+					break;
+			}
+			pos++;
+			return currentToken;
+		}
+		function back(token) {
+			returned.push(token);
+		}
+		return {
+			back,
+			endOfFile,
+			nextToken,
+			position
+		};
+	};
+}));
+//#endregion
+//#region ../../node_modules/.bun/postcss@8.5.19/node_modules/postcss/lib/parser.js
+var require_parser = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var AtRule = require_at_rule();
+	var Comment = require_comment();
+	var Declaration = require_declaration();
+	var Root = require_root();
+	var Rule = require_rule();
+	var tokenizer = require_tokenize();
+	var SAFE_COMMENT_NEIGHBOR = {
+		empty: true,
+		space: true
+	};
+	function findLastWithPosition(tokens) {
+		for (let i = tokens.length - 1; i >= 0; i--) {
+			let token = tokens[i];
+			let pos = token[3] || token[2];
+			if (pos) return pos;
+		}
+	}
+	function tokensToString(tokens, from, to) {
+		let result = "";
+		for (let i = from; i < to; i++) result += tokens[i][1];
+		return result;
+	}
+	var Parser = class {
+		constructor(input) {
+			this.input = input;
+			this.root = new Root();
+			this.current = this.root;
+			this.spaces = "";
+			this.semicolon = false;
+			this.createTokenizer();
+			this.root.source = {
+				input,
+				start: {
+					column: 1,
+					line: 1,
+					offset: 0
+				}
+			};
+		}
+		atrule(token) {
+			let node = new AtRule();
+			node.name = token[1].slice(1);
+			if (node.name === "") this.unnamedAtrule(node, token);
+			this.init(node, token[2]);
+			let type;
+			let prev;
+			let shift;
+			let last = false;
+			let open = false;
+			let params = [];
+			let brackets = [];
+			while (!this.tokenizer.endOfFile()) {
+				token = this.tokenizer.nextToken();
+				type = token[0];
+				if (type === "(" || type === "[") brackets.push(type === "(" ? ")" : "]");
+				else if (type === "{" && brackets.length > 0) brackets.push("}");
+				else if (type === brackets[brackets.length - 1]) brackets.pop();
+				if (brackets.length === 0) if (type === ";") {
+					node.source.end = this.getPosition(token[2]);
+					node.source.end.offset++;
+					this.semicolon = true;
+					break;
+				} else if (type === "{") {
+					open = true;
+					break;
+				} else if (type === "}") {
+					if (params.length > 0) {
+						shift = params.length - 1;
+						prev = params[shift];
+						while (prev && prev[0] === "space") prev = params[--shift];
+						if (prev) {
+							node.source.end = this.getPosition(prev[3] || prev[2]);
+							node.source.end.offset++;
+						}
+					}
+					this.end(token);
+					break;
+				} else params.push(token);
+				else params.push(token);
+				if (this.tokenizer.endOfFile()) {
+					last = true;
+					break;
+				}
+			}
+			node.raws.between = this.spacesAndCommentsFromEnd(params);
+			if (params.length) {
+				node.raws.afterName = this.spacesAndCommentsFromStart(params);
+				this.raw(node, "params", params);
+				if (last) {
+					token = params[params.length - 1];
+					node.source.end = this.getPosition(token[3] || token[2]);
+					node.source.end.offset++;
+					this.spaces = node.raws.between;
+					node.raws.between = "";
+				}
+			} else {
+				node.raws.afterName = "";
+				node.params = "";
+			}
+			if (open) {
+				node.nodes = [];
+				this.current = node;
+			}
+		}
+		checkMissedSemicolon(tokens) {
+			let colon = this.colon(tokens);
+			if (colon === false) return;
+			let founded = 0;
+			let token;
+			for (let j = colon - 1; j >= 0; j--) {
+				token = tokens[j];
+				if (token[0] !== "space") {
+					founded += 1;
+					if (founded === 2) break;
+				}
+			}
+			throw this.input.error("Missed semicolon", token[0] === "word" ? token[3] + 1 : token[2]);
+		}
+		colon(tokens) {
+			let brackets = 0;
+			let prev, token, type;
+			for (let [i, element] of tokens.entries()) {
+				token = element;
+				type = token[0];
+				if (type === "(") brackets += 1;
+				if (type === ")") brackets -= 1;
+				if (brackets === 0 && type === ":") if (!prev) this.doubleColon(token);
+				else if (prev[0] === "word" && prev[1] === "progid") continue;
+				else return i;
+				prev = token;
+			}
+			return false;
+		}
+		comment(token) {
+			let node = new Comment();
+			this.init(node, token[2]);
+			node.source.end = this.getPosition(token[3] || token[2]);
+			node.source.end.offset++;
+			let text = token[1].slice(2, -2);
+			if (!text.trim()) {
+				node.text = "";
+				node.raws.left = text;
+				node.raws.right = "";
+			} else {
+				let match = text.match(/^(\s*)([^]*\S)(\s*)$/);
+				node.text = match[2];
+				node.raws.left = match[1];
+				node.raws.right = match[3];
+			}
+		}
+		createTokenizer() {
+			this.tokenizer = tokenizer(this.input);
+		}
+		decl(tokens, customProperty) {
+			let node = new Declaration();
+			this.init(node, tokens[0][2]);
+			let last = tokens[tokens.length - 1];
+			if (last[0] === ";") {
+				this.semicolon = true;
+				tokens.pop();
+			}
+			node.source.end = this.getPosition(last[3] || last[2] || findLastWithPosition(tokens));
+			node.source.end.offset++;
+			let start = 0;
+			while (tokens[start][0] !== "word") {
+				if (start === tokens.length - 1) this.unknownWord([tokens[start]]);
+				start++;
+			}
+			node.raws.before += tokensToString(tokens, 0, start);
+			node.source.start = this.getPosition(tokens[start][2]);
+			let propStart = start;
+			while (start < tokens.length) {
+				let type = tokens[start][0];
+				if (type === ":" || type === "space" || type === "comment") break;
+				start++;
+			}
+			node.prop = tokensToString(tokens, propStart, start);
+			let betweenStart = start;
+			let token;
+			while (start < tokens.length) {
+				token = tokens[start];
+				start++;
+				if (token[0] === ":") break;
+				if (token[0] === "word" && /\w/.test(token[1])) this.unknownWord([token]);
+			}
+			node.raws.between = tokensToString(tokens, betweenStart, start);
+			if (node.prop[0] === "_" || node.prop[0] === "*") {
+				node.raws.before += node.prop[0];
+				node.prop = node.prop.slice(1);
+			}
+			let firstSpacesStart = start;
+			while (start < tokens.length) {
+				let next = tokens[start][0];
+				if (next !== "space" && next !== "comment") break;
+				start++;
+			}
+			let firstSpaces = tokens.slice(firstSpacesStart, start);
+			tokens = tokens.slice(start);
+			this.precheckMissedSemicolon(tokens);
+			for (let i = tokens.length - 1; i >= 0; i--) {
+				token = tokens[i];
+				if (token[1].toLowerCase() === "!important") {
+					node.important = true;
+					let string = this.stringFrom(tokens, i);
+					string = this.spacesFromEnd(tokens) + string;
+					if (string !== " !important") node.raws.important = string;
+					break;
+				} else if (token[1].toLowerCase() === "important") {
+					let cache = tokens.slice(0);
+					let str = "";
+					for (let j = i; j > 0; j--) {
+						let type = cache[j][0];
+						if (str.trim().startsWith("!") && type !== "space") break;
+						str = cache.pop()[1] + str;
+					}
+					if (str.trim().startsWith("!")) {
+						node.important = true;
+						node.raws.important = str;
+						tokens = cache;
+					}
+				}
+				if (token[0] !== "space" && token[0] !== "comment") break;
+			}
+			if (tokens.some((i) => i[0] !== "space" && i[0] !== "comment")) {
+				node.raws.between += firstSpaces.map((i) => i[1]).join("");
+				firstSpaces = [];
+			}
+			this.raw(node, "value", firstSpaces.concat(tokens), customProperty);
+			if (node.value.includes(":") && !customProperty) this.checkMissedSemicolon(tokens);
+		}
+		doubleColon(token) {
+			throw this.input.error("Double colon", { offset: token[2] }, { offset: token[2] + token[1].length });
+		}
+		emptyRule(token) {
+			let node = new Rule();
+			this.init(node, token[2]);
+			node.selector = "";
+			node.raws.between = "";
+			this.current = node;
+		}
+		end(token) {
+			if (this.current.nodes && this.current.nodes.length) this.current.raws.semicolon = this.semicolon;
+			this.semicolon = false;
+			this.current.raws.after = (this.current.raws.after || "") + this.spaces;
+			this.spaces = "";
+			if (this.current.parent) {
+				this.current.source.end = this.getPosition(token[2]);
+				this.current.source.end.offset++;
+				this.current = this.current.parent;
+			} else this.unexpectedClose(token);
+		}
+		endFile() {
+			if (this.current.parent) this.unclosedBlock();
+			if (this.current.nodes && this.current.nodes.length) this.current.raws.semicolon = this.semicolon;
+			this.current.raws.after = (this.current.raws.after || "") + this.spaces;
+			this.root.source.end = this.getPosition(this.tokenizer.position());
+		}
+		freeSemicolon(token) {
+			this.spaces += token[1];
+			if (this.current.nodes) {
+				let prev = this.current.nodes[this.current.nodes.length - 1];
+				if (prev && prev.type === "rule" && !prev.raws.ownSemicolon) {
+					prev.raws.ownSemicolon = this.spaces;
+					this.spaces = "";
+					prev.source.end = this.getPosition(token[2]);
+					prev.source.end.offset += prev.raws.ownSemicolon.length;
+				}
+			}
+		}
+		getPosition(offset) {
+			let pos = this.input.fromOffset(offset);
+			return {
+				column: pos.col,
+				line: pos.line,
+				offset
+			};
+		}
+		init(node, offset) {
+			this.current.push(node);
+			node.source = {
+				input: this.input,
+				start: this.getPosition(offset)
+			};
+			node.raws.before = this.spaces;
+			this.spaces = "";
+			if (node.type !== "comment") this.semicolon = false;
+		}
+		other(start) {
+			let end = false;
+			let type = null;
+			let colon = false;
+			let bracket = null;
+			let brackets = [];
+			let customProperty = start[1].startsWith("--");
+			let tokens = [];
+			let token = start;
+			while (token) {
+				type = token[0];
+				tokens.push(token);
+				if (type === "(" || type === "[") {
+					if (!bracket) bracket = token;
+					brackets.push(type === "(" ? ")" : "]");
+				} else if (customProperty && colon && type === "{") {
+					if (!bracket) bracket = token;
+					brackets.push("}");
+				} else if (brackets.length === 0) {
+					if (type === ";") if (colon) {
+						this.decl(tokens, customProperty);
+						return;
+					} else break;
+					else if (type === "{") {
+						this.rule(tokens);
+						return;
+					} else if (type === "}") {
+						this.tokenizer.back(tokens.pop());
+						end = true;
+						break;
+					} else if (type === ":") colon = true;
+				} else if (type === brackets[brackets.length - 1]) {
+					brackets.pop();
+					if (brackets.length === 0) bracket = null;
+				}
+				token = this.tokenizer.nextToken();
+			}
+			if (this.tokenizer.endOfFile()) end = true;
+			if (brackets.length > 0) this.unclosedBracket(bracket);
+			if (end && colon) {
+				if (!customProperty) while (tokens.length) {
+					token = tokens[tokens.length - 1][0];
+					if (token !== "space" && token !== "comment") break;
+					this.tokenizer.back(tokens.pop());
+				}
+				this.decl(tokens, customProperty);
+			} else this.unknownWord(tokens);
+		}
+		parse() {
+			let token;
+			while (!this.tokenizer.endOfFile()) {
+				token = this.tokenizer.nextToken();
+				switch (token[0]) {
+					case "space":
+						this.spaces += token[1];
+						break;
+					case ";":
+						this.freeSemicolon(token);
+						break;
+					case "}":
+						this.end(token);
+						break;
+					case "comment":
+						this.comment(token);
+						break;
+					case "at-word":
+						this.atrule(token);
+						break;
+					case "{":
+						this.emptyRule(token);
+						break;
+					default:
+						this.other(token);
+						break;
+				}
+			}
+			this.endFile();
+		}
+		precheckMissedSemicolon() {}
+		raw(node, prop, tokens, customProperty) {
+			let token, type;
+			let length = tokens.length;
+			let value = "";
+			let clean = true;
+			let next, prev;
+			for (let i = 0; i < length; i += 1) {
+				token = tokens[i];
+				type = token[0];
+				if (type === "space" && i === length - 1 && !customProperty) clean = false;
+				else if (type === "comment") {
+					prev = tokens[i - 1] ? tokens[i - 1][0] : "empty";
+					next = tokens[i + 1] ? tokens[i + 1][0] : "empty";
+					if (!SAFE_COMMENT_NEIGHBOR[prev] && !SAFE_COMMENT_NEIGHBOR[next]) if (value.slice(-1) === ",") clean = false;
+					else value += token[1];
+					else clean = false;
+				} else value += token[1];
+			}
+			if (!clean) {
+				let raw = tokens.reduce((all, i) => all + i[1], "");
+				node.raws[prop] = {
+					raw,
+					value
+				};
+			}
+			node[prop] = value;
+		}
+		rule(tokens) {
+			tokens.pop();
+			let node = new Rule();
+			this.init(node, tokens[0][2]);
+			node.raws.between = this.spacesAndCommentsFromEnd(tokens);
+			this.raw(node, "selector", tokens);
+			this.current = node;
+		}
+		spacesAndCommentsFromEnd(tokens) {
+			let lastTokenType;
+			let spaces = "";
+			while (tokens.length) {
+				lastTokenType = tokens[tokens.length - 1][0];
+				if (lastTokenType !== "space" && lastTokenType !== "comment") break;
+				spaces = tokens.pop()[1] + spaces;
+			}
+			return spaces;
+		}
+		spacesAndCommentsFromStart(tokens) {
+			let next;
+			let spaces = "";
+			while (tokens.length) {
+				next = tokens[0][0];
+				if (next !== "space" && next !== "comment") break;
+				spaces += tokens.shift()[1];
+			}
+			return spaces;
+		}
+		spacesFromEnd(tokens) {
+			let lastTokenType;
+			let spaces = "";
+			while (tokens.length) {
+				lastTokenType = tokens[tokens.length - 1][0];
+				if (lastTokenType !== "space") break;
+				spaces = tokens.pop()[1] + spaces;
+			}
+			return spaces;
+		}
+		stringFrom(tokens, from) {
+			let result = "";
+			for (let i = from; i < tokens.length; i++) result += tokens[i][1];
+			tokens.splice(from, tokens.length - from);
+			return result;
+		}
+		unclosedBlock() {
+			let pos = this.current.source.start;
+			throw this.input.error("Unclosed block", pos.line, pos.column);
+		}
+		unclosedBracket(bracket) {
+			throw this.input.error("Unclosed bracket", { offset: bracket[2] }, { offset: bracket[2] + 1 });
+		}
+		unexpectedClose(token) {
+			throw this.input.error("Unexpected }", { offset: token[2] }, { offset: token[2] + 1 });
+		}
+		unknownWord(tokens) {
+			throw this.input.error("Unknown word " + tokens[0][1], { offset: tokens[0][2] }, { offset: tokens[0][2] + tokens[0][1].length });
+		}
+		unnamedAtrule(node, token) {
+			throw this.input.error("At-rule without name", { offset: token[2] }, { offset: token[2] + token[1].length });
+		}
+	};
+	module.exports = Parser;
+}));
+//#endregion
+//#region ../../node_modules/.bun/postcss@8.5.19/node_modules/postcss/lib/parse.js
+var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var Container = require_container();
+	var Input = require_input();
+	var Parser = require_parser();
+	function parse(css, opts) {
+		let parser = new Parser(new Input(css, opts));
+		try {
+			parser.parse();
+		} catch (e) {
+			if (process.env.NODE_ENV !== "production") {
+				if (e.name === "CssSyntaxError" && opts && opts.from) {
+					if (/\.scss$/i.test(opts.from)) e.message += "\nYou tried to parse SCSS with the standard CSS parser; try again with the postcss-scss parser";
+					else if (/\.sass/i.test(opts.from)) e.message += "\nYou tried to parse Sass with the standard CSS parser; try again with the postcss-sass parser";
+					else if (/\.less$/i.test(opts.from)) e.message += "\nYou tried to parse Less with the standard CSS parser; try again with the postcss-less parser";
+				}
+			}
+			throw e;
+		}
+		return parser.root;
+	}
+	module.exports = parse;
+	parse.default = parse;
+	Container.registerParse(parse);
+}));
+//#endregion
+//#region ../../node_modules/.bun/postcss@8.5.19/node_modules/postcss/lib/warning.js
+var require_warning = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var Warning = class {
+		constructor(text, opts = {}) {
+			this.type = "warning";
+			this.text = text;
+			if (opts.node && opts.node.source) {
+				let range = opts.node.rangeBy(opts);
+				this.line = range.start.line;
+				this.column = range.start.column;
+				this.endLine = range.end.line;
+				this.endColumn = range.end.column;
+			}
+			for (let opt in opts) this[opt] = opts[opt];
+		}
+		toString() {
+			if (this.node) return this.node.error(this.text, {
+				index: this.index,
+				plugin: this.plugin,
+				word: this.word
+			}).message;
+			if (this.plugin) return this.plugin + ": " + this.text;
+			return this.text;
+		}
+	};
+	module.exports = Warning;
+	Warning.default = Warning;
+}));
+//#endregion
+//#region ../../node_modules/.bun/postcss@8.5.19/node_modules/postcss/lib/result.js
+var require_result = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var Warning = require_warning();
+	var Result = class {
+		get content() {
+			return this.css;
+		}
+		constructor(processor, root, opts) {
+			this.processor = processor;
+			this.messages = [];
+			this.root = root;
+			this.opts = opts;
+			this.css = "";
+			this.map = void 0;
+		}
+		toString() {
+			return this.css;
+		}
+		warn(text, opts = {}) {
+			if (!opts.plugin) {
+				if (this.lastPlugin && this.lastPlugin.postcssPlugin) opts.plugin = this.lastPlugin.postcssPlugin;
+			}
+			let warning = new Warning(text, opts);
+			this.messages.push(warning);
+			return warning;
+		}
+		warnings() {
+			return this.messages.filter((i) => i.type === "warning");
+		}
+	};
+	module.exports = Result;
+	Result.default = Result;
+}));
+//#endregion
+//#region ../../node_modules/.bun/postcss@8.5.19/node_modules/postcss/lib/warn-once.js
+var require_warn_once = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var printed = {};
+	module.exports = function warnOnce(message) {
+		if (printed[message]) return;
+		printed[message] = true;
+		if (typeof console !== "undefined" && console.warn) console.warn(message);
+	};
+}));
+//#endregion
+//#region ../../node_modules/.bun/postcss@8.5.19/node_modules/postcss/lib/lazy-result.js
+var require_lazy_result = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var Container = require_container();
+	var Document = require_document();
+	var MapGenerator = require_map_generator();
+	var parse = require_parse();
+	var Result = require_result();
+	var Root = require_root();
+	var stringify = require_stringify();
+	var { isClean, my } = require_symbols();
+	var warnOnce = require_warn_once();
+	var TYPE_TO_CLASS_NAME = {
+		atrule: "AtRule",
+		comment: "Comment",
+		decl: "Declaration",
+		document: "Document",
+		root: "Root",
+		rule: "Rule"
+	};
+	var PLUGIN_PROPS = {
+		AtRule: true,
+		AtRuleExit: true,
+		Comment: true,
+		CommentExit: true,
+		Declaration: true,
+		DeclarationExit: true,
+		Document: true,
+		DocumentExit: true,
+		Once: true,
+		OnceExit: true,
+		postcssPlugin: true,
+		prepare: true,
+		Root: true,
+		RootExit: true,
+		Rule: true,
+		RuleExit: true
+	};
+	var NOT_VISITORS = {
+		Once: true,
+		postcssPlugin: true,
+		prepare: true
+	};
+	var CHILDREN = 0;
+	function isPromise(obj) {
+		return typeof obj === "object" && typeof obj.then === "function";
+	}
+	function getEvents(node) {
+		let key = false;
+		let type = TYPE_TO_CLASS_NAME[node.type];
+		if (node.type === "decl") key = node.prop.toLowerCase();
+		else if (node.type === "atrule") key = node.name.toLowerCase();
+		if (key && node.append) return [
+			type,
+			type + "-" + key,
+			CHILDREN,
+			type + "Exit",
+			type + "Exit-" + key
+		];
+		else if (key) return [
+			type,
+			type + "-" + key,
+			type + "Exit",
+			type + "Exit-" + key
+		];
+		else if (node.append) return [
+			type,
+			CHILDREN,
+			type + "Exit"
+		];
+		else return [type, type + "Exit"];
+	}
+	function toStack(node) {
+		let events;
+		if (node.type === "document") events = [
+			"Document",
+			CHILDREN,
+			"DocumentExit"
+		];
+		else if (node.type === "root") events = [
+			"Root",
+			CHILDREN,
+			"RootExit"
+		];
+		else events = getEvents(node);
+		return {
+			eventIndex: 0,
+			events,
+			iterator: 0,
+			node,
+			visitorIndex: 0,
+			visitors: []
+		};
+	}
+	function cleanMarks(node) {
+		let stack = [node];
+		while (stack.length > 0) {
+			let next = stack.pop();
+			next[isClean] = false;
+			if (next.nodes) for (let i of next.nodes) stack.push(i);
+		}
+		return node;
+	}
+	var postcss = {};
+	var LazyResult = class LazyResult {
+		get content() {
+			return this.stringify().content;
+		}
+		get css() {
+			return this.stringify().css;
+		}
+		get map() {
+			return this.stringify().map;
+		}
+		get messages() {
+			return this.sync().messages;
+		}
+		get opts() {
+			return this.result.opts;
+		}
+		get processor() {
+			return this.result.processor;
+		}
+		get root() {
+			return this.sync().root;
+		}
+		get [Symbol.toStringTag]() {
+			return "LazyResult";
+		}
+		constructor(processor, css, opts) {
+			this.stringified = false;
+			this.processed = false;
+			let root;
+			if (typeof css === "object" && css !== null && (css.type === "root" || css.type === "document")) root = cleanMarks(css);
+			else if (css instanceof LazyResult || css instanceof Result) {
+				root = cleanMarks(css.root);
+				if (css.map) {
+					if (typeof opts.map === "undefined") opts.map = {};
+					if (!opts.map.inline) opts.map.inline = false;
+					opts.map.prev = css.map;
+				}
+			} else {
+				let parser = parse;
+				if (opts.syntax) parser = opts.syntax.parse;
+				if (opts.parser) parser = opts.parser;
+				if (parser.parse) parser = parser.parse;
+				try {
+					root = parser(css, opts);
+				} catch (error) {
+					this.processed = true;
+					this.error = error;
+				}
+				if (root && !root[my])
+ /* c8 ignore next 2 */
+				Container.rebuild(root);
+			}
+			this.result = new Result(processor, root, opts);
+			this.helpers = {
+				...postcss,
+				postcss,
+				result: this.result
+			};
+			this.plugins = this.processor.plugins.map((plugin) => {
+				if (typeof plugin === "object" && plugin.prepare) return {
+					...plugin,
+					...plugin.prepare(this.result)
+				};
+				else return plugin;
+			});
+		}
+		async() {
+			if (this.error) return Promise.reject(this.error);
+			if (this.processed) return Promise.resolve(this.result);
+			if (!this.processing) this.processing = this.runAsync();
+			return this.processing;
+		}
+		catch(onRejected) {
+			return this.async().catch(onRejected);
+		}
+		finally(onFinally) {
+			return this.async().then(onFinally, onFinally);
+		}
+		getAsyncError() {
+			throw new Error("Use process(css).then(cb) to work with async plugins");
+		}
+		handleError(error, node) {
+			let plugin = this.result.lastPlugin;
+			try {
+				if (node) node.addToError(error);
+				this.error = error;
+				if (error.name === "CssSyntaxError" && !error.plugin) {
+					error.plugin = plugin.postcssPlugin;
+					error.setMessage();
+				} else if (plugin.postcssVersion) {
+					if (process.env.NODE_ENV !== "production") {
+						let pluginName = plugin.postcssPlugin;
+						let pluginVer = plugin.postcssVersion;
+						let runtimeVer = this.result.processor.version;
+						let a = pluginVer.split(".");
+						let b = runtimeVer.split(".");
+						if (a[0] !== b[0] || parseInt(a[1]) > parseInt(b[1])) console.error("Unknown error from PostCSS plugin. Your current PostCSS version is " + runtimeVer + ", but " + pluginName + " uses " + pluginVer + ". Perhaps this is the source of the error below.");
+					}
+				}
+			} catch (err) {
+				/* c8 ignore next 3 */
+				if (console && console.error) console.error(err);
+			}
+			return error;
+		}
+		prepareVisitors() {
+			this.listeners = {};
+			let add = (plugin, type, cb) => {
+				if (!this.listeners[type]) this.listeners[type] = [];
+				this.listeners[type].push([plugin, cb]);
+			};
+			for (let plugin of this.plugins) if (typeof plugin === "object") for (let event in plugin) {
+				if (!PLUGIN_PROPS[event] && /^[A-Z]/.test(event)) throw new Error(`Unknown event ${event} in ${plugin.postcssPlugin}. Try to update PostCSS (${this.processor.version} now).`);
+				if (!NOT_VISITORS[event]) {
+					if (typeof plugin[event] === "object") for (let filter in plugin[event]) if (filter === "*") add(plugin, event, plugin[event][filter]);
+					else add(plugin, event + "-" + filter.toLowerCase(), plugin[event][filter]);
+					else if (typeof plugin[event] === "function") add(plugin, event, plugin[event]);
+				}
+			}
+			this.hasListener = Object.keys(this.listeners).length > 0;
+		}
+		async runAsync() {
+			this.plugin = 0;
+			for (let i = 0; i < this.plugins.length; i++) {
+				let plugin = this.plugins[i];
+				let promise = this.runOnRoot(plugin);
+				if (isPromise(promise)) try {
+					await promise;
+				} catch (error) {
+					throw this.handleError(error);
+				}
+			}
+			this.prepareVisitors();
+			if (this.hasListener) {
+				let root = this.result.root;
+				while (!root[isClean]) {
+					root[isClean] = true;
+					let stack = [toStack(root)];
+					while (stack.length > 0) {
+						let promise = this.visitTick(stack);
+						if (isPromise(promise)) try {
+							await promise;
+						} catch (e) {
+							let node = stack[stack.length - 1].node;
+							throw this.handleError(e, node);
+						}
+					}
+				}
+				if (this.listeners.OnceExit) for (let [plugin, visitor] of this.listeners.OnceExit) {
+					this.result.lastPlugin = plugin;
+					try {
+						if (root.type === "document") {
+							let roots = root.nodes.map((subRoot) => visitor(subRoot, this.helpers));
+							await Promise.all(roots);
+						} else await visitor(root, this.helpers);
+					} catch (e) {
+						throw this.handleError(e);
+					}
+				}
+			}
+			this.processed = true;
+			return this.stringify();
+		}
+		runOnRoot(plugin) {
+			this.result.lastPlugin = plugin;
+			try {
+				if (typeof plugin === "object" && plugin.Once) {
+					if (this.result.root.type === "document") {
+						let roots = this.result.root.nodes.map((root) => plugin.Once(root, this.helpers));
+						if (isPromise(roots[0])) return Promise.all(roots);
+						return roots;
+					}
+					return plugin.Once(this.result.root, this.helpers);
+				} else if (typeof plugin === "function") return plugin(this.result.root, this.result);
+			} catch (error) {
+				throw this.handleError(error);
+			}
+		}
+		stringify() {
+			if (this.error) throw this.error;
+			if (this.stringified) return this.result;
+			this.stringified = true;
+			this.sync();
+			let opts = this.result.opts;
+			let str = stringify;
+			if (opts.syntax) str = opts.syntax.stringify;
+			if (opts.stringifier) str = opts.stringifier;
+			if (str.stringify) str = str.stringify;
+			let rootSource = this.result.root.source;
+			if (opts.map === void 0 && !(rootSource && rootSource.input && rootSource.input.map)) {
+				let result = "";
+				str(this.result.root, (i) => {
+					result += i;
+				});
+				this.result.css = result;
+				return this.result;
+			}
+			let data = new MapGenerator(str, this.result.root, this.result.opts).generate();
+			this.result.css = data[0];
+			this.result.map = data[1];
+			return this.result;
+		}
+		sync() {
+			if (this.error) throw this.error;
+			if (this.processed) return this.result;
+			this.processed = true;
+			if (this.processing) throw this.getAsyncError();
+			for (let plugin of this.plugins) if (isPromise(this.runOnRoot(plugin))) throw this.getAsyncError();
+			this.prepareVisitors();
+			if (this.hasListener) {
+				let root = this.result.root;
+				while (!root[isClean]) {
+					root[isClean] = true;
+					this.walkSync(root);
+				}
+				if (this.listeners.OnceExit) if (root.type === "document") for (let subRoot of root.nodes) this.visitSync(this.listeners.OnceExit, subRoot);
+				else this.visitSync(this.listeners.OnceExit, root);
+			}
+			return this.result;
+		}
+		then(onFulfilled, onRejected) {
+			if (process.env.NODE_ENV !== "production") {
+				if (!("from" in this.opts)) warnOnce("Without `from` option PostCSS could generate wrong source map and will not find Browserslist config. Set it to CSS file path or to `undefined` to prevent this warning.");
+			}
+			return this.async().then(onFulfilled, onRejected);
+		}
+		toString() {
+			return this.css;
+		}
+		visitSync(visitors, node) {
+			for (let [plugin, visitor] of visitors) {
+				this.result.lastPlugin = plugin;
+				let promise;
+				try {
+					promise = visitor(node, this.helpers);
+				} catch (e) {
+					throw this.handleError(e, node.proxyOf);
+				}
+				if (node.type !== "root" && node.type !== "document" && !node.parent) return true;
+				if (isPromise(promise)) throw this.getAsyncError();
+			}
+		}
+		visitTick(stack) {
+			let visit = stack[stack.length - 1];
+			let { node, visitors } = visit;
+			if (node.type !== "root" && node.type !== "document" && !node.parent) {
+				stack.pop();
+				return;
+			}
+			if (visitors.length > 0 && visit.visitorIndex < visitors.length) {
+				let [plugin, visitor] = visitors[visit.visitorIndex];
+				visit.visitorIndex += 1;
+				if (visit.visitorIndex === visitors.length) {
+					visit.visitors = [];
+					visit.visitorIndex = 0;
+				}
+				this.result.lastPlugin = plugin;
+				try {
+					return visitor(node.toProxy(), this.helpers);
+				} catch (e) {
+					throw this.handleError(e, node);
+				}
+			}
+			if (visit.iterator !== 0) {
+				let iterator = visit.iterator;
+				let child;
+				while (child = node.nodes[node.indexes[iterator]]) {
+					node.indexes[iterator] += 1;
+					if (!child[isClean]) {
+						child[isClean] = true;
+						stack.push(toStack(child));
+						return;
+					}
+				}
+				visit.iterator = 0;
+				delete node.indexes[iterator];
+			}
+			let events = visit.events;
+			while (visit.eventIndex < events.length) {
+				let event = events[visit.eventIndex];
+				visit.eventIndex += 1;
+				if (event === CHILDREN) {
+					if (node.nodes && node.nodes.length) {
+						node[isClean] = true;
+						visit.iterator = node.getIterator();
+					}
+					return;
+				} else if (this.listeners[event]) {
+					visit.visitors = this.listeners[event];
+					return;
+				}
+			}
+			stack.pop();
+		}
+		walkSync(node) {
+			node[isClean] = true;
+			let stack = [{
+				eventIndex: 0,
+				events: getEvents(node),
+				iterator: 0,
+				node
+			}];
+			while (stack.length > 0) {
+				let visit = stack[stack.length - 1];
+				let visitNode = visit.node;
+				if (visit.iterator !== 0) {
+					let iterator = visit.iterator;
+					let child;
+					let descended = false;
+					while (child = visitNode.nodes[visitNode.indexes[iterator]]) {
+						visitNode.indexes[iterator] += 1;
+						if (!child[isClean]) {
+							child[isClean] = true;
+							stack.push({
+								eventIndex: 0,
+								events: getEvents(child),
+								iterator: 0,
+								node: child
+							});
+							descended = true;
+							break;
+						}
+					}
+					if (descended) continue;
+					visit.iterator = 0;
+					delete visitNode.indexes[iterator];
+				}
+				if (visit.eventIndex < visit.events.length) {
+					let event = visit.events[visit.eventIndex];
+					visit.eventIndex += 1;
+					if (event === CHILDREN) {
+						if (visitNode.nodes && visitNode.nodes.length) visit.iterator = visitNode.getIterator();
+					} else {
+						let visitors = this.listeners[event];
+						if (visitors) {
+							if (this.visitSync(visitors, visitNode.toProxy())) stack.pop();
+						}
+					}
+					continue;
+				}
+				stack.pop();
+			}
+		}
+		warnings() {
+			return this.sync().warnings();
+		}
+	};
+	LazyResult.registerPostcss = (dependant) => {
+		postcss = dependant;
+	};
+	module.exports = LazyResult;
+	LazyResult.default = LazyResult;
+	Root.registerLazyResult(LazyResult);
+	Document.registerLazyResult(LazyResult);
+}));
+//#endregion
+//#region ../../node_modules/.bun/postcss@8.5.19/node_modules/postcss/lib/no-work-result.js
+var require_no_work_result = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var MapGenerator = require_map_generator();
+	var parse = require_parse();
+	var Result = require_result();
+	var stringify = require_stringify();
+	var warnOnce = require_warn_once();
+	var NoWorkResult = class {
+		get content() {
+			return this.result.css;
+		}
+		get css() {
+			return this.result.css;
+		}
+		get map() {
+			return this.result.map;
+		}
+		get messages() {
+			return [];
+		}
+		get opts() {
+			return this.result.opts;
+		}
+		get processor() {
+			return this.result.processor;
+		}
+		get root() {
+			if (this._root) return this._root;
+			let root;
+			let parser = parse;
+			try {
+				root = parser(this._css, this._opts);
+			} catch (error) {
+				this.error = error;
+			}
+			if (this.error) throw this.error;
+			else {
+				this._root = root;
+				return root;
+			}
+		}
+		get [Symbol.toStringTag]() {
+			return "NoWorkResult";
+		}
+		constructor(processor, css, opts) {
+			css = css.toString();
+			this.stringified = false;
+			this._processor = processor;
+			this._css = css;
+			this._opts = opts;
+			this._map = void 0;
+			let str = stringify;
+			this.result = new Result(this._processor, void 0, this._opts);
+			this.result.css = css;
+			let self = this;
+			Object.defineProperty(this.result, "root", { get() {
+				return self.root;
+			} });
+			let map = new MapGenerator(str, void 0, this._opts, css);
+			if (map.isMap()) {
+				let [generatedCSS, generatedMap] = map.generate();
+				if (generatedCSS) this.result.css = generatedCSS;
+				if (generatedMap) this.result.map = generatedMap;
+			} else {
+				map.clearAnnotation();
+				this.result.css = map.css;
+			}
+		}
+		async() {
+			if (this.error) return Promise.reject(this.error);
+			return Promise.resolve(this.result);
+		}
+		catch(onRejected) {
+			return this.async().catch(onRejected);
+		}
+		finally(onFinally) {
+			return this.async().then(onFinally, onFinally);
+		}
+		sync() {
+			if (this.error) throw this.error;
+			return this.result;
+		}
+		then(onFulfilled, onRejected) {
+			if (process.env.NODE_ENV !== "production") {
+				if (!("from" in this._opts)) warnOnce("Without `from` option PostCSS could generate wrong source map and will not find Browserslist config. Set it to CSS file path or to `undefined` to prevent this warning.");
+			}
+			return this.async().then(onFulfilled, onRejected);
+		}
+		toString() {
+			return this._css;
+		}
+		warnings() {
+			return [];
+		}
+	};
+	module.exports = NoWorkResult;
+	NoWorkResult.default = NoWorkResult;
+}));
+//#endregion
+//#region ../../node_modules/.bun/postcss@8.5.19/node_modules/postcss/lib/processor.js
+var require_processor = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var Document = require_document();
+	var LazyResult = require_lazy_result();
+	var NoWorkResult = require_no_work_result();
+	var Root = require_root();
+	var Processor = class {
+		constructor(plugins = []) {
+			this.version = "8.5.19";
+			this.plugins = this.normalize(plugins);
+		}
+		normalize(plugins) {
+			let normalized = [];
+			for (let i of plugins) {
+				if (i.postcss === true) i = i();
+				else if (i.postcss) i = i.postcss;
+				if (typeof i === "object" && Array.isArray(i.plugins)) normalized = normalized.concat(i.plugins);
+				else if (typeof i === "object" && i.postcssPlugin) normalized.push(i);
+				else if (typeof i === "function") normalized.push(i);
+				else if (typeof i === "object" && (i.parse || i.stringify)) {
+					if (process.env.NODE_ENV !== "production") throw new Error("PostCSS syntaxes cannot be used as plugins. Instead, please use one of the syntax/parser/stringifier options as outlined in your PostCSS runner documentation.");
+				} else throw new Error(i + " is not a PostCSS plugin");
+			}
+			return normalized;
+		}
+		process(css, opts = {}) {
+			if (!this.plugins.length && !opts.parser && !opts.stringifier && !opts.syntax) return new NoWorkResult(this, css, opts);
+			else return new LazyResult(this, css, opts);
+		}
+		use(plugin) {
+			this.plugins = this.plugins.concat(this.normalize([plugin]));
+			return this;
+		}
+	};
+	module.exports = Processor;
+	Processor.default = Processor;
+	Root.registerProcessor(Processor);
+	Document.registerProcessor(Processor);
+}));
+//#endregion
+//#region ../../node_modules/.bun/postcss@8.5.19/node_modules/postcss/lib/postcss.mjs
+var import_postcss = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var AtRule = require_at_rule();
+	var Comment = require_comment();
+	var Container = require_container();
+	var CssSyntaxError = require_css_syntax_error();
+	var Declaration = require_declaration();
+	var Document = require_document();
+	var fromJSON = require_fromJSON();
+	var Input = require_input();
+	var LazyResult = require_lazy_result();
+	var list = require_list();
+	var Node = require_node();
+	var parse = require_parse();
+	var Processor = require_processor();
+	var Result = require_result();
+	var Root = require_root();
+	var Rule = require_rule();
+	var stringify = require_stringify();
+	var Warning = require_warning();
+	function postcss(...plugins) {
+		if (plugins.length === 1 && Array.isArray(plugins[0])) plugins = plugins[0];
+		return new Processor(plugins);
+	}
+	postcss.plugin = function plugin(name, initializer) {
+		let warningPrinted = false;
+		function creator(...args) {
+			if (console && console.warn && !warningPrinted) {
+				warningPrinted = true;
+				console.warn(name + ": postcss.plugin was deprecated. Migration guide:\nhttps://evilmartians.com/chronicles/postcss-8-plugin-migration");
+				if (process.env.LANG && process.env.LANG.startsWith("cn"))
+ /* c8 ignore next 7 */
+				console.warn(name + ": 里面 postcss.plugin 被弃用. 迁移指南:\nhttps://www.w3ctech.com/topic/2226");
+			}
+			let transformer = initializer(...args);
+			transformer.postcssPlugin = name;
+			transformer.postcssVersion = new Processor().version;
+			return transformer;
+		}
+		let cache;
+		Object.defineProperty(creator, "postcss", { get() {
+			if (!cache) cache = creator();
+			return cache;
+		} });
+		creator.process = function(css, processOpts, pluginOpts) {
+			return postcss([creator(pluginOpts)]).process(css, processOpts);
+		};
+		return creator;
+	};
+	postcss.stringify = stringify;
+	postcss.parse = parse;
+	postcss.fromJSON = fromJSON;
+	postcss.list = list;
+	postcss.comment = (defaults) => new Comment(defaults);
+	postcss.atRule = (defaults) => new AtRule(defaults);
+	postcss.decl = (defaults) => new Declaration(defaults);
+	postcss.rule = (defaults) => new Rule(defaults);
+	postcss.root = (defaults) => new Root(defaults);
+	postcss.document = (defaults) => new Document(defaults);
+	postcss.CssSyntaxError = CssSyntaxError;
+	postcss.Declaration = Declaration;
+	postcss.Container = Container;
+	postcss.Processor = Processor;
+	postcss.Document = Document;
+	postcss.Comment = Comment;
+	postcss.Warning = Warning;
+	postcss.AtRule = AtRule;
+	postcss.Result = Result;
+	postcss.Input = Input;
+	postcss.Rule = Rule;
+	postcss.Root = Root;
+	postcss.Node = Node;
+	LazyResult.registerPostcss(postcss);
+	module.exports = postcss;
+	postcss.default = postcss;
+})))(), 1);
+var postcss_default = import_postcss.default;
+var stringify = import_postcss.default.stringify;
+var fromJSON = import_postcss.default.fromJSON;
+var plugin = import_postcss.default.plugin;
+var parse = import_postcss.default.parse;
+var list = import_postcss.default.list;
+var document = import_postcss.default.document;
+var comment = import_postcss.default.comment;
+var atRule = import_postcss.default.atRule;
+var rule = import_postcss.default.rule;
+var decl = import_postcss.default.decl;
+var root = import_postcss.default.root;
+var CssSyntaxError = import_postcss.default.CssSyntaxError;
+var Declaration = import_postcss.default.Declaration;
+var Container = import_postcss.default.Container;
+var Processor = import_postcss.default.Processor;
+var Document = import_postcss.default.Document;
+var Comment = import_postcss.default.Comment;
+var Warning = import_postcss.default.Warning;
+var AtRule = import_postcss.default.AtRule;
+var Result = import_postcss.default.Result;
+var Input = import_postcss.default.Input;
+var Rule = import_postcss.default.Rule;
+var Root = import_postcss.default.Root;
+var Node = import_postcss.default.Node;
+//#endregion
+export { AtRule, Comment, Container, CssSyntaxError, Declaration, Document, Input, Node, Processor, Result, Root, Rule, Warning, atRule, comment, decl, postcss_default as default, document, fromJSON, list, parse, plugin, root, rule, stringify };