deepbox 0.1.0

package/dist/chunk-ZXKBDFP3.js

@@ -0,0 +1,4235 @@
+import { tensor } from './chunk-BCR7G3A6.js';
+import { __export, InvalidParameterError, NotImplementedError, ShapeError, DTypeError } from './chunk-4S73VUBD.js';
+
+// src/plot/index.ts
+var plot_exports = {};
+__export(plot_exports, {
+  Axes: () => Axes,
+  Figure: () => Figure,
+  bar: () => bar,
+  barh: () => barh,
+  boxplot: () => boxplot,
+  contour: () => contour,
+  contourf: () => contourf,
+  figure: () => figure,
+  gca: () => gca,
+  heatmap: () => heatmap,
+  hist: () => hist,
+  imshow: () => imshow,
+  legend: () => legend,
+  pie: () => pie,
+  plot: () => plot,
+  plotConfusionMatrix: () => plotConfusionMatrix,
+  plotDecisionBoundary: () => plotDecisionBoundary,
+  plotLearningCurve: () => plotLearningCurve,
+  plotPrecisionRecallCurve: () => plotPrecisionRecallCurve,
+  plotRocCurve: () => plotRocCurve,
+  plotValidationCurve: () => plotValidationCurve,
+  saveFig: () => saveFig,
+  scatter: () => scatter,
+  show: () => show,
+  subplot: () => subplot,
+  violinplot: () => violinplot
+});
+
+// src/plot/utils/colors.ts
+var colorCache = /* @__PURE__ */ new Map();
+var namedColors = {
+  aliceblue: "#f0f8ff",
+  antiquewhite: "#faebd7",
+  aqua: "#00ffff",
+  aquamarine: "#7fffd4",
+  azure: "#f0ffff",
+  beige: "#f5f5dc",
+  bisque: "#ffe4c4",
+  black: "#000000",
+  blanchedalmond: "#ffebcd",
+  blue: "#0000ff",
+  blueviolet: "#8a2be2",
+  brown: "#a52a2a",
+  burlywood: "#deb887",
+  cadetblue: "#5f9ea0",
+  chartreuse: "#7fff00",
+  chocolate: "#d2691e",
+  coral: "#ff7f50",
+  cornflowerblue: "#6495ed",
+  cornsilk: "#fff8dc",
+  crimson: "#dc143c",
+  cyan: "#00ffff",
+  darkblue: "#00008b",
+  darkcyan: "#008b8b",
+  darkgoldenrod: "#b8860b",
+  darkgray: "#a9a9a9",
+  darkgrey: "#a9a9a9",
+  darkgreen: "#006400",
+  darkkhaki: "#bdb76b",
+  darkmagenta: "#8b008b",
+  darkolivegreen: "#556b2f",
+  darkorange: "#ff8c00",
+  darkorchid: "#9932cc",
+  darkred: "#8b0000",
+  darksalmon: "#e9967a",
+  darkseagreen: "#8fbc8f",
+  darkslateblue: "#483d8b",
+  darkslategray: "#2f4f4f",
+  darkslategrey: "#2f4f4f",
+  darkturquoise: "#00ced1",
+  darkviolet: "#9400d3",
+  deeppink: "#ff1493",
+  deepskyblue: "#00bfff",
+  dimgray: "#696969",
+  dimgrey: "#696969",
+  dodgerblue: "#1e90ff",
+  firebrick: "#b22222",
+  floralwhite: "#fffaf0",
+  forestgreen: "#228b22",
+  fuchsia: "#ff00ff",
+  gainsboro: "#dcdcdc",
+  ghostwhite: "#f8f8ff",
+  gold: "#ffd700",
+  goldenrod: "#daa520",
+  gray: "#808080",
+  grey: "#808080",
+  green: "#008000",
+  greenyellow: "#adff2f",
+  honeydew: "#f0fff0",
+  hotpink: "#ff69b4",
+  indianred: "#cd5c5c",
+  indigo: "#4b0082",
+  ivory: "#fffff0",
+  khaki: "#f0e68c",
+  lavender: "#e6e6fa",
+  lavenderblush: "#fff0f5",
+  lawngreen: "#7cfc00",
+  lemonchiffon: "#fffacd",
+  lightblue: "#add8e6",
+  lightcoral: "#f08080",
+  lightcyan: "#e0ffff",
+  lightgoldenrodyellow: "#fafad2",
+  lightgray: "#d3d3d3",
+  lightgrey: "#d3d3d3",
+  lightgreen: "#90ee90",
+  lightpink: "#ffb6c1",
+  lightsalmon: "#ffa07a",
+  lightseagreen: "#20b2aa",
+  lightskyblue: "#87cefa",
+  lightslategray: "#778899",
+  lightslategrey: "#778899",
+  lightsteelblue: "#b0c4de",
+  lightyellow: "#ffffe0",
+  lime: "#00ff00",
+  limegreen: "#32cd32",
+  linen: "#faf0e6",
+  magenta: "#ff00ff",
+  maroon: "#800000",
+  mediumaquamarine: "#66cdaa",
+  mediumblue: "#0000cd",
+  mediumorchid: "#ba55d3",
+  mediumpurple: "#9370db",
+  mediumseagreen: "#3cb371",
+  mediumslateblue: "#7b68ee",
+  mediumspringgreen: "#00fa9a",
+  mediumturquoise: "#48d1cc",
+  mediumvioletred: "#c71585",
+  midnightblue: "#191970",
+  mintcream: "#f5fffa",
+  mistyrose: "#ffe4e1",
+  moccasin: "#ffe4b5",
+  navajowhite: "#ffdead",
+  navy: "#000080",
+  oldlace: "#fdf5e6",
+  olive: "#808000",
+  olivedrab: "#6b8e23",
+  orange: "#ffa500",
+  orangered: "#ff4500",
+  orchid: "#da70d6",
+  palegoldenrod: "#eee8aa",
+  palegreen: "#98fb98",
+  paleturquoise: "#afeeee",
+  palevioletred: "#db7093",
+  papayawhip: "#ffefd5",
+  peachpuff: "#ffdab9",
+  peru: "#cd853f",
+  pink: "#ffc0cb",
+  plum: "#dda0dd",
+  powderblue: "#b0e0e6",
+  purple: "#800080",
+  rebeccapurple: "#663399",
+  red: "#ff0000",
+  rosybrown: "#bc8f8f",
+  royalblue: "#4169e1",
+  saddlebrown: "#8b4513",
+  salmon: "#fa8072",
+  sandybrown: "#f4a460",
+  seagreen: "#2e8b57",
+  seashell: "#fff5ee",
+  sienna: "#a0522d",
+  silver: "#c0c0c0",
+  skyblue: "#87ceeb",
+  slateblue: "#6a5acd",
+  slategray: "#708090",
+  slategrey: "#708090",
+  snow: "#fffafa",
+  springgreen: "#00ff7f",
+  steelblue: "#4682b4",
+  tan: "#d2b48c",
+  teal: "#008080",
+  thistle: "#d8bfd8",
+  tomato: "#ff6347",
+  turquoise: "#40e0d0",
+  violet: "#ee82ee",
+  wheat: "#f5deb3",
+  white: "#ffffff",
+  whitesmoke: "#f5f5f5",
+  yellow: "#ffff00",
+  yellowgreen: "#9acd32"
+};
+function normalizeColor(c, fallback) {
+  if (!c) return fallback;
+  const s = c.trim();
+  if (s.length === 0) return fallback;
+  const hex8 = s.match(/^#([0-9a-fA-F]{8})$/);
+  if (hex8 && hex8[1] !== void 0) {
+    return `#${hex8[1].toLowerCase()}`;
+  }
+  const rgba = parseHexColorToRGBA(s);
+  const r = rgba.r.toString(16).padStart(2, "0");
+  const g = rgba.g.toString(16).padStart(2, "0");
+  const b = rgba.b.toString(16).padStart(2, "0");
+  if (rgba.a === 255) {
+    return `#${r}${g}${b}`;
+  }
+  const a = rgba.a.toString(16).padStart(2, "0");
+  return `#${r}${g}${b}${a}`;
+}
+function parseHexColorToRGBA(c) {
+  const cached = colorCache.get(c);
+  if (cached) return cached;
+  const s = c.trim().toLowerCase();
+  const clampByte = (value) => {
+    if (!Number.isFinite(value)) return 0;
+    return Math.min(255, Math.max(0, Math.round(value)));
+  };
+  const clampAlpha = (value) => {
+    if (!Number.isFinite(value)) return 1;
+    return Math.min(1, Math.max(0, value));
+  };
+  if (namedColors[s]) {
+    const namedColor = namedColors[s];
+    if (typeof namedColor === "string") {
+      const result3 = parseHexColorToRGBA(namedColor);
+      colorCache.set(c, result3);
+      return result3;
+    }
+    const result2 = { r: 0, g: 0, b: 0, a: 255 };
+    colorCache.set(c, result2);
+    return result2;
+  }
+  if (s.startsWith("#")) {
+    const hex = s.slice(1);
+    if (hex.length === 6 || hex.length === 8) {
+      const r = Number.parseInt(hex.slice(0, 2), 16);
+      const g = Number.parseInt(hex.slice(2, 4), 16);
+      const b = Number.parseInt(hex.slice(4, 6), 16);
+      const a = hex.length === 8 ? Number.parseInt(hex.slice(6, 8), 16) : 255;
+      if (Number.isFinite(r) && Number.isFinite(g) && Number.isFinite(b) && Number.isFinite(a)) {
+        const result2 = { r, g, b, a };
+        colorCache.set(c, result2);
+        return result2;
+      }
+    }
+  }
+  const rgbMatch = s.match(/^rgba?\s*\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*(?:,\s*([\d.]+)\s*)?\)$/);
+  if (rgbMatch) {
+    const rStr = rgbMatch[1];
+    const gStr = rgbMatch[2];
+    const bStr = rgbMatch[3];
+    if (!rStr || !gStr || !bStr) {
+      const result3 = { r: 0, g: 0, b: 0, a: 255 };
+      colorCache.set(c, result3);
+      return result3;
+    }
+    const r = clampByte(Number.parseInt(rStr, 10));
+    const g = clampByte(Number.parseInt(gStr, 10));
+    const b = clampByte(Number.parseInt(bStr, 10));
+    const alpha = rgbMatch[4] ? clampAlpha(Number.parseFloat(rgbMatch[4])) : 1;
+    const result2 = { r, g, b, a: Math.round(alpha * 255) };
+    colorCache.set(c, result2);
+    return result2;
+  }
+  const hslMatch = s.match(
+    /^hsla?\s*\(\s*([\d.]+)\s*,\s*([\d.]+)%\s*,\s*([\d.]+)%\s*(?:,\s*([\d.]+)\s*)?\)$/
+  );
+  if (hslMatch) {
+    const hRaw = hslMatch[1];
+    const sRaw = hslMatch[2];
+    const lRaw = hslMatch[3];
+    if (!hRaw || !sRaw || !lRaw) {
+      const result3 = { r: 0, g: 0, b: 0, a: 255 };
+      colorCache.set(c, result3);
+      return result3;
+    }
+    const hueDegrees = Number.parseFloat(hRaw);
+    const sat = Number.parseFloat(sRaw);
+    const light = Number.parseFloat(lRaw);
+    if (!Number.isFinite(hueDegrees) || !Number.isFinite(sat) || !Number.isFinite(light)) {
+      const result3 = { r: 0, g: 0, b: 0, a: 255 };
+      colorCache.set(c, result3);
+      return result3;
+    }
+    const h = (hueDegrees % 360 + 360) % 360 / 360;
+    const sl = Math.min(1, Math.max(0, sat / 100));
+    const l = Math.min(1, Math.max(0, light / 100));
+    const alpha = hslMatch[4] ? clampAlpha(Number.parseFloat(hslMatch[4])) : 1;
+    const hslToRgb = (h2, s2, l2) => {
+      let r2, g2, b2;
+      if (s2 === 0) {
+        r2 = g2 = b2 = l2;
+      } else {
+        const hue2rgb = (p2, q2, t) => {
+          if (t < 0) t += 1;
+          if (t > 1) t -= 1;
+          if (t < 1 / 6) return p2 + (q2 - p2) * 6 * t;
+          if (t < 1 / 2) return q2;
+          if (t < 2 / 3) return p2 + (q2 - p2) * (2 / 3 - t) * 6;
+          return p2;
+        };
+        const q = l2 < 0.5 ? l2 * (1 + s2) : l2 + s2 - l2 * s2;
+        const p = 2 * l2 - q;
+        r2 = hue2rgb(p, q, h2 + 1 / 3);
+        g2 = hue2rgb(p, q, h2);
+        b2 = hue2rgb(p, q, h2 - 1 / 3);
+      }
+      return [Math.round(r2 * 255), Math.round(g2 * 255), Math.round(b2 * 255)];
+    };
+    const [r, g, b] = hslToRgb(h, sl, l);
+    const result2 = {
+      r: clampByte(r),
+      g: clampByte(g),
+      b: clampByte(b),
+      a: Math.round(alpha * 255)
+    };
+    colorCache.set(c, result2);
+    return result2;
+  }
+  const result = { r: 0, g: 0, b: 0, a: 255 };
+  colorCache.set(c, result);
+  return result;
+}
+
+// src/plot/utils/legend.ts
+function normalizeLegendLabel(label) {
+  if (typeof label !== "string") return null;
+  const trimmed = label.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+function buildLegendEntry(label, entry) {
+  if (!label) return null;
+  return { label, ...entry };
+}
+
+// src/plot/utils/validation.ts
+function assertPositiveInt(name, v) {
+  if (!Number.isFinite(v)) {
+    throw new InvalidParameterError(`${name} must be a positive integer; received ${v}`, name, v);
+  }
+  if (v <= 0) {
+    throw new InvalidParameterError(`${name} must be a positive integer; received ${v}`, name, v);
+  }
+  if (Math.trunc(v) !== v) {
+    throw new InvalidParameterError(`${name} must be a positive integer; received ${v}`, name, v);
+  }
+}
+function isFiniteNumber(x) {
+  return Number.isFinite(x);
+}
+function clampInt(x, lo, hi) {
+  if (!Number.isFinite(x)) return lo;
+  if (x < lo) return lo;
+  if (x > hi) return hi;
+  return Math.trunc(x);
+}
+
+// src/plot/utils/xml.ts
+function escapeXml(s) {
+  return s.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&apos;");
+}
+
+// src/plot/plots/Bar2D.ts
+var Bar2D = class {
+  kind = "bar";
+  x;
+  height;
+  color;
+  edgecolor;
+  barWidth;
+  label;
+  constructor(x, height, options) {
+    if (x.length !== height.length) throw new ShapeError("x and height must have the same length");
+    this.x = x;
+    this.height = height;
+    this.color = normalizeColor(options.color, "#2ca02c");
+    this.edgecolor = normalizeColor(options.edgecolor, "#000000");
+    this.barWidth = 0.8;
+    this.label = normalizeLegendLabel(options.label);
+  }
+  getDataRange() {
+    let xmin = Number.POSITIVE_INFINITY;
+    let xmax = Number.NEGATIVE_INFINITY;
+    let ymin = 0;
+    let ymax = 0;
+    let sawValue = false;
+    for (let i = 0; i < this.x.length; i++) {
+      const xi = this.x[i] ?? 0;
+      const hi = this.height[i] ?? 0;
+      if (!isFiniteNumber(xi) || !isFiniteNumber(hi)) continue;
+      sawValue = true;
+      xmin = Math.min(xmin, xi - this.barWidth / 2);
+      xmax = Math.max(xmax, xi + this.barWidth / 2);
+      ymin = Math.min(ymin, hi);
+      ymax = Math.max(ymax, hi);
+    }
+    if (!sawValue || !Number.isFinite(xmin) || !Number.isFinite(xmax)) {
+      return null;
+    }
+    return { xmin, xmax, ymin, ymax };
+  }
+  drawSVG(ctx) {
+    for (let i = 0; i < this.x.length; i++) {
+      const xi = this.x[i] ?? 0;
+      const hi = this.height[i] ?? 0;
+      if (!isFiniteNumber(xi) || !isFiniteNumber(hi)) continue;
+      const x0 = ctx.transform.xToPx(xi - this.barWidth / 2);
+      const x1 = ctx.transform.xToPx(xi + this.barWidth / 2);
+      const y0 = ctx.transform.yToPx(0);
+      const y1 = ctx.transform.yToPx(hi);
+      const w = Math.abs(x1 - x0);
+      const h = Math.abs(y1 - y0);
+      const rx = Math.min(x0, x1);
+      const ry = Math.min(y0, y1);
+      ctx.push(
+        `<rect x="${rx.toFixed(2)}" y="${ry.toFixed(2)}" width="${w.toFixed(2)}" height="${h.toFixed(2)}" fill="${escapeXml(this.color)}" stroke="${escapeXml(this.edgecolor)}" />`
+      );
+    }
+  }
+  drawRaster(ctx) {
+    const rgba = parseHexColorToRGBA(this.color);
+    const edge = parseHexColorToRGBA(this.edgecolor);
+    for (let i = 0; i < this.x.length; i++) {
+      const xi = this.x[i] ?? 0;
+      const hi = this.height[i] ?? 0;
+      if (!isFiniteNumber(xi) || !isFiniteNumber(hi)) continue;
+      const x0 = Math.round(ctx.transform.xToPx(xi - this.barWidth / 2));
+      const x1 = Math.round(ctx.transform.xToPx(xi + this.barWidth / 2));
+      const y0 = Math.round(ctx.transform.yToPx(0));
+      const y1 = Math.round(ctx.transform.yToPx(hi));
+      const w = Math.abs(x1 - x0);
+      const h = Math.abs(y1 - y0);
+      const rx = Math.min(x0, x1);
+      const ry = Math.min(y0, y1);
+      ctx.canvas.fillRectRGBA(rx, ry, w, h, rgba.r, rgba.g, rgba.b, rgba.a);
+      const r_e = edge.r;
+      const g_e = edge.g;
+      const b_e = edge.b;
+      const a_e = edge.a;
+      ctx.canvas.drawLineRGBA(rx, ry, rx + w, ry, r_e, g_e, b_e, a_e);
+      ctx.canvas.drawLineRGBA(rx + w, ry, rx + w, ry + h, r_e, g_e, b_e, a_e);
+      ctx.canvas.drawLineRGBA(rx + w, ry + h, rx, ry + h, r_e, g_e, b_e, a_e);
+      ctx.canvas.drawLineRGBA(rx, ry + h, rx, ry, r_e, g_e, b_e, a_e);
+    }
+  }
+  getLegendEntries() {
+    const entry = buildLegendEntry(this.label, { color: this.color, shape: "box" });
+    return entry ? [entry] : null;
+  }
+};
+
+// src/plot/utils/statistics.ts
+function calculateQuartiles(sortedData) {
+  const n = sortedData.length;
+  if (n === 0) {
+    return { q1: 0, median: 0, q3: 0 };
+  }
+  if (n === 1) {
+    const val = sortedData[0] ?? 0;
+    return { q1: val, median: val, q3: val };
+  }
+  const medianOf = (arr, start, end) => {
+    const length = end - start;
+    if (length === 0) return 0;
+    if (length === 1) return arr[start] ?? 0;
+    const mid2 = start + Math.floor(length / 2);
+    if (length % 2 === 1) {
+      return arr[mid2] ?? 0;
+    } else {
+      return ((arr[mid2 - 1] ?? 0) + (arr[mid2] ?? 0)) / 2;
+    }
+  };
+  const mid = Math.floor(n / 2);
+  const median = n % 2 === 1 ? sortedData[mid] ?? 0 : ((sortedData[mid - 1] ?? 0) + (sortedData[mid] ?? 0)) / 2;
+  const q1 = medianOf(sortedData, 0, mid);
+  const q3 = medianOf(sortedData, n % 2 === 1 ? mid + 1 : mid, n);
+  return { q1, median, q3 };
+}
+function calculateWhiskers(sortedData, q1, q3) {
+  if (sortedData.length === 0) {
+    return { lowerWhisker: 0, upperWhisker: 0, outliers: [] };
+  }
+  const iqr = q3 - q1;
+  const lowerBound = q1 - 1.5 * iqr;
+  const upperBound = q3 + 1.5 * iqr;
+  const outliers = [];
+  let lowerWhisker = null;
+  let upperWhisker = null;
+  for (const value of sortedData) {
+    if (value < lowerBound || value > upperBound) {
+      outliers.push(value);
+    } else {
+      if (lowerWhisker === null) {
+        lowerWhisker = value;
+      }
+      upperWhisker = value;
+    }
+  }
+  if (lowerWhisker === null) {
+    lowerWhisker = q1;
+  }
+  if (upperWhisker === null) {
+    upperWhisker = q3;
+  }
+  return { lowerWhisker, upperWhisker, outliers };
+}
+function kernelDensityEstimation(data, points, bandwidth) {
+  const n = data.length;
+  const m = points.length;
+  const result = new Float64Array(m);
+  if (n === 0) {
+    return Array.from(result);
+  }
+  if (!Number.isFinite(bandwidth) || bandwidth <= 0) {
+    let sum = 0;
+    let sumSq = 0;
+    let min = Number.POSITIVE_INFINITY;
+    let max = Number.NEGATIVE_INFINITY;
+    for (let i = 0; i < n; i++) {
+      const v = data[i] ?? 0;
+      sum += v;
+      sumSq += v * v;
+      if (v < min) min = v;
+      if (v > max) max = v;
+    }
+    const mean = sum / n;
+    const variance = Math.max(0, sumSq / n - mean * mean);
+    const stdDev = Math.sqrt(variance);
+    const silverman = 1.06 * stdDev * n ** -0.2;
+    if (Number.isFinite(silverman) && silverman > 0) {
+      bandwidth = silverman;
+    } else {
+      const range = max - min;
+      bandwidth = Number.isFinite(range) && range > 0 ? range * 0.1 : 1;
+    }
+  }
+  if (!Number.isFinite(bandwidth) || bandwidth <= 0) {
+    bandwidth = 1;
+  }
+  const invSqrt2PiBandwidth = 1 / (bandwidth * Math.sqrt(2 * Math.PI));
+  for (let i = 0; i < m; i++) {
+    const x = points[i] ?? 0;
+    let sum = 0;
+    for (let j = 0; j < n; j++) {
+      const u = (x - (data[j] ?? 0)) / bandwidth;
+      sum += Math.exp(-0.5 * u * u);
+    }
+    result[i] = sum * invSqrt2PiBandwidth / n;
+  }
+  return Array.from(result);
+}
+
+// src/plot/plots/Boxplot.ts
+var Boxplot = class {
+  kind = "boxplot";
+  position;
+  q1;
+  median;
+  q3;
+  whiskerLow;
+  whiskerHigh;
+  outliers;
+  color;
+  edgecolor;
+  boxWidth;
+  label;
+  hasData;
+  constructor(position, data, options) {
+    this.position = position;
+    this.color = normalizeColor(options.color, "#8c564b");
+    this.edgecolor = normalizeColor(options.edgecolor, "#000000");
+    this.boxWidth = 0.5;
+    this.label = normalizeLegendLabel(options.label);
+    const sorted = Array.from(data).filter(isFiniteNumber).sort((a, b) => a - b);
+    const n = sorted.length;
+    if (n === 0) {
+      if (data.length > 0) {
+        throw new InvalidParameterError(
+          "boxplot data must contain at least one finite value",
+          "data",
+          data
+        );
+      }
+      this.hasData = false;
+      this.q1 = 0;
+      this.median = 0;
+      this.q3 = 0;
+      this.whiskerLow = 0;
+      this.whiskerHigh = 0;
+      this.outliers = [];
+      return;
+    }
+    this.hasData = true;
+    const { q1, median, q3 } = calculateQuartiles(sorted);
+    this.q1 = q1;
+    this.median = median;
+    this.q3 = q3;
+    const { lowerWhisker, upperWhisker, outliers } = calculateWhiskers(sorted, q1, q3);
+    this.whiskerLow = lowerWhisker;
+    this.whiskerHigh = upperWhisker;
+    this.outliers = outliers;
+  }
+  getDataRange() {
+    if (!this.hasData) return null;
+    let ymin = this.whiskerLow;
+    let ymax = this.whiskerHigh;
+    for (const o of this.outliers) {
+      if (o < ymin) ymin = o;
+      if (o > ymax) ymax = o;
+    }
+    return {
+      xmin: this.position - this.boxWidth,
+      xmax: this.position + this.boxWidth,
+      ymin,
+      ymax
+    };
+  }
+  drawSVG(ctx) {
+    if (!this.hasData) return;
+    const x = this.position;
+    const x0 = ctx.transform.xToPx(x - this.boxWidth / 2);
+    const x1 = ctx.transform.xToPx(x + this.boxWidth / 2);
+    const xc = ctx.transform.xToPx(x);
+    const yq1 = ctx.transform.yToPx(this.q1);
+    const ymed = ctx.transform.yToPx(this.median);
+    const yq3 = ctx.transform.yToPx(this.q3);
+    const ywl = ctx.transform.yToPx(this.whiskerLow);
+    const ywh = ctx.transform.yToPx(this.whiskerHigh);
+    ctx.push(
+      `<rect x="${Math.min(x0, x1).toFixed(2)}" y="${Math.min(yq1, yq3).toFixed(2)}" width="${Math.abs(x1 - x0).toFixed(2)}" height="${Math.abs(yq3 - yq1).toFixed(2)}" fill="${escapeXml(this.color)}" stroke="${escapeXml(this.edgecolor)}" />`
+    );
+    ctx.push(
+      `<line x1="${x0.toFixed(2)}" y1="${ymed.toFixed(2)}" x2="${x1.toFixed(2)}" y2="${ymed.toFixed(2)}" stroke="${escapeXml(this.edgecolor)}" stroke-width="2" />`
+    );
+    ctx.push(
+      `<line x1="${xc.toFixed(2)}" y1="${yq1.toFixed(2)}" x2="${xc.toFixed(2)}" y2="${ywl.toFixed(2)}" stroke="${escapeXml(this.edgecolor)}" />`
+    );
+    ctx.push(
+      `<line x1="${xc.toFixed(2)}" y1="${yq3.toFixed(2)}" x2="${xc.toFixed(2)}" y2="${ywh.toFixed(2)}" stroke="${escapeXml(this.edgecolor)}" />`
+    );
+    const capHalf = Math.abs(x1 - x0) / 4;
+    ctx.push(
+      `<line x1="${(xc - capHalf).toFixed(2)}" y1="${ywl.toFixed(2)}" x2="${(xc + capHalf).toFixed(2)}" y2="${ywl.toFixed(2)}" stroke="${escapeXml(this.edgecolor)}" />`
+    );
+    ctx.push(
+      `<line x1="${(xc - capHalf).toFixed(2)}" y1="${ywh.toFixed(2)}" x2="${(xc + capHalf).toFixed(2)}" y2="${ywh.toFixed(2)}" stroke="${escapeXml(this.edgecolor)}" />`
+    );
+    for (const outlier of this.outliers) {
+      const yo = ctx.transform.yToPx(outlier);
+      ctx.push(
+        `<circle cx="${xc.toFixed(2)}" cy="${yo.toFixed(2)}" r="3" fill="${escapeXml(this.edgecolor)}" stroke="none" />`
+      );
+    }
+  }
+  drawRaster(ctx) {
+    if (!this.hasData) return;
+    const rgba = parseHexColorToRGBA(this.color);
+    const edge = parseHexColorToRGBA(this.edgecolor);
+    const x = this.position;
+    const x0 = Math.round(ctx.transform.xToPx(x - this.boxWidth / 2));
+    const x1 = Math.round(ctx.transform.xToPx(x + this.boxWidth / 2));
+    const xc = Math.round(ctx.transform.xToPx(x));
+    const yq1 = Math.round(ctx.transform.yToPx(this.q1));
+    const ymed = Math.round(ctx.transform.yToPx(this.median));
+    const yq3 = Math.round(ctx.transform.yToPx(this.q3));
+    const ywl = Math.round(ctx.transform.yToPx(this.whiskerLow));
+    const ywh = Math.round(ctx.transform.yToPx(this.whiskerHigh));
+    const rx = Math.min(x0, x1);
+    const ry = Math.min(yq1, yq3);
+    const w = Math.abs(x1 - x0);
+    const h = Math.abs(yq3 - yq1);
+    ctx.canvas.fillRectRGBA(rx, ry, w, h, rgba.r, rgba.g, rgba.b, rgba.a);
+    ctx.canvas.drawLineRGBA(rx, ry, rx + w, ry, edge.r, edge.g, edge.b, edge.a);
+    ctx.canvas.drawLineRGBA(rx + w, ry, rx + w, ry + h, edge.r, edge.g, edge.b, edge.a);
+    ctx.canvas.drawLineRGBA(rx + w, ry + h, rx, ry + h, edge.r, edge.g, edge.b, edge.a);
+    ctx.canvas.drawLineRGBA(rx, ry + h, rx, ry, edge.r, edge.g, edge.b, edge.a);
+    ctx.canvas.drawLineRGBA(x0, ymed, x1, ymed, edge.r, edge.g, edge.b, edge.a);
+    ctx.canvas.drawLineRGBA(xc, yq1, xc, ywl, edge.r, edge.g, edge.b, edge.a);
+    ctx.canvas.drawLineRGBA(xc, yq3, xc, ywh, edge.r, edge.g, edge.b, edge.a);
+    const capHalf = Math.round(Math.abs(x1 - x0) / 4);
+    ctx.canvas.drawLineRGBA(xc - capHalf, ywl, xc + capHalf, ywl, edge.r, edge.g, edge.b, edge.a);
+    ctx.canvas.drawLineRGBA(xc - capHalf, ywh, xc + capHalf, ywh, edge.r, edge.g, edge.b, edge.a);
+    for (const outlier of this.outliers) {
+      const yo = Math.round(ctx.transform.yToPx(outlier));
+      ctx.canvas.drawCircleRGBA(xc, yo, 3, edge.r, edge.g, edge.b, edge.a);
+    }
+  }
+  getLegendEntries() {
+    const entry = buildLegendEntry(this.label, {
+      color: this.color,
+      shape: "box"
+    });
+    return entry ? [entry] : null;
+  }
+};
+
+// src/plot/utils/colormaps.ts
+var colormaps = {
+  viridis: [
+    [68, 1, 84],
+    [72, 40, 120],
+    [62, 73, 137],
+    [49, 104, 142],
+    [38, 130, 142],
+    [31, 158, 137],
+    [53, 183, 121],
+    [110, 206, 88],
+    [181, 222, 43],
+    [253, 231, 37]
+  ],
+  plasma: [
+    [13, 8, 135],
+    [75, 3, 161],
+    [125, 3, 168],
+    [168, 34, 150],
+    [203, 70, 121],
+    [229, 107, 93],
+    [248, 148, 65],
+    [253, 195, 40],
+    [240, 249, 33],
+    [240, 249, 33]
+  ],
+  inferno: [
+    [0, 0, 4],
+    [40, 11, 84],
+    [101, 21, 110],
+    [159, 42, 99],
+    [212, 72, 66],
+    [245, 125, 21],
+    [250, 193, 39],
+    [245, 251, 161],
+    [252, 255, 164],
+    [252, 255, 164]
+  ],
+  magma: [
+    [0, 0, 4],
+    [28, 16, 68],
+    [79, 18, 123],
+    [129, 37, 129],
+    [181, 54, 122],
+    [229, 80, 100],
+    [251, 135, 97],
+    [254, 194, 135],
+    [252, 253, 191],
+    [252, 253, 191]
+  ],
+  grayscale: [
+    [0, 0, 0],
+    [28, 28, 28],
+    [57, 57, 57],
+    [85, 85, 85],
+    [113, 113, 113],
+    [142, 142, 142],
+    [170, 170, 170],
+    [198, 198, 198],
+    [227, 227, 227],
+    [255, 255, 255]
+  ]
+};
+function applyColormap(value, colormap) {
+  const cmap = colormaps[colormap];
+  const n = cmap.length;
+  const clamped = Math.max(0, Math.min(1, value));
+  const idx = Math.max(0, Math.min(n - 2, Math.floor(clamped * (n - 1))));
+  const nextIdx = idx + 1;
+  const t = Math.max(0, Math.min(1, clamped * (n - 1) - idx));
+  const c1 = cmap[idx];
+  const c2 = cmap[nextIdx];
+  if (!c1 || !c2) return [0, 0, 0];
+  return [
+    Math.round(c1[0] + (c2[0] - c1[0]) * t),
+    Math.round(c1[1] + (c2[1] - c1[1]) * t),
+    Math.round(c1[2] + (c2[2] - c1[2]) * t)
+  ];
+}
+
+// src/plot/plots/Contour2D.ts
+var DEFAULT_COLORS = [
+  "#1f77b4",
+  "#ff7f0e",
+  "#2ca02c",
+  "#d62728",
+  "#9467bd",
+  "#8c564b",
+  "#e377c2",
+  "#7f7f7f",
+  "#bcbd22",
+  "#17becf"
+];
+function resolveLevels(min, max, levels) {
+  if (Array.isArray(levels)) {
+    const filtered = levels.filter((v) => Number.isFinite(v));
+    if (filtered.length === 0) {
+      throw new InvalidParameterError(
+        "levels must contain at least one finite value",
+        "levels",
+        levels
+      );
+    }
+    const unique = Array.from(new Set(filtered));
+    unique.sort((a, b) => a - b);
+    return unique;
+  }
+  const numLevels = typeof levels === "number" ? levels : 10;
+  if (!Number.isFinite(numLevels) || Math.trunc(numLevels) !== numLevels || numLevels <= 0) {
+    throw new InvalidParameterError(
+      `levels must be a positive integer; received ${numLevels}`,
+      "levels",
+      numLevels
+    );
+  }
+  if (numLevels === 1) {
+    return [min === max ? min : (min + max) / 2];
+  }
+  const step = (max - min) / (numLevels - 1);
+  const values = new Array(numLevels);
+  for (let i = 0; i < numLevels; i++) {
+    values[i] = min + i * step;
+  }
+  return values;
+}
+function resolveLevelColors(levels, options) {
+  const count = levels.length;
+  const colors = [];
+  if (options.colors && options.colors.length > 0) {
+    for (let i = 0; i < count; i++) {
+      const color = options.colors[i % options.colors.length];
+      colors.push(normalizeColor(color, DEFAULT_COLORS[i % DEFAULT_COLORS.length] ?? "#1f77b4"));
+    }
+  } else if (options.color) {
+    const normalized = normalizeColor(options.color, "#1f77b4");
+    for (let i = 0; i < count; i++) colors.push(normalized);
+  } else if (options.colormap) {
+    if (!["viridis", "plasma", "inferno", "magma", "grayscale"].includes(options.colormap)) {
+      throw new InvalidParameterError(
+        `colormap must be one of viridis, plasma, inferno, magma, grayscale; received ${options.colormap}`,
+        "colormap",
+        options.colormap
+      );
+    }
+    const denom = Math.max(1, count - 1);
+    for (let i = 0; i < count; i++) {
+      const t = i / denom;
+      const [r, g, b] = applyColormap(t, options.colormap);
+      colors.push(normalizeColor(`rgb(${r},${g},${b})`, "#1f77b4"));
+    }
+  } else {
+    for (let i = 0; i < count; i++) {
+      const color = DEFAULT_COLORS[i % DEFAULT_COLORS.length] ?? "#1f77b4";
+      colors.push(i === 0 ? color : normalizeColor(color, "#1f77b4"));
+    }
+  }
+  const rgba = colors.map((c) => parseHexColorToRGBA(c));
+  return { colors, rgba };
+}
+function interpolate(level, v0, v1, c0, c1) {
+  if (v0 === v1) return (c0 + c1) / 2;
+  const t = Math.max(0, Math.min(1, (level - v0) / (v1 - v0)));
+  return c0 + t * (c1 - c0);
+}
+var Contour2D = class {
+  kind = "contour";
+  segments;
+  levelColors;
+  levelRGBA;
+  linewidth;
+  xmin;
+  xmax;
+  ymin;
+  ymax;
+  label;
+  constructor(grid, options = {}) {
+    if (options.vmin !== void 0 && !Number.isFinite(options.vmin)) {
+      throw new InvalidParameterError(
+        `vmin must be finite; received ${options.vmin}`,
+        "vmin",
+        options.vmin
+      );
+    }
+    if (options.vmax !== void 0 && !Number.isFinite(options.vmax)) {
+      throw new InvalidParameterError(
+        `vmax must be finite; received ${options.vmax}`,
+        "vmax",
+        options.vmax
+      );
+    }
+    const min = options.vmin ?? grid.dataMin;
+    const max = options.vmax ?? grid.dataMax;
+    if (Number.isFinite(min) && Number.isFinite(max) && min > max) {
+      throw new InvalidParameterError(
+        `vmin must be <= vmax; received vmin=${min} vmax=${max}`,
+        "vmin/vmax",
+        { vmin: min, vmax: max }
+      );
+    }
+    const levels = resolveLevels(min, max, options.levels);
+    const { colors, rgba } = resolveLevelColors(levels, options);
+    let levelColors = colors;
+    let levelRGBA = rgba;
+    this.label = normalizeLegendLabel(options.label);
+    const lw = options.linewidth ?? 1;
+    if (!Number.isFinite(lw) || lw <= 0) {
+      throw new InvalidParameterError(
+        `linewidth must be a positive number; received ${lw}`,
+        "linewidth",
+        lw
+      );
+    }
+    this.linewidth = lw;
+    let xMin = Number.POSITIVE_INFINITY;
+    let xMax = Number.NEGATIVE_INFINITY;
+    let yMin = Number.POSITIVE_INFINITY;
+    let yMax = Number.NEGATIVE_INFINITY;
+    for (let i = 0; i < grid.xCoords.length; i++) {
+      const v = grid.xCoords[i] ?? 0;
+      if (v < xMin) xMin = v;
+      if (v > xMax) xMax = v;
+    }
+    for (let i = 0; i < grid.yCoords.length; i++) {
+      const v = grid.yCoords[i] ?? 0;
+      if (v < yMin) yMin = v;
+      if (v > yMax) yMax = v;
+    }
+    this.xmin = xMin;
+    this.xmax = xMax;
+    this.ymin = yMin;
+    this.ymax = yMax;
+    let segments = [];
+    const rows = grid.rows;
+    const cols = grid.cols;
+    const data = grid.data;
+    const xCoords = grid.xCoords;
+    const yCoords = grid.yCoords;
+    if (rows >= 2 && cols >= 2) {
+      for (let levelIndex = 0; levelIndex < levels.length; levelIndex++) {
+        const level = levels[levelIndex] ?? 0;
+        for (let i = 0; i < rows - 1; i++) {
+          const y0 = yCoords[i] ?? 0;
+          const y1 = yCoords[i + 1] ?? 0;
+          const rowOffset = i * cols;
+          const rowOffsetNext = (i + 1) * cols;
+          for (let j = 0; j < cols - 1; j++) {
+            const x0 = xCoords[j] ?? 0;
+            const x1 = xCoords[j + 1] ?? 0;
+            const v00 = data[rowOffset + j] ?? 0;
+            const v10 = data[rowOffset + j + 1] ?? 0;
+            const v11 = data[rowOffsetNext + j + 1] ?? 0;
+            const v01 = data[rowOffsetNext + j] ?? 0;
+            if (!isFiniteNumber(v00) || !isFiniteNumber(v10) || !isFiniteNumber(v11) || !isFiniteNumber(v01)) {
+              continue;
+            }
+            const idx = (v00 >= level ? 1 : 0) | (v10 >= level ? 2 : 0) | (v11 >= level ? 4 : 0) | (v01 >= level ? 8 : 0);
+            if (idx === 0 || idx === 15) continue;
+            const edgePoint = (edge) => {
+              switch (edge) {
+                case 0:
+                  return { x: interpolate(level, v00, v10, x0, x1), y: y0 };
+                case 1:
+                  return { x: x1, y: interpolate(level, v10, v11, y0, y1) };
+                case 2:
+                  return { x: interpolate(level, v11, v01, x1, x0), y: y1 };
+                case 3:
+                  return { x: x0, y: interpolate(level, v01, v00, y1, y0) };
+                default:
+                  return { x: x0, y: y0 };
+              }
+            };
+            const pushSegment = (e1, e2) => {
+              const p1 = edgePoint(e1);
+              const p2 = edgePoint(e2);
+              segments.push({
+                x1: p1.x,
+                y1: p1.y,
+                x2: p2.x,
+                y2: p2.y,
+                levelIndex
+              });
+            };
+            switch (idx) {
+              case 1:
+                pushSegment(3, 0);
+                break;
+              case 2:
+                pushSegment(0, 1);
+                break;
+              case 3:
+                pushSegment(3, 1);
+                break;
+              case 4:
+                pushSegment(1, 2);
+                break;
+              case 5: {
+                const center = (v00 + v10 + v11 + v01) / 4;
+                if (center >= level) {
+                  pushSegment(3, 2);
+                  pushSegment(0, 1);
+                } else {
+                  pushSegment(3, 0);
+                  pushSegment(1, 2);
+                }
+                break;
+              }
+              case 6:
+                pushSegment(0, 2);
+                break;
+              case 7:
+                pushSegment(3, 2);
+                break;
+              case 8:
+                pushSegment(2, 3);
+                break;
+              case 9:
+                pushSegment(0, 2);
+                break;
+              case 10: {
+                const center = (v00 + v10 + v11 + v01) / 4;
+                if (center >= level) {
+                  pushSegment(0, 3);
+                  pushSegment(2, 1);
+                } else {
+                  pushSegment(0, 1);
+                  pushSegment(2, 3);
+                }
+                break;
+              }
+              case 11:
+                pushSegment(1, 2);
+                break;
+              case 12:
+                pushSegment(1, 3);
+                break;
+              case 13:
+                pushSegment(0, 1);
+                break;
+              case 14:
+                pushSegment(3, 0);
+                break;
+            }
+          }
+        }
+      }
+    }
+    if (segments.length > 0) {
+      const used = Array.from(new Set(segments.map((seg) => seg.levelIndex))).sort((a, b) => a - b);
+      if (used.length > 0 && used.length < levels.length) {
+        const usedLevels = used.map((idx) => levels[idx] ?? 0);
+        const resolved = resolveLevelColors(usedLevels, options);
+        levelColors = resolved.colors;
+        levelRGBA = resolved.rgba;
+        const map = /* @__PURE__ */ new Map();
+        for (let i = 0; i < used.length; i++) {
+          const idx = used[i];
+          if (idx !== void 0) {
+            map.set(idx, i);
+          }
+        }
+        segments = segments.map((seg) => ({
+          x1: seg.x1,
+          y1: seg.y1,
+          x2: seg.x2,
+          y2: seg.y2,
+          levelIndex: map.get(seg.levelIndex) ?? 0
+        }));
+      }
+    }
+    this.levelColors = levelColors;
+    this.levelRGBA = levelRGBA;
+    this.segments = segments;
+  }
+  getDataRange() {
+    if (!Number.isFinite(this.xmin) || !Number.isFinite(this.xmax)) return null;
+    if (!Number.isFinite(this.ymin) || !Number.isFinite(this.ymax)) return null;
+    return {
+      xmin: this.xmin,
+      xmax: this.xmax,
+      ymin: this.ymin,
+      ymax: this.ymax
+    };
+  }
+  drawSVG(ctx) {
+    for (const seg of this.segments) {
+      const color = this.levelColors[seg.levelIndex] ?? "#1f77b4";
+      ctx.push(
+        `<line x1="${ctx.transform.xToPx(seg.x1).toFixed(2)}" y1="${ctx.transform.yToPx(seg.y1).toFixed(2)}" x2="${ctx.transform.xToPx(seg.x2).toFixed(2)}" y2="${ctx.transform.yToPx(seg.y2).toFixed(
+          2
+        )}" stroke="${escapeXml(color)}" stroke-width="${this.linewidth}" fill="none" />`
+      );
+    }
+  }
+  drawRaster(ctx) {
+    for (const seg of this.segments) {
+      const rgba = this.levelRGBA[seg.levelIndex] ?? {
+        r: 0,
+        g: 0,
+        b: 0,
+        a: 255
+      };
+      ctx.canvas.drawLineRGBA(
+        Math.round(ctx.transform.xToPx(seg.x1)),
+        Math.round(ctx.transform.yToPx(seg.y1)),
+        Math.round(ctx.transform.xToPx(seg.x2)),
+        Math.round(ctx.transform.yToPx(seg.y2)),
+        rgba.r,
+        rgba.g,
+        rgba.b,
+        rgba.a
+      );
+    }
+  }
+  getLegendEntries() {
+    const color = this.levelColors[0] ?? "#1f77b4";
+    const entry = buildLegendEntry(this.label, {
+      color,
+      shape: "line",
+      lineWidth: this.linewidth
+    });
+    return entry ? [entry] : null;
+  }
+};
+
+// src/plot/plots/ContourF2D.ts
+var DEFAULT_COLORS2 = [
+  "#1f77b4",
+  "#ff7f0e",
+  "#2ca02c",
+  "#d62728",
+  "#9467bd",
+  "#8c564b",
+  "#e377c2",
+  "#7f7f7f",
+  "#bcbd22",
+  "#17becf"
+];
+function interpolateVertex(a, b, threshold) {
+  const dv = b.v - a.v;
+  const t = dv === 0 ? 0.5 : Math.max(0, Math.min(1, (threshold - a.v) / dv));
+  return {
+    x: a.x + t * (b.x - a.x),
+    y: a.y + t * (b.y - a.y),
+    v: threshold
+  };
+}
+function clipPolygonByThreshold(points, threshold, keepAbove) {
+  if (points.length === 0) return [];
+  const output = [];
+  for (let i = 0; i < points.length; i++) {
+    const current = points[i];
+    const next = points[(i + 1) % points.length];
+    if (!current || !next) continue;
+    const currentInside = keepAbove ? current.v >= threshold : current.v <= threshold;
+    const nextInside = keepAbove ? next.v >= threshold : next.v <= threshold;
+    if (currentInside && nextInside) {
+      output.push(next);
+    } else if (currentInside && !nextInside) {
+      output.push(interpolateVertex(current, next, threshold));
+    } else if (!currentInside && nextInside) {
+      output.push(interpolateVertex(current, next, threshold));
+      output.push(next);
+    }
+  }
+  return output;
+}
+function triangulatePolygon(polygon, band, out) {
+  if (polygon.length < 3) return;
+  const origin = polygon[0];
+  if (!origin) return;
+  for (let i = 1; i < polygon.length - 1; i++) {
+    const v1 = polygon[i];
+    const v2 = polygon[i + 1];
+    if (!v1 || !v2) continue;
+    out.push({
+      x1: origin.x,
+      y1: origin.y,
+      x2: v1.x,
+      y2: v1.y,
+      x3: v2.x,
+      y3: v2.y,
+      band
+    });
+  }
+}
+function addBandTriangles(tri, levels, out) {
+  if (tri.length !== 3 || levels.length < 2) return;
+  const v0 = tri[0]?.v ?? 0;
+  const v1 = tri[1]?.v ?? 0;
+  const v2 = tri[2]?.v ?? 0;
+  const triMin = Math.min(v0, v1, v2);
+  const triMax = Math.max(v0, v1, v2);
+  const lastLevel = levels[levels.length - 1] ?? 0;
+  if (triMax < (levels[0] ?? 0) || triMin > lastLevel) return;
+  const bandCount = levels.length - 1;
+  for (let band = 0; band < bandCount; band++) {
+    const lo = levels[band] ?? 0;
+    const hi = levels[band + 1] ?? lo;
+    if (triMax < lo || triMin > hi) continue;
+    let poly = clipPolygonByThreshold(tri, lo, true);
+    if (poly.length === 0) continue;
+    poly = clipPolygonByThreshold(poly, hi, false);
+    if (poly.length < 3) continue;
+    triangulatePolygon(poly, band, out);
+  }
+}
+function resolveFillLevels(min, max, levels) {
+  if (Array.isArray(levels)) {
+    const filtered = levels.filter((v) => Number.isFinite(v));
+    const unique = Array.from(new Set(filtered));
+    unique.sort((a, b) => a - b);
+    if (unique.length < 2) {
+      throw new InvalidParameterError(
+        "levels must contain at least two finite values",
+        "levels",
+        levels
+      );
+    }
+    return unique;
+  }
+  const numLevels = typeof levels === "number" ? levels : 10;
+  if (!Number.isFinite(numLevels) || Math.trunc(numLevels) !== numLevels || numLevels <= 0) {
+    throw new InvalidParameterError(
+      `levels must be a positive integer; received ${numLevels}`,
+      "levels",
+      numLevels
+    );
+  }
+  if (min === max) {
+    return [min, max];
+  }
+  const step = (max - min) / numLevels;
+  const boundaries = new Array(numLevels + 1);
+  for (let i = 0; i <= numLevels; i++) {
+    boundaries[i] = min + i * step;
+  }
+  if (boundaries.length < 2) {
+    return [min, max];
+  }
+  return boundaries;
+}
+function resolveBandColors(bandCount, options) {
+  const colors = [];
+  if (options.colors && options.colors.length > 0) {
+    for (let i = 0; i < bandCount; i++) {
+      const color = options.colors[i % options.colors.length];
+      colors.push(normalizeColor(color, DEFAULT_COLORS2[i % DEFAULT_COLORS2.length] ?? "#1f77b4"));
+    }
+  } else if (options.color) {
+    const normalized = normalizeColor(options.color, "#1f77b4");
+    for (let i = 0; i < bandCount; i++) colors.push(normalized);
+  } else if (options.colormap) {
+    if (!["viridis", "plasma", "inferno", "magma", "grayscale"].includes(options.colormap)) {
+      throw new InvalidParameterError(
+        `colormap must be one of viridis, plasma, inferno, magma, grayscale; received ${options.colormap}`,
+        "colormap",
+        options.colormap
+      );
+    }
+    const denom = Math.max(1, bandCount - 1);
+    for (let i = 0; i < bandCount; i++) {
+      const t = i / denom;
+      const [r, g, b] = applyColormap(t, options.colormap);
+      colors.push(`rgb(${r},${g},${b})`);
+    }
+  } else {
+    const colormap = "viridis";
+    const denom = Math.max(1, bandCount - 1);
+    for (let i = 0; i < bandCount; i++) {
+      const t = i / denom;
+      const [r, g, b] = applyColormap(t, colormap);
+      colors.push(`rgb(${r},${g},${b})`);
+    }
+  }
+  const rgba = colors.map((c) => parseHexColorToRGBA(c));
+  return { colors, rgba };
+}
+var ContourF2D = class {
+  kind = "contourf";
+  rows;
+  cols;
+  xCoords;
+  yCoords;
+  levels;
+  bandColors;
+  bandRGBA;
+  triangles;
+  xmin;
+  xmax;
+  ymin;
+  ymax;
+  label;
+  constructor(grid, options = {}) {
+    this.rows = grid.rows;
+    this.cols = grid.cols;
+    this.xCoords = grid.xCoords;
+    this.yCoords = grid.yCoords;
+    if (options.vmin !== void 0 && !Number.isFinite(options.vmin)) {
+      throw new InvalidParameterError(
+        `vmin must be finite; received ${options.vmin}`,
+        "vmin",
+        options.vmin
+      );
+    }
+    if (options.vmax !== void 0 && !Number.isFinite(options.vmax)) {
+      throw new InvalidParameterError(
+        `vmax must be finite; received ${options.vmax}`,
+        "vmax",
+        options.vmax
+      );
+    }
+    const min = options.vmin ?? grid.dataMin;
+    const max = options.vmax ?? grid.dataMax;
+    if (Number.isFinite(min) && Number.isFinite(max) && min > max) {
+      throw new InvalidParameterError(
+        `vmin must be <= vmax; received vmin=${min} vmax=${max}`,
+        "vmin/vmax",
+        { vmin: min, vmax: max }
+      );
+    }
+    this.levels = resolveFillLevels(min, max, options.levels);
+    const bandCount = this.levels.length - 1;
+    if (bandCount <= 0) {
+      throw new InvalidParameterError(
+        "levels must define at least one fill band",
+        "levels",
+        this.levels
+      );
+    }
+    const { colors, rgba } = resolveBandColors(bandCount, options);
+    this.bandColors = colors;
+    this.bandRGBA = rgba;
+    this.label = normalizeLegendLabel(options.label);
+    let xMin = Number.POSITIVE_INFINITY;
+    let xMax = Number.NEGATIVE_INFINITY;
+    let yMin = Number.POSITIVE_INFINITY;
+    let yMax = Number.NEGATIVE_INFINITY;
+    for (let i = 0; i < this.xCoords.length; i++) {
+      const v = this.xCoords[i] ?? 0;
+      if (v < xMin) xMin = v;
+      if (v > xMax) xMax = v;
+    }
+    for (let i = 0; i < this.yCoords.length; i++) {
+      const v = this.yCoords[i] ?? 0;
+      if (v < yMin) yMin = v;
+      if (v > yMax) yMax = v;
+    }
+    this.xmin = xMin;
+    this.xmax = xMax;
+    this.ymin = yMin;
+    this.ymax = yMax;
+    const cellRows = Math.max(0, this.rows - 1);
+    const cellCols = Math.max(0, this.cols - 1);
+    const triangles = [];
+    if (cellRows > 0 && cellCols > 0) {
+      const data = grid.data;
+      for (let i = 0; i < cellRows; i++) {
+        const rowOffset = i * this.cols;
+        const rowOffsetNext = (i + 1) * this.cols;
+        const y0 = this.yCoords[i] ?? 0;
+        const y1 = this.yCoords[i + 1] ?? 0;
+        for (let j = 0; j < cellCols; j++) {
+          const x0 = this.xCoords[j] ?? 0;
+          const x1 = this.xCoords[j + 1] ?? 0;
+          const v00 = data[rowOffset + j] ?? 0;
+          const v10 = data[rowOffset + j + 1] ?? 0;
+          const v11 = data[rowOffsetNext + j + 1] ?? 0;
+          const v01 = data[rowOffsetNext + j] ?? 0;
+          if (!isFiniteNumber(v00) || !isFiniteNumber(v10) || !isFiniteNumber(v11) || !isFiniteNumber(v01)) {
+            continue;
+          }
+          const t0 = { x: x0, y: y0, v: v00 };
+          const t1 = { x: x1, y: y0, v: v10 };
+          const t2 = { x: x1, y: y1, v: v11 };
+          const t3 = { x: x0, y: y1, v: v01 };
+          addBandTriangles([t0, t1, t2], this.levels, triangles);
+          addBandTriangles([t0, t2, t3], this.levels, triangles);
+        }
+      }
+    }
+    this.triangles = triangles;
+  }
+  getDataRange() {
+    if (!Number.isFinite(this.xmin) || !Number.isFinite(this.xmax)) return null;
+    if (!Number.isFinite(this.ymin) || !Number.isFinite(this.ymax)) return null;
+    return {
+      xmin: this.xmin,
+      xmax: this.xmax,
+      ymin: this.ymin,
+      ymax: this.ymax
+    };
+  }
+  drawSVG(ctx) {
+    if (this.triangles.length === 0) return;
+    for (const tri of this.triangles) {
+      const color = this.bandColors[tri.band] ?? "#1f77b4";
+      const x1 = ctx.transform.xToPx(tri.x1);
+      const y1 = ctx.transform.yToPx(tri.y1);
+      const x2 = ctx.transform.xToPx(tri.x2);
+      const y2 = ctx.transform.yToPx(tri.y2);
+      const x3 = ctx.transform.xToPx(tri.x3);
+      const y3 = ctx.transform.yToPx(tri.y3);
+      ctx.push(
+        `<path d="M ${x1.toFixed(2)} ${y1.toFixed(2)} L ${x2.toFixed(2)} ${y2.toFixed(
+          2
+        )} L ${x3.toFixed(2)} ${y3.toFixed(2)} Z" fill="${escapeXml(color)}" />`
+      );
+    }
+  }
+  drawRaster(ctx) {
+    if (this.triangles.length === 0) return;
+    for (const tri of this.triangles) {
+      const rgba = this.bandRGBA[tri.band] ?? { r: 0, g: 0, b: 0, a: 255 };
+      ctx.canvas.fillTriangleRGBA(
+        Math.round(ctx.transform.xToPx(tri.x1)),
+        Math.round(ctx.transform.yToPx(tri.y1)),
+        Math.round(ctx.transform.xToPx(tri.x2)),
+        Math.round(ctx.transform.yToPx(tri.y2)),
+        Math.round(ctx.transform.xToPx(tri.x3)),
+        Math.round(ctx.transform.yToPx(tri.y3)),
+        rgba.r,
+        rgba.g,
+        rgba.b,
+        rgba.a
+      );
+    }
+  }
+  getLegendEntries() {
+    const color = this.bandColors[Math.floor(this.bandColors.length / 2)] ?? "#1f77b4";
+    const entry = buildLegendEntry(this.label, { color, shape: "box" });
+    return entry ? [entry] : null;
+  }
+};
+
+// src/plot/plots/Heatmap2D.ts
+var Heatmap2D = class {
+  kind = "heatmap";
+  data;
+  rows;
+  cols;
+  vmin;
+  vmax;
+  colormap;
+  xMin;
+  xMax;
+  yMin;
+  yMax;
+  label;
+  constructor(data, rows, cols, options) {
+    this.data = data;
+    this.rows = rows;
+    this.cols = cols;
+    const colormap = options.colormap ?? "viridis";
+    if (!["viridis", "plasma", "inferno", "magma", "grayscale"].includes(colormap)) {
+      throw new InvalidParameterError(
+        `colormap must be one of viridis, plasma, inferno, magma, grayscale; received ${colormap}`,
+        "colormap",
+        colormap
+      );
+    }
+    this.colormap = colormap;
+    this.label = normalizeLegendLabel(options.label);
+    const extent = options.extent;
+    if (extent) {
+      const { xmin, xmax, ymin, ymax } = extent;
+      if (!Number.isFinite(xmin) || !Number.isFinite(xmax) || !Number.isFinite(ymin) || !Number.isFinite(ymax)) {
+        throw new InvalidParameterError("extent values must be finite", "extent", extent);
+      }
+      if (xmax <= xmin || ymax <= ymin) {
+        throw new InvalidParameterError("extent ranges must be positive", "extent", extent);
+      }
+      this.xMin = xmin;
+      this.xMax = xmax;
+      this.yMin = ymin;
+      this.yMax = ymax;
+    } else {
+      this.xMin = 0;
+      this.xMax = cols;
+      this.yMin = 0;
+      this.yMax = rows;
+    }
+    let min = Number.POSITIVE_INFINITY;
+    let max = Number.NEGATIVE_INFINITY;
+    for (let i = 0; i < data.length; i++) {
+      const v = data[i] ?? 0;
+      if (isFiniteNumber(v)) {
+        min = Math.min(min, v);
+        max = Math.max(max, v);
+      }
+    }
+    if (!Number.isFinite(min) || !Number.isFinite(max)) {
+      throw new InvalidParameterError(
+        "heatmap data must contain at least one finite value",
+        "data",
+        data
+      );
+    }
+    if (options.vmin !== void 0 && !Number.isFinite(options.vmin)) {
+      throw new InvalidParameterError(
+        `vmin must be finite; received ${options.vmin}`,
+        "vmin",
+        options.vmin
+      );
+    }
+    if (options.vmax !== void 0 && !Number.isFinite(options.vmax)) {
+      throw new InvalidParameterError(
+        `vmax must be finite; received ${options.vmax}`,
+        "vmax",
+        options.vmax
+      );
+    }
+    const vmin = options.vmin ?? min;
+    const vmax = options.vmax ?? max;
+    if (Number.isFinite(vmin) && Number.isFinite(vmax) && vmin > vmax) {
+      throw new InvalidParameterError(
+        `vmin must be <= vmax; received vmin=${vmin} vmax=${vmax}`,
+        "vmin/vmax",
+        { vmin, vmax }
+      );
+    }
+    this.vmin = Number.isFinite(vmin) ? vmin : 0;
+    this.vmax = Number.isFinite(vmax) ? vmax : 1;
+  }
+  getDataRange() {
+    return { xmin: this.xMin, xmax: this.xMax, ymin: this.yMin, ymax: this.yMax };
+  }
+  drawSVG(ctx) {
+    if (this.rows <= 0 || this.cols <= 0) return;
+    const range = this.vmax - this.vmin;
+    const xSpan = this.xMax - this.xMin;
+    const ySpan = this.yMax - this.yMin;
+    for (let i = 0; i < this.rows; i++) {
+      for (let j = 0; j < this.cols; j++) {
+        const v = this.data[i * this.cols + j] ?? 0;
+        if (!isFiniteNumber(v)) continue;
+        const normalized = range !== 0 ? (v - this.vmin) / range : 0;
+        const intensity = Math.max(0, Math.min(1, normalized));
+        const [r, g, b] = applyColormap(intensity, this.colormap);
+        const color = `rgb(${r},${g},${b})`;
+        const x0 = ctx.transform.xToPx(this.xMin + j / this.cols * xSpan);
+        const x1 = ctx.transform.xToPx(this.xMin + (j + 1) / this.cols * xSpan);
+        const y0 = ctx.transform.yToPx(this.yMin + i / this.rows * ySpan);
+        const y1 = ctx.transform.yToPx(this.yMin + (i + 1) / this.rows * ySpan);
+        const w = Math.abs(x1 - x0);
+        const h = Math.abs(y1 - y0);
+        const rx = Math.min(x0, x1);
+        const ry = Math.min(y0, y1);
+        ctx.push(
+          `<rect x="${rx.toFixed(2)}" y="${ry.toFixed(2)}" width="${w.toFixed(2)}" height="${h.toFixed(2)}" fill="${color}" />`
+        );
+      }
+    }
+  }
+  drawRaster(ctx) {
+    if (this.rows <= 0 || this.cols <= 0) return;
+    const range = this.vmax - this.vmin;
+    const xSpan = this.xMax - this.xMin;
+    const ySpan = this.yMax - this.yMin;
+    for (let i = 0; i < this.rows; i++) {
+      for (let j = 0; j < this.cols; j++) {
+        const v = this.data[i * this.cols + j] ?? 0;
+        if (!isFiniteNumber(v)) continue;
+        const normalized = range !== 0 ? (v - this.vmin) / range : 0;
+        const intensity = Math.max(0, Math.min(1, normalized));
+        const [r, g, b] = applyColormap(intensity, this.colormap);
+        const x0 = Math.round(ctx.transform.xToPx(this.xMin + j / this.cols * xSpan));
+        const x1 = Math.round(ctx.transform.xToPx(this.xMin + (j + 1) / this.cols * xSpan));
+        const y0 = Math.round(ctx.transform.yToPx(this.yMin + i / this.rows * ySpan));
+        const y1 = Math.round(ctx.transform.yToPx(this.yMin + (i + 1) / this.rows * ySpan));
+        const w = Math.abs(x1 - x0);
+        const h = Math.abs(y1 - y0);
+        const rx = Math.min(x0, x1);
+        const ry = Math.min(y0, y1);
+        ctx.canvas.fillRectRGBA(rx, ry, w, h, r, g, b, 255);
+      }
+    }
+  }
+  getLegendEntries() {
+    const entry = buildLegendEntry(this.label, {
+      color: normalizeColor(`rgb(${applyColormap(0.5, this.colormap).join(",")})`, "#1f77b4"),
+      shape: "box"
+    });
+    return entry ? [entry] : null;
+  }
+};
+
+// src/plot/plots/Histogram.ts
+var Histogram = class {
+  kind = "histogram";
+  bins;
+  counts;
+  binWidth;
+  color;
+  edgecolor;
+  label;
+  constructor(data, numBins, options) {
+    if (!Number.isFinite(numBins) || Math.trunc(numBins) !== numBins || numBins <= 0) {
+      throw new InvalidParameterError(
+        `bins must be a positive integer; received ${numBins}`,
+        "bins",
+        numBins
+      );
+    }
+    this.color = normalizeColor(options.color, "#d62728");
+    this.edgecolor = normalizeColor(options.edgecolor, "#000000");
+    this.label = normalizeLegendLabel(options.label);
+    let min = Number.POSITIVE_INFINITY;
+    let max = Number.NEGATIVE_INFINITY;
+    let hasFinite = false;
+    let hasInfinity = false;
+    for (let i = 0; i < data.length; i++) {
+      const v = data[i] ?? 0;
+      if (isFiniteNumber(v)) {
+        hasFinite = true;
+        min = Math.min(min, v);
+        max = Math.max(max, v);
+      } else if (v === Infinity || v === -Infinity) {
+        hasInfinity = true;
+      }
+    }
+    if (!hasFinite) {
+      if (hasInfinity) {
+        throw new InvalidParameterError(
+          "histogram data must contain at least one finite value",
+          "data",
+          data
+        );
+      }
+      this.bins = new Float64Array(0);
+      this.counts = new Float64Array(0);
+      this.binWidth = 1;
+      return;
+    }
+    const span = max - min;
+    const binWidth = span > 0 ? span / numBins : 1;
+    const binStart = span > 0 ? min : min - numBins * binWidth / 2;
+    this.bins = new Float64Array(numBins);
+    this.counts = new Float64Array(numBins);
+    this.binWidth = binWidth;
+    for (let i = 0; i < numBins; i++) {
+      this.bins[i] = binStart + i * binWidth;
+      this.counts[i] = 0;
+    }
+    if (span === 0) {
+      let finiteCount = 0;
+      for (let i = 0; i < data.length; i++) {
+        const v = data[i] ?? 0;
+        if (isFiniteNumber(v)) finiteCount++;
+      }
+      const mid = Math.floor(numBins / 2);
+      this.counts[mid] = finiteCount;
+      return;
+    }
+    for (let i = 0; i < data.length; i++) {
+      const v = data[i] ?? 0;
+      if (!isFiniteNumber(v)) continue;
+      const rawIdx = Math.floor((v - min) / binWidth);
+      const binIdx = Math.min(Math.max(0, rawIdx), numBins - 1);
+      this.counts[binIdx] = (this.counts[binIdx] ?? 0) + 1;
+    }
+  }
+  getDataRange() {
+    if (this.bins.length === 0) return null;
+    const xmin = this.bins[0] ?? 0;
+    const xmax = (this.bins[this.bins.length - 1] ?? 0) + this.binWidth;
+    let ymax = 0;
+    for (let i = 0; i < this.counts.length; i++) {
+      ymax = Math.max(ymax, this.counts[i] ?? 0);
+    }
+    return { xmin, xmax, ymin: 0, ymax };
+  }
+  drawSVG(ctx) {
+    if (this.bins.length === 0) return;
+    const binWidth = this.binWidth;
+    for (let i = 0; i < this.bins.length; i++) {
+      const x0 = this.bins[i] ?? 0;
+      const count = this.counts[i] ?? 0;
+      const px0 = ctx.transform.xToPx(x0);
+      const px1 = ctx.transform.xToPx(x0 + binWidth);
+      const py0 = ctx.transform.yToPx(0);
+      const py1 = ctx.transform.yToPx(count);
+      const w = Math.abs(px1 - px0);
+      const h = Math.abs(py1 - py0);
+      const rx = Math.min(px0, px1);
+      const ry = Math.min(py0, py1);
+      ctx.push(
+        `<rect x="${rx.toFixed(2)}" y="${ry.toFixed(2)}" width="${w.toFixed(2)}" height="${h.toFixed(2)}" fill="${escapeXml(this.color)}" stroke="${escapeXml(this.edgecolor)}" />`
+      );
+    }
+  }
+  drawRaster(ctx) {
+    if (this.bins.length === 0) return;
+    const rgba = parseHexColorToRGBA(this.color);
+    const edge = parseHexColorToRGBA(this.edgecolor);
+    const binWidth = this.binWidth;
+    for (let i = 0; i < this.bins.length; i++) {
+      const x0 = this.bins[i] ?? 0;
+      const count = this.counts[i] ?? 0;
+      const px0 = Math.round(ctx.transform.xToPx(x0));
+      const px1 = Math.round(ctx.transform.xToPx(x0 + binWidth));
+      const py0 = Math.round(ctx.transform.yToPx(0));
+      const py1 = Math.round(ctx.transform.yToPx(count));
+      const w = Math.abs(px1 - px0);
+      const h = Math.abs(py1 - py0);
+      const rx = Math.min(px0, px1);
+      const ry = Math.min(py0, py1);
+      ctx.canvas.fillRectRGBA(rx, ry, w, h, rgba.r, rgba.g, rgba.b, rgba.a);
+      const r_e = edge.r;
+      const g_e = edge.g;
+      const b_e = edge.b;
+      const a_e = edge.a;
+      ctx.canvas.drawLineRGBA(rx, ry, rx + w, ry, r_e, g_e, b_e, a_e);
+      ctx.canvas.drawLineRGBA(rx + w, ry, rx + w, ry + h, r_e, g_e, b_e, a_e);
+      ctx.canvas.drawLineRGBA(rx + w, ry + h, rx, ry + h, r_e, g_e, b_e, a_e);
+      ctx.canvas.drawLineRGBA(rx, ry + h, rx, ry, r_e, g_e, b_e, a_e);
+    }
+  }
+  getLegendEntries() {
+    const entry = buildLegendEntry(this.label, { color: this.color, shape: "box" });
+    return entry ? [entry] : null;
+  }
+};
+
+// src/plot/plots/HorizontalBar2D.ts
+var HorizontalBar2D = class {
+  kind = "barh";
+  y;
+  width;
+  color;
+  edgecolor;
+  barHeight;
+  label;
+  constructor(y, width, options) {
+    if (y.length !== width.length) throw new ShapeError("y and width must have the same length");
+    this.y = y;
+    this.width = width;
+    this.color = normalizeColor(options.color, "#9467bd");
+    this.edgecolor = normalizeColor(options.edgecolor, "#000000");
+    this.barHeight = 0.8;
+    this.label = normalizeLegendLabel(options.label);
+  }
+  getDataRange() {
+    let ymin = Number.POSITIVE_INFINITY;
+    let ymax = Number.NEGATIVE_INFINITY;
+    let xmin = 0;
+    let xmax = 0;
+    let sawValue = false;
+    for (let i = 0; i < this.y.length; i++) {
+      const yi = this.y[i] ?? 0;
+      const wi = this.width[i] ?? 0;
+      if (!isFiniteNumber(yi) || !isFiniteNumber(wi)) continue;
+      sawValue = true;
+      ymin = Math.min(ymin, yi - this.barHeight / 2);
+      ymax = Math.max(ymax, yi + this.barHeight / 2);
+      xmin = Math.min(xmin, wi);
+      xmax = Math.max(xmax, wi);
+    }
+    if (!sawValue || !Number.isFinite(ymin) || !Number.isFinite(ymax)) {
+      return null;
+    }
+    return { xmin, xmax, ymin, ymax };
+  }
+  drawSVG(ctx) {
+    for (let i = 0; i < this.y.length; i++) {
+      const yi = this.y[i] ?? 0;
+      const wi = this.width[i] ?? 0;
+      if (!isFiniteNumber(yi) || !isFiniteNumber(wi)) continue;
+      const x0 = ctx.transform.xToPx(0);
+      const x1 = ctx.transform.xToPx(wi);
+      const y0 = ctx.transform.yToPx(yi - this.barHeight / 2);
+      const y1 = ctx.transform.yToPx(yi + this.barHeight / 2);
+      const w = Math.abs(x1 - x0);
+      const h = Math.abs(y1 - y0);
+      const rx = Math.min(x0, x1);
+      const ry = Math.min(y0, y1);
+      ctx.push(
+        `<rect x="${rx.toFixed(2)}" y="${ry.toFixed(2)}" width="${w.toFixed(2)}" height="${h.toFixed(2)}" fill="${escapeXml(this.color)}" stroke="${escapeXml(this.edgecolor)}" />`
+      );
+    }
+  }
+  drawRaster(ctx) {
+    const rgba = parseHexColorToRGBA(this.color);
+    const edge = parseHexColorToRGBA(this.edgecolor);
+    for (let i = 0; i < this.y.length; i++) {
+      const yi = this.y[i] ?? 0;
+      const wi = this.width[i] ?? 0;
+      if (!isFiniteNumber(yi) || !isFiniteNumber(wi)) continue;
+      const x0 = Math.round(ctx.transform.xToPx(0));
+      const x1 = Math.round(ctx.transform.xToPx(wi));
+      const y0 = Math.round(ctx.transform.yToPx(yi - this.barHeight / 2));
+      const y1 = Math.round(ctx.transform.yToPx(yi + this.barHeight / 2));
+      const w = Math.abs(x1 - x0);
+      const h = Math.abs(y1 - y0);
+      const rx = Math.min(x0, x1);
+      const ry = Math.min(y0, y1);
+      ctx.canvas.fillRectRGBA(rx, ry, w, h, rgba.r, rgba.g, rgba.b, rgba.a);
+      const r_e = edge.r;
+      const g_e = edge.g;
+      const b_e = edge.b;
+      const a_e = edge.a;
+      ctx.canvas.drawLineRGBA(rx, ry, rx + w, ry, r_e, g_e, b_e, a_e);
+      ctx.canvas.drawLineRGBA(rx + w, ry, rx + w, ry + h, r_e, g_e, b_e, a_e);
+      ctx.canvas.drawLineRGBA(rx + w, ry + h, rx, ry + h, r_e, g_e, b_e, a_e);
+      ctx.canvas.drawLineRGBA(rx, ry + h, rx, ry, r_e, g_e, b_e, a_e);
+    }
+  }
+  getLegendEntries() {
+    const entry = buildLegendEntry(this.label, { color: this.color, shape: "box" });
+    return entry ? [entry] : null;
+  }
+};
+
+// src/plot/plots/Line2D.ts
+var Line2D = class {
+  kind = "line";
+  x;
+  y;
+  color;
+  linewidth;
+  label;
+  constructor(x, y, options) {
+    if (x.length !== y.length) throw new ShapeError("x and y must have the same length");
+    this.x = x;
+    this.y = y;
+    this.color = normalizeColor(options.color, "#1f77b4");
+    const lw = options.linewidth ?? 2;
+    if (!Number.isFinite(lw) || lw <= 0) {
+      throw new InvalidParameterError(
+        `linewidth must be a positive number; received ${lw}`,
+        "linewidth",
+        lw
+      );
+    }
+    this.linewidth = lw;
+    this.label = normalizeLegendLabel(options.label);
+  }
+  getDataRange() {
+    let xmin = Number.POSITIVE_INFINITY;
+    let xmax = Number.NEGATIVE_INFINITY;
+    let ymin = Number.POSITIVE_INFINITY;
+    let ymax = Number.NEGATIVE_INFINITY;
+    for (let i = 0; i < this.x.length; i++) {
+      const xi = this.x[i] ?? 0;
+      const yi = this.y[i] ?? 0;
+      if (!isFiniteNumber(xi) || !isFiniteNumber(yi)) continue;
+      xmin = Math.min(xmin, xi);
+      xmax = Math.max(xmax, xi);
+      ymin = Math.min(ymin, yi);
+      ymax = Math.max(ymax, yi);
+    }
+    if (!Number.isFinite(xmin) || !Number.isFinite(xmax) || !Number.isFinite(ymin) || !Number.isFinite(ymax)) {
+      return null;
+    }
+    return { xmin, xmax, ymin, ymax };
+  }
+  drawSVG(ctx) {
+    const pts = [];
+    for (let i = 0; i < this.x.length; i++) {
+      const xi = this.x[i] ?? 0;
+      const yi = this.y[i] ?? 0;
+      if (!isFiniteNumber(xi) || !isFiniteNumber(yi)) continue;
+      pts.push(`${ctx.transform.xToPx(xi).toFixed(2)},${ctx.transform.yToPx(yi).toFixed(2)}`);
+    }
+    ctx.push(
+      `<polyline fill="none" stroke="${escapeXml(this.color)}" stroke-width="${this.linewidth}" points="${pts.join(" ")}" />`
+    );
+  }
+  drawRaster(ctx) {
+    const rgba = parseHexColorToRGBA(this.color);
+    for (let i = 1; i < this.x.length; i++) {
+      const x0 = this.x[i - 1] ?? 0;
+      const y0 = this.y[i - 1] ?? 0;
+      const x1 = this.x[i] ?? 0;
+      const y1 = this.y[i] ?? 0;
+      if (!isFiniteNumber(x0) || !isFiniteNumber(y0) || !isFiniteNumber(x1) || !isFiniteNumber(y1))
+        continue;
+      ctx.canvas.drawLineRGBA(
+        Math.round(ctx.transform.xToPx(x0)),
+        Math.round(ctx.transform.yToPx(y0)),
+        Math.round(ctx.transform.xToPx(x1)),
+        Math.round(ctx.transform.yToPx(y1)),
+        rgba.r,
+        rgba.g,
+        rgba.b,
+        rgba.a
+      );
+    }
+  }
+  getLegendEntries() {
+    const entry = buildLegendEntry(this.label, {
+      color: this.color,
+      shape: "line",
+      lineWidth: this.linewidth
+    });
+    return entry ? [entry] : null;
+  }
+};
+
+// src/plot/plots/Pie.ts
+var Pie = class {
+  kind = "pie";
+  centerX;
+  centerY;
+  radius;
+  values;
+  angles;
+  colors;
+  labels;
+  rangeOverride;
+  label;
+  constructor(centerX, centerY, radius, values, labels, options = {}, rangeOverride) {
+    if (!Number.isFinite(centerX) || !Number.isFinite(centerY)) {
+      throw new InvalidParameterError("pie center must be finite", "center", { centerX, centerY });
+    }
+    if (!Number.isFinite(radius) || radius <= 0) {
+      throw new InvalidParameterError(
+        `pie radius must be positive; received ${radius}`,
+        "radius",
+        radius
+      );
+    }
+    this.centerX = centerX;
+    this.centerY = centerY;
+    this.radius = radius;
+    if (values.length === 0) {
+      throw new InvalidParameterError("pie requires at least one value", "values", values.length);
+    }
+    if (labels && labels.length !== values.length) {
+      throw new InvalidParameterError(
+        `labels length (${labels.length}) must match values length (${values.length})`,
+        "labels",
+        labels
+      );
+    }
+    this.labels = labels ?? [];
+    this.label = normalizeLegendLabel(options.label);
+    this.rangeOverride = rangeOverride;
+    const validValues = [];
+    for (let i = 0; i < values.length; i++) {
+      const v = values[i] ?? 0;
+      if (!isFiniteNumber(v)) {
+        throw new InvalidParameterError("pie values must be finite", "values", v);
+      }
+      if (v < 0) {
+        throw new InvalidParameterError("pie values must be non-negative", "values", v);
+      }
+      validValues.push(v);
+    }
+    const total = validValues.reduce((sum, val) => sum + val, 0);
+    if (!Number.isFinite(total) || total <= 0) {
+      throw new InvalidParameterError(
+        "pie values must sum to a positive number",
+        "values",
+        validValues
+      );
+    }
+    this.values = validValues;
+    const angles = [0];
+    let cumulative = 0;
+    for (const value of validValues) {
+      cumulative += value / total * 2 * Math.PI;
+      angles.push(cumulative);
+    }
+    this.angles = angles;
+    const defaultColors = [
+      "#1f77b4",
+      "#ff7f0e",
+      "#2ca02c",
+      "#d62728",
+      "#9467bd",
+      "#8c564b",
+      "#e377c2",
+      "#7f7f7f",
+      "#bcbd22",
+      "#17becf"
+    ];
+    const colors = [];
+    if (options.colors && options.colors.length > 0) {
+      for (let i = 0; i < validValues.length; i++) {
+        const colorOption = options.colors[i % options.colors.length];
+        const colorToUse = colorOption;
+        const defaultColor = defaultColors[i % defaultColors.length] ?? "#1f77b4";
+        colors.push(normalizeColor(colorToUse, defaultColor));
+      }
+    } else {
+      for (let i = 0; i < validValues.length; i++) {
+        const defaultColor = defaultColors[i % defaultColors.length] ?? "#1f77b4";
+        colors.push(normalizeColor(void 0, defaultColor));
+      }
+    }
+    this.colors = colors;
+  }
+  getDataRange() {
+    if (this.rangeOverride) return this.rangeOverride;
+    return {
+      xmin: this.centerX - this.radius,
+      xmax: this.centerX + this.radius,
+      ymin: this.centerY - this.radius,
+      ymax: this.centerY + this.radius
+    };
+  }
+  drawSVG(ctx) {
+    const cx = ctx.transform.xToPx(this.centerX);
+    const cy = ctx.transform.yToPx(this.centerY);
+    const rx = Math.abs(ctx.transform.xToPx(this.centerX + this.radius) - cx);
+    const ry = Math.abs(ctx.transform.yToPx(this.centerY + this.radius) - cy);
+    const r = Math.min(rx, ry);
+    for (let i = 0; i < this.values.length; i++) {
+      const startAngle = this.angles[i] ?? 0;
+      const endAngle = this.angles[i + 1] ?? 2 * Math.PI;
+      const x1 = cx + r * Math.cos(startAngle);
+      const y1 = cy - r * Math.sin(startAngle);
+      const x2 = cx + r * Math.cos(endAngle);
+      const y2 = cy - r * Math.sin(endAngle);
+      const largeArcFlag = endAngle - startAngle > Math.PI ? 1 : 0;
+      const pathData = [
+        `M ${cx.toFixed(2)} ${cy.toFixed(2)}`,
+        `L ${x1.toFixed(2)} ${y1.toFixed(2)}`,
+        `A ${r.toFixed(2)} ${r.toFixed(2)} 0 ${largeArcFlag} 0 ${x2.toFixed(2)} ${y2.toFixed(2)}`,
+        "Z"
+      ].join(" ");
+      const fillColor = this.colors[i] ?? "#1f77b4";
+      ctx.push(
+        `<path d="${pathData}" fill="${escapeXml(fillColor)}" stroke="#ffffff" stroke-width="1" />`
+      );
+      const label = this.labels[i];
+      if (i < this.labels.length && label) {
+        const midAngle = (startAngle + endAngle) / 2;
+        const labelRadius = r * 0.7;
+        const labelX = cx + labelRadius * Math.cos(midAngle);
+        const labelY = cy - labelRadius * Math.sin(midAngle);
+        ctx.push(
+          `<text x="${labelX.toFixed(2)}" y="${labelY.toFixed(2)}" text-anchor="middle" font-size="12" fill="#ffffff">${escapeXml(label)}</text>`
+        );
+      }
+    }
+  }
+  drawRaster(ctx) {
+    const cx = Math.round(ctx.transform.xToPx(this.centerX));
+    const cy = Math.round(ctx.transform.yToPx(this.centerY));
+    const rx = Math.abs(ctx.transform.xToPx(this.centerX + this.radius) - cx);
+    const ry = Math.abs(ctx.transform.yToPx(this.centerY + this.radius) - cy);
+    const r = Math.round(Math.min(rx, ry));
+    const edge = parseHexColorToRGBA("#ffffff");
+    for (let i = 0; i < this.values.length; i++) {
+      const startAngle = this.angles[i] ?? 0;
+      const endAngle = this.angles[i + 1] ?? 2 * Math.PI;
+      const fillColor = this.colors[i] ?? "#1f77b4";
+      const rgba = parseHexColorToRGBA(fillColor);
+      const arcLength = (endAngle - startAngle) * r;
+      const numSegments = Math.max(5, Math.ceil(arcLength / 5));
+      for (let j = 0; j < numSegments; j++) {
+        const angle1 = startAngle + j / numSegments * (endAngle - startAngle);
+        const angle2 = startAngle + (j + 1) / numSegments * (endAngle - startAngle);
+        const x1 = cx + r * Math.cos(angle1);
+        const y1 = cy - r * Math.sin(angle1);
+        const x2 = cx + r * Math.cos(angle2);
+        const y2 = cy - r * Math.sin(angle2);
+        ctx.canvas.fillTriangleRGBA(cx, cy, x1, y1, x2, y2, rgba.r, rgba.g, rgba.b, rgba.a);
+      }
+      const edgeX = Math.round(cx + r * Math.cos(startAngle));
+      const edgeY = Math.round(cy - r * Math.sin(startAngle));
+      ctx.canvas.drawLineRGBA(cx, cy, edgeX, edgeY, edge.r, edge.g, edge.b, edge.a);
+      const label = this.labels[i];
+      if (i < this.labels.length && label) {
+        const midAngle = (startAngle + endAngle) / 2;
+        const labelRadius = r * 0.7;
+        const labelX = cx + labelRadius * Math.cos(midAngle);
+        const labelY = cy - labelRadius * Math.sin(midAngle);
+        const textColor = parseHexColorToRGBA("#ffffff");
+        ctx.canvas.drawTextRGBA(
+          label,
+          Math.round(labelX),
+          Math.round(labelY),
+          textColor.r,
+          textColor.g,
+          textColor.b,
+          textColor.a,
+          { fontSize: 12, align: "middle", baseline: "middle" }
+        );
+      }
+    }
+  }
+  getLegendEntries() {
+    const entries = [];
+    if (this.labels.length > 0) {
+      for (let i = 0; i < this.labels.length; i++) {
+        const label = normalizeLegendLabel(this.labels[i]);
+        if (!label) continue;
+        const color = this.colors[i] ?? "#1f77b4";
+        entries.push({ label, color, shape: "box" });
+      }
+      return entries.length > 0 ? entries : null;
+    }
+    if (!this.label) {
+      return null;
+    }
+    const entry = {
+      label: this.label,
+      color: this.colors[0] ?? "#1f77b4",
+      shape: "box"
+    };
+    return [entry];
+  }
+};
+
+// src/plot/plots/Scatter2D.ts
+var Scatter2D = class {
+  kind = "scatter";
+  x;
+  y;
+  color;
+  size;
+  label;
+  constructor(x, y, options) {
+    if (x.length !== y.length) throw new ShapeError("x and y must have the same length");
+    this.x = x;
+    this.y = y;
+    this.color = normalizeColor(options.color, "#ff7f0e");
+    const size = options.size ?? 5;
+    if (!Number.isFinite(size) || size <= 0) {
+      throw new InvalidParameterError(
+        `size must be a positive number; received ${size}`,
+        "size",
+        size
+      );
+    }
+    this.size = size;
+    this.label = normalizeLegendLabel(options.label);
+  }
+  getDataRange() {
+    let xmin = Number.POSITIVE_INFINITY;
+    let xmax = Number.NEGATIVE_INFINITY;
+    let ymin = Number.POSITIVE_INFINITY;
+    let ymax = Number.NEGATIVE_INFINITY;
+    for (let i = 0; i < this.x.length; i++) {
+      const xi = this.x[i] ?? 0;
+      const yi = this.y[i] ?? 0;
+      if (!isFiniteNumber(xi) || !isFiniteNumber(yi)) continue;
+      xmin = Math.min(xmin, xi);
+      xmax = Math.max(xmax, xi);
+      ymin = Math.min(ymin, yi);
+      ymax = Math.max(ymax, yi);
+    }
+    if (!Number.isFinite(xmin) || !Number.isFinite(xmax) || !Number.isFinite(ymin) || !Number.isFinite(ymax)) {
+      return null;
+    }
+    return { xmin, xmax, ymin, ymax };
+  }
+  drawSVG(ctx) {
+    for (let i = 0; i < this.x.length; i++) {
+      const xi = this.x[i] ?? 0;
+      const yi = this.y[i] ?? 0;
+      if (!isFiniteNumber(xi) || !isFiniteNumber(yi)) continue;
+      const px = ctx.transform.xToPx(xi);
+      const py = ctx.transform.yToPx(yi);
+      ctx.push(
+        `<circle cx="${px.toFixed(2)}" cy="${py.toFixed(2)}" r="${this.size}" fill="${escapeXml(this.color)}" />`
+      );
+    }
+  }
+  drawRaster(ctx) {
+    const rgba = parseHexColorToRGBA(this.color);
+    for (let i = 0; i < this.x.length; i++) {
+      const xi = this.x[i] ?? 0;
+      const yi = this.y[i] ?? 0;
+      if (!isFiniteNumber(xi) || !isFiniteNumber(yi)) continue;
+      const px = Math.round(ctx.transform.xToPx(xi));
+      const py = Math.round(ctx.transform.yToPx(yi));
+      ctx.canvas.drawCircleRGBA(px, py, this.size, rgba.r, rgba.g, rgba.b, rgba.a);
+    }
+  }
+  getLegendEntries() {
+    const entry = buildLegendEntry(this.label, {
+      color: this.color,
+      shape: "marker",
+      markerSize: this.size
+    });
+    return entry ? [entry] : null;
+  }
+};
+
+// src/plot/plots/Violinplot.ts
+var Violinplot = class {
+  kind = "violinplot";
+  position;
+  q1;
+  median;
+  q3;
+  kdePoints;
+  kdeValues;
+  color;
+  edgecolor;
+  violinWidth;
+  label;
+  hasData;
+  constructor(position, data, options) {
+    this.position = position;
+    this.color = normalizeColor(options.color, "#8c564b");
+    this.edgecolor = normalizeColor(options.edgecolor, "#000000");
+    this.violinWidth = 0.8;
+    this.label = normalizeLegendLabel(options.label);
+    const sorted = Array.from(data).filter(isFiniteNumber).sort((a, b) => a - b);
+    const n = sorted.length;
+    if (n === 0) {
+      if (data.length > 0) {
+        throw new InvalidParameterError(
+          "violinplot data must contain at least one finite value",
+          "data",
+          data
+        );
+      }
+      this.hasData = false;
+      this.q1 = 0;
+      this.median = 0;
+      this.q3 = 0;
+      this.kdeValues = [];
+      this.kdePoints = [];
+      return;
+    }
+    this.hasData = true;
+    const { q1, median, q3 } = calculateQuartiles(sorted);
+    this.q1 = q1;
+    this.median = median;
+    this.q3 = q3;
+    const firstVal = sorted[0] ?? 0;
+    const lastVal = sorted[sorted.length - 1] ?? 0;
+    const dataRange = lastVal - firstVal;
+    const padding = dataRange * 0.1;
+    const min = firstVal - padding;
+    const max = lastVal + padding;
+    const numPoints = 100;
+    const kdePoints = [];
+    for (let i = 0; i < numPoints; i++) {
+      kdePoints.push(min + i / (numPoints - 1) * (max - min));
+    }
+    this.kdeValues = kernelDensityEstimation(sorted, kdePoints, 0);
+    this.kdePoints = kdePoints;
+  }
+  getDataRange() {
+    if (!this.hasData) return null;
+    if (this.kdePoints.length === 0) return null;
+    const minY = this.kdePoints[0] ?? 0;
+    const maxY = this.kdePoints[this.kdePoints.length - 1] ?? 0;
+    return {
+      xmin: this.position - this.violinWidth / 2,
+      xmax: this.position + this.violinWidth / 2,
+      ymin: minY,
+      ymax: maxY
+    };
+  }
+  drawSVG(ctx) {
+    if (!this.hasData) return;
+    const x = this.position;
+    let maxKDE = 0;
+    for (let i = 0; i < this.kdeValues.length; i++) {
+      const v = this.kdeValues[i] ?? 0;
+      if (v > maxKDE) maxKDE = v;
+    }
+    if (maxKDE === 0) return;
+    const pathPoints = [];
+    for (let i = 0; i < this.kdePoints.length; i++) {
+      const y = this.kdePoints[i] ?? 0;
+      const kde = this.kdeValues[i] ?? 0;
+      const width = kde / maxKDE * this.violinWidth;
+      const xLeft2 = x - width / 2;
+      const px = ctx.transform.xToPx(xLeft2);
+      const py = ctx.transform.yToPx(y);
+      pathPoints.push(`${px.toFixed(2)},${py.toFixed(2)}`);
+    }
+    for (let i = this.kdePoints.length - 1; i >= 0; i--) {
+      const y = this.kdePoints[i] ?? 0;
+      const kde = this.kdeValues[i] ?? 0;
+      const width = kde / maxKDE * this.violinWidth;
+      const xRight2 = x + width / 2;
+      const px = ctx.transform.xToPx(xRight2);
+      const py = ctx.transform.yToPx(y);
+      pathPoints.push(`${px.toFixed(2)},${py.toFixed(2)}`);
+    }
+    if (pathPoints.length > 0) {
+      ctx.push(
+        `<path d="M ${pathPoints.join(" L ")} Z" fill="${escapeXml(this.color)}" stroke="${escapeXml(this.edgecolor)}" stroke-width="1" />`
+      );
+    }
+    const yq1 = ctx.transform.yToPx(this.q1);
+    const ymed = ctx.transform.yToPx(this.median);
+    const yq3 = ctx.transform.yToPx(this.q3);
+    const indicatorWidth = this.violinWidth * 0.8;
+    const xLeft = ctx.transform.xToPx(x - indicatorWidth / 2);
+    const xRight = ctx.transform.xToPx(x + indicatorWidth / 2);
+    ctx.push(
+      `<line x1="${xLeft.toFixed(2)}" y1="${yq1.toFixed(2)}" x2="${xRight.toFixed(2)}" y2="${yq1.toFixed(2)}" stroke="${escapeXml(this.edgecolor)}" stroke-width="2" />`
+    );
+    ctx.push(
+      `<line x1="${xLeft.toFixed(2)}" y1="${ymed.toFixed(2)}" x2="${xRight.toFixed(2)}" y2="${ymed.toFixed(2)}" stroke="${escapeXml(this.edgecolor)}" stroke-width="3" />`
+    );
+    ctx.push(
+      `<line x1="${xLeft.toFixed(2)}" y1="${yq3.toFixed(2)}" x2="${xRight.toFixed(2)}" y2="${yq3.toFixed(2)}" stroke="${escapeXml(this.edgecolor)}" stroke-width="2" />`
+    );
+  }
+  drawRaster(ctx) {
+    if (!this.hasData) return;
+    const rgba = parseHexColorToRGBA(this.color);
+    const edge = parseHexColorToRGBA(this.edgecolor);
+    const x = this.position;
+    let maxKDE = 0;
+    for (let i = 0; i < this.kdeValues.length; i++) {
+      const v = this.kdeValues[i] ?? 0;
+      if (v > maxKDE) maxKDE = v;
+    }
+    if (maxKDE === 0) return;
+    for (let i = 0; i < this.kdePoints.length - 1; i++) {
+      const y1 = this.kdePoints[i] ?? 0;
+      const y2 = this.kdePoints[i + 1] ?? 0;
+      const kde1 = this.kdeValues[i] ?? 0;
+      const kde2 = this.kdeValues[i + 1] ?? 0;
+      const width1 = kde1 / maxKDE * this.violinWidth;
+      const width2 = kde2 / maxKDE * this.violinWidth;
+      const xLeft1 = x - width1 / 2;
+      const xRight1 = x + width1 / 2;
+      const xLeft2 = x - width2 / 2;
+      const xRight2 = x + width2 / 2;
+      const pxLeft1 = Math.round(ctx.transform.xToPx(xLeft1));
+      const pxRight1 = Math.round(ctx.transform.xToPx(xRight1));
+      const pxLeft2 = Math.round(ctx.transform.xToPx(xLeft2));
+      const pxRight2 = Math.round(ctx.transform.xToPx(xRight2));
+      const py1 = Math.round(ctx.transform.yToPx(y1));
+      const py2 = Math.round(ctx.transform.yToPx(y2));
+      ctx.canvas.drawLineRGBA(pxLeft1, py1, pxRight1, py1, rgba.r, rgba.g, rgba.b, rgba.a);
+      ctx.canvas.drawLineRGBA(pxRight1, py1, pxRight2, py2, rgba.r, rgba.g, rgba.b, rgba.a);
+      ctx.canvas.drawLineRGBA(pxRight2, py2, pxLeft2, py2, rgba.r, rgba.g, rgba.b, rgba.a);
+      ctx.canvas.drawLineRGBA(pxLeft2, py2, pxLeft1, py1, rgba.r, rgba.g, rgba.b, rgba.a);
+      const minY = Math.min(py1, py2);
+      const maxY = Math.max(py1, py2);
+      if (py1 === py2) {
+        const leftX = Math.min(pxLeft1, pxLeft2);
+        const rightX = Math.max(pxRight1, pxRight2);
+        ctx.canvas.drawLineRGBA(leftX, py1, rightX, py1, rgba.r, rgba.g, rgba.b, rgba.a);
+      } else {
+        for (let y = minY; y <= maxY; y++) {
+          const t = (y - py1) / (py2 - py1);
+          const leftX = pxLeft1 + t * (pxLeft2 - pxLeft1);
+          const rightX = pxRight1 + t * (pxRight2 - pxRight1);
+          ctx.canvas.drawLineRGBA(
+            Math.round(leftX),
+            y,
+            Math.round(rightX),
+            y,
+            rgba.r,
+            rgba.g,
+            rgba.b,
+            rgba.a
+          );
+        }
+      }
+    }
+    const yq1 = Math.round(ctx.transform.yToPx(this.q1));
+    const ymed = Math.round(ctx.transform.yToPx(this.median));
+    const yq3 = Math.round(ctx.transform.yToPx(this.q3));
+    const indicatorWidth = this.violinWidth * 0.8;
+    const xLeft = Math.round(ctx.transform.xToPx(x - indicatorWidth / 2));
+    const xRight = Math.round(ctx.transform.xToPx(x + indicatorWidth / 2));
+    ctx.canvas.drawLineRGBA(xLeft, yq1, xRight, yq1, edge.r, edge.g, edge.b, edge.a);
+    ctx.canvas.drawLineRGBA(xLeft, ymed, xRight, ymed, edge.r, edge.g, edge.b, edge.a);
+    ctx.canvas.drawLineRGBA(xLeft, yq3, xRight, yq3, edge.r, edge.g, edge.b, edge.a);
+  }
+  getLegendEntries() {
+    const entry = buildLegendEntry(this.label, {
+      color: this.color,
+      shape: "box"
+    });
+    return entry ? [entry] : null;
+  }
+};
+
+// src/plot/utils/tensor.ts
+function tensorToFloat64Vector1D(t) {
+  const tensor2 = "tensor" in t ? t.tensor : t;
+  if (tensor2.ndim !== 1) throw new ShapeError("Expected a 1D tensor");
+  if (tensor2.dtype === "string") throw new DTypeError("Plotting does not support string tensors");
+  const n = tensor2.shape[0] ?? 0;
+  const stride = tensor2.strides[0] ?? 0;
+  const out = new Float64Array(n);
+  const base = tensor2.offset;
+  for (let i = 0; i < n; i++) {
+    const v = tensor2.data[base + i * stride];
+    out[i] = safeConvertToNumber(v);
+  }
+  return out;
+}
+function tensorToFloat64Matrix2D(t) {
+  const tensor2 = "tensor" in t ? t.tensor : t;
+  if (tensor2.ndim !== 2) throw new ShapeError("Expected a 2D tensor");
+  if (tensor2.dtype === "string") throw new DTypeError("Plotting does not support string tensors");
+  const rows = tensor2.shape[0] ?? 0;
+  const cols = tensor2.shape[1] ?? 0;
+  const strideRow = tensor2.strides[0] ?? 0;
+  const strideCol = tensor2.strides[1] ?? 0;
+  const out = new Float64Array(rows * cols);
+  if (strideCol === 1 && strideRow === cols) {
+    const start = tensor2.offset;
+    const end = start + rows * cols;
+    for (let i = 0, j = start; j < end; i++, j++) {
+      const v = tensor2.data[j];
+      out[i] = safeConvertToNumber(v);
+    }
+    return { rows, cols, data: out };
+  }
+  const base = tensor2.offset;
+  for (let i = 0; i < rows; i++) {
+    const rowBase = base + i * strideRow;
+    for (let j = 0; j < cols; j++) {
+      const v = tensor2.data[rowBase + j * strideCol];
+      out[i * cols + j] = safeConvertToNumber(v);
+    }
+  }
+  return { rows, cols, data: out };
+}
+function safeConvertToNumber(value) {
+  if (typeof value === "number") {
+    return value;
+  }
+  if (typeof value === "bigint") {
+    return Number(value);
+  }
+  throw new DTypeError(`Cannot convert ${typeof value} to number for plotting`);
+}
+
+// src/plot/utils/contours.ts
+function tensorSize(t) {
+  const tensor2 = "tensor" in t ? t.tensor : t;
+  if (tensor2.ndim === 0) return 1;
+  let size = 1;
+  for (const dim of tensor2.shape) {
+    const d = dim ?? 0;
+    if (d === 0) return 0;
+    size *= d;
+  }
+  return size;
+}
+function assertFiniteCoords(values, name) {
+  for (let i = 0; i < values.length; i++) {
+    const v = values[i] ?? 0;
+    if (!isFiniteNumber(v)) {
+      throw new InvalidParameterError(`${name} coordinates must be finite`, name, v);
+    }
+  }
+}
+function computeDataRange(data) {
+  let min = Number.POSITIVE_INFINITY;
+  let max = Number.NEGATIVE_INFINITY;
+  let hasNaN = false;
+  for (let i = 0; i < data.length; i++) {
+    const v = data[i] ?? 0;
+    if (!isFiniteNumber(v)) {
+      if (Number.isNaN(v)) {
+        hasNaN = true;
+      }
+      continue;
+    }
+    if (v < min) min = v;
+    if (v > max) max = v;
+  }
+  if (!Number.isFinite(min) || !Number.isFinite(max)) {
+    throw new InvalidParameterError("Contour requires at least one finite Z value", "Z", data);
+  }
+  return { min, max, hasNaN };
+}
+function meshgridToCoords(X, Y, rows, cols) {
+  const xMat = tensorToFloat64Matrix2D(X);
+  const yMat = tensorToFloat64Matrix2D(Y);
+  if (xMat.rows !== rows || xMat.cols !== cols) {
+    throw new ShapeError("X must match Z shape for meshgrid input");
+  }
+  if (yMat.rows !== rows || yMat.cols !== cols) {
+    throw new ShapeError("Y must match Z shape for meshgrid input");
+  }
+  const xCoords = new Float64Array(cols);
+  const yCoords = new Float64Array(rows);
+  for (let j = 0; j < cols; j++) {
+    xCoords[j] = xMat.data[j] ?? 0;
+  }
+  for (let i = 0; i < rows; i++) {
+    yCoords[i] = xMat.cols > 0 ? yMat.data[i * cols] ?? 0 : 0;
+  }
+  const tol = 1e-12;
+  for (let i = 0; i < rows; i++) {
+    const rowOffset = i * cols;
+    for (let j = 0; j < cols; j++) {
+      const expectedX = xCoords[j] ?? 0;
+      const expectedY = yCoords[i] ?? 0;
+      const xv = xMat.data[rowOffset + j] ?? 0;
+      const yv = yMat.data[rowOffset + j] ?? 0;
+      if (!isFiniteNumber(xv) || !isFiniteNumber(yv)) {
+        throw new InvalidParameterError("X/Y meshgrid values must be finite", "X/Y", {
+          x: xv,
+          y: yv
+        });
+      }
+      if (Math.abs(xv - expectedX) > tol || Math.abs(yv - expectedY) > tol) {
+        throw new InvalidParameterError(
+          "Contour supports only rectilinear grids (use 1D X/Y or meshgrid)",
+          "X/Y",
+          { x: xv, y: yv }
+        );
+      }
+    }
+  }
+  assertFiniteCoords(xCoords, "X");
+  assertFiniteCoords(yCoords, "Y");
+  return { xCoords, yCoords };
+}
+function buildContourGrid(X, Y, Z, extent) {
+  const zMat = tensorToFloat64Matrix2D(Z);
+  const { rows, cols, data } = zMat;
+  const { min, max, hasNaN } = computeDataRange(data);
+  const xSize = tensorSize(X);
+  const ySize = tensorSize(Y);
+  let xCoords;
+  let yCoords;
+  if (xSize === 0 && ySize === 0) {
+    xCoords = new Float64Array(cols);
+    yCoords = new Float64Array(rows);
+    if (extent) {
+      const { xmin, xmax, ymin, ymax } = extent;
+      if (!Number.isFinite(xmin) || !Number.isFinite(xmax) || !Number.isFinite(ymin) || !Number.isFinite(ymax)) {
+        throw new InvalidParameterError("extent values must be finite", "extent", extent);
+      }
+      if (xmax <= xmin || ymax <= ymin) {
+        throw new InvalidParameterError("extent ranges must be positive", "extent", extent);
+      }
+      const xDenom = Math.max(1, cols - 1);
+      const yDenom = Math.max(1, rows - 1);
+      for (let j = 0; j < cols; j++) {
+        xCoords[j] = xmin + (xmax - xmin) * j / xDenom;
+      }
+      for (let i = 0; i < rows; i++) {
+        yCoords[i] = ymin + (ymax - ymin) * i / yDenom;
+      }
+    } else {
+      for (let j = 0; j < cols; j++) xCoords[j] = j;
+      for (let i = 0; i < rows; i++) yCoords[i] = i;
+    }
+  } else if (xSize > 0 && ySize > 0) {
+    if (extent) {
+      throw new InvalidParameterError(
+        "extent cannot be combined with explicit X/Y coordinates",
+        "extent",
+        extent
+      );
+    }
+    const rawX = "tensor" in X ? X.tensor : X;
+    const rawY = "tensor" in Y ? Y.tensor : Y;
+    if (rawX.ndim === 1 && rawY.ndim === 1) {
+      xCoords = tensorToFloat64Vector1D(X);
+      yCoords = tensorToFloat64Vector1D(Y);
+      if (xCoords.length !== cols) {
+        throw new ShapeError(`X must have length ${cols}; received ${xCoords.length}`);
+      }
+      if (yCoords.length !== rows) {
+        throw new ShapeError(`Y must have length ${rows}; received ${yCoords.length}`);
+      }
+      assertFiniteCoords(xCoords, "X");
+      assertFiniteCoords(yCoords, "Y");
+    } else if (rawX.ndim === 2 && rawY.ndim === 2) {
+      ({ xCoords, yCoords } = meshgridToCoords(X, Y, rows, cols));
+    } else {
+      throw new ShapeError("X and Y must be 1D vectors or 2D meshgrids matching Z");
+    }
+  } else {
+    throw new InvalidParameterError("Both X and Y must be provided or both empty", "X/Y", {
+      xSize,
+      ySize
+    });
+  }
+  return {
+    rows,
+    cols,
+    data,
+    xCoords,
+    yCoords,
+    dataMin: min,
+    dataMax: max + (hasNaN ? Number.EPSILON : 0)
+  };
+}
+
+// src/plot/utils/text.ts
+function estimateTextWidth(text, fontSize) {
+  if (text.length === 0) return 0;
+  return text.length * fontSize * 0.6;
+}
+
+// src/plot/utils/ticks.ts
+function niceNumber(range, round) {
+  if (!Number.isFinite(range) || range <= 0) return 1;
+  const exponent = Math.floor(Math.log10(range));
+  const fraction = range / 10 ** exponent;
+  let niceFraction;
+  if (round) {
+    if (fraction < 1.5) niceFraction = 1;
+    else if (fraction < 3) niceFraction = 2;
+    else if (fraction < 4.5) niceFraction = 2.5;
+    else if (fraction < 7) niceFraction = 5;
+    else niceFraction = 10;
+  } else {
+    if (fraction <= 1) niceFraction = 1;
+    else if (fraction <= 2) niceFraction = 2;
+    else if (fraction <= 2.5) niceFraction = 2.5;
+    else if (fraction <= 5) niceFraction = 5;
+    else niceFraction = 10;
+  }
+  return niceFraction * 10 ** exponent;
+}
+function formatTick(value, step) {
+  if (!Number.isFinite(value)) return "";
+  const abs = Math.abs(value);
+  if (abs < 1e-12) return "0";
+  if (abs > 0 && abs < 1e-4 || abs >= 1e6) {
+    return value.toExponential(2);
+  }
+  const absStep = Math.abs(step);
+  let decimals = 0;
+  if (absStep > 0 && absStep < 1) {
+    decimals = Math.min(6, Math.ceil(-Math.log10(absStep)));
+  }
+  let text = value.toFixed(decimals);
+  if (decimals > 0) {
+    text = text.replace(/\.?0+$/, "");
+  }
+  return text;
+}
+function generateTicks(min, max, maxTicks = 5) {
+  if (!Number.isFinite(min) || !Number.isFinite(max)) return [];
+  if (maxTicks <= 0 || !Number.isFinite(maxTicks)) return [];
+  const m = Math.min(min, max);
+  const M = Math.max(min, max);
+  if (m === M) {
+    const span = Math.max(1, Math.abs(m) * 0.05);
+    return generateTicks(m - span, M + span, maxTicks);
+  }
+  const range = niceNumber(M - m, false);
+  const step = niceNumber(range / Math.max(1, maxTicks - 1), true);
+  if (!Number.isFinite(step) || step <= 0) return [];
+  const niceMin = Math.floor(m / step) * step;
+  const niceMax = Math.ceil(M / step) * step;
+  const ticks = [];
+  const epsilon = step * 1e-9;
+  for (let v = niceMin; v <= niceMax + epsilon; v += step) {
+    if (v + epsilon < m || v - epsilon > M) continue;
+    ticks.push({ value: v, label: formatTick(v, step) });
+  }
+  return ticks;
+}
+
+// src/plot/utils/transforms.ts
+function computeAutoRange(drawables) {
+  let xmin = Number.POSITIVE_INFINITY;
+  let xmax = Number.NEGATIVE_INFINITY;
+  let ymin = Number.POSITIVE_INFINITY;
+  let ymax = Number.NEGATIVE_INFINITY;
+  for (const d of drawables) {
+    const r = d.getDataRange();
+    if (!r) continue;
+    xmin = Math.min(xmin, r.xmin);
+    xmax = Math.max(xmax, r.xmax);
+    ymin = Math.min(ymin, r.ymin);
+    ymax = Math.max(ymax, r.ymax);
+  }
+  if (!Number.isFinite(xmin) || !Number.isFinite(xmax)) {
+    xmin = 0;
+    xmax = 1;
+  } else if (xmin === xmax) {
+    const span = Math.max(1, Math.abs(xmin) * 0.05);
+    xmin -= span;
+    xmax += span;
+  }
+  if (!Number.isFinite(ymin) || !Number.isFinite(ymax)) {
+    ymin = 0;
+    ymax = 1;
+  } else if (ymin === ymax) {
+    const span = Math.max(1, Math.abs(ymin) * 0.05);
+    ymin -= span;
+    ymax += span;
+  }
+  const xPad = (xmax - xmin) * 0.05;
+  const yPad = (ymax - ymin) * 0.05;
+  return {
+    xmin: xmin - xPad,
+    xmax: xmax + xPad,
+    ymin: ymin - yPad,
+    ymax: ymax + yPad
+  };
+}
+function makeTransform(range, viewport) {
+  const dx = range.xmax - range.xmin;
+  const dy = range.ymax - range.ymin;
+  const sx = dx !== 0 ? viewport.width / dx : 0;
+  const sy = dy !== 0 ? viewport.height / dy : 0;
+  return {
+    xToPx: (x) => viewport.x + (x - range.xmin) * sx,
+    yToPx: (y) => viewport.y + viewport.height - (y - range.ymin) * sy
+  };
+}
+
+// src/plot/figure/Axes.ts
+var Axes = class {
+  fig;
+  padding;
+  paddingProvided;
+  facecolor;
+  drawables;
+  title;
+  xlabel;
+  ylabel;
+  legendOptions;
+  xTicksOverride;
+  yTicksOverride;
+  baseViewport;
+  constructor(fig, options) {
+    this.fig = fig;
+    this.paddingProvided = options.padding !== void 0;
+    const base = options.viewport ?? {
+      x: 0,
+      y: 0,
+      width: this.fig.width,
+      height: this.fig.height
+    };
+    if (!Number.isFinite(base.x) || !Number.isFinite(base.y) || !Number.isFinite(base.width) || !Number.isFinite(base.height) || base.width <= 0 || base.height <= 0) {
+      throw new InvalidParameterError(
+        "viewport must have positive finite width/height",
+        "viewport",
+        base
+      );
+    }
+    const p = options.padding ?? Math.min(50, Math.max(0, Math.floor(Math.min(base.width, base.height) / 4)));
+    if (!Number.isFinite(p) || p < 0) {
+      throw new InvalidParameterError(`padding must be non-negative; received ${p}`, "padding", p);
+    }
+    if (2 * p >= base.width || 2 * p >= base.height) {
+      if (this.paddingProvided) {
+        throw new InvalidParameterError("padding is too large", "padding", p);
+      }
+      const maxSafe = Math.max(0, Math.floor((Math.min(base.width, base.height) - 1) / 2));
+      this.padding = maxSafe;
+    } else {
+      this.padding = p;
+    }
+    this.facecolor = normalizeColor(options.facecolor, "#ffffff");
+    this.baseViewport = options.viewport;
+    this.drawables = [];
+    this.title = "";
+    this.xlabel = "";
+    this.ylabel = "";
+    this.legendOptions = null;
+    this.xTicksOverride = null;
+    this.yTicksOverride = null;
+  }
+  /** Set the axes title text. */
+  setTitle(title) {
+    this.title = title;
+  }
+  /** Set the x-axis label text. */
+  setXLabel(label) {
+    this.xlabel = label;
+  }
+  /** Set the y-axis label text. */
+  setYLabel(label) {
+    this.ylabel = label;
+  }
+  /**
+   * Set custom x-axis tick positions and labels.
+   * @param values - Tick positions in data coordinates
+   * @param labels - Optional tick labels
+   */
+  setXTicks(values, labels) {
+    this.xTicksOverride = this.buildTickOverride(values, labels, "xTicks");
+  }
+  /**
+   * Set custom y-axis tick positions and labels.
+   * @param values - Tick positions in data coordinates
+   * @param labels - Optional tick labels
+   */
+  setYTicks(values, labels) {
+    this.yTicksOverride = this.buildTickOverride(values, labels, "yTicks");
+  }
+  /**
+   * Show or configure the legend for this axes.
+   * @param options - Legend display options
+   */
+  legend(options = {}) {
+    if (options.location !== void 0 && !["upper-right", "upper-left", "lower-right", "lower-left"].includes(options.location)) {
+      throw new InvalidParameterError(
+        `legend location must be one of upper-right, upper-left, lower-right, lower-left; received ${options.location}`,
+        "location",
+        options.location
+      );
+    }
+    if (options.fontSize !== void 0) {
+      if (!Number.isFinite(options.fontSize) || options.fontSize <= 0) {
+        throw new InvalidParameterError(
+          `legend fontSize must be positive; received ${options.fontSize}`,
+          "fontSize",
+          options.fontSize
+        );
+      }
+    }
+    if (options.padding !== void 0) {
+      if (!Number.isFinite(options.padding) || options.padding < 0) {
+        throw new InvalidParameterError(
+          `legend padding must be non-negative; received ${options.padding}`,
+          "padding",
+          options.padding
+        );
+      }
+    }
+    this.legendOptions = options;
+  }
+  /**
+   * Plot a connected line series.
+   * @param x - 1D tensor of x coordinates
+   * @param y - 1D tensor of y coordinates
+   * @param options - Styling options
+   */
+  plot(x, y, options = {}) {
+    const xv = tensorToFloat64Vector1D(x);
+    const yv = tensorToFloat64Vector1D(y);
+    const d = new Line2D(xv, yv, options);
+    this.drawables.push(d);
+    return d;
+  }
+  /**
+   * Plot unconnected points.
+   * @param x - 1D tensor of x coordinates
+   * @param y - 1D tensor of y coordinates
+   * @param options - Styling options
+   */
+  scatter(x, y, options = {}) {
+    const xv = tensorToFloat64Vector1D(x);
+    const yv = tensorToFloat64Vector1D(y);
+    const d = new Scatter2D(xv, yv, options);
+    this.drawables.push(d);
+    return d;
+  }
+  /**
+   * Plot vertical bars.
+   * @param x - 1D tensor of bar centers
+   * @param height - 1D tensor of bar heights
+   * @param options - Styling options
+   */
+  bar(x, height, options = {}) {
+    const xv = tensorToFloat64Vector1D(x);
+    const hv = tensorToFloat64Vector1D(height);
+    const d = new Bar2D(xv, hv, options);
+    this.drawables.push(d);
+    return d;
+  }
+  /**
+   * Plot a histogram.
+   * @param x - 1D tensor of sample values
+   * @param bins - Number of bins
+   * @param options - Styling options
+   */
+  hist(x, bins = 10, options = {}) {
+    const xv = tensorToFloat64Vector1D(x);
+    const resolvedBins = options.bins ?? bins;
+    const d = new Histogram(xv, resolvedBins, options);
+    this.drawables.push(d);
+    return d;
+  }
+  /**
+   * Plot horizontal bars.
+   * @param y - 1D tensor of bar centers
+   * @param width - 1D tensor of bar widths
+   * @param options - Styling options
+   */
+  barh(y, width, options = {}) {
+    const yv = tensorToFloat64Vector1D(y);
+    const wv = tensorToFloat64Vector1D(width);
+    const d = new HorizontalBar2D(yv, wv, options);
+    this.drawables.push(d);
+    return d;
+  }
+  /**
+   * Plot a heatmap for 2D data.
+   * @param data - 2D tensor of values
+   * @param options - Styling and scale options
+   */
+  heatmap(data, options = {}) {
+    const mat = tensorToFloat64Matrix2D(data);
+    const d = new Heatmap2D(mat.data, mat.rows, mat.cols, options);
+    this.drawables.push(d);
+    return d;
+  }
+  /**
+   * Display a matrix as an image (alias of heatmap).
+   * @param data - 2D tensor of values
+   * @param options - Styling and scale options
+   */
+  imshow(data, options = {}) {
+    const mat = tensorToFloat64Matrix2D(data);
+    const d = new Heatmap2D(mat.data, mat.rows, mat.cols, options);
+    this.drawables.push(d);
+    return d;
+  }
+  /**
+   * Plot contour lines for a 2D grid.
+   * @param X - 1D/2D tensor of x coordinates (or empty)
+   * @param Y - 1D/2D tensor of y coordinates (or empty)
+   * @param Z - 2D tensor of values
+   * @param options - Styling and level options
+   */
+  contour(X, Y, Z, options = {}) {
+    const grid = buildContourGrid(X, Y, Z, options.extent);
+    const d = new Contour2D(grid, options);
+    this.drawables.push(d);
+    return d;
+  }
+  /**
+   * Plot filled contours for a 2D grid.
+   * @param X - 1D/2D tensor of x coordinates (or empty)
+   * @param Y - 1D/2D tensor of y coordinates (or empty)
+   * @param Z - 2D tensor of values
+   * @param options - Styling and level options
+   */
+  contourf(X, Y, Z, options = {}) {
+    const grid = buildContourGrid(X, Y, Z, options.extent);
+    const d = new ContourF2D(grid, options);
+    this.drawables.push(d);
+    return d;
+  }
+  /**
+   * Plot a box-and-whisker summary for a 1D dataset.
+   * @param data - 1D tensor of values
+   * @param options - Styling options
+   */
+  boxplot(data, options = {}) {
+    const values = tensorToFloat64Vector1D(data);
+    const d = new Boxplot(1, values, options);
+    this.drawables.push(d);
+    return d;
+  }
+  /**
+   * Plot a violin distribution summary for a 1D dataset.
+   * @param data - 1D tensor of values
+   * @param options - Styling options
+   */
+  violinplot(data, options = {}) {
+    const values = tensorToFloat64Vector1D(data);
+    const d = new Violinplot(1, values, options);
+    this.drawables.push(d);
+    return d;
+  }
+  /**
+   * Plot a pie chart.
+   * @param values - 1D tensor of non-negative values
+   * @param labels - Optional labels (must match values length)
+   * @param options - Styling options
+   */
+  pie(values, labels, options = {}) {
+    const data = tensorToFloat64Vector1D(values);
+    const range = { xmin: 0, xmax: 1, ymin: 0, ymax: 1 };
+    const d = new Pie(0.5, 0.5, 0.35, data, labels, options, range);
+    this.drawables.push(d);
+    return d;
+  }
+  viewport() {
+    const p = this.padding;
+    const base = this.baseViewport ?? {
+      x: 0,
+      y: 0,
+      width: this.fig.width,
+      height: this.fig.height
+    };
+    return {
+      x: base.x + p,
+      y: base.y + p,
+      width: base.width - 2 * p,
+      height: base.height - 2 * p
+    };
+  }
+  collectLegendEntries() {
+    const entries = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const drawable of this.drawables) {
+      const list = drawable.getLegendEntries?.();
+      if (!list) continue;
+      for (const entry of list) {
+        const trimmed = entry.label.trim();
+        if (!trimmed) continue;
+        if (seen.has(trimmed)) continue;
+        seen.add(trimmed);
+        entries.push({ ...entry, label: trimmed });
+      }
+    }
+    return entries;
+  }
+  resolveLegendOptions() {
+    const options = this.legendOptions ?? {};
+    return {
+      visible: options.visible ?? true,
+      location: options.location ?? "upper-right",
+      fontSize: options.fontSize ?? 12,
+      padding: options.padding ?? 6,
+      background: normalizeColor(options.background, "#ffffff"),
+      borderColor: normalizeColor(options.borderColor, "#000000")
+    };
+  }
+  buildTickOverride(values, labels, name) {
+    if (values.length === 0) return null;
+    if (labels && labels.length !== values.length) {
+      throw new InvalidParameterError(
+        `${name} labels length must match values length (${values.length}); received ${labels.length}`,
+        name,
+        labels
+      );
+    }
+    const ticks = [];
+    for (const [i, value] of values.entries()) {
+      if (!Number.isFinite(value)) {
+        throw new InvalidParameterError(`${name} values must be finite`, name, value);
+      }
+      const label = labels ? labels[i] ?? "" : String(value);
+      ticks.push({ value, label: label.trim() });
+    }
+    return ticks;
+  }
+  renderTicksSVG(elements, vp, range, transform) {
+    const maxXTicks = Math.max(2, Math.floor(vp.width / 80));
+    const maxYTicks = Math.max(2, Math.floor(vp.height / 60));
+    const xTicks = (this.xTicksOverride ?? generateTicks(range.xmin, range.xmax, maxXTicks)).filter(
+      (tick) => tick.value >= range.xmin && tick.value <= range.xmax
+    );
+    const yTicks = (this.yTicksOverride ?? generateTicks(range.ymin, range.ymax, maxYTicks)).filter(
+      (tick) => tick.value >= range.ymin && tick.value <= range.ymax
+    );
+    const tickLength = 5;
+    const labelOffset = 2;
+    for (const tick of xTicks) {
+      const px = transform.xToPx(tick.value);
+      elements.push(
+        `<line class="x-tick" x1="${px.toFixed(2)}" y1="${(vp.y + vp.height).toFixed(
+          2
+        )}" x2="${px.toFixed(2)}" y2="${(vp.y + vp.height + tickLength).toFixed(
+          2
+        )}" stroke="#000" />`
+      );
+      elements.push(
+        `<text class="tick-label tick-label-x" x="${px.toFixed(2)}" y="${(vp.y + vp.height + tickLength + labelOffset).toFixed(
+          2
+        )}" text-anchor="middle" dominant-baseline="hanging" font-size="10" fill="#000">${escapeXml(
+          tick.label
+        )}</text>`
+      );
+    }
+    for (const tick of yTicks) {
+      const py = transform.yToPx(tick.value);
+      elements.push(
+        `<line class="y-tick" x1="${vp.x.toFixed(2)}" y1="${py.toFixed(2)}" x2="${(vp.x - tickLength).toFixed(2)}" y2="${py.toFixed(2)}" stroke="#000" />`
+      );
+      elements.push(
+        `<text class="tick-label tick-label-y" x="${(vp.x - tickLength - labelOffset).toFixed(
+          2
+        )}" y="${py.toFixed(2)}" text-anchor="end" dominant-baseline="middle" font-size="10" fill="#000">${escapeXml(
+          tick.label
+        )}</text>`
+      );
+    }
+  }
+  renderLegendSVG(elements, vp) {
+    if (!this.legendOptions) return;
+    const entries = this.collectLegendEntries();
+    if (entries.length === 0) return;
+    const options = this.resolveLegendOptions();
+    if (!options.visible) return;
+    const fontSize = options.fontSize;
+    const padding = options.padding;
+    const symbolSize = Math.max(8, Math.round(fontSize * 0.9));
+    const gap = 6;
+    let maxLabelWidth = 0;
+    for (const entry of entries) {
+      const width = estimateTextWidth(entry.label, fontSize);
+      maxLabelWidth = Math.max(maxLabelWidth, width);
+    }
+    const lineHeight = fontSize + 4;
+    const boxWidth = padding * 2 + symbolSize + gap + maxLabelWidth;
+    const boxHeight = padding * 2 + entries.length * lineHeight;
+    const margin = 6;
+    const isRight = options.location.includes("right");
+    const isUpper = options.location.includes("upper");
+    const boxX = isRight ? vp.x + vp.width - boxWidth - margin : vp.x + margin;
+    const boxY = isUpper ? vp.y + margin : vp.y + vp.height - boxHeight - margin;
+    elements.push(`<g class="legend">`);
+    elements.push(
+      `<rect class="legend-box" x="${boxX.toFixed(2)}" y="${boxY.toFixed(
+        2
+      )}" width="${boxWidth.toFixed(2)}" height="${boxHeight.toFixed(
+        2
+      )}" fill="${escapeXml(options.background)}" stroke="${escapeXml(options.borderColor)}" />`
+    );
+    for (let i = 0; i < entries.length; i++) {
+      const entry = entries[i];
+      if (!entry) continue;
+      const rowY = boxY + padding + i * lineHeight + lineHeight / 2;
+      const symbolX = boxX + padding;
+      const symbolY = rowY - symbolSize / 2;
+      if (entry.shape === "line") {
+        const lineY = rowY;
+        const lineWidth = entry.lineWidth ?? 2;
+        elements.push(
+          `<line class="legend-line" x1="${symbolX.toFixed(2)}" y1="${lineY.toFixed(
+            2
+          )}" x2="${(symbolX + symbolSize).toFixed(2)}" y2="${lineY.toFixed(
+            2
+          )}" stroke="${escapeXml(entry.color)}" stroke-width="${lineWidth}" />`
+        );
+      } else if (entry.shape === "marker") {
+        const radius = Math.max(2, Math.min(symbolSize / 2, entry.markerSize ?? symbolSize / 2));
+        const cx = symbolX + symbolSize / 2;
+        const cy = rowY;
+        elements.push(
+          `<circle class="legend-marker" cx="${cx.toFixed(2)}" cy="${cy.toFixed(
+            2
+          )}" r="${radius.toFixed(2)}" fill="${escapeXml(entry.color)}" />`
+        );
+      } else {
+        elements.push(
+          `<rect class="legend-swatch" x="${symbolX.toFixed(2)}" y="${symbolY.toFixed(
+            2
+          )}" width="${symbolSize.toFixed(2)}" height="${symbolSize.toFixed(
+            2
+          )}" fill="${escapeXml(entry.color)}" stroke="#000" />`
+        );
+      }
+      const textX = symbolX + symbolSize + gap;
+      elements.push(
+        `<text class="legend-label" x="${textX.toFixed(2)}" y="${rowY.toFixed(
+          2
+        )}" text-anchor="start" dominant-baseline="middle" font-size="${fontSize}" fill="#000">${escapeXml(
+          entry.label
+        )}</text>`
+      );
+    }
+    elements.push(`</g>`);
+  }
+  renderTicksRaster(canvas, vp, range, transform) {
+    const maxXTicks = Math.max(2, Math.floor(vp.width / 80));
+    const maxYTicks = Math.max(2, Math.floor(vp.height / 60));
+    const xTicks = (this.xTicksOverride ?? generateTicks(range.xmin, range.xmax, maxXTicks)).filter(
+      (tick) => tick.value >= range.xmin && tick.value <= range.xmax
+    );
+    const yTicks = (this.yTicksOverride ?? generateTicks(range.ymin, range.ymax, maxYTicks)).filter(
+      (tick) => tick.value >= range.ymin && tick.value <= range.ymax
+    );
+    const tickLength = 5;
+    const labelOffset = 2;
+    const text = parseHexColorToRGBA("#000000");
+    for (const tick of xTicks) {
+      const px = Math.round(transform.xToPx(tick.value));
+      const y0 = Math.round(vp.y + vp.height);
+      const y1 = y0 + tickLength;
+      canvas.drawLineRGBA(px, y0, px, y1, text.r, text.g, text.b, text.a);
+      canvas.drawTextRGBA(tick.label, px, y1 + labelOffset, text.r, text.g, text.b, text.a, {
+        fontSize: 10,
+        align: "middle",
+        baseline: "top"
+      });
+    }
+    for (const tick of yTicks) {
+      const py = Math.round(transform.yToPx(tick.value));
+      const x0 = Math.round(vp.x);
+      const x1 = x0 - tickLength;
+      canvas.drawLineRGBA(x0, py, x1, py, text.r, text.g, text.b, text.a);
+      canvas.drawTextRGBA(tick.label, x1 - labelOffset, py, text.r, text.g, text.b, text.a, {
+        fontSize: 10,
+        align: "end",
+        baseline: "middle"
+      });
+    }
+  }
+  renderLegendRaster(canvas, vp) {
+    if (!this.legendOptions) return;
+    const entries = this.collectLegendEntries();
+    if (entries.length === 0) return;
+    const options = this.resolveLegendOptions();
+    if (!options.visible) return;
+    const fontSize = options.fontSize;
+    const padding = options.padding;
+    const symbolSize = Math.max(8, Math.round(fontSize * 0.9));
+    const gap = 6;
+    let maxLabelWidth = 0;
+    for (const entry of entries) {
+      maxLabelWidth = Math.max(maxLabelWidth, estimateTextWidth(entry.label, fontSize));
+    }
+    const lineHeight = fontSize + 4;
+    const boxWidth = padding * 2 + symbolSize + gap + maxLabelWidth;
+    const boxHeight = padding * 2 + entries.length * lineHeight;
+    const margin = 6;
+    const isRight = options.location.includes("right");
+    const isUpper = options.location.includes("upper");
+    const boxX = isRight ? vp.x + vp.width - boxWidth - margin : vp.x + margin;
+    const boxY = isUpper ? vp.y + margin : vp.y + vp.height - boxHeight - margin;
+    const bg = parseHexColorToRGBA(options.background);
+    const border = parseHexColorToRGBA(options.borderColor);
+    const bx = Math.round(boxX);
+    const by = Math.round(boxY);
+    const bw = Math.round(boxWidth);
+    const bh = Math.round(boxHeight);
+    canvas.fillRectRGBA(bx, by, bw, bh, bg.r, bg.g, bg.b, bg.a);
+    canvas.drawLineRGBA(bx, by, bx + bw, by, border.r, border.g, border.b, border.a);
+    canvas.drawLineRGBA(bx, by + bh, bx + bw, by + bh, border.r, border.g, border.b, border.a);
+    canvas.drawLineRGBA(bx, by, bx, by + bh, border.r, border.g, border.b, border.a);
+    canvas.drawLineRGBA(bx + bw, by, bx + bw, by + bh, border.r, border.g, border.b, border.a);
+    const text = parseHexColorToRGBA("#000000");
+    for (let i = 0; i < entries.length; i++) {
+      const entry = entries[i];
+      if (!entry) continue;
+      const rowY = boxY + padding + i * lineHeight + lineHeight / 2;
+      const symbolX = boxX + padding;
+      const symbolY = rowY - symbolSize / 2;
+      const color = parseHexColorToRGBA(entry.color);
+      if (entry.shape === "line") {
+        const y = Math.round(rowY);
+        const x0 = Math.round(symbolX);
+        const x1 = Math.round(symbolX + symbolSize);
+        canvas.drawLineRGBA(x0, y, x1, y, color.r, color.g, color.b, color.a);
+      } else if (entry.shape === "marker") {
+        const radius = Math.max(2, Math.min(symbolSize / 2, entry.markerSize ?? symbolSize / 2));
+        const cx = Math.round(symbolX + symbolSize / 2);
+        const cy = Math.round(rowY);
+        canvas.drawCircleRGBA(cx, cy, Math.round(radius), color.r, color.g, color.b, color.a);
+      } else {
+        canvas.fillRectRGBA(
+          Math.round(symbolX),
+          Math.round(symbolY),
+          Math.round(symbolSize),
+          Math.round(symbolSize),
+          color.r,
+          color.g,
+          color.b,
+          color.a
+        );
+      }
+      const textX = symbolX + symbolSize + gap;
+      canvas.drawTextRGBA(
+        entry.label,
+        Math.round(textX),
+        Math.round(rowY),
+        text.r,
+        text.g,
+        text.b,
+        text.a,
+        { fontSize, align: "start", baseline: "middle" }
+      );
+    }
+  }
+  /**
+   * Render axes to SVG elements.
+   * @internal
+   */
+  renderSVGInto(elements) {
+    const vp = this.viewport();
+    const range = computeAutoRange(this.drawables);
+    const transform = makeTransform(range, vp);
+    elements.push(
+      `<rect x="${vp.x}" y="${vp.y}" width="${vp.width}" height="${vp.height}" fill="${escapeXml(this.facecolor)}" stroke="#000" />`
+    );
+    const ctx = {
+      transform,
+      push: (el) => {
+        elements.push(el);
+      }
+    };
+    for (const d of this.drawables) d.drawSVG(ctx);
+    const shouldRenderTicks = this.drawables.length > 0;
+    if (shouldRenderTicks) {
+      this.renderTicksSVG(elements, vp, range, transform);
+    }
+    if (this.title) {
+      const titleX = vp.x + vp.width / 2;
+      const titleY = vp.y - 10;
+      elements.push(
+        `<text x="${titleX}" y="${titleY}" text-anchor="middle" font-size="14" font-weight="bold" fill="#000">${escapeXml(this.title)}</text>`
+      );
+    }
+    if (this.xlabel) {
+      const xlabelX = vp.x + vp.width / 2;
+      const xlabelY = vp.y + vp.height + 35;
+      elements.push(
+        `<text x="${xlabelX}" y="${xlabelY}" text-anchor="middle" font-size="12" fill="#000">${escapeXml(this.xlabel)}</text>`
+      );
+    }
+    if (this.ylabel) {
+      const ylabelX = vp.x - 35;
+      const ylabelY = vp.y + vp.height / 2;
+      elements.push(
+        `<text x="${ylabelX}" y="${ylabelY}" text-anchor="middle" font-size="12" fill="#000" transform="rotate(-90 ${ylabelX} ${ylabelY})">${escapeXml(this.ylabel)}</text>`
+      );
+    }
+    this.renderLegendSVG(elements, vp);
+  }
+  /**
+   * Render axes to raster canvas.
+   * @internal
+   */
+  renderRasterInto(canvas) {
+    const vp = this.viewport();
+    const range = computeAutoRange(this.drawables);
+    const transform = makeTransform(range, vp);
+    const ctx = { transform, canvas };
+    const bg = parseHexColorToRGBA(this.facecolor);
+    const x0 = Math.round(vp.x);
+    const y0 = Math.round(vp.y);
+    const w = Math.max(0, Math.round(vp.width));
+    const h = Math.max(0, Math.round(vp.height));
+    if (w > 0 && h > 0) {
+      canvas.fillRectRGBA(x0, y0, w, h, bg.r, bg.g, bg.b, bg.a);
+      const edge = parseHexColorToRGBA("#000000");
+      const x1 = x0 + w;
+      const y1 = y0 + h;
+      canvas.drawLineRGBA(x0, y0, x1, y0, edge.r, edge.g, edge.b, edge.a);
+      canvas.drawLineRGBA(x0, y1, x1, y1, edge.r, edge.g, edge.b, edge.a);
+      canvas.drawLineRGBA(x0, y0, x0, y1, edge.r, edge.g, edge.b, edge.a);
+      canvas.drawLineRGBA(x1, y0, x1, y1, edge.r, edge.g, edge.b, edge.a);
+    }
+    for (const d of this.drawables) d.drawRaster(ctx);
+    const shouldRenderTicks = this.drawables.length > 0;
+    if (shouldRenderTicks) {
+      this.renderTicksRaster(canvas, vp, range, transform);
+    }
+    const text = parseHexColorToRGBA("#000000");
+    if (this.title) {
+      const titleX = vp.x + vp.width / 2;
+      const titleY = vp.y - 10;
+      canvas.drawTextRGBA(this.title, titleX, titleY, text.r, text.g, text.b, text.a, {
+        fontSize: 14,
+        align: "middle",
+        baseline: "bottom"
+      });
+    }
+    if (this.xlabel) {
+      const xlabelX = vp.x + vp.width / 2;
+      const xlabelY = vp.y + vp.height + 35;
+      canvas.drawTextRGBA(this.xlabel, xlabelX, xlabelY, text.r, text.g, text.b, text.a, {
+        fontSize: 12,
+        align: "middle",
+        baseline: "top"
+      });
+    }
+    if (this.ylabel) {
+      const ylabelX = vp.x - 35;
+      const ylabelY = vp.y + vp.height / 2;
+      canvas.drawTextRGBA(this.ylabel, ylabelX, ylabelY, text.r, text.g, text.b, text.a, {
+        fontSize: 12,
+        align: "middle",
+        baseline: "middle",
+        rotation: -90
+      });
+    }
+    this.renderLegendRaster(canvas, vp);
+  }
+};
+
+// src/plot/canvas/RasterCanvas.ts
+var RasterCanvas = class {
+  width;
+  height;
+  data;
+  constructor(width, height) {
+    assertPositiveInt("width", width);
+    assertPositiveInt("height", height);
+    this.width = width;
+    this.height = height;
+    this.data = new Uint8ClampedArray(width * height * 4);
+  }
+  clearRGBA(r, g, b, a) {
+    const n = this.width * this.height;
+    for (let i = 0; i < n; i++) {
+      const k = i * 4;
+      this.data[k] = r;
+      this.data[k + 1] = g;
+      this.data[k + 2] = b;
+      this.data[k + 3] = a;
+    }
+  }
+  setPixelRGBA(x, y, r, g, b, a) {
+    if (x < 0 || y < 0 || x >= this.width || y >= this.height) return;
+    const idx = (y * this.width + x) * 4;
+    this.data[idx] = r;
+    this.data[idx + 1] = g;
+    this.data[idx + 2] = b;
+    this.data[idx + 3] = a;
+  }
+  fillRectRGBA(x0, y0, w, h, r, g, b, a) {
+    const x1 = x0 + w;
+    const y1 = y0 + h;
+    const cx0 = clampInt(x0, 0, this.width);
+    const cy0 = clampInt(y0, 0, this.height);
+    const cx1 = clampInt(x1, 0, this.width);
+    const cy1 = clampInt(y1, 0, this.height);
+    for (let y = cy0; y < cy1; y++) {
+      for (let x = cx0; x < cx1; x++) this.setPixelRGBA(x, y, r, g, b, a);
+    }
+  }
+  drawLineRGBA(x0, y0, x1, y1, r, g, b, a) {
+    let x = clampInt(x0, -1e6, 1e6);
+    let y = clampInt(y0, -1e6, 1e6);
+    const xEnd = clampInt(x1, -1e6, 1e6);
+    const yEnd = clampInt(y1, -1e6, 1e6);
+    const dx = Math.abs(xEnd - x);
+    const sx = x < xEnd ? 1 : -1;
+    const dy = -Math.abs(yEnd - y);
+    const sy = y < yEnd ? 1 : -1;
+    let err = dx + dy;
+    for (; ; ) {
+      this.setPixelRGBA(x, y, r, g, b, a);
+      if (x === xEnd && y === yEnd) break;
+      const e2 = 2 * err;
+      if (e2 >= dy) {
+        err += dy;
+        x += sx;
+      }
+      if (e2 <= dx) {
+        err += dx;
+        y += sy;
+      }
+    }
+  }
+  fillTriangleRGBA(x0, y0, x1, y1, x2, y2, r, g, b, a) {
+    if (y0 > y1) {
+      [x0, x1] = [x1, x0];
+      [y0, y1] = [y1, y0];
+    }
+    if (y0 > y2) {
+      [x0, x2] = [x2, x0];
+      [y0, y2] = [y2, y0];
+    }
+    if (y1 > y2) {
+      [x1, x2] = [x2, x1];
+      [y1, y2] = [y2, y1];
+    }
+    const totalHeight = y2 - y0;
+    if (totalHeight === 0) return;
+    for (let i = 0; i < totalHeight; i++) {
+      const secondHalf = i > y1 - y0 || y1 === y0;
+      const segmentHeight = secondHalf ? y2 - y1 : y1 - y0;
+      const alpha = i / totalHeight;
+      const beta = (i - (secondHalf ? y1 - y0 : 0)) / segmentHeight;
+      let ax = x0 + (x2 - x0) * alpha;
+      let bx = secondHalf ? x1 + (x2 - x1) * beta : x0 + (x1 - x0) * beta;
+      if (ax > bx) {
+        [ax, bx] = [bx, ax];
+      }
+      const y = Math.floor(y0 + i);
+      const startX = Math.floor(ax);
+      const endX = Math.ceil(bx);
+      for (let x = startX; x < endX; x++) {
+        this.setPixelRGBA(x, y, r, g, b, a);
+      }
+    }
+  }
+  drawCircleRGBA(cx, cy, radius, r, g, b, a) {
+    const rr = Math.max(0, radius);
+    const r2 = rr * rr;
+    const x0 = clampInt(cx - rr, 0, this.width);
+    const x1 = clampInt(cx + rr + 1, 0, this.width);
+    const y0 = clampInt(cy - rr, 0, this.height);
+    const y1 = clampInt(cy + rr + 1, 0, this.height);
+    for (let y = y0; y < y1; y++) {
+      const dy = y - cy;
+      for (let x = x0; x < x1; x++) {
+        const dx = x - cx;
+        if (dx * dx + dy * dy <= r2) this.setPixelRGBA(x, y, r, g, b, a);
+      }
+    }
+  }
+  measureText(text, fontSize = 12) {
+    const scale = Math.max(1, Math.round(fontSize / FONT_HEIGHT));
+    const charWidth = FONT_WIDTH * scale;
+    const charHeight = FONT_HEIGHT * scale;
+    const spacing = scale;
+    if (text.length === 0) return { width: 0, height: charHeight };
+    return { width: text.length * charWidth + (text.length - 1) * spacing, height: charHeight };
+  }
+  drawTextRGBA(text, x, y, r, g, b, a, options = {}) {
+    if (text.length === 0) return;
+    const fontSize = options.fontSize ?? 12;
+    const align = options.align ?? "start";
+    const baseline = options.baseline ?? "top";
+    const rotation = options.rotation ?? 0;
+    const scale = Math.max(1, Math.round(fontSize / FONT_HEIGHT));
+    const charWidth = FONT_WIDTH * scale;
+    const charHeight = FONT_HEIGHT * scale;
+    const spacing = scale;
+    const textWidth = text.length * charWidth + (text.length - 1) * spacing;
+    const textHeight = charHeight;
+    const boxWidth = rotation === 0 ? textWidth : textHeight;
+    const boxHeight = rotation === 0 ? textHeight : textWidth;
+    let originX = Math.round(x);
+    let originY = Math.round(y);
+    if (align === "middle") originX -= Math.round(boxWidth / 2);
+    else if (align === "end") originX -= boxWidth;
+    if (baseline === "middle") originY -= Math.round(boxHeight / 2);
+    else if (baseline === "bottom") originY -= boxHeight;
+    for (let i = 0; i < text.length; i++) {
+      const ch = text[i] ?? "";
+      const rows = glyphRows(ch);
+      const xOffset = i * (charWidth + spacing);
+      for (let row = 0; row < rows.length; row++) {
+        const mask = rows[row] ?? 0;
+        for (let col = 0; col < FONT_WIDTH; col++) {
+          if ((mask & 1 << FONT_WIDTH - 1 - col) === 0) continue;
+          const baseX = xOffset + col * scale;
+          const baseY = row * scale;
+          for (let sy = 0; sy < scale; sy++) {
+            for (let sx = 0; sx < scale; sx++) {
+              const px = baseX + sx;
+              const py = baseY + sy;
+              let rx = px;
+              let ry = py;
+              if (rotation === -90) {
+                rx = py;
+                ry = textWidth - 1 - px;
+              } else if (rotation === 90) {
+                rx = textHeight - 1 - py;
+                ry = px;
+              }
+              this.setPixelRGBA(originX + rx, originY + ry, r, g, b, a);
+            }
+          }
+        }
+      }
+    }
+  }
+};
+var FONT_WIDTH = 5;
+var FONT_HEIGHT = 7;
+var FONT = {
+  " ": [0, 0, 0, 0, 0, 0, 0],
+  "!": [4, 4, 4, 4, 4, 0, 4],
+  '"': [10, 10, 0, 0, 0, 0, 0],
+  "'": [4, 4, 0, 0, 0, 0, 0],
+  "(": [2, 4, 8, 8, 8, 4, 2],
+  ")": [8, 4, 2, 2, 2, 4, 8],
+  "*": [0, 10, 4, 31, 4, 10, 0],
+  "+": [0, 4, 4, 31, 4, 4, 0],
+  ",": [0, 0, 0, 0, 0, 4, 8],
+  "-": [0, 0, 0, 31, 0, 0, 0],
+  ".": [0, 0, 0, 0, 0, 0, 4],
+  "/": [1, 2, 4, 8, 16, 0, 0],
+  "0": [14, 17, 19, 21, 25, 17, 14],
+  "1": [4, 12, 4, 4, 4, 4, 14],
+  "2": [14, 17, 1, 2, 4, 8, 31],
+  "3": [31, 2, 4, 2, 1, 17, 14],
+  "4": [2, 6, 10, 18, 31, 2, 2],
+  "5": [31, 16, 30, 1, 1, 17, 14],
+  "6": [6, 8, 16, 30, 17, 17, 14],
+  "7": [31, 1, 2, 4, 8, 8, 8],
+  "8": [14, 17, 17, 14, 17, 17, 14],
+  "9": [14, 17, 17, 15, 1, 2, 12],
+  ":": [0, 4, 0, 0, 0, 4, 0],
+  ";": [0, 4, 0, 0, 0, 4, 8],
+  "<": [2, 4, 8, 16, 8, 4, 2],
+  "=": [0, 31, 0, 31, 0, 0, 0],
+  ">": [16, 8, 4, 2, 4, 8, 16],
+  "?": [14, 17, 1, 2, 4, 0, 4],
+  "%": [25, 25, 2, 4, 8, 19, 19],
+  _: [0, 0, 0, 0, 0, 0, 31],
+  A: [14, 17, 17, 31, 17, 17, 17],
+  B: [30, 17, 17, 30, 17, 17, 30],
+  C: [14, 17, 16, 16, 16, 17, 14],
+  D: [30, 17, 17, 17, 17, 17, 30],
+  E: [31, 16, 16, 30, 16, 16, 31],
+  F: [31, 16, 16, 30, 16, 16, 16],
+  G: [14, 17, 16, 23, 17, 17, 14],
+  H: [17, 17, 17, 31, 17, 17, 17],
+  I: [14, 4, 4, 4, 4, 4, 14],
+  J: [7, 2, 2, 2, 18, 18, 12],
+  K: [17, 18, 20, 24, 20, 18, 17],
+  L: [16, 16, 16, 16, 16, 16, 31],
+  M: [17, 27, 21, 17, 17, 17, 17],
+  N: [17, 25, 21, 19, 17, 17, 17],
+  O: [14, 17, 17, 17, 17, 17, 14],
+  P: [30, 17, 17, 30, 16, 16, 16],
+  Q: [14, 17, 17, 17, 21, 18, 13],
+  R: [30, 17, 17, 30, 20, 18, 17],
+  S: [15, 16, 16, 14, 1, 1, 30],
+  T: [31, 4, 4, 4, 4, 4, 4],
+  U: [17, 17, 17, 17, 17, 17, 14],
+  V: [17, 17, 17, 17, 17, 10, 4],
+  W: [17, 17, 17, 17, 21, 27, 17],
+  X: [17, 17, 10, 4, 10, 17, 17],
+  Y: [17, 17, 10, 4, 4, 4, 4],
+  Z: [31, 1, 2, 4, 8, 16, 31],
+  "[": [14, 8, 8, 8, 8, 8, 14],
+  "]": [14, 2, 2, 2, 2, 2, 14]
+};
+function glyphRows(ch) {
+  const direct = FONT[ch];
+  if (direct) return direct;
+  const upper = ch.toUpperCase();
+  return FONT[upper] ?? FONT["?"] ?? [0, 0, 0, 0, 0, 0, 0];
+}
+
+// src/plot/renderers/png.ts
+function isNodeEnvironment() {
+  return typeof process !== "undefined" && typeof process.versions !== "undefined" && typeof process.versions.node !== "undefined";
+}
+function u32be(n) {
+  return Uint8Array.of(n >>> 24 & 255, n >>> 16 & 255, n >>> 8 & 255, n & 255);
+}
+function ascii4(s) {
+  return Uint8Array.of(
+    s.charCodeAt(0) & 255,
+    s.charCodeAt(1) & 255,
+    s.charCodeAt(2) & 255,
+    s.charCodeAt(3) & 255
+  );
+}
+function concatBytes(chunks) {
+  let total = 0;
+  for (const c of chunks) total += c.length;
+  const out = new Uint8Array(total);
+  let o = 0;
+  for (const c of chunks) {
+    out.set(c, o);
+    o += c.length;
+  }
+  return out;
+}
+function crc32(buf) {
+  let crc = 4294967295;
+  for (let i = 0; i < buf.length; i++) {
+    let x = (crc ^ (buf[i] ?? 0)) & 255;
+    for (let k = 0; k < 8; k++) {
+      x = (x & 1) !== 0 ? 3988292384 ^ x >>> 1 : x >>> 1;
+    }
+    crc = crc >>> 8 ^ x;
+  }
+  return (crc ^ 4294967295) >>> 0;
+}
+function pngChunk(type, data) {
+  const t = ascii4(type);
+  const len = u32be(data.length);
+  const crc = u32be(crc32(concatBytes([t, data])));
+  return concatBytes([len, t, data, crc]);
+}
+function deflateUncompressed(data) {
+  const maxBlockSize = 65535;
+  const numBlocks = Math.ceil(data.length / maxBlockSize);
+  let totalSize = 0;
+  for (let i = 0; i < numBlocks; i++) {
+    const blockStart = i * maxBlockSize;
+    const blockSize = Math.min(maxBlockSize, data.length - blockStart);
+    totalSize += 5 + blockSize;
+  }
+  const output = new Uint8Array(2 + totalSize + 4);
+  let outPos = 0;
+  output[outPos++] = 120;
+  output[outPos++] = 1;
+  for (let i = 0; i < numBlocks; i++) {
+    const blockStart = i * maxBlockSize;
+    const blockSize = Math.min(maxBlockSize, data.length - blockStart);
+    const isLast = i === numBlocks - 1;
+    output[outPos++] = isLast ? 1 : 0;
+    output[outPos++] = blockSize & 255;
+    output[outPos++] = blockSize >> 8 & 255;
+    const nlen = ~blockSize & 65535;
+    output[outPos++] = nlen & 255;
+    output[outPos++] = nlen >> 8 & 255;
+    output.set(data.subarray(blockStart, blockStart + blockSize), outPos);
+    outPos += blockSize;
+  }
+  let a = 1;
+  let b = 0;
+  for (let i = 0; i < data.length; i++) {
+    a = (a + (data[i] ?? 0)) % 65521;
+    b = (b + a) % 65521;
+  }
+  const adler32 = (b << 16 | a) >>> 0;
+  output[outPos++] = adler32 >>> 24 & 255;
+  output[outPos++] = adler32 >>> 16 & 255;
+  output[outPos++] = adler32 >>> 8 & 255;
+  output[outPos++] = adler32 & 255;
+  return output;
+}
+async function pngEncodeRGBA(width, height, rgba) {
+  assertPositiveInt("width", width);
+  assertPositiveInt("height", height);
+  if (rgba.length !== width * height * 4)
+    throw new InvalidParameterError("RGBA buffer has incorrect length", "rgba", rgba.length);
+  const signature = Uint8Array.of(137, 80, 78, 71, 13, 10, 26, 10);
+  const ihdrData = concatBytes([u32be(width), u32be(height), Uint8Array.of(8, 6, 0, 0, 0)]);
+  const ihdr = pngChunk("IHDR", ihdrData);
+  const stride = width * 4;
+  const raw = new Uint8Array(height * (1 + stride));
+  for (let y = 0; y < height; y++) {
+    const rowOff = y * (1 + stride);
+    raw[rowOff] = 0;
+    raw.set(rgba.subarray(y * stride, y * stride + stride), rowOff + 1);
+  }
+  let compressed;
+  if (isNodeEnvironment()) {
+    try {
+      const zlib = await import('zlib');
+      compressed = typeof zlib.deflateSync === "function" ? zlib.deflateSync(raw, { level: 9 }) : deflateUncompressed(raw);
+    } catch {
+      compressed = deflateUncompressed(raw);
+    }
+  } else {
+    compressed = deflateUncompressed(raw);
+  }
+  const idat = pngChunk("IDAT", compressed);
+  const iend = pngChunk("IEND", new Uint8Array(0));
+  return concatBytes([signature, ihdr, idat, iend]);
+}
+function isNodeEnvironment_export() {
+  return isNodeEnvironment();
+}
+
+// src/plot/figure/Figure.ts
+var Figure = class {
+  width;
+  height;
+  background;
+  axesList;
+  constructor(options = {}) {
+    this.width = options.width ?? 640;
+    this.height = options.height ?? 480;
+    assertPositiveInt("Figure.width", this.width);
+    assertPositiveInt("Figure.height", this.height);
+    if (this.width > 32768 || this.height > 32768) {
+      throw new InvalidParameterError(
+        "Figure dimensions too large. Maximum is 32,768 pixels.",
+        "width/height",
+        { width: this.width, height: this.height }
+      );
+    }
+    this.background = normalizeColor(options.background, "#ffffff");
+    this.axesList = [];
+  }
+  /**
+   * Add a new axes to the figure.
+   * @param options - Axes layout options
+   */
+  addAxes(options = {}) {
+    const ax = new Axes(this, options);
+    this.axesList.push(ax);
+    return ax;
+  }
+  /**
+   * Render this figure to SVG.
+   */
+  renderSVG() {
+    const elements = [];
+    elements.push(
+      `<rect x="0" y="0" width="${this.width}" height="${this.height}" fill="${escapeXml(this.background)}" />`
+    );
+    for (const ax of this.axesList) ax.renderSVGInto(elements);
+    const svg = `<?xml version="1.0" encoding="UTF-8"?>
+<svg xmlns="http://www.w3.org/2000/svg" width="${this.width}" height="${this.height}" viewBox="0 0 ${this.width} ${this.height}">
+${elements.join("\n")}
+</svg>`;
+    return { kind: "svg", svg };
+  }
+  /**
+   * Render this figure to PNG (Node.js only).
+   *
+   * Note: PNG text rendering uses a built-in bitmap font for basic ASCII.
+   * Unsupported characters are rendered as "?".
+   */
+  async renderPNG() {
+    if (!isNodeEnvironment_export()) {
+      throw new NotImplementedError(
+        "PNG rendering is only available in Node.js environments. Use renderSVG() for browser compatibility, or run in Node.js to generate PNG files."
+      );
+    }
+    const canvas = new RasterCanvas(this.width, this.height);
+    const bg = parseHexColorToRGBA(this.background);
+    canvas.clearRGBA(bg.r, bg.g, bg.b, bg.a);
+    for (const ax of this.axesList) ax.renderRasterInto(canvas);
+    const bytes = await pngEncodeRGBA(this.width, this.height, canvas.data);
+    return { kind: "png", width: this.width, height: this.height, bytes };
+  }
+};
+
+// src/plot/figure/state.ts
+var _currentFigure = null;
+var _currentAxes = null;
+function gcf() {
+  if (!_currentFigure) {
+    _currentFigure = new Figure({ width: 320, height: 240 });
+  }
+  return _currentFigure;
+}
+function gca() {
+  const fig = gcf();
+  if (_currentAxes && fig.axesList.includes(_currentAxes)) return _currentAxes;
+  if (fig.axesList.length === 0) {
+    _currentAxes = fig.addAxes();
+    return _currentAxes;
+  }
+  const firstAxes = fig.axesList[0];
+  if (!firstAxes) {
+    _currentAxes = fig.addAxes();
+    return _currentAxes;
+  }
+  _currentAxes = firstAxes;
+  return _currentAxes;
+}
+function figure(options = {}) {
+  _currentFigure = new Figure({
+    width: options.width ?? 320,
+    height: options.height ?? 240,
+    ...options.background !== void 0 && { background: options.background }
+  });
+  _currentAxes = _currentFigure.addAxes();
+  return _currentFigure;
+}
+function subplot(rows, cols, index, options = {}) {
+  if (!Number.isFinite(rows) || Math.trunc(rows) !== rows || rows <= 0) {
+    throw new InvalidParameterError(
+      `rows must be a positive integer; received ${rows}`,
+      "rows",
+      rows
+    );
+  }
+  if (!Number.isFinite(cols) || Math.trunc(cols) !== cols || cols <= 0) {
+    throw new InvalidParameterError(
+      `cols must be a positive integer; received ${cols}`,
+      "cols",
+      cols
+    );
+  }
+  const total = rows * cols;
+  if (total > 1e4) {
+    throw new InvalidParameterError(
+      `Subplot grid too large (${rows}\xD7${cols}=${total}). Maximum is 10,000 subplots.`,
+      "rows*cols",
+      total
+    );
+  }
+  if (!Number.isFinite(index) || Math.trunc(index) !== index || index < 1 || index > total) {
+    throw new InvalidParameterError(
+      `index must be in [1, ${total}]; received ${index}`,
+      "index",
+      index
+    );
+  }
+  const fig = gcf();
+  const idx0 = index - 1;
+  const row = Math.floor(idx0 / cols);
+  const col = idx0 % cols;
+  const cellW = fig.width / cols;
+  const cellH = fig.height / rows;
+  const viewport = {
+    x: col * cellW,
+    y: row * cellH,
+    width: cellW,
+    height: cellH
+  };
+  const ax = fig.addAxes({ ...options, viewport });
+  _currentAxes = ax;
+  return ax;
+}
+
+// src/plot/index.ts
+function show(options = {}) {
+  const fig = options.figure ?? gca().fig;
+  if (options.format === "png") return fig.renderPNG();
+  return fig.renderSVG();
+}
+async function saveFig(path, options = {}) {
+  if (!path || path.trim().length === 0) {
+    throw new InvalidParameterError("path must be a non-empty string", "path", path);
+  }
+  const dotIndex = path.lastIndexOf(".");
+  const ext = dotIndex > 0 ? path.slice(dotIndex + 1).toLowerCase() : void 0;
+  const fmt = options.format ?? (ext === "png" ? "png" : "svg");
+  if (ext && ext !== fmt) {
+    throw new InvalidParameterError(
+      `File extension .${ext} does not match format ${fmt}`,
+      "path",
+      path
+    );
+  }
+  const fig = options.figure ?? gca().fig;
+  if (fmt === "png") {
+    const { writeFile } = await import('fs/promises');
+    const png = await fig.renderPNG();
+    await writeFile(path, png.bytes);
+  } else {
+    const { writeFile } = await import('fs/promises');
+    const svg = fig.renderSVG();
+    await writeFile(path, svg.svg, "utf-8");
+  }
+}
+function plot(x, y, options = {}) {
+  gca().plot(x, y, options);
+}
+function scatter(x, y, options = {}) {
+  gca().scatter(x, y, options);
+}
+function bar(x, height, options = {}) {
+  gca().bar(x, height, options);
+}
+function barh(y, width, options = {}) {
+  gca().barh(y, width, options);
+}
+function hist(x, bins = 10, options = {}) {
+  gca().hist(x, bins, options);
+}
+function boxplot(data, options = {}) {
+  gca().boxplot(data, options);
+}
+function violinplot(data, options = {}) {
+  gca().violinplot(data, options);
+}
+function pie(values, labels, options = {}) {
+  gca().pie(values, labels, options);
+}
+function legend(options = {}) {
+  gca().legend(options);
+}
+function heatmap(data, options = {}) {
+  gca().heatmap(data, options);
+}
+function imshow(data, options = {}) {
+  gca().imshow(data, options);
+}
+function contour(X, Y, Z, options = {}) {
+  gca().contour(X, Y, Z, options);
+}
+function contourf(X, Y, Z, options = {}) {
+  gca().contourf(X, Y, Z, options);
+}
+function plotConfusionMatrix(cm, labels, options = {}) {
+  const ax = gca();
+  ax.heatmap(cm, options);
+  if (cm.ndim === 2) {
+    const rows = cm.shape[0] ?? 0;
+    const cols = cm.shape[1] ?? 0;
+    ax.setTitle("Confusion Matrix");
+    ax.setXLabel("Predicted");
+    ax.setYLabel("Actual");
+    if (labels && labels.length < Math.max(rows, cols)) {
+      throw new InvalidParameterError(
+        `labels length must be >= ${Math.max(rows, cols)}; received ${labels.length}`,
+        "labels",
+        labels
+      );
+    }
+    if (labels && rows > 0 && cols > 0) {
+      const xLabels = labels.slice(0, cols);
+      const yLabels = labels.slice(0, rows);
+      const xValues = xLabels.map((_, i) => i + 0.5);
+      const yValues = yLabels.map((_, i) => i + 0.5);
+      ax.setXTicks(xValues, xLabels);
+      ax.setYTicks(yValues, yLabels);
+    }
+  }
+}
+function plotRocCurve(fpr, tpr, auc, options = {}) {
+  const ax = gca();
+  ax.plot(fpr, tpr, {
+    ...options,
+    color: options.color ?? "#1f77b4",
+    label: options.label ?? "ROC"
+  });
+  ax.plot(tensor([0, 1]), tensor([0, 1]), {
+    color: "#999999",
+    linewidth: 1,
+    label: "Chance"
+  });
+  if (auc !== void 0) {
+    ax.setTitle(`ROC Curve (AUC = ${auc.toFixed(3)})`);
+  } else {
+    ax.setTitle("ROC Curve");
+  }
+  ax.setXLabel("False Positive Rate");
+  ax.setYLabel("True Positive Rate");
+}
+function plotPrecisionRecallCurve(precision, recall, averagePrecision, options = {}) {
+  const ax = gca();
+  ax.plot(recall, precision, {
+    ...options,
+    color: options.color ?? "#1f77b4",
+    label: options.label ?? "Precision-Recall"
+  });
+  if (averagePrecision !== void 0) {
+    ax.setTitle(`Precision-Recall Curve (AP = ${averagePrecision.toFixed(3)})`);
+  } else {
+    ax.setTitle("Precision-Recall Curve");
+  }
+  ax.setXLabel("Recall");
+  ax.setYLabel("Precision");
+}
+function plotLearningCurve(trainSizes, trainScores, valScores, options = {}) {
+  const ax = gca();
+  const trainColor = options.colors?.[0] ?? options.color ?? "#1f77b4";
+  const valColor = options.colors?.[1] ?? options.color ?? "#ff7f0e";
+  ax.plot(trainSizes, trainScores, {
+    color: trainColor,
+    label: "Training Score"
+  });
+  ax.plot(trainSizes, valScores, {
+    color: valColor,
+    label: "Validation Score"
+  });
+  ax.setTitle("Learning Curve");
+  ax.setXLabel("Training Set Size");
+  ax.setYLabel("Score");
+}
+function plotValidationCurve(paramRange, trainScores, valScores, options = {}) {
+  const ax = gca();
+  const trainColor = options.colors?.[0] ?? options.color ?? "#1f77b4";
+  const valColor = options.colors?.[1] ?? options.color ?? "#ff7f0e";
+  ax.plot(paramRange, trainScores, {
+    color: trainColor,
+    label: "Training Score"
+  });
+  ax.plot(paramRange, valScores, {
+    color: valColor,
+    label: "Validation Score"
+  });
+  ax.setTitle("Validation Curve");
+  ax.setXLabel("Parameter Value");
+  ax.setYLabel("Score");
+}
+function plotDecisionBoundary(X, y, model, options = {}) {
+  if (X.dtype === "string") {
+    throw new InvalidParameterError("plotDecisionBoundary: X must be numeric", "X", X.dtype);
+  }
+  if (X.ndim !== 2 || (X.shape[1] ?? 0) !== 2) {
+    throw new ShapeError("plotDecisionBoundary: X must be shape [n, 2]");
+  }
+  const n = X.shape[0] ?? 0;
+  if (n === 0) {
+    throw new InvalidParameterError("plotDecisionBoundary: X must have at least one row", "X", n);
+  }
+  if (y.ndim !== 1 || (y.shape[0] ?? -1) !== n) {
+    throw new ShapeError("plotDecisionBoundary: y must be shape [n]");
+  }
+  const { data: xData } = tensorToFloat64Matrix2D(X);
+  const x0 = new Float64Array(n);
+  const x1 = new Float64Array(n);
+  for (let i = 0; i < n; i++) {
+    const vx = xData[i * 2] ?? NaN;
+    const vy = xData[i * 2 + 1] ?? NaN;
+    if (!Number.isFinite(vx) || !Number.isFinite(vy)) {
+      throw new InvalidParameterError("plotDecisionBoundary: X must be finite", "X", {
+        index: i,
+        x: vx,
+        y: vy
+      });
+    }
+    x0[i] = vx;
+    x1[i] = vy;
+  }
+  const readLabel = (labelTensor, index) => {
+    const value = labelTensor.at(index);
+    if (typeof value === "string") return value;
+    if (typeof value === "number") {
+      if (!Number.isFinite(value)) {
+        throw new InvalidParameterError("plotDecisionBoundary: invalid label value", "y", value);
+      }
+      return value;
+    }
+    if (typeof value === "bigint") return value;
+    throw new InvalidParameterError("plotDecisionBoundary: invalid label value", "y", value);
+  };
+  const toFiniteNumber = (value) => {
+    if (typeof value === "number") {
+      if (!Number.isFinite(value)) {
+        throw new InvalidParameterError(
+          "plotDecisionBoundary: model.predict must return finite numeric scores",
+          "predict",
+          value
+        );
+      }
+      return value;
+    }
+    if (typeof value === "bigint") {
+      const n2 = Number(value);
+      if (!Number.isFinite(n2)) {
+        throw new InvalidParameterError(
+          "plotDecisionBoundary: model.predict must return finite numeric scores",
+          "predict",
+          value
+        );
+      }
+      return n2;
+    }
+    throw new InvalidParameterError(
+      "plotDecisionBoundary: model.predict must return numeric scores",
+      "predict",
+      value
+    );
+  };
+  const labelKey = (value) => `${typeof value}:${String(value)}`;
+  let xMin = x0[0] ?? 0;
+  let xMax = x0[0] ?? 0;
+  let yMin = x1[0] ?? 0;
+  let yMax = x1[0] ?? 0;
+  for (let i = 1; i < n; i++) {
+    const vx = x0[i] ?? 0;
+    const vy = x1[i] ?? 0;
+    if (vx < xMin) xMin = vx;
+    if (vx > xMax) xMax = vx;
+    if (vy < yMin) yMin = vy;
+    if (vy > yMax) yMax = vy;
+  }
+  const marginX = xMax > xMin ? (xMax - xMin) * 0.05 : 1;
+  const marginY = yMax > yMin ? (yMax - yMin) * 0.05 : 1;
+  xMin -= marginX;
+  xMax += marginX;
+  yMin -= marginY;
+  yMax += marginY;
+  const gridResolution = 100;
+  const gridCount = gridResolution * gridResolution;
+  const gridFlat = new Float64Array(gridCount * 2);
+  for (let gy = 0; gy < gridResolution; gy++) {
+    const fy = yMin + (yMax - yMin) * gy / Math.max(1, gridResolution - 1);
+    for (let gx = 0; gx < gridResolution; gx++) {
+      const fx = xMin + (xMax - xMin) * gx / Math.max(1, gridResolution - 1);
+      const idx = (gy * gridResolution + gx) * 2;
+      gridFlat[idx] = fx;
+      gridFlat[idx + 1] = fy;
+    }
+  }
+  const gridTensor = tensor(gridFlat).reshape([gridCount, 2]);
+  const predictions = model.predict(gridTensor);
+  const predictedLabels = new Array(gridCount);
+  if (predictions.ndim === 1) {
+    if ((predictions.shape[0] ?? -1) !== gridCount) {
+      throw new ShapeError("plotDecisionBoundary: model.predict must return [gridSize] labels");
+    }
+    for (let i = 0; i < gridCount; i++) {
+      predictedLabels[i] = readLabel(predictions, i);
+    }
+  } else if (predictions.ndim === 2) {
+    const rows = predictions.shape[0] ?? -1;
+    const cols = predictions.shape[1] ?? -1;
+    if (rows !== gridCount || cols <= 0) {
+      throw new ShapeError("plotDecisionBoundary: model.predict must return [gridSize, k]");
+    }
+    for (let i = 0; i < rows; i++) {
+      let bestCol = 0;
+      let bestValue = toFiniteNumber(predictions.at(i, 0));
+      for (let c = 1; c < cols; c++) {
+        const value = toFiniteNumber(predictions.at(i, c));
+        if (value > bestValue) {
+          bestValue = value;
+          bestCol = c;
+        }
+      }
+      predictedLabels[i] = bestCol;
+    }
+  } else {
+    throw new ShapeError("plotDecisionBoundary: model.predict output must be 1D or 2D");
+  }
+  const classIndex = /* @__PURE__ */ new Map();
+  const classValues = [];
+  for (let i = 0; i < n; i++) {
+    const label = readLabel(y, i);
+    const key = labelKey(label);
+    if (!classIndex.has(key)) {
+      classIndex.set(key, classValues.length);
+      classValues.push(label);
+    }
+  }
+  for (const label of predictedLabels) {
+    const key = labelKey(label);
+    if (!classIndex.has(key)) {
+      classIndex.set(key, classValues.length);
+      classValues.push(label);
+    }
+  }
+  const boundaryMatrix = Array.from(
+    { length: gridResolution },
+    () => Array(gridResolution).fill(0)
+  );
+  for (let gy = 0; gy < gridResolution; gy++) {
+    const row = boundaryMatrix[gy];
+    if (!row) {
+      throw new InvalidParameterError("plotDecisionBoundary: grid row access failed", "gy", gy);
+    }
+    for (let gx = 0; gx < gridResolution; gx++) {
+      const label = predictedLabels[gy * gridResolution + gx];
+      const mapped = label === void 0 ? 0 : classIndex.get(labelKey(label)) ?? 0;
+      row[gx] = mapped;
+    }
+  }
+  const ax = gca();
+  ax.imshow(tensor(boundaryMatrix), {
+    colormap: options.colormap ?? "grayscale",
+    vmin: options.vmin ?? 0,
+    vmax: options.vmax ?? Math.max(1, classValues.length - 1),
+    extent: { xmin: xMin, xmax: xMax, ymin: yMin, ymax: yMax }
+  });
+  const defaultClassColors = [
+    "#1f77b4",
+    "#ff7f0e",
+    "#2ca02c",
+    "#d62728",
+    "#9467bd",
+    "#8c564b",
+    "#e377c2",
+    "#7f7f7f",
+    "#bcbd22",
+    "#17becf"
+  ];
+  const classColors = options.colors !== void 0 && options.colors.length > 0 ? options.colors : defaultClassColors;
+  const byClass = /* @__PURE__ */ new Map();
+  for (let i = 0; i < n; i++) {
+    const label = readLabel(y, i);
+    const key = labelKey(label);
+    const labelText = String(label);
+    const mapped = classIndex.get(key) ?? 0;
+    const current = byClass.get(key) ?? {
+      x: [],
+      y: [],
+      index: mapped,
+      label: labelText
+    };
+    current.x.push(x0[i] ?? 0);
+    current.y.push(x1[i] ?? 0);
+    byClass.set(key, current);
+  }
+  for (const group of byClass.values()) {
+    const color = classColors[group.index % classColors.length] ?? "#000000";
+    ax.scatter(tensor(group.x), tensor(group.y), {
+      color,
+      size: options.size ?? 4,
+      label: group.label
+    });
+  }
+  ax.setTitle("Decision Boundary");
+  ax.setXLabel("Feature 1");
+  ax.setYLabel("Feature 2");
+}
+
+export { Axes, Figure, bar, barh, boxplot, contour, contourf, figure, gca, heatmap, hist, imshow, legend, pie, plot, plotConfusionMatrix, plotDecisionBoundary, plotLearningCurve, plotPrecisionRecallCurve, plotRocCurve, plotValidationCurve, plot_exports, saveFig, scatter, show, subplot, violinplot };
+//# sourceMappingURL=chunk-ZXKBDFP3.js.map
+//# sourceMappingURL=chunk-ZXKBDFP3.js.map