@ggterm/core 0.2.11 → 0.2.15

package/dist/index.js

@@ -1564,6 +1564,82 @@ function renderGeomFreqpoly(data, _geom, aes, scales, canvas) {
     }
   }
 }
+function renderGeomDensity(data, geom, aes, scales, canvas) {
+  if (data.length < 2)
+    return;
+  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]));
+  const plotBottom = Math.round(Math.max(scales.y.range[0], scales.y.range[1]));
+  const groups = new Map;
+  const groupField = aes.group || aes.color || aes.fill;
+  if (groupField) {
+    for (const row of data) {
+      const key = String(row[groupField] ?? "default");
+      if (!groups.has(key))
+        groups.set(key, []);
+      groups.get(key).push(row);
+    }
+  } else {
+    groups.set("default", data);
+  }
+  let baseline = Math.round(scales.y.map(0));
+  baseline = Math.max(plotTop, Math.min(plotBottom, baseline));
+  const alpha = geom.params.alpha ?? 0.3;
+  const fillChar = "░";
+  for (const [groupKey, groupData] of groups) {
+    if (groupData.length < 2)
+      continue;
+    const sorted = [...groupData].sort((a, b) => {
+      const ax = Number(a.x) || 0;
+      const bx = Number(b.x) || 0;
+      return ax - bx;
+    });
+    let baseColor = scales.color?.map(groupKey) ?? DEFAULT_POINT_COLOR;
+    const fillColor = {
+      r: Math.round(baseColor.r * alpha),
+      g: Math.round(baseColor.g * alpha),
+      b: Math.round(baseColor.b * alpha),
+      a: baseColor.a
+    };
+    for (let i = 0;i < sorted.length - 1; i++) {
+      const row1 = sorted[i];
+      const row2 = sorted[i + 1];
+      const density1 = Number(row1.y ?? row1.density) || 0;
+      const density2 = Number(row2.y ?? row2.density) || 0;
+      const x1 = Math.round(scales.x.map(row1.x));
+      const y1 = Math.round(scales.y.map(density1));
+      const x2 = Math.round(scales.x.map(row2.x));
+      const y2 = Math.round(scales.y.map(density2));
+      for (let x = x1;x <= x2; x++) {
+        if (x < plotLeft || x > plotRight)
+          continue;
+        const t = x2 !== x1 ? (x - x1) / (x2 - x1) : 0;
+        const yInterp = Math.round(y1 + (y2 - y1) * t);
+        const top = Math.min(yInterp, baseline);
+        const bottom = Math.max(yInterp, baseline);
+        for (let y = top;y <= bottom; y++) {
+          if (y >= plotTop && y <= plotBottom) {
+            canvas.drawChar(x, y, fillChar, fillColor);
+          }
+        }
+      }
+    }
+    for (let i = 0;i < sorted.length - 1; i++) {
+      const row1 = sorted[i];
+      const row2 = sorted[i + 1];
+      const density1 = Number(row1.y ?? row1.density) || 0;
+      const density2 = Number(row2.y ?? row2.density) || 0;
+      const x1 = Math.round(scales.x.map(row1.x));
+      const y1 = Math.round(scales.y.map(density1));
+      const x2 = Math.round(scales.x.map(row2.x));
+      const y2 = Math.round(scales.y.map(density2));
+      if (x1 >= plotLeft && x1 <= plotRight && x2 >= plotLeft && x2 <= plotRight && y1 >= plotTop && y1 <= plotBottom && y2 >= plotTop && y2 <= plotBottom) {
+        drawLine(canvas, x1, y1, x2, y2, baseColor);
+      }
+    }
+  }
+}
 function renderGeomBoxplot(data, geom, _aes, scales, canvas) {
   const widthFactor = geom.params.width ?? 0.75;
   let boxWidth;
@@ -2208,6 +2284,78 @@ function renderGeomLinerange(data, geom, aes, scales, canvas) {
     }
   }
 }
+function renderGeomCrossbar(data, geom, aes, scales, canvas) {
+  const width = geom.params.width ?? 0.5;
+  const fatten = geom.params.fatten ?? 2.5;
+  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]));
+  const plotBottom = Math.round(Math.max(scales.y.range[0], scales.y.range[1]));
+  const halfWidth = Math.max(2, Math.round(width * 4));
+  for (const row of data) {
+    const xVal = row[aes.x];
+    const yVal = row[aes.y];
+    const ymin = row["ymin"];
+    const ymax = row["ymax"];
+    if (xVal === null || xVal === undefined || ymin === undefined || ymax === undefined) {
+      continue;
+    }
+    const cx = Math.round(scales.x.map(xVal));
+    const cy = yVal !== null && yVal !== undefined ? Math.round(scales.y.map(yVal)) : null;
+    const cyMin = Math.round(scales.y.map(ymin));
+    const cyMax = Math.round(scales.y.map(ymax));
+    const color = getPointColor(row, aes, scales.color);
+    const top = Math.min(cyMin, cyMax);
+    const bottom = Math.max(cyMin, cyMax);
+    const left = cx - halfWidth;
+    const right = cx + halfWidth;
+    for (let y = top;y <= bottom; y++) {
+      if (y >= plotTop && y <= plotBottom) {
+        if (left >= plotLeft && left <= plotRight) {
+          canvas.drawChar(left, y, "│", color);
+        }
+        if (right >= plotLeft && right <= plotRight) {
+          canvas.drawChar(right, y, "│", color);
+        }
+      }
+    }
+    for (let x = left;x <= right; x++) {
+      if (x >= plotLeft && x <= plotRight) {
+        if (top >= plotTop && top <= plotBottom) {
+          canvas.drawChar(x, top, "─", color);
+        }
+        if (bottom >= plotTop && bottom <= plotBottom) {
+          canvas.drawChar(x, bottom, "─", color);
+        }
+      }
+    }
+    if (left >= plotLeft && left <= plotRight) {
+      if (top >= plotTop && top <= plotBottom)
+        canvas.drawChar(left, top, "┌", color);
+      if (bottom >= plotTop && bottom <= plotBottom)
+        canvas.drawChar(left, bottom, "└", color);
+    }
+    if (right >= plotLeft && right <= plotRight) {
+      if (top >= plotTop && top <= plotBottom)
+        canvas.drawChar(right, top, "┐", color);
+      if (bottom >= plotTop && bottom <= plotBottom)
+        canvas.drawChar(right, bottom, "┘", color);
+    }
+    if (cy !== null && cy >= plotTop && cy <= plotBottom) {
+      const fattenLines = Math.max(1, Math.round(fatten / 2));
+      for (let dy = -fattenLines + 1;dy < fattenLines; dy++) {
+        const lineY = cy + dy;
+        if (lineY >= plotTop && lineY <= plotBottom && lineY >= top && lineY <= bottom) {
+          for (let x = left + 1;x < right; x++) {
+            if (x >= plotLeft && x <= plotRight) {
+              canvas.drawChar(x, lineY, "━", color);
+            }
+          }
+        }
+      }
+    }
+  }
+}
 function renderGeomPointrange(data, geom, aes, scales, canvas) {
   renderGeomLinerange(data, geom, aes, scales, canvas);
   const plotLeft = Math.round(scales.x.range[0]);
@@ -2287,78 +2435,1205 @@ function renderGeomSmooth(data, geom, _aes, scales, canvas) {
     drawLine(canvas, x1, y1, x2, y2, baseColor);
   }
 }
