@weasel-js/ui 0.5.1 → 0.6.0

package/dist/chunks/Badge-DU8ihE7Z.js

@@ -0,0 +1,2942 @@
+import { useEffect as e, useId as t, useLayoutEffect as n, useRef as r, useState as i } from "react";
+import { Fragment as a, jsx as o, jsxs as s } from "react/jsx-runtime";
+var c = {
+	badge: "_badge_18w8w_1",
+	deco: "_deco_18w8w_33",
+	content: "_content_18w8w_49",
+	remove: "_remove_18w8w_161"
+}, l = {
+	Component: () => null,
+	insets: {
+		top: 0,
+		right: 0,
+		bottom: 0,
+		left: 0
+	},
+	stretches: !0,
+	renderMode: "css"
+}, u = {
+	Component: () => null,
+	insets: {
+		top: 0,
+		right: 0,
+		bottom: 0,
+		left: 0
+	},
+	stretches: !0,
+	renderMode: "css"
+}, d = { erosion: .16 }, f = {
+	compose: (e) => ({
+		base: "rounded-rect",
+		baseParams: { erosion: {
+			...d,
+			...e
+		}.erosion }
+	}),
+	insets: {
+		top: 0,
+		right: 0,
+		bottom: 0,
+		left: 0
+	},
+	stretches: !0,
+	defaults: d
+}, p = {
+	erosion: .28,
+	eccentricity: 1
+};
+function m(e, t) {
+	let n = e * t, r = e / t;
+	return [
+		`M ${n} 0`,
+		`L ${100 - n} 0`,
+		`A ${n} ${r} 0 0 0 100 ${r}`,
+		`L 100 ${100 - r}`,
+		`A ${n} ${r} 0 0 0 ${100 - n} 100`,
+		`L ${n} 100`,
+		`A ${n} ${r} 0 0 0 0 ${100 - r}`,
+		`L 0 ${r}`,
+		`A ${n} ${r} 0 0 0 ${n} 0`,
+		"Z"
+	].join(" ");
+}
+var h = {
+	Component: ({ variant: e, focused: t, params: n }) => {
+		let r = {
+			...p,
+			...n
+		}, i = m(Math.max(0, Math.min(r.erosion, 1)) * 49, Math.max(.2, Math.min(r.eccentricity, 5)));
+		return /* @__PURE__ */ s(a, { children: [
+			(e === "solid" || e === "subtle") && /* @__PURE__ */ o("path", {
+				className: "badge-fill",
+				d: i
+			}),
+			(e === "outline" || e === "solid") && /* @__PURE__ */ o("path", {
+				className: "badge-stroke",
+				d: i
+			}),
+			t && /* @__PURE__ */ o("path", {
+				className: "badge-focus",
+				d: i,
+				transform: "translate(50 50) scale(1.06) translate(-50 -50)"
+			})
+		] });
+	},
+	insets: {
+		top: 0,
+		right: 4,
+		bottom: 0,
+		left: 4
+	},
+	stretches: !0,
+	defaults: p
+}, g = {
+	holeRadius: 3.5,
+	holePitch: 11
+};
+function _({ variant: e, focused: a, params: c }) {
+	let l = {
+		...g,
+		...c
+	}, u = t(), d = r(null), [f, p] = i({
+		w: 100,
+		h: 100
+	});
+	n(() => {
+		let e = d.current?.ownerSVGElement;
+		if (!e) return;
+		let t = () => {
+			let t = e.getBoundingClientRect();
+			t.width > 0 && t.height > 0 && p({
+				w: t.width,
+				h: t.height
+			});
+		};
+		if (t(), typeof ResizeObserver > "u") return;
+		let n = new ResizeObserver(t);
+		return n.observe(e), () => n.disconnect();
+	}, []);
+	let m = l.holeRadius / f.w * 100, h = l.holeRadius / f.h * 100, _ = Math.max(2, Math.round(f.w / l.holePitch)), v = Math.max(2, Math.round(f.h / l.holePitch)), y = [];
+	for (let e = 0; e < _; e++) {
+		let t = (e + .5) / _;
+		y.push({
+			cx: t * 100,
+			cy: 0
+		}), y.push({
+			cx: t * 100,
+			cy: 100
+		});
+	}
+	for (let e = 0; e < v; e++) {
+		let t = (e + .5) / v;
+		y.push({
+			cx: 0,
+			cy: t * 100
+		}), y.push({
+			cx: 100,
+			cy: t * 100
+		});
+	}
+	return /* @__PURE__ */ s("g", {
+		ref: d,
+		children: [
+			/* @__PURE__ */ o("defs", { children: /* @__PURE__ */ s("mask", {
+				id: u,
+				maskUnits: "userSpaceOnUse",
+				x: "-5",
+				y: "-5",
+				width: "110",
+				height: "110",
+				children: [/* @__PURE__ */ o("rect", {
+					x: "0",
+					y: "0",
+					width: "100",
+					height: "100",
+					fill: "white"
+				}), y.map((e, t) => /* @__PURE__ */ o("ellipse", {
+					cx: e.cx,
+					cy: e.cy,
+					rx: m,
+					ry: h,
+					fill: "black"
+				}, t))]
+			}) }),
+			(e === "solid" || e === "subtle") && /* @__PURE__ */ o("rect", {
+				className: "badge-fill",
+				x: "0",
+				y: "0",
+				width: "100",
+				height: "100",
+				mask: `url(#${u})`
+			}),
+			(e === "outline" || e === "solid") && /* @__PURE__ */ o("rect", {
+				className: "badge-stroke",
+				x: "0",
+				y: "0",
+				width: "100",
+				height: "100",
+				mask: `url(#${u})`
+			}),
+			a && /* @__PURE__ */ o("rect", {
+				className: "badge-focus",
+				x: "-4",
+				y: "-4",
+				width: "108",
+				height: "108",
+				mask: `url(#${u})`
+			})
+		]
+	});
+}
+var v = {
+	Component: _,
+	insets: {
+		top: 2,
+		right: 4,
+		bottom: 2,
+		left: 4
+	},
+	stretches: !0,
+	defaults: g
+}, y = {
+	tipHeight: 25,
+	tipTruncation: 0
+};
+function b(e, t) {
+	let n = Math.max(0, Math.min(e, 49)), r = Math.max(0, Math.min(t, n));
+	if (r <= 0) return [
+		[50, 0],
+		[100, n],
+		[100, 100 - n],
+		[50, 100],
+		[0, 100 - n],
+		[0, n]
+	];
+	let i = r / n, a = 50 - 50 * i, o = 50 + 50 * i;
+	return [
+		[a, r],
+		[o, r],
+		[100, n],
+		[100, 100 - n],
+		[o, 100 - r],
+		[a, 100 - r],
+		[0, 100 - n],
+		[0, n]
+	];
+}
+var x = {
+	compose: (e) => {
+		let t = {
+			...y,
+			...e
+		};
+		return {
+			base: "polygon",
+			baseParams: { vertices: b(t.tipHeight, t.tipTruncation) }
+		};
+	},
+	insets: {
+		top: 4,
+		right: 6,
+		bottom: 4,
+		left: 6
+	},
+	stretches: !0,
+	defaults: y
+}, S = {
+	points: 12,
+	outerR: 48,
+	innerR: 36,
+	rotation: -7,
+	erosion: 0
+};
+function C(e, t, n, r, i) {
+	let a = e * 2, o = Math.PI * 2 / a, s = r * Math.PI / 180, c = Math.max(0, Math.min(i, 1)), l = [];
+	for (let e = 0; e < a; e++) {
+		let r = e % 2 == 0 ? t : n, i = s + e * o;
+		l.push([50 + Math.cos(i) * r, 50 + Math.sin(i) * r]);
+	}
+	if (c <= 0) {
+		let e = "";
+		for (let t = 0; t < l.length; t++) e += (t === 0 ? "M " : " L ") + l[t][0].toFixed(2) + " " + l[t][1].toFixed(2);
+		return e + " Z";
+	}
+	let u = "";
+	for (let e = 0; e < l.length; e++) {
+		let t = l[(e + l.length - 1) % l.length], n = l[e], r = l[(e + 1) % l.length], i = c * .45, a = n[0] + (t[0] - n[0]) * i, o = n[1] + (t[1] - n[1]) * i, s = n[0] + (r[0] - n[0]) * i, d = n[1] + (r[1] - n[1]) * i;
+		e === 0 ? u += `M ${a.toFixed(2)} ${o.toFixed(2)}` : u += ` L ${a.toFixed(2)} ${o.toFixed(2)}`, u += ` Q ${n[0].toFixed(2)} ${n[1].toFixed(2)} ${s.toFixed(2)} ${d.toFixed(2)}`;
+	}
+	return u + " Z";
+}
+var w = {
+	Component: ({ variant: e, focused: t, params: n }) => {
+		let r = {
+			...S,
+			...n
+		}, i = C(r.points, r.outerR, r.innerR, r.rotation, r.erosion), c = C(r.points, r.outerR + 4, r.innerR + 3, r.rotation, r.erosion);
+		return /* @__PURE__ */ s(a, { children: [
+			(e === "solid" || e === "subtle") && /* @__PURE__ */ o("path", {
+				className: "badge-fill",
+				d: i
+			}),
+			(e === "outline" || e === "solid") && /* @__PURE__ */ o("path", {
+				className: "badge-stroke",
+				d: i
+			}),
+			t && /* @__PURE__ */ o("path", {
+				className: "badge-focus",
+				d: c
+			})
+		] });
+	},
+	insets: {
+		top: 8,
+		right: 8,
+		bottom: 8,
+		left: 8
+	},
+	stretches: !0,
+	defaults: S
+}, T = {
+	scallopRadius: 5,
+	scallopSpacing: 12,
+	irregularity: 0
+}, E = {
+	compose: (e) => {
+		let t = {
+			...T,
+			...e
+		};
+		return {
+			base: "rounded-rect",
+			baseParams: { erosion: 0 },
+			effects: [{
+				type: "scallops",
+				params: {
+					scallopRadius: t.scallopRadius,
+					scallopSpacing: t.scallopSpacing,
+					irregularity: t.irregularity
+				}
+			}]
+		};
+	},
+	insets: {
+		top: 4,
+		right: 6,
+		bottom: 4,
+		left: 6
+	},
+	stretches: !0,
+	defaults: T
+}, D = {
+	pointDepth: 100,
+	shoulderY: 55,
+	curveTightness: .7,
+	erosion: .33
+};
+function O({ variant: e, focused: t, params: a }) {
+	let c = {
+		...D,
+		...a
+	}, l = r(null), [u, d] = i({
+		w: 100,
+		h: 100
+	});
+	n(() => {
+		let e = l.current?.ownerSVGElement;
+		if (!e) return;
+		let t = () => {
+			let t = e.getBoundingClientRect();
+			t.width > 0 && t.height > 0 && d({
+				w: t.width,
+				h: t.height
+			});
+		};
+		if (t(), typeof ResizeObserver > "u") return;
+		let n = new ResizeObserver(t);
+		return n.observe(e), () => n.disconnect();
+	}, []);
+	let f = Math.max(60, Math.min(c.pointDepth, 110)), p = Math.max(20, Math.min(c.shoulderY, f - 5)), m = p + (f - p) * Math.max(.1, Math.min(c.curveTightness, 1)), h = Math.max(0, Math.min(c.erosion, 1)) * 12, g = h / u.w * 100, _ = h / u.h * 100, v = [
+		`M ${g.toFixed(3)} 0`,
+		`L ${(100 - g).toFixed(3)} 0`,
+		`A ${g.toFixed(3)} ${_.toFixed(3)} 0 0 1 100 ${_.toFixed(3)}`,
+		`L 100 ${p}`,
+		`Q 100 ${m} 50 ${f}`,
+		`Q 0 ${m} 0 ${p}`,
+		`L 0 ${_.toFixed(3)}`,
+		`A ${g.toFixed(3)} ${_.toFixed(3)} 0 0 1 ${g.toFixed(3)} 0`,
+		"Z"
+	].join(" ");
+	return /* @__PURE__ */ s("g", {
+		ref: l,
+		children: [
+			(e === "solid" || e === "subtle") && /* @__PURE__ */ o("path", {
+				className: "badge-fill",
+				d: v
+			}),
+			(e === "outline" || e === "solid") && /* @__PURE__ */ o("path", {
+				className: "badge-stroke",
+				d: v
+			}),
+			t && /* @__PURE__ */ o("path", {
+				className: "badge-focus",
+				d: v,
+				transform: "translate(50 50) scale(1.06) translate(-50 -50)"
+			})
+		]
+	});
+}
+var k = {
+	Component: O,
+	insets: {
+		top: 2,
+		right: 8,
+		bottom: 14,
+		left: 8
+	},
+	stretches: !0,
+	defaults: D
+}, A = {
+	left: "inward",
+	right: "outward",
+	taperWidth: 8
+}, j = {
+	compose: (e) => ({
+		base: "ribbon",
+		baseParams: {
+			...A,
+			...e
+		}
+	}),
+	insets: {
+		top: 0,
+		right: 0,
+		bottom: 0,
+		left: 0
+	},
+	stretches: !0,
+	defaults: A
+}, M = {
+	points: 44,
+	cornerRadius: 6,
+	spikeLen: 12,
+	spikeBaseWidth: 3,
+	irregularity: 0
+}, N = {
+	compose: (e) => {
+		let t = {
+			...M,
+			...e
+		};
+		return {
+			base: "rounded-rect",
+			baseParams: { erosion: Math.max(0, Math.min(1, t.cornerRadius / 11)) },
+			effects: [{
+				type: "spikes",
+				params: {
+					count: t.points,
+					length: t.spikeLen,
+					baseWidth: t.spikeBaseWidth,
+					vertScale: 1,
+					horzScale: 1,
+					diagonalScale: 1,
+					irregularity: t.irregularity
+				}
+			}]
+		};
+	},
+	insets: {
+		top: 6,
+		right: 8,
+		bottom: 6,
+		left: 8
+	},
+	stretches: !0,
+	defaults: M
+}, P = {
+	points: 16,
+	outerR: 58,
+	innerR: 50,
+	rotation: -5
+};
+function F(e, t, n, r) {
+	let i = e * 2, a = Math.PI * 2 / i, o = r * Math.PI / 180, s = "";
+	for (let e = 0; e < i; e++) {
+		let r = e % 2 == 0 ? t : n, i = o + e * a, c = 50 + Math.cos(i) * r, l = 50 + Math.sin(i) * r;
+		s += (e === 0 ? "M " : " L ") + c.toFixed(2) + " " + l.toFixed(2);
+	}
+	return s + " Z";
+}
+var ee = {
+	Component: ({ variant: e, focused: t, params: n }) => {
+		let { points: r, outerR: i, innerR: c, rotation: l } = {
+			...P,
+			...n
+		}, u = F(r, i, c, l), d = F(r, i + 4, c + 3, l);
+		return /* @__PURE__ */ s(a, { children: [
+			(e === "solid" || e === "subtle") && /* @__PURE__ */ o("path", {
+				className: "badge-fill",
+				d: u
+			}),
+			(e === "outline" || e === "solid") && /* @__PURE__ */ o("path", {
+				className: "badge-stroke",
+				d: u
+			}),
+			t && /* @__PURE__ */ o("path", {
+				className: "badge-focus",
+				d
+			})
+		] });
+	},
+	insets: {
+		top: 4,
+		right: 4,
+		bottom: 4,
+		left: 4
+	},
+	stretches: !0,
+	defaults: P
+}, I = {
+	biteRadius: 3,
+	biteSpacing: 8,
+	irregularity: 0
+}, te = {
+	compose: (e) => {
+		let t = {
+			...I,
+			...e
+		};
+		return {
+			base: "rounded-rect",
+			baseParams: { erosion: 0 },
+			effects: [{
+				type: "bites",
+				params: {
+					biteRadius: t.biteRadius,
+					biteSpacing: t.biteSpacing,
+					irregularity: t.irregularity
+				}
+			}]
+		};
+	},
+	insets: {
+		top: 4,
+		right: 6,
+		bottom: 4,
+		left: 6
+	},
+	stretches: !0,
+	defaults: I
+}, ne = {
+	bumpWidth: 24,
+	puffiness: 14,
+	erosion: .2,
+	irregularity: 0
+}, re = {
+	compose: (e) => {
+		let t = {
+			...ne,
+			...e
+		};
+		return {
+			base: "rounded-rect",
+			baseParams: { erosion: t.erosion },
+			effects: [{
+				type: "puffs",
+				params: {
+					bumpWidth: t.bumpWidth,
+					puffiness: t.puffiness,
+					irregularity: t.irregularity
+				}
+			}]
+		};
+	},
+	insets: {
+		top: 6,
+		right: 8,
+		bottom: 6,
+		left: 8
+	},
+	stretches: !0,
+	defaults: ne
+}, ie = {
+	eaveY: 32,
+	peakHeight: 32,
+	roofOverhang: 0
+}, L = {
+	compose: (e) => {
+		let t = {
+			...ie,
+			...e
+		}, n = Math.max(2, Math.min(t.eaveY, 95)), r = n - Math.max(0, t.peakHeight), i = Math.max(0, Math.min(t.roofOverhang, 12));
+		return {
+			base: "polygon",
+			baseParams: { vertices: [
+				[50, r],
+				[100 + i, n],
+				[100, n],
+				[100, 100],
+				[0, 100],
+				[0, n],
+				[-i, n]
+			] }
+		};
+	},
+	insets: {
+		top: 10,
+		right: 4,
+		bottom: 0,
+		left: 4
+	},
+	stretches: !0,
+	defaults: ie
+}, ae = {
+	bevelWidth: 6,
+	lightFrom: "tl",
+	rivetRadius: 2.4,
+	rivetInset: 7,
+	sheenIntensity: .22
+}, oe = {
+	compose: (e) => {
+		let t = {
+			...ae,
+			...e
+		};
+		return {
+			base: "rounded-rect",
+			baseParams: { erosion: 0 },
+			effects: [
+				{
+					type: "bevel",
+					params: {
+						bevelWidth: t.bevelWidth,
+						lightFrom: t.lightFrom
+					}
+				},
+				{
+					type: "sheen",
+					params: {
+						lightFrom: t.lightFrom,
+						intensity: t.sheenIntensity
+					}
+				},
+				{
+					type: "rivets",
+					params: {
+						radius: t.rivetRadius,
+						inset: t.rivetInset,
+						lightFrom: t.lightFrom
+					}
+				}
+			]
+		};
+	},
+	insets: {
+		top: 6,
+		right: 8,
+		bottom: 6,
+		left: 8
+	},
+	stretches: !0,
+	defaults: ae
+}, R = {
+	topInset: 12,
+	pointDepth: 100
+};
+function se(e, t) {
+	let n = Math.max(0, Math.min(e, 35)), r = Math.max(60, Math.min(t, 110));
+	return [
+		`M ${n} 6`,
+		`Q ${n / 2} 0 ${n + 4} 0`,
+		`L ${100 - n - 4} 0`,
+		`Q ${100 - n / 2} 0 ${100 - n} 6`,
+		`L ${100 - n * .4} ${r * .35}`,
+		`Q ${100 - n} ${r * .7} 50 ${r}`,
+		`Q ${n} ${r * .7} ${n * .4} ${r * .35}`,
+		"Z"
+	].join(" ");
+}
+var z = {
+	Component: ({ variant: e, focused: t, params: n }) => {
+		let r = {
+			...R,
+			...n
+		}, i = se(r.topInset, r.pointDepth);
+		return /* @__PURE__ */ s(a, { children: [
+			(e === "solid" || e === "subtle") && /* @__PURE__ */ o("path", {
+				className: "badge-fill",
+				d: i
+			}),
+			(e === "outline" || e === "solid") && /* @__PURE__ */ o("path", {
+				className: "badge-stroke",
+				d: i
+			}),
+			t && /* @__PURE__ */ o("path", {
+				className: "badge-focus",
+				d: i,
+				transform: "translate(50 50) scale(1.06) translate(-50 -50)"
+			})
+		] });
+	},
+	insets: {
+		top: 4,
+		right: 10,
+		bottom: 14,
+		left: 10
+	},
+	stretches: !0,
+	defaults: R
+}, ce = "M 35 0 L 30 12 Q 15 30 15 55 Q 15 75 30 90 L 30 100 L 70 100 L 70 90 Q 85 75 85 55 Q 85 30 70 12 L 65 0 Z", B = {
+	Component: ({ variant: e, focused: t }) => /* @__PURE__ */ s(a, { children: [
+		(e === "solid" || e === "subtle") && /* @__PURE__ */ o("path", {
+			className: "badge-fill",
+			d: ce
+		}),
+		(e === "outline" || e === "solid") && /* @__PURE__ */ o("path", {
+			className: "badge-stroke",
+			d: ce
+		}),
+		t && /* @__PURE__ */ o("path", {
+			className: "badge-focus",
+			d: ce,
+			transform: "translate(50 50) scale(1.05) translate(-50 -50)"
+		})
+	] }),
+	insets: {
+		top: 4,
+		right: 12,
+		bottom: 4,
+		left: 12
+	},
+	stretches: !0
+}, V = {
+	headX: 6,
+	headHalfHeight: 23,
+	shoulderX: 33,
+	shoulderHalfHeight: 36,
+	footX: 100,
+	footHalfHeight: 29
+}, le = {
+	compose: (e) => {
+		let t = {
+			...V,
+			...e
+		}, n = Math.max(0, Math.min(t.headX, 40)), r = Math.max(n + 1, Math.min(t.shoulderX, 70)), i = Math.max(r + 1, Math.min(t.footX, 100)), a = Math.max(2, Math.min(t.headHalfHeight, 50)), o = Math.max(0, Math.min(t.shoulderHalfHeight, 50)), s = Math.min(50, a + o), c = Math.max(2, Math.min(t.footHalfHeight, 50));
+		return {
+			base: "polygon",
+			baseParams: { vertices: [
+				[n, 50 - a],
+				[r, 50 - s],
+				[i, 50 - c],
+				[i, 50 + c],
+				[r, 50 + s],
+				[n, 50 + a]
+			] }
+		};
+	},
+	insets: {
+		top: 4,
+		right: 6,
+		bottom: 4,
+		left: 11
+	},
+	stretches: !0,
+	defaults: V
+}, H = {
+	teeth: 11,
+	tearDepth: 4,
+	sideToTopRatio: 3
+};
+function U(e, t) {
+	let n = Math.max(3, Math.floor(e)), r = Math.max(1, t), i = (e) => r * (.55 + .55 * Math.abs(Math.sin(e * 1.73 + .5))), a = "M 0 0 L 100 0";
+	for (let e = 0; e < n; e++) {
+		let t = (e + .5) / n * 100, r = (e + 1) / n * 100;
+		a += ` L ${(100 - i(e)).toFixed(3)} ${t.toFixed(3)} L 100 ${r.toFixed(3)}`;
+	}
+	a += " L 0 100";
+	for (let e = n - 1; e >= 0; e--) {
+		let t = (e + .5) / n * 100, r = e / n * 100;
+		a += ` L ${i(e + n).toFixed(3)} ${t.toFixed(3)} L 0 ${r.toFixed(3)}`;
+	}
+	return a + " Z";
+}
+var ue = 2, de = {
+	Component: ({ variant: e, focused: t, params: n }) => {
+		let r = {
+			...H,
+			...n
+		}, i = U(r.teeth, r.tearDepth);
+		return /* @__PURE__ */ s(a, { children: [
+			(e === "solid" || e === "subtle") && /* @__PURE__ */ o("path", {
+				className: "badge-fill",
+				d: i
+			}),
+			(e === "outline" || e === "solid") && /* @__PURE__ */ o("path", {
+				className: "badge-stroke",
+				d: i
+			}),
+			t && /* @__PURE__ */ o("path", {
+				className: "badge-focus",
+				d: i,
+				transform: "translate(50 50) scale(1.04) translate(-50 -50)"
+			})
+		] });
+	},
+	insets: (e) => {
+		let t = Math.max(.2, Math.min(e.sideToTopRatio ?? H.sideToTopRatio, 10)), n = ue, r = Math.round(n * t);
+		return {
+			top: n,
+			right: r,
+			bottom: n,
+			left: r
+		};
+	},
+	stretches: !0,
+	defaults: H
+}, W = "M 8 30 Q 0 50 8 70 L 92 70 Q 100 50 92 30 Z", fe = {
+	Component: ({ variant: e, focused: t }) => /* @__PURE__ */ s(a, { children: [
+		(e === "solid" || e === "subtle") && /* @__PURE__ */ o("path", {
+			className: "badge-fill",
+			d: W
+		}),
+		(e === "outline" || e === "solid") && /* @__PURE__ */ o("path", {
+			className: "badge-stroke",
+			d: W
+		}),
+		(e === "outline" || e === "solid") && /* @__PURE__ */ s(a, { children: [
+			/* @__PURE__ */ o("path", {
+				className: "badge-stroke",
+				d: "M 12 38 Q 30 35 50 39 T 88 38",
+				opacity: .5,
+				fill: "none"
+			}),
+			/* @__PURE__ */ o("path", {
+				className: "badge-stroke",
+				d: "M 10 46 Q 36 49 54 45 T 90 47",
+				opacity: .4,
+				fill: "none"
+			}),
+			/* @__PURE__ */ o("path", {
+				className: "badge-stroke",
+				d: "M 12 54 Q 28 51 52 56 T 88 54",
+				opacity: .55,
+				fill: "none"
+			}),
+			/* @__PURE__ */ o("path", {
+				className: "badge-stroke",
+				d: "M 10 62 Q 40 65 58 61 T 90 62",
+				opacity: .4,
+				fill: "none"
+			}),
+			/* @__PURE__ */ o("ellipse", {
+				className: "badge-stroke",
+				cx: "32",
+				cy: "50",
+				rx: "3.4",
+				ry: "2.8",
+				opacity: .7,
+				fill: "none"
+			}),
+			/* @__PURE__ */ o("ellipse", {
+				className: "badge-stroke",
+				cx: "32",
+				cy: "50",
+				rx: "1.4",
+				ry: "1.1",
+				opacity: .85,
+				fill: "none"
+			}),
+			/* @__PURE__ */ o("ellipse", {
+				className: "badge-stroke",
+				cx: "70",
+				cy: "42",
+				rx: "2.4",
+				ry: "2",
+				opacity: .6,
+				fill: "none"
+			})
+		] }),
+		t && /* @__PURE__ */ o("path", {
+			className: "badge-focus",
+			d: W,
+			transform: "translate(50 50) scale(1.05) translate(-50 -50)"
+		})
+	] }),
+	insets: {
+		top: 10,
+		right: 4,
+		bottom: 10,
+		left: 4
+	},
+	stretches: !0
+}, G = {
+	spikeR: 50,
+	lobeR: 42,
+	valleyR: 25,
+	valleyAt: .5,
+	spikeCurvature: 1,
+	spikeBend: 0,
+	spikeTipErosion: 0,
+	lobeCurvature: 1,
+	lobeBend: 0,
+	lobeTipErosion: 0,
+	valleySmooth: 3,
+	rotation: 0,
+	samples: 192
+}, pe = {
+	pill: l,
+	plain: u,
+	square: f,
+	notched: h,
+	perforated: v,
+	hexagon: x,
+	starburst: w,
+	scalloped: E,
+	shield: k,
+	ribbon: j,
+	beavis: N,
+	sparkler: ee,
+	postage: te,
+	cloud: re,
+	house: L,
+	plaque: oe,
+	crest: z,
+	urn: B,
+	coffin: le,
+	receipt: de,
+	wood: fe,
+	quatrefoil: {
+		compose: (e) => ({
+			base: "quatrefoil",
+			baseParams: {
+				...G,
+				...e
+			}
+		}),
+		insets: {
+			top: 10,
+			right: 14,
+			bottom: 10,
+			left: 14
+		},
+		stretches: !0,
+		defaults: G
+	}
+}, K = { chamfer: 6 }, me = {
+	build: (e, t, n) => {
+		let r = {
+			...K,
+			...e
+		}, i = 100 / t, a = 100 / n, o = r.chamfer * i, s = r.chamfer * a, c = [
+			[o, 0],
+			[100 - o, 0],
+			[100, s],
+			[100, 100 - s],
+			[100 - o, 100],
+			[o, 100],
+			[0, 100 - s],
+			[0, s]
+		], l = [], u = [0];
+		for (let e = 0; e < c.length; e++) {
+			let t = c[e], n = c[(e + 1) % c.length], r = (n[0] - t[0]) / i, o = (n[1] - t[1]) / a, s = Math.hypot(r, o);
+			l.push(s), u.push(u[u.length - 1] + s);
+		}
+		let d = u[u.length - 1];
+		return {
+			bodyPath: `M ${c[0][0]} ${c[0][1]} ` + c.slice(1).map(([e, t]) => `L ${e} ${t}`).join(" ") + " Z",
+			perimeterAt: (e) => {
+				let t = (e % d + d) % d;
+				for (let e = 0; e < l.length; e++) {
+					let n = u[e];
+					if (t <= u[e + 1] + 1e-9) {
+						let r = l[e] > 0 ? (t - n) / l[e] : 0, o = c[e], s = c[(e + 1) % c.length], u = o[0] + (s[0] - o[0]) * r, d = o[1] + (s[1] - o[1]) * r, f = (s[0] - o[0]) / i, p = (s[1] - o[1]) / a, m = Math.hypot(f, p) || 1;
+						return {
+							x: u,
+							y: d,
+							nx: p / m,
+							ny: -f / m
+						};
+					}
+				}
+				return {
+					x: c[0][0],
+					y: c[0][1],
+					nx: 0,
+					ny: -1
+				};
+			},
+			totalCss: d
+		};
+	},
+	defaults: K,
+	insets: {
+		top: 0,
+		right: 4,
+		bottom: 0,
+		left: 4
+	}
+}, he = {
+	erosion: .16,
+	eccentricity: 1,
+	pinch: 0
+}, ge = {
+	build: (e, t, n) => {
+		let r = {
+			...he,
+			...e
+		}, i = 100 / t, a = 100 / n, o = Math.max(0, Math.min(r.erosion, 1)), s = Math.max(.1, Math.min(r.eccentricity, 10)), c = Math.min(t, n) / 2 * o, l = c * i * s, u = c * a / s, d = Math.max(0, Math.min(l, 50)), f = Math.max(0, Math.min(u, 50)), p = (100 - 2 * d) / i, m = (100 - 2 * f) / a, h = c + c || 1, g = Math.PI * h * 1 / 4, _ = [
+			{
+				kind: "h-edge",
+				cssLen: p
+			},
+			{
+				kind: "tr-arc",
+				cssLen: g
+			},
+			{
+				kind: "v-edge",
+				cssLen: m
+			},
+			{
+				kind: "br-arc",
+				cssLen: g
+			},
+			{
+				kind: "h-edge-b",
+				cssLen: p
+			},
+			{
+				kind: "bl-arc",
+				cssLen: g
+			},
+			{
+				kind: "v-edge-l",
+				cssLen: m
+			},
+			{
+				kind: "tl-arc",
+				cssLen: g
+			}
+		], v = [0];
+		for (let e of _) v.push(v[v.length - 1] + e.cssLen);
+		let y = v[v.length - 1], b = (e) => {
+			let t = (e % y + y) % y, n = 0;
+			for (; n < _.length - 1 && t > v[n + 1];) n++;
+			let r = t - v[n], i = _[n], a = i.cssLen > 0 ? r / i.cssLen : 0;
+			switch (i.kind) {
+				case "h-edge": return {
+					x: d + (100 - 2 * d) * a,
+					y: 0,
+					nx: 0,
+					ny: -1
+				};
+				case "tr-arc": {
+					let e = -Math.PI / 2 + Math.PI / 2 * a;
+					return {
+						x: 100 - d + d * Math.cos(e),
+						y: f + f * Math.sin(e),
+						nx: Math.cos(e),
+						ny: Math.sin(e)
+					};
+				}
+				case "v-edge": return {
+					x: 100,
+					y: f + (100 - 2 * f) * a,
+					nx: 1,
+					ny: 0
+				};
+				case "br-arc": {
+					let e = Math.PI / 2 * a;
+					return {
+						x: 100 - d + d * Math.cos(e),
+						y: 100 - f + f * Math.sin(e),
+						nx: Math.cos(e),
+						ny: Math.sin(e)
+					};
+				}
+				case "h-edge-b": return {
+					x: 100 - d - (100 - 2 * d) * a,
+					y: 100,
+					nx: 0,
+					ny: 1
+				};
+				case "bl-arc": {
+					let e = Math.PI / 2 + Math.PI / 2 * a;
+					return {
+						x: d + d * Math.cos(e),
+						y: 100 - f + f * Math.sin(e),
+						nx: Math.cos(e),
+						ny: Math.sin(e)
+					};
+				}
+				case "v-edge-l": return {
+					x: 0,
+					y: 100 - f - (100 - 2 * f) * a,
+					nx: -1,
+					ny: 0
+				};
+				case "tl-arc": {
+					let e = Math.PI + Math.PI / 2 * a;
+					return {
+						x: d + d * Math.cos(e),
+						y: f + f * Math.sin(e),
+						nx: Math.cos(e),
+						ny: Math.sin(e)
+					};
+				}
+			}
+			return {
+				x: 0,
+				y: 0,
+				nx: 0,
+				ny: -1
+			};
+		}, x = Math.max(0, Math.min(r.pinch, 1)) * (1 - o), S = (e, t) => {
+			if (x === 0) return t;
+			let n = Math.abs(e - 50) / 50;
+			return 50 + (t - 50) * (1 - n * x);
+		}, C, w = b;
+		if (x === 0) C = [
+			`M ${d} 0`,
+			`L ${100 - d} 0`,
+			`A ${d} ${f} 0 0 1 100 ${f}`,
+			`L 100 ${100 - f}`,
+			`A ${d} ${f} 0 0 1 ${100 - d} 100`,
+			`L ${d} 100`,
+			`A ${d} ${f} 0 0 1 0 ${100 - f}`,
+			`L 0 ${f}`,
+			`A ${d} ${f} 0 0 1 ${d} 0`,
+			"Z"
+		].join(" ");
+		else {
+			let e = [];
+			for (let t = 0; t < 240; t++) {
+				let n = b(t / 240 * y);
+				e.push({
+					x: n.x,
+					y: S(n.x, n.y)
+				});
+			}
+			C = e.reduce((e, t, n) => e + (n === 0 ? `M ${t.x.toFixed(3)} ${t.y.toFixed(3)}` : ` L ${t.x.toFixed(3)} ${t.y.toFixed(3)}`), "") + " Z", w = (e) => {
+				let t = (e % y + y) % y, n = b(t), r = n.x, o = S(n.x, n.y), s = y / 480, c = b(t - s), l = b(t + s), u = c.x, d = S(c.x, c.y), f = l.x, p = S(l.x, l.y), m = (f - u) / i, h = (p - d) / a, g = Math.hypot(m, h) || 1;
+				return {
+					x: r,
+					y: o,
+					nx: h / g,
+					ny: -m / g
+				};
+			};
+		}
+		return {
+			bodyPath: C,
+			perimeterAt: w,
+			totalCss: y
+		};
+	},
+	defaults: he,
+	insets: {
+		top: 0,
+		right: 4,
+		bottom: 0,
+		left: 4
+	}
+};
+//#endregion
+//#region src/components/Badge/bases/polygonSampler.ts
+function q(e, t, n) {
+	let r = 100 / t, i = 100 / n, a = [], o = [0];
+	for (let t = 0; t < e.length; t++) {
+		let n = e[t], s = e[(t + 1) % e.length], c = (s[0] - n[0]) / r, l = (s[1] - n[1]) / i, u = Math.hypot(c, l);
+		a.push(u), o.push(o[o.length - 1] + u);
+	}
+	let s = o[o.length - 1];
+	return {
+		bodyPath: `M ${e[0][0]} ${e[0][1]} ` + e.slice(1).map(([e, t]) => `L ${e} ${t}`).join(" ") + " Z",
+		perimeterAt: (t) => {
+			let n = (t % s + s) % s;
+			for (let t = 0; t < a.length; t++) {
+				let s = o[t];
+				if (n <= o[t + 1] + 1e-9) {
+					let o = a[t] > 0 ? (n - s) / a[t] : 0, c = e[t], l = e[(t + 1) % e.length], u = c[0] + (l[0] - c[0]) * o, d = c[1] + (l[1] - c[1]) * o, f = (l[0] - c[0]) / r, p = (l[1] - c[1]) / i, m = Math.hypot(f, p) || 1;
+					return {
+						x: u,
+						y: d,
+						nx: p / m,
+						ny: -f / m
+					};
+				}
+			}
+			return {
+				x: e[0][0],
+				y: e[0][1],
+				nx: 0,
+				ny: -1
+			};
+		},
+		totalCss: s
+	};
+}
+//#endregion
+//#region src/components/Badge/bases/Polygon.tsx
+var _e = [
+	[0, 0],
+	[100, 0],
+	[100, 100],
+	[0, 100]
+], ve = {
+	build: (e, t, n) => q(e?.vertices && e.vertices.length >= 3 ? e.vertices : _e, t, n),
+	defaults: { vertices: _e },
+	insets: {
+		top: 0,
+		right: 4,
+		bottom: 0,
+		left: 4
+	}
+}, ye = {
+	top: "out",
+	right: "in",
+	bottom: "out",
+	left: "in",
+	tabSize: 12,
+	arcSamples: 18
+}, J = .62;
+function be(e, t, n, r, i, a, o) {
+	if (i === "flat") return [t];
+	let s = i === "out" ? 1 : -1, c = t[0] - e[0], l = t[1] - e[1], u = Math.hypot(c, l) || 1, d = c / u, f = l / u, p = (e[0] + t[0]) / 2, m = (e[1] + t[1]) / 2, h = p + n * s * a * J, g = m + r * s * a * J, _ = a * Math.sqrt(Math.max(0, 1 - J * J)), v = [p - d * _, m - f * _], y = [p + d * _, m + f * _], b = [p + n * s * (a + a * (1 - J)), m + r * s * (a + a * (1 - J))], x = Math.hypot(v[0] - h, v[1] - g), S = Math.atan2(v[1] - g, v[0] - h), C = Math.atan2(y[1] - g, y[0] - h), w = Math.atan2(b[1] - g, b[0] - h), T = Math.PI * 2, E = ((w - S) % T + T) % T, D = ((C - S) % T + T) % T, O = E < D ? D : D - T, k = [];
+	k.push(v);
+	for (let e = 1; e <= o; e++) {
+		let t = S + e / o * O;
+		k.push([h + x * Math.cos(t), g + x * Math.sin(t)]);
+	}
+	return k.push(t), k;
+}
+var xe = {
+	build: (e, t, n) => {
+		let r = {
+			...ye,
+			...e
+		}, i = Math.max(2, Math.min(r.tabSize, 40)), a = Math.max(6, Math.floor(r.arcSamples)), o = [0, 0], s = [100, 0], c = [100, 100], l = [0, 100], u = [o];
+		return u.push(...be(o, s, 0, -1, r.top, i, a)), u.push(...be(s, c, 1, 0, r.right, i, a)), u.push(...be(c, l, 0, 1, r.bottom, i, a)), u.push(...be(l, o, -1, 0, r.left, i, a)), u.length > 1 && u[u.length - 1][0] === o[0] && u[u.length - 1][1] === o[1] && u.pop(), q(u, t, n);
+	},
+	defaults: ye,
+	insets: {
+		top: 12,
+		right: 16,
+		bottom: 12,
+		left: 16
+	}
+}, Se = {
+	spikeR: 50,
+	lobeR: 42,
+	valleyR: 25,
+	valleyAt: .5,
+	spikeCurvature: 1,
+	spikeBend: 0,
+	spikeTipErosion: 0,
+	lobeCurvature: 1,
+	lobeBend: 0,
+	lobeTipErosion: 0,
+	valleySmooth: 3,
+	rotation: 0,
+	samples: 192
+};
+function Ce(e, t, n) {
+	let r = e - t;
+	return (e + t + Math.sqrt(r * r + n * n)) / 2;
+}
+function we(e, t, n, r) {
+	if (e <= 0) return 0;
+	if (e >= 1) return 1 - r;
+	let i = Math.max(.1, t * (1 + n)), a = Math.max(.1, t * (1 - n)), o = (1 - (1 - e) ** i) ** (1 / a);
+	return Math.min(o, 1 - r);
+}
+function Te(e = {}) {
+	let t = {
+		...Se,
+		...e
+	}, n = Math.max(5, Math.min(t.spikeR, 50)), r = Math.max(5, Math.min(t.lobeR, 50 * Math.SQRT2)), i = Math.max(0, Math.min(t.valleyR, Math.min(n, r))), a = Math.max(.05, Math.min(t.valleyAt, .95)), o = Math.max(.2, t.spikeCurvature), s = Math.max(-.95, Math.min(t.spikeBend, .95)), c = Math.max(0, Math.min(t.spikeTipErosion, 1)), l = Math.max(.2, t.lobeCurvature), u = Math.max(-.95, Math.min(t.lobeBend, .95)), d = Math.max(0, Math.min(t.lobeTipErosion, 1)), f = Math.max(0, t.valleySmooth), p = t.rotation * Math.PI / 180, m = Math.max(24, Math.floor(t.samples)), h = [];
+	for (let e = 0; e < m; e++) {
+		let t = e / m * 2 * Math.PI, g = Math.abs(Math.sin(2 * (t - p))), _ = (a - g) / a, v = (g - a) / (1 - a), y = Ce(i + (n - i) * we(Math.max(0, _), o, s, c), i + (r - i) * we(Math.max(0, v), l, u, d), f);
+		h.push([50 + y * Math.cos(t), 50 + y * Math.sin(t)]);
+	}
+	return h;
+}
+var Ee = {
+	build: (e, t, n) => q(Te(e), t, n),
+	defaults: Se,
+	insets: {
+		top: 10,
+		right: 14,
+		bottom: 10,
+		left: 14
+	}
+}, De = {
+	mode: "octant",
+	count: 5,
+	s0: 0,
+	s1: .25,
+	s2: .5,
+	s3: .75,
+	s4: 1,
+	s5: 1,
+	s6: 1,
+	s7: 1,
+	s8: 1,
+	s9: 1,
+	s10: 1,
+	s11: 1,
+	r0: 48,
+	r1: 30,
+	r2: 32,
+	r3: 38,
+	r4: 46,
+	r5: 42,
+	r6: 36,
+	r7: 32,
+	r8: 30,
+	r9: 30,
+	r10: 30,
+	r11: 30,
+	w0: 1,
+	w1: 1,
+	w2: 1,
+	w3: 1,
+	w4: 1,
+	w5: 1,
+	w6: 1,
+	w7: 1,
+	w8: 1,
+	w9: 1,
+	w10: 1,
+	w11: 1,
+	rotation: 0,
+	samples: 192
+};
+function Oe(e = {}) {
+	let t = {
+		...De,
+		...e
+	}, n = Math.max(3, Math.min(Math.floor(t.count), 12)), r = [
+		"s0",
+		"s1",
+		"s2",
+		"s3",
+		"s4",
+		"s5",
+		"s6",
+		"s7",
+		"s8",
+		"s9",
+		"s10",
+		"s11"
+	], i = [
+		"r0",
+		"r1",
+		"r2",
+		"r3",
+		"r4",
+		"r5",
+		"r6",
+		"r7",
+		"r8",
+		"r9",
+		"r10",
+		"r11"
+	], a = [
+		"w0",
+		"w1",
+		"w2",
+		"w3",
+		"w4",
+		"w5",
+		"w6",
+		"w7",
+		"w8",
+		"w9",
+		"w10",
+		"w11"
+	], o = [];
+	for (let e = 0; e < n; e++) o.push({
+		s: Math.max(0, Math.min(1, Number(t[r[e]]))),
+		r: Math.max(0, Number(t[i[e]])),
+		w: Math.max(0, Number(t[a[e]] ?? 1))
+	});
+	return o.sort((e, t) => e.s - t.s), o[0].s = 0, o[n - 1].s = 1, t.mode === "quadrant" && (o[n - 1].r = o[0].r, o[n - 1].w = o[0].w), o;
+}
+function ke(e) {
+	let t = e.length - 1, n = Array(t);
+	for (let r = 0; r < t; r++) n[r] = Math.max(1e-9, e[r + 1].s - e[r].s);
+	let r = Array(t + 1), i = Array(t + 1), a = Array(t + 1), o = Array(t + 1);
+	r[0] = 0, i[0] = n[0] / 3, a[0] = n[0] / 6, o[0] = (e[1].r - e[0].r) / n[0];
+	for (let s = 1; s < t; s++) r[s] = n[s - 1] / 6, i[s] = (n[s - 1] + n[s]) / 3, a[s] = n[s] / 6, o[s] = (e[s + 1].r - e[s].r) / n[s] - (e[s].r - e[s - 1].r) / n[s - 1];
+	r[t] = n[t - 1] / 6, i[t] = n[t - 1] / 3, a[t] = 0, o[t] = -(e[t].r - e[t - 1].r) / n[t - 1];
+	for (let e = 1; e <= t; e++) {
+		let t = r[e] / i[e - 1];
+		i[e] -= t * a[e - 1], o[e] -= t * o[e - 1];
+	}
+	let s = Array(t + 1);
+	s[t] = o[t] / i[t];
+	for (let e = t - 1; e >= 0; e--) s[e] = (o[e] - a[e] * s[e + 1]) / i[e];
+	return s;
+}
+function Ae(e) {
+	return {
+		anchors: e,
+		M: ke(e)
+	};
+}
+function je(e, t) {
+	let { anchors: n, M: r } = t, i = n.length;
+	if (i === 0) return 0;
+	if (i === 1 || e <= n[0].s) return n[0].r;
+	if (e >= n[i - 1].s) return n[i - 1].r;
+	let a = 0;
+	for (; a < i - 1 && n[a + 1].s <= e;) a++;
+	let o = n[a], s = n[a + 1], c = s.s - o.s;
+	if (c <= 0) return o.r;
+	let l = (s.s - e) / c, u = (e - o.s) / c, d = (l * l * l - l) * c * c / 6, f = (u * u * u - u) * c * c / 6;
+	return l * o.r + u * s.r + (d * r[a] * o.w + f * r[a + 1] * s.w);
+}
+var Me = {
+	build: (e, t, n) => {
+		let r = {
+			...De,
+			...e
+		}, i = Ae(Oe(r)), a = r.rotation * Math.PI / 180, o = Math.max(48, Math.floor(r.samples)), s = [], c = Math.PI / 2;
+		for (let e = 0; e < o; e++) {
+			let t = e / o * 2 * Math.PI, n = t - a, l;
+			l = r.mode === "quadrant" ? (n % c + c) % c / c : Math.abs(Math.sin(2 * n));
+			let u = je(l, i);
+			s.push([50 + u * Math.cos(t), 50 + u * Math.sin(t)]);
+		}
+		return q(s, t, n);
+	},
+	defaults: De,
+	insets: {
+		top: 10,
+		right: 14,
+		bottom: 10,
+		left: 14
+	}
+}, Ne = {
+	mode: "octant",
+	count: 5,
+	s0: 0,
+	s1: .25,
+	s2: .5,
+	s3: .75,
+	s4: 1,
+	s5: 1,
+	s6: 1,
+	s7: 1,
+	s8: 1,
+	s9: 1,
+	s10: 1,
+	s11: 1,
+	r0: 48,
+	r1: 30,
+	r2: 32,
+	r3: 38,
+	r4: 46,
+	r5: 42,
+	r6: 36,
+	r7: 32,
+	r8: 30,
+	r9: 30,
+	r10: 30,
+	r11: 30,
+	w0: 1,
+	w1: 1,
+	w2: 1,
+	w3: 1,
+	w4: 1,
+	w5: 1,
+	w6: 1,
+	w7: 1,
+	w8: 1,
+	w9: 1,
+	w10: 1,
+	w11: 1,
+	rotation: 0,
+	samples: 192
+};
+function Pe(e = {}) {
+	let t = {
+		...Ne,
+		...e
+	}, n = Math.max(3, Math.min(Math.floor(t.count), 12)), r = [
+		"s0",
+		"s1",
+		"s2",
+		"s3",
+		"s4",
+		"s5",
+		"s6",
+		"s7",
+		"s8",
+		"s9",
+		"s10",
+		"s11"
+	], i = [
+		"r0",
+		"r1",
+		"r2",
+		"r3",
+		"r4",
+		"r5",
+		"r6",
+		"r7",
+		"r8",
+		"r9",
+		"r10",
+		"r11"
+	], a = [
+		"w0",
+		"w1",
+		"w2",
+		"w3",
+		"w4",
+		"w5",
+		"w6",
+		"w7",
+		"w8",
+		"w9",
+		"w10",
+		"w11"
+	], o = [];
+	for (let e = 0; e < n; e++) o.push({
+		s: Math.max(0, Math.min(1, Number(t[r[e]]))),
+		r: Math.max(0, Number(t[i[e]])),
+		w: Math.max(.01, Number(t[a[e]] ?? 1))
+	});
+	return o.sort((e, t) => e.s - t.s), o[0].s = 0, o[n - 1].s = 1, t.mode === "quadrant" && (o[n - 1].r = o[0].r, o[n - 1].w = o[0].w), o;
+}
+function Fe(e) {
+	let t = e.length, n = {
+		s: -e[1].s,
+		r: e[1].r,
+		w: e[1].w
+	}, r = {
+		s: -e[Math.min(2, t - 1)].s,
+		r: e[Math.min(2, t - 1)].r,
+		w: e[Math.min(2, t - 1)].w
+	}, i = {
+		s: 2 - e[t - 2].s,
+		r: e[t - 2].r,
+		w: e[t - 2].w
+	}, a = {
+		s: 2 - e[Math.max(t - 3, 0)].s,
+		r: e[Math.max(t - 3, 0)].r,
+		w: e[Math.max(t - 3, 0)].w
+	};
+	return [
+		r,
+		n,
+		...e,
+		i,
+		a
+	];
+}
+function Ie(e, t) {
+	let n = e + t + 1, r = Array(n);
+	for (let e = 0; e <= t; e++) r[e] = 0;
+	let i = e - t - 1;
+	for (let e = 1; e <= i; e++) r[t + e] = e / (i + 1);
+	for (let e = n - t - 1; e < n; e++) r[e] = 1;
+	return r;
+}
+function Le(e, t, n, r) {
+	if (e >= t[r]) return r - 1;
+	if (e <= t[n]) return n;
+	let i = n, a = r, o = i + a >>> 1;
+	for (; e < t[o] || e >= t[o + 1];) e < t[o] ? a = o : i = o, o = i + a >>> 1;
+	return o;
+}
+function Re(e, t, n, r) {
+	let i = Array(r + 1).fill(0), a = Array(r + 1), o = Array(r + 1);
+	i[0] = 1;
+	for (let s = 1; s <= r; s++) {
+		a[s] = t - n[e + 1 - s], o[s] = n[e + s] - t;
+		let r = 0;
+		for (let e = 0; e < s; e++) {
+			let t = o[e + 1] + a[s - e], n = t === 0 ? 0 : i[e] / t;
+			i[e] = r + o[e + 1] * n, r = a[s - e] * n;
+		}
+		i[s] = r;
+	}
+	return i;
+}
+function ze(e) {
+	let t = Fe(e);
+	return {
+		extended: t,
+		knots: Ie(t.length, 3),
+		degree: 3
+	};
+}
+function Be(e, t) {
+	let { extended: n, knots: r, degree: i } = t, a = n.length, o = Math.max(0, Math.min(1, e)), s = Le(o, r, i, a), c = Re(s, o, r, i), l = 0, u = 0, d = 0;
+	for (let e = 0; e <= i; e++) {
+		let t = n[s - i + e], r = t.w * c[e];
+		l += r * t.s, u += r * t.r, d += r;
+	}
+	return d > 0 ? {
+		s: l / d,
+		r: u / d
+	} : {
+		s: 0,
+		r: 0
+	};
+}
+function Ve(e, t) {
+	if (e <= 0) return Be(0, t).r;
+	if (e >= 1) return Be(1, t).r;
+	let n = 0, r = 1;
+	for (let i = 0; i < 30; i++) {
+		let i = (n + r) * .5, { s: a } = Be(i, t);
+		if (a < e ? n = i : r = i, r - n < 1e-5) break;
+	}
+	return Be((n + r) * .5, t).r;
+}
+var He = {
+	build: (e, t, n) => {
+		let r = {
+			...Ne,
+			...e
+		}, i = ze(Pe(r)), a = r.rotation * Math.PI / 180, o = Math.max(48, Math.floor(r.samples)), s = [], c = Math.PI / 2;
+		for (let e = 0; e < o; e++) {
+			let t = e / o * 2 * Math.PI, n = t - a, l;
+			l = r.mode === "quadrant" ? (n % c + c) % c / c : Math.abs(Math.sin(2 * n));
+			let u = Ve(l, i);
+			s.push([50 + u * Math.cos(t), 50 + u * Math.sin(t)]);
+		}
+		return q(s, t, n);
+	},
+	defaults: Ne,
+	insets: {
+		top: 10,
+		right: 14,
+		bottom: 10,
+		left: 14
+	}
+}, Ue = {
+	left: "inward",
+	right: "outward",
+	taperWidth: 8
+};
+function We(e, t, n, r) {
+	switch (e) {
+		case "flat": return {
+			top: [t, 0],
+			mid: null,
+			bottom: [t, 100]
+		};
+		case "outward": return {
+			top: [t + n * r, 0],
+			mid: [t, 50],
+			bottom: [t + n * r, 100]
+		};
+		case "inward": return {
+			top: [t, 0],
+			mid: [t + n * r, 50],
+			bottom: [t, 100]
+		};
+	}
+}
+function Ge(e, t) {
+	let n = Math.max(0, t);
+	switch (e) {
+		case "flat": return 4;
+		case "outward": return Math.round(n * .7);
+		case "inward": return Math.round(n * .8);
+	}
+}
+var Ke = {
+	build: (e, t, n) => {
+		let r = {
+			...Ue,
+			...e
+		}, i = Math.max(0, r.taperWidth), a = t > 0 ? i / t * 100 : 0, o = We(r.left, 0, 1, a), s = We(r.right, 100, -1, a), c = [o.top];
+		return c.push(s.top), s.mid && c.push(s.mid), c.push(s.bottom), c.push(o.bottom), o.mid && c.push(o.mid), q(c, t, n);
+	},
+	insets: (e) => {
+		let t = {
+			...Ue,
+			...e
+		};
+		return {
+			top: 0,
+			right: Ge(t.right, t.taperWidth),
+			bottom: 0,
+			left: Ge(t.left, t.taperWidth)
+		};
+	},
+	defaults: Ue
+}, qe = {
+	flat: (e, t) => 0,
+	chevron: (e, t) => (1 - Math.abs(e - .5) * 2) * t,
+	slant: (e, t) => e * t,
+	"slant-up": (e, t) => (1 - e) * t,
+	round: (e, t) => Math.sin(e * Math.PI) * t,
+	scallop: (e, t) => Math.sin(e * Math.PI * 3) * .4 * t,
+	"concave-chevron": (e, t) => -(1 - Math.abs(e - .5) * 2) * t
+};
+function Je(e) {
+	return typeof e == "function" ? e : qe[e] ?? qe.flat;
+}
+//#endregion
+//#region src/components/Badge/bases/Powerline.tsx
+var Y = {
+	leftEdge: "flat",
+	rightEdge: "flat",
+	depth: 6
+}, X = 64, Ye = {
+	"chamfered-rect": me,
+	"rounded-rect": ge,
+	polygon: ve,
+	puzzle: xe,
+	quatrefoil: Ee,
+	"octant-spline": Me,
+	"octant-bspline": He,
+	ribbon: Ke,
+	powerline: {
+		build: (e, t, n) => {
+			let r = {
+				...Y,
+				...e
+			}, i = Je(r.leftEdge), a = Je(r.rightEdge), o = r.depth, s = 100 / t, c = 100 / n, l = [];
+			l.push({
+				x: i(0, o) * s,
+				y: 0,
+				nx: 0,
+				ny: -1
+			}), l.push({
+				x: (t + a(0, o)) * s,
+				y: 0,
+				nx: 0,
+				ny: -1
+			});
+			for (let e = 1; e < X; e++) {
+				let n = e / X, r = t + a(n, o);
+				l.push({
+					x: r * s,
+					y: n * 100,
+					nx: 1,
+					ny: 0
+				});
+			}
+			l.push({
+				x: (t + a(1, o)) * s,
+				y: 100,
+				nx: 0,
+				ny: 1
+			}), l.push({
+				x: (0 + i(1, o)) * s,
+				y: 100,
+				nx: 0,
+				ny: 1
+			});
+			for (let e = X - 1; e >= 1; e--) {
+				let t = e / X, n = 0 + i(t, o);
+				l.push({
+					x: n * s,
+					y: t * 100,
+					nx: -1,
+					ny: 0
+				});
+			}
+			let u = [0];
+			for (let e = 1; e < l.length; e++) {
+				let t = l[e - 1], n = l[e], r = (n.x - t.x) / s, i = (n.y - t.y) / c;
+				u.push(u[e - 1] + Math.hypot(r, i));
+			}
+			let d = l[l.length - 1], f = l[0], p = Math.hypot((f.x - d.x) / s, (f.y - d.y) / c), m = u[u.length - 1] + p;
+			return {
+				bodyPath: l.reduce((e, t, n) => e + (n === 0 ? `M ${t.x.toFixed(3)} ${t.y.toFixed(3)}` : ` L ${t.x.toFixed(3)} ${t.y.toFixed(3)}`), "") + " Z",
+				perimeterAt: (e) => {
+					let t = (e % m + m) % m;
+					for (let e = 1; e < l.length; e++) if (t <= u[e]) {
+						let n = u[e] - u[e - 1], r = n > 0 ? (t - u[e - 1]) / n : 0, i = l[e - 1], a = l[e];
+						return {
+							x: i.x + (a.x - i.x) * r,
+							y: i.y + (a.y - i.y) * r,
+							nx: a.nx,
+							ny: a.ny
+						};
+					}
+					let n = l.length - 1, r = p, i = r > 0 ? (t - u[n]) / r : 0;
+					return {
+						x: l[n].x + (f.x - l[n].x) * i,
+						y: l[n].y + (f.y - l[n].y) * i,
+						nx: 0,
+						ny: 1
+					};
+				},
+				totalCss: m
+			};
+		},
+		defaults: Y,
+		insets: (e) => {
+			let t = e?.depth ?? Y.depth, n = e?.leftEdge ?? Y.leftEdge, r = e?.rightEdge ?? Y.rightEdge, i = Je(n), a = Je(r), o = 0, s = 0, c = 0, l = 0;
+			for (let e = 0; e <= 32; e++) {
+				let n = e / 32, r = i(n, t), u = a(n, t), d = e === 0 || e === 32 ? .5 : 1;
+				o += d * r / 32, s += d * u / 32, r > c && (c = r), -u > l && (l = -u);
+			}
+			let u = (o + s) / 2, d = Math.max(c, t + u);
+			return {
+				top: 0,
+				right: Math.max(l, t - u),
+				bottom: 0,
+				left: d
+			};
+		}
+	}
+};
+//#endregion
+//#region src/components/Badge/effects/rangeMask.ts
+function Z(e, t, n) {
+	if (!n) return 1;
+	let [r, i] = n;
+	if (r === i) return 0;
+	let a = (e % t + t) % t / t;
+	return r < i ? +(a >= r && a <= i) : +(a >= r || a <= i);
+}
+//#endregion
+//#region src/components/Badge/effects/Spikes.tsx
+var Xe = {
+	count: 44,
+	length: 8,
+	baseWidth: 3,
+	vertScale: 1.4,
+	horzScale: 1,
+	diagonalScale: .5,
+	irregularity: 0,
+	cornerCompensation: 1
+}, Ze = {
+	offsetAt: (e, { params: t, phase: n, totalCss: r, perimeterAt: i }) => {
+		let a = {
+			...Xe,
+			...t
+		}, o = Z(e, r, a.range);
+		if (o === 0) return {
+			dx: 0,
+			dy: 0
+		};
+		let s = r / Math.max(3, Math.floor(a.count)), c = Math.max(.1, Math.min(s / 2 - .05, a.baseWidth / 2)), l = n * s, u = (e % r + r) % r, d = Math.round((u - l) / s), f = ((d * s + l) % r + r) % r, p = u - f;
+		if (p > r / 2 && (p -= r), p < -r / 2 && (p += r), Math.abs(p) > c) return {
+			dx: 0,
+			dy: 0
+		};
+		let m = 1 - Math.abs(p) / c, h = i(f), g = h.nx, _ = h.ny, v = Math.abs(h.nx), y = Math.abs(h.ny), b = Math.min(1, 2 * v * y), x = (y > v ? a.vertScale : a.horzScale) * (1 - b) + a.diagonalScale * b, S = 1 + a.irregularity * .5 * Math.sin(d * 1.73 + .7), C = Math.max(s * .5, c), w = 0;
+		for (let e = 0; e < 5; e++) {
+			let t = (e + .5) / 5, n = f - C + t * 2 * C - C / 5, r = f - C + t * 2 * C + C / 5, a = i(n), o = i(r);
+			w += Math.hypot(o.nx - a.nx, o.ny - a.ny) / (r - n);
+		}
+		w /= 5;
+		let T = a.length * x * S * m, E = Math.max(0, Math.min(a.cornerCompensation, 1)), D = Math.max(0, T / (1 + E * w * T)) * o;
+		return {
+			dx: g * D,
+			dy: _ * D
+		};
+	},
+	defaults: Xe
+}, Qe = {
+	bumpWidth: 18,
+	puffiness: 10,
+	irregularity: 0
+}, $e = {
+	offsetAt: (e, { params: t, phase: n, totalCss: r, perimeterAt: i }) => {
+		let a = {
+			...Qe,
+			...t
+		}, o = Z(e, r, a.range);
+		if (o === 0) return {
+			dx: 0,
+			dy: 0
+		};
+		let s = r / Math.max(2, Math.round(r / Math.max(6, a.bumpWidth))), c = n * s, l = (e % r + r) % r, u = Math.floor((l - c) / s), d = (l - (u * s + c)) / s;
+		d < 0 && (d += 1), d > 1 && --d;
+		let f = Math.max(0, Math.min(a.irregularity, 1)), p = Math.max(.5, a.puffiness) * (1 + f * .55 * Math.sin(u * 1.73 + .7)) * Math.sin(Math.PI * d) * o, m = i(e);
+		return {
+			dx: m.nx * p,
+			dy: m.ny * p
+		};
+	},
+	defaults: Qe
+}, et = {
+	biteRadius: 3,
+	biteSpacing: 8,
+	irregularity: 0
+}, tt = {
+	offsetAt: (e, { params: t, phase: n, totalCss: r, perimeterAt: i }) => {
+		let a = {
+			...et,
+			...t
+		}, o = Z(e, r, a.range);
+		if (o === 0) return {
+			dx: 0,
+			dy: 0
+		};
+		let s = Math.max(.5, a.biteRadius), c = Math.max(2 * s + .5, a.biteSpacing), l = r / Math.max(2, Math.floor(r / c)), u = n * l, d = (e % r + r) % r, f = Math.round((d - u) / l), p = d - ((f * l + u) % r + r) % r;
+		p > r / 2 && (p -= r), p < -r / 2 && (p += r);
+		let m = s * (1 + Math.max(0, Math.min(a.irregularity, 1)) * .55 * Math.sin(f * 1.73 + .7));
+		if (Math.abs(p) > m) return {
+			dx: 0,
+			dy: 0
+		};
+		let h = 1 - Math.abs(p) / m, g = -m * h, _ = i(e);
+		return {
+			dx: _.nx * g * o,
+			dy: _.ny * g * o
+		};
+	},
+	defaults: et
+}, nt = {
+	scallopRadius: 4,
+	scallopSpacing: 10,
+	irregularity: 0
+}, rt = {
+	offsetAt: (e, { params: t, phase: n, totalCss: r, perimeterAt: i }) => {
+		let a = {
+			...nt,
+			...t
+		}, o = Z(e, r, a.range);
+		if (o === 0) return {
+			dx: 0,
+			dy: 0
+		};
+		let s = Math.max(.5, a.scallopRadius), c = Math.max(2 * s + .5, a.scallopSpacing), l = r / Math.max(2, Math.floor(r / c)), u = n * l, d = (e % r + r) % r, f = Math.round((d - u) / l), p = d - ((f * l + u) % r + r) % r;
+		p > r / 2 && (p -= r), p < -r / 2 && (p += r);
+		let m = s * (1 + Math.max(0, Math.min(a.irregularity, 1)) * .55 * Math.sin(f * 1.73 + .7));
+		if (Math.abs(p) > m) return {
+			dx: 0,
+			dy: 0
+		};
+		let h = (p + m) / (2 * m), g = m * Math.sin(Math.PI * h) * o, _ = i(e);
+		return {
+			dx: _.nx * g,
+			dy: _.ny * g
+		};
+	},
+	defaults: nt
+}, it = {
+	bevelWidth: 6,
+	lightFrom: "tl"
+};
+function at(e, t) {
+	return Math.abs(t) > Math.abs(e) ? t < 0 ? "top" : "bottom" : e < 0 ? "left" : "right";
+}
+function ot(e) {
+	let t = e[0] === "t", n = e[1] === "l";
+	return {
+		top: t ? "badge-bevel-light" : "badge-bevel-dark",
+		bottom: t ? "badge-bevel-dark" : "badge-bevel-light",
+		left: n ? "badge-bevel-medium-light" : "badge-bevel-medium-dark",
+		right: n ? "badge-bevel-medium-dark" : "badge-bevel-medium-light"
+	};
+}
+var st = 240, ct = {
+	Component: ({ sampler: e, boxW: n, boxH: r, variant: i, params: c }) => {
+		if (i !== "solid" && i !== "subtle") return null;
+		let l = {
+			...it,
+			...c
+		}, u = t(), d = 100 / n, f = 100 / r, p = ot(l.lightFrom), m = e.totalCss, h = [], g = [];
+		for (let t = 0; t < st; t++) {
+			let n = e.perimeterAt(t / st * m);
+			h.push({
+				x: n.x,
+				y: n.y,
+				side: at(n.nx, n.ny)
+			}), g.push({
+				x: n.x - n.nx * l.bevelWidth * d,
+				y: n.y - n.ny * l.bevelWidth * f
+			});
+		}
+		let _ = [], v = null;
+		for (let e = 0; e < st; e++) {
+			let t = h[e].side;
+			!v || v.side !== t ? (v = {
+				side: t,
+				idxs: [e]
+			}, _.push(v)) : v.idxs.push(e);
+		}
+		_.length > 1 && _[0].side === _[_.length - 1].side && (_[_.length - 1].idxs = _[_.length - 1].idxs.concat(_[0].idxs), _.shift());
+		let y = (e) => {
+			let t = e.idxs.map((e) => h[e]), n = e.idxs.map((e) => g[e]).reverse(), r = [...t, ...n];
+			if (r.length === 0) return "";
+			let i = `M ${r[0].x.toFixed(3)} ${r[0].y.toFixed(3)}`;
+			for (let e = 1; e < r.length; e++) i += ` L ${r[e].x.toFixed(3)} ${r[e].y.toFixed(3)}`;
+			return i + " Z";
+		};
+		return /* @__PURE__ */ s(a, { children: [/* @__PURE__ */ o("defs", { children: /* @__PURE__ */ o("clipPath", {
+			id: u,
+			children: /* @__PURE__ */ o("path", { d: e.bodyPath })
+		}) }), /* @__PURE__ */ o("g", {
+			clipPath: `url(#${u})`,
+			children: _.map((e, t) => /* @__PURE__ */ o("path", {
+				className: p[e.side],
+				d: y(e)
+			}, t))
+		})] });
+	},
+	zone: "foreground",
+	defaults: it
+}, lt = {
+	lightFrom: "tl",
+	intensity: .22
+}, ut = {
+	tl: {
+		x1: "100%",
+		y1: "100%",
+		x2: "0%",
+		y2: "0%"
+	},
+	tr: {
+		x1: "0%",
+		y1: "100%",
+		x2: "100%",
+		y2: "0%"
+	},
+	bl: {
+		x1: "100%",
+		y1: "0%",
+		x2: "0%",
+		y2: "100%"
+	},
+	br: {
+		x1: "0%",
+		y1: "0%",
+		x2: "100%",
+		y2: "100%"
+	}
+}, dt = {
+	Component: ({ sampler: e, variant: n, params: r }) => {
+		if (n !== "solid" && n !== "subtle") return null;
+		let i = {
+			...lt,
+			...r
+		}, c = t(), l = t(), u = Math.max(0, Math.min(i.intensity, 1));
+		return /* @__PURE__ */ s(a, { children: [/* @__PURE__ */ s("defs", { children: [/* @__PURE__ */ o("clipPath", {
+			id: l,
+			children: /* @__PURE__ */ o("path", { d: e.bodyPath })
+		}), /* @__PURE__ */ s("linearGradient", {
+			id: c,
+			...ut[i.lightFrom],
+			children: [
+				/* @__PURE__ */ o("stop", {
+					offset: "0%",
+					stopColor: "black",
+					stopOpacity: u
+				}),
+				/* @__PURE__ */ o("stop", {
+					offset: "45%",
+					stopColor: "black",
+					stopOpacity: "0.04"
+				}),
+				/* @__PURE__ */ o("stop", {
+					offset: "58%",
+					stopColor: "white",
+					stopOpacity: "0.04"
+				}),
+				/* @__PURE__ */ o("stop", {
+					offset: "100%",
+					stopColor: "white",
+					stopOpacity: u
+				})
+			]
+		})] }), /* @__PURE__ */ o("rect", {
+			clipPath: `url(#${l})`,
+			x: "0",
+			y: "0",
+			width: "100",
+			height: "100",
+			fill: `url(#${c})`,
+			style: { pointerEvents: "none" }
+		})] });
+	},
+	zone: "foreground",
+	defaults: lt
+}, ft = {
+	radius: 2.4,
+	inset: 7,
+	lightFrom: "tl"
+}, pt = {
+	Component: ({ boxW: e, boxH: t, variant: n, params: r }) => {
+		if (n !== "solid" && n !== "subtle") return null;
+		let i = {
+			...ft,
+			...r
+		}, c = 100 / e, l = 100 / t, u = i.radius * c, d = i.radius * l, f = i.inset * c, p = i.inset * l, m = i.lightFrom[1] === "l" ? -i.radius * .32 : i.radius * .32, h = i.lightFrom[0] === "t" ? -i.radius * .32 : i.radius * .32;
+		return /* @__PURE__ */ o(a, { children: [
+			[f, p],
+			[100 - f, p],
+			[f, 100 - p],
+			[100 - f, 100 - p]
+		].map(([e, t], n) => /* @__PURE__ */ s("g", { children: [
+			/* @__PURE__ */ o("ellipse", {
+				className: "badge-bevel-dark",
+				cx: e,
+				cy: t,
+				rx: u,
+				ry: d
+			}),
+			/* @__PURE__ */ o("ellipse", {
+				className: "badge-bevel-medium-dark",
+				cx: e - m * .6 * c,
+				cy: t - h * .6 * l,
+				rx: u * .75,
+				ry: d * .75
+			}),
+			/* @__PURE__ */ o("ellipse", {
+				className: "badge-bevel-light",
+				cx: e + m * c,
+				cy: t + h * l,
+				rx: u * .45,
+				ry: d * .45
+			})
+		] }, n)) });
+	},
+	zone: "foreground",
+	defaults: ft
+}, mt = {
+	dx: 1,
+	dy: 2,
+	opacity: .28
+}, ht = {
+	Component: ({ sampler: e, boxW: t, boxH: n, params: r }) => {
+		let i = {
+			...mt,
+			...r
+		}, a = 100 / t, s = 100 / n, c = i.dx * a, l = i.dy * s;
+		return /* @__PURE__ */ o("path", {
+			d: e.bodyPath,
+			transform: `translate(${c.toFixed(3)} ${l.toFixed(3)})`,
+			fill: `rgba(0, 0, 0, ${Math.max(0, Math.min(i.opacity, 1))})`,
+			stroke: "none",
+			style: { pointerEvents: "none" }
+		});
+	},
+	zone: "background",
+	defaults: mt
+}, gt = {
+	lines: 4,
+	knots: 2,
+	intensity: .55
+};
+function _t(e) {
+	return Math.sin(e * 1.73 + .5);
+}
+var vt = {
+	Component: ({ sampler: e, variant: n, params: r }) => {
+		if (n !== "solid" && n !== "subtle") return null;
+		let i = {
+			...gt,
+			...r
+		}, c = t(), l = [];
+		for (let e = 0; e < i.lines; e++) {
+			let t = (e + 1) / (i.lines + 1) * 100, n = _t(e * 2 + 1) * 4, r = _t(e * 2 + 2) * 4;
+			l.push(`M -5 ${t.toFixed(2)} Q 35 ${(t + n).toFixed(2)} 60 ${t.toFixed(2)} T 105 ${(t + r).toFixed(2)}`);
+		}
+		let u = [];
+		for (let e = 0; e < i.knots; e++) {
+			let t = 30 + _t(e * 3 + .7) * 30 + 20, n = 50 + _t(e * 3 + 1.3) * 30;
+			u.push([t, n]);
+		}
+		return /* @__PURE__ */ s(a, { children: [/* @__PURE__ */ o("defs", { children: /* @__PURE__ */ o("clipPath", {
+			id: c,
+			children: /* @__PURE__ */ o("path", { d: e.bodyPath })
+		}) }), /* @__PURE__ */ s("g", {
+			clipPath: `url(#${c})`,
+			opacity: Math.max(0, Math.min(i.intensity, 1)),
+			style: { pointerEvents: "none" },
+			children: [l.map((e, t) => /* @__PURE__ */ o("path", {
+				className: "badge-stroke",
+				d: e,
+				fill: "none"
+			}, `l${t}`)), u.map(([e, t], n) => /* @__PURE__ */ s("g", { children: [/* @__PURE__ */ o("ellipse", {
+				className: "badge-stroke",
+				cx: e,
+				cy: t,
+				rx: 3,
+				ry: 2.4,
+				fill: "none"
+			}), /* @__PURE__ */ o("ellipse", {
+				className: "badge-stroke",
+				cx: e,
+				cy: t,
+				rx: 1.2,
+				ry: 1,
+				fill: "none"
+			})] }, `k${n}`))]
+		})] });
+	},
+	zone: "foreground",
+	defaults: gt
+}, yt = {
+	holeRadius: 3,
+	holeSpacing: 11
+}, bt = {
+	Component: ({ sampler: e, boxW: t, boxH: n, params: r }) => {
+		let i = {
+			...yt,
+			...r
+		}, s = 100 / t, c = 100 / n, l = e.totalCss, u = Math.max(2, Math.round(l / Math.max(2 * i.holeRadius, i.holeSpacing))), d = l / u, f = [];
+		for (let t = 0; t < u; t++) {
+			let n = (t + .5) * d;
+			if (Z(n, l, r?.range) === 0) continue;
+			let i = e.perimeterAt(n);
+			f.push({
+				cx: i.x,
+				cy: i.y
+			});
+		}
+		let p = i.holeRadius * s, m = i.holeRadius * c;
+		return /* @__PURE__ */ o(a, { children: f.map((e, t) => /* @__PURE__ */ o("ellipse", {
+			cx: e.cx,
+			cy: e.cy,
+			rx: p,
+			ry: m,
+			fill: "black"
+		}, t)) });
+	},
+	zone: "mask",
+	defaults: yt
+}, xt = {
+	bevelWidth: 6,
+	lightFrom: 315
+}, Q = 240, St = [
+	"badge-bevel-light",
+	"badge-bevel-medium-light",
+	"badge-bevel-medium-light",
+	"badge-bevel-medium-dark",
+	"badge-bevel-medium-dark",
+	"badge-bevel-dark"
+];
+function Ct(e) {
+	let t = e * Math.PI / 180;
+	return {
+		lx: Math.sin(t),
+		ly: -Math.cos(t)
+	};
+}
+var wt = {
+	Component: ({ sampler: e, boxW: n, boxH: r, variant: i, params: c }) => {
+		if (i !== "solid" && i !== "subtle") return null;
+		let l = {
+			...xt,
+			...c
+		}, u = t(), d = 100 / n, f = 100 / r, p = e.totalCss, { lx: m, ly: h } = Ct(l.lightFrom), g = [], _ = [];
+		for (let t = 0; t < Q; t++) {
+			let n = e.perimeterAt(t / Q * p), r = -(n.nx * m + n.ny * h), i = Math.max(0, Math.min((r + 1) / 2, .9999)), a = Math.floor(i * St.length);
+			g.push({
+				x: n.x,
+				y: n.y,
+				bucket: a
+			}), _.push({
+				x: n.x - n.nx * l.bevelWidth * d,
+				y: n.y - n.ny * l.bevelWidth * f
+			});
+		}
+		let v = [], y = null;
+		for (let e = 0; e < Q; e++) {
+			let t = g[e].bucket;
+			!y || y.bucket !== t ? (y = {
+				bucket: t,
+				idxs: [e]
+			}, v.push(y)) : y.idxs.push(e);
+		}
+		v.length > 1 && v[0].bucket === v[v.length - 1].bucket && (v[v.length - 1].idxs = v[v.length - 1].idxs.concat(v[0].idxs), v.shift());
+		let b = (e) => {
+			let t = e.idxs[0], n = e.idxs[e.idxs.length - 1], r = (t - 1 + Q) % Q, i = (n + 1) % Q, a = [
+				r,
+				...e.idxs,
+				i
+			], o = a.map((e) => g[e]), s = a.map((e) => _[e]).reverse(), c = [...o, ...s], l = `M ${c[0].x.toFixed(3)} ${c[0].y.toFixed(3)}`;
+			for (let e = 1; e < c.length; e++) l += ` L ${c[e].x.toFixed(3)} ${c[e].y.toFixed(3)}`;
+			return l + " Z";
+		};
+		return /* @__PURE__ */ s(a, { children: [/* @__PURE__ */ o("defs", { children: /* @__PURE__ */ o("clipPath", {
+			id: u,
+			children: /* @__PURE__ */ o("path", { d: e.bodyPath })
+		}) }), /* @__PURE__ */ o("g", {
+			clipPath: `url(#${u})`,
+			children: v.map((e, t) => /* @__PURE__ */ o("path", {
+				className: St[e.bucket],
+				d: b(e)
+			}, t))
+		})] });
+	},
+	zone: "foreground",
+	defaults: xt
+}, Tt = {
+	width: 1,
+	color: "var(--badge-edge)",
+	dash: "",
+	blendMode: "normal",
+	opacity: 1
+}, Et = {
+	Component: ({ sampler: e, boxW: t, boxH: n, params: r }) => {
+		let i = {
+			...Tt,
+			...r
+		}, a = 100 / t, s = 100 / n, c = i.width * Math.max(a, s);
+		return /* @__PURE__ */ o("path", {
+			d: e.bodyPath,
+			fill: "none",
+			stroke: i.color,
+			strokeWidth: c,
+			strokeDasharray: i.dash || void 0,
+			strokeOpacity: i.opacity,
+			vectorEffect: "non-scaling-stroke",
+			style: { mixBlendMode: i.blendMode }
+		});
+	},
+	zone: "foreground",
+	defaults: Tt
+}, Dt = {
+	count: 3,
+	width: 18,
+	gap: 8,
+	angle: 28,
+	opacity: .18,
+	color: "#ffffff",
+	offset: 0,
+	irregularity: 0,
+	gradientAngle: 90,
+	gradientStart: 0,
+	gradientEnd: 1
+}, Ot = {
+	Component: ({ sampler: e, boxW: n, boxH: r, params: i }) => {
+		let c = {
+			...Dt,
+			...i
+		}, l = t(), u = t(), d = t(), f = 100 / n, p = 100 / r, m = Math.max(0, Math.min(c.irregularity, 1)), h = (e) => 1 + m * .45 * Math.sin(e * 1.73 + .7), g = (e) => 1 + m * .5 * Math.sin(e * 2.31 + 1.3), _ = (e) => m * 8 * Math.sin(e * 3.07 + .4), v = c.width * f, y = c.gap * f, b = c.offset * f, x = 50 - (c.count * v + (c.count - 1) * y) / 2 + b, S = [];
+		for (let e = 0; e < c.count; e++) {
+			let t = v * h(e), n = x, r = x + t, i = Math.tan((c.angle + _(e)) * Math.PI / 180) * (f / p) * 200 / 2, a = [
+				[n + i, -50],
+				[r + i, -50],
+				[r - i, 150],
+				[n - i, 150]
+			];
+			S.push({
+				points: a.map(([e, t]) => `${e.toFixed(3)},${t.toFixed(3)}`).join(" "),
+				opacity: Math.max(0, Math.min(c.opacity * g(e), 1))
+			}), x += v + y;
+		}
+		let C = c.gradientAngle * Math.PI / 180, w = Math.cos(C), T = Math.sin(C), E = 50 - w * 100 / 2, D = 50 - T * 100 / 2, O = 50 + w * 100 / 2, k = 50 + T * 100 / 2, A = Math.max(0, Math.min(c.gradientStart, 1)), j = Math.max(0, Math.min(c.gradientEnd, 1)), M = A <= j ? [
+			{
+				offset: 0,
+				color: "#fff"
+			},
+			{
+				offset: A,
+				color: "#fff"
+			},
+			{
+				offset: j,
+				color: "#000"
+			},
+			{
+				offset: 1,
+				color: "#000"
+			}
+		] : [
+			{
+				offset: 0,
+				color: "#000"
+			},
+			{
+				offset: j,
+				color: "#000"
+			},
+			{
+				offset: A,
+				color: "#fff"
+			},
+			{
+				offset: 1,
+				color: "#fff"
+			}
+		];
+		return /* @__PURE__ */ s(a, { children: [/* @__PURE__ */ s("defs", { children: [
+			/* @__PURE__ */ o("clipPath", {
+				id: l,
+				children: /* @__PURE__ */ o("path", { d: e.bodyPath })
+			}),
+			/* @__PURE__ */ o("linearGradient", {
+				id: d,
+				x1: E,
+				y1: D,
+				x2: O,
+				y2: k,
+				gradientUnits: "userSpaceOnUse",
+				children: M.map((e, t) => /* @__PURE__ */ o("stop", {
+					offset: e.offset,
+					stopColor: e.color
+				}, t))
+			}),
+			/* @__PURE__ */ o("mask", {
+				id: u,
+				maskUnits: "userSpaceOnUse",
+				x: "0",
+				y: "0",
+				width: "100",
+				height: "100",
+				children: /* @__PURE__ */ o("rect", {
+					x: "0",
+					y: "0",
+					width: "100",
+					height: "100",
+					fill: `url(#${d})`
+				})
+			})
+		] }), /* @__PURE__ */ o("g", {
+			clipPath: `url(#${l})`,
+			mask: `url(#${u})`,
+			children: S.map((e, t) => /* @__PURE__ */ o("polygon", {
+				points: e.points,
+				fill: c.color,
+				opacity: e.opacity
+			}, t))
+		})] });
+	},
+	zone: "foreground",
+	defaults: Dt
+}, kt = {
+	accent: "var(--badge-edge)",
+	topAlpha: .45,
+	upperAlpha: .7,
+	equator: 52,
+	equatorSpread: 12,
+	equatorTint: 95,
+	baseTint: 70,
+	glossTopAlpha: .7,
+	glossMidAlpha: .18,
+	glossExtent: 50,
+	bezelAlpha: .7,
+	bezelWidth: 1,
+	rimAlpha: .22,
+	rimWidth: 1
+}, At = 240, jt = {
+	Component: ({ sampler: e, boxW: n, boxH: r, variant: i, params: c }) => {
+		if (i !== "solid" && i !== "subtle" && i !== "outline") return null;
+		let l = {
+			...kt,
+			...c
+		}, u = t(), d = t(), f = t(), p = e.totalCss, m = [], h = null;
+		for (let t = 0; t < At; t++) {
+			let n = t / At * p, r = e.perimeterAt(n);
+			r.ny < 0 ? (h || (h = [], m.push(h)), h.push({
+				x: r.x,
+				y: r.y
+			})) : h = null;
+		}
+		if (m.length > 1) {
+			let t = e.perimeterAt(0), n = e.perimeterAt((At - 1) / At * p);
+			if (t.ny < 0 && n.ny < 0) {
+				let e = m.shift();
+				m[m.length - 1].push(...e);
+			}
+		}
+		let g = [];
+		for (let e of m) {
+			if (e.length < 2) continue;
+			let t = `M ${e[0].x.toFixed(3)} ${e[0].y.toFixed(3)}`;
+			for (let n = 1; n < e.length; n++) t += ` L ${e[n].x.toFixed(3)} ${e[n].y.toFixed(3)}`;
+			g.push(t);
+		}
+		let _ = 100 / n, v = 100 / r, y = Math.max(_, v), b = l.bezelWidth * y, x = l.rimWidth * y, S = Math.max(0, l.equator - l.equatorSpread), C = Math.min(100, l.equator + l.equatorSpread * 1.6), w = `color-mix(in srgb, ${l.accent} ${l.equatorTint}%, white)`, T = `color-mix(in srgb, ${l.accent} ${l.baseTint}%, black)`;
+		return /* @__PURE__ */ s(a, { children: [
+			/* @__PURE__ */ s("defs", { children: [
+				/* @__PURE__ */ s("linearGradient", {
+					id: u,
+					x1: "0%",
+					y1: "0%",
+					x2: "0%",
+					y2: "100%",
+					children: [
+						/* @__PURE__ */ o("stop", {
+							offset: "0%",
+							style: {
+								stopColor: l.accent,
+								stopOpacity: l.topAlpha
+							}
+						}),
+						/* @__PURE__ */ o("stop", {
+							offset: `${S}%`,
+							style: {
+								stopColor: l.accent,
+								stopOpacity: l.upperAlpha
+							}
+						}),
+						/* @__PURE__ */ o("stop", {
+							offset: `${l.equator}%`,
+							style: {
+								stopColor: w,
+								stopOpacity: 1
+							}
+						}),
+						/* @__PURE__ */ o("stop", {
+							offset: `${C}%`,
+							style: {
+								stopColor: l.accent,
+								stopOpacity: 1
+							}
+						}),
+						/* @__PURE__ */ o("stop", {
+							offset: "100%",
+							style: {
+								stopColor: T,
+								stopOpacity: 1
+							}
+						})
+					]
+				}),
+				/* @__PURE__ */ s("linearGradient", {
+					id: d,
+					x1: "0%",
+					y1: "0%",
+					x2: "0%",
+					y2: `${l.glossExtent}%`,
+					children: [
+						/* @__PURE__ */ o("stop", {
+							offset: "0%",
+							style: {
+								stopColor: "white",
+								stopOpacity: l.glossTopAlpha
+							}
+						}),
+						/* @__PURE__ */ o("stop", {
+							offset: "60%",
+							style: {
+								stopColor: "white",
+								stopOpacity: l.glossMidAlpha
+							}
+						}),
+						/* @__PURE__ */ o("stop", {
+							offset: "100%",
+							style: {
+								stopColor: "white",
+								stopOpacity: 0
+							}
+						})
+					]
+				}),
+				/* @__PURE__ */ o("clipPath", {
+					id: f,
+					children: /* @__PURE__ */ o("path", { d: e.bodyPath })
+				})
+			] }),
+			/* @__PURE__ */ o("path", {
+				d: e.bodyPath,
+				fill: `url(#${u})`,
+				style: { pointerEvents: "none" }
+			}),
+			/* @__PURE__ */ o("rect", {
+				x: "0",
+				y: "0",
+				width: "100",
+				height: l.glossExtent,
+				fill: `url(#${d})`,
+				clipPath: `url(#${f})`,
+				style: { pointerEvents: "none" }
+			}),
+			g.map((e, t) => /* @__PURE__ */ o("path", {
+				d: e,
+				fill: "none",
+				stroke: "white",
+				strokeOpacity: l.bezelAlpha,
+				strokeWidth: b,
+				strokeLinecap: "round",
+				vectorEffect: "non-scaling-stroke",
+				style: { pointerEvents: "none" }
+			}, `bz-${t}`)),
+			/* @__PURE__ */ o("path", {
+				d: e.bodyPath,
+				fill: "none",
+				stroke: "black",
+				strokeOpacity: l.rimAlpha,
+				strokeWidth: x,
+				vectorEffect: "non-scaling-stroke",
+				style: { pointerEvents: "none" }
+			})
+		] });
+	},
+	zone: "foreground",
+	defaults: kt
+}, Mt = {
+	accent: "#aab3bd",
+	specularity: .6,
+	equator: 50,
+	equatorSpread: 8,
+	topDarkness: 55,
+	baseDarkness: 35,
+	glossExtent: 50,
+	glossAlphaTop: .55,
+	bezelAlpha: .85,
+	bezelWidth: 1,
+	rimAlpha: .35,
+	rimWidth: 1
+}, Nt = 240, $ = {
+	spikes: Ze,
+	puffs: $e,
+	bites: tt,
+	scallops: rt,
+	bevel: ct,
+	bevel2: wt,
+	sheen: dt,
+	rivets: pt,
+	shadow: ht,
+	woodgrain: vt,
+	perforations: bt,
+	outline: Et,
+	sunbeams: Ot,
+	aqua: jt,
+	metal: {
+		Component: ({ sampler: e, boxW: n, boxH: r, variant: i, params: c }) => {
+			if (i !== "solid" && i !== "subtle" && i !== "outline") return null;
+			let l = {
+				...Mt,
+				...c
+			}, u = Math.max(0, Math.min(l.specularity, 1)), d = t(), f = t(), p = t(), m = e.totalCss, h = [], g = null;
+			for (let t = 0; t < Nt; t++) {
+				let n = t / Nt * m, r = e.perimeterAt(n);
+				r.ny < 0 ? (g || (g = [], h.push(g)), g.push({
+					x: r.x,
+					y: r.y
+				})) : g = null;
+			}
+			if (h.length > 1) {
+				let t = e.perimeterAt(0), n = e.perimeterAt((Nt - 1) / Nt * m);
+				if (t.ny < 0 && n.ny < 0) {
+					let e = h.shift();
+					h[h.length - 1].push(...e);
+				}
+			}
+			let _ = [];
+			for (let e of h) {
+				if (e.length < 2) continue;
+				let t = `M ${e[0].x.toFixed(3)} ${e[0].y.toFixed(3)}`;
+				for (let n = 1; n < e.length; n++) t += ` L ${e[n].x.toFixed(3)} ${e[n].y.toFixed(3)}`;
+				_.push(t);
+			}
+			let v = 100 / n, y = 100 / r, b = Math.max(v, y), x = l.bezelWidth * b, S = l.rimWidth * b, C = Math.max(0, l.equator - l.equatorSpread), w = Math.min(100, l.equator + l.equatorSpread), T = 100 - Math.round(u * 85), E = `color-mix(in srgb, ${l.accent} ${T}%, white)`, D = `color-mix(in srgb, ${l.accent} ${l.topDarkness}%, black)`, O = `color-mix(in srgb, ${l.accent} ${l.baseDarkness}%, black)`, k = 100 - Math.round(u * 50), A = 100 - Math.round(u * 30), j = `color-mix(in srgb, ${l.accent} ${k}%, white)`, M = `color-mix(in srgb, ${l.accent} ${A}%, white)`, N = l.glossAlphaTop * u, P = l.bezelAlpha * (.4 + .6 * u), F = l.rimAlpha * (.6 + .4 * u);
+			return /* @__PURE__ */ s(a, { children: [
+				/* @__PURE__ */ s("defs", { children: [
+					/* @__PURE__ */ s("linearGradient", {
+						id: d,
+						x1: "0%",
+						y1: "0%",
+						x2: "0%",
+						y2: "100%",
+						children: [
+							/* @__PURE__ */ o("stop", {
+								offset: "0%",
+								style: { stopColor: D }
+							}),
+							/* @__PURE__ */ o("stop", {
+								offset: `${C}%`,
+								style: { stopColor: j }
+							}),
+							/* @__PURE__ */ o("stop", {
+								offset: `${l.equator}%`,
+								style: { stopColor: E }
+							}),
+							/* @__PURE__ */ o("stop", {
+								offset: `${w}%`,
+								style: { stopColor: M }
+							}),
+							/* @__PURE__ */ o("stop", {
+								offset: "100%",
+								style: { stopColor: O }
+							})
+						]
+					}),
+					/* @__PURE__ */ s("linearGradient", {
+						id: f,
+						x1: "0%",
+						y1: "0%",
+						x2: "0%",
+						y2: `${l.glossExtent}%`,
+						children: [/* @__PURE__ */ o("stop", {
+							offset: "0%",
+							style: {
+								stopColor: "white",
+								stopOpacity: N
+							}
+						}), /* @__PURE__ */ o("stop", {
+							offset: "100%",
+							style: {
+								stopColor: "white",
+								stopOpacity: 0
+							}
+						})]
+					}),
+					/* @__PURE__ */ o("clipPath", {
+						id: p,
+						children: /* @__PURE__ */ o("path", { d: e.bodyPath })
+					})
+				] }),
+				/* @__PURE__ */ o("path", {
+					d: e.bodyPath,
+					fill: `url(#${d})`,
+					style: { pointerEvents: "none" }
+				}),
+				N > 0 && /* @__PURE__ */ o("rect", {
+					x: "0",
+					y: "0",
+					width: "100",
+					height: l.glossExtent,
+					fill: `url(#${f})`,
+					clipPath: `url(#${p})`,
+					style: { pointerEvents: "none" }
+				}),
+				_.map((e, t) => /* @__PURE__ */ o("path", {
+					d: e,
+					fill: "none",
+					stroke: "white",
+					strokeOpacity: P,
+					strokeWidth: x,
+					strokeLinecap: "round",
+					vectorEffect: "non-scaling-stroke",
+					style: { pointerEvents: "none" }
+				}, `bz-${t}`)),
+				/* @__PURE__ */ o("path", {
+					d: e.bodyPath,
+					fill: "none",
+					stroke: "black",
+					strokeOpacity: F,
+					strokeWidth: S,
+					vectorEffect: "non-scaling-stroke",
+					style: { pointerEvents: "none" }
+				})
+			] });
+		},
+		zone: "foreground",
+		defaults: Mt
+	}
+};
+//#endregion
+//#region src/components/Badge/Badge.tsx
+function Pt(e) {
+	return e.as ? e.as : e.href ? "a" : e.onClick ? "button" : "span";
+}
+function Ft(l) {
+	let { shape: u = "pill", tone: d = "neutral", variant: f = "outline", size: p = "sm", onClick: m, onRemove: h, removeLabel: g, href: _, children: v, className: y, shapeParams: b, bloat: x, padding: S, style: C, breakStyle: w, crawl: T, base: E, baseParams: D, effects: O } = l, k = l["aria-label"], A = Pt(l), [j, M] = i(!1), [N, P] = i(0), F = pe[u] ?? pe.pill, ee = pe[u] ? u : "pill", I = F.Component, te = {
+		...F.defaults ?? {},
+		...b ?? {}
+	};
+	e(() => {
+		if (!T) {
+			P(0);
+			return;
+		}
+		let e = typeof T == "number" ? T : .2, t = 0, n = performance.now(), r = (i) => {
+			let a = (i - n) / 1e3;
+			n = i, P((t) => (t + e * a) % 1), t = requestAnimationFrame(r);
+		};
+		return t = requestAnimationFrame(r), () => cancelAnimationFrame(t);
+	}, [T]);
+	let ne = [c.badge, y].filter(Boolean).join(" "), re = !E && F.compose ? F.compose(te) : null, ie = E ?? re?.base, L = ie ? Ye[ie] : null, ae = E ? D : re?.baseParams, oe = E ? O : re?.effects ?? O, R = L ? {
+		...L.defaults ?? {},
+		...ae ?? {}
+	} : null, se = r(null), [z, ce] = i({
+		w: 100,
+		h: 100
+	});
+	n(() => {
+		if (!L) return;
+		let e = se.current;
+		if (!e) return;
+		let t = () => {
+			let t = e.getBoundingClientRect();
+			t.width > 0 && t.height > 0 && ce({
+				w: t.width,
+				h: t.height
+			});
+		};
+		if (t(), typeof ResizeObserver > "u") return;
+		let n = new ResizeObserver(t);
+		return n.observe(e), () => n.disconnect();
+	}, [L]);
+	let B = L ? L.build(R, z.w, z.h) : null, V = L ? (typeof L.insets == "function" ? L.insets(R) : L.insets) ?? {
+		top: 0,
+		right: 0,
+		bottom: 0,
+		left: 0
+	} : typeof F.insets == "function" ? F.insets(te) : F.insets, le = {
+		className: ne,
+		style: {
+			"--badge-inset-top": `${V.top}px`,
+			"--badge-inset-right": `${V.right}px`,
+			"--badge-inset-bottom": `${V.bottom}px`,
+			"--badge-inset-left": `${V.left}px`,
+			...S !== void 0 && { padding: typeof S == "number" ? `${S}px` : S },
+			...w !== void 0 && {
+				boxDecorationBreak: w,
+				WebkitBoxDecorationBreak: w
+			},
+			...C
+		},
+		"data-shape": L ? "compose" : ee,
+		"data-tone": d,
+		"data-variant": f,
+		"data-size": p,
+		"data-focused": j ? "true" : void 0,
+		onFocus: () => M(!0),
+		onBlur: () => M(!1),
+		"aria-label": k
+	}, H = (() => {
+		if (!L || !B) return null;
+		let e = (oe ?? []).map((e) => {
+			let t = $[e.type];
+			if (!t?.offsetAt) return null;
+			let n = {
+				...t.defaults ?? {},
+				...e.params ?? {}
+			};
+			return {
+				offsetAt: t.offsetAt,
+				params: n
+			};
+		}).filter(Boolean), t = x ?? 0;
+		if (e.length === 0 && t === 0) return B;
+		let n = 100 / z.w, r = 100 / z.h, i = B.totalCss, a = (a) => {
+			let o = (a % i + i) % i, s = B.perimeterAt(o), c = s.nx * t, l = s.ny * t;
+			for (let t of e) {
+				let e = t.offsetAt(o, {
+					params: t.params,
+					phase: N,
+					totalCss: i,
+					perimeterAt: B.perimeterAt
+				});
+				c += e.dx, l += e.dy;
+			}
+			return {
+				x: s.x + c * n,
+				y: s.y + l * r
+			};
+		}, o = "";
+		for (let e = 0; e < 600; e++) {
+			let t = a(e / 600 * i);
+			o += e === 0 ? `M ${t.x.toFixed(3)} ${t.y.toFixed(3)}` : ` L ${t.x.toFixed(3)} ${t.y.toFixed(3)}`;
+		}
+		return o += " Z", {
+			bodyPath: o,
+			perimeterAt: (e) => {
+				let t = (e % i + i) % i, o = a(t), s = i / (600 * 2), c = a(t - s), l = a(t + s), u = (l.x - c.x) / n, d = (l.y - c.y) / r, f = Math.hypot(u, d) || 1, p = d / f, m = -u / f;
+				return {
+					x: o.x,
+					y: o.y,
+					nx: p,
+					ny: m
+				};
+			},
+			totalCss: i
+		};
+	})(), U = (oe ?? []).filter((e) => $[e.type]?.Component), ue = U.filter((e) => ($[e.type].zone ?? "foreground") === "background"), de = U.filter((e) => ($[e.type].zone ?? "foreground") === "foreground"), W = U.filter((e) => $[e.type].zone === "mask"), fe = `badge-mask-${t().replace(/:/g, "")}`, G = (e, t) => {
+		let n = $[e.type], r = n?.Component;
+		if (!r || !H) return null;
+		let i = {
+			...n.defaults ?? {},
+			...e.params ?? {}
+		};
+		return /* @__PURE__ */ o(r, {
+			sampler: H,
+			boxW: z.w,
+			boxH: z.h,
+			variant: f,
+			params: i,
+			phase: N
+		}, `${e.type}-${t}`);
+	}, K = /* @__PURE__ */ s(a, { children: [L && H ? /* @__PURE__ */ s("svg", {
+		ref: se,
+		className: c.deco,
+		viewBox: "0 0 100 100",
+		preserveAspectRatio: "none",
+		"aria-hidden": "true",
+		children: [
+			W.length > 0 && /* @__PURE__ */ o("defs", { children: /* @__PURE__ */ s("mask", {
+				id: fe,
+				maskUnits: "userSpaceOnUse",
+				x: "-10",
+				y: "-10",
+				width: "120",
+				height: "120",
+				children: [/* @__PURE__ */ o("rect", {
+					x: "-10",
+					y: "-10",
+					width: "120",
+					height: "120",
+					fill: "white"
+				}), W.map(G)]
+			}) }),
+			ue.map(G),
+			/* @__PURE__ */ s("g", {
+				...W.length > 0 ? { mask: `url(#${fe})` } : {},
+				children: [(f === "solid" || f === "subtle") && /* @__PURE__ */ o("path", {
+					className: "badge-fill",
+					d: H.bodyPath
+				}), (f === "outline" || f === "solid") && /* @__PURE__ */ o("path", {
+					className: "badge-stroke",
+					d: H.bodyPath
+				})]
+			}),
+			de.map(G)
+		]
+	}) : F.renderMode !== "css" && I ? /* @__PURE__ */ o("svg", {
+		className: c.deco,
+		viewBox: "0 0 100 100",
+		preserveAspectRatio: F.stretches === !1 ? "xMidYMid meet" : "none",
+		"aria-hidden": "true",
+		children: /* @__PURE__ */ o(I, {
+			variant: f,
+			focused: j,
+			params: te,
+			phase: N
+		})
+	}) : null, /* @__PURE__ */ s("span", {
+		className: c.content,
+		children: [/* @__PURE__ */ o("span", { children: v }), h && /* @__PURE__ */ o("button", {
+			type: "button",
+			className: c.remove,
+			"aria-label": g ?? "Remove",
+			onClick: (e) => {
+				e.stopPropagation(), h();
+			},
+			children: /* @__PURE__ */ o("svg", {
+				viewBox: "0 0 10 10",
+				width: "10",
+				height: "10",
+				"aria-hidden": "true",
+				focusable: "false",
+				children: /* @__PURE__ */ o("path", {
+					d: "M 2 2 L 8 8 M 8 2 L 2 8",
+					stroke: "currentColor",
+					strokeWidth: "1.6",
+					strokeLinecap: "round",
+					fill: "none"
+				})
+			})
+		})]
+	})] });
+	return A === "button" ? /* @__PURE__ */ o("button", {
+		type: "button",
+		...le,
+		onClick: m,
+		children: K
+	}) : A === "a" ? /* @__PURE__ */ o("a", {
+		href: _,
+		...le,
+		onClick: m,
+		children: K
+	}) : /* @__PURE__ */ o("span", {
+		...le,
+		children: K
+	});
+}
+//#endregion
+export { qe as n, Ft as t };
+
+//# sourceMappingURL=Badge-DU8ihE7Z.js.map