@pixerate/editor 0.164.0 → 0.166.0

package/dist/{chunk-SDHZG5TF.js → chunk-ILP77UD6.js}

@@ -1,10 +1,14 @@
 import {
   defineEditorDocument
-} from "./chunk-NHLYK3AX.js";
+} from "./chunk-XBQX76CT.js";
 import {
   hexToRgba,
   normalizeTokenColor
 } from "./chunk-2WPNAGHI.js";
+import {
+  contrastRatio,
+  parseColor
+} from "./chunk-MHLU6GRJ.js";
 
 // src/tokens/types.ts
 var TOKEN_TYPES = ["color", "number", "string", "boolean"];
@@ -1307,6 +1311,157 @@ function createTokensEditorDocument(store) {
   });
 }
 
+// src/tokens/style.ts
+function findVariable(state, ref) {
+  return getTokenVariable(state, ref) ?? findTokenVariable(state, ref);
+}
+function createTokenStyleSource(store) {
+  return {
+    resolve({ token, mode }) {
+      const state = store.getState();
+      const variable = findVariable(state, token);
+      if (!variable) return { ok: false, message: `there is no design token "${token}".` };
+      let modes;
+      if (mode !== void 0) {
+        const collection = getTokenCollection(state, variable.collectionId);
+        const found = findTokenMode(collection, mode);
+        if (!found) return { ok: false, message: `"${collection.name}" has no mode "${mode}"; its modes are ${collection.modes.map((m) => `"${m.name}"`).join(", ")}.` };
+        modes = { [collection.id]: found.id };
+      }
+      const resolved = resolveToken(state, variable.id, modes);
+      return resolved.ok ? { ok: true, value: resolved.value } : { ok: false, message: `"${token}" does not resolve: ${resolved.message}` };
+    },
+    subscribe: (listener) => store.subscribe(() => listener())
+  };
+}
+var profileOf = (profile) => profile;
+var requiredVariables = {
+  id: "required-variables",
+  description: `Every variable named in the profile's "required" list exists.`,
+  run(state, profile) {
+    const required = profileOf(profile).required;
+    if (!required?.length) throw new Error('the profile has no "required" list.');
+    return required.filter((name) => !findVariable(state, name)).map((name) => ({ severity: "error", message: `The token set has no variable "${name}"; add it (house style requires it).`, target: { variable: name } }));
+  }
+};
+var namePattern = {
+  id: "name-pattern",
+  description: `Every variable name matches the profile's "namePattern" regular expression.`,
+  run(state, profile) {
+    const pattern = profileOf(profile).namePattern;
+    if (!pattern) throw new Error('the profile has no "namePattern".');
+    let re;
+    try {
+      re = new RegExp(pattern);
+    } catch {
+      throw new Error(`"namePattern" ${pattern} is not a valid regular expression.`);
+    }
+    return state.variables.filter((v) => !re.test(v.name)).map((v) => ({ severity: "warning", message: `Variable "${v.name}" does not match the naming pattern ${pattern}; rename it.`, target: { variableId: v.id } }));
+  }
+};
+var requiredModes = {
+  id: "required-modes",
+  description: `Every collection has the modes named in the profile's "modes" list (e.g. Light and Dark).`,
+  run(state, profile) {
+    const modes = profileOf(profile).modes;
+    if (!modes?.length) throw new Error('the profile has no "modes" list.');
+    return state.collections.flatMap(
+      (c) => modes.filter((m) => !findTokenMode(c, m)).map((m) => ({ severity: "error", message: `Collection "${c.name}" has no "${m}" mode; add it.`, target: { collectionId: c.id } }))
+    );
+  }
+};
+var contrastPairs = {
+  id: "contrast-pairs",
+  description: `Each foreground / background pair in "contrastPairs" reaches its contrast ratio (default 4.5) in every mode of the foreground's collection.`,
+  run(state, profile) {
+    const pairs = profileOf(profile).contrastPairs;
+    if (!pairs?.length) throw new Error('the profile has no "contrastPairs".');
+    const findings = [];
+    for (const { fg, bg, ratio = 4.5 } of pairs) {
+      const f = findVariable(state, fg);
+      const b = findVariable(state, bg);
+      if (!f || !b) {
+        findings.push({ severity: "error", message: `Contrast pair ${fg} on ${bg} names a variable the token set lacks (${!f ? fg : bg}).`, target: { variable: !f ? fg : bg } });
+        continue;
+      }
+      const collection = getTokenCollection(state, f.collectionId);
+      for (const mode of collection.modes) {
+        const modes = { [collection.id]: mode.id, [b.collectionId]: findTokenMode(getTokenCollection(state, b.collectionId), mode.name)?.id ?? mode.id };
+        const fv = resolveToken(state, f.id, modes);
+        const bv = resolveToken(state, b.id, modes);
+        const fc = fv.ok && typeof fv.value === "string" ? parseColor(fv.value) : null;
+        const bc = bv.ok && typeof bv.value === "string" ? parseColor(bv.value) : null;
+        if (!fc || !bc) continue;
+        const r = contrastRatio(fc, bc);
+        if (r < ratio) {
+          findings.push({
+            severity: "error",
+            message: `${f.name} on ${b.name} has contrast ${Math.round(r * 100) / 100}:1 in ${mode.name}; want at least ${ratio}:1, so darken or lighten one of them in that mode.`,
+            target: { variableId: f.id, modeId: mode.id }
+          });
+        }
+      }
+    }
+    return findings;
+  }
+};
+var tokensStyleDomain = {
+  id: "tokens",
+  title: "Design tokens",
+  description: "Rules for the token set itself: variables that must exist, a naming pattern, required modes and colour pairs that must reach a contrast ratio.",
+  profileSchema: {
+    type: "object",
+    properties: {
+      required: { type: "array", items: { type: "string", minLength: 1 }, description: 'Variable names that must exist, e.g. "brand/primary".' },
+      namePattern: { type: "string", minLength: 1, description: 'Regular expression every variable name must match, e.g. "^[a-z0-9-]+(/[a-z0-9-]+)*$".' },
+      modes: { type: "array", items: { type: "string", minLength: 1 }, description: 'Mode names every collection must have, e.g. ["Light", "Dark"].' },
+      contrastPairs: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            fg: { type: "string", minLength: 1, description: "Foreground variable name or id." },
+            bg: { type: "string", minLength: 1, description: "Background variable name or id." },
+            ratio: { type: "number", minimum: 1, maximum: 21, description: "Smallest contrast ratio (default 4.5, WCAG AA for text)." }
+          },
+          required: ["fg", "bg"],
+          additionalProperties: false
+        },
+        description: "Colour pairs checked in every mode."
+      }
+    },
+    additionalProperties: false
+  },
+  checks: [requiredVariables, namePattern, requiredModes, contrastPairs]
+};
+function createTokensStyleToolProvider(store, styles, options = {}) {
+  if (!styles.domains.some((d) => d.id === "tokens")) throw new Error('The style resolver has no "tokens" domain; add tokensStyleDomain to its domains.');
+  const check = {
+    name: "check_tokens_style",
+    title: "Check token house style",
+    description: 'Checks the design-token set against the house style (see get_style with domain "tokens"): runs the checks its profile turns on (required-variables, name-pattern, required-modes, contrast-pairs). Returns findings with a severity, a sentence saying how to fix it, a target (variable id or name, mode id, collection id) and the layer that asked for it; plus the checks that ran and the ones skipped with the reason. Fix findings with get_tokens_document / load_tokens_document, then check again.',
+    inputSchema: { type: "object", properties: {}, additionalProperties: false },
+    annotations: { title: "Check token house style", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    handler: async () => {
+      const { style, ...report } = await styles.check("tokens", store.getState());
+      return {
+        ...report,
+        ok: report.findings.length === 0,
+        ...style.skills.length ? {} : { note: "No house style applies to design tokens." },
+        ...style.issues.length ? { issues: style.issues } : {}
+      };
+    }
+  };
+  return {
+    id: options.id ?? "tokens-style",
+    namespace: options.namespace ?? "tokens",
+    title: "Token house style",
+    description: "Check the design-token set against the house style.",
+    skill: "pixerate-tokens",
+    tools: [check]
+  };
+}
+
 export {
   TOKEN_TYPES,
   TokenError,
@@ -1360,5 +1515,8 @@ export {
   exportW3CTokens,
   exportW3CTokensJson,
   importW3CTokens,
-  createTokensEditorDocument
+  createTokensEditorDocument,
+  createTokenStyleSource,
+  tokensStyleDomain,
+  createTokensStyleToolProvider
 };

package/dist/{chunk-Z4P2RBMJ.js → chunk-ITANXMZD.js}

@@ -12,7 +12,7 @@ import {
   chartTreeTotal,
   chartVariesColors,
   shadeChartColor
-} from "./chunk-3NEZJCBY.js";
+} from "./chunk-FR432ROA.js";
 import {
   NumberFormat
 } from "./chunk-II2WIF5Z.js";
@@ -948,7 +948,7 @@ function drawCallouts(ctx, plot) {
   }
   if (unplaced) ctx.warn("annotations-skipped", `${unplaced} callout${unplaced === 1 ? " points" : "s point"} at a gap or a hidden value and ${unplaced === 1 ? "is" : "are"} not drawn.`);
 }
