@ggterm/core 0.2.5 → 0.2.9

package/dist/cli.js

@@ -30,426 +30,74 @@ 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) {
-  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;
-      }
-    }
-  }
-  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/repl/repl.ts
-import * as readline from "readline";
-
-// src/themes/default.ts
-function defaultTheme() {
+function themeDark() {
   return {
     panel: {
-      background: "",
-      border: "single",
+      background: "#1e1e1e",
+      border: "rounded",
       grid: { major: "·", minor: null }
     },
     axis: {
-      text: { color: "" },
+      text: { color: "#ccc" },
       ticks: { char: "┼", length: 1 },
-      title: { color: "", bold: false }
+      title: { color: "#fff", bold: true }
     },
     legend: {
       position: "right",
@@ -461,51 +109,23 @@ function defaultTheme() {
     },
     facet: {
       strip: {
-        text: "#c8c8c8",
-        background: ""
+        text: "#ffffff",
+        background: "#333333"
       }
     }
   };
 }
-function themeMinimal() {
+function themeClassic() {
   return {
     panel: {
       background: "",
-      border: "none",
+      border: "single",
       grid: { major: null, minor: null }
     },
     axis: {
       text: { color: "" },
-      ticks: { char: "│", length: 1 },
-      title: { color: "", bold: false }
-    },
-    legend: {
-      position: "right",
-      title: { bold: false }
-    },
-    title: {
-      align: "left",
-      bold: false
-    },
-    facet: {
-      strip: {
-        text: "#999999",
-        background: ""
-      }
-    }
-  };
-}
-function themeDark() {
-  return {
-    panel: {
-      background: "#1e1e1e",
-      border: "rounded",
-      grid: { major: "·", minor: null }
-    },
-    axis: {
-      text: { color: "#ccc" },
-      ticks: { char: "┼", length: 1 },
-      title: { color: "#fff", bold: true }
+      ticks: { char: "─", length: 1 },
+      title: { color: "", bold: true }
     },
     legend: {
       position: "right",
@@ -517,304 +137,705 @@ function themeDark() {
     },
     facet: {
       strip: {
-        text: "#ffffff",
-        background: "#333333"
+        text: "#c8c8c8",
+        background: ""
       }
     }
   };
 }
-function themeClassic() {
+function themeVoid() {
   return {
     panel: {
       background: "",
-      border: "single",
+      border: "none",
       grid: { major: null, minor: null }
     },
     axis: {
       text: { color: "" },
-      ticks: { char: "─", length: 1 },
-      title: { color: "", bold: true }
+      ticks: { char: "", length: 0 },
+      title: { color: "", bold: false }
     },
     legend: {
-      position: "right",
-      title: { bold: true }
+      position: "none",
+      title: { bold: false }
     },
     title: {
-      align: "center",
-      bold: true
+      align: "left",
+      bold: false
     },
     facet: {
       strip: {
-        text: "#c8c8c8",
+        text: "#888888",
         background: ""
       }
     }
-  };
+  };
+}
+
+// src/coords/cartesian.ts
+function coordCartesian(options = {}) {
+  return {
+    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 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 themeVoid() {
-  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 }
-    },
-    title: {
-      align: "left",
-      bold: false
-    },
-    facet: {
-      strip: {
-        text: "#888888",
-        background: ""
+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++;
       }
     }
-  };
-}
-
-// src/coords/cartesian.ts
-function coordCartesian(options = {}) {
-  return {
-    type: "cartesian",
-    xlim: options.xlim,
-    ylim: options.ylim,
-    clip: options.clip ?? true,
-    transform(x, y) {
-      return { x, y };
+    index++;
+  }
+  let result;
+  if (limits) {
+    if (drop) {
+      result = limits.filter((v) => seen.has(v));
+    } else {
+      result = [...limits];
     }
-  };
-}
-function coordFlip() {
-  return {
-    type: "flip",
-    transform(x, y) {
-      return { x: y, y: x };
+  } 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 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 expandDomain(domain, expand = 0.05) {
+  const range = domain[1] - domain[0];
+  const padding = range * expand;
+  return [domain[0] - padding, domain[1] + padding];
 }
-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 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 coordEqual(options = {}) {
-  return coordFixed({ ...options, ratio: 1 });
+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 getTransform(type) {
-  switch (type) {
+function getTransformFunctions(trans = "identity") {
+  switch (trans) {
     case "log10":
-      return (v) => v > 0 ? Math.log10(v) : -Infinity;
+      return {
+        type: "log10",
+        transform: (v) => v > 0 ? Math.log10(v) : -Infinity,
+        invert: (v) => Math.pow(10, v)
+      };
     case "sqrt":
-      return (v) => v >= 0 ? Math.sqrt(v) : 0;
+      return {
+        type: "sqrt",
+        transform: (v) => v >= 0 ? Math.sqrt(v) : 0,
+        invert: (v) => v * v
+      };
     case "reverse":
-      return (v) => -v;
+      return {
+        type: "reverse",
+        transform: (v) => -v,
+        invert: (v) => -v
+      };
     default:
-      return (v) => v;
+      return {
+        type: "identity",
+        transform: (v) => v,
+        invert: (v) => v
+      };
   }
 }
-function coordTrans(options = {}) {
-  const xTrans = getTransform(options.x ?? "identity");
-  const yTrans = getTransform(options.y ?? "identity");
+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 {
-    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)
-      };
+    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);
+    },
+    toCanvas(normalized) {
+      return rangeMin + normalized * rangeSpan;
+    },
+    map(value) {
+      return this.toCanvas(this.normalize(value));
+    }
+  };
+}
+function createResolvedDiscreteScale(aesthetic, domain, range) {
+  const [rangeMin, rangeMax] = range;
+  const rangeSpan = rangeMax - rangeMin;
+  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;
+    },
+    toCanvas(normalized) {
+      return rangeMin + normalized * rangeSpan;
+    },
+    map(value) {
+      return this.toCanvas(this.normalize(value));
     }
   };
 }
-function coordFlipWithLimits(options = {}) {
+function interpolateColor(color1, color2, t) {
   return {
-    type: "flip",
-    xlim: options.xlim,
-    ylim: options.ylim,
-    clip: options.clip ?? true,
-    transform(x, y) {
-      return { x: y, y: x };
+    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) {
+  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];
     }
   };
 }
-
-// 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 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 {
-    char: " ",
-    fg: { ...DEFAULT_FG },
-    bg: { ...DEFAULT_BG }
+    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);
+    }
   };
 }
