@vuecs/table 1.0.0

package/dist/index.mjs

@@ -0,0 +1,2081 @@
+import { installDefaultsManager, installThemeManager, isObject, themableProps, useComponentDefaults, useComponentTheme, useSelectionMachine as useRowSelectionMachine, useThemeProps } from "@vuecs/core";
+import { Comment, Fragment, Teleport, Text, computed, defineComponent, h, inject, mergeProps, nextTick, onBeforeUnmount, onMounted, provide, ref, shallowRef, toRef, triggerRef, watch } from "vue";
+//#region src/composables/context.ts
+const TABLE_CONTEXT_KEY = Symbol("vcTableContext");
+function provideTableContext(ctx) {
+	provide(TABLE_CONTEXT_KEY, ctx);
+}
+function useTable() {
+	return inject(TABLE_CONTEXT_KEY, null);
+}
+const TABLE_ROW_CONTEXT_KEY = Symbol("vcTableRowContext");
+function provideTableRowContext(ctx) {
+	provide(TABLE_ROW_CONTEXT_KEY, ctx);
+}
+function useTableRow() {
+	return inject(TABLE_ROW_CONTEXT_KEY, null);
+}
+const TABLE_HEAD_CELL_COUNT_CONTEXT_KEY = Symbol("vcTableHeadCellCountContext");
+function provideHeadCellCountContext(ctx) {
+	provide(TABLE_HEAD_CELL_COUNT_CONTEXT_KEY, ctx);
+}
+function useHeadCellCountContext() {
+	return inject(TABLE_HEAD_CELL_COUNT_CONTEXT_KEY, null);
+}
+//#endregion
+//#region src/composables/sort.ts
+/**
+* Controlled sort machine. The consumer owns the sort state via
+* `v-model:sort` — the table emits intent only. When `<VCTable
+* :client-sort>` is set, the table additionally sorts data internally
+* via `sortRows()` from `utils/sort-rows.ts`; the controlled v-model
+* still emits, so consumers stay observable.
+*
+* State shape is `SortDescriptor[]` from v1.x-B onward — single-column
+* sort is an array of length 0–1. Multi-key cycling lives entirely
+* here; `<VCTableHeadCell>` reads `directionFor` / `positionFor` to
+* paint the indicator + numeric badge.
+*/
+function useSortMachine(options) {
+	const { source, columns, mustSort, maxSortKeys, emit } = options;
+	const local = ref(normalize(source.value));
+	watch(source, (next) => {
+		local.value = normalize(next);
+	});
+	const state = computed(() => local.value);
+	function findInitialDirection(key) {
+		return columns.value.find((c) => c.key === key)?.initialSortDirection ?? "asc";
+	}
+	function setSort(key, opts = {}) {
+		const current = local.value;
+		const idx = current.findIndex((s) => s.key === key);
+		const initial = findInitialDirection(key);
+		if (opts.direction !== void 0) {
+			const next = opts.append ? upsertAppend(current, key, opts.direction, maxSortKeys.value) : [{
+				key,
+				direction: opts.direction
+			}];
+			local.value = next;
+			emit(next);
+			return;
+		}
+		if (!opts.append) {
+			const existing = idx >= 0 ? current[idx] : null;
+			let next;
+			if (!existing) next = [{
+				key,
+				direction: initial
+			}];
+			else if (existing.direction === initial) next = [{
+				key,
+				direction: initial === "asc" ? "desc" : "asc"
+			}];
+			else next = mustSort.value ? [{
+				key,
+				direction: initial
+			}] : [];
+			local.value = next;
+			emit(next);
+			return;
+		}
+		if (idx < 0) {
+			const next = appendCapped(current, {
+				key,
+				direction: initial
+			}, maxSortKeys.value);
+			local.value = next;
+			emit(next);
+			return;
+		}
+		const existing = current[idx];
+		let next;
+		if (existing.direction === initial) next = current.map((s, i) => i === idx ? {
+			key,
+			direction: initial === "asc" ? "desc" : "asc"
+		} : s);
+		else next = current.filter((_, i) => i !== idx);
+		local.value = next;
+		emit(next);
+	}
+	function directionFor(key) {
+		const cur = local.value.find((s) => s.key === key);
+		return cur ? cur.direction : null;
+	}
+	function positionFor(key) {
+		const i = local.value.findIndex((s) => s.key === key);
+		return i < 0 ? null : i + 1;
+	}
+	/**
+	* Replace the entire sort state. Bypasses cycle logic + multi-sort
+	* gating — for callers that know exactly what they want (e.g. the
+	* sort-indicator chip row removes / reorders / clears descriptors
+	* directly without going through Shift-click semantics).
+	*/
+	function setState(next) {
+		local.value = next;
+		emit(next);
+	}
+	return {
+		state,
+		setSort,
+		setState,
+		directionFor,
+		positionFor
+	};
+}
+/**
+* Coerce v-model input into the canonical array shape. `undefined` /
+* `null` (which Vue may bind through during the v1.x-B migration
+* window when consumers still hold `ref<...>(null)`) become `[]`.
+*/
+function normalize(v) {
+	if (v == null) return [];
+	return v;
+}
+/**
+* Append a new descriptor, evicting the oldest when over the cap.
+* Cap of `<= 0` is treated as "unlimited" so consumers can opt out.
+*/
+function appendCapped(state, descriptor, max) {
+	const next = [...state, descriptor];
+	if (max > 0 && next.length > max) return next.slice(next.length - max);
+	return next;
+}
+/**
+* In-place semantic: if `key` is already in the state, update its
+* direction; else append (capped). Used by the explicit-direction
+* path when `append` is set.
+*/
+function upsertAppend(state, key, direction, max) {
+	const idx = state.findIndex((s) => s.key === key);
+	if (idx >= 0) return state.map((s, i) => i === idx ? {
+		key,
+		direction
+	} : s);
+	return appendCapped(state, {
+		key,
+		direction
+	}, max);
+}
+//#endregion
+//#region src/components/TableBody.vue?vue&type=script&lang.ts
+const tableBodyThemeDefaults$1 = { classes: { root: "vc-table-body" } };
+//#endregion
+//#region src/components/TableBody.vue
+var TableBody_default = defineComponent({
+	name: "VCTableBody",
+	inheritAttrs: false,
+	props: { ...themableProps() },
+	slots: Object,
+	setup(props, { attrs, slots }) {
+		const theme = useComponentTheme("tableBody", useThemeProps(props), tableBodyThemeDefaults$1);
+		const ctx = useTable();
+		return () => {
+			const rowSlot = slots.row;
+			const data = ctx?.data.value ?? [];
+			let children;
+			if (rowSlot) {
+				if (data.length === 0) return null;
+				children = data.map((row, index) => rowSlot({
+					row,
+					index
+				}));
+			} else children = [slots.default?.() ?? null];
+			return h("tbody", mergeProps(attrs, { class: theme.value.root || void 0 }), children);
+		};
+	}
+});
+//#endregion
+//#region src/utils/render-utils.ts
+/**
+* Convert a key like `'firstName'` / `'first_name'` / `'first-name'` to
+* `'First Name'`. Used by the bare-string column shorthand to derive
+* a label when only the key is given.
+*/
+function startCase(input) {
+	if (!input) return "";
+	return input.replace(/[_-]+/g, " ").replace(/([a-z])([A-Z])/g, "$1 $2").replace(/\s+/g, " ").trim().split(" ").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+}
+/**
+* Normalize the `:columns` prop into a uniform `TableColumn[]`.
+*
+* - **Explicit array** (including empty `[]`): pass through, fill `label`
+*   from `startCase(key)`. Treating `[]` as authoritative lets consumers
+*   deliberately render a header-less table during loading without the
+*   auto-derive kicking in the moment data arrives.
+* - **Bare-string shorthand**: `['id', 'name']` → `[{ key, label }, ...]`.
+* - **Auto-derive**: only when `columns` is `undefined` AND `data[0]` is an
+*   object, derive the columns from `Object.keys(data[0])`, skipping
+*   underscore-prefixed row-meta keys (`_rowVariant` / `_cellVariants`).
+*/
+function normalizeColumns(columns, data) {
+	const fromRaw = (col) => {
+		if (typeof col === "string") return {
+			key: col,
+			label: startCase(col)
+		};
+		return {
+			...col,
+			label: col.label ?? startCase(col.key)
+		};
+	};
+	if (columns !== void 0) return columns.map(fromRaw);
+	if (data.length === 0 || !isObject(data[0])) return [];
+	const first = data[0];
+	return Object.keys(first).filter((key) => !key.startsWith("_")).map((key) => ({
+		key,
+		label: startCase(key)
+	}));
+}
+/**
+* Resolve a column's value against a row.
+*
+* - String accessor: dot-path lookup (e.g. `'profile.email'` → `row.profile.email`)
+* - Function accessor: invoked with the row
+* - Falls back to `row[column.key]`
+*/
+function resolveCellValue(column, row) {
+	const { accessor } = column;
+	if (typeof accessor === "function") return accessor(row);
+	if (typeof accessor === "string") return resolveDotPath(row, accessor);
+	if (isObject(row)) return row[column.key];
+}
+function resolveDotPath(obj, path) {
+	if (!isObject(obj)) return void 0;
+	let cur = obj;
+	for (const part of path.split(".")) {
+		if (!isObject(cur)) return void 0;
+		cur = cur[part];
+	}
+	return cur;
+}
+/**
+* Resolve attribute objects, supporting both static-object and function forms
+* used by `cellAttrs` and `headerAttrs`.
+*/
+function resolveAttrs(attrs, ctx) {
+	if (!attrs) return void 0;
+	return typeof attrs === "function" ? attrs(ctx) : attrs;
+}
+/**
+* Selectors that mark an element (or an ancestor of it) as interactive —
+* row-click handlers should NOT fire when the click originates inside one
+* of these. Plan 028 D5 ships this list; the closest-ancestor matching
+* (vs direct-match) is what catches clicks on text INSIDE a button or
+* anchor.
+*/
+const INTERACTIVE_SELECTOR = [
+	"a",
+	"button",
+	"input",
+	"select",
+	"textarea",
+	"label[for]",
+	"[role=\"button\"]",
+	"[role=\"link\"]",
+	"[contenteditable]:not([contenteditable=\"false\"])",
+	"[tabindex]:not([tabindex=\"-1\"])",
+	".vc-overlay-portal-content"
+].join(",");
+/**
+* Returns `true` when a row-level click should be suppressed because the
+* event originated inside an interactive descendant — a button, anchor,
+* form input, role=button/link, an explicitly-focusable element, or a
+* portal'd overlay rendered into the document body (e.g. a
+* `<VCDropdownMenu>` action menu inside the row).
+*
+* Pass the `<tr>` element as `rowEl` so the helper can disambiguate
+* legitimate row clicks (where the `closest()` ancestor walk reaches the
+* `<tr>` itself, which carries `tabindex="0"` when the row is clickable)
+* from clicks on a genuine interactive descendant.
+*
+* Use at the row click handler: `if (filterRowClickEvent(event, tr)) return;`.
+*/
+function filterRowClickEvent(event, rowEl) {
+	const { target } = event;
+	if (!(target instanceof Element)) return false;
+	const hit = target.closest(INTERACTIVE_SELECTOR);
+	if (hit === null) return false;
+	if (rowEl && hit === rowEl) return false;
+	return true;
+}
+//#endregion
+//#region src/components/TableCell.vue?vue&type=script&lang.ts
+const tableCellThemeDefaults$1 = { classes: { root: "vc-table-cell" } };
+const tableCellProps = {
+	/** Render as `<th scope="row">` instead of `<td>` (mirror of `column.isRowHeader`). */
+	isRowHeader: {
+		type: Boolean,
+		default: false
+	},
+	/**
+	* Column key this cell corresponds to — used to resolve
+	* `_cellVariants[key]` from row meta AND to look up the column's
+	* `accessor` / `formatter` for the default-render path.
+	*/
+	columnKey: {
+		type: String,
+		default: void 0
+	},
+	/** Forward-compat for stacked-mode CSS — emitted as `data-label`. */
+	dataLabel: {
+		type: String,
+		default: void 0
+	},
+	/** Alignment helper — selects the `align.<value>` theme variant. */
+	align: {
+		type: String,
+		default: void 0
+	},
+	/** `position: sticky` on this cell. Forwarded as `themeVariant.stickyColumn`. */
+	stickyColumn: {
+		type: Boolean,
+		default: void 0
+	},
+	/**
+	* Renders a selection checkbox/radio for this row. Pairs with
+	* `<VCTableHeadCell isSelector>` to build a selection column.
+	* State mirrors `selection.isSelected(rowKey)`; clicking toggles
+	* that row independently of any row-click handler. Falls back
+	* to the default slot when selection is off.
+	*/
+	isSelector: {
+		type: Boolean,
+		default: false
+	},
+	/** `aria-label` for the per-row checkbox (defaults to `'Select row'`). */
+	selectorAriaLabel: {
+		type: String,
+		default: "Select row"
+	},
+	...themableProps()
+};
+/**
+* Detect whether the consumer-passed default slot's rendered vnodes
+* contain any meaningful content (vs being an empty / whitespace-only
+* / comment-only render).
+*
+* Vue passes `slots.default` as a render fn that's always present when
+* a `<template>` slot is declared (even if empty), so a naive
+* `slots.default?.()` truthy check would always pick the slot path
+* and skip the auto-render. Walk the rendered vnodes and recurse into
+* `Fragment` children — a `<template v-if>` / `<template v-for>` /
+* multi-child template renders as a Fragment whose `children` is the
+* actual content. Without recursion those would be falsely classified
+* as empty.
+*
+* Takes the pre-rendered vnodes (not the slot fn) so the caller can
+* invoke the slot at most once per render — slot fns can be
+* non-trivial and should not be called twice.
+*/
+function hasMeaningfulSlotContent(nodes) {
+	if (nodes == null || nodes === false) return false;
+	if (typeof nodes === "string") return nodes.trim().length > 0;
+	if (typeof nodes === "number") return true;
+	if (Array.isArray(nodes)) {
+		for (const child of nodes) if (hasMeaningfulSlotContent(child)) return true;
+		return false;
+	}
+	if (typeof nodes !== "object") return false;
+	const v = nodes;
+	if (v.type === Comment) return false;
+	if (v.type === Text) return typeof v.children === "string" && v.children.trim().length > 0;
+	if (v.type === Fragment) return hasMeaningfulSlotContent(v.children);
+	return true;
+}
+//#endregion
+//#region src/components/TableCell.vue
+var TableCell_default = defineComponent({
+	name: "VCTableCell",
+	inheritAttrs: false,
+	props: tableCellProps,
+	setup(props, { attrs, slots }) {
+		const tableCtx = useTable();
+		const rowCtx = useTableRow();
+		const themeProps = useThemeProps(props, "align", "stickyColumn");
+		const theme = useComponentTheme("tableCell", {
+			get themeClass() {
+				return themeProps.themeClass;
+			},
+			get themeVariant() {
+				const cellVariant = props.columnKey ? rowCtx?.cellVariants.value[props.columnKey] ?? void 0 : void 0;
+				return {
+					...themeProps.themeVariant ?? {},
+					...cellVariant ? { cellVariant } : {}
+				};
+			}
+		}, tableCellThemeDefaults$1);
+		return () => {
+			if (props.isSelector && tableCtx?.selection.mode.value !== void 0 && rowCtx) {
+				const rowKey = rowCtx.selectionKey.value;
+				const mode = tableCtx.selection.mode.value;
+				const checked = tableCtx.selection.isSelected(rowKey);
+				return h(props.isRowHeader ? "th" : "td", mergeProps(attrs, {
+					class: theme.value.root || void 0,
+					"data-label": props.dataLabel || void 0,
+					"data-sticky-column": props.stickyColumn ? "" : void 0,
+					scope: props.isRowHeader ? "row" : void 0,
+					role: props.isRowHeader ? "rowheader" : "gridcell"
+				}), [h("input", {
+					type: mode === "single" ? "radio" : "checkbox",
+					class: "vc-table-selector-checkbox",
+					"aria-label": props.selectorAriaLabel,
+					checked,
+					onClick: (e) => {
+						e.stopPropagation();
+						if (rowKey === void 0) return;
+						tableCtx.selection.toggle(rowKey);
+					}
+				})]);
+			}
+			const slotVNodes = slots.default?.();
+			let content = slotVNodes;
+			if (props.columnKey && tableCtx && rowCtx && !hasMeaningfulSlotContent(slotVNodes)) {
+				const column = tableCtx.columns.value.find((c) => c.key === props.columnKey);
+				if (column) {
+					const value = resolveCellValue(column, rowCtx.row.value);
+					if (column.formatter) content = column.formatter({
+						value,
+						key: column.key,
+						row: rowCtx.row.value
+					});
+					else if (value === void 0 || value === null) content = "";
+					else content = String(value);
+				}
+			}
+			const inGrid = tableCtx?.selection.mode.value !== void 0;
+			let cellRole;
+			if (inGrid) cellRole = props.isRowHeader ? "rowheader" : "gridcell";
+			const ariaAttrs = inGrid ? { role: cellRole } : {};
+			return h(props.isRowHeader ? "th" : "td", mergeProps(attrs, {
+				class: theme.value.root || void 0,
+				"data-label": props.dataLabel || void 0,
+				"data-sticky-column": props.stickyColumn ? "" : void 0,
+				scope: props.isRowHeader ? "row" : void 0,
+				...ariaAttrs
+			}), content);
+		};
+	}
+});
+//#endregion
+//#region src/components/TableFooter.vue?vue&type=script&lang.ts
+const tableFooterThemeDefaults$1 = { classes: { root: "vc-table-footer" } };
+//#endregion
+//#region src/components/TableFooter.vue
+var TableFooter_default = defineComponent({
+	name: "VCTableFooter",
+	inheritAttrs: false,
+	props: { ...themableProps() },
+	setup(props, { attrs, slots }) {
+		const theme = useComponentTheme("tableFooter", useThemeProps(props), tableFooterThemeDefaults$1);
+		provideHeadCellCountContext({
+			register: () => {},
+			unregister: () => {}
+		});
+		return () => h("tfoot", mergeProps(attrs, { class: theme.value.root || void 0 }), slots.default?.());
+	}
+});
+//#endregion
+//#region src/components/TableHeadCell.vue?vue&type=script&lang.ts
+const tableHeadCellThemeDefaults$1 = { classes: {
+	root: "vc-table-head-cell",
+	sortIcon: "vc-table-head-cell-sort-icon"
+} };
+function renderHeadContent(args) {
+	if (!args.isSelector) return args.defaultSlot?.();
+	if (args.selectionMode === "single") return null;
+	if (args.selectionMode === void 0) return args.defaultSlot?.();
+	return h("input", {
+		type: "checkbox",
+		class: "vc-table-selector-checkbox",
+		"aria-label": args.selectorAriaLabel,
+		checked: args.selectAllState === "all",
+		indeterminate: args.selectAllState === "some",
+		onClick: (e) => {
+			e.stopPropagation();
+			args.onSelectorClick();
+		}
+	});
+}
+//#endregion
+//#region src/components/TableHeadCell.vue
+var TableHeadCell_default = defineComponent({
+	name: "VCTableHeadCell",
+	inheritAttrs: false,
+	props: {
+		/** Column key — required for sort wiring (omit for purely presentational heads). */
+		columnKey: {
+			type: String,
+			default: void 0
+		},
+		/** Mark this header sortable. When set, click + Enter/Space cycle sort state. */
+		sortable: {
+			type: Boolean,
+			default: false
+		},
+		/** Override scope ("col" / "colgroup" / "row" / "rowgroup"). Smart default: colspan→colgroup, rowspan→rowgroup, else col. */
+		scope: {
+			type: String,
+			default: void 0
+		},
+		/** Native `<th colspan>` (forwarded; also drives the smart scope default). */
+		colspan: {
+			type: Number,
+			default: void 0
+		},
+		/** Native `<th rowspan>` (forwarded; also drives the smart scope default). */
+		rowspan: {
+			type: Number,
+			default: void 0
+		},
+		/** Native `<th title>`. */
+		title: {
+			type: String,
+			default: void 0
+		},
+		/** Native `<th abbr>`. */
+		abbr: {
+			type: String,
+			default: void 0
+		},
+		/** Alignment helper — selects the `align.<value>` theme variant. */
+		align: {
+			type: String,
+			default: void 0
+		},
+		/** `position: sticky` on this header cell. Forwarded as `themeVariant.stickyColumn`. */
+		stickyColumn: {
+			type: Boolean,
+			default: void 0
+		},
+		/**
+		* Renders a select-all checkbox when the parent table has
+		* `:selection-mode="multi"`. State is derived from the current
+		* selection against the visible data set: checked = all visible
+		* rows selected; indeterminate = some visible rows selected;
+		* unchecked = none.
+		*
+		* Click semantics — Gmail / GitHub style: when state is `none`
+		* or `some`, ADDS every visible row's key to the selection
+		* (preserving any off-screen / paginated selection); when state
+		* is `all`, REMOVES every visible row's key (also preserving
+		* off-screen selection). Cross-page selection persists across
+		* pagination flips.
+		*
+		* In `single` mode the header renders empty (only one row can
+		* be selected); when selection is off, the slot's default
+		* content renders so the column collapses gracefully.
+		*/
+		isSelector: {
+			type: Boolean,
+			default: false
+		},
+		/** `aria-label` for the select-all checkbox (defaults to `'Select all rows'`). */
+		selectorAriaLabel: {
+			type: String,
+			default: "Select all rows"
+		},
+		...themableProps()
+	},
+	setup(props, { attrs, slots }) {
+		const ctx = useTable();
+		const countCtx = useHeadCellCountContext();
+		onMounted(() => countCtx?.register());
+		onBeforeUnmount(() => countCtx?.unregister());
+		const themeProps = useThemeProps(props, "align", "stickyColumn");
+		const sortDirection = computed(() => {
+			if (!props.sortable || !props.columnKey || !ctx) return null;
+			const found = ctx.sort.value.find((s) => s.key === props.columnKey);
+			return found ? found.direction : null;
+		});
+		const sortIndex = computed(() => {
+			if (!props.sortable || !props.columnKey || !ctx) return null;
+			const i = ctx.sort.value.findIndex((s) => s.key === props.columnKey);
+			return i < 0 ? null : i + 1;
+		});
+		const theme = useComponentTheme("tableHeadCell", {
+			get themeClass() {
+				return themeProps.themeClass;
+			},
+			get themeVariant() {
+				return {
+					...themeProps.themeVariant ?? {},
+					sorted: sortDirection.value ?? "none"
+				};
+			}
+		}, tableHeadCellThemeDefaults$1);
+		const resolvedScope = computed(() => {
+			if (props.scope) return props.scope;
+			if (props.colspan && props.colspan > 1) return "colgroup";
+			if (props.rowspan && props.rowspan > 1) return "rowgroup";
+			return "col";
+		});
+		const ariaSort = computed(() => {
+			if (!props.sortable) return void 0;
+			const d = sortDirection.value;
+			if (d === "asc") return "ascending";
+			if (d === "desc") return "descending";
+			return "none";
+		});
+		function onClick(event) {
+			if (!props.sortable || !props.columnKey) return;
+			event.preventDefault();
+			ctx?.setSort(props.columnKey, { append: event.shiftKey });
+		}
+		const allRowKeys = computed(() => {
+			if (!ctx) return [];
+			return ctx.data.value.map((row, i) => ctx.getRowKey(row, i) ?? i);
+		});
+		const selectAllState = computed(() => {
+			if (!ctx || ctx.selection.mode.value !== "multi") return "none";
+			const keys = allRowKeys.value;
+			if (keys.length === 0) return "none";
+			const sel = ctx.selection.value.value;
+			const selectedSet = new Set(Array.isArray(sel) ? sel : []);
+			if (selectedSet.size === 0) return "none";
+			let selectedCount = 0;
+			for (const k of keys) if (selectedSet.has(k)) selectedCount += 1;
+			if (selectedCount === 0) return "none";
+			if (selectedCount === keys.length) return "all";
+			return "some";
+		});
+		function onSelectorClick() {
+			if (!ctx || ctx.selection.mode.value !== "multi") return;
+			const current = ctx.selection.value.value;
+			const existing = new Set(Array.isArray(current) ? current : []);
+			if (selectAllState.value === "all") for (const k of allRowKeys.value) existing.delete(k);
+			else for (const k of allRowKeys.value) existing.add(k);
+			ctx.selection.setValue(Array.from(existing));
+		}
+		function onKeydown(event) {
+			if (!props.sortable || !props.columnKey) return;
+			if (event.key === "Enter" || event.key === " ") {
+				event.preventDefault();
+				ctx?.setSort(props.columnKey, { append: event.shiftKey });
+			}
+		}
+		return () => h("th", mergeProps(attrs, {
+			class: theme.value.root || void 0,
+			scope: resolvedScope.value,
+			"data-sticky-column": props.stickyColumn ? "" : void 0,
+			colspan: props.colspan,
+			rowspan: props.rowspan,
+			title: props.title,
+			abbr: props.abbr,
+			"aria-sort": ariaSort.value,
+			"data-sort-index": sortIndex.value !== null && sortIndex.value > 1 ? String(sortIndex.value) : void 0,
+			tabindex: props.sortable ? 0 : void 0,
+			role: props.sortable || ctx?.selection.mode.value !== void 0 ? "columnheader" : void 0,
+			onClick: props.sortable ? onClick : void 0,
+			onKeydown: props.sortable ? onKeydown : void 0
+		}), [renderHeadContent({
+			isSelector: props.isSelector,
+			selectionMode: ctx?.selection.mode.value,
+			selectAllState: selectAllState.value,
+			selectorAriaLabel: props.selectorAriaLabel,
+			onSelectorClick,
+			defaultSlot: slots.default
+		}), props.sortable && sortDirection.value ? h("span", {
+			class: theme.value.sortIcon || void 0,
+			"aria-hidden": "true",
+			"data-sort": sortDirection.value
+		}, sortDirection.value === "asc" ? "↑" : "↓") : null]);
+	}
+});
+//#endregion
+//#region src/components/TableHeader.vue?vue&type=script&lang.ts
+const tableHeaderThemeDefaults$1 = { classes: { root: "vc-table-header" } };
+//#endregion
+//#region src/components/TableHeader.vue
+var TableHeader_default = defineComponent({
+	name: "VCTableHeader",
+	inheritAttrs: false,
+	props: { ...themableProps() },
+	setup(props, { attrs, slots }) {
+		const theme = useComponentTheme("tableHeader", useThemeProps(props), tableHeaderThemeDefaults$1);
+		return () => h("thead", mergeProps(attrs, { class: theme.value.root || void 0 }), slots.default?.());
+	}
+});
+//#endregion
+//#region src/components/TableRow.vue?vue&type=script&lang.ts
+const tableRowThemeDefaults$1 = { classes: { root: "vc-table-row" } };
+//#endregion
+//#region src/components/TableRow.vue
+var TableRow_default = defineComponent({
+	name: "VCTableRow",
+	inheritAttrs: false,
+	props: {
+		/** Current row data — used to resolve `_rowVariant` / `_cellVariants` and to emit `@row-click`. */
+		row: {
+			type: null,
+			default: void 0
+		},
+		/** Row index — used by row keyboard navigation + focused-row tracking. */
+		index: {
+			type: Number,
+			default: void 0
+		},
+		/** Mark the row disabled — forwarded to `themeVariant.disabled`. */
+		disabled: {
+			type: Boolean,
+			default: void 0
+		},
+		/**
+		* Manual override for the row's selected state. When set, wins over
+		* the auto-resolved selection from `useTable().selection`. Leave
+		* undefined to let `<VCTable :selection>` drive selection state.
+		*/
+		selected: {
+			type: Boolean,
+			default: void 0
+		},
+		...themableProps()
+	},
+	setup(props, { attrs, slots }) {
+		const ctx = useTable();
+		const rowVariant = computed(() => {
+			if (!isObject(props.row)) return null;
+			const v = props.row._rowVariant;
+			return typeof v === "string" ? v : null;
+		});
+		const cellVariants = computed(() => {
+			if (!isObject(props.row)) return {};
+			const v = props.row._cellVariants;
+			return isObject(v) ? v : {};
+		});
+		const focused = computed(() => {
+			if (props.index === void 0) return false;
+			return ctx?.focusedRow.value === props.index;
+		});
+		const selectionKey = computed(() => {
+			if (props.index === void 0) return -1;
+			return ctx?.getRowKey(props.row, props.index) ?? props.index;
+		});
+		const selectionMode = computed(() => ctx?.selection.mode.value);
+		const autoSelected = computed(() => {
+			if (props.selected !== void 0) return props.selected;
+			if (props.index === void 0) return false;
+			return ctx?.selection.isSelected(selectionKey.value) ?? false;
+		});
+		const themeProps = useThemeProps(props, "disabled");
+		const theme = useComponentTheme("tableRow", {
+			get themeClass() {
+				return themeProps.themeClass;
+			},
+			get themeVariant() {
+				return {
+					...themeProps.themeVariant ?? {},
+					...rowVariant.value ? { rowVariant: rowVariant.value } : {},
+					focused: focused.value,
+					selected: autoSelected.value
+				};
+			}
+		}, tableRowThemeDefaults$1);
+		if (props.index !== void 0) provideTableRowContext({
+			row: toRef(props, "row"),
+			index: toRef(props, "index"),
+			rowVariant,
+			cellVariants,
+			focused,
+			selectionKey,
+			selected: autoSelected
+		});
+		const selectionActive = computed(() => selectionMode.value !== void 0);
+		const isInteractive = computed(() => (ctx?.rowClickable.value || selectionActive.value) && props.index !== void 0 && !props.disabled);
+		watch([isInteractive, () => props.index], ([active, idx], [, prevIdx]) => {
+			if (!ctx) return;
+			if (prevIdx !== void 0 && prevIdx !== idx) ctx.unregisterInteractiveRow(prevIdx);
+			if (active && idx !== void 0) ctx.registerInteractiveRow(idx);
+			else if (idx !== void 0) ctx.unregisterInteractiveRow(idx);
+		}, { immediate: true });
+		onBeforeUnmount(() => {
+			if (ctx && props.index !== void 0) ctx.unregisterInteractiveRow(props.index);
+		});
+		const tabindex = computed(() => {
+			if (!isInteractive.value) return void 0;
+			if (!selectionActive.value) return 0;
+			const focusIdx = ctx?.focusedRow.value;
+			const interactives = ctx?.interactiveRows.value;
+			if (focusIdx !== null && focusIdx !== void 0 && interactives !== void 0 && interactives.has(focusIdx)) return props.index === focusIdx ? 0 : -1;
+			if (!interactives || interactives.size === 0) return -1;
+			let firstInteractive = null;
+			for (const idx of interactives) if (firstInteractive === null || idx < firstInteractive) firstInteractive = idx;
+			return props.index === firstInteractive ? 0 : -1;
+		});
+		function activateSelection(event) {
+			if (!selectionActive.value || props.index === void 0) return;
+			ctx?.selection.toggle(selectionKey.value, {
+				range: event.shiftKey,
+				toggle: event.metaKey || event.ctrlKey
+			});
+			ctx?.setFocusedRow(props.index);
+		}
+		function onClick(event) {
+			if (!isInteractive.value) return;
+			const rowEl = event.currentTarget;
+			if (filterRowClickEvent(event, rowEl)) return;
+			if (props.index === void 0) return;
+			ctx?.setFocusedRow(props.index);
+			activateSelection(event);
+			if (ctx?.rowClickable.value) ctx?.emitRowClick(props.row, props.index, event);
+		}
+		function onKeydown(event) {
+			if (!isInteractive.value || props.index === void 0) return;
+			const i = props.index;
+			const interactives = ctx?.interactiveRows.value;
+			const sorted = interactives && interactives.size > 0 ? Array.from(interactives).sort((a, b) => a - b) : [];
+			const posInSorted = sorted.indexOf(i);
+			const moveTo = (target) => {
+				event.preventDefault();
+				if (sorted.length === 0) return;
+				const nextIdx = sorted[Math.max(0, Math.min(sorted.length - 1, target))];
+				ctx?.setFocusedRow(nextIdx);
+				const tr = event.currentTarget;
+				if (!tr) return;
+				nextTick(() => {
+					const direction = nextIdx > i ? "nextElementSibling" : "previousElementSibling";
+					let sibling = tr[direction];
+					while (sibling) {
+						if (sibling instanceof globalThis.HTMLElement && sibling.tagName === "TR" && sibling.getAttribute("tabindex") === "0") {
+							sibling.focus();
+							break;
+						}
+						sibling = sibling[direction];
+					}
+				});
+				if (event.shiftKey && selectionActive.value && selectionMode.value === "multi" && ctx) {
+					if (ctx.selection.rangeAnchor.value === null) {
+						const currentRow = ctx.data.value[i];
+						if (currentRow !== void 0) ctx.selection.rangeAnchor.value = ctx.getRowKey(currentRow, i);
+					}
+					const targetRow = ctx.data.value[nextIdx];
+					if (targetRow !== void 0) {
+						const targetKey = ctx.getRowKey(targetRow, nextIdx);
+						ctx.selection.toggle(targetKey, { range: true });
+					}
+				}
+			};
+			if (event.key === "ArrowDown") moveTo(posInSorted + 1);
+			else if (event.key === "ArrowUp") moveTo(posInSorted - 1);
+			else if (event.key === "Home") moveTo(0);
+			else if (event.key === "End") moveTo(sorted.length - 1);
+			else if (event.key === "Enter" || event.key === " ") {
+				event.preventDefault();
+				activateSelection(event);
+				if (ctx?.rowClickable.value) ctx?.emitRowClick(props.row, i, event);
+			}
+		}
+		function onFocus() {
+			if (!isInteractive.value || props.index === void 0) return;
+			ctx?.setFocusedRow(props.index);
+		}
+		return () => {
+			const selectionAttrs = selectionActive.value ? {
+				role: "row",
+				"aria-selected": autoSelected.value ? "true" : "false"
+			} : {};
+			return h("tr", mergeProps(attrs, {
+				class: theme.value.root || void 0,
+				tabindex: tabindex.value,
+				"data-row-variant": rowVariant.value || void 0,
+				...selectionAttrs,
+				onClick: isInteractive.value ? onClick : void 0,
+				onKeydown: isInteractive.value ? onKeydown : void 0,
+				onFocus: isInteractive.value ? onFocus : void 0
+			}), slots.default?.());
+		};
+	}
+});
+//#endregion
+//#region src/utils/auto-render.ts
+/**
+* Recursively check whether `nodes` (a slot return) contains a vnode
+* whose `type` equals `target`. Recurses into Vue `Fragment` vnodes so
+* `<template v-if>` / `<template v-for>` wrapping around a part
+* doesn't hide it from the auto-render check.
+*
+* Used by `<VCTable>` and `<VCTableLite>` to detect whether the
+* consumer wrote a manual `<VCTableHeader>` / `<VCTableBody>` in the
+* default slot — if not, and `:columns` is set, the table renders the
+* missing band itself.
+*/
+function containsComponent(nodes, target) {
+	if (nodes == null || nodes === false) return false;
+	if (Array.isArray(nodes)) {
+		for (const child of nodes) if (containsComponent(child, target)) return true;
+		return false;
+	}
+	if (typeof nodes !== "object") return false;
+	const v = nodes;
+	if (v.type === target) return true;
+	if (v.type === Fragment) return containsComponent(v.children, target);
+	return false;
+}
+/**
+* Flatten a slot return into a single-level array, unwrapping
+* `Fragment` vnodes so partition logic operates on a flat sequence.
+* Fragments only serve as grouping markers and lose no DOM semantics
+* when flattened.
+*/
+function flattenSlot(nodes) {
+	if (nodes == null || nodes === false) return [];
+	if (Array.isArray(nodes)) return nodes.flatMap(flattenSlot);
+	if (typeof nodes !== "object") return [nodes];
+	const v = nodes;
+	if (v.type === Fragment) return flattenSlot(v.children);
+	return [nodes];
+}
+/**
+* Partition slot children into vnodes that should render BEFORE the
+* auto-body and vnodes that should render AFTER it. Body precedence
+* rules:
+*
+*   <thead>           ← always first
+*   <tbody>           ← auto-rendered band
+*   <VCTableEmpty>    ← own <tbody>, gated on empty data
+*   <VCTableLoading>  ← own <tbody>, gated on busy
+*   <tfoot>           ← must come last (HTML5 says SHOULD; matches
+*                       browser visual placement so the source order
+*                       lines up with the rendered order)
+*
+* Only `<VCTableFooter>` is partitioned to "after"; everything else
+* keeps source order in "before".
+*/
+function partitionBeforeAfterBody(nodes) {
+	const flat = flattenSlot(nodes);
+	const before = [];
+	const after = [];
+	for (const n of flat) if (n && typeof n === "object" && n.type === TableFooter_default) after.push(n);
+	else before.push(n);
+	return {
+		before,
+		after
+	};
+}
+/**
+* Compose the inner children of a `<table>` for the driver auto-render
+* path (plan 033 v0.2-B). Returns the array of vnodes in the order
+* the table should render them:
+*
+*   caption? · colgroup? · autoHeader? · slotChildren · autoBody?
+*
+* Header / body auto-render fires when `columns.length > 0` AND the
+* matching part isn't already present in `slotChildren` (Fragment-
+* aware via `containsComponent`).
+*/
+function composeTableInner(opts) {
+	const { cols, slotChildren, captionSlot, colgroupSlot } = opts;
+	const inner = [];
+	if (captionSlot) inner.push(h("caption", null, captionSlot()));
+	if (colgroupSlot) inner.push(h("colgroup", null, colgroupSlot()));
+	const autoRender = cols.length > 0;
+	const hasHeader = autoRender && containsComponent(slotChildren, TableHeader_default);
+	const hasBody = autoRender && containsComponent(slotChildren, TableBody_default);
+	if (autoRender && !hasHeader) inner.push(h(TableHeader_default, null, () => h(TableRow_default, null, () => cols.map((col) => h(TableHeadCell_default, {
+		key: col.key,
+		columnKey: col.key,
+		sortable: col.sortable,
+		stickyColumn: col.stickyColumn,
+		title: col.headerTitle,
+		abbr: col.headerAbbr,
+		class: [col.class, col.headerClass]
+	}, () => col.label)))));
+	const { before, after } = partitionBeforeAfterBody(slotChildren);
+	if (before.length > 0) inner.push(before);
+	if (autoRender && !hasBody) inner.push(h(TableBody_default, null, { row: ({ row, index }) => h(TableRow_default, {
+		row,
+		index
+	}, () => cols.map((col) => h(TableCell_default, {
+		key: col.key,
+		columnKey: col.key,
+		isRowHeader: col.isRowHeader,
+		stickyColumn: col.stickyColumn,
+		dataLabel: col.label,
+		class: [col.class, col.cellClass]
+	}))) }));
+	if (after.length > 0) inner.push(after);
+	return inner;
+}
+//#endregion
+//#region src/utils/sort-rows.ts
+/**
+* Client-side row sort (plan 033 v1.x-B).
+*
+* Returns a new array — the input is untouched. Honors:
+*
+* - **Sort key**: `column.sortByFormatted` → use `formatter` output;
+*   else → use `accessor` resolved value (default, matches v0.1
+*   `resolveCellValue`).
+* - **Comparator**: `column.sortFn(a, b) => number` when present;
+*   else a built-in compare that handles numbers, Dates, booleans,
+*   and uses `localeCompare` (with `numeric: true`) for everything
+*   else — so `'item 2'` sorts before `'item 10'`.
+* - **Null handling**: `null` / `undefined` sort LAST regardless of
+*   direction. Per-column `nullsFirst: true` floats them to the top.
+* - **Multi-key tie-break**: descriptors are applied in order. The
+*   first non-zero comparison wins.
+* - **Stability**: relies on `Array.prototype.sort`'s stable
+*   guarantee (ES2019+, every supported runtime).
+*
+* Empty `sorts` returns a shallow copy — never the input reference
+* itself, so callers can safely mutate the result.
+*/
+function sortRows(rows, options) {
+	if (options.sorts.length === 0) return rows.slice();
+	const columnByKey = /* @__PURE__ */ new Map();
+	for (const col of options.columns) columnByKey.set(col.key, col);
+	return rows.slice().sort((a, b) => {
+		for (const sort of options.sorts) {
+			const column = columnByKey.get(sort.key);
+			if (!column) continue;
+			const cmp = compareWithColumn(a, b, column, sort.direction);
+			if (cmp !== 0) return cmp;
+		}
+		return 0;
+	});
+}
+function compareWithColumn(a, b, column, direction) {
+	const av = resolveSortValue(column, a);
+	const bv = resolveSortValue(column, b);
+	const aMissing = av === null || av === void 0;
+	const bMissing = bv === null || bv === void 0;
+	if (aMissing && bMissing) return 0;
+	if (aMissing) return column.nullsFirst ? -1 : 1;
+	if (bMissing) return column.nullsFirst ? 1 : -1;
+	const cmp = column.sortFn ? column.sortFn(av, bv) : defaultCompare(av, bv);
+	return direction === "asc" ? cmp : -cmp;
+}
+function resolveSortValue(column, row) {
+	const value = resolveCellValue(column, row);
+	if (!column.sortByFormatted || !column.formatter) return value;
+	return column.formatter({
+		value,
+		key: column.key,
+		row
+	});
+}
+/**
+* Default comparator. Locale-aware for strings, numeric for numbers,
+* chronological for Dates. Falls back to coerced-string compare so
+* mixed-type columns don't throw.
+*/
+function defaultCompare(a, b) {
+	if (typeof a === "number" && typeof b === "number") return a - b;
+	if (a instanceof Date && b instanceof Date) return a.getTime() - b.getTime();
+	if (typeof a === "boolean" && typeof b === "boolean") {
+		if (a === b) return 0;
+		return a ? 1 : -1;
+	}
+	const as = typeof a === "string" ? a : String(a);
+	const bs = typeof b === "string" ? b : String(b);
+	return as.localeCompare(bs, void 0, { numeric: true });
+}
+//#endregion
+//#region src/components/Table.vue?vue&type=script&lang.ts
+const tableThemeDefaults$1 = { classes: {
+	root: "vc-table",
+	scrollContainer: "vc-table-scroll-container"
+} };
+//#endregion
+//#region src/components/Table.vue
+var Table_default = defineComponent({
+	name: "VCTable",
+	inheritAttrs: false,
+	props: {
+		/** Row data array. */
+		data: {
+			type: Array,
+			default: () => []
+		},
+		/** Column definitions (TableColumn or bare-string shorthand). When omitted, columns are derived from `Object.keys(data[0])`. */
+		columns: {
+			type: Array,
+			default: void 0
+		},
+		/** Busy flag — drives `aria-busy` on the `<table>` and gates the loading-band render. */
+		busy: {
+			type: Boolean,
+			default: false
+		},
+		/**
+		* Controlled sort state as `SortDescriptor[]`. Use `v-model:sort`.
+		* Empty array means "no sort". Since v1.x-B this is always an
+		* array (BREAKING change from v0.1's `{ key, direction } | null`).
+		* Single-column sort is just an array of length 0 or 1.
+		*/
+		sort: {
+			type: Array,
+			default: () => []
+		},
+		/** When `true`, the cycle skips the `null` step: `null → asc → desc → asc`. */
+		mustSort: {
+			type: Boolean,
+			default: false
+		},
+		/**
+		* Enable multi-column sort. When `true`, Shift-click on a
+		* sortable header adds it as a secondary descriptor (or cycles
+		* its direction if already present). Plain click without Shift
+		* replaces multi-sort with single-sort of the clicked column.
+		* Default `false` — Shift-click behaves identically to plain
+		* click and the sort array stays length 0–1.
+		*/
+		multiSort: {
+			type: Boolean,
+			default: false
+		},
+		/**
+		* Maximum number of sort keys retained when `:multi-sort` is on.
+		* Adding a key past the cap drops the oldest descriptor. `0`
+		* means unlimited. Default `3` (matches Excel / bvnext / TanStack
+		* convention).
+		*/
+		maxSortKeys: {
+			type: Number,
+			default: 3
+		},
+		/**
+		* When `true`, the table reorders `:data` internally using
+		* `accessor` (or `formatter` output if `column.sortByFormatted`),
+		* honoring `column.sortFn` / `nullsFirst` if set. `v-model:sort`
+		* still emits intent so consumers stay observable. Default
+		* `false` — v0.1 controlled-sort behaviour preserved.
+		*/
+		clientSort: {
+			type: Boolean,
+			default: false
+		},
+		/** Wrap the `<table>` in an overflow scroll container. */
+		scrollable: {
+			type: Boolean,
+			default: false
+		},
+		/** When `:scrollable`, sticks the `<thead>` to the top of the scroll container. */
+		stickyHeader: {
+			type: Boolean,
+			default: false
+		},
+		/** When `:scrollable`, applied as `max-height` on the scroll container (any CSS length, e.g. `'24rem'`). */
+		maxHeight: {
+			type: String,
+			default: void 0
+		},
+		/** Opt-in row-click affordance — adds `tabindex` + cursor-pointer on every row and emits `@row-click`. */
+		rowClickable: {
+			type: Boolean,
+			default: false
+		},
+		/**
+		* Row selection mode (plan 033 v1.x-A). When set, the table flips
+		* to ARIA `role="grid"` (+ `aria-multiselectable` for multi) and
+		* rows render with `aria-selected`. `undefined` keeps the v0.1
+		* plain-table semantics.
+		*/
+		selectionMode: {
+			type: String,
+			default: void 0
+		},
+		/**
+		* Controlled selection state. Use `v-model:selection`. Type is
+		* `string|number` for single mode, `(string|number)[]` for multi.
+		* `null` clears the selection.
+		*/
+		selection: {
+			type: [
+				String,
+				Number,
+				Array,
+				null
+			],
+			default: null
+		},
+		/**
+		* Resolve a row's selection key. Defaults to `row.id` (falling
+		* back to the row index when absent). Pass a function for richer
+		* mappings (e.g. `(row) => row.uuid`).
+		*/
+		getRowKey: {
+			type: Function,
+			default: void 0
+		},
+		/**
+		* Stacked responsive mode (v0.2-D). When `true`, sets
+		* `data-responsive="true"` on the `<table>` so the structural CSS
+		* (and any theme-specific overrides) can collapse the table into
+		* per-row cards at narrow viewports. Uses each cell's `data-label`
+		* as the per-row column label.
+		*/
+		responsive: {
+			type: Boolean,
+			default: false
+		},
+		/** Density shorthand for `themeVariant.density`. */
+		density: {
+			type: String,
+			default: void 0
+		},
+		/** Alternating row backgrounds — shorthand for `themeVariant.striped`. */
+		striped: {
+			type: Boolean,
+			default: void 0
+		},
+		/** Cell borders — shorthand for `themeVariant.bordered`. */
+		bordered: {
+			type: Boolean,
+			default: void 0
+		},
+		/** Row hover highlight — shorthand for `themeVariant.hover`. */
+		hover: {
+			type: Boolean,
+			default: void 0
+		},
+		/** HTML tag to render. */
+		tag: {
+			type: String,
+			default: "table"
+		},
+		...themableProps()
+	},
+	emits: [
+		"update:sort",
+		"update:selection",
+		"row-click"
+	],
+	slots: Object,
+	setup(props, { attrs, slots, emit }) {
+		const theme = useComponentTheme("table", useThemeProps(props, "density", "striped", "bordered", "hover", "stickyHeader"), tableThemeDefaults$1);
+		const dataRef = toRef(props, "data");
+		const rawColumns = toRef(props, "columns");
+		const columns = computed(() => normalizeColumns(rawColumns.value, dataRef.value));
+		const sortSource = toRef(props, "sort");
+		const mustSortRef = toRef(props, "mustSort");
+		const maxSortKeysRef = toRef(props, "maxSortKeys");
+		const sortMachine = useSortMachine({
+			source: sortSource,
+			columns,
+			mustSort: mustSortRef,
+			maxSortKeys: maxSortKeysRef,
+			emit: (next) => emit("update:sort", next)
+		});
+		const visibleData = computed(() => {
+			if (!props.clientSort || sortMachine.state.value.length === 0) return dataRef.value;
+			return sortRows(dataRef.value, {
+				columns: columns.value,
+				sorts: sortMachine.state.value
+			});
+		});
+		const childCellCount = ref(0);
+		provideHeadCellCountContext({
+			register: () => {
+				childCellCount.value += 1;
+			},
+			unregister: () => {
+				childCellCount.value = Math.max(0, childCellCount.value - 1);
+			}
+		});
+		const colspan = computed(() => {
+			if (columns.value.length > 0) return columns.value.length;
+			return Math.max(1, childCellCount.value);
+		});
+		watch(() => columns.value.length > 0, (hasColumns) => {
+			if (hasColumns) childCellCount.value = 0;
+		});
+		const focusedRow = ref(null);
+		const setFocusedRow = (index) => {
+			focusedRow.value = index;
+		};
+		const emitRowClick = (row, index, event) => {
+			emit("row-click", row, index, event);
+		};
+		const wrapperEl = ref(null);
+		const interactiveRows = shallowRef(/* @__PURE__ */ new Set());
+		const registerInteractiveRow = (index) => {
+			if (interactiveRows.value.has(index)) return;
+			interactiveRows.value.add(index);
+			triggerRef(interactiveRows);
+		};
+		const unregisterInteractiveRow = (index) => {
+			if (!interactiveRows.value.has(index)) return;
+			interactiveRows.value.delete(index);
+			triggerRef(interactiveRows);
+		};
+		const selectionMode = computed(() => props.selectionMode);
+		const selectionValue = computed(() => props.selection);
+		const getRowKey = (row, index) => {
+			const custom = props.getRowKey;
+			if (typeof custom === "function") return custom(row, index);
+			if (row && typeof row === "object") {
+				const { id } = row;
+				if (typeof id === "string" || typeof id === "number") return id;
+			}
+			return index;
+		};
+		const selection = useRowSelectionMachine({
+			mode: selectionMode,
+			value: selectionValue,
+			emit: (next) => emit("update:selection", next),
+			keyAt: (index) => {
+				const view = visibleData.value;
+				if (index < 0 || index >= view.length) return void 0;
+				return getRowKey(view[index], index);
+			}
+		});
+		provideTableContext({
+			data: visibleData,
+			busy: toRef(props, "busy"),
+			columns,
+			sort: sortMachine.state,
+			setSort: (key, opts) => sortMachine.setSort(key, {
+				...opts,
+				append: props.multiSort ? opts?.append : false
+			}),
+			setSortState: sortMachine.setState,
+			maxSortKeys: maxSortKeysRef,
+			supportsSortMutation: true,
+			rowClickable: toRef(props, "rowClickable"),
+			focusedRow,
+			setFocusedRow,
+			selection,
+			getRowKey,
+			interactiveRows,
+			registerInteractiveRow,
+			unregisterInteractiveRow,
+			colspan,
+			emitRowClick,
+			wrapperEl
+		});
+		const slotProps = computed(() => ({
+			data: visibleData.value,
+			busy: props.busy,
+			columns: columns.value,
+			sort: sortMachine.state.value,
+			setSort: sortMachine.setSort
+		}));
+		const setWrapperRef = (el) => {
+			wrapperEl.value = el ?? null;
+		};
+		return () => {
+			const inner = composeTableInner({
+				cols: columns.value,
+				slotChildren: slots.default?.(slotProps.value),
+				captionSlot: slots.caption,
+				colgroupSlot: slots.colgroup
+			});
+			const mode = selectionMode.value;
+			const selectionAttrs = mode === void 0 ? {} : {
+				role: "grid",
+				...mode === "multi" ? { "aria-multiselectable": "true" } : {}
+			};
+			const tableNode = h(props.tag, mergeProps(attrs, {
+				class: theme.value.root || void 0,
+				"aria-busy": props.busy ? "true" : void 0,
+				"data-responsive": props.responsive ? "true" : void 0,
+				...selectionAttrs
+			}), inner);
+			const wrapper = h("div", {
+				ref: setWrapperRef,
+				class: "vc-table-wrapper",
+				style: { position: "relative" }
+			}, [tableNode]);
+			if (!props.scrollable) return wrapper;
+			return h("div", {
+				class: theme.value.scrollContainer || void 0,
+				style: props.maxHeight ? {
+					maxHeight: props.maxHeight,
+					overflow: "auto"
+				} : { overflow: "auto" }
+			}, [wrapper]);
+		};
+	}
+});
+//#endregion
+//#region src/components/TableLite.vue?vue&type=script&lang.ts
+const tableLiteThemeDefaults = { classes: {
+	root: "vc-table",
+	scrollContainer: "vc-table-scroll-container"
+} };
+/**
+* Slim sibling of `<VCTable>` — same columns driver + theme system +
+* auto-render, but with the sort + row-click + keyboard-nav machinery
+* stripped out (plan 033 v0.2-C). Consumers who want their own state
+* plumbing (e.g. tanstack-table on top) import this instead of the
+* full `<VCTable>`. Lite-only consumers tree-shake `useSortMachine`
+* out of their bundle.
+*
+* Provides the same `TableContext` shape so child components
+* (`<VCTableRow>`, `<VCTableHeadCell>`, …) work identically — the
+* sort / row-click hooks are wired to no-ops, so sortable headers and
+* `:row-clickable` rows visually behave as if the consumer hadn't
+* opted in.
+*/
+const tableLiteProps = {
+	/** Row data array. */
+	data: {
+		type: Array,
+		default: () => []
+	},
+	/** Column definitions (TableColumn or bare-string shorthand). When omitted, columns are derived from `Object.keys(data[0])`. */
+	columns: {
+		type: Array,
+		default: void 0
+	},
+	/** Busy flag — drives `aria-busy` on the `<table>` and gates the loading-band render. */
+	busy: {
+		type: Boolean,
+		default: false
+	},
+	/** Wrap the `<table>` in an overflow scroll container. */
+	scrollable: {
+		type: Boolean,
+		default: false
+	},
+	/** When `:scrollable`, sticks the `<thead>` to the top of the scroll container. */
+	stickyHeader: {
+		type: Boolean,
+		default: false
+	},
+	/** When `:scrollable`, applied as `max-height` on the scroll container. */
+	maxHeight: {
+		type: String,
+		default: void 0
+	},
+	/** Stacked responsive mode opt-in. Same shape as `<VCTable :responsive>`. */
+	responsive: {
+		type: Boolean,
+		default: false
+	},
+	/** Density shorthand for `themeVariant.density`. */
+	density: {
+		type: String,
+		default: void 0
+	},
+	/** Alternating row backgrounds — shorthand for `themeVariant.striped`. */
+	striped: {
+		type: Boolean,
+		default: void 0
+	},
+	/** Cell borders — shorthand for `themeVariant.bordered`. */
+	bordered: {
+		type: Boolean,
+		default: void 0
+	},
+	/** Row hover highlight — shorthand for `themeVariant.hover`. */
+	hover: {
+		type: Boolean,
+		default: void 0
+	},
+	/** HTML tag to render. */
+	tag: {
+		type: String,
+		default: "table"
+	},
+	...themableProps()
+};
+const NOOP_SORT_STATE = ref([]);
+const NOOP_SELECTION_MODE = computed(() => void 0);
+const NOOP_SELECTION_VALUE = computed(() => null);
+//#endregion
+//#region src/components/TableLite.vue
+var TableLite_default = defineComponent({
+	name: "VCTableLite",
+	inheritAttrs: false,
+	props: tableLiteProps,
+	slots: Object,
+	setup(props, { attrs, slots }) {
+		const theme = useComponentTheme("table", useThemeProps(props, "density", "striped", "bordered", "hover", "stickyHeader"), tableLiteThemeDefaults);
+		const dataRef = toRef(props, "data");
+		const rawColumns = toRef(props, "columns");
+		const columns = computed(() => normalizeColumns(rawColumns.value, dataRef.value));
+		const childCellCount = ref(0);
+		provideHeadCellCountContext({
+			register: () => {
+				childCellCount.value += 1;
+			},
+			unregister: () => {
+				childCellCount.value = Math.max(0, childCellCount.value - 1);
+			}
+		});
+		const colspan = computed(() => {
+			if (columns.value.length > 0) return columns.value.length;
+			return Math.max(1, childCellCount.value);
+		});
+		watch(() => columns.value.length > 0, (hasColumns) => {
+			if (hasColumns) childCellCount.value = 0;
+		});
+		const wrapperEl = ref(null);
+		const liteSelection = useRowSelectionMachine({
+			mode: NOOP_SELECTION_MODE,
+			value: NOOP_SELECTION_VALUE,
+			emit: () => {},
+			keyAt: () => void 0
+		});
+		const liteGetRowKey = (row, index) => {
+			if (row && typeof row === "object") {
+				const { id } = row;
+				if (typeof id === "string" || typeof id === "number") return id;
+			}
+			return index;
+		};
+		provideTableContext({
+			data: dataRef,
+			busy: toRef(props, "busy"),
+			columns,
+			sort: NOOP_SORT_STATE,
+			setSort: () => {},
+			setSortState: () => {},
+			maxSortKeys: ref(0),
+			supportsSortMutation: false,
+			rowClickable: computed(() => false),
+			focusedRow: ref(null),
+			setFocusedRow: () => {},
+			colspan,
+			emitRowClick: () => {},
+			wrapperEl,
+			selection: liteSelection,
+			getRowKey: liteGetRowKey,
+			interactiveRows: ref(/* @__PURE__ */ new Set()),
+			registerInteractiveRow: () => {},
+			unregisterInteractiveRow: () => {}
+		});
+		const slotProps = computed(() => ({
+			data: dataRef.value,
+			busy: props.busy,
+			columns: columns.value,
+			sort: NOOP_SORT_STATE.value,
+			setSort: () => {}
+		}));
+		const setWrapperRef = (el) => {
+			wrapperEl.value = el ?? null;
+		};
+		return () => {
+			const inner = composeTableInner({
+				cols: columns.value,
+				slotChildren: slots.default?.(slotProps.value),
+				captionSlot: slots.caption,
+				colgroupSlot: slots.colgroup
+			});
+			const tableNode = h(props.tag, mergeProps(attrs, {
+				class: theme.value.root || void 0,
+				"aria-busy": props.busy ? "true" : void 0,
+				"data-responsive": props.responsive ? "true" : void 0
+			}), inner);
+			const wrapper = h("div", {
+				ref: setWrapperRef,
+				class: "vc-table-wrapper",
+				style: { position: "relative" }
+			}, [tableNode]);
+			if (!props.scrollable) return wrapper;
+			return h("div", {
+				class: theme.value.scrollContainer || void 0,
+				style: props.maxHeight ? {
+					maxHeight: props.maxHeight,
+					overflow: "auto"
+				} : { overflow: "auto" }
+			}, [wrapper]);
+		};
+	}
+});
+//#endregion
+//#region src/components/TableEmpty.vue?vue&type=script&lang.ts
+const tableEmptyThemeDefaults$1 = { classes: { root: "vc-table-empty" } };
+const behavioralDefaults$2 = {
+	content: "No results.",
+	filteredContent: "No matches."
+};
+//#endregion
+//#region src/components/TableEmpty.vue
+var TableEmpty_default = defineComponent({
+	name: "VCTableEmpty",
+	inheritAttrs: false,
+	props: {
+		/** Override the auto-derived `colspan`. When omitted, uses the table's resolved colspan. */
+		colspan: {
+			type: Number,
+			default: void 0
+		},
+		/** Mark this as the empty-after-filter case (distinct copy / icon vs empty-no-data). */
+		filtered: {
+			type: Boolean,
+			default: false
+		},
+		/** Override the rendered text. Falls back to global defaults / hardcoded. */
+		content: {
+			type: String,
+			default: void 0
+		},
+		/** Override the rendered text for the filtered case. */
+		filteredContent: {
+			type: String,
+			default: void 0
+		},
+		...themableProps()
+	},
+	setup(props, { attrs, slots }) {
+		const ctx = useTable();
+		const defaults = useComponentDefaults("tableEmpty", props, behavioralDefaults$2);
+		const themeProps = useThemeProps(props);
+		const theme = useComponentTheme("tableEmpty", {
+			get themeClass() {
+				return themeProps.themeClass;
+			},
+			get themeVariant() {
+				return {
+					...themeProps.themeVariant ?? {},
+					filtered: props.filtered
+				};
+			}
+		}, tableEmptyThemeDefaults$1);
+		const shouldRender = computed(() => {
+			if (!ctx) return true;
+			return ctx.data.value.length === 0 && !ctx.busy.value;
+		});
+		const resolvedColspan = computed(() => props.colspan ?? ctx?.colspan.value ?? 1);
+		return () => {
+			if (!shouldRender.value) return null;
+			const cellContent = slots.default?.() ?? (props.filtered ? defaults.value.filteredContent : defaults.value.content);
+			return h("tbody", mergeProps(attrs, { class: theme.value.root || void 0 }), [h("tr", null, [h("td", { colspan: resolvedColspan.value }, [h("div", {
+				role: "status",
+				"aria-live": "polite"
+			}, cellContent)])])]);
+		};
+	}
+});
+//#endregion
+//#region src/components/TableLoading.vue?vue&type=script&lang.ts
+const tableLoadingThemeDefaults$1 = { classes: {
+	root: "vc-table-loading",
+	overlay: "vc-table-loading-overlay"
+} };
+const behavioralDefaults$1 = { content: "Loading…" };
+//#endregion
+//#region src/components/TableLoading.vue
+var TableLoading_default = defineComponent({
+	name: "VCTableLoading",
+	inheritAttrs: false,
+	props: {
+		/** Override the auto-derived `colspan` (default mode only — ignored in overlay mode). */
+		colspan: {
+			type: Number,
+			default: void 0
+		},
+		/** Render as a positioned overlay on top of the existing `<tbody>` (refresh feedback). Default mode is a centered tbody/tr/td placeholder. */
+		overlay: {
+			type: Boolean,
+			default: false
+		},
+		/** Override the rendered text. Falls back to global defaults. */
+		content: {
+			type: String,
+			default: void 0
+		},
+		...themableProps()
+	},
+	setup(props, { attrs, slots }) {
+		const ctx = useTable();
+		const defaults = useComponentDefaults("tableLoading", props, behavioralDefaults$1);
+		const themeProps = useThemeProps(props);
+		const theme = useComponentTheme("tableLoading", {
+			get themeClass() {
+				return themeProps.themeClass;
+			},
+			get themeVariant() {
+				return {
+					...themeProps.themeVariant ?? {},
+					overlay: props.overlay
+				};
+			}
+		}, tableLoadingThemeDefaults$1);
+		const shouldRender = computed(() => {
+			if (!ctx) return true;
+			const busy = ctx.busy.value;
+			const hasData = ctx.data.value.length > 0;
+			return props.overlay ? busy : busy && !hasData;
+		});
+		const resolvedColspan = computed(() => props.colspan ?? ctx?.colspan.value ?? 1);
+		return () => {
+			if (!shouldRender.value) return null;
+			const cellContent = slots.default?.() ?? defaults.value.content;
+			if (props.overlay) {
+				const overlayNode = h("div", mergeProps(attrs, {
+					class: [theme.value.root || void 0, theme.value.overlay || void 0],
+					role: "status",
+					"aria-live": "polite",
+					"aria-busy": "true"
+				}), cellContent);
+				if (ctx?.wrapperEl.value) return h(Teleport, { to: ctx.wrapperEl.value }, [overlayNode]);
+				return overlayNode;
+			}
+			return h("tbody", mergeProps(attrs, { class: theme.value.root || void 0 }), [h("tr", null, [h("td", { colspan: resolvedColspan.value }, [h("div", {
+				role: "status",
+				"aria-live": "polite",
+				"aria-busy": "true"
+			}, cellContent)])])]);
+		};
+	}
+});
+//#endregion
+//#region src/components/TableSortIndicators.vue?vue&type=script&lang.ts
+const tableSortIndicatorsThemeDefaults$1 = { classes: {
+	root: "vc-table-sort-indicators",
+	label: "vc-table-sort-indicators-label",
+	empty: "vc-table-sort-indicators-empty",
+	chip: "vc-table-sort-indicators-chip",
+	chipToggle: "vc-table-sort-indicators-chip-toggle",
+	chipPosition: "vc-table-sort-indicators-chip-position",
+	chipLabel: "vc-table-sort-indicators-chip-label",
+	chipArrow: "vc-table-sort-indicators-chip-arrow",
+	chipRemove: "vc-table-sort-indicators-chip-remove",
+	addWrapper: "",
+	add: "vc-table-sort-indicators-add",
+	clear: "vc-table-sort-indicators-clear"
+} };
+const behavioralDefaults = {
+	label: "Sort:",
+	emptyContent: "no columns sorted yet",
+	addLabel: "+ Add column",
+	clearLabel: "Clear all",
+	removeAriaLabel: "Remove sort key",
+	toggleAscTitle: "Click to toggle descending",
+	toggleDescTitle: "Click to toggle ascending",
+	arrowAsc: "↑",
+	arrowDesc: "↓",
+	removeGlyph: "×"
+};
+//#endregion
+//#region src/components/TableSortIndicators.vue
+var TableSortIndicators_default = defineComponent({
+	name: "VCTableSortIndicators",
+	inheritAttrs: false,
+	props: {
+		/**
+		* Sort state to render. Use `v-model:sort` for two-way binding.
+		* `null` is treated as "empty array" so consumers carrying
+		* migration-era `ref<TableSortState | null>(null)` don't crash.
+		* When BOTH `:sort` and `:columns` are omitted, the component
+		* falls back to `useTable()` context — note that with the
+		* default `<table>` rendering, slot children render INSIDE the
+		* `<table>`, so the v-model path is the recommended placement
+		* for chip rows above / below the table.
+		*/
+		sort: {
+			type: Array,
+			default: void 0
+		},
+		/**
+		* Columns the sort can reference. Required when using v-model
+		* mode (to look up labels + filter the add-column dropdown).
+		* Falls back to `useTable()` context when omitted.
+		*/
+		columns: {
+			type: Array,
+			default: void 0
+		},
+		/**
+		* Cap on the sort-state array length (mirrors `<VCTable
+		* :max-sort-keys>`). `0` = unlimited. When the cap is hit,
+		* adding via this component evicts the oldest descriptor.
+		* Falls back to `useTable().maxSortKeys` when omitted; defaults
+		* to `0` (unlimited) in stand-alone v-model mode without a
+		* context.
+		*/
+		maxSortKeys: {
+			type: Number,
+			default: void 0
+		},
+		/** Override the leading label text. Falls back to global defaults. */
+		label: {
+			type: String,
+			default: void 0
+		},
+		/** Override the empty-state copy. Falls back to global defaults. */
+		emptyContent: {
+			type: String,
+			default: void 0
+		},
+		/** Override the add-column trigger text. Falls back to global defaults. */
+		addLabel: {
+			type: String,
+			default: void 0
+		},
+		/** Override the clear-all trigger text. Falls back to global defaults. */
+		clearLabel: {
+			type: String,
+			default: void 0
+		},
+		/** Override the aria-label applied to per-chip remove buttons. */
+		removeAriaLabel: {
+			type: String,
+			default: void 0
+		},
+		/** Hide the add-column dropdown (consumer brings their own affordance). */
+		hideAdd: {
+			type: Boolean,
+			default: false
+		},
+		/** Hide the clear-all button. */
+		hideClear: {
+			type: Boolean,
+			default: false
+		},
+		...themableProps()
+	},
+	emits: ["update:sort"],
+	slots: Object,
+	setup(props, { attrs, emit, slots }) {
+		const ctx = useTable();
+		const defaults = useComponentDefaults("tableSortIndicators", props, behavioralDefaults);
+		const theme = useComponentTheme("tableSortIndicators", useThemeProps(props), tableSortIndicatorsThemeDefaults$1);
+		const sortPropProvided = computed(() => props.sort !== void 0);
+		const resolvedSort = computed(() => {
+			if (sortPropProvided.value) return props.sort ?? [];
+			return ctx?.sort.value ?? [];
+		});
+		const resolvedColumns = computed(() => {
+			if (props.columns !== void 0) return props.columns;
+			return ctx?.columns.value ?? [];
+		});
+		function commitSort(next) {
+			if (sortPropProvided.value) {
+				emit("update:sort", next);
+				return;
+			}
+			if (ctx) {
+				if (globalThis.process?.env?.NODE_ENV !== "production" && !ctx.supportsSortMutation) console.warn("[VCTableSortIndicators] mounted inside a table context that does not support sort mutation (likely <VCTableLite>). Clicks will be swallowed. Either bind :sort + :columns directly for v-model mode, or use <VCTable> instead of Lite.");
+				ctx.setSortState(next);
+			}
+		}
+		const columnByKey = computed(() => {
+			const map = /* @__PURE__ */ new Map();
+			for (const col of resolvedColumns.value) map.set(col.key, col);
+			return map;
+		});
+		const unsortedSortable = computed(() => {
+			const inSort = new Set(resolvedSort.value.map((s) => s.key));
+			return resolvedColumns.value.filter((c) => c.sortable && !inSort.has(c.key));
+		});
+		function toggleDirection(key) {
+			commitSort(resolvedSort.value.map((s) => s.key === key ? {
+				...s,
+				direction: s.direction === "asc" ? "desc" : "asc"
+			} : s));
+		}
+		function removeKey(key) {
+			commitSort(resolvedSort.value.filter((s) => s.key !== key));
+		}
+		const resolvedMaxSortKeys = computed(() => {
+			if (props.maxSortKeys !== void 0) return props.maxSortKeys;
+			return ctx?.maxSortKeys.value ?? 0;
+		});
+		function appendKey(key) {
+			if (!key) return;
+			const col = columnByKey.value.get(key);
+			if (!col || !col.sortable) return;
+			if (resolvedSort.value.some((s) => s.key === key)) return;
+			const next = [...resolvedSort.value, {
+				key,
+				direction: "asc"
+			}];
+			const cap = resolvedMaxSortKeys.value;
+			commitSort(cap > 0 && next.length > cap ? next.slice(next.length - cap) : next);
+		}
+		function clearAll() {
+			commitSort([]);
+		}
+		const chipSlotProps = computed(() => resolvedSort.value.map((descriptor, index) => ({
+			descriptor,
+			index,
+			position: index + 1,
+			column: columnByKey.value.get(descriptor.key),
+			toggle: () => toggleDirection(descriptor.key),
+			remove: () => removeKey(descriptor.key)
+		})));
+		return () => {
+			if (!sortPropProvided.value && !ctx) return null;
+			const sortState = resolvedSort.value;
+			const t = theme.value;
+			const d = defaults.value;
+			const addSlotProps = {
+				options: unsortedSortable.value,
+				add: appendKey
+			};
+			const clearSlotProps = { clear: clearAll };
+			const renderChip = (chip) => {
+				if (slots.chip) return slots.chip(chip);
+				const isAsc = chip.descriptor.direction === "asc";
+				return h("div", {
+					key: chip.descriptor.key,
+					class: t.chip || void 0,
+					"data-sort-key": chip.descriptor.key,
+					"data-direction": chip.descriptor.direction
+				}, [h("button", {
+					type: "button",
+					class: t.chipToggle || void 0,
+					title: isAsc ? d.toggleAscTitle : d.toggleDescTitle,
+					onClick: chip.toggle
+				}, [
+					h("span", { class: t.chipPosition || void 0 }, `${chip.position}.`),
+					h("span", { class: t.chipLabel || void 0 }, chip.column?.label ?? chip.descriptor.key),
+					h("span", { class: t.chipArrow || void 0 }, isAsc ? d.arrowAsc : d.arrowDesc)
+				]), h("button", {
+					type: "button",
+					class: t.chipRemove || void 0,
+					"aria-label": d.removeAriaLabel,
+					onClick: chip.remove
+				}, d.removeGlyph)]);
+			};
+			const renderLabel = () => slots.label ? slots.label() : h("span", { class: t.label || void 0 }, d.label);
+			const renderEmpty = () => slots.empty ? slots.empty() : h("span", { class: t.empty || void 0 }, d.emptyContent);
+			const renderAdd = () => {
+				if (props.hideAdd || addSlotProps.options.length === 0) return null;
+				if (slots.add) return slots.add(addSlotProps);
+				const selectNode = h("select", {
+					class: t.add || void 0,
+					"aria-label": d.addLabel,
+					onChange: (e) => {
+						const target = e.target;
+						appendKey(target.value);
+						target.value = "";
+					}
+				}, [h("option", { value: "" }, d.addLabel), ...addSlotProps.options.map((col) => h("option", {
+					key: col.key,
+					value: col.key
+				}, col.label ?? col.key))]);
+				if (!t.addWrapper) return selectNode;
+				return h("div", { class: t.addWrapper }, [selectNode]);
+			};
+			const renderClear = () => {
+				if (props.hideClear || sortState.length === 0) return null;
+				if (slots.clear) return slots.clear(clearSlotProps);
+				return h("button", {
+					type: "button",
+					class: t.clear || void 0,
+					onClick: clearAll
+				}, d.clearLabel);
+			};
+			const rootAttrs = {
+				class: t.root || void 0,
+				role: "toolbar",
+				"aria-label": "Active sort columns"
+			};
+			if (slots.default) return h("div", mergeProps(attrs, rootAttrs), slots.default({
+				sort: sortState,
+				chips: chipSlotProps.value,
+				add: addSlotProps,
+				clear: clearSlotProps
+			}));
+			const chipsContent = sortState.length === 0 ? [renderEmpty()] : chipSlotProps.value.map(renderChip);
+			return h("div", mergeProps(attrs, rootAttrs), [
+				renderLabel(),
+				...chipsContent,
+				renderAdd(),
+				renderClear()
+			]);
+		};
+	}
+});
+//#endregion
+//#region src/composables/define-table.ts
+/**
+* Pinia-style factory mirroring `defineList()`. Returns reactive state
+* containers + a `setSort` mutator. Useful when a consumer wants to share
+* a table's state across multiple components without prop drilling, or
+* when wiring a controlled table outside the SFC.
+*
+*   const usersTable = defineTable<User>({
+*       columns: ['id', 'name', 'email'],
+*       data: [],
+*       busy: false,
+*   });
+*
+*   <VCTable :data="usersTable.data" :columns="usersTable.columns" ... />
+*
+* The sort cycle composes `useSortMachine` internally — same semantics
+* as the `<VCTable>` SFC path (honors per-column `initialSortDirection`
+* + `mustSort`).
+*/
+function defineTable(options = {}) {
+	const data = ref(options.data ?? []);
+	const rawColumns = ref(options.columns ?? []);
+	const busy = ref(options.busy ?? false);
+	const mustSort = ref(options.mustSort ?? false);
+	const sort = ref(options.sort ?? []);
+	const maxSortKeys = ref(options.maxSortKeys ?? 3);
+	const columns = computed(() => normalizeColumns(rawColumns.value, data.value));
+	return {
+		data,
+		columns,
+		rawColumns,
+		busy,
+		mustSort,
+		sort,
+		setSort: useSortMachine({
+			source: sort,
+			columns,
+			mustSort,
+			maxSortKeys,
+			emit: (next) => {
+				sort.value = next;
+			}
+		}).setSort
+	};
+}
+//#endregion
+//#region src/theme.ts
+const tableThemeDefaults = { classes: {
+	root: "vc-table",
+	scrollContainer: "vc-table-scroll-container"
+} };
+const tableHeaderThemeDefaults = { classes: { root: "vc-table-header" } };
+const tableBodyThemeDefaults = { classes: { root: "vc-table-body" } };
+const tableFooterThemeDefaults = { classes: { root: "vc-table-footer" } };
+const tableRowThemeDefaults = { classes: { root: "vc-table-row" } };
+const tableCellThemeDefaults = { classes: { root: "vc-table-cell" } };
+const tableHeadCellThemeDefaults = { classes: {
+	root: "vc-table-head-cell",
+	sortIcon: "vc-table-head-cell-sort-icon"
+} };
+const tableEmptyThemeDefaults = { classes: { root: "vc-table-empty" } };
+const tableLoadingThemeDefaults = { classes: {
+	root: "vc-table-loading",
+	overlay: "vc-table-loading-overlay"
+} };
+const tableSortIndicatorsThemeDefaults = { classes: {
+	root: "vc-table-sort-indicators",
+	label: "vc-table-sort-indicators-label",
+	empty: "vc-table-sort-indicators-empty",
+	chip: "vc-table-sort-indicators-chip",
+	chipToggle: "vc-table-sort-indicators-chip-toggle",
+	chipPosition: "vc-table-sort-indicators-chip-position",
+	chipLabel: "vc-table-sort-indicators-chip-label",
+	chipArrow: "vc-table-sort-indicators-chip-arrow",
+	chipRemove: "vc-table-sort-indicators-chip-remove",
+	addWrapper: "",
+	add: "vc-table-sort-indicators-add",
+	clear: "vc-table-sort-indicators-clear"
+} };
+//#endregion
+//#region src/index.ts
+function install(app, options = {}) {
+	installThemeManager(app, options);
+	installDefaultsManager(app, options);
+	Object.entries({
+		VCTable: Table_default,
+		VCTableLite: TableLite_default,
+		VCTableHeader: TableHeader_default,
+		VCTableBody: TableBody_default,
+		VCTableFooter: TableFooter_default,
+		VCTableRow: TableRow_default,
+		VCTableCell: TableCell_default,
+		VCTableHeadCell: TableHeadCell_default,
+		VCTableEmpty: TableEmpty_default,
+		VCTableLoading: TableLoading_default,
+		VCTableSortIndicators: TableSortIndicators_default
+	}).forEach(([name, component]) => {
+		app.component(name, component);
+	});
+}
+var src_default = { install };
+//#endregion
+export { Table_default as VCTable, TableBody_default as VCTableBody, TableCell_default as VCTableCell, TableEmpty_default as VCTableEmpty, TableFooter_default as VCTableFooter, TableHeadCell_default as VCTableHeadCell, TableHeader_default as VCTableHeader, TableLite_default as VCTableLite, TableLoading_default as VCTableLoading, TableRow_default as VCTableRow, TableSortIndicators_default as VCTableSortIndicators, src_default as default, defineTable, filterRowClickEvent, install, normalizeColumns, provideHeadCellCountContext, provideTableContext, provideTableRowContext, resolveAttrs, resolveCellValue, sortRows, startCase, tableBodyThemeDefaults, tableCellThemeDefaults, tableEmptyThemeDefaults, tableFooterThemeDefaults, tableHeadCellThemeDefaults, tableHeaderThemeDefaults, tableLoadingThemeDefaults, tableRowThemeDefaults, tableSortIndicatorsThemeDefaults, tableThemeDefaults, useHeadCellCountContext, useRowSelectionMachine, useSortMachine, useTable, useTableRow };
+
+//# sourceMappingURL=index.mjs.map