@walidsj/react-ui 0.1.1 → 0.1.3

package/dist/index.js

@@ -1,7 +1,6 @@
 import { Button as Button$1 } from "@base-ui/react/button";
 import { clsx } from "clsx";
 import { forwardRef } from "react";
-import { twMerge } from "tailwind-merge";
 import { jsx } from "react/jsx-runtime";
 import { Input as Input$1 } from "@base-ui/react/input";
 // node_modules/class-variance-authority/dist/index.mjs
@@ -56,18 +55,1176 @@ var cva = (base, config) => (props) => {
 		] : acc;
 	}, []), props === null || props === void 0 ? void 0 : props.class, props === null || props === void 0 ? void 0 : props.className);
 };
-// src/lib/cn.ts
-function cn(...inputs) {
-	return twMerge(clsx(inputs));
+// node_modules/cn/dist/tables.js
+var P = 48;
+var U = (s, o = 0) => {
+	const out = new Int32Array(s.length);
+	for (let i = 0; i < s.length; i++) out[i] = s.charCodeAt(i) - P - o;
+	return out;
+};
+var PS = (counts) => {
+	const out = new Int32Array(counts.length + 1);
+	for (let i = 0; i < counts.length; i++) out[i + 1] = out[i] + counts[i];
+	return out;
+};
+var DZ = (s) => {
+	const out = new Int32Array(s.length);
+	let a = 0;
+	for (let i = 0; i < s.length; i++) {
+		const z = s.charCodeAt(i) - P;
+		a += z >>> 1 ^ -(z & 1);
+		out[i] = a;
+	}
+	return out;
+};
+var GROUP_COUNT = 384;
+var customValidatorNames = [];
+var edgeStart = PS(U("E0500002005282000000002000150000020021820000011200000003022202000300004200120000200420001200021200301200010400162000010000220021010:2192001200220012000220012000200200200400010200040000000000400200108200110100000022010313000162002000020020012020080213000228200000000082000000000120002000120020020040101020300130001001010"));
+var labelStart = PS(U(":11111111211111119311546544411119731869:671397415686432441111111111161114151214313433415:78311132233313187211117221449443411141111151152226611131111112212518142224214215421421542142424242516171151615616347111111111197911327451111111111111111111113134714133513411111311111111111111111111112444411111342312715245411117:3"));
+var labelText = "@containerabcdefghinlmoprstunderlineviawzccentlignnimatespectuto-colsrowsaglorightnessckdrop-sisbcontrastfiltergrayscalehue-rotateinvertopacityslurrightnessaturateepia-coniclinearpositionradialsizeockurrderttom-belrstxyespacing-xyaretoursorlnt-umnsendspantartainentrasteividerop-shadowurationcorationlay-xyasendillexontromlter-featuresstretchapr-xyayscaleidow-colsrowsue-rotatedentlinesetvert-beringsxyeshadoweiadingftnest-clamp-imageabein-lrstxyskx--b-coniclpositionrsizet-x-y-fromto-fromto-inearfromto-fromto-adialfromto-fromtofromtofromtofromtoblockhinlinew-screenesblockhinlinewbjectpacityrutlinederigin-offsetbelrstxyesrspective-originaceholderioghtng-offsettateundedw-xyz-belrstlreseslr-endspantartaturatecepiahizekewpace-taleroll-xyz-barmpbelrstxyesbelrstxyes-thumbrackadowrink-xyxyartrokeabextora-shadowpckingnsformitionlate-xyz-offsetill-changeoom";
+var edgeTarget = (() => {
+	const N = edgeStart.length - 1;
+	const sizes = new Int32Array(N);
+	for (let i = N - 1; i >= 0; i--) {
+		let s = 1;
+		let c = i + 1;
+		for (let k = edgeStart[i]; k < edgeStart[i + 1]; k++) {
+			s += sizes[c];
+			c += sizes[c];
+		}
+		sizes[i] = s;
+	}
+	const out = new Int32Array(edgeStart[N]);
+	let e = 0;
+	for (let i = 0; i < N; i++) {
+		let c = i + 1;
+		for (let k = edgeStart[i]; k < edgeStart[i + 1]; k++) {
+			out[e++] = c;
+			c += sizes[c];
+		}
+	}
+	return out;
+})();
+var nodeGroup = U("02000000000000900<=0?000B000F00F00ŏI0J0LNPRTVX0000]_a00000000000000000000000rst0000000zŏ00000000000…ŏ000ˆ0000ŏ0000000000—0000000000000000000000000000000000000000000000000000Ë000000000000000000000Þ000000000000000000ð0000000ø0ùúûüýþÿĀāĂ㥹Ć000000000000000000000000000000000000000000ħ0ĨĪ00000000000000000000ļĽ00000Ŭ000000", 1);
+var vlistPat = PS(U("123333359346463635126536711576"));
+var vlistOps = U("93203242332583253248325D>E?F@03263243255B:032523853:0325B:8GA032542H<C=12727B:0328432553;D>E?3257D>032585:0325B:;0328B:032");
+var vlistRef = U("012113445661666666789111:5;;;;;;;;444;;;:62999<1161=62>>?61:21@ABCD4446996:64E:::;:?::64:F114GHHIHHHHIHH1HH1HH1HHHHHH::EEJ4444::EE4444441691;644444114244444:;K6666555555555555555999666664444444444444444444444226?6:66644L9M?D:111::::6DE199");
+var vlistGroup = DZ("020200202020020020020020020020200200200200200200200002020202001003040106000200200200200200200200200200200200200200200200200200200200200200200200200200200200020020020020020020002020200202002002002002002002002002002020002002020020200220200200200200200200200200200200020020020000200020002000200200200020020020002000200200200020020202002020202000200200020022000200200020020002002000200220002002000200W0Z00020020002002020002002000200g0j0002002000200200020020002002000200200020020002000200002000002002002002002000200020000200002002002002002002002020020020200200200200200200200200202020020020020020020020020002002002020020020020020020020020020020020020020020020020020020020020020020020020020020020020020020020020020020020020020020020020020020020020020020020020020020020020020020020020020002002002002002002000200200200200200200200200200020202020002000200020002002002002000020200200");
+var nodeVlist = (() => {
+	const out = (/* @__PURE__ */ new Int32Array(319)).fill(-1);
+	const A = DZ("02422242:222222242224222242442222222422222244442242226224222426222422442462222422622222222626222462242622422622422424242422222222422222222242422222222222222222622442224222222222222224424442262222222222222222222226224222424242422224422422422222");
+	const V = DZ("02222222222222222222202222222222222222222222221422222222222222222222222222222222222Y\\222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222221422222222222222222222222222222222222222Ŀł222222222222222222");
+	for (let i = 0; i < A.length; i++) out[A[i]] = V[i];
+	return out;
+})();
+var SETS = "container |break-after- all auto avoid avoid-page column left page right|break-before- all auto avoid avoid-page column left page right|break-inside-a uto void void-column void-page|box-decoration- clone slice|box- border content| contents flow-root hidden table table-caption table-cell table-column table-column-group table-footer-group table-header-group table-row table-row-group| not-sr-only sr-only|float- end left none right start|clear- both end left none right start|isolat e ion-auto|overflow- auto clip hidden scroll visible|overflow-x- auto clip hidden scroll visible|overflow-y- auto clip hidden scroll visible|overscroll- auto contain none|overscroll-x- auto contain none|overscroll-y- auto contain none| absolute fixed relative static sticky| collapse invisible visible|justify- around baseline between center center-safe end end-safe evenly normal start stretch|justify-items- center center-safe end end-safe normal start stretch|justify-self- auto center center-safe end end-safe start stretch|items- baseline baseline-last center center-safe end end-safe start stretch|self- auto baseline baseline-last center center-safe end end-safe start stretch|place-content- around baseline between center center-safe end end-safe evenly start stretch|place-items- baseline center center-safe end end-safe start stretch|place-self- auto center center-safe end end-safe start stretch| antialiased subpixel-antialiased| italic not-italic|normal-nums |ordinal |slashed-zero | lining-nums oldstyle-nums| proportional-nums tabular-nums| diagonal-fractions stacked-fractions| no-underline overline| capitalize lowercase normal-case uppercase|truncate |whitespace- break-spaces normal nowrap pre pre-line pre-wrap|break- all keep normal words|wrap- anywhere break-word normal|hyphens- auto manual none|mix-blend- color color-burn color-dodge darken difference exclusion hard-light hue lighten luminosity multiply normal overlay plus-darker plus-lighter saturation screen soft-light|table- auto fixed|caption- bottom top|backface- hidden visible|appearance- auto none|scheme- dark light light-dark normal only-dark only-light|field-sizing- content fixed|pointer-events- auto none|resize  -none -x -y|snap- align-none center end start|snap- always normal|snap- both none x y|snap- mandatory proximity|touch- auto manipulation none|touch-pan- left right x|touch-pan- down up y|touch-pinch-zoom |select- all auto none text|forced-color-adjust- auto none| normal size| baseline bottom middle sub super text-bottom text-top top| bounce none ping pulse spin| auto square video| auto fr max min px|none | auto full px| fixed local scroll|clip- border content padding text|origin- border content padding| bottom bottom-left bottom-right center left left-bottom left-top right right-bottom right-top top top-left top-right| no-repeat repeat repeat-round repeat-space repeat-x repeat-y| auto contain cover| gradient-to-b gradient-to-bl gradient-to-br gradient-to-l gradient-to-r gradient-to-t gradient-to-tl gradient-to-tr none|blend- color color-burn color-dodge darken difference exclusion hard-light hue lighten luminosity multiply normal overlay saturation screen soft-light|to- b bl br l r t tl tr| auto dvh fit full lh lvh max min px screen svh| dashed dotted double hidden none solid| collapse separate|px |auto |full | content none strict| inline-size size|layout |paint |style | around baseline between center center-safe end end-safe evenly normal start stretch| alias all-scroll auto cell col-resize context-menu copy crosshair default e-resize ew-resize grab grabbing help move n-resize ne-resize nesw-resize no-drop none not-allowed ns-resize nw-resize nwse-resize pointer progress row-resize s-resize se-resize sw-resize text vertical-text w-resize wait zoom-in zoom-out| dashed dotted double solid wavy| auto from-font|reverse |initial | in in-out initial linear out| col col-reverse row row-reverse| nowrap wrap wrap-reverse| auto initial none| black bold extrabold extralight light medium normal semibold thin| condensed expanded extra-condensed extra-expanded normal semi-condensed semi-expanded ultra-condensed ultra-expanded|flow- col col-dense dense row row-dense| none subgrid| auto dvh dvw fit full lh lvh lvw max min px screen svh svw| block flex grid table| auto dvw fit full lvw max min px screen svw| loose none normal px relaxed snug tight|through |item | inside outside| decimal disc none| auto px| clip-border clip-content clip-fill clip-padding clip-stroke clip-view no-clip| add exclude intersect subtract| alpha luminance match|origin- border content fill padding stroke view|type- alpha luminance| circle ellipse| closest-corner closest-side farthest-corner farthest-side|at- bottom bottom-left bottom-right center left left-bottom left-top right right-bottom right-top top top-left top-right| dvh fit full lh lvh max min none px screen svh| auto dvh dvw fit full lh lvh lvw max min none px screen svh svw| dvw fit full lvw max min none px screen svw| auto dvh dvw fit full lvh lvw max min none prose px svh svw| auto dvh dvw fit full lvh lvw max min none px screen svh svw| contain cover fill none scale-down| first last none| distant dramatic midrange near none normal|inset | full none|3d | auto smooth|gutter- auto both stable| auto none thin| inner none| auto dvh dvw fit full lvh lvw max min px svh svw|base | center end justify left right start| clip ellipsis| balance nowrap pretty wrap| normal tight tighter wide wider widest| cpu gpu none| 3d flat| all colors none opacity shadow transform| discrete normal| full px| auto dvh dvw fit full lvh lvw max min px screen svh svw| auto contents scroll transform".split("|").map((s) => {
+	const tails = s.split(" ");
+	const prefix = tails.shift();
+	for (let i = 0; i < tails.length; i++) tails[i] = prefix + tails[i];
+	return tails;
+});
+var AA = DZ("0000000000000000000000000000000000000000000000000000000000000262242:6@200000006:240B428:4422400002046044222426220026642642462026224222824220022400000000\\00N222422242222222224062242222222422226264222422222222222222442804222422222222222222222222220<4<0204260002444020204224422");
+var AG = DZ("ɠ222222222222222222222222222222222222222222222222222222222222˕4222226>ʶ22ʷʺʷ2ʸʷ42ʴ2ʓ22>621422ɶ222ɹɼɷɺɷɺ22ɱ42222ɨ2ɧ26622ɘɓ244ƸƵ222]d24242ǖǓƚÄȫ2263ȨȥȨ2222222ǣ222222222222222222ǂƽ2ƾƵ2222222422222ƜƑ22222222222222222222144Ŧţ22Ţş222222222222222222222ĸ2ı68ĦģĦɡŰ4Ġ«®ĝ822ĔđĔ2ē2222622");
+var AS = DZ("02222222222222222222222222222222222222222222222222222222222222222202022222222222EH2200IL021042222Y\\222IL0cf2e10j2222U00X202[^2y0000120|{~‚22…ˆ‡:22|22222222222G000q†OVI00000}š2›>40000ŒB00000I¨©000¬00000000000000021M®­00°“000000000000000000000–222›HGHa1º222¿2À2222ÉÌ000­°2±");
+var litAnchor = /* @__PURE__ */ new Int32Array(995);
+var litGroup = /* @__PURE__ */ new Int32Array(995);
+var litPool = /* @__PURE__ */ new Int32Array(995);
+var poolText = "";
+var poolOffsets = /* @__PURE__ */ new Int32Array(1038);
+{
+	const tailRef = /* @__PURE__ */ new Map();
+	let nextRef = 0;
+	let e = 0;
+	for (let i = 0; i < AA.length; i++) for (const tail of SETS[AS[i]]) {
+		let r = tailRef.get(tail);
+		if (r === void 0) {
+			r = nextRef++;
+			tailRef.set(tail, r);
+			poolOffsets[r * 2] = poolText.length;
+			poolOffsets[r * 2 + 1] = tail.length;
+			poolText += tail;
+		}
+		litAnchor[e] = AA[i];
+		litGroup[e] = AG[i];
+		litPool[e] = r;
+		e++;
+	}
 }
+var adjGid = DZ("0b2N:222@R>F@286¦2@H2D266226FB22B2>BD\\6N22222Z222D222p");
+var adjStart = PS(U("1::24444432:442:44:44>222222:44:4421322511111311111114"));
+var adjTgt = DZ("2Š4A;33N=C@H4A;33N=C@<27;83:;8393NQ:3NQʰ222ˉºŴŽ2R2=18cƴÅҜ=cĞÛC1ƈǝȈ:ħ25=11D3A@4=<1;1DEr25;11B3?<6;:371BCn9@7=<8192>2E121@9@EHE@9>2T25511<398454131<=V25511<398454131<=„ƧNž2Đå242L222290000f22500ɛ000ǘ222");
+var patGid = U("ij");
+var patTgt = U("—");
+var postfixLookupGroups = U("1");
+var tables_generated_default = {
+	GROUP_COUNT,
+	customValidatorNames,
+	edgeStart,
+	labelStart,
+	labelText,
+	edgeTarget,
+	nodeGroup,
+	nodeVlist,
+	vlistPat,
+	vlistOps,
+	vlistRef,
+	vlistGroup,
+	litAnchor,
+	litGroup,
+	litPool,
+	poolOffsets,
+	poolText,
+	adjGid,
+	adjStart,
+	adjTgt,
+	patGid,
+	patTgt,
+	postfixLookupGroups,
+	orderSensitiveModifiers: "* ** after backdrop before details-content file first-letter first-line marker placeholder selection"
+};
+// node_modules/cn/dist/engine.js
+var IS_JSC = "line" in /* @__PURE__ */ new Error();
+var EXTERNAL = -1;
+var DEAD = -1;
+var fnv = (str, s, e) => {
+	let h = 2166136261;
+	for (let p = s; p < e; p++) h = Math.imul(h ^ str.charCodeAt(p), 16777619);
+	return h;
+};
+var spanHash = (str, s, e) => {
+	const len = e - s;
+	let h = Math.imul(len, 2654435761) ^ str.charCodeAt(s);
+	if (len > 3) {
+		const q = len >> 2;
+		const m = len >> 1;
+		h = Math.imul(h ^ str.charCodeAt(s + 1) << 8 ^ str.charCodeAt(s + 2) << 16 ^ str.charCodeAt(s + q), 2246822507);
+		h = Math.imul(h ^ str.charCodeAt(s + m) << 8 ^ str.charCodeAt(s + m + q) << 16 ^ str.charCodeAt(e - 3), 3266489909);
+		h ^= str.charCodeAt(e - 2) << 8 ^ str.charCodeAt(e - 1) << 16;
+		for (let p = s + 3, q = e - 4; p < s + 8 && p < q; p++, q--) h = Math.imul(h ^ str.charCodeAt(p) ^ str.charCodeAt(q) << 8, 16777619);
+	}
+	return h ^ h >>> 15 | 0;
+};
+var createEngine = (T, validatorImpls, options = {}) => {
+	const { GROUP_COUNT, edgeStart, labelStart, labelText, edgeTarget, nodeGroup, nodeVlist, vlistPat, vlistOps, vlistRef, vlistGroup, litAnchor, litGroup, litPool, poolOffsets, poolText, adjGid, adjStart, adjTgt, patGid, patTgt, postfixLookupGroups, customValidatorNames, orderSensitiveModifiers } = T;
+	const adjRow = new Int32Array(GROUP_COUNT).fill(-1);
+	for (let i = 0; i < adjGid.length; i++) adjRow[adjGid[i]] = i;
+	let maxAdj = 0;
+	for (let r = 0; r + 1 < adjStart.length; r++) {
+		const n = adjStart[r + 1] - adjStart[r];
+		if (n > maxAdj) maxAdj = n;
+	}
+	let CLAIM_PER_TOKEN = 32;
+	while (CLAIM_PER_TOKEN < 2 * (1 + maxAdj + patGid.length)) CLAIM_PER_TOKEN <<= 1;
+	const vgStart = new Int32Array(vlistRef.length + 1);
+	for (let l = 0; l < vlistRef.length; l++) vgStart[l + 1] = vgStart[l] + vlistPat[vlistRef[l] + 1] - vlistPat[vlistRef[l]];
+	const postfixLookupSet = new Uint8Array(GROUP_COUNT);
+	for (let i = 0; i < postfixLookupGroups.length; i++) postfixLookupSet[postfixLookupGroups[i]] = 1;
+	const nodeCount = edgeStart.length - 1;
+	const nodeHasLit = new Uint8Array(nodeCount);
+	let litMaxLen = 0;
+	let litNoArb = true;
+	for (let i = 0; i < litAnchor.length; i++) {
+		nodeHasLit[litAnchor[i]] = 1;
+		const len = poolOffsets[litPool[i] * 2 + 1];
+		if (len > litMaxLen) litMaxLen = len;
+		const c0 = poolText.charCodeAt(poolOffsets[litPool[i] * 2]);
+		if (c0 === 91 || c0 === 40) litNoArb = false;
+	}
+	let LIT_SIZE = 1;
+	while (LIT_SIZE < litAnchor.length * 2) LIT_SIZE <<= 1;
+	const litTable = new Int32Array(LIT_SIZE).fill(-1);
+	for (let i = 0; i < litAnchor.length; i++) {
+		const off = poolOffsets[litPool[i] * 2];
+		let idx = (fnv(poolText, off, off + poolOffsets[litPool[i] * 2 + 1]) ^ Math.imul(litAnchor[i], 2654435761) | 0) & LIT_SIZE - 1;
+		while (litTable[idx] !== -1) idx = idx + 1 & LIT_SIZE - 1;
+		litTable[idx] = i;
+	}
+	const litProbe = (anchor, input, s, e) => {
+		let idx = (fnv(input, s, e) ^ Math.imul(anchor, 2654435761) | 0) & LIT_SIZE - 1;
+		const len = e - s;
+		for (;;) {
+			const entry = litTable[idx];
+			if (entry === -1) return -1;
+			if (litAnchor[entry] === anchor && poolOffsets[litPool[entry] * 2 + 1] === len) {
+				const off = poolOffsets[litPool[entry] * 2];
+				let ok = true;
+				for (let k = 0; k < len; k++) if (poolText.charCodeAt(off + k) !== input.charCodeAt(s + k)) {
+					ok = false;
+					break;
+				}
+				if (ok) return litGroup[entry];
+			}
+			idx = idx + 1 & LIT_SIZE - 1;
+		}
+	};
+	const cacheSize = options.cacheSize ?? 8192;
+	const RAW_PREFIX = options.prefix ?? T.prefix ?? "";
+	const FULL_PREFIX = RAW_PREFIX === "" ? "" : RAW_PREFIX + ":";
+	const FPL = FULL_PREFIX.length;
+	const vCustom = (customValidatorNames ?? []).map((name) => {
+		const fn = validatorImpls && validatorImpls[name];
+		if (!fn) throw new Error("cn: missing validator " + name);
+		return fn;
+	});
+	const lengthUnitRegex = /\d+(%|px|r?em|[sdl]?v([hwib]|min|max)|pt|pc|in|cm|mm|cap|ch|ex|r?lh|cq(w|h|i|b|min|max))|\b(calc|min|max|clamp)\(.+\)|^0$/;
+	const colorFunctionRegex = /^(rgba?|hsla?|hwb|(ok)?(lab|lch)|color-mix)\(.+\)$/;
+	const shadowRegex = /^(inset_)?-?((\d+)?\.?(\d+)[a-z]+|0)_-?((\d+)?\.?(\d+)[a-z]+|0)/;
+	const imageRegex = /^(url|image|image-set|cross-fade|element|(repeating-)?(linear|radial|conic)-gradient)\(.+\)$/;
+	let aKind = 0;
+	let aLabelS = -1;
+	let aLabelE = -1;
+	let aValS = -1;
+	let aValE = -1;
+	const isWordCode = (c) => c >= 97 && c <= 122 || c >= 65 && c <= 90 || c >= 48 && c <= 57 || c === 95;
+	const isUniWS = (c) => /\s/.test(String.fromCharCode(c));
+	const analyzeArb = (input, s, e) => {
+		aKind = 0;
+		aLabelS = -1;
+		if (e - s < 3) return;
+		const c0 = input.charCodeAt(s);
+		const cl = input.charCodeAt(e - 1);
+		if (c0 === 91 && cl === 93) aKind = 1;
+		else if (c0 === 40 && cl === 41) aKind = 2;
+		else return;
+		aValS = s + 1;
+		aValE = e - 1;
+		let p = s + 1;
+		if (isWordCode(input.charCodeAt(p))) {
+			p++;
+			while (p < e - 1) {
+				const c = input.charCodeAt(p);
+				if (!isWordCode(c) && c !== 45) break;
+				p++;
+			}
+			if (p < e - 2 && input.charCodeAt(p) === 58) {
+				aLabelS = s + 1;
+				aLabelE = p;
+				aValS = p + 1;
+			}
+		}
+	};
+	const spanEq = (input, s, e, str) => {
+		if (e - s !== str.length) return false;
+		for (let i = 0; i < str.length; i++) if (input.charCodeAt(s + i) !== str.charCodeAt(i)) return false;
+		return true;
+	};
+	const fractionRegex = /^\d+(?:\.\d+)?\/\d+(?:\.\d+)?$/;
+	const tshirtRegex = /^(\d+(\.\d+)?)?(xs|sm|md|lg|xl)$/;
+	const isNumStr = (v) => !!v && !Number.isNaN(Number(v));
+	const spanIsNamedContainerQuery = (input, s, e) => {
+		if (e - s < 11 || !spanEq(input, s, s + 10, "@container")) return false;
+		if (input.charCodeAt(s + 10) === 47) return e - s >= 12;
+		const c11 = input.charCodeAt(s + 11);
+		return c11 === 115 && e - s >= 17 && spanEq(input, s + 10, s + 16, "-size/") || c11 === 110 && e - s >= 19 && spanEq(input, s + 10, s + 18, "-normal/");
+	};
+	const VKIND = [
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		2,
+		2,
+		2,
+		2,
+		2,
+		2,
+		2
+	];
+	const VLABELS = "length|number|number weight|family-name|position percentage|length size bg-size|image url|shadow|length|family-name|position percentage|length size bg-size|image url|shadow|number weight".split("|").map((s) => s.split(" "));
+	const VFALL = [
+		2,
+		3,
+		1,
+		0,
+		0,
+		0,
+		4,
+		5,
+		0,
+		0,
+		0,
+		0,
+		0,
+		1,
+		1
+	];
+	const runValidator = (op, input, s, e) => {
+		if (op >= 10) {
+			if (op >= 25) return vCustom[op - 25](input.slice(s, e));
+			const i = op - 10;
+			if (aKind !== VKIND[i]) return false;
+			if (aLabelS >= 0) {
+				for (const L of VLABELS[i]) if (spanEq(input, aLabelS, aLabelE, L)) return true;
+				return false;
+			}
+			switch (VFALL[i]) {
+				case 0: return false;
+				case 1: return true;
+				case 2: {
+					const v = input.slice(aValS, aValE);
+					return lengthUnitRegex.test(v) && !colorFunctionRegex.test(v);
+				}
+				case 3: return isNumStr(input.slice(aValS, aValE));
+				case 4: return imageRegex.test(input.slice(aValS, aValE));
+				default: return shadowRegex.test(input.slice(aValS, aValE));
+			}
+		}
+		switch (op) {
+			case 0: return true;
+			case 1: return aKind === 0;
+			case 2: return aKind === 1;
+			case 3: return aKind === 2;
+			case 4: return fractionRegex.test(input.slice(s, e));
+			case 5: return isNumStr(input.slice(s, e));
+			case 6: {
+				const v = input.slice(s, e);
+				return !!v && Number.isInteger(Number(v));
+			}
+			case 7: return e > s && input.charCodeAt(e - 1) === 37 && isNumStr(input.slice(s, e - 1));
+			case 8: return tshirtRegex.test(input.slice(s, e));
+			default: return spanIsNamedContainerQuery(input, s, e);
+		}
+	};
+	const orderSensitive = new Set(typeof orderSensitiveModifiers === "string" ? orderSensitiveModifiers.split(" ") : orderSensitiveModifiers);
+	const internSpan = (map, input, s, e, imp, make) => {
+		const h = fnv(input, s, e) ^ (imp ? 2654435769 : 0) | 0;
+		let bucket = map.get(h);
+		if (bucket !== void 0) outer: for (let b = 0; b < bucket.length; b++) {
+			const en = bucket[b];
+			if (en.imp !== imp || en.k.length !== e - s) continue;
+			for (let i = 0; i < en.k.length; i++) if (en.k.charCodeAt(i) !== input.charCodeAt(s + i)) continue outer;
+			return en.id;
+		}
+		else map.set(h, bucket = []);
+		const k = input.slice(s, e);
+		const id = make(k);
+		bucket.push({
+			k,
+			imp,
+			id
+		});
+		return id;
+	};
+	let ctxByHash = /* @__PURE__ */ new Map();
+	let ctxByCanon = /* @__PURE__ */ new Map();
+	let nextCtxId = 2;
+	const MAX_CTX = 4096;
+	const canonicalizeContext = (raw, important) => {
+		const mods = [];
+		let dB = 0, dP = 0, start = 0;
+		for (let i = 0; i < raw.length; i++) {
+			const c = raw.charCodeAt(i);
+			if (dB === 0 && dP === 0 && c === 58) {
+				mods.push(raw.slice(start, i));
+				start = i + 1;
+			} else if (c === 91) dB++;
+			else if (c === 93) dB--;
+			else if (c === 40) dP++;
+			else if (c === 41) dP--;
+		}
+		mods.push(raw.slice(start));
+		let canonical = mods[0];
+		if (mods.length > 1) {
+			const result = [];
+			let segment = [];
+			for (const mod of mods) if (mod.charCodeAt(0) === 91 || orderSensitive.has(mod)) {
+				if (segment.length) {
+					result.push(...segment.sort());
+					segment = [];
+				}
+				result.push(mod);
+			} else segment.push(mod);
+			if (segment.length) result.push(...segment.sort());
+			canonical = result.join(":");
+		}
+		const key = important ? canonical + " !" : canonical;
+		let id = ctxByCanon.get(key);
+		if (id === void 0) ctxByCanon.set(key, id = nextCtxId++);
+		return id;
+	};
+	let dynByHash = /* @__PURE__ */ new Map();
+	let nextDynId = GROUP_COUNT;
+	const MAX_DYN = GROUP_COUNT + 4096;
+	const newDynId = () => nextDynId++;
+	const ID_LIMIT = 2097152;
+	const TOKEN_TABLE = 8192;
+	const memoHash = new Int32Array(TOKEN_TABLE);
+	const memoStr = new Array(TOKEN_TABLE).fill(null);
+	const memoGid = new Int32Array(TOKEN_TABLE);
+	const memoCtx = new Int32Array(TOKEN_TABLE);
+	const memoFlags = new Uint8Array(TOKEN_TABLE);
+	let memoTick = 0;
+	const memoPut = (way0, input, ts, te, h, gid, ctxId, flags) => {
+		let slot = way0;
+		if (memoStr[way0] !== null) {
+			if (memoStr[way0 | 1] === null) slot = way0 | 1;
+			else if ((memoTick++ & 3) === 0) slot = way0 | memoTick >> 2 & 1;
+			else return;
+		}
+		memoStr[slot] = input.slice(ts, te);
+		memoHash[slot] = h;
+		memoGid[slot] = gid;
+		memoCtx[slot] = ctxId;
+		memoFlags[slot] = flags;
+	};
+	const memoReset = () => memoStr.fill(null);
+	let cap = 256;
+	let tokI32 = [
+		new Int32Array(cap),
+		new Int32Array(cap),
+		new Int32Array(cap),
+		new Int32Array(cap)
+	];
+	let [tokStart, tokEnd, tokGid, tokCtx] = tokI32;
+	let tokFlags = new Uint8Array(cap);
+	let keep = new Uint8Array(cap);
+	const growTokens = () => {
+		cap *= 2;
+		tokI32 = tokI32.map((a) => {
+			const n = new Int32Array(cap);
+			n.set(a);
+			return n;
+		});
+		[tokStart, tokEnd, tokGid, tokCtx] = tokI32;
+		const nf = new Uint8Array(cap);
+		nf.set(tokFlags);
+		tokFlags = nf;
+		keep = new Uint8Array(cap);
+	};
+	let ckptCap = 64;
+	let ckptNode = new Int32Array(ckptCap);
+	let ckptTail = new Int32Array(ckptCap);
+	const claim0 = new Int32Array(GROUP_COUNT);
+	let CLAIM_TABLE = 2048;
+	let claimShift = 21;
+	let claimKeys = new Float64Array(CLAIM_TABLE);
+	let claimEpochs = new Int32Array(CLAIM_TABLE);
+	let epoch = 0;
+	const claimTest = (ctx, gid) => {
+		if (ctx === 0 && gid < GROUP_COUNT) {
+			if (claim0[gid] === epoch) return 1;
+			claim0[gid] = epoch;
+			return 0;
+		}
+		const key = ctx * 2097152 + gid + 1;
+		let idx = Math.imul(key, 2654435761) >>> claimShift;
+		for (;;) {
+			if (claimEpochs[idx] !== epoch) break;
+			if (claimKeys[idx] === key) return 1;
+			idx = idx + 1 & CLAIM_TABLE - 1;
+		}
+		claimKeys[idx] = key;
+		claimEpochs[idx] = epoch;
+		return 0;
+	};
+	const resolveAt = (input, bs, endPos, nodeAt, ckptAt) => {
+		if (endPos - bs >= 2 && input.charCodeAt(bs) === 91 && input.charCodeAt(endPos - 1) === 93) {
+			let colon = -1;
+			for (let p = bs + 1; p < endPos - 1; p++) if (input.charCodeAt(p) === 58) {
+				colon = p;
+				break;
+			}
+			if (colon === -1 || colon === bs + 1) return EXTERNAL;
+			return internSpan(dynByHash, input, bs + 1, colon, 0, newDynId);
+		}
+		if (nodeAt >= 0 && nodeGroup[nodeAt] >= 0) return nodeGroup[nodeAt];
+		for (let k = ckptAt - 1; k >= 0; k--) {
+			const tailStart = ckptTail[k];
+			if (tailStart > endPos) continue;
+			const nodeId = ckptNode[k];
+			const tlen = endPos - tailStart;
+			if (nodeHasLit[nodeId] === 1 && tlen > 0 && tlen <= litMaxLen) {
+				const c0 = input.charCodeAt(tailStart);
+				if (litNoArb === false || c0 !== 91 && c0 !== 40) {
+					const g = litProbe(nodeId, input, tailStart, endPos);
+					if (g >= 0) return g;
+				}
+			}
+			const vl = nodeVlist[nodeId];
+			if (vl < 0) continue;
+			const pat = vlistRef[vl];
+			const vs = vlistPat[pat];
+			const ve = vlistPat[pat + 1];
+			if (vs === ve) continue;
+			analyzeArb(input, tailStart, endPos);
+			const g0 = vgStart[vl] - vs;
+			for (let v = vs; v < ve; v++) if (runValidator(vlistOps[v], input, tailStart, endPos)) return vlistGroup[g0 + v];
+		}
+		return EXTERNAL;
+	};
+	const mergeClassList = (input) => {
+		const n = input.length;
+		let tokenCount = 0;
+		let totalTokenChars = 0;
+		let sawNonSpaceWS = false;
+		if (nextCtxId > MAX_CTX || ctxByHash.size > MAX_CTX) {
+			ctxByHash = /* @__PURE__ */ new Map();
+			ctxByCanon = /* @__PURE__ */ new Map();
+			nextCtxId = 2;
+			memoReset();
+		}
+		if (nextDynId > MAX_DYN) {
+			dynByHash = /* @__PURE__ */ new Map();
+			nextDynId = GROUP_COUNT;
+			memoReset();
+		}
+		let i = 0;
+		while (i < n) {
+			let c = input.charCodeAt(i);
+			if (c === 32 || c >= 9 && c <= 13 || c >= 160 && isUniWS(c)) {
+				if (c !== 32) sawNonSpaceWS = true;
+				i++;
+				continue;
+			}
+			const ts = i;
+			let th = 0;
+			while (i < n) {
+				c = input.charCodeAt(i);
+				if (c <= 32) {
+					if (c === 32) break;
+					if (c >= 9 && c <= 13) {
+						sawNonSpaceWS = true;
+						break;
+					}
+				} else if (c >= 160 && isUniWS(c)) {
+					sawNonSpaceWS = true;
+					break;
+				}
+				th = Math.imul(th ^ c, 16777619);
+				i++;
+			}
+			const te = i;
+			const len = te - ts;
+			if (tokenCount === cap) growTokens();
+			const t = tokenCount++;
+			tokStart[t] = ts;
+			tokEnd[t] = te;
+			totalTokenChars += len;
+			th ^= Math.imul(len, 2654435761);
+			const h = th ^ th >>> 15 | 0;
+			const way0 = h & 8190;
+			{
+				let hitAt = -1;
+				if (memoHash[way0] === h && memoStr[way0] !== null && memoStr[way0].length === len) hitAt = way0;
+				else if (memoHash[way0 | 1] === h && memoStr[way0 | 1] !== null && memoStr[way0 | 1].length === len) hitAt = way0 | 1;
+				if (hitAt >= 0) {
+					const s = memoStr[hitAt];
+					let ok = true;
+					for (let k = 0; k < len; k++) if (s.charCodeAt(k) !== input.charCodeAt(ts + k)) {
+						ok = false;
+						break;
+					}
+					if (ok) {
+						tokGid[t] = memoGid[hitAt];
+						tokCtx[t] = memoCtx[hitAt];
+						tokFlags[t] = memoFlags[hitAt];
+						continue;
+					}
+				}
+			}
+			let pts = ts;
+			if (FPL !== 0) {
+				if (te - ts <= FPL || !input.startsWith(FULL_PREFIX, ts)) {
+					tokGid[t] = EXTERNAL;
+					memoPut(way0, input, ts, te, h, EXTERNAL, 0, 0);
+					continue;
+				}
+				pts = ts + FPL;
+			}
+			let depthB = 0, depthP = 0;
+			let lastColon = -1, lastSlash = -1;
+			for (let p = pts; p < te; p++) {
+				const pc = input.charCodeAt(p);
+				if (depthB === 0 && depthP === 0) {
+					if (pc === 58) {
+						lastColon = p;
+						continue;
+					}
+					if (pc === 47) {
+						lastSlash = p;
+						continue;
+					}
+				}
+				if (pc === 91) depthB++;
+				else if (pc === 93) depthB--;
+				else if (pc === 40) depthP++;
+				else if (pc === 41) depthP--;
+			}
+			const modStart = lastColon >= pts ? lastColon + 1 : pts;
+			let bs = modStart;
+			let be = te;
+			let important = false;
+			let prefixShift = 0;
+			if (be > bs && input.charCodeAt(be - 1) === 33) {
+				important = true;
+				be--;
+			} else if (be > bs && input.charCodeAt(bs) === 33) {
+				important = true;
+				bs++;
+				prefixShift = 1;
+			}
+			let postfixEnd = -1;
+			if (lastSlash > modStart) {
+				postfixEnd = lastSlash + prefixShift;
+				if (postfixEnd >= be) postfixEnd = -1;
+			}
+			let feedStart = bs;
+			if (be - bs > 1 && input.charCodeAt(bs) === 45) feedStart = bs + 1;
+			let node = 0;
+			let lp = 0;
+			let le = 0;
+			let pending = -1;
+			let ckptTop = 0;
+			if (nodeVlist[0] >= 0 || nodeHasLit[0] === 1) {
+				ckptNode[0] = 0;
+				ckptTail[0] = feedStart;
+				ckptTop = 1;
+			}
+			let slashNode = DEAD;
+			let slashCkpt = 0;
+			for (let p = feedStart; p < be; p++) {
+				if (p === postfixEnd) {
+					slashNode = lp < le ? DEAD : node;
+					slashCkpt = ckptTop;
+				}
+				if (node !== DEAD) {
+					const cc = input.charCodeAt(p);
+					let arrived = -1;
+					if (lp < le) {
+						if (labelText.charCodeAt(lp) === cc) {
+							lp++;
+							if (lp === le) arrived = node = pending;
+						} else node = DEAD;
+					} else {
+						const es = edgeStart[node];
+						const ee = edgeStart[node + 1];
+						let next = DEAD;
+						for (let e = es; e < ee; e++) {
+							const ls = labelStart[e];
+							if (labelText.charCodeAt(ls) === cc) {
+								if (labelStart[e + 1] - ls === 1) arrived = next = edgeTarget[e];
+								else {
+									lp = ls + 1;
+									le = labelStart[e + 1];
+									pending = edgeTarget[e];
+									next = node;
+								}
+								break;
+							}
+						}
+						node = next;
+					}
+					if (arrived >= 0 && (nodeVlist[arrived] >= 0 || nodeHasLit[arrived] === 1) && p + 1 < be && input.charCodeAt(p + 1) === 45) {
+						if (ckptTop === ckptCap) {
+							ckptCap *= 2;
+							const nv = new Int32Array(ckptCap);
+							nv.set(ckptNode);
+							ckptNode = nv;
+							const nt = new Int32Array(ckptCap);
+							nt.set(ckptTail);
+							ckptTail = nt;
+						}
+						ckptNode[ckptTop] = arrived;
+						ckptTail[ckptTop] = p + 2;
+						ckptTop++;
+					}
+				}
+			}
+			if (postfixEnd === be) {
+				slashNode = lp < le ? DEAD : node;
+				slashCkpt = ckptTop;
+			}
+			const endNode = lp < le ? DEAD : node;
+			let gid;
+			let hasPostfix = false;
+			if (postfixEnd >= 0) {
+				hasPostfix = true;
+				gid = resolveAt(input, bs, postfixEnd, slashNode, slashCkpt);
+				if (gid !== EXTERNAL && gid < GROUP_COUNT && postfixLookupSet[gid]) {
+					const gidFull = resolveAt(input, bs, be, endNode, ckptTop);
+					if (gidFull !== EXTERNAL && gidFull !== gid) {
+						gid = gidFull;
+						hasPostfix = false;
+					}
+				} else if (gid === EXTERNAL) {
+					gid = resolveAt(input, bs, be, endNode, ckptTop);
+					hasPostfix = false;
+				}
+			} else gid = resolveAt(input, bs, be, endNode, ckptTop);
+			let ctxId = 0;
+			let flags = 0;
+			if (gid === EXTERNAL) tokGid[t] = EXTERNAL;
+			else {
+				flags = hasPostfix ? 1 : 0;
+				ctxId = pts >= lastColon ? important ? 1 : 0 : internSpan(ctxByHash, input, pts, lastColon, important ? 1 : 0, (k) => canonicalizeContext(k, important));
+				tokGid[t] = gid;
+				tokFlags[t] = flags;
+				tokCtx[t] = ctxId;
+			}
+			memoPut(way0, input, ts, te, h, gid, ctxId, flags);
+		}
+		if (tokenCount === 0) return "";
+		if (tokenCount === 1) return tokStart[0] === 0 && tokEnd[0] === n ? input : input.slice(tokStart[0], tokEnd[0]);
+		if (tokenCount * CLAIM_PER_TOKEN > CLAIM_TABLE) {
+			while (tokenCount * CLAIM_PER_TOKEN > CLAIM_TABLE) {
+				CLAIM_TABLE <<= 1;
+				claimShift--;
+			}
+			claimKeys = new Float64Array(CLAIM_TABLE);
+			claimEpochs = new Int32Array(CLAIM_TABLE);
+		}
+		if (nextCtxId >= ID_LIMIT || nextDynId >= ID_LIMIT) throw new Error("cn: too many distinct classes in one merge");
+		epoch = epoch + 1 | 0;
+		if (epoch === 0) {
+			claim0.fill(0);
+			claimEpochs.fill(0);
+			epoch = 1;
+		}
+		let didDrop = false;
+		for (let t = tokenCount - 1; t >= 0; t--) {
+			const gid = tokGid[t];
+			if (gid === EXTERNAL) {
+				keep[t] = 1;
+				continue;
+			}
+			const ctxId = tokCtx[t];
+			if (claimTest(ctxId, gid) === 1) {
+				keep[t] = 0;
+				didDrop = true;
+				continue;
+			}
+			keep[t] = 1;
+			if (gid < GROUP_COUNT) {
+				const r = adjRow[gid];
+				if (r >= 0) for (let k = adjStart[r]; k < adjStart[r + 1]; k++) claimTest(ctxId, adjTgt[k]);
+				if (tokFlags[t] & 1) {
+					for (let k = 0; k < patGid.length; k++) if (patGid[k] === gid) claimTest(ctxId, patTgt[k]);
+				}
+			}
+		}
+		if (!didDrop && !sawNonSpaceWS && n === totalTokenChars + tokenCount - 1) return input;
+		let out = "";
+		let t = 0;
+		while (t < tokenCount) {
+			if (!keep[t]) {
+				t++;
+				continue;
+			}
+			const runStart = tokStart[t];
+			let runEnd = tokEnd[t];
+			let u = t + 1;
+			while (u < tokenCount && keep[u] && tokStart[u] === runEnd + 1 && input.charCodeAt(runEnd) === 32) {
+				runEnd = tokEnd[u];
+				u++;
+			}
+			if (out.length > 0) out += " ";
+			out += input.slice(runStart, runEnd);
+			t = u;
+		}
+		return out;
+	};
+	const DOOR_SIZE = 16384;
+	const door = new Int32Array(DOOR_SIZE * 2);
+	let doorBase = 0;
+	let doorEpoch = 1;
+	let cache = Object.create(null);
+	let prevCache = Object.create(null);
+	let cacheMap = /* @__PURE__ */ new Map();
+	let prevCacheMap = /* @__PURE__ */ new Map();
+	let cacheCount = 0;
+	let doorMarks = 0;
+	const rotateDoor = () => {
+		doorBase ^= DOOR_SIZE;
+		doorEpoch = doorEpoch + 1 | 0;
+		doorMarks = 0;
+	};
+	const mergeCached = (input) => {
+		let merged = cache[input];
+		if (merged !== void 0) return merged;
+		const hash = spanHash(input, 0, input.length);
+		const slot = (hash & 16383) + doorBase;
+		const wasSeen = door[slot] === (hash ^ doorEpoch) || door[slot ^ DOOR_SIZE] === (hash ^ doorEpoch - 1);
+		if (wasSeen) {
+			merged = prevCache[input];
+			if (merged !== void 0) {
+				cache[input] = merged;
+				return merged;
+			}
+		}
+		merged = mergeClassList(input);
+		if (wasSeen) {
+			cache[input] = merged;
+			if (++cacheCount > cacheSize) {
+				cacheCount = 0;
+				prevCache = cache;
+				cache = Object.create(null);
+				rotateDoor();
+			}
+		} else {
+			door[slot] = hash ^ doorEpoch;
+			if (++doorMarks > DOOR_SIZE) rotateDoor();
+		}
+		return merged;
+	};
+	const mergeCachedMap = (input) => {
+		let merged = cacheMap.get(input);
+		if (merged !== void 0) return merged;
+		const hash = spanHash(input, 0, input.length);
+		const slot = (hash & 16383) + doorBase;
+		const wasSeen = door[slot] === (hash ^ doorEpoch) || door[slot ^ DOOR_SIZE] === (hash ^ doorEpoch - 1);
+		if (wasSeen) {
+			merged = prevCacheMap.get(input);
+			if (merged !== void 0) {
+				cacheMap.set(input, merged);
+				return merged;
+			}
+		}
+		merged = mergeClassList(input);
+		if (wasSeen) {
+			cacheMap.set(input, merged);
+			if (++cacheCount > cacheSize) {
+				cacheCount = 0;
+				prevCacheMap = cacheMap;
+				cacheMap = /* @__PURE__ */ new Map();
+				rotateDoor();
+			}
+		} else {
+			door[slot] = hash ^ doorEpoch;
+			if (++doorMarks > DOOR_SIZE) rotateDoor();
+		}
+		return merged;
+	};
+	const seenBefore = (input) => {
+		const hash = spanHash(input, 0, input.length);
+		const slot = (hash & 16383) + doorBase;
+		if (door[slot] === (hash ^ doorEpoch) || door[slot ^ DOOR_SIZE] === (hash ^ doorEpoch - 1)) return true;
+		door[slot] = hash ^ doorEpoch;
+		if (++doorMarks > DOOR_SIZE) rotateDoor();
+		return false;
+	};
+	const mergeString = cacheSize === 0 ? mergeClassList : IS_JSC ? (input) => {
+		const merged = cacheMap.get(input);
+		return merged !== void 0 ? merged : mergeCachedMap(input);
+	} : mergeCached;
+	const merge = function() {
+		return arguments.length === 1 && typeof arguments[0] === "string" ? mergeString(arguments[0]) : mergeString(twJoin.apply(null, arguments));
+	};
+	return {
+		merge,
+		mergeString,
+		seenBefore: cacheSize === 0 ? () => false : seenBefore,
+		mergeUncached: mergeClassList
+	};
+};
+var resolveValue = (v, clsxMode) => {
+	if (!v) return "";
+	if (typeof v === "string") return v;
+	let out = "";
+	if (typeof v.length === "number" && (clsxMode ? Array.isArray(v) : true)) {
+		const arr = v;
+		for (let i = 0; i < arr.length; i++) {
+			const item = arr[i];
+			if (!item) continue;
+			const r = typeof item === "string" ? item : resolveValue(item, clsxMode);
+			if (r) {
+				if (out) out += " ";
+				out += r;
+			}
+		}
+		return out;
+	}
+	if (clsxMode) {
+		if (typeof v === "number") return "" + v;
+		if (typeof v === "object") {
+			for (const k in v) if (v[k]) {
+				if (out) out += " ";
+				out += k;
+			}
+		}
+	}
+	return out;
+};
+var joinArgs = (args, clsxMode) => {
+	let s = "";
+	for (let i = 0; i < args.length; i++) {
+		const a = args[i];
+		if (!a) continue;
+		const r = typeof a === "string" ? a : resolveValue(a, clsxMode);
+		if (r) {
+			if (s) s += " ";
+			s += r;
+		}
+	}
+	return s;
+};
+/** join-only, `twJoin`-compatible (strings + nested arrays, falsy skipped) */
+var twJoin = function() {
+	return joinArgs(arguments, false);
+};
+var BUCKET_CAP = 256;
+var BUCKET_MISS_CAP = 16;
+var BUCKET_SKIP = 1024;
+var CHURN_SIZE = 4096;
+var wrapClsx = (mergeString, fresh) => {
+	const seenBefore = fresh === void 0 ? () => true : fresh.seenBefore;
+	const mergeUncached = fresh === void 0 ? mergeString : fresh.mergeUncached;
+	let argCache = /* @__PURE__ */ new Map();
+	let prevArgCache = /* @__PURE__ */ new Map();
+	let argCount = 0;
+	let lastHit = null;
+	let churnKey = null;
+	let churnOwn = [];
+	let churnVal = [];
+	let churnTick = 0;
+	const churnLookup = (key, own, join) => {
+		if (churnKey === null) {
+			churnKey = new Array(CHURN_SIZE).fill("");
+			churnOwn = new Array(CHURN_SIZE).fill("");
+			churnVal = new Array(CHURN_SIZE).fill("");
+		}
+		const way0 = spanHash(key, 0, key.length) & 4094;
+		if (churnKey[way0] === key && churnOwn[way0] === own) return churnVal[way0];
+		if (churnKey[way0 | 1] === key && churnOwn[way0 | 1] === own) return churnVal[way0 | 1];
+		const merged = mergeString(join ? own + " " + key : key);
+		const slot = churnKey[way0] === "" ? way0 : way0 | (churnKey[way0 | 1] === "" ? 1 : churnTick++ & 1);
+		churnKey[slot] = key;
+		churnOwn[slot] = own;
+		churnVal[slot] = merged;
+		return merged;
+	};
+	const match3 = (e, v0, v1, v2) => {
+		let k = 0;
+		if (v0) {
+			if (v0 !== e.a0) return false;
+			k = 1;
+		}
+		if (v1) {
+			if (v1 !== (k === 0 ? e.a0 : e.a1)) return false;
+			k++;
+		}
+		if (v2) {
+			if (v2 !== (k === 0 ? e.a0 : k === 1 ? e.a1 : e.a2)) return false;
+			k++;
+		}
+		return k === e.t;
+	};
+	const matchN = (e, vals) => {
+		const ea = e.a;
+		let k = 0;
+		for (let i = 0; i < vals.length; i++) {
+			const v = vals[i];
+			if (!v) continue;
+			if (v !== ea[k]) return false;
+			k++;
+		}
+		return k === e.t;
+	};
+	const resolveArgs = (vals, probed) => {
+		const nArgs = vals.length;
+		const pred = lastHit === null ? null : lastHit.n;
+		if (!probed) {
+			if (pred !== null && matchN(pred, vals)) {
+				lastHit = pred;
+				return pred.r;
+			}
+			if (lastHit !== null && lastHit !== pred && matchN(lastHit, vals)) return lastHit.r;
+		}
+		let first = "";
+		let firstIdx = -1;
+		let truthy = 0;
+		let hasResolvedValue = false;
+		for (let i = 0; i < nArgs; i++) {
+			let v = vals[i];
+			if (!v) continue;
+			if (typeof v !== "string") {
+				v = vals[i] = resolveValue(v, true);
+				if (!v) continue;
+				hasResolvedValue = true;
+			}
+			if (firstIdx < 0) {
+				first = v;
+				firstIdx = i;
+			}
+			truthy++;
+		}
+		if (truthy === 0) return "";
+		if (truthy === 1) return mergeString(first);
+		if (hasResolvedValue) {
+			if (pred !== null && matchN(pred, vals)) {
+				lastHit = pred;
+				return pred.r;
+			}
+			if (lastHit !== null && lastHit !== pred && matchN(lastHit, vals)) return lastHit.r;
+		}
+		let bucket = argCache.get(first);
+		if (bucket === void 0) {
+			bucket = prevArgCache.get(first);
+			if (bucket !== void 0) argCache.set(first, bucket);
+		}
+		let hit = null;
+		if (bucket !== void 0) {
+			if (bucket.skip > 0) {
+				bucket.skip--;
+				lastHit = null;
+				let joined = first;
+				for (let i = firstIdx + 1; i < nArgs; i++) {
+					const v = vals[i];
+					if (v) joined += " " + v;
+				}
+				return churnLookup(joined, "", false);
+			}
+			const entries = bucket.e;
+			outer: for (let b = 0; b < entries.length; b++) {
+				const e = entries[b];
+				if (e.t !== truthy) continue;
+				const ea = e.a;
+				let k = 1;
+				for (let i = firstIdx + 1; i < nArgs; i++) {
+					const v = vals[i];
+					if (v && v !== ea[k++]) continue outer;
+				}
+				hit = e;
+				break;
+			}
+			if (hit !== null) bucket.miss = 0;
+		}
+		if (hit === null) {
+			let joined = first;
+			const a = [first];
+			for (let i = firstIdx + 1; i < nArgs; i++) {
+				const v = vals[i];
+				if (!v) continue;
+				joined += " " + v;
+				a.push(v);
+			}
+			if (!seenBefore(joined)) return mergeUncached(joined);
+			hit = {
+				r: mergeString(joined),
+				t: a.length,
+				a0: a[0],
+				a1: a[1],
+				a2: a[2] ?? "",
+				a,
+				n: null
+			};
+			if (bucket === void 0) argCache.set(first, bucket = {
+				e: [],
+				miss: 0,
+				skip: 0,
+				at: 0
+			});
+			else if (++bucket.miss > BUCKET_MISS_CAP) {
+				bucket.miss = BUCKET_MISS_CAP;
+				bucket.skip = BUCKET_SKIP;
+				bucket.e.length = 0;
+				bucket.at = 0;
+			}
+			const entries = bucket.e;
+			if (entries.length < BUCKET_CAP) entries.push(hit);
+			else {
+				entries[bucket.at] = hit;
+				bucket.at = bucket.at + 1 & 255;
+			}
+			if (++argCount > 1e3) {
+				argCount = 0;
+				prevArgCache = argCache;
+				argCache = /* @__PURE__ */ new Map();
+			}
+		}
+		if (lastHit !== null && lastHit !== hit) lastHit.n = hit;
+		lastHit = hit;
+		return hit.r;
+	};
+	const mergeSingleValue = (value) => Array.isArray(value) ? resolveArgs(value.slice(), false) : mergeString(resolveValue(value, true));
+	return function(v0, v1, v2) {
+		const nArgs = arguments.length;
+		if ((nArgs | 1) === 3) {
+			const lh = lastHit;
+			if (lh !== null) {
+				const pred = lh.n;
+				if (pred !== null && match3(pred, v0, v1, v2)) {
+					lastHit = pred;
+					return pred.r;
+				}
+				if (lh !== pred && match3(lh, v0, v1, v2)) return lh.r;
+			}
+			if (nArgs === 2 && typeof v1 === "string" && v1 !== "") {
+				const bucket = argCache.get(v0);
+				if (bucket !== void 0 && bucket.skip > 0) {
+					bucket.skip--;
+					lastHit = null;
+					return churnLookup(v1, v0, true);
+				}
+			}
+			return resolveArgs([
+				v0,
+				v1,
+				v2
+			], true);
+		}
+		if (nArgs === 1) return typeof v0 === "string" ? mergeString(v0) : mergeSingleValue(v0);
+		const lh = lastHit;
+		if (lh !== null) {
+			const pred = lh.n;
+			if (pred !== null) {
+				const pa = pred.a;
+				let k = 0;
+				let ok = true;
+				for (let i = 0; i < nArgs; i++) {
+					const v = arguments[i];
+					if (!v) continue;
+					if (v !== pa[k]) {
+						ok = false;
+						break;
+					}
+					k++;
+				}
+				if (ok && k === pred.t) {
+					lastHit = pred;
+					return pred.r;
+				}
+			}
+			if (lh !== pred) {
+				const la = lh.a;
+				let k = 0;
+				let ok = true;
+				for (let i = 0; i < nArgs; i++) {
+					const v = arguments[i];
+					if (!v) continue;
+					if (v !== la[k]) {
+						ok = false;
+						break;
+					}
+					k++;
+				}
+				if (ok && k === lh.t) return lh.r;
+			}
+		}
+		const vals = [];
+		for (let i = 0; i < nArgs; i++) vals.push(arguments[i]);
+		return resolveArgs(vals, true);
+	};
+};
+// node_modules/cn/dist/index.js
+var instance = /* @__PURE__ */ createEngine(tables_generated_default);
+/**
+* Merge Tailwind CSS classes with clsx-style arguments (strings, arrays,
+* objects, conditionals). Drop-in replacement for `twMerge(clsx(...))`.
+*/
+var cn = /* @__PURE__ */ wrapClsx(instance.mergeString, instance);
+instance.merge;
 // src/components/button/button.tsx
-var buttonVariants = cva("inline-flex select-none items-center justify-center whitespace-nowrap rounded-ui-md font-medium transition-colors outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 focus-visible:ring-offset-background disabled:pointer-events-none disabled:opacity-50", {
+var buttonVariants = cva("rounded-ui-md focus-visible:ring-ring focus-visible:ring-offset-background inline-flex items-center justify-center font-medium whitespace-nowrap transition-colors outline-none select-none focus-visible:ring-2 focus-visible:ring-offset-2 disabled:pointer-events-none disabled:opacity-50", {
 	variants: {
 		variant: {
 			primary: "bg-primary text-primary-foreground hover:bg-primary/90 active:bg-primary/80",
 			secondary: "bg-secondary text-secondary-foreground hover:bg-secondary/80 active:bg-secondary/70",
-			outline: "border border-border bg-transparent text-foreground hover:bg-muted active:bg-muted/70",
-			ghost: "bg-transparent text-foreground hover:bg-muted active:bg-muted/70",
+			outline: "border-border text-foreground hover:bg-muted active:bg-muted/70 border bg-transparent",
+			ghost: "text-foreground hover:bg-muted active:bg-muted/70 bg-transparent",
 			danger: "bg-danger text-danger-foreground hover:bg-danger/90 active:bg-danger/80"
 		},
 		size: {
@@ -93,14 +1250,63 @@ var Button = forwardRef(function Button({ className, variant = "primary", size =
 	});
 });
 // src/components/input/input.tsx
-var Input = forwardRef(function Input({ className, invalid = false, "aria-invalid": ariaInvalid, ...props }, ref) {
+var inputVariants = cva("rounded-ui-md border-border bg-background text-foreground placeholder:text-muted-foreground focus-visible:border-ring focus-visible:ring-ring/30 flex w-full border py-2 shadow-sm transition-colors outline-none focus-visible:ring-2 disabled:cursor-not-allowed disabled:opacity-50", {
+	variants: {
+		size: {
+			sm: "h-8 px-2.5 text-sm",
+			md: "h-10 px-3 text-sm",
+			lg: "h-12 px-4 text-base"
+		},
+		invalid: {
+			true: "border-danger focus-visible:ring-danger/30",
+			false: ""
+		}
+	},
+	defaultVariants: {
+		size: "md",
+		invalid: false
+	}
+});
+var Input = forwardRef(function Input({ className, invalid = false, size = "md", "aria-invalid": ariaInvalid, ...props }, ref) {
 	return /* @__PURE__ */ jsx(Input$1, {
 		...props,
 		ref,
 		"aria-invalid": invalid || ariaInvalid,
-		className: cn("flex h-10 w-full rounded-ui-md border border-border bg-background px-3 py-2 text-sm text-foreground shadow-sm outline-none transition-colors placeholder:text-muted-foreground focus-visible:border-ring focus-visible:ring-2 focus-visible:ring-ring/30 disabled:cursor-not-allowed disabled:opacity-50 aria-[invalid=true]:border-danger aria-[invalid=true]:focus-visible:ring-danger/30", className)
+		className: cn(inputVariants({
+			size,
+			invalid
+		}), className)
+	});
+});
+// src/components/textarea/textarea.tsx
+var textareaVariants = cva("rounded-ui-md border-border bg-background text-foreground placeholder:text-muted-foreground focus-visible:border-ring focus-visible:ring-ring/30 flex w-full resize-y border py-2 shadow-sm transition-colors outline-none focus-visible:ring-2 disabled:cursor-not-allowed disabled:opacity-50", {
+	variants: {
+		size: {
+			sm: "min-h-16 px-2.5 text-sm",
+			md: "min-h-20 px-3 text-sm",
+			lg: "min-h-28 px-4 text-base"
+		},
+		invalid: {
+			true: "border-danger focus-visible:ring-danger/30",
+			false: ""
+		}
+	},
+	defaultVariants: {
+		size: "md",
+		invalid: false
+	}
+});
+var Textarea = forwardRef(function Textarea({ className, invalid = false, size = "md", "aria-invalid": ariaInvalid, ...props }, ref) {
+	return /* @__PURE__ */ jsx("textarea", {
+		...props,
+		ref,
+		"aria-invalid": invalid || ariaInvalid,
+		className: cn(textareaVariants({
+			size,
+			invalid
+		}), className)
 	});
 });
-export { Button, Input };
+export { Button, Input, Textarea };
 
 //# sourceMappingURL=index.js.map