@tuicomponents/chart 0.2.0

package/dist/index.js

@@ -0,0 +1,3656 @@
+// src/chart.ts
+import {
+  BaseTuiComponent,
+  measureLines,
+  registry
+} from "@tuicomponents/core";
+import { zodToJsonSchema } from "zod-to-json-schema";
+
+// src/schema.ts
+import { z } from "zod";
+var chartTypeSchema = z.enum([
+  "bar",
+  // Horizontal bars
+  "bar-vertical",
+  // Vertical bars (column chart)
+  "bar-stacked",
+  // Stacked horizontal bars
+  "bar-stacked-vertical",
+  // Stacked vertical bars
+  "line",
+  // Line chart (height blocks)
+  "area",
+  // Filled area
+  "area-stacked",
+  // Stacked area
+  "scatter",
+  // 2D scatter plot with X/Y axes
+  "pie",
+  // Pie chart (circular)
+  "donut",
+  // Donut chart (pie with inner radius)
+  "heatmap"
+  // 2D grid with intensity shading
+]);
+var barStyleSchema = z.enum([
+  "block",
+  // ████████
+  "shaded",
+  // ▓▓▓▓▓▓▓▓
+  "light",
+  // ░░░░░░░░
+  "hash",
+  // ########
+  "equals",
+  // ========
+  "arrow"
+  // >>>>>>>>
+]);
+var lineStyleSchema = z.enum([
+  "blocks",
+  // Height blocks: ▁▂▃▄▅▆▇█ (default)
+  "braille",
+  // Braille dots (high resolution)
+  "dots"
+  // Point markers: · • ●
+]);
+var scatterStyleSchema = z.enum([
+  "dots",
+  // Simple character dots (●, ■, ▲)
+  "braille"
+  // High-resolution braille positioning
+]);
+var scatterMarkerSchema = z.enum([
+  "circle",
+  // ●
+  "square",
+  // ■
+  "triangle",
+  // ▲
+  "diamond",
+  // ◆
+  "plus"
+  // +
+]);
+var heatmapStyleSchema = z.enum([
+  "blocks",
+  // ░▒▓█ (4 intensity levels)
+  "ascii",
+  // . : * # (4 levels, markdown-friendly)
+  "numeric"
+  // Show actual values in cells
+]);
+var valueFormatSchema = z.enum([
+  "number",
+  // Regular number
+  "percent",
+  // Percentage
+  "compact",
+  // K/M/B suffixes
+  "currency"
+  // Dollar prefix
+]);
+var legendPositionSchema = z.enum([
+  "none",
+  // No legend
+  "top",
+  // Above chart
+  "bottom",
+  // Below chart
+  "right",
+  // To the right
+  "inline"
+  // Inline with data
+]);
+var dataPointSchema = z.object({
+  /**
+   * Category or x-value.
+   * Can be a string (categorical) or number (continuous).
+   */
+  x: z.union([z.string(), z.number()]),
+  /**
+   * Numeric y-value.
+   */
+  y: z.number(),
+  /**
+   * Optional custom label for this data point.
+   */
+  label: z.string().optional()
+});
+var dataSeriesSchema = z.object({
+  /**
+   * Series name (used in legend).
+   */
+  name: z.string(),
+  /**
+   * Data points in this series.
+   */
+  data: z.array(dataPointSchema),
+  /**
+   * Optional style for this series.
+   */
+  style: barStyleSchema.optional()
+});
+var axisConfigSchema = z.object({
+  /**
+   * Axis title/label.
+   */
+  label: z.string().optional(),
+  /**
+   * Explicit minimum value (auto-computed if not set).
+   */
+  min: z.number().optional(),
+  /**
+   * Explicit maximum value (auto-computed if not set).
+   */
+  max: z.number().optional(),
+  /**
+   * Number of tick marks.
+   * @default 5
+   */
+  tickCount: z.number().int().positive().default(5),
+  /**
+   * Whether to show tick marks.
+   * @default true
+   */
+  showTicks: z.boolean().default(true),
+  /**
+   * Value format for tick labels.
+   * @default "number"
+   */
+  format: valueFormatSchema.default("number"),
+  /**
+   * Number of decimal places.
+   */
+  decimals: z.number().int().nonnegative().optional()
+});
+var legendConfigSchema = z.object({
+  /**
+   * Legend position.
+   * @default "bottom"
+   */
+  position: legendPositionSchema.default("bottom"),
+  /**
+   * Whether to use boxed style.
+   * @default false
+   */
+  boxed: z.boolean().default(false)
+});
+var gridConfigSchema = z.object({
+  /**
+   * Show horizontal grid lines.
+   * @default false
+   */
+  horizontal: z.boolean().default(false),
+  /**
+   * Show vertical grid lines.
+   * @default false
+   */
+  vertical: z.boolean().default(false),
+  /**
+   * Grid character.
+   * @default "·"
+   */
+  char: z.string().default("\xB7")
+});
+var chartInputSchema = z.object({
+  /**
+   * Chart type.
+   */
+  type: chartTypeSchema,
+  /**
+   * Data series to display.
+   */
+  series: z.array(dataSeriesSchema).min(1),
+  /**
+   * Chart title.
+   */
+  title: z.string().optional(),
+  /**
+   * X-axis configuration.
+   */
+  xAxis: axisConfigSchema.optional(),
+  /**
+   * Y-axis configuration.
+   */
+  yAxis: axisConfigSchema.optional(),
+  /**
+   * Legend configuration.
+   */
+  legend: legendConfigSchema.optional(),
+  /**
+   * Grid configuration.
+   */
+  grid: gridConfigSchema.optional(),
+  /**
+   * Chart width in characters.
+   * @default 40
+   */
+  width: z.number().int().positive().default(40),
+  /**
+   * Chart height in lines.
+   * @default 10
+   */
+  height: z.number().int().positive().default(10),
+  /**
+   * Show values on data points.
+   * @default false
+   */
+  showValues: z.boolean().default(false),
+  /**
+   * Show axes.
+   * @default true
+   */
+  showAxes: z.boolean().default(true),
+  /**
+   * Line/area rendering style.
+   * @default "blocks"
+   */
+  lineStyle: lineStyleSchema.default("blocks"),
+  /**
+   * Default bar style for series without explicit style.
+   * @default "block"
+   */
+  barStyle: barStyleSchema.default("block"),
+  /**
+   * Scatter plot rendering style.
+   * @default "dots"
+   */
+  scatterStyle: scatterStyleSchema.default("dots"),
+  /**
+   * Heatmap rendering style.
+   * @default "blocks"
+   */
+  heatmapStyle: heatmapStyleSchema.default("blocks"),
+  /**
+   * Center label for donut charts.
+   * Displayed in the center of the donut.
+   */
+  centerLabel: z.string().optional(),
+  /**
+   * Inner radius ratio for donut charts (0-0.9).
+   * 0 = pie chart, 0.5 = typical donut.
+   * @default 0.5
+   */
+  innerRadius: z.number().min(0).max(0.9).default(0.5)
+});
+
+// src/layout/bar.ts
+import { getStringWidth } from "@tuicomponents/core";
+
+// src/core/scaling.ts
+var NICE_INTERVALS = [1, 2, 2.5, 5, 10];
+function findNiceStep(rawStep) {
+  if (rawStep === 0) return 1;
+  const magnitude = Math.pow(10, Math.floor(Math.log10(Math.abs(rawStep))));
+  const normalized = rawStep / magnitude;
+  for (const interval of NICE_INTERVALS) {
+    if (interval >= normalized) {
+      return interval * magnitude;
+    }
+  }
+  return 10 * magnitude;
+}
+function floorToStep(value, step) {
+  return Math.floor(value / step) * step;
+}
+function ceilToStep(value, step) {
+  return Math.ceil(value / step) * step;
+}
+function computeNiceTicks(options) {
+  const {
+    dataMin,
+    dataMax,
+    tickCount = 5,
+    includeZero = true,
+    forceMin,
+    forceMax
+  } = options;
+  if (dataMin === dataMax && forceMin === void 0 && forceMax === void 0) {
+    const center = dataMin;
+    const half = center === 0 ? 5 : Math.abs(center) * 0.5;
+    const ticks2 = [center - half, center, center + half];
+    return {
+      min: ticks2[0] ?? center - half,
+      max: ticks2[2] ?? center + half,
+      step: half,
+      ticks: ticks2
+    };
+  }
+  let effectiveMin = dataMin;
+  let effectiveMax = dataMax;
+  if (includeZero) {
+    if (effectiveMin > 0) effectiveMin = 0;
+    if (effectiveMax < 0) effectiveMax = 0;
+  }
+  if (forceMin !== void 0) effectiveMin = forceMin;
+  if (forceMax !== void 0) effectiveMax = forceMax;
+  const range = effectiveMax - effectiveMin;
+  const rawStep = range / Math.max(1, tickCount - 1);
+  const niceStep = findNiceStep(rawStep);
+  let niceMin = forceMin ?? floorToStep(effectiveMin, niceStep);
+  let niceMax = forceMax ?? ceilToStep(effectiveMax, niceStep);
+  if (niceMin > dataMin) niceMin -= niceStep;
+  if (niceMax < dataMax) niceMax += niceStep;
+  const ticks = [];
+  const epsilon = niceStep * 1e-10;
+  for (let value = niceMin; value <= niceMax + epsilon; value += niceStep) {
+    const roundedValue = Math.round(value * 1e12) / 1e12;
+    ticks.push(roundedValue);
+  }
+  return {
+    min: niceMin,
+    max: niceMax,
+    step: niceStep,
+    ticks
+  };
+}
+function formatTickValue(value, format = "number", decimals) {
+  switch (format) {
+    case "percent":
+      return `${(value * 100).toFixed(decimals ?? 0)}%`;
+    case "compact": {
+      const abs = Math.abs(value);
+      if (abs >= 1e9) {
+        return `${(value / 1e9).toFixed(decimals ?? 1)}B`;
+      }
+      if (abs >= 1e6) {
+        return `${(value / 1e6).toFixed(decimals ?? 1)}M`;
+      }
+      if (abs >= 1e3) {
+        return `${(value / 1e3).toFixed(decimals ?? 1)}K`;
+      }
+      return value.toFixed(decimals ?? 0);
+    }
+    case "currency":
+      return `$${value.toLocaleString("en-US", {
+        minimumFractionDigits: decimals ?? 0,
+        maximumFractionDigits: decimals ?? 0
+      })}`;
+    case "number":
+    default:
+      if (decimals !== void 0) {
+        return value.toFixed(decimals);
+      }
+      if (Number.isInteger(value)) {
+        return value.toLocaleString("en-US");
+      }
+      return value.toLocaleString("en-US", {
+        minimumFractionDigits: 0,
+        maximumFractionDigits: 2
+      });
+  }
+}
+function scaleValue(value, min, max, size) {
+  if (max === min) return size / 2;
+  return (value - min) / (max - min) * size;
+}
+function unscaleValue(position, min, max, size) {
+  if (size === 0) return min;
+  return min + position / size * (max - min);
+}
+
+// src/core/chars.ts
+var AXIS_CHARS = {
+  /** Y-axis line (│) */
+  vertical: "\u2502",
+  /** X-axis line (─) */
+  horizontal: "\u2500",
+  /** Origin corner (└) */
+  origin: "\u2514",
+  /** Y-axis tick (├) - points right */
+  yTick: "\u251C",
+  /** X-axis tick (┬) - points up */
+  xTick: "\u252C",
+  /** Grid intersection (┼) */
+  cross: "\u253C",
+  /** Y-axis with grid (┤) - points left */
+  yTickLeft: "\u2524",
+  /** X-axis tick (┴) - points down */
+  xTickDown: "\u2534"
+};
+var HEIGHT_BLOCKS = [
+  "\u2581",
+  // 1/8
+  "\u2582",
+  // 2/8
+  "\u2583",
+  // 3/8
+  "\u2584",
+  // 4/8
+  "\u2585",
+  // 5/8
+  "\u2586",
+  // 6/8
+  "\u2587",
+  // 7/8
+  "\u2588"
+  // 8/8 (full)
+];
+var BAR_CHARS = {
+  /** Solid block █ */
+  block: "\u2588",
+  /** Dark shade ▓ */
+  shaded: "\u2593",
+  /** Light shade ░ */
+  light: "\u2591",
+  /** Hash # */
+  hash: "#",
+  /** Equals = */
+  equals: "=",
+  /** Arrow > */
+  arrow: ">"
+};
+var BRAILLE_BASE = 10240;
+var BRAILLE_DOTS = {
+  topLeft: 1,
+  upperLeft: 2,
+  lowerLeft: 3,
+  bottomLeft: 7,
+  topRight: 4,
+  upperRight: 5,
+  lowerRight: 6,
+  bottomRight: 8
+};
+function valueToBlock(normalized) {
+  if (normalized <= 0) return " ";
+  const index = Math.min(7, Math.floor(normalized * 8));
+  return HEIGHT_BLOCKS[index] ?? "\u2588";
+}
+function getBarChar(style) {
+  return BAR_CHARS[style];
+}
+function toBrailleChar(dots) {
+  let pattern = 0;
+  for (const dot of dots) {
+    if (dot >= 1 && dot <= 8) {
+      pattern |= 1 << dot - 1;
+    }
+  }
+  return String.fromCharCode(BRAILLE_BASE + pattern);
+}
+var SERIES_STYLES = [
+  { char: "\u2588", useBackticks: false },
+  // Solid, plain
+  { char: "\u2588", useBackticks: true },
+  // Solid, highlighted
+  { char: "\u2593", useBackticks: false },
+  // Shaded, plain
+  { char: "\u2591", useBackticks: true }
+  // Light, highlighted
+];
+var SCATTER_MARKERS = {
+  circle: "\u25CF",
+  square: "\u25A0",
+  triangle: "\u25B2",
+  diamond: "\u25C6",
+  plus: "+"
+};
+var SCATTER_MARKER_SEQUENCE = ["\u25CF", "\u25A0", "\u25B2", "\u25C6", "+"];
+var HEATMAP_BLOCKS = [" ", "\u2591", "\u2592", "\u2593", "\u2588"];
+var HEATMAP_ASCII = [" ", ".", ":", "*", "#"];
+function valueToHeatmapChar(normalized, style) {
+  const chars = style === "blocks" ? HEATMAP_BLOCKS : HEATMAP_ASCII;
+  if (normalized <= 0) return chars[0];
+  if (normalized >= 1) return chars[chars.length - 1] ?? " ";
+  const index = Math.min(
+    chars.length - 1,
+    Math.floor(normalized * chars.length)
+  );
+  return chars[index] ?? " ";
+}
+var LINE_CHARS = {
+  /** Point marker */
+  point: "\u25CF",
+  /** Horizontal line */
+  horizontal: "\u2500",
+  /** Vertical line */
+  vertical: "\u2502",
+  /** Rising diagonal (approximation) */
+  rising: "\u2571",
+  /** Falling diagonal (approximation) */
+  falling: "\u2572"
+};
+var BRAILLE_DOT_MAP = {
+  "0,0": 1,
+  "0,1": 2,
+  "0,2": 3,
+  "0,3": 7,
+  "1,0": 4,
+  "1,1": 5,
+  "1,2": 6,
+  "1,3": 8
+};
+var BrailleCanvas = class {
+  /** Width in character cells */
+  width;
+  /** Height in character cells */
+  height;
+  /** Dot grid (width*2 x height*4) */
+  dots;
+  /** Series index for each dot (for coloring) */
+  seriesIndices;
+  constructor(width, height) {
+    this.width = width;
+    this.height = height;
+    const dotWidth = width * 2;
+    const dotHeight = height * 4;
+    this.dots = Array.from(
+      { length: dotHeight },
+      () => Array.from({ length: dotWidth }, () => false)
+    );
+    this.seriesIndices = Array.from(
+      { length: dotHeight },
+      () => Array.from({ length: dotWidth }, () => null)
+    );
+  }
+  /**
+   * Set a dot at the given dot coordinates.
+   */
+  setDot(dotX, dotY, seriesIndex = 0) {
+    if (dotX >= 0 && dotX < this.width * 2 && dotY >= 0 && dotY < this.height * 4) {
+      const dotRow = this.dots[dotY];
+      const seriesRow = this.seriesIndices[dotY];
+      if (dotRow && seriesRow) {
+        dotRow[dotX] = true;
+        seriesRow[dotX] = seriesIndex;
+      }
+    }
+  }
+  /**
+   * Draw a line between two points using Bresenham's algorithm.
+   * Coordinates are in dot space (width*2 x height*4).
+   */
+  drawLine(x0, y0, x1, y1, seriesIndex = 0) {
+    const dx = Math.abs(x1 - x0);
+    const dy = Math.abs(y1 - y0);
+    const sx = x0 < x1 ? 1 : -1;
+    const sy = y0 < y1 ? 1 : -1;
+    let err = dx - dy;
+    let x = x0;
+    let y = y0;
+    while (true) {
+      this.setDot(x, y, seriesIndex);
+      if (x === x1 && y === y1) break;
+      const e2 = 2 * err;
+      if (e2 > -dy) {
+        err -= dy;
+        x += sx;
+      }
+      if (e2 < dx) {
+        err += dx;
+        y += sy;
+      }
+    }
+  }
+  /**
+   * Draw a point marker (fills more dots for visibility).
+   */
+  drawPoint(dotX, dotY, seriesIndex = 0) {
+    for (let dy = -1; dy <= 1; dy++) {
+      for (let dx = -1; dx <= 1; dx++) {
+        this.setDot(dotX + dx, dotY + dy, seriesIndex);
+      }
+    }
+  }
+  /**
+   * Draw a circle outline using the midpoint circle algorithm.
+   * Coordinates are in dot space (width*2 x height*4).
+   *
+   * @param centerX - Center X in dot coordinates
+   * @param centerY - Center Y in dot coordinates
+   * @param radius - Radius in dot units
+   * @param seriesIndex - Series index for coloring
+   */
+  drawCircle(centerX, centerY, radius, seriesIndex = 0) {
+    if (radius <= 0) return;
+    let x = radius;
+    let y = 0;
+    let err = 1 - radius;
+    while (x >= y) {
+      this.setDot(centerX + x, centerY + y, seriesIndex);
+      this.setDot(centerX - x, centerY + y, seriesIndex);
+      this.setDot(centerX + x, centerY - y, seriesIndex);
+      this.setDot(centerX - x, centerY - y, seriesIndex);
+      this.setDot(centerX + y, centerY + x, seriesIndex);
+      this.setDot(centerX - y, centerY + x, seriesIndex);
+      this.setDot(centerX + y, centerY - x, seriesIndex);
+      this.setDot(centerX - y, centerY - x, seriesIndex);
+      y++;
+      if (err < 0) {
+        err += 2 * y + 1;
+      } else {
+        x--;
+        err += 2 * (y - x) + 1;
+      }
+    }
+  }
+  /**
+   * Draw an arc (portion of a circle).
+   * Angles are in radians, 0 = top (12 o'clock), increasing clockwise.
+   *
+   * @param centerX - Center X in dot coordinates
+   * @param centerY - Center Y in dot coordinates
+   * @param radius - Radius in dot units
+   * @param startAngle - Start angle in radians (0 = top)
+   * @param endAngle - End angle in radians
+   * @param seriesIndex - Series index for coloring
+   */
+  drawArc(centerX, centerY, radius, startAngle, endAngle, seriesIndex = 0) {
+    if (radius <= 0) return;
+    const twoPi = Math.PI * 2;
+    startAngle = (startAngle % twoPi + twoPi) % twoPi;
+    endAngle = (endAngle % twoPi + twoPi) % twoPi;
+    const arcLength = endAngle > startAngle ? endAngle - startAngle : twoPi - startAngle + endAngle;
+    const steps = Math.max(8, Math.ceil(radius * arcLength * 0.5));
+    for (let i = 0; i <= steps; i++) {
+      const t = i / steps;
+      let angle;
+      if (endAngle > startAngle) {
+        angle = startAngle + t * (endAngle - startAngle);
+      } else {
+        angle = startAngle + t * (twoPi - startAngle + endAngle);
+        if (angle >= twoPi) angle -= twoPi;
+      }
+      const mathAngle = angle - Math.PI / 2;
+      const x = Math.round(centerX + radius * Math.cos(mathAngle));
+      const y = Math.round(centerY + radius * Math.sin(mathAngle));
+      this.setDot(x, y, seriesIndex);
+    }
+  }
+  /**
+   * Fill a wedge (pie slice) from center to edge.
+   * Angles are in radians, 0 = top (12 o'clock), increasing clockwise.
+   *
+   * @param centerX - Center X in dot coordinates
+   * @param centerY - Center Y in dot coordinates
+   * @param radius - Outer radius in dot units
+   * @param startAngle - Start angle in radians (0 = top)
+   * @param endAngle - End angle in radians
+   * @param seriesIndex - Series index for coloring
+   * @param innerRadius - Inner radius for donut (0 for pie)
+   */
+  fillWedge(centerX, centerY, radius, startAngle, endAngle, seriesIndex = 0, innerRadius = 0) {
+    if (radius <= 0) return;
+    const twoPi = Math.PI * 2;
+    startAngle = (startAngle % twoPi + twoPi) % twoPi;
+    endAngle = (endAngle % twoPi + twoPi) % twoPi;
+    const arcLength = endAngle > startAngle ? endAngle - startAngle : twoPi - startAngle + endAngle;
+    const angleSteps = Math.max(8, Math.ceil(radius * arcLength * 0.3));
+    for (let i = 0; i <= angleSteps; i++) {
+      const t = i / angleSteps;
+      let angle;
+      if (endAngle > startAngle) {
+        angle = startAngle + t * (endAngle - startAngle);
+      } else {
+        angle = startAngle + t * (twoPi - startAngle + endAngle);
+        if (angle >= twoPi) angle -= twoPi;
+      }
+      const mathAngle = angle - Math.PI / 2;
+      const cos = Math.cos(mathAngle);
+      const sin = Math.sin(mathAngle);
+      const startR = Math.ceil(innerRadius);
+      for (let r = startR; r <= radius; r++) {
+        const x = Math.round(centerX + r * cos);
+        const y = Math.round(centerY + r * sin);
+        this.setDot(x, y, seriesIndex);
+      }
+    }
+  }
+  /**
+   * Get the braille character at the given character cell.
+   */
+  getChar(charX, charY) {
+    const dots = [];
+    const dotBaseX = charX * 2;
+    const dotBaseY = charY * 4;
+    for (let dy = 0; dy < 4; dy++) {
+      for (let dx = 0; dx < 2; dx++) {
+        const dotX = dotBaseX + dx;
+        const dotY = dotBaseY + dy;
+        const dotRow = this.dots[dotY];
+        if (dotY >= 0 && dotY < this.height * 4 && dotX >= 0 && dotX < this.width * 2 && dotRow?.[dotX]) {
+          const dotNum = BRAILLE_DOT_MAP[`${String(dx)},${String(dy)}`];
+          if (dotNum) {
+            dots.push(dotNum);
+          }
+        }
+      }
+    }
+    if (dots.length === 0) {
+      return " ";
+    }
+    return toBrailleChar(dots);
+  }
+  /**
+   * Get the dominant series index for a character cell.
+   */
+  getSeriesIndex(charX, charY) {
+    const counts = /* @__PURE__ */ new Map();
+    const dotBaseX = charX * 2;
+    const dotBaseY = charY * 4;
+    for (let dy = 0; dy < 4; dy++) {
+      for (let dx = 0; dx < 2; dx++) {
+        const dotX = dotBaseX + dx;
+        const dotY = dotBaseY + dy;
+        if (dotY >= 0 && dotY < this.height * 4 && dotX >= 0 && dotX < this.width * 2) {
+          const seriesRow = this.seriesIndices[dotY];
+          const idx = seriesRow?.[dotX];
+          if (idx !== null && idx !== void 0) {
+            counts.set(idx, (counts.get(idx) ?? 0) + 1);
+          }
+        }
+      }
+    }
+    let maxCount = 0;
+    let maxIndex = null;
+    for (const [idx, count] of counts) {
+      if (count > maxCount) {
+        maxCount = count;
+        maxIndex = idx;
+      }
+    }
+    return maxIndex;
+  }
+  /**
+   * Render the entire canvas to a 2D array of characters.
+   */
+  render() {
+    const chars = [];
+    const indices = [];
+    for (let y = 0; y < this.height; y++) {
+      const row = [];
+      const indexRow = [];
+      for (let x = 0; x < this.width; x++) {
+        row.push(this.getChar(x, y));
+        indexRow.push(this.getSeriesIndex(x, y));
+      }
+      chars.push(row);
+      indices.push(indexRow);
+    }
+    return { chars, seriesIndices: indices };
+  }
+};
+
+// src/layout/bar.ts
+function computeBarLayout(input) {
+  const isVertical = input.type === "bar-vertical";
+  const series = input.series;
+  const allValues = [];
+  const categorySet = /* @__PURE__ */ new Set();
+  for (const s of series) {
+    for (const point of s.data) {
+      allValues.push(point.y);
+      categorySet.add(String(point.x));
+    }
+  }
+  const categories = Array.from(categorySet);
+  const dataMin = Math.min(0, ...allValues);
+  const dataMax = Math.max(...allValues);
+  const yScale = computeNiceTicks({
+    dataMin,
+    dataMax,
+    tickCount: input.yAxis?.tickCount ?? 5,
+    includeZero: true,
+    forceMin: input.yAxis?.min,
+    forceMax: input.yAxis?.max
+  });
+  let maxLabelWidth = 0;
+  for (const category of categories) {
+    const width = getStringWidth(category);
+    if (width > maxLabelWidth) {
+      maxLabelWidth = width;
+    }
+  }
+  const barAreaSize = isVertical ? input.height - 2 : input.width - maxLabelWidth - 3;
+  const bars = [];
+  const formattedValues = [];
+  for (let seriesIndex = 0; seriesIndex < series.length; seriesIndex++) {
+    const s = series[seriesIndex];
+    if (!s) continue;
+    const styleIndex = seriesIndex % SERIES_STYLES.length;
+    const styleInfo = SERIES_STYLES[styleIndex];
+    if (!styleInfo) continue;
+    const barChar = s.style ? getBarChar(s.style) : styleInfo.char;
+    const useBackticks = s.style ? false : styleInfo.useBackticks;
+    for (let pointIndex = 0; pointIndex < s.data.length; pointIndex++) {
+      const point = s.data[pointIndex];
+      if (!point) continue;
+      const value = point.y;
+      const label = point.label ?? String(point.x);
+      const normalizedValue = scaleValue(
+        value,
+        yScale.min,
+        yScale.max,
+        barAreaSize
+      );
+      const length = Math.max(0, Math.round(normalizedValue));
+      const format = input.yAxis?.format ?? "number";
+      const decimals = input.yAxis?.decimals;
+      const formattedValue = formatTickValue(value, format, decimals);
+      formattedValues.push(formattedValue);
+      const percentage = yScale.max !== yScale.min ? (value - yScale.min) / (yScale.max - yScale.min) * 100 : 0;
+      bars.push({
+        seriesIndex,
+        pointIndex,
+        label,
+        value,
+        length,
+        formattedValue,
+        barChar,
+        useBackticks,
+        percentage
+      });
+    }
+  }
+  let maxValueWidth = 0;
+  for (const formatted of formattedValues) {
+    const width = getStringWidth(formatted);
+    if (width > maxValueWidth) {
+      maxValueWidth = width;
+    }
+  }
+  return {
+    type: isVertical ? "bar-vertical" : "bar",
+    bars,
+    categories,
+    maxLabelWidth,
+    maxValueWidth,
+    barAreaSize,
+    yScale,
+    showValues: input.showValues,
+    width: input.width,
+    height: input.height
+  };
+}
+function groupBarsByCategory(layout) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const bar of layout.bars) {
+    const existing = groups.get(bar.label);
+    if (existing) {
+      existing.push(bar);
+    } else {
+      groups.set(bar.label, [bar]);
+    }
+  }
+  return groups;
+}
+
+// src/layout/stacked-bar.ts
+import { getStringWidth as getStringWidth2 } from "@tuicomponents/core";
+function computeStackedBarLayout(input) {
+  const isVertical = input.type === "bar-stacked-vertical";
+  const series = input.series;
+  const categoryTotals = /* @__PURE__ */ new Map();
+  const categoryData = /* @__PURE__ */ new Map();
+  for (let seriesIndex = 0; seriesIndex < series.length; seriesIndex++) {
+    const s = series[seriesIndex];
+    if (!s) continue;
+    for (const point of s.data) {
+      const category = String(point.x);
+      const value = point.y;
+      const currentTotal = categoryTotals.get(category) ?? 0;
+      categoryTotals.set(category, currentTotal + value);
+      let seriesMap = categoryData.get(category);
+      if (!seriesMap) {
+        seriesMap = /* @__PURE__ */ new Map();
+        categoryData.set(category, seriesMap);
+      }
+      seriesMap.set(seriesIndex, value);
+    }
+  }
+  const categories = Array.from(categoryTotals.keys());
+  const maxTotal = Math.max(...categoryTotals.values());
+  const yScale = computeNiceTicks({
+    dataMin: 0,
+    dataMax: maxTotal,
+    tickCount: input.yAxis?.tickCount ?? 5,
+    includeZero: true,
+    forceMin: input.yAxis?.min,
+    forceMax: input.yAxis?.max
+  });
+  let maxLabelWidth = 0;
+  for (const category of categories) {
+    const width = getStringWidth2(category);
+    if (width > maxLabelWidth) {
+      maxLabelWidth = width;
+    }
+  }
+  const barAreaSize = isVertical ? input.height - 2 : input.width - maxLabelWidth - 3;
+  const stacks = [];
+  let maxValueWidth = 0;
+  for (const category of categories) {
+    const seriesMap = categoryData.get(category);
+    const total = categoryTotals.get(category);
+    if (!seriesMap || total === void 0) continue;
+    const segments = [];
+    let cumulativeValue = 0;
+    for (let seriesIndex = 0; seriesIndex < series.length; seriesIndex++) {
+      const value = seriesMap.get(seriesIndex) ?? 0;
+      if (value <= 0) continue;
+      const styleIndex = seriesIndex % SERIES_STYLES.length;
+      const styleInfo = SERIES_STYLES[styleIndex];
+      if (!styleInfo) continue;
+      const s = series[seriesIndex];
+      if (!s) continue;
+      const barChar = s.style ? getBarChar(s.style) : styleInfo.char;
+      const useBackticks = s.style ? false : styleInfo.useBackticks;
+      const startPos = scaleValue(
+        cumulativeValue,
+        yScale.min,
+        yScale.max,
+        barAreaSize
+      );
+      cumulativeValue += value;
+      const endPos = scaleValue(
+        cumulativeValue,
+        yScale.min,
+        yScale.max,
+        barAreaSize
+      );
+      const length = Math.max(1, Math.round(endPos - startPos));
+      const format = input.yAxis?.format ?? "number";
+      const decimals = input.yAxis?.decimals;
+      const formattedValue = formatTickValue(value, format, decimals);
+      const valueWidth = getStringWidth2(formattedValue);
+      if (valueWidth > maxValueWidth) {
+        maxValueWidth = valueWidth;
+      }
+      segments.push({
+        seriesIndex,
+        pointIndex: categories.indexOf(category),
+        label: category,
+        value,
+        length,
+        formattedValue,
+        barChar,
+        useBackticks,
+        percentage: total > 0 ? value / total * 100 : 0
+      });
+    }
+    stacks.push({
+      label: category,
+      segments,
+      total
+    });
+  }
+  const seriesNames = series.map((s) => s.name);
+  const seriesStyles = series.map((s, i) => {
+    const styleIndex = i % SERIES_STYLES.length;
+    const styleInfo = SERIES_STYLES[styleIndex];
+    if (!styleInfo) return null;
+    return {
+      char: s.style ? getBarChar(s.style) : styleInfo.char,
+      useBackticks: s.style ? false : styleInfo.useBackticks
+    };
+  }).filter(
+    (style) => style !== null
+  );
+  return {
+    type: isVertical ? "bar-stacked-vertical" : "bar-stacked",
+    stacks,
+    seriesNames,
+    seriesStyles,
+    maxLabelWidth,
+    maxValueWidth,
+    barAreaSize,
+    yScale,
+    showValues: input.showValues,
+    width: input.width,
+    height: input.height
+  };
+}
+
+// src/layout/line.ts
+import { getStringWidth as getStringWidth3 } from "@tuicomponents/core";
+var LINE_DRAW = {
+  horizontal: "\u2500",
+  point: "\u25CF",
+  rise: "\u2571",
+  fall: "\u2572"
+};
+function computeLineLayout(input) {
+  const series = input.series;
+  const lineStyle = input.lineStyle;
+  const allValues = [];
+  const categorySet = /* @__PURE__ */ new Set();
+  for (const s of series) {
+    for (const point of s.data) {
+      allValues.push(point.y);
+      categorySet.add(String(point.x));
+    }
+  }
+  const categories = Array.from(categorySet);
+  const seriesNames = series.map((s) => s.name);
+  const dataMin = Math.min(...allValues);
+  const dataMax = Math.max(...allValues);
+  const yScale = computeNiceTicks({
+    dataMin,
+    dataMax,
+    tickCount: input.yAxis?.tickCount ?? 5,
+    includeZero: input.yAxis?.min === void 0,
+    forceMin: input.yAxis?.min,
+    forceMax: input.yAxis?.max
+  });
+  let maxXLabelWidth = 0;
+  for (const category of categories) {
+    const width = getStringWidth3(category);
+    if (width > maxXLabelWidth) {
+      maxXLabelWidth = width;
+    }
+  }
+  let yAxisWidth = 0;
+  const format = input.yAxis?.format ?? "number";
+  const decimals = input.yAxis?.decimals;
+  for (const tick of yScale.ticks) {
+    const label = formatTickValue(tick, format, decimals);
+    const width = getStringWidth3(label);
+    if (width > yAxisWidth) {
+      yAxisWidth = width;
+    }
+  }
+  yAxisWidth += 2;
+  const chartHeight = input.height - 2;
+  if (lineStyle === "braille") {
+    return computeBrailleLayout(
+      input,
+      categories,
+      seriesNames,
+      series,
+      yScale,
+      yAxisWidth,
+      chartHeight,
+      format,
+      decimals
+    );
+  } else {
+    return computeBlocksLayout(
+      input,
+      categories,
+      seriesNames,
+      series,
+      yScale,
+      yAxisWidth,
+      chartHeight,
+      format,
+      decimals,
+      lineStyle
+    );
+  }
+}
+function computeBlocksLayout(input, categories, seriesNames, series, yScale, yAxisWidth, chartHeight, format, decimals, lineStyle) {
+  const chartWidth = categories.length * 2 - 1;
+  const points = [];
+  for (let seriesIndex = 0; seriesIndex < series.length; seriesIndex++) {
+    const s = series[seriesIndex];
+    if (!s) continue;
+    const seriesPoints = [];
+    for (const point of s.data) {
+      const categoryIndex = categories.indexOf(String(point.x));
+      const colPos = categoryIndex * 2;
+      const normalizedY = scaleValue(point.y, yScale.min, yScale.max, 1);
+      const clampedY = Math.max(0, Math.min(1, normalizedY));
+      seriesPoints.push({
+        x: colPos,
+        value: point.y,
+        normalizedY: clampedY,
+        seriesIndex
+      });
+    }
+    seriesPoints.sort((a, b) => a.x - b.x);
+    points.push(seriesPoints);
+  }
+  const grid = [];
+  const seriesGrid = [];
+  for (let row = 0; row < chartHeight; row++) {
+    grid.push(Array(chartWidth).fill(" "));
+    seriesGrid.push(Array(chartWidth).fill(null));
+  }
+  for (let seriesIndex = 0; seriesIndex < points.length; seriesIndex++) {
+    const seriesPoints = points[seriesIndex];
+    if (!seriesPoints) continue;
+    for (let i = 0; i < seriesPoints.length; i++) {
+      const p = seriesPoints[i];
+      if (!p) continue;
+      const row = Math.floor((1 - p.normalizedY) * (chartHeight - 1e-3));
+      const col = p.x;
+      if (row >= 0 && row < chartHeight && col >= 0 && col < chartWidth) {
+        const gridRow = grid[row];
+        const seriesGridRow = seriesGrid[row];
+        if (!gridRow || !seriesGridRow) continue;
+        gridRow[col] = lineStyle === "dots" ? "\u25CF" : LINE_DRAW.point;
+        seriesGridRow[col] = seriesIndex;
+        if (lineStyle !== "dots" && i < seriesPoints.length - 1) {
+          const nextP = seriesPoints[i + 1];
+          if (!nextP) continue;
+          const nextRow = Math.floor(
+            (1 - nextP.normalizedY) * (chartHeight - 1e-3)
+          );
+          const nextCol = nextP.x;
+          if (nextCol > col + 1) {
+            const rowDiff = nextRow - row;
+            const colDiff = nextCol - col;
+            for (let c = col + 1; c < nextCol; c++) {
+              const t = (c - col) / colDiff;
+              const interpRow = Math.round(row + rowDiff * t);
+              const interpGridRow = grid[interpRow];
+              const interpSeriesGridRow = seriesGrid[interpRow];
+              if (interpRow >= 0 && interpRow < chartHeight && interpGridRow?.[c] === " ") {
+                if (rowDiff < 0) {
+                  interpGridRow[c] = LINE_DRAW.rise;
+                } else if (rowDiff > 0) {
+                  interpGridRow[c] = LINE_DRAW.fall;
+                } else {
+                  interpGridRow[c] = LINE_DRAW.horizontal;
+                }
+                if (interpSeriesGridRow) {
+                  interpSeriesGridRow[c] = seriesIndex;
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  const rows = [];
+  for (let rowIndex = 0; rowIndex < chartHeight; rowIndex++) {
+    const rowBottom = 1 - (rowIndex + 1) / chartHeight;
+    const rowTop = 1 - rowIndex / chartHeight;
+    let yLabel;
+    let yValue = yScale.min + rowTop * (yScale.max - yScale.min);
+    for (const tick of yScale.ticks) {
+      const tickNormalized = (tick - yScale.min) / (yScale.max - yScale.min);
+      if (tickNormalized > rowBottom && tickNormalized <= rowTop) {
+        yLabel = formatTickValue(tick, format, decimals);
+        yValue = tick;
+        break;
+      }
+    }
+    const chars = grid[rowIndex];
+    const seriesIndices = seriesGrid[rowIndex];
+    if (!chars || !seriesIndices) continue;
+    const useBackticks = seriesIndices.map((idx) => {
+      if (idx === null) return false;
+      const styleIndex = idx % SERIES_STYLES.length;
+      return SERIES_STYLES[styleIndex]?.useBackticks ?? false;
+    });
+    rows.push({ yLabel, yValue, chars, useBackticks, seriesIndices });
+  }
+  return {
+    type: "line",
+    lineStyle: input.lineStyle,
+    categories,
+    seriesNames,
+    points,
+    rows,
+    yScale,
+    maxXLabelWidth: Math.max(...categories.map((c) => getStringWidth3(c))),
+    yAxisWidth,
+    width: input.width,
+    height: input.height,
+    showValues: input.showValues
+  };
+}
+function computeBrailleLayout(input, categories, seriesNames, series, yScale, yAxisWidth, chartHeight, format, decimals) {
+  const charsPerCategory = 3;
+  const chartWidth = categories.length * charsPerCategory;
+  const points = [];
+  for (let seriesIndex = 0; seriesIndex < series.length; seriesIndex++) {
+    const s = series[seriesIndex];
+    if (!s) continue;
+    const seriesPoints = [];
+    for (const point of s.data) {
+      const categoryIndex = categories.indexOf(String(point.x));
+      const colPos = categoryIndex * charsPerCategory + Math.floor(charsPerCategory / 2);
+      const normalizedY = scaleValue(point.y, yScale.min, yScale.max, 1);
+      const clampedY = Math.max(0, Math.min(1, normalizedY));
+      seriesPoints.push({
+        x: colPos,
+        value: point.y,
+        normalizedY: clampedY,
+        seriesIndex
+      });
+    }
+    seriesPoints.sort((a, b) => a.x - b.x);
+    points.push(seriesPoints);
+  }
+  const canvas = new BrailleCanvas(chartWidth, chartHeight);
+  for (let seriesIndex = 0; seriesIndex < points.length; seriesIndex++) {
+    const seriesPoints = points[seriesIndex];
+    if (!seriesPoints) continue;
+    for (let i = 0; i < seriesPoints.length; i++) {
+      const p = seriesPoints[i];
+      if (!p) continue;
+      const dotX = p.x * 2 + 1;
+      const dotY = Math.round((1 - p.normalizedY) * (chartHeight * 4 - 1));
+      if (i < seriesPoints.length - 1) {
+        const nextP = seriesPoints[i + 1];
+        if (nextP) {
+          const nextDotX = nextP.x * 2 + 1;
+          const nextDotY = Math.round(
+            (1 - nextP.normalizedY) * (chartHeight * 4 - 1)
+          );
+          canvas.drawLine(dotX, dotY, nextDotX, nextDotY, seriesIndex);
+        }
+      }
+      canvas.drawPoint(dotX, dotY, seriesIndex);
+    }
+  }
+  const rendered = canvas.render();
+  const rows = [];
+  for (let rowIndex = 0; rowIndex < chartHeight; rowIndex++) {
+    const rowBottom = 1 - (rowIndex + 1) / chartHeight;
+    const rowTop = 1 - rowIndex / chartHeight;
+    let yLabel;
+    let yValue = yScale.min + rowTop * (yScale.max - yScale.min);
+    for (const tick of yScale.ticks) {
+      const tickNormalized = (tick - yScale.min) / (yScale.max - yScale.min);
+      if (tickNormalized > rowBottom && tickNormalized <= rowTop) {
+        yLabel = formatTickValue(tick, format, decimals);
+        yValue = tick;
+        break;
+      }
+    }
+    const chars = rendered.chars[rowIndex] ?? [];
+    const seriesIndices = rendered.seriesIndices[rowIndex] ?? [];
+    const useBackticks = seriesIndices.map((idx) => {
+      if (idx === null) return false;
+      const styleIndex = idx % SERIES_STYLES.length;
+      return SERIES_STYLES[styleIndex]?.useBackticks ?? false;
+    });
+    rows.push({ yLabel, yValue, chars, useBackticks, seriesIndices });
+  }
+  return {
+    type: "line",
+    lineStyle: input.lineStyle,
+    categories,
+    seriesNames,
+    points,
+    rows,
+    yScale,
+    maxXLabelWidth: Math.max(...categories.map((c) => getStringWidth3(c))),
+    yAxisWidth,
+    width: input.width,
+    height: input.height,
+    showValues: input.showValues
+  };
+}
+
+// src/layout/area.ts
+import { getStringWidth as getStringWidth4 } from "@tuicomponents/core";
+function computeAreaLayout(input) {
+  const isStacked = input.type === "area-stacked";
+  const series = input.series;
+  const lineStyle = input.lineStyle;
+  const categoryData = /* @__PURE__ */ new Map();
+  const categories = [];
+  for (const s of series) {
+    for (const point of s.data) {
+      const category = String(point.x);
+      if (!categoryData.has(category)) {
+        categoryData.set(
+          category,
+          new Array(series.length).fill(0)
+        );
+        categories.push(category);
+      }
+    }
+  }
+  for (let seriesIndex = 0; seriesIndex < series.length; seriesIndex++) {
+    const s = series[seriesIndex];
+    if (!s) continue;
+    for (const point of s.data) {
+      const category = String(point.x);
+      const values = categoryData.get(category);
+      if (!values) continue;
+      values[seriesIndex] = point.y;
+    }
+  }
+  let maxValue = 0;
+  const columns = [];
+  for (let i = 0; i < categories.length; i++) {
+    const category = categories[i];
+    if (!category) continue;
+    const values = categoryData.get(category);
+    if (!values) continue;
+    const cumulativeValues = [];
+    let cumulative = 0;
+    for (const value of values) {
+      if (isStacked) {
+        cumulative += value;
+        cumulativeValues.push(cumulative);
+      } else {
+        cumulativeValues.push(value);
+        if (value > cumulative) cumulative = value;
+      }
+    }
+    if (cumulative > maxValue) maxValue = cumulative;
+    columns.push({
+      x: i,
+      label: category,
+      cumulativeValues,
+      normalizedHeights: []
+      // Fill in after we have scale
+    });
+  }
+  const yScale = computeNiceTicks({
+    dataMin: 0,
+    dataMax: maxValue,
+    tickCount: input.yAxis?.tickCount ?? 5,
+    includeZero: true,
+    forceMin: input.yAxis?.min,
+    forceMax: input.yAxis?.max
+  });
+  for (const column of columns) {
+    column.normalizedHeights = column.cumulativeValues.map(
+      (v) => scaleValue(v, yScale.min, yScale.max, 1)
+    );
+  }
+  let yAxisWidth = 0;
+  const format = input.yAxis?.format ?? "number";
+  const decimals = input.yAxis?.decimals;
+  for (const tick of yScale.ticks) {
+    const label = formatTickValue(tick, format, decimals);
+    const width = getStringWidth4(label);
+    if (width > yAxisWidth) {
+      yAxisWidth = width;
+    }
+  }
+  yAxisWidth += 2;
+  const seriesNames = series.map((s) => s.name);
+  const seriesStyles = series.map((_, i) => {
+    const styleIndex = i % SERIES_STYLES.length;
+    const style = SERIES_STYLES[styleIndex];
+    if (!style) throw new Error(`Invalid style index: ${String(styleIndex)}`);
+    return style;
+  });
+  const chartHeight = input.height - 2;
+  const rows = [];
+  for (let rowIndex = 0; rowIndex < chartHeight; rowIndex++) {
+    const rowBottom = 1 - (rowIndex + 1) / chartHeight;
+    const rowTop = 1 - rowIndex / chartHeight;
+    let yLabel;
+    for (const tick of yScale.ticks) {
+      const tickNormalized = (tick - yScale.min) / (yScale.max - yScale.min);
+      if (tickNormalized > rowBottom && tickNormalized <= rowTop) {
+        yLabel = formatTickValue(tick, format, decimals);
+        break;
+      }
+    }
+    const chars = [];
+    const useBackticks = [];
+    const fillChars = [];
+    for (const column of columns) {
+      let activeSeriesIndex = -1;
+      let fillLevel = 0;
+      for (let seriesIndex = column.normalizedHeights.length - 1; seriesIndex >= 0; seriesIndex--) {
+        const height = column.normalizedHeights[seriesIndex];
+        if (height === void 0) continue;
+        const prevHeight = seriesIndex > 0 ? column.normalizedHeights[seriesIndex - 1] ?? 0 : 0;
+        if (height > rowBottom && prevHeight < rowTop) {
+          activeSeriesIndex = seriesIndex;
+          const effectiveTop = Math.min(height, rowTop);
+          const effectiveBottom = Math.max(prevHeight, rowBottom);
+          fillLevel = (effectiveTop - effectiveBottom) / (rowTop - rowBottom);
+          break;
+        }
+      }
+      if (activeSeriesIndex >= 0) {
+        const char = valueToBlock(fillLevel);
+        const style = seriesStyles[activeSeriesIndex];
+        if (!style) {
+          chars.push(" ");
+          useBackticks.push(false);
+          fillChars.push(" ");
+        } else {
+          chars.push(char);
+          useBackticks.push(style.useBackticks);
+          fillChars.push(style.char);
+        }
+      } else {
+        chars.push(" ");
+        useBackticks.push(false);
+        fillChars.push(" ");
+      }
+    }
+    rows.push({
+      yLabel,
+      chars,
+      useBackticks,
+      fillChars
+    });
+  }
+  return {
+    type: isStacked ? "area-stacked" : "area",
+    lineStyle,
+    categories,
+    seriesNames,
+    seriesStyles,
+    columns,
+    rows,
+    yScale,
+    yAxisWidth,
+    width: input.width,
+    height: input.height,
+    showValues: input.showValues
+  };
+}
+
+// src/layout/scatter.ts
+import { getStringWidth as getStringWidth5 } from "@tuicomponents/core";
+function computeScatterLayout(input) {
+  const series = input.series;
+  const scatterStyle = input.scatterStyle;
+  const allXValues = [];
+  const allYValues = [];
+  for (const s of series) {
+    for (const point of s.data) {
+      const xVal = typeof point.x === "number" ? point.x : parseFloat(point.x);
+      if (!isNaN(xVal)) {
+        allXValues.push(xVal);
+      }
+      allYValues.push(point.y);
+    }
+  }
+  if (allXValues.length === 0 || allYValues.length === 0) {
+    return {
+      type: "scatter",
+      scatterStyle,
+      seriesNames: series.map((s) => s.name),
+      points: [],
+      xScale: { min: 0, max: 100, step: 20, ticks: [0, 20, 40, 60, 80, 100] },
+      yScale: { min: 0, max: 100, step: 20, ticks: [0, 20, 40, 60, 80, 100] },
+      yAxisWidth: 6,
+      chartWidth: input.width - 6,
+      chartHeight: input.height - 2,
+      width: input.width,
+      height: input.height
+    };
+  }
+  const seriesNames = series.map((s) => s.name);
+  const xDataMin = Math.min(...allXValues);
+  const xDataMax = Math.max(...allXValues);
+  const yDataMin = Math.min(...allYValues);
+  const yDataMax = Math.max(...allYValues);
+  const xScale = computeNiceTicks({
+    dataMin: xDataMin,
+    dataMax: xDataMax,
+    tickCount: input.xAxis?.tickCount ?? 5,
+    includeZero: input.xAxis?.min === void 0,
+    forceMin: input.xAxis?.min,
+    forceMax: input.xAxis?.max
+  });
+  const yScale = computeNiceTicks({
+    dataMin: yDataMin,
+    dataMax: yDataMax,
+    tickCount: input.yAxis?.tickCount ?? 5,
+    includeZero: input.yAxis?.min === void 0,
+    forceMin: input.yAxis?.min,
+    forceMax: input.yAxis?.max
+  });
+  const yFormat = input.yAxis?.format ?? "number";
+  const yDecimals = input.yAxis?.decimals;
+  let yAxisWidth = 0;
+  for (const tick of yScale.ticks) {
+    const label = formatTickValue(tick, yFormat, yDecimals);
+    const width = getStringWidth5(label);
+    if (width > yAxisWidth) {
+      yAxisWidth = width;
+    }
+  }
+  yAxisWidth += 2;
+  const chartHeight = input.height - 2;
+  const chartWidth = input.width - yAxisWidth - 1;
+  const points = [];
+  for (let seriesIndex = 0; seriesIndex < series.length; seriesIndex++) {
+    const s = series[seriesIndex];
+    if (!s) continue;
+    for (const point of s.data) {
+      const xVal = typeof point.x === "number" ? point.x : parseFloat(point.x);
+      if (isNaN(xVal)) continue;
+      const normalizedX = scaleValue(xVal, xScale.min, xScale.max, 1);
+      const normalizedY = scaleValue(point.y, yScale.min, yScale.max, 1);
+      const charX = Math.round(
+        Math.max(0, Math.min(1, normalizedX)) * (chartWidth - 1)
+      );
+      const charY = Math.round(
+        (1 - Math.max(0, Math.min(1, normalizedY))) * (chartHeight - 1)
+      );
+      points.push({
+        dataX: xVal,
+        dataY: point.y,
+        charX,
+        charY,
+        seriesIndex
+      });
+    }
+  }
+  if (scatterStyle === "braille") {
+    return computeBrailleScatterLayout(
+      input,
+      seriesNames,
+      points,
+      xScale,
+      yScale,
+      yAxisWidth,
+      chartWidth,
+      chartHeight
+    );
+  } else {
+    return computeDotsScatterLayout(
+      input,
+      seriesNames,
+      points,
+      xScale,
+      yScale,
+      yAxisWidth,
+      chartWidth,
+      chartHeight
+    );
+  }
+}
+function computeDotsScatterLayout(input, seriesNames, points, xScale, yScale, yAxisWidth, chartWidth, chartHeight) {
+  const grid = [];
+  const seriesIndices = [];
+  for (let row = 0; row < chartHeight; row++) {
+    grid.push(Array(chartWidth).fill(" "));
+    seriesIndices.push(Array(chartWidth).fill(null));
+  }
+  for (const point of points) {
+    if (point.charY >= 0 && point.charY < chartHeight && point.charX >= 0 && point.charX < chartWidth) {
+      const marker = SCATTER_MARKER_SEQUENCE[point.seriesIndex % SCATTER_MARKER_SEQUENCE.length];
+      if (!marker) continue;
+      const gridRow = grid[point.charY];
+      const seriesRow = seriesIndices[point.charY];
+      if (!gridRow || !seriesRow) continue;
+      gridRow[point.charX] = marker;
+      seriesRow[point.charX] = point.seriesIndex;
+    }
+  }
+  return {
+    type: "scatter",
+    scatterStyle: "dots",
+    seriesNames,
+    points,
+    xScale,
+    yScale,
+    yAxisWidth,
+    chartWidth,
+    chartHeight,
+    width: input.width,
+    height: input.height,
+    grid,
+    seriesIndices
+  };
+}
+function computeBrailleScatterLayout(input, seriesNames, points, xScale, yScale, yAxisWidth, chartWidth, chartHeight) {
+  const canvas = new BrailleCanvas(chartWidth, chartHeight);
+  for (const point of points) {
+    const dotX = Math.round(
+      scaleValue(point.dataX, xScale.min, xScale.max, chartWidth * 2 - 1)
+    );
+    const normalizedY = scaleValue(point.dataY, yScale.min, yScale.max, 1);
+    const dotY = Math.round((1 - normalizedY) * (chartHeight * 4 - 1));
+    canvas.drawPoint(dotX, dotY, point.seriesIndex);
+  }
+  const rendered = canvas.render();
+  return {
+    type: "scatter",
+    scatterStyle: "braille",
+    seriesNames,
+    points,
+    xScale,
+    yScale,
+    yAxisWidth,
+    chartWidth,
+    chartHeight,
+    width: input.width,
+    height: input.height,
+    brailleChars: rendered.chars,
+    brailleSeriesIndices: rendered.seriesIndices
+  };
+}
+
+// src/layout/pie.ts
+function computePieLayout(input) {
+  const type = input.type;
+  const series = input.series;
+  const slicesData = [];
+  for (const s of series) {
+    for (const point of s.data) {
+      const label = point.label ?? String(point.x);
+      if (point.y > 0) {
+        slicesData.push({ label, value: point.y });
+      }
+    }
+  }
+  const total = slicesData.reduce((sum, s) => sum + s.value, 0);
+  if (total === 0 || slicesData.length === 0) {
+    return {
+      type,
+      slices: [],
+      total: 0,
+      radius: 0,
+      centerX: Math.floor(input.width / 2),
+      centerY: Math.floor(input.height / 2),
+      innerRadius: 0,
+      ...input.centerLabel !== void 0 && {
+        centerLabel: input.centerLabel
+      },
+      width: input.width,
+      height: input.height,
+      brailleChars: [],
+      brailleSeriesIndices: [],
+      seriesStyles: SERIES_STYLES
+    };
+  }
+  const chartHeight = input.height - 2;
+  const chartWidth = input.width;
+  const maxRadiusY = Math.floor(chartHeight / 2);
+  const maxRadiusX = Math.floor(chartWidth / 2);
+  const radius = Math.min(maxRadiusX, maxRadiusY);
+  const centerX = Math.floor(chartWidth / 2);
+  const centerY = Math.floor(chartHeight / 2);
+  const innerRadiusRatio = type === "donut" ? input.innerRadius : 0;
+  const slices = [];
+  let currentAngle = 0;
+  for (let i = 0; i < slicesData.length; i++) {
+    const data = slicesData[i];
+    if (!data) continue;
+    const percentage = data.value / total * 100;
+    const arcAngle = data.value / total * Math.PI * 2;
+    const style = SERIES_STYLES[i % SERIES_STYLES.length];
+    if (!style) continue;
+    slices.push({
+      label: data.label,
+      value: data.value,
+      percentage,
+      startAngle: currentAngle,
+      endAngle: currentAngle + arcAngle,
+      barChar: style.char,
+      useBackticks: style.useBackticks,
+      seriesIndex: i
+    });
+    currentAngle += arcAngle;
+  }
+  const canvas = new BrailleCanvas(chartWidth, chartHeight);
+  const dotCenterX = centerX * 2;
+  const dotCenterY = centerY * 4;
+  const dotRadiusX = radius * 2;
+  const dotRadiusY = radius * 4;
+  const dotRadius = Math.min(dotRadiusX, dotRadiusY);
+  const _dotInnerRadius = dotRadius * innerRadiusRatio;
+  for (const slice of slices) {
+    drawEllipticalWedge(
+      canvas,
+      dotCenterX,
+      dotCenterY,
+      dotRadiusX,
+      dotRadiusY,
+      slice.startAngle,
+      slice.endAngle,
+      slice.seriesIndex,
+      dotRadiusX * innerRadiusRatio,
+      dotRadiusY * innerRadiusRatio
+    );
+  }
+  const rendered = canvas.render();
+  return {
+    type,
+    slices,
+    total,
+    radius,
+    centerX,
+    centerY,
+    innerRadius: radius * innerRadiusRatio,
+    ...input.centerLabel !== void 0 && { centerLabel: input.centerLabel },
+    width: input.width,
+    height: input.height,
+    brailleChars: rendered.chars,
+    brailleSeriesIndices: rendered.seriesIndices,
+    seriesStyles: SERIES_STYLES
+  };
+}
+function drawEllipticalWedge(canvas, centerX, centerY, radiusX, radiusY, startAngle, endAngle, seriesIndex, innerRadiusX, innerRadiusY) {
+  if (radiusX <= 0 || radiusY <= 0) return;
+  const twoPi = Math.PI * 2;
+  startAngle = (startAngle % twoPi + twoPi) % twoPi;
+  endAngle = (endAngle % twoPi + twoPi) % twoPi;
+  const arcLength = endAngle > startAngle ? endAngle - startAngle : twoPi - startAngle + endAngle;
+  const avgRadius = (radiusX + radiusY) / 2;
+  const angleSteps = Math.max(16, Math.ceil(avgRadius * arcLength * 0.4));
+  for (let i = 0; i <= angleSteps; i++) {
+    const t = i / angleSteps;
+    let angle;
+    if (endAngle > startAngle) {
+      angle = startAngle + t * (endAngle - startAngle);
+    } else {
+      angle = startAngle + t * (twoPi - startAngle + endAngle);
+      if (angle >= twoPi) angle -= twoPi;
+    }
+    const mathAngle = angle - Math.PI / 2;
+    const cos = Math.cos(mathAngle);
+    const sin = Math.sin(mathAngle);
+    const maxR = Math.max(radiusX, radiusY);
+    const innerR = Math.max(innerRadiusX, innerRadiusY);
+    for (let r = Math.ceil(innerR); r <= maxR; r++) {
+      const scaleX = radiusX / maxR;
+      const scaleY = radiusY / maxR;
+      const x = Math.round(centerX + r * cos * scaleX);
+      const y = Math.round(centerY + r * sin * scaleY);
+      canvas.setDot(x, y, seriesIndex);
+    }
+  }
+}
+
+// src/layout/heatmap.ts
+import { getStringWidth as getStringWidth6 } from "@tuicomponents/core";
+function computeHeatmapLayout(input) {
+  const series = input.series;
+  const heatmapStyle = input.heatmapStyle;
+  const rowLabelSet = /* @__PURE__ */ new Set();
+  const colLabelSet = /* @__PURE__ */ new Set();
+  const valueMap = /* @__PURE__ */ new Map();
+  for (const s of series) {
+    for (const point of s.data) {
+      const colLabel = String(point.x);
+      const rowLabel = point.label ?? s.name;
+      const value = point.y;
+      rowLabelSet.add(rowLabel);
+      colLabelSet.add(colLabel);
+      valueMap.set(JSON.stringify([rowLabel, colLabel]), value);
+    }
+  }
+  const rowLabels = Array.from(rowLabelSet);
+  const colLabels = Array.from(colLabelSet);
+  const values = Array.from(valueMap.values());
+  const minValue = values.length > 0 ? Math.min(...values) : 0;
+  const maxValue = values.length > 0 ? Math.max(...values) : 1;
+  const valueRange = { min: minValue, max: maxValue };
+  let rowLabelWidth = 0;
+  for (const label of rowLabels) {
+    const width = getStringWidth6(label);
+    if (width > rowLabelWidth) {
+      rowLabelWidth = width;
+    }
+  }
+  rowLabelWidth += 2;
+  let cellWidth;
+  if (heatmapStyle === "numeric") {
+    const maxValueWidth = Math.max(
+      getStringWidth6(formatValue(minValue)),
+      getStringWidth6(formatValue(maxValue))
+    );
+    cellWidth = Math.max(3, maxValueWidth + 1);
+  } else {
+    cellWidth = 2;
+  }
+  let colLabelWidth = cellWidth;
+  for (const label of colLabels) {
+    const width = getStringWidth6(label);
+    if (width > colLabelWidth) {
+      colLabelWidth = width;
+    }
+  }
+  const cells = [];
+  for (let rowIdx = 0; rowIdx < rowLabels.length; rowIdx++) {
+    const rowLabel = rowLabels[rowIdx];
+    if (!rowLabel) continue;
+    const rowCells = [];
+    for (let colIdx = 0; colIdx < colLabels.length; colIdx++) {
+      const colLabel = colLabels[colIdx];
+      if (!colLabel) continue;
+      const key = JSON.stringify([rowLabel, colLabel]);
+      const value = valueMap.get(key) ?? 0;
+      const range = maxValue - minValue;
+      const normalizedValue = range > 0 ? (value - minValue) / range : 0.5;
+      let displayChar;
+      if (heatmapStyle === "numeric") {
+        displayChar = formatValue(value);
+      } else {
+        const baseChar = valueToHeatmapChar(
+          normalizedValue,
+          heatmapStyle === "blocks" ? "blocks" : "ascii"
+        );
+        displayChar = baseChar.repeat(cellWidth);
+      }
+      rowCells.push({
+        row: rowIdx,
+        col: colIdx,
+        value,
+        normalizedValue,
+        displayChar
+      });
+    }
+    cells.push(rowCells);
+  }
+  return {
+    type: "heatmap",
+    heatmapStyle,
+    rowLabels,
+    colLabels,
+    cells,
+    valueRange,
+    cellWidth,
+    colLabelWidth,
+    rowLabelWidth,
+    width: input.width,
+    height: input.height
+  };
+}
+function formatValue(value) {
+  if (Number.isInteger(value)) {
+    return String(value);
+  }
+  if (Math.abs(value) >= 100) {
+    return value.toFixed(0);
+  }
+  if (Math.abs(value) >= 10) {
+    return value.toFixed(1);
+  }
+  return value.toFixed(2);
+}
+
+// src/renderers/ansi.ts
+import { padToWidth as padToWidth2 } from "@tuicomponents/core";
+
+// src/core/legend.ts
+import { getStringWidth as getStringWidth7 } from "@tuicomponents/core";
+function getLegendItemWidth(item) {
+  const baseWidth = getStringWidth7(item.symbol) + 1 + getStringWidth7(item.name);
+  if (item.useBackticks) {
+    return baseWidth + 1;
+  }
+  return baseWidth;
+}
+function formatLegendItem(item, forMarkdown) {
+  if (forMarkdown && item.useBackticks) {
+    return ` \`${item.symbol}\` ${item.name}`;
+  }
+  return `${item.symbol} ${item.name}`;
+}
+function computeLegendLayout(options) {
+  const { items, position, boxed = false, maxWidth = 80 } = options;
+  if (position === "none" || items.length === 0) {
+    return {
+      position,
+      boxed,
+      rows: [],
+      totalWidth: 0,
+      totalHeight: 0
+    };
+  }
+  const itemWidths = items.map((item) => getLegendItemWidth(item));
+  const _separator = "  ";
+  const separatorWidth = 2;
+  const rows = [];
+  let currentRow = [];
+  let currentWidth = 0;
+  for (let i = 0; i < items.length; i++) {
+    const item = items[i];
+    const itemWidth = itemWidths[i];
+    if (!item || itemWidth === void 0) continue;
+    const widthWithSeparator = currentRow.length > 0 ? itemWidth + separatorWidth : itemWidth;
+    if (currentWidth + widthWithSeparator > maxWidth && currentRow.length > 0) {
+      rows.push({ items: currentRow, width: currentWidth });
+      currentRow = [item];
+      currentWidth = itemWidth;
+    } else {
+      currentRow.push(item);
+      currentWidth += widthWithSeparator;
+    }
+  }
+  if (currentRow.length > 0) {
+    rows.push({ items: currentRow, width: currentWidth });
+  }
+  const totalWidth = Math.max(...rows.map((r) => r.width));
+  const totalHeight = rows.length + (boxed ? 2 : 0);
+  return {
+    position,
+    boxed,
+    rows,
+    totalWidth,
+    totalHeight
+  };
+}
+function renderLegendRow(row, forMarkdown) {
+  return row.items.map((item) => formatLegendItem(item, forMarkdown)).join("  ");
+}
+
+// src/core/axis-renderer.ts
+import { padToWidth } from "@tuicomponents/core";
+function computeYAxisRow(row, config) {
+  const {
+    scale,
+    chartHeight,
+    labelWidth,
+    format = "number",
+    decimals
+  } = config;
+  const rowBottom = row / chartHeight;
+  const rowTop = (row + 1) / chartHeight;
+  let label = " ".repeat(labelWidth);
+  let hasTick = false;
+  for (const tick of scale.ticks) {
+    const tickNorm = (tick - scale.min) / (scale.max - scale.min);
+    if (tickNorm < 1e-3) continue;
+    const epsilon = 1e-3;
+    if (tickNorm > rowBottom - epsilon && tickNorm <= rowTop) {
+      label = padToWidth(formatTickValue(tick, format, decimals), labelWidth - 1) + " ";
+      hasTick = true;
+      break;
+    }
+  }
+  const axisChar = hasTick ? AXIS_CHARS.yTickLeft : AXIS_CHARS.vertical;
+  return { label, hasTick, axisChar };
+}
+function renderXAxis(config) {
+  const {
+    categories,
+    barWidth,
+    yAxisWidth,
+    chartWidth,
+    minValue,
+    format = "number",
+    decimals
+  } = config;
+  const zeroLabel = padToWidth(formatTickValue(minValue, format, decimals), yAxisWidth - 1) + " ";
+  let xAxisLine = "";
+  for (let i = 0; i < categories.length; i++) {
+    const tickPos = Math.floor(barWidth / 2);
+    const beforeTick = AXIS_CHARS.horizontal.repeat(tickPos);
+    const afterTick = AXIS_CHARS.horizontal.repeat(barWidth - tickPos - 1);
+    xAxisLine += beforeTick + AXIS_CHARS.xTick + afterTick;
+    if (i < categories.length - 1) {
+      xAxisLine += AXIS_CHARS.horizontal;
+    }
+  }
+  const remaining = chartWidth - yAxisWidth - xAxisLine.length - 1;
+  if (remaining > 0) {
+    xAxisLine += AXIS_CHARS.horizontal.repeat(remaining);
+  }
+  const fullAxisLine = zeroLabel + AXIS_CHARS.origin + xAxisLine;
+  let labelLine = "";
+  for (let i = 0; i < categories.length; i++) {
+    const label = categories[i];
+    if (!label) continue;
+    const tickPos = Math.floor(barWidth / 2);
+    const labelStart = Math.max(0, tickPos - Math.floor(label.length / 2));
+    const labelEnd = labelStart + label.length;
+    const paddingBefore = " ".repeat(labelStart);
+    const paddingAfter = " ".repeat(Math.max(0, barWidth - labelEnd));
+    labelLine += paddingBefore + label + paddingAfter;
+    if (i < categories.length - 1) {
+      labelLine += " ";
+    }
+  }
+  const fullLabelLine = " ".repeat(yAxisWidth + 1) + labelLine;
+  return {
+    axisLine: fullAxisLine,
+    labelLine: fullLabelLine
+  };
+}
+function buildChartRow(row, content, config) {
+  const { label, axisChar } = computeYAxisRow(row, config);
+  return `${label}${axisChar}${content}`;
+}
+
+// src/renderers/ansi.ts
+function renderLegendRowAnsi(row, theme) {
+  return row.items.map((item) => {
+    const symbol = item.useBackticks && theme ? theme.semantic.secondary(item.symbol) : theme ? theme.semantic.primary(item.symbol) : item.symbol;
+    return `${symbol} ${item.name}`;
+  }).join("  ");
+}
+function renderBarChartAnsi(layout, options) {
+  const { theme } = options;
+  const lines = [];
+  for (const bar of layout.bars) {
+    const label = padToWidth2(bar.label, layout.maxLabelWidth);
+    const coloredLabel = theme ? theme.semantic.header(label) : label;
+    const barStr = bar.barChar.repeat(bar.length);
+    const coloredBar = theme ? theme.semantic.primary(barStr) : barStr;
+    const coloredValue = theme ? theme.semantic.secondary(bar.formattedValue) : bar.formattedValue;
+    if (layout.showValues) {
+      lines.push(`${coloredLabel} ${coloredBar} ${coloredValue}`);
+    } else {
+      lines.push(`${coloredLabel} ${coloredBar}`);
+    }
+  }
+  return lines.join("\n");
+}
+function renderVerticalBarChartAnsi(layout, options) {
+  const { theme, input } = options;
+  const lines = [];
+  const chartHeight = layout.barAreaSize;
+  const numBars = layout.bars.length;
+  const barWidth = Math.max(1, Math.floor((layout.width - 2) / numBars) - 1);
+  const yAxisWidth = layout.maxValueWidth + 2;
+  const format = input.yAxis?.format ?? "number";
+  const decimals = input.yAxis?.decimals;
+  for (let row = chartHeight - 1; row >= 0; row--) {
+    const rowThreshold = (row + 1) / chartHeight;
+    let yLabel = " ".repeat(yAxisWidth);
+    for (const tick of layout.yScale.ticks) {
+      const tickNorm = (tick - layout.yScale.min) / (layout.yScale.max - layout.yScale.min);
+      if (Math.abs(tickNorm - rowThreshold) < 0.5 / chartHeight) {
+        yLabel = padToWidth2(formatTickValue(tick, format, decimals), yAxisWidth - 1) + " ";
+        break;
+      }
+    }
+    const axisChar = row === 0 ? AXIS_CHARS.origin : AXIS_CHARS.vertical;
+    const segments = [];
+    for (const bar of layout.bars) {
+      const barNorm = bar.length / layout.barAreaSize;
+      if (barNorm >= rowThreshold) {
+        const barSegment = bar.barChar.repeat(barWidth);
+        segments.push(theme ? theme.semantic.primary(barSegment) : barSegment);
+      } else {
+        segments.push(" ".repeat(barWidth));
+      }
+    }
+    lines.push(`${yLabel}${axisChar}${segments.join(" ")}`);
+  }
+  const xAxisLine = AXIS_CHARS.horizontal.repeat(layout.width - yAxisWidth - 1);
+  lines.push(" ".repeat(yAxisWidth) + AXIS_CHARS.origin + xAxisLine);
+  const xLabels = [];
+  for (const bar of layout.bars) {
+    xLabels.push(padToWidth2(bar.label, barWidth));
+  }
+  lines.push(" ".repeat(yAxisWidth + 1) + xLabels.join(" "));
+  return lines.join("\n");
+}
+function renderStackedBarChartAnsi(layout, options) {
+  const { theme, input } = options;
+  const lines = [];
+  const isVertical = layout.type === "bar-stacked-vertical";
+  if (isVertical) {
+    const chartHeight = layout.barAreaSize;
+    const numStacks = layout.stacks.length;
+    const barWidth = Math.max(
+      1,
+      Math.floor((layout.width - 2) / numStacks) - 1
+    );
+    const yAxisWidth = layout.maxValueWidth + 2;
+    const format = input.yAxis?.format ?? "number";
+    const decimals = input.yAxis?.decimals;
+    const yAxisConfig = {
+      scale: layout.yScale,
+      chartHeight,
+      labelWidth: yAxisWidth,
+      format,
+      decimals
+    };
+    for (let row = chartHeight - 1; row >= 0; row--) {
+      const rowBottom = row / chartHeight;
+      const rowTop = (row + 1) / chartHeight;
+      const { label: yLabel, axisChar } = computeYAxisRow(row, yAxisConfig);
+      const segments = [];
+      for (const stack of layout.stacks) {
+        let activeSegment = null;
+        let cumHeight = 0;
+        for (const segment of stack.segments) {
+          const segmentHeight = segment.length / layout.barAreaSize;
+          if (rowBottom < cumHeight + segmentHeight && rowTop > cumHeight) {
+            activeSegment = segment;
+            break;
+          }
+          cumHeight += segmentHeight;
+        }
+        if (activeSegment) {
+          const barSegment = activeSegment.barChar.repeat(barWidth);
+          segments.push(
+            theme ? theme.semantic.primary(barSegment) : barSegment
+          );
+        } else {
+          segments.push(" ".repeat(barWidth));
+        }
+      }
+      lines.push(`${yLabel}${axisChar}${segments.join(" ")}`);
+    }
+    const xAxis = renderXAxis({
+      categories: layout.stacks.map((s) => s.label),
+      barWidth,
+      yAxisWidth,
+      chartWidth: layout.width,
+      minValue: layout.yScale.min,
+      format,
+      decimals
+    });
+    lines.push(xAxis.axisLine);
+    lines.push(xAxis.labelLine);
+  } else {
+    for (const stack of layout.stacks) {
+      const label = padToWidth2(stack.label, layout.maxLabelWidth);
+      const coloredLabel = theme ? theme.semantic.header(label) : label;
+      let barStr = "";
+      for (const segment of stack.segments) {
+        const segmentStr = segment.barChar.repeat(segment.length);
+        barStr += theme ? theme.semantic.primary(segmentStr) : segmentStr;
+      }
+      lines.push(`${coloredLabel} ${barStr}`);
+    }
+  }
+  const legendItems = layout.seriesNames.map((name, i) => {
+    const style = layout.seriesStyles[i];
+    if (!style) {
+      throw new Error(`Missing series style at index ${String(i)}`);
+    }
+    return {
+      name,
+      symbol: style.char,
+      useBackticks: style.useBackticks
+    };
+  });
+  const legendLayout = computeLegendLayout({
+    items: legendItems,
+    position: input.legend?.position ?? "bottom",
+    maxWidth: layout.width
+  });
+  if (legendLayout.rows.length > 0) {
+    lines.push("");
+    for (const row of legendLayout.rows) {
+      lines.push(renderLegendRowAnsi(row, theme));
+    }
+  }
+  return lines.join("\n");
+}
+function renderLineChartAnsi(layout, options) {
+  const { theme, input } = options;
+  const lines = [];
+  const chartWidth = layout.rows[0]?.chars.length ?? layout.categories.length;
+  for (const row of layout.rows) {
+    const yLabel = row.yLabel ? padToWidth2(row.yLabel, layout.yAxisWidth - 1) + " " : " ".repeat(layout.yAxisWidth);
+    let content = "";
+    for (let i = 0; i < row.chars.length; i++) {
+      const char = row.chars[i];
+      if (char === void 0) {
+        continue;
+      }
+      const seriesIdx = row.seriesIndices[i];
+      if (char !== " " && theme) {
+        if (seriesIdx !== null && seriesIdx !== void 0 && seriesIdx % 2 === 1) {
+          content += theme.semantic.secondary(char);
+        } else {
+          content += theme.semantic.primary(char);
+        }
+      } else {
+        content += char;
+      }
+    }
+    lines.push(`${yLabel}${AXIS_CHARS.vertical}${content}`);
+  }
+  const xAxisLine = AXIS_CHARS.horizontal.repeat(chartWidth);
+  lines.push(" ".repeat(layout.yAxisWidth) + AXIS_CHARS.origin + xAxisLine);
+  const labelLine = Array(chartWidth).fill(" ");
+  const isBraille = layout.lineStyle === "braille";
+  const spacing = isBraille ? 3 : 2;
+  for (let i = 0; i < layout.categories.length; i++) {
+    const label = layout.categories[i];
+    if (label === void 0) {
+      continue;
+    }
+    const pos = isBraille ? i * spacing + Math.floor(spacing / 2) : i * spacing;
+    if (pos < chartWidth) {
+      labelLine[pos] = label.charAt(0) || " ";
+    }
+  }
+  lines.push(" ".repeat(layout.yAxisWidth + 1) + labelLine.join(""));
+  if (layout.seriesNames.length > 1) {
+    const legendItems = layout.seriesNames.map((name, i) => {
+      return {
+        name,
+        symbol: "\u28FF",
+        // Use braille full block for line chart legend
+        useBackticks: i % 2 === 1
+      };
+    });
+    const legendLayout = computeLegendLayout({
+      items: legendItems,
+      position: input.legend?.position ?? "bottom",
+      maxWidth: layout.width
+    });
+    if (legendLayout.rows.length > 0) {
+      lines.push("");
+      for (const row of legendLayout.rows) {
+        lines.push(renderLegendRowAnsi(row, theme));
+      }
+    }
+  }
+  return lines.join("\n");
+}
+function renderAreaChartAnsi(layout, options) {
+  const { theme, input } = options;
+  const lines = [];
+  for (const row of layout.rows) {
+    const yLabel = row.yLabel ? padToWidth2(row.yLabel, layout.yAxisWidth - 1) + " " : " ".repeat(layout.yAxisWidth);
+    let content = "";
+    for (const char of row.chars) {
+      if (char !== " " && theme) {
+        content += theme.semantic.primary(char);
+      } else {
+        content += char;
+      }
+    }
+    lines.push(`${yLabel}${AXIS_CHARS.vertical}${content}`);
+  }
+  const xAxisLine = AXIS_CHARS.horizontal.repeat(layout.categories.length);
+  lines.push(" ".repeat(layout.yAxisWidth) + AXIS_CHARS.origin + xAxisLine);
+  const xLabels = layout.categories.map((c) => c.charAt(0) || " ").join("");
+  lines.push(" ".repeat(layout.yAxisWidth + 1) + xLabels);
+  const legendItems = layout.seriesNames.map((name, i) => {
+    const style = layout.seriesStyles[i];
+    if (!style) {
+      throw new Error(`Missing series style at index ${String(i)}`);
+    }
+    return {
+      name,
+      symbol: style.char,
+      useBackticks: style.useBackticks
+    };
+  });
+  const legendLayout = computeLegendLayout({
+    items: legendItems,
+    position: input.legend?.position ?? "bottom",
+    maxWidth: layout.width
+  });
+  if (legendLayout.rows.length > 0) {
+    lines.push("");
+    for (const row of legendLayout.rows) {
+      lines.push(renderLegendRowAnsi(row, theme));
+    }
+  }
+  return lines.join("\n");
+}
+function renderScatterChartAnsi(layout, options) {
+  const { theme, input } = options;
+  const lines = [];
+  const format = input.yAxis?.format ?? "number";
+  const decimals = input.yAxis?.decimals;
+  for (let rowIndex = 0; rowIndex < layout.chartHeight; rowIndex++) {
+    let yLabel = " ".repeat(layout.yAxisWidth);
+    const rowTop = 1 - rowIndex / layout.chartHeight;
+    const rowBottom = 1 - (rowIndex + 1) / layout.chartHeight;
+    for (const tick of layout.yScale.ticks) {
+      const tickNorm = (tick - layout.yScale.min) / (layout.yScale.max - layout.yScale.min);
+      if (tickNorm > rowBottom && tickNorm <= rowTop) {
+        yLabel = padToWidth2(
+          formatTickValue(tick, format, decimals),
+          layout.yAxisWidth - 1
+        ) + " ";
+        break;
+      }
+    }
+    let content = "";
+    if (layout.scatterStyle === "braille" && layout.brailleChars) {
+      const rowChars = layout.brailleChars[rowIndex] ?? [];
+      const rowIndices = layout.brailleSeriesIndices?.[rowIndex] ?? [];
+      for (let i = 0; i < rowChars.length; i++) {
+        const char = rowChars[i];
+        if (char === void 0) {
+          continue;
+        }
+        const seriesIdx = rowIndices[i];
+        if (char !== " " && theme) {
+          if (seriesIdx !== null && seriesIdx !== void 0 && seriesIdx % 2 === 1) {
+            content += theme.semantic.secondary(char);
+          } else {
+            content += theme.semantic.primary(char);
+          }
+        } else {
+          content += char;
+        }
+      }
+    } else if (layout.grid) {
+      const rowChars = layout.grid[rowIndex] ?? [];
+      const rowIndices = layout.seriesIndices?.[rowIndex] ?? [];
+      for (let i = 0; i < rowChars.length; i++) {
+        const char = rowChars[i];
+        if (char === void 0) {
+          continue;
+        }
+        const seriesIdx = rowIndices[i];
+        if (char !== " " && theme) {
+          if (seriesIdx !== null && seriesIdx !== void 0 && seriesIdx % 2 === 1) {
+            content += theme.semantic.secondary(char);
+          } else {
+            content += theme.semantic.primary(char);
+          }
+        } else {
+          content += char;
+        }
+      }
+    }
+    lines.push(`${yLabel}${AXIS_CHARS.vertical}${content}`);
+  }
+  const xAxisLine = AXIS_CHARS.horizontal.repeat(layout.chartWidth);
+  lines.push(" ".repeat(layout.yAxisWidth) + AXIS_CHARS.origin + xAxisLine);
+  const xFormat = input.xAxis?.format ?? "number";
+  const xDecimals = input.xAxis?.decimals;
+  const labelPositions = [];
+  for (const tick of layout.xScale.ticks) {
+    const norm = (tick - layout.xScale.min) / (layout.xScale.max - layout.xScale.min);
+    const pos = Math.round(norm * (layout.chartWidth - 1));
+    const label = formatTickValue(tick, xFormat, xDecimals);
+    labelPositions.push({ pos, label });
+  }
+  const labelLine = Array(layout.chartWidth).fill(" ");
+  for (const { pos, label } of labelPositions) {
+    const halfLen = Math.floor(label.length / 2);
+    const startPos = Math.max(
+      0,
+      Math.min(layout.chartWidth - label.length, pos - halfLen)
+    );
+    for (let i = 0; i < label.length && startPos + i < layout.chartWidth; i++) {
+      const char = label[i];
+      if (char !== void 0) {
+        labelLine[startPos + i] = char;
+      }
+    }
+  }
+  lines.push(" ".repeat(layout.yAxisWidth + 1) + labelLine.join(""));
+  if (layout.seriesNames.length > 1) {
+    const symbolArray = ["\u25CF", "\u25A0", "\u25B2", "\u25C6", "+"];
+    const legendItems = layout.seriesNames.map((name, i) => {
+      const symbol = layout.scatterStyle === "braille" ? "\u28FF" : symbolArray[i % 5];
+      if (!symbol) {
+        throw new Error(`Missing symbol at index ${String(i % 5)}`);
+      }
+      return {
+        name,
+        symbol,
+        useBackticks: i % 2 === 1
+      };
+    });
+    const legendLayout = computeLegendLayout({
+      items: legendItems,
+      position: input.legend?.position ?? "bottom",
+      maxWidth: layout.width
+    });
+    if (legendLayout.rows.length > 0) {
+      lines.push("");
+      for (const row of legendLayout.rows) {
+        lines.push(renderLegendRowAnsi(row, theme));
+      }
+    }
+  }
+  return lines.join("\n");
+}
+function renderPieChartAnsi(layout, options) {
+  const { theme, input } = options;
+  const lines = [];
+  if (layout.slices.length === 0) {
+    lines.push("No data");
+    return lines.join("\n");
+  }
+  for (let rowIndex = 0; rowIndex < layout.brailleChars.length; rowIndex++) {
+    const rowChars = layout.brailleChars[rowIndex] ?? [];
+    const rowIndices = layout.brailleSeriesIndices[rowIndex] ?? [];
+    let content = "";
+    for (let i = 0; i < rowChars.length; i++) {
+      const char = rowChars[i];
+      if (char === void 0) {
+        continue;
+      }
+      const seriesIdx = rowIndices[i];
+      if (char !== " " && theme) {
+        if (seriesIdx !== null && seriesIdx !== void 0 && seriesIdx % 2 === 1) {
+          content += theme.semantic.secondary(char);
+        } else {
+          content += theme.semantic.primary(char);
+        }
+      } else {
+        content += char;
+      }
+    }
+    if (layout.type === "donut" && layout.centerLabel && rowIndex === Math.floor(layout.brailleChars.length / 2)) {
+      const labelLen = layout.centerLabel.length;
+      const startPos = Math.floor((layout.width - labelLen) / 2);
+      if (startPos >= 0) {
+        const contentArray = [...content];
+        for (let i = 0; i < labelLen && startPos + i < contentArray.length; i++) {
+          const char = layout.centerLabel[i];
+          if (char !== void 0) {
+            contentArray[startPos + i] = char;
+          }
+        }
+        content = contentArray.join("");
+      }
+    }
+    lines.push(content);
+  }
+  const legendItems = layout.slices.map((slice) => ({
+    name: `${slice.label} ${slice.percentage.toFixed(0)}%`,
+    symbol: slice.barChar,
+    useBackticks: slice.useBackticks
+  }));
+  const legendLayout = computeLegendLayout({
+    items: legendItems,
+    position: input.legend?.position ?? "bottom",
+    maxWidth: layout.width
+  });
+  if (legendLayout.rows.length > 0) {
+    lines.push("");
+    for (const row of legendLayout.rows) {
+      lines.push(renderLegendRowAnsi(row, theme));
+    }
+  }
+  return lines.join("\n");
+}
+function renderHeatmapAnsi(layout, options) {
+  const { theme } = options;
+  const lines = [];
+  const colLabelRow = " ".repeat(layout.rowLabelWidth) + layout.colLabels.map((label) => padToWidth2(label, layout.colLabelWidth)).join(" ");
+  lines.push(colLabelRow);
+  for (let rowIdx = 0; rowIdx < layout.rowLabels.length; rowIdx++) {
+    const rowLabel = layout.rowLabels[rowIdx];
+    if (rowLabel === void 0) {
+      continue;
+    }
+    const rowCells = layout.cells[rowIdx] ?? [];
+    let row = padToWidth2(rowLabel, layout.rowLabelWidth);
+    for (const cell of rowCells) {
+      let cellStr;
+      if (layout.heatmapStyle === "numeric") {
+        cellStr = padToWidth2(cell.displayChar, layout.colLabelWidth);
+      } else {
+        cellStr = padToWidth2(cell.displayChar, layout.colLabelWidth);
+      }
+      if (theme) {
+        if (cell.normalizedValue > 0.5) {
+          cellStr = theme.semantic.primary(cellStr);
+        } else if (cell.normalizedValue > 0.25) {
+          cellStr = theme.semantic.secondary(cellStr);
+        }
+      }
+      row += cellStr + " ";
+    }
+    lines.push(row.trimEnd());
+  }
+  if (layout.heatmapStyle !== "numeric") {
+    lines.push("");
+    const scaleLabel = layout.heatmapStyle === "blocks" ? `Scale: \u2591 ${String(layout.valueRange.min)} \u2592 \u2593 \u2588 ${String(layout.valueRange.max)}` : `Scale: . ${String(layout.valueRange.min)} : * # ${String(layout.valueRange.max)}`;
+    lines.push(theme ? theme.semantic.secondary(scaleLabel) : scaleLabel);
+  }
+  return lines.join("\n");
+}
+
+// src/renderers/markdown.ts
+import { padToWidth as padToWidth3, anchorLine, DEFAULT_ANCHOR } from "@tuicomponents/core";
+function wrapInlineCode(text, useBackticks) {
+  if (useBackticks) {
+    return ` \`${text}\``;
+  }
+  return text;
+}
+function renderBarChartMarkdown(layout, _options) {
+  const lines = [];
+  for (const bar of layout.bars) {
+    const label = padToWidth3(bar.label, layout.maxLabelWidth);
+    const barStr = bar.barChar.repeat(bar.length);
+    const styledBar = wrapInlineCode(barStr, bar.useBackticks);
+    let content;
+    if (layout.showValues) {
+      content = `${label} ${styledBar} ${bar.formattedValue}`;
+    } else {
+      content = `${label} ${styledBar}`;
+    }
+    if (bar.useBackticks) {
+      content += "  ";
+    }
+    lines.push(anchorLine(content, DEFAULT_ANCHOR));
+  }
+  return lines.join("\n");
+}
+function renderVerticalBarChartMarkdown(layout, options) {
+  const { input } = options;
+  const lines = [];
+  const chartHeight = layout.barAreaSize;
+  const numBars = layout.bars.length;
+  const barWidth = Math.max(1, Math.floor((layout.width - 2) / numBars) - 1);
+  const yAxisWidth = layout.maxValueWidth + 2;
+  const format = input.yAxis?.format ?? "number";
+  const decimals = input.yAxis?.decimals;
+  for (let row = chartHeight - 1; row >= 0; row--) {
+    const rowThreshold = (row + 1) / chartHeight;
+    let yLabel = " ".repeat(yAxisWidth);
+    for (const tick of layout.yScale.ticks) {
+      const tickNorm = (tick - layout.yScale.min) / (layout.yScale.max - layout.yScale.min);
+      if (Math.abs(tickNorm - rowThreshold) < 0.5 / chartHeight) {
+        yLabel = padToWidth3(formatTickValue(tick, format, decimals), yAxisWidth - 1) + " ";
+        break;
+      }
+    }
+    const axisChar = row === 0 ? AXIS_CHARS.origin : AXIS_CHARS.vertical;
+    const segments = [];
+    for (const bar of layout.bars) {
+      const barNorm = bar.length / layout.barAreaSize;
+      if (barNorm >= rowThreshold) {
+        const barSegment = bar.barChar.repeat(barWidth);
+        segments.push(wrapInlineCode(barSegment, bar.useBackticks));
+      } else {
+        segments.push(" ".repeat(barWidth));
+      }
+    }
+    lines.push(
+      anchorLine(`${yLabel}${axisChar}${segments.join(" ")}`, DEFAULT_ANCHOR)
+    );
+  }
+  const xAxisLine = AXIS_CHARS.horizontal.repeat(layout.width - yAxisWidth - 1);
+  lines.push(
+    anchorLine(
+      " ".repeat(yAxisWidth) + AXIS_CHARS.origin + xAxisLine,
+      DEFAULT_ANCHOR
+    )
+  );
+  const xLabels = [];
+  for (const bar of layout.bars) {
+    xLabels.push(padToWidth3(bar.label, barWidth));
+  }
+  lines.push(
+    anchorLine(" ".repeat(yAxisWidth + 1) + xLabels.join(" "), DEFAULT_ANCHOR)
+  );
+  return lines.join("\n");
+}
+function renderStackedBarChartMarkdown(layout, options) {
+  const { input } = options;
+  const lines = [];
+  const isVertical = layout.type === "bar-stacked-vertical";
+  if (isVertical) {
+    const chartHeight = layout.barAreaSize;
+    const numStacks = layout.stacks.length;
+    const barWidth = Math.max(
+      1,
+      Math.floor((layout.width - 2) / numStacks) - 1
+    );
+    const yAxisWidth = layout.maxValueWidth + 2;
+    const format = input.yAxis?.format ?? "number";
+    const decimals = input.yAxis?.decimals;
+    const yAxisConfig = {
+      scale: layout.yScale,
+      chartHeight,
+      labelWidth: yAxisWidth,
+      format,
+      decimals
+    };
+    for (let row = chartHeight - 1; row >= 0; row--) {
+      const rowBottom = row / chartHeight;
+      const rowTop = (row + 1) / chartHeight;
+      const { label: yLabel, axisChar } = computeYAxisRow(row, yAxisConfig);
+      const segments = [];
+      for (const stack of layout.stacks) {
+        let activeSegment = null;
+        let cumHeight = 0;
+        for (const segment of stack.segments) {
+          const segmentHeight = segment.length / layout.barAreaSize;
+          if (rowBottom < cumHeight + segmentHeight && rowTop > cumHeight) {
+            activeSegment = segment;
+            break;
+          }
+          cumHeight += segmentHeight;
+        }
+        if (activeSegment) {
+          const barSegment = activeSegment.barChar.repeat(barWidth);
+          if (activeSegment.useBackticks) {
+            segments.push(`\`${barSegment}\``);
+          } else {
+            segments.push(barSegment);
+          }
+        } else {
+          segments.push(" ".repeat(barWidth));
+        }
+      }
+      lines.push(
+        anchorLine(`${yLabel}${axisChar}${segments.join(" ")}`, DEFAULT_ANCHOR)
+      );
+    }
+    const xAxis = renderXAxis({
+      categories: layout.stacks.map((s) => s.label),
+      barWidth,
+      yAxisWidth,
+      chartWidth: layout.width,
+      minValue: layout.yScale.min,
+      format,
+      decimals
+    });
+    lines.push(anchorLine(xAxis.axisLine, DEFAULT_ANCHOR));
+    lines.push(anchorLine(xAxis.labelLine, DEFAULT_ANCHOR));
+  } else {
+    for (const stack of layout.stacks) {
+      const label = padToWidth3(stack.label, layout.maxLabelWidth);
+      let barStr = "";
+      for (const segment of stack.segments) {
+        const segmentStr = segment.barChar.repeat(segment.length);
+        if (segment.useBackticks) {
+          barStr += `\`${segmentStr}\``;
+        } else {
+          barStr += segmentStr;
+        }
+      }
+      lines.push(anchorLine(`${label} ${barStr}`, DEFAULT_ANCHOR));
+    }
+  }
+  const legendItems = layout.seriesNames.map((name, i) => {
+    const style = layout.seriesStyles[i];
+    if (!style) {
+      throw new Error(`Missing style for series ${String(i)}`);
+    }
+    return {
+      name,
+      symbol: style.char,
+      useBackticks: style.useBackticks
+    };
+  });
+  const legendLayout = computeLegendLayout({
+    items: legendItems,
+    position: input.legend?.position ?? "bottom",
+    maxWidth: layout.width
+  });
+  if (legendLayout.rows.length > 0) {
+    lines.push(anchorLine("", DEFAULT_ANCHOR));
+    for (const row of legendLayout.rows) {
+      lines.push(anchorLine(renderLegendRow(row, true), DEFAULT_ANCHOR));
+    }
+  }
+  return lines.join("\n");
+}
+function renderLineChartMarkdown(layout, options) {
+  const { input } = options;
+  const lines = [];
+  const chartWidth = layout.rows[0]?.chars.length ?? layout.categories.length;
+  for (const row of layout.rows) {
+    const yLabel = row.yLabel ? padToWidth3(row.yLabel, layout.yAxisWidth - 1) + " " : " ".repeat(layout.yAxisWidth);
+    let content = "";
+    for (let i = 0; i < row.chars.length; i++) {
+      const char = row.chars[i];
+      const useBackticks = row.useBackticks[i];
+      if (char === void 0 || useBackticks === void 0) {
+        throw new Error(`Missing char or useBackticks at index ${String(i)}`);
+      }
+      content += wrapInlineCode(char, useBackticks && char !== " ");
+    }
+    lines.push(
+      anchorLine(`${yLabel}${AXIS_CHARS.vertical}${content}`, DEFAULT_ANCHOR)
+    );
+  }
+  const xAxisLine = AXIS_CHARS.horizontal.repeat(chartWidth);
+  lines.push(
+    anchorLine(
+      " ".repeat(layout.yAxisWidth) + AXIS_CHARS.origin + xAxisLine,
+      DEFAULT_ANCHOR
+    )
+  );
+  const labelLine = Array(chartWidth).fill(" ");
+  const isBraille = layout.lineStyle === "braille";
+  const spacing = isBraille ? 3 : 2;
+  for (let i = 0; i < layout.categories.length; i++) {
+    const label = layout.categories[i];
+    if (label === void 0) {
+      throw new Error(`Missing category at index ${String(i)}`);
+    }
+    const pos = isBraille ? i * spacing + Math.floor(spacing / 2) : i * spacing;
+    if (pos < chartWidth) {
+      labelLine[pos] = label.charAt(0) || " ";
+    }
+  }
+  lines.push(
+    anchorLine(
+      " ".repeat(layout.yAxisWidth + 1) + labelLine.join(""),
+      DEFAULT_ANCHOR
+    )
+  );
+  if (layout.seriesNames.length > 1) {
+    const legendItems = layout.seriesNames.map((name, i) => {
+      return {
+        name,
+        symbol: "\u28FF",
+        // Use braille full block for line chart legend
+        useBackticks: i % 2 === 1
+      };
+    });
+    const legendLayout = computeLegendLayout({
+      items: legendItems,
+      position: input.legend?.position ?? "bottom",
+      maxWidth: layout.width
+    });
+    if (legendLayout.rows.length > 0) {
+      lines.push(anchorLine("", DEFAULT_ANCHOR));
+      for (const row of legendLayout.rows) {
+        lines.push(anchorLine(renderLegendRow(row, true), DEFAULT_ANCHOR));
+      }
+    }
+  }
+  return lines.join("\n");
+}
+function renderAreaChartMarkdown(layout, options) {
+  const { input } = options;
+  const lines = [];
+  for (const row of layout.rows) {
+    const yLabel = row.yLabel ? padToWidth3(row.yLabel, layout.yAxisWidth - 1) + " " : " ".repeat(layout.yAxisWidth);
+    let content = "";
+    for (let i = 0; i < row.chars.length; i++) {
+      const char = row.chars[i];
+      const useBackticks = row.useBackticks[i];
+      if (char === void 0 || useBackticks === void 0) {
+        throw new Error(`Missing char or useBackticks at index ${String(i)}`);
+      }
+      content += wrapInlineCode(char, useBackticks && char !== " ");
+    }
+    lines.push(
+      anchorLine(`${yLabel}${AXIS_CHARS.vertical}${content}`, DEFAULT_ANCHOR)
+    );
+  }
+  const xAxisLine = AXIS_CHARS.horizontal.repeat(layout.categories.length);
+  lines.push(
+    anchorLine(
+      " ".repeat(layout.yAxisWidth) + AXIS_CHARS.origin + xAxisLine,
+      DEFAULT_ANCHOR
+    )
+  );
+  const xLabels = layout.categories.map((c) => c.charAt(0) || " ").join("");
+  lines.push(
+    anchorLine(" ".repeat(layout.yAxisWidth + 1) + xLabels, DEFAULT_ANCHOR)
+  );
+  const legendItems = layout.seriesNames.map((name, i) => {
+    const style = layout.seriesStyles[i];
+    if (!style) {
+      throw new Error(`Missing style for series ${String(i)}`);
+    }
+    return {
+      name,
+      symbol: style.char,
+      useBackticks: style.useBackticks
+    };
+  });
+  const legendLayout = computeLegendLayout({
+    items: legendItems,
+    position: input.legend?.position ?? "bottom",
+    maxWidth: layout.width
+  });
+  if (legendLayout.rows.length > 0) {
+    lines.push(anchorLine("", DEFAULT_ANCHOR));
+    for (const row of legendLayout.rows) {
+      lines.push(anchorLine(renderLegendRow(row, true), DEFAULT_ANCHOR));
+    }
+  }
+  return lines.join("\n");
+}
+function renderScatterChartMarkdown(layout, options) {
+  const { input } = options;
+  const lines = [];
+  const format = input.yAxis?.format ?? "number";
+  const decimals = input.yAxis?.decimals;
+  for (let rowIndex = 0; rowIndex < layout.chartHeight; rowIndex++) {
+    let yLabel = " ".repeat(layout.yAxisWidth);
+    const rowTop = 1 - rowIndex / layout.chartHeight;
+    const rowBottom = 1 - (rowIndex + 1) / layout.chartHeight;
+    for (const tick of layout.yScale.ticks) {
+      const tickNorm = (tick - layout.yScale.min) / (layout.yScale.max - layout.yScale.min);
+      if (tickNorm > rowBottom && tickNorm <= rowTop) {
+        yLabel = padToWidth3(
+          formatTickValue(tick, format, decimals),
+          layout.yAxisWidth - 1
+        ) + " ";
+        break;
+      }
+    }
+    let content = "";
+    if (layout.scatterStyle === "braille" && layout.brailleChars) {
+      const rowChars = layout.brailleChars[rowIndex] ?? [];
+      const rowIndices = layout.brailleSeriesIndices?.[rowIndex] ?? [];
+      for (let i = 0; i < rowChars.length; i++) {
+        const char = rowChars[i];
+        if (char === void 0) {
+          throw new Error(`Missing char at index ${String(i)}`);
+        }
+        const seriesIdx = rowIndices[i];
+        const useBackticks = seriesIdx !== null && seriesIdx !== void 0 && seriesIdx % 2 === 1;
+        content += wrapInlineCode(char, useBackticks && char !== " ");
+      }
+    } else if (layout.grid) {
+      const rowChars = layout.grid[rowIndex] ?? [];
+      const rowIndices = layout.seriesIndices?.[rowIndex] ?? [];
+      for (let i = 0; i < rowChars.length; i++) {
+        const char = rowChars[i];
+        if (char === void 0) {
+          throw new Error(`Missing char at index ${String(i)}`);
+        }
+        const seriesIdx = rowIndices[i];
+        const useBackticks = seriesIdx !== null && seriesIdx !== void 0 && seriesIdx % 2 === 1;
+        content += wrapInlineCode(char, useBackticks && char !== " ");
+      }
+    }
+    lines.push(
+      anchorLine(`${yLabel}${AXIS_CHARS.vertical}${content}`, DEFAULT_ANCHOR)
+    );
+  }
+  const xAxisLine = AXIS_CHARS.horizontal.repeat(layout.chartWidth);
+  lines.push(
+    anchorLine(
+      " ".repeat(layout.yAxisWidth) + AXIS_CHARS.origin + xAxisLine,
+      DEFAULT_ANCHOR
+    )
+  );
+  const xFormat = input.xAxis?.format ?? "number";
+  const xDecimals = input.xAxis?.decimals;
+  const labelPositions = [];
+  for (const tick of layout.xScale.ticks) {
+    const norm = (tick - layout.xScale.min) / (layout.xScale.max - layout.xScale.min);
+    const pos = Math.round(norm * (layout.chartWidth - 1));
+    const label = formatTickValue(tick, xFormat, xDecimals);
+    labelPositions.push({ pos, label });
+  }
+  const labelLine = Array(layout.chartWidth).fill(" ");
+  for (const { pos, label } of labelPositions) {
+    const halfLen = Math.floor(label.length / 2);
+    const startPos = Math.max(
+      0,
+      Math.min(layout.chartWidth - label.length, pos - halfLen)
+    );
+    for (let i = 0; i < label.length && startPos + i < layout.chartWidth; i++) {
+      const char = label[i];
+      if (char === void 0) {
+        throw new Error(`Missing char at index ${String(i)}`);
+      }
+      labelLine[startPos + i] = char;
+    }
+  }
+  lines.push(
+    anchorLine(
+      " ".repeat(layout.yAxisWidth + 1) + labelLine.join(""),
+      DEFAULT_ANCHOR
+    )
+  );
+  if (layout.seriesNames.length > 1) {
+    const legendItems = layout.seriesNames.map((name, i) => {
+      const symbols = ["\u25CF", "\u25A0", "\u25B2", "\u25C6", "+"];
+      const symbol = layout.scatterStyle === "braille" ? "\u28FF" : symbols[i % 5];
+      if (!symbol) {
+        throw new Error(`Missing symbol for series ${String(i)}`);
+      }
+      return {
+        name,
+        symbol,
+        useBackticks: i % 2 === 1
+      };
+    });
+    const legendLayout = computeLegendLayout({
+      items: legendItems,
+      position: input.legend?.position ?? "bottom",
+      maxWidth: layout.width
+    });
+    if (legendLayout.rows.length > 0) {
+      lines.push(anchorLine("", DEFAULT_ANCHOR));
+      for (const row of legendLayout.rows) {
+        lines.push(anchorLine(renderLegendRow(row, true), DEFAULT_ANCHOR));
+      }
+    }
+  }
+  return lines.join("\n");
+}
+function renderPieChartMarkdown(layout, options) {
+  const { input } = options;
+  const lines = [];
+  if (layout.slices.length === 0) {
+    lines.push(anchorLine("No data", DEFAULT_ANCHOR));
+    return lines.join("\n");
+  }
+  for (let rowIndex = 0; rowIndex < layout.brailleChars.length; rowIndex++) {
+    const rowChars = layout.brailleChars[rowIndex] ?? [];
+    const rowIndices = layout.brailleSeriesIndices[rowIndex] ?? [];
+    let content = "";
+    for (let i = 0; i < rowChars.length; i++) {
+      const char = rowChars[i];
+      if (char === void 0) {
+        throw new Error(`Missing char at index ${String(i)}`);
+      }
+      const seriesIdx = rowIndices[i];
+      const useBackticks = seriesIdx !== null && seriesIdx !== void 0 && seriesIdx % 2 === 1;
+      content += wrapInlineCode(char, useBackticks && char !== " ");
+    }
+    if (layout.type === "donut" && layout.centerLabel && rowIndex === Math.floor(layout.brailleChars.length / 2)) {
+      const labelLen = layout.centerLabel.length;
+      const startPos = Math.floor((layout.width - labelLen) / 2);
+      if (startPos >= 0) {
+        const contentArray = [...content];
+        for (let i = 0; i < labelLen && startPos + i < contentArray.length; i++) {
+          const char = layout.centerLabel[i];
+          if (char === void 0) {
+            throw new Error(`Missing centerLabel char at index ${String(i)}`);
+          }
+          contentArray[startPos + i] = char;
+        }
+        content = contentArray.join("");
+      }
+    }
+    lines.push(anchorLine(content, DEFAULT_ANCHOR));
+  }
+  const legendItems = layout.slices.map((slice) => ({
+    name: `${slice.label} ${slice.percentage.toFixed(0)}%`,
+    symbol: slice.barChar,
+    useBackticks: slice.useBackticks
+  }));
+  const legendLayout = computeLegendLayout({
+    items: legendItems,
+    position: input.legend?.position ?? "bottom",
+    maxWidth: layout.width
+  });
+  if (legendLayout.rows.length > 0) {
+    lines.push(anchorLine("", DEFAULT_ANCHOR));
+    for (const row of legendLayout.rows) {
+      lines.push(anchorLine(renderLegendRow(row, true), DEFAULT_ANCHOR));
+    }
+  }
+  return lines.join("\n");
+}
+function renderHeatmapMarkdown(layout, options) {
+  const { input: _input } = options;
+  const lines = [];
+  if (layout.cells.length === 0 || (layout.cells[0]?.length ?? 0) === 0) {
+    lines.push(anchorLine("No data", DEFAULT_ANCHOR));
+    return lines.join("\n");
+  }
+  const colHeaderPadding = " ".repeat(layout.rowLabelWidth);
+  const colHeaders = layout.colLabels.map((label) => padToWidth3(label, layout.colLabelWidth)).join("");
+  lines.push(anchorLine(`${colHeaderPadding}${colHeaders}`, DEFAULT_ANCHOR));
+  for (let rowIdx = 0; rowIdx < layout.rowLabels.length; rowIdx++) {
+    const rowLabelText = layout.rowLabels[rowIdx];
+    if (!rowLabelText) continue;
+    const rowLabel = padToWidth3(rowLabelText, layout.rowLabelWidth);
+    const rowCells = layout.cells[rowIdx];
+    if (!rowCells) continue;
+    let rowContent = "";
+    for (const cell of rowCells) {
+      if (layout.heatmapStyle === "numeric") {
+        rowContent += padToWidth3(cell.displayChar, layout.colLabelWidth);
+      } else {
+        const useBackticks = cell.normalizedValue > 0.5;
+        const paddedChar = padToWidth3(cell.displayChar, layout.colLabelWidth);
+        const styled = wrapInlineCode(paddedChar, useBackticks);
+        rowContent += styled;
+      }
+    }
+    lines.push(anchorLine(`${rowLabel}${rowContent}`, DEFAULT_ANCHOR));
+  }
+  if (layout.heatmapStyle !== "numeric") {
+    lines.push(anchorLine("", DEFAULT_ANCHOR));
+    const scaleChars = layout.heatmapStyle === "blocks" ? ["\u2591", "\u2592", "\u2593", "\u2588"] : [".", ":", "*", "#"];
+    const scaleLabels = ["Low", "", "", "High"];
+    let scaleLine = "Scale: ";
+    for (let i = 0; i < scaleChars.length; i++) {
+      const char = scaleChars[i] ?? "";
+      const label = scaleLabels[i] ?? "";
+      scaleLine += `${char} ${label}`;
+      if (i < scaleChars.length - 1) scaleLine += " ";
+    }
+    lines.push(anchorLine(scaleLine, DEFAULT_ANCHOR));
+  }
+  return lines.join("\n");
+}
+
+// src/chart.ts
+var ChartComponent = class extends BaseTuiComponent {
+  metadata = {
+    name: "chart",
+    description: "Renders various chart types including bar, line, and area charts",
+    version: "0.1.0",
+    supportedModes: ["ansi", "markdown"],
+    examples: [
+      {
+        name: "horizontal-bar",
+        description: "Simple horizontal bar chart",
+        input: {
+          type: "bar",
+          series: [
+            {
+              name: "Sales",
+              data: [
+                { x: "Q1", y: 120 },
+                { x: "Q2", y: 150 },
+                { x: "Q3", y: 180 },
+                { x: "Q4", y: 200 }
+              ]
+            }
+          ],
+          showValues: true
+        }
+      },
+      {
+        name: "vertical-bar",
+        description: "Vertical bar chart (column chart)",
+        input: {
+          type: "bar-vertical",
+          series: [
+            {
+              name: "Revenue",
+              data: [
+                { x: "Jan", y: 65 },
+                { x: "Feb", y: 80 },
+                { x: "Mar", y: 95 },
+                { x: "Apr", y: 70 }
+              ]
+            }
+          ],
+          height: 8,
+          width: 30
+        }
+      },
+      {
+        name: "stacked-bar",
+        description: "Stacked horizontal bar chart",
+        input: {
+          type: "bar-stacked",
+          series: [
+            {
+              name: "Product A",
+              data: [
+                { x: "Q1", y: 50 },
+                { x: "Q2", y: 60 },
+                { x: "Q3", y: 70 }
+              ]
+            },
+            {
+              name: "Product B",
+              data: [
+                { x: "Q1", y: 30 },
+                { x: "Q2", y: 40 },
+                { x: "Q3", y: 35 }
+              ]
+            }
+          ],
+          width: 40
+        }
+      },
+      {
+        name: "stacked-vertical",
+        description: "Stacked vertical bar chart",
+        input: {
+          type: "bar-stacked-vertical",
+          series: [
+            {
+              name: "Revenue",
+              data: [
+                { x: "Q1", y: 100 },
+                { x: "Q2", y: 120 },
+                { x: "Q3", y: 90 },
+                { x: "Q4", y: 150 }
+              ]
+            },
+            {
+              name: "Costs",
+              data: [
+                { x: "Q1", y: 60 },
+                { x: "Q2", y: 70 },
+                { x: "Q3", y: 55 },
+                { x: "Q4", y: 80 }
+              ]
+            },
+            {
+              name: "Profit",
+              data: [
+                { x: "Q1", y: 40 },
+                { x: "Q2", y: 50 },
+                { x: "Q3", y: 35 },
+                { x: "Q4", y: 70 }
+              ]
+            }
+          ],
+          height: 10,
+          width: 35
+        }
+      },
+      {
+        name: "line",
+        description: "Line chart with height blocks",
+        input: {
+          type: "line",
+          series: [
+            {
+              name: "Temperature",
+              data: [
+                { x: "J", y: 30 },
+                { x: "F", y: 35 },
+                { x: "M", y: 50 },
+                { x: "A", y: 65 },
+                { x: "M", y: 75 },
+                { x: "J", y: 85 },
+                { x: "J", y: 90 },
+                { x: "A", y: 88 },
+                { x: "S", y: 78 },
+                { x: "O", y: 62 },
+                { x: "N", y: 45 },
+                { x: "D", y: 32 }
+              ]
+            }
+          ],
+          height: 8,
+          width: 20
+        }
+      },
+      {
+        name: "multi-line",
+        description: "Multiple series line chart",
+        input: {
+          type: "line",
+          series: [
+            {
+              name: "2023",
+              data: [
+                { x: "Q1", y: 100 },
+                { x: "Q2", y: 120 },
+                { x: "Q3", y: 110 },
+                { x: "Q4", y: 140 }
+              ]
+            },
+            {
+              name: "2024",
+              data: [
+                { x: "Q1", y: 130 },
+                { x: "Q2", y: 145 },
+                { x: "Q3", y: 135 },
+                { x: "Q4", y: 160 }
+              ]
+            }
+          ],
+          height: 6,
+          width: 20
+        }
+      },
+      {
+        name: "area",
+        description: "Area chart",
+        input: {
+          type: "area",
+          series: [
+            {
+              name: "Users",
+              data: [
+                { x: "W1", y: 100 },
+                { x: "W2", y: 150 },
+                { x: "W3", y: 180 },
+                { x: "W4", y: 160 },
+                { x: "W5", y: 200 }
+              ]
+            }
+          ],
+          height: 6,
+          width: 15
+        }
+      },
+      {
+        name: "stacked-area",
+        description: "Stacked area chart",
+        input: {
+          type: "area-stacked",
+          series: [
+            {
+              name: "Mobile",
+              data: [
+                { x: "J", y: 50 },
+                { x: "F", y: 60 },
+                { x: "M", y: 70 },
+                { x: "A", y: 65 }
+              ]
+            },
+            {
+              name: "Desktop",
+              data: [
+                { x: "J", y: 100 },
+                { x: "F", y: 90 },
+                { x: "M", y: 85 },
+                { x: "A", y: 95 }
+              ]
+            }
+          ],
+          height: 8,
+          width: 15
+        }
+      },
+      {
+        name: "scatter",
+        description: "Scatter plot with numeric axes",
+        input: {
+          type: "scatter",
+          series: [
+            {
+              name: "Data",
+              data: [
+                { x: 10, y: 20 },
+                { x: 30, y: 50 },
+                { x: 50, y: 30 },
+                { x: 70, y: 80 },
+                { x: 90, y: 60 }
+              ]
+            }
+          ],
+          height: 8,
+          width: 30
+        }
+      },
+      {
+        name: "pie",
+        description: "Pie chart with percentage breakdown",
+        input: {
+          type: "pie",
+          series: [
+            {
+              name: "Revenue",
+              data: [
+                { label: "Sales", x: "Sales", y: 45 },
+                { label: "Support", x: "Support", y: 30 },
+                { label: "Other", x: "Other", y: 25 }
+              ]
+            }
+          ],
+          height: 10,
+          width: 30
+        }
+      },
+      {
+        name: "donut",
+        description: "Donut chart with center label",
+        input: {
+          type: "donut",
+          series: [
+            {
+              name: "Market Share",
+              data: [
+                { label: "Chrome", x: "Chrome", y: 65 },
+                { label: "Firefox", x: "Firefox", y: 20 },
+                { label: "Safari", x: "Safari", y: 15 }
+              ]
+            }
+          ],
+          height: 10,
+          width: 30,
+          centerLabel: "100%",
+          innerRadius: 0.5
+        }
+      },
+      {
+        name: "heatmap",
+        description: "Heatmap showing intensity values",
+        input: {
+          type: "heatmap",
+          series: [
+            {
+              name: "Activity",
+              data: [
+                { x: "Mon", y: 10, label: "9am" },
+                { x: "Tue", y: 50, label: "9am" },
+                { x: "Wed", y: 80, label: "9am" },
+                { x: "Mon", y: 30, label: "10am" },
+                { x: "Tue", y: 70, label: "10am" },
+                { x: "Wed", y: 90, label: "10am" }
+              ]
+            }
+          ],
+          height: 6,
+          width: 25,
+          heatmapStyle: "blocks"
+        }
+      }
+    ]
+  };
+  schema = chartInputSchema;
+  getJsonSchema() {
+    return zodToJsonSchema(this.schema, {
+      name: this.metadata.name,
+      $refStrategy: "none"
+    });
+  }
+  render(input, context) {
+    const parsed = this.schema.parse(input);
+    if (parsed.series.length === 0 || parsed.series.every((s) => s.data.length === 0)) {
+      return { output: "", actualWidth: 0, lineCount: 0 };
+    }
+    let output;
+    switch (parsed.type) {
+      case "bar": {
+        const layout = computeBarLayout(parsed);
+        output = context.renderMode === "markdown" ? renderBarChartMarkdown(layout, { input: parsed }) : renderBarChartAnsi(layout, {
+          theme: context.theme,
+          input: parsed
+        });
+        break;
+      }
+      case "bar-vertical": {
+        const layout = computeBarLayout(parsed);
+        output = context.renderMode === "markdown" ? renderVerticalBarChartMarkdown(layout, { input: parsed }) : renderVerticalBarChartAnsi(layout, {
+          theme: context.theme,
+          input: parsed
+        });
+        break;
+      }
+      case "bar-stacked":
+      case "bar-stacked-vertical": {
+        const layout = computeStackedBarLayout(parsed);
+        output = context.renderMode === "markdown" ? renderStackedBarChartMarkdown(layout, { input: parsed }) : renderStackedBarChartAnsi(layout, {
+          theme: context.theme,
+          input: parsed
+        });
+        break;
+      }
+      case "line": {
+        const layout = computeLineLayout(parsed);
+        output = context.renderMode === "markdown" ? renderLineChartMarkdown(layout, { input: parsed }) : renderLineChartAnsi(layout, {
+          theme: context.theme,
+          input: parsed
+        });
+        break;
+      }
+      case "area":
+      case "area-stacked": {
+        const layout = computeAreaLayout(parsed);
+        output = context.renderMode === "markdown" ? renderAreaChartMarkdown(layout, { input: parsed }) : renderAreaChartAnsi(layout, {
+          theme: context.theme,
+          input: parsed
+        });
+        break;
+      }
+      case "scatter": {
+        const layout = computeScatterLayout(parsed);
+        output = context.renderMode === "markdown" ? renderScatterChartMarkdown(layout, { input: parsed }) : renderScatterChartAnsi(layout, {
+          theme: context.theme,
+          input: parsed
+        });
+        break;
+      }
+      case "pie":
+      case "donut": {
+        const layout = computePieLayout(parsed);
+        output = context.renderMode === "markdown" ? renderPieChartMarkdown(layout, { input: parsed }) : renderPieChartAnsi(layout, {
+          theme: context.theme,
+          input: parsed
+        });
+        break;
+      }
+      case "heatmap": {
+        const layout = computeHeatmapLayout(parsed);
+        output = context.renderMode === "markdown" ? renderHeatmapMarkdown(layout, { input: parsed }) : renderHeatmapAnsi(layout, {
+          theme: context.theme,
+          input: parsed
+        });
+        break;
+      }
+      default: {
+        const _exhaustiveCheck = parsed.type;
+        throw new Error(`Unknown chart type: ${String(_exhaustiveCheck)}`);
+      }
+    }
+    if (parsed.title) {
+      const titleLine = context.theme ? context.theme.semantic.header(parsed.title) : parsed.title;
+      output = titleLine + "\n" + output;
+    }
+    const measured = measureLines(output);
+    return {
+      output,
+      actualWidth: measured.maxWidth,
+      lineCount: measured.lineCount
+    };
+  }
+};
+function createChart() {
+  return new ChartComponent();
+}
+registry.register(createChart);
+
+// src/core/axis.ts
+import { getStringWidth as getStringWidth8 } from "@tuicomponents/core";
+function computeAxisLayout(options) {
+  const {
+    dataMin,
+    dataMax,
+    size,
+    orientation,
+    position,
+    tickCount = 5,
+    showTicks = true,
+    format = "number",
+    decimals,
+    label,
+    forceMin,
+    forceMax,
+    includeZero = true
+  } = options;
+  const scale = computeNiceTicks({
+    dataMin,
+    dataMax,
+    tickCount,
+    includeZero,
+    forceMin,
+    forceMax
+  });
+  const ticks = scale.ticks.map((value) => {
+    const label2 = formatTickValue(value, format, decimals);
+    const normalizedPosition = (value - scale.min) / (scale.max - scale.min);
+    const position2 = orientation === "vertical" ? size * (1 - normalizedPosition) : size * normalizedPosition;
+    return { value, label: label2, position: position2 };
+  });
+  let maxLabelWidth = 0;
+  for (const tick of ticks) {
+    const width = getStringWidth8(tick.label);
+    if (width > maxLabelWidth) {
+      maxLabelWidth = width;
+    }
+  }
+  let totalWidth;
+  let totalHeight;
+  if (orientation === "vertical") {
+    totalWidth = maxLabelWidth + (showTicks ? 2 : 1);
+    totalHeight = size;
+  } else {
+    totalWidth = size;
+    totalHeight = 1 + (label ? 1 : 0);
+  }
+  return {
+    orientation,
+    position,
+    scale,
+    ticks,
+    maxLabelWidth,
+    title: label,
+    totalWidth,
+    totalHeight
+  };
+}
+function computeDualAxisLayout(options) {
+  const {
+    xMin,
+    xMax,
+    yMin,
+    yMax,
+    chartWidth,
+    chartHeight,
+    xAxis: xAxisOpts = {},
+    yAxis: yAxisOpts = {}
+  } = options;
+  const yAxisInitial = computeAxisLayout({
+    dataMin: yMin,
+    dataMax: yMax,
+    size: chartHeight,
+    orientation: "vertical",
+    position: "left",
+    ...yAxisOpts
+  });
+  const chartAreaX = yAxisInitial.totalWidth;
+  const chartAreaY = 0;
+  const chartAreaWidth = Math.max(1, chartWidth - yAxisInitial.totalWidth);
+  const chartAreaHeight = Math.max(1, chartHeight - 2);
+  const yAxis = computeAxisLayout({
+    dataMin: yMin,
+    dataMax: yMax,
+    size: chartAreaHeight,
+    orientation: "vertical",
+    position: "left",
+    ...yAxisOpts
+  });
+  const xAxis = computeAxisLayout({
+    dataMin: xMin,
+    dataMax: xMax,
+    size: chartAreaWidth,
+    orientation: "horizontal",
+    position: "bottom",
+    ...xAxisOpts
+  });
+  return {
+    xAxis,
+    yAxis,
+    chartAreaWidth,
+    chartAreaHeight,
+    chartAreaX,
+    chartAreaY
+  };
+}
+
+// src/core/grid.ts
+var DEFAULT_GRID_CHAR = "\xB7";
+function computeGridLayout(options) {
+  const {
+    width,
+    height,
+    xAxis,
+    yAxis,
+    showHorizontal = true,
+    showVertical = false,
+    char = DEFAULT_GRID_CHAR
+  } = options;
+  const horizontalLines = [];
+  const verticalLines = [];
+  if (showHorizontal && yAxis) {
+    for (const tick of yAxis.ticks) {
+      if (tick.position === 0 || tick.position === height) continue;
+      horizontalLines.push({
+        orientation: "horizontal",
+        position: Math.round(tick.position),
+        start: 0,
+        end: width
+      });
+    }
+  }
+  if (showVertical && xAxis) {
+    for (const tick of xAxis.ticks) {
+      if (tick.position === 0 || tick.position === width) continue;
+      verticalLines.push({
+        orientation: "vertical",
+        position: Math.round(tick.position),
+        start: 0,
+        end: height
+      });
+    }
+  }
+  return {
+    horizontalLines,
+    verticalLines,
+    char
+  };
+}
+function createGridBuffer(width, height, grid) {
+  const buffer = [];
+  for (let y = 0; y < height; y++) {
+    const row = [];
+    for (let x = 0; x < width; x++) {
+      row.push(" ");
+    }
+    buffer.push(row);
+  }
+  for (const line of grid.horizontalLines) {
+    const y = line.position;
+    if (y >= 0 && y < height) {
+      const row = buffer[y];
+      if (row) {
+        for (let x = line.start; x < line.end && x < width; x++) {
+          row[x] = grid.char;
+        }
+      }
+    }
+  }
+  for (const line of grid.verticalLines) {
+    const x = line.position;
+    if (x >= 0 && x < width) {
+      for (let y = line.start; y < line.end && y < height; y++) {
+        const row = buffer[y];
+        if (row) {
+          row[x] = grid.char;
+        }
+      }
+    }
+  }
+  return buffer;
+}
+export {
+  AXIS_CHARS,
+  BAR_CHARS,
+  BRAILLE_BASE,
+  BRAILLE_DOTS,
+  BrailleCanvas,
+  ChartComponent,
+  DEFAULT_GRID_CHAR,
+  HEATMAP_ASCII,
+  HEATMAP_BLOCKS,
+  HEIGHT_BLOCKS,
+  LINE_CHARS,
+  SCATTER_MARKERS,
+  SCATTER_MARKER_SEQUENCE,
+  SERIES_STYLES,
+  axisConfigSchema,
+  barStyleSchema,
+  buildChartRow,
+  chartInputSchema,
+  chartTypeSchema,
+  computeAreaLayout,
+  computeAxisLayout,
+  computeBarLayout,
+  computeDualAxisLayout,
+  computeGridLayout,
+  computeHeatmapLayout,
+  computeLegendLayout,
+  computeLineLayout,
+  computeNiceTicks,
+  computePieLayout,
+  computeScatterLayout,
+  computeStackedBarLayout,
+  computeYAxisRow,
+  createChart,
+  createGridBuffer,
+  dataPointSchema,
+  dataSeriesSchema,
+  formatLegendItem,
+  formatTickValue,
+  getBarChar,
+  getLegendItemWidth,
+  gridConfigSchema,
+  groupBarsByCategory,
+  heatmapStyleSchema,
+  legendConfigSchema,
+  legendPositionSchema,
+  lineStyleSchema,
+  renderAreaChartAnsi,
+  renderAreaChartMarkdown,
+  renderBarChartAnsi,
+  renderBarChartMarkdown,
+  renderHeatmapAnsi,
+  renderHeatmapMarkdown,
+  renderLegendRow,
+  renderLineChartAnsi,
+  renderLineChartMarkdown,
+  renderPieChartAnsi,
+  renderPieChartMarkdown,
+  renderScatterChartAnsi,
+  renderScatterChartMarkdown,
+  renderStackedBarChartAnsi,
+  renderStackedBarChartMarkdown,
+  renderVerticalBarChartAnsi,
+  renderVerticalBarChartMarkdown,
+  renderXAxis,
+  scaleValue,
+  scatterMarkerSchema,
+  scatterStyleSchema,
+  toBrailleChar,
+  unscaleValue,
+  valueFormatSchema,
+  valueToBlock,
+  valueToHeatmapChar
+};
+//# sourceMappingURL=index.js.map