-
-class TerminalCanvas {
-  width;
-  height;
-  cells;
-  constructor(width, height) {
-    this.width = width;
-    this.height = height;
-    this.cells = [];
-    this.clear();
-  }
-  setCell(x, y, cell) {
-    if (x < 0 || x >= this.width || y < 0 || y >= this.height) {
-      return;
+function isCategoricalField(data, field) {
+  for (const row of data) {
+    const value = row[field];
+    if (value !== null && value !== undefined) {
+      if (typeof value === "string") {
+        return true;
+      }
     }
-    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();
+  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);
     }
-    return this.cells[Math.floor(y)][Math.floor(x)];
+  };
+}
+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)];
   }
-  clear() {
-    this.cells = [];
-    for (let y = 0;y < this.height; y++) {
-      const row = [];
-      for (let x = 0;x < this.width; x++) {
-        row.push(createEmptyCell());
+  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;
       }
-      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 xDomain = inferDiscreteDomain(data, aes.x, xOrderOptions);
+    x = createResolvedDiscreteScale("x", xDomain, [plotArea.x, plotArea.x + plotArea.width - 1]);
+    if (userXScale?.labels) {
+      x.labels = userXScale.labels;
     }
-  }
-  drawHLine(x, y, length, char = "─", fg) {
-    for (let i = 0;i < length; i++) {
-      this.drawChar(x + i, y, char, fg);
+  } 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;
     }
-  }
-  drawVLine(x, y, length, char = "│", fg) {
-    for (let i = 0;i < length; i++) {
-      this.drawChar(x, y + i, char, fg);
+    if (userXScale?.labels) {
+      x.labels = userXScale.labels;
     }
   }
-  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 });
+  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;
       }
     }
+    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;
+    }
+  } 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;
+    }
+    if (userYScale?.labels) {
+      y.labels = userYScale.labels;
+    }
   }
-  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(`
-`);
+  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;
   }
-  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 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 };
         }
-      }
-      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() {
@@ -1016,22 +1037,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;
@@ -1044,6 +1049,44 @@ function getPointColor(row, aes, colorScale) {
   }
   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);
   const positionType = getPositionType(geom.position);
@@ -1442,7 +1485,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);
@@ -1452,7 +1495,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);
@@ -1769,20 +1812,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 (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];
+      }
     }
-    if (yVals.length > 1) {
-      tileHeight = 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];
@@ -1792,8 +1867,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);
@@ -1981,7 +2054,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]));
@@ -2173,6 +2246,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":
@@ -2202,6 +2276,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) {
@@ -2509,7 +2603,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;
@@ -2637,6 +2730,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 = {}) {
@@ -2748,6 +2845,248 @@ function stat_bin(params = {}) {
   };
 }
 
+// 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;
+  }
+}
+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 results;
+}
+function stat_bin2d(params = {}) {
+  return {
+    type: "bin2d",
+    compute(data, aes) {
+      const bins = computeBins2d(data, aes.x, aes.y, params);
+      return bins.map((bin) => ({
+        x: bin.x,
+        y: bin.y,
+        count: bin.count,
+        density: bin.density,
+        fill: bin.count,
+        width: bin.width,
+        height: bin.height
+      }));
+    }
+  };
+}
+var init_bin2d = () => {};
+
 // src/stats/boxplot.ts
 function quantile(sorted, p) {
   if (sorted.length === 0)
@@ -3163,17 +3502,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)
@@ -3305,6 +3633,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) {
@@ -3487,15 +3829,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;
 }