-function parseColor(color) {
-  if (color.startsWith("#")) {
-    const hex = color.slice(1);
-    if (hex.length === 3) {
+function parseColor(color) {
+  if (color.startsWith("#")) {
+    const hex = color.slice(1);
+    if (hex.length === 3) {
+      return {
+        r: parseInt(hex[0] + hex[0], 16),
+        g: parseInt(hex[1] + hex[1], 16),
+        b: parseInt(hex[2] + hex[2], 16),
+        a: 1
+      };
+    } else if (hex.length === 6) {
+      return {
+        r: parseInt(hex.slice(0, 2), 16),
+        g: parseInt(hex.slice(2, 4), 16),
+        b: parseInt(hex.slice(4, 6), 16),
+        a: 1
+      };
+    }
+  }
+  return { r: 128, g: 128, b: 128, a: 1 };
+}
+function renderGeomBeeswarm(data, geom, aes, scales, canvas) {
+  const alpha = geom.params.alpha ?? 1;
+  const fixedColor = geom.params.color;
+  const shape = getPointShape(geom.params.shape);
+  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]));
+  const plotBottom = Math.round(Math.max(scales.y.range[0], scales.y.range[1]));
+  const defaultColors = [
+    { r: 79, g: 169, b: 238, a: 1 },
+    { r: 238, g: 136, b: 102, a: 1 },
+    { r: 102, g: 204, b: 153, a: 1 },
+    { r: 204, g: 102, b: 204, a: 1 },
+    { r: 255, g: 200, b: 87, a: 1 },
+    { r: 138, g: 201, b: 222, a: 1 },
+    { r: 255, g: 153, b: 153, a: 1 },
+    { r: 170, g: 170, b: 170, a: 1 }
+  ];
+  const categories = new Set;
+  for (const row of data) {
+    categories.add(String(row.xOriginal ?? row[aes.x] ?? "default"));
+  }
+  const categoryList = [...categories];
+  for (const row of data) {
+    const xVal = row.x;
+    const yVal = row.y;
+    if (xVal === null || xVal === undefined || yVal === null || yVal === undefined) {
+      continue;
+    }
+    const numGroups = categoryList.length;
+    const xRange = plotRight - plotLeft;
+    const xNormalized = (Number(xVal) + 0.5) / numGroups;
+    const cx = Math.round(plotLeft + xNormalized * xRange);
+    const cy = Math.round(scales.y.map(yVal));
+    let color;
+    if (fixedColor) {
+      color = parseColorToRgba(fixedColor);
+    } else if (scales.color && aes.color) {
+      color = getPointColor(row, aes, scales.color);
+    } else {
+      const category = String(row.xOriginal ?? row[aes.x] ?? "default");
+      const categoryIdx = categoryList.indexOf(category);
+      color = defaultColors[categoryIdx % defaultColors.length];
+    }
+    if (alpha < 1) {
+      color = { ...color, a: alpha };
+    }
+    if (cx >= plotLeft && cx <= plotRight && cy >= plotTop && cy <= plotBottom) {
+      canvas.drawChar(cx, cy, shape, color);
+    }
+  }
+}
+function renderGeomDumbbell(data, geom, aes, scales, canvas) {
+  const lineColor = parseColorToRgba(geom.params.lineColor ?? "#666666");
+  const alpha = geom.params.alpha ?? 1;
+  const shape = getPointShape(geom.params.shape);
+  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]));
+  const plotBottom = Math.round(Math.max(scales.y.range[0], scales.y.range[1]));
+  const defaultColors = [
+    { r: 79, g: 169, b: 238, a: 1 },
+    { r: 238, g: 136, b: 102, a: 1 },
+    { r: 102, g: 204, b: 153, a: 1 },
+    { r: 204, g: 102, b: 204, a: 1 }
+  ];
+  for (let i = 0;i < data.length; i++) {
+    const row = data[i];
+    const xVal = row[aes.x];
+    const xendVal = row["xend"] ?? row[aes.x];
+    const yVal = row[aes.y];
+    if (xVal === null || xVal === undefined || yVal === null || yVal === undefined) {
+      continue;
+    }
+    const x1 = Math.round(scales.x.map(xVal));
+    const x2 = Math.round(scales.x.map(xendVal));
+    const cy = Math.round(scales.y.map(yVal));
+    let startColor;
+    let endColor;
+    if (geom.params.color) {
+      startColor = parseColorToRgba(geom.params.color);
+    } else if (scales.color && aes.color) {
+      startColor = getPointColor(row, aes, scales.color);
+    } else {
+      startColor = defaultColors[0];
+    }
+    if (geom.params.colorEnd) {
+      endColor = parseColorToRgba(geom.params.colorEnd);
+    } else {
+      endColor = geom.params.color ? startColor : defaultColors[1];
+    }
+    if (alpha < 1) {
+      startColor = { ...startColor, a: alpha };
+      endColor = { ...endColor, a: alpha };
+    }
+    if (cy >= plotTop && cy <= plotBottom) {
+      const left = Math.max(plotLeft, Math.min(x1, x2));
+      const right = Math.min(plotRight, Math.max(x1, x2));
+      for (let x = left;x <= right; x++) {
+        canvas.drawChar(x, cy, "─", lineColor);
+      }
+    }
+    if (x1 >= plotLeft && x1 <= plotRight && cy >= plotTop && cy <= plotBottom) {
+      canvas.drawChar(x1, cy, shape, startColor);
+    }
+    if (x2 >= plotLeft && x2 <= plotRight && cy >= plotTop && cy <= plotBottom) {
+      canvas.drawChar(x2, cy, shape, endColor);
+    }
+  }
+}
+function renderGeomLollipop(data, geom, aes, scales, canvas) {
+  const alpha = geom.params.alpha ?? 1;
+  const baseline = geom.params.baseline ?? 0;
+  const direction = geom.params.direction ?? "vertical";
+  const shape = getPointShape(geom.params.shape);
+  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]));
+  const plotBottom = Math.round(Math.max(scales.y.range[0], scales.y.range[1]));
+  const defaultColors = [
+    { r: 79, g: 169, b: 238, a: 1 },
+    { r: 238, g: 136, b: 102, a: 1 },
+    { r: 102, g: 204, b: 153, a: 1 },
+    { r: 204, g: 102, b: 204, a: 1 },
+    { r: 255, g: 200, b: 87, a: 1 },
+    { r: 138, g: 201, b: 222, a: 1 }
+  ];
+  const xValues = [...new Set(data.map((row) => row[aes.x]))];
+  for (let i = 0;i < data.length; i++) {
+    const row = data[i];
+    const xVal = row[aes.x];
+    const yVal = row[aes.y];
+    if (xVal === null || xVal === undefined || yVal === null || yVal === undefined) {
+      continue;
+    }
+    const cx = Math.round(scales.x.map(xVal));
+    const cy = Math.round(scales.y.map(yVal));
+    let color;
+    if (geom.params.color) {
+      color = parseColorToRgba(geom.params.color);
+    } else if (scales.color && aes.color) {
+      color = getPointColor(row, aes, scales.color);
+    } else {
+      const categoryIdx = xValues.indexOf(xVal);
+      color = defaultColors[categoryIdx % defaultColors.length];
+    }
+    let lineColor;
+    if (geom.params.lineColor) {
+      lineColor = parseColorToRgba(geom.params.lineColor);
+    } else {
+      lineColor = {
+        r: Math.round(color.r * 0.7),
+        g: Math.round(color.g * 0.7),
+        b: Math.round(color.b * 0.7),
+        a: color.a
+      };
+    }
+    if (alpha < 1) {
+      color = { ...color, a: alpha };
+      lineColor = { ...lineColor, a: alpha };
+    }
+    if (direction === "vertical") {
+      let baselineY = Math.round(scales.y.map(baseline));
+      baselineY = Math.max(plotTop, Math.min(plotBottom, baselineY));
+      if (cx >= plotLeft && cx <= plotRight) {
+        const top = Math.min(cy, baselineY);
+        const bottom = Math.max(cy, baselineY);
+        for (let y = top;y <= bottom; y++) {
+          if (y >= plotTop && y <= plotBottom) {
+            canvas.drawChar(cx, y, "│", lineColor);
+          }
+        }
+      }
+      if (cx >= plotLeft && cx <= plotRight && cy >= plotTop && cy <= plotBottom) {
+        canvas.drawChar(cx, cy, shape, color);
+      }
+    } else {
+      let baselineX = Math.round(scales.x.map(baseline));
+      baselineX = Math.max(plotLeft, Math.min(plotRight, baselineX));
+      if (cy >= plotTop && cy <= plotBottom) {
+        const left = Math.min(cx, baselineX);
+        const right = Math.max(cx, baselineX);
+        for (let x = left;x <= right; x++) {
+          if (x >= plotLeft && x <= plotRight) {
+            canvas.drawChar(x, cy, "─", lineColor);
+          }
+        }
+      }
+      if (cx >= plotLeft && cx <= plotRight && cy >= plotTop && cy <= plotBottom) {
+        canvas.drawChar(cx, cy, shape, color);
+      }
+    }
+  }
+}
+function renderGeomWaffle(data, geom, aes, scales, canvas) {
+  const rows = geom.params.rows ?? 10;
+  const cols = geom.params.cols ?? 10;
+  const fillChar = geom.params.fill_char ?? "█";
+  const emptyChar = geom.params.empty_char ?? "░";
+  const showLegend = geom.params.show_legend ?? true;
+  const flip = geom.params.flip ?? false;
+  const gap = geom.params.gap ?? 0;
+  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]));
+  const plotBottom = Math.round(Math.max(scales.y.range[0], scales.y.range[1]));
+  const defaultColors = [
+    { r: 79, g: 169, b: 238, a: 1 },
+    { r: 238, g: 136, b: 102, a: 1 },
+    { r: 102, g: 204, b: 153, a: 1 },
+    { r: 204, g: 102, b: 204, a: 1 },
+    { r: 255, g: 200, b: 87, a: 1 },
+    { r: 138, g: 201, b: 222, a: 1 },
+    { r: 255, g: 153, b: 153, a: 1 },
+    { r: 170, g: 170, b: 170, a: 1 }
+  ];
+  const fillField = aes.fill || aes.color || "category";
+  const valueField = aes.y || "value";
+  const categories = new Map;
+  let totalValue = 0;
+  for (const row of data) {
+    const cat = String(row[fillField] ?? "default");
+    const val = Number(row[valueField]) || 1;
+    categories.set(cat, (categories.get(cat) ?? 0) + val);
+    totalValue += val;
+  }
+  const cellsPerCategory = [];
+  const categoryList = [...categories.keys()];
+  let cellsAssigned = 0;
+  for (let i = 0;i < categoryList.length; i++) {
+    const cat = categoryList[i];
+    const val = categories.get(cat);
+    const proportion = val / totalValue;
+    const cells = Math.round(proportion * rows * cols);
+    const color = scales.color?.map(cat) ?? defaultColors[i % defaultColors.length];
+    cellsPerCategory.push({ category: cat, cells, color });
+    cellsAssigned += cells;
+  }
+  if (cellsAssigned < rows * cols && cellsPerCategory.length > 0) {
+    cellsPerCategory[0].cells += rows * cols - cellsAssigned;
+  }
+  const grid = [];
+  for (const { cells, color } of cellsPerCategory) {
+    for (let i = 0;i < cells; i++) {
+      grid.push({ char: fillChar, color });
+    }
+  }
+  const emptyColor = { r: 80, g: 80, b: 80, a: 0.3 };
+  while (grid.length < rows * cols) {
+    grid.push({ char: emptyChar, color: emptyColor });
+  }
+  const availableWidth = plotRight - plotLeft - (showLegend ? 15 : 0);
+  const availableHeight = plotBottom - plotTop;
+  const cellWidth = Math.max(1, Math.floor(availableWidth / cols)) + gap;
+  const cellHeight = Math.max(1, Math.floor(availableHeight / rows)) + gap;
+  for (let row = 0;row < rows; row++) {
+    for (let col = 0;col < cols; col++) {
+      let idx;
+      if (flip) {
+        idx = row * cols + col;
+      } else {
+        idx = col * rows + (rows - 1 - row);
+      }
+      if (idx >= grid.length)
+        continue;
+      const cell = grid[idx];
+      const x = plotLeft + col * cellWidth;
+      const y = plotTop + row * cellHeight;
+      if (x >= plotLeft && x < plotRight - (showLegend ? 15 : 0) && y >= plotTop && y <= plotBottom) {
+        canvas.drawChar(x, y, cell.char, cell.color);
+      }
+    }
+  }
+  if (showLegend) {
+    const legendX = plotRight - 12;
+    let legendY = plotTop;
+    for (let i = 0;i < cellsPerCategory.length && legendY < plotBottom; i++) {
+      const { category, cells, color } = cellsPerCategory[i];
+      const pct = Math.round(cells / (rows * cols) * 100);
+      const label = `${category.slice(0, 6)} ${pct}%`;
+      canvas.drawChar(legendX, legendY, "█", color);
+      canvas.drawString(legendX + 2, legendY, label, { r: 180, g: 180, b: 180, a: 1 });
+      legendY += 2;
+    }
+  }
+}
+function renderGeomSparkline(data, geom, aes, scales, canvas) {
+  const sparkType = geom.params.sparkType ?? "bar";
+  const width = geom.params.width ?? 20;
+  const showMinmax = geom.params.show_minmax ?? false;
+  const normalize = geom.params.normalize ?? true;
+  const minColor = parseColorToRgba(geom.params.min_color ?? "#e74c3c");
+  const maxColor = parseColorToRgba(geom.params.max_color ?? "#2ecc71");
+  const plotLeft = Math.round(scales.x.range[0]);
+  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]));
+  const SPARK_CHARS = ["▁", "▂", "▃", "▄", "▅", "▆", "▇", "█"];
+  const defaultColor = { r: 79, g: 169, b: 238, a: 1 };
+  const groupField = aes.group || aes.color;
+  const groups = new Map;
+  if (groupField) {
+    for (const row of data) {
+      const key = String(row[groupField] ?? "default");
+      if (!groups.has(key))
+        groups.set(key, []);
+      groups.get(key).push(row);
+    }
+  } else {
+    groups.set("default", [...data]);
+  }
+  let currentY = plotTop;
+  for (const [groupKey, groupData] of groups) {
+    const sorted = aes.x ? [...groupData].sort((a, b) => Number(a[aes.x]) - Number(b[aes.x])) : groupData;
+    const values = sorted.map((row) => Number(row[aes.y]) || 0);
+    if (values.length === 0)
+      continue;
+    const minVal = Math.min(...values);
+    const maxVal = Math.max(...values);
+    const minIdx = values.indexOf(minVal);
+    const maxIdx = values.indexOf(maxVal);
+    const range = maxVal - minVal || 1;
+    const color = scales.color?.map(groupKey) ?? defaultColor;
+    const sparkValues = [];
+    if (values.length <= width) {
+      sparkValues.push(...values);
+    } else {
+      for (let i = 0;i < width; i++) {
+        const idx = Math.floor(i * values.length / width);
+        sparkValues.push(values[idx]);
+      }
+    }
+    for (let i = 0;i < sparkValues.length; i++) {
+      const val = sparkValues[i];
+      const normalized = normalize ? (val - minVal) / range : val / (maxVal || 1);
+      const charIdx = Math.min(7, Math.max(0, Math.floor(normalized * 8)));
+      const char = sparkType === "dot" ? "•" : SPARK_CHARS[charIdx];
+      const x = plotLeft + i;
+      const y = currentY;
+      let pointColor = color;
+      if (showMinmax) {
+        const origIdx = Math.floor(i * values.length / sparkValues.length);
+        if (origIdx === minIdx)
+          pointColor = minColor;
+        else if (origIdx === maxIdx)
+          pointColor = maxColor;
+      }
+      if (x < plotLeft + width && y >= plotTop && y <= plotBottom) {
+        canvas.drawChar(x, y, char, pointColor);
+      }
+    }
+    if (groupField && groups.size > 1) {
+      const labelX = plotLeft + width + 1;
+      canvas.drawString(labelX, currentY, groupKey.slice(0, 8), { r: 180, g: 180, b: 180, a: 1 });
+    }
+    currentY += 2;
+  }
+}
+function renderGeomBullet(data, geom, aes, scales, canvas) {
+  const width = geom.params.width ?? 40;
+  const targetChar = geom.params.target_char ?? "│";
+  const barChar = geom.params.bar_char ?? "█";
+  const rangeChars = geom.params.range_chars ?? ["░", "▒", "▓"];
+  const showValues = geom.params.show_values ?? true;
+  const targetColor = parseColorToRgba(geom.params.target_color ?? "#e74c3c");
+  const plotLeft = Math.round(scales.x.range[0]);
+  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]));
+  const defaultColors = [
+    { r: 79, g: 169, b: 238, a: 1 },
+    { r: 238, g: 136, b: 102, a: 1 },
+    { r: 102, g: 204, b: 153, a: 1 }
+  ];
+  const rangeColors = [
+    { r: 60, g: 60, b: 60, a: 1 },
+    { r: 90, g: 90, b: 90, a: 1 },
+    { r: 120, g: 120, b: 120, a: 1 }
+  ];
+  let currentY = plotTop;
+  for (let i = 0;i < data.length; i++) {
+    const row = data[i];
+    const label = aes.x ? String(row[aes.x]).slice(0, 10) : `Item ${i + 1}`;
+    const value = Number(row[aes.y]) || 0;
+    const target = Number(row["target"]) || null;
+    const maxValue = Number(row["max"]) || Math.max(value, target || 0) * 1.2;
+    const ranges = row["ranges"] ?? [maxValue * 0.6, maxValue * 0.8, maxValue];
+    const color = scales.color?.map(label) ?? defaultColors[i % defaultColors.length];
+    const labelWidth = 12;
+    canvas.drawString(plotLeft, currentY, label.padEnd(labelWidth), { r: 180, g: 180, b: 180, a: 1 });
+    const barStart = plotLeft + labelWidth;
+    const barWidth = Math.min(width, scales.x.range[1] - barStart - (showValues ? 8 : 0));
+    for (let r = ranges.length - 1;r >= 0; r--) {
+      const rangeWidth = Math.round(ranges[r] / maxValue * barWidth);
+      for (let x = 0;x < rangeWidth; x++) {
+        if (barStart + x <= scales.x.range[1]) {
+          canvas.drawChar(barStart + x, currentY, rangeChars[r], rangeColors[r]);
+        }
+      }
+    }
+    const valueWidth = Math.round(value / maxValue * barWidth);
+    for (let x = 0;x < valueWidth; x++) {
+      if (barStart + x <= scales.x.range[1]) {
+        canvas.drawChar(barStart + x, currentY, barChar, color);
+      }
+    }
+    if (target !== null) {
+      const targetX = barStart + Math.round(target / maxValue * barWidth);
+      if (targetX >= barStart && targetX <= barStart + barWidth) {
+        canvas.drawChar(targetX, currentY, targetChar, targetColor);
+      }
+    }
+    if (showValues) {
+      const valueStr = value.toFixed(0);
+      canvas.drawString(barStart + barWidth + 2, currentY, valueStr, { r: 180, g: 180, b: 180, a: 1 });
+    }
+    currentY += 2;
+    if (currentY > plotBottom)
+      break;
+  }
+}
+function renderGeomBraille(data, geom, aes, scales, canvas) {
+  const brailleType = geom.params.brailleType ?? "point";
+  const fill = geom.params.fill ?? false;
+  const alpha = geom.params.alpha ?? 1;
+  const BRAILLE_BASE = 10240;
+  const DOTS = [
+    [1, 2, 4, 64],
+    [8, 16, 32, 128]
+  ];
+  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]));
+  const plotBottom = Math.round(Math.max(scales.y.range[0], scales.y.range[1]));
+  const plotWidth = plotRight - plotLeft;
+  const plotHeight = plotBottom - plotTop;
+  const brailleWidth = plotWidth;
+  const brailleHeight = plotHeight;
+  const buffer = [];
+  for (let y = 0;y < brailleHeight; y++) {
+    buffer[y] = new Array(brailleWidth).fill(0);
+  }
+  const defaultColor = { r: 79, g: 169, b: 238, a: 1 };
+  const color = geom.params.color ? parseColorToRgba(geom.params.color) : defaultColor;
+  const finalColor = alpha < 1 ? { ...color, a: alpha } : color;
+  const sorted = aes.x ? [...data].sort((a, b) => Number(a[aes.x]) - Number(b[aes.x])) : data;
+  const setDot = (canvasX, canvasY) => {
+    const subX = (canvasX - plotLeft) * 2;
+    const subY = (canvasY - plotTop) * 4;
+    const cellX = Math.floor(subX / 2);
+    const cellY = Math.floor(subY / 4);
+    const dotCol = subX % 2;
+    const dotRow = subY % 4;
+    if (cellX >= 0 && cellX < brailleWidth && cellY >= 0 && cellY < brailleHeight) {
+      if (dotCol >= 0 && dotCol < 2 && dotRow >= 0 && dotRow < 4) {
+        buffer[cellY][cellX] |= DOTS[dotCol][dotRow];
+      }
+    }
+  };
+  let prevCx = null;
+  let prevCy = null;
+  for (const row of sorted) {
+    const xVal = row[aes.x];
+    const yVal = row[aes.y];
+    if (xVal === null || xVal === undefined || yVal === null || yVal === undefined) {
+      prevCx = null;
+      prevCy = null;
+      continue;
+    }
+    const cx = Math.round(scales.x.map(xVal));
+    const cy = Math.round(scales.y.map(yVal));
+    if (brailleType === "line" && prevCx !== null && prevCy !== null) {
+      const dx = Math.abs(cx - prevCx);
+      const dy = Math.abs(cy - prevCy);
+      const sx = prevCx < cx ? 1 : -1;
+      const sy = prevCy < cy ? 1 : -1;
+      let err = dx - dy;
+      let x = prevCx;
+      let y = prevCy;
+      while (true) {
+        if (x >= plotLeft && x < plotRight && y >= plotTop && y < plotBottom) {
+          setDot(x, y);
+          if (fill) {
+            for (let fy = y;fy < plotBottom; fy++) {
+              setDot(x, fy);
+            }
+          }
+        }
+        if (x === cx && y === cy)
+          break;
+        const e2 = 2 * err;
+        if (e2 > -dy) {
+          err -= dy;
+          x += sx;
+        }
+        if (e2 < dx) {
+          err += dx;
+          y += sy;
+        }
+      }
+    } else {
+      if (cx >= plotLeft && cx < plotRight && cy >= plotTop && cy < plotBottom) {
+        setDot(cx, cy);
+      }
+    }
+    prevCx = cx;
+    prevCy = cy;
+  }
+  for (let y = 0;y < brailleHeight; y++) {
+    for (let x = 0;x < brailleWidth; x++) {
+      if (buffer[y][x] > 0) {
+        const char = String.fromCharCode(BRAILLE_BASE + buffer[y][x]);
+        canvas.drawChar(plotLeft + x, plotTop + y, char, finalColor);
+      }
+    }
+  }
+}
+function renderGeomCalendar(data, geom, aes, scales, canvas) {
+  if (data.length === 0)
+    return;
+  const cellChar = geom.params.cell_char ?? "█";
+  const emptyColor = parseColorToRgba(geom.params.empty_color ?? "#161b22");
+  const fillColor = parseColorToRgba(geom.params.fill_color ?? "#39d353");
+  const levels = geom.params.levels ?? 5;
+  const showDays = geom.params.show_days ?? true;
+  const showMonths = geom.params.show_months ?? true;
+  const weekStart = geom.params.week_start ?? 0;
+  const dateField = aes.x;
+  const valueField = aes.fill || aes.y || "value";
+  const entries = [];
+  let minValue = Infinity;
+  let maxValue = -Infinity;
+  for (const row of data) {
+    const dateVal = row[dateField];
+    const val = Number(row[valueField]) || 0;
+    let date;
+    if (dateVal instanceof Date) {
+      date = dateVal;
+    } else if (typeof dateVal === "string" || typeof dateVal === "number") {
+      date = new Date(dateVal);
+    } else {
+      continue;
+    }
+    if (isNaN(date.getTime()))
+      continue;
+    entries.push({ date, value: val });
+    if (val < minValue)
+      minValue = val;
+    if (val > maxValue)
+      maxValue = val;
+  }
+  if (entries.length === 0)
+    return;
+  entries.sort((a, b) => a.date.getTime() - b.date.getTime());
+  const startDate = new Date(entries[0].date);
+  const endDate = new Date(entries[entries.length - 1].date);
+  startDate.setDate(startDate.getDate() - (startDate.getDay() - weekStart + 7) % 7);
+  const valueMap = new Map;
+  for (const entry of entries) {
+    const key = entry.date.toISOString().slice(0, 10);
+    valueMap.set(key, (valueMap.get(key) || 0) + entry.value);
+  }
+  const plotLeft = Math.round(scales.x.range[0]);
+  const plotTop = Math.round(Math.min(scales.y.range[0], scales.y.range[1]));
+  const dayLabels = ["S", "M", "T", "W", "T", "F", "S"];
+  const monthLabels = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+  const msPerDay = 24 * 60 * 60 * 1000;
+  const totalDays = Math.ceil((endDate.getTime() - startDate.getTime()) / msPerDay) + 7;
+  const numWeeks = Math.ceil(totalDays / 7);
+  const getColor = (value) => {
+    if (value === 0 || maxValue === minValue)
+      return emptyColor;
+    const t = Math.min(1, Math.max(0, (value - minValue) / (maxValue - minValue)));
+    const level = Math.floor(t * (levels - 1));
+    const levelT = level / (levels - 1);
+    return {
+      r: Math.round(emptyColor.r + (fillColor.r - emptyColor.r) * levelT),
+      g: Math.round(emptyColor.g + (fillColor.g - emptyColor.g) * levelT),
+      b: Math.round(emptyColor.b + (fillColor.b - emptyColor.b) * levelT),
+      a: 1
+    };
+  };
+  const xOffset = showDays ? 3 : 0;
+  const yOffset = showMonths ? 2 : 0;
+  if (showDays) {
+    for (let d = 0;d < 7; d++) {
+      const dayIndex = (d + weekStart) % 7;
+      const y = plotTop + yOffset + d;
+      canvas.drawChar(plotLeft, y, dayLabels[dayIndex], { r: 128, g: 128, b: 128, a: 1 });
+    }
+  }
+  let lastMonth = -1;
+  const currentDate = new Date(startDate);
+  for (let week = 0;week < numWeeks; week++) {
+    const x = plotLeft + xOffset + week * 2;
+    if (showMonths && currentDate.getMonth() !== lastMonth) {
+      const monthLabel = monthLabels[currentDate.getMonth()];
+      for (let i = 0;i < monthLabel.length; i++) {
+        canvas.drawChar(x + i, plotTop, monthLabel[i], { r: 128, g: 128, b: 128, a: 1 });
+      }
+      lastMonth = currentDate.getMonth();
+    }
+    for (let day = 0;day < 7; day++) {
+      const dayDate = new Date(currentDate);
+      dayDate.setDate(dayDate.getDate() + day);
+      if (dayDate > endDate)
+        break;
+      const key = dayDate.toISOString().slice(0, 10);
+      const value = valueMap.get(key) || 0;
+      const color = getColor(value);
+      const y = plotTop + yOffset + day;
+      canvas.drawChar(x, y, cellChar, color);
+    }
+    currentDate.setDate(currentDate.getDate() + 7);
+  }
+}
+function renderGeomFlame(data, geom, aes, scales, canvas) {
+  if (data.length === 0)
+    return;
+  const style = geom.params.style ?? "flame";
+  const palette = geom.params.palette ?? "warm";
+  const showLabels = geom.params.show_labels ?? true;
+  const minLabelWidth = geom.params.min_label_width ?? 10;
+  const barChar = geom.params.bar_char ?? "█";
+  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]));
+  const plotBottom = Math.round(Math.max(scales.y.range[0], scales.y.range[1]));
+  const plotWidth = plotRight - plotLeft;
+  const plotHeight = plotBottom - plotTop;
+  const nameField = aes.x || "name";
+  const valueField = aes.fill || "value";
+  const depthField = aes.y || "depth";
+  const startField = "start";
+  const frames = [];
+  let totalValue = 0;
+  let maxDepth = 0;
+  for (const row of data) {
+    const name = String(row[nameField] || "");
+    const value = Number(row[valueField]) || 0;
+    const depth = Number(row[depthField]) || 0;
+    const start = row[startField] !== undefined ? Number(row[startField]) : -1;
+    frames.push({ name, value, depth, start, width: 0 });
+    if (depth === 0)
+      totalValue += value;
+    if (depth > maxDepth)
+      maxDepth = depth;
+  }
+  if (totalValue === 0)
+    return;
+  for (const frame of frames) {
+    frame.width = frame.value / totalValue * plotWidth;
+  }
+  frames.sort((a, b) => {
+    if (a.depth !== b.depth)
+      return a.depth - b.depth;
+    if (a.start !== b.start)
+      return a.start - b.start;
+    return a.name.localeCompare(b.name);
+  });
+  const depthOffsets = new Array(maxDepth + 1).fill(0);
+  for (const frame of frames) {
+    if (frame.start < 0) {
+      frame.start = depthOffsets[frame.depth];
+    }
+    depthOffsets[frame.depth] = frame.start + frame.width;
+  }
+  const getPaletteColor = (name) => {
+    let hash = 0;
+    for (let i = 0;i < name.length; i++) {
+      hash = (hash << 5) - hash + name.charCodeAt(i);
+      hash = hash & hash;
+    }
+    const hue = Math.abs(hash) % 360;
+    let h;
+    if (palette === "warm") {
+      h = hue % 60 + 0;
+    } else if (palette === "cool") {
+      h = hue % 60 + 180;
+    } else {
+      h = hue % 40 + 10;
+    }
+    const s = 0.7;
+    const l = 0.5;
+    const c = (1 - Math.abs(2 * l - 1)) * s;
+    const x = c * (1 - Math.abs(h / 60 % 2 - 1));
+    const m = l - c / 2;
+    let r = 0, g = 0, b = 0;
+    if (h < 60) {
+      r = c;
+      g = x;
+      b = 0;
+    } else if (h < 120) {
+      r = x;
+      g = c;
+      b = 0;
+    } else if (h < 180) {
+      r = 0;
+      g = c;
+      b = x;
+    } else if (h < 240) {
+      r = 0;
+      g = x;
+      b = c;
+    } else if (h < 300) {
+      r = x;
+      g = 0;
+      b = c;
+    } else {
+      r = c;
+      g = 0;
+      b = x;
+    }
+    return {
+      r: Math.round((r + m) * 255),
+      g: Math.round((g + m) * 255),
+      b: Math.round((b + m) * 255),
+      a: 1
+    };
+  };
+  const rowHeight = Math.max(1, Math.floor(plotHeight / (maxDepth + 1)));
+  for (const frame of frames) {
+    const x1 = plotLeft + Math.round(frame.start);
+    const x2 = plotLeft + Math.round(frame.start + frame.width);
+    const width = x2 - x1;
+    if (width < 1)
+      continue;
+    let y;
+    if (style === "icicle") {
+      y = plotTop + frame.depth * rowHeight;
+    } else {
+      y = plotBottom - (frame.depth + 1) * rowHeight;
+    }
+    const color = getPaletteColor(frame.name);
+    for (let row = 0;row < rowHeight; row++) {
+      for (let col = x1;col < x2; col++) {
+        if (col >= plotLeft && col < plotRight && y + row >= plotTop && y + row < plotBottom) {
+          canvas.drawChar(col, y + row, barChar, color);
+        }
+      }
+    }
+    if (showLabels && width >= minLabelWidth) {
+      const label = frame.name.slice(0, width - 2);
+      const labelX = x1 + 1;
+      const labelY = y + Math.floor(rowHeight / 2);
+      const textColor = { r: 255, g: 255, b: 255, a: 1 };
+      for (let i = 0;i < label.length; i++) {
+        if (labelX + i < x2 - 1) {
+          canvas.drawChar(labelX + i, labelY, label[i], textColor);
+        }
+      }
+    }
+  }
+}
+function renderGeomCorrmat(data, geom, aes, scales, canvas) {
+  if (data.length === 0)
+    return;
+  const showValues = geom.params.show_values ?? true;
+  const decimals = geom.params.decimals ?? 2;
+  const positiveColor = parseColorToRgba(geom.params.positive_color ?? "#2166ac");
+  const negativeColor = parseColorToRgba(geom.params.negative_color ?? "#b2182b");
+  const neutralColor = parseColorToRgba(geom.params.neutral_color ?? "#f7f7f7");
+  const lowerTriangle = geom.params.lower_triangle ?? false;
+  const upperTriangle = geom.params.upper_triangle ?? false;
+  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]));
+  const plotBottom = Math.round(Math.max(scales.y.range[0], scales.y.range[1]));
+  const xField = aes.x || "var1";
+  const yField = aes.y || "var2";
+  const valueField = aes.fill || "correlation";
+  const xVars = new Set;
+  const yVars = new Set;
+  const corrMap = new Map;
+  for (const row of data) {
+    const x = String(row[xField] || "");
+    const y = String(row[yField] || "");
+    const r = Number(row[valueField]) || 0;
+    xVars.add(x);
+    yVars.add(y);
+    corrMap.set(`${x}|${y}`, r);
+  }
+  const xList = [...xVars];
+  const yList = [...yVars];
+  const numX = xList.length;
+  const numY = yList.length;
+  if (numX === 0 || numY === 0)
+    return;
+  const cellWidth = Math.max(4, Math.floor((plotRight - plotLeft) / numX));
+  const cellHeight = Math.max(2, Math.floor((plotBottom - plotTop) / numY));
+  const getColor = (r) => {
+    const t = (r + 1) / 2;
+    if (t < 0.5) {
+      const s = t * 2;
       return {
-        r: parseInt(hex[0] + hex[0], 16),
-        g: parseInt(hex[1] + hex[1], 16),
-        b: parseInt(hex[2] + hex[2], 16),
+        r: Math.round(negativeColor.r + (neutralColor.r - negativeColor.r) * s),
+        g: Math.round(negativeColor.g + (neutralColor.g - negativeColor.g) * s),
+        b: Math.round(negativeColor.b + (neutralColor.b - negativeColor.b) * s),
         a: 1
       };
-    } else if (hex.length === 6) {
+    } else {
+      const s = (t - 0.5) * 2;
       return {
-        r: parseInt(hex.slice(0, 2), 16),
-        g: parseInt(hex.slice(2, 4), 16),
-        b: parseInt(hex.slice(4, 6), 16),
+        r: Math.round(neutralColor.r + (positiveColor.r - neutralColor.r) * s),
+        g: Math.round(neutralColor.g + (positiveColor.g - neutralColor.g) * s),
+        b: Math.round(neutralColor.b + (positiveColor.b - neutralColor.b) * s),
         a: 1
       };
     }
+  };
+  for (let i = 0;i < numX; i++) {
+    for (let j = 0;j < numY; j++) {
+      if (lowerTriangle && i < j)
+        continue;
+      if (upperTriangle && i > j)
+        continue;
+      const x = xList[i];
+      const y = yList[j];
+      const key = `${x}|${y}`;
+      const r = corrMap.get(key) ?? corrMap.get(`${y}|${x}`) ?? (i === j ? 1 : 0);
+      const color = getColor(r);
+      const cellX = plotLeft + i * cellWidth;
+      const cellY = plotTop + j * cellHeight;
+      for (let cy = 0;cy < cellHeight; cy++) {
+        for (let cx = 0;cx < cellWidth; cx++) {
+          if (cellX + cx < plotRight && cellY + cy < plotBottom) {
+            canvas.drawChar(cellX + cx, cellY + cy, "█", color);
+          }
+        }
+      }
+      if (showValues && cellWidth >= 4) {
+        const valueStr = r.toFixed(decimals);
+        const textX = cellX + Math.floor((cellWidth - valueStr.length) / 2);
+        const textY = cellY + Math.floor(cellHeight / 2);
+        const brightness = (color.r * 299 + color.g * 587 + color.b * 114) / 1000;
+        const textColor = brightness > 128 ? { r: 0, g: 0, b: 0, a: 1 } : { r: 255, g: 255, b: 255, a: 1 };
+        for (let k = 0;k < valueStr.length; k++) {
+          if (textX + k < cellX + cellWidth && textX + k < plotRight) {
+            canvas.drawChar(textX + k, textY, valueStr[k], textColor);
+          }
+        }
+      }
+    }
   }
