@alfadocs/ui-kit-debug 1.65.0 → 1.66.0

package/dist/_chunks/heatmap-C1TeC7wT.js

@@ -0,0 +1,3650 @@
+import { jsx as H, jsxs as le, Fragment as Vn } from "react/jsx-runtime";
+import { useContext as Gn, createContext as $n, useId as Pn, useRef as ie, useMemo as X, useState as we, useCallback as ae, useEffect as gt, memo as jn, forwardRef as Mn, lazy as Sn, Suspense as qn } from "react";
+import { useTranslation as Ht } from "react-i18next";
+import { u as Wn } from "./registry-DvAUVLHh.js";
+import { f as An } from "./intl-locale-FWh-Y5_3.js";
+import { B as Un } from "./button-D-MQxsA_.js";
+import { E as Yn } from "./empty-state-pL1qum99.js";
+import { L as Jn } from "./live-region-C41SO3cA.js";
+import { S as qt } from "./skeleton-B1KTdJ4N.js";
+import { T as Nn, a as Qn } from "./tooltip-uEBdD1-5.js";
+import { p as Xn } from "./privacy-mask-Ch7743uk.js";
+import { u as nt } from "./use-isomorphic-layout-effect-BGfaCOP1.js";
+import { i as Zn } from "./is-development-CLUAnsU7.js";
+import { c as ge } from "./index-D2ZczOXr.js";
+import { C as eo } from "./chevron-down-DWE7GSq9.js";
+import { E as to } from "./error-boundary-Dzgu3O6W.js";
+import { c as _n } 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 no = [
+  ["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" }]
+], oo = _n("grid-3x3", no);
+/**
+ * @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 ao = [
+  [
+    "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"
+    }
+  ]
+], ro = _n("table-2", ao), ft = {
+  type: "object",
+  properties: {
+    rowId: { type: "string", description: "Row id, from rowIds." },
+    columnId: {
+      type: ["string", "number"],
+      description: "Column id, from columnIds."
+    }
+  },
+  required: ["rowId", "columnId"]
+}, so = {
+  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: ft,
+      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: ft,
+            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: { ...ft, description: "One corner, inclusive." },
+          to: { ...ft, 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: ft,
+      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.'
+    }
+  }
+}, _t = $n(null);
+function Rn() {
+  return Gn(_t);
+}
+function En(e, t) {
+  const n = new Intl.NumberFormat(
+    e,
+    t === "rate" ? { style: "percent", maximumFractionDigits: 0 } : { maximumFractionDigits: 2 }
+  );
+  return (o) => n.format(o);
+}
+function Tn(e) {
+  const t = new Intl.NumberFormat(e, { maximumFractionDigits: 0 });
+  return (n) => t.format(n);
+}
+const io = "–";
+function lo({
+  t: e,
+  privacyMode: t,
+  privacyScope: n = "rows",
+  valueType: o,
+  formatValue: s,
+  formatCount: a,
+  groups: i
+}) {
+  const u = new Map(i == null ? void 0 : i.map((p) => [p.id, p.label])), d = Xn(), l = t, v = t && n === "all", m = t && n === "all", w = (p) => p.status === "empty" ? e("heatmap.noData") : p.status === "low-sample" ? p.withheld ? e("heatmap.totalWithheld") : e("heatmap.lowSample") : p.label !== void 0 && !t ? p.label : p.value === null ? e("heatmap.noData") : s(p.value), b = (p) => p.count === void 0 ? null : o === "rate" && p.status === "value" && p.value !== null ? e("heatmap.countOf", {
+    part: a(Math.round(p.value * p.count)),
+    total: a(p.count)
+  }) : e("heatmap.records", {
+    count: p.count,
+    formatted: a(p.count)
+  });
+  return {
+    masksRows: l,
+    masksColumns: v,
+    masksGroups: m,
+    rowLabel: (p) => l ? d : p.label,
+    columnLabel: (p) => v ? d : 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) => m ? d : u.get(p) ?? (t ? d : p),
+    cellName: (p, A) => e("heatmap.cellName", { row: p, column: A }),
+    groupRowText: (p, A) => e("heatmap.groupRow", {
+      group: p,
+      method: e(A === "sum" ? "heatmap.totals.sum" : "heatmap.totals.mean")
+    }),
+    tableText: (p) => {
+      const A = p.status === "empty" ? null : b(p), O = w(p);
+      return A === null ? O : e("heatmap.valueWithCount", { value: O, count: A });
+    },
+    methodLabel: (p) => e(p === "sum" ? "heatmap.totals.sum" : "heatmap.totals.mean"),
+    valueText: w,
+    visibleText: (p) => p.status === "empty" ? io : p.status === "low-sample" ? "" : w(p),
+    countText: b,
+    sentence: (p, A, O) => {
+      const D = b(O), y = w(O);
+      return D === null || O.status === "empty" ? e("heatmap.cell", { row: p, column: A, value: y }) : e("heatmap.cellWithCount", {
+        row: p,
+        column: A,
+        value: y,
+        count: D
+      });
+    },
+    formatValue: s
+  };
+}
+const Te = 1e12, co = 5e6, uo = co;
+let Tt = 0;
+const tn = new Error("heatmap audit: work limit"), po = 32, Le = (e) => {
+  if (Tt += e, Tt > uo) throw tn;
+};
+function Wt(e, t) {
+  return {
+    n: e,
+    head: new Int32Array(e).fill(-1),
+    next: new Int32Array(t * 2),
+    to: new Int32Array(t * 2),
+    edges: 0
+  };
+}
+function ht(e, t, n) {
+  const o = e.edges;
+  return e.to[o] = n, e.next[o] = e.head[t], e.head[t] = o, e.to[o + 1] = t, e.next[o + 1] = e.head[n], e.head[n] = o + 1, e.edges += 2, o;
+}
+function nn(e, t, n, o, s, a, i, u, d) {
+  if (n === o) return s;
+  const l = a >= 0 ? a >> 1 : -1;
+  let v = 0, m = 0;
+  for (; v < s - i; ) {
+    u.fill(-2), u[n] = -1;
+    let w = 0, b = 0;
+    d[b++] = n;
+    let p = !1;
+    for (; w < b && !p; ) {
+      const O = d[w++];
+      for (let D = e.head[O]; D !== -1; D = e.next[D]) {
+        if (m += 1, t[D] <= i || D >> 1 === l) continue;
+        const y = e.to[D];
+        if (u[y] === -2) {
+          if (u[y] = D, y === o) {
+            p = !0;
+            break;
+          }
+          d[b++] = y;
+        }
+      }
+    }
+    if (Le(m), m = 0, !p) break;
+    let A = s - v;
+    for (let O = o; O !== n; O = e.to[u[O] ^ 1])
+      A = Math.min(A, t[u[O]]);
+    for (let O = o; O !== n; O = e.to[u[O] ^ 1])
+      t[u[O]] -= A, t[u[O] ^ 1] += A;
+    v += A;
+  }
+  return v;
+}
+function mo(e, t, n, o, s, a) {
+  const i = new Uint8Array(e.n), u = -1;
+  i[n] = 1;
+  let d = 0, l = 0;
+  a[l++] = n;
+  let v = 0;
+  for (; d < l; ) {
+    const m = a[d++];
+    for (let w = e.head[m]; w !== -1; w = e.next[w]) {
+      if (v += 1, t[w] <= s || w >> 1 === u) continue;
+      const b = e.to[w];
+      i[b] || (i[b] = 1, a[l++] = b);
+    }
+  }
+  return Le(v), i;
+}
+const fo = (e, t) => e.integral ? Math.max(1, Math.ceil(t / 2 - 1e-9)) : Math.max(t / 2, 1e-6);
+function ho(e, t) {
+  const n = e.totals.length + e.cells.length + 1, o = new Float64Array(n), s = new Float64Array(n), a = e.mode === "free";
+  e.totals.forEach((u, d) => {
+    t[d] ? (o[d] = u.value, s[d] = u.value) : (o[d] = a ? -Te : 0, s[d] = Te);
+  });
+  const i = e.totals.length;
+  return e.cells.forEach((u, d) => {
+    o[i + d] = a ? -Te : Math.max(u.lo, -Te), s[i + d] = a ? Te : Math.min(u.hi, Te);
+  }), o[n - 1] = a ? -Te : 0, s[n - 1] = Te, { lo: o, hi: s };
+}
+function vt(e, t) {
+  const n = e.totals.length;
+  if (t < n) return [e.totals[t].from, e.totals[t].to];
+  if (t < n + e.cells.length) {
+    const o = e.cells[t - n];
+    return [o.from, o.to];
+  }
+  return [e.sink, e.source];
+}
+function go(e, t, n) {
+  const { lo: o, hi: s } = ho(e, t), a = o.length, i = e.nodeCount;
+  Le(a * 4);
+  const u = Wt(i + 2, a + i), d = new Float64Array((a + i) * 2), l = new Float64Array(i);
+  for (let g = 0; g < a; g += 1) {
+    const [R, L] = vt(e, g), V = ht(u, R, L);
+    d[V] = s[g] - o[g], l[L] += o[g], l[R] -= o[g];
+  }
+  const v = i, m = i + 1;
+  let w = 0;
+  for (let g = 0; g < i; g += 1)
+    l[g] > 0 ? (d[ht(u, v, g)] = l[g], w += l[g]) : l[g] < 0 && (d[ht(u, g, m)] = -l[g]);
+  const b = new Int32Array(i + 2), p = new Int32Array(i + 2);
+  if (nn(
+    u,
+    d,
+    v,
+    m,
+    1 / 0,
+    -1,
+    n,
+    b,
+    p
+  ) < w - n * Math.max(1, a)) return null;
+  const O = new Float64Array(a);
+  for (let g = 0; g < a; g += 1)
+    O[g] = o[g] + (s[g] - o[g] - d[2 * g]);
+  const D = Wt(i, a), y = new Float64Array(a * 2);
+  for (let g = 0; g < a; g += 1) {
+    const [R, L] = vt(e, g), V = ht(D, R, L), J = g < e.totals.length && t[g];
+    y[V] = J ? 0 : Math.max(0, s[g] - O[g]), y[V + 1] = J ? 0 : Math.max(0, O[g] - o[g]);
+  }
+  const E = e.totals.length;
+  return {
+    graph: D,
+    cap: y,
+    flow: O,
+    closing: a - 1,
+    cellArc: (g) => E + g
+  };
+}
+function Ut(e, t, n, o, s, a, i, u) {
+  if (n === o) return !0;
+  u.fill(0);
+  const d = s >> 1;
+  u[n] = 1;
+  let l = 0, v = 0, m = 0;
+  for (i[v++] = n; l < v; ) {
+    const w = i[l++];
+    for (let b = e.head[w]; b !== -1; b = e.next[b]) {
+      if (m += 1, t[b] <= a || b >> 1 === d) continue;
+      const p = e.to[b];
+      if (!u[p]) {
+        if (p === o)
+          return Le(m), !0;
+        u[p] = 1, i[v++] = p;
+      }
+    }
+  }
+  return Le(m), !1;
+}
+function vo(e, t, n, o) {
+  const s = Array.from(
+    { length: n },
+    () => []
+  );
+  return e.totals.forEach((a, i) => {
+    t[i] && (s[a.from].push([a.to, a.records, i]), a.value > o && s[a.to].push([a.from, a.records, i]));
+  }), Le(e.totals.length), s;
+}
+function sn(e, t, n, o, s, a) {
+  const { graph: i, cap: u } = e, d = i.n, l = s >> 1, v = new Float64Array(d).fill(1 / 0), m = new Int32Array(d).fill(-1), w = new Int32Array(d).fill(-1), b = new Uint8Array(d);
+  v[n] = 0;
+  const p = [[0, n]], A = (y) => {
+    p.push(y);
+    let E = p.length - 1;
+    for (; E > 0; ) {
+      const g = E - 1 >> 1;
+      if (p[g][0] < y[0] || p[g][0] === y[0] && p[g][1] <= y[1])
+        break;
+      p[E] = p[g], E = g;
+    }
+    p[E] = y;
+  }, O = () => {
+    const y = p[0], E = p.pop();
+    if (p.length) {
+      let g = 0;
+      for (; ; ) {
+        const R = 2 * g + 1, L = R + 1;
+        let V = g;
+        const J = (Y, T) => p[Y][0] < T[0] || p[Y][0] === T[0] && p[Y][1] < T[1];
+        let F = E;
+        if (R < p.length && J(R, F) && (V = R, F = p[R]), L < p.length && J(L, F) && (V = L, F = p[L]), V === g) break;
+        p[g] = p[V], g = V;
+      }
+      p[g] = E;
+    }
+    return y;
+  };
+  for (; p.length; ) {
+    const [y, E] = O();
+    if (b[E]) continue;
+    b[E] = 1;
+    let g = 2 + t[E].length;
+    for (let R = i.head[E]; R !== -1; R = i.next[R]) g += 1;
+    if (Le(g), E === o) break;
+    for (let R = i.head[E]; R !== -1; R = i.next[R]) {
+      if (u[R] <= a || R >> 1 === l) continue;
+      const L = i.to[R];
+      y < v[L] && (v[L] = y, m[L] = -1, w[L] = E, A([y, L]));
+    }
+    for (const [R, L, V] of t[E])
+      y + L < v[R] && (v[R] = y + L, m[R] = V, w[R] = E, A([y + L, R]));
+  }
+  if (!Number.isFinite(v[o])) return [];
+  const D = [];
+  for (let y = o; y !== n; y = w[y])
+    m[y] >= 0 && D.push(m[y]);
+  return D.sort((y, E) => y - E);
+}
+function wo(e, t, n, o, s, a) {
+  const i = [], { graph: u, cap: d } = n, l = new Int32Array(u.n), v = new Int32Array(u.n), m = new Uint8Array(u.n), w = [], b = n.flow.length, p = new Uint8Array(b), A = e.mode === "rate" && e.integral, O = (g, R, L, V) => L <= o ? 0 : A && L <= 1 + o ? Ut(u, d, g, R, V, o, v, m) ? L : 0 : (Le(d.length >> 2), nn(u, d.slice(), g, R, L, V, o, l, v));
+  let D = null;
+  const y = () => (D = D ?? vo(e, t, u.n, o), D);
+  let E = 0;
+  for (const g of s) {
+    const R = e.cells[g], L = n.cellArc(g), [V, J] = vt(e, L), F = 2 * L;
+    let Y, T, N, K, z;
+    if (e.mode === "rate") {
+      const c = fo(e, R.records);
+      T = Math.min(d[F], c), K = O(J, V, T, F), N = Math.min(d[F + 1], c - K), z = O(V, J, N, F), Y = K + z >= c - o;
+    } else {
+      const c = n.flow[L];
+      N = d[F + 1], z = O(V, J, N, F);
+      const I = Math.max(c - 2 * z, z > o ? 0 : o * 4);
+      T = Math.min(d[F], I), K = I > 0 ? O(J, V, T, F) : 0, Y = I <= 0 || K >= I - o;
+    }
+    if (K + z <= o && (p[L] = 1), Y) continue;
+    if (i.push(g), a) {
+      w.push({ allOf: [] });
+      break;
+    }
+    if (E >= po) continue;
+    E += 1;
+    const $ = /* @__PURE__ */ new Set();
+    if (K < T - o)
+      for (const c of sn(n, y(), J, V, F, o))
+        $.add(c);
+    if (z < N - o)
+      for (const c of sn(n, y(), V, J, F, o))
+        $.add(c);
+    if ($.size === 0)
+      for (const c of e.cellTotals[g]) t[c] && $.add(c);
+    w.push({ allOf: [...$].sort((c, I) => c - I) });
+  }
+  return { disclosures: w, failed: i, pinned: p };
+}
+function bo(e, t, n, o, s) {
+  const { graph: a, cap: i } = n, u = new Int32Array(a.n), d = new Uint8Array(a.n), l = (v) => {
+    const [m, w] = vt(e, v), b = 2 * v;
+    i[b] > s && Ut(a, i, w, m, b, s, u, d) || i[b + 1] > s && Ut(a, i, m, w, b, s, u, d) || (o[v] = 1);
+  };
+  e.totals.forEach((v, m) => {
+    t[m] || l(m);
+  }), l(n.closing);
+}
+function ln(e, t, n, o) {
+  const s = e.nodeCount, a = new Int32Array(s);
+  for (let c = 0; c < s; c += 1) a[c] = c;
+  const i = (c) => {
+    let I = c;
+    for (; a[I] !== I; ) I = a[I];
+    for (; a[c] !== I; ) {
+      const P = a[c];
+      a[c] = I, c = P;
+    }
+    return I;
+  }, u = (c, I) => {
+    const P = i(c), C = i(I);
+    P !== C && (a[Math.max(P, C)] = Math.min(P, C));
+  };
+  e.totals.forEach((c, I) => {
+    !t[I] && !o[I] && u(c.from, c.to);
+  }), o[n.closing] || u(e.sink, e.source);
+  const d = /* @__PURE__ */ new Map();
+  e.cells.forEach((c, I) => {
+    if (o[n.cellArc(I)]) return;
+    const P = i(c.from), C = i(c.to);
+    if (P === C) return;
+    const Q = P * s + C, te = d.get(Q) ?? { from: P, to: C, weight: 0, cells: [] };
+    te.weight += c.records > 0 ? c.records : e.minCount, te.cells.push(I), d.set(Q, te);
+  });
+  const l = [...d.values()].sort(
+    (c, I) => c.from - I.from || c.to - I.to
+  );
+  if (l.length === 0) return [];
+  const v = [...new Set(l.flatMap((c) => [c.from, c.to]))].sort(
+    (c, I) => c - I
+  ), m = new Map(v.map((c, I) => [c, I])), w = v.length, b = Array.from({ length: w }, () => []);
+  l.forEach((c, I) => b[m.get(c.from)].push(I));
+  const p = new Int32Array(w).fill(-1);
+  {
+    const c = new Int32Array(w).fill(-1), I = new Int32Array(w), P = new Uint8Array(w), C = [];
+    let Q = 0, te = 0;
+    for (let x = 0; x < w; x += 1) {
+      if (c[x] !== -1) continue;
+      const _ = [[x, 0]];
+      for (c[x] = I[x] = Q++, C.push(x), P[x] = 1; _.length; ) {
+        const W = _[_.length - 1], [G, q] = W;
+        if (q < b[G].length) {
+          W[1] += 1;
+          const B = m.get(l[b[G][q]].to);
+          c[B] === -1 ? (c[B] = I[B] = Q++, C.push(B), P[B] = 1, _.push([B, 0])) : P[B] && (I[G] = Math.min(I[G], c[B]));
+        } else {
+          if (_.pop(), _.length) {
+            const B = _[_.length - 1][0];
+            I[B] = Math.min(I[B], I[G]);
+          }
+          if (I[G] === c[G]) {
+            let B;
+            do
+              B = C.pop(), P[B] = 0, p[B] = te;
+            while (B !== G);
+            te += 1;
+          }
+        }
+      }
+    }
+  }
+  const A = /* @__PURE__ */ new Map(), O = /* @__PURE__ */ new Map();
+  for (const c of l) {
+    const I = p[m.get(c.from)], P = p[m.get(c.to)];
+    if (I === P) continue;
+    const C = `${I}>${P}`, Q = A.get(C) ?? { a: I, b: P, weight: 0 };
+    Q.weight += c.weight, A.set(C, Q), O.set(C, [...O.get(C) ?? [], ...c.cells]);
+  }
+  if (A.size === 0) return [];
+  const D = [...A.entries()].sort(([c], [I]) => c < I ? -1 : 1), y = [...new Set(D.flatMap(([, c]) => [c.a, c.b]))].sort(
+    (c, I) => c - I
+  ), E = new Map(y.map((c, I) => [c, I])), g = y.length, R = new Int32Array(g);
+  for (let c = 0; c < g; c += 1) R[c] = c;
+  const L = (c) => {
+    for (; R[c] !== c; )
+      R[c] = R[R[c]], c = R[c];
+    return c;
+  };
+  for (const [, c] of D) {
+    const I = L(E.get(c.a)), P = L(E.get(c.b));
+    I !== P && (R[Math.max(I, P)] = Math.min(I, P));
+  }
+  const V = Wt(g, D.length), J = new Float64Array(D.length * 2);
+  for (const [, c] of D) {
+    const I = ht(
+      V,
+      E.get(c.a),
+      E.get(c.b)
+    );
+    J[I] = c.weight, J[I + 1] = Te;
+  }
+  const F = new Int32Array(g), Y = new Int32Array(g), T = /* @__PURE__ */ new Map(), N = (c) => {
+    const I = new Uint8Array(s), P = new Uint8Array(s), C = /* @__PURE__ */ new Map();
+    y.forEach((Q, te) => C.set(Q, c[te]));
+    for (let Q = 0; Q < s; Q += 1) {
+      const te = m.get(i(Q));
+      te !== void 0 && (P[Q] = 1, I[Q] = C.get(p[te]) ?? 0);
+    }
+    return { nodeSide: I, inGraph: P };
+  }, K = (c) => {
+    const I = [];
+    for (const [W, G] of D) {
+      const q = E.get(G.a), B = E.get(G.b);
+      c[q] === 1 && c[B] === 0 && I.push(...O.get(W) ?? []);
+    }
+    I.sort((W, G) => W - G);
+    const P = I.join(",");
+    if (T.has(P)) return;
+    const { nodeSide: C, inGraph: Q } = N(c), te = /* @__PURE__ */ new Set(), x = /* @__PURE__ */ new Set();
+    e.totals.forEach((W, G) => {
+      !t[G] || C[W.from] === C[W.to] || (Q[W.from] && Q[W.to] ? te.add(G) : x.add(G));
+    });
+    const _ = te.size > 0 ? te : x;
+    if (_.size === 0)
+      for (const W of I)
+        for (const G of e.cellTotals[W]) t[G] && _.add(G);
+    T.set(P, { anyOf: [..._].sort((W, G) => W - G) });
+  }, z = e.minCount, $ = /* @__PURE__ */ new Map();
+  for (let c = 0; c < g; c += 1) {
+    const I = L(c);
+    $.has(I) || $.set(I, c);
+  }
+  for (let c = 0; c < g; c += 1) {
+    const I = $.get(L(c));
+    if (I !== c)
+      for (const [P, C] of [
+        [I, c],
+        [c, I]
+      ]) {
+        Le(J.length >> 2);
+        const Q = J.slice();
+        if (nn(V, Q, P, C, z, -1, 1e-9, F, Y) < z - 1e-9) {
+          const x = mo(V, Q, P, -1, 1e-9, Y);
+          K(x);
+        }
+      }
+  }
+  return [...T.values()];
+}
+function yo(e, t) {
+  const n = e.nodeCount, o = e.totals.length + e.cells.length + 1, s = Array.from({ length: n }, () => []);
+  for (let l = 0; l < o; l += 1) {
+    if (l < e.totals.length && t[l]) continue;
+    const [v, m] = vt(e, l);
+    s[v].push([m, l]), s[m].push([v, l]);
+  }
+  const a = new Uint8Array(o), i = new Int32Array(n).fill(-1), u = new Int32Array(n);
+  let d = 0;
+  for (let l = 0; l < n; l += 1) {
+    if (i[l] !== -1) continue;
+    const v = [[l, -1, 0]];
+    for (i[l] = u[l] = d++; v.length; ) {
+      const m = v[v.length - 1], [w, b, p] = m;
+      if (p < s[w].length) {
+        m[2] += 1;
+        const [A, O] = s[w][p];
+        if (O === b) continue;
+        i[A] === -1 ? (i[A] = u[A] = d++, v.push([A, O, 0])) : u[w] = Math.min(u[w], i[A]);
+      } else if (v.pop(), v.length) {
+        const A = v[v.length - 1][0];
+        u[A] = Math.min(u[A], u[w]), u[w] > i[A] && (a[b] = 1);
+      }
+    }
+  }
+  return a;
+}
+function Ln(e, t, n, o, s = !1) {
+  if (e.mode === "free") {
+    const u = yo(e, t), d = [], l = [];
+    for (const m of o)
+      if (u[e.totals.length + m]) {
+        if (s) return { disclosures: [{ allOf: [] }], cells: [m] };
+        l.push(m), d.push({
+          anyOf: e.cellTotals[m].filter((w) => t[w])
+        });
+      }
+    if (d.length) return { disclosures: d, cells: l };
+    const v = {
+      closing: e.totals.length + e.cells.length,
+      cellArc: (m) => e.totals.length + m
+    };
+    return {
+      disclosures: ln(e, t, v, u),
+      cells: []
+    };
+  }
+  const a = go(e, t, n);
+  if (!a) return null;
+  const i = wo(e, t, a, n, o, s);
+  return i.disclosures.length ? { disclosures: i.disclosures, cells: i.failed } : (bo(e, t, a, i.pinned, n), {
+    disclosures: ln(e, t, a, i.pinned),
+    cells: []
+  });
+}
+function xo(e, t) {
+  const n = /* @__PURE__ */ new Set();
+  for (const s of t) for (const a of s.allOf ?? []) n.add(a);
+  let o = t.filter(
+    (s) => s.anyOf && s.anyOf.length > 0 && !s.anyOf.some((a) => n.has(a))
+  );
+  for (; o.length; ) {
+    const s = /* @__PURE__ */ new Map();
+    for (const i of o)
+      for (const u of i.anyOf ?? []) s.set(u, (s.get(u) ?? 0) + 1);
+    let a = -1;
+    for (const [i, u] of s) {
+      const d = s.get(a) ?? -1;
+      (a === -1 || u > d || u === d && (e.totals[i].records < e.totals[a].records || e.totals[i].records === e.totals[a].records && i < a)) && (a = i);
+    }
+    n.add(a), o = o.filter((i) => !(i.anyOf ?? []).includes(a));
+  }
+  return [...n].sort((s, a) => s - a);
+}
+function Io(e, t = 0) {
+  Tt = t;
+  try {
+    return Mo(e);
+  } catch (n) {
+    if (n !== tn) throw n;
+    const o = new Uint8Array(e.totals.length);
+    for (const s of e.cellTotals)
+      for (const a of s) o[a] = 1;
+    return e.totals.map((s, a) => s.shown && !o[a]);
+  }
+}
+function ko() {
+  return Tt;
+}
+function Mo(e) {
+  const t = e.totals.map((m) => m.shown);
+  if (e.cells.length === 0) return t;
+  let n = 1;
+  for (const m of e.totals)
+    m.shown && (n = Math.max(n, Math.abs(m.value)));
+  for (const m of e.cells)
+    Number.isFinite(m.hi) && (n = Math.max(n, Math.abs(m.hi)));
+  const o = 1e-9 * n, s = new Uint8Array(e.totals.length);
+  for (const m of e.cellTotals)
+    for (const w of m) s[w] = 1;
+  const a = () => t.map((m, w) => m && !s[w]), i = e.cells.map((m, w) => w);
+  let u = i;
+  const d = [], l = e.totals.length + 1;
+  for (let m = 0; ; m += 1) {
+    if (m > l) return a();
+    const w = Ln(e, t, o, u);
+    if (w === null) return a();
+    if (w.disclosures.length === 0) break;
+    const b = xo(e, w.disclosures);
+    if (b.length === 0) return a();
+    for (const p of b)
+      t[p] = !1, d.push(p);
+    u = w.cells;
+  }
+  const v = [...d].sort(
+    (m, w) => e.totals[w].records - e.totals[m].records || m - w
+  );
+  for (const m of v)
+    t[m] = !0, So(e, t, m, i, o) || (t[m] = !1);
+  return t;
+}
+function So(e, t, n, o, s) {
+  try {
+    const a = /* @__PURE__ */ new Set();
+    e.cellTotals.forEach((d, l) => {
+      d.includes(n) && a.add(l);
+    });
+    const i = [...a, ...o.filter((d) => !a.has(d))], u = Ln(e, t, s, i, !0);
+    return u !== null && u.disclosures.length === 0;
+  } catch (a) {
+    if (a !== tn) throw a;
+    return !1;
+  }
+}
+const Re = 10, on = Math.floor(Re / 2), ot = Re - 1, et = Re / 2, rt = (e, t, n) => Math.min(n, Math.max(t, e)), cn = /* @__PURE__ */ new Set();
+function Yt(e) {
+  !Zn() || cn.has(e) || (cn.add(e), console.warn(`Heatmap: ${e}`));
+}
+function dn(e) {
+  return e[0] <= e[1] ? e : (Yt(
+    `scale domain [${e[0]}, ${e[1]}] is reversed; using [${e[1]}, ${e[0]}].`
+  ), [e[1], e[0]]);
+}
+function On(e) {
+  const t = e.filter(Number.isFinite).sort((n, o) => n - o);
+  return t.filter((n, o) => o === 0 || n !== t[o - 1]);
+}
+function Ao(e) {
+  let t = 1 / 0, n = -1 / 0;
+  for (const o of e)
+    Number.isFinite(o) && (o < t && (t = o), o > n && (n = o));
+  return t === 1 / 0 ? null : [t, n];
+}
+function No(e, t, n) {
+  if (!(n > t)) return on;
+  const o = rt((e - t) / (n - t), 0, 1);
+  return Math.min(ot, Math.floor(o * Re));
+}
+function _o(e, t, n, o) {
+  if (e < n) {
+    const i = n - t, u = i > 0 ? rt((n - e) / i, 0, 1) : 1;
+    return et - 1 - Math.min(et - 1, Math.floor(u * et));
+  }
+  const s = o - n, a = s > 0 ? rt((e - n) / s, 0, 1) : e > n ? 1 : 0;
+  return et + Math.min(et - 1, Math.floor(a * et));
+}
+function Ro(e, t) {
+  if (e.type !== "diverging" || e.midpoint === void 0) return !1;
+  const n = Math.max(
+    Math.abs(e.midpoint),
+    Math.abs(e.min ?? 0),
+    Math.abs(e.max ?? 0)
+  );
+  return Math.abs(t - e.midpoint) <= n * Number.EPSILON * 16;
+}
+function Eo(e, t) {
+  const n = e.length;
+  if (n === 0) return NaN;
+  if (n === 1) return e[0];
+  const o = rt(t, 0, 1) * (n - 1), s = Math.floor(o), a = Math.min(n - 1, s + 1);
+  return e[s] + (e[a] - e[s]) * (o - s);
+}
+function To(e, t) {
+  const n = Math.max(1, Math.round(t)), o = [];
+  for (let s = 1; s < n; s += 1)
+    o.push(Eo(e, s / n));
+  return o;
+}
+function Lo(e, t) {
+  if (e.length === 0) return [];
+  const n = e[0], o = (s) => {
+    let a = 0, i = e.length - 1;
+    for (; a < i; ) {
+      const u = a + i >>> 1;
+      e[u] < s ? a = u + 1 : i = u;
+    }
+    return e[a];
+  };
+  return On(
+    To(e, t).map(o)
+  ).filter((s) => s > n);
+}
+function un(e, t) {
+  let n = 0, o = t.length;
+  for (; n < o; ) {
+    const s = n + o >>> 1;
+    t[s] <= e ? n = s + 1 : o = s;
+  }
+  return n;
+}
+function Jt(e, t) {
+  return t <= 1 ? on : Math.round(
+    rt(e, 0, t - 1) * ot / (t - 1)
+  );
+}
+function Qt(e, t) {
+  const n = Ao(t);
+  switch (e.type) {
+    case "diverging": {
+      const o = e.domain && e.domain !== "auto" ? dn(e.domain) : null, s = e.midpoint ?? (o && (o[0] > 0 || o[1] < 0) ? (o[0] + o[1]) / 2 : 0);
+      let a, i;
+      if (o)
+        [a, i] = o;
+      else {
+        const u = n ? Math.max(
+          Math.abs(n[0] - s),
+          Math.abs(n[1] - s)
+        ) : 0;
+        a = s - u, i = s + u;
+      }
+      return {
+        type: "diverging",
+        min: a,
+        max: i,
+        midpoint: s,
+        thresholds: [],
+        stepOf: (u) => _o(u, a, s, i)
+      };
+    }
+    case "quantile": {
+      const o = t.filter(Number.isFinite).slice().sort((i, u) => i - u), s = rt(
+        Math.round(e.buckets ?? Re),
+        2,
+        Re
+      ), a = Lo(o, s);
+      return {
+        type: "quantile",
+        min: (n == null ? void 0 : n[0]) ?? null,
+        max: (n == null ? void 0 : n[1]) ?? null,
+        thresholds: a,
+        stepOf: (i) => Jt(un(i, a), a.length + 1)
+      };
+    }
+    case "threshold": {
+      const o = e.thresholds.filter(Number.isFinite), s = On(o);
+      s.length !== o.length && Yt("duplicate thresholds merged."), s.length > ot && Yt(
+        `${s.length} thresholds given; ten steps take at most ${ot}, so the highest ${s.length - ot} are dropped.`
+      );
+      const a = s.slice(0, ot);
+      return {
+        type: "threshold",
+        min: (n == null ? void 0 : n[0]) ?? null,
+        max: (n == null ? void 0 : n[1]) ?? null,
+        thresholds: a,
+        stepOf: (i) => Jt(un(i, a), a.length + 1)
+      };
+    }
+    case "sequential":
+    default: {
+      const o = e.domain && e.domain !== "auto" ? dn(e.domain) : null, s = o ? o[0] : (n == null ? void 0 : n[0]) ?? null, a = o ? o[1] : (n == null ? void 0 : n[1]) ?? null;
+      return {
+        type: "sequential",
+        min: s,
+        max: a,
+        thresholds: [],
+        stepOf: (i) => s === null || a === null ? on : No(i, s, a)
+      };
+    }
+  }
+}
+function Oo(e) {
+  let t = 0, n = !1, o = 0, s = !1;
+  for (const a of e)
+    a.value === null || !Number.isFinite(a.value) || (t += a.value, n = !0, a.count !== void 0 && (o += a.count, s = !0));
+  return { value: n ? t : null, count: s ? o : void 0 };
+}
+function Co(e) {
+  let t = 0, n = 0, o = 0, s = !1;
+  for (const a of e) {
+    if (a.value === null || !Number.isFinite(a.value)) continue;
+    const i = a.count ?? 1;
+    t += a.value * i, n += i, a.count !== void 0 && (o += a.count, s = !0);
+  }
+  return {
+    value: n > 0 ? t / n : null,
+    count: s ? o : void 0
+  };
+}
+function Ho(e, t) {
+  return t === "sum" ? Oo(e) : Co(e);
+}
+function Do(e, t) {
+  const n = new Set(t == null ? void 0 : t.map((i) => i.id)), o = new Set(n), s = /* @__PURE__ */ new Map();
+  let a = 0;
+  for (const i of e) {
+    const u = i.group;
+    if (u === void 0 || s.has(u)) continue;
+    if (n.has(u)) {
+      s.set(u, u);
+      continue;
+    }
+    let d;
+    do
+      a += 1, d = `group-${a}`;
+    while (o.has(d));
+    o.add(d), s.set(u, d);
+  }
+  return s;
+}
+function Cn(e, t) {
+  return t !== void 0 && e !== void 0 && e < t;
+}
+function Hn(e, t) {
+  if (e == null)
+    return { value: null, status: "empty" };
+  const n = typeof e == "number" ? { value: e } : e, o = n.value === null || !Number.isFinite(n.value) ? null : n.value, s = Cn(n.count, t) && (o !== null || (n.count ?? 0) > 0) ? "low-sample" : o === null ? "empty" : "value";
+  return { value: o, count: n.count, label: n.label, status: s };
+}
+function Ko(e, t, n, o, s) {
+  return e.map(
+    (a, i) => t.map(
+      (u, d) => {
+        var l;
+        return Hn(
+          n ? n(a, u, i, d) : (l = o == null ? void 0 : o[i]) == null ? void 0 : l[d],
+          s
+        );
+      }
+    )
+  );
+}
+function zo(e) {
+  const t = [];
+  for (const n of e)
+    for (const o of n)
+      o.status === "value" && o.value !== null && t.push(o.value);
+  return t;
+}
+function Fo(e) {
+  return e.some((t) => t.some((n) => n.status !== "empty"));
+}
+const Bo = {
+  value: null,
+  status: "low-sample",
+  withheld: !0
+}, Vo = {
+  rows: !0,
+  columns: !0,
+  grand: !0,
+  groups: !0,
+  groupColumns: !0
+};
+function Go(e, t, n) {
+  const o = Ho(e, t);
+  return {
+    value: o.value,
+    count: o.count,
+    status: o.value === null ? "empty" : Cn(o.count, n) ? "low-sample" : "value"
+  };
+}
+function $o(e, t, n, o) {
+  const {
+    rowMethod: s,
+    columnMethod: a,
+    groupColumnMethod: i,
+    groups: u,
+    minCount: d,
+    getTotal: l,
+    valueType: v = "number"
+  } = o, m = o.shown ?? Vo, w = t.map((T, N) => N), b = n.map((T, N) => N), p = [], A = (T, N, K, z, $) => {
+    const c = [];
+    for (const x of K)
+      for (const _ of z) c.push(e[x][_]);
+    let I = 0, P = !1, C = !1;
+    for (const x of c)
+      x.status === "low-sample" && (P = !0, I += x.count ?? 0, x.value === null && (C = !0));
+    const Q = T === void 0 ? Go(c, N, d) : Hn(T, d), te = Q.status === "low-sample" || T === void 0 && C || d !== void 0 && I > 0 && I < d;
+    return p.push({
+      method: N,
+      rowIndexes: K,
+      columnIndexes: z,
+      own: Q,
+      primary: te,
+      visible: $,
+      holdsHidden: P
+    }), p.length - 1;
+  }, O = t.map(
+    (T, N) => A(
+      l == null ? void 0 : l({
+        kind: "row",
+        method: s,
+        row: T,
+        rowId: T.id,
+        rowIndex: N
+      }),
+      s,
+      [N],
+      b,
+      m.rows
+    )
+  ), D = /* @__PURE__ */ new Map();
+  t.forEach((T, N) => {
+    if (T.group === void 0) return;
+    const K = D.get(T.group) ?? [];
+    K.push(N), D.set(T.group, K);
+  });
+  const y = new Map(u == null ? void 0 : u.map((T) => [T.id, T])), E = (T, N) => {
+    const K = y.get(T);
+    return {
+      groupId: T,
+      ...K === void 0 ? {} : { group: K },
+      rows: N.map((z) => t[z]),
+      rowIndexes: N
+    };
+  }, g = /* @__PURE__ */ new Map();
+  for (const [T, N] of D) {
+    const K = E(T, N);
+    g.set(
+      T,
+      n.map(
+        (z, $) => A(
+          l == null ? void 0 : l({
+            kind: "group-column",
+            method: i,
+            ...K,
+            column: z,
+            columnId: z.id,
+            columnIndex: $
+          }),
+          i,
+          N,
+          [$],
+          m.groupColumns
+        )
+      )
+    );
+  }
+  const R = n.map(
+    (T, N) => A(
+      l == null ? void 0 : l({
+        kind: "column",
+        method: a,
+        column: T,
+        columnId: T.id,
+        columnIndex: N
+      }),
+      a,
+      w,
+      [N],
+      m.columns
+    )
+  ), L = /* @__PURE__ */ new Map();
+  for (const [T, N] of D)
+    L.set(
+      T,
+      A(
+        l == null ? void 0 : l({
+          kind: "group",
+          method: s,
+          ...E(T, N)
+        }),
+        s,
+        N,
+        b,
+        m.groups
+      )
+    );
+  const V = A(
+    l == null ? void 0 : l({ kind: "grand", method: s }),
+    s,
+    w,
+    b,
+    m.grand
+  ), J = p.map((T) => T.primary);
+  Po({
+    matrix: e,
+    rows: t,
+    drafts: p,
+    rowDrafts: O,
+    columnDrafts: R,
+    groupDrafts: L,
+    groupColumnDrafts: g,
+    grandDraft: V,
+    members: D,
+    valueType: v,
+    minCount: d
+  }).forEach((T, N) => {
+    T || (J[N] = !0);
+  });
+  const Y = (T) => J[T] ? Bo : p[T].own;
+  return {
+    rows: O.map(Y),
+    columns: R.map(Y),
+    grand: Y(V),
+    groupColumns: new Map(
+      [...g].map(([T, N]) => [
+        T,
+        N.map(Y)
+      ])
+    ),
+    groups: new Map(
+      [...L].map(([T, N]) => [T, Y(N)])
+    )
+  };
+}
+function Po(e) {
+  const { matrix: t, rows: n, drafts: o, members: s, valueType: a, minCount: i } = e, u = o.map(() => !0);
+  if (i === void 0) return u;
+  const d = o.map(
+    (x) => x.visible && !x.primary && x.own.value !== null
+  ), l = new Set(
+    o.filter((x, _) => d[_] && x.holdsHidden).map((x) => x.method)
+  );
+  if (l.size === 0) return u;
+  const v = () => o.map((x, _) => !(d[_] && x.holdsHidden));
+  if (l.size > 1) return v();
+  const m = [...l][0];
+  if (a === "rate" && m === "sum") return v();
+  const w = (x) => m === "mean" ? x.count ?? 1 : 1, b = a === "rate";
+  if (!b && m === "mean") return v();
+  const p = (x) => x.status === "low-sample" && (m === "sum" || (x.count ?? 0) > 0), A = 0, O = 1, D = 2;
+  let y = 3;
+  const E = /* @__PURE__ */ new Map();
+  for (const x of s.keys()) E.set(x, y++);
+  const g = n.map(() => y++), R = /* @__PURE__ */ new Map(), L = e.columnDrafts.length;
+  for (const x of s.keys())
+    R.set(
+      x,
+      Array.from({ length: L }, () => y++)
+    );
+  const V = e.columnDrafts.map(() => y++), J = (x) => n[x].group, F = o.map(() => [0, 0]);
+  e.rowDrafts.forEach((x, _) => {
+    const W = J(_);
+    F[x] = [
+      W === void 0 ? D : E.get(W),
+      g[_]
+    ];
+  });
+  for (const [x, _] of e.groupDrafts)
+    F[_] = [D, E.get(x)];
+  for (const [x, _] of e.groupColumnDrafts)
+    _.forEach((W, G) => {
+      F[W] = [R.get(x)[G], V[G]];
+    });
+  e.columnDrafts.forEach((x, _) => {
+    F[x] = [V[_], O];
+  }), F[e.grandDraft] = [A, D];
+  const Y = [], T = [];
+  let N = !0, K = !0;
+  if (t.forEach((x, _) => {
+    x.forEach((W, G) => {
+      if (W.value !== null && W.value < 0 && (K = !1), !p(W)) return;
+      Number.isInteger(W.count ?? 0) || (N = !1);
+      const q = J(_);
+      Y.push({
+        from: g[_],
+        to: q === void 0 ? V[G] : R.get(q)[G],
+        lo: 0,
+        hi: a === "rate" ? W.count ?? 0 : 1 / 0,
+        records: W.count ?? 0
+      });
+      const B = [
+        e.rowDrafts[_],
+        e.columnDrafts[G],
+        e.grandDraft
+      ];
+      q !== void 0 && B.push(
+        e.groupDrafts.get(q),
+        e.groupColumnDrafts.get(q)[G]
+      ), T.push(B.sort((re, ne) => re - ne));
+    });
+  }), Y.length === 0) return u;
+  const z = (x) => Math.abs(x - Math.round(x)) <= 1e-9 * Math.max(1, Math.abs(x));
+  let $ = !0, c = !1;
+  const I = (x, _) => x.count === void 0 ? _ : Math.round(_), P = o.map((x, _) => {
+    let W = 0, G = 0, q = 0, B = 0, re = 0;
+    for (const Ne of x.rowIndexes)
+      for (const be of x.columnIndexes) {
+        const Z = t[Ne][be];
+        if (Z.status !== "empty") {
+          if (G += w(Z), W += Z.count ?? 1, p(Z)) re += 1;
+          else if (Z.value !== null) {
+            const pe = w(Z) * Z.value;
+            z(pe) || ($ = !1), q += pe, B += I(Z, pe);
+          }
+        }
+      }
+    let ne = 0, Me = 0;
+    if (d[_] && re > 0) {
+      const Ne = x.own.value;
+      ne = m === "mean" ? Ne * G : Ne, z(ne) || ($ = !1), m === "mean" && x.own.count !== void 0 && Math.abs(x.own.count - G) > 1e-9 * Math.max(1, G) && (c = !0), Me = x.own.count === void 0 ? ne : Math.round(ne);
+    }
+    return { records: W, exact: q, rounded: B, unknowns: re, whole: ne, wholeRounded: Me };
+  });
+  if (c) return v();
+  o.forEach((x, _) => {
+    d[_] && x.own.value < 0 && (K = !1);
+  });
+  const C = a === "rate" ? "rate" : K ? "scaled" : "free", Q = (x, _, W) => {
+    const G = o.map((q, B) => {
+      const re = P[B];
+      let ne = 0;
+      if (_[B] && re.unknowns > 0) {
+        ne = x ? re.wholeRounded - re.rounded : re.whole - re.exact;
+        const Me = 1e-9 * Math.max(1, Math.abs(re.whole), Math.abs(re.exact));
+        ne < 0 && ne > -Me && (ne = 0);
+      }
+      return {
+        from: F[B][0],
+        to: F[B][1],
+        value: ne,
+        shown: _[B],
+        records: re.records
+      };
+    });
+    return Io(
+      {
+        nodeCount: y,
+        sink: O,
+        source: A,
+        cells: Y,
+        totals: G,
+        cellTotals: T,
+        mode: C,
+        integral: b && N && (x || $),
+        minCount: i
+      },
+      W
+    );
+  };
+  let te;
+  if (!b || $)
+    te = Q(b, d, 0);
+  else {
+    const x = Q(!0, d, 0);
+    te = Q(
+      !1,
+      d.map((_, W) => _ && x[W]),
+      ko()
+    );
+  }
+  return o.map((x, _) => !d[_] || te[_]);
+}
+const Vt = (e) => `d:${e}`, jo = (e) => `g:${e}`, At = "f";
+function qo(e, t, n, o, s) {
+  const a = [...e];
+  if (o === "label")
+    return a.sort((i, u) => s.compare(t[i].label, t[u].label));
+  if (o === "total-asc" || o === "total-desc") {
+    const i = o === "total-asc" ? 1 : -1;
+    return a.sort((u, d) => {
+      var m, w;
+      const l = (m = n[u]) == null ? void 0 : m.value, v = (w = n[d]) == null ? void 0 : w.value;
+      return l == null ? v == null ? 0 : 1 : v == null ? -1 : (l - v) * i;
+    });
+  }
+  return a;
+}
+function pn(e, t, n, o) {
+  var d;
+  if (!n)
+    return t.map((l) => ({
+      kind: "data",
+      key: Vt(e[l].id),
+      rowIndex: l,
+      groupId: e[l].group
+    }));
+  const s = [], a = /* @__PURE__ */ new Map(), i = [];
+  e.forEach((l) => {
+    l.group !== void 0 && !a.has(l.group) && (a.set(l.group, []), s.push(l.group));
+  });
+  for (const l of t) {
+    const v = e[l].group;
+    v === void 0 ? i.push(l) : (d = a.get(v)) == null || d.push(l);
+  }
+  const u = [];
+  for (const l of s) {
+    const v = a.get(l) ?? [], m = o.has(l);
+    if (u.push({
+      kind: "group",
+      key: jo(l),
+      groupId: l,
+      collapsed: m,
+      rowIndexes: v
+    }), !m)
+      for (const w of v)
+        u.push({
+          kind: "data",
+          key: Vt(e[w].id),
+          rowIndex: w,
+          groupId: l
+        });
+  }
+  for (const l of i)
+    u.push({ kind: "data", key: Vt(e[l].id), rowIndex: l });
+  return u;
+}
+function Dn({
+  cell: e,
+  label: t,
+  open: n,
+  onOpenChange: o,
+  side: s = "top",
+  children: a
+}) {
+  const i = Rn(), u = t ?? (i == null ? void 0 : i.tooltipText(e)) ?? "";
+  return /* @__PURE__ */ H(
+    Nn,
+    {
+      label: u,
+      open: n,
+      onOpenChange: o,
+      side: s,
+      delayDuration: 0,
+      children: a
+    }
+  );
+}
+Dn.displayName = "HeatmapTooltip";
+function mn({
+  label: e,
+  onOpenChange: t
+}) {
+  return /* @__PURE__ */ H(Nn, { label: e, open: !0, onOpenChange: t, delayDuration: 0, children: /* @__PURE__ */ H(
+    "span",
+    {
+      "aria-hidden": "true",
+      "data-component": "heatmap-tooltip",
+      className: "ds:pointer-events-none ds:absolute ds:inset-0"
+    }
+  ) });
+}
+const Wo = 1e3, Uo = 3;
+function fn({ offset: e, viewport: t, lead: n, pitch: o, count: s }, a = Uo) {
+  if (s <= 0) return [0, 0];
+  if (!(o > 0)) return [0, s];
+  const i = Math.abs(e) - n, u = Math.floor(i / o) - a, d = Math.ceil((i + t) / o) + a, l = Math.max(0, Math.min(s - 1, u)), v = Math.max(l + 1, Math.min(s, d));
+  return [l, v];
+}
+function hn(e, t, n) {
+  const [o, s] = e, a = [];
+  for (let i = o; i < s; i += 1) a.push(i);
+  return n === null || n < 0 || n >= t ? {
+    indexes: a,
+    lead: o,
+    middle: 0,
+    middleAfter: 0,
+    tail: Math.max(0, t - s)
+  } : n < o ? {
+    indexes: [n, ...a],
+    lead: n,
+    middle: o - n - 1,
+    middleAfter: 1,
+    tail: Math.max(0, t - s)
+  } : n >= s ? {
+    indexes: [...a, n],
+    lead: o,
+    middle: n - s,
+    middleAfter: a.length,
+    tail: t - n - 1
+  } : {
+    indexes: a,
+    lead: o,
+    middle: 0,
+    middleAfter: 0,
+    tail: Math.max(0, t - s)
+  };
+}
+function Nt(e) {
+  return {
+    indexes: Array.from({ length: e }, (t, n) => n),
+    lead: 0,
+    middle: 0,
+    middleAfter: 0,
+    tail: 0
+  };
+}
+function gn(e, t) {
+  if (e.indexes.every((o) => o < t)) return e;
+  const n = e.indexes.filter((o) => o < t);
+  return {
+    indexes: n,
+    lead: Math.min(e.lead, t),
+    middle: 0,
+    middleAfter: 0,
+    tail: Math.max(0, t - (n.length + Math.min(e.lead, t)))
+  };
+}
+function vn(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((n, o) => n === t.indexes[o]);
+}
+const Xt = (e, t) => `${e}-${Math.min(9, Math.max(0, Math.round(t)))}`, Kn = {
+  "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"
+}, wn = ge(
+  "ds:flex ds:min-w-0 ds:max-w-full ds:flex-col ds:gap-[var(--spacing-sm)] ds:text-[color:var(--foreground)]"
+), Yo = ge(
+  "ds:flex ds:flex-wrap ds:items-center ds:justify-between ds:gap-[var(--spacing-sm)]"
+), Jo = ge(
+  [
+    "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(" ")
+), Qo = ge(
+  // 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 }
+  }
+), Xo = ge(
+  [
+    "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
+    }
+  }
+), Lt = ge(
+  "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" }
+  }
+), at = ge("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)]"
+    }
+  }
+}), zn = "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)]", Gt = ge(
+  [
+    "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]",
+    zn
+  ].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 }
+  }
+), Zt = ge(
+  [
+    "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]",
+    zn
+  ].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 }
+  }
+), bn = ge("ds:min-w-0", {
+  variants: {
+    virtualised: {
+      true: "ds:overflow-hidden ds:text-ellipsis",
+      false: ""
+    }
+  },
+  defaultVariants: { virtualised: !1 }
+}), Rt = ge(
+  [
+    "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: Kn,
+      interactive: {
+        true: "ds:cursor-pointer",
+        false: "ds:cursor-default"
+      }
+    },
+    defaultVariants: { tone: "empty", interactive: !1 }
+  }
+), Zo = ge(
+  "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)]"
+), ea = ge(
+  "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" }
+  }
+), tt = ge(
+  "ds:inline-block ds:forced-colors:[forced-color-adjust:none]",
+  {
+    variants: {
+      tone: Kn,
+      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" }
+  }
+), Fn = "", Ot = (e, t) => `${e}${Fn}${String(t)}`, Et = (e) => {
+  const t = e.indexOf(Fn);
+  return [e.slice(0, t), e.slice(t + 1)];
+};
+function ta(e, t, n) {
+  return e.status === "low-sample" ? "low-sample" : e.status === "empty" || e.value === null ? "empty" : Ro(t, e.value) ? "midpoint" : Xt(n, t.stepOf(e.value));
+}
+const na = { value: null, status: "empty" }, en = (e) => e.status === "value" ? "aggregate" : e.status;
+function Ct(e, t) {
+  const n = [];
+  return e.lead > 0 && n.push(
+    /* @__PURE__ */ H(
+      "div",
+      {
+        "aria-hidden": "true",
+        className: at({ axis: "col-lead" })
+      },
+      "lead"
+    )
+  ), e.indexes.forEach((o, s) => {
+    e.middle > 0 && s === e.middleAfter && n.push(
+      /* @__PURE__ */ H(
+        "div",
+        {
+          "aria-hidden": "true",
+          className: at({ axis: "col-middle" })
+        },
+        "middle"
+      )
+    ), n.push(t(o));
+  }), e.tail > 0 && n.push(
+    /* @__PURE__ */ H(
+      "div",
+      {
+        "aria-hidden": "true",
+        className: at({ axis: "col-tail" })
+      },
+      "tail"
+    )
+  ), n;
+}
+const oa = jn(function({
+  ctx: t,
+  row: n,
+  ariaRowIndex: o,
+  highlighted: s,
+  activeCol: a,
+  tooltipCol: i,
+  selectedCols: u
+}) {
+  var O, D;
+  const d = t.columns.length, l = X(
+    () => new Set(u === "" ? [] : u.split(",").map(Number)),
+    [u]
+  );
+  if (n.kind === "group") {
+    const y = t.describer.groupLabel(n.groupId), E = t.groupIds.get(n.groupId), g = `${t.idBase}-label-${o}`, R = ((O = t.totals) == null ? void 0 : O.groupColumns.get(n.groupId)) ?? [], L = (D = t.totals) == null ? void 0 : D.groups.get(n.groupId), V = (F, Y, T, N) => {
+      const K = F ?? na, z = T(K);
+      return /* @__PURE__ */ le(
+        "div",
+        {
+          role: "gridcell",
+          "aria-colindex": Y + 2,
+          "aria-expanded": !n.collapsed,
+          "aria-label": z,
+          tabIndex: a === Y ? 0 : -1,
+          "data-heatmap-group-id": E,
+          className: Rt({
+            tone: en(K),
+            interactive: !0
+          }),
+          children: [
+            t.describer.visibleText(K),
+            N && i === Y ? /* @__PURE__ */ H(
+              mn,
+              {
+                label: z,
+                onOpenChange: t.onTooltipOpenChange
+              }
+            ) : null
+          ]
+        },
+        Y
+      );
+    }, J = t.describer.groupRowText(
+      y,
+      t.groupColumnMethod
+    );
+    return /* @__PURE__ */ le(
+      "div",
+      {
+        role: "row",
+        "aria-rowindex": o,
+        "data-heatmap-body-row": "",
+        "data-heatmap-group-id": E,
+        className: Lt({ position: "body" }),
+        children: [
+          /* @__PURE__ */ le(
+            "div",
+            {
+              role: "rowheader",
+              "aria-colindex": 1,
+              "aria-labelledby": g,
+              "data-highlighted": s,
+              className: Zt({
+                kind: "group",
+                virtualised: t.virtualised
+              }),
+              children: [
+                /* @__PURE__ */ H(
+                  "button",
+                  {
+                    type: "button",
+                    tabIndex: -1,
+                    "aria-expanded": !n.collapsed,
+                    "aria-label": n.collapsed ? t.expandLabel(y) : t.collapseLabel(y),
+                    onMouseDown: (F) => F.preventDefault(),
+                    onClick: () => t.onToggleGroup(n.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__ */ H(
+                      eo,
+                      {
+                        "aria-hidden": "true",
+                        className: [
+                          "ds:size-4 ds:transition-transform ds:duration-[var(--animation-duration)] ds:motion-reduce:transition-none",
+                          n.collapsed ? "ds:-rotate-90 ds:rtl:rotate-90" : ""
+                        ].join(" ")
+                      }
+                    )
+                  }
+                ),
+                /* @__PURE__ */ H(
+                  "span",
+                  {
+                    id: g,
+                    className: bn({
+                      virtualised: t.virtualised
+                    }),
+                    children: y
+                  }
+                )
+              ]
+            }
+          ),
+          Ct(
+            t.colWindow,
+            (F) => V(
+              R[F],
+              F,
+              (Y) => t.describer.sentence(
+                J,
+                t.describer.columnLabel(t.columns[F]),
+                Y
+              ),
+              !0
+            )
+          ),
+          t.rowTotals ? V(
+            L,
+            d,
+            (F) => t.describer.sentence(
+              y,
+              t.describer.methodLabel(t.rowTotals || "mean"),
+              F
+            ),
+            !1
+          ) : null
+        ]
+      }
+    );
+  }
+  const v = n.rowIndex, m = t.rows[v], w = t.describer.rowLabel(m), b = t.matrix[v], p = (y) => {
+    const E = b[y], g = t.columns[y], R = l.has(y);
+    return /* @__PURE__ */ le(
+      "div",
+      {
+        role: "gridcell",
+        "aria-colindex": y + 2,
+        "aria-label": t.describer.sentence(
+          w,
+          t.describer.columnLabel(g),
+          E
+        ),
+        "aria-describedby": a === y ? t.describedBy : void 0,
+        "aria-selected": t.selectable ? R : void 0,
+        tabIndex: a === y ? 0 : -1,
+        "data-heatmap-cell-id": `${m.id}:${String(g.id)}`,
+        "data-status": E.status,
+        className: Rt({
+          tone: ta(E, t.scale, t.palette),
+          interactive: t.interactive
+        }),
+        children: [
+          t.showValues || E.status === "empty" ? t.describer.visibleText(E) : null,
+          i === y ? /* @__PURE__ */ H(
+            mn,
+            {
+              label: t.tooltipText(t.cellInfo(v, y)),
+              onOpenChange: t.onTooltipOpenChange
+            }
+          ) : null
+        ]
+      },
+      y
+    );
+  };
+  let A = null;
+  if (t.rowTotals && t.totals) {
+    const y = t.totals.rows[v];
+    A = /* @__PURE__ */ H(
+      "div",
+      {
+        role: "gridcell",
+        "aria-colindex": d + 2,
+        "aria-label": t.describer.sentence(
+          w,
+          t.describer.methodLabel(t.rowTotals),
+          y
+        ),
+        tabIndex: a === d ? 0 : -1,
+        className: Rt({ tone: en(y) }),
+        children: t.describer.visibleText(y)
+      }
+    );
+  }
+  return /* @__PURE__ */ le(
+    "div",
+    {
+      role: "row",
+      "aria-rowindex": o,
+      "data-heatmap-body-row": "",
+      "data-heatmap-row-id": m.id,
+      className: Lt({ position: "body" }),
+      children: [
+        /* @__PURE__ */ H(
+          "div",
+          {
+            role: "rowheader",
+            "aria-colindex": 1,
+            "data-highlighted": s,
+            className: Zt({
+              kind: "data",
+              virtualised: t.virtualised
+            }),
+            children: /* @__PURE__ */ H(
+              "span",
+              {
+                className: bn({ virtualised: t.virtualised }),
+                children: w
+              }
+            )
+          }
+        ),
+        Ct(t.colWindow, p),
+        A
+      ]
+    }
+  );
+}), $t = {
+  headerBlock: 48,
+  footerBlock: 0,
+  rowPitch: 46,
+  leadInline: 120,
+  colPitch: 46,
+  viewportBlock: 600,
+  viewportInline: 900
+}, yn = (e) => Math.max(
+  1,
+  Math.floor(
+    (e.viewportBlock - e.headerBlock - e.footerBlock) / Math.max(1, e.rowPitch)
+  )
+);
+function aa(e) {
+  const {
+    title: t,
+    rowsLabel: n,
+    rows: o,
+    columns: s,
+    matrix: a,
+    body: i,
+    scale: u,
+    palette: d,
+    describer: l,
+    showValues: v,
+    totals: m,
+    rowTotals: w,
+    columnTotals: b,
+    groupColumnMethod: p,
+    groupIds: A,
+    selectionMode: O,
+    selected: D,
+    columnIndexOfKey: y,
+    interactive: E,
+    virtualised: g,
+    size: R,
+    density: L,
+    cellInfo: V,
+    tooltipText: J,
+    describeFocused: F,
+    onActivate: Y,
+    onRange: T,
+    onToggleGroup: N
+  } = e, { t: K } = Ht("ui"), z = Pn(), $ = ie(null), c = ie(null), I = ie(null), P = ie(null), C = s.length, Q = C + (w ? 1 : 0), te = !!(b && m), x = X(
+    () => [
+      ...i.map((f) => f.key),
+      ...te ? [At] : []
+    ],
+    [i, te]
+  ), _ = X(() => {
+    const f = /* @__PURE__ */ new Map();
+    return x.forEach((r, h) => f.set(r, h)), f;
+  }, [x]), [W, G] = we(() => ({
+    rowKey: x[0] ?? At,
+    col: 0
+  })), q = (() => {
+    const f = _.get(W.rowKey);
+    if (f !== void 0) return f;
+    const r = o.find((M) => `d:${M.id}` === W.rowKey);
+    return ((r == null ? void 0 : r.group) === void 0 ? void 0 : _.get(`g:${r.group}`)) ?? 0;
+  })(), B = Math.min(
+    Math.max(0, W.col),
+    Math.max(0, Q - 1)
+  ), re = x[q], ne = ie(!1), [Me, Ne] = we(!1), be = ie(!1), Z = ie("pointer"), [pe, je] = we(null), qe = ie(null), [wt, Oe] = we(!1), We = ae((f) => {
+    const r = qe.current;
+    r === f || r && f && r.rowKey === f.rowKey && r.col === f.col || (qe.current = f, je(f), Oe(!1));
+  }, []), me = pe ?? (Me && re ? { rowKey: re, col: B } : null), Ce = wt ? null : pe ?? (Me && Z.current === "keyboard" && re ? { rowKey: re, col: B } : null), [fe, Dt] = we($t), ve = ie(fe);
+  ve.current = fe;
+  const st = ae(() => {
+    var ce, Ae;
+    const f = $.current, r = c.current;
+    if (!f || !r) return;
+    const h = window.getComputedStyle(r), M = parseFloat(h.rowGap) || 0, S = parseFloat(h.columnGap) || 0, k = h.gridTemplateColumns.split(" ").map((Ze) => parseFloat(Ze)).filter((Ze) => Number.isFinite(Ze)), U = ((ce = I.current) == null ? void 0 : ce.getBoundingClientRect().height) ?? 0, j = r.querySelector(
+      "[data-heatmap-body-row]"
+    ), oe = (j == null ? void 0 : j.getBoundingClientRect().height) ?? 0, se = {
+      headerBlock: U + M,
+      footerBlock: ((Ae = P.current) == null ? void 0 : Ae.getBoundingClientRect().height) ?? 0,
+      rowPitch: (oe || U || $t.rowPitch) + M,
+      leadInline: (k[0] ?? 0) + S,
+      colPitch: (k[1] ?? $t.colPitch) + S,
+      viewportBlock: f.clientHeight,
+      viewportInline: f.clientWidth
+    }, ue = ve.current;
+    Object.keys(se).some(
+      (Ze) => Math.abs(se[Ze] - ue[Ze]) > 0.5
+    ) && Dt(se);
+  }, []);
+  nt(() => {
+    st();
+    const f = $.current;
+    if (!f || typeof ResizeObserver > "u") return;
+    const r = new ResizeObserver(() => st());
+    return r.observe(f), c.current && r.observe(c.current), () => r.disconnect();
+  }, [st, i.length, C, R, L]);
+  const it = re === At ? null : q, bt = B < C ? B : null, lt = ae(() => {
+    if (!g)
+      return { rows: Nt(i.length), cols: Nt(C) };
+    const f = $.current, r = ve.current, h = fn({
+      offset: (f == null ? void 0 : f.scrollTop) ?? 0,
+      viewport: r.viewportBlock,
+      lead: r.headerBlock,
+      pitch: r.rowPitch,
+      count: i.length
+    }), M = fn({
+      offset: (f == null ? void 0 : f.scrollLeft) ?? 0,
+      viewport: r.viewportInline,
+      lead: r.leadInline,
+      pitch: r.colPitch,
+      count: C
+    });
+    return {
+      rows: hn(h, i.length, it),
+      cols: hn(M, C, bt)
+    };
+  }, [g, i.length, C, it, bt]), [De, Kt] = we(lt), _e = X(() => Nt(i.length), [i.length]), yt = X(() => Nt(C), [C]), ye = X(
+    () => g ? {
+      rows: gn(De.rows, i.length),
+      cols: gn(De.cols, C)
+    } : { rows: _e, cols: yt },
+    [g, De, i.length, C, _e, yt]
+  ), Ue = ae(() => {
+    const f = lt();
+    Kt(
+      (r) => vn(r.rows, f.rows) && vn(r.cols, f.cols) ? r : f
+    );
+  }, [lt]);
+  nt(() => {
+    Ue();
+  }, [Ue, fe]);
+  const Ke = ie(0), xt = ae(() => {
+    !g || Ke.current || (Ke.current = window.requestAnimationFrame(() => {
+      Ke.current = 0, Ue();
+    }));
+  }, [g, Ue]);
+  gt(() => () => window.cancelAnimationFrame(Ke.current), []), nt(() => {
+    re !== void 0 && re !== W.rowKey && G({ rowKey: re, col: B });
+  }), nt(() => {
+    if (!be.current || ne.current) return;
+    const f = document.activeElement;
+    f && f !== document.body && f.isConnected || (ne.current = !0);
+  });
+  const xe = ae(
+    (f, r) => {
+      var h;
+      return ((h = c.current) == null ? void 0 : h.querySelector(
+        `[role="row"][aria-rowindex="${f + 2}"] > [aria-colindex="${r + 2}"]`
+      )) ?? null;
+    },
+    []
+  );
+  nt(() => {
+    var r;
+    if (!ne.current) return;
+    const f = xe(q, B);
+    f && (ne.current = !1, f.focus({ preventScroll: !0 }), (r = f.scrollIntoView) == null || r.call(f, { block: "nearest", inline: "nearest" }));
+  });
+  const Ye = () => c.current ? window.getComputedStyle(c.current).direction === "rtl" : !1, de = ie(null), ze = (f) => {
+    const r = i[f];
+    return r && r.kind === "data" ? r.rowIndex : null;
+  }, Ie = ie(!1), Se = (f, r) => {
+    const h = Math.max(0, Math.min(x.length - 1, f)), M = Math.max(0, Math.min(Q - 1, r));
+    return ne.current = !0, Oe(!1), G({ rowKey: x[h], col: M }), { row: h, col: M };
+  }, ct = (f, r, h) => {
+    const M = i[f];
+    if (M) {
+      if (M.kind === "group") {
+        N(M.groupId);
+        return;
+      }
+      if (!(r >= C)) {
+        if (O === "range" && h && de.current) {
+          T(de.current, { rowIndex: M.rowIndex, col: r });
+          return;
+        }
+        de.current = { rowIndex: M.rowIndex, col: r }, Y(M.rowIndex, r, !0);
+      }
+    }
+  }, Fe = (f) => {
+    if (f.target instanceof Element && f.target.closest("button"))
+      return;
+    Z.current = "keyboard";
+    const r = x.length - 1, h = Q - 1, M = Ye() ? -1 : 1;
+    let S = q, k = B;
+    const U = f.ctrlKey || f.metaKey;
+    switch (f.key) {
+      case "ArrowRight":
+        k += M;
+        break;
+      case "ArrowLeft":
+        k -= M;
+        break;
+      case "ArrowDown":
+        S += 1;
+        break;
+      case "ArrowUp":
+        S -= 1;
+        break;
+      case "Home":
+        k = 0, U && (S = 0);
+        break;
+      case "End":
+        k = h, U && (S = r);
+        break;
+      case "PageDown": {
+        const se = i.findIndex(
+          (ce, Ae) => Ae > q && ce.kind === "group"
+        );
+        S = i.some((ce) => ce.kind === "group") ? se === -1 ? r : se : q + yn(ve.current);
+        break;
+      }
+      case "PageUp": {
+        let se = -1;
+        for (let ce = Math.min(q, i.length) - 1; ce >= 0; ce -= 1)
+          if (i[ce].kind === "group") {
+            se = ce;
+            break;
+          }
+        S = i.some((ce) => ce.kind === "group") ? se === -1 ? 0 : se : q - yn(ve.current);
+        break;
+      }
+      case "Enter":
+      case " ":
+        f.preventDefault(), ct(q, B, f.shiftKey);
+        return;
+      case "Escape":
+        Ce && (f.preventDefault(), Oe(!0));
+        return;
+      default:
+        return;
+    }
+    f.preventDefault();
+    const j = Se(S, k), oe = f.key.startsWith("Arrow");
+    if (O === "range" && f.shiftKey && oe) {
+      const se = ze(j.row), ue = de.current ?? (() => {
+        const ce = ze(q);
+        return ce === null || B >= C ? null : { rowIndex: ce, col: B };
+      })();
+      ue && se !== null && j.col < C && (de.current = ue, T(ue, { rowIndex: se, col: j.col }));
+    }
+  }, Je = (f) => {
+    var k;
+    if (!(f instanceof Element)) return null;
+    const r = f.closest('[role="gridcell"]'), h = r == null ? void 0 : r.parentElement;
+    if (!r || !h || !((k = c.current) != null && k.contains(r))) return null;
+    const M = Number(h.getAttribute("aria-rowindex")) - 2, S = Number(r.getAttribute("aria-colindex")) - 2;
+    return !Number.isInteger(M) || M < 0 || S < 0 ? null : { row: M, col: S };
+  }, Be = ie(!1), Ve = ie("mouse"), It = (f) => {
+    if (Z.current = "pointer", Ve.current = f.pointerType, O !== "range" || f.pointerType !== "mouse" || f.button !== 0)
+      return;
+    const r = Je(f.target);
+    if (Ie.current = !1, !r) return;
+    const h = ze(r.row);
+    if (h === null || r.col >= C) return;
+    if (f.shiftKey && de.current)
+      T(de.current, { rowIndex: h, col: r.col });
+    else {
+      de.current = { rowIndex: h, col: r.col };
+      const S = Ot(o[h].id, s[r.col].id);
+      D.size === 1 && D.has(S) ? Ie.current = !0 : T(de.current, de.current);
+    }
+    Be.current = !0;
+    const M = () => {
+      Be.current = !1, window.removeEventListener("pointerup", M), window.removeEventListener("pointercancel", M);
+    };
+    window.addEventListener("pointerup", M), window.addEventListener("pointercancel", M);
+  }, zt = (f) => {
+    if (f.pointerType !== "mouse") return;
+    const r = Je(f.target);
+    if (We(
+      r ? { rowKey: x[r.row], col: r.col } : null
+    ), Be.current && r && de.current) {
+      const h = ze(r.row);
+      h !== null && r.col < C && ((h !== de.current.rowIndex || r.col !== de.current.col) && (Ie.current = !1), Ie.current || T(de.current, { rowIndex: h, col: r.col }));
+    }
+  }, he = ie(null), Ge = ae(() => {
+    he.current && (document.removeEventListener("pointerover", he.current), he.current = null);
+  }, []);
+  gt(() => Ge, [Ge]);
+  const kt = (f) => {
+    Ge();
+    const r = f.relatedTarget;
+    if (r instanceof Element && r.closest('[data-component="tooltip"]')) {
+      const h = (M) => {
+        var k;
+        const S = M.target;
+        S instanceof Element && S.closest('[data-component="tooltip"]') || (Ge(), S instanceof Node && ((k = c.current) != null && k.contains(S)) || We(null));
+      };
+      he.current = h, document.addEventListener("pointerover", h);
+      return;
+    }
+    We(null);
+  }, He = (f) => {
+    var M;
+    const r = f.target instanceof Element ? f.target.closest("button") : null;
+    if (r) {
+      const S = Number((M = r.closest('[role="row"]')) == null ? void 0 : M.getAttribute("aria-rowindex")) - 2;
+      Number.isInteger(S) && S >= 0 && Se(S, B);
+      return;
+    }
+    const h = Je(f.target);
+    if (h) {
+      if (Se(h.row, h.col), ne.current = !1, O === "range" && Ve.current === "mouse") {
+        const S = i[h.row];
+        (S == null ? void 0 : S.kind) === "group" ? ct(h.row, h.col, !1) : (S == null ? void 0 : S.kind) === "data" && h.col < C && Y(S.rowIndex, h.col, Ie.current), Ie.current = !1;
+        return;
+      }
+      ct(h.row, h.col, f.shiftKey);
+    }
+  }, $e = ie(!1);
+  gt(() => {
+    let f = 0;
+    const r = () => {
+      $e.current = !0, window.cancelAnimationFrame(f), f = window.requestAnimationFrame(() => {
+        $e.current = !1;
+      });
+    };
+    return window.addEventListener("scroll", r, { capture: !0 }), () => {
+      window.removeEventListener("scroll", r, { capture: !0 }), window.cancelAnimationFrame(f);
+    };
+  }, []);
+  const Pe = ae((f) => {
+    f || $e.current && qe.current === null || Oe(!0);
+  }, []), Qe = ae(
+    (f) => K("heatmap.expandGroup", { group: f }),
+    [K]
+  ), Mt = ae(
+    (f) => K("heatmap.collapseGroup", { group: f }),
+    [K]
+  ), dt = `${z}-description`, Xe = i[q], ut = F && (Xe == null ? void 0 : Xe.kind) === "data" && B < C ? J(V(Xe.rowIndex, B)) : null, ee = X(
+    () => ({
+      rows: o,
+      columns: s,
+      matrix: a,
+      scale: u,
+      palette: d,
+      describer: l,
+      showValues: v,
+      totals: m,
+      rowTotals: w,
+      groupColumnMethod: p,
+      groupIds: A,
+      selectable: O !== "none",
+      interactive: E,
+      virtualised: g,
+      colWindow: ye.cols,
+      idBase: z,
+      describedBy: F ? dt : void 0,
+      cellInfo: V,
+      tooltipText: J,
+      onTooltipOpenChange: Pe,
+      onToggleGroup: N,
+      expandLabel: Qe,
+      collapseLabel: Mt
+    }),
+    [
+      o,
+      s,
+      a,
+      u,
+      d,
+      l,
+      v,
+      m,
+      w,
+      p,
+      A,
+      O,
+      E,
+      g,
+      ye.cols,
+      z,
+      F,
+      dt,
+      V,
+      J,
+      Pe,
+      N,
+      Qe,
+      Mt
+    ]
+  ), Ft = X(() => {
+    const f = /* @__PURE__ */ new Map();
+    for (const h of D) {
+      const [M, S] = Et(h), k = y(S);
+      if (k === void 0) continue;
+      const U = f.get(M) ?? [];
+      U.push(k), f.set(M, U);
+    }
+    const r = /* @__PURE__ */ new Map();
+    for (const [h, M] of f)
+      r.set(h, M.sort((S, k) => S - k).join(","));
+    return r;
+  }, [D, y]), pt = (me == null ? void 0 : me.col) ?? -1, St = /* @__PURE__ */ le(
+    "div",
+    {
+      ref: I,
+      role: "row",
+      "aria-rowindex": 1,
+      className: Lt({ position: "header" }),
+      children: [
+        /* @__PURE__ */ H(
+          "div",
+          {
+            role: "columnheader",
+            "aria-colindex": 1,
+            className: Gt({ corner: !0 }),
+            children: n ?? /* @__PURE__ */ H("span", { className: "ds:sr-only", children: K("heatmap.rowsHeader") })
+          }
+        ),
+        Ct(ye.cols, (f) => /* @__PURE__ */ H(
+          "div",
+          {
+            role: "columnheader",
+            "aria-colindex": f + 2,
+            "data-highlighted": pt === f,
+            className: Gt(),
+            children: l.columnLabel(s[f])
+          },
+          f
+        )),
+        w ? /* @__PURE__ */ H(
+          "div",
+          {
+            role: "columnheader",
+            "aria-colindex": C + 2,
+            "data-highlighted": pt === C,
+            className: Gt(),
+            children: l.methodLabel(w)
+          }
+        ) : null
+      ]
+    }
+  );
+  let mt = null;
+  if (b && m) {
+    const f = i.length, r = l.methodLabel(b), h = q === f, M = (S, k, U, j = r) => /* @__PURE__ */ H(
+      "div",
+      {
+        role: "gridcell",
+        "aria-colindex": k + 2,
+        "aria-label": l.sentence(j, U, S),
+        tabIndex: h && B === k ? 0 : -1,
+        className: Rt({ tone: en(S) }),
+        children: l.visibleText(S)
+      },
+      k
+    );
+    mt = /* @__PURE__ */ le(
+      "div",
+      {
+        ref: P,
+        role: "row",
+        "aria-rowindex": f + 2,
+        className: Lt({ position: "footer" }),
+        children: [
+          /* @__PURE__ */ H(
+            "div",
+            {
+              role: "rowheader",
+              "aria-colindex": 1,
+              "data-highlighted": (me == null ? void 0 : me.rowKey) === At,
+              className: Zt({ kind: "total", virtualised: g }),
+              children: r
+            }
+          ),
+          Ct(
+            ye.cols,
+            (S) => M(m.columns[S], S, l.columnLabel(s[S]))
+          ),
+          w ? M(
+            m.grand,
+            C,
+            l.methodLabel(w),
+            // The corner aggregates every cell by the row method, so it
+            // is named for all cells, not for the footer's own method.
+            K("heatmap.allCells")
+          ) : null
+        ]
+      }
+    );
+  }
+  const Ee = [], ke = ye.rows;
+  ke.lead > 0 && Ee.push(
+    /* @__PURE__ */ H(
+      "div",
+      {
+        "aria-hidden": "true",
+        className: at({ axis: "row-lead" })
+      },
+      "row-lead"
+    )
+  ), ke.indexes.forEach((f, r) => {
+    ke.middle > 0 && r === ke.middleAfter && Ee.push(
+      /* @__PURE__ */ H(
+        "div",
+        {
+          "aria-hidden": "true",
+          className: at({ axis: "row-middle" })
+        },
+        "row-middle"
+      )
+    );
+    const h = i[f];
+    if (!h) return;
+    const M = f === q;
+    Ee.push(
+      /* @__PURE__ */ H(
+        oa,
+        {
+          ctx: ee,
+          row: h,
+          ariaRowIndex: f + 2,
+          highlighted: (me == null ? void 0 : me.rowKey) === h.key,
+          activeCol: M ? B : -1,
+          tooltipCol: (Ce == null ? void 0 : Ce.rowKey) === h.key ? Ce.col : -1,
+          selectedCols: h.kind === "data" ? Ft.get(o[h.rowIndex].id) ?? "" : ""
+        },
+        h.key
+      )
+    );
+  }), ke.tail > 0 && Ee.push(
+    /* @__PURE__ */ H(
+      "div",
+      {
+        "aria-hidden": "true",
+        className: at({ axis: "row-tail" })
+      },
+      "row-tail"
+    )
+  );
+  const Bt = {
+    "--heatmap-columns": String(Math.max(1, C)),
+    "--heatmap-row-lead": String(ke.lead),
+    "--heatmap-row-middle": String(ke.middle),
+    "--heatmap-row-tail": String(ke.tail),
+    "--heatmap-col-lead": String(ye.cols.lead),
+    "--heatmap-col-middle": String(ye.cols.middle),
+    "--heatmap-col-tail": String(ye.cols.tail),
+    "--heatmap-sticky-block-start": `${fe.headerBlock}px`,
+    "--heatmap-sticky-block-end": `${fe.footerBlock}px`,
+    "--heatmap-sticky-inline-start": `${fe.leadInline}px`
+  };
+  return /* @__PURE__ */ le(
+    "div",
+    {
+      ref: $,
+      onScroll: xt,
+      style: Bt,
+      "data-component": "heatmap-grid",
+      className: Jo(),
+      children: [
+        /* @__PURE__ */ le(
+          "div",
+          {
+            ref: c,
+            role: "grid",
+            tabIndex: -1,
+            "aria-label": t,
+            "aria-rowcount": x.length + 1,
+            "aria-colcount": Q + 1,
+            "aria-multiselectable": O === "multiple" || O === "range" ? !0 : void 0,
+            "data-heatmap-grid": "",
+            className: Xo({
+              size: R,
+              density: L,
+              virtualised: g,
+              totalsColumn: !!w
+            }),
+            onKeyDown: Fe,
+            onPointerDown: It,
+            onPointerMove: zt,
+            onPointerLeave: kt,
+            onClick: He,
+            onFocus: (f) => {
+              f.target.matches(":focus-visible") && (Z.current = "keyboard"), be.current = !0, Ne(!0);
+            },
+            onBlur: (f) => {
+              f.currentTarget.contains(f.relatedTarget) || (be.current = !1, Ne(!1));
+            },
+            children: [
+              St,
+              Ee,
+              mt
+            ]
+          }
+        ),
+        ut !== null ? /* @__PURE__ */ H("span", { id: dt, hidden: !0, children: ut }) : null
+      ]
+    }
+  );
+}
+const Pt = Array.from({ length: Re }, (e, t) => t);
+function ra(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 an = Mn(
+  ({
+    variant: e = "stepped",
+    palette: t,
+    scale: n,
+    values: o,
+    valueFormatter: s,
+    showEmpty: a,
+    showLowSample: i,
+    showWithheldTotal: u,
+    minCount: d,
+    className: l
+  }, v) => {
+    const { t: m, i18n: w } = Ht("ui"), b = Rn(), p = An(w.resolvedLanguage ?? w.language), A = X(
+      () => n ? Qt(n, o ?? []) : (b == null ? void 0 : b.scale) ?? Qt({ type: "sequential" }, o ?? []),
+      [n, o, b == null ? void 0 : b.scale]
+    ), O = t ?? (b == null ? void 0 : b.palette) ?? (A.type === "diverging" ? "diverging" : "primary"), D = s ?? (b == null ? void 0 : b.describer.formatValue) ?? En(p, "number"), y = (A.type === "quantile" || A.type === "threshold") && A.thresholds.length > 0, E = A.thresholds.length + 1, g = y ? Array.from(
+      { length: E },
+      ($, c) => Jt(c, E)
+    ) : [], R = A.thresholds.map(D), L = ra(A, D), V = y ? m("heatmap.legend.descriptionBands", {
+      count: E,
+      formatted: Tn(p)(E),
+      edges: new Intl.ListFormat(p, {
+        type: "conjunction"
+      }).format(R)
+    }) : L.middle !== void 0 ? m("heatmap.legend.descriptionDiverging", {
+      min: L.start,
+      max: L.end,
+      midpoint: L.middle
+    }) : m("heatmap.legend.description", {
+      min: L.start,
+      max: L.end
+    }), J = (A.type === "quantile" || A.type === "threshold") && !y ? [A.min === null ? Re / 2 : A.stepOf(A.min)] : null, F = a ?? (b == null ? void 0 : b.hasEmpty) ?? !1, Y = i ?? (b == null ? void 0 : b.hasLowSample) ?? !1, T = u ?? (b == null ? void 0 : b.hasWithheldTotal) ?? !1, N = d ?? (b == null ? void 0 : b.minCount), K = e === "continuous" ? "continuous" : "stepped", z = ($) => /* @__PURE__ */ H("span", { className: ea({ variant: e }), children: $.map((c) => /* @__PURE__ */ H(
+      "span",
+      {
+        className: tt({
+          tone: Xt(O, c),
+          shape: K
+        })
+      },
+      c
+    )) });
+    return /* @__PURE__ */ le(
+      "div",
+      {
+        ref: v,
+        role: "group",
+        "aria-label": m("heatmap.legend.label"),
+        "data-component": "heatmap-legend",
+        className: Zo({ className: l }),
+        children: [
+          /* @__PURE__ */ H("span", { className: "ds:sr-only", children: V }),
+          y ? /* @__PURE__ */ H(
+            "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: g.map(($, c) => /* @__PURE__ */ le(
+                "span",
+                {
+                  className: "ds:inline-flex ds:items-center ds:gap-[var(--spacing-xs)]",
+                  children: [
+                    /* @__PURE__ */ H(
+                      "span",
+                      {
+                        "data-step": $,
+                        className: tt({
+                          tone: Xt(O, $),
+                          shape: "key"
+                        })
+                      }
+                    ),
+                    c < R.length ? /* @__PURE__ */ H("span", { className: "ds:shrink-0", children: R[c] }) : null
+                  ]
+                },
+                $
+              ))
+            }
+          ) : /* @__PURE__ */ le(
+            "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__ */ H("span", { className: "ds:shrink-0", children: L.start }),
+                L.middle !== void 0 ? /* @__PURE__ */ le(Vn, { children: [
+                  z(Pt.slice(0, Re / 2)),
+                  /* @__PURE__ */ H(
+                    "span",
+                    {
+                      "data-legend": "midpoint",
+                      className: tt({
+                        tone: "midpoint",
+                        shape: "label"
+                      }),
+                      children: L.middle
+                    }
+                  ),
+                  z(Pt.slice(Re / 2))
+                ] }) : z(J ?? Pt),
+                /* @__PURE__ */ H("span", { className: "ds:shrink-0", children: L.end })
+              ]
+            }
+          ),
+          F ? /* @__PURE__ */ le("span", { className: "ds:inline-flex ds:items-center ds:gap-[var(--spacing-xs)]", children: [
+            /* @__PURE__ */ H(
+              "span",
+              {
+                "aria-hidden": "true",
+                className: tt({ tone: "empty" })
+              }
+            ),
+            m("heatmap.legend.noData")
+          ] }) : null,
+          Y ? /* @__PURE__ */ le("span", { className: "ds:inline-flex ds:items-center ds:gap-[var(--spacing-xs)]", children: [
+            /* @__PURE__ */ H(
+              "span",
+              {
+                "aria-hidden": "true",
+                className: tt({ tone: "low-sample" })
+              }
+            ),
+            N === void 0 ? m("heatmap.legend.lowSample") : m("heatmap.legend.lowSampleUnder", {
+              value: new Intl.NumberFormat(p).format(N)
+            })
+          ] }) : null,
+          T ? /* @__PURE__ */ le("span", { className: "ds:inline-flex ds:items-center ds:gap-[var(--spacing-xs)]", children: [
+            /* @__PURE__ */ H(
+              "span",
+              {
+                "aria-hidden": "true",
+                className: tt({ tone: "low-sample" })
+              }
+            ),
+            m("heatmap.legend.totalWithheld")
+          ] }) : null
+        ]
+      }
+    );
+  }
+);
+an.displayName = "HeatmapLegend";
+const rn = () => import("./data-table-COoCQ4n_.js").then((e) => e.h).then((e) => ({
+  default: e.DataTable
+})), sa = Sn(rn);
+function xn() {
+  rn().catch(() => {
+  });
+}
+const In = { value: null, status: "empty" };
+function ia({
+  title: e,
+  rowsLabel: t,
+  rows: n,
+  columns: o,
+  matrix: s,
+  body: a,
+  grouped: i,
+  groupIds: u,
+  describer: d,
+  totals: l,
+  rowTotals: v,
+  columnTotals: m,
+  groupColumnMethod: w,
+  onLoadError: b
+}) {
+  const { t: p } = Ht("ui"), A = X(
+    () => [
+      ...i ? [
+        {
+          colId: "group",
+          field: "group",
+          headerName: p("heatmap.table.group"),
+          // A sort here would pull rows out of their groups.
+          sortable: !1
+        }
+      ] : [],
+      {
+        colId: "row",
+        field: "row",
+        headerName: t ?? p("heatmap.rowsHeader"),
+        sortable: !i
+      },
+      ...o.map(
+        (N, K) => ({
+          colId: `c${K}`,
+          headerName: d.columnLabel(N),
+          valueGetter: (z) => {
+            var $;
+            return (($ = z.data) == null ? void 0 : $.cells[K]) ?? "";
+          },
+          sortable: !1
+        })
+      ),
+      ...v ? [
+        {
+          colId: "total",
+          field: "total",
+          headerName: d.methodLabel(v),
+          sortable: !1
+        }
+      ] : []
+    ],
+    [i, t, o, d, v, p]
+  ), O = X(
+    () => a.map((N) => {
+      if (N.kind === "group") {
+        const $ = d.groupLabel(N.groupId), c = (l == null ? void 0 : l.groupColumns.get(N.groupId)) ?? [];
+        return {
+          id: `group:${u.get(N.groupId) ?? ""}`,
+          group: $,
+          row: d.groupRowText($, w),
+          cells: o.map(
+            (I, P) => d.tableText(c[P] ?? In)
+          ),
+          total: v && l ? d.tableText(
+            l.groups.get(N.groupId) ?? In
+          ) : void 0
+        };
+      }
+      const K = N.rowIndex, z = n[K].group;
+      return {
+        id: `row:${n[K].id}`,
+        group: i && z !== void 0 ? d.groupLabel(z) : void 0,
+        row: d.rowLabel(n[K]),
+        cells: s[K].map(($) => d.tableText($)),
+        total: v && l ? d.tableText(l.rows[K]) : void 0
+      };
+    }),
+    [
+      a,
+      n,
+      o,
+      s,
+      i,
+      u,
+      d,
+      v,
+      l,
+      w
+    ]
+  ), D = X(
+    () => m && l ? [
+      {
+        id: "heatmap-column-totals",
+        row: d.methodLabel(m),
+        cells: l.columns.map((N) => d.tableText(N)),
+        // The grand total, by the row method, as the grid's corner.
+        total: v ? d.tableText(l.grand) : void 0
+      }
+    ] : void 0,
+    [m, v, l, d]
+  ), y = O.length + ((D == null ? void 0 : D.length) ?? 0), E = ie(y);
+  E.current = y;
+  const [g, R] = we(null), L = g === y, V = ie(null);
+  nt(() => {
+    const N = V.current;
+    if (L || !N || typeof ResizeObserver > "u") return;
+    const K = new ResizeObserver(() => {
+      N.scrollHeight > N.clientHeight + 1 && R(E.current);
+    }), z = () => {
+      K.observe(N);
+      for (const c of Array.from(N.children)) K.observe(c);
+    };
+    z();
+    const $ = new MutationObserver(z);
+    return $.observe(N, { childList: !0 }), () => {
+      K.disconnect(), $.disconnect();
+    };
+  }, [L]);
+  const J = X(
+    () => ({
+      getRowId: (N) => N.data.id,
+      domLayout: L ? "normal" : "autoHeight"
+    }),
+    [L]
+  ), [F, Y] = we(0), T = X(
+    () => F === 0 ? sa : Sn(rn),
+    [F]
+  );
+  return /* @__PURE__ */ H(
+    "div",
+    {
+      ref: V,
+      role: "group",
+      "aria-label": e,
+      tabIndex: -1,
+      "data-component": "heatmap-table",
+      "data-layout": L ? "capped" : "fit",
+      className: Qo({ capped: L }),
+      children: /* @__PURE__ */ H(
+        to,
+        {
+          size: "sm",
+          onError: () => b == null ? void 0 : b(),
+          onRetry: () => {
+            var N;
+            Y((K) => K + 1), (N = V.current) == null || N.focus();
+          },
+          children: /* @__PURE__ */ H(
+            qn,
+            {
+              fallback: /* @__PURE__ */ H("div", { role: "status", "aria-label": p("heatmap.loadingTable"), children: /* @__PURE__ */ H(
+                qt,
+                {
+                  variant: "rectangular",
+                  className: "ds:h-[calc(var(--min-target-size)*4)] ds:w-full"
+                }
+              ) }),
+              children: /* @__PURE__ */ H(
+                T,
+                {
+                  columnDefs: A,
+                  rowData: O,
+                  pinnedBottomRowData: D,
+                  density: "compact",
+                  heightClass: L ? "ds:min-h-0 ds:flex-1" : "",
+                  gridOptions: J
+                }
+              )
+            }
+          )
+        }
+      )
+    }
+  );
+}
+const la = { type: "sequential", domain: "auto" }, jt = (e) => new Set((e ?? []).map((t) => Ot(t.rowId, t.columnId))), kn = { text: "", privacyMode: !1, repeat: 0 }, Bn = Mn(
+  ({
+    title: e,
+    rows: t,
+    columns: n,
+    getCell: o,
+    cells: s,
+    groups: a,
+    scale: i = la,
+    palette: u,
+    valueType: d = "number",
+    minCount: l,
+    getTotal: v,
+    valueFormatter: m,
+    showValues: w = !1,
+    legend: b = "stepped",
+    rowTotals: p = !1,
+    columnTotals: A = !1,
+    sortRows: O,
+    defaultSortRows: D = "none",
+    onSortRowsChange: y,
+    groupRows: E = !1,
+    defaultCollapsedGroups: g,
+    selection: R = "none",
+    selectedCells: L,
+    defaultSelectedCells: V,
+    onSelectionChange: J,
+    onCellClick: F,
+    renderTooltip: Y,
+    density: T = "default",
+    size: N = "md",
+    loading: K = !1,
+    privacyMode: z = !1,
+    privacyScope: $ = "rows",
+    rowsLabel: c,
+    defaultView: I = "heatmap",
+    onViewChange: P,
+    id: C,
+    className: Q,
+    children: te
+  }, x) => {
+    const { t: _, i18n: W } = Ht("ui"), G = An(W.resolvedLanguage ?? W.language), q = X(
+      () => Ko(t, n, o, s, l),
+      [t, n, o, s, l]
+    ), B = X(() => zo(q), [q]), re = JSON.stringify(i), ne = X(
+      () => Qt(i, B),
+      // eslint-disable-next-line react-hooks/exhaustive-deps -- keyed by content
+      [re, B]
+    ), Me = u ?? (ne.type === "diverging" ? "diverging" : "primary"), Ne = X(
+      () => m ?? En(G, d),
+      [m, G, d]
+    ), be = X(() => Tn(G), [G]), Z = X(
+      () => lo({
+        t: _,
+        privacyMode: z,
+        privacyScope: $,
+        valueType: d,
+        formatValue: Ne,
+        formatCount: be,
+        groups: a
+      }),
+      [
+        _,
+        z,
+        $,
+        d,
+        Ne,
+        be,
+        a
+      ]
+    ), pe = X(
+      () => Do(t, a),
+      [t, a]
+    ), je = A || p || "mean", qe = p || A || "mean", wt = A || p || "mean", [Oe, We] = we(kn), me = ie(0), Ce = ie(z);
+    Ce.current = z;
+    const fe = ae((r, h = !1) => {
+      window.clearTimeout(me.current);
+      const M = Ce.current, S = () => We((k) => ({
+        text: r,
+        privacyMode: M,
+        repeat: k.text === r ? k.repeat + 1 : 0
+      }));
+      h ? me.current = window.setTimeout(S, 300) : S();
+    }, []);
+    gt(() => () => window.clearTimeout(me.current), []), gt(() => {
+      window.clearTimeout(me.current), We((r) => r.text === "" ? r : kn);
+    }, [z]);
+    const Dt = Oe.privacyMode === z ? (
+      // 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.
+      `${Oe.text}${Oe.repeat % 2 === 1 ? " " : ""}`
+    ) : "", [ve, st] = we(I), it = ae(
+      (r) => {
+        st(r), P == null || P(r), fe(
+          _(r === "table" ? "heatmap.announce.tableView" : "heatmap.announce.heatmapView")
+        );
+      },
+      [P, fe, _]
+    ), [bt, lt] = we(D), De = O ?? bt, Kt = ae(
+      (r) => {
+        O === void 0 && lt(r), y == null || y(r);
+      },
+      [O, y]
+    ), [_e, yt] = we(
+      () => new Set(g ?? [])
+    ), ye = ae(
+      (r, h) => {
+        if (_e.has(r) === h) return;
+        yt((S) => {
+          if (S.has(r) === h) return S;
+          const k = new Set(S);
+          return h ? k.add(r) : k.delete(r), k;
+        });
+        const M = Z.groupLabel(r);
+        fe(
+          h ? _("heatmap.announce.groupCollapsed", { group: M }) : _("heatmap.announce.groupExpanded", { group: M })
+        );
+      },
+      [_e, fe, Z, _]
+    ), Ue = ae(
+      (r) => ye(r, !_e.has(r)),
+      [_e, ye]
+    ), Ke = X(
+      () => new Intl.Collator(G, { numeric: !0, sensitivity: "base" }),
+      [G]
+    ), xt = De === "label" && Z.masksRows ? "none" : De, xe = X(
+      () => $o(q, t, n, {
+        rowMethod: qe,
+        columnMethod: wt,
+        groupColumnMethod: je,
+        groups: a,
+        minCount: l,
+        getTotal: v,
+        valueType: d
+      }),
+      [
+        q,
+        t,
+        n,
+        qe,
+        wt,
+        je,
+        a,
+        l,
+        v,
+        d
+      ]
+    ), Ye = X(
+      () => qo(
+        t.map((r, h) => h),
+        t,
+        xe.rows,
+        xt,
+        Ke
+      ),
+      [t, xe.rows, xt, Ke]
+    ), de = X(
+      () => pn(t, Ye, E, _e),
+      [t, Ye, E, _e]
+    ), ze = X(
+      () => pn(t, Ye, E, /* @__PURE__ */ new Set()),
+      [t, Ye, E]
+    ), Ie = X(
+      () => new Map(t.map((r, h) => [r.id, h])),
+      [t]
+    ), Se = X(
+      () => new Map(n.map((r, h) => [String(r.id), h])),
+      [n]
+    ), ct = ae(
+      (r) => Se.get(r),
+      [Se]
+    ), Fe = ae(
+      (r, h) => {
+        const M = t[r], S = n[h], k = q[r][h];
+        return {
+          rowId: M.id,
+          columnId: S.id,
+          row: M,
+          column: S,
+          rowIndex: r,
+          columnIndex: h,
+          value: k.value,
+          count: k.count,
+          label: k.label,
+          status: k.status,
+          step: k.status === "value" && k.value !== null ? ne.stepOf(k.value) : null
+        };
+      },
+      [t, n, q, ne]
+    ), Je = ae(
+      (r) => {
+        const h = r.row.group === void 0 ? void 0 : pe.get(r.row.group);
+        return {
+          rowId: r.rowId,
+          columnId: r.columnId,
+          row: {
+            id: r.row.id,
+            label: Z.rowLabel(r.row),
+            ...h === void 0 ? {} : { group: h }
+          },
+          column: {
+            id: r.column.id,
+            label: Z.columnLabel(r.column)
+          },
+          rowIndex: r.rowIndex,
+          columnIndex: r.columnIndex,
+          value: r.value,
+          count: r.count,
+          status: r.status,
+          step: r.step
+        };
+      },
+      [Z, pe]
+    ), Be = ae(
+      (r) => Y ? Y(z ? Je(r) : r, {
+        privacyMode: z
+      }) : Z.sentence(
+        Z.rowLabel(r.row),
+        Z.columnLabel(r.column),
+        q[r.rowIndex][r.columnIndex]
+      ),
+      [Y, z, Je, Z, q]
+    ), Ve = L !== void 0, [It, zt] = we(
+      () => jt(V)
+    ), he = X(() => {
+      const r = Ve ? jt(L) : It, h = /* @__PURE__ */ new Set();
+      for (const M of r) {
+        const [S, k] = Et(M);
+        Ie.has(S) && Se.has(k) && h.add(M);
+      }
+      return h;
+    }, [
+      Ve,
+      L,
+      It,
+      Ie,
+      Se
+    ]), Ge = ae(
+      (r) => {
+        const h = [];
+        for (const M of r) {
+          const [S, k] = Et(M), U = Ie.get(S), j = Se.get(k);
+          U !== void 0 && j !== void 0 && h.push(Fe(U, j));
+        }
+        return h;
+      },
+      [Ie, Se, Fe]
+    ), kt = ae(
+      (r, h) => Z.cellName(
+        Z.rowLabel(t[r]),
+        Z.columnLabel(n[h])
+      ),
+      [Z, t, n]
+    ), He = ae(
+      (r, h, M = !1) => {
+        Ve || zt(r), J == null || J(Ge(r)), fe(h, M);
+      },
+      [Ve, J, Ge, fe]
+    ), $e = ae(
+      (r) => r === 0 ? _("heatmap.announce.cleared") : _("heatmap.announce.count", {
+        count: r,
+        formatted: be(r)
+      }),
+      [_, be]
+    ), Pe = X(
+      () => de.flatMap((r) => r.kind === "data" ? [r.rowIndex] : []),
+      [de]
+    ), Qe = ae(
+      (r, h) => {
+        const M = Pe.indexOf(r.rowIndex), S = Pe.indexOf(h.rowIndex), k = /* @__PURE__ */ new Set();
+        if (M === -1 || S === -1) return k;
+        const [U, j] = M <= S ? [M, S] : [S, M], [oe, se] = r.col <= h.col ? [r.col, h.col] : [h.col, r.col];
+        for (let ue = U; ue <= j; ue += 1) {
+          const ce = t[Pe[ue]].id;
+          for (let Ae = oe; Ae <= se; Ae += 1)
+            k.add(Ot(ce, n[Ae].id));
+        }
+        return k;
+      },
+      [Pe, t, n]
+    ), Mt = ae(
+      (r, h, M) => {
+        if (F == null || F(Fe(r, h)), !M || R === "none") return;
+        const S = Ot(t[r].id, n[h].id), k = kt(r, h);
+        if (R === "multiple") {
+          const j = new Set(he), oe = !j.has(S);
+          oe ? j.add(S) : j.delete(S), He(
+            j,
+            _(oe ? "heatmap.announce.added" : "heatmap.announce.removed", {
+              cell: k,
+              count: j.size,
+              formatted: be(j.size)
+            })
+          );
+          return;
+        }
+        const U = he.size === 1 && he.has(S);
+        He(
+          U ? /* @__PURE__ */ new Set() : /* @__PURE__ */ new Set([S]),
+          U ? _("heatmap.announce.cleared") : _("heatmap.announce.selected", { cell: k })
+        );
+      },
+      [
+        F,
+        Fe,
+        R,
+        t,
+        n,
+        kt,
+        he,
+        He,
+        be,
+        _
+      ]
+    ), dt = ae(
+      (r, h) => {
+        if (R !== "range" && R !== "multiple") return;
+        const M = Qe(r, h);
+        M.size === he.size && [...M].every((S) => he.has(S)) || He(M, $e(M.size), !0);
+      },
+      [R, Qe, he, He, $e]
+    ), Xe = X(
+      () => new Map([...pe].map(([r, h]) => [h, r])),
+      [pe]
+    ), ut = {
+      selected: he,
+      selection: R,
+      view: ve,
+      sortRows: De,
+      collapsed: _e,
+      groupRows: E,
+      rows: t,
+      columns: n,
+      expandedBody: ze,
+      groupIds: pe,
+      groupByPublicId: Xe,
+      rowIndexById: Ie,
+      columnIndexById: Se,
+      matrix: q,
+      scale: ne,
+      setView: it,
+      setSortRows: Kt,
+      setGroupCollapsed: ye,
+      commitSelection: He,
+      rectangle: Qe,
+      countMessage: $e
+    }, ee = ie(ut);
+    ee.current = ut;
+    const Ft = X(() => {
+      const r = (k) => {
+        const { columns: U, columnIndexById: j } = ee.current, oe = [];
+        for (const se of k) {
+          const [ue, ce] = Et(se), Ae = j.get(ce);
+          Ae !== void 0 && oe.push({ rowId: ue, columnId: U[Ae].id });
+        }
+        return oe;
+      }, h = (k) => {
+        const { rowIndexById: U, columnIndexById: j } = ee.current, oe = U.get(k.rowId), se = j.get(String(k.columnId));
+        return oe === void 0 || se === void 0 ? null : { rowIndex: oe, col: se };
+      }, M = (k) => {
+        const U = h(k);
+        if (!U)
+          throw new Error(
+            `Heatmap: no cell at row "${k.rowId}", column "${String(k.columnId)}".`
+          );
+        return U;
+      }, S = () => {
+        if (ee.current.selection === "none")
+          throw new Error('Heatmap: selection is off (selection="none").');
+      };
+      return {
+        getSelection: () => r(ee.current.selected),
+        getSelectionMode: () => ee.current.selection,
+        selectCells: (k) => {
+          S(), k.forEach(M);
+          const { selection: U } = ee.current, j = U === "single" ? k.slice(0, 1) : k, oe = jt(j);
+          ee.current.commitSelection(
+            oe,
+            ee.current.countMessage(oe.size)
+          );
+        },
+        selectRange: (k, U) => {
+          const { selection: j } = ee.current;
+          if (j !== "range" && j !== "multiple")
+            throw new Error(
+              'Heatmap: select_range needs selection="range" or "multiple".'
+            );
+          const oe = M(k), se = M(U), ue = ee.current.rectangle(oe, se);
+          ee.current.commitSelection(
+            ue,
+            ee.current.countMessage(ue.size)
+          );
+        },
+        clearSelection: () => {
+          S(), ee.current.selected.size !== 0 && ee.current.commitSelection(
+            /* @__PURE__ */ new Set(),
+            ee.current.countMessage(0)
+          );
+        },
+        readCell: (k) => {
+          const U = h(k);
+          if (!U) return null;
+          const j = ee.current.matrix[U.rowIndex][U.col];
+          return {
+            value: j.value,
+            count: j.count,
+            status: j.status,
+            step: j.status === "value" && j.value !== null ? ee.current.scale.stepOf(j.value) : null
+          };
+        },
+        getView: () => ee.current.view,
+        setView: (k) => ee.current.setView(k),
+        getSortRows: () => ee.current.sortRows,
+        setSortRows: (k) => ee.current.setSortRows(k),
+        getRowIds: () => {
+          const { expandedBody: k, rows: U } = ee.current;
+          return k.flatMap(
+            (j) => j.kind === "data" ? [U[j.rowIndex].id] : []
+          );
+        },
+        getColumnIds: () => ee.current.columns.map((k) => k.id),
+        getGroupIds: () => {
+          const {
+            groupRows: k,
+            expandedBody: U,
+            groupIds: j
+          } = ee.current;
+          return k ? U.flatMap(
+            (oe) => oe.kind === "group" ? [j.get(oe.groupId) ?? ""] : []
+          ) : [];
+        },
+        getCollapsedGroups: () => {
+          const { collapsed: k, groupIds: U } = ee.current;
+          return [...k].flatMap((j) => {
+            const oe = U.get(j);
+            return oe === void 0 ? [] : [oe];
+          });
+        },
+        setGroupCollapsed: (k, U) => {
+          const { groupRows: j, groupByPublicId: oe } = ee.current;
+          if (!j)
+            throw new Error(
+              "Heatmap: rows are not grouped (groupRows is off)."
+            );
+          const se = oe.get(k);
+          if (se === void 0)
+            throw new Error(`Heatmap: no group "${k}".`);
+          ee.current.setGroupCollapsed(se, U);
+        }
+      };
+    }, []);
+    Wn(so, Ft, C);
+    const pt = X(
+      () => q.some((r) => r.some((h) => h.status === "empty")),
+      [q]
+    ), St = X(() => {
+      const r = (S) => S.status === "low-sample", h = E ? [...xe.groupColumns.values()].flat() : [], M = E ? [...xe.groups.values()] : [];
+      return h.some(r) || p !== !1 && (xe.rows.some(r) || M.some(r)) || A !== !1 && (xe.columns.some(r) || p !== !1 && r(xe.grand));
+    }, [xe, p, A, E]), mt = X(
+      () => q.some((r) => r.some((h) => h.status === "low-sample")),
+      [q]
+    ), Ee = X(
+      () => ({
+        palette: Me,
+        scale: ne,
+        describer: Z,
+        hasEmpty: pt,
+        hasLowSample: mt,
+        hasWithheldTotal: St,
+        minCount: l,
+        tooltipText: Be
+      }),
+      [
+        Me,
+        ne,
+        Z,
+        pt,
+        mt,
+        St,
+        l,
+        Be
+      ]
+    ), ke = wn({ className: Q });
+    if (K)
+      return /* @__PURE__ */ H(_t.Provider, { value: Ee, children: /* @__PURE__ */ le(
+        "div",
+        {
+          ref: x,
+          "data-component": "heatmap",
+          "data-component-id": C,
+          className: ke,
+          children: [
+            /* @__PURE__ */ le(
+              "div",
+              {
+                role: "status",
+                "aria-label": _("heatmap.loading"),
+                "aria-busy": "true",
+                className: wn(),
+                children: [
+                  /* @__PURE__ */ H(
+                    qt,
+                    {
+                      variant: "rectangular",
+                      className: "ds:h-[var(--spacing-md)] ds:w-[calc(var(--spacing-xl)*6)] ds:max-w-full"
+                    }
+                  ),
+                  /* @__PURE__ */ H(
+                    qt,
+                    {
+                      variant: "rectangular",
+                      className: "ds:h-[calc(var(--min-target-size)*5)] ds:w-full"
+                    }
+                  )
+                ]
+              }
+            ),
+            te
+          ]
+        }
+      ) });
+    if (t.length === 0 || n.length === 0 || !Fo(q))
+      return /* @__PURE__ */ H(_t.Provider, { value: Ee, children: /* @__PURE__ */ le(
+        "div",
+        {
+          ref: x,
+          "data-component": "heatmap",
+          "data-component-id": C,
+          className: ke,
+          children: [
+            /* @__PURE__ */ H(
+              Yn,
+              {
+                variant: "no-results",
+                size: "sm",
+                title: _("heatmap.empty.title"),
+                description: _("heatmap.empty.description")
+              }
+            ),
+            te
+          ]
+        }
+      ) });
+    const Bt = t.length * n.length > Wo, f = R !== "none" || F !== void 0;
+    return /* @__PURE__ */ H(_t.Provider, { value: Ee, children: /* @__PURE__ */ le(
+      "div",
+      {
+        ref: x,
+        "data-component": "heatmap",
+        "data-component-id": C,
+        className: ke,
+        children: [
+          /* @__PURE__ */ le("div", { className: Yo(), children: [
+            b !== !1 ? /* @__PURE__ */ H(an, { variant: b }) : null,
+            /* @__PURE__ */ H(
+              Un,
+              {
+                intent: "outline",
+                size: "sm",
+                className: "ds:ms-auto",
+                startIcon: ve === "table" ? /* @__PURE__ */ H(oo, { "aria-hidden": "true" }) : /* @__PURE__ */ H(ro, { "aria-hidden": "true" }),
+                onPointerEnter: ve === "table" ? void 0 : xn,
+                onFocus: ve === "table" ? void 0 : xn,
+                onClick: () => it(ve === "table" ? "heatmap" : "table"),
+                children: _(ve === "table" ? "heatmap.viewAsHeatmap" : "heatmap.viewAsTable")
+              }
+            )
+          ] }),
+          ve === "table" ? /* @__PURE__ */ H(
+            ia,
+            {
+              onLoadError: () => fe(_("heatmap.announce.tableFailed")),
+              title: e,
+              rowsLabel: c,
+              rows: t,
+              columns: n,
+              matrix: q,
+              body: ze,
+              grouped: E,
+              groupIds: pe,
+              describer: Z,
+              totals: xe,
+              rowTotals: p,
+              columnTotals: A,
+              groupColumnMethod: je
+            },
+            `${z}-${$}`
+          ) : /* @__PURE__ */ H(Qn, { delayDuration: 0, children: /* @__PURE__ */ H(
+            aa,
+            {
+              title: e,
+              rowsLabel: c,
+              rows: t,
+              columns: n,
+              matrix: q,
+              body: de,
+              scale: ne,
+              palette: Me,
+              describer: Z,
+              showValues: w,
+              totals: xe,
+              rowTotals: p,
+              columnTotals: A,
+              groupColumnMethod: je,
+              groupIds: pe,
+              selectionMode: R,
+              selected: he,
+              columnIndexOfKey: ct,
+              interactive: f,
+              virtualised: Bt,
+              size: N,
+              density: T,
+              cellInfo: Fe,
+              tooltipText: Be,
+              describeFocused: Y !== void 0,
+              onActivate: Mt,
+              onRange: dt,
+              onToggleGroup: Ue
+            }
+          ) }),
+          te,
+          /* @__PURE__ */ H(Jn, { children: Dt }, String(z))
+        ]
+      }
+    ) });
+  }
+);
+Bn.displayName = "Heatmap";
+const Aa = Object.assign(Bn, {
+  Legend: an,
+  Tooltip: Dn
+});
+export {
+  Aa as H,
+  an as a,
+  Dn as b,
+  so as h
+};
+//# sourceMappingURL=heatmap-C1TeC7wT.js.map