-var MUTED = /* @__PURE__ */ new Set(["bar", "line", "area", "point", "slice", "cell", "box", "whisker", "outlier", "connector", "trendline", "trendline-label", "error-bar", "data-label", "legend-swatch", "legend-label"]);
+var MUTED = /* @__PURE__ */ new Set(["node", "bar", "line", "area", "point", "slice", "cell", "box", "whisker", "outlier", "connector", "trendline", "trendline-label", "error-bar", "data-label", "legend-swatch", "legend-label"]);
 function applyHighlight(ctx) {
   const { spec, marks } = ctx;
   if (!spec.highlight.length) return;
@@ -1677,6 +1677,38 @@ function trendlineLegendItems(spec, color) {
   );
 }
 
+// src/chart/race.ts
+function chartRaceValueAt(series, index) {
+  for (let i = Math.min(index, series.values.length - 1); i >= 0; i--) {
+    const v = series.values[i];
+    if (v !== null && v !== void 0 && Number.isFinite(v)) return v;
+  }
+  return 0;
+}
+function chartRaceMoment(count, frame) {
+  const last = Math.max(0, count - 1);
+  const at = frame === null || frame === void 0 || !Number.isFinite(frame) ? last : Math.max(0, Math.min(last, frame));
+  const from = Math.floor(at);
+  const to = Math.min(last, from + 1);
+  return { from, to, t: at - from, at };
+}
+function chartRaceRanking(spec, frame) {
+  const visible = spec.series.filter((s) => !s.hidden);
+  const { from, to, t } = chartRaceMoment(spec.categories.length, frame);
+  const rankAt = (i) => {
+    const order2 = visible.map((s, k) => ({ id: s.id, v: chartRaceValueAt(s, i), k })).sort((a, b) => b.v - a.v || a.k - b.k);
+    return new Map(order2.map((o, r) => [o.id, r]));
+  };
+  const r0 = rankAt(from);
+  const r1 = rankAt(to);
+  const near = t < 0.5 ? r0 : r1;
+  return visible.map((s) => {
+    const a = chartRaceValueAt(s, from);
+    const b = chartRaceValueAt(s, to);
+    return { seriesId: s.id, name: s.name, value: a + (b - a) * t, position: r0.get(s.id) + (r1.get(s.id) - r0.get(s.id)) * t, rank: near.get(s.id) };
+  }).sort((a, b) => a.position - b.position || b.value - a.value);
+}
+
 // src/chart/layout-families.ts
 var sliceColor = (ctx, series, i) => series.pointColors?.[i] || chartSliceColor(ctx.spec, i);
 function layoutPie(ctx, area, series) {
@@ -2349,11 +2381,142 @@ function layoutSunburst(ctx, area, series) {
   }
   return { plot };
 }