-  return { r: 128, g: 128, b: 128, a: 1 };
 }
-function renderGeomBeeswarm(data, geom, aes, scales, canvas) {
-  const alpha = geom.params.alpha ?? 1;
-  const fixedColor = geom.params.color;
-  const shape = getPointShape(geom.params.shape);
+function renderGeomSankey(data, geom, aes, scales, canvas) {
+  if (data.length === 0)
+    return;
+  const nodeWidth = geom.params.node_width ?? 3;
+  const nodePadding = geom.params.node_padding ?? 2;
+  const nodeChar = geom.params.node_char ?? "█";
+  const showLabels = geom.params.show_labels ?? true;
+  const showValues = geom.params.show_values ?? false;
+  const minFlowWidth = geom.params.min_flow_width ?? 1;
   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]));
   const plotBottom = Math.round(Math.max(scales.y.range[0], scales.y.range[1]));
-  const defaultColors = [
-    { r: 79, g: 169, b: 238, a: 1 },
-    { r: 238, g: 136, b: 102, a: 1 },
-    { r: 102, g: 204, b: 153, a: 1 },
-    { r: 204, g: 102, b: 204, a: 1 },
-    { r: 255, g: 200, b: 87, a: 1 },
-    { r: 138, g: 201, b: 222, a: 1 },
-    { r: 255, g: 153, b: 153, a: 1 },
-    { r: 170, g: 170, b: 170, a: 1 }
-  ];
-  const categories = new Set;
+  const plotHeight = plotBottom - plotTop;
+  const sourceField = aes.x || "source";
+  const targetField = aes.y || "target";
+  const valueField = aes.fill || "value";
+  const nodes = new Map;
+  const links = [];
+  const sourceNodes = new Set;
+  const targetNodes = new Set;
   for (const row of data) {
-    categories.add(String(row.xOriginal ?? row[aes.x] ?? "default"));
+    const source = String(row[sourceField] ?? "");
+    const target = String(row[targetField] ?? "");
+    const value = Number(row[valueField]) || 0;
+    if (!source || !target)
+      continue;
+    sourceNodes.add(source);
+    targetNodes.add(target);
+    links.push({ source, target, value });
+    if (!nodes.has(source)) {
+      nodes.set(source, { name: source, value: 0, column: 0, y: 0, height: 0 });
+    }
+    if (!nodes.has(target)) {
+      nodes.set(target, { name: target, value: 0, column: 1, y: 0, height: 0 });
+    }
+    nodes.get(source).value += value;
+    nodes.get(target).value += value;
+  }
+  for (const [name, node] of nodes) {
+    if (sourceNodes.has(name) && !targetNodes.has(name)) {
+      node.column = 0;
+    } else if (targetNodes.has(name) && !sourceNodes.has(name)) {
+      node.column = 1;
+    } else {
+      node.column = 0;
+    }
   }
