cck-ui 0.0.1

package/dist/index.full.mjs

@@ -0,0 +1,2945 @@
+/*! CCK UI v0.0.1 */
+
+//#region ../../packages/cck-ui/make-installer.ts
+const INSTALLED_KEY = Symbol("INSTALLED_KEY");
+const makeInstaller = (components) => {
+	const install = (app) => {
+		if (app[INSTALLED_KEY]) return;
+		app[INSTALLED_KEY] = true;
+		components.forEach((c) => app.use(c));
+	};
+	return { install };
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/@ctrl+tinycolor@4.2.0/node_modules/@ctrl/tinycolor/dist/module/util.js
+function bound01(n, max) {
+	if (isOnePointZero(n)) n = "100%";
+	const isPercent = isPercentage(n);
+	n = max === 360 ? n : Math.min(max, Math.max(0, parseFloat(n)));
+	if (isPercent) n = parseInt(String(n * max), 10) / 100;
+	if (Math.abs(n - max) < 1e-6) return 1;
+	if (max === 360) n = (n < 0 ? n % max + max : n % max) / parseFloat(String(max));
+	else n = n % max / parseFloat(String(max));
+	return n;
+}
+function clamp01(val) {
+	return Math.min(1, Math.max(0, val));
+}
+function isOnePointZero(n) {
+	return typeof n === "string" && n.indexOf(".") !== -1 && parseFloat(n) === 1;
+}
+function isPercentage(n) {
+	return typeof n === "string" && n.indexOf("%") !== -1;
+}
+function boundAlpha(a) {
+	a = parseFloat(a);
+	if (isNaN(a) || a < 0 || a > 1) a = 1;
+	return a;
+}
+function convertToPercentage(n) {
+	if (Number(n) <= 1) return `${Number(n) * 100}%`;
+	return n;
+}
+function pad2(c) {
+	return c.length === 1 ? "0" + c : String(c);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/@ctrl+tinycolor@4.2.0/node_modules/@ctrl/tinycolor/dist/module/conversion.js
+function rgbToRgb(r, g, b) {
+	return {
+		r: bound01(r, 255) * 255,
+		g: bound01(g, 255) * 255,
+		b: bound01(b, 255) * 255
+	};
+}
+function rgbToHsl(r, g, b) {
+	r = bound01(r, 255);
+	g = bound01(g, 255);
+	b = bound01(b, 255);
+	const max = Math.max(r, g, b);
+	const min = Math.min(r, g, b);
+	let h = 0;
+	let s = 0;
+	const l = (max + min) / 2;
+	if (max === min) {
+		s = 0;
+		h = 0;
+	} else {
+		const d = max - min;
+		s = l > .5 ? d / (2 - max - min) : d / (max + min);
+		switch (max) {
+			case r:
+				h = (g - b) / d + (g < b ? 6 : 0);
+				break;
+			case g:
+				h = (b - r) / d + 2;
+				break;
+			case b:
+				h = (r - g) / d + 4;
+				break;
+			default: break;
+		}
+		h /= 6;
+	}
+	return {
+		h,
+		s,
+		l
+	};
+}
+function hue2rgb(p, q, t) {
+	if (t < 0) t += 1;
+	if (t > 1) t -= 1;
+	if (t < 1 / 6) return p + (q - p) * (6 * t);
+	if (t < 1 / 2) return q;
+	if (t < 2 / 3) return p + (q - p) * (2 / 3 - t) * 6;
+	return p;
+}
+function hslToRgb(h, s, l) {
+	let r;
+	let g;
+	let b;
+	h = bound01(h, 360);
+	s = bound01(s, 100);
+	l = bound01(l, 100);
+	if (s === 0) {
+		g = l;
+		b = l;
+		r = l;
+	} else {
+		const q = l < .5 ? l * (1 + s) : l + s - l * s;
+		const p = 2 * l - q;
+		r = hue2rgb(p, q, h + 1 / 3);
+		g = hue2rgb(p, q, h);
+		b = hue2rgb(p, q, h - 1 / 3);
+	}
+	return {
+		r: r * 255,
+		g: g * 255,
+		b: b * 255
+	};
+}
+function rgbToHsv(r, g, b) {
+	r = bound01(r, 255);
+	g = bound01(g, 255);
+	b = bound01(b, 255);
+	const max = Math.max(r, g, b);
+	const min = Math.min(r, g, b);
+	let h = 0;
+	const v = max;
+	const d = max - min;
+	const s = max === 0 ? 0 : d / max;
+	if (max === min) h = 0;
+	else {
+		switch (max) {
+			case r:
+				h = (g - b) / d + (g < b ? 6 : 0);
+				break;
+			case g:
+				h = (b - r) / d + 2;
+				break;
+			case b:
+				h = (r - g) / d + 4;
+				break;
+			default: break;
+		}
+		h /= 6;
+	}
+	return {
+		h,
+		s,
+		v
+	};
+}
+function hsvToRgb(h, s, v) {
+	h = bound01(h, 360) * 6;
+	s = bound01(s, 100);
+	v = bound01(v, 100);
+	const i = Math.floor(h);
+	const f = h - i;
+	const p = v * (1 - s);
+	const q = v * (1 - f * s);
+	const t = v * (1 - (1 - f) * s);
+	const mod = i % 6;
+	const r = [
+		v,
+		q,
+		p,
+		p,
+		t,
+		v
+	][mod];
+	const g = [
+		t,
+		v,
+		v,
+		q,
+		p,
+		p
+	][mod];
+	const b = [
+		p,
+		p,
+		t,
+		v,
+		v,
+		q
+	][mod];
+	return {
+		r: r * 255,
+		g: g * 255,
+		b: b * 255
+	};
+}
+function rgbToHex(r, g, b, allow3Char) {
+	const hex = [
+		pad2(Math.round(r).toString(16)),
+		pad2(Math.round(g).toString(16)),
+		pad2(Math.round(b).toString(16))
+	];
+	if (allow3Char && hex[0].startsWith(hex[0].charAt(1)) && hex[1].startsWith(hex[1].charAt(1)) && hex[2].startsWith(hex[2].charAt(1))) return hex[0].charAt(0) + hex[1].charAt(0) + hex[2].charAt(0);
+	return hex.join("");
+}
+function rgbaToHex(r, g, b, a, allow4Char) {
+	const hex = [
+		pad2(Math.round(r).toString(16)),
+		pad2(Math.round(g).toString(16)),
+		pad2(Math.round(b).toString(16)),
+		pad2(convertDecimalToHex(a))
+	];
+	if (allow4Char && hex[0].startsWith(hex[0].charAt(1)) && hex[1].startsWith(hex[1].charAt(1)) && hex[2].startsWith(hex[2].charAt(1)) && hex[3].startsWith(hex[3].charAt(1))) return hex[0].charAt(0) + hex[1].charAt(0) + hex[2].charAt(0) + hex[3].charAt(0);
+	return hex.join("");
+}
+function cmykToRgb(c, m, y, k) {
+	const cConv = c / 100;
+	const mConv = m / 100;
+	const yConv = y / 100;
+	const kConv = k / 100;
+	return {
+		r: 255 * (1 - cConv) * (1 - kConv),
+		g: 255 * (1 - mConv) * (1 - kConv),
+		b: 255 * (1 - yConv) * (1 - kConv)
+	};
+}
+function rgbToCmyk(r, g, b) {
+	let c = 1 - r / 255;
+	let m = 1 - g / 255;
+	let y = 1 - b / 255;
+	let k = Math.min(c, m, y);
+	if (k === 1) {
+		c = 0;
+		m = 0;
+		y = 0;
+	} else {
+		c = (c - k) / (1 - k) * 100;
+		m = (m - k) / (1 - k) * 100;
+		y = (y - k) / (1 - k) * 100;
+	}
+	k *= 100;
+	return {
+		c: Math.round(c),
+		m: Math.round(m),
+		y: Math.round(y),
+		k: Math.round(k)
+	};
+}
+function convertDecimalToHex(d) {
+	return Math.round(parseFloat(d) * 255).toString(16);
+}
+function convertHexToDecimal(h) {
+	return parseIntFromHex(h) / 255;
+}
+function parseIntFromHex(val) {
+	return parseInt(val, 16);
+}
+function numberInputToObject(color) {
+	return {
+		r: color >> 16,
+		g: (color & 65280) >> 8,
+		b: color & 255
+	};
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/@ctrl+tinycolor@4.2.0/node_modules/@ctrl/tinycolor/dist/module/css-color-names.js
+const names = {
+	aliceblue: "#f0f8ff",
+	antiquewhite: "#faebd7",
+	aqua: "#00ffff",
+	aquamarine: "#7fffd4",
+	azure: "#f0ffff",
+	beige: "#f5f5dc",
+	bisque: "#ffe4c4",
+	black: "#000000",
+	blanchedalmond: "#ffebcd",
+	blue: "#0000ff",
+	blueviolet: "#8a2be2",
+	brown: "#a52a2a",
+	burlywood: "#deb887",
+	cadetblue: "#5f9ea0",
+	chartreuse: "#7fff00",
+	chocolate: "#d2691e",
+	coral: "#ff7f50",
+	cornflowerblue: "#6495ed",
+	cornsilk: "#fff8dc",
+	crimson: "#dc143c",
+	cyan: "#00ffff",
+	darkblue: "#00008b",
+	darkcyan: "#008b8b",
+	darkgoldenrod: "#b8860b",
+	darkgray: "#a9a9a9",
+	darkgreen: "#006400",
+	darkgrey: "#a9a9a9",
+	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: "#ff00ff",
+	gainsboro: "#dcdcdc",
+	ghostwhite: "#f8f8ff",
+	goldenrod: "#daa520",
+	gold: "#ffd700",
+	gray: "#808080",
+	green: "#008000",
+	greenyellow: "#adff2f",
+	grey: "#808080",
+	honeydew: "#f0fff0",
+	hotpink: "#ff69b4",
+	indianred: "#cd5c5c",
+	indigo: "#4b0082",
+	ivory: "#fffff0",
+	khaki: "#f0e68c",
+	lavenderblush: "#fff0f5",
+	lavender: "#e6e6fa",
+	lawngreen: "#7cfc00",
+	lemonchiffon: "#fffacd",
+	lightblue: "#add8e6",
+	lightcoral: "#f08080",
+	lightcyan: "#e0ffff",
+	lightgoldenrodyellow: "#fafad2",
+	lightgray: "#d3d3d3",
+	lightgreen: "#90ee90",
+	lightgrey: "#d3d3d3",
+	lightpink: "#ffb6c1",
+	lightsalmon: "#ffa07a",
+	lightseagreen: "#20b2aa",
+	lightskyblue: "#87cefa",
+	lightslategray: "#778899",
+	lightslategrey: "#778899",
+	lightsteelblue: "#b0c4de",
+	lightyellow: "#ffffe0",
+	lime: "#00ff00",
+	limegreen: "#32cd32",
+	linen: "#faf0e6",
+	magenta: "#ff00ff",
+	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: "#663399",
+	red: "#ff0000",
+	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: "#ffffff",
+	whitesmoke: "#f5f5f5",
+	yellow: "#ffff00",
+	yellowgreen: "#9acd32"
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/@ctrl+tinycolor@4.2.0/node_modules/@ctrl/tinycolor/dist/module/format-input.js
+function inputToRGB(color) {
+	let rgb = {
+		r: 0,
+		g: 0,
+		b: 0
+	};
+	let a = 1;
+	let s = null;
+	let v = null;
+	let l = null;
+	let ok = false;
+	let format = false;
+	if (typeof color === "string") color = stringInputToObject(color);
+	if (typeof color === "object") {
+		if (isValidCSSUnit(color.r) && isValidCSSUnit(color.g) && isValidCSSUnit(color.b)) {
+			rgb = rgbToRgb(color.r, color.g, color.b);
+			ok = true;
+			format = String(color.r).substr(-1) === "%" ? "prgb" : "rgb";
+		} else if (isValidCSSUnit(color.h) && isValidCSSUnit(color.s) && isValidCSSUnit(color.v)) {
+			s = convertToPercentage(color.s);
+			v = convertToPercentage(color.v);
+			rgb = hsvToRgb(color.h, s, v);
+			ok = true;
+			format = "hsv";
+		} else if (isValidCSSUnit(color.h) && isValidCSSUnit(color.s) && isValidCSSUnit(color.l)) {
+			s = convertToPercentage(color.s);
+			l = convertToPercentage(color.l);
+			rgb = hslToRgb(color.h, s, l);
+			ok = true;
+			format = "hsl";
+		} else if (isValidCSSUnit(color.c) && isValidCSSUnit(color.m) && isValidCSSUnit(color.y) && isValidCSSUnit(color.k)) {
+			rgb = cmykToRgb(color.c, color.m, color.y, color.k);
+			ok = true;
+			format = "cmyk";
+		}
+		if (Object.prototype.hasOwnProperty.call(color, "a")) a = color.a;
+	}
+	a = boundAlpha(a);
+	return {
+		ok,
+		format: color.format || format,
+		r: Math.min(255, Math.max(rgb.r, 0)),
+		g: Math.min(255, Math.max(rgb.g, 0)),
+		b: Math.min(255, Math.max(rgb.b, 0)),
+		a
+	};
+}
+const matchers = {
+	CSS_UNIT: /* @__PURE__ */ new RegExp("(?:[-\\+]?\\d*\\.\\d+%?)|(?:[-\\+]?\\d+%?)"),
+	rgb: /* @__PURE__ */ new RegExp("rgb[\\s|\\(]+((?:[-\\+]?\\d*\\.\\d+%?)|(?:[-\\+]?\\d+%?))[,|\\s]+((?:[-\\+]?\\d*\\.\\d+%?)|(?:[-\\+]?\\d+%?))[,|\\s]+((?:[-\\+]?\\d*\\.\\d+%?)|(?:[-\\+]?\\d+%?))\\s*\\)?"),
+	rgba: /* @__PURE__ */ new RegExp("rgba[\\s|\\(]+((?:[-\\+]?\\d*\\.\\d+%?)|(?:[-\\+]?\\d+%?))[,|\\s]+((?:[-\\+]?\\d*\\.\\d+%?)|(?:[-\\+]?\\d+%?))[,|\\s]+((?:[-\\+]?\\d*\\.\\d+%?)|(?:[-\\+]?\\d+%?))[,|\\s]+((?:[-\\+]?\\d*\\.\\d+%?)|(?:[-\\+]?\\d+%?))\\s*\\)?"),
+	hsl: /* @__PURE__ */ new RegExp("hsl[\\s|\\(]+((?:[-\\+]?\\d*\\.\\d+%?)|(?:[-\\+]?\\d+%?))[,|\\s]+((?:[-\\+]?\\d*\\.\\d+%?)|(?:[-\\+]?\\d+%?))[,|\\s]+((?:[-\\+]?\\d*\\.\\d+%?)|(?:[-\\+]?\\d+%?))\\s*\\)?"),
+	hsla: /* @__PURE__ */ new RegExp("hsla[\\s|\\(]+((?:[-\\+]?\\d*\\.\\d+%?)|(?:[-\\+]?\\d+%?))[,|\\s]+((?:[-\\+]?\\d*\\.\\d+%?)|(?:[-\\+]?\\d+%?))[,|\\s]+((?:[-\\+]?\\d*\\.\\d+%?)|(?:[-\\+]?\\d+%?))[,|\\s]+((?:[-\\+]?\\d*\\.\\d+%?)|(?:[-\\+]?\\d+%?))\\s*\\)?"),
+	hsv: /* @__PURE__ */ new RegExp("hsv[\\s|\\(]+((?:[-\\+]?\\d*\\.\\d+%?)|(?:[-\\+]?\\d+%?))[,|\\s]+((?:[-\\+]?\\d*\\.\\d+%?)|(?:[-\\+]?\\d+%?))[,|\\s]+((?:[-\\+]?\\d*\\.\\d+%?)|(?:[-\\+]?\\d+%?))\\s*\\)?"),
+	hsva: /* @__PURE__ */ new RegExp("hsva[\\s|\\(]+((?:[-\\+]?\\d*\\.\\d+%?)|(?:[-\\+]?\\d+%?))[,|\\s]+((?:[-\\+]?\\d*\\.\\d+%?)|(?:[-\\+]?\\d+%?))[,|\\s]+((?:[-\\+]?\\d*\\.\\d+%?)|(?:[-\\+]?\\d+%?))[,|\\s]+((?:[-\\+]?\\d*\\.\\d+%?)|(?:[-\\+]?\\d+%?))\\s*\\)?"),
+	cmyk: /* @__PURE__ */ new RegExp("cmyk[\\s|\\(]+((?:[-\\+]?\\d*\\.\\d+%?)|(?:[-\\+]?\\d+%?))[,|\\s]+((?:[-\\+]?\\d*\\.\\d+%?)|(?:[-\\+]?\\d+%?))[,|\\s]+((?:[-\\+]?\\d*\\.\\d+%?)|(?:[-\\+]?\\d+%?))[,|\\s]+((?:[-\\+]?\\d*\\.\\d+%?)|(?:[-\\+]?\\d+%?))\\s*\\)?"),
+	hex3: /^#?([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/,
+	hex6: /^#?([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$/,
+	hex4: /^#?([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/,
+	hex8: /^#?([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$/
+};
+function stringInputToObject(color) {
+	color = color.trim().toLowerCase();
+	if (color.length === 0) return false;
+	let named = false;
+	if (names[color]) {
+		color = names[color];
+		named = true;
+	} else if (color === "transparent") return {
+		r: 0,
+		g: 0,
+		b: 0,
+		a: 0,
+		format: "name"
+	};
+	let match = matchers.rgb.exec(color);
+	if (match) return {
+		r: match[1],
+		g: match[2],
+		b: match[3]
+	};
+	match = matchers.rgba.exec(color);
+	if (match) return {
+		r: match[1],
+		g: match[2],
+		b: match[3],
+		a: match[4]
+	};
+	match = matchers.hsl.exec(color);
+	if (match) return {
+		h: match[1],
+		s: match[2],
+		l: match[3]
+	};
+	match = matchers.hsla.exec(color);
+	if (match) return {
+		h: match[1],
+		s: match[2],
+		l: match[3],
+		a: match[4]
+	};
+	match = matchers.hsv.exec(color);
+	if (match) return {
+		h: match[1],
+		s: match[2],
+		v: match[3]
+	};
+	match = matchers.hsva.exec(color);
+	if (match) return {
+		h: match[1],
+		s: match[2],
+		v: match[3],
+		a: match[4]
+	};
+	match = matchers.cmyk.exec(color);
+	if (match) return {
+		c: match[1],
+		m: match[2],
+		y: match[3],
+		k: match[4]
+	};
+	match = matchers.hex8.exec(color);
+	if (match) return {
+		r: parseIntFromHex(match[1]),
+		g: parseIntFromHex(match[2]),
+		b: parseIntFromHex(match[3]),
+		a: convertHexToDecimal(match[4]),
+		format: named ? "name" : "hex8"
+	};
+	match = matchers.hex6.exec(color);
+	if (match) return {
+		r: parseIntFromHex(match[1]),
+		g: parseIntFromHex(match[2]),
+		b: parseIntFromHex(match[3]),
+		format: named ? "name" : "hex"
+	};
+	match = matchers.hex4.exec(color);
+	if (match) return {
+		r: parseIntFromHex(match[1] + match[1]),
+		g: parseIntFromHex(match[2] + match[2]),
+		b: parseIntFromHex(match[3] + match[3]),
+		a: convertHexToDecimal(match[4] + match[4]),
+		format: named ? "name" : "hex8"
+	};
+	match = matchers.hex3.exec(color);
+	if (match) return {
+		r: parseIntFromHex(match[1] + match[1]),
+		g: parseIntFromHex(match[2] + match[2]),
+		b: parseIntFromHex(match[3] + match[3]),
+		format: named ? "name" : "hex"
+	};
+	return false;
+}
+function isValidCSSUnit(color) {
+	if (typeof color === "number") return !Number.isNaN(color);
+	return matchers.CSS_UNIT.test(color);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/@ctrl+tinycolor@4.2.0/node_modules/@ctrl/tinycolor/dist/module/index.js
+var TinyColor = class TinyColor {
+	constructor(color = "", opts = {}) {
+		if (color instanceof TinyColor) return color;
+		if (typeof color === "number") color = numberInputToObject(color);
+		this.originalInput = color;
+		const rgb = inputToRGB(color);
+		this.originalInput = color;
+		this.r = rgb.r;
+		this.g = rgb.g;
+		this.b = rgb.b;
+		this.a = rgb.a;
+		this.roundA = Math.round(100 * this.a) / 100;
+		this.format = opts.format ?? rgb.format;
+		this.gradientType = opts.gradientType;
+		if (this.r < 1) this.r = Math.round(this.r);
+		if (this.g < 1) this.g = Math.round(this.g);
+		if (this.b < 1) this.b = Math.round(this.b);
+		this.isValid = rgb.ok;
+	}
+	isDark() {
+		return this.getBrightness() < 128;
+	}
+	isLight() {
+		return !this.isDark();
+	}
+	getBrightness() {
+		const rgb = this.toRgb();
+		return (rgb.r * 299 + rgb.g * 587 + rgb.b * 114) / 1e3;
+	}
+	getLuminance() {
+		const rgb = this.toRgb();
+		let R;
+		let G;
+		let B;
+		const RsRGB = rgb.r / 255;
+		const GsRGB = rgb.g / 255;
+		const BsRGB = rgb.b / 255;
+		if (RsRGB <= .03928) R = RsRGB / 12.92;
+		else R = Math.pow((RsRGB + .055) / 1.055, 2.4);
+		if (GsRGB <= .03928) G = GsRGB / 12.92;
+		else G = Math.pow((GsRGB + .055) / 1.055, 2.4);
+		if (BsRGB <= .03928) B = BsRGB / 12.92;
+		else B = Math.pow((BsRGB + .055) / 1.055, 2.4);
+		return .2126 * R + .7152 * G + .0722 * B;
+	}
+	getAlpha() {
+		return this.a;
+	}
+	setAlpha(alpha) {
+		this.a = boundAlpha(alpha);
+		this.roundA = Math.round(100 * this.a) / 100;
+		return this;
+	}
+	isMonochrome() {
+		const { s } = this.toHsl();
+		return s === 0;
+	}
+	toHsv() {
+		const hsv = rgbToHsv(this.r, this.g, this.b);
+		return {
+			h: hsv.h * 360,
+			s: hsv.s,
+			v: hsv.v,
+			a: this.a
+		};
+	}
+	toHsvString() {
+		const hsv = rgbToHsv(this.r, this.g, this.b);
+		const h = Math.round(hsv.h * 360);
+		const s = Math.round(hsv.s * 100);
+		const v = Math.round(hsv.v * 100);
+		return this.a === 1 ? `hsv(${h}, ${s}%, ${v}%)` : `hsva(${h}, ${s}%, ${v}%, ${this.roundA})`;
+	}
+	toHsl() {
+		const hsl = rgbToHsl(this.r, this.g, this.b);
+		return {
+			h: hsl.h * 360,
+			s: hsl.s,
+			l: hsl.l,
+			a: this.a
+		};
+	}
+	toHslString() {
+		const hsl = rgbToHsl(this.r, this.g, this.b);
+		const h = Math.round(hsl.h * 360);
+		const s = Math.round(hsl.s * 100);
+		const l = Math.round(hsl.l * 100);
+		return this.a === 1 ? `hsl(${h}, ${s}%, ${l}%)` : `hsla(${h}, ${s}%, ${l}%, ${this.roundA})`;
+	}
+	toHex(allow3Char = false) {
+		return rgbToHex(this.r, this.g, this.b, allow3Char);
+	}
+	toHexString(allow3Char = false) {
+		return "#" + this.toHex(allow3Char);
+	}
+	toHex8(allow4Char = false) {
+		return rgbaToHex(this.r, this.g, this.b, this.a, allow4Char);
+	}
+	toHex8String(allow4Char = false) {
+		return "#" + this.toHex8(allow4Char);
+	}
+	toHexShortString(allowShortChar = false) {
+		return this.a === 1 ? this.toHexString(allowShortChar) : this.toHex8String(allowShortChar);
+	}
+	toRgb() {
+		return {
+			r: Math.round(this.r),
+			g: Math.round(this.g),
+			b: Math.round(this.b),
+			a: this.a
+		};
+	}
+	toRgbString() {
+		const r = Math.round(this.r);
+		const g = Math.round(this.g);
+		const b = Math.round(this.b);
+		return this.a === 1 ? `rgb(${r}, ${g}, ${b})` : `rgba(${r}, ${g}, ${b}, ${this.roundA})`;
+	}
+	toPercentageRgb() {
+		const fmt = (x) => `${Math.round(bound01(x, 255) * 100)}%`;
+		return {
+			r: fmt(this.r),
+			g: fmt(this.g),
+			b: fmt(this.b),
+			a: this.a
+		};
+	}
+	toPercentageRgbString() {
+		const rnd = (x) => Math.round(bound01(x, 255) * 100);
+		return this.a === 1 ? `rgb(${rnd(this.r)}%, ${rnd(this.g)}%, ${rnd(this.b)}%)` : `rgba(${rnd(this.r)}%, ${rnd(this.g)}%, ${rnd(this.b)}%, ${this.roundA})`;
+	}
+	toCmyk() {
+		return { ...rgbToCmyk(this.r, this.g, this.b) };
+	}
+	toCmykString() {
+		const { c, m, y, k } = rgbToCmyk(this.r, this.g, this.b);
+		return `cmyk(${c}, ${m}, ${y}, ${k})`;
+	}
+	toName() {
+		if (this.a === 0) return "transparent";
+		if (this.a < 1) return false;
+		const hex = "#" + rgbToHex(this.r, this.g, this.b, false);
+		for (const [key, value] of Object.entries(names)) if (hex === value) return key;
+		return false;
+	}
+	toString(format) {
+		const formatSet = Boolean(format);
+		format = format ?? this.format;
+		let formattedString = false;
+		const hasAlpha = this.a < 1 && this.a >= 0;
+		if (!formatSet && hasAlpha && (format.startsWith("hex") || format === "name")) {
+			if (format === "name" && this.a === 0) return this.toName();
+			return this.toRgbString();
+		}
+		if (format === "rgb") formattedString = this.toRgbString();
+		if (format === "prgb") formattedString = this.toPercentageRgbString();
+		if (format === "hex" || format === "hex6") formattedString = this.toHexString();
+		if (format === "hex3") formattedString = this.toHexString(true);
+		if (format === "hex4") formattedString = this.toHex8String(true);
+		if (format === "hex8") formattedString = this.toHex8String();
+		if (format === "name") formattedString = this.toName();
+		if (format === "hsl") formattedString = this.toHslString();
+		if (format === "hsv") formattedString = this.toHsvString();
+		if (format === "cmyk") formattedString = this.toCmykString();
+		return formattedString || this.toHexString();
+	}
+	toNumber() {
+		return (Math.round(this.r) << 16) + (Math.round(this.g) << 8) + Math.round(this.b);
+	}
+	clone() {
+		return new TinyColor(this.toString());
+	}
+	lighten(amount = 10) {
+		const hsl = this.toHsl();
+		hsl.l += amount / 100;
+		hsl.l = clamp01(hsl.l);
+		return new TinyColor(hsl);
+	}
+	brighten(amount = 10) {
+		const rgb = this.toRgb();
+		rgb.r = Math.max(0, Math.min(255, rgb.r - Math.round(255 * -(amount / 100))));
+		rgb.g = Math.max(0, Math.min(255, rgb.g - Math.round(255 * -(amount / 100))));
+		rgb.b = Math.max(0, Math.min(255, rgb.b - Math.round(255 * -(amount / 100))));
+		return new TinyColor(rgb);
+	}
+	darken(amount = 10) {
+		const hsl = this.toHsl();
+		hsl.l -= amount / 100;
+		hsl.l = clamp01(hsl.l);
+		return new TinyColor(hsl);
+	}
+	tint(amount = 10) {
+		return this.mix("white", amount);
+	}
+	shade(amount = 10) {
+		return this.mix("black", amount);
+	}
+	desaturate(amount = 10) {
+		const hsl = this.toHsl();
+		hsl.s -= amount / 100;
+		hsl.s = clamp01(hsl.s);
+		return new TinyColor(hsl);
+	}
+	saturate(amount = 10) {
+		const hsl = this.toHsl();
+		hsl.s += amount / 100;
+		hsl.s = clamp01(hsl.s);
+		return new TinyColor(hsl);
+	}
+	greyscale() {
+		return this.desaturate(100);
+	}
+	spin(amount) {
+		const hsl = this.toHsl();
+		const hue = (hsl.h + amount) % 360;
+		hsl.h = hue < 0 ? 360 + hue : hue;
+		return new TinyColor(hsl);
+	}
+	mix(color, amount = 50) {
+		const rgb1 = this.toRgb();
+		const rgb2 = new TinyColor(color).toRgb();
+		const p = amount / 100;
+		return new TinyColor({
+			r: (rgb2.r - rgb1.r) * p + rgb1.r,
+			g: (rgb2.g - rgb1.g) * p + rgb1.g,
+			b: (rgb2.b - rgb1.b) * p + rgb1.b,
+			a: (rgb2.a - rgb1.a) * p + rgb1.a
+		});
+	}
+	analogous(results = 6, slices = 30) {
+		const hsl = this.toHsl();
+		const part = 360 / slices;
+		const ret = [this];
+		for (hsl.h = (hsl.h - (part * results >> 1) + 720) % 360; --results;) {
+			hsl.h = (hsl.h + part) % 360;
+			ret.push(new TinyColor(hsl));
+		}
+		return ret;
+	}
+	complement() {
+		const hsl = this.toHsl();
+		hsl.h = (hsl.h + 180) % 360;
+		return new TinyColor(hsl);
+	}
+	monochromatic(results = 6) {
+		const hsv = this.toHsv();
+		const { h } = hsv;
+		const { s } = hsv;
+		let { v } = hsv;
+		const res = [];
+		const modification = 1 / results;
+		while (results--) {
+			res.push(new TinyColor({
+				h,
+				s,
+				v
+			}));
+			v = (v + modification) % 1;
+		}
+		return res;
+	}
+	splitcomplement() {
+		const hsl = this.toHsl();
+		const { h } = hsl;
+		return [
+			this,
+			new TinyColor({
+				h: (h + 72) % 360,
+				s: hsl.s,
+				l: hsl.l
+			}),
+			new TinyColor({
+				h: (h + 216) % 360,
+				s: hsl.s,
+				l: hsl.l
+			})
+		];
+	}
+	onBackground(background) {
+		const fg = this.toRgb();
+		const bg = new TinyColor(background).toRgb();
+		const alpha = fg.a + bg.a * (1 - fg.a);
+		return new TinyColor({
+			r: (fg.r * fg.a + bg.r * bg.a * (1 - fg.a)) / alpha,
+			g: (fg.g * fg.a + bg.g * bg.a * (1 - fg.a)) / alpha,
+			b: (fg.b * fg.a + bg.b * bg.a * (1 - fg.a)) / alpha,
+			a: alpha
+		});
+	}
+	triad() {
+		return this.polyad(3);
+	}
+	tetrad() {
+		return this.polyad(4);
+	}
+	polyad(n) {
+		const hsl = this.toHsl();
+		const { h } = hsl;
+		const result = [this];
+		const increment = 360 / n;
+		for (let i = 1; i < n; i++) result.push(new TinyColor({
+			h: (h + i * increment) % 360,
+			s: hsl.s,
+			l: hsl.l
+		}));
+		return result;
+	}
+	equals(color) {
+		const comparedColor = new TinyColor(color);
+		if (this.format === "cmyk" || comparedColor.format === "cmyk") return this.toCmykString() === comparedColor.toCmykString();
+		return this.toRgbString() === comparedColor.toRgbString();
+	}
+};
+
+//#endregion
+//#region ../../packages/utils/colors.ts
+const SATURATIONS = [
+	8,
+	15,
+	30,
+	55,
+	78,
+	95,
+	95,
+	92,
+	88,
+	85
+];
+const LIGHTNESSES = [
+	95,
+	88,
+	75,
+	62,
+	50,
+	40,
+	32,
+	27,
+	22,
+	18
+];
+const shadeCache = /* @__PURE__ */ new Map();
+function getNormalizedKey(colorStr) {
+	const tc = new TinyColor(colorStr);
+	if (!tc.isValid) return null;
+	return tc.toHexString();
+}
+function getFormat(colorStr) {
+	const fmt = new TinyColor(colorStr).format;
+	return fmt === "name" ? "hex" : fmt;
+}
+function generateColorShades(originalColor) {
+	const normKey = getNormalizedKey(originalColor);
+	if (!normKey) throw new Error(`Invalid color: ${originalColor}`);
+	const targetFormat = getFormat(originalColor);
+	const cacheKey = `${normKey}|${targetFormat}`;
+	if (shadeCache.has(cacheKey)) return shadeCache.get(cacheKey);
+	const base = new TinyColor(originalColor);
+	if (!base.isValid) throw new Error(`Invalid color: ${originalColor}`);
+	const { h } = base.toHsl();
+	const shades = [];
+	for (let i = 0; i < 10; i++) {
+		const color = new TinyColor({
+			h,
+			s: SATURATIONS[i] / 100,
+			l: LIGHTNESSES[i] / 100
+		});
+		let output;
+		switch (targetFormat) {
+			case "hex":
+				output = color.toHexString();
+				break;
+			case "rgb":
+				output = color.toRgbString();
+				break;
+			case "hsl":
+				output = color.toHslString();
+				break;
+			case "hsv":
+				output = color.toHsvString();
+				break;
+			default: output = color.toHexString();
+		}
+		shades.push(output);
+	}
+	shadeCache.set(cacheKey, shades);
+	return shades;
+}
+function setColorAlpha(originalColor, alpha) {
+	if (Number.isNaN(Number(alpha))) throw new TypeError(`Invalid alpha: ${alpha}`);
+	const tc = new TinyColor(originalColor);
+	if (!tc.isValid) throw new Error(`Invalid color: ${originalColor}`);
+	const targetFormat = getFormat(originalColor);
+	tc.setAlpha(alpha);
+	let output;
+	switch (targetFormat) {
+		case "rgb":
+			output = tc.toRgbString();
+			break;
+		case "hsl":
+			output = tc.toHslString();
+			break;
+		case "hsv":
+			output = tc.toHsvString();
+			break;
+		default: output = tc.toRgbString();
+	}
+	return output;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/@vue+shared@3.5.35/node_modules/@vue/shared/dist/shared.esm-bundler.js
+/**
+* @vue/shared v3.5.35
+* (c) 2018-present Yuxi (Evan) You and Vue contributors
+* @license MIT
+**/
+// @__NO_SIDE_EFFECTS__
+function makeMap(str) {
+	const map = /* @__PURE__ */ Object.create(null);
+	for (const key of str.split(",")) map[key] = 1;
+	return (val) => val in map;
+}
+const EMPTY_OBJ = {};
+const EMPTY_ARR = [];
+const NO = () => false;
+const isOn = (key) => key.charCodeAt(0) === 111 && key.charCodeAt(1) === 110 && (key.charCodeAt(2) > 122 || key.charCodeAt(2) < 97);
+const isModelListener = (key) => key.startsWith("onUpdate:");
+const extend = Object.assign;
+const hasOwnProperty$1 = Object.prototype.hasOwnProperty;
+const hasOwn = (val, key) => hasOwnProperty$1.call(val, key);
+const isArray = Array.isArray;
+const isMap = (val) => toTypeString(val) === "[object Map]";
+const isFunction = (val) => typeof val === "function";
+const isString = (val) => typeof val === "string";
+const isSymbol = (val) => typeof val === "symbol";
+const isObject = (val) => val !== null && typeof val === "object";
+const isPromise = (val) => {
+	return (isObject(val) || isFunction(val)) && isFunction(val.then) && isFunction(val.catch);
+};
+const objectToString = Object.prototype.toString;
+const toTypeString = (value) => objectToString.call(value);
+const toRawType = (value) => {
+	return toTypeString(value).slice(8, -1);
+};
+const isIntegerKey = (key) => isString(key) && key !== "NaN" && key[0] !== "-" && "" + parseInt(key, 10) === key;
+const cacheStringFunction = (fn) => {
+	const cache = /* @__PURE__ */ Object.create(null);
+	return ((str) => {
+		return cache[str] || (cache[str] = fn(str));
+	});
+};
+const camelizeRE = /-\w/g;
+const camelize = cacheStringFunction((str) => {
+	return str.replace(camelizeRE, (c) => c.slice(1).toUpperCase());
+});
+const hyphenateRE = /\B([A-Z])/g;
+const hyphenate = cacheStringFunction((str) => str.replace(hyphenateRE, "-$1").toLowerCase());
+const capitalize = cacheStringFunction((str) => {
+	return str.charAt(0).toUpperCase() + str.slice(1);
+});
+const toHandlerKey = cacheStringFunction((str) => {
+	return str ? `on${capitalize(str)}` : ``;
+});
+const hasChanged = (value, oldValue) => !Object.is(value, oldValue);
+let _globalThis;
+const getGlobalThis = () => {
+	return _globalThis || (_globalThis = typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : {});
+};
+function normalizeStyle(value) {
+	if (isArray(value)) {
+		const res = {};
+		for (let i = 0; i < value.length; i++) {
+			const item = value[i];
+			const normalized = isString(item) ? parseStringStyle(item) : normalizeStyle(item);
+			if (normalized) for (const key in normalized) res[key] = normalized[key];
+		}
+		return res;
+	} else if (isString(value) || isObject(value)) return value;
+}
+const listDelimiterRE = /;(?![^(]*\))/g;
+const propertyDelimiterRE = /:([^]+)/;
+const styleCommentRE = /\/\*[^]*?\*\//g;
+function parseStringStyle(cssText) {
+	const ret = {};
+	cssText.replace(styleCommentRE, "").split(listDelimiterRE).forEach((item) => {
+		if (item) {
+			const tmp = item.split(propertyDelimiterRE);
+			tmp.length > 1 && (ret[tmp[0].trim()] = tmp[1].trim());
+		}
+	});
+	return ret;
+}
+function normalizeClass(value) {
+	let res = "";
+	if (isString(value)) res = value;
+	else if (isArray(value)) for (let i = 0; i < value.length; i++) {
+		const normalized = normalizeClass(value[i]);
+		if (normalized) res += normalized + " ";
+	}
+	else if (isObject(value)) {
+		for (const name in value) if (value[name]) res += name + " ";
+	}
+	return res.trim();
+}
+const specialBooleanAttrs = `itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly`;
+const isBooleanAttr = /* @__PURE__ */ makeMap(specialBooleanAttrs + `,async,autofocus,autoplay,controls,default,defer,disabled,hidden,inert,loop,open,required,reversed,scoped,seamless,checked,muted,multiple,selected`);
+
+//#endregion
+//#region ../../packages/utils/types.ts
+const isUndefined = (val) => val === void 0;
+const isNumber = (val) => typeof val === "number";
+const isStringNumber = (val) => {
+	if (!isString(val)) return false;
+	return !Number.isNaN(Number(val));
+};
+
+//#endregion
+//#region ../../packages/utils/dom/style.ts
+function addUnit(value, defaultUnit = "px") {
+	if (!value && value !== 0) return "";
+	if (isNumber(value) || isStringNumber(value)) return `${value}${defaultUnit}`;
+	else if (isString(value)) return value;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/es-toolkit@1.47.0/node_modules/es-toolkit/dist/predicate/isPlainObject.mjs
+function isPlainObject(value) {
+	if (!value || typeof value !== "object") return false;
+	const proto = Object.getPrototypeOf(value);
+	if (!(proto === null || proto === Object.prototype || Object.getPrototypeOf(proto) === null)) return false;
+	return Object.prototype.toString.call(value) === "[object Object]";
+}
+
+//#endregion
+//#region ../../packages/utils/vue/install.ts
+const withPropsDefaultSetter = (target) => {
+	const _p = target.props;
+	const props = isArray(_p) ? Object.fromEntries(_p.map((key) => [key, {}])) : _p;
+	target.setPropsDefaults = (defaults) => {
+		if (!props) return;
+		for (const [key, value] of Object.entries(defaults)) {
+			const prop = props[key];
+			if (!hasOwn(props, key)) continue;
+			if (isPlainObject(prop)) {
+				props[key] = {
+					...props,
+					default: value
+				};
+				continue;
+			}
+			props[key] = {
+				type: prop,
+				default: value
+			};
+		}
+		target.props = props;
+	};
+};
+const withInstall = (main, extra) => {
+	main.install = (app) => {
+		for (const comp of [main, ...Object.values(extra ?? [])]) app.component(comp.name, comp);
+	};
+	if (extra) for (const [key, comp] of Object.entries(extra)) main[key] = comp;
+	withPropsDefaultSetter(main);
+	return main;
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/@vue+reactivity@3.5.35/node_modules/@vue/reactivity/dist/reactivity.esm-bundler.js
+/**
+* @vue/reactivity v3.5.35
+* (c) 2018-present Yuxi (Evan) You and Vue contributors
+* @license MIT
+**/
+let activeSub;
+let batchDepth = 0;
+let batchedSub;
+let batchedComputed;
+function batch(sub, isComputed = false) {
+	sub.flags |= 8;
+	if (isComputed) {
+		sub.next = batchedComputed;
+		batchedComputed = sub;
+		return;
+	}
+	sub.next = batchedSub;
+	batchedSub = sub;
+}
+function startBatch() {
+	batchDepth++;
+}
+function endBatch() {
+	if (--batchDepth > 0) return;
+	if (batchedComputed) {
+		let e = batchedComputed;
+		batchedComputed = void 0;
+		while (e) {
+			const next = e.next;
+			e.next = void 0;
+			e.flags &= -9;
+			e = next;
+		}
+	}
+	let error;
+	while (batchedSub) {
+		let e = batchedSub;
+		batchedSub = void 0;
+		while (e) {
+			const next = e.next;
+			e.next = void 0;
+			e.flags &= -9;
+			if (e.flags & 1) try {
+				e.trigger();
+			} catch (err) {
+				if (!error) error = err;
+			}
+			e = next;
+		}
+	}
+	if (error) throw error;
+}
+function prepareDeps(sub) {
+	for (let link = sub.deps; link; link = link.nextDep) {
+		link.version = -1;
+		link.prevActiveLink = link.dep.activeLink;
+		link.dep.activeLink = link;
+	}
+}
+function cleanupDeps(sub) {
+	let head;
+	let tail = sub.depsTail;
+	let link = tail;
+	while (link) {
+		const prev = link.prevDep;
+		if (link.version === -1) {
+			if (link === tail) tail = prev;
+			removeSub(link);
+			removeDep(link);
+		} else head = link;
+		link.dep.activeLink = link.prevActiveLink;
+		link.prevActiveLink = void 0;
+		link = prev;
+	}
+	sub.deps = head;
+	sub.depsTail = tail;
+}
+function isDirty(sub) {
+	for (let link = sub.deps; link; link = link.nextDep) if (link.dep.version !== link.version || link.dep.computed && (refreshComputed(link.dep.computed) || link.dep.version !== link.version)) return true;
+	if (sub._dirty) return true;
+	return false;
+}
+function refreshComputed(computed) {
+	if (computed.flags & 4 && !(computed.flags & 16)) return;
+	computed.flags &= -17;
+	if (computed.globalVersion === globalVersion) return;
+	computed.globalVersion = globalVersion;
+	if (!computed.isSSR && computed.flags & 128 && (!computed.deps && !computed._dirty || !isDirty(computed))) return;
+	computed.flags |= 2;
+	const dep = computed.dep;
+	const prevSub = activeSub;
+	const prevShouldTrack = shouldTrack;
+	activeSub = computed;
+	shouldTrack = true;
+	try {
+		prepareDeps(computed);
+		const value = computed.fn(computed._value);
+		if (dep.version === 0 || hasChanged(value, computed._value)) {
+			computed.flags |= 128;
+			computed._value = value;
+			dep.version++;
+		}
+	} catch (err) {
+		dep.version++;
+		throw err;
+	} finally {
+		activeSub = prevSub;
+		shouldTrack = prevShouldTrack;
+		cleanupDeps(computed);
+		computed.flags &= -3;
+	}
+}
+function removeSub(link, soft = false) {
+	const { dep, prevSub, nextSub } = link;
+	if (prevSub) {
+		prevSub.nextSub = nextSub;
+		link.prevSub = void 0;
+	}
+	if (nextSub) {
+		nextSub.prevSub = prevSub;
+		link.nextSub = void 0;
+	}
+	if (dep.subs === link) {
+		dep.subs = prevSub;
+		if (!prevSub && dep.computed) {
+			dep.computed.flags &= -5;
+			for (let l = dep.computed.deps; l; l = l.nextDep) removeSub(l, true);
+		}
+	}
+	if (!soft && !--dep.sc && dep.map) dep.map.delete(dep.key);
+}
+function removeDep(link) {
+	const { prevDep, nextDep } = link;
+	if (prevDep) {
+		prevDep.nextDep = nextDep;
+		link.prevDep = void 0;
+	}
+	if (nextDep) {
+		nextDep.prevDep = prevDep;
+		link.nextDep = void 0;
+	}
+}
+let shouldTrack = true;
+const trackStack = [];
+function pauseTracking() {
+	trackStack.push(shouldTrack);
+	shouldTrack = false;
+}
+function resetTracking() {
+	const last = trackStack.pop();
+	shouldTrack = last === void 0 ? true : last;
+}
+let globalVersion = 0;
+var Link = class {
+	constructor(sub, dep) {
+		this.sub = sub;
+		this.dep = dep;
+		this.version = dep.version;
+		this.nextDep = this.prevDep = this.nextSub = this.prevSub = this.prevActiveLink = void 0;
+	}
+};
+var Dep = class {
+	constructor(computed) {
+		this.computed = computed;
+		this.version = 0;
+		this.activeLink = void 0;
+		this.subs = void 0;
+		this.map = void 0;
+		this.key = void 0;
+		this.sc = 0;
+		this.__v_skip = true;
+	}
+	track(debugInfo) {
+		if (!activeSub || !shouldTrack || activeSub === this.computed) return;
+		let link = this.activeLink;
+		if (link === void 0 || link.sub !== activeSub) {
+			link = this.activeLink = new Link(activeSub, this);
+			if (!activeSub.deps) activeSub.deps = activeSub.depsTail = link;
+			else {
+				link.prevDep = activeSub.depsTail;
+				activeSub.depsTail.nextDep = link;
+				activeSub.depsTail = link;
+			}
+			addSub(link);
+		} else if (link.version === -1) {
+			link.version = this.version;
+			if (link.nextDep) {
+				const next = link.nextDep;
+				next.prevDep = link.prevDep;
+				if (link.prevDep) link.prevDep.nextDep = next;
+				link.prevDep = activeSub.depsTail;
+				link.nextDep = void 0;
+				activeSub.depsTail.nextDep = link;
+				activeSub.depsTail = link;
+				if (activeSub.deps === link) activeSub.deps = next;
+			}
+		}
+		return link;
+	}
+	trigger(debugInfo) {
+		this.version++;
+		globalVersion++;
+		this.notify(debugInfo);
+	}
+	notify(debugInfo) {
+		startBatch();
+		try {
+			for (let link = this.subs; link; link = link.prevSub) if (link.sub.notify()) link.sub.dep.notify();
+		} finally {
+			endBatch();
+		}
+	}
+};
+function addSub(link) {
+	link.dep.sc++;
+	if (link.sub.flags & 4) {
+		const computed = link.dep.computed;
+		if (computed && !link.dep.subs) {
+			computed.flags |= 20;
+			for (let l = computed.deps; l; l = l.nextDep) addSub(l);
+		}
+		const currentTail = link.dep.subs;
+		if (currentTail !== link) {
+			link.prevSub = currentTail;
+			if (currentTail) currentTail.nextSub = link;
+		}
+		link.dep.subs = link;
+	}
+}
+const targetMap = /* @__PURE__ */ new WeakMap();
+const ITERATE_KEY = /* @__PURE__ */ Symbol("");
+const MAP_KEY_ITERATE_KEY = /* @__PURE__ */ Symbol("");
+const ARRAY_ITERATE_KEY = /* @__PURE__ */ Symbol("");
+function track(target, type, key) {
+	if (shouldTrack && activeSub) {
+		let depsMap = targetMap.get(target);
+		if (!depsMap) targetMap.set(target, depsMap = /* @__PURE__ */ new Map());
+		let dep = depsMap.get(key);
+		if (!dep) {
+			depsMap.set(key, dep = new Dep());
+			dep.map = depsMap;
+			dep.key = key;
+		}
+		dep.track();
+	}
+}
+function trigger(target, type, key, newValue, oldValue, oldTarget) {
+	const depsMap = targetMap.get(target);
+	if (!depsMap) {
+		globalVersion++;
+		return;
+	}
+	const run = (dep) => {
+		if (dep) dep.trigger();
+	};
+	startBatch();
+	if (type === "clear") depsMap.forEach(run);
+	else {
+		const targetIsArray = isArray(target);
+		const isArrayIndex = targetIsArray && isIntegerKey(key);
+		if (targetIsArray && key === "length") {
+			const newLength = Number(newValue);
+			depsMap.forEach((dep, key2) => {
+				if (key2 === "length" || key2 === ARRAY_ITERATE_KEY || !isSymbol(key2) && key2 >= newLength) run(dep);
+			});
+		} else {
+			if (key !== void 0 || depsMap.has(void 0)) run(depsMap.get(key));
+			if (isArrayIndex) run(depsMap.get(ARRAY_ITERATE_KEY));
+			switch (type) {
+				case "add":
+					if (!targetIsArray) {
+						run(depsMap.get(ITERATE_KEY));
+						if (isMap(target)) run(depsMap.get(MAP_KEY_ITERATE_KEY));
+					} else if (isArrayIndex) run(depsMap.get("length"));
+					break;
+				case "delete":
+					if (!targetIsArray) {
+						run(depsMap.get(ITERATE_KEY));
+						if (isMap(target)) run(depsMap.get(MAP_KEY_ITERATE_KEY));
+					}
+					break;
+				case "set":
+					if (isMap(target)) run(depsMap.get(ITERATE_KEY));
+					break;
+			}
+		}
+	}
+	endBatch();
+}
+function reactiveReadArray(array) {
+	const raw = /* @__PURE__ */ toRaw(array);
+	if (raw === array) return raw;
+	track(raw, "iterate", ARRAY_ITERATE_KEY);
+	return /* @__PURE__ */ isShallow(array) ? raw : raw.map(toReactive);
+}
+function shallowReadArray(arr) {
+	track(arr = /* @__PURE__ */ toRaw(arr), "iterate", ARRAY_ITERATE_KEY);
+	return arr;
+}
+function toWrapped(target, item) {
+	if (/* @__PURE__ */ isReadonly(target)) return /* @__PURE__ */ isReactive(target) ? toReadonly(toReactive(item)) : toReadonly(item);
+	return toReactive(item);
+}
+const arrayInstrumentations = {
+	__proto__: null,
+	[Symbol.iterator]() {
+		return iterator(this, Symbol.iterator, (item) => toWrapped(this, item));
+	},
+	concat(...args) {
+		return reactiveReadArray(this).concat(...args.map((x) => isArray(x) ? reactiveReadArray(x) : x));
+	},
+	entries() {
+		return iterator(this, "entries", (value) => {
+			value[1] = toWrapped(this, value[1]);
+			return value;
+		});
+	},
+	every(fn, thisArg) {
+		return apply(this, "every", fn, thisArg, void 0, arguments);
+	},
+	filter(fn, thisArg) {
+		return apply(this, "filter", fn, thisArg, (v) => v.map((item) => toWrapped(this, item)), arguments);
+	},
+	find(fn, thisArg) {
+		return apply(this, "find", fn, thisArg, (item) => toWrapped(this, item), arguments);
+	},
+	findIndex(fn, thisArg) {
+		return apply(this, "findIndex", fn, thisArg, void 0, arguments);
+	},
+	findLast(fn, thisArg) {
+		return apply(this, "findLast", fn, thisArg, (item) => toWrapped(this, item), arguments);
+	},
+	findLastIndex(fn, thisArg) {
+		return apply(this, "findLastIndex", fn, thisArg, void 0, arguments);
+	},
+	forEach(fn, thisArg) {
+		return apply(this, "forEach", fn, thisArg, void 0, arguments);
+	},
+	includes(...args) {
+		return searchProxy(this, "includes", args);
+	},
+	indexOf(...args) {
+		return searchProxy(this, "indexOf", args);
+	},
+	join(separator) {
+		return reactiveReadArray(this).join(separator);
+	},
+	lastIndexOf(...args) {
+		return searchProxy(this, "lastIndexOf", args);
+	},
+	map(fn, thisArg) {
+		return apply(this, "map", fn, thisArg, void 0, arguments);
+	},
+	pop() {
+		return noTracking(this, "pop");
+	},
+	push(...args) {
+		return noTracking(this, "push", args);
+	},
+	reduce(fn, ...args) {
+		return reduce(this, "reduce", fn, args);
+	},
+	reduceRight(fn, ...args) {
+		return reduce(this, "reduceRight", fn, args);
+	},
+	shift() {
+		return noTracking(this, "shift");
+	},
+	some(fn, thisArg) {
+		return apply(this, "some", fn, thisArg, void 0, arguments);
+	},
+	splice(...args) {
+		return noTracking(this, "splice", args);
+	},
+	toReversed() {
+		return reactiveReadArray(this).toReversed();
+	},
+	toSorted(comparer) {
+		return reactiveReadArray(this).toSorted(comparer);
+	},
+	toSpliced(...args) {
+		return reactiveReadArray(this).toSpliced(...args);
+	},
+	unshift(...args) {
+		return noTracking(this, "unshift", args);
+	},
+	values() {
+		return iterator(this, "values", (item) => toWrapped(this, item));
+	}
+};
+function iterator(self, method, wrapValue) {
+	const arr = shallowReadArray(self);
+	const iter = arr[method]();
+	if (arr !== self && !/* @__PURE__ */ isShallow(self)) {
+		iter._next = iter.next;
+		iter.next = () => {
+			const result = iter._next();
+			if (!result.done) result.value = wrapValue(result.value);
+			return result;
+		};
+	}
+	return iter;
+}
+const arrayProto = Array.prototype;
+function apply(self, method, fn, thisArg, wrappedRetFn, args) {
+	const arr = shallowReadArray(self);
+	const needsWrap = arr !== self && !/* @__PURE__ */ isShallow(self);
+	const methodFn = arr[method];
+	if (methodFn !== arrayProto[method]) {
+		const result2 = methodFn.apply(self, args);
+		return needsWrap ? toReactive(result2) : result2;
+	}
+	let wrappedFn = fn;
+	if (arr !== self) {
+		if (needsWrap) wrappedFn = function(item, index) {
+			return fn.call(this, toWrapped(self, item), index, self);
+		};
+		else if (fn.length > 2) wrappedFn = function(item, index) {
+			return fn.call(this, item, index, self);
+		};
+	}
+	const result = methodFn.call(arr, wrappedFn, thisArg);
+	return needsWrap && wrappedRetFn ? wrappedRetFn(result) : result;
+}
+function reduce(self, method, fn, args) {
+	const arr = shallowReadArray(self);
+	const needsWrap = arr !== self && !/* @__PURE__ */ isShallow(self);
+	let wrappedFn = fn;
+	let wrapInitialAccumulator = false;
+	if (arr !== self) {
+		if (needsWrap) {
+			wrapInitialAccumulator = args.length === 0;
+			wrappedFn = function(acc, item, index) {
+				if (wrapInitialAccumulator) {
+					wrapInitialAccumulator = false;
+					acc = toWrapped(self, acc);
+				}
+				return fn.call(this, acc, toWrapped(self, item), index, self);
+			};
+		} else if (fn.length > 3) wrappedFn = function(acc, item, index) {
+			return fn.call(this, acc, item, index, self);
+		};
+	}
+	const result = arr[method](wrappedFn, ...args);
+	return wrapInitialAccumulator ? toWrapped(self, result) : result;
+}
+function searchProxy(self, method, args) {
+	const arr = /* @__PURE__ */ toRaw(self);
+	track(arr, "iterate", ARRAY_ITERATE_KEY);
+	const res = arr[method](...args);
+	if ((res === -1 || res === false) && /* @__PURE__ */ isProxy(args[0])) {
+		args[0] = /* @__PURE__ */ toRaw(args[0]);
+		return arr[method](...args);
+	}
+	return res;
+}
+function noTracking(self, method, args = []) {
+	pauseTracking();
+	startBatch();
+	const res = (/* @__PURE__ */ toRaw(self))[method].apply(self, args);
+	endBatch();
+	resetTracking();
+	return res;
+}
+const isNonTrackableKeys = /* @__PURE__ */ makeMap(`__proto__,__v_isRef,__isVue`);
+const builtInSymbols = new Set(/* @__PURE__ */ Object.getOwnPropertyNames(Symbol).filter((key) => key !== "arguments" && key !== "caller").map((key) => Symbol[key]).filter(isSymbol));
+function hasOwnProperty(key) {
+	if (!isSymbol(key)) key = String(key);
+	const obj = /* @__PURE__ */ toRaw(this);
+	track(obj, "has", key);
+	return obj.hasOwnProperty(key);
+}
+var BaseReactiveHandler = class {
+	constructor(_isReadonly = false, _isShallow = false) {
+		this._isReadonly = _isReadonly;
+		this._isShallow = _isShallow;
+	}
+	get(target, key, receiver) {
+		if (key === "__v_skip") return target["__v_skip"];
+		const isReadonly2 = this._isReadonly, isShallow2 = this._isShallow;
+		if (key === "__v_isReactive") return !isReadonly2;
+		else if (key === "__v_isReadonly") return isReadonly2;
+		else if (key === "__v_isShallow") return isShallow2;
+		else if (key === "__v_raw") {
+			if (receiver === (isReadonly2 ? isShallow2 ? shallowReadonlyMap : readonlyMap : isShallow2 ? shallowReactiveMap : reactiveMap).get(target) || Object.getPrototypeOf(target) === Object.getPrototypeOf(receiver)) return target;
+			return;
+		}
+		const targetIsArray = isArray(target);
+		if (!isReadonly2) {
+			let fn;
+			if (targetIsArray && (fn = arrayInstrumentations[key])) return fn;
+			if (key === "hasOwnProperty") return hasOwnProperty;
+		}
+		const res = Reflect.get(target, key, /* @__PURE__ */ isRef(target) ? target : receiver);
+		if (isSymbol(key) ? builtInSymbols.has(key) : isNonTrackableKeys(key)) return res;
+		if (!isReadonly2) track(target, "get", key);
+		if (isShallow2) return res;
+		if (/* @__PURE__ */ isRef(res)) {
+			const value = targetIsArray && isIntegerKey(key) ? res : res.value;
+			return isReadonly2 && isObject(value) ? /* @__PURE__ */ readonly(value) : value;
+		}
+		if (isObject(res)) return isReadonly2 ? /* @__PURE__ */ readonly(res) : /* @__PURE__ */ reactive(res);
+		return res;
+	}
+};
+var MutableReactiveHandler = class extends BaseReactiveHandler {
+	constructor(isShallow2 = false) {
+		super(false, isShallow2);
+	}
+	set(target, key, value, receiver) {
+		let oldValue = target[key];
+		const isArrayWithIntegerKey = isArray(target) && isIntegerKey(key);
+		if (!this._isShallow) {
+			const isOldValueReadonly = /* @__PURE__ */ isReadonly(oldValue);
+			if (!/* @__PURE__ */ isShallow(value) && !/* @__PURE__ */ isReadonly(value)) {
+				oldValue = /* @__PURE__ */ toRaw(oldValue);
+				value = /* @__PURE__ */ toRaw(value);
+			}
+			if (!isArrayWithIntegerKey && /* @__PURE__ */ isRef(oldValue) && !/* @__PURE__ */ isRef(value)) if (isOldValueReadonly) return true;
+			else {
+				oldValue.value = value;
+				return true;
+			}
+		}
+		const hadKey = isArrayWithIntegerKey ? Number(key) < target.length : hasOwn(target, key);
+		const result = Reflect.set(target, key, value, /* @__PURE__ */ isRef(target) ? target : receiver);
+		if (target === /* @__PURE__ */ toRaw(receiver)) {
+			if (!hadKey) trigger(target, "add", key, value);
+			else if (hasChanged(value, oldValue)) trigger(target, "set", key, value, oldValue);
+		}
+		return result;
+	}
+	deleteProperty(target, key) {
+		const hadKey = hasOwn(target, key);
+		const oldValue = target[key];
+		const result = Reflect.deleteProperty(target, key);
+		if (result && hadKey) trigger(target, "delete", key, void 0, oldValue);
+		return result;
+	}
+	has(target, key) {
+		const result = Reflect.has(target, key);
+		if (!isSymbol(key) || !builtInSymbols.has(key)) track(target, "has", key);
+		return result;
+	}
+	ownKeys(target) {
+		track(target, "iterate", isArray(target) ? "length" : ITERATE_KEY);
+		return Reflect.ownKeys(target);
+	}
+};
+var ReadonlyReactiveHandler = class extends BaseReactiveHandler {
+	constructor(isShallow2 = false) {
+		super(true, isShallow2);
+	}
+	set(target, key) {
+		return true;
+	}
+	deleteProperty(target, key) {
+		return true;
+	}
+};
+const mutableHandlers = /* @__PURE__ */ new MutableReactiveHandler();
+const readonlyHandlers = /* @__PURE__ */ new ReadonlyReactiveHandler();
+const toShallow = (value) => value;
+const getProto = (v) => Reflect.getPrototypeOf(v);
+function createIterableMethod(method, isReadonly2, isShallow2) {
+	return function(...args) {
+		const target = this["__v_raw"];
+		const rawTarget = /* @__PURE__ */ toRaw(target);
+		const targetIsMap = isMap(rawTarget);
+		const isPair = method === "entries" || method === Symbol.iterator && targetIsMap;
+		const isKeyOnly = method === "keys" && targetIsMap;
+		const innerIterator = target[method](...args);
+		const wrap = isShallow2 ? toShallow : isReadonly2 ? toReadonly : toReactive;
+		!isReadonly2 && track(rawTarget, "iterate", isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY);
+		return extend(Object.create(innerIterator), { next() {
+			const { value, done } = innerIterator.next();
+			return done ? {
+				value,
+				done
+			} : {
+				value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value),
+				done
+			};
+		} });
+	};
+}
+function createReadonlyMethod(type) {
+	return function(...args) {
+		return type === "delete" ? false : type === "clear" ? void 0 : this;
+	};
+}
+function createInstrumentations(readonly, shallow) {
+	const instrumentations = {
+		get(key) {
+			const target = this["__v_raw"];
+			const rawTarget = /* @__PURE__ */ toRaw(target);
+			const rawKey = /* @__PURE__ */ toRaw(key);
+			if (!readonly) {
+				if (hasChanged(key, rawKey)) track(rawTarget, "get", key);
+				track(rawTarget, "get", rawKey);
+			}
+			const { has } = getProto(rawTarget);
+			const wrap = shallow ? toShallow : readonly ? toReadonly : toReactive;
+			if (has.call(rawTarget, key)) return wrap(target.get(key));
+			else if (has.call(rawTarget, rawKey)) return wrap(target.get(rawKey));
+			else if (target !== rawTarget) target.get(key);
+		},
+		get size() {
+			const target = this["__v_raw"];
+			!readonly && track(/* @__PURE__ */ toRaw(target), "iterate", ITERATE_KEY);
+			return target.size;
+		},
+		has(key) {
+			const target = this["__v_raw"];
+			const rawTarget = /* @__PURE__ */ toRaw(target);
+			const rawKey = /* @__PURE__ */ toRaw(key);
+			if (!readonly) {
+				if (hasChanged(key, rawKey)) track(rawTarget, "has", key);
+				track(rawTarget, "has", rawKey);
+			}
+			return key === rawKey ? target.has(key) : target.has(key) || target.has(rawKey);
+		},
+		forEach(callback, thisArg) {
+			const observed = this;
+			const target = observed["__v_raw"];
+			const rawTarget = /* @__PURE__ */ toRaw(target);
+			const wrap = shallow ? toShallow : readonly ? toReadonly : toReactive;
+			!readonly && track(rawTarget, "iterate", ITERATE_KEY);
+			return target.forEach((value, key) => {
+				return callback.call(thisArg, wrap(value), wrap(key), observed);
+			});
+		}
+	};
+	extend(instrumentations, readonly ? {
+		add: createReadonlyMethod("add"),
+		set: createReadonlyMethod("set"),
+		delete: createReadonlyMethod("delete"),
+		clear: createReadonlyMethod("clear")
+	} : {
+		add(value) {
+			const target = /* @__PURE__ */ toRaw(this);
+			const proto = getProto(target);
+			const rawValue = /* @__PURE__ */ toRaw(value);
+			const valueToAdd = !shallow && !/* @__PURE__ */ isShallow(value) && !/* @__PURE__ */ isReadonly(value) ? rawValue : value;
+			if (!(proto.has.call(target, valueToAdd) || hasChanged(value, valueToAdd) && proto.has.call(target, value) || hasChanged(rawValue, valueToAdd) && proto.has.call(target, rawValue))) {
+				target.add(valueToAdd);
+				trigger(target, "add", valueToAdd, valueToAdd);
+			}
+			return this;
+		},
+		set(key, value) {
+			if (!shallow && !/* @__PURE__ */ isShallow(value) && !/* @__PURE__ */ isReadonly(value)) value = /* @__PURE__ */ toRaw(value);
+			const target = /* @__PURE__ */ toRaw(this);
+			const { has, get } = getProto(target);
+			let hadKey = has.call(target, key);
+			if (!hadKey) {
+				key = /* @__PURE__ */ toRaw(key);
+				hadKey = has.call(target, key);
+			}
+			const oldValue = get.call(target, key);
+			target.set(key, value);
+			if (!hadKey) trigger(target, "add", key, value);
+			else if (hasChanged(value, oldValue)) trigger(target, "set", key, value, oldValue);
+			return this;
+		},
+		delete(key) {
+			const target = /* @__PURE__ */ toRaw(this);
+			const { has, get } = getProto(target);
+			let hadKey = has.call(target, key);
+			if (!hadKey) {
+				key = /* @__PURE__ */ toRaw(key);
+				hadKey = has.call(target, key);
+			}
+			const oldValue = get ? get.call(target, key) : void 0;
+			const result = target.delete(key);
+			if (hadKey) trigger(target, "delete", key, void 0, oldValue);
+			return result;
+		},
+		clear() {
+			const target = /* @__PURE__ */ toRaw(this);
+			const hadItems = target.size !== 0;
+			const oldTarget = void 0;
+			const result = target.clear();
+			if (hadItems) trigger(target, "clear", void 0, void 0, oldTarget);
+			return result;
+		}
+	});
+	[
+		"keys",
+		"values",
+		"entries",
+		Symbol.iterator
+	].forEach((method) => {
+		instrumentations[method] = createIterableMethod(method, readonly, shallow);
+	});
+	return instrumentations;
+}
+function createInstrumentationGetter(isReadonly2, shallow) {
+	const instrumentations = createInstrumentations(isReadonly2, shallow);
+	return (target, key, receiver) => {
+		if (key === "__v_isReactive") return !isReadonly2;
+		else if (key === "__v_isReadonly") return isReadonly2;
+		else if (key === "__v_raw") return target;
+		return Reflect.get(hasOwn(instrumentations, key) && key in target ? instrumentations : target, key, receiver);
+	};
+}
+const mutableCollectionHandlers = { get: /* @__PURE__ */ createInstrumentationGetter(false, false) };
+const readonlyCollectionHandlers = { get: /* @__PURE__ */ createInstrumentationGetter(true, false) };
+const reactiveMap = /* @__PURE__ */ new WeakMap();
+const shallowReactiveMap = /* @__PURE__ */ new WeakMap();
+const readonlyMap = /* @__PURE__ */ new WeakMap();
+const shallowReadonlyMap = /* @__PURE__ */ new WeakMap();
+function targetTypeMap(rawType) {
+	switch (rawType) {
+		case "Object":
+		case "Array": return 1;
+		case "Map":
+		case "Set":
+		case "WeakMap":
+		case "WeakSet": return 2;
+		default: return 0;
+	}
+}
+// @__NO_SIDE_EFFECTS__
+function reactive(target) {
+	if (/* @__PURE__ */ isReadonly(target)) return target;
+	return createReactiveObject(target, false, mutableHandlers, mutableCollectionHandlers, reactiveMap);
+}
+// @__NO_SIDE_EFFECTS__
+function readonly(target) {
+	return createReactiveObject(target, true, readonlyHandlers, readonlyCollectionHandlers, readonlyMap);
+}
+function createReactiveObject(target, isReadonly2, baseHandlers, collectionHandlers, proxyMap) {
+	if (!isObject(target)) return target;
+	if (target["__v_raw"] && !(isReadonly2 && target["__v_isReactive"])) return target;
+	if (target["__v_skip"] || !Object.isExtensible(target)) return target;
+	const existingProxy = proxyMap.get(target);
+	if (existingProxy) return existingProxy;
+	const targetType = targetTypeMap(toRawType(target));
+	if (targetType === 0) return target;
+	const proxy = new Proxy(target, targetType === 2 ? collectionHandlers : baseHandlers);
+	proxyMap.set(target, proxy);
+	return proxy;
+}
+// @__NO_SIDE_EFFECTS__
+function isReactive(value) {
+	if (/* @__PURE__ */ isReadonly(value)) return /* @__PURE__ */ isReactive(value["__v_raw"]);
+	return !!(value && value["__v_isReactive"]);
+}
+// @__NO_SIDE_EFFECTS__
+function isReadonly(value) {
+	return !!(value && value["__v_isReadonly"]);
+}
+// @__NO_SIDE_EFFECTS__
+function isShallow(value) {
+	return !!(value && value["__v_isShallow"]);
+}
+// @__NO_SIDE_EFFECTS__
+function isProxy(value) {
+	return value ? !!value["__v_raw"] : false;
+}
+// @__NO_SIDE_EFFECTS__
+function toRaw(observed) {
+	const raw = observed && observed["__v_raw"];
+	return raw ? /* @__PURE__ */ toRaw(raw) : observed;
+}
+const toReactive = (value) => isObject(value) ? /* @__PURE__ */ reactive(value) : value;
+const toReadonly = (value) => isObject(value) ? /* @__PURE__ */ readonly(value) : value;
+// @__NO_SIDE_EFFECTS__
+function isRef(r) {
+	return r ? r["__v_isRef"] === true : false;
+}
+// @__NO_SIDE_EFFECTS__
+function ref(value) {
+	return createRef(value, false);
+}
+function createRef(rawValue, shallow) {
+	if (/* @__PURE__ */ isRef(rawValue)) return rawValue;
+	return new RefImpl(rawValue, shallow);
+}
+var RefImpl = class {
+	constructor(value, isShallow2) {
+		this.dep = new Dep();
+		this["__v_isRef"] = true;
+		this["__v_isShallow"] = false;
+		this._rawValue = isShallow2 ? value : /* @__PURE__ */ toRaw(value);
+		this._value = isShallow2 ? value : toReactive(value);
+		this["__v_isShallow"] = isShallow2;
+	}
+	get value() {
+		this.dep.track();
+		return this._value;
+	}
+	set value(newValue) {
+		const oldValue = this._rawValue;
+		const useDirectValue = this["__v_isShallow"] || /* @__PURE__ */ isShallow(newValue) || /* @__PURE__ */ isReadonly(newValue);
+		newValue = useDirectValue ? newValue : /* @__PURE__ */ toRaw(newValue);
+		if (hasChanged(newValue, oldValue)) {
+			this._rawValue = newValue;
+			this._value = useDirectValue ? newValue : toReactive(newValue);
+			this.dep.trigger();
+		}
+	}
+};
+function unref(ref2) {
+	return /* @__PURE__ */ isRef(ref2) ? ref2.value : ref2;
+}
+var ComputedRefImpl = class {
+	constructor(fn, setter, isSSR) {
+		this.fn = fn;
+		this.setter = setter;
+		this._value = void 0;
+		this.dep = new Dep(this);
+		this.__v_isRef = true;
+		this.deps = void 0;
+		this.depsTail = void 0;
+		this.flags = 16;
+		this.globalVersion = globalVersion - 1;
+		this.next = void 0;
+		this.effect = this;
+		this["__v_isReadonly"] = !setter;
+		this.isSSR = isSSR;
+	}
+	notify() {
+		this.flags |= 16;
+		if (!(this.flags & 8) && activeSub !== this) {
+			batch(this, true);
+			return true;
+		}
+	}
+	get value() {
+		const link = this.dep.track();
+		refreshComputed(this);
+		if (link) link.version = this.dep.version;
+		return this._value;
+	}
+	set value(newValue) {
+		if (this.setter) this.setter(newValue);
+	}
+};
+// @__NO_SIDE_EFFECTS__
+function computed$1(getterOrOptions, debugOptions, isSSR = false) {
+	let getter;
+	let setter;
+	if (isFunction(getterOrOptions)) getter = getterOrOptions;
+	else {
+		getter = getterOrOptions.get;
+		setter = getterOrOptions.set;
+	}
+	return new ComputedRefImpl(getter, setter, isSSR);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/@vue+runtime-core@3.5.35/node_modules/@vue/runtime-core/dist/runtime-core.esm-bundler.js
+/**
+* @vue/runtime-core v3.5.35
+* (c) 2018-present Yuxi (Evan) You and Vue contributors
+* @license MIT
+**/
+function callWithErrorHandling(fn, instance, type, args) {
+	try {
+		return args ? fn(...args) : fn();
+	} catch (err) {
+		handleError(err, instance, type);
+	}
+}
+function callWithAsyncErrorHandling(fn, instance, type, args) {
+	if (isFunction(fn)) {
+		const res = callWithErrorHandling(fn, instance, type, args);
+		if (res && isPromise(res)) res.catch((err) => {
+			handleError(err, instance, type);
+		});
+		return res;
+	}
+	if (isArray(fn)) {
+		const values = [];
+		for (let i = 0; i < fn.length; i++) values.push(callWithAsyncErrorHandling(fn[i], instance, type, args));
+		return values;
+	}
+}
+function handleError(err, instance, type, throwInDev = true) {
+	const contextVNode = instance ? instance.vnode : null;
+	const { errorHandler, throwUnhandledErrorInProduction } = instance && instance.appContext.config || EMPTY_OBJ;
+	if (instance) {
+		let cur = instance.parent;
+		const exposedInstance = instance.proxy;
+		const errorInfo = `https://vuejs.org/error-reference/#runtime-${type}`;
+		while (cur) {
+			const errorCapturedHooks = cur.ec;
+			if (errorCapturedHooks) {
+				for (let i = 0; i < errorCapturedHooks.length; i++) if (errorCapturedHooks[i](err, exposedInstance, errorInfo) === false) return;
+			}
+			cur = cur.parent;
+		}
+		if (errorHandler) {
+			pauseTracking();
+			callWithErrorHandling(errorHandler, null, 10, [
+				err,
+				exposedInstance,
+				errorInfo
+			]);
+			resetTracking();
+			return;
+		}
+	}
+	logError(err, type, contextVNode, throwInDev, throwUnhandledErrorInProduction);
+}
+function logError(err, type, contextVNode, throwInDev = true, throwInProd = false) {
+	if (throwInProd) throw err;
+	else console.error(err);
+}
+let devtools$1;
+let buffer = [];
+let devtoolsNotInstalled = false;
+function emit$1(event, ...args) {
+	if (devtools$1) devtools$1.emit(event, ...args);
+	else if (!devtoolsNotInstalled) buffer.push({
+		event,
+		args
+	});
+}
+const devtoolsComponentUpdated = /* @__PURE__ */ createDevtoolsComponentHook("component:updated");
+// @__NO_SIDE_EFFECTS__
+function createDevtoolsComponentHook(hook) {
+	return (component) => {
+		emit$1(hook, component.appContext.app, component.uid, component.parent ? component.parent.uid : void 0, component);
+	};
+}
+let currentRenderingInstance = null;
+let currentScopeId = null;
+function setCurrentRenderingInstance(instance) {
+	const prev = currentRenderingInstance;
+	currentRenderingInstance = instance;
+	currentScopeId = instance && instance.type.__scopeId || null;
+	return prev;
+}
+function withCtx(fn, ctx = currentRenderingInstance, isNonScopedSlot) {
+	if (!ctx) return fn;
+	if (fn._n) return fn;
+	const renderFnWithContext = (...args) => {
+		if (renderFnWithContext._d) setBlockTracking(-1);
+		const prevInstance = setCurrentRenderingInstance(ctx);
+		let res;
+		try {
+			res = fn(...args);
+		} finally {
+			setCurrentRenderingInstance(prevInstance);
+			if (renderFnWithContext._d) setBlockTracking(1);
+		}
+		if (__VUE_PROD_DEVTOOLS__) devtoolsComponentUpdated(ctx);
+		return res;
+	};
+	renderFnWithContext._n = true;
+	renderFnWithContext._c = true;
+	renderFnWithContext._d = true;
+	return renderFnWithContext;
+}
+function inject(key, defaultValue, treatDefaultAsFactory = false) {
+	const instance = getCurrentInstance();
+	if (instance || currentApp) {
+		let provides = currentApp ? currentApp._context.provides : instance ? instance.parent == null || instance.ce ? instance.vnode.appContext && instance.vnode.appContext.provides : instance.parent.provides : void 0;
+		if (provides && key in provides) return provides[key];
+		else if (arguments.length > 1) return treatDefaultAsFactory && isFunction(defaultValue) ? defaultValue.call(instance && instance.proxy) : defaultValue;
+	}
+}
+const isTeleport = (type) => type.__isTeleport;
+function setTransitionHooks(vnode, hooks) {
+	if (vnode.shapeFlag & 6 && vnode.component) {
+		vnode.transition = hooks;
+		setTransitionHooks(vnode.component.subTree, hooks);
+	} else if (vnode.shapeFlag & 128) {
+		vnode.ssContent.transition = hooks.clone(vnode.ssContent);
+		vnode.ssFallback.transition = hooks.clone(vnode.ssFallback);
+	} else vnode.transition = hooks;
+}
+// @__NO_SIDE_EFFECTS__
+function defineComponent(options, extraOptions) {
+	return isFunction(options) ? /* @__PURE__ */ (() => extend({ name: options.name }, extraOptions, { setup: options }))() : options;
+}
+const requestIdleCallback = getGlobalThis().requestIdleCallback || ((cb) => setTimeout(cb, 1));
+const cancelIdleCallback = getGlobalThis().cancelIdleCallback || ((id) => clearTimeout(id));
+const isAsyncWrapper = (i) => !!i.type.__asyncLoader;
+function injectHook(type, hook, target = currentInstance, prepend = false) {
+	if (target) {
+		const hooks = target[type] || (target[type] = []);
+		const wrappedHook = hook.__weh || (hook.__weh = (...args) => {
+			pauseTracking();
+			const reset = setCurrentInstance(target);
+			const res = callWithAsyncErrorHandling(hook, target, type, args);
+			reset();
+			resetTracking();
+			return res;
+		});
+		if (prepend) hooks.unshift(wrappedHook);
+		else hooks.push(wrappedHook);
+		return wrappedHook;
+	}
+}
+const createHook = (lifecycle) => (hook, target = currentInstance) => {
+	if (!isInSSRComponentSetup || lifecycle === "sp") injectHook(lifecycle, (...args) => hook(...args), target);
+};
+const onBeforeMount = createHook("bm");
+const onMounted = createHook("m");
+const onBeforeUpdate = createHook("bu");
+const onUpdated = createHook("u");
+const onBeforeUnmount = createHook("bum");
+const onUnmounted = createHook("um");
+const onServerPrefetch = createHook("sp");
+const onRenderTriggered = createHook("rtg");
+const onRenderTracked = createHook("rtc");
+const COMPONENTS = "components";
+const NULL_DYNAMIC_COMPONENT = /* @__PURE__ */ Symbol.for("v-ndc");
+function resolveDynamicComponent(component) {
+	if (isString(component)) return resolveAsset(COMPONENTS, component, false) || component;
+	else return component || NULL_DYNAMIC_COMPONENT;
+}
+function resolveAsset(type, name, warnMissing = true, maybeSelfReference = false) {
+	const instance = currentRenderingInstance || currentInstance;
+	if (instance) {
+		const Component = instance.type;
+		if (type === COMPONENTS) {
+			const selfName = getComponentName(Component, false);
+			if (selfName && (selfName === name || selfName === camelize(name) || selfName === capitalize(camelize(name)))) return Component;
+		}
+		const res = resolve(instance[type] || Component[type], name) || resolve(instance.appContext[type], name);
+		if (!res && maybeSelfReference) return Component;
+		return res;
+	}
+}
+function resolve(registry, name) {
+	return registry && (registry[name] || registry[camelize(name)] || registry[capitalize(camelize(name))]);
+}
+function renderSlot(slots, name, props = {}, fallback, noSlotted) {
+	if (currentRenderingInstance.ce || currentRenderingInstance.parent && isAsyncWrapper(currentRenderingInstance.parent) && currentRenderingInstance.parent.ce) {
+		const hasProps = Object.keys(props).length > 0;
+		if (name !== "default") props.name = name;
+		return openBlock(), createBlock(Fragment, null, [createVNode("slot", props, fallback && fallback())], hasProps ? -2 : 64);
+	}
+	let slot = slots[name];
+	if (slot && slot._c) slot._d = false;
+	openBlock();
+	const validSlotContent = slot && ensureValidVNode(slot(props));
+	const slotKey = props.key || validSlotContent && validSlotContent.key;
+	const rendered = createBlock(Fragment, { key: (slotKey && !isSymbol(slotKey) ? slotKey : `_${name}`) + (!validSlotContent && fallback ? "_fb" : "") }, validSlotContent || (fallback ? fallback() : []), validSlotContent && slots._ === 1 ? 64 : -2);
+	if (!noSlotted && rendered.scopeId) rendered.slotScopeIds = [rendered.scopeId + "-s"];
+	if (slot && slot._c) slot._d = true;
+	return rendered;
+}
+function ensureValidVNode(vnodes) {
+	return vnodes.some((child) => {
+		if (!isVNode(child)) return true;
+		if (child.type === Comment) return false;
+		if (child.type === Fragment && !ensureValidVNode(child.children)) return false;
+		return true;
+	}) ? vnodes : null;
+}
+function useSlots() {
+	return getContext("useSlots").slots;
+}
+function getContext(calledFunctionName) {
+	const i = getCurrentInstance();
+	return i.setupContext || (i.setupContext = createSetupContext(i));
+}
+function createAppContext() {
+	return {
+		app: null,
+		config: {
+			isNativeTag: NO,
+			performance: false,
+			globalProperties: {},
+			optionMergeStrategies: {},
+			errorHandler: void 0,
+			warnHandler: void 0,
+			compilerOptions: {}
+		},
+		mixins: [],
+		components: {},
+		directives: {},
+		provides: /* @__PURE__ */ Object.create(null),
+		optionsCache: /* @__PURE__ */ new WeakMap(),
+		propsCache: /* @__PURE__ */ new WeakMap(),
+		emitsCache: /* @__PURE__ */ new WeakMap()
+	};
+}
+let currentApp = null;
+const internalObjectProto = {};
+const isInternalObject = (obj) => Object.getPrototypeOf(obj) === internalObjectProto;
+const isSuspense = (type) => type.__isSuspense;
+const Fragment = /* @__PURE__ */ Symbol.for("v-fgt");
+const Text = /* @__PURE__ */ Symbol.for("v-txt");
+const Comment = /* @__PURE__ */ Symbol.for("v-cmt");
+const blockStack = [];
+let currentBlock = null;
+function openBlock(disableTracking = false) {
+	blockStack.push(currentBlock = disableTracking ? null : []);
+}
+function closeBlock() {
+	blockStack.pop();
+	currentBlock = blockStack[blockStack.length - 1] || null;
+}
+let isBlockTreeEnabled = 1;
+function setBlockTracking(value, inVOnce = false) {
+	isBlockTreeEnabled += value;
+	if (value < 0 && currentBlock && inVOnce) currentBlock.hasOnce = true;
+}
+function setupBlock(vnode) {
+	vnode.dynamicChildren = isBlockTreeEnabled > 0 ? currentBlock || EMPTY_ARR : null;
+	closeBlock();
+	if (isBlockTreeEnabled > 0 && currentBlock) currentBlock.push(vnode);
+	return vnode;
+}
+function createElementBlock(type, props, children, patchFlag, dynamicProps, shapeFlag) {
+	return setupBlock(createBaseVNode(type, props, children, patchFlag, dynamicProps, shapeFlag, true));
+}
+function createBlock(type, props, children, patchFlag, dynamicProps) {
+	return setupBlock(createVNode(type, props, children, patchFlag, dynamicProps, true));
+}
+function isVNode(value) {
+	return value ? value.__v_isVNode === true : false;
+}
+const normalizeKey = ({ key }) => key != null ? key : null;
+const normalizeRef = ({ ref, ref_key, ref_for }) => {
+	if (typeof ref === "number") ref = "" + ref;
+	return ref != null ? isString(ref) || isRef(ref) || isFunction(ref) ? {
+		i: currentRenderingInstance,
+		r: ref,
+		k: ref_key,
+		f: !!ref_for
+	} : ref : null;
+};
+function createBaseVNode(type, props = null, children = null, patchFlag = 0, dynamicProps = null, shapeFlag = type === Fragment ? 0 : 1, isBlockNode = false, needFullChildrenNormalization = false) {
+	const vnode = {
+		__v_isVNode: true,
+		__v_skip: true,
+		type,
+		props,
+		key: props && normalizeKey(props),
+		ref: props && normalizeRef(props),
+		scopeId: currentScopeId,
+		slotScopeIds: null,
+		children,
+		component: null,
+		suspense: null,
+		ssContent: null,
+		ssFallback: null,
+		dirs: null,
+		transition: null,
+		el: null,
+		anchor: null,
+		target: null,
+		targetStart: null,
+		targetAnchor: null,
+		staticCount: 0,
+		shapeFlag,
+		patchFlag,
+		dynamicProps,
+		dynamicChildren: null,
+		appContext: null,
+		ctx: currentRenderingInstance
+	};
+	if (needFullChildrenNormalization) {
+		normalizeChildren(vnode, children);
+		if (shapeFlag & 128) type.normalize(vnode);
+	} else if (children) vnode.shapeFlag |= isString(children) ? 8 : 16;
+	if (isBlockTreeEnabled > 0 && !isBlockNode && currentBlock && (vnode.patchFlag > 0 || shapeFlag & 6) && vnode.patchFlag !== 32) currentBlock.push(vnode);
+	return vnode;
+}
+const createVNode = _createVNode;
+function _createVNode(type, props = null, children = null, patchFlag = 0, dynamicProps = null, isBlockNode = false) {
+	if (!type || type === NULL_DYNAMIC_COMPONENT) type = Comment;
+	if (isVNode(type)) {
+		const cloned = cloneVNode(type, props, true);
+		if (children) normalizeChildren(cloned, children);
+		if (isBlockTreeEnabled > 0 && !isBlockNode && currentBlock) if (cloned.shapeFlag & 6) currentBlock[currentBlock.indexOf(type)] = cloned;
+		else currentBlock.push(cloned);
+		cloned.patchFlag = -2;
+		return cloned;
+	}
+	if (isClassComponent(type)) type = type.__vccOpts;
+	if (props) {
+		props = guardReactiveProps(props);
+		let { class: klass, style } = props;
+		if (klass && !isString(klass)) props.class = normalizeClass(klass);
+		if (isObject(style)) {
+			if (isProxy(style) && !isArray(style)) style = extend({}, style);
+			props.style = normalizeStyle(style);
+		}
+	}
+	const shapeFlag = isString(type) ? 1 : isSuspense(type) ? 128 : isTeleport(type) ? 64 : isObject(type) ? 4 : isFunction(type) ? 2 : 0;
+	return createBaseVNode(type, props, children, patchFlag, dynamicProps, shapeFlag, isBlockNode, true);
+}
+function guardReactiveProps(props) {
+	if (!props) return null;
+	return isProxy(props) || isInternalObject(props) ? extend({}, props) : props;
+}
+function cloneVNode(vnode, extraProps, mergeRef = false, cloneTransition = false) {
+	const { props, ref, patchFlag, children, transition } = vnode;
+	const mergedProps = extraProps ? mergeProps(props || {}, extraProps) : props;
+	const cloned = {
+		__v_isVNode: true,
+		__v_skip: true,
+		type: vnode.type,
+		props: mergedProps,
+		key: mergedProps && normalizeKey(mergedProps),
+		ref: extraProps && extraProps.ref ? mergeRef && ref ? isArray(ref) ? ref.concat(normalizeRef(extraProps)) : [ref, normalizeRef(extraProps)] : normalizeRef(extraProps) : ref,
+		scopeId: vnode.scopeId,
+		slotScopeIds: vnode.slotScopeIds,
+		children,
+		target: vnode.target,
+		targetStart: vnode.targetStart,
+		targetAnchor: vnode.targetAnchor,
+		staticCount: vnode.staticCount,
+		shapeFlag: vnode.shapeFlag,
+		patchFlag: extraProps && vnode.type !== Fragment ? patchFlag === -1 ? 16 : patchFlag | 16 : patchFlag,
+		dynamicProps: vnode.dynamicProps,
+		dynamicChildren: vnode.dynamicChildren,
+		appContext: vnode.appContext,
+		dirs: vnode.dirs,
+		transition,
+		component: vnode.component,
+		suspense: vnode.suspense,
+		ssContent: vnode.ssContent && cloneVNode(vnode.ssContent),
+		ssFallback: vnode.ssFallback && cloneVNode(vnode.ssFallback),
+		placeholder: vnode.placeholder,
+		el: vnode.el,
+		anchor: vnode.anchor,
+		ctx: vnode.ctx,
+		ce: vnode.ce
+	};
+	if (transition && cloneTransition) setTransitionHooks(cloned, transition.clone(cloned));
+	return cloned;
+}
+function createTextVNode(text = " ", flag = 0) {
+	return createVNode(Text, null, text, flag);
+}
+function createCommentVNode(text = "", asBlock = false) {
+	return asBlock ? (openBlock(), createBlock(Comment, null, text)) : createVNode(Comment, null, text);
+}
+function normalizeChildren(vnode, children) {
+	let type = 0;
+	const { shapeFlag } = vnode;
+	if (children == null) children = null;
+	else if (isArray(children)) type = 16;
+	else if (typeof children === "object") if (shapeFlag & 65) {
+		const slot = children.default;
+		if (slot) {
+			slot._c && (slot._d = false);
+			normalizeChildren(vnode, slot());
+			slot._c && (slot._d = true);
+		}
+		return;
+	} else {
+		type = 32;
+		const slotFlag = children._;
+		if (!slotFlag && !isInternalObject(children)) children._ctx = currentRenderingInstance;
+		else if (slotFlag === 3 && currentRenderingInstance) if (currentRenderingInstance.slots._ === 1) children._ = 1;
+		else {
+			children._ = 2;
+			vnode.patchFlag |= 1024;
+		}
+	}
+	else if (isFunction(children)) {
+		children = {
+			default: children,
+			_ctx: currentRenderingInstance
+		};
+		type = 32;
+	} else {
+		children = String(children);
+		if (shapeFlag & 64) {
+			type = 16;
+			children = [createTextVNode(children)];
+		} else type = 8;
+	}
+	vnode.children = children;
+	vnode.shapeFlag |= type;
+}
+function mergeProps(...args) {
+	const ret = {};
+	for (let i = 0; i < args.length; i++) {
+		const toMerge = args[i];
+		for (const key in toMerge) if (key === "class") {
+			if (ret.class !== toMerge.class) ret.class = normalizeClass([ret.class, toMerge.class]);
+		} else if (key === "style") ret.style = normalizeStyle([ret.style, toMerge.style]);
+		else if (isOn(key)) {
+			const existing = ret[key];
+			const incoming = toMerge[key];
+			if (incoming && existing !== incoming && !(isArray(existing) && existing.includes(incoming))) ret[key] = existing ? [].concat(existing, incoming) : incoming;
+			else if (incoming == null && existing == null && !isModelListener(key)) ret[key] = incoming;
+		} else if (key !== "") ret[key] = toMerge[key];
+	}
+	return ret;
+}
+const emptyAppContext = createAppContext();
+let currentInstance = null;
+const getCurrentInstance = () => currentInstance || currentRenderingInstance;
+let internalSetCurrentInstance;
+let setInSSRSetupState;
+{
+	const g = getGlobalThis();
+	const registerGlobalSetter = (key, setter) => {
+		let setters;
+		if (!(setters = g[key])) setters = g[key] = [];
+		setters.push(setter);
+		return (v) => {
+			if (setters.length > 1) setters.forEach((set) => set(v));
+			else setters[0](v);
+		};
+	};
+	internalSetCurrentInstance = registerGlobalSetter(`__VUE_INSTANCE_SETTERS__`, (v) => currentInstance = v);
+	setInSSRSetupState = registerGlobalSetter(`__VUE_SSR_SETTERS__`, (v) => isInSSRComponentSetup = v);
+}
+const setCurrentInstance = (instance) => {
+	const prev = currentInstance;
+	internalSetCurrentInstance(instance);
+	instance.scope.on();
+	return () => {
+		instance.scope.off();
+		internalSetCurrentInstance(prev);
+	};
+};
+let isInSSRComponentSetup = false;
+const attrsProxyHandlers = { get(target, key) {
+	track(target, "get", "");
+	return target[key];
+} };
+function createSetupContext(instance) {
+	const expose = (exposed) => {
+		instance.exposed = exposed || {};
+	};
+	return {
+		attrs: new Proxy(instance.attrs, attrsProxyHandlers),
+		slots: instance.slots,
+		emit: instance.emit,
+		expose
+	};
+}
+function getComponentName(Component, includeInferred = true) {
+	return isFunction(Component) ? Component.displayName || Component.name : Component.name || includeInferred && Component.__name;
+}
+function isClassComponent(value) {
+	return isFunction(value) && "__vccOpts" in value;
+}
+const computed = (getterOrOptions, debugOptions) => {
+	return computed$1(getterOrOptions, debugOptions, isInSSRComponentSetup);
+};
+
+//#endregion
+//#region ../../packages/hooks/use-namespace/index.ts
+const defaultNamespace = "c";
+const statePrefix = "is-";
+const _bem = (namespace, block, blockSuffix, element, modifier) => {
+	let cls = `${namespace}-${block}`;
+	if (blockSuffix) cls += `-${blockSuffix}`;
+	if (element) cls += `__${element}`;
+	if (modifier) cls += `--${modifier}`;
+	return cls;
+};
+const namespaceContextKey = Symbol("namespaceContextKey");
+const useGetDerivedNamespace = (namespaceOverrides) => {
+	const derivedNamespace = namespaceOverrides || (getCurrentInstance() ? inject(namespaceContextKey, ref("c")) : ref("c"));
+	return computed(() => {
+		return unref(derivedNamespace) || "c";
+	});
+};
+const useNamespace = (block, namespaceOverrides) => {
+	const namespace = useGetDerivedNamespace(namespaceOverrides);
+	const b = (blockSuffix = "") => _bem(namespace.value, block, blockSuffix, "", "");
+	const e = (element) => element ? _bem(namespace.value, block, "", element, "") : "";
+	const m = (modifier) => modifier ? _bem(namespace.value, block, "", "", modifier) : "";
+	const be = (blockSuffix, element) => blockSuffix && element ? _bem(namespace.value, block, blockSuffix, element, "") : "";
+	const em = (element, modifier) => element && modifier ? _bem(namespace.value, block, "", element, modifier) : "";
+	const bm = (blockSuffix, modifier) => blockSuffix && modifier ? _bem(namespace.value, block, blockSuffix, "", modifier) : "";
+	const bem = (blockSuffix, element, modifier) => blockSuffix && element && modifier ? _bem(namespace.value, block, blockSuffix, element, modifier) : "";
+	const is = (name, ...args) => {
+		const state = args.length >= 1 ? args[0] : true;
+		return name && state ? `${statePrefix}${name}` : "";
+	};
+	const cssVar = (object) => {
+		const styles = {};
+		for (const key in object) if (object[key]) styles[`--${namespace.value}-${key}`] = object[key];
+		return styles;
+	};
+	const cssVarBlock = (object) => {
+		const styles = {};
+		for (const key in object) if (object[key]) styles[`--${namespace.value}-${block}-${key}`] = object[key];
+		return styles;
+	};
+	const cssVarName = (name) => `--${namespace.value}-${name}`;
+	const cssVarBlockName = (name) => `--${namespace.value}-${block}-${name}`;
+	return {
+		namespace,
+		b,
+		e,
+		m,
+		be,
+		em,
+		bm,
+		bem,
+		is,
+		cssVar,
+		cssVarName,
+		cssVarBlock,
+		cssVarBlockName
+	};
+};
+
+//#endregion
+//#region ../../packages/hooks/use-prop/index.ts
+const useProp = (name) => {
+	const vm = getCurrentInstance();
+	return computed(() => (vm?.proxy?.$props)?.[name]);
+};
+
+//#endregion
+//#region ../../packages/hooks/use-theme/index.ts
+const getCurrentScheme = () => {
+	if (typeof document === "undefined") return "light";
+	return document.documentElement.dataset.cColorScheme === "dark" ? "dark" : "light";
+};
+const colorScheme = ref(getCurrentScheme());
+if (typeof window !== "undefined") new MutationObserver(() => {
+	const newScheme = getCurrentScheme();
+	if (newScheme !== colorScheme.value) colorScheme.value = newScheme;
+}).observe(document.documentElement, {
+	attributes: true,
+	attributeFilter: ["data-c-color-scheme"]
+});
+const useColorScheme = () => readonly(colorScheme);
+
+//#endregion
+//#region ../../packages/components/form/src/constants.ts
+const formContextKey = Symbol("formContextKey");
+
+//#endregion
+//#region ../../packages/components/form/src/hooks/use-form-common-props.ts
+const useFormDisabled = (fallback) => {
+	const disabled = useProp("disabled");
+	const form = inject(formContextKey, void 0);
+	return computed(() => {
+		return disabled.value ?? unref(fallback) ?? form?.disabled ?? false;
+	});
+};
+
+//#endregion
+//#region ../../packages/components/button/src/use-button.ts
+const useButton = (props, slots) => {
+	const _disabled = useFormDisabled();
+	const _ref = ref();
+	const { hasLeftSlot, hasRightSlot } = slots;
+	const hasLeftSection = hasLeftSlot || !!props.leftSection;
+	const hasRightSection = hasRightSlot || !!props.rightSection;
+	const _props = computed(() => {
+		const _attrs = {
+			"data-disabled": _disabled.value || props.loading || void 0,
+			"data-block": props.fullWidth || void 0,
+			"data-size": props.size && props.size !== "sm" ? props.size : void 0,
+			"data-with-left-section": hasLeftSection || void 0,
+			"data-with-right-section": hasRightSection || void 0,
+			"data-variant": props.variant || "default"
+		};
+		if (props.tag === "button") {
+			_attrs["aria-disabled"] = _disabled.value || props.loading || void 0;
+			_attrs["disabled"] = _disabled.value || props.loading;
+		}
+		return _attrs;
+	});
+	const handleClick = (evt) => {
+		if (_disabled.value || props.loading) {
+			evt.stopPropagation();
+			return;
+		}
+	};
+	return {
+		_disabled,
+		_ref,
+		_props,
+		handleClick
+	};
+};
+
+//#endregion
+//#region ../../packages/components/button/src/button-custom.ts
+const PRESET_COLORS = [
+	"red",
+	"pink",
+	"grape",
+	"violet",
+	"indigo",
+	"blue",
+	"cyan",
+	"teal",
+	"green",
+	"lime",
+	"yellow",
+	"orange",
+	"gray",
+	"dark"
+];
+const getShadeIndexes = (scheme) => {
+	if (scheme === "light") return {
+		bg: 6,
+		hover: 7,
+		lightBg: 1,
+		lightHover: 2,
+		lightColor: 9,
+		outlineColor: 6,
+		outlineHoverBgAlpha: .05
+	};
+	else return {
+		bg: 8,
+		hover: 9,
+		lightBg: 1,
+		lightHover: 2,
+		lightColor: 9,
+		outlineColor: 4,
+		outlineHoverBgAlpha: .05
+	};
+};
+function useButtonCustomStyle(props) {
+	const colorScheme = useColorScheme();
+	return computed(() => {
+		const styles = {};
+		const { color, gradient, justify, variant } = props;
+		const scheme = colorScheme.value;
+		const idx = getShadeIndexes(scheme);
+		if (justify) styles["--button-justify"] = justify;
+		switch (variant) {
+			case "default": break;
+			case "filled":
+				if (color) if (PRESET_COLORS.includes(color)) {
+					styles["--button-bg"] = `var(--c-color-${color}-filled)`;
+					styles["--button-hover"] = `var(--c-color-${color}-filled-hover)`;
+				} else {
+					const shades = generateColorShades(color);
+					styles["--button-bg"] = shades[idx.bg];
+					styles["--button-hover"] = shades[idx.hover];
+				}
+				break;
+			case "light":
+				if (color) if (PRESET_COLORS.includes(color)) {
+					styles["--button-bg"] = `var(--c-color-${color}-light)`;
+					styles["--button-hover"] = `var(--c-color-${color}-light-hover)`;
+					styles["--button-color"] = `var(--c-color-${color}-light-color)`;
+				} else {
+					const shades = generateColorShades(color);
+					styles["--button-bg"] = shades[idx.lightBg];
+					styles["--button-hover"] = shades[idx.lightHover];
+					styles["--button-color"] = shades[idx.lightColor];
+				}
+				break;
+			case "outline":
+				if (color) if (PRESET_COLORS.includes(color)) {
+					styles["--button-hover"] = `var(--c-color-${color}-outline-hover)`;
+					styles["--button-color"] = `var(--c-color-${color}-outline)`;
+					styles["--button-bd"] = `calc(0.0625rem * var(--c-scale)) solid var(--c-color-${color}-outline)`;
+				} else {
+					const shades = generateColorShades(color);
+					styles["--button-hover"] = setColorAlpha(shades[idx.outlineColor], idx.outlineHoverBgAlpha);
+					styles["--button-color"] = shades[idx.outlineColor];
+					styles["--button-bd"] = `calc(0.0625rem * var(--c-scale)) solid ${shades[idx.outlineColor]}`;
+				}
+				break;
+			case "subtle":
+				if (color) if (PRESET_COLORS.includes(color)) {
+					styles["--button-hover"] = `var(--c-color-${color}-outline-hover)`;
+					styles["--button-color"] = `var(--c-color-${color}-outline)`;
+				} else {
+					const shades = generateColorShades(color);
+					styles["--button-hover"] = setColorAlpha(shades[idx.outlineColor], idx.outlineHoverBgAlpha);
+					styles["--button-color"] = shades[idx.outlineColor];
+				}
+				break;
+			case "transparent":
+				if (color) if (PRESET_COLORS.includes(color)) styles["--button-color"] = `var(--c-color-${color}-light-color)`;
+				else styles["--button-color"] = generateColorShades(color)[idx.lightColor];
+				break;
+			case "white":
+				if (color) if (PRESET_COLORS.includes(color)) styles["--button-color"] = `var(--c-color-${color}-filled)`;
+				else styles["--button-color"] = generateColorShades(color)[idx.bg];
+				break;
+			case "gradient":
+				const from = gradient?.from || "blue";
+				const to = gradient?.to || "cyan";
+				const deg = gradient?.deg || "45";
+				let finalFrom = from;
+				let finalTo = to;
+				if (PRESET_COLORS.includes(from)) finalFrom = `var(--c-color-${from}-filled)`;
+				if (PRESET_COLORS.includes(to)) finalTo = `var(--c-color-${to}-filled)`;
+				styles["--button-bg"] = `linear-gradient(${deg}deg, ${finalFrom} 0%, ${finalTo} 100%)`;
+				break;
+			default: break;
+		}
+		return styles;
+	});
+}
+
+//#endregion
+//#region ../../packages/components/button/src/button.vue?vue&type=script&setup=true&lang.ts
+const _hoisted_1 = {
+	key: 0,
+	"data-position": "left"
+};
+const _hoisted_2 = {
+	key: 1,
+	"data-position": "left"
+};
+const _hoisted_3 = {
+	key: 2,
+	"data-position": "right"
+};
+const _hoisted_4 = {
+	key: 3,
+	"data-position": "right"
+};
+var button_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	name: "CButton",
+	__name: "button",
+	props: {
+		autoContrast: {
+			type: Boolean,
+			required: false
+		},
+		color: {
+			type: String,
+			required: false
+		},
+		disabled: {
+			type: Boolean,
+			required: false
+		},
+		fullWidth: {
+			type: Boolean,
+			required: false
+		},
+		gradient: {
+			type: Object,
+			required: false
+		},
+		justify: {
+			type: void 0,
+			required: false
+		},
+		leftSection: {
+			type: null,
+			required: false
+		},
+		loaderProps: {
+			type: Object,
+			required: false
+		},
+		loading: {
+			type: Boolean,
+			required: false
+		},
+		radius: {
+			type: String,
+			required: false,
+			default: "4px"
+		},
+		rightSection: {
+			type: null,
+			required: false
+		},
+		size: {
+			type: null,
+			required: false,
+			default: "sm"
+		},
+		tag: {
+			type: null,
+			required: false,
+			default: "button"
+		},
+		variant: {
+			type: String,
+			required: false,
+			default: "default"
+		}
+	},
+	setup(__props, { expose: __expose }) {
+		const slots = useSlots();
+		const hasLeftSlot = computed(() => !!slots["left-section"]);
+		const hasRightSlot = computed(() => !!slots["right-section"]);
+		const props = __props;
+		const { _disabled, _props, _ref, handleClick } = useButton(props, {
+			hasLeftSlot: hasLeftSlot.value,
+			hasRightSlot: hasRightSlot.value
+		});
+		const buttonStyle = useButtonCustomStyle(props);
+		const ns = useNamespace("button");
+		const buttonClass = computed(() => [
+			useNamespace("focus").b("auto"),
+			!_disabled.value && useNamespace("active").b(),
+			ns.e("root"),
+			ns.is("loading", props.loading)
+		]);
+		const innerClass = computed(() => [ns.e("inner")]);
+		const labelClass = computed(() => [ns.e("label")]);
+		__expose({
+			disabled: _disabled.value,
+			ref: _ref,
+			size: props.size,
+			variant: props.variant
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(resolveDynamicComponent(__props.tag), mergeProps(unref(_props), {
+				class: buttonClass.value,
+				style: unref(buttonStyle),
+				onClick: unref(handleClick)
+			}), {
+				default: withCtx(() => [createBaseVNode("span", { class: normalizeClass(innerClass.value) }, [
+					_ctx.$slots["left-section"] ? (openBlock(), createElementBlock("span", _hoisted_1, [renderSlot(_ctx.$slots, "left-section")])) : __props.leftSection ? (openBlock(), createElementBlock("span", _hoisted_2, [(openBlock(), createBlock(resolveDynamicComponent(__props.leftSection)))])) : createCommentVNode("v-if", true),
+					createBaseVNode("span", { class: normalizeClass(labelClass.value) }, [renderSlot(_ctx.$slots, "default")], 2),
+					_ctx.$slots["right-section"] ? (openBlock(), createElementBlock("span", _hoisted_3, [renderSlot(_ctx.$slots, "right-section")])) : __props.rightSection ? (openBlock(), createElementBlock("span", _hoisted_4, [(openBlock(), createBlock(resolveDynamicComponent(__props.rightSection)))])) : createCommentVNode("v-if", true)
+				], 2)]),
+				_: 3
+			}, 16, [
+				"class",
+				"style",
+				"onClick"
+			]);
+		};
+	}
+});
+
+//#endregion
+//#region ../../packages/components/button/src/button.vue
+var button_default = button_vue_vue_type_script_setup_true_lang_default;
+
+//#endregion
+//#region ../../packages/components/button/index.ts
+const CButton = withInstall(button_default);
+
+//#endregion
+//#region ../../packages/components/icon/src/icon.vue?vue&type=script&setup=true&lang.ts
+var icon_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	name: "CIcon",
+	inheritAttrs: false,
+	__name: "icon",
+	props: {
+		size: {
+			type: [Number, String],
+			required: false
+		},
+		color: {
+			type: String,
+			required: false
+		}
+	},
+	setup(__props) {
+		const props = __props;
+		const ns = useNamespace("icon");
+		const style = computed(() => {
+			const { size, color } = props;
+			if (!size && !color) return {};
+			return {
+				fontSize: isUndefined(size) ? void 0 : addUnit(size),
+				"--color": color
+			};
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("i", mergeProps({
+				class: unref(ns).b(),
+				style: style.value
+			}, _ctx.$attrs), [renderSlot(_ctx.$slots, "default")], 16);
+		};
+	}
+});
+
+//#endregion
+//#region ../../packages/components/icon/src/icon.vue
+var icon_default = icon_vue_vue_type_script_setup_true_lang_default;
+
+//#endregion
+//#region ../../packages/components/icon/index.ts
+const CIcon = withInstall(icon_default);
+
+//#endregion
+//#region ../../packages/cck-ui/component.ts
+var component_default = [CButton, CIcon];
+
+//#endregion
+//#region ../../packages/cck-ui/plugin.ts
+var plugin_default = [];
+
+//#endregion
+//#region ../../packages/cck-ui/defaults.ts
+var defaults_default = makeInstaller([...component_default, ...plugin_default]);
+
+//#endregion
+//#region ../../packages/cck-ui/index.ts
+const install = defaults_default.install;
+var cck_ui_default = defaults_default;
+
+//#endregion
+export { CButton, CIcon, cck_ui_default as default, install, makeInstaller };