shap-svg 0.1.0

package/dist/chunk-OXFKP5I3.js

@@ -0,0 +1,1566 @@
+// src/core/types.ts
+var UnsupportedContractVersionError = class extends Error {
+  constructor(received) {
+    super(`shap-svg supports contract_version 1, received ${JSON.stringify(received)}`);
+    this.received = received;
+    this.name = "UnsupportedContractVersionError";
+  }
+};
+var InvalidExplanationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "InvalidExplanationError";
+  }
+};
+
+// src/core/taxonomy.ts
+function genusOf(featureName) {
+  const underscore = featureName.indexOf("_");
+  return underscore === -1 ? featureName : featureName.slice(0, underscore);
+}
+function groupByGenus(featureNames) {
+  const genera = [];
+  const memberIndices = [];
+  const seen = /* @__PURE__ */ new Map();
+  featureNames.forEach((name, index) => {
+    const genus = genusOf(name);
+    let slot = seen.get(genus);
+    if (slot === void 0) {
+      slot = genera.length;
+      seen.set(genus, slot);
+      genera.push(genus);
+      memberIndices.push([]);
+    }
+    memberIndices[slot].push(index);
+  });
+  return { genera, memberIndices };
+}
+function aggregateByGenus(values, data, featureNames) {
+  const { genera, memberIndices } = groupByGenus(featureNames);
+  const sumInto = (rows) => rows.map(
+    (row) => memberIndices.map(
+      (members) => members.reduce((total, index) => {
+        var _a;
+        return total + ((_a = row[index]) != null ? _a : 0);
+      }, 0)
+    )
+  );
+  return {
+    values: sumInto(values),
+    data: sumInto(data),
+    featureNames: genera
+  };
+}
+function groupExplanationByGenus(explanation) {
+  const grouped = aggregateByGenus(
+    explanation.values,
+    explanation.data,
+    explanation.featureNames
+  );
+  return {
+    ...explanation,
+    values: grouped.values,
+    data: grouped.data,
+    featureNames: grouped.featureNames,
+    nFeatures: grouped.featureNames.length
+  };
+}
+
+// src/core/rowSort.ts
+function sortDisplayRows(display, sort, data) {
+  if (sort === "importance") return display;
+  const meanOf = (featureIndex) => data.length === 0 ? 0 : data.reduce((sum, sample) => sum + sample[featureIndex], 0) / data.length;
+  const keyed = display.rows.filter((row) => !row.isOtherRow).map((row, rank) => ({
+    row,
+    rank,
+    mean: row.featureIndex === null ? 0 : meanOf(row.featureIndex)
+  }));
+  keyed.sort((a, b) => {
+    const primary = sort === "name" ? a.row.label.localeCompare(b.row.label, void 0, { sensitivity: "base" }) : b.mean - a.mean;
+    return primary || a.rank - b.rank;
+  });
+  return {
+    ...display,
+    rows: [...keyed.map((k) => k.row), ...display.rows.filter((row) => row.isOtherRow)]
+  };
+}
+
+// src/core/parse.ts
+var SUPPORTED_CONTRACT_VERSION = 1;
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function assertFiniteRows(rows, field) {
+  if (!Array.isArray(rows)) {
+    throw new InvalidExplanationError(`${field} must be an array of Sample rows`);
+  }
+  for (let i = 0; i < rows.length; i++) {
+    const row = rows[i];
+    if (!Array.isArray(row)) {
+      throw new InvalidExplanationError(`${field}[${i}] must be an array of Feature values`);
+    }
+    for (let j = 0; j < row.length; j++) {
+      if (typeof row[j] !== "number" || !Number.isFinite(row[j])) {
+        throw new InvalidExplanationError(
+          `${field}[${i}][${j}] is ${String(row[j])}; the payload must contain only finite numbers`
+        );
+      }
+    }
+  }
+}
+function assertStringArray(value, field) {
+  if (!Array.isArray(value) || value.some((entry) => typeof entry !== "string")) {
+    throw new InvalidExplanationError(`${field} must be an array of strings`);
+  }
+}
+function selectClassValues(values, classIndex) {
+  if (!Array.isArray(values)) {
+    throw new InvalidExplanationError("values must be an array");
+  }
+  if (!Number.isInteger(classIndex) || classIndex < 0) {
+    throw new InvalidExplanationError(`classIndex must be a non-negative integer, received ${classIndex}`);
+  }
+  const firstRow = values[0];
+  const firstCell = Array.isArray(firstRow) ? firstRow[0] : void 0;
+  if (Array.isArray(firstCell)) {
+    return values.map((row, sampleIndex) => {
+      if (!Array.isArray(row)) {
+        throw new InvalidExplanationError(`values[${sampleIndex}] must be an array of Feature values`);
+      }
+      return row.map((cell, featureIndex) => {
+        if (!Array.isArray(cell) || classIndex >= cell.length) {
+          throw new InvalidExplanationError(
+            `values[${sampleIndex}][${featureIndex}] has no class ${classIndex}`
+          );
+        }
+        return cell[classIndex];
+      });
+    });
+  }
+  return values;
+}
+function selectBaseValues(value, nSamples, classIndex) {
+  if (typeof value === "number") {
+    return new Array(nSamples).fill(value);
+  }
+  if (!Array.isArray(value)) {
+    throw new InvalidExplanationError("base_values must be a number, an array, or an array of class arrays");
+  }
+  if (Array.isArray(value[0])) {
+    return value.map((row, sampleIndex) => {
+      if (!Array.isArray(row) || classIndex >= row.length) {
+        throw new InvalidExplanationError(`base_values[${sampleIndex}] has no class ${classIndex}`);
+      }
+      return row[classIndex];
+    });
+  }
+  return value;
+}
+function parseExplanation(input, opts = {}) {
+  var _a, _b;
+  const classIndex = (_a = opts.classIndex) != null ? _a : 1;
+  if (!isRecord(input) || input.contract_version !== SUPPORTED_CONTRACT_VERSION) {
+    throw new UnsupportedContractVersionError(isRecord(input) ? input.contract_version : void 0);
+  }
+  const e = input;
+  assertStringArray(e.feature_names, "feature_names");
+  assertFiniteRows(e.data, "data");
+  const values = selectClassValues(e.values, classIndex);
+  assertFiniteRows(values, "values");
+  const nSamples = values.length;
+  const nFeatures = e.feature_names.length;
+  if (e.data.length !== nSamples) {
+    throw new InvalidExplanationError(`data has ${e.data.length} Samples but values has ${nSamples}`);
+  }
+  for (const [name, rows] of [["values", values], ["data", e.data]]) {
+    for (let i = 0; i < rows.length; i++) {
+      if (rows[i].length !== nFeatures) {
+        throw new InvalidExplanationError(
+          `${name}[${i}] has ${rows[i].length} Features but feature_names has ${nFeatures}`
+        );
+      }
+    }
+  }
+  const baseValues = selectBaseValues(e.base_values, nSamples, classIndex);
+  if (baseValues.length !== nSamples) {
+    throw new InvalidExplanationError(
+      `base_values has ${baseValues.length} entries but there are ${nSamples} Samples`
+    );
+  }
+  assertFiniteRows([baseValues], "base_values");
+  if (e.sample_ids !== void 0) {
+    assertStringArray(e.sample_ids, "sample_ids");
+    if (e.sample_ids.length !== nSamples) {
+      throw new InvalidExplanationError(
+        `sample_ids has ${e.sample_ids.length} entries but there are ${nSamples} Samples`
+      );
+    }
+  }
+  if (e.sample_labels !== void 0) {
+    assertStringArray(e.sample_labels, "sample_labels");
+    if (e.sample_labels.length !== nSamples) {
+      throw new InvalidExplanationError(
+        `sample_labels has ${e.sample_labels.length} entries but there are ${nSamples} Samples`
+      );
+    }
+  }
+  if (e.sample_label_column !== void 0 && typeof e.sample_label_column !== "string") {
+    throw new InvalidExplanationError("sample_label_column must be a string");
+  }
+  if (e.output_names !== void 0) assertStringArray(e.output_names, "output_names");
+  return {
+    values,
+    data: e.data,
+    baseValues,
+    featureNames: e.feature_names,
+    sampleIds: e.sample_ids,
+    sampleLabels: e.sample_labels,
+    sampleLabelColumn: e.sample_label_column,
+    outputName: (_b = e.output_names) == null ? void 0 : _b[0],
+    nSamples,
+    nFeatures
+  };
+}
+
+// src/core/order.ts
+function globalImportance(e) {
+  const out = new Array(e.nFeatures).fill(0);
+  for (const row of e.values) {
+    for (let j = 0; j < e.nFeatures; j++) out[j] += Math.abs(row[j]);
+  }
+  return out.map((sum) => sum / e.nSamples);
+}
+function orderFeatures(importance) {
+  return importance.map((value, index) => ({ value, index })).sort((a, b) => b.value - a.value || a.index - b.index).map((entry) => entry.index);
+}
+
+// src/core/format.ts
+var MINUS = "\u2212";
+var EXPONENT_THRESHOLD = 1e-3;
+var PERCENT_DECIMALS = 2;
+function formatShapValue(v, decimals) {
+  if (v === 0) return "0";
+  return (v < 0 ? MINUS : "+") + magnitudeOf(v, decimals);
+}
+function formatLevel(v, decimals) {
+  if (v === 0) return "0";
+  return (v < 0 ? MINUS : "") + magnitudeOf(v, decimals);
+}
+function magnitudeOf(v, decimals) {
+  const magnitude = Math.abs(v);
+  if (decimals === void 0) {
+    return magnitude < EXPONENT_THRESHOLD ? magnitude.toExponential(0) : String(Number(magnitude.toPrecision(3)));
+  }
+  const places = decimals === "percent" ? PERCENT_DECIMALS : decimals;
+  const scaled = decimals === "percent" ? magnitude * 100 : magnitude;
+  const unit = decimals === "percent" ? "%" : "";
+  if (scaled < 0.5 * 10 ** -places) return magnitude.toExponential(0);
+  return scaled.toFixed(places) + unit;
+}
+function formatFeatureLabel(name) {
+  return name.replace(/_/g, " ");
+}
+
+// src/core/collapse.ts
+function collapseToDisplay(featureNames, importance, order, maxDisplay, faithfulOtherRow) {
+  const p = order.length;
+  if (maxDisplay >= p) {
+    return {
+      rows: order.map((index) => ({
+        label: formatFeatureLabel(featureNames[index]),
+        featureIndex: index,
+        value: importance[index],
+        isOtherRow: false
+      })),
+      collapsedCount: 0
+    };
+  }
+  const realCount = faithfulOtherRow ? maxDisplay - 1 : maxDisplay;
+  const rows = order.slice(0, realCount).map((index) => ({
+    label: formatFeatureLabel(featureNames[index]),
+    featureIndex: index,
+    value: importance[index],
+    isOtherRow: false
+  }));
+  const collapsed = order.slice(realCount);
+  const collapsedValue = collapsed.reduce((sum, index) => sum + importance[index], 0);
+  rows.push({
+    label: faithfulOtherRow ? `Sum of ${collapsed.length} other features` : `${collapsed.length} other features`,
+    featureIndex: null,
+    value: collapsedValue,
+    isOtherRow: true
+  });
+  return { rows, collapsedCount: collapsed.length };
+}
+
+// src/core/ticks.ts
+var MINUS2 = "\u2212";
+var PX_TO_PT = 0.75;
+var MAX_TICKS = 9;
+var LADDER = [1, 2, 2.5, 5, 10];
+var TICK_LENGTH = 5;
+var TICK_LABEL_DY = 18;
+var AXIS_TITLE_DY = 38;
+function tickSpace(axisPx, labelPt) {
+  const space = Math.floor(axisPx * PX_TO_PT / (labelPt * 3));
+  return Math.min(MAX_TICKS, Math.max(1, space));
+}
+function niceTicks(min, max, maxTicks, { integer = false } = {}) {
+  const span = max - min;
+  if (!(span > 0) || !(maxTicks > 0)) return { ticks: [], step: 0 };
+  const rough = span / maxTicks;
+  let magnitude = 10 ** Math.floor(Math.log10(rough));
+  let step = 0;
+  for (let decade = 0; decade < 4 && step === 0; decade++, magnitude *= 10) {
+    for (const multiple of LADDER) {
+      const candidate = multiple * magnitude;
+      if (candidate < rough * (1 - 1e-9)) continue;
+      if (integer && (candidate < 1 || Math.abs(candidate - Math.round(candidate)) > 1e-9)) {
+        continue;
+      }
+      step = candidate;
+      break;
+    }
+  }
+  if (step === 0) return { ticks: [], step: 0 };
+  const first = Math.ceil(min / step - 1e-9) * step;
+  const count = Math.floor((max - first) / step + 1e-9) + 1;
+  const ticks = [];
+  for (let i = 0; i < count; i++) {
+    const value = first + i * step;
+    ticks.push(Math.abs(value) < step * 1e-9 ? 0 : value);
+  }
+  return { ticks, step };
+}
+function tickLabel(value, step, percent = false) {
+  const scaled = percent ? value * 100 : value;
+  const scaledStep = percent ? step * 100 : step;
+  let decimals = 0;
+  while (decimals < 6) {
+    const factor = 10 ** decimals;
+    if (Math.abs(scaledStep * factor - Math.round(scaledStep * factor)) < 1e-9) break;
+    decimals++;
+  }
+  const digits = Math.abs(scaled).toFixed(decimals);
+  const sign = scaled < 0 && Number(digits) !== 0 ? MINUS2 : "";
+  return sign + digits + (percent ? "%" : "");
+}
+
+// src/core/barLayout.ts
+var POSITIVE_COLOR = "#ff0051";
+var NEGATIVE_COLOR = "#008bfb";
+var BAR_THICKNESS_RATIO = 0.7;
+var AXIS_HEIGHT = 52;
+var TICK_LABEL_PT = 11;
+var TITLE_PT = 13;
+var X_MARGIN = 0.05;
+function barXAxis(min, max, toX, marginLeft, plotWidth, plotBottom) {
+  const { ticks, step } = niceTicks(min, max, tickSpace(plotWidth, TICK_LABEL_PT));
+  return {
+    xTicks: ticks.map((value) => ({ value, x: toX(value), label: tickLabel(value, step) })),
+    xSpine: { x1: marginLeft, x2: marginLeft + plotWidth, y: plotBottom },
+    xTitle: {
+      // _bar.py:143-150 builds this from the Explanation's transform history:
+      // "SHAP value" -> "|SHAP value|" -> "mean(|SHAP value|)".
+      text: "mean(|SHAP value|)",
+      x: marginLeft + plotWidth / 2,
+      y: plotBottom + AXIS_TITLE_DY,
+      fontSize: TITLE_PT
+    }
+  };
+}
+function barLayout(rows, opts) {
+  const { width, rowHeight, marginLeft, marginRight, marginTop } = opts;
+  const plotWidth = width - marginLeft - marginRight;
+  const values = rows.rows.map((r) => r.value);
+  const dataMin = Math.min(0, ...values);
+  const dataMax = Math.max(0, ...values);
+  const dataSpan = dataMax - dataMin;
+  const negative = values.some((v) => v < 0);
+  const autoMin = negative ? dataMin - dataSpan * X_MARGIN : dataMin;
+  const autoMax = dataMax + dataSpan * X_MARGIN;
+  const buffer = (autoMax - autoMin) * X_MARGIN;
+  const min = negative ? autoMin - buffer : autoMin;
+  const max = autoMax + buffer;
+  const span = max - min || 1;
+  const toX = (v) => marginLeft + (v - min) / span * plotWidth;
+  const xZero = toX(0);
+  const barHeight = rowHeight * BAR_THICKNESS_RATIO;
+  const inset = (rowHeight - barHeight) / 2;
+  const bars = rows.rows.map((row, i) => {
+    const rowTop = marginTop + i * rowHeight;
+    const end = toX(row.value);
+    const positive = row.value > 0;
+    return {
+      label: row.label,
+      featureIndex: row.featureIndex,
+      isOtherRow: row.isOtherRow,
+      value: row.value,
+      x: positive ? xZero : end,
+      y: rowTop + inset,
+      width: Math.abs(end - xZero),
+      height: barHeight,
+      color: positive ? POSITIVE_COLOR : NEGATIVE_COLOR,
+      centerY: rowTop + rowHeight / 2
+    };
+  });
+  return {
+    bars,
+    xDomain: [min, max],
+    xZero,
+    plotWidth,
+    plotBottom: marginTop + rows.rows.length * rowHeight,
+    ...barXAxis(min, max, toX, marginLeft, plotWidth, marginTop + rows.rows.length * rowHeight),
+    zeroLine: { x: xZero, y1: marginTop, y2: marginTop + rows.rows.length * rowHeight },
+    height: marginTop + rows.rows.length * rowHeight + AXIS_HEIGHT
+  };
+}
+
+// src/core/waterfallLayout.ts
+var WATERFALL_HEAD_LENGTH_PX = 8;
+var BAR_THICKNESS_RATIO2 = 0.8;
+var AXIS_HEIGHT2 = 52;
+var WATERFALL_TICK_LABEL_DY = 18;
+var WATERFALL_BASE_LABEL_DY = 36;
+var TICK_LABEL_PT2 = 13;
+var colorFor = (value) => value < 0 ? NEGATIVE_COLOR : POSITIVE_COLOR;
+var VALUE_LABEL_GAP = 6;
+var VALUE_LABEL_FONT_SIZE = 12;
+var GLYPH_WIDTH_RATIO = 0.6;
+var INSIDE_PADDING = 4;
+function placeValueLabel(value, startX, endX, gutterX, decimals) {
+  const text = formatShapValue(value, decimals);
+  const estimatedWidth = text.length * VALUE_LABEL_FONT_SIZE * GLYPH_WIDTH_RATIO;
+  const base = { estimatedWidth, text };
+  if (estimatedWidth + 2 * INSIDE_PADDING <= Math.abs(endX - startX)) {
+    return { ...base, x: (startX + endX) / 2, anchor: "middle", inside: true };
+  }
+  if (value >= 0) {
+    return { ...base, x: endX + VALUE_LABEL_GAP, anchor: "start", inside: false };
+  }
+  const outsideLeftEdge = endX - VALUE_LABEL_GAP - estimatedWidth;
+  if (outsideLeftEdge >= gutterX) {
+    return { ...base, x: endX - VALUE_LABEL_GAP, anchor: "end", inside: false };
+  }
+  return { ...base, x: startX + VALUE_LABEL_GAP, anchor: "start", inside: false };
+}
+function waterfallRows(explanation, sampleIndex, maxDisplay, faithfulOtherRow) {
+  if (!Number.isInteger(sampleIndex) || sampleIndex < 0 || sampleIndex >= explanation.nSamples) {
+    throw new RangeError(
+      `sampleIndex must identify a Sample from 0 to ${explanation.nSamples - 1}, received ${sampleIndex}`
+    );
+  }
+  if (!Number.isInteger(maxDisplay) || maxDisplay <= 0) {
+    throw new RangeError(`maxDisplay must be a positive integer, received ${maxDisplay}`);
+  }
+  const values = explanation.values[sampleIndex];
+  const baseValue = explanation.baseValues[sampleIndex];
+  const modelOutput = baseValue + values.reduce((sum, value) => sum + value, 0);
+  const order = orderFeatures(values.map(Math.abs));
+  const visibleLimit = Math.min(maxDisplay, explanation.nFeatures);
+  const hasOtherRow = visibleLimit < explanation.nFeatures;
+  const realCount = hasOtherRow && faithfulOtherRow ? visibleLimit - 1 : visibleLimit;
+  const rowCount = realCount + (hasOtherRow ? 1 : 0);
+  let location = modelOutput;
+  const rows = [];
+  for (let rank = 0; rank < realCount; rank++) {
+    const featureIndex = order[rank];
+    const value = values[featureIndex];
+    location -= value;
+    rows.push({
+      label: formatFeatureLabel(explanation.featureNames[featureIndex]),
+      featureIndex,
+      isOtherRow: false,
+      value,
+      left: location,
+      width: value,
+      row: rowCount - 1 - rank,
+      color: colorFor(value)
+    });
+  }
+  const collapsed = order.slice(realCount);
+  if (hasOtherRow) {
+    const value = collapsed.reduce((sum, featureIndex) => sum + values[featureIndex], 0);
+    rows.push({
+      label: `${collapsed.length} other features`,
+      featureIndex: null,
+      isOtherRow: true,
+      value,
+      left: baseValue,
+      width: value,
+      row: 0,
+      color: colorFor(value)
+    });
+  }
+  return {
+    rows,
+    baseValue,
+    modelOutput,
+    collapsedCount: hasOtherRow ? collapsed.length : 0
+  };
+}
+function waterfallLayout(valueRows, opts) {
+  const { width, rowHeight, marginLeft, marginRight, marginTop } = opts;
+  const plotWidth = width - marginLeft - marginRight;
+  const coordinates = [valueRows.baseValue, valueRows.modelOutput];
+  for (const row of valueRows.rows) coordinates.push(row.left, row.left + row.width);
+  const min = Math.min(...coordinates);
+  const max = Math.max(...coordinates);
+  const span = max - min || 1;
+  const toX = (value) => marginLeft + (value - min) / span * plotWidth;
+  const barHeight = rowHeight * BAR_THICKNESS_RATIO2;
+  const inset = (rowHeight - barHeight) / 2;
+  const arrows = valueRows.rows.map((row, index) => {
+    const y = marginTop + index * rowHeight + inset;
+    const centerY = marginTop + index * rowHeight + rowHeight / 2;
+    const startX = toX(row.left);
+    const endX = toX(row.left + row.width);
+    const headLength = Math.min(Math.abs(endX - startX), WATERFALL_HEAD_LENGTH_PX);
+    const neckX = row.width < 0 ? endX + headLength : endX - headLength;
+    const points = [
+      { x: startX, y },
+      { x: neckX, y },
+      { x: endX, y: centerY },
+      { x: neckX, y: y + barHeight },
+      { x: startX, y: y + barHeight }
+    ];
+    return {
+      ...row,
+      points,
+      startX,
+      endX,
+      y,
+      centerY,
+      height: barHeight,
+      headLength,
+      valueLabel: placeValueLabel(row.value, startX, endX, marginLeft, opts.decimals)
+    };
+  });
+  const plotBottom = marginTop + valueRows.rows.length * rowHeight;
+  const { ticks, step } = niceTicks(min, max, tickSpace(plotWidth, TICK_LABEL_PT2));
+  const individualCount = valueRows.rows.filter((row) => !row.isOtherRow).length;
+  const hasOtherRow = individualCount < valueRows.rows.length;
+  const connectors = [];
+  for (let index = 0; index < individualCount; index++) {
+    if (!hasOtherRow && index + 4 >= individualCount) continue;
+    connectors.push({
+      x: arrows[index].startX,
+      y1: marginTop + index * rowHeight + inset,
+      y2: marginTop + (index + 1) * rowHeight + inset + barHeight
+    });
+  }
+  return {
+    arrows,
+    connectors,
+    xTicks: ticks.map((value) => ({
+      value,
+      x: toX(value),
+      label: tickLabel(value, step, opts.decimals === "percent")
+    })),
+    axisMarks: [
+      {
+        kind: "base",
+        value: valueRows.baseValue,
+        x: toX(valueRows.baseValue),
+        // axvline(base_values, 0, 1 / num_features) — one row tall, not full
+        // height. Drawn the full height it reads as a y axis the chart has not
+        // got, which is the whole reason SHAP hides the left spine.
+        y1: plotBottom - rowHeight,
+        y2: plotBottom,
+        label: `E[f(X)] = ${formatLevel(valueRows.baseValue, opts.decimals)}`
+      },
+      {
+        kind: "output",
+        value: valueRows.modelOutput,
+        x: toX(valueRows.modelOutput),
+        // axvline(fx, 0, 1) — the full height.
+        y1: marginTop,
+        y2: plotBottom,
+        label: `f(x) = ${formatLevel(valueRows.modelOutput, opts.decimals)}`
+      }
+    ],
+    separators: valueRows.rows.map((_, index) => ({
+      y: marginTop + index * rowHeight + rowHeight / 2,
+      x1: marginLeft,
+      x2: marginLeft + plotWidth
+    })),
+    xDomain: [min, max],
+    plotWidth,
+    plotLeft: marginLeft,
+    plotRight: marginLeft + plotWidth,
+    plotBottom,
+    height: plotBottom + AXIS_HEIGHT2
+  };
+}
+
+// src/core/colormaps.json
+var colormaps_default = {
+  note: "256-entry sRGB lookup tables dumped from shap.plots.colors. Interpolate linearly between entries; do not re-derive from Lch.",
+  red_blue: [
+    "#008bfb",
+    "#008afb",
+    "#0089fa",
+    "#0089fa",
+    "#0088fa",
+    "#0088fa",
+    "#0087fa",
+    "#0087fa",
+    "#0086fa",
+    "#0086f9",
+    "#0085f9",
+    "#0085f9",
+    "#0084f9",
+    "#0083f8",
+    "#0083f8",
+    "#0082f8",
+    "#0082f8",
+    "#0081f8",
+    "#0081f7",
+    "#0080f7",
+    "#0080f7",
+    "#007ff6",
+    "#007ef6",
+    "#007ef6",
+    "#007df6",
+    "#007df5",
+    "#007cf5",
+    "#007bf5",
+    "#007bf4",
+    "#007af4",
+    "#007af4",
+    "#0079f3",
+    "#0078f3",
+    "#0078f2",
+    "#0077f2",
+    "#0076f2",
+    "#0076f1",
+    "#0075f1",
+    "#0075f0",
+    "#0074f0",
+    "#0073f0",
+    "#0073ef",
+    "#0072ef",
+    "#0071ee",
+    "#0071ee",
+    "#0070ed",
+    "#006fed",
+    "#066fec",
+    "#0f6eec",
+    "#196deb",
+    "#1e6deb",
+    "#236cea",
+    "#286bea",
+    "#2c6be9",
+    "#306ae9",
+    "#3369e8",
+    "#3769e8",
+    "#3a68e7",
+    "#3c67e6",
+    "#3f66e6",
+    "#4266e5",
+    "#4465e5",
+    "#4764e4",
+    "#4964e3",
+    "#4b63e3",
+    "#4d62e2",
+    "#5061e2",
+    "#5261e1",
+    "#5460e0",
+    "#565fe0",
+    "#575edf",
+    "#595ede",
+    "#5b5dde",
+    "#5d5cdd",
+    "#5f5bdc",
+    "#605bdb",
+    "#625adb",
+    "#6359da",
+    "#6558d9",
+    "#6757d9",
+    "#6856d8",
+    "#6a56d7",
+    "#6b55d6",
+    "#6d54d6",
+    "#6e53d5",
+    "#6f52d4",
+    "#7151d3",
+    "#7251d2",
+    "#7350d2",
+    "#754fd1",
+    "#764ed0",
+    "#774dcf",
+    "#794cce",
+    "#7a4bce",
+    "#7b4acd",
+    "#7c49cc",
+    "#7d48cb",
+    "#7e48ca",
+    "#8047c9",
+    "#8146c8",
+    "#8245c7",
+    "#8344c7",
+    "#8443c6",
+    "#8542c5",
+    "#8641c4",
+    "#8740c3",
+    "#883fc2",
+    "#893ec1",
+    "#8a3cc0",
+    "#8b3bbf",
+    "#8c3abe",
+    "#8d39bd",
+    "#8e38bc",
+    "#8f37bb",
+    "#9036ba",
+    "#9134b9",
+    "#9233b8",
+    "#9232b8",
+    "#9331b7",
+    "#942fb6",
+    "#952eb4",
+    "#962db3",
+    "#972bb2",
+    "#972ab1",
+    "#9828b0",
+    "#9927af",
+    "#9a25ae",
+    "#9b24ae",
+    "#9c23ad",
+    "#9d22ac",
+    "#9e21ac",
+    "#a020ab",
+    "#a11fab",
+    "#a21eaa",
+    "#a41daa",
+    "#a51ca9",
+    "#a61ba9",
+    "#a719a8",
+    "#a918a8",
+    "#aa17a7",
+    "#ab16a7",
+    "#ac14a6",
+    "#ae13a6",
+    "#af11a5",
+    "#b010a5",
+    "#b10ea4",
+    "#b20ca4",
+    "#b40aa3",
+    "#b507a2",
+    "#b605a2",
+    "#b703a1",
+    "#b802a1",
+    "#b900a0",
+    "#bb00a0",
+    "#bc009f",
+    "#bd009e",
+    "#be009e",
+    "#bf009d",
+    "#c0009d",
+    "#c1009c",
+    "#c2009b",
+    "#c3009b",
+    "#c4009a",
+    "#c50099",
+    "#c60099",
+    "#c70098",
+    "#c90097",
+    "#ca0097",
+    "#cb0096",
+    "#cc0096",
+    "#cd0095",
+    "#cd0094",
+    "#ce0093",
+    "#cf0093",
+    "#d00092",
+    "#d10091",
+    "#d20091",
+    "#d30090",
+    "#d4008f",
+    "#d5008f",
+    "#d6008e",
+    "#d7008d",
+    "#d8008d",
+    "#d9008c",
+    "#da008b",
+    "#da008a",
+    "#db008a",
+    "#dc0089",
+    "#dd0088",
+    "#de0087",
+    "#df0087",
+    "#df0086",
+    "#e00085",
+    "#e10084",
+    "#e20084",
+    "#e30083",
+    "#e30082",
+    "#e40081",
+    "#e50081",
+    "#e60080",
+    "#e6007f",
+    "#e7007e",
+    "#e8007d",
+    "#e9007d",
+    "#e9007c",
+    "#ea007b",
+    "#eb007a",
+    "#eb007a",
+    "#ec0079",
+    "#ed0078",
+    "#ed0077",
+    "#ee0076",
+    "#ef0076",
+    "#ef0075",
+    "#f00074",
+    "#f10073",
+    "#f10072",
+    "#f20071",
+    "#f20071",
+    "#f30070",
+    "#f4006f",
+    "#f4006e",
+    "#f5006d",
+    "#f5006d",
+    "#f6006c",
+    "#f6006b",
+    "#f7006a",
+    "#f70069",
+    "#f80068",
+    "#f80068",
+    "#f90067",
+    "#f90066",
+    "#fa0065",
+    "#fa0064",
+    "#fb0063",
+    "#fb0062",
+    "#fc0062",
+    "#fc0061",
+    "#fd0060",
+    "#fd005f",
+    "#fd005e",
+    "#fe005d",
+    "#fe005c",
+    "#fe005c",
+    "#ff005b",
+    "#ff005a",
+    "#ff0059",
+    "#ff0058",
+    "#ff0057",
+    "#ff0056",
+    "#ff0055",
+    "#ff0055",
+    "#ff0054",
+    "#ff0053",
+    "#ff0052",
+    "#ff0051"
+  ],
+  red_white_blue: [
+    "#008bfb",
+    "#028bfb",
+    "#048cfb",
+    "#068dfb",
+    "#088efb",
+    "#0a8ffb",
+    "#0c90fb",
+    "#0e91fb",
+    "#1092fb",
+    "#1293fb",
+    "#1494fb",
+    "#1695fb",
+    "#1896fb",
+    "#1a96fb",
+    "#1c97fb",
+    "#1e98fb",
+    "#2099fb",
+    "#229afb",
+    "#249bfb",
+    "#269cfb",
+    "#289dfb",
+    "#2a9efb",
+    "#2c9ffb",
+    "#2ea0fc",
+    "#30a1fc",
+    "#32a2fc",
+    "#34a2fc",
+    "#36a3fc",
+    "#38a4fc",
+    "#3aa5fc",
+    "#3ca6fc",
+    "#3ea7fc",
+    "#40a8fc",
+    "#42a9fc",
+    "#44aafc",
+    "#46abfc",
+    "#48acfc",
+    "#4aadfc",
+    "#4cadfc",
+    "#4eaefc",
+    "#50affc",
+    "#52b0fc",
+    "#54b1fc",
+    "#56b2fc",
+    "#58b3fc",
+    "#5ab4fc",
+    "#5cb5fc",
+    "#5eb6fc",
+    "#60b7fc",
+    "#62b8fc",
+    "#65b8fc",
+    "#67b9fc",
+    "#69bafc",
+    "#6bbbfd",
+    "#6dbcfd",
+    "#6fbdfd",
+    "#71befd",
+    "#73bffd",
+    "#75c0fd",
+    "#77c1fd",
+    "#79c2fd",
+    "#7bc3fd",
+    "#7dc3fd",
+    "#7fc4fd",
+    "#81c5fd",
+    "#83c6fd",
+    "#85c7fd",
+    "#87c8fd",
+    "#89c9fd",
+    "#8bcafd",
+    "#8dcbfd",
+    "#8fccfd",
+    "#91cdfd",
+    "#93cefd",
+    "#95cefd",
+    "#97cffd",
+    "#99d0fd",
+    "#9bd1fd",
+    "#9dd2fd",
+    "#9fd3fd",
+    "#a1d4fd",
+    "#a3d5fd",
+    "#a5d6fe",
+    "#a7d7fe",
+    "#a9d8fe",
+    "#abd9fe",
+    "#add9fe",
+    "#afdafe",
+    "#b1dbfe",
+    "#b3dcfe",
+    "#b5ddfe",
+    "#b7defe",
+    "#b9dffe",
+    "#bbe0fe",
+    "#bde1fe",
+    "#bfe2fe",
+    "#c1e3fe",
+    "#c3e4fe",
+    "#c5e5fe",
+    "#c7e5fe",
+    "#c9e6fe",
+    "#cbe7fe",
+    "#cde8fe",
+    "#cfe9fe",
+    "#d1eafe",
+    "#d3ebfe",
+    "#d5ecfe",
+    "#d7edfe",
+    "#d9eefe",
+    "#dbeffe",
+    "#ddf0fe",
+    "#dff0fe",
+    "#e1f1ff",
+    "#e3f2ff",
+    "#e5f3ff",
+    "#e7f4ff",
+    "#e9f5ff",
+    "#ebf6ff",
+    "#edf7ff",
+    "#eff8ff",
+    "#f1f9ff",
+    "#f3faff",
+    "#f5fbff",
+    "#f7fbff",
+    "#f9fcff",
+    "#fbfdff",
+    "#fdfeff",
+    "#ffffff",
+    "#ffffff",
+    "#fffdfe",
+    "#fffbfc",
+    "#fff9fb",
+    "#fff7fa",
+    "#fff5f8",
+    "#fff3f7",
+    "#fff1f6",
+    "#ffeff4",
+    "#ffedf3",
+    "#ffebf1",
+    "#ffe9f0",
+    "#ffe7ef",
+    "#ffe5ed",
+    "#ffe3ec",
+    "#ffe1eb",
+    "#ffdfe9",
+    "#ffdde8",
+    "#ffdbe7",
+    "#ffd9e5",
+    "#ffd7e4",
+    "#ffd5e2",
+    "#ffd3e1",
+    "#ffd1e0",
+    "#ffcfde",
+    "#ffcddd",
+    "#ffcbdc",
+    "#ffc9da",
+    "#ffc7d9",
+    "#ffc5d7",
+    "#ffc3d6",
+    "#ffc1d5",
+    "#ffbfd3",
+    "#ffbdd2",
+    "#ffbbd1",
+    "#ffb9cf",
+    "#ffb7ce",
+    "#ffb5cc",
+    "#ffb3cb",
+    "#ffb1ca",
+    "#ffafc8",
+    "#ffadc7",
+    "#ffabc6",
+    "#ffa9c4",
+    "#ffa7c3",
+    "#ffa5c1",
+    "#ffa3c0",
+    "#ffa1bf",
+    "#ff9fbd",
+    "#ff9dbc",
+    "#ff9bbb",
+    "#ff99b9",
+    "#ff97b8",
+    "#ff95b7",
+    "#ff93b5",
+    "#ff91b4",
+    "#ff8fb2",
+    "#ff8db1",
+    "#ff8bb0",
+    "#ff89ae",
+    "#ff87ad",
+    "#ff85ac",
+    "#ff83aa",
+    "#ff81a9",
+    "#ff7fa7",
+    "#ff7da6",
+    "#ff7ba5",
+    "#ff79a3",
+    "#ff77a2",
+    "#ff75a1",
+    "#ff739f",
+    "#ff719e",
+    "#ff6f9c",
+    "#ff6d9b",
+    "#ff6b9a",
+    "#ff6998",
+    "#ff6797",
+    "#ff6596",
+    "#ff6294",
+    "#ff6093",
+    "#ff5e92",
+    "#ff5c90",
+    "#ff5a8f",
+    "#ff588d",
+    "#ff568c",
+    "#ff548b",
+    "#ff5289",
+    "#ff5088",
+    "#ff4e87",
+    "#ff4c85",
+    "#ff4a84",
+    "#ff4882",
+    "#ff4681",
+    "#ff4480",
+    "#ff427e",
+    "#ff407d",
+    "#ff3e7c",
+    "#ff3c7a",
+    "#ff3a79",
+    "#ff3877",
+    "#ff3676",
+    "#ff3475",
+    "#ff3273",
+    "#ff3072",
+    "#ff2e71",
+    "#ff2c6f",
+    "#ff2a6e",
+    "#ff286d",
+    "#ff266b",
+    "#ff246a",
+    "#ff2268",
+    "#ff2067",
+    "#ff1e66",
+    "#ff1c64",
+    "#ff1a63",
+    "#ff1862",
+    "#ff1660",
+    "#ff145f",
+    "#ff125d",
+    "#ff105c",
+    "#ff0e5b",
+    "#ff0c59",
+    "#ff0a58",
+    "#ff0857",
+    "#ff0655",
+    "#ff0454",
+    "#ff0252",
+    "#ff0051"
+  ],
+  nan_grey: "#848484"
+};
+
+// src/core/colormap.ts
+var tables = colormaps_default;
+function channel(hex, offset) {
+  return Number.parseInt(hex.slice(offset, offset + 2), 16);
+}
+function hexByte(value) {
+  return Math.round(value).toString(16).padStart(2, "0");
+}
+function sampleColormap(name, t) {
+  if (!Number.isFinite(t)) {
+    throw new RangeError(`colormap position must be finite, received ${String(t)}`);
+  }
+  const table = tables[name];
+  if (!table) throw new RangeError(`unknown colormap ${String(name)}`);
+  const position = Math.max(0, Math.min(1, t)) * (table.length - 1);
+  const lowerIndex = Math.floor(position);
+  const upperIndex = Math.ceil(position);
+  const fraction = position - lowerIndex;
+  const lower = table[lowerIndex];
+  const upper = table[upperIndex];
+  const red = channel(lower, 1) + (channel(upper, 1) - channel(lower, 1)) * fraction;
+  const green = channel(lower, 3) + (channel(upper, 3) - channel(lower, 3)) * fraction;
+  const blue = channel(lower, 5) + (channel(upper, 5) - channel(lower, 5)) * fraction;
+  return `#${hexByte(red)}${hexByte(green)}${hexByte(blue)}`;
+}
+
+// src/core/beeswarmLayout.ts
+var BEESWARM_MISSING_COLOR = "#777777";
+var BEESWARM_ROW_HEIGHT = 0.4;
+var NBINS = 100;
+var AXIS_HEIGHT3 = 74;
+var TICK_LABEL_PT3 = 11;
+var TITLE_PT2 = 13;
+var X_MARGIN2 = 0.05;
+function percentile(values, percent) {
+  const finite = values.filter(Number.isFinite).sort((a, b) => a - b);
+  if (finite.length === 0) return 0;
+  const position = (finite.length - 1) * percent / 100;
+  const lower = Math.floor(position);
+  const upper = Math.ceil(position);
+  const fraction = position - lower;
+  return finite[lower] + (finite[upper] - finite[lower]) * fraction;
+}
+function colorDomain(featureValues) {
+  let vmin = percentile(featureValues, 5);
+  let vmax = percentile(featureValues, 95);
+  if (vmin === vmax) {
+    vmin = percentile(featureValues, 1);
+    vmax = percentile(featureValues, 99);
+  }
+  if (vmin === vmax) {
+    const finite = featureValues.filter(Number.isFinite);
+    if (finite.length > 0) {
+      vmin = Math.min(...finite);
+      vmax = Math.max(...finite);
+    }
+  }
+  if (vmin > vmax) vmin = vmax;
+  return [vmin, vmax];
+}
+function seededRandom(seed) {
+  let state = Math.trunc(seed) >>> 0;
+  return () => {
+    state = state + 1831565813 >>> 0;
+    let value = state;
+    value = Math.imul(value ^ value >>> 15, value | 1);
+    value ^= value + Math.imul(value ^ value >>> 7, value | 61);
+    return ((value ^ value >>> 14) >>> 0) / 4294967296;
+  };
+}
+function numpyRound(value) {
+  const lower = Math.floor(value);
+  if (value - lower === 0.5) return lower % 2 === 0 ? lower : lower + 1;
+  return Math.round(value);
+}
+function spreadPoints(xs, rowIndex, seed) {
+  const min = Math.min(...xs);
+  const max = Math.max(...xs);
+  const quantized = xs.map((x) => numpyRound(NBINS * (x - min) / (max - min + 1e-8)));
+  const random = seededRandom(seed);
+  const order = quantized.map((bin, index) => ({ bin, index, tieBreak: random() })).sort((a, b) => a.bin - b.bin || a.tieBreak - b.tieBreak).map((entry) => entry.index);
+  const offsets = new Array(xs.length).fill(0);
+  let layer = 0;
+  let lastBin = -1;
+  for (const index of order) {
+    const bin = quantized[index];
+    if (bin !== lastBin) layer = 0;
+    offsets[index] = Math.ceil(layer / 2) * (layer % 2 * 2 - 1);
+    layer += 1;
+    lastBin = bin;
+  }
+  const maxPositiveOffset = Math.max(0, ...offsets);
+  const scale = 0.9 * (BEESWARM_ROW_HEIGHT / (maxPositiveOffset + 1));
+  return offsets.map((offset) => rowIndex + offset * scale);
+}
+function beeswarmRows(explanation, maxDisplay, faithfulOtherRow, seed = 0, rowSort = "importance") {
+  if (!Number.isInteger(maxDisplay) || maxDisplay <= 0) {
+    throw new RangeError(`maxDisplay must be a positive integer, received ${maxDisplay}`);
+  }
+  if (!Number.isFinite(seed)) {
+    throw new RangeError(`seed must be finite, received ${String(seed)}`);
+  }
+  const importance = globalImportance(explanation);
+  const order = orderFeatures(importance);
+  const display = sortDisplayRows(
+    collapseToDisplay(
+      explanation.featureNames,
+      importance,
+      order,
+      maxDisplay,
+      faithfulOtherRow
+    ),
+    rowSort,
+    explanation.data
+  );
+  const visibleFeatures = new Set(
+    display.rows.flatMap((row) => row.featureIndex === null ? [] : [row.featureIndex])
+  );
+  const collapsedFeatures = order.filter((featureIndex) => !visibleFeatures.has(featureIndex));
+  const rows = display.rows.map((displayRow, displayIndex) => {
+    const featureIndices = displayRow.featureIndex === null ? collapsedFeatures : [displayRow.featureIndex];
+    const colorFeatureIndices = displayRow.featureIndex === null && faithfulOtherRow ? collapsedFeatures.slice(0, 1) : featureIndices;
+    const xs = explanation.values.map((sample) => featureIndices.reduce((sum, featureIndex) => sum + sample[featureIndex], 0));
+    const featureValues = explanation.data.map((sample) => colorFeatureIndices.reduce((sum, featureIndex) => sum + sample[featureIndex], 0));
+    const rowIndex = display.rows.length - 1 - displayIndex;
+    const ys = spreadPoints(xs, rowIndex, seed + Math.imul(displayIndex + 1, 2654435761));
+    const [vmin, vmax] = colorDomain(featureValues);
+    const colorSpan = vmax - vmin;
+    return {
+      label: displayRow.label,
+      featureIndex: displayRow.featureIndex,
+      isOtherRow: displayRow.isOtherRow,
+      rowIndex,
+      vmin,
+      vmax,
+      points: xs.map((x, sampleIndex) => {
+        const featureValue = featureValues[sampleIndex];
+        if (!Number.isFinite(featureValue)) {
+          return {
+            sampleIndex,
+            x,
+            y: ys[sampleIndex],
+            featureValue,
+            colorValue: null,
+            color: BEESWARM_MISSING_COLOR
+          };
+        }
+        const colorValue = Math.max(vmin, Math.min(vmax, featureValue));
+        const normalized = colorSpan === 0 ? 0 : (colorValue - vmin) / colorSpan;
+        return {
+          sampleIndex,
+          x,
+          y: ys[sampleIndex],
+          featureValue,
+          colorValue,
+          color: sampleColormap("red_blue", normalized)
+        };
+      })
+    };
+  });
+  return { rows, collapsedCount: display.collapsedCount };
+}
+function beeswarmXAxis(min, max, toX, marginLeft, plotWidth, plotBottom) {
+  const { ticks, step } = niceTicks(min, max, tickSpace(plotWidth, TICK_LABEL_PT3));
+  return {
+    xTicks: ticks.map((value) => ({ value, x: toX(value), label: tickLabel(value, step) })),
+    xSpine: { x1: marginLeft, x2: marginLeft + plotWidth, y: plotBottom },
+    xTitle: {
+      // _labels.py:5, labels["VALUE"].
+      text: "SHAP value (impact on model output)",
+      x: marginLeft + plotWidth / 2,
+      y: plotBottom + AXIS_TITLE_DY,
+      fontSize: TITLE_PT2
+    }
+  };
+}
+function beeswarmLayout(valueRows, opts) {
+  const { width, rowHeight, marginLeft, marginRight, marginTop, dotRadius } = opts;
+  const plotWidth = width - marginLeft - marginRight;
+  const values = valueRows.rows.flatMap((row) => row.points.map((point) => point.x));
+  const dataMin = Math.min(0, ...values);
+  const dataMax = Math.max(0, ...values);
+  const margin = (dataMax - dataMin) * X_MARGIN2;
+  const min = dataMin - margin;
+  const max = dataMax + margin;
+  const span = max - min || 1;
+  const toX = (value) => marginLeft + (value - min) / span * plotWidth;
+  const highestRowIndex = Math.max(0, valueRows.rows.length - 1);
+  const rows = valueRows.rows.map((row) => {
+    const centerY = marginTop + (highestRowIndex - row.rowIndex + 0.5) * rowHeight;
+    return {
+      ...row,
+      centerY,
+      points: row.points.map((point) => ({
+        ...point,
+        valueX: point.x,
+        valueY: point.y,
+        x: toX(point.x),
+        y: centerY - (point.y - row.rowIndex) * rowHeight,
+        radius: dotRadius
+      }))
+    };
+  });
+  const plotBottom = marginTop + valueRows.rows.length * rowHeight;
+  return {
+    rows,
+    xDomain: [min, max],
+    xZero: toX(0),
+    ...beeswarmXAxis(min, max, toX, marginLeft, plotWidth, plotBottom),
+    plotWidth,
+    plotBottom,
+    height: plotBottom + AXIS_HEIGHT3
+  };
+}
+
+// src/core/heatmapLayout.ts
+var FX_TOP = 8;
+var FX_BOTTOM_GAP = 12;
+var SEPARATOR_GAP = 4;
+var SIDE_BAR_GAP = 10;
+var SIDE_BAR_RIGHT_INSET = 40;
+var SIDE_BAR_HEIGHT_RATIO = 0.6;
+var AXIS_HEIGHT4 = 52;
+var TICK_LABEL_PT4 = 10;
+var Y_TICK_LENGTH = 5;
+function percentile2(values, fraction) {
+  if (values.length === 0) return 0;
+  const sorted = [...values].sort((a, b) => a - b);
+  const position = (sorted.length - 1) * fraction;
+  const lower = Math.floor(position);
+  const upper = Math.ceil(position);
+  const weight = position - lower;
+  return sorted[lower] + (sorted[upper] - sorted[lower]) * weight;
+}
+function heatmapRows(explanation, maxDisplay, faithfulOtherRow, rowSort = "importance") {
+  if (!Number.isInteger(maxDisplay) || maxDisplay <= 0) {
+    throw new RangeError(`maxDisplay must be a positive integer, received ${maxDisplay}`);
+  }
+  const importance = globalImportance(explanation);
+  const featureOrder = orderFeatures(importance);
+  const display = sortDisplayRows(
+    collapseToDisplay(
+      explanation.featureNames,
+      importance,
+      featureOrder,
+      maxDisplay,
+      faithfulOtherRow
+    ),
+    rowSort,
+    explanation.data
+  );
+  const displayedFeatures = new Set(
+    display.rows.flatMap((row) => row.featureIndex === null ? [] : [row.featureIndex])
+  );
+  const collapsedFeatures = featureOrder.filter((index) => !displayedFeatures.has(index));
+  const columns = explanation.values.map((sample, sampleIndex) => {
+    var _a, _b;
+    return {
+      sampleIndex,
+      sampleId: (_a = explanation.sampleIds) == null ? void 0 : _a[sampleIndex],
+      sampleLabel: (_b = explanation.sampleLabels) == null ? void 0 : _b[sampleIndex],
+      total: sample.reduce((sum, value) => sum + value, 0)
+    };
+  }).sort((a, b) => b.total - a.total || a.sampleIndex - b.sampleIndex);
+  const uncolouredRows = display.rows.map((displayRow) => {
+    const featureIndices = displayRow.featureIndex === null ? collapsedFeatures : [displayRow.featureIndex];
+    return {
+      displayRow,
+      cells: columns.map((column) => ({
+        sampleIndex: column.sampleIndex,
+        value: featureIndices.reduce(
+          (sum, featureIndex) => sum + explanation.values[column.sampleIndex][featureIndex],
+          0
+        )
+      }))
+    };
+  });
+  const allCells = uncolouredRows.flatMap((row) => row.cells.map((cell) => cell.value));
+  const lower = percentile2(allCells, 0.01);
+  const upper = percentile2(allCells, 0.99);
+  const limit = Math.max(-lower, upper, 0);
+  const vmin = limit === 0 ? 0 : -limit;
+  const vmax = limit;
+  const largestImportance = Math.max(0, ...display.rows.map((row) => row.value));
+  const rows = uncolouredRows.map(({ displayRow, cells }) => ({
+    label: displayRow.label,
+    featureIndex: displayRow.featureIndex,
+    isOtherRow: displayRow.isOtherRow,
+    importance: displayRow.value,
+    sideBarValue: largestImportance === 0 ? 0 : displayRow.value / largestImportance,
+    cells: cells.map((cell) => {
+      const colorValue = limit === 0 ? 0 : Math.max(-limit, Math.min(limit, cell.value));
+      const normalized = limit === 0 ? 0.5 : (colorValue + limit) / (2 * limit);
+      return {
+        ...cell,
+        colorValue,
+        color: sampleColormap("red_white_blue", normalized)
+      };
+    })
+  }));
+  return {
+    rows,
+    columns,
+    fxLine: columns.map((column) => column.total),
+    vmin,
+    vmax,
+    collapsedCount: display.collapsedCount,
+    sampleLabelColumn: explanation.sampleLabelColumn
+  };
+}
+function heatmapXAxis(sampleCount, marginLeft, cellWidth, plotWidth, plotBottom) {
+  const { ticks, step } = niceTicks(
+    -0.5,
+    sampleCount - 0.5,
+    tickSpace(plotWidth, TICK_LABEL_PT4),
+    { integer: true }
+  );
+  return {
+    xTicks: ticks.map((value) => ({
+      value,
+      x: marginLeft + (value + 0.5) * cellWidth,
+      label: tickLabel(value, step)
+    })),
+    xSpine: null,
+    xTitle: {
+      text: "Instances",
+      x: marginLeft + plotWidth / 2,
+      y: plotBottom + AXIS_TITLE_DY,
+      fontSize: TICK_LABEL_PT4
+    }
+  };
+}
+function heatmapLayout(valueRows, opts) {
+  const { width, rowHeight, marginLeft, marginRight, marginTop } = opts;
+  const plotWidth = width - marginLeft - marginRight;
+  const cellWidth = valueRows.columns.length === 0 ? 0 : plotWidth / valueRows.columns.length;
+  const gridRight = marginLeft + plotWidth;
+  const plotBottom = marginTop + valueRows.rows.length * rowHeight;
+  const sideBarWidth = Math.max(0, marginRight - SIDE_BAR_RIGHT_INSET - SIDE_BAR_GAP);
+  const columns = valueRows.columns.map((column, index) => ({
+    ...column,
+    x: marginLeft + index * cellWidth,
+    centerX: marginLeft + (index + 0.5) * cellWidth,
+    width: cellWidth
+  }));
+  const rows = valueRows.rows.map((row, rowIndex) => {
+    const y = marginTop + rowIndex * rowHeight;
+    const centerY = y + rowHeight / 2;
+    const barHeight = rowHeight * SIDE_BAR_HEIGHT_RATIO;
+    return {
+      ...row,
+      centerY,
+      cells: row.cells.map((cell, columnIndex) => ({
+        ...cell,
+        x: marginLeft + columnIndex * cellWidth,
+        y,
+        width: cellWidth,
+        height: rowHeight
+      })),
+      sideBar: {
+        value: row.sideBarValue,
+        x: gridRight + SIDE_BAR_GAP,
+        y: centerY - barHeight / 2,
+        width: row.sideBarValue * sideBarWidth,
+        height: barHeight
+      }
+    };
+  });
+  const fxMin = Math.min(0, ...valueRows.fxLine);
+  const fxMax = Math.max(0, ...valueRows.fxLine);
+  const fxSpan = fxMax - fxMin || 1;
+  const fxBottom = Math.max(FX_TOP, marginTop - FX_BOTTOM_GAP);
+  const toY = (value) => FX_TOP + (fxMax - value) / fxSpan * (fxBottom - FX_TOP);
+  const fxLine = columns.map((column, index) => ({
+    sampleIndex: column.sampleIndex,
+    sampleId: column.sampleId,
+    value: valueRows.fxLine[index],
+    x: column.centerX,
+    y: toY(valueRows.fxLine[index])
+  }));
+  const axisValues = [fxMax, 0, fxMin].filter(
+    (value, index, values) => values.indexOf(value) === index
+  );
+  return {
+    rows,
+    columns,
+    fxLine,
+    fxAxisMarks: axisValues.map((value) => ({
+      value,
+      y: toY(value),
+      label: formatShapValue(value)
+    })),
+    fxDomain: [fxMin, fxMax],
+    separatorY: marginTop - SEPARATOR_GAP,
+    gridLeft: marginLeft,
+    gridRight,
+    gridTop: marginTop,
+    plotBottom,
+    spines: {
+      left: { x: marginLeft, y1: marginTop, y2: plotBottom },
+      right: { x: gridRight, y1: marginTop, y2: plotBottom }
+    },
+    yTicks: rows.map((row) => ({
+      y: row.centerY,
+      x1: marginLeft - Y_TICK_LENGTH,
+      x2: marginLeft
+    })),
+    ...heatmapXAxis(valueRows.columns.length, marginLeft, cellWidth, plotWidth, plotBottom),
+    sampleLabelColumn: valueRows.sampleLabelColumn,
+    plotWidth,
+    cellWidth,
+    height: plotBottom + AXIS_HEIGHT4
+  };
+}
+
+export {
+  UnsupportedContractVersionError,
+  InvalidExplanationError,
+  genusOf,
+  groupByGenus,
+  aggregateByGenus,
+  groupExplanationByGenus,
+  sortDisplayRows,
+  parseExplanation,
+  globalImportance,
+  orderFeatures,
+  formatShapValue,
+  formatLevel,
+  formatFeatureLabel,
+  collapseToDisplay,
+  TICK_LENGTH,
+  TICK_LABEL_DY,
+  POSITIVE_COLOR,
+  NEGATIVE_COLOR,
+  barLayout,
+  WATERFALL_HEAD_LENGTH_PX,
+  WATERFALL_TICK_LABEL_DY,
+  WATERFALL_BASE_LABEL_DY,
+  waterfallRows,
+  waterfallLayout,
+  sampleColormap,
+  BEESWARM_MISSING_COLOR,
+  BEESWARM_ROW_HEIGHT,
+  beeswarmRows,
+  beeswarmLayout,
+  heatmapRows,
+  heatmapLayout
+};
+//# sourceMappingURL=chunk-OXFKP5I3.js.map