@alfadocs/ui-kit-debug 1.64.0 → 1.66.0

package/dist/_chunks/heatmap-DuDfTIII.js

@@ -1,2865 +0,0 @@
-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-D-MQxsA_.js";
-import { E as Va } from "./empty-state-pL1qum99.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-uEBdD1-5.js";
-import { p as Ga } from "./privacy-mask-Ch7743uk.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-Dzgu3O6W.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-C6ft3fSd.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-DuDfTIII.js.map