@photonviz/core 0.3.2 → 0.4.1

package/dist/index.js

@@ -5718,7 +5718,7 @@ var Plot = class {
     this.container.setAttribute("aria-label", this.ariaLabel ?? this.describe());
   }
   /**
-   * Register a layer built outside core (e.g. `@photonviz/map`). Use with
+   * Register a layer built outside core (a custom WebGL2 `Layer`). Use with
    * {@link context} to construct the layer against this plot's WebGL2 context.
    */
   add(layer) {
@@ -6559,7 +6559,7 @@ var Plot = class {
     const out = [];
     for (const l of this.layers) {
       const a = l;
-      if (typeof a.name === "string" && a.name && typeof a.colorCss === "string") {
+      if (typeof a.name === "string" && a.name && a.name !== a.id && typeof a.colorCss === "string") {
         out.push({ name: a.name, colorCss: a.colorCss });
       }
     }
@@ -11418,6 +11418,586 @@ function lttb(x, y, threshold) {
   return { x: sx, y: sy };
 }
 
+// src/ml/metrics.ts
+function confusionMatrix(yTrue, yPred, classes) {
+  const n = Math.min(yTrue.length, yPred.length);
+  let c = classes ?? 0;
+  if (!classes) {
+    for (let i = 0; i < n; i++) c = Math.max(c, (yTrue[i] | 0) + 1, (yPred[i] | 0) + 1);
+  }
+  c = Math.max(1, c);
+  const counts = new Float64Array(c * c);
+  for (let i = 0; i < n; i++) {
+    const t = yTrue[i] | 0, p = yPred[i] | 0;
+    if (t < 0 || t >= c || p < 0 || p >= c) continue;
+    counts[t * c + p] += 1;
+  }
+  const support = new Float64Array(c);
+  const normalized = new Float64Array(c * c);
+  for (let t = 0; t < c; t++) {
+    let s = 0;
+    for (let p = 0; p < c; p++) s += counts[t * c + p];
+    support[t] = s;
+    if (s > 0) for (let p = 0; p < c; p++) normalized[t * c + p] = counts[t * c + p] / s;
+  }
+  return { counts, normalized, support, classes: c };
+}
+function argsortDesc(scores, n) {
+  const idx = new Array(n);
+  for (let i = 0; i < n; i++) idx[i] = i;
+  idx.sort((a, b) => scores[b] - scores[a]);
+  return idx;
+}
+function rocCurve(scores, labels) {
+  const n = Math.min(scores.length, labels.length);
+  let P = 0, N = 0;
+  for (let i = 0; i < n; i++) labels[i] ? P++ : N++;
+  const idx = argsortDesc(scores, n);
+  const fpr = [0], tpr = [0], thr = [Infinity];
+  let tp = 0, fp = 0, prevF = 0, prevT = 0, auc = 0;
+  for (let i = 0; i < n; ) {
+    const t = scores[idx[i]];
+    while (i < n && scores[idx[i]] === t) {
+      labels[idx[i]] ? tp++ : fp++;
+      i++;
+    }
+    const f = N ? fp / N : 0, tr = P ? tp / P : 0;
+    auc += (f - prevF) * (tr + prevT) / 2;
+    fpr.push(f);
+    tpr.push(tr);
+    thr.push(t);
+    prevF = f;
+    prevT = tr;
+  }
+  return {
+    fpr: Float64Array.from(fpr),
+    tpr: Float64Array.from(tpr),
+    thresholds: Float64Array.from(thr),
+    auc: P && N ? auc : NaN
+  };
+}
+function prCurve(scores, labels) {
+  const n = Math.min(scores.length, labels.length);
+  let P = 0;
+  for (let i = 0; i < n; i++) if (labels[i]) P++;
+  const idx = argsortDesc(scores, n);
+  const recall = [0], precision = [1], thr = [Infinity];
+  let tp = 0, fp = 0, prevR = 0, ap = 0;
+  for (let i = 0; i < n; ) {
+    const t = scores[idx[i]];
+    while (i < n && scores[idx[i]] === t) {
+      labels[idx[i]] ? tp++ : fp++;
+      i++;
+    }
+    const r = P ? tp / P : 0, p = tp + fp ? tp / (tp + fp) : 1;
+    ap += (r - prevR) * p;
+    recall.push(r);
+    precision.push(p);
+    thr.push(t);
+    prevR = r;
+  }
+  return {
+    recall: Float64Array.from(recall),
+    precision: Float64Array.from(precision),
+    thresholds: Float64Array.from(thr),
+    ap: P ? ap : NaN,
+    baseline: n ? P / n : 0
+  };
+}
+function calibrationCurve(scores, labels, bins = 10) {
+  const b = Math.max(1, bins | 0);
+  const n = Math.min(scores.length, labels.length);
+  const sumScore = new Float64Array(b), sumLabel = new Float64Array(b), count = new Float64Array(b);
+  for (let i = 0; i < n; i++) {
+    const s = scores[i];
+    if (!Number.isFinite(s)) continue;
+    let k = Math.floor(s * b);
+    if (k >= b) k = b - 1;
+    if (k < 0) k = 0;
+    sumScore[k] += s;
+    sumLabel[k] += labels[i] ? 1 : 0;
+    count[k] += 1;
+  }
+  const meanPredicted = new Float64Array(b), fractionPositive = new Float64Array(b);
+  let ece = 0;
+  for (let k = 0; k < b; k++) {
+    if (count[k] > 0) {
+      const conf = sumScore[k] / count[k], acc = sumLabel[k] / count[k];
+      meanPredicted[k] = conf;
+      fractionPositive[k] = acc;
+      ece += count[k] / Math.max(1, n) * Math.abs(acc - conf);
+    } else {
+      meanPredicted[k] = NaN;
+      fractionPositive[k] = NaN;
+    }
+  }
+  return { meanPredicted, fractionPositive, binCount: count, ece };
+}
+function emaSmooth(values, weight = 0.6) {
+  const w = Math.min(0.999999, Math.max(0, weight));
+  const n = values.length;
+  const out = new Float64Array(n);
+  let last = 0, num = 0;
+  for (let i = 0; i < n; i++) {
+    const v = values[i];
+    if (!Number.isFinite(v)) {
+      out[i] = v;
+      continue;
+    }
+    last = last * w + (1 - w) * v;
+    num++;
+    out[i] = last / (1 - Math.pow(w, num));
+  }
+  return out;
+}
+
+// src/ml/reduce.ts
+function standardize(data, n, d) {
+  const out = new Float64Array(n * d);
+  for (let j = 0; j < d; j++) {
+    let mean = 0;
+    for (let i = 0; i < n; i++) mean += data[i * d + j];
+    mean /= Math.max(1, n);
+    let varsum = 0;
+    for (let i = 0; i < n; i++) {
+      const dv = data[i * d + j] - mean;
+      varsum += dv * dv;
+    }
+    const sd = Math.sqrt(varsum / Math.max(1, n - 1)) || 1;
+    for (let i = 0; i < n; i++) out[i * d + j] = (data[i * d + j] - mean) / sd;
+  }
+  return out;
+}
+function pca(data, n, d, k = 2) {
+  k = Math.max(1, Math.min(k, d));
+  const mean = new Float64Array(d);
+  for (let i = 0; i < n; i++) for (let j = 0; j < d; j++) mean[j] += data[i * d + j];
+  for (let j = 0; j < d; j++) mean[j] /= Math.max(1, n);
+  const Xc = new Float64Array(n * d);
+  for (let i = 0; i < n; i++) for (let j = 0; j < d; j++) Xc[i * d + j] = data[i * d + j] - mean[j];
+  const cov = new Float64Array(d * d);
+  const denom = Math.max(1, n - 1);
+  for (let i = 0; i < n; i++) {
+    const row = i * d;
+    for (let a = 0; a < d; a++) {
+      const xa = Xc[row + a];
+      if (xa === 0) continue;
+      for (let b = a; b < d; b++) cov[a * d + b] += xa * Xc[row + b];
+    }
+  }
+  let totalVar = 0;
+  for (let a = 0; a < d; a++) {
+    for (let b = a; b < d; b++) {
+      const v2 = cov[a * d + b] / denom;
+      cov[a * d + b] = v2;
+      cov[b * d + a] = v2;
+    }
+    totalVar += cov[a * d + a];
+  }
+  const components = new Float64Array(k * d);
+  const explained = new Float64Array(k);
+  const v = new Float64Array(d), w = new Float64Array(d);
+  for (let c = 0; c < k; c++) {
+    for (let j = 0; j < d; j++) v[j] = Math.sin(1 + j * (c + 1)) + 0.5;
+    normalize3(v, d);
+    let eig = 0;
+    for (let iter = 0; iter < 256; iter++) {
+      for (let a = 0; a < d; a++) {
+        let s = 0;
+        const ra = a * d;
+        for (let b = 0; b < d; b++) s += cov[ra + b] * v[b];
+        w[a] = s;
+      }
+      const norm2 = normalize3(w, d);
+      let dot = 0;
+      for (let a = 0; a < d; a++) dot += w[a] * v[a];
+      for (let a = 0; a < d; a++) v[a] = w[a];
+      if (Math.abs(Math.abs(dot) - 1) < 1e-9) {
+        eig = norm2;
+        break;
+      }
+      eig = norm2;
+    }
+    for (let j = 0; j < d; j++) components[c * d + j] = v[j];
+    explained[c] = totalVar > 0 ? eig / totalVar : 0;
+    for (let a = 0; a < d; a++) {
+      const va = eig * v[a];
+      for (let b = 0; b < d; b++) cov[a * d + b] -= va * v[b];
+    }
+  }
+  const scores = new Float64Array(n * k);
+  for (let i = 0; i < n; i++) {
+    const row = i * d;
+    for (let c = 0; c < k; c++) {
+      let s = 0;
+      const cr = c * d;
+      for (let j = 0; j < d; j++) s += Xc[row + j] * components[cr + j];
+      scores[i * k + c] = s;
+    }
+  }
+  return { scores, components, explained, mean, n, d, k };
+}
+function normalize3(vec, d) {
+  let s = 0;
+  for (let j = 0; j < d; j++) s += vec[j] * vec[j];
+  const norm2 = Math.sqrt(s);
+  if (norm2 > 0) for (let j = 0; j < d; j++) vec[j] /= norm2;
+  return norm2;
+}
+
+// src/ml/charts.ts
+var ML_PALETTE = [
+  "#4e79a7",
+  "#f28e2b",
+  "#e15759",
+  "#76b7b2",
+  "#59a14f",
+  "#edc948",
+  "#b07aa1",
+  "#ff9da7",
+  "#9c755f",
+  "#bab0ac"
+];
+function addConfusionMatrix(plot, opts) {
+  const cm = confusionMatrix(opts.yTrue, opts.yPred, opts.classes);
+  const C = cm.classes;
+  const src = opts.normalize ? cm.normalized : cm.counts;
+  const values = new Float64Array(C * C);
+  for (let hr = 0; hr < C; hr++) {
+    const t = C - 1 - hr;
+    for (let p = 0; p < C; p++) values[hr * C + p] = src[t * C + p];
+  }
+  const heatmap = plot.addHeatmap({
+    values,
+    cols: C,
+    rows: C,
+    extent: { x: [0, C], y: [0, C] },
+    colormap: opts.colormap ?? "viridis"
+  });
+  if (opts.annotate ?? true) {
+    let maxV = 0;
+    for (let i = 0; i < src.length; i++) if (src[i] > maxV) maxV = src[i];
+    for (let hr = 0; hr < C; hr++) {
+      const t = C - 1 - hr;
+      for (let p = 0; p < C; p++) {
+        const text = opts.normalize ? src[t * C + p].toFixed(2) : String(cm.counts[t * C + p]);
+        const hot = maxV ? src[t * C + p] / maxV > 0.55 : false;
+        plot.addAnnotation({ type: "label", x: p + 0.5, y: hr + 0.5, text, align: "center", color: hot ? "#0b1020" : "#e5e7eb" });
+      }
+    }
+  }
+  return { heatmap, classes: C };
+}
+function addRocCurve(plot, opts) {
+  const roc = rocCurve(opts.scores, opts.labels);
+  const color = opts.color ?? "#60a5fa";
+  const area2 = opts.fill ? plot.addArea({ x: roc.fpr, y: roc.tpr, base: 0, color: withAlpha(color, 0.18) }) : void 0;
+  if (opts.showChance ?? true) {
+    plot.addAnnotation({ type: "line", x0: 0, y0: 0, x1: 1, y1: 1, color: "#8b93a7", width: 1, dash: [6, 6] });
+  }
+  const line = plot.addLine({
+    x: roc.fpr,
+    y: roc.tpr,
+    color,
+    width: 2,
+    name: opts.name ?? `ROC \xB7 AUC ${Number.isFinite(roc.auc) ? roc.auc.toFixed(3) : "\u2014"}`
+  });
+  return { line, area: area2, auc: roc.auc };
+}
+function addPrCurve(plot, opts) {
+  const pr = prCurve(opts.scores, opts.labels);
+  const color = opts.color ?? "#f472b6";
+  const area2 = opts.fill ? plot.addArea({ x: pr.recall, y: pr.precision, base: 0, color: withAlpha(color, 0.18) }) : void 0;
+  if (opts.showBaseline ?? true) {
+    plot.addAnnotation({ type: "line", x0: 0, y0: pr.baseline, x1: 1, y1: pr.baseline, color: "#8b93a7", width: 1, dash: [6, 6] });
+  }
+  const line = plot.addLine({
+    x: pr.recall,
+    y: pr.precision,
+    color,
+    width: 2,
+    name: opts.name ?? `PR \xB7 AP ${Number.isFinite(pr.ap) ? pr.ap.toFixed(3) : "\u2014"}`
+  });
+  return { line, area: area2, ap: pr.ap };
+}
+function addCalibration(plot, opts) {
+  const cal = calibrationCurve(opts.scores, opts.labels, opts.bins ?? 10);
+  const xs = [], ys = [];
+  for (let i = 0; i < cal.meanPredicted.length; i++) {
+    if (Number.isFinite(cal.meanPredicted[i])) {
+      xs.push(cal.meanPredicted[i]);
+      ys.push(cal.fractionPositive[i]);
+    }
+  }
+  plot.addAnnotation({ type: "line", x0: 0, y0: 0, x1: 1, y1: 1, color: "#8b93a7", width: 1, dash: [6, 6] });
+  const color = opts.color ?? "#34d399";
+  const line = plot.addLine({ x: xs, y: ys, color, width: 2, name: opts.name ?? `reliability \xB7 ECE ${cal.ece.toFixed(3)}` });
+  const points = plot.addScatter({ x: xs, y: ys, color, size: 7 });
+  return { line, points, ece: cal.ece };
+}
+function addEmbedding(plot, opts) {
+  const size = opts.size ?? 4;
+  if (opts.labels) {
+    return { layers: scatterByClass(plot, opts.x, opts.y, opts.labels, opts.classNames, opts.palette, size, opts.text, opts.renderType) };
+  }
+  if (opts.colorBy) {
+    return {
+      layers: [plot.addScatter({
+        x: opts.x,
+        y: opts.y,
+        size,
+        name: opts.name,
+        labels: opts.text,
+        renderType: opts.renderType,
+        colorBy: { values: opts.colorBy, colormap: opts.colormap ?? "viridis" }
+      })]
+    };
+  }
+  return { layers: [plot.addScatter({ x: opts.x, y: opts.y, size, color: (opts.palette ?? ML_PALETTE)[0], name: opts.name, labels: opts.text, renderType: opts.renderType })] };
+}
+function addDecisionBoundary(plot, opts) {
+  const heatmap = plot.addHeatmap({
+    values: opts.values,
+    cols: opts.cols,
+    rows: opts.rows,
+    extent: opts.extent,
+    colormap: opts.colormap ?? "viridis",
+    domain: opts.domain
+  });
+  const p = opts.points;
+  const points = p ? scatterByClass(plot, p.x, p.y, p.labels, p.classNames, p.palette, p.size ?? 5, void 0, void 0) : [];
+  return { heatmap, points };
+}
+function addFeatureImportance(plot, opts) {
+  const n = Math.min(opts.names.length, opts.values.length);
+  let order = Array.from({ length: n }, (_, i) => i);
+  if (opts.sort ?? true) order.sort((a, b) => Math.abs(opts.values[b]) - Math.abs(opts.values[a]));
+  if (opts.top && opts.top < order.length) order = order.slice(0, opts.top);
+  const m = order.length;
+  const ypos = new Float64Array(m), vals = new Float64Array(m);
+  for (let j = 0; j < m; j++) {
+    ypos[j] = m - 1 - j;
+    vals[j] = opts.values[order[j]];
+  }
+  const bars = plot.addBar({
+    x: ypos,
+    y: vals,
+    orientation: "h",
+    base: 0,
+    width: 0.72,
+    color: opts.color ?? "#60a5fa",
+    name: opts.name,
+    renderType: opts.renderType
+  });
+  if (opts.annotate ?? true) {
+    for (let j = 0; j < m; j++) {
+      plot.addAnnotation({ type: "label", x: 0, y: m - 1 - j, text: ` ${opts.names[order[j]]}`, align: "left", color: "#e5e7eb" });
+    }
+  }
+  return { bars, order };
+}
+function addShapBeeswarm(plot, opts) {
+  const f = Math.min(opts.values.length, opts.names.length);
+  const meanAbs = (row) => {
+    let s = 0;
+    for (const v of row) s += Math.abs(v);
+    return row.length ? s / row.length : 0;
+  };
+  const order = Array.from({ length: f }, (_, i) => i).sort((a, b) => meanAbs(opts.values[b]) - meanAbs(opts.values[a]));
+  const spread = opts.spread ?? 0.8;
+  const xs = [], ys = [], cs = [];
+  let minX = Infinity;
+  for (let band = 0; band < f; band++) {
+    const feat = order[f - 1 - band];
+    const row = opts.values[feat];
+    const offsets = beeswarmLayout(row, { spread });
+    const fv = opts.featureValues?.[feat];
+    for (let i = 0; i < row.length; i++) {
+      xs.push(row[i]);
+      ys.push(band + offsets[i]);
+      cs.push(fv ? fv[i] : 0);
+      if (row[i] < minX) minX = row[i];
+    }
+  }
+  const scatter = plot.addScatter({
+    x: xs,
+    y: ys,
+    size: opts.size ?? 4,
+    name: opts.name,
+    colorBy: { values: cs, colormap: opts.colormap ?? "coolwarm" }
+  });
+  if (Number.isFinite(minX)) {
+    for (let band = 0; band < f; band++) {
+      plot.addAnnotation({ type: "label", x: minX, y: band, text: `${opts.names[order[f - 1 - band]]} `, align: "right", color: "#e5e7eb" });
+    }
+  }
+  return { scatter, order };
+}
+function addPartialDependence(plot, opts) {
+  const ice = (opts.ice ?? []).map((row) => plot.addLine({ x: opts.x, y: row, color: opts.iceColor ?? "rgba(148,163,184,0.25)", width: 1, renderType: opts.renderType }));
+  const pd = plot.addLine({ x: opts.x, y: opts.pd, color: opts.color ?? "#f59e0b", width: 2.5, name: opts.name ?? "PDP", renderType: opts.renderType });
+  return { pd, ice };
+}
+function addAttentionMap(plot, opts) {
+  let flat, Q, K;
+  if (Array.isArray(opts.weights) && Array.isArray(opts.weights[0])) {
+    const w = opts.weights;
+    Q = w.length;
+    K = w[0].length;
+    flat = new Float64Array(Q * K);
+    for (let q = 0; q < Q; q++) for (let k = 0; k < K; k++) flat[q * K + k] = w[q][k];
+  } else {
+    Q = opts.queries ?? 0;
+    K = opts.keys ?? 0;
+    flat = Float64Array.from(opts.weights);
+  }
+  const values = new Float64Array(Q * K);
+  for (let hr = 0; hr < Q; hr++) for (let k = 0; k < K; k++) values[hr * K + k] = flat[(Q - 1 - hr) * K + k];
+  const heatmap = plot.addHeatmap({
+    values,
+    cols: K,
+    rows: Q,
+    extent: { x: [0, K], y: [0, Q] },
+    colormap: opts.colormap ?? "viridis"
+  });
+  if (opts.annotate) {
+    for (let hr = 0; hr < Q; hr++) for (let k = 0; k < K; k++) {
+      plot.addAnnotation({ type: "label", x: k + 0.5, y: hr + 0.5, text: flat[(Q - 1 - hr) * K + k].toFixed(2), align: "center", color: "#e5e7eb" });
+    }
+  }
+  return { heatmap, queries: Q, keys: K };
+}
+function addTrainingCurves(plot, opts) {
+  const palette = opts.palette ?? ML_PALETTE;
+  const smoothing = opts.smoothing ?? 0.6;
+  const width = opts.width ?? 2;
+  const raw = [], smoothed = [];
+  opts.series.forEach((s, i) => {
+    const n = s.y.length;
+    const x = s.x ?? Float64Array.from({ length: n }, (_, j) => j);
+    const color = s.color ?? palette[i % palette.length];
+    if (smoothing > 0) {
+      if (opts.showRaw ?? true) raw.push(plot.addLine({ x, y: s.y, color: withAlpha(color, 0.25), width: 1, renderType: opts.renderType }));
+      smoothed.push(plot.addLine({ x, y: emaSmooth(s.y, smoothing), color, width, name: s.name, renderType: opts.renderType }));
+    } else {
+      smoothed.push(plot.addLine({ x, y: s.y, color, width, name: s.name, renderType: opts.renderType }));
+    }
+    if (opts.best) {
+      let bi = -1, bv = opts.best === "min" ? Infinity : -Infinity;
+      for (let j = 0; j < n; j++) {
+        const v = s.y[j];
+        if (!Number.isFinite(v)) continue;
+        if (opts.best === "min" ? v < bv : v > bv) {
+          bv = v;
+          bi = j;
+        }
+      }
+      if (bi >= 0) plot.addAnnotation({ type: "label", x: x[bi], y: bv, text: `${s.name ? s.name + " " : ""}${bv.toFixed(3)}`, align: "center", color });
+    }
+  });
+  return { raw, smoothed };
+}
+function addRidgeline(plot, opts) {
+  const g = opts.groups;
+  let lo = opts.range?.[0] ?? Infinity, hi = opts.range?.[1] ?? -Infinity;
+  if (!opts.range) {
+    for (const grp of g) for (let i = 0; i < grp.values.length; i++) {
+      const v = grp.values[i];
+      if (v < lo) lo = v;
+      if (v > hi) hi = v;
+    }
+  }
+  if (!Number.isFinite(lo) || !Number.isFinite(hi) || lo === hi) {
+    lo = (lo || 0) - 1;
+    hi = (hi || 0) + 1;
+  }
+  const points = opts.points ?? 96;
+  const palette = opts.palette ?? ML_PALETTE;
+  const height = 1 + Math.max(0, opts.overlap ?? 1);
+  const areas = [], lines = [];
+  g.forEach((grp, i) => {
+    const dens = kde(grp.values, lo, hi, points);
+    let peak = 0;
+    for (let j = 0; j < dens.ys.length; j++) if (dens.ys[j] > peak) peak = dens.ys[j];
+    const scale = peak > 0 ? height / peak : 0;
+    const y = new Float64Array(dens.ys.length);
+    for (let j = 0; j < y.length; j++) y[j] = i + dens.ys[j] * scale;
+    const color = palette[i % palette.length];
+    if (opts.fill ?? true) areas.push(plot.addArea({ x: dens.xs, y, base: i, color: withAlpha(color, 0.55) }));
+    lines.push(plot.addLine({ x: dens.xs, y, color, width: 1.5 }));
+    if (grp.label) plot.addAnnotation({ type: "label", x: lo, y: i + 0.05, text: `${grp.label} `, align: "right", color: "#e5e7eb" });
+  });
+  return { areas, lines };
+}
+function beeswarmLayout(x, opts = {}) {
+  const n = x.length;
+  const spread = opts.spread ?? 0.8;
+  const y = new Array(n).fill(0);
+  if (!n) return y;
+  let lo = Infinity, hi = -Infinity;
+  for (let i = 0; i < n; i++) {
+    const v = x[i];
+    if (v < lo) lo = v;
+    if (v > hi) hi = v;
+  }
+  const width = hi - lo || 1;
+  const bins = Math.max(1, opts.bins ?? Math.min(64, Math.round(Math.sqrt(n))));
+  const buckets = Array.from({ length: bins }, () => []);
+  for (let i = 0; i < n; i++) {
+    let b = Math.floor((x[i] - lo) / width * bins);
+    if (b >= bins) b = bins - 1;
+    if (b < 0) b = 0;
+    buckets[b].push(i);
+  }
+  let maxCount = 1;
+  for (const arr of buckets) if (arr.length > maxCount) maxCount = arr.length;
+  const denom = Math.max(1, maxCount);
+  for (const arr of buckets) {
+    const m = arr.length;
+    for (let j = 0; j < m; j++) {
+      const off = j - (m - 1) / 2;
+      y[arr[j]] = off / denom * spread;
+    }
+  }
+  return y;
+}
+function scatterByClass(plot, x, y, labels, classNames, palette = ML_PALETTE, size = 4, text, renderType) {
+  const n = Math.min(x.length, y.length);
+  if (!labels) return [plot.addScatter({ x, y, size, color: palette[0], labels: text, renderType })];
+  const keys = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (let i = 0; i < n; i++) {
+    const k = labels[i];
+    const sk = String(k);
+    if (!seen.has(sk)) {
+      seen.add(sk);
+      keys.push(k);
+    }
+  }
+  if (keys.every((k) => typeof k === "number")) keys.sort((a, b) => a - b);
+  const layers = [];
+  keys.forEach((key, ci) => {
+    const sx = [], sy = [], st = [];
+    for (let i = 0; i < n; i++) {
+      if (String(labels[i]) !== String(key)) continue;
+      sx.push(x[i]);
+      sy.push(y[i]);
+      if (text) st.push(String(text[i]));
+    }
+    const name = classNames && typeof key === "number" ? classNames[key] ?? String(key) : String(key);
+    layers.push(plot.addScatter({ x: sx, y: sy, size, color: palette[ci % palette.length], name, labels: text ? st : void 0, renderType }));
+  });
+  return layers;
+}
+function withAlpha(color, alpha) {
+  const hex = /^#([0-9a-f]{6})$/i.exec(color);
+  if (hex) {
+    const v = parseInt(hex[1], 16);
+    return `rgba(${v >> 16 & 255}, ${v >> 8 & 255}, ${v & 255}, ${alpha})`;
+  }
+  return color;
+}
+
 // src/charts/treemap.ts
 var DEFAULT_EXTENT = { x: [0, 1], y: [0, 1] };
 var TREEMAP_PALETTE = [
@@ -12041,7 +12621,7 @@ function addChord(plot, opts) {
   const color = (i) => palette[i % palette.length];
   const patches = [];
   for (const rb of ribbons) {
-    patches.push({ x: rb.x, y: rb.y, color: withAlpha(color(rb.i), opacity) });
+    patches.push({ x: rb.x, y: rb.y, color: withAlpha2(color(rb.i), opacity) });
   }
   for (const arc of groupArcs) {
     patches.push({ x: arc.x, y: arc.y, color: color(arc.i) });
@@ -12082,7 +12662,7 @@ function addChord(plot, opts) {
   }
   return layer;
 }
-function withAlpha(color, alpha) {
+function withAlpha2(color, alpha) {
   const hex = /^#([0-9a-f]{6})$/i.exec(color);
   if (hex) {
     const v = parseInt(hex[1], 16);
@@ -12164,7 +12744,7 @@ function addParallelCoordinates(plot, opts) {
     (ln, r) => plot.addLine({
       x: ln.x,
       y: ln.y,
-      color: withAlpha2(rowColor(r), opacity),
+      color: withAlpha3(rowColor(r), opacity),
       width,
       name: r === 0 ? opts.name : void 0,
       renderType: opts.renderType
@@ -12176,7 +12756,7 @@ function addParallelCoordinates(plot, opts) {
   }
   return { lines: layers };
 }
-function withAlpha2(color, alpha) {
+function withAlpha3(color, alpha) {
   const hex = /^#([0-9a-f]{6})$/i.exec(color);
   if (hex) {
     const v = parseInt(hex[1], 16);
@@ -12206,6 +12786,7 @@ export {
   LineLayer,
   LinearScale,
   LogScale,
+  ML_PALETTE,
   OhlcLayer,
   OrdinalTimeScale,
   PARALLEL_PALETTE,
@@ -12225,28 +12806,43 @@ export {
   TREEMAP_PALETTE,
   TimeScale,
   VolumeLayer,
+  addAttentionMap,
   addBollinger,
+  addCalibration,
   addChord,
+  addConfusionMatrix,
+  addDecisionBoundary,
   addDepth,
+  addEmbedding,
+  addFeatureImportance,
   addFunnel,
   addGauge,
   addHeikinAshi,
   addParallelCoordinates,
+  addPartialDependence,
+  addPrCurve,
   addRenko,
+  addRidgeline,
+  addRocCurve,
   addSankey,
+  addShapBeeswarm,
   addSunburst,
+  addTrainingCurves,
   addTreemap,
   addVolumeProfile,
   adx,
   atr,
   autoTicks,
+  beeswarmLayout,
   bollinger,
   boxStats,
   bufferUsage,
+  calibrationCurve,
   canvasToBlob,
   chordLayout,
   colormap,
   colormapLUT,
+  confusionMatrix,
   copyCanvasToClipboard,
   createProgram,
   createToolbar,
@@ -12256,6 +12852,7 @@ export {
   downloadCanvas,
   earcut,
   ema,
+  emaSmooth,
   fft,
   fibRetracements,
   firstFinite,
@@ -12278,17 +12875,21 @@ export {
   parallelLayout,
   parseCSV,
   parseColor,
+  pca,
   pointAndFigure,
+  prCurve,
   quantileSorted,
   renko,
   resolveAxisStyle,
   resolveTicks,
+  rocCurve,
   rollingStd,
   rsi,
   sankeyLayout,
   setTransformUniforms,
   sma,
   spectrogram,
+  standardize,
   stochastic,
   sunburstLayout,
   superTrend,