-  const categoryList = [...categories];
-  for (const row of data) {
-    const xVal = row.x;
-    const yVal = row.y;
-    if (xVal === null || xVal === undefined || yVal === null || yVal === undefined) {
+  const columns = [[], []];
+  for (const [, node] of nodes) {
+    if (!columns[node.column])
+      columns[node.column] = [];
+    columns[node.column].push(node);
+  }
+  const maxColumnValue = Math.max(columns[0]?.reduce((sum, n) => sum + n.value, 0) || 0, columns[1]?.reduce((sum, n) => sum + n.value, 0) || 0);
+  if (maxColumnValue === 0)
+    return;
+  const availableHeight = plotHeight - nodePadding * Math.max(columns[0]?.length || 0, columns[1]?.length || 0);
+  for (let col = 0;col < 2; col++) {
+    if (!columns[col])
       continue;
+    let currentY = plotTop;
+    columns[col].sort((a, b) => b.value - a.value);
+    for (const node of columns[col]) {
+      node.height = Math.max(1, Math.round(node.value / maxColumnValue * availableHeight));
+      node.y = currentY;
+      currentY += node.height + nodePadding;
     }
-    const numGroups = categoryList.length;
-    const xRange = plotRight - plotLeft;
-    const xNormalized = (Number(xVal) + 0.5) / numGroups;
-    const cx = Math.round(plotLeft + xNormalized * xRange);
-    const cy = Math.round(scales.y.map(yVal));
-    let color;
-    if (fixedColor) {
-      color = parseColorToRgba(fixedColor);
-    } else if (scales.color && aes.color) {
-      color = getPointColor(row, aes, scales.color);
+  }
+  const colorPalette = [
+    { r: 79, g: 169, b: 238, a: 1 },
+    { r: 240, g: 128, b: 60, a: 1 },
+    { r: 102, g: 194, b: 114, a: 1 },
+    { r: 218, g: 98, b: 125, a: 1 },
+    { r: 169, g: 140, b: 204, a: 1 },
+    { r: 255, g: 204, b: 102, a: 1 }
+  ];
+  const nodeColors = new Map;
+  let colorIdx = 0;
+  for (const [name] of nodes) {
+    nodeColors.set(name, colorPalette[colorIdx % colorPalette.length]);
+    colorIdx++;
+  }
+  const labelSpace = showLabels ? 8 : 0;
+  const col0X = plotLeft + labelSpace;
+  const col1X = plotRight - nodeWidth - labelSpace;
+  for (const [name, node] of nodes) {
+    const x = node.column === 0 ? col0X : col1X;
+    const color = nodeColors.get(name);
+    for (let dy = 0;dy < node.height; dy++) {
+      for (let dx = 0;dx < nodeWidth; dx++) {
+        canvas.drawChar(x + dx, node.y + dy, nodeChar, color);
+      }
+    }
+    if (showLabels) {
+      const labelX = node.column === 0 ? x - name.length - 1 : x + nodeWidth + 1;
+      const labelY = node.y + Math.floor(node.height / 2);
+      const labelColor = { r: 180, g: 180, b: 180, a: 1 };
+      for (let i = 0;i < name.length && labelX + i >= plotLeft && labelX + i < plotRight; i++) {
+        canvas.drawChar(labelX + i, labelY, name[i], labelColor);
+      }
+    }
+  }
+  for (const link of links) {
+    const sourceNode = nodes.get(link.source);
+    const targetNode = nodes.get(link.target);
+    if (!sourceNode || !targetNode)
+      continue;
+    const flowWidth = Math.max(minFlowWidth, Math.round(link.value / maxColumnValue * (plotHeight / 4)));
+    const sourceColor = nodeColors.get(link.source);
+    const x1 = col0X + nodeWidth;
+    const x2 = col1X;
+    const y1 = sourceNode.y + Math.floor(sourceNode.height / 2);
+    const y2 = targetNode.y + Math.floor(targetNode.height / 2);
+    const steps = Math.abs(x2 - x1);
+    for (let i = 0;i <= steps; i++) {
+      const t = i / steps;
+      const x = Math.round(x1 + (x2 - x1) * t);
+      const y = Math.round(y1 + (y2 - y1) * (3 * t * t - 2 * t * t * t));
+      const halfWidth = Math.floor(flowWidth / 2);
+      for (let dy = -halfWidth;dy <= halfWidth; dy++) {
+        const flowY = y + dy;
+        if (flowY >= plotTop && flowY < plotBottom && x >= plotLeft && x < plotRight) {
+          const flowColor = {
+            r: sourceColor.r,
+            g: sourceColor.g,
+            b: sourceColor.b,
+            a: 0.4
+          };
+          const char = dy === 0 ? "─" : "░";
+          canvas.drawChar(x, flowY, char, flowColor);
+        }
+      }
+    }
+    if (showValues) {
+      const midX = Math.round((x1 + x2) / 2);
+      const midY = Math.round((y1 + y2) / 2);
+      const valueStr = String(link.value);
+      const textColor = { r: 200, g: 200, b: 200, a: 1 };
+      for (let i = 0;i < valueStr.length; i++) {
+        canvas.drawChar(midX - Math.floor(valueStr.length / 2) + i, midY, valueStr[i], textColor);
+      }
+    }
+  }
+}
+function renderGeomTreemap(data, geom, aes, scales, canvas) {
+  if (data.length === 0)
+    return;
+  const showLabels = geom.params.show_labels ?? true;
+  const showValues = geom.params.show_values ?? false;
+  const border = geom.params.border ?? true;
+  const minLabelSize = geom.params.min_label_size ?? 4;
+  const fillChar = geom.params.fill_char ?? "█";
+  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]));
+  const plotBottom = Math.round(Math.max(scales.y.range[0], scales.y.range[1]));
+  const labelField = aes.x || "name";
+  const valueField = aes.fill || aes.y || "value";
+  const parentField = aes.group || "parent";
+  const idField = aes.x || "id";
+  const nodeMap = new Map;
+  const roots = [];
+  for (const row of data) {
+    const id = String(row[idField] ?? row[labelField] ?? "");
+    const label = String(row[labelField] ?? id);
+    const value = Number(row[valueField]) || 0;
+    const parent = row[parentField] ? String(row[parentField]) : undefined;
+    const node = {
+      id,
+      label,
+      value,
+      parent,
+      children: [],
+      x: 0,
+      y: 0,
+      width: 0,
+      height: 0
+    };
+    nodeMap.set(id, node);
+  }
+  for (const [, node] of nodeMap) {
+    if (node.parent && nodeMap.has(node.parent)) {
+      nodeMap.get(node.parent).children.push(node);
     } else {
-      const category = String(row.xOriginal ?? row[aes.x] ?? "default");
-      const categoryIdx = categoryList.indexOf(category);
-      color = defaultColors[categoryIdx % defaultColors.length];
+      roots.push(node);
     }
-    if (alpha < 1) {
-      color = { ...color, a: alpha };
+  }
+  if (roots.length === 0) {
+    for (const [, node] of nodeMap) {
+      roots.push(node);
     }
-    if (cx >= plotLeft && cx <= plotRight && cy >= plotTop && cy <= plotBottom) {
-      canvas.drawChar(cx, cy, shape, color);
+  }
+  function calculateValue(node) {
+    if (node.children.length === 0) {
+      return node.value;
+    }
+    const childSum = node.children.reduce((sum, child) => sum + calculateValue(child), 0);
+    return node.value || childSum;
+  }
+  for (const root of roots) {
+    root.value = calculateValue(root);
+  }
+  const validRoots = roots.filter((n) => n.value > 0).sort((a, b) => b.value - a.value);
+  if (validRoots.length === 0)
+    return;
+  function squarify(nodes, x, y, width, height) {
+    if (nodes.length === 0 || width <= 0 || height <= 0)
+      return;
+    const totalValue = nodes.reduce((sum, n) => sum + n.value, 0);
+    if (totalValue === 0)
+      return;
+    if (nodes.length === 1) {
+      const node = nodes[0];
+      node.x = x;
+      node.y = y;
+      node.width = width;
+      node.height = height;
+      return;
+    }
+    const isHorizontal = width > height;
+    let currentPos = isHorizontal ? x : y;
+    const totalSize = isHorizontal ? width : height;
+    for (const node of nodes) {
+      const fraction = node.value / totalValue;
+      const size = Math.round(totalSize * fraction);
+      if (isHorizontal) {
+        node.x = currentPos;
+        node.y = y;
+        node.width = Math.max(1, size);
+        node.height = height;
+        currentPos += node.width;
+      } else {
+        node.x = x;
+        node.y = currentPos;
+        node.width = width;
+        node.height = Math.max(1, size);
+        currentPos += node.height;
+      }
+    }
+  }
+  squarify(validRoots, plotLeft, plotTop, plotRight - plotLeft, plotBottom - plotTop);
+  const colorPalette = [
+    { r: 66, g: 133, b: 244, a: 1 },
+    { r: 234, g: 67, b: 53, a: 1 },
+    { r: 251, g: 188, b: 5, a: 1 },
+    { r: 52, g: 168, b: 83, a: 1 },
+    { r: 154, g: 102, b: 255, a: 1 },
+    { r: 255, g: 109, b: 0, a: 1 },
+    { r: 0, g: 188, b: 212, a: 1 },
+    { r: 233, g: 30, b: 99, a: 1 }
+  ];
+  function renderNode(node, colorIndex, depth) {
+    if (node.width <= 0 || node.height <= 0)
+      return;
+    const baseColor = colorPalette[colorIndex % colorPalette.length];
+    const depthFactor = Math.max(0.5, 1 - depth * 0.15);
+    const color = {
+      r: Math.round(baseColor.r * depthFactor),
+      g: Math.round(baseColor.g * depthFactor),
+      b: Math.round(baseColor.b * depthFactor),
+      a: 1
+    };
+    for (let dy = 0;dy < node.height; dy++) {
+      for (let dx = 0;dx < node.width; dx++) {
+        const px = node.x + dx;
+        const py = node.y + dy;
+        if (px >= plotLeft && px < plotRight && py >= plotTop && py < plotBottom) {
+          canvas.drawChar(px, py, fillChar, color);
+        }
+      }
+    }
+    if (border && node.width >= 2 && node.height >= 2) {
+      const borderColor = { r: 40, g: 40, b: 40, a: 1 };
+      for (let dx = 0;dx < node.width; dx++) {
+        const px = node.x + dx;
+        if (px >= plotLeft && px < plotRight) {
+          if (node.y >= plotTop)
+            canvas.drawChar(px, node.y, "─", borderColor);
+          if (node.y + node.height - 1 < plotBottom)
+            canvas.drawChar(px, node.y + node.height - 1, "─", borderColor);
+        }
+      }
+      for (let dy = 0;dy < node.height; dy++) {
+        const py = node.y + dy;
+        if (py >= plotTop && py < plotBottom) {
+          if (node.x >= plotLeft)
+            canvas.drawChar(node.x, py, "│", borderColor);
+          if (node.x + node.width - 1 < plotRight)
+            canvas.drawChar(node.x + node.width - 1, py, "│", borderColor);
+        }
+      }
+      if (node.x >= plotLeft && node.y >= plotTop)
+        canvas.drawChar(node.x, node.y, "┌", borderColor);
+      if (node.x + node.width - 1 < plotRight && node.y >= plotTop)
+        canvas.drawChar(node.x + node.width - 1, node.y, "┐", borderColor);
+      if (node.x >= plotLeft && node.y + node.height - 1 < plotBottom)
+        canvas.drawChar(node.x, node.y + node.height - 1, "└", borderColor);
+      if (node.x + node.width - 1 < plotRight && node.y + node.height - 1 < plotBottom)
+        canvas.drawChar(node.x + node.width - 1, node.y + node.height - 1, "┘", borderColor);
+    }
+    if (showLabels && node.width >= minLabelSize && node.height >= 1) {
+      const label = node.label.substring(0, node.width - 2);
+      const labelX = node.x + 1;
+      const labelY = node.y + Math.floor(node.height / 2);
+      const brightness = (color.r * 299 + color.g * 587 + color.b * 114) / 1000;
+      const textColor = brightness > 128 ? { r: 0, g: 0, b: 0, a: 1 } : { r: 255, g: 255, b: 255, a: 1 };
+      for (let i = 0;i < label.length; i++) {
+        const px = labelX + i;
+        if (px >= plotLeft && px < node.x + node.width - 1 && px < plotRight) {
+          canvas.drawChar(px, labelY, label[i], textColor);
+        }
+      }
+      if (showValues && node.height >= 3) {
+        const valueStr = String(node.value);
+        const valueY = labelY + 1;
+        for (let i = 0;i < valueStr.length; i++) {
+          const px = labelX + i;
+          if (px >= plotLeft && px < node.x + node.width - 1 && px < plotRight && valueY < plotBottom) {
+            canvas.drawChar(px, valueY, valueStr[i], textColor);
+          }
+        }
+      }
+    }
+    if (node.children.length > 0) {
+      const childrenSorted = [...node.children].sort((a, b) => b.value - a.value);
+      squarify(childrenSorted, node.x + (border ? 1 : 0), node.y + (border ? 1 : 0), node.width - (border ? 2 : 0), node.height - (border ? 2 : 0));
+      for (let i = 0;i < childrenSorted.length; i++) {
+        renderNode(childrenSorted[i], colorIndex, depth + 1);
+      }
     }
   }
+  for (let i = 0;i < validRoots.length; i++) {
+    renderNode(validRoots[i], i, 0);
+  }
 }
 function renderGeom(data, geom, aes, scales, canvas, coordType) {
   switch (geom.type) {
@@ -2397,6 +3672,9 @@ function renderGeom(data, geom, aes, scales, canvas, coordType) {
     case "freqpoly":
       renderGeomFreqpoly(data, geom, aes, scales, canvas);
       break;
+    case "density":
+      renderGeomDensity(data, geom, aes, scales, canvas);
+      break;
     case "boxplot":
       renderGeomBoxplot(data, geom, aes, scales, canvas);
       break;
@@ -2435,6 +3713,9 @@ function renderGeom(data, geom, aes, scales, canvas, coordType) {
     case "linerange":
       renderGeomLinerange(data, geom, aes, scales, canvas);
       break;
+    case "crossbar":
+      renderGeomCrossbar(data, geom, aes, scales, canvas);
+      break;
     case "pointrange":
       renderGeomPointrange(data, geom, aes, scales, canvas);
       break;
@@ -2445,6 +3726,40 @@ function renderGeom(data, geom, aes, scales, canvas, coordType) {
     case "quasirandom":
       renderGeomBeeswarm(data, geom, aes, scales, canvas);
       break;
+    case "dumbbell":
+      renderGeomDumbbell(data, geom, aes, scales, canvas);
+      break;
+    case "lollipop":
+      renderGeomLollipop(data, geom, aes, scales, canvas);
+      break;
+    case "waffle":
+      renderGeomWaffle(data, geom, aes, scales, canvas);
+      break;
+    case "sparkline":
+      renderGeomSparkline(data, geom, aes, scales, canvas);
+      break;
+    case "bullet":
+      renderGeomBullet(data, geom, aes, scales, canvas);
+      break;
+    case "braille":
+      renderGeomBraille(data, geom, aes, scales, canvas);
+      break;
+    case "calendar":
+      renderGeomCalendar(data, geom, aes, scales, canvas);
+      break;
+    case "flame":
+    case "icicle":
+      renderGeomFlame(data, geom, aes, scales, canvas);
+      break;
+    case "corrmat":
+      renderGeomCorrmat(data, geom, aes, scales, canvas);
+      break;
+    case "sankey":
+      renderGeomSankey(data, geom, aes, scales, canvas);
+      break;
+    case "treemap":
+      renderGeomTreemap(data, geom, aes, scales, canvas);
+      break;
     default:
       break;
   }
@@ -5450,6 +6765,26 @@ function geom_freqpoly(options = {}) {
   };
 }
 
+// src/geoms/density.ts
+function geom_density(options = {}) {
+  return {
+    type: "density",
+    stat: "density",
+    position: "identity",
+    params: {
+      n: options.n ?? 512,
+      bw: options.bw,
+      kernel: options.kernel ?? "gaussian",
+      adjust: options.adjust ?? 1,
+      alpha: options.alpha ?? 0.3,
+      color: options.color,
+      fill: options.fill,
+      linewidth: options.linewidth ?? 1,
+      linetype: options.linetype ?? "solid"
+    }
+  };
+}
+
 // src/geoms/boxplot.ts
 function geom_boxplot(options = {}) {
   return {
@@ -5817,9 +7152,240 @@ function geom_quasirandom(options = {}) {
   return geom_beeswarm({ ...options, method: "center" });
 }
 
+// src/geoms/dumbbell.ts
+function geom_dumbbell(options = {}) {
+  return {
+    type: "dumbbell",
+    stat: "identity",
+    position: "identity",
+    params: {
+      size: options.size ?? 2,
+      sizeEnd: options.sizeEnd ?? options.size ?? 2,
+      color: options.color,
+      colorEnd: options.colorEnd ?? options.color,
+      lineColor: options.lineColor ?? "#666666",
+      lineWidth: options.lineWidth ?? 1,
+      alpha: options.alpha ?? 1,
+      shape: options.shape ?? "circle"
+    }
+  };
+}
+
+// src/geoms/lollipop.ts
+function geom_lollipop(options = {}) {
+  return {
+    type: "lollipop",
+    stat: "identity",
+    position: "identity",
+    params: {
+      size: options.size ?? 2,
+      color: options.color,
+      lineColor: options.lineColor,
+      lineWidth: options.lineWidth ?? 1,
+      alpha: options.alpha ?? 1,
+      shape: options.shape ?? "circle",
+      direction: options.direction ?? "vertical",
+      baseline: options.baseline ?? 0
+    }
+  };
+}
+
+// src/geoms/waffle.ts
+function geom_waffle(options = {}) {
+  return {
+    type: "waffle",
+    stat: "identity",
+    position: "identity",
+    params: {
+      rows: options.rows ?? 10,
+      cols: options.cols ?? 10,
+      n_total: options.n_total ?? 100,
+      fill_char: options.fill_char ?? "█",
+      empty_char: options.empty_char ?? "░",
+      alpha: options.alpha ?? 1,
+      show_legend: options.show_legend ?? true,
+      flip: options.flip ?? false,
+      gap: options.gap ?? 0
+    }
+  };
+}
+
+// src/geoms/sparkline.ts
+function geom_sparkline(options = {}) {
+  return {
+    type: "sparkline",
+    stat: "identity",
+    position: "identity",
+    params: {
+      sparkType: options.type ?? "bar",
+      width: options.width ?? 20,
+      height: options.height ?? 1,
+      show_minmax: options.show_minmax ?? false,
+      color: options.color,
+      min_color: options.min_color ?? "#e74c3c",
+      max_color: options.max_color ?? "#2ecc71",
+      normalize: options.normalize ?? true
+    }
+  };
+}
+var SPARK_BARS, SPARK_DOTS;
+var init_sparkline = __esm(() => {
+  SPARK_BARS = ["▁", "▂", "▃", "▄", "▅", "▆", "▇", "█"];
+  SPARK_DOTS = ["⠀", "⢀", "⢠", "⢰", "⢸", "⣸", "⣾", "⣿"];
+});
+
+// src/geoms/bullet.ts
+function geom_bullet(options = {}) {
+  return {
+    type: "bullet",
+    stat: "identity",
+    position: "identity",
+    params: {
+      width: options.width ?? 40,
+      height: options.height ?? 1,
+      target_char: options.target_char ?? "│",
+      bar_char: options.bar_char ?? "█",
+      range_chars: options.range_chars ?? ["░", "▒", "▓"],
+      show_values: options.show_values ?? true,
+      color: options.color,
+      target_color: options.target_color ?? "#e74c3c",
+      orientation: options.orientation ?? "horizontal"
+    }
+  };
+}
+
+// src/geoms/braille.ts
+function geom_braille(options = {}) {
+  return {
+    type: "braille",
+    stat: "identity",
+    position: "identity",
+    params: {
+      brailleType: options.type ?? "point",
+      color: options.color,
+      fill: options.fill ?? false,
+      alpha: options.alpha ?? 1,
+      dot_size: options.dot_size ?? 1
+    }
+  };
+}
+var BRAILLE_BASE = 10240, BRAILLE_DOTS;
+var init_braille = __esm(() => {
+  BRAILLE_DOTS = [
+    [1, 2, 4, 64],
+    [8, 16, 32, 128]
+  ];
+});
+
+// src/geoms/calendar.ts
+function geom_calendar(options = {}) {
+  return {
+    type: "calendar",
+    stat: "identity",
+    position: "identity",
+    params: {
+      cell_char: options.cell_char ?? "█",
+      empty_char: options.empty_char ?? "░",
+      empty_color: options.empty_color ?? "#161b22",
+      fill_color: options.fill_color ?? "#39d353",
+      show_months: options.show_months ?? true,
+      show_days: options.show_days ?? true,
+      week_start: options.week_start ?? 0,
+      levels: options.levels ?? 5
+    }
+  };
+}
+
+// src/geoms/flame.ts
+function geom_flame(options = {}) {
+  return {
+    type: "flame",
+    stat: "identity",
+    position: "identity",
+    params: {
+      style: options.style ?? "flame",
+      palette: options.palette ?? "warm",
+      show_labels: options.show_labels ?? true,
+      min_label_width: options.min_label_width ?? 10,
+      sort: options.sort ?? "alpha",
+      bar_char: options.bar_char ?? "█"
+    }
+  };
+}
+function geom_icicle(options = {}) {
+  return geom_flame({ ...options, style: "icicle" });
+}
+
+// src/geoms/corrmat.ts
+function geom_corrmat(options = {}) {
+  return {
+    type: "corrmat",
+    stat: "identity",
+    position: "identity",
+    params: {
+      show_values: options.show_values ?? true,
+      decimals: options.decimals ?? 2,
+      show_significance: options.show_significance ?? false,
+      sig_threshold: options.sig_threshold ?? 0.05,
+      sig_marker: options.sig_marker ?? "*",
+      positive_color: options.positive_color ?? "#2166ac",
+      negative_color: options.negative_color ?? "#b2182b",
+      neutral_color: options.neutral_color ?? "#f7f7f7",
+      lower_triangle: options.lower_triangle ?? false,
+      upper_triangle: options.upper_triangle ?? false,
+      show_diagonal: options.show_diagonal ?? true,
+      method: options.method ?? "pearson"
+    }
+  };
+}
+
+// src/geoms/sankey.ts
+function geom_sankey(options = {}) {
+  return {
+    type: "sankey",
+    stat: "identity",
+    position: "identity",
+    params: {
+      node_width: options.node_width ?? 3,
+      node_padding: options.node_padding ?? 2,
+      node_char: options.node_char ?? "█",
+      flow_char: options.flow_char ?? "─",
+      show_labels: options.show_labels ?? true,
+      show_values: options.show_values ?? false,
+      align: options.align ?? "justify",
+      color_by: options.color_by ?? "auto",
+      min_flow_width: options.min_flow_width ?? 1,
+      flow_gap: options.flow_gap ?? 0
+    }
+  };
+}
+
+// src/geoms/treemap.ts
+function geom_treemap(options = {}) {
+  return {
+    type: "treemap",
+    stat: "identity",
+    position: "identity",
+    params: {
+      algorithm: options.algorithm ?? "squarify",
+      show_labels: options.show_labels ?? true,
+      show_values: options.show_values ?? false,
+      border: options.border ?? true,
+      padding: options.padding ?? 0,
+      min_label_size: options.min_label_size ?? 4,
+      color_by: options.color_by ?? "value",
+      fill_char: options.fill_char ?? "█",
+      max_depth: options.max_depth,
+      aspect_ratio: options.aspect_ratio ?? 1.618
+    }
+  };
+}
+
 // src/geoms/index.ts
 var init_geoms = __esm(() => {
   init_ridgeline();
+  init_sparkline();
+  init_braille();
 });
 
 // src/stats/index.ts
@@ -10322,13 +11888,17 @@ __export(exports_src, {
   getColorEscape: () => getColorEscape,
   getCapabilities: () => getCapabilities,
   getAvailablePalettes: () => getAvailablePalettes,
+  geom_waffle: () => geom_waffle,
   geom_vline: () => geom_vline,
   geom_violin: () => geom_violin,
+  geom_treemap: () => geom_treemap,
   geom_tile: () => geom_tile,
   geom_text: () => geom_text,
   geom_step: () => geom_step,
+  geom_sparkline: () => geom_sparkline,
   geom_smooth: () => geom_smooth,
   geom_segment: () => geom_segment,
+  geom_sankey: () => geom_sankey,
   geom_rug: () => geom_rug,
   geom_ridgeline: () => geom_ridgeline,
   geom_ribbon: () => geom_ribbon,
@@ -10340,21 +11910,30 @@ __export(exports_src, {
   geom_pointrange: () => geom_pointrange,
   geom_point: () => geom_point,
   geom_path: () => geom_path,
+  geom_lollipop: () => geom_lollipop,
   geom_linerange: () => geom_linerange,
   geom_line: () => geom_line,
   geom_label: () => geom_label,
   geom_joy: () => geom_joy,
+  geom_icicle: () => geom_icicle,
   geom_hline: () => geom_hline,
   geom_histogram: () => geom_histogram,
   geom_freqpoly: () => geom_freqpoly,
+  geom_flame: () => geom_flame,
   geom_errorbarh: () => geom_errorbarh,
   geom_errorbar: () => geom_errorbar,
+  geom_dumbbell: () => geom_dumbbell,
   geom_density_2d: () => geom_density_2d,
+  geom_density: () => geom_density,
   geom_curve: () => geom_curve,
   geom_crossbar: () => geom_crossbar,
+  geom_corrmat: () => geom_corrmat,
   geom_contour_filled: () => geom_contour_filled,
   geom_contour: () => geom_contour,
   geom_col: () => geom_col,
+  geom_calendar: () => geom_calendar,
+  geom_bullet: () => geom_bullet,
+  geom_braille: () => geom_braille,
   geom_boxplot: () => geom_boxplot,
   geom_bin2d: () => geom_bin2d,
   geom_beeswarm: () => geom_beeswarm,
@@ -10426,6 +12005,8 @@ __export(exports_src, {
   annotate: () => annotate,
   TerminalCanvas: () => TerminalCanvas,
   StreamingPlot: () => StreamingPlot,
+  SPARK_DOTS: () => SPARK_DOTS,
+  SPARK_BARS: () => SPARK_BARS,
   SHAPE_CHARS: () => SHAPE_CHARS,
   RollingAggregator: () => RollingAggregator,
   RendererChain: () => RendererChain,
@@ -10445,6 +12026,8 @@ __export(exports_src, {
   DEFAULT_BG: () => DEFAULT_BG,
   CanvasDiff: () => CanvasDiff,
   Binner: () => Binner,
+  BRAILLE_DOTS: () => BRAILLE_DOTS,
+  BRAILLE_BASE: () => BRAILLE_BASE,
   ANSI_16_COLORS: () => ANSI_16_COLORS
 });
 var init_src = __esm(() => {
@@ -10574,13 +12157,17 @@ export {
   getColorEscape,
   getCapabilities,
   getAvailablePalettes,
+  geom_waffle,
   geom_vline,
   geom_violin,
+  geom_treemap,
   geom_tile,
   geom_text,
   geom_step,
+  geom_sparkline,
   geom_smooth,
   geom_segment,
+  geom_sankey,
   geom_rug,
   geom_ridgeline,
   geom_ribbon,
@@ -10592,21 +12179,30 @@ export {
   geom_pointrange,
   geom_point,
   geom_path,
+  geom_lollipop,
   geom_linerange,
   geom_line,
   geom_label,
   geom_joy,
+  geom_icicle,
   geom_hline,
   geom_histogram,
   geom_freqpoly,
+  geom_flame,
   geom_errorbarh,
   geom_errorbar,
+  geom_dumbbell,
   geom_density_2d,
+  geom_density,
   geom_curve,
   geom_crossbar,
+  geom_corrmat,
   geom_contour_filled,
   geom_contour,
   geom_col,
+  geom_calendar,
+  geom_bullet,
+  geom_braille,
   geom_boxplot,
   geom_bin2d,
   geom_beeswarm,
@@ -10678,6 +12274,8 @@ export {
   annotate,
   TerminalCanvas,
   StreamingPlot,
+  SPARK_DOTS,
+  SPARK_BARS,
   SHAPE_CHARS,
   RollingAggregator,
   RendererChain,
@@ -10697,5 +12295,7 @@ export {
   DEFAULT_BG,
   CanvasDiff,
   Binner,
+  BRAILLE_DOTS,
+  BRAILLE_BASE,
   ANSI_16_COLORS
 };