@ggterm/core 0.2.5 → 0.2.9

package/dist/index.js

@@ -29,423 +29,102 @@ var __export = (target, all) => {
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
-// src/pipeline/scales.ts
-var exports_scales = {};
-__export(exports_scales, {
-  niceDomain: () => niceDomain,
-  inferDiscreteDomain: () => inferDiscreteDomain,
-  inferContinuousDomain: () => inferContinuousDomain,
-  getTransformFunctions: () => getTransformFunctions,
-  expandDomain: () => expandDomain,
-  createResolvedSizeScale: () => createResolvedSizeScale,
-  createResolvedDiscreteScale: () => createResolvedDiscreteScale,
-  createResolvedDiscreteColorScale: () => createResolvedDiscreteColorScale,
-  createResolvedContinuousScale: () => createResolvedContinuousScale,
-  createResolvedContinuousColorScale: () => createResolvedContinuousColorScale,
-  buildScaleContext: () => buildScaleContext,
-  DEFAULT_POINT_COLOR: () => DEFAULT_POINT_COLOR
-});
-function inferContinuousDomain(data, field) {
-  let min = Infinity;
-  let max = -Infinity;
-  for (const row of data) {
-    const value = row[field];
-    if (typeof value === "number" && !isNaN(value)) {
-      if (value < min)
-        min = value;
-      if (value > max)
-        max = value;
-    }
-  }
-  if (min === Infinity)
-    min = 0;
-  if (max === -Infinity)
-    max = 1;
-  if (min === max) {
-    min = min - 1;
-    max = max + 1;
-  }
-  return [min, max];
-}
-function inferDiscreteDomain(data, field, options = {}) {
-  const { limits, order = "alphabetical", reverse = false, exclude, drop = true } = options;
-  const seen = new Map;
-  let index = 0;
-  for (const row of data) {
-    const value = row[field];
-    if (value !== null && value !== undefined) {
-      const key = String(value);
-      if (!seen.has(key)) {
-        seen.set(key, { firstIndex: index, count: 1 });
-      } else {
-        seen.get(key).count++;
-      }
-    }
-    index++;
-  }
-  let result;
-  if (limits) {
-    if (drop) {
-      result = limits.filter((v) => seen.has(v));
-    } else {
-      result = [...limits];
-    }
-  } else {
-    const values = Array.from(seen.keys());
-    switch (order) {
-      case "data":
-        result = values.sort((a, b) => seen.get(a).firstIndex - seen.get(b).firstIndex);
-        break;
-      case "frequency":
-        result = values.sort((a, b) => seen.get(b).count - seen.get(a).count);
-        break;
-      case "reverse":
-        result = values.sort().reverse();
-        break;
-      case "alphabetical":
-      default:
-        result = values.sort();
-        break;
-    }
-  }
-  if (exclude && exclude.length > 0) {
-    const excludeSet = new Set(exclude);
-    result = result.filter((v) => !excludeSet.has(v));
-  }
-  if (reverse) {
-    result = result.reverse();
-  }
-  return result;
-}
-function expandDomain(domain, expand = 0.05) {
-  const range = domain[1] - domain[0];
-  const padding = range * expand;
-  return [domain[0] - padding, domain[1] + padding];
-}
-function niceStep(range, targetTicks = 5) {
-  const rawStep = range / Math.max(1, targetTicks - 1);
-  const magnitude = Math.pow(10, Math.floor(Math.log10(rawStep)));
-  const normalized = rawStep / magnitude;
-  let nice;
-  if (normalized <= 1.5)
-    nice = 1;
-  else if (normalized <= 3)
-    nice = 2;
-  else if (normalized <= 7)
-    nice = 5;
-  else
-    nice = 10;
-  return nice * magnitude;
-}
-function niceDomain(domain, targetTicks = 5) {
-  const [min, max] = domain;
-  const range = max - min;
-  if (range === 0) {
-    if (min === 0)
-      return [-1, 1];
-    const magnitude = Math.pow(10, Math.floor(Math.log10(Math.abs(min))));
-    return [min - magnitude, min + magnitude];
-  }
-  const step = niceStep(range, targetTicks);
-  const niceMin = Math.floor(min / step) * step;
-  const niceMax = Math.ceil(max / step) * step;
-  return [niceMin, niceMax];
-}
-function getTransformFunctions(trans = "identity") {
-  switch (trans) {
-    case "log10":
-      return {
-        type: "log10",
-        transform: (v) => v > 0 ? Math.log10(v) : -Infinity,
-        invert: (v) => Math.pow(10, v)
-      };
-    case "sqrt":
-      return {
-        type: "sqrt",
-        transform: (v) => v >= 0 ? Math.sqrt(v) : 0,
-        invert: (v) => v * v
-      };
-    case "reverse":
-      return {
-        type: "reverse",
-        transform: (v) => -v,
-        invert: (v) => -v
-      };
-    default:
-      return {
-        type: "identity",
-        transform: (v) => v,
-        invert: (v) => v
-      };
-  }
-}
-function createResolvedContinuousScale(aesthetic, domain, range, trans = "identity") {
-  const [domainMin, domainMax] = domain;
-  const [rangeMin, rangeMax] = range;
-  const rangeSpan = rangeMax - rangeMin;
-  const { transform, invert } = getTransformFunctions(trans);
+// src/themes/default.ts
+function defaultTheme() {
   return {
-    aesthetic,
-    type: "continuous",
-    domain,
-    range,
-    trans,
-    transform,
-    invert,
-    normalize(value) {
-      const num = Number(value);
-      if (isNaN(num))
-        return 0;
-      const transformed = transform(num);
-      const transformedMin = transform(domainMin);
-      const transformedMax = transform(domainMax);
-      if (transformedMax === transformedMin)
-        return 0.5;
-      return (transformed - transformedMin) / (transformedMax - transformedMin);
+    panel: {
+      background: "",
+      border: "single",
+      grid: { major: "·", minor: null }
     },
-    toCanvas(normalized) {
-      return rangeMin + normalized * rangeSpan;
+    axis: {
+      text: { color: "" },
+      ticks: { char: "┼", length: 1 },
+      title: { color: "", bold: false }
     },
-    map(value) {
-      return this.toCanvas(this.normalize(value));
+    legend: {
+      position: "right",
+      title: { bold: true }
+    },
+    title: {
+      align: "center",
+      bold: true
+    },
+    facet: {
+      strip: {
+        text: "#c8c8c8",
+        background: ""
+      }
     }
   };
 }
-function createResolvedDiscreteScale(aesthetic, domain, range) {
-  const [rangeMin, rangeMax] = range;
-  const rangeSpan = rangeMax - rangeMin;
+function themeMinimal() {
   return {
-    aesthetic,
-    type: "discrete",
-    domain,
-    range,
-    normalize(value) {
-      const str = String(value);
-      const index = domain.indexOf(str);
-      if (index < 0)
-        return 0;
-      return domain.length > 1 ? index / (domain.length - 1) : 0.5;
+    panel: {
+      background: "",
+      border: "none",
+      grid: { major: null, minor: null }
     },
-    toCanvas(normalized) {
-      return rangeMin + normalized * rangeSpan;
+    axis: {
+      text: { color: "" },
+      ticks: { char: "│", length: 1 },
+      title: { color: "", bold: false }
     },
-    map(value) {
-      return this.toCanvas(this.normalize(value));
+    legend: {
+      position: "right",
+      title: { bold: false }
+    },
+    title: {
+      align: "left",
+      bold: false
+    },
+    facet: {
+      strip: {
+        text: "#999999",
+        background: ""
+      }
     }
   };
 }
-function interpolateColor(color1, color2, t) {
-  return {
-    r: Math.round(color1.r + (color2.r - color1.r) * t),
-    g: Math.round(color1.g + (color2.g - color1.g) * t),
-    b: Math.round(color1.b + (color2.b - color1.b) * t),
-    a: color1.a + (color2.a - color1.a) * t
-  };
-}
-function createResolvedDiscreteColorScale(domain, palette = CATEGORY_COLORS) {
+function themeDark() {
   return {
-    aesthetic: "color",
-    type: "discrete",
-    domain,
-    map(value) {
-      const str = String(value);
-      const index = domain.indexOf(str);
-      if (index < 0)
-        return palette[0];
-      return palette[index % palette.length];
-    }
-  };
-}
-function createResolvedContinuousColorScale(domain, lowColor = { r: 68, g: 1, b: 84, a: 1 }, highColor = { r: 253, g: 231, b: 37, a: 1 }) {
-  const [min, max] = domain;
-  const span = max - min;
-  return {
-    aesthetic: "color",
-    type: "continuous",
-    domain,
-    map(value) {
-      const num = Number(value);
-      if (isNaN(num))
-        return lowColor;
-      const t = Math.max(0, Math.min(1, (num - min) / span));
-      return interpolateColor(lowColor, highColor, t);
-    }
-  };
-}
-function isCategoricalField(data, field) {
-  for (const row of data) {
-    const value = row[field];
-    if (value !== null && value !== undefined) {
-      if (typeof value === "string" && isNaN(Number(value))) {
-        return true;
+    panel: {
+      background: "#1e1e1e",
+      border: "rounded",
+      grid: { major: "·", minor: null }
+    },
+    axis: {
+      text: { color: "#ccc" },
+      ticks: { char: "┼", length: 1 },
+      title: { color: "#fff", bold: true }
+    },
+    legend: {
+      position: "right",
+      title: { bold: true }
+    },
+    title: {
+      align: "center",
+      bold: true
+    },
+    facet: {
+      strip: {
+        text: "#ffffff",
+        background: "#333333"
       }
     }
-  }
-  return false;
-}
-function createResolvedSizeScale(domain) {
-  const [min, max] = domain;
-  const span = max - min;
-  return {
-    aesthetic: "size",
-    type: "continuous",
-    domain,
-    map(value) {
-      const num = Number(value);
-      if (isNaN(num))
-        return 1;
-      const t = Math.max(0, Math.min(1, (num - min) / span));
-      return Math.floor(t * 3.99);
-    }
   };
 }
-function computeDomain(data, field, trans = "identity") {
-  const rawDomain = inferContinuousDomain(data, field);
-  if (trans === "log10") {
-    const [min, max] = rawDomain;
-    const safeMin = min > 0 ? min : 0.001;
-    const safeMax = max > 0 ? max : 1;
-    const minPow = Math.floor(Math.log10(safeMin));
-    const maxPow = Math.ceil(Math.log10(safeMax));
-    return [Math.pow(10, minPow), Math.pow(10, maxPow)];
-  }
-  return niceDomain(rawDomain);
-}
-function buildScaleContext(data, aes, plotArea, userScales = [], coordLimits) {
-  const userXScale = userScales.find((s) => s.aesthetic === "x");
-  const userYScale = userScales.find((s) => s.aesthetic === "y");
-  const userColorScale = userScales.find((s) => s.aesthetic === "color" || s.aesthetic === "fill");
-  const xIsCategorical = isCategoricalField(data, aes.x);
-  let x;
-  if (xIsCategorical) {
-    const xOrderOptions = {};
-    if (userXScale) {
-      if (userXScale.domain && Array.isArray(userXScale.domain)) {
-        xOrderOptions.limits = userXScale.domain;
-      }
-      const orderOpts = userXScale.orderOptions;
-      if (orderOpts) {
-        if (orderOpts.order)
-          xOrderOptions.order = orderOpts.order;
-        if (orderOpts.reverse)
-          xOrderOptions.reverse = orderOpts.reverse;
-        if (orderOpts.exclude)
-          xOrderOptions.exclude = orderOpts.exclude;
-        if (orderOpts.drop !== undefined)
-          xOrderOptions.drop = orderOpts.drop;
-      }
-    }
-    const xDomain = inferDiscreteDomain(data, aes.x, xOrderOptions);
-    x = createResolvedDiscreteScale("x", xDomain, [plotArea.x, plotArea.x + plotArea.width - 1]);
-    if (userXScale?.labels) {
-      x.labels = userXScale.labels;
-    }
-  } else {
-    const xTrans = userXScale?.trans ?? "identity";
-    const xDomain = coordLimits?.xlim ?? userXScale?.domain ?? computeDomain(data, aes.x, xTrans);
-    x = createResolvedContinuousScale("x", xDomain, [plotArea.x, plotArea.x + plotArea.width - 1], xTrans);
-    if (userXScale?.breaks) {
-      x.breaks = userXScale.breaks;
-    }
-    if (userXScale?.labels) {
-      x.labels = userXScale.labels;
-    }
-  }
-  const yTrans = userYScale?.trans ?? "identity";
-  const yDomain = coordLimits?.ylim ?? userYScale?.domain ?? computeDomain(data, aes.y, yTrans);
-  const y = createResolvedContinuousScale("y", yDomain, [plotArea.y + plotArea.height - 1, plotArea.y], yTrans);
-  if (userYScale?.breaks) {
-    y.breaks = userYScale.breaks;
-  }
-  if (userYScale?.labels) {
-    y.labels = userYScale.labels;
-  }
-  const context = { x, y };
-  if (aes.y2) {
-    const userY2Scale = userScales.find((s) => s.aesthetic === "y2");
-    const y2Trans = userY2Scale?.trans ?? "identity";
-    const y2Domain = userY2Scale?.domain ?? computeDomain(data, aes.y2, y2Trans);
-    const y2 = createResolvedContinuousScale("y2", y2Domain, [plotArea.y + plotArea.height - 1, plotArea.y], y2Trans);
-    if (userY2Scale?.breaks) {
-      y2.breaks = userY2Scale.breaks;
-    }
-    if (userY2Scale?.labels) {
-      y2.labels = userY2Scale.labels;
-    }
-    context.y2 = y2;
-  }
-  const colorAesField = aes.color || aes.fill;
-  if (colorAesField) {
-    const colorOrderOptions = {};
-    if (userColorScale) {
-      if (userColorScale.domain && Array.isArray(userColorScale.domain)) {
-        colorOrderOptions.limits = userColorScale.domain;
-      }
-      const orderOpts = userColorScale.orderOptions;
-      if (orderOpts) {
-        if (orderOpts.order)
-          colorOrderOptions.order = orderOpts.order;
-        if (orderOpts.reverse)
-          colorOrderOptions.reverse = orderOpts.reverse;
-        if (orderOpts.exclude)
-          colorOrderOptions.exclude = orderOpts.exclude;
-        if (orderOpts.drop !== undefined)
-          colorOrderOptions.drop = orderOpts.drop;
-      }
-    }
-    const colorDomain = inferDiscreteDomain(data, colorAesField, colorOrderOptions);
-    if (userColorScale && userColorScale.map) {
-      context.color = {
-        aesthetic: userColorScale.aesthetic || "color",
-        type: userColorScale.type === "continuous" ? "continuous" : "discrete",
-        domain: userColorScale.type === "continuous" ? userColorScale.domain ?? inferContinuousDomain(data, colorAesField) : colorDomain,
-        map: (value) => {
-          const result = userColorScale.map(value);
-          if (typeof result === "object" && "r" in result) {
-            return result;
-          }
-          return { r: 128, g: 128, b: 128, a: 1 };
-        }
-      };
-    } else {
-      context.color = createResolvedDiscreteColorScale(colorDomain);
-    }
-  }
-  if (aes.size) {
-    const sizeDomain = inferContinuousDomain(data, aes.size);
-    context.size = createResolvedSizeScale(sizeDomain);
-  }
-  return context;
-}
-var CATEGORY_COLORS, DEFAULT_POINT_COLOR;
-var init_scales = __esm(() => {
-  CATEGORY_COLORS = [
-    { r: 31, g: 119, b: 180, a: 1 },
-    { r: 255, g: 127, b: 14, a: 1 },
-    { r: 44, g: 160, b: 44, a: 1 },
-    { r: 214, g: 39, b: 40, a: 1 },
-    { r: 148, g: 103, b: 189, a: 1 },
-    { r: 140, g: 86, b: 75, a: 1 },
-    { r: 227, g: 119, b: 194, a: 1 },
-    { r: 127, g: 127, b: 127, a: 1 },
-    { r: 188, g: 189, b: 34, a: 1 },
-    { r: 23, g: 190, b: 207, a: 1 }
-  ];
-  DEFAULT_POINT_COLOR = { r: 79, g: 169, b: 238, a: 1 };
-});
-
-// src/themes/default.ts
-function defaultTheme() {
+function themeClassic() {
   return {
     panel: {
       background: "",
       border: "single",
-      grid: { major: "·", minor: null }
+      grid: { major: null, minor: null }
     },
     axis: {
       text: { color: "" },
-      ticks: { char: "┼", length: 1 },
-      title: { color: "", bold: false }
+      ticks: { char: "─", length: 1 },
+      title: { color: "", bold: true }
     },
     legend: {
       position: "right",
@@ -463,7 +142,7 @@ function defaultTheme() {
     }
   };
 }
-function themeMinimal() {
+function themeVoid() {
   return {
     panel: {
       background: "",
@@ -472,11 +151,11 @@ function themeMinimal() {
     },
     axis: {
       text: { color: "" },
-      ticks: { char: "│", length: 1 },
+      ticks: { char: "", length: 0 },
       title: { color: "", bold: false }
     },
     legend: {
-      position: "right",
+      position: "none",
       title: { bold: false }
     },
     title: {
@@ -485,332 +164,677 @@ function themeMinimal() {
     },
     facet: {
       strip: {
-        text: "#999999",
+        text: "#888888",
         background: ""
       }
     }
   };
 }
-function themeDark() {
+
+// src/coords/cartesian.ts
+function coordCartesian(options = {}) {
   return {
-    panel: {
-      background: "#1e1e1e",
-      border: "rounded",
-      grid: { major: "·", minor: null }
-    },
-    axis: {
-      text: { color: "#ccc" },
-      ticks: { char: "┼", length: 1 },
-      title: { color: "#fff", bold: true }
-    },
-    legend: {
-      position: "right",
-      title: { bold: true }
-    },
-    title: {
-      align: "center",
-      bold: true
-    },
-    facet: {
-      strip: {
-        text: "#ffffff",
-        background: "#333333"
-      }
+    type: "cartesian",
+    xlim: options.xlim,
+    ylim: options.ylim,
+    clip: options.clip ?? true,
+    transform(x, y) {
+      return { x, y };
+    }
+  };
+}
+function coordFlip() {
+  return {
+    type: "flip",
+    transform(x, y) {
+      return { x: y, y: x };
     }
   };
 }
-function themeClassic() {
+function coordPolar(options = {}) {
+  const theta = options.theta ?? "x";
+  return {
+    type: "polar",
+    transform(x, y) {
+      const angle = theta === "x" ? x : y;
+      const radius = theta === "x" ? y : x;
+      return {
+        x: radius * Math.cos(angle),
+        y: radius * Math.sin(angle)
+      };
+    }
+  };
+}
+function coordFixed(options = {}) {
+  const ratio = options.ratio ?? 1;
+  return {
+    type: "fixed",
+    xlim: options.xlim,
+    ylim: options.ylim,
+    clip: options.clip ?? true,
+    ratio,
+    transform(x, y) {
+      return { x, y };
+    }
+  };
+}
+function coordEqual(options = {}) {
+  return coordFixed({ ...options, ratio: 1 });
+}
+function getTransform(type) {
+  switch (type) {
+    case "log10":
+      return (v) => v > 0 ? Math.log10(v) : -Infinity;
+    case "sqrt":
+      return (v) => v >= 0 ? Math.sqrt(v) : 0;
+    case "reverse":
+      return (v) => -v;
+    default:
+      return (v) => v;
+  }
+}
+function coordTrans(options = {}) {
+  const xTrans = getTransform(options.x ?? "identity");
+  const yTrans = getTransform(options.y ?? "identity");
+  return {
+    type: "trans",
+    xlim: options.xlim,
+    ylim: options.ylim,
+    clip: options.clip ?? true,
+    xTransType: options.x ?? "identity",
+    yTransType: options.y ?? "identity",
+    transform(x, y) {
+      return {
+        x: xTrans(x),
+        y: yTrans(y)
+      };
+    }
+  };
+}
+function coordFlipWithLimits(options = {}) {
+  return {
+    type: "flip",
+    xlim: options.xlim,
+    ylim: options.ylim,
+    clip: options.clip ?? true,
+    transform(x, y) {
+      return { x: y, y: x };
+    }
+  };
+}
+
+// src/canvas/canvas.ts
+function createEmptyCell() {
+  return {
+    char: " ",
+    fg: { ...DEFAULT_FG },
+    bg: { ...DEFAULT_BG }
+  };
+}
+
+class TerminalCanvas {
+  width;
+  height;
+  cells;
+  constructor(width, height) {
+    this.width = width;
+    this.height = height;
+    this.cells = [];
+    this.clear();
+  }
+  setCell(x, y, cell) {
+    if (!Number.isFinite(x) || !Number.isFinite(y) || x < 0 || x >= this.width || y < 0 || y >= this.height) {
+      return;
+    }
+    const ix = Math.floor(x);
+    const iy = Math.floor(y);
+    const existing = this.cells[iy][ix];
+    this.cells[iy][ix] = {
+      char: cell.char ?? existing.char,
+      fg: cell.fg ?? existing.fg,
+      bg: cell.bg ?? existing.bg,
+      bold: cell.bold ?? existing.bold,
+      italic: cell.italic ?? existing.italic,
+      underline: cell.underline ?? existing.underline
+    };
+  }
+  getCell(x, y) {
+    if (!Number.isFinite(x) || !Number.isFinite(y) || x < 0 || x >= this.width || y < 0 || y >= this.height) {
+      return createEmptyCell();
+    }
+    return this.cells[Math.floor(y)][Math.floor(x)];
+  }
+  clear() {
+    this.cells = [];
+    for (let y = 0;y < this.height; y++) {
+      const row = [];
+      for (let x = 0;x < this.width; x++) {
+        row.push(createEmptyCell());
+      }
+      this.cells.push(row);
+    }
+  }
+  drawChar(x, y, char, fg) {
+    this.setCell(x, y, { char, fg });
+  }
+  drawString(x, y, str, fg) {
+    for (let i = 0;i < str.length; i++) {
+      this.drawChar(x + i, y, str[i], fg);
+    }
+  }
+  drawHLine(x, y, length, char = "─", fg) {
+    for (let i = 0;i < length; i++) {
+      this.drawChar(x + i, y, char, fg);
+    }
+  }
+  drawVLine(x, y, length, char = "│", fg) {
+    for (let i = 0;i < length; i++) {
+      this.drawChar(x, y + i, char, fg);
+    }
+  }
+  drawPoint(x, y, fg, shape = "●") {
+    this.drawChar(x, y, shape, fg);
+  }
+  fillRect(x, y, width, height, char = " ", fg, bg) {
+    for (let dy = 0;dy < height; dy++) {
+      for (let dx = 0;dx < width; dx++) {
+        this.setCell(x + dx, y + dy, { char, fg, bg });
+      }
+    }
+  }
+  drawBox(x, y, width, height, style = "single", fg) {
+    const chars = style === "double" ? { tl: "╔", tr: "╗", bl: "╚", br: "╝", h: "═", v: "║" } : style === "rounded" ? { tl: "╭", tr: "╮", bl: "╰", br: "╯", h: "─", v: "│" } : { tl: "┌", tr: "┐", bl: "└", br: "┘", h: "─", v: "│" };
+    this.drawChar(x, y, chars.tl, fg);
+    this.drawChar(x + width - 1, y, chars.tr, fg);
+    this.drawChar(x, y + height - 1, chars.bl, fg);
+    this.drawChar(x + width - 1, y + height - 1, chars.br, fg);
+    this.drawHLine(x + 1, y, width - 2, chars.h, fg);
+    this.drawHLine(x + 1, y + height - 1, width - 2, chars.h, fg);
+    this.drawVLine(x, y + 1, height - 2, chars.v, fg);
+    this.drawVLine(x + width - 1, y + 1, height - 2, chars.v, fg);
+  }
+  toString() {
+    return this.cells.map((row) => row.map((cell) => cell.char).join("")).join(`
+`);
+  }
+  toAnsiString() {
+    const lines = [];
+    for (const row of this.cells) {
+      let line = "";
+      let currentFg = null;
+      let currentBg = null;
+      for (const cell of row) {
+        const fgChanged = !currentFg || currentFg.r !== cell.fg.r || currentFg.g !== cell.fg.g || currentFg.b !== cell.fg.b;
+        const bgChanged = cell.bg.a > 0 && (!currentBg || currentBg.r !== cell.bg.r || currentBg.g !== cell.bg.g || currentBg.b !== cell.bg.b);
+        if (fgChanged) {
+          line += `\x1B[38;2;${cell.fg.r};${cell.fg.g};${cell.fg.b}m`;
+          currentFg = cell.fg;
+        }
+        if (bgChanged) {
+          line += `\x1B[48;2;${cell.bg.r};${cell.bg.g};${cell.bg.b}m`;
+          currentBg = cell.bg;
+        }
+        if (cell.bold)
+          line += "\x1B[1m";
+        if (cell.italic)
+          line += "\x1B[3m";
+        if (cell.underline)
+          line += "\x1B[4m";
+        line += cell.char;
+        if (cell.bold || cell.italic || cell.underline) {
+          line += "\x1B[22;23;24m";
+          if (currentFg) {
+            line += `\x1B[38;2;${currentFg.r};${currentFg.g};${currentFg.b}m`;
+          }
+        }
+      }
+      line += "\x1B[0m";
+      lines.push(line);
+    }
+    return lines.join(`
+`);
+  }
+}
+function createCanvas(width, height) {
+  return new TerminalCanvas(width, height);
+}
+var DEFAULT_FG, DEFAULT_BG;
+var init_canvas = __esm(() => {
+  DEFAULT_FG = { r: 255, g: 255, b: 255, a: 1 };
+  DEFAULT_BG = { r: 0, g: 0, b: 0, a: 0 };
+});
+
+// src/pipeline/scales.ts
+var exports_scales = {};
+__export(exports_scales, {
+  niceDomain: () => niceDomain,
+  inferDiscreteDomain: () => inferDiscreteDomain,
+  inferContinuousDomain: () => inferContinuousDomain,
+  getTransformFunctions: () => getTransformFunctions,
+  expandDomain: () => expandDomain,
+  createResolvedSizeScale: () => createResolvedSizeScale,
+  createResolvedDiscreteScale: () => createResolvedDiscreteScale,
+  createResolvedDiscreteColorScale: () => createResolvedDiscreteColorScale,
+  createResolvedContinuousScale: () => createResolvedContinuousScale,
+  createResolvedContinuousColorScale: () => createResolvedContinuousColorScale,
+  buildScaleContext: () => buildScaleContext,
+  DEFAULT_POINT_COLOR: () => DEFAULT_POINT_COLOR
+});
+function inferContinuousDomain(data, field) {
+  let min = Infinity;
+  let max = -Infinity;
+  for (const row of data) {
+    const value = row[field];
+    if (typeof value === "number" && !isNaN(value)) {
+      if (value < min)
+        min = value;
+      if (value > max)
+        max = value;
+    }
+  }
+  if (min === Infinity)
+    min = 0;
+  if (max === -Infinity)
+    max = 1;
+  if (min === max) {
+    min = min - 1;
+    max = max + 1;
+  }
+  return [min, max];
+}
+function inferDiscreteDomain(data, field, options = {}) {
+  const { limits, order = "alphabetical", reverse = false, exclude, drop = true } = options;
+  const seen = new Map;
+  let index = 0;
+  for (const row of data) {
+    const value = row[field];
+    if (value !== null && value !== undefined) {
+      const key = String(value);
+      if (!seen.has(key)) {
+        seen.set(key, { firstIndex: index, count: 1 });
+      } else {
+        seen.get(key).count++;
+      }
+    }
+    index++;
+  }
+  let result;
+  if (limits) {
+    if (drop) {
+      result = limits.filter((v) => seen.has(v));
+    } else {
+      result = [...limits];
+    }
+  } else {
+    const values = Array.from(seen.keys());
+    switch (order) {
+      case "data":
+        result = values.sort((a, b) => seen.get(a).firstIndex - seen.get(b).firstIndex);
+        break;
+      case "frequency":
+        result = values.sort((a, b) => seen.get(b).count - seen.get(a).count);
+        break;
+      case "reverse":
+        result = values.sort().reverse();
+        break;
+      case "alphabetical":
+      default:
+        result = values.sort();
+        break;
+    }
+  }
+  if (exclude && exclude.length > 0) {
+    const excludeSet = new Set(exclude);
+    result = result.filter((v) => !excludeSet.has(v));
+  }
+  if (reverse) {
+    result = result.reverse();
+  }
+  return result;
+}
+function expandDomain(domain, expand = 0.05) {
+  const range = domain[1] - domain[0];
+  const padding = range * expand;
+  return [domain[0] - padding, domain[1] + padding];
+}
+function niceStep(range, targetTicks = 5) {
+  const rawStep = range / Math.max(1, targetTicks - 1);
+  const magnitude = Math.pow(10, Math.floor(Math.log10(rawStep)));
+  const normalized = rawStep / magnitude;
+  let nice;
+  if (normalized <= 1.5)
+    nice = 1;
+  else if (normalized <= 3)
+    nice = 2;
+  else if (normalized <= 7)
+    nice = 5;
+  else
+    nice = 10;
+  return nice * magnitude;
+}
+function niceDomain(domain, targetTicks = 5) {
+  const [min, max] = domain;
+  const range = max - min;
+  if (range === 0) {
+    if (min === 0)
+      return [-1, 1];
+    const magnitude = Math.pow(10, Math.floor(Math.log10(Math.abs(min))));
+    return [min - magnitude, min + magnitude];
+  }
+  const step = niceStep(range, targetTicks);
+  const niceMin = Math.floor(min / step) * step;
+  const niceMax = Math.ceil(max / step) * step;
+  return [niceMin, niceMax];
+}
+function getTransformFunctions(trans = "identity") {
+  switch (trans) {
+    case "log10":
+      return {
+        type: "log10",
+        transform: (v) => v > 0 ? Math.log10(v) : -Infinity,
+        invert: (v) => Math.pow(10, v)
+      };
+    case "sqrt":
+      return {
+        type: "sqrt",
+        transform: (v) => v >= 0 ? Math.sqrt(v) : 0,
+        invert: (v) => v * v
+      };
+    case "reverse":
+      return {
+        type: "reverse",
+        transform: (v) => -v,
+        invert: (v) => -v
+      };
+    default:
+      return {
+        type: "identity",
+        transform: (v) => v,
+        invert: (v) => v
+      };
+  }
+}
+function createResolvedContinuousScale(aesthetic, domain, range, trans = "identity") {
+  const [domainMin, domainMax] = domain;
+  const [rangeMin, rangeMax] = range;
+  const rangeSpan = rangeMax - rangeMin;
+  const { transform, invert } = getTransformFunctions(trans);
   return {
-    panel: {
-      background: "",
-      border: "single",
-      grid: { major: null, minor: null }
-    },
-    axis: {
-      text: { color: "" },
-      ticks: { char: "─", length: 1 },
-      title: { color: "", bold: true }
-    },
-    legend: {
-      position: "right",
-      title: { bold: true }
+    aesthetic,
+    type: "continuous",
+    domain,
+    range,
+    trans,
+    transform,
+    invert,
+    normalize(value) {
+      const num = Number(value);
+      if (isNaN(num))
+        return 0;
+      const transformed = transform(num);
+      const transformedMin = transform(domainMin);
+      const transformedMax = transform(domainMax);
+      if (transformedMax === transformedMin)
+        return 0.5;
+      return (transformed - transformedMin) / (transformedMax - transformedMin);
     },
-    title: {
-      align: "center",
-      bold: true
+    toCanvas(normalized) {
+      return rangeMin + normalized * rangeSpan;
     },
-    facet: {
-      strip: {
-        text: "#c8c8c8",
-        background: ""
-      }
+    map(value) {
+      return this.toCanvas(this.normalize(value));
     }
   };
 }
-function themeVoid() {
+function createResolvedDiscreteScale(aesthetic, domain, range) {
+  const [rangeMin, rangeMax] = range;
+  const rangeSpan = rangeMax - rangeMin;
   return {
-    panel: {
-      background: "",
-      border: "none",
-      grid: { major: null, minor: null }
-    },
-    axis: {
-      text: { color: "" },
-      ticks: { char: "", length: 0 },
-      title: { color: "", bold: false }
-    },
-    legend: {
-      position: "none",
-      title: { bold: false }
+    aesthetic,
+    type: "discrete",
+    domain,
+    range,
+    normalize(value) {
+      const str = String(value);
+      const index = domain.indexOf(str);
+      if (index < 0)
+        return 0;
+      return domain.length > 1 ? index / (domain.length - 1) : 0.5;
     },
-    title: {
-      align: "left",
-      bold: false
+    toCanvas(normalized) {
+      return rangeMin + normalized * rangeSpan;
     },
-    facet: {
-      strip: {
-        text: "#888888",
-        background: ""
-      }
+    map(value) {
+      return this.toCanvas(this.normalize(value));
     }
   };
 }
-
-// src/coords/cartesian.ts
-function coordCartesian(options = {}) {
+function interpolateColor(color1, color2, t) {
   return {
-    type: "cartesian",
-    xlim: options.xlim,
-    ylim: options.ylim,
-    clip: options.clip ?? true,
-    transform(x, y) {
-      return { x, y };
-    }
+    r: Math.round(color1.r + (color2.r - color1.r) * t),
+    g: Math.round(color1.g + (color2.g - color1.g) * t),
+    b: Math.round(color1.b + (color2.b - color1.b) * t),
+    a: color1.a + (color2.a - color1.a) * t
   };
 }
-function coordFlip() {
+function createResolvedDiscreteColorScale(domain, palette = CATEGORY_COLORS) {
   return {
-    type: "flip",
-    transform(x, y) {
-      return { x: y, y: x };
+    aesthetic: "color",
+    type: "discrete",
+    domain,
+    map(value) {
+      const str = String(value);
+      const index = domain.indexOf(str);
+      if (index < 0)
+        return palette[0];
+      return palette[index % palette.length];
     }
   };
 }
-function coordPolar(options = {}) {
-  const theta = options.theta ?? "x";
+function createResolvedContinuousColorScale(domain, lowColor = { r: 68, g: 1, b: 84, a: 1 }, highColor = { r: 253, g: 231, b: 37, a: 1 }) {
+  const [min, max] = domain;
+  const span = max - min;
   return {
-    type: "polar",
-    transform(x, y) {
-      const angle = theta === "x" ? x : y;
-      const radius = theta === "x" ? y : x;
-      return {
-        x: radius * Math.cos(angle),
-        y: radius * Math.sin(angle)
-      };
+    aesthetic: "color",
+    type: "continuous",
+    domain,
+    map(value) {
+      const num = Number(value);
+      if (isNaN(num))
+        return lowColor;
+      const t = Math.max(0, Math.min(1, (num - min) / span));
+      return interpolateColor(lowColor, highColor, t);
     }
   };
 }
-function coordFixed(options = {}) {
-  const ratio = options.ratio ?? 1;
-  return {
-    type: "fixed",
-    xlim: options.xlim,
-    ylim: options.ylim,
-    clip: options.clip ?? true,
-    ratio,
-    transform(x, y) {
-      return { x, y };
+function isCategoricalField(data, field) {
+  for (const row of data) {
+    const value = row[field];
+    if (value !== null && value !== undefined) {
+      if (typeof value === "string") {
+        return true;
+      }
     }
-  };
-}
-function coordEqual(options = {}) {
-  return coordFixed({ ...options, ratio: 1 });
-}
-function getTransform(type) {
-  switch (type) {
-    case "log10":
-      return (v) => v > 0 ? Math.log10(v) : -Infinity;
-    case "sqrt":
-      return (v) => v >= 0 ? Math.sqrt(v) : 0;
-    case "reverse":
-      return (v) => -v;
-    default:
-      return (v) => v;
   }
+  return false;
 }
-function coordTrans(options = {}) {
-  const xTrans = getTransform(options.x ?? "identity");
-  const yTrans = getTransform(options.y ?? "identity");
-  return {
-    type: "trans",
-    xlim: options.xlim,
-    ylim: options.ylim,
-    clip: options.clip ?? true,
-    xTransType: options.x ?? "identity",
-    yTransType: options.y ?? "identity",
-    transform(x, y) {
-      return {
-        x: xTrans(x),
-        y: yTrans(y)
-      };
-    }
-  };
-}
-function coordFlipWithLimits(options = {}) {
-  return {
-    type: "flip",
-    xlim: options.xlim,
-    ylim: options.ylim,
-    clip: options.clip ?? true,
-    transform(x, y) {
-      return { x: y, y: x };
-    }
-  };
-}
-
-// src/canvas/canvas.ts
-var DEFAULT_FG = { r: 255, g: 255, b: 255, a: 1 };
-var DEFAULT_BG = { r: 0, g: 0, b: 0, a: 0 };
-function createEmptyCell() {
+function createResolvedSizeScale(domain) {
+  const [min, max] = domain;
+  const span = max - min;
   return {
-    char: " ",
-    fg: { ...DEFAULT_FG },
-    bg: { ...DEFAULT_BG }
+    aesthetic: "size",
+    type: "continuous",
+    domain,
+    map(value) {
+      const num = Number(value);
+      if (isNaN(num))
+        return 1;
+      const t = Math.max(0, Math.min(1, (num - min) / span));
+      return Math.floor(t * 3.99);
+    }
   };
 }
-
-class TerminalCanvas {
-  width;
-  height;
-  cells;
-  constructor(width, height) {
-    this.width = width;
-    this.height = height;
-    this.cells = [];
-    this.clear();
+function computeDomain(data, field, trans = "identity") {
+  const rawDomain = inferContinuousDomain(data, field);
+  if (trans === "log10") {
+    const [min, max] = rawDomain;
+    const safeMin = min > 0 ? min : 0.001;
+    const safeMax = max > 0 ? max : 1;
+    const minPow = Math.floor(Math.log10(safeMin));
+    const maxPow = Math.ceil(Math.log10(safeMax));
+    return [Math.pow(10, minPow), Math.pow(10, maxPow)];
   }
-  setCell(x, y, cell) {
-    if (x < 0 || x >= this.width || y < 0 || y >= this.height) {
-      return;
+  return niceDomain(rawDomain);
+}
+function buildScaleContext(data, aes, plotArea, userScales = [], coordLimits) {
+  const userXScale = userScales.find((s) => s.aesthetic === "x");
+  const userYScale = userScales.find((s) => s.aesthetic === "y");
+  const userColorScale = userScales.find((s) => s.aesthetic === "color" || s.aesthetic === "fill");
+  const xIsCategorical = isCategoricalField(data, aes.x);
+  let x;
+  if (xIsCategorical) {
+    const xOrderOptions = {};
+    if (userXScale) {
+      if (userXScale.domain && Array.isArray(userXScale.domain)) {
+        xOrderOptions.limits = userXScale.domain;
+      }
+      const orderOpts = userXScale.orderOptions;
+      if (orderOpts) {
+        if (orderOpts.order)
+          xOrderOptions.order = orderOpts.order;
+        if (orderOpts.reverse)
+          xOrderOptions.reverse = orderOpts.reverse;
+        if (orderOpts.exclude)
+          xOrderOptions.exclude = orderOpts.exclude;
+        if (orderOpts.drop !== undefined)
+          xOrderOptions.drop = orderOpts.drop;
+      }
     }
-    const ix = Math.floor(x);
-    const iy = Math.floor(y);
-    const existing = this.cells[iy][ix];
-    this.cells[iy][ix] = {
-      char: cell.char ?? existing.char,
-      fg: cell.fg ?? existing.fg,
-      bg: cell.bg ?? existing.bg,
-      bold: cell.bold ?? existing.bold,
-      italic: cell.italic ?? existing.italic,
-      underline: cell.underline ?? existing.underline
-    };
-  }
-  getCell(x, y) {
-    if (x < 0 || x >= this.width || y < 0 || y >= this.height) {
-      return createEmptyCell();
+    const xDomain = inferDiscreteDomain(data, aes.x, xOrderOptions);
+    x = createResolvedDiscreteScale("x", xDomain, [plotArea.x, plotArea.x + plotArea.width - 1]);
+    if (userXScale?.labels) {
+      x.labels = userXScale.labels;
+    }
+  } else {
+    const xTrans = userXScale?.trans ?? "identity";
+    const xDomain = coordLimits?.xlim ?? userXScale?.domain ?? computeDomain(data, aes.x, xTrans);
+    x = createResolvedContinuousScale("x", xDomain, [plotArea.x, plotArea.x + plotArea.width - 1], xTrans);
+    if (userXScale?.breaks) {
+      x.breaks = userXScale.breaks;
+    }
+    if (userXScale?.labels) {
+      x.labels = userXScale.labels;
     }
-    return this.cells[Math.floor(y)][Math.floor(x)];
   }
-  clear() {
-    this.cells = [];
-    for (let y = 0;y < this.height; y++) {
-      const row = [];
-      for (let x = 0;x < this.width; x++) {
-        row.push(createEmptyCell());
+  const yIsCategorical = isCategoricalField(data, aes.y);
+  let y;
+  if (yIsCategorical) {
+    const yOrderOptions = {};
+    if (userYScale) {
+      if (userYScale.domain && Array.isArray(userYScale.domain)) {
+        yOrderOptions.limits = userYScale.domain;
+      }
+      const orderOpts = userYScale.orderOptions;
+      if (orderOpts) {
+        if (orderOpts.order)
+          yOrderOptions.order = orderOpts.order;
+        if (orderOpts.reverse)
+          yOrderOptions.reverse = orderOpts.reverse;
+        if (orderOpts.exclude)
+          yOrderOptions.exclude = orderOpts.exclude;
+        if (orderOpts.drop !== undefined)
+          yOrderOptions.drop = orderOpts.drop;
       }
-      this.cells.push(row);
     }
-  }
-  drawChar(x, y, char, fg) {
-    this.setCell(x, y, { char, fg });
-  }
-  drawString(x, y, str, fg) {
-    for (let i = 0;i < str.length; i++) {
-      this.drawChar(x + i, y, str[i], fg);
+    const yDomain = inferDiscreteDomain(data, aes.y, yOrderOptions);
+    y = createResolvedDiscreteScale("y", yDomain, [plotArea.y + plotArea.height - 1, plotArea.y]);
+    if (userYScale?.labels) {
+      y.labels = userYScale.labels;
     }
-  }
-  drawHLine(x, y, length, char = "─", fg) {
-    for (let i = 0;i < length; i++) {
-      this.drawChar(x + i, y, char, fg);
+  } else {
+    const yTrans = userYScale?.trans ?? "identity";
+    const yDomain = coordLimits?.ylim ?? userYScale?.domain ?? computeDomain(data, aes.y, yTrans);
+    y = createResolvedContinuousScale("y", yDomain, [plotArea.y + plotArea.height - 1, plotArea.y], yTrans);
+    if (userYScale?.breaks) {
+      y.breaks = userYScale.breaks;
     }
-  }
-  drawVLine(x, y, length, char = "│", fg) {
-    for (let i = 0;i < length; i++) {
-      this.drawChar(x, y + i, char, fg);
+    if (userYScale?.labels) {
+      y.labels = userYScale.labels;
     }
   }
-  drawPoint(x, y, fg, shape = "●") {
-    this.drawChar(x, y, shape, fg);
+  const context = { x, y };
+  if (aes.y2) {
+    const userY2Scale = userScales.find((s) => s.aesthetic === "y2");
+    const y2Trans = userY2Scale?.trans ?? "identity";
+    const y2Domain = userY2Scale?.domain ?? computeDomain(data, aes.y2, y2Trans);
+    const y2 = createResolvedContinuousScale("y2", y2Domain, [plotArea.y + plotArea.height - 1, plotArea.y], y2Trans);
+    if (userY2Scale?.breaks) {
+      y2.breaks = userY2Scale.breaks;
+    }
+    if (userY2Scale?.labels) {
+      y2.labels = userY2Scale.labels;
+    }
+    context.y2 = y2;
   }
-  fillRect(x, y, width, height, char = " ", fg, bg) {
-    for (let dy = 0;dy < height; dy++) {
-      for (let dx = 0;dx < width; dx++) {
-        this.setCell(x + dx, y + dy, { char, fg, bg });
+  const colorAesField = aes.color || aes.fill;
+  if (colorAesField) {
+    const colorOrderOptions = {};
+    if (userColorScale) {
+      if (userColorScale.domain && Array.isArray(userColorScale.domain)) {
+        colorOrderOptions.limits = userColorScale.domain;
+      }
+      const orderOpts = userColorScale.orderOptions;
+      if (orderOpts) {
+        if (orderOpts.order)
+          colorOrderOptions.order = orderOpts.order;
+        if (orderOpts.reverse)
+          colorOrderOptions.reverse = orderOpts.reverse;
+        if (orderOpts.exclude)
+          colorOrderOptions.exclude = orderOpts.exclude;
+        if (orderOpts.drop !== undefined)
+          colorOrderOptions.drop = orderOpts.drop;
       }
     }
-  }
-  drawBox(x, y, width, height, style = "single", fg) {
-    const chars = style === "double" ? { tl: "╔", tr: "╗", bl: "╚", br: "╝", h: "═", v: "║" } : style === "rounded" ? { tl: "╭", tr: "╮", bl: "╰", br: "╯", h: "─", v: "│" } : { tl: "┌", tr: "┐", bl: "└", br: "┘", h: "─", v: "│" };
-    this.drawChar(x, y, chars.tl, fg);
-    this.drawChar(x + width - 1, y, chars.tr, fg);
-    this.drawChar(x, y + height - 1, chars.bl, fg);
-    this.drawChar(x + width - 1, y + height - 1, chars.br, fg);
-    this.drawHLine(x + 1, y, width - 2, chars.h, fg);
-    this.drawHLine(x + 1, y + height - 1, width - 2, chars.h, fg);
-    this.drawVLine(x, y + 1, height - 2, chars.v, fg);
-    this.drawVLine(x + width - 1, y + 1, height - 2, chars.v, fg);
-  }
-  toString() {
-    return this.cells.map((row) => row.map((cell) => cell.char).join("")).join(`
-`);
-  }
-  toAnsiString() {
-    const lines = [];
-    for (const row of this.cells) {
-      let line = "";
-      let currentFg = null;
-      let currentBg = null;
-      for (const cell of row) {
-        const fgChanged = !currentFg || currentFg.r !== cell.fg.r || currentFg.g !== cell.fg.g || currentFg.b !== cell.fg.b;
-        const bgChanged = cell.bg.a > 0 && (!currentBg || currentBg.r !== cell.bg.r || currentBg.g !== cell.bg.g || currentBg.b !== cell.bg.b);
-        if (fgChanged) {
-          line += `\x1B[38;2;${cell.fg.r};${cell.fg.g};${cell.fg.b}m`;
-          currentFg = cell.fg;
-        }
-        if (bgChanged) {
-          line += `\x1B[48;2;${cell.bg.r};${cell.bg.g};${cell.bg.b}m`;
-          currentBg = cell.bg;
-        }
-        if (cell.bold)
-          line += "\x1B[1m";
-        if (cell.italic)
-          line += "\x1B[3m";
-        if (cell.underline)
-          line += "\x1B[4m";
-        line += cell.char;
-        if (cell.bold || cell.italic || cell.underline) {
-          line += "\x1B[22;23;24m";
-          if (currentFg) {
-            line += `\x1B[38;2;${currentFg.r};${currentFg.g};${currentFg.b}m`;
+    const colorDomain = inferDiscreteDomain(data, colorAesField, colorOrderOptions);
+    if (userColorScale && userColorScale.map) {
+      context.color = {
+        aesthetic: userColorScale.aesthetic || "color",
+        type: userColorScale.type === "continuous" ? "continuous" : "discrete",
+        domain: userColorScale.type === "continuous" ? userColorScale.domain ?? inferContinuousDomain(data, colorAesField) : colorDomain,
+        map: (value) => {
+          const result = userColorScale.map(value);
+          if (typeof result === "object" && "r" in result) {
+            return result;
           }
+          return { r: 128, g: 128, b: 128, a: 1 };
         }
-      }
-      line += "\x1B[0m";
-      lines.push(line);
+      };
+    } else {
+      context.color = createResolvedDiscreteColorScale(colorDomain);
     }
-    return lines.join(`
-`);
   }
+  if (aes.size) {
+    const sizeDomain = inferContinuousDomain(data, aes.size);
+    context.size = createResolvedSizeScale(sizeDomain);
+  }
+  return context;
 }
-function createCanvas(width, height) {
-  return new TerminalCanvas(width, height);
-}
-
-// src/pipeline/pipeline.ts
-init_scales();
-
-// src/pipeline/render-geoms.ts
-init_scales();
+var CATEGORY_COLORS, DEFAULT_POINT_COLOR;
+var init_scales = __esm(() => {
+  CATEGORY_COLORS = [
+    { r: 31, g: 119, b: 180, a: 1 },
+    { r: 255, g: 127, b: 14, a: 1 },
+    { r: 44, g: 160, b: 44, a: 1 },
+    { r: 214, g: 39, b: 40, a: 1 },
+    { r: 148, g: 103, b: 189, a: 1 },
+    { r: 140, g: 86, b: 75, a: 1 },
+    { r: 227, g: 119, b: 194, a: 1 },
+    { r: 127, g: 127, b: 127, a: 1 },
+    { r: 188, g: 189, b: 34, a: 1 },
+    { r: 23, g: 190, b: 207, a: 1 }
+  ];
+  DEFAULT_POINT_COLOR = { r: 79, g: 169, b: 238, a: 1 };
+});
 
 // src/positions/index.ts
 function position_identity() {
@@ -1012,22 +1036,6 @@ function getPositionType(position) {
 }
 
 // src/pipeline/render-geoms.ts
-var POINT_SHAPES = {
-  circle: "●",
-  filled_circle: "●",
-  open_circle: "○",
-  square: "■",
-  open_square: "□",
-  diamond: "◆",
-  open_diamond: "◇",
-  triangle: "▲",
-  open_triangle: "△",
-  cross: "✕",
-  plus: "+",
-  star: "★",
-  dot: "•"
-};
-var SIZE_CHARS = ["·", "•", "●", "⬤"];
 function getPointShape(shape) {
   if (!shape)
     return POINT_SHAPES.circle;
@@ -1038,7 +1046,45 @@ function getPointColor(row, aes, colorScale) {
     const value = row[aes.color];
     return colorScale.map(value);
   }
-  return DEFAULT_POINT_COLOR;
+  return DEFAULT_POINT_COLOR;
+}
+function parseColorToRgba(color, fallback = { r: 128, g: 128, b: 128, a: 1 }) {
+  if (!color)
+    return fallback;
+  if (typeof color === "object" && color !== null && "r" in color) {
+    return color;
+  }
+  if (typeof color === "string") {
+    if (color.startsWith("#")) {
+      const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(color);
+      if (result) {
+        return {
+          r: parseInt(result[1], 16),
+          g: parseInt(result[2], 16),
+          b: parseInt(result[3], 16),
+          a: 1
+        };
+      }
+    }
+    const namedColors = {
+      red: { r: 255, g: 0, b: 0, a: 1 },
+      blue: { r: 0, g: 0, b: 255, a: 1 },
+      green: { r: 0, g: 128, b: 0, a: 1 },
+      black: { r: 0, g: 0, b: 0, a: 1 },
+      white: { r: 255, g: 255, b: 255, a: 1 },
+      gray: { r: 128, g: 128, b: 128, a: 1 },
+      grey: { r: 128, g: 128, b: 128, a: 1 },
+      yellow: { r: 255, g: 255, b: 0, a: 1 },
+      orange: { r: 255, g: 165, b: 0, a: 1 },
+      purple: { r: 128, g: 0, b: 128, a: 1 },
+      cyan: { r: 0, g: 255, b: 255, a: 1 },
+      magenta: { r: 255, g: 0, b: 255, a: 1 }
+    };
+    const named = namedColors[color.toLowerCase()];
+    if (named)
+      return named;
+  }
+  return fallback;
 }
 function renderGeomPoint(data, geom, aes, scales, canvas) {
   const defaultShape = getPointShape(geom.params.shape);
@@ -1438,7 +1484,7 @@ function renderGeomHLine(_data, geom, _aes, scales, canvas) {
   if (yintercept === undefined)
     return;
   const cy = Math.round(scales.y.map(yintercept));
-  const color = geom.params.color ?? { r: 128, g: 128, b: 128, a: 1 };
+  const color = parseColorToRgba(geom.params.color);
   const startX = Math.round(scales.x.range[0]);
   const endX = Math.round(scales.x.range[1]);
   canvas.drawHLine(startX, cy, endX - startX + 1, "─", color);
@@ -1448,7 +1494,7 @@ function renderGeomVLine(_data, geom, _aes, scales, canvas) {
   if (xintercept === undefined)
     return;
   const cx = Math.round(scales.x.map(xintercept));
-  const color = geom.params.color ?? { r: 128, g: 128, b: 128, a: 1 };
+  const color = parseColorToRgba(geom.params.color);
   const startY = Math.round(Math.min(scales.y.range[0], scales.y.range[1]));
   const endY = Math.round(Math.max(scales.y.range[0], scales.y.range[1]));
   canvas.drawVLine(cx, startY, endY - startY + 1, "│", color);
@@ -1765,20 +1811,52 @@ function renderGeomTile(data, geom, aes, scales, canvas) {
   const plotRight = Math.round(scales.x.range[1]);
   const plotTop = Math.round(Math.min(scales.y.range[0], scales.y.range[1]));
   const plotBottom = Math.round(Math.max(scales.y.range[0], scales.y.range[1]));
-  let tileWidth = geom.params.width;
-  let tileHeight = geom.params.height;
-  if (!tileWidth || !tileHeight) {
-    const xVals = [...new Set(data.map((r) => Number(r[aes.x]) || 0))].sort((a, b) => a - b);
-    const yVals = [...new Set(data.map((r) => Number(r[aes.y]) || 0))].sort((a, b) => a - b);
-    if (xVals.length > 1) {
-      tileWidth = tileWidth ?? xVals[1] - xVals[0];
+  let halfW;
+  let halfH;
+  const xIsDiscrete = scales.x.type === "discrete";
+  const yIsDiscrete = scales.y.type === "discrete";
+  if (xIsDiscrete) {
+    const xDomain = scales.x.domain;
+    const canvasWidth = Math.abs(scales.x.range[1] - scales.x.range[0]);
+    halfW = Math.max(1, Math.floor(canvasWidth / (xDomain.length * 2)));
+  } else {
+    let tileWidth = data[0]?.width ?? geom.params.width;
+    if (!tileWidth) {
+      const xVals = [...new Set(data.map((r) => Number(r[aes.x])).filter((v) => !isNaN(v)))].sort((a, b) => a - b);
+      if (xVals.length > 1) {
+        tileWidth = xVals[1] - xVals[0];
+      }
+    }
+    tileWidth = tileWidth ?? 1;
+    const sampleX = data.find((r) => r[aes.x] !== null && r[aes.x] !== undefined)?.[aes.x];
+    if (sampleX !== undefined) {
+      const cx = scales.x.map(sampleX);
+      halfW = Math.max(1, Math.floor(Math.abs(scales.x.map(Number(sampleX) + tileWidth / 2) - cx)));
+    } else {
+      halfW = 1;
     }
-    if (yVals.length > 1) {
-      tileHeight = tileHeight ?? yVals[1] - yVals[0];
+  }
+  if (yIsDiscrete) {
+    const yDomain = scales.y.domain;
+    const canvasHeight = Math.abs(scales.y.range[1] - scales.y.range[0]);
+    halfH = Math.max(1, Math.floor(canvasHeight / (yDomain.length * 2)));
+  } else {
+    let tileHeight = data[0]?.height ?? geom.params.height;
+    if (!tileHeight) {
+      const yVals = [...new Set(data.map((r) => Number(r[aes.y])).filter((v) => !isNaN(v)))].sort((a, b) => a - b);
+      if (yVals.length > 1) {
+        tileHeight = yVals[1] - yVals[0];
+      }
+    }
+    tileHeight = tileHeight ?? 1;
+    const sampleY = data.find((r) => r[aes.y] !== null && r[aes.y] !== undefined)?.[aes.y];
+    if (sampleY !== undefined) {
+      const cy = scales.y.map(sampleY);
+      halfH = Math.max(1, Math.floor(Math.abs(scales.y.map(Number(sampleY) + tileHeight / 2) - cy)));
+    } else {
+      halfH = 1;
     }
   }
-  tileWidth = tileWidth ?? 1;
-  tileHeight = tileHeight ?? 1;
   for (const row of data) {
     const xVal = row[aes.x];
     const yVal = row[aes.y];
@@ -1788,8 +1866,6 @@ function renderGeomTile(data, geom, aes, scales, canvas) {
     }
     const cx = Math.round(scales.x.map(xVal));
     const cy = Math.round(scales.y.map(yVal));
-    const halfW = Math.max(1, Math.floor(Math.abs(scales.x.map(Number(xVal) + tileWidth / 2) - cx)));
-    const halfH = Math.max(1, Math.floor(Math.abs(scales.y.map(Number(yVal) + tileHeight / 2) - cy)));
     let color;
     if (scales.color && typeof fillVal === "number") {
       color = scales.color.map(fillVal);
@@ -1977,7 +2053,7 @@ function renderGeomAbline(_data, geom, _aes, scales, canvas) {
   const intercept = geom.params.intercept ?? 0;
   const linetype = geom.params.linetype ?? "solid";
   const lineChar = linetype === "dotted" ? "·" : linetype === "dashed" ? "╌" : "─";
-  const color = geom.params.color ?? { r: 128, g: 128, b: 128, a: 1 };
+  const color = parseColorToRgba(geom.params.color);
   const plotLeft = Math.round(scales.x.range[0]);
   const plotRight = Math.round(scales.x.range[1]);
   const plotTop = Math.round(Math.min(scales.y.range[0], scales.y.range[1]));
@@ -2169,6 +2245,7 @@ function renderGeom(data, geom, aes, scales, canvas, coordType) {
       break;
     case "tile":
     case "raster":
+    case "bin2d":
       renderGeomTile(data, geom, aes, scales, canvas);
       break;
     case "contour":
@@ -2198,6 +2275,26 @@ function renderGeom(data, geom, aes, scales, canvas, coordType) {
       break;
   }
 }
+var POINT_SHAPES, SIZE_CHARS;
+var init_render_geoms = __esm(() => {
+  init_scales();
+  POINT_SHAPES = {
+    circle: "●",
+    filled_circle: "●",
+    open_circle: "○",
+    square: "■",
+    open_square: "□",
+    diamond: "◆",
+    open_diamond: "◇",
+    triangle: "▲",
+    open_triangle: "△",
+    cross: "✕",
+    plus: "+",
+    star: "★",
+    dot: "•"
+  };
+  SIZE_CHARS = ["·", "•", "●", "⬤"];
+});
 
 // src/pipeline/render-axes.ts
 function calculateTicks(domain, targetTicks = 5, transform, invert) {
@@ -2505,7 +2602,6 @@ function renderTitle(canvas, title, width, theme) {
   }
   canvas.drawString(x, 0, title, titleColor);
 }
-var SIZE_SYMBOLS = ["·", "•", "●", "⬤"];
 function renderMultiLegend(canvas, entries, x, y, theme, width) {
   if (theme.legend.position === "none" || entries.length === 0)
     return;
@@ -2633,6 +2729,10 @@ function formatContinuousLegendValue(value) {
   }
   return value.toFixed(1);
 }
+var SIZE_SYMBOLS;
+var init_render_axes = __esm(() => {
+  SIZE_SYMBOLS = ["·", "•", "●", "⬤"];
+});
 
 // src/stats/bin.ts
 function computeBins(data, field, params = {}) {
@@ -2678,71 +2778,313 @@ function computeBins(data, field, params = {}) {
   } else {
     binStart = min;
   }
-  const binCounts = new Map;
-  for (const val of values) {
-    const binIndex = Math.floor((val - binStart) / binWidth);
-    binCounts.set(binIndex, (binCounts.get(binIndex) ?? 0) + 1);
+  const binCounts = new Map;
+  for (const val of values) {
+    const binIndex = Math.floor((val - binStart) / binWidth);
+    binCounts.set(binIndex, (binCounts.get(binIndex) ?? 0) + 1);
+  }
+  const bins = [];
+  const maxBinIndex = Math.ceil((max - binStart) / binWidth);
+  for (let i = 0;i <= maxBinIndex; i++) {
+    const count = binCounts.get(i) ?? 0;
+    const xmin = binStart + i * binWidth;
+    const xmax = xmin + binWidth;
+    const x = (xmin + xmax) / 2;
+    bins.push({
+      x,
+      xmin,
+      xmax,
+      count,
+      density: count / (values.length * binWidth)
+    });
+  }
+  return { bins, binWidth };
+}
+function stat_bin(params = {}) {
+  return {
+    type: "bin",
+    compute(data, aes) {
+      const groupField = aes.color || aes.fill || aes.group;
+      if (groupField) {
+        const groups = new Map;
+        for (const row of data) {
+          const groupVal = String(row[groupField] ?? "default");
+          if (!groups.has(groupVal)) {
+            groups.set(groupVal, []);
+          }
+          groups.get(groupVal).push(row);
+        }
+        const results = [];
+        for (const [groupVal, groupData] of groups) {
+          const { bins: bins2 } = computeBins(groupData, aes.x, params);
+          for (const bin of bins2) {
+            results.push({
+              x: bin.x,
+              xmin: bin.xmin,
+              xmax: bin.xmax,
+              y: bin.count,
+              count: bin.count,
+              density: bin.density,
+              [groupField]: groupVal
+            });
+          }
+        }
+        return results;
+      }
+      const { bins } = computeBins(data, aes.x, params);
+      return bins.map((bin) => ({
+        x: bin.x,
+        xmin: bin.xmin,
+        xmax: bin.xmax,
+        y: bin.count,
+        count: bin.count,
+        density: bin.density
+      }));
+    }
+  };
+}
+
+// src/performance/binning.ts
+function computeDomain2(data, field) {
+  let min = Infinity;
+  let max = -Infinity;
+  for (const d of data) {
+    const v = d[field];
+    if (typeof v === "number" && !isNaN(v)) {
+      if (v < min)
+        min = v;
+      if (v > max)
+        max = v;
+    }
+  }
+  if (min === Infinity)
+    return [0, 1];
+  if (min === max)
+    return [min - 0.5, max + 0.5];
+  return [min, max];
+}
+function aggregateValues(values, method) {
+  if (values.length === 0)
+    return 0;
+  switch (method) {
+    case "count":
+      return values.length;
+    case "sum":
+      return values.reduce((a, b) => a + b, 0);
+    case "mean":
+      return values.reduce((a, b) => a + b, 0) / values.length;
+    case "median":
+      const sorted = [...values].sort((a, b) => a - b);
+      const mid = Math.floor(sorted.length / 2);
+      return sorted.length % 2 === 0 ? (sorted[mid - 1] + sorted[mid]) / 2 : sorted[mid];
+    case "min":
+      return Math.min(...values);
+    case "max":
+      return Math.max(...values);
+    default:
+      return values.length;
+  }
+}
+function rectbin(data, options) {
+  const {
+    xField,
+    yField,
+    xBins = 20,
+    yBins = 20,
+    aggregate = "count",
+    valueField
+  } = options;
+  if (data.length === 0)
+    return [];
+  const xDomain = options.xDomain ?? computeDomain2(data, xField);
+  const yDomain = options.yDomain ?? computeDomain2(data, yField);
+  const xRange = xDomain[1] - xDomain[0];
+  const yRange = yDomain[1] - yDomain[0];
+  const binWidth = xRange / xBins;
+  const binHeight = yRange / yBins;
+  const bins = new Map;
+  for (const point of data) {
+    const x = point[xField];
+    const y = point[yField];
+    if (typeof x !== "number" || typeof y !== "number")
+      continue;
+    const bx = Math.min(xBins - 1, Math.max(0, Math.floor((x - xDomain[0]) / binWidth)));
+    const by = Math.min(yBins - 1, Math.max(0, Math.floor((y - yDomain[0]) / binHeight)));
+    const key = `${bx},${by}`;
+    if (!bins.has(key)) {
+      bins.set(key, { points: [], values: [] });
+    }
+    const bin = bins.get(key);
+    bin.points.push(point);
+    if (valueField && typeof point[valueField] === "number") {
+      bin.values.push(point[valueField]);
+    }
+  }
+  const result = [];
+  for (const [key, bin] of bins) {
+    const [bx, by] = key.split(",").map(Number);
+    const centerX = xDomain[0] + (bx + 0.5) * binWidth;
+    const centerY = yDomain[0] + (by + 0.5) * binHeight;
+    result.push({
+      x: centerX,
+      y: centerY,
+      count: bin.points.length,
+      value: aggregateValues(bin.values.length > 0 ? bin.values : [bin.points.length], aggregate),
+      width: binWidth,
+      height: binHeight,
+      points: bin.points
+    });
+  }
+  return result;
+}
+function hexbin(data, options) {
+  const { xField, yField, aggregate = "count", valueField, radius = 10 } = options;
+  if (data.length === 0)
+    return [];
+  const xDomain = options.xDomain ?? computeDomain2(data, xField);
+  const yDomain = options.yDomain ?? computeDomain2(data, yField);
+  const hexWidth = radius * 2;
+  const hexHeight = radius * Math.sqrt(3);
+  const bins = new Map;
+  for (const point of data) {
+    const x = point[xField];
+    const y = point[yField];
+    if (typeof x !== "number" || typeof y !== "number")
+      continue;
+    const col = Math.round((x - xDomain[0]) / (hexWidth * 0.75));
+    const row = Math.round((y - yDomain[0]) / hexHeight - col % 2 * 0.5);
+    const key = `${col},${row}`;
+    if (!bins.has(key)) {
+      bins.set(key, { points: [], values: [], col, row });
+    }
+    const bin = bins.get(key);
+    bin.points.push(point);
+    if (valueField && typeof point[valueField] === "number") {
+      bin.values.push(point[valueField]);
+    }
+  }
+  function hexVertices(cx, cy, r) {
+    const vertices = [];
+    for (let i = 0;i < 6; i++) {
+      const angle = Math.PI / 3 * i + Math.PI / 6;
+      vertices.push({
+        x: cx + r * Math.cos(angle),
+        y: cy + r * Math.sin(angle)
+      });
+    }
+    return vertices;
+  }
+  const result = [];
+  for (const [, bin] of bins) {
+    const centerX = xDomain[0] + bin.col * hexWidth * 0.75;
+    const centerY = yDomain[0] + (bin.row + bin.col % 2 * 0.5) * hexHeight;
+    result.push({
+      x: centerX,
+      y: centerY,
+      count: bin.points.length,
+      value: aggregateValues(bin.values.length > 0 ? bin.values : [bin.points.length], aggregate),
+      width: hexWidth,
+      height: hexHeight,
+      points: bin.points,
+      vertices: hexVertices(centerX, centerY, radius),
+      col: bin.col,
+      row: bin.row
+    });
+  }
+  return result;
+}
+
+class Binner {
+  options;
+  type;
+  hexRadius;
+  constructor(options) {
+    this.options = options;
+    this.type = options.type ?? "rect";
+    this.hexRadius = options.hexRadius ?? 10;
+  }
+  bin(data) {
+    if (this.type === "hex") {
+      return hexbin(data, { ...this.options, radius: this.hexRadius });
+    }
+    return rectbin(data, this.options);
+  }
+  toPlotData(data) {
+    const bins = this.bin(data);
+    const maxCount = Math.max(...bins.map((b) => b.count));
+    const minSize = 1;
+    const maxSize = 5;
+    return bins.map((bin) => ({
+      x: bin.x,
+      y: bin.y,
+      count: bin.count,
+      value: bin.value,
+      size: minSize + bin.count / maxCount * (maxSize - minSize)
+    }));
+  }
+  getDensityColors(bins, colorScale) {
+    const maxCount = Math.max(...bins.map((b) => b.count));
+    const colors = new Map;
+    for (const bin of bins) {
+      const t = bin.count / maxCount;
+      colors.set(bin, colorScale(t));
+    }
+    return colors;
   }
-  const bins = [];
-  const maxBinIndex = Math.ceil((max - binStart) / binWidth);
-  for (let i = 0;i <= maxBinIndex; i++) {
-    const count = binCounts.get(i) ?? 0;
-    const xmin = binStart + i * binWidth;
-    const xmax = xmin + binWidth;
-    const x = (xmin + xmax) / 2;
-    bins.push({
-      x,
-      xmin,
-      xmax,
-      count,
-      density: count / (values.length * binWidth)
-    });
+}
+function createBinner(options) {
+  return new Binner(options);
+}
+
+// src/stats/bin2d.ts
+function computeBins2d(data, xField, yField, params = {}) {
+  const {
+    bins = 30,
+    binsx,
+    binsy,
+    drop = true
+  } = params;
+  const xBins = binsx ?? bins;
+  const yBins = binsy ?? bins;
+  const binned = rectbin(data, {
+    xField,
+    yField,
+    xBins,
+    yBins,
+    aggregate: "count"
+  });
+  const total = data.length;
+  const results = binned.map((bin) => ({
+    x: bin.x,
+    y: bin.y,
+    count: bin.count,
+    density: total > 0 ? bin.count / total : 0,
+    width: bin.width,
+    height: bin.height
+  }));
+  if (drop) {
+    return results.filter((r) => r.count > 0);
   }
-  return { bins, binWidth };
+  return results;
 }
-function stat_bin(params = {}) {
+function stat_bin2d(params = {}) {
   return {
-    type: "bin",
+    type: "bin2d",
     compute(data, aes) {
-      const groupField = aes.color || aes.fill || aes.group;
-      if (groupField) {
-        const groups = new Map;
-        for (const row of data) {
-          const groupVal = String(row[groupField] ?? "default");
-          if (!groups.has(groupVal)) {
-            groups.set(groupVal, []);
-          }
-          groups.get(groupVal).push(row);
-        }
-        const results = [];
-        for (const [groupVal, groupData] of groups) {
-          const { bins: bins2 } = computeBins(groupData, aes.x, params);
-          for (const bin of bins2) {
-            results.push({
-              x: bin.x,
-              xmin: bin.xmin,
-              xmax: bin.xmax,
-              y: bin.count,
-              count: bin.count,
-              density: bin.density,
-              [groupField]: groupVal
-            });
-          }
-        }
-        return results;
-      }
-      const { bins } = computeBins(data, aes.x, params);
+      const bins = computeBins2d(data, aes.x, aes.y, params);
       return bins.map((bin) => ({
         x: bin.x,
-        xmin: bin.xmin,
-        xmax: bin.xmax,
-        y: bin.count,
+        y: bin.y,
         count: bin.count,
-        density: bin.density
+        density: bin.density,
+        fill: bin.count,
+        width: bin.width,
+        height: bin.height
       }));
     }
   };
 }
+var init_bin2d = () => {};
 
 // src/stats/boxplot.ts
 function quantile(sorted, p) {
@@ -3159,17 +3501,6 @@ function stat_smooth(params = {}) {
 }
 
 // src/stats/summary.ts
-var summaryFunctions = {
-  mean: (values) => values.reduce((a, b) => a + b, 0) / values.length,
-  median: (values) => {
-    const sorted = [...values].sort((a, b) => a - b);
-    const mid = Math.floor(sorted.length / 2);
-    return sorted.length % 2 ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2;
-  },
-  min: (values) => Math.min(...values),
-  max: (values) => Math.max(...values),
-  sum: (values) => values.reduce((a, b) => a + b, 0)
-};
 function sd(values) {
   const n = values.length;
   if (n < 2)
@@ -3301,6 +3632,20 @@ function stat_summary(params = {}) {
     }
   };
 }
+var summaryFunctions;
+var init_summary = __esm(() => {
+  summaryFunctions = {
+    mean: (values) => values.reduce((a, b) => a + b, 0) / values.length,
+    median: (values) => {
+      const sorted = [...values].sort((a, b) => a - b);
+      const mid = Math.floor(sorted.length / 2);
+      return sorted.length % 2 ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2;
+    },
+    min: (values) => Math.min(...values),
+    max: (values) => Math.max(...values),
+    sum: (values) => values.reduce((a, b) => a + b, 0)
+  };
+});
 
 // src/stats/qq.ts
 function qnorm(p, mean = 0, sd2 = 1) {
@@ -3483,15 +3828,125 @@ function stat_qq_line(params = {}) {
   };
 }
 
+// src/stats/density2d.ts
+function gaussian2d(dx, dy, hx, hy) {
+  const ux = dx / hx;
+  const uy = dy / hy;
+  return Math.exp(-0.5 * (ux * ux + uy * uy)) / (2 * Math.PI * hx * hy);
+}
+function scottBandwidth2d(values) {
+  const n = values.length;
+  if (n < 2)
+    return 1;
+  const mean = values.reduce((a, b) => a + b, 0) / n;
+  const variance = values.reduce((sum, v) => sum + (v - mean) ** 2, 0) / (n - 1);
+  const std = Math.sqrt(variance);
+  return std * Math.pow(n, -1 / 6);
+}
+function computeDensity2d(data, xField, yField, params = {}) {
+  const points = [];
+  const xValues = [];
+  const yValues = [];
+  for (const row of data) {
+    const xVal = row[xField];
+    const yVal = row[yField];
+    if (xVal === null || xVal === undefined || yVal === null || yVal === undefined)
+      continue;
+    const x = Number(xVal);
+    const y = Number(yVal);
+    if (isNaN(x) || isNaN(y))
+      continue;
+    points.push({ x, y });
+    xValues.push(x);
+    yValues.push(y);
+  }
+  if (points.length < 3) {
+    return [];
+  }
+  const n = params.n ?? 50;
+  const nx = params.nx ?? n;
+  const ny = params.ny ?? n;
+  const adjust = params.adjust ?? 1;
+  let hx, hy;
+  if (Array.isArray(params.h)) {
+    hx = params.h[0] * adjust;
+    hy = params.h[1] * adjust;
+  } else if (params.h !== undefined) {
+    hx = params.h * adjust;
+    hy = params.h * adjust;
+  } else {
+    hx = scottBandwidth2d(xValues) * adjust;
+    hy = scottBandwidth2d(yValues) * adjust;
+  }
+  if (hx <= 0)
+    hx = 1;
+  if (hy <= 0)
+    hy = 1;
+  const xMin = Math.min(...xValues);
+  const xMax = Math.max(...xValues);
+  const yMin = Math.min(...yValues);
+  const yMax = Math.max(...yValues);
+  const xPad = 3 * hx;
+  const yPad = 3 * hy;
+  const gridXMin = xMin - xPad;
+  const gridXMax = xMax + xPad;
+  const gridYMin = yMin - yPad;
+  const gridYMax = yMax + yPad;
+  const xStep = (gridXMax - gridXMin) / (nx - 1);
+  const yStep = (gridYMax - gridYMin) / (ny - 1);
+  const results = [];
+  const nPoints = points.length;
+  for (let i = 0;i < nx; i++) {
+    const gx = gridXMin + i * xStep;
+    for (let j = 0;j < ny; j++) {
+      const gy = gridYMin + j * yStep;
+      let density = 0;
+      for (const pt of points) {
+        density += gaussian2d(gx - pt.x, gy - pt.y, hx, hy);
+      }
+      density /= nPoints;
+      results.push({
+        x: gx,
+        y: gy,
+        z: density,
+        density,
+        level: density
+      });
+    }
+  }
+  return results;
+}
+function stat_density_2d(params = {}) {
+  return {
+    type: "density_2d",
+    compute(data, aes) {
+      if (aes.color) {
+        const groups = new Map;
+        for (const row of data) {
+          const group = String(row[aes.color] ?? "default");
+          if (!groups.has(group)) {
+            groups.set(group, []);
+          }
+          groups.get(group).push(row);
+        }
+        const result = [];
+        for (const [group, groupData] of groups) {
+          const density = computeDensity2d(groupData, aes.x, aes.y, params);
+          for (const d of density) {
+            result.push({
+              ...d,
+              [aes.color]: group
+            });
+          }
+        }
+        return result;
+      }
+      return computeDensity2d(data, aes.x, aes.y, params);
+    }
+  };
+}
+
 // src/facets/index.ts
-var label_value = (value) => value;
-var label_both = (value, variable) => variable ? `${variable}: ${value}` : value;
-var label_parsed = (value) => value.replace(/_/g, " ");
-var label_wrap = (width) => (value) => {
-  if (value.length <= width)
-    return value;
-  return value.substring(0, width - 1) + "…";
-};
 function as_labeller(labels) {
   return (value) => labels[value] ?? value;
 }
@@ -3684,6 +4139,11 @@ function calculateGridStripLayout(totalWidth, totalHeight, nrow, ncol, hasTitle,
     rowStripWidth: rowStripWidth - 1
   };
 }
+var label_value = (value) => value, label_both = (value, variable) => variable ? `${variable}: ${value}` : value, label_parsed = (value) => value.replace(/_/g, " "), label_wrap = (width) => (value) => {
+  if (value.length <= width)
+    return value;
+  return value.substring(0, width - 1) + "…";
+};
 
 // src/pipeline/pipeline.ts
 function calculateLayout(spec, options) {
@@ -3796,6 +4256,23 @@ function applyStatTransform(data, geom, aes) {
       dparams: geom.params.dparams
     });
     return qqLineStat.compute(data, aes);
+  } else if (geom.stat === "bin2d") {
+    const bin2dStat = stat_bin2d({
+      bins: geom.params.bins,
+      binsx: geom.params.binsx,
+      binsy: geom.params.binsy,
+      drop: geom.params.drop
+    });
+    return bin2dStat.compute(data, aes);
+  } else if (geom.stat === "density_2d") {
+    const density2dStat = stat_density_2d({
+      h: geom.params.bandwidth,
+      n: geom.params.n,
+      nx: geom.params.nx,
+      ny: geom.params.ny,
+      adjust: geom.params.adjust
+    });
+    return density2dStat.compute(data, aes);
   }
   return data;
 }
@@ -3860,6 +4337,14 @@ function renderToCanvas(spec, options) {
         scaleAes = { ...spec.aes, x: "x", y: "y" };
       }
       break;
+    } else if (geom.stat === "bin2d") {
+      scaleData = applyStatTransform(spec.data, geom, spec.aes);
+      scaleAes = { ...spec.aes, x: "x", y: "y", fill: "fill" };
+      break;
+    } else if (geom.stat === "density_2d") {
+      scaleData = applyStatTransform(spec.data, geom, spec.aes);
+      scaleAes = { ...spec.aes, x: "x", y: "y" };
+      break;
     }
   }
   scaleData = applyCoordTransform(scaleData, scaleAes, spec.coord);
@@ -3894,6 +4379,10 @@ function renderToCanvas(spec, options) {
         geomAes = { ...spec.aes, x: "x", y: "y" };
       } else if (geom.stat === "qq_line") {
         geomAes = { ...spec.aes, x: "x", y: "y", xend: "xend", yend: "yend" };
+      } else if (geom.stat === "bin2d") {
+        geomAes = { ...spec.aes, x: "x", y: "y", fill: "fill" };
+      } else if (geom.stat === "density_2d") {
+        geomAes = { ...spec.aes, x: "x", y: "y" };
       }
       geomData = applyCoordTransform(geomData, geomAes, spec.coord);
     }
@@ -4144,8 +4633,14 @@ function renderPanel(canvas, panel, layout, spec, facet, sharedScales, nrow = 1,
   renderPanelAxes(canvas, scales, plotArea, panel.row, panel.col, nrow, ncol, spec.theme);
   for (const geom of spec.geoms) {
     let geomData = applyStatTransform(panel.data, geom, spec.aes);
-    geomData = applyCoordTransform(geomData, spec.aes, spec.coord);
-    renderGeom(geomData, geom, spec.aes, scales, canvas, spec.coord.type);
+    let geomAes = spec.aes;
+    if (geom.stat === "bin" || geom.stat === "boxplot" || geom.stat === "count" || geom.stat === "qq") {
+      geomAes = { ...spec.aes, x: "x", y: "y" };
+    } else if (geom.stat === "bin2d") {
+      geomAes = { ...spec.aes, x: "x", y: "y", fill: "fill" };
+    }
+    geomData = applyCoordTransform(geomData, geomAes, spec.coord);
+    renderGeom(geomData, geom, geomAes, scales, canvas, spec.coord.type);
   }
 }
 function renderPanelAxes(canvas, scales, plotArea, row, col, nrow, _ncol, _theme) {
@@ -4193,9 +4688,22 @@ function renderToString(spec, options) {
   }
   return canvas.toAnsiString();
 }
+var init_pipeline = __esm(() => {
+  init_canvas();
+  init_scales();
+  init_render_geoms();
+  init_render_axes();
+  init_bin2d();
+  init_summary();
+});
 
 // src/pipeline/index.ts
-init_scales();
+var init_pipeline2 = __esm(() => {
+  init_pipeline();
+  init_scales();
+  init_render_geoms();
+  init_render_axes();
+});
 
 // src/grammar.ts
 class GGPlot {
@@ -4286,6 +4794,15 @@ class GGPlot {
 function gg(data = []) {
   return new GGPlot(data);
 }
+var init_grammar = __esm(() => {
+  init_pipeline2();
+});
+
+// src/canvas/index.ts
+var init_canvas2 = __esm(() => {
+  init_canvas();
+});
+
 // src/geoms/point.ts
 function geom_point(options = {}) {
   return {
@@ -4300,6 +4817,7 @@ function geom_point(options = {}) {
     }
   };
 }
+
 // src/geoms/line.ts
 function geom_line(options = {}) {
   return {
@@ -4338,6 +4856,7 @@ function geom_vline(options) {
     }
   };
 }
+
 // src/geoms/path.ts
 function geom_path(options = {}) {
   return {
@@ -4354,6 +4873,7 @@ function geom_path(options = {}) {
     }
   };
 }
+
 // src/geoms/bar.ts
 function geom_bar(options = {}) {
   return {
@@ -4371,6 +4891,7 @@ function geom_bar(options = {}) {
 function geom_col(options = {}) {
   return geom_bar({ ...options, stat: "identity" });
 }
+
 // src/geoms/text.ts
 function geom_text(options = {}) {
   return {
@@ -4403,6 +4924,7 @@ function geom_label(options = {}) {
     }
   };
 }
+
 // src/geoms/area.ts
 function geom_area(options = {}) {
   return {
@@ -4428,6 +4950,7 @@ function geom_ribbon(options = {}) {
     }
   };
 }
+
 // src/geoms/histogram.ts
 function geom_histogram(options = {}) {
   return {
@@ -4459,6 +4982,7 @@ function geom_freqpoly(options = {}) {
     }
   };
 }
+
 // src/geoms/boxplot.ts
 function geom_boxplot(options = {}) {
   return {
@@ -4475,6 +4999,7 @@ function geom_boxplot(options = {}) {
     }
   };
 }
+
 // src/geoms/segment.ts
 function geom_segment(options = {}) {
   return {
@@ -4507,6 +5032,7 @@ function geom_curve(options = {}) {
     }
   };
 }
+
 // src/geoms/smooth.ts
 function geom_smooth(options = {}) {
   return {
@@ -4526,6 +5052,7 @@ function geom_smooth(options = {}) {
     }
   };
 }
+
 // src/geoms/step.ts
 function geom_step(options = {}) {
   return {
@@ -4541,6 +5068,7 @@ function geom_step(options = {}) {
     }
   };
 }
+
 // src/geoms/rug.ts
 function geom_rug(options = {}) {
   return {
@@ -4556,6 +5084,7 @@ function geom_rug(options = {}) {
     }
   };
 }
+
 // src/geoms/violin.ts
 function geom_violin(options = {}) {
   return {
@@ -4573,6 +5102,7 @@ function geom_violin(options = {}) {
     }
   };
 }
+
 // src/geoms/tile.ts
 function geom_tile(options = {}) {
   return {
@@ -4591,6 +5121,22 @@ function geom_tile(options = {}) {
 function geom_raster(options = {}) {
   return geom_tile(options);
 }
+
+// src/geoms/bin2d.ts
+function geom_bin2d(options = {}) {
+  return {
+    type: "bin2d",
+    stat: "bin2d",
+    params: {
+      bins: options.bins ?? 30,
+      binsx: options.binsx,
+      binsy: options.binsy,
+      alpha: options.alpha ?? 1,
+      drop: options.drop ?? true
+    }
+  };
+}
+
 // src/geoms/contour.ts
 function geom_contour(options = {}) {
   return {
@@ -4633,6 +5179,7 @@ function geom_density_2d(options = {}) {
     }
   };
 }
+
 // src/geoms/errorbar.ts
 function geom_errorbar(options = {}) {
   return {
@@ -4699,6 +5246,7 @@ function geom_pointrange(options = {}) {
     }
   };
 }
+
 // src/geoms/rect.ts
 function geom_rect(options = {}) {
   return {
@@ -4727,6 +5275,7 @@ function geom_abline(options = {}) {
     }
   };
 }
+
 // src/geoms/qq.ts
 function geom_qq(options = {}) {
   return {
@@ -4755,6 +5304,16 @@ function geom_qq_line(options = {}) {
     }
   };
 }
+
+// src/geoms/index.ts
+var init_geoms = () => {};
+
+// src/stats/index.ts
+var init_stats = __esm(() => {
+  init_bin2d();
+  init_summary();
+});
+
 // src/scales/continuous.ts
 function createContinuousScale(aesthetic, options = {}) {
   const trans = options.trans ?? "identity";
@@ -4833,6 +5392,7 @@ function scale_y2_sqrt(options = {}) {
 function scale_y2_reverse(options = {}) {
   return createContinuousScale("y2", { ...options, trans: "reverse" });
 }
+
 // src/scales/discrete.ts
 function createDiscreteScale(aesthetic, options = {}) {
   const valueToPosition = new Map;
@@ -4882,123 +5442,8 @@ function scale_x_discrete(options = {}) {
 function scale_y_discrete(options = {}) {
   return createDiscreteScale("y", options);
 }
+
 // src/scales/color.ts
-var PALETTES = {
-  viridis: ["#440154", "#414487", "#2a788e", "#22a884", "#7ad151", "#fde725"],
-  plasma: ["#0d0887", "#6a00a8", "#b12a90", "#e16462", "#fca636", "#f0f921"],
-  inferno: ["#000004", "#420a68", "#932667", "#dd513a", "#fca50a", "#fcffa4"],
-  magma: ["#000004", "#3b0f70", "#8c2981", "#de4968", "#fe9f6d", "#fcfdbf"],
-  cividis: ["#002051", "#1d3f6e", "#52596a", "#7b7b78", "#a89f68", "#d9c84a", "#fdea45"],
-  turbo: ["#30123b", "#4662d7", "#35aaf8", "#1ae4b6", "#72fe5e", "#c8ef34", "#faba39", "#f66b19", "#ca2a04"],
-  Blues: ["#f7fbff", "#deebf7", "#c6dbef", "#9ecae1", "#6baed6", "#4292c6", "#2171b5", "#08519c", "#08306b"],
-  Greens: ["#f7fcf5", "#e5f5e0", "#c7e9c0", "#a1d99b", "#74c476", "#41ab5d", "#238b45", "#006d2c", "#00441b"],
-  Greys: ["#ffffff", "#f0f0f0", "#d9d9d9", "#bdbdbd", "#969696", "#737373", "#525252", "#252525", "#000000"],
-  Oranges: ["#fff5eb", "#fee6ce", "#fdd0a2", "#fdae6b", "#fd8d3c", "#f16913", "#d94801", "#a63603", "#7f2704"],
-  Purples: ["#fcfbfd", "#efedf5", "#dadaeb", "#bcbddc", "#9e9ac8", "#807dba", "#6a51a3", "#54278f", "#3f007d"],
-  Reds: ["#fff5f0", "#fee0d2", "#fcbba1", "#fc9272", "#fb6a4a", "#ef3b2c", "#cb181d", "#a50f15", "#67000d"],
-  BuGn: ["#f7fcfd", "#e5f5f9", "#ccece6", "#99d8c9", "#66c2a4", "#41ae76", "#238b45", "#006d2c", "#00441b"],
-  BuPu: ["#f7fcfd", "#e0ecf4", "#bfd3e6", "#9ebcda", "#8c96c6", "#8c6bb1", "#88419d", "#810f7c", "#4d004b"],
-  GnBu: ["#f7fcf0", "#e0f3db", "#ccebc5", "#a8ddb5", "#7bccc4", "#4eb3d3", "#2b8cbe", "#0868ac", "#084081"],
-  OrRd: ["#fff7ec", "#fee8c8", "#fdd49e", "#fdbb84", "#fc8d59", "#ef6548", "#d7301f", "#b30000", "#7f0000"],
-  PuBu: ["#fff7fb", "#ece7f2", "#d0d1e6", "#a6bddb", "#74a9cf", "#3690c0", "#0570b0", "#045a8d", "#023858"],
-  PuBuGn: ["#fff7fb", "#ece2f0", "#d0d1e6", "#a6bddb", "#67a9cf", "#3690c0", "#02818a", "#016c59", "#014636"],
-  PuRd: ["#f7f4f9", "#e7e1ef", "#d4b9da", "#c994c7", "#df65b0", "#e7298a", "#ce1256", "#980043", "#67001f"],
-  RdPu: ["#fff7f3", "#fde0dd", "#fcc5c0", "#fa9fb5", "#f768a1", "#dd3497", "#ae017e", "#7a0177", "#49006a"],
-  YlGn: ["#ffffe5", "#f7fcb9", "#d9f0a3", "#addd8e", "#78c679", "#41ab5d", "#238b45", "#006837", "#004529"],
-  YlGnBu: ["#ffffd9", "#edf8b1", "#c7e9b4", "#7fcdbb", "#41b6c4", "#1d91c0", "#225ea8", "#253494", "#081d58"],
-  YlOrBr: ["#ffffe5", "#fff7bc", "#fee391", "#fec44f", "#fe9929", "#ec7014", "#cc4c02", "#993404", "#662506"],
-  YlOrRd: ["#ffffcc", "#ffeda0", "#fed976", "#feb24c", "#fd8d3c", "#fc4e2a", "#e31a1c", "#bd0026", "#800026"],
-  BrBG: ["#543005", "#8c510a", "#bf812d", "#dfc27d", "#f6e8c3", "#f5f5f5", "#c7eae5", "#80cdc1", "#35978f", "#01665e", "#003c30"],
-  PiYG: ["#8e0152", "#c51b7d", "#de77ae", "#f1b6da", "#fde0ef", "#f7f7f7", "#e6f5d0", "#b8e186", "#7fbc41", "#4d9221", "#276419"],
-  PRGn: ["#40004b", "#762a83", "#9970ab", "#c2a5cf", "#e7d4e8", "#f7f7f7", "#d9f0d3", "#a6dba0", "#5aae61", "#1b7837", "#00441b"],
-  PuOr: ["#7f3b08", "#b35806", "#e08214", "#fdb863", "#fee0b6", "#f7f7f7", "#d8daeb", "#b2abd2", "#8073ac", "#542788", "#2d004b"],
-  RdBu: ["#67001f", "#b2182b", "#d6604d", "#f4a582", "#fddbc7", "#f7f7f7", "#d1e5f0", "#92c5de", "#4393c3", "#2166ac", "#053061"],
-  RdGy: ["#67001f", "#b2182b", "#d6604d", "#f4a582", "#fddbc7", "#ffffff", "#e0e0e0", "#bababa", "#878787", "#4d4d4d", "#1a1a1a"],
-  RdYlBu: ["#a50026", "#d73027", "#f46d43", "#fdae61", "#fee090", "#ffffbf", "#e0f3f8", "#abd9e9", "#74add1", "#4575b4", "#313695"],
-  RdYlGn: ["#a50026", "#d73027", "#f46d43", "#fdae61", "#fee08b", "#ffffbf", "#d9ef8b", "#a6d96a", "#66bd63", "#1a9850", "#006837"],
-  Spectral: ["#9e0142", "#d53e4f", "#f46d43", "#fdae61", "#fee08b", "#ffffbf", "#e6f598", "#abdda4", "#66c2a5", "#3288bd", "#5e4fa2"],
-  category10: [
-    "#1f77b4",
-    "#ff7f0e",
-    "#2ca02c",
-    "#d62728",
-    "#9467bd",
-    "#8c564b",
-    "#e377c2",
-    "#7f7f7f",
-    "#bcbd22",
-    "#17becf"
-  ],
-  category20: [
-    "#1f77b4",
-    "#aec7e8",
-    "#ff7f0e",
-    "#ffbb78",
-    "#2ca02c",
-    "#98df8a",
-    "#d62728",
-    "#ff9896",
-    "#9467bd",
-    "#c5b0d5",
-    "#8c564b",
-    "#c49c94",
-    "#e377c2",
-    "#f7b6d2",
-    "#7f7f7f",
-    "#c7c7c7",
-    "#bcbd22",
-    "#dbdb8d",
-    "#17becf",
-    "#9edae5"
-  ],
-  Accent: ["#7fc97f", "#beaed4", "#fdc086", "#ffff99", "#386cb0", "#f0027f", "#bf5b17", "#666666"],
-  Dark2: ["#1b9e77", "#d95f02", "#7570b3", "#e7298a", "#66a61e", "#e6ab02", "#a6761d", "#666666"],
-  Paired: ["#a6cee3", "#1f78b4", "#b2df8a", "#33a02c", "#fb9a99", "#e31a1c", "#fdbf6f", "#ff7f00", "#cab2d6", "#6a3d9a", "#ffff99", "#b15928"],
-  Pastel1: ["#fbb4ae", "#b3cde3", "#ccebc5", "#decbe4", "#fed9a6", "#ffffcc", "#e5d8bd", "#fddaec", "#f2f2f2"],
-  Pastel2: ["#b3e2cd", "#fdcdac", "#cbd5e8", "#f4cae4", "#e6f5c9", "#fff2ae", "#f1e2cc", "#cccccc"],
-  Set1: ["#e41a1c", "#377eb8", "#4daf4a", "#984ea3", "#ff7f00", "#ffff33", "#a65628", "#f781bf", "#999999"],
-  Set2: ["#66c2a5", "#fc8d62", "#8da0cb", "#e78ac3", "#a6d854", "#ffd92f", "#e5c494", "#b3b3b3"],
-  Set3: ["#8dd3c7", "#ffffb3", "#bebada", "#fb8072", "#80b1d3", "#fdb462", "#b3de69", "#fccde5", "#d9d9d9", "#bc80bd", "#ccebc5", "#ffed6f"],
-  Tab10: [
-    "#4e79a7",
-    "#f28e2c",
-    "#e15759",
-    "#76b7b2",
-    "#59a14f",
-    "#edc949",
-    "#af7aa1",
-    "#ff9da7",
-    "#9c755f",
-    "#bab0ab"
-  ],
-  Tab20: [
-    "#4e79a7",
-    "#a0cbe8",
-    "#f28e2c",
-    "#ffbe7d",
-    "#59a14f",
-    "#8cd17d",
-    "#b6992d",
-    "#f1ce63",
-    "#499894",
-    "#86bcb6",
-    "#e15759",
-    "#ff9d9a",
-    "#79706e",
-    "#bab0ac",
-    "#d37295",
-    "#fabfd2",
-    "#b07aa1",
-    "#d4a6c8",
-    "#9d7660",
-    "#d7b5a6"
-  ],
-  thermal: ["#042333", "#2c3e50", "#0b5345", "#1e8449", "#f39c12", "#e74c3c", "#fadbd8"],
-  haline: ["#2c3e50", "#1a5276", "#2980b9", "#5dade2", "#aed6f1", "#d5f5e3"],
-  terrain: ["#333399", "#0099ff", "#00cc00", "#ffff00", "#ff9900", "#cc6600", "#996633", "#ffffff"],
-  rainbow: ["#ff0000", "#ff8000", "#ffff00", "#80ff00", "#00ff00", "#00ff80", "#00ffff", "#0080ff", "#0000ff", "#8000ff"],
-  cubehelix: ["#000000", "#1a1530", "#30304d", "#4d5366", "#6d826e", "#8ab17d", "#add38a", "#dae8a2", "#ffffff"]
-};
 function hexToRgba(hex) {
   const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
   if (!result)
@@ -5219,6 +5664,126 @@ function getAvailablePalettes() {
 function getPaletteColors(name) {
   return PALETTES[name];
 }
+var PALETTES;
+var init_color = __esm(() => {
+  PALETTES = {
+    viridis: ["#440154", "#414487", "#2a788e", "#22a884", "#7ad151", "#fde725"],
+    plasma: ["#0d0887", "#6a00a8", "#b12a90", "#e16462", "#fca636", "#f0f921"],
+    inferno: ["#000004", "#420a68", "#932667", "#dd513a", "#fca50a", "#fcffa4"],
+    magma: ["#000004", "#3b0f70", "#8c2981", "#de4968", "#fe9f6d", "#fcfdbf"],
+    cividis: ["#002051", "#1d3f6e", "#52596a", "#7b7b78", "#a89f68", "#d9c84a", "#fdea45"],
+    turbo: ["#30123b", "#4662d7", "#35aaf8", "#1ae4b6", "#72fe5e", "#c8ef34", "#faba39", "#f66b19", "#ca2a04"],
+    Blues: ["#f7fbff", "#deebf7", "#c6dbef", "#9ecae1", "#6baed6", "#4292c6", "#2171b5", "#08519c", "#08306b"],
+    Greens: ["#f7fcf5", "#e5f5e0", "#c7e9c0", "#a1d99b", "#74c476", "#41ab5d", "#238b45", "#006d2c", "#00441b"],
+    Greys: ["#ffffff", "#f0f0f0", "#d9d9d9", "#bdbdbd", "#969696", "#737373", "#525252", "#252525", "#000000"],
+    Oranges: ["#fff5eb", "#fee6ce", "#fdd0a2", "#fdae6b", "#fd8d3c", "#f16913", "#d94801", "#a63603", "#7f2704"],
+    Purples: ["#fcfbfd", "#efedf5", "#dadaeb", "#bcbddc", "#9e9ac8", "#807dba", "#6a51a3", "#54278f", "#3f007d"],
+    Reds: ["#fff5f0", "#fee0d2", "#fcbba1", "#fc9272", "#fb6a4a", "#ef3b2c", "#cb181d", "#a50f15", "#67000d"],
+    BuGn: ["#f7fcfd", "#e5f5f9", "#ccece6", "#99d8c9", "#66c2a4", "#41ae76", "#238b45", "#006d2c", "#00441b"],
+    BuPu: ["#f7fcfd", "#e0ecf4", "#bfd3e6", "#9ebcda", "#8c96c6", "#8c6bb1", "#88419d", "#810f7c", "#4d004b"],
+    GnBu: ["#f7fcf0", "#e0f3db", "#ccebc5", "#a8ddb5", "#7bccc4", "#4eb3d3", "#2b8cbe", "#0868ac", "#084081"],
+    OrRd: ["#fff7ec", "#fee8c8", "#fdd49e", "#fdbb84", "#fc8d59", "#ef6548", "#d7301f", "#b30000", "#7f0000"],
+    PuBu: ["#fff7fb", "#ece7f2", "#d0d1e6", "#a6bddb", "#74a9cf", "#3690c0", "#0570b0", "#045a8d", "#023858"],
+    PuBuGn: ["#fff7fb", "#ece2f0", "#d0d1e6", "#a6bddb", "#67a9cf", "#3690c0", "#02818a", "#016c59", "#014636"],
+    PuRd: ["#f7f4f9", "#e7e1ef", "#d4b9da", "#c994c7", "#df65b0", "#e7298a", "#ce1256", "#980043", "#67001f"],
+    RdPu: ["#fff7f3", "#fde0dd", "#fcc5c0", "#fa9fb5", "#f768a1", "#dd3497", "#ae017e", "#7a0177", "#49006a"],
+    YlGn: ["#ffffe5", "#f7fcb9", "#d9f0a3", "#addd8e", "#78c679", "#41ab5d", "#238b45", "#006837", "#004529"],
+    YlGnBu: ["#ffffd9", "#edf8b1", "#c7e9b4", "#7fcdbb", "#41b6c4", "#1d91c0", "#225ea8", "#253494", "#081d58"],
+    YlOrBr: ["#ffffe5", "#fff7bc", "#fee391", "#fec44f", "#fe9929", "#ec7014", "#cc4c02", "#993404", "#662506"],
+    YlOrRd: ["#ffffcc", "#ffeda0", "#fed976", "#feb24c", "#fd8d3c", "#fc4e2a", "#e31a1c", "#bd0026", "#800026"],
+    BrBG: ["#543005", "#8c510a", "#bf812d", "#dfc27d", "#f6e8c3", "#f5f5f5", "#c7eae5", "#80cdc1", "#35978f", "#01665e", "#003c30"],
+    PiYG: ["#8e0152", "#c51b7d", "#de77ae", "#f1b6da", "#fde0ef", "#f7f7f7", "#e6f5d0", "#b8e186", "#7fbc41", "#4d9221", "#276419"],
+    PRGn: ["#40004b", "#762a83", "#9970ab", "#c2a5cf", "#e7d4e8", "#f7f7f7", "#d9f0d3", "#a6dba0", "#5aae61", "#1b7837", "#00441b"],
+    PuOr: ["#7f3b08", "#b35806", "#e08214", "#fdb863", "#fee0b6", "#f7f7f7", "#d8daeb", "#b2abd2", "#8073ac", "#542788", "#2d004b"],
+    RdBu: ["#67001f", "#b2182b", "#d6604d", "#f4a582", "#fddbc7", "#f7f7f7", "#d1e5f0", "#92c5de", "#4393c3", "#2166ac", "#053061"],
+    RdGy: ["#67001f", "#b2182b", "#d6604d", "#f4a582", "#fddbc7", "#ffffff", "#e0e0e0", "#bababa", "#878787", "#4d4d4d", "#1a1a1a"],
+    RdYlBu: ["#a50026", "#d73027", "#f46d43", "#fdae61", "#fee090", "#ffffbf", "#e0f3f8", "#abd9e9", "#74add1", "#4575b4", "#313695"],
+    RdYlGn: ["#a50026", "#d73027", "#f46d43", "#fdae61", "#fee08b", "#ffffbf", "#d9ef8b", "#a6d96a", "#66bd63", "#1a9850", "#006837"],
+    Spectral: ["#9e0142", "#d53e4f", "#f46d43", "#fdae61", "#fee08b", "#ffffbf", "#e6f598", "#abdda4", "#66c2a5", "#3288bd", "#5e4fa2"],
+    category10: [
+      "#1f77b4",
+      "#ff7f0e",
+      "#2ca02c",
+      "#d62728",
+      "#9467bd",
+      "#8c564b",
+      "#e377c2",
+      "#7f7f7f",
+      "#bcbd22",
+      "#17becf"
+    ],
+    category20: [
+      "#1f77b4",
+      "#aec7e8",
+      "#ff7f0e",
+      "#ffbb78",
+      "#2ca02c",
+      "#98df8a",
+      "#d62728",
+      "#ff9896",
+      "#9467bd",
+      "#c5b0d5",
+      "#8c564b",
+      "#c49c94",
+      "#e377c2",
+      "#f7b6d2",
+      "#7f7f7f",
+      "#c7c7c7",
+      "#bcbd22",
+      "#dbdb8d",
+      "#17becf",
+      "#9edae5"
+    ],
+    Accent: ["#7fc97f", "#beaed4", "#fdc086", "#ffff99", "#386cb0", "#f0027f", "#bf5b17", "#666666"],
+    Dark2: ["#1b9e77", "#d95f02", "#7570b3", "#e7298a", "#66a61e", "#e6ab02", "#a6761d", "#666666"],
+    Paired: ["#a6cee3", "#1f78b4", "#b2df8a", "#33a02c", "#fb9a99", "#e31a1c", "#fdbf6f", "#ff7f00", "#cab2d6", "#6a3d9a", "#ffff99", "#b15928"],
+    Pastel1: ["#fbb4ae", "#b3cde3", "#ccebc5", "#decbe4", "#fed9a6", "#ffffcc", "#e5d8bd", "#fddaec", "#f2f2f2"],
+    Pastel2: ["#b3e2cd", "#fdcdac", "#cbd5e8", "#f4cae4", "#e6f5c9", "#fff2ae", "#f1e2cc", "#cccccc"],
+    Set1: ["#e41a1c", "#377eb8", "#4daf4a", "#984ea3", "#ff7f00", "#ffff33", "#a65628", "#f781bf", "#999999"],
+    Set2: ["#66c2a5", "#fc8d62", "#8da0cb", "#e78ac3", "#a6d854", "#ffd92f", "#e5c494", "#b3b3b3"],
+    Set3: ["#8dd3c7", "#ffffb3", "#bebada", "#fb8072", "#80b1d3", "#fdb462", "#b3de69", "#fccde5", "#d9d9d9", "#bc80bd", "#ccebc5", "#ffed6f"],
+    Tab10: [
+      "#4e79a7",
+      "#f28e2c",
+      "#e15759",
+      "#76b7b2",
+      "#59a14f",
+      "#edc949",
+      "#af7aa1",
+      "#ff9da7",
+      "#9c755f",
+      "#bab0ab"
+    ],
+    Tab20: [
+      "#4e79a7",
+      "#a0cbe8",
+      "#f28e2c",
+      "#ffbe7d",
+      "#59a14f",
+      "#8cd17d",
+      "#b6992d",
+      "#f1ce63",
+      "#499894",
+      "#86bcb6",
+      "#e15759",
+      "#ff9d9a",
+      "#79706e",
+      "#bab0ac",
+      "#d37295",
+      "#fabfd2",
+      "#b07aa1",
+      "#d4a6c8",
+      "#9d7660",
+      "#d7b5a6"
+    ],
+    thermal: ["#042333", "#2c3e50", "#0b5345", "#1e8449", "#f39c12", "#e74c3c", "#fadbd8"],
+    haline: ["#2c3e50", "#1a5276", "#2980b9", "#5dade2", "#aed6f1", "#d5f5e3"],
+    terrain: ["#333399", "#0099ff", "#00cc00", "#ffff00", "#ff9900", "#cc6600", "#996633", "#ffffff"],
+    rainbow: ["#ff0000", "#ff8000", "#ffff00", "#80ff00", "#00ff00", "#00ff80", "#00ffff", "#0080ff", "#0000ff", "#8000ff"],
+    cubehelix: ["#000000", "#1a1530", "#30304d", "#4d5366", "#6d826e", "#8ab17d", "#add38a", "#dae8a2", "#ffffff"]
+  };
+});
+
 // src/scales/size.ts
 function scale_size_continuous(options = {}) {
   const range = options.range ?? [1, 6];
@@ -5287,45 +5852,8 @@ function scale_size_binned(options = {}) {
     }
   };
 }
+
 // src/scales/shape.ts
-var DEFAULT_SHAPES = [
-  "circle",
-  "square",
-  "triangle",
-  "diamond",
-  "cross",
-  "plus",
-  "star",
-  "open_circle",
-  "open_square",
-  "open_triangle",
-  "open_diamond",
-  "dot"
-];
-var SHAPE_CHARS = {
-  circle: "●",
-  filled_circle: "●",
-  open_circle: "○",
-  square: "■",
-  filled_square: "■",
-  open_square: "□",
-  triangle: "▲",
-  filled_triangle: "▲",
-  open_triangle: "△",
-  triangle_down: "▼",
-  diamond: "◆",
-  filled_diamond: "◆",
-  open_diamond: "◇",
-  cross: "✕",
-  plus: "+",
-  star: "★",
-  open_star: "☆",
-  dot: "•",
-  bullet: "•",
-  asterisk: "*",
-  hash: "#",
-  at: "@"
-};
 function scale_shape_discrete(options = {}) {
   const shapes = options.values ?? DEFAULT_SHAPES;
   return {
@@ -5384,6 +5912,48 @@ function scale_shape_ordinal(options = {}) {
     }
   };
 }
+var DEFAULT_SHAPES, SHAPE_CHARS;
+var init_shape = __esm(() => {
+  DEFAULT_SHAPES = [
+    "circle",
+    "square",
+    "triangle",
+    "diamond",
+    "cross",
+    "plus",
+    "star",
+    "open_circle",
+    "open_square",
+    "open_triangle",
+    "open_diamond",
+    "dot"
+  ];
+  SHAPE_CHARS = {
+    circle: "●",
+    filled_circle: "●",
+    open_circle: "○",
+    square: "■",
+    filled_square: "■",
+    open_square: "□",
+    triangle: "▲",
+    filled_triangle: "▲",
+    open_triangle: "△",
+    triangle_down: "▼",
+    diamond: "◆",
+    filled_diamond: "◆",
+    open_diamond: "◇",
+    cross: "✕",
+    plus: "+",
+    star: "★",
+    open_star: "☆",
+    dot: "•",
+    bullet: "•",
+    asterisk: "*",
+    hash: "#",
+    at: "@"
+  };
+});
+
 // src/scales/alpha.ts
 function scale_alpha_continuous(options = {}) {
   const range = options.range ?? [0.1, 1];
@@ -5480,17 +6050,8 @@ function scale_alpha_binned(options = {}) {
     }
   };
 }
+
 // src/scales/datetime.ts
-var TIME_INTERVALS = [
-  { name: "millisecond", ms: 1 },
-  { name: "second", ms: 1000 },
-  { name: "minute", ms: 60 * 1000 },
-  { name: "hour", ms: 60 * 60 * 1000 },
-  { name: "day", ms: 24 * 60 * 60 * 1000 },
-  { name: "week", ms: 7 * 24 * 60 * 60 * 1000 },
-  { name: "month", ms: 30 * 24 * 60 * 60 * 1000 },
-  { name: "year", ms: 365 * 24 * 60 * 60 * 1000 }
-];
 function parseDateTime(value) {
   if (value === null || value === undefined)
     return null;
@@ -5672,6 +6233,27 @@ function scale_y_duration(options = {}) {
   scale.aesthetic = "y";
   return scale;
 }
+var TIME_INTERVALS;
+var init_datetime = __esm(() => {
+  TIME_INTERVALS = [
+    { name: "millisecond", ms: 1 },
+    { name: "second", ms: 1000 },
+    { name: "minute", ms: 60 * 1000 },
+    { name: "hour", ms: 60 * 60 * 1000 },
+    { name: "day", ms: 24 * 60 * 60 * 1000 },
+    { name: "week", ms: 7 * 24 * 60 * 60 * 1000 },
+    { name: "month", ms: 30 * 24 * 60 * 60 * 1000 },
+    { name: "year", ms: 365 * 24 * 60 * 60 * 1000 }
+  ];
+});
+
+// src/scales/index.ts
+var init_scales2 = __esm(() => {
+  init_color();
+  init_shape();
+  init_datetime();
+});
+
 // src/annotations.ts
 function annotate(geomType, options = {}) {
   const parseColor2 = (c) => {
@@ -5825,6 +6407,7 @@ function annotate_hline(yintercept, options = {}) {
 function annotate_vline(xintercept, options = {}) {
   return annotate("vline", { ...options, x: xintercept });
 }
+
 // src/terminal/capabilities.ts
 function detectColorCapability() {
   const colorTerm = process.env.COLORTERM ?? "";
@@ -5937,7 +6520,6 @@ function getRecommendedRenderer(caps) {
     return "block";
   return "ascii";
 }
-var cachedCapabilities = null;
 function getCapabilities() {
   if (!cachedCapabilities) {
     cachedCapabilities = detectCapabilities();
@@ -5947,25 +6529,9 @@ function getCapabilities() {
 function clearCapabilityCache() {
   cachedCapabilities = null;
 }
+var cachedCapabilities = null;
+
 // src/terminal/colors.ts
-var ANSI_16_COLORS = [
-  { r: 0, g: 0, b: 0, a: 255 },
-  { r: 128, g: 0, b: 0, a: 255 },
-  { r: 0, g: 128, b: 0, a: 255 },
-  { r: 128, g: 128, b: 0, a: 255 },
-  { r: 0, g: 0, b: 128, a: 255 },
-  { r: 128, g: 0, b: 128, a: 255 },
-  { r: 0, g: 128, b: 128, a: 255 },
-  { r: 192, g: 192, b: 192, a: 255 },
-  { r: 128, g: 128, b: 128, a: 255 },
-  { r: 255, g: 0, b: 0, a: 255 },
-  { r: 0, g: 255, b: 0, a: 255 },
-  { r: 255, g: 255, b: 0, a: 255 },
-  { r: 0, g: 0, b: 255, a: 255 },
-  { r: 255, g: 0, b: 255, a: 255 },
-  { r: 0, g: 255, b: 255, a: 255 },
-  { r: 255, g: 255, b: 255, a: 255 }
-];
 function generate256Palette() {
   const palette = [];
   palette.push(...ANSI_16_COLORS);
@@ -5988,7 +6554,6 @@ function generate256Palette() {
   }
   return palette;
 }
-var _palette256 = null;
 function getPalette256() {
   if (!_palette256) {
     _palette256 = generate256Palette();
@@ -6225,28 +6790,29 @@ function getColorEscape(color, mode, type) {
   }
   return bgEscape(color, mode);
 }
-var RESET = "\x1B[0m";
-var RESET_FG = "\x1B[39m";
-var RESET_BG = "\x1B[49m";
+var ANSI_16_COLORS, _palette256 = null, RESET = "\x1B[0m", RESET_FG = "\x1B[39m", RESET_BG = "\x1B[49m";
+var init_colors = __esm(() => {
+  ANSI_16_COLORS = [
+    { r: 0, g: 0, b: 0, a: 255 },
+    { r: 128, g: 0, b: 0, a: 255 },
+    { r: 0, g: 128, b: 0, a: 255 },
+    { r: 128, g: 128, b: 0, a: 255 },
+    { r: 0, g: 0, b: 128, a: 255 },
+    { r: 128, g: 0, b: 128, a: 255 },
+    { r: 0, g: 128, b: 128, a: 255 },
+    { r: 192, g: 192, b: 192, a: 255 },
+    { r: 128, g: 128, b: 128, a: 255 },
+    { r: 255, g: 0, b: 0, a: 255 },
+    { r: 0, g: 255, b: 0, a: 255 },
+    { r: 255, g: 255, b: 0, a: 255 },
+    { r: 0, g: 0, b: 255, a: 255 },
+    { r: 255, g: 0, b: 255, a: 255 },
+    { r: 0, g: 255, b: 255, a: 255 },
+    { r: 255, g: 255, b: 255, a: 255 }
+  ];
+});
+
 // src/terminal/renderer-chain.ts
-var RENDERER_REQUIREMENTS = {
-  kitty: { graphics: "kitty" },
-  iterm2: { graphics: "iterm2" },
-  sixel: { graphics: "sixel" },
-  braille: { unicode: true, braille: true },
-  "block-subpixel": { unicode: true },
-  block: { unicode: true },
-  ascii: {}
-};
-var FALLBACK_ORDER = [
-  "kitty",
-  "iterm2",
-  "sixel",
-  "braille",
-  "block-subpixel",
-  "block",
-  "ascii"
-];
 function isRendererAvailable(type, caps) {
   const reqs = RENDERER_REQUIREMENTS[type];
   if (reqs.graphics) {
@@ -6395,194 +6961,226 @@ function getTerminalInfo() {
     isTTY: caps.isTTY
   };
 }
+var RENDERER_REQUIREMENTS, FALLBACK_ORDER;
+var init_renderer_chain = __esm(() => {
+  init_colors();
+  RENDERER_REQUIREMENTS = {
+    kitty: { graphics: "kitty" },
+    iterm2: { graphics: "iterm2" },
+    sixel: { graphics: "sixel" },
+    braille: { unicode: true, braille: true },
+    "block-subpixel": { unicode: true },
+    block: { unicode: true },
+    ascii: {}
+  };
+  FALLBACK_ORDER = [
+    "kitty",
+    "iterm2",
+    "sixel",
+    "braille",
+    "block-subpixel",
+    "block",
+    "ascii"
+  ];
+});
+
+// src/terminal/index.ts
+var init_terminal = __esm(() => {
+  init_colors();
+  init_renderer_chain();
+});
+
 // src/streaming/data-buffer.ts
-class DataBuffer {
-  buffer;
-  head = 0;
-  tail = 0;
-  _size = 0;
-  options;
-  lastCleanup = 0;
-  cleanupInterval = 1000;
-  constructor(options) {
-    this.options = {
-      maxSize: options.maxSize,
-      overwrite: options.overwrite ?? true,
-      timeField: options.timeField ?? "time",
-      maxAge: options.maxAge ?? 0
-    };
-    this.buffer = new Array(options.maxSize);
-  }
-  push(record) {
-    if (this.options.maxAge > 0) {
-      this.cleanupOldData();
+function createDataBuffer(options) {
+  return new DataBuffer(options);
+}
+var DataBuffer;
+var init_data_buffer = __esm(() => {
+  DataBuffer = class DataBuffer {
+    buffer;
+    head = 0;
+    tail = 0;
+    _size = 0;
+    options;
+    lastCleanup = 0;
+    cleanupInterval = 1000;
+    constructor(options) {
+      this.options = {
+        maxSize: options.maxSize,
+        overwrite: options.overwrite ?? true,
+        timeField: options.timeField ?? "time",
+        maxAge: options.maxAge ?? 0
+      };
+      this.buffer = new Array(options.maxSize);
     }
-    if (this._size === this.options.maxSize) {
-      if (!this.options.overwrite) {
-        return false;
+    push(record) {
+      if (this.options.maxAge > 0) {
+        this.cleanupOldData();
       }
-      this.head = (this.head + 1) % this.options.maxSize;
-    } else {
-      this._size++;
+      if (this._size === this.options.maxSize) {
+        if (!this.options.overwrite) {
+          return false;
+        }
+        this.head = (this.head + 1) % this.options.maxSize;
+      } else {
+        this._size++;
+      }
+      this.buffer[this.tail] = record;
+      this.tail = (this.tail + 1) % this.options.maxSize;
+      return true;
     }
-    this.buffer[this.tail] = record;
-    this.tail = (this.tail + 1) % this.options.maxSize;
-    return true;
-  }
-  pushMany(records) {
-    let added = 0;
-    for (const record of records) {
-      if (this.push(record)) {
-        added++;
+    pushMany(records) {
+      let added = 0;
+      for (const record of records) {
+        if (this.push(record)) {
+          added++;
+        }
+      }
+      return added;
+    }
+    shift() {
+      if (this._size === 0) {
+        return;
       }
+      const record = this.buffer[this.head];
+      this.head = (this.head + 1) % this.options.maxSize;
+      this._size--;
+      return record;
     }
-    return added;
-  }
-  shift() {
-    if (this._size === 0) {
-      return;
+    get(index) {
+      if (index < 0 || index >= this._size) {
+        return;
+      }
+      const actualIndex = (this.head + index) % this.options.maxSize;
+      return this.buffer[actualIndex];
     }
-    const record = this.buffer[this.head];
-    this.head = (this.head + 1) % this.options.maxSize;
-    this._size--;
-    return record;
-  }
-  get(index) {
-    if (index < 0 || index >= this._size) {
-      return;
+    latest() {
+      if (this._size === 0) {
+        return;
+      }
+      const index = (this.tail - 1 + this.options.maxSize) % this.options.maxSize;
+      return this.buffer[index];
     }
-    const actualIndex = (this.head + index) % this.options.maxSize;
-    return this.buffer[actualIndex];
-  }
-  latest() {
-    if (this._size === 0) {
-      return;
+    oldest() {
+      if (this._size === 0) {
+        return;
+      }
+      return this.buffer[this.head];
     }
-    const index = (this.tail - 1 + this.options.maxSize) % this.options.maxSize;
-    return this.buffer[index];
-  }
-  oldest() {
-    if (this._size === 0) {
-      return;
+    toArray() {
+      const result = [];
+      for (let i = 0;i < this._size; i++) {
+        const index = (this.head + i) % this.options.maxSize;
+        result.push(this.buffer[index]);
+      }
+      return result;
     }
-    return this.buffer[this.head];
-  }
-  toArray() {
-    const result = [];
-    for (let i = 0;i < this._size; i++) {
-      const index = (this.head + i) % this.options.maxSize;
-      result.push(this.buffer[index]);
+    getTimeRange(startTime, endTime) {
+      const timeField = this.options.timeField;
+      const result = [];
+      for (let i = 0;i < this._size; i++) {
+        const index = (this.head + i) % this.options.maxSize;
+        const record = this.buffer[index];
+        const time = record[timeField];
+        if (time >= startTime && time <= endTime) {
+          result.push(record);
+        }
+      }
+      return result;
     }
-    return result;
-  }
-  getTimeRange(startTime, endTime) {
-    const timeField = this.options.timeField;
-    const result = [];
-    for (let i = 0;i < this._size; i++) {
-      const index = (this.head + i) % this.options.maxSize;
-      const record = this.buffer[index];
-      const time = record[timeField];
-      if (time >= startTime && time <= endTime) {
-        result.push(record);
+    getLast(n) {
+      const count = Math.min(n, this._size);
+      const result = [];
+      for (let i = this._size - count;i < this._size; i++) {
+        const index = (this.head + i) % this.options.maxSize;
+        result.push(this.buffer[index]);
       }
+      return result;
     }
-    return result;
-  }
-  getLast(n) {
-    const count = Math.min(n, this._size);
-    const result = [];
-    for (let i = this._size - count;i < this._size; i++) {
-      const index = (this.head + i) % this.options.maxSize;
-      result.push(this.buffer[index]);
+    clear() {
+      this.head = 0;
+      this.tail = 0;
+      this._size = 0;
     }
-    return result;
-  }
-  clear() {
-    this.head = 0;
-    this.tail = 0;
-    this._size = 0;
-  }
-  get size() {
-    return this._size;
-  }
-  get capacity() {
-    return this.options.maxSize;
-  }
-  get isFull() {
-    return this._size === this.options.maxSize;
-  }
-  get isEmpty() {
-    return this._size === 0;
-  }
-  getTimeExtent() {
-    if (this._size === 0) {
-      return null;
+    get size() {
+      return this._size;
     }
-    const timeField = this.options.timeField;
-    let min = Infinity;
-    let max = -Infinity;
-    for (let i = 0;i < this._size; i++) {
-      const index = (this.head + i) % this.options.maxSize;
-      const time = this.buffer[index][timeField];
-      if (time < min)
-        min = time;
-      if (time > max)
-        max = time;
+    get capacity() {
+      return this.options.maxSize;
     }
-    return { min, max };
-  }
-  cleanupOldData() {
-    const now = Date.now();
-    if (now - this.lastCleanup < this.cleanupInterval) {
-      return;
+    get isFull() {
+      return this._size === this.options.maxSize;
     }
-    this.lastCleanup = now;
-    const cutoff = now - this.options.maxAge;
-    const timeField = this.options.timeField;
-    while (this._size > 0) {
-      const oldest = this.buffer[this.head];
-      const time = oldest[timeField];
-      if (time >= cutoff) {
-        break;
+    get isEmpty() {
+      return this._size === 0;
+    }
+    getTimeExtent() {
+      if (this._size === 0) {
+        return null;
       }
-      this.head = (this.head + 1) % this.options.maxSize;
-      this._size--;
+      const timeField = this.options.timeField;
+      let min = Infinity;
+      let max = -Infinity;
+      for (let i = 0;i < this._size; i++) {
+        const index = (this.head + i) % this.options.maxSize;
+        const time = this.buffer[index][timeField];
+        if (time < min)
+          min = time;
+        if (time > max)
+          max = time;
+      }
+      return { min, max };
     }
-  }
-  *[Symbol.iterator]() {
-    for (let i = 0;i < this._size; i++) {
-      const index = (this.head + i) % this.options.maxSize;
-      yield this.buffer[index];
+    cleanupOldData() {
+      const now = Date.now();
+      if (now - this.lastCleanup < this.cleanupInterval) {
+        return;
+      }
+      this.lastCleanup = now;
+      const cutoff = now - this.options.maxAge;
+      const timeField = this.options.timeField;
+      while (this._size > 0) {
+        const oldest = this.buffer[this.head];
+        const time = oldest[timeField];
+        if (time >= cutoff) {
+          break;
+        }
+        this.head = (this.head + 1) % this.options.maxSize;
+        this._size--;
+      }
     }
-  }
-  map(fn) {
-    const result = [];
-    let i = 0;
-    for (const record of this) {
-      result.push(fn(record, i++));
+    *[Symbol.iterator]() {
+      for (let i = 0;i < this._size; i++) {
+        const index = (this.head + i) % this.options.maxSize;
+        yield this.buffer[index];
+      }
     }
-    return result;
-  }
-  filter(fn) {
-    const result = [];
-    for (const record of this) {
-      if (fn(record)) {
-        result.push(record);
+    map(fn) {
+      const result = [];
+      let i = 0;
+      for (const record of this) {
+        result.push(fn(record, i++));
       }
+      return result;
     }
-    return result;
-  }
-  reduce(fn, initial) {
-    let acc = initial;
-    for (const record of this) {
-      acc = fn(acc, record);
+    filter(fn) {
+      const result = [];
+      for (const record of this) {
+        if (fn(record)) {
+          result.push(record);
+        }
+      }
+      return result;
     }
-    return acc;
-  }
-}
-function createDataBuffer(options) {
-  return new DataBuffer(options);
-}
+    reduce(fn, initial) {
+      let acc = initial;
+      for (const record of this) {
+        acc = fn(acc, record);
+      }
+      return acc;
+    }
+  };
+});
 
 // src/streaming/data-window.ts
 class DataWindow {
@@ -6757,6 +7355,9 @@ class DataWindow {
 function createDataWindow(options) {
   return new DataWindow(options);
 }
+var init_data_window = __esm(() => {
+  init_data_buffer();
+});
 
 // src/streaming/rolling-aggregator.ts
 class RollingAggregator {
@@ -7217,6 +7818,19 @@ function createTimeSeriesPlot(options) {
     labels: { title: options.title ?? "Time Series" }
   });
 }
+var init_streaming_plot = __esm(() => {
+  init_grammar();
+  init_data_buffer();
+  init_data_window();
+});
+
+// src/streaming/index.ts
+var init_streaming = __esm(() => {
+  init_streaming_plot();
+  init_data_window();
+  init_data_buffer();
+});
+
 // src/performance/sampling.ts
 class SeededRandom {
   seed;
@@ -7382,14 +7996,8 @@ function autoSample(data, targetSize, options = {}) {
   }
   return systematicSample(data, targetSize);
 }
+
 // src/performance/level-of-detail.ts
-var DEFAULT_LOD_LEVELS = [
-  { name: "full", maxPoints: 500, threshold: 0 },
-  { name: "medium", maxPoints: 1000, threshold: 1000, samplingMethod: "lttb" },
-  { name: "low", maxPoints: 500, threshold: 5000, samplingMethod: "lttb" },
-  { name: "veryLow", maxPoints: 200, threshold: 20000, samplingMethod: "systematic" },
-  { name: "minimal", maxPoints: 100, threshold: 1e5, samplingMethod: "binned", binResolution: 50 }
-];
 function binData(data, resolution, xField, yField) {
   if (data.length === 0)
     return [];
@@ -7487,252 +8095,72 @@ class LevelOfDetail {
     switch (method) {
       case "lttb":
         return lttbSample(data, level.maxPoints, this.options.xField, this.options.yField);
-      case "binned":
-        return binData(data, level.binResolution || 50, this.options.xField, this.options.yField);
-      case "systematic":
-      default:
-        return systematicSample(data, level.maxPoints);
-    }
-  }
-  updateRenderTime(renderMs) {
-    this.lastRenderMs = renderMs;
-    if (renderMs > this.options.targetRenderMs * 1.5) {
-      this.adaptiveMaxPoints = Math.max(50, Math.floor(this.adaptiveMaxPoints * 0.8));
-    } else if (renderMs < this.options.targetRenderMs * 0.5) {
-      this.adaptiveMaxPoints = Math.min(this.currentLevel.maxPoints * 2, Math.floor(this.adaptiveMaxPoints * 1.2));
-    }
-  }
-  getCurrentLevel() {
-    return this.currentLevel;
-  }
-  getLevels() {
-    return [...this.options.levels];
-  }
-  setLevel(name) {
-    const level = this.options.levels.find((l) => l.name === name);
-    if (level) {
-      this.currentLevel = level;
-      this.adaptiveMaxPoints = level.maxPoints;
-      return true;
-    }
-    return false;
-  }
-  getStats() {
-    return {
-      currentLevel: this.currentLevel.name,
-      maxPoints: this.currentLevel.maxPoints,
-      adaptiveMaxPoints: this.adaptiveMaxPoints,
-      lastRenderMs: this.lastRenderMs,
-      targetRenderMs: this.options.targetRenderMs
-    };
-  }
-  processAdaptive(data) {
-    if (data.length <= this.adaptiveMaxPoints) {
-      return data;
-    }
-    return lttbSample(data, this.adaptiveMaxPoints, this.options.xField, this.options.yField);
-  }
-}
-function createLOD(options = {}) {
-  return new LevelOfDetail({
-    levels: options.levels ?? DEFAULT_LOD_LEVELS,
-    xField: options.xField,
-    yField: options.yField,
-    autoSelect: options.autoSelect,
-    targetRenderMs: options.targetRenderMs
-  });
-}
-// src/performance/binning.ts
-function computeDomain2(data, field) {
-  let min = Infinity;
-  let max = -Infinity;
-  for (const d of data) {
-    const v = d[field];
-    if (typeof v === "number" && !isNaN(v)) {
-      if (v < min)
-        min = v;
-      if (v > max)
-        max = v;
-    }
-  }
-  if (min === Infinity)
-    return [0, 1];
-  if (min === max)
-    return [min - 0.5, max + 0.5];
-  return [min, max];
-}
-function aggregateValues(values, method) {
-  if (values.length === 0)
-    return 0;
-  switch (method) {
-    case "count":
-      return values.length;
-    case "sum":
-      return values.reduce((a, b) => a + b, 0);
-    case "mean":
-      return values.reduce((a, b) => a + b, 0) / values.length;
-    case "median":
-      const sorted = [...values].sort((a, b) => a - b);
-      const mid = Math.floor(sorted.length / 2);
-      return sorted.length % 2 === 0 ? (sorted[mid - 1] + sorted[mid]) / 2 : sorted[mid];
-    case "min":
-      return Math.min(...values);
-    case "max":
-      return Math.max(...values);
-    default:
-      return values.length;
-  }
-}
-function rectbin(data, options) {
-  const {
-    xField,
-    yField,
-    xBins = 20,
-    yBins = 20,
-    aggregate = "count",
-    valueField
-  } = options;
-  if (data.length === 0)
-    return [];
-  const xDomain = options.xDomain ?? computeDomain2(data, xField);
-  const yDomain = options.yDomain ?? computeDomain2(data, yField);
-  const xRange = xDomain[1] - xDomain[0];
-  const yRange = yDomain[1] - yDomain[0];
-  const binWidth = xRange / xBins;
-  const binHeight = yRange / yBins;
-  const bins = new Map;
-  for (const point of data) {
-    const x = point[xField];
-    const y = point[yField];
-    if (typeof x !== "number" || typeof y !== "number")
-      continue;
-    const bx = Math.min(xBins - 1, Math.max(0, Math.floor((x - xDomain[0]) / binWidth)));
-    const by = Math.min(yBins - 1, Math.max(0, Math.floor((y - yDomain[0]) / binHeight)));
-    const key = `${bx},${by}`;
-    if (!bins.has(key)) {
-      bins.set(key, { points: [], values: [] });
-    }
-    const bin = bins.get(key);
-    bin.points.push(point);
-    if (valueField && typeof point[valueField] === "number") {
-      bin.values.push(point[valueField]);
-    }
-  }
-  const result = [];
-  for (const [key, bin] of bins) {
-    const [bx, by] = key.split(",").map(Number);
-    const centerX = xDomain[0] + (bx + 0.5) * binWidth;
-    const centerY = yDomain[0] + (by + 0.5) * binHeight;
-    result.push({
-      x: centerX,
-      y: centerY,
-      count: bin.points.length,
-      value: aggregateValues(bin.values.length > 0 ? bin.values : [bin.points.length], aggregate),
-      width: binWidth,
-      height: binHeight,
-      points: bin.points
-    });
-  }
-  return result;
-}
-function hexbin(data, options) {
-  const { xField, yField, aggregate = "count", valueField, radius = 10 } = options;
-  if (data.length === 0)
-    return [];
-  const xDomain = options.xDomain ?? computeDomain2(data, xField);
-  const yDomain = options.yDomain ?? computeDomain2(data, yField);
-  const hexWidth = radius * 2;
-  const hexHeight = radius * Math.sqrt(3);
-  const bins = new Map;
-  for (const point of data) {
-    const x = point[xField];
-    const y = point[yField];
-    if (typeof x !== "number" || typeof y !== "number")
-      continue;
-    const col = Math.round((x - xDomain[0]) / (hexWidth * 0.75));
-    const row = Math.round((y - yDomain[0]) / hexHeight - col % 2 * 0.5);
-    const key = `${col},${row}`;
-    if (!bins.has(key)) {
-      bins.set(key, { points: [], values: [], col, row });
-    }
-    const bin = bins.get(key);
-    bin.points.push(point);
-    if (valueField && typeof point[valueField] === "number") {
-      bin.values.push(point[valueField]);
+      case "binned":
+        return binData(data, level.binResolution || 50, this.options.xField, this.options.yField);
+      case "systematic":
+      default:
+        return systematicSample(data, level.maxPoints);
     }
   }
-  function hexVertices(cx, cy, r) {
-    const vertices = [];
-    for (let i = 0;i < 6; i++) {
-      const angle = Math.PI / 3 * i + Math.PI / 6;
-      vertices.push({
-        x: cx + r * Math.cos(angle),
-        y: cy + r * Math.sin(angle)
-      });
+  updateRenderTime(renderMs) {
+    this.lastRenderMs = renderMs;
+    if (renderMs > this.options.targetRenderMs * 1.5) {
+      this.adaptiveMaxPoints = Math.max(50, Math.floor(this.adaptiveMaxPoints * 0.8));
+    } else if (renderMs < this.options.targetRenderMs * 0.5) {
+      this.adaptiveMaxPoints = Math.min(this.currentLevel.maxPoints * 2, Math.floor(this.adaptiveMaxPoints * 1.2));
     }
-    return vertices;
   }
-  const result = [];
-  for (const [, bin] of bins) {
-    const centerX = xDomain[0] + bin.col * hexWidth * 0.75;
-    const centerY = yDomain[0] + (bin.row + bin.col % 2 * 0.5) * hexHeight;
-    result.push({
-      x: centerX,
-      y: centerY,
-      count: bin.points.length,
-      value: aggregateValues(bin.values.length > 0 ? bin.values : [bin.points.length], aggregate),
-      width: hexWidth,
-      height: hexHeight,
-      points: bin.points,
-      vertices: hexVertices(centerX, centerY, radius),
-      col: bin.col,
-      row: bin.row
-    });
+  getCurrentLevel() {
+    return this.currentLevel;
   }
-  return result;
-}
-
-class Binner {
-  options;
-  type;
-  hexRadius;
-  constructor(options) {
-    this.options = options;
-    this.type = options.type ?? "rect";
-    this.hexRadius = options.hexRadius ?? 10;
+  getLevels() {
+    return [...this.options.levels];
   }
-  bin(data) {
-    if (this.type === "hex") {
-      return hexbin(data, { ...this.options, radius: this.hexRadius });
+  setLevel(name) {
+    const level = this.options.levels.find((l) => l.name === name);
+    if (level) {
+      this.currentLevel = level;
+      this.adaptiveMaxPoints = level.maxPoints;
+      return true;
     }
-    return rectbin(data, this.options);
+    return false;
   }
-  toPlotData(data) {
-    const bins = this.bin(data);
-    const maxCount = Math.max(...bins.map((b) => b.count));
-    const minSize = 1;
-    const maxSize = 5;
-    return bins.map((bin) => ({
-      x: bin.x,
-      y: bin.y,
-      count: bin.count,
-      value: bin.value,
-      size: minSize + bin.count / maxCount * (maxSize - minSize)
-    }));
+  getStats() {
+    return {
+      currentLevel: this.currentLevel.name,
+      maxPoints: this.currentLevel.maxPoints,
+      adaptiveMaxPoints: this.adaptiveMaxPoints,
+      lastRenderMs: this.lastRenderMs,
+      targetRenderMs: this.options.targetRenderMs
+    };
   }
-  getDensityColors(bins, colorScale) {
-    const maxCount = Math.max(...bins.map((b) => b.count));
-    const colors = new Map;
-    for (const bin of bins) {
-      const t = bin.count / maxCount;
-      colors.set(bin, colorScale(t));
+  processAdaptive(data) {
+    if (data.length <= this.adaptiveMaxPoints) {
+      return data;
     }
-    return colors;
+    return lttbSample(data, this.adaptiveMaxPoints, this.options.xField, this.options.yField);
   }
 }
-function createBinner(options) {
-  return new Binner(options);
+function createLOD(options = {}) {
+  return new LevelOfDetail({
+    levels: options.levels ?? DEFAULT_LOD_LEVELS,
+    xField: options.xField,
+    yField: options.yField,
+    autoSelect: options.autoSelect,
+    targetRenderMs: options.targetRenderMs
+  });
 }
+var DEFAULT_LOD_LEVELS;
+var init_level_of_detail = __esm(() => {
+  DEFAULT_LOD_LEVELS = [
+    { name: "full", maxPoints: 500, threshold: 0 },
+    { name: "medium", maxPoints: 1000, threshold: 1000, samplingMethod: "lttb" },
+    { name: "low", maxPoints: 500, threshold: 5000, samplingMethod: "lttb" },
+    { name: "veryLow", maxPoints: 200, threshold: 20000, samplingMethod: "systematic" },
+    { name: "minimal", maxPoints: 100, threshold: 1e5, samplingMethod: "binned", binResolution: 50 }
+  ];
+});
+
 // src/performance/canvas-diff.ts
 function colorsEqual(a, b, tolerance = 0) {
   if (tolerance === 0) {
@@ -7913,8 +8341,15 @@ function quickDiff(oldCanvas, newCanvas) {
   }
   return false;
 }
+
+// src/performance/index.ts
+var init_performance = __esm(() => {
+  init_level_of_detail();
+});
+
 // src/repl/repl.ts
 import * as readline from "readline";
+
 class GGTermREPL {
   rl = null;
   state;
@@ -8549,25 +8984,18 @@ function startREPL(options) {
   repl.start();
   return repl;
 }
+var init_repl = __esm(() => {
+  init_grammar();
+  init_geoms();
+  init_scales2();
+});
+
+// src/repl/index.ts
+var init_repl2 = __esm(() => {
+  init_repl();
+});
+
 // src/export/vega-lite.ts
-var GEOM_TO_MARK = {
-  point: "point",
-  line: "line",
-  bar: "bar",
-  area: "area",
-  boxplot: "boxplot",
-  rect: "rect",
-  text: "text",
-  rule: "rule",
-  histogram: "bar",
-  freqpoly: "line",
-  violin: "area",
-  step: "line",
-  path: "line",
-  segment: "rule",
-  smooth: "line",
-  errorbar: "errorbar"
-};
 function inferFieldType(data, field) {
   const values = data.map((d) => d[field]).filter((v) => v != null);
   if (values.length === 0)
@@ -8587,11 +9015,12 @@ function inferFieldType(data, field) {
 }
 function buildEncoding(aes, data, geom) {
   const encoding = {};
+  const isHeatmap = geom.type === "tile" || geom.type === "raster";
   if (aes.x) {
     const xType = inferFieldType(data, aes.x);
     encoding.x = {
       field: aes.x,
-      type: xType,
+      type: isHeatmap && xType === "quantitative" ? "ordinal" : xType,
       ...xType === "temporal" ? { timeUnit: "yearmonthdate" } : {}
     };
   }
@@ -8602,18 +9031,25 @@ function buildEncoding(aes, data, geom) {
       const yType = inferFieldType(data, aes.y);
       encoding.y = {
         field: aes.y,
-        type: yType
+        type: isHeatmap && yType === "quantitative" ? "ordinal" : yType
       };
     }
   }
-  if (aes.color) {
+  if (isHeatmap && aes.fill) {
+    const fillType = inferFieldType(data, aes.fill);
+    encoding.color = {
+      field: aes.fill,
+      type: fillType === "nominal" ? "quantitative" : fillType,
+      scale: { scheme: "viridis" }
+    };
+  } else if (aes.color) {
     const colorType = inferFieldType(data, aes.color);
     encoding.color = {
       field: aes.color,
       type: colorType
     };
   }
-  if (aes.fill && !aes.color) {
+  if (aes.fill && !aes.color && !isHeatmap) {
     const fillType = inferFieldType(data, aes.fill);
     encoding.color = {
       field: aes.fill,
@@ -8646,16 +9082,39 @@ function buildMark(geom) {
       markProps.color = geom.params.color;
     if (geom.params.fill)
       markProps.fill = geom.params.fill;
+    if (geom.params.linetype === "dashed")
+      markProps.strokeDash = [4, 4];
+    if (geom.params.linetype === "dotted")
+      markProps.strokeDash = [2, 2];
   }
   if (geom.type === "step") {
     markProps.interpolate = "step-after";
   }
-  if (geom.type === "smooth") {
+  if (geom.type === "smooth" || geom.type === "curve") {
     markProps.interpolate = "monotone";
   }
   if (geom.type === "histogram") {
     markProps.type = "bar";
   }
+  if (geom.type === "tile" || geom.type === "raster" || geom.type === "density_2d") {
+    markProps.type = "rect";
+    markProps.tooltip = true;
+  }
+  if (geom.type === "contour") {
+    markProps.type = "line";
+    markProps.strokeWidth = 1;
+  }
+  if (geom.type === "contour_filled") {
+    markProps.type = "area";
+    markProps.opacity = 0.7;
+  }
+  if (geom.type === "qq") {
+    markProps.type = "point";
+  }
+  if (geom.type === "qq_line") {
+    markProps.type = "line";
+    markProps.strokeDash = [4, 4];
+  }
   if (Object.keys(markProps).length === 1) {
     return markType;
   }
@@ -8705,6 +9164,184 @@ function buildBoxplotSpec(data, aes) {
     }
   };
 }
+function buildHLineSpec(geom, _data) {
+  const yintercept = geom.params?.yintercept;
+  if (yintercept !== undefined) {
+    return {
+      mark: { type: "rule", strokeDash: geom.params?.linetype === "dashed" ? [4, 4] : undefined },
+      encoding: {
+        y: { datum: yintercept },
+        ...geom.params?.color ? { color: { value: geom.params.color } } : {}
+      }
+    };
+  }
+  return {
+    mark: "rule",
+    encoding: {
+      y: { field: "y", type: "quantitative" }
+    }
+  };
+}
+function buildVLineSpec(geom, _data) {
+  const xintercept = geom.params?.xintercept;
+  if (xintercept !== undefined) {
+    return {
+      mark: { type: "rule", strokeDash: geom.params?.linetype === "dashed" ? [4, 4] : undefined },
+      encoding: {
+        x: { datum: xintercept },
+        ...geom.params?.color ? { color: { value: geom.params.color } } : {}
+      }
+    };
+  }
+  return {
+    mark: "rule",
+    encoding: {
+      x: { field: "x", type: "quantitative" }
+    }
+  };
+}
+function buildAblineSpec(geom, data, aes) {
+  const slope = geom.params?.slope ?? 1;
+  const intercept = geom.params?.intercept ?? 0;
+  const xValues = data.map((d) => Number(d[aes.x])).filter((x) => !isNaN(x));
+  const xMin = Math.min(...xValues);
+  const xMax = Math.max(...xValues);
+  const yMin = slope * xMin + intercept;
+  const yMax = slope * xMax + intercept;
+  return {
+    data: {
+      values: [
+        { x: xMin, y: yMin },
+        { x: xMax, y: yMax }
+      ]
+    },
+    mark: { type: "line", strokeDash: geom.params?.linetype === "dashed" ? [4, 4] : undefined },
+    encoding: {
+      x: { field: "x", type: "quantitative" },
+      y: { field: "y", type: "quantitative" },
+      ...geom.params?.color ? { color: { value: geom.params.color } } : {}
+    }
+  };
+}
+function buildLinerangeSpec(data, aes) {
+  return {
+    mark: "rule",
+    encoding: {
+      x: { field: aes.x, type: inferFieldType(data, aes.x) },
+      y: { field: aes.ymin || "ymin", type: "quantitative" },
+      y2: { field: aes.ymax || "ymax" },
+      ...aes.color ? { color: { field: aes.color, type: inferFieldType(data, aes.color) } } : {}
+    }
+  };
+}
+function buildPointrangeSpec(data, aes) {
+  const colorEncoding = aes.color ? { color: { field: aes.color, type: inferFieldType(data, aes.color) } } : {};
+  return [
+    {
+      mark: "rule",
+      encoding: {
+        x: { field: aes.x, type: inferFieldType(data, aes.x) },
+        y: { field: aes.ymin || "ymin", type: "quantitative" },
+        y2: { field: aes.ymax || "ymax" },
+        ...colorEncoding
+      }
+    },
+    {
+      mark: { type: "point", filled: true },
+      encoding: {
+        x: { field: aes.x, type: inferFieldType(data, aes.x) },
+        y: { field: aes.y, type: "quantitative" },
+        ...colorEncoding
+      }
+    }
+  ];
+}
+function buildCrossbarSpec(data, aes) {
+  const colorEncoding = aes.color ? { color: { field: aes.color, type: inferFieldType(data, aes.color) } } : {};
+  return [
+    {
+      mark: { type: "bar", width: 20 },
+      encoding: {
+        x: { field: aes.x, type: inferFieldType(data, aes.x) },
+        y: { field: aes.ymin || "ymin", type: "quantitative" },
+        y2: { field: aes.ymax || "ymax" },
+        ...colorEncoding
+      }
+    },
+    {
+      mark: { type: "tick", thickness: 2 },
+      encoding: {
+        x: { field: aes.x, type: inferFieldType(data, aes.x) },
+        y: { field: aes.y, type: "quantitative" },
+        color: { value: "black" }
+      }
+    }
+  ];
+}
+function buildErrorbarhSpec(data, aes) {
+  return {
+    mark: "rule",
+    encoding: {
+      y: { field: aes.y, type: inferFieldType(data, aes.y) },
+      x: { field: aes.xmin || "xmin", type: "quantitative" },
+      x2: { field: aes.xmax || "xmax" },
+      ...aes.color ? { color: { field: aes.color, type: inferFieldType(data, aes.color) } } : {}
+    }
+  };
+}
+function buildRibbonSpec(data, aes) {
+  return {
+    mark: { type: "area", opacity: 0.3 },
+    encoding: {
+      x: { field: aes.x, type: inferFieldType(data, aes.x) },
+      y: { field: aes.ymin || "ymin", type: "quantitative" },
+      y2: { field: aes.ymax || "ymax" },
+      ...aes.color ? { color: { field: aes.color, type: inferFieldType(data, aes.color) } } : {},
+      ...aes.fill ? { fill: { field: aes.fill, type: inferFieldType(data, aes.fill) } } : {}
+    }
+  };
+}
+function buildRugSpec(data, aes, geom) {
+  const sides = geom.params?.sides || "b";
+  const encoding = {};
+  if (sides.includes("b") || sides.includes("t")) {
+    encoding.x = { field: aes.x, type: inferFieldType(data, aes.x) };
+  }
+  if (sides.includes("l") || sides.includes("r")) {
+    encoding.y = { field: aes.y, type: inferFieldType(data, aes.y) };
+  }
+  if (Object.keys(encoding).length === 0) {
+    encoding.x = { field: aes.x, type: inferFieldType(data, aes.x) };
+  }
+  return {
+    mark: { type: "tick", thickness: 1 },
+    encoding
+  };
+}
+function buildBin2dSpec(_data, aes, geom) {
+  const binX = geom.params?.binwidth_x || geom.params?.bins || 10;
+  const binY = geom.params?.binwidth_y || geom.params?.bins || 10;
+  return {
+    mark: "rect",
+    encoding: {
+      x: {
+        field: aes.x,
+        bin: { maxbins: binX },
+        type: "quantitative"
+      },
+      y: {
+        field: aes.y,
+        bin: { maxbins: binY },
+        type: "quantitative"
+      },
+      color: {
+        aggregate: "count",
+        type: "quantitative",
+        scale: { scheme: "viridis" }
+      }
+    }
+  };
+}
 function getPublicationConfig() {
   return {
     font: "Arial",
@@ -8808,40 +9445,107 @@ function plotSpecToVegaLite(spec, options = {}) {
       vlSpec.title = spec.labels.title;
     }
   }
-  if (spec.geoms.length > 1) {
-    vlSpec.layer = spec.geoms.map((geom) => {
-      if (geom.type === "histogram" || geom.stat === "bin") {
-        const histSpec = buildHistogramSpec(spec.data, spec.aes, geom);
-        return {
-          mark: histSpec.mark,
-          encoding: histSpec.encoding
-        };
-      }
-      if (geom.type === "boxplot") {
-        const boxSpec = buildBoxplotSpec(spec.data, spec.aes);
-        return {
-          mark: boxSpec.mark,
-          encoding: boxSpec.encoding
-        };
-      }
+  function buildGeomLayer(geom) {
+    const data = spec.data;
+    if (geom.type === "histogram" || geom.stat === "bin") {
+      const histSpec = buildHistogramSpec(data, spec.aes, geom);
       return {
-        mark: buildMark(geom),
-        encoding: buildEncoding(spec.aes, spec.data, geom)
+        mark: histSpec.mark,
+        encoding: histSpec.encoding
       };
-    });
+    }
+    if (geom.type === "boxplot") {
+      const boxSpec = buildBoxplotSpec(data, spec.aes);
+      return {
+        mark: boxSpec.mark,
+        encoding: boxSpec.encoding
+      };
+    }
+    if (geom.type === "hline") {
+      const hlineSpec = buildHLineSpec(geom, data);
+      return {
+        mark: hlineSpec.mark,
+        encoding: hlineSpec.encoding
+      };
+    }
+    if (geom.type === "vline") {
+      const vlineSpec = buildVLineSpec(geom, data);
+      return {
+        mark: vlineSpec.mark,
+        encoding: vlineSpec.encoding
+      };
+    }
+    if (geom.type === "abline") {
+      const ablineSpec = buildAblineSpec(geom, data, spec.aes);
+      return {
+        mark: ablineSpec.mark,
+        encoding: ablineSpec.encoding
+      };
+    }
+    if (geom.type === "linerange") {
+      const linerangeSpec = buildLinerangeSpec(data, spec.aes);
+      return {
+        mark: linerangeSpec.mark,
+        encoding: linerangeSpec.encoding
+      };
+    }
+    if (geom.type === "pointrange") {
+      return buildPointrangeSpec(data, spec.aes);
+    }
+    if (geom.type === "crossbar") {
+      return buildCrossbarSpec(data, spec.aes);
+    }
+    if (geom.type === "errorbarh") {
+      const errorhSpec = buildErrorbarhSpec(data, spec.aes);
+      return {
+        mark: errorhSpec.mark,
+        encoding: errorhSpec.encoding
+      };
+    }
+    if (geom.type === "ribbon") {
+      const ribbonSpec = buildRibbonSpec(data, spec.aes);
+      return {
+        mark: ribbonSpec.mark,
+        encoding: ribbonSpec.encoding
+      };
+    }
+    if (geom.type === "rug") {
+      const rugSpec = buildRugSpec(data, spec.aes, geom);
+      return {
+        mark: rugSpec.mark,
+        encoding: rugSpec.encoding
+      };
+    }
+    if (geom.type === "bin2d") {
+      const bin2dSpec = buildBin2dSpec(data, spec.aes, geom);
+      return {
+        mark: bin2dSpec.mark,
+        encoding: bin2dSpec.encoding
+      };
+    }
+    return {
+      mark: buildMark(geom),
+      encoding: buildEncoding(spec.aes, data, geom)
+    };
+  }
+  if (spec.geoms.length > 1) {
+    vlSpec.layer = [];
+    for (const geom of spec.geoms) {
+      const layerResult = buildGeomLayer(geom);
+      if (Array.isArray(layerResult)) {
+        vlSpec.layer.push(...layerResult);
+      } else {
+        vlSpec.layer.push(layerResult);
+      }
+    }
   } else if (spec.geoms.length === 1) {
     const geom = spec.geoms[0];
-    if (geom.type === "histogram" || geom.stat === "bin") {
-      const histSpec = buildHistogramSpec(spec.data, spec.aes, geom);
-      vlSpec.mark = histSpec.mark;
-      vlSpec.encoding = histSpec.encoding;
-    } else if (geom.type === "boxplot") {
-      const boxSpec = buildBoxplotSpec(spec.data, spec.aes);
-      vlSpec.mark = boxSpec.mark;
-      vlSpec.encoding = boxSpec.encoding;
+    const layerResult = buildGeomLayer(geom);
+    if (Array.isArray(layerResult)) {
+      vlSpec.layer = layerResult;
     } else {
-      vlSpec.mark = buildMark(geom);
-      vlSpec.encoding = buildEncoding(spec.aes, spec.data, geom);
+      vlSpec.mark = layerResult.mark;
+      vlSpec.encoding = layerResult.encoding;
     }
   } else {
     vlSpec.mark = "point";
@@ -8938,6 +9642,306 @@ function exportToVegaLiteJSON(spec, options = {}) {
   const vlSpec = plotSpecToVegaLite(spec, options);
   return JSON.stringify(vlSpec, null, 2);
 }
+var GEOM_TO_MARK;
+var init_vega_lite = __esm(() => {
+  GEOM_TO_MARK = {
+    point: "point",
+    line: "line",
+    bar: "bar",
+    col: "bar",
+    area: "area",
+    rect: "rect",
+    text: "text",
+    label: "text",
+    rule: "rule",
+    boxplot: "boxplot",
+    histogram: "bar",
+    freqpoly: "line",
+    violin: "area",
+    tile: "rect",
+    raster: "rect",
+    bin2d: "rect",
+    density_2d: "rect",
+    contour: "line",
+    contour_filled: "area",
+    step: "line",
+    path: "line",
+    smooth: "line",
+    curve: "line",
+    segment: "rule",
+    linerange: "rule",
+    pointrange: "rule",
+    errorbar: "errorbar",
+    errorbarh: "rule",
+    crossbar: "rule",
+    ribbon: "area",
+    hline: "rule",
+    vline: "rule",
+    abline: "line",
+    qq: "point",
+    qq_line: "line",
+    rug: "tick"
+  };
+});
+
+// src/export/index.ts
+var exports_export = {};
+__export(exports_export, {
+  plotSpecToVegaLite: () => plotSpecToVegaLite,
+  exportToVegaLiteJSON: () => exportToVegaLiteJSON
+});
+var init_export = __esm(() => {
+  init_vega_lite();
+});
+
+// src/index.ts
+var exports_src = {};
+__export(exports_src, {
+  themeVoid: () => themeVoid,
+  themeMinimal: () => themeMinimal,
+  themeDark: () => themeDark,
+  themeClassic: () => themeClassic,
+  systematicSample: () => systematicSample,
+  stratifiedSample: () => stratifiedSample,
+  stat_summary: () => stat_summary,
+  stat_smooth: () => stat_smooth,
+  stat_qq_line: () => stat_qq_line,
+  stat_qq: () => stat_qq,
+  stat_density: () => stat_density,
+  stat_boxplot: () => stat_boxplot,
+  stat_bin2d: () => stat_bin2d,
+  stat_bin: () => stat_bin,
+  startREPL: () => startREPL,
+  selectRenderer: () => selectRenderer,
+  selectColorMode: () => selectColorMode,
+  scale_y_time: () => scale_y_time,
+  scale_y_sqrt: () => scale_y_sqrt,
+  scale_y_reverse: () => scale_y_reverse,
+  scale_y_log10: () => scale_y_log10,
+  scale_y_duration: () => scale_y_duration,
+  scale_y_discrete: () => scale_y_discrete,
+  scale_y_datetime: () => scale_y_datetime,
+  scale_y_date: () => scale_y_date,
+  scale_y_continuous: () => scale_y_continuous,
+  scale_y2_sqrt: () => scale_y2_sqrt,
+  scale_y2_reverse: () => scale_y2_reverse,
+  scale_y2_log10: () => scale_y2_log10,
+  scale_y2_continuous: () => scale_y2_continuous,
+  scale_x_time: () => scale_x_time,
+  scale_x_sqrt: () => scale_x_sqrt,
+  scale_x_reverse: () => scale_x_reverse,
+  scale_x_log10: () => scale_x_log10,
+  scale_x_duration: () => scale_x_duration,
+  scale_x_discrete: () => scale_x_discrete,
+  scale_x_datetime: () => scale_x_datetime,
+  scale_x_date: () => scale_x_date,
+  scale_x_continuous: () => scale_x_continuous,
+  scale_size_radius: () => scale_size_radius,
+  scale_size_identity: () => scale_size_identity,
+  scale_size_continuous: () => scale_size_continuous,
+  scale_size_binned: () => scale_size_binned,
+  scale_size_area: () => scale_size_area,
+  scale_shape_ordinal: () => scale_shape_ordinal,
+  scale_shape_manual: () => scale_shape_manual,
+  scale_shape_identity: () => scale_shape_identity,
+  scale_shape_discrete: () => scale_shape_discrete,
+  scale_fill_viridis: () => scale_fill_viridis,
+  scale_fill_manual: () => scale_fill_manual,
+  scale_fill_gradientn: () => scale_fill_gradientn,
+  scale_fill_gradient2: () => scale_fill_gradient2,
+  scale_fill_gradient: () => scale_fill_gradient,
+  scale_fill_distiller: () => scale_fill_distiller,
+  scale_fill_discrete: () => scale_fill_discrete,
+  scale_fill_continuous: () => scale_fill_continuous,
+  scale_fill_brewer: () => scale_fill_brewer,
+  scale_color_viridis: () => scale_color_viridis,
+  scale_color_manual: () => scale_color_manual,
+  scale_color_gradientn: () => scale_color_gradientn,
+  scale_color_gradient2: () => scale_color_gradient2,
+  scale_color_gradient: () => scale_color_gradient,
+  scale_color_distiller: () => scale_color_distiller,
+  scale_color_discrete: () => scale_color_discrete,
+  scale_color_continuous: () => scale_color_continuous,
+  scale_color_brewer: () => scale_color_brewer,
+  scale_alpha_manual: () => scale_alpha_manual,
+  scale_alpha_identity: () => scale_alpha_identity,
+  scale_alpha_discrete: () => scale_alpha_discrete,
+  scale_alpha_continuous: () => scale_alpha_continuous,
+  scale_alpha_binned: () => scale_alpha_binned,
+  scale_alpha: () => scale_alpha,
+  rgbToAnsi256: () => rgbToAnsi256,
+  rgbToAnsi16: () => rgbToAnsi16,
+  reservoirSample: () => reservoirSample,
+  renderToString: () => renderToString,
+  renderToCanvas: () => renderToCanvas,
+  rectbin: () => rectbin,
+  randomSample: () => randomSample,
+  quickDiff: () => quickDiff,
+  querySixelSupport: () => querySixelSupport,
+  quantizeColor: () => quantizeColor,
+  position_stack: () => position_stack,
+  position_jitter: () => position_jitter,
+  position_identity: () => position_identity,
+  position_fill: () => position_fill,
+  position_dodge: () => position_dodge,
+  plotSpecToVegaLite: () => plotSpecToVegaLite,
+  lttbSample: () => lttbSample,
+  label_wrap: () => label_wrap,
+  label_value: () => label_value,
+  label_parsed: () => label_parsed,
+  label_both: () => label_both,
+  isStackPosition: () => isStackPosition,
+  isRendererAvailable: () => isRendererAvailable,
+  isDodgePosition: () => isDodgePosition,
+  isCI: () => isCI,
+  inferDiscreteDomain: () => inferDiscreteDomain,
+  inferContinuousDomain: () => inferContinuousDomain,
+  hexbin: () => hexbin,
+  gg: () => gg,
+  getTerminalName: () => getTerminalName,
+  getTerminalInfo: () => getTerminalInfo,
+  getRecommendedRenderer: () => getRecommendedRenderer,
+  getPositionType: () => getPositionType,
+  getPaletteColors: () => getPaletteColors,
+  getPalette256: () => getPalette256,
+  getColorEscape: () => getColorEscape,
+  getCapabilities: () => getCapabilities,
+  getAvailablePalettes: () => getAvailablePalettes,
+  geom_vline: () => geom_vline,
+  geom_violin: () => geom_violin,
+  geom_tile: () => geom_tile,
+  geom_text: () => geom_text,
+  geom_step: () => geom_step,
+  geom_smooth: () => geom_smooth,
+  geom_segment: () => geom_segment,
+  geom_rug: () => geom_rug,
+  geom_ribbon: () => geom_ribbon,
+  geom_rect: () => geom_rect,
+  geom_raster: () => geom_raster,
+  geom_qq_line: () => geom_qq_line,
+  geom_qq: () => geom_qq,
+  geom_pointrange: () => geom_pointrange,
+  geom_point: () => geom_point,
+  geom_path: () => geom_path,
+  geom_linerange: () => geom_linerange,
+  geom_line: () => geom_line,
+  geom_label: () => geom_label,
+  geom_hline: () => geom_hline,
+  geom_histogram: () => geom_histogram,
+  geom_freqpoly: () => geom_freqpoly,
+  geom_errorbarh: () => geom_errorbarh,
+  geom_errorbar: () => geom_errorbar,
+  geom_density_2d: () => geom_density_2d,
+  geom_curve: () => geom_curve,
+  geom_crossbar: () => geom_crossbar,
+  geom_contour_filled: () => geom_contour_filled,
+  geom_contour: () => geom_contour,
+  geom_col: () => geom_col,
+  geom_boxplot: () => geom_boxplot,
+  geom_bin2d: () => geom_bin2d,
+  geom_bar: () => geom_bar,
+  geom_area: () => geom_area,
+  geom_abline: () => geom_abline,
+  generate256Palette: () => generate256Palette,
+  formatDateTime: () => formatDateTime,
+  findClosestPaletteColor: () => findClosestPaletteColor,
+  fgEscape: () => fgEscape,
+  facet_wrap: () => facet_wrap,
+  facet_grid: () => facet_grid,
+  exportToVegaLiteJSON: () => exportToVegaLiteJSON,
+  ditherPixels: () => ditherPixels,
+  detectUnicodeSupport: () => detectUnicodeSupport,
+  detectTerminalSize: () => detectTerminalSize,
+  detectGraphicsProtocol: () => detectGraphicsProtocol,
+  detectColorCapability: () => detectColorCapability,
+  detectCapabilities: () => detectCapabilities,
+  defaultTheme: () => defaultTheme,
+  createTimeSeriesPlot: () => createTimeSeriesPlot,
+  createStreamingPlot: () => createStreamingPlot,
+  createSampler: () => createSampler,
+  createRollingAggregator: () => createRollingAggregator,
+  createRendererChain: () => createRendererChain,
+  createOptimizedPalette: () => createOptimizedPalette,
+  createMultiAggregator: () => createMultiAggregator,
+  createLOD: () => createLOD,
+  createDataWindow: () => createDataWindow,
+  createDataBuffer: () => createDataBuffer,
+  createCanvasDiff: () => createCanvasDiff,
+  createCanvas: () => createCanvas,
+  createBinner: () => createBinner,
+  coordTrans: () => coordTrans,
+  coordPolar: () => coordPolar,
+  coordFlipWithLimits: () => coordFlipWithLimits,
+  coordFlip: () => coordFlip,
+  coordFixed: () => coordFixed,
+  coordEqual: () => coordEqual,
+  coordCartesian: () => coordCartesian,
+  computeSummary: () => computeSummary,
+  computeSmooth: () => computeSmooth,
+  computeQQLine: () => computeQQLine,
+  computeQQ: () => computeQQ,
+  computeFacetPanels: () => computeFacetPanels,
+  computeDensity: () => computeDensity,
+  computeBoxplotStats: () => computeBoxplotStats,
+  computeBins2d: () => computeBins2d,
+  computeBins: () => computeBins,
+  colorDistance: () => colorDistance,
+  clearCapabilityCache: () => clearCapabilityCache,
+  calculatePanelLayouts: () => calculatePanelLayouts,
+  calculateLayout: () => calculateLayout,
+  calculateGridStripLayout: () => calculateGridStripLayout,
+  calculateDateTimeTicks: () => calculateDateTimeTicks,
+  buildScaleContext: () => buildScaleContext,
+  bgEscape: () => bgEscape,
+  autoSample: () => autoSample,
+  autoRenderer: () => autoRenderer,
+  as_labeller: () => as_labeller,
+  applyPositionAdjustment: () => applyPositionAdjustment,
+  annotate_vline: () => annotate_vline,
+  annotate_text: () => annotate_text,
+  annotate_segment: () => annotate_segment,
+  annotate_rect: () => annotate_rect,
+  annotate_label: () => annotate_label,
+  annotate_hline: () => annotate_hline,
+  annotate: () => annotate,
+  TerminalCanvas: () => TerminalCanvas,
+  StreamingPlot: () => StreamingPlot,
+  SHAPE_CHARS: () => SHAPE_CHARS,
+  RollingAggregator: () => RollingAggregator,
+  RendererChain: () => RendererChain,
+  RESET_FG: () => RESET_FG,
+  RESET_BG: () => RESET_BG,
+  RESET: () => RESET,
+  LevelOfDetail: () => LevelOfDetail,
+  GGTermREPL: () => GGTermREPL,
+  GGPlot: () => GGPlot,
+  ExponentialMovingAverage: () => ExponentialMovingAverage,
+  DataWindow: () => DataWindow,
+  DataSampler: () => DataSampler,
+  DataBuffer: () => DataBuffer,
+  DEFAULT_SHAPES: () => DEFAULT_SHAPES,
+  DEFAULT_LOD_LEVELS: () => DEFAULT_LOD_LEVELS,
+  DEFAULT_FG: () => DEFAULT_FG,
+  DEFAULT_BG: () => DEFAULT_BG,
+  CanvasDiff: () => CanvasDiff,
+  Binner: () => Binner,
+  ANSI_16_COLORS: () => ANSI_16_COLORS
+});
+var init_src = __esm(() => {
+  init_grammar();
+  init_canvas2();
+  init_pipeline2();
+  init_geoms();
+  init_stats();
+  init_scales2();
+  init_terminal();
+  init_streaming();
+  init_performance();
+  init_repl2();
+  init_export();
+});
+init_src();
+
 export {
   themeVoid,
   themeMinimal,
@@ -8951,6 +9955,7 @@ export {
   stat_qq,
   stat_density,
   stat_boxplot,
+  stat_bin2d,
   stat_bin,
   startREPL,
   selectRenderer,
@@ -9079,6 +10084,7 @@ export {
   geom_contour,
   geom_col,
   geom_boxplot,
+  geom_bin2d,
   geom_bar,
   geom_area,
   geom_abline,
@@ -9123,6 +10129,7 @@ export {
   computeFacetPanels,
   computeDensity,
   computeBoxplotStats,
+  computeBins2d,
   computeBins,
   colorDistance,
   clearCapabilityCache,