+function layoutSankey(ctx, area, series) {
+  const { spec, theme, marks, fs, measure } = ctx;
+  const nodes = spec.sankeyNodes;
+  const links = spec.links;
+  const at = new Map(nodes.map((n, i) => [n, i]));
+  const incoming = nodes.map(() => []);
+  const outgoing = nodes.map(() => []);
+  links.forEach((l, k) => {
+    outgoing[at.get(l.source)].push(k);
+    incoming[at.get(l.target)].push(k);
+  });
+  const column = nodes.map(() => -1);
+  const depth = (i) => {
+    if (column[i] >= 0) return column[i];
+    column[i] = 0;
+    column[i] = incoming[i].reduce((d, k) => Math.max(d, depth(at.get(links[k].source)) + 1), 0);
+    return column[i];
+  };
+  nodes.forEach((_, i) => depth(i));
+  const last = Math.max(...column);
+  nodes.forEach((_, i) => {
+    if (!outgoing[i].length) column[i] = last;
+  });
+  const value = series?.values.map((v) => v ?? 0) ?? nodes.map(() => 0);
+  const nodeW = Math.max(6, Math.min(16, area.width * 0.02));
+  const gap = last > 0 ? (area.width - nodeW) / last : 0;
+  const xOf = (c) => last > 0 ? area.x + c * gap : area.x + area.width / 2 - nodeW / 2;
+  const columns = Array.from({ length: last + 1 }, (_, c) => nodes.map((_2, i) => i).filter((i) => column[i] === c));
+  const pad = Math.max(4, Math.min(fs * 1.2, area.height / Math.max(1, Math.max(...columns.map((c) => c.length))) / 3));
+  const ky = Math.min(...columns.filter((c) => c.length).map((c) => (area.height - pad * (c.length - 1)) / Math.max(1e-9, c.reduce((t, i) => t + value[i], 0))));
+  const top = nodes.map(() => 0);
+  for (const col of columns) {
+    const used = col.reduce((t, i) => t + value[i] * ky, 0) + pad * Math.max(0, col.length - 1);
+    let y = area.y + (area.height - used) / 2;
+    for (const i of col) {
+      top[i] = y;
+      y += value[i] * ky + pad;
+    }
+  }
+  const color = (i) => series?.pointColors?.[i] || chartSliceColor(spec, i);
+  const named = new Set(spec.highlight);
+  const lit = nodes.map((n) => named.has(n));
+  const dimLinks = lit.some(Boolean);
+  const outOffset = nodes.map(() => 0);
+  const inOffset = nodes.map(() => 0);
+  const startY = /* @__PURE__ */ new Map();
+  const endY = /* @__PURE__ */ new Map();
+  nodes.forEach((_, i) => {
+    for (const k of [...outgoing[i]].sort((a, b) => top[at.get(links[a].target)] - top[at.get(links[b].target)])) {
+      startY.set(k, top[i] + outOffset[i]);
+      outOffset[i] += links[k].value * ky;
+    }
+    for (const k of [...incoming[i]].sort((a, b) => top[at.get(links[a].source)] - top[at.get(links[b].source)])) {
+      endY.set(k, top[i] + inOffset[i]);
+      inOffset[i] += links[k].value * ky;
+    }
+  });
+  const selectedNode = (i) => ctx.isSelected({ kind: "category", index: i }) || ctx.isSelected({ kind: "point", seriesId: series?.id ?? "", index: i });
+  links.forEach((l, k) => {
+    const s = at.get(l.source);
+    const t = at.get(l.target);
+    const w = l.value * ky;
+    const x0 = xOf(column[s]) + nodeW;
+    const x1 = xOf(column[t]);
+    const y0 = startY.get(k);
+    const y1 = endY.get(k);
+    const xm = (x0 + x1) / 2;
+    const d = `M${r2(x0)},${r2(y0)}C${r2(xm)},${r2(y0)} ${r2(xm)},${r2(y1)} ${r2(x1)},${r2(y1)}L${r2(x1)},${r2(y1 + w)}C${r2(xm)},${r2(y1 + w)} ${r2(xm)},${r2(y0 + w)} ${r2(x0)},${r2(y0 + w)}Z`;
+    const fill = l.color ?? (spec.sankeyLinkColor === "gray" ? theme.mutedText : color(spec.sankeyLinkColor === "target" ? t : s));
+    const emphasis = selectedNode(s) || selectedNode(t) ? 0.6 : 0.35;
+    const opacity = dimLinks && !lit[s] && !lit[t] ? emphasis * 0.25 : emphasis;
+    marks.push({ kind: "path", key: `link-${k}`, role: "link", d, fill, opacity });
+  });
+  const labelsOn = series?.dataLabels ?? spec.dataLabels;
+  const format = series?.format ?? spec.yAxis.format;
+  let hidden = 0;
+  nodes.forEach((name, i) => {
+    const x = xOf(column[i]);
+    const h = Math.max(1, value[i] * ky);
+    const target = { kind: "category", index: i };
+    const selected = selectedNode(i);
+    marks.push({ kind: "rect", key: `node-${i}`, role: "node", x, y: top[i], width: nodeW, height: h, fill: color(i), radius: 1, ...selected ? { stroke: theme.selection, strokeWidth: 2 } : {}, target, selected });
+    const text = labelsOn ? `${name} ${formatChartNumber(value[i], format)}` : name;
+    const room = (last > 0 ? gap : area.width / 2) - nodeW - 10;
+    const shown = truncate(text, Math.max(fs * 2, room), fs, measure);
+    if (shown !== text) hidden++;
+    const right = column[i] < last || last === 0;
+    marks.push({ kind: "text", key: `label-node-${i}`, role: "data-label", x: right ? x + nodeW + 5 : x - 5, y: top[i] + h / 2, text: shown, anchor: right ? "start" : "end", baseline: "middle", size: fs, weight: selected ? 600 : void 0, fill: selected ? theme.selection : theme.text, target, selected });
+  });
+  if (hidden) ctx.warn("labels-truncated", `${hidden} node label${hidden === 1 ? " was" : "s were"} shortened to fit between the columns.`);
+  return { plot: area };
+}
+function layoutBarRace(ctx, area, frame) {
+  const { spec, theme, marks, fs, measure } = ctx;
+  const top = spec.raceTopN;
+  const moment = chartRaceMoment(spec.categories.length, frame);
+  const ranking = chartRaceRanking(spec, frame);
+  const shown = ranking.filter((e) => e.position < top);
+  const labelW = Math.min(area.width * 0.3, Math.max(0, ...ranking.map((e) => measure(e.name, fs)))) + 8;
+  const tickH = spec.yAxis.show ? fs * 1.6 : 4;
+  const plot = { x: area.x + labelW, y: area.y + tickH, width: Math.max(1, area.width - labelW - fs * 4), height: Math.max(1, area.height - tickH) };
+  const lead = Math.max(1e-9, ...shown.map((e) => e.value));
+  const max = spec.yAxis.max !== null && spec.yAxis.max > 0 ? spec.yAxis.max : lead * 1.08;
+  const xOf = (v) => plot.x + Math.max(0, Math.min(max, v)) / max * plot.width;
+  const ticks = niceScale(0, max, 5).ticks.filter((t) => t <= max);
+  const axisTarget = { kind: "axis", axis: "y" };
+  const format = spec.yAxis.format;
+  ticks.forEach((t, k) => {
+    if (spec.yAxis.gridlines) marks.push({ kind: "line", key: `grid-y-${k}`, role: "grid", x1: xOf(t), y1: plot.y, x2: xOf(t), y2: plot.y + plot.height, stroke: theme.grid, strokeWidth: 1 });
+    if (spec.yAxis.show) marks.push({ kind: "text", key: `tick-y-${k}`, role: "tick-label", x: xOf(t), y: area.y, text: formatChartNumber(t, format, format.decimals ?? stepDecimals(ticks[1] - ticks[0] || 1)), anchor: "middle", baseline: "top", size: fs - 1, fill: theme.mutedText, target: axisTarget });
+  });
+  const label = spec.categories[moment.t < 0.5 ? moment.from : moment.to] ?? "";
+  const timeSize = Math.min(theme.titleSize * 3, plot.height * 0.2, plot.width * 0.5 / Math.max(1, label.length * 0.6));
+  marks.push({ kind: "text", key: "race-time", role: "race-time", x: plot.x + plot.width, y: plot.y + plot.height - 4, text: label, anchor: "end", baseline: "bottom", size: timeSize, weight: 700, fill: theme.mutedText, opacity: 0.55, target: { kind: "category", index: moment.t < 0.5 ? moment.from : moment.to } });
+  const band = plot.height / top;
+  const barH = Math.max(2, band * (1 - Math.min(0.8, spec.gapWidth)));
+  const index = Math.round(moment.at);
+  for (const e of shown) {
+    const si = spec.series.findIndex((s2) => s2.id === e.seriesId);
+    const s = spec.series[si];
+    const y = plot.y + e.position * band + (band - barH) / 2;
+    const target = { kind: "point", seriesId: e.seriesId, index };
+    const selected = ctx.isSelected(target) || ctx.seriesSelected(e.seriesId);
+    const width = Math.max(0, xOf(e.value) - plot.x);
+    marks.push({ kind: "rect", key: `bar-${e.seriesId}`, role: "bar", x: plot.x, y, width, height: barH, fill: chartSeriesColor(spec, si), radius: Math.min(3, barH / 4), target, selected, ...selected ? { stroke: theme.selection, strokeWidth: 1.5 } : {} });
+    marks.push({ kind: "text", key: `label-name-${e.seriesId}`, role: "tick-label", x: plot.x - 6, y: y + barH / 2, text: truncate(e.name, labelW - 8, fs, measure), anchor: "end", baseline: "middle", size: fs, fill: selected ? theme.selection : theme.text, target: { kind: "series", seriesId: e.seriesId } });
+    if (s.dataLabels ?? true) marks.push({ kind: "text", key: `label-${e.seriesId}`, role: "data-label", x: plot.x + width + 5, y: y + barH / 2, text: formatChartNumber(e.value, s.format ?? format, (s.format ?? format).decimals ?? (Math.abs(e.value) >= 100 ? 0 : void 0)), anchor: "start", baseline: "middle", size: fs - 1, fill: theme.text, target });
+  }
+  if (ranking.length > top) ctx.warn("values-skipped", `The race shows the top ${top} of ${ranking.length} names at each moment (raceTopN).`);
+  return { plot, valueScale: { axis: "x", domain: [0, max], range: [plot.x, plot.x + plot.width], ticks } };
+}
 
 // src/chart/layout.ts
 function legendItems(spec, ctx) {
   const family = chartFamily(spec);
-  if (spec.type === "funnel" || spec.type === "slope") return [];
+  if (spec.type === "funnel" || spec.type === "slope" || spec.type === "sankey" || spec.type === "barrace") return [];
   if (chartSpecColorsByCategory(spec)) {
     const first = spec.series.find((s) => !s.hidden);
     const seats = (i) => Math.max(0, Math.round(first?.values[i] ?? 0));
@@ -2493,6 +2656,14 @@ function layoutChart(spec, options) {
       return finish(layoutFunnel(ctx, area, visible[0]));
     case "treemap":
       return finish(spec.tree.length ? layoutTreemapTree(ctx, area, spec.series[0]) : layoutTreemap(ctx, area, visible[0]));
+    case "barrace":
+      return finish(layoutBarRace(ctx, area, options.raceFrame));
+    case "sankey":
+      if (!spec.links.length) {
+        ctx.warn("type-fallback", "A Sankey diagram needs flows (set_chart_links); it is drawn as a bar chart until then.");
+        return finish(layoutCartesian(ctx, area, visible));
+      }
+      return finish(layoutSankey(ctx, area, spec.series[0]));
     case "sunburst":
       return finish(layoutSunburst(ctx, area, spec.tree.length ? spec.series[0] : visible[0]));
     case "slope":
@@ -2696,6 +2867,9 @@ export {
   MAX_CHART_DATA_LABELS,
   MAX_CHART_LINE_POINTS,
   MAX_CHART_MARKERS,
+  chartRaceValueAt,
+  chartRaceMoment,
+  chartRaceRanking,
   layoutChart,
   chartValueAtPoint,
   chartXAtPoint,

package/dist/chunk-KGRZMHZB.js

@@ -0,0 +1,204 @@
+import {
+  splitSource
+} from "./chunk-O6OGNDND.js";
+
+// src/diagram/sankey/index.ts
+function parseSankey(source) {
+  const split = splitSource(source);
+  if (!/^\s*sankey(?:-beta)?\b/i.test(split.header)) {
+    return { error: "Not a sankey diagram: the first line should be `sankey-beta`." };
+  }
+  const firstLine = split.headerIndex + 2;
+  const kept = [];
+  split.bodyLines.forEach((text, i) => {
+    if (/^\s*%%/.test(text)) return;
+    kept.push({ text: text.trim(), line: firstLine + i });
+  });
+  const records = readRecords(kept);
+  if ("error" in records) return records;
+  const nodes = [];
+  const seen = /* @__PURE__ */ new Set();
+  const add = (name) => {
+    if (!seen.has(name)) {
+      seen.add(name);
+      nodes.push(name);
+    }
+  };
+  const links = [];
+  for (const { fields, line } of records) {
+    if (fields.length !== 3) {
+      return {
+        error: `Expected three fields (source,target,value), found ${fields.length}.`,
+        line
+      };
+    }
+    const [source2, target, raw] = fields;
+    const value = Number.parseFloat(raw);
+    if (!Number.isFinite(value)) {
+      return { error: `"${raw}" is not a number.`, line };
+    }
+    add(source2);
+    add(target);
+    links.push({ source: source2, target, value });
+  }
+  if (!links.length) return { error: "No links: add lines like `A,B,10`." };
+  return { data: { nodes, links } };
+}
+function readRecords(lines) {
+  const records = [];
+  let i = 0;
+  while (i < lines.length) {
+    const start = lines[i];
+    if (start.text === "") {
+      i++;
+      continue;
+    }
+    const fields = [];
+    let text = start.text;
+    let pos = 0;
+    let field = "";
+    let quoted = false;
+    for (; ; ) {
+      if (quoted) {
+        const close = text.indexOf('"', pos);
+        if (close < 0) {
+          field += text.slice(pos);
+          i++;
+          if (i >= lines.length)
+            return { error: "A quoted field is never closed.", line: start.line };
+          field += "\n";
+          text = lines[i].text;
+          pos = 0;
+          continue;
+        }
+        field += text.slice(pos, close);
+        if (text[close + 1] === '"') {
+          field += '"';
+          pos = close + 2;
+          continue;
+        }
+        quoted = false;
+        pos = close + 1;
+        const rest = /^[ \t]*/.exec(text.slice(pos))[0].length;
+        pos += rest;
+        if (pos < text.length && text[pos] !== ",") {
+          return { error: "Unexpected text after a quoted field.", line: lines[i].line };
+        }
+        continue;
+      }
+      if (pos >= text.length) {
+        fields.push(field.trim());
+        break;
+      }
+      const ch = text[pos];
+      if (ch === ",") {
+        fields.push(field.trim());
+        field = "";
+        pos++;
+      } else if (ch === '"' && field.trim() === "") {
+        quoted = true;
+        field = "";
+        pos++;
+      } else if (ch === '"') {
+        return { error: "A quote inside an unquoted field.", line: lines[i].line };
+      } else {
+        field += ch;
+        pos++;
+      }
+    }
+    records.push({ fields, line: start.line });
+    i++;
+  }
+  return records;
+}
+
+// src/diagram/treemap/index.ts
+var NAME = String.raw`(?:"([^"]*)"|'([^']*)')`;
+var CLASS = String.raw`(?:\s*:::\s*([A-Za-z_]\w*))?`;
+var SECTION_RE = new RegExp(String.raw`^${NAME}${CLASS}$`);
+var LEAF_RE = new RegExp(String.raw`^${NAME}\s*[:,]\s*([0-9_.,]+)${CLASS}$`);
+function parseTreemap(source) {
+  const split = splitSource(source);
+  if (!/^\s*treemap(?:-beta)?\b/i.test(split.header)) {
+    return { error: "Not a treemap: the first line should be `treemap-beta`." };
+  }
+  const data = { items: [] };
+  const stack = [];
+  const firstLine = split.headerIndex + 2;
+  const lines = split.bodyLines;
+  for (let i = 0; i < lines.length; i++) {
+    const raw = lines[i];
+    const line = firstLine + i;
+    const indent = /^[ \t]*/.exec(raw)[0].length;
+    const text = stripComment(raw).trim();
+    if (!text) continue;
+    const accBlock = /^accDescr\s*\{(.*)$/.exec(text);
+    if (accBlock) {
+      let body = accBlock[1];
+      while (!body.includes("}") && i + 1 < lines.length) body += `
+${lines[++i]}`;
+      if (!body.includes("}")) return { error: "`accDescr {` is never closed.", line };
+      data.accDescr = body.slice(0, body.indexOf("}")).trim();
+      continue;
+    }
+    const acc = /^(accTitle|accDescr)\s*:(.*)$/.exec(text);
+    if (acc) {
+      data[acc[1]] = acc[2].trim();
+      continue;
+    }
+    const title = /^title(?:[ \t]+(.*))?$/.exec(text);
+    if (title) {
+      data.title = (title[1] ?? "").trim() || void 0;
+      continue;
+    }
+    if (/^classDef\s/.test(text)) continue;
+    let item;
+    const leaf = LEAF_RE.exec(text);
+    const section = leaf ? null : SECTION_RE.exec(text);
+    if (leaf) {
+      const value = Number.parseFloat(leaf[3].replace(/,/g, ""));
+      if (!Number.isFinite(value)) return { error: `"${leaf[3]}" is not a number.`, line };
+      item = { name: leaf[1] ?? leaf[2], value };
+      if (leaf[4]) item.className = leaf[4];
+    } else if (section) {
+      item = { name: section[1] ?? section[2], children: [] };
+      if (section[3]) item.className = section[3];
+    } else {
+      return {
+        error: /^["']/.test(text) ? 'Expected `"Name"` for a section or `"Name": value` for a leaf.' : 'Names must be in quotes, e.g. `"Sales": 120`.',
+        line
+      };
+    }
+    while (stack.length && stack[stack.length - 1].indent >= indent) stack.pop();
+    const parent = stack[stack.length - 1]?.item;
+    if (parent) parent.children.push(item);
+    else data.items.push(item);
+    if (item.children) stack.push({ item, indent });
+  }
+  if (!data.items.length) return { error: 'No items: add lines like `"Sales": 120`.' };
+  return { data };
+}
+function stripComment(line) {
+  let quote = null;
+  for (let i = 0; i < line.length; i++) {
+    const ch = line[i];
+    if (quote) {
+      if (ch === quote) quote = null;
+    } else if (ch === '"' || ch === "'") {
+      quote = ch;
+    } else if (ch === "%" && line[i + 1] === "%") {
+      return line.slice(0, i);
+    }
+  }
+  return line;
+}
+function treemapValue(item) {
+  if (!item.children) return item.value ?? 0;
+  return item.children.reduce((sum, child) => sum + treemapValue(child), 0);
+}
+
+export {
+  parseSankey,
+  parseTreemap,
+  treemapValue
+};

package/dist/{chunk-SET6KJOP.js → chunk-LPIKXPBM.js}

@@ -51,7 +51,7 @@ import {
 import {
   oklabToRgb,
   rgbToOklab
-} from "./chunk-BQWGN5WH.js";
+} from "./chunk-M2TPMYJE.js";
 import {
   hexToRgba,
   normalizeTokenColor,

package/dist/{chunk-BQWGN5WH.js → chunk-M2TPMYJE.js}

@@ -6,7 +6,7 @@ import {
 import {
   oklabToRgb,
   rgbToOklab
-} from "./chunk-4VU4CP7R.js";
+} from "./chunk-MHLU6GRJ.js";
 
 // src/animation/color.ts
 function rgbToOklab2(r, g, b, alpha = 1) {

package/dist/{chunk-GTELFJRE.cjs → chunk-M5GLQQWG.cjs}

@@ -4,7 +4,7 @@
 var _chunkDWJJI6RTcjs = require('./chunk-DWJJI6RT.cjs');
 
 
-var _chunkCIPIESX4cjs = require('./chunk-CIPIESX4.cjs');
+var _chunk4ZC5QJE2cjs = require('./chunk-4ZC5QJE2.cjs');
 
 // src/animation/keyframes.ts
 var ANIMATION_TIME_EPSILON = 1e-6;
@@ -46,7 +46,7 @@ function interpolateAnimationValue(from, to, t, type = "number") {
   if (t <= 0) return from;
   if (t >= 1) return to;
   if (type === "color" || typeof from === "string" && typeof to === "string") {
-    const mixed = _chunkCIPIESX4cjs.mixColorsOklab.call(void 0, from, to, t);
+    const mixed = _chunk4ZC5QJE2cjs.mixColorsOklab.call(void 0, from, to, t);
     if (mixed !== null) return mixed;
   }
   return from;