@danielsimonjr/mathts-plot 0.2.0

package/dist/index.js

@@ -0,0 +1,1140 @@
+// src/plot.ts
+import { parse, evaluate, range } from "@danielsimonjr/mathts-functions";
+
+// src/coerce.ts
+import {
+  isMatrix,
+  isComplex,
+  isBigNumber,
+  isFraction,
+  number as toNumber
+} from "@danielsimonjr/mathts-core";
+function scalar(v) {
+  if (typeof v === "number") return v;
+  if (typeof v === "bigint") return Number(v);
+  if (isComplex(v)) return v.re;
+  if (isBigNumber(v) || isFraction(v)) {
+    try {
+      return toNumber(v);
+    } catch {
+      return NaN;
+    }
+  }
+  return Number(v);
+}
+function unwrap(raw) {
+  if (isMatrix(raw)) {
+    try {
+      return raw.toArray();
+    } catch {
+      return raw;
+    }
+  }
+  return raw;
+}
+function coerce1d(raw) {
+  const u = unwrap(raw);
+  const arr = Array.isArray(u) ? u.flat(Infinity) : u instanceof Float64Array ? Array.from(u) : [];
+  const out = [];
+  for (const v of arr) {
+    const n = scalar(v);
+    if (Number.isFinite(n)) out.push(n);
+  }
+  return out;
+}
+function coerce1dPositional(raw) {
+  const u = unwrap(raw);
+  const arr = Array.isArray(u) ? u.flat(Infinity) : u instanceof Float64Array ? Array.from(u) : [];
+  return arr.map((v) => scalar(v));
+}
+function coerce2d(raw) {
+  const u = unwrap(raw);
+  if (!Array.isArray(u)) return [];
+  return u.map((row) => {
+    const r = row instanceof Float64Array ? Array.from(row) : Array.isArray(row) ? row : [row];
+    return r.map((v) => {
+      const n = scalar(v);
+      return Number.isFinite(n) ? n : NaN;
+    });
+  });
+}
+
+// src/scale.ts
+function extent(xs) {
+  if (xs.length === 0) return [0, 1];
+  let lo = xs[0];
+  let hi = xs[0];
+  for (const v of xs) {
+    if (v < lo) lo = v;
+    if (v > hi) hi = v;
+  }
+  if (lo === hi) return [lo - 1, hi + 1];
+  return [lo, hi];
+}
+function linearScale(dom, range2) {
+  const [d0, d1] = dom;
+  const [r0, r1] = range2;
+  const m = (r1 - r0) / (d1 - d0);
+  return (v) => r0 + (v - d0) * m;
+}
+function logScale(dom, range2) {
+  const d0 = Math.log10(Math.max(dom[0], Number.MIN_VALUE));
+  const d1 = Math.log10(Math.max(dom[1], Number.MIN_VALUE));
+  const [r0, r1] = range2;
+  const m = (r1 - r0) / (d1 - d0);
+  return (v) => r0 + (Math.log10(Math.max(v, Number.MIN_VALUE)) - d0) * m;
+}
+function niceTicks(min, max, count = 5) {
+  if (!(max > min)) return [min];
+  const span = max - min;
+  const raw = span / count;
+  const mag = Math.pow(10, Math.floor(Math.log10(raw)));
+  const norm = raw / mag;
+  const step2 = (norm < 1.5 ? 1 : norm < 3 ? 2 : norm < 7 ? 5 : 10) * mag;
+  const start = Math.floor(min / step2) * step2;
+  const ticks = [];
+  for (let t = start; t <= max + step2 * 0.5; t += step2) ticks.push(Math.round(t / step2) * step2);
+  return ticks;
+}
+
+// src/svg.ts
+var PALETTE = [
+  "#2a4d8f",
+  "#c0392b",
+  "#27ae60",
+  "#8e44ad",
+  "#d68910",
+  "#16a085",
+  "#7f8c8d",
+  "#2c3e50"
+];
+var THEMES = {
+  light: {
+    fg: "#1a1a2e",
+    muted: "#5a5a72",
+    grid: "#e6e6ee",
+    axis: "#5a5a72",
+    bg: "#ffffff",
+    series: PALETTE
+  },
+  dark: {
+    fg: "#e8e8f0",
+    muted: "#a0a0b0",
+    grid: "#2c2c3a",
+    axis: "#a0a0b0",
+    bg: "#14141c",
+    series: PALETTE
+  }
+};
+function esc(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function fmt(n) {
+  if (!Number.isFinite(n)) return "";
+  const a = Math.abs(n);
+  if (a !== 0 && (a < 1e-3 || a >= 1e6)) return n.toExponential(2);
+  return String(Math.round(n * 1e6) / 1e6);
+}
+var r2 = (n) => Math.round(n * 100) / 100;
+function svgDoc(width, height, body, bg) {
+  return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${width} ${height}" width="100%" role="img"><rect x="0" y="0" width="${width}" height="${height}" fill="${bg}"/>${body}</svg>`;
+}
+function line(x1, y1, x2, y2, stroke, w = 1, opacity) {
+  const op = opacity !== void 0 && opacity < 1 ? ` stroke-opacity="${Math.round(opacity * 1e3) / 1e3}"` : "";
+  return `<line x1="${r2(x1)}" y1="${r2(y1)}" x2="${r2(x2)}" y2="${r2(y2)}" stroke="${stroke}" stroke-width="${w}"${op}/>`;
+}
+function circle(cx, cy, r, fill, opacity) {
+  const op = opacity !== void 0 && opacity < 1 ? ` fill-opacity="${Math.round(opacity * 1e3) / 1e3}"` : "";
+  return `<circle cx="${r2(cx)}" cy="${r2(cy)}" r="${r}" fill="${fill}"${op}/>`;
+}
+function rect(x, y, w, h, fill) {
+  return `<rect x="${r2(x)}" y="${r2(y)}" width="${r2(w)}" height="${r2(h)}" fill="${fill}"/>`;
+}
+function polyline(pts, stroke, w = 2) {
+  const p = pts.map(([x, y]) => `${r2(x)},${r2(y)}`).join(" ");
+  return `<polyline points="${p}" fill="none" stroke="${stroke}" stroke-width="${w}"/>`;
+}
+function polygon(pts, fill, stroke = "none") {
+  const p = pts.map(([x, y]) => `${r2(x)},${r2(y)}`).join(" ");
+  return `<polygon points="${p}" fill="${fill}" stroke="${stroke}"/>`;
+}
+function text(x, y, s, fill, anchor = "start", size = 12) {
+  return `<text x="${r2(x)}" y="${r2(y)}" text-anchor="${anchor}" font-family="system-ui,sans-serif" font-size="${size}" fill="${fill}">${esc(s)}</text>`;
+}
+function primSVG(p) {
+  switch (p.k) {
+    case "line":
+      return line(p.x1, p.y1, p.x2, p.y2, p.stroke, p.w, p.opacity);
+    case "circle":
+      return circle(p.cx, p.cy, p.r, p.fill, p.opacity);
+    case "rect":
+      return rect(p.x, p.y, p.w, p.h, p.fill);
+    case "polyline":
+      return polyline(p.pts, p.stroke, p.w);
+    case "polygon":
+      return polygon(p.pts, p.fill, p.stroke);
+    case "text":
+      return p.rotate !== void 0 ? `<text transform="translate(${p.x},${p.y}) rotate(${p.rotate})" text-anchor="${p.anchor}" font-family="system-ui,sans-serif" font-size="${p.size}" fill="${p.fill}">${esc(p.s)}</text>` : text(p.x, p.y, p.s, p.fill, p.anchor, p.size);
+  }
+}
+function emitSVG(scene) {
+  return svgDoc(scene.width, scene.height, scene.prims.map(primSVG).join(""), scene.bg);
+}
+
+// src/render-core.ts
+function xy(layer) {
+  const ys = coerce1dPositional(layer.y);
+  const xs = layer.x ? coerce1dPositional(layer.x) : ys.map((_, i) => i);
+  const n = Math.min(xs.length, ys.length);
+  const pts = [];
+  for (let i = 0; i < n; i++) {
+    if (Number.isFinite(xs[i]) && Number.isFinite(ys[i])) pts.push([xs[i], ys[i]]);
+  }
+  return pts;
+}
+function renderLine(layer, f, i) {
+  const color = layer.color ?? f.color(i);
+  const pts = xy(layer).map(([x, y]) => [f.px(x), f.py(y)]);
+  return [
+    { k: "polyline", pts, stroke: color, w: 2 },
+    ...pts.map((p) => ({ k: "circle", cx: p[0], cy: p[1], r: 2.5, fill: color }))
+  ];
+}
+function renderScatter(layer, f, i) {
+  const color = layer.color ?? f.color(i);
+  return xy(layer).map(
+    ([x, y]) => ({ k: "circle", cx: f.px(x), cy: f.py(y), r: 3, fill: color })
+  );
+}
+function renderBar(layer, f, i) {
+  const color = layer.color ?? f.color(i);
+  const pts = xy(layer);
+  const base = f.py(Math.max(0, f.ydom[0]));
+  const bw = pts.length > 1 ? Math.abs(f.px(pts[1][0]) - f.px(pts[0][0])) * 0.7 : 20;
+  return pts.map(([x, y]) => {
+    const yp = f.py(y);
+    return {
+      k: "rect",
+      x: f.px(x) - bw / 2,
+      y: Math.min(yp, base),
+      w: bw,
+      h: Math.abs(base - yp),
+      fill: color
+    };
+  });
+}
+function renderArea(layer, f, i) {
+  const color = layer.color ?? f.color(i);
+  const pts = xy(layer).map(([x, y]) => [f.px(x), f.py(y)]);
+  if (pts.length === 0) return [];
+  const base = f.py(Math.max(0, f.ydom[0]));
+  const poly = [[pts[0][0], base], ...pts, [pts[pts.length - 1][0], base]];
+  return [
+    { k: "polygon", pts: poly, fill: color + "55", stroke: "none" },
+    { k: "polyline", pts, stroke: color, w: 2 }
+  ];
+}
+function renderStep(layer, f, i) {
+  const color = layer.color ?? f.color(i);
+  const pts = xy(layer).map(([x, y]) => [f.px(x), f.py(y)]);
+  const stepped = [];
+  for (let k = 0; k < pts.length; k++) {
+    stepped.push(pts[k]);
+    if (k < pts.length - 1) stepped.push([pts[k + 1][0], pts[k][1]]);
+  }
+  return [{ k: "polyline", pts: stepped, stroke: color, w: 2 }];
+}
+function renderErrorbar(layer, f, i) {
+  const color = layer.color ?? f.color(i);
+  const ys = coerce1dPositional(layer.y);
+  const xs = layer.x ? coerce1dPositional(layer.x) : ys.map((_, k) => k);
+  const errs = coerce1dPositional(layer.yerr ?? []);
+  const n = Math.min(xs.length, ys.length);
+  const out = [];
+  for (let k = 0; k < n; k++) {
+    if (!Number.isFinite(xs[k]) || !Number.isFinite(ys[k])) continue;
+    const e = Number.isFinite(errs[k]) ? errs[k] : 0;
+    const cx = f.px(xs[k]);
+    const top = f.py(ys[k] + e);
+    const bot = f.py(ys[k] - e);
+    out.push(
+      { k: "line", x1: cx, y1: top, x2: cx, y2: bot, stroke: color, w: 1.5 },
+      { k: "line", x1: cx - 3, y1: top, x2: cx + 3, y2: top, stroke: color, w: 1.5 },
+      { k: "line", x1: cx - 3, y1: bot, x2: cx + 3, y2: bot, stroke: color, w: 1.5 },
+      { k: "circle", cx, cy: f.py(ys[k]), r: 3, fill: color }
+    );
+  }
+  return out;
+}
+function renderQuiver(layer, f, i) {
+  const color = layer.color ?? f.color(i);
+  const xs = layer.x ? coerce1dPositional(layer.x) : [];
+  const ys = coerce1dPositional(layer.y);
+  const us = coerce1dPositional(layer.u ?? []);
+  const vs = coerce1dPositional(layer.v ?? []);
+  const n = Math.min(xs.length, ys.length, us.length, vs.length);
+  const out = [];
+  for (let k = 0; k < n; k++) {
+    if (![xs[k], ys[k], us[k], vs[k]].every(Number.isFinite)) continue;
+    const x0 = f.px(xs[k]);
+    const y0 = f.py(ys[k]);
+    const x1 = f.px(xs[k] + us[k]);
+    const y1 = f.py(ys[k] + vs[k]);
+    const ang = Math.atan2(y1 - y0, x1 - x0);
+    const ah = 5;
+    out.push(
+      { k: "line", x1: x0, y1: y0, x2: x1, y2: y1, stroke: color, w: 1.5 },
+      {
+        k: "line",
+        x1,
+        y1,
+        x2: x1 - ah * Math.cos(ang - 0.4),
+        y2: y1 - ah * Math.sin(ang - 0.4),
+        stroke: color,
+        w: 1.5
+      },
+      {
+        k: "line",
+        x1,
+        y1,
+        x2: x1 - ah * Math.cos(ang + 0.4),
+        y2: y1 - ah * Math.sin(ang + 0.4),
+        stroke: color,
+        w: 1.5
+      }
+    );
+  }
+  return out;
+}
+function renderLayer(layer, f, i) {
+  switch (layer.type) {
+    case "line":
+      return renderLine(layer, f, i);
+    case "scatter":
+      return renderScatter(layer, f, i);
+    case "bar":
+      return renderBar(layer, f, i);
+    case "area":
+      return renderArea(layer, f, i);
+    case "step":
+      return renderStep(layer, f, i);
+    case "errorbar":
+      return renderErrorbar(layer, f, i);
+    case "quiver":
+      return renderQuiver(layer, f, i);
+    default:
+      return renderLine(layer, f, i);
+  }
+}
+
+// src/tikz.ts
+function texEsc(s) {
+  return s.replace(/[\\&%$#_{}~^]/g, (c) => {
+    switch (c) {
+      case "\\":
+        return "\\textbackslash{}";
+      case "~":
+        return "\\textasciitilde{}";
+      case "^":
+        return "\\textasciicircum{}";
+      default:
+        return `\\${c}`;
+    }
+  });
+}
+function tikzColor(c) {
+  if (c === "none") return { color: "none", alpha: 1 };
+  if (c.startsWith("#")) {
+    const h = c.slice(1);
+    const r = parseInt(h.slice(0, 2), 16);
+    const g = parseInt(h.slice(2, 4), 16);
+    const b = parseInt(h.slice(4, 6), 16);
+    const alpha = h.length >= 8 ? Math.round(parseInt(h.slice(6, 8), 16) / 255 * 100) / 100 : 1;
+    return { color: `{rgb,255:red,${r};green,${g};blue,${b}}`, alpha };
+  }
+  return { color: c, alpha: 1 };
+}
+var round = (n) => Math.round(n * 100) / 100;
+var ANCHOR = {
+  start: "base west",
+  middle: "base",
+  end: "base east"
+};
+function primTikZ(p, X, Y, s) {
+  const pt = (x, y) => `(${X(x)},${Y(y)})`;
+  const path = (pts) => pts.map(([x, y]) => pt(x, y)).join(" -- ");
+  switch (p.k) {
+    case "line": {
+      const { color } = tikzColor(p.stroke);
+      const op = p.opacity !== void 0 && p.opacity < 1 ? `,draw opacity=${round(p.opacity)}` : "";
+      return `\\draw[color=${color},line width=${round(p.w * s)}pt${op}] ${pt(p.x1, p.y1)} -- ${pt(p.x2, p.y2)};`;
+    }
+    case "polyline": {
+      const { color } = tikzColor(p.stroke);
+      return `\\draw[color=${color},line width=${round(p.w * s)}pt] ${path(p.pts)};`;
+    }
+    case "polygon": {
+      const f = tikzColor(p.fill);
+      const st = tikzColor(p.stroke);
+      const drawOpt = p.stroke === "none" ? "draw=none" : `draw=${st.color}`;
+      const op = f.alpha < 1 ? `,fill opacity=${f.alpha}` : "";
+      return `\\filldraw[fill=${f.color},${drawOpt}${op}] ${path(p.pts)} -- cycle;`;
+    }
+    case "rect": {
+      const f = tikzColor(p.fill);
+      const op = f.alpha < 1 ? `[fill opacity=${f.alpha}]` : "";
+      return `\\fill${op}[color=${f.color}] ${pt(p.x, p.y)} rectangle ${pt(p.x + p.w, p.y + p.h)};`;
+    }
+    case "circle": {
+      const f = tikzColor(p.fill);
+      const a = (p.opacity ?? 1) * f.alpha;
+      const op = a < 1 ? `,fill opacity=${round(a)}` : "";
+      return `\\filldraw[fill=${f.color},draw=none${op}] ${pt(p.cx, p.cy)} circle (${round(p.r * s)}pt);`;
+    }
+    case "text": {
+      const { color } = tikzColor(p.fill);
+      const rot = p.rotate !== void 0 ? `,rotate=${p.rotate}` : "";
+      return `\\node[anchor=${ANCHOR[p.anchor]},text=${color},font=\\fontsize{${round(p.size * s)}}{${round(p.size * s * 1.2)}}\\selectfont${rot}] at ${pt(p.x, p.y)} {${texEsc(p.s)}};`;
+    }
+  }
+}
+function emitTikZ(scene, opts = {}) {
+  const s = opts.tikz?.scale ?? 0.75;
+  const X = (x) => round(x * s);
+  const Y = (y) => round((scene.height - y) * s);
+  const bg = tikzColor(scene.bg);
+  const body = [
+    `\\fill[color=${bg.color}] (${X(0)},${Y(scene.height)}) rectangle (${X(scene.width)},${Y(0)});`,
+    ...scene.prims.map((p) => primTikZ(p, X, Y, s))
+  ];
+  const pic = `\\begin{tikzpicture}[x=1pt,y=1pt]
+${body.join("\n")}
+\\end{tikzpicture}`;
+  if (opts.tikz?.standalone === false) return pic;
+  return `\\documentclass[tikz,border=2pt]{standalone}
+\\begin{document}
+${pic}
+\\end{document}`;
+}
+
+// src/emit.ts
+function emit(scene, opts = {}) {
+  return opts.format === "tikz" ? emitTikZ(scene, opts) : emitSVG(scene);
+}
+
+// src/frame.ts
+var MARGIN = { top: 34, right: 20, bottom: 46, left: 64 };
+function combinedExtent(layers, pick) {
+  const all = [];
+  for (const l of layers) all.push(...pick(l));
+  return extent(all);
+}
+function noDataScene(width, height, theme) {
+  return {
+    width,
+    height,
+    bg: theme.bg,
+    prims: [
+      {
+        k: "text",
+        x: width / 2,
+        y: height / 2,
+        s: "no data",
+        fill: theme.muted,
+        anchor: "middle",
+        size: 13
+      }
+    ]
+  };
+}
+function draw2D(layers, opts = {}) {
+  const width = opts.width ?? 520;
+  const height = opts.height ?? 320;
+  const theme = THEMES[opts.theme ?? "light"];
+  try {
+    const yAll = layers.flatMap((l) => coerce1d(l.y));
+    if (yAll.length === 0) return emit(noDataScene(width, height, theme), opts);
+    const xdom = combinedExtent(
+      layers,
+      (l) => l.x ? coerce1d(l.x) : coerce1d(l.y).map((_, i) => i)
+    );
+    const ydom = combinedExtent(layers, (l) => coerce1d(l.y));
+    if (!Number.isFinite(xdom[0]) || !Number.isFinite(ydom[0]))
+      return emit(noDataScene(width, height, theme), opts);
+    const innerX = [MARGIN.left, width - MARGIN.right];
+    const innerY = [height - MARGIN.bottom, MARGIN.top];
+    const xScaleFn = opts.x?.scale === "log" ? logScale : linearScale;
+    const yScaleFn = opts.y?.scale === "log" ? logScale : linearScale;
+    const px = xScaleFn(xdom, innerX);
+    const py = yScaleFn(ydom, innerY);
+    const frame = {
+      px,
+      py,
+      xdom,
+      ydom,
+      theme,
+      width,
+      height,
+      color: (i) => theme.series[i % theme.series.length]
+    };
+    const prims = [];
+    const xticks = niceTicks(xdom[0], xdom[1]).filter((t) => t >= xdom[0] && t <= xdom[1]);
+    const yticks = niceTicks(ydom[0], ydom[1]).filter((t) => t >= ydom[0] && t <= ydom[1]);
+    for (const t of xticks)
+      prims.push({
+        k: "line",
+        x1: px(t),
+        y1: innerY[0],
+        x2: px(t),
+        y2: innerY[1],
+        stroke: theme.grid,
+        w: 1
+      });
+    for (const t of yticks)
+      prims.push({
+        k: "line",
+        x1: innerX[0],
+        y1: py(t),
+        x2: innerX[1],
+        y2: py(t),
+        stroke: theme.grid,
+        w: 1
+      });
+    prims.push({
+      k: "line",
+      x1: MARGIN.left,
+      y1: height - MARGIN.bottom,
+      x2: width - MARGIN.right,
+      y2: height - MARGIN.bottom,
+      stroke: theme.axis,
+      w: 1
+    });
+    prims.push({
+      k: "line",
+      x1: MARGIN.left,
+      y1: MARGIN.top,
+      x2: MARGIN.left,
+      y2: height - MARGIN.bottom,
+      stroke: theme.axis,
+      w: 1
+    });
+    for (const t of xticks)
+      prims.push({
+        k: "text",
+        x: px(t),
+        y: height - MARGIN.bottom + 16,
+        s: fmt(t),
+        fill: theme.muted,
+        anchor: "middle",
+        size: 11
+      });
+    for (const t of yticks)
+      prims.push({
+        k: "text",
+        x: MARGIN.left - 8,
+        y: py(t) + 4,
+        s: fmt(t),
+        fill: theme.muted,
+        anchor: "end",
+        size: 11
+      });
+    if (opts.title)
+      prims.push({
+        k: "text",
+        x: width / 2,
+        y: 20,
+        s: opts.title,
+        fill: theme.fg,
+        anchor: "middle",
+        size: 14
+      });
+    if (opts.xLabel)
+      prims.push({
+        k: "text",
+        x: MARGIN.left + (width - MARGIN.left - MARGIN.right) / 2,
+        y: height - 8,
+        s: opts.xLabel,
+        fill: theme.fg,
+        anchor: "middle",
+        size: 12
+      });
+    if (opts.yLabel)
+      prims.push({
+        k: "text",
+        x: 16,
+        y: MARGIN.top + (height - MARGIN.top - MARGIN.bottom) / 2,
+        s: opts.yLabel,
+        fill: theme.fg,
+        anchor: "middle",
+        size: 12,
+        rotate: -90
+      });
+    layers.forEach((l, i) => prims.push(...renderLayer(l, frame, i)));
+    if (opts.legend && layers.some((l) => l.label)) {
+      layers.forEach((l, i) => {
+        if (!l.label) return;
+        const ly = MARGIN.top + 4 + i * 16;
+        const c = l.color ?? frame.color(i);
+        prims.push({ k: "rect", x: width - MARGIN.right - 120, y: ly - 8, w: 10, h: 10, fill: c });
+        prims.push({
+          k: "text",
+          x: width - MARGIN.right - 106,
+          y: ly + 1,
+          s: l.label,
+          fill: theme.fg,
+          anchor: "start",
+          size: 11
+        });
+      });
+    }
+    return emit({ width, height, bg: theme.bg, prims }, opts);
+  } catch {
+    return emit(noDataScene(width, height, theme), opts);
+  }
+}
+
+// src/marks2d.ts
+function line2(x, y, opts) {
+  return draw2D([{ type: "line", x, y }], opts);
+}
+function scatter(x, y, opts) {
+  return draw2D([{ type: "scatter", x, y }], opts);
+}
+function bar(x, y, opts) {
+  return draw2D([{ type: "bar", x, y }], opts);
+}
+function area(x, y, opts) {
+  return draw2D([{ type: "area", x, y }], opts);
+}
+function step(x, y, opts) {
+  return draw2D([{ type: "step", x, y }], opts);
+}
+function errorbar(x, y, yerr, opts) {
+  return draw2D([{ type: "errorbar", x, y, yerr }], opts);
+}
+function quiver(x, y, u, v, opts) {
+  return draw2D([{ type: "quiver", x, y, u, v }], opts);
+}
+
+// src/overlay.ts
+function overlay(layers, opts) {
+  return draw2D(layers, opts);
+}
+
+// src/palette.ts
+var STOPS = [
+  [68, 1, 84],
+  [72, 40, 120],
+  [62, 74, 137],
+  [49, 104, 142],
+  [38, 130, 142],
+  [31, 158, 137],
+  [53, 183, 121],
+  [110, 206, 88],
+  [253, 231, 37]
+];
+var hex = (n) => Math.round(n).toString(16).padStart(2, "0");
+function viridis(t) {
+  const c = Math.max(0, Math.min(1, t));
+  const s = c * (STOPS.length - 1);
+  const i = Math.min(STOPS.length - 2, Math.floor(s));
+  const f = s - i;
+  const a = STOPS[i];
+  const b = STOPS[i + 1];
+  const r = a[0] + (b[0] - a[0]) * f;
+  const g = a[1] + (b[1] - a[1]) * f;
+  const bl = a[2] + (b[2] - a[2]) * f;
+  return `#${hex(r)}${hex(g)}${hex(bl)}`;
+}
+
+// src/contour.ts
+var MARGIN2 = { top: 34, right: 22, bottom: 30, left: 40 };
+function contour(z, opts = {}) {
+  const width = opts.width ?? 520;
+  const height = opts.height ?? 320;
+  const theme = THEMES[opts.theme ?? "light"];
+  const grid = coerce2d(z);
+  const rows = grid.length;
+  const cols = rows ? grid[0].length : 0;
+  if (rows < 2 || cols < 2) {
+    const scene = {
+      width,
+      height,
+      bg: theme.bg,
+      prims: [
+        {
+          k: "text",
+          x: width / 2,
+          y: height / 2,
+          s: "no data",
+          fill: theme.muted,
+          anchor: "middle",
+          size: 13
+        }
+      ]
+    };
+    return emit(scene, opts);
+  }
+  let lo = Infinity;
+  let hi = -Infinity;
+  for (const row of grid)
+    for (const v of row)
+      if (Number.isFinite(v)) {
+        if (v < lo) lo = v;
+        if (v > hi) hi = v;
+      }
+  const nLevels = opts.levels ?? 10;
+  const px = linearScale([0, cols - 1], [MARGIN2.left, width - MARGIN2.right]);
+  const py = linearScale([0, rows - 1], [height - MARGIN2.bottom, MARGIN2.top]);
+  const prims = [];
+  const span = hi > lo ? hi - lo : 1;
+  for (let li = 1; li <= nLevels; li++) {
+    const level = lo + span * li / (nLevels + 1);
+    const color = viridis(li / (nLevels + 1));
+    const interp = (va, vb) => (level - va) / (vb - va);
+    for (let r = 0; r < rows - 1; r++) {
+      for (let c = 0; c < cols - 1; c++) {
+        const tl = grid[r][c];
+        const tr = grid[r][c + 1];
+        const br = grid[r + 1][c + 1];
+        const bl = grid[r + 1][c];
+        if (![tl, tr, br, bl].every(Number.isFinite)) continue;
+        const cross = [];
+        if (tl < level !== tr < level) cross.push([c + interp(tl, tr), r]);
+        if (tr < level !== br < level) cross.push([c + 1, r + interp(tr, br)]);
+        if (bl < level !== br < level) cross.push([c + interp(bl, br), r + 1]);
+        if (tl < level !== bl < level) cross.push([c, r + interp(tl, bl)]);
+        for (let k = 0; k + 1 < cross.length; k += 2) {
+          const [ax, ay] = cross[k];
+          const [bx, by] = cross[k + 1];
+          prims.push({
+            k: "line",
+            x1: px(ax),
+            y1: py(ay),
+            x2: px(bx),
+            y2: py(by),
+            stroke: color,
+            w: 1.5
+          });
+        }
+      }
+    }
+  }
+  if (opts.title)
+    prims.push({
+      k: "text",
+      x: width / 2,
+      y: 20,
+      s: opts.title,
+      fill: theme.fg,
+      anchor: "middle",
+      size: 14
+    });
+  return emit({ width, height, bg: theme.bg, prims }, opts);
+}
+
+// src/three/project.ts
+function project(p, cam) {
+  const az = cam.azim * Math.PI / 180;
+  const el = cam.elev * Math.PI / 180;
+  const [x, y, z] = p;
+  const xa = x * Math.cos(az) - y * Math.sin(az);
+  const ya = x * Math.sin(az) + y * Math.cos(az);
+  const sx = xa;
+  const sy = z * Math.cos(el) - ya * Math.sin(el);
+  const depth = z * Math.sin(el) + ya * Math.cos(el);
+  return [sx, sy, depth];
+}
+
+// src/three/surface.ts
+var MARGIN3 = 40;
+function surface(z, opts = {}) {
+  const width = opts.width ?? 520;
+  const height = opts.height ?? 320;
+  const theme = THEMES[opts.theme ?? "light"];
+  const grid = coerce2d(z);
+  const rows = grid.length;
+  const cols = rows ? grid[0].length : 0;
+  if (rows < 2 || cols < 2) {
+    const scene = {
+      width,
+      height,
+      bg: theme.bg,
+      prims: [
+        {
+          k: "text",
+          x: width / 2,
+          y: height / 2,
+          s: "no data",
+          fill: theme.muted,
+          anchor: "middle",
+          size: 13
+        }
+      ]
+    };
+    return emit(scene, opts);
+  }
+  const cam = { azim: opts.azim ?? 45, elev: opts.elev ?? 25 };
+  let zlo = Infinity;
+  let zhi = -Infinity;
+  for (const row of grid)
+    for (const v of row)
+      if (Number.isFinite(v)) {
+        if (v < zlo) zlo = v;
+        if (v > zhi) zhi = v;
+      }
+  const zspan = zhi > zlo ? zhi - zlo : 1;
+  const proj = [];
+  let sxlo = Infinity, sxhi = -Infinity, sylo = Infinity, syhi = -Infinity;
+  for (let r = 0; r < rows; r++) {
+    const prow = [];
+    for (let c = 0; c < cols; c++) {
+      const wx = c / (cols - 1) * 2 - 1;
+      const wy = r / (rows - 1) * 2 - 1;
+      const wz = (grid[r][c] - zlo) / zspan * 2 - 1;
+      const p = project([wx, wy, wz], cam);
+      prow.push(p);
+      if (p[0] < sxlo) sxlo = p[0];
+      if (p[0] > sxhi) sxhi = p[0];
+      if (p[1] < sylo) sylo = p[1];
+      if (p[1] > syhi) syhi = p[1];
+    }
+    proj.push(prow);
+  }
+  const sxSpan = sxhi > sxlo ? sxhi - sxlo : 1;
+  const sySpan = syhi > sylo ? syhi - sylo : 1;
+  const toScreen = (p) => [
+    MARGIN3 + (p[0] - sxlo) / sxSpan * (width - 2 * MARGIN3),
+    height - MARGIN3 - (p[1] - sylo) / sySpan * (height - 2 * MARGIN3)
+  ];
+  const kind = opts.kind ?? "filled";
+  const prims = [];
+  if (kind === "wireframe") {
+    for (let r = 0; r < rows; r++)
+      prims.push({ k: "polyline", pts: proj[r].map(toScreen), stroke: theme.series[0], w: 1 });
+    for (let c = 0; c < cols; c++)
+      prims.push({
+        k: "polyline",
+        pts: proj.map((row) => toScreen(row[c])),
+        stroke: theme.series[0],
+        w: 1
+      });
+  } else {
+    const quads = [];
+    for (let r = 0; r < rows - 1; r++) {
+      for (let c = 0; c < cols - 1; c++) {
+        const corners = [proj[r][c], proj[r][c + 1], proj[r + 1][c + 1], proj[r + 1][c]];
+        const depth = (corners[0][2] + corners[1][2] + corners[2][2] + corners[3][2]) / 4;
+        const meanZ = (grid[r][c] + grid[r][c + 1] + grid[r + 1][c + 1] + grid[r + 1][c]) / 4;
+        quads.push({ depth, pts: corners.map(toScreen), shade: (meanZ - zlo) / zspan });
+      }
+    }
+    quads.sort((a, b) => b.depth - a.depth);
+    for (const q of quads)
+      prims.push({ k: "polygon", pts: q.pts, fill: viridis(q.shade), stroke: theme.grid });
+  }
+  if (opts.title)
+    prims.push({
+      k: "text",
+      x: width / 2,
+      y: 20,
+      s: opts.title,
+      fill: theme.fg,
+      anchor: "middle",
+      size: 14
+    });
+  return emit({ width, height, bg: theme.bg, prims }, opts);
+}
+
+// src/plot.ts
+function isLayerArray(v) {
+  return Array.isArray(v) && v.length > 0 && typeof v[0] === "object" && v[0] !== null && "type" in v[0];
+}
+function freeVars(source) {
+  const names = /* @__PURE__ */ new Set();
+  const funcs = /* @__PURE__ */ new Set();
+  try {
+    const node = parse(source);
+    if (typeof node.traverse === "function") {
+      node.traverse((n) => {
+        const nn = n;
+        if (nn.type === "SymbolNode" && nn.name) names.add(nn.name);
+        if (nn.type === "FunctionNode" && nn.name) funcs.add(nn.name);
+      });
+    }
+  } catch {
+  }
+  funcs.forEach((f) => names.delete(f));
+  ["pi", "e", "tau"].forEach((c) => names.delete(c));
+  return [...names];
+}
+function plotExpr(source, opts) {
+  const { kind, ...rest } = opts;
+  const from = opts.from ?? -10;
+  const to = opts.to ?? 10;
+  const n = opts.samples ?? 200;
+  const scope = opts.scope ?? {};
+  const rangeFn = range;
+  const grid = rangeFn(from, to, (to - from) / (n - 1), true).toArray?.() ?? Array.from({ length: n }, (_, i) => from + (to - from) * i / (n - 1));
+  const vars = freeVars(source);
+  if (vars.length <= 1) {
+    const v = vars[0] ?? "x";
+    const ys = grid.map((val) => {
+      try {
+        return Number(evaluate(source, { ...scope, [v]: val }));
+      } catch {
+        return NaN;
+      }
+    });
+    return line2(grid, ys, { xLabel: v, title: source, ...rest });
+  }
+  const [vx, vy] = vars;
+  const g2 = grid.map(
+    (yv) => grid.map((xv) => {
+      try {
+        return Number(evaluate(source, { ...scope, [vx]: xv, [vy]: yv }));
+      } catch {
+        return NaN;
+      }
+    })
+  );
+  return kind === "3d" || kind === "surface" ? surface(g2, { title: source, ...rest }) : contour(g2, { title: source, ...rest });
+}
+function plot(a, b, c) {
+  if (typeof a === "string") return plotExpr(a, b ?? {});
+  if (isLayerArray(a)) return overlay(a, b ?? {});
+  if (Array.isArray(b) || b instanceof Float64Array) return line2(a, b, c);
+  return line2(void 0, a, b ?? {});
+}
+function toTikZ(a, b, c) {
+  if (typeof a === "string") return plot(a, { ...b ?? {}, format: "tikz" });
+  if (Array.isArray(a) && a.length > 0 && typeof a[0] === "object" && a[0] !== null && "type" in a[0])
+    return plot(a, { ...b ?? {}, format: "tikz" });
+  if (Array.isArray(b) || b instanceof Float64Array)
+    return plot(a, b, { ...c ?? {}, format: "tikz" });
+  return plot(a, { ...b ?? {}, format: "tikz" });
+}
+
+// src/histogram.ts
+import { histogram as histBins } from "@danielsimonjr/mathts-functions";
+function histogram(data, opts = {}) {
+  const nums = coerce1d(data);
+  if (nums.length === 0) return draw2D([], opts);
+  const { counts, edges } = histBins(nums, opts.bins ?? 10);
+  const centers = counts.map((_, i) => (edges[i] + edges[i + 1]) / 2);
+  return draw2D([{ type: "bar", x: centers, y: counts, color: opts.palette?.[0] }], {
+    yLabel: "count",
+    ...opts
+  });
+}
+
+// src/heatmap.ts
+var MARGIN4 = { top: 34, right: 22, bottom: 30, left: 40 };
+function heatmap(z, opts = {}) {
+  const width = opts.width ?? 520;
+  const height = opts.height ?? 320;
+  const theme = THEMES[opts.theme ?? "light"];
+  const grid = coerce2d(z);
+  const rows = grid.length;
+  const cols = rows ? grid[0].length : 0;
+  if (rows === 0 || cols === 0) {
+    const scene = {
+      width,
+      height,
+      bg: theme.bg,
+      prims: [
+        {
+          k: "text",
+          x: width / 2,
+          y: height / 2,
+          s: "no data",
+          fill: theme.muted,
+          anchor: "middle",
+          size: 13
+        }
+      ]
+    };
+    return emit(scene, opts);
+  }
+  let lo = Infinity;
+  let hi = -Infinity;
+  for (const row of grid)
+    for (const v of row)
+      if (Number.isFinite(v)) {
+        if (v < lo) lo = v;
+        if (v > hi) hi = v;
+      }
+  const span = hi > lo ? hi - lo : 1;
+  const cw = (width - MARGIN4.left - MARGIN4.right) / cols;
+  const ch = (height - MARGIN4.top - MARGIN4.bottom) / rows;
+  const prims = [];
+  for (let r = 0; r < rows; r++) {
+    for (let c = 0; c < cols; c++) {
+      const v = grid[r][c];
+      const color = Number.isFinite(v) ? viridis((v - lo) / span) : theme.grid;
+      prims.push({
+        k: "rect",
+        x: MARGIN4.left + c * cw,
+        y: MARGIN4.top + r * ch,
+        w: cw + 0.5,
+        h: ch + 0.5,
+        fill: color
+      });
+    }
+  }
+  if (opts.title)
+    prims.push({
+      k: "text",
+      x: width / 2,
+      y: 20,
+      s: opts.title,
+      fill: theme.fg,
+      anchor: "middle",
+      size: 14
+    });
+  return emit({ width, height, bg: theme.bg, prims }, opts);
+}
+
+// src/three/points3d.ts
+var MARGIN5 = 40;
+function minOf(a) {
+  let m = Infinity;
+  for (const v of a) if (v < m) m = v;
+  return m;
+}
+function maxOf(a) {
+  let m = -Infinity;
+  for (const v of a) if (v > m) m = v;
+  return m;
+}
+function projectAll(x, y, z, cam) {
+  const xs = coerce1d(x);
+  const ys = coerce1d(y);
+  const zs = coerce1d(z);
+  const n = Math.min(xs.length, ys.length, zs.length);
+  const nx = (a) => {
+    const lo = minOf(a);
+    const hi = maxOf(a);
+    const s = hi > lo ? hi - lo : 1;
+    return (v) => (v - lo) / s * 2 - 1;
+  };
+  const fx = nx(xs.slice(0, n));
+  const fy = nx(ys.slice(0, n));
+  const fz = nx(zs.slice(0, n));
+  const screen = [];
+  for (let i = 0; i < n; i++) screen.push(project([fx(xs[i]), fy(ys[i]), fz(zs[i])], cam));
+  return { screen };
+}
+function render(x, y, z, opts, mode) {
+  const width = opts.width ?? 520;
+  const height = opts.height ?? 320;
+  const theme = THEMES[opts.theme ?? "light"];
+  const cam = { azim: opts.azim ?? 45, elev: opts.elev ?? 25 };
+  const { screen } = projectAll(x, y, z, cam);
+  if (screen.length === 0) {
+    const scene = {
+      width,
+      height,
+      bg: theme.bg,
+      prims: [
+        {
+          k: "text",
+          x: width / 2,
+          y: height / 2,
+          s: "no data",
+          fill: theme.muted,
+          anchor: "middle",
+          size: 13
+        }
+      ]
+    };
+    return emit(scene, opts);
+  }
+  let sxlo = Infinity, sxhi = -Infinity, sylo = Infinity, syhi = -Infinity;
+  for (const p of screen) {
+    if (p[0] < sxlo) sxlo = p[0];
+    if (p[0] > sxhi) sxhi = p[0];
+    if (p[1] < sylo) sylo = p[1];
+    if (p[1] > syhi) syhi = p[1];
+  }
+  const sxSpan = sxhi > sxlo ? sxhi - sxlo : 1;
+  const sySpan = syhi > sylo ? syhi - sylo : 1;
+  const toScreen = (p) => [
+    MARGIN5 + (p[0] - sxlo) / sxSpan * (width - 2 * MARGIN5),
+    height - MARGIN5 - (p[1] - sylo) / sySpan * (height - 2 * MARGIN5)
+  ];
+  const color = theme.series[0];
+  const prims = [];
+  if (mode === "line") {
+    const depths = screen.map((p) => p[2]);
+    const dlo = minOf(depths);
+    const dhi = maxOf(depths);
+    const dspan = dhi > dlo ? dhi - dlo : 1;
+    const segs = [];
+    for (let i = 0; i + 1 < screen.length; i++) {
+      const a = screen[i];
+      const b = screen[i + 1];
+      segs.push({ a, b, depth: (a[2] + b[2]) / 2 });
+    }
+    segs.sort((s1, s2) => s2.depth - s1.depth);
+    for (const sg of segs) {
+      const near = 1 - (sg.depth - dlo) / dspan;
+      const opacity = 0.4 + 0.6 * near;
+      const [x1, y1] = toScreen(sg.a);
+      const [x2, y2] = toScreen(sg.b);
+      prims.push({ k: "line", x1, y1, x2, y2, stroke: color, w: 2, opacity });
+    }
+  } else {
+    const depths = screen.map((p) => p[2]);
+    const dlo = minOf(depths);
+    const dhi = maxOf(depths);
+    const dspan = dhi > dlo ? dhi - dlo : 1;
+    const sorted = screen.slice().sort((a, b) => b[2] - a[2]);
+    for (const p of sorted) {
+      const [sx, sy] = toScreen(p);
+      const near = 1 - (p[2] - dlo) / dspan;
+      const opacity = 0.4 + 0.6 * near;
+      prims.push({ k: "circle", cx: sx, cy: sy, r: 3, fill: color, opacity });
+    }
+  }
+  if (opts.title)
+    prims.push({
+      k: "text",
+      x: width / 2,
+      y: 20,
+      s: opts.title,
+      fill: theme.fg,
+      anchor: "middle",
+      size: 14
+    });
+  return emit({ width, height, bg: theme.bg, prims }, opts);
+}
+function scatter3d(x, y, z, opts = {}) {
+  return render(x, y, z, opts, "points");
+}
+function curve3d(x, y, z, opts = {}) {
+  return render(x, y, z, opts, "line");
+}
+
+// src/index.ts
+var VERSION = "0.2.0";
+export {
+  VERSION,
+  area,
+  bar,
+  contour,
+  curve3d,
+  errorbar,
+  heatmap,
+  histogram,
+  line2 as line,
+  overlay,
+  plot,
+  quiver,
+  scatter,
+  scatter3d,
+  step,
+  surface,
+  toTikZ,
+  viridis
+};