@pixerate/editor 0.162.0 → 0.163.0

package/dist/{chunk-7CKPUUN4.js → chunk-POR54B55.js}

@@ -2,11 +2,13 @@ import {
   chartFamily,
   chartRgbToHex,
   chartSeriesType,
+  chartTreeFromRows,
+  chartVariesColors,
   defaultChartAxis,
   isCartesianChart,
   normalizeChartSpec,
   parseChartColor
-} from "./chunk-HLOKB7WW.js";
+} from "./chunk-3NEZJCBY.js";
 
 // src/chart/ooxml.ts
 var CHART_OOXML_NS = "http://schemas.openxmlformats.org/drawingml/2006/chart";
@@ -295,7 +297,7 @@ function chartFromOoxml(xml, options = {}) {
   input.orientation = orientation;
   input.dataLabels = dataLabels;
   input.points = points || first !== "line";
-  if (bool(val(groups[0], "varyColors")) && (first === "bar" || first === "line") && series.length === 1) unsupported.push("one colour per point (vary colours)");
+  if (bool(val(groups[0], "varyColors")) && !combo && isCartesianChart(first) && series.length === 1) input.varyColors = true;
   const readAxis = (a, fallback) => {
     const axis = { ...fallback, format: {} };
     if (!a) return axis;
@@ -340,6 +342,29 @@ function readChartex(root, issues, unsupported) {
     const numDim = kids(d, "numDim")[0];
     const lvl = (dim) => kids(dim, "lvl")[0];
     const cats = kids(lvl(strDim), "pt").map((p) => p.textContent ?? "");
+    const levels = kids(strDim, "lvl").map((l) => {
+      const out = [];
+      for (const p of kids(l, "pt")) out[Number(p.getAttribute("idx") ?? out.length)] = (p.textContent ?? "").trim();
+      return out;
+    });
+    let paths;
+    if (levels.length > 1) {
+      const carried = [];
+      paths = levels[0].map((_, i) => {
+        const path2 = [];
+        for (let k = levels.length - 1; k >= 1; k--) {
+          const name = levels[k][i];
+          if (name) {
+            carried[k] = name;
+            carried.length = Math.max(carried.length, k + 1);
+            for (let j = 1; j < k; j++) carried[j] = "";
+          }
+          if (carried[k]) path2.push(carried[k]);
+        }
+        if (levels[0][i]) path2.push(levels[0][i]);
+        return path2;
+      });
+    }
     const values = [];
     const nl = lvl(numDim);
     for (const p of kids(nl, "pt")) {
@@ -347,19 +372,18 @@ function readChartex(root, issues, unsupported) {
       while (values.length < i) values.push(null);
       values[i] = numberOf((p.textContent ?? "").trim());
     }
-    data.set(id, { categories: cats, values, code: nl?.getAttribute("formatCode") ?? void 0 });
+    data.set(id, { categories: cats, values, code: nl?.getAttribute("formatCode") ?? void 0, paths });
   }
   const chart = kid(root, "chart");
   const region = path(chart, "plotArea", "plotAreaRegion");
   const seriesEls = kids(region, "series");
-  const layouts = { waterfall: "waterfall", funnel: "funnel", treemap: "treemap", sunburst: "treemap", boxWhisker: "box", clusteredColumn: "histogram", paretoLine: "histogram" };
+  const layouts = { waterfall: "waterfall", funnel: "funnel", treemap: "treemap", sunburst: "sunburst", boxWhisker: "box", clusteredColumn: "histogram", paretoLine: "histogram" };
   const layout = seriesEls[0]?.getAttribute("layoutId") ?? "";
   const type = layouts[layout];
   if (!type) {
     issues.push({ path: "plotArea", message: `The chart layout "${layout || "unknown"}" is not supported.` });
     return { spec: normalizeChartSpec({}).spec, issues, unsupported: [layout || "unknown chartex layout"], lossless: false };
   }
-  if (layout === "sunburst") unsupported.push("sunburst (drawn as a treemap of the innermost level)");
   if (layout === "paretoLine") unsupported.push("pareto line");
   const series = [];
   let categories = [];
@@ -382,6 +406,12 @@ function readChartex(root, issues, unsupported) {
     categories: categories.length >= longest ? categories : Array.from({ length: longest }, (_, i) => categories[i] ?? `${i + 1}`)
   };
   if (type === "waterfall") input.showTotal = false;
+  const first = data.get(kid(seriesEls[0], "dataId")?.getAttribute("val") ?? "0");
+  if ((type === "treemap" || type === "sunburst") && first?.paths) {
+    const treeIssues = [];
+    input.tree = chartTreeFromRows(first.paths.map((path2, i) => ({ path: path2, value: first.values[i] ?? 0 })), treeIssues);
+    for (const t of treeIssues) issues.push({ path: "chartData", message: t.message });
+  }
   const { spec, issues: specIssues } = normalizeChartSpec(input);
   issues.push(...specIssues);
   return { spec, issues, unsupported, lossless: unsupported.length === 0 && specIssues.length === 0 };
@@ -440,10 +470,30 @@ function chartToOoxml(spec) {
     issues.push(`${spec.type} charts are written as bar charts: DrawingML has no ${spec.type} type (Office 2016 stores it as chartex).`);
     type = "bar";
   } else if (family === "treemap") {
-    issues.push("Treemaps are written as pie charts: DrawingML has no treemap type.");
+    issues.push(`Treemaps are written as pie charts${spec.tree.length ? " of the top-level group totals" : ""}: DrawingML has no treemap type.`);
     type = "pie";
+  } else if (family === "sunburst") {
+    issues.push(`Sunburst charts are written as doughnut charts of the ${spec.tree.length ? "top-level group totals" : "values"}: DrawingML has no sunburst type (Office 2016 stores it as chartex).`);
+    type = "donut";
+  } else if (family === "parliament") {
+    issues.push("Parliament charts are written as doughnut charts of the seats: DrawingML has no parliament type.");
+    type = "donut";
+  } else if (family === "slope") {
+    issues.push("Slope charts are written as line charts with the two series as lines over the categories: DrawingML has no slope type.");
+    type = "line";
+  } else if (family === "likert") {
+    issues.push("Likert charts are written as 100% stacked horizontal bars: DrawingML has no diverging bar.");
+    spec = { ...spec, type: "bar", stacking: "percent", orientation: "horizontal" };
+    type = "bar";
   }
   const visible = spec.series.filter((s) => !s.hidden);
+  const annotations = [
+    spec.referenceLines.length || spec.referenceBands.length ? "reference lines and bands" : "",
+    spec.series.some((s) => s.callouts) ? "callouts" : "",
+    spec.highlight.length ? "the highlight" : "",
+    spec.note ? "the note" : ""
+  ].filter(Boolean);
+  if (annotations.length) issues.push(`${annotations.join(", ").replace(/^./, (c) => c.toUpperCase())} ${annotations.length === 1 && !annotations[0].endsWith("s") ? "is" : "are"} not written: DrawingML has no equivalent.`);
   if (visible.length < spec.series.length) issues.push(`${spec.series.length - visible.length} hidden series ${spec.series.length - visible.length === 1 ? "is" : "are"} left out.`);
   const grouping = spec.stacking === "stacked" ? "stacked" : spec.stacking === "percent" ? "percentStacked" : "standard";
   const ids = { cat: 500000001, val: 500000002, cat2: 500000003, val2: 500000004 };
@@ -512,6 +562,7 @@ function chartToOoxml(spec) {
     return `<c:ser>${parts.join("")}</c:ser>`;
   };
   const dLbls = `<c:dLbls><c:showLegendKey val="0"/><c:showVal val="${spec.dataLabels ? 1 : 0}"/><c:showCatName val="0"/><c:showSerName val="0"/><c:showPercent val="0"/><c:showBubbleSize val="0"/></c:dLbls>`;
+  const vary = chartVariesColors(spec) ? 1 : 0;
   const groupXml = groups.map((g) => {
     const axes2 = g.secondary ? `<c:axId val="${ids.cat2}"/><c:axId val="${ids.val2}"/>` : `<c:axId val="${ids.cat}"/><c:axId val="${ids.val}"/>`;
     const sers = g.series.map(({ s, index }) => serXml(g.kind, s, index)).join("");
@@ -521,14 +572,14 @@ function chartToOoxml(spec) {
         const barsWidth = spec.stacking === "none" ? n - (n - 1) * spec.overlap : 1;
         const gapPct = Math.round(Math.min(500, spec.gapWidth / Math.max(0.01, 1 - spec.gapWidth) * barsWidth * 100));
         const overlapPct = spec.stacking === "none" ? Math.round(spec.overlap * 100) : 100;
-        return `<c:barChart><c:barDir val="${spec.orientation === "horizontal" ? "bar" : "col"}"/><c:grouping val="${spec.stacking === "none" ? "clustered" : grouping}"/><c:varyColors val="0"/>${sers}${dLbls}<c:gapWidth val="${gapPct}"/><c:overlap val="${overlapPct}"/>${axes2}</c:barChart>`;
+        return `<c:barChart><c:barDir val="${spec.orientation === "horizontal" ? "bar" : "col"}"/><c:grouping val="${spec.stacking === "none" ? "clustered" : grouping}"/><c:varyColors val="${vary}"/>${sers}${dLbls}<c:gapWidth val="${gapPct}"/><c:overlap val="${overlapPct}"/>${axes2}</c:barChart>`;
       }
       case "line":
-        return `<c:lineChart><c:grouping val="${spec.stacking === "none" ? "standard" : "standard"}"/><c:varyColors val="0"/>${sers}${dLbls}<c:marker val="1"/>${axes2}</c:lineChart>`;
+        return `<c:lineChart><c:grouping val="${spec.stacking === "none" ? "standard" : "standard"}"/><c:varyColors val="${vary}"/>${sers}${dLbls}<c:marker val="1"/>${axes2}</c:lineChart>`;
       case "area":
-        return `<c:areaChart><c:grouping val="${grouping}"/><c:varyColors val="0"/>${sers}${dLbls}${axes2}</c:areaChart>`;
+        return `<c:areaChart><c:grouping val="${grouping}"/><c:varyColors val="${vary}"/>${sers}${dLbls}${axes2}</c:areaChart>`;
       case "scatter":
-        return `<c:scatterChart><c:scatterStyle val="lineMarker"/><c:varyColors val="0"/>${sers}${dLbls}${axes2}</c:scatterChart>`;
+        return `<c:scatterChart><c:scatterStyle val="lineMarker"/><c:varyColors val="${vary}"/>${sers}${dLbls}${axes2}</c:scatterChart>`;
       case "bubble":
         return `<c:bubbleChart><c:varyColors val="0"/>${sers}${dLbls}<c:bubbleScale val="100"/>${axes2}</c:bubbleChart>`;
       case "radar":

package/dist/{chunk-KGTF55R3.js → chunk-QY4KUDMY.js}

@@ -18,7 +18,7 @@ import {
   unionBounds,
   vectorGradientPoints,
   widthProfileAt
-} from "./chunk-2TKHLX6H.js";
+} from "./chunk-SET6KJOP.js";
 import {
   segmentLength,
   segmentParamAtLength,

package/dist/{chunk-LL3H5XUH.cjs → chunk-R3P2M7HU.cjs}

@@ -224,7 +224,7 @@ function parseChartAmountList(text2) {
 }
 
 // src/chart/spec.ts
-var CHART_TYPES = ["bar", "line", "area", "scatter", "bubble", "pie", "donut", "radar", "waterfall", "histogram", "box", "funnel", "treemap"];
+var CHART_TYPES = ["bar", "line", "area", "scatter", "bubble", "pie", "donut", "radar", "waterfall", "histogram", "box", "funnel", "treemap", "sunburst", "slope", "likert", "parliament"];
 var CHART_MARKERS = ["circle", "square", "diamond", "triangle", "cross", "none"];
 var CHART_TRENDLINE_TYPES = ["linear", "exponential", "logarithmic", "power", "polynomial", "moving-average"];
 var CHART_LABEL_POSITIONS = ["auto", "inside", "outside", "center"];
@@ -234,6 +234,9 @@ var CHART_SERIES_TYPES = ["bar", "line", "area", "scatter"];
 var CHART_STACKINGS = ["none", "stacked", "percent"];
 var CHART_CURVES = ["linear", "smooth", "step"];
 var CHART_RADAR_GRATICULES = ["polygon", "circle"];
+var CHART_LIKERT_NEUTRALS = ["split", "separate"];
+var CHART_LIKERT_SORTS = ["none", "positive", "negative"];
+var CHART_REFERENCE_AXES = ["y", "y2", "x"];
 var CHART_ORIENTATIONS = ["vertical", "horizontal"];
 var CHART_LEGEND_POSITIONS = ["top", "bottom", "left", "right"];
 var CHART_NUMBER_STYLES = ["number", "percent", "currency", "compact"];
@@ -250,7 +253,11 @@ var CHART_TYPE_LABELS = {
   histogram: "Histogram",
   box: "Box plot",
   funnel: "Funnel",
-  treemap: "Treemap"
+  treemap: "Treemap",
+  slope: "Slope",
+  likert: "Likert",
+  parliament: "Parliament",
+  sunburst: "Sunburst"
 };
 var DEFAULT_CHART_PALETTE = ["#4269d0", "#efb118", "#ff725c", "#6cc5b0", "#3ca951", "#ff8ab7", "#a463f2", "#97bbf5", "#9c6b4e", "#9498a0"];
 var DEFAULT_CHART_THEME = {
@@ -297,6 +304,10 @@ function chartFamily(spec) {
     case "box":
     case "funnel":
     case "treemap":
+    case "slope":
+    case "likert":
+    case "parliament":
+    case "sunburst":
       return spec.type;
     case "bubble":
       return "xy";
@@ -305,7 +316,10 @@ function chartFamily(spec) {
   }
 }
 function chartColorsByCategory(type) {
-  return type === "pie" || type === "donut" || type === "funnel" || type === "treemap";
+  return type === "pie" || type === "donut" || type === "funnel" || type === "treemap" || type === "slope" || type === "parliament" || type === "sunburst";
+}
+function chartSpecColorsByCategory(spec) {
+  return chartColorsByCategory(spec.type) || chartVariesColors(spec);
 }
 function defaultChartAxis(value) {
   return { show: true, title: "", min: null, max: null, step: null, gridlines: value, format: {} };
@@ -316,17 +330,37 @@ function createChartSpec(partial = {}) {
 function chartSeriesColor(spec, seriesIndex) {
   const series = spec.series[seriesIndex];
   if (_optionalChain([series, 'optionalAccess', _10 => _10.color])) return series.color;
+  if (spec.type === "likert") return chartLikertColor(spec.series.length, seriesIndex);
   return cyclePaletteColor(spec.palette.length ? spec.palette : DEFAULT_CHART_PALETTE, seriesIndex);
 }
+var LIKERT_NEGATIVE = [["#e66101"], ["#e66101", "#fdb863"], ["#b35806", "#f1a340", "#fee0b6"], ["#b35806", "#e08214", "#fdb863", "#fee0b6"]];
+var LIKERT_POSITIVE = [["#5e3c99"], ["#b2abd2", "#5e3c99"], ["#d8daeb", "#998ec3", "#542788"], ["#d8daeb", "#b2abd2", "#8073ac", "#542788"]];
+var LIKERT_NEUTRAL = "#d4d4d8";
+function chartLikertColor(count, index) {
+  const side = Math.floor(count / 2);
+  if (count % 2 === 1 && index === side) return LIKERT_NEUTRAL;
+  if (!side) return LIKERT_POSITIVE[0][0];
+  const ramp = (sets) => sets[Math.min(side, sets.length) - 1];
+  const pick2 = (list, k) => list[Math.min(list.length - 1, Math.floor(k * list.length / side))];
+  if (index < side) return pick2(ramp(LIKERT_NEGATIVE), index);
+  return pick2(ramp(LIKERT_POSITIVE), index - (count - side));
+}
 function chartSliceColor(spec, index) {
   return cyclePaletteColor(spec.palette.length ? spec.palette : DEFAULT_CHART_PALETTE, index);
 }
+function chartVariesColors(spec) {
+  return !!spec.varyColors && isCartesianChart(spec.type) && spec.series.filter((s) => !s.hidden).length === 1;
+}
 function chartPointColor(spec, seriesIndex, index) {
-  return _optionalChain([spec, 'access', _11 => _11.series, 'access', _12 => _12[seriesIndex], 'optionalAccess', _13 => _13.pointColors, 'optionalAccess', _14 => _14[index]]) || chartSeriesColor(spec, seriesIndex);
+  const own = _optionalChain([spec, 'access', _11 => _11.series, 'access', _12 => _12[seriesIndex], 'optionalAccess', _13 => _13.pointColors, 'optionalAccess', _14 => _14[index]]);
+  if (own) return own;
+  if (spec.type && chartVariesColors(spec)) return chartSliceColor(spec, index);
+  return chartSeriesColor(spec, seriesIndex);
 }
 function chartSeriesType(spec, series) {
   if (series.type) return series.type;
   if (spec.type === "bubble") return "scatter";
+  if (spec.type === "slope") return "line";
   return isCartesianChart(spec.type) ? spec.type : "bar";
 }
 function uniqueChartSeriesId(series, base = "series") {
@@ -524,6 +558,16 @@ function normalizeSeries(value, length, used, index, issues) {
       if (colors.some((c) => c !== null)) series.pointColors = colors;
     }
   }
+  if (value.callouts !== void 0 && value.callouts !== null) {
+    if (!Array.isArray(value.callouts)) issues.push({ path: `${path}.callouts`, message: `${path}.callouts must be an array of labels or nulls, one per category.` });
+    else {
+      const labels = Array.from({ length }, (_, i) => {
+        const c = value.callouts[i];
+        return typeof c === "string" && c.trim() ? c : typeof c === "number" ? String(c) : null;
+      });
+      if (labels.some((c) => c !== null)) series.callouts = labels;
+    }
+  }
   if (value.marker !== void 0 && value.marker !== null) series.marker = pick(value.marker, CHART_MARKERS, "circle", `${path}.marker`, issues);
   if (value.curve !== void 0 && value.curve !== null) series.curve = pick(value.curve, CHART_CURVES, "linear", `${path}.curve`, issues);
   if (value.dataLabels !== void 0 && value.dataLabels !== null) series.dataLabels = flag(value.dataLabels, false, `${path}.dataLabels`, issues);
@@ -546,6 +590,49 @@ function normalizeSeries(value, length, used, index, issues) {
   return series;
 }
 var key = (value, name) => value[name] !== void 0 && value[name] !== null;
+function referenceCommon(value, path, issues) {
+  const out = {};
+  const label = text(value.label, "", `${path}.label`, issues);
+  if (label) out.label = label;
+  if (key(value, "axis")) {
+    const axis = pick(value.axis, CHART_REFERENCE_AXES, "y", `${path}.axis`, issues);
+    if (axis !== "y") out.axis = axis;
+  }
+  if (typeof value.color === "string" && value.color.trim()) out.color = value.color.trim();
+  else if (key(value, "color")) issues.push({ path: `${path}.color`, message: `${path}.color must be a CSS colour.` });
+  return out;
+}
+var finiteNumber = (value) => {
+  const n = typeof value === "string" && value.trim() ? Number(value) : value;
+  return typeof n === "number" && Number.isFinite(n) ? n : null;
+};
+function normalizeChartReferenceLine(value, path, issues = []) {
+  if (!isRecord(value)) {
+    issues.push({ path, message: `${path} must be an object with a value, e.g. {"value": 100, "label": "Target"}.` });
+    return null;
+  }
+  const at = finiteNumber(value.value);
+  if (at === null) {
+    issues.push({ path: `${path}.value`, message: `${path}.value must be a number (where the line crosses the axis).` });
+    return null;
+  }
+  for (const k of Object.keys(value)) if (!["value", "label", "axis", "color"].includes(k)) issues.push({ path: `${path}.${k}`, message: `${path} has no "${k}"; it takes value, label, axis and color.` });
+  return { value: at, ...referenceCommon(value, path, issues) };
+}
+function normalizeChartReferenceBand(value, path, issues = []) {
+  if (!isRecord(value)) {
+    issues.push({ path, message: `${path} must be an object with from and to, e.g. {"from": 80, "to": 120, "label": "Target range"}.` });
+    return null;
+  }
+  const from = finiteNumber(value.from);
+  const to = finiteNumber(value.to);
+  if (from === null || to === null) {
+    issues.push({ path, message: `${path} needs numbers for from and to (the ends of the band on its axis).` });
+    return null;
+  }
+  for (const k of Object.keys(value)) if (!["from", "to", "label", "axis", "color"].includes(k)) issues.push({ path: `${path}.${k}`, message: `${path} has no "${k}"; it takes from, to, label, axis and color.` });
+  return { from: Math.min(from, to), to: Math.max(from, to), ...referenceCommon(value, path, issues) };
+}
 function normalizeChartErrorBars(value, length, path, issues = []) {
   if (!isRecord(value)) {
     issues.push({ path, message: `${path} must be an object with a type (${CHART_ERROR_BAR_TYPES.join(", ")}), or null for none.` });
@@ -631,8 +718,14 @@ function normalizeChartSpec(input) {
     const longest = rawSeries.reduce((n, s) => Math.max(n, isRecord(s) && Array.isArray(s.values) ? s.values.length : 0), 0);
     categories = Array.from({ length: longest }, (_, i) => `${i + 1}`);
   }
+  const tree = normalizeChartTree(value.tree, issues);
+  if (tree.length) categories = tree.map((n) => n.name);
   const used = /* @__PURE__ */ new Set();
   const series = rawSeries.map((s, i) => normalizeSeries(s, categories.length, used, i, issues)).filter((s) => s !== null);
+  if (tree.length) {
+    if (!series.length) series.push({ id: uniqueChartSeriesId(series), name: "Values", values: [] });
+    series[0] = { ...series[0], values: tree.map(chartTreeTotal) };
+  }
   let palette = [...DEFAULT_CHART_PALETTE];
   if (Array.isArray(value.palette)) {
     const colors = value.palette.filter((c) => typeof c === "string" && c.trim() !== "");
@@ -655,6 +748,32 @@ function normalizeChartSpec(input) {
     if (Number.isInteger(b) && b >= 1 && b <= 500) bins = b;
     else issues.push({ path: "bins", message: "bins must be a whole number from 1 to 500, or null for automatic." });
   }
+  const highlight = [];
+  if (Array.isArray(value.highlight)) {
+    for (const h of value.highlight) {
+      if (typeof h === "string" || typeof h === "number") {
+        const name = String(h);
+        if (!highlight.includes(name)) highlight.push(name);
+      } else issues.push({ path: "highlight", message: "highlight must list category labels or series names." });
+    }
+  } else if (value.highlight !== void 0 && value.highlight !== null) issues.push({ path: "highlight", message: "highlight must be an array of category labels or series names." });
+  const listOf = (name, read) => {
+    const raw = value[name];
+    if (raw === void 0 || raw === null) return [];
+    if (!Array.isArray(raw)) {
+      issues.push({ path: name, message: `${name} must be an array.` });
+      return [];
+    }
+    return raw.map((item, i) => read(item, `${name}[${i}]`, issues)).filter((x) => x !== null);
+  };
+  const referenceLines = listOf("referenceLines", normalizeChartReferenceLine);
+  const referenceBands = listOf("referenceBands", normalizeChartReferenceBand);
+  let parliamentMajority = null;
+  if (value.parliamentMajority !== void 0 && value.parliamentMajority !== null) {
+    const m = Number(value.parliamentMajority);
+    if (Number.isInteger(m) && m >= 1) parliamentMajority = m;
+    else issues.push({ path: "parliamentMajority", message: "parliamentMajority must be a whole number of seats, 1 or more, or null for half plus one." });
+  }
   let radarTicks = null;
   if (value.radarTicks !== void 0 && value.radarTicks !== null) {
     const t = Number(value.radarTicks);
@@ -685,7 +804,19 @@ function normalizeChartSpec(input) {
     bins,
     showTotal: flag(value.showTotal, true, "showTotal", issues),
     radarTicks,
-    radarGraticule: pick(value.radarGraticule, CHART_RADAR_GRATICULES, "polygon", "radarGraticule", issues)
+    radarGraticule: pick(value.radarGraticule, CHART_RADAR_GRATICULES, "polygon", "radarGraticule", issues),
+    note: text(value.note, "", "note", issues),
+    highlight,
+    referenceLines,
+    referenceBands,
+    varyColors: flag(value.varyColors, false, "varyColors", issues),
+    likertNeutral: pick(value.likertNeutral, CHART_LIKERT_NEUTRALS, "split", "likertNeutral", issues),
+    likertSort: pick(value.likertSort, CHART_LIKERT_SORTS, "none", "likertSort", issues),
+    parliamentArc: fraction("parliamentArc", 180, 90, 360),
+    parliamentMajority,
+    parliamentLabel: text(value.parliamentLabel, "", "parliamentLabel", issues),
+    tree,
+    sunburstLabel: text(value.sunburstLabel, "", "sunburstLabel", issues)
   };
   if (spec.stacking === "percent")
     for (const name of ["yAxis", "yAxis2"]) {
@@ -705,7 +836,11 @@ function cloneChartSpec(spec) {
     yAxis: { ...spec.yAxis, format: { ...spec.yAxis.format } },
     yAxis2: { ...spec.yAxis2, format: { ...spec.yAxis2.format } },
     legend: { ...spec.legend },
-    palette: [...spec.palette]
+    palette: [...spec.palette],
+    highlight: [...spec.highlight],
+    referenceLines: spec.referenceLines.map((l) => ({ ...l })),
+    referenceBands: spec.referenceBands.map((b) => ({ ...b })),
+    tree: cloneChartTree(spec.tree)
   };
 }
 function cloneChartSeries(series) {
@@ -713,6 +848,7 @@ function cloneChartSeries(series) {
   if (series.x) copy.x = [...series.x];
   if (series.sizes) copy.sizes = [...series.sizes];
   if (series.pointColors) copy.pointColors = [...series.pointColors];
+  if (series.callouts) copy.callouts = [...series.callouts];
   if (series.format) copy.format = { ...series.format };
   if (series.trendlines) copy.trendlines = series.trendlines.map((t) => ({ ...t }));
   for (const name of ["errorBars", "xErrorBars"]) {
@@ -773,6 +909,230 @@ function chartColorInputValue(color) {
   return "#000000";
 }
 
+// src/chart/tree.ts
+var MAX_CHART_TREE_DEPTH = 6;
+var MAX_CHART_TREE_NODES = 5e3;
+var isRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+function normalizeChartTree(value, issues = [], path = "tree") {
+  if (value === void 0 || value === null) return [];
+  if (!Array.isArray(value)) {
+    issues.push({ path, message: `${path} must be an array of nodes such as {"name": "Europe", "children": [{"name": "France", "value": 40}]}.` });
+    return [];
+  }
+  let count = 0;
+  const read = (list, at, depth) => {
+    const out = [];
+    const names = /* @__PURE__ */ new Set();
+    list.forEach((raw, i) => {
+      const where = `${at}[${i}]`;
+      if (!isRecord2(raw)) {
+        issues.push({ path: where, message: `${where} must be an object with a name and a value or children.` });
+        return;
+      }
+      const name = typeof raw.name === "number" ? String(raw.name) : typeof raw.name === "string" ? raw.name.trim() : "";
+      if (!name) {
+        issues.push({ path: `${where}.name`, message: `${where} needs a name.` });
+        return;
+      }
+      if (names.has(name)) {
+        issues.push({ path: `${where}.name`, message: `"${name}" appears twice under the same group in ${at}; sibling names must be unique, so the second was left out.` });
+        return;
+      }
+      if (++count > MAX_CHART_TREE_NODES) {
+        if (count === MAX_CHART_TREE_NODES + 1) issues.push({ path, message: `The tree has more than ${MAX_CHART_TREE_NODES} nodes; the rest were left out.` });
+        return;
+      }
+      names.add(name);
+      for (const k of Object.keys(raw)) if (!["name", "value", "children", "color"].includes(k)) issues.push({ path: `${where}.${k}`, message: `${where} has no "${k}"; a node takes name, value, children and color.` });
+      const node = { name };
+      if (typeof raw.color === "string" && raw.color.trim()) node.color = raw.color.trim();
+      if (Array.isArray(raw.children) && raw.children.length) {
+        if (depth >= MAX_CHART_TREE_DEPTH) {
+          issues.push({ path: `${where}.children`, message: `${where} is more than ${MAX_CHART_TREE_DEPTH} levels deep; its children were left out.` });
+          node.value = 0;
+        } else {
+          if (raw.value !== void 0 && raw.value !== null) issues.push({ path: `${where}.value`, message: `"${name}" is a group: its value is the sum of its children, so the value given was ignored.` });
+          const children = read(raw.children, `${where}.children`, depth + 1);
+          if (children.length) node.children = children;
+          else node.value = 0;
+        }
+      } else {
+        if (raw.children !== void 0 && raw.children !== null && !Array.isArray(raw.children)) issues.push({ path: `${where}.children`, message: `${where}.children must be an array of nodes.` });
+        const v = parseChartValue(raw.value);
+        if (raw.value === void 0 || raw.value === null) node.value = 0;
+        else if (typeof v === "number" && v >= 0) node.value = v;
+        else {
+          issues.push({ path: `${where}.value`, message: `"${name}" needs a value of 0 or more; got ${JSON.stringify(raw.value)}.` });
+          node.value = 0;
+        }
+      }
+      out.push(node);
+    });
+    return out;
+  };
+  return read(value, path, 1);
+}
+function chartTreeTotal(node) {
+  return node.children ? node.children.reduce((t, c) => t + chartTreeTotal(c), 0) : _nullishCoalesce(node.value, () => ( 0));
+}
+function chartTreeDepth(tree) {
+  return tree.reduce((d, n) => Math.max(d, 1 + (n.children ? chartTreeDepth(n.children) : 0)), 0);
+}
+function findChartTreeNode(tree, path) {
+  let list = tree;
+  let node;
+  for (const name of path) {
+    node = _optionalChain([list, 'optionalAccess', _18 => _18.find, 'call', _19 => _19((n) => n.name === name)]);
+    if (!node) return void 0;
+    list = node.children;
+  }
+  return node;
+}
+function chartTreeToRows(tree) {
+  const out = [];
+  const walk = (list, prefix) => {
+    for (const n of list) {
+      if (n.children) walk(n.children, [...prefix, n.name]);
+      else out.push({ path: [...prefix, n.name], value: _nullishCoalesce(n.value, () => ( 0)) });
+    }
+  };
+  walk(tree, []);
+  return out;
+}
+function chartTreeFromRows(rows, issues = []) {
+  const tree = [];
+  rows.forEach((row, r) => {
+    const path = [];
+    for (const cell of row.path) {
+      const name = cell === null || cell === void 0 ? "" : String(cell).trim();
+      if (!name) break;
+      path.push(name);
+    }
+    if (!path.length) return;
+    if (path.length > MAX_CHART_TREE_DEPTH) {
+      issues.push({ path: `rows[${r}]`, message: `Row ${r + 1} is ${path.length} levels deep; the tree keeps at most ${MAX_CHART_TREE_DEPTH}, so the row was left out.` });
+      return;
+    }
+    const v = parseChartValue(row.value);
+    if (row.value !== null && row.value !== void 0 && String(row.value).trim() !== "" && !(typeof v === "number" && v >= 0)) {
+      issues.push({ path: `rows[${r}]`, message: `Row ${r + 1} (${path.join(" / ")}) needs a value of 0 or more; got ${JSON.stringify(row.value)}. It was counted as 0.` });
+    }
+    const value = typeof v === "number" && v >= 0 ? v : 0;
+    let list = tree;
+    for (let k = 0; k < path.length; k++) {
+      const last = k === path.length - 1;
+      let node = list.find((n) => n.name === path[k]);
+      if (!node) {
+        node = last ? { name: path[k], value } : { name: path[k], children: [] };
+        list.push(node);
+        if (last) return;
+      } else if (last) {
+        issues.push({ path: `rows[${r}]`, message: `Row ${r + 1} (${path.join(" / ")}) ${node.children ? "names a group that already has items" : "repeats an earlier row"}; it was left out.` });
+        return;
+      } else if (!node.children) {
+        issues.push({ path: `rows[${r}]`, message: `Row ${r + 1} puts items under "${path.slice(0, k + 1).join(" / ")}", which an earlier row made an item with its own value; it was left out.` });
+        return;
+      }
+      list = node.children;
+    }
+  });
+  return tree;
+}
+function chartTreeFromTable(rows, options = {}, issues = []) {
+  const grid = rows.filter((r) => r.some((c) => c !== null && c !== void 0 && String(c).trim() !== ""));
+  if (!grid.length) return [];
+  const width = Math.max(...grid.map((r) => r.length));
+  if (width < 2) {
+    issues.push({ path: "rows", message: "A tree table needs at least two columns: names, then values." });
+    return [];
+  }
+  const header = _nullishCoalesce(options.header, () => ( "auto"));
+  const skip = header === true || header === "auto" && typeof parseChartValue(grid[0][width - 1]) !== "number";
+  const body = skip ? grid.slice(1) : grid;
+  let above = [];
+  return chartTreeFromRows(
+    body.map((r) => {
+      const cells = Array.from({ length: width - 1 }, (_, k) => r[k] === null || r[k] === void 0 ? "" : String(r[k]).trim());
+      const first = cells.findIndex((c) => c !== "");
+      if (first < 0) return { path: [], value: r[width - 1] };
+      const own = [];
+      for (const c of cells.slice(first)) {
+        if (!c) break;
+        own.push(c);
+      }
+      const path = [...above.slice(0, first), ...own];
+      above = path;
+      return { path, value: r[width - 1] };
+    }),
+    issues
+  );
+}
+function chartTreeFromSeries(categories, values) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  categories.forEach((c, i) => {
+    const name = c.trim() || `${i + 1}`;
+    if (seen.has(name)) return;
+    seen.add(name);
+    const v = values[i];
+    out.push({ name, value: v !== null && v !== void 0 && Number.isFinite(v) && v > 0 ? v : 0 });
+  });
+  return out;
+}
+function cloneChartTree(tree) {
+  return tree.map((n) => ({ ...n, ...n.children ? { children: cloneChartTree(n.children) } : {} }));
+}
+function chartTreeColumnLabels(depth) {
+  if (depth <= 1) return ["Item"];
+  return Array.from({ length: depth }, (_, k) => k === 0 ? "Group" : k === depth - 1 ? "Item" : `Level ${k + 1}`);
+}
+function setChartTreeRowName(rows, row, level, name) {
+  return rows.map((r, i) => {
+    if (i !== row) return { path: [...r.path], value: r.value };
+    const path = [...r.path];
+    while (path.length <= level) path.push("");
+    path[level] = name.trim();
+    return { path, value: r.value };
+  });
+}
+function setChartTreeRowValue(rows, row, value) {
+  return rows.map((r, i) => ({ path: [...r.path], value: i === row ? value : r.value }));
+}
+function addChartTreeRow(rows) {
+  const parent = rows.length ? rows[rows.length - 1].path.slice(0, -1) : [];
+  const taken = new Set(rows.filter((r) => r.path.length === parent.length + 1 && parent.every((p, k) => r.path[k] === p)).map((r) => r.path[parent.length]));
+  let n = rows.length + 1;
+  while (taken.has(`Item ${n}`)) n++;
+  return [...rows.map((r) => ({ path: [...r.path], value: r.value })), { path: [...parent, `Item ${n}`], value: 0 }];
+}
+function removeChartTreeRow(rows, row) {
+  return rows.filter((_, i) => i !== row).map((r) => ({ path: [...r.path], value: r.value }));
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 
 
@@ -834,4 +1194,4 @@ function chartColorInputValue(color) {
 
 
 
-exports.parseChartColor = parseChartColor; exports.chartRgbToHex = chartRgbToHex; exports.shadeChartColor = shadeChartColor; exports.CHART_PALETTE_SHADES = CHART_PALETTE_SHADES; exports.cyclePaletteColor = cyclePaletteColor; exports.chartLuminance = chartLuminance; exports.chartContrastRatio = chartContrastRatio; exports.chartTextOn = chartTextOn; exports.chartRgbToOklab = chartRgbToOklab; exports.chartColorDistance = chartColorDistance; exports.simulateChartVision = simulateChartVision; exports.checkChartColors = checkChartColors; exports.CHART_ERROR_BAR_TYPES = CHART_ERROR_BAR_TYPES; exports.CHART_ERROR_BAR_DIRECTIONS = CHART_ERROR_BAR_DIRECTIONS; exports.CHART_ERROR_BAR_LABELS = CHART_ERROR_BAR_LABELS; exports.defaultChartErrorBarValue = defaultChartErrorBarValue; exports.chartErrorAmounts = chartErrorAmounts; exports.describeChartErrorBars = describeChartErrorBars; exports.chartErrorBarsOfType = chartErrorBarsOfType; exports.formatChartAmountList = formatChartAmountList; exports.parseChartAmountList = parseChartAmountList; exports.CHART_TYPES = CHART_TYPES; exports.CHART_MARKERS = CHART_MARKERS; exports.CHART_TRENDLINE_TYPES = CHART_TRENDLINE_TYPES; exports.CHART_LABEL_POSITIONS = CHART_LABEL_POSITIONS; exports.CHART_AXIS_KINDS = CHART_AXIS_KINDS; exports.CHART_AXIS_SCALES = CHART_AXIS_SCALES; exports.CHART_SERIES_TYPES = CHART_SERIES_TYPES; exports.CHART_STACKINGS = CHART_STACKINGS; exports.CHART_CURVES = CHART_CURVES; exports.CHART_RADAR_GRATICULES = CHART_RADAR_GRATICULES; exports.CHART_ORIENTATIONS = CHART_ORIENTATIONS; exports.CHART_LEGEND_POSITIONS = CHART_LEGEND_POSITIONS; exports.CHART_NUMBER_STYLES = CHART_NUMBER_STYLES; exports.CHART_TYPE_LABELS = CHART_TYPE_LABELS; exports.DEFAULT_CHART_PALETTE = DEFAULT_CHART_PALETTE; exports.DEFAULT_CHART_THEME = DEFAULT_CHART_THEME; exports.CSS_VARIABLE_CHART_THEME = CSS_VARIABLE_CHART_THEME; exports.isCartesianChart = isCartesianChart; exports.isXyChart = isXyChart; exports.chartFamily = chartFamily; exports.chartColorsByCategory = chartColorsByCategory; exports.defaultChartAxis = defaultChartAxis; exports.createChartSpec = createChartSpec; exports.chartSeriesColor = chartSeriesColor; exports.chartSliceColor = chartSliceColor; exports.chartPointColor = chartPointColor; exports.chartSeriesType = chartSeriesType; exports.uniqueChartSeriesId = uniqueChartSeriesId; exports.parseChartValue = parseChartValue; exports.normalizeChartAxis = normalizeChartAxis; exports.normalizeChartValues = normalizeChartValues; exports.normalizeChartErrorBars = normalizeChartErrorBars; exports.normalizeChartTrendline = normalizeChartTrendline; exports.normalizeChartSpec = normalizeChartSpec; exports.cloneChartSpec = cloneChartSpec; exports.cloneChartSeries = cloneChartSeries; exports.chartDataFromTable = chartDataFromTable; exports.chartDataToTable = chartDataToTable; exports.chartColorInputValue = chartColorInputValue;
+exports.parseChartColor = parseChartColor; exports.chartRgbToHex = chartRgbToHex; exports.shadeChartColor = shadeChartColor; exports.CHART_PALETTE_SHADES = CHART_PALETTE_SHADES; exports.cyclePaletteColor = cyclePaletteColor; exports.chartLuminance = chartLuminance; exports.chartContrastRatio = chartContrastRatio; exports.chartTextOn = chartTextOn; exports.chartRgbToOklab = chartRgbToOklab; exports.chartColorDistance = chartColorDistance; exports.simulateChartVision = simulateChartVision; exports.checkChartColors = checkChartColors; exports.CHART_ERROR_BAR_TYPES = CHART_ERROR_BAR_TYPES; exports.CHART_ERROR_BAR_DIRECTIONS = CHART_ERROR_BAR_DIRECTIONS; exports.CHART_ERROR_BAR_LABELS = CHART_ERROR_BAR_LABELS; exports.defaultChartErrorBarValue = defaultChartErrorBarValue; exports.chartErrorAmounts = chartErrorAmounts; exports.describeChartErrorBars = describeChartErrorBars; exports.chartErrorBarsOfType = chartErrorBarsOfType; exports.formatChartAmountList = formatChartAmountList; exports.parseChartAmountList = parseChartAmountList; exports.MAX_CHART_TREE_DEPTH = MAX_CHART_TREE_DEPTH; exports.MAX_CHART_TREE_NODES = MAX_CHART_TREE_NODES; exports.normalizeChartTree = normalizeChartTree; exports.chartTreeTotal = chartTreeTotal; exports.chartTreeDepth = chartTreeDepth; exports.findChartTreeNode = findChartTreeNode; exports.chartTreeToRows = chartTreeToRows; exports.chartTreeFromRows = chartTreeFromRows; exports.chartTreeFromTable = chartTreeFromTable; exports.chartTreeFromSeries = chartTreeFromSeries; exports.cloneChartTree = cloneChartTree; exports.chartTreeColumnLabels = chartTreeColumnLabels; exports.setChartTreeRowName = setChartTreeRowName; exports.setChartTreeRowValue = setChartTreeRowValue; exports.addChartTreeRow = addChartTreeRow; exports.removeChartTreeRow = removeChartTreeRow; exports.CHART_TYPES = CHART_TYPES; exports.CHART_MARKERS = CHART_MARKERS; exports.CHART_TRENDLINE_TYPES = CHART_TRENDLINE_TYPES; exports.CHART_LABEL_POSITIONS = CHART_LABEL_POSITIONS; exports.CHART_AXIS_KINDS = CHART_AXIS_KINDS; exports.CHART_AXIS_SCALES = CHART_AXIS_SCALES; exports.CHART_SERIES_TYPES = CHART_SERIES_TYPES; exports.CHART_STACKINGS = CHART_STACKINGS; exports.CHART_CURVES = CHART_CURVES; exports.CHART_RADAR_GRATICULES = CHART_RADAR_GRATICULES; exports.CHART_LIKERT_NEUTRALS = CHART_LIKERT_NEUTRALS; exports.CHART_LIKERT_SORTS = CHART_LIKERT_SORTS; exports.CHART_REFERENCE_AXES = CHART_REFERENCE_AXES; exports.CHART_ORIENTATIONS = CHART_ORIENTATIONS; exports.CHART_LEGEND_POSITIONS = CHART_LEGEND_POSITIONS; exports.CHART_NUMBER_STYLES = CHART_NUMBER_STYLES; exports.CHART_TYPE_LABELS = CHART_TYPE_LABELS; exports.DEFAULT_CHART_PALETTE = DEFAULT_CHART_PALETTE; exports.DEFAULT_CHART_THEME = DEFAULT_CHART_THEME; exports.CSS_VARIABLE_CHART_THEME = CSS_VARIABLE_CHART_THEME; exports.isCartesianChart = isCartesianChart; exports.isXyChart = isXyChart; exports.chartFamily = chartFamily; exports.chartColorsByCategory = chartColorsByCategory; exports.chartSpecColorsByCategory = chartSpecColorsByCategory; exports.defaultChartAxis = defaultChartAxis; exports.createChartSpec = createChartSpec; exports.chartSeriesColor = chartSeriesColor; exports.chartLikertColor = chartLikertColor; exports.chartSliceColor = chartSliceColor; exports.chartVariesColors = chartVariesColors; exports.chartPointColor = chartPointColor; exports.chartSeriesType = chartSeriesType; exports.uniqueChartSeriesId = uniqueChartSeriesId; exports.parseChartValue = parseChartValue; exports.normalizeChartAxis = normalizeChartAxis; exports.normalizeChartValues = normalizeChartValues; exports.normalizeChartReferenceLine = normalizeChartReferenceLine; exports.normalizeChartReferenceBand = normalizeChartReferenceBand; exports.normalizeChartErrorBars = normalizeChartErrorBars; exports.normalizeChartTrendline = normalizeChartTrendline; exports.normalizeChartSpec = normalizeChartSpec; exports.cloneChartSpec = cloneChartSpec; exports.cloneChartSeries = cloneChartSeries; exports.chartDataFromTable = chartDataFromTable; exports.chartDataToTable = chartDataToTable; exports.chartColorInputValue = chartColorInputValue;