@x12i/data 1.0.0 → 1.1.0

package/dist/chunk-ASP4ABDG.js

@@ -0,0 +1,1987 @@
+// src/types.ts
+function defineColumns(columns) {
+  return columns;
+}
+var SAVED_VIEW_VERSION = 1;
+var FILTER_OPERATORS = [
+  "contains",
+  "not-contains",
+  "starts-with",
+  "equals",
+  "not-equals",
+  "gt",
+  "gte",
+  "lt",
+  "lte",
+  "between",
+  "in",
+  "before",
+  "after",
+  "is-empty",
+  "is-not-empty"
+];
+
+// src/columns.ts
+var DEFAULT_COLUMN_WIDTH = 160;
+var DEFAULT_COLUMN_MIN_WIDTH = 64;
+var DEFAULT_COLUMN_MAX_WIDTH = 1200;
+function getColumnValue(column, row) {
+  if (column.accessor !== void 0) return column.accessor(row);
+  if (column.field !== void 0) return row[column.field];
+  return void 0;
+}
+function columnFieldName(column) {
+  return column.field ?? column.id;
+}
+var NUMERIC = /* @__PURE__ */ new Set(["number", "currency", "percent"]);
+function isNumericCellType(cellType) {
+  return cellType !== void 0 && NUMERIC.has(cellType);
+}
+function resolveColumnAlign(column) {
+  if (column.align !== void 0) return column.align;
+  if (isNumericCellType(column.cellType)) return "end";
+  if (column.cellType === "boolean") return "center";
+  return "start";
+}
+function resolveFilterType(column) {
+  if (column.filterType !== void 0) return column.filterType;
+  switch (column.cellType) {
+    case "number":
+    case "currency":
+    case "percent":
+    case "progress":
+      return "number";
+    case "date":
+    case "datetime":
+      return "date";
+    case "boolean":
+      return "boolean";
+    case "status":
+      return "enum";
+    case "tags":
+      return column.options !== void 0 ? "enum" : "text";
+    default:
+      return column.options !== void 0 ? "enum" : "text";
+  }
+}
+function resolveEditor(column) {
+  if (column.editor !== void 0) return column.editor;
+  switch (column.cellType) {
+    case "number":
+    case "currency":
+    case "percent":
+    case "progress":
+      return "number";
+    case "date":
+    case "datetime":
+      return "date";
+    case "boolean":
+      return "boolean";
+    case "status":
+      return "select";
+    default:
+      return column.options !== void 0 ? "select" : "text";
+  }
+}
+var INERT = /* @__PURE__ */ new Set(["actions", "custom"]);
+function isSortable(column) {
+  if (column.sortable !== void 0) return column.sortable;
+  return column.cellType === void 0 || !INERT.has(column.cellType);
+}
+function isFilterable(column) {
+  if (column.filterable !== void 0) return column.filterable;
+  return false;
+}
+function isResizable(column) {
+  return column.resizable ?? true;
+}
+function isEditable(column, row) {
+  if (column.editable !== true) return false;
+  return column.canEdit === void 0 || column.canEdit(row);
+}
+function clampColumnWidth(column, width) {
+  const min = column.minWidth ?? DEFAULT_COLUMN_MIN_WIDTH;
+  const max = Math.max(min, column.maxWidth ?? DEFAULT_COLUMN_MAX_WIDTH);
+  return Math.min(max, Math.max(min, Math.round(width)));
+}
+function initialColumnWidth(column) {
+  return clampColumnWidth(column, column.width ?? DEFAULT_COLUMN_WIDTH);
+}
+function indexColumns(columns) {
+  const map = /* @__PURE__ */ new Map();
+  for (const column of columns) if (!map.has(column.id)) map.set(column.id, column);
+  return map;
+}
+
+// src/values.ts
+var DATE_ONLY = /^\d{4}-\d{2}-\d{2}$/;
+function isDateOnlyString(value) {
+  return typeof value === "string" && DATE_ONLY.test(value);
+}
+function isEmptyValue(value) {
+  return value === null || value === void 0 || value === "" || typeof value === "number" && Number.isNaN(value) || Array.isArray(value) && value.length === 0;
+}
+function toNumber(value) {
+  if (typeof value === "number") return value;
+  if (typeof value === "bigint") return Number(value);
+  if (typeof value === "string") {
+    const text = value.trim();
+    return text === "" ? Number.NaN : Number(text);
+  }
+  return Number.NaN;
+}
+function toTimestamp(value) {
+  if (value instanceof Date) return value.getTime();
+  if (typeof value === "number") return value;
+  if (typeof value === "string") return value === "" ? Number.NaN : Date.parse(value);
+  return Number.NaN;
+}
+function toDate(value) {
+  const time = toTimestamp(value);
+  return Number.isNaN(time) ? null : new Date(time);
+}
+function toText(value) {
+  if (value === null || value === void 0) return "";
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
+    return String(value);
+  }
+  if (value instanceof Date) return Number.isNaN(value.getTime()) ? "" : value.toISOString();
+  if (Array.isArray(value)) return value.map(toText).join(", ");
+  if (typeof value === "object") {
+    try {
+      return JSON.stringify(value);
+    } catch {
+      return "";
+    }
+  }
+  return String(value);
+}
+function normalizeText(value, locale) {
+  return value.normalize("NFD").replace(/\p{M}+/gu, "").toLocaleLowerCase(locale);
+}
+function toBoolean(value) {
+  if (typeof value === "boolean") return value;
+  if (value === "true") return true;
+  if (value === "false") return false;
+  return null;
+}
+
+// src/formatters.ts
+var defaultFormatLabels = { yes: "Yes", no: "No" };
+var cache = /* @__PURE__ */ new Map();
+function numberFormat(locale, options) {
+  const key = `n|${locale ?? ""}|${JSON.stringify(options)}`;
+  let format = cache.get(key);
+  if (format === void 0) {
+    try {
+      format = new Intl.NumberFormat(locale, options);
+    } catch {
+      return null;
+    }
+    cache.set(key, format);
+  }
+  return format;
+}
+function dateFormat(locale, options) {
+  const key = `d|${locale ?? ""}|${JSON.stringify(options)}`;
+  let format = cache.get(key);
+  if (format === void 0) {
+    try {
+      format = new Intl.DateTimeFormat(locale, options);
+    } catch {
+      return null;
+    }
+    cache.set(key, format);
+  }
+  return format;
+}
+function resolveNumberFormatOptions(column) {
+  const format = column.format;
+  const type = column.cellType;
+  if (type === "currency") {
+    const code = column.currency ?? (format !== void 0 && /^[A-Za-z]{3}$/.test(format) ? format.toUpperCase() : "USD");
+    return { style: "currency", currency: code, ...column.numberFormat };
+  }
+  if (type === "percent" || type === "progress") {
+    return { style: "percent", minimumFractionDigits: 0, maximumFractionDigits: 1, ...column.numberFormat };
+  }
+  const base = {};
+  if (format === "integer") base.maximumFractionDigits = 0;
+  else if (format === "compact") base.notation = "compact";
+  else if (format?.startsWith("decimal:")) {
+    const digits = Number(format.slice("decimal:".length));
+    if (Number.isInteger(digits) && digits >= 0 && digits <= 20) {
+      base.minimumFractionDigits = digits;
+      base.maximumFractionDigits = digits;
+    }
+  } else if (format?.startsWith("unit:")) {
+    base.style = "unit";
+    base.unit = format.slice("unit:".length);
+  }
+  return { ...base, ...column.numberFormat };
+}
+var DATE_STYLES = /* @__PURE__ */ new Set(["short", "medium", "long", "full"]);
+function resolveDateFormatOptions(column) {
+  if (column.dateFormat !== void 0) return column.dateFormat;
+  const style = DATE_STYLES.has(column.format ?? "") ? column.format : "medium";
+  if (column.cellType === "datetime") {
+    return { dateStyle: style, timeStyle: style === "short" || style === "medium" ? "short" : "medium" };
+  }
+  return { dateStyle: style };
+}
+function formatDate(column, value, ctx, options) {
+  const date = toDate(value);
+  if (date === null) return toText(value);
+  const dateOnly = isDateOnlyString(value);
+  if (column.format === "iso") {
+    return column.cellType === "datetime" && !dateOnly ? date.toISOString() : date.toISOString().slice(0, 10);
+  }
+  const effective = { ...options };
+  if (dateOnly) effective.timeZone = "UTC";
+  else if (ctx.timeZone !== void 0) effective.timeZone = ctx.timeZone;
+  const format = dateFormat(ctx.locale, effective);
+  return format === null ? date.toISOString() : format.format(date);
+}
+function optionLabel(column, value) {
+  const text = toText(value);
+  return column.options?.find((option) => option.value === text)?.label ?? text;
+}
+function createCellFormatter(column, ctx = {}) {
+  if (column.formatter !== void 0) {
+    const custom = column.formatter;
+    return (value, row) => custom(value, row);
+  }
+  const labels = ctx.labels ?? defaultFormatLabels;
+  const type = column.cellType;
+  const numeric = numberFormat(ctx.locale, resolveNumberFormatOptions({ ...column, cellType: type ?? "number" }));
+  const dateOptions = resolveDateFormatOptions({ ...column, cellType: type ?? "date" });
+  const percentWhole = column.format === "whole";
+  const progressMax = column.progressMax ?? 100;
+  const formatNumber2 = (value, scale = 1) => {
+    const number = toNumber(value);
+    if (Number.isNaN(number)) return toText(value);
+    return numeric === null ? String(number) : numeric.format(number / scale);
+  };
+  return (value) => {
+    if (isEmptyValue(value)) return "";
+    switch (type) {
+      case "number":
+      case "currency":
+        return formatNumber2(value);
+      case "percent":
+        return formatNumber2(value, percentWhole ? 100 : 1);
+      case "progress":
+        return formatNumber2(value, progressMax);
+      case "date":
+      case "datetime":
+        return formatDate(column, value, ctx, dateOptions);
+      case "boolean": {
+        const flag = toBoolean(value);
+        return flag === null ? toText(value) : flag ? labels.yes : labels.no;
+      }
+      case "status":
+        return optionLabel(column, value);
+      case "tags":
+        return Array.isArray(value) ? value.map((item) => optionLabel(column, item)).join(", ") : toText(value);
+      case "sparkline":
+        return Array.isArray(value) ? value.map(toText).join(" ") : toText(value);
+      case "actions":
+        return "";
+      case void 0: {
+        if (typeof value === "number") return formatNumber2(value);
+        if (value instanceof Date) return formatDate(column, value, ctx, resolveDateFormatOptions({ ...column, cellType: "date" }));
+        if (typeof value === "boolean") return value ? labels.yes : labels.no;
+        if (column.options !== void 0) return optionLabel(column, value);
+        return toText(value);
+      }
+      default:
+        return toText(value);
+    }
+  };
+}
+function formatCellValue(column, value, row, ctx = {}) {
+  return createCellFormatter(column, ctx)(value, row);
+}
+
+// src/sort.ts
+function createCollator(options = {}) {
+  return new Intl.Collator(options.locale, {
+    numeric: options.numeric ?? true,
+    sensitivity: options.caseInsensitive === false ? "variant" : "base"
+  });
+}
+function toSortKey(value) {
+  if (value === null || value === void 0) return null;
+  if (typeof value === "number") return Number.isNaN(value) ? null : value;
+  if (typeof value === "bigint") return Number(value);
+  if (typeof value === "boolean") return value ? 1 : 0;
+  if (value instanceof Date) {
+    const time = value.getTime();
+    return Number.isNaN(time) ? null : time;
+  }
+  if (typeof value === "string") return value === "" ? null : value;
+  if (Array.isArray(value)) return value.length === 0 ? null : toText(value);
+  return toText(value);
+}
+function columnSortKey(column, value) {
+  switch (column.cellType) {
+    case "number":
+    case "currency":
+    case "percent":
+    case "progress": {
+      const number = toNumber(value);
+      return Number.isNaN(number) ? null : number;
+    }
+    case "date":
+    case "datetime": {
+      const time = toTimestamp(value);
+      return Number.isNaN(time) ? null : time;
+    }
+    default:
+      return toSortKey(value);
+  }
+}
+function compareKeys(a, b, collator) {
+  if (typeof a === "number") {
+    if (typeof b === "number") return a < b ? -1 : a > b ? 1 : 0;
+    return -1;
+  }
+  if (typeof b === "number") return 1;
+  return collator.compare(a, b);
+}
+function compareValues(a, b, collator = createCollator()) {
+  const keyA = toSortKey(a);
+  const keyB = toSortKey(b);
+  if (keyA === null) return keyB === null ? 0 : 1;
+  if (keyB === null) return -1;
+  return compareKeys(keyA, keyB, collator);
+}
+function sortIndexes(rows, indexes, sort, columns, options = {}) {
+  const byId = indexColumns(columns);
+  const specs = [];
+  for (const item of sort) {
+    const column = byId.get(item.field);
+    if (column !== void 0) specs.push({ column, sign: item.direction === "desc" ? -1 : 1 });
+  }
+  const count = indexes.length;
+  if (specs.length === 0 || count < 2) return indexes.slice();
+  const collator = createCollator(options);
+  const keys = specs.map(({ column }) => {
+    const out = new Array(count);
+    const custom = column.comparator !== void 0;
+    for (let position = 0; position < count; position += 1) {
+      const row = rows[indexes[position]];
+      const value = getColumnValue(column, row);
+      out[position] = custom ? value : columnSortKey(column, value);
+    }
+    return out;
+  });
+  const order = new Array(count);
+  for (let position = 0; position < count; position += 1) order[position] = position;
+  order.sort((a, b) => {
+    for (let s = 0; s < specs.length; s += 1) {
+      const spec = specs[s];
+      const column = spec.column;
+      const list = keys[s];
+      const keyA = list[a];
+      const keyB = list[b];
+      let result;
+      if (column.comparator !== void 0) {
+        result = column.comparator(
+          keyA,
+          keyB,
+          rows[indexes[a]],
+          rows[indexes[b]]
+        ) * spec.sign;
+      } else if (keyA === null) {
+        result = keyB === null ? 0 : 1;
+      } else if (keyB === null) {
+        result = -1;
+      } else {
+        result = compareKeys(keyA, keyB, collator) * spec.sign;
+      }
+      if (result !== 0) return result;
+    }
+    return a - b;
+  });
+  return order.map((position) => indexes[position]);
+}
+function sortRows(rows, sort, columns, options = {}) {
+  const all = new Array(rows.length);
+  for (let i = 0; i < rows.length; i += 1) all[i] = i;
+  return sortIndexes(rows, all, sort, columns, options).map((index) => rows[index]);
+}
+
+// src/filter.ts
+var OPERATORS_BY_FILTER_TYPE = {
+  text: ["contains", "not-contains", "starts-with", "equals", "not-equals", "is-empty", "is-not-empty"],
+  number: ["equals", "not-equals", "gt", "gte", "lt", "lte", "between", "is-empty", "is-not-empty"],
+  date: ["equals", "before", "after", "between", "is-empty", "is-not-empty"],
+  enum: ["in", "is-empty", "is-not-empty"],
+  boolean: ["equals", "is-empty", "is-not-empty"]
+};
+function operatorsFor(type) {
+  return OPERATORS_BY_FILTER_TYPE[type];
+}
+function isValuelessOperator(operator) {
+  return operator === "is-empty" || operator === "is-not-empty";
+}
+function hasText(value) {
+  return !isEmptyValue(value) && toText(value).trim() !== "";
+}
+function isFilterEffective(item) {
+  if (isValuelessOperator(item.operator)) return true;
+  if (item.operator === "between") {
+    const range = Array.isArray(item.value) ? item.value : [];
+    return hasText(range[0]) || hasText(range[1]);
+  }
+  if (item.operator === "in") return Array.isArray(item.value) && item.value.length > 0;
+  return hasText(item.value);
+}
+function pad(value) {
+  return String(value).padStart(2, "0");
+}
+function toDayString(value) {
+  if (isDateOnlyString(value)) return value;
+  if (value instanceof Date && !Number.isNaN(value.getTime())) {
+    return `${value.getFullYear()}-${pad(value.getMonth() + 1)}-${pad(value.getDate())}`;
+  }
+  if (typeof value === "string" && value.length >= 10 && isDateOnlyString(value.slice(0, 10))) {
+    return value.slice(0, 10);
+  }
+  return null;
+}
+function offsetMs(timestamp, timeZone) {
+  const parts = new Intl.DateTimeFormat("en-US", {
+    timeZone,
+    hourCycle: "h23",
+    year: "numeric",
+    month: "numeric",
+    day: "numeric",
+    hour: "numeric",
+    minute: "numeric",
+    second: "numeric"
+  }).formatToParts(timestamp);
+  const get = (type) => Number(parts.find((part) => part.type === type)?.value);
+  const asUtc = Date.UTC(get("year"), get("month") - 1, get("day"), get("hour"), get("minute"), get("second"));
+  return asUtc - Math.floor(timestamp / 1e3) * 1e3;
+}
+function dayStart(day, timeZone) {
+  const [year, month, date] = day.split("-").map(Number);
+  if (timeZone === void 0) return new Date(year, month - 1, date).getTime();
+  const guess = Date.UTC(year, month - 1, date);
+  if (timeZone === "UTC") return guess;
+  try {
+    const first = offsetMs(guess, timeZone);
+    let result = guess - first;
+    const second = offsetMs(result, timeZone);
+    if (second !== first) result = guess - second;
+    return result;
+  } catch {
+    return guess;
+  }
+}
+function nextDay(day) {
+  const [year, month, date] = day.split("-").map(Number);
+  const next = new Date(Date.UTC(year, month - 1, date + 1));
+  return `${next.getUTCFullYear()}-${pad(next.getUTCMonth() + 1)}-${pad(next.getUTCDate())}`;
+}
+var ALWAYS = () => true;
+function textPredicate(item, ctx) {
+  const { operator } = item;
+  const norm = (value) => normalizeText(toText(value), ctx.locale);
+  if (operator === "in") {
+    const wanted = new Set((Array.isArray(item.value) ? item.value : []).map((entry) => norm(entry)));
+    return (value) => Array.isArray(value) ? value.some((entry) => wanted.has(norm(entry))) : wanted.has(norm(value));
+  }
+  if (operator === "between" || operator === "gt" || operator === "gte" || operator === "lt" || operator === "lte") {
+    const collator = createCollator({ ...ctx.locale === void 0 ? {} : { locale: ctx.locale } });
+    const [low, high] = operator === "between" && Array.isArray(item.value) ? item.value : [item.value, item.value];
+    return (value) => {
+      if (isEmptyValue(value)) return false;
+      const text = toText(value);
+      switch (operator) {
+        case "gt":
+          return collator.compare(text, toText(item.value)) > 0;
+        case "gte":
+          return collator.compare(text, toText(item.value)) >= 0;
+        case "lt":
+          return collator.compare(text, toText(item.value)) < 0;
+        case "lte":
+          return collator.compare(text, toText(item.value)) <= 0;
+        default:
+          return (!hasText(low) || collator.compare(text, toText(low)) >= 0) && (!hasText(high) || collator.compare(text, toText(high)) <= 0);
+      }
+    };
+  }
+  const needle = norm(item.value);
+  switch (operator) {
+    case "contains":
+      return (value) => norm(value).includes(needle);
+    case "not-contains":
+      return (value) => !norm(value).includes(needle);
+    case "starts-with":
+      return (value) => norm(value).startsWith(needle);
+    case "equals":
+      return (value) => norm(value) === needle;
+    case "not-equals":
+      return (value) => norm(value) !== needle;
+    // Date operators on a text column compare as text; they are meaningless but harmless.
+    case "before":
+    case "after":
+      return ALWAYS;
+    default:
+      return ALWAYS;
+  }
+}
+function numberPredicate(item) {
+  const { operator } = item;
+  if (operator === "in") {
+    const wanted = new Set((Array.isArray(item.value) ? item.value : []).map(toNumber));
+    return (value) => wanted.has(toNumber(value));
+  }
+  if (operator === "between") {
+    const range = Array.isArray(item.value) ? item.value : [];
+    const low = hasText(range[0]) ? toNumber(range[0]) : Number.NEGATIVE_INFINITY;
+    const high = hasText(range[1]) ? toNumber(range[1]) : Number.POSITIVE_INFINITY;
+    return (value) => {
+      const number = toNumber(value);
+      return !Number.isNaN(number) && number >= low && number <= high;
+    };
+  }
+  const target = toNumber(item.value);
+  if (Number.isNaN(target)) return ALWAYS;
+  switch (operator) {
+    case "equals":
+      return (value) => toNumber(value) === target;
+    case "not-equals":
+      return (value) => toNumber(value) !== target;
+    case "gt":
+    case "after":
+      return (value) => toNumber(value) > target;
+    case "gte":
+      return (value) => toNumber(value) >= target;
+    case "lt":
+    case "before":
+      return (value) => toNumber(value) < target;
+    case "lte":
+      return (value) => toNumber(value) <= target;
+    default:
+      return ALWAYS;
+  }
+}
+function datePredicate(item, ctx) {
+  const { operator } = item;
+  const range = operator === "between" && Array.isArray(item.value) ? item.value : [item.value, item.value];
+  const first = toDayString(operator === "between" ? range[0] : item.value);
+  const second = toDayString(operator === "between" ? range[1] : item.value);
+  const startMs = (day) => dayStart(day, ctx.timeZone);
+  const test = (inRange) => (value) => {
+    if (isEmptyValue(value)) return false;
+    if (isDateOnlyString(value)) return inRange(value, Number.NaN);
+    const time = toTimestamp(value);
+    return !Number.isNaN(time) && inRange(null, time);
+  };
+  switch (operator) {
+    case "equals":
+    case "not-equals": {
+      if (first === null) return ALWAYS;
+      const equals = test(
+        (day, time) => day !== null ? day === first : time >= startMs(first) && time < startMs(nextDay(first))
+      );
+      return operator === "equals" ? equals : (value) => !equals(value);
+    }
+    case "before":
+    case "lt": {
+      if (first === null) return ALWAYS;
+      return test((day, time) => day !== null ? day < first : time < startMs(first));
+    }
+    case "lte": {
+      if (first === null) return ALWAYS;
+      return test((day, time) => day !== null ? day <= first : time < startMs(nextDay(first)));
+    }
+    case "after":
+    case "gt": {
+      if (first === null) return ALWAYS;
+      return test((day, time) => day !== null ? day > first : time >= startMs(nextDay(first)));
+    }
+    case "gte": {
+      if (first === null) return ALWAYS;
+      return test((day, time) => day !== null ? day >= first : time >= startMs(first));
+    }
+    case "between": {
+      if (first === null && second === null) return ALWAYS;
+      return test((day, time) => {
+        if (day !== null) return (first === null || day >= first) && (second === null || day <= second);
+        return (first === null || time >= startMs(first)) && (second === null || time < startMs(nextDay(second)));
+      });
+    }
+    default:
+      return ALWAYS;
+  }
+}
+function enumPredicate(item) {
+  const { operator } = item;
+  const values = Array.isArray(item.value) ? item.value : [item.value];
+  const wanted = new Set(values.filter((entry) => entry !== void 0 && entry !== null).map(String));
+  const hit = (value) => Array.isArray(value) ? value.some((entry) => wanted.has(String(entry))) : wanted.has(String(value));
+  switch (operator) {
+    case "in":
+    case "equals":
+      return hit;
+    case "not-equals":
+      return (value) => !hit(value);
+    default:
+      return ALWAYS;
+  }
+}
+function booleanPredicate(item) {
+  const target = toBoolean(item.value);
+  if (target === null) return ALWAYS;
+  switch (item.operator) {
+    case "equals":
+      return (value) => toBoolean(value) === target;
+    case "not-equals":
+      return (value) => toBoolean(value) !== target;
+    default:
+      return ALWAYS;
+  }
+}
+function createValuePredicate(item, column, ctx = {}) {
+  if (item.operator === "is-empty") return isEmptyValue;
+  if (item.operator === "is-not-empty") return (value) => !isEmptyValue(value);
+  if (!isFilterEffective(item)) return ALWAYS;
+  let predicate;
+  switch (resolveFilterType(column)) {
+    case "number":
+      predicate = numberPredicate(item);
+      break;
+    case "date":
+      predicate = datePredicate(item, ctx);
+      break;
+    case "enum":
+      predicate = enumPredicate(item);
+      break;
+    case "boolean":
+      predicate = booleanPredicate(item);
+      break;
+    default:
+      predicate = textPredicate(item, ctx);
+  }
+  if (predicate === ALWAYS) return ALWAYS;
+  const keepsEmpty = item.operator === "not-equals" || item.operator === "not-contains";
+  return (value) => isEmptyValue(value) ? keepsEmpty : predicate(value);
+}
+function matchesFilter(value, item, column, ctx = {}) {
+  return createValuePredicate(item, column, ctx)(value);
+}
+function parseQuickFilter(text, locale) {
+  return normalizeText(text, locale).split(/\s+/).filter((token) => token !== "");
+}
+var NOT_SEARCHABLE = /* @__PURE__ */ new Set(["actions", "sparkline", "custom"]);
+function isSearchable(column) {
+  if (column.searchable !== void 0) return column.searchable;
+  return column.cellType === void 0 || !NOT_SEARCHABLE.has(column.cellType);
+}
+function createSearchIndex(rows, columns, ctx = {}) {
+  const searchable = columns.filter(isSearchable).map((column) => ({
+    column,
+    format: createCellFormatter(column, ctx)
+  }));
+  const out = new Array(rows.length);
+  for (let i = 0; i < rows.length; i += 1) {
+    const row = rows[i];
+    let text = "";
+    for (const { column, format } of searchable) {
+      const value = getColumnValue(column, row);
+      if (isEmptyValue(value)) continue;
+      text += `${format(value, row)}
`;
+    }
+    out[i] = normalizeText(text, ctx.locale);
+  }
+  return out;
+}
+function filterIndexes(rows, filter, columns, options = {}) {
+  const byId = indexColumns(columns);
+  const ctx = {
+    ...options.locale === void 0 ? {} : { locale: options.locale },
+    ...options.timeZone === void 0 ? {} : { timeZone: options.timeZone }
+  };
+  const tests = [];
+  for (const item of filter) {
+    const column = byId.get(item.field);
+    if (column === void 0) continue;
+    const test = createValuePredicate(item, column, ctx);
+    if (test !== ALWAYS) tests.push({ column, test });
+  }
+  const tokens = options.quickFilter === void 0 ? [] : parseQuickFilter(options.quickFilter, options.locale);
+  let haystack = null;
+  if (tokens.length > 0) {
+    haystack = options.searchIndex ?? createSearchIndex(rows, options.searchColumns ?? columns, {
+      ...ctx,
+      ...options.labels === void 0 ? {} : { labels: options.labels }
+    });
+  }
+  const out = [];
+  const total = rows.length;
+  for (let i = 0; i < total; i += 1) {
+    const row = rows[i];
+    let pass = true;
+    for (let t = 0; t < tests.length; t += 1) {
+      const entry = tests[t];
+      if (!entry.test(getColumnValue(entry.column, row))) {
+        pass = false;
+        break;
+      }
+    }
+    if (pass && haystack !== null) {
+      const text = haystack[i] ?? "";
+      for (const token of tokens) {
+        if (!text.includes(token)) {
+          pass = false;
+          break;
+        }
+      }
+    }
+    if (pass) out.push(i);
+  }
+  return out;
+}
+function distinctValues(rows, column, limit = 500) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const row of rows) {
+    const value = getColumnValue(column, row);
+    if (isEmptyValue(value)) continue;
+    if (Array.isArray(value)) for (const entry of value) seen.add(entry);
+    else seen.add(value);
+    if (seen.size >= limit) break;
+  }
+  return [...seen].sort((a, b) => compareValues(a, b));
+}
+
+// src/aggregate.ts
+function aggregateValues(values, name, options = {}) {
+  if (name === "count") {
+    let count = 0;
+    for (const value of values) if (!isEmptyValue(value)) count += 1;
+    return count;
+  }
+  const numeric = (value) => options.dates === true ? toTimestamp(value) : toNumber(value);
+  if (name === "sum" || name === "avg") {
+    let sum = 0;
+    let count = 0;
+    for (const value of values) {
+      const number = toNumber(value);
+      if (Number.isNaN(number)) continue;
+      sum += number;
+      count += 1;
+    }
+    if (name === "sum") return sum;
+    return count === 0 ? null : sum / count;
+  }
+  let best = null;
+  let bestKey = Number.NaN;
+  for (const value of values) {
+    const key = numeric(value);
+    if (Number.isNaN(key)) continue;
+    if (Number.isNaN(bestKey) || (name === "min" ? key < bestKey : key > bestKey)) {
+      best = value;
+      bestKey = key;
+    }
+  }
+  return best;
+}
+function computeAggregate(column, rows) {
+  const aggregate = column.aggregate;
+  if (aggregate === void 0) return void 0;
+  const values = rows.map((row) => getColumnValue(column, row));
+  if (typeof aggregate === "function") return aggregate(values, rows);
+  return aggregateValues(values, aggregate, { dates: column.cellType === "date" || column.cellType === "datetime" });
+}
+function computeAggregates(columns, rows) {
+  const out = {};
+  for (const column of columns) {
+    if (column.aggregate === void 0) continue;
+    out[column.id] = computeAggregate(column, rows);
+  }
+  return out;
+}
+
+// src/group.ts
+function encode(value) {
+  return encodeURIComponent(value);
+}
+function buildGroupTree(rows, indexes, group, columns, options = {}) {
+  const byId = indexColumns(columns);
+  const levels = group.map((item) => byId.get(item.field)).filter((column) => column !== void 0);
+  if (levels.length === 0) return [];
+  const collator = createCollator(options);
+  const build = (subset, depth, parentId) => {
+    const column = levels[depth];
+    const buckets = /* @__PURE__ */ new Map();
+    for (const index of subset) {
+      const value = getColumnValue(column, rows[index]);
+      const key = toText(value);
+      let bucket = buckets.get(key);
+      if (bucket === void 0) {
+        bucket = { value, indexes: [] };
+        buckets.set(key, bucket);
+      }
+      bucket.indexes.push(index);
+    }
+    let entries = [...buckets.entries()];
+    const order = typeof options.order === "function" ? options.order(column.id) : options.order ?? "asc";
+    if (order !== "first") {
+      const sign = order === "desc" ? -1 : 1;
+      entries = entries.sort((a, b) => sign * compareValues(a[1].value, b[1].value, collator));
+    }
+    return entries.map(([key, bucket]) => {
+      const id = `${parentId === "" ? "" : `${parentId}/`}${encode(column.id)}=${encode(key)}`;
+      return {
+        id,
+        field: column.id,
+        value: bucket.value,
+        depth,
+        indexes: bucket.indexes,
+        children: depth + 1 < levels.length ? build(bucket.indexes, depth + 1, id) : [],
+        aggregates: computeAggregates(
+          columns,
+          bucket.indexes.map((index) => rows[index])
+        )
+      };
+    });
+  };
+  return build(indexes, 0, "");
+}
+
+// src/view.ts
+function computeViewIndexes(rows, columns, options = {}) {
+  const matched = filterIndexes(rows, options.filter ?? [], columns, options);
+  return sortIndexes(rows, matched, options.sort ?? [], columns, options);
+}
+function buildDisplayRows(rows, indexes, columns, options) {
+  const out = [];
+  const expandedRows = options.expandedRows ?? {};
+  const pushData = (index, depth) => {
+    const row = rows[index];
+    const id = options.getRowId(row, index);
+    out.push({ kind: "data", id, row, index, depth });
+    if (options.withDetail === true && expandedRows[id] === true) {
+      out.push({ kind: "detail", id: `${id}:detail`, parentId: id, row, index, depth });
+    }
+  };
+  const group = options.group ?? [];
+  const sorted = new Map((options.sort ?? []).map((item) => [item.field, item.direction]));
+  const tree = buildGroupTree(rows, indexes, group, columns, {
+    ...options.locale === void 0 ? {} : { locale: options.locale },
+    order: (field) => sorted.get(field) ?? "asc"
+  });
+  if (tree.length === 0) {
+    for (const index of indexes) pushData(index, 0);
+    return { rows: out, groups: [] };
+  }
+  const expansion = options.groupExpansion ?? {};
+  const byDefault = options.groupsExpandedByDefault ?? true;
+  const walk = (nodes) => {
+    for (const node of nodes) {
+      const expanded = expansion[node.id] ?? byDefault;
+      out.push({
+        kind: "group",
+        id: node.id,
+        field: node.field,
+        value: node.value,
+        depth: node.depth,
+        count: node.indexes.length,
+        expanded,
+        aggregates: node.aggregates
+      });
+      if (!expanded) continue;
+      if (node.children.length > 0) walk(node.children);
+      else for (const index of node.indexes) pushData(index, node.depth + 1);
+    }
+  };
+  walk(tree);
+  return { rows: out, groups: tree };
+}
+
+// src/selection.ts
+var EMPTY_SELECTION = Object.freeze({ mode: "include", ids: /* @__PURE__ */ new Set() });
+function createSelection(ids = []) {
+  return { mode: "include", ids: new Set(ids) };
+}
+function isSelected(state, id) {
+  return state.mode === "include" ? state.ids.has(id) : !state.ids.has(id);
+}
+function isSelectionEmpty(state) {
+  return state.mode === "include" && state.ids.size === 0;
+}
+function toggleRow(state, id, selected) {
+  const next = selected ?? !isSelected(state, id);
+  if (isSelected(state, id) === next) return state;
+  const ids = new Set(state.ids);
+  if (next === (state.mode === "include")) ids.add(id);
+  else ids.delete(id);
+  return { mode: state.mode, ids };
+}
+function selectOnly(id) {
+  return createSelection([id]);
+}
+function selectRange(state, orderedIds, from, to, selected = true) {
+  if (orderedIds.length === 0) return state;
+  const last = orderedIds.length - 1;
+  const start = Math.max(0, Math.min(last, Math.min(from, to)));
+  const end = Math.max(0, Math.min(last, Math.max(from, to)));
+  const ids = new Set(state.ids);
+  const add = selected === (state.mode === "include");
+  for (let position = start; position <= end; position += 1) {
+    const id = orderedIds[position];
+    if (add) ids.add(id);
+    else ids.delete(id);
+  }
+  return { mode: state.mode, ids };
+}
+function selectAll(ids) {
+  return createSelection(ids);
+}
+function selectAllExceptNone() {
+  return { mode: "exclude", ids: /* @__PURE__ */ new Set() };
+}
+function clearSelection() {
+  return createSelection();
+}
+function countSelected(state, total) {
+  return state.mode === "include" ? state.ids.size : Math.max(0, total - state.ids.size);
+}
+function summarizeSelection(state, ids) {
+  if (ids.length === 0) return "none";
+  let selected = 0;
+  for (const id of ids) if (isSelected(state, id)) selected += 1;
+  if (selected === 0) return "none";
+  return selected === ids.length ? "all" : "some";
+}
+function resolveSelectedIds(state, allIds) {
+  const out = [];
+  for (const id of allIds) if (isSelected(state, id)) out.push(id);
+  return out;
+}
+function serializeSelection(state) {
+  return { mode: state.mode, ids: [...state.ids] };
+}
+function deserializeSelection(value) {
+  return { mode: value.mode === "exclude" ? "exclude" : "include", ids: new Set(value.ids) };
+}
+
+// src/keyboard.ts
+var NAVIGATION_KEYS = /* @__PURE__ */ new Set([
+  "ArrowUp",
+  "ArrowDown",
+  "ArrowLeft",
+  "ArrowRight",
+  "Home",
+  "End",
+  "PageUp",
+  "PageDown"
+]);
+function isNavigationKey(input) {
+  if (!NAVIGATION_KEYS.has(input.key)) return false;
+  if (input.altKey === true || input.metaKey === true) return false;
+  if (input.ctrlKey === true) return input.key === "Home" || input.key === "End";
+  return true;
+}
+var clamp = (value, max) => Math.max(0, Math.min(max, value));
+function clampNav(state, bounds) {
+  const row = clamp(state.row, bounds.rowCount - 1);
+  const col = clamp(state.col, bounds.columnCount - 1);
+  return row === state.row && col === state.col ? state : { row, col };
+}
+function navigate(state, input, bounds) {
+  if (!isNavigationKey(input) || bounds.rowCount <= 0 || bounds.columnCount <= 0) return state;
+  const lastRow = bounds.rowCount - 1;
+  const lastCol = bounds.columnCount - 1;
+  const forward = bounds.rtl === true ? "ArrowLeft" : "ArrowRight";
+  const pageSize = Math.max(1, Math.floor(bounds.pageSize));
+  let row = state.row;
+  let col = state.col;
+  switch (input.key) {
+    case "ArrowUp":
+      row -= 1;
+      break;
+    case "ArrowDown":
+      row += 1;
+      break;
+    case "ArrowLeft":
+    case "ArrowRight":
+      col += input.key === forward ? 1 : -1;
+      break;
+    case "Home":
+      col = 0;
+      if (input.ctrlKey === true) row = 0;
+      break;
+    case "End":
+      col = lastCol;
+      if (input.ctrlKey === true) row = lastRow;
+      break;
+    case "PageUp":
+      row -= pageSize;
+      break;
+    case "PageDown":
+      row += pageSize;
+      break;
+    default:
+      return state;
+  }
+  row = clamp(row, lastRow);
+  col = clamp(col, lastCol);
+  return row === state.row && col === state.col ? state : { row, col };
+}
+
+// src/state.ts
+function createViewState(columns) {
+  const visibility = {};
+  const pinning = { start: [], end: [] };
+  for (const column of columns) {
+    if (column.hidden === true) visibility[column.id] = false;
+    if (column.pinned === "start") pinning.start.push(column.id);
+    if (column.pinned === "end") pinning.end.push(column.id);
+  }
+  return {
+    sort: [],
+    filter: [],
+    group: [],
+    columnOrder: columns.map((column) => column.id),
+    columnVisibility: visibility,
+    columnSizing: {},
+    columnPinning: pinning
+  };
+}
+function resolveColumnOrder(columns, order) {
+  const known = new Set(columns.map((column) => column.id));
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const id of order) {
+    if (known.has(id) && !seen.has(id)) {
+      seen.add(id);
+      out.push(id);
+    }
+  }
+  for (const column of columns) {
+    if (!seen.has(column.id)) {
+      seen.add(column.id);
+      out.push(column.id);
+    }
+  }
+  return out;
+}
+function layoutColumns(columns, state) {
+  const byId = indexColumns(columns);
+  const visible = (id) => byId.has(id) && state.columnVisibility[id] !== false;
+  const start = state.columnPinning.start.filter(visible);
+  const end = state.columnPinning.end.filter((id) => visible(id) && !start.includes(id));
+  const pinned = /* @__PURE__ */ new Set([...start, ...end]);
+  const center = resolveColumnOrder(columns, state.columnOrder).filter((id) => visible(id) && !pinned.has(id));
+  return { start, center, end };
+}
+function toggleSort(sort, field, multi = false) {
+  const current = sort.find((item) => item.field === field)?.direction;
+  const next = current === void 0 ? "asc" : current === "asc" ? "desc" : null;
+  return setSort(sort, field, next, multi);
+}
+function setSort(sort, field, direction, multi = false) {
+  if (!multi) return direction === null ? [] : [{ field, direction }];
+  const exists = sort.some((item) => item.field === field);
+  if (direction === null) return sort.filter((item) => item.field !== field);
+  if (!exists) return [...sort, { field, direction }];
+  return sort.map((item) => item.field === field ? { field, direction } : item);
+}
+function sortRank(sort, field) {
+  const position = sort.findIndex((item) => item.field === field);
+  return position < 0 ? null : position + 1;
+}
+function setColumnFilter(filter, field, item) {
+  const rest = filter.filter((entry) => entry.field !== field);
+  return item === null ? rest : [...rest, item];
+}
+function toggleGroup(group, field) {
+  return group.some((item) => item.field === field) ? group.filter((item) => item.field !== field) : [...group, { field }];
+}
+function setPinning(pinning, id, pin) {
+  const start = pinning.start.filter((entry) => entry !== id);
+  const end = pinning.end.filter((entry) => entry !== id);
+  if (pin === "start") start.push(id);
+  if (pin === "end") end.push(id);
+  return { start, end };
+}
+function moveWithin(list, id, targetId) {
+  const from = list.indexOf(id);
+  const to = list.indexOf(targetId);
+  if (from < 0 || to < 0 || from === to) return list.slice();
+  const next = list.slice();
+  next.splice(from, 1);
+  next.splice(to, 0, id);
+  return next;
+}
+function moveColumn(columns, state, id, delta) {
+  const layout = layoutColumns(columns, state);
+  const order = resolveColumnOrder(columns, state.columnOrder);
+  const unchanged = { columnOrder: order, columnPinning: state.columnPinning };
+  const zone = layout.start.includes(id) ? "start" : layout.end.includes(id) ? "end" : layout.center.includes(id) ? "center" : null;
+  if (zone === null) return unchanged;
+  const ids = layout[zone];
+  const target = ids[ids.indexOf(id) + delta];
+  if (target === void 0) return unchanged;
+  if (zone === "center") return { columnOrder: moveWithin(order, id, target), columnPinning: state.columnPinning };
+  const pinning = { start: state.columnPinning.start.slice(), end: state.columnPinning.end.slice() };
+  pinning[zone] = moveWithin(pinning[zone], id, target);
+  return { columnOrder: order, columnPinning: pinning };
+}
+function moveColumnTo(columns, state, id, targetId, placement) {
+  const layout = layoutColumns(columns, state);
+  const order = resolveColumnOrder(columns, state.columnOrder);
+  const unchanged = { columnOrder: order, columnPinning: state.columnPinning };
+  const zoneOf = (columnId) => layout.start.includes(columnId) ? "start" : layout.end.includes(columnId) ? "end" : layout.center.includes(columnId) ? "center" : null;
+  const zone = zoneOf(id);
+  if (zone === null || id === targetId || zone !== zoneOf(targetId)) return unchanged;
+  const place = (list) => {
+    if (!list.includes(id) || !list.includes(targetId)) return null;
+    const rest = list.filter((entry) => entry !== id);
+    rest.splice(rest.indexOf(targetId) + (placement === "after" ? 1 : 0), 0, id);
+    return rest;
+  };
+  if (zone === "center") {
+    const next2 = place(order);
+    return next2 === null ? unchanged : { columnOrder: next2, columnPinning: state.columnPinning };
+  }
+  const next = place(state.columnPinning[zone]);
+  if (next === null) return unchanged;
+  return { columnOrder: order, columnPinning: { ...state.columnPinning, [zone]: next } };
+}
+function resizeColumn(columns, sizing, id, width) {
+  const column = indexColumns(columns).get(id);
+  if (column === void 0) return { ...sizing };
+  return { ...sizing, [id]: clampColumnWidth(column, width) };
+}
+
+// src/csv.ts
+var PLAIN_NUMBER = /^[+-][\p{Sc}\s\d.,%()]*$/u;
+function escapeDelimitedField(text, delimiter = ",") {
+  if (text === "") return "";
+  const needsQuotes = text.includes(delimiter) || text.includes('"') || text.includes("\n") || text.includes("\r");
+  return needsQuotes ? `"${text.replace(/"/g, '""')}"` : text;
+}
+function escapeCsvField(text, delimiter = ",") {
+  return escapeDelimitedField(text, delimiter);
+}
+function neutralizeFormula(text) {
+  if (text === "") return text;
+  const first = text.charAt(0);
+  if (first === "=" || first === "@" || first === "	" || first === "\r") return `'${text}`;
+  if ((first === "+" || first === "-") && !PLAIN_NUMBER.test(text)) return `'${text}`;
+  return text;
+}
+function rawText(value) {
+  if (isEmptyValue(value)) return "";
+  return toText(value);
+}
+function exportableColumns(columns) {
+  return columns.filter((column) => column.cellType !== "actions");
+}
+function toDelimited(rows, columns, options, defaults) {
+  const delimiter = options.delimiter ?? defaults.delimiter;
+  const eol = options.eol ?? defaults.eol;
+  const sanitize = options.sanitizeFormulas ?? defaults.sanitize;
+  const formatted = (options.values ?? "formatted") === "formatted";
+  const fields = exportableColumns(columns).map((column) => ({
+    column,
+    format: formatted ? createCellFormatter(column, options) : null
+  }));
+  const cell = (text) => escapeDelimitedField(sanitize ? neutralizeFormula(text) : text, delimiter);
+  const lines = [];
+  if (options.header !== false) {
+    lines.push(fields.map(({ column }) => cell(column.header)).join(delimiter));
+  }
+  for (const row of rows) {
+    lines.push(
+      fields.map(({ column, format }) => {
+        const value = getColumnValue(column, row);
+        return cell(format === null ? rawText(value) : format(value, row));
+      }).join(delimiter)
+    );
+  }
+  return lines.join(eol);
+}
+function gridToCsv(rows, columns, options = {}) {
+  const body = toDelimited(rows, columns, options, { delimiter: ",", eol: "\r\n", sanitize: true });
+  return options.bom === true ? `\uFEFF${body}` : body;
+}
+function gridToTsv(rows, columns, options = {}) {
+  return toDelimited(rows, columns, options, { delimiter: "	", eol: "\n", sanitize: false });
+}
+function parseDelimited(text, delimiter = ",") {
+  const source = text.charCodeAt(0) === 65279 ? text.slice(1) : text;
+  const rows = [];
+  let row = [];
+  let field = "";
+  let quoted = false;
+  for (let i = 0; i < source.length; i += 1) {
+    const char = source.charAt(i);
+    if (quoted) {
+      if (char === '"') {
+        if (source.charAt(i + 1) === '"') {
+          field += '"';
+          i += 1;
+        } else quoted = false;
+      } else field += char;
+    } else if (char === '"') quoted = true;
+    else if (char === delimiter) {
+      row.push(field);
+      field = "";
+    } else if (char === "\n" || char === "\r") {
+      if (char === "\r" && source.charAt(i + 1) === "\n") i += 1;
+      row.push(field);
+      rows.push(row);
+      row = [];
+      field = "";
+    } else field += char;
+  }
+  if (field !== "" || row.length > 0) {
+    row.push(field);
+    rows.push(row);
+  }
+  return rows;
+}
+
+// src/saved-views.ts
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isOptionalNumber = (value) => value === void 0 || typeof value === "number" && Number.isFinite(value);
+function parseSavedView(value) {
+  if (!isRecord(value) || value.version !== SAVED_VIEW_VERSION) return null;
+  if (value.name !== void 0 && typeof value.name !== "string") return null;
+  const { columns, sort, filter, group } = value;
+  if (!Array.isArray(columns) || !Array.isArray(sort) || !Array.isArray(filter)) return null;
+  if (group !== void 0 && !Array.isArray(group)) return null;
+  for (const column of columns) {
+    if (!isRecord(column) || typeof column.id !== "string") return null;
+    if (!isOptionalNumber(column.width)) return null;
+    if (column.hidden !== void 0 && typeof column.hidden !== "boolean") return null;
+    if (column.pinned !== void 0 && column.pinned !== "start" && column.pinned !== "end") {
+      return null;
+    }
+  }
+  for (const item of sort) {
+    if (!isRecord(item) || typeof item.field !== "string") return null;
+    if (item.direction !== "asc" && item.direction !== "desc") return null;
+  }
+  for (const item of filter) {
+    if (!isRecord(item) || typeof item.field !== "string") return null;
+    if (!FILTER_OPERATORS.includes(item.operator)) return null;
+  }
+  for (const item of group ?? []) {
+    if (!isRecord(item) || typeof item.field !== "string") return null;
+  }
+  return value;
+}
+function captureView(state, columns, options = {}) {
+  const known = indexColumns(columns);
+  const pinnedStart = state.columnPinning.start.filter((id) => known.has(id));
+  const pinnedEnd = state.columnPinning.end.filter((id) => known.has(id) && !pinnedStart.includes(id));
+  const pinned = /* @__PURE__ */ new Set([...pinnedStart, ...pinnedEnd]);
+  const center = resolveColumnOrder(columns, state.columnOrder).filter((id) => !pinned.has(id));
+  const entry = (id, pin) => {
+    const out = { id };
+    const width = state.columnSizing[id];
+    if (width !== void 0) out.width = width;
+    if (state.columnVisibility[id] === false) out.hidden = true;
+    if (pin !== void 0) out.pinned = pin;
+    return out;
+  };
+  const view = {
+    version: SAVED_VIEW_VERSION,
+    columns: [
+      ...pinnedStart.map((id) => entry(id, "start")),
+      ...center.map((id) => entry(id)),
+      ...pinnedEnd.map((id) => entry(id, "end"))
+    ],
+    sort: state.sort.filter((item) => known.has(item.field)).map((item) => ({ ...item })),
+    filter: state.filter.filter((item) => known.has(item.field)).map((item) => ({ ...item }))
+  };
+  if (options.name !== void 0) view.name = options.name;
+  if (state.group.length > 0) view.group = state.group.filter((item) => known.has(item.field)).map((item) => ({ ...item }));
+  return view;
+}
+function applySavedView(view, columns) {
+  const defaults = createViewState(columns);
+  const known = indexColumns(columns);
+  const inView = view.columns.filter((column) => known.has(column.id));
+  const mentioned = new Set(inView.map((column) => column.id));
+  const visibility = {};
+  for (const column of columns) {
+    if (!mentioned.has(column.id) && defaults.columnVisibility[column.id] === false) visibility[column.id] = false;
+  }
+  const sizing = {};
+  const pinning = { start: [], end: [] };
+  for (const column of inView) {
+    if (column.hidden === true) visibility[column.id] = false;
+    if (column.width !== void 0) sizing[column.id] = column.width;
+    if (column.pinned === "start") pinning.start.push(column.id);
+    if (column.pinned === "end") pinning.end.push(column.id);
+  }
+  for (const column of columns) {
+    if (mentioned.has(column.id)) continue;
+    if (column.pinned === "start") pinning.start.push(column.id);
+    if (column.pinned === "end") pinning.end.push(column.id);
+  }
+  return {
+    sort: view.sort.filter((item) => known.has(item.field)).map((item) => ({ ...item })),
+    filter: view.filter.filter((item) => known.has(item.field)).map((item) => ({ ...item })),
+    group: (view.group ?? []).filter((item) => known.has(item.field)).map((item) => ({ ...item })),
+    columnOrder: resolveColumnOrder(
+      columns,
+      inView.map((column) => column.id)
+    ),
+    columnVisibility: visibility,
+    columnSizing: sizing,
+    columnPinning: pinning
+  };
+}
+function createMemorySavedViewStore(initial = {}) {
+  const views = new Map(Object.entries(initial));
+  return {
+    list: async () => [...views.entries()].map(([id, view]) => view.name === void 0 ? { id } : { id, name: view.name }),
+    load: async (id) => {
+      const view = views.get(id);
+      return view === void 0 ? null : parseSavedView(JSON.parse(JSON.stringify(view)));
+    },
+    save: async (id, view) => {
+      views.set(id, JSON.parse(JSON.stringify(view)));
+    },
+    delete: async (id) => {
+      views.delete(id);
+    }
+  };
+}
+function createLocalStorageSavedViewStore(options = {}) {
+  const key = options.key ?? "x12i-data-views";
+  const fallback = /* @__PURE__ */ new Map();
+  const resolve = () => {
+    if (options.storage !== void 0) return options.storage;
+    try {
+      const candidate = globalThis.localStorage;
+      if (candidate !== void 0) return candidate;
+    } catch {
+    }
+    return { getItem: (k) => fallback.get(k) ?? null, setItem: (k, v) => void fallback.set(k, v) };
+  };
+  const read = () => {
+    try {
+      const parsed = JSON.parse(resolve().getItem(key) ?? "{}");
+      return isRecord(parsed) ? parsed : {};
+    } catch {
+      return {};
+    }
+  };
+  return {
+    list: async () => {
+      const out = [];
+      for (const [id, value] of Object.entries(read())) {
+        const view = parseSavedView(value);
+        if (view !== null) out.push(view.name === void 0 ? { id } : { id, name: view.name });
+      }
+      return out;
+    },
+    load: async (id) => parseSavedView(read()[id]),
+    save: async (id, view) => {
+      resolve().setItem(key, JSON.stringify({ ...read(), [id]: view }));
+    },
+    delete: async (id) => {
+      const all = read();
+      delete all[id];
+      resolve().setItem(key, JSON.stringify(all));
+    }
+  };
+}
+
+// src/server.ts
+function createAbortError(message = "Aborted") {
+  if (typeof DOMException === "function") return new DOMException(message, "AbortError");
+  const error = new Error(message);
+  error.name = "AbortError";
+  return error;
+}
+function isAbortError(error) {
+  return typeof error === "object" && error !== null && error.name === "AbortError";
+}
+function mapFields(items, map) {
+  return items.map((item) => ({ ...item, field: map.get(item.field) ?? item.field }));
+}
+function toServerQuery(columns, query) {
+  const map = new Map(columns.map((column) => [column.id, columnFieldName(column)]));
+  const out = {
+    sort: mapFields(query.sort, map),
+    filter: mapFields(query.filter, map),
+    group: mapFields(query.group, map)
+  };
+  if (query.quickFilter !== void 0 && query.quickFilter !== "") out.quickFilter = query.quickFilter;
+  return out;
+}
+function fromServerQuery(columns, query) {
+  const map = new Map(columns.map((column) => [columnFieldName(column), column.id]));
+  const out = {
+    sort: mapFields(query.sort, map),
+    filter: mapFields(query.filter, map),
+    group: mapFields(query.group, map)
+  };
+  if (query.quickFilter !== void 0) out.quickFilter = query.quickFilter;
+  return out;
+}
+function delay(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted === true) {
+      reject(createAbortError());
+      return;
+    }
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(createAbortError());
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+function createClientDataSource(rows, columns, options = {}) {
+  return {
+    async getRows(request, requestOptions) {
+      const latency = typeof options.latency === "function" ? options.latency() : options.latency ?? 0;
+      await delay(latency, requestOptions?.signal);
+      const failure = options.fail?.(request);
+      if (failure !== void 0 && failure !== false && failure !== null) {
+        throw failure instanceof Error ? failure : new Error(String(failure));
+      }
+      const local = fromServerQuery(columns, request);
+      const indexes = computeViewIndexes(rows, columns, {
+        sort: local.sort,
+        filter: local.filter,
+        ...local.quickFilter === void 0 ? {} : { quickFilter: local.quickFilter },
+        ...options.locale === void 0 ? {} : { locale: options.locale }
+      });
+      const slice = indexes.slice(request.startRow, request.endRow);
+      const result = { rows: slice.map((index) => rows[index]), total: indexes.length };
+      return result;
+    }
+  };
+}
+function createServerRowStore(options) {
+  const { dataSource } = options;
+  let blockSize = Math.max(1, Math.floor(options.blockSize));
+  let query = options.query ?? { sort: [], filter: [], group: [] };
+  let queryKey = JSON.stringify(query);
+  const blocks = /* @__PURE__ */ new Map();
+  const cursors = /* @__PURE__ */ new Map();
+  let cursorMode = false;
+  let total = null;
+  let totalStale = false;
+  let lastError = null;
+  let version = 0;
+  let destroyed = false;
+  let windowStart = 0;
+  let windowEnd = 0;
+  const listeners = /* @__PURE__ */ new Set();
+  const compute = () => {
+    let loading = false;
+    let stale = totalStale;
+    const first = Math.floor(windowStart / blockSize);
+    const last = Math.floor((windowEnd - 1) / blockSize);
+    for (const [index, block] of blocks) {
+      if (block.status === "loading") loading = true;
+      if (block.stale && index >= first && index <= last) stale = true;
+    }
+    return { version, total, loading, error: lastError, stale };
+  };
+  let snapshot = compute();
+  const emit = () => {
+    version += 1;
+    snapshot = compute();
+    for (const listener of [...listeners]) listener();
+  };
+  const abortAll = () => {
+    for (const block of blocks.values()) {
+      block.controller?.abort();
+      block.controller = null;
+    }
+  };
+  const load = (index) => {
+    const existing = blocks.get(index);
+    const block = existing ?? { status: "idle", rows: [], stale: false, controller: null };
+    blocks.set(index, block);
+    block.controller?.abort();
+    const controller = new AbortController();
+    block.controller = controller;
+    block.status = "loading";
+    const request = {
+      startRow: index * blockSize,
+      endRow: (index + 1) * blockSize,
+      sort: query.sort,
+      filter: query.filter,
+      group: query.group
+    };
+    if (query.quickFilter !== void 0 && query.quickFilter !== "") request.quickFilter = query.quickFilter;
+    if (cursorMode) request.cursor = index === 0 ? null : cursors.get(index) ?? null;
+    return dataSource.getRows(request, { signal: controller.signal }).then(
+      (result) => {
+        if (destroyed || block.controller !== controller || controller.signal.aborted) return;
+        block.controller = null;
+        block.status = "loaded";
+        block.rows = result.rows;
+        block.stale = false;
+        total = result.total;
+        totalStale = false;
+        lastError = null;
+        if (result.nextCursor !== void 0) {
+          cursorMode = true;
+          cursors.set(index + 1, result.nextCursor);
+        }
+        emit();
+      },
+      (error) => {
+        if (destroyed || block.controller !== controller || controller.signal.aborted || isAbortError(error)) return;
+        block.controller = null;
+        block.status = "error";
+        lastError = error;
+        emit();
+      }
+    );
+  };
+  const loadWithCursors = async (index) => {
+    let start = index;
+    while (start > 0 && !cursors.has(start)) start -= 1;
+    for (let next = start; next <= index; next += 1) {
+      const block = blocks.get(next);
+      if (block !== void 0 && block.status === "loaded" && !block.stale) continue;
+      await load(next);
+      if (blocks.get(next)?.status !== "loaded") return;
+    }
+  };
+  const needsLoad = (block) => block === void 0 || block.status === "idle" || block.status === "loaded" && block.stale;
+  return {
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => void listeners.delete(listener);
+    },
+    getSnapshot: () => snapshot,
+    setQuery(next) {
+      const key = JSON.stringify(next);
+      if (key === queryKey) return false;
+      queryKey = key;
+      query = next;
+      abortAll();
+      cursors.clear();
+      for (const [index, block] of [...blocks.entries()]) {
+        if (block.status === "loaded") {
+          block.stale = true;
+          block.status = "idle";
+        } else {
+          blocks.delete(index);
+        }
+      }
+      lastError = null;
+      totalStale = total !== null;
+      emit();
+      return true;
+    },
+    setBlockSize(size) {
+      const next = Math.max(1, Math.floor(size));
+      if (next === blockSize) return;
+      blockSize = next;
+      abortAll();
+      blocks.clear();
+      cursors.clear();
+      total = null;
+      totalStale = false;
+      lastError = null;
+      emit();
+    },
+    request(startRow, endRow) {
+      if (destroyed || endRow <= startRow) return;
+      windowStart = Math.max(0, startRow);
+      windowEnd = endRow;
+      const first = Math.floor(Math.max(0, startRow) / blockSize);
+      const last = Math.floor((endRow - 1) / blockSize);
+      for (let index = first; index <= last; index += 1) {
+        if (!needsLoad(blocks.get(index))) continue;
+        if (cursorMode && index > 0) {
+          if (cursors.has(index)) void load(index);
+          else void loadWithCursors(index);
+        } else {
+          void load(index);
+        }
+      }
+      const next = compute();
+      if (snapshot.loading !== next.loading || snapshot.stale !== next.stale) emit();
+    },
+    getRow(index) {
+      const block = blocks.get(Math.floor(index / blockSize));
+      return block?.rows[index % blockSize];
+    },
+    getBlockStatus(index) {
+      const block = blocks.get(Math.floor(index / blockSize));
+      if (block === void 0) return "idle";
+      return block.stale && block.status === "idle" ? "loaded" : block.status;
+    },
+    isStale(index) {
+      return blocks.get(Math.floor(index / blockSize))?.stale === true;
+    },
+    retry() {
+      const failed = [...blocks.entries()].filter(([, block]) => block.status === "error").map(([index]) => index);
+      if (failed.length === 0) return;
+      lastError = null;
+      for (const index of failed) {
+        if (cursorMode && index > 0 && !cursors.has(index)) void loadWithCursors(index);
+        else void load(index);
+      }
+      emit();
+    },
+    reset() {
+      abortAll();
+      blocks.clear();
+      cursors.clear();
+      total = null;
+      totalStale = false;
+      lastError = null;
+      emit();
+    },
+    destroy() {
+      destroyed = true;
+      abortAll();
+      listeners.clear();
+    }
+  };
+}
+
+// src/message-format.ts
+function formatMessage(template, values = {}, locale) {
+  return render(template, values, locale, void 0);
+}
+function formatNumber(value, locale) {
+  try {
+    return new Intl.NumberFormat(locale).format(value);
+  } catch {
+    return String(value);
+  }
+}
+function formatValue(value, locale) {
+  if (value === void 0) return "";
+  return typeof value === "number" ? formatNumber(value, locale) : value;
+}
+function closingBrace(text, open) {
+  let depth = 0;
+  for (let i = open; i < text.length; i += 1) {
+    const char = text.charAt(i);
+    if (char === "{") depth += 1;
+    else if (char === "}") {
+      depth -= 1;
+      if (depth === 0) return i;
+    }
+  }
+  return -1;
+}
+function render(template, values, locale, pluralValue) {
+  let out = "";
+  let i = 0;
+  while (i < template.length) {
+    const char = template.charAt(i);
+    if (char === "{") {
+      const end = closingBrace(template, i);
+      if (end < 0) {
+        out += template.slice(i);
+        break;
+      }
+      out += evaluate(template.slice(i + 1, end), values, locale);
+      i = end + 1;
+    } else if (char === "#" && pluralValue !== void 0) {
+      out += formatNumber(pluralValue, locale);
+      i += 1;
+    } else {
+      out += char;
+      i += 1;
+    }
+  }
+  return out;
+}
+function evaluate(body, values, locale) {
+  const firstComma = body.indexOf(",");
+  if (firstComma < 0) return formatValue(values[body.trim()], locale);
+  const name = body.slice(0, firstComma).trim();
+  const rest = body.slice(firstComma + 1);
+  const secondComma = rest.indexOf(",");
+  if (secondComma < 0) return formatValue(values[name], locale);
+  const kind = rest.slice(0, secondComma).trim();
+  const branchesSource = rest.slice(secondComma + 1);
+  const branches = /* @__PURE__ */ new Map();
+  let i = 0;
+  while (i < branchesSource.length) {
+    while (i < branchesSource.length && /\s/.test(branchesSource.charAt(i))) i += 1;
+    let selector = "";
+    while (i < branchesSource.length && !/[\s{]/.test(branchesSource.charAt(i))) {
+      selector += branchesSource.charAt(i);
+      i += 1;
+    }
+    while (i < branchesSource.length && /\s/.test(branchesSource.charAt(i))) i += 1;
+    if (branchesSource.charAt(i) !== "{") break;
+    const end = closingBrace(branchesSource, i);
+    if (end < 0) break;
+    branches.set(selector, branchesSource.slice(i + 1, end));
+    i = end + 1;
+  }
+  const value = values[name];
+  if (kind === "plural") {
+    const count = typeof value === "number" ? value : Number(value);
+    if (Number.isNaN(count)) return "";
+    let category = "other";
+    try {
+      category = new Intl.PluralRules(locale).select(count);
+    } catch {
+    }
+    const chosen = branches.get(`=${count}`) ?? branches.get(category) ?? branches.get("other") ?? "";
+    return render(chosen, values, locale, count);
+  }
+  if (kind === "select") {
+    const chosen = branches.get(String(value)) ?? branches.get("other") ?? "";
+    return render(chosen, values, locale, void 0);
+  }
+  return formatValue(value, locale);
+}
+
+// src/messages.ts
+var defaultMessages = {
+  loading: "Loading rows",
+  loadingMore: "Loading more rows",
+  empty: "No rows to show",
+  emptyFiltered: "No rows match the current filters",
+  error: "Could not load rows",
+  retry: "Try again",
+  clearFilters: "Clear filters",
+  toolbarLabel: "Grid tools",
+  quickSearch: "Search rows",
+  quickSearchPlaceholder: "Search",
+  clearSearch: "Clear search",
+  columns: "Columns",
+  columnsMenuLabel: "Show or hide columns",
+  showAllColumns: "Show all columns",
+  exportCsv: "Export CSV",
+  copySelection: "Copy",
+  copied: "{count, plural, one {Copied # row} other {Copied # rows}}",
+  copyFailed: "Could not copy to the clipboard",
+  selectedCount: "{count, plural, one {# row selected} other {# rows selected}}",
+  allSelected: "All {count, plural, one {# row} other {# rows}} selected",
+  clearSelection: "Clear selection",
+  selectAll: "Select all rows",
+  selectRow: "Select row",
+  sortAscending: "Sort ascending",
+  sortDescending: "Sort descending",
+  clearSort: "Clear sort",
+  filterColumn: "Filter {column}",
+  columnMenu: "Options for {column}",
+  hideColumn: "Hide column",
+  pinStart: "Pin to start",
+  pinEnd: "Pin to end",
+  unpin: "Unpin",
+  moveEarlier: "Move earlier",
+  moveLater: "Move later",
+  groupBy: "Group by {column}",
+  ungroup: "Stop grouping by {column}",
+  resizeColumn: "Resize {column}",
+  sortRank: "Sort priority {rank}",
+  filterOperator: "Operator",
+  filterValue: "Value",
+  filterFrom: "From",
+  filterTo: "To",
+  filterApply: "Apply",
+  filterClear: "Clear",
+  filterAny: "Any",
+  filterNoOptions: "No values to choose from",
+  filterBlank: "(Blank)",
+  operators: {
+    contains: "contains",
+    "not-contains": "does not contain",
+    "starts-with": "starts with",
+    equals: "is",
+    "not-equals": "is not",
+    gt: "is greater than",
+    gte: "is at least",
+    lt: "is less than",
+    lte: "is at most",
+    between: "is between",
+    in: "is one of",
+    before: "is before",
+    after: "is after",
+    "is-empty": "is empty",
+    "is-not-empty": "is not empty"
+  },
+  activeFilters: "Active filters",
+  filterSummary: "{column} {operator} {value}",
+  removeFilter: "Remove filter {summary}",
+  clearAllFilters: "Clear all",
+  groupedBy: "Grouped by {column}",
+  removeGrouping: "Stop grouping by {column}",
+  expandRow: "Expand row",
+  collapseRow: "Collapse row",
+  expandGroup: "Expand group",
+  collapseGroup: "Collapse group",
+  groupLabel: "{value} ({count})",
+  rowActions: "Row actions",
+  detailRegion: "Row details",
+  totals: "Total",
+  yes: "Yes",
+  no: "No",
+  moreTags: "+{count}",
+  progressLabel: "{value} complete",
+  editCell: "Edit {column}",
+  cellEditFailed: "Could not save {column}. The change was undone.",
+  cellSaved: "{column} saved",
+  invalidNumber: "Enter a number",
+  invalidDate: "Enter a valid date",
+  announceSorted: "Sorted by {column}, {direction, select, desc {descending} other {ascending}}. {count, plural, one {# row} other {# rows}}.",
+  announceSortCleared: "Sorting cleared. {count, plural, one {# row} other {# rows}}.",
+  announceFiltered: "{count, plural, =0 {No rows match} one {# row matches} other {# rows match}} the filters.",
+  announceFilterCleared: "Filters cleared. {count, plural, one {# row} other {# rows}}.",
+  announceGrouped: "Grouped by {column}.",
+  announceColumnMoved: "{column} moved to position {position} of {total}.",
+  announceColumnHidden: "{column} hidden.",
+  announceColumnResized: "{column} width {width} pixels.",
+  announcePinned: "{column} pinned to the {side, select, end {end} other {start}}.",
+  announceSelection: "{count, plural, one {# row selected} other {# rows selected}}.",
+  rowLoading: "Loading row",
+  rowFailed: "Row could not be loaded",
+  paginationLabel: "Pagination",
+  pageSize: "Rows per page",
+  firstPage: "First page",
+  previousPage: "Previous page",
+  nextPage: "Next page",
+  lastPage: "Last page",
+  pageRange: "{start}\u2013{end} of {total}",
+  pageStatus: "Page {page} of {pages}"
+};
+function resolveMessages(overrides) {
+  if (overrides === void 0) return defaultMessages;
+  const { operators, ...rest } = overrides;
+  const merged = { ...defaultMessages };
+  for (const [key, value] of Object.entries(rest)) if (value !== void 0) merged[key] = value;
+  return {
+    ...merged,
+    operators: { ...defaultMessages.operators, ...operators }
+  };
+}
+
+export {
+  defineColumns,
+  SAVED_VIEW_VERSION,
+  FILTER_OPERATORS,
+  DEFAULT_COLUMN_WIDTH,
+  DEFAULT_COLUMN_MIN_WIDTH,
+  DEFAULT_COLUMN_MAX_WIDTH,
+  getColumnValue,
+  columnFieldName,
+  isNumericCellType,
+  resolveColumnAlign,
+  resolveFilterType,
+  resolveEditor,
+  isSortable,
+  isFilterable,
+  isResizable,
+  isEditable,
+  clampColumnWidth,
+  initialColumnWidth,
+  indexColumns,
+  isDateOnlyString,
+  isEmptyValue,
+  toNumber,
+  toTimestamp,
+  toDate,
+  toText,
+  normalizeText,
+  toBoolean,
+  defaultFormatLabels,
+  resolveNumberFormatOptions,
+  resolveDateFormatOptions,
+  createCellFormatter,
+  formatCellValue,
+  createCollator,
+  toSortKey,
+  compareValues,
+  sortIndexes,
+  sortRows,
+  OPERATORS_BY_FILTER_TYPE,
+  operatorsFor,
+  isValuelessOperator,
+  isFilterEffective,
+  toDayString,
+  dayStart,
+  nextDay,
+  createValuePredicate,
+  matchesFilter,
+  parseQuickFilter,
+  isSearchable,
+  createSearchIndex,
+  filterIndexes,
+  distinctValues,
+  aggregateValues,
+  computeAggregate,
+  computeAggregates,
+  buildGroupTree,
+  computeViewIndexes,
+  buildDisplayRows,
+  EMPTY_SELECTION,
+  createSelection,
+  isSelected,
+  isSelectionEmpty,
+  toggleRow,
+  selectOnly,
+  selectRange,
+  selectAll,
+  selectAllExceptNone,
+  clearSelection,
+  countSelected,
+  summarizeSelection,
+  resolveSelectedIds,
+  serializeSelection,
+  deserializeSelection,
+  isNavigationKey,
+  clampNav,
+  navigate,
+  createViewState,
+  resolveColumnOrder,
+  layoutColumns,
+  toggleSort,
+  setSort,
+  sortRank,
+  setColumnFilter,
+  toggleGroup,
+  setPinning,
+  moveColumn,
+  moveColumnTo,
+  resizeColumn,
+  escapeDelimitedField,
+  escapeCsvField,
+  exportableColumns,
+  gridToCsv,
+  gridToTsv,
+  parseDelimited,
+  parseSavedView,
+  captureView,
+  applySavedView,
+  createMemorySavedViewStore,
+  createLocalStorageSavedViewStore,
+  createAbortError,
+  isAbortError,
+  toServerQuery,
+  fromServerQuery,
+  createClientDataSource,
+  createServerRowStore,
+  formatMessage,
+  defaultMessages,
+  resolveMessages
+};
+//# sourceMappingURL=chunk-ASP4ABDG.js.map