@ggterm/core 0.2.12 → 0.2.16

package/dist/cli.js

@@ -1565,6 +1565,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;
@@ -2209,6 +2285,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]);
@@ -2824,6 +2972,670 @@ function renderGeomBraille(data, geom, aes, scales, canvas) {
     }
   }
 }
+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: 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 {
+      const s = (t - 0.5) * 2;
+      return {
+        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);
+          }
+        }
+      }
+    }
+  }
+}
+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 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) {
+    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 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 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 {
+      roots.push(node);
+    }
+  }
+  if (roots.length === 0) {
+    for (const [, node] of nodeMap) {
+      roots.push(node);
+    }
+  }
+  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) {
     case "point":
@@ -2861,6 +3673,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;
@@ -2899,6 +3714,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;
@@ -2927,6 +3745,22 @@ function renderGeom(data, geom, aes, scales, canvas, coordType) {
     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;
   }
@@ -5927,6 +6761,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 {
@@ -6419,6 +7273,110 @@ var init_braille = __esm(() => {
   ];
 });
 
+// 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();