@opendata-ai/openchart-engine 6.23.0 → 6.24.0

package/dist/index.js

@@ -35,9 +35,9 @@ function computeTextBounds(labelX, labelY, text, fontSize, fontWeight) {
   const isMultiLine = lines.length > 1;
   const maxWidth = Math.max(...lines.map((line) => estimateTextWidth(line, fontSize, fontWeight)));
   const totalHeight = lines.length * fontSize * DEFAULT_LINE_HEIGHT;
-  const x = isMultiLine ? labelX - maxWidth / 2 : labelX;
+  const x2 = isMultiLine ? labelX - maxWidth / 2 : labelX;
   return {
-    x,
+    x: x2,
     y: labelY - fontSize,
     width: maxWidth,
     height: totalHeight
@@ -395,25 +395,25 @@ function resolveTextAnnotation(annotation, scales, chartArea, isDark) {
 
 // src/annotations/resolve-range.ts
 function resolveRangeAnnotation(annotation, scales, chartArea, isDark) {
-  let x = chartArea.x;
-  let y = chartArea.y;
+  let x2 = chartArea.x;
+  let y2 = chartArea.y;
   let width = chartArea.width;
   let height = chartArea.height;
   if (annotation.x1 !== void 0 && annotation.x2 !== void 0) {
     const x1px = resolvePosition(annotation.x1, scales.x);
     const x2px = resolvePosition(annotation.x2, scales.x);
     if (x1px === null || x2px === null) return null;
-    x = Math.min(x1px, x2px);
+    x2 = Math.min(x1px, x2px);
     width = Math.abs(x2px - x1px);
   }
   if (annotation.y1 !== void 0 && annotation.y2 !== void 0) {
     const y1px = resolvePosition(annotation.y1, scales.y);
     const y2px = resolvePosition(annotation.y2, scales.y);
     if (y1px === null || y2px === null) return null;
-    y = Math.min(y1px, y2px);
+    y2 = Math.min(y1px, y2px);
     height = Math.abs(y2px - y1px);
   }
-  const rect = { x, y, width, height };
+  const rect = { x: x2, y: y2, width, height };
   let label;
   if (annotation.label) {
     const anchor = annotation.labelAnchor ?? "top";
@@ -427,11 +427,11 @@ function resolveRangeAnnotation(annotation, scales, chartArea, isDark) {
     } else if (anchor === "right") {
       style.textAnchor = "end";
     }
-    const baseX = centered ? x + width / 2 : anchor === "right" ? x + width : x;
+    const baseX = centered ? x2 + width / 2 : anchor === "right" ? x2 + width : x2;
     label = {
       text: annotation.label,
       x: baseX + labelDelta.dx,
-      y: y + labelDelta.dy,
+      y: y2 + labelDelta.dy,
       style,
       visible: true
     };
@@ -581,6 +581,9 @@ function computeAnnotations(spec, scales, chartArea, strategy, isDark = false, o
   return annotations;
 }
 
+// src/charts/bar/compute.ts
+import { isGradientDef } from "@opendata-ai/openchart-core";
+
 // src/transforms/predicates.ts
 function isFieldPredicate(pred) {
   return "field" in pred;
@@ -598,57 +601,2667 @@ function evaluateFieldPredicate(datum, pred) {
   if (pred.lt !== void 0) {
     return numValue < pred.lt;
   }
-  if (pred.lte !== void 0) {
-    return numValue <= pred.lte;
+  if (pred.lte !== void 0) {
+    return numValue <= pred.lte;
+  }
+  if (pred.gt !== void 0) {
+    return numValue > pred.gt;
+  }
+  if (pred.gte !== void 0) {
+    return numValue >= pred.gte;
+  }
+  if (pred.range !== void 0) {
+    const [min4, max4] = pred.range;
+    return numValue >= min4 && numValue <= max4;
+  }
+  if (pred.oneOf !== void 0) {
+    return pred.oneOf.some((v) => v == value2);
+  }
+  return true;
+}
+function evaluatePredicate(datum, predicate) {
+  if (isFieldPredicate(predicate)) {
+    return evaluateFieldPredicate(datum, predicate);
+  }
+  if ("and" in predicate) {
+    return predicate.and.every((p) => evaluatePredicate(datum, p));
+  }
+  if ("or" in predicate) {
+    return predicate.or.some((p) => evaluatePredicate(datum, p));
+  }
+  if ("not" in predicate) {
+    return !evaluatePredicate(datum, predicate.not);
+  }
+  return true;
+}
+
+// src/transforms/conditional.ts
+function resolveConditionalValue(datum, channelDef) {
+  const conditions = Array.isArray(channelDef.condition) ? channelDef.condition : [channelDef.condition];
+  for (const cond of conditions) {
+    if (evaluatePredicate(datum, cond.test)) {
+      if (cond.field !== void 0) {
+        return datum[cond.field];
+      }
+      return cond.value;
+    }
+  }
+  return channelDef.value;
+}
+function isConditionalValueDef(def) {
+  return def !== null && typeof def === "object" && "condition" in def;
+}
+
+// src/charts/_shared/format-label-value.ts
+import { abbreviateNumber, formatNumber } from "@opendata-ai/openchart-core";
+function formatLabelValue(value2) {
+  if (Math.abs(value2) >= 1e3) return abbreviateNumber(value2);
+  return formatNumber(value2);
+}
+
+// src/charts/utils.ts
+var DEFAULT_COLOR = "#1b7fa3";
+function scaleValue(scale, scaleType, value2) {
+  if (value2 == null) return null;
+  if (scaleType === "time" || scaleType === "utc") {
+    const date2 = value2 instanceof Date ? value2 : new Date(String(value2));
+    if (Number.isNaN(date2.getTime())) return null;
+    return scale(date2);
+  }
+  if (scaleType === "point" || scaleType === "band" || scaleType === "ordinal") {
+    const result = scale(String(value2));
+    return result ?? null;
+  }
+  const num = typeof value2 === "number" ? value2 : Number(value2);
+  if (!Number.isFinite(num)) return null;
+  return scale(num);
+}
+function groupByField(data, field) {
+  const groups = /* @__PURE__ */ new Map();
+  if (!field) {
+    groups.set("__default__", data);
+    return groups;
+  }
+  for (const row of data) {
+    const key = String(row[field] ?? "__default__");
+    const existing = groups.get(key);
+    if (existing) {
+      existing.push(row);
+    } else {
+      groups.set(key, [row]);
+    }
+  }
+  return groups;
+}
+function sortByField(data, field) {
+  if (data.length <= 1) return [...data];
+  return [...data].sort((a, b) => {
+    const aVal = a[field];
+    const bVal = b[field];
+    if (aVal == null && bVal == null) return 0;
+    if (aVal == null) return 1;
+    if (bVal == null) return -1;
+    if (typeof aVal === "number" && typeof bVal === "number") {
+      return aVal - bVal;
+    }
+    if (aVal instanceof Date && bVal instanceof Date) {
+      return aVal.getTime() - bVal.getTime();
+    }
+    const aStr = String(aVal);
+    const bStr = String(bVal);
+    const aNum = Number(aStr);
+    const bNum = Number(bStr);
+    if (Number.isFinite(aNum) && Number.isFinite(bNum)) {
+      return aNum - bNum;
+    }
+    return aStr.localeCompare(bStr);
+  });
+}
+function getColor(scales, key, _index, fallback = DEFAULT_COLOR) {
+  if (scales.color && key !== "__default__") {
+    const colorScale = scales.color.scale;
+    return colorScale(key);
+  }
+  return scales.defaultColor ?? fallback;
+}
+function getSequentialColor(scales, value2, fallback = DEFAULT_COLOR) {
+  if (scales.color?.type === "sequential") {
+    const colorScale = scales.color.scale;
+    return colorScale(value2);
+  }
+  return scales.defaultColor ?? fallback;
+}
+
+// src/charts/bar/compute.ts
+function orientGradientForHorizontalBar(grad) {
+  if (grad.gradient !== "linear") return grad;
+  const lg = grad;
+  const isDefaultVertical = (lg.x1 === void 0 || lg.x1 === 0) && (lg.y1 === void 0 || lg.y1 === 0) && (lg.x2 === void 0 || lg.x2 === 0) && (lg.y2 === void 0 || lg.y2 === 1);
+  if (!isDefaultVertical) return grad;
+  return { ...lg, x1: 0, y1: 0, x2: 1, y2: 0 };
+}
+var MIN_BAR_WIDTH = 1;
+function computeBarMarks(spec, scales, _chartArea, _strategy) {
+  const encoding = spec.encoding;
+  const xChannel = encoding.x;
+  const yChannel = encoding.y;
+  if (!xChannel || !yChannel || !scales.x || !scales.y) {
+    return [];
+  }
+  const yScale = scales.y.scale;
+  const xScale = scales.x.scale;
+  if (typeof yScale.bandwidth !== "function") {
+    return [];
+  }
+  const bandwidth = yScale.bandwidth();
+  const baseline = xScale(0);
+  const colorEnc = encoding.color && "field" in encoding.color ? encoding.color : void 0;
+  const conditionalColor = encoding.color && isConditionalValueDef(encoding.color) ? encoding.color : void 0;
+  const colorField = colorEnc?.field;
+  const isSequentialColor = colorEnc?.type === "quantitative";
+  if (!colorField || isSequentialColor) {
+    return computeSimpleBars(
+      spec.data,
+      xChannel.field,
+      yChannel.field,
+      xScale,
+      yScale,
+      bandwidth,
+      baseline,
+      scales,
+      isSequentialColor,
+      conditionalColor
+    );
+  }
+  const categoryGroups = groupByField(spec.data, yChannel.field);
+  const needsStacking = Array.from(categoryGroups.values()).some((rows) => rows.length > 1);
+  if (needsStacking) {
+    const stackDisabled = xChannel.stack === null || xChannel.stack === false;
+    if (stackDisabled) {
+      return computeGroupedBars(
+        spec.data,
+        xChannel.field,
+        yChannel.field,
+        colorField,
+        xScale,
+        yScale,
+        bandwidth,
+        baseline,
+        scales
+      );
+    }
+    const stackMode = xChannel.stack === "normalize" ? "normalize" : xChannel.stack === "center" ? "center" : "zero";
+    return computeStackedBars(
+      spec.data,
+      xChannel.field,
+      yChannel.field,
+      colorField,
+      xScale,
+      yScale,
+      bandwidth,
+      baseline,
+      scales,
+      stackMode
+    );
+  }
+  return computeColoredBars(
+    spec.data,
+    xChannel.field,
+    yChannel.field,
+    colorField,
+    xScale,
+    yScale,
+    bandwidth,
+    baseline,
+    scales
+  );
+}
+function computeStackedBars(data, valueField, categoryField, colorField, xScale, yScale, bandwidth, _baseline, scales, stackMode = "zero") {
+  const marks = [];
+  const categoryGroups = groupByField(data, categoryField);
+  for (const [category, rows] of categoryGroups) {
+    const bandY = yScale(category);
+    if (bandY === void 0) continue;
+    let categoryTotal = 0;
+    for (const row of rows) {
+      const v = Number(row[valueField] ?? 0);
+      if (Number.isFinite(v) && v > 0) categoryTotal += v;
+    }
+    let cumulativeValue = stackMode === "center" ? -categoryTotal / 2 : 0;
+    for (const row of rows) {
+      const groupKey2 = String(row[colorField] ?? "");
+      const rawValue = Number(row[valueField] ?? 0);
+      if (!Number.isFinite(rawValue) || rawValue <= 0) continue;
+      const value2 = stackMode === "normalize" && categoryTotal > 0 ? rawValue / categoryTotal : rawValue;
+      const color2 = getColor(scales, groupKey2);
+      const xLeft = xScale(cumulativeValue);
+      const xRight = xScale(cumulativeValue + value2);
+      const barWidth = Math.max(Math.abs(xRight - xLeft), MIN_BAR_WIDTH);
+      const aria = {
+        label: `${category}, ${groupKey2}: ${formatLabelValue(rawValue)}`
+      };
+      marks.push({
+        type: "rect",
+        x: Math.min(xLeft, xRight),
+        y: bandY,
+        width: barWidth,
+        height: bandwidth,
+        fill: isGradientDef(color2) ? orientGradientForHorizontalBar(color2) : color2,
+        cornerRadius: 0,
+        data: row,
+        aria,
+        orient: "horizontal",
+        stackGroup: category
+      });
+      cumulativeValue += value2;
+    }
+  }
+  return marks;
+}
+function computeGroupedBars(data, valueField, categoryField, colorField, xScale, yScale, bandwidth, baseline, scales) {
+  const marks = [];
+  const categoryGroups = groupByField(data, categoryField);
+  const groupIndexMap = /* @__PURE__ */ new Map();
+  for (const row of data) {
+    const key = String(row[colorField] ?? "");
+    if (!groupIndexMap.has(key)) {
+      groupIndexMap.set(key, groupIndexMap.size);
+    }
+  }
+  const groupCount = groupIndexMap.size;
+  if (groupCount === 0) return marks;
+  const gap = Math.min(1, bandwidth * 0.05);
+  const subBandHeight = Math.max((bandwidth - gap * (groupCount - 1)) / groupCount, MIN_BAR_WIDTH);
+  for (const [category, rows] of categoryGroups) {
+    const bandY = yScale(category);
+    if (bandY === void 0) continue;
+    for (const row of rows) {
+      const groupKey2 = String(row[colorField] ?? "");
+      const value2 = Number(row[valueField] ?? 0);
+      if (!Number.isFinite(value2)) continue;
+      const groupIndex = groupIndexMap.get(groupKey2) ?? 0;
+      const color2 = getColor(scales, groupKey2);
+      const xPos = value2 >= 0 ? baseline : xScale(value2);
+      const barWidth = Math.max(Math.abs(xScale(value2) - baseline), MIN_BAR_WIDTH);
+      const subY = bandY + groupIndex * (subBandHeight + gap);
+      const aria = {
+        label: `${category}, ${groupKey2}: ${formatLabelValue(value2)}`
+      };
+      marks.push({
+        type: "rect",
+        x: xPos,
+        y: subY,
+        width: barWidth,
+        height: subBandHeight,
+        fill: isGradientDef(color2) ? orientGradientForHorizontalBar(color2) : color2,
+        cornerRadius: 2,
+        data: row,
+        aria,
+        orient: "horizontal"
+      });
+    }
+  }
+  return marks;
+}
+function computeColoredBars(data, valueField, categoryField, colorField, xScale, yScale, bandwidth, baseline, scales) {
+  const marks = [];
+  for (const row of data) {
+    const category = String(row[categoryField] ?? "");
+    const value2 = Number(row[valueField] ?? 0);
+    if (!Number.isFinite(value2)) continue;
+    const bandY = yScale(category);
+    if (bandY === void 0) continue;
+    const groupKey2 = String(row[colorField] ?? "");
+    const color2 = getColor(scales, groupKey2);
+    const xPos = value2 >= 0 ? baseline : xScale(value2);
+    const barWidth = Math.max(Math.abs(xScale(value2) - baseline), MIN_BAR_WIDTH);
+    const aria = {
+      label: `${category}, ${groupKey2}: ${formatLabelValue(value2)}`
+    };
+    marks.push({
+      type: "rect",
+      x: xPos,
+      y: bandY,
+      width: barWidth,
+      height: bandwidth,
+      fill: isGradientDef(color2) ? orientGradientForHorizontalBar(color2) : color2,
+      cornerRadius: 2,
+      data: row,
+      aria,
+      orient: "horizontal"
+    });
+  }
+  return marks;
+}
+function computeSimpleBars(data, valueField, categoryField, xScale, yScale, bandwidth, baseline, scales, sequentialColor = false, conditionalColor) {
+  const marks = [];
+  for (const row of data) {
+    const category = String(row[categoryField] ?? "");
+    const value2 = Number(row[valueField] ?? 0);
+    if (!Number.isFinite(value2)) continue;
+    const bandY = yScale(category);
+    if (bandY === void 0) continue;
+    let color2;
+    if (conditionalColor) {
+      const resolved = resolveConditionalValue(row, conditionalColor);
+      if (resolved != null) {
+        color2 = isGradientDef(resolved) ? resolved : String(resolved);
+      } else {
+        color2 = getColor(scales, "__default__");
+      }
+    } else if (sequentialColor) {
+      color2 = getSequentialColor(scales, value2);
+    } else {
+      color2 = getColor(scales, "__default__");
+    }
+    const xPos = value2 >= 0 ? baseline : xScale(value2);
+    const barWidth = Math.max(Math.abs(xScale(value2) - baseline), MIN_BAR_WIDTH);
+    const aria = {
+      label: `${category}: ${formatLabelValue(value2)}`
+    };
+    marks.push({
+      type: "rect",
+      x: xPos,
+      y: bandY,
+      width: barWidth,
+      height: bandwidth,
+      fill: isGradientDef(color2) ? orientGradientForHorizontalBar(color2) : color2,
+      cornerRadius: 2,
+      data: row,
+      aria,
+      orient: "horizontal"
+    });
+  }
+  return marks;
+}
+
+// src/charts/bar/labels.ts
+import {
+  buildD3Formatter,
+  estimateTextWidth as estimateTextWidth2,
+  getRepresentativeColor,
+  resolveCollisions
+} from "@opendata-ai/openchart-core";
+
+// src/charts/_shared/density-filter.ts
+function filterByDensity(marks, density) {
+  if (density === "none") return [];
+  if (density === "endpoints" && marks.length > 1) {
+    return [marks[0], marks[marks.length - 1]];
+  }
+  return marks;
+}
+
+// src/charts/bar/labels.ts
+var SUFFIX_MULTIPLIERS = {
+  K: 1e3,
+  M: 1e6,
+  B: 1e9,
+  T: 1e12
+};
+function parseDisplayNumber(raw) {
+  const trimmed = raw.trim().replace(/\u2212/g, "-");
+  if (!trimmed) return NaN;
+  const last = trimmed[trimmed.length - 1].toUpperCase();
+  const multiplier = SUFFIX_MULTIPLIERS[last];
+  if (multiplier) {
+    const numPart = trimmed.slice(0, -1).replace(/,/g, "");
+    const n = Number(numPart);
+    return Number.isNaN(n) ? NaN : n * multiplier;
+  }
+  if (last === "%") {
+    return Number(trimmed.slice(0, -1).replace(/,/g, ""));
+  }
+  return Number(trimmed.replace(/,/g, ""));
+}
+var LABEL_FONT_SIZE = 11;
+var LABEL_FONT_WEIGHT = 600;
+var LABEL_PADDING = 6;
+var MIN_WIDTH_FOR_INSIDE_LABEL = 40;
+function computeBarLabels(marks, _chartArea, density = "auto", labelFormat, labelPrefix, valueField) {
+  const targetMarks = filterByDensity(marks, density);
+  const candidates = [];
+  const fitsInSegment = [];
+  const formatter = buildD3Formatter(labelFormat);
+  for (const mark of targetMarks) {
+    let valuePart;
+    const rawNum = valueField != null ? Number(mark.data[valueField]) : NaN;
+    if (formatter && Number.isFinite(rawNum)) {
+      valuePart = formatter(rawNum);
+    } else if (Number.isFinite(rawNum)) {
+      valuePart = formatLabelValue(rawNum);
+    } else {
+      const ariaLabel = mark.aria.label;
+      const lastColon = ariaLabel.lastIndexOf(":");
+      const rawValue = lastColon >= 0 ? ariaLabel.slice(lastColon + 1).trim() : "";
+      if (!rawValue) continue;
+      if (formatter) {
+        const num = parseDisplayNumber(rawValue);
+        valuePart = !Number.isNaN(num) ? formatter(num) : rawValue;
+      } else {
+        valuePart = rawValue;
+      }
+    }
+    if (labelPrefix) valuePart = labelPrefix + valuePart;
+    const textWidth = estimateTextWidth2(valuePart, LABEL_FONT_SIZE, LABEL_FONT_WEIGHT);
+    const textHeight = LABEL_FONT_SIZE * 1.2;
+    const isStacked = mark.cornerRadius === 0;
+    const isInside = mark.width >= MIN_WIDTH_FOR_INSIDE_LABEL;
+    let anchorX;
+    let fill;
+    let textAnchor;
+    if (isStacked && isInside) {
+      anchorX = mark.x + mark.width / 2;
+      fill = "#ffffff";
+      textAnchor = "middle";
+    } else if (isInside) {
+      anchorX = mark.x + mark.width - LABEL_PADDING;
+      fill = "#ffffff";
+      textAnchor = "end";
+    } else {
+      anchorX = mark.x + mark.width + LABEL_PADDING;
+      fill = getRepresentativeColor(mark.fill);
+      textAnchor = "start";
+    }
+    const anchorY = mark.y + mark.height / 2;
+    const fits = !(isStacked && textWidth > mark.width - 2 * LABEL_PADDING);
+    fitsInSegment.push(fits);
+    candidates.push({
+      text: valuePart,
+      anchorX,
+      anchorY,
+      width: textWidth,
+      height: textHeight,
+      priority: "data",
+      style: {
+        fontFamily: "system-ui, -apple-system, sans-serif",
+        fontSize: LABEL_FONT_SIZE,
+        fontWeight: LABEL_FONT_WEIGHT,
+        fill,
+        lineHeight: 1.2,
+        textAnchor,
+        dominantBaseline: "central"
+      }
+    });
+  }
+  if (candidates.length === 0) return [];
+  if (density === "all") {
+    return candidates.map((c, i) => ({
+      text: c.text,
+      x: c.anchorX,
+      y: c.anchorY,
+      style: c.style,
+      visible: fitsInSegment[i] !== false
+    }));
+  }
+  const fittingCandidates = [];
+  const unfittingIndices = /* @__PURE__ */ new Set();
+  for (let i = 0; i < candidates.length; i++) {
+    if (fitsInSegment[i] === false) {
+      unfittingIndices.add(i);
+    } else {
+      fittingCandidates.push(candidates[i]);
+    }
+  }
+  const resolved = resolveCollisions(fittingCandidates);
+  const results = [];
+  let resolvedIdx = 0;
+  for (let i = 0; i < candidates.length; i++) {
+    if (unfittingIndices.has(i)) {
+      results.push({
+        text: candidates[i].text,
+        x: candidates[i].anchorX,
+        y: candidates[i].anchorY,
+        style: candidates[i].style,
+        visible: false
+      });
+    } else {
+      results.push(resolved[resolvedIdx++]);
+    }
+  }
+  return results;
+}
+
+// src/charts/bar/index.ts
+var barRenderer = (spec, scales, chartArea, strategy, _theme) => {
+  const marks = computeBarMarks(spec, scales, chartArea, strategy);
+  const valueField = spec.encoding?.x && "field" in spec.encoding.x ? spec.encoding.x.field : void 0;
+  const labels = computeBarLabels(
+    marks,
+    chartArea,
+    spec.labels.density,
+    spec.labels.format,
+    spec.labels.prefix,
+    valueField
+  );
+  for (let i = 0; i < marks.length && i < labels.length; i++) {
+    marks[i].label = labels[i];
+  }
+  return marks;
+};
+
+// src/charts/column/compute.ts
+import { isGradientDef as isGradientDef2 } from "@opendata-ai/openchart-core";
+var MIN_COLUMN_HEIGHT = 1;
+function computeColumnMarks(spec, scales, _chartArea, _strategy) {
+  const encoding = spec.encoding;
+  const xChannel = encoding.x;
+  const yChannel = encoding.y;
+  if (!xChannel || !yChannel || !scales.x || !scales.y) {
+    return [];
+  }
+  const xScale = scales.x.scale;
+  const yScale = scales.y.scale;
+  if (typeof xScale.bandwidth !== "function") {
+    return [];
+  }
+  const bandwidth = xScale.bandwidth();
+  const baseline = yScale(0);
+  const colorEnc = encoding.color && "field" in encoding.color ? encoding.color : void 0;
+  const conditionalColor = encoding.color && isConditionalValueDef(encoding.color) ? encoding.color : void 0;
+  const colorField = colorEnc?.field;
+  const isSequentialColor = colorEnc?.type === "quantitative";
+  if (colorField && !isSequentialColor) {
+    const categoryGroups = groupByField(spec.data, xChannel.field);
+    const needsStacking = Array.from(categoryGroups.values()).some((rows) => rows.length > 1);
+    if (needsStacking) {
+      const stackDisabled = yChannel.stack === null || yChannel.stack === false;
+      if (stackDisabled) {
+        return computeGroupedColumns(
+          spec.data,
+          xChannel.field,
+          yChannel.field,
+          colorField,
+          xScale,
+          yScale,
+          bandwidth,
+          baseline,
+          scales
+        );
+      }
+      const stackMode = yChannel.stack === "normalize" ? "normalize" : yChannel.stack === "center" ? "center" : "zero";
+      return computeStackedColumns(
+        spec.data,
+        xChannel.field,
+        yChannel.field,
+        colorField,
+        xScale,
+        yScale,
+        bandwidth,
+        baseline,
+        scales,
+        stackMode
+      );
+    }
+    return computeColoredColumns(
+      spec.data,
+      xChannel.field,
+      yChannel.field,
+      colorField,
+      xScale,
+      yScale,
+      bandwidth,
+      baseline,
+      scales
+    );
+  }
+  return computeSimpleColumns(
+    spec.data,
+    xChannel.field,
+    yChannel.field,
+    xScale,
+    yScale,
+    bandwidth,
+    baseline,
+    scales,
+    isSequentialColor,
+    conditionalColor
+  );
+}
+function computeSimpleColumns(data, categoryField, valueField, xScale, yScale, bandwidth, baseline, scales, sequentialColor = false, conditionalColor) {
+  const marks = [];
+  for (const row of data) {
+    const category = String(row[categoryField] ?? "");
+    const value2 = Number(row[valueField] ?? 0);
+    if (!Number.isFinite(value2)) continue;
+    const bandX = xScale(category);
+    if (bandX === void 0) continue;
+    let color2;
+    if (conditionalColor) {
+      const resolved = resolveConditionalValue(row, conditionalColor);
+      if (resolved != null) {
+        color2 = isGradientDef2(resolved) ? resolved : String(resolved);
+      } else {
+        color2 = getColor(scales, "__default__");
+      }
+    } else if (sequentialColor) {
+      color2 = getSequentialColor(scales, value2);
+    } else {
+      color2 = getColor(scales, "__default__");
+    }
+    const yPos = yScale(value2);
+    const columnHeight = Math.max(Math.abs(baseline - yPos), MIN_COLUMN_HEIGHT);
+    const y2 = value2 >= 0 ? yPos : baseline;
+    const aria = {
+      label: `${category}: ${formatLabelValue(value2)}`
+    };
+    marks.push({
+      type: "rect",
+      x: bandX,
+      y: y2,
+      width: bandwidth,
+      height: columnHeight,
+      fill: color2,
+      cornerRadius: 2,
+      data: row,
+      aria,
+      orient: "vertical"
+    });
+  }
+  return marks;
+}
+function computeColoredColumns(data, categoryField, valueField, colorField, xScale, yScale, bandwidth, baseline, scales) {
+  const marks = [];
+  for (const row of data) {
+    const category = String(row[categoryField] ?? "");
+    const value2 = Number(row[valueField] ?? 0);
+    if (!Number.isFinite(value2)) continue;
+    const bandX = xScale(category);
+    if (bandX === void 0) continue;
+    const groupKey2 = String(row[colorField] ?? "");
+    const color2 = getColor(scales, groupKey2);
+    const yPos = yScale(value2);
+    const columnHeight = Math.max(Math.abs(baseline - yPos), MIN_COLUMN_HEIGHT);
+    const y2 = value2 >= 0 ? yPos : baseline;
+    const aria = {
+      label: `${category}, ${groupKey2}: ${formatLabelValue(value2)}`
+    };
+    marks.push({
+      type: "rect",
+      x: bandX,
+      y: y2,
+      width: bandwidth,
+      height: columnHeight,
+      fill: color2,
+      cornerRadius: 2,
+      data: row,
+      aria,
+      orient: "vertical"
+    });
+  }
+  return marks;
+}
+function computeGroupedColumns(data, categoryField, valueField, colorField, xScale, yScale, bandwidth, baseline, scales) {
+  const marks = [];
+  const categoryGroups = groupByField(data, categoryField);
+  const groupIndexMap = /* @__PURE__ */ new Map();
+  for (const row of data) {
+    const key = String(row[colorField] ?? "");
+    if (!groupIndexMap.has(key)) {
+      groupIndexMap.set(key, groupIndexMap.size);
+    }
+  }
+  const groupCount = groupIndexMap.size;
+  if (groupCount === 0) return marks;
+  const gap = Math.min(1, bandwidth * 0.05);
+  const subBandWidth = Math.max(
+    (bandwidth - gap * (groupCount - 1)) / groupCount,
+    MIN_COLUMN_HEIGHT
+  );
+  for (const [category, rows] of categoryGroups) {
+    const bandX = xScale(category);
+    if (bandX === void 0) continue;
+    for (const row of rows) {
+      const groupKey2 = String(row[colorField] ?? "");
+      const value2 = Number(row[valueField] ?? 0);
+      if (!Number.isFinite(value2)) continue;
+      const groupIndex = groupIndexMap.get(groupKey2) ?? 0;
+      const color2 = getColor(scales, groupKey2);
+      const yPos = yScale(value2);
+      const columnHeight = Math.max(Math.abs(baseline - yPos), MIN_COLUMN_HEIGHT);
+      const y2 = value2 >= 0 ? yPos : baseline;
+      const subX = bandX + groupIndex * (subBandWidth + gap);
+      const aria = {
+        label: `${category}, ${groupKey2}: ${formatLabelValue(value2)}`
+      };
+      marks.push({
+        type: "rect",
+        x: subX,
+        y: y2,
+        width: subBandWidth,
+        height: columnHeight,
+        fill: color2,
+        cornerRadius: 2,
+        data: row,
+        aria,
+        orient: "vertical"
+      });
+    }
+  }
+  return marks;
+}
+function computeStackedColumns(data, categoryField, valueField, colorField, xScale, yScale, bandwidth, _baseline, scales, stackMode = "zero") {
+  const marks = [];
+  const categoryGroups = groupByField(data, categoryField);
+  for (const [category, rows] of categoryGroups) {
+    const bandX = xScale(category);
+    if (bandX === void 0) continue;
+    let categoryTotal = 0;
+    for (const row of rows) {
+      const v = Number(row[valueField] ?? 0);
+      if (Number.isFinite(v) && v > 0) categoryTotal += v;
+    }
+    let cumulativeValue = stackMode === "center" ? -categoryTotal / 2 : 0;
+    for (const row of rows) {
+      const groupKey2 = String(row[colorField] ?? "");
+      const rawValue = Number(row[valueField] ?? 0);
+      if (!Number.isFinite(rawValue) || rawValue <= 0) continue;
+      const value2 = stackMode === "normalize" && categoryTotal > 0 ? rawValue / categoryTotal : rawValue;
+      const color2 = getColor(scales, groupKey2);
+      const yTop = yScale(cumulativeValue + value2);
+      const yBottom = yScale(cumulativeValue);
+      const columnHeight = Math.max(Math.abs(yBottom - yTop), MIN_COLUMN_HEIGHT);
+      const aria = {
+        label: `${category}, ${groupKey2}: ${formatLabelValue(rawValue)}`
+      };
+      marks.push({
+        type: "rect",
+        x: bandX,
+        y: Math.min(yTop, yBottom),
+        width: bandwidth,
+        height: columnHeight,
+        fill: color2,
+        cornerRadius: 0,
+        data: row,
+        aria,
+        orient: "vertical",
+        stackGroup: category
+      });
+      cumulativeValue += value2;
+    }
+  }
+  return marks;
+}
+
+// src/charts/column/labels.ts
+import {
+  buildD3Formatter as buildD3Formatter2,
+  estimateTextWidth as estimateTextWidth3,
+  getRepresentativeColor as getRepresentativeColor2,
+  resolveCollisions as resolveCollisions2
+} from "@opendata-ai/openchart-core";
+var LABEL_FONT_SIZE2 = 10;
+var LABEL_FONT_WEIGHT2 = 600;
+var LABEL_OFFSET_Y = 6;
+function computeColumnLabels(marks, _chartArea, density = "auto", labelFormat, labelPrefix, valueField) {
+  const targetMarks = filterByDensity(marks, density);
+  const formatter = buildD3Formatter2(labelFormat);
+  const candidates = [];
+  for (const mark of targetMarks) {
+    let valuePart;
+    const rawNum = valueField != null ? Number(mark.data[valueField]) : NaN;
+    if (formatter && Number.isFinite(rawNum)) {
+      valuePart = formatter(rawNum);
+    } else if (Number.isFinite(rawNum)) {
+      valuePart = formatLabelValue(rawNum);
+    } else {
+      const ariaLabel = mark.aria.label;
+      const lastColon = ariaLabel.lastIndexOf(":");
+      const rawValue = lastColon >= 0 ? ariaLabel.slice(lastColon + 1).trim() : "";
+      if (!rawValue) continue;
+      if (formatter) {
+        const num = Number(rawValue.replace(/[^0-9.-]/g, ""));
+        valuePart = !Number.isNaN(num) ? formatter(num) : rawValue;
+      } else {
+        valuePart = rawValue;
+      }
+    }
+    if (labelPrefix) valuePart = labelPrefix + valuePart;
+    const numericValue = parseFloat(valuePart);
+    const isNegative = Number.isFinite(numericValue) && numericValue < 0;
+    const textWidth = estimateTextWidth3(valuePart, LABEL_FONT_SIZE2, LABEL_FONT_WEIGHT2);
+    const textHeight = LABEL_FONT_SIZE2 * 1.2;
+    const anchorX = mark.x + mark.width / 2;
+    const anchorY = isNegative ? mark.y + mark.height + LABEL_OFFSET_Y : mark.y - LABEL_OFFSET_Y - textHeight;
+    candidates.push({
+      text: valuePart,
+      anchorX,
+      anchorY,
+      width: textWidth,
+      height: textHeight,
+      priority: "data",
+      style: {
+        fontFamily: "system-ui, -apple-system, sans-serif",
+        fontSize: LABEL_FONT_SIZE2,
+        fontWeight: LABEL_FONT_WEIGHT2,
+        fill: getRepresentativeColor2(mark.fill),
+        lineHeight: 1.2,
+        textAnchor: "middle",
+        dominantBaseline: isNegative ? "hanging" : "auto"
+      }
+    });
+  }
+  if (candidates.length === 0) return [];
+  if (density === "all") {
+    return candidates.map((c) => ({
+      text: c.text,
+      x: c.anchorX,
+      y: c.anchorY,
+      style: c.style,
+      visible: true
+    }));
+  }
+  return resolveCollisions2(candidates);
+}
+
+// src/charts/column/index.ts
+var columnRenderer = (spec, scales, chartArea, strategy, _theme) => {
+  const marks = computeColumnMarks(spec, scales, chartArea, strategy);
+  const valueField = spec.encoding?.y && "field" in spec.encoding.y ? spec.encoding.y.field : void 0;
+  const labels = computeColumnLabels(
+    marks,
+    chartArea,
+    spec.labels.density,
+    spec.labels.format,
+    spec.labels.prefix,
+    valueField
+  );
+  for (let i = 0; i < marks.length && i < labels.length; i++) {
+    marks[i].label = labels[i];
+  }
+  return marks;
+};
+
+// src/charts/dot/compute.ts
+var DOT_RADIUS = 6;
+var STEM_WIDTH = 2;
+var STEM_COLOR = "#cccccc";
+function computeDotMarks(spec, scales, _chartArea, _strategy) {
+  const encoding = spec.encoding;
+  const xChannel = encoding.x;
+  const yChannel = encoding.y;
+  if (!xChannel || !yChannel || !scales.x || !scales.y) {
+    return [];
+  }
+  const xScale = scales.x.scale;
+  const yScale = scales.y.scale;
+  if (typeof yScale.bandwidth !== "function") {
+    return [];
+  }
+  const bandwidth = yScale.bandwidth();
+  const [rangeStart, rangeEnd] = xScale.range();
+  const rangeMin = Math.min(rangeStart, rangeEnd);
+  const rangeMax = Math.max(rangeStart, rangeEnd);
+  const baseline = Math.max(rangeMin, Math.min(rangeMax, xScale(0)));
+  const colorEnc = encoding.color && "field" in encoding.color ? encoding.color : void 0;
+  const isSequentialColor = colorEnc?.type === "quantitative";
+  const colorField = isSequentialColor ? void 0 : colorEnc?.field;
+  if (colorField) {
+    return computeDumbbellMarks(
+      spec.data,
+      xChannel.field,
+      yChannel.field,
+      colorField,
+      xScale,
+      yScale,
+      bandwidth,
+      scales
+    );
+  }
+  return computeLollipopMarks(
+    spec.data,
+    xChannel.field,
+    yChannel.field,
+    xScale,
+    yScale,
+    bandwidth,
+    baseline,
+    scales,
+    isSequentialColor
+  );
+}
+function computeDumbbellMarks(data, valueField, categoryField, colorField, xScale, yScale, bandwidth, scales) {
+  const marks = [];
+  const categoryGroups = groupByField([...data], categoryField);
+  for (const [category, rows] of categoryGroups) {
+    const bandY = yScale(category);
+    if (bandY === void 0) continue;
+    const cy = bandY + bandwidth / 2;
+    const xValues = [];
+    for (const row of rows) {
+      const value2 = Number(row[valueField] ?? 0);
+      if (Number.isFinite(value2)) xValues.push(value2);
+    }
+    if (xValues.length === 0) continue;
+    const minVal = Math.min(...xValues);
+    const maxVal = Math.max(...xValues);
+    const xLeft = xScale(minVal);
+    const xRight = xScale(maxVal);
+    const barWidth = Math.abs(xRight - xLeft);
+    if (barWidth > 0) {
+      const stemAria = {
+        label: `Range for ${category}: ${minVal} to ${maxVal}`
+      };
+      marks.push({
+        type: "rect",
+        x: Math.min(xLeft, xRight),
+        y: cy - STEM_WIDTH / 2,
+        width: barWidth,
+        height: STEM_WIDTH,
+        fill: STEM_COLOR,
+        data: rows[0],
+        aria: stemAria
+      });
+    }
+    for (const row of rows) {
+      const value2 = Number(row[valueField] ?? 0);
+      if (!Number.isFinite(value2)) continue;
+      const cx = xScale(value2);
+      const colorCategory = String(row[colorField] ?? "");
+      const color2 = getColor(scales, colorCategory);
+      const dotAria = {
+        label: `${category}, ${colorCategory}: ${value2}`
+      };
+      marks.push({
+        type: "point",
+        cx,
+        cy,
+        r: DOT_RADIUS,
+        fill: color2,
+        stroke: "#ffffff",
+        strokeWidth: 2,
+        data: row,
+        aria: dotAria
+      });
+    }
+  }
+  return marks;
+}
+function computeLollipopMarks(data, valueField, categoryField, xScale, yScale, bandwidth, baseline, scales, isSequentialColor = false) {
+  const marks = [];
+  for (const row of data) {
+    const category = String(row[categoryField] ?? "");
+    const value2 = Number(row[valueField] ?? 0);
+    if (!Number.isFinite(value2)) continue;
+    const bandY = yScale(category);
+    if (bandY === void 0) continue;
+    const cx = xScale(value2);
+    const cy = bandY + bandwidth / 2;
+    const color2 = isSequentialColor ? getSequentialColor(scales, value2) : getColor(scales, "__default__");
+    const stemX = Math.min(baseline, cx);
+    const stemWidth = Math.abs(cx - baseline);
+    if (stemWidth > 0) {
+      const stemAria = {
+        label: `Stem for ${category}`
+      };
+      marks.push({
+        type: "rect",
+        x: stemX,
+        y: cy - STEM_WIDTH / 2,
+        width: stemWidth,
+        height: STEM_WIDTH,
+        fill: STEM_COLOR,
+        data: row,
+        aria: stemAria
+      });
+    }
+    const dotAria = {
+      label: `${category}: ${value2}`
+    };
+    marks.push({
+      type: "point",
+      cx,
+      cy,
+      r: DOT_RADIUS,
+      fill: color2,
+      stroke: "#ffffff",
+      strokeWidth: 2,
+      data: row,
+      aria: dotAria
+    });
+  }
+  return marks;
+}
+
+// src/charts/dot/labels.ts
+import {
+  buildD3Formatter as buildD3Formatter3,
+  estimateTextWidth as estimateTextWidth4,
+  getRepresentativeColor as getRepresentativeColor3,
+  resolveCollisions as resolveCollisions3
+} from "@opendata-ai/openchart-core";
+var LABEL_FONT_SIZE3 = 11;
+var LABEL_FONT_WEIGHT3 = 600;
+var LABEL_OFFSET_X = 10;
+function computeDotLabels(marks, _chartArea, density = "auto", labelPrefix, labelFormat, valueField) {
+  const targetMarks = filterByDensity(marks, density);
+  const formatter = buildD3Formatter3(labelFormat);
+  const candidates = [];
+  for (const mark of targetMarks) {
+    let valuePart;
+    const rawNum = valueField != null ? Number(mark.data[valueField]) : NaN;
+    if (formatter && Number.isFinite(rawNum)) {
+      valuePart = formatter(rawNum);
+    } else if (Number.isFinite(rawNum)) {
+      valuePart = formatLabelValue(rawNum);
+    } else {
+      const ariaLabel = mark.aria.label;
+      const lastColon = ariaLabel.lastIndexOf(":");
+      valuePart = lastColon >= 0 ? ariaLabel.slice(lastColon + 1).trim() : "";
+      if (!valuePart) continue;
+      if (formatter) {
+        const num = Number(valuePart.replace(/[^0-9.-]/g, ""));
+        if (!Number.isNaN(num)) valuePart = formatter(num);
+      }
+    }
+    if (labelPrefix) valuePart = labelPrefix + valuePart;
+    const textWidth = estimateTextWidth4(valuePart, LABEL_FONT_SIZE3, LABEL_FONT_WEIGHT3);
+    const textHeight = LABEL_FONT_SIZE3 * 1.2;
+    candidates.push({
+      text: valuePart,
+      anchorX: mark.cx + mark.r + LABEL_OFFSET_X,
+      anchorY: mark.cy - textHeight / 2,
+      width: textWidth,
+      height: textHeight,
+      priority: "data",
+      style: {
+        fontFamily: "system-ui, -apple-system, sans-serif",
+        fontSize: LABEL_FONT_SIZE3,
+        fontWeight: LABEL_FONT_WEIGHT3,
+        fill: getRepresentativeColor3(mark.fill),
+        lineHeight: 1.2,
+        textAnchor: "start",
+        dominantBaseline: "central"
+      }
+    });
+  }
+  if (candidates.length === 0) return [];
+  if (density === "all") {
+    return candidates.map((c) => ({
+      text: c.text,
+      x: c.anchorX,
+      y: c.anchorY,
+      style: c.style,
+      visible: true
+    }));
+  }
+  return resolveCollisions3(candidates);
+}
+
+// src/charts/dot/index.ts
+var dotRenderer = (spec, scales, chartArea, strategy, _theme) => {
+  const marks = computeDotMarks(spec, scales, chartArea, strategy);
+  const pointMarks = marks.filter((m) => m.type === "point");
+  const valueField = spec.encoding?.x && "field" in spec.encoding.x ? spec.encoding.x.field : void 0;
+  const labels = computeDotLabels(
+    pointMarks,
+    chartArea,
+    spec.labels.density,
+    spec.labels.prefix,
+    spec.labels.format,
+    valueField
+  );
+  let labelIdx = 0;
+  for (const mark of marks) {
+    if (mark.type === "point" && labelIdx < labels.length) {
+      mark.label = labels[labelIdx];
+      labelIdx++;
+    }
+  }
+  return marks;
+};
+
+// src/charts/line/index.ts
+import { getRepresentativeColor as getRepresentativeColor6 } from "@opendata-ai/openchart-core";
+
+// src/charts/line/area.ts
+import { getRepresentativeColor as getRepresentativeColor4 } from "@opendata-ai/openchart-core";
+
+// ../../node_modules/.bun/d3-shape@3.2.0/node_modules/d3-shape/src/constant.js
+function constant_default(x2) {
+  return function constant2() {
+    return x2;
+  };
+}
+
+// ../../node_modules/.bun/d3-shape@3.2.0/node_modules/d3-shape/src/math.js
+var abs = Math.abs;
+var atan2 = Math.atan2;
+var cos = Math.cos;
+var max = Math.max;
+var min = Math.min;
+var sin = Math.sin;
+var sqrt = Math.sqrt;
+var epsilon = 1e-12;
+var pi = Math.PI;
+var halfPi = pi / 2;
+var tau = 2 * pi;
+function acos(x2) {
+  return x2 > 1 ? 0 : x2 < -1 ? pi : Math.acos(x2);
+}
+function asin(x2) {
+  return x2 >= 1 ? halfPi : x2 <= -1 ? -halfPi : Math.asin(x2);
+}
+
+// ../../node_modules/.bun/d3-path@3.1.0/node_modules/d3-path/src/path.js
+var pi2 = Math.PI;
+var tau2 = 2 * pi2;
+var epsilon2 = 1e-6;
+var tauEpsilon = tau2 - epsilon2;
+function append(strings) {
+  this._ += strings[0];
+  for (let i = 1, n = strings.length; i < n; ++i) {
+    this._ += arguments[i] + strings[i];
+  }
+}
+function appendRound(digits) {
+  let d = Math.floor(digits);
+  if (!(d >= 0)) throw new Error(`invalid digits: ${digits}`);
+  if (d > 15) return append;
+  const k = 10 ** d;
+  return function(strings) {
+    this._ += strings[0];
+    for (let i = 1, n = strings.length; i < n; ++i) {
+      this._ += Math.round(arguments[i] * k) / k + strings[i];
+    }
+  };
+}
+var Path = class {
+  constructor(digits) {
+    this._x0 = this._y0 = // start of current subpath
+    this._x1 = this._y1 = null;
+    this._ = "";
+    this._append = digits == null ? append : appendRound(digits);
+  }
+  moveTo(x2, y2) {
+    this._append`M${this._x0 = this._x1 = +x2},${this._y0 = this._y1 = +y2}`;
+  }
+  closePath() {
+    if (this._x1 !== null) {
+      this._x1 = this._x0, this._y1 = this._y0;
+      this._append`Z`;
+    }
+  }
+  lineTo(x2, y2) {
+    this._append`L${this._x1 = +x2},${this._y1 = +y2}`;
+  }
+  quadraticCurveTo(x1, y1, x2, y2) {
+    this._append`Q${+x1},${+y1},${this._x1 = +x2},${this._y1 = +y2}`;
+  }
+  bezierCurveTo(x1, y1, x2, y2, x3, y3) {
+    this._append`C${+x1},${+y1},${+x2},${+y2},${this._x1 = +x3},${this._y1 = +y3}`;
+  }
+  arcTo(x1, y1, x2, y2, r) {
+    x1 = +x1, y1 = +y1, x2 = +x2, y2 = +y2, r = +r;
+    if (r < 0) throw new Error(`negative radius: ${r}`);
+    let x0 = this._x1, y0 = this._y1, x21 = x2 - x1, y21 = y2 - y1, x01 = x0 - x1, y01 = y0 - y1, l01_2 = x01 * x01 + y01 * y01;
+    if (this._x1 === null) {
+      this._append`M${this._x1 = x1},${this._y1 = y1}`;
+    } else if (!(l01_2 > epsilon2)) ;
+    else if (!(Math.abs(y01 * x21 - y21 * x01) > epsilon2) || !r) {
+      this._append`L${this._x1 = x1},${this._y1 = y1}`;
+    } else {
+      let x20 = x2 - x0, y20 = y2 - y0, l21_2 = x21 * x21 + y21 * y21, l20_2 = x20 * x20 + y20 * y20, l21 = Math.sqrt(l21_2), l01 = Math.sqrt(l01_2), l = r * Math.tan((pi2 - Math.acos((l21_2 + l01_2 - l20_2) / (2 * l21 * l01))) / 2), t01 = l / l01, t21 = l / l21;
+      if (Math.abs(t01 - 1) > epsilon2) {
+        this._append`L${x1 + t01 * x01},${y1 + t01 * y01}`;
+      }
+      this._append`A${r},${r},0,0,${+(y01 * x20 > x01 * y20)},${this._x1 = x1 + t21 * x21},${this._y1 = y1 + t21 * y21}`;
+    }
+  }
+  arc(x2, y2, r, a0, a1, ccw) {
+    x2 = +x2, y2 = +y2, r = +r, ccw = !!ccw;
+    if (r < 0) throw new Error(`negative radius: ${r}`);
+    let dx = r * Math.cos(a0), dy = r * Math.sin(a0), x0 = x2 + dx, y0 = y2 + dy, cw = 1 ^ ccw, da = ccw ? a0 - a1 : a1 - a0;
+    if (this._x1 === null) {
+      this._append`M${x0},${y0}`;
+    } else if (Math.abs(this._x1 - x0) > epsilon2 || Math.abs(this._y1 - y0) > epsilon2) {
+      this._append`L${x0},${y0}`;
+    }
+    if (!r) return;
+    if (da < 0) da = da % tau2 + tau2;
+    if (da > tauEpsilon) {
+      this._append`A${r},${r},0,1,${cw},${x2 - dx},${y2 - dy}A${r},${r},0,1,${cw},${this._x1 = x0},${this._y1 = y0}`;
+    } else if (da > epsilon2) {
+      this._append`A${r},${r},0,${+(da >= pi2)},${cw},${this._x1 = x2 + r * Math.cos(a1)},${this._y1 = y2 + r * Math.sin(a1)}`;
+    }
+  }
+  rect(x2, y2, w, h) {
+    this._append`M${this._x0 = this._x1 = +x2},${this._y0 = this._y1 = +y2}h${w = +w}v${+h}h${-w}Z`;
+  }
+  toString() {
+    return this._;
+  }
+};
+function path() {
+  return new Path();
+}
+path.prototype = Path.prototype;
+
+// ../../node_modules/.bun/d3-shape@3.2.0/node_modules/d3-shape/src/path.js
+function withPath(shape) {
+  let digits = 3;
+  shape.digits = function(_) {
+    if (!arguments.length) return digits;
+    if (_ == null) {
+      digits = null;
+    } else {
+      const d = Math.floor(_);
+      if (!(d >= 0)) throw new RangeError(`invalid digits: ${_}`);
+      digits = d;
+    }
+    return shape;
+  };
+  return () => new Path(digits);
+}
+
+// ../../node_modules/.bun/d3-shape@3.2.0/node_modules/d3-shape/src/arc.js
+function arcInnerRadius(d) {
+  return d.innerRadius;
+}
+function arcOuterRadius(d) {
+  return d.outerRadius;
+}
+function arcStartAngle(d) {
+  return d.startAngle;
+}
+function arcEndAngle(d) {
+  return d.endAngle;
+}
+function arcPadAngle(d) {
+  return d && d.padAngle;
+}
+function intersect(x0, y0, x1, y1, x2, y2, x3, y3) {
+  var x10 = x1 - x0, y10 = y1 - y0, x32 = x3 - x2, y32 = y3 - y2, t = y32 * x10 - x32 * y10;
+  if (t * t < epsilon) return;
+  t = (x32 * (y0 - y2) - y32 * (x0 - x2)) / t;
+  return [x0 + t * x10, y0 + t * y10];
+}
+function cornerTangents(x0, y0, x1, y1, r1, rc, cw) {
+  var x01 = x0 - x1, y01 = y0 - y1, lo = (cw ? rc : -rc) / sqrt(x01 * x01 + y01 * y01), ox = lo * y01, oy = -lo * x01, x11 = x0 + ox, y11 = y0 + oy, x10 = x1 + ox, y10 = y1 + oy, x00 = (x11 + x10) / 2, y00 = (y11 + y10) / 2, dx = x10 - x11, dy = y10 - y11, d2 = dx * dx + dy * dy, r = r1 - rc, D = x11 * y10 - x10 * y11, d = (dy < 0 ? -1 : 1) * sqrt(max(0, r * r * d2 - D * D)), cx0 = (D * dy - dx * d) / d2, cy0 = (-D * dx - dy * d) / d2, cx1 = (D * dy + dx * d) / d2, cy1 = (-D * dx + dy * d) / d2, dx0 = cx0 - x00, dy0 = cy0 - y00, dx1 = cx1 - x00, dy1 = cy1 - y00;
+  if (dx0 * dx0 + dy0 * dy0 > dx1 * dx1 + dy1 * dy1) cx0 = cx1, cy0 = cy1;
+  return {
+    cx: cx0,
+    cy: cy0,
+    x01: -ox,
+    y01: -oy,
+    x11: cx0 * (r1 / r - 1),
+    y11: cy0 * (r1 / r - 1)
+  };
+}
+function arc_default() {
+  var innerRadius = arcInnerRadius, outerRadius = arcOuterRadius, cornerRadius = constant_default(0), padRadius = null, startAngle = arcStartAngle, endAngle = arcEndAngle, padAngle = arcPadAngle, context = null, path2 = withPath(arc);
+  function arc() {
+    var buffer, r, r0 = +innerRadius.apply(this, arguments), r1 = +outerRadius.apply(this, arguments), a0 = startAngle.apply(this, arguments) - halfPi, a1 = endAngle.apply(this, arguments) - halfPi, da = abs(a1 - a0), cw = a1 > a0;
+    if (!context) context = buffer = path2();
+    if (r1 < r0) r = r1, r1 = r0, r0 = r;
+    if (!(r1 > epsilon)) context.moveTo(0, 0);
+    else if (da > tau - epsilon) {
+      context.moveTo(r1 * cos(a0), r1 * sin(a0));
+      context.arc(0, 0, r1, a0, a1, !cw);
+      if (r0 > epsilon) {
+        context.moveTo(r0 * cos(a1), r0 * sin(a1));
+        context.arc(0, 0, r0, a1, a0, cw);
+      }
+    } else {
+      var a01 = a0, a11 = a1, a00 = a0, a10 = a1, da0 = da, da1 = da, ap = padAngle.apply(this, arguments) / 2, rp = ap > epsilon && (padRadius ? +padRadius.apply(this, arguments) : sqrt(r0 * r0 + r1 * r1)), rc = min(abs(r1 - r0) / 2, +cornerRadius.apply(this, arguments)), rc0 = rc, rc1 = rc, t02, t12;
+      if (rp > epsilon) {
+        var p0 = asin(rp / r0 * sin(ap)), p1 = asin(rp / r1 * sin(ap));
+        if ((da0 -= p0 * 2) > epsilon) p0 *= cw ? 1 : -1, a00 += p0, a10 -= p0;
+        else da0 = 0, a00 = a10 = (a0 + a1) / 2;
+        if ((da1 -= p1 * 2) > epsilon) p1 *= cw ? 1 : -1, a01 += p1, a11 -= p1;
+        else da1 = 0, a01 = a11 = (a0 + a1) / 2;
+      }
+      var x01 = r1 * cos(a01), y01 = r1 * sin(a01), x10 = r0 * cos(a10), y10 = r0 * sin(a10);
+      if (rc > epsilon) {
+        var x11 = r1 * cos(a11), y11 = r1 * sin(a11), x00 = r0 * cos(a00), y00 = r0 * sin(a00), oc;
+        if (da < pi) {
+          if (oc = intersect(x01, y01, x00, y00, x11, y11, x10, y10)) {
+            var ax = x01 - oc[0], ay = y01 - oc[1], bx = x11 - oc[0], by = y11 - oc[1], kc = 1 / sin(acos((ax * bx + ay * by) / (sqrt(ax * ax + ay * ay) * sqrt(bx * bx + by * by))) / 2), lc = sqrt(oc[0] * oc[0] + oc[1] * oc[1]);
+            rc0 = min(rc, (r0 - lc) / (kc - 1));
+            rc1 = min(rc, (r1 - lc) / (kc + 1));
+          } else {
+            rc0 = rc1 = 0;
+          }
+        }
+      }
+      if (!(da1 > epsilon)) context.moveTo(x01, y01);
+      else if (rc1 > epsilon) {
+        t02 = cornerTangents(x00, y00, x01, y01, r1, rc1, cw);
+        t12 = cornerTangents(x11, y11, x10, y10, r1, rc1, cw);
+        context.moveTo(t02.cx + t02.x01, t02.cy + t02.y01);
+        if (rc1 < rc) context.arc(t02.cx, t02.cy, rc1, atan2(t02.y01, t02.x01), atan2(t12.y01, t12.x01), !cw);
+        else {
+          context.arc(t02.cx, t02.cy, rc1, atan2(t02.y01, t02.x01), atan2(t02.y11, t02.x11), !cw);
+          context.arc(0, 0, r1, atan2(t02.cy + t02.y11, t02.cx + t02.x11), atan2(t12.cy + t12.y11, t12.cx + t12.x11), !cw);
+          context.arc(t12.cx, t12.cy, rc1, atan2(t12.y11, t12.x11), atan2(t12.y01, t12.x01), !cw);
+        }
+      } else context.moveTo(x01, y01), context.arc(0, 0, r1, a01, a11, !cw);
+      if (!(r0 > epsilon) || !(da0 > epsilon)) context.lineTo(x10, y10);
+      else if (rc0 > epsilon) {
+        t02 = cornerTangents(x10, y10, x11, y11, r0, -rc0, cw);
+        t12 = cornerTangents(x01, y01, x00, y00, r0, -rc0, cw);
+        context.lineTo(t02.cx + t02.x01, t02.cy + t02.y01);
+        if (rc0 < rc) context.arc(t02.cx, t02.cy, rc0, atan2(t02.y01, t02.x01), atan2(t12.y01, t12.x01), !cw);
+        else {
+          context.arc(t02.cx, t02.cy, rc0, atan2(t02.y01, t02.x01), atan2(t02.y11, t02.x11), !cw);
+          context.arc(0, 0, r0, atan2(t02.cy + t02.y11, t02.cx + t02.x11), atan2(t12.cy + t12.y11, t12.cx + t12.x11), cw);
+          context.arc(t12.cx, t12.cy, rc0, atan2(t12.y11, t12.x11), atan2(t12.y01, t12.x01), !cw);
+        }
+      } else context.arc(0, 0, r0, a10, a00, cw);
+    }
+    context.closePath();
+    if (buffer) return context = null, buffer + "" || null;
+  }
+  arc.centroid = function() {
+    var r = (+innerRadius.apply(this, arguments) + +outerRadius.apply(this, arguments)) / 2, a = (+startAngle.apply(this, arguments) + +endAngle.apply(this, arguments)) / 2 - pi / 2;
+    return [cos(a) * r, sin(a) * r];
+  };
+  arc.innerRadius = function(_) {
+    return arguments.length ? (innerRadius = typeof _ === "function" ? _ : constant_default(+_), arc) : innerRadius;
+  };
+  arc.outerRadius = function(_) {
+    return arguments.length ? (outerRadius = typeof _ === "function" ? _ : constant_default(+_), arc) : outerRadius;
+  };
+  arc.cornerRadius = function(_) {
+    return arguments.length ? (cornerRadius = typeof _ === "function" ? _ : constant_default(+_), arc) : cornerRadius;
+  };
+  arc.padRadius = function(_) {
+    return arguments.length ? (padRadius = _ == null ? null : typeof _ === "function" ? _ : constant_default(+_), arc) : padRadius;
+  };
+  arc.startAngle = function(_) {
+    return arguments.length ? (startAngle = typeof _ === "function" ? _ : constant_default(+_), arc) : startAngle;
+  };
+  arc.endAngle = function(_) {
+    return arguments.length ? (endAngle = typeof _ === "function" ? _ : constant_default(+_), arc) : endAngle;
+  };
+  arc.padAngle = function(_) {
+    return arguments.length ? (padAngle = typeof _ === "function" ? _ : constant_default(+_), arc) : padAngle;
+  };
+  arc.context = function(_) {
+    return arguments.length ? (context = _ == null ? null : _, arc) : context;
+  };
+  return arc;
+}
+
+// ../../node_modules/.bun/d3-shape@3.2.0/node_modules/d3-shape/src/array.js
+var slice = Array.prototype.slice;
+function array_default(x2) {
+  return typeof x2 === "object" && "length" in x2 ? x2 : Array.from(x2);
+}
+
+// ../../node_modules/.bun/d3-shape@3.2.0/node_modules/d3-shape/src/curve/linear.js
+function Linear(context) {
+  this._context = context;
+}
+Linear.prototype = {
+  areaStart: function() {
+    this._line = 0;
+  },
+  areaEnd: function() {
+    this._line = NaN;
+  },
+  lineStart: function() {
+    this._point = 0;
+  },
+  lineEnd: function() {
+    if (this._line || this._line !== 0 && this._point === 1) this._context.closePath();
+    this._line = 1 - this._line;
+  },
+  point: function(x2, y2) {
+    x2 = +x2, y2 = +y2;
+    switch (this._point) {
+      case 0:
+        this._point = 1;
+        this._line ? this._context.lineTo(x2, y2) : this._context.moveTo(x2, y2);
+        break;
+      case 1:
+        this._point = 2;
+      // falls through
+      default:
+        this._context.lineTo(x2, y2);
+        break;
+    }
+  }
+};
+function linear_default(context) {
+  return new Linear(context);
+}
+
+// ../../node_modules/.bun/d3-shape@3.2.0/node_modules/d3-shape/src/point.js
+function x(p) {
+  return p[0];
+}
+function y(p) {
+  return p[1];
+}
+
+// ../../node_modules/.bun/d3-shape@3.2.0/node_modules/d3-shape/src/line.js
+function line_default(x2, y2) {
+  var defined = constant_default(true), context = null, curve = linear_default, output = null, path2 = withPath(line);
+  x2 = typeof x2 === "function" ? x2 : x2 === void 0 ? x : constant_default(x2);
+  y2 = typeof y2 === "function" ? y2 : y2 === void 0 ? y : constant_default(y2);
+  function line(data) {
+    var i, n = (data = array_default(data)).length, d, defined0 = false, buffer;
+    if (context == null) output = curve(buffer = path2());
+    for (i = 0; i <= n; ++i) {
+      if (!(i < n && defined(d = data[i], i, data)) === defined0) {
+        if (defined0 = !defined0) output.lineStart();
+        else output.lineEnd();
+      }
+      if (defined0) output.point(+x2(d, i, data), +y2(d, i, data));
+    }
+    if (buffer) return output = null, buffer + "" || null;
+  }
+  line.x = function(_) {
+    return arguments.length ? (x2 = typeof _ === "function" ? _ : constant_default(+_), line) : x2;
+  };
+  line.y = function(_) {
+    return arguments.length ? (y2 = typeof _ === "function" ? _ : constant_default(+_), line) : y2;
+  };
+  line.defined = function(_) {
+    return arguments.length ? (defined = typeof _ === "function" ? _ : constant_default(!!_), line) : defined;
+  };
+  line.curve = function(_) {
+    return arguments.length ? (curve = _, context != null && (output = curve(context)), line) : curve;
+  };
+  line.context = function(_) {
+    return arguments.length ? (_ == null ? context = output = null : output = curve(context = _), line) : context;
+  };
+  return line;
+}
+
+// ../../node_modules/.bun/d3-shape@3.2.0/node_modules/d3-shape/src/area.js
+function area_default(x0, y0, y1) {
+  var x1 = null, defined = constant_default(true), context = null, curve = linear_default, output = null, path2 = withPath(area);
+  x0 = typeof x0 === "function" ? x0 : x0 === void 0 ? x : constant_default(+x0);
+  y0 = typeof y0 === "function" ? y0 : y0 === void 0 ? constant_default(0) : constant_default(+y0);
+  y1 = typeof y1 === "function" ? y1 : y1 === void 0 ? y : constant_default(+y1);
+  function area(data) {
+    var i, j, k, n = (data = array_default(data)).length, d, defined0 = false, buffer, x0z = new Array(n), y0z = new Array(n);
+    if (context == null) output = curve(buffer = path2());
+    for (i = 0; i <= n; ++i) {
+      if (!(i < n && defined(d = data[i], i, data)) === defined0) {
+        if (defined0 = !defined0) {
+          j = i;
+          output.areaStart();
+          output.lineStart();
+        } else {
+          output.lineEnd();
+          output.lineStart();
+          for (k = i - 1; k >= j; --k) {
+            output.point(x0z[k], y0z[k]);
+          }
+          output.lineEnd();
+          output.areaEnd();
+        }
+      }
+      if (defined0) {
+        x0z[i] = +x0(d, i, data), y0z[i] = +y0(d, i, data);
+        output.point(x1 ? +x1(d, i, data) : x0z[i], y1 ? +y1(d, i, data) : y0z[i]);
+      }
+    }
+    if (buffer) return output = null, buffer + "" || null;
+  }
+  function arealine() {
+    return line_default().defined(defined).curve(curve).context(context);
+  }
+  area.x = function(_) {
+    return arguments.length ? (x0 = typeof _ === "function" ? _ : constant_default(+_), x1 = null, area) : x0;
+  };
+  area.x0 = function(_) {
+    return arguments.length ? (x0 = typeof _ === "function" ? _ : constant_default(+_), area) : x0;
+  };
+  area.x1 = function(_) {
+    return arguments.length ? (x1 = _ == null ? null : typeof _ === "function" ? _ : constant_default(+_), area) : x1;
+  };
+  area.y = function(_) {
+    return arguments.length ? (y0 = typeof _ === "function" ? _ : constant_default(+_), y1 = null, area) : y0;
+  };
+  area.y0 = function(_) {
+    return arguments.length ? (y0 = typeof _ === "function" ? _ : constant_default(+_), area) : y0;
+  };
+  area.y1 = function(_) {
+    return arguments.length ? (y1 = _ == null ? null : typeof _ === "function" ? _ : constant_default(+_), area) : y1;
+  };
+  area.lineX0 = area.lineY0 = function() {
+    return arealine().x(x0).y(y0);
+  };
+  area.lineY1 = function() {
+    return arealine().x(x0).y(y1);
+  };
+  area.lineX1 = function() {
+    return arealine().x(x1).y(y0);
+  };
+  area.defined = function(_) {
+    return arguments.length ? (defined = typeof _ === "function" ? _ : constant_default(!!_), area) : defined;
+  };
+  area.curve = function(_) {
+    return arguments.length ? (curve = _, context != null && (output = curve(context)), area) : curve;
+  };
+  area.context = function(_) {
+    return arguments.length ? (_ == null ? context = output = null : output = curve(context = _), area) : context;
+  };
+  return area;
+}
+
+// ../../node_modules/.bun/d3-shape@3.2.0/node_modules/d3-shape/src/descending.js
+function descending_default(a, b) {
+  return b < a ? -1 : b > a ? 1 : b >= a ? 0 : NaN;
+}
+
+// ../../node_modules/.bun/d3-shape@3.2.0/node_modules/d3-shape/src/identity.js
+function identity_default(d) {
+  return d;
+}
+
+// ../../node_modules/.bun/d3-shape@3.2.0/node_modules/d3-shape/src/pie.js
+function pie_default() {
+  var value2 = identity_default, sortValues = descending_default, sort = null, startAngle = constant_default(0), endAngle = constant_default(tau), padAngle = constant_default(0);
+  function pie(data) {
+    var i, n = (data = array_default(data)).length, j, k, sum2 = 0, index = new Array(n), arcs = new Array(n), a0 = +startAngle.apply(this, arguments), da = Math.min(tau, Math.max(-tau, endAngle.apply(this, arguments) - a0)), a1, p = Math.min(Math.abs(da) / n, padAngle.apply(this, arguments)), pa = p * (da < 0 ? -1 : 1), v;
+    for (i = 0; i < n; ++i) {
+      if ((v = arcs[index[i] = i] = +value2(data[i], i, data)) > 0) {
+        sum2 += v;
+      }
+    }
+    if (sortValues != null) index.sort(function(i2, j2) {
+      return sortValues(arcs[i2], arcs[j2]);
+    });
+    else if (sort != null) index.sort(function(i2, j2) {
+      return sort(data[i2], data[j2]);
+    });
+    for (i = 0, k = sum2 ? (da - n * pa) / sum2 : 0; i < n; ++i, a0 = a1) {
+      j = index[i], v = arcs[j], a1 = a0 + (v > 0 ? v * k : 0) + pa, arcs[j] = {
+        data: data[j],
+        index: i,
+        value: v,
+        startAngle: a0,
+        endAngle: a1,
+        padAngle: p
+      };
+    }
+    return arcs;
+  }
+  pie.value = function(_) {
+    return arguments.length ? (value2 = typeof _ === "function" ? _ : constant_default(+_), pie) : value2;
+  };
+  pie.sortValues = function(_) {
+    return arguments.length ? (sortValues = _, sort = null, pie) : sortValues;
+  };
+  pie.sort = function(_) {
+    return arguments.length ? (sort = _, sortValues = null, pie) : sort;
+  };
+  pie.startAngle = function(_) {
+    return arguments.length ? (startAngle = typeof _ === "function" ? _ : constant_default(+_), pie) : startAngle;
+  };
+  pie.endAngle = function(_) {
+    return arguments.length ? (endAngle = typeof _ === "function" ? _ : constant_default(+_), pie) : endAngle;
+  };
+  pie.padAngle = function(_) {
+    return arguments.length ? (padAngle = typeof _ === "function" ? _ : constant_default(+_), pie) : padAngle;
+  };
+  return pie;
+}
+
+// ../../node_modules/.bun/d3-shape@3.2.0/node_modules/d3-shape/src/curve/basis.js
+function point(that, x2, y2) {
+  that._context.bezierCurveTo(
+    (2 * that._x0 + that._x1) / 3,
+    (2 * that._y0 + that._y1) / 3,
+    (that._x0 + 2 * that._x1) / 3,
+    (that._y0 + 2 * that._y1) / 3,
+    (that._x0 + 4 * that._x1 + x2) / 6,
+    (that._y0 + 4 * that._y1 + y2) / 6
+  );
+}
+function Basis(context) {
+  this._context = context;
+}
+Basis.prototype = {
+  areaStart: function() {
+    this._line = 0;
+  },
+  areaEnd: function() {
+    this._line = NaN;
+  },
+  lineStart: function() {
+    this._x0 = this._x1 = this._y0 = this._y1 = NaN;
+    this._point = 0;
+  },
+  lineEnd: function() {
+    switch (this._point) {
+      case 3:
+        point(this, this._x1, this._y1);
+      // falls through
+      case 2:
+        this._context.lineTo(this._x1, this._y1);
+        break;
+    }
+    if (this._line || this._line !== 0 && this._point === 1) this._context.closePath();
+    this._line = 1 - this._line;
+  },
+  point: function(x2, y2) {
+    x2 = +x2, y2 = +y2;
+    switch (this._point) {
+      case 0:
+        this._point = 1;
+        this._line ? this._context.lineTo(x2, y2) : this._context.moveTo(x2, y2);
+        break;
+      case 1:
+        this._point = 2;
+        break;
+      case 2:
+        this._point = 3;
+        this._context.lineTo((5 * this._x0 + this._x1) / 6, (5 * this._y0 + this._y1) / 6);
+      // falls through
+      default:
+        point(this, x2, y2);
+        break;
+    }
+    this._x0 = this._x1, this._x1 = x2;
+    this._y0 = this._y1, this._y1 = y2;
+  }
+};
+function basis_default(context) {
+  return new Basis(context);
+}
+
+// ../../node_modules/.bun/d3-shape@3.2.0/node_modules/d3-shape/src/curve/cardinal.js
+function point2(that, x2, y2) {
+  that._context.bezierCurveTo(
+    that._x1 + that._k * (that._x2 - that._x0),
+    that._y1 + that._k * (that._y2 - that._y0),
+    that._x2 + that._k * (that._x1 - x2),
+    that._y2 + that._k * (that._y1 - y2),
+    that._x2,
+    that._y2
+  );
+}
+function Cardinal(context, tension) {
+  this._context = context;
+  this._k = (1 - tension) / 6;
+}
+Cardinal.prototype = {
+  areaStart: function() {
+    this._line = 0;
+  },
+  areaEnd: function() {
+    this._line = NaN;
+  },
+  lineStart: function() {
+    this._x0 = this._x1 = this._x2 = this._y0 = this._y1 = this._y2 = NaN;
+    this._point = 0;
+  },
+  lineEnd: function() {
+    switch (this._point) {
+      case 2:
+        this._context.lineTo(this._x2, this._y2);
+        break;
+      case 3:
+        point2(this, this._x1, this._y1);
+        break;
+    }
+    if (this._line || this._line !== 0 && this._point === 1) this._context.closePath();
+    this._line = 1 - this._line;
+  },
+  point: function(x2, y2) {
+    x2 = +x2, y2 = +y2;
+    switch (this._point) {
+      case 0:
+        this._point = 1;
+        this._line ? this._context.lineTo(x2, y2) : this._context.moveTo(x2, y2);
+        break;
+      case 1:
+        this._point = 2;
+        this._x1 = x2, this._y1 = y2;
+        break;
+      case 2:
+        this._point = 3;
+      // falls through
+      default:
+        point2(this, x2, y2);
+        break;
+    }
+    this._x0 = this._x1, this._x1 = this._x2, this._x2 = x2;
+    this._y0 = this._y1, this._y1 = this._y2, this._y2 = y2;
+  }
+};
+var cardinal_default = (function custom(tension) {
+  function cardinal(context) {
+    return new Cardinal(context, tension);
+  }
+  cardinal.tension = function(tension2) {
+    return custom(+tension2);
+  };
+  return cardinal;
+})(0);
+
+// ../../node_modules/.bun/d3-shape@3.2.0/node_modules/d3-shape/src/curve/monotone.js
+function sign(x2) {
+  return x2 < 0 ? -1 : 1;
+}
+function slope3(that, x2, y2) {
+  var h0 = that._x1 - that._x0, h1 = x2 - that._x1, s0 = (that._y1 - that._y0) / (h0 || h1 < 0 && -0), s1 = (y2 - that._y1) / (h1 || h0 < 0 && -0), p = (s0 * h1 + s1 * h0) / (h0 + h1);
+  return (sign(s0) + sign(s1)) * Math.min(Math.abs(s0), Math.abs(s1), 0.5 * Math.abs(p)) || 0;
+}
+function slope2(that, t) {
+  var h = that._x1 - that._x0;
+  return h ? (3 * (that._y1 - that._y0) / h - t) / 2 : t;
+}
+function point3(that, t02, t12) {
+  var x0 = that._x0, y0 = that._y0, x1 = that._x1, y1 = that._y1, dx = (x1 - x0) / 3;
+  that._context.bezierCurveTo(x0 + dx, y0 + dx * t02, x1 - dx, y1 - dx * t12, x1, y1);
+}
+function MonotoneX(context) {
+  this._context = context;
+}
+MonotoneX.prototype = {
+  areaStart: function() {
+    this._line = 0;
+  },
+  areaEnd: function() {
+    this._line = NaN;
+  },
+  lineStart: function() {
+    this._x0 = this._x1 = this._y0 = this._y1 = this._t0 = NaN;
+    this._point = 0;
+  },
+  lineEnd: function() {
+    switch (this._point) {
+      case 2:
+        this._context.lineTo(this._x1, this._y1);
+        break;
+      case 3:
+        point3(this, this._t0, slope2(this, this._t0));
+        break;
+    }
+    if (this._line || this._line !== 0 && this._point === 1) this._context.closePath();
+    this._line = 1 - this._line;
+  },
+  point: function(x2, y2) {
+    var t12 = NaN;
+    x2 = +x2, y2 = +y2;
+    if (x2 === this._x1 && y2 === this._y1) return;
+    switch (this._point) {
+      case 0:
+        this._point = 1;
+        this._line ? this._context.lineTo(x2, y2) : this._context.moveTo(x2, y2);
+        break;
+      case 1:
+        this._point = 2;
+        break;
+      case 2:
+        this._point = 3;
+        point3(this, slope2(this, t12 = slope3(this, x2, y2)), t12);
+        break;
+      default:
+        point3(this, this._t0, t12 = slope3(this, x2, y2));
+        break;
+    }
+    this._x0 = this._x1, this._x1 = x2;
+    this._y0 = this._y1, this._y1 = y2;
+    this._t0 = t12;
+  }
+};
+function MonotoneY(context) {
+  this._context = new ReflectContext(context);
+}
+(MonotoneY.prototype = Object.create(MonotoneX.prototype)).point = function(x2, y2) {
+  MonotoneX.prototype.point.call(this, y2, x2);
+};
+function ReflectContext(context) {
+  this._context = context;
+}
+ReflectContext.prototype = {
+  moveTo: function(x2, y2) {
+    this._context.moveTo(y2, x2);
+  },
+  closePath: function() {
+    this._context.closePath();
+  },
+  lineTo: function(x2, y2) {
+    this._context.lineTo(y2, x2);
+  },
+  bezierCurveTo: function(x1, y1, x2, y2, x3, y3) {
+    this._context.bezierCurveTo(y1, x1, y2, x2, y3, x3);
+  }
+};
+function monotoneX(context) {
+  return new MonotoneX(context);
+}
+
+// ../../node_modules/.bun/d3-shape@3.2.0/node_modules/d3-shape/src/curve/natural.js
+function Natural(context) {
+  this._context = context;
+}
+Natural.prototype = {
+  areaStart: function() {
+    this._line = 0;
+  },
+  areaEnd: function() {
+    this._line = NaN;
+  },
+  lineStart: function() {
+    this._x = [];
+    this._y = [];
+  },
+  lineEnd: function() {
+    var x2 = this._x, y2 = this._y, n = x2.length;
+    if (n) {
+      this._line ? this._context.lineTo(x2[0], y2[0]) : this._context.moveTo(x2[0], y2[0]);
+      if (n === 2) {
+        this._context.lineTo(x2[1], y2[1]);
+      } else {
+        var px = controlPoints(x2), py = controlPoints(y2);
+        for (var i0 = 0, i1 = 1; i1 < n; ++i0, ++i1) {
+          this._context.bezierCurveTo(px[0][i0], py[0][i0], px[1][i0], py[1][i0], x2[i1], y2[i1]);
+        }
+      }
+    }
+    if (this._line || this._line !== 0 && n === 1) this._context.closePath();
+    this._line = 1 - this._line;
+    this._x = this._y = null;
+  },
+  point: function(x2, y2) {
+    this._x.push(+x2);
+    this._y.push(+y2);
+  }
+};
+function controlPoints(x2) {
+  var i, n = x2.length - 1, m, a = new Array(n), b = new Array(n), r = new Array(n);
+  a[0] = 0, b[0] = 2, r[0] = x2[0] + 2 * x2[1];
+  for (i = 1; i < n - 1; ++i) a[i] = 1, b[i] = 4, r[i] = 4 * x2[i] + 2 * x2[i + 1];
+  a[n - 1] = 2, b[n - 1] = 7, r[n - 1] = 8 * x2[n - 1] + x2[n];
+  for (i = 1; i < n; ++i) m = a[i] / b[i - 1], b[i] -= m, r[i] -= m * r[i - 1];
+  a[n - 1] = r[n - 1] / b[n - 1];
+  for (i = n - 2; i >= 0; --i) a[i] = (r[i] - a[i + 1]) / b[i];
+  b[n - 1] = (x2[n] + a[n - 1]) / 2;
+  for (i = 0; i < n - 1; ++i) b[i] = 2 * x2[i + 1] - a[i + 1];
+  return [a, b];
+}
+function natural_default(context) {
+  return new Natural(context);
+}
+
+// ../../node_modules/.bun/d3-shape@3.2.0/node_modules/d3-shape/src/curve/step.js
+function Step(context, t) {
+  this._context = context;
+  this._t = t;
+}
+Step.prototype = {
+  areaStart: function() {
+    this._line = 0;
+  },
+  areaEnd: function() {
+    this._line = NaN;
+  },
+  lineStart: function() {
+    this._x = this._y = NaN;
+    this._point = 0;
+  },
+  lineEnd: function() {
+    if (0 < this._t && this._t < 1 && this._point === 2) this._context.lineTo(this._x, this._y);
+    if (this._line || this._line !== 0 && this._point === 1) this._context.closePath();
+    if (this._line >= 0) this._t = 1 - this._t, this._line = 1 - this._line;
+  },
+  point: function(x2, y2) {
+    x2 = +x2, y2 = +y2;
+    switch (this._point) {
+      case 0:
+        this._point = 1;
+        this._line ? this._context.lineTo(x2, y2) : this._context.moveTo(x2, y2);
+        break;
+      case 1:
+        this._point = 2;
+      // falls through
+      default: {
+        if (this._t <= 0) {
+          this._context.lineTo(this._x, y2);
+          this._context.lineTo(x2, y2);
+        } else {
+          var x1 = this._x * (1 - this._t) + x2 * this._t;
+          this._context.lineTo(x1, this._y);
+          this._context.lineTo(x1, y2);
+        }
+        break;
+      }
+    }
+    this._x = x2, this._y = y2;
+  }
+};
+function step_default(context) {
+  return new Step(context, 0.5);
+}
+function stepBefore(context) {
+  return new Step(context, 0);
+}
+function stepAfter(context) {
+  return new Step(context, 1);
+}
+
+// ../../node_modules/.bun/d3-shape@3.2.0/node_modules/d3-shape/src/offset/none.js
+function none_default(series, order) {
+  if (!((n = series.length) > 1)) return;
+  for (var i = 1, j, s0, s1 = series[order[0]], n, m = s1.length; i < n; ++i) {
+    s0 = s1, s1 = series[order[i]];
+    for (j = 0; j < m; ++j) {
+      s1[j][1] += s1[j][0] = isNaN(s0[j][1]) ? s0[j][0] : s0[j][1];
+    }
+  }
+}
+
+// ../../node_modules/.bun/d3-shape@3.2.0/node_modules/d3-shape/src/order/none.js
+function none_default2(series) {
+  var n = series.length, o = new Array(n);
+  while (--n >= 0) o[n] = n;
+  return o;
+}
+
+// ../../node_modules/.bun/d3-shape@3.2.0/node_modules/d3-shape/src/stack.js
+function stackValue(d, key) {
+  return d[key];
+}
+function stackSeries(key) {
+  const series = [];
+  series.key = key;
+  return series;
+}
+function stack_default() {
+  var keys = constant_default([]), order = none_default2, offset = none_default, value2 = stackValue;
+  function stack(data) {
+    var sz = Array.from(keys.apply(this, arguments), stackSeries), i, n = sz.length, j = -1, oz;
+    for (const d of data) {
+      for (i = 0, ++j; i < n; ++i) {
+        (sz[i][j] = [0, +value2(d, sz[i].key, j, data)]).data = d;
+      }
+    }
+    for (i = 0, oz = array_default(order(sz)); i < n; ++i) {
+      sz[oz[i]].index = i;
+    }
+    offset(sz, oz);
+    return sz;
+  }
+  stack.keys = function(_) {
+    return arguments.length ? (keys = typeof _ === "function" ? _ : constant_default(Array.from(_)), stack) : keys;
+  };
+  stack.value = function(_) {
+    return arguments.length ? (value2 = typeof _ === "function" ? _ : constant_default(+_), stack) : value2;
+  };
+  stack.order = function(_) {
+    return arguments.length ? (order = _ == null ? none_default2 : typeof _ === "function" ? _ : constant_default(Array.from(_)), stack) : order;
+  };
+  stack.offset = function(_) {
+    return arguments.length ? (offset = _ == null ? none_default : _, stack) : offset;
+  };
+  return stack;
+}
+
+// ../../node_modules/.bun/d3-shape@3.2.0/node_modules/d3-shape/src/offset/expand.js
+function expand_default(series, order) {
+  if (!((n = series.length) > 0)) return;
+  for (var i, n, j = 0, m = series[0].length, y2; j < m; ++j) {
+    for (y2 = i = 0; i < n; ++i) y2 += series[i][j][1] || 0;
+    if (y2) for (i = 0; i < n; ++i) series[i][j][1] /= y2;
+  }
+  none_default(series, order);
+}
+
+// ../../node_modules/.bun/d3-shape@3.2.0/node_modules/d3-shape/src/offset/silhouette.js
+function silhouette_default(series, order) {
+  if (!((n = series.length) > 0)) return;
+  for (var j = 0, s0 = series[order[0]], n, m = s0.length; j < m; ++j) {
+    for (var i = 0, y2 = 0; i < n; ++i) y2 += series[i][j][1] || 0;
+    s0[j][1] += s0[j][0] = -y2 / 2;
+  }
+  none_default(series, order);
+}
+
+// src/charts/line/curves.ts
+var CURVE_MAP = {
+  linear: linear_default,
+  monotone: monotoneX,
+  step: step_default,
+  "step-before": stepBefore,
+  "step-after": stepAfter,
+  basis: basis_default,
+  cardinal: cardinal_default,
+  natural: natural_default
+};
+function resolveCurve(interpolate) {
+  if (!interpolate) return monotoneX;
+  return CURVE_MAP[interpolate] ?? monotoneX;
+}
+
+// src/charts/line/area.ts
+var DEFAULT_FILL_OPACITY = 0.15;
+function computeSingleArea(spec, scales, _chartArea) {
+  const encoding = spec.encoding;
+  const xChannel = encoding.x;
+  const yChannel = encoding.y;
+  if (!xChannel || !yChannel || !scales.x || !scales.y) return [];
+  const yScale = scales.y.scale;
+  const domain = yScale.domain();
+  const baselineY = yScale(Math.min(domain[0], domain[1]));
+  const colorField = encoding.color && "field" in encoding.color ? encoding.color.field : void 0;
+  const groups = /* @__PURE__ */ new Map();
+  if (!colorField) {
+    groups.set("__default__", spec.data);
+  } else {
+    for (const row of spec.data) {
+      const key = String(row[colorField] ?? "__default__");
+      const existing = groups.get(key);
+      if (existing) {
+        existing.push(row);
+      } else {
+        groups.set(key, [row]);
+      }
+    }
+  }
+  const marks = [];
+  for (const [seriesKey, rows] of groups) {
+    const color2 = getColor(scales, seriesKey);
+    const sortedRows = xChannel.type === "nominal" || xChannel.type === "ordinal" ? rows : sortByField(rows, xChannel.field);
+    const validPoints = [];
+    for (const row of sortedRows) {
+      const xVal = scaleValue(scales.x.scale, scales.x.type, row[xChannel.field]);
+      const yVal = scaleValue(scales.y.scale, scales.y.type, row[yChannel.field]);
+      if (xVal === null || yVal === null) continue;
+      validPoints.push({
+        x: xVal,
+        yTop: yVal,
+        yBottom: baselineY,
+        row
+      });
+    }
+    if (validPoints.length === 0) continue;
+    const curve = resolveCurve(spec.markDef.interpolate);
+    const areaGenerator = area_default().x((d) => d.x).y0((d) => d.yBottom).y1((d) => d.yTop).curve(curve);
+    const pathStr = areaGenerator(validPoints) ?? "";
+    const topLineGenerator = line_default().x((d) => d.x).y((d) => d.yTop).curve(curve);
+    const topPathStr = topLineGenerator(validPoints) ?? "";
+    const topPoints = validPoints.map((p) => ({ x: p.x, y: p.yTop }));
+    const bottomPoints = validPoints.map((p) => ({ x: p.x, y: p.yBottom }));
+    const ariaLabel = seriesKey === "__default__" ? `Area with ${validPoints.length} data points` : `${seriesKey}: area with ${validPoints.length} data points`;
+    const aria = { label: ariaLabel };
+    marks.push({
+      type: "area",
+      topPoints,
+      bottomPoints,
+      path: pathStr,
+      topPath: topPathStr,
+      fill: color2,
+      fillOpacity: DEFAULT_FILL_OPACITY,
+      stroke: getRepresentativeColor4(color2),
+      strokeWidth: 2,
+      seriesKey: seriesKey === "__default__" ? void 0 : seriesKey,
+      data: validPoints.map((p) => p.row),
+      dataPoints: validPoints.map((p) => ({ x: p.x, y: p.yTop, datum: p.row })),
+      aria
+    });
+  }
+  return marks;
+}
+function computeStackedArea(spec, scales, chartArea) {
+  const encoding = spec.encoding;
+  const xChannel = encoding.x;
+  const yChannel = encoding.y;
+  const colorField = encoding.color && "field" in encoding.color ? encoding.color.field : void 0;
+  if (!xChannel || !yChannel || !scales.x || !scales.y || !colorField) {
+    return computeSingleArea(spec, scales, chartArea);
+  }
+  const sortedData = xChannel.type === "nominal" || xChannel.type === "ordinal" ? spec.data : sortByField(spec.data, xChannel.field);
+  const seriesKeys = /* @__PURE__ */ new Set();
+  const xValueSet = /* @__PURE__ */ new Set();
+  const rowsByXSeries = /* @__PURE__ */ new Map();
+  const rowsByX = /* @__PURE__ */ new Map();
+  for (const row of sortedData) {
+    const xStr = String(row[xChannel.field]);
+    const series = String(row[colorField]);
+    seriesKeys.add(series);
+    xValueSet.add(xStr);
+    rowsByXSeries.set(`${xStr}::${series}`, row);
+    const existing = rowsByX.get(xStr);
+    if (existing) {
+      existing.push(row);
+    } else {
+      rowsByX.set(xStr, [row]);
+    }
+  }
+  const keys = Array.from(seriesKeys);
+  const xValues = Array.from(xValueSet);
+  const pivotData = xValues.map((xVal) => {
+    const pivot = { __x__: xVal };
+    for (const key of keys) {
+      pivot[key] = 0;
+    }
+    const xRows = rowsByX.get(xVal);
+    if (xRows) {
+      for (const row of xRows) {
+        const series = String(row[colorField]);
+        pivot[series] = row[yChannel.field] ?? 0;
+      }
+    }
+    return pivot;
+  });
+  const stackProp = yChannel.stack;
+  const offsetFn = stackProp === "normalize" ? expand_default : stackProp === "center" ? silhouette_default : none_default;
+  const stackGenerator = stack_default().keys(keys).order(none_default2).offset(offsetFn);
+  const stackedData = stackGenerator(pivotData);
+  const yScale = scales.y.scale;
+  const marks = [];
+  for (const layer of stackedData) {
+    const seriesKey = layer.key;
+    const color2 = getColor(scales, seriesKey);
+    const validPoints = [];
+    for (const d of layer) {
+      const xVal = scaleValue(scales.x.scale, scales.x.type, d.data.__x__);
+      if (xVal === null) continue;
+      const yTop = yScale(d[1]);
+      const yBottom = yScale(d[0]);
+      validPoints.push({ x: xVal, yTop, yBottom });
+    }
+    if (validPoints.length === 0) continue;
+    const stackCurve = resolveCurve(spec.markDef.interpolate);
+    const areaGenerator = area_default().x((p) => p.x).y0((p) => p.yBottom).y1((p) => p.yTop).curve(stackCurve);
+    const pathStr = areaGenerator(validPoints) ?? "";
+    const topLineGenerator = line_default().x((p) => p.x).y((p) => p.yTop).curve(stackCurve);
+    const topPathStr = topLineGenerator(validPoints) ?? "";
+    const topPoints = validPoints.map((p) => ({ x: p.x, y: p.yTop }));
+    const bottomPoints = validPoints.map((p) => ({ x: p.x, y: p.yBottom }));
+    const aria = {
+      label: `${seriesKey}: stacked area with ${validPoints.length} data points`
+    };
+    marks.push({
+      type: "area",
+      topPoints,
+      bottomPoints,
+      path: pathStr,
+      topPath: topPathStr,
+      fill: color2,
+      fillOpacity: 0.7,
+      // Higher opacity for stacked so layers are visible
+      stroke: getRepresentativeColor4(color2),
+      strokeWidth: 1,
+      seriesKey,
+      data: layer.map((d) => {
+        const xStr = String(d.data.__x__);
+        return rowsByXSeries.get(`${xStr}::${seriesKey}`) ?? d.data;
+      }),
+      dataPoints: validPoints.map((p, idx) => {
+        const xStr = String(layer[idx]?.data.__x__);
+        const datum = rowsByXSeries.get(`${xStr}::${seriesKey}`) ?? layer[idx]?.data ?? {};
+        return { x: p.x, y: p.yTop, datum };
+      }),
+      aria
+    });
+  }
+  return marks;
+}
+function computeAreaMarks(spec, scales, chartArea) {
+  const encoding = spec.encoding;
+  const hasColor = !!encoding.color;
+  if (hasColor) {
+    return computeStackedArea(spec, scales, chartArea);
+  }
+  return computeSingleArea(spec, scales, chartArea);
+}
+
+// src/charts/line/compute.ts
+import { getRepresentativeColor as getRepresentativeColor5 } from "@opendata-ai/openchart-core";
+var DEFAULT_STROKE_WIDTH = 2.5;
+var DEFAULT_POINT_RADIUS = 3;
+function computeLineMarks(spec, scales, _chartArea, _strategy) {
+  const encoding = spec.encoding;
+  const xChannel = encoding.x;
+  const yChannel = encoding.y;
+  if (!xChannel || !yChannel || !scales.x || !scales.y) {
+    return [];
   }
-  if (pred.gt !== void 0) {
-    return numValue > pred.gt;
+  const colorEnc = encoding.color && "field" in encoding.color ? encoding.color : void 0;
+  const isSequentialColor = colorEnc?.type === "quantitative";
+  const colorField = isSequentialColor ? void 0 : colorEnc?.field;
+  const sequentialColorField = isSequentialColor ? colorEnc.field : void 0;
+  const groups = groupByField(spec.data, colorField);
+  const marks = [];
+  for (const [seriesKey, rows] of groups) {
+    const color2 = isSequentialColor ? getSequentialColor(scales, _getMidValue(rows, sequentialColorField)) : getColor(scales, seriesKey);
+    const strokeColor = getRepresentativeColor5(color2);
+    const sortedRows = xChannel.type === "nominal" || xChannel.type === "ordinal" ? rows : sortByField(rows, xChannel.field);
+    const pointsWithData = [];
+    const segments = [];
+    let currentSegment = [];
+    for (const row of sortedRows) {
+      const xVal = scaleValue(scales.x.scale, scales.x.type, row[xChannel.field]);
+      const yVal = scaleValue(scales.y.scale, scales.y.type, row[yChannel.field]);
+      if (xVal === null || yVal === null) {
+        if (currentSegment.length > 0) {
+          segments.push(currentSegment);
+          currentSegment = [];
+        }
+        continue;
+      }
+      const point5 = { x: xVal, y: yVal };
+      currentSegment.push(point5);
+      pointsWithData.push({ ...point5, row });
+    }
+    if (currentSegment.length > 0) {
+      segments.push(currentSegment);
+    }
+    const curve = resolveCurve(spec.markDef.interpolate);
+    const lineGenerator = line_default().x((d) => d.x).y((d) => d.y).curve(curve);
+    const allPoints = [];
+    const pathParts = [];
+    for (const segment of segments) {
+      if (segment.length === 0) continue;
+      const pathStr = lineGenerator(segment);
+      if (pathStr) {
+        pathParts.push(pathStr);
+      }
+      allPoints.push(...segment);
+    }
+    if (allPoints.length === 0) continue;
+    const ariaLabel = seriesKey === "__default__" ? `Line with ${allPoints.length} data points` : `${seriesKey}: line with ${allPoints.length} data points`;
+    const aria = {
+      label: ariaLabel
+    };
+    const combinedPath = pathParts.join(" ");
+    const seriesStyleKey = seriesKey === "__default__" ? void 0 : seriesKey;
+    const styleOverride = seriesStyleKey ? spec.seriesStyles?.[seriesStyleKey] : void 0;
+    let strokeDasharray;
+    if (styleOverride?.lineStyle === "dashed") strokeDasharray = "6 4";
+    else if (styleOverride?.lineStyle === "dotted") strokeDasharray = "2 3";
+    const lineMark = {
+      type: "line",
+      points: allPoints,
+      path: combinedPath,
+      stroke: strokeColor,
+      strokeWidth: styleOverride?.strokeWidth ?? DEFAULT_STROKE_WIDTH,
+      strokeDasharray,
+      opacity: styleOverride?.opacity,
+      seriesKey: seriesStyleKey,
+      data: pointsWithData.map((p) => p.row),
+      dataPoints: pointsWithData.map((p) => ({ x: p.x, y: p.y, datum: p.row })),
+      aria
+    };
+    marks.push(lineMark);
+    const markPoint = spec.markDef.point;
+    const showPoints = markPoint === true || markPoint === "transparent" || isSequentialColor;
+    if (showPoints) {
+      const isTransparent = markPoint === "transparent";
+      const seriesShowPoints = styleOverride?.showPoints !== false;
+      for (let i = 0; i < pointsWithData.length; i++) {
+        const p = pointsWithData[i];
+        const visible = seriesShowPoints && !isTransparent;
+        let pointColor = color2;
+        if (isSequentialColor) {
+          const val = Number(p.row[sequentialColorField]);
+          pointColor = Number.isFinite(val) ? getSequentialColor(scales, val) : color2;
+        }
+        const pointMark = {
+          type: "point",
+          cx: p.x,
+          cy: p.y,
+          r: visible ? DEFAULT_POINT_RADIUS : 0,
+          fill: pointColor,
+          stroke: visible ? "#ffffff" : "transparent",
+          strokeWidth: visible ? 1.5 : 0,
+          fillOpacity: isTransparent ? 0 : 1,
+          data: p.row,
+          aria: {
+            label: `Data point: ${xChannel.field}=${String(p.row[xChannel.field])}, ${yChannel.field}=${String(p.row[yChannel.field])}`
+          }
+        };
+        marks.push(pointMark);
+      }
+    }
   }
-  if (pred.gte !== void 0) {
-    return numValue >= pred.gte;
+  return marks;
+}
+function _getMidValue(rows, field) {
+  const values = rows.map((r) => Number(r[field])).filter(Number.isFinite);
+  if (values.length === 0) return 0;
+  const sorted = values.sort((a, b) => a - b);
+  return sorted[Math.floor(sorted.length / 2)];
+}
+
+// src/charts/line/labels.ts
+import {
+  EXTENDED_OFFSET_STRATEGIES,
+  estimateTextWidth as estimateTextWidth5,
+  resolveCollisions as resolveCollisions4
+} from "@opendata-ai/openchart-core";
+var LABEL_FONT_SIZE4 = 11;
+var LABEL_FONT_WEIGHT4 = 600;
+var LABEL_OFFSET_X2 = 6;
+function computeLineLabels(marks, strategy, density = "auto", labelOffsets) {
+  const result = /* @__PURE__ */ new Map();
+  if (density === "none") return result;
+  if (strategy.labelMode === "none") {
+    return result;
   }
-  if (pred.range !== void 0) {
-    const [min3, max3] = pred.range;
-    return numValue >= min3 && numValue <= max3;
+  const candidates = [];
+  const seriesOrder = [];
+  for (const mark of marks) {
+    if (mark.points.length === 0) continue;
+    const labelText = mark.seriesKey ?? "";
+    if (!labelText) continue;
+    const lastPoint = mark.points[mark.points.length - 1];
+    const textWidth = estimateTextWidth5(labelText, LABEL_FONT_SIZE4, LABEL_FONT_WEIGHT4);
+    const textHeight = LABEL_FONT_SIZE4 * 1.2;
+    candidates.push({
+      text: labelText,
+      anchorX: lastPoint.x + LABEL_OFFSET_X2,
+      anchorY: lastPoint.y - textHeight / 2,
+      width: textWidth,
+      height: textHeight,
+      priority: "data",
+      style: {
+        fontFamily: "system-ui, -apple-system, sans-serif",
+        fontSize: LABEL_FONT_SIZE4,
+        fontWeight: LABEL_FONT_WEIGHT4,
+        fill: mark.stroke,
+        lineHeight: 1.2,
+        textAnchor: "start",
+        dominantBaseline: "central"
+      }
+    });
+    seriesOrder.push(labelText);
+  }
+  if (candidates.length === 0) return result;
+  if (density === "all") {
+    for (let i = 0; i < candidates.length; i++) {
+      const c = candidates[i];
+      const seriesKey = seriesOrder[i];
+      const userOffset = labelOffsets?.[seriesKey];
+      result.set(seriesKey, {
+        text: c.text,
+        x: c.anchorX + (userOffset?.dx ?? 0),
+        y: c.anchorY + (userOffset?.dy ?? 0),
+        style: c.style,
+        visible: true
+      });
+    }
+    return result;
   }
-  if (pred.oneOf !== void 0) {
-    return pred.oneOf.some((v) => v == value2);
+  const resolved = resolveCollisions4(candidates, EXTENDED_OFFSET_STRATEGIES);
+  for (let i = 0; i < resolved.length; i++) {
+    const seriesKey = seriesOrder[i];
+    const label = resolved[i];
+    const userOffset = labelOffsets?.[seriesKey];
+    if (userOffset) {
+      label.x += userOffset.dx ?? 0;
+      label.y += userOffset.dy ?? 0;
+    }
+    result.set(seriesKey, label);
   }
-  return true;
+  return result;
 }
-function evaluatePredicate(datum, predicate) {
-  if (isFieldPredicate(predicate)) {
-    return evaluateFieldPredicate(datum, predicate);
+
+// src/charts/line/index.ts
+var lineRenderer = (spec, scales, chartArea, strategy, _theme) => {
+  const marks = computeLineMarks(spec, scales, chartArea, strategy);
+  const lineMarks = marks.filter((m) => m.type === "line");
+  const labelMap = computeLineLabels(lineMarks, strategy, spec.labels.density, spec.labels.offsets);
+  for (const mark of marks) {
+    if (mark.type === "line" && mark.seriesKey) {
+      const label = labelMap.get(mark.seriesKey);
+      if (label) {
+        mark.label = label;
+      }
+    }
   }
-  if ("and" in predicate) {
-    return predicate.and.every((p) => evaluatePredicate(datum, p));
+  return marks;
+};
+var areaRenderer = (spec, scales, chartArea, strategy, _theme) => {
+  const areas = computeAreaMarks(spec, scales, chartArea);
+  const encoding = spec.encoding;
+  const hasColor = !!(encoding.color && "field" in encoding.color);
+  const lines = hasColor ? linesFromAreas(areas) : computeLineMarks(spec, scales, chartArea, strategy);
+  return [...areas, ...lines];
+};
+function linesFromAreas(areas) {
+  return areas.map((a) => ({
+    type: "line",
+    points: a.topPoints,
+    path: a.topPath,
+    stroke: getRepresentativeColor6(a.fill),
+    strokeWidth: a.strokeWidth ?? 1,
+    seriesKey: a.seriesKey,
+    data: a.data,
+    dataPoints: a.dataPoints,
+    aria: { label: `${a.seriesKey ?? "Series"}: line with ${a.topPoints.length} data points` }
+  }));
+}
+
+// src/charts/pie/compute.ts
+import { isConditionalDef, isGradientDef as isGradientDef3 } from "@opendata-ai/openchart-core";
+var SMALL_SLICE_THRESHOLD = 0.03;
+var DEFAULT_PALETTE = [
+  "#1b7fa3",
+  "#c44e52",
+  "#6a9f58",
+  "#d47215",
+  "#507e79",
+  "#9a6a8d",
+  "#c4636b",
+  "#9c755f",
+  "#a88f22",
+  "#858078"
+];
+function groupSmallSlices(slices, threshold2) {
+  const total = slices.reduce((sum2, s) => sum2 + s.value, 0);
+  if (total === 0) return slices;
+  const big = [];
+  let otherValue = 0;
+  for (const slice2 of slices) {
+    if (slice2.value / total < threshold2) {
+      otherValue += slice2.value;
+    } else {
+      big.push(slice2);
+    }
   }
-  if ("or" in predicate) {
-    return predicate.or.some((p) => evaluatePredicate(datum, p));
+  if (otherValue > 0) {
+    big.push({
+      label: "Other",
+      value: otherValue,
+      originalRow: { label: "Other", value: otherValue }
+    });
   }
-  if ("not" in predicate) {
-    return !evaluatePredicate(datum, predicate.not);
+  return big;
+}
+function computePieMarks(spec, scales, chartArea, _strategy, isDonut = false) {
+  const encoding = spec.encoding;
+  const valueChannel = encoding.y ?? encoding.x;
+  const categoryField = encoding.color && "field" in encoding.color ? encoding.color.field : void 0;
+  const conditionalColor = encoding.color && isConditionalDef(encoding.color) ? encoding.color : void 0;
+  if (!valueChannel) return [];
+  let slices = [];
+  if (categoryField) {
+    const categoryTotals = /* @__PURE__ */ new Map();
+    const categoryRows = /* @__PURE__ */ new Map();
+    for (const row of spec.data) {
+      const cat = String(row[categoryField] ?? "");
+      const val = Number(row[valueChannel.field] ?? 0);
+      if (!Number.isFinite(val) || val < 0) continue;
+      categoryTotals.set(cat, (categoryTotals.get(cat) ?? 0) + val);
+      if (!categoryRows.has(cat)) {
+        categoryRows.set(cat, row);
+      }
+    }
+    for (const [label, value2] of categoryTotals) {
+      slices.push({
+        label,
+        value: value2,
+        originalRow: categoryRows.get(label) ?? {
+          [categoryField]: label,
+          [valueChannel.field]: value2
+        }
+      });
+    }
+  } else {
+    for (let i = 0; i < spec.data.length; i++) {
+      const row = spec.data[i];
+      const val = Number(row[valueChannel.field] ?? 0);
+      if (!Number.isFinite(val) || val < 0) continue;
+      const label = String(row.label ?? row.name ?? row.category ?? `Slice ${i + 1}`);
+      slices.push({ label, value: val, originalRow: row });
+    }
+  }
+  if (slices.length === 0) return [];
+  slices.sort((a, b) => b.value - a.value);
+  slices = groupSmallSlices(slices, SMALL_SLICE_THRESHOLD);
+  const pieGenerator = pie_default().value((d) => d.value).sort(null).padAngle(0.01);
+  const arcs = pieGenerator(slices);
+  const centerX = chartArea.x + chartArea.width / 2;
+  const centerY = chartArea.y + chartArea.height / 2;
+  const outerRadius = Math.min(chartArea.width, chartArea.height) / 2 * 0.85;
+  const innerRadius = isDonut ? outerRadius * 0.6 : 0;
+  const arcGenerator = arc_default().innerRadius(innerRadius).outerRadius(outerRadius);
+  const marks = [];
+  const center2 = { x: centerX, y: centerY };
+  const total = slices.reduce((sum2, s) => sum2 + s.value, 0);
+  for (let i = 0; i < arcs.length; i++) {
+    const arcDatum = arcs[i];
+    const slice2 = arcDatum.data;
+    let color2;
+    if (conditionalColor) {
+      const resolved = resolveConditionalValue(
+        slice2.originalRow,
+        conditionalColor
+      );
+      if (resolved != null) {
+        color2 = isGradientDef3(resolved) ? resolved : String(resolved);
+      } else if (scales.color && categoryField) {
+        const colorScale = scales.color.scale;
+        color2 = colorScale(slice2.label);
+      } else {
+        color2 = DEFAULT_PALETTE[i % DEFAULT_PALETTE.length];
+      }
+    } else if (scales.color && categoryField) {
+      const colorScale = scales.color.scale;
+      color2 = colorScale(slice2.label);
+    } else {
+      color2 = DEFAULT_PALETTE[i % DEFAULT_PALETTE.length];
+    }
+    const path2 = arcGenerator(arcDatum) ?? "";
+    const centroidResult = arcGenerator.centroid(arcDatum);
+    const percentage = total > 0 ? (slice2.value / total * 100).toFixed(1) : "0";
+    const aria = {
+      label: `${slice2.label}: ${slice2.value} (${percentage}%)`
+    };
+    marks.push({
+      type: "arc",
+      path: path2,
+      centroid: {
+        x: centroidResult[0] + centerX,
+        y: centroidResult[1] + centerY
+      },
+      center: center2,
+      innerRadius,
+      outerRadius,
+      startAngle: arcDatum.startAngle,
+      endAngle: arcDatum.endAngle,
+      fill: color2,
+      stroke: "#ffffff",
+      strokeWidth: 2,
+      data: slice2.originalRow,
+      aria
+    });
   }
-  return true;
+  return marks;
 }
 
-// src/transforms/conditional.ts
-function resolveConditionalValue(datum, channelDef) {
-  const conditions = Array.isArray(channelDef.condition) ? channelDef.condition : [channelDef.condition];
-  for (const cond of conditions) {
-    if (evaluatePredicate(datum, cond.test)) {
-      if (cond.field !== void 0) {
-        return datum[cond.field];
+// src/charts/pie/labels.ts
+import { estimateTextWidth as estimateTextWidth6, resolveCollisions as resolveCollisions5 } from "@opendata-ai/openchart-core";
+var LABEL_FONT_SIZE5 = 10;
+var LABEL_FONT_WEIGHT5 = 500;
+var LEADER_LINE_OFFSET = 12;
+function computePieLabels(marks, _chartArea, density = "auto", _textFill = "#333333") {
+  if (marks.length === 0) return [];
+  const centerX = marks[0].center.x;
+  const centerY = marks[0].center.y;
+  const targetMarks = filterByDensity(marks, density);
+  if (targetMarks.length === 0) return [];
+  const candidates = [];
+  const targetMarkIndices = [];
+  for (let mi = 0; mi < targetMarks.length; mi++) {
+    const mark = targetMarks[mi];
+    const ariaLabel = mark.aria.label;
+    const firstColon = ariaLabel.indexOf(":");
+    const labelText = firstColon >= 0 ? ariaLabel.slice(0, firstColon).trim() : "";
+    if (!labelText) continue;
+    const textWidth = estimateTextWidth6(labelText, LABEL_FONT_SIZE5, LABEL_FONT_WEIGHT5);
+    const textHeight = LABEL_FONT_SIZE5 * 1.2;
+    const midAngle = (mark.startAngle + mark.endAngle) / 2;
+    const labelRadius = mark.outerRadius + LEADER_LINE_OFFSET;
+    const labelX = centerX + Math.sin(midAngle) * labelRadius;
+    const labelY = centerY - Math.cos(midAngle) * labelRadius;
+    const isRight = Math.sin(midAngle) > 0;
+    candidates.push({
+      text: labelText,
+      anchorX: isRight ? labelX : labelX - textWidth,
+      anchorY: labelY - textHeight / 2,
+      width: textWidth,
+      height: textHeight,
+      priority: "data",
+      style: {
+        fontFamily: "system-ui, -apple-system, sans-serif",
+        fontSize: LABEL_FONT_SIZE5,
+        fontWeight: LABEL_FONT_WEIGHT5,
+        fill: _textFill,
+        lineHeight: 1.2,
+        textAnchor: isRight ? "start" : "end",
+        dominantBaseline: "central"
       }
-      return cond.value;
+    });
+    targetMarkIndices.push(mi);
+  }
+  if (candidates.length === 0) return [];
+  let resolved;
+  if (density === "all") {
+    resolved = candidates.map((c) => ({
+      text: c.text,
+      x: c.anchorX,
+      y: c.anchorY,
+      style: c.style,
+      visible: true
+    }));
+  } else {
+    resolved = resolveCollisions5(candidates);
+  }
+  for (let i = 0; i < resolved.length && i < targetMarks.length; i++) {
+    const label = resolved[i];
+    const mark = targetMarks[i];
+    if (label.visible) {
+      label.connector = {
+        from: { x: label.x, y: label.y },
+        to: { x: mark.centroid.x, y: mark.centroid.y },
+        stroke: _textFill,
+        style: "straight"
+      };
     }
   }
-  return channelDef.value;
-}
-function isConditionalValueDef(def) {
-  return def !== null && typeof def === "object" && "condition" in def;
+  return resolved;
 }
 
+// src/charts/pie/index.ts
+var pieRenderer = (spec, scales, chartArea, strategy, theme) => {
+  const marks = computePieMarks(spec, scales, chartArea, strategy, false);
+  const labels = computePieLabels(marks, chartArea, spec.labels.density, theme.colors.text);
+  for (let i = 0; i < marks.length && i < labels.length; i++) {
+    marks[i].label = labels[i];
+  }
+  return marks;
+};
+var donutRenderer = (spec, scales, chartArea, strategy, theme) => {
+  const marks = computePieMarks(spec, scales, chartArea, strategy, true);
+  const labels = computePieLabels(marks, chartArea, spec.labels.density, theme.colors.text);
+  for (let i = 0; i < marks.length && i < labels.length; i++) {
+    marks[i].label = labels[i];
+  }
+  return marks;
+};
+
 // src/charts/registry.ts
 var renderers = /* @__PURE__ */ new Map();
 function registerChartRenderer(type, renderer) {
@@ -661,6 +3274,78 @@ function clearRenderers() {
   renderers.clear();
 }
 
+// src/charts/rule/index.ts
+import { getRepresentativeColor as getRepresentativeColor7 } from "@opendata-ai/openchart-core";
+function computeRuleMarks(spec, scales, chartArea) {
+  const encoding = spec.encoding;
+  const xChannel = encoding.x;
+  const yChannel = encoding.y;
+  const x2Channel = encoding.x2;
+  const y2Channel = encoding.y2;
+  const colorEncoding = encoding.color && "field" in encoding.color ? encoding.color : void 0;
+  const colorField = colorEncoding?.field;
+  const marks = [];
+  for (const row of spec.data) {
+    let x1 = chartArea.x;
+    let y1 = chartArea.y;
+    let x2 = chartArea.x + chartArea.width;
+    let y2 = chartArea.y + chartArea.height;
+    if (xChannel && scales.x) {
+      const xVal = scaleValue(scales.x.scale, scales.x.type, row[xChannel.field]);
+      if (xVal == null) continue;
+      x1 = xVal;
+      x2 = xVal;
+    }
+    if (yChannel && scales.y) {
+      const yVal = scaleValue(scales.y.scale, scales.y.type, row[yChannel.field]);
+      if (yVal == null) continue;
+      y1 = yVal;
+      y2 = yVal;
+    }
+    if (xChannel && !yChannel) {
+      y1 = chartArea.y;
+      y2 = chartArea.y + chartArea.height;
+    }
+    if (yChannel && !xChannel) {
+      x1 = chartArea.x;
+      x2 = chartArea.x + chartArea.width;
+    }
+    if (x2Channel && scales.x) {
+      const x2Val = scaleValue(scales.x.scale, scales.x.type, row[x2Channel.field]);
+      if (x2Val != null) x2 = x2Val;
+    }
+    if (y2Channel && scales.y) {
+      const y2Val = scaleValue(scales.y.scale, scales.y.type, row[y2Channel.field]);
+      if (y2Val != null) y2 = y2Val;
+    }
+    const color2 = getRepresentativeColor7(
+      colorField ? getColor(scales, String(row[colorField] ?? "__default__")) : getColor(scales, "__default__")
+    );
+    const strokeDashEncoding = encoding.strokeDash && "field" in encoding.strokeDash ? encoding.strokeDash : void 0;
+    const strokeDasharray = strokeDashEncoding ? String(row[strokeDashEncoding.field] ?? "") : void 0;
+    const aria = {
+      label: `Rule from (${Math.round(x1)}, ${Math.round(y1)}) to (${Math.round(x2)}, ${Math.round(y2)})`
+    };
+    marks.push({
+      type: "rule",
+      x1,
+      y1,
+      x2,
+      y2,
+      stroke: color2,
+      strokeWidth: 1,
+      strokeDasharray: strokeDasharray || void 0,
+      opacity: encoding.opacity && "field" in encoding.opacity ? Math.max(0, Math.min(1, Number(row[encoding.opacity.field]) || 1)) : void 0,
+      data: row,
+      aria
+    });
+  }
+  return marks;
+}
+var ruleRenderer = (spec, scales, chartArea, _strategy, _theme) => {
+  return computeRuleMarks(spec, scales, chartArea);
+};
+
 // ../../node_modules/.bun/d3-array@3.2.4/node_modules/d3-array/src/ascending.js
 function ascending(a, b) {
   return a == null || b == null ? NaN : a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN;
@@ -676,38 +3361,38 @@ function bisector(f) {
   let compare1, compare2, delta;
   if (f.length !== 2) {
     compare1 = ascending;
-    compare2 = (d, x) => ascending(f(d), x);
-    delta = (d, x) => f(d) - x;
+    compare2 = (d, x2) => ascending(f(d), x2);
+    delta = (d, x2) => f(d) - x2;
   } else {
     compare1 = f === ascending || f === descending ? f : zero;
     compare2 = f;
     delta = f;
   }
-  function left2(a, x, lo = 0, hi = a.length) {
+  function left2(a, x2, lo = 0, hi = a.length) {
     if (lo < hi) {
-      if (compare1(x, x) !== 0) return hi;
+      if (compare1(x2, x2) !== 0) return hi;
       do {
         const mid = lo + hi >>> 1;
-        if (compare2(a[mid], x) < 0) lo = mid + 1;
+        if (compare2(a[mid], x2) < 0) lo = mid + 1;
         else hi = mid;
       } while (lo < hi);
     }
     return lo;
   }
-  function right2(a, x, lo = 0, hi = a.length) {
+  function right2(a, x2, lo = 0, hi = a.length) {
     if (lo < hi) {
-      if (compare1(x, x) !== 0) return hi;
+      if (compare1(x2, x2) !== 0) return hi;
       do {
         const mid = lo + hi >>> 1;
-        if (compare2(a[mid], x) <= 0) lo = mid + 1;
+        if (compare2(a[mid], x2) <= 0) lo = mid + 1;
         else hi = mid;
       } while (lo < hi);
     }
     return lo;
   }
-  function center2(a, x, lo = 0, hi = a.length) {
-    const i = left2(a, x, lo, hi - 1);
-    return i > lo && delta(a[i - 1], x) > -delta(a[i], x) ? i - 1 : i;
+  function center2(a, x2, lo = 0, hi = a.length) {
+    const i = left2(a, x2, lo, hi - 1);
+    return i > lo && delta(a[i - 1], x2) > -delta(a[i], x2) ? i - 1 : i;
   }
   return { left: left2, center: center2, right: right2 };
 }
@@ -716,8 +3401,8 @@ function zero() {
 }
 
 // ../../node_modules/.bun/d3-array@3.2.4/node_modules/d3-array/src/number.js
-function number(x) {
-  return x === null ? NaN : +x;
+function number(x2) {
+  return x2 === null ? NaN : +x2;
 }
 
 // ../../node_modules/.bun/d3-array@3.2.4/node_modules/d3-array/src/bisect.js
@@ -729,16 +3414,16 @@ var bisect_default = bisectRight;
 
 // ../../node_modules/.bun/d3-array@3.2.4/node_modules/d3-array/src/extent.js
 function extent(values, valueof) {
-  let min3;
-  let max3;
+  let min4;
+  let max4;
   if (valueof === void 0) {
     for (const value2 of values) {
       if (value2 != null) {
-        if (min3 === void 0) {
-          if (value2 >= value2) min3 = max3 = value2;
+        if (min4 === void 0) {
+          if (value2 >= value2) min4 = max4 = value2;
         } else {
-          if (min3 > value2) min3 = value2;
-          if (max3 < value2) max3 = value2;
+          if (min4 > value2) min4 = value2;
+          if (max4 < value2) max4 = value2;
         }
       }
     }
@@ -746,16 +3431,16 @@ function extent(values, valueof) {
     let index = -1;
     for (let value2 of values) {
       if ((value2 = valueof(value2, ++index, values)) != null) {
-        if (min3 === void 0) {
-          if (value2 >= value2) min3 = max3 = value2;
+        if (min4 === void 0) {
+          if (value2 >= value2) min4 = max4 = value2;
         } else {
-          if (min3 > value2) min3 = value2;
-          if (max3 < value2) max3 = value2;
+          if (min4 > value2) min4 = value2;
+          if (max4 < value2) max4 = value2;
         }
       }
     }
   }
-  return [min3, max3];
+  return [min4, max4];
 }
 
 // ../../node_modules/.bun/internmap@2.0.3/node_modules/internmap/src/index.js
@@ -851,43 +3536,43 @@ function tickStep(start, stop, count) {
 }
 
 // ../../node_modules/.bun/d3-array@3.2.4/node_modules/d3-array/src/max.js
-function max(values, valueof) {
-  let max3;
+function max2(values, valueof) {
+  let max4;
   if (valueof === void 0) {
     for (const value2 of values) {
-      if (value2 != null && (max3 < value2 || max3 === void 0 && value2 >= value2)) {
-        max3 = value2;
+      if (value2 != null && (max4 < value2 || max4 === void 0 && value2 >= value2)) {
+        max4 = value2;
       }
     }
   } else {
     let index = -1;
     for (let value2 of values) {
-      if ((value2 = valueof(value2, ++index, values)) != null && (max3 < value2 || max3 === void 0 && value2 >= value2)) {
-        max3 = value2;
+      if ((value2 = valueof(value2, ++index, values)) != null && (max4 < value2 || max4 === void 0 && value2 >= value2)) {
+        max4 = value2;
       }
     }
   }
-  return max3;
+  return max4;
 }
 
 // ../../node_modules/.bun/d3-array@3.2.4/node_modules/d3-array/src/min.js
-function min(values, valueof) {
-  let min3;
+function min2(values, valueof) {
+  let min4;
   if (valueof === void 0) {
     for (const value2 of values) {
-      if (value2 != null && (min3 > value2 || min3 === void 0 && value2 >= value2)) {
-        min3 = value2;
+      if (value2 != null && (min4 > value2 || min4 === void 0 && value2 >= value2)) {
+        min4 = value2;
       }
     }
   } else {
     let index = -1;
     for (let value2 of values) {
-      if ((value2 = valueof(value2, ++index, values)) != null && (min3 > value2 || min3 === void 0 && value2 >= value2)) {
-        min3 = value2;
+      if ((value2 = valueof(value2, ++index, values)) != null && (min4 > value2 || min4 === void 0 && value2 >= value2)) {
+        min4 = value2;
       }
     }
   }
-  return min3;
+  return min4;
 }
 
 // ../../node_modules/.bun/d3-array@3.2.4/node_modules/d3-array/src/quantile.js
@@ -1037,7 +3722,7 @@ function pointish(scale) {
   };
   return scale;
 }
-function point() {
+function point4() {
   return pointish(band.apply(null, arguments).paddingInner(1));
 }
 
@@ -1328,12 +4013,12 @@ function hslConvert(o) {
   if (!o) return new Hsl();
   if (o instanceof Hsl) return o;
   o = o.rgb();
-  var r = o.r / 255, g = o.g / 255, b = o.b / 255, min3 = Math.min(r, g, b), max3 = Math.max(r, g, b), h = NaN, s = max3 - min3, l = (max3 + min3) / 2;
+  var r = o.r / 255, g = o.g / 255, b = o.b / 255, min4 = Math.min(r, g, b), max4 = Math.max(r, g, b), h = NaN, s = max4 - min4, l = (max4 + min4) / 2;
   if (s) {
-    if (r === max3) h = (g - b) / s + (g < b) * 6;
-    else if (g === max3) h = (b - r) / s + 2;
+    if (r === max4) h = (g - b) / s + (g < b) * 6;
+    else if (g === max4) h = (b - r) / s + 2;
     else h = (r - g) / s + 4;
-    s /= l < 0.5 ? max3 + min3 : 2 - max3 - min3;
+    s /= l < 0.5 ? max4 + min4 : 2 - max4 - min4;
     h *= 60;
   } else {
     s = l > 0 && l < 1 ? 0 : h;
@@ -1394,7 +4079,7 @@ function basis(t12, v0, v1, v2, v3) {
   var t2 = t12 * t12, t3 = t2 * t12;
   return ((1 - 3 * t12 + 3 * t2 - t3) * v0 + (4 - 6 * t2 + 3 * t3) * v1 + (1 + 3 * t12 + 3 * t2 - 3 * t3) * v2 + t3 * v3) / 6;
 }
-function basis_default(values) {
+function basis_default2(values) {
   var n = values.length - 1;
   return function(t) {
     var i = t <= 0 ? t = 0 : t >= 1 ? (t = 1, n - 1) : Math.floor(t * n), v1 = values[i], v2 = values[i + 1], v0 = i > 0 ? values[i - 1] : 2 * v1 - v2, v3 = i < n - 1 ? values[i + 2] : 2 * v2 - v1;
@@ -1412,7 +4097,7 @@ function basisClosed_default(values) {
 }
 
 // ../../node_modules/.bun/d3-interpolate@3.0.1/node_modules/d3-interpolate/src/constant.js
-var constant_default = (x) => () => x;
+var constant_default2 = (x2) => () => x2;
 
 // ../../node_modules/.bun/d3-interpolate@3.0.1/node_modules/d3-interpolate/src/color.js
 function linear(a, d) {
@@ -1420,24 +4105,24 @@ function linear(a, d) {
     return a + t * d;
   };
 }
-function exponential(a, b, y) {
-  return a = Math.pow(a, y), b = Math.pow(b, y) - a, y = 1 / y, function(t) {
-    return Math.pow(a + t * b, y);
+function exponential(a, b, y2) {
+  return a = Math.pow(a, y2), b = Math.pow(b, y2) - a, y2 = 1 / y2, function(t) {
+    return Math.pow(a + t * b, y2);
   };
 }
-function gamma(y) {
-  return (y = +y) === 1 ? nogamma : function(a, b) {
-    return b - a ? exponential(a, b, y) : constant_default(isNaN(a) ? b : a);
+function gamma(y2) {
+  return (y2 = +y2) === 1 ? nogamma : function(a, b) {
+    return b - a ? exponential(a, b, y2) : constant_default2(isNaN(a) ? b : a);
   };
 }
 function nogamma(a, b) {
   var d = b - a;
-  return d ? linear(a, d) : constant_default(isNaN(a) ? b : a);
+  return d ? linear(a, d) : constant_default2(isNaN(a) ? b : a);
 }
 
 // ../../node_modules/.bun/d3-interpolate@3.0.1/node_modules/d3-interpolate/src/rgb.js
-var rgb_default = (function rgbGamma(y) {
-  var color2 = gamma(y);
+var rgb_default = (function rgbGamma(y2) {
+  var color2 = gamma(y2);
   function rgb2(start, end) {
     var r = color2((start = rgb(start)).r, (end = rgb(end)).r), g = color2(start.g, end.g), b = color2(start.b, end.b), opacity = nogamma(start.opacity, end.opacity);
     return function(t) {
@@ -1472,7 +4157,7 @@ function rgbSpline(spline) {
     };
   };
 }
-var rgbBasis = rgbSpline(basis_default);
+var rgbBasis = rgbSpline(basis_default2);
 var rgbBasisClosed = rgbSpline(basisClosed_default);
 
 // ../../node_modules/.bun/d3-interpolate@3.0.1/node_modules/d3-interpolate/src/numberArray.js
@@ -1484,17 +4169,17 @@ function numberArray_default(a, b) {
     return c;
   };
 }
-function isNumberArray(x) {
-  return ArrayBuffer.isView(x) && !(x instanceof DataView);
+function isNumberArray(x2) {
+  return ArrayBuffer.isView(x2) && !(x2 instanceof DataView);
 }
 
 // ../../node_modules/.bun/d3-interpolate@3.0.1/node_modules/d3-interpolate/src/array.js
 function genericArray(a, b) {
-  var nb = b ? b.length : 0, na = a ? Math.min(nb, a.length) : 0, x = new Array(na), c = new Array(nb), i;
-  for (i = 0; i < na; ++i) x[i] = value_default(a[i], b[i]);
+  var nb = b ? b.length : 0, na = a ? Math.min(nb, a.length) : 0, x2 = new Array(na), c = new Array(nb), i;
+  for (i = 0; i < na; ++i) x2[i] = value_default(a[i], b[i]);
   for (; i < nb; ++i) c[i] = b[i];
   return function(t) {
-    for (i = 0; i < na; ++i) c[i] = x[i](t);
+    for (i = 0; i < na; ++i) c[i] = x2[i](t);
     return c;
   };
 }
@@ -1577,7 +4262,7 @@ function string_default(a, b) {
 // ../../node_modules/.bun/d3-interpolate@3.0.1/node_modules/d3-interpolate/src/value.js
 function value_default(a, b) {
   var t = typeof b, c;
-  return b == null || t === "boolean" ? constant_default(b) : (t === "number" ? number_default : t === "string" ? (c = color(b)) ? (b = c, rgb_default) : string_default : b instanceof color ? rgb_default : b instanceof Date ? date_default : isNumberArray(b) ? numberArray_default : Array.isArray(b) ? genericArray : typeof b.valueOf !== "function" && typeof b.toString !== "function" || isNaN(b) ? object_default : number_default)(a, b);
+  return b == null || t === "boolean" ? constant_default2(b) : (t === "number" ? number_default : t === "string" ? (c = color(b)) ? (b = c, rgb_default) : string_default : b instanceof color ? rgb_default : b instanceof Date ? date_default : isNumberArray(b) ? numberArray_default : Array.isArray(b) ? genericArray : typeof b.valueOf !== "function" && typeof b.toString !== "function" || isNaN(b) ? object_default : number_default)(a, b);
 }
 
 // ../../node_modules/.bun/d3-interpolate@3.0.1/node_modules/d3-interpolate/src/round.js
@@ -1588,40 +4273,40 @@ function round_default(a, b) {
 }
 
 // ../../node_modules/.bun/d3-scale@4.0.2/node_modules/d3-scale/src/constant.js
-function constants(x) {
+function constants(x2) {
   return function() {
-    return x;
+    return x2;
   };
 }
 
 // ../../node_modules/.bun/d3-scale@4.0.2/node_modules/d3-scale/src/number.js
-function number2(x) {
-  return +x;
+function number2(x2) {
+  return +x2;
 }
 
 // ../../node_modules/.bun/d3-scale@4.0.2/node_modules/d3-scale/src/continuous.js
 var unit = [0, 1];
-function identity(x) {
-  return x;
+function identity(x2) {
+  return x2;
 }
 function normalize(a, b) {
-  return (b -= a = +a) ? function(x) {
-    return (x - a) / b;
+  return (b -= a = +a) ? function(x2) {
+    return (x2 - a) / b;
   } : constants(isNaN(b) ? NaN : 0.5);
 }
 function clamper(a, b) {
   var t;
   if (a > b) t = a, a = b, b = t;
-  return function(x) {
-    return Math.max(a, Math.min(b, x));
+  return function(x2) {
+    return Math.max(a, Math.min(b, x2));
   };
 }
 function bimap(domain, range2, interpolate) {
   var d0 = domain[0], d1 = domain[1], r0 = range2[0], r1 = range2[1];
   if (d1 < d0) d0 = normalize(d1, d0), r0 = interpolate(r1, r0);
   else d0 = normalize(d0, d1), r0 = interpolate(r0, r1);
-  return function(x) {
-    return r0(d0(x));
+  return function(x2) {
+    return r0(d0(x2));
   };
 }
 function polymap(domain, range2, interpolate) {
@@ -1634,9 +4319,9 @@ function polymap(domain, range2, interpolate) {
     d[i] = normalize(domain[i], domain[i + 1]);
     r[i] = interpolate(range2[i], range2[i + 1]);
   }
-  return function(x) {
-    var i2 = bisect_default(domain, x, 1, j) - 1;
-    return r[i2](d[i2](x));
+  return function(x2) {
+    var i2 = bisect_default(domain, x2, 1, j) - 1;
+    return r[i2](d[i2](x2));
   };
 }
 function copy(source, target) {
@@ -1651,11 +4336,11 @@ function transformer() {
     output = input = null;
     return scale;
   }
-  function scale(x) {
-    return x == null || isNaN(x = +x) ? unknown : (output || (output = piecewise(domain.map(transform), range2, interpolate)))(transform(clamp(x)));
+  function scale(x2) {
+    return x2 == null || isNaN(x2 = +x2) ? unknown : (output || (output = piecewise(domain.map(transform), range2, interpolate)))(transform(clamp(x2)));
   }
-  scale.invert = function(y) {
-    return clamp(untransform((input || (input = piecewise(range2, domain.map(transform), number_default)))(y)));
+  scale.invert = function(y2) {
+    return clamp(untransform((input || (input = piecewise(range2, domain.map(transform), number_default)))(y2)));
   };
   scale.domain = function(_) {
     return arguments.length ? (domain = Array.from(_, number2), rescale()) : domain.slice();
@@ -1685,21 +4370,21 @@ function continuous() {
 }
 
 // ../../node_modules/.bun/d3-format@3.1.2/node_modules/d3-format/src/formatDecimal.js
-function formatDecimal_default(x) {
-  return Math.abs(x = Math.round(x)) >= 1e21 ? x.toLocaleString("en").replace(/,/g, "") : x.toString(10);
+function formatDecimal_default(x2) {
+  return Math.abs(x2 = Math.round(x2)) >= 1e21 ? x2.toLocaleString("en").replace(/,/g, "") : x2.toString(10);
 }
-function formatDecimalParts(x, p) {
-  if (!isFinite(x) || x === 0) return null;
-  var i = (x = p ? x.toExponential(p - 1) : x.toExponential()).indexOf("e"), coefficient = x.slice(0, i);
+function formatDecimalParts(x2, p) {
+  if (!isFinite(x2) || x2 === 0) return null;
+  var i = (x2 = p ? x2.toExponential(p - 1) : x2.toExponential()).indexOf("e"), coefficient = x2.slice(0, i);
   return [
     coefficient.length > 1 ? coefficient[0] + coefficient.slice(2) : coefficient,
-    +x.slice(i + 1)
+    +x2.slice(i + 1)
   ];
 }
 
 // ../../node_modules/.bun/d3-format@3.1.2/node_modules/d3-format/src/exponent.js
-function exponent_default(x) {
-  return x = formatDecimalParts(Math.abs(x)), x ? x[1] : NaN;
+function exponent_default(x2) {
+  return x2 = formatDecimalParts(Math.abs(x2)), x2 ? x2[1] : NaN;
 }
 
 // ../../node_modules/.bun/d3-format@3.1.2/node_modules/d3-format/src/formatGroup.js
@@ -1782,51 +4467,51 @@ function formatTrim_default(s) {
 
 // ../../node_modules/.bun/d3-format@3.1.2/node_modules/d3-format/src/formatPrefixAuto.js
 var prefixExponent;
-function formatPrefixAuto_default(x, p) {
-  var d = formatDecimalParts(x, p);
-  if (!d) return prefixExponent = void 0, x.toPrecision(p);
+function formatPrefixAuto_default(x2, p) {
+  var d = formatDecimalParts(x2, p);
+  if (!d) return prefixExponent = void 0, x2.toPrecision(p);
   var coefficient = d[0], exponent = d[1], i = exponent - (prefixExponent = Math.max(-8, Math.min(8, Math.floor(exponent / 3))) * 3) + 1, n = coefficient.length;
-  return i === n ? coefficient : i > n ? coefficient + new Array(i - n + 1).join("0") : i > 0 ? coefficient.slice(0, i) + "." + coefficient.slice(i) : "0." + new Array(1 - i).join("0") + formatDecimalParts(x, Math.max(0, p + i - 1))[0];
+  return i === n ? coefficient : i > n ? coefficient + new Array(i - n + 1).join("0") : i > 0 ? coefficient.slice(0, i) + "." + coefficient.slice(i) : "0." + new Array(1 - i).join("0") + formatDecimalParts(x2, Math.max(0, p + i - 1))[0];
 }
 
 // ../../node_modules/.bun/d3-format@3.1.2/node_modules/d3-format/src/formatRounded.js
-function formatRounded_default(x, p) {
-  var d = formatDecimalParts(x, p);
-  if (!d) return x + "";
+function formatRounded_default(x2, p) {
+  var d = formatDecimalParts(x2, p);
+  if (!d) return x2 + "";
   var coefficient = d[0], exponent = d[1];
   return exponent < 0 ? "0." + new Array(-exponent).join("0") + coefficient : coefficient.length > exponent + 1 ? coefficient.slice(0, exponent + 1) + "." + coefficient.slice(exponent + 1) : coefficient + new Array(exponent - coefficient.length + 2).join("0");
 }
 
 // ../../node_modules/.bun/d3-format@3.1.2/node_modules/d3-format/src/formatTypes.js
 var formatTypes_default = {
-  "%": (x, p) => (x * 100).toFixed(p),
-  "b": (x) => Math.round(x).toString(2),
-  "c": (x) => x + "",
+  "%": (x2, p) => (x2 * 100).toFixed(p),
+  "b": (x2) => Math.round(x2).toString(2),
+  "c": (x2) => x2 + "",
   "d": formatDecimal_default,
-  "e": (x, p) => x.toExponential(p),
-  "f": (x, p) => x.toFixed(p),
-  "g": (x, p) => x.toPrecision(p),
-  "o": (x) => Math.round(x).toString(8),
-  "p": (x, p) => formatRounded_default(x * 100, p),
+  "e": (x2, p) => x2.toExponential(p),
+  "f": (x2, p) => x2.toFixed(p),
+  "g": (x2, p) => x2.toPrecision(p),
+  "o": (x2) => Math.round(x2).toString(8),
+  "p": (x2, p) => formatRounded_default(x2 * 100, p),
   "r": formatRounded_default,
   "s": formatPrefixAuto_default,
-  "X": (x) => Math.round(x).toString(16).toUpperCase(),
-  "x": (x) => Math.round(x).toString(16)
+  "X": (x2) => Math.round(x2).toString(16).toUpperCase(),
+  "x": (x2) => Math.round(x2).toString(16)
 };
 
 // ../../node_modules/.bun/d3-format@3.1.2/node_modules/d3-format/src/identity.js
-function identity_default(x) {
-  return x;
+function identity_default2(x2) {
+  return x2;
 }
 
 // ../../node_modules/.bun/d3-format@3.1.2/node_modules/d3-format/src/locale.js
 var map = Array.prototype.map;
 var prefixes = ["y", "z", "a", "f", "p", "n", "\xB5", "m", "", "k", "M", "G", "T", "P", "E", "Z", "Y"];
 function locale_default(locale3) {
-  var group = locale3.grouping === void 0 || locale3.thousands === void 0 ? identity_default : formatGroup_default(map.call(locale3.grouping, Number), locale3.thousands + ""), currencyPrefix = locale3.currency === void 0 ? "" : locale3.currency[0] + "", currencySuffix = locale3.currency === void 0 ? "" : locale3.currency[1] + "", decimal = locale3.decimal === void 0 ? "." : locale3.decimal + "", numerals = locale3.numerals === void 0 ? identity_default : formatNumerals_default(map.call(locale3.numerals, String)), percent = locale3.percent === void 0 ? "%" : locale3.percent + "", minus = locale3.minus === void 0 ? "\u2212" : locale3.minus + "", nan = locale3.nan === void 0 ? "NaN" : locale3.nan + "";
+  var group = locale3.grouping === void 0 || locale3.thousands === void 0 ? identity_default2 : formatGroup_default(map.call(locale3.grouping, Number), locale3.thousands + ""), currencyPrefix = locale3.currency === void 0 ? "" : locale3.currency[0] + "", currencySuffix = locale3.currency === void 0 ? "" : locale3.currency[1] + "", decimal = locale3.decimal === void 0 ? "." : locale3.decimal + "", numerals = locale3.numerals === void 0 ? identity_default2 : formatNumerals_default(map.call(locale3.numerals, String)), percent = locale3.percent === void 0 ? "%" : locale3.percent + "", minus = locale3.minus === void 0 ? "\u2212" : locale3.minus + "", nan = locale3.nan === void 0 ? "NaN" : locale3.nan + "";
   function newFormat(specifier, options) {
     specifier = formatSpecifier(specifier);
-    var fill = specifier.fill, align = specifier.align, sign = specifier.sign, symbol = specifier.symbol, zero3 = specifier.zero, width = specifier.width, comma = specifier.comma, precision = specifier.precision, trim = specifier.trim, type = specifier.type;
+    var fill = specifier.fill, align = specifier.align, sign2 = specifier.sign, symbol = specifier.symbol, zero3 = specifier.zero, width = specifier.width, comma = specifier.comma, precision = specifier.precision, trim = specifier.trim, type = specifier.type;
     if (type === "n") comma = true, type = "g";
     else if (!formatTypes_default[type]) precision === void 0 && (precision = 12), trim = true, type = "g";
     if (zero3 || fill === "0" && align === "=") zero3 = true, fill = "0", align = "=";
@@ -1843,9 +4528,9 @@ function locale_default(locale3) {
         var valueNegative = value2 < 0 || 1 / value2 < 0;
         value2 = isNaN(value2) ? nan : formatType(Math.abs(value2), precision);
         if (trim) value2 = formatTrim_default(value2);
-        if (valueNegative && +value2 === 0 && sign !== "+") valueNegative = false;
-        valuePrefix = (valueNegative ? sign === "(" ? sign : minus : sign === "-" || sign === "(" ? "" : sign) + valuePrefix;
-        valueSuffix = (type === "s" && !isNaN(value2) && prefixExponent !== void 0 ? prefixes[8 + prefixExponent / 3] : "") + valueSuffix + (valueNegative && sign === "(" ? ")" : "");
+        if (valueNegative && +value2 === 0 && sign2 !== "+") valueNegative = false;
+        valuePrefix = (valueNegative ? sign2 === "(" ? sign2 : minus : sign2 === "-" || sign2 === "(" ? "" : sign2) + valuePrefix;
+        valueSuffix = (type === "s" && !isNaN(value2) && prefixExponent !== void 0 ? prefixes[8 + prefixExponent / 3] : "") + valueSuffix + (valueNegative && sign2 === "(" ? ")" : "");
         if (maybeSuffix) {
           i = -1, n = value2.length;
           while (++i < n) {
@@ -1920,9 +4605,9 @@ function precisionPrefix_default(step, value2) {
 }
 
 // ../../node_modules/.bun/d3-format@3.1.2/node_modules/d3-format/src/precisionRound.js
-function precisionRound_default(step, max3) {
-  step = Math.abs(step), max3 = Math.abs(max3) - step;
-  return Math.max(0, exponent_default(max3) - exponent_default(step)) + 1;
+function precisionRound_default(step, max4) {
+  step = Math.abs(step), max4 = Math.abs(max4) - step;
+  return Math.max(0, exponent_default(max4) - exponent_default(step)) + 1;
 }
 
 // ../../node_modules/.bun/d3-scale@4.0.2/node_modules/d3-scale/src/tickFormat.js
@@ -2021,29 +4706,29 @@ function nice(domain, interval) {
 }
 
 // ../../node_modules/.bun/d3-scale@4.0.2/node_modules/d3-scale/src/log.js
-function transformLog(x) {
-  return Math.log(x);
+function transformLog(x2) {
+  return Math.log(x2);
 }
-function transformExp(x) {
-  return Math.exp(x);
+function transformExp(x2) {
+  return Math.exp(x2);
 }
-function transformLogn(x) {
-  return -Math.log(-x);
+function transformLogn(x2) {
+  return -Math.log(-x2);
 }
-function transformExpn(x) {
-  return -Math.exp(-x);
+function transformExpn(x2) {
+  return -Math.exp(-x2);
 }
-function pow10(x) {
-  return isFinite(x) ? +("1e" + x) : x < 0 ? 0 : x;
+function pow10(x2) {
+  return isFinite(x2) ? +("1e" + x2) : x2 < 0 ? 0 : x2;
 }
 function powp(base) {
-  return base === 10 ? pow10 : base === Math.E ? Math.exp : (x) => Math.pow(base, x);
+  return base === 10 ? pow10 : base === Math.E ? Math.exp : (x2) => Math.pow(base, x2);
 }
 function logp(base) {
-  return base === Math.E ? Math.log : base === 10 && Math.log10 || base === 2 && Math.log2 || (base = Math.log(base), (x) => Math.log(x) / base);
+  return base === Math.E ? Math.log : base === 10 && Math.log10 || base === 2 && Math.log2 || (base = Math.log(base), (x2) => Math.log(x2) / base);
 }
 function reflect(f) {
-  return (x, k) => -f(-x, k);
+  return (x2, k) => -f(-x2, k);
 }
 function loggish(transform) {
   const scale = transform(transformLog, transformExp);
@@ -2120,8 +4805,8 @@ function loggish(transform) {
   };
   scale.nice = () => {
     return domain(nice(domain(), {
-      floor: (x) => pows(Math.floor(logs(x))),
-      ceil: (x) => pows(Math.ceil(logs(x)))
+      floor: (x2) => pows(Math.floor(logs(x2))),
+      ceil: (x2) => pows(Math.ceil(logs(x2)))
     }));
   };
   return scale;
@@ -2135,13 +4820,13 @@ function log() {
 
 // ../../node_modules/.bun/d3-scale@4.0.2/node_modules/d3-scale/src/symlog.js
 function transformSymlog(c) {
-  return function(x) {
-    return Math.sign(x) * Math.log1p(Math.abs(x / c));
+  return function(x2) {
+    return Math.sign(x2) * Math.log1p(Math.abs(x2 / c));
   };
 }
 function transformSymexp(c) {
-  return function(x) {
-    return Math.sign(x) * Math.expm1(Math.abs(x)) * c;
+  return function(x2) {
+    return Math.sign(x2) * Math.expm1(Math.abs(x2)) * c;
   };
 }
 function symlogish(transform) {
@@ -2161,15 +4846,15 @@ function symlog() {
 
 // ../../node_modules/.bun/d3-scale@4.0.2/node_modules/d3-scale/src/pow.js
 function transformPow(exponent) {
-  return function(x) {
-    return x < 0 ? -Math.pow(-x, exponent) : Math.pow(x, exponent);
+  return function(x2) {
+    return x2 < 0 ? -Math.pow(-x2, exponent) : Math.pow(x2, exponent);
   };
 }
-function transformSqrt(x) {
-  return x < 0 ? -Math.sqrt(-x) : Math.sqrt(x);
+function transformSqrt(x2) {
+  return x2 < 0 ? -Math.sqrt(-x2) : Math.sqrt(x2);
 }
-function transformSquare(x) {
-  return x < 0 ? -x * x : x * x;
+function transformSquare(x2) {
+  return x2 < 0 ? -x2 * x2 : x2 * x2;
 }
 function powish(transform) {
   var scale = transform(identity, identity), exponent = 1;
@@ -2189,7 +4874,7 @@ function pow() {
   initRange.apply(scale, arguments);
   return scale;
 }
-function sqrt() {
+function sqrt2() {
   return pow.apply(null, arguments).exponent(0.5);
 }
 
@@ -2202,11 +4887,11 @@ function quantile2() {
     while (++i < n) thresholds[i - 1] = quantileSorted(domain, i / n);
     return scale;
   }
-  function scale(x) {
-    return x == null || isNaN(x = +x) ? unknown : range2[bisect_default(thresholds, x)];
+  function scale(x2) {
+    return x2 == null || isNaN(x2 = +x2) ? unknown : range2[bisect_default(thresholds, x2)];
   }
-  scale.invertExtent = function(y) {
-    var i = range2.indexOf(y);
+  scale.invertExtent = function(y2) {
+    var i = range2.indexOf(y2);
     return i < 0 ? [NaN, NaN] : [
       i > 0 ? thresholds[i - 1] : domain[0],
       i < thresholds.length ? thresholds[i] : domain[domain.length - 1]
@@ -2237,8 +4922,8 @@ function quantile2() {
 // ../../node_modules/.bun/d3-scale@4.0.2/node_modules/d3-scale/src/quantize.js
 function quantize() {
   var x0 = 0, x1 = 1, n = 1, domain = [0.5], range2 = [0, 1], unknown;
-  function scale(x) {
-    return x != null && x <= x ? range2[bisect_default(domain, x, 0, n)] : unknown;
+  function scale(x2) {
+    return x2 != null && x2 <= x2 ? range2[bisect_default(domain, x2, 0, n)] : unknown;
   }
   function rescale() {
     var i = -1;
@@ -2252,8 +4937,8 @@ function quantize() {
   scale.range = function(_) {
     return arguments.length ? (n = (range2 = Array.from(_)).length - 1, rescale()) : range2.slice();
   };
-  scale.invertExtent = function(y) {
-    var i = range2.indexOf(y);
+  scale.invertExtent = function(y2) {
+    var i = range2.indexOf(y2);
     return i < 0 ? [NaN, NaN] : i < 1 ? [x0, domain[0]] : i >= n ? [domain[n - 1], x1] : [domain[i - 1], domain[i]];
   };
   scale.unknown = function(_) {
@@ -2271,8 +4956,8 @@ function quantize() {
 // ../../node_modules/.bun/d3-scale@4.0.2/node_modules/d3-scale/src/threshold.js
 function threshold() {
   var domain = [0.5], range2 = [0, 1], unknown, n = 1;
-  function scale(x) {
-    return x != null && x <= x ? range2[bisect_default(domain, x, 0, n)] : unknown;
+  function scale(x2) {
+    return x2 != null && x2 <= x2 ? range2[bisect_default(domain, x2, 0, n)] : unknown;
   }
   scale.domain = function(_) {
     return arguments.length ? (domain = Array.from(_), n = Math.min(domain.length, range2.length - 1), scale) : domain.slice();
@@ -2280,8 +4965,8 @@ function threshold() {
   scale.range = function(_) {
     return arguments.length ? (range2 = Array.from(_), n = Math.min(domain.length, range2.length - 1), scale) : range2.slice();
   };
-  scale.invertExtent = function(y) {
-    var i = range2.indexOf(y);
+  scale.invertExtent = function(y2) {
+    var i = range2.indexOf(y2);
     return [domain[i - 1], domain[i]];
   };
   scale.unknown = function(_) {
@@ -2644,8 +5329,8 @@ function utcDate(d) {
   }
   return new Date(Date.UTC(d.y, d.m, d.d, d.H, d.M, d.S, d.L));
 }
-function newDate(y, m, d) {
-  return { y, m, d, H: 0, M: 0, S: 0, L: 0 };
+function newDate(y2, m, d) {
+  return { y: y2, m, d, H: 0, M: 0, S: 0, L: 0 };
 }
 function formatLocale(locale3) {
   var locale_dateTime = locale3.dateTime, locale_date = locale3.date, locale_time = locale3.time, locale_periods = locale3.periods, locale_weekdays = locale3.days, locale_shortWeekdays = locale3.shortDays, locale_months = locale3.months, locale_shortMonths = locale3.shortMonths;
@@ -2933,8 +5618,8 @@ var numberRe = /^\s*\d+/;
 var percentRe = /^%/;
 var requoteRe = /[\\^$*+?|[\]().{}]/g;
 function pad(value2, fill, width) {
-  var sign = value2 < 0 ? "-" : "", string = (sign ? -value2 : value2) + "", length = string.length;
-  return sign + (length < width ? new Array(width - length + 1).join(fill) + string : string);
+  var sign2 = value2 < 0 ? "-" : "", string = (sign2 ? -value2 : value2) + "", length = string.length;
+  return sign2 + (length < width ? new Array(width - length + 1).join(fill) + string : string);
 }
 function requote(s) {
   return s.replace(requoteRe, "\\$&");
@@ -3206,8 +5891,8 @@ function calendar(ticks2, tickInterval, year, month, week, day, hour, minute, se
   function tickFormat2(date2) {
     return (second2(date2) < date2 ? formatMillisecond : minute(date2) < date2 ? formatSecond : hour(date2) < date2 ? formatMinute : day(date2) < date2 ? formatHour : month(date2) < date2 ? week(date2) < date2 ? formatDay : formatWeek : year(date2) < date2 ? formatMonth : formatYear2)(date2);
   }
-  scale.invert = function(y) {
-    return new Date(invert(y));
+  scale.invert = function(y2) {
+    return new Date(invert(y2));
   };
   scale.domain = function(_) {
     return arguments.length ? domain(Array.from(_, number3)) : domain().map(date);
@@ -3241,8 +5926,8 @@ function utcTime() {
 // ../../node_modules/.bun/d3-scale@4.0.2/node_modules/d3-scale/src/sequential.js
 function transformer2() {
   var x0 = 0, x1 = 1, t02, t12, k10, transform, interpolator = identity, clamp = false, unknown;
-  function scale(x) {
-    return x == null || isNaN(x = +x) ? unknown : interpolator(k10 === 0 ? 0.5 : (x = (transform(x) - t02) * k10, clamp ? Math.max(0, Math.min(1, x)) : x));
+  function scale(x2) {
+    return x2 == null || isNaN(x2 = +x2) ? unknown : interpolator(k10 === 0 ? 0.5 : (x2 = (transform(x2) - t02) * k10, clamp ? Math.max(0, Math.min(1, x2)) : x2));
   }
   scale.domain = function(_) {
     return arguments.length ? ([x0, x1] = _, t02 = transform(x0 = +x0), t12 = transform(x1 = +x1), k10 = t02 === t12 ? 0 : 1 / (t12 - t02), scale) : [x0, x1];
@@ -3280,6 +5965,293 @@ function sequential() {
   return initInterpolator.apply(scale, arguments);
 }
 
+// src/charts/scatter/compute.ts
+var DEFAULT_POINT_RADIUS2 = 5;
+var MIN_BUBBLE_RADIUS = 3;
+var MAX_BUBBLE_RADIUS = 30;
+function resolvePosition2(value2, channelType, scale) {
+  switch (channelType) {
+    case "nominal":
+    case "ordinal": {
+      const s = String(value2);
+      if ("bandwidth" in scale && typeof scale.bandwidth === "function") {
+        const bw = scale.bandwidth();
+        const pos = scale(s);
+        if (pos === void 0) return void 0;
+        return bw > 0 ? pos + bw / 2 : pos;
+      }
+      return scale(s);
+    }
+    case "temporal": {
+      const px = scale(new Date(value2));
+      return Number.isNaN(px) ? void 0 : px;
+    }
+    default: {
+      const num = Number(value2);
+      if (!Number.isFinite(num)) return void 0;
+      return scale(num);
+    }
+  }
+}
+function computeScatterMarks(spec, scales, _chartArea, _strategy) {
+  const encoding = spec.encoding;
+  const xChannel = encoding.x;
+  const yChannel = encoding.y;
+  if (!xChannel || !yChannel || !scales.x || !scales.y) {
+    return [];
+  }
+  const xScale = scales.x.scale;
+  const yScale = scales.y.scale;
+  const xType = xChannel.type;
+  const yType = yChannel.type;
+  const colorEnc = encoding.color && "field" in encoding.color ? encoding.color : void 0;
+  const isSequentialColor = colorEnc?.type === "quantitative";
+  const colorField = colorEnc?.field;
+  const sizeField = encoding.size && "field" in encoding.size ? encoding.size.field : void 0;
+  let sizeScale;
+  if (sizeField) {
+    const sizeValues = spec.data.map((d) => Number(d[sizeField])).filter((v) => Number.isFinite(v));
+    const sizeMin = min2(sizeValues) ?? 0;
+    const sizeMax = max2(sizeValues) ?? 1;
+    sizeScale = sqrt2().domain([sizeMin, sizeMax]).range([MIN_BUBBLE_RADIUS, MAX_BUBBLE_RADIUS]);
+  }
+  const marks = [];
+  for (const row of spec.data) {
+    const rawX = row[xChannel.field];
+    const rawY = row[yChannel.field];
+    const cx = resolvePosition2(rawX, xType, xScale);
+    const cy = resolvePosition2(rawY, yType, yScale);
+    if (cx === void 0 || cy === void 0) continue;
+    const category = colorField && !isSequentialColor ? String(row[colorField] ?? "") : void 0;
+    let color2;
+    if (isSequentialColor && colorField) {
+      const val = Number(row[colorField]);
+      color2 = Number.isFinite(val) ? getSequentialColor(scales, val) : getColor(scales, "__default__");
+    } else {
+      color2 = getColor(scales, category ?? "__default__");
+    }
+    let radius = DEFAULT_POINT_RADIUS2;
+    if (sizeScale && sizeField) {
+      const sizeVal = Number(row[sizeField]);
+      if (Number.isFinite(sizeVal)) {
+        radius = sizeScale(sizeVal);
+      }
+    }
+    const labelParts = [`${xChannel.field}=${rawX}`, `${yChannel.field}=${rawY}`];
+    if (category) labelParts.push(`${colorField}=${category}`);
+    if (sizeField && row[sizeField] != null) {
+      labelParts.push(`${sizeField}=${row[sizeField]}`);
+    }
+    const aria = {
+      label: `Data point: ${labelParts.join(", ")}`
+    };
+    marks.push({
+      type: "point",
+      cx,
+      cy,
+      r: radius,
+      fill: color2,
+      stroke: "#ffffff",
+      strokeWidth: 1,
+      fillOpacity: 0.7,
+      data: row,
+      aria
+    });
+  }
+  return marks;
+}
+
+// src/charts/scatter/trendline.ts
+var TRENDLINE_COLOR = "#666666";
+var TRENDLINE_STROKE_WIDTH = 1.5;
+var TRENDLINE_DASH = "6 4";
+function linearRegression(points) {
+  const n = points.length;
+  if (n < 2) return null;
+  let sumX = 0;
+  let sumY = 0;
+  let sumXY = 0;
+  let sumXX = 0;
+  for (const p of points) {
+    sumX += p.x;
+    sumY += p.y;
+    sumXY += p.x * p.y;
+    sumXX += p.x * p.x;
+  }
+  const denominator = n * sumXX - sumX * sumX;
+  if (denominator === 0) return null;
+  const slope = (n * sumXY - sumX * sumY) / denominator;
+  const intercept = (sumY - slope * sumX) / n;
+  return { slope, intercept };
+}
+function computeTrendLine(marks) {
+  if (marks.length < 2) return null;
+  const points = marks.map((m) => ({ x: m.cx, y: m.cy }));
+  const result = linearRegression(points);
+  if (!result) return null;
+  const { slope, intercept } = result;
+  let minX = Infinity;
+  let maxX = -Infinity;
+  for (const m of marks) {
+    if (m.cx < minX) minX = m.cx;
+    if (m.cx > maxX) maxX = m.cx;
+  }
+  const y1 = slope * minX + intercept;
+  const y2 = slope * maxX + intercept;
+  const aria = {
+    label: `Trend line: linear regression`
+  };
+  return {
+    type: "line",
+    points: [
+      { x: minX, y: y1 },
+      { x: maxX, y: y2 }
+    ],
+    stroke: TRENDLINE_COLOR,
+    strokeWidth: TRENDLINE_STROKE_WIDTH,
+    strokeDasharray: TRENDLINE_DASH,
+    data: [],
+    aria
+  };
+}
+
+// src/charts/scatter/index.ts
+var scatterRenderer = (spec, scales, chartArea, strategy, _theme) => {
+  const pointMarks = computeScatterMarks(spec, scales, chartArea, strategy);
+  const marks = [...pointMarks];
+  const trendLine = computeTrendLine(pointMarks);
+  if (trendLine) {
+    marks.unshift(trendLine);
+  }
+  return marks;
+};
+
+// src/charts/text/index.ts
+import { getRepresentativeColor as getRepresentativeColor8 } from "@opendata-ai/openchart-core";
+function computeTextMarks(spec, scales) {
+  const encoding = spec.encoding;
+  const xChannel = encoding.x;
+  const yChannel = encoding.y;
+  const textChannel = encoding.text;
+  if (!textChannel || !("field" in textChannel)) return [];
+  const marks = [];
+  const colorEncoding = encoding.color && "field" in encoding.color ? encoding.color : void 0;
+  const colorField = colorEncoding?.field;
+  const sizeEncoding = encoding.size && "field" in encoding.size ? encoding.size : void 0;
+  for (const row of spec.data) {
+    let x2 = 0;
+    if (xChannel && scales.x) {
+      const xVal = scaleValue(scales.x.scale, scales.x.type, row[xChannel.field]);
+      if (xVal == null) continue;
+      x2 = xVal;
+    }
+    let y2 = 0;
+    if (yChannel && scales.y) {
+      const yVal = scaleValue(scales.y.scale, scales.y.type, row[yChannel.field]);
+      if (yVal == null) continue;
+      y2 = yVal;
+    }
+    const text = String(row[textChannel.field] ?? "");
+    if (!text) continue;
+    const color2 = getRepresentativeColor8(
+      colorField ? getColor(scales, String(row[colorField] ?? "__default__")) : getColor(scales, "__default__")
+    );
+    const fontSize = sizeEncoding ? Math.max(8, Math.min(48, Number(row[sizeEncoding.field]) || 12)) : 12;
+    const aria = {
+      label: text
+    };
+    marks.push({
+      type: "textMark",
+      x: x2,
+      y: y2,
+      text,
+      fill: color2,
+      fontSize,
+      textAnchor: "middle",
+      angle: encoding.angle && "field" in encoding.angle ? Number(row[encoding.angle.field]) || 0 : void 0,
+      data: row,
+      aria
+    });
+  }
+  return marks;
+}
+var textRenderer = (spec, scales, _chartArea, _strategy, _theme) => {
+  return computeTextMarks(spec, scales);
+};
+
+// src/charts/tick/index.ts
+import { getRepresentativeColor as getRepresentativeColor9 } from "@opendata-ai/openchart-core";
+var DEFAULT_TICK_LENGTH = 18;
+function computeTickMarks(spec, scales, _chartArea) {
+  const encoding = spec.encoding;
+  const xChannel = encoding.x;
+  const yChannel = encoding.y;
+  if (!xChannel || !yChannel || !scales.x || !scales.y) return [];
+  const colorEncoding = encoding.color && "field" in encoding.color ? encoding.color : void 0;
+  const colorField = colorEncoding?.field;
+  const marks = [];
+  const isHorizontal = xChannel.type === "quantitative" && yChannel.type !== "quantitative";
+  const orient = isHorizontal ? "horizontal" : "vertical";
+  for (const row of spec.data) {
+    const xVal = scaleValue(scales.x.scale, scales.x.type, row[xChannel.field]);
+    const yVal = scaleValue(scales.y.scale, scales.y.type, row[yChannel.field]);
+    if (xVal == null || yVal == null) continue;
+    const color2 = getRepresentativeColor9(
+      colorField ? getColor(scales, String(row[colorField] ?? "__default__")) : getColor(scales, "__default__")
+    );
+    const aria = {
+      label: `${row[xChannel.field]}, ${row[yChannel.field]}`
+    };
+    marks.push({
+      type: "tick",
+      x: xVal,
+      y: yVal,
+      length: DEFAULT_TICK_LENGTH,
+      orient,
+      stroke: color2,
+      strokeWidth: 1,
+      opacity: encoding.opacity && "field" in encoding.opacity ? Math.max(0, Math.min(1, Number(row[encoding.opacity.field]) || 1)) : void 0,
+      data: row,
+      aria
+    });
+  }
+  return marks;
+}
+var tickRenderer = (spec, scales, chartArea, _strategy, _theme) => {
+  return computeTickMarks(spec, scales, chartArea);
+};
+
+// src/charts/builtin.ts
+var builtinRenderers = {
+  line: lineRenderer,
+  area: areaRenderer,
+  bar: barRenderer,
+  // horizontal bars
+  "bar:vertical": columnRenderer,
+  // vertical bars (old 'column')
+  point: scatterRenderer,
+  // old 'scatter'
+  arc: pieRenderer,
+  // old 'pie' (donut handled via innerRadius)
+  "arc:donut": donutRenderer,
+  // old 'donut'
+  circle: dotRenderer,
+  // old 'dot'
+  lollipop: dotRenderer,
+  // semantic alias for dot/circle
+  text: textRenderer,
+  rule: ruleRenderer,
+  tick: tickRenderer,
+  rect: columnRenderer
+  // rect uses column renderer (RectMark output) as baseline for heatmaps
+};
+function registerBuiltinRenderers() {
+  for (const [type, renderer] of Object.entries(builtinRenderers)) {
+    registerChartRenderer(type, renderer);
+  }
+}
+registerBuiltinRenderers();
+
 // src/charts/post-process.ts
 function computeMarkObstacles(marks, scales) {
   if (scales.y?.type === "band") {
@@ -4484,7 +7456,7 @@ var MAX_NODE_RADIUS = 12;
 var DEFAULT_EDGE_WIDTH = 1;
 var MIN_EDGE_WIDTH = 0.5;
 var MAX_EDGE_WIDTH = 4;
-var DEFAULT_STROKE_WIDTH = 1;
+var DEFAULT_STROKE_WIDTH2 = 1;
 function darkenColor(hex2, amount = 0.2) {
   const clean = hex2.replace(/^#/, "");
   if (clean.length !== 6 && clean.length !== 3) return hex2;
@@ -4523,9 +7495,9 @@ function resolveNodeVisuals(nodes, encoding, edges, theme, nodeOverrides) {
   if (encoding.nodeSize?.field) {
     const field = encoding.nodeSize.field;
     const values = nodes.map((n) => Number(n[field])).filter((v) => Number.isFinite(v));
-    const sizeMin = min(values) ?? 0;
-    const sizeMax = max(values) ?? 1;
-    sizeScale = sqrt().domain([sizeMin, sizeMax]).range([MIN_NODE_RADIUS, MAX_NODE_RADIUS]);
+    const sizeMin = min2(values) ?? 0;
+    const sizeMax = max2(values) ?? 1;
+    sizeScale = sqrt2().domain([sizeMin, sizeMax]).range([MIN_NODE_RADIUS, MAX_NODE_RADIUS]);
   }
   let colorFn;
   if (encoding.nodeColor?.field) {
@@ -4534,8 +7506,8 @@ function resolveNodeVisuals(nodes, encoding, edges, theme, nodeOverrides) {
     const scaleConfig = encoding.nodeColor.scale;
     if (fieldType === "quantitative") {
       const values = nodes.map((n) => Number(n[field])).filter((v) => Number.isFinite(v));
-      const colorMin = min(values) ?? 0;
-      const colorMax = max(values) ?? 1;
+      const colorMin = min2(values) ?? 0;
+      const colorMax = max2(values) ?? 1;
       const seqPalettes = Object.values(theme.colors.sequential);
       const palette = seqPalettes.length > 0 ? seqPalettes[0] : ["#ccc", "#333"];
       const domain = scaleConfig?.domain && scaleConfig.domain.length === 2 ? scaleConfig.domain : [colorMin, colorMax];
@@ -4577,7 +7549,7 @@ function resolveNodeVisuals(nodes, encoding, edges, theme, nodeOverrides) {
     const override = nodeOverrides?.[node.id];
     const finalFill = override?.fill ?? fill;
     const finalRadius = override?.radius ?? radius;
-    const finalStrokeWidth = override?.strokeWidth ?? DEFAULT_STROKE_WIDTH;
+    const finalStrokeWidth = override?.strokeWidth ?? DEFAULT_STROKE_WIDTH2;
     const finalStroke = override?.stroke ?? stroke;
     const finalLabelPriority = override?.alwaysShowLabel ? Infinity : labelPriority;
     return {
@@ -4598,8 +7570,8 @@ function resolveEdgeVisuals(edges, encoding, theme) {
   if (encoding.edgeWidth?.field) {
     const field = encoding.edgeWidth.field;
     const values = edges.map((e) => Number(e[field])).filter((v) => Number.isFinite(v));
-    const widthMin = min(values) ?? 0;
-    const widthMax = max(values) ?? 1;
+    const widthMin = min2(values) ?? 0;
+    const widthMax = max2(values) ?? 1;
     widthScale = linear2().domain([widthMin, widthMax]).range([MIN_EDGE_WIDTH, MAX_EDGE_WIDTH]);
   }
   let edgeColorFn;
@@ -4609,8 +7581,8 @@ function resolveEdgeVisuals(edges, encoding, theme) {
     const scaleConfig = encoding.edgeColor.scale;
     if (fieldType === "quantitative") {
       const values = edges.map((e) => Number(e[field])).filter((v) => Number.isFinite(v));
-      const colorMin = min(values) ?? 0;
-      const colorMax = max(values) ?? 1;
+      const colorMin = min2(values) ?? 0;
+      const colorMax = max2(values) ?? 1;
       const seqPalettes = Object.values(theme.colors.sequential);
       const palette = seqPalettes.length > 0 ? seqPalettes[0] : ["#ccc", "#333"];
       const domain = scaleConfig?.domain && scaleConfig.domain.length === 2 ? scaleConfig.domain : [colorMin, colorMax];
@@ -4869,11 +7841,11 @@ function compileGraph(spec, options) {
 var DEFAULT_COLLISION_PADDING = 5;
 
 // src/layout/axes/thinning.ts
-import { estimateTextWidth as estimateTextWidth2 } from "@opendata-ai/openchart-core";
+import { estimateTextWidth as estimateTextWidth7 } from "@opendata-ai/openchart-core";
 var MIN_TICK_GAP_FACTOR = 1;
 var MIN_TICK_COUNT = 2;
 function measureLabel(text, fontSize, fontWeight, measureText) {
-  return measureText ? measureText(text, fontSize, fontWeight).width : estimateTextWidth2(text, fontSize, fontWeight);
+  return measureText ? measureText(text, fontSize, fontWeight).width : estimateTextWidth7(text, fontSize, fontWeight);
 }
 function ticksOverlap(ticks2, fontSize, fontWeight, measureText, orientation = "horizontal") {
   if (ticks2.length < 2) return false;
@@ -4914,11 +7886,11 @@ function thinTicksUntilFit(ticks2, fontSize, fontWeight, measureText, orientatio
 
 // src/layout/axes/ticks.ts
 import {
-  abbreviateNumber,
-  buildD3Formatter,
+  abbreviateNumber as abbreviateNumber2,
+  buildD3Formatter as buildD3Formatter4,
   buildTemporalFormatter,
   formatDate,
-  formatNumber
+  formatNumber as formatNumber2
 } from "@opendata-ai/openchart-core";
 var Y_PX_PER_TICK = {
   full: 55,
@@ -4947,9 +7919,9 @@ var TICK_COUNTS = {
 };
 function targetTickCount(axisLength, density, orientation) {
   const pxPerTick = orientation === "y" ? Y_PX_PER_TICK[density] : X_PX_PER_TICK[density];
-  const [min3, max3] = orientation === "y" ? Y_TICK_COUNT_RANGE[density] : X_TICK_COUNT_RANGE[density];
+  const [min4, max4] = orientation === "y" ? Y_TICK_COUNT_RANGE[density] : X_TICK_COUNT_RANGE[density];
   const raw = Math.round(axisLength / pxPerTick);
-  return Math.max(min3, Math.min(max3, raw));
+  return Math.max(min4, Math.min(max4, raw));
 }
 var NUMERIC_SCALE_TYPES = /* @__PURE__ */ new Set([
   "linear",
@@ -4973,11 +7945,11 @@ function formatTickLabel(value2, resolvedScale) {
   if (NUMERIC_SCALE_TYPES.has(resolvedScale.type)) {
     const num = value2;
     if (formatStr) {
-      const fmt = buildD3Formatter(formatStr);
+      const fmt = buildD3Formatter4(formatStr);
       if (fmt) return fmt(num);
     }
-    if (Math.abs(num) >= 1e3) return abbreviateNumber(num);
-    return formatNumber(num);
+    if (Math.abs(num) >= 1e3) return abbreviateNumber2(num);
+    return formatNumber2(num);
   }
   return String(value2);
 }
@@ -5148,7 +8120,8 @@ function computeAxes(scales, chartArea, strategy, theme, measureText) {
       position: t.position,
       major: true
     }));
-    const shouldThin = scales.x.type !== "band" && !axisConfig?.tickCount && !axisConfig?.values;
+    const hasExplicitValues = !!axisConfig?.values;
+    const shouldThin = scales.x.type !== "band" && !hasExplicitValues;
     let ticks2;
     if (!shouldThin) {
       ticks2 = allTicks;
@@ -5210,9 +8183,9 @@ function computeAxes(scales, chartArea, strategy, theme, measureText) {
     } else {
       allTicks = continuousTicks(scales.y, yDensity, yTargetCount);
     }
-    const shouldThin = scales.y.type !== "band" && !axisConfig?.tickCount && !axisConfig?.values;
+    const shouldThinY = scales.y.type !== "band" && !axisConfig?.values;
     let ticks2;
-    if (!shouldThin) {
+    if (!shouldThinY) {
       ticks2 = allTicks;
     } else if (isContinuousY) {
       ticks2 = fitContinuousTicks(
@@ -5258,7 +8231,51 @@ function computeAxes(scales, chartArea, strategy, theme, measureText) {
 }
 
 // src/layout/dimensions.ts
-import { computeChrome as computeChrome2, estimateTextWidth as estimateTextWidth3 } from "@opendata-ai/openchart-core";
+import { computeChrome as computeChrome2, estimateTextWidth as estimateTextWidth9 } from "@opendata-ai/openchart-core";
+
+// src/legend/wrap.ts
+import { COMPACT_WIDTH, estimateTextWidth as estimateTextWidth8 } from "@opendata-ai/openchart-core";
+var SWATCH_SIZE2 = 12;
+var SWATCH_GAP2 = 6;
+var ENTRY_GAP2 = 16;
+var ENTRY_GAP_COMPACT = 10;
+var LEGEND_GAP = 4;
+function legendGap(width) {
+  return width < COMPACT_WIDTH ? 0 : LEGEND_GAP;
+}
+function measureLegendWrap(entries, maxWidth, labelStyle, maxRows, entryGap = ENTRY_GAP2) {
+  if (entries.length === 0) {
+    return { rowCount: 0, fittingCount: 0, rowWidths: [] };
+  }
+  let rowCount = 1;
+  let rowWidth = 0;
+  const rowWidths = [];
+  let fittingCount = entries.length;
+  let fittingCountLocked = false;
+  for (let i = 0; i < entries.length; i++) {
+    const labelWidth = estimateTextWidth8(
+      entries[i].label,
+      labelStyle.fontSize,
+      labelStyle.fontWeight
+    );
+    const entryWidth = SWATCH_SIZE2 + SWATCH_GAP2 + labelWidth + entryGap;
+    if (rowWidth + entryWidth > maxWidth && rowWidth > 0) {
+      rowWidths.push(rowWidth);
+      rowCount++;
+      rowWidth = entryWidth;
+      if (!fittingCountLocked && maxRows != null && rowCount > maxRows) {
+        fittingCount = i;
+        fittingCountLocked = true;
+      }
+    } else {
+      rowWidth += entryWidth;
+    }
+  }
+  rowWidths.push(rowWidth);
+  return { rowCount, fittingCount, rowWidths };
+}
+
+// src/layout/dimensions.ts
 function chromeToInput(chrome) {
   return {
     title: chrome.title,
@@ -5307,7 +8324,7 @@ function computeDimensions(spec, options, legendLayout, theme, strategy, waterma
     if (xField) {
       for (const row of spec.data) {
         const label = String(row[xField] ?? "");
-        const w = estimateTextWidth3(label, theme.fonts.sizes.axisTick, theme.fonts.weights.normal);
+        const w = estimateTextWidth9(label, theme.fonts.sizes.axisTick, theme.fonts.weights.normal);
         if (w > maxLabelWidth) maxLabelWidth = w;
       }
     }
@@ -5335,7 +8352,7 @@ function computeDimensions(spec, options, legendLayout, theme, strategy, waterma
         const label = String(row[colorField] ?? "");
         if (!seen.has(label)) {
           seen.add(label);
-          const w = estimateTextWidth3(label, 11, 600);
+          const w = estimateTextWidth9(label, 11, 600);
           if (w > maxLabelWidth) maxLabelWidth = w;
         }
       }
@@ -5355,7 +8372,7 @@ function computeDimensions(spec, options, legendLayout, theme, strategy, waterma
       const maxXStr = String(maxX);
       for (const ann of spec.annotations) {
         if (ann.type === "text" && String(ann.x) === maxXStr) {
-          const textWidth = estimateTextWidth3(ann.text, ann.fontSize ?? 11, ann.fontWeight ?? 600);
+          const textWidth = estimateTextWidth9(ann.text, ann.fontSize ?? 11, ann.fontWeight ?? 600);
           const dx = ann.offset?.dx ?? 0;
           const anchor = ann.anchor ?? "auto";
           const baseRightExtent = anchor === "left" ? textWidth : (
@@ -5379,11 +8396,15 @@ function computeDimensions(spec, options, legendLayout, theme, strategy, waterma
       let maxLabelWidth = 0;
       for (const row of spec.data) {
         const label = String(row[yField] ?? "");
-        const w = estimateTextWidth3(label, theme.fonts.sizes.axisTick, theme.fonts.weights.normal);
+        const w = estimateTextWidth9(label, theme.fonts.sizes.axisTick, theme.fonts.weights.normal);
         if (w > maxLabelWidth) maxLabelWidth = w;
       }
       if (maxLabelWidth > 0) {
-        margins.left = Math.max(margins.left, padding + maxLabelWidth + 12);
+        const labelGap = width < 500 ? 8 : 12;
+        const maxLeftFraction = width < 400 ? 0.45 : width < 600 ? 0.55 : 1;
+        const maxLeftReserved = Math.floor(width * maxLeftFraction);
+        const reserved = Math.min(padding + maxLabelWidth + labelGap, maxLeftReserved);
+        margins.left = Math.max(margins.left, reserved);
       }
     } else if (encoding.y.type === "quantitative" || encoding.y.type === "temporal") {
       const yField = encoding.y.field;
@@ -5411,7 +8432,7 @@ function computeDimensions(spec, options, legendLayout, theme, strategy, waterma
       }
       const negPrefix = spec.data.some((r) => Number(r[yField]) < 0) ? "-" : "";
       const labelEst = negPrefix + sampleLabel;
-      const labelWidth = estimateTextWidth3(
+      const labelWidth = estimateTextWidth9(
         labelEst,
         theme.fonts.sizes.axisTick,
         theme.fonts.weights.normal
@@ -5425,12 +8446,13 @@ function computeDimensions(spec, options, legendLayout, theme, strategy, waterma
     margins.left = Math.max(margins.left, padding + rotatedLabelMargin);
   }
   if (legendLayout.entries.length > 0) {
+    const gap = legendGap(width);
     if (legendLayout.position === "right" || legendLayout.position === "bottom-right") {
       margins.right += legendLayout.bounds.width + 8;
     } else if (legendLayout.position === "top") {
-      margins.top += legendLayout.bounds.height + 4;
+      margins.top += legendLayout.bounds.height + gap;
     } else if (legendLayout.position === "bottom") {
-      margins.bottom += legendLayout.bounds.height + 4;
+      margins.bottom += legendLayout.bounds.height + gap;
     }
   }
   let chartArea = {
@@ -5456,7 +8478,8 @@ function computeDimensions(spec, options, legendLayout, theme, strategy, waterma
     const newBottom = padding + fallbackChrome.bottomHeight + xAxisHeight;
     const bottomDelta = margins.bottom - newBottom;
     if (topDelta > 0 || bottomDelta > 0) {
-      margins.top = newTop + (legendLayout.entries.length > 0 && legendLayout.position === "top" ? legendLayout.bounds.height + 4 : 0);
+      const gap = legendGap(width);
+      margins.top = newTop + (legendLayout.entries.length > 0 && legendLayout.position === "top" ? legendLayout.bounds.height + gap : 0);
       margins.bottom = newBottom;
       chartArea = {
         x: margins.left,
@@ -5565,8 +8588,8 @@ function buildLinearScale(channel, data, rangeStart, rangeEnd) {
     domainMin = d0;
     domainMax = d1;
   } else {
-    domainMin = min(values) ?? 0;
-    domainMax = max(values) ?? 1;
+    domainMin = min2(values) ?? 0;
+    domainMax = max2(values) ?? 1;
     if (channel.scale?.zero !== false) {
       domainMin = Math.min(0, domainMin);
       domainMax = Math.max(0, domainMax);
@@ -5581,8 +8604,8 @@ function buildLinearScale(channel, data, rangeStart, rangeEnd) {
 }
 function buildLogScale(channel, data, rangeStart, rangeEnd) {
   const values = parseNumbers(fieldValues(data, channel.field)).filter((v) => v > 0);
-  const domainMin = channel.scale?.domain ? channel.scale.domain[0] : min(values) ?? 1;
-  const domainMax = channel.scale?.domain ? channel.scale.domain[1] : max(values) ?? 10;
+  const domainMin = channel.scale?.domain ? channel.scale.domain[0] : min2(values) ?? 1;
+  const domainMax = channel.scale?.domain ? channel.scale.domain[1] : max2(values) ?? 10;
   const scale = log().domain([domainMin, domainMax]).range([rangeStart, rangeEnd]);
   if (channel.scale?.base !== void 0) {
     scale.base(channel.scale.base);
@@ -5600,8 +8623,8 @@ function buildPowScale(channel, data, rangeStart, rangeEnd) {
   if (channel.scale?.domain) {
     [domainMin, domainMax] = channel.scale.domain;
   } else {
-    domainMin = min(values) ?? 0;
-    domainMax = max(values) ?? 1;
+    domainMin = min2(values) ?? 0;
+    domainMax = max2(values) ?? 1;
     if (channel.scale?.zero !== false) {
       domainMin = Math.min(0, domainMin);
       domainMax = Math.max(0, domainMax);
@@ -5624,14 +8647,14 @@ function buildSqrtScale(channel, data, rangeStart, rangeEnd) {
   if (channel.scale?.domain) {
     [domainMin, domainMax] = channel.scale.domain;
   } else {
-    domainMin = min(values) ?? 0;
-    domainMax = max(values) ?? 1;
+    domainMin = min2(values) ?? 0;
+    domainMax = max2(values) ?? 1;
     if (channel.scale?.zero !== false) {
       domainMin = Math.min(0, domainMin);
       domainMax = Math.max(0, domainMax);
     }
   }
-  const scale = sqrt().domain([domainMin, domainMax]).range([rangeStart, rangeEnd]);
+  const scale = sqrt2().domain([domainMin, domainMax]).range([rangeStart, rangeEnd]);
   if (!channel.scale?.domain && channel.scale?.nice !== false) {
     scale.nice();
   }
@@ -5645,8 +8668,8 @@ function buildSymlogScale(channel, data, rangeStart, rangeEnd) {
   if (channel.scale?.domain) {
     [domainMin, domainMax] = channel.scale.domain;
   } else {
-    domainMin = min(values) ?? 0;
-    domainMax = max(values) ?? 1;
+    domainMin = min2(values) ?? 0;
+    domainMax = max2(values) ?? 1;
     if (channel.scale?.zero !== false) {
       domainMin = Math.min(0, domainMin);
       domainMax = Math.max(0, domainMax);
@@ -5670,8 +8693,8 @@ function buildQuantileScale(channel, data, rangeStart, rangeEnd) {
 }
 function buildQuantizeScale(channel, data, rangeStart, rangeEnd) {
   const values = parseNumbers(fieldValues(data, channel.field));
-  const domainMin = channel.scale?.domain ? channel.scale.domain[0] : min(values) ?? 0;
-  const domainMax = channel.scale?.domain ? channel.scale.domain[1] : max(values) ?? 1;
+  const domainMin = channel.scale?.domain ? channel.scale.domain[0] : min2(values) ?? 0;
+  const domainMax = channel.scale?.domain ? channel.scale.domain[1] : max2(values) ?? 1;
   const range2 = channel.scale?.range ? channel.scale.range : evenRange(rangeStart, rangeEnd, 4);
   const scale = quantize().domain([domainMin, domainMax]).range(range2);
   return { scale, type: "quantize", channel };
@@ -5706,7 +8729,7 @@ function buildBandScale(channel, data, rangeStart, rangeEnd) {
 function buildPointScale(channel, data, rangeStart, rangeEnd) {
   const values = channel.scale?.domain ? channel.scale.domain : applyCategoricalSort(uniqueStrings(fieldValues(data, channel.field)), channel.sort);
   const padding = channel.scale?.padding ?? 0.5;
-  const scale = point().domain(values).range([rangeStart, rangeEnd]).padding(padding);
+  const scale = point4().domain(values).range([rangeStart, rangeEnd]).padding(padding);
   if (channel.scale?.reverse) {
     const [r0, r1] = scale.range();
     scale.range([r1, r0]);
@@ -5723,8 +8746,8 @@ function buildOrdinalColorScale(channel, data, palette) {
 }
 function buildSequentialColorScale(channel, data, palette) {
   const values = parseNumbers(fieldValues(data, channel.field));
-  const domainMin = min(values) ?? 0;
-  const domainMax = max(values) ?? 1;
+  const domainMin = min2(values) ?? 0;
+  const domainMax = max2(values) ?? 1;
   const explicitRange = channel.scale?.range;
   const colors = explicitRange ?? palette;
   const scale = linear2().domain([domainMin, domainMax]).range([colors[0], colors[colors.length - 1]]).clamp(true);
@@ -5925,46 +8948,7 @@ function computeScales(spec, chartArea, data) {
 }
 
 // src/legend/compute.ts
-import { BRAND_RESERVE_WIDTH as BRAND_RESERVE_WIDTH2, estimateTextWidth as estimateTextWidth5 } from "@opendata-ai/openchart-core";
-
-// src/legend/wrap.ts
-import { estimateTextWidth as estimateTextWidth4 } from "@opendata-ai/openchart-core";
-var SWATCH_SIZE2 = 12;
-var SWATCH_GAP2 = 6;
-var ENTRY_GAP2 = 16;
-function measureLegendWrap(entries, maxWidth, labelStyle, maxRows) {
-  if (entries.length === 0) {
-    return { rowCount: 0, fittingCount: 0, rowWidths: [] };
-  }
-  let rowCount = 1;
-  let rowWidth = 0;
-  const rowWidths = [];
-  let fittingCount = entries.length;
-  let fittingCountLocked = false;
-  for (let i = 0; i < entries.length; i++) {
-    const labelWidth = estimateTextWidth4(
-      entries[i].label,
-      labelStyle.fontSize,
-      labelStyle.fontWeight
-    );
-    const entryWidth = SWATCH_SIZE2 + SWATCH_GAP2 + labelWidth + ENTRY_GAP2;
-    if (rowWidth + entryWidth > maxWidth && rowWidth > 0) {
-      rowWidths.push(rowWidth);
-      rowCount++;
-      rowWidth = entryWidth;
-      if (!fittingCountLocked && maxRows != null && rowCount > maxRows) {
-        fittingCount = i;
-        fittingCountLocked = true;
-      }
-    } else {
-      rowWidth += entryWidth;
-    }
-  }
-  rowWidths.push(rowWidth);
-  return { rowCount, fittingCount, rowWidths };
-}
-
-// src/legend/compute.ts
+import { BRAND_RESERVE_WIDTH as BRAND_RESERVE_WIDTH2, COMPACT_WIDTH as COMPACT_WIDTH2, estimateTextWidth as estimateTextWidth10 } from "@opendata-ai/openchart-core";
 var LEGEND_PADDING = 8;
 var LEGEND_RIGHT_WIDTH = 120;
 var RIGHT_LEGEND_MAX_HEIGHT_RATIO = 0.4;
@@ -5986,11 +8970,15 @@ function extractColorEntries(spec, theme) {
   if (!colorEnc) return [];
   if ("condition" in colorEnc) return [];
   if (colorEnc.type === "quantitative") return [];
-  const uniqueValues = [...new Set(spec.data.map((d) => String(d[colorEnc.field])))];
+  const dataValues = [...new Set(spec.data.map((d) => String(d[colorEnc.field])))];
   const explicitDomain = colorEnc.scale?.domain;
   const explicitRange = colorEnc.scale?.range;
   const palette = explicitRange ?? theme.colors.categorical;
   const shape = swatchShapeForType(spec.markType);
+  const uniqueValues = explicitDomain ? [
+    ...explicitDomain.filter((v) => dataValues.includes(v)),
+    ...dataValues.filter((v) => !explicitDomain.includes(v))
+  ] : dataValues;
   return uniqueValues.map((value2, i) => {
     let colorIndex = i;
     if (explicitDomain && explicitRange) {
@@ -6045,8 +9033,8 @@ function computeLegend(spec, strategy, theme, chartArea, watermark = true) {
   if (isLineOrArea && hasLabels && labelsWillRender && hasColorEncoding && legendNotForced) {
     const isArea = spec.markType === "area";
     const quantChannel = spec.encoding.y?.type === "quantitative" ? spec.encoding.y : spec.encoding.x;
-    const stackValue = quantChannel?.stack;
-    const isStacked = stackValue !== null && stackValue !== false;
+    const stackValue2 = quantChannel?.stack;
+    const isStacked = stackValue2 !== null && stackValue2 !== false;
     if (!isArea || !isStacked) {
       entries = [];
     }
@@ -6072,7 +9060,7 @@ function computeLegend(spec, strategy, theme, chartArea, watermark = true) {
   }
   if (resolvedPosition === "right" || resolvedPosition === "bottom-right") {
     const maxLabelWidth = Math.max(
-      ...entries.map((e) => estimateTextWidth5(e.label, labelStyle.fontSize, labelStyle.fontWeight))
+      ...entries.map((e) => estimateTextWidth10(e.label, labelStyle.fontSize, labelStyle.fontWeight))
     );
     const legendWidth = Math.min(
       LEGEND_RIGHT_WIDTH,
@@ -6110,7 +9098,10 @@ function computeLegend(spec, strategy, theme, chartArea, watermark = true) {
     };
   }
   const reserveBrand = watermark && resolvedPosition === "bottom";
-  const availableWidth = chartArea.width - LEGEND_PADDING * 2 - (reserveBrand ? BRAND_RESERVE_WIDTH2 : 0);
+  const isCompact = chartArea.width < COMPACT_WIDTH2;
+  const effectivePadding = isCompact ? 2 : LEGEND_PADDING;
+  const effectiveEntryGap = isCompact ? ENTRY_GAP_COMPACT : ENTRY_GAP2;
+  const availableWidth = chartArea.width - effectivePadding * 2 - (reserveBrand ? BRAND_RESERVE_WIDTH2 : 0);
   if (spec.legend?.symbolLimit != null) {
     const limit = Math.max(1, spec.legend.symbolLimit);
     if (limit < entries.length) {
@@ -6118,17 +9109,29 @@ function computeLegend(spec, strategy, theme, chartArea, watermark = true) {
     }
   }
   const maxRows = spec.legend?.maxRows != null ? Math.max(1, spec.legend.maxRows) : spec.legend?.columns != null ? Math.ceil(entries.length / spec.legend.columns) : TOP_LEGEND_MAX_ROWS;
-  const { fittingCount } = measureLegendWrap(entries, availableWidth, labelStyle, maxRows);
+  const { fittingCount } = measureLegendWrap(
+    entries,
+    availableWidth,
+    labelStyle,
+    maxRows,
+    effectiveEntryGap
+  );
   if (fittingCount < entries.length) {
     entries = truncateEntries(entries, fittingCount);
   }
   const totalWidth = entries.reduce((sum2, entry) => {
-    const labelWidth = estimateTextWidth5(entry.label, labelStyle.fontSize, labelStyle.fontWeight);
-    return sum2 + SWATCH_SIZE2 + SWATCH_GAP2 + labelWidth + ENTRY_GAP2;
+    const labelWidth = estimateTextWidth10(entry.label, labelStyle.fontSize, labelStyle.fontWeight);
+    return sum2 + SWATCH_SIZE2 + SWATCH_GAP2 + labelWidth + effectiveEntryGap;
   }, 0);
-  const { rowCount } = measureLegendWrap(entries, availableWidth, labelStyle);
+  const { rowCount } = measureLegendWrap(
+    entries,
+    availableWidth,
+    labelStyle,
+    void 0,
+    effectiveEntryGap
+  );
   const rowHeight = SWATCH_SIZE2 + 4;
-  const legendHeight = rowCount * rowHeight + LEGEND_PADDING * 2;
+  const legendHeight = rowCount * rowHeight + effectivePadding * 2;
   const offsetDx = spec.legend?.offset?.dx ?? 0;
   const offsetDy = spec.legend?.offset?.dy ?? 0;
   return {
@@ -6143,58 +9146,58 @@ function computeLegend(spec, strategy, theme, chartArea, watermark = true) {
     labelStyle,
     swatchSize: SWATCH_SIZE2,
     swatchGap: SWATCH_GAP2,
-    entryGap: ENTRY_GAP2
+    entryGap: effectiveEntryGap
   };
 }
 
 // src/sankey/compile-sankey.ts
 import {
   adaptTheme as adaptTheme2,
-  buildD3Formatter as buildD3Formatter2,
+  buildD3Formatter as buildD3Formatter5,
   computeChrome as computeChrome3,
-  estimateTextWidth as estimateTextWidth6,
-  formatNumber as formatNumber2,
+  estimateTextWidth as estimateTextWidth11,
+  formatNumber as formatNumber3,
   resolveTheme as resolveTheme2
 } from "@opendata-ai/openchart-core";
 
 // ../../node_modules/.bun/d3-array@2.12.1/node_modules/d3-array/src/max.js
-function max2(values, valueof) {
-  let max3;
+function max3(values, valueof) {
+  let max4;
   if (valueof === void 0) {
     for (const value2 of values) {
-      if (value2 != null && (max3 < value2 || max3 === void 0 && value2 >= value2)) {
-        max3 = value2;
+      if (value2 != null && (max4 < value2 || max4 === void 0 && value2 >= value2)) {
+        max4 = value2;
       }
     }
   } else {
     let index = -1;
     for (let value2 of values) {
-      if ((value2 = valueof(value2, ++index, values)) != null && (max3 < value2 || max3 === void 0 && value2 >= value2)) {
-        max3 = value2;
+      if ((value2 = valueof(value2, ++index, values)) != null && (max4 < value2 || max4 === void 0 && value2 >= value2)) {
+        max4 = value2;
       }
     }
   }
-  return max3;
+  return max4;
 }
 
 // ../../node_modules/.bun/d3-array@2.12.1/node_modules/d3-array/src/min.js
-function min2(values, valueof) {
-  let min3;
+function min3(values, valueof) {
+  let min4;
   if (valueof === void 0) {
     for (const value2 of values) {
-      if (value2 != null && (min3 > value2 || min3 === void 0 && value2 >= value2)) {
-        min3 = value2;
+      if (value2 != null && (min4 > value2 || min4 === void 0 && value2 >= value2)) {
+        min4 = value2;
       }
     }
   } else {
     let index = -1;
     for (let value2 of values) {
-      if ((value2 = valueof(value2, ++index, values)) != null && (min3 > value2 || min3 === void 0 && value2 >= value2)) {
-        min3 = value2;
+      if ((value2 = valueof(value2, ++index, values)) != null && (min4 > value2 || min4 === void 0 && value2 >= value2)) {
+        min4 = value2;
       }
     }
   }
-  return min3;
+  return min4;
 }
 
 // ../../node_modules/.bun/d3-array@2.12.1/node_modules/d3-array/src/sum.js
@@ -6231,13 +9234,13 @@ function justify(node, n) {
   return node.sourceLinks.length ? node.depth : n - 1;
 }
 function center(node) {
-  return node.targetLinks.length ? node.depth : node.sourceLinks.length ? min2(node.sourceLinks, targetDepth) - 1 : 0;
+  return node.targetLinks.length ? node.depth : node.sourceLinks.length ? min3(node.sourceLinks, targetDepth) - 1 : 0;
 }
 
 // ../../node_modules/.bun/d3-sankey@0.12.3/node_modules/d3-sankey/src/constant.js
-function constant(x) {
+function constant(x2) {
   return function() {
-    return x;
+    return x2;
   };
 }
 
@@ -6371,15 +9374,15 @@ function Sankey() {
     const n = nodes2.length;
     let current = new Set(nodes2);
     let next = /* @__PURE__ */ new Set();
-    let x = 0;
+    let x2 = 0;
     while (current.size) {
       for (const node of current) {
-        node.depth = x;
+        node.depth = x2;
         for (const { target } of node.sourceLinks) {
           next.add(target);
         }
       }
-      if (++x > n) throw new Error("circular link");
+      if (++x2 > n) throw new Error("circular link");
       current = next;
       next = /* @__PURE__ */ new Set();
     }
@@ -6388,25 +9391,25 @@ function Sankey() {
     const n = nodes2.length;
     let current = new Set(nodes2);
     let next = /* @__PURE__ */ new Set();
-    let x = 0;
+    let x2 = 0;
     while (current.size) {
       for (const node of current) {
-        node.height = x;
+        node.height = x2;
         for (const { source } of node.targetLinks) {
           next.add(source);
         }
       }
-      if (++x > n) throw new Error("circular link");
+      if (++x2 > n) throw new Error("circular link");
       current = next;
       next = /* @__PURE__ */ new Set();
     }
   }
   function computeNodeLayers({ nodes: nodes2 }) {
-    const x = max2(nodes2, (d) => d.depth) + 1;
-    const kx = (x1 - x0 - dx) / (x - 1);
-    const columns = new Array(x);
+    const x2 = max3(nodes2, (d) => d.depth) + 1;
+    const kx = (x1 - x0 - dx) / (x2 - 1);
+    const columns = new Array(x2);
     for (const node of nodes2) {
-      const i = Math.max(0, Math.min(x - 1, Math.floor(align.call(null, node, x))));
+      const i = Math.max(0, Math.min(x2 - 1, Math.floor(align.call(null, node, x2))));
       node.layer = i;
       node.x0 = x0 + i * kx;
       node.x1 = node.x0 + dx;
@@ -6419,29 +9422,29 @@ function Sankey() {
     return columns;
   }
   function initializeNodeBreadths(columns) {
-    const ky = min2(columns, (c) => (y1 - y0 - (c.length - 1) * py) / sum(c, value));
+    const ky = min3(columns, (c) => (y1 - y0 - (c.length - 1) * py) / sum(c, value));
     for (const nodes2 of columns) {
-      let y = y0;
+      let y2 = y0;
       for (const node of nodes2) {
-        node.y0 = y;
-        node.y1 = y + node.value * ky;
-        y = node.y1 + py;
+        node.y0 = y2;
+        node.y1 = y2 + node.value * ky;
+        y2 = node.y1 + py;
         for (const link of node.sourceLinks) {
           link.width = link.value * ky;
         }
       }
-      y = (y1 - y + py) / (nodes2.length + 1);
+      y2 = (y1 - y2 + py) / (nodes2.length + 1);
       for (let i = 0; i < nodes2.length; ++i) {
         const node = nodes2[i];
-        node.y0 += y * (i + 1);
-        node.y1 += y * (i + 1);
+        node.y0 += y2 * (i + 1);
+        node.y1 += y2 * (i + 1);
       }
       reorderLinks(nodes2);
     }
   }
   function computeNodeBreadths(graph) {
     const columns = computeNodeLayers(graph);
-    py = Math.min(dy, (y1 - y0) / (max2(columns, (c) => c.length) - 1));
+    py = Math.min(dy, (y1 - y0) / (max3(columns, (c) => c.length) - 1));
     initializeNodeBreadths(columns);
     for (let i = 0; i < iterations; ++i) {
       const alpha = Math.pow(0.99, i);
@@ -6454,45 +9457,45 @@ function Sankey() {
     for (let i = 1, n = columns.length; i < n; ++i) {
       const column = columns[i];
       for (const target of column) {
-        let y = 0;
+        let y2 = 0;
         let w = 0;
         for (const { source, value: value2 } of target.targetLinks) {
           let v = value2 * (target.layer - source.layer);
-          y += targetTop(source, target) * v;
+          y2 += targetTop(source, target) * v;
           w += v;
         }
         if (!(w > 0)) continue;
-        let dy2 = (y / w - target.y0) * alpha;
+        let dy2 = (y2 / w - target.y0) * alpha;
         target.y0 += dy2;
         target.y1 += dy2;
         reorderNodeLinks(target);
       }
       if (sort === void 0) column.sort(ascendingBreadth);
-      resolveCollisions(column, beta);
+      resolveCollisions6(column, beta);
     }
   }
   function relaxRightToLeft(columns, alpha, beta) {
     for (let n = columns.length, i = n - 2; i >= 0; --i) {
       const column = columns[i];
       for (const source of column) {
-        let y = 0;
+        let y2 = 0;
         let w = 0;
         for (const { target, value: value2 } of source.sourceLinks) {
           let v = value2 * (target.layer - source.layer);
-          y += sourceTop(source, target) * v;
+          y2 += sourceTop(source, target) * v;
           w += v;
         }
         if (!(w > 0)) continue;
-        let dy2 = (y / w - source.y0) * alpha;
+        let dy2 = (y2 / w - source.y0) * alpha;
         source.y0 += dy2;
         source.y1 += dy2;
         reorderNodeLinks(source);
       }
       if (sort === void 0) column.sort(ascendingBreadth);
-      resolveCollisions(column, beta);
+      resolveCollisions6(column, beta);
     }
   }
-  function resolveCollisions(nodes2, alpha) {
+  function resolveCollisions6(nodes2, alpha) {
     const i = nodes2.length >> 1;
     const subject = nodes2[i];
     resolveCollisionsBottomToTop(nodes2, subject.y0 - py, i - 1, alpha);
@@ -6500,20 +9503,20 @@ function Sankey() {
     resolveCollisionsBottomToTop(nodes2, y1, nodes2.length - 1, alpha);
     resolveCollisionsTopToBottom(nodes2, y0, 0, alpha);
   }
-  function resolveCollisionsTopToBottom(nodes2, y, i, alpha) {
+  function resolveCollisionsTopToBottom(nodes2, y2, i, alpha) {
     for (; i < nodes2.length; ++i) {
       const node = nodes2[i];
-      const dy2 = (y - node.y0) * alpha;
+      const dy2 = (y2 - node.y0) * alpha;
       if (dy2 > 1e-6) node.y0 += dy2, node.y1 += dy2;
-      y = node.y1 + py;
+      y2 = node.y1 + py;
     }
   }
-  function resolveCollisionsBottomToTop(nodes2, y, i, alpha) {
+  function resolveCollisionsBottomToTop(nodes2, y2, i, alpha) {
     for (; i >= 0; --i) {
       const node = nodes2[i];
-      const dy2 = (node.y1 - y) * alpha;
+      const dy2 = (node.y1 - y2) * alpha;
       if (dy2 > 1e-6) node.y0 -= dy2, node.y1 -= dy2;
-      y = node.y0 - py;
+      y2 = node.y0 - py;
     }
   }
   function reorderNodeLinks({ sourceLinks, targetLinks }) {
@@ -6535,28 +9538,28 @@ function Sankey() {
     }
   }
   function targetTop(source, target) {
-    let y = source.y0 - (source.sourceLinks.length - 1) * py / 2;
+    let y2 = source.y0 - (source.sourceLinks.length - 1) * py / 2;
     for (const { target: node, width } of source.sourceLinks) {
       if (node === target) break;
-      y += width + py;
+      y2 += width + py;
     }
     for (const { source: node, width } of target.targetLinks) {
       if (node === source) break;
-      y -= width;
+      y2 -= width;
     }
-    return y;
+    return y2;
   }
   function sourceTop(source, target) {
-    let y = target.y0 - (target.targetLinks.length - 1) * py / 2;
+    let y2 = target.y0 - (target.targetLinks.length - 1) * py / 2;
     for (const { source: node, width } of target.targetLinks) {
       if (node === source) break;
-      y += width + py;
+      y2 += width + py;
     }
     for (const { target: node, width } of source.sourceLinks) {
       if (node === target) break;
-      y -= width;
+      y2 -= width;
     }
-    return y;
+    return y2;
   }
   return sankey;
 }
@@ -6797,12 +9800,12 @@ function compileSankey(spec, options) {
     theme,
     fullArea
   );
-  const legendGap = legend.entries.length > 0 ? 4 : 0;
+  const legendGap2 = legend.entries.length > 0 ? 4 : 0;
   const area = {
     x: fullArea.x,
-    y: fullArea.y + legend.bounds.height + legendGap,
+    y: fullArea.y + legend.bounds.height + legendGap2,
     width: fullArea.width,
-    height: fullArea.height - legend.bounds.height - legendGap
+    height: fullArea.height - legend.bounds.height - legendGap2
   };
   if (area.height <= 0) {
     return emptyLayout(area, chrome, theme, options, watermark);
@@ -6824,7 +9827,7 @@ function compileSankey(spec, options) {
     sankeySpec.nodeSort
   );
   const nodeLabelAlign = sankeySpec.nodeLabelAlign ?? "auto";
-  const maxDepthFirst = nodes.reduce((max3, n) => Math.max(max3, n.depth ?? 0), 0);
+  const maxDepthFirst = nodes.reduce((max4, n) => Math.max(max4, n.depth ?? 0), 0);
   const rightEdge = area.x + area.width;
   let maxOverflow = 0;
   for (const node of nodes) {
@@ -6833,7 +9836,7 @@ function compileSankey(spec, options) {
     if (labelsLeft) continue;
     const labelX = (node.x1 ?? nodeWidth) + LABEL_GAP;
     const labelText = node.label ?? node.id;
-    const labelWidth = estimateTextWidth6(labelText, labelFontSize, labelFontWeight);
+    const labelWidth = estimateTextWidth11(labelText, labelFontSize, labelFontWeight);
     const overflow = labelX + labelWidth - rightEdge;
     if (overflow > maxOverflow) maxOverflow = overflow;
   }
@@ -6866,7 +9869,7 @@ function compileSankey(spec, options) {
     sourceField,
     targetField
   );
-  const maxDepth = nodes.reduce((max3, n) => Math.max(max3, n.depth ?? 0), 0);
+  const maxDepth = nodes.reduce((max4, n) => Math.max(max4, n.depth ?? 0), 0);
   const nodeMarks = nodes.map((node) => {
     const fill = nodeColorMap.get(node.id) ?? theme.colors.categorical[0];
     const depth = node.depth ?? 0;
@@ -6960,7 +9963,8 @@ function compileSankey(spec, options) {
       height: options.height
     },
     animation: resolvedAnimation,
-    watermark
+    watermark,
+    measureText: options.measureText
   };
 }
 function buildSankeyLegend(nodeColorMap, colorField, data, sourceField, targetField, theme, area) {
@@ -7022,10 +10026,10 @@ function buildSankeyLegend(nodeColorMap, colorField, data, sourceField, targetFi
 }
 function formatFlowValue(value2, valueFormat) {
   if (valueFormat) {
-    const fmt = buildD3Formatter2(valueFormat);
+    const fmt = buildD3Formatter5(valueFormat);
     if (fmt) return fmt(value2);
   }
-  return formatNumber2(value2);
+  return formatNumber3(value2);
 }
 function buildTooltipDescriptors(nodes, links, valueFormat) {
   const descriptors = /* @__PURE__ */ new Map();
@@ -7094,7 +10098,7 @@ function emptyLayout(area, chrome, theme, options, watermark) {
 }
 
 // src/tables/compile-table.ts
-import { computeChrome as computeChrome4, estimateTextWidth as estimateTextWidth7 } from "@opendata-ai/openchart-core";
+import { computeChrome as computeChrome4, estimateTextWidth as estimateTextWidth12 } from "@opendata-ai/openchart-core";
 
 // src/tables/bar-column.ts
 var NEGATIVE_BAR_COLOR = "#c44e52";
@@ -7132,24 +10136,24 @@ function computeBarCell(value2, config, columnMax, columnMin, theme, _darkMode)
   };
 }
 function computeColumnMax(data, key) {
-  let max3 = 0;
+  let max4 = 0;
   for (const row of data) {
     const val = row[key];
-    if (typeof val === "number" && Number.isFinite(val) && val > max3) {
-      max3 = val;
+    if (typeof val === "number" && Number.isFinite(val) && val > max4) {
+      max4 = val;
     }
   }
-  return max3;
+  return max4;
 }
 function computeColumnMin(data, key) {
-  let min3 = 0;
+  let min4 = 0;
   for (const row of data) {
     const val = row[key];
-    if (typeof val === "number" && Number.isFinite(val) && val < min3) {
-      min3 = val;
+    if (typeof val === "number" && Number.isFinite(val) && val < min4) {
+      min4 = val;
     }
   }
-  return min3;
+  return min4;
 }
 
 // src/tables/category-colors.ts
@@ -7211,7 +10215,7 @@ function computeCategoryColors(data, column, theme, darkMode) {
 }
 
 // src/tables/format-cells.ts
-import { buildD3Formatter as buildD3Formatter3, formatDate as formatDate2, formatNumber as formatNumber3 } from "@opendata-ai/openchart-core";
+import { buildD3Formatter as buildD3Formatter6, formatDate as formatDate2, formatNumber as formatNumber4 } from "@opendata-ai/openchart-core";
 function isNumericValue(value2) {
   if (typeof value2 === "number") return Number.isFinite(value2);
   return false;
@@ -7230,7 +10234,7 @@ function formatCell(value2, column) {
     };
   }
   if (column.format && isNumericValue(value2)) {
-    const formatter = buildD3Formatter3(column.format);
+    const formatter = buildD3Formatter6(column.format);
     if (formatter) {
       return {
         value: value2,
@@ -7242,7 +10246,7 @@ function formatCell(value2, column) {
   if (isNumericValue(value2)) {
     return {
       value: value2,
-      formattedValue: formatNumber3(value2),
+      formattedValue: formatNumber4(value2),
       style
     };
   }
@@ -7262,13 +10266,13 @@ function formatCell(value2, column) {
 function formatValueForSearch(value2, column) {
   if (value2 == null) return "";
   if (column.format && isNumericValue(value2)) {
-    const formatter = buildD3Formatter3(column.format);
+    const formatter = buildD3Formatter6(column.format);
     if (formatter) {
       return formatter(value2);
     }
   }
   if (isNumericValue(value2)) {
-    return formatNumber3(value2);
+    return formatNumber4(value2);
   }
   return String(value2);
 }
@@ -7315,13 +10319,13 @@ function computeHeatmapColors(data, column, theme, darkMode) {
   if (config.domain) {
     domain = config.domain;
   } else {
-    let min3 = Infinity;
-    let max3 = -Infinity;
+    let min4 = Infinity;
+    let max4 = -Infinity;
     for (const { value: value2 } of numericValues) {
-      if (value2 < min3) min3 = value2;
-      if (value2 > max3) max3 = value2;
+      if (value2 < min4) min4 = value2;
+      if (value2 > max4) max4 = value2;
     }
-    domain = [min3, max3];
+    domain = [min4, max4];
   }
   let stops = resolvePalette(config.palette, theme);
   if (darkMode) {
@@ -7437,14 +10441,14 @@ function computeSparkline(values, config, theme, _darkMode) {
   if (values.length === 0) return null;
   const type = config.type ?? "line";
   const color2 = config.color ?? theme.colors.categorical[0];
-  let min3 = Infinity;
-  let max3 = -Infinity;
+  let min4 = Infinity;
+  let max4 = -Infinity;
   for (const v of values) {
-    if (v < min3) min3 = v;
-    if (v > max3) max3 = v;
+    if (v < min4) min4 = v;
+    if (v > max4) max4 = v;
   }
-  const range2 = max3 - min3;
-  const normalize2 = (v) => range2 === 0 ? 0.5 : (v - min3) / range2;
+  const range2 = max4 - min4;
+  const normalize2 = (v) => range2 === 0 ? 0.5 : (v - min4) / range2;
   const startValue = values[0];
   const endValue = values[values.length - 1];
   if (type === "line") {
@@ -7509,13 +10513,13 @@ function estimateColumnWidth(col, data, fontSize) {
   if (col.image) return (col.image.width ?? 24) + PADDING;
   if (col.flag) return 60;
   const label = col.label ?? col.key;
-  const headerWidth = estimateTextWidth7(label, fontSize, 600) + PADDING;
+  const headerWidth = estimateTextWidth12(label, fontSize, 600) + PADDING;
   const sampleSize = Math.min(100, data.length);
   let maxDataWidth = 0;
   for (let i = 0; i < sampleSize; i++) {
     const val = data[i][col.key];
     const text = val == null ? "" : String(val);
-    const width = estimateTextWidth7(text, fontSize, 400) + PADDING;
+    const width = estimateTextWidth12(text, fontSize, 400) + PADDING;
     if (width > maxDataWidth) maxDataWidth = width;
   }
   return Math.max(MIN_WIDTH, headerWidth, maxDataWidth);
@@ -7743,8 +10747,8 @@ function compileTableLayout(spec, options, theme) {
 import {
   buildTemporalFormatter as buildTemporalFormatter2,
   formatDate as formatDate3,
-  formatNumber as formatNumber4,
-  getRepresentativeColor
+  formatNumber as formatNumber5,
+  getRepresentativeColor as getRepresentativeColor10
 } from "@opendata-ai/openchart-core";
 function formatValue(value2, fieldType, format2) {
   if (value2 == null) return "";
@@ -7758,10 +10762,10 @@ function formatValue(value2, fieldType, format2) {
       try {
         return format(format2)(value2);
       } catch {
-        return formatNumber4(value2);
+        return formatNumber5(value2);
       }
     }
-    return formatNumber4(value2);
+    return formatNumber5(value2);
   }
   return String(value2);
 }
@@ -7860,12 +10864,12 @@ function tooltipsForLine(mark, encoding, _markIndex) {
 }
 function tooltipsForPoint(mark, encoding, markIndex) {
   const title = getTooltipTitle(mark.data, encoding);
-  const fields = buildFields(mark.data, encoding, getRepresentativeColor(mark.fill));
+  const fields = buildFields(mark.data, encoding, getRepresentativeColor10(mark.fill));
   return [[`point-${markIndex}`, { title, fields }]];
 }
 function tooltipsForRect(mark, encoding, markIndex) {
   const title = getTooltipTitle(mark.data, encoding);
-  const fields = buildFields(mark.data, encoding, getRepresentativeColor(mark.fill));
+  const fields = buildFields(mark.data, encoding, getRepresentativeColor10(mark.fill));
   return [[`rect-${markIndex}`, { title, fields }]];
 }
 function tooltipsForArc(mark, encoding, markIndex) {
@@ -7878,14 +10882,14 @@ function tooltipsForArc(mark, encoding, markIndex) {
       fields.push({
         label: categoryName,
         value: formatValue(row[encoding.y.field], encoding.y.type, resolveFormat(encoding.y)),
-        color: getRepresentativeColor(mark.fill)
+        color: getRepresentativeColor10(mark.fill)
       });
     }
   } else if (encoding.y) {
     fields.push({
       label: resolveLabel(encoding.y),
       value: formatValue(row[encoding.y.field], encoding.y.type, resolveFormat(encoding.y)),
-      color: getRepresentativeColor(mark.fill)
+      color: getRepresentativeColor10(mark.fill)
     });
   }
   const title = colorEnc ? String(row[colorEnc.field] ?? "") : void 0;
@@ -7896,7 +10900,7 @@ function tooltipsForArea(mark, encoding, _markIndex) {
     for (const dp of mark.dataPoints) {
       dp.tooltip = {
         title: getTooltipTitle(dp.datum, encoding),
-        fields: buildFields(dp.datum, encoding, getRepresentativeColor(mark.fill))
+        fields: buildFields(dp.datum, encoding, getRepresentativeColor10(mark.fill))
       };
     }
   }
@@ -8046,16 +11050,16 @@ function runBin(data, transform) {
   const field = transform.field;
   let extent2 = params.extent;
   if (!extent2) {
-    let min3 = Infinity;
-    let max3 = -Infinity;
+    let min4 = Infinity;
+    let max4 = -Infinity;
     for (const row of data) {
       const v = Number(row[field]);
       if (Number.isFinite(v)) {
-        if (v < min3) min3 = v;
-        if (v > max3) max3 = v;
+        if (v < min4) min4 = v;
+        if (v > max4) max4 = v;
       }
     }
-    extent2 = [min3 === Infinity ? 0 : min3, max3 === -Infinity ? 0 : max3];
+    extent2 = [min4 === Infinity ? 0 : min4, max4 === -Infinity ? 0 : max4];
   }
   const step = params.step ?? computeStep(extent2, maxbins, nice2);
   const [startAs, endAs] = Array.isArray(transform.as) ? transform.as : [transform.as, void 0];
@@ -8351,13 +11355,14 @@ function compileChart(spec, options) {
   const chartArea = dims.chartArea;
   const legendArea = { ...chartArea };
   if (legendLayout.entries.length > 0) {
+    const gap = legendGap(options.width);
     switch (legendLayout.position) {
       case "top":
-        legendArea.y -= legendLayout.bounds.height + 4;
-        legendArea.height += legendLayout.bounds.height + 4;
+        legendArea.y -= legendLayout.bounds.height + gap;
+        legendArea.height += legendLayout.bounds.height + gap;
         break;
       case "bottom":
-        legendArea.height += legendLayout.bounds.height + 4;
+        legendArea.height += legendLayout.bounds.height + gap;
         break;
       case "right":
       case "bottom-right":