@pixerate/editor 0.164.0 → 0.165.0

package/dist/{chunk-3NEZJCBY.js → chunk-2ZRN43IN.js}

@@ -1,10 +1,12 @@
 import {
   simulateColorVision
-} from "./chunk-QYZGBVNC.js";
+} from "./chunk-7272D3K2.js";
+import {
+  deltaEOK
+} from "./chunk-YBAPT7NL.js";
 import {
-  deltaEOK,
   rgbToOklab
-} from "./chunk-4VU4CP7R.js";
+} from "./chunk-MHLU6GRJ.js";
 
 // src/chart/color.ts
 var NAMED = {
@@ -223,8 +225,208 @@ function parseChartAmountList(text2) {
   return text2.split(/[;,\s]+/).filter((t) => t !== "").map((t) => t === "-" ? null : t);
 }
 
+// src/chart/tree.ts
+var MAX_CHART_TREE_DEPTH = 6;
+var MAX_CHART_TREE_NODES = 5e3;
+var isRecord = (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 (!isRecord(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) : 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 = list?.find((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: 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 = 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 }));
+}
+
 // src/chart/spec.ts
-var CHART_TYPES = ["bar", "line", "area", "scatter", "bubble", "pie", "donut", "radar", "waterfall", "histogram", "box", "funnel", "treemap", "sunburst", "slope", "likert", "parliament"];
+var CHART_TYPES = ["bar", "line", "area", "scatter", "bubble", "pie", "donut", "radar", "waterfall", "histogram", "box", "funnel", "treemap", "sunburst", "sankey", "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"];
@@ -236,6 +438,7 @@ 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_SANKEY_LINK_COLORS = ["source", "target", "gray"];
 var CHART_REFERENCE_AXES = ["y", "y2", "x"];
 var CHART_ORIENTATIONS = ["vertical", "horizontal"];
 var CHART_LEGEND_POSITIONS = ["top", "bottom", "left", "right"];
@@ -257,7 +460,8 @@ var CHART_TYPE_LABELS = {
   slope: "Slope",
   likert: "Likert",
   parliament: "Parliament",
-  sunburst: "Sunburst"
+  sunburst: "Sunburst",
+  sankey: "Sankey"
 };
 var DEFAULT_CHART_PALETTE = ["#4269d0", "#efb118", "#ff725c", "#6cc5b0", "#3ca951", "#ff8ab7", "#a463f2", "#97bbf5", "#9c6b4e", "#9498a0"];
 var DEFAULT_CHART_THEME = {
@@ -308,6 +512,7 @@ function chartFamily(spec) {
     case "likert":
     case "parliament":
     case "sunburst":
+    case "sankey":
       return spec.type;
     case "bubble":
       return "xy";
@@ -316,7 +521,7 @@ function chartFamily(spec) {
   }
 }
 function chartColorsByCategory(type) {
-  return type === "pie" || type === "donut" || type === "funnel" || type === "treemap" || type === "slope" || type === "parliament" || type === "sunburst";
+  return type === "pie" || type === "donut" || type === "funnel" || type === "treemap" || type === "slope" || type === "parliament" || type === "sunburst" || type === "sankey";
 }
 function chartSpecColorsByCategory(spec) {
   return chartColorsByCategory(spec.type) || chartVariesColors(spec);
@@ -390,7 +595,7 @@ function parseChartValue(input) {
   if (negative) value = -value;
   return Number.isFinite(value) ? value : void 0;
 }
-var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 function pick(value, options, fallback, path, issues) {
   if (value === void 0) return fallback;
   if (typeof value === "string" && options.includes(value)) return value;
@@ -419,7 +624,7 @@ function bound(value, path, issues) {
 }
 function normalizeFormat(value, path, issues) {
   if (value === void 0 || value === null) return {};
-  if (!isRecord(value)) {
+  if (!isRecord2(value)) {
     issues.push({ path, message: `${path} must be an object.` });
     return {};
   }
@@ -437,7 +642,7 @@ function normalizeFormat(value, path, issues) {
 }
 function normalizeChartAxis(value, fallback, path, issues = []) {
   if (value === void 0) return { ...fallback, format: { ...fallback.format } };
-  if (!isRecord(value)) {
+  if (!isRecord2(value)) {
     issues.push({ path, message: `${path} must be an object.` });
     return { ...fallback, format: { ...fallback.format } };
   }
@@ -487,7 +692,7 @@ function normalizeChartAxis(value, fallback, path, issues = []) {
 function normalizeLegend(value, issues) {
   const fallback = { show: true, position: "bottom" };
   if (value === void 0) return fallback;
-  if (!isRecord(value)) {
+  if (!isRecord2(value)) {
     issues.push({ path: "legend", message: "legend must be an object." });
     return fallback;
   }
@@ -517,7 +722,7 @@ function normalizeChartValues(value, length, path, issues = []) {
 }
 function normalizeSeries(value, length, used, index, issues) {
   const path = `series[${index}]`;
-  if (!isRecord(value)) {
+  if (!isRecord2(value)) {
     issues.push({ path, message: `${path} must be an object with a name and values.` });
     return null;
   }
@@ -607,7 +812,7 @@ var finiteNumber = (value) => {
   return typeof n === "number" && Number.isFinite(n) ? n : null;
 };
 function normalizeChartReferenceLine(value, path, issues = []) {
-  if (!isRecord(value)) {
+  if (!isRecord2(value)) {
     issues.push({ path, message: `${path} must be an object with a value, e.g. {"value": 100, "label": "Target"}.` });
     return null;
   }
@@ -620,7 +825,7 @@ function normalizeChartReferenceLine(value, path, issues = []) {
   return { value: at, ...referenceCommon(value, path, issues) };
 }
 function normalizeChartReferenceBand(value, path, issues = []) {
-  if (!isRecord(value)) {
+  if (!isRecord2(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;
   }
@@ -634,7 +839,7 @@ function normalizeChartReferenceBand(value, path, issues = []) {
   return { from: Math.min(from, to), to: Math.max(from, to), ...referenceCommon(value, path, issues) };
 }
 function normalizeChartErrorBars(value, length, path, issues = []) {
-  if (!isRecord(value)) {
+  if (!isRecord2(value)) {
     issues.push({ path, message: `${path} must be an object with a type (${CHART_ERROR_BAR_TYPES.join(", ")}), or null for none.` });
     return null;
   }
@@ -667,7 +872,7 @@ function normalizeChartErrorBars(value, length, path, issues = []) {
   return issues.length > before ? null : bars;
 }
 function normalizeChartTrendline(value, path, issues = []) {
-  if (!isRecord(value)) {
+  if (!isRecord2(value)) {
     issues.push({ path, message: `${path} must be an object with a type.` });
     return null;
   }
@@ -706,8 +911,8 @@ function normalizeChartTrendline(value, path, issues = []) {
 }
 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 value = isRecord2(input) ? input : {};
+  if (input !== void 0 && !isRecord2(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." });
@@ -715,16 +920,21 @@ function normalizeChartSpec(input) {
   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);
+    const longest = rawSeries.reduce((n, s) => Math.max(n, isRecord2(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 links = normalizeChartLinks(value.links, issues);
+  const sankeyNodes = chartSankeyNodes(links, Array.isArray(value.sankeyNodes) ? value.sankeyNodes.map(String) : [], issues);
+  if (value.sankeyNodes !== void 0 && value.sankeyNodes !== null && !Array.isArray(value.sankeyNodes)) issues.push({ path: "sankeyNodes", message: "sankeyNodes must be an array of node names." });
+  if (tree.length && links.length) issues.push({ path: "links", message: "A chart holds either grouped data (tree) or flows (links), not both; the flows were used." });
+  if (links.length) categories = [...sankeyNodes];
+  else 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 (tree.length || links.length) {
     if (!series.length) series.push({ id: uniqueChartSeriesId(series), name: "Values", values: [] });
-    series[0] = { ...series[0], values: tree.map(chartTreeTotal) };
+    series[0] = { ...series[0], values: links.length ? chartSankeyNodeValues(links, sankeyNodes) : tree.map(chartTreeTotal) };
   }
   let palette = [...DEFAULT_CHART_PALETTE];
   if (Array.isArray(value.palette)) {
@@ -815,8 +1025,11 @@ function normalizeChartSpec(input) {
     parliamentArc: fraction("parliamentArc", 180, 90, 360),
     parliamentMajority,
     parliamentLabel: text(value.parliamentLabel, "", "parliamentLabel", issues),
-    tree,
-    sunburstLabel: text(value.sunburstLabel, "", "sunburstLabel", issues)
+    tree: links.length ? [] : tree,
+    sunburstLabel: text(value.sunburstLabel, "", "sunburstLabel", issues),
+    links,
+    sankeyNodes: links.length ? sankeyNodes : [],
+    sankeyLinkColor: pick(value.sankeyLinkColor, CHART_SANKEY_LINK_COLORS, "source", "sankeyLinkColor", issues)
   };
   if (spec.stacking === "percent")
     for (const name of ["yAxis", "yAxis2"]) {
@@ -840,7 +1053,9 @@ function cloneChartSpec(spec) {
     highlight: [...spec.highlight],
     referenceLines: spec.referenceLines.map((l) => ({ ...l })),
     referenceBands: spec.referenceBands.map((b) => ({ ...b })),
-    tree: cloneChartTree(spec.tree)
+    tree: cloneChartTree(spec.tree),
+    links: spec.links.map((l) => ({ ...l })),
+    sankeyNodes: [...spec.sankeyNodes]
   };
 }
 function cloneChartSeries(series) {
@@ -909,204 +1124,120 @@ 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") {
+// src/chart/links.ts
+var MAX_CHART_LINKS = 2e3;
+var isRecord3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var nameOf = (value) => typeof value === "number" ? String(value) : typeof value === "string" ? value.trim() : "";
+function normalizeChartLinks(value, issues = [], path = "links") {
   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}]}.` });
+    issues.push({ path, message: `${path} must be an array of flows such as {"source": "Website", "target": "Signup", "value": 120}.` });
     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) : 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 = list?.find((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: n.value ?? 0 });
+  const seen = /* @__PURE__ */ new Set();
+  const next = /* @__PURE__ */ new Map();
+  const reaches = (to, from) => {
+    const stack = [to];
+    const visited = /* @__PURE__ */ new Set();
+    while (stack.length) {
+      const n = stack.pop();
+      if (n === from) return true;
+      if (visited.has(n)) continue;
+      visited.add(n);
+      for (const m of next.get(n) ?? []) stack.push(m);
     }
+    return false;
   };
-  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);
+  value.forEach((raw, i) => {
+    const where = `${path}[${i}]`;
+    if (out.length >= MAX_CHART_LINKS) {
+      if (out.length === MAX_CHART_LINKS && i === MAX_CHART_LINKS) issues.push({ path, message: `There are more than ${MAX_CHART_LINKS} flows; the rest were left out.` });
+      return;
     }
-    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.` });
+    if (!isRecord3(raw)) {
+      issues.push({ path: where, message: `${where} must be an object with source, target and value.` });
       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.` });
+    for (const k of Object.keys(raw)) if (!["source", "target", "value", "color"].includes(k)) issues.push({ path: `${where}.${k}`, message: `${where} has no "${k}"; a flow takes source, target, value and color.` });
+    const source = nameOf(raw.source);
+    const target = nameOf(raw.target);
+    if (!source || !target) {
+      issues.push({ path: where, message: `${where} needs a source and a target (node names).` });
+      return;
     }
-    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;
+    if (source === target) {
+      issues.push({ path: where, message: `${where} goes from "${source}" to itself; a flow must join two different nodes.` });
+      return;
+    }
+    const v = parseChartValue(raw.value);
+    if (!(typeof v === "number" && v > 0)) {
+      issues.push({ path: `${where}.value`, message: `The flow from "${source}" to "${target}" needs a value above 0; got ${JSON.stringify(raw.value)}.` });
+      return;
+    }
+    const key2 = `${source}\0${target}`;
+    if (seen.has(key2)) {
+      issues.push({ path: where, message: `The flow from "${source}" to "${target}" appears twice; add the values into one flow. The second was left out.` });
+      return;
     }
+    if (reaches(target, source)) {
+      issues.push({ path: where, message: `The flow from "${source}" to "${target}" would close a loop (${target} already leads back to ${source}); flows must only go forwards, so it was left out.` });
+      return;
+    }
+    seen.add(key2);
+    if (!next.has(source)) next.set(source, /* @__PURE__ */ new Set());
+    next.get(source).add(target);
+    const link = { source, target, value: v };
+    if (typeof raw.color === "string" && raw.color.trim()) link.color = raw.color.trim();
+    out.push(link);
   });
-  return tree;
+  return out;
 }
-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 = 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);
+function chartSankeyNodes(links, order = [], issues = []) {
+  const used = /* @__PURE__ */ new Set();
+  const named = [];
+  for (const l of links)
+    for (const n of [l.source, l.target])
+      if (!used.has(n)) {
+        used.add(n);
+        named.push(n);
       }
-      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 });
-  });
+  for (const n of order) {
+    if (!used.has(n)) {
+      if (links.length) issues.push({ path: "sankeyNodes", message: `sankeyNodes names "${n}", which no flow uses; it was left out.` });
+      continue;
+    }
+    if (!out.includes(n)) out.push(n);
+  }
+  for (const n of named) if (!out.includes(n)) out.push(n);
   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 chartSankeyNodeValues(links, nodes) {
+  const inflow = /* @__PURE__ */ new Map();
+  const outflow = /* @__PURE__ */ new Map();
+  for (const l of links) {
+    outflow.set(l.source, (outflow.get(l.source) ?? 0) + l.value);
+    inflow.set(l.target, (inflow.get(l.target) ?? 0) + l.value);
+  }
+  return nodes.map((n) => Math.max(inflow.get(n) ?? 0, outflow.get(n) ?? 0));
 }
-function setChartTreeRowValue(rows, row, value) {
-  return rows.map((r, i) => ({ path: [...r.path], value: i === row ? value : r.value }));
+function chartLinksFromTable(rows, options = {}) {
+  const grid = rows.filter((r) => r.some((c) => c !== null && c !== void 0 && String(c).trim() !== ""));
+  if (!grid.length) return [];
+  const header = options.header ?? "auto";
+  const skip = header === true || header === "auto" && typeof parseChartValue(grid[0][2]) !== "number";
+  return (skip ? grid.slice(1) : grid).map((r) => ({ source: r[0], target: r[1], value: r[2] }));
 }
-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 setChartLinkField(links, index, field, text2) {
+  return links.map((l, i) => i === index ? { ...l, [field]: field === "value" ? text2 : text2.trim() } : { ...l });
 }
-function removeChartTreeRow(rows, row) {
-  return rows.filter((_, i) => i !== row).map((r) => ({ path: [...r.path], value: r.value }));
+function addChartLink(links) {
+  const last = links[links.length - 1];
+  const names = new Set(links.flatMap((l) => [l.source, l.target]));
+  let n = names.size + 1;
+  while (names.has(`Step ${n}`)) n++;
+  return [...links.map((l) => ({ ...l })), { source: last?.target ?? "Start", target: `Step ${n}`, value: last?.value ?? 1 }];
 }
 
 export {
@@ -1131,6 +1262,13 @@ export {
   chartErrorBarsOfType,
   formatChartAmountList,
   parseChartAmountList,
+  MAX_CHART_LINKS,
+  normalizeChartLinks,
+  chartSankeyNodes,
+  chartSankeyNodeValues,
+  chartLinksFromTable,
+  setChartLinkField,
+  addChartLink,
   MAX_CHART_TREE_DEPTH,
   MAX_CHART_TREE_NODES,
   normalizeChartTree,
@@ -1159,6 +1297,7 @@ export {
   CHART_RADAR_GRATICULES,
   CHART_LIKERT_NEUTRALS,
   CHART_LIKERT_SORTS,
+  CHART_SANKEY_LINK_COLORS,
   CHART_REFERENCE_AXES,
   CHART_ORIENTATIONS,
   CHART_LEGEND_POSITIONS,