@pixerate/editor 0.46.0 → 0.47.0

package/dist/chunk-C3NWJE3K.js

@@ -0,0 +1,1182 @@
+// src/chart/color.ts
+var NAMED = {
+  black: "#000000",
+  white: "#ffffff",
+  red: "#ff0000",
+  green: "#008000",
+  blue: "#0000ff",
+  yellow: "#ffff00",
+  orange: "#ffa500",
+  purple: "#800080",
+  gray: "#808080",
+  grey: "#808080",
+  teal: "#008080",
+  navy: "#000080",
+  maroon: "#800000",
+  olive: "#808000",
+  silver: "#c0c0c0",
+  lime: "#00ff00",
+  aqua: "#00ffff",
+  cyan: "#00ffff",
+  fuchsia: "#ff00ff",
+  magenta: "#ff00ff",
+  pink: "#ffc0cb",
+  brown: "#a52a2a"
+};
+function parseChartColor(color) {
+  const text2 = color.trim().toLowerCase();
+  const hex2 = NAMED[text2] ?? text2;
+  let m = /^#([0-9a-f]{3})$/.exec(hex2);
+  if (m) return [...m[1]].map((c) => parseInt(c + c, 16) / 255);
+  m = /^#([0-9a-f]{6})([0-9a-f]{2})?$/.exec(hex2);
+  if (m) return [0, 2, 4].map((i) => parseInt(m[1].slice(i, i + 2), 16) / 255);
+  m = /^rgba?\(\s*([\d.]+)%?[\s,]+([\d.]+)%?[\s,]+([\d.]+)%?(?:[\s,/]+[\d.]+%?)?\s*\)$/.exec(text2);
+  if (m) {
+    const pct = text2.includes("%");
+    return [m[1], m[2], m[3]].map((v) => Math.max(0, Math.min(1, Number(v) / (pct ? 100 : 255))));
+  }
+  return null;
+}
+function chartRgbToHex(rgb) {
+  return `#${rgb.map((c) => Math.round(Math.max(0, Math.min(1, c)) * 255).toString(16).padStart(2, "0")).join("")}`;
+}
+function shadeChartColor(color, amount) {
+  const rgb = parseChartColor(color);
+  if (!rgb || !amount) return color;
+  const t = Math.max(-1, Math.min(1, amount));
+  return chartRgbToHex(rgb.map((c) => t > 0 ? c + (1 - c) * t : c * (1 + t)));
+}
+var CHART_PALETTE_SHADES = [0, 0.4, -0.25, 0.6, -0.5, 0.2];
+function cyclePaletteColor(palette, index) {
+  const base = palette[index % palette.length];
+  const round = Math.floor(index / palette.length) % CHART_PALETTE_SHADES.length;
+  return shadeChartColor(base, CHART_PALETTE_SHADES[round]);
+}
+var toLinear = (c) => c <= 0.04045 ? c / 12.92 : Math.pow((c + 0.055) / 1.055, 2.4);
+var fromLinear = (c) => c <= 31308e-7 ? c * 12.92 : 1.055 * Math.pow(c, 1 / 2.4) - 0.055;
+function chartLuminance(rgb) {
+  const [r, g, b] = rgb.map(toLinear);
+  return 0.2126 * r + 0.7152 * g + 0.0722 * b;
+}
+function chartContrastRatio(a, b) {
+  const ra = parseChartColor(a);
+  const rb = parseChartColor(b);
+  if (!ra || !rb) return null;
+  const la = chartLuminance(ra);
+  const lb = chartLuminance(rb);
+  return (Math.max(la, lb) + 0.05) / (Math.min(la, lb) + 0.05);
+}
+function chartTextOn(fill, fallback, dark = "#0f172a", light = "#ffffff") {
+  const rgb = parseChartColor(fill);
+  if (!rgb) return fallback;
+  const darkRatio = chartContrastRatio(fill, dark);
+  const lightRatio = chartContrastRatio(fill, light);
+  return darkRatio >= lightRatio ? dark : light;
+}
+function chartRgbToOklab(rgb) {
+  const [r, g, b] = rgb.map(toLinear);
+  const l = Math.cbrt(0.4122214708 * r + 0.5363325363 * g + 0.0514459929 * b);
+  const m = Math.cbrt(0.2119034982 * r + 0.6806995451 * g + 0.1073969566 * b);
+  const s = Math.cbrt(0.0883024619 * r + 0.2817188376 * g + 0.6299787005 * b);
+  return [
+    0.2104542553 * l + 0.793617785 * m - 0.0040720468 * s,
+    1.9779984951 * l - 2.428592205 * m + 0.4505937099 * s,
+    0.0259040371 * l + 0.7827717662 * m - 0.808675766 * s
+  ];
+}
+function chartColorDistance(a, b) {
+  const p = chartRgbToOklab(a);
+  const q = chartRgbToOklab(b);
+  return Math.hypot(p[0] - q[0], p[1] - q[1], p[2] - q[2]);
+}
+var CVD = {
+  protanopia: [
+    [0.152286, 1.052583, -0.204868],
+    [0.114503, 0.786281, 0.099216],
+    [-3882e-6, -0.048116, 1.051998]
+  ],
+  deuteranopia: [
+    [0.367322, 0.860646, -0.227968],
+    [0.280085, 0.672501, 0.047413],
+    [-0.01182, 0.04294, 0.968881]
+  ],
+  tritanopia: [
+    [1.255528, -0.076749, -0.178779],
+    [-0.078411, 0.930809, 0.147602],
+    [4733e-6, 0.691367, 0.3039]
+  ]
+};
+function simulateChartVision(rgb, vision) {
+  if (vision === "normal") return rgb;
+  const lin = rgb.map(toLinear);
+  const m = CVD[vision];
+  return m.map((row) => fromLinear(Math.max(0, Math.min(1, row[0] * lin[0] + row[1] * lin[1] + row[2] * lin[2]))));
+}
+function checkChartColors(colors, options = {}) {
+  const surface = options.surface ?? "#ffffff";
+  const minDistance = options.minDistance ?? 0.08;
+  const minContrast = options.minContrast ?? 1.5;
+  const visions = options.visions ?? ["normal", "protanopia", "deuteranopia", "tritanopia"];
+  const parsed = colors.map(parseChartColor);
+  const skipped = colors.filter((_, i) => !parsed[i]);
+  const issues = [];
+  const closest = {};
+  for (const vision of visions) {
+    const seen = parsed.map((c) => c ? simulateChartVision(c, vision) : null);
+    let best;
+    for (let a = 0; a < seen.length; a++) {
+      for (let b = a + 1; b < seen.length; b++) {
+        if (!seen[a] || !seen[b]) continue;
+        const distance = chartColorDistance(seen[a], seen[b]);
+        if (!best || distance < best.distance) best = { a, b, colors: [colors[a], colors[b]], distance: Math.round(distance * 1e3) / 1e3 };
+      }
+    }
+    if (best) {
+      closest[vision] = best;
+      if (best.distance < minDistance) {
+        const who = vision === "normal" ? "" : ` with ${vision}`;
+        issues.push(`Colours ${best.a + 1} (${best.colors[0]}) and ${best.b + 1} (${best.colors[1]}) are hard to tell apart${who} (distance ${best.distance}, want at least ${minDistance}).`);
+      }
+    }
+  }
+  const contrast = colors.map((c) => {
+    const ratio = chartContrastRatio(c, surface);
+    return ratio === null ? null : Math.round(ratio * 100) / 100;
+  });
+  contrast.forEach((ratio, i) => {
+    if (ratio !== null && ratio < minContrast) issues.push(`Colour ${i + 1} (${colors[i]}) barely stands out from the background ${surface} (contrast ${ratio}:1, want at least ${minContrast}:1).`);
+  });
+  return { ok: issues.length === 0, closest, contrast, issues, skipped };
+}
+
+// src/chart/spec.ts
+var CHART_TYPES = ["bar", "line", "area", "scatter", "bubble", "pie", "donut", "radar", "waterfall", "histogram", "box", "funnel", "treemap"];
+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"];
+var CHART_AXIS_KINDS = ["category", "date"];
+var CHART_SERIES_TYPES = ["bar", "line", "area", "scatter"];
+var CHART_STACKINGS = ["none", "stacked", "percent"];
+var CHART_CURVES = ["linear", "smooth", "step"];
+var CHART_ORIENTATIONS = ["vertical", "horizontal"];
+var CHART_LEGEND_POSITIONS = ["top", "bottom", "left", "right"];
+var CHART_NUMBER_STYLES = ["number", "percent", "currency", "compact"];
+var CHART_TYPE_LABELS = {
+  bar: "Bar",
+  line: "Line",
+  area: "Area",
+  scatter: "Scatter",
+  bubble: "Bubble",
+  pie: "Pie",
+  donut: "Donut",
+  radar: "Radar",
+  waterfall: "Waterfall",
+  histogram: "Histogram",
+  box: "Box plot",
+  funnel: "Funnel",
+  treemap: "Treemap"
+};
+var DEFAULT_CHART_PALETTE = ["#4269d0", "#efb118", "#ff725c", "#6cc5b0", "#3ca951", "#ff8ab7", "#a463f2", "#97bbf5", "#9c6b4e", "#9498a0"];
+var DEFAULT_CHART_THEME = {
+  background: "#ffffff",
+  surface: "#ffffff",
+  text: "#0f172a",
+  mutedText: "#64748b",
+  grid: "#e2e8f0",
+  axis: "#94a3b8",
+  selection: "#2563eb",
+  positive: "#3ca951",
+  negative: "#e5484d",
+  fontFamily: 'system-ui, -apple-system, "Segoe UI", sans-serif',
+  fontSize: 11,
+  titleSize: 15
+};
+var CSS_VARIABLE_CHART_THEME = {
+  ...DEFAULT_CHART_THEME,
+  background: "transparent",
+  surface: "var(--background, #ffffff)",
+  text: "var(--foreground, #0f172a)",
+  mutedText: "var(--muted-foreground, #64748b)",
+  grid: "var(--border, #e2e8f0)",
+  axis: "var(--muted-foreground, #94a3b8)",
+  selection: "var(--primary, #2563eb)",
+  fontFamily: "inherit"
+};
+function isCartesianChart(type) {
+  return type === "bar" || type === "line" || type === "area" || type === "scatter";
+}
+function isXyChart(spec) {
+  if (spec.type === "bubble") return true;
+  return spec.type === "scatter" && spec.series.some((s) => !s.hidden && Array.isArray(s.x) && s.x.some((v) => v !== null));
+}
+function chartFamily(spec) {
+  if (isXyChart(spec)) return "xy";
+  switch (spec.type) {
+    case "pie":
+    case "donut":
+      return "pie";
+    case "radar":
+    case "waterfall":
+    case "histogram":
+    case "box":
+    case "funnel":
+    case "treemap":
+      return spec.type;
+    case "bubble":
+      return "xy";
+    default:
+      return "cartesian";
+  }
+}
+function chartColorsByCategory(type) {
+  return type === "pie" || type === "donut" || type === "funnel" || type === "treemap";
+}
+function defaultChartAxis(value) {
+  return { show: true, title: "", min: null, max: null, step: null, gridlines: value, format: {} };
+}
+function createChartSpec(partial = {}) {
+  return normalizeChartSpec(partial).spec;
+}
+function chartSeriesColor(spec, seriesIndex) {
+  const series = spec.series[seriesIndex];
+  if (series?.color) return series.color;
+  return cyclePaletteColor(spec.palette.length ? spec.palette : DEFAULT_CHART_PALETTE, seriesIndex);
+}
+function chartSliceColor(spec, index) {
+  return cyclePaletteColor(spec.palette.length ? spec.palette : DEFAULT_CHART_PALETTE, index);
+}
+function chartPointColor(spec, seriesIndex, index) {
+  return spec.series[seriesIndex]?.pointColors?.[index] || chartSeriesColor(spec, seriesIndex);
+}
+function chartSeriesType(spec, series) {
+  if (series.type) return series.type;
+  if (spec.type === "bubble") return "scatter";
+  return isCartesianChart(spec.type) ? spec.type : "bar";
+}
+function uniqueChartSeriesId(series, base = "series") {
+  const used = new Set(series.map((s) => s.id));
+  for (let i = series.length + 1; ; i++) {
+    const id = `${base}-${i}`;
+    if (!used.has(id)) return id;
+  }
+}
+function parseChartValue(input) {
+  if (input === null || input === void 0) return null;
+  if (typeof input === "number") return Number.isFinite(input) ? input : void 0;
+  if (typeof input !== "string") return void 0;
+  let text2 = input.trim();
+  if (!text2 || text2 === "-" || text2 === "\u2014") return null;
+  let negative = false;
+  if (/^\(.*\)$/.test(text2)) {
+    negative = true;
+    text2 = text2.slice(1, -1).trim();
+  }
+  const percent = text2.endsWith("%");
+  if (percent) text2 = text2.slice(0, -1).trim();
+  text2 = text2.replace(/^[$€£¥]/, "").replace(/,/g, "").replace(/\s+/g, "");
+  if (!/^[-+]?(\d+\.?\d*|\.\d+)(e[-+]?\d+)?$/i.test(text2)) return void 0;
+  let value = Number(text2);
+  if (percent) value /= 100;
+  if (negative) value = -value;
+  return Number.isFinite(value) ? value : void 0;
+}
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+function pick(value, options, fallback, path2, issues) {
+  if (value === void 0) return fallback;
+  if (typeof value === "string" && options.includes(value)) return value;
+  issues.push({ path: path2, message: `${path2} must be one of ${options.map((o) => `"${o}"`).join(", ")}; got ${JSON.stringify(value)}.` });
+  return fallback;
+}
+function text(value, fallback, path2, issues) {
+  if (value === void 0 || value === null) return fallback;
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  issues.push({ path: path2, message: `${path2} must be text.` });
+  return fallback;
+}
+function flag(value, fallback, path2, issues) {
+  if (value === void 0) return fallback;
+  if (typeof value === "boolean") return value;
+  issues.push({ path: path2, message: `${path2} must be true or false.` });
+  return fallback;
+}
+function bound(value, path2, issues) {
+  if (value === void 0 || value === null || value === "") return null;
+  const n = typeof value === "string" ? Number(value) : value;
+  if (typeof n === "number" && Number.isFinite(n)) return n;
+  issues.push({ path: path2, message: `${path2} must be a number or null.` });
+  return null;
+}
+function normalizeFormat(value, path2, issues) {
+  if (value === void 0 || value === null) return {};
+  if (!isRecord(value)) {
+    issues.push({ path: path2, message: `${path2} must be an object.` });
+    return {};
+  }
+  const out = {};
+  if (value.style !== void 0) out.style = pick(value.style, CHART_NUMBER_STYLES, "number", `${path2}.style`, issues);
+  if (value.decimals !== void 0) {
+    const d = Number(value.decimals);
+    if (Number.isInteger(d) && d >= 0 && d <= 10) out.decimals = d;
+    else issues.push({ path: `${path2}.decimals`, message: `${path2}.decimals must be a whole number from 0 to 10.` });
+  }
+  for (const key2 of ["currency", "prefix", "suffix", "code"]) {
+    if (value[key2] !== void 0) out[key2] = text(value[key2], "", `${path2}.${key2}`, issues);
+  }
+  return out;
+}
+function normalizeChartAxis(value, fallback, path2, issues = []) {
+  if (value === void 0) return { ...fallback, format: { ...fallback.format } };
+  if (!isRecord(value)) {
+    issues.push({ path: path2, message: `${path2} must be an object.` });
+    return { ...fallback, format: { ...fallback.format } };
+  }
+  let min = "min" in value ? bound(value.min, `${path2}.min`, issues) : fallback.min;
+  let max = "max" in value ? bound(value.max, `${path2}.max`, issues) : fallback.max;
+  if (min !== null && max !== null && min >= max) {
+    issues.push({ path: `${path2}.max`, message: `${path2}.max (${max}) must be greater than ${path2}.min (${min}).` });
+    min = fallback.min;
+    max = fallback.max;
+  }
+  let step = "step" in value ? bound(value.step, `${path2}.step`, issues) : fallback.step;
+  if (step !== null && !(step > 0)) {
+    issues.push({ path: `${path2}.step`, message: `${path2}.step must be greater than 0 (or null for automatic).` });
+    step = fallback.step;
+  }
+  const axis = {
+    show: flag(value.show, fallback.show, `${path2}.show`, issues),
+    title: text(value.title, fallback.title, `${path2}.title`, issues),
+    min,
+    max,
+    step,
+    gridlines: flag(value.gridlines, fallback.gridlines, `${path2}.gridlines`, issues),
+    format: "format" in value ? normalizeFormat(value.format, `${path2}.format`, issues) : { ...fallback.format }
+  };
+  const kind = "kind" in value ? value.kind === null ? void 0 : pick(value.kind, CHART_AXIS_KINDS, "category", `${path2}.kind`, issues) : fallback.kind;
+  if (kind && kind !== "category") axis.kind = kind;
+  return axis;
+}
+function normalizeLegend(value, issues) {
+  const fallback = { show: true, position: "bottom" };
+  if (value === void 0) return fallback;
+  if (!isRecord(value)) {
+    issues.push({ path: "legend", message: "legend must be an object." });
+    return fallback;
+  }
+  return {
+    show: flag(value.show, fallback.show, "legend.show", issues),
+    position: pick(value.position, CHART_LEGEND_POSITIONS, fallback.position, "legend.position", issues)
+  };
+}
+function normalizeChartValues(value, length, path2, issues = []) {
+  if (value === void 0) return length ? Array(length).fill(null) : [];
+  if (!Array.isArray(value)) {
+    issues.push({ path: path2, message: `${path2} must be an array of numbers.` });
+    return length ? Array(length).fill(null) : [];
+  }
+  const out = value.map((v, i) => {
+    const parsed = parseChartValue(v);
+    if (parsed === void 0) {
+      issues.push({ path: `${path2}[${i}]`, message: `${path2}[${i}] is not a number: ${JSON.stringify(v)}.` });
+      return null;
+    }
+    return parsed;
+  });
+  if (length === void 0) return out;
+  if (out.length > length) return out.slice(0, length);
+  while (out.length < length) out.push(null);
+  return out;
+}
+function normalizeSeries(value, length, used, index, issues) {
+  const path2 = `series[${index}]`;
+  if (!isRecord(value)) {
+    issues.push({ path: path2, message: `${path2} must be an object with a name and values.` });
+    return null;
+  }
+  let id = typeof value.id === "string" && value.id.trim() ? value.id.trim() : "";
+  if (!id || used.has(id)) {
+    if (id) issues.push({ path: `${path2}.id`, message: `Series id "${id}" is used twice; the second was renamed.` });
+    for (let n = index + 1; ; n++) {
+      id = `series-${n}`;
+      if (!used.has(id)) break;
+    }
+  }
+  used.add(id);
+  const series = {
+    id,
+    name: text(value.name, `Series ${index + 1}`, `${path2}.name`, issues),
+    values: normalizeChartValues(value.values, length, `${path2}.values`, issues)
+  };
+  if (typeof value.color === "string" && value.color.trim()) series.color = value.color.trim();
+  if (value.type !== void 0 && value.type !== null) series.type = pick(value.type, CHART_SERIES_TYPES, "bar", `${path2}.type`, issues);
+  if (value.hidden === true) series.hidden = true;
+  if (value.axis !== void 0 && value.axis !== null && pick(value.axis, ["primary", "secondary"], "primary", `${path2}.axis`, issues) === "secondary") series.axis = "secondary";
+  for (const key2 of ["x", "sizes"]) {
+    if (value[key2] === void 0 || value[key2] === null) continue;
+    const list = normalizeChartValues(value[key2], length, `${path2}.${key2}`, issues);
+    if (list.some((v) => v !== null)) series[key2] = list;
+  }
+  if (key(value, "sizes") && series.sizes?.some((v) => v !== null && v < 0)) {
+    issues.push({ path: `${path2}.sizes`, message: `${path2}.sizes must not be negative.` });
+    series.sizes = series.sizes.map((v) => v !== null && v < 0 ? null : v);
+  }
+  if (value.pointColors !== void 0 && value.pointColors !== null) {
+    if (!Array.isArray(value.pointColors)) issues.push({ path: `${path2}.pointColors`, message: `${path2}.pointColors must be an array of colours or nulls.` });
+    else {
+      const colors = Array.from({ length }, (_, i) => {
+        const c = value.pointColors[i];
+        return typeof c === "string" && c.trim() ? c.trim() : null;
+      });
+      if (colors.some((c) => c !== null)) series.pointColors = colors;
+    }
+  }
+  if (value.marker !== void 0 && value.marker !== null) series.marker = pick(value.marker, CHART_MARKERS, "circle", `${path2}.marker`, issues);
+  if (value.curve !== void 0 && value.curve !== null) series.curve = pick(value.curve, CHART_CURVES, "linear", `${path2}.curve`, issues);
+  if (value.dataLabels !== void 0 && value.dataLabels !== null) series.dataLabels = flag(value.dataLabels, false, `${path2}.dataLabels`, issues);
+  if (value.format !== void 0 && value.format !== null) {
+    const format = normalizeFormat(value.format, `${path2}.format`, issues);
+    if (Object.keys(format).length) series.format = format;
+  }
+  if (value.trendlines !== void 0 && value.trendlines !== null) {
+    if (!Array.isArray(value.trendlines)) issues.push({ path: `${path2}.trendlines`, message: `${path2}.trendlines must be an array.` });
+    else {
+      const lines = value.trendlines.map((t, i) => normalizeChartTrendline(t, `${path2}.trendlines[${i}]`, issues)).filter((t) => t !== null);
+      if (lines.length) series.trendlines = lines;
+    }
+  }
+  return series;
+}
+var key = (value, name) => value[name] !== void 0 && value[name] !== null;
+function normalizeChartTrendline(value, path2, issues = []) {
+  if (!isRecord(value)) {
+    issues.push({ path: path2, message: `${path2} must be an object with a type.` });
+    return null;
+  }
+  const type = pick(value.type, CHART_TRENDLINE_TYPES, "linear", `${path2}.type`, issues);
+  const line = { type };
+  const whole = (name, min, max) => {
+    if (!key(value, name)) return;
+    const n = Number(value[name]);
+    if (Number.isInteger(n) && n >= min && n <= max) line[name] = n;
+    else issues.push({ path: `${path2}.${name}`, message: `${path2}.${name} must be a whole number from ${min} to ${max}.` });
+  };
+  if (type === "polynomial") whole("order", 2, 6);
+  if (type === "moving-average") whole("period", 2, 1e3);
+  for (const name of ["forward", "backward"]) {
+    if (!key(value, name)) continue;
+    const n = Number(value[name]);
+    if (Number.isFinite(n) && n >= 0) {
+      if (n > 0) line[name] = n;
+    } else issues.push({ path: `${path2}.${name}`, message: `${path2}.${name} must be a number of x units, 0 or more.` });
+  }
+  if (key(value, "intercept")) {
+    const n = Number(value.intercept);
+    if (!Number.isFinite(n)) issues.push({ path: `${path2}.intercept`, message: `${path2}.intercept must be a number or null.` });
+    else if (type === "linear" || type === "polynomial" || type === "exponential") {
+      if (type === "exponential" && n <= 0) issues.push({ path: `${path2}.intercept`, message: `${path2}.intercept must be greater than 0 for an exponential trendline.` });
+      else line.intercept = n;
+    } else issues.push({ path: `${path2}.intercept`, message: `A ${type} trendline cannot have a fixed intercept; use linear, polynomial or exponential.` });
+  }
+  for (const name of ["showEquation", "showR2"]) if (key(value, name) && flag(value[name], false, `${path2}.${name}`, issues)) line[name] = true;
+  for (const name of ["name", "color"]) {
+    if (!key(value, name)) continue;
+    const t = text(value[name], "", `${path2}.${name}`, issues).trim();
+    if (t) line[name] = t;
+  }
+  return line;
+}
+function normalizeChartSpec(input) {
+  const issues = [];
+  const value = isRecord(input) ? input : {};
+  if (input !== void 0 && !isRecord(input)) issues.push({ path: "", message: "A chart must be an object." });
+  const type = pick(value.type, CHART_TYPES, "bar", "type", issues);
+  const rawSeries = Array.isArray(value.series) ? value.series : [];
+  if (value.series !== void 0 && !Array.isArray(value.series)) issues.push({ path: "series", message: "series must be an array." });
+  let categories;
+  if (Array.isArray(value.categories)) categories = value.categories.map((c, i) => text(c, "", `categories[${i}]`, issues));
+  else {
+    if (value.categories !== void 0) issues.push({ path: "categories", message: "categories must be an array of labels." });
+    const longest = rawSeries.reduce((n, s) => Math.max(n, isRecord(s) && Array.isArray(s.values) ? s.values.length : 0), 0);
+    categories = Array.from({ length: longest }, (_, i) => `${i + 1}`);
+  }
+  const used = /* @__PURE__ */ new Set();
+  const series = rawSeries.map((s, i) => normalizeSeries(s, categories.length, used, i, issues)).filter((s) => s !== null);
+  let palette = [...DEFAULT_CHART_PALETTE];
+  if (Array.isArray(value.palette)) {
+    const colors = value.palette.filter((c) => typeof c === "string" && c.trim() !== "");
+    if (colors.length) palette = colors;
+    else issues.push({ path: "palette", message: "palette must list at least one colour." });
+  } else if (value.palette !== void 0) issues.push({ path: "palette", message: "palette must be an array of colours." });
+  const fraction = (name, fallback, min, max) => {
+    if (value[name] === void 0) return fallback;
+    const r = Number(value[name]);
+    if (value[name] !== null && Number.isFinite(r) && r >= min && r <= max) return r;
+    issues.push({ path: name, message: `${name} must be a number from ${min} to ${max}.` });
+    return fallback;
+  };
+  const innerRadius = fraction("innerRadius", 0.55, 0, 0.9);
+  const gapWidth = fraction("gapWidth", 0.28, 0, 0.9);
+  const overlap = fraction("overlap", -0.12, -1, 1);
+  let bins = null;
+  if (value.bins !== void 0 && value.bins !== null) {
+    const b = Number(value.bins);
+    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 spec = {
+    version: 1,
+    type,
+    title: text(value.title, "", "title", issues),
+    subtitle: text(value.subtitle, "", "subtitle", issues),
+    categories,
+    series,
+    xAxis: normalizeChartAxis(value.xAxis, defaultChartAxis(false), "xAxis", issues),
+    yAxis: normalizeChartAxis(value.yAxis, defaultChartAxis(true), "yAxis", issues),
+    yAxis2: normalizeChartAxis(value.yAxis2, defaultChartAxis(false), "yAxis2", issues),
+    legend: normalizeLegend(value.legend, issues),
+    stacking: pick(value.stacking, CHART_STACKINGS, "none", "stacking", issues),
+    orientation: pick(value.orientation, CHART_ORIENTATIONS, "vertical", "orientation", issues),
+    curve: pick(value.curve, CHART_CURVES, "linear", "curve", issues),
+    points: flag(value.points, true, "points", issues),
+    dataLabels: flag(value.dataLabels, false, "dataLabels", issues),
+    labelPosition: pick(value.labelPosition, CHART_LABEL_POSITIONS, "auto", "labelPosition", issues),
+    palette,
+    innerRadius,
+    gapWidth,
+    overlap,
+    bins,
+    showTotal: flag(value.showTotal, true, "showTotal", issues)
+  };
+  return { spec, issues };
+}
+function cloneChartSpec(spec) {
+  return {
+    ...spec,
+    categories: [...spec.categories],
+    series: spec.series.map(cloneChartSeries),
+    xAxis: { ...spec.xAxis, format: { ...spec.xAxis.format } },
+    yAxis: { ...spec.yAxis, format: { ...spec.yAxis.format } },
+    yAxis2: { ...spec.yAxis2, format: { ...spec.yAxis2.format } },
+    legend: { ...spec.legend },
+    palette: [...spec.palette]
+  };
+}
+function cloneChartSeries(series) {
+  const copy = { ...series, values: [...series.values] };
+  if (series.x) copy.x = [...series.x];
+  if (series.sizes) copy.sizes = [...series.sizes];
+  if (series.pointColors) copy.pointColors = [...series.pointColors];
+  if (series.format) copy.format = { ...series.format };
+  if (series.trendlines) copy.trendlines = series.trendlines.map((t) => ({ ...t }));
+  return copy;
+}
+function chartDataFromTable(rows, options = {}) {
+  let grid = rows.map((r) => [...r]).filter((r) => r.some((c) => c !== null && c !== void 0 && String(c).trim() !== ""));
+  if (options.seriesIn === "rows") {
+    const width2 = Math.max(0, ...grid.map((r) => r.length));
+    grid = Array.from({ length: width2 }, (_, c) => grid.map((r) => r[c]));
+  }
+  const issues = [];
+  if (!grid.length) return { categories: [], series: [], issues };
+  const width = Math.max(...grid.map((r) => r.length));
+  const header = options.header === "auto" ? grid[0].slice(1).some((c) => c !== null && c !== void 0 && String(c).trim() !== "" && parseChartValue(c) === void 0) : options.header ?? true;
+  const names = header ? grid[0] : [];
+  const body = header ? grid.slice(1) : grid;
+  const categories = body.map((r, i) => {
+    const c = r[0];
+    return c === null || c === void 0 || String(c).trim() === "" ? `${i + 1}` : String(c).trim();
+  });
+  const series = [];
+  for (let col = 1; col < width; col++) {
+    const name = names[col] !== void 0 && String(names[col]).trim() ? String(names[col]).trim() : `Series ${col}`;
+    const values = body.map((r, i) => {
+      const parsed = parseChartValue(r[col] ?? null);
+      if (parsed === void 0) {
+        issues.push({ path: `${name}[${i}]`, message: `"${String(r[col])}" in ${name} (${categories[i]}) is not a number; it was left blank.` });
+        return null;
+      }
+      return parsed;
+    });
+    series.push({ id: `series-${col}`, name, values });
+  }
+  if (options.xFromFirstColumn) {
+    const x = body.map((r, i) => {
+      const parsed = parseChartValue(r[0] ?? null);
+      if (parsed === void 0) issues.push({ path: `x[${i}]`, message: `"${String(r[0])}" in the first column is not a number; that point has no x.` });
+      return parsed ?? null;
+    });
+    for (const s of series) s.x = [...x];
+  }
+  return { categories, series, issues };
+}
+function chartDataToTable(spec, options = {}) {
+  return [
+    [options.categoryHeader ?? "", ...spec.series.map((s) => s.name)],
+    ...spec.categories.map((category, i) => [category, ...spec.series.map((s) => s.values[i] ?? null)])
+  ];
+}
+function chartColorInputValue(color) {
+  if (/^#[0-9a-f]{6}$/i.test(color)) return color.toLowerCase();
+  if (/^#[0-9a-f]{3}$/i.test(color)) return `#${[...color.slice(1)].map((c) => c + c).join("")}`.toLowerCase();
+  return "#000000";
+}
+
+// src/chart/ooxml.ts
+var CHART_OOXML_NS = "http://schemas.openxmlformats.org/drawingml/2006/chart";
+var CHART_OOXML_CONTENT_TYPE = "application/vnd.openxmlformats-officedocument.drawingml.chart+xml";
+var CHART_OOXML_RELATIONSHIP = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/chart";
+var MAX_POINTS = 1e5;
+function parser(options) {
+  const P = options.DOMParser ?? globalThis.DOMParser;
+  if (!P) throw new Error("Reading chart XML needs a DOMParser. In Node, pass one (e.g. from jsdom or @xmldom/xmldom) as { DOMParser }.");
+  return P;
+}
+var kids = (el, name) => el ? Array.from(el.childNodes).filter((n) => n.nodeType === 1 && (!name || n.localName === name)) : [];
+var kid = (el, name) => kids(el, name)[0];
+var val = (el, name) => kid(el, name)?.getAttribute("val") ?? void 0;
+var path = (el, ...names) => names.reduce((e, n) => kid(e, n), el ?? void 0);
+var find = (el, name) => {
+  if (!el) return void 0;
+  for (const c of kids(el)) {
+    if (c.localName === name) return c;
+    const deep = find(c, name);
+    if (deep) return deep;
+  }
+  return void 0;
+};
+var bool = (v, fallback = false) => v === void 0 ? fallback : v === "1" || v === "true";
+var numberOf = (v) => {
+  if (v === void 0) return null;
+  const n = Number(v);
+  return Number.isFinite(n) ? n : null;
+};
+function strings(e) {
+  if (!e) return [];
+  const cache = find(e, "strCache") ?? find(e, "numCache") ?? find(e, "strLit") ?? find(e, "numLit");
+  if (cache) {
+    const n = Math.min(MAX_POINTS, Number(val(cache, "ptCount") ?? 0) || 0);
+    const out = Array(n).fill("");
+    for (const pt of kids(cache, "pt").slice(0, MAX_POINTS)) {
+      const i = Number(pt.getAttribute("idx") ?? 0);
+      if (!Number.isInteger(i) || i < 0 || i >= MAX_POINTS) continue;
+      while (out.length <= i) out.push("");
+      out[i] = kid(pt, "v")?.textContent ?? "";
+    }
+    return out;
+  }
+  const multi = find(e, "multiLvlStrCache");
+  if (multi) {
+    const lvl = kid(multi, "lvl");
+    return kids(lvl, "pt").map((p) => kid(p, "v")?.textContent ?? "");
+  }
+  const v = kid(e, "v") ?? find(e, "v");
+  return v ? [v.textContent ?? ""] : [];
+}
+var numbers = (e) => strings(e).map((s) => s.trim() === "" ? null : numberOf(s.trim()));
+function formatCodeOf(e) {
+  return find(e, "numCache") ? kid(find(e, "numCache"), "formatCode")?.textContent ?? void 0 : void 0;
+}
+function richText(t) {
+  if (!t) return void 0;
+  const tx = kid(t, "tx");
+  const rich2 = kid(tx, "rich");
+  if (rich2) return kids(rich2, "p").map((p) => Array.from(p.getElementsByTagNameNS("*", "t")).map((x) => x.textContent ?? "").join("")).join("\n");
+  const v = find(tx, "v");
+  return v?.textContent ?? void 0;
+}
+function solidColor(spPr) {
+  const fill = kid(spPr, "solidFill") ?? kid(kid(spPr, "ln"), "solidFill");
+  const srgb = kid(fill, "srgbClr");
+  const v = srgb?.getAttribute("val");
+  return v && /^[0-9a-f]{6}$/i.test(v) ? `#${v.toLowerCase()}` : void 0;
+}
+var MARKERS = { circle: "circle", dot: "circle", square: "square", diamond: "diamond", triangle: "triangle", x: "cross", plus: "cross", star: "cross", dash: "square", none: "none" };
+var TREND_IN = { linear: "linear", exp: "exponential", log: "logarithmic", poly: "polynomial", power: "power", movingAvg: "moving-average" };
+var TREND_OUT = { linear: "linear", exponential: "exp", logarithmic: "log", polynomial: "poly", power: "power", "moving-average": "movingAvg" };
+var LEGEND_IN = { b: "bottom", t: "top", l: "left", r: "right", tr: "right" };
+function chartFromOoxml(xml, options = {}) {
+  const issues = [];
+  const unsupported = [];
+  let doc;
+  try {
+    doc = new (parser(options))().parseFromString(xml, "application/xml");
+  } catch (error) {
+    return { spec: normalizeChartSpec({}).spec, issues: [{ path: "", message: `The chart XML could not be read: ${error.message}` }], unsupported, lossless: false };
+  }
+  const root = doc.documentElement;
+  if (!root || root.localName !== "chartSpace" || doc.getElementsByTagName("parsererror").length) {
+    return { spec: normalizeChartSpec({}).spec, issues: [{ path: "", message: "This is not a chart part: expected a c:chartSpace (or cx:chartSpace) root element." }], unsupported, lossless: false };
+  }
+  if (root.namespaceURI?.includes("chartex") || kid(root, "chartData")) return readChartex(root, issues, unsupported);
+  const chart = kid(root, "chart");
+  const plot = kid(chart, "plotArea");
+  const input = { type: "bar" };
+  const titleEl = kid(chart, "title");
+  if (titleEl && !bool(val(chart, "autoTitleDeleted"))) input.title = richText(titleEl) ?? "";
+  const legend = kid(chart, "legend");
+  input.legend = { show: !!legend, position: LEGEND_IN[val(legend, "legendPos") ?? "r"] ?? "right" };
+  if (kid(root, "roundedCorners") && bool(val(root, "roundedCorners"))) unsupported.push("rounded corners");
+  const valAxes = kids(plot, "valAx");
+  const vertical = (a) => ["l", "r"].includes(val(a, "axPos") ?? "");
+  const secondaryPlaced = (a) => val(a, "crosses") === "max" || ["r", "t"].includes(val(a, "axPos") ?? "");
+  const groupValAxis = (g) => {
+    const ids = kids(g, "axId").map((a) => a.getAttribute("val"));
+    const axes = ids.map((id) => valAxes.find((a) => val(a, "axId") === id)).filter((a) => !!a);
+    return axes.find(vertical) ?? axes[0];
+  };
+  const groups = kids(plot).filter((g) => g.localName.endsWith("Chart"));
+  const used = groups.map(groupValAxis).filter((a) => !!a);
+  const primaryAxis = used.find((a) => !secondaryPlaced(a)) ?? used[0];
+  const series = [];
+  let categories = [];
+  const types = [];
+  let stacking = "none";
+  let orientation = "vertical";
+  let dataLabels = false;
+  let points = false;
+  for (const g of groups) {
+    const name = g.localName;
+    const grouping = val(g, "grouping") ?? "clustered";
+    let type;
+    if (/3D/.test(name)) unsupported.push(`3-D ${name.replace(/3DChart$/, "")} chart (drawn flat)`);
+    switch (name) {
+      case "barChart":
+      case "bar3DChart":
+        type = "bar";
+        if (val(g, "barDir") === "bar") orientation = "horizontal";
+        break;
+      case "lineChart":
+      case "line3DChart":
+        type = "line";
+        if (kids(g, "ser").some((s) => (val(kid(s, "marker"), "symbol") ?? (bool(val(g, "marker"), true) ? "auto" : "none")) !== "none")) points = true;
+        break;
+      case "areaChart":
+      case "area3DChart":
+        type = "area";
+        break;
+      case "pieChart":
+      case "pie3DChart":
+      case "ofPieChart":
+        type = "pie";
+        if (name === "ofPieChart") unsupported.push("pie-of-pie (drawn as one pie)");
+        break;
+      case "doughnutChart":
+        type = "donut";
+        input.innerRadius = Math.min(0.9, Math.max(0, (numberOf(val(g, "holeSize")) ?? 50) / 100));
+        break;
+      case "scatterChart":
+        type = "scatter";
+        if (/line/i.test(val(g, "scatterStyle") ?? "")) points = true;
+        break;
+      case "bubbleChart":
+        type = "bubble";
+        break;
+      case "radarChart":
+        type = "radar";
+        break;
+      default:
+        unsupported.push(`${name.replace(/Chart$/, "")} chart`);
+        continue;
+    }
+    if (grouping === "stacked") stacking = "stacked";
+    else if (grouping === "percentStacked") stacking = "percent";
+    const gap = numberOf(val(g, "gapWidth"));
+    const overlap = numberOf(val(g, "overlap"));
+    if (type === "bar") {
+      const n = Math.max(1, kids(g, "ser").length);
+      const g100 = (gap ?? 150) / 100;
+      const o = Math.max(-1, Math.min(1, (overlap ?? (grouping === "clustered" ? 0 : 100)) / 100));
+      const barsWidth = grouping === "clustered" ? n - (n - 1) * o : 1;
+      input.gapWidth = Math.round(Math.max(0, Math.min(0.9, g100 / (barsWidth + g100))) * 100) / 100;
+      if (grouping === "clustered") input.overlap = o;
+    }
+    if (bool(val(kid(g, "dLbls"), "showVal"))) dataLabels = true;
+    types.push(type);
+    const axis = groupValAxis(g);
+    const secondary = !!axis && !!primaryAxis && axis !== primaryAxis;
+    for (const s of kids(g, "ser").slice(0, 1e3)) {
+      const out = { id: `series-${series.length + 1}`, name: strings(kid(s, "tx"))[0] ?? `Series ${series.length + 1}`, values: [] };
+      const color = solidColor(kid(s, "spPr"));
+      if (color) out.color = color;
+      out.type = type === "bubble" ? void 0 : type;
+      if (secondary) out.axis = "secondary";
+      const marker = val(kid(s, "marker"), "symbol");
+      if (marker && MARKERS[marker] && MARKERS[marker] !== "circle" && (type === "scatter" || MARKERS[marker] !== "none") && (type === "line" || type === "scatter")) out.marker = MARKERS[marker];
+      if (bool(val(s, "smooth"))) out.curve = "smooth";
+      const sl = kid(s, "dLbls");
+      if (sl && val(sl, "showVal") !== void 0) out.dataLabels = bool(val(sl, "showVal"));
+      const labelCode = [kid(sl, "numFmt"), kid(kid(g, "dLbls"), "numFmt")].find((n) => n && n.getAttribute("sourceLinked") !== "1")?.getAttribute("formatCode");
+      const valueEl = kid(s, "val") ?? kid(s, "yVal");
+      const code = labelCode ?? formatCodeOf(valueEl);
+      if (code && code !== "General") out.format = { code };
+      const catEl = kid(s, "cat") ?? kid(s, "xVal");
+      const cats = strings(catEl);
+      if (type === "scatter" || type === "bubble") {
+        const xs = cats.map((c) => numberOf(c.trim()));
+        if (xs.some((x) => x !== null)) out.x = xs;
+      }
+      if (!categories.length && cats.length) categories = cats;
+      out.values = numbers(valueEl);
+      if (type === "bubble") out.sizes = numbers(kid(s, "bubbleSize"));
+      const dPts = kids(s, "dPt");
+      if (dPts.length) {
+        const pc = [];
+        for (const dp of dPts) {
+          const i = Number(val(dp, "idx"));
+          const c = solidColor(kid(dp, "spPr"));
+          if (Number.isInteger(i) && i >= 0 && i < MAX_POINTS && c) {
+            while (pc.length <= i) pc.push(null);
+            pc[i] = c;
+          }
+        }
+        if (pc.some(Boolean)) out.pointColors = pc;
+      }
+      const trends = [];
+      for (const t of kids(s, "trendline")) {
+        const kind = TREND_IN[val(t, "trendlineType") ?? ""];
+        if (!kind) continue;
+        const line = { type: kind };
+        const order = numberOf(val(t, "order"));
+        const period = numberOf(val(t, "period"));
+        if (kind === "polynomial" && order) line.order = order;
+        if (kind === "moving-average" && period) line.period = period;
+        for (const k of ["forward", "backward", "intercept"]) {
+          const n = numberOf(val(t, k));
+          if (n !== null && (k === "intercept" || n > 0)) line[k] = n;
+        }
+        if (bool(val(t, "dispEq"))) line.showEquation = true;
+        if (bool(val(t, "dispRSqr"))) line.showR2 = true;
+        const tName = kid(t, "name")?.textContent;
+        if (tName) line.name = tName;
+        const tc = solidColor(kid(t, "spPr"));
+        if (tc) line.color = tc;
+        trends.push(line);
+      }
+      if (trends.length) out.trendlines = trends;
+      if (kids(s, "errBars").length) unsupported.push("error bars");
+      series.push(out);
+    }
+  }
+  if (!types.length) {
+    issues.push({ path: "plotArea", message: unsupported.length ? `The chart type is not supported: ${unsupported.join(", ")}.` : "The chart has no plot groups." });
+    return { spec: normalizeChartSpec(input).spec, issues, unsupported, lossless: false };
+  }
+  const first = types[0];
+  const combo = types.some((t) => t !== first);
+  input.type = combo ? types.includes("bar") ? "bar" : first : first;
+  if (!combo) for (const s of series) delete s.type;
+  else for (const s of series) if (s.type === input.type) delete s.type;
+  if (!combo) {
+    for (const s of series) if (s.axis) issues.push({ path: "series", message: `"${s.name}" is on a second value axis.` });
+  }
+  if (types.some((t) => !isCartesianChart(t)) && combo) unsupported.push("a pie or radar mixed with other chart types");
+  input.series = series;
+  input.categories = categories.length ? categories : Array.from({ length: Math.max(0, ...series.map((s) => s.values.length)) }, (_, i) => `${i + 1}`);
+  input.stacking = stacking;
+  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)");
+  const readAxis = (a, fallback) => {
+    const axis = { ...fallback, format: {} };
+    if (!a) return axis;
+    axis.show = !bool(val(a, "delete"));
+    axis.title = richText(kid(a, "title")) ?? "";
+    axis.gridlines = !!kid(a, "majorGridlines");
+    const scaling = kid(a, "scaling");
+    axis.min = numberOf(val(scaling, "min"));
+    axis.max = numberOf(val(scaling, "max"));
+    if (val(scaling, "orientation") === "maxMin") unsupported.push("a reversed axis");
+    if (kid(scaling, "logBase")) unsupported.push("a logarithmic axis");
+    axis.step = numberOf(val(a, "majorUnit"));
+    const fmt = kid(a, "numFmt");
+    const code = fmt?.getAttribute("formatCode");
+    if (code && code !== "General" && fmt?.getAttribute("sourceLinked") !== "1") axis.format = { code };
+    return axis;
+  };
+  const xy = first === "scatter" || first === "bubble";
+  const catAxis = kid(plot, "catAx") ?? kid(plot, "dateAx") ?? (xy ? valAxes.find((a) => !vertical(a)) : void 0);
+  input.xAxis = readAxis(catAxis, defaultChartAxis(false));
+  if (kid(plot, "dateAx")) input.xAxis.kind = "date";
+  input.yAxis = readAxis(primaryAxis ?? valAxes.find(vertical) ?? valAxes[0], defaultChartAxis(true));
+  const secondaryAxis = valAxes.find((a) => a !== primaryAxis && (xy ? vertical(a) && a !== primaryAxis : true) && a !== catAxis);
+  if (series.some((s) => s.axis === "secondary") && secondaryAxis) input.yAxis2 = readAxis(secondaryAxis, defaultChartAxis(false));
+  const { spec, issues: specIssues } = normalizeChartSpec(input);
+  issues.push(...specIssues);
+  const uniq = [...new Set(unsupported)];
+  return { spec, issues, unsupported: uniq, lossless: uniq.length === 0 && specIssues.length === 0 };
+}
+function readChartex(root, issues, unsupported) {
+  const data = /* @__PURE__ */ new Map();
+  for (const d of kids(kid(root, "chartData"), "data")) {
+    const id = d.getAttribute("id") ?? String(data.size);
+    const strDim = kids(d, "strDim")[0];
+    const numDim = kids(d, "numDim")[0];
+    const lvl = (dim) => kids(dim, "lvl")[0];
+    const cats = kids(lvl(strDim), "pt").map((p) => p.textContent ?? "");
+    const values = [];
+    const nl = lvl(numDim);
+    for (const p of kids(nl, "pt")) {
+      const i = Number(p.getAttribute("idx") ?? values.length);
+      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 });
+  }
+  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 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 = [];
+  for (const s of seriesEls) {
+    if (s.getAttribute("layoutId") === "paretoLine") continue;
+    const ref = kid(s, "dataId")?.getAttribute("val") ?? "0";
+    const d = data.get(ref);
+    if (!d) continue;
+    if (!categories.length) categories = d.categories;
+    const out = { id: `series-${series.length + 1}`, name: strings(kid(s, "tx"))[0] ?? `Series ${series.length + 1}`, values: d.values };
+    if (d.code && d.code !== "General") out.format = { code: d.code };
+    series.push(out);
+  }
+  const title = richText(kid(chart, "title"));
+  const longest = Math.max(0, ...series.map((s) => s.values.length));
+  const input = {
+    type,
+    title: title ?? "",
+    series,
+    categories: categories.length >= longest ? categories : Array.from({ length: longest }, (_, i) => categories[i] ?? `${i + 1}`)
+  };
+  if (type === "waterfall") input.showTotal = false;
+  const { spec, issues: specIssues } = normalizeChartSpec(input);
+  issues.push(...specIssues);
+  return { spec, issues, unsupported, lossless: unsupported.length === 0 && specIssues.length === 0 };
+}
+var esc = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+var hex = (color) => {
+  if (!color) return null;
+  const rgb = parseChartColor(color);
+  return rgb ? chartRgbToHex(rgb).slice(1).toUpperCase() : null;
+};
+var fillXml = (color, line = false) => {
+  const h = hex(color);
+  if (!h) return "";
+  return line ? `<c:spPr><a:ln w="28575" cap="rnd"><a:solidFill><a:srgbClr val="${h}"/></a:solidFill><a:round/></a:ln></c:spPr>` : `<c:spPr><a:solidFill><a:srgbClr val="${h}"/></a:solidFill></c:spPr>`;
+};
+var rich = (text2) => `<c:tx><c:rich><a:bodyPr/><a:lstStyle/><a:p><a:r><a:t>${esc(text2)}</a:t></a:r></a:p></c:rich></c:tx><c:overlay val="0"/>`;
+var strLit = (items) => `<c:strLit><c:ptCount val="${items.length}"/>${items.map((s, i) => `<c:pt idx="${i}"><c:v>${esc(s)}</c:v></c:pt>`).join("")}</c:strLit>`;
+var numLit = (items, code = "General") => `<c:numLit><c:formatCode>${esc(code)}</c:formatCode><c:ptCount val="${items.length}"/>${items.map((v, i) => v === null || !Number.isFinite(v) ? "" : `<c:pt idx="${i}"><c:v>${v}</c:v></c:pt>`).join("")}</c:numLit>`;
+var CURRENCY_SYMBOL = { USD: "$", EUR: "\u20AC", GBP: "\xA3", JPY: "\xA5", CNY: "\xA5", INR: "\u20B9" };
+function chartFormatToCode(format) {
+  if (format.code) return format.code;
+  const d = format.decimals;
+  const frac = (n, fallback) => {
+    const k = n ?? fallback;
+    return k > 0 ? `.${"0".repeat(k)}` : "";
+  };
+  const wrap = (body) => `${format.prefix ? `"${format.prefix.replace(/"/g, "")}"` : ""}${body}${format.suffix ? `"${format.suffix.replace(/"/g, "")}"` : ""}`;
+  switch (format.style) {
+    case "percent":
+      return wrap(`#,##0${frac(d, 0)}%`);
+    case "currency": {
+      const code = (format.currency || "USD").toUpperCase();
+      const sym = CURRENCY_SYMBOL[code] ?? `${code} `;
+      return wrap(`"${sym}"#,##0${frac(d, 0)}`);
+    }
+    case "compact":
+      return wrap('#,##0.0,,"M"');
+    default:
+      return d !== void 0 || format.prefix || format.suffix ? wrap(`#,##0${frac(d, 0)}`) : "General";
+  }
+}
+var MARKER_OUT = { circle: "circle", square: "square", diamond: "diamond", triangle: "triangle", cross: "x", none: "none" };
+function chartToOoxml(spec) {
+  const issues = [];
+  const family = chartFamily(spec);
+  let type = spec.type;
+  if (family === "waterfall" || family === "histogram" || family === "box" || family === "funnel") {
+    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.");
+    type = "pie";
+  }
+  const visible = spec.series.filter((s) => !s.hidden);
+  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 };
+  const xy = family === "xy" || type === "scatter" || type === "bubble";
+  const pieLike = type === "pie" || type === "donut";
+  const typed = (s) => pieLike || type === "radar" ? type : type === "bubble" ? "bubble" : xy ? "scatter" : chartSeriesType({ type }, s);
+  const groups = [];
+  visible.forEach((s) => {
+    const kind = typed(s);
+    const secondary = !pieLike && s.axis === "secondary";
+    let g = groups.find((x) => x.kind === kind && x.secondary === secondary);
+    if (!g) groups.push(g = { kind, secondary, series: [] });
+    g.series.push({ s, index: spec.series.indexOf(s) });
+  });
+  if (pieLike && visible.length > 1) issues.push("Only the first series of a pie is drawn; the others are kept in the part.");
+  const catLit = strLit(spec.categories);
+  let order = 0;
+  const serXml = (kind, s, index) => {
+    const parts = [`<c:idx val="${index}"/>`, `<c:order val="${order++}"/>`, `<c:tx><c:v>${esc(s.name)}</c:v></c:tx>`];
+    const lineLike = kind === "line" || kind === "scatter" || kind === "radar";
+    parts.push(fillXml(s.color, lineLike));
+    if (kind === "bar" || kind === "bubble") parts.push('<c:invertIfNegative val="0"/>');
+    if (lineLike) {
+      const marker = s.marker ?? (spec.points || kind === "scatter" ? "circle" : "none");
+      parts.push(`<c:marker><c:symbol val="${MARKER_OUT[marker]}"/>${marker !== "none" ? '<c:size val="5"/>' : ""}</c:marker>`);
+    }
+    (s.pointColors ?? []).forEach((c, i) => {
+      const h = hex(c ?? void 0);
+      if (h) parts.push(`<c:dPt><c:idx val="${i}"/>${kind === "bar" ? '<c:invertIfNegative val="0"/>' : ""}<c:bubble3D val="0"/><c:spPr><a:solidFill><a:srgbClr val="${h}"/></a:solidFill></c:spPr></c:dPt>`);
+    });
+    const labels = s.dataLabels ?? spec.dataLabels;
+    const code = s.format ? chartFormatToCode(s.format) : void 0;
+    if (s.dataLabels !== void 0 || code)
+      parts.push(`<c:dLbls>${code ? `<c:numFmt formatCode="${esc(code)}" sourceLinked="0"/>` : ""}<c:showLegendKey val="0"/><c:showVal val="${labels ? 1 : 0}"/><c:showCatName val="0"/><c:showSerName val="0"/><c:showPercent val="0"/><c:showBubbleSize val="0"/></c:dLbls>`);
+    if (!pieLike && kind !== "radar")
+      for (const t of s.trendlines ?? []) {
+        let x = `<c:trendline>${t.name ? `<c:name>${esc(t.name)}</c:name>` : ""}${fillXml(t.color, true)}<c:trendlineType val="${TREND_OUT[t.type]}"/>`;
+        if (t.type === "polynomial") x += `<c:order val="${t.order ?? 2}"/>`;
+        if (t.type === "moving-average") x += `<c:period val="${t.period ?? 2}"/>`;
+        if (t.forward) x += `<c:forward val="${t.forward}"/>`;
+        if (t.backward) x += `<c:backward val="${t.backward}"/>`;
+        if (t.intercept !== void 0 && t.intercept !== null) x += `<c:intercept val="${t.intercept}"/>`;
+        x += `<c:dispRSqr val="${t.showR2 ? 1 : 0}"/><c:dispEq val="${t.showEquation ? 1 : 0}"/></c:trendline>`;
+        parts.push(x);
+      }
+    const valCode = chartFormatToCode(s.format ?? (s.axis === "secondary" ? spec.yAxis2.format : spec.yAxis.format));
+    if (kind === "scatter" || kind === "bubble") {
+      const xs = s.x ?? spec.categories.map((_, i) => i + 1);
+      parts.push(`<c:xVal>${numLit(xs)}</c:xVal><c:yVal>${numLit(s.values, valCode)}</c:yVal>`);
+      if (kind === "bubble") parts.push(`<c:bubbleSize>${numLit(s.sizes ?? s.values.map(() => 1))}</c:bubbleSize><c:bubble3D val="0"/>`);
+      else parts.push(`<c:smooth val="${(s.curve ?? spec.curve) === "smooth" ? 1 : 0}"/>`);
+    } else {
+      parts.push(`<c:cat>${catLit}</c:cat><c:val>${numLit(s.values, valCode)}</c:val>`);
+      if (kind === "line") parts.push(`<c:smooth val="${(s.curve ?? spec.curve) === "smooth" ? 1 : 0}"/>`);
+    }
+    if ((s.curve ?? spec.curve) === "step" && lineLike) issues.push(`"${s.name}" uses step lines, which DrawingML cannot express; they are written straight.`);
+    if ((s.curve ?? spec.curve) === "smooth" && kind === "area") issues.push(`"${s.name}" is a smoothed area, which DrawingML cannot express; it is written straight.`);
+    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 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("");
+    switch (g.kind) {
+      case "bar": {
+        const n = g.series.length;
+        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>`;
+      }
+      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>`;
+      case "area":
+        return `<c:areaChart><c:grouping val="${grouping}"/><c:varyColors val="0"/>${sers}${dLbls}${axes2}</c:areaChart>`;
+      case "scatter":
+        return `<c:scatterChart><c:scatterStyle val="lineMarker"/><c:varyColors val="0"/>${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":
+        return `<c:radarChart><c:radarStyle val="marker"/><c:varyColors val="0"/>${sers}${dLbls}${axes2}</c:radarChart>`;
+      case "donut":
+        return `<c:doughnutChart><c:varyColors val="1"/>${sers}${dLbls}<c:firstSliceAng val="0"/><c:holeSize val="${Math.round(Math.max(10, Math.min(90, spec.innerRadius * 100)))}"/></c:doughnutChart>`;
+      default:
+        return `<c:pieChart><c:varyColors val="1"/>${sers}${dLbls}<c:firstSliceAng val="0"/></c:pieChart>`;
+    }
+  });
+  const scaling = (a) => `<c:scaling><c:orientation val="minMax"/>${a.max !== null ? `<c:max val="${a.max}"/>` : ""}${a.min !== null ? `<c:min val="${a.min}"/>` : ""}</c:scaling>`;
+  const title = (a) => a.title ? `<c:title>${rich(a.title)}</c:title>` : "";
+  const fmt = (a) => {
+    const code = chartFormatToCode(a.format);
+    return code !== "General" ? `<c:numFmt formatCode="${esc(code)}" sourceLinked="0"/>` : `<c:numFmt formatCode="${spec.stacking === "percent" ? "0%" : "General"}" sourceLinked="1"/>`;
+  };
+  const horizontal = spec.orientation === "horizontal";
+  const catPos = horizontal ? "l" : "b";
+  const valPos = horizontal ? "b" : "l";
+  const valAx = (id, cross, a, pos, crosses, catKind = false) => `<c:valAx><c:axId val="${id}"/>${scaling(a)}<c:delete val="${a.show ? 0 : 1}"/><c:axPos val="${pos}"/>${a.gridlines ? "<c:majorGridlines/>" : ""}${title(a)}${fmt(a)}<c:majorTickMark val="out"/><c:minorTickMark val="none"/><c:tickLblPos val="nextTo"/><c:crossAx val="${cross}"/><c:crosses val="${crosses}"/><c:crossBetween val="${catKind ? "midCat" : "between"}"/>${a.step ? `<c:majorUnit val="${a.step}"/>` : ""}</c:valAx>`;
+  const catAx = (id, cross, a, pos, hidden = false) => `<c:${a.kind === "date" ? "dateAx" : "catAx"}><c:axId val="${id}"/><c:scaling><c:orientation val="minMax"/></c:scaling><c:delete val="${a.show && !hidden ? 0 : 1}"/><c:axPos val="${pos}"/>${a.gridlines ? "<c:majorGridlines/>" : ""}${title(a)}<c:numFmt formatCode="General" sourceLinked="1"/><c:majorTickMark val="out"/><c:minorTickMark val="none"/><c:tickLblPos val="nextTo"/><c:crossAx val="${cross}"/><c:crosses val="autoZero"/><c:auto val="1"/>${a.kind === "date" ? '<c:lblOffset val="100"/><c:baseTimeUnit val="days"/>' : '<c:lblAlgn val="ctr"/><c:lblOffset val="100"/><c:noMultiLvlLbl val="0"/>'}</c:${a.kind === "date" ? "dateAx" : "catAx"}>`;
+  let axes = "";
+  if (!pieLike) {
+    if (xy) axes = valAx(ids.cat, ids.val, spec.xAxis, "b", "autoZero", true) + valAx(ids.val, ids.cat, spec.yAxis, "l", "autoZero", true);
+    else axes = catAx(ids.cat, ids.val, spec.xAxis, catPos) + valAx(ids.val, ids.cat, spec.yAxis, valPos, "autoZero");
+    if (groups.some((g) => g.secondary)) axes += catAx(ids.cat2, ids.val2, spec.xAxis, catPos, true) + valAx(ids.val2, ids.cat2, spec.yAxis2, horizontal ? "t" : "r", "max");
+  }
+  const legendPos = { bottom: "b", top: "t", left: "l", right: "r" }[spec.legend.position];
+  const legend = spec.legend.show ? `<c:legend><c:legendPos val="${legendPos}"/><c:overlay val="0"/></c:legend>` : "";
+  const titleXml = spec.title ? `<c:title>${rich(spec.title)}</c:title><c:autoTitleDeleted val="0"/>` : '<c:autoTitleDeleted val="1"/>';
+  if (spec.subtitle) issues.push("The subtitle is left out: DrawingML charts have one title.");
+  if (family === "radar" && spec.series.some((s) => s.trendlines?.length)) issues.push("Trendlines on a radar chart are left out.");
+  const xml = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?><c:chartSpace xmlns:c="${CHART_OOXML_NS}" xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships"><c:roundedCorners val="0"/><c:chart>${titleXml}<c:plotArea><c:layout/>${groupXml.join("")}${axes}</c:plotArea>${legend}<c:plotVisOnly val="1"/><c:dispBlanksAs val="gap"/></c:chart><c:txPr><a:bodyPr/><a:lstStyle/><a:p><a:pPr><a:defRPr sz="${Math.round(10 * 100)}"/></a:pPr><a:endParaRPr lang="en-US"/></a:p></c:txPr></c:chartSpace>`;
+  return { xml, issues: [...new Set(issues)] };
+}
+
+export {
+  parseChartColor,
+  chartRgbToHex,
+  shadeChartColor,
+  CHART_PALETTE_SHADES,
+  cyclePaletteColor,
+  chartLuminance,
+  chartContrastRatio,
+  chartTextOn,
+  chartRgbToOklab,
+  chartColorDistance,
+  simulateChartVision,
+  checkChartColors,
+  CHART_TYPES,
+  CHART_MARKERS,
+  CHART_TRENDLINE_TYPES,
+  CHART_LABEL_POSITIONS,
+  CHART_AXIS_KINDS,
+  CHART_SERIES_TYPES,
+  CHART_STACKINGS,
+  CHART_CURVES,
+  CHART_ORIENTATIONS,
+  CHART_LEGEND_POSITIONS,
+  CHART_NUMBER_STYLES,
+  CHART_TYPE_LABELS,
+  DEFAULT_CHART_PALETTE,
+  DEFAULT_CHART_THEME,
+  CSS_VARIABLE_CHART_THEME,
+  isCartesianChart,
+  isXyChart,
+  chartFamily,
+  chartColorsByCategory,
+  defaultChartAxis,
+  createChartSpec,
+  chartSeriesColor,
+  chartSliceColor,
+  chartPointColor,
+  chartSeriesType,
+  uniqueChartSeriesId,
+  parseChartValue,
+  normalizeChartAxis,
+  normalizeChartValues,
+  normalizeChartTrendline,
+  normalizeChartSpec,
+  cloneChartSpec,
+  cloneChartSeries,
+  chartDataFromTable,
+  chartDataToTable,
+  chartColorInputValue,
+  CHART_OOXML_NS,
+  CHART_OOXML_CONTENT_TYPE,
+  CHART_OOXML_RELATIONSHIP,
+  chartFromOoxml,
+  chartFormatToCode,
+  chartToOoxml
+};
+//# sourceMappingURL=chunk-C3NWJE3K.js.map