ipx 3.1.1 → 4.0.0-alpha.2

package/dist/_chunks/libs/csso.mjs

@@ -0,0 +1,1834 @@
+import { __commonJSMin as e } from "../rolldown-runtime.mjs";
+import { require_cjs as t } from "./css-tree.mjs";
+var n = e(((e, t) => {
+	t.exports = {
+		name: `csso`,
+		version: `5.0.5`,
+		description: `CSS minifier with structural optimisations`,
+		author: `Sergey Kryzhanovsky <skryzhanovsky@ya.ru> (https://github.com/afelix)`,
+		maintainers: [{
+			name: `Roman Dvornov`,
+			email: `rdvornov@gmail.com`,
+			"github-username": `lahmatiy`
+		}],
+		repository: `css/csso`,
+		license: `MIT`,
+		keywords: [
+			`css`,
+			`compress`,
+			`minifier`,
+			`minify`,
+			`optimise`,
+			`optimisation`,
+			`csstree`
+		],
+		type: `module`,
+		unpkg: `dist/csso.esm.js`,
+		jsdelivr: `dist/csso.esm.js`,
+		browser: {
+			"./cjs/version.cjs": `./dist/version.cjs`,
+			"./lib/version.js": `./dist/version.js`
+		},
+		main: `./cjs/index.cjs`,
+		module: `./lib/index.js`,
+		exports: {
+			".": {
+				import: `./lib/index.js`,
+				require: `./cjs/index.cjs`
+			},
+			"./syntax": {
+				import: `./lib/syntax.js`,
+				require: `./cjs/syntax.cjs`
+			},
+			"./dist/*": `./dist/*.js`,
+			"./package.json": `./package.json`
+		},
+		scripts: {
+			test: "mocha test --reporter ${REPORTER:-progress}",
+			"test:cjs": "mocha cjs-test --reporter ${REPORTER:-progress}",
+			"test:dist": "mocha dist/test --reporter ${REPORTER:-progress}",
+			lint: `eslint lib scripts test`,
+			"lint-and-test": `npm run lint && npm test`,
+			build: `npm run bundle && npm run esm-to-cjs`,
+			"build-and-test": `npm run build && npm run test:dist && npm run test:cjs`,
+			bundle: `node scripts/bundle`,
+			"bundle-and-test": `npm run bundle && npm run test:dist`,
+			"esm-to-cjs": `node scripts/esm-to-cjs.cjs`,
+			"esm-to-cjs-and-test": `npm run esm-to-cjs && npm run test:cjs`,
+			coverage: `c8 --reporter=lcovonly npm test`,
+			prepublishOnly: `npm run lint-and-test && npm run build-and-test`,
+			hydrogen: `node --trace-hydrogen --trace-phase=Z --trace-deopt --code-comments --hydrogen-track-positions --redirect-code-traces --redirect-code-traces-to=code.asm --trace_hydrogen_file=code.cfg --print-opt-code bin/csso --stat -o /dev/null`
+		},
+		dependencies: { "css-tree": `~2.2.0` },
+		devDependencies: {
+			c8: `^7.10.0`,
+			esbuild: `^0.14.54`,
+			eslint: `^7.24.0`,
+			mocha: `^9.2.2`,
+			rollup: `^2.60.2`,
+			"source-map-js": `^1.0.1`
+		},
+		engines: {
+			node: `^10 || ^12.20.0 || ^14.13.0 || >=15.0.0`,
+			npm: `>=7.0.0`
+		},
+		files: [
+			`dist`,
+			`!dist/test`,
+			`cjs`,
+			`lib`
+		]
+	};
+})), r = e(((e) => {
+	let { version: t } = n();
+	e.version = t;
+})), i = e(((e) => {
+	let { hasOwnProperty: t } = Object.prototype;
+	function n(e, t) {
+		let n = Object.create(null);
+		if (!Array.isArray(e)) return null;
+		for (let r of e) t && (r = r.toLowerCase()), n[r] = !0;
+		return n;
+	}
+	function r(e) {
+		if (!e) return null;
+		let t = n(e.tags, !0), r = n(e.ids), i = n(e.classes);
+		return t === null && r === null && i === null ? null : {
+			tags: t,
+			ids: r,
+			classes: i
+		};
+	}
+	function i(e) {
+		let n = !1;
+		if (e.scopes && Array.isArray(e.scopes)) {
+			n = Object.create(null);
+			for (let r = 0; r < e.scopes.length; r++) {
+				let i = e.scopes[r];
+				if (!i || !Array.isArray(i)) throw Error(`Wrong usage format`);
+				for (let e of i) {
+					if (t.call(n, e)) throw Error(`Class can't be used for several scopes: ${e}`);
+					n[e] = r + 1;
+				}
+			}
+		}
+		return {
+			whitelist: r(e),
+			blacklist: r(e.blacklist),
+			scopes: n
+		};
+	}
+	e.buildIndex = i;
+})), a = e(((e) => {
+	function t(e) {
+		return !e || !e.children || e.children.isEmpty;
+	}
+	function n(e, t) {
+		return e !== null && e.children === t;
+	}
+	e.hasNoChildren = t, e.isNodeChildrenList = n;
+})), o = e(((e, n) => {
+	let r = t(), i = a();
+	function o(e, t, n) {
+		if (e.block && (this.stylesheet !== null && (this.stylesheet.firstAtrulesAllowed = !1), i.hasNoChildren(e.block))) {
+			n.remove(t);
+			return;
+		}
+		switch (e.name) {
+			case `charset`:
+				if (i.hasNoChildren(e.prelude)) {
+					n.remove(t);
+					return;
+				}
+				if (t.prev) {
+					n.remove(t);
+					return;
+				}
+				break;
+			case `import`:
+				if (this.stylesheet === null || !this.stylesheet.firstAtrulesAllowed) {
+					n.remove(t);
+					return;
+				}
+				n.prevUntil(t.prev, function(e) {
+					if (!(e.type === `Atrule` && (e.name === `import` || e.name === `charset`))) return this.root.firstAtrulesAllowed = !1, n.remove(t), !0;
+				}, this);
+				break;
+			default: {
+				let a = r.keyword(e.name).basename;
+				(a === `keyframes` || a === `media` || a === `supports`) && (i.hasNoChildren(e.prelude) || i.hasNoChildren(e.block)) && n.remove(t);
+			}
+		}
+	}
+	n.exports = o;
+})), s = e(((e, t) => {
+	function n(e, t, n) {
+		n.remove(t);
+	}
+	t.exports = n;
+})), c = e(((e, n) => {
+	let r = t();
+	function i(e, t, n) {
+		if (e.value.children && e.value.children.isEmpty) {
+			n.remove(t);
+			return;
+		}
+		r.property(e.property).custom && /\S/.test(e.value.value) && (e.value.value = e.value.value.trim());
+	}
+	n.exports = i;
+})), l = e(((e, t) => {
+	let n = a();
+	function r(e, t, r) {
+		(n.isNodeChildrenList(this.stylesheet, r) || n.isNodeChildrenList(this.block, r)) && r.remove(t);
+	}
+	t.exports = r;
+})), u = e(((e, n) => {
+	let r = t(), i = a(), { hasOwnProperty: o } = Object.prototype, s = /* @__PURE__ */ new Set([`keyframes`]);
+	function c(e, t) {
+		return e.children.forEach((n, i, a) => {
+			let s = !1;
+			r.walk(n, function(n) {
+				if (this.selector === null || this.selector === e) switch (n.type) {
+					case `SelectorList`:
+						(this.function === null || this.function.name.toLowerCase() !== `not`) && c(n, t) && (s = !0);
+						break;
+					case `ClassSelector`:
+						t.whitelist !== null && t.whitelist.classes !== null && !o.call(t.whitelist.classes, n.name) && (s = !0), t.blacklist !== null && t.blacklist.classes !== null && o.call(t.blacklist.classes, n.name) && (s = !0);
+						break;
+					case `IdSelector`:
+						t.whitelist !== null && t.whitelist.ids !== null && !o.call(t.whitelist.ids, n.name) && (s = !0), t.blacklist !== null && t.blacklist.ids !== null && o.call(t.blacklist.ids, n.name) && (s = !0);
+						break;
+					case `TypeSelector`:
+						n.name.charAt(n.name.length - 1) !== `*` && (t.whitelist !== null && t.whitelist.tags !== null && !o.call(t.whitelist.tags, n.name.toLowerCase()) && (s = !0), t.blacklist !== null && t.blacklist.tags !== null && o.call(t.blacklist.tags, n.name.toLowerCase()) && (s = !0));
+						break;
+				}
+			}), s && a.remove(i);
+		}), e.children.isEmpty;
+	}
+	function l(e, t, n, a) {
+		if (i.hasNoChildren(e.prelude) || i.hasNoChildren(e.block)) {
+			n.remove(t);
+			return;
+		}
+		if (this.atrule && s.has(r.keyword(this.atrule.name).basename)) return;
+		let { usage: o } = a;
+		if (o && (o.whitelist !== null || o.blacklist !== null) && (c(e.prelude, o), i.hasNoChildren(e.prelude))) {
+			n.remove(t);
+			return;
+		}
+	}
+	n.exports = l;
+})), d = e(((e, t) => {
+	function n(e, t, n) {
+		if (t.data.name !== `*`) return;
+		let r = t.next && t.next.data.type;
+		(r === `IdSelector` || r === `ClassSelector` || r === `AttributeSelector` || r === `PseudoClassSelector` || r === `PseudoElementSelector`) && n.remove(t);
+	}
+	t.exports = n;
+})), f = e(((e, t) => {
+	function n(e, t, n) {
+		n.remove(t);
+	}
+	t.exports = n;
+})), p = e(((e, n) => {
+	let r = t(), i = {
+		Atrule: o(),
+		Comment: s(),
+		Declaration: c(),
+		Raw: l(),
+		Rule: u(),
+		TypeSelector: d(),
+		WhiteSpace: f()
+	};
+	function a(e, t) {
+		r.walk(e, { leave(e, n, r) {
+			i.hasOwnProperty(e.type) && i[e.type].call(this, e, n, r, t);
+		} });
+	}
+	n.exports = a;
+})), m = e(((e, t) => {
+	function n(e) {
+		e.block.children.forEach((e) => {
+			e.prelude.children.forEach((e) => {
+				e.children.forEach((e, t) => {
+					e.type === `Percentage` && e.value === `100` ? t.data = {
+						type: `TypeSelector`,
+						loc: e.loc,
+						name: `to`
+					} : e.type === `TypeSelector` && e.name === `from` && (t.data = {
+						type: `Percentage`,
+						loc: e.loc,
+						value: `0`
+					});
+				});
+			});
+		});
+	}
+	t.exports = n;
+})), h = e(((e, n) => {
+	let r = t(), i = m();
+	function a(e) {
+		r.keyword(e.name).basename === `keyframes` && i(e);
+	}
+	n.exports = a;
+})), g = e(((e, t) => {
+	let n = /^(-?\d|--)|[\u0000-\u002c\u002e\u002f\u003A-\u0040\u005B-\u005E\u0060\u007B-\u009f]/;
+	function r(e) {
+		return e === `` || e === `-` ? !1 : !n.test(e);
+	}
+	function i(e) {
+		let t = e.value;
+		!t || t.type !== `String` || r(t.value) && (e.value = {
+			type: `Identifier`,
+			loc: t.loc,
+			name: t.value
+		});
+	}
+	t.exports = i;
+})), _ = e(((e, t) => {
+	function n(e) {
+		let t = e.children;
+		t.forEachRight(function(e, t) {
+			if (e.type === `Identifier`) {
+				if (e.name === `bold`) t.data = {
+					type: `Number`,
+					loc: e.loc,
+					value: `700`
+				};
+				else if (e.name === `normal`) {
+					let e = t.prev;
+					e && e.data.type === `Operator` && e.data.value === `/` && this.remove(e), this.remove(t);
+				}
+			}
+		}), t.isEmpty && t.insert(t.createItem({
+			type: `Identifier`,
+			name: `normal`
+		}));
+	}
+	t.exports = n;
+})), v = e(((e, t) => {
+	function n(e) {
+		let t = e.children.head.data;
+		if (t.type === `Identifier`) switch (t.name) {
+			case `normal`:
+				e.children.head.data = {
+					type: `Number`,
+					loc: t.loc,
+					value: `400`
+				};
+				break;
+			case `bold`:
+				e.children.head.data = {
+					type: `Number`,
+					loc: t.loc,
+					value: `700`
+				};
+				break;
+		}
+	}
+	t.exports = n;
+})), y = e(((e, n) => {
+	let r = t();
+	function i(e) {
+		function t() {
+			i.length || i.unshift({
+				type: `Number`,
+				loc: null,
+				value: `0`
+			}, {
+				type: `Number`,
+				loc: null,
+				value: `0`
+			}), n.push.apply(n, i), i = [];
+		}
+		let n = [], i = [];
+		e.children.forEach((e) => {
+			if (e.type === `Operator` && e.value === `,`) {
+				t(), n.push(e);
+				return;
+			}
+			e.type === `Identifier` && (e.name === `transparent` || e.name === `none` || e.name === `repeat` || e.name === `scroll`) || i.push(e);
+		}), t(), e.children = new r.List().fromArray(n);
+	}
+	n.exports = i;
+})), b = e(((e, t) => {
+	function n(e) {
+		e.children.forEach((e, t, n) => {
+			e.type === `Identifier` && e.name.toLowerCase() === `none` && (n.head === n.tail ? t.data = {
+				type: `Number`,
+				loc: e.loc,
+				value: `0`
+			} : n.remove(t));
+		});
+	}
+	t.exports = n;
+})), x = e(((e, n) => {
+	let r = t(), i = _(), a = v(), o = y(), s = b(), c = {
+		font: i,
+		"font-weight": a,
+		background: o,
+		border: s,
+		outline: s
+	};
+	function l(e) {
+		if (!this.declaration) return;
+		let t = r.property(this.declaration.property);
+		c.hasOwnProperty(t.basename) && c[t.basename](e);
+	}
+	n.exports = l;
+})), S = e(((e) => {
+	let t = /^(?:\+|(-))?0*(\d*)(?:\.0*|(\.\d*?)0*)?$/, n = /^([\+\-])?0*(\d*)(?:\.0*|(\.\d*?)0*)?$/, r = /* @__PURE__ */ new Set([
+		`Dimension`,
+		`Hash`,
+		`Identifier`,
+		`Number`,
+		`Raw`,
+		`UnicodeRange`
+	]);
+	function i(e, i) {
+		let a = i && i.prev !== null && r.has(i.prev.data.type) ? n : t;
+		return e = String(e).replace(a, `$1$2$3`), (e === `` || e === `-`) && (e = `0`), e;
+	}
+	function a(e) {
+		e.value = i(e.value);
+	}
+	e.Number = a, e.packNumber = i;
+})), C = e(((e, t) => {
+	let n = S(), r = /* @__PURE__ */ new Set([
+		`calc`,
+		`min`,
+		`max`,
+		`clamp`
+	]), i = /* @__PURE__ */ new Set([
+		`px`,
+		`mm`,
+		`cm`,
+		`in`,
+		`pt`,
+		`pc`,
+		`em`,
+		`ex`,
+		`ch`,
+		`rem`,
+		`vh`,
+		`vw`,
+		`vmin`,
+		`vmax`,
+		`vm`
+	]);
+	function a(e, t) {
+		let a = n.packNumber(e.value);
+		if (e.value = a, a === `0` && this.declaration !== null && this.atrulePrelude === null) {
+			let n = e.unit.toLowerCase();
+			if (!i.has(n) || this.declaration.property === `-ms-flex` || this.declaration.property === `flex` || this.function && r.has(this.function.name)) return;
+			t.data = {
+				type: `Number`,
+				loc: e.loc,
+				value: a
+			};
+		}
+	}
+	t.exports = a;
+})), w = e(((e, n) => {
+	let r = t(), i = S(), a = /* @__PURE__ */ new Set([
+		`width`,
+		`min-width`,
+		`max-width`,
+		`height`,
+		`min-height`,
+		`max-height`,
+		`flex`,
+		`-ms-flex`
+	]);
+	function o(e, t) {
+		e.value = i.packNumber(e.value), e.value === `0` && this.declaration && !a.has(this.declaration.property) && (t.data = {
+			type: `Number`,
+			loc: e.loc,
+			value: e.value
+		}, r.lexer.matchDeclaration(this.declaration).isType(t.data, `length`) || (t.data = e));
+	}
+	n.exports = o;
+})), T = e(((e, t) => {
+	function n(e) {
+		e.value = e.value.replace(/\\/g, `/`);
+	}
+	t.exports = n;
+})), E = e(((e) => {
+	let n = t(), r = S(), i = {
+		aliceblue: `f0f8ff`,
+		antiquewhite: `faebd7`,
+		aqua: `0ff`,
+		aquamarine: `7fffd4`,
+		azure: `f0ffff`,
+		beige: `f5f5dc`,
+		bisque: `ffe4c4`,
+		black: `000`,
+		blanchedalmond: `ffebcd`,
+		blue: `00f`,
+		blueviolet: `8a2be2`,
+		brown: `a52a2a`,
+		burlywood: `deb887`,
+		cadetblue: `5f9ea0`,
+		chartreuse: `7fff00`,
+		chocolate: `d2691e`,
+		coral: `ff7f50`,
+		cornflowerblue: `6495ed`,
+		cornsilk: `fff8dc`,
+		crimson: `dc143c`,
+		cyan: `0ff`,
+		darkblue: `00008b`,
+		darkcyan: `008b8b`,
+		darkgoldenrod: `b8860b`,
+		darkgray: `a9a9a9`,
+		darkgrey: `a9a9a9`,
+		darkgreen: `006400`,
+		darkkhaki: `bdb76b`,
+		darkmagenta: `8b008b`,
+		darkolivegreen: `556b2f`,
+		darkorange: `ff8c00`,
+		darkorchid: `9932cc`,
+		darkred: `8b0000`,
+		darksalmon: `e9967a`,
+		darkseagreen: `8fbc8f`,
+		darkslateblue: `483d8b`,
+		darkslategray: `2f4f4f`,
+		darkslategrey: `2f4f4f`,
+		darkturquoise: `00ced1`,
+		darkviolet: `9400d3`,
+		deeppink: `ff1493`,
+		deepskyblue: `00bfff`,
+		dimgray: `696969`,
+		dimgrey: `696969`,
+		dodgerblue: `1e90ff`,
+		firebrick: `b22222`,
+		floralwhite: `fffaf0`,
+		forestgreen: `228b22`,
+		fuchsia: `f0f`,
+		gainsboro: `dcdcdc`,
+		ghostwhite: `f8f8ff`,
+		gold: `ffd700`,
+		goldenrod: `daa520`,
+		gray: `808080`,
+		grey: `808080`,
+		green: `008000`,
+		greenyellow: `adff2f`,
+		honeydew: `f0fff0`,
+		hotpink: `ff69b4`,
+		indianred: `cd5c5c`,
+		indigo: `4b0082`,
+		ivory: `fffff0`,
+		khaki: `f0e68c`,
+		lavender: `e6e6fa`,
+		lavenderblush: `fff0f5`,
+		lawngreen: `7cfc00`,
+		lemonchiffon: `fffacd`,
+		lightblue: `add8e6`,
+		lightcoral: `f08080`,
+		lightcyan: `e0ffff`,
+		lightgoldenrodyellow: `fafad2`,
+		lightgray: `d3d3d3`,
+		lightgrey: `d3d3d3`,
+		lightgreen: `90ee90`,
+		lightpink: `ffb6c1`,
+		lightsalmon: `ffa07a`,
+		lightseagreen: `20b2aa`,
+		lightskyblue: `87cefa`,
+		lightslategray: `789`,
+		lightslategrey: `789`,
+		lightsteelblue: `b0c4de`,
+		lightyellow: `ffffe0`,
+		lime: `0f0`,
+		limegreen: `32cd32`,
+		linen: `faf0e6`,
+		magenta: `f0f`,
+		maroon: `800000`,
+		mediumaquamarine: `66cdaa`,
+		mediumblue: `0000cd`,
+		mediumorchid: `ba55d3`,
+		mediumpurple: `9370db`,
+		mediumseagreen: `3cb371`,
+		mediumslateblue: `7b68ee`,
+		mediumspringgreen: `00fa9a`,
+		mediumturquoise: `48d1cc`,
+		mediumvioletred: `c71585`,
+		midnightblue: `191970`,
+		mintcream: `f5fffa`,
+		mistyrose: `ffe4e1`,
+		moccasin: `ffe4b5`,
+		navajowhite: `ffdead`,
+		navy: `000080`,
+		oldlace: `fdf5e6`,
+		olive: `808000`,
+		olivedrab: `6b8e23`,
+		orange: `ffa500`,
+		orangered: `ff4500`,
+		orchid: `da70d6`,
+		palegoldenrod: `eee8aa`,
+		palegreen: `98fb98`,
+		paleturquoise: `afeeee`,
+		palevioletred: `db7093`,
+		papayawhip: `ffefd5`,
+		peachpuff: `ffdab9`,
+		peru: `cd853f`,
+		pink: `ffc0cb`,
+		plum: `dda0dd`,
+		powderblue: `b0e0e6`,
+		purple: `800080`,
+		rebeccapurple: `639`,
+		red: `f00`,
+		rosybrown: `bc8f8f`,
+		royalblue: `4169e1`,
+		saddlebrown: `8b4513`,
+		salmon: `fa8072`,
+		sandybrown: `f4a460`,
+		seagreen: `2e8b57`,
+		seashell: `fff5ee`,
+		sienna: `a0522d`,
+		silver: `c0c0c0`,
+		skyblue: `87ceeb`,
+		slateblue: `6a5acd`,
+		slategray: `708090`,
+		slategrey: `708090`,
+		snow: `fffafa`,
+		springgreen: `00ff7f`,
+		steelblue: `4682b4`,
+		tan: `d2b48c`,
+		teal: `008080`,
+		thistle: `d8bfd8`,
+		tomato: `ff6347`,
+		turquoise: `40e0d0`,
+		violet: `ee82ee`,
+		wheat: `f5deb3`,
+		white: `fff`,
+		whitesmoke: `f5f5f5`,
+		yellow: `ff0`,
+		yellowgreen: `9acd32`
+	}, a = {
+		8e5: `maroon`,
+		800080: `purple`,
+		808e3: `olive`,
+		808080: `gray`,
+		"00ffff": `cyan`,
+		f0ffff: `azure`,
+		f5f5dc: `beige`,
+		ffe4c4: `bisque`,
+		"000000": `black`,
+		"0000ff": `blue`,
+		a52a2a: `brown`,
+		ff7f50: `coral`,
+		ffd700: `gold`,
+		"008000": `green`,
+		"4b0082": `indigo`,
+		fffff0: `ivory`,
+		f0e68c: `khaki`,
+		"00ff00": `lime`,
+		faf0e6: `linen`,
+		"000080": `navy`,
+		ffa500: `orange`,
+		da70d6: `orchid`,
+		cd853f: `peru`,
+		ffc0cb: `pink`,
+		dda0dd: `plum`,
+		f00: `red`,
+		ff0000: `red`,
+		fa8072: `salmon`,
+		a0522d: `sienna`,
+		c0c0c0: `silver`,
+		fffafa: `snow`,
+		d2b48c: `tan`,
+		"008080": `teal`,
+		ff6347: `tomato`,
+		ee82ee: `violet`,
+		f5deb3: `wheat`,
+		ffffff: `white`,
+		ffff00: `yellow`
+	};
+	function o(e, t, n) {
+		return n < 0 && (n += 1), n > 1 && --n, n < 1 / 6 ? e + (t - e) * 6 * n : n < 1 / 2 ? t : n < 2 / 3 ? e + (t - e) * (2 / 3 - n) * 6 : e;
+	}
+	function s(e, t, n, r) {
+		let i, a, s;
+		if (t === 0) i = a = s = n;
+		else {
+			let r = n < .5 ? n * (1 + t) : n + t - n * t, c = 2 * n - r;
+			i = o(c, r, e + 1 / 3), a = o(c, r, e), s = o(c, r, e - 1 / 3);
+		}
+		return [
+			Math.round(i * 255),
+			Math.round(a * 255),
+			Math.round(s * 255),
+			r
+		];
+	}
+	function c(e) {
+		return e = e.toString(16), e.length === 1 ? `0` + e : e;
+	}
+	function l(e, t, n) {
+		let r = e.head, i = [], a = !1;
+		for (; r !== null;) {
+			let { type: e, value: t } = r.data;
+			switch (e) {
+				case `Number`:
+				case `Percentage`:
+					if (a) return;
+					a = !0, i.push({
+						type: e,
+						value: Number(t)
+					});
+					break;
+				case `Operator`:
+					if (t === `,`) {
+						if (!a) return;
+						a = !1;
+					} else if (a || t !== `+`) return;
+					break;
+				default: return;
+			}
+			r = r.next;
+		}
+		if (i.length === t) {
+			if (i.length === 4) {
+				if (i[3].type !== `Number`) return;
+				i[3].type = `Alpha`;
+			}
+			if (n) {
+				if (i[0].type !== i[1].type || i[0].type !== i[2].type) return;
+			} else {
+				if (i[0].type !== `Number` || i[1].type !== `Percentage` || i[2].type !== `Percentage`) return;
+				i[0].type = `Angle`;
+			}
+			return i.map(function(e) {
+				let t = Math.max(0, e.value);
+				switch (e.type) {
+					case `Number`:
+						t = Math.min(t, 255);
+						break;
+					case `Percentage`:
+						if (t = Math.min(t, 100) / 100, !n) return t;
+						t = 255 * t;
+						break;
+					case `Angle`: return (t % 360 + 360) % 360 / 360;
+					case `Alpha`: return Math.min(t, 1);
+				}
+				return Math.round(t);
+			});
+		}
+	}
+	function u(e, t) {
+		let n = e.name, i;
+		if (n === `rgba` || n === `hsla`) {
+			if (i = l(e.children, 4, n === `rgba`), !i) return;
+			if (n === `hsla` && (i = s(...i), e.name = `rgba`), i[3] === 0) {
+				let n = this.function && this.function.name;
+				if (i[0] === 0 && i[1] === 0 && i[2] === 0 || !/^(?:to|from|color-stop)$|gradient$/i.test(n)) {
+					t.data = {
+						type: `Identifier`,
+						loc: e.loc,
+						name: `transparent`
+					};
+					return;
+				}
+			}
+			if (i[3] !== 1) {
+				e.children.forEach((e, t, n) => {
+					if (e.type === `Operator`) {
+						e.value !== `,` && n.remove(t);
+						return;
+					}
+					t.data = {
+						type: `Number`,
+						loc: e.loc,
+						value: r.packNumber(i.shift())
+					};
+				});
+				return;
+			}
+			n = `rgb`;
+		}
+		if (n === `hsl`) {
+			if (i ||= l(e.children, 3, !1), !i) return;
+			i = s(...i), n = `rgb`;
+		}
+		if (n === `rgb`) {
+			if (i ||= l(e.children, 3, !0), !i) return;
+			t.data = {
+				type: `Hash`,
+				loc: e.loc,
+				value: c(i[0]) + c(i[1]) + c(i[2])
+			}, f(t.data, t);
+		}
+	}
+	function d(e, t) {
+		if (this.declaration === null) return;
+		let r = e.name.toLowerCase();
+		if (i.hasOwnProperty(r) && n.lexer.matchDeclaration(this.declaration).isType(e, `color`)) {
+			let n = i[r];
+			n.length + 1 <= r.length ? t.data = {
+				type: `Hash`,
+				loc: e.loc,
+				value: n
+			} : (r === `grey` && (r = `gray`), e.name = r);
+		}
+	}
+	function f(e, t) {
+		let n = e.value.toLowerCase();
+		n.length === 6 && n[0] === n[1] && n[2] === n[3] && n[4] === n[5] && (n = n[0] + n[2] + n[4]), a[n] ? t.data = {
+			type: `Identifier`,
+			loc: e.loc,
+			name: a[n]
+		} : e.value = n;
+	}
+	e.compressFunction = u, e.compressHex = f, e.compressIdent = d;
+})), D = e(((e, n) => {
+	let r = t(), i = h(), a = g(), o = x(), s = C(), c = w(), l = S(), u = T(), d = E(), f = {
+		Atrule: i,
+		AttributeSelector: a,
+		Value: o,
+		Dimension: s,
+		Percentage: c,
+		Number: l.Number,
+		Url: u,
+		Hash: d.compressHex,
+		Identifier: d.compressIdent,
+		Function: d.compressFunction
+	};
+	function p(e) {
+		r.walk(e, { leave(e, t, n) {
+			f.hasOwnProperty(e.type) && f[e.type].call(this, e, t, n);
+		} });
+	}
+	n.exports = p;
+})), O = e(((e, n) => {
+	let r = t();
+	var i = class {
+		constructor() {
+			this.map = /* @__PURE__ */ new Map();
+		}
+		resolve(e) {
+			let t = this.map.get(e);
+			return t === void 0 && (t = this.map.size + 1, this.map.set(e, t)), t;
+		}
+	};
+	function a() {
+		let e = new i();
+		return function(t) {
+			let n = r.generate(t);
+			return t.id = e.resolve(n), t.length = n.length, t.fingerprint = null, t;
+		};
+	}
+	n.exports = a;
+})), k = e(((e, n) => {
+	let r = t();
+	function i(e) {
+		return e.type === `Raw` ? r.parse(e.value, { context: `selectorList` }) : e;
+	}
+	function a(e, t) {
+		for (let n = 0; n < 3; n++) if (e[n] !== t[n]) return e[n] > t[n] ? e : t;
+		return e;
+	}
+	function o(e) {
+		return i(e).children.reduce((e, t) => a(s(t), e), [
+			0,
+			0,
+			0
+		]);
+	}
+	function s(e) {
+		let t = 0, n = 0, r = 0;
+		return e.children.forEach((e) => {
+			switch (e.type) {
+				case `IdSelector`:
+					t++;
+					break;
+				case `ClassSelector`:
+				case `AttributeSelector`:
+					n++;
+					break;
+				case `PseudoClassSelector`:
+					switch (e.name.toLowerCase()) {
+						case `not`:
+						case `has`:
+						case `is`:
+						case `matches`:
+						case `-webkit-any`:
+						case `-moz-any`: {
+							let [i, a, s] = o(e.children.first);
+							t += i, n += a, r += s;
+							break;
+						}
+						case `nth-child`:
+						case `nth-last-child`: {
+							let i = e.children.first;
+							if (i.type === `Nth` && i.selector) {
+								let [e, a, s] = o(i.selector);
+								t += e, n += a + 1, r += s;
+							} else n++;
+							break;
+						}
+						case `where`: break;
+						case `before`:
+						case `after`:
+						case `first-line`:
+						case `first-letter`:
+							r++;
+							break;
+						default: n++;
+					}
+					break;
+				case `TypeSelector`:
+					e.name.endsWith(`*`) || r++;
+					break;
+				case `PseudoElementSelector`:
+					r++;
+					break;
+			}
+		}), [
+			t,
+			n,
+			r
+		];
+	}
+	n.exports = s;
+})), A = e(((e, n) => {
+	let r = t(), i = k(), a = /* @__PURE__ */ new Set([
+		`first-letter`,
+		`first-line`,
+		`after`,
+		`before`
+	]), o = /* @__PURE__ */ new Set([
+		`link`,
+		`visited`,
+		`hover`,
+		`active`,
+		`first-letter`,
+		`first-line`,
+		`after`,
+		`before`
+	]);
+	function s(e, t) {
+		let n = /* @__PURE__ */ new Set();
+		e.prelude.children.forEach(function(e) {
+			let s = `*`, c = 0;
+			e.children.forEach(function(i) {
+				switch (i.type) {
+					case `ClassSelector`:
+						if (t && t.scopes) {
+							let n = t.scopes[i.name] || 0;
+							if (c !== 0 && n !== c) throw Error(`Selector can't has classes from different scopes: ` + r.generate(e));
+							c = n;
+						}
+						break;
+					case `PseudoClassSelector`: {
+						let e = i.name.toLowerCase();
+						o.has(e) || n.add(`:${e}`);
+						break;
+					}
+					case `PseudoElementSelector`: {
+						let e = i.name.toLowerCase();
+						a.has(e) || n.add(`::${e}`);
+						break;
+					}
+					case `TypeSelector`:
+						s = i.name.toLowerCase();
+						break;
+					case `AttributeSelector`:
+						i.flags && n.add(`[${i.flags.toLowerCase()}]`);
+						break;
+					case `Combinator`:
+						s = `*`;
+						break;
+				}
+			}), e.compareMarker = i(e).toString(), e.id = null, e.id = r.generate(e), c && (e.compareMarker += `:` + c), s !== `*` && (e.compareMarker += `,` + s);
+		}), e.pseudoSignature = n.size > 0 ? [...n].sort().join(`,`) : !1;
+	}
+	n.exports = s;
+})), j = e(((e, n) => {
+	let r = t(), i = O(), a = A();
+	function o(e, t) {
+		let n = i();
+		return r.walk(e, {
+			visit: `Rule`,
+			enter(e) {
+				e.block.children.forEach(n), a(e, t.usage);
+			}
+		}), r.walk(e, {
+			visit: `Atrule`,
+			enter(e) {
+				e.prelude && (e.prelude.id = null, e.prelude.id = r.generate(e.prelude)), r.keyword(e.name).basename === `keyframes` && (e.block.avoidRulesMerge = !0, e.block.children.forEach(function(e) {
+					e.prelude.children.forEach(function(e) {
+						e.compareMarker = e.id;
+					});
+				}));
+			}
+		}), { declaration: n };
+	}
+	n.exports = o;
+})), M = e(((e, n) => {
+	let r = t(), { hasOwnProperty: i } = Object.prototype;
+	function a(e, t, n, a) {
+		let o = t.data, s = r.keyword(o.name).basename, c = o.name.toLowerCase() + `/` + (o.prelude ? o.prelude.id : null);
+		i.call(e, s) || (e[s] = Object.create(null)), a && delete e[s][c], i.call(e[s], c) || (e[s][c] = new r.List()), e[s][c].append(n.remove(t));
+	}
+	function o(e, t) {
+		let n = Object.create(null), i = null;
+		e.children.forEach(function(e, o, s) {
+			if (e.type === `Atrule`) {
+				let c = r.keyword(e.name).basename;
+				switch (c) {
+					case `keyframes`:
+						a(n, o, s, !0);
+						return;
+					case `media`:
+						if (t.forceMediaMerge) {
+							a(n, o, s, !1);
+							return;
+						}
+						break;
+				}
+				i === null && c !== `charset` && c !== `import` && (i = o);
+			} else i === null && (i = o);
+		});
+		for (let t in n) for (let r in n[t]) e.children.insertList(n[t][r], t === `media` ? null : i);
+	}
+	function s(e) {
+		return e.type === `Atrule` && e.name === `media`;
+	}
+	function c(e, t, n) {
+		if (!s(e)) return;
+		let r = t.prev && t.prev.data;
+		!r || !s(r) || e.prelude && r.prelude && e.prelude.id === r.prelude.id && (r.block.children.appendList(e.block.children), n.remove(t));
+	}
+	function l(e, t) {
+		o(e, t), r.walk(e, {
+			visit: `Atrule`,
+			reverse: !0,
+			enter: c
+		});
+	}
+	n.exports = l;
+})), N = e(((e) => {
+	let { hasOwnProperty: t } = Object.prototype;
+	function n(e, t) {
+		let n = e.head, r = t.head;
+		for (; n !== null && r !== null && n.data.id === r.data.id;) n = n.next, r = r.next;
+		return n === null && r === null;
+	}
+	function r(e, t) {
+		let n = e.head, r = t.head;
+		for (; n !== null && r !== null && n.data.id === r.data.id;) n = n.next, r = r.next;
+		return n === null && r === null;
+	}
+	function i(e, n) {
+		let r = {
+			eq: [],
+			ne1: [],
+			ne2: [],
+			ne2overrided: []
+		}, i = Object.create(null), a = Object.create(null);
+		for (let e = n.head; e; e = e.next) a[e.data.id] = !0;
+		for (let t = e.head; t; t = t.next) {
+			let e = t.data;
+			e.fingerprint && (i[e.fingerprint] = e.important), a[e.id] ? (a[e.id] = !1, r.eq.push(e)) : r.ne1.push(e);
+		}
+		for (let e = n.head; e; e = e.next) {
+			let n = e.data;
+			a[n.id] && ((!t.call(i, n.fingerprint) || !i[n.fingerprint] && n.important) && r.ne2.push(n), r.ne2overrided.push(n));
+		}
+		return r;
+	}
+	function a(e, t) {
+		return t.forEach((t) => {
+			let n = t.id, r = e.head;
+			for (; r;) {
+				let e = r.data.id;
+				if (e === n) return;
+				if (e > n) break;
+				r = r.next;
+			}
+			e.insert(e.createItem(t), r);
+		}), e;
+	}
+	function o(e, t) {
+		let n = e.head;
+		for (; n !== null;) {
+			let e = t.head;
+			for (; e !== null;) {
+				if (n.data.compareMarker === e.data.compareMarker) return !0;
+				e = e.next;
+			}
+			n = n.next;
+		}
+		return !1;
+	}
+	function s(e) {
+		switch (e.type) {
+			case `Rule`: return o(e.prelude.children, this);
+			case `Atrule`:
+				if (e.block) return e.block.children.some(s, this);
+				break;
+			case `Declaration`: return !1;
+		}
+		return !0;
+	}
+	e.addSelectors = a, e.compareDeclarations = i, e.hasSimilarSelectors = o, e.isEqualDeclarations = r, e.isEqualSelectors = n, e.unsafeToSkipNode = s;
+})), P = e(((e, n) => {
+	let r = t(), i = N();
+	function a(e, t, n) {
+		let r = e.prelude.children, a = e.block.children;
+		n.prevUntil(t.prev, function(o) {
+			if (o.type !== `Rule`) return i.unsafeToSkipNode.call(r, o);
+			let s = o.prelude.children, c = o.block.children;
+			if (e.pseudoSignature === o.pseudoSignature) {
+				if (i.isEqualSelectors(s, r)) return c.appendList(a), n.remove(t), !0;
+				if (i.isEqualDeclarations(a, c)) return i.addSelectors(s, r), n.remove(t), !0;
+			}
+			return i.hasSimilarSelectors(r, s);
+		});
+	}
+	function o(e) {
+		r.walk(e, {
+			visit: `Rule`,
+			enter: a
+		});
+	}
+	n.exports = o;
+})), F = e(((e, n) => {
+	let r = t();
+	function i(e, t, n) {
+		let i = e.prelude.children;
+		for (; i.head !== i.tail;) {
+			let a = new r.List();
+			a.insert(i.remove(i.head)), n.insert(n.createItem({
+				type: `Rule`,
+				loc: e.loc,
+				prelude: {
+					type: `SelectorList`,
+					loc: e.prelude.loc,
+					children: a
+				},
+				block: {
+					type: `Block`,
+					loc: e.block.loc,
+					children: e.block.children.copy()
+				},
+				pseudoSignature: e.pseudoSignature
+			}), t);
+		}
+	}
+	function a(e) {
+		r.walk(e, {
+			visit: `Rule`,
+			reverse: !0,
+			enter: i
+		});
+	}
+	n.exports = a;
+})), I = e(((e, n) => {
+	let r = t(), i = [
+		`top`,
+		`right`,
+		`bottom`,
+		`left`
+	], a = {
+		"margin-top": `top`,
+		"margin-right": `right`,
+		"margin-bottom": `bottom`,
+		"margin-left": `left`,
+		"padding-top": `top`,
+		"padding-right": `right`,
+		"padding-bottom": `bottom`,
+		"padding-left": `left`,
+		"border-top-color": `top`,
+		"border-right-color": `right`,
+		"border-bottom-color": `bottom`,
+		"border-left-color": `left`,
+		"border-top-width": `top`,
+		"border-right-width": `right`,
+		"border-bottom-width": `bottom`,
+		"border-left-width": `left`,
+		"border-top-style": `top`,
+		"border-right-style": `right`,
+		"border-bottom-style": `bottom`,
+		"border-left-style": `left`
+	}, o = {
+		margin: `margin`,
+		"margin-top": `margin`,
+		"margin-right": `margin`,
+		"margin-bottom": `margin`,
+		"margin-left": `margin`,
+		padding: `padding`,
+		"padding-top": `padding`,
+		"padding-right": `padding`,
+		"padding-bottom": `padding`,
+		"padding-left": `padding`,
+		"border-color": `border-color`,
+		"border-top-color": `border-color`,
+		"border-right-color": `border-color`,
+		"border-bottom-color": `border-color`,
+		"border-left-color": `border-color`,
+		"border-width": `border-width`,
+		"border-top-width": `border-width`,
+		"border-right-width": `border-width`,
+		"border-bottom-width": `border-width`,
+		"border-left-width": `border-width`,
+		"border-style": `border-style`,
+		"border-top-style": `border-style`,
+		"border-right-style": `border-style`,
+		"border-bottom-style": `border-style`,
+		"border-left-style": `border-style`
+	};
+	var s = class {
+		constructor(e) {
+			this.name = e, this.loc = null, this.iehack = void 0, this.sides = {
+				top: null,
+				right: null,
+				bottom: null,
+				left: null
+			};
+		}
+		getValueSequence(e, t) {
+			let n = [], r = ``;
+			return e.value.type !== `Value` || e.value.children.some(function(t) {
+				let i = !1;
+				switch (t.type) {
+					case `Identifier`:
+						switch (t.name) {
+							case `\\0`:
+							case `\\9`:
+								r = t.name;
+								return;
+							case `inherit`:
+							case `initial`:
+							case `unset`:
+							case `revert`:
+								i = t.name;
+								break;
+						}
+						break;
+					case `Dimension`:
+						switch (t.unit) {
+							case `rem`:
+							case `vw`:
+							case `vh`:
+							case `vmin`:
+							case `vmax`:
+							case `vm`:
+								i = t.unit;
+								break;
+						}
+						break;
+					case `Hash`:
+					case `Number`:
+					case `Percentage`: break;
+					case `Function`:
+						if (t.name === `var`) return !0;
+						i = t.name;
+						break;
+					default: return !0;
+				}
+				n.push({
+					node: t,
+					special: i,
+					important: e.important
+				});
+			}) || n.length > t || typeof this.iehack == `string` && this.iehack !== r ? !1 : (this.iehack = r, n);
+		}
+		canOverride(e, t) {
+			let n = this.sides[e];
+			return !n || t.important && !n.important;
+		}
+		add(e, t) {
+			function n() {
+				let n = this.sides, r = a[e];
+				if (r) {
+					if (!(r in n)) return !1;
+					let e = this.getValueSequence(t, 1);
+					if (!e || !e.length) return !1;
+					for (let t in n) if (n[t] !== null && n[t].special !== e[0].special) return !1;
+					return this.canOverride(r, e[0]) && (n[r] = e[0]), !0;
+				} else if (e === this.name) {
+					let e = this.getValueSequence(t, 4);
+					if (!e || !e.length) return !1;
+					switch (e.length) {
+						case 1:
+							e[1] = e[0], e[2] = e[0], e[3] = e[0];
+							break;
+						case 2:
+							e[2] = e[0], e[3] = e[1];
+							break;
+						case 3:
+							e[3] = e[1];
+							break;
+					}
+					for (let t = 0; t < 4; t++) for (let r in n) if (n[r] !== null && n[r].special !== e[t].special) return !1;
+					for (let t = 0; t < 4; t++) this.canOverride(i[t], e[t]) && (n[i[t]] = e[t]);
+					return !0;
+				}
+			}
+			return n.call(this) ? (this.loc ||= t.loc, !0) : !1;
+		}
+		isOkToMinimize() {
+			let e = this.sides.top, t = this.sides.right, n = this.sides.bottom, r = this.sides.left;
+			if (e && t && n && r) {
+				let i = e.important + t.important + n.important + r.important;
+				return i === 0 || i === 4;
+			}
+			return !1;
+		}
+		getValue() {
+			let e = new r.List(), t = this.sides, n = [
+				t.top,
+				t.right,
+				t.bottom,
+				t.left
+			], i = [
+				r.generate(t.top.node),
+				r.generate(t.right.node),
+				r.generate(t.bottom.node),
+				r.generate(t.left.node)
+			];
+			i[3] === i[1] && (n.pop(), i[2] === i[0] && (n.pop(), i[1] === i[0] && n.pop()));
+			for (let t = 0; t < n.length; t++) e.appendData(n[t].node);
+			return this.iehack && e.appendData({
+				type: `Identifier`,
+				loc: null,
+				name: this.iehack
+			}), {
+				type: `Value`,
+				loc: null,
+				children: e
+			};
+		}
+		getDeclaration() {
+			return {
+				type: `Declaration`,
+				loc: this.loc,
+				important: this.sides.top.important,
+				property: this.name,
+				value: this.getValue()
+			};
+		}
+	};
+	function c(e, t, n, r) {
+		let i = e.block.children, a = e.prelude.children.first.id;
+		return e.block.children.forEachRight(function(e, c) {
+			let l = e.property;
+			if (!o.hasOwnProperty(l)) return;
+			let u = o[l], d, f;
+			if ((!r || a === r) && u in t && (f = 2, d = t[u]), (!d || !d.add(l, e)) && (f = 1, d = new s(u), !d.add(l, e))) {
+				r = null;
+				return;
+			}
+			t[u] = d, n.push({
+				operation: f,
+				block: i,
+				item: c,
+				shorthand: d
+			}), r = a;
+		}), r;
+	}
+	function l(e, t) {
+		e.forEach(function(e) {
+			let n = e.shorthand;
+			n.isOkToMinimize() && (e.operation === 1 ? e.item.data = t(n.getDeclaration()) : e.block.remove(e.item));
+		});
+	}
+	function u(e, t) {
+		let n = {}, i = [];
+		r.walk(e, {
+			visit: `Rule`,
+			reverse: !0,
+			enter(e) {
+				let t = this.block || this.stylesheet, r = (e.pseudoSignature || ``) + `|` + e.prelude.children.first.id, a, o;
+				n.hasOwnProperty(t.id) ? a = n[t.id] : (a = { lastShortSelector: null }, n[t.id] = a), a.hasOwnProperty(r) ? o = a[r] : (o = {}, a[r] = o), a.lastShortSelector = c.call(this, e, o, i, a.lastShortSelector);
+			}
+		}), l(i, t.declaration);
+	}
+	n.exports = u;
+})), L = e(((e, n) => {
+	let r = t(), i = 1, a = /* @__PURE__ */ new Set([`src`]), o = {
+		display: /table|ruby|flex|-(flex)?box$|grid|contents|run-in/i,
+		"text-align": /^(start|end|match-parent|justify-all)$/i
+	}, s = {
+		cursor: [
+			`auto`,
+			`crosshair`,
+			`default`,
+			`move`,
+			`text`,
+			`wait`,
+			`help`,
+			`n-resize`,
+			`e-resize`,
+			`s-resize`,
+			`w-resize`,
+			`ne-resize`,
+			`nw-resize`,
+			`se-resize`,
+			`sw-resize`,
+			`pointer`,
+			`progress`,
+			`not-allowed`,
+			`no-drop`,
+			`vertical-text`,
+			`all-scroll`,
+			`col-resize`,
+			`row-resize`
+		],
+		overflow: [
+			`hidden`,
+			`visible`,
+			`scroll`,
+			`auto`
+		],
+		position: [
+			`static`,
+			`relative`,
+			`absolute`,
+			`fixed`
+		]
+	}, c = {
+		"border-width": [`border`],
+		"border-style": [`border`],
+		"border-color": [`border`],
+		"border-top": [`border`],
+		"border-right": [`border`],
+		"border-bottom": [`border`],
+		"border-left": [`border`],
+		"border-top-width": [
+			`border-top`,
+			`border-width`,
+			`border`
+		],
+		"border-right-width": [
+			`border-right`,
+			`border-width`,
+			`border`
+		],
+		"border-bottom-width": [
+			`border-bottom`,
+			`border-width`,
+			`border`
+		],
+		"border-left-width": [
+			`border-left`,
+			`border-width`,
+			`border`
+		],
+		"border-top-style": [
+			`border-top`,
+			`border-style`,
+			`border`
+		],
+		"border-right-style": [
+			`border-right`,
+			`border-style`,
+			`border`
+		],
+		"border-bottom-style": [
+			`border-bottom`,
+			`border-style`,
+			`border`
+		],
+		"border-left-style": [
+			`border-left`,
+			`border-style`,
+			`border`
+		],
+		"border-top-color": [
+			`border-top`,
+			`border-color`,
+			`border`
+		],
+		"border-right-color": [
+			`border-right`,
+			`border-color`,
+			`border`
+		],
+		"border-bottom-color": [
+			`border-bottom`,
+			`border-color`,
+			`border`
+		],
+		"border-left-color": [
+			`border-left`,
+			`border-color`,
+			`border`
+		],
+		"margin-top": [`margin`],
+		"margin-right": [`margin`],
+		"margin-bottom": [`margin`],
+		"margin-left": [`margin`],
+		"padding-top": [`padding`],
+		"padding-right": [`padding`],
+		"padding-bottom": [`padding`],
+		"padding-left": [`padding`],
+		"font-style": [`font`],
+		"font-variant": [`font`],
+		"font-weight": [`font`],
+		"font-size": [`font`],
+		"font-family": [`font`],
+		"list-style-type": [`list-style`],
+		"list-style-position": [`list-style`],
+		"list-style-image": [`list-style`]
+	};
+	function l(e, t, n) {
+		let a = r.property(e).basename;
+		if (a === `background`) return e + `:` + r.generate(t.value);
+		let c = t.id, l = n[c];
+		if (!l) {
+			switch (t.value.type) {
+				case `Value`:
+					let e = {}, n = ``, c = ``, u = !1;
+					t.value.children.forEach(function t(i) {
+						switch (i.type) {
+							case `Value`:
+							case `Brackets`:
+							case `Parentheses`:
+								i.children.forEach(t);
+								break;
+							case `Raw`:
+								u = !0;
+								break;
+							case `Identifier`: {
+								let { name: t } = i;
+								n ||= r.keyword(t).vendor, /\\[09]/.test(t) && (c = RegExp.lastMatch), s.hasOwnProperty(a) ? s[a].indexOf(t) === -1 && (e[t] = !0) : o.hasOwnProperty(a) && o[a].test(t) && (e[t] = !0);
+								break;
+							}
+							case `Function`: {
+								let { name: a } = i;
+								n ||= r.keyword(a).vendor, a === `rect` && (i.children.some((e) => e.type === `Operator` && e.value === `,`) || (a = `rect-backward`)), e[a + `()`] = !0, i.children.forEach(t);
+								break;
+							}
+							case `Dimension`: {
+								let { unit: t } = i;
+								switch (/\\[09]/.test(t) && (c = RegExp.lastMatch), t) {
+									case `rem`:
+									case `vw`:
+									case `vh`:
+									case `vmin`:
+									case `vmax`:
+									case `vm`:
+										e[t] = !0;
+										break;
+								}
+								break;
+							}
+						}
+					}), l = u ? `!` + i++ : `!` + Object.keys(e).sort() + `|` + c + n;
+					break;
+				case `Raw`:
+					l = `!` + t.value.value;
+					break;
+				default: l = r.generate(t.value);
+			}
+			n[c] = l;
+		}
+		return e + l;
+	}
+	function u(e, t, n) {
+		let i = r.property(t.property);
+		if (c.hasOwnProperty(i.basename)) {
+			let r = c[i.basename];
+			for (let a of r) {
+				let r = l(i.prefix + a, t, n), o = e.hasOwnProperty(r) ? e[r] : null;
+				if (o && (!t.important || o.item.data.important)) return o;
+			}
+		}
+	}
+	function d(e, t, n, r, i) {
+		let o = e.block.children;
+		o.forEachRight(function(e, t) {
+			let { property: n } = e, s = l(n, e, i), c = r[s];
+			c && !a.has(n) ? e.important && !c.item.data.important ? (r[s] = {
+				block: o,
+				item: t
+			}, c.block.remove(c.item)) : o.remove(t) : u(r, e, i) ? o.remove(t) : (e.fingerprint = s, r[s] = {
+				block: o,
+				item: t
+			});
+		}), o.isEmpty && n.remove(t);
+	}
+	function f(e) {
+		let t = {}, n = Object.create(null);
+		r.walk(e, {
+			visit: `Rule`,
+			reverse: !0,
+			enter(e, r, i) {
+				let a = this.block || this.stylesheet, o = (e.pseudoSignature || ``) + `|` + e.prelude.children.first.id, s, c;
+				t.hasOwnProperty(a.id) ? s = t[a.id] : (s = {}, t[a.id] = s), s.hasOwnProperty(o) ? c = s[o] : (c = {}, s[o] = c), d.call(this, e, r, i, c, n);
+			}
+		});
+	}
+	n.exports = f;
+})), R = e(((e, n) => {
+	let r = t(), i = N();
+	function a(e, t, n) {
+		let r = e.prelude.children, a = e.block.children, o = r.first.compareMarker, s = {};
+		n.nextUntil(t.next, function(t, c) {
+			if (t.type !== `Rule`) return i.unsafeToSkipNode.call(r, t);
+			if (e.pseudoSignature !== t.pseudoSignature) return !0;
+			let l = t.prelude.children.head, u = t.block.children, d = l.data.compareMarker;
+			if (d in s) return !0;
+			if (r.head === r.tail && r.first.id === l.data.id) {
+				a.appendList(u), n.remove(c);
+				return;
+			}
+			if (i.isEqualDeclarations(a, u)) {
+				let e = l.data.id;
+				r.some((t, n) => {
+					if (e < t.id) return r.insert(l, n), !0;
+					if (!n.next) return r.insert(l), !0;
+				}), n.remove(c);
+				return;
+			}
+			if (d === o) return !0;
+			s[d] = !0;
+		});
+	}
+	function o(e) {
+		r.walk(e, {
+			visit: `Rule`,
+			enter: a
+		});
+	}
+	n.exports = o;
+})), z = e(((e, n) => {
+	let r = t(), i = N();
+	function a(e) {
+		return e.reduce((e, t) => e + t.id.length + 1, 0) - 1;
+	}
+	function o(e) {
+		let t = 0;
+		for (let n of e) t += n.length;
+		return t + e.length - 1;
+	}
+	function s(e, t, n) {
+		let s = this.block === null ? !1 : this.block.avoidRulesMerge, c = e.prelude.children, l = e.block, u = Object.create(null), d = !0, f = !0;
+		n.prevUntil(t.prev, function(p, m) {
+			let h = p.block, g = p.type;
+			if (g !== `Rule`) {
+				let e = i.unsafeToSkipNode.call(c, p);
+				return !e && g === `Atrule` && h && r.walk(h, {
+					visit: `Rule`,
+					enter(e) {
+						e.prelude.children.forEach((e) => {
+							u[e.compareMarker] = !0;
+						});
+					}
+				}), e;
+			}
+			if (e.pseudoSignature !== p.pseudoSignature) return !0;
+			let _ = p.prelude.children;
+			if (f = !_.some((e) => e.compareMarker in u), !f && !d) return !0;
+			if (d && i.isEqualSelectors(_, c)) return h.children.appendList(l.children), n.remove(t), !0;
+			let v = i.compareDeclarations(l.children, h.children);
+			if (v.eq.length) {
+				if (!v.ne1.length && !v.ne2.length) return f && (i.addSelectors(c, _), n.remove(m)), !0;
+				if (!s) if (v.ne1.length && !v.ne2.length) {
+					let e = a(c), t = o(v.eq);
+					d && e < t && (i.addSelectors(_, c), l.children.fromArray(v.ne1));
+				} else if (!v.ne1.length && v.ne2.length) {
+					let e = a(_), t = o(v.eq);
+					f && e < t && (i.addSelectors(c, _), h.children.fromArray(v.ne2));
+				} else {
+					let s = {
+						type: `SelectorList`,
+						loc: null,
+						children: i.addSelectors(_.copy(), c)
+					}, u = a(s.children) + 2;
+					if (o(v.eq) >= u) {
+						let i = n.createItem({
+							type: `Rule`,
+							loc: null,
+							prelude: s,
+							block: {
+								type: `Block`,
+								loc: null,
+								children: new r.List().fromArray(v.eq)
+							},
+							pseudoSignature: e.pseudoSignature
+						});
+						return l.children.fromArray(v.ne1), h.children.fromArray(v.ne2overrided), d ? n.insert(i, m) : n.insert(i, t), !0;
+					}
+				}
+			}
+			d &&= !_.some((e) => c.some((t) => t.compareMarker === e.compareMarker)), _.forEach((e) => {
+				u[e.compareMarker] = !0;
+			});
+		});
+	}
+	function c(e) {
+		r.walk(e, {
+			visit: `Rule`,
+			reverse: !0,
+			enter: s
+		});
+	}
+	n.exports = c;
+})), B = e(((e, t) => {
+	let n = j(), r = M(), i = P(), a = F(), o = I(), s = L(), c = R(), l = z();
+	function u(e, t) {
+		let u = n(e, t);
+		t.logger(`prepare`, e), r(e, t), t.logger(`mergeAtrule`, e), i(e), t.logger(`initialMergeRuleset`, e), a(e), t.logger(`disjoinRuleset`, e), o(e, u), t.logger(`restructShorthand`, e), s(e), t.logger(`restructBlock`, e), c(e), t.logger(`mergeRuleset`, e), l(e), t.logger(`restructRuleset`, e);
+	}
+	t.exports = u;
+})), V = e(((e, n) => {
+	let r = t(), a = i(), o = p(), s = D(), c = B();
+	function l(e, t) {
+		let n = new r.List(), i = !1, a;
+		return e.nextUntil(e.head, (e, r, o) => {
+			if (e.type === `Comment`) {
+				if (!t || e.value.charAt(0) !== `!`) {
+					o.remove(r);
+					return;
+				}
+				if (i || a) return !0;
+				o.remove(r), a = e;
+				return;
+			}
+			e.type !== `WhiteSpace` && (i = !0), n.insert(o.remove(r));
+		}), {
+			comment: a,
+			stylesheet: {
+				type: `StyleSheet`,
+				loc: null,
+				children: n
+			}
+		};
+	}
+	function u(e, t, n, i) {
+		i.logger(`Compress block #${n}`, null, !0);
+		let a = 1;
+		return e.type === `StyleSheet` && (e.firstAtrulesAllowed = t, e.id = a++), r.walk(e, {
+			visit: `Atrule`,
+			enter(e) {
+				e.block !== null && (e.block.id = a++);
+			}
+		}), i.logger(`init`, e), o(e, i), i.logger(`clean`, e), s(e), i.logger(`replace`, e), i.restructuring && c(e, i), e;
+	}
+	function d(e) {
+		let t = `comments` in e ? e.comments : `exclamation`;
+		return typeof t == `boolean` ? t = t ? `exclamation` : !1 : t !== `exclamation` && t !== `first-exclamation` && (t = !1), t;
+	}
+	function f(e) {
+		return `restructure` in e ? e.restructure : `restructuring` in e ? e.restructuring : !0;
+	}
+	function m(e) {
+		return new r.List().appendData({
+			type: `Rule`,
+			loc: null,
+			prelude: {
+				type: `SelectorList`,
+				loc: null,
+				children: new r.List().appendData({
+					type: `Selector`,
+					loc: null,
+					children: new r.List().appendData({
+						type: `TypeSelector`,
+						loc: null,
+						name: `x`
+					})
+				})
+			},
+			block: e
+		});
+	}
+	function h(e, t) {
+		e ||= {
+			type: `StyleSheet`,
+			loc: null,
+			children: new r.List()
+		}, t ||= {};
+		let n = {
+			logger: typeof t.logger == `function` ? t.logger : function() {},
+			restructuring: f(t),
+			forceMediaMerge: !!t.forceMediaMerge,
+			usage: t.usage ? a.buildIndex(t.usage) : !1
+		}, i = new r.List(), o = d(t), s = !0, c, p, h = 1, g;
+		t.clone && (e = r.clone(e)), e.type === `StyleSheet` ? (c = e.children, e.children = i) : c = m(e);
+		do {
+			if (p = l(c, !!o), u(p.stylesheet, s, h++, n), g = p.stylesheet.children, p.comment && (i.isEmpty || i.insert(r.List.createItem({
+				type: `Raw`,
+				value: `
+`
+			})), i.insert(r.List.createItem(p.comment)), g.isEmpty || i.insert(r.List.createItem({
+				type: `Raw`,
+				value: `
+`
+			}))), s && !g.isEmpty) {
+				let e = g.last;
+				(e.type !== `Atrule` || e.name !== `import` && e.name !== `charset`) && (s = !1);
+			}
+			o !== `exclamation` && (o = !1), i.appendList(g);
+		} while (!c.isEmpty);
+		return { ast: e };
+	}
+	n.exports = h;
+})), H = e(((e) => {
+	let n = t(), r = V(), i = k();
+	function a(e) {
+		let t = n.string.encode(e, !0), r = n.string.encode(e);
+		return t.length < r.length ? t : r;
+	}
+	let { lexer: o, tokenize: s, parse: c, generate: l, walk: u, find: d, findLast: f, findAll: p, fromPlainObject: m, toPlainObject: h } = n.fork({ node: {
+		String: { generate(e) {
+			this.token(n.tokenTypes.String, a(e.value));
+		} },
+		Url: { generate(e) {
+			let t = n.url.encode(e.value), r = a(e.value);
+			this.token(n.tokenTypes.Url, t.length <= r.length + 5 ? t : `url(` + r + `)`);
+		} }
+	} });
+	e.compress = r, e.specificity = i, e.find = d, e.findAll = p, e.findLast = f, e.fromPlainObject = m, e.generate = l, e.lexer = o, e.parse = c, e.toPlainObject = h, e.tokenize = s, e.walk = u;
+})), U = e(((e) => {
+	let t = A(), n = N();
+	e.processSelector = t, e.addSelectors = n.addSelectors, e.compareDeclarations = n.compareDeclarations, e.hasSimilarSelectors = n.hasSimilarSelectors, e.isEqualDeclarations = n.isEqualDeclarations, e.isEqualSelectors = n.isEqualSelectors, e.unsafeToSkipNode = n.unsafeToSkipNode;
+})), W = e(((e) => {
+	let t = r(), n = H(), i = U(), { parse: a, generate: o, compress: s } = n;
+	function c(e, t, n, r) {
+		return t.debug && console.error(`## ${e} done in %d ms\n`, Date.now() - n), r;
+	}
+	function l(e) {
+		let t;
+		return function(n, r) {
+			let i = n;
+			if (r && (i = `[${((Date.now() - t) / 1e3).toFixed(3)}s] ${i}`), e > 1 && r) {
+				let t = o(r);
+				e === 2 && t.length > 256 && (t = t.substr(0, 256) + `...`), i += `\n  ${t}\n`;
+			}
+			console.error(i), t = Date.now();
+		};
+	}
+	function u(e) {
+		return e = { ...e }, typeof e.logger != `function` && e.debug && (e.logger = l(e.debug)), e;
+	}
+	function d(e, t, n) {
+		Array.isArray(n) || (n = [n]), n.forEach((n) => n(e, t));
+	}
+	function f(e, t, n) {
+		n ||= {};
+		let r = n.filename || `<unknown>`, i, l = c(`parsing`, n, Date.now(), a(t, {
+			context: e,
+			filename: r,
+			positions: !!n.sourceMap
+		}));
+		n.beforeCompress && c(`beforeCompress`, n, Date.now(), d(l, n, n.beforeCompress));
+		let f = c(`compress`, n, Date.now(), s(l, u(n)));
+		return n.afterCompress && c(`afterCompress`, n, Date.now(), d(f, n, n.afterCompress)), i = n.sourceMap ? c(`generate(sourceMap: true)`, n, Date.now(), (() => {
+			let e = o(f.ast, { sourceMap: !0 });
+			return e.map._file = r, e.map.setSourceContent(r, t), e;
+		})()) : c(`generate`, n, Date.now(), {
+			css: o(f.ast),
+			map: null
+		}), i;
+	}
+	function p(e, t) {
+		return f(`stylesheet`, e, t);
+	}
+	function m(e, t) {
+		return f(`declarationList`, e, t);
+	}
+	e.version = t.version, e.syntax = n, e.utils = i, e.minify = p, e.minifyBlock = m;
+}));
+export { W as require_cjs };