@opendata-ai/openchart-engine 2.6.0 → 2.8.0

package/dist/index.js

@@ -26,9 +26,9 @@ function resolvePosition(value, scale) {
   const s = scale.scale;
   const type = scale.type;
   if (type === "time") {
-    const date = new Date(String(value));
-    if (Number.isNaN(date.getTime())) return null;
-    return s(date);
+    const date2 = new Date(String(value));
+    if (Number.isNaN(date2.getTime())) return null;
+    return s(date2);
   }
   if (type === "linear" || type === "log") {
     const num = typeof value === "number" ? value : Number(value);
@@ -61,11 +61,11 @@ function makeAnnotationLabelStyle(fontSize, fontWeight, fill, isDark) {
 function computeTextBounds(labelX, labelY, text, fontSize, fontWeight) {
   const lines = text.split("\n");
   const isMultiLine = lines.length > 1;
-  const maxWidth = Math.max(...lines.map((line3) => estimateTextWidth(line3, fontSize, fontWeight)));
+  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
@@ -181,25 +181,25 @@ function resolveTextAnnotation(annotation, scales, chartArea, isDark) {
   };
 }
 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 ?? "left";
@@ -213,11 +213,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
     };
@@ -410,9 +410,9 @@ var DEFAULT_COLOR = "#1b7fa3";
 function scaleValue(scale, scaleType, value) {
   if (value == null) return null;
   if (scaleType === "time") {
-    const date = value instanceof Date ? value : new Date(String(value));
-    if (Number.isNaN(date.getTime())) return null;
-    return scale(date);
+    const date2 = value instanceof Date ? value : new Date(String(value));
+    if (Number.isNaN(date2.getTime())) return null;
+    return scale(date2);
   }
   if (scaleType === "point" || scaleType === "band" || scaleType === "ordinal") {
     const result = scale(String(value));
@@ -536,7 +536,7 @@ function computeStackedBars(data, valueField, categoryField, colorField, xScale,
       const groupKey = String(row[colorField] ?? "");
       const value = Number(row[valueField] ?? 0);
       if (!Number.isFinite(value) || value <= 0) continue;
-      const color = getColor(scales, groupKey);
+      const color2 = getColor(scales, groupKey);
       const xLeft = xScale(cumulativeValue);
       const xRight = xScale(cumulativeValue + value);
       const barWidth = Math.max(Math.abs(xRight - xLeft), MIN_BAR_WIDTH);
@@ -549,7 +549,7 @@ function computeStackedBars(data, valueField, categoryField, colorField, xScale,
         y: bandY,
         width: barWidth,
         height: bandwidth,
-        fill: color,
+        fill: color2,
         cornerRadius: 0,
         data: row,
         aria
@@ -567,7 +567,7 @@ function computeSimpleBars(data, valueField, categoryField, xScale, yScale, band
     if (!Number.isFinite(value)) continue;
     const bandY = yScale(category);
     if (bandY === void 0) continue;
-    const color = sequentialColor ? getSequentialColor(scales, value) : getColor(scales, "__default__");
+    const color2 = sequentialColor ? getSequentialColor(scales, value) : getColor(scales, "__default__");
     const xPos = value >= 0 ? baseline : xScale(value);
     const barWidth = Math.max(Math.abs(xScale(value) - baseline), MIN_BAR_WIDTH);
     const aria = {
@@ -579,7 +579,7 @@ function computeSimpleBars(data, valueField, categoryField, xScale, yScale, band
       y: bandY,
       width: barWidth,
       height: bandwidth,
-      fill: color,
+      fill: color2,
       cornerRadius: 2,
       data: row,
       aria
@@ -589,8 +589,11 @@ function computeSimpleBars(data, valueField, categoryField, xScale, yScale, band
 }
 
 // src/charts/bar/labels.ts
-import { estimateTextWidth as estimateTextWidth2, resolveCollisions } from "@opendata-ai/openchart-core";
-import { format as d3Format } from "d3-format";
+import {
+  buildD3Formatter,
+  estimateTextWidth as estimateTextWidth2,
+  resolveCollisions
+} from "@opendata-ai/openchart-core";
 var LABEL_FONT_SIZE = 11;
 var LABEL_FONT_WEIGHT = 600;
 var LABEL_PADDING = 6;
@@ -599,22 +602,7 @@ function computeBarLabels(marks, _chartArea, density = "auto", labelFormat) {
   if (density === "none") return [];
   const targetMarks = density === "endpoints" && marks.length > 1 ? [marks[0], marks[marks.length - 1]] : marks;
   const candidates = [];
-  let formatter = null;
-  if (labelFormat) {
-    try {
-      formatter = d3Format(labelFormat);
-    } catch {
-      const suffixMatch = labelFormat.match(/^(.+[a-z])([^a-z]+)$/i);
-      if (suffixMatch) {
-        try {
-          const d3Fmt = d3Format(suffixMatch[1]);
-          const suffix = suffixMatch[2];
-          formatter = (v) => d3Fmt(v) + suffix;
-        } catch {
-        }
-      }
-    }
-  }
+  const formatter = buildD3Formatter(labelFormat);
   for (const mark of targetMarks) {
     const ariaLabel = mark.aria.label;
     const lastColon = ariaLabel.lastIndexOf(":");
@@ -758,20 +746,20 @@ function computeSimpleColumns(data, categoryField, valueField, xScale, yScale, b
     if (!Number.isFinite(value)) continue;
     const bandX = xScale(category);
     if (bandX === void 0) continue;
-    const color = sequentialColor ? getSequentialColor(scales, value) : getColor(scales, "__default__");
+    const color2 = sequentialColor ? getSequentialColor(scales, value) : getColor(scales, "__default__");
     const yPos = yScale(value);
     const columnHeight = Math.max(Math.abs(baseline - yPos), MIN_COLUMN_HEIGHT);
-    const y = value >= 0 ? yPos : baseline;
+    const y2 = value >= 0 ? yPos : baseline;
     const aria = {
       label: `${category}: ${formatColumnValue(value)}`
     };
     marks.push({
       type: "rect",
       x: bandX,
-      y,
+      y: y2,
       width: bandwidth,
       height: columnHeight,
-      fill: color,
+      fill: color2,
       cornerRadius: 2,
       data: row,
       aria
@@ -788,20 +776,20 @@ function computeColoredColumns(data, categoryField, valueField, colorField, xSca
     const bandX = xScale(category);
     if (bandX === void 0) continue;
     const groupKey = String(row[colorField] ?? "");
-    const color = getColor(scales, groupKey);
+    const color2 = getColor(scales, groupKey);
     const yPos = yScale(value);
     const columnHeight = Math.max(Math.abs(baseline - yPos), MIN_COLUMN_HEIGHT);
-    const y = value >= 0 ? yPos : baseline;
+    const y2 = value >= 0 ? yPos : baseline;
     const aria = {
       label: `${category}, ${groupKey}: ${formatColumnValue(value)}`
     };
     marks.push({
       type: "rect",
       x: bandX,
-      y,
+      y: y2,
       width: bandwidth,
       height: columnHeight,
-      fill: color,
+      fill: color2,
       cornerRadius: 2,
       data: row,
       aria
@@ -820,7 +808,7 @@ function computeStackedColumns(data, categoryField, valueField, colorField, xSca
       const groupKey = String(row[colorField] ?? "");
       const value = Number(row[valueField] ?? 0);
       if (!Number.isFinite(value) || value <= 0) continue;
-      const color = getColor(scales, groupKey);
+      const color2 = getColor(scales, groupKey);
       const yTop = yScale(cumulativeValue + value);
       const yBottom = yScale(cumulativeValue);
       const columnHeight = Math.max(Math.abs(yBottom - yTop), MIN_COLUMN_HEIGHT);
@@ -833,7 +821,7 @@ function computeStackedColumns(data, categoryField, valueField, colorField, xSca
         y: yTop,
         width: bandwidth,
         height: columnHeight,
-        fill: color,
+        fill: color2,
         cornerRadius: 0,
         data: row,
         aria
@@ -845,24 +833,34 @@ function computeStackedColumns(data, categoryField, valueField, colorField, xSca
 }
 
 // src/charts/column/labels.ts
-import { estimateTextWidth as estimateTextWidth3, resolveCollisions as resolveCollisions2 } from "@opendata-ai/openchart-core";
+import {
+  buildD3Formatter as buildD3Formatter2,
+  estimateTextWidth as estimateTextWidth3,
+  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") {
+function computeColumnLabels(marks, _chartArea, density = "auto", labelFormat) {
   if (density === "none") return [];
   const targetMarks = density === "endpoints" && marks.length > 1 ? [marks[0], marks[marks.length - 1]] : marks;
+  const formatter = buildD3Formatter2(labelFormat);
   const candidates = [];
   for (const mark of targetMarks) {
     const ariaLabel = mark.aria.label;
     const lastColon = ariaLabel.lastIndexOf(":");
-    const valuePart = lastColon >= 0 ? ariaLabel.slice(lastColon + 1).trim() : "";
-    if (!valuePart) continue;
+    const rawValue = lastColon >= 0 ? ariaLabel.slice(lastColon + 1).trim() : "";
+    if (!rawValue) continue;
+    let valuePart = rawValue;
+    if (formatter) {
+      const num = Number(rawValue.replace(/[^0-9.-]/g, ""));
+      if (!Number.isNaN(num)) valuePart = formatter(num);
+    }
     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 - textWidth / 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,
@@ -898,7 +896,7 @@ function computeColumnLabels(marks, _chartArea, density = "auto") {
 // src/charts/column/index.ts
 var columnRenderer = (spec, scales, chartArea, strategy, _theme) => {
   const marks = computeColumnMarks(spec, scales, chartArea, strategy);
-  const labels = computeColumnLabels(marks, chartArea, spec.labels.density);
+  const labels = computeColumnLabels(marks, chartArea, spec.labels.density, spec.labels.format);
   for (let i = 0; i < marks.length && i < labels.length; i++) {
     marks[i].label = labels[i];
   }
@@ -985,7 +983,7 @@ function computeDumbbellMarks(data, valueField, categoryField, colorField, xScal
       if (!Number.isFinite(value)) continue;
       const cx = xScale(value);
       const colorCategory = String(row[colorField] ?? "");
-      const color = getColor(scales, colorCategory);
+      const color2 = getColor(scales, colorCategory);
       const dotAria = {
         label: `${category}, ${colorCategory}: ${value}`
       };
@@ -994,7 +992,7 @@ function computeDumbbellMarks(data, valueField, categoryField, colorField, xScal
         cx,
         cy,
         r: DOT_RADIUS,
-        fill: color,
+        fill: color2,
         stroke: "#ffffff",
         strokeWidth: 2,
         data: row,
@@ -1014,7 +1012,7 @@ function computeLollipopMarks(data, valueField, categoryField, xScale, yScale, b
     if (bandY === void 0) continue;
     const cx = xScale(value);
     const cy = bandY + bandwidth / 2;
-    const color = getColor(scales, "__default__");
+    const color2 = getColor(scales, "__default__");
     const stemX = Math.min(baseline, cx);
     const stemWidth = Math.abs(cx - baseline);
     if (stemWidth > 0) {
@@ -1040,7 +1038,7 @@ function computeLollipopMarks(data, valueField, categoryField, xScale, yScale, b
       cx,
       cy,
       r: DOT_RADIUS,
-      fill: color,
+      fill: color2,
       stroke: "#ffffff",
       strokeWidth: 2,
       data: row,
@@ -1112,8 +1110,644 @@ var dotRenderer = (spec, scales, chartArea, strategy, _theme) => {
   return marks;
 };
 
+// ../../node_modules/.bun/d3-shape@3.2.0/node_modules/d3-shape/src/constant.js
+function constant_default(x2) {
+  return function constant() {
+    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 value = 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, sum = 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] = +value(data[i], i, data)) > 0) {
+        sum += 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 = sum ? (da - n * pa) / sum : 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 ? (value = typeof _ === "function" ? _ : constant_default(+_), pie) : value;
+  };
+  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/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 point(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:
+        point(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;
+        point(this, slope2(this, t12 = slope3(this, x2, y2)), t12);
+        break;
+      default:
+        point(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/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, value = 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, +value(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 ? (value = typeof _ === "function" ? _ : constant_default(+_), stack) : value;
+  };
+  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;
+}
+
 // src/charts/line/area.ts
-import { area, curveMonotoneX, line, stack, stackOffsetNone, stackOrderNone } from "d3-shape";
 var DEFAULT_FILL_OPACITY = 0.15;
 function computeSingleArea(spec, scales, _chartArea) {
   const encoding = spec.encoding;
@@ -1140,7 +1774,7 @@ function computeSingleArea(spec, scales, _chartArea) {
   }
   const marks = [];
   for (const [seriesKey, rows] of groups) {
-    const color = getColor(scales, seriesKey);
+    const color2 = getColor(scales, seriesKey);
     const sortedRows = sortByField(rows, xChannel.field);
     const validPoints = [];
     for (const row of sortedRows) {
@@ -1155,9 +1789,9 @@ function computeSingleArea(spec, scales, _chartArea) {
       });
     }
     if (validPoints.length === 0) continue;
-    const areaGenerator = area().x((d) => d.x).y0((d) => d.yBottom).y1((d) => d.yTop).curve(curveMonotoneX);
+    const areaGenerator = area_default().x((d) => d.x).y0((d) => d.yBottom).y1((d) => d.yTop).curve(monotoneX);
     const pathStr = areaGenerator(validPoints) ?? "";
-    const topLineGenerator = line().x((d) => d.x).y((d) => d.yTop).curve(curveMonotoneX);
+    const topLineGenerator = line_default().x((d) => d.x).y((d) => d.yTop).curve(monotoneX);
     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 }));
@@ -1169,9 +1803,9 @@ function computeSingleArea(spec, scales, _chartArea) {
       bottomPoints,
       path: pathStr,
       topPath: topPathStr,
-      fill: color,
+      fill: color2,
       fillOpacity: DEFAULT_FILL_OPACITY,
-      stroke: color,
+      stroke: color2,
       strokeWidth: 2,
       seriesKey: seriesKey === "__default__" ? void 0 : seriesKey,
       data: validPoints.map((p) => p.row),
@@ -1222,13 +1856,13 @@ function computeStackedArea(spec, scales, chartArea) {
     }
     return pivot;
   });
-  const stackGenerator = stack().keys(keys).order(stackOrderNone).offset(stackOffsetNone);
+  const stackGenerator = stack_default().keys(keys).order(none_default2).offset(none_default);
   const stackedData = stackGenerator(pivotData);
   const yScale = scales.y.scale;
   const marks = [];
   for (const layer of stackedData) {
     const seriesKey = layer.key;
-    const color = getColor(scales, seriesKey);
+    const color2 = getColor(scales, seriesKey);
     const validPoints = [];
     for (const d of layer) {
       const xVal = scaleValue(scales.x.scale, scales.x.type, d.data.__x__);
@@ -1238,9 +1872,9 @@ function computeStackedArea(spec, scales, chartArea) {
       validPoints.push({ x: xVal, yTop, yBottom });
     }
     if (validPoints.length === 0) continue;
-    const areaGenerator = area().x((p) => p.x).y0((p) => p.yBottom).y1((p) => p.yTop).curve(curveMonotoneX);
+    const areaGenerator = area_default().x((p) => p.x).y0((p) => p.yBottom).y1((p) => p.yTop).curve(monotoneX);
     const pathStr = areaGenerator(validPoints) ?? "";
-    const topLineGenerator = line().x((p) => p.x).y((p) => p.yTop).curve(curveMonotoneX);
+    const topLineGenerator = line_default().x((p) => p.x).y((p) => p.yTop).curve(monotoneX);
     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 }));
@@ -1253,10 +1887,10 @@ function computeStackedArea(spec, scales, chartArea) {
       bottomPoints,
       path: pathStr,
       topPath: topPathStr,
-      fill: color,
+      fill: color2,
       fillOpacity: 0.7,
       // Higher opacity for stacked so layers are visible
-      stroke: color,
+      stroke: color2,
       strokeWidth: 1,
       seriesKey,
       data: layer.map((d) => {
@@ -1278,7 +1912,6 @@ function computeAreaMarks(spec, scales, chartArea) {
 }
 
 // src/charts/line/compute.ts
-import { curveMonotoneX as curveMonotoneX2, line as line2 } from "d3-shape";
 var DEFAULT_STROKE_WIDTH = 2.5;
 var DEFAULT_POINT_RADIUS = 3;
 function computeLineMarks(spec, scales, _chartArea, _strategy) {
@@ -1292,7 +1925,7 @@ function computeLineMarks(spec, scales, _chartArea, _strategy) {
   const groups = groupByField(spec.data, colorField);
   const marks = [];
   for (const [seriesKey, rows] of groups) {
-    const color = getColor(scales, seriesKey);
+    const color2 = getColor(scales, seriesKey);
     const sortedRows = sortByField(rows, xChannel.field);
     const pointsWithData = [];
     const segments = [];
@@ -1307,14 +1940,14 @@ function computeLineMarks(spec, scales, _chartArea, _strategy) {
         }
         continue;
       }
-      const point = { x: xVal, y: yVal };
-      currentSegment.push(point);
-      pointsWithData.push({ ...point, row });
+      const point3 = { x: xVal, y: yVal };
+      currentSegment.push(point3);
+      pointsWithData.push({ ...point3, row });
     }
     if (currentSegment.length > 0) {
       segments.push(currentSegment);
     }
-    const lineGenerator = line2().x((d) => d.x).y((d) => d.y).curve(curveMonotoneX2);
+    const lineGenerator = line_default().x((d) => d.x).y((d) => d.y).curve(monotoneX);
     const allPoints = [];
     const pathParts = [];
     for (const segment of segments) {
@@ -1340,7 +1973,7 @@ function computeLineMarks(spec, scales, _chartArea, _strategy) {
       type: "line",
       points: allPoints,
       path: combinedPath,
-      stroke: color,
+      stroke: color2,
       strokeWidth: styleOverride?.strokeWidth ?? DEFAULT_STROKE_WIDTH,
       strokeDasharray,
       opacity: styleOverride?.opacity,
@@ -1357,7 +1990,7 @@ function computeLineMarks(spec, scales, _chartArea, _strategy) {
         cx: p.x,
         cy: p.y,
         r: showPoints ? DEFAULT_POINT_RADIUS : 0,
-        fill: color,
+        fill: color2,
         stroke: showPoints ? "#ffffff" : "transparent",
         strokeWidth: showPoints ? 1.5 : 0,
         fillOpacity: 0,
@@ -1463,7 +2096,6 @@ var areaRenderer = (spec, scales, chartArea, strategy, _theme) => {
 };
 
 // src/charts/pie/compute.ts
-import { arc as d3Arc, pie as d3Pie } from "d3-shape";
 var SMALL_SLICE_THRESHOLD = 0.03;
 var DEFAULT_PALETTE = [
   "#1b7fa3",
@@ -1482,11 +2114,11 @@ function groupSmallSlices(slices, threshold) {
   if (total === 0) return slices;
   const big = [];
   let otherValue = 0;
-  for (const slice of slices) {
-    if (slice.value / total < threshold) {
-      otherValue += slice.value;
+  for (const slice2 of slices) {
+    if (slice2.value / total < threshold) {
+      otherValue += slice2.value;
     } else {
-      big.push(slice);
+      big.push(slice2);
     }
   }
   if (otherValue > 0) {
@@ -1538,160 +2170,2637 @@ function computePieMarks(spec, scales, chartArea, _strategy, isDonut = false) {
   if (slices.length === 0) return [];
   slices.sort((a, b) => b.value - a.value);
   slices = groupSmallSlices(slices, SMALL_SLICE_THRESHOLD);
-  const pieGenerator = d3Pie().value((d) => d.value).sort(null).padAngle(0.01);
+  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 = d3Arc().innerRadius(innerRadius).outerRadius(outerRadius);
+  const arcGenerator = arc_default().innerRadius(innerRadius).outerRadius(outerRadius);
   const marks = [];
   const center = { x: centerX, y: centerY };
   const total = slices.reduce((sum, s) => sum + s.value, 0);
   for (let i = 0; i < arcs.length; i++) {
     const arcDatum = arcs[i];
-    const slice = arcDatum.data;
-    let color;
+    const slice2 = arcDatum.data;
+    let color2;
     if (scales.color && categoryField) {
       const colorScale = scales.color.scale;
-      color = colorScale(slice.label);
+      color2 = colorScale(slice2.label);
     } else {
-      color = DEFAULT_PALETTE[i % DEFAULT_PALETTE.length];
+      color2 = DEFAULT_PALETTE[i % DEFAULT_PALETTE.length];
     }
-    const path = arcGenerator(arcDatum) ?? "";
+    const path2 = arcGenerator(arcDatum) ?? "";
     const centroidResult = arcGenerator.centroid(arcDatum);
-    const percentage = total > 0 ? (slice.value / total * 100).toFixed(1) : "0";
+    const percentage = total > 0 ? (slice2.value / total * 100).toFixed(1) : "0";
     const aria = {
-      label: `${slice.label}: ${slice.value} (${percentage}%)`
+      label: `${slice2.label}: ${slice2.value} (${percentage}%)`
+    };
+    marks.push({
+      type: "arc",
+      path: path2,
+      centroid: {
+        x: centroidResult[0] + centerX,
+        y: centroidResult[1] + centerY
+      },
+      center,
+      innerRadius,
+      outerRadius,
+      startAngle: arcDatum.startAngle,
+      endAngle: arcDatum.endAngle,
+      fill: color2,
+      stroke: "#ffffff",
+      strokeWidth: 2,
+      data: slice2.originalRow,
+      aria
+    });
+  }
+  return marks;
+}
+
+// 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 [];
+  if (density === "none") return [];
+  const centerX = marks[0].center.x;
+  const centerY = marks[0].center.y;
+  const targetMarks = density === "endpoints" && marks.length > 1 ? [marks[0], marks[marks.length - 1]] : marks;
+  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"
+      }
+    });
+    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 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) {
+  renderers.set(type, renderer);
+}
+function getChartRenderer(type) {
+  return renderers.get(type);
+}
+function clearRenderers() {
+  renderers.clear();
+}
+
+// ../../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;
+}
+
+// ../../node_modules/.bun/d3-array@3.2.4/node_modules/d3-array/src/descending.js
+function descending(a, b) {
+  return a == null || b == null ? NaN : b < a ? -1 : b > a ? 1 : b >= a ? 0 : NaN;
+}
+
+// ../../node_modules/.bun/d3-array@3.2.4/node_modules/d3-array/src/bisector.js
+function bisector(f) {
+  let compare1, compare2, delta;
+  if (f.length !== 2) {
+    compare1 = ascending;
+    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 left(a, x2, lo = 0, hi = a.length) {
+    if (lo < hi) {
+      if (compare1(x2, x2) !== 0) return hi;
+      do {
+        const mid = lo + hi >>> 1;
+        if (compare2(a[mid], x2) < 0) lo = mid + 1;
+        else hi = mid;
+      } while (lo < hi);
+    }
+    return lo;
+  }
+  function right(a, x2, lo = 0, hi = a.length) {
+    if (lo < hi) {
+      if (compare1(x2, x2) !== 0) return hi;
+      do {
+        const mid = lo + hi >>> 1;
+        if (compare2(a[mid], x2) <= 0) lo = mid + 1;
+        else hi = mid;
+      } while (lo < hi);
+    }
+    return lo;
+  }
+  function center(a, x2, lo = 0, hi = a.length) {
+    const i = left(a, x2, lo, hi - 1);
+    return i > lo && delta(a[i - 1], x2) > -delta(a[i], x2) ? i - 1 : i;
+  }
+  return { left, center, right };
+}
+function zero() {
+  return 0;
+}
+
+// ../../node_modules/.bun/d3-array@3.2.4/node_modules/d3-array/src/number.js
+function number(x2) {
+  return x2 === null ? NaN : +x2;
+}
+
+// ../../node_modules/.bun/d3-array@3.2.4/node_modules/d3-array/src/bisect.js
+var ascendingBisect = bisector(ascending);
+var bisectRight = ascendingBisect.right;
+var bisectLeft = ascendingBisect.left;
+var bisectCenter = bisector(number).center;
+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;
+  if (valueof === void 0) {
+    for (const value of values) {
+      if (value != null) {
+        if (min3 === void 0) {
+          if (value >= value) min3 = max3 = value;
+        } else {
+          if (min3 > value) min3 = value;
+          if (max3 < value) max3 = value;
+        }
+      }
+    }
+  } else {
+    let index = -1;
+    for (let value of values) {
+      if ((value = valueof(value, ++index, values)) != null) {
+        if (min3 === void 0) {
+          if (value >= value) min3 = max3 = value;
+        } else {
+          if (min3 > value) min3 = value;
+          if (max3 < value) max3 = value;
+        }
+      }
+    }
+  }
+  return [min3, max3];
+}
+
+// ../../node_modules/.bun/internmap@2.0.3/node_modules/internmap/src/index.js
+var InternMap = class extends Map {
+  constructor(entries, key = keyof) {
+    super();
+    Object.defineProperties(this, { _intern: { value: /* @__PURE__ */ new Map() }, _key: { value: key } });
+    if (entries != null) for (const [key2, value] of entries) this.set(key2, value);
+  }
+  get(key) {
+    return super.get(intern_get(this, key));
+  }
+  has(key) {
+    return super.has(intern_get(this, key));
+  }
+  set(key, value) {
+    return super.set(intern_set(this, key), value);
+  }
+  delete(key) {
+    return super.delete(intern_delete(this, key));
+  }
+};
+function intern_get({ _intern, _key }, value) {
+  const key = _key(value);
+  return _intern.has(key) ? _intern.get(key) : value;
+}
+function intern_set({ _intern, _key }, value) {
+  const key = _key(value);
+  if (_intern.has(key)) return _intern.get(key);
+  _intern.set(key, value);
+  return value;
+}
+function intern_delete({ _intern, _key }, value) {
+  const key = _key(value);
+  if (_intern.has(key)) {
+    value = _intern.get(key);
+    _intern.delete(key);
+  }
+  return value;
+}
+function keyof(value) {
+  return value !== null && typeof value === "object" ? value.valueOf() : value;
+}
+
+// ../../node_modules/.bun/d3-array@3.2.4/node_modules/d3-array/src/ticks.js
+var e10 = Math.sqrt(50);
+var e5 = Math.sqrt(10);
+var e2 = Math.sqrt(2);
+function tickSpec(start, stop, count) {
+  const step = (stop - start) / Math.max(0, count), power = Math.floor(Math.log10(step)), error = step / Math.pow(10, power), factor = error >= e10 ? 10 : error >= e5 ? 5 : error >= e2 ? 2 : 1;
+  let i1, i2, inc;
+  if (power < 0) {
+    inc = Math.pow(10, -power) / factor;
+    i1 = Math.round(start * inc);
+    i2 = Math.round(stop * inc);
+    if (i1 / inc < start) ++i1;
+    if (i2 / inc > stop) --i2;
+    inc = -inc;
+  } else {
+    inc = Math.pow(10, power) * factor;
+    i1 = Math.round(start / inc);
+    i2 = Math.round(stop / inc);
+    if (i1 * inc < start) ++i1;
+    if (i2 * inc > stop) --i2;
+  }
+  if (i2 < i1 && 0.5 <= count && count < 2) return tickSpec(start, stop, count * 2);
+  return [i1, i2, inc];
+}
+function ticks(start, stop, count) {
+  stop = +stop, start = +start, count = +count;
+  if (!(count > 0)) return [];
+  if (start === stop) return [start];
+  const reverse = stop < start, [i1, i2, inc] = reverse ? tickSpec(stop, start, count) : tickSpec(start, stop, count);
+  if (!(i2 >= i1)) return [];
+  const n = i2 - i1 + 1, ticks2 = new Array(n);
+  if (reverse) {
+    if (inc < 0) for (let i = 0; i < n; ++i) ticks2[i] = (i2 - i) / -inc;
+    else for (let i = 0; i < n; ++i) ticks2[i] = (i2 - i) * inc;
+  } else {
+    if (inc < 0) for (let i = 0; i < n; ++i) ticks2[i] = (i1 + i) / -inc;
+    else for (let i = 0; i < n; ++i) ticks2[i] = (i1 + i) * inc;
+  }
+  return ticks2;
+}
+function tickIncrement(start, stop, count) {
+  stop = +stop, start = +start, count = +count;
+  return tickSpec(start, stop, count)[2];
+}
+function tickStep(start, stop, count) {
+  stop = +stop, start = +start, count = +count;
+  const reverse = stop < start, inc = reverse ? tickIncrement(stop, start, count) : tickIncrement(start, stop, count);
+  return (reverse ? -1 : 1) * (inc < 0 ? 1 / -inc : inc);
+}
+
+// ../../node_modules/.bun/d3-array@3.2.4/node_modules/d3-array/src/max.js
+function max2(values, valueof) {
+  let max3;
+  if (valueof === void 0) {
+    for (const value of values) {
+      if (value != null && (max3 < value || max3 === void 0 && value >= value)) {
+        max3 = value;
+      }
+    }
+  } else {
+    let index = -1;
+    for (let value of values) {
+      if ((value = valueof(value, ++index, values)) != null && (max3 < value || max3 === void 0 && value >= value)) {
+        max3 = value;
+      }
+    }
+  }
+  return max3;
+}
+
+// ../../node_modules/.bun/d3-array@3.2.4/node_modules/d3-array/src/min.js
+function min2(values, valueof) {
+  let min3;
+  if (valueof === void 0) {
+    for (const value of values) {
+      if (value != null && (min3 > value || min3 === void 0 && value >= value)) {
+        min3 = value;
+      }
+    }
+  } else {
+    let index = -1;
+    for (let value of values) {
+      if ((value = valueof(value, ++index, values)) != null && (min3 > value || min3 === void 0 && value >= value)) {
+        min3 = value;
+      }
+    }
+  }
+  return min3;
+}
+
+// ../../node_modules/.bun/d3-array@3.2.4/node_modules/d3-array/src/range.js
+function range(start, stop, step) {
+  start = +start, stop = +stop, step = (n = arguments.length) < 2 ? (stop = start, start = 0, 1) : n < 3 ? 1 : +step;
+  var i = -1, n = Math.max(0, Math.ceil((stop - start) / step)) | 0, range2 = new Array(n);
+  while (++i < n) {
+    range2[i] = start + i * step;
+  }
+  return range2;
+}
+
+// ../../node_modules/.bun/d3-scale@4.0.2/node_modules/d3-scale/src/init.js
+function initRange(domain, range2) {
+  switch (arguments.length) {
+    case 0:
+      break;
+    case 1:
+      this.range(domain);
+      break;
+    default:
+      this.range(range2).domain(domain);
+      break;
+  }
+  return this;
+}
+function initInterpolator(domain, interpolator) {
+  switch (arguments.length) {
+    case 0:
+      break;
+    case 1: {
+      if (typeof domain === "function") this.interpolator(domain);
+      else this.range(domain);
+      break;
+    }
+    default: {
+      this.domain(domain);
+      if (typeof interpolator === "function") this.interpolator(interpolator);
+      else this.range(interpolator);
+      break;
+    }
+  }
+  return this;
+}
+
+// ../../node_modules/.bun/d3-scale@4.0.2/node_modules/d3-scale/src/ordinal.js
+var implicit = /* @__PURE__ */ Symbol("implicit");
+function ordinal() {
+  var index = new InternMap(), domain = [], range2 = [], unknown = implicit;
+  function scale(d) {
+    let i = index.get(d);
+    if (i === void 0) {
+      if (unknown !== implicit) return unknown;
+      index.set(d, i = domain.push(d) - 1);
+    }
+    return range2[i % range2.length];
+  }
+  scale.domain = function(_) {
+    if (!arguments.length) return domain.slice();
+    domain = [], index = new InternMap();
+    for (const value of _) {
+      if (index.has(value)) continue;
+      index.set(value, domain.push(value) - 1);
+    }
+    return scale;
+  };
+  scale.range = function(_) {
+    return arguments.length ? (range2 = Array.from(_), scale) : range2.slice();
+  };
+  scale.unknown = function(_) {
+    return arguments.length ? (unknown = _, scale) : unknown;
+  };
+  scale.copy = function() {
+    return ordinal(domain, range2).unknown(unknown);
+  };
+  initRange.apply(scale, arguments);
+  return scale;
+}
+
+// ../../node_modules/.bun/d3-scale@4.0.2/node_modules/d3-scale/src/band.js
+function band() {
+  var scale = ordinal().unknown(void 0), domain = scale.domain, ordinalRange = scale.range, r0 = 0, r1 = 1, step, bandwidth, round = false, paddingInner = 0, paddingOuter = 0, align = 0.5;
+  delete scale.unknown;
+  function rescale() {
+    var n = domain().length, reverse = r1 < r0, start = reverse ? r1 : r0, stop = reverse ? r0 : r1;
+    step = (stop - start) / Math.max(1, n - paddingInner + paddingOuter * 2);
+    if (round) step = Math.floor(step);
+    start += (stop - start - step * (n - paddingInner)) * align;
+    bandwidth = step * (1 - paddingInner);
+    if (round) start = Math.round(start), bandwidth = Math.round(bandwidth);
+    var values = range(n).map(function(i) {
+      return start + step * i;
+    });
+    return ordinalRange(reverse ? values.reverse() : values);
+  }
+  scale.domain = function(_) {
+    return arguments.length ? (domain(_), rescale()) : domain();
+  };
+  scale.range = function(_) {
+    return arguments.length ? ([r0, r1] = _, r0 = +r0, r1 = +r1, rescale()) : [r0, r1];
+  };
+  scale.rangeRound = function(_) {
+    return [r0, r1] = _, r0 = +r0, r1 = +r1, round = true, rescale();
+  };
+  scale.bandwidth = function() {
+    return bandwidth;
+  };
+  scale.step = function() {
+    return step;
+  };
+  scale.round = function(_) {
+    return arguments.length ? (round = !!_, rescale()) : round;
+  };
+  scale.padding = function(_) {
+    return arguments.length ? (paddingInner = Math.min(1, paddingOuter = +_), rescale()) : paddingInner;
+  };
+  scale.paddingInner = function(_) {
+    return arguments.length ? (paddingInner = Math.min(1, _), rescale()) : paddingInner;
+  };
+  scale.paddingOuter = function(_) {
+    return arguments.length ? (paddingOuter = +_, rescale()) : paddingOuter;
+  };
+  scale.align = function(_) {
+    return arguments.length ? (align = Math.max(0, Math.min(1, _)), rescale()) : align;
+  };
+  scale.copy = function() {
+    return band(domain(), [r0, r1]).round(round).paddingInner(paddingInner).paddingOuter(paddingOuter).align(align);
+  };
+  return initRange.apply(rescale(), arguments);
+}
+function pointish(scale) {
+  var copy3 = scale.copy;
+  scale.padding = scale.paddingOuter;
+  delete scale.paddingInner;
+  delete scale.paddingOuter;
+  scale.copy = function() {
+    return pointish(copy3());
+  };
+  return scale;
+}
+function point2() {
+  return pointish(band.apply(null, arguments).paddingInner(1));
+}
+
+// ../../node_modules/.bun/d3-color@3.1.0/node_modules/d3-color/src/define.js
+function define_default(constructor, factory, prototype) {
+  constructor.prototype = factory.prototype = prototype;
+  prototype.constructor = constructor;
+}
+function extend(parent, definition) {
+  var prototype = Object.create(parent.prototype);
+  for (var key in definition) prototype[key] = definition[key];
+  return prototype;
+}
+
+// ../../node_modules/.bun/d3-color@3.1.0/node_modules/d3-color/src/color.js
+function Color() {
+}
+var darker = 0.7;
+var brighter = 1 / darker;
+var reI = "\\s*([+-]?\\d+)\\s*";
+var reN = "\\s*([+-]?(?:\\d*\\.)?\\d+(?:[eE][+-]?\\d+)?)\\s*";
+var reP = "\\s*([+-]?(?:\\d*\\.)?\\d+(?:[eE][+-]?\\d+)?)%\\s*";
+var reHex = /^#([0-9a-f]{3,8})$/;
+var reRgbInteger = new RegExp(`^rgb\\(${reI},${reI},${reI}\\)$`);
+var reRgbPercent = new RegExp(`^rgb\\(${reP},${reP},${reP}\\)$`);
+var reRgbaInteger = new RegExp(`^rgba\\(${reI},${reI},${reI},${reN}\\)$`);
+var reRgbaPercent = new RegExp(`^rgba\\(${reP},${reP},${reP},${reN}\\)$`);
+var reHslPercent = new RegExp(`^hsl\\(${reN},${reP},${reP}\\)$`);
+var reHslaPercent = new RegExp(`^hsla\\(${reN},${reP},${reP},${reN}\\)$`);
+var named = {
+  aliceblue: 15792383,
+  antiquewhite: 16444375,
+  aqua: 65535,
+  aquamarine: 8388564,
+  azure: 15794175,
+  beige: 16119260,
+  bisque: 16770244,
+  black: 0,
+  blanchedalmond: 16772045,
+  blue: 255,
+  blueviolet: 9055202,
+  brown: 10824234,
+  burlywood: 14596231,
+  cadetblue: 6266528,
+  chartreuse: 8388352,
+  chocolate: 13789470,
+  coral: 16744272,
+  cornflowerblue: 6591981,
+  cornsilk: 16775388,
+  crimson: 14423100,
+  cyan: 65535,
+  darkblue: 139,
+  darkcyan: 35723,
+  darkgoldenrod: 12092939,
+  darkgray: 11119017,
+  darkgreen: 25600,
+  darkgrey: 11119017,
+  darkkhaki: 12433259,
+  darkmagenta: 9109643,
+  darkolivegreen: 5597999,
+  darkorange: 16747520,
+  darkorchid: 10040012,
+  darkred: 9109504,
+  darksalmon: 15308410,
+  darkseagreen: 9419919,
+  darkslateblue: 4734347,
+  darkslategray: 3100495,
+  darkslategrey: 3100495,
+  darkturquoise: 52945,
+  darkviolet: 9699539,
+  deeppink: 16716947,
+  deepskyblue: 49151,
+  dimgray: 6908265,
+  dimgrey: 6908265,
+  dodgerblue: 2003199,
+  firebrick: 11674146,
+  floralwhite: 16775920,
+  forestgreen: 2263842,
+  fuchsia: 16711935,
+  gainsboro: 14474460,
+  ghostwhite: 16316671,
+  gold: 16766720,
+  goldenrod: 14329120,
+  gray: 8421504,
+  green: 32768,
+  greenyellow: 11403055,
+  grey: 8421504,
+  honeydew: 15794160,
+  hotpink: 16738740,
+  indianred: 13458524,
+  indigo: 4915330,
+  ivory: 16777200,
+  khaki: 15787660,
+  lavender: 15132410,
+  lavenderblush: 16773365,
+  lawngreen: 8190976,
+  lemonchiffon: 16775885,
+  lightblue: 11393254,
+  lightcoral: 15761536,
+  lightcyan: 14745599,
+  lightgoldenrodyellow: 16448210,
+  lightgray: 13882323,
+  lightgreen: 9498256,
+  lightgrey: 13882323,
+  lightpink: 16758465,
+  lightsalmon: 16752762,
+  lightseagreen: 2142890,
+  lightskyblue: 8900346,
+  lightslategray: 7833753,
+  lightslategrey: 7833753,
+  lightsteelblue: 11584734,
+  lightyellow: 16777184,
+  lime: 65280,
+  limegreen: 3329330,
+  linen: 16445670,
+  magenta: 16711935,
+  maroon: 8388608,
+  mediumaquamarine: 6737322,
+  mediumblue: 205,
+  mediumorchid: 12211667,
+  mediumpurple: 9662683,
+  mediumseagreen: 3978097,
+  mediumslateblue: 8087790,
+  mediumspringgreen: 64154,
+  mediumturquoise: 4772300,
+  mediumvioletred: 13047173,
+  midnightblue: 1644912,
+  mintcream: 16121850,
+  mistyrose: 16770273,
+  moccasin: 16770229,
+  navajowhite: 16768685,
+  navy: 128,
+  oldlace: 16643558,
+  olive: 8421376,
+  olivedrab: 7048739,
+  orange: 16753920,
+  orangered: 16729344,
+  orchid: 14315734,
+  palegoldenrod: 15657130,
+  palegreen: 10025880,
+  paleturquoise: 11529966,
+  palevioletred: 14381203,
+  papayawhip: 16773077,
+  peachpuff: 16767673,
+  peru: 13468991,
+  pink: 16761035,
+  plum: 14524637,
+  powderblue: 11591910,
+  purple: 8388736,
+  rebeccapurple: 6697881,
+  red: 16711680,
+  rosybrown: 12357519,
+  royalblue: 4286945,
+  saddlebrown: 9127187,
+  salmon: 16416882,
+  sandybrown: 16032864,
+  seagreen: 3050327,
+  seashell: 16774638,
+  sienna: 10506797,
+  silver: 12632256,
+  skyblue: 8900331,
+  slateblue: 6970061,
+  slategray: 7372944,
+  slategrey: 7372944,
+  snow: 16775930,
+  springgreen: 65407,
+  steelblue: 4620980,
+  tan: 13808780,
+  teal: 32896,
+  thistle: 14204888,
+  tomato: 16737095,
+  turquoise: 4251856,
+  violet: 15631086,
+  wheat: 16113331,
+  white: 16777215,
+  whitesmoke: 16119285,
+  yellow: 16776960,
+  yellowgreen: 10145074
+};
+define_default(Color, color, {
+  copy(channels) {
+    return Object.assign(new this.constructor(), this, channels);
+  },
+  displayable() {
+    return this.rgb().displayable();
+  },
+  hex: color_formatHex,
+  // Deprecated! Use color.formatHex.
+  formatHex: color_formatHex,
+  formatHex8: color_formatHex8,
+  formatHsl: color_formatHsl,
+  formatRgb: color_formatRgb,
+  toString: color_formatRgb
+});
+function color_formatHex() {
+  return this.rgb().formatHex();
+}
+function color_formatHex8() {
+  return this.rgb().formatHex8();
+}
+function color_formatHsl() {
+  return hslConvert(this).formatHsl();
+}
+function color_formatRgb() {
+  return this.rgb().formatRgb();
+}
+function color(format2) {
+  var m, l;
+  format2 = (format2 + "").trim().toLowerCase();
+  return (m = reHex.exec(format2)) ? (l = m[1].length, m = parseInt(m[1], 16), l === 6 ? rgbn(m) : l === 3 ? new Rgb(m >> 8 & 15 | m >> 4 & 240, m >> 4 & 15 | m & 240, (m & 15) << 4 | m & 15, 1) : l === 8 ? rgba(m >> 24 & 255, m >> 16 & 255, m >> 8 & 255, (m & 255) / 255) : l === 4 ? rgba(m >> 12 & 15 | m >> 8 & 240, m >> 8 & 15 | m >> 4 & 240, m >> 4 & 15 | m & 240, ((m & 15) << 4 | m & 15) / 255) : null) : (m = reRgbInteger.exec(format2)) ? new Rgb(m[1], m[2], m[3], 1) : (m = reRgbPercent.exec(format2)) ? new Rgb(m[1] * 255 / 100, m[2] * 255 / 100, m[3] * 255 / 100, 1) : (m = reRgbaInteger.exec(format2)) ? rgba(m[1], m[2], m[3], m[4]) : (m = reRgbaPercent.exec(format2)) ? rgba(m[1] * 255 / 100, m[2] * 255 / 100, m[3] * 255 / 100, m[4]) : (m = reHslPercent.exec(format2)) ? hsla(m[1], m[2] / 100, m[3] / 100, 1) : (m = reHslaPercent.exec(format2)) ? hsla(m[1], m[2] / 100, m[3] / 100, m[4]) : named.hasOwnProperty(format2) ? rgbn(named[format2]) : format2 === "transparent" ? new Rgb(NaN, NaN, NaN, 0) : null;
+}
+function rgbn(n) {
+  return new Rgb(n >> 16 & 255, n >> 8 & 255, n & 255, 1);
+}
+function rgba(r, g, b, a) {
+  if (a <= 0) r = g = b = NaN;
+  return new Rgb(r, g, b, a);
+}
+function rgbConvert(o) {
+  if (!(o instanceof Color)) o = color(o);
+  if (!o) return new Rgb();
+  o = o.rgb();
+  return new Rgb(o.r, o.g, o.b, o.opacity);
+}
+function rgb(r, g, b, opacity) {
+  return arguments.length === 1 ? rgbConvert(r) : new Rgb(r, g, b, opacity == null ? 1 : opacity);
+}
+function Rgb(r, g, b, opacity) {
+  this.r = +r;
+  this.g = +g;
+  this.b = +b;
+  this.opacity = +opacity;
+}
+define_default(Rgb, rgb, extend(Color, {
+  brighter(k) {
+    k = k == null ? brighter : Math.pow(brighter, k);
+    return new Rgb(this.r * k, this.g * k, this.b * k, this.opacity);
+  },
+  darker(k) {
+    k = k == null ? darker : Math.pow(darker, k);
+    return new Rgb(this.r * k, this.g * k, this.b * k, this.opacity);
+  },
+  rgb() {
+    return this;
+  },
+  clamp() {
+    return new Rgb(clampi(this.r), clampi(this.g), clampi(this.b), clampa(this.opacity));
+  },
+  displayable() {
+    return -0.5 <= this.r && this.r < 255.5 && (-0.5 <= this.g && this.g < 255.5) && (-0.5 <= this.b && this.b < 255.5) && (0 <= this.opacity && this.opacity <= 1);
+  },
+  hex: rgb_formatHex,
+  // Deprecated! Use color.formatHex.
+  formatHex: rgb_formatHex,
+  formatHex8: rgb_formatHex8,
+  formatRgb: rgb_formatRgb,
+  toString: rgb_formatRgb
+}));
+function rgb_formatHex() {
+  return `#${hex(this.r)}${hex(this.g)}${hex(this.b)}`;
+}
+function rgb_formatHex8() {
+  return `#${hex(this.r)}${hex(this.g)}${hex(this.b)}${hex((isNaN(this.opacity) ? 1 : this.opacity) * 255)}`;
+}
+function rgb_formatRgb() {
+  const a = clampa(this.opacity);
+  return `${a === 1 ? "rgb(" : "rgba("}${clampi(this.r)}, ${clampi(this.g)}, ${clampi(this.b)}${a === 1 ? ")" : `, ${a})`}`;
+}
+function clampa(opacity) {
+  return isNaN(opacity) ? 1 : Math.max(0, Math.min(1, opacity));
+}
+function clampi(value) {
+  return Math.max(0, Math.min(255, Math.round(value) || 0));
+}
+function hex(value) {
+  value = clampi(value);
+  return (value < 16 ? "0" : "") + value.toString(16);
+}
+function hsla(h, s, l, a) {
+  if (a <= 0) h = s = l = NaN;
+  else if (l <= 0 || l >= 1) h = s = NaN;
+  else if (s <= 0) h = NaN;
+  return new Hsl(h, s, l, a);
+}
+function hslConvert(o) {
+  if (o instanceof Hsl) return new Hsl(o.h, o.s, o.l, o.opacity);
+  if (!(o instanceof Color)) o = color(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;
+  if (s) {
+    if (r === max3) h = (g - b) / s + (g < b) * 6;
+    else if (g === max3) h = (b - r) / s + 2;
+    else h = (r - g) / s + 4;
+    s /= l < 0.5 ? max3 + min3 : 2 - max3 - min3;
+    h *= 60;
+  } else {
+    s = l > 0 && l < 1 ? 0 : h;
+  }
+  return new Hsl(h, s, l, o.opacity);
+}
+function hsl(h, s, l, opacity) {
+  return arguments.length === 1 ? hslConvert(h) : new Hsl(h, s, l, opacity == null ? 1 : opacity);
+}
+function Hsl(h, s, l, opacity) {
+  this.h = +h;
+  this.s = +s;
+  this.l = +l;
+  this.opacity = +opacity;
+}
+define_default(Hsl, hsl, extend(Color, {
+  brighter(k) {
+    k = k == null ? brighter : Math.pow(brighter, k);
+    return new Hsl(this.h, this.s, this.l * k, this.opacity);
+  },
+  darker(k) {
+    k = k == null ? darker : Math.pow(darker, k);
+    return new Hsl(this.h, this.s, this.l * k, this.opacity);
+  },
+  rgb() {
+    var h = this.h % 360 + (this.h < 0) * 360, s = isNaN(h) || isNaN(this.s) ? 0 : this.s, l = this.l, m2 = l + (l < 0.5 ? l : 1 - l) * s, m1 = 2 * l - m2;
+    return new Rgb(
+      hsl2rgb(h >= 240 ? h - 240 : h + 120, m1, m2),
+      hsl2rgb(h, m1, m2),
+      hsl2rgb(h < 120 ? h + 240 : h - 120, m1, m2),
+      this.opacity
+    );
+  },
+  clamp() {
+    return new Hsl(clamph(this.h), clampt(this.s), clampt(this.l), clampa(this.opacity));
+  },
+  displayable() {
+    return (0 <= this.s && this.s <= 1 || isNaN(this.s)) && (0 <= this.l && this.l <= 1) && (0 <= this.opacity && this.opacity <= 1);
+  },
+  formatHsl() {
+    const a = clampa(this.opacity);
+    return `${a === 1 ? "hsl(" : "hsla("}${clamph(this.h)}, ${clampt(this.s) * 100}%, ${clampt(this.l) * 100}%${a === 1 ? ")" : `, ${a})`}`;
+  }
+}));
+function clamph(value) {
+  value = (value || 0) % 360;
+  return value < 0 ? value + 360 : value;
+}
+function clampt(value) {
+  return Math.max(0, Math.min(1, value || 0));
+}
+function hsl2rgb(h, m1, m2) {
+  return (h < 60 ? m1 + (m2 - m1) * h / 60 : h < 180 ? m2 : h < 240 ? m1 + (m2 - m1) * (240 - h) / 60 : m1) * 255;
+}
+
+// ../../node_modules/.bun/d3-interpolate@3.0.1/node_modules/d3-interpolate/src/basis.js
+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) {
+  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;
+    return basis((t - i / n) * n, v0, v1, v2, v3);
+  };
+}
+
+// ../../node_modules/.bun/d3-interpolate@3.0.1/node_modules/d3-interpolate/src/basisClosed.js
+function basisClosed_default(values) {
+  var n = values.length;
+  return function(t) {
+    var i = Math.floor(((t %= 1) < 0 ? ++t : t) * n), v0 = values[(i + n - 1) % n], v1 = values[i % n], v2 = values[(i + 1) % n], v3 = values[(i + 2) % n];
+    return basis((t - i / n) * n, v0, v1, v2, v3);
+  };
+}
+
+// ../../node_modules/.bun/d3-interpolate@3.0.1/node_modules/d3-interpolate/src/constant.js
+var constant_default2 = (x2) => () => x2;
+
+// ../../node_modules/.bun/d3-interpolate@3.0.1/node_modules/d3-interpolate/src/color.js
+function linear(a, d) {
+  return function(t) {
+    return a + t * d;
+  };
+}
+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(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_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(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) {
+      start.r = r(t);
+      start.g = g(t);
+      start.b = b(t);
+      start.opacity = opacity(t);
+      return start + "";
+    };
+  }
+  rgb2.gamma = rgbGamma;
+  return rgb2;
+})(1);
+function rgbSpline(spline) {
+  return function(colors) {
+    var n = colors.length, r = new Array(n), g = new Array(n), b = new Array(n), i, color2;
+    for (i = 0; i < n; ++i) {
+      color2 = rgb(colors[i]);
+      r[i] = color2.r || 0;
+      g[i] = color2.g || 0;
+      b[i] = color2.b || 0;
+    }
+    r = spline(r);
+    g = spline(g);
+    b = spline(b);
+    color2.opacity = 1;
+    return function(t) {
+      color2.r = r(t);
+      color2.g = g(t);
+      color2.b = b(t);
+      return color2 + "";
+    };
+  };
+}
+var rgbBasis = rgbSpline(basis_default);
+var rgbBasisClosed = rgbSpline(basisClosed_default);
+
+// ../../node_modules/.bun/d3-interpolate@3.0.1/node_modules/d3-interpolate/src/numberArray.js
+function numberArray_default(a, b) {
+  if (!b) b = [];
+  var n = a ? Math.min(b.length, a.length) : 0, c = b.slice(), i;
+  return function(t) {
+    for (i = 0; i < n; ++i) c[i] = a[i] * (1 - t) + b[i] * t;
+    return c;
+  };
+}
+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, 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] = x2[i](t);
+    return c;
+  };
+}
+
+// ../../node_modules/.bun/d3-interpolate@3.0.1/node_modules/d3-interpolate/src/date.js
+function date_default(a, b) {
+  var d = /* @__PURE__ */ new Date();
+  return a = +a, b = +b, function(t) {
+    return d.setTime(a * (1 - t) + b * t), d;
+  };
+}
+
+// ../../node_modules/.bun/d3-interpolate@3.0.1/node_modules/d3-interpolate/src/number.js
+function number_default(a, b) {
+  return a = +a, b = +b, function(t) {
+    return a * (1 - t) + b * t;
+  };
+}
+
+// ../../node_modules/.bun/d3-interpolate@3.0.1/node_modules/d3-interpolate/src/object.js
+function object_default(a, b) {
+  var i = {}, c = {}, k;
+  if (a === null || typeof a !== "object") a = {};
+  if (b === null || typeof b !== "object") b = {};
+  for (k in b) {
+    if (k in a) {
+      i[k] = value_default(a[k], b[k]);
+    } else {
+      c[k] = b[k];
+    }
+  }
+  return function(t) {
+    for (k in i) c[k] = i[k](t);
+    return c;
+  };
+}
+
+// ../../node_modules/.bun/d3-interpolate@3.0.1/node_modules/d3-interpolate/src/string.js
+var reA = /[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?/g;
+var reB = new RegExp(reA.source, "g");
+function zero2(b) {
+  return function() {
+    return b;
+  };
+}
+function one(b) {
+  return function(t) {
+    return b(t) + "";
+  };
+}
+function string_default(a, b) {
+  var bi = reA.lastIndex = reB.lastIndex = 0, am, bm, bs, i = -1, s = [], q = [];
+  a = a + "", b = b + "";
+  while ((am = reA.exec(a)) && (bm = reB.exec(b))) {
+    if ((bs = bm.index) > bi) {
+      bs = b.slice(bi, bs);
+      if (s[i]) s[i] += bs;
+      else s[++i] = bs;
+    }
+    if ((am = am[0]) === (bm = bm[0])) {
+      if (s[i]) s[i] += bm;
+      else s[++i] = bm;
+    } else {
+      s[++i] = null;
+      q.push({ i, x: number_default(am, bm) });
+    }
+    bi = reB.lastIndex;
+  }
+  if (bi < b.length) {
+    bs = b.slice(bi);
+    if (s[i]) s[i] += bs;
+    else s[++i] = bs;
+  }
+  return s.length < 2 ? q[0] ? one(q[0].x) : zero2(b) : (b = q.length, function(t) {
+    for (var i2 = 0, o; i2 < b; ++i2) s[(o = q[i2]).i] = o.x(t);
+    return s.join("");
+  });
+}
+
+// ../../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_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
+function round_default(a, b) {
+  return a = +a, b = +b, function(t) {
+    return Math.round(a * (1 - t) + b * t);
+  };
+}
+
+// ../../node_modules/.bun/d3-scale@4.0.2/node_modules/d3-scale/src/constant.js
+function constants(x2) {
+  return function() {
+    return x2;
+  };
+}
+
+// ../../node_modules/.bun/d3-scale@4.0.2/node_modules/d3-scale/src/number.js
+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(x2) {
+  return x2;
+}
+function normalize(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(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(x2) {
+    return r0(d0(x2));
+  };
+}
+function polymap(domain, range2, interpolate) {
+  var j = Math.min(domain.length, range2.length) - 1, d = new Array(j), r = new Array(j), i = -1;
+  if (domain[j] < domain[0]) {
+    domain = domain.slice().reverse();
+    range2 = range2.slice().reverse();
+  }
+  while (++i < j) {
+    d[i] = normalize(domain[i], domain[i + 1]);
+    r[i] = interpolate(range2[i], range2[i + 1]);
+  }
+  return function(x2) {
+    var i2 = bisect_default(domain, x2, 1, j) - 1;
+    return r[i2](d[i2](x2));
+  };
+}
+function copy(source, target) {
+  return target.domain(source.domain()).range(source.range()).interpolate(source.interpolate()).clamp(source.clamp()).unknown(source.unknown());
+}
+function transformer() {
+  var domain = unit, range2 = unit, interpolate = value_default, transform, untransform, unknown, clamp = identity, piecewise, output, input;
+  function rescale() {
+    var n = Math.min(domain.length, range2.length);
+    if (clamp !== identity) clamp = clamper(domain[0], domain[n - 1]);
+    piecewise = n > 2 ? polymap : bimap;
+    output = input = null;
+    return scale;
+  }
+  function scale(x2) {
+    return x2 == null || isNaN(x2 = +x2) ? unknown : (output || (output = piecewise(domain.map(transform), range2, interpolate)))(transform(clamp(x2)));
+  }
+  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();
+  };
+  scale.range = function(_) {
+    return arguments.length ? (range2 = Array.from(_), rescale()) : range2.slice();
+  };
+  scale.rangeRound = function(_) {
+    return range2 = Array.from(_), interpolate = round_default, rescale();
+  };
+  scale.clamp = function(_) {
+    return arguments.length ? (clamp = _ ? true : identity, rescale()) : clamp !== identity;
+  };
+  scale.interpolate = function(_) {
+    return arguments.length ? (interpolate = _, rescale()) : interpolate;
+  };
+  scale.unknown = function(_) {
+    return arguments.length ? (unknown = _, scale) : unknown;
+  };
+  return function(t, u) {
+    transform = t, untransform = u;
+    return rescale();
+  };
+}
+function continuous() {
+  return transformer()(identity, identity);
+}
+
+// ../../node_modules/.bun/d3-format@3.1.2/node_modules/d3-format/src/formatDecimal.js
+function formatDecimal_default(x2) {
+  return Math.abs(x2 = Math.round(x2)) >= 1e21 ? x2.toLocaleString("en").replace(/,/g, "") : x2.toString(10);
+}
+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,
+    +x2.slice(i + 1)
+  ];
+}
+
+// ../../node_modules/.bun/d3-format@3.1.2/node_modules/d3-format/src/exponent.js
+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
+function formatGroup_default(grouping, thousands) {
+  return function(value, width) {
+    var i = value.length, t = [], j = 0, g = grouping[0], length = 0;
+    while (i > 0 && g > 0) {
+      if (length + g + 1 > width) g = Math.max(1, width - length);
+      t.push(value.substring(i -= g, i + g));
+      if ((length += g + 1) > width) break;
+      g = grouping[j = (j + 1) % grouping.length];
+    }
+    return t.reverse().join(thousands);
+  };
+}
+
+// ../../node_modules/.bun/d3-format@3.1.2/node_modules/d3-format/src/formatNumerals.js
+function formatNumerals_default(numerals) {
+  return function(value) {
+    return value.replace(/[0-9]/g, function(i) {
+      return numerals[+i];
+    });
+  };
+}
+
+// ../../node_modules/.bun/d3-format@3.1.2/node_modules/d3-format/src/formatSpecifier.js
+var re = /^(?:(.)?([<>=^]))?([+\-( ])?([$#])?(0)?(\d+)?(,)?(\.\d+)?(~)?([a-z%])?$/i;
+function formatSpecifier(specifier) {
+  if (!(match = re.exec(specifier))) throw new Error("invalid format: " + specifier);
+  var match;
+  return new FormatSpecifier({
+    fill: match[1],
+    align: match[2],
+    sign: match[3],
+    symbol: match[4],
+    zero: match[5],
+    width: match[6],
+    comma: match[7],
+    precision: match[8] && match[8].slice(1),
+    trim: match[9],
+    type: match[10]
+  });
+}
+formatSpecifier.prototype = FormatSpecifier.prototype;
+function FormatSpecifier(specifier) {
+  this.fill = specifier.fill === void 0 ? " " : specifier.fill + "";
+  this.align = specifier.align === void 0 ? ">" : specifier.align + "";
+  this.sign = specifier.sign === void 0 ? "-" : specifier.sign + "";
+  this.symbol = specifier.symbol === void 0 ? "" : specifier.symbol + "";
+  this.zero = !!specifier.zero;
+  this.width = specifier.width === void 0 ? void 0 : +specifier.width;
+  this.comma = !!specifier.comma;
+  this.precision = specifier.precision === void 0 ? void 0 : +specifier.precision;
+  this.trim = !!specifier.trim;
+  this.type = specifier.type === void 0 ? "" : specifier.type + "";
+}
+FormatSpecifier.prototype.toString = function() {
+  return this.fill + this.align + this.sign + this.symbol + (this.zero ? "0" : "") + (this.width === void 0 ? "" : Math.max(1, this.width | 0)) + (this.comma ? "," : "") + (this.precision === void 0 ? "" : "." + Math.max(0, this.precision | 0)) + (this.trim ? "~" : "") + this.type;
+};
+
+// ../../node_modules/.bun/d3-format@3.1.2/node_modules/d3-format/src/formatTrim.js
+function formatTrim_default(s) {
+  out: for (var n = s.length, i = 1, i0 = -1, i1; i < n; ++i) {
+    switch (s[i]) {
+      case ".":
+        i0 = i1 = i;
+        break;
+      case "0":
+        if (i0 === 0) i0 = i;
+        i1 = i;
+        break;
+      default:
+        if (!+s[i]) break out;
+        if (i0 > 0) i0 = 0;
+        break;
+    }
+  }
+  return i0 > 0 ? s.slice(0, i0) + s.slice(i1 + 1) : s;
+}
+
+// ../../node_modules/.bun/d3-format@3.1.2/node_modules/d3-format/src/formatPrefixAuto.js
+var prefixExponent;
+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(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(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 = {
+  "%": (x2, p) => (x2 * 100).toFixed(p),
+  "b": (x2) => Math.round(x2).toString(2),
+  "c": (x2) => x2 + "",
+  "d": formatDecimal_default,
+  "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": (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_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_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, 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 = "=";
+    var prefix = (options && options.prefix !== void 0 ? options.prefix : "") + (symbol === "$" ? currencyPrefix : symbol === "#" && /[boxX]/.test(type) ? "0" + type.toLowerCase() : ""), suffix = (symbol === "$" ? currencySuffix : /[%p]/.test(type) ? percent : "") + (options && options.suffix !== void 0 ? options.suffix : "");
+    var formatType = formatTypes_default[type], maybeSuffix = /[defgprs%]/.test(type);
+    precision = precision === void 0 ? 6 : /[gprs]/.test(type) ? Math.max(1, Math.min(21, precision)) : Math.max(0, Math.min(20, precision));
+    function format2(value) {
+      var valuePrefix = prefix, valueSuffix = suffix, i, n, c;
+      if (type === "c") {
+        valueSuffix = formatType(value) + valueSuffix;
+        value = "";
+      } else {
+        value = +value;
+        var valueNegative = value < 0 || 1 / value < 0;
+        value = isNaN(value) ? nan : formatType(Math.abs(value), precision);
+        if (trim) value = formatTrim_default(value);
+        if (valueNegative && +value === 0 && sign2 !== "+") valueNegative = false;
+        valuePrefix = (valueNegative ? sign2 === "(" ? sign2 : minus : sign2 === "-" || sign2 === "(" ? "" : sign2) + valuePrefix;
+        valueSuffix = (type === "s" && !isNaN(value) && prefixExponent !== void 0 ? prefixes[8 + prefixExponent / 3] : "") + valueSuffix + (valueNegative && sign2 === "(" ? ")" : "");
+        if (maybeSuffix) {
+          i = -1, n = value.length;
+          while (++i < n) {
+            if (c = value.charCodeAt(i), 48 > c || c > 57) {
+              valueSuffix = (c === 46 ? decimal + value.slice(i + 1) : value.slice(i)) + valueSuffix;
+              value = value.slice(0, i);
+              break;
+            }
+          }
+        }
+      }
+      if (comma && !zero3) value = group(value, Infinity);
+      var length = valuePrefix.length + value.length + valueSuffix.length, padding = length < width ? new Array(width - length + 1).join(fill) : "";
+      if (comma && zero3) value = group(padding + value, padding.length ? width - valueSuffix.length : Infinity), padding = "";
+      switch (align) {
+        case "<":
+          value = valuePrefix + value + valueSuffix + padding;
+          break;
+        case "=":
+          value = valuePrefix + padding + value + valueSuffix;
+          break;
+        case "^":
+          value = padding.slice(0, length = padding.length >> 1) + valuePrefix + value + valueSuffix + padding.slice(length);
+          break;
+        default:
+          value = padding + valuePrefix + value + valueSuffix;
+          break;
+      }
+      return numerals(value);
+    }
+    format2.toString = function() {
+      return specifier + "";
+    };
+    return format2;
+  }
+  function formatPrefix2(specifier, value) {
+    var e = Math.max(-8, Math.min(8, Math.floor(exponent_default(value) / 3))) * 3, k = Math.pow(10, -e), f = newFormat((specifier = formatSpecifier(specifier), specifier.type = "f", specifier), { suffix: prefixes[8 + e / 3] });
+    return function(value2) {
+      return f(k * value2);
+    };
+  }
+  return {
+    format: newFormat,
+    formatPrefix: formatPrefix2
+  };
+}
+
+// ../../node_modules/.bun/d3-format@3.1.2/node_modules/d3-format/src/defaultLocale.js
+var locale;
+var format;
+var formatPrefix;
+defaultLocale({
+  thousands: ",",
+  grouping: [3],
+  currency: ["$", ""]
+});
+function defaultLocale(definition) {
+  locale = locale_default(definition);
+  format = locale.format;
+  formatPrefix = locale.formatPrefix;
+  return locale;
+}
+
+// ../../node_modules/.bun/d3-format@3.1.2/node_modules/d3-format/src/precisionFixed.js
+function precisionFixed_default(step) {
+  return Math.max(0, -exponent_default(Math.abs(step)));
+}
+
+// ../../node_modules/.bun/d3-format@3.1.2/node_modules/d3-format/src/precisionPrefix.js
+function precisionPrefix_default(step, value) {
+  return Math.max(0, Math.max(-8, Math.min(8, Math.floor(exponent_default(value) / 3))) * 3 - exponent_default(Math.abs(step)));
+}
+
+// ../../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;
+}
+
+// ../../node_modules/.bun/d3-scale@4.0.2/node_modules/d3-scale/src/tickFormat.js
+function tickFormat(start, stop, count, specifier) {
+  var step = tickStep(start, stop, count), precision;
+  specifier = formatSpecifier(specifier == null ? ",f" : specifier);
+  switch (specifier.type) {
+    case "s": {
+      var value = Math.max(Math.abs(start), Math.abs(stop));
+      if (specifier.precision == null && !isNaN(precision = precisionPrefix_default(step, value))) specifier.precision = precision;
+      return formatPrefix(specifier, value);
+    }
+    case "":
+    case "e":
+    case "g":
+    case "p":
+    case "r": {
+      if (specifier.precision == null && !isNaN(precision = precisionRound_default(step, Math.max(Math.abs(start), Math.abs(stop))))) specifier.precision = precision - (specifier.type === "e");
+      break;
+    }
+    case "f":
+    case "%": {
+      if (specifier.precision == null && !isNaN(precision = precisionFixed_default(step))) specifier.precision = precision - (specifier.type === "%") * 2;
+      break;
+    }
+  }
+  return format(specifier);
+}
+
+// ../../node_modules/.bun/d3-scale@4.0.2/node_modules/d3-scale/src/linear.js
+function linearish(scale) {
+  var domain = scale.domain;
+  scale.ticks = function(count) {
+    var d = domain();
+    return ticks(d[0], d[d.length - 1], count == null ? 10 : count);
+  };
+  scale.tickFormat = function(count, specifier) {
+    var d = domain();
+    return tickFormat(d[0], d[d.length - 1], count == null ? 10 : count, specifier);
+  };
+  scale.nice = function(count) {
+    if (count == null) count = 10;
+    var d = domain();
+    var i0 = 0;
+    var i1 = d.length - 1;
+    var start = d[i0];
+    var stop = d[i1];
+    var prestep;
+    var step;
+    var maxIter = 10;
+    if (stop < start) {
+      step = start, start = stop, stop = step;
+      step = i0, i0 = i1, i1 = step;
+    }
+    while (maxIter-- > 0) {
+      step = tickIncrement(start, stop, count);
+      if (step === prestep) {
+        d[i0] = start;
+        d[i1] = stop;
+        return domain(d);
+      } else if (step > 0) {
+        start = Math.floor(start / step) * step;
+        stop = Math.ceil(stop / step) * step;
+      } else if (step < 0) {
+        start = Math.ceil(start * step) / step;
+        stop = Math.floor(stop * step) / step;
+      } else {
+        break;
+      }
+      prestep = step;
+    }
+    return scale;
+  };
+  return scale;
+}
+function linear2() {
+  var scale = continuous();
+  scale.copy = function() {
+    return copy(scale, linear2());
+  };
+  initRange.apply(scale, arguments);
+  return linearish(scale);
+}
+
+// ../../node_modules/.bun/d3-scale@4.0.2/node_modules/d3-scale/src/nice.js
+function nice(domain, interval) {
+  domain = domain.slice();
+  var i0 = 0, i1 = domain.length - 1, x0 = domain[i0], x1 = domain[i1], t;
+  if (x1 < x0) {
+    t = i0, i0 = i1, i1 = t;
+    t = x0, x0 = x1, x1 = t;
+  }
+  domain[i0] = interval.floor(x0);
+  domain[i1] = interval.ceil(x1);
+  return domain;
+}
+
+// ../../node_modules/.bun/d3-scale@4.0.2/node_modules/d3-scale/src/log.js
+function transformLog(x2) {
+  return Math.log(x2);
+}
+function transformExp(x2) {
+  return Math.exp(x2);
+}
+function transformLogn(x2) {
+  return -Math.log(-x2);
+}
+function transformExpn(x2) {
+  return -Math.exp(-x2);
+}
+function pow10(x2) {
+  return isFinite(x2) ? +("1e" + x2) : x2 < 0 ? 0 : x2;
+}
+function powp(base) {
+  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), (x2) => Math.log(x2) / base);
+}
+function reflect(f) {
+  return (x2, k) => -f(-x2, k);
+}
+function loggish(transform) {
+  const scale = transform(transformLog, transformExp);
+  const domain = scale.domain;
+  let base = 10;
+  let logs;
+  let pows;
+  function rescale() {
+    logs = logp(base), pows = powp(base);
+    if (domain()[0] < 0) {
+      logs = reflect(logs), pows = reflect(pows);
+      transform(transformLogn, transformExpn);
+    } else {
+      transform(transformLog, transformExp);
+    }
+    return scale;
+  }
+  scale.base = function(_) {
+    return arguments.length ? (base = +_, rescale()) : base;
+  };
+  scale.domain = function(_) {
+    return arguments.length ? (domain(_), rescale()) : domain();
+  };
+  scale.ticks = (count) => {
+    const d = domain();
+    let u = d[0];
+    let v = d[d.length - 1];
+    const r = v < u;
+    if (r) [u, v] = [v, u];
+    let i = logs(u);
+    let j = logs(v);
+    let k;
+    let t;
+    const n = count == null ? 10 : +count;
+    let z = [];
+    if (!(base % 1) && j - i < n) {
+      i = Math.floor(i), j = Math.ceil(j);
+      if (u > 0) for (; i <= j; ++i) {
+        for (k = 1; k < base; ++k) {
+          t = i < 0 ? k / pows(-i) : k * pows(i);
+          if (t < u) continue;
+          if (t > v) break;
+          z.push(t);
+        }
+      }
+      else for (; i <= j; ++i) {
+        for (k = base - 1; k >= 1; --k) {
+          t = i > 0 ? k / pows(-i) : k * pows(i);
+          if (t < u) continue;
+          if (t > v) break;
+          z.push(t);
+        }
+      }
+      if (z.length * 2 < n) z = ticks(u, v, n);
+    } else {
+      z = ticks(i, j, Math.min(j - i, n)).map(pows);
+    }
+    return r ? z.reverse() : z;
+  };
+  scale.tickFormat = (count, specifier) => {
+    if (count == null) count = 10;
+    if (specifier == null) specifier = base === 10 ? "s" : ",";
+    if (typeof specifier !== "function") {
+      if (!(base % 1) && (specifier = formatSpecifier(specifier)).precision == null) specifier.trim = true;
+      specifier = format(specifier);
+    }
+    if (count === Infinity) return specifier;
+    const k = Math.max(1, base * count / scale.ticks().length);
+    return (d) => {
+      let i = d / pows(Math.round(logs(d)));
+      if (i * base < base - 0.5) i *= base;
+      return i <= k ? specifier(d) : "";
+    };
+  };
+  scale.nice = () => {
+    return domain(nice(domain(), {
+      floor: (x2) => pows(Math.floor(logs(x2))),
+      ceil: (x2) => pows(Math.ceil(logs(x2)))
+    }));
+  };
+  return scale;
+}
+function log() {
+  const scale = loggish(transformer()).domain([1, 10]);
+  scale.copy = () => copy(scale, log()).base(scale.base());
+  initRange.apply(scale, arguments);
+  return scale;
+}
+
+// ../../node_modules/.bun/d3-scale@4.0.2/node_modules/d3-scale/src/pow.js
+function transformPow(exponent) {
+  return function(x2) {
+    return x2 < 0 ? -Math.pow(-x2, exponent) : Math.pow(x2, exponent);
+  };
+}
+function transformSqrt(x2) {
+  return x2 < 0 ? -Math.sqrt(-x2) : Math.sqrt(x2);
+}
+function transformSquare(x2) {
+  return x2 < 0 ? -x2 * x2 : x2 * x2;
+}
+function powish(transform) {
+  var scale = transform(identity, identity), exponent = 1;
+  function rescale() {
+    return exponent === 1 ? transform(identity, identity) : exponent === 0.5 ? transform(transformSqrt, transformSquare) : transform(transformPow(exponent), transformPow(1 / exponent));
+  }
+  scale.exponent = function(_) {
+    return arguments.length ? (exponent = +_, rescale()) : exponent;
+  };
+  return linearish(scale);
+}
+function pow() {
+  var scale = powish(transformer());
+  scale.copy = function() {
+    return copy(scale, pow()).exponent(scale.exponent());
+  };
+  initRange.apply(scale, arguments);
+  return scale;
+}
+function sqrt2() {
+  return pow.apply(null, arguments).exponent(0.5);
+}
+
+// ../../node_modules/.bun/d3-time@3.1.0/node_modules/d3-time/src/interval.js
+var t0 = /* @__PURE__ */ new Date();
+var t1 = /* @__PURE__ */ new Date();
+function timeInterval(floori, offseti, count, field) {
+  function interval(date2) {
+    return floori(date2 = arguments.length === 0 ? /* @__PURE__ */ new Date() : /* @__PURE__ */ new Date(+date2)), date2;
+  }
+  interval.floor = (date2) => {
+    return floori(date2 = /* @__PURE__ */ new Date(+date2)), date2;
+  };
+  interval.ceil = (date2) => {
+    return floori(date2 = new Date(date2 - 1)), offseti(date2, 1), floori(date2), date2;
+  };
+  interval.round = (date2) => {
+    const d0 = interval(date2), d1 = interval.ceil(date2);
+    return date2 - d0 < d1 - date2 ? d0 : d1;
+  };
+  interval.offset = (date2, step) => {
+    return offseti(date2 = /* @__PURE__ */ new Date(+date2), step == null ? 1 : Math.floor(step)), date2;
+  };
+  interval.range = (start, stop, step) => {
+    const range2 = [];
+    start = interval.ceil(start);
+    step = step == null ? 1 : Math.floor(step);
+    if (!(start < stop) || !(step > 0)) return range2;
+    let previous;
+    do
+      range2.push(previous = /* @__PURE__ */ new Date(+start)), offseti(start, step), floori(start);
+    while (previous < start && start < stop);
+    return range2;
+  };
+  interval.filter = (test) => {
+    return timeInterval((date2) => {
+      if (date2 >= date2) while (floori(date2), !test(date2)) date2.setTime(date2 - 1);
+    }, (date2, step) => {
+      if (date2 >= date2) {
+        if (step < 0) while (++step <= 0) {
+          while (offseti(date2, -1), !test(date2)) {
+          }
+        }
+        else while (--step >= 0) {
+          while (offseti(date2, 1), !test(date2)) {
+          }
+        }
+      }
+    });
+  };
+  if (count) {
+    interval.count = (start, end) => {
+      t0.setTime(+start), t1.setTime(+end);
+      floori(t0), floori(t1);
+      return Math.floor(count(t0, t1));
+    };
+    interval.every = (step) => {
+      step = Math.floor(step);
+      return !isFinite(step) || !(step > 0) ? null : !(step > 1) ? interval : interval.filter(field ? (d) => field(d) % step === 0 : (d) => interval.count(0, d) % step === 0);
+    };
+  }
+  return interval;
+}
+
+// ../../node_modules/.bun/d3-time@3.1.0/node_modules/d3-time/src/millisecond.js
+var millisecond = timeInterval(() => {
+}, (date2, step) => {
+  date2.setTime(+date2 + step);
+}, (start, end) => {
+  return end - start;
+});
+millisecond.every = (k) => {
+  k = Math.floor(k);
+  if (!isFinite(k) || !(k > 0)) return null;
+  if (!(k > 1)) return millisecond;
+  return timeInterval((date2) => {
+    date2.setTime(Math.floor(date2 / k) * k);
+  }, (date2, step) => {
+    date2.setTime(+date2 + step * k);
+  }, (start, end) => {
+    return (end - start) / k;
+  });
+};
+var milliseconds = millisecond.range;
+
+// ../../node_modules/.bun/d3-time@3.1.0/node_modules/d3-time/src/duration.js
+var durationSecond = 1e3;
+var durationMinute = durationSecond * 60;
+var durationHour = durationMinute * 60;
+var durationDay = durationHour * 24;
+var durationWeek = durationDay * 7;
+var durationMonth = durationDay * 30;
+var durationYear = durationDay * 365;
+
+// ../../node_modules/.bun/d3-time@3.1.0/node_modules/d3-time/src/second.js
+var second = timeInterval((date2) => {
+  date2.setTime(date2 - date2.getMilliseconds());
+}, (date2, step) => {
+  date2.setTime(+date2 + step * durationSecond);
+}, (start, end) => {
+  return (end - start) / durationSecond;
+}, (date2) => {
+  return date2.getUTCSeconds();
+});
+var seconds = second.range;
+
+// ../../node_modules/.bun/d3-time@3.1.0/node_modules/d3-time/src/minute.js
+var timeMinute = timeInterval((date2) => {
+  date2.setTime(date2 - date2.getMilliseconds() - date2.getSeconds() * durationSecond);
+}, (date2, step) => {
+  date2.setTime(+date2 + step * durationMinute);
+}, (start, end) => {
+  return (end - start) / durationMinute;
+}, (date2) => {
+  return date2.getMinutes();
+});
+var timeMinutes = timeMinute.range;
+var utcMinute = timeInterval((date2) => {
+  date2.setUTCSeconds(0, 0);
+}, (date2, step) => {
+  date2.setTime(+date2 + step * durationMinute);
+}, (start, end) => {
+  return (end - start) / durationMinute;
+}, (date2) => {
+  return date2.getUTCMinutes();
+});
+var utcMinutes = utcMinute.range;
+
+// ../../node_modules/.bun/d3-time@3.1.0/node_modules/d3-time/src/hour.js
+var timeHour = timeInterval((date2) => {
+  date2.setTime(date2 - date2.getMilliseconds() - date2.getSeconds() * durationSecond - date2.getMinutes() * durationMinute);
+}, (date2, step) => {
+  date2.setTime(+date2 + step * durationHour);
+}, (start, end) => {
+  return (end - start) / durationHour;
+}, (date2) => {
+  return date2.getHours();
+});
+var timeHours = timeHour.range;
+var utcHour = timeInterval((date2) => {
+  date2.setUTCMinutes(0, 0, 0);
+}, (date2, step) => {
+  date2.setTime(+date2 + step * durationHour);
+}, (start, end) => {
+  return (end - start) / durationHour;
+}, (date2) => {
+  return date2.getUTCHours();
+});
+var utcHours = utcHour.range;
+
+// ../../node_modules/.bun/d3-time@3.1.0/node_modules/d3-time/src/day.js
+var timeDay = timeInterval(
+  (date2) => date2.setHours(0, 0, 0, 0),
+  (date2, step) => date2.setDate(date2.getDate() + step),
+  (start, end) => (end - start - (end.getTimezoneOffset() - start.getTimezoneOffset()) * durationMinute) / durationDay,
+  (date2) => date2.getDate() - 1
+);
+var timeDays = timeDay.range;
+var utcDay = timeInterval((date2) => {
+  date2.setUTCHours(0, 0, 0, 0);
+}, (date2, step) => {
+  date2.setUTCDate(date2.getUTCDate() + step);
+}, (start, end) => {
+  return (end - start) / durationDay;
+}, (date2) => {
+  return date2.getUTCDate() - 1;
+});
+var utcDays = utcDay.range;
+var unixDay = timeInterval((date2) => {
+  date2.setUTCHours(0, 0, 0, 0);
+}, (date2, step) => {
+  date2.setUTCDate(date2.getUTCDate() + step);
+}, (start, end) => {
+  return (end - start) / durationDay;
+}, (date2) => {
+  return Math.floor(date2 / durationDay);
+});
+var unixDays = unixDay.range;
+
+// ../../node_modules/.bun/d3-time@3.1.0/node_modules/d3-time/src/week.js
+function timeWeekday(i) {
+  return timeInterval((date2) => {
+    date2.setDate(date2.getDate() - (date2.getDay() + 7 - i) % 7);
+    date2.setHours(0, 0, 0, 0);
+  }, (date2, step) => {
+    date2.setDate(date2.getDate() + step * 7);
+  }, (start, end) => {
+    return (end - start - (end.getTimezoneOffset() - start.getTimezoneOffset()) * durationMinute) / durationWeek;
+  });
+}
+var timeSunday = timeWeekday(0);
+var timeMonday = timeWeekday(1);
+var timeTuesday = timeWeekday(2);
+var timeWednesday = timeWeekday(3);
+var timeThursday = timeWeekday(4);
+var timeFriday = timeWeekday(5);
+var timeSaturday = timeWeekday(6);
+var timeSundays = timeSunday.range;
+var timeMondays = timeMonday.range;
+var timeTuesdays = timeTuesday.range;
+var timeWednesdays = timeWednesday.range;
+var timeThursdays = timeThursday.range;
+var timeFridays = timeFriday.range;
+var timeSaturdays = timeSaturday.range;
+function utcWeekday(i) {
+  return timeInterval((date2) => {
+    date2.setUTCDate(date2.getUTCDate() - (date2.getUTCDay() + 7 - i) % 7);
+    date2.setUTCHours(0, 0, 0, 0);
+  }, (date2, step) => {
+    date2.setUTCDate(date2.getUTCDate() + step * 7);
+  }, (start, end) => {
+    return (end - start) / durationWeek;
+  });
+}
+var utcSunday = utcWeekday(0);
+var utcMonday = utcWeekday(1);
+var utcTuesday = utcWeekday(2);
+var utcWednesday = utcWeekday(3);
+var utcThursday = utcWeekday(4);
+var utcFriday = utcWeekday(5);
+var utcSaturday = utcWeekday(6);
+var utcSundays = utcSunday.range;
+var utcMondays = utcMonday.range;
+var utcTuesdays = utcTuesday.range;
+var utcWednesdays = utcWednesday.range;
+var utcThursdays = utcThursday.range;
+var utcFridays = utcFriday.range;
+var utcSaturdays = utcSaturday.range;
+
+// ../../node_modules/.bun/d3-time@3.1.0/node_modules/d3-time/src/month.js
+var timeMonth = timeInterval((date2) => {
+  date2.setDate(1);
+  date2.setHours(0, 0, 0, 0);
+}, (date2, step) => {
+  date2.setMonth(date2.getMonth() + step);
+}, (start, end) => {
+  return end.getMonth() - start.getMonth() + (end.getFullYear() - start.getFullYear()) * 12;
+}, (date2) => {
+  return date2.getMonth();
+});
+var timeMonths = timeMonth.range;
+var utcMonth = timeInterval((date2) => {
+  date2.setUTCDate(1);
+  date2.setUTCHours(0, 0, 0, 0);
+}, (date2, step) => {
+  date2.setUTCMonth(date2.getUTCMonth() + step);
+}, (start, end) => {
+  return end.getUTCMonth() - start.getUTCMonth() + (end.getUTCFullYear() - start.getUTCFullYear()) * 12;
+}, (date2) => {
+  return date2.getUTCMonth();
+});
+var utcMonths = utcMonth.range;
+
+// ../../node_modules/.bun/d3-time@3.1.0/node_modules/d3-time/src/year.js
+var timeYear = timeInterval((date2) => {
+  date2.setMonth(0, 1);
+  date2.setHours(0, 0, 0, 0);
+}, (date2, step) => {
+  date2.setFullYear(date2.getFullYear() + step);
+}, (start, end) => {
+  return end.getFullYear() - start.getFullYear();
+}, (date2) => {
+  return date2.getFullYear();
+});
+timeYear.every = (k) => {
+  return !isFinite(k = Math.floor(k)) || !(k > 0) ? null : timeInterval((date2) => {
+    date2.setFullYear(Math.floor(date2.getFullYear() / k) * k);
+    date2.setMonth(0, 1);
+    date2.setHours(0, 0, 0, 0);
+  }, (date2, step) => {
+    date2.setFullYear(date2.getFullYear() + step * k);
+  });
+};
+var timeYears = timeYear.range;
+var utcYear = timeInterval((date2) => {
+  date2.setUTCMonth(0, 1);
+  date2.setUTCHours(0, 0, 0, 0);
+}, (date2, step) => {
+  date2.setUTCFullYear(date2.getUTCFullYear() + step);
+}, (start, end) => {
+  return end.getUTCFullYear() - start.getUTCFullYear();
+}, (date2) => {
+  return date2.getUTCFullYear();
+});
+utcYear.every = (k) => {
+  return !isFinite(k = Math.floor(k)) || !(k > 0) ? null : timeInterval((date2) => {
+    date2.setUTCFullYear(Math.floor(date2.getUTCFullYear() / k) * k);
+    date2.setUTCMonth(0, 1);
+    date2.setUTCHours(0, 0, 0, 0);
+  }, (date2, step) => {
+    date2.setUTCFullYear(date2.getUTCFullYear() + step * k);
+  });
+};
+var utcYears = utcYear.range;
+
+// ../../node_modules/.bun/d3-time@3.1.0/node_modules/d3-time/src/ticks.js
+function ticker(year, month, week, day, hour, minute) {
+  const tickIntervals = [
+    [second, 1, durationSecond],
+    [second, 5, 5 * durationSecond],
+    [second, 15, 15 * durationSecond],
+    [second, 30, 30 * durationSecond],
+    [minute, 1, durationMinute],
+    [minute, 5, 5 * durationMinute],
+    [minute, 15, 15 * durationMinute],
+    [minute, 30, 30 * durationMinute],
+    [hour, 1, durationHour],
+    [hour, 3, 3 * durationHour],
+    [hour, 6, 6 * durationHour],
+    [hour, 12, 12 * durationHour],
+    [day, 1, durationDay],
+    [day, 2, 2 * durationDay],
+    [week, 1, durationWeek],
+    [month, 1, durationMonth],
+    [month, 3, 3 * durationMonth],
+    [year, 1, durationYear]
+  ];
+  function ticks2(start, stop, count) {
+    const reverse = stop < start;
+    if (reverse) [start, stop] = [stop, start];
+    const interval = count && typeof count.range === "function" ? count : tickInterval(start, stop, count);
+    const ticks3 = interval ? interval.range(start, +stop + 1) : [];
+    return reverse ? ticks3.reverse() : ticks3;
+  }
+  function tickInterval(start, stop, count) {
+    const target = Math.abs(stop - start) / count;
+    const i = bisector(([, , step2]) => step2).right(tickIntervals, target);
+    if (i === tickIntervals.length) return year.every(tickStep(start / durationYear, stop / durationYear, count));
+    if (i === 0) return millisecond.every(Math.max(tickStep(start, stop, count), 1));
+    const [t, step] = tickIntervals[target / tickIntervals[i - 1][2] < tickIntervals[i][2] / target ? i - 1 : i];
+    return t.every(step);
+  }
+  return [ticks2, tickInterval];
+}
+var [utcTicks, utcTickInterval] = ticker(utcYear, utcMonth, utcSunday, unixDay, utcHour, utcMinute);
+var [timeTicks, timeTickInterval] = ticker(timeYear, timeMonth, timeSunday, timeDay, timeHour, timeMinute);
+
+// ../../node_modules/.bun/d3-time-format@4.1.0/node_modules/d3-time-format/src/locale.js
+function localDate(d) {
+  if (0 <= d.y && d.y < 100) {
+    var date2 = new Date(-1, d.m, d.d, d.H, d.M, d.S, d.L);
+    date2.setFullYear(d.y);
+    return date2;
+  }
+  return new Date(d.y, d.m, d.d, d.H, d.M, d.S, d.L);
+}
+function utcDate(d) {
+  if (0 <= d.y && d.y < 100) {
+    var date2 = new Date(Date.UTC(-1, d.m, d.d, d.H, d.M, d.S, d.L));
+    date2.setUTCFullYear(d.y);
+    return date2;
+  }
+  return new Date(Date.UTC(d.y, d.m, d.d, d.H, d.M, d.S, d.L));
+}
+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;
+  var periodRe = formatRe(locale_periods), periodLookup = formatLookup(locale_periods), weekdayRe = formatRe(locale_weekdays), weekdayLookup = formatLookup(locale_weekdays), shortWeekdayRe = formatRe(locale_shortWeekdays), shortWeekdayLookup = formatLookup(locale_shortWeekdays), monthRe = formatRe(locale_months), monthLookup = formatLookup(locale_months), shortMonthRe = formatRe(locale_shortMonths), shortMonthLookup = formatLookup(locale_shortMonths);
+  var formats = {
+    "a": formatShortWeekday,
+    "A": formatWeekday,
+    "b": formatShortMonth,
+    "B": formatMonth,
+    "c": null,
+    "d": formatDayOfMonth,
+    "e": formatDayOfMonth,
+    "f": formatMicroseconds,
+    "g": formatYearISO,
+    "G": formatFullYearISO,
+    "H": formatHour24,
+    "I": formatHour12,
+    "j": formatDayOfYear,
+    "L": formatMilliseconds,
+    "m": formatMonthNumber,
+    "M": formatMinutes,
+    "p": formatPeriod,
+    "q": formatQuarter,
+    "Q": formatUnixTimestamp,
+    "s": formatUnixTimestampSeconds,
+    "S": formatSeconds,
+    "u": formatWeekdayNumberMonday,
+    "U": formatWeekNumberSunday,
+    "V": formatWeekNumberISO,
+    "w": formatWeekdayNumberSunday,
+    "W": formatWeekNumberMonday,
+    "x": null,
+    "X": null,
+    "y": formatYear,
+    "Y": formatFullYear,
+    "Z": formatZone,
+    "%": formatLiteralPercent
+  };
+  var utcFormats = {
+    "a": formatUTCShortWeekday,
+    "A": formatUTCWeekday,
+    "b": formatUTCShortMonth,
+    "B": formatUTCMonth,
+    "c": null,
+    "d": formatUTCDayOfMonth,
+    "e": formatUTCDayOfMonth,
+    "f": formatUTCMicroseconds,
+    "g": formatUTCYearISO,
+    "G": formatUTCFullYearISO,
+    "H": formatUTCHour24,
+    "I": formatUTCHour12,
+    "j": formatUTCDayOfYear,
+    "L": formatUTCMilliseconds,
+    "m": formatUTCMonthNumber,
+    "M": formatUTCMinutes,
+    "p": formatUTCPeriod,
+    "q": formatUTCQuarter,
+    "Q": formatUnixTimestamp,
+    "s": formatUnixTimestampSeconds,
+    "S": formatUTCSeconds,
+    "u": formatUTCWeekdayNumberMonday,
+    "U": formatUTCWeekNumberSunday,
+    "V": formatUTCWeekNumberISO,
+    "w": formatUTCWeekdayNumberSunday,
+    "W": formatUTCWeekNumberMonday,
+    "x": null,
+    "X": null,
+    "y": formatUTCYear,
+    "Y": formatUTCFullYear,
+    "Z": formatUTCZone,
+    "%": formatLiteralPercent
+  };
+  var parses = {
+    "a": parseShortWeekday,
+    "A": parseWeekday,
+    "b": parseShortMonth,
+    "B": parseMonth,
+    "c": parseLocaleDateTime,
+    "d": parseDayOfMonth,
+    "e": parseDayOfMonth,
+    "f": parseMicroseconds,
+    "g": parseYear,
+    "G": parseFullYear,
+    "H": parseHour24,
+    "I": parseHour24,
+    "j": parseDayOfYear,
+    "L": parseMilliseconds,
+    "m": parseMonthNumber,
+    "M": parseMinutes,
+    "p": parsePeriod,
+    "q": parseQuarter,
+    "Q": parseUnixTimestamp,
+    "s": parseUnixTimestampSeconds,
+    "S": parseSeconds,
+    "u": parseWeekdayNumberMonday,
+    "U": parseWeekNumberSunday,
+    "V": parseWeekNumberISO,
+    "w": parseWeekdayNumberSunday,
+    "W": parseWeekNumberMonday,
+    "x": parseLocaleDate,
+    "X": parseLocaleTime,
+    "y": parseYear,
+    "Y": parseFullYear,
+    "Z": parseZone,
+    "%": parseLiteralPercent
+  };
+  formats.x = newFormat(locale_date, formats);
+  formats.X = newFormat(locale_time, formats);
+  formats.c = newFormat(locale_dateTime, formats);
+  utcFormats.x = newFormat(locale_date, utcFormats);
+  utcFormats.X = newFormat(locale_time, utcFormats);
+  utcFormats.c = newFormat(locale_dateTime, utcFormats);
+  function newFormat(specifier, formats2) {
+    return function(date2) {
+      var string = [], i = -1, j = 0, n = specifier.length, c, pad2, format2;
+      if (!(date2 instanceof Date)) date2 = /* @__PURE__ */ new Date(+date2);
+      while (++i < n) {
+        if (specifier.charCodeAt(i) === 37) {
+          string.push(specifier.slice(j, i));
+          if ((pad2 = pads[c = specifier.charAt(++i)]) != null) c = specifier.charAt(++i);
+          else pad2 = c === "e" ? " " : "0";
+          if (format2 = formats2[c]) c = format2(date2, pad2);
+          string.push(c);
+          j = i + 1;
+        }
+      }
+      string.push(specifier.slice(j, i));
+      return string.join("");
+    };
+  }
+  function newParse(specifier, Z) {
+    return function(string) {
+      var d = newDate(1900, void 0, 1), i = parseSpecifier(d, specifier, string += "", 0), week, day;
+      if (i != string.length) return null;
+      if ("Q" in d) return new Date(d.Q);
+      if ("s" in d) return new Date(d.s * 1e3 + ("L" in d ? d.L : 0));
+      if (Z && !("Z" in d)) d.Z = 0;
+      if ("p" in d) d.H = d.H % 12 + d.p * 12;
+      if (d.m === void 0) d.m = "q" in d ? d.q : 0;
+      if ("V" in d) {
+        if (d.V < 1 || d.V > 53) return null;
+        if (!("w" in d)) d.w = 1;
+        if ("Z" in d) {
+          week = utcDate(newDate(d.y, 0, 1)), day = week.getUTCDay();
+          week = day > 4 || day === 0 ? utcMonday.ceil(week) : utcMonday(week);
+          week = utcDay.offset(week, (d.V - 1) * 7);
+          d.y = week.getUTCFullYear();
+          d.m = week.getUTCMonth();
+          d.d = week.getUTCDate() + (d.w + 6) % 7;
+        } else {
+          week = localDate(newDate(d.y, 0, 1)), day = week.getDay();
+          week = day > 4 || day === 0 ? timeMonday.ceil(week) : timeMonday(week);
+          week = timeDay.offset(week, (d.V - 1) * 7);
+          d.y = week.getFullYear();
+          d.m = week.getMonth();
+          d.d = week.getDate() + (d.w + 6) % 7;
+        }
+      } else if ("W" in d || "U" in d) {
+        if (!("w" in d)) d.w = "u" in d ? d.u % 7 : "W" in d ? 1 : 0;
+        day = "Z" in d ? utcDate(newDate(d.y, 0, 1)).getUTCDay() : localDate(newDate(d.y, 0, 1)).getDay();
+        d.m = 0;
+        d.d = "W" in d ? (d.w + 6) % 7 + d.W * 7 - (day + 5) % 7 : d.w + d.U * 7 - (day + 6) % 7;
+      }
+      if ("Z" in d) {
+        d.H += d.Z / 100 | 0;
+        d.M += d.Z % 100;
+        return utcDate(d);
+      }
+      return localDate(d);
     };
-    marks.push({
-      type: "arc",
-      path,
-      centroid: {
-        x: centroidResult[0] + centerX,
-        y: centroidResult[1] + centerY
-      },
-      center,
-      innerRadius,
-      outerRadius,
-      startAngle: arcDatum.startAngle,
-      endAngle: arcDatum.endAngle,
-      fill: color,
-      stroke: "#ffffff",
-      strokeWidth: 2,
-      data: slice.originalRow,
-      aria
-    });
   }
-  return marks;
-}
-
-// 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 [];
-  if (density === "none") return [];
-  const centerX = marks[0].center.x;
-  const centerY = marks[0].center.y;
-  const targetMarks = density === "endpoints" && marks.length > 1 ? [marks[0], marks[marks.length - 1]] : marks;
-  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"
+  function parseSpecifier(d, specifier, string, j) {
+    var i = 0, n = specifier.length, m = string.length, c, parse;
+    while (i < n) {
+      if (j >= m) return -1;
+      c = specifier.charCodeAt(i++);
+      if (c === 37) {
+        c = specifier.charAt(i++);
+        parse = parses[c in pads ? specifier.charAt(i++) : c];
+        if (!parse || (j = parse(d, string, j)) < 0) return -1;
+      } else if (c != string.charCodeAt(j++)) {
+        return -1;
       }
-    });
-    targetMarkIndices.push(mi);
+    }
+    return j;
   }
-  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);
+  function parsePeriod(d, string, i) {
+    var n = periodRe.exec(string.slice(i));
+    return n ? (d.p = periodLookup.get(n[0].toLowerCase()), i + n[0].length) : -1;
   }
-  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"
+  function parseShortWeekday(d, string, i) {
+    var n = shortWeekdayRe.exec(string.slice(i));
+    return n ? (d.w = shortWeekdayLookup.get(n[0].toLowerCase()), i + n[0].length) : -1;
+  }
+  function parseWeekday(d, string, i) {
+    var n = weekdayRe.exec(string.slice(i));
+    return n ? (d.w = weekdayLookup.get(n[0].toLowerCase()), i + n[0].length) : -1;
+  }
+  function parseShortMonth(d, string, i) {
+    var n = shortMonthRe.exec(string.slice(i));
+    return n ? (d.m = shortMonthLookup.get(n[0].toLowerCase()), i + n[0].length) : -1;
+  }
+  function parseMonth(d, string, i) {
+    var n = monthRe.exec(string.slice(i));
+    return n ? (d.m = monthLookup.get(n[0].toLowerCase()), i + n[0].length) : -1;
+  }
+  function parseLocaleDateTime(d, string, i) {
+    return parseSpecifier(d, locale_dateTime, string, i);
+  }
+  function parseLocaleDate(d, string, i) {
+    return parseSpecifier(d, locale_date, string, i);
+  }
+  function parseLocaleTime(d, string, i) {
+    return parseSpecifier(d, locale_time, string, i);
+  }
+  function formatShortWeekday(d) {
+    return locale_shortWeekdays[d.getDay()];
+  }
+  function formatWeekday(d) {
+    return locale_weekdays[d.getDay()];
+  }
+  function formatShortMonth(d) {
+    return locale_shortMonths[d.getMonth()];
+  }
+  function formatMonth(d) {
+    return locale_months[d.getMonth()];
+  }
+  function formatPeriod(d) {
+    return locale_periods[+(d.getHours() >= 12)];
+  }
+  function formatQuarter(d) {
+    return 1 + ~~(d.getMonth() / 3);
+  }
+  function formatUTCShortWeekday(d) {
+    return locale_shortWeekdays[d.getUTCDay()];
+  }
+  function formatUTCWeekday(d) {
+    return locale_weekdays[d.getUTCDay()];
+  }
+  function formatUTCShortMonth(d) {
+    return locale_shortMonths[d.getUTCMonth()];
+  }
+  function formatUTCMonth(d) {
+    return locale_months[d.getUTCMonth()];
+  }
+  function formatUTCPeriod(d) {
+    return locale_periods[+(d.getUTCHours() >= 12)];
+  }
+  function formatUTCQuarter(d) {
+    return 1 + ~~(d.getUTCMonth() / 3);
+  }
+  return {
+    format: function(specifier) {
+      var f = newFormat(specifier += "", formats);
+      f.toString = function() {
+        return specifier;
       };
+      return f;
+    },
+    parse: function(specifier) {
+      var p = newParse(specifier += "", false);
+      p.toString = function() {
+        return specifier;
+      };
+      return p;
+    },
+    utcFormat: function(specifier) {
+      var f = newFormat(specifier += "", utcFormats);
+      f.toString = function() {
+        return specifier;
+      };
+      return f;
+    },
+    utcParse: function(specifier) {
+      var p = newParse(specifier += "", true);
+      p.toString = function() {
+        return specifier;
+      };
+      return p;
     }
-  }
-  return resolved;
+  };
+}
+var pads = { "-": "", "_": " ", "0": "0" };
+var numberRe = /^\s*\d+/;
+var percentRe = /^%/;
+var requoteRe = /[\\^$*+?|[\]().{}]/g;
+function pad(value, fill, width) {
+  var sign2 = value < 0 ? "-" : "", string = (sign2 ? -value : value) + "", length = string.length;
+  return sign2 + (length < width ? new Array(width - length + 1).join(fill) + string : string);
+}
+function requote(s) {
+  return s.replace(requoteRe, "\\$&");
+}
+function formatRe(names) {
+  return new RegExp("^(?:" + names.map(requote).join("|") + ")", "i");
+}
+function formatLookup(names) {
+  return new Map(names.map((name, i) => [name.toLowerCase(), i]));
+}
+function parseWeekdayNumberSunday(d, string, i) {
+  var n = numberRe.exec(string.slice(i, i + 1));
+  return n ? (d.w = +n[0], i + n[0].length) : -1;
+}
+function parseWeekdayNumberMonday(d, string, i) {
+  var n = numberRe.exec(string.slice(i, i + 1));
+  return n ? (d.u = +n[0], i + n[0].length) : -1;
+}
+function parseWeekNumberSunday(d, string, i) {
+  var n = numberRe.exec(string.slice(i, i + 2));
+  return n ? (d.U = +n[0], i + n[0].length) : -1;
+}
+function parseWeekNumberISO(d, string, i) {
+  var n = numberRe.exec(string.slice(i, i + 2));
+  return n ? (d.V = +n[0], i + n[0].length) : -1;
+}
+function parseWeekNumberMonday(d, string, i) {
+  var n = numberRe.exec(string.slice(i, i + 2));
+  return n ? (d.W = +n[0], i + n[0].length) : -1;
+}
+function parseFullYear(d, string, i) {
+  var n = numberRe.exec(string.slice(i, i + 4));
+  return n ? (d.y = +n[0], i + n[0].length) : -1;
+}
+function parseYear(d, string, i) {
+  var n = numberRe.exec(string.slice(i, i + 2));
+  return n ? (d.y = +n[0] + (+n[0] > 68 ? 1900 : 2e3), i + n[0].length) : -1;
+}
+function parseZone(d, string, i) {
+  var n = /^(Z)|([+-]\d\d)(?::?(\d\d))?/.exec(string.slice(i, i + 6));
+  return n ? (d.Z = n[1] ? 0 : -(n[2] + (n[3] || "00")), i + n[0].length) : -1;
+}
+function parseQuarter(d, string, i) {
+  var n = numberRe.exec(string.slice(i, i + 1));
+  return n ? (d.q = n[0] * 3 - 3, i + n[0].length) : -1;
+}
+function parseMonthNumber(d, string, i) {
+  var n = numberRe.exec(string.slice(i, i + 2));
+  return n ? (d.m = n[0] - 1, i + n[0].length) : -1;
+}
+function parseDayOfMonth(d, string, i) {
+  var n = numberRe.exec(string.slice(i, i + 2));
+  return n ? (d.d = +n[0], i + n[0].length) : -1;
+}
+function parseDayOfYear(d, string, i) {
+  var n = numberRe.exec(string.slice(i, i + 3));
+  return n ? (d.m = 0, d.d = +n[0], i + n[0].length) : -1;
+}
+function parseHour24(d, string, i) {
+  var n = numberRe.exec(string.slice(i, i + 2));
+  return n ? (d.H = +n[0], i + n[0].length) : -1;
+}
+function parseMinutes(d, string, i) {
+  var n = numberRe.exec(string.slice(i, i + 2));
+  return n ? (d.M = +n[0], i + n[0].length) : -1;
+}
+function parseSeconds(d, string, i) {
+  var n = numberRe.exec(string.slice(i, i + 2));
+  return n ? (d.S = +n[0], i + n[0].length) : -1;
+}
+function parseMilliseconds(d, string, i) {
+  var n = numberRe.exec(string.slice(i, i + 3));
+  return n ? (d.L = +n[0], i + n[0].length) : -1;
+}
+function parseMicroseconds(d, string, i) {
+  var n = numberRe.exec(string.slice(i, i + 6));
+  return n ? (d.L = Math.floor(n[0] / 1e3), i + n[0].length) : -1;
+}
+function parseLiteralPercent(d, string, i) {
+  var n = percentRe.exec(string.slice(i, i + 1));
+  return n ? i + n[0].length : -1;
+}
+function parseUnixTimestamp(d, string, i) {
+  var n = numberRe.exec(string.slice(i));
+  return n ? (d.Q = +n[0], i + n[0].length) : -1;
+}
+function parseUnixTimestampSeconds(d, string, i) {
+  var n = numberRe.exec(string.slice(i));
+  return n ? (d.s = +n[0], i + n[0].length) : -1;
+}
+function formatDayOfMonth(d, p) {
+  return pad(d.getDate(), p, 2);
+}
+function formatHour24(d, p) {
+  return pad(d.getHours(), p, 2);
+}
+function formatHour12(d, p) {
+  return pad(d.getHours() % 12 || 12, p, 2);
+}
+function formatDayOfYear(d, p) {
+  return pad(1 + timeDay.count(timeYear(d), d), p, 3);
+}
+function formatMilliseconds(d, p) {
+  return pad(d.getMilliseconds(), p, 3);
+}
+function formatMicroseconds(d, p) {
+  return formatMilliseconds(d, p) + "000";
+}
+function formatMonthNumber(d, p) {
+  return pad(d.getMonth() + 1, p, 2);
+}
+function formatMinutes(d, p) {
+  return pad(d.getMinutes(), p, 2);
+}
+function formatSeconds(d, p) {
+  return pad(d.getSeconds(), p, 2);
+}
+function formatWeekdayNumberMonday(d) {
+  var day = d.getDay();
+  return day === 0 ? 7 : day;
+}
+function formatWeekNumberSunday(d, p) {
+  return pad(timeSunday.count(timeYear(d) - 1, d), p, 2);
+}
+function dISO(d) {
+  var day = d.getDay();
+  return day >= 4 || day === 0 ? timeThursday(d) : timeThursday.ceil(d);
+}
+function formatWeekNumberISO(d, p) {
+  d = dISO(d);
+  return pad(timeThursday.count(timeYear(d), d) + (timeYear(d).getDay() === 4), p, 2);
+}
+function formatWeekdayNumberSunday(d) {
+  return d.getDay();
+}
+function formatWeekNumberMonday(d, p) {
+  return pad(timeMonday.count(timeYear(d) - 1, d), p, 2);
+}
+function formatYear(d, p) {
+  return pad(d.getFullYear() % 100, p, 2);
+}
+function formatYearISO(d, p) {
+  d = dISO(d);
+  return pad(d.getFullYear() % 100, p, 2);
+}
+function formatFullYear(d, p) {
+  return pad(d.getFullYear() % 1e4, p, 4);
+}
+function formatFullYearISO(d, p) {
+  var day = d.getDay();
+  d = day >= 4 || day === 0 ? timeThursday(d) : timeThursday.ceil(d);
+  return pad(d.getFullYear() % 1e4, p, 4);
+}
+function formatZone(d) {
+  var z = d.getTimezoneOffset();
+  return (z > 0 ? "-" : (z *= -1, "+")) + pad(z / 60 | 0, "0", 2) + pad(z % 60, "0", 2);
+}
+function formatUTCDayOfMonth(d, p) {
+  return pad(d.getUTCDate(), p, 2);
+}
+function formatUTCHour24(d, p) {
+  return pad(d.getUTCHours(), p, 2);
+}
+function formatUTCHour12(d, p) {
+  return pad(d.getUTCHours() % 12 || 12, p, 2);
+}
+function formatUTCDayOfYear(d, p) {
+  return pad(1 + utcDay.count(utcYear(d), d), p, 3);
+}
+function formatUTCMilliseconds(d, p) {
+  return pad(d.getUTCMilliseconds(), p, 3);
+}
+function formatUTCMicroseconds(d, p) {
+  return formatUTCMilliseconds(d, p) + "000";
+}
+function formatUTCMonthNumber(d, p) {
+  return pad(d.getUTCMonth() + 1, p, 2);
+}
+function formatUTCMinutes(d, p) {
+  return pad(d.getUTCMinutes(), p, 2);
+}
+function formatUTCSeconds(d, p) {
+  return pad(d.getUTCSeconds(), p, 2);
+}
+function formatUTCWeekdayNumberMonday(d) {
+  var dow = d.getUTCDay();
+  return dow === 0 ? 7 : dow;
+}
+function formatUTCWeekNumberSunday(d, p) {
+  return pad(utcSunday.count(utcYear(d) - 1, d), p, 2);
+}
+function UTCdISO(d) {
+  var day = d.getUTCDay();
+  return day >= 4 || day === 0 ? utcThursday(d) : utcThursday.ceil(d);
+}
+function formatUTCWeekNumberISO(d, p) {
+  d = UTCdISO(d);
+  return pad(utcThursday.count(utcYear(d), d) + (utcYear(d).getUTCDay() === 4), p, 2);
+}
+function formatUTCWeekdayNumberSunday(d) {
+  return d.getUTCDay();
+}
+function formatUTCWeekNumberMonday(d, p) {
+  return pad(utcMonday.count(utcYear(d) - 1, d), p, 2);
+}
+function formatUTCYear(d, p) {
+  return pad(d.getUTCFullYear() % 100, p, 2);
+}
+function formatUTCYearISO(d, p) {
+  d = UTCdISO(d);
+  return pad(d.getUTCFullYear() % 100, p, 2);
+}
+function formatUTCFullYear(d, p) {
+  return pad(d.getUTCFullYear() % 1e4, p, 4);
+}
+function formatUTCFullYearISO(d, p) {
+  var day = d.getUTCDay();
+  d = day >= 4 || day === 0 ? utcThursday(d) : utcThursday.ceil(d);
+  return pad(d.getUTCFullYear() % 1e4, p, 4);
+}
+function formatUTCZone() {
+  return "+0000";
+}
+function formatLiteralPercent() {
+  return "%";
+}
+function formatUnixTimestamp(d) {
+  return +d;
+}
+function formatUnixTimestampSeconds(d) {
+  return Math.floor(+d / 1e3);
 }
 
-// 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];
+// ../../node_modules/.bun/d3-time-format@4.1.0/node_modules/d3-time-format/src/defaultLocale.js
+var locale2;
+var timeFormat;
+var timeParse;
+var utcFormat;
+var utcParse;
+defaultLocale2({
+  dateTime: "%x, %X",
+  date: "%-m/%-d/%Y",
+  time: "%-I:%M:%S %p",
+  periods: ["AM", "PM"],
+  days: ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"],
+  shortDays: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"],
+  months: ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"],
+  shortMonths: ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]
+});
+function defaultLocale2(definition) {
+  locale2 = formatLocale(definition);
+  timeFormat = locale2.format;
+  timeParse = locale2.parse;
+  utcFormat = locale2.utcFormat;
+  utcParse = locale2.utcParse;
+  return locale2;
+}
+
+// ../../node_modules/.bun/d3-scale@4.0.2/node_modules/d3-scale/src/time.js
+function date(t) {
+  return new Date(t);
+}
+function number3(t) {
+  return t instanceof Date ? +t : +/* @__PURE__ */ new Date(+t);
+}
+function calendar(ticks2, tickInterval, year, month, week, day, hour, minute, second2, format2) {
+  var scale = continuous(), invert = scale.invert, domain = scale.domain;
+  var formatMillisecond = format2(".%L"), formatSecond = format2(":%S"), formatMinute = format2("%I:%M"), formatHour = format2("%I %p"), formatDay = format2("%a %d"), formatWeek = format2("%b %d"), formatMonth = format2("%B"), formatYear2 = format2("%Y");
+  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);
   }
-  return marks;
-};
+  scale.invert = function(y2) {
+    return new Date(invert(y2));
+  };
+  scale.domain = function(_) {
+    return arguments.length ? domain(Array.from(_, number3)) : domain().map(date);
+  };
+  scale.ticks = function(interval) {
+    var d = domain();
+    return ticks2(d[0], d[d.length - 1], interval == null ? 10 : interval);
+  };
+  scale.tickFormat = function(count, specifier) {
+    return specifier == null ? tickFormat2 : format2(specifier);
+  };
+  scale.nice = function(interval) {
+    var d = domain();
+    if (!interval || typeof interval.range !== "function") interval = tickInterval(d[0], d[d.length - 1], interval == null ? 10 : interval);
+    return interval ? domain(nice(d, interval)) : scale;
+  };
+  scale.copy = function() {
+    return copy(scale, calendar(ticks2, tickInterval, year, month, week, day, hour, minute, second2, format2));
+  };
+  return scale;
+}
+function time() {
+  return initRange.apply(calendar(timeTicks, timeTickInterval, timeYear, timeMonth, timeSunday, timeDay, timeHour, timeMinute, second, timeFormat).domain([new Date(2e3, 0, 1), new Date(2e3, 0, 2)]), arguments);
+}
 
-// src/charts/registry.ts
-var renderers = /* @__PURE__ */ new Map();
-function registerChartRenderer(type, renderer) {
-  renderers.set(type, renderer);
+// ../../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(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];
+  };
+  scale.clamp = function(_) {
+    return arguments.length ? (clamp = !!_, scale) : clamp;
+  };
+  scale.interpolator = function(_) {
+    return arguments.length ? (interpolator = _, scale) : interpolator;
+  };
+  function range2(interpolate) {
+    return function(_) {
+      var r0, r1;
+      return arguments.length ? ([r0, r1] = _, interpolator = interpolate(r0, r1), scale) : [interpolator(0), interpolator(1)];
+    };
+  }
+  scale.range = range2(value_default);
+  scale.rangeRound = range2(round_default);
+  scale.unknown = function(_) {
+    return arguments.length ? (unknown = _, scale) : unknown;
+  };
+  return function(t) {
+    transform = t, t02 = t(x0), t12 = t(x1), k10 = t02 === t12 ? 0 : 1 / (t12 - t02);
+    return scale;
+  };
 }
-function getChartRenderer(type) {
-  return renderers.get(type);
+function copy2(source, target) {
+  return target.domain(source.domain()).interpolator(source.interpolator()).clamp(source.clamp()).unknown(source.unknown());
 }
-function clearRenderers() {
-  renderers.clear();
+function sequential() {
+  var scale = linearish(transformer2()(identity));
+  scale.copy = function() {
+    return copy2(scale, sequential());
+  };
+  return initInterpolator.apply(scale, arguments);
 }
 
 // src/charts/scatter/compute.ts
-import { max, min } from "d3-array";
-import { scaleSqrt } from "d3-scale";
 var DEFAULT_POINT_RADIUS2 = 5;
 var MIN_BUBBLE_RADIUS = 3;
 var MAX_BUBBLE_RADIUS = 30;
@@ -1709,9 +4818,9 @@ function computeScatterMarks(spec, scales, _chartArea, _strategy) {
   let sizeScale;
   if (sizeField) {
     const sizeValues = spec.data.map((d) => Number(d[sizeField])).filter((v) => Number.isFinite(v));
-    const sizeMin = min(sizeValues) ?? 0;
-    const sizeMax = max(sizeValues) ?? 1;
-    sizeScale = scaleSqrt().domain([sizeMin, sizeMax]).range([MIN_BUBBLE_RADIUS, MAX_BUBBLE_RADIUS]);
+    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) {
@@ -1721,7 +4830,7 @@ function computeScatterMarks(spec, scales, _chartArea, _strategy) {
     const cx = xScale(xVal);
     const cy = yScale(yVal);
     const category = colorField ? String(row[colorField] ?? "") : void 0;
-    const color = getColor(scales, category ?? "__default__");
+    const color2 = getColor(scales, category ?? "__default__");
     let radius = DEFAULT_POINT_RADIUS2;
     if (sizeScale && sizeField) {
       const sizeVal = Number(row[sizeField]);
@@ -1742,7 +4851,7 @@ function computeScatterMarks(spec, scales, _chartArea, _strategy) {
       cx,
       cy,
       r: radius,
-      fill: color,
+      fill: color2,
       stroke: "#ffffff",
       strokeWidth: 1,
       fillOpacity: 0.7,
@@ -1854,8 +4963,8 @@ function inferFieldType(data, field) {
         numericCount++;
         continue;
       }
-      const date = new Date(value);
-      if (!Number.isNaN(date.getTime())) {
+      const date2 = new Date(value);
+      if (!Number.isNaN(date2.getTime())) {
         dateCount++;
         continue;
       }
@@ -2466,8 +5575,6 @@ ${errorMessages}`);
 import { adaptTheme, computeChrome, resolveTheme } from "@opendata-ai/openchart-core";
 
 // src/graphs/encoding.ts
-import { max as max2, min as min2 } from "d3-array";
-import { scaleLinear, scaleOrdinal, scaleSqrt as scaleSqrt2 } from "d3-scale";
 var DEFAULT_NODE_RADIUS = 5;
 var MIN_NODE_RADIUS = 3;
 var MAX_NODE_RADIUS = 12;
@@ -2475,19 +5582,19 @@ var DEFAULT_EDGE_WIDTH = 1;
 var MIN_EDGE_WIDTH = 0.5;
 var MAX_EDGE_WIDTH = 4;
 var DEFAULT_STROKE_WIDTH2 = 1;
-function darkenColor(hex, amount = 0.2) {
-  const clean = hex.replace(/^#/, "");
-  if (clean.length !== 6 && clean.length !== 3) return hex;
+function darkenColor(hex2, amount = 0.2) {
+  const clean = hex2.replace(/^#/, "");
+  if (clean.length !== 6 && clean.length !== 3) return hex2;
   const full = clean.length === 3 ? clean.split("").map((c) => c + c).join("") : clean;
   const r = Math.max(0, Math.round(parseInt(full.substring(0, 2), 16) * (1 - amount)));
   const g = Math.max(0, Math.round(parseInt(full.substring(2, 4), 16) * (1 - amount)));
   const b = Math.max(0, Math.round(parseInt(full.substring(4, 6), 16) * (1 - amount)));
   return `#${r.toString(16).padStart(2, "0")}${g.toString(16).padStart(2, "0")}${b.toString(16).padStart(2, "0")}`;
 }
-function hexWithOpacity(hex, opacity) {
-  const clean = hex.replace(/^#/, "");
+function hexWithOpacity(hex2, opacity) {
+  const clean = hex2.replace(/^#/, "");
   if (clean.length !== 6 && clean.length !== 3) {
-    return hex;
+    return hex2;
   }
   const full = clean.length === 3 ? clean.split("").map((c) => c + c).join("") : clean;
   const r = parseInt(full.substring(0, 2), 16);
@@ -2515,7 +5622,7 @@ function resolveNodeVisuals(nodes, encoding, edges, theme, nodeOverrides) {
     const values = nodes.map((n) => Number(n[field])).filter((v) => Number.isFinite(v));
     const sizeMin = min2(values) ?? 0;
     const sizeMax = max2(values) ?? 1;
-    sizeScale = scaleSqrt2().domain([sizeMin, sizeMax]).range([MIN_NODE_RADIUS, MAX_NODE_RADIUS]);
+    sizeScale = sqrt2().domain([sizeMin, sizeMax]).range([MIN_NODE_RADIUS, MAX_NODE_RADIUS]);
   }
   let colorFn;
   if (encoding.nodeColor?.field) {
@@ -2527,14 +5634,14 @@ function resolveNodeVisuals(nodes, encoding, edges, theme, nodeOverrides) {
       const colorMax = max2(values) ?? 1;
       const seqPalettes = Object.values(theme.colors.sequential);
       const palette = seqPalettes.length > 0 ? seqPalettes[0] : ["#ccc", "#333"];
-      const colorScale = scaleLinear().domain([colorMin, colorMax]).range([palette[0], palette[palette.length - 1]]);
+      const colorScale = linear2().domain([colorMin, colorMax]).range([palette[0], palette[palette.length - 1]]);
       colorFn = (node) => {
         const val = Number(node[field]);
         return Number.isFinite(val) ? colorScale(val) : theme.colors.categorical[0];
       };
     } else {
       const uniqueValues = [...new Set(nodes.map((n) => String(n[field] ?? "")))];
-      const ordinalScale = scaleOrdinal().domain(uniqueValues).range(theme.colors.categorical);
+      const ordinalScale = ordinal().domain(uniqueValues).range(theme.colors.categorical);
       colorFn = (node) => ordinalScale(String(node[field] ?? ""));
     }
   }
@@ -2586,7 +5693,7 @@ function resolveEdgeVisuals(edges, encoding, theme) {
     const values = edges.map((e) => Number(e[field])).filter((v) => Number.isFinite(v));
     const widthMin = min2(values) ?? 0;
     const widthMax = max2(values) ?? 1;
-    widthScale = scaleLinear().domain([widthMin, widthMax]).range([MIN_EDGE_WIDTH, MAX_EDGE_WIDTH]);
+    widthScale = linear2().domain([widthMin, widthMax]).range([MIN_EDGE_WIDTH, MAX_EDGE_WIDTH]);
   }
   let edgeColorFn;
   if (encoding.edgeColor?.field) {
@@ -2598,14 +5705,14 @@ function resolveEdgeVisuals(edges, encoding, theme) {
       const colorMax = max2(values) ?? 1;
       const seqPalettes = Object.values(theme.colors.sequential);
       const palette = seqPalettes.length > 0 ? seqPalettes[0] : ["#ccc", "#333"];
-      const colorScale = scaleLinear().domain([colorMin, colorMax]).range([palette[0], palette[palette.length - 1]]);
+      const colorScale = linear2().domain([colorMin, colorMax]).range([palette[0], palette[palette.length - 1]]);
       edgeColorFn = (edge) => {
         const val = Number(edge[field]);
         return Number.isFinite(val) ? colorScale(val) : hexWithOpacity(theme.colors.axis, 0.4);
       };
     } else {
       const uniqueValues = [...new Set(edges.map((e) => String(e[field] ?? "")))];
-      const ordinalScale = scaleOrdinal().domain(uniqueValues).range(theme.colors.categorical);
+      const ordinalScale = ordinal().domain(uniqueValues).range(theme.colors.categorical);
       edgeColorFn = (edge) => ordinalScale(String(edge[field] ?? ""));
     }
   }
@@ -2689,9 +5796,9 @@ function buildGraphLegend(nodes, communityColorMap, hasCommunities, theme) {
   };
   let entries;
   if (hasCommunities && communityColorMap.size > 0) {
-    entries = [...communityColorMap.entries()].map(([label, color]) => ({
+    entries = [...communityColorMap.entries()].map(([label, color2]) => ({
       label,
-      color,
+      color: color2,
       shape: "circle",
       active: true
     }));
@@ -2705,9 +5812,9 @@ function buildGraphLegend(nodes, communityColorMap, hasCommunities, theme) {
     if (colorLabels.size <= 1) {
       entries = [];
     } else {
-      entries = [...colorLabels.entries()].map(([color, label]) => ({
+      entries = [...colorLabels.entries()].map(([color2, label]) => ({
         label,
-        color,
+        color: color2,
         shape: "circle",
         active: true
       }));
@@ -2836,8 +5943,12 @@ function compileGraph(spec, options) {
 var DEFAULT_COLLISION_PADDING = 5;
 
 // src/layout/axes.ts
-import { abbreviateNumber as abbreviateNumber3, formatDate, formatNumber as formatNumber3 } from "@opendata-ai/openchart-core";
-import { format as d3Format2 } from "d3-format";
+import {
+  abbreviateNumber as abbreviateNumber3,
+  buildD3Formatter as buildD3Formatter3,
+  formatDate,
+  formatNumber as formatNumber3
+} from "@opendata-ai/openchart-core";
 var TICK_COUNTS = {
   full: 8,
   reduced: 5,
@@ -2862,8 +5973,8 @@ function effectiveDensity(baseDensity, axisLength, minimalThreshold, reducedThre
 function continuousTicks(resolvedScale, density) {
   const scale = resolvedScale.scale;
   const count = resolvedScale.channel.axis?.tickCount ?? TICK_COUNTS[density];
-  const ticks = scale.ticks(count);
-  return ticks.map((value) => ({
+  const ticks2 = scale.ticks(count);
+  return ticks2.map((value) => ({
     value,
     position: scale(value),
     label: formatTickLabel(value, resolvedScale)
@@ -2898,17 +6009,8 @@ function formatTickLabel(value, resolvedScale) {
   if (resolvedScale.type === "linear" || resolvedScale.type === "log") {
     const num = value;
     if (formatStr) {
-      try {
-        return d3Format2(formatStr)(num);
-      } catch {
-        const suffixMatch = formatStr.match(/^(.+[a-z])([^a-z]+)$/i);
-        if (suffixMatch) {
-          try {
-            return d3Format2(suffixMatch[1])(num) + suffixMatch[2];
-          } catch {
-          }
-        }
-      }
+      const fmt = buildD3Formatter3(formatStr);
+      if (fmt) return fmt(num);
     }
     if (Math.abs(num) >= 1e3) return abbreviateNumber3(num);
     return formatNumber3(num);
@@ -2946,13 +6048,13 @@ function computeAxes(scales, chartArea, strategy, theme) {
     lineHeight: 1.3
   };
   if (scales.x) {
-    const ticks = scales.x.type === "band" || scales.x.type === "point" || scales.x.type === "ordinal" ? categoricalTicks(scales.x, xDensity) : continuousTicks(scales.x, xDensity);
-    const gridlines = ticks.map((t) => ({
+    const ticks2 = scales.x.type === "band" || scales.x.type === "point" || scales.x.type === "ordinal" ? categoricalTicks(scales.x, xDensity) : continuousTicks(scales.x, xDensity);
+    const gridlines = ticks2.map((t) => ({
       position: t.position,
       major: true
     }));
     result.x = {
-      ticks,
+      ticks: ticks2,
       gridlines: scales.x.channel.axis?.grid ? gridlines : [],
       label: scales.x.channel.axis?.label,
       labelStyle: axisLabelStyle,
@@ -2963,13 +6065,13 @@ function computeAxes(scales, chartArea, strategy, theme) {
     };
   }
   if (scales.y) {
-    const ticks = scales.y.type === "band" || scales.y.type === "point" || scales.y.type === "ordinal" ? categoricalTicks(scales.y, yDensity) : continuousTicks(scales.y, yDensity);
-    const gridlines = ticks.map((t) => ({
+    const ticks2 = scales.y.type === "band" || scales.y.type === "point" || scales.y.type === "ordinal" ? categoricalTicks(scales.y, yDensity) : continuousTicks(scales.y, yDensity);
+    const gridlines = ticks2.map((t) => ({
       position: t.position,
       major: true
     }));
     result.y = {
-      ticks,
+      ticks: ticks2,
       // Y-axis gridlines are shown by default (standard editorial practice)
       gridlines,
       label: scales.y.channel.axis?.label,
@@ -3138,8 +6240,6 @@ function computeGridlines(axes, chartArea, showVertical = false) {
 }
 
 // src/layout/scales.ts
-import { extent, max as max3, min as min3 } from "d3-array";
-import { scaleBand, scaleLinear as scaleLinear2, scaleLog, scaleOrdinal as scaleOrdinal2, scalePoint, scaleTime } from "d3-scale";
 function fieldValues(data, field) {
   return data.map((d) => d[field]).filter((v) => v != null);
 }
@@ -3164,7 +6264,7 @@ function uniqueStrings(values) {
 function buildTimeScale(channel, data, rangeStart, rangeEnd) {
   const values = parseDates(fieldValues(data, channel.field));
   const domain = channel.scale?.domain ? [new Date(channel.scale.domain[0]), new Date(channel.scale.domain[1])] : extent(values);
-  const scale = scaleTime().domain(domain).range([rangeStart, rangeEnd]);
+  const scale = time().domain(domain).range([rangeStart, rangeEnd]);
   if (channel.scale?.nice !== false) {
     scale.nice();
   }
@@ -3179,14 +6279,14 @@ function buildLinearScale(channel, data, rangeStart, rangeEnd) {
     domainMin = d0;
     domainMax = d1;
   } else {
-    domainMin = min3(values) ?? 0;
-    domainMax = max3(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 = scaleLinear2().domain([domainMin, domainMax]).range([rangeStart, rangeEnd]);
+  const scale = linear2().domain([domainMin, domainMax]).range([rangeStart, rangeEnd]);
   if (channel.scale?.nice !== false) {
     scale.nice();
   }
@@ -3194,31 +6294,31 @@ 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 = min3(values) ?? 1;
-  const domainMax = max3(values) ?? 10;
-  const scale = scaleLog().domain([domainMin, domainMax]).range([rangeStart, rangeEnd]).nice();
+  const domainMin = min2(values) ?? 1;
+  const domainMax = max2(values) ?? 10;
+  const scale = log().domain([domainMin, domainMax]).range([rangeStart, rangeEnd]).nice();
   return { scale, type: "log", channel };
 }
 function buildBandScale(channel, data, rangeStart, rangeEnd) {
   const values = channel.scale?.domain ? channel.scale.domain : uniqueStrings(fieldValues(data, channel.field));
-  const scale = scaleBand().domain(values).range([rangeStart, rangeEnd]).padding(0.35);
+  const scale = band().domain(values).range([rangeStart, rangeEnd]).padding(0.35);
   return { scale, type: "band", channel };
 }
 function buildPointScale(channel, data, rangeStart, rangeEnd) {
   const values = channel.scale?.domain ? channel.scale.domain : uniqueStrings(fieldValues(data, channel.field));
-  const scale = scalePoint().domain(values).range([rangeStart, rangeEnd]).padding(0.5);
+  const scale = point2().domain(values).range([rangeStart, rangeEnd]).padding(0.5);
   return { scale, type: "point", channel };
 }
 function buildOrdinalColorScale(channel, data, palette) {
   const values = uniqueStrings(fieldValues(data, channel.field));
-  const scale = scaleOrdinal2().domain(values).range(palette);
+  const scale = ordinal().domain(values).range(palette);
   return { scale, type: "ordinal", channel };
 }
 function buildSequentialColorScale(channel, data, palette) {
   const values = parseNumbers(fieldValues(data, channel.field));
-  const domainMin = min3(values) ?? 0;
-  const domainMax = max3(values) ?? 1;
-  const scale = scaleLinear2().domain([domainMin, domainMax]).range([palette[0], palette[palette.length - 1]]).clamp(true);
+  const domainMin = min2(values) ?? 0;
+  const domainMax = max2(values) ?? 1;
+  const scale = linear2().domain([domainMin, domainMax]).range([palette[0], palette[palette.length - 1]]).clamp(true);
   return { scale, type: "sequential", channel };
 }
 function buildPositionalScale(channel, data, rangeStart, rangeEnd, chartType, axis) {
@@ -3381,6 +6481,23 @@ function extractColorEntries(spec, theme) {
   }));
 }
 function computeLegend(spec, strategy, theme, chartArea) {
+  if (spec.legend?.show === false) {
+    return {
+      position: "top",
+      entries: [],
+      bounds: { x: 0, y: 0, width: 0, height: 0 },
+      labelStyle: {
+        fontFamily: theme.fonts.family,
+        fontSize: theme.fonts.sizes.small,
+        fontWeight: theme.fonts.weights.normal,
+        fill: theme.colors.text,
+        lineHeight: 1.3
+      },
+      swatchSize: SWATCH_SIZE2,
+      swatchGap: SWATCH_GAP2,
+      entryGap: ENTRY_GAP2
+    };
+  }
   const entries = extractColorEntries(spec, theme);
   const labelStyle = {
     fontFamily: theme.fonts.family,
@@ -3492,24 +6609,24 @@ function computeBarCell(value, config, columnMax, columnMin, theme, _darkMode) {
   };
 }
 function computeColumnMax(data, key) {
-  let max4 = 0;
+  let max3 = 0;
   for (const row of data) {
     const val = row[key];
-    if (typeof val === "number" && Number.isFinite(val) && val > max4) {
-      max4 = val;
+    if (typeof val === "number" && Number.isFinite(val) && val > max3) {
+      max3 = val;
     }
   }
-  return max4;
+  return max3;
 }
 function computeColumnMin(data, key) {
-  let min4 = 0;
+  let min3 = 0;
   for (const row of data) {
     const val = row[key];
-    if (typeof val === "number" && Number.isFinite(val) && val < min4) {
-      min4 = val;
+    if (typeof val === "number" && Number.isFinite(val) && val < min3) {
+      min3 = val;
     }
   }
-  return min4;
+  return min3;
 }
 
 // src/tables/category-colors.ts
@@ -3563,7 +6680,6 @@ function computeCategoryColors(data, column, theme, darkMode) {
 
 // src/tables/format-cells.ts
 import { formatDate as formatDate2, formatNumber as formatNumber4 } from "@opendata-ai/openchart-core";
-import { format as d3Format3 } from "d3-format";
 function isNumericValue(value) {
   if (typeof value === "number") return Number.isFinite(value);
   return false;
@@ -3583,7 +6699,7 @@ function formatCell(value, column) {
   }
   if (column.format && isNumericValue(value)) {
     try {
-      const formatter = d3Format3(column.format);
+      const formatter = format(column.format);
       return {
         value,
         formattedValue: formatter(value),
@@ -3616,7 +6732,7 @@ function formatValueForSearch(value, column) {
   if (value == null) return "";
   if (column.format && isNumericValue(value)) {
     try {
-      return d3Format3(column.format)(value);
+      return format(column.format)(value);
     } catch {
     }
   }
@@ -3628,8 +6744,6 @@ function formatValueForSearch(value, column) {
 
 // src/tables/heatmap.ts
 import { adaptColorForDarkMode as adaptColorForDarkMode2 } from "@opendata-ai/openchart-core";
-import { interpolateRgb } from "d3-interpolate";
-import { scaleSequential } from "d3-scale";
 function interpolatorFromStops(stops) {
   if (stops.length === 0) return () => "#ffffff";
   if (stops.length === 1) return () => stops[0];
@@ -3639,7 +6753,7 @@ function interpolatorFromStops(stops) {
     const lo = Math.floor(segment);
     const hi = Math.min(lo + 1, stops.length - 1);
     const frac = segment - lo;
-    return interpolateRgb(stops[lo], stops[hi])(frac);
+    return rgb_default(stops[lo], stops[hi])(frac);
   };
 }
 function resolvePalette(palette, theme) {
@@ -3670,13 +6784,13 @@ function computeHeatmapColors(data, column, theme, darkMode) {
   if (config.domain) {
     domain = config.domain;
   } else {
-    let min4 = Infinity;
-    let max4 = -Infinity;
+    let min3 = Infinity;
+    let max3 = -Infinity;
     for (const { value } of numericValues) {
-      if (value < min4) min4 = value;
-      if (value > max4) max4 = value;
+      if (value < min3) min3 = value;
+      if (value > max3) max3 = value;
     }
-    domain = [min4, max4];
+    domain = [min3, max3];
   }
   let stops = resolvePalette(config.palette, theme);
   if (darkMode) {
@@ -3685,7 +6799,7 @@ function computeHeatmapColors(data, column, theme, darkMode) {
     stops = stops.map((c) => adaptColorForDarkMode2(c, lightBg, darkBg));
   }
   const interpolator = interpolatorFromStops(stops);
-  const scale = scaleSequential(interpolator).domain(domain).clamp(true);
+  const scale = sequential(interpolator).domain(domain).clamp(true);
   for (const { index, value } of numericValues) {
     const bg = scale(value);
     const textColor = accessibleTextColor(bg);
@@ -3791,42 +6905,42 @@ function extractValues(row, columnKey, config) {
 function computeSparkline(values, config, theme, _darkMode) {
   if (values.length === 0) return null;
   const type = config.type ?? "line";
-  const color = config.color ?? theme.colors.categorical[0];
-  let min4 = Infinity;
-  let max4 = -Infinity;
+  const color2 = config.color ?? theme.colors.categorical[0];
+  let min3 = Infinity;
+  let max3 = -Infinity;
   for (const v of values) {
-    if (v < min4) min4 = v;
-    if (v > max4) max4 = v;
+    if (v < min3) min3 = v;
+    if (v > max3) max3 = v;
   }
-  const range = max4 - min4;
-  const normalize = (v) => range === 0 ? 0.5 : (v - min4) / range;
+  const range2 = max3 - min3;
+  const normalize2 = (v) => range2 === 0 ? 0.5 : (v - min3) / range2;
   const startValue = values[0];
   const endValue = values[values.length - 1];
   if (type === "line") {
     const points2 = values.map((v, i) => ({
       x: values.length === 1 ? 0.5 : i / (values.length - 1),
-      y: normalize(v)
+      y: normalize2(v)
     }));
     return {
       type,
       points: points2,
       bars: [],
-      color,
+      color: color2,
       count: values.length,
       startValue,
       endValue
     };
   }
-  const bars = values.map(normalize);
+  const bars = values.map(normalize2);
   const points = values.map((v, i) => ({
     x: values.length === 1 ? 0.5 : i / (values.length - 1),
-    y: normalize(v)
+    y: normalize2(v)
   }));
   return {
     type,
     points,
     bars,
-    color,
+    color: color2,
     count: values.length,
     startValue,
     endValue
@@ -4090,16 +7204,15 @@ function compileTableLayout(spec, options, theme) {
 
 // src/tooltips/compute.ts
 import { formatDate as formatDate3, formatNumber as formatNumber5 } from "@opendata-ai/openchart-core";
-import { format as d3Format4 } from "d3-format";
-function formatValue(value, fieldType, format) {
+function formatValue(value, fieldType, format2) {
   if (value == null) return "";
   if (fieldType === "temporal" || value instanceof Date) {
     return formatDate3(value);
   }
   if (typeof value === "number") {
-    if (format) {
+    if (format2) {
       try {
-        return d3Format4(format)(value);
+        return format(format2)(value);
       } catch {
         return formatNumber5(value);
       }
@@ -4108,13 +7221,13 @@ function formatValue(value, fieldType, format) {
   }
   return String(value);
 }
-function buildFields(row, encoding, color) {
+function buildFields(row, encoding, color2) {
   const fields = [];
   if (encoding.y) {
     fields.push({
       label: encoding.y.axis?.label ?? encoding.y.field,
       value: formatValue(row[encoding.y.field], encoding.y.type, encoding.y.axis?.format),
-      color
+      color: color2
     });
   }
   if (encoding.x) {
@@ -4279,14 +7392,52 @@ function compileChart(spec, options) {
   if (normalized.type === "graph") {
     throw new Error("compileChart received a graph spec. Use compileGraph instead.");
   }
-  const chartSpec = normalized;
+  let chartSpec = normalized;
+  const breakpoint = getBreakpoint(options.width);
+  const strategy = getLayoutStrategy(breakpoint);
+  const rawSpec = spec;
+  const overrides = rawSpec.overrides;
+  if (overrides?.[breakpoint]) {
+    const bp = overrides[breakpoint];
+    if (bp.chrome) {
+      chartSpec = {
+        ...chartSpec,
+        chrome: {
+          ...chartSpec.chrome,
+          ...bp.chrome
+        }
+      };
+    }
+    if (bp.labels) {
+      chartSpec = {
+        ...chartSpec,
+        labels: {
+          ...chartSpec.labels,
+          ...bp.labels
+        }
+      };
+    }
+    if (bp.legend) {
+      chartSpec = {
+        ...chartSpec,
+        legend: {
+          ...chartSpec.legend,
+          ...bp.legend
+        }
+      };
+    }
+    if (bp.annotations) {
+      chartSpec = {
+        ...chartSpec,
+        annotations: bp.annotations
+      };
+    }
+  }
   const mergedThemeConfig = options.theme ? { ...chartSpec.theme, ...options.theme } : chartSpec.theme;
   let theme = resolveTheme2(mergedThemeConfig);
   if (options.darkMode) {
     theme = adaptTheme2(theme);
   }
-  const breakpoint = getBreakpoint(options.width);
-  const strategy = getLayoutStrategy(breakpoint);
   const preliminaryArea = {
     x: 0,
     y: 0,