@box-kite/react 0.0.1 → 2.0.0

package/components/dataGrid.mjs

@@ -0,0 +1,4907 @@
+"use client";
+import { o as e, u as t } from "../platform.mjs";
+import { n } from "../effects.mjs";
+import r from "../box.mjs";
+import { n as i, r as a, t as o } from "../behavior.mjs";
+import { t as s } from "../identity.mjs";
+import { Path as c, Svg as l } from "./svg.mjs";
+import u from "./baseSvg.mjs";
+import d from "./button.mjs";
+import f from "./flex.mjs";
+import p from "./checkbox.mjs";
+import m from "./overlay.mjs";
+import h from "./presence.mjs";
+import g from "./textbox.mjs";
+import _ from "./grid.mjs";
+import v from "./dropdown.mjs";
+import y from "./visuallyHidden.mjs";
+import { Span as b } from "./semantics.mjs";
+import x, { Fragment as S, createContext as C, forwardRef as w, useCallback as T, useContext as E, useEffect as D, useImperativeHandle as ee, useLayoutEffect as O, useMemo as te, useRef as k, useState as A } from "react";
+import { Fragment as j, jsx as M, jsxs as N } from "react/jsx-runtime";
+import { useSyncExternalStore as P } from "use-sync-external-store/shim";
+//#region src/components/dataGrid/components/dataGridPagination.tsx
+function F(e) {
+	let { grid: t } = e, { pagination: n } = t, i = n.state, a = T(() => n.firstPage(), [n]), o = T(() => n.prevPage(), [n]), s = T(() => n.nextPage(), [n]), c = T(() => n.lastPage(), [n]);
+	if (!i) return null;
+	let { canGoPrev: l, canGoNext: u, totalPages: d } = n;
+	return /* @__PURE__ */ N(f, {
+		component: `${t.componentName}.bottomBar.pagination`,
+		gap: .5,
+		ai: "center",
+		children: [
+			/* @__PURE__ */ M(ne, {
+				grid: t,
+				pageSize: i.pageSize
+			}),
+			/* @__PURE__ */ M(I, {
+				componentName: t.componentName,
+				label: "First page",
+				onClick: a,
+				disabled: !l,
+				children: /* @__PURE__ */ M(oe, {})
+			}),
+			/* @__PURE__ */ M(I, {
+				componentName: t.componentName,
+				label: "Previous page",
+				onClick: o,
+				disabled: !l,
+				children: /* @__PURE__ */ M(ie, {})
+			}),
+			/* @__PURE__ */ N(f, {
+				ai: "center",
+				gap: 1.5,
+				px: 2,
+				userSelect: "none",
+				children: [/* @__PURE__ */ M(re, {
+					grid: t,
+					page: i.page,
+					totalPages: d
+				}), /* @__PURE__ */ N(r, {
+					component: `${t.componentName}.bottomBar.pagination.info`,
+					fontSize: 12,
+					opacity: .7,
+					children: ["of ", d]
+				})]
+			}),
+			/* @__PURE__ */ M(I, {
+				componentName: t.componentName,
+				label: "Next page",
+				onClick: s,
+				disabled: !u,
+				children: /* @__PURE__ */ M(ae, {})
+			}),
+			/* @__PURE__ */ M(I, {
+				componentName: t.componentName,
+				label: "Last page",
+				onClick: c,
+				disabled: !u,
+				children: /* @__PURE__ */ M(se, {})
+			})
+		]
+	});
+}
+F.displayName = "DataGridPagination";
+function ne({ grid: e, pageSize: t }) {
+	let n = e.pagination.pageSizeOptions;
+	return !n || n.length === 0 ? null : /* @__PURE__ */ M(f, {
+		ai: "center",
+		gap: 1,
+		me: 1,
+		children: /* @__PURE__ */ M(r, {
+			component: `${e.componentName}.bottomBar.pagination.pageSize`,
+			tag: "select",
+			fontSize: 12,
+			borderRadius: 4,
+			cursor: "pointer",
+			props: {
+				"aria-label": "Rows per page",
+				value: t,
+				onChange: (t) => e.pagination.changePageSize(Number(t.target.value))
+			},
+			children: n.map((e) => /* @__PURE__ */ N("option", {
+				value: e,
+				children: [e, " / page"]
+			}, e))
+		})
+	});
+}
+function re({ grid: e, page: t, totalPages: n }) {
+	let [r, i] = A(String(t)), [a, o] = A(t);
+	t !== a && (o(t), i(String(t)));
+	let s = T(() => {
+		e.pagination.jumpToPage(r), i(String(e.pagination.page));
+	}, [e, r]), c = T((e) => {
+		e.key === "Enter" ? s() : e.key === "Escape" && i(String(t));
+	}, [s, t]);
+	return /* @__PURE__ */ M(g, {
+		type: "number",
+		variant: "compact",
+		value: r,
+		onChange: (e) => i(e.target.value),
+		textAlign: "center",
+		fontSize: 12,
+		props: {
+			"aria-label": "Page number",
+			onKeyDown: c,
+			onBlur: s,
+			min: 1,
+			max: n
+		}
+	});
+}
+function I(e) {
+	let { componentName: t, label: n, onClick: r, disabled: i, children: a } = e;
+	return /* @__PURE__ */ M(d, {
+		component: `${t}.bottomBar.pagination.button`,
+		props: {
+			"aria-label": n,
+			"aria-disabled": i || void 0
+		},
+		onClick: r,
+		cursor: i ? "default" : "pointer",
+		p: 1,
+		borderRadius: 4,
+		opacity: i ? .3 : .7,
+		hover: i ? void 0 : {
+			opacity: 1,
+			bgColor: "gray-100"
+		},
+		theme: { dark: { hover: i ? void 0 : { bgColor: "gray-700" } } },
+		transitionDuration: 150,
+		children: a
+	});
+}
+function L(e) {
+	return /* @__PURE__ */ M(l, {
+		viewBox: "0 0 24 24",
+		width: "14",
+		height: "14",
+		fill: "none",
+		stroke: "currentColor",
+		strokeWidth: 2,
+		strokeLinecap: "round",
+		strokeLinejoin: "round",
+		children: /* @__PURE__ */ M(c, { d: e.d })
+	});
+}
+function ie() {
+	return /* @__PURE__ */ M(L, { d: "M15 18l-6-6 6-6" });
+}
+function ae() {
+	return /* @__PURE__ */ M(L, { d: "M9 18l6-6-6-6" });
+}
+function oe() {
+	return /* @__PURE__ */ M(L, { d: "M18 18l-6-6 6-6M11 18l-6-6 6-6" });
+}
+function se() {
+	return /* @__PURE__ */ M(L, { d: "M6 18l6-6-6-6M13 18l6-6-6-6" });
+}
+//#endregion
+//#region src/components/dataGrid/components/dataGridBottomBar.tsx
+function ce(e) {
+	let { grid: t } = e, { pagination: n, filter: i } = t;
+	if (n.state) {
+		let { totalItems: e, startItem: i, endItem: a } = n;
+		return /* @__PURE__ */ N(f, {
+			component: `${t.componentName}.bottomBar`,
+			children: [
+				/* @__PURE__ */ N(r, {
+					component: `${t.componentName}.bottomBar.info`,
+					children: ["Rows: ", e > 0 ? `${i}–${a} of ${e}` : "0"]
+				}),
+				t.props.def.rowSelection && /* @__PURE__ */ N(r, {
+					component: `${t.componentName}.bottomBar.info`,
+					children: ["Selected: ", t.selectedRows.size]
+				}),
+				/* @__PURE__ */ M(F, { grid: t })
+			]
+		});
+	}
+	let { filtered: a, total: o } = i.filterStats;
+	return /* @__PURE__ */ N(f, {
+		component: `${t.componentName}.bottomBar`,
+		children: [
+			/* @__PURE__ */ N(r, {
+				component: `${t.componentName}.bottomBar.info`,
+				children: ["Rows: ", a === o ? o : `${a} / ${o}`]
+			}),
+			t.props.def.rowSelection && /* @__PURE__ */ N(r, {
+				component: `${t.componentName}.bottomBar.info`,
+				children: ["Selected: ", t.selectedRows.size]
+			}),
+			i.hasActiveFilters && /* @__PURE__ */ M(r, {
+				component: `${t.componentName}.bottomBar.clearFilters`,
+				color: "blue-600",
+				cursor: "pointer",
+				hover: { textDecoration: "underline" },
+				props: { onClick: i.clearAllFilters },
+				children: "Clear filters"
+			})
+		]
+	});
+}
+//#endregion
+//#region src/components/dataGrid/gridNavigationContext.ts
+var le = C(null);
+function R() {
+	return E(le);
+}
+//#endregion
+//#region src/components/dataGrid/models/editModel.ts
+var ue = "Invalid value";
+function de(e, t) {
+	return JSON.stringify([e, t]);
+}
+var fe = 1e3;
+function pe(e) {
+	return typeof e == "number" ? "number" : typeof e == "boolean" ? "checkbox" : "text";
+}
+function me(e, t) {
+	if (e === "text") return t;
+	if (e !== "number" || t.trim() === "") return;
+	let n = Number(t);
+	return Number.isFinite(n) ? n : void 0;
+}
+function he(e) {
+	return e.key.length === 1 && !e.ctrlKey && !e.metaKey && !e.altKey;
+}
+var ge = class {
+	grid;
+	constructor(e) {
+		this.grid = e;
+	}
+	values = /* @__PURE__ */ new Map();
+	_edits = [];
+	_active;
+	_token = 0;
+	get enabled() {
+		let { def: e } = this.grid.props;
+		return e.editable === !0 || e.columns.some((e) => e.editable !== void 0 && e.editable !== !1);
+	}
+	isEditable(e, t) {
+		if (e.placeholder || !t.isData) return !1;
+		let n = t.editable;
+		return typeof n == "function" ? !!n(e.data) : n;
+	}
+	editorFor(e, t) {
+		let { editor: n } = e.def;
+		return typeof n == "object" ? n : n ? { type: n } : { type: pe(t) };
+	}
+	isEditing(e, t) {
+		return this._active?.rowKey === e && this._active.columnKey === t;
+	}
+	get draft() {
+		return this._active?.draft;
+	}
+	get error() {
+		return this._active?.error;
+	}
+	get pending() {
+		return !!this._active?.pending;
+	}
+	begin(e, t, n, r) {
+		let i = r === void 0 ? void 0 : me(this.editorFor(t, n).type, r);
+		this._active = {
+			row: e,
+			rowKey: e.key,
+			columnKey: t.key,
+			draft: i ?? n,
+			token: ++this._token,
+			pending: !1
+		}, this.grid.notify();
+	}
+	beginAt(e, t, n) {
+		let r = this.grid.flatRows.value[e], i = this.grid.columns.value.visibleLeafs[t];
+		if (!i || !r || r.kind !== "row" || !this.isEditable(r, i)) return !1;
+		let a = r.data[i.key];
+		return this.begin(r, i, this.valueOf(r.key, i.key, a), n), !0;
+	}
+	setDraft(e) {
+		this._active && (this._active = {
+			...this._active,
+			draft: e,
+			error: void 0
+		}, this.grid.notify());
+	}
+	cancel() {
+		this._active && (this._token++, this._active = void 0, this.grid.notify());
+	}
+	commit() {
+		let e = this._active;
+		if (!e || e.pending) return;
+		let { row: t, rowKey: n, columnKey: r, draft: i } = e, a = this.valueOf(n, r, t.data[r]);
+		if (Object.is(i, a)) {
+			this.cancel();
+			return;
+		}
+		let o = {
+			rowKey: n,
+			columnKey: r,
+			row: t.data,
+			value: i,
+			oldValue: a
+		}, s = this.grid.props.def.onCellEdit?.(o);
+		if (s instanceof Promise) {
+			this._active = {
+				...e,
+				pending: !0
+			}, this.grid.notify(), s.then((t) => this.settle(e.token, o, t), (t) => this.settle(e.token, o, t instanceof Error ? t.message : ue));
+			return;
+		}
+		this.settle(e.token, o, s);
+	}
+	settle(e, t, n) {
+		if (!(!this._active || this._active.token !== e)) {
+			if (typeof n == "string" || n === !1) {
+				this._active = {
+					...this._active,
+					pending: !1,
+					error: typeof n == "string" ? n : ue
+				}, this.grid.notify();
+				return;
+			}
+			this.values.set(de(t.rowKey, t.columnKey), t.value), this._edits = [...this._edits, t], this._active = void 0, this.grid.notify(), this.grid.props.onCellEditsChange?.(this._edits, { reason: "edit" });
+		}
+	}
+	valueOf(e, t, n) {
+		if (this.values.size === 0) return n;
+		let r = de(e, t);
+		return this.values.has(r) ? this.values.get(r) : n;
+	}
+	get edits() {
+		return this._edits;
+	}
+	clearEdits = () => {
+		(this.values.size !== 0 || this._edits.length !== 0) && (this.values.clear(), this._edits = [], this.grid.notify(), this.grid.props.onCellEditsChange?.(this._edits, { reason: "clear" }));
+	};
+	nextEditable(e, t, n = !1) {
+		let r = this.grid.flatRows.value, i = this.grid.columns.value.visibleLeafs, a = n ? -1 : 1, o = e * i.length + t + a, s = Math.min(r.length * i.length - 1, o + fe);
+		for (let e = o; e >= Math.max(0, o - fe) && e <= s; e += a) {
+			let t = Math.floor(e / i.length), n = e % i.length, a = r[t], o = i[n];
+			if (!(!o || a?.kind !== "row" || !this.isEditable(a, o))) return {
+				row: t,
+				column: n
+			};
+		}
+	}
+}, z = Symbol("memo.unset"), _e = class {
+	action;
+	deps;
+	cache = z;
+	dependents = /* @__PURE__ */ new Set();
+	wired = !1;
+	constructor(e, t) {
+		this.action = e, this.deps = t;
+	}
+	wire() {
+		if (!this.wired) {
+			this.wired = !0;
+			for (let e of this.deps()) e.dependents.add(this);
+		}
+	}
+	get value() {
+		return this.wire(), this.cache === z && (this.cache = this.action()), this.cache;
+	}
+	clear() {
+		if (this.wire(), this.cache !== z) {
+			this.cache = z;
+			for (let e of this.dependents) e.clear();
+		}
+	}
+};
+function B(e, t = () => []) {
+	return new _e(e, t);
+}
+//#endregion
+//#region src/components/dataGrid/models/cellModel.ts
+var ve = class {
+	grid;
+	row;
+	column;
+	constructor(e, t, n) {
+		this.grid = e, this.row = t, this.column = n;
+	}
+	get value() {
+		if (this.column.isRowNumber) return this.row.rowIndex + 1;
+		let e = this.row.data[this.column.key];
+		return this.grid.edits.valueOf(this.row.key, this.column.key, e);
+	}
+	get isExpanded() {
+		return this.row.expanded;
+	}
+	get selected() {
+		return this.row.selected;
+	}
+	get isFirst() {
+		return this.row.cells[0] === this;
+	}
+	get isLast() {
+		let e = this.row.cells;
+		return e[e.length - 1] === this;
+	}
+	toggleDetail = () => {
+		this.grid.toggleDetailRow(this.row.key);
+	};
+	get indeterminate() {
+		return this.row.indeterminate;
+	}
+	toggleSelection = () => {
+		this.row.toggleSelection();
+	};
+	get editable() {
+		return this.grid.edits.isEditable(this.row, this.column);
+	}
+	get editing() {
+		return this.grid.edits.isEditing(this.row.key, this.column.key);
+	}
+	get editor() {
+		return this.grid.edits.editorFor(this.column, this.value);
+	}
+	get draft() {
+		return this.grid.edits.draft;
+	}
+	get error() {
+		return this.grid.edits.error;
+	}
+	get pending() {
+		return this.grid.edits.pending;
+	}
+	beginEdit = (e) => {
+		this.editable && this.grid.edits.begin(this.row, this.column, this.value, e);
+	};
+	setDraft = (e) => {
+		this.grid.edits.setDraft(e);
+	};
+	commitEdit = () => {
+		this.grid.edits.commit();
+	};
+	cancelEdit = () => {
+		this.grid.edits.cancel();
+	};
+}, V = class e {
+	grid;
+	parentRow;
+	constructor(e, t) {
+		this.grid = e, this.parentRow = t;
+	}
+	kind = "detail";
+	get key() {
+		return `detail-${this.parentRow.key}`;
+	}
+	get isAutoHeight() {
+		return this.height === "auto";
+	}
+	static AUTO_HEIGHT_ESTIMATE = 200;
+	get height() {
+		let e = this.grid.props.def.rowDetail;
+		return !e || e.height === void 0 || e.height === "auto" ? "auto" : typeof e.height == "function" ? e.height(this.parentRow.data) : e.height;
+	}
+	get heightForOffset() {
+		let t = this.height;
+		return t === "auto" ? e.AUTO_HEIGHT_ESTIMATE : t;
+	}
+	count = 0;
+	cellCount = 1;
+	columnOf() {
+		return 0;
+	}
+	get flatRows() {
+		return [this];
+	}
+	get allRows() {
+		return [];
+	}
+}, H = class {
+	grid;
+	rowIndex;
+	constructor(e, t, n) {
+		this.grid = e, this.rowIndex = n, this._data = t;
+	}
+	_data;
+	get data() {
+		return this._data;
+	}
+	_key;
+	get key() {
+		return this._key ??= this.grid.getRowKey(this.data);
+	}
+	parentRow;
+	count = 1;
+	kind = "row";
+	get placeholder() {
+		return !1;
+	}
+	get expandOnRowClick() {
+		return this.grid.props.def.rowDetail?.expandOnRowClick ?? !1;
+	}
+	toggleDetail = () => {
+		this.grid.toggleDetailRow(this.key);
+	};
+	_cells = B(() => this.grid.columns.value.visibleLeafs.map((e) => new ve(this.grid, this, e)));
+	get cells() {
+		return this._cells.value;
+	}
+	get cellCount() {
+		return this.cells.length;
+	}
+	columnOf(e) {
+		return e;
+	}
+	get selected() {
+		return this.grid.selectedRows.has(this.key);
+	}
+	get indeterminate() {
+		return !1;
+	}
+	toggleSelection = () => {
+		this.grid.toggleRowSelection(this.key);
+	};
+	get expanded() {
+		return this.grid.expandedDetailRows.has(this.key);
+	}
+	get flatRows() {
+		return this.grid.props.def.rowDetail && this.expanded ? [this, new V(this.grid, this)] : [this];
+	}
+	get allRows() {
+		return this;
+	}
+};
+//#endregion
+//#region src/components/dataGrid/models/treeRow.ts
+function U(e) {
+	return !!e && e.isTreeRow === !0;
+}
+//#endregion
+//#region src/components/dataGrid/useGridNavigation.ts
+var ye = "[role=\"gridcell\"],[role=\"columnheader\"]", be = "a[href],button:not([disabled]),input:not([disabled]),select:not([disabled]),textarea:not([disabled]),[tabindex]", xe = 2, Se = [];
+function Ce(e) {
+	let { grid: t, scrollerRef: r, scrollTop: i, onScrollTo: a } = e, s = t.headerRows.value, c = t.filter.hasFilterableColumns, l = s.length + +!!c, u = t.viewport.isEmpty ? Se : t.flatRows.value, d = t.columns.value.visibleLeafs.length, f = t.aggregation.hasFooter && !t.viewport.isEmpty ? 1 : 0, p = l + u.length + f, m = T((e) => {
+		if (e < s.length) return s[e]?.length ?? 0;
+		if (e < l || e >= l + u.length) return d;
+		let t = u[e - l];
+		return t ? t.cellCount : 0;
+	}, [
+		u,
+		d,
+		l,
+		s
+	]), h = T((e, t) => e < s.length ? (s[e]?.[t]?.headerCell.columnIndex ?? t + 1) - 1 : e < l ? t : u[e - l]?.columnOf(t) ?? t, [
+		u,
+		l,
+		s
+	]), g = k(!1), _ = T((e, n) => {
+		let { viewport: o } = t, s = e - l, c = r.current;
+		if (o.showAll || !c || s >= u.length) return;
+		if (s < 0) {
+			n >= l && (c.scrollTop = 0, a(0));
+			return;
+		}
+		let { startIndex: d, take: f } = o.window(i);
+		if (s >= d + xe && s < d + f - xe) return;
+		let p = o.rowTop(s);
+		c.scrollTop = p, a(p);
+	}, [
+		u.length,
+		t,
+		l,
+		a,
+		i,
+		r
+	]), v = k(0), y = o({
+		count: p,
+		columns: m,
+		columnIndexOf: h,
+		pageSize: t.viewport.pageRows,
+		onActiveCellChange: (e, t) => {
+			let n = v.current;
+			v.current = e.row, t.reason === "keyboard" && (_(e.row, n), g.current = !0);
+		}
+	}), b = y.activeItem;
+	n(() => {
+		g.current && (g.current = !1, b()?.focus());
+	});
+	let x = T((e, n, r) => {
+		if (!t.tree.enabled || e.key !== "ArrowRight" && e.key !== "ArrowLeft") return !1;
+		let i = u[n - l];
+		if (!U(i) || t.columns.value.visibleLeafs[r]?.key !== t.tree.columnKey) return !1;
+		if (e.key === (t.isRtl ? "ArrowLeft" : "ArrowRight")) return !i.hasChildren || i.treeExpanded ? !1 : (i.toggleTree(), !0);
+		if (i.hasChildren && i.treeExpanded) return i.toggleTree(), !0;
+		for (let e = n - 1; e >= l; e--) {
+			let t = u[e - l];
+			if (!(!U(t) || t.level >= i.level)) return y.setActiveCell(e, r, { reason: "keyboard" }), !0;
+		}
+		return !1;
+	}, [
+		u,
+		t,
+		l,
+		y
+	]), S = T((e) => {
+		let { activeIndex: t, activeColumn: n } = y, r = e ? -1 : 1, i = n + r;
+		if (i >= 0 && i < m(t)) return y.setActiveCell(t, i, { reason: "keyboard" }), !0;
+		let a = t + r;
+		return a < 0 || a >= p ? !1 : (y.setActiveCell(a, e ? Math.max(0, m(a) - 1) : 0, { reason: "keyboard" }), !0);
+	}, [
+		m,
+		y,
+		p
+	]), C = T((e, n) => {
+		if (!t.props.def.rowSelection) return !1;
+		if (e < l) return e >= s.length || !t.columns.value.visibleLeafs[n]?.isRowSelection ? !1 : (t.toggleSelectAllRows(), !0);
+		let r = t.flatRows.value[e - l];
+		return r instanceof H && (r.toggleSelection(), !0);
+	}, [
+		t,
+		l,
+		s.length
+	]), w = T((e, t, n) => {
+		let r = Array.from(e.querySelectorAll(be));
+		if (r.length < 2) return !1;
+		let i = r.indexOf(t);
+		return i !== -1 && (r[(i + (n ? -1 : 1) + r.length) % r.length].focus(), !0);
+	}, []), E = y.onKeyDown, D = T((e) => {
+		let n = e.target, r = n.closest?.(ye);
+		if (r) {
+			if (n !== r) {
+				if (e.key === "Escape" && !r.querySelector("[aria-expanded=\"true\"]")) {
+					e.preventDefault(), r.focus();
+					return;
+				}
+				e.key === "Tab" && w(r, n, e.shiftKey) && e.preventDefault();
+				return;
+			}
+			if (e.key === "Tab" && t.props.def.tabNavigation === "cells") {
+				S(e.shiftKey) && e.preventDefault();
+				return;
+			}
+			if (e.key === " " && C(y.activeIndex, y.activeColumn)) {
+				e.preventDefault();
+				return;
+			}
+			if (e.key === "Enter" || e.key === " " || e.key === "F2") {
+				let n = s[y.activeIndex]?.[y.activeColumn];
+				if (e.key !== "F2" && n?.headerCell.isSortable) {
+					e.preventDefault(), n.sortColumn();
+					return;
+				}
+				if (t.edits.beginAt(y.activeIndex - l, y.activeColumn)) {
+					e.preventDefault();
+					return;
+				}
+				let i = r.querySelector(be);
+				if (i) {
+					e.preventDefault(), i.focus();
+					return;
+				}
+			}
+			if (t.edits.enabled && he(e) && t.edits.beginAt(y.activeIndex - l, y.activeColumn, e.key)) {
+				e.preventDefault();
+				return;
+			}
+			if (x(e, y.activeIndex, y.activeColumn)) {
+				e.preventDefault();
+				return;
+			}
+			E(e);
+		}
+	}, [
+		t,
+		l,
+		s,
+		y.activeColumn,
+		y.activeIndex,
+		E,
+		S,
+		w,
+		C,
+		x
+	]);
+	return {
+		rowCount: p,
+		columnCount: d,
+		headerRowCount: l,
+		cellProps: y.cellProps,
+		setActiveCell: y.setActiveCell,
+		onKeyDown: D
+	};
+}
+//#endregion
+//#region src/utils/array/arrayUtils.ts
+var we;
+(function(e) {
+	function t(e, t, n = 0) {
+		return e.slice(n, n + t);
+	}
+	e.take = t;
+	function n(e, t, n = 0) {
+		return e.reduce((e, n, r) => e + t(n, r), n);
+	}
+	e.sumBy = n;
+	function r(e, t, n) {
+		return [...e].sort((e, r) => {
+			let i = t(e), a = t(r);
+			return i < a ? n === "DESC" ? 1 : -1 : i > a ? n === "DESC" ? -1 : 1 : 0;
+		});
+	}
+	e.sortBy = r;
+	function i(e, t) {
+		return Math.max(...e.map(t));
+	}
+	e.maxBy = i;
+	function a(e, t) {
+		let n = e.find(t);
+		if (n === void 0) throw Error("No items satisfy the provided condition.");
+		return n;
+	}
+	e.findOrThrow = a;
+	function o(e, t) {
+		return e.reduce((e, n) => {
+			let r = t(n);
+			if (!r) return e;
+			let [i, a] = r;
+			return e[i] = a, e;
+		}, {});
+	}
+	e.toRecord = o;
+	function s(e, t) {
+		let n = e.reduce((e, n, r) => {
+			let i = t(n, r);
+			return e.has(i) === !1 && e.set(i, []), e.get(i)?.push(n), e;
+		}, /* @__PURE__ */ new Map());
+		return Array.from(n, ([e, t]) => ({
+			key: e,
+			values: t
+		}));
+	}
+	e.groupBy = s;
+})(we ||= {});
+var W = we, Te = "row-number-cell", Ee = "row-selection-cell", G = "grouping-cell", De = "row-detail-cell";
+//#endregion
+//#region src/components/dataGrid/models/aggregationModel.ts
+function K(e) {
+	return e.filter((e) => typeof e == "number" && !Number.isNaN(e));
+}
+var Oe = (e) => e.reduce((e, t) => e + t, 0), ke = (e, t) => e.reduce((e, n) => (t ? n < e : n > e) ? n : e), Ae = {
+	sum: (e) => {
+		let t = K(e);
+		return t.length ? Oe(t) : null;
+	},
+	avg: (e) => {
+		let t = K(e);
+		return t.length ? Math.round(Oe(t) / t.length * 100) / 100 : null;
+	},
+	min: (e) => {
+		let t = K(e);
+		return t.length ? ke(t, !0) : null;
+	},
+	max: (e) => {
+		let t = K(e);
+		return t.length ? ke(t, !1) : null;
+	},
+	count: (e, t) => t.length
+};
+function je(e, t, n) {
+	return typeof e == "function" ? e(t, n) : Ae[e]?.(t, n) ?? null;
+}
+var Me = class {
+	grid;
+	constructor(e) {
+		this.grid = e;
+	}
+	get columns() {
+		return this.grid.columns.value.visibleLeafs.filter((e) => !!e.aggregate);
+	}
+	get hasAggregates() {
+		return this.columns.length > 0;
+	}
+	get hasFooter() {
+		return !!this.grid.props.def.footer && this.hasAggregates;
+	}
+	get footerLabel() {
+		let { footer: e } = this.grid.props.def;
+		return typeof e == "object" ? e.label : "Total";
+	}
+	get footerLabelColumn() {
+		return this.grid.columns.value.visibleLeafs.find((e) => (e.isData || e.isGrouping) && !e.aggregate);
+	}
+	footerCells = B(() => this.grid.columns.value.visibleLeafs.map((e) => new Ne(this.grid, e, this.grid.filteredData, "footer")), () => [this.grid.rows]);
+}, Ne = class {
+	grid;
+	column;
+	rows;
+	scope;
+	given;
+	constructor(e, t, n, r, i) {
+		this.grid = e, this.column = t, this.rows = n, this.scope = r, this.given = i;
+	}
+	_values = B(() => this.rows.map((e) => e[this.column.key]));
+	get values() {
+		return this._values.value;
+	}
+	_value = B(() => {
+		let e = this.column.aggregate;
+		return e ? je(e, this.values, this.rows) : null;
+	});
+	get value() {
+		let e = this.given?.();
+		return e === void 0 ? this._value.value : e;
+	}
+	get isExpanded() {
+		return !1;
+	}
+	get isFirst() {
+		return !1;
+	}
+	get isLast() {
+		return !1;
+	}
+}, Pe = class {
+	grid;
+	row;
+	column;
+	constructor(e, t, n) {
+		this.grid = e, this.row = t, this.column = n;
+	}
+	get value() {
+		return this.column.isRowNumber ? this.row.rowIndex + 1 : this.column.isGrouping ? this.row.label : null;
+	}
+	get isExpanded() {
+		return !1;
+	}
+	get isFirst() {
+		return !1;
+	}
+	get isLast() {
+		return !1;
+	}
+	get cellKind() {
+		return this.column.isGrouping ? "grouping" : this.column.isRowSelection ? this.row.selectable ? "selection" : "spacer" : this.row.spans(this.column) ? "hidden" : this.column.aggregate ? "aggregate" : "spacer";
+	}
+	_aggregate = B(() => this.column.aggregate ? new Ne(this.grid, this.column, this.row.allRows.map((e) => e.data), "group", () => this.row.aggregateValue(this.column)) : null);
+	get aggregate() {
+		return this._aggregate.value;
+	}
+	get depthPadding() {
+		return 4 * this.row.depth;
+	}
+	get gridColumnSpan() {
+		return this.row.groupingColumnGridColumn;
+	}
+	get widthVar() {
+		return `var(${this.column.groupColumnWidthVarName})`;
+	}
+	get isEndPinned() {
+		return this.column.pin === "END";
+	}
+	get hasGroupingBorder() {
+		return this.row.groupingColumn.pin === "START";
+	}
+}, Fe = class {
+	grid;
+	groupColumn;
+	rows;
+	rowIndex;
+	constructor(e, t, n, r, i) {
+		this.grid = e, this.groupColumn = t, this.rows = n, this.rowIndex = r, this._groupValue = i, n.forEach((e) => e.parentRow = this);
+	}
+	_groupValue;
+	get groupValue() {
+		return this._groupValue;
+	}
+	get label() {
+		return `${this.groupValue} (${this.count})`;
+	}
+	get placeholder() {
+		return !1;
+	}
+	get selectable() {
+		return !0;
+	}
+	aggregateValue(e) {}
+	get key() {
+		return `${this.parentRow?.key ?? ""}${this.groupColumn.key}${this.groupValue}`;
+	}
+	parentRow;
+	_cells = B(() => this.grid.columns.value.visibleLeafs.map((e) => new Pe(this.grid, this, e)));
+	get cells() {
+		return this._cells.value;
+	}
+	_renderedCells = B(() => {
+		let e = [];
+		return this.cells.forEach((t, n) => {
+			t.cellKind !== "hidden" && e.push({
+				cell: t,
+				columnIndex: n
+			});
+		}), e;
+	});
+	get renderedCells() {
+		return this._renderedCells.value;
+	}
+	get cellCount() {
+		return this.renderedCells.length;
+	}
+	columnOf(e) {
+		return this.renderedCells[e]?.columnIndex ?? e;
+	}
+	get selected() {
+		return this.allRows.every((e) => e.selected);
+	}
+	get indeterminate() {
+		return !this.selected && this.allRows.some((e) => e.selected);
+	}
+	get expanded() {
+		return this.grid.isGroupExpanded(this.key, this.depth);
+	}
+	get depth() {
+		return this.parentRow ? this.parentRow.depth + 1 : 0;
+	}
+	get count() {
+		return W.sumBy(this.rows, (e) => e.count, 0);
+	}
+	get flatRows() {
+		return this.expanded ? [this, ...this.rows.flatMap((e) => e.flatRows)] : [this];
+	}
+	get allRows() {
+		return this.rows.flatMap((e) => e.allRows);
+	}
+	get groupingColumn() {
+		return W.findOrThrow(this.grid.columns.value.leafs, (e) => e.key === G);
+	}
+	get groupingColumnGridColumn() {
+		return this.grid.groupingSpan.value.length;
+	}
+	spans(e) {
+		return !e.isGrouping && this.grid.groupingSpan.value.includes(e);
+	}
+	kind = "group";
+	toggleRow() {
+		this.grid.toggleGroupRow(this.key, this.expanded);
+	}
+	toggleSelectAll = () => {
+		this.grid.toggleRowsSelection(this.allRows.map((e) => e.key));
+	};
+};
+//#endregion
+//#region src/components/dataGrid/components/dataGridDetailRow.tsx
+function Ie(e) {
+	let { row: t, index: i } = e, { grid: a, parentRow: o } = t, s = a.props.def.rowDetail, c = R(), l = (c?.headerRowCount ?? 0) + i, { ref: u, tabIndex: d, onFocus: p } = c?.cellProps(l, 0) ?? {}, m = t.isAutoHeight, h = k(null);
+	return n(() => {
+		a.takeDetailReveal(o.key) && h.current?.scrollIntoView?.({ block: "nearest" });
+	}), /* @__PURE__ */ M(f, {
+		ref: h,
+		component: `${a.componentName}.body.detailRow`,
+		props: {
+			role: "row",
+			"aria-rowindex": l + 1
+		},
+		style: {
+			gridColumn: "1 / -1",
+			height: m ? "auto" : `${t.height}px`
+		},
+		children: /* @__PURE__ */ M(r, {
+			ref: u,
+			component: `${a.componentName}.body.detailRow.content`,
+			position: "sticky",
+			insetStart: 0,
+			overflowX: "auto",
+			overflowY: "hidden",
+			props: {
+				role: "gridcell",
+				"aria-colindex": 1,
+				"aria-colspan": c?.columnCount,
+				tabIndex: d,
+				onFocus: p
+			},
+			style: { width: `var(${a.viewportWidthVarName})` },
+			children: s.content(o.data)
+		})
+	});
+}
+Ie.displayName = "DataGridDetailRow";
+//#endregion
+//#region src/components/dataGrid/components/dataGridAggregateValue.tsx
+function Le(e) {
+	let { cell: t } = e, { column: n } = t;
+	if (n.AggregateCell) return /* @__PURE__ */ M(n.AggregateCell, { cell: t });
+	let i = t.scope === "footer" ? "footer.cell" : "body.groupRow.aggregate";
+	return /* @__PURE__ */ M(r, {
+		component: `${n.grid.componentName}.${i}`,
+		px: 3,
+		textOverflow: "ellipsis",
+		overflow: "hidden",
+		textWrap: "nowrap",
+		children: t.value
+	});
+}
+Le.displayName = "DataGridAggregateValue";
+//#endregion
+//#region src/components/dataGrid/components/dataGridCell.tsx
+var Re = "button,a[href],input,select,textarea";
+function q(t) {
+	let { children: n, cell: r, row: i, columnIndex: a, ariaColIndex: o, ariaColSpan: s, style: c, ...l } = t, { column: u } = r, { ref: d, tabIndex: p, onFocus: m } = R()?.cellProps(i, a) ?? {};
+	u.hasAlign && (l.jc = u.align);
+	let h = r.isExpanded ? {
+		...u.cellVariant.value,
+		isExpanded: !0,
+		isExpandedFirstLeaf: r.isFirst,
+		isExpandedLastLeaf: r.isLast
+	} : u.cellVariant.value;
+	r instanceof ve && r.editing && (h = {
+		...h,
+		isEditing: !0,
+		isInvalid: !!r.error
+	});
+	let g = r instanceof ve ? (t) => {
+		t.target.closest(Re) || (e(t.currentTarget), r.beginEdit());
+	} : void 0;
+	return /* @__PURE__ */ M(f, {
+		ref: d,
+		component: `${u.grid.componentName}.body.cell`,
+		props: {
+			role: "gridcell",
+			"aria-colindex": o ?? a + 1,
+			"aria-colspan": s,
+			tabIndex: p,
+			onFocus: m,
+			onDoubleClick: g
+		},
+		variant: h,
+		style: {
+			...u.cellStyleVars.value,
+			...c
+		},
+		...l,
+		children: n
+	});
+}
+q.displayName = "DataGridCell";
+//#endregion
+//#region src/components/dataGrid/components/dataGridFooter.tsx
+function ze(e) {
+	let { grid: t } = e, { aggregation: n } = t, i = R();
+	if (!n.hasFooter) return null;
+	let a = (i?.rowCount ?? 1) - 1, { footerLabelColumn: o, footerLabel: s } = n;
+	return /* @__PURE__ */ M(_, {
+		component: `${t.componentName}.footer`,
+		props: { role: "rowgroup" },
+		style: { gridTemplateColumns: t.gridTemplateColumns.value },
+		children: /* @__PURE__ */ M(r, {
+			display: "contents",
+			props: {
+				role: "row",
+				"aria-rowindex": a + 1
+			},
+			children: n.footerCells.value.map((e, n) => /* @__PURE__ */ M(q, {
+				cell: e,
+				row: a,
+				columnIndex: n,
+				children: e.column.aggregate ? /* @__PURE__ */ M(Le, { cell: e }) : e.column === o ? /* @__PURE__ */ M(r, {
+					component: `${t.componentName}.footer.label`,
+					px: 3,
+					textWrap: "nowrap",
+					children: s
+				}) : null
+			}, e.column.key))
+		})
+	});
+}
+ze.displayName = "DataGridFooter";
+//#endregion
+//#region src/icons/expandIcon.tsx
+function J(e) {
+	return /* @__PURE__ */ M(l, {
+		viewBox: "4 2 16 18",
+		width: "1rem",
+		fill: "currentColor",
+		...e,
+		children: /* @__PURE__ */ M(c, {
+			fillRule: "evenodd",
+			d: "M12.707 14.707a1 1 0 0 1-1.414 0l-5-5a1 1 0 0 1 1.414-1.414L12 12.586l4.293-4.293a1 1 0 1 1 1.414 1.414l-5 5Z",
+			props: { clipRule: "evenodd" }
+		})
+	});
+}
+//#endregion
+//#region src/components/dataGrid/components/dataGridCellPlaceholder.tsx
+var Be = [
+	"3/5",
+	"2/5",
+	"4/5",
+	"1/2",
+	"7/12"
+];
+function Y(e) {
+	let { cell: t, columnIndex: n } = e, i = Be[(t.row.rowIndex + n) % Be.length];
+	return /* @__PURE__ */ M(f, {
+		component: `${t.grid.componentName}.body.cell.placeholder`,
+		ai: "center",
+		px: 3,
+		props: { "aria-hidden": !0 },
+		children: /* @__PURE__ */ M(r, {
+			component: `${t.grid.componentName}.body.cell.placeholder.bar`,
+			width: i
+		})
+	});
+}
+Y.displayName = "DataGridCellPlaceholder";
+//#endregion
+//#region src/components/dataGrid/components/dataGridGroupRow.tsx
+function Ve(e) {
+	let { row: t, index: n } = e, { selected: i, indeterminate: a, expanded: o, placeholder: s } = t, c = (R()?.headerRowCount ?? 0) + n, l = T(() => t.toggleSelectAll(), [t]);
+	return /* @__PURE__ */ M(f, {
+		component: `${t.grid.componentName}.body.groupRow`,
+		className: "grid-row",
+		selected: t.grid.props.def.rowSelection ? i : void 0,
+		display: "contents",
+		props: {
+			role: "row",
+			"aria-rowindex": c + 1,
+			"data-group-row": "",
+			"aria-busy": s || void 0
+		},
+		children: t.renderedCells.map(({ cell: e, columnIndex: n }, u) => {
+			switch (e.cellKind) {
+				case "grouping": return /* @__PURE__ */ M(q, {
+					cell: e,
+					row: c,
+					columnIndex: u,
+					ariaColIndex: n + 1,
+					ariaColSpan: e.gridColumnSpan,
+					style: {
+						width: e.widthVar,
+						insetInlineEnd: e.isEndPinned ? "0" : void 0
+					},
+					be: e.hasGroupingBorder ? 1 : void 0,
+					gridColumn: e.gridColumnSpan,
+					ps: e.depthPadding,
+					overflow: "auto",
+					children: s ? /* @__PURE__ */ M(Y, {
+						cell: e,
+						columnIndex: u
+					}) : /* @__PURE__ */ M(r, {
+						textWrap: "nowrap",
+						px: 3,
+						children: /* @__PURE__ */ N(d, {
+							component: `${t.grid.componentName}.body.groupRow.expandButton`,
+							onClick: () => t.toggleRow(),
+							cursor: "pointer",
+							display: "flex",
+							gap: 1,
+							ai: "center",
+							props: {
+								tabIndex: -1,
+								"aria-expanded": o
+							},
+							children: [/* @__PURE__ */ M(J, {
+								fill: "currentColor",
+								width: "14px",
+								height: "14px",
+								rotate: o ? 0 : -90
+							}), e.value]
+						})
+					})
+				}, e.column.key);
+				case "selection": return /* @__PURE__ */ M(q, {
+					cell: e,
+					row: c,
+					columnIndex: u,
+					ariaColIndex: n + 1,
+					children: /* @__PURE__ */ M(p, {
+						variant: "datagrid",
+						m: 1,
+						checked: i,
+						indeterminate: a,
+						onChange: l,
+						props: {
+							tabIndex: -1,
+							"aria-label": `Select all rows in ${t.groupValue}`
+						}
+					})
+				}, e.column.key);
+				case "aggregate": return /* @__PURE__ */ M(q, {
+					cell: e,
+					row: c,
+					columnIndex: u,
+					ariaColIndex: n + 1,
+					children: e.aggregate && /* @__PURE__ */ M(Le, { cell: e.aggregate })
+				}, e.column.key);
+				case "spacer": return /* @__PURE__ */ M(q, {
+					cell: e,
+					row: c,
+					columnIndex: u,
+					ariaColIndex: n + 1,
+					px: e.column.isRowNumber ? 3 : void 0,
+					children: e.value
+				}, e.column.key);
+				default: return null;
+			}
+		})
+	});
+}
+Ve.displayName = "DataGridGroupRow";
+//#endregion
+//#region src/components/dataGrid/components/dataGridCellEditor.tsx
+var He = "input,select,textarea,button";
+function Ue(e) {
+	let { options: t } = e.editor;
+	return typeof t == "function" ? t(e.row.data) : t ?? [];
+}
+function We(e) {
+	let { cell: t, row: r, columnIndex: i } = e, { grid: a } = t, o = R(), c = k(null), l = s("datagrid-cell-error"), { error: u, pending: d } = t;
+	n(() => {
+		let e = c.current?.querySelector(He);
+		e?.focus(), e instanceof HTMLInputElement && e.type !== "checkbox" && e.select();
+	}, []);
+	let p = T(() => {
+		c.current?.closest("[role=\"gridcell\"]")?.focus();
+	}, []), h = T((e) => {
+		if (!o) return;
+		let t = a.edits.nextEditable(r - o.headerRowCount, i, e.shiftKey);
+		t && (e.preventDefault(), o.setActiveCell(t.row + o.headerRowCount, t.column, { reason: "programmatic" }), a.edits.beginAt(t.row, t.column));
+	}, [
+		i,
+		a,
+		o,
+		r
+	]), g = T((e) => {
+		if (e.key === "Escape") {
+			if (c.current?.querySelector("[aria-expanded=\"true\"]")) return;
+			e.preventDefault(), e.stopPropagation(), t.cancelEdit(), p();
+			return;
+		}
+		if (e.key === "Enter") {
+			e.preventDefault(), e.stopPropagation(), t.commitEdit(), t.editing || p();
+			return;
+		}
+		if (e.key === "Tab") {
+			if (e.stopPropagation(), t.commitEdit(), t.editing) {
+				e.preventDefault();
+				return;
+			}
+			h(e);
+		}
+	}, [
+		t,
+		p,
+		h
+	]), _ = T(() => {
+		!t.editing || t.pending || t.commitEdit();
+	}, [t]);
+	return /* @__PURE__ */ N(f, {
+		ref: c,
+		component: `${a.componentName}.body.cell.editor`,
+		variant: { isPending: d },
+		props: { onKeyDown: g },
+		width: "fit",
+		height: "fit",
+		ai: "center",
+		children: [/* @__PURE__ */ M(Ge, {
+			cell: t,
+			errorId: u ? l : void 0,
+			onBlur: _,
+			onCommitted: p
+		}), u && /* @__PURE__ */ M(m, {
+			anchor: c,
+			side: "bottom",
+			align: "start",
+			offset: 1,
+			matchWidth: !1,
+			component: `${a.componentName}.body.cell.error`,
+			id: l,
+			props: { role: "alert" },
+			children: u
+		})]
+	});
+}
+function Ge(e) {
+	let { cell: t, errorId: n, onBlur: r, onCommitted: i } = e, { EditCell: a } = t.column.def, { type: o, placeholder: s, step: c, min: l, max: u } = t.editor, d = {
+		"aria-label": `Edit ${t.column.header ?? t.column.key}`,
+		"aria-invalid": n ? !0 : void 0,
+		"aria-describedby": n
+	};
+	if (a) return /* @__PURE__ */ M(a, { cell: t });
+	if (o === "checkbox") return /* @__PURE__ */ M(p, {
+		checked: !!t.draft,
+		onChange: (e) => {
+			t.setDraft(e.target.checked), t.commitEdit(), i();
+		},
+		props: {
+			...d,
+			onBlur: r
+		}
+	});
+	if (o === "select") return /* @__PURE__ */ M(v, {
+		value: t.draft,
+		defaultOpen: !0,
+		width: "fit",
+		variant: "compact",
+		b: 0,
+		bgColor: "transparent",
+		focus: { outline: 0 },
+		onValueChange: (e) => {
+			t.setDraft(e ?? null), t.commitEdit(), i();
+		},
+		props: d,
+		children: Ue(t).map((e) => /* @__PURE__ */ M(v.Item, {
+			value: e.value,
+			children: e.label ?? String(e.value)
+		}, String(e.value)))
+	});
+	let f = o === "number";
+	return /* @__PURE__ */ M(g, {
+		type: f ? "number" : "text",
+		value: t.draft === null || t.draft === void 0 ? "" : String(t.draft),
+		placeholder: s,
+		step: c,
+		width: "fit",
+		variant: "compact",
+		b: 0,
+		bgColor: "transparent",
+		focus: { outline: 0 },
+		onChange: (e) => {
+			let n = e.target.value;
+			t.setDraft(f ? n === "" ? null : Number(n) : n);
+		},
+		props: {
+			...d,
+			min: l,
+			max: u,
+			onBlur: r
+		}
+	});
+}
+We.displayName = "DataGridCellEditor";
+//#endregion
+//#region src/components/dataGrid/components/dataGridCellText.tsx
+function Ke(e) {
+	let { cell: t } = e;
+	return /* @__PURE__ */ M(f, {
+		component: `${t.grid.componentName}.body.cell.text`,
+		height: "fit",
+		width: "fit",
+		overflow: "auto",
+		ai: "center",
+		jc: t.column.align,
+		children: /* @__PURE__ */ M(r, {
+			px: 3,
+			textOverflow: "ellipsis",
+			overflow: "hidden",
+			textWrap: "nowrap",
+			children: t.value
+		})
+	});
+}
+Ke.displayName = "DataGridCellText";
+//#endregion
+//#region src/components/dataGrid/components/dataGridCellTree.tsx
+function qe(e) {
+	let { cell: t, row: n, children: i } = e, { hasChildren: a, treeExpanded: o, level: s } = n, c = n.grid.componentName, l = T((e) => {
+		e.stopPropagation(), n.toggleTree();
+	}, [n]), u = t.value == null || t.value === "" ? `row ${n.rowIndex + 1}` : String(t.value);
+	return /* @__PURE__ */ N(f, {
+		component: `${c}.body.cell.tree`,
+		ai: "center",
+		ps: s * n.grid.tree.indent,
+		children: [a ? /* @__PURE__ */ M(d, {
+			component: `${c}.body.cell.tree.toggle`,
+			variant: { isExpanded: o },
+			type: "button",
+			onClick: l,
+			cursor: "pointer",
+			display: "flex",
+			ai: "center",
+			jc: "center",
+			props: {
+				tabIndex: -1,
+				"aria-label": `${o ? "Collapse" : "Expand"} ${u}`
+			},
+			children: /* @__PURE__ */ M(J, {
+				fill: "currentColor",
+				width: "14px",
+				height: "14px",
+				rotate: o ? 0 : -90
+			})
+		}) : /* @__PURE__ */ M(r, { component: `${c}.body.cell.tree.spacer` }), /* @__PURE__ */ M(r, {
+			textOverflow: "ellipsis",
+			overflow: "hidden",
+			textWrap: "nowrap",
+			minWidth: 0,
+			children: i
+		})]
+	});
+}
+qe.displayName = "DataGridCellTree";
+//#endregion
+//#region src/components/dataGrid/components/dataGridRow.tsx
+function Je(e) {
+	let { row: t, index: n } = e, { selected: r, expandOnRowClick: i } = t, a = (R()?.headerRowCount ?? 0) + n, o = U(t) ? t : void 0, s = o && t.grid.tree.columnKey, c = T(() => {
+		t.toggleDetail();
+	}, [t]), l = (e, n) => {
+		if (e.editing) return /* @__PURE__ */ M(We, {
+			cell: e,
+			row: a,
+			columnIndex: n
+		});
+		let r = t.placeholder && !e.column.isRowNumber ? /* @__PURE__ */ M(Y, {
+			cell: e,
+			columnIndex: n
+		}) : e.column.Cell ? /* @__PURE__ */ M(e.column.Cell, { cell: e }) : /* @__PURE__ */ M(Ke, { cell: e });
+		return !o || e.column.key !== s ? r : /* @__PURE__ */ M(qe, {
+			cell: e,
+			row: o,
+			children: r
+		});
+	};
+	return /* @__PURE__ */ M(f, {
+		component: `${t.grid.componentName}.body.row`,
+		className: "grid-row",
+		selected: t.grid.props.def.rowSelection ? r : void 0,
+		display: "contents",
+		props: {
+			role: "row",
+			"aria-rowindex": a + 1,
+			"aria-busy": t.placeholder || void 0,
+			"aria-level": o ? o.level + 1 : void 0,
+			"aria-posinset": o ? o.position + 1 : void 0,
+			"aria-setsize": o ? o.siblings : void 0,
+			"aria-expanded": o?.hasChildren ? o.treeExpanded : void 0,
+			onClick: i ? c : void 0
+		},
+		cursor: i ? "pointer" : void 0,
+		children: t.cells.map((e, t) => /* @__PURE__ */ M(q, {
+			cell: e,
+			row: a,
+			columnIndex: t,
+			children: l(e, t)
+		}, e.column.key))
+	});
+}
+Je.displayName = "DataGridRow";
+//#endregion
+//#region src/components/dataGrid/components/dataGridBody.tsx
+function Ye(e, t) {
+	return e instanceof V ? /* @__PURE__ */ M(Ie, {
+		row: e,
+		index: t
+	}, e.key) : e instanceof Fe ? /* @__PURE__ */ M(Ve, {
+		row: e,
+		index: t
+	}, e.key) : /* @__PURE__ */ M(Je, {
+		row: e,
+		index: t
+	}, e.key);
+}
+function Xe(e) {
+	let { grid: t, scrollTop: n } = e, { viewport: i } = t, { startIndex: a, take: o, translateY: s, totalHeight: c, viewHeight: l } = i.window(n), u = i.showAll, d = i.isEmpty, p = t.flatRows.value, m = te(() => d ? null : W.take(p, o, a).map((e, t) => Ye(e, a + t)), [
+		p,
+		d,
+		o,
+		a
+	]);
+	if (d) {
+		let { noDataComponent: e } = t.props.def, n = t.props.loading ? "loading..." : "empty";
+		return /* @__PURE__ */ M(f, {
+			component: `${t.componentName}.body.empty`,
+			jc: "center",
+			ai: "center",
+			width: "fit",
+			position: "sticky",
+			insetStart: 0,
+			props: { role: "row" },
+			style: { height: i.emptyHeight },
+			children: /* @__PURE__ */ M(r, {
+				display: "contents",
+				props: { role: "gridcell" },
+				children: e ?? n
+			})
+		});
+	}
+	return u ? /* @__PURE__ */ N(j, { children: [/* @__PURE__ */ M(_, {
+		component: `${t.componentName}.body`,
+		width: "max-content",
+		minWidth: "fit",
+		transition: "none",
+		props: { role: "rowgroup" },
+		style: { gridTemplateColumns: t.gridTemplateColumns.value },
+		children: m
+	}), /* @__PURE__ */ M(ze, { grid: t })] }) : /* @__PURE__ */ N(r, {
+		props: { role: "presentation" },
+		style: { height: l },
+		children: [/* @__PURE__ */ M(r, {
+			props: { role: "presentation" },
+			style: { height: `${c}px` },
+			children: /* @__PURE__ */ M(_, {
+				component: `${t.componentName}.body`,
+				width: "max-content",
+				minWidth: "fit",
+				transition: "none",
+				props: { role: "rowgroup" },
+				style: {
+					transform: `translate3d(0, ${s}px, 0)`,
+					willChange: "transform",
+					gridTemplateColumns: t.gridTemplateColumns.value
+				},
+				children: m
+			})
+		}), /* @__PURE__ */ M(ze, { grid: t })]
+	});
+}
+Xe.displayName = "DataGridBody";
+//#endregion
+//#region src/components/dataGrid/components/dataGridEmptyColumns.tsx
+function Ze(e) {
+	let { grid: t } = e;
+	return /* @__PURE__ */ M(f, {
+		component: `${t.componentName}.emptyColumns`,
+		d: "column",
+		ai: "center",
+		jc: "center",
+		gap: 4,
+		py: 16,
+		px: 6,
+		bgColor: "gray-50",
+		borderRadius: 4,
+		theme: { dark: { bgColor: "gray-900" } },
+		children: /* @__PURE__ */ N(f, {
+			d: "column",
+			ai: "center",
+			gap: 3,
+			children: [/* @__PURE__ */ M(r, {
+				width: 16,
+				height: 16,
+				borderRadius: 999,
+				bgColor: "gray-200",
+				theme: { dark: { bgColor: "gray-700" } },
+				display: "flex",
+				ai: "center",
+				jc: "center",
+				children: /* @__PURE__ */ M(l, {
+					viewBox: "0 0 24 24",
+					width: "40",
+					fill: "currentColor",
+					color: "gray-400",
+					theme: { dark: { color: "gray-500" } },
+					children: /* @__PURE__ */ M(c, {
+						fillRule: "evenodd",
+						props: { clipRule: "evenodd" },
+						d: "M3 6a3 3 0 013-3h12a3 3 0 013 3v12a3 3 0 01-3 3H6a3 3 0 01-3-3V6zm3-1a1 1 0 00-1 1v12a1 1 0 001 1h12a1 1 0 001-1V6a1 1 0 00-1-1H6zm2 3a1 1 0 011-1h6a1 1 0 110 2H9a1 1 0 01-1-1zm0 4a1 1 0 011-1h6a1 1 0 110 2H9a1 1 0 01-1-1zm0 4a1 1 0 011-1h4a1 1 0 110 2H9a1 1 0 01-1-1z"
+					})
+				})
+			}), /* @__PURE__ */ N(f, {
+				d: "column",
+				ai: "center",
+				gap: 1,
+				children: [/* @__PURE__ */ M(r, {
+					fontSize: 18,
+					fontWeight: 600,
+					color: "gray-900",
+					theme: { dark: { color: "gray-50" } },
+					children: "No Columns Selected"
+				}), /* @__PURE__ */ M(r, {
+					fontSize: 14,
+					color: "gray-500",
+					textAlign: "center",
+					theme: { dark: { color: "gray-400" } },
+					children: "Select at least one column from the columns menu to display data"
+				})]
+			})]
+		})
+	});
+}
+//#endregion
+//#region src/components/dataGrid/components/dataGridColumnFilter.tsx
+function Qe(e) {
+	let { columnName: t, onClear: n } = e;
+	return /* @__PURE__ */ M(d, {
+		clean: !0,
+		type: "button",
+		position: "absolute",
+		insetEnd: 2,
+		top: "1/2",
+		translateY: "-1/2",
+		cursor: "pointer",
+		display: "flex",
+		ai: "center",
+		onClick: n,
+		props: {
+			tabIndex: -1,
+			"aria-label": `Clear the ${t} filter`
+		},
+		children: /* @__PURE__ */ M(r, {
+			fontSize: 10,
+			color: "gray-400",
+			hover: { color: "gray-600" },
+			children: "✕"
+		})
+	});
+}
+function $e({ column: e }) {
+	let { currentFilter: t } = e, { componentName: n } = e.grid, r = e.header ?? e.key, i = t?.type === "text" ? t.value : "", [a, o] = A(i), s = k(null);
+	D(() => () => {
+		s.current && clearTimeout(s.current);
+	}, []);
+	let c = T((t) => {
+		let n = t.target.value;
+		o(n), s.current && clearTimeout(s.current), s.current = setTimeout(() => {
+			e.setTextFilter(n), s.current = null;
+		}, 300);
+	}, [e]), l = T(() => {
+		o(""), e.clearFilter();
+	}, [e]);
+	return /* @__PURE__ */ N(f, {
+		component: `${n}.filter.cell.input`,
+		children: [/* @__PURE__ */ M(g, {
+			width: "fit",
+			variant: "compact",
+			placeholder: e.filterConfig?.placeholder ?? "Filter...",
+			value: a,
+			onChange: c,
+			b: 0,
+			bgColor: "transparent",
+			focus: { outline: 0 },
+			props: {
+				tabIndex: -1,
+				"aria-label": `Filter ${r}`
+			}
+		}), a && /* @__PURE__ */ M(Qe, {
+			columnName: r,
+			onClear: l
+		})]
+	});
+}
+function et({ column: e }) {
+	let { currentFilter: t } = e, { componentName: n } = e.grid, r = e.header ?? e.key, i = t?.type === "number" ? t.value : "", a = t?.type === "number" ? t.operator : "eq", o = t?.type === "number" ? t.valueTo : "", [s, c] = A(i), [l, u] = A(a), [d, p] = A(o ?? ""), m = k(null), h = k(null);
+	D(() => () => {
+		m.current && clearTimeout(m.current), h.current && clearTimeout(h.current);
+	}, []);
+	let _ = e.filterConfig, y = T((t) => {
+		let n = t.target.value;
+		c(n), m.current && clearTimeout(m.current), m.current = setTimeout(() => {
+			e.setNumberFilter(l, n, d), m.current = null;
+		}, 300);
+	}, [
+		e,
+		l,
+		d
+	]), b = T((t) => {
+		u(t), e.setNumberFilter(t, s, d);
+	}, [
+		e,
+		s,
+		d
+	]), x = T((t) => {
+		let n = t.target.value;
+		p(n), h.current && clearTimeout(h.current), h.current = setTimeout(() => {
+			e.setNumberFilter(l, s, n), h.current = null;
+		}, 300);
+	}, [
+		e,
+		l,
+		s
+	]), S = T(() => {
+		c(""), p(""), u("eq"), e.clearFilter();
+	}, [e]);
+	return /* @__PURE__ */ N(f, {
+		component: `${n}.filter.cell.input`,
+		ai: l === "between" ? "start" : "center",
+		gap: 1,
+		children: [/* @__PURE__ */ N(v, {
+			value: l,
+			variant: "compact",
+			onChange: (e) => e && b(e),
+			minWidth: 6,
+			hideIcon: !0,
+			b: 0,
+			bgColor: "transparent",
+			focus: { outline: 0 },
+			props: {
+				tabIndex: -1,
+				"aria-label": `Comparison for ${r}`
+			},
+			children: [
+				/* @__PURE__ */ M(v.Item, {
+					value: "eq",
+					children: "="
+				}),
+				/* @__PURE__ */ M(v.Item, {
+					value: "ne",
+					children: "≠"
+				}),
+				/* @__PURE__ */ M(v.Item, {
+					value: "gt",
+					children: ">"
+				}),
+				/* @__PURE__ */ M(v.Item, {
+					value: "gte",
+					children: "≥"
+				}),
+				/* @__PURE__ */ M(v.Item, {
+					value: "lt",
+					children: "<"
+				}),
+				/* @__PURE__ */ M(v.Item, {
+					value: "lte",
+					children: "≤"
+				}),
+				/* @__PURE__ */ M(v.Item, {
+					value: "between",
+					children: "↔"
+				})
+			]
+		}), l === "between" ? /* @__PURE__ */ N(f, {
+			d: "column",
+			gap: 1,
+			flex1: !0,
+			children: [/* @__PURE__ */ N(f, {
+				ai: "center",
+				position: "relative",
+				flex1: !0,
+				children: [/* @__PURE__ */ M(g, {
+					type: "number",
+					variant: "compact",
+					placeholder: _?.placeholder ?? "From",
+					value: s,
+					onChange: y,
+					width: "fit",
+					step: _?.step,
+					b: 0,
+					bgColor: "transparent",
+					focus: { outline: 0 },
+					props: {
+						tabIndex: -1,
+						"aria-label": `Filter ${r} from`
+					}
+				}), (s !== "" || d !== "") && /* @__PURE__ */ M(Qe, {
+					columnName: r,
+					onClear: S
+				})]
+			}), /* @__PURE__ */ M(f, {
+				ai: "center",
+				flex1: !0,
+				children: /* @__PURE__ */ M(g, {
+					type: "number",
+					variant: "compact",
+					placeholder: "To",
+					value: d,
+					onChange: x,
+					width: "fit",
+					step: _?.step,
+					b: 0,
+					bgColor: "transparent",
+					focus: { outline: 0 },
+					props: {
+						tabIndex: -1,
+						"aria-label": `Filter ${r} to`
+					}
+				})
+			})]
+		}) : /* @__PURE__ */ N(f, {
+			ai: "center",
+			position: "relative",
+			flex1: !0,
+			children: [/* @__PURE__ */ M(g, {
+				type: "number",
+				variant: "compact",
+				placeholder: _?.placeholder ?? "Value",
+				value: s,
+				onChange: y,
+				width: "fit",
+				step: _?.step,
+				b: 0,
+				bgColor: "transparent",
+				focus: { outline: 0 },
+				props: {
+					tabIndex: -1,
+					"aria-label": `Filter ${r}`
+				}
+			}), s !== "" && /* @__PURE__ */ M(Qe, {
+				columnName: r,
+				onClear: S
+			})]
+		})]
+	});
+}
+function tt({ column: e }) {
+	let { currentFilter: t } = e, { componentName: n } = e.grid, i = e.header ?? e.key, a = t?.type === "multiselect" ? t.values : [], o = e.filterOptions, s = T((t, n) => {
+		e.setMultiselectFilter(n);
+	}, [e]);
+	return /* @__PURE__ */ M(f, {
+		component: `${n}.filter.cell.input`,
+		children: /* @__PURE__ */ N(v, {
+			multiple: !0,
+			showCheckbox: !0,
+			isSearchable: !0,
+			searchPlaceholder: "Search...",
+			value: a,
+			width: "fit",
+			minWidth: 0,
+			bgColor: "transparent",
+			onChange: s,
+			variant: "compact",
+			b: 0,
+			focus: { outline: 0 },
+			props: {
+				tabIndex: -1,
+				"aria-label": `Filter ${i}`
+			},
+			children: [
+				/* @__PURE__ */ M(v.Display, { children: (t) => t.length === 0 ? /* @__PURE__ */ M(r, {
+					tag: "span",
+					color: "gray-400",
+					children: e.filterConfig?.placeholder ?? "Select..."
+				}) : t.length === 1 ? o.find((e) => e.value === t[0])?.label ?? String(t[0]) : `${t.length} selected` }),
+				/* @__PURE__ */ M(v.Unselect, { children: "Clear" }),
+				/* @__PURE__ */ M(v.SelectAll, { children: "Select All" }),
+				o.map((e) => /* @__PURE__ */ M(v.Item, {
+					value: e.value,
+					ai: "center",
+					gap: 2,
+					children: e.label
+				}, String(e.value)))
+			]
+		})
+	});
+}
+function nt(e) {
+	let { column: t } = e, n = t.filterConfig;
+	if (!n) return null;
+	switch (n.type) {
+		case "number": return /* @__PURE__ */ M(et, { column: t });
+		case "multiselect": return /* @__PURE__ */ M(tt, { column: t });
+		default: return /* @__PURE__ */ M($e, { column: t });
+	}
+}
+nt.displayName = "DataGridColumnFilter";
+//#endregion
+//#region src/components/dataGrid/components/dataGridFilterCell.tsx
+function rt(e) {
+	let { column: t, grid: n, row: r, columnIndex: i } = e, { widthVarName: a, inlineStartVarName: o, inlineEndVarName: s, filterable: c } = t, { isStartPinned: l, isEndPinned: u, isPinned: d, isFirstStartPinned: p, isLastStartPinned: m, isFirstEndPinned: h, isLastEndPinned: g } = t.pinFlags.value, { ref: _, tabIndex: v, onFocus: y } = R()?.cellProps(r, i) ?? {}, b = t.isGrouping || t.isRowNumber || t.isRowSelection;
+	return /* @__PURE__ */ M(f, {
+		ref: _,
+		component: `${n.componentName}.filter.cell`,
+		props: {
+			role: "gridcell",
+			"aria-colindex": i + 1,
+			tabIndex: v,
+			onFocus: y
+		},
+		variant: {
+			isPinned: d,
+			isFirstStartPinned: p,
+			isLastStartPinned: m,
+			isFirstEndPinned: h,
+			isLastEndPinned: g
+		},
+		px: 2,
+		style: {
+			width: `var(${a})`,
+			insetInlineStart: l ? `var(${o})` : void 0,
+			insetInlineEnd: u ? `var(${s})` : void 0
+		},
+		children: !b && c && /* @__PURE__ */ M(nt, { column: t })
+	});
+}
+rt.displayName = "DataGridFilterCell";
+//#endregion
+//#region src/components/dataGrid/components/dataGridFilterRow.tsx
+function it(e) {
+	let { grid: t } = e;
+	if (!t.filter.hasFilterableColumns) return null;
+	let n = t.headerRows.value.length;
+	return /* @__PURE__ */ M(r, {
+		display: "contents",
+		props: {
+			role: "row",
+			"aria-rowindex": n + 1
+		},
+		children: t.columns.value.visibleLeafs.map((e, r) => /* @__PURE__ */ M(rt, {
+			column: e,
+			grid: t,
+			row: n,
+			columnIndex: r
+		}, e.uniqueKey))
+	});
+}
+it.displayName = "DataGridFilterRow";
+//#endregion
+//#region src/icons/sortIcon.tsx
+function at(e) {
+	return /* @__PURE__ */ M(l, {
+		viewBox: "0 0 24 24",
+		width: "1.5rem",
+		...e,
+		children: /* @__PURE__ */ M(c, { d: "M4 12l1.41 1.41L11 7.83V20h2V7.83l5.58 5.59L20 12l-8-8-8 8z" })
+	});
+}
+//#endregion
+//#region src/icons/dotsIcon.tsx
+function ot(e) {
+	return /* @__PURE__ */ M(l, {
+		viewBox: "0 0 16 16",
+		width: "18",
+		...e,
+		children: /* @__PURE__ */ M(c, {
+			strokeWidth: 4,
+			d: "M7.936 12.128a.936.936 0 1 1 0 1.872.936.936 0 0 1 0-1.872ZM7.936 7.052a.936.936 0 1 1 0 1.873.936.936 0 0 1 0-1.873ZM7.936 1.977a.936.936 0 1 1 0 1.872.936.936 0 0 1 0-1.872Z"
+		})
+	});
+}
+//#endregion
+//#region src/icons/groupingIcon.tsx
+function st(e) {
+	return /* @__PURE__ */ M(l, {
+		viewBox: "0 0 24 24",
+		width: "1.5rem",
+		...e,
+		children: /* @__PURE__ */ M(c, { d: "M3 5h8v2H3V5zm0 6h8v2H3v-2zm0 6h8v2H3v-2zm12-12h6v6h-6V5zm1 1v4h4V6h-4zm-1 7h6v6h-6v-6zm1 1v4h4v-4h-4z" })
+	});
+}
+//#endregion
+//#region src/icons/pinIcon.tsx
+function ct(e) {
+	return /* @__PURE__ */ M(l, {
+		viewBox: "0 0 1024 1024",
+		width: "1.5rem",
+		...e,
+		children: /* @__PURE__ */ M(c, { d: "M31.997 1023.957a31.699 31.699 0 0 1-22.611-9.386C3.328 1008.556 0 1000.493 0 991.96s3.328-16.596 9.386-22.611L328.25 650.484l-152.52-152.52a95.907 95.907 0 0 1-25.087-92.152 95.31 95.31 0 0 1 44.327-58.62l.896-.512a353.464 353.464 0 0 1 176.156-47.398c20.137 0 40.36 1.749 60.283 5.205L597.71 44.54A95.224 95.224 0 0 1 678.685.085c25.64 0 49.745 9.983 67.877 28.073l249.195 249.195a95.224 95.224 0 0 1 25.897 88.74 95.139 95.139 0 0 1-42.152 60.154L719.513 591.695a352.227 352.227 0 0 1-42.663 237.292A95.395 95.395 0 0 1 594 876.514a95.523 95.523 0 0 1-67.963-28.2L373.43 695.706 54.61 1014.614a31.912 31.912 0 0 1-22.612 9.343zm340.025-660.68c-50.64 0-100.685 13.566-144.798 39.207a31.57 31.57 0 0 0-14.676 19.497 31.699 31.699 0 0 0 8.362 30.675L571.344 803.09c6.059 6.059 14.122 9.386 22.697 9.386a31.699 31.699 0 0 0 27.56-15.785 287.421 287.421 0 0 0 31.06-212.676 31.997 31.997 0 0 1 13.907-34.471l278.59-177.266a31.57 31.57 0 0 0 14.037-20.051 31.699 31.699 0 0 0-8.618-29.566l-249.28-249.28a31.912 31.912 0 0 0-49.618 5.418l-177.308 278.59a31.827 31.827 0 0 1-34.472 13.908 293.778 293.778 0 0 0-67.877-8.02z" })
+	});
+}
+//#endregion
+//#region src/components/dataGrid/components/dataGridHeaderCellContextMenu.tsx
+function lt(e) {
+	let t = e.side === "start" ? "Left" : "Right", n = e.side === "start" ? "Right" : "Left";
+	return /* @__PURE__ */ N(j, { children: [/* @__PURE__ */ N(b, {
+		rtl: { display: "none" },
+		children: ["Pin ", t]
+	}), /* @__PURE__ */ N(b, {
+		ltr: { display: "none" },
+		children: ["Pin ", n]
+	})] });
+}
+function ut(e) {
+	let { column: t } = e, { grid: c, isEndAligned: l, header: u, key: p } = t, g = t.headerCell, _ = u ?? p, v = s("datagrid-column-menu"), [y, x] = A(!1), C = k(null), w = k(null), E = k(!1), D = l ? 2 : void 0, ee = l ? void 0 : t.pin === "END" ? 2.5 : 4, O = te(() => {
+		let e = (e) => /* @__PURE__ */ M(b, {
+			component: `${c.componentName}.header.cell.contextMenu.tooltip.item.icon`,
+			children: e
+		}), n = (t) => e(/* @__PURE__ */ M(at, {
+			width: "100%",
+			fill: "currentColor",
+			rotate: t
+		})), i = (t, n) => e(/* @__PURE__ */ M(ct, {
+			width: "100%",
+			fill: "currentColor",
+			rotate: t,
+			rtl: { rotate: n }
+		})), a = e(/* @__PURE__ */ M(st, {
+			width: "100%",
+			fill: "currentColor"
+		})), o = /* @__PURE__ */ M(r, { width: 4 });
+		return [
+			[
+				g.canSortAsc && {
+					key: "sort-asc",
+					icon: n(),
+					label: "Sort Ascending",
+					text: "Sort Ascending",
+					run: () => t.sortColumn("ASC")
+				},
+				g.canSortDesc && {
+					key: "sort-desc",
+					icon: n(180),
+					label: "Sort Descending",
+					text: "Sort Descending",
+					run: () => t.sortColumn("DESC")
+				},
+				g.canClearSort && {
+					key: "sort-clear",
+					icon: o,
+					label: "Clear Sort",
+					text: "Clear Sort",
+					run: () => t.sortColumn(void 0)
+				}
+			],
+			[
+				g.canPinStart && {
+					key: "pin-start",
+					icon: i(0, -90),
+					label: /* @__PURE__ */ M(lt, { side: "start" }),
+					text: "Pin Left",
+					run: () => t.pinColumn("START")
+				},
+				g.canPinEnd && {
+					key: "pin-end",
+					icon: i(-90, 0),
+					label: /* @__PURE__ */ M(lt, { side: "end" }),
+					text: "Pin Right",
+					run: () => t.pinColumn("END")
+				},
+				g.canUnpin && {
+					key: "unpin",
+					icon: o,
+					label: "Unpin",
+					text: "Unpin",
+					run: () => t.pinColumn()
+				}
+			],
+			[g.canGroupBy && {
+				key: "group",
+				icon: a,
+				label: /* @__PURE__ */ N(r, {
+					textWrap: "nowrap",
+					children: ["Group by ", _]
+				}),
+				text: `Group by ${_}`,
+				run: t.toggleGrouping
+			}, g.canUnGroupAll && {
+				key: "ungroup",
+				icon: a,
+				label: /* @__PURE__ */ M(r, {
+					textWrap: "nowrap",
+					children: "Un-Group All"
+				}),
+				text: "Un-Group All",
+				run: c.unGroupAll
+			}]
+		].map((e) => e.filter((e) => e !== !1)).filter((e) => e.length > 0).flatMap((e, t) => e.map((e, n) => ({
+			...e,
+			startsSection: t > 0 && n === 0
+		})));
+	}, [
+		t,
+		_,
+		c,
+		g
+	]), j = T((e = !0) => {
+		E.current = !1, x(!1), e && C.current?.focus();
+	}, []), P = o({
+		count: O.length,
+		textOf: (e) => O[e]?.text ?? "",
+		onSelect: (e) => {
+			O[e]?.run(), j();
+		}
+	});
+	a({
+		enabled: y,
+		inside: [C, w],
+		onDismiss: () => j()
+	}), i({
+		enabled: y,
+		returnTo: C
+	});
+	let F = P.setActiveIndex, ne = P.activeItem, re = T(() => {
+		F(0, { reason: "programmatic" }), E.current = !0, x(!0);
+	}, [F]);
+	return n(() => {
+		if (!E.current) return;
+		let e = ne();
+		e && (E.current = !1, e.focus());
+	}), /* @__PURE__ */ N(f, {
+		position: "absolute",
+		insetStart: D,
+		insetEnd: ee,
+		top: "1/2",
+		translateY: -3,
+		ai: "center",
+		children: [/* @__PURE__ */ M(d, {
+			ref: C,
+			component: `${c.componentName}.header.cell.contextMenu`,
+			onClick: () => y ? j(!1) : re(),
+			variant: g.contextMenuButtonVariant,
+			type: "button",
+			props: {
+				tabIndex: -1,
+				"aria-label": `Column options for ${_}`,
+				"aria-haspopup": "menu",
+				"aria-expanded": y,
+				"aria-controls": y ? v : void 0
+			},
+			children: /* @__PURE__ */ M(b, {
+				component: `${c.componentName}.header.cell.contextMenu.icon`,
+				children: /* @__PURE__ */ M(ot, { fill: "currentColor" })
+			})
+		}), /* @__PURE__ */ M(h, {
+			present: y,
+			children: (e) => /* @__PURE__ */ M(m, {
+				component: `${c.componentName}.header.cell.contextMenu.tooltip`,
+				variant: { closed: !e.present },
+				ref: w,
+				contentRef: e.ref,
+				anchor: C,
+				side: "bottom",
+				align: "end",
+				matchWidth: !1,
+				id: v,
+				props: {
+					role: "menu",
+					"aria-label": `Column options for ${_}`,
+					onKeyDown: P.onKeyDown,
+					...e.props
+				},
+				children: O.map((e, t) => {
+					let { ref: n, tabIndex: i, onFocus: a } = P.itemProps(t);
+					return /* @__PURE__ */ N(S, { children: [e.startsSection && /* @__PURE__ */ M(r, {
+						bb: 1,
+						my: 2,
+						borderColor: "gray-300",
+						component: `${c.componentName}.header.cell.contextMenu.tooltip.item.separator`
+					}), /* @__PURE__ */ N(d, {
+						component: `${c.componentName}.header.cell.contextMenu.tooltip.item`,
+						ref: n,
+						type: "button",
+						onClick: (t) => {
+							t.stopPropagation(), e.run(), j();
+						},
+						props: {
+							role: "menuitem",
+							tabIndex: i,
+							onFocus: a
+						},
+						children: [e.icon, e.label]
+					})] }, e.key);
+				})
+			})
+		})]
+	});
+}
+ut.displayName = "DataGridHeaderCellContextMenu";
+//#endregion
+//#region src/components/dataGrid/components/dataGridHeaderCellResizer.tsx
+var X = (e) => "touches" in e ? e.touches[0]?.pageX ?? 0 : e.pageX, dt = 16, ft = 150;
+function pt(e) {
+	let t = e.sizingElement;
+	t && Object.entries(e.sizes.value).forEach(([e, n]) => t.style.setProperty(e, n));
+}
+function mt(e) {
+	let { column: t, controls: n } = e, i = t.grid.resizerStyle, a = t.headerCell, o = T((e) => {
+		let { grid: n } = t;
+		e.type === "mousedown" && e.preventDefault(), t.beginResize(X(e.nativeEvent));
+		let r = new AbortController(), { signal: i } = r, a = 0, o = X(e.nativeEvent), s = () => {
+			t.applyResize(o), pt(n);
+		}, c = n.resizeMode === "instant" ? (e) => {
+			o = X(e), s();
+		} : (e) => {
+			o = X(e), a ||= requestAnimationFrame(() => {
+				a = 0, s();
+			});
+		}, l = () => {
+			r.abort(), a && cancelAnimationFrame(a), s(), t.endResize();
+		};
+		window.addEventListener("mousemove", c, { signal: i }), window.addEventListener("touchmove", c, { signal: i }), window.addEventListener("mouseup", l, { signal: i }), window.addEventListener("touchend", l, { signal: i });
+	}, [t]), s = k(void 0), c = k(0), l = T(() => {
+		let { grid: e } = t;
+		if (e.resizeMode === "instant") {
+			pt(e);
+			return;
+		}
+		c.current ||= requestAnimationFrame(() => {
+			c.current = 0, pt(e);
+		});
+	}, [t]), u = T(() => {
+		s.current !== void 0 && (clearTimeout(s.current), s.current = void 0, c.current &&= (cancelAnimationFrame(c.current), 0), t.endResize());
+	}, [t]);
+	D(() => () => {
+		clearTimeout(s.current), c.current && cancelAnimationFrame(c.current);
+	}, []);
+	let d = T((e) => {
+		switch (e.key) {
+			case "ArrowRight":
+				t.moveResizer(dt);
+				break;
+			case "ArrowLeft":
+				t.moveResizer(-16);
+				break;
+			case "Home":
+				t.resizeWidthTo(a.minWidth);
+				break;
+			case "End":
+				t.resizeWidthTo(a.maxWidth);
+				break;
+			default: return;
+		}
+		e.preventDefault(), l(), clearTimeout(s.current), s.current = setTimeout(u, ft);
+	}, [
+		t,
+		u,
+		a,
+		l
+	]);
+	return /* @__PURE__ */ M(f, {
+		height: "fit",
+		ai: "center",
+		position: "absolute",
+		insetEnd: t.pin === "END" ? void 0 : 0,
+		insetStart: t.pin === "END" ? 0 : void 0,
+		py: 3,
+		children: /* @__PURE__ */ M(r, {
+			cursor: "col-resize",
+			px: .75,
+			mt: -6,
+			className: "resizer",
+			height: "fit",
+			props: {
+				onMouseDown: o,
+				onTouchStart: o
+			},
+			children: /* @__PURE__ */ M(r, {
+				component: `${t.grid.componentName}.header.cell.resizer`,
+				opacity: i === "visible" ? void 0 : 0,
+				group: i === "hover" ? { "header-cell/hover": { opacity: 1 } } : void 0,
+				props: {
+					role: "separator",
+					"aria-label": a.resizerLabel,
+					"aria-controls": n,
+					"aria-orientation": "vertical",
+					"aria-valuenow": a.width,
+					"aria-valuemin": a.minWidth,
+					"aria-valuemax": a.maxWidth,
+					"aria-valuetext": `${a.width} pixels`,
+					tabIndex: -1,
+					onKeyDown: d,
+					onKeyUp: u
+				}
+			})
+		})
+	});
+}
+mt.displayName = "DataGridHeaderCellResizer";
+//#endregion
+//#region src/components/dataGrid/components/dataGridHeaderCell.tsx
+function ht(e) {
+	let { column: t, row: n, columnIndex: i } = e, { grid: a } = t, { isStartPinned: o, isEndPinned: c } = t.pinFlags.value, l = t.headerCell, { isSortable: u, showResizer: d, showContextMenu: m, paddingStart: h, paddingEnd: g } = l, { ref: _, tabIndex: v, onFocus: b } = R()?.cellProps(n, i) ?? {}, x = s("datagrid-columnheader"), S = T(() => {
+		a.toggleSelectAllRows();
+	}, [a]), C = t.isRowSelection ? /* @__PURE__ */ M(p, {
+		variant: "datagrid",
+		m: 1,
+		indeterminate: a.someRowsSelected && !a.allRowsSelected,
+		checked: a.allRowsSelected,
+		onChange: S,
+		props: {
+			tabIndex: -1,
+			"aria-label": "Select all rows"
+		}
+	}) : l.hiddenLabel ? /* @__PURE__ */ M(y, {
+		tag: "span",
+		children: l.hiddenLabel
+	}) : l.label;
+	return /* @__PURE__ */ M(f, {
+		ref: _,
+		id: x,
+		props: {
+			role: "columnheader",
+			"aria-colindex": l.columnIndex,
+			"aria-colspan": l.columnSpan,
+			"aria-rowspan": l.rowSpan,
+			"aria-sort": l.ariaSort,
+			tabIndex: v,
+			onFocus: b
+		},
+		className: "header-cell",
+		component: `${a.componentName}.header.cell`,
+		variant: l.variant,
+		gridRow: t.gridRows,
+		gridColumn: l.gridColumn,
+		style: {
+			width: `var(${t.widthVarName})`,
+			insetInlineStart: o ? `var(${t.inlineStartVarName})` : void 0,
+			insetInlineEnd: c ? `var(${t.inlineEndVarName})` : void 0
+		},
+		children: /* @__PURE__ */ N(j, { children: [
+			/* @__PURE__ */ M(f, {
+				width: "fit",
+				height: "fit",
+				jc: t.align,
+				props: { onClick: u ? () => t.sortColumn() : void 0 },
+				children: /* @__PURE__ */ N(f, {
+					overflow: "hidden",
+					position: t.isLeaf ? void 0 : "sticky",
+					ai: "center",
+					transition: "none",
+					ps: h,
+					pe: g,
+					style: { insetInlineStart: t.pin ? void 0 : `var(${a.inlineStartEdgeVarName})` },
+					children: [
+						/* @__PURE__ */ M(r, {
+							overflow: "hidden",
+							textOverflow: "ellipsis",
+							textWrap: "nowrap",
+							children: C
+						}),
+						l.isSorted && /* @__PURE__ */ M(r, {
+							ps: (t.inlineWidth ?? 0) < 58 ? 0 : 2,
+							children: /* @__PURE__ */ M(at, {
+								width: "16px",
+								rotate: l.sortDirection === "ASC" ? 0 : 180,
+								fill: "currentColor"
+							})
+						}),
+						m && /* @__PURE__ */ M(r, { minWidth: t.isEndAligned ? 4 : 10 })
+					]
+				})
+			}),
+			d && /* @__PURE__ */ M(mt, {
+				column: t,
+				controls: x
+			}),
+			m && /* @__PURE__ */ M(ut, { column: t })
+		] })
+	});
+}
+ht.displayName = "DataGridHeaderCell";
+//#endregion
+//#region src/components/dataGrid/components/dataGridHeader.tsx
+function gt(e) {
+	let { grid: t } = e;
+	return /* @__PURE__ */ N(_, {
+		component: `${t.componentName}.header`,
+		props: { role: "rowgroup" },
+		style: { gridTemplateColumns: t.gridTemplateColumns.value },
+		children: [t.headerRows.value.map((e, t) => /* @__PURE__ */ M(r, {
+			display: "contents",
+			props: {
+				role: "row",
+				"aria-rowindex": t + 1
+			},
+			children: e.map((e, n) => /* @__PURE__ */ M(ht, {
+				column: e,
+				row: t,
+				columnIndex: n
+			}, e.uniqueKey))
+		}, t)), /* @__PURE__ */ M(it, { grid: t })]
+	});
+}
+gt.displayName = "DataGridHeader";
+//#endregion
+//#region src/components/dataGrid/components/dataGridLoader.tsx
+function _t(e) {
+	let { grid: t } = e;
+	return /* @__PURE__ */ M(r, {
+		component: `${t.componentName}.loader`,
+		props: { "aria-hidden": !0 },
+		children: /* @__PURE__ */ M(r, {
+			component: `${t.componentName}.loader.track`,
+			style: { height: 3 },
+			children: /* @__PURE__ */ M(r, {
+				component: `${t.componentName}.loader.track.bar`,
+				width: "2/5"
+			})
+		})
+	});
+}
+_t.displayName = "DataGridLoader";
+//#endregion
+//#region src/components/dataGrid/components/dataGridContent.tsx
+function vt(e) {
+	let { grid: t } = e, i = k(null), [a, o] = A(0), s = k(null), c = T((e) => {
+		s.current !== null && cancelAnimationFrame(s.current), s.current = requestAnimationFrame(() => {
+			o(e.target.scrollTop), s.current = null;
+		});
+	}, []), l = Ce({
+		grid: t,
+		scrollerRef: i,
+		scrollTop: a,
+		onScrollTo: o
+	}), { source: u } = t, { queryVersion: d } = u;
+	return n(() => {
+		u.enabled && i.current && (i.current.scrollTop = 0);
+	}, [u, d]), D(() => {
+		if (!u.enabled) return;
+		let { startIndex: e, take: n } = t.viewport.window(i.current?.scrollTop ?? 0);
+		u.request(e, e + n);
+	}, [
+		t,
+		u,
+		d,
+		a,
+		t.totalRowCount,
+		t.page,
+		t.pageSize,
+		t.expansionVersion
+	]), n(() => {
+		let e = i.current;
+		if (!e) return;
+		let n = new ResizeObserver(() => t.setContainerWidth(e.clientWidth));
+		return n.observe(e), () => n.disconnect();
+	}, [t]), t.hasVisibleColumns ? /* @__PURE__ */ M(le.Provider, {
+		value: l,
+		children: /* @__PURE__ */ N(r, {
+			ref: i,
+			component: `${t.componentName}.content`,
+			overflowX: "auto",
+			scrollbarGutter: t.viewport.showAll ? void 0 : "stable",
+			style: { willChange: "scroll-position" },
+			props: {
+				role: t.tree.enabled ? "treegrid" : "grid",
+				"aria-rowcount": l.rowCount,
+				"aria-colcount": l.columnCount,
+				"aria-multiselectable": t.props.def.rowSelection ? !0 : void 0,
+				"aria-labelledby": t.props.def.title ? t.titleId : void 0,
+				"aria-busy": t.props.loading || u.isLoading ? !0 : void 0,
+				onScroll: c,
+				onKeyDown: l.onKeyDown
+			},
+			children: [
+				/* @__PURE__ */ M(gt, { grid: t }),
+				(t.props.loading || u.isLoading) && /* @__PURE__ */ M(_t, { grid: t }),
+				/* @__PURE__ */ M(Xe, {
+					grid: t,
+					scrollTop: a
+				})
+			]
+		})
+	}) : /* @__PURE__ */ M(Ze, { grid: t });
+}
+vt.displayName = "DataGridContent";
+//#endregion
+//#region src/components/dataGrid/components/dataGridDataSourceError.tsx
+function yt(e) {
+	let { grid: t } = e, { error: n } = t.source;
+	if (n === void 0) return null;
+	let i = n instanceof Error && n.message ? n.message : "Could not load rows.";
+	return /* @__PURE__ */ N(f, {
+		component: `${t.componentName}.error`,
+		props: { role: "alert" },
+		children: [/* @__PURE__ */ M(r, {
+			component: `${t.componentName}.error.message`,
+			children: i
+		}), /* @__PURE__ */ M(d, {
+			component: `${t.componentName}.error.retry`,
+			type: "button",
+			onClick: t.source.retry,
+			children: "Retry"
+		})]
+	});
+}
+yt.displayName = "DataGridDataSourceError";
+//#endregion
+//#region src/components/dataGrid/components/dataGridColumnGroups.tsx
+function bt(e) {
+	let { grid: t } = e;
+	return t.groupColumns.size === 0 ? null : /* @__PURE__ */ N(f, {
+		component: `${t.componentName}.topBar.columnGroups`,
+		children: [/* @__PURE__ */ M(b, {
+			component: `${t.componentName}.topBar.columnGroups.icon`,
+			children: /* @__PURE__ */ M(st, {
+				width: "100%",
+				fill: "currentColor"
+			})
+		}), t.groupedColumns.map((e) => /* @__PURE__ */ N(x.Fragment, { children: [/* @__PURE__ */ M(J, {
+			fill: "currentColor",
+			width: "14px",
+			height: "14px",
+			rotate: -90
+		}), /* @__PURE__ */ N(f, {
+			component: `${t.componentName}.topBar.columnGroups.item`,
+			children: [e.header ?? e.key, /* @__PURE__ */ M(d, {
+				component: `${t.componentName}.topBar.columnGroups.item.icon`,
+				onClick: () => t.toggleGrouping(e.key),
+				props: { "aria-label": `Stop grouping by ${e.header ?? e.key}` },
+				children: /* @__PURE__ */ M(r, {
+					fontSize: 10,
+					color: "gray-400",
+					hover: { color: "gray-600" },
+					children: "✕"
+				})
+			})]
+		})] }, e.key))]
+	});
+}
+bt.displayName = "DataGridColumnGroups";
+//#endregion
+//#region src/components/dataGrid/components/dataGridExport.tsx
+function xt(e) {
+	let { grid: t } = e, n = t.exportConfig, r = T(() => void t.exportCsv(n).catch(() => void 0), [t, n]), i = T(() => void t.exportXlsx(n).catch(() => void 0), [t, n]);
+	return n ? /* @__PURE__ */ N(f, {
+		component: `${t.componentName}.topBar.export`,
+		ai: "center",
+		gap: 2,
+		children: [n.csv !== !1 && /* @__PURE__ */ M(St, {
+			componentName: t.componentName,
+			onClick: r,
+			label: "Export CSV",
+			children: "CSV"
+		}), n.xlsx !== !1 && /* @__PURE__ */ M(St, {
+			componentName: t.componentName,
+			onClick: i,
+			label: "Export Excel",
+			children: "Excel"
+		})]
+	}) : null;
+}
+xt.displayName = "DataGridExport";
+function St(e) {
+	let { componentName: t, onClick: n, label: r, children: i } = e;
+	return /* @__PURE__ */ N(d, {
+		component: `${t}.topBar.export.button`,
+		onClick: n,
+		props: { "aria-label": r },
+		children: [/* @__PURE__ */ N(l, {
+			viewBox: "0 0 20 20",
+			width: 16,
+			height: 16,
+			fill: "none",
+			stroke: "currentColor",
+			strokeWidth: 1.6,
+			children: [/* @__PURE__ */ M(c, {
+				d: "M10 3v9m0 0 3.5-3.5M10 12 6.5 8.5",
+				strokeLinecap: "round",
+				strokeLinejoin: "round"
+			}), /* @__PURE__ */ M(c, {
+				d: "M3.5 13.5v2a1 1 0 0 0 1 1h11a1 1 0 0 0 1-1v-2",
+				strokeLinecap: "round"
+			})]
+		}), i]
+	});
+}
+//#endregion
+//#region src/icons/searchIcon.tsx
+function Ct(e) {
+	return /* @__PURE__ */ M(l, {
+		viewBox: "0 0 488.4 488.4",
+		width: "1.5rem",
+		...e,
+		children: /* @__PURE__ */ M(c, { d: "M0 203.25c0 112.1 91.2 203.2 203.2 203.2 51.6 0 98.8-19.4 134.7-51.2l129.5 129.5c2.4 2.4 5.5 3.6 8.7 3.6s6.3-1.2 8.7-3.6c4.8-4.8 4.8-12.5 0-17.3l-129.6-129.5c31.8-35.9 51.2-83 51.2-134.7C406.4 91.15 315.2.05 203.2.05S0 91.15 0 203.25zm381.9 0c0 98.5-80.2 178.7-178.7 178.7s-178.7-80.2-178.7-178.7 80.2-178.7 178.7-178.7 178.7 80.1 178.7 178.7z" })
+	});
+}
+//#endregion
+//#region src/components/dataGrid/components/dataGridGlobalFilter.tsx
+function wt(e) {
+	let { grid: t } = e, [n, i] = A(t.globalFilterValue), a = k(null);
+	D(() => () => {
+		a.current && clearTimeout(a.current);
+	}, []);
+	let o = T((e) => {
+		let n = e.target.value;
+		i(n), a.current && clearTimeout(a.current), a.current = setTimeout(() => {
+			t.filter.setGlobalFilter(n), a.current = null;
+		}, 300);
+	}, [t]), s = T(() => {
+		i(""), t.filter.setGlobalFilter("");
+	}, [t]), { filtered: c, total: l } = t.filter.filterStats, u = t.filter.hasActiveFilters && c !== l;
+	return /* @__PURE__ */ N(f, {
+		component: `${t.componentName}.topBar.globalFilter`,
+		children: [u && /* @__PURE__ */ N(r, {
+			component: `${t.componentName}.topBar.globalFilter.stats`,
+			children: [
+				c,
+				"/",
+				l
+			]
+		}), /* @__PURE__ */ N(f, {
+			position: "relative",
+			ai: "center",
+			children: [
+				/* @__PURE__ */ M(f, {
+					position: "absolute",
+					insetStart: 3,
+					pointerEvents: "none",
+					color: "gray-400",
+					theme: { dark: { color: "gray-500" } },
+					children: /* @__PURE__ */ M(Ct, {
+						fill: "currentColor",
+						width: "14px"
+					})
+				}),
+				/* @__PURE__ */ M(g, {
+					placeholder: "Search...",
+					variant: "compact",
+					value: n,
+					onChange: o,
+					ps: 8,
+					pe: n ? 8 : 3
+				}),
+				n && /* @__PURE__ */ M(r, {
+					position: "absolute",
+					insetEnd: 2,
+					cursor: "pointer",
+					p: 1,
+					color: "gray-400",
+					hover: { color: "gray-600" },
+					theme: { dark: {
+						color: "gray-500",
+						hover: { color: "gray-300" }
+					} },
+					props: { onClick: s },
+					children: /* @__PURE__ */ M(r, {
+						fontSize: 12,
+						fontWeight: 600,
+						children: "✕"
+					})
+				})
+			]
+		})]
+	});
+}
+//#endregion
+//#region src/components/dataGrid/components/dataGridTopBarContextMenu.tsx
+function Tt(e) {
+	let { grid: t } = e, { columnVisibility: n } = t, { entries: i, selectedIds: a, total: o, hasHidden: s } = n;
+	return /* @__PURE__ */ N(v, {
+		component: `${t.componentName}.topBar.columnVisibility`,
+		multiple: !0,
+		showCheckbox: !0,
+		hideIcon: !0,
+		variant: "compact",
+		value: a,
+		onChange: (e, t) => {
+			n.setVisibility(t);
+		},
+		isSearchable: i.length > 6,
+		searchPlaceholder: "Search columns...",
+		display: "inline-flex",
+		props: { "aria-label": "Columns" },
+		children: [
+			/* @__PURE__ */ M(v.Display, { children: (e) => {
+				let n = e.length === 0;
+				return /* @__PURE__ */ N(f, {
+					ai: "center",
+					gap: 2,
+					children: [/* @__PURE__ */ N(u, {
+						viewBox: "0 0 20 20",
+						width: "18",
+						height: "18",
+						children: [
+							/* @__PURE__ */ M("rect", {
+								x: "2",
+								y: "3",
+								width: "4",
+								height: "14",
+								rx: "1",
+								fill: "currentColor",
+								opacity: .9
+							}),
+							/* @__PURE__ */ M("rect", {
+								x: "8",
+								y: "3",
+								width: "4",
+								height: "14",
+								rx: "1",
+								fill: "currentColor",
+								opacity: .6
+							}),
+							/* @__PURE__ */ M("rect", {
+								x: "14",
+								y: "3",
+								width: "4",
+								height: "14",
+								rx: "1",
+								fill: "currentColor",
+								opacity: .3
+							})
+						]
+					}), s && /* @__PURE__ */ N(r, {
+						component: `${t.componentName}.topBar.columnVisibility.badge`,
+						tag: "span",
+						fontSize: 11,
+						lineHeight: 16,
+						fontWeight: 500,
+						px: 2,
+						py: .5,
+						borderRadius: 1,
+						bgColor: n ? "red-100" : "amber-100",
+						color: n ? "red-700" : "amber-700",
+						theme: { dark: {
+							bgColor: n ? "red-900" : "amber-900",
+							color: n ? "red-300" : "amber-300"
+						} },
+						children: [
+							e.length,
+							"/",
+							o
+						]
+					})]
+				});
+			} }),
+			/* @__PURE__ */ M(v.SelectAll, { children: "Show All" }),
+			/* @__PURE__ */ M(v.Unselect, { children: "Hide All" }),
+			i.map((e) => /* @__PURE__ */ M(v.Item, {
+				value: e.id,
+				textWrap: "nowrap",
+				children: e.label
+			}, e.id))
+		]
+	});
+}
+Tt.displayName = "DataGridTopBarContextMenu";
+//#endregion
+//#region src/components/dataGrid/components/dataGridTopBar.tsx
+function Et(e) {
+	let { grid: t } = e, { title: n, topBarContent: i, globalFilter: a } = t.props.def;
+	return /* @__PURE__ */ N(f, {
+		component: `${t.componentName}.topBar`,
+		position: "relative",
+		d: "column",
+		gap: 3,
+		children: [/* @__PURE__ */ N(f, {
+			ai: "center",
+			jc: "space-between",
+			gap: 4,
+			flexWrap: "wrap",
+			width: "fit",
+			children: [/* @__PURE__ */ N(f, {
+				ai: "center",
+				gap: 3,
+				flexWrap: "wrap",
+				minWidth: 0,
+				children: [
+					/* @__PURE__ */ M(Tt, { grid: t }),
+					n && /* @__PURE__ */ M(r, {
+						id: t.titleId,
+						fontWeight: 600,
+						fontSize: 16,
+						color: "gray-800",
+						theme: { dark: { color: "gray-100" } },
+						children: n
+					}),
+					/* @__PURE__ */ M(bt, { grid: t })
+				]
+			}), /* @__PURE__ */ N(f, {
+				ai: "center",
+				gap: 3,
+				flexWrap: "wrap",
+				children: [a && /* @__PURE__ */ M(wt, { grid: t }), /* @__PURE__ */ M(xt, { grid: t })]
+			})]
+		}), i && /* @__PURE__ */ M(r, {
+			width: "fit",
+			children: i
+		})]
+	});
+}
+Et.displayName = "DataGridTopBar";
+//#endregion
+//#region src/utils/string/fuzzySearch.ts
+function Dt(e, t) {
+	if (!e) return {
+		score: 1,
+		matches: []
+	};
+	if (!t) return null;
+	let n = e.toLowerCase(), r = t.toLowerCase(), i = 0, a = 0, o = [], s = -1, c = 0, l = 0;
+	for (; i < n.length && a < r.length;) n[i] === r[a] ? (s === -1 && (s = a), i++, l++, c += l, (a === 0 || /\s|_|-/.test(t[a - 1])) && (c += 5), e[i - 1] === t[a] && (c += 1)) : (s !== -1 && (o.push([s, a]), s = -1), l = 0), a++;
+	return s !== -1 && o.push([s, a]), i < n.length ? null : (c /= t.length, {
+		score: c,
+		matches: o
+	});
+}
+function Ot(e, t) {
+	return Dt(e, t) !== null;
+}
+//#endregion
+//#region src/components/dataGrid/components/dataGridCellRowDetail.tsx
+function kt(e) {
+	let { cell: t } = e, n = t.isExpanded, r = T((e) => {
+		e.stopPropagation(), t.toggleDetail();
+	}, [t]);
+	return /* @__PURE__ */ M(d, {
+		component: `${t.grid.componentName}.body.cell.rowDetail`,
+		variant: { isExpanded: n },
+		type: "button",
+		onClick: r,
+		cursor: "pointer",
+		display: "flex",
+		ai: "center",
+		jc: "center",
+		width: "fit",
+		height: "fit",
+		props: {
+			tabIndex: -1,
+			"aria-label": `${n ? "Collapse" : "Expand"} details for row ${t.row.rowIndex + 1}`,
+			"aria-expanded": n
+		},
+		children: /* @__PURE__ */ M(J, {
+			fill: "currentColor",
+			width: "14px",
+			height: "14px",
+			rotate: n ? 0 : -90
+		})
+	});
+}
+kt.displayName = "DataGridCellRowDetail";
+//#endregion
+//#region src/components/dataGrid/components/dataGridCellRowSelection.tsx
+function At(e) {
+	let { cell: t } = e, n = T(() => {
+		t.toggleSelection();
+	}, [t]);
+	return /* @__PURE__ */ M(p, {
+		variant: "datagrid",
+		checked: t.selected,
+		indeterminate: t.indeterminate,
+		onChange: n,
+		props: {
+			tabIndex: -1,
+			"aria-label": `Select row ${t.row.rowIndex + 1}`
+		}
+	});
+}
+At.displayName = "DataGridCellRowSelection";
+//#endregion
+//#region src/components/dataGrid/contracts/dataGridContract.ts
+function jt(e) {
+	if (e) return e === "LEFT" ? "START" : e === "RIGHT" ? "END" : e;
+}
+//#endregion
+//#region src/components/dataGrid/models/headerCellModel.ts
+var Mt = 1e3, Nt = class {
+	column;
+	constructor(e) {
+		this.column = e;
+	}
+	get grid() {
+		return this.column.grid;
+	}
+	get label() {
+		let e = this.column;
+		if (e.isRowNumber || e.isRowSelection) return null;
+		if (e.isGrouping) {
+			if (this.grid.groupColumns.size === 1) {
+				let e = this.grid.groupColumns.values().next().value, t = W.findOrThrow(this.grid.columns.value.leafs, (t) => t.key === e);
+				return t.header ?? t.key;
+			}
+			return "Group";
+		}
+		return e.header ?? e.key;
+	}
+	get hiddenLabel() {
+		if (this.column.isRowNumber) return "Row number";
+		if (this.column.isRowDetail) return "Row details";
+	}
+	get isSortable() {
+		let e = this.column;
+		return e.isLeaf && !e.isRowNumber && !e.isRowSelection && !e.isRowDetail && e.sortable;
+	}
+	get isSorted() {
+		return this.column.key === this.grid.sortColumn;
+	}
+	get sortDirection() {
+		return this.grid.sortDirection;
+	}
+	get showResizer() {
+		let e = this.column;
+		return !e.isRowNumber && !e.isRowSelection && !e.isRowDetail && e.resizable;
+	}
+	get showContextMenu() {
+		let e = this.column;
+		return !e.isRowNumber && !e.isRowSelection && !e.isRowDetail && e.showContextMenu;
+	}
+	get gridColumn() {
+		return this.column.isLeaf ? 1 : this.column.leafs.length;
+	}
+	get columnIndex() {
+		let e = this.column.leafs[0] ?? this.column;
+		return this.grid.columns.value.visibleLeafs.indexOf(e) + 1;
+	}
+	get columnSpan() {
+		let e = this.column.leafs.length;
+		return e > 1 ? e : void 0;
+	}
+	get rowSpan() {
+		let e = this.column.gridRows;
+		return e > 1 ? e : void 0;
+	}
+	get ariaSort() {
+		if (this.isSortable) return !this.isSorted || !this.sortDirection ? "none" : this.sortDirection === "ASC" ? "ascending" : "descending";
+	}
+	get resizerLabel() {
+		return `Resize ${this.label ?? this.column.key}`;
+	}
+	get width() {
+		return this.column.inlineWidth ?? this.column.baseWidth;
+	}
+	get minWidth() {
+		return Math.max(1, this.column.leafs.length) * this.grid.MIN_COLUMN_WIDTH_PX;
+	}
+	get maxWidth() {
+		return Math.max(this.grid.containerWidth || Mt, this.width, this.minWidth);
+	}
+	get paddingStart() {
+		if (!this.column.isRowSelection) return this.column.isEndAligned ? 10 : 3;
+	}
+	get paddingEnd() {
+		if (!this.column.isRowSelection) return this.column.align === "center" ? 3 : void 0;
+	}
+	get variant() {
+		let { isPinned: e, isFirstStartPinned: t, isLastStartPinned: n, isFirstEndPinned: r, isLastEndPinned: i } = this.column.pinFlags.value;
+		return {
+			isPinned: e,
+			isFirstStartPinned: t,
+			isLastStartPinned: n,
+			isFirstEndPinned: r,
+			isLastEndPinned: i,
+			isSortable: this.isSortable,
+			isRowNumber: this.column.isRowNumber,
+			isFirstLeaf: this.column.isFirstLeaf,
+			isLastLeaf: this.column.isLastLeaf
+		};
+	}
+	get contextMenuButtonVariant() {
+		let { isPinned: e, isFirstStartPinned: t, isLastStartPinned: n, isFirstEndPinned: r, isLastEndPinned: i } = this.column.pinFlags.value;
+		return {
+			isPinned: e,
+			isFirstStartPinned: t,
+			isLastStartPinned: n,
+			isFirstEndPinned: r,
+			isLastEndPinned: i,
+			isSortable: this.isSortable,
+			isRowNumber: this.column.isRowNumber
+		};
+	}
+	get sections() {
+		return this.column.contextMenuSections;
+	}
+	get canSortAsc() {
+		let { key: e } = this.column;
+		return this.sections.sort && this.column.isLeaf && this.column.sortable && (this.grid.sortColumn !== e || this.grid.sortDirection === "DESC");
+	}
+	get canSortDesc() {
+		let { key: e } = this.column;
+		return this.sections.sort && this.column.isLeaf && this.column.sortable && (this.grid.sortColumn !== e || this.grid.sortDirection === "ASC");
+	}
+	get canClearSort() {
+		return this.sections.sort && this.column.isLeaf && this.column.sortable && this.grid.sortColumn === this.column.key;
+	}
+	get canPinStart() {
+		return this.sections.pin && this.column.pin !== "START";
+	}
+	get canPinEnd() {
+		return this.sections.pin && this.column.pin !== "END";
+	}
+	get canUnpin() {
+		return this.sections.pin && !!this.column.pin;
+	}
+	get canGroupBy() {
+		return this.sections.group && this.column.isLeaf && !this.column.isGrouping;
+	}
+	get canUnGroupAll() {
+		return this.sections.group && this.column.isLeaf && this.column.isGrouping;
+	}
+	get hasSortSection() {
+		return this.canSortAsc || this.canSortDesc || this.canClearSort;
+	}
+	get hasPinSection() {
+		return this.canPinStart || this.canPinEnd || this.canUnpin;
+	}
+	get hasGroupSection() {
+		return this.canGroupBy || this.canUnGroupAll;
+	}
+}, Z = class e {
+	def;
+	grid;
+	parent;
+	constructor(t, n, r) {
+		if (this.def = t, this.grid = n, this.parent = r, this.columns = t.columns?.map((r) => new e(t.pin ? {
+			...r,
+			pin: t.pin
+		} : r, n, this)) ?? [], this.isLeaf) {
+			let e = this.grid.columnWidths.get(this.key);
+			this._inlineWidth = e ?? this.def.width ?? this.grid.DEFAULT_COLUMN_WIDTH_PX, this._pin = jt(t.pin);
+		}
+	}
+	columns = [];
+	get kind() {
+		switch (this.key) {
+			case Te: return "rowNumber";
+			case Ee: return "rowSelection";
+			case De: return "rowDetail";
+			case G: return "grouping";
+			default: return "data";
+		}
+	}
+	get isRowNumber() {
+		return this.kind === "rowNumber";
+	}
+	get isRowSelection() {
+		return this.kind === "rowSelection";
+	}
+	get isRowDetail() {
+		return this.kind === "rowDetail";
+	}
+	get isGrouping() {
+		return this.kind === "grouping";
+	}
+	get isData() {
+		return this.kind === "data";
+	}
+	pinFlags = B(() => {
+		let e = this.pin === "START", t = this.pin === "END";
+		return {
+			isStartPinned: e,
+			isEndPinned: t,
+			isPinned: e || t,
+			isFirstStartPinned: e && this.startOffset === 0,
+			isLastStartPinned: e && this.isEdge,
+			isFirstEndPinned: t && this.isEdge,
+			isLastEndPinned: t && this.endOffset === 0
+		};
+	}, () => [this.grid.columns]);
+	cellVariant = B(() => {
+		let { isPinned: e, isFirstStartPinned: t, isLastStartPinned: n, isFirstEndPinned: r, isLastEndPinned: i } = this.pinFlags.value;
+		return {
+			isPinned: e,
+			isFirstStartPinned: t,
+			isLastStartPinned: n,
+			isFirstEndPinned: r,
+			isLastEndPinned: i,
+			isRowSelection: this.isRowSelection,
+			isRowNumber: this.isRowNumber,
+			isFirstLeaf: this.isFirstLeaf,
+			isLastLeaf: this.isLastLeaf,
+			isRowDetail: this.isRowDetail
+		};
+	}, () => [this.pinFlags]);
+	cellStyleVars = B(() => {
+		let { isStartPinned: e, isEndPinned: t } = this.pinFlags.value;
+		return {
+			width: `var(${this.widthVarName})`,
+			height: `var(${this.grid.rowHeightVarName})`,
+			insetInlineStart: e ? `var(${this.inlineStartVarName})` : void 0,
+			insetInlineEnd: t ? `var(${this.inlineEndVarName})` : void 0
+		};
+	}, () => [this.pinFlags]);
+	_headerCell = B(() => new Nt(this));
+	get headerCell() {
+		return this._headerCell.value;
+	}
+	get visibleColumns() {
+		return this.columns.filter((e) => e.isVisible);
+	}
+	get isFirstLeaf() {
+		let { leafs: e } = this;
+		return e.length > 0 && e.at(0) === this;
+	}
+	get isLastLeaf() {
+		let { leafs: e } = this;
+		return e.length > 0 && e.at(-1) === this;
+	}
+	get key() {
+		return this.def.key;
+	}
+	get header() {
+		return this.def.header;
+	}
+	get align() {
+		return this.def.align;
+	}
+	get isEndAligned() {
+		return this.align === "end" || this.align === "right";
+	}
+	get hasAlign() {
+		return "align" in this.def;
+	}
+	get isLeaf() {
+		return this.columns.length === 0;
+	}
+	get Cell() {
+		return this.def.Cell;
+	}
+	get aggregate() {
+		return this.def.aggregate;
+	}
+	get AggregateCell() {
+		return this.def.AggregateCell;
+	}
+	get filterable() {
+		return this.def.filterable;
+	}
+	get filterConfig() {
+		let { filterable: e } = this.def;
+		if (e) return typeof e == "object" ? e : { type: "text" };
+	}
+	get currentFilter() {
+		return this.grid.columnFilters[this.key];
+	}
+	get filterOptions() {
+		let e = this.filterConfig;
+		return e?.type === "multiselect" && e.options ? e.options : this.grid.getColumnUniqueValues(this.key).map((e) => ({
+			label: e === null ? "(empty)" : String(e),
+			value: e
+		}));
+	}
+	setTextFilter(e) {
+		this.grid.setColumnFilter(this.key, e.trim() ? {
+			type: "text",
+			value: e
+		} : void 0);
+	}
+	setNumberFilter(e, t, n) {
+		let r = typeof t == "number" ? t : parseFloat(t);
+		if (isNaN(r) || t === "") {
+			this.grid.setColumnFilter(this.key, void 0);
+			return;
+		}
+		let i = {
+			type: "number",
+			operator: e,
+			value: r
+		};
+		if (e === "between" && n !== void 0 && n !== "") {
+			let e = typeof n == "number" ? n : parseFloat(String(n));
+			isNaN(e) || (i.valueTo = e);
+		}
+		this.grid.setColumnFilter(this.key, i);
+	}
+	setMultiselectFilter(e) {
+		this.grid.setColumnFilter(this.key, e.length === 0 ? void 0 : {
+			type: "multiselect",
+			values: e
+		});
+	}
+	clearFilter() {
+		this.grid.setColumnFilter(this.key, void 0);
+	}
+	get editable() {
+		return this.def.editable === void 0 ? this.grid.props.def.editable ?? !1 : this.def.editable;
+	}
+	get sortable() {
+		return this.def.sortable === void 0 ? this.grid.props.def.sortable !== !1 : this.def.sortable;
+	}
+	get resizable() {
+		return this.def.resizable === void 0 ? this.grid.props.def.resizable !== !1 : this.def.resizable;
+	}
+	get contextMenu() {
+		return this.def.contextMenu === void 0 ? this.grid.props.def.contextMenu ?? !0 : this.def.contextMenu;
+	}
+	get showContextMenu() {
+		let e = this.contextMenu;
+		return typeof e == "boolean" ? e : e.sort !== !1 || e.pin !== !1 || e.group !== !1;
+	}
+	get contextMenuSections() {
+		let e = this.contextMenu, t = (!this.grid.source.enabled || this.grid.source.canGroup) && !this.grid.tree.enabled;
+		return typeof e == "boolean" ? {
+			sort: e,
+			pin: e,
+			group: e && t
+		} : {
+			sort: e.sort !== !1,
+			pin: e.pin !== !1,
+			group: t && e.group !== !1
+		};
+	}
+	get isFlexible() {
+		return this.def.flexible !== !1;
+	}
+	get baseWidth() {
+		return this._inlineWidth ?? this.grid.DEFAULT_COLUMN_WIDTH_PX;
+	}
+	_pin;
+	get pin() {
+		if (this.isLeaf) return this._pin;
+		let e = [...new Set(this.columns.flatMap((e) => e.pin))];
+		if (e.length === 1) return e[0];
+	}
+	get uniqueKey() {
+		return `${this.key}${this.pin ?? ""}`;
+	}
+	getPinnedColumn(t) {
+		if (this.hasPin(t)) {
+			if (this.isLeaf) return this;
+			let n = new e({
+				...this.def,
+				pin: t
+			}, this.grid, this.parent);
+			return n.columns = this.columns.filter((e) => e.hasPin(t)).map((e) => {
+				let r = e.getPinnedColumn(t);
+				return r.parent = n, r;
+			}).filter((e) => !!e), n;
+		}
+	}
+	hasPin(e) {
+		return this.isLeaf ? this._pin === e : this.columns.some((t) => t.hasPin(e));
+	}
+	get death() {
+		return this.parent ? this.parent.death + 1 : 0;
+	}
+	get flatColumns() {
+		let e = [this];
+		return e.push(...this.columns.flatMap((e) => e.flatColumns)), e;
+	}
+	_inlineWidth;
+	get inlineWidth() {
+		if (this.isLeaf) return this.grid.getFlexWidth(this.key) ?? this._inlineWidth;
+		let e = this.visibleColumns.map((e) => e.inlineWidth).filter((e) => typeof e == "number");
+		if (e.length !== 0) return W.sumBy(e, (e) => e);
+	}
+	get startOffset() {
+		let e = 0;
+		if (this.parent) {
+			let { visibleColumns: t, startOffset: n } = this.parent, r = t.findIndex((e) => e === this);
+			e += W.sumBy(t, (e, t) => t < r ? e.inlineWidth ?? 0 : 0), e += n;
+		} else {
+			let t = this.grid.columns.value.start.filter((e) => e.isVisible), n = t.findIndex((e) => e === this);
+			e += W.sumBy(t, (e, t) => t < n ? e.inlineWidth ?? 0 : 0);
+		}
+		return e;
+	}
+	get endOffset() {
+		let e = 0;
+		if (this.parent) {
+			let { visibleColumns: t } = this.parent, n = t.reverse(), r = n.findIndex((e) => e === this);
+			e += W.sumBy(n, (e, t) => t < r ? e.inlineWidth ?? 0 : 0), e += this.parent.endOffset;
+		} else {
+			let t = this.grid.columns.value.end.filter((e) => e.isVisible).reverse(), n = t.findIndex((e) => e === this);
+			e += W.sumBy(t, (e, t) => t < n ? e.inlineWidth ?? 0 : 0);
+		}
+		return e;
+	}
+	get isEdge() {
+		if (!this.pin) return !1;
+		if (this.parent) {
+			let { visibleColumns: e } = this.parent;
+			return (this.pin === "START" ? e.at(-1) : e.at(0)) === this && this.parent.isEdge;
+		}
+		return (this.pin === "START" ? this.grid.columns.value.start.filter((e) => e.isVisible).at(-1) : this.grid.columns.value.end.filter((e) => e.isVisible).at(0)) === this;
+	}
+	get isVisible() {
+		return this.isLeaf ? !this.grid.hiddenColumns.has(this.key) : this.leafs.some((e) => e.isVisible);
+	}
+	get leafs() {
+		return this.isLeaf ? [this] : this.visibleColumns.flatMap((e) => e.leafs);
+	}
+	get groupColumnWidthVarName() {
+		return `--${this.uniqueKey}-group-width`;
+	}
+	get widthVarName() {
+		return `--${this.uniqueKey}-width`;
+	}
+	get inlineStartVarName() {
+		return `--${this.uniqueKey}-inline-start`;
+	}
+	get inlineEndVarName() {
+		return `--${this.uniqueKey}-inline-end`;
+	}
+	get gridRows() {
+		return this.isLeaf ? this.grid.columns.value.maxDeath - this.death : 1;
+	}
+	_resizeStartX = 0;
+	_resizeSizes = {};
+	_resizeTotalWidth = 0;
+	beginResize = (e) => {
+		let { MIN_COLUMN_WIDTH_PX: t } = this.grid;
+		this._resizeStartX = e, this._resizeSizes = W.toRecord(this.leafs, (e) => [e.key, e.inlineWidth ?? e.baseWidth]), this._resizeTotalWidth = W.sumBy(this.leafs, (e) => this._resizeSizes[e.key]) - this.leafs.length * t;
+	};
+	get resizeSign() {
+		return this.pin === "END" === this.grid.isRtl ? 1 : -1;
+	}
+	applyResize = (e) => {
+		let { MIN_COLUMN_WIDTH_PX: t } = this.grid, n = (e - this._resizeStartX) * this.resizeSign;
+		this.leafs.forEach((e) => {
+			let r = this._resizeSizes[e.key], i = this._resizeTotalWidth > 0 ? (r - t) / this._resizeTotalWidth * n : n / this.leafs.length, a = Math.round(r + i);
+			e.setWidth(a < t ? t : a);
+		}), this.grid.flexWidths.clear();
+	};
+	resizeTo = (e) => {
+		this.applyResize(e), this.grid.notify();
+	};
+	endResize = () => {
+		this.grid.notify();
+	};
+	moveResizer = (e) => {
+		this.beginResize(0), this.applyResize(e);
+	};
+	resizeWidthTo = (e) => {
+		let t = this.inlineWidth ?? this.baseWidth;
+		this.moveResizer((e - t) * this.resizeSign);
+	};
+	pinColumn = (e) => {
+		this.isLeaf ? this._pin = jt(e) : this.columns.forEach((t) => t.pinColumn(e)), this.grid.pinColumn(this.uniqueKey, e);
+	};
+	toggleGrouping = () => {
+		this.grid.toggleGrouping(this.key);
+	};
+	sortColumn = (...e) => {
+		this.grid.setSortColumn(this.key, ...e);
+	};
+	setWidth = (e) => {
+		if (!this.isLeaf) throw Error("Cannot set width for a parent column.");
+		this._inlineWidth !== e && (this._inlineWidth = e, this.grid.setWidth(this.key, e));
+	};
+	toggleVisibility = () => {
+		this.grid.toggleColumnVisibility(this.key);
+	};
+}, Pt = class {
+	grid;
+	constructor(e) {
+		this.grid = e;
+	}
+	get entries() {
+		return this.grid.columns.value.leafs.filter((e) => e.isData).map((e) => ({
+			id: String(e.key),
+			label: String(e.header ?? e.key),
+			column: e,
+			visible: e.isVisible
+		}));
+	}
+	get selectedIds() {
+		return this.entries.filter((e) => e.visible).map((e) => e.id);
+	}
+	get total() {
+		return this.entries.length;
+	}
+	get hiddenCount() {
+		return this.entries.reduce((e, t) => t.visible ? e : e + 1, 0);
+	}
+	get hasHidden() {
+		return this.hiddenCount > 0;
+	}
+	setVisibility = (e) => {
+		let t = new Set(e);
+		this.entries.forEach((e) => {
+			let n = t.has(e.id);
+			e.visible !== n && e.column.toggleVisibility();
+		});
+	};
+};
+//#endregion
+//#region src/utils/array/lazyList.ts
+function Ft(e, t) {
+	return new Proxy([], {
+		get(n, r, i) {
+			if (r === "length") return e;
+			let a = Q(r, e);
+			return a === void 0 ? Reflect.get(n, r, i) : t(a);
+		},
+		has(t, n) {
+			return Q(n, e) !== void 0 || Reflect.has(t, n);
+		},
+		getOwnPropertyDescriptor(n, r) {
+			return Q(r, e) === void 0 ? Reflect.getOwnPropertyDescriptor(n, r) : {
+				value: t(Q(r, e)),
+				writable: !0,
+				enumerable: !0,
+				configurable: !0
+			};
+		}
+	});
+}
+function Q(e, t) {
+	if (typeof e != "string") return;
+	let n = Number(e);
+	return Number.isInteger(n) && n >= 0 && n < t ? n : void 0;
+}
+//#endregion
+//#region src/components/dataGrid/models/sourceLevel.ts
+var $ = class e {
+	source;
+	path;
+	parent;
+	parentRowIndex;
+	constructor(e, t, n, r = 0, i) {
+		this.source = e, this.path = t, this.parent = n, this.parentRowIndex = r, this._totalCount = i;
+	}
+	blocks = /* @__PURE__ */ new Map();
+	_totalCount;
+	alive = !0;
+	_reachedEnd = !1;
+	static keyOf(e) {
+		return JSON.stringify(e);
+	}
+	get key() {
+		return e.keyOf(this.path);
+	}
+	get groupKeys() {
+		return this.source.isTree ? [] : this.path;
+	}
+	get treeKeys() {
+		return this.source.isTree ? this.path : [];
+	}
+	get placeholderKey() {
+		return this.depth === 0 ? "rb-placeholder" : `rb-placeholder-${this.key}`;
+	}
+	get depth() {
+		return this.path.length;
+	}
+	get isGroupLevel() {
+		return this.depth < this.source.groupBy.length;
+	}
+	get rowCount() {
+		if (this._totalCount !== void 0) return this._totalCount;
+		let e = 0;
+		return this.blocks.forEach((t, n) => {
+			t.status === "loaded" && (e = Math.max(e, n * this.source.blockSize + t.rows.length));
+		}), this._reachedEnd ? e : e + this.source.blockSize;
+	}
+	get totalCount() {
+		return this._totalCount;
+	}
+	rowAt(e) {
+		let t = this.blocks.get(Math.floor(e / this.source.blockSize));
+		if (!(!t || t.status !== "loaded")) return t.rows[e % this.source.blockSize];
+	}
+	groupCountAt(e) {
+		let t = this.blocks.get(Math.floor(e / this.source.blockSize));
+		return t?.status === "loaded" ? t.counts?.[e % this.source.blockSize] : void 0;
+	}
+	statusAt(e) {
+		return this.blocks.get(Math.floor(e / this.source.blockSize))?.status ?? "missing";
+	}
+	get isLoading() {
+		for (let e of this.blocks.values()) if (e.status === "loading") return !0;
+		return !1;
+	}
+	failedBlocks() {
+		let e = [];
+		return this.blocks.forEach((t, n) => t.status === "error" && e.push(n)), e;
+	}
+	errorAt(e) {
+		return this.blocks.get(e)?.error;
+	}
+	has(e) {
+		return this.blocks.has(e);
+	}
+	loadedBlocks() {
+		let e = [];
+		return this.blocks.forEach((t, n) => t.status === "loaded" && e.push({
+			index: n,
+			rows: t.rows
+		})), e.sort((e, t) => e.index - t.index);
+	}
+	drop(e) {
+		this.blocks.get(e)?.controller?.abort(), this.blocks.delete(e);
+	}
+	dispose() {
+		this.alive = !1, this.blocks.forEach((e) => e.controller?.abort()), this.blocks.clear();
+	}
+	retry() {
+		let e = this.failedBlocks();
+		e.forEach((e) => this.blocks.delete(e)), e.forEach((e) => this.load(e));
+	}
+	load(e) {
+		let t = this.source.config;
+		if (!t) return;
+		let { grid: n } = this.source, r = this.source.blockSize, i = new AbortController(), a = this.source.queryVersion;
+		this.blocks.set(e, {
+			status: "loading",
+			rows: [],
+			controller: i
+		});
+		let o = {
+			startRow: e * r,
+			endRow: (e + 1) * r,
+			page: e + 1,
+			pageSize: r,
+			sort: n.sortColumn !== void 0 && n.sortDirection !== void 0 ? {
+				columnKey: n.sortColumn,
+				direction: n.sortDirection
+			} : void 0,
+			globalFilter: n.globalFilterValue,
+			columnFilters: n.columnFilters,
+			groupBy: this.source.groupBy,
+			groupKeys: this.groupKeys,
+			treeKeys: this.treeKeys,
+			signal: i.signal
+		};
+		t.getRows(o).then((t) => {
+			!this.alive || a !== this.source.queryVersion || i.signal.aborted || (this.blocks.set(e, {
+				status: "loaded",
+				rows: t.rows ?? [],
+				counts: t.groupCounts
+			}), t.totalCount !== void 0 && (this._totalCount = t.totalCount), (t.rows?.length ?? 0) < r && (this._reachedEnd = !0), this.source.changed());
+		}, (t) => {
+			!this.alive || a !== this.source.queryVersion || i.signal.aborted || (this.blocks.set(e, {
+				status: "error",
+				rows: [],
+				error: t
+			}), this.source.changed());
+		});
+	}
+}, It = class extends Fe {
+	level;
+	constructor(e, t, n, r) {
+		super(e, n, [], r, ""), this.level = t;
+	}
+	get row() {
+		return this.level.rowAt(this.rowIndex);
+	}
+	get data() {
+		return this.row;
+	}
+	get placeholder() {
+		return this.row === void 0;
+	}
+	get groupValue() {
+		let e = this.row;
+		return e == null ? "" : e[this.groupColumn.key];
+	}
+	get groupKeys() {
+		return [...this.level.groupKeys, this.groupValue];
+	}
+	get key() {
+		return this.placeholder ? `${this.level.placeholderKey}-group-${this.rowIndex}` : Lt(this.groupKeys);
+	}
+	get depth() {
+		return this.level.depth;
+	}
+	get count() {
+		return this.level.groupCountAt(this.rowIndex) ?? 0;
+	}
+	get label() {
+		if (this.placeholder) return "";
+		let e = this.level.groupCountAt(this.rowIndex);
+		return e === void 0 ? `${this.groupValue}` : `${this.groupValue} (${e})`;
+	}
+	aggregateValue(e) {
+		let t = this.row?.[e.key];
+		return typeof t == "number" || typeof t == "string" ? t : void 0;
+	}
+	get selectable() {
+		return !1;
+	}
+	get selected() {
+		return !1;
+	}
+	get indeterminate() {
+		return !1;
+	}
+	get expanded() {
+		return !this.placeholder && this.grid.expandedGroupRow.has(this.key);
+	}
+	get allRows() {
+		return [];
+	}
+	toggleRow() {
+		this.placeholder || this.grid.toggleGroupRow(this.key);
+	}
+};
+function Lt(e) {
+	return `rb-group:${$.keyOf(e)}`;
+}
+//#endregion
+//#region src/components/dataGrid/models/sourceRowModel.ts
+var Rt = {}, zt = class extends H {
+	sourceLevel;
+	constructor(e, t, n) {
+		super(e, Rt, n), this.sourceLevel = t;
+	}
+	get row() {
+		return this.sourceLevel.rowAt(this.rowIndex);
+	}
+	get data() {
+		return this.row ?? Rt;
+	}
+	get placeholder() {
+		return this.row === void 0;
+	}
+	get key() {
+		let e = this.row;
+		return e === void 0 ? `${this.sourceLevel.placeholderKey}-${this.rowIndex}` : this.grid.getRowKey(e);
+	}
+	get expandOnRowClick() {
+		return !this.placeholder && super.expandOnRowClick;
+	}
+	get expanded() {
+		return !this.placeholder && super.expanded;
+	}
+	get selected() {
+		return !this.placeholder && super.selected;
+	}
+}, Bt = class extends zt {
+	isTreeRow = !0;
+	get level() {
+		return this.sourceLevel.depth;
+	}
+	get position() {
+		return this.rowIndex;
+	}
+	get siblings() {
+		return this.sourceLevel.totalCount ?? -1;
+	}
+	get hasChildren() {
+		return !this.placeholder && this.grid.tree.rowHasChildren(this.data);
+	}
+	get treeExpanded() {
+		return this.hasChildren && this.grid.tree.isExpanded(this.key, this.level);
+	}
+	toggleTree = () => {
+		this.hasChildren && this.grid.tree.toggle(this.key, this.level);
+	};
+}, Vt = 100, Ht = 40, Ut = class {
+	grid;
+	constructor(e) {
+		this.grid = e;
+	}
+	root = new $(this, []);
+	levels = /* @__PURE__ */ new Map([[this.root.key, this.root]]);
+	recent = [];
+	_query = 0;
+	get config() {
+		return this.grid.props.def.dataSource;
+	}
+	get enabled() {
+		return !!this.config;
+	}
+	get canGroup() {
+		return !!this.config?.grouping && !this.isTree;
+	}
+	get isTree() {
+		return this.enabled && !!this.grid.props.def.treeData;
+	}
+	get groupBy() {
+		return this.canGroup ? [...this.grid.groupColumns] : [];
+	}
+	get blockSize() {
+		let e = this.config?.blockSize;
+		return e && e > 0 ? Math.floor(e) : this.grid.isPaginated ? this.grid.pageSize : Vt;
+	}
+	get maxBlocks() {
+		let e = this.config?.maxBlocks;
+		return e && e > 0 ? Math.floor(e) : Ht;
+	}
+	get queryVersion() {
+		return this._query;
+	}
+	get totalCount() {
+		return this.root.totalCount;
+	}
+	get isLoading() {
+		for (let e of this.levels.values()) if (e.isLoading) return !0;
+		return !1;
+	}
+	get error() {
+		for (let e of this.levels.values()) {
+			let t = e.failedBlocks();
+			if (t.length > 0) return e.errorAt(t[0]);
+		}
+	}
+	_segments;
+	_byLevel;
+	segments() {
+		if (this._segments) return this._segments;
+		let e = [], t = /* @__PURE__ */ new Set(), n = 0, r = (t, r, i) => {
+			i <= 0 || (e.push({
+				start: n,
+				levelStart: r,
+				length: i,
+				level: t
+			}), n += i);
+		}, i = (e) => {
+			t.add(e.key);
+			let n = 0;
+			for (let { rowIndex: t, child: a } of this.expansionsOf(e)) t < n || t >= e.rowCount || (r(e, n, t - n + 1), n = t + 1, i(a));
+			r(e, n, e.rowCount - n);
+		};
+		return i(this.root), this.levels.forEach((e, n) => {
+			t.has(n) || (e.dispose(), this.levels.delete(n));
+		}), this._segments = e, e;
+	}
+	byLevel() {
+		if (this._byLevel) return this._byLevel;
+		let e = /* @__PURE__ */ new Map();
+		return this.segments().forEach((t) => {
+			let n = t.level.key, r = e.get(n);
+			r ? r.push(t) : e.set(n, [t]);
+		}), this._byLevel = e;
+	}
+	expansionsOf(e) {
+		if (this.isTree) return this.treeExpansionsOf(e);
+		let t = this.grid.expandedGroupRow;
+		if (!e.isGroupLevel || t.size === 0) return [];
+		let n = this.blockSize, r = this.groupBy[e.depth], i = [];
+		return e.loadedBlocks().forEach(({ index: a, rows: o }) => {
+			o.forEach((o, s) => {
+				let c = [...e.path, o[r]];
+				if (!t.has(Lt(c))) return;
+				let l = a * n + s;
+				i.push({
+					rowIndex: l,
+					child: this.levelFor(c, e, l)
+				});
+			});
+		}), i.sort((e, t) => e.rowIndex - t.rowIndex);
+	}
+	treeExpansionsOf(e) {
+		let { tree: t } = this.grid;
+		if (!t.mayExpand) return [];
+		let n = this.blockSize, r = [];
+		return e.loadedBlocks().forEach(({ index: i, rows: a }) => {
+			a.forEach((a, o) => {
+				if (!t.rowHasChildren(a)) return;
+				let s = this.grid.getRowKey(a);
+				if (!t.isExpanded(s, e.depth)) return;
+				let c = i * n + o;
+				r.push({
+					rowIndex: c,
+					child: this.levelFor([...e.path, s], e, c)
+				});
+			});
+		}), r.sort((e, t) => e.rowIndex - t.rowIndex);
+	}
+	openTreeKeys() {
+		if (!this.isTree) return [];
+		this.segments();
+		let e = [];
+		return this.levels.forEach((t) => t.depth > 0 && e.push(t.path[t.depth - 1])), e;
+	}
+	levelFor(e, t, n) {
+		let r = $.keyOf(e), i = this.levels.get(r);
+		return i ? i.parentRowIndex = n : this.levels.set(r, i = new $(this, e, t, n)), i;
+	}
+	segmentAt(e) {
+		let t = this.segments(), n = 0, r = t.length - 1;
+		for (; n < r;) {
+			let i = n + r + 1 >>> 1;
+			t[i].start <= e ? n = i : r = i - 1;
+		}
+		let i = t[n];
+		return i && e >= i.start && e < i.start + i.length ? i : void 0;
+	}
+	get rowCount() {
+		if (!this.enabled) return 0;
+		let e = this.segments(), t = e[e.length - 1];
+		return t ? t.start + t.length : 0;
+	}
+	models = /* @__PURE__ */ new Map();
+	listLength = -1;
+	rowList() {
+		let { start: e } = this.visibleRange();
+		return this.listLength = this.visibleLength(), Ft(this.listLength, (t) => this.rowModelAt(e + t));
+	}
+	flatRowList(e) {
+		let t = this.detailPositions();
+		return t.length === 0 ? e : Ft(e.length + t.length, (n) => {
+			let r = Gt(t, n);
+			return t[r] === n ? new V(this.grid, e[n - r - 1]) : e[n - r];
+		});
+	}
+	rowOffsets(e) {
+		let { rowHeight: t } = this.grid, n = this.detailPositions(), r = [0];
+		return n.forEach((t, n) => r.push(r[n] + e[t].heightForOffset)), {
+			offsets: Ft(e.length, (e) => {
+				let i = Gt(n, e);
+				return (e - i) * t + r[i];
+			}),
+			totalHeight: (e.length - n.length) * t + r[n.length]
+		};
+	}
+	detailPositions() {
+		let e = this.grid.expandedDetailRows;
+		if (!this.grid.props.def.rowDetail || e.size === 0) return [];
+		let { start: t, end: n } = this.visibleRange(), r = [];
+		return this.eachLoadedLeafRow((i, a) => {
+			i >= t && i < n && e.has(this.grid.getRowKey(a)) && r.push(i);
+		}), r.sort((e, t) => e - t), r.map((e, n) => e - t + n + 1);
+	}
+	loadedRows() {
+		let { start: e, end: t } = this.visibleRange(), n = [];
+		return this.eachLoadedLeafRow((r, i) => {
+			r >= e && r < t && n.push({
+				display: r,
+				row: i
+			});
+		}), n.sort((e, t) => e.display - t.display).map((e) => e.row);
+	}
+	eachLoadedLeafRow(e) {
+		let t = this.blockSize;
+		this.byLevel().forEach((n, r) => {
+			let i = this.levels.get(r);
+			!i || i.isGroupLevel || i.loadedBlocks().forEach(({ index: r, rows: i }) => {
+				i.forEach((i, a) => {
+					let o = Wt(n, r * t + a);
+					o !== void 0 && e(o, i);
+				});
+			});
+		});
+	}
+	rowModelAt(e) {
+		let t = this.segmentAt(e);
+		if (!t) return new zt(this.grid, this.root, e);
+		let { level: n } = t, r = t.levelStart + (e - t.start), i = this.models.get(n.key);
+		i || this.models.set(n.key, i = /* @__PURE__ */ new Map());
+		let a = i.get(r);
+		return a || (a = n.isGroupLevel ? new It(this.grid, n, this.groupColumnAt(n.depth), r) : this.isTree ? new Bt(this.grid, n, r) : new zt(this.grid, n, r), i.set(r, a)), a;
+	}
+	groupColumnAt(e) {
+		return W.findOrThrow(this.grid.columns.value.leafs, (t) => t.key === this.groupBy[e]);
+	}
+	visibleLength() {
+		let { start: e, end: t } = this.visibleRange();
+		return Math.max(0, t - e);
+	}
+	visibleRange() {
+		if (!this.grid.isPaginated) return {
+			start: 0,
+			end: this.rowCount
+		};
+		let { pageSize: e } = this.grid, t = (this.grid.page - 1) * e;
+		return {
+			start: t,
+			end: Math.min(t + e, Math.max(this.rowCount, t))
+		};
+	}
+	rowAt(e) {
+		let t = this.segmentAt(e);
+		return t?.level.rowAt(t.levelStart + (e - t.start));
+	}
+	statusAt(e) {
+		let t = this.segmentAt(e);
+		return t ? t.level.statusAt(t.levelStart + (e - t.start)) : "missing";
+	}
+	request(e, t) {
+		if (!this.enabled) return;
+		let n = this.grid.isPaginated ? this.visibleRange() : {
+			start: e,
+			end: t
+		}, r = {
+			start: n.start,
+			end: Math.max(n.end, n.start + 1)
+		}, i = this.blockSize, a = !1;
+		for (let e of this.segments()) {
+			let t = Math.max(r.start, e.start), n = Math.min(r.end, e.start + e.length);
+			if (n <= t) continue;
+			let o = Math.floor((e.levelStart + (t - e.start)) / i), s = Math.floor((e.levelStart + (n - 1 - e.start)) / i);
+			for (let t = o; t <= s; t++) this.touch(e.level, t), !e.level.has(t) && (e.level.load(t), a = !0);
+		}
+		this.evict(), a && this.changed();
+	}
+	expansionChanged() {
+		this._segments = void 0, this._byLevel = void 0;
+	}
+	retry = () => {
+		let e = !1;
+		this.levels.forEach((t) => {
+			t.failedBlocks().length !== 0 && (t.retry(), e = !0);
+		}), e && this.changed();
+	};
+	invalidate() {
+		if (!this.enabled) return;
+		this._query++;
+		let e = this.root.totalCount;
+		this.levels.forEach((e) => e.dispose()), this.root = new $(this, [], void 0, 0, e), this.levels = /* @__PURE__ */ new Map([[this.root.key, this.root]]), this.recent = [], this.models.clear(), this.changed();
+	}
+	touch(e, t) {
+		this.bump(e.key, t);
+		for (let t = e.parent, n = e.parentRowIndex; t; n = t.parentRowIndex, t = t.parent) this.bump(t.key, Math.floor(n / this.blockSize));
+	}
+	bump(e, t) {
+		let n = this.recent.findIndex((n) => n.level === e && n.index === t);
+		n !== -1 && this.recent.splice(n, 1), this.recent.push({
+			level: e,
+			index: t
+		});
+	}
+	evict() {
+		for (; this.recent.length > this.maxBlocks;) {
+			let e = this.recent.shift();
+			this.levels.get(e.level)?.drop(e.index);
+		}
+		let e = this.blockSize;
+		this.models.forEach((t, n) => {
+			let r = this.levels.get(n);
+			if (!r) return this.models.delete(n);
+			t.forEach((n, i) => {
+				r.has(Math.floor(i / e)) || t.delete(i);
+			});
+		});
+	}
+	changed() {
+		this._segments = void 0, this._byLevel = void 0, this.listLength !== this.visibleLength() && this.grid.rows.clear(), this.grid.flatRows.clear(), this.grid.notify();
+	}
+};
+function Wt(e, t) {
+	for (let n of e) if (t >= n.levelStart && t < n.levelStart + n.length) return n.start + (t - n.levelStart);
+}
+function Gt(e, t) {
+	let n = 0, r = e.length;
+	for (; n < r;) {
+		let i = n + r >>> 1;
+		e[i] < t ? n = i + 1 : r = i;
+	}
+	return n;
+}
+//#endregion
+//#region src/components/dataGrid/models/exportModel.ts
+var Kt = 7, qt = class {
+	grid;
+	constructor(e) {
+		this.grid = e;
+	}
+	columns(e) {
+		let t = this.grid.columns.value.leafs.filter((e) => e.isData && (e.isVisible || this.grid.groupColumns.has(e.key)));
+		return e ? e.map((e) => t.find((t) => t.key === e)).filter((e) => !!e) : t;
+	}
+	header(e) {
+		return e.header ?? String(e.key);
+	}
+	width(e) {
+		let t = e.inlineWidth ?? this.grid.DEFAULT_COLUMN_WIDTH_PX;
+		return Math.min(80, Math.max(6, Math.round(t / Kt * 10) / 10));
+	}
+	value(e, t) {
+		let { exportValue: n } = e.def, r = n ? n(t) : t[e.key];
+		return this.grid.edits.edits.length ? this.grid.edits.valueOf(this.grid.getRowKey(t), e.key, r) : r;
+	}
+	aggregateOf(e, t) {
+		let n = e.aggregate;
+		return n ? je(n, t.map((t) => this.value(e, t)), t) : null;
+	}
+	table(e = {}) {
+		let t = this.columns(e.columns), n = e.groups ?? !0, r = [], i = (e, a, o) => {
+			for (let s of e) if (s.kind === "group") {
+				let e = !s.expanded, c = s.allRows.map((e) => e.data);
+				n && r.push({
+					kind: "group",
+					level: a,
+					hidden: o,
+					collapsed: e,
+					values: t.map((e) => e.key === s.groupColumn.key ? s.groupValue : this.aggregateOf(e, c))
+				}), i(s.rows, n ? a + 1 : a, o || n && e);
+			} else {
+				if (s.placeholder) continue;
+				let e = U(s) ? s.level : a;
+				r.push({
+					kind: "data",
+					level: e,
+					hidden: o,
+					collapsed: !1,
+					values: t.map((e) => this.value(e, s.data))
+				});
+			}
+		};
+		return this.grid.tree.isEager ? this.walkTree(r, t) : i(this.grid.rows.value, 0, !1), (e.footer ?? this.grid.aggregation.hasFooter) && r.push(this.footerRow(t)), {
+			columns: t.map((e) => ({
+				key: e.key,
+				header: this.header(e),
+				width: this.width(e),
+				format: e.def.exportFormat
+			})),
+			rows: r
+		};
+	}
+	walkTree(e, t) {
+		let { tree: n } = this.grid, r = (i, a, o) => {
+			i.forEach((i) => {
+				let s = i.children.length > 0 && !n.isExpanded(this.grid.getRowKey(i.data), a);
+				e.push({
+					kind: "data",
+					level: a,
+					hidden: o,
+					collapsed: s,
+					values: t.map((e) => this.value(e, i.data))
+				}), r(i.children, a + 1, o || s);
+			});
+		};
+		r(n.nodes.value, 0, !1);
+	}
+	footerRow(e) {
+		let t = this.grid.filteredData, n = this.grid.aggregation.footerLabel, r = e.find((e) => !e.aggregate);
+		return {
+			kind: "footer",
+			level: 0,
+			hidden: !1,
+			collapsed: !1,
+			values: e.map((e) => e.aggregate ? this.aggregateOf(e, t) : e === r && (typeof n == "string" || typeof n == "number") ? n : null)
+		};
+	}
+	fileName(e = {}) {
+		let { title: t } = this.grid.props.def, n = typeof t == "string" && t.trim() ? t.trim() : "export";
+		return e.fileName?.trim() || n;
+	}
+}, Jt = class {
+	grid;
+	constructor(e) {
+		this.grid = e;
+	}
+	get globalFilterValue() {
+		return this.grid.globalFilterValue;
+	}
+	get columnFilters() {
+		return this.grid.columnFilters;
+	}
+	get hasActiveFilters() {
+		return this.grid.hasActiveFilters;
+	}
+	get filterStats() {
+		return this.grid.filterStats;
+	}
+	get hasFilterableColumns() {
+		return this.grid.columns.value.visibleLeafs.some((e) => !!e.filterable);
+	}
+	setGlobalFilter = (e) => this.grid.setGlobalFilter(e);
+	clearAllFilters = () => this.grid.clearAllFilters();
+}, Yt = class {
+	grid;
+	constructor(e) {
+		this.grid = e;
+	}
+	get isPaginated() {
+		return this.grid.isPaginated;
+	}
+	get state() {
+		return this.grid.paginationState;
+	}
+	get pageSizeOptions() {
+		return this.grid.pageSizeOptions;
+	}
+	get page() {
+		return this.grid.page;
+	}
+	get pageSize() {
+		return this.grid.pageSize;
+	}
+	get totalPages() {
+		return this.state?.totalPages ?? 1;
+	}
+	get totalItems() {
+		return this.state?.totalItems ?? 0;
+	}
+	get canGoPrev() {
+		return this.page > 1;
+	}
+	get canGoNext() {
+		return this.page < this.totalPages;
+	}
+	get startItem() {
+		return (this.page - 1) * this.pageSize + 1;
+	}
+	get endItem() {
+		return Math.min(this.startItem + this.pageSize - 1, this.totalItems);
+	}
+	changePage = (e) => this.grid.changePage(e);
+	changePageSize = (e) => this.grid.changePageSize(e);
+	firstPage = () => {
+		this.canGoPrev && this.grid.changePage(1);
+	};
+	prevPage = () => {
+		this.canGoPrev && this.grid.changePage(this.page - 1);
+	};
+	nextPage = () => {
+		this.canGoNext && this.grid.changePage(this.page + 1);
+	};
+	lastPage = () => {
+		this.canGoNext && this.grid.changePage(this.totalPages);
+	};
+	jumpToPage = (e) => {
+		let t = parseInt(e, 10);
+		isNaN(t) || this.grid.changePage(Math.max(1, Math.min(t, this.totalPages)));
+	};
+}, Xt = class extends H {
+	node;
+	level;
+	position;
+	siblings;
+	treeParent;
+	isTreeRow = !0;
+	constructor(e, t, n, r, i, a, o) {
+		super(e, t.data, n), this.node = t, this.level = r, this.position = i, this.siblings = a, this.treeParent = o;
+	}
+	children = [];
+	get hasChildren() {
+		return this.node.children.length > 0;
+	}
+	get treeExpanded() {
+		return this.hasChildren && this.grid.tree.isExpanded(this.key, this.level);
+	}
+	toggleTree = () => {
+		this.grid.tree.toggle(this.key, this.level);
+	};
+	_subtreeKeys = B(() => {
+		let e = [], t = (n) => {
+			n.forEach((n) => {
+				e.push(this.grid.getRowKey(n.data)), t(n.children);
+			});
+		};
+		return e.push(this.key), t(this.node.children), e;
+	});
+	get subtreeKeys() {
+		return this._subtreeKeys.value;
+	}
+	get selected() {
+		return this.grid.tree.cascades ? this.subtreeKeys.every((e) => this.grid.selectedRows.has(e)) : super.selected;
+	}
+	get indeterminate() {
+		return this.grid.tree.cascades ? !this.selected && this.subtreeKeys.some((e) => this.grid.selectedRows.has(e)) : !1;
+	}
+	toggleSelection = () => {
+		if (!this.grid.tree.cascades) {
+			this.grid.toggleRowSelection(this.key);
+			return;
+		}
+		this.grid.toggleRowsSelection(this.subtreeKeys);
+	};
+	get flatRows() {
+		let e = super.flatRows;
+		return this.children.length === 0 ? e : [...e, ...this.children.flatMap((e) => e.flatRows)];
+	}
+};
+//#endregion
+//#region src/components/dataGrid/models/treeModel.ts
+function Zt(e) {
+	return JSON.stringify(e);
+}
+var Qt = class {
+	grid;
+	constructor(e) {
+		this.grid = e;
+	}
+	get config() {
+		return this.grid.props.def.treeData;
+	}
+	get enabled() {
+		return !!this.config;
+	}
+	get isEager() {
+		return this.enabled && !this.grid.source.enabled;
+	}
+	get isLazy() {
+		return this.enabled && this.grid.source.enabled;
+	}
+	rowHasChildren(e) {
+		let { hasChildren: t } = this.config ?? {};
+		return typeof t == "function" ? !!t(e) : t ? !!e[t] : !1;
+	}
+	get columnKey() {
+		if (this.enabled) return this.config?.column ?? this.grid.columns.value.userVisibleLeafs[0]?.key;
+	}
+	get indent() {
+		return this.config?.indent ?? 4;
+	}
+	get cascades() {
+		return this.config?.selection === "cascade" && !this.isLazy;
+	}
+	get isFlat() {
+		return !!(this.config?.getPath || this.config?.pathKey);
+	}
+	childrenOf(e) {
+		let { getChildren: t, childrenKey: n } = this.config ?? {};
+		return t ? t(e) ?? [] : n ? e[n] ?? [] : [];
+	}
+	pathOf(e) {
+		let { getPath: t, pathKey: n } = this.config ?? {};
+		return t ? t(e) ?? [] : n ? e[n] ?? [] : [];
+	}
+	buildNested(e) {
+		return e.map((e) => ({
+			data: e,
+			children: this.buildNested(this.childrenOf(e))
+		}));
+	}
+	buildFlat(e) {
+		let t = [], n = /* @__PURE__ */ new Map();
+		return [...e].sort((e, t) => this.pathOf(e).length - this.pathOf(t).length).forEach((e) => {
+			let r = this.pathOf(e), i = {
+				data: e,
+				children: []
+			};
+			n.set(Zt(r), i);
+			let a;
+			for (let e = r.length - 1; e > 0 && !a; e--) a = n.get(Zt(r.slice(0, e)));
+			(a ? a.children : t).push(i);
+		}), t;
+	}
+	prune(e) {
+		let t = [];
+		return e.forEach((e) => {
+			let n = this.prune(e.children);
+			(n.length > 0 || this.grid.rowMatchesFilters(e.data)) && t.push({
+				data: e.data,
+				children: n
+			});
+		}), t;
+	}
+	sortNodes(e) {
+		let { sortColumn: t, sortDirection: n } = this.grid;
+		return t === void 0 ? e : W.sortBy(e, (e) => e.data[t], n).map((e) => ({
+			data: e.data,
+			children: this.sortNodes(e.children)
+		}));
+	}
+	nodes = B(() => {
+		if (!this.isEager) return [];
+		let e = this.isFlat ? this.buildFlat(this.grid.data) : this.buildNested(this.grid.data);
+		return this.sortNodes(this.grid.hasRowFilters ? this.prune(e) : e);
+	});
+	allRows = B(() => {
+		let e = [], t = (n) => {
+			n.forEach((n) => {
+				e.push(n.data), t(n.children);
+			});
+		};
+		return t(this.nodes.value), e;
+	}, () => [this.nodes]);
+	everyRow() {
+		if (!this.isEager) return [];
+		if (this.isFlat) return this.grid.data;
+		let e = [], t = (n) => {
+			n.forEach((n) => {
+				e.push(n), t(this.childrenOf(n));
+			});
+		};
+		return t(this.grid.data), e;
+	}
+	rowList() {
+		let e = 0, t = (n, r, i) => n.map((a, o) => {
+			let s = new Xt(this.grid, a, e++, r, o, n.length, i);
+			return s.treeExpanded && (s.children = t(a.children, r + 1, s)), s;
+		});
+		return t(this.nodes.value, 0);
+	}
+	_opened = /* @__PURE__ */ new Set();
+	_closed = /* @__PURE__ */ new Set();
+	_cachedKeys;
+	keySet(e) {
+		return this._cachedKeys?.source !== e && (this._cachedKeys = {
+			source: e,
+			set: new Set(e)
+		}), this._cachedKeys.set;
+	}
+	defaultExpanded(e, t) {
+		let n = this.config?.defaultExpanded;
+		return Array.isArray(n) ? this.keySet(n).has(e) : typeof n == "number" ? t < n : n === !0;
+	}
+	get mayExpand() {
+		if (this.grid.props.expandedTreeKeys || this._opened.size > 0) return !0;
+		let e = this.config?.defaultExpanded;
+		return Array.isArray(e) ? e.length > 0 : e === !0 || typeof e == "number" && e > 0;
+	}
+	isExpanded(e, t) {
+		let n = this.grid.props.expandedTreeKeys;
+		return n ? this.keySet(n).has(e) : this._opened.has(e) ? !0 : !this._closed.has(e) && this.defaultExpanded(e, t);
+	}
+	expandedKeys() {
+		if (this.isLazy) return this.grid.source.openTreeKeys();
+		let e = [], t = (n, r) => {
+			n.forEach((n) => {
+				if (n.children.length === 0) return;
+				let i = this.grid.getRowKey(n.data);
+				this.isExpanded(i, r) && (e.push(i), t(n.children, r + 1));
+			});
+		};
+		return t(this.nodes.value, 0), e;
+	}
+	toggle = (e, t) => {
+		let n = !this.isExpanded(e, t);
+		n ? (this._opened.add(e), this._closed.delete(e)) : (this._closed.add(e), this._opened.delete(e)), this.grid.treeExpansionChanged(), this.grid.props.onExpandedTreeKeysChange?.(this.expandedKeys(), { reason: n ? "expand" : "collapse" }), this.grid.notify();
+	};
+}, $t = class e {
+	grid;
+	static DEFAULT_VISIBLE_ROWS_COUNT = 10;
+	static ROWS_TO_PRELOAD = 20;
+	constructor(e) {
+		this.grid = e;
+	}
+	get showAll() {
+		return this.grid.props.def.visibleRowsCount === "all";
+	}
+	get hasDetailRows() {
+		return !!this.grid.props.def.rowDetail;
+	}
+	get isEmpty() {
+		return this.grid.source.enabled ? this.grid.flatRows.value.length === 0 : this.grid.data.length === 0;
+	}
+	get visibleRowsCount() {
+		if (this.showAll) return this.grid.flatRows.value.length;
+		let t = this.grid.props.def.visibleRowsCount;
+		return typeof t == "number" ? t : e.DEFAULT_VISIBLE_ROWS_COUNT;
+	}
+	get pageRows() {
+		let t = this.grid.props.def.visibleRowsCount;
+		return typeof t == "number" ? t : e.DEFAULT_VISIBLE_ROWS_COUNT;
+	}
+	get viewHeight() {
+		if (this.showAll) return;
+		let { rowHeight: e } = this.grid;
+		return e * this.visibleRowsCount + e / 5;
+	}
+	get totalHeight() {
+		return this.hasDetailRows ? this.grid.rowOffsets.value.totalHeight : this.grid.flatRows.value.length * this.grid.rowHeight;
+	}
+	get emptyHeight() {
+		return this.viewHeight ?? this.grid.rowHeight * e.DEFAULT_VISIBLE_ROWS_COUNT;
+	}
+	rowTop(e) {
+		return this.hasDetailRows ? this.grid.rowOffsets.value.offsets[e] ?? 0 : e * this.grid.rowHeight;
+	}
+	findStartIndex(e, t) {
+		let n = 0, r = e.length - 1;
+		for (; n < r;) {
+			let i = n + r + 1 >>> 1;
+			e[i] <= t ? n = i : r = i - 1;
+		}
+		return n;
+	}
+	window(t) {
+		let n = this.grid.flatRows.value.length;
+		if (this.showAll) return {
+			startIndex: 0,
+			take: n,
+			translateY: 0,
+			totalHeight: this.totalHeight,
+			viewHeight: void 0
+		};
+		let { rowHeight: r } = this.grid, i = e.ROWS_TO_PRELOAD, { offsets: a } = this.grid.rowOffsets.value, o = this.hasDetailRows ? Math.max(0, this.findStartIndex(a, t) - i) : Math.max(0, Math.floor(t / r) - i), s = this.hasDetailRows ? a[o] ?? 0 : o * r;
+		return {
+			startIndex: o,
+			take: this.visibleRowsCount + i * 2,
+			translateY: s,
+			totalHeight: this.totalHeight,
+			viewHeight: this.viewHeight
+		};
+	}
+}, en = {}, tn = class {
+	props;
+	constructor(e, t) {
+		this.props = e, t && this.listeners.add(t);
+	}
+	_version = 0;
+	listeners = /* @__PURE__ */ new Set();
+	subscribe = (e) => (this.listeners.add(e), () => this.listeners.delete(e));
+	getSnapshot = () => this._version;
+	notify = () => {
+		this._version++, this.listeners.forEach((e) => e());
+	};
+	setProps(e) {
+		let t = this.props;
+		t !== e && (this.props = e, t.def !== e.def && this.sourceColumns.clear(), (t.data !== e.data || t.def !== e.def || t.globalFilterValue !== e.globalFilterValue || t.columnFilters !== e.columnFilters || t.filters !== e.filters || t.expandedRowKeys !== e.expandedRowKeys || t.expandedTreeKeys !== e.expandedTreeKeys || t.page !== e.page || t.pageSize !== e.pageSize) && this.rows.clear(), (t.data !== e.data || t.def !== e.def || t.globalFilterValue !== e.globalFilterValue || t.columnFilters !== e.columnFilters || t.filters !== e.filters) && this.tree.nodes.clear());
+	}
+	get data() {
+		return this.props.data ?? [];
+	}
+	get loadedRows() {
+		return this.source.enabled ? this.source.loadedRows() : this.tree.isEager ? this.tree.allRows.value : this.data;
+	}
+	get componentName() {
+		return this.props.component || "datagrid";
+	}
+	_identifier = "datagrid";
+	get identifier() {
+		return this._identifier;
+	}
+	setIdentifier(e) {
+		this._identifier = e;
+	}
+	get titleId() {
+		return `${this._identifier}-title`;
+	}
+	get resizerStyle() {
+		return this.props.def.resizerStyle ?? "visible";
+	}
+	get resizeMode() {
+		return this.props.def.resizeMode ?? "smooth";
+	}
+	sourceColumns = B(() => {
+		let { def: e } = this.props, t = [];
+		if (this.groupColumns.size > 0 && t.push(new Z({ key: G }, this)), t.push(...e.columns.map((e) => new Z(e, this))), e.rowSelection) {
+			let n = typeof e.rowSelection == "object" && e.rowSelection.pinned ? "START" : void 0;
+			t.unshift(new Z({
+				key: Ee,
+				pin: n,
+				width: 50,
+				align: "center",
+				Cell: At
+			}, this));
+		}
+		if (e.showRowNumber) {
+			let n, r = 70;
+			typeof e.showRowNumber == "object" && (e.showRowNumber.pinned && (n = "START"), r = e.showRowNumber.width ?? 70), t.unshift(new Z({
+				key: Te,
+				pin: n,
+				width: r,
+				align: "end"
+			}, this));
+		}
+		if (e.rowDetail) {
+			let n = e.rowDetail.pinned ? "START" : void 0, r = e.rowDetail.expandColumnWidth ?? 50, i = e.rowDetail.expandColumnHeader ?? "";
+			t.unshift(new Z({
+				key: De,
+				header: i,
+				pin: n,
+				width: r,
+				align: "center",
+				Cell: kt
+			}, this));
+		}
+		return t;
+	});
+	columns = B(() => {
+		let e = this.sourceColumns.value.map((e) => e.getPinnedColumn("START")).filter((e) => !!e), t = this.sourceColumns.value.map((e) => e.getPinnedColumn()).filter((e) => !!e), n = this.sourceColumns.value.map((e) => e.getPinnedColumn("END")).filter((e) => !!e), r = [
+			...e,
+			...t,
+			...n
+		].flatMap((e) => e.flatColumns), i = r.filter((e) => e.isLeaf), a = r.filter((e) => e.isLeaf && e.isVisible);
+		return {
+			start: e,
+			middle: t,
+			end: n,
+			flat: r,
+			leafs: i,
+			visibleLeafs: a,
+			userVisibleLeafs: a.filter((e) => ![
+				Te,
+				Ee,
+				G,
+				De
+			].includes(e.key)),
+			maxDeath: W.maxBy(r, (e) => e.death) + 1
+		};
+	}, () => [this.sourceColumns]);
+	headerRows = B(() => W.sortBy(W.groupBy(this.columns.value.flat, (e) => e.death), (e) => e.key).map((e) => {
+		let t = W.toRecord(W.groupBy(e.values, (e) => e.pin ?? "NO_PIN"), (e) => [e.key, e.values]);
+		return [
+			...t.START?.filter((e) => e.isVisible) ?? [],
+			...t.NO_PIN?.filter((e) => e.isVisible) ?? [],
+			...t.END?.filter((e) => e.isVisible) ?? []
+		];
+	}), () => [this.columns]);
+	gridTemplateColumns = B(() => {
+		let { visibleLeafs: e } = this.columns.value, t = W.sumBy(e, (e) => +(e.pin === "END")), n = e.length - t;
+		return `${n > 0 ? `repeat(${n}, max-content)` : ""} ${t > 0 ? `repeat(${t}, max-content)` : ""}`.trim();
+	}, () => [this.columns]);
+	_globalFilterValue = "";
+	get globalFilterValue() {
+		return this.props.globalFilterValue ?? this._globalFilterValue;
+	}
+	_columnFilters = {};
+	get columnFilters() {
+		return this.props.columnFilters ?? this._columnFilters;
+	}
+	globalFilterColumns = B(() => this.props.def.globalFilterKeys ?? this.columns.value.leafs.filter((e) => e.key !== "row-number-cell" && e.key !== "row-selection-cell" && e.key !== "grouping-cell" && e.key !== "row-detail-cell").map((e) => e.key), () => [this.columns]);
+	rowMatchesFilters(e) {
+		let { filters: t } = this.props;
+		return t && !t.every((t) => t(e)) || this.props.def.globalFilter && !this.matchesGlobalFilter(e) ? !1 : this.matchesColumnFilters(e);
+	}
+	get hasRowFilters() {
+		return (this.props.filters?.length ?? 0) > 0 || !!this.props.def.globalFilter && this.globalFilterValue.trim() !== "" || Object.keys(this.columnFilters).length > 0;
+	}
+	matchesGlobalFilter(e) {
+		let t = this.globalFilterValue.trim();
+		return !t || this.globalFilterColumns.value.some((n) => {
+			let r = e[n];
+			return r != null && Ot(t, String(r));
+		});
+	}
+	matchesColumnFilters(e) {
+		let t = this.columnFilters;
+		return Object.keys(t).every((n) => {
+			let r = t[n];
+			return !r || this.matchesFilter(e[n], r);
+		});
+	}
+	matchesFilter(e, t) {
+		switch (t.type) {
+			case "text": return !t.value.trim() || e != null && Ot(t.value, String(e));
+			case "number": {
+				if (e == null) return !1;
+				let n = typeof e == "number" ? e : parseFloat(String(e));
+				if (isNaN(n)) return !1;
+				switch (t.operator) {
+					case "eq": return n === t.value;
+					case "ne": return n !== t.value;
+					case "gt": return n > t.value;
+					case "gte": return n >= t.value;
+					case "lt": return n < t.value;
+					case "lte": return n <= t.value;
+					case "between": return t.valueTo === void 0 ? n >= t.value : n >= t.value && n <= t.valueTo;
+					default: return !0;
+				}
+			}
+			case "multiselect": return t.values.length === 0 || t.values.includes(e);
+			default: return !0;
+		}
+	}
+	get filteredData() {
+		return this.source.enabled || this.isPaginated ? this.data : this.tree.isEager ? this.tree.allRows.value : this.hasRowFilters ? this.data.filter((e) => this.rowMatchesFilters(e)) : this.data;
+	}
+	fireServerStateChange(e, t) {
+		this.props.onServerStateChange?.({
+			page: t?.page ?? this.page,
+			pageSize: t?.pageSize ?? this.pageSize,
+			sortColumn: "sortColumn" in (t ?? {}) ? t.sortColumn : this._sortColumn,
+			sortDirection: "sortDirection" in (t ?? {}) ? t.sortDirection : this._sortDirection,
+			columnFilters: t?.columnFilters ?? this.columnFilters,
+			globalFilterValue: t?.globalFilterValue ?? this.globalFilterValue
+		}, { reason: e });
+	}
+	firePaginationChange(e, t, n) {
+		this.props.onPaginationChange?.({
+			page: e,
+			pageSize: t
+		}, { reason: n }), this.props.onPageChange?.(e, t);
+	}
+	resetToFirstPage(e) {
+		return !this.isPaginated || this.page === 1 ? this.page : (this._page = 1, this.firePaginationChange(1, this.pageSize, e), 1);
+	}
+	setGlobalFilter = (e) => {
+		let t = e === "" ? "clear" : "filter";
+		this._globalFilterValue = e, this.props.onGlobalFilterChange?.(e, { reason: t });
+		let n = this.resetToFirstPage(t);
+		this.fireServerStateChange(t, {
+			globalFilterValue: e,
+			page: n
+		}), this.source.invalidate(), this.tree.nodes.clear(), this.rows.clear(), this.notify();
+	};
+	setColumnFilter = (e, t) => {
+		let n = { ...this.columnFilters }, r = t === void 0 ? "clear" : "filter";
+		t === void 0 ? delete n[e] : n[e] = t, this._columnFilters = n, this.props.onColumnFiltersChange?.(n, { reason: r });
+		let i = this.resetToFirstPage(r);
+		this.fireServerStateChange(r, {
+			columnFilters: n,
+			page: i
+		}), this.source.invalidate(), this.tree.nodes.clear(), this.rows.clear(), this.notify();
+	};
+	clearColumnFilters = () => {
+		this._columnFilters = {}, this.props.onColumnFiltersChange?.({}, { reason: "clear" }), this.fireServerStateChange("clear", { columnFilters: {} }), this.source.invalidate(), this.tree.nodes.clear(), this.rows.clear(), this.notify();
+	};
+	clearAllFilters = () => {
+		this.setGlobalFilter(""), this.clearColumnFilters();
+	};
+	getColumnUniqueValues = (e) => {
+		let t = /* @__PURE__ */ new Set();
+		return (this.tree.isEager ? this.tree.everyRow() : this.data).forEach((n) => {
+			let r = n[e];
+			r !== void 0 && t.add(r);
+		}), Array.from(t).sort((e, t) => e === null ? 1 : t === null ? -1 : typeof e == "string" && typeof t == "string" ? e.localeCompare(t) : typeof e == "number" && typeof t == "number" ? e - t : String(e).localeCompare(String(t)));
+	};
+	get hasActiveFilters() {
+		return this.globalFilterValue.trim() !== "" || Object.keys(this.columnFilters).length > 0;
+	}
+	get filterStats() {
+		if (this.source.enabled || this.isPaginated) {
+			let e = this.totalRowCount;
+			return {
+				filtered: e,
+				total: e
+			};
+		}
+		return {
+			filtered: this.filteredData.length,
+			total: this.tree.isEager ? this.tree.everyRow().length : this.data.length
+		};
+	}
+	get totalRowCount() {
+		return this.source.enabled ? this.source.rowCount : this.tree.isEager ? this.tree.everyRow().length : this.props.def.pagination?.totalCount ?? this.data.length;
+	}
+	rows = B(() => {
+		if (this.source.enabled) return this.source.rowList();
+		if (this.tree.isEager) return this.tree.rowList();
+		let e = this.filteredData;
+		if (this._sortColumn && !this.isPaginated && (e = W.sortBy(e, (e) => e[this._sortColumn], this._sortDirection)), this.groupColumns.size > 0) {
+			let t = (e, n, r) => {
+				let i = n.values().next().value;
+				n.delete(i);
+				let a = W.findOrThrow(this.columns.value.leafs, (e) => e.key === i);
+				return this._sortColumn === "grouping-cell" && (e = W.sortBy(e, (e) => e[i], this._sortDirection)), W.groupBy(e, (e) => e[i]).map((e) => {
+					let i;
+					i = n.size > 0 ? t(e.values, new Set(n), r + 1) : e.values.map((e, t) => new H(this, e, r + 1 + t));
+					let o = new Fe(this, a, i, r, e.key);
+					return r += 1, o.expanded && (r += i.length), o;
+				});
+			};
+			return t(e, new Set(this.groupColumns), 0);
+		}
+		return e.map((e, t) => new H(this, e, t));
+	}, () => [this.columns]);
+	groupingSpan = B(() => {
+		let { visibleLeafs: e } = this.columns.value, t = e.findIndex((e) => e.isGrouping);
+		if (t === -1) return [];
+		let n = (n, r) => r > t && n.pin === e[t].pin && !n.isRowNumber && !n.isRowSelection && !n.isRowDetail, r = e.findIndex((e, t) => n(e, t) && !!e.aggregate), i = r === -1 ? e.length : r;
+		return [e[t], ...e.filter((e, t) => t < i && n(e, t))];
+	}, () => [this.columns]);
+	flatRows = B(() => this.source.enabled ? this.source.flatRowList(this.rows.value) : this.rows.value.flatMap((e) => e.flatRows), () => [this.rows]);
+	get rowHeight() {
+		return this.props.def.rowHeight ?? this.DEFAULT_ROW_HEIGHT_PX;
+	}
+	sizes = B(() => {
+		let e = this.columns.value.flat.reduce((e, t) => {
+			let { inlineWidth: n } = t;
+			return typeof n == "number" && (e[t.widthVarName] = `${t.inlineWidth}px`), t.pin === "START" && (e[t.inlineStartVarName] = `${t.startOffset}px`), t.pin === "END" && (e[t.inlineEndVarName] = `${t.endOffset}px`), e;
+		}, {});
+		e[this.rowHeightVarName] = `${this.rowHeight}px`, e[this.inlineStartEdgeVarName] = `${this.inlineStartEdge}px`, this._containerWidth > 0 && (e[this.viewportWidthVarName] = `${this._containerWidth}px`);
+		let { visibleLeafs: t } = this.columns.value, n = t.find((e) => e.key === G);
+		if (n) {
+			let t = W.sumBy(this.groupingSpan.value, (e) => e.inlineWidth ?? 0);
+			e[n.groupColumnWidthVarName] = `${t}px`;
+		}
+		return this.groupColumns.forEach((n) => {
+			let r = W.findOrThrow(this.columns.value.leafs, (e) => e.key === n);
+			e[r.groupColumnWidthVarName] = `${W.sumBy(t, (e) => e.pin === r.pin ? e.inlineWidth ?? 0 : 0)}px`;
+		}), e;
+	}, () => [this.columns, this.flexWidths]);
+	_containerWidth = 0;
+	get containerWidth() {
+		return this._containerWidth;
+	}
+	_sizingElement = null;
+	get sizingElement() {
+		return this._sizingElement;
+	}
+	setSizingElement = (e) => {
+		this._sizingElement = e;
+	};
+	get isRtl() {
+		return t(this._sizingElement);
+	}
+	setContainerWidth = (e) => {
+		this._containerWidth !== e && (this._containerWidth = e, this.flexWidths.clear(), this.notify());
+	};
+	flexWidths = B(() => {
+		let e = this._containerWidth;
+		if (e <= 0) return {};
+		let t = this.columns.value.visibleLeafs, n = (e) => !e.isFlexible || this.columnWidths.has(e.key), r = W.sumBy(t.filter(n), (e) => e.baseWidth), i = t.filter((e) => !n(e)), a = W.sumBy(i, (e) => e.baseWidth), o = e - r;
+		if (o <= a) return W.toRecord(i, (e) => [e.key, e.baseWidth]);
+		let s = {}, c = 0;
+		return i.forEach((e, t) => {
+			if (t === i.length - 1) s[e.key] = o - c;
+			else {
+				let t = Math.floor(e.baseWidth / a * o);
+				s[e.key] = t, c += t;
+			}
+		}), s;
+	}, () => [this.columns]);
+	getFlexWidth(e) {
+		return this.flexWidths.value[e];
+	}
+	DEFAULT_ROW_HEIGHT_PX = 48;
+	MIN_COLUMN_WIDTH_PX = 48;
+	DEFAULT_COLUMN_WIDTH_PX = 200;
+	expandedGroupRow = /* @__PURE__ */ new Set();
+	_expandedDetailRows = /* @__PURE__ */ new Set();
+	get expandedDetailRows() {
+		return this.props.expandedRowKeys ? new Set(this.props.expandedRowKeys) : this._expandedDetailRows;
+	}
+	_revealDetailKey = null;
+	takeDetailReveal(e) {
+		return this._revealDetailKey === e && (this._revealDetailKey = null, !0);
+	}
+	toggleDetailRow = (e) => {
+		let t = new Set(this.expandedDetailRows);
+		t.has(e) ? t.delete(e) : t.add(e);
+		let n = t.has(e);
+		this._revealDetailKey = n && this.props.def.rowDetail?.scrollIntoView !== !1 ? e : null, this._expandedDetailRows = t, this.props.onExpandedRowKeysChange?.(Array.from(t), { reason: n ? "expand" : "collapse" }), this.rows.clear(), this.notify();
+	};
+	_page = 1;
+	_pageSize;
+	get page() {
+		return this.props.page ?? this._page;
+	}
+	get pageSize() {
+		if (this.props.pageSize !== void 0) return this.props.pageSize;
+		if (this._pageSize !== void 0) return this._pageSize;
+		let e = this.props.def.pagination;
+		if (e?.pageSize) return e.pageSize;
+		let t = this.props.def.visibleRowsCount;
+		return typeof t == "number" ? t : 10;
+	}
+	get pageSizeOptions() {
+		return this.props.def.pagination?.pageSizeOptions;
+	}
+	get isPaginated() {
+		return !!this.props.def.pagination;
+	}
+	get paginationState() {
+		let e = this.props.def.pagination;
+		if (!e) return;
+		let t = e.totalCount ?? (this.source.enabled ? this.source.rowCount : 0), n = this.pageSize;
+		return {
+			page: this.page,
+			pageSize: n,
+			totalItems: t,
+			totalPages: Math.max(1, Math.ceil(t / n))
+		};
+	}
+	changePage = (e) => {
+		let t = this.paginationState;
+		if (!t) return;
+		let n = Math.max(1, Math.min(e, t.totalPages));
+		n !== this.page && (this._page = n, this.firePaginationChange(n, t.pageSize, "page"), this.fireServerStateChange("page", { page: n }), this.rows.clear(), this.notify());
+	};
+	changePageSize = (e) => {
+		e !== this.pageSize && (this._pageSize = e, this._page = 1, this.props.onPageSizeChange?.(e), this.firePaginationChange(1, e, "page-size"), this.fireServerStateChange("page-size", {
+			page: 1,
+			pageSize: e
+		}), this.source.invalidate(), this.tree.nodes.clear(), this.rows.clear(), this.notify());
+	};
+	rowOffsets = B(() => {
+		if (this.source.enabled) return this.source.rowOffsets(this.flatRows.value);
+		let e = [], t = 0;
+		for (let n of this.flatRows.value) e.push(t), t += n instanceof V ? n.heightForOffset : this.rowHeight;
+		return {
+			offsets: e,
+			totalHeight: t
+		};
+	}, () => [this.flatRows]);
+	viewport = new $t(this);
+	columnVisibility = new Pt(this);
+	filter = new Jt(this);
+	pagination = new Yt(this);
+	aggregation = new Me(this);
+	exporter = new qt(this);
+	source = new Ut(this);
+	tree = new Qt(this);
+	edits = new ge(this);
+	refresh = () => {
+		this.edits.clearEdits(), this.source.invalidate();
+	};
+	get exportConfig() {
+		let e = this.props.def.export;
+		if (e) return typeof e == "object" ? e : en;
+	}
+	exportCsv = async (e = {}) => {
+		let { downloadCsv: t } = await import("../gridExport.mjs");
+		t(this.exporter.table(e), this.exporter.fileName(e), e);
+	};
+	exportXlsx = async (e = {}) => {
+		let { downloadXlsx: t } = await import("../gridExport.mjs");
+		t(this.exporter.table(e), this.exporter.fileName(e), e);
+	};
+	get hasVisibleColumns() {
+		return this.columns.value.userVisibleLeafs.length > 0;
+	}
+	get isEmpty() {
+		return this.source.enabled ? this.flatRows.value.length === 0 : this.data.length === 0;
+	}
+	get allRowsSelected() {
+		let e = this.loadedRows.length;
+		return e > 0 && this.selectedRows.size === e;
+	}
+	get someRowsSelected() {
+		return this.selectedRows.size > 0;
+	}
+	_selectionAnnounced = !1;
+	get selectionAnnouncement() {
+		if (!this._selectionAnnounced) return "";
+		let e = this.selectedRows.size;
+		return e === 0 ? "No rows selected" : `${e} of ${this.totalRowCount} rows selected`;
+	}
+	get groupedColumns() {
+		return Array.from(this.groupColumns, (e) => W.findOrThrow(this.columns.value.leafs, (t) => t.key === e));
+	}
+	selectedRows = /* @__PURE__ */ new Set();
+	get inlineStartEdge() {
+		return W.sumBy(this.columns.value.start, (e) => e.inlineWidth ?? 0);
+	}
+	get inlineEndEdge() {
+		return W.sumBy(this.columns.value.end, (e) => e.inlineWidth ?? 0);
+	}
+	inlineStartEdgeVarName = "--inline-start-edge";
+	rowHeightVarName = "--row-height";
+	viewportWidthVarName = "--viewport-width";
+	_idMap = /* @__PURE__ */ new WeakMap();
+	_autoId = 0;
+	_idFactory = typeof crypto < "u" && typeof crypto.randomUUID == "function" ? () => crypto.randomUUID() : () => `auto-row-${this._autoId++}`;
+	getRowKey(e) {
+		let { rowKey: t } = this.props.def;
+		return t ? typeof t == "function" ? t(e) : e[t] : (this._idMap.has(e) || this._idMap.set(e, this._idFactory()), this._idMap.get(e));
+	}
+	setSortColumn = (e, ...t) => {
+		if (t.length > 0) [this._sortDirection] = t, this._sortColumn = this._sortDirection ? e : void 0;
+		else {
+			let { _sortColumn: t, _sortDirection: n } = this;
+			this._sortColumn = t === e && n === "DESC" ? void 0 : e, this._sortDirection = t === e && n === "ASC" ? "DESC" : "ASC";
+		}
+		let n = this._sortColumn !== void 0 && this._sortDirection !== void 0 ? {
+			columnKey: this._sortColumn,
+			direction: this._sortDirection
+		} : void 0;
+		this.props.onSortingChange?.(n, { reason: n ? "sort" : "clear" }), this.props.onSortChange?.(this._sortColumn, this._sortDirection);
+		let r = this.resetToFirstPage("sort");
+		this.fireServerStateChange("sort", {
+			sortColumn: this._sortColumn,
+			sortDirection: this._sortDirection,
+			page: r
+		}), this.source.invalidate(), this.tree.nodes.clear(), this.rows.clear(), this.notify();
+	};
+	pinColumn = (e, t) => {
+		let n = jt(t), r = W.findOrThrow(this.columns.value.flat, (t) => t.uniqueKey === e);
+		r.pin !== n && r.pinColumn(n), this.columns.clear(), this.notify();
+	};
+	toggleGrouping = (e) => {
+		this.groupColumns = new Set(this.groupColumns), this.hiddenColumns = new Set(this.hiddenColumns), this.groupColumns.has(e) ? (this.groupColumns.delete(e), this.hiddenColumns.delete(e)) : (this.groupColumns.add(e), this.hiddenColumns.add(e)), this.collapseGroups(), this.sourceColumns.clear(), this.notify();
+	};
+	unGroupAll = () => {
+		let e = new Set(this.groupColumns);
+		this.groupColumns = /* @__PURE__ */ new Set(), this.hiddenColumns = new Set(Array.from(this.hiddenColumns).filter((t) => !e.has(t))), this.collapseGroups(), this.sourceColumns.clear(), this.notify();
+	};
+	collapseGroups() {
+		this.expandedGroupRow = /* @__PURE__ */ new Set(), this._collapsedGroupRow = /* @__PURE__ */ new Set(), this.source.expansionChanged(), this.source.invalidate();
+	}
+	_expansion = 0;
+	get expansionVersion() {
+		return this._expansion;
+	}
+	isGroupExpanded(e, t) {
+		if (this.expandedGroupRow.has(e)) return !0;
+		if (this._collapsedGroupRow.has(e)) return !1;
+		let n = this.props.def.groupDefaultExpanded;
+		return typeof n == "number" ? t < n : n === !0;
+	}
+	_collapsedGroupRow = /* @__PURE__ */ new Set();
+	toggleGroupRow = (e, t = this.expandedGroupRow.has(e)) => {
+		this._expansion++, this.expandedGroupRow = new Set(this.expandedGroupRow), this._collapsedGroupRow = new Set(this._collapsedGroupRow), t ? (this.expandedGroupRow.delete(e), this._collapsedGroupRow.add(e)) : (this.expandedGroupRow.add(e), this._collapsedGroupRow.delete(e)), this.source.expansionChanged(), this.rows.clear(), this.notify();
+	};
+	treeExpansionChanged() {
+		this._expansion++, this.source.expansionChanged(), this.rows.clear();
+	}
+	toggleRowSelection = (e) => {
+		this.toggleRowsSelection([e]);
+	};
+	toggleRowsSelection = (e, t = !1) => {
+		this.selectedRows = new Set(this.selectedRows), this._selectionAnnounced = !0;
+		let n = e.every((e) => this.selectedRows.has(e));
+		n ? e.forEach((e) => this.selectedRows.delete(e)) : e.forEach((e) => this.selectedRows.add(e)), this.flatRows.clear(), this.notify();
+		let r = Array.from(this.selectedRows), i = t ? n ? "clear" : "select-all" : n ? "deselect" : "select";
+		this.props.onSelectedRowKeysChange?.(r, { reason: i }), this.props.onSelectionChange?.({
+			action: n ? "deselect" : "select",
+			affectedRowKeys: e,
+			selectedRowKeys: r,
+			isAllSelected: this.selectedRows.size === this.loadedRows.length
+		});
+	};
+	toggleSelectAllRows = () => {
+		this.toggleRowsSelection(this.loadedRows.map((e) => this.getRowKey(e)), !0);
+	};
+	toggleColumnVisibility = (e) => {
+		this.hiddenColumns = new Set(this.hiddenColumns), this.hiddenColumns.has(e) ? this.hiddenColumns.delete(e) : this.hiddenColumns.add(e), this.columns.clear(), this.notify();
+	};
+	setWidth = (e, t) => {
+		this.columnWidths.set(e, t);
+	};
+	_groupColumns;
+	get groupColumns() {
+		return this._groupColumns ??= new Set(this.props.def.groupBy ?? []);
+	}
+	set groupColumns(e) {
+		this._groupColumns = e;
+	}
+	_hiddenColumns;
+	get hiddenColumns() {
+		return this._hiddenColumns ??= new Set(this.props.def.groupBy ?? []);
+	}
+	set hiddenColumns(e) {
+		this._hiddenColumns = e;
+	}
+	columnWidths = /* @__PURE__ */ new Map();
+	_sortColumn;
+	get sortColumn() {
+		return this._sortColumn;
+	}
+	_sortDirection = "ASC";
+	get sortDirection() {
+		return this._sortDirection;
+	}
+};
+//#endregion
+//#region src/components/dataGrid/useGrid.ts
+function nn(e) {
+	let [t] = A(() => new tn(e)), n = s("datagrid");
+	return t.setProps(e), t.setIdentifier(n), P(t.subscribe, t.getSnapshot, t.getSnapshot), t;
+}
+//#endregion
+//#region src/components/dataGrid.tsx
+function rn(e, t) {
+	let n = nn(e), i = k(null);
+	ee(t, () => ({
+		get element() {
+			return i.current;
+		},
+		exportCsv: n.exportCsv,
+		exportXlsx: n.exportXlsx,
+		refresh: n.refresh,
+		clearEdits: n.edits.clearEdits
+	}), [n]);
+	let { component: a, data: o, def: s, loading: c, filters: l, globalFilterValue: u, columnFilters: d, expandedRowKeys: f, expandedTreeKeys: p, page: m, pageSize: h, onSelectedRowKeysChange: g, onSelectionChange: _, onGlobalFilterChange: v, onColumnFiltersChange: b, onExpandedRowKeysChange: x, onExpandedTreeKeysChange: S, onCellEditsChange: C, onPaginationChange: w, onPageChange: T, onPageSizeChange: E, onSortingChange: D, onSortChange: te, onServerStateChange: A, style: j, ...P } = e;
+	return O(() => {
+		let e = i.current;
+		if (e) return n.setSizingElement(e), () => n.setSizingElement(null);
+	}, [n]), /* @__PURE__ */ N(r, {
+		ref: i,
+		component: n.componentName,
+		...P,
+		style: {
+			...n.sizes.value,
+			...j
+		},
+		children: [
+			n.props.def.topBar && /* @__PURE__ */ M(Et, { grid: n }),
+			/* @__PURE__ */ M(yt, { grid: n }),
+			/* @__PURE__ */ M(vt, { grid: n }),
+			n.props.def.bottomBar && /* @__PURE__ */ M(ce, { grid: n }),
+			/* @__PURE__ */ M(y, {
+				props: { role: "status" },
+				children: n.selectionAnnouncement
+			})
+		]
+	});
+}
+var an = w(rn);
+rn.displayName = "DataGrid";
+//#endregion
+export { an as default };