@lostgradient/cinder 0.2.0 → 0.3.0

package/dist/components/data-grid/index.js

@@ -0,0 +1,3088 @@
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/components/data-grid/index.ts
+import"@lostgradient/cinder/data-grid/styles";
+
+// src/components/data-grid/data-grid.svelte
+import"svelte/internal/disclose-version";
+import * as $4 from "svelte/internal/client";
+import { tick } from "svelte";
+
+// src/utilities/class-names.ts
+function classNames(...parts) {
+  return parts.filter((part) => typeof part === "string" && part.length > 0).join(" ");
+}
+
+// src/utilities/clipboard.ts
+async function copyToClipboard(text) {
+  if (typeof navigator !== "undefined" && navigator.clipboard?.writeText) {
+    try {
+      await navigator.clipboard.writeText(text);
+      return true;
+    } catch {}
+  }
+  return legacyCopy(text);
+}
+function legacyCopy(text) {
+  if (typeof document === "undefined")
+    return false;
+  const textarea = document.createElement("textarea");
+  textarea.value = text;
+  textarea.setAttribute("readonly", "");
+  textarea.setAttribute("aria-hidden", "true");
+  textarea.setAttribute("tabindex", "-1");
+  textarea.style.position = "absolute";
+  textarea.style.left = "-9999px";
+  document.body.appendChild(textarea);
+  textarea.select();
+  let succeeded = false;
+  try {
+    succeeded = document.execCommand("copy");
+  } catch {
+    succeeded = false;
+  }
+  textarea.remove();
+  return succeeded;
+}
+
+// ../../node_modules/esm-env/true.js
+var true_default = true;
+// src/utilities/dev-warn.ts
+function devWarn(message, ...args) {
+  if (!true_default)
+    return;
+  console.warn(message, ...args);
+}
+
+// src/components/data-grid/_internal/column-model.svelte.ts
+import * as $ from "svelte/internal/client";
+var DEFAULT_DATA_GRID_COLUMN_WIDTH = 150;
+var DEFAULT_DATA_GRID_COLUMN_MIN_WIDTH = 60;
+
+class DataGridColumnModel {
+  columns;
+  columnOrder;
+  columnSizing;
+  columnPinning;
+  constructor(options) {
+    this.columns = options.columns;
+    this.columnOrder = options.columnOrder;
+    this.columnSizing = options.columnSizing;
+    this.columnPinning = options.columnPinning;
+  }
+  #orderedColumns = $.derived(() => orderColumns(this.columns(), this.columnOrder()).map((column, index) => resolveColumn(column, index, this.columnSizing(), this.columnPinning())));
+  get orderedColumns() {
+    return $.get(this.#orderedColumns);
+  }
+  set orderedColumns(value) {
+    $.set(this.#orderedColumns, value);
+  }
+  #leftPinnedColumns = $.derived(() => withPinOffsets(this.orderedColumns.filter((column) => column.pin === "left"), "left"));
+  get leftPinnedColumns() {
+    return $.get(this.#leftPinnedColumns);
+  }
+  set leftPinnedColumns(value) {
+    $.set(this.#leftPinnedColumns, value);
+  }
+  #rightPinnedColumns = $.derived(() => withPinOffsets(this.orderedColumns.filter((column) => column.pin === "right"), "right"));
+  get rightPinnedColumns() {
+    return $.get(this.#rightPinnedColumns);
+  }
+  set rightPinnedColumns(value) {
+    $.set(this.#rightPinnedColumns, value);
+  }
+  #leftPinnedWidth = $.derived(() => totalColumnWidth(this.leftPinnedColumns));
+  get leftPinnedWidth() {
+    return $.get(this.#leftPinnedWidth);
+  }
+  set leftPinnedWidth(value) {
+    $.set(this.#leftPinnedWidth, value);
+  }
+  #rightPinnedWidth = $.derived(() => totalColumnWidth(this.rightPinnedColumns));
+  get rightPinnedWidth() {
+    return $.get(this.#rightPinnedWidth);
+  }
+  set rightPinnedWidth(value) {
+    $.set(this.#rightPinnedWidth, value);
+  }
+  #unpinnedColumns = $.derived(() => this.orderedColumns.filter((column) => column.pin === undefined));
+  get unpinnedColumns() {
+    return $.get(this.#unpinnedColumns);
+  }
+  set unpinnedColumns(value) {
+    $.set(this.#unpinnedColumns, value);
+  }
+  #renderColumns = $.derived(() => {
+    return withRenderColIndexes([
+      ...this.leftPinnedColumns,
+      ...this.unpinnedColumns,
+      ...this.rightPinnedColumns
+    ]);
+  });
+  get renderColumns() {
+    return $.get(this.#renderColumns);
+  }
+  set renderColumns(value) {
+    $.set(this.#renderColumns, value);
+  }
+}
+function orderColumns(columns, columnOrder) {
+  assertUniqueColumnKeys(columns);
+  if (!columnOrder || columnOrder.length === 0)
+    return columns;
+  const byKey = new Map(columns.map((column) => [column.key, column]));
+  const ordered = columnOrder.flatMap((key) => {
+    const column = byKey.get(key);
+    if (!column)
+      return [];
+    byKey.delete(key);
+    return [column];
+  });
+  return [...ordered, ...byKey.values()];
+}
+function assertUniqueColumnKeys(columns) {
+  const seenColumnKeys = new Set;
+  for (const column of columns) {
+    if (seenColumnKeys.has(column.key)) {
+      throw new Error(`[cinder-data-grid] DataGrid column keys must be unique. Duplicate column key: ${JSON.stringify(column.key)}.`);
+    }
+    seenColumnKeys.add(column.key);
+  }
+}
+function resolveColumn(column, index, columnSizing, columnPinning) {
+  const minWidth = Math.max(0, finiteNumberOrFallback(column.minWidth, DEFAULT_DATA_GRID_COLUMN_MIN_WIDTH));
+  const baseWidth = finiteNumberOrFallback(columnSizing?.[column.key] ?? column.width, DEFAULT_DATA_GRID_COLUMN_WIDTH);
+  const maxWidth = Math.max(minWidth, finiteNumberOrFallback(column.maxWidth, Number.POSITIVE_INFINITY));
+  const pin = resolveColumnPin(column, columnPinning);
+  const resolvedColumn = {
+    key: column.key,
+    header: column.header,
+    minWidth,
+    width: Math.min(Math.max(baseWidth, minWidth), maxWidth),
+    colIndex: index + 1,
+    renderIndex: index + 1,
+    pinOffset: 0
+  };
+  if (column.cell !== undefined)
+    resolvedColumn.cell = column.cell;
+  if (column.maxWidth !== undefined)
+    resolvedColumn.maxWidth = column.maxWidth;
+  if (column.sortable !== undefined)
+    resolvedColumn.sortable = column.sortable;
+  if (column.sortComparator !== undefined)
+    resolvedColumn.sortComparator = column.sortComparator;
+  if (column.getValue !== undefined)
+    resolvedColumn.getValue = column.getValue;
+  if (pin !== undefined)
+    return { ...resolvedColumn, pin };
+  const { pin: _pin, ...unpinnedColumn } = resolvedColumn;
+  return unpinnedColumn;
+}
+function finiteNumberOrFallback(value, fallback) {
+  return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+function resolveColumnPin(column, columnPinning) {
+  if (columnPinning?.left?.includes(column.key))
+    return "left";
+  if (columnPinning?.right?.includes(column.key))
+    return "right";
+  return column.pin;
+}
+function withPinOffsets(columns, pin) {
+  if (pin === "left") {
+    let offset2 = 0;
+    return columns.map((column) => {
+      const nextColumn = { ...column, pinOffset: offset2 };
+      offset2 += column.width;
+      return nextColumn;
+    });
+  }
+  let offset = 0;
+  const columnsWithOffsets = [];
+  for (let index = columns.length - 1;index >= 0; index -= 1) {
+    const column = columns[index];
+    if (!column)
+      continue;
+    columnsWithOffsets.unshift({ ...column, pinOffset: offset });
+    offset += column.width;
+  }
+  return columnsWithOffsets;
+}
+function withRenderColIndexes(columns) {
+  return columns.map((column, index) => ({ ...column, renderIndex: index + 1 }));
+}
+function totalColumnWidth(columns) {
+  return columns.reduce((totalWidth, column) => totalWidth + column.width, 0);
+}
+function getDataGridColumnValue(row, column) {
+  if (column.getValue)
+    return column.getValue(row);
+  if (row !== null && typeof row === "object" && Object.hasOwn(row, column.key)) {
+    const value = Reflect.get(row, column.key);
+    return value;
+  }
+  return;
+}
+
+// src/components/data-grid/_internal/keyboard-model.ts
+function dataGridKeyToAction(event, context) {
+  const { activeRowIndex, activeColumnIndex, rowCount, columnCount, pageSize = 10 } = context;
+  if (rowCount === 0 || columnCount === 0)
+    return;
+  const extend = event.shiftKey;
+  const isCommand = event.ctrlKey || event.metaKey;
+  if (isCommand && event.key.toLowerCase() === "a")
+    return { type: "select-all" };
+  if (isCommand && event.key.toLowerCase() === "c")
+    return { type: "copy-selection" };
+  if (event.key === "Escape")
+    return { type: "collapse-selection" };
+  if (event.key === "Enter" || event.key === " ")
+    return { type: "select-active-cell" };
+  if (event.key === "ArrowRight") {
+    return {
+      type: "move-cell",
+      rowIndex: activeRowIndex,
+      columnIndex: activeColumnIndex + 1,
+      extend
+    };
+  }
+  if (event.key === "ArrowLeft") {
+    return {
+      type: "move-cell",
+      rowIndex: activeRowIndex,
+      columnIndex: activeColumnIndex - 1,
+      extend
+    };
+  }
+  if (event.key === "ArrowDown") {
+    return {
+      type: "move-cell",
+      rowIndex: activeRowIndex + 1,
+      columnIndex: activeColumnIndex,
+      extend
+    };
+  }
+  if (event.key === "ArrowUp") {
+    return {
+      type: "move-cell",
+      rowIndex: activeRowIndex - 1,
+      columnIndex: activeColumnIndex,
+      extend
+    };
+  }
+  if (event.key === "Home") {
+    return {
+      type: "move-cell",
+      rowIndex: isCommand ? 0 : activeRowIndex,
+      columnIndex: 0,
+      extend
+    };
+  }
+  if (event.key === "End") {
+    return {
+      type: "move-cell",
+      rowIndex: isCommand ? rowCount - 1 : activeRowIndex,
+      columnIndex: columnCount - 1,
+      extend
+    };
+  }
+  if (event.key === "PageDown") {
+    return {
+      type: "move-cell",
+      rowIndex: activeRowIndex + pageSize,
+      columnIndex: activeColumnIndex,
+      extend
+    };
+  }
+  if (event.key === "PageUp") {
+    return {
+      type: "move-cell",
+      rowIndex: activeRowIndex - pageSize,
+      columnIndex: activeColumnIndex,
+      extend
+    };
+  }
+  if (event.key === "Tab") {
+    const direction = event.shiftKey ? -1 : 1;
+    const nextCellIndex = activeRowIndex * columnCount + activeColumnIndex + direction;
+    const lastCellIndex = rowCount * columnCount - 1;
+    if (nextCellIndex < 0 || nextCellIndex > lastCellIndex)
+      return;
+    return {
+      type: "move-cell",
+      rowIndex: Math.floor(nextCellIndex / columnCount),
+      columnIndex: nextCellIndex % columnCount,
+      extend: false
+    };
+  }
+  return;
+}
+
+// src/components/data-grid/_internal/selection-model.svelte.ts
+import * as $2 from "svelte/internal/client";
+
+// src/components/data-grid/_internal/geometry.ts
+function getCellCoordinateKey(cell) {
+  return `${cell.rowId}\x00${cell.columnKey}`;
+}
+function computeCellRange(anchor, focus, rowIds, columnKeys) {
+  const anchorRowIndex = rowIds.indexOf(anchor.rowId);
+  const focusRowIndex = rowIds.indexOf(focus.rowId);
+  const anchorColumnIndex = columnKeys.indexOf(anchor.columnKey);
+  const focusColumnIndex = columnKeys.indexOf(focus.columnKey);
+  if (anchorRowIndex < 0 || focusRowIndex < 0 || anchorColumnIndex < 0 || focusColumnIndex < 0) {
+    return;
+  }
+  const startRowIndex = Math.min(anchorRowIndex, focusRowIndex);
+  const endRowIndex = Math.max(anchorRowIndex, focusRowIndex);
+  const startColumnIndex = Math.min(anchorColumnIndex, focusColumnIndex);
+  const endColumnIndex = Math.max(anchorColumnIndex, focusColumnIndex);
+  return {
+    anchor,
+    focus,
+    rowIds: rowIds.slice(startRowIndex, endRowIndex + 1),
+    columnKeys: columnKeys.slice(startColumnIndex, endColumnIndex + 1),
+    startRowIndex,
+    endRowIndex,
+    startColumnIndex,
+    endColumnIndex
+  };
+}
+function getCellsInRange(range) {
+  if (!range)
+    return [];
+  return range.rowIds.flatMap((rowId) => range.columnKeys.map((columnKey) => ({
+    rowId,
+    columnKey
+  })));
+}
+function clampCellCoordinate(cell, rowIds, columnKeys) {
+  if (rowIds.length === 0 || columnKeys.length === 0)
+    return;
+  const rowIndex = rowIds.indexOf(cell.rowId);
+  const columnIndex = columnKeys.indexOf(cell.columnKey);
+  if (rowIndex < 0 || columnIndex < 0)
+    return;
+  return {
+    rowId: rowIds[Math.min(Math.max(rowIndex, 0), rowIds.length - 1)] ?? rowIds[0],
+    columnKey: columnKeys[Math.min(Math.max(columnIndex, 0), columnKeys.length - 1)] ?? columnKeys[0]
+  };
+}
+
+// src/components/data-grid/_internal/selection-model.svelte.ts
+class DataGridSelectionModel {
+  rowIds;
+  columnKeys;
+  #activeCell = $2.state();
+  get activeCell() {
+    return $2.get(this.#activeCell);
+  }
+  set activeCell(value) {
+    $2.set(this.#activeCell, value, true);
+  }
+  #anchorCell = $2.state();
+  get anchorCell() {
+    return $2.get(this.#anchorCell);
+  }
+  set anchorCell(value) {
+    $2.set(this.#anchorCell, value, true);
+  }
+  #toggledCells = $2.state([]);
+  get toggledCells() {
+    return $2.get(this.#toggledCells);
+  }
+  set toggledCells(value) {
+    $2.set(this.#toggledCells, value);
+  }
+  constructor(options) {
+    this.rowIds = options.rowIds;
+    this.columnKeys = options.columnKeys;
+  }
+  #range = $2.derived(() => {
+    if (!this.anchorCell || !this.activeCell)
+      return;
+    return computeCellRange(this.anchorCell, this.activeCell, this.rowIds(), this.columnKeys());
+  });
+  get range() {
+    return $2.get(this.#range);
+  }
+  set range(value) {
+    $2.set(this.#range, value);
+  }
+  #selectedCellCoordinates = $2.derived(() => {
+    const cellsByKey = new Map;
+    for (const cell of getCellsInRange(this.range))
+      cellsByKey.set(getCellCoordinateKey(cell), cell);
+    for (const cell of this.toggledCells) {
+      if (clampCellCoordinate(cell, this.rowIds(), this.columnKeys())) {
+        cellsByKey.set(getCellCoordinateKey(cell), cell);
+      }
+    }
+    return [...cellsByKey.values()];
+  });
+  get selectedCellCoordinates() {
+    return $2.get(this.#selectedCellCoordinates);
+  }
+  set selectedCellCoordinates(value) {
+    $2.set(this.#selectedCellCoordinates, value);
+  }
+  #selectedCells = $2.derived(() => {
+    const keys = new Set;
+    for (const cell of this.selectedCellCoordinates)
+      keys.add(getCellCoordinateKey(cell));
+    return keys;
+  });
+  get selectedCells() {
+    return $2.get(this.#selectedCells);
+  }
+  set selectedCells(value) {
+    $2.set(this.#selectedCells, value);
+  }
+  setActiveCell(cell, options = {}) {
+    if (options.toggle) {
+      this.materializeRangeSelection();
+      this.toggleCell(cell);
+      this.activeCell = cell;
+      this.anchorCell = undefined;
+      return;
+    }
+    if (options.extend) {
+      if (!this.anchorCell)
+        this.anchorCell = this.activeCell ?? cell;
+      this.activeCell = cell;
+      return;
+    }
+    this.anchorCell = cell;
+    this.toggledCells = [];
+    this.activeCell = cell;
+  }
+  selectAll() {
+    const firstRowId = this.rowIds()[0];
+    const lastRowId = this.rowIds().at(-1);
+    const firstColumnKey = this.columnKeys()[0];
+    const lastColumnKey = this.columnKeys().at(-1);
+    if (firstRowId === undefined || lastRowId === undefined || firstColumnKey === undefined || lastColumnKey === undefined) {
+      return;
+    }
+    this.anchorCell = { rowId: firstRowId, columnKey: firstColumnKey };
+    this.activeCell = { rowId: lastRowId, columnKey: lastColumnKey };
+    this.toggledCells = [];
+  }
+  collapseToActiveCell() {
+    if (!this.activeCell)
+      return;
+    this.anchorCell = this.activeCell;
+    this.toggledCells = [];
+  }
+  isCellSelected(cell) {
+    return this.selectedCells.has(getCellCoordinateKey(cell));
+  }
+  isAnchorCell(cell) {
+    if (!this.anchorCell)
+      return false;
+    return getCellCoordinateKey(this.anchorCell) === getCellCoordinateKey(cell);
+  }
+  reconcile(fallbackCell) {
+    const rowIds = this.rowIds();
+    const columnKeys = this.columnKeys();
+    if (rowIds.length === 0 || columnKeys.length === 0) {
+      this.activeCell = undefined;
+      this.anchorCell = undefined;
+      this.toggledCells = [];
+      return;
+    }
+    const hadActiveCell = this.activeCell !== undefined;
+    const hadAnchorCell = this.anchorCell !== undefined;
+    const reconciledActiveCell = this.activeCell && clampCellCoordinate(this.activeCell, rowIds, columnKeys);
+    const nextActiveCell = reconciledActiveCell ?? fallbackCell;
+    if (!areCellsEqual(this.activeCell, nextActiveCell))
+      this.activeCell = nextActiveCell;
+    const nextAnchorCell = (this.anchorCell && clampCellCoordinate(this.anchorCell, rowIds, columnKeys)) ?? (hadAnchorCell || !hadActiveCell ? nextActiveCell : undefined);
+    if (!areCellsEqual(this.anchorCell, nextAnchorCell))
+      this.anchorCell = nextAnchorCell;
+    const nextToggledCells = this.toggledCells.filter((cell) => clampCellCoordinate(cell, rowIds, columnKeys));
+    if (nextToggledCells.length !== this.toggledCells.length) {
+      this.toggledCells = nextToggledCells;
+    }
+  }
+  materializeRangeSelection() {
+    const rangeCells = getCellsInRange(this.range);
+    if (rangeCells.length <= 1)
+      return;
+    const cellsByKey = new Map(this.toggledCells.map((toggledCell) => [getCellCoordinateKey(toggledCell), toggledCell]));
+    for (const cell of rangeCells)
+      cellsByKey.set(getCellCoordinateKey(cell), cell);
+    this.toggledCells = [...cellsByKey.values()];
+  }
+  toggleCell(cell) {
+    const key = getCellCoordinateKey(cell);
+    const cellsByKey = new Map(this.toggledCells.map((toggledCell) => [getCellCoordinateKey(toggledCell), toggledCell]));
+    if (cellsByKey.has(key))
+      cellsByKey.delete(key);
+    else
+      cellsByKey.set(key, cell);
+    this.toggledCells = [...cellsByKey.values()];
+  }
+}
+function areCellsEqual(left, right) {
+  if (left === undefined && right === undefined)
+    return true;
+  if (!left || !right)
+    return false;
+  return left.rowId === right.rowId && left.columnKey === right.columnKey;
+}
+
+// src/components/data-grid/_internal/sort-model.ts
+var sortCollator = new Intl.Collator(undefined, { numeric: true, sensitivity: "base" });
+function getNextDataGridSortModel(currentSortModel, columnKey, multiSort) {
+  const currentIndex = currentSortModel.findIndex((item) => item.key === columnKey);
+  const currentItem = currentIndex >= 0 ? currentSortModel[currentIndex] : undefined;
+  const nextDirection = getNextSortDirection(currentItem?.direction);
+  if (!multiSort) {
+    return nextDirection === undefined ? [] : [{ key: columnKey, direction: nextDirection }];
+  }
+  if (currentIndex < 0)
+    return [...currentSortModel, { key: columnKey, direction: "ascending" }];
+  if (nextDirection === undefined)
+    return currentSortModel.filter((item) => item.key !== columnKey);
+  return currentSortModel.map((item, index) => index === currentIndex ? { key: columnKey, direction: nextDirection } : item);
+}
+function getActiveDataGridSortModel(columns, sortModel) {
+  return sortModel.filter((item) => columns.some((column) => column.sortable && column.key === item.key));
+}
+function getSortedDataGridRowIndices(rows, columns, sortModel) {
+  const rowIndices = rows.map((_, index) => index);
+  const activeSortItems = getActiveDataGridSortModel(columns, sortModel).flatMap((item) => {
+    const column = columns.find((candidate) => candidate.key === item.key);
+    return column === undefined ? [] : [{ column, direction: item.direction }];
+  });
+  if (activeSortItems.length === 0)
+    return rowIndices;
+  const sortedRowIndices = rowIndices.slice();
+  sortedRowIndices.sort((leftIndex, rightIndex) => {
+    const leftRow = rows[leftIndex];
+    const rightRow = rows[rightIndex];
+    if (leftRow === undefined || rightRow === undefined)
+      return leftIndex - rightIndex;
+    for (const { column, direction } of activeSortItems) {
+      const leftValue = getDataGridColumnValue(leftRow, column);
+      const rightValue = getDataGridColumnValue(rightRow, column);
+      if (isNullishSortValue(leftValue) || isNullishSortValue(rightValue)) {
+        const comparison2 = compareDataGridValues(leftValue, rightValue, direction);
+        if (comparison2 !== 0)
+          return comparison2;
+        continue;
+      }
+      const comparison = column.sortComparator ? column.sortComparator(leftValue, rightValue, leftRow, rightRow) : compareDataGridValues(leftValue, rightValue, direction);
+      if (comparison !== 0) {
+        return column.sortComparator && direction === "descending" ? -comparison : comparison;
+      }
+    }
+    return leftIndex - rightIndex;
+  });
+  return sortedRowIndices;
+}
+function compareDataGridValues(leftValue, rightValue, direction = "ascending") {
+  if (Object.is(leftValue, rightValue))
+    return 0;
+  const leftValueIsNullish = isNullishSortValue(leftValue);
+  const rightValueIsNullish = isNullishSortValue(rightValue);
+  if (leftValueIsNullish && rightValueIsNullish)
+    return 0;
+  if (leftValueIsNullish)
+    return 1;
+  if (rightValueIsNullish)
+    return -1;
+  const leftNumber = getComparableNumber(leftValue);
+  const rightNumber = getComparableNumber(rightValue);
+  if (leftNumber !== undefined && rightNumber !== undefined) {
+    return direction === "ascending" ? leftNumber - rightNumber : rightNumber - leftNumber;
+  }
+  const comparison = sortCollator.compare(getComparableLabel(leftValue), getComparableLabel(rightValue));
+  return direction === "ascending" ? comparison : -comparison;
+}
+function getNextSortDirection(currentDirection) {
+  if (currentDirection === undefined)
+    return "ascending";
+  if (currentDirection === "ascending")
+    return "descending";
+  return;
+}
+function getComparableNumber(value) {
+  if (typeof value === "number" && Number.isFinite(value))
+    return value;
+  if (value instanceof Date) {
+    const time = value.getTime();
+    return Number.isFinite(time) ? time : undefined;
+  }
+  return;
+}
+function getComparableLabel(value) {
+  if (typeof value === "string")
+    return value;
+  if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
+    return value.toString();
+  }
+  if (typeof value === "symbol")
+    return value.description ?? "";
+  if (value instanceof Date)
+    return value.toISOString();
+  return Object.prototype.toString.call(value);
+}
+function isNullishSortValue(value) {
+  return value === null || value === undefined || value instanceof Date && !Number.isFinite(value.getTime());
+}
+
+// src/components/data-grid/_internal/virtualization-adapter.svelte.ts
+import * as $3 from "svelte/internal/client";
+
+// ../../node_modules/@tanstack/virtual-core/dist/esm/lazy-measurements.js
+function createLazyMeasurementsView(count, flat, getItemKey) {
+  const cache = new Array(count);
+  return new Proxy(cache, {
+    get(target, prop, receiver) {
+      if (typeof prop === "string") {
+        const c = prop.charCodeAt(0);
+        if (c >= 48 && c <= 57) {
+          const i = +prop;
+          if (Number.isInteger(i) && i >= 0 && i < count) {
+            let v = target[i];
+            if (!v) {
+              const s = flat[i * 2];
+              v = target[i] = {
+                index: i,
+                key: getItemKey(i),
+                start: s,
+                size: flat[i * 2 + 1],
+                end: s + flat[i * 2 + 1],
+                lane: 0
+              };
+            }
+            return v;
+          }
+        }
+        if (prop === "length")
+          return count;
+      }
+      return Reflect.get(target, prop, receiver);
+    }
+  });
+}
+
+// ../../node_modules/@tanstack/virtual-core/dist/esm/utils.js
+function memo(getDeps, fn, opts) {
+  let deps = opts.initialDeps ?? [];
+  let result;
+  let isInitial = true;
+  function memoizedFunction() {
+    var _a;
+    const debugEnabled = !!opts.key && !!((_a = opts.debug) == null ? undefined : _a.call(opts));
+    let depTime = 0;
+    if (debugEnabled)
+      depTime = Date.now();
+    const newDeps = getDeps();
+    const depsChanged = newDeps.length !== deps.length || newDeps.some((dep, index) => deps[index] !== dep);
+    if (!depsChanged) {
+      return result;
+    }
+    deps = newDeps;
+    let resultTime = 0;
+    if (debugEnabled)
+      resultTime = Date.now();
+    result = fn(...newDeps);
+    if (debugEnabled) {
+      const depEndTime = Math.round((Date.now() - depTime) * 100) / 100;
+      const resultEndTime = Math.round((Date.now() - resultTime) * 100) / 100;
+      const resultFpsPercentage = resultEndTime / 16;
+      const pad = (str, num) => {
+        str = String(str);
+        while (str.length < num) {
+          str = " " + str;
+        }
+        return str;
+      };
+      console.info(`%c⏱ ${pad(resultEndTime, 5)} /${pad(depEndTime, 5)} ms`, `
+            font-size: .6rem;
+            font-weight: bold;
+            color: hsl(${Math.max(0, Math.min(120 - 120 * resultFpsPercentage, 120))}deg 100% 31%);`, opts == null ? undefined : opts.key);
+    }
+    if ((opts == null ? undefined : opts.onChange) && !(isInitial && opts.skipInitialOnChange)) {
+      opts.onChange(result);
+    }
+    isInitial = false;
+    return result;
+  }
+  memoizedFunction.updateDeps = (newDeps) => {
+    deps = newDeps;
+  };
+  return memoizedFunction;
+}
+function notUndefined(value, msg) {
+  if (value === undefined) {
+    throw new Error(`Unexpected undefined${msg ? `: ${msg}` : ""}`);
+  } else {
+    return value;
+  }
+}
+var approxEqual = (a, b) => Math.abs(a - b) < 1.01;
+
+// ../../node_modules/@tanstack/virtual-core/dist/esm/index.js
+var _isIOSResult;
+var isIOSWebKit = () => {
+  if (_isIOSResult !== undefined)
+    return _isIOSResult;
+  if (typeof navigator === "undefined")
+    return _isIOSResult = false;
+  if (/iP(hone|od|ad)/.test(navigator.userAgent))
+    return _isIOSResult = true;
+  const mtp = navigator.maxTouchPoints;
+  return _isIOSResult = navigator.platform === "MacIntel" && mtp !== undefined && mtp > 0;
+};
+var defaultKeyExtractor = (index) => index;
+var defaultRangeExtractor = (range) => {
+  const start = Math.max(range.startIndex - range.overscan, 0);
+  const end = Math.min(range.endIndex + range.overscan, range.count - 1);
+  const len = end - start + 1;
+  const arr = new Array(len);
+  for (let i = 0;i < len; i++) {
+    arr[i] = start + i;
+  }
+  return arr;
+};
+var addEventListenerOptions = {
+  passive: true
+};
+var supportsScrollend = typeof window == "undefined" ? true : ("onscrollend" in window);
+var measureElement = (element, entry, instance) => {
+  if (instance.options.useCachedMeasurements) {
+    const index = instance.indexFromElement(element);
+    const key = instance.options.getItemKey(index);
+    return instance.itemSizeCache.get(key) ?? instance.options.estimateSize(index);
+  }
+  if (entry == null ? undefined : entry.borderBoxSize) {
+    const box = entry.borderBoxSize[0];
+    if (box) {
+      const size = Math.round(box[instance.options.horizontal ? "inlineSize" : "blockSize"]);
+      return size;
+    }
+  }
+  if (!entry) {
+    const index = instance.indexFromElement(element);
+    const key = instance.options.getItemKey(index);
+    const cachedSize = instance.itemSizeCache.get(key);
+    if (cachedSize !== undefined) {
+      return cachedSize;
+    }
+  }
+  return element[instance.options.horizontal ? "offsetWidth" : "offsetHeight"];
+};
+class Virtualizer {
+  constructor(opts) {
+    this.unsubs = [];
+    this.scrollElement = null;
+    this.targetWindow = null;
+    this.isScrolling = false;
+    this.scrollState = null;
+    this.measurementsCache = [];
+    this._flatMeasurements = null;
+    this.itemSizeCache = /* @__PURE__ */ new Map;
+    this.itemSizeCacheVersion = 0;
+    this.laneAssignments = /* @__PURE__ */ new Map;
+    this.pendingMin = null;
+    this.prevLanes = undefined;
+    this.lanesChangedFlag = false;
+    this.lanesSettling = false;
+    this.pendingScrollAnchor = null;
+    this.scrollRect = null;
+    this.scrollOffset = null;
+    this.scrollDirection = null;
+    this.scrollAdjustments = 0;
+    this._iosDeferredAdjustment = 0;
+    this._iosTouching = false;
+    this._iosJustTouchEnded = false;
+    this._iosTouchEndTimerId = null;
+    this._intendedScrollOffset = null;
+    this.elementsCache = /* @__PURE__ */ new Map;
+    this.now = () => {
+      var _a, _b, _c;
+      return ((_c = (_b = (_a = this.targetWindow) == null ? undefined : _a.performance) == null ? undefined : _b.now) == null ? undefined : _c.call(_b)) ?? Date.now();
+    };
+    this.observer = /* @__PURE__ */ (() => {
+      let _ro = null;
+      const get3 = () => {
+        if (_ro) {
+          return _ro;
+        }
+        if (!this.targetWindow || !this.targetWindow.ResizeObserver) {
+          return null;
+        }
+        return _ro = new this.targetWindow.ResizeObserver((entries) => {
+          entries.forEach((entry) => {
+            const run = () => {
+              const node = entry.target;
+              const index = this.indexFromElement(node);
+              if (!node.isConnected) {
+                this.observer.unobserve(node);
+                for (const [cacheKey, cachedNode] of this.elementsCache) {
+                  if (cachedNode === node) {
+                    this.elementsCache.delete(cacheKey);
+                    break;
+                  }
+                }
+                return;
+              }
+              if (this.shouldMeasureDuringScroll(index)) {
+                this.resizeItem(index, this.options.measureElement(node, entry, this));
+              }
+            };
+            this.options.useAnimationFrameWithResizeObserver ? requestAnimationFrame(run) : run();
+          });
+        });
+      };
+      return {
+        disconnect: () => {
+          var _a;
+          (_a = get3()) == null || _a.disconnect();
+          _ro = null;
+        },
+        observe: (target) => {
+          var _a;
+          return (_a = get3()) == null ? undefined : _a.observe(target, { box: "border-box" });
+        },
+        unobserve: (target) => {
+          var _a;
+          return (_a = get3()) == null ? undefined : _a.unobserve(target);
+        }
+      };
+    })();
+    this.range = null;
+    this.setOptions = (opts2) => {
+      var _a, _b;
+      const merged = {
+        debug: false,
+        initialOffset: 0,
+        overscan: 1,
+        paddingStart: 0,
+        paddingEnd: 0,
+        scrollPaddingStart: 0,
+        scrollPaddingEnd: 0,
+        horizontal: false,
+        getItemKey: defaultKeyExtractor,
+        rangeExtractor: defaultRangeExtractor,
+        onChange: () => {},
+        measureElement,
+        initialRect: { width: 0, height: 0 },
+        scrollMargin: 0,
+        gap: 0,
+        indexAttribute: "data-index",
+        initialMeasurementsCache: [],
+        lanes: 1,
+        anchorTo: "start",
+        followOnAppend: false,
+        scrollEndThreshold: 1,
+        isScrollingResetDelay: 150,
+        enabled: true,
+        isRtl: false,
+        useScrollendEvent: false,
+        useAnimationFrameWithResizeObserver: false,
+        laneAssignmentMode: "estimate",
+        useCachedMeasurements: false
+      };
+      for (const key in opts2) {
+        const v = opts2[key];
+        if (v !== undefined)
+          merged[key] = v;
+      }
+      const prevOptions = this.options;
+      let anchor = null;
+      let followOnAppend = null;
+      let edgeKeysChanged = false;
+      if (prevOptions !== undefined && prevOptions.enabled && merged.enabled && merged.anchorTo === "end" && this.scrollElement !== null) {
+        const prevCount = prevOptions.count;
+        const nextCount = merged.count;
+        const measurements = this.getMeasurements();
+        const prevFirstKey = prevCount > 0 ? ((_a = measurements[0]) == null ? undefined : _a.key) ?? prevOptions.getItemKey(0) : null;
+        const prevLastKey = prevCount > 0 ? ((_b = measurements[prevCount - 1]) == null ? undefined : _b.key) ?? prevOptions.getItemKey(prevCount - 1) : null;
+        const didCountChange = nextCount !== prevCount;
+        const didEdgeKeysChange = didCountChange || prevCount > 0 && nextCount > 0 && (merged.getItemKey(0) !== prevFirstKey || merged.getItemKey(nextCount - 1) !== prevLastKey);
+        if (didEdgeKeysChange) {
+          edgeKeysChanged = true;
+          const item = prevCount > 0 ? this.getVirtualItemForOffset(this.getScrollOffset()) ?? measurements[0] : null;
+          if (item) {
+            anchor = [item.key, this.getScrollOffset() - item.start];
+          }
+          const behavior = merged.followOnAppend === true ? "auto" : merged.followOnAppend || null;
+          if (behavior && nextCount > prevCount && this.isAtEnd(prevOptions.scrollEndThreshold) && (prevCount === 0 || merged.getItemKey(nextCount - 1) !== prevLastKey)) {
+            followOnAppend = behavior;
+          }
+        }
+      }
+      this.options = merged;
+      if (edgeKeysChanged) {
+        this.pendingMin = 0;
+        this.itemSizeCacheVersion++;
+      }
+      let anchorResolved = false;
+      let anchorDelta = 0;
+      if (anchor && this.scrollOffset !== null) {
+        const [anchorKey, anchorOffset] = anchor;
+        const newMeasurements = this.getMeasurements();
+        const { count, getItemKey } = this.options;
+        let idx = 0;
+        while (idx < count && getItemKey(idx) !== anchorKey) {
+          idx++;
+        }
+        if (idx < count) {
+          const anchorItem = newMeasurements[idx];
+          if (anchorItem) {
+            const newOffset = anchorItem.start + anchorOffset;
+            if (newOffset !== this.scrollOffset) {
+              anchorDelta = newOffset - this.scrollOffset;
+              this.scrollOffset = newOffset;
+              anchorResolved = true;
+            }
+          }
+        }
+      }
+      if (anchorResolved || followOnAppend) {
+        this.pendingScrollAnchor = [
+          anchorResolved ? anchor[0] : null,
+          anchorResolved ? anchor[1] : 0,
+          followOnAppend,
+          anchorDelta
+        ];
+      }
+    };
+    this.notify = (sync) => {
+      var _a, _b;
+      (_b = (_a = this.options).onChange) == null || _b.call(_a, this, sync);
+    };
+    this.maybeNotify = memo(() => {
+      this.calculateRange();
+      return [
+        this.isScrolling,
+        this.range ? this.range.startIndex : null,
+        this.range ? this.range.endIndex : null
+      ];
+    }, (isScrolling) => {
+      this.notify(isScrolling);
+    }, {
+      key: "maybeNotify",
+      debug: () => this.options.debug,
+      initialDeps: [
+        this.isScrolling,
+        this.range ? this.range.startIndex : null,
+        this.range ? this.range.endIndex : null
+      ]
+    });
+    this.cleanup = () => {
+      this.unsubs.filter(Boolean).forEach((d) => d());
+      this.unsubs = [];
+      this.observer.disconnect();
+      if (this.rafId != null && this.targetWindow) {
+        this.targetWindow.cancelAnimationFrame(this.rafId);
+        this.rafId = null;
+      }
+      this.scrollState = null;
+      this.scrollElement = null;
+      this.targetWindow = null;
+    };
+    this._didMount = () => {
+      return () => {
+        this.cleanup();
+      };
+    };
+    this._willUpdate = () => {
+      var _a;
+      const scrollElement = this.options.enabled ? this.options.getScrollElement() : null;
+      if (this.scrollElement !== scrollElement) {
+        this.cleanup();
+        if (!scrollElement) {
+          this.maybeNotify();
+          return;
+        }
+        this.scrollElement = scrollElement;
+        if (this.scrollElement && "ownerDocument" in this.scrollElement) {
+          this.targetWindow = this.scrollElement.ownerDocument.defaultView;
+        } else {
+          this.targetWindow = ((_a = this.scrollElement) == null ? undefined : _a.window) ?? null;
+        }
+        this.elementsCache.forEach((cached) => {
+          this.observer.observe(cached);
+        });
+        this.unsubs.push(this.options.observeElementRect(this, (rect) => {
+          this.scrollRect = rect;
+          this.maybeNotify();
+        }));
+        this.unsubs.push(this.options.observeElementOffset(this, (offset, isScrolling) => {
+          if (this._intendedScrollOffset !== null && Math.abs(offset - this._intendedScrollOffset) < 1.5) {
+            offset = this._intendedScrollOffset;
+          }
+          this._intendedScrollOffset = null;
+          this.scrollAdjustments = 0;
+          this.scrollDirection = isScrolling ? this.getScrollOffset() < offset ? "forward" : "backward" : null;
+          this.scrollOffset = offset;
+          this.isScrolling = isScrolling;
+          this._flushIosDeferredIfReady();
+          if (this.scrollState) {
+            this.scheduleScrollReconcile();
+          }
+          this.maybeNotify();
+        }));
+        if ("addEventListener" in this.scrollElement) {
+          const scrollEl = this.scrollElement;
+          const onTouchStart = () => {
+            this._iosTouching = true;
+            this._iosJustTouchEnded = false;
+            if (this._iosTouchEndTimerId !== null && this.targetWindow != null) {
+              this.targetWindow.clearTimeout(this._iosTouchEndTimerId);
+              this._iosTouchEndTimerId = null;
+            }
+          };
+          const onTouchEnd = () => {
+            this._iosTouching = false;
+            if (!isIOSWebKit() || this.targetWindow == null) {
+              return;
+            }
+            this._iosJustTouchEnded = true;
+            this._iosTouchEndTimerId = this.targetWindow.setTimeout(() => {
+              this._iosJustTouchEnded = false;
+              this._iosTouchEndTimerId = null;
+              this._flushIosDeferredIfReady();
+            }, 150);
+          };
+          scrollEl.addEventListener("touchstart", onTouchStart, addEventListenerOptions);
+          scrollEl.addEventListener("touchend", onTouchEnd, addEventListenerOptions);
+          this.unsubs.push(() => {
+            scrollEl.removeEventListener("touchstart", onTouchStart);
+            scrollEl.removeEventListener("touchend", onTouchEnd);
+            if (this._iosTouchEndTimerId !== null && this.targetWindow != null) {
+              this.targetWindow.clearTimeout(this._iosTouchEndTimerId);
+              this._iosTouchEndTimerId = null;
+            }
+          });
+        }
+        this._scrollToOffset(this.getScrollOffset(), {
+          adjustments: undefined,
+          behavior: undefined
+        });
+      }
+      const anchor = this.pendingScrollAnchor;
+      this.pendingScrollAnchor = null;
+      if (anchor && this.scrollElement && this.options.enabled) {
+        const [key, _offset, followOnAppend, anchorDelta] = anchor;
+        if (key !== null && !followOnAppend) {
+          if (isIOSWebKit() && (this.isScrolling || this._iosTouching || this._iosJustTouchEnded)) {
+            if (anchorDelta !== 0) {
+              this._iosDeferredAdjustment += anchorDelta;
+            }
+          } else {
+            this._scrollToOffset(this.getScrollOffset(), {
+              adjustments: undefined,
+              behavior: undefined
+            });
+          }
+        }
+        if (followOnAppend) {
+          this.scrollToEnd({ behavior: followOnAppend });
+        }
+      }
+    };
+    this._flushIosDeferredIfReady = () => {
+      if (this._iosDeferredAdjustment === 0)
+        return;
+      if (this.isScrolling)
+        return;
+      if (this._iosTouching)
+        return;
+      if (this._iosJustTouchEnded)
+        return;
+      const cur = this.getScrollOffset();
+      const max = this.getMaxScrollOffset();
+      if (cur < 0 || cur > max)
+        return;
+      const delta = this._iosDeferredAdjustment;
+      this._iosDeferredAdjustment = 0;
+      this._scrollToOffset(cur, {
+        adjustments: this.scrollAdjustments += delta,
+        behavior: undefined
+      });
+    };
+    this.rafId = null;
+    this.getSize = () => {
+      if (!this.options.enabled) {
+        this.scrollRect = null;
+        return 0;
+      }
+      this.scrollRect = this.scrollRect ?? this.options.initialRect;
+      return this.scrollRect[this.options.horizontal ? "width" : "height"];
+    };
+    this.getScrollOffset = () => {
+      if (!this.options.enabled) {
+        this.scrollOffset = null;
+        return 0;
+      }
+      this.scrollOffset = this.scrollOffset ?? (typeof this.options.initialOffset === "function" ? this.options.initialOffset() : this.options.initialOffset);
+      return this.scrollOffset;
+    };
+    this.getFurthestMeasurement = (measurements, index) => {
+      const furthestMeasurementsFound = /* @__PURE__ */ new Map;
+      const furthestMeasurements = /* @__PURE__ */ new Map;
+      for (let m = index - 1;m >= 0; m--) {
+        const measurement = measurements[m];
+        if (furthestMeasurementsFound.has(measurement.lane)) {
+          continue;
+        }
+        const previousFurthestMeasurement = furthestMeasurements.get(measurement.lane);
+        if (previousFurthestMeasurement == null || measurement.end > previousFurthestMeasurement.end) {
+          furthestMeasurements.set(measurement.lane, measurement);
+        } else if (measurement.end < previousFurthestMeasurement.end) {
+          furthestMeasurementsFound.set(measurement.lane, true);
+        }
+        if (furthestMeasurementsFound.size === this.options.lanes) {
+          break;
+        }
+      }
+      return furthestMeasurements.size === this.options.lanes ? Array.from(furthestMeasurements.values()).sort((a, b) => {
+        if (a.end === b.end) {
+          return a.index - b.index;
+        }
+        return a.end - b.end;
+      })[0] : undefined;
+    };
+    this.getMeasurementOptions = memo(() => [
+      this.options.count,
+      this.options.paddingStart,
+      this.options.scrollMargin,
+      this.options.getItemKey,
+      this.options.enabled,
+      this.options.lanes,
+      this.options.laneAssignmentMode
+    ], (count, paddingStart, scrollMargin, getItemKey, enabled, lanes, laneAssignmentMode) => {
+      const lanesChanged = this.prevLanes !== undefined && this.prevLanes !== lanes;
+      if (lanesChanged) {
+        this.lanesChangedFlag = true;
+      }
+      this.prevLanes = lanes;
+      this.pendingMin = null;
+      return {
+        count,
+        paddingStart,
+        scrollMargin,
+        getItemKey,
+        enabled,
+        lanes,
+        laneAssignmentMode
+      };
+    }, {
+      key: false
+    });
+    this.getMeasurements = memo(() => [this.getMeasurementOptions(), this.itemSizeCacheVersion], ({
+      count,
+      paddingStart,
+      scrollMargin,
+      getItemKey,
+      enabled,
+      lanes,
+      laneAssignmentMode
+    }, _itemSizeCacheVersion) => {
+      const itemSizeCache = this.itemSizeCache;
+      if (!enabled) {
+        this.measurementsCache = [];
+        this.itemSizeCache.clear();
+        this.laneAssignments.clear();
+        return [];
+      }
+      if (this.laneAssignments.size > count) {
+        for (const index of this.laneAssignments.keys()) {
+          if (index >= count) {
+            this.laneAssignments.delete(index);
+          }
+        }
+      }
+      if (this.lanesChangedFlag) {
+        this.lanesChangedFlag = false;
+        this.lanesSettling = true;
+        this.measurementsCache = [];
+        this.itemSizeCache.clear();
+        this.laneAssignments.clear();
+        this.pendingMin = null;
+      }
+      if (this.measurementsCache.length === 0 && !this.lanesSettling) {
+        this.measurementsCache = this.options.initialMeasurementsCache;
+        this.measurementsCache.forEach((item) => {
+          this.itemSizeCache.set(item.key, item.size);
+        });
+      }
+      const min = this.lanesSettling ? 0 : this.pendingMin ?? 0;
+      this.pendingMin = null;
+      if (this.lanesSettling && this.measurementsCache.length === count) {
+        this.lanesSettling = false;
+      }
+      if (lanes === 1) {
+        const gap = this.options.gap;
+        const need = count * 2;
+        let flat = this._flatMeasurements;
+        if (!flat || flat.length < need) {
+          const next = new Float64Array(need);
+          if (flat && min > 0)
+            next.set(flat.subarray(0, min * 2));
+          flat = next;
+          this._flatMeasurements = flat;
+        }
+        let runningStart;
+        if (min === 0) {
+          runningStart = paddingStart + scrollMargin;
+        } else {
+          const prevIdx = min - 1;
+          runningStart = flat[prevIdx * 2] + flat[prevIdx * 2 + 1] + gap;
+        }
+        for (let i = min;i < count; i++) {
+          const key = getItemKey(i);
+          const measuredSize = itemSizeCache.get(key);
+          const size = typeof measuredSize === "number" ? measuredSize : this.options.estimateSize(i);
+          flat[i * 2] = runningStart;
+          flat[i * 2 + 1] = size;
+          runningStart += size + gap;
+        }
+        const view = createLazyMeasurementsView(count, flat, getItemKey);
+        this.measurementsCache = view;
+        return view;
+      }
+      const measurements = this.measurementsCache.slice(0, min);
+      const laneLastIndex = new Array(lanes).fill(undefined);
+      for (let m = 0;m < min; m++) {
+        const item = measurements[m];
+        if (item) {
+          laneLastIndex[item.lane] = m;
+        }
+      }
+      for (let i = min;i < count; i++) {
+        const key = getItemKey(i);
+        const cachedLane = this.laneAssignments.get(i);
+        let lane;
+        let start;
+        const shouldCacheLane = laneAssignmentMode === "estimate" || itemSizeCache.has(key);
+        if (cachedLane !== undefined && this.options.lanes > 1) {
+          lane = cachedLane;
+          const prevIndex = laneLastIndex[lane];
+          const prevInLane = prevIndex !== undefined ? measurements[prevIndex] : undefined;
+          start = prevInLane ? prevInLane.end + this.options.gap : paddingStart + scrollMargin;
+        } else {
+          const furthestMeasurement = this.options.lanes === 1 ? measurements[i - 1] : this.getFurthestMeasurement(measurements, i);
+          start = furthestMeasurement ? furthestMeasurement.end + this.options.gap : paddingStart + scrollMargin;
+          lane = furthestMeasurement ? furthestMeasurement.lane : i % this.options.lanes;
+          if (this.options.lanes > 1 && shouldCacheLane) {
+            this.laneAssignments.set(i, lane);
+          }
+        }
+        const measuredSize = itemSizeCache.get(key);
+        const size = typeof measuredSize === "number" ? measuredSize : this.options.estimateSize(i);
+        const end = start + size;
+        measurements[i] = {
+          index: i,
+          start,
+          size,
+          end,
+          key,
+          lane
+        };
+        laneLastIndex[lane] = i;
+      }
+      this.measurementsCache = measurements;
+      return measurements;
+    }, {
+      key: "getMeasurements",
+      debug: () => this.options.debug
+    });
+    this.calculateRange = memo(() => [
+      this.getMeasurements(),
+      this.getSize(),
+      this.getScrollOffset(),
+      this.options.lanes
+    ], (measurements, outerSize, scrollOffset, lanes) => {
+      return this.range = measurements.length > 0 && outerSize > 0 ? calculateRange({
+        measurements,
+        outerSize,
+        scrollOffset,
+        lanes,
+        flat: lanes === 1 && this._flatMeasurements != null ? this._flatMeasurements : null
+      }) : null;
+    }, {
+      key: "calculateRange",
+      debug: () => this.options.debug
+    });
+    this.getVirtualIndexes = memo(() => {
+      let startIndex = null;
+      let endIndex = null;
+      const range = this.calculateRange();
+      if (range) {
+        startIndex = range.startIndex;
+        endIndex = range.endIndex;
+      }
+      this.maybeNotify.updateDeps([this.isScrolling, startIndex, endIndex]);
+      return [
+        this.options.rangeExtractor,
+        this.options.overscan,
+        this.options.count,
+        startIndex,
+        endIndex
+      ];
+    }, (rangeExtractor, overscan, count, startIndex, endIndex) => {
+      return startIndex === null || endIndex === null ? [] : rangeExtractor({
+        startIndex,
+        endIndex,
+        overscan,
+        count
+      });
+    }, {
+      key: "getVirtualIndexes",
+      debug: () => this.options.debug
+    });
+    this.indexFromElement = (node) => {
+      const attributeName = this.options.indexAttribute;
+      const indexStr = node.getAttribute(attributeName);
+      if (!indexStr) {
+        console.warn(`Missing attribute name '${attributeName}={index}' on measured element.`);
+        return -1;
+      }
+      return parseInt(indexStr, 10);
+    };
+    this.shouldMeasureDuringScroll = (index) => {
+      var _a;
+      if (!this.scrollState || this.scrollState.behavior !== "smooth") {
+        return true;
+      }
+      const scrollIndex = this.scrollState.index ?? ((_a = this.getVirtualItemForOffset(this.scrollState.lastTargetOffset)) == null ? undefined : _a.index);
+      if (scrollIndex !== undefined && this.range) {
+        const bufferSize = Math.max(this.options.overscan, Math.ceil((this.range.endIndex - this.range.startIndex) / 2));
+        const minIndex = Math.max(0, scrollIndex - bufferSize);
+        const maxIndex = Math.min(this.options.count - 1, scrollIndex + bufferSize);
+        return index >= minIndex && index <= maxIndex;
+      }
+      return true;
+    };
+    this.measureElement = (node) => {
+      if (!node) {
+        this.elementsCache.forEach((cached, key2) => {
+          if (!cached.isConnected) {
+            this.observer.unobserve(cached);
+            this.elementsCache.delete(key2);
+          }
+        });
+        return;
+      }
+      const index = this.indexFromElement(node);
+      const key = this.options.getItemKey(index);
+      const prevNode = this.elementsCache.get(key);
+      if (prevNode !== node) {
+        if (prevNode) {
+          this.observer.unobserve(prevNode);
+        }
+        this.observer.observe(node);
+        this.elementsCache.set(key, node);
+      }
+      if ((!this.isScrolling || this.scrollState) && this.shouldMeasureDuringScroll(index)) {
+        this.resizeItem(index, this.options.measureElement(node, undefined, this));
+      }
+    };
+    this.resizeItem = (index, size) => {
+      var _a, _b;
+      if (index < 0 || index >= this.options.count)
+        return;
+      let cachedSize;
+      let itemStart;
+      let key;
+      const flat = this._flatMeasurements;
+      if (this.options.lanes === 1 && flat !== null) {
+        key = this.options.getItemKey(index);
+        itemStart = flat[index * 2];
+        cachedSize = flat[index * 2 + 1];
+      } else {
+        const item = this.measurementsCache[index];
+        if (!item)
+          return;
+        key = item.key;
+        itemStart = item.start;
+        cachedSize = item.size;
+      }
+      const itemSize = this.itemSizeCache.get(key) ?? cachedSize;
+      const delta = size - itemSize;
+      if (delta !== 0) {
+        const wasAtEnd = this.options.anchorTo === "end" && ((_a = this.scrollState) == null ? undefined : _a.behavior) !== "smooth" && this.getVirtualDistanceFromEnd() <= this.options.scrollEndThreshold;
+        const prevTotalSize = wasAtEnd ? this.getTotalSize() : 0;
+        const shouldAdjustScroll = ((_b = this.scrollState) == null ? undefined : _b.behavior) !== "smooth" && (this.shouldAdjustScrollPositionOnItemSizeChange !== undefined ? this.shouldAdjustScrollPositionOnItemSizeChange(this.measurementsCache[index] ?? {
+          index,
+          key,
+          start: itemStart,
+          size: cachedSize,
+          end: itemStart + cachedSize,
+          lane: 0
+        }, delta, this) : itemStart < this.getScrollOffset() + this.scrollAdjustments && (!this.itemSizeCache.has(key) || this.scrollDirection !== "backward"));
+        if (this.pendingMin === null || index < this.pendingMin) {
+          this.pendingMin = index;
+        }
+        this.itemSizeCache.set(key, size);
+        this.itemSizeCacheVersion++;
+        if (wasAtEnd) {
+          this.applyScrollAdjustment(this.getTotalSize() - prevTotalSize);
+        } else if (shouldAdjustScroll) {
+          this.applyScrollAdjustment(delta);
+        }
+        this.notify(false);
+      }
+    };
+    this.getVirtualItems = memo(() => [this.getVirtualIndexes(), this.getMeasurements()], (indexes, measurements) => {
+      const virtualItems = [];
+      for (let k = 0, len = indexes.length;k < len; k++) {
+        const i = indexes[k];
+        const measurement = measurements[i];
+        virtualItems.push(measurement);
+      }
+      return virtualItems;
+    }, {
+      key: "getVirtualItems",
+      debug: () => this.options.debug
+    });
+    this.getVirtualItemForOffset = (offset) => {
+      const measurements = this.getMeasurements();
+      if (measurements.length === 0) {
+        return;
+      }
+      const flat = this._flatMeasurements;
+      const useFlat = this.options.lanes === 1 && flat != null;
+      const idx = findNearestBinarySearch(0, measurements.length - 1, useFlat ? (i) => flat[i * 2] : (i) => notUndefined(measurements[i]).start, offset);
+      return notUndefined(measurements[idx]);
+    };
+    this.getMaxScrollOffset = () => {
+      if (!this.scrollElement)
+        return 0;
+      if ("scrollHeight" in this.scrollElement) {
+        return this.options.horizontal ? this.scrollElement.scrollWidth - this.scrollElement.clientWidth : this.scrollElement.scrollHeight - this.scrollElement.clientHeight;
+      } else {
+        const doc = this.scrollElement.document.documentElement;
+        return this.options.horizontal ? doc.scrollWidth - this.scrollElement.innerWidth : doc.scrollHeight - this.scrollElement.innerHeight;
+      }
+    };
+    this.getVirtualDistanceFromEnd = () => {
+      return Math.max(this.getTotalSize() - this.getSize() - this.getScrollOffset(), 0);
+    };
+    this.getDistanceFromEnd = () => {
+      return Math.max(this.getMaxScrollOffset() - this.getScrollOffset(), 0);
+    };
+    this.isAtEnd = (threshold = this.options.scrollEndThreshold) => {
+      return this.getDistanceFromEnd() <= threshold;
+    };
+    this.getOffsetForAlignment = (toOffset, align, itemSize = 0) => {
+      if (!this.scrollElement)
+        return 0;
+      const size = this.getSize();
+      const scrollOffset = this.getScrollOffset();
+      if (align === "auto") {
+        align = toOffset >= scrollOffset + size ? "end" : "start";
+      }
+      if (align === "center") {
+        toOffset += (itemSize - size) / 2;
+      } else if (align === "end") {
+        toOffset -= size;
+      }
+      const maxOffset = this.getMaxScrollOffset();
+      return Math.max(Math.min(maxOffset, toOffset), 0);
+    };
+    this.getOffsetForIndex = (index, align = "auto") => {
+      index = Math.max(0, Math.min(index, this.options.count - 1));
+      const size = this.getSize();
+      const scrollOffset = this.getScrollOffset();
+      const item = this.measurementsCache[index];
+      if (!item)
+        return;
+      if (align === "auto") {
+        if (item.end >= scrollOffset + size - this.options.scrollPaddingEnd) {
+          align = "end";
+        } else if (item.start <= scrollOffset + this.options.scrollPaddingStart) {
+          align = "start";
+        } else {
+          return [scrollOffset, align];
+        }
+      }
+      if (align === "end" && index === this.options.count - 1) {
+        return [this.getMaxScrollOffset(), align];
+      }
+      const toOffset = align === "end" ? item.end + this.options.scrollPaddingEnd : item.start - this.options.scrollPaddingStart;
+      return [
+        this.getOffsetForAlignment(toOffset, align, item.size),
+        align
+      ];
+    };
+    this.scrollToOffset = (toOffset, { align = "start", behavior = "auto" } = {}) => {
+      const offset = this.getOffsetForAlignment(toOffset, align);
+      const now = this.now();
+      this.scrollState = {
+        index: null,
+        align,
+        behavior,
+        startedAt: now,
+        lastTargetOffset: offset,
+        stableFrames: 0
+      };
+      this._scrollToOffset(offset, { adjustments: undefined, behavior });
+      this.scheduleScrollReconcile();
+    };
+    this.scrollToIndex = (index, {
+      align: initialAlign = "auto",
+      behavior = "auto"
+    } = {}) => {
+      index = Math.max(0, Math.min(index, this.options.count - 1));
+      const offsetInfo = this.getOffsetForIndex(index, initialAlign);
+      if (!offsetInfo) {
+        return;
+      }
+      const [offset, align] = offsetInfo;
+      const now = this.now();
+      this.scrollState = {
+        index,
+        align,
+        behavior,
+        startedAt: now,
+        lastTargetOffset: offset,
+        stableFrames: 0
+      };
+      this._scrollToOffset(offset, { adjustments: undefined, behavior });
+      this.scheduleScrollReconcile();
+    };
+    this.scrollBy = (delta, { behavior = "auto" } = {}) => {
+      const offset = this.getScrollOffset() + delta;
+      const now = this.now();
+      this.scrollState = {
+        index: null,
+        align: "start",
+        behavior,
+        startedAt: now,
+        lastTargetOffset: offset,
+        stableFrames: 0
+      };
+      this._scrollToOffset(offset, { adjustments: undefined, behavior });
+      this.scheduleScrollReconcile();
+    };
+    this.scrollToEnd = ({ behavior = "auto" } = {}) => {
+      if (this.options.count > 0) {
+        this.scrollToIndex(this.options.count - 1, {
+          align: "end",
+          behavior
+        });
+        return;
+      }
+      this.scrollToOffset(Math.max(this.getTotalSize() - this.getSize(), 0), {
+        behavior
+      });
+    };
+    this.getTotalSize = () => {
+      var _a;
+      const measurements = this.getMeasurements();
+      let end;
+      if (measurements.length === 0) {
+        end = this.options.paddingStart;
+      } else if (this.options.lanes === 1) {
+        const lastIdx = measurements.length - 1;
+        const flat = this._flatMeasurements;
+        if (flat != null) {
+          end = flat[lastIdx * 2] + flat[lastIdx * 2 + 1];
+        } else {
+          end = ((_a = measurements[lastIdx]) == null ? undefined : _a.end) ?? 0;
+        }
+      } else {
+        const endByLane = Array(this.options.lanes).fill(null);
+        let endIndex = measurements.length - 1;
+        while (endIndex >= 0 && endByLane.some((val) => val === null)) {
+          const item = measurements[endIndex];
+          if (endByLane[item.lane] === null) {
+            endByLane[item.lane] = item.end;
+          }
+          endIndex--;
+        }
+        end = Math.max(...endByLane.filter((val) => val !== null));
+      }
+      return Math.max(end - this.options.scrollMargin + this.options.paddingEnd, 0);
+    };
+    this.takeSnapshot = () => {
+      const snapshot = [];
+      if (this.itemSizeCache.size === 0)
+        return snapshot;
+      const m = this.getMeasurements();
+      for (const item of m) {
+        if (item && this.itemSizeCache.has(item.key)) {
+          snapshot.push({
+            index: item.index,
+            key: item.key,
+            start: item.start,
+            size: item.size,
+            end: item.end,
+            lane: item.lane
+          });
+        }
+      }
+      return snapshot;
+    };
+    this._scrollToOffset = (offset, {
+      adjustments,
+      behavior
+    }) => {
+      this._intendedScrollOffset = offset + (adjustments ?? 0);
+      this.options.scrollToFn(offset, { behavior, adjustments }, this);
+    };
+    this.measure = () => {
+      this.pendingMin = null;
+      this.itemSizeCache.clear();
+      this.laneAssignments.clear();
+      this.itemSizeCacheVersion++;
+      this.notify(false);
+    };
+    this.setOptions(opts);
+  }
+  applyScrollAdjustment(delta, behavior) {
+    if (delta === 0)
+      return;
+    if (this.options.debug) {
+      console.info("correction", delta);
+    }
+    if (isIOSWebKit() && (this.isScrolling || this._iosTouching || this._iosJustTouchEnded)) {
+      this._iosDeferredAdjustment += delta;
+    } else {
+      this._scrollToOffset(this.getScrollOffset(), {
+        adjustments: this.scrollAdjustments += delta,
+        behavior
+      });
+    }
+  }
+  scheduleScrollReconcile() {
+    if (!this.targetWindow) {
+      this.scrollState = null;
+      return;
+    }
+    if (this.rafId != null)
+      return;
+    this.rafId = this.targetWindow.requestAnimationFrame(() => {
+      this.rafId = null;
+      this.reconcileScroll();
+    });
+  }
+  reconcileScroll() {
+    if (!this.scrollState)
+      return;
+    const el = this.scrollElement;
+    if (!el)
+      return;
+    const MAX_RECONCILE_MS = 5000;
+    if (this.now() - this.scrollState.startedAt > MAX_RECONCILE_MS) {
+      this.scrollState = null;
+      return;
+    }
+    const offsetInfo = this.scrollState.index != null ? this.getOffsetForIndex(this.scrollState.index, this.scrollState.align) : undefined;
+    const targetOffset = offsetInfo ? offsetInfo[0] : this.scrollState.lastTargetOffset;
+    const STABLE_FRAMES = 1;
+    const targetChanged = targetOffset !== this.scrollState.lastTargetOffset;
+    if (!targetChanged && approxEqual(targetOffset, this.getScrollOffset())) {
+      this.scrollState.stableFrames++;
+      if (this.scrollState.stableFrames >= STABLE_FRAMES) {
+        if (this.getScrollOffset() !== targetOffset) {
+          this._scrollToOffset(targetOffset, {
+            adjustments: undefined,
+            behavior: "auto"
+          });
+        }
+        this.scrollState = null;
+        return;
+      }
+    } else {
+      this.scrollState.stableFrames = 0;
+      if (targetChanged) {
+        const viewport = this.getSize() || 600;
+        const distance = Math.abs(targetOffset - this.getScrollOffset());
+        const keepSmooth = this.scrollState.behavior === "smooth" && distance > viewport;
+        this.scrollState.lastTargetOffset = targetOffset;
+        if (!keepSmooth) {
+          this.scrollState.behavior = "auto";
+        }
+        this._scrollToOffset(targetOffset, {
+          adjustments: undefined,
+          behavior: keepSmooth ? "smooth" : "auto"
+        });
+      }
+    }
+    this.scheduleScrollReconcile();
+  }
+}
+var findNearestBinarySearch = (low, high, getCurrentValue, value) => {
+  while (low <= high) {
+    const middle = (low + high) / 2 | 0;
+    const currentValue = getCurrentValue(middle);
+    if (currentValue < value) {
+      low = middle + 1;
+    } else if (currentValue > value) {
+      high = middle - 1;
+    } else {
+      return middle;
+    }
+  }
+  if (low > 0) {
+    return low - 1;
+  } else {
+    return 0;
+  }
+};
+function calculateRange({
+  measurements,
+  outerSize,
+  scrollOffset,
+  lanes,
+  flat
+}) {
+  const lastIndex = measurements.length - 1;
+  const getStart = flat ? (index) => flat[index * 2] : (index) => measurements[index].start;
+  const getEnd = flat ? (index) => flat[index * 2] + flat[index * 2 + 1] : (index) => measurements[index].end;
+  if (measurements.length <= lanes) {
+    return {
+      startIndex: 0,
+      endIndex: lastIndex
+    };
+  }
+  let startIndex = findNearestBinarySearch(0, lastIndex, getStart, scrollOffset);
+  let endIndex = startIndex;
+  if (lanes === 1) {
+    while (endIndex < lastIndex && getEnd(endIndex) < scrollOffset + outerSize) {
+      endIndex++;
+    }
+  } else if (lanes > 1) {
+    const endPerLane = Array(lanes).fill(0);
+    while (endIndex < lastIndex && endPerLane.some((pos) => pos < scrollOffset + outerSize)) {
+      const item = measurements[endIndex];
+      endPerLane[item.lane] = item.end;
+      endIndex++;
+    }
+    const startPerLane = Array(lanes).fill(scrollOffset + outerSize);
+    while (startIndex >= 0 && startPerLane.some((pos) => pos >= scrollOffset)) {
+      const item = measurements[startIndex];
+      startPerLane[item.lane] = item.start;
+      startIndex--;
+    }
+    startIndex = Math.max(0, startIndex - startIndex % lanes);
+    endIndex = Math.min(lastIndex, endIndex + (lanes - 1 - endIndex % lanes));
+  }
+  return { startIndex, endIndex };
+}
+
+// src/components/data-grid/_internal/virtualization-adapter.svelte.ts
+import { createSubscriber } from "svelte/reactivity";
+var defaultDataGridVirtualRowHeight = 44;
+
+class DataGridVirtualizationAdapter {
+  options;
+  #rowVirtualizer = null;
+  #columnVirtualizer = null;
+  #scrollElement = null;
+  #update = () => {};
+  #subscribe;
+  constructor(options) {
+    this.options = options;
+    this.#subscribe = createSubscriber((update) => {
+      if (typeof window === "undefined")
+        return;
+      this.#update = update;
+      this.#rowVirtualizer = new Virtualizer(this.#buildRowOptions());
+      this.#columnVirtualizer = new Virtualizer(this.#buildColumnOptions());
+      const cleanup = this.#rowVirtualizer._didMount();
+      const cleanupColumns = this.#columnVirtualizer._didMount();
+      this.#rowVirtualizer._willUpdate();
+      this.#columnVirtualizer._willUpdate();
+      update();
+      return () => {
+        cleanup();
+        cleanupColumns();
+        this.#rowVirtualizer = null;
+        this.#columnVirtualizer = null;
+      };
+    });
+  }
+  get virtualRows() {
+    if (typeof window === "undefined")
+      return [];
+    this.#subscribe();
+    this.#syncOptions();
+    const fallbackRows = this.#fallbackRows();
+    const virtualRows = this.#rowVirtualizer?.getVirtualItems();
+    const rows = this.#shouldUseFallbackRows(virtualRows, fallbackRows) ? fallbackRows : virtualRows ?? fallbackRows;
+    return rows.map(toDataGridVirtualItem);
+  }
+  get virtualColumns() {
+    if (typeof window === "undefined")
+      return [];
+    this.#subscribe();
+    this.#syncOptions();
+    const fallbackColumns = this.#fallbackColumns();
+    const virtualColumns = this.#columnVirtualizer?.getVirtualItems();
+    const columns = this.#shouldUseFallbackColumns(virtualColumns, fallbackColumns) ? fallbackColumns : virtualColumns ?? fallbackColumns;
+    return columns.map(toDataGridVirtualItem);
+  }
+  get totalHeight() {
+    if (typeof window === "undefined")
+      return this.options.getRowCount() * this.#rowHeight();
+    this.#subscribe();
+    this.#syncOptions();
+    return this.#rowVirtualizer?.getTotalSize() ?? this.options.getRowCount() * this.#rowHeight();
+  }
+  get totalWidth() {
+    if (typeof window === "undefined")
+      return this.#totalColumnWidth();
+    this.#subscribe();
+    this.#syncOptions();
+    return this.#columnVirtualizer?.getTotalSize() ?? this.#totalColumnWidth();
+  }
+  mountScrollContainer = (node) => {
+    this.#setScrollElement(node);
+    return () => {
+      if (this.#scrollElement === node) {
+        this.#setScrollElement(null);
+      }
+    };
+  };
+  measureElement = (node) => {
+    this.#syncOptions();
+    this.#rowVirtualizer?.measureElement(node);
+    return () => this.#rowVirtualizer?.measureElement(null);
+  };
+  refreshMeasurements() {
+    this.#subscribe();
+    this.#syncOptions();
+    this.#update();
+  }
+  scrollToRow(index, options = { align: "auto" }) {
+    this.#subscribe();
+    this.#syncOptions();
+    const element = this.#getScrollElement();
+    const shouldUseFallbackScroll = Boolean(element && (!this.#rowVirtualizer || element.clientHeight === 0));
+    this.#rowVirtualizer?.scrollToIndex(index, options);
+    if (!element || !shouldUseFallbackScroll)
+      return;
+    element.scrollTop = this.#scrollPaddingStart() + Math.max(0, index * this.#rowHeight());
+    element.dispatchEvent(new Event("scroll"));
+  }
+  scrollToColumn(index, options = { align: "auto" }) {
+    this.#subscribe();
+    this.#syncOptions();
+    const element = this.#getScrollElement();
+    const shouldUseFallbackScroll = Boolean(element && (!this.#columnVirtualizer || element.clientWidth === 0));
+    this.#columnVirtualizer?.scrollToIndex(index, options);
+    if (!element || !shouldUseFallbackScroll)
+      return;
+    element.scrollLeft = this.#columnStart(index);
+    element.dispatchEvent(new Event("scroll"));
+  }
+  #setScrollElement(element) {
+    if (this.#scrollElement === element)
+      return;
+    this.#scrollElement = element;
+    this.#syncOptions();
+    this.#update();
+  }
+  #syncOptions() {
+    if (this.#rowVirtualizer) {
+      this.#rowVirtualizer.setOptions(this.#buildRowOptions());
+      this.#rowVirtualizer._willUpdate();
+    }
+    if (this.#columnVirtualizer) {
+      this.#columnVirtualizer.setOptions(this.#buildColumnOptions());
+      this.#columnVirtualizer._willUpdate();
+    }
+  }
+  #buildRowOptions() {
+    return {
+      count: this.options.getRowCount(),
+      getScrollElement: this.#getScrollElement,
+      getItemKey: this.options.getRowKey,
+      estimateSize: () => this.#rowHeight(),
+      overscan: this.#overscan(),
+      initialRect: { width: 0, height: this.options.getInitialHeight() },
+      observeElementRect: this.#observeElementRect,
+      observeElementOffset: this.#observeElementOffset,
+      scrollToFn: this.#scrollToOffset,
+      measureElement: this.#measureElement,
+      onChange: () => this.#update(),
+      indexAttribute: "data-cinder-virtual-index",
+      scrollPaddingStart: this.#scrollPaddingStart()
+    };
+  }
+  #buildColumnOptions() {
+    return {
+      count: this.options.getColumnCount(),
+      getScrollElement: this.#getScrollElement,
+      getItemKey: this.options.getColumnKey,
+      estimateSize: (index) => this.#columnWidth(index),
+      overscan: this.#overscan(),
+      horizontal: true,
+      initialRect: { width: this.options.getInitialWidth(), height: 0 },
+      observeElementRect: this.#observeElementRect,
+      observeElementOffset: this.#observeElementHorizontalOffset,
+      scrollToFn: this.#scrollToHorizontalOffset,
+      onChange: () => this.#update(),
+      scrollPaddingStart: 0
+    };
+  }
+  #getScrollElement = () => this.#scrollElement ?? this.options.getScrollElement();
+  #scrollToOffset = (offset, { adjustments = 0, behavior }, instance) => {
+    const element = instance.scrollElement;
+    if (!element)
+      return;
+    const top = this.#scrollPaddingStart() + offset + adjustments;
+    if (typeof element.scrollTo === "function") {
+      element.scrollTo(behavior ? { top, behavior } : { top });
+      return;
+    }
+    element.scrollTop = top;
+  };
+  #scrollToHorizontalOffset = (offset, { adjustments = 0, behavior }, instance) => {
+    const element = instance.scrollElement;
+    if (!element)
+      return;
+    const left = offset + adjustments;
+    if (typeof element.scrollTo === "function") {
+      element.scrollTo(behavior ? { left, behavior } : { left });
+      return;
+    }
+    element.scrollLeft = left;
+  };
+  #observeElementRect = (instance, callback) => {
+    const element = instance.scrollElement;
+    if (!element)
+      return () => {};
+    const notify = () => {
+      const rect = element.getBoundingClientRect();
+      const scrollPaddingStart = this.#scrollPaddingStart();
+      const height = rect.height || element.clientHeight || this.options.getInitialHeight();
+      const width = rect.width || element.clientWidth || this.options.getInitialWidth();
+      callback({
+        width: Math.max(0, width - this.#scrollPaddingInlineStart() - this.#scrollPaddingInlineEnd()) || this.options.getInitialWidth(),
+        height: Math.max(0, height - scrollPaddingStart) || this.options.getInitialHeight()
+      });
+    };
+    notify();
+    if (typeof ResizeObserver === "undefined")
+      return () => {};
+    const observer = new ResizeObserver(notify);
+    observer.observe(element);
+    return () => observer.disconnect();
+  };
+  #observeElementOffset = (instance, callback) => {
+    const element = instance.scrollElement;
+    if (!element)
+      return () => {};
+    const notify = () => {
+      callback(this.#scrollOffset(element), true);
+      this.#update();
+    };
+    callback(this.#scrollOffset(element), false);
+    element.addEventListener("scroll", notify, { passive: true });
+    return () => element.removeEventListener("scroll", notify);
+  };
+  #observeElementHorizontalOffset = (instance, callback) => {
+    const element = instance.scrollElement;
+    if (!element)
+      return () => {};
+    const notify = () => {
+      callback(this.#horizontalScrollOffset(element), true);
+      this.#update();
+    };
+    callback(this.#horizontalScrollOffset(element), false);
+    element.addEventListener("scroll", notify, { passive: true });
+    return () => element.removeEventListener("scroll", notify);
+  };
+  #measureElement = (element) => {
+    const rect = element.getBoundingClientRect();
+    return rect.height || this.#rowHeight();
+  };
+  #fallbackRows() {
+    const count = this.options.getRowCount();
+    if (count === 0)
+      return [];
+    const rowHeight = this.#rowHeight();
+    const overscan = this.#overscan();
+    const scrollTop = this.#scrollOffset(this.#getScrollElement());
+    const visibleCount = Math.ceil(this.#viewportHeight() / rowHeight);
+    const startIndex = Math.max(0, Math.floor(scrollTop / rowHeight) - overscan);
+    const itemCount = Math.min(count - startIndex, visibleCount + overscan * 2);
+    return Array.from({ length: itemCount }, (_, offset) => {
+      const index = startIndex + offset;
+      return {
+        key: this.options.getRowKey(index),
+        index,
+        start: index * rowHeight,
+        end: (index + 1) * rowHeight,
+        size: rowHeight,
+        lane: 0
+      };
+    });
+  }
+  #fallbackColumns() {
+    const count = this.options.getColumnCount();
+    if (count === 0)
+      return [];
+    const overscan = this.#overscan();
+    const scrollLeft = this.#horizontalScrollOffset(this.#getScrollElement());
+    const viewportWidth = this.#viewportWidth();
+    const startIndex = Math.max(0, this.#columnIndexAtOffset(scrollLeft) - overscan);
+    const items = [];
+    let index = startIndex;
+    let start = this.#columnStart(index);
+    let end = start;
+    const maxEnd = scrollLeft + viewportWidth;
+    while (index < count && (items.length < overscan * 2 || end <= maxEnd + this.#columnWidth(index))) {
+      const size = this.#columnWidth(index);
+      end = start + size;
+      items.push({
+        key: this.options.getColumnKey(index),
+        index,
+        start,
+        end,
+        size,
+        lane: 0
+      });
+      index += 1;
+      start = end;
+    }
+    return items;
+  }
+  #shouldUseFallbackRows(virtualizerRows, fallbackRows) {
+    if (!virtualizerRows || fallbackRows.length === 0)
+      return false;
+    if (virtualizerRows.length === 0)
+      return true;
+    const scrollTop = this.#scrollOffset(this.#getScrollElement());
+    if (scrollTop <= 0)
+      return false;
+    const firstVirtualizerIndex = virtualizerRows[0]?.index ?? 0;
+    const firstFallbackIndex = fallbackRows[0]?.index ?? 0;
+    return Math.abs(firstVirtualizerIndex - firstFallbackIndex) > 1;
+  }
+  #shouldUseFallbackColumns(virtualizerColumns, fallbackColumns) {
+    if (!virtualizerColumns || fallbackColumns.length === 0)
+      return false;
+    if (virtualizerColumns.length === 0)
+      return true;
+    const scrollLeft = this.#horizontalScrollOffset(this.#getScrollElement());
+    if (scrollLeft <= 0)
+      return false;
+    const firstVirtualizerIndex = virtualizerColumns[0]?.index ?? 0;
+    const firstFallbackIndex = fallbackColumns[0]?.index ?? 0;
+    return Math.abs(firstVirtualizerIndex - firstFallbackIndex) > 1;
+  }
+  #rowHeight() {
+    const rowHeight = this.options.getRowHeight();
+    return Number.isFinite(rowHeight) && rowHeight > 0 ? rowHeight : defaultDataGridVirtualRowHeight;
+  }
+  #viewportHeight() {
+    const element = this.#getScrollElement();
+    if (!element)
+      return this.options.getInitialHeight();
+    const rect = element.getBoundingClientRect();
+    const height = rect.height || element.clientHeight || this.options.getInitialHeight();
+    return Math.max(0, height - this.#scrollPaddingStart()) || this.options.getInitialHeight();
+  }
+  #viewportWidth() {
+    const element = this.#getScrollElement();
+    if (!element)
+      return this.options.getInitialWidth();
+    const rect = element.getBoundingClientRect();
+    const width = rect.width || element.clientWidth || this.options.getInitialWidth();
+    return Math.max(0, width - this.#scrollPaddingInlineStart() - this.#scrollPaddingInlineEnd()) || this.options.getInitialWidth();
+  }
+  #scrollOffset(element) {
+    if (!element)
+      return 0;
+    return Math.max(0, element.scrollTop - this.#scrollPaddingStart());
+  }
+  #horizontalScrollOffset(element) {
+    if (!element)
+      return 0;
+    return Math.max(0, element.scrollLeft);
+  }
+  #scrollPaddingStart() {
+    const value = this.options.getScrollPaddingStart();
+    return Number.isFinite(value) && value > 0 ? value : 0;
+  }
+  #scrollPaddingInlineStart() {
+    const value = this.options.getScrollPaddingInlineStart();
+    return Number.isFinite(value) && value > 0 ? value : 0;
+  }
+  #scrollPaddingInlineEnd() {
+    const value = this.options.getScrollPaddingInlineEnd();
+    return Number.isFinite(value) && value > 0 ? value : 0;
+  }
+  #overscan() {
+    return Math.max(0, this.options.getOverscan());
+  }
+  #columnWidth(index) {
+    const width = this.options.getColumnWidth(index);
+    return Number.isFinite(width) && width > 0 ? width : 1;
+  }
+  #totalColumnWidth() {
+    let totalWidth = 0;
+    for (let index = 0;index < this.options.getColumnCount(); index += 1) {
+      totalWidth += this.#columnWidth(index);
+    }
+    return totalWidth;
+  }
+  #columnStart(targetIndex) {
+    let start = 0;
+    for (let index = 0;index < targetIndex; index += 1) {
+      start += this.#columnWidth(index);
+    }
+    return start;
+  }
+  #columnIndexAtOffset(offset) {
+    let start = 0;
+    for (let index = 0;index < this.options.getColumnCount(); index += 1) {
+      const end = start + this.#columnWidth(index);
+      if (end > offset)
+        return index;
+      start = end;
+    }
+    return Math.max(0, this.options.getColumnCount() - 1);
+  }
+}
+function toDataGridVirtualItem(item) {
+  return {
+    index: item.index,
+    start: item.start,
+    size: item.size,
+    key: typeof item.key === "number" || typeof item.key === "string" ? item.key : String(item.key)
+  };
+}
+
+// src/components/data-grid/data-grid.svelte
+var root_7 = $4.from_html(`<span class="cinder-data-grid__sort-priority" aria-hidden="true"> </span>`);
+var root_2 = $4.from_html(`<button class="cinder-data-grid__sort-button" type="button"><span class="cinder-data-grid__header-content"><!></span> <span class="cinder-data-grid__sort-indicator" aria-hidden="true"><!></span> <!> <span class="cinder-sr-only"> </span></button>`);
+var root_1 = $4.from_html(`<div class="cinder-data-grid__header-cell" role="columnheader"><!></div>`);
+var root_11 = $4.from_html(`<div class="cinder-data-grid__cell" role="gridcell" tabindex="-1"><!></div>`);
+var root_10 = $4.from_html(`<div role="row"></div>`);
+var root = $4.from_html(`<div><div class="cinder-data-grid__header-row" role="row" aria-rowindex="1"></div> <div class="cinder-data-grid__body" role="rowgroup"></div></div> <div class="cinder-sr-only cinder-data-grid__live-region" role="status" aria-live="polite" aria-atomic="true"> </div>`, 1);
+function Data_grid($$anchor, $$props) {
+  const gridId = $4.props_id();
+  $4.push($$props, true);
+  const interactiveDescendantSelector = [
+    "a[href]",
+    "button",
+    "input",
+    "select",
+    "textarea",
+    '[contenteditable=""]',
+    '[contenteditable="true"]',
+    '[tabindex]:not([tabindex="-1"])'
+  ].join(",");
+  const defaultVirtualRowHeight = 44;
+  let density = $4.prop($$props, "density", 3, "comfortable"), stickyHeader = $4.prop($$props, "stickyHeader", 3, true), virtualizeRows = $4.prop($$props, "virtualizeRows", 3, false), virtualizeColumns = $4.prop($$props, "virtualizeColumns", 3, false), selectionMode = $4.prop($$props, "selectionMode", 3, "none"), selectionModel = $4.prop($$props, "selectionModel", 15, undefined), sortModel = $4.prop($$props, "sortModel", 31, () => $4.proxy([])), rest = $4.rest_props($$props, [
+    "$$slots",
+    "$$events",
+    "$$legacy",
+    "rows",
+    "columns",
+    "getRowId",
+    "density",
+    "stickyHeader",
+    "virtualizeRows",
+    "virtualizeColumns",
+    "rowHeight",
+    "columnOrder",
+    "columnSizing",
+    "columnPinning",
+    "selectionMode",
+    "selectionModel",
+    "onSelectionModelChange",
+    "sortModel",
+    "onSortModelChange",
+    "rowClass",
+    "getRowAriaLabel",
+    "class",
+    "aria-label",
+    "aria-labelledby",
+    "onkeydown"
+  ]);
+  const columnModel = new DataGridColumnModel({
+    columns: () => $$props.columns,
+    columnOrder: () => $$props.columnOrder,
+    columnSizing: () => $$props.columnSizing,
+    columnPinning: () => $$props.columnPinning
+  });
+  let liveRegionMessage = $4.state("");
+  let renderedLiveRegionMessage = $4.state("");
+  let liveRegionAnnouncementSequence = $4.state(0);
+  let measuredGridWidth = $4.state(undefined);
+  let isRightToLeft = $4.state(false);
+  const activeSortModel = $4.derived(() => getActiveDataGridSortModel(columnModel.orderedColumns, sortModel()));
+  const sortedRowIndices = $4.derived(() => getSortedDataGridRowIndices($$props.rows, columnModel.orderedColumns, $4.get(activeSortModel)));
+  const keyedRows = $4.derived(() => {
+    const records = $$props.rows.map((row, rowIndex) => ({ row, rowId: $$props.getRowId(row), rowIndex }));
+    const rowIdCounts = new Map;
+    for (const { rowId } of records) {
+      rowIdCounts.set(rowId, (rowIdCounts.get(rowId) ?? 0) + 1);
+    }
+    const rowIdOccurrences = new Map;
+    return records.map((record) => {
+      const occurrence = rowIdOccurrences.get(record.rowId) ?? 0;
+      rowIdOccurrences.set(record.rowId, occurrence + 1);
+      const hasDuplicateRowId = (rowIdCounts.get(record.rowId) ?? 0) > 1;
+      const uniqueRowId = hasDuplicateRowId ? `${record.rowId}\x00${occurrence}` : record.rowId;
+      return { ...record, rowDomId: uniqueRowId, rowKey: uniqueRowId };
+    });
+  });
+  const sortedKeyedRows = $4.derived(() => $4.get(sortedRowIndices).flatMap((rowIndex) => $4.get(keyedRows)[rowIndex] ?? []));
+  const resolvedRowHeight = $4.derived(() => resolveVirtualRowHeight($$props.rowHeight));
+  const shouldWarnVirtualRowHeightFallback = $4.derived(() => virtualizeRows() && !isValidVirtualRowHeight($$props.rowHeight));
+  const shouldVirtualizeRows = $4.derived(() => virtualizeRows() && $4.get(sortedKeyedRows).length > 0);
+  const shouldVirtualizeColumns = $4.derived(() => virtualizeColumns() && columnModel.unpinnedColumns.length > 0 && $4.get(measuredGridWidth) !== undefined && $4.get(measuredGridWidth) > 0 && !$4.get(isRightToLeft) && typeof window !== "undefined");
+  const rowVirtualizer = new DataGridVirtualizationAdapter({
+    getScrollElement: () => gridElement ?? null,
+    getRowCount: () => $4.get(sortedKeyedRows).length,
+    getRowKey: (index) => $4.get(sortedKeyedRows)[index]?.rowKey ?? index,
+    getRowHeight: () => $4.get(resolvedRowHeight),
+    getColumnCount: () => columnModel.unpinnedColumns.length,
+    getColumnKey: (index) => columnModel.unpinnedColumns[index]?.key ?? index,
+    getColumnWidth: (index) => columnModel.unpinnedColumns[index]?.width ?? 150,
+    getOverscan: () => 5,
+    getInitialHeight: () => $4.get(resolvedRowHeight) * 10,
+    getInitialWidth: () => $4.get(measuredGridWidth) ?? 1000,
+    getScrollPaddingStart: () => getHeaderHeight(),
+    getScrollPaddingInlineStart: () => columnModel.leftPinnedWidth,
+    getScrollPaddingInlineEnd: () => columnModel.rightPinnedWidth
+  });
+  const observeHeaderSize = (node) => {
+    if (typeof ResizeObserver === "undefined")
+      return;
+    let previousHeight = getElementHeight(node);
+    const observer = new ResizeObserver(() => {
+      const nextHeight = getElementHeight(node);
+      if (nextHeight === previousHeight)
+        return;
+      previousHeight = nextHeight;
+      rowVirtualizer.refreshMeasurements();
+    });
+    observer.observe(node);
+    return () => observer.disconnect();
+  };
+  const observeGridSize = (node) => {
+    const updateGridMeasurement = () => {
+      const rect = node.getBoundingClientRect();
+      $4.set(measuredGridWidth, rect.width || node.clientWidth || undefined, true);
+      $4.set(isRightToLeft, getComputedStyle(node).direction === "rtl");
+    };
+    updateGridMeasurement();
+    if (typeof ResizeObserver === "undefined")
+      return;
+    const observer = new ResizeObserver(updateGridMeasurement);
+    observer.observe(node);
+    return () => observer.disconnect();
+  };
+  const delegateBodyEvents = (node) => {
+    node.addEventListener("click", handleBodyClick);
+    node.addEventListener("keydown", handleBodyKeydown);
+    return () => {
+      node.removeEventListener("click", handleBodyClick);
+      node.removeEventListener("keydown", handleBodyKeydown);
+    };
+  };
+  const virtualRows = $4.derived(() => rowVirtualizer.virtualRows);
+  const virtualColumns = $4.derived(() => rowVirtualizer.virtualColumns);
+  const virtualColumnLeadingSpacer = $4.derived(() => $4.get(virtualColumns)[0]?.start ?? 0);
+  const virtualColumnTrailingSpacer = $4.derived(() => {
+    const lastColumn = $4.get(virtualColumns).at(-1);
+    if (!lastColumn)
+      return 0;
+    return Math.max(0, rowVirtualizer.totalWidth - (lastColumn.start + lastColumn.size));
+  });
+  const gridContentWidth = $4.derived(() => $4.get(shouldVirtualizeColumns) ? columnModel.leftPinnedWidth + rowVirtualizer.totalWidth + columnModel.rightPinnedWidth : undefined);
+  const gridTemplateColumns = $4.derived(() => {
+    if (!$4.get(shouldVirtualizeColumns)) {
+      return columnModel.renderColumns.map((column) => `${column.width}px`).join(" ");
+    }
+    return [
+      ...columnModel.leftPinnedColumns.map((column) => `${column.width}px`),
+      `${$4.get(virtualColumnLeadingSpacer)}px`,
+      ...$4.get(virtualColumns).map((item) => `${item.size}px`),
+      `${$4.get(virtualColumnTrailingSpacer)}px`,
+      ...columnModel.rightPinnedColumns.map((column) => `${column.width}px`)
+    ].join(" ");
+  });
+  const renderedColumns = $4.derived(() => {
+    if (!$4.get(shouldVirtualizeColumns))
+      return columnModel.renderColumns;
+    const virtualUnpinnedColumns = $4.get(virtualColumns).flatMap((item) => {
+      const column = columnModel.unpinnedColumns[item.index];
+      return column ? [column] : [];
+    });
+    return [
+      ...columnModel.leftPinnedColumns,
+      ...virtualUnpinnedColumns,
+      ...columnModel.rightPinnedColumns
+    ];
+  });
+  const renderedRows = $4.derived(() => {
+    if (!$4.get(shouldVirtualizeRows)) {
+      return $4.get(sortedKeyedRows).map((keyedRow, visualRowIndex) => ({
+        keyedRow,
+        visualRowIndex,
+        start: 0,
+        size: $4.get(resolvedRowHeight),
+        virtualized: false
+      }));
+    }
+    return $4.get(virtualRows).flatMap((item) => {
+      const keyedRow = $4.get(sortedKeyedRows)[item.index];
+      return keyedRow ? [
+        {
+          keyedRow,
+          visualRowIndex: item.index,
+          start: item.start,
+          size: item.size,
+          virtualized: true
+        }
+      ] : [];
+    });
+  });
+  const bodyHeight = $4.derived(() => $4.get(shouldVirtualizeRows) ? `${rowVirtualizer.totalHeight}px` : undefined);
+  const duplicateRowIds = $4.derived(() => {
+    const seen = new Set;
+    const duplicates = new Set;
+    for (const { rowId } of $4.get(keyedRows)) {
+      if (seen.has(rowId))
+        duplicates.add(rowId);
+      else
+        seen.add(rowId);
+    }
+    return [...duplicates];
+  });
+  const firstRowDomId = $4.derived(() => $4.get(sortedKeyedRows)[0]?.rowDomId);
+  const firstColumnKey = $4.derived(() => columnModel.renderColumns[0]?.key);
+  const rowDomIds = $4.derived(() => $4.get(sortedKeyedRows).map((row) => row.rowDomId));
+  const columnKeys = $4.derived(() => columnModel.renderColumns.map((column) => column.key));
+  let requestedActiveRowIndex = $4.state(0);
+  let requestedActiveColumnKey = $4.state(undefined);
+  const selectionState = new DataGridSelectionModel({
+    rowIds: () => $4.get(rowDomIds),
+    columnKeys: () => $4.get(columnKeys)
+  });
+  const activeRowIndex = $4.derived(() => $4.get(sortedKeyedRows).length > 0 ? Math.min($4.get(requestedActiveRowIndex), $4.get(sortedKeyedRows).length - 1) : 0);
+  const activeColumnIndex = $4.derived(() => {
+    const index = columnModel.renderColumns.findIndex((column) => column.key === $4.get(requestedActiveColumnKey));
+    return index >= 0 ? index : 0;
+  });
+  const activeRowDomId = $4.derived(() => $4.get(sortedKeyedRows).length > 0 ? $4.get(sortedKeyedRows)[Math.min($4.get(activeRowIndex), $4.get(sortedKeyedRows).length - 1)]?.rowDomId : $4.get(firstRowDomId));
+  const activeColumnKey = $4.derived(() => columnModel.renderColumns[$4.get(activeColumnIndex)]?.key);
+  const canExposeActiveCell = $4.derived(() => !($4.get(shouldVirtualizeRows) && typeof window === "undefined"));
+  const activeCellId = $4.derived(() => $4.get(canExposeActiveCell) && $4.get(activeRowDomId) !== undefined && $4.get(firstColumnKey) !== undefined ? getCellId($4.get(activeRowDomId), $4.get(activeColumnKey) ?? $4.get(firstColumnKey)) : undefined);
+  const activeCellCoordinates = $4.derived(() => $4.get(activeRowDomId) !== undefined && $4.get(activeColumnKey) !== undefined ? {
+    rowId: $4.get(activeRowDomId),
+    columnKey: $4.get(activeColumnKey)
+  } : undefined);
+  const resolvedSelectionModel = $4.derived(() => selectionModel() ?? []);
+  const selectedRowIds = $4.derived(() => selectionMode() === "none" ? new Set : new Set($4.get(resolvedSelectionModel)));
+  const resolvedAriaLabel = $4.derived(() => typeof $$props["aria-label"] === "string" && $$props["aria-label"].trim().length > 0 ? $$props["aria-label"] : undefined);
+  const resolvedAriaLabelledBy = $4.derived(() => typeof $$props["aria-labelledby"] === "string" && $$props["aria-labelledby"].trim().length > 0 ? $$props["aria-labelledby"] : undefined);
+  let hasWarnedNoLabel = false;
+  let warnedDuplicateRowIdsSignature;
+  let previousActiveCellId;
+  let previousActiveVirtualRowIndex;
+  let previousActiveVirtualColumnIndex;
+  let previousSelectionRowIds;
+  let previousSelectionColumnKeys;
+  let gridElement;
+  let headerElement;
+  let liveRegionTimeoutId;
+  let liveRegionVersion = 0;
+  let warnedVirtualRowHeightFallback = false;
+  $4.user_effect(() => {
+    if (!$4.get(resolvedAriaLabel) && !$4.get(resolvedAriaLabelledBy) && !hasWarnedNoLabel) {
+      hasWarnedNoLabel = true;
+      devWarn("[cinder-data-grid] DataGrid requires either aria-label or aria-labelledby.");
+    }
+  });
+  $4.user_effect(() => {
+    if ($4.get(duplicateRowIds).length === 0) {
+      warnedDuplicateRowIdsSignature = undefined;
+      return;
+    }
+    const signature = JSON.stringify($4.get(duplicateRowIds));
+    if (signature === warnedDuplicateRowIdsSignature)
+      return;
+    warnedDuplicateRowIdsSignature = signature;
+    devWarn(`[cinder-data-grid] getRowId returned duplicate row ids: ${$4.get(duplicateRowIds).map((rowId) => JSON.stringify(rowId)).join(", ")}. Row ids must be unique.`);
+  });
+  $4.user_effect(() => {
+    if (!$4.get(shouldWarnVirtualRowHeightFallback) || warnedVirtualRowHeightFallback)
+      return;
+    warnedVirtualRowHeightFallback = true;
+    devWarn("[cinder-data-grid] DataGrid row virtualization is using the default rowHeight of 44px. Pass a positive finite rowHeight to match your row layout.");
+  });
+  $4.user_effect(() => {
+    const nextMessage = $4.get(liveRegionMessage);
+    $4.get(liveRegionAnnouncementSequence);
+    const currentVersion = ++liveRegionVersion;
+    if (liveRegionTimeoutId) {
+      clearTimeout(liveRegionTimeoutId);
+      liveRegionTimeoutId = undefined;
+    }
+    $4.set(renderedLiveRegionMessage, "");
+    if (nextMessage === "")
+      return;
+    liveRegionTimeoutId = setTimeout(() => {
+      if (liveRegionVersion !== currentVersion)
+        return;
+      $4.set(renderedLiveRegionMessage, nextMessage, true);
+      liveRegionTimeoutId = undefined;
+    }, 0);
+    return () => {
+      if (!liveRegionTimeoutId)
+        return;
+      clearTimeout(liveRegionTimeoutId);
+      liveRegionTimeoutId = undefined;
+    };
+  });
+  $4.user_effect(() => {
+    const cellId = $4.get(activeCellId);
+    const activeVirtualRowIndex = $4.get(shouldVirtualizeRows) ? $4.get(activeRowIndex) : undefined;
+    const activeVirtualColumnIndex = $4.get(shouldVirtualizeColumns) ? getUnpinnedColumnIndex($4.get(activeColumnKey)) : undefined;
+    if (cellId === undefined || cellId === previousActiveCellId && activeVirtualRowIndex === previousActiveVirtualRowIndex && activeVirtualColumnIndex === previousActiveVirtualColumnIndex) {
+      previousActiveCellId = cellId;
+      previousActiveVirtualRowIndex = activeVirtualRowIndex;
+      previousActiveVirtualColumnIndex = activeVirtualColumnIndex;
+      return;
+    }
+    if (previousActiveCellId === undefined && previousActiveVirtualRowIndex === undefined && previousActiveVirtualColumnIndex === undefined) {
+      previousActiveCellId = cellId;
+      previousActiveVirtualRowIndex = activeVirtualRowIndex;
+      previousActiveVirtualColumnIndex = activeVirtualColumnIndex;
+      return;
+    }
+    previousActiveCellId = cellId;
+    previousActiveVirtualRowIndex = activeVirtualRowIndex;
+    previousActiveVirtualColumnIndex = activeVirtualColumnIndex;
+    if ($4.get(shouldVirtualizeRows)) {
+      rowVirtualizer.scrollToRow($4.get(activeRowIndex));
+    }
+    if ($4.get(shouldVirtualizeColumns) && activeVirtualColumnIndex !== undefined) {
+      rowVirtualizer.scrollToColumn(activeVirtualColumnIndex);
+    }
+    scrollActiveCellIntoView(cellId);
+  });
+  $4.user_effect(() => {
+    const previousRowIds = previousSelectionRowIds;
+    const previousColumnKeys = previousSelectionColumnKeys;
+    const isInitialSelectionReconciliation = previousRowIds === undefined || previousColumnKeys === undefined;
+    const didSelectionGeometryChange = !isInitialSelectionReconciliation && (didStringArrayChange(previousRowIds, $4.get(rowDomIds)) || didStringArrayChange(previousColumnKeys, $4.get(columnKeys)));
+    previousSelectionRowIds = $4.get(rowDomIds);
+    previousSelectionColumnKeys = $4.get(columnKeys);
+    if (!isInitialSelectionReconciliation && !didSelectionGeometryChange)
+      return;
+    selectionState.reconcile($4.get(activeCellCoordinates));
+    if (!didSelectionGeometryChange)
+      return;
+    syncRequestedActiveCell();
+  });
+  function syncRequestedActiveCell() {
+    const activeCell = selectionState.activeCell;
+    if (!activeCell)
+      return;
+    const nextActiveRowIndex = $4.get(rowDomIds).indexOf(activeCell.rowId);
+    if (nextActiveRowIndex >= 0 && $4.get(requestedActiveRowIndex) !== nextActiveRowIndex) {
+      $4.set(requestedActiveRowIndex, nextActiveRowIndex, true);
+    }
+    if ($4.get(requestedActiveColumnKey) !== activeCell.columnKey) {
+      $4.set(requestedActiveColumnKey, activeCell.columnKey, true);
+    }
+  }
+  function didStringArrayChange(previousValues, nextValues) {
+    if (previousValues.length !== nextValues.length)
+      return true;
+    return previousValues.some((value, index) => value !== nextValues[index]);
+  }
+  function getCellId(rowId, columnKey) {
+    return `${gridId}-cell-r-${toDomIdSegment(rowId)}-c-${toDomIdSegment(columnKey)}`;
+  }
+  function toDomIdSegment(value) {
+    const segment = Array.from(value, (character) => character.codePointAt(0)?.toString(16) ?? "0");
+    return segment.length > 0 ? segment.join("_") : "empty";
+  }
+  function isValidVirtualRowHeight(value) {
+    return typeof value === "number" && Number.isFinite(value) && value > 0;
+  }
+  function resolveVirtualRowHeight(value) {
+    return isValidVirtualRowHeight(value) ? value : defaultVirtualRowHeight;
+  }
+  function formatDataGridValue(value) {
+    if (value === null || value === undefined)
+      return "";
+    if (value instanceof Date)
+      return value.toISOString();
+    return String(value);
+  }
+  function getRowClass(row, rowIndex) {
+    if (typeof $$props.rowClass === "function")
+      return $$props.rowClass(row, rowIndex);
+    return $$props.rowClass;
+  }
+  function getResolvedRowAriaLabel(row, rowIndex) {
+    const label = $$props.getRowAriaLabel?.(row, rowIndex);
+    return typeof label === "string" && label.trim().length > 0 ? label : undefined;
+  }
+  function getCellStyle(column) {
+    const customProperties = [
+      `--_cinder-data-grid-column-width: ${column.width}px`,
+      `grid-column: ${getCellGridColumn(column)}`
+    ];
+    if (column.pin === "left") {
+      customProperties.push(`--_cinder-data-grid-pin-left-offset: ${column.pinOffset}px`);
+    }
+    if (column.pin === "right") {
+      customProperties.push(`--_cinder-data-grid-pin-right-offset: ${column.pinOffset}px`);
+    }
+    return customProperties.join("; ");
+  }
+  function getRowStyle(row) {
+    if (!row.virtualized)
+      return;
+    return [
+      `--_cinder-data-grid-row-translate-y: ${row.start}px`,
+      `--_cinder-data-grid-row-height: ${row.size}px`
+    ].join("; ");
+  }
+  function getHeaderHeight() {
+    return headerElement ? getElementHeight(headerElement) : 0;
+  }
+  function getElementHeight(element) {
+    const offsetHeight = element.offsetHeight;
+    if (offsetHeight > 0)
+      return offsetHeight;
+    return element.getBoundingClientRect().height || 0;
+  }
+  function getColumnSortModelItem(columnKey) {
+    return $4.get(activeSortModel).find((item) => item.key === columnKey);
+  }
+  function getColumnSortPriority(columnKey) {
+    const index = $4.get(activeSortModel).findIndex((item) => item.key === columnKey);
+    return index >= 0 && $4.get(activeSortModel).length > 1 ? index + 1 : undefined;
+  }
+  function getHeaderAriaSort(column, sortItem) {
+    return $4.get(activeSortModel)[0]?.key === column.key ? sortItem?.direction : undefined;
+  }
+  function getSortStateDescription(sortItem, sortPriority) {
+    if (!sortItem)
+      return "not sorted";
+    if (sortPriority === undefined)
+      return `sorted ${sortItem.direction}`;
+    return `sorted ${sortItem.direction}, priority ${sortPriority}`;
+  }
+  function handleColumnHeaderClick(column, event) {
+    if (!column.sortable)
+      return;
+    const nextSortModel = getNextDataGridSortModel($4.get(activeSortModel), column.key, event.shiftKey);
+    sortModel(nextSortModel);
+    $$props.onSortModelChange?.(nextSortModel);
+  }
+  function getCellCoordinate(rowIndex, columnIndex) {
+    const rowId = $4.get(rowDomIds)[Math.min(Math.max(rowIndex, 0), $4.get(rowDomIds).length - 1)];
+    const columnKey = $4.get(columnKeys)[Math.min(Math.max(columnIndex, 0), $4.get(columnKeys).length - 1)];
+    if (rowId === undefined || columnKey === undefined)
+      return;
+    return { rowId, columnKey };
+  }
+  function getUnpinnedColumnIndex(columnKey) {
+    if (columnKey === undefined)
+      return;
+    const index = columnModel.unpinnedColumns.findIndex((column) => column.key === columnKey);
+    return index >= 0 ? index : undefined;
+  }
+  function getCellGridColumn(column) {
+    if (!$4.get(shouldVirtualizeColumns))
+      return column.renderIndex;
+    const leftPinnedCount = columnModel.leftPinnedColumns.length;
+    if (column.pin === "left") {
+      const leftPinnedIndex = columnModel.leftPinnedColumns.findIndex((item) => item.key === column.key);
+      return Math.max(0, leftPinnedIndex) + 1;
+    }
+    const visibleUnpinnedIndex = $4.get(virtualColumns).findIndex((item) => item.key === column.key);
+    if (visibleUnpinnedIndex >= 0)
+      return leftPinnedCount + 2 + visibleUnpinnedIndex;
+    const rightPinnedIndex = columnModel.rightPinnedColumns.findIndex((item) => item.key === column.key);
+    return leftPinnedCount + 2 + $4.get(virtualColumns).length + 1 + Math.max(0, rightPinnedIndex);
+  }
+  async function scrollActiveCellIntoView(cellId) {
+    await tick();
+    document.getElementById(cellId)?.scrollIntoView({ block: "nearest", inline: "nearest" });
+  }
+  function moveActiveCell(rowIndex, columnIndex, extend = false) {
+    if ($4.get(sortedKeyedRows).length === 0 || columnModel.renderColumns.length === 0)
+      return;
+    $4.set(requestedActiveRowIndex, Math.min(Math.max(rowIndex, 0), $4.get(sortedKeyedRows).length - 1), true);
+    $4.set(requestedActiveColumnKey, columnModel.renderColumns[Math.min(Math.max(columnIndex, 0), columnModel.renderColumns.length - 1)]?.key, true);
+    const cell = getCellCoordinate(rowIndex, columnIndex);
+    if (cell)
+      selectionState.setActiveCell(cell, { extend });
+  }
+  function setSelectionModel(nextSelectionModel) {
+    selectionModel(nextSelectionModel);
+    $$props.onSelectionModelChange?.(nextSelectionModel);
+  }
+  function updateRowSelection(rowId, event) {
+    if (selectionMode() === "none")
+      return;
+    if (selectionMode() === "single") {
+      setSelectionModel([rowId]);
+      return;
+    }
+    const isToggle = event.ctrlKey || event.metaKey;
+    if (event.shiftKey)
+      return;
+    if (!isToggle) {
+      setSelectionModel([rowId]);
+      return;
+    }
+    const nextSelection = new Set($4.get(resolvedSelectionModel));
+    if (nextSelection.has(rowId))
+      nextSelection.delete(rowId);
+    else
+      nextSelection.add(rowId);
+    setSelectionModel([...nextSelection]);
+  }
+  function selectActiveCell(event) {
+    const row = $4.get(sortedKeyedRows)[$4.get(activeRowIndex)];
+    if (!row || $4.get(activeColumnKey) === undefined || $4.get(activeRowDomId) === undefined)
+      return;
+    selectionState.setActiveCell({
+      rowId: $4.get(activeRowDomId),
+      columnKey: $4.get(activeColumnKey)
+    }, {
+      extend: event.shiftKey,
+      toggle: event.ctrlKey || event.metaKey
+    });
+    updateRowSelection(row.rowId, event);
+  }
+  function collapseSelectionToActiveCell() {
+    selectionState.collapseToActiveCell();
+    if (selectionMode() === "none")
+      return;
+    const row = $4.get(sortedKeyedRows)[$4.get(activeRowIndex)];
+    setSelectionModel(row ? [row.rowId] : []);
+  }
+  async function copySelectedCells() {
+    const cells = selectionState.selectedCellCoordinates.length > 0 ? sortCellsByGridOrder(selectionState.selectedCellCoordinates) : $4.get(activeCellCoordinates) ? [$4.get(activeCellCoordinates)] : [];
+    if (cells.length === 0)
+      return;
+    const rowsByDomId = new Map($4.get(keyedRows).map((row) => [row.rowDomId, row.row]));
+    const columnsByKey = new Map(columnModel.renderColumns.map((column) => [column.key, column]));
+    const cellsByRow = new Map;
+    for (const cell of cells) {
+      const rowCells = cellsByRow.get(cell.rowId);
+      if (rowCells)
+        rowCells.push(cell);
+      else
+        cellsByRow.set(cell.rowId, [cell]);
+    }
+    const text2 = [...cellsByRow.entries()].map(([rowId, rowCells]) => {
+      const row = rowsByDomId.get(rowId);
+      if (!row)
+        return "";
+      return rowCells.map((cell) => {
+        const column = columnsByKey.get(cell.columnKey);
+        if (!column)
+          return "";
+        return formatDataGridValue(getDataGridColumnValue(row, column));
+      }).join("\t");
+    }).join(`
+`);
+    const copied = await copyToClipboard(text2);
+    if (copied) {
+      announceCopiedCells(`Copied ${cells.length} ${cells.length === 1 ? "cell" : "cells"}`);
+      return;
+    }
+    announceCopiedCells("Copy failed");
+  }
+  function announceCopiedCells(message) {
+    $4.set(liveRegionMessage, message, true);
+    $4.set(liveRegionAnnouncementSequence, $4.get(liveRegionAnnouncementSequence) + 1);
+  }
+  function sortCellsByGridOrder(cells) {
+    const rowIndexes = new Map($4.get(rowDomIds).map((rowId, index) => [rowId, index]));
+    const columnIndexes = new Map($4.get(columnKeys).map((columnKey, index) => [columnKey, index]));
+    return [...cells].sort((left, right) => {
+      const leftRowIndex = rowIndexes.get(left.rowId) ?? Number.POSITIVE_INFINITY;
+      const rightRowIndex = rowIndexes.get(right.rowId) ?? Number.POSITIVE_INFINITY;
+      if (leftRowIndex !== rightRowIndex)
+        return leftRowIndex - rightRowIndex;
+      const leftColumnIndex = columnIndexes.get(left.columnKey) ?? Number.POSITIVE_INFINITY;
+      const rightColumnIndex = columnIndexes.get(right.columnKey) ?? Number.POSITIVE_INFINITY;
+      return leftColumnIndex - rightColumnIndex;
+    });
+  }
+  function handleCellClick(event, rowId, rowDomId, columnKey, rowIndex) {
+    $4.set(requestedActiveRowIndex, rowIndex, true);
+    $4.set(requestedActiveColumnKey, columnKey, true);
+    selectionState.setActiveCell({ rowId: rowDomId, columnKey }, {
+      extend: event.shiftKey,
+      toggle: event.ctrlKey || event.metaKey
+    });
+    updateRowSelection(rowId, event);
+    if (!isInteractiveEventTarget(event))
+      gridElement?.focus({ preventScroll: true });
+  }
+  function handleBodyClick(event) {
+    const cell = getCellEventDetail(event);
+    if (!cell)
+      return;
+    handleCellClick(event, cell.rowId, cell.rowDomId, cell.columnKey, cell.rowIndex);
+  }
+  function handleCellKeydown(event, rowId, rowDomId, columnKey, rowIndex) {
+    if (isInteractiveEventTarget(event))
+      return;
+    if (event.key !== "Enter" && event.key !== " ")
+      return;
+    event.preventDefault();
+    event.stopPropagation();
+    $4.set(requestedActiveRowIndex, rowIndex, true);
+    $4.set(requestedActiveColumnKey, columnKey, true);
+    selectionState.setActiveCell({ rowId: rowDomId, columnKey }, {
+      extend: event.shiftKey,
+      toggle: event.ctrlKey || event.metaKey
+    });
+    updateRowSelection(rowId, event);
+    gridElement?.focus({ preventScroll: true });
+  }
+  function handleBodyKeydown(event) {
+    const cell = getCellEventDetail(event);
+    if (!cell)
+      return;
+    handleCellKeydown(event, cell.rowId, cell.rowDomId, cell.columnKey, cell.rowIndex);
+  }
+  function getCellEventDetail(event) {
+    if (!(event.target instanceof Element))
+      return;
+    const cell = event.target.closest(".cinder-data-grid__cell");
+    if (!cell)
+      return;
+    const { cinderRowId, cinderRowDomId, cinderColumnKey, cinderRowIndex } = cell.dataset;
+    const rowIndex = Number(cinderRowIndex);
+    if (cinderRowId === undefined || cinderRowDomId === undefined || cinderColumnKey === undefined || !Number.isInteger(rowIndex)) {
+      return;
+    }
+    return {
+      rowId: cinderRowId,
+      rowDomId: cinderRowDomId,
+      columnKey: cinderColumnKey,
+      rowIndex
+    };
+  }
+  function handleKeydown(event) {
+    if ($$props.onkeydown) {
+      $$props.onkeydown(event);
+    }
+    if (event.defaultPrevented)
+      return;
+    if (event.target instanceof Element && event.target.closest(".cinder-data-grid__sort-button")) {
+      return;
+    }
+    if (isInteractiveEventTarget(event))
+      return;
+    if ($4.get(sortedKeyedRows).length === 0 || columnModel.renderColumns.length === 0)
+      return;
+    const action = dataGridKeyToAction(event, {
+      activeRowIndex: $4.get(activeRowIndex),
+      activeColumnIndex: $4.get(activeColumnIndex),
+      rowCount: $4.get(sortedKeyedRows).length,
+      columnCount: columnModel.renderColumns.length
+    });
+    if (!action)
+      return;
+    event.preventDefault();
+    if (action.type === "move-cell") {
+      moveActiveCell(action.rowIndex, action.columnIndex, action.extend);
+      return;
+    }
+    if (action.type === "select-all") {
+      selectionState.selectAll();
+      syncRequestedActiveCell();
+      if (selectionMode() === "multiple") {
+        setSelectionModel($4.get(sortedKeyedRows).map((row) => row.rowId));
+      } else if (selectionMode() === "single") {
+        const row = $4.get(sortedKeyedRows)[$4.get(activeRowIndex)];
+        setSelectionModel(row ? [row.rowId] : []);
+      }
+      return;
+    }
+    if (action.type === "collapse-selection") {
+      collapseSelectionToActiveCell();
+      return;
+    }
+    if (action.type === "select-active-cell") {
+      selectActiveCell(event);
+      return;
+    }
+    if (action.type === "copy-selection") {
+      copySelectedCells();
+    }
+  }
+  function isInteractiveEventTarget(event) {
+    if (!(event.target instanceof Element))
+      return false;
+    const interactiveElement = event.target.closest(interactiveDescendantSelector);
+    return interactiveElement !== null && interactiveElement !== gridElement;
+  }
+  var fragment = root();
+  var div = $4.first_child(fragment);
+  $4.attribute_effect(div, ($0) => ({
+    ...rest,
+    class: $0,
+    role: "grid",
+    "aria-rowcount": $$props.rows.length + 1,
+    "aria-colcount": columnModel.orderedColumns.length,
+    "aria-label": $4.get(resolvedAriaLabel),
+    "aria-labelledby": $4.get(resolvedAriaLabelledBy),
+    "aria-activedescendant": $4.get(activeCellId),
+    "aria-multiselectable": "true",
+    tabindex: "0",
+    onkeydown: handleKeydown,
+    "data-cinder-density": density(),
+    "data-cinder-sticky-header": stickyHeader() ? "true" : undefined,
+    "data-cinder-virtualized-rows": $4.get(shouldVirtualizeRows) ? "true" : undefined,
+    "data-cinder-virtualized-columns": $4.get(shouldVirtualizeColumns) ? "true" : undefined,
+    [$4.STYLE]: {
+      "--_cinder-data-grid-template-columns": $4.get(gridTemplateColumns),
+      "--_cinder-data-grid-content-width": $4.get(gridContentWidth) === undefined ? undefined : `${$4.get(gridContentWidth)}px`
+    }
+  }), [() => classNames("cinder-data-grid", $$props.class)]);
+  var div_1 = $4.child(div);
+  $4.each(div_1, 21, () => $4.get(renderedColumns), (column) => column.key, ($$anchor2, column) => {
+    const sortItem = $4.derived(() => getColumnSortModelItem($4.get(column).key));
+    const sortPriority = $4.derived(() => getColumnSortPriority($4.get(column).key));
+    var div_2 = root_1();
+    var node_1 = $4.child(div_2);
+    {
+      var consequent_4 = ($$anchor3) => {
+        var button = root_2();
+        var span = $4.child(button);
+        var node_2 = $4.child(span);
+        {
+          var consequent = ($$anchor4) => {
+            var fragment_1 = $4.comment();
+            var node_3 = $4.first_child(fragment_1);
+            $4.snippet(node_3, () => $4.get(column).header);
+            $4.append($$anchor4, fragment_1);
+          };
+          var alternate = ($$anchor4) => {
+            var text_1 = $4.text();
+            $4.template_effect(() => $4.set_text(text_1, $4.get(column).header));
+            $4.append($$anchor4, text_1);
+          };
+          $4.if(node_2, ($$render) => {
+            if (typeof $4.get(column).header === "function")
+              $$render(consequent);
+            else
+              $$render(alternate, -1);
+          });
+        }
+        $4.reset(span);
+        var span_1 = $4.sibling(span, 2);
+        var node_4 = $4.child(span_1);
+        {
+          var consequent_1 = ($$anchor4) => {
+            var text_2 = $4.text("Asc");
+            $4.append($$anchor4, text_2);
+          };
+          var consequent_2 = ($$anchor4) => {
+            var text_3 = $4.text("Desc");
+            $4.append($$anchor4, text_3);
+          };
+          $4.if(node_4, ($$render) => {
+            if ($4.get(sortItem)?.direction === "ascending")
+              $$render(consequent_1);
+            else if ($4.get(sortItem)?.direction === "descending")
+              $$render(consequent_2, 1);
+          });
+        }
+        $4.reset(span_1);
+        var node_5 = $4.sibling(span_1, 2);
+        {
+          var consequent_3 = ($$anchor4) => {
+            var span_2 = root_7();
+            var text_4 = $4.child(span_2, true);
+            $4.reset(span_2);
+            $4.template_effect(() => $4.set_text(text_4, $4.get(sortPriority)));
+            $4.append($$anchor4, span_2);
+          };
+          $4.if(node_5, ($$render) => {
+            if ($4.get(sortPriority) !== undefined)
+              $$render(consequent_3);
+          });
+        }
+        var span_3 = $4.sibling(node_5, 2);
+        var text_5 = $4.child(span_3, true);
+        $4.reset(span_3);
+        $4.reset(button);
+        $4.template_effect(($0) => $4.set_text(text_5, $0), [
+          () => getSortStateDescription($4.get(sortItem), $4.get(sortPriority))
+        ]);
+        $4.delegated("click", button, (event) => handleColumnHeaderClick($4.get(column), event));
+        $4.append($$anchor3, button);
+      };
+      var consequent_5 = ($$anchor3) => {
+        var fragment_3 = $4.comment();
+        var node_6 = $4.first_child(fragment_3);
+        $4.snippet(node_6, () => $4.get(column).header);
+        $4.append($$anchor3, fragment_3);
+      };
+      var alternate_1 = ($$anchor3) => {
+        var text_6 = $4.text();
+        $4.template_effect(() => $4.set_text(text_6, $4.get(column).header));
+        $4.append($$anchor3, text_6);
+      };
+      $4.if(node_1, ($$render) => {
+        if ($4.get(column).sortable)
+          $$render(consequent_4);
+        else if (typeof $4.get(column).header === "function")
+          $$render(consequent_5, 1);
+        else
+          $$render(alternate_1, -1);
+      });
+    }
+    $4.reset(div_2);
+    $4.template_effect(($0, $1) => {
+      $4.set_attribute(div_2, "aria-colindex", $4.get(column).colIndex);
+      $4.set_attribute(div_2, "aria-sort", $0);
+      $4.set_attribute(div_2, "data-cinder-pin", $4.get(column).pin);
+      $4.set_attribute(div_2, "data-cinder-sortable", $4.get(column).sortable ? "true" : undefined);
+      $4.set_attribute(div_2, "data-cinder-sort-direction", $4.get(sortItem)?.direction);
+      $4.set_style(div_2, $1);
+    }, [
+      () => $4.get(column).sortable ? getHeaderAriaSort($4.get(column), $4.get(sortItem)) : undefined,
+      () => getCellStyle($4.get(column))
+    ]);
+    $4.append($$anchor2, div_2);
+  });
+  $4.reset(div_1);
+  $4.bind_this(div_1, ($$value) => headerElement = $$value, () => headerElement);
+  $4.attach(div_1, () => observeHeaderSize);
+  var div_3 = $4.sibling(div_1, 2);
+  let styles;
+  $4.each(div_3, 21, () => $4.get(renderedRows), (renderedRow) => renderedRow.keyedRow.rowKey, ($$anchor2, renderedRow) => {
+    const keyedRow = $4.derived(() => $4.get(renderedRow).keyedRow);
+    const row = $4.derived(() => $4.get(keyedRow).row);
+    const rowId = $4.derived(() => $4.get(keyedRow).rowId);
+    const rowDomId = $4.derived(() => $4.get(keyedRow).rowDomId);
+    const rowIndex = $4.derived(() => $4.get(renderedRow).visualRowIndex);
+    var div_4 = root_10();
+    $4.each(div_4, 21, () => $4.get(renderedColumns), (column) => column.key, ($$anchor3, column) => {
+      const value = $4.derived(() => getDataGridColumnValue($4.get(row), $4.get(column)));
+      const cellId = $4.derived(() => getCellId($4.get(rowDomId), $4.get(column).key));
+      const cellCoordinates = $4.derived(() => ({ rowId: $4.get(rowDomId), columnKey: $4.get(column).key }));
+      const isSelectedCell = $4.derived(() => selectionState.isCellSelected($4.get(cellCoordinates)));
+      const isAnchorCell = $4.derived(() => selectionState.isAnchorCell($4.get(cellCoordinates)));
+      var div_5 = root_11();
+      var node_7 = $4.child(div_5);
+      {
+        var consequent_6 = ($$anchor4) => {
+          var fragment_5 = $4.comment();
+          var node_8 = $4.first_child(fragment_5);
+          $4.snippet(node_8, () => $4.get(column).cell, () => ({ row: $4.get(row), value: $4.get(value), editing: false }));
+          $4.append($$anchor4, fragment_5);
+        };
+        var alternate_2 = ($$anchor4) => {
+          var text_7 = $4.text();
+          $4.template_effect(($0) => $4.set_text(text_7, $0), [() => formatDataGridValue($4.get(value))]);
+          $4.append($$anchor4, text_7);
+        };
+        $4.if(node_7, ($$render) => {
+          if ($4.get(column).cell)
+            $$render(consequent_6);
+          else
+            $$render(alternate_2, -1);
+        });
+      }
+      $4.reset(div_5);
+      $4.template_effect(($0) => {
+        $4.set_attribute(div_5, "id", $4.get(cellId));
+        $4.set_attribute(div_5, "aria-colindex", $4.get(column).colIndex);
+        $4.set_attribute(div_5, "aria-selected", $4.get(isSelectedCell) ? "true" : undefined);
+        $4.set_attribute(div_5, "data-cinder-pin", $4.get(column).pin);
+        $4.set_attribute(div_5, "data-cinder-active", $4.get(activeCellId) === $4.get(cellId) ? "true" : undefined);
+        $4.set_attribute(div_5, "data-cinder-selected", $4.get(isSelectedCell) ? "true" : undefined);
+        $4.set_attribute(div_5, "data-cinder-anchor", $4.get(isAnchorCell) ? "true" : undefined);
+        $4.set_attribute(div_5, "data-cinder-row-id", $4.get(rowId));
+        $4.set_attribute(div_5, "data-cinder-row-dom-id", $4.get(rowDomId));
+        $4.set_attribute(div_5, "data-cinder-column-key", $4.get(column).key);
+        $4.set_attribute(div_5, "data-cinder-row-index", $4.get(rowIndex));
+        $4.set_style(div_5, $0);
+      }, [() => getCellStyle($4.get(column))]);
+      $4.append($$anchor3, div_5);
+    });
+    $4.reset(div_4);
+    $4.template_effect(($0, $1, $22, $32, $42) => {
+      $4.set_class(div_4, 1, $0);
+      $4.set_attribute(div_4, "aria-rowindex", $4.get(rowIndex) + 2);
+      $4.set_attribute(div_4, "aria-label", $1);
+      $4.set_attribute(div_4, "aria-selected", $22);
+      $4.set_attribute(div_4, "data-cinder-selected", $32);
+      $4.set_attribute(div_4, "data-cinder-virtual-index", $4.get(rowIndex));
+      $4.set_style(div_4, $42);
+    }, [
+      () => $4.clsx(classNames("cinder-data-grid__row", getRowClass($4.get(row), $4.get(rowIndex)))),
+      () => getResolvedRowAriaLabel($4.get(row), $4.get(rowIndex)),
+      () => $4.get(selectedRowIds).has($4.get(rowId)) ? "true" : undefined,
+      () => $4.get(selectedRowIds).has($4.get(rowId)) ? "true" : undefined,
+      () => getRowStyle($4.get(renderedRow))
+    ]);
+    $4.append($$anchor2, div_4);
+  });
+  $4.reset(div_3);
+  $4.attach(div_3, () => delegateBodyEvents);
+  $4.reset(div);
+  $4.bind_this(div, ($$value) => gridElement = $$value, () => gridElement);
+  $4.attach(div, () => rowVirtualizer.mountScrollContainer);
+  $4.attach(div, () => observeGridSize);
+  var div_6 = $4.sibling(div, 2);
+  var text_8 = $4.child(div_6, true);
+  $4.reset(div_6);
+  $4.template_effect(() => {
+    $4.set_attribute(div_3, "data-cinder-virtualized", $4.get(shouldVirtualizeRows) ? "true" : undefined);
+    styles = $4.set_style(div_3, "", styles, { height: $4.get(bodyHeight) });
+    $4.set_text(text_8, $4.get(renderedLiveRegionMessage));
+  });
+  $4.append($$anchor, fragment);
+  $4.pop();
+}
+$4.delegate(["click"]);
+
+// src/components/data-grid/index.ts
+var data_grid_default = Data_grid;
+export {
+  data_grid_default as default,
+  Data_grid as DataGrid
+};
+
+//# debugId=DBADF5D5E9737F4864756E2164756E21