@alfadocs/ui-kit 1.54.3 → 1.55.0

package/dist/_chunks/heatmap-BARGZZt2.js

@@ -0,0 +1,2865 @@
+import { jsx as v, jsxs as P, Fragment as La } from "react/jsx-runtime";
+import { useContext as Ea, createContext as Aa, useId as Ka, useRef as $, useMemo as _, useState as le, useCallback as C, useEffect as gt, memo as Ca, forwardRef as fa, lazy as va, Suspense as Ha } from "react";
+import { useTranslation as Ht } from "react-i18next";
+import { u as Oa } from "./registry-DvAUVLHh.js";
+import { f as wa } from "./intl-locale-ySteXlDD.js";
+import { B as za } from "./button-Bn16lcFM.js";
+import { E as Va } from "./empty-state-gNG3qYCX.js";
+import { L as Ba } from "./live-region-C41SO3cA.js";
+import { S as jt } from "./skeleton-B1KTdJ4N.js";
+import { T as ba, a as Fa } from "./tooltip-Cp-PLePW.js";
+import { p as Ga } from "./privacy-mask-ChIjELJC.js";
+import { u as Je } from "./use-isomorphic-layout-effect-BGfaCOP1.js";
+import { i as $a } from "./is-development-CLUAnsU7.js";
+import { c as oe } from "./index-D2ZczOXr.js";
+import { C as Da } from "./chevron-down-DWE7GSq9.js";
+import { E as ja } from "./error-boundary-ChowhO6w.js";
+import { c as ya } from "./createLucideIcon-DhHxpK9K.js";
+/**
+ * @license lucide-react v1.22.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const Pa = [
+  ["rect", { width: "18", height: "18", x: "3", y: "3", rx: "2", key: "afitv7" }],
+  ["path", { d: "M3 9h18", key: "1pudct" }],
+  ["path", { d: "M3 15h18", key: "5xshup" }],
+  ["path", { d: "M9 3v18", key: "fh3hqa" }],
+  ["path", { d: "M15 3v18", key: "14nvp0" }]
+], qa = ya("grid-3x3", Pa);
+/**
+ * @license lucide-react v1.22.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const Wa = [
+  [
+    "path",
+    {
+      d: "M9 3H5a2 2 0 0 0-2 2v4m6-6h10a2 2 0 0 1 2 2v4M9 3v18m0 0h10a2 2 0 0 0 2-2V9M9 21H5a2 2 0 0 1-2-2V9m0 0h18",
+      key: "gugj83"
+    }
+  ]
+], Ua = ya("table-2", Wa), ut = {
+  type: "object",
+  properties: {
+    rowId: { type: "string", description: "Row id, from rowIds." },
+    columnId: {
+      type: ["string", "number"],
+      description: "Column id, from columnIds."
+    }
+  },
+  required: ["rowId", "columnId"]
+}, Ya = {
+  id: "heatmap",
+  capabilities: [
+    "select_single",
+    "select_multiple",
+    "range_pick",
+    "expand",
+    "sort",
+    "view_change"
+  ],
+  state: {
+    selection: {
+      type: "Array<{ rowId, columnId }>",
+      descriptionKey: "ui.agent.heatmap.state.selection",
+      description: "Row and column ids of the selected cells.",
+      read: (e) => e.getSelection()
+    },
+    selectionMode: {
+      type: "'none' | 'single' | 'multiple' | 'range'",
+      descriptionKey: "ui.agent.heatmap.state.selectionMode",
+      description: "How cells can be selected in this heatmap.",
+      read: (e) => e.getSelectionMode()
+    },
+    view: {
+      type: "'heatmap' | 'table'",
+      descriptionKey: "ui.agent.heatmap.state.view",
+      description: "Whether the heatmap or its table view is showing.",
+      read: (e) => e.getView()
+    },
+    sortRows: {
+      type: "'none' | 'label' | 'total-asc' | 'total-desc'",
+      descriptionKey: "ui.agent.heatmap.state.sortRows",
+      description: "Current row order.",
+      read: (e) => e.getSortRows()
+    },
+    rowIds: {
+      type: "string[]",
+      descriptionKey: "ui.agent.heatmap.state.rowIds",
+      description: "Row ids in display order, every group expanded. Opaque, never a label.",
+      read: (e) => e.getRowIds()
+    },
+    columnIds: {
+      type: "Array<string | number>",
+      descriptionKey: "ui.agent.heatmap.state.columnIds",
+      description: "Column ids in order. Opaque, never a label.",
+      read: (e) => e.getColumnIds()
+    },
+    groupIds: {
+      type: "string[]",
+      descriptionKey: "ui.agent.heatmap.state.groupIds",
+      description: "Group ids in display order, empty unless rows are grouped. A group not listed in `groups` shows as group-1, group-2 and so on.",
+      read: (e) => e.getGroupIds()
+    },
+    collapsedGroups: {
+      type: "string[]",
+      descriptionKey: "ui.agent.heatmap.state.collapsedGroups",
+      description: "Ids (as in groupIds) of the row groups that are collapsed.",
+      read: (e) => e.getCollapsedGroups()
+    }
+  },
+  actions: {
+    select_cell: {
+      safety: "read",
+      argsType: "{ rowId: string, columnId: string | number }",
+      argsSchema: ut,
+      idempotent: !0,
+      descriptionKey: "ui.agent.heatmap.actions.selectCell",
+      description: "Make one cell the whole selection.",
+      errors: [
+        'Selection is off (selection="none").',
+        "The row or column id does not exist."
+      ],
+      examples: [
+        {
+          args: { rowId: "chair-1", columnId: 10 },
+          note: "Select chair 1 at 10:00."
+        }
+      ],
+      invoke: (e, t) => {
+        e.selectCells([t]);
+      }
+    },
+    select_cells: {
+      safety: "read",
+      argsType: "{ cells: Array<{ rowId, columnId }> }",
+      argsSchema: {
+        type: "object",
+        properties: {
+          cells: {
+            type: "array",
+            items: ut,
+            description: "Cells to select; replaces the selection. Single mode keeps the first."
+          }
+        },
+        required: ["cells"]
+      },
+      idempotent: !0,
+      descriptionKey: "ui.agent.heatmap.actions.selectCells",
+      description: "Replace the selection with the given cells.",
+      errors: [
+        'Selection is off (selection="none").',
+        "A row or column id does not exist; nothing is selected."
+      ],
+      invoke: (e, t) => {
+        e.selectCells(t.cells);
+      }
+    },
+    select_range: {
+      safety: "read",
+      argsType: "{ from: { rowId, columnId }, to: { rowId, columnId } }",
+      argsSchema: {
+        type: "object",
+        properties: {
+          from: { ...ut, description: "One corner, inclusive." },
+          to: { ...ut, description: "The opposite corner, inclusive." }
+        },
+        required: ["from", "to"]
+      },
+      idempotent: !0,
+      descriptionKey: "ui.agent.heatmap.actions.selectRange",
+      description: "Select the rectangle of cells between two corners, in the rows as shown.",
+      errors: [
+        'Needs selection="range" or "multiple".',
+        "A corner names a row or column that does not exist."
+      ],
+      invoke: (e, t) => {
+        e.selectRange(t.from, t.to);
+      }
+    },
+    clear_selection: {
+      safety: "read",
+      idempotent: !0,
+      descriptionKey: "ui.agent.heatmap.actions.clearSelection",
+      description: "Deselect every cell.",
+      errors: ['Selection is off (selection="none").'],
+      invoke: (e) => {
+        e.clearSelection();
+      }
+    },
+    read_cell: {
+      safety: "read",
+      argsType: "{ rowId: string, columnId: string | number }",
+      argsSchema: ut,
+      returns: "{ value, count, status, step } | null",
+      returnsSchema: {
+        type: ["object", "null"],
+        properties: {
+          value: { type: ["number", "null"] },
+          count: { type: "number" },
+          status: { enum: ["value", "empty", "low-sample"] },
+          step: { type: ["number", "null"] }
+        }
+      },
+      idempotent: !0,
+      descriptionKey: "ui.agent.heatmap.actions.readCell",
+      description: "Read a cell's value, count, status and colour step (no labels).",
+      invoke: (e, t) => e.readCell(t)
+    },
+    toggle_table_view: {
+      safety: "read",
+      descriptionKey: "ui.agent.heatmap.actions.toggleTableView",
+      description: "Switch between the heatmap and its table view.",
+      returns: "'heatmap' | 'table'",
+      returnsSchema: { enum: ["heatmap", "table"] },
+      invoke: (e) => {
+        const t = e.getView() === "table" ? "heatmap" : "table";
+        return e.setView(t), t;
+      }
+    },
+    set_view: {
+      safety: "read",
+      argsType: "{ view: 'heatmap' | 'table' }",
+      argsSchema: {
+        type: "object",
+        properties: {
+          view: {
+            enum: ["heatmap", "table"],
+            description: "The coloured grid, or the same data as a table."
+          }
+        },
+        required: ["view"]
+      },
+      idempotent: !0,
+      descriptionKey: "ui.agent.heatmap.actions.setView",
+      description: "Show the heatmap or its table view.",
+      invoke: (e, t) => {
+        e.getView() !== t.view && e.setView(t.view);
+      }
+    },
+    sort_rows: {
+      safety: "read",
+      argsType: "{ sort: 'none' | 'label' | 'total-asc' | 'total-desc' }",
+      argsSchema: {
+        type: "object",
+        properties: {
+          sort: {
+            enum: ["none", "label", "total-asc", "total-desc"],
+            description: "Row order within each group: as given, by label, or by row total."
+          }
+        },
+        required: ["sort"]
+      },
+      idempotent: !0,
+      descriptionKey: "ui.agent.heatmap.actions.sortRows",
+      description: "Reorder the rows.",
+      invoke: (e, t) => {
+        e.setSortRows(t.sort);
+      }
+    },
+    expand_group: {
+      safety: "read",
+      argsType: "{ groupId: string }",
+      argsSchema: {
+        type: "object",
+        properties: {
+          groupId: { type: "string", description: "Group id, from groupIds." }
+        },
+        required: ["groupId"]
+      },
+      idempotent: !0,
+      descriptionKey: "ui.agent.heatmap.actions.expandGroup",
+      description: "Show a group's rows.",
+      errors: [
+        "Rows are not grouped (groupRows is off).",
+        "The group id does not exist (see groupIds)."
+      ],
+      invoke: (e, t) => {
+        e.setGroupCollapsed(t.groupId, !1);
+      }
+    },
+    collapse_group: {
+      safety: "read",
+      argsType: "{ groupId: string }",
+      argsSchema: {
+        type: "object",
+        properties: {
+          groupId: { type: "string", description: "Group id, from groupIds." }
+        },
+        required: ["groupId"]
+      },
+      idempotent: !0,
+      descriptionKey: "ui.agent.heatmap.actions.collapseGroup",
+      description: "Hide a group's rows, leaving its totals row.",
+      errors: [
+        "Rows are not grouped (groupRows is off).",
+        "The group id does not exist (see groupIds)."
+      ],
+      invoke: (e, t) => {
+        e.setGroupCollapsed(t.groupId, !0);
+      }
+    }
+  },
+  domHooks: {
+    root: {
+      attr: "data-component",
+      value: "heatmap",
+      description: "Marks the Heatmap root."
+    },
+    instanceId: {
+      attr: "data-component-id",
+      sourceProp: "id",
+      description: "Sourced from the id prop on Heatmap."
+    },
+    item: {
+      attr: "data-heatmap-cell-id",
+      description: 'On every data cell: "<rowId>:<columnId>", built from the opaque ids, never from labels. A group header row and its cells carry data-heatmap-group-id, the group id as in groupIds.'
+    }
+  }
+}, Tt = Aa(null);
+function xa() {
+  return Ea(Tt);
+}
+function Ia(e, t) {
+  const a = new Intl.NumberFormat(
+    e,
+    t === "rate" ? { style: "percent", maximumFractionDigits: 0 } : { maximumFractionDigits: 2 }
+  );
+  return (o) => a.format(o);
+}
+function ka(e) {
+  const t = new Intl.NumberFormat(e, { maximumFractionDigits: 0 });
+  return (a) => t.format(a);
+}
+const Ja = "–";
+function Qa({
+  t: e,
+  privacyMode: t,
+  privacyScope: a = "rows",
+  valueType: o,
+  formatValue: s,
+  formatCount: c,
+  groups: l
+}) {
+  const b = new Map(l == null ? void 0 : l.map((p) => [p.id, p.label])), w = Ga(), m = t, x = t && a === "all", k = t && a === "all", g = (p) => p.status === "empty" ? e("heatmap.noData") : p.status === "low-sample" ? e("heatmap.lowSample") : p.label !== void 0 && !t ? p.label : p.value === null ? e("heatmap.noData") : s(p.value), M = (p) => p.count === void 0 ? null : o === "rate" && p.status === "value" && p.value !== null ? e("heatmap.countOf", {
+    part: c(Math.round(p.value * p.count)),
+    total: c(p.count)
+  }) : e("heatmap.records", {
+    count: p.count,
+    formatted: c(p.count)
+  });
+  return {
+    masksRows: m,
+    masksColumns: x,
+    masksGroups: k,
+    rowLabel: (p) => m ? w : p.label,
+    columnLabel: (p) => x ? w : p.label,
+    // A group missing from `groups` has only its id to show, which may be a
+    // name, so privacy mode masks it whatever the scope.
+    groupLabel: (p) => k ? w : b.get(p) ?? (t ? w : p),
+    cellName: (p, E) => e("heatmap.cellName", { row: p, column: E }),
+    groupRowText: (p, E) => e("heatmap.groupRow", {
+      group: p,
+      method: e(E === "sum" ? "heatmap.totals.sum" : "heatmap.totals.mean")
+    }),
+    tableText: (p) => {
+      const E = p.status === "empty" ? null : M(p), D = g(p);
+      return E === null ? D : e("heatmap.valueWithCount", { value: D, count: E });
+    },
+    methodLabel: (p) => e(p === "sum" ? "heatmap.totals.sum" : "heatmap.totals.mean"),
+    valueText: g,
+    visibleText: (p) => p.status === "empty" ? Ja : p.status === "low-sample" ? "" : g(p),
+    countText: M,
+    sentence: (p, E, D) => {
+      const A = M(D), I = g(D);
+      return A === null || D.status === "empty" ? e("heatmap.cell", { row: p, column: E, value: I }) : e("heatmap.cellWithCount", {
+        row: p,
+        column: E,
+        value: I,
+        count: A
+      });
+    },
+    formatValue: s
+  };
+}
+const be = 10, Xt = Math.floor(be / 2), Qe = be - 1, Ye = be / 2, Ze = (e, t, a) => Math.min(a, Math.max(t, e)), aa = /* @__PURE__ */ new Set();
+function Pt(e) {
+  !$a() || aa.has(e) || (aa.add(e), console.warn(`Heatmap: ${e}`));
+}
+function ra(e) {
+  return e[0] <= e[1] ? e : (Pt(
+    `scale domain [${e[0]}, ${e[1]}] is reversed; using [${e[1]}, ${e[0]}].`
+  ), [e[1], e[0]]);
+}
+function Sa(e) {
+  const t = e.filter(Number.isFinite).sort((a, o) => a - o);
+  return t.filter((a, o) => o === 0 || a !== t[o - 1]);
+}
+function Xa(e) {
+  let t = 1 / 0, a = -1 / 0;
+  for (const o of e)
+    Number.isFinite(o) && (o < t && (t = o), o > a && (a = o));
+  return t === 1 / 0 ? null : [t, a];
+}
+function Za(e, t, a) {
+  if (!(a > t)) return Xt;
+  const o = Ze((e - t) / (a - t), 0, 1);
+  return Math.min(Qe, Math.floor(o * be));
+}
+function er(e, t, a, o) {
+  if (e < a) {
+    const l = a - t, b = l > 0 ? Ze((a - e) / l, 0, 1) : 1;
+    return Ye - 1 - Math.min(Ye - 1, Math.floor(b * Ye));
+  }
+  const s = o - a, c = s > 0 ? Ze((e - a) / s, 0, 1) : e > a ? 1 : 0;
+  return Ye + Math.min(Ye - 1, Math.floor(c * Ye));
+}
+function tr(e, t) {
+  if (e.type !== "diverging" || e.midpoint === void 0) return !1;
+  const a = Math.max(
+    Math.abs(e.midpoint),
+    Math.abs(e.min ?? 0),
+    Math.abs(e.max ?? 0)
+  );
+  return Math.abs(t - e.midpoint) <= a * Number.EPSILON * 16;
+}
+function ar(e, t) {
+  const a = e.length;
+  if (a === 0) return NaN;
+  if (a === 1) return e[0];
+  const o = Ze(t, 0, 1) * (a - 1), s = Math.floor(o), c = Math.min(a - 1, s + 1);
+  return e[s] + (e[c] - e[s]) * (o - s);
+}
+function rr(e, t) {
+  const a = Math.max(1, Math.round(t)), o = [];
+  for (let s = 1; s < a; s += 1)
+    o.push(ar(e, s / a));
+  return o;
+}
+function nr(e, t) {
+  if (e.length === 0) return [];
+  const a = e[0], o = (s) => {
+    let c = 0, l = e.length - 1;
+    for (; c < l; ) {
+      const b = c + l >>> 1;
+      e[b] < s ? c = b + 1 : l = b;
+    }
+    return e[c];
+  };
+  return Sa(
+    rr(e, t).map(o)
+  ).filter((s) => s > a);
+}
+function na(e, t) {
+  let a = 0, o = t.length;
+  for (; a < o; ) {
+    const s = a + o >>> 1;
+    t[s] <= e ? a = s + 1 : o = s;
+  }
+  return a;
+}
+function qt(e, t) {
+  return t <= 1 ? Xt : Math.round(
+    Ze(e, 0, t - 1) * Qe / (t - 1)
+  );
+}
+function Wt(e, t) {
+  const a = Xa(t);
+  switch (e.type) {
+    case "diverging": {
+      const o = e.domain && e.domain !== "auto" ? ra(e.domain) : null, s = e.midpoint ?? (o && (o[0] > 0 || o[1] < 0) ? (o[0] + o[1]) / 2 : 0);
+      let c, l;
+      if (o)
+        [c, l] = o;
+      else {
+        const b = a ? Math.max(
+          Math.abs(a[0] - s),
+          Math.abs(a[1] - s)
+        ) : 0;
+        c = s - b, l = s + b;
+      }
+      return {
+        type: "diverging",
+        min: c,
+        max: l,
+        midpoint: s,
+        thresholds: [],
+        stepOf: (b) => er(b, c, s, l)
+      };
+    }
+    case "quantile": {
+      const o = t.filter(Number.isFinite).slice().sort((l, b) => l - b), s = Ze(
+        Math.round(e.buckets ?? be),
+        2,
+        be
+      ), c = nr(o, s);
+      return {
+        type: "quantile",
+        min: (a == null ? void 0 : a[0]) ?? null,
+        max: (a == null ? void 0 : a[1]) ?? null,
+        thresholds: c,
+        stepOf: (l) => qt(na(l, c), c.length + 1)
+      };
+    }
+    case "threshold": {
+      const o = e.thresholds.filter(Number.isFinite), s = Sa(o);
+      s.length !== o.length && Pt("duplicate thresholds merged."), s.length > Qe && Pt(
+        `${s.length} thresholds given; ten steps take at most ${Qe}, so the highest ${s.length - Qe} are dropped.`
+      );
+      const c = s.slice(0, Qe);
+      return {
+        type: "threshold",
+        min: (a == null ? void 0 : a[0]) ?? null,
+        max: (a == null ? void 0 : a[1]) ?? null,
+        thresholds: c,
+        stepOf: (l) => qt(na(l, c), c.length + 1)
+      };
+    }
+    case "sequential":
+    default: {
+      const o = e.domain && e.domain !== "auto" ? ra(e.domain) : null, s = o ? o[0] : (a == null ? void 0 : a[0]) ?? null, c = o ? o[1] : (a == null ? void 0 : a[1]) ?? null;
+      return {
+        type: "sequential",
+        min: s,
+        max: c,
+        thresholds: [],
+        stepOf: (l) => s === null || c === null ? Xt : Za(l, s, c)
+      };
+    }
+  }
+}
+function or(e) {
+  let t = 0, a = !1, o = 0, s = !1;
+  for (const c of e)
+    c.value === null || !Number.isFinite(c.value) || (t += c.value, a = !0, c.count !== void 0 && (o += c.count, s = !0));
+  return { value: a ? t : null, count: s ? o : void 0 };
+}
+function sr(e) {
+  let t = 0, a = 0, o = 0, s = !1;
+  for (const c of e) {
+    if (c.value === null || !Number.isFinite(c.value)) continue;
+    const l = c.count ?? 1;
+    t += c.value * l, a += l, c.count !== void 0 && (o += c.count, s = !0);
+  }
+  return {
+    value: a > 0 ? t / a : null,
+    count: s ? o : void 0
+  };
+}
+function pt(e, t) {
+  return t === "sum" ? or(e) : sr(e);
+}
+function ir(e, t) {
+  const a = new Set(t == null ? void 0 : t.map((l) => l.id)), o = new Set(a), s = /* @__PURE__ */ new Map();
+  let c = 0;
+  for (const l of e) {
+    const b = l.group;
+    if (b === void 0 || s.has(b)) continue;
+    if (a.has(b)) {
+      s.set(b, b);
+      continue;
+    }
+    let w;
+    do
+      c += 1, w = `group-${c}`;
+    while (o.has(w));
+    o.add(w), s.set(b, w);
+  }
+  return s;
+}
+function Zt(e, t) {
+  return t !== void 0 && e !== void 0 && e < t;
+}
+function lr(e, t) {
+  if (e == null)
+    return { value: null, status: "empty" };
+  const a = typeof e == "number" ? { value: e } : e, o = a.value === null || !Number.isFinite(a.value) ? null : a.value, s = o === null ? "empty" : Zt(a.count, t) ? "low-sample" : "value";
+  return { value: o, count: a.count, label: a.label, status: s };
+}
+function dr(e, t, a, o, s) {
+  return e.map(
+    (c, l) => t.map(
+      (b, w) => {
+        var m;
+        return lr(
+          a ? a(c, b, l, w) : (m = o == null ? void 0 : o[l]) == null ? void 0 : m[w],
+          s
+        );
+      }
+    )
+  );
+}
+function cr(e) {
+  const t = [];
+  for (const a of e)
+    for (const o of a)
+      o.status === "value" && o.value !== null && t.push(o.value);
+  return t;
+}
+function ur(e) {
+  return e.some((t) => t.some((a) => a.status !== "empty"));
+}
+function pr(e, t, a, o, s, c) {
+  const l = e.map((k) => pt(k, o)), b = [];
+  for (let k = 0; k < a; k += 1)
+    b.push(
+      pt(
+        e.map((g) => g[k]),
+        s
+      )
+    );
+  const w = /* @__PURE__ */ new Map();
+  t.forEach((k, g) => {
+    if (k.group === void 0) return;
+    const M = w.get(k.group) ?? [];
+    M.push(g), w.set(k.group, M);
+  });
+  const m = /* @__PURE__ */ new Map(), x = /* @__PURE__ */ new Map();
+  for (const [k, g] of w) {
+    const M = [];
+    for (let p = 0; p < a; p += 1)
+      M.push(
+        pt(
+          g.map((E) => e[E][p]),
+          c
+        )
+      );
+    m.set(k, M), x.set(
+      k,
+      pt(
+        g.flatMap((p) => e[p]),
+        o
+      )
+    );
+  }
+  return {
+    rows: l,
+    columns: b,
+    grand: pt(e.flat(), o),
+    groupColumns: m,
+    groups: x
+  };
+}
+const Bt = (e) => `d:${e}`, mr = (e) => `g:${e}`, Mt = "f";
+function hr(e, t, a, o, s) {
+  const c = [...e];
+  if (o === "label")
+    return c.sort((l, b) => s.compare(t[l].label, t[b].label));
+  if (o === "total-asc" || o === "total-desc") {
+    const l = o === "total-asc" ? 1 : -1;
+    return c.sort((b, w) => {
+      var k, g;
+      const m = (k = a[b]) == null ? void 0 : k.value, x = (g = a[w]) == null ? void 0 : g.value;
+      return m == null ? x == null ? 0 : 1 : x == null ? -1 : (m - x) * l;
+    });
+  }
+  return c;
+}
+function oa(e, t, a, o) {
+  var w;
+  if (!a)
+    return t.map((m) => ({
+      kind: "data",
+      key: Bt(e[m].id),
+      rowIndex: m,
+      groupId: e[m].group
+    }));
+  const s = [], c = /* @__PURE__ */ new Map(), l = [];
+  e.forEach((m) => {
+    m.group !== void 0 && !c.has(m.group) && (c.set(m.group, []), s.push(m.group));
+  });
+  for (const m of t) {
+    const x = e[m].group;
+    x === void 0 ? l.push(m) : (w = c.get(x)) == null || w.push(m);
+  }
+  const b = [];
+  for (const m of s) {
+    const x = c.get(m) ?? [], k = o.has(m);
+    if (b.push({
+      kind: "group",
+      key: mr(m),
+      groupId: m,
+      collapsed: k,
+      rowIndexes: x
+    }), !k)
+      for (const g of x)
+        b.push({
+          kind: "data",
+          key: Bt(e[g].id),
+          rowIndex: g,
+          groupId: m
+        });
+  }
+  for (const m of l)
+    b.push({ kind: "data", key: Bt(e[m].id), rowIndex: m });
+  return b;
+}
+function Na({
+  cell: e,
+  label: t,
+  open: a,
+  onOpenChange: o,
+  side: s = "top",
+  children: c
+}) {
+  const l = xa(), b = t ?? (l == null ? void 0 : l.tooltipText(e)) ?? "";
+  return /* @__PURE__ */ v(
+    ba,
+    {
+      label: b,
+      open: a,
+      onOpenChange: o,
+      side: s,
+      delayDuration: 0,
+      children: c
+    }
+  );
+}
+Na.displayName = "HeatmapTooltip";
+function sa({
+  label: e,
+  onOpenChange: t
+}) {
+  return /* @__PURE__ */ v(ba, { label: e, open: !0, onOpenChange: t, delayDuration: 0, children: /* @__PURE__ */ v(
+    "span",
+    {
+      "aria-hidden": "true",
+      "data-component": "heatmap-tooltip",
+      className: "ds:pointer-events-none ds:absolute ds:inset-0"
+    }
+  ) });
+}
+const gr = 1e3, fr = 3;
+function ia({ offset: e, viewport: t, lead: a, pitch: o, count: s }, c = fr) {
+  if (s <= 0) return [0, 0];
+  if (!(o > 0)) return [0, s];
+  const l = Math.abs(e) - a, b = Math.floor(l / o) - c, w = Math.ceil((l + t) / o) + c, m = Math.max(0, Math.min(s - 1, b)), x = Math.max(m + 1, Math.min(s, w));
+  return [m, x];
+}
+function la(e, t, a) {
+  const [o, s] = e, c = [];
+  for (let l = o; l < s; l += 1) c.push(l);
+  return a === null || a < 0 || a >= t ? {
+    indexes: c,
+    lead: o,
+    middle: 0,
+    middleAfter: 0,
+    tail: Math.max(0, t - s)
+  } : a < o ? {
+    indexes: [a, ...c],
+    lead: a,
+    middle: o - a - 1,
+    middleAfter: 1,
+    tail: Math.max(0, t - s)
+  } : a >= s ? {
+    indexes: [...c, a],
+    lead: o,
+    middle: a - s,
+    middleAfter: c.length,
+    tail: t - a - 1
+  } : {
+    indexes: c,
+    lead: o,
+    middle: 0,
+    middleAfter: 0,
+    tail: Math.max(0, t - s)
+  };
+}
+function Rt(e) {
+  return {
+    indexes: Array.from({ length: e }, (t, a) => a),
+    lead: 0,
+    middle: 0,
+    middleAfter: 0,
+    tail: 0
+  };
+}
+function da(e, t) {
+  if (e.indexes.every((o) => o < t)) return e;
+  const a = e.indexes.filter((o) => o < t);
+  return {
+    indexes: a,
+    lead: Math.min(e.lead, t),
+    middle: 0,
+    middleAfter: 0,
+    tail: Math.max(0, t - (a.length + Math.min(e.lead, t)))
+  };
+}
+function ca(e, t) {
+  return e.lead !== t.lead || e.tail !== t.tail || e.middle !== t.middle || e.indexes.length !== t.indexes.length ? !1 : e.indexes.every((a, o) => a === t.indexes[o]);
+}
+const Ut = (e, t) => `${e}-${Math.min(9, Math.max(0, Math.round(t)))}`, _a = {
+  "primary-0": "ds:bg-[var(--heatmap-primary-0)] ds:text-[color:var(--heatmap-primary-0-foreground)]",
+  "primary-1": "ds:bg-[var(--heatmap-primary-1)] ds:text-[color:var(--heatmap-primary-1-foreground)]",
+  "primary-2": "ds:bg-[var(--heatmap-primary-2)] ds:text-[color:var(--heatmap-primary-2-foreground)]",
+  "primary-3": "ds:bg-[var(--heatmap-primary-3)] ds:text-[color:var(--heatmap-primary-3-foreground)]",
+  "primary-4": "ds:bg-[var(--heatmap-primary-4)] ds:text-[color:var(--heatmap-primary-4-foreground)]",
+  "primary-5": "ds:bg-[var(--heatmap-primary-5)] ds:text-[color:var(--heatmap-primary-5-foreground)]",
+  "primary-6": "ds:bg-[var(--heatmap-primary-6)] ds:text-[color:var(--heatmap-primary-6-foreground)]",
+  "primary-7": "ds:bg-[var(--heatmap-primary-7)] ds:text-[color:var(--heatmap-primary-7-foreground)]",
+  "primary-8": "ds:bg-[var(--heatmap-primary-8)] ds:text-[color:var(--heatmap-primary-8-foreground)]",
+  "primary-9": "ds:bg-[var(--heatmap-primary-9)] ds:text-[color:var(--heatmap-primary-9-foreground)]",
+  "success-0": "ds:bg-[var(--heatmap-success-0)] ds:text-[color:var(--heatmap-success-0-foreground)]",
+  "success-1": "ds:bg-[var(--heatmap-success-1)] ds:text-[color:var(--heatmap-success-1-foreground)]",
+  "success-2": "ds:bg-[var(--heatmap-success-2)] ds:text-[color:var(--heatmap-success-2-foreground)]",
+  "success-3": "ds:bg-[var(--heatmap-success-3)] ds:text-[color:var(--heatmap-success-3-foreground)]",
+  "success-4": "ds:bg-[var(--heatmap-success-4)] ds:text-[color:var(--heatmap-success-4-foreground)]",
+  "success-5": "ds:bg-[var(--heatmap-success-5)] ds:text-[color:var(--heatmap-success-5-foreground)]",
+  "success-6": "ds:bg-[var(--heatmap-success-6)] ds:text-[color:var(--heatmap-success-6-foreground)]",
+  "success-7": "ds:bg-[var(--heatmap-success-7)] ds:text-[color:var(--heatmap-success-7-foreground)]",
+  "success-8": "ds:bg-[var(--heatmap-success-8)] ds:text-[color:var(--heatmap-success-8-foreground)]",
+  "success-9": "ds:bg-[var(--heatmap-success-9)] ds:text-[color:var(--heatmap-success-9-foreground)]",
+  "destructive-0": "ds:bg-[var(--heatmap-destructive-0)] ds:text-[color:var(--heatmap-destructive-0-foreground)]",
+  "destructive-1": "ds:bg-[var(--heatmap-destructive-1)] ds:text-[color:var(--heatmap-destructive-1-foreground)]",
+  "destructive-2": "ds:bg-[var(--heatmap-destructive-2)] ds:text-[color:var(--heatmap-destructive-2-foreground)]",
+  "destructive-3": "ds:bg-[var(--heatmap-destructive-3)] ds:text-[color:var(--heatmap-destructive-3-foreground)]",
+  "destructive-4": "ds:bg-[var(--heatmap-destructive-4)] ds:text-[color:var(--heatmap-destructive-4-foreground)]",
+  "destructive-5": "ds:bg-[var(--heatmap-destructive-5)] ds:text-[color:var(--heatmap-destructive-5-foreground)]",
+  "destructive-6": "ds:bg-[var(--heatmap-destructive-6)] ds:text-[color:var(--heatmap-destructive-6-foreground)]",
+  "destructive-7": "ds:bg-[var(--heatmap-destructive-7)] ds:text-[color:var(--heatmap-destructive-7-foreground)]",
+  "destructive-8": "ds:bg-[var(--heatmap-destructive-8)] ds:text-[color:var(--heatmap-destructive-8-foreground)]",
+  "destructive-9": "ds:bg-[var(--heatmap-destructive-9)] ds:text-[color:var(--heatmap-destructive-9-foreground)]",
+  "diverging-0": "ds:bg-[var(--heatmap-diverging-0)] ds:text-[color:var(--heatmap-diverging-0-foreground)]",
+  "diverging-1": "ds:bg-[var(--heatmap-diverging-1)] ds:text-[color:var(--heatmap-diverging-1-foreground)]",
+  "diverging-2": "ds:bg-[var(--heatmap-diverging-2)] ds:text-[color:var(--heatmap-diverging-2-foreground)]",
+  "diverging-3": "ds:bg-[var(--heatmap-diverging-3)] ds:text-[color:var(--heatmap-diverging-3-foreground)]",
+  "diverging-4": "ds:bg-[var(--heatmap-diverging-4)] ds:text-[color:var(--heatmap-diverging-4-foreground)]",
+  "diverging-5": "ds:bg-[var(--heatmap-diverging-5)] ds:text-[color:var(--heatmap-diverging-5-foreground)]",
+  "diverging-6": "ds:bg-[var(--heatmap-diverging-6)] ds:text-[color:var(--heatmap-diverging-6-foreground)]",
+  "diverging-7": "ds:bg-[var(--heatmap-diverging-7)] ds:text-[color:var(--heatmap-diverging-7-foreground)]",
+  "diverging-8": "ds:bg-[var(--heatmap-diverging-8)] ds:text-[color:var(--heatmap-diverging-8-foreground)]",
+  "diverging-9": "ds:bg-[var(--heatmap-diverging-9)] ds:text-[color:var(--heatmap-diverging-9-foreground)]",
+  // A value exactly on a diverging scale's midpoint: neutral, so a cell
+  // with no change never looks like one with a small change.
+  midpoint: "ds:bg-[var(--heatmap-midpoint)] ds:text-[color:var(--heatmap-midpoint-foreground)]",
+  empty: "ds:border ds:border-dashed ds:border-[color:var(--heatmap-empty-border)] ds:bg-[var(--heatmap-empty)] ds:text-[color:var(--heatmap-empty-foreground)]",
+  "low-sample": "ds:border ds:border-[color:var(--heatmap-empty-border)] ds:bg-[var(--heatmap-low-sample-surface)] ds:bg-[image:var(--heatmap-low-sample)] ds:text-[color:var(--heatmap-empty-foreground)]",
+  aggregate: "ds:bg-[var(--muted)] ds:text-[color:var(--foreground)] ds:font-semibold"
+}, ua = oe(
+  "ds:flex ds:min-w-0 ds:max-w-full ds:flex-col ds:gap-[var(--spacing-sm)] ds:text-[color:var(--foreground)]"
+), vr = oe(
+  "ds:flex ds:flex-wrap ds:items-center ds:justify-between ds:gap-[var(--spacing-sm)]"
+), wr = oe(
+  [
+    "ds:relative ds:max-w-full ds:overflow-auto ds:overscroll-contain",
+    "ds:max-h-[var(--heatmap-max-block-size)]",
+    "ds:bg-[var(--background)]",
+    // Keep a cell scrolled into view clear of the sticky header, footer and
+    // row-header column. The sizes are measured and set on this element.
+    "ds:scroll-pt-[var(--heatmap-sticky-block-start)] ds:scroll-pb-[var(--heatmap-sticky-block-end)] ds:scroll-ps-[var(--heatmap-sticky-inline-start)]"
+  ].join(" ")
+), br = oe(
+  // Focusable only to hold focus during a retry; not a control, so no ring.
+  "ds:min-w-0 ds:max-w-full ds:outline-none",
+  {
+    variants: {
+      capped: {
+        true: "ds:flex ds:h-[var(--heatmap-max-block-size)] ds:flex-col",
+        false: "ds:block ds:max-h-[var(--heatmap-max-block-size)]"
+      }
+    },
+    defaultVariants: { capped: !1 }
+  }
+), yr = oe(
+  [
+    "ds:grid ds:w-max ds:min-w-full",
+    "ds:[grid-template-rows:auto] ds:auto-rows-[var(--heatmap-row-track)]",
+    "ds:gap-[var(--heatmap-gap)]",
+    "ds:outline-none"
+  ].join(" "),
+  {
+    variants: {
+      size: {
+        sm: "ds:[--heatmap-cell-inline:var(--min-target-size)] ds:[--heatmap-cell-block:var(--min-target-size)]",
+        md: "ds:[--heatmap-cell-inline:max(var(--min-target-size),var(--spacing-2xl))] ds:[--heatmap-cell-block:var(--min-target-size)]",
+        lg: "ds:[--heatmap-cell-inline:max(var(--min-target-size),calc(var(--spacing-2xl)_+_var(--spacing-md)))] ds:[--heatmap-cell-block:max(var(--min-target-size),var(--spacing-2xl))]"
+      },
+      density: {
+        default: "ds:[--heatmap-gap:var(--spacing-2xs)]",
+        compact: "ds:[--heatmap-gap:var(--spacing-none)]"
+      },
+      virtualised: {
+        true: "ds:[--heatmap-track:var(--heatmap-cell-inline)] ds:[--heatmap-row-track:var(--heatmap-cell-block)]",
+        false: "ds:[--heatmap-track:minmax(var(--heatmap-cell-inline),1fr)] ds:[--heatmap-row-track:minmax(var(--heatmap-cell-block),auto)]"
+      },
+      totalsColumn: {
+        true: "ds:grid-cols-[max-content_repeat(var(--heatmap-columns),var(--heatmap-track))_max-content]",
+        false: "ds:grid-cols-[max-content_repeat(var(--heatmap-columns),var(--heatmap-track))]"
+      }
+    },
+    defaultVariants: {
+      size: "md",
+      density: "default",
+      virtualised: !1,
+      totalsColumn: !1
+    }
+  }
+), At = oe(
+  "ds:col-span-full ds:grid ds:grid-cols-subgrid",
+  {
+    variants: {
+      position: {
+        // The header and footer rows stick to the scroll box's block edges,
+        // above the row headers that stick to its inline start.
+        // Each also covers the row gap on its inner side, so cells
+        // scrolling underneath never show through the gap.
+        header: "ds:sticky ds:top-0 ds:z-[calc(var(--z-sticky)+1)] ds:bg-[var(--background)] ds:after:pointer-events-none ds:after:absolute ds:after:inset-x-0 ds:after:top-[calc(100%_-_var(--spacing-2xs))] ds:after:h-[calc(var(--heatmap-gap)_+_var(--spacing-2xs))] ds:after:bg-[var(--background)] ds:after:content-['']",
+        footer: "ds:sticky ds:bottom-0 ds:z-[calc(var(--z-sticky)+1)] ds:bg-[var(--background)] ds:after:pointer-events-none ds:after:absolute ds:after:inset-x-0 ds:after:bottom-[calc(100%_-_var(--spacing-2xs))] ds:after:h-[calc(var(--heatmap-gap)_+_var(--spacing-2xs))] ds:after:bg-[var(--background)] ds:after:content-['']",
+        body: ""
+      }
+    },
+    defaultVariants: { position: "body" }
+  }
+), Xe = oe("ds:pointer-events-none", {
+  variants: {
+    axis: {
+      "row-lead": "ds:col-span-full ds:row-span-[var(--heatmap-row-lead)]",
+      "row-middle": "ds:col-span-full ds:row-span-[var(--heatmap-row-middle)]",
+      "row-tail": "ds:col-span-full ds:row-span-[var(--heatmap-row-tail)]",
+      "col-lead": "ds:col-span-[var(--heatmap-col-lead)]",
+      "col-middle": "ds:col-span-[var(--heatmap-col-middle)]",
+      // Holds the skipped columns after the window, so the row-totals cell
+      // lands in its own track at the end and never next to the window.
+      "col-tail": "ds:col-span-[var(--heatmap-col-tail)]"
+    }
+  }
+}), Ma = "ds:transition-colors ds:duration-[var(--animation-duration)] ds:motion-reduce:transition-none ds:data-[highlighted=true]:bg-[var(--muted)] ds:data-[highlighted=true]:text-[color:var(--foreground)]", Ft = oe(
+  [
+    "ds:flex ds:min-w-0 ds:items-end ds:justify-center ds:text-center",
+    "ds:rounded-[var(--radius-sm)] ds:px-[var(--spacing-2xs)] ds:py-[var(--spacing-xs)]",
+    "type-meta ds:text-[color:var(--muted-foreground)] ds:break-normal ds:[overflow-wrap:anywhere]",
+    Ma
+  ].join(" "),
+  {
+    variants: {
+      corner: {
+        // The top-start corner sticks with the row headers below it.
+        true: "ds:sticky ds:start-0 ds:z-[var(--z-sticky)] ds:items-end ds:justify-start ds:text-start ds:bg-[var(--background)] ds:pe-[var(--spacing-sm)]",
+        false: ""
+      }
+    },
+    defaultVariants: { corner: !1 }
+  }
+), Yt = oe(
+  [
+    "ds:sticky ds:start-0 ds:z-[var(--z-sticky)] ds:flex ds:min-w-0 ds:items-center",
+    "ds:max-w-[calc(var(--spacing-2xl)*4)] ds:gap-[var(--spacing-xs)]",
+    "ds:bg-[var(--background)] ds:ps-[var(--spacing-xs)] ds:pe-[var(--spacing-sm)]",
+    // Cover the gaps at the inline end and below too, so cells scrolling
+    // underneath never show through between row headers.
+    "ds:after:pointer-events-none ds:after:absolute ds:after:top-0 ds:after:bottom-[calc(var(--heatmap-gap)*-1)] ds:after:start-full ds:after:w-[var(--heatmap-gap)] ds:after:bg-[var(--background)] ds:after:content-['']",
+    // The strip below overlaps its neighbours slightly so a fractional row
+    // position never leaves a hairline seam.
+    "ds:before:pointer-events-none ds:before:absolute ds:before:inset-x-0 ds:before:top-[calc(100%_-_var(--spacing-2xs))] ds:before:h-[calc(var(--heatmap-gap)_+_var(--spacing-2xs)*2)] ds:before:bg-[var(--background)] ds:before:content-['']",
+    "type-body-sm ds:text-start ds:break-normal ds:[overflow-wrap:anywhere]",
+    Ma
+  ].join(" "),
+  {
+    variants: {
+      kind: {
+        data: "",
+        group: "ds:font-semibold",
+        total: "ds:font-semibold"
+      },
+      // A virtualised grid needs every row the same height: no wrapping.
+      // The label truncates inside its own span (heatmapRowLabelVariants):
+      // overflow on the header itself would clip its gap-covering strips.
+      virtualised: {
+        true: "ds:whitespace-nowrap",
+        false: ""
+      }
+    },
+    defaultVariants: { kind: "data", virtualised: !1 }
+  }
+), pa = oe("ds:min-w-0", {
+  variants: {
+    virtualised: {
+      true: "ds:overflow-hidden ds:text-ellipsis",
+      false: ""
+    }
+  },
+  defaultVariants: { virtualised: !1 }
+}), Lt = oe(
+  [
+    "ds:relative ds:flex ds:min-w-0 ds:items-center ds:justify-center",
+    "ds:min-h-[var(--heatmap-cell-block)] ds:overflow-hidden ds:px-[var(--spacing-2xs)]",
+    "type-meta ds:tabular-nums ds:whitespace-nowrap ds:select-none",
+    "ds:forced-colors:[forced-color-adjust:none]",
+    "ds:focus-visible:outline-solid ds:focus-visible:outline-[length:var(--focus-ring-width)] ds:focus-visible:outline-ring",
+    "ds:focus-visible:outline-offset-[calc(var(--focus-ring-width)*-1)]",
+    "ds:focus-visible:shadow-[inset_0_0_0_calc(var(--focus-ring-width)*2)_var(--background)]",
+    "ds:forced-colors:focus-visible:outline-[Highlight]",
+    "ds:aria-selected:shadow-[inset_0_0_0_var(--spacing-2xs)_var(--background),inset_0_0_0_calc(var(--spacing-2xs)*2)_var(--foreground),inset_0_0_0_calc(var(--spacing-2xs)*3)_var(--background)]",
+    "ds:aria-selected:focus-visible:shadow-[inset_0_0_0_calc(var(--focus-ring-width)_+_var(--spacing-2xs))_var(--background),inset_0_0_0_calc(var(--focus-ring-width)_+_var(--spacing-2xs)*2)_var(--foreground),inset_0_0_0_calc(var(--focus-ring-width)_+_var(--spacing-2xs)*3)_var(--background)]"
+  ].join(" "),
+  {
+    variants: {
+      tone: _a,
+      interactive: {
+        true: "ds:cursor-pointer",
+        false: "ds:cursor-default"
+      }
+    },
+    defaultVariants: { tone: "empty", interactive: !1 }
+  }
+), xr = oe(
+  "ds:flex ds:min-w-0 ds:flex-wrap ds:items-center ds:gap-x-[var(--spacing-md)] ds:gap-y-[var(--spacing-xs)] type-meta ds:text-[color:var(--muted-foreground)]"
+), Ir = oe(
+  "ds:flex ds:w-[calc(var(--spacing-xl)*6)] ds:min-w-0 ds:max-w-full ds:shrink ds:items-stretch",
+  {
+    variants: {
+      variant: {
+        stepped: "ds:gap-[var(--spacing-2xs)]",
+        continuous: "ds:overflow-hidden ds:rounded-[var(--radius-sm)]"
+      }
+    },
+    defaultVariants: { variant: "stepped" }
+  }
+), mt = oe(
+  "ds:inline-block ds:forced-colors:[forced-color-adjust:none]",
+  {
+    variants: {
+      tone: _a,
+      shape: {
+        stepped: "ds:h-[var(--spacing-sm)] ds:min-w-0 ds:flex-1 ds:rounded-[var(--radius-sm)]",
+        continuous: "ds:h-[var(--spacing-sm)] ds:min-w-0 ds:flex-1",
+        key: "ds:size-[var(--spacing-md)] ds:shrink-0 ds:rounded-[var(--radius-sm)]",
+        label: "ds:shrink-0 ds:rounded-[var(--radius-sm)] ds:px-[var(--spacing-xs)] ds:whitespace-nowrap"
+      }
+    },
+    defaultVariants: { tone: "empty", shape: "key" }
+  }
+), Ra = "", Kt = (e, t) => `${e}${Ra}${String(t)}`, Et = (e) => {
+  const t = e.indexOf(Ra);
+  return [e.slice(0, t), e.slice(t + 1)];
+};
+function kr(e, t, a) {
+  return e.status === "empty" || e.value === null ? "empty" : e.status === "low-sample" ? "low-sample" : tr(t, e.value) ? "midpoint" : Ut(a, t.stepOf(e.value));
+}
+function Jt(e, t) {
+  return {
+    value: e.value,
+    count: e.count,
+    status: e.value === null ? "empty" : Zt(e.count, t) ? "low-sample" : "value"
+  };
+}
+const Qt = (e) => e.status === "value" ? "aggregate" : e.status;
+function Ct(e, t) {
+  const a = [];
+  return e.lead > 0 && a.push(
+    /* @__PURE__ */ v(
+      "div",
+      {
+        "aria-hidden": "true",
+        className: Xe({ axis: "col-lead" })
+      },
+      "lead"
+    )
+  ), e.indexes.forEach((o, s) => {
+    e.middle > 0 && s === e.middleAfter && a.push(
+      /* @__PURE__ */ v(
+        "div",
+        {
+          "aria-hidden": "true",
+          className: Xe({ axis: "col-middle" })
+        },
+        "middle"
+      )
+    ), a.push(t(o));
+  }), e.tail > 0 && a.push(
+    /* @__PURE__ */ v(
+      "div",
+      {
+        "aria-hidden": "true",
+        className: Xe({ axis: "col-tail" })
+      },
+      "tail"
+    )
+  ), a;
+}
+const Sr = Ca(function({
+  ctx: t,
+  row: a,
+  ariaRowIndex: o,
+  highlighted: s,
+  activeCol: c,
+  tooltipCol: l,
+  selectedCols: b
+}) {
+  var D, A;
+  const w = t.columns.length, m = _(
+    () => new Set(b === "" ? [] : b.split(",").map(Number)),
+    [b]
+  );
+  if (a.kind === "group") {
+    const I = t.describer.groupLabel(a.groupId), q = t.groupIds.get(a.groupId), H = `${t.idBase}-label-${o}`, L = ((D = t.totals) == null ? void 0 : D.groupColumns.get(a.groupId)) ?? [], ve = (A = t.totals) == null ? void 0 : A.groups.get(a.groupId), j = (V, U, we, ee) => {
+      const y = Jt(V ?? { value: null }, t.minCount), S = we(y);
+      return /* @__PURE__ */ P(
+        "div",
+        {
+          role: "gridcell",
+          "aria-colindex": U + 2,
+          "aria-expanded": !a.collapsed,
+          "aria-label": S,
+          tabIndex: c === U ? 0 : -1,
+          "data-heatmap-group-id": q,
+          className: Lt({
+            tone: Qt(y),
+            interactive: !0
+          }),
+          children: [
+            t.describer.visibleText(y),
+            ee && l === U ? /* @__PURE__ */ v(
+              sa,
+              {
+                label: S,
+                onOpenChange: t.onTooltipOpenChange
+              }
+            ) : null
+          ]
+        },
+        U
+      );
+    }, J = t.describer.groupRowText(
+      I,
+      t.groupColumnMethod
+    );
+    return /* @__PURE__ */ P(
+      "div",
+      {
+        role: "row",
+        "aria-rowindex": o,
+        "data-heatmap-body-row": "",
+        "data-heatmap-group-id": q,
+        className: At({ position: "body" }),
+        children: [
+          /* @__PURE__ */ P(
+            "div",
+            {
+              role: "rowheader",
+              "aria-colindex": 1,
+              "aria-labelledby": H,
+              "data-highlighted": s,
+              className: Yt({
+                kind: "group",
+                virtualised: t.virtualised
+              }),
+              children: [
+                /* @__PURE__ */ v(
+                  "button",
+                  {
+                    type: "button",
+                    tabIndex: -1,
+                    "aria-expanded": !a.collapsed,
+                    "aria-label": a.collapsed ? t.expandLabel(I) : t.collapseLabel(I),
+                    onMouseDown: (V) => V.preventDefault(),
+                    onClick: () => t.onToggleGroup(a.groupId),
+                    className: "ds:inline-flex ds:size-[var(--spacing-lg)] ds:shrink-0 ds:cursor-pointer ds:items-center ds:justify-center ds:rounded-[var(--radius-sm)] ds:bg-transparent ds:text-[color:inherit] ds:hover:bg-[var(--muted)] ds:focus-visible:outline-solid ds:focus-visible:outline-[length:var(--focus-ring-width)] ds:focus-visible:outline-ring ds:forced-colors:focus-visible:outline-[Highlight]",
+                    children: /* @__PURE__ */ v(
+                      Da,
+                      {
+                        "aria-hidden": "true",
+                        className: [
+                          "ds:size-4 ds:transition-transform ds:duration-[var(--animation-duration)] ds:motion-reduce:transition-none",
+                          a.collapsed ? "ds:-rotate-90 ds:rtl:rotate-90" : ""
+                        ].join(" ")
+                      }
+                    )
+                  }
+                ),
+                /* @__PURE__ */ v(
+                  "span",
+                  {
+                    id: H,
+                    className: pa({
+                      virtualised: t.virtualised
+                    }),
+                    children: I
+                  }
+                )
+              ]
+            }
+          ),
+          Ct(
+            t.colWindow,
+            (V) => j(
+              L[V],
+              V,
+              (U) => t.describer.sentence(
+                J,
+                t.describer.columnLabel(t.columns[V]),
+                U
+              ),
+              !0
+            )
+          ),
+          t.rowTotals ? j(
+            ve,
+            w,
+            (V) => t.describer.sentence(
+              I,
+              t.describer.methodLabel(t.rowTotals || "mean"),
+              V
+            ),
+            !1
+          ) : null
+        ]
+      }
+    );
+  }
+  const x = a.rowIndex, k = t.rows[x], g = t.describer.rowLabel(k), M = t.matrix[x], p = (I) => {
+    const q = M[I], H = t.columns[I], L = m.has(I);
+    return /* @__PURE__ */ P(
+      "div",
+      {
+        role: "gridcell",
+        "aria-colindex": I + 2,
+        "aria-label": t.describer.sentence(
+          g,
+          t.describer.columnLabel(H),
+          q
+        ),
+        "aria-describedby": c === I ? t.describedBy : void 0,
+        "aria-selected": t.selectable ? L : void 0,
+        tabIndex: c === I ? 0 : -1,
+        "data-heatmap-cell-id": `${k.id}:${String(H.id)}`,
+        "data-status": q.status,
+        className: Lt({
+          tone: kr(q, t.scale, t.palette),
+          interactive: t.interactive
+        }),
+        children: [
+          t.showValues || q.status === "empty" ? t.describer.visibleText(q) : null,
+          l === I ? /* @__PURE__ */ v(
+            sa,
+            {
+              label: t.tooltipText(t.cellInfo(x, I)),
+              onOpenChange: t.onTooltipOpenChange
+            }
+          ) : null
+        ]
+      },
+      I
+    );
+  };
+  let E = null;
+  if (t.rowTotals && t.totals) {
+    const I = Jt(t.totals.rows[x], t.minCount);
+    E = /* @__PURE__ */ v(
+      "div",
+      {
+        role: "gridcell",
+        "aria-colindex": w + 2,
+        "aria-label": t.describer.sentence(
+          g,
+          t.describer.methodLabel(t.rowTotals),
+          I
+        ),
+        tabIndex: c === w ? 0 : -1,
+        className: Lt({ tone: Qt(I) }),
+        children: t.describer.visibleText(I)
+      }
+    );
+  }
+  return /* @__PURE__ */ P(
+    "div",
+    {
+      role: "row",
+      "aria-rowindex": o,
+      "data-heatmap-body-row": "",
+      "data-heatmap-row-id": k.id,
+      className: At({ position: "body" }),
+      children: [
+        /* @__PURE__ */ v(
+          "div",
+          {
+            role: "rowheader",
+            "aria-colindex": 1,
+            "data-highlighted": s,
+            className: Yt({
+              kind: "data",
+              virtualised: t.virtualised
+            }),
+            children: /* @__PURE__ */ v(
+              "span",
+              {
+                className: pa({ virtualised: t.virtualised }),
+                children: g
+              }
+            )
+          }
+        ),
+        Ct(t.colWindow, p),
+        E
+      ]
+    }
+  );
+}), Gt = {
+  headerBlock: 48,
+  footerBlock: 0,
+  rowPitch: 46,
+  leadInline: 120,
+  colPitch: 46,
+  viewportBlock: 600,
+  viewportInline: 900
+}, ma = (e) => Math.max(
+  1,
+  Math.floor(
+    (e.viewportBlock - e.headerBlock - e.footerBlock) / Math.max(1, e.rowPitch)
+  )
+);
+function Nr(e) {
+  const {
+    title: t,
+    rowsLabel: a,
+    rows: o,
+    columns: s,
+    matrix: c,
+    body: l,
+    scale: b,
+    palette: w,
+    describer: m,
+    showValues: x,
+    totals: k,
+    rowTotals: g,
+    columnTotals: M,
+    groupColumnMethod: p,
+    groupIds: E,
+    minCount: D,
+    selectionMode: A,
+    selected: I,
+    columnIndexOfKey: q,
+    interactive: H,
+    virtualised: L,
+    size: ve,
+    density: j,
+    cellInfo: J,
+    tooltipText: V,
+    describeFocused: U,
+    onActivate: we,
+    onRange: ee,
+    onToggleGroup: y
+  } = e, { t: S } = Ht("ui"), ae = Ka(), Q = $(null), Y = $(null), _e = $(null), Oe = $(null), K = s.length, Me = K + (g ? 1 : 0), O = !!(M && k), de = _(
+    () => [
+      ...l.map((n) => n.key),
+      ...O ? [Mt] : []
+    ],
+    [l, O]
+  ), ye = _(() => {
+    const n = /* @__PURE__ */ new Map();
+    return de.forEach((r, d) => n.set(r, d)), n;
+  }, [de]), [F, et] = le(() => ({
+    rowKey: de[0] ?? Mt,
+    col: 0
+  })), te = (() => {
+    const n = ye.get(F.rowKey);
+    if (n !== void 0) return n;
+    const r = o.find((u) => `d:${u.id}` === F.rowKey);
+    return ((r == null ? void 0 : r.group) === void 0 ? void 0 : ye.get(`g:${r.group}`)) ?? 0;
+  })(), z = Math.min(
+    Math.max(0, F.col),
+    Math.max(0, Me - 1)
+  ), ce = de[te], xe = $(!1), [Ie, G] = le(!1), me = $(!1), ke = $("pointer"), [tt, ze] = le(null), Le = $(null), [ft, Se] = le(!1), Ve = C((n) => {
+    const r = Le.current;
+    r === n || r && n && r.rowKey === n.rowKey && r.col === n.col || (Le.current = n, ze(n), Se(!1));
+  }, []), X = tt ?? (Ie && ce ? { rowKey: ce, col: z } : null), Ee = ft ? null : tt ?? (Ie && ke.current === "keyboard" && ce ? { rowKey: ce, col: z } : null), [re, Ot] = le(Gt), Re = $(re);
+  Re.current = re;
+  const at = C(() => {
+    var Z, _t;
+    const n = Q.current, r = Y.current;
+    if (!n || !r) return;
+    const d = window.getComputedStyle(r), u = parseFloat(d.rowGap) || 0, h = parseFloat(d.columnGap) || 0, N = d.gridTemplateColumns.split(" ").map((Ue) => parseFloat(Ue)).filter((Ue) => Number.isFinite(Ue)), W = ((Z = _e.current) == null ? void 0 : Z.getBoundingClientRect().height) ?? 0, se = r.querySelector(
+      "[data-heatmap-body-row]"
+    ), ne = (se == null ? void 0 : se.getBoundingClientRect().height) ?? 0, ie = {
+      headerBlock: W + u,
+      footerBlock: ((_t = Oe.current) == null ? void 0 : _t.getBoundingClientRect().height) ?? 0,
+      rowPitch: (ne || W || Gt.rowPitch) + u,
+      leadInline: (N[0] ?? 0) + h,
+      colPitch: (N[1] ?? Gt.colPitch) + h,
+      viewportBlock: n.clientHeight,
+      viewportInline: n.clientWidth
+    }, He = Re.current;
+    Object.keys(ie).some(
+      (Ue) => Math.abs(ie[Ue] - He[Ue]) > 0.5
+    ) && Ot(ie);
+  }, []);
+  Je(() => {
+    at();
+    const n = Q.current;
+    if (!n || typeof ResizeObserver > "u") return;
+    const r = new ResizeObserver(() => at());
+    return r.observe(n), Y.current && r.observe(Y.current), () => r.disconnect();
+  }, [at, l.length, K, ve, j]);
+  const vt = ce === Mt ? null : te, Be = z < K ? z : null, rt = C(() => {
+    if (!L)
+      return { rows: Rt(l.length), cols: Rt(K) };
+    const n = Q.current, r = Re.current, d = ia({
+      offset: (n == null ? void 0 : n.scrollTop) ?? 0,
+      viewport: r.viewportBlock,
+      lead: r.headerBlock,
+      pitch: r.rowPitch,
+      count: l.length
+    }), u = ia({
+      offset: (n == null ? void 0 : n.scrollLeft) ?? 0,
+      viewport: r.viewportInline,
+      lead: r.leadInline,
+      pitch: r.colPitch,
+      count: K
+    });
+    return {
+      rows: la(d, l.length, vt),
+      cols: la(u, K, Be)
+    };
+  }, [L, l.length, K, vt, Be]), [he, zt] = le(rt), Fe = _(() => Rt(l.length), [l.length]), wt = _(() => Rt(K), [K]), ge = _(
+    () => L ? {
+      rows: da(he.rows, l.length),
+      cols: da(he.cols, K)
+    } : { rows: Fe, cols: wt },
+    [L, he, l.length, K, Fe, wt]
+  ), Ae = C(() => {
+    const n = rt();
+    zt(
+      (r) => ca(r.rows, n.rows) && ca(r.cols, n.cols) ? r : n
+    );
+  }, [rt]);
+  Je(() => {
+    Ae();
+  }, [Ae, re]);
+  const Ne = $(0), nt = C(() => {
+    !L || Ne.current || (Ne.current = window.requestAnimationFrame(() => {
+      Ne.current = 0, Ae();
+    }));
+  }, [L, Ae]);
+  gt(() => () => window.cancelAnimationFrame(Ne.current), []), Je(() => {
+    ce !== void 0 && ce !== F.rowKey && et({ rowKey: ce, col: z });
+  }), Je(() => {
+    if (!me.current || xe.current) return;
+    const n = document.activeElement;
+    n && n !== document.body && n.isConnected || (xe.current = !0);
+  });
+  const bt = C(
+    (n, r) => {
+      var d;
+      return ((d = Y.current) == null ? void 0 : d.querySelector(
+        `[role="row"][aria-rowindex="${n + 2}"] > [aria-colindex="${r + 2}"]`
+      )) ?? null;
+    },
+    []
+  );
+  Je(() => {
+    var r;
+    if (!xe.current) return;
+    const n = bt(te, z);
+    n && (xe.current = !1, n.focus({ preventScroll: !0 }), (r = n.scrollIntoView) == null || r.call(n, { block: "nearest", inline: "nearest" }));
+  });
+  const Ke = () => Y.current ? window.getComputedStyle(Y.current).direction === "rtl" : !1, B = $(null), Ge = (n) => {
+    const r = l[n];
+    return r && r.kind === "data" ? r.rowIndex : null;
+  }, ue = $(!1), $e = (n, r) => {
+    const d = Math.max(0, Math.min(de.length - 1, n)), u = Math.max(0, Math.min(Me - 1, r));
+    return xe.current = !0, Se(!1), et({ rowKey: de[d], col: u }), { row: d, col: u };
+  }, Ce = (n, r, d) => {
+    const u = l[n];
+    if (u) {
+      if (u.kind === "group") {
+        y(u.groupId);
+        return;
+      }
+      if (!(r >= K)) {
+        if (A === "range" && d && B.current) {
+          ee(B.current, { rowIndex: u.rowIndex, col: r });
+          return;
+        }
+        B.current = { rowIndex: u.rowIndex, col: r }, we(u.rowIndex, r, !0);
+      }
+    }
+  }, De = (n) => {
+    if (n.target instanceof Element && n.target.closest("button"))
+      return;
+    ke.current = "keyboard";
+    const r = de.length - 1, d = Me - 1, u = Ke() ? -1 : 1;
+    let h = te, N = z;
+    const W = n.ctrlKey || n.metaKey;
+    switch (n.key) {
+      case "ArrowRight":
+        N += u;
+        break;
+      case "ArrowLeft":
+        N -= u;
+        break;
+      case "ArrowDown":
+        h += 1;
+        break;
+      case "ArrowUp":
+        h -= 1;
+        break;
+      case "Home":
+        N = 0, W && (h = 0);
+        break;
+      case "End":
+        N = d, W && (h = r);
+        break;
+      case "PageDown": {
+        const ie = l.findIndex(
+          (Z, _t) => _t > te && Z.kind === "group"
+        );
+        h = l.some((Z) => Z.kind === "group") ? ie === -1 ? r : ie : te + ma(Re.current);
+        break;
+      }
+      case "PageUp": {
+        let ie = -1;
+        for (let Z = Math.min(te, l.length) - 1; Z >= 0; Z -= 1)
+          if (l[Z].kind === "group") {
+            ie = Z;
+            break;
+          }
+        h = l.some((Z) => Z.kind === "group") ? ie === -1 ? 0 : ie : te - ma(Re.current);
+        break;
+      }
+      case "Enter":
+      case " ":
+        n.preventDefault(), Ce(te, z, n.shiftKey);
+        return;
+      case "Escape":
+        Ee && (n.preventDefault(), Se(!0));
+        return;
+      default:
+        return;
+    }
+    n.preventDefault();
+    const se = $e(h, N), ne = n.key.startsWith("Arrow");
+    if (A === "range" && n.shiftKey && ne) {
+      const ie = Ge(se.row), He = B.current ?? (() => {
+        const Z = Ge(te);
+        return Z === null || z >= K ? null : { rowIndex: Z, col: z };
+      })();
+      He && ie !== null && se.col < K && (B.current = He, ee(He, { rowIndex: ie, col: se.col }));
+    }
+  }, je = (n) => {
+    var N;
+    if (!(n instanceof Element)) return null;
+    const r = n.closest('[role="gridcell"]'), d = r == null ? void 0 : r.parentElement;
+    if (!r || !d || !((N = Y.current) != null && N.contains(r))) return null;
+    const u = Number(d.getAttribute("aria-rowindex")) - 2, h = Number(r.getAttribute("aria-colindex")) - 2;
+    return !Number.isInteger(u) || u < 0 || h < 0 ? null : { row: u, col: h };
+  }, ot = $(!1), pe = $("mouse"), yt = (n) => {
+    if (ke.current = "pointer", pe.current = n.pointerType, A !== "range" || n.pointerType !== "mouse" || n.button !== 0)
+      return;
+    const r = je(n.target);
+    if (ue.current = !1, !r) return;
+    const d = Ge(r.row);
+    if (d === null || r.col >= K) return;
+    if (n.shiftKey && B.current)
+      ee(B.current, { rowIndex: d, col: r.col });
+    else {
+      B.current = { rowIndex: d, col: r.col };
+      const h = Kt(o[d].id, s[r.col].id);
+      I.size === 1 && I.has(h) ? ue.current = !0 : ee(B.current, B.current);
+    }
+    ot.current = !0;
+    const u = () => {
+      ot.current = !1, window.removeEventListener("pointerup", u), window.removeEventListener("pointercancel", u);
+    };
+    window.addEventListener("pointerup", u), window.addEventListener("pointercancel", u);
+  }, xt = (n) => {
+    if (n.pointerType !== "mouse") return;
+    const r = je(n.target);
+    if (Ve(
+      r ? { rowKey: de[r.row], col: r.col } : null
+    ), ot.current && r && B.current) {
+      const d = Ge(r.row);
+      d !== null && r.col < K && ((d !== B.current.rowIndex || r.col !== B.current.col) && (ue.current = !1), ue.current || ee(B.current, { rowIndex: d, col: r.col }));
+    }
+  }, fe = $(null), Te = C(() => {
+    fe.current && (document.removeEventListener("pointerover", fe.current), fe.current = null);
+  }, []);
+  gt(() => Te, [Te]);
+  const Pe = (n) => {
+    Te();
+    const r = n.relatedTarget;
+    if (r instanceof Element && r.closest('[data-component="tooltip"]')) {
+      const d = (u) => {
+        var N;
+        const h = u.target;
+        h instanceof Element && h.closest('[data-component="tooltip"]') || (Te(), h instanceof Node && ((N = Y.current) != null && N.contains(h)) || Ve(null));
+      };
+      fe.current = d, document.addEventListener("pointerover", d);
+      return;
+    }
+    Ve(null);
+  }, st = (n) => {
+    var u;
+    const r = n.target instanceof Element ? n.target.closest("button") : null;
+    if (r) {
+      const h = Number((u = r.closest('[role="row"]')) == null ? void 0 : u.getAttribute("aria-rowindex")) - 2;
+      Number.isInteger(h) && h >= 0 && $e(h, z);
+      return;
+    }
+    const d = je(n.target);
+    if (d) {
+      if ($e(d.row, d.col), xe.current = !1, A === "range" && pe.current === "mouse") {
+        const h = l[d.row];
+        (h == null ? void 0 : h.kind) === "group" ? Ce(d.row, d.col, !1) : (h == null ? void 0 : h.kind) === "data" && d.col < K && we(h.rowIndex, d.col, ue.current), ue.current = !1;
+        return;
+      }
+      Ce(d.row, d.col, n.shiftKey);
+    }
+  }, it = $(!1);
+  gt(() => {
+    let n = 0;
+    const r = () => {
+      it.current = !0, window.cancelAnimationFrame(n), n = window.requestAnimationFrame(() => {
+        it.current = !1;
+      });
+    };
+    return window.addEventListener("scroll", r, { capture: !0 }), () => {
+      window.removeEventListener("scroll", r, { capture: !0 }), window.cancelAnimationFrame(n);
+    };
+  }, []);
+  const It = C((n) => {
+    n || it.current && Le.current === null || Se(!0);
+  }, []), kt = C(
+    (n) => S("heatmap.expandGroup", { group: n }),
+    [S]
+  ), lt = C(
+    (n) => S("heatmap.collapseGroup", { group: n }),
+    [S]
+  ), R = `${ae}-description`, qe = l[te], dt = U && (qe == null ? void 0 : qe.kind) === "data" && z < K ? V(J(qe.rowIndex, z)) : null, St = _(
+    () => ({
+      rows: o,
+      columns: s,
+      matrix: c,
+      scale: b,
+      palette: w,
+      describer: m,
+      showValues: x,
+      totals: k,
+      rowTotals: g,
+      groupColumnMethod: p,
+      groupIds: E,
+      minCount: D,
+      selectable: A !== "none",
+      interactive: H,
+      virtualised: L,
+      colWindow: ge.cols,
+      idBase: ae,
+      describedBy: U ? R : void 0,
+      cellInfo: J,
+      tooltipText: V,
+      onTooltipOpenChange: It,
+      onToggleGroup: y,
+      expandLabel: kt,
+      collapseLabel: lt
+    }),
+    [
+      o,
+      s,
+      c,
+      b,
+      w,
+      m,
+      x,
+      k,
+      g,
+      p,
+      E,
+      D,
+      A,
+      H,
+      L,
+      ge.cols,
+      ae,
+      U,
+      R,
+      J,
+      V,
+      It,
+      y,
+      kt,
+      lt
+    ]
+  ), ct = _(() => {
+    const n = /* @__PURE__ */ new Map();
+    for (const d of I) {
+      const [u, h] = Et(d), N = q(h);
+      if (N === void 0) continue;
+      const W = n.get(u) ?? [];
+      W.push(N), n.set(u, W);
+    }
+    const r = /* @__PURE__ */ new Map();
+    for (const [d, u] of n)
+      r.set(d, u.sort((h, N) => h - N).join(","));
+    return r;
+  }, [I, q]), We = (X == null ? void 0 : X.col) ?? -1, Vt = /* @__PURE__ */ P(
+    "div",
+    {
+      ref: _e,
+      role: "row",
+      "aria-rowindex": 1,
+      className: At({ position: "header" }),
+      children: [
+        /* @__PURE__ */ v(
+          "div",
+          {
+            role: "columnheader",
+            "aria-colindex": 1,
+            className: Ft({ corner: !0 }),
+            children: a ?? /* @__PURE__ */ v("span", { className: "ds:sr-only", children: S("heatmap.rowsHeader") })
+          }
+        ),
+        Ct(ge.cols, (n) => /* @__PURE__ */ v(
+          "div",
+          {
+            role: "columnheader",
+            "aria-colindex": n + 2,
+            "data-highlighted": We === n,
+            className: Ft(),
+            children: m.columnLabel(s[n])
+          },
+          n
+        )),
+        g ? /* @__PURE__ */ v(
+          "div",
+          {
+            role: "columnheader",
+            "aria-colindex": K + 2,
+            "data-highlighted": We === K,
+            className: Ft(),
+            children: m.methodLabel(g)
+          }
+        ) : null
+      ]
+    }
+  );
+  let Nt = null;
+  if (M && k) {
+    const n = l.length, r = m.methodLabel(M), d = te === n, u = (h, N, W, se = r) => {
+      const ne = Jt(h, D);
+      return /* @__PURE__ */ v(
+        "div",
+        {
+          role: "gridcell",
+          "aria-colindex": N + 2,
+          "aria-label": m.sentence(se, W, ne),
+          tabIndex: d && z === N ? 0 : -1,
+          className: Lt({ tone: Qt(ne) }),
+          children: m.visibleText(ne)
+        },
+        N
+      );
+    };
+    Nt = /* @__PURE__ */ P(
+      "div",
+      {
+        ref: Oe,
+        role: "row",
+        "aria-rowindex": n + 2,
+        className: At({ position: "footer" }),
+        children: [
+          /* @__PURE__ */ v(
+            "div",
+            {
+              role: "rowheader",
+              "aria-colindex": 1,
+              "data-highlighted": (X == null ? void 0 : X.rowKey) === Mt,
+              className: Yt({ kind: "total", virtualised: L }),
+              children: r
+            }
+          ),
+          Ct(
+            ge.cols,
+            (h) => u(k.columns[h], h, m.columnLabel(s[h]))
+          ),
+          g ? u(
+            k.grand,
+            K,
+            m.methodLabel(g),
+            // The corner aggregates every cell by the row method, so it
+            // is named for all cells, not for the footer's own method.
+            S("heatmap.allCells")
+          ) : null
+        ]
+      }
+    );
+  }
+  const i = [], f = ge.rows;
+  f.lead > 0 && i.push(
+    /* @__PURE__ */ v(
+      "div",
+      {
+        "aria-hidden": "true",
+        className: Xe({ axis: "row-lead" })
+      },
+      "row-lead"
+    )
+  ), f.indexes.forEach((n, r) => {
+    f.middle > 0 && r === f.middleAfter && i.push(
+      /* @__PURE__ */ v(
+        "div",
+        {
+          "aria-hidden": "true",
+          className: Xe({ axis: "row-middle" })
+        },
+        "row-middle"
+      )
+    );
+    const d = l[n];
+    if (!d) return;
+    const u = n === te;
+    i.push(
+      /* @__PURE__ */ v(
+        Sr,
+        {
+          ctx: St,
+          row: d,
+          ariaRowIndex: n + 2,
+          highlighted: (X == null ? void 0 : X.rowKey) === d.key,
+          activeCol: u ? z : -1,
+          tooltipCol: (Ee == null ? void 0 : Ee.rowKey) === d.key ? Ee.col : -1,
+          selectedCols: d.kind === "data" ? ct.get(o[d.rowIndex].id) ?? "" : ""
+        },
+        d.key
+      )
+    );
+  }), f.tail > 0 && i.push(
+    /* @__PURE__ */ v(
+      "div",
+      {
+        "aria-hidden": "true",
+        className: Xe({ axis: "row-tail" })
+      },
+      "row-tail"
+    )
+  );
+  const T = {
+    "--heatmap-columns": String(Math.max(1, K)),
+    "--heatmap-row-lead": String(f.lead),
+    "--heatmap-row-middle": String(f.middle),
+    "--heatmap-row-tail": String(f.tail),
+    "--heatmap-col-lead": String(ge.cols.lead),
+    "--heatmap-col-middle": String(ge.cols.middle),
+    "--heatmap-col-tail": String(ge.cols.tail),
+    "--heatmap-sticky-block-start": `${re.headerBlock}px`,
+    "--heatmap-sticky-block-end": `${re.footerBlock}px`,
+    "--heatmap-sticky-inline-start": `${re.leadInline}px`
+  };
+  return /* @__PURE__ */ P(
+    "div",
+    {
+      ref: Q,
+      onScroll: nt,
+      style: T,
+      "data-component": "heatmap-grid",
+      className: wr(),
+      children: [
+        /* @__PURE__ */ P(
+          "div",
+          {
+            ref: Y,
+            role: "grid",
+            tabIndex: -1,
+            "aria-label": t,
+            "aria-rowcount": de.length + 1,
+            "aria-colcount": Me + 1,
+            "aria-multiselectable": A === "multiple" || A === "range" ? !0 : void 0,
+            "data-heatmap-grid": "",
+            className: yr({
+              size: ve,
+              density: j,
+              virtualised: L,
+              totalsColumn: !!g
+            }),
+            onKeyDown: De,
+            onPointerDown: yt,
+            onPointerMove: xt,
+            onPointerLeave: Pe,
+            onClick: st,
+            onFocus: (n) => {
+              n.target.matches(":focus-visible") && (ke.current = "keyboard"), me.current = !0, G(!0);
+            },
+            onBlur: (n) => {
+              n.currentTarget.contains(n.relatedTarget) || (me.current = !1, G(!1));
+            },
+            children: [
+              Vt,
+              i,
+              Nt
+            ]
+          }
+        ),
+        dt !== null ? /* @__PURE__ */ v("span", { id: R, hidden: !0, children: dt }) : null
+      ]
+    }
+  );
+}
+const $t = Array.from({ length: be }, (e, t) => t);
+function _r(e, t) {
+  return {
+    start: e.min === null ? "" : t(e.min),
+    end: e.max === null ? "" : t(e.max),
+    middle: e.type === "diverging" && e.midpoint !== void 0 ? t(e.midpoint) : void 0
+  };
+}
+const ea = fa(
+  ({
+    variant: e = "stepped",
+    palette: t,
+    scale: a,
+    values: o,
+    valueFormatter: s,
+    showEmpty: c,
+    showLowSample: l,
+    minCount: b,
+    className: w
+  }, m) => {
+    const { t: x, i18n: k } = Ht("ui"), g = xa(), M = wa(k.resolvedLanguage ?? k.language), p = _(
+      () => a ? Wt(a, o ?? []) : (g == null ? void 0 : g.scale) ?? Wt({ type: "sequential" }, o ?? []),
+      [a, o, g == null ? void 0 : g.scale]
+    ), E = t ?? (g == null ? void 0 : g.palette) ?? (p.type === "diverging" ? "diverging" : "primary"), D = s ?? (g == null ? void 0 : g.describer.formatValue) ?? Ia(M, "number"), A = (p.type === "quantile" || p.type === "threshold") && p.thresholds.length > 0, I = p.thresholds.length + 1, q = A ? Array.from(
+      { length: I },
+      (y, S) => qt(S, I)
+    ) : [], H = p.thresholds.map(D), L = _r(p, D), ve = A ? x("heatmap.legend.descriptionBands", {
+      count: I,
+      formatted: ka(M)(I),
+      edges: new Intl.ListFormat(M, {
+        type: "conjunction"
+      }).format(H)
+    }) : L.middle !== void 0 ? x("heatmap.legend.descriptionDiverging", {
+      min: L.start,
+      max: L.end,
+      midpoint: L.middle
+    }) : x("heatmap.legend.description", {
+      min: L.start,
+      max: L.end
+    }), j = (p.type === "quantile" || p.type === "threshold") && !A ? [p.min === null ? be / 2 : p.stepOf(p.min)] : null, J = c ?? (g == null ? void 0 : g.hasEmpty) ?? !1, V = l ?? (g == null ? void 0 : g.hasLowSample) ?? !1, U = b ?? (g == null ? void 0 : g.minCount), we = e === "continuous" ? "continuous" : "stepped", ee = (y) => /* @__PURE__ */ v("span", { className: Ir({ variant: e }), children: y.map((S) => /* @__PURE__ */ v(
+      "span",
+      {
+        className: mt({
+          tone: Ut(E, S),
+          shape: we
+        })
+      },
+      S
+    )) });
+    return /* @__PURE__ */ P(
+      "div",
+      {
+        ref: m,
+        role: "group",
+        "aria-label": x("heatmap.legend.label"),
+        "data-component": "heatmap-legend",
+        className: xr({ className: w }),
+        children: [
+          /* @__PURE__ */ v("span", { className: "ds:sr-only", children: ve }),
+          A ? /* @__PURE__ */ v(
+            "span",
+            {
+              "aria-hidden": "true",
+              "data-legend": "bands",
+              className: "ds:flex ds:min-w-0 ds:max-w-full ds:flex-wrap ds:items-center ds:gap-[var(--spacing-xs)] ds:tabular-nums",
+              children: q.map((y, S) => /* @__PURE__ */ P(
+                "span",
+                {
+                  className: "ds:inline-flex ds:items-center ds:gap-[var(--spacing-xs)]",
+                  children: [
+                    /* @__PURE__ */ v(
+                      "span",
+                      {
+                        "data-step": y,
+                        className: mt({
+                          tone: Ut(E, y),
+                          shape: "key"
+                        })
+                      }
+                    ),
+                    S < H.length ? /* @__PURE__ */ v("span", { className: "ds:shrink-0", children: H[S] }) : null
+                  ]
+                },
+                y
+              ))
+            }
+          ) : /* @__PURE__ */ P(
+            "span",
+            {
+              "aria-hidden": "true",
+              className: "ds:flex ds:min-w-0 ds:max-w-full ds:items-center ds:gap-[var(--spacing-xs)] ds:tabular-nums",
+              children: [
+                /* @__PURE__ */ v("span", { className: "ds:shrink-0", children: L.start }),
+                L.middle !== void 0 ? /* @__PURE__ */ P(La, { children: [
+                  ee($t.slice(0, be / 2)),
+                  /* @__PURE__ */ v(
+                    "span",
+                    {
+                      "data-legend": "midpoint",
+                      className: mt({
+                        tone: "midpoint",
+                        shape: "label"
+                      }),
+                      children: L.middle
+                    }
+                  ),
+                  ee($t.slice(be / 2))
+                ] }) : ee(j ?? $t),
+                /* @__PURE__ */ v("span", { className: "ds:shrink-0", children: L.end })
+              ]
+            }
+          ),
+          J ? /* @__PURE__ */ P("span", { className: "ds:inline-flex ds:items-center ds:gap-[var(--spacing-xs)]", children: [
+            /* @__PURE__ */ v(
+              "span",
+              {
+                "aria-hidden": "true",
+                className: mt({ tone: "empty" })
+              }
+            ),
+            x("heatmap.legend.noData")
+          ] }) : null,
+          V ? /* @__PURE__ */ P("span", { className: "ds:inline-flex ds:items-center ds:gap-[var(--spacing-xs)]", children: [
+            /* @__PURE__ */ v(
+              "span",
+              {
+                "aria-hidden": "true",
+                className: mt({ tone: "low-sample" })
+              }
+            ),
+            U === void 0 ? x("heatmap.legend.lowSample") : x("heatmap.legend.lowSampleUnder", {
+              value: new Intl.NumberFormat(M).format(U)
+            })
+          ] }) : null
+        ]
+      }
+    );
+  }
+);
+ea.displayName = "HeatmapLegend";
+const ta = () => import("./data-table-C6T31E33.js").then((e) => e.h).then((e) => ({
+  default: e.DataTable
+})), Mr = va(ta);
+function ha() {
+  ta().catch(() => {
+  });
+}
+function ht(e, t) {
+  const a = (e == null ? void 0 : e.value) ?? null;
+  return {
+    value: a,
+    count: e == null ? void 0 : e.count,
+    status: a === null ? "empty" : Zt(e == null ? void 0 : e.count, t) ? "low-sample" : "value"
+  };
+}
+function Rr({
+  title: e,
+  rowsLabel: t,
+  rows: a,
+  columns: o,
+  matrix: s,
+  body: c,
+  grouped: l,
+  groupIds: b,
+  describer: w,
+  totals: m,
+  rowTotals: x,
+  columnTotals: k,
+  groupColumnMethod: g,
+  minCount: M,
+  onLoadError: p
+}) {
+  const { t: E } = Ht("ui"), D = _(
+    () => [
+      ...l ? [
+        {
+          colId: "group",
+          field: "group",
+          headerName: E("heatmap.table.group"),
+          // A sort here would pull rows out of their groups.
+          sortable: !1
+        }
+      ] : [],
+      {
+        colId: "row",
+        field: "row",
+        headerName: t ?? E("heatmap.rowsHeader"),
+        sortable: !l
+      },
+      ...o.map(
+        (y, S) => ({
+          colId: `c${S}`,
+          headerName: w.columnLabel(y),
+          valueGetter: (ae) => {
+            var Q;
+            return ((Q = ae.data) == null ? void 0 : Q.cells[S]) ?? "";
+          },
+          sortable: !1
+        })
+      ),
+      ...x ? [
+        {
+          colId: "total",
+          field: "total",
+          headerName: w.methodLabel(x),
+          sortable: !1
+        }
+      ] : []
+    ],
+    [l, t, o, w, x, E]
+  ), A = _(
+    () => c.map((y) => {
+      if (y.kind === "group") {
+        const Q = w.groupLabel(y.groupId), Y = (m == null ? void 0 : m.groupColumns.get(y.groupId)) ?? [];
+        return {
+          id: `group:${b.get(y.groupId) ?? ""}`,
+          group: Q,
+          row: w.groupRowText(Q, g),
+          cells: o.map(
+            (_e, Oe) => w.tableText(ht(Y[Oe], M))
+          ),
+          total: x && m ? w.tableText(
+            ht(m.groups.get(y.groupId), M)
+          ) : void 0
+        };
+      }
+      const S = y.rowIndex, ae = a[S].group;
+      return {
+        id: `row:${a[S].id}`,
+        group: l && ae !== void 0 ? w.groupLabel(ae) : void 0,
+        row: w.rowLabel(a[S]),
+        cells: s[S].map((Q) => w.tableText(Q)),
+        total: x && m ? w.tableText(ht(m.rows[S], M)) : void 0
+      };
+    }),
+    [
+      c,
+      a,
+      o,
+      s,
+      l,
+      b,
+      w,
+      x,
+      m,
+      g,
+      M
+    ]
+  ), I = _(
+    () => k && m ? [
+      {
+        id: "heatmap-column-totals",
+        row: w.methodLabel(k),
+        cells: m.columns.map(
+          (y) => w.tableText(ht(y, M))
+        ),
+        // The grand total, by the row method, as the grid's corner.
+        total: x ? w.tableText(ht(m.grand, M)) : void 0
+      }
+    ] : void 0,
+    [k, x, m, w, M]
+  ), q = A.length + ((I == null ? void 0 : I.length) ?? 0), H = $(q);
+  H.current = q;
+  const [L, ve] = le(null), j = L === q, J = $(null);
+  Je(() => {
+    const y = J.current;
+    if (j || !y || typeof ResizeObserver > "u") return;
+    const S = new ResizeObserver(() => {
+      y.scrollHeight > y.clientHeight + 1 && ve(H.current);
+    }), ae = () => {
+      S.observe(y);
+      for (const Y of Array.from(y.children)) S.observe(Y);
+    };
+    ae();
+    const Q = new MutationObserver(ae);
+    return Q.observe(y, { childList: !0 }), () => {
+      S.disconnect(), Q.disconnect();
+    };
+  }, [j]);
+  const V = _(
+    () => ({
+      getRowId: (y) => y.data.id,
+      domLayout: j ? "normal" : "autoHeight"
+    }),
+    [j]
+  ), [U, we] = le(0), ee = _(
+    () => U === 0 ? Mr : va(ta),
+    [U]
+  );
+  return /* @__PURE__ */ v(
+    "div",
+    {
+      ref: J,
+      role: "group",
+      "aria-label": e,
+      tabIndex: -1,
+      "data-component": "heatmap-table",
+      "data-layout": j ? "capped" : "fit",
+      className: br({ capped: j }),
+      children: /* @__PURE__ */ v(
+        ja,
+        {
+          size: "sm",
+          onError: () => p == null ? void 0 : p(),
+          onRetry: () => {
+            var y;
+            we((S) => S + 1), (y = J.current) == null || y.focus();
+          },
+          children: /* @__PURE__ */ v(
+            Ha,
+            {
+              fallback: /* @__PURE__ */ v("div", { role: "status", "aria-label": E("heatmap.loadingTable"), children: /* @__PURE__ */ v(
+                jt,
+                {
+                  variant: "rectangular",
+                  className: "ds:h-[calc(var(--min-target-size)*4)] ds:w-full"
+                }
+              ) }),
+              children: /* @__PURE__ */ v(
+                ee,
+                {
+                  columnDefs: D,
+                  rowData: A,
+                  pinnedBottomRowData: I,
+                  density: "compact",
+                  heightClass: j ? "ds:min-h-0 ds:flex-1" : "",
+                  gridOptions: V
+                }
+              )
+            }
+          )
+        }
+      )
+    }
+  );
+}
+const Tr = { type: "sequential", domain: "auto" }, Dt = (e) => new Set((e ?? []).map((t) => Kt(t.rowId, t.columnId))), ga = { text: "", privacyMode: !1, repeat: 0 }, Ta = fa(
+  ({
+    title: e,
+    rows: t,
+    columns: a,
+    getCell: o,
+    cells: s,
+    groups: c,
+    scale: l = Tr,
+    palette: b,
+    valueType: w = "number",
+    minCount: m,
+    valueFormatter: x,
+    showValues: k = !1,
+    legend: g = "stepped",
+    rowTotals: M = !1,
+    columnTotals: p = !1,
+    sortRows: E,
+    defaultSortRows: D = "none",
+    onSortRowsChange: A,
+    groupRows: I = !1,
+    defaultCollapsedGroups: q,
+    selection: H = "none",
+    selectedCells: L,
+    defaultSelectedCells: ve,
+    onSelectionChange: j,
+    onCellClick: J,
+    renderTooltip: V,
+    density: U = "default",
+    size: we = "md",
+    loading: ee = !1,
+    privacyMode: y = !1,
+    privacyScope: S = "rows",
+    rowsLabel: ae,
+    defaultView: Q = "heatmap",
+    onViewChange: Y,
+    id: _e,
+    className: Oe,
+    children: K
+  }, Me) => {
+    const { t: O, i18n: de } = Ht("ui"), ye = wa(de.resolvedLanguage ?? de.language), F = _(
+      () => dr(t, a, o, s, m),
+      [t, a, o, s, m]
+    ), et = _(() => cr(F), [F]), te = JSON.stringify(l), z = _(
+      () => Wt(l, et),
+      // eslint-disable-next-line react-hooks/exhaustive-deps -- keyed by content
+      [te, et]
+    ), ce = b ?? (z.type === "diverging" ? "diverging" : "primary"), xe = _(
+      () => x ?? Ia(ye, w),
+      [x, ye, w]
+    ), Ie = _(() => ka(ye), [ye]), G = _(
+      () => Qa({
+        t: O,
+        privacyMode: y,
+        privacyScope: S,
+        valueType: w,
+        formatValue: xe,
+        formatCount: Ie,
+        groups: c
+      }),
+      [
+        O,
+        y,
+        S,
+        w,
+        xe,
+        Ie,
+        c
+      ]
+    ), me = _(
+      () => ir(t, c),
+      [t, c]
+    ), ke = p || M || "mean", tt = M || "mean", ze = _(
+      () => pr(
+        F,
+        t,
+        a.length,
+        tt,
+        p || "mean",
+        ke
+      ),
+      [
+        F,
+        t,
+        a.length,
+        tt,
+        p,
+        ke
+      ]
+    ), [Le, ft] = le(ga), Se = $(0), Ve = $(y);
+    Ve.current = y;
+    const X = C((i, f = !1) => {
+      window.clearTimeout(Se.current);
+      const T = Ve.current, n = () => ft((r) => ({
+        text: i,
+        privacyMode: T,
+        repeat: r.text === i ? r.repeat + 1 : 0
+      }));
+      f ? Se.current = window.setTimeout(n, 300) : n();
+    }, []);
+    gt(() => () => window.clearTimeout(Se.current), []), gt(() => {
+      window.clearTimeout(Se.current), ft((i) => i.text === "" ? i : ga);
+    }, [y]);
+    const Ee = Le.privacyMode === y ? (
+      // The same words twice leave the DOM unchanged and a screen reader
+      // silent: a trailing no-break space on every other repeat changes
+      // the text without changing what is read.
+      `${Le.text}${Le.repeat % 2 === 1 ? " " : ""}`
+    ) : "", [re, Ot] = le(Q), Re = C(
+      (i) => {
+        Ot(i), Y == null || Y(i), X(
+          O(i === "table" ? "heatmap.announce.tableView" : "heatmap.announce.heatmapView")
+        );
+      },
+      [Y, X, O]
+    ), [at, vt] = le(D), Be = E ?? at, rt = C(
+      (i) => {
+        E === void 0 && vt(i), A == null || A(i);
+      },
+      [E, A]
+    ), [he, zt] = le(
+      () => new Set(q ?? [])
+    ), Fe = C(
+      (i, f) => {
+        if (he.has(i) === f) return;
+        zt((n) => {
+          if (n.has(i) === f) return n;
+          const r = new Set(n);
+          return f ? r.add(i) : r.delete(i), r;
+        });
+        const T = G.groupLabel(i);
+        X(
+          f ? O("heatmap.announce.groupCollapsed", { group: T }) : O("heatmap.announce.groupExpanded", { group: T })
+        );
+      },
+      [he, X, G, O]
+    ), wt = C(
+      (i) => Fe(i, !he.has(i)),
+      [he, Fe]
+    ), ge = _(
+      () => new Intl.Collator(ye, { numeric: !0, sensitivity: "base" }),
+      [ye]
+    ), Ae = Be === "label" && G.masksRows ? "none" : Be, Ne = _(
+      () => hr(
+        t.map((i, f) => f),
+        t,
+        ze.rows,
+        Ae,
+        ge
+      ),
+      [t, ze.rows, Ae, ge]
+    ), nt = _(
+      () => oa(t, Ne, I, he),
+      [t, Ne, I, he]
+    ), bt = _(
+      () => oa(t, Ne, I, /* @__PURE__ */ new Set()),
+      [t, Ne, I]
+    ), Ke = _(
+      () => new Map(t.map((i, f) => [i.id, f])),
+      [t]
+    ), B = _(
+      () => new Map(a.map((i, f) => [String(i.id), f])),
+      [a]
+    ), Ge = C(
+      (i) => B.get(i),
+      [B]
+    ), ue = C(
+      (i, f) => {
+        const T = t[i], n = a[f], r = F[i][f];
+        return {
+          rowId: T.id,
+          columnId: n.id,
+          row: T,
+          column: n,
+          rowIndex: i,
+          columnIndex: f,
+          value: r.value,
+          count: r.count,
+          label: r.label,
+          status: r.status,
+          step: r.status === "value" && r.value !== null ? z.stepOf(r.value) : null
+        };
+      },
+      [t, a, F, z]
+    ), $e = C(
+      (i) => {
+        const f = i.row.group === void 0 ? void 0 : me.get(i.row.group);
+        return {
+          rowId: i.rowId,
+          columnId: i.columnId,
+          row: {
+            id: i.row.id,
+            label: G.rowLabel(i.row),
+            ...f === void 0 ? {} : { group: f }
+          },
+          column: {
+            id: i.column.id,
+            label: G.columnLabel(i.column)
+          },
+          rowIndex: i.rowIndex,
+          columnIndex: i.columnIndex,
+          value: i.value,
+          count: i.count,
+          status: i.status,
+          step: i.step
+        };
+      },
+      [G, me]
+    ), Ce = C(
+      (i) => V ? V(y ? $e(i) : i, {
+        privacyMode: y
+      }) : G.sentence(
+        G.rowLabel(i.row),
+        G.columnLabel(i.column),
+        F[i.rowIndex][i.columnIndex]
+      ),
+      [V, y, $e, G, F]
+    ), De = L !== void 0, [je, ot] = le(
+      () => Dt(ve)
+    ), pe = _(() => {
+      const i = De ? Dt(L) : je, f = /* @__PURE__ */ new Set();
+      for (const T of i) {
+        const [n, r] = Et(T);
+        Ke.has(n) && B.has(r) && f.add(T);
+      }
+      return f;
+    }, [
+      De,
+      L,
+      je,
+      Ke,
+      B
+    ]), yt = C(
+      (i) => {
+        const f = [];
+        for (const T of i) {
+          const [n, r] = Et(T), d = Ke.get(n), u = B.get(r);
+          d !== void 0 && u !== void 0 && f.push(ue(d, u));
+        }
+        return f;
+      },
+      [Ke, B, ue]
+    ), xt = C(
+      (i, f) => G.cellName(
+        G.rowLabel(t[i]),
+        G.columnLabel(a[f])
+      ),
+      [G, t, a]
+    ), fe = C(
+      (i, f, T = !1) => {
+        De || ot(i), j == null || j(yt(i)), X(f, T);
+      },
+      [De, j, yt, X]
+    ), Te = C(
+      (i) => i === 0 ? O("heatmap.announce.cleared") : O("heatmap.announce.count", {
+        count: i,
+        formatted: Ie(i)
+      }),
+      [O, Ie]
+    ), Pe = _(
+      () => nt.flatMap((i) => i.kind === "data" ? [i.rowIndex] : []),
+      [nt]
+    ), st = C(
+      (i, f) => {
+        const T = Pe.indexOf(i.rowIndex), n = Pe.indexOf(f.rowIndex), r = /* @__PURE__ */ new Set();
+        if (T === -1 || n === -1) return r;
+        const [d, u] = T <= n ? [T, n] : [n, T], [h, N] = i.col <= f.col ? [i.col, f.col] : [f.col, i.col];
+        for (let W = d; W <= u; W += 1) {
+          const se = t[Pe[W]].id;
+          for (let ne = h; ne <= N; ne += 1)
+            r.add(Kt(se, a[ne].id));
+        }
+        return r;
+      },
+      [Pe, t, a]
+    ), it = C(
+      (i, f, T) => {
+        if (J == null || J(ue(i, f)), !T || H === "none") return;
+        const n = Kt(t[i].id, a[f].id), r = xt(i, f);
+        if (H === "multiple") {
+          const u = new Set(pe), h = !u.has(n);
+          h ? u.add(n) : u.delete(n), fe(
+            u,
+            O(h ? "heatmap.announce.added" : "heatmap.announce.removed", {
+              cell: r,
+              count: u.size,
+              formatted: Ie(u.size)
+            })
+          );
+          return;
+        }
+        const d = pe.size === 1 && pe.has(n);
+        fe(
+          d ? /* @__PURE__ */ new Set() : /* @__PURE__ */ new Set([n]),
+          d ? O("heatmap.announce.cleared") : O("heatmap.announce.selected", { cell: r })
+        );
+      },
+      [
+        J,
+        ue,
+        H,
+        t,
+        a,
+        xt,
+        pe,
+        fe,
+        Ie,
+        O
+      ]
+    ), It = C(
+      (i, f) => {
+        if (H !== "range" && H !== "multiple") return;
+        const T = st(i, f);
+        T.size === pe.size && [...T].every((n) => pe.has(n)) || fe(T, Te(T.size), !0);
+      },
+      [H, st, pe, fe, Te]
+    ), kt = _(
+      () => new Map([...me].map(([i, f]) => [f, i])),
+      [me]
+    ), lt = {
+      selected: pe,
+      selection: H,
+      view: re,
+      sortRows: Be,
+      collapsed: he,
+      groupRows: I,
+      rows: t,
+      columns: a,
+      expandedBody: bt,
+      groupIds: me,
+      groupByPublicId: kt,
+      rowIndexById: Ke,
+      columnIndexById: B,
+      matrix: F,
+      scale: z,
+      setView: Re,
+      setSortRows: rt,
+      setGroupCollapsed: Fe,
+      commitSelection: fe,
+      rectangle: st,
+      countMessage: Te
+    }, R = $(lt);
+    R.current = lt;
+    const qe = _(() => {
+      const i = (r) => {
+        const { columns: d, columnIndexById: u } = R.current, h = [];
+        for (const N of r) {
+          const [W, se] = Et(N), ne = u.get(se);
+          ne !== void 0 && h.push({ rowId: W, columnId: d[ne].id });
+        }
+        return h;
+      }, f = (r) => {
+        const { rowIndexById: d, columnIndexById: u } = R.current, h = d.get(r.rowId), N = u.get(String(r.columnId));
+        return h === void 0 || N === void 0 ? null : { rowIndex: h, col: N };
+      }, T = (r) => {
+        const d = f(r);
+        if (!d)
+          throw new Error(
+            `Heatmap: no cell at row "${r.rowId}", column "${String(r.columnId)}".`
+          );
+        return d;
+      }, n = () => {
+        if (R.current.selection === "none")
+          throw new Error('Heatmap: selection is off (selection="none").');
+      };
+      return {
+        getSelection: () => i(R.current.selected),
+        getSelectionMode: () => R.current.selection,
+        selectCells: (r) => {
+          n(), r.forEach(T);
+          const { selection: d } = R.current, u = d === "single" ? r.slice(0, 1) : r, h = Dt(u);
+          R.current.commitSelection(
+            h,
+            R.current.countMessage(h.size)
+          );
+        },
+        selectRange: (r, d) => {
+          const { selection: u } = R.current;
+          if (u !== "range" && u !== "multiple")
+            throw new Error(
+              'Heatmap: select_range needs selection="range" or "multiple".'
+            );
+          const h = T(r), N = T(d), W = R.current.rectangle(h, N);
+          R.current.commitSelection(
+            W,
+            R.current.countMessage(W.size)
+          );
+        },
+        clearSelection: () => {
+          n(), R.current.selected.size !== 0 && R.current.commitSelection(
+            /* @__PURE__ */ new Set(),
+            R.current.countMessage(0)
+          );
+        },
+        readCell: (r) => {
+          const d = f(r);
+          if (!d) return null;
+          const u = R.current.matrix[d.rowIndex][d.col];
+          return {
+            value: u.value,
+            count: u.count,
+            status: u.status,
+            step: u.status === "value" && u.value !== null ? R.current.scale.stepOf(u.value) : null
+          };
+        },
+        getView: () => R.current.view,
+        setView: (r) => R.current.setView(r),
+        getSortRows: () => R.current.sortRows,
+        setSortRows: (r) => R.current.setSortRows(r),
+        getRowIds: () => {
+          const { expandedBody: r, rows: d } = R.current;
+          return r.flatMap(
+            (u) => u.kind === "data" ? [d[u.rowIndex].id] : []
+          );
+        },
+        getColumnIds: () => R.current.columns.map((r) => r.id),
+        getGroupIds: () => {
+          const {
+            groupRows: r,
+            expandedBody: d,
+            groupIds: u
+          } = R.current;
+          return r ? d.flatMap(
+            (h) => h.kind === "group" ? [u.get(h.groupId) ?? ""] : []
+          ) : [];
+        },
+        getCollapsedGroups: () => {
+          const { collapsed: r, groupIds: d } = R.current;
+          return [...r].flatMap((u) => {
+            const h = d.get(u);
+            return h === void 0 ? [] : [h];
+          });
+        },
+        setGroupCollapsed: (r, d) => {
+          const { groupRows: u, groupByPublicId: h } = R.current;
+          if (!u)
+            throw new Error(
+              "Heatmap: rows are not grouped (groupRows is off)."
+            );
+          const N = h.get(r);
+          if (N === void 0)
+            throw new Error(`Heatmap: no group "${r}".`);
+          R.current.setGroupCollapsed(N, d);
+        }
+      };
+    }, []);
+    Oa(Ya, qe, _e);
+    const dt = _(
+      () => F.some((i) => i.some((f) => f.status === "empty")),
+      [F]
+    ), St = _(
+      () => F.some((i) => i.some((f) => f.status === "low-sample")),
+      [F]
+    ), ct = _(
+      () => ({
+        palette: ce,
+        scale: z,
+        describer: G,
+        hasEmpty: dt,
+        hasLowSample: St,
+        minCount: m,
+        tooltipText: Ce
+      }),
+      [
+        ce,
+        z,
+        G,
+        dt,
+        St,
+        m,
+        Ce
+      ]
+    ), We = ua({ className: Oe });
+    if (ee)
+      return /* @__PURE__ */ v(Tt.Provider, { value: ct, children: /* @__PURE__ */ P(
+        "div",
+        {
+          ref: Me,
+          "data-component": "heatmap",
+          "data-component-id": _e,
+          className: We,
+          children: [
+            /* @__PURE__ */ P(
+              "div",
+              {
+                role: "status",
+                "aria-label": O("heatmap.loading"),
+                "aria-busy": "true",
+                className: ua(),
+                children: [
+                  /* @__PURE__ */ v(
+                    jt,
+                    {
+                      variant: "rectangular",
+                      className: "ds:h-[var(--spacing-md)] ds:w-[calc(var(--spacing-xl)*6)] ds:max-w-full"
+                    }
+                  ),
+                  /* @__PURE__ */ v(
+                    jt,
+                    {
+                      variant: "rectangular",
+                      className: "ds:h-[calc(var(--min-target-size)*5)] ds:w-full"
+                    }
+                  )
+                ]
+              }
+            ),
+            K
+          ]
+        }
+      ) });
+    if (t.length === 0 || a.length === 0 || !ur(F))
+      return /* @__PURE__ */ v(Tt.Provider, { value: ct, children: /* @__PURE__ */ P(
+        "div",
+        {
+          ref: Me,
+          "data-component": "heatmap",
+          "data-component-id": _e,
+          className: We,
+          children: [
+            /* @__PURE__ */ v(
+              Va,
+              {
+                variant: "no-results",
+                size: "sm",
+                title: O("heatmap.empty.title"),
+                description: O("heatmap.empty.description")
+              }
+            ),
+            K
+          ]
+        }
+      ) });
+    const Vt = t.length * a.length > gr, Nt = H !== "none" || J !== void 0;
+    return /* @__PURE__ */ v(Tt.Provider, { value: ct, children: /* @__PURE__ */ P(
+      "div",
+      {
+        ref: Me,
+        "data-component": "heatmap",
+        "data-component-id": _e,
+        className: We,
+        children: [
+          /* @__PURE__ */ P("div", { className: vr(), children: [
+            g !== !1 ? /* @__PURE__ */ v(ea, { variant: g }) : null,
+            /* @__PURE__ */ v(
+              za,
+              {
+                intent: "outline",
+                size: "sm",
+                className: "ds:ms-auto",
+                startIcon: re === "table" ? /* @__PURE__ */ v(qa, { "aria-hidden": "true" }) : /* @__PURE__ */ v(Ua, { "aria-hidden": "true" }),
+                onPointerEnter: re === "table" ? void 0 : ha,
+                onFocus: re === "table" ? void 0 : ha,
+                onClick: () => Re(re === "table" ? "heatmap" : "table"),
+                children: O(re === "table" ? "heatmap.viewAsHeatmap" : "heatmap.viewAsTable")
+              }
+            )
+          ] }),
+          re === "table" ? /* @__PURE__ */ v(
+            Rr,
+            {
+              onLoadError: () => X(O("heatmap.announce.tableFailed")),
+              title: e,
+              rowsLabel: ae,
+              rows: t,
+              columns: a,
+              matrix: F,
+              body: bt,
+              grouped: I,
+              groupIds: me,
+              describer: G,
+              totals: ze,
+              rowTotals: M,
+              columnTotals: p,
+              groupColumnMethod: ke,
+              minCount: m
+            },
+            `${y}-${S}`
+          ) : /* @__PURE__ */ v(Fa, { delayDuration: 0, children: /* @__PURE__ */ v(
+            Nr,
+            {
+              title: e,
+              rowsLabel: ae,
+              rows: t,
+              columns: a,
+              matrix: F,
+              body: nt,
+              scale: z,
+              palette: ce,
+              describer: G,
+              showValues: k,
+              totals: ze,
+              rowTotals: M,
+              columnTotals: p,
+              groupColumnMethod: ke,
+              groupIds: me,
+              minCount: m,
+              selectionMode: H,
+              selected: pe,
+              columnIndexOfKey: Ge,
+              interactive: Nt,
+              virtualised: Vt,
+              size: we,
+              density: U,
+              cellInfo: ue,
+              tooltipText: Ce,
+              describeFocused: V !== void 0,
+              onActivate: it,
+              onRange: It,
+              onToggleGroup: wt
+            }
+          ) }),
+          K,
+          /* @__PURE__ */ v(Ba, { children: Ee }, String(y))
+        ]
+      }
+    ) });
+  }
+);
+Ta.displayName = "Heatmap";
+const Wr = Object.assign(Ta, {
+  Legend: ea,
+  Tooltip: Na
+});
+export {
+  Wr as H,
+  ea as a,
+  Na as b,
+  Ya as h
+};
+//# sourceMappingURL=heatmap-BARGZZt2.js.map