@pixerate/editor 0.47.0 → 0.49.0

package/dist/chunk-GTZXF4BI.cjs

@@ -0,0 +1,3424 @@
+"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 _chunkJOX6MJW4cjs = require('./chunk-JOX6MJW4.cjs');
+
+
+var _chunkXP5IUZUOcjs = require('./chunk-XP5IUZUO.cjs');
+
+
+
+var _chunkTNNJXF46cjs = require('./chunk-TNNJXF46.cjs');
+
+
+var _chunkQKLRAA4Tcjs = require('./chunk-QKLRAA4T.cjs');
+
+// src/chart/mermaid.ts
+var CHART_MERMAID_META_PREFIX = "%% @pixerate ";
+var quote = (text) => `"${text.replace(/"/g, "#quot;")}"`;
+var unquote = (text) => {
+  const t = text.trim();
+  return (t.length >= 2 && t.startsWith('"') && t.endsWith('"') ? t.slice(1, -1) : t).replace(/#quot;/g, '"');
+};
+var word = (text) => /^[A-Za-z0-9_]+$/.test(text) ? text : quote(text);
+var num = (value) => Number.isInteger(value) ? String(value) : String(Number(value.toPrecision(10)));
+function splitOutside(text, sep) {
+  const out = [];
+  let cur = "";
+  let quoted = false;
+  let depth = 0;
+  for (const ch of text) {
+    if (ch === '"') quoted = !quoted;
+    else if (!quoted && (ch === "[" || ch === "{")) depth++;
+    else if (!quoted && (ch === "]" || ch === "}")) depth--;
+    if (ch === sep && !quoted && depth === 0) {
+      out.push(cur);
+      cur = "";
+    } else cur += ch;
+  }
+  out.push(cur);
+  return out;
+}
+function chartMermaidFamily(spec) {
+  const family = _chunkJOX6MJW4cjs.chartFamily.call(void 0, spec);
+  if (family === "pie" || family === "funnel" || family === "treemap") return "pie";
+  if (family === "radar") return "radar";
+  return "xychart";
+}
+function slug(label, i, taken) {
+  let base = label.normalize("NFKD").replace(/[^\w-]+/g, "_").replace(/^_+|_+$/g, "") || `a${i + 1}`;
+  if (!/^[A-Za-z_]/.test(base)) base = `a_${base}`;
+  let id = base;
+  for (let k = 2; taken.has(id); k++) id = `${base}_${k}`;
+  taken.add(id);
+  return id;
+}
+function metaFor(spec, text) {
+  const base = chartFromMermaid(text, { ignoreMeta: true }).spec;
+  const meta = {};
+  const same = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+  for (const key of Object.keys(spec)) {
+    if (key === "series" || key === "version") continue;
+    if (!same(spec[key], base[key])) meta[key] = spec[key];
+  }
+  const series = spec.series.map((s, i) => {
+    const b = base.series[i];
+    const out = {};
+    for (const [k, v] of Object.entries(s)) {
+      if (k === "values") {
+        if (b && !same(v, b.values)) out.values = v;
+        continue;
+      }
+      if (!b || !same(v, b[k])) out[k] = v;
+    }
+    return out;
+  });
+  if (series.some((s) => Object.keys(s).length) || spec.series.length !== base.series.length) meta.series = series;
+  return Object.keys(meta).length ? meta : null;
+}
+function chartToMermaid(spec, options = {}) {
+  const ind = _nullishCoalesce(options.indent, () => ( "    "));
+  const family = chartMermaidFamily(spec);
+  const visible = spec.series.filter((s) => !s.hidden);
+  const lines = [];
+  const v = (x) => x === null || !Number.isFinite(x) ? "0" : num(x);
+  if (family === "pie") {
+    const s = _nullishCoalesce(visible[0], () => ( spec.series[0]));
+    lines.push(`pie${spec.dataLabels ? " showData" : ""}`);
+    if (spec.title) lines.push(`${ind}title ${spec.title}`);
+    spec.categories.forEach((c, i) => {
+      const value = _optionalChain([s, 'optionalAccess', _2 => _2.values, 'access', _3 => _3[i]]);
+      if (value !== null && value !== void 0 && Number.isFinite(value) && value > 0) lines.push(`${ind}${quote(c)} : ${num(value)}`);
+    });
+  } else if (family === "radar") {
+    lines.push("radar-beta");
+    if (spec.title) lines.push(`${ind}title ${spec.title}`);
+    const taken = /* @__PURE__ */ new Set();
+    const ids = spec.categories.map((c, i) => slug(c, i, taken));
+    lines.push(`${ind}axis ${ids.map((id, i) => id === spec.categories[i] ? id : `${id}["${spec.categories[i].replace(/"/g, "'")}"]`).join(", ")}`);
+    const seriesTaken = new Set(ids);
+    for (const [i, s] of spec.series.entries()) {
+      const id = slug(s.id, i, seriesTaken);
+      lines.push(`${ind}curve ${id}["${s.name.replace(/"/g, "'")}"]{${s.values.map(v).join(", ")}}`);
+    }
+    if (spec.yAxis.max !== null) lines.push(`${ind}max ${num(spec.yAxis.max)}`);
+    if (spec.yAxis.min !== null) lines.push(`${ind}min ${num(spec.yAxis.min)}`);
+    if (!spec.legend.show) lines.push(`${ind}showLegend false`);
+  } else {
+    lines.push(`xychart-beta${spec.orientation === "horizontal" ? " horizontal" : ""}`);
+    if (spec.title) lines.push(`${ind}title ${quote(spec.title)}`);
+    const xTitle = spec.xAxis.title ? ` ${quote(spec.xAxis.title)}` : "";
+    lines.push(`${ind}x-axis${xTitle} [${spec.categories.map(word).join(", ")}]`);
+    const y = spec.yAxis;
+    if (y.title || y.min !== null || y.max !== null) {
+      let out = `${ind}y-axis`;
+      if (y.title) out += ` ${quote(y.title)}`;
+      if (y.min !== null || y.max !== null) {
+        const all = spec.series.flatMap((s) => s.values).filter((x) => x !== null && Number.isFinite(x));
+        const lo = _nullishCoalesce(y.min, () => ( Math.min(0, ...all)));
+        const hi = _nullishCoalesce(y.max, () => ( Math.max(lo + 1, ...all)));
+        out += ` ${num(lo)} --> ${num(hi)}`;
+      }
+      lines.push(out);
+    }
+    for (const s of spec.series) {
+      const kind = (_nullishCoalesce(s.type, () => ( (spec.type === "bar" ? "bar" : "line")))) === "bar" ? "bar" : "line";
+      lines.push(`${ind}${kind} ${quote(s.name)} [${s.values.map(v).join(", ")}]`);
+    }
+  }
+  let text = `${lines.join("\n")}
+`;
+  if (options.meta !== false) {
+    const meta = metaFor(spec, text);
+    if (meta) {
+      const [header, ...rest] = lines;
+      text = `${[header, `${CHART_MERMAID_META_PREFIX}${JSON.stringify({ v: 1, ...meta })}`, ...rest].join("\n")}
+`;
+    }
+  }
+  return text;
+}
+var RANGE = /^(-?\d+(?:\.\d+)?)\s*-->\s*(-?\d+(?:\.\d+)?)$/;
+function takeTitle(text) {
+  const t = text.trim();
+  if (t.startsWith('"')) {
+    const end = t.indexOf('"', 1);
+    if (end > 0) return { title: unquote(t.slice(0, end + 1)), rest: t.slice(end + 1).trim() };
+  }
+  if (!t || t.startsWith("[") || RANGE.test(t) || /^-?\d/.test(t)) return { rest: t };
+  const m = /^(\S+)\s*(.*)$/.exec(t);
+  return { title: m[1], rest: m[2].trim() };
+}
+function parseList(text, partial) {
+  const t = text.trim();
+  let m = /^\[(.*)\]$/s.exec(t);
+  if (!m && partial) m = /^\[(.*)$/s.exec(t);
+  if (!m) return void 0;
+  if (!m[1].trim()) return [];
+  const items = splitOutside(m[1], ",").map((x) => x.trim());
+  if (partial && !/\]$/.test(t)) {
+    const last = items[items.length - 1];
+    if (!last || last.startsWith('"') && !/"$/.test(last.slice(1))) items.pop();
+  }
+  return items.map(unquote);
+}
+function chartFromMermaid(text, options = {}) {
+  const issues = [];
+  const partial = !!options.partial;
+  const all = text.replace(/^/, "").split(/\r?\n/);
+  let start = 0;
+  let frontTitle;
+  if (_optionalChain([all, 'access', _4 => _4[0], 'optionalAccess', _5 => _5.trim, 'call', _6 => _6()]) === "---") {
+    const end = all.findIndex((l, i) => i > 0 && l.trim() === "---");
+    if (end > 0) {
+      for (const l of all.slice(1, end)) {
+        const m = /^title:\s*(.+)$/.exec(l.trim());
+        if (m) frontTitle = unquote(m[1]);
+      }
+      start = end + 1;
+    }
+  }
+  let family = null;
+  let headerLine = -1;
+  let horizontal = false;
+  let showData = false;
+  let meta = null;
+  for (let i = start; i < all.length; i++) {
+    const t = all[i].trim();
+    if (!t || t.startsWith("%%")) continue;
+    let m;
+    if (m = /^xychart(?:-beta)?(?:\s+(horizontal|vertical))?\s*$/i.exec(t)) {
+      family = "xychart";
+      horizontal = _optionalChain([m, 'access', _7 => _7[1], 'optionalAccess', _8 => _8.toLowerCase, 'call', _9 => _9()]) === "horizontal";
+    } else if (m = /^pie(\s+showData)?(?:\s+title\s+(.*))?\s*$/i.exec(t)) {
+      family = "pie";
+      showData = !!m[1];
+      if (m[2]) frontTitle = m[2].trim();
+    } else if (/^radar(?:-beta)?\s*$/i.test(t)) family = "radar";
+    else issues.push({ path: "header", line: i + 1, message: `Line ${i + 1}: expected a chart header (xychart-beta, pie or radar-beta), got "${t.slice(0, 40)}".` });
+    headerLine = i;
+    break;
+  }
+  let title = _nullishCoalesce(frontTitle, () => ( ""));
+  const categories = [];
+  const series = [];
+  const xAxis = _chunkJOX6MJW4cjs.defaultChartAxis.call(void 0, false);
+  const yAxis = _chunkJOX6MJW4cjs.defaultChartAxis.call(void 0, true);
+  const radarAxes = [];
+  const pieSlices = [];
+  let legendShow = true;
+  const counts = { bar: 0, line: 0 };
+  const lineIssue = (i, message) => issues.push({ path: `line ${i + 1}`, line: i + 1, message: `Line ${i + 1}: ${message}` });
+  for (let i = headerLine + 1; family && i < all.length; i++) {
+    const raw = all[i];
+    const t = raw.trim();
+    if (!t) continue;
+    if (t.startsWith(CHART_MERMAID_META_PREFIX.trim())) {
+      if (options.ignoreMeta) continue;
+      try {
+        const parsed = JSON.parse(t.slice(CHART_MERMAID_META_PREFIX.trim().length).trim());
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) meta = parsed;
+        else lineIssue(i, "the @pixerate metadata is not a JSON object; it was ignored.");
+      } catch (e2) {
+        if (!partial) lineIssue(i, "the @pixerate metadata is not valid JSON; it was ignored.");
+      }
+      continue;
+    }
+    if (t.startsWith("%%")) continue;
+    const isLast = i === all.length - 1 || all.slice(i + 1).every((l) => !l.trim());
+    let m;
+    if (m = /^title\s+(.+)$/i.exec(t)) {
+      title = unquote(m[1]);
+      continue;
+    }
+    if (family === "xychart") {
+      if (m = /^x-axis\b(.*)$/i.exec(t)) {
+        const { title: xt, rest } = takeTitle(m[1]);
+        if (xt) xAxis.title = xt;
+        const list = parseList(rest, partial && isLast);
+        if (list) categories.splice(0, categories.length, ...list);
+        else if (RANGE.test(rest)) {
+          const r = RANGE.exec(rest);
+          xAxis.min = Number(r[1]);
+          xAxis.max = Number(r[2]);
+        } else if (rest) lineIssue(i, `expected x-axis [a, b, \u2026] or a range "min --> max", got "${rest.slice(0, 40)}".`);
+        continue;
+      }
+      if (m = /^y-axis\b(.*)$/i.exec(t)) {
+        const { title: yt, rest } = takeTitle(m[1]);
+        if (yt) yAxis.title = yt;
+        const r = RANGE.exec(rest);
+        if (r) {
+          yAxis.min = Number(r[1]);
+          yAxis.max = Number(r[2]);
+        } else if (rest) lineIssue(i, `expected y-axis "min --> max", got "${rest.slice(0, 40)}".`);
+        continue;
+      }
+      if (m = /^(bar|line)\b(.*)$/i.exec(t)) {
+        const kind = m[1].toLowerCase();
+        const { title: st, rest } = takeTitle(m[2]);
+        const list = parseList(rest, partial && isLast);
+        if (!list) {
+          if (!(partial && isLast)) lineIssue(i, `expected ${kind} [1, 2, 3], got "${rest.slice(0, 40)}".`);
+          continue;
+        }
+        const values = list.map((x) => x.trim() === "" ? null : Number(x));
+        if (values.some((x) => x !== null && !Number.isFinite(x))) {
+          lineIssue(i, `${kind} values must be numbers.`);
+          continue;
+        }
+        counts[kind]++;
+        series.push({ id: `series-${series.length + 1}`, name: _nullishCoalesce(st, () => ( `${kind === "bar" ? "Bar" : "Line"} ${counts[kind]}`)), values, type: kind });
+        continue;
+      }
+    } else if (family === "pie") {
+      if (m = /^"((?:[^"\\]|\\.)*)"\s*:\s*(-?\d+(?:\.\d+)?)\s*$/.exec(t)) {
+        pieSlices.push({ label: m[1].replace(/#quot;/g, '"'), value: Number(m[2]) });
+        continue;
+      }
+      if (/^showData\s*$/i.test(t)) {
+        showData = true;
+        continue;
+      }
+    } else if (family === "radar") {
+      if (m = /^axis\s+(.+)$/.exec(t)) {
+        for (const part of splitOutside(m[1], ",")) {
+          const a = /^([A-Za-z_][\w-]*)\s*(?:\[\s*"((?:[^"\\]|\\.)*)"\s*\])?$/.exec(part.trim());
+          if (a) radarAxes.push({ id: a[1], label: _nullishCoalesce(a[2], () => ( a[1])) });
+          else lineIssue(i, `could not read the axis "${part.trim()}".`);
+        }
+        continue;
+      }
+      if (m = /^curve\s+([A-Za-z_][\w-]*)\s*(?:\[\s*"((?:[^"\\]|\\.)*)"\s*\])?\s*\{(.*)\}?\s*$/.exec(t)) {
+        const body = m[3].replace(/\}\s*$/, "");
+        const entries = body.trim() ? splitOutside(body, ",").map((x) => x.trim()).filter(Boolean) : [];
+        const ids = radarAxes.map((a) => a.id);
+        const values = ids.map(() => null);
+        let k = 0;
+        for (const e of entries) {
+          const keyed = /^([A-Za-z_][\w-]*)\s*:\s*(-?\d+(?:\.\d+)?)$/.exec(e);
+          if (keyed) {
+            const at = ids.indexOf(keyed[1]);
+            if (at >= 0) values[at] = Number(keyed[2]);
+            else lineIssue(i, `curve ${m[1]} names an unknown axis "${keyed[1]}".`);
+          } else if (/^-?\d+(?:\.\d+)?$/.test(e)) {
+            if (k < values.length) values[k] = Number(e);
+            else values.push(Number(e));
+            k++;
+          } else lineIssue(i, `could not read "${e}" in curve ${m[1]}.`);
+        }
+        series.push({ id: m[1], name: _nullishCoalesce(m[2], () => ( m[1])), values });
+        continue;
+      }
+      if (m = /^(max|min|ticks|graticule|showLegend)\s+(\S+)$/.exec(t)) {
+        if (m[1] === "max") yAxis.max = Number(m[2]);
+        else if (m[1] === "min") yAxis.min = Number(m[2]);
+        else if (m[1] === "showLegend") legendShow = m[2] !== "false";
+        continue;
+      }
+    }
+    if (!(partial && isLast)) lineIssue(i, `could not read "${t.slice(0, 60)}"; it was skipped.`);
+  }
+  let input;
+  if (family === "pie") {
+    input = {
+      type: "pie",
+      title,
+      dataLabels: showData,
+      categories: pieSlices.map((s) => s.label),
+      series: [{ id: "series-1", name: title || "Values", values: pieSlices.map((s) => s.value) }]
+    };
+  } else if (family === "radar") {
+    input = { type: "radar", title, categories: radarAxes.map((a) => a.label), series, yAxis, legend: { show: legendShow, position: "bottom" } };
+  } else {
+    const allBar = series.length > 0 && series.every((s) => s.type === "bar");
+    const allLine = series.length > 0 && series.every((s) => s.type === "line");
+    const type = allLine ? "line" : "bar";
+    const longest = Math.max(0, ...series.map((s) => s.values.length));
+    const cats = categories.length ? categories : Array.from({ length: longest }, (_, i) => `${i + 1}`);
+    input = {
+      type,
+      title,
+      orientation: horizontal ? "horizontal" : "vertical",
+      categories: cats,
+      xAxis,
+      yAxis,
+      // Series that match the chart type do not need their own type.
+      series: series.map((s) => allBar || allLine || s.type === type ? { ...s, type: void 0 } : s)
+    };
+  }
+  if (meta) {
+    const { v: _v, series: metaSeries, ...rest } = meta;
+    Object.assign(input, rest);
+    if (Array.isArray(metaSeries)) {
+      const base = _nullishCoalesce(input.series, () => ( []));
+      input.series = metaSeries.map((extra, i) => ({ ..._nullishCoalesce(base[i], () => ( {})), ..._nullishCoalesce(extra, () => ( {})) }));
+    }
+  }
+  const { spec, issues: specIssues } = _chunkJOX6MJW4cjs.normalizeChartSpec.call(void 0, input);
+  if (!family && !partial && !issues.length) issues.push({ path: "header", message: "The text is empty: expected a chart header (xychart-beta, pie or radar-beta)." });
+  return { spec, issues: [...issues, ...specIssues], family, hasMeta: !!meta };
+}
+function findMermaidCharts(text) {
+  const lines = text.replace(/^/, "").split(/\r?\n/);
+  const found = [];
+  const familyOf = (body) => {
+    const header = body.split(/\r?\n/).find((l) => l.trim() && !l.trim().startsWith("%%") && l.trim() !== "---");
+    if (!header) return null;
+    if (/^\s*xychart(-beta)?\b/.test(header)) return "xychart";
+    if (/^\s*pie\b/.test(header)) return "pie";
+    if (/^\s*radar(-beta)?\b/.test(header)) return "radar";
+    return null;
+  };
+  for (let i = 0; i < lines.length; i++) {
+    const open = /^ {0,3}(`{3,}|~{3,})\s*([\w-]*)/.exec(lines[i]);
+    if (!open) continue;
+    const fence = open[1];
+    const info = open[2].toLowerCase();
+    let end = i + 1;
+    while (end < lines.length && !new RegExp(`^ {0,3}${fence[0]}{${fence.length},}\\s*$`).test(lines[end])) end++;
+    const body = lines.slice(i + 1, end).join("\n");
+    if (!info || info === "mermaid") {
+      const family = familyOf(body);
+      if (family) found.push({ source: `${body.trimEnd()}
+`, family, line: i + 2 });
+    }
+    i = end;
+  }
+  if (!found.length) {
+    const family = familyOf(text);
+    if (family) found.push({ source: `${text.trim()}
+`, family, line: 1 });
+  }
+  return found;
+}
+
+// src/chart/date.ts
+var MONTHS = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+function parseChartDate(label) {
+  const text = label.trim();
+  let m = /^(\d{4})$/.exec(text);
+  if (m) return Date.UTC(Number(m[1]), 0, 1);
+  m = /^(\d{4})[-/](\d{1,2})$/.exec(text);
+  if (m) return valid(Number(m[1]), Number(m[2]) - 1, 1);
+  m = /^(\d{4})[-/](\d{1,2})[-/](\d{1,2})(?:[T ](\d{1,2}):(\d{2})(?::(\d{2}))?(?:\.\d+)?(Z|[+-]\d{2}:?\d{2})?)?$/.exec(text);
+  if (m) {
+    if (m[4] !== void 0) {
+      const t = Date.parse(text.replace(" ", "T").replace(/\//g, "-") + (m[7] ? "" : "Z"));
+      return Number.isFinite(t) ? t : null;
+    }
+    return valid(Number(m[1]), Number(m[2]) - 1, Number(m[3]));
+  }
+  m = /^(?:(\d{1,2})\s+)?([A-Za-z]{3})[a-z]*\.?,?\s+(\d{4})$/.exec(text);
+  if (m) {
+    const month = MONTHS.findIndex((x) => x.toLowerCase() === m[2].toLowerCase());
+    if (month >= 0) return valid(Number(m[3]), month, m[1] ? Number(m[1]) : 1);
+  }
+  return null;
+}
+function valid(y, mo, d) {
+  const t = Date.UTC(y, mo, d);
+  const date = new Date(t);
+  return date.getUTCFullYear() === y && date.getUTCMonth() === mo && date.getUTCDate() === d ? t : null;
+}
+var CHART_DATE_STEPS = [
+  { unit: "day", count: 1 },
+  { unit: "day", count: 2 },
+  { unit: "week", count: 1 },
+  { unit: "week", count: 2 },
+  { unit: "month", count: 1 },
+  { unit: "month", count: 3 },
+  { unit: "month", count: 6 },
+  { unit: "year", count: 1 },
+  { unit: "year", count: 2 },
+  { unit: "year", count: 5 },
+  { unit: "year", count: 10 },
+  { unit: "year", count: 25 },
+  { unit: "year", count: 50 },
+  { unit: "year", count: 100 }
+];
+function bucket(t, step) {
+  const d = new Date(t);
+  const y = d.getUTCFullYear();
+  switch (step.unit) {
+    case "day":
+      return Math.floor(Math.floor(t / 864e5) / step.count);
+    case "week":
+      return Math.floor(Math.floor((t / 864e5 - 4) / 7) / step.count);
+    case "month":
+      return Math.floor((y * 12 + d.getUTCMonth()) / step.count);
+    case "year":
+      return Math.floor(y / step.count);
+  }
+}
+function formatChartDate(t, step, previous = null) {
+  const d = new Date(t);
+  const y = d.getUTCFullYear();
+  const mo = MONTHS[d.getUTCMonth()];
+  const sameYear = previous !== null && new Date(previous).getUTCFullYear() === y;
+  if (step.unit === "year") return String(y);
+  if (step.unit === "month") return sameYear ? mo : `${mo} ${y}`;
+  return sameYear ? `${d.getUTCDate()} ${mo}` : `${d.getUTCDate()} ${mo} ${y}`;
+}
+function chartDateLabels(categories, band, measure, gap = 10) {
+  const times = categories.map(parseChartDate);
+  if (times.filter((t) => t !== null).length < Math.max(1, categories.length / 2)) return null;
+  const present = times.filter((t) => t !== null).sort((x, y) => x - y);
+  const gaps = present.slice(1).map((t, i) => t - present[i]).filter((g) => g > 0).sort((x, y) => x - y);
+  const spacing = gaps.length ? gaps[Math.floor(gaps.length / 2)] : 0;
+  const DAY = 864e5;
+  const length = (step) => step.count * (step.unit === "day" ? DAY : step.unit === "week" ? 7 * DAY : step.unit === "month" ? 30 * DAY : 365 * DAY);
+  for (const step of CHART_DATE_STEPS) {
+    if (length(step) < spacing * 0.5 && step !== CHART_DATE_STEPS[CHART_DATE_STEPS.length - 1]) continue;
+    const indexes = [];
+    const labels = /* @__PURE__ */ new Map();
+    let last = null;
+    let lastTime = null;
+    times.forEach((t, i) => {
+      if (t === null) return;
+      const b = bucket(t, step);
+      if (b === last) return;
+      last = b;
+      indexes.push(i);
+      labels.set(i, formatChartDate(t, step, lastTime));
+      lastTime = t;
+    });
+    let fits = true;
+    for (let k = 1; k < indexes.length && fits; k++) {
+      const a = labels.get(indexes[k - 1]);
+      const b = labels.get(indexes[k]);
+      if ((indexes[k] - indexes[k - 1]) * band < (measure(a) + measure(b)) / 2 + gap) fits = false;
+    }
+    if (fits || step === CHART_DATE_STEPS[CHART_DATE_STEPS.length - 1]) return { step, indexes, labels };
+  }
+  return null;
+}
+
+// src/chart/numfmt.ts
+function compileChartFormatCode(code) {
+  const fmt = _chunkXP5IUZUOcjs.NumberFormat.parseCached(code);
+  return {
+    isDate: fmt.isDate(),
+    isPercent: fmt.isPercent(),
+    format: (value) => Number.isFinite(value) ? fmt.formatNumber(value).text : ""
+  };
+}
+function formatChartValueWithCode(value, code) {
+  return compileChartFormatCode(code).format(value);
+}
+function chartSerialToDate(serial) {
+  const origin = serial < 61 ? Date.UTC(1899, 11, 31) : Date.UTC(1899, 11, 30);
+  return new Date(origin + Math.round(serial * 864e5));
+}
+function chartDateToSerial(date) {
+  const serial = (date.getTime() - Date.UTC(1899, 11, 30)) / 864e5;
+  return serial < 61 ? serial - 1 : serial;
+}
+
+// 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) {
+  if (fixedMin !== null && !Number.isFinite(fixedMin)) fixedMin = null;
+  if (fixedMax !== null && !Number.isFinite(fixedMax)) fixedMax = null;
+  let lo = _nullishCoalesce(fixedMin, () => ( min));
+  let hi = _nullishCoalesce(fixedMax, () => ( max));
+  if (!Number.isFinite(lo) || !Number.isFinite(hi)) {
+    fixedMin = fixedMax = null;
+    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 span = hi - lo;
+  const step = Number.isFinite(span) ? niceStep(span, count) : niceStep(hi / 2 - lo / 2, count) * 2;
+  const finiteOr = (n2, fallback) => Number.isFinite(n2) ? n2 : fallback;
+  const niceMin = _nullishCoalesce(fixedMin, () => ( finiteOr(snap(Math.floor(lo / step + 1e-9) * step, step), lo)));
+  const niceMax = _nullishCoalesce(fixedMax, () => ( finiteOr(snap(Math.ceil(hi / step - 1e-9) * step, step), hi)));
+  const firstIndex = Math.ceil(niceMin / step - 1e-9);
+  const lastIndex = Math.floor(niceMax / step + 1e-9);
+  const n = Math.min(999, Math.max(-1, lastIndex - firstIndex));
+  const ticks = [];
+  for (let i = 0; i <= n; i++) {
+    const t = snap((firstIndex + i) * step, step);
+    if (Number.isFinite(t) && t !== ticks[ticks.length - 1]) ticks.push(t);
+  }
+  return { min: niceMin, max: niceMax, step, ticks };
+}
+function snap(n, step) {
+  const c = clean(n);
+  return Math.abs(c - n) <= step * 1e-6 ? c : n;
+}
+function stepDecimals(step) {
+  if (!(step > 0) || !Number.isFinite(step)) return 0;
+  for (let d = 0; d < 6; d++) {
+    const scaled = step * Math.pow(10, d);
+    if (Math.abs(scaled - Math.round(scaled)) < 1e-9) return d;
+  }
+  return 6;
+}
+function magnitudeDecimals(value) {
+  if (!(value > 0) || value >= 1) return 0;
+  return Math.min(6, Math.max(0, Math.ceil(-Math.log10(value) - 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 "";
+  if (format.code) return `${_nullishCoalesce(format.prefix, () => ( ""))}${formatChartValueWithCode(value, format.code)}${_nullishCoalesce(format.suffix, () => ( ""))}`;
+  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, magnitudeDecimals(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-shared.ts
+var estimateChartTextWidth = (text, size, weight = 400) => text.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":
+    case "trendline":
+      return a.seriesId === b.seriesId && a.index === b.index;
+    case "category":
+      return a.index === b.index;
+    default:
+      return true;
+  }
+}
+function contrastingTextColor(fill) {
+  let rgb = null;
+  const hex = /^#([0-9a-f]{3}|[0-9a-f]{6})$/i.exec(fill.trim());
+  if (hex) {
+    const h = hex[1].length === 3 ? [...hex[1]].map((c) => c + c).join("") : hex[1];
+    rgb = [0, 2, 4].map((i) => parseInt(h.slice(i, i + 2), 16));
+  } else {
+    const fn = /^rgba?\(\s*([\d.]+)[\s,]+([\d.]+)[\s,]+([\d.]+)/i.exec(fill.trim());
+    if (fn) rgb = fn.slice(1, 4).map(Number);
+  }
+  if (!rgb) return "#ffffff";
+  const luminance = (0.299 * rgb[0] + 0.587 * rgb[1] + 0.114 * rgb[2]) / 255;
+  return luminance > 0.5 ? "#0f172a" : "#ffffff";
+}
+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 truncate(text, maxWidth, size, measure) {
+  if (measure(text, size) <= maxWidth) return text;
+  let out = text;
+  while (out.length > 1 && measure(`${out}\u2026`, size) > maxWidth) out = out.slice(0, -1);
+  return `${out}\u2026`;
+}
+function markerPath(shape, cx, cy, r) {
+  switch (shape) {
+    case "square":
+      return `M${r2(cx - r)},${r2(cy - r)}H${r2(cx + r)}V${r2(cy + r)}H${r2(cx - r)}Z`;
+    case "diamond": {
+      const d = r * 1.3;
+      return `M${r2(cx)},${r2(cy - d)}L${r2(cx + d)},${r2(cy)}L${r2(cx)},${r2(cy + d)}L${r2(cx - d)},${r2(cy)}Z`;
+    }
+    case "triangle": {
+      const d = r * 1.3;
+      return `M${r2(cx)},${r2(cy - d)}L${r2(cx + d * 0.87)},${r2(cy + d * 0.5)}L${r2(cx - d * 0.87)},${r2(cy + d * 0.5)}Z`;
+    }
+    case "cross": {
+      const d = r;
+      return `M${r2(cx - d)},${r2(cy - d)}L${r2(cx + d)},${r2(cy + d)}M${r2(cx - d)},${r2(cy + d)}L${r2(cx + d)},${r2(cy - d)}`;
+    }
+  }
+}
+var tickCount = (length) => Math.max(2, Math.min(10, Math.round(length / 56)));
+function axisScale(lo, hi, length, axis, frozen, headroom = false) {
+  const fixedMin = frozen && Number.isFinite(frozen.min) ? frozen.min : axis.min;
+  const fixedMax = frozen && Number.isFinite(frozen.max) ? frozen.max : axis.max;
+  const step = axis.step;
+  if (step && step > 0 && Number.isFinite(lo) && Number.isFinite(hi)) {
+    let min = _nullishCoalesce(fixedMin, () => ( Math.floor(lo / step + 1e-9) * step));
+    let max = _nullishCoalesce(fixedMax, () => ( Math.ceil(hi / step - 1e-9) * step));
+    if (!(max > min)) max = min + step;
+    const first = Math.ceil(min / step - 1e-9);
+    const last = Math.floor(max / step + 1e-9);
+    if (last - first <= 200) {
+      const clean3 = (n) => Math.abs(n) < 1e-12 ? 0 : Number(n.toPrecision(12));
+      min = clean3(min);
+      max = clean3(max);
+      const ticks = [];
+      for (let i = first; i <= last; i++) ticks.push(clean3(i * step));
+      return { min, max, step, ticks };
+    }
+  }
+  let scale = niceScale(lo, hi, tickCount(length), fixedMin, fixedMax);
+  const roomy = hi + (hi - lo) * 0.05;
+  if (headroom && fixedMax === null && hi !== 0 && hi > lo && scale.max === hi && Number.isFinite(roomy)) scale = niceScale(lo, roomy, tickCount(length), fixedMin, fixedMax);
+  return scale;
+}
+function clipSegment(a, b, rect) {
+  let t0 = 0;
+  let t1 = 1;
+  const dx = b[0] - a[0];
+  const dy = b[1] - a[1];
+  const checks = [
+    [-dx, a[0] - rect.x],
+    [dx, rect.x + rect.width - a[0]],
+    [-dy, a[1] - rect.y],
+    [dy, rect.y + rect.height - a[1]]
+  ];
+  for (const [p, q] of checks) {
+    if (p === 0) {
+      if (q < 0) return null;
+      continue;
+    }
+    const r = q / p;
+    if (p < 0) {
+      if (r > t1) return null;
+      if (r > t0) t0 = r;
+    } else {
+      if (r < t0) return null;
+      if (r < t1) t1 = r;
+    }
+  }
+  return [
+    [a[0] + t0 * dx, a[1] + t0 * dy],
+    [a[0] + t1 * dx, a[1] + t1 * dy]
+  ];
+}
+function clippedPolyline(points, rect) {
+  let d = "";
+  let open = false;
+  let last = null;
+  for (let i = 1; i < points.length; i++) {
+    const seg = clipSegment(points[i - 1], points[i], rect);
+    if (!seg) {
+      open = false;
+      continue;
+    }
+    const [p, q] = seg;
+    if (!open || !last || Math.abs(last[0] - p[0]) > 0.01 || Math.abs(last[1] - p[1]) > 0.01) d += `M${r2(p[0])},${r2(p[1])}`;
+    d += `L${r2(q[0])},${r2(q[1])}`;
+    last = q;
+    open = true;
+  }
+  return d;
+}
+
+// src/chart/stats.ts
+function chartHistogram(values, bins = null) {
+  const vals = values.filter((v) => v !== null && Number.isFinite(v));
+  if (!vals.length) return [];
+  let lo = Infinity;
+  let hi = -Infinity;
+  for (const v of vals) {
+    lo = Math.min(lo, v);
+    hi = Math.max(hi, v);
+  }
+  const span = hi - lo;
+  let count = _nullishCoalesce(bins, () => ( Math.max(1, Math.min(100, Math.ceil(Math.sqrt(vals.length))))));
+  if (!(span > 0)) count = 1;
+  const width = count === 1 && !(span > 0) ? 1 : span / count;
+  const edges = Array.from({ length: count }, (_, b) => b + 1 === count ? Math.max(hi, lo + b * width) : lo + (b + 1) * width);
+  const counts = Array(count).fill(0);
+  for (const v of vals) {
+    let a = 0;
+    let z = count;
+    while (a < z) {
+      const mid = a + z >> 1;
+      if (edges[mid] < v) a = mid + 1;
+      else z = mid;
+    }
+    counts[Math.min(a, count - 1)]++;
+  }
+  return counts.map((c, b) => ({ from: clean2(lo + b * width), to: clean2(edges[b]), count: c }));
+}
+var clean2 = (n) => Math.abs(n) < 1e-12 ? 0 : Number(n.toPrecision(12));
+function chartQuantile(sorted, q) {
+  const n = sorted.length;
+  if (!n) return 0;
+  const pos = q * (n - 1);
+  const i = Math.floor(pos);
+  const a = sorted[i];
+  const b = _nullishCoalesce(sorted[i + 1], () => ( a));
+  return a + (b - a) * (pos - i);
+}
+function chartBoxStats(values) {
+  const v = values.filter((x) => x !== null && Number.isFinite(x)).sort((a, b) => a - b);
+  if (!v.length) return null;
+  const q1 = chartQuantile(v, 0.25);
+  const median = chartQuantile(v, 0.5);
+  const q3 = chartQuantile(v, 0.75);
+  const iqr = q3 - q1;
+  const lo = q1 - 1.5 * iqr;
+  const hi = q3 + 1.5 * iqr;
+  return {
+    min: v[0],
+    max: v[v.length - 1],
+    q1,
+    median,
+    q3,
+    mean: v.reduce((t, x) => t + x, 0) / v.length,
+    lowerWhisker: _nullishCoalesce(v.find((x) => x >= lo), () => ( q1)),
+    upperWhisker: _nullishCoalesce([...v].reverse().find((x) => x <= hi), () => ( q3)),
+    outliers: v.filter((x) => x < lo || x > hi),
+    count: v.length
+  };
+}
+function chartSquarify(values, rect) {
+  const out = values.map(() => ({ x: rect.x, y: rect.y, width: 0, height: 0 }));
+  const items = values.map((v, i2) => [i2, v]).filter(([, v]) => v > 0 && Number.isFinite(v)).sort((a, b) => b[1] - a[1]);
+  const total = items.reduce((t, [, v]) => t + v, 0);
+  const area = rect.width * rect.height;
+  if (!(total > 0 && area > 0)) return out;
+  const scale = area / total;
+  const rem = { ...rect };
+  let row = [];
+  const worst = (r, side) => {
+    const s = r.reduce((t, v) => t + v, 0);
+    if (s <= 0 || side <= 0) return Infinity;
+    const mn = Math.min(...r);
+    const mx = Math.max(...r);
+    return Math.max(side * side * mx / (s * s), s * s / (side * side * mn));
+  };
+  const layoutRow = (r) => {
+    const s = r.reduce((t, [, a]) => t + a, 0);
+    if (s <= 0) return;
+    if (rem.width >= rem.height) {
+      const cw = s / Math.max(1e-6, rem.height);
+      let y = rem.y;
+      for (const [j, a] of r) {
+        const h = a / Math.max(1e-6, cw);
+        out[j] = { x: rem.x, y, width: cw, height: h };
+        y += h;
+      }
+      rem.x += cw;
+      rem.width = Math.max(0, rem.width - cw);
+    } else {
+      const rh = s / Math.max(1e-6, rem.width);
+      let x = rem.x;
+      for (const [j, a] of r) {
+        const w = a / Math.max(1e-6, rh);
+        out[j] = { x, y: rem.y, width: w, height: rh };
+        x += w;
+      }
+      rem.y += rh;
+      rem.height = Math.max(0, rem.height - rh);
+    }
+  };
+  let i = 0;
+  while (i < items.length) {
+    const [j, v] = items[i];
+    const a = v * scale;
+    const side = Math.min(rem.width, rem.height);
+    const cur = row.map(([, x]) => x);
+    if (!row.length || worst([...cur, a], side) <= worst(cur, side)) {
+      row.push([j, a]);
+      i++;
+    } else {
+      layoutRow(row);
+      row = [];
+    }
+  }
+  if (row.length) layoutRow(row);
+  return out;
+}
+function decimateChartPoints(points, max = 2e3) {
+  if (points.length <= max) return [...points];
+  const out = [];
+  let i = 0;
+  while (i < points.length) {
+    const col = Math.floor(points[i].x);
+    const start = i;
+    let mn = i;
+    let mx = i;
+    let k = i + 1;
+    while (k < points.length && Math.floor(points[k].x) === col) {
+      if (points[k].y < points[mn].y) mn = k;
+      if (points[k].y > points[mx].y) mx = k;
+      k++;
+    }
+    const end = k - 1;
+    for (const idx of [.../* @__PURE__ */ new Set([start, mn, mx, end])].sort((a, b) => a - b)) out.push(points[idx]);
+    i = k;
+  }
+  return out;
+}
+var round = (n) => Number(n.toPrecision(6));
+function summarizeChartSeries(series, categories) {
+  const present = series.values.map((v, i) => [i, v]).filter((p) => p[1] !== null && Number.isFinite(p[1]));
+  const base = { id: series.id, name: series.name, count: present.length, gaps: series.values.length - present.length, min: null, max: null, mean: null, sum: null, minAt: null, maxAt: null, trend: null, change: null };
+  if (!present.length) return base;
+  let lo = present[0];
+  let hi = present[0];
+  let sum = 0;
+  for (const p of present) {
+    if (p[1] < lo[1]) lo = p;
+    if (p[1] > hi[1]) hi = p;
+    sum += p[1];
+  }
+  const mean = sum / present.length;
+  let trend = null;
+  if (present.length >= 2) {
+    const mx = present.reduce((t, p) => t + p[0], 0) / present.length;
+    let sxy = 0;
+    let sxx = 0;
+    for (const [i, v] of present) {
+      sxy += (i - mx) * (v - mean);
+      sxx += (i - mx) ** 2;
+    }
+    const slope = sxx ? sxy / sxx : 0;
+    const spread = hi[1] - lo[1];
+    const travel = Math.abs(slope * (present[present.length - 1][0] - present[0][0]));
+    trend = !spread || travel < spread * 0.05 ? "flat" : slope > 0 ? "rising" : "falling";
+  }
+  const first = present[0][1];
+  const last = present[present.length - 1][1];
+  return {
+    ...base,
+    min: round(lo[1]),
+    max: round(hi[1]),
+    mean: round(mean),
+    sum: round(sum),
+    minAt: _nullishCoalesce(categories[lo[0]], () => ( String(lo[0]))),
+    maxAt: _nullishCoalesce(categories[hi[0]], () => ( String(hi[0]))),
+    trend,
+    change: present.length >= 2 && first !== 0 ? round((last - first) / Math.abs(first)) : null
+  };
+}
+
+// src/chart/trend.ts
+var degree = (t) => t.type === "polynomial" ? Math.max(2, Math.min(6, _nullishCoalesce(t.order, () => ( 2)))) : 1;
+var logX = (type) => type === "logarithmic" || type === "power";
+var logY = (type) => type === "exponential" || type === "power";
+function fitChartTrendline(trendline, points) {
+  const type = trendline.type;
+  if (type === "moving-average") return null;
+  const d = degree(trendline);
+  const data = points.filter(([x, y]) => Number.isFinite(x) && Number.isFinite(y) && (!logX(type) || x > 0) && (!logY(type) || y > 0)).map(([x, y]) => [logX(type) ? Math.log(x) : x, logY(type) ? Math.log(y) : y]);
+  if (data.length < 2 || data.length <= d) return null;
+  let fixed = null;
+  const b = trendline.intercept;
+  if (b !== void 0 && b !== null && Number.isFinite(b)) {
+    if (type === "linear" || type === "polynomial") fixed = b;
+    else if (type === "exponential" && b > 0) fixed = Math.log(b);
+  }
+  const n = data.length;
+  const center = fixed !== null ? 0 : data.reduce((t, p) => t + p[0], 0) / n;
+  const scale = data.reduce((m2, p) => Math.max(m2, Math.abs(p[0] - center)), 0);
+  if (!(Number.isFinite(scale) && scale > 0)) return null;
+  const first = fixed !== null ? 1 : 0;
+  const b0 = _nullishCoalesce(fixed, () => ( 0));
+  const m = d + 1 - first;
+  const ata = Array.from({ length: m }, () => Array(m).fill(0));
+  const aty = Array(m).fill(0);
+  for (const [x, y] of data) {
+    const u = (x - center) / scale;
+    const pows = Array.from({ length: m }, (_, k) => Math.pow(u, k + first));
+    for (let i = 0; i < m; i++) {
+      aty[i] += pows[i] * (y - b0);
+      for (let j = 0; j < m; j++) ata[i][j] += pows[i] * pows[j];
+    }
+  }
+  const sol = solve(ata, aty);
+  if (!sol) return null;
+  const a = Array(d + 1).fill(b0);
+  sol.forEach((v, k) => a[k + first] = v);
+  const coefficients = expand(a, center, scale);
+  if (!coefficients) return null;
+  const poly = (x) => {
+    const u = (x - center) / scale;
+    return a.reduceRight((acc, c) => acc * u + c, 0);
+  };
+  const mean = data.reduce((t, p) => t + p[1], 0) / n;
+  let ssRes = 0;
+  let ssTot = 0;
+  for (const [x, y] of data) {
+    ssRes += (y - poly(x)) ** 2;
+    ssTot += fixed !== null ? (y - b0) ** 2 : (y - mean) ** 2;
+  }
+  const r22 = ssTot > 0 && Number.isFinite(ssTot) && Number.isFinite(ssRes) ? 1 - ssRes / ssTot : null;
+  return {
+    type,
+    coefficients,
+    r2: r22,
+    equation: equationText(type, coefficients),
+    points: n,
+    evaluate(x) {
+      let xx = x;
+      if (logX(type)) {
+        if (!(x > 0)) return null;
+        xx = Math.log(x);
+      }
+      const p = poly(xx);
+      const y = logY(type) ? Math.exp(p) : p;
+      return Number.isFinite(y) ? y : null;
+    }
+  };
+}
+function solve(a, b) {
+  const n = b.length;
+  const big = a.flat().reduce((m, v) => Math.max(m, Math.abs(v)), 0);
+  if (!(Number.isFinite(big) && big > 0)) return null;
+  for (let col = 0; col < n; col++) {
+    let piv = col;
+    for (let r = col + 1; r < n; r++) if (Math.abs(a[r][col]) > Math.abs(a[piv][col])) piv = r;
+    [a[col], a[piv]] = [a[piv], a[col]];
+    [b[col], b[piv]] = [b[piv], b[col]];
+    const p = a[col][col];
+    if (!Number.isFinite(p) || Math.abs(p) <= big * 1e-13) return null;
+    for (let r = col + 1; r < n; r++) {
+      const f = a[r][col] / p;
+      for (let c = col; c < n; c++) a[r][c] -= f * a[col][c];
+      b[r] -= f * b[col];
+    }
+  }
+  const x = Array(n).fill(0);
+  for (let r = n - 1; r >= 0; r--) {
+    let s = 0;
+    for (let c = r + 1; c < n; c++) s += a[r][c] * x[c];
+    x[r] = (b[r] - s) / a[r][r];
+  }
+  return x.every(Number.isFinite) ? x : null;
+}
+function expand(a, c, s) {
+  const out = Array(a.length).fill(0);
+  a.forEach((ak, k) => {
+    const lead = ak / Math.pow(s, k);
+    let binom = 1;
+    for (let j = 0; j <= k; j++) {
+      out[j] += lead * binom * Math.pow(-c, k - j);
+      binom = binom * (k - j) / (j + 1);
+    }
+  });
+  return out.every(Number.isFinite) ? out : null;
+}
+var POWERS = ["", "x", "x\xB2", "x\xB3", "x\u2074", "x\u2075", "x\u2076"];
+function equationText(type, coef) {
+  const c0 = _nullishCoalesce(coef[0], () => ( 0));
+  const c1 = _nullishCoalesce(coef[1], () => ( 0));
+  if (type === "exponential") return `y = ${trendNumberText(Math.exp(c0))}e^(${trendNumberText(c1)}x)`;
+  if (type === "power") return `y = ${trendNumberText(Math.exp(c0))}x^${trendNumberText(c1)}`;
+  if (type === "logarithmic") return terms([[c1, "ln(x)"], [c0, ""]]);
+  return terms(coef.map((c, k) => [c, _nullishCoalesce(POWERS[k], () => ( "x"))]).reverse());
+}
+function terms(parts) {
+  let s = "y = ";
+  let first = true;
+  for (const [c, t] of parts) {
+    const txt = trendNumberText(Math.abs(c));
+    if (txt === "0") continue;
+    const neg = c < 0;
+    if (first) s += neg ? "-" : "";
+    else s += neg ? " - " : " + ";
+    if (txt !== "1" || !t) s += txt;
+    s += t;
+    first = false;
+  }
+  return first ? `${s}0` : s;
+}
+function trendNumberText(v) {
+  if (!Number.isFinite(v)) return "#NUM!";
+  const a = Math.abs(v);
+  if (a === 0) return "0";
+  if (a < 1e-4 || a >= 1e11) {
+    const [mant, exp] = v.toExponential(4).split("e");
+    const e = Number(exp);
+    return `${trimZeros(mant)}E${e < 0 ? "-" : "+"}${String(Math.abs(e)).padStart(2, "0")}`;
+  }
+  const s = trimZeros(v.toFixed(4));
+  return s === "-0" ? "0" : s;
+}
+var trimZeros = (s) => s.includes(".") ? s.replace(/0+$/, "").replace(/\.$/, "") : s;
+function chartMovingAverage(points, period) {
+  const p = Math.max(2, Math.min(1e3, Math.round(period) || 2));
+  const pts = points.filter(([x, y]) => Number.isFinite(x) && Number.isFinite(y));
+  const out = [];
+  let sum = 0;
+  pts.forEach(([x, y], i) => {
+    sum += y;
+    if (i >= p) sum -= pts[i - p][1];
+    if (i >= p - 1) out.push([x, sum / p]);
+  });
+  return out;
+}
+function chartTrendlineName(trendline, seriesName) {
+  if (trendline.name) return trendline.name;
+  const kind = {
+    linear: "Linear",
+    exponential: "Expon.",
+    logarithmic: "Log.",
+    polynomial: "Poly.",
+    power: "Power",
+    "moving-average": `${Math.max(2, _nullishCoalesce(trendline.period, () => ( 2)))} per. Mov. Avg.`
+  };
+  return `${kind[trendline.type]} (${seriesName})`;
+}
+function chartSupportsTrendlines(type, stacking) {
+  return (type === "bar" || type === "line" || type === "area" || type === "scatter" || type === "bubble") && stacking === "none";
+}
+
+// src/chart/layout-cartesian.ts
+var MAX_CHART_DATA_LABELS = 200;
+var MAX_CHART_LINE_POINTS = 2e3;
+var MAX_CHART_MARKERS = 1e3;
+function scaleInfo(scale, range, format) {
+  const domain = [scale.min, scale.max];
+  const raw = (v) => linearMap(v, domain, range);
+  const px = (v) => raw(Math.min(scale.max, Math.max(scale.min, v)));
+  return { scale, range, px, raw, zero: px(0), format, tickText: (t) => formatChartNumber(t, format, _nullishCoalesce(format.decimals, () => ( stepDecimals(scale.step)))) };
+}
+function categoryFrame(ctx, area, input) {
+  const { spec, theme, measure, fs, marks } = ctx;
+  const { labels, horizontal, primary, secondary } = input;
+  const xAxis = _nullishCoalesce(input.categoryAxis, () => ( spec.xAxis));
+  const n = Math.max(1, labels.length);
+  const titleBand = fs * 1.3 + 6;
+  const labelTarget = _nullishCoalesce(input.labelTarget, () => ( ((i) => ({ kind: "category", index: i }))));
+  const estimate = (v, length) => {
+    const s = axisScale(v.lo, v.hi, length, v.axis, v.frozen, v.headroom);
+    const info = scaleInfo(s, [0, 1], v.format);
+    return Math.max(0, ...s.ticks.map((t) => measure(info.tickText(t), fs)));
+  };
+  const valueLen0 = horizontal ? area.width : area.height;
+  const valueLabelWidth = primary.axis.show ? estimate(primary, valueLen0) : 0;
+  const valueLabelWidth2 = _optionalChain([secondary, 'optionalAccess', _10 => _10.axis, 'access', _11 => _11.show]) ? estimate(secondary, valueLen0) : 0;
+  const catLabelWidth = Math.max(0, ...labels.map((c) => measure(c, fs)));
+  let left;
+  let bottom;
+  let right = 8;
+  let top = horizontal ? 4 : fs / 2 + 2;
+  let rotate = 0;
+  let dateLabels = null;
+  let rotatedMax = 0;
+  if (horizontal) {
+    left = (xAxis.show ? Math.min(catLabelWidth, area.width * 0.35) + 8 : 2) + (xAxis.title ? titleBand : 0);
+    bottom = (primary.axis.show ? fs * 1.6 : 2) + (primary.axis.title ? titleBand : 0);
+    right = Math.max(8, valueLabelWidth / 2);
+    if (secondary) top = (secondary.axis.show ? fs * 1.6 : 4) + (secondary.axis.title ? titleBand : 0);
+  } else {
+    left = (primary.axis.show ? valueLabelWidth + 8 : 2) + (primary.axis.title ? titleBand : 0);
+    if (secondary) right = (secondary.axis.show ? valueLabelWidth2 + 8 : 8) + (secondary.axis.title ? titleBand : 0);
+    const band2 = (area.width - left - right) / n;
+    if (xAxis.show && xAxis.kind === "date") dateLabels = chartDateLabels(labels, band2, (t) => measure(t, fs));
+    if (xAxis.show && !dateLabels && catLabelWidth > band2 * 0.92) rotate = -40;
+    const sin = Math.sin(Math.PI / 4.5);
+    const catHeight = rotate ? Math.min(catLabelWidth * sin + fs, area.height * 0.4) : fs * 1.6;
+    if (rotate) rotatedMax = (catHeight - fs) / sin;
+    bottom = (xAxis.show ? catHeight : 2) + (xAxis.title ? titleBand : 0);
+  }
+  const plot = {
+    x: area.x + left,
+    y: area.y + top,
+    width: Math.max(1, area.width - left - right),
+    height: Math.max(1, area.height - bottom - top)
+  };
+  const valueLen = horizontal ? plot.width : plot.height;
+  const range = horizontal ? [plot.x, plot.x + plot.width] : [plot.y + plot.height, plot.y];
+  const value = scaleInfo(axisScale(primary.lo, primary.hi, valueLen, primary.axis, primary.frozen, primary.headroom), range, primary.format);
+  const value2 = secondary ? scaleInfo(axisScale(secondary.lo, secondary.hi, valueLen, secondary.axis, secondary.frozen, secondary.headroom), range, secondary.format) : void 0;
+  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 gridAt = (info, key) => info.scale.ticks.forEach((t, i) => {
+    const p = info.px(t);
+    const [x1, y1] = map({ c: catStart, v: p });
+    const [x2, y2] = map({ c: catStart + catLen, v: p });
+    marks.push({ kind: "line", key: `grid-${key}-${i}`, role: "grid", x1, y1, x2, y2, stroke: theme.grid, strokeWidth: 1 });
+  });
+  if (primary.axis.gridlines) gridAt(value, "y");
+  if (value2 && secondary.axis.gridlines) gridAt(value2, "y2");
+  if (xAxis.gridlines) {
+    for (let i = 1; i < n; i++) {
+      const c = catStart + band * i;
+      const [x1, y1] = map({ c, v: range[0] });
+      const [x2, y2] = map({ c, v: range[1] });
+      marks.push({ kind: "line", key: `grid-x-${i}`, role: "grid", x1, y1, x2, y2, stroke: theme.grid, strokeWidth: 1 });
+    }
+  }
+  const ticksFor = (info, v, far) => {
+    if (!v.axis.show) return;
+    const target = { kind: "axis", axis: v.key };
+    info.scale.ticks.forEach((t, i) => {
+      const p = info.px(t);
+      const label = info.tickText(t);
+      const key = `tick-${v.key}-${i}`;
+      if (horizontal) {
+        if (far) marks.push({ kind: "text", key, role: "tick-label", x: p, y: plot.y - 6, text: label, anchor: "middle", baseline: "bottom", size: fs, fill: theme.mutedText, target });
+        else marks.push({ kind: "text", key, role: "tick-label", x: p, y: plot.y + plot.height + 6, text: label, anchor: "middle", baseline: "top", size: fs, fill: theme.mutedText, target });
+      } else if (far) marks.push({ kind: "text", key, role: "tick-label", x: plot.x + plot.width + 8, y: p, text: label, anchor: "start", baseline: "middle", size: fs, fill: theme.mutedText, target });
+      else marks.push({ kind: "text", key, role: "tick-label", x: plot.x - 8, y: p, text: label, anchor: "end", baseline: "middle", size: fs, fill: theme.mutedText, target });
+    });
+  };
+  ticksFor(value, primary, false);
+  if (value2) ticksFor(value2, secondary, true);
+  const xTarget = { kind: "axis", axis: "x" };
+  if (xAxis.show) {
+    const [x1, y1] = map({ c: catStart, v: value.zero });
+    const [x2, y2] = map({ c: catStart + catLen, v: value.zero });
+    marks.push({ kind: "line", key: "axis-x", role: "axis", x1, y1, x2, y2, stroke: theme.axis, strokeWidth: 1, target: xTarget });
+    const every = dateLabels ? 1 : horizontal ? Math.max(1, Math.ceil(fs * 1.3 / band)) : rotate ? Math.max(1, Math.ceil(fs * 1.4 / band)) : 1;
+    let hidden = 0;
+    let truncated = 0;
+    labels.forEach((c, i) => {
+      const text0 = dateLabels ? dateLabels.labels.get(i) : i % every ? void 0 : c;
+      if (text0 === void 0) {
+        hidden++;
+        return;
+      }
+      const target = labelTarget(i);
+      const selected = target ? ctx.isSelected(target) : false;
+      const fill = selected ? theme.selection : theme.mutedText;
+      const extra = target ? { target, selected } : {};
+      if (horizontal) {
+        const maxW = left - (xAxis.title ? titleBand : 0) - 8;
+        const text = truncate(text0, maxW, fs, measure);
+        if (text !== text0) truncated++;
+        marks.push({ kind: "text", key: `tick-x-${i}`, role: "tick-label", x: plot.x - 8, y: catCenter(i), text, anchor: "end", baseline: "middle", size: fs, fill, ...extra });
+      } else if (rotate) {
+        const room = (catCenter(i) - 2) / Math.cos(Math.PI / 4.5);
+        const text = truncate(text0, Math.max(fs, Math.min(rotatedMax, room)), fs, measure);
+        if (text !== text0) truncated++;
+        marks.push({ kind: "text", key: `tick-x-${i}`, role: "tick-label", x: catCenter(i), y: plot.y + plot.height + 8, text, anchor: "end", baseline: "middle", size: fs, fill, rotate, ...extra });
+      } else {
+        const text = dateLabels ? text0 : truncate(text0, Math.max(band - 4, fs * 2), fs, measure);
+        if (text !== text0) truncated++;
+        marks.push({ kind: "text", key: `tick-x-${i}`, role: "tick-label", x: catCenter(i), y: plot.y + plot.height + 6, text, anchor: dateLabels ? "start" : "middle", baseline: "top", size: fs, fill, ...extra });
+      }
+    });
+    if (dateLabels) {
+      for (const i of dateLabels.indexes) {
+        const x = catCenter(i);
+        marks.push({ kind: "line", key: `tick-mark-x-${i}`, role: "tick", x1: x, y1: plot.y + plot.height, x2: x, y2: plot.y + plot.height + 4, stroke: theme.axis, strokeWidth: 1 });
+      }
+    }
+    if (hidden && !dateLabels) ctx.warn("labels-hidden", `${hidden} of ${labels.length} category labels are hidden so the rest do not overlap.`);
+    if (truncated) ctx.warn("labels-truncated", `${truncated} category label${truncated === 1 ? " was" : "s were"} shortened to fit.`);
+  }
+  const yTarget = { kind: "axis", axis: "y" };
+  const valueTitle = primary.axis.title;
+  const catTitle = xAxis.title;
+  const bottomTitle = horizontal ? valueTitle : catTitle;
+  const leftTitle = horizontal ? catTitle : valueTitle;
+  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 });
+  if (_optionalChain([secondary, 'optionalAccess', _12 => _12.axis, 'access', _13 => _13.title])) {
+    const target = { kind: "axis", axis: "y2" };
+    if (horizontal) marks.push({ kind: "text", key: "axis-title-y2", role: "axis-title", x: plot.x + plot.width / 2, y: area.y, text: secondary.axis.title, anchor: "middle", baseline: "top", size: fs + 1, weight: 500, fill: theme.text, target });
+    else marks.push({ kind: "text", key: "axis-title-y2", role: "axis-title", x: area.x + area.width, y: plot.y + plot.height / 2, text: secondary.axis.title, anchor: "middle", baseline: "top", size: fs + 1, weight: 500, fill: theme.text, rotate: 90, target });
+  }
+  for (const axis of ["x", "y", "y2"]) {
+    if (!ctx.isSelected({ kind: "axis", axis })) continue;
+    if (axis === "y2" && !secondary) continue;
+    let box;
+    if (axis === "y2") box = horizontal ? { x: plot.x - 4, y: area.y, width: plot.width + 8, height: plot.y - area.y - 2 } : { x: plot.x + plot.width + 2, y: plot.y - fs / 2, width: area.x + area.width - plot.x - plot.width - 2, height: plot.height + fs };
+    else {
+      const onLeft = axis === "y" !== horizontal;
+      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 };
+    }
+    ctx.outline(`axis-${axis}-selection`, box);
+  }
+  return { plot, horizontal, n, band, catStart, catLen, catCenter, map, value, value2 };
+}
+var toValueScale = (info, axis) => ({ axis, domain: [info.scale.min, info.scale.max], range: info.range, ticks: info.scale.ticks });
+var order = (t) => t === "area" ? 0 : t === "bar" ? 1 : t === "line" ? 2 : 3;
+function pointMark(base, shape, cx, cy, r, fill, stroke, strokeWidth) {
+  if (shape === "circle" || shape === "hit" || shape === "none") return { kind: "circle", role: "point", ...base, cx, cy, r, fill, ...stroke ? { stroke, strokeWidth } : {} };
+  const closed = shape !== "cross";
+  return { kind: "path", role: "point", ...base, d: markerPath(shape, cx, cy, r), fill: closed ? fill : "none", stroke: _nullishCoalesce(stroke, () => ( fill)), strokeWidth: _nullishCoalesce(strokeWidth, () => ( 2)) };
+}
+function drawTrendlines(ctx, plot, series, color, points, toPx, labels) {
+  (_nullishCoalesce(series.trendlines, () => ( []))).forEach((t, ti) => {
+    const target = { kind: "trendline", seriesId: series.id, index: ti };
+    const selected = ctx.isSelected(target);
+    const stroke = _nullishCoalesce(t.color, () => ( color));
+    let px = [];
+    if (t.type === "moving-average") px = chartMovingAverage(points, _nullishCoalesce(t.period, () => ( 2))).map(([x, y]) => toPx(x, y));
+    else {
+      const fit = fitChartTrendline(t, points);
+      if (!fit) {
+        ctx.warn("values-skipped", `The ${t.type} trendline on "${series.name}" could not be fitted (too few usable points).`);
+        return;
+      }
+      const xs = points.map((p) => p[0]);
+      const lo = Math.min(...xs) - (_nullishCoalesce(t.backward, () => ( 0)));
+      const hi = Math.max(...xs) + (_nullishCoalesce(t.forward, () => ( 0)));
+      const steps = t.type === "linear" ? 1 : 200;
+      for (let k = 0; k <= steps; k++) {
+        const x = lo + (hi - lo) * k / steps;
+        const y = fit.evaluate(x);
+        if (y !== null) px.push(toPx(x, y));
+      }
+      if (t.showEquation) labels.push({ text: fit.equation, color: stroke, target });
+      if (t.showR2) labels.push({ text: fit.r2 === null ? "R\xB2 = #N/A" : `R\xB2 = ${trendNumberText(fit.r2)}`, color: stroke, target });
+    }
+    const d = clippedPolyline(px, plot);
+    if (!d) return;
+    ctx.marks.push({ kind: "path", key: `trendline-${series.id}-${ti}`, role: "trendline", d, fill: "none", stroke, strokeWidth: selected ? 3 : 1.5, dash: "6 4", target, selected });
+  });
+}
+function drawTrendLabels(ctx, plot, labels) {
+  labels.forEach(
+    (l, i) => ctx.marks.push({ kind: "text", key: `trendline-label-${i}`, role: "trendline-label", x: plot.x + plot.width - 4, y: plot.y + 4 + i * (ctx.fs + 3), text: l.text, anchor: "end", baseline: "top", size: ctx.fs - 1, fill: l.color, target: l.target })
+  );
+}
+function barLabel(ctx, text, rect, horizontal, positive, stacked, fill, plot) {
+  const { measure, fs, spec, theme } = ctx;
+  const size = fs - 1;
+  const tw = measure(text, size);
+  const th = size + 2;
+  const along = horizontal ? rect.width : rect.height;
+  const across = horizontal ? rect.height : rect.width;
+  const need = horizontal ? tw + 6 : th + 2;
+  const fitsInside = along >= need && across >= (horizontal ? th : Math.min(tw, across + 1));
+  let position = spec.labelPosition;
+  if (position === "auto") position = stacked ? "center" : "outside";
+  const cx = rect.x + rect.width / 2;
+  const cy = rect.y + rect.height / 2;
+  const inner = contrastingTextColor(fill);
+  const centre = () => ({ x: cx, y: cy, anchor: "middle", baseline: "middle", fill: inner });
+  const insideEnd = () => horizontal ? { x: positive ? rect.x + rect.width - 4 : rect.x + 4, y: cy, anchor: positive ? "end" : "start", baseline: "middle", fill: inner } : { x: cx, y: positive ? rect.y + 3 : rect.y + rect.height - 3, anchor: "middle", baseline: positive ? "top" : "bottom", fill: inner };
+  const outside = () => horizontal ? { x: positive ? rect.x + rect.width + 4 : rect.x - 4, y: cy, anchor: positive ? "start" : "end", baseline: "middle", fill: theme.text } : { x: cx, y: positive ? rect.y - 4 : rect.y + rect.height + 4, anchor: "middle", baseline: positive ? "bottom" : "top", fill: theme.text };
+  const outsideFits = () => {
+    if (horizontal) return positive ? rect.x + rect.width + 4 + tw <= plot.x + plot.width + 8 : rect.x - 4 - tw >= plot.x - 8;
+    return positive ? rect.y - 4 - th >= plot.y - fs : rect.y + rect.height + 4 + th <= plot.y + plot.height + fs;
+  };
+  if (position === "center") return fitsInside ? centre() : null;
+  if (position === "inside") return fitsInside ? insideEnd() : stacked ? null : outside();
+  if (stacked) return fitsInside ? centre() : null;
+  if (outsideFits()) return outside();
+  return fitsInside ? insideEnd() : null;
+}
+function layoutCartesian(ctx, area, visible) {
+  const { spec, theme, marks, measure, fs } = ctx;
+  const horizontal = spec.orientation === "horizontal";
+  const n = spec.categories.length;
+  const types = new Map(visible.map((s) => [s.id, _chunkJOX6MJW4cjs.chartSeriesType.call(void 0, spec, s)]));
+  const stacked = spec.stacking !== "none";
+  const percent = spec.stacking === "percent";
+  const onSecondary = (s) => s.axis === "secondary";
+  const useSecondary = visible.some(onSecondary);
+  const stacks = /* @__PURE__ */ new Map();
+  if (stacked) {
+    for (const kind of ["bar", "area"]) {
+      for (const secondary of [false, true]) {
+        const group = visible.filter((s) => types.get(s.id) === kind && onSecondary(s) === secondary);
+        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 });
+        }
+      }
+    }
+  }
+  const range = (secondary) => {
+    let lo = Infinity;
+    let hi = -Infinity;
+    const see = (v) => {
+      lo = Math.min(lo, v);
+      hi = Math.max(hi, v);
+    };
+    const group = visible.filter((s) => onSecondary(s) === secondary);
+    for (const s of group) {
+      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 && Number.isFinite(v) && see(v));
+    }
+    if (!Number.isFinite(lo)) {
+      lo = 0;
+      hi = 1;
+    }
+    if (group.some((s) => types.get(s.id) === "bar" || types.get(s.id) === "area")) {
+      lo = Math.min(lo, 0);
+      hi = Math.max(hi, 0);
+    }
+    const lineLike = group.some((s) => types.get(s.id) === "line" || types.get(s.id) === "scatter");
+    return { lo, hi, lineLike };
+  };
+  const pctFormat = (f) => percent && !f.style && !f.code ? { ...f, style: "percent" } : f;
+  const p = range(false);
+  const s2 = useSecondary ? range(true) : null;
+  const frame = categoryFrame(ctx, area, {
+    labels: spec.categories,
+    horizontal,
+    primary: { lo: p.lo, hi: p.hi, axis: spec.yAxis, format: pctFormat(spec.yAxis.format), frozen: ctx.options.valueDomain, headroom: p.lineLike, key: "y" },
+    secondary: s2 ? { lo: s2.lo, hi: s2.hi, axis: spec.yAxis2, format: pctFormat(spec.yAxis2.format), frozen: ctx.options.valueDomain2, headroom: s2.lineLike, key: "y2" } : void 0
+  });
+  const { plot, band, catCenter, map, catStart } = frame;
+  const infoOf = (s) => onSecondary(s) && frame.value2 ? frame.value2 : frame.value;
+  const bars = visible.filter((s) => types.get(s.id) === "bar");
+  const barAxes = [...new Set(bars.map((s) => onSecondary(s)))];
+  const slots = stacked ? barAxes.length : bars.length;
+  const groupWidth = band * (1 - spec.gapWidth);
+  const o = Math.max(-1, Math.min(0.99, spec.overlap));
+  const barWidth = slots ? groupWidth / (slots - (slots - 1) * o) : 0;
+  const slotOf = (s) => stacked ? barAxes.indexOf(onSecondary(s)) : bars.indexOf(s);
+  const labelMarks = [];
+  const trendLabels = [];
+  let hiddenLabels = 0;
+  const trendsAllowed = chartSupportsTrendlines(spec.type, spec.stacking);
+  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 = _chunkJOX6MJW4cjs.chartSeriesColor.call(void 0, spec, si);
+    const type = types.get(s.id);
+    const stack = stacks.get(s.id);
+    const selSeries = ctx.seriesSelected(s.id);
+    const seriesTarget = { kind: "series", seriesId: s.id };
+    const info = infoOf(s);
+    const valuePx = info.px;
+    const labelsOn = (_nullishCoalesce(s.dataLabels, () => ( spec.dataLabels))) && s.values.length <= MAX_CHART_DATA_LABELS;
+    if ((_nullishCoalesce(s.dataLabels, () => ( spec.dataLabels))) && !labelsOn) ctx.warn("data-labels-hidden", `Data labels are off for "${s.name}": it has more than ${MAX_CHART_DATA_LABELS} points.`);
+    const labelFormat = _nullishCoalesce(s.format, () => ( info.format));
+    const dataLabel = (v) => formatChartNumber(v, labelFormat, _nullishCoalesce(labelFormat.decimals, () => ( void 0)));
+    if (type === "bar") {
+      const slot = slotOf(s);
+      s.values.forEach((raw, i) => {
+        const seg = stack ? stack.segments[i] : raw === null ? null : [0, raw];
+        if (!seg || raw === null || !Number.isFinite(raw)) return;
+        const a = valuePx(seg[0]);
+        const b = valuePx(seg[1]);
+        const c0 = catCenter(i) - groupWidth / 2 + slot * barWidth * (1 - o);
+        const cw = barWidth;
+        const target = { kind: "point", seriesId: s.id, index: i };
+        const selected = ctx.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) };
+        const fill = _chunkJOX6MJW4cjs.chartPointColor.call(void 0, spec, si, i);
+        marks.push({
+          kind: "rect",
+          key: `bar-${s.id}-${i}`,
+          role: "bar",
+          ...rect,
+          fill,
+          radius: Math.min(2, cw / 4),
+          target,
+          selected: selected || selSeries,
+          ...selSeries ? { stroke: theme.selection, strokeWidth: 1.5 } : {}
+        });
+        if (selected) ctx.outline(`bar-${s.id}-${i}-selection`, { x: rect.x - 2, y: rect.y - 2, width: rect.width + 4, height: rect.height + 4 });
+        if (labelsOn) {
+          const v = percent ? seg[1] - seg[0] : raw;
+          const text = dataLabel(v);
+          const at = barLabel(ctx, text, rect, horizontal, seg[1] >= seg[0], stacked, fill, plot);
+          if (!at) {
+            hiddenLabels++;
+            return;
+          }
+          labelMarks.push({ kind: "text", key: `label-${s.id}-${i}`, role: "data-label", ...at, text, size: fs - 1, target });
+        }
+      });
+    } else {
+      const curve = _nullishCoalesce(s.curve, () => ( spec.curve));
+      const pointValue = (i) => {
+        const v = stack ? _nullishCoalesce(_optionalChain([stack, 'access', _14 => _14.segments, 'access', _15 => _15[i], 'optionalAccess', _16 => _16[1]]), () => ( null)) : s.values[i];
+        return v !== null && Number.isFinite(v) ? v : null;
+      };
+      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);
+      const thin = (r) => {
+        if (r.length <= MAX_CHART_LINE_POINTS) return r;
+        const pts = decimateChartPoints(r.map((p2) => ({ x: p2.c, y: p2.v, p: p2 })), MAX_CHART_LINE_POINTS).map((q) => q.p);
+        ctx.warn("points-decimated", `"${s.name}" has ${r.length} points; its line is drawn with ${pts.length} (one column of pixels each).`);
+        return pts;
+      };
+      const drawn = runs.map(thin);
+      if (type === "area") {
+        const parts = drawn.map((r) => {
+          const baseline = stack ? r.map((pt) => ({ c: pt.c, v: valuePx(_nullishCoalesce(_optionalChain([stack, 'access', _17 => _17.segments, 'access', _18 => _18[Math.round((pt.c - catStart) / band - 0.5)], 'optionalAccess', _19 => _19[0]]), () => ( 0))) })).reverse() : [
+            { c: r[r.length - 1].c, v: info.zero },
+            { c: r[0].c, v: info.zero }
+          ];
+          return `${curvePath(r, curve, map)}${stack ? curvePath(baseline, curve, map, false) : baseline.map((pt) => `L${map(pt).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: drawn.map((r) => curvePath(r, curve, map)).join(""), fill: "none", stroke: color, strokeWidth: selSeries ? 3.5 : 2, target: seriesTarget, selected: selSeries });
+      }
+      const marker = _nullishCoalesce(s.marker, () => ( (type === "scatter" || spec.points ? "circle" : "none")));
+      const showDots = marker !== "none";
+      const thinMarkers = n > MAX_CHART_MARKERS;
+      const cells = /* @__PURE__ */ new Set();
+      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) });
+        if (thinMarkers) {
+          const cell = `${Math.round(cx / 2)},${Math.round(cy / 2)}`;
+          if (cells.has(cell)) continue;
+          cells.add(cell);
+        }
+        const target = { kind: "point", seriesId: s.id, index: i };
+        const selected = ctx.isSelected(target);
+        const r = type === "scatter" ? 4.5 : 3.5;
+        const pointColor = _chunkJOX6MJW4cjs.chartPointColor.call(void 0, spec, si, i);
+        const fill = showDots ? type === "scatter" ? pointColor : theme.surface : "transparent";
+        marks.push(
+          pointMark({ key: `point-${s.id}-${i}`, target, selected: selected || selSeries, opacity: type === "scatter" ? 0.85 : void 0 }, showDots ? marker : "hit", cx, cy, showDots ? r : 6, fill, showDots ? pointColor : void 0, 2)
+        );
+        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 (labelsOn) {
+          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
+          });
+        }
+      }
+    }
+    if (trendsAllowed && _optionalChain([s, 'access', _20 => _20.trendlines, 'optionalAccess', _21 => _21.length])) {
+      const points = [];
+      s.values.forEach((v, i) => v !== null && Number.isFinite(v) && points.push([i + 1, v]));
+      const toPx = (x, y) => map({ c: catStart + band * (x - 0.5), v: info.raw(y) });
+      drawTrendlines(ctx, plot, s, color, points, toPx, trendLabels);
+    }
+  }
+  marks.push(...labelMarks);
+  drawTrendLabels(ctx, plot, trendLabels);
+  if (hiddenLabels) ctx.warn("data-labels-hidden", `${hiddenLabels} data label${hiddenLabels === 1 ? "" : "s"} did not fit and ${hiddenLabels === 1 ? "is" : "are"} hidden.`);
+  return {
+    plot,
+    valueScale: toValueScale(frame.value, horizontal ? "x" : "y"),
+    ...frame.value2 ? { valueScale2: toValueScale(frame.value2, horizontal ? "x" : "y") } : {},
+    percent
+  };
+}
+function layoutXy(ctx, area, visible) {
+  const { spec, theme, marks, measure, fs } = ctx;
+  const bubble = spec.type === "bubble";
+  const pointsOf = (s) => s.values.map((y, i) => ({ i, x: _nullishCoalesce(_optionalChain([s, 'access', _22 => _22.x, 'optionalAccess', _23 => _23[i]]), () => ( (bubble || !s.x ? i + 1 : null))), y, size: _nullishCoalesce(_optionalChain([s, 'access', _24 => _24.sizes, 'optionalAccess', _25 => _25[i]]), () => ( null)) })).filter((p) => p.x !== null && p.y !== null && Number.isFinite(p.x) && Number.isFinite(p.y));
+  const all = visible.map((s) => ({ s, pts: pointsOf(s) }));
+  let xlo = Infinity;
+  let xhi = -Infinity;
+  let ylo = Infinity;
+  let yhi = -Infinity;
+  let maxSize = 0;
+  for (const { s, pts } of all) {
+    for (const p of pts) {
+      xlo = Math.min(xlo, p.x);
+      xhi = Math.max(xhi, p.x);
+      ylo = Math.min(ylo, p.y);
+      yhi = Math.max(yhi, p.y);
+      if (p.size !== null && p.size > maxSize) maxSize = p.size;
+    }
+    for (const t of _nullishCoalesce(s.trendlines, () => ( []))) {
+      if (!pts.length) continue;
+      xlo = Math.min(xlo, Math.min(...pts.map((p) => p.x)) - (_nullishCoalesce(t.backward, () => ( 0))));
+      xhi = Math.max(xhi, Math.max(...pts.map((p) => p.x)) + (_nullishCoalesce(t.forward, () => ( 0))));
+    }
+  }
+  if (!Number.isFinite(xlo)) [xlo, xhi, ylo, yhi] = [0, 1, 0, 1];
+  const titleBand = fs * 1.3 + 6;
+  const yAxis = spec.yAxis;
+  const xAxis = spec.xAxis;
+  const yEst = axisScale(ylo, yhi, area.height, yAxis, ctx.options.valueDomain, true);
+  const yText = (t, step) => formatChartNumber(t, yAxis.format, _nullishCoalesce(yAxis.format.decimals, () => ( stepDecimals(step))));
+  const left = (yAxis.show ? Math.max(0, ...yEst.ticks.map((t) => measure(yText(t, yEst.step), fs))) + 8 : 2) + (yAxis.title ? titleBand : 0);
+  const bottom = (xAxis.show ? fs * 1.6 : 2) + (xAxis.title ? titleBand : 0);
+  const plot = { x: area.x + left, y: area.y + fs / 2 + 2, width: Math.max(1, area.width - left - 12), height: Math.max(1, area.height - bottom - fs / 2 - 2) };
+  const maxR = bubble ? Math.max(4, Math.min(plot.width, plot.height) * 0.08) : 0;
+  const inset = bubble ? maxR : 0;
+  const yScale = axisScale(ylo, yhi, plot.height, yAxis, ctx.options.valueDomain, true);
+  const xScale = axisScale(xlo, xhi, plot.width, xAxis, ctx.options.xDomain, true);
+  const xRange = [plot.x + inset, plot.x + plot.width - inset];
+  const yRange = [plot.y + plot.height - inset, plot.y + inset];
+  const xRaw = (x) => linearMap(x, [xScale.min, xScale.max], xRange);
+  const yRaw = (y) => linearMap(y, [yScale.min, yScale.max], yRange);
+  const xPx = (x) => xRaw(Math.min(xScale.max, Math.max(xScale.min, x)));
+  const yPx = (y) => yRaw(Math.min(yScale.max, Math.max(yScale.min, y)));
+  const xTarget = { kind: "axis", axis: "x" };
+  const yTarget = { kind: "axis", axis: "y" };
+  if (yAxis.gridlines) yScale.ticks.forEach((t, i) => marks.push({ kind: "line", key: `grid-y-${i}`, role: "grid", x1: plot.x, y1: yPx(t), x2: plot.x + plot.width, y2: yPx(t), stroke: theme.grid, strokeWidth: 1 }));
+  if (xAxis.gridlines) xScale.ticks.forEach((t, i) => marks.push({ kind: "line", key: `grid-x-${i}`, role: "grid", x1: xPx(t), y1: plot.y, x2: xPx(t), y2: plot.y + plot.height, stroke: theme.grid, strokeWidth: 1 }));
+  if (yAxis.show) yScale.ticks.forEach((t, i) => marks.push({ kind: "text", key: `tick-y-${i}`, role: "tick-label", x: plot.x - 8, y: yPx(t), text: yText(t, yScale.step), anchor: "end", baseline: "middle", size: fs, fill: theme.mutedText, target: yTarget }));
+  if (xAxis.show) {
+    const y0 = yScale.min <= 0 && yScale.max >= 0 ? yPx(0) : plot.y + plot.height;
+    marks.push({ kind: "line", key: "axis-x", role: "axis", x1: plot.x, y1: y0, x2: plot.x + plot.width, y2: y0, stroke: theme.axis, strokeWidth: 1, target: xTarget });
+    const texts = xScale.ticks.map((t) => formatChartNumber(t, xAxis.format, _nullishCoalesce(xAxis.format.decimals, () => ( stepDecimals(xScale.step)))));
+    const widest = Math.max(0, ...texts.map((t) => measure(t, fs)));
+    const spacing = xScale.ticks.length > 1 ? Math.abs(xPx(xScale.ticks[1]) - xPx(xScale.ticks[0])) : Infinity;
+    const every = Math.max(1, Math.ceil((widest + 8) / spacing));
+    xScale.ticks.forEach((t, i) => {
+      if (i % every) return;
+      marks.push({ kind: "text", key: `tick-x-${i}`, role: "tick-label", x: xPx(t), y: plot.y + plot.height + 6, text: texts[i], anchor: "middle", baseline: "top", size: fs, fill: theme.mutedText, target: xTarget });
+    });
+  }
+  if (xAxis.title) marks.push({ kind: "text", key: "axis-title-x", role: "axis-title", x: plot.x + plot.width / 2, y: area.y + area.height, text: xAxis.title, anchor: "middle", baseline: "bottom", size: fs + 1, weight: 500, fill: theme.text, target: xTarget });
+  if (yAxis.title) marks.push({ kind: "text", key: "axis-title-y", role: "axis-title", x: area.x, y: plot.y + plot.height / 2, text: yAxis.title, anchor: "middle", baseline: "top", size: fs + 1, weight: 500, fill: theme.text, rotate: -90, target: yTarget });
+  for (const axis of ["x", "y"]) {
+    if (!ctx.isSelected({ kind: "axis", axis })) continue;
+    ctx.outline(`axis-${axis}-selection`, axis === "y" ? { 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 });
+  }
+  const labelMarks = [];
+  const trendLabels = [];
+  for (const { s, pts } of all) {
+    const si = spec.series.indexOf(s);
+    const color = _chunkJOX6MJW4cjs.chartSeriesColor.call(void 0, spec, si);
+    const type = _chunkJOX6MJW4cjs.chartSeriesType.call(void 0, spec, s);
+    const selSeries = ctx.seriesSelected(s.id);
+    const seriesTarget = { kind: "series", seriesId: s.id };
+    if (type === "line" || type === "area") {
+      const xy = pts.map((p) => ({ x: xPx(p.x), y: yPx(p.y) }));
+      const thinned = xy.length > MAX_CHART_LINE_POINTS ? decimateChartPoints(xy, MAX_CHART_LINE_POINTS) : xy;
+      if (thinned.length < xy.length) ctx.warn("points-decimated", `"${s.name}" has ${xy.length} points; its line is drawn with ${thinned.length}.`);
+      const d = curvePath(thinned.map((p) => ({ c: p.x, v: p.y })), _nullishCoalesce(s.curve, () => ( spec.curve)), (p) => [p.c, p.v]);
+      if (d) marks.push({ kind: "path", key: `line-${s.id}`, role: "line", d, fill: "none", stroke: color, strokeWidth: selSeries ? 3.5 : 2, target: seriesTarget, selected: selSeries });
+    }
+    const marker = bubble ? "circle" : _nullishCoalesce(s.marker, () => ( (type === "scatter" || spec.points ? "circle" : "none")));
+    const ordered = bubble ? [...pts].sort((a, b) => (_nullishCoalesce(b.size, () => ( 0))) - (_nullishCoalesce(a.size, () => ( 0)))) : pts;
+    const labelsOn = (_nullishCoalesce(s.dataLabels, () => ( spec.dataLabels))) && pts.length <= MAX_CHART_DATA_LABELS;
+    const labelFormat = _nullishCoalesce(s.format, () => ( yAxis.format));
+    const cells = /* @__PURE__ */ new Set();
+    for (const p of ordered) {
+      const cx = xPx(p.x);
+      const cy = yPx(p.y);
+      if (pts.length > MAX_CHART_MARKERS) {
+        const cell = `${Math.round(cx / 2)},${Math.round(cy / 2)}`;
+        if (cells.has(cell)) continue;
+        cells.add(cell);
+      }
+      const target = { kind: "point", seriesId: s.id, index: p.i };
+      const selected = ctx.isSelected(target);
+      const pointColor = _chunkJOX6MJW4cjs.chartPointColor.call(void 0, spec, si, p.i);
+      const r = bubble ? maxSize > 0 && p.size !== null && p.size > 0 ? Math.max(2, Math.sqrt(p.size / maxSize) * maxR) : 2 : 4.5;
+      if (bubble) marks.push({ kind: "circle", key: `point-${s.id}-${p.i}`, role: "point", cx, cy, r, fill: pointColor, stroke: pointColor, strokeWidth: 1, opacity: 0.6, target, selected: selected || selSeries });
+      else marks.push(pointMark({ key: `point-${s.id}-${p.i}`, target, selected: selected || selSeries, opacity: 0.85 }, marker === "none" ? "hit" : marker, cx, cy, marker === "none" ? 6 : r, marker === "none" ? "transparent" : pointColor, marker === "none" ? void 0 : pointColor, 2));
+      if (selected) marks.push({ kind: "circle", key: `point-${s.id}-${p.i}-selection`, role: "selection", cx, cy, r: r + 3.5, fill: "none", stroke: theme.selection, strokeWidth: 1.5 });
+      if (labelsOn) labelMarks.push({ kind: "text", key: `label-${s.id}-${p.i}`, role: "data-label", x: cx, y: cy - r - 4, text: formatChartNumber(p.y, labelFormat), anchor: "middle", baseline: "bottom", size: fs - 1, fill: theme.text, target });
+    }
+    if (_optionalChain([s, 'access', _26 => _26.trendlines, 'optionalAccess', _27 => _27.length])) drawTrendlines(ctx, plot, s, color, pts.map((p) => [p.x, p.y]), (x, y) => [xRaw(x), yRaw(y)], trendLabels);
+  }
+  marks.push(...labelMarks);
+  drawTrendLabels(ctx, plot, trendLabels);
+  return {
+    plot,
+    valueScale: { axis: "y", domain: [yScale.min, yScale.max], range: yRange, ticks: yScale.ticks },
+    xScale: { axis: "x", domain: [xScale.min, xScale.max], range: xRange, ticks: xScale.ticks }
+  };
+}
+function trendlineLegendItems(spec, color) {
+  if (!chartSupportsTrendlines(spec.type, spec.stacking)) return [];
+  return spec.series.flatMap(
+    (s, si) => s.hidden ? [] : (_nullishCoalesce(s.trendlines, () => ( []))).map((t, ti) => ({ label: chartTrendlineName(t, s.name), color: _nullishCoalesce(t.color, () => ( color(si))), target: { kind: "trendline", seriesId: s.id, index: ti }, after: s.id }))
+  );
+}
+
+// src/chart/layout-families.ts
+var sliceColor = (ctx, series, i) => _optionalChain([series, 'access', _28 => _28.pointColors, 'optionalAccess', _29 => _29[i]]) || _chunkJOX6MJW4cjs.chartSliceColor.call(void 0, ctx.spec, i);
+function layoutPie(ctx, area, series) {
+  const { spec, theme, marks, fs, selection } = ctx;
+  const values = spec.categories.map((_, i) => {
+    const v = series.values[i];
+    return v !== null && Number.isFinite(v) ? Math.max(0, v) : 0;
+  });
+  const total = values.reduce((a, b) => a + b, 0);
+  const labelsOn = _nullishCoalesce(series.dataLabels, () => ( spec.dataLabels));
+  const labelRoom = labelsOn ? 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 { plot };
+  }
+  let angle = 0;
+  const format = _nullishCoalesce(series.format, () => ( spec.yAxis.format));
+  let hidden = 0;
+  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 = ctx.isSelected(target) || ctx.isSelected({ kind: "category", index: i });
+    const seriesSel = _optionalChain([selection, 'optionalAccess', _30 => _30.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: sliceColor(ctx, series, i),
+      stroke: selected || seriesSel ? theme.selection : theme.surface,
+      strokeWidth: selected || seriesSel ? 2 : 1,
+      target,
+      selected: selected || seriesSel
+    });
+    if (!labelsOn) return;
+    if (sweep <= 0.12) {
+      hidden++;
+      return;
+    }
+    const share = v / total;
+    const text = format.style || format.code ? 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, anchor, baseline: "middle", size: fs, fill: theme.text, target });
+  });
+  if (hidden) ctx.warn("data-labels-hidden", `${hidden} slice label${hidden === 1 ? " is" : "s are"} hidden: the slices are too thin.`);
+  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 { plot };
+}
+function layoutRadar(ctx, area, visible) {
+  const { spec, theme, marks, fs, measure } = ctx;
+  const n = spec.categories.length;
+  const labelW = Math.min(area.width * 0.25, Math.max(0, ...spec.categories.map((c) => measure(c, fs))));
+  const radius = Math.max(8, Math.min(area.width / 2 - labelW - 8, area.height / 2 - fs * 1.6));
+  const cx = area.x + area.width / 2;
+  const cy = area.y + area.height / 2;
+  let lo = 0;
+  let hi = -Infinity;
+  for (const s of visible) for (const v of s.values) if (v !== null && Number.isFinite(v)) lo = Math.min(lo, v), hi = Math.max(hi, v);
+  if (!Number.isFinite(hi)) hi = 1;
+  const scale = axisScale(lo, hi, radius, spec.yAxis, ctx.options.valueDomain);
+  const rOf = (v) => linearMap(Math.min(scale.max, Math.max(scale.min, v)), [scale.min, scale.max], [0, radius]);
+  const angle = (i) => i / n * Math.PI * 2;
+  const at = (i, r) => [cx + r * Math.sin(angle(i)), cy - r * Math.cos(angle(i))];
+  const yTarget = { kind: "axis", axis: "y" };
+  if (spec.yAxis.gridlines)
+    scale.ticks.forEach((t, k) => {
+      const r = rOf(t);
+      if (r <= 0) return;
+      const d = Array.from({ length: n }, (_, i) => at(i, r)).map(([x, y], i) => `${i ? "L" : "M"}${r2(x)},${r2(y)}`).join("") + "Z";
+      marks.push({ kind: "path", key: `grid-ring-${k}`, role: "grid", d, fill: "none", stroke: theme.grid, strokeWidth: 1 });
+    });
+  for (let i = 0; i < n; i++) {
+    const [x, y] = at(i, radius);
+    marks.push({ kind: "line", key: `spoke-${i}`, role: "axis", x1: cx, y1: cy, x2: x, y2: y, stroke: theme.grid, strokeWidth: 1, target: { kind: "axis", axis: "x" } });
+    if (spec.xAxis.show) {
+      const [lx, ly] = at(i, radius + 8);
+      const s = Math.sin(angle(i));
+      const c = Math.cos(angle(i));
+      const target = { kind: "category", index: i };
+      const selected = ctx.isSelected(target);
+      marks.push({ kind: "text", key: `tick-x-${i}`, role: "tick-label", x: lx, y: ly, text: truncate(spec.categories[i], labelW, fs, measure), anchor: Math.abs(s) < 0.2 ? "middle" : s > 0 ? "start" : "end", baseline: Math.abs(c) < 0.2 ? "middle" : c > 0 ? "bottom" : "top", size: fs, fill: selected ? theme.selection : theme.mutedText, target, selected });
+    }
+  }
+  if (spec.yAxis.show)
+    scale.ticks.forEach((t, k) => {
+      const r = rOf(t);
+      marks.push({ kind: "text", key: `tick-y-${k}`, role: "tick-label", x: cx + 4, y: cy - r, text: formatChartNumber(t, spec.yAxis.format, _nullishCoalesce(spec.yAxis.format.decimals, () => ( stepDecimals(scale.step)))), anchor: "start", baseline: "bottom", size: fs - 1, fill: theme.mutedText, target: yTarget });
+    });
+  for (const s of visible) {
+    const si = spec.series.indexOf(s);
+    const color = _chunkJOX6MJW4cjs.chartSeriesColor.call(void 0, spec, si);
+    const selSeries = ctx.seriesSelected(s.id);
+    const pts = s.values.map((v, i) => v !== null && Number.isFinite(v) ? at(i, rOf(v)) : null);
+    const present = pts.filter((p) => p !== null);
+    if (!present.length) continue;
+    const d = present.map(([x, y], i) => `${i ? "L" : "M"}${r2(x)},${r2(y)}`).join("") + "Z";
+    marks.push({ kind: "path", key: `area-${s.id}`, role: "area", d, fill: color, opacity: s.type === "line" ? 0 : 0.15, target: { kind: "series", seriesId: s.id }, selected: selSeries });
+    marks.push({ kind: "path", key: `line-${s.id}`, role: "line", d, fill: "none", stroke: color, strokeWidth: selSeries ? 3.5 : 2, target: { kind: "series", seriesId: s.id }, selected: selSeries });
+    pts.forEach((p, i) => {
+      if (!p) return;
+      const target = { kind: "point", seriesId: s.id, index: i };
+      const selected = ctx.isSelected(target);
+      marks.push({ kind: "circle", key: `point-${s.id}-${i}`, role: "point", cx: p[0], cy: p[1], r: spec.points ? 3.5 : 6, fill: spec.points ? theme.surface : "transparent", ...spec.points ? { stroke: color, strokeWidth: 2 } : {}, target, selected: selected || selSeries });
+      if (selected) marks.push({ kind: "circle", key: `point-${s.id}-${i}-selection`, role: "selection", cx: p[0], cy: p[1], r: 7, fill: "none", stroke: theme.selection, strokeWidth: 1.5 });
+      if (_nullishCoalesce(s.dataLabels, () => ( spec.dataLabels))) marks.push({ kind: "text", key: `label-${s.id}-${i}`, role: "data-label", x: p[0], y: p[1] - 6, text: formatChartNumber(s.values[i], _nullishCoalesce(s.format, () => ( spec.yAxis.format))), anchor: "middle", baseline: "bottom", size: fs - 1, fill: theme.text, target });
+    });
+  }
+  return { plot: { x: cx - radius, y: cy - radius, width: radius * 2, height: radius * 2 } };
+}
+function layoutWaterfall(ctx, area, series) {
+  const { spec, theme, marks, fs } = ctx;
+  const isTotal = (label) => /\b(sub)?total\b/i.test(label);
+  const steps = [];
+  let running = 0;
+  spec.categories.forEach((label, i) => {
+    const v = series.values[i];
+    if (isTotal(label)) {
+      steps.push({ label, index: i, from: 0, to: running, total: true });
+      return;
+    }
+    const delta = v !== null && Number.isFinite(v) ? v : 0;
+    steps.push({ label, index: i, from: running, to: running + delta, total: false });
+    running += delta;
+  });
+  if (spec.showTotal && !(steps.length && steps[steps.length - 1].total)) steps.push({ label: "Total", index: null, from: 0, to: running, total: true });
+  let lo = 0;
+  let hi = 0;
+  for (const s of steps) {
+    lo = Math.min(lo, s.from, s.to);
+    hi = Math.max(hi, s.from, s.to);
+  }
+  const horizontal = spec.orientation === "horizontal";
+  const frame = categoryFrame(ctx, area, {
+    labels: steps.map((s) => s.label),
+    horizontal,
+    primary: { lo, hi, axis: spec.yAxis, format: spec.yAxis.format, frozen: ctx.options.valueDomain, key: "y" },
+    labelTarget: (k) => steps[k].index !== null ? { kind: "category", index: steps[k].index } : void 0
+  });
+  const { band, catCenter, map, value } = frame;
+  const w = band * (1 - spec.gapWidth);
+  const color = _chunkJOX6MJW4cjs.chartSeriesColor.call(void 0, spec, spec.series.indexOf(series));
+  const format = _nullishCoalesce(series.format, () => ( spec.yAxis.format));
+  const labelsOn = _nullishCoalesce(series.dataLabels, () => ( spec.dataLabels));
+  let prevEnd = null;
+  steps.forEach((s, k) => {
+    const a = value.px(s.from);
+    const b = value.px(s.to);
+    const c0 = catCenter(k) - w / 2;
+    const [x, y] = map({ c: c0, v: Math.min(a, b) });
+    const rect = horizontal ? { x: Math.min(a, b), y: c0, width: Math.max(1, Math.abs(b - a)), height: w } : { x, y, width: w, height: Math.max(1, Math.abs(b - a)) };
+    const fill = s.total ? color : s.to >= s.from ? theme.positive : theme.negative;
+    const target = s.index !== null ? { kind: "point", seriesId: series.id, index: s.index } : { kind: "series", seriesId: series.id };
+    const selected = ctx.isSelected(target);
+    marks.push({ kind: "rect", key: `bar-${series.id}-${_nullishCoalesce(s.index, () => ( "total"))}`, role: "bar", ...rect, fill, radius: Math.min(2, w / 4), target, selected });
+    if (selected) ctx.outline(`bar-${series.id}-${_nullishCoalesce(s.index, () => ( "total"))}-selection`, { x: rect.x - 2, y: rect.y - 2, width: rect.width + 4, height: rect.height + 4 });
+    if (prevEnd !== null) {
+      const [x1, y1] = map({ c: catCenter(k - 1) + w / 2, v: value.px(prevEnd) });
+      const [x2, y2] = map({ c: c0, v: value.px(prevEnd) });
+      marks.push({ kind: "line", key: `connector-${k}`, role: "connector", x1, y1, x2, y2, stroke: theme.axis, strokeWidth: 1, dash: "3 3" });
+    }
+    prevEnd = s.to;
+    if (labelsOn) {
+      const text = formatChartNumber(s.total ? s.to : s.to - s.from, format);
+      const up = s.to >= s.from;
+      const [lx, ly] = map({ c: catCenter(k), v: horizontal ? Math.max(a, b) + 4 : up ? Math.min(a, b) - 4 : Math.max(a, b) + 4 });
+      marks.push({ kind: "text", key: `label-${series.id}-${_nullishCoalesce(s.index, () => ( "total"))}`, role: "data-label", x: lx, y: ly, text, anchor: horizontal ? "start" : "middle", baseline: horizontal ? "middle" : up ? "bottom" : "top", size: fs - 1, fill: theme.text, target });
+    }
+  });
+  return { plot: frame.plot, valueScale: toValueScale(value, horizontal ? "x" : "y") };
+}
+function layoutHistogram(ctx, area, visible) {
+  const { spec, marks, fs, theme } = ctx;
+  const pooled = visible.flatMap((s) => s.values);
+  const bins = chartHistogram(pooled, spec.bins);
+  if (!bins.length) return { plot: area };
+  const edgeFormat = spec.xAxis.format;
+  const edges = (b, k2) => `${k2 === 0 ? "[" : "("}${formatChartNumber(b.from, edgeFormat)}, ${formatChartNumber(b.to, edgeFormat)}]`;
+  const counts = visible.map((s) => {
+    const c = bins.map(() => 0);
+    for (const v of s.values) {
+      if (v === null || !Number.isFinite(v)) continue;
+      let k2 = bins.findIndex((b) => v <= b.to);
+      if (k2 < 0) k2 = bins.length - 1;
+      c[k2]++;
+    }
+    return c;
+  });
+  const maxCount = Math.max(1, ...counts.flat());
+  const frame = categoryFrame(ctx, area, {
+    labels: bins.map(edges),
+    horizontal: false,
+    primary: { lo: 0, hi: maxCount, axis: { ...spec.yAxis, format: spec.yAxis.format.code || spec.yAxis.format.style ? spec.yAxis.format : { decimals: 0 } }, format: spec.yAxis.format.code || spec.yAxis.format.style ? spec.yAxis.format : { decimals: 0 }, frozen: null, key: "y" },
+    labelTarget: () => void 0
+  });
+  const { band, catCenter, value, plot } = frame;
+  const k = visible.length;
+  const gap = k > 1 ? band * spec.gapWidth * 0.5 : 0;
+  const w = (band - gap) / k;
+  visible.forEach((s, si) => {
+    const color = _chunkJOX6MJW4cjs.chartSeriesColor.call(void 0, spec, spec.series.indexOf(s));
+    const target = { kind: "series", seriesId: s.id };
+    const selected = ctx.seriesSelected(s.id);
+    counts[si].forEach((c, b) => {
+      if (!c) return;
+      const top = value.px(c);
+      const x = catCenter(b) - band / 2 + gap / 2 + si * w;
+      marks.push({ kind: "rect", key: `bar-${s.id}-${b}`, role: "bar", x, y: top, width: w, height: value.zero - top, fill: color, stroke: theme.surface, strokeWidth: 0.75, opacity: k > 1 ? 0.85 : void 0, target, selected });
+      if (_nullishCoalesce(s.dataLabels, () => ( spec.dataLabels))) marks.push({ kind: "text", key: `label-${s.id}-${b}`, role: "data-label", x: x + w / 2, y: top - 3, text: String(c), anchor: "middle", baseline: "bottom", size: fs - 1, fill: theme.text, target });
+    });
+  });
+  return { plot };
+}
+function layoutBox(ctx, area, visible) {
+  const { spec, marks, theme, fs } = ctx;
+  const stats = visible.map((s) => chartBoxStats(s.values));
+  let lo = Infinity;
+  let hi = -Infinity;
+  for (const st of stats) if (st) lo = Math.min(lo, st.min), hi = Math.max(hi, st.max);
+  if (!Number.isFinite(lo)) [lo, hi] = [0, 1];
+  const frame = categoryFrame(ctx, area, {
+    labels: visible.map((s) => s.name),
+    horizontal: false,
+    primary: { lo, hi, axis: spec.yAxis, format: spec.yAxis.format, frozen: ctx.options.valueDomain, headroom: true, key: "y" },
+    labelTarget: (i) => ({ kind: "series", seriesId: visible[i].id })
+  });
+  const { band, catCenter, value, plot } = frame;
+  const bw = Math.min(80, band * (1 - spec.gapWidth) * 0.6);
+  visible.forEach((s, i) => {
+    const st = stats[i];
+    if (!st) return;
+    const color = _chunkJOX6MJW4cjs.chartSeriesColor.call(void 0, spec, spec.series.indexOf(s));
+    const target = { kind: "series", seriesId: s.id };
+    const selected = ctx.seriesSelected(s.id);
+    const c = catCenter(i);
+    const y = value.px;
+    const line = (key, x1, y1, x2, y2, width = 1.25, stroke = color) => marks.push({ kind: "line", key, role: "whisker", x1, y1, x2, y2, stroke, strokeWidth: width, target });
+    line(`whisker-hi-${s.id}`, c, y(st.upperWhisker), c, y(st.q3));
+    line(`whisker-lo-${s.id}`, c, y(st.q1), c, y(st.lowerWhisker));
+    line(`cap-hi-${s.id}`, c - bw / 4, y(st.upperWhisker), c + bw / 4, y(st.upperWhisker));
+    line(`cap-lo-${s.id}`, c - bw / 4, y(st.lowerWhisker), c + bw / 4, y(st.lowerWhisker));
+    const top = y(st.q3);
+    const bottom = y(st.q1);
+    marks.push({ kind: "rect", key: `box-${s.id}`, role: "box", x: c - bw / 2, y: top, width: bw, height: Math.max(0.5, bottom - top), fill: color, opacity: 0.3, stroke: selected ? theme.selection : color, strokeWidth: selected ? 2.5 : 1.5, target, selected });
+    line(`median-${s.id}`, c - bw / 2, y(st.median), c + bw / 2, y(st.median), 2.5);
+    const my = y(st.mean);
+    marks.push({ kind: "path", key: `mean-${s.id}`, role: "whisker", d: `M${r2(c - 3)},${r2(my - 3)}L${r2(c + 3)},${r2(my + 3)}M${r2(c - 3)},${r2(my + 3)}L${r2(c + 3)},${r2(my - 3)}`, stroke: color, strokeWidth: 1.25, fill: "none", target });
+    st.outliers.slice(0, 500).forEach((o, k) => marks.push({ kind: "circle", key: `outlier-${s.id}-${k}`, role: "outlier", cx: c, cy: y(o), r: 2.5, fill: "none", stroke: color, strokeWidth: 1, target }));
+    if (_nullishCoalesce(s.dataLabels, () => ( spec.dataLabels))) marks.push({ kind: "text", key: `label-${s.id}-median`, role: "data-label", x: c + bw / 2 + 4, y: y(st.median), text: formatChartNumber(st.median, _nullishCoalesce(s.format, () => ( spec.yAxis.format))), anchor: "start", baseline: "middle", size: fs - 1, fill: theme.text, target });
+  });
+  return { plot, valueScale: toValueScale(value, "y") };
+}
+function layoutFunnel(ctx, area, series) {
+  const { spec, marks, theme, fs, measure } = ctx;
+  const n = spec.categories.length;
+  const labelW = spec.xAxis.show ? Math.min(area.width * 0.3, Math.max(0, ...spec.categories.map((c) => measure(c, fs)))) + 10 : 0;
+  const plot = { x: area.x + labelW, y: area.y, width: Math.max(1, area.width - labelW), height: area.height };
+  const max = Math.max(0, ...series.values.map((v) => v !== null && Number.isFinite(v) ? Math.abs(v) : 0));
+  const band = plot.height / Math.max(1, n);
+  const h = band * (1 - Math.min(0.5, spec.gapWidth * 0.5));
+  const format = _nullishCoalesce(series.format, () => ( spec.yAxis.format));
+  const labelsOn = _nullishCoalesce(series.dataLabels, () => ( true));
+  const cx = plot.x + plot.width / 2;
+  spec.categories.forEach((label, i) => {
+    const v = series.values[i];
+    const cy = plot.y + band * (i + 0.5);
+    const target = { kind: "point", seriesId: series.id, index: i };
+    const selected = ctx.isSelected(target);
+    if (spec.xAxis.show) {
+      const catTarget = { kind: "category", index: i };
+      marks.push({ kind: "text", key: `tick-x-${i}`, role: "tick-label", x: plot.x - 8, y: cy, text: truncate(label, labelW - 10, fs, measure), anchor: "end", baseline: "middle", size: fs, fill: ctx.isSelected(catTarget) ? theme.selection : theme.mutedText, target: catTarget });
+    }
+    if (v === null || !Number.isFinite(v) || max <= 0) return;
+    const w = Math.max(1, Math.abs(v) / max * plot.width);
+    const fill = sliceColor(ctx, series, i);
+    marks.push({ kind: "rect", key: `bar-${series.id}-${i}`, role: "bar", x: cx - w / 2, y: cy - h / 2, width: w, height: h, fill, radius: 2, target, selected });
+    if (selected) ctx.outline(`bar-${series.id}-${i}-selection`, { x: cx - w / 2 - 2, y: cy - h / 2 - 2, width: w + 4, height: h + 4 });
+    if (labelsOn) {
+      const text = formatChartNumber(v, format);
+      const fits = measure(text, fs) + 8 <= w && fs + 2 <= h;
+      marks.push({ kind: "text", key: `label-${series.id}-${i}`, role: "data-label", x: fits ? cx : cx + w / 2 + 4, y: cy, text, anchor: fits ? "middle" : "start", baseline: "middle", size: fs, fill: fits ? contrastingTextColor(fill) : theme.text, target });
+    }
+  });
+  return { plot };
+}
+function layoutTreemap(ctx, area, series) {
+  const { spec, marks, theme, fs, measure } = ctx;
+  const values = spec.categories.map((_, i) => {
+    const v = series.values[i];
+    return v !== null && Number.isFinite(v) ? v : 0;
+  });
+  const rects = chartSquarify(values, area);
+  const format = _nullishCoalesce(series.format, () => ( spec.yAxis.format));
+  const labelsOn = _nullishCoalesce(series.dataLabels, () => ( true));
+  let unlabelled = 0;
+  rects.forEach((r, i) => {
+    if (r.width <= 0 || r.height <= 0) return;
+    const target = { kind: "point", seriesId: series.id, index: i };
+    const selected = ctx.isSelected(target) || ctx.isSelected({ kind: "category", index: i });
+    const fill = sliceColor(ctx, series, i);
+    marks.push({ kind: "rect", key: `cell-${i}`, role: "cell", ...r, fill, stroke: selected ? theme.selection : theme.surface, strokeWidth: selected ? 2.5 : 1.5, target, selected });
+    if (!labelsOn) return;
+    const room = r.width - 8;
+    if (room < fs * 2 || r.height < fs * 1.5) {
+      unlabelled++;
+      return;
+    }
+    const color = contrastingTextColor(fill);
+    marks.push({ kind: "text", key: `label-cell-${i}`, role: "data-label", x: r.x + 4, y: r.y + 4, text: truncate(spec.categories[i], room, fs, measure), anchor: "start", baseline: "top", size: fs, weight: 600, fill: color, target });
+    if (r.height >= fs * 3) marks.push({ kind: "text", key: `label-value-${i}`, role: "data-label", x: r.x + 4, y: r.y + 6 + fs * 1.2, text: truncate(formatChartNumber(values[i], format), room, fs - 1, measure), anchor: "start", baseline: "top", size: fs - 1, fill: color, target });
+  });
+  if (unlabelled) ctx.warn("data-labels-hidden", `${unlabelled} treemap cell${unlabelled === 1 ? " is" : "s are"} too small for a label.`);
+  return { plot: area };
+}
+
+// src/chart/layout.ts
+function legendItems(spec, ctx) {
+  const family = _chunkJOX6MJW4cjs.chartFamily.call(void 0, spec);
+  if (spec.type === "funnel") return [];
+  if (_chunkJOX6MJW4cjs.chartColorsByCategory.call(void 0, spec.type)) {
+    const first = spec.series.find((s) => !s.hidden);
+    return spec.categories.map((c, i) => ({
+      label: c,
+      color: _optionalChain([first, 'optionalAccess', _31 => _31.pointColors, 'optionalAccess', _32 => _32[i]]) || _chunkJOX6MJW4cjs.chartSliceColor.call(void 0, spec, i),
+      target: { kind: "category", index: i },
+      faded: false,
+      selected: ctx.isSelected({ kind: "category", index: i }),
+      shape: "square"
+    }));
+  }
+  if (family === "waterfall") {
+    const first = spec.series.find((s) => !s.hidden);
+    if (!first) return [];
+    const target = { kind: "series", seriesId: first.id };
+    return [
+      { label: "Increase", color: ctx.theme.positive, target, faded: false, selected: false, shape: "square" },
+      { label: "Decrease", color: ctx.theme.negative, target, faded: false, selected: false, shape: "square" },
+      { label: "Total", color: _chunkJOX6MJW4cjs.chartSeriesColor.call(void 0, spec, spec.series.indexOf(first)), target, faded: false, selected: false, shape: "square" }
+    ];
+  }
+  if (family === "box") return [];
+  const trends = trendlineLegendItems(spec, (i) => _chunkJOX6MJW4cjs.chartSeriesColor.call(void 0, spec, i));
+  const items = [];
+  spec.series.forEach((s, i) => {
+    const type = _chunkJOX6MJW4cjs.chartSeriesType.call(void 0, spec, s);
+    items.push({
+      label: s.name,
+      color: _chunkJOX6MJW4cjs.chartSeriesColor.call(void 0, spec, i),
+      target: { kind: "series", seriesId: s.id },
+      faded: !!s.hidden,
+      selected: ctx.seriesSelected(s.id),
+      shape: family === "cartesian" || family === "xy" || family === "radar" ? type === "line" ? "line" : "square" : "square"
+    });
+    for (const t of trends.filter((t2) => t2.after === s.id)) items.push({ label: t.label, color: t.color, target: t.target, faded: false, selected: ctx.isSelected(t.target), shape: "dash" });
+  });
+  return items;
+}
+function layoutChart(spec, options) {
+  const width = Math.max(1, Number.isFinite(options.width) ? options.width : 1);
+  const height = Math.max(1, Number.isFinite(options.height) ? options.height : 1);
+  const theme = { ..._chunkJOX6MJW4cjs.DEFAULT_CHART_THEME, ...options.theme };
+  const selection = _nullishCoalesce(options.selection, () => ( null));
+  const marks = [];
+  const warnings = [];
+  const ctx = {
+    spec,
+    options,
+    theme,
+    measure: _nullishCoalesce(options.measureText, () => ( estimateChartTextWidth)),
+    fs: theme.fontSize,
+    width,
+    height,
+    marks,
+    warnings,
+    selection,
+    isSelected: (target) => sameChartSelection(selection, target),
+    seriesSelected: (id) => _optionalChain([selection, 'optionalAccess', _33 => _33.kind]) === "series" && selection.seriesId === id,
+    outline: (key, box) => marks.push({ kind: "rect", key, role: "selection", ...box, fill: "none", stroke: theme.selection, strokeWidth: 1, radius: 3 }),
+    warn: (code, message) => {
+      if (!warnings.some((w) => w.code === code && w.message === message)) warnings.push({ code, message });
+    }
+  };
+  const pad = 12;
+  const fs = theme.fontSize;
+  marks.push({ kind: "rect", key: "background", role: "background", x: 0, y: 0, width, height, fill: theme.background, target: { kind: "chart" } });
+  let top = pad;
+  const titleMark = (kind, label, size, weight, fill) => {
+    const target = { kind };
+    const selected = ctx.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 = ctx.measure(label, size, weight);
+      ctx.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 family = _chunkJOX6MJW4cjs.chartFamily.call(void 0, spec);
+  const visible = spec.series.filter((s) => !s.hidden);
+  const items = legendItems(spec, ctx);
+  let area = { x: pad, y: top, width: width - pad * 2, height: height - top - pad };
+  const seriesLegend = family === "cartesian" || family === "xy" || family === "radar" || family === "histogram";
+  const hasTrend = items.some((i) => i.shape === "dash");
+  const showLegend = spec.legend.show && items.length > 0 && (!seriesLegend || spec.series.length > 1 || spec.series.some((s) => s.hidden) || hasTrend);
+  if (showLegend) area = layoutLegend(items, spec.legend.position, area, ctx, ctx.isSelected({ kind: "legend" }));
+  const finish = (result) => {
+    if (options.readout) addReadout(ctx, options.readout, result.plot);
+    const kept = finalizeMarks(marks, width, height);
+    if (kept.length < marks.length) ctx.warn("values-skipped", `${marks.length - kept.length} mark${marks.length - kept.length === 1 ? " was" : "s were"} left out: their values are not finite numbers.`);
+    return {
+      width,
+      height,
+      plot: result.plot,
+      marks: kept,
+      percent: _nullishCoalesce(result.percent, () => ( false)),
+      theme,
+      warnings,
+      ...result.valueScale ? { valueScale: result.valueScale } : {},
+      ...result.valueScale2 ? { valueScale2: result.valueScale2 } : {},
+      ...result.xScale ? { xScale: result.xScale } : {}
+    };
+  };
+  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 finish({ plot: { x: area.x, y: area.y, width: 0, height: 0 } });
+  };
+  const hasData = visible.some((s) => s.values.some((v) => v !== null && Number.isFinite(v)));
+  const needsCategories = family !== "histogram" && family !== "box" && family !== "xy";
+  if (needsCategories && !spec.categories.length || !visible.length || !hasData) return empty(_nullishCoalesce(options.emptyMessage, () => ( "No data")));
+  switch (family) {
+    case "pie":
+      return finish(layoutPie(ctx, area, visible[0]));
+    case "radar":
+      if (spec.categories.length < 3) {
+        ctx.warn("type-fallback", "A radar chart needs at least 3 categories; it is drawn as a line chart until then.");
+        return finish(layoutCartesian(ctx, area, visible));
+      }
+      return finish(layoutRadar(ctx, area, visible));
+    case "waterfall":
+      return finish(layoutWaterfall(ctx, area, visible[0]));
+    case "histogram":
+      return finish(layoutHistogram(ctx, area, visible));
+    case "box":
+      return finish(layoutBox(ctx, area, visible));
+    case "funnel":
+      return finish(layoutFunnel(ctx, area, visible[0]));
+    case "treemap":
+      return finish(layoutTreemap(ctx, area, visible[0]));
+    case "xy":
+      return finish(layoutXy(ctx, area, visible));
+    default:
+      return finish(layoutCartesian(ctx, area, visible));
+  }
+}
+function layoutLegend(items, position, area, ctx, legendSelected) {
+  const { theme, measure, marks } = ctx;
+  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 fit = Math.max(1, Math.floor((area.height + 0.5) / rowH));
+    const shown = items.slice(0, fit);
+    const h = Math.min(shown.length * rowH, area.height);
+    const x = position === "left" ? area.x : area.x + area.width - w;
+    const y = area.y + (area.height - h) / 2;
+    shown.forEach((item, i) => placed.push({ item, x, y: y + i * rowH + rowH / 2 }));
+    if (shown.length < items.length) ctx.warn("legend-truncated", `The legend shows ${shown.length} of ${items.length} entries; the chart is too short for the rest.`);
+    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 maxRows = Math.max(1, Math.floor(ctx.height * 0.3 / rowH));
+    const shown = rows.slice(0, maxRows);
+    const hiddenCount = rows.slice(maxRows).reduce((t, r) => t + r.length, 0);
+    if (hiddenCount) ctx.warn("legend-truncated", `The legend shows ${items.length - hiddenCount} of ${items.length} entries; the rest do not fit.`);
+    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" || item.shape === "dash")
+      marks.push({ kind: "line", key: `legend-swatch-${i}`, role: "legend-swatch", x1: x, y1: y, x2: x + swatch, y2: y, stroke: item.color, strokeWidth: item.shape === "dash" ? 1.5 : 2.5, ...item.shape === "dash" ? { dash: "3 2" } : {}, 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 addReadout(ctx, readout, plot) {
+  const { spec, marks, theme, fs, measure } = ctx;
+  const series = spec.series.find((s) => s.id === readout.seriesId);
+  const value = _optionalChain([series, 'optionalAccess', _34 => _34.values, 'access', _35 => _35[readout.index]]);
+  if (!series || value === null || value === void 0) return;
+  const mark = marks.find((m) => (m.role === "point" || m.role === "bar") && _optionalChain([m, 'access', _36 => _36.target, 'optionalAccess', _37 => _37.kind]) === "point" && m.target.seriesId === readout.seriesId && m.target.index === readout.index);
+  if (!mark) return;
+  let ax;
+  let ay;
+  if (mark.kind === "rect") {
+    ax = mark.x + mark.width / 2;
+    ay = mark.y;
+  } else if (mark.kind === "circle") {
+    ax = mark.cx;
+    ay = mark.cy - mark.r;
+  } else return;
+  const axis = series.axis === "secondary" ? spec.yAxis2 : spec.yAxis;
+  const x = _optionalChain([series, 'access', _38 => _38.x, 'optionalAccess', _39 => _39[readout.index]]);
+  const text = x !== null && x !== void 0 && _chunkJOX6MJW4cjs.chartFamily.call(void 0, spec) === "xy" ? `${formatChartNumber(x, spec.xAxis.format)}, ${formatChartNumber(value, axis.format)}` : `${_nullishCoalesce(spec.categories[readout.index], () => ( ""))}: ${formatChartNumber(value, _nullishCoalesce(series.format, () => ( axis.format)))}`;
+  const w = measure(text, fs, 600) + 10;
+  const h = fs + 8;
+  const bx = Math.max(plot.x, Math.min(plot.x + plot.width - w, ax - w / 2));
+  const by = Math.max(plot.y, Math.min(plot.y + plot.height - h, ay - h - 6));
+  marks.push({ kind: "rect", key: "drag-readout-box", role: "drag-readout", x: bx, y: by, width: w, height: h, fill: theme.text, radius: 3, opacity: 0.9 });
+  marks.push({ kind: "text", key: "drag-readout", role: "drag-readout", x: bx + w / 2, y: by + h / 2, text, anchor: "middle", baseline: "middle", size: fs, weight: 600, fill: theme.surface });
+}
+var finite = (...n) => n.every((v) => v === void 0 || Number.isFinite(v));
+function finalizeMarks(marks, width, height) {
+  const lim = (v, size) => Math.max(-size * 4, Math.min(size * 5, v));
+  const out = [];
+  for (const m of marks) {
+    switch (m.kind) {
+      case "rect":
+        if (!finite(m.x, m.y, m.width, m.height)) continue;
+        out.push({ ...m, x: lim(m.x, width), y: lim(m.y, height), width: Math.max(0, Math.min(m.width, width * 9)), height: Math.max(0, Math.min(m.height, height * 9)) });
+        break;
+      case "circle":
+        if (!finite(m.cx, m.cy, m.r)) continue;
+        out.push({ ...m, cx: lim(m.cx, width), cy: lim(m.cy, height) });
+        break;
+      case "line":
+        if (!finite(m.x1, m.y1, m.x2, m.y2)) continue;
+        out.push({ ...m, x1: lim(m.x1, width), y1: lim(m.y1, height), x2: lim(m.x2, width), y2: lim(m.y2, height) });
+        break;
+      case "text":
+        if (!finite(m.x, m.y, m.size)) continue;
+        out.push(m);
+        break;
+      case "path":
+        if (/NaN|Infinity/.test(m.d)) continue;
+        out.push(m);
+        break;
+    }
+  }
+  return out;
+}
+function chartValueAtPoint(scene, point, secondary = false) {
+  const scale = secondary ? _nullishCoalesce(scene.valueScale2, () => ( scene.valueScale)) : 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 chartXAtPoint(scene, point) {
+  const scale = scene.xScale;
+  if (!scale) return void 0;
+  return linearMap(point.x, scale.range, scale.domain);
+}
+function snapChartValue(scene, value, step, ticks = _nullishCoalesce(_optionalChain([scene, 'access', _40 => _40.valueScale, 'optionalAccess', _41 => _41.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/summary.ts
+function summarizeChart(spec, size = { width: 640, height: 400 }, scene = layoutChart(spec, { ...size, selection: null })) {
+  const visible = spec.series.filter((s) => !s.hidden);
+  const series = visible.map((s) => summarizeChartSeries(s, spec.categories));
+  const colors = _chunkJOX6MJW4cjs.chartColorsByCategory.call(void 0, spec.type) ? spec.categories.map((_, i) => _optionalChain([visible, 'access', _42 => _42[0], 'optionalAccess', _43 => _43.pointColors, 'optionalAccess', _44 => _44[i]]) || _chunkJOX6MJW4cjs.chartSliceColor.call(void 0, spec, i)) : visible.map((s) => _chunkJOX6MJW4cjs.chartSeriesColor.call(void 0, spec, spec.series.indexOf(s)));
+  const check = _chunkJOX6MJW4cjs.checkChartColors.call(void 0, colors, { surface: scene.theme.surface.startsWith("var(") ? "#ffffff" : scene.theme.surface });
+  const axis = (s) => s ? { min: s.domain[0], max: s.domain[1], ticks: [...s.ticks] } : void 0;
+  return {
+    type: spec.type,
+    title: spec.title,
+    categories: spec.categories.length,
+    series,
+    ...scene.valueScale ? { valueAxis: axis(scene.valueScale) } : {},
+    ...scene.valueScale2 ? { secondaryAxis: axis(scene.valueScale2) } : {},
+    ...scene.xScale ? { xAxis: axis(scene.xScale) } : {},
+    warnings: scene.warnings,
+    colors: { ok: check.ok, issues: check.issues },
+    description: describeChart(spec, series)
+  };
+}
+function describeChart(spec, series = spec.series.filter((s) => !s.hidden).map((s) => summarizeChartSeries(s, spec.categories))) {
+  const kind = _chunkJOX6MJW4cjs.CHART_TYPE_LABELS[spec.type].toLowerCase();
+  const parts = [];
+  const family = _chunkJOX6MJW4cjs.chartFamily.call(void 0, spec);
+  const format = spec.yAxis.format;
+  const fmt = (v) => v === null ? "blank" : formatChartNumber(v, format);
+  const head = spec.title ? `${spec.title}: a ${kind} chart` : `A ${kind} chart`;
+  if (!series.length || series.every((s) => s.count === 0)) return `${head} with no data.`;
+  if (family === "pie" || family === "funnel" || family === "treemap") {
+    const s = series[0];
+    const total = _nullishCoalesce(s.sum, () => ( 0));
+    const share = (v) => total && v !== null ? ` (${Math.round(v / total * 100)}%)` : "";
+    parts.push(`${head} of ${s.name} across ${spec.categories.length} categories, totalling ${fmt(s.sum)}.`);
+    parts.push(`The largest is ${s.maxAt} at ${fmt(s.max)}${share(s.max)}; the smallest is ${s.minAt} at ${fmt(s.min)}${share(s.min)}.`);
+    return parts.join(" ");
+  }
+  if (family === "waterfall") {
+    const s = spec.series.find((x) => !x.hidden);
+    const steps = s.values.filter((v, i) => v !== null && Number.isFinite(v) && !/\b(sub)?total\b/i.test(_nullishCoalesce(spec.categories[i], () => ( ""))));
+    const total = steps.reduce((t, v) => t + v, 0);
+    const up = steps.filter((v) => v > 0).length;
+    const down = steps.filter((v) => v < 0).length;
+    return `${head} of ${s.name}: ${up} increase${up === 1 ? "" : "s"} and ${down} decrease${down === 1 ? "" : "s"} over ${spec.categories.length} steps, ending at a total of ${fmt(total)}.`;
+  }
+  if (family === "histogram" || family === "box") {
+    parts.push(`${head} of ${series.map((s) => s.name).join(", ")}.`);
+    for (const s of series) parts.push(`${s.name}: ${s.count} values from ${fmt(s.min)} to ${fmt(s.max)}, mean ${fmt(s.mean)}.`);
+    return parts.join(" ");
+  }
+  const what = family === "xy" ? `${series.length} series of points` : `${series.length} series over ${spec.categories.length} categories${spec.categories.length ? ` (${spec.categories[0]} to ${spec.categories[spec.categories.length - 1]})` : ""}`;
+  parts.push(`${head} showing ${what}.`);
+  for (const s of series.slice(0, 8)) {
+    if (!s.count) {
+      parts.push(`${s.name} has no values.`);
+      continue;
+    }
+    const pct = s.change !== null ? Math.round(Math.abs(s.change) * 100) : 0;
+    const trend = s.trend && s.trend !== "flat" ? `, ${s.trend}${pct ? `, ${s.change > 0 ? "up" : "down"} ${pct}% from first to last` : ""}` : s.trend === "flat" ? ", roughly flat" : "";
+    parts.push(`${s.name} ranges from ${fmt(s.min)} (${s.minAt}) to ${fmt(s.max)} (${s.maxAt})${trend}.`);
+  }
+  if (series.length > 8) parts.push(`${series.length - 8} more series are not described.`);
+  return parts.join(" ");
+}
+
+// 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 = (text) => text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+function markParts(mark, fontFamily) {
+  const common = { opacity: mark.opacity, "data-role": mark.role };
+  const parts = (tag, values, text) => ({
+    tag,
+    attrs: Object.fromEntries(Object.entries(values).filter(([, v]) => v !== void 0 && v !== "").map(([k, v]) => [k, String(v)])),
+    text
+  });
+  switch (mark.kind) {
+    case "rect":
+      return parts("rect", { 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 parts("path", { 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 parts("circle", { cx: mark.cx, cy: mark.cy, r: mark.r, fill: mark.fill, stroke: mark.stroke, "stroke-width": mark.strokeWidth, ...common });
+    case "line":
+      return parts("line", { 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 parts(
+        "text",
+        {
+          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
+        },
+        mark.text
+      );
+  }
+}
+function markToSvg(mark, fontFamily) {
+  const { tag, attrs, text } = markParts(mark, fontFamily);
+  const attrText = Object.entries(attrs).map(([k, v]) => ` ${k}="${escape(v)}"`).join("");
+  return text === void 0 ? `<${tag}${attrText}/>` : `<${tag}${attrText}>${escape(text)}</${tag}>`;
+}
+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;
+  const desc = options.description;
+  const labelled = [label ? "chart-title" : "", desc ? "chart-desc" : ""].filter(Boolean).join(" ");
+  const head = `${label ? `<title id="chart-title">${escape(label)}</title>` : ""}${desc ? `<desc id="chart-desc">${escape(desc)}</desc>` : ""}`;
+  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)}"` : ""}${labelled ? ` aria-labelledby="${labelled}"` : ""}>${head}${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))), description: _nullishCoalesce(options.description, () => ( describeChart(spec))) });
+}
+var SVG_NS = "http://www.w3.org/2000/svg";
+function chartSceneToDomSpec(scene, options = {}) {
+  const hide = _nullishCoalesce(options.hideSelection, () => ( true));
+  const font = scene.theme.fontFamily;
+  const tag = (name) => `${SVG_NS} ${name}`;
+  const children = [];
+  if (options.ariaLabel) children.push([tag("title"), {}, options.ariaLabel]);
+  if (options.description) children.push([tag("desc"), {}, options.description]);
+  for (const mark of scene.marks) {
+    if (hide && mark.role === "selection") continue;
+    const { tag: name, attrs: attrs2, text } = markParts(mark, font);
+    children.push(text === void 0 ? [tag(name), attrs2] : [tag(name), attrs2, text]);
+  }
+  const attrs = {
+    width: String(scene.width),
+    height: String(scene.height),
+    viewBox: `0 0 ${scene.width} ${scene.height}`,
+    role: "img",
+    ...options.ariaLabel ? { "aria-label": options.ariaLabel } : {},
+    ...options.attrs
+  };
+  return [tag("svg"), attrs, ...children];
+}
+
+// src/chart/presets.ts
+var CHART_LAYOUT_PRESETS = [
+  { id: "standard", label: "Standard", description: "Legend at the bottom, value grid lines, no data labels.", patch: { legend: { show: true, position: "bottom" }, dataLabels: false, xAxis: { gridlines: false, show: true }, yAxis: { gridlines: true, show: true } } },
+  { id: "minimal", label: "Minimal", description: "No legend, grid lines or axis titles; the data speaks.", patch: { legend: { show: false }, dataLabels: false, xAxis: { gridlines: false, title: "" }, yAxis: { gridlines: false, title: "" } } },
+  { id: "labelled", label: "Labelled", description: "Values written on the marks, no value axis or grid lines.", patch: { dataLabels: true, labelPosition: "auto", yAxis: { show: false, gridlines: false }, xAxis: { gridlines: false } } },
+  { id: "legend-right", label: "Legend on the right", description: "Legend beside the plot, value grid lines.", patch: { legend: { show: true, position: "right" }, yAxis: { gridlines: true } } },
+  { id: "presentation", label: "Presentation", description: "Legend on top, data labels, light grid.", patch: { legend: { show: true, position: "top" }, dataLabels: true, yAxis: { gridlines: true }, xAxis: { gridlines: false } } },
+  { id: "analysis", label: "Analysis", description: "Grid lines on both axes, point markers, legend at the bottom.", patch: { legend: { show: true, position: "bottom" }, points: true, dataLabels: false, xAxis: { gridlines: true }, yAxis: { gridlines: true } } }
+];
+function monochromeChartPalette(base, count = 6) {
+  const steps = count <= 1 ? [0] : Array.from({ length: count }, (_, i) => -0.45 + 1.05 * i / (count - 1));
+  return steps.map((t) => _chunkJOX6MJW4cjs.shadeChartColor.call(void 0, base, t));
+}
+var CHART_COLOR_SCHEMES = [
+  { id: "default", label: "Default", description: "Ten distinct colours, readable on light and dark backgrounds.", palette: _chunkJOX6MJW4cjs.DEFAULT_CHART_PALETTE },
+  { id: "okabe-ito", label: "Okabe\u2013Ito", description: "Eight colours chosen to stay distinct with colour-blindness.", palette: ["#e69f00", "#56b4e9", "#009e73", "#f0e442", "#0072b2", "#d55e00", "#cc79a7", "#000000"] },
+  { id: "office", label: "Office", description: "The six accent colours of the default Office theme.", palette: ["#4472c4", "#ed7d31", "#a5a5a5", "#ffc000", "#5b9bd5", "#70ad47"] },
+  { id: "warm", label: "Warm", description: "Reds, oranges and yellows.", palette: ["#b2182b", "#d6604d", "#f4a582", "#e08214", "#fdb863", "#8c510a"] },
+  { id: "cool", label: "Cool", description: "Blues, teals and purples.", palette: ["#2166ac", "#4393c3", "#35978f", "#80cdc1", "#762a83", "#9970ab"] },
+  { id: "monochrome-blue", label: "Monochrome blue", description: "Shades of one blue.", palette: monochromeChartPalette("#4269d0") },
+  { id: "monochrome-green", label: "Monochrome green", description: "Shades of one green.", palette: monochromeChartPalette("#3ca951") },
+  { id: "monochrome-orange", label: "Monochrome orange", description: "Shades of one orange.", palette: monochromeChartPalette("#e8710a") },
+  { id: "monochrome-gray", label: "Monochrome grey", description: "Shades of grey.", palette: monochromeChartPalette("#6b7280") }
+];
+function chartPresetPatch(options) {
+  const patch = {};
+  if (options.layout !== void 0) {
+    const preset = CHART_LAYOUT_PRESETS.find((p) => p.id === options.layout);
+    if (!preset) return { ok: false, message: `There is no layout "${options.layout}"; expected one of ${CHART_LAYOUT_PRESETS.map((p) => `"${p.id}"`).join(", ")}.` };
+    Object.assign(patch, preset.patch);
+  }
+  if (options.colors !== void 0) {
+    const scheme = CHART_COLOR_SCHEMES.find((p) => p.id === options.colors);
+    if (!scheme) return { ok: false, message: `There is no colour scheme "${options.colors}"; expected one of ${CHART_COLOR_SCHEMES.map((p) => `"${p.id}"`).join(", ")}.` };
+    patch.palette = [...scheme.palette];
+  }
+  if (options.layout === void 0 && options.colors === void 0) return { ok: false, message: "Name a layout, a colour scheme or both." };
+  return { ok: true, patch };
+}
+
+// src/chart/controller.ts
+function sameChartJson(a, b) {
+  if (a === b) return true;
+  if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) return Number.isNaN(a) && Number.isNaN(b);
+  if (Array.isArray(a) !== Array.isArray(b)) return false;
+  if (Array.isArray(a)) {
+    const bb = b;
+    return a.length === bb.length && a.every((v, i) => sameChartJson(v, bb[i]));
+  }
+  const ao = a;
+  const bo = b;
+  const keys = Object.keys(ao).filter((k) => ao[k] !== void 0);
+  if (keys.length !== Object.keys(bo).filter((k) => bo[k] !== void 0).length) return false;
+  return keys.every((k) => Object.prototype.hasOwnProperty.call(bo, k) && sameChartJson(ao[k], bo[k]));
+}
+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.gestureStart = null}
+  __init6() {this.revision = 0}
+  __init7() {this.applying = false}
+  
+  __init8() {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);_class.prototype.__init10.call(this);
+    this.history = _nullishCoalesce(options.history, () => ( new (0, _chunkQKLRAA4Tcjs.HistoryManager)()));
+    this.onChange = options.onChange;
+    const { spec, issues } = _chunkJOX6MJW4cjs.normalizeChartSpec.call(void 0, _nullishCoalesce(options.spec, () => ( {})));
+    this.spec = spec;
+    this.issues = issues;
+    this.state = this.computeState();
+    this.connect();
+  }
+  connect() {
+    _optionalChain([this, 'access', _45 => _45.unsubscribeHistory, 'optionalCall', _46 => _46()]);
+    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). */
+  __init9() {this.getState = () => this.state}
+  /** Calls `listener` after every change. Returns an unsubscribe function. */
+  __init10() {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', _47 => _47.kind]) === "series" || _optionalChain([sel, 'optionalAccess', _48 => _48.kind]) === "point" || _optionalChain([sel, 'optionalAccess', _49 => _49.kind]) === "trendline" ? 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', _50 => _50.kind]) === "point" || _optionalChain([sel, 'optionalAccess', _51 => _51.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', _52 => _52.onChange, 'optionalCall', _53 => _53(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 "trendline":
+        return _optionalChain([spec, 'access', _54 => _54.series, 'access', _55 => _55.find, 'call', _56 => _56((s) => s.id === sel.seriesId), 'optionalAccess', _57 => _57.trendlines, 'optionalAccess', _58 => _58[sel.index]]) ? 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;
+    const hadIssues = this.issues.length > 0;
+    this.issues = [];
+    if (sameChartJson(before, next)) {
+      const reselect = select !== void 0 && !sameChartSelection(this.selection, select) && !(select === null && this.selection === null);
+      if (reselect) this.selection = select;
+      if (reselect || hadIssues) this.notify(false);
+      return;
+    }
+    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 = _chunkJOX6MJW4cjs.cloneChartSpec.call(void 0, 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,
+      yAxis2: patch.yAxis2 ? { ...s.yAxis2, ...patch.yAxis2 } : s.yAxis2,
+      legend: patch.legend ? { ...s.legend, ...patch.legend } : s.legend,
+      version: 1
+    };
+    const { spec, issues } = _chunkJOX6MJW4cjs.normalizeChartSpec.call(void 0, 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`), value (`y`) or secondary value (`y2`) axis. */
+  setAxis(axis, patch) {
+    const key = axis === "x" ? "xAxis" : axis === "y" ? "yAxis" : "yAxis2";
+    return this.update({ [key]: patch }, { label: `Change ${axis === "x" ? "category" : axis === "y" ? "value" : "secondary value"} axis` });
+  }
+  /**
+   * Applies a named quick layout and / or colour scheme (see `CHART_LAYOUT_PRESETS` and
+   * `CHART_COLOR_SCHEMES`) as one undo step.
+   */
+  applyPreset(options) {
+    const preset = chartPresetPatch(options);
+    if (!preset.ok) return this.reject(preset.message);
+    const label = options.layout && options.colors ? "Apply chart style" : options.layout ? "Apply quick layout" : "Change colours";
+    return this.update(preset.patch, { label });
+  }
+  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 = _chunkJOX6MJW4cjs.parseChartValue.call(void 0, 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 = _chunkJOX6MJW4cjs.parseChartValue.call(void 0, 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 : _chunkJOX6MJW4cjs.uniqueChartSeriesId.call(void 0, 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 } = _chunkJOX6MJW4cjs.normalizeChartSpec.call(void 0, { ...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 = _chunkJOX6MJW4cjs.cloneChartSeries.call(void 0, 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 resettable = ["axis", "x", "sizes", "pointColors", "marker", "curve", "dataLabels", "format"];
+    for (const key of resettable) {
+      if (!(key in patch) || patch[key] === void 0) continue;
+      if (patch[key] === null) delete next[key];
+      else next[key] = patch[key];
+    }
+    if (next.axis === "primary") delete next.axis;
+    const series2 = this.spec.series.map((s) => s.id === id ? next : s);
+    const { spec, issues } = _chunkJOX6MJW4cjs.normalizeChartSpec.call(void 0, { ...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 = _chunkJOX6MJW4cjs.uniqueChartSeriesId.call(void 0, 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 = _chunkJOX6MJW4cjs.parseChartValue.call(void 0, 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 = _chunkJOX6MJW4cjs.chartDataFromTable.call(void 0, 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', _59 => _59.color]) ? { color: old.color } : {}, ..._optionalChain([old, 'optionalAccess', _60 => _60.type]) ? { type: old.type } : {}, ...old ? { id: old.id } : {} };
+    });
+    const { spec } = _chunkJOX6MJW4cjs.normalizeChartSpec.call(void 0, { ...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(text, options = {}) {
+    const delimiter = _nullishCoalesce(options.delimiter, () => ( (text.includes("	") ? "	" : ",")));
+    return this.importTable(_chunkTNNJXF46cjs.parseCsv.call(void 0, text, { delimiter }), options);
+  }
+  // -------------------------------------------------------------------------
+  // Trendlines
+  // -------------------------------------------------------------------------
+  /** Adds a trendline to a series and selects it. Returns its index (and the fit, when it can be computed). */
+  addTrendline(seriesId, input) {
+    const series = this.getSeries(seriesId);
+    if (!series) return this.unknownSeries(seriesId);
+    if (!chartSupportsTrendlines(this.spec.type, this.spec.stacking))
+      return this.reject(`Trendlines need an unstacked bar, line, area, scatter or bubble chart; this is a ${this.spec.stacking !== "none" ? `${this.spec.stacking} ` : ""}${this.spec.type} chart.`);
+    const issues = [];
+    const line = _chunkJOX6MJW4cjs.normalizeChartTrendline.call(void 0, input, "trendline", issues);
+    if (!line || issues.length) return this.reject(issues.map((i) => i.message).join(" ") || "The trendline is not valid.", issues);
+    const index = _nullishCoalesce(_optionalChain([series, 'access', _61 => _61.trendlines, 'optionalAccess', _62 => _62.length]), () => ( 0));
+    const next = this.edited((d) => {
+      const s = d.series.find((x) => x.id === seriesId);
+      s.trendlines = [..._nullishCoalesce(s.trendlines, () => ( [])), line];
+    });
+    this.commit(`Add trendline to "${series.name}"`, next, { kind: "trendline", seriesId, index });
+    return { ok: true, index, fit: this.trendlineFit(seriesId, index) };
+  }
+  /** Changes a trendline (all-or-nothing). */
+  updateTrendline(seriesId, index, patch) {
+    const series = this.getSeries(seriesId);
+    if (!series) return this.unknownSeries(seriesId);
+    const current = _optionalChain([series, 'access', _63 => _63.trendlines, 'optionalAccess', _64 => _64[index]]);
+    if (!current) return fail(`"${series.name}" has no trendline ${index}; ${_optionalChain([series, 'access', _65 => _65.trendlines, 'optionalAccess', _66 => _66.length]) ? `expected 0 to ${series.trendlines.length - 1}` : "it has none yet"}.`);
+    const issues = [];
+    const merged = { ...current, ...patch };
+    for (const [k, v] of Object.entries(patch)) if (v === null) delete merged[k];
+    const line = _chunkJOX6MJW4cjs.normalizeChartTrendline.call(void 0, merged, "trendline", issues);
+    if (!line || issues.length) return this.reject(issues.map((i) => i.message).join(" "), issues);
+    this.commit(
+      "Change trendline",
+      this.edited((d) => {
+        d.series.find((x) => x.id === seriesId).trendlines[index] = line;
+      })
+    );
+    return { ok: true };
+  }
+  removeTrendline(seriesId, index) {
+    const series = this.getSeries(seriesId);
+    if (!series) return this.unknownSeries(seriesId);
+    if (!_optionalChain([series, 'access', _67 => _67.trendlines, 'optionalAccess', _68 => _68[index]])) return fail(`"${series.name}" has no trendline ${index}.`);
+    this.commit(
+      "Delete trendline",
+      this.edited((d) => {
+        const s = d.series.find((x) => x.id === seriesId);
+        s.trendlines = s.trendlines.filter((_, i) => i !== index);
+        if (!s.trendlines.length) delete s.trendlines;
+      })
+    );
+    return { ok: true };
+  }
+  /** The points a series' trendlines are fitted to: (x, y) with x = 1, 2, 3 … on category charts. */
+  trendlinePoints(seriesId) {
+    const series = this.getSeries(seriesId);
+    if (!series) return [];
+    const xy = _chunkJOX6MJW4cjs.chartFamily.call(void 0, this.spec) === "xy";
+    const out = [];
+    series.values.forEach((v, i) => {
+      const x = xy ? _nullishCoalesce(_optionalChain([series, 'access', _69 => _69.x, 'optionalAccess', _70 => _70[i]]), () => ( (this.spec.type === "bubble" ? i + 1 : null))) : i + 1;
+      if (v !== null && x !== null && Number.isFinite(v) && Number.isFinite(x)) out.push([x, v]);
+    });
+    return out;
+  }
+  /** The fitted coefficients, R² and equation of a trendline (null for moving averages or unfittable data). */
+  trendlineFit(seriesId, index) {
+    const line = _optionalChain([this, 'access', _71 => _71.getSeries, 'call', _72 => _72(seriesId), 'optionalAccess', _73 => _73.trendlines, 'optionalAccess', _74 => _74[index]]);
+    if (!line) return null;
+    return fitChartTrendline(line, this.trendlinePoints(seriesId));
+  }
+  /** The moving-average points of a trendline (empty for other kinds). */
+  trendlineMovingAverage(seriesId, index) {
+    const line = _optionalChain([this, 'access', _75 => _75.getSeries, 'call', _76 => _76(seriesId), 'optionalAccess', _77 => _77.trendlines, 'optionalAccess', _78 => _78[index]]);
+    if (!line || line.type !== "moving-average") return [];
+    return chartMovingAverage(this.trendlinePoints(seriesId), _nullishCoalesce(line.period, () => ( 2)));
+  }
+  // -------------------------------------------------------------------------
+  // Reshaping
+  // -------------------------------------------------------------------------
+  /**
+   * Switches rows and columns: series become categories and categories become series (one
+   * undo step). Series colours, types and other per-series settings are dropped.
+   */
+  transpose() {
+    const s = this.spec;
+    if (!s.series.length || !s.categories.length) return this.reject("There is no data to switch: the chart needs at least one series and one category.");
+    const used = /* @__PURE__ */ new Set();
+    const series = s.categories.map((name, i) => {
+      let id = `series-${i + 1}`;
+      for (let k = i + 2; used.has(id); k++) id = `series-${k}`;
+      used.add(id);
+      return { id, name, values: s.series.map((x) => _nullishCoalesce(x.values[i], () => ( null))) };
+    });
+    const { spec } = _chunkJOX6MJW4cjs.normalizeChartSpec.call(void 0, { ...s, categories: s.series.map((x) => x.name), series });
+    this.commit("Switch rows and columns", spec, null);
+    return { ok: true };
+  }
+  // -------------------------------------------------------------------------
+  // 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 });
+      case "trendline":
+        return this.removeTrendline(sel.seriesId, sel.index);
+      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.gestureStart = { spec: this.spec, mark: this.history.mark() };
+    this.notify(false);
+  }
+  /**
+   * Cancels the gesture in progress (Escape during a drag): everything it changed is taken
+   * back and leaves no undo or redo step.
+   */
+  cancelGesture() {
+    if (this.gestureKey === null) return;
+    const start = this.gestureStart;
+    this.gestureKey = null;
+    this.gestureStart = null;
+    this.history.endGesture();
+    if (start) this.history.revertTo(start.mark);
+    this.notify(false);
+  }
+  endGesture() {
+    if (this.gestureKey === null) return;
+    this.gestureKey = null;
+    this.history.endGesture();
+    const start = this.gestureStart;
+    this.gestureStart = null;
+    if (start && sameChartJson(start.spec, this.spec)) this.history.revertTo(start.mark);
+    this.notify(false);
+  }
+  // -------------------------------------------------------------------------
+  // Persistence and history
+  // -------------------------------------------------------------------------
+  /** The spec, for saving (a copy). */
+  toJSON() {
+    return _chunkJOX6MJW4cjs.cloneChartSpec.call(void 0, 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 } = _chunkJOX6MJW4cjs.normalizeChartSpec.call(void 0, 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', _79 => _79.unsubscribeHistory, 'optionalCall', _80 => _80()]);
+    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",
+    yAxis2: "Change secondary value axis",
+    labelPosition: "Change label position",
+    gapWidth: "Change bar spacing",
+    overlap: "Change bar overlap",
+    bins: "Change histogram bins",
+    showTotal: "Toggle waterfall total",
+    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/sparkline.ts
+var MAX_POINTS = 1e5;
+function layoutSparkline(values, options) {
+  const kind = _nullishCoalesce(options.kind, () => ( "line"));
+  const w = Number.isFinite(options.width) ? Math.max(1, options.width) : 1;
+  const h = Number.isFinite(options.height) ? Math.max(1, options.height) : 1;
+  const color = _nullishCoalesce(options.color, () => ( "#4269d0"));
+  const negative = _nullishCoalesce(options.negativeColor, () => ( "#e5484d"));
+  const theme = { ..._chunkJOX6MJW4cjs.DEFAULT_CHART_THEME, background: "transparent" };
+  const marks = [];
+  const scene = { width: w, height: h, plot: { x: 0, y: 0, width: w, height: h }, marks, percent: false, theme, warnings: [] };
+  const vals = values.slice(0, MAX_POINTS).map((v) => v !== null && Number.isFinite(v) ? Math.max(-1e300, Math.min(1e300, v)) : null);
+  const n = vals.length;
+  if (!n) return scene;
+  const pad = Math.max(0.5, Math.min(2, h * 0.1));
+  const x0 = pad;
+  const y0 = pad;
+  const iw = Math.max(0.5, w - 2 * pad);
+  const ih = Math.max(0.5, h - 2 * pad);
+  let lo = Infinity;
+  let hi = -Infinity;
+  for (const v of vals) if (v !== null) lo = Math.min(lo, v), hi = Math.max(hi, v);
+  if (!Number.isFinite(lo)) return scene;
+  if (options.min !== void 0 && Number.isFinite(options.min)) lo = options.min;
+  if (options.max !== void 0 && Number.isFinite(options.max)) hi = options.max;
+  let hiAt = -1;
+  let loAt = -1;
+  vals.forEach((v, i) => {
+    if (v === null) return;
+    if (hiAt < 0 || v > vals[hiAt]) hiAt = i;
+    if (loAt < 0 || v < vals[loAt]) loAt = i;
+  });
+  if (kind === "line") {
+    const span2 = hi - lo;
+    const fy2 = (v) => y0 + ih - (span2 > 0 ? (v - lo) / span2 : 0.5) * ih;
+    const fx = (j) => n > 1 ? x0 + j / (n - 1) * iw : x0 + iw / 2;
+    let d = "";
+    let run = [];
+    const flush = () => {
+      if (run.length >= 2) {
+        const pts = run.length > 4e3 ? run.filter((_, i) => i % (Math.floor(run.length / 2e3) + 1) === 0) : run;
+        d += pts.map(([x, y], i) => `${i ? "L" : "M"}${r2(x)},${r2(y)}`).join("");
+      }
+      run = [];
+    };
+    vals.forEach((v, j) => v === null ? flush() : run.push([fx(j), fy2(v)]));
+    flush();
+    if (d) marks.push({ kind: "path", key: "sparkline", role: "line", d, fill: "none", stroke: color, strokeWidth: 1.25 });
+    const r = Math.max(1, Math.min(3, h * 0.08));
+    if (options.markers || n === 1) {
+      const step = Math.max(1, Math.floor(n / 500));
+      vals.forEach((v, j) => {
+        if (v !== null && j % step === 0) marks.push({ kind: "circle", key: `point-${j}`, role: "point", cx: fx(j), cy: fy2(v), r, fill: color });
+      });
+    }
+    if (options.highLow && n > 1) {
+      if (hiAt >= 0) marks.push({ kind: "circle", key: "high", role: "point", cx: fx(hiAt), cy: fy2(vals[hiAt]), r: r + 0.5, fill: color });
+      if (loAt >= 0 && loAt !== hiAt) marks.push({ kind: "circle", key: "low", role: "point", cx: fx(loAt), cy: fy2(vals[loAt]), r: r + 0.5, fill: negative });
+    }
+    return scene;
+  }
+  const slot = iw / n;
+  const bw = Math.max(0.25, slot * 0.8);
+  const win = kind === "win-loss";
+  const lo0 = win ? -1 : Math.min(lo, 0);
+  const hi0 = win ? 1 : Math.max(hi, 0);
+  const span = hi0 - lo0;
+  const fy = (v) => span > 0 ? y0 + ih - (v - lo0) / span * ih : y0 + ih;
+  const base = fy(0);
+  vals.forEach((raw, j) => {
+    if (raw === null) return;
+    const v = win ? Math.sign(raw) : raw;
+    if (win && v === 0) return;
+    const top = fy(v);
+    const highlight = options.highLow && !win && (j === hiAt || j === loAt);
+    marks.push({ kind: "rect", key: `bar-${j}`, role: "bar", x: x0 + j * slot + (slot - bw) / 2, y: Math.min(top, base), width: bw, height: Math.max(0.5, Math.abs(top - base)), fill: v < 0 ? negative : color, opacity: options.highLow && !win && !highlight ? 0.6 : void 0 });
+  });
+  return scene;
+}
+function sparklineToSvg(values, options) {
+  return chartSceneToSvg(layoutSparkline(values, options), { ariaLabel: options.ariaLabel });
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.CHART_MERMAID_META_PREFIX = CHART_MERMAID_META_PREFIX; exports.chartMermaidFamily = chartMermaidFamily; exports.chartToMermaid = chartToMermaid; exports.chartFromMermaid = chartFromMermaid; exports.findMermaidCharts = findMermaidCharts; exports.parseChartDate = parseChartDate; exports.CHART_DATE_STEPS = CHART_DATE_STEPS; exports.formatChartDate = formatChartDate; exports.chartDateLabels = chartDateLabels; exports.compileChartFormatCode = compileChartFormatCode; exports.formatChartValueWithCode = formatChartValueWithCode; exports.chartSerialToDate = chartSerialToDate; exports.chartDateToSerial = chartDateToSerial; exports.niceStep = niceStep; exports.niceScale = niceScale; exports.stepDecimals = stepDecimals; exports.formatChartNumber = formatChartNumber; exports.linearMap = linearMap; exports.estimateChartTextWidth = estimateChartTextWidth; exports.sameChartSelection = sameChartSelection; exports.contrastingTextColor = contrastingTextColor; exports.chartHistogram = chartHistogram; exports.chartQuantile = chartQuantile; exports.chartBoxStats = chartBoxStats; exports.chartSquarify = chartSquarify; exports.decimateChartPoints = decimateChartPoints; exports.summarizeChartSeries = summarizeChartSeries; exports.fitChartTrendline = fitChartTrendline; exports.trendNumberText = trendNumberText; exports.chartMovingAverage = chartMovingAverage; exports.chartTrendlineName = chartTrendlineName; exports.chartSupportsTrendlines = chartSupportsTrendlines; exports.MAX_CHART_DATA_LABELS = MAX_CHART_DATA_LABELS; exports.MAX_CHART_LINE_POINTS = MAX_CHART_LINE_POINTS; exports.MAX_CHART_MARKERS = MAX_CHART_MARKERS; exports.layoutChart = layoutChart; exports.chartValueAtPoint = chartValueAtPoint; exports.chartXAtPoint = chartXAtPoint; exports.snapChartValue = snapChartValue; exports.summarizeChart = summarizeChart; exports.describeChart = describeChart; exports.chartTextBaseline = chartTextBaseline; exports.chartTextTransform = chartTextTransform; exports.chartSceneToSvg = chartSceneToSvg; exports.chartToSvg = chartToSvg; exports.chartSceneToDomSpec = chartSceneToDomSpec; exports.CHART_LAYOUT_PRESETS = CHART_LAYOUT_PRESETS; exports.monochromeChartPalette = monochromeChartPalette; exports.CHART_COLOR_SCHEMES = CHART_COLOR_SCHEMES; exports.chartPresetPatch = chartPresetPatch; exports.ChartController = ChartController; exports.createChartController = createChartController; exports.layoutSparkline = layoutSparkline; exports.sparklineToSvg = sparklineToSvg;
+//# sourceMappingURL=chunk-GTZXF4BI.cjs.map