@pixerate/editor 0.45.0 → 0.46.0

package/dist/chart/index.cjs

@@ -0,0 +1,1984 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class;
+
+
+var _chunkTNNJXF46cjs = require('../chunk-TNNJXF46.cjs');
+
+
+var _chunkQKLRAA4Tcjs = require('../chunk-QKLRAA4T.cjs');
+
+// src/chart/spec.ts
+var CHART_TYPES = ["bar", "line", "area", "scatter", "pie", "donut"];
+var CHART_SERIES_TYPES = ["bar", "line", "area", "scatter"];
+var CHART_STACKINGS = ["none", "stacked", "percent"];
+var CHART_CURVES = ["linear", "smooth", "step"];
+var CHART_ORIENTATIONS = ["vertical", "horizontal"];
+var CHART_LEGEND_POSITIONS = ["top", "bottom", "left", "right"];
+var CHART_NUMBER_STYLES = ["number", "percent", "currency", "compact"];
+var CHART_TYPE_LABELS = {
+  bar: "Bar",
+  line: "Line",
+  area: "Area",
+  scatter: "Scatter",
+  pie: "Pie",
+  donut: "Donut"
+};
+var DEFAULT_CHART_PALETTE = ["#4269d0", "#efb118", "#ff725c", "#6cc5b0", "#3ca951", "#ff8ab7", "#a463f2", "#97bbf5", "#9c6b4e", "#9498a0"];
+var DEFAULT_CHART_THEME = {
+  background: "#ffffff",
+  surface: "#ffffff",
+  text: "#0f172a",
+  mutedText: "#64748b",
+  grid: "#e2e8f0",
+  axis: "#94a3b8",
+  selection: "#2563eb",
+  fontFamily: 'system-ui, -apple-system, "Segoe UI", sans-serif',
+  fontSize: 11,
+  titleSize: 15
+};
+var CSS_VARIABLE_CHART_THEME = {
+  ...DEFAULT_CHART_THEME,
+  background: "transparent",
+  surface: "var(--background, #ffffff)",
+  text: "var(--foreground, #0f172a)",
+  mutedText: "var(--muted-foreground, #64748b)",
+  grid: "var(--border, #e2e8f0)",
+  axis: "var(--muted-foreground, #94a3b8)",
+  selection: "var(--primary, #2563eb)",
+  fontFamily: "inherit"
+};
+function isCartesianChart(type) {
+  return type !== "pie" && type !== "donut";
+}
+function defaultChartAxis(value) {
+  return { show: true, title: "", min: null, max: null, gridlines: value, format: {} };
+}
+function createChartSpec(partial = {}) {
+  return normalizeChartSpec(partial).spec;
+}
+function chartSeriesColor(spec, seriesIndex) {
+  const series = spec.series[seriesIndex];
+  if (_optionalChain([series, 'optionalAccess', _2 => _2.color])) return series.color;
+  const palette = spec.palette.length ? spec.palette : DEFAULT_CHART_PALETTE;
+  return palette[seriesIndex % palette.length];
+}
+function chartSliceColor(spec, index) {
+  const palette = spec.palette.length ? spec.palette : DEFAULT_CHART_PALETTE;
+  return palette[index % palette.length];
+}
+function chartSeriesType(spec, series) {
+  if (series.type) return series.type;
+  return isCartesianChart(spec.type) ? spec.type : "bar";
+}
+function uniqueChartSeriesId(series, base = "series") {
+  const used = new Set(series.map((s) => s.id));
+  for (let i = series.length + 1; ; i++) {
+    const id = `${base}-${i}`;
+    if (!used.has(id)) return id;
+  }
+}
+function parseChartValue(input) {
+  if (input === null || input === void 0) return null;
+  if (typeof input === "number") return Number.isFinite(input) ? input : void 0;
+  if (typeof input !== "string") return void 0;
+  let text2 = input.trim();
+  if (!text2 || text2 === "-" || text2 === "\u2014") return null;
+  let negative = false;
+  if (/^\(.*\)$/.test(text2)) {
+    negative = true;
+    text2 = text2.slice(1, -1).trim();
+  }
+  const percent = text2.endsWith("%");
+  if (percent) text2 = text2.slice(0, -1).trim();
+  text2 = text2.replace(/^[$€£¥]/, "").replace(/,/g, "").replace(/\s+/g, "");
+  if (!/^[-+]?(\d+\.?\d*|\.\d+)(e[-+]?\d+)?$/i.test(text2)) return void 0;
+  let value = Number(text2);
+  if (percent) value /= 100;
+  if (negative) value = -value;
+  return Number.isFinite(value) ? value : void 0;
+}
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+function pick(value, options, fallback, path, issues) {
+  if (value === void 0) return fallback;
+  if (typeof value === "string" && options.includes(value)) return value;
+  issues.push({ path, message: `${path} must be one of ${options.map((o) => `"${o}"`).join(", ")}; got ${JSON.stringify(value)}.` });
+  return fallback;
+}
+function text(value, fallback, path, issues) {
+  if (value === void 0 || value === null) return fallback;
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  issues.push({ path, message: `${path} must be text.` });
+  return fallback;
+}
+function flag(value, fallback, path, issues) {
+  if (value === void 0) return fallback;
+  if (typeof value === "boolean") return value;
+  issues.push({ path, message: `${path} must be true or false.` });
+  return fallback;
+}
+function bound(value, path, issues) {
+  if (value === void 0 || value === null || value === "") return null;
+  const n = typeof value === "string" ? Number(value) : value;
+  if (typeof n === "number" && Number.isFinite(n)) return n;
+  issues.push({ path, message: `${path} must be a number or null.` });
+  return null;
+}
+function normalizeFormat(value, path, issues) {
+  if (value === void 0 || value === null) return {};
+  if (!isRecord(value)) {
+    issues.push({ path, message: `${path} must be an object.` });
+    return {};
+  }
+  const out = {};
+  if (value.style !== void 0) out.style = pick(value.style, CHART_NUMBER_STYLES, "number", `${path}.style`, issues);
+  if (value.decimals !== void 0) {
+    const d = Number(value.decimals);
+    if (Number.isInteger(d) && d >= 0 && d <= 10) out.decimals = d;
+    else issues.push({ path: `${path}.decimals`, message: `${path}.decimals must be a whole number from 0 to 10.` });
+  }
+  for (const key of ["currency", "prefix", "suffix"]) {
+    if (value[key] !== void 0) out[key] = text(value[key], "", `${path}.${key}`, issues);
+  }
+  return out;
+}
+function normalizeChartAxis(value, fallback, path, issues = []) {
+  if (value === void 0) return { ...fallback, format: { ...fallback.format } };
+  if (!isRecord(value)) {
+    issues.push({ path, message: `${path} must be an object.` });
+    return { ...fallback, format: { ...fallback.format } };
+  }
+  let min = "min" in value ? bound(value.min, `${path}.min`, issues) : fallback.min;
+  let max = "max" in value ? bound(value.max, `${path}.max`, issues) : fallback.max;
+  if (min !== null && max !== null && min >= max) {
+    issues.push({ path: `${path}.max`, message: `${path}.max (${max}) must be greater than ${path}.min (${min}).` });
+    min = fallback.min;
+    max = fallback.max;
+  }
+  return {
+    show: flag(value.show, fallback.show, `${path}.show`, issues),
+    title: text(value.title, fallback.title, `${path}.title`, issues),
+    min,
+    max,
+    gridlines: flag(value.gridlines, fallback.gridlines, `${path}.gridlines`, issues),
+    format: "format" in value ? normalizeFormat(value.format, `${path}.format`, issues) : { ...fallback.format }
+  };
+}
+function normalizeLegend(value, issues) {
+  const fallback = { show: true, position: "bottom" };
+  if (value === void 0) return fallback;
+  if (!isRecord(value)) {
+    issues.push({ path: "legend", message: "legend must be an object." });
+    return fallback;
+  }
+  return {
+    show: flag(value.show, fallback.show, "legend.show", issues),
+    position: pick(value.position, CHART_LEGEND_POSITIONS, fallback.position, "legend.position", issues)
+  };
+}
+function normalizeChartValues(value, length, path, issues = []) {
+  if (value === void 0) return length ? Array(length).fill(null) : [];
+  if (!Array.isArray(value)) {
+    issues.push({ path, message: `${path} must be an array of numbers.` });
+    return length ? Array(length).fill(null) : [];
+  }
+  const out = value.map((v, i) => {
+    const parsed = parseChartValue(v);
+    if (parsed === void 0) {
+      issues.push({ path: `${path}[${i}]`, message: `${path}[${i}] is not a number: ${JSON.stringify(v)}.` });
+      return null;
+    }
+    return parsed;
+  });
+  if (length === void 0) return out;
+  if (out.length > length) return out.slice(0, length);
+  while (out.length < length) out.push(null);
+  return out;
+}
+function normalizeSeries(value, length, used, index, issues) {
+  const path = `series[${index}]`;
+  if (!isRecord(value)) {
+    issues.push({ path, message: `${path} must be an object with a name and values.` });
+    return null;
+  }
+  let id = typeof value.id === "string" && value.id.trim() ? value.id.trim() : "";
+  if (!id || used.has(id)) {
+    if (id) issues.push({ path: `${path}.id`, message: `Series id "${id}" is used twice; the second was renamed.` });
+    for (let n = index + 1; ; n++) {
+      id = `series-${n}`;
+      if (!used.has(id)) break;
+    }
+  }
+  used.add(id);
+  const series = {
+    id,
+    name: text(value.name, `Series ${index + 1}`, `${path}.name`, issues),
+    values: normalizeChartValues(value.values, length, `${path}.values`, issues)
+  };
+  if (typeof value.color === "string" && value.color.trim()) series.color = value.color.trim();
+  if (value.type !== void 0 && value.type !== null) series.type = pick(value.type, CHART_SERIES_TYPES, "bar", `${path}.type`, issues);
+  if (value.hidden === true) series.hidden = true;
+  return series;
+}
+function normalizeChartSpec(input) {
+  const issues = [];
+  const value = isRecord(input) ? input : {};
+  if (input !== void 0 && !isRecord(input)) issues.push({ path: "", message: "A chart must be an object." });
+  const type = pick(value.type, CHART_TYPES, "bar", "type", issues);
+  const rawSeries = Array.isArray(value.series) ? value.series : [];
+  if (value.series !== void 0 && !Array.isArray(value.series)) issues.push({ path: "series", message: "series must be an array." });
+  let categories;
+  if (Array.isArray(value.categories)) categories = value.categories.map((c, i) => text(c, "", `categories[${i}]`, issues));
+  else {
+    if (value.categories !== void 0) issues.push({ path: "categories", message: "categories must be an array of labels." });
+    const longest = rawSeries.reduce((n, s) => Math.max(n, isRecord(s) && Array.isArray(s.values) ? s.values.length : 0), 0);
+    categories = Array.from({ length: longest }, (_, i) => `${i + 1}`);
+  }
+  const used = /* @__PURE__ */ new Set();
+  const series = rawSeries.map((s, i) => normalizeSeries(s, categories.length, used, i, issues)).filter((s) => s !== null);
+  let palette = [...DEFAULT_CHART_PALETTE];
+  if (Array.isArray(value.palette)) {
+    const colors = value.palette.filter((c) => typeof c === "string" && c.trim() !== "");
+    if (colors.length) palette = colors;
+    else issues.push({ path: "palette", message: "palette must list at least one colour." });
+  } else if (value.palette !== void 0) issues.push({ path: "palette", message: "palette must be an array of colours." });
+  let innerRadius = 0.55;
+  if (value.innerRadius !== void 0) {
+    const r = Number(value.innerRadius);
+    if (Number.isFinite(r) && r >= 0 && r <= 0.9) innerRadius = r;
+    else issues.push({ path: "innerRadius", message: "innerRadius must be a number from 0 to 0.9." });
+  }
+  const spec = {
+    version: 1,
+    type,
+    title: text(value.title, "", "title", issues),
+    subtitle: text(value.subtitle, "", "subtitle", issues),
+    categories,
+    series,
+    xAxis: normalizeChartAxis(value.xAxis, defaultChartAxis(false), "xAxis", issues),
+    yAxis: normalizeChartAxis(value.yAxis, defaultChartAxis(true), "yAxis", issues),
+    legend: normalizeLegend(value.legend, issues),
+    stacking: pick(value.stacking, CHART_STACKINGS, "none", "stacking", issues),
+    orientation: pick(value.orientation, CHART_ORIENTATIONS, "vertical", "orientation", issues),
+    curve: pick(value.curve, CHART_CURVES, "linear", "curve", issues),
+    points: flag(value.points, true, "points", issues),
+    dataLabels: flag(value.dataLabels, false, "dataLabels", issues),
+    palette,
+    innerRadius
+  };
+  return { spec, issues };
+}
+function cloneChartSpec(spec) {
+  return {
+    ...spec,
+    categories: [...spec.categories],
+    series: spec.series.map(cloneChartSeries),
+    xAxis: { ...spec.xAxis, format: { ...spec.xAxis.format } },
+    yAxis: { ...spec.yAxis, format: { ...spec.yAxis.format } },
+    legend: { ...spec.legend },
+    palette: [...spec.palette]
+  };
+}
+function cloneChartSeries(series) {
+  return { ...series, values: [...series.values] };
+}
+function chartDataFromTable(rows, options = {}) {
+  const header = _nullishCoalesce(options.header, () => ( true));
+  let grid = rows.map((r) => [...r]).filter((r) => r.some((c) => c !== null && c !== void 0 && String(c).trim() !== ""));
+  if (options.seriesIn === "rows") {
+    const width2 = Math.max(0, ...grid.map((r) => r.length));
+    grid = Array.from({ length: width2 }, (_, c) => grid.map((r) => r[c]));
+  }
+  const issues = [];
+  if (!grid.length) return { categories: [], series: [], issues };
+  const width = Math.max(...grid.map((r) => r.length));
+  const names = header ? grid[0] : [];
+  const body = header ? grid.slice(1) : grid;
+  const categories = body.map((r, i) => {
+    const c = r[0];
+    return c === null || c === void 0 || String(c).trim() === "" ? `${i + 1}` : String(c).trim();
+  });
+  const series = [];
+  for (let col = 1; col < width; col++) {
+    const name = names[col] !== void 0 && String(names[col]).trim() ? String(names[col]).trim() : `Series ${col}`;
+    const values = body.map((r, i) => {
+      const parsed = parseChartValue(_nullishCoalesce(r[col], () => ( null)));
+      if (parsed === void 0) {
+        issues.push({ path: `${name}[${i}]`, message: `"${String(r[col])}" in ${name} (${categories[i]}) is not a number; it was left blank.` });
+        return null;
+      }
+      return parsed;
+    });
+    series.push({ id: `series-${col}`, name, values });
+  }
+  return { categories, series, issues };
+}
+function chartDataToTable(spec, options = {}) {
+  return [
+    [_nullishCoalesce(options.categoryHeader, () => ( "")), ...spec.series.map((s) => s.name)],
+    ...spec.categories.map((category, i) => [category, ...spec.series.map((s) => _nullishCoalesce(s.values[i], () => ( null)))])
+  ];
+}
+function chartColorInputValue(color) {
+  if (/^#[0-9a-f]{6}$/i.test(color)) return color.toLowerCase();
+  if (/^#[0-9a-f]{3}$/i.test(color)) return `#${[...color.slice(1)].map((c) => c + c).join("")}`.toLowerCase();
+  return "#000000";
+}
+
+// src/chart/scale.ts
+function niceStep(span, count) {
+  if (!(span > 0) || !(count > 0)) return 1;
+  const raw = span / count;
+  const power = Math.pow(10, Math.floor(Math.log10(raw)));
+  const fraction = raw / power;
+  const nice = fraction <= 1 ? 1 : fraction <= 2 ? 2 : fraction <= 2.5 ? 2.5 : fraction <= 5 ? 5 : 10;
+  return nice * power;
+}
+var clean = (n) => Math.abs(n) < 1e-12 ? 0 : Number(n.toPrecision(12));
+function niceScale(min, max, count = 5, fixedMin = null, fixedMax = null) {
+  let lo = _nullishCoalesce(fixedMin, () => ( min));
+  let hi = _nullishCoalesce(fixedMax, () => ( max));
+  if (!Number.isFinite(lo) || !Number.isFinite(hi)) {
+    lo = 0;
+    hi = 1;
+  }
+  if (lo > hi) [lo, hi] = [hi, lo];
+  if (lo === hi) {
+    const pad = lo === 0 ? 1 : Math.abs(lo) * 0.1;
+    if (fixedMin === null && lo !== 0) lo -= pad;
+    if (fixedMax === null || lo === hi) hi += pad;
+  }
+  const step = niceStep(hi - lo, count);
+  const niceMin = _nullishCoalesce(fixedMin, () => ( clean(Math.floor(lo / step + 1e-9) * step)));
+  const niceMax = _nullishCoalesce(fixedMax, () => ( clean(Math.ceil(hi / step - 1e-9) * step)));
+  const ticks = [];
+  const first = Math.ceil(niceMin / step - 1e-9) * step;
+  for (let t = first, i = 0; t <= niceMax + step * 1e-9 && i < 1e3; t += step, i++) ticks.push(clean(t));
+  return { min: niceMin, max: niceMax, step, ticks };
+}
+function stepDecimals(step) {
+  if (!(step > 0) || step >= 1) return 0;
+  return Math.min(6, Math.max(0, Math.ceil(-Math.log10(step) - 1e-9)));
+}
+var COMPACT = [
+  { value: 1e12, suffix: "T" },
+  { value: 1e9, suffix: "B" },
+  { value: 1e6, suffix: "M" },
+  { value: 1e3, suffix: "K" }
+];
+function grouped(value, decimals) {
+  const fixed = Math.abs(value).toFixed(decimals);
+  const [int, frac] = fixed.split(".");
+  const withCommas = int.replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+  return `${value < 0 && Number(fixed) !== 0 ? "-" : ""}${withCommas}${frac ? `.${frac}` : ""}`;
+}
+var CURRENCY_SYMBOLS = { USD: "$", EUR: "\u20AC", GBP: "\xA3", JPY: "\xA5", CNY: "\xA5", INR: "\u20B9", AUD: "A$", CAD: "C$" };
+function formatChartNumber(value, format = {}, fallbackDecimals) {
+  if (value === null || value === void 0 || !Number.isFinite(value)) return "";
+  const style = _nullishCoalesce(format.style, () => ( "number"));
+  let body;
+  const decimalsFor = (v) => {
+    if (format.decimals !== void 0) return format.decimals;
+    if (fallbackDecimals !== void 0) return fallbackDecimals;
+    return Number.isInteger(v) ? 0 : Math.abs(v) < 1 ? Math.min(4, Math.max(2, stepDecimals(Math.abs(v)) + 1)) : 2;
+  };
+  const trim = (s) => format.decimals === void 0 && fallbackDecimals === void 0 && s.includes(".") ? s.replace(/\.?0+$/, "") : s;
+  if (style === "percent") {
+    const v = value * 100;
+    const d = _nullishCoalesce(format.decimals, () => ( (fallbackDecimals !== void 0 ? Math.max(0, fallbackDecimals - 2) : Number.isInteger(clean(v)) ? 0 : 1)));
+    body = `${grouped(clean(v), d)}%`;
+  } else if (style === "compact") {
+    const unit = COMPACT.find((u) => Math.abs(value) >= u.value);
+    if (unit) {
+      const v = value / unit.value;
+      const d = _nullishCoalesce(format.decimals, () => ( (Math.abs(v) >= 100 || Number.isInteger(clean(v)) ? 0 : 1)));
+      body = `${trim(grouped(v, d))}${unit.suffix}`;
+    } else body = trim(grouped(value, decimalsFor(value)));
+  } else if (style === "currency") {
+    const code = (format.currency || "USD").toUpperCase();
+    const symbol = _nullishCoalesce(CURRENCY_SYMBOLS[code], () => ( `${code} `));
+    const d = _nullishCoalesce(format.decimals, () => ( (fallbackDecimals !== void 0 ? fallbackDecimals : Number.isInteger(value) ? 0 : 2)));
+    const s = grouped(Math.abs(value), d);
+    body = `${value < 0 ? "-" : ""}${symbol}${s}`;
+  } else body = trim(grouped(value, decimalsFor(value)));
+  return `${_nullishCoalesce(format.prefix, () => ( ""))}${body}${_nullishCoalesce(format.suffix, () => ( ""))}`;
+}
+function linearMap(value, domain, range) {
+  const [d0, d1] = domain;
+  const [r0, r1] = range;
+  if (d1 === d0) return (r0 + r1) / 2;
+  return r0 + (value - d0) / (d1 - d0) * (r1 - r0);
+}
+
+// src/chart/layout.ts
+var estimateChartTextWidth = (text2, size, weight = 400) => text2.length * size * (weight >= 600 ? 0.6 : 0.56);
+function sameChartSelection(a, b) {
+  if (!a || !b || a.kind !== b.kind) return false;
+  switch (a.kind) {
+    case "axis":
+      return a.axis === b.axis;
+    case "series":
+      return a.seriesId === b.seriesId;
+    case "point":
+      return a.seriesId === b.seriesId && a.index === b.index;
+    case "category":
+      return a.index === b.index;
+    default:
+      return true;
+  }
+}
+var r2 = (n) => Math.round(n * 100) / 100;
+function curvePath(points, curve, map, moveFirst = true) {
+  if (!points.length) return "";
+  const xy = points.map(map);
+  let d = `${moveFirst ? "M" : "L"}${r2(xy[0][0])},${r2(xy[0][1])}`;
+  if (points.length === 1) return d;
+  if (curve === "step") {
+    for (let i = 1; i < points.length; i++) {
+      const mid = (points[i - 1].c + points[i].c) / 2;
+      const a = map({ c: mid, v: points[i - 1].v });
+      const b = map({ c: mid, v: points[i].v });
+      d += `L${r2(a[0])},${r2(a[1])}L${r2(b[0])},${r2(b[1])}L${r2(xy[i][0])},${r2(xy[i][1])}`;
+    }
+    return d;
+  }
+  if (curve === "smooth" && points.length > 2) {
+    const n = points.length;
+    const dc = points.slice(1).map((p, i) => p.c - points[i].c);
+    const slope = points.slice(1).map((p, i) => dc[i] === 0 ? 0 : (p.v - points[i].v) / dc[i]);
+    const tangent = points.map((_, i) => {
+      if (i === 0) return slope[0];
+      if (i === n - 1) return slope[n - 2];
+      const a = slope[i - 1];
+      const b = slope[i];
+      if (a * b <= 0) return 0;
+      const wa = 2 * dc[i] + dc[i - 1];
+      const wb = dc[i] + 2 * dc[i - 1];
+      return (wa + wb) / (wa / a + wb / b);
+    });
+    for (let i = 1; i < n; i++) {
+      const h = dc[i - 1] / 3;
+      const p0 = points[i - 1];
+      const p1 = points[i];
+      const a = map({ c: p0.c + h, v: p0.v + tangent[i - 1] * h });
+      const b = map({ c: p1.c - h, v: p1.v - tangent[i] * h });
+      d += `C${r2(a[0])},${r2(a[1])} ${r2(b[0])},${r2(b[1])} ${r2(xy[i][0])},${r2(xy[i][1])}`;
+    }
+    return d;
+  }
+  for (let i = 1; i < xy.length; i++) d += `L${r2(xy[i][0])},${r2(xy[i][1])}`;
+  return d;
+}
+function arcPath(cx, cy, outer, inner, start, end) {
+  const full = end - start >= Math.PI * 2 - 1e-9;
+  if (full) end = start + Math.PI * 2 - 1e-4;
+  const p = (r, a) => `${r2(cx + r * Math.sin(a))},${r2(cy - r * Math.cos(a))}`;
+  const large = end - start > Math.PI ? 1 : 0;
+  let d = `M${p(outer, start)}A${r2(outer)},${r2(outer)} 0 ${large} 1 ${p(outer, end)}`;
+  if (inner > 0) d += `L${p(inner, end)}A${r2(inner)},${r2(inner)} 0 ${large} 0 ${p(inner, start)}Z`;
+  else d += `L${r2(cx)},${r2(cy)}Z`;
+  return d;
+}
+function layoutChart(spec, options) {
+  const width = Math.max(1, options.width);
+  const height = Math.max(1, options.height);
+  const theme = { ...DEFAULT_CHART_THEME, ...options.theme };
+  const measure = _nullishCoalesce(options.measureText, () => ( estimateChartTextWidth));
+  const selection = _nullishCoalesce(options.selection, () => ( null));
+  const fs = theme.fontSize;
+  const marks = [];
+  const isSelected = (target) => sameChartSelection(selection, target);
+  const seriesSelected = (id) => _optionalChain([selection, 'optionalAccess', _3 => _3.kind]) === "series" && selection.seriesId === id;
+  const pad = 12;
+  marks.push({ kind: "rect", key: "background", role: "background", x: 0, y: 0, width, height, fill: theme.background, target: { kind: "chart" } });
+  let top = pad;
+  const outline = (key, box) => marks.push({ kind: "rect", key, role: "selection", ...box, fill: "none", stroke: theme.selection, strokeWidth: 1, radius: 3 });
+  const titleMark = (kind, label, size, weight, fill) => {
+    const target = { kind };
+    const selected = isSelected(target);
+    marks.push({ kind: "text", key: kind, role: kind, x: width / 2, y: top, text: label, anchor: "middle", baseline: "top", size, weight, fill, target, selected });
+    if (selected) {
+      const w = measure(label, size, weight);
+      outline(`${kind}-selection`, { x: width / 2 - w / 2 - 4, y: top - 3, width: w + 8, height: size * 1.25 + 6 });
+    }
+    top += size * 1.35;
+  };
+  if (spec.title) titleMark("title", spec.title, theme.titleSize, 600, theme.text);
+  if (spec.subtitle) titleMark("subtitle", spec.subtitle, fs + 1, 400, theme.mutedText);
+  if (spec.title || spec.subtitle) top += 6;
+  const cartesian = isCartesianChart(spec.type);
+  const visible = spec.series.filter((s) => !s.hidden);
+  const legendItems = cartesian ? spec.series.map((s, i) => ({
+    label: s.name,
+    color: chartSeriesColor(spec, i),
+    target: { kind: "series", seriesId: s.id },
+    faded: !!s.hidden,
+    selected: seriesSelected(s.id),
+    shape: chartSeriesType(spec, s) === "line" ? "line" : "square"
+  })) : spec.categories.map((c, i) => ({
+    label: c,
+    color: chartSliceColor(spec, i),
+    target: { kind: "category", index: i },
+    faded: false,
+    selected: isSelected({ kind: "category", index: i }),
+    shape: "square"
+  }));
+  let area = { x: pad, y: top, width: width - pad * 2, height: height - top - pad };
+  const showLegend = spec.legend.show && legendItems.length > 0 && (!cartesian || spec.series.length > 1 || spec.series.some((s) => s.hidden));
+  if (showLegend) area = layoutLegend(legendItems, spec.legend.position, area, theme, measure, marks, isSelected({ kind: "legend" }));
+  const empty = (message) => {
+    marks.push({ kind: "text", key: "empty", role: "empty", x: area.x + area.width / 2, y: area.y + area.height / 2, text: message, anchor: "middle", baseline: "middle", size: fs + 1, fill: theme.mutedText });
+    return { width, height, plot: { x: area.x, y: area.y, width: 0, height: 0 }, marks, percent: false, theme };
+  };
+  const hasData = visible.some((s) => s.values.some((v) => v !== null));
+  if (!spec.categories.length || !visible.length || !hasData) return empty(_nullishCoalesce(options.emptyMessage, () => ( "No data")));
+  if (!cartesian) return layoutPie(spec, visible[0], area, theme, marks, selection, width, height);
+  const horizontal = spec.orientation === "horizontal";
+  const n = spec.categories.length;
+  const types = new Map(visible.map((s) => [s.id, chartSeriesType(spec, s)]));
+  const stacked = spec.stacking !== "none";
+  const percent = spec.stacking === "percent";
+  const stacks = /* @__PURE__ */ new Map();
+  if (stacked) {
+    for (const kind of ["bar", "area"]) {
+      const group = visible.filter((s) => types.get(s.id) === kind);
+      if (!group.length) continue;
+      const totals = Array.from({ length: n }, (_, i) => group.reduce((t, s) => t + Math.abs(_nullishCoalesce(s.values[i], () => ( 0))), 0));
+      const pos = Array(n).fill(0);
+      const neg = Array(n).fill(0);
+      for (const s of group) {
+        const segments = s.values.map((raw, i) => {
+          if (raw === null && kind === "bar") return null;
+          let v = _nullishCoalesce(raw, () => ( 0));
+          if (percent) v = totals[i] ? v / totals[i] : 0;
+          const base = v >= 0 ? pos[i] : neg[i];
+          const seg = [base, base + v];
+          if (v >= 0) pos[i] += v;
+          else neg[i] += v;
+          return seg;
+        });
+        stacks.set(s.id, { segments });
+      }
+    }
+  }
+  let lo = Infinity;
+  let hi = -Infinity;
+  const see = (v) => {
+    lo = Math.min(lo, v);
+    hi = Math.max(hi, v);
+  };
+  for (const s of visible) {
+    const stack = stacks.get(s.id);
+    if (stack) stack.segments.forEach((seg) => seg && (see(seg[0]), see(seg[1])));
+    else s.values.forEach((v) => v !== null && see(v));
+  }
+  if (!Number.isFinite(lo)) {
+    lo = 0;
+    hi = 1;
+  }
+  if ([...types.values()].some((t) => t === "bar" || t === "area")) {
+    lo = Math.min(lo, 0);
+    hi = Math.max(hi, 0);
+  }
+  const valueFormat = percent && !spec.yAxis.format.style ? { ...spec.yAxis.format, style: "percent" } : spec.yAxis.format;
+  const xAxis = spec.xAxis;
+  const yAxis = spec.yAxis;
+  const titleBand = fs * 1.3 + 6;
+  const valueLen0 = horizontal ? area.width : area.height;
+  let scale = niceScale(lo, hi, Math.max(2, Math.min(10, Math.round(valueLen0 / 56))), yAxis.min, yAxis.max);
+  const tickText = (t) => formatChartNumber(t, valueFormat, _nullishCoalesce(valueFormat.decimals, () => ( stepDecimals(scale.step))));
+  const valueLabelWidth = Math.max(0, ...scale.ticks.map((t) => measure(tickText(t), fs)));
+  const catLabelWidth = Math.max(0, ...spec.categories.map((c) => measure(c, fs)));
+  let left;
+  let bottom;
+  let rotate = 0;
+  if (horizontal) {
+    left = (xAxis.show ? Math.min(catLabelWidth, area.width * 0.35) + 8 : 2) + (xAxis.title ? titleBand : 0);
+    bottom = (yAxis.show ? fs * 1.6 : 2) + (yAxis.title ? titleBand : 0);
+  } else {
+    left = (yAxis.show ? valueLabelWidth + 8 : 2) + (yAxis.title ? titleBand : 0);
+    const band2 = (area.width - left - 8) / n;
+    if (xAxis.show && catLabelWidth > band2 * 0.92) rotate = -40;
+    const catHeight = rotate ? Math.min(catLabelWidth * Math.sin(Math.PI / 4.5) + fs, area.height * 0.4) : fs * 1.6;
+    bottom = (xAxis.show ? catHeight : 2) + (xAxis.title ? titleBand : 0);
+  }
+  const rightPad = horizontal ? Math.max(8, valueLabelWidth / 2) : 8;
+  const plot = {
+    x: area.x + left,
+    y: area.y + (horizontal ? 4 : fs / 2 + 2),
+    width: Math.max(1, area.width - left - rightPad),
+    height: Math.max(1, area.height - bottom - (horizontal ? 4 : fs / 2 + 2))
+  };
+  scale = niceScale(lo, hi, Math.max(2, Math.min(10, Math.round((horizontal ? plot.width : plot.height) / 56))), yAxis.min, yAxis.max);
+  const domain = [scale.min, scale.max];
+  const valueRange = horizontal ? [plot.x, plot.x + plot.width] : [plot.y + plot.height, plot.y];
+  const valuePx = (v) => linearMap(Math.min(scale.max, Math.max(scale.min, v)), domain, valueRange);
+  const catStart = horizontal ? plot.y : plot.x;
+  const catLen = horizontal ? plot.height : plot.width;
+  const band = catLen / n;
+  const catCenter = (i) => catStart + band * (i + 0.5);
+  const map = (p) => horizontal ? [p.v, p.c] : [p.c, p.v];
+  const zero = valuePx(Math.min(scale.max, Math.max(scale.min, 0)));
+  const axisSelected = (axis) => isSelected({ kind: "axis", axis });
+  if (yAxis.gridlines) {
+    scale.ticks.forEach((t, i) => {
+      const p = valuePx(t);
+      const [x1, y1] = map({ c: catStart, v: p });
+      const [x2, y2] = map({ c: catStart + catLen, v: p });
+      marks.push({ kind: "line", key: `grid-y-${i}`, role: "grid", x1, y1, x2, y2, stroke: theme.grid, strokeWidth: 1 });
+    });
+  }
+  if (xAxis.gridlines) {
+    for (let i = 1; i < n; i++) {
+      const c = catStart + band * i;
+      const [x1, y1] = map({ c, v: valueRange[0] });
+      const [x2, y2] = map({ c, v: valueRange[1] });
+      marks.push({ kind: "line", key: `grid-x-${i}`, role: "grid", x1, y1, x2, y2, stroke: theme.grid, strokeWidth: 1 });
+    }
+  }
+  const yTarget = { kind: "axis", axis: "y" };
+  const xTarget = { kind: "axis", axis: "x" };
+  if (yAxis.show) {
+    scale.ticks.forEach((t, i) => {
+      const p = valuePx(t);
+      const label = tickText(t);
+      if (horizontal)
+        marks.push({ kind: "text", key: `tick-y-${i}`, role: "tick-label", x: p, y: plot.y + plot.height + 6, text: label, anchor: "middle", baseline: "top", size: fs, fill: theme.mutedText, target: yTarget });
+      else marks.push({ kind: "text", key: `tick-y-${i}`, role: "tick-label", x: plot.x - 8, y: p, text: label, anchor: "end", baseline: "middle", size: fs, fill: theme.mutedText, target: yTarget });
+    });
+  }
+  if (xAxis.show) {
+    const [x1, y1] = map({ c: catStart, v: zero });
+    const [x2, y2] = map({ c: catStart + catLen, v: zero });
+    marks.push({ kind: "line", key: "axis-x", role: "axis", x1, y1, x2, y2, stroke: theme.axis, strokeWidth: 1, target: xTarget });
+    const every = horizontal ? Math.max(1, Math.ceil(fs * 1.3 / band)) : rotate ? Math.max(1, Math.ceil(fs * 1.4 / band)) : 1;
+    spec.categories.forEach((c, i) => {
+      if (i % every) return;
+      const target = { kind: "category", index: i };
+      const selected = isSelected(target);
+      const fill = selected ? theme.selection : theme.mutedText;
+      if (horizontal) {
+        const maxW = left - (xAxis.title ? titleBand : 0) - 8;
+        marks.push({ kind: "text", key: `tick-x-${i}`, role: "tick-label", x: plot.x - 8, y: catCenter(i), text: truncate(c, maxW, fs, measure), anchor: "end", baseline: "middle", size: fs, fill, target, selected });
+      } else if (rotate)
+        marks.push({ kind: "text", key: `tick-x-${i}`, role: "tick-label", x: catCenter(i), y: plot.y + plot.height + 8, text: c, anchor: "end", baseline: "middle", size: fs, fill, rotate, target, selected });
+      else marks.push({ kind: "text", key: `tick-x-${i}`, role: "tick-label", x: catCenter(i), y: plot.y + plot.height + 6, text: c, anchor: "middle", baseline: "top", size: fs, fill, target, selected });
+    });
+  }
+  const bottomTitle = horizontal ? yAxis.title : xAxis.title;
+  const leftTitle = horizontal ? xAxis.title : yAxis.title;
+  if (bottomTitle)
+    marks.push({ kind: "text", key: `axis-title-${horizontal ? "y" : "x"}`, role: "axis-title", x: plot.x + plot.width / 2, y: area.y + area.height, text: bottomTitle, anchor: "middle", baseline: "bottom", size: fs + 1, weight: 500, fill: theme.text, target: horizontal ? yTarget : xTarget });
+  if (leftTitle)
+    marks.push({ kind: "text", key: `axis-title-${horizontal ? "x" : "y"}`, role: "axis-title", x: area.x, y: plot.y + plot.height / 2, text: leftTitle, anchor: "middle", baseline: "top", size: fs + 1, weight: 500, fill: theme.text, rotate: -90, target: horizontal ? xTarget : yTarget });
+  for (const axis of ["x", "y"]) {
+    if (!axisSelected(axis)) continue;
+    const onLeft = axis === "y" !== horizontal;
+    const box = onLeft ? { x: area.x, y: plot.y - fs / 2, width: left - 2, height: plot.height + fs } : { x: plot.x - 4, y: plot.y + plot.height + 2, width: plot.width + 8, height: area.y + area.height - plot.y - plot.height - 2 };
+    outline(`axis-${axis}-selection`, box);
+  }
+  const bars = visible.filter((s) => types.get(s.id) === "bar");
+  const slots = stacked ? 1 : bars.length;
+  const groupWidth = band * (bars.length ? 0.72 : 0);
+  const barWidth = slots ? groupWidth / slots : 0;
+  const labelMarks = [];
+  const decimals = _nullishCoalesce(valueFormat.decimals, () => ( void 0));
+  const dataLabel = (v) => formatChartNumber(v, valueFormat, decimals);
+  const drawOrder = [...visible].sort((a, b) => order(types.get(a.id)) - order(types.get(b.id)));
+  for (const s of drawOrder) {
+    const si = spec.series.indexOf(s);
+    const color = chartSeriesColor(spec, si);
+    const type = types.get(s.id);
+    const stack = stacks.get(s.id);
+    const selSeries = seriesSelected(s.id);
+    const seriesTarget = { kind: "series", seriesId: s.id };
+    if (type === "bar") {
+      const slot = stacked ? 0 : bars.indexOf(s);
+      s.values.forEach((raw, i) => {
+        const seg = stack ? stack.segments[i] : raw === null ? null : [0, raw];
+        if (!seg || raw === null) return;
+        const a = valuePx(seg[0]);
+        const b = valuePx(seg[1]);
+        const c0 = catCenter(i) - groupWidth / 2 + slot * barWidth + barWidth * 0.06;
+        const cw = barWidth * 0.88;
+        const target = { kind: "point", seriesId: s.id, index: i };
+        const selected = isSelected(target);
+        const [x, y] = map({ c: c0, v: Math.min(a, b) });
+        const rect = horizontal ? { x: Math.min(a, b), y: c0, width: Math.abs(b - a), height: cw } : { x, y, width: cw, height: Math.abs(b - a) };
+        marks.push({
+          kind: "rect",
+          key: `bar-${s.id}-${i}`,
+          role: "bar",
+          ...rect,
+          fill: color,
+          radius: Math.min(2, cw / 4),
+          target,
+          selected: selected || selSeries,
+          ...selSeries ? { stroke: theme.selection, strokeWidth: 1.5 } : {}
+        });
+        if (selected) outline(`bar-${s.id}-${i}-selection`, { x: rect.x - 2, y: rect.y - 2, width: rect.width + 4, height: rect.height + 4 });
+        if (spec.dataLabels) {
+          const v = percent ? seg[1] - seg[0] : raw;
+          const end = valuePx(seg[1]);
+          const outward = (seg[1] >= seg[0] ? 1 : -1) * (horizontal ? 1 : -1);
+          const [lx, ly] = map({ c: c0 + cw / 2, v: stacked ? (a + b) / 2 : end + outward * 4 });
+          labelMarks.push({
+            kind: "text",
+            key: `label-${s.id}-${i}`,
+            role: "data-label",
+            x: lx,
+            y: ly,
+            text: dataLabel(v),
+            anchor: horizontal && !stacked ? outward > 0 ? "start" : "end" : "middle",
+            baseline: horizontal || stacked ? "middle" : outward < 0 ? "bottom" : "top",
+            size: fs - 1,
+            fill: stacked ? "#ffffff" : theme.text,
+            target
+          });
+        }
+      });
+      continue;
+    }
+    const pointValue = (i) => stack ? _nullishCoalesce(_optionalChain([stack, 'access', _4 => _4.segments, 'access', _5 => _5[i], 'optionalAccess', _6 => _6[1]]), () => ( null)) : s.values[i];
+    const runs = [];
+    let run = [];
+    for (let i = 0; i < n; i++) {
+      const v = pointValue(i);
+      if (v === null) {
+        if (run.length) runs.push(run);
+        run = [];
+        continue;
+      }
+      run.push({ c: catCenter(i), v: valuePx(v) });
+    }
+    if (run.length) runs.push(run);
+    if (type === "area") {
+      const parts = runs.map((r) => {
+        const baseline = stack ? r.map((p) => ({ c: p.c, v: valuePx(_nullishCoalesce(_optionalChain([stack, 'access', _7 => _7.segments, 'access', _8 => _8[Math.round((p.c - catStart) / band - 0.5)], 'optionalAccess', _9 => _9[0]]), () => ( 0))) })).reverse() : [
+          { c: r[r.length - 1].c, v: zero },
+          { c: r[0].c, v: zero }
+        ];
+        return `${curvePath(r, spec.curve, map)}${stack ? curvePath(baseline, spec.curve, map, false) : baseline.map((p) => `L${map(p).map(r2).join(",")}`).join("")}Z`;
+      });
+      marks.push({ kind: "path", key: `area-${s.id}`, role: "area", d: parts.join(""), fill: color, opacity: 0.22, target: seriesTarget, selected: selSeries });
+    }
+    if (type === "line" || type === "area") {
+      marks.push({
+        kind: "path",
+        key: `line-${s.id}`,
+        role: "line",
+        d: runs.map((r) => curvePath(r, spec.curve, map)).join(""),
+        fill: "none",
+        stroke: color,
+        strokeWidth: selSeries ? 3.5 : 2,
+        target: seriesTarget,
+        selected: selSeries
+      });
+    }
+    const showDots = type === "scatter" || spec.points;
+    for (let i = 0; i < n; i++) {
+      const v = pointValue(i);
+      if (v === null || s.values[i] === null) continue;
+      const [cx, cy] = map({ c: catCenter(i), v: valuePx(v) });
+      const target = { kind: "point", seriesId: s.id, index: i };
+      const selected = isSelected(target);
+      const r = type === "scatter" ? 4.5 : 3.5;
+      marks.push({
+        kind: "circle",
+        key: `point-${s.id}-${i}`,
+        role: "point",
+        cx,
+        cy,
+        r: showDots ? r : 6,
+        fill: showDots ? type === "scatter" ? color : theme.surface : "transparent",
+        ...showDots ? { stroke: color, strokeWidth: 2 } : {},
+        opacity: type === "scatter" ? 0.85 : void 0,
+        target,
+        selected: selected || selSeries
+      });
+      if (selected) marks.push({ kind: "circle", key: `point-${s.id}-${i}-selection`, role: "selection", cx, cy, r: r + 3.5, fill: "none", stroke: theme.selection, strokeWidth: 1.5 });
+      if (spec.dataLabels) {
+        const raw = s.values[i];
+        const shown = percent && stack ? stack.segments[i][1] - stack.segments[i][0] : raw;
+        labelMarks.push({
+          kind: "text",
+          key: `label-${s.id}-${i}`,
+          role: "data-label",
+          x: horizontal ? cx + 8 : cx,
+          y: horizontal ? cy : cy - 8,
+          text: dataLabel(shown),
+          anchor: horizontal ? "start" : "middle",
+          baseline: horizontal ? "middle" : "bottom",
+          size: fs - 1,
+          fill: theme.text,
+          target
+        });
+      }
+    }
+  }
+  marks.push(...labelMarks);
+  const valueScale = { axis: horizontal ? "x" : "y", domain, range: valueRange, ticks: scale.ticks };
+  return { width, height, plot, marks, valueScale, percent, theme };
+}
+var order = (t) => t === "area" ? 0 : t === "bar" ? 1 : t === "line" ? 2 : 3;
+function truncate(text2, maxWidth, size, measure) {
+  if (measure(text2, size) <= maxWidth) return text2;
+  let out = text2;
+  while (out.length > 1 && measure(`${out}\u2026`, size) > maxWidth) out = out.slice(0, -1);
+  return `${out}\u2026`;
+}
+function layoutLegend(items, position, area, theme, measure, marks, legendSelected) {
+  const fs = theme.fontSize;
+  const swatch = 10;
+  const rowH = fs * 1.7;
+  const itemW = (item) => swatch + 6 + measure(item.label, fs) + 14;
+  const placed = [];
+  let box;
+  let rest;
+  if (position === "left" || position === "right") {
+    const w = Math.min(area.width * 0.35, Math.max(...items.map(itemW)));
+    const h = Math.min(items.length * rowH, area.height);
+    const x = position === "left" ? area.x : area.x + area.width - w;
+    const y = area.y + (area.height - h) / 2;
+    items.forEach((item, i) => {
+      if ((i + 1) * rowH <= area.height + 0.5) placed.push({ item, x, y: y + i * rowH + rowH / 2 });
+    });
+    box = { x, y, width: w, height: h };
+    rest = position === "left" ? { ...area, x: area.x + w + 8, width: area.width - w - 8 } : { ...area, width: area.width - w - 8 };
+  } else {
+    const rows = [[]];
+    let used = 0;
+    for (const item of items) {
+      const w = itemW(item);
+      if (used + w > area.width && rows[rows.length - 1].length) {
+        rows.push([]);
+        used = 0;
+      }
+      rows[rows.length - 1].push(item);
+      used += w;
+    }
+    const shown = rows.slice(0, 3);
+    const h = shown.length * rowH;
+    const y0 = position === "top" ? area.y : area.y + area.height - h;
+    shown.forEach((row, r) => {
+      const total = row.reduce((t, item) => t + itemW(item), 0) - 14;
+      let x = area.x + (area.width - total) / 2;
+      for (const item of row) {
+        placed.push({ item, x, y: y0 + r * rowH + rowH / 2 });
+        x += itemW(item);
+      }
+    });
+    box = { x: area.x, y: y0, width: area.width, height: h };
+    rest = position === "top" ? { ...area, y: area.y + h + 6, height: area.height - h - 6 } : { ...area, height: area.height - h - 6 };
+  }
+  placed.forEach(({ item, x, y }, i) => {
+    const opacity = item.faded ? 0.4 : void 0;
+    if (item.shape === "line")
+      marks.push({ kind: "line", key: `legend-swatch-${i}`, role: "legend-swatch", x1: x, y1: y, x2: x + swatch, y2: y, stroke: item.color, strokeWidth: 2.5, opacity, target: item.target, selected: item.selected });
+    else
+      marks.push({ kind: "rect", key: `legend-swatch-${i}`, role: "legend-swatch", x, y: y - swatch / 2, width: swatch, height: swatch, radius: 2, fill: item.color, opacity, target: item.target, selected: item.selected });
+    marks.push({
+      kind: "text",
+      key: `legend-label-${i}`,
+      role: "legend-label",
+      x: x + swatch + 6,
+      y,
+      text: item.label,
+      anchor: "start",
+      baseline: "middle",
+      size: fs,
+      fill: item.selected ? theme.selection : theme.text,
+      weight: item.selected ? 600 : void 0,
+      opacity,
+      target: item.target,
+      selected: item.selected
+    });
+  });
+  if (legendSelected) marks.push({ kind: "rect", key: "legend-selection", role: "selection", x: box.x - 4, y: box.y - 2, width: box.width + 8, height: box.height + 4, fill: "none", stroke: theme.selection, strokeWidth: 1, radius: 3 });
+  return rest;
+}
+function layoutPie(spec, series, area, theme, marks, selection, width, height) {
+  const fs = theme.fontSize;
+  const values = spec.categories.map((_, i) => Math.max(0, _nullishCoalesce(series.values[i], () => ( 0))));
+  const total = values.reduce((a, b) => a + b, 0);
+  const labelRoom = spec.dataLabels ? fs * 2.2 : 4;
+  const outer = Math.max(4, Math.min(area.width, area.height) / 2 - labelRoom);
+  const inner = spec.type === "donut" ? outer * spec.innerRadius : 0;
+  const cx = area.x + area.width / 2;
+  const cy = area.y + area.height / 2;
+  const plot = { x: cx - outer, y: cy - outer, width: outer * 2, height: outer * 2 };
+  if (total <= 0) {
+    marks.push({ kind: "text", key: "empty", role: "empty", x: cx, y: cy, text: "No positive values", anchor: "middle", baseline: "middle", size: fs + 1, fill: theme.mutedText });
+    return { width, height, plot, marks, percent: false, theme };
+  }
+  let angle = 0;
+  const format = spec.yAxis.format;
+  values.forEach((v, i) => {
+    if (v <= 0) return;
+    const sweep = v / total * Math.PI * 2;
+    const start = angle;
+    const end = angle + sweep;
+    angle = end;
+    const target = { kind: "point", seriesId: series.id, index: i };
+    const selected = sameChartSelection(selection, target) || sameChartSelection(selection, { kind: "category", index: i });
+    const seriesSel = _optionalChain([selection, 'optionalAccess', _10 => _10.kind]) === "series" && selection.seriesId === series.id;
+    const mid = (start + end) / 2;
+    const off = selected ? 6 : 0;
+    const ox = cx + off * Math.sin(mid);
+    const oy = cy - off * Math.cos(mid);
+    marks.push({
+      kind: "path",
+      key: `slice-${i}`,
+      role: "slice",
+      d: arcPath(ox, oy, outer, inner, start, end),
+      fill: chartSliceColor(spec, i),
+      stroke: selected || seriesSel ? theme.selection : theme.surface,
+      strokeWidth: selected || seriesSel ? 2 : 1,
+      target,
+      selected: selected || seriesSel
+    });
+    if (spec.dataLabels && sweep > 0.12) {
+      const share = v / total;
+      const text2 = format.style ? formatChartNumber(v, format) : `${Math.round(share * 100)}%`;
+      const lr = outer + fs * 1.1;
+      const lx = ox + lr * Math.sin(mid);
+      const ly = oy - lr * Math.cos(mid);
+      const anchor = Math.abs(Math.sin(mid)) < 0.2 ? "middle" : Math.sin(mid) > 0 ? "start" : "end";
+      marks.push({ kind: "text", key: `label-slice-${i}`, role: "data-label", x: lx, y: ly, text: text2, anchor, baseline: "middle", size: fs, fill: theme.text, target });
+    }
+  });
+  if (spec.type === "donut" && inner > fs * 2) {
+    marks.push({ kind: "text", key: "donut-total", role: "data-label", x: cx, y: cy, text: formatChartNumber(total, format), anchor: "middle", baseline: "middle", size: Math.min(theme.titleSize + 4, inner / 2), weight: 600, fill: theme.text, target: { kind: "series", seriesId: series.id } });
+  }
+  return { width, height, plot, marks, percent: false, theme };
+}
+function chartValueAtPoint(scene, point) {
+  const scale = scene.valueScale;
+  if (!scale || scene.percent) return void 0;
+  const px = scale.axis === "y" ? point.y : point.x;
+  return linearMap(px, scale.range, scale.domain);
+}
+function snapChartValue(scene, value, step) {
+  const ticks = _nullishCoalesce(_optionalChain([scene, 'access', _11 => _11.valueScale, 'optionalAccess', _12 => _12.ticks]), () => ( []));
+  const unit = _nullishCoalesce(step, () => ( (ticks.length > 1 ? (ticks[1] - ticks[0]) / 10 : 1)));
+  if (!(unit > 0)) return value;
+  const snapped = Math.round(value / unit) * unit;
+  return Number(snapped.toPrecision(12));
+}
+
+// src/chart/svg.ts
+function chartTextBaseline(baseline) {
+  return baseline === "top" ? "hanging" : baseline === "middle" ? "central" : "text-after-edge";
+}
+function chartTextTransform(mark) {
+  return mark.rotate ? `rotate(${mark.rotate} ${mark.x} ${mark.y})` : void 0;
+}
+var escape = (text2) => text2.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+function attrs(values) {
+  return Object.entries(values).filter(([, v]) => v !== void 0 && v !== "").map(([k, v]) => ` ${k}="${escape(String(v))}"`).join("");
+}
+function markToSvg(mark, fontFamily) {
+  const common = { opacity: mark.opacity, "data-role": mark.role };
+  switch (mark.kind) {
+    case "rect":
+      return `<rect${attrs({ x: mark.x, y: mark.y, width: mark.width, height: mark.height, rx: mark.radius, fill: mark.fill, stroke: mark.stroke, "stroke-width": mark.strokeWidth, ...common })}/>`;
+    case "path":
+      return `<path${attrs({ d: mark.d, fill: _nullishCoalesce(mark.fill, () => ( "none")), stroke: mark.stroke, "stroke-width": mark.strokeWidth, "stroke-dasharray": mark.dash, "stroke-linejoin": "round", "stroke-linecap": "round", ...common })}/>`;
+    case "circle":
+      return `<circle${attrs({ cx: mark.cx, cy: mark.cy, r: mark.r, fill: mark.fill, stroke: mark.stroke, "stroke-width": mark.strokeWidth, ...common })}/>`;
+    case "line":
+      return `<line${attrs({ x1: mark.x1, y1: mark.y1, x2: mark.x2, y2: mark.y2, stroke: mark.stroke, "stroke-width": mark.strokeWidth, "stroke-dasharray": mark.dash, ...common })}/>`;
+    case "text":
+      return `<text${attrs({
+        x: mark.x,
+        y: mark.y,
+        "text-anchor": mark.anchor,
+        "dominant-baseline": chartTextBaseline(mark.baseline),
+        "font-size": mark.size,
+        "font-weight": mark.weight,
+        "font-family": fontFamily,
+        fill: mark.fill,
+        transform: chartTextTransform(mark),
+        ...common
+      })}>${escape(mark.text)}</text>`;
+  }
+}
+function chartSceneToSvg(scene, options = {}) {
+  const hide = _nullishCoalesce(options.hideSelection, () => ( true));
+  const font = scene.theme.fontFamily;
+  const body = scene.marks.filter((m) => !(hide && m.role === "selection")).map((m) => markToSvg(m, font)).join("");
+  const label = options.ariaLabel;
+  return `<svg xmlns="http://www.w3.org/2000/svg" width="${scene.width}" height="${scene.height}" viewBox="0 0 ${scene.width} ${scene.height}" role="img"${label ? ` aria-label="${escape(label)}"` : ""}>${body}</svg>`;
+}
+function chartToSvg(spec, options) {
+  const scene = layoutChart(spec, { ...options, selection: null });
+  return chartSceneToSvg(scene, { ...options, ariaLabel: _nullishCoalesce(options.ariaLabel, () => ( (spec.title || void 0))) });
+}
+
+// src/chart/controller.ts
+var fail = (message, issues) => ({ ok: false, message, ...issues ? { issues } : {} });
+var ChartController = (_class = class {
+  
+  
+  __init() {this.selection = null}
+  __init2() {this.issues = []}
+  __init3() {this.gestureKey = null}
+  __init4() {this.gestureCount = 0}
+  __init5() {this.revision = 0}
+  __init6() {this.applying = false}
+  
+  __init7() {this.listeners = /* @__PURE__ */ new Set()}
+  
+  
+  constructor(options = {}) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);_class.prototype.__init4.call(this);_class.prototype.__init5.call(this);_class.prototype.__init6.call(this);_class.prototype.__init7.call(this);_class.prototype.__init8.call(this);_class.prototype.__init9.call(this);
+    this.history = _nullishCoalesce(options.history, () => ( new (0, _chunkQKLRAA4Tcjs.HistoryManager)()));
+    this.onChange = options.onChange;
+    const { spec, issues } = normalizeChartSpec(_nullishCoalesce(options.spec, () => ( {})));
+    this.spec = spec;
+    this.issues = issues;
+    this.state = this.computeState();
+    this.connect();
+  }
+  connect() {
+    _optionalChain([this, 'access', _13 => _13.unsubscribeHistory, 'optionalCall', _14 => _14()]);
+    this.unsubscribeHistory = this.history.subscribe((h) => {
+      const s = this.state;
+      if (this.applying || s.canUndo === h.canUndo && s.canRedo === h.canRedo && s.undoLabel === h.undoName && s.redoLabel === h.redoName) return;
+      this.notify(false);
+    });
+  }
+  // -------------------------------------------------------------------------
+  // State
+  // -------------------------------------------------------------------------
+  /** The current snapshot (stable until the next change). */
+  __init8() {this.getState = () => this.state}
+  /** Calls `listener` after every change. Returns an unsubscribe function. */
+  __init9() {this.subscribe = (listener) => {
+    if (!this.unsubscribeHistory) this.connect();
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }}
+  /** The current spec (do not mutate; edit through the controller). */
+  getSpec() {
+    return this.spec;
+  }
+  getSeries(id) {
+    return this.spec.series.find((s) => s.id === id);
+  }
+  computeState() {
+    const h = this.history.getState();
+    const sel = this.selection;
+    const seriesId = _optionalChain([sel, 'optionalAccess', _15 => _15.kind]) === "series" || _optionalChain([sel, 'optionalAccess', _16 => _16.kind]) === "point" ? sel.seriesId : null;
+    return {
+      spec: this.spec,
+      selection: sel,
+      selectedSeries: seriesId ? _nullishCoalesce(this.spec.series.find((s) => s.id === seriesId), () => ( null)) : null,
+      selectedIndex: _optionalChain([sel, 'optionalAccess', _17 => _17.kind]) === "point" || _optionalChain([sel, 'optionalAccess', _18 => _18.kind]) === "category" ? sel.index : null,
+      issues: this.issues,
+      gesture: this.gestureKey,
+      canUndo: h.canUndo,
+      canRedo: h.canRedo,
+      undoLabel: h.undoName,
+      redoLabel: h.redoName,
+      revision: this.revision
+    };
+  }
+  notify(specChanged) {
+    this.revision++;
+    this.state = this.computeState();
+    if (specChanged) _optionalChain([this, 'access', _19 => _19.onChange, 'optionalCall', _20 => _20(this.spec)]);
+    const state = this.state;
+    this.listeners.forEach((listener) => {
+      try {
+        listener(state);
+      } catch (error) {
+        console.error("[ChartController] Error in state listener:", error);
+      }
+    });
+  }
+  // -------------------------------------------------------------------------
+  // Changes: every edit records a before / after snapshot of the spec
+  // -------------------------------------------------------------------------
+  /** Drops a selection that no longer points at anything. */
+  validSelection(sel, spec) {
+    if (!sel) return null;
+    switch (sel.kind) {
+      case "series":
+        return spec.series.some((s) => s.id === sel.seriesId) ? sel : null;
+      case "point":
+        return spec.series.some((s) => s.id === sel.seriesId) && sel.index < spec.categories.length ? sel : null;
+      case "category":
+        return sel.index < spec.categories.length ? sel : null;
+      case "title":
+        return spec.title ? sel : null;
+      case "subtitle":
+        return spec.subtitle ? sel : null;
+      default:
+        return sel;
+    }
+  }
+  applySpec(spec) {
+    this.applying = true;
+    try {
+      this.spec = spec;
+      this.selection = this.validSelection(this.selection, spec);
+    } finally {
+      this.applying = false;
+    }
+    this.notify(true);
+  }
+  commit(label, next, select) {
+    const before = this.spec;
+    this.issues = [];
+    const command = {
+      name: label,
+      tag: "chart",
+      execute: () => this.applySpec(next),
+      undo: () => this.applySpec(before),
+      redo: () => this.applySpec(next)
+    };
+    if (select !== void 0) this.selection = select;
+    if (this.gestureKey !== null) this.history.executeMerged(command, { key: `chart.gesture:${this.gestureKey}:${this.gestureCount}` });
+    else this.history.execute(command);
+  }
+  reject(message, issues = []) {
+    this.issues = issues.length ? issues : [{ path: "", message }];
+    this.notify(false);
+    return fail(message, issues.length ? issues : void 0);
+  }
+  /** A copy of the spec with `edit` applied (series and categories copied as needed). */
+  edited(edit) {
+    const draft = cloneChartSpec(this.spec);
+    edit(draft);
+    return draft;
+  }
+  unknownSeries(id) {
+    const ids = this.spec.series.map((s) => `"${s.id}"`);
+    return fail(`There is no series "${id}"; ${ids.length ? `expected one of ${ids.join(", ")}` : "the chart has no series yet"}.`);
+  }
+  badIndex(index) {
+    const n = this.spec.categories.length;
+    return fail(n ? `Category index ${index} is out of range; expected 0 to ${n - 1}.` : "The chart has no categories yet.");
+  }
+  // -------------------------------------------------------------------------
+  // Presentation
+  // -------------------------------------------------------------------------
+  /**
+   * Changes any presentation or data fields as one undo step. All-or-nothing: if anything
+   * is invalid, nothing changes and every problem is returned (and shown in `state.issues`).
+   */
+  update(patch, options = {}) {
+    const s = this.spec;
+    const merged = {
+      ...s,
+      ...patch,
+      xAxis: patch.xAxis ? { ...s.xAxis, ...patch.xAxis } : s.xAxis,
+      yAxis: patch.yAxis ? { ...s.yAxis, ...patch.yAxis } : s.yAxis,
+      legend: patch.legend ? { ...s.legend, ...patch.legend } : s.legend,
+      version: 1
+    };
+    const { spec, issues } = normalizeChartSpec(merged);
+    if (issues.length) return this.reject(issues.map((i) => i.message).join(" "), issues);
+    if (JSON.stringify(spec) === JSON.stringify(s)) return { ok: true };
+    this.commit(_nullishCoalesce(options.label, () => ( updateLabel(patch))), spec);
+    return { ok: true };
+  }
+  setType(type) {
+    return this.update({ type }, { label: `Change chart type` });
+  }
+  setTitle(title) {
+    return this.update({ title }, { label: "Edit title" });
+  }
+  setSubtitle(subtitle) {
+    return this.update({ subtitle }, { label: "Edit subtitle" });
+  }
+  /** Changes the category (`x`) or value (`y`) axis. */
+  setAxis(axis, patch) {
+    return this.update(axis === "x" ? { xAxis: patch } : { yAxis: patch }, { label: `Change ${axis === "x" ? "category" : "value"} axis` });
+  }
+  setLegend(patch) {
+    return this.update({ legend: patch }, { label: "Change legend" });
+  }
+  // -------------------------------------------------------------------------
+  // Data
+  // -------------------------------------------------------------------------
+  /**
+   * Replaces categories and / or series as one undo step. Values are validated and padded
+   * to the categories; all-or-nothing like `update`.
+   */
+  setData(data, options = {}) {
+    return this.update({ ...data.categories ? { categories: data.categories } : {}, ...data.series ? { series: data.series } : {} }, { label: _nullishCoalesce(options.label, () => ( "Edit chart data")) });
+  }
+  /**
+   * Sets one value (numbers, numeric text such as `1,200` or `12%`, or blank for a gap).
+   * One undo step, or part of the current gesture.
+   */
+  setValue(seriesId, index, value, options = {}) {
+    const series = this.getSeries(seriesId);
+    if (!series) return this.unknownSeries(seriesId);
+    if (!Number.isInteger(index) || index < 0 || index >= this.spec.categories.length) return this.badIndex(index);
+    const parsed = parseChartValue(value);
+    if (parsed === void 0) return this.reject(`"${String(value)}" is not a number; enter a number or leave the cell blank.`, [{ path: `${seriesId}[${index}]`, message: `"${String(value)}" is not a number.` }]);
+    if (series.values[index] === parsed) {
+      if (this.issues.length) {
+        this.issues = [];
+        this.notify(false);
+      }
+      return { ok: true };
+    }
+    const next = this.edited((d) => {
+      d.series.find((s) => s.id === seriesId).values[index] = parsed;
+    });
+    this.commit(_nullishCoalesce(options.label, () => ( `Edit ${series.name} \xB7 ${this.spec.categories[index]}`)), next);
+    return { ok: true };
+  }
+  /** Several values as one undo step (all-or-nothing). */
+  setValues(cells, options = {}) {
+    const issues = [];
+    const parsed = [];
+    for (const cell of cells) {
+      if (!this.getSeries(cell.seriesId)) issues.push({ path: cell.seriesId, message: this.unknownSeries(cell.seriesId).message });
+      else if (!Number.isInteger(cell.index) || cell.index < 0 || cell.index >= this.spec.categories.length) issues.push({ path: `${cell.seriesId}[${cell.index}]`, message: this.badIndex(cell.index).message });
+      else {
+        const value = parseChartValue(cell.value);
+        if (value === void 0) issues.push({ path: `${cell.seriesId}[${cell.index}]`, message: `"${String(cell.value)}" is not a number.` });
+        else parsed.push({ seriesId: cell.seriesId, index: cell.index, value });
+      }
+    }
+    if (issues.length) return this.reject(issues.map((i) => i.message).join(" "), issues);
+    const next = this.edited((d) => {
+      for (const cell of parsed) d.series.find((s) => s.id === cell.seriesId).values[cell.index] = cell.value;
+    });
+    if (JSON.stringify(next.series) !== JSON.stringify(this.spec.series)) this.commit(_nullishCoalesce(options.label, () => ( "Edit values")), next);
+    return { ok: true };
+  }
+  /** Adds a series (values padded to the categories) and selects it. Returns its id. */
+  addSeries(input = {}, options = {}) {
+    const id = input.id && !this.getSeries(input.id) ? input.id : uniqueChartSeriesId(this.spec.series);
+    const name = _nullishCoalesce(input.name, () => ( `Series ${this.spec.series.length + 1}`));
+    const at = Math.max(0, Math.min(this.spec.series.length, _nullishCoalesce(options.at, () => ( this.spec.series.length))));
+    const series = [...this.spec.series];
+    series.splice(at, 0, { ...input, id, name, values: _nullishCoalesce(input.values, () => ( [])) });
+    const { spec, issues } = normalizeChartSpec({ ...this.spec, series });
+    if (issues.length) return this.reject(issues.map((i) => i.message).join(" "), issues);
+    this.commit(`Add series "${name}"`, spec, { kind: "series", seriesId: id });
+    return { ok: true, id };
+  }
+  removeSeries(id) {
+    const series = this.getSeries(id);
+    if (!series) return this.unknownSeries(id);
+    this.commit(
+      `Delete series "${series.name}"`,
+      this.edited((d) => {
+        d.series = d.series.filter((s) => s.id !== id);
+      })
+    );
+    return { ok: true };
+  }
+  updateSeries(id, patch) {
+    const series = this.getSeries(id);
+    if (!series) return this.unknownSeries(id);
+    const next = cloneChartSeries(series);
+    if (patch.name !== void 0) next.name = String(patch.name);
+    if (patch.color === null || patch.color === "") delete next.color;
+    else if (patch.color !== void 0) next.color = patch.color;
+    if (patch.type === null) delete next.type;
+    else if (patch.type !== void 0) next.type = patch.type;
+    if (patch.hidden !== void 0) {
+      if (patch.hidden) next.hidden = true;
+      else delete next.hidden;
+    }
+    const series2 = this.spec.series.map((s) => s.id === id ? next : s);
+    const { spec, issues } = normalizeChartSpec({ ...this.spec, series: series2 });
+    if (issues.length) return this.reject(issues.map((i) => i.message).join(" "), issues);
+    if (JSON.stringify(spec.series) === JSON.stringify(this.spec.series)) return { ok: true };
+    const label = patch.hidden !== void 0 && Object.keys(patch).length === 1 ? `${patch.hidden ? "Hide" : "Show"} "${series.name}"` : patch.name !== void 0 && Object.keys(patch).length === 1 ? "Rename series" : `Change series "${series.name}"`;
+    this.commit(label, spec);
+    return { ok: true };
+  }
+  toggleSeries(id) {
+    const series = this.getSeries(id);
+    if (!series) return this.unknownSeries(id);
+    return this.updateSeries(id, { hidden: !series.hidden });
+  }
+  /** Moves a series to position `to` (drawing and legend order). */
+  moveSeries(id, to) {
+    const from = this.spec.series.findIndex((s) => s.id === id);
+    if (from < 0) return this.unknownSeries(id);
+    const target = Math.max(0, Math.min(this.spec.series.length - 1, to));
+    if (target === from) return { ok: true };
+    this.commit(
+      "Reorder series",
+      this.edited((d) => {
+        const [s] = d.series.splice(from, 1);
+        d.series.splice(target, 0, s);
+      })
+    );
+    return { ok: true };
+  }
+  /** Inserts a category (with gaps in every series) at `at` (default: the end). Returns its index. */
+  addCategory(label, options = {}) {
+    const at = Math.max(0, Math.min(this.spec.categories.length, _nullishCoalesce(options.at, () => ( this.spec.categories.length))));
+    const name = _nullishCoalesce(label, () => ( `${this.spec.categories.length + 1}`));
+    this.commit(
+      `Add category "${name}"`,
+      this.edited((d) => {
+        d.categories.splice(at, 0, name);
+        for (const s of d.series) s.values.splice(at, 0, null);
+      }),
+      { kind: "category", index: at }
+    );
+    return { ok: true, index: at };
+  }
+  removeCategory(index) {
+    if (!Number.isInteger(index) || index < 0 || index >= this.spec.categories.length) return this.badIndex(index);
+    this.commit(
+      `Delete category "${this.spec.categories[index]}"`,
+      this.edited((d) => {
+        d.categories.splice(index, 1);
+        for (const s of d.series) s.values.splice(index, 1);
+      })
+    );
+    return { ok: true };
+  }
+  renameCategory(index, label) {
+    if (!Number.isInteger(index) || index < 0 || index >= this.spec.categories.length) return this.badIndex(index);
+    if (this.spec.categories[index] === label) return { ok: true };
+    this.commit(
+      "Rename category",
+      this.edited((d) => {
+        d.categories[index] = String(label);
+      })
+    );
+    return { ok: true };
+  }
+  moveCategory(from, to) {
+    if (!Number.isInteger(from) || from < 0 || from >= this.spec.categories.length) return this.badIndex(from);
+    const target = Math.max(0, Math.min(this.spec.categories.length - 1, to));
+    if (target === from) return { ok: true };
+    const move = (list) => {
+      const [item] = list.splice(from, 1);
+      list.splice(target, 0, item);
+    };
+    this.commit(
+      "Reorder categories",
+      this.edited((d) => {
+        move(d.categories);
+        for (const s of d.series) move(s.values);
+      })
+    );
+    return { ok: true };
+  }
+  /**
+   * Pastes a block of cells (TSV / CSV text or rows) into the data grid with its top-left at
+   * `row` (category index) and `column` (series index; `-1` is the category column). The
+   * grid grows to fit. Non-numeric value cells become gaps and are reported in `issues`.
+   */
+  pasteCells(row, column, cells) {
+    const rows = typeof cells === "string" ? cells.includes("	") ? _chunkTNNJXF46cjs.parseTsv.call(void 0, cells) : _chunkTNNJXF46cjs.parseCsv.call(void 0, cells) : cells.map((r) => [...r]);
+    if (!rows.length) return { ok: true };
+    const issues = [];
+    const next = this.edited((d) => {
+      const width = Math.max(...rows.map((r) => r.length));
+      const lastSeries = column + width - 1;
+      while (d.series.length <= lastSeries) {
+        const id = uniqueChartSeriesId(d.series);
+        d.series.push({ id, name: `Series ${d.series.length + 1}`, values: d.categories.map(() => null) });
+      }
+      const lastRow = row + rows.length - 1;
+      while (d.categories.length <= lastRow) {
+        d.categories.push(`${d.categories.length + 1}`);
+        for (const s of d.series) s.values.push(null);
+      }
+      rows.forEach((cellsInRow, r) => {
+        cellsInRow.forEach((cell, c) => {
+          const col = column + c;
+          const index = row + r;
+          if (col < 0) d.categories[index] = cell === null || cell === void 0 ? "" : String(cell).trim();
+          else {
+            const parsed = parseChartValue(cell);
+            if (parsed === void 0) issues.push({ path: `${d.series[col].id}[${index}]`, message: `"${String(cell)}" is not a number; it was left blank.` });
+            d.series[col].values[index] = _nullishCoalesce(parsed, () => ( null));
+          }
+        });
+      });
+    });
+    this.commit("Paste cells", next);
+    if (issues.length) {
+      this.issues = issues;
+      this.notify(false);
+    }
+    return issues.length ? { ok: true, issues } : { ok: true };
+  }
+  /**
+   * Replaces the data with a grid of cells (see `chartDataFromTable`): one undo step. Series
+   * colours and types are kept by name.
+   */
+  importTable(rows, options = {}) {
+    const data = chartDataFromTable(rows, options);
+    if (!data.categories.length || !data.series.length) return this.reject("There is no data to import: expected a header row and at least one row of values.");
+    const byName = new Map(this.spec.series.map((s) => [s.name, s]));
+    const series = data.series.map((s) => {
+      const old = byName.get(s.name);
+      return { ...s, ..._optionalChain([old, 'optionalAccess', _21 => _21.color]) ? { color: old.color } : {}, ..._optionalChain([old, 'optionalAccess', _22 => _22.type]) ? { type: old.type } : {}, ...old ? { id: old.id } : {} };
+    });
+    const { spec } = normalizeChartSpec({ ...this.spec, categories: data.categories, series });
+    this.commit("Import data", spec);
+    if (data.issues.length) {
+      this.issues = data.issues;
+      this.notify(false);
+      return { ok: true, issues: data.issues };
+    }
+    return { ok: true };
+  }
+  /** Imports CSV (or TSV, detected by tabs) text; see `importTable`. */
+  importCsv(text2, options = {}) {
+    const delimiter = _nullishCoalesce(options.delimiter, () => ( (text2.includes("	") ? "	" : ",")));
+    return this.importTable(_chunkTNNJXF46cjs.parseCsv.call(void 0, text2, { delimiter }), options);
+  }
+  // -------------------------------------------------------------------------
+  // Selection and gestures
+  // -------------------------------------------------------------------------
+  /** Selects a chart element (view state; not an undo step). */
+  select(selection) {
+    const next = this.validSelection(selection, this.spec);
+    if (sameChartSelection(next, this.selection) || next === null && this.selection === null) return;
+    this.selection = next;
+    this.notify(false);
+  }
+  /**
+   * Deletes what is selected: a series or category is removed, a point becomes a gap, a
+   * title is cleared, the legend or an axis is hidden.
+   */
+  deleteSelection() {
+    const sel = this.selection;
+    if (!sel) return fail("Nothing is selected.");
+    switch (sel.kind) {
+      case "series":
+        return this.removeSeries(sel.seriesId);
+      case "category":
+        return this.removeCategory(sel.index);
+      case "point":
+        return this.setValue(sel.seriesId, sel.index, null, { label: "Clear value" });
+      case "title":
+        return this.setTitle("");
+      case "subtitle":
+        return this.setSubtitle("");
+      case "legend":
+        return this.setLegend({ show: false });
+      case "axis":
+        return this.setAxis(sel.axis, { show: false });
+      default:
+        return fail("The chart itself cannot be deleted.");
+    }
+  }
+  /** Adds `delta` to a value (a gap counts as 0). */
+  nudgeValue(seriesId, index, delta) {
+    const series = this.getSeries(seriesId);
+    if (!series) return this.unknownSeries(seriesId);
+    const current = _nullishCoalesce(series.values[index], () => ( 0));
+    return this.setValue(seriesId, index, Number((current + delta).toPrecision(12)), { label: `Edit ${series.name} \xB7 ${_nullishCoalesce(this.spec.categories[index], () => ( index))}` });
+  }
+  /** Starts a continuous edit (a drag): every change until `endGesture()` is one undo step. */
+  beginGesture(key) {
+    if (this.gestureKey === key) return;
+    this.history.endGesture();
+    this.gestureKey = key;
+    this.gestureCount++;
+    this.notify(false);
+  }
+  endGesture() {
+    if (this.gestureKey === null) return;
+    this.gestureKey = null;
+    this.history.endGesture();
+    this.notify(false);
+  }
+  // -------------------------------------------------------------------------
+  // Persistence and history
+  // -------------------------------------------------------------------------
+  /** The spec, for saving (a copy). */
+  toJSON() {
+    return cloneChartSpec(this.spec);
+  }
+  /**
+   * Replaces the chart without an undo step (e.g. when opening a document). Problems are
+   * fixed with defaults and reported in `state.issues` (and returned).
+   */
+  load(input, options = {}) {
+    const { spec, issues } = normalizeChartSpec(input);
+    this.spec = spec;
+    this.issues = issues;
+    this.selection = this.validSelection(this.selection, spec);
+    if (options.clearHistory) {
+      this.applying = true;
+      try {
+        this.history.clear();
+      } finally {
+        this.applying = false;
+      }
+    }
+    this.notify(true);
+    return issues;
+  }
+  undo() {
+    this.endGesture();
+    return this.history.undo();
+  }
+  redo() {
+    this.endGesture();
+    return this.history.redo();
+  }
+  /** Stops listening to the history (reconnected by the next `subscribe`). */
+  destroy() {
+    _optionalChain([this, 'access', _23 => _23.unsubscribeHistory, 'optionalCall', _24 => _24()]);
+    this.unsubscribeHistory = void 0;
+    this.listeners.clear();
+  }
+}, _class);
+function createChartController(options = {}) {
+  return new ChartController(options);
+}
+function updateLabel(patch) {
+  const keys = Object.keys(patch);
+  if (keys.length !== 1) return "Change chart";
+  const labels = {
+    type: "Change chart type",
+    title: "Edit title",
+    subtitle: "Edit subtitle",
+    categories: "Edit categories",
+    series: "Edit series",
+    xAxis: "Change category axis",
+    yAxis: "Change value axis",
+    legend: "Change legend",
+    stacking: "Change stacking",
+    orientation: "Change orientation",
+    curve: "Change line style",
+    points: "Toggle points",
+    dataLabels: "Toggle data labels",
+    palette: "Change colours",
+    innerRadius: "Change donut hole"
+  };
+  return _nullishCoalesce(labels[keys[0]], () => ( "Change chart"));
+}
+
+// src/chart/commands.ts
+var fail2 = (message) => {
+  throw new Error(message);
+};
+var check = (result) => {
+  if (!result.ok) fail2(_nullishCoalesce(result.message, () => ( "The change was rejected.")));
+};
+var VALUE = { type: ["number", "string", "null"], description: 'A number, numeric text ("1,200", "12%") or null for a gap.' };
+var FORMAT = {
+  type: "object",
+  properties: {
+    style: { type: "string", enum: [...CHART_NUMBER_STYLES] },
+    decimals: { type: "integer", minimum: 0, maximum: 10 },
+    currency: { type: "string", description: 'ISO code for style "currency", e.g. "EUR".' },
+    prefix: { type: "string" },
+    suffix: { type: "string" }
+  },
+  additionalProperties: false
+};
+var AXIS = {
+  type: "object",
+  properties: {
+    show: { type: "boolean" },
+    title: { type: "string" },
+    min: { type: ["number", "null"], description: "Fixed lower bound, or null for automatic." },
+    max: { type: ["number", "null"], description: "Fixed upper bound, or null for automatic." },
+    gridlines: { type: "boolean" },
+    format: FORMAT
+  },
+  additionalProperties: false
+};
+var SERIES = {
+  type: "object",
+  properties: {
+    id: { type: "string" },
+    name: { type: "string" },
+    values: { type: "array", items: VALUE, description: "One value per category." },
+    color: { type: "string", description: "CSS colour." },
+    type: { type: "string", enum: [...CHART_SERIES_TYPES], description: "Draw this series differently (combo charts)." },
+    hidden: { type: "boolean" }
+  },
+  required: ["name", "values"],
+  additionalProperties: false
+};
+function createChartCommands(controller, options = {}) {
+  const prefix = _nullishCoalesce(options.prefix, () => ( "chart."));
+  const base = { group: _nullishCoalesce(options.group, () => ( "Chart")), ...options.scope ? { scope: options.scope } : {} };
+  const seriesIds = () => controller.getSpec().series.map((s) => s.id);
+  const resolveSeries = (ref) => {
+    const spec = controller.getSpec();
+    const series = _nullishCoalesce(spec.series.find((s) => s.id === ref), () => ( spec.series.find((s) => s.name === ref)));
+    if (!series) fail2(`There is no series "${ref}"; expected one of ${seriesIds().map((id) => `"${id}"`).join(", ") || "(none yet)"}.`);
+    return series;
+  };
+  const resolveCategory = (ref) => {
+    const categories = controller.getSpec().categories;
+    const index = typeof ref === "number" ? ref : categories.indexOf(ref);
+    if (index < 0 || index >= categories.length || !Number.isInteger(index)) fail2(`There is no category ${JSON.stringify(ref)}; expected an index from 0 to ${categories.length - 1} or one of the labels.`);
+    return index;
+  };
+  return [
+    {
+      ...base,
+      id: `${prefix}describe`,
+      label: "Describe Chart",
+      readOnly: true,
+      keywords: ["chart", "data", "spec", "get"],
+      description: "Returns the chart spec (type, titles, axes, legend, options) and its data as a table with series names in the header row.",
+      run: () => {
+        const spec = controller.getSpec();
+        return { spec: controller.toJSON(), table: chartDataToTable(spec), issues: controller.getState().issues };
+      }
+    },
+    {
+      ...base,
+      id: `${prefix}update`,
+      label: "Change Chart\u2026",
+      keywords: ["chart", "title", "axis", "legend", "stack", "style", "format"],
+      description: "Changes chart presentation as one undo step: type, titles, axes (x = categories, y = values), legend, stacking, orientation, curve, points, data labels, palette or donut hole. Invalid values change nothing and return why.",
+      params: {
+        type: "object",
+        properties: {
+          type: { type: "string", enum: [...CHART_TYPES] },
+          title: { type: "string" },
+          subtitle: { type: "string" },
+          xAxis: AXIS,
+          yAxis: AXIS,
+          legend: { type: "object", properties: { show: { type: "boolean" }, position: { type: "string", enum: [...CHART_LEGEND_POSITIONS] } }, additionalProperties: false },
+          stacking: { type: "string", enum: [...CHART_STACKINGS] },
+          orientation: { type: "string", enum: [...CHART_ORIENTATIONS] },
+          curve: { type: "string", enum: [...CHART_CURVES] },
+          points: { type: "boolean" },
+          dataLabels: { type: "boolean" },
+          palette: { type: "array", items: { type: "string" }, minItems: 1 },
+          innerRadius: { type: "number", minimum: 0, maximum: 0.9 }
+        },
+        additionalProperties: false
+      },
+      run: (_ctx, params) => {
+        check(controller.update(params));
+        return { spec: controller.toJSON() };
+      }
+    },
+    {
+      ...base,
+      id: `${prefix}setData`,
+      label: "Replace Chart Data\u2026",
+      keywords: ["chart", "data", "series", "categories"],
+      description: "Replaces the categories and series as one undo step. Each series has one value per category (padded with gaps).",
+      params: {
+        type: "object",
+        properties: {
+          categories: { type: "array", items: { type: "string" } },
+          series: { type: "array", items: SERIES }
+        },
+        additionalProperties: false
+      },
+      run: (_ctx, params) => {
+        check(controller.setData(params));
+        return { table: chartDataToTable(controller.getSpec()) };
+      }
+    },
+    {
+      ...base,
+      id: `${prefix}setValues`,
+      label: "Set Chart Values\u2026",
+      keywords: ["chart", "value", "cell", "edit"],
+      description: "Sets individual values as one undo step. Series by id or name; category by index or label.",
+      params: {
+        type: "object",
+        properties: {
+          cells: {
+            type: "array",
+            minItems: 1,
+            items: {
+              type: "object",
+              properties: { series: { type: "string" }, category: { type: ["string", "integer"] }, value: VALUE },
+              required: ["series", "category", "value"],
+              additionalProperties: false
+            }
+          }
+        },
+        required: ["cells"]
+      },
+      run: (_ctx, params) => {
+        check(controller.setValues(params.cells.map((c) => ({ seriesId: resolveSeries(c.series).id, index: resolveCategory(c.category), value: c.value }))));
+        return { table: chartDataToTable(controller.getSpec()) };
+      }
+    },
+    {
+      ...base,
+      id: `${prefix}addSeries`,
+      label: "Add Series",
+      keywords: ["chart", "series", "new"],
+      description: "Adds a series (default: an empty one at the end). Returns its id.",
+      params: { type: "object", properties: { ...SERIES.properties, at: { type: "integer", minimum: 0 } }, additionalProperties: false },
+      run: (_ctx, params = {}) => {
+        const { at, ...input } = _nullishCoalesce(params, () => ( {}));
+        const result = controller.addSeries(input, { at });
+        check(result);
+        return { id: result.id };
+      }
+    },
+    {
+      ...base,
+      id: `${prefix}updateSeries`,
+      label: "Change Series\u2026",
+      keywords: ["chart", "series", "rename", "colour", "color", "hide"],
+      description: "Renames, recolours, hides or changes how a series is drawn (null colour / type resets it).",
+      params: {
+        type: "object",
+        properties: {
+          series: { type: "string", description: "Series id or name." },
+          name: { type: "string" },
+          color: { type: ["string", "null"] },
+          type: { type: ["string", "null"], enum: [...CHART_SERIES_TYPES, null] },
+          hidden: { type: "boolean" }
+        },
+        required: ["series"],
+        additionalProperties: false
+      },
+      run: (_ctx, params) => {
+        const { series, ...patch } = params;
+        const id = resolveSeries(series).id;
+        check(controller.updateSeries(id, patch));
+        return { series: controller.getSeries(id) };
+      }
+    },
+    {
+      ...base,
+      id: `${prefix}removeSeries`,
+      label: "Delete Series",
+      keywords: ["chart", "series", "remove"],
+      description: "Deletes a series by id or name.",
+      params: { type: "object", properties: { series: { type: "string" } }, required: ["series"], additionalProperties: false },
+      run: (_ctx, params) => {
+        check(controller.removeSeries(resolveSeries(params.series).id));
+        return { series: seriesIds() };
+      }
+    },
+    {
+      ...base,
+      id: `${prefix}addCategory`,
+      label: "Add Category",
+      keywords: ["chart", "category", "row", "label"],
+      description: "Inserts a category (gaps in every series) at `at` (default: the end).",
+      params: { type: "object", properties: { label: { type: "string" }, at: { type: "integer", minimum: 0 } }, additionalProperties: false },
+      run: (_ctx, params = {}) => controller.addCategory(_optionalChain([params, 'optionalAccess', _25 => _25.label]), { at: _optionalChain([params, 'optionalAccess', _26 => _26.at]) })
+    },
+    {
+      ...base,
+      id: `${prefix}removeCategory`,
+      label: "Delete Category",
+      keywords: ["chart", "category", "row", "remove"],
+      description: "Deletes a category (and its values) by index or label.",
+      params: { type: "object", properties: { category: { type: ["string", "integer"] } }, required: ["category"], additionalProperties: false },
+      run: (_ctx, params) => {
+        check(controller.removeCategory(resolveCategory(params.category)));
+        return { categories: controller.getSpec().categories };
+      }
+    },
+    {
+      ...base,
+      id: `${prefix}importCsv`,
+      label: "Import Chart Data from CSV\u2026",
+      keywords: ["chart", "csv", "tsv", "paste", "import"],
+      description: "Replaces the data with CSV / TSV text: by default the first column holds categories and the first row series names.",
+      params: {
+        type: "object",
+        properties: {
+          csv: { type: "string" },
+          seriesIn: { type: "string", enum: ["columns", "rows"] },
+          header: { type: "boolean" }
+        },
+        required: ["csv"],
+        additionalProperties: false
+      },
+      run: (_ctx, params) => {
+        const result = controller.importCsv(params.csv, { seriesIn: params.seriesIn, header: params.header });
+        check(result);
+        return { table: chartDataToTable(controller.getSpec()), issues: _nullishCoalesce(result.issues, () => ( [])) };
+      }
+    },
+    {
+      ...base,
+      id: `${prefix}exportSvg`,
+      label: "Export Chart as SVG",
+      readOnly: true,
+      keywords: ["chart", "svg", "export", "image"],
+      description: "Returns the chart drawn as a standalone SVG string.",
+      params: { type: "object", properties: { width: { type: "number", minimum: 50 }, height: { type: "number", minimum: 50 } }, additionalProperties: false },
+      run: (_ctx, params = {}) => ({
+        svg: chartToSvg(controller.getSpec(), { width: _nullishCoalesce(_optionalChain([params, 'optionalAccess', _27 => _27.width]), () => ( 640)), height: _nullishCoalesce(_optionalChain([params, 'optionalAccess', _28 => _28.height]), () => ( 400)) })
+      })
+    },
+    {
+      ...base,
+      id: `${prefix}undo`,
+      label: "Undo Chart Edit",
+      keywords: ["chart", "undo"],
+      enabled: () => controller.getState().canUndo || "Nothing to undo",
+      run: () => ({ undone: controller.undo() })
+    },
+    {
+      ...base,
+      id: `${prefix}redo`,
+      label: "Redo Chart Edit",
+      keywords: ["chart", "redo"],
+      enabled: () => controller.getState().canRedo || "Nothing to redo",
+      run: () => ({ redone: controller.redo() })
+    }
+  ];
+}
+
+// src/chart/interaction.ts
+function chartClientToScene(scene, box, clientX, clientY) {
+  const sx = box.width ? scene.width / box.width : 1;
+  const sy = box.height ? scene.height / box.height : 1;
+  return { x: (clientX - box.left) * sx, y: (clientY - box.top) * sy };
+}
+function canDragChartPoint(controller, scene, target) {
+  if (_optionalChain([target, 'optionalAccess', _29 => _29.kind]) !== "point" || !scene.valueScale || scene.percent) return false;
+  const spec = controller.getSpec();
+  if (!isCartesianChart(spec.type)) return false;
+  const series = controller.getSeries(target.seriesId);
+  return !!series && !series.hidden && series.values[target.index] !== null;
+}
+function startChartPointDrag(controller, scene, target, start, options = {}) {
+  if (!canDragChartPoint(controller, scene, target)) return null;
+  const { seriesId, index } = target;
+  const startValue = _nullishCoalesce(controller.getSeries(seriesId).values[index], () => ( 0));
+  const startAt = chartValueAtPoint(scene, start);
+  if (startAt === void 0) return null;
+  controller.beginGesture(`drag:${seriesId}:${index}`);
+  let ended = false;
+  return {
+    move(point) {
+      if (ended) return;
+      const at = chartValueAtPoint(scene, point);
+      if (at === void 0) return;
+      controller.setValue(seriesId, index, snapChartValue(scene, startValue + (at - startAt), options.step), { label: `Drag ${_nullishCoalesce(_optionalChain([controller, 'access', _30 => _30.getSeries, 'call', _31 => _31(seriesId), 'optionalAccess', _32 => _32.name]), () => ( "value"))}` });
+    },
+    end() {
+      if (ended) return;
+      ended = true;
+      controller.endGesture();
+    }
+  };
+}
+function handleChartKey(controller, scene, event) {
+  if (event.metaKey || event.ctrlKey || event.altKey) return false;
+  const { selection, spec } = controller.getState();
+  switch (event.key) {
+    case "Escape":
+      if (!selection) return false;
+      controller.select(null);
+      return true;
+    case "Delete":
+    case "Backspace":
+      if (!selection || selection.kind === "chart") return false;
+      controller.deleteSelection();
+      return true;
+    case "ArrowLeft":
+    case "ArrowRight": {
+      if (_optionalChain([selection, 'optionalAccess', _33 => _33.kind]) !== "point" && _optionalChain([selection, 'optionalAccess', _34 => _34.kind]) !== "category") return false;
+      const n = spec.categories.length;
+      const index = Math.max(0, Math.min(n - 1, selection.index + (event.key === "ArrowRight" ? 1 : -1)));
+      controller.select({ ...selection, index });
+      return true;
+    }
+    case "ArrowUp":
+    case "ArrowDown": {
+      if (_optionalChain([selection, 'optionalAccess', _35 => _35.kind]) !== "point" || _optionalChain([scene, 'optionalAccess', _36 => _36.percent])) return false;
+      const ticks = _nullishCoalesce(_optionalChain([scene, 'optionalAccess', _37 => _37.valueScale, 'optionalAccess', _38 => _38.ticks]), () => ( []));
+      const step = ticks.length > 1 ? ticks[1] - ticks[0] : 1;
+      const delta = (event.shiftKey ? step : step / 10) * (event.key === "ArrowUp" ? 1 : -1);
+      controller.nudgeValue(selection.seriesId, selection.index, delta);
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+function describeChartSelection(controller, selection = controller.getState().selection) {
+  if (!selection) return "Nothing selected";
+  const spec = controller.getSpec();
+  switch (selection.kind) {
+    case "chart":
+      return "Chart";
+    case "title":
+      return "Title";
+    case "subtitle":
+      return "Subtitle";
+    case "legend":
+      return "Legend";
+    case "axis":
+      return selection.axis === "x" ? "Category axis" : "Value axis";
+    case "series":
+      return `Series "${_nullishCoalesce(_optionalChain([controller, 'access', _39 => _39.getSeries, 'call', _40 => _40(selection.seriesId), 'optionalAccess', _41 => _41.name]), () => ( selection.seriesId))}"`;
+    case "category":
+      return `Category "${_nullishCoalesce(spec.categories[selection.index], () => ( selection.index))}"`;
+    case "point": {
+      const series = controller.getSeries(selection.seriesId);
+      const value = _optionalChain([series, 'optionalAccess', _42 => _42.values, 'access', _43 => _43[selection.index]]);
+      return `${_nullishCoalesce(_optionalChain([series, 'optionalAccess', _44 => _44.name]), () => ( selection.seriesId))} \xB7 ${_nullishCoalesce(spec.categories[selection.index], () => ( selection.index))}: ${_nullishCoalesce(value, () => ( "blank"))}`;
+    }
+  }
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.CHART_CURVES = CHART_CURVES; exports.CHART_LEGEND_POSITIONS = CHART_LEGEND_POSITIONS; exports.CHART_NUMBER_STYLES = CHART_NUMBER_STYLES; exports.CHART_ORIENTATIONS = CHART_ORIENTATIONS; exports.CHART_SERIES_TYPES = CHART_SERIES_TYPES; exports.CHART_STACKINGS = CHART_STACKINGS; exports.CHART_TYPES = CHART_TYPES; exports.CHART_TYPE_LABELS = CHART_TYPE_LABELS; exports.CSS_VARIABLE_CHART_THEME = CSS_VARIABLE_CHART_THEME; exports.ChartController = ChartController; exports.DEFAULT_CHART_PALETTE = DEFAULT_CHART_PALETTE; exports.DEFAULT_CHART_THEME = DEFAULT_CHART_THEME; exports.canDragChartPoint = canDragChartPoint; exports.chartClientToScene = chartClientToScene; exports.chartColorInputValue = chartColorInputValue; exports.chartDataFromTable = chartDataFromTable; exports.chartDataToTable = chartDataToTable; exports.chartSceneToSvg = chartSceneToSvg; exports.chartSeriesColor = chartSeriesColor; exports.chartSeriesType = chartSeriesType; exports.chartSliceColor = chartSliceColor; exports.chartTextBaseline = chartTextBaseline; exports.chartTextTransform = chartTextTransform; exports.chartToSvg = chartToSvg; exports.chartValueAtPoint = chartValueAtPoint; exports.cloneChartSeries = cloneChartSeries; exports.cloneChartSpec = cloneChartSpec; exports.createChartCommands = createChartCommands; exports.createChartController = createChartController; exports.createChartSpec = createChartSpec; exports.defaultChartAxis = defaultChartAxis; exports.describeChartSelection = describeChartSelection; exports.estimateChartTextWidth = estimateChartTextWidth; exports.formatChartNumber = formatChartNumber; exports.handleChartKey = handleChartKey; exports.isCartesianChart = isCartesianChart; exports.layoutChart = layoutChart; exports.linearMap = linearMap; exports.niceScale = niceScale; exports.niceStep = niceStep; exports.normalizeChartAxis = normalizeChartAxis; exports.normalizeChartSpec = normalizeChartSpec; exports.normalizeChartValues = normalizeChartValues; exports.parseChartValue = parseChartValue; exports.sameChartSelection = sameChartSelection; exports.snapChartValue = snapChartValue; exports.startChartPointDrag = startChartPointDrag; exports.stepDecimals = stepDecimals; exports.uniqueChartSeriesId = uniqueChartSeriesId;
+//# sourceMappingURL=index.cjs.map