@@ -3688,6 +4140,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) {
@@ -3800,6 +4257,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;
 }
@@ -3864,6 +4338,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);
@@ -3898,6 +4380,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);
     }
@@ -4148,8 +4634,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) {
@@ -4197,9 +4689,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 {
@@ -4290,6 +4795,9 @@ class GGPlot {
 function gg(data = []) {
   return new GGPlot(data);
 }
+var init_grammar = __esm(() => {
+  init_pipeline2();
+});
 
 // src/geoms/point.ts
 function geom_point(options = {}) {
@@ -4305,6 +4813,7 @@ function geom_point(options = {}) {
     }
   };
 }
+
 // src/geoms/line.ts
 function geom_line(options = {}) {
   return {
@@ -4343,6 +4852,7 @@ function geom_vline(options) {
     }
   };
 }
+
 // src/geoms/path.ts
 function geom_path(options = {}) {
   return {
@@ -4359,6 +4869,7 @@ function geom_path(options = {}) {
     }
   };
 }
+
 // src/geoms/bar.ts
 function geom_bar(options = {}) {
   return {
@@ -4376,6 +4887,7 @@ function geom_bar(options = {}) {
 function geom_col(options = {}) {
   return geom_bar({ ...options, stat: "identity" });
 }
+
 // src/geoms/text.ts
 function geom_text(options = {}) {
   return {
@@ -4408,6 +4920,7 @@ function geom_label(options = {}) {
     }
   };
 }
+
 // src/geoms/area.ts
 function geom_area(options = {}) {
   return {
@@ -4433,6 +4946,7 @@ function geom_ribbon(options = {}) {
     }
   };
 }
+
 // src/geoms/histogram.ts
 function geom_histogram(options = {}) {
   return {
@@ -4464,6 +4978,7 @@ function geom_freqpoly(options = {}) {
     }
   };
 }
+
 // src/geoms/boxplot.ts
 function geom_boxplot(options = {}) {
   return {
@@ -4480,6 +4995,7 @@ function geom_boxplot(options = {}) {
     }
   };
 }
+
 // src/geoms/segment.ts
 function geom_segment(options = {}) {
   return {
@@ -4512,6 +5028,7 @@ function geom_curve(options = {}) {
     }
   };
 }
+
 // src/geoms/smooth.ts
 function geom_smooth(options = {}) {
   return {
@@ -4531,6 +5048,7 @@ function geom_smooth(options = {}) {
     }
   };
 }
+
 // src/geoms/step.ts
 function geom_step(options = {}) {
   return {
@@ -4546,6 +5064,7 @@ function geom_step(options = {}) {
     }
   };
 }
+
 // src/geoms/rug.ts
 function geom_rug(options = {}) {
   return {
@@ -4561,6 +5080,7 @@ function geom_rug(options = {}) {
     }
   };
 }
+
 // src/geoms/violin.ts
 function geom_violin(options = {}) {
   return {
@@ -4578,6 +5098,7 @@ function geom_violin(options = {}) {
     }
   };
 }
+
 // src/geoms/tile.ts
 function geom_tile(options = {}) {
   return {
@@ -4596,6 +5117,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 {
@@ -4638,6 +5175,7 @@ function geom_density_2d(options = {}) {
     }
   };
 }
+
 // src/geoms/errorbar.ts
 function geom_errorbar(options = {}) {
   return {
@@ -4704,6 +5242,7 @@ function geom_pointrange(options = {}) {
     }
   };
 }
+
 // src/geoms/rect.ts
 function geom_rect(options = {}) {
   return {
@@ -4732,6 +5271,7 @@ function geom_abline(options = {}) {
     }
   };
 }
+
 // src/geoms/qq.ts
 function geom_qq(options = {}) {
   return {
@@ -4760,6 +5300,10 @@ function geom_qq_line(options = {}) {
     }
   };
 }
+
+// src/geoms/index.ts
+var init_geoms = () => {};
+
 // src/scales/continuous.ts
 function createContinuousScale(aesthetic, options = {}) {
   const trans = options.trans ?? "identity";
@@ -4838,6 +5382,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;
@@ -4887,123 +5432,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)
@@ -5224,6 +5654,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];
@@ -5292,45 +5842,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 {
@@ -5389,6 +5902,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];
@@ -5485,17 +6040,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;
@@ -5677,7 +6223,30 @@ 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/repl/repl.ts
+import * as readline from "readline";
+
 class GGTermREPL {
   rl = null;
   state;
@@ -6312,7 +6881,19 @@ 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/cli.ts
+init_repl2();
 import * as fs from "fs";
 import * as path from "path";
 var VERSION = "0.0.1";