@weasel-js/plot 0.0.0-stage → 1.15.1

package/dist/index.js

@@ -0,0 +1,3888 @@
+import { ordinalScale, polarScale, niceDomain, linearScale, decimalsOf, timeScale, bandScale } from './chunk-HA77BIQF.js';
+export { bandScale, decimalsOf, formatInstant, formatNumber, formatTick, linearScale, logScale, niceDomain, niceStep, ordinalScale, polarScale, stepTicks, tickDecimals, tickStep, timeScale } from './chunk-HA77BIQF.js';
+import { ellipsePath, pathFromD, boundsOfPath } from '@weasel-js/geom';
+import { THEMES } from '@weasel-js/theme';
+import { measureTextBounds } from '@weasel-js/text';
+import { isTextData, useLatest, composeWorldPose, scenePoseAdapter, composeAffordanceLayer, WeaselProvider, useScene, SceneCanvas } from '@weasel-js/core';
+import { useMemo, useState, useEffect } from 'react';
+import { jsx } from 'react/jsx-runtime';
+
+var rectOf = (b) => ({ kind: "rect", x: b.x, y: b.y, width: b.width, height: b.height });
+var fillOf = (color, opacity) => ({ paint: { color, ...opacity !== void 0 ? { opacity } : {} } });
+function barMark(opts) {
+  const lo = Math.min(opts.from, opts.to);
+  const length = Math.abs(opts.to - opts.from);
+  const pose = opts.orient === "horizontal" ? { x: lo, y: opts.x, width: length, height: opts.width } : { x: opts.x, y: lo, width: opts.width, height: length };
+  return {
+    key: opts.key,
+    pose,
+    data: { plotMark: { kind: "bar", ...opts.datum ? { datum: opts.datum } : {} }, path: rectOf(pose), fill: fillOf(opts.color) }
+  };
+}
+function spanMark(opts) {
+  const pose = { x: Math.min(opts.x0, opts.x1), y: opts.y, width: Math.abs(opts.x1 - opts.x0), height: opts.height };
+  return {
+    key: opts.key,
+    pose,
+    data: {
+      plotMark: { kind: "span", ...opts.datum ? { datum: opts.datum } : {} },
+      path: rectOf(pose),
+      fill: fillOf(opts.color, opts.opacity)
+    }
+  };
+}
+function pointMark(opts) {
+  const r = opts.radius ?? 3;
+  const pose = { x: opts.x - r, y: opts.y - r, width: 2 * r, height: 2 * r };
+  return {
+    key: opts.key,
+    pose,
+    data: { plotMark: { kind: "point", ...opts.datum ? { datum: opts.datum } : {} }, path: ellipsePath(pose), fill: fillOf(opts.color) }
+  };
+}
+var n = (v) => Number(v.toFixed(3));
+var at = (p) => `${n(p.x)} ${n(p.y)}`;
+function pathMark(key, path, data) {
+  const b = boundsOfPath(path);
+  return { key, pose: { x: b.x, y: b.y, width: b.width, height: b.height }, data: { ...data, path } };
+}
+var traitOf = (kind, datum) => ({ kind, ...datum ? { datum } : {} });
+function lineMark(opts) {
+  const [first, ...rest] = opts.points;
+  if (first === void 0) throw new Error(`lineMark "${opts.key}": no points`);
+  const d = `M ${at(first)}${rest.map((p) => ` L ${at(p)}`).join("")}`;
+  const stroke = {
+    paint: { color: opts.color },
+    width: opts.width ?? 2,
+    join: "round",
+    cap: "round",
+    ...opts.dash ? { dash: opts.dash } : {}
+  };
+  return pathMark(opts.key, pathFromD(d), { plotMark: traitOf("line", opts.datum), stroke });
+}
+function ruleMark(opts) {
+  const stroke = { paint: { color: opts.color }, width: opts.width ?? 1, cap: "butt", ...opts.dash ? { dash: opts.dash } : {} };
+  return pathMark(opts.key, pathFromD(`M ${at(opts.from)} L ${at(opts.to)}`), { plotMark: traitOf("rule", opts.datum), stroke });
+}
+function areaMark(opts) {
+  if (opts.top.length === 0) throw new Error(`areaMark "${opts.key}": no points`);
+  const bottom = opts.bottom ?? (opts.baseline !== void 0 ? opts.top.map((p) => ({ x: p.x, y: opts.baseline })) : []);
+  const ring = [...opts.top, ...[...bottom].reverse()];
+  const d = `M ${ring.map(at).join(" L ")} Z`;
+  return pathMark(opts.key, pathFromD(d), {
+    plotMark: traitOf("area", opts.datum),
+    fill: { paint: { color: opts.color, opacity: opts.opacity ?? 0.35 } }
+  });
+}
+var polar = (c, r, a) => ({ x: c.x + r * Math.sin(a), y: c.y - r * Math.cos(a) });
+function arcTo(c, r, a0, a1) {
+  const sweep = a1 >= a0 ? 1 : 0;
+  const mid = (a0 + a1) / 2;
+  const to = (a) => ` A ${n(r)} ${n(r)} 0 0 ${sweep} ${at(polar(c, r, a))}`;
+  return Math.abs(a1 - a0) > Math.PI ? to(mid) + to(a1) : to(a1);
+}
+function arcMark(opts) {
+  const { center: c, innerRadius: r0, outerRadius: r1, startAngle: a0 } = opts;
+  const a1 = Math.abs(opts.endAngle - a0) >= 2 * Math.PI ? a0 + Math.sign(opts.endAngle - a0) * (2 * Math.PI - 1e-6) : opts.endAngle;
+  let d = `M ${at(polar(c, r1, a0))}${arcTo(c, r1, a0, a1)}`;
+  d += r0 > 0 ? ` L ${at(polar(c, r0, a1))}${arcTo(c, r0, a1, a0)} Z` : ` L ${at(c)} Z`;
+  return pathMark(opts.key, pathFromD(d), { plotMark: traitOf("arc", opts.datum), fill: { paint: { color: opts.color } } });
+}
+function ribbonMark(opts) {
+  const { from: f, to: t } = opts;
+  const mx = (f.x + t.x) / 2;
+  const d = `M ${n(f.x)} ${n(f.y0)} C ${n(mx)} ${n(f.y0)} ${n(mx)} ${n(t.y0)} ${n(t.x)} ${n(t.y0)} L ${n(t.x)} ${n(t.y1)} C ${n(mx)} ${n(t.y1)} ${n(mx)} ${n(f.y1)} ${n(f.x)} ${n(f.y1)} Z`;
+  return pathMark(opts.key, pathFromD(d), {
+    plotMark: traitOf("ribbon", opts.datum),
+    fill: { paint: { color: opts.color, opacity: opts.opacity ?? 0.45 } }
+  });
+}
+
+// src/marks/text.ts
+var ALIGN = { start: "left", middle: "center", end: "right" };
+function textMark(opts) {
+  const { width: width2, height } = opts.measure(opts.text, opts.font);
+  const anchor = opts.anchor ?? "middle";
+  const baseline = opts.baseline ?? "middle";
+  const along = anchor === "start" ? 0 : anchor === "middle" ? -width2 / 2 : -width2;
+  const across = baseline === "top" ? 0 : baseline === "middle" ? -height / 2 : -height;
+  const center = opts.vertical ? { x: opts.x + across + height / 2, y: opts.y - along - width2 / 2 } : { x: opts.x + along + width2 / 2, y: opts.y + across + height / 2 };
+  return {
+    key: opts.key,
+    pose: {
+      x: center.x - width2 / 2,
+      y: center.y - height / 2,
+      width: width2,
+      height,
+      ...opts.vertical ? { rotation: -Math.PI / 2 } : {}
+    },
+    data: {
+      plotMark: { kind: "text", ...opts.datum ? { datum: opts.datum } : {} },
+      text: opts.text,
+      style: { fontFamily: opts.font.fontFamily, fontSize: opts.font.fontSize, align: ALIGN[anchor], ...opts.bold ? { fontWeight: 700 } : {} },
+      fill: { paint: { color: opts.color } },
+      verticalAlign: "center"
+    }
+  };
+}
+
+// src/axes.ts
+var TICK = 5;
+var GAP = 4;
+var isHorizontal = (side) => side === "top" || side === "bottom";
+var outward = (side) => side === "bottom" || side === "right" ? 1 : -1;
+function axisRoom(opts) {
+  const { scale, side, theme, measure } = opts;
+  const sizes = scale.ticks(opts.ticks).map((t) => measure(scale.format(t), theme.font));
+  const labels2 = sizes.length === 0 ? 0 : Math.max(...sizes.map((s) => isHorizontal(side) ? s.height : s.width));
+  const title = opts.title ? measure(opts.title, theme.font).height + GAP : 0;
+  return TICK + GAP + labels2 + title;
+}
+function axisMarks(opts) {
+  const { scale, side, at: at3, theme, measure } = opts;
+  const key = opts.key ?? `axis:${side}`;
+  const h = isHorizontal(side);
+  const out = outward(side);
+  const pt = (along, across) => h ? { x: along, y: across } : { x: across, y: along };
+  const [r0, r1] = scale.range;
+  const marks = [];
+  const ticks = scale.ticks(opts.ticks);
+  ticks.forEach((t, i) => {
+    const p = scale.position(t);
+    if (opts.gridTo !== void 0) {
+      marks.push(ruleMark({ key: `${key}:grid:${i}`, from: pt(p, at3), to: pt(p, opts.gridTo), color: theme.grid }));
+    }
+  });
+  marks.push(ruleMark({ key: `${key}:rule`, from: pt(r0, at3), to: pt(r1, at3), color: theme.axis }));
+  let reach = 0;
+  ticks.forEach((t, i) => {
+    const p = scale.position(t);
+    marks.push(ruleMark({ key: `${key}:tick:${i}`, from: pt(p, at3), to: pt(p, at3 + out * TICK), color: theme.axis }));
+    const anchorAt = pt(p, at3 + out * (TICK + GAP));
+    const label = textMark({
+      key: `${key}:label:${i}`,
+      text: scale.format(t),
+      ...anchorAt,
+      font: theme.font,
+      color: theme.text,
+      measure,
+      anchor: h ? "middle" : out > 0 ? "start" : "end",
+      baseline: h ? out > 0 ? "top" : "bottom" : "middle"
+    });
+    reach = Math.max(reach, h ? label.pose.height : label.pose.width);
+    marks.push(label);
+  });
+  if (opts.title) {
+    const across = at3 + out * (TICK + GAP + reach + GAP);
+    marks.push(textMark({
+      key: `${key}:title`,
+      text: opts.title,
+      ...pt((r0 + r1) / 2, across),
+      font: theme.font,
+      color: theme.text,
+      measure,
+      anchor: "middle",
+      baseline: out > 0 ? "top" : "bottom",
+      vertical: !h
+    }));
+  }
+  return marks;
+}
+var SWATCHES = ["sky", "amber", "green", "rose", "violet", "teal", "citron", "fuchsia", "blue", "red"];
+function plotThemeFrom(resolved, font = PLOT_FONT) {
+  const at3 = (token) => resolved[`--wzl-${token}`] ?? "#888888";
+  return {
+    text: at3("fg"),
+    axis: at3("border-strong"),
+    grid: at3("border"),
+    series: SWATCHES.map((s) => at3(`swatch-${s}`)),
+    font
+  };
+}
+var PLOT_FONT = { fontFamily: "sans-serif", fontSize: 12 };
+var PLOT_THEME = plotThemeFrom(THEMES.weasel.selections["mode=dark,density=comfortable"]);
+var seriesColor = (theme, i) => theme.series[(i % theme.series.length + theme.series.length) % theme.series.length] ?? theme.text;
+var textMeasure = (text, font) => {
+  const { width: width2 } = measureTextBounds(text, { fontFamily: font.fontFamily, fontSize: font.fontSize });
+  return { width: Math.ceil(width2), height: Math.ceil(font.fontSize * 1.2) };
+};
+
+// src/chartTitle.ts
+var CHART_PAD = 12;
+var GAP2 = 8;
+function chartTitle(title, width2, theme, measure) {
+  if (!title) return { marks: [], top: CHART_PAD };
+  const mark = textMark({
+    key: "title",
+    text: title,
+    x: width2 / 2,
+    y: CHART_PAD,
+    baseline: "top",
+    font: theme.font,
+    color: theme.text,
+    measure,
+    bold: true,
+    datum: { edit: "title" }
+  });
+  return { marks: [mark], top: CHART_PAD + mark.pose.height + GAP2 };
+}
+function withTitle(data, text) {
+  const title = text.trim();
+  if ((data.title ?? "") === title) return data;
+  const { title: _, ...rest } = data;
+  return title === "" ? rest : { ...rest, title };
+}
+
+// src/gantt/dates.ts
+var TOKENS = ["YYYY", "SSS", "YY", "MM", "DD", "HH", "mm", "ss", "M", "D", "H", "m", "s", "X", "x"];
+var PATTERN = {
+  YYYY: "\\d{4}",
+  YY: "\\d{2}",
+  MM: "\\d{2}",
+  M: "\\d{1,2}",
+  DD: "\\d{2}",
+  D: "\\d{1,2}",
+  HH: "\\d{2}",
+  H: "\\d{1,2}",
+  mm: "\\d{2}",
+  m: "\\d{1,2}",
+  ss: "\\d{2}",
+  s: "\\d{1,2}",
+  SSS: "\\d{3}",
+  X: "[+-]?\\d+(?:\\.\\d+)?",
+  x: "[+-]?\\d+"
+};
+var GANTT_DATE_FORMAT = "YYYY-MM-DD";
+function partsOf(format) {
+  const parts = [];
+  let literal = "";
+  for (let i = 0; i < format.length; ) {
+    const close = format[i] === "[" ? format.indexOf("]", i) : -1;
+    if (close > i) {
+      literal += format.slice(i + 1, close);
+      i = close + 1;
+      continue;
+    }
+    const token = TOKENS.find((t) => format.startsWith(t, i));
+    if (token === void 0) {
+      literal += format[i];
+      i++;
+      continue;
+    }
+    if (literal !== "") parts.push({ literal });
+    literal = "";
+    parts.push({ token });
+    i += token.length;
+  }
+  if (literal !== "") parts.push({ literal });
+  return parts;
+}
+var escapeRe = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+var formatHasHours = (format) => partsOf(format).some((p) => "token" in p && ["HH", "H", "X", "x"].includes(p.token));
+function parseGanttDate(text, format) {
+  const parts = partsOf(format);
+  const m = new RegExp(`^${parts.map((p) => "token" in p ? `(${PATTERN[p.token]})` : escapeRe(p.literal)).join("")}$`).exec(text.trim());
+  if (m === null) return null;
+  const f = { year: 1970, month: 1, day: 1, hour: 0, minute: 0, second: 0, ms: 0 };
+  let group = 1;
+  for (const p of parts) {
+    if (!("token" in p)) continue;
+    const n2 = Number(m[group++]);
+    switch (p.token) {
+      case "X":
+        return n2 * 1e3;
+      case "x":
+        return n2;
+      case "YYYY":
+        f.year = n2;
+        break;
+      case "YY":
+        f.year = n2 + (n2 > 68 ? 1900 : 2e3);
+        break;
+      case "MM":
+      case "M":
+        f.month = n2;
+        break;
+      case "DD":
+      case "D":
+        f.day = n2;
+        break;
+      case "HH":
+      case "H":
+        f.hour = n2;
+        break;
+      case "mm":
+      case "m":
+        f.minute = n2;
+        break;
+      case "ss":
+      case "s":
+        f.second = n2;
+        break;
+      case "SSS":
+        f.ms = n2;
+        break;
+    }
+  }
+  if (f.month < 1 || f.month > 12 || f.day < 1 || f.hour > 23 || f.minute > 59 || f.second > 59) return null;
+  const t = Date.UTC(f.year, f.month - 1, f.day, f.hour, f.minute, f.second, f.ms);
+  return new Date(t).getUTCDate() === f.day ? t : null;
+}
+var pad = (n2, width2 = 2) => String(n2).padStart(width2, "0");
+function formatGanttDate(t, format) {
+  const d = new Date(t);
+  const field = {
+    YYYY: () => pad(d.getUTCFullYear(), 4),
+    YY: () => pad(d.getUTCFullYear() % 100),
+    MM: () => pad(d.getUTCMonth() + 1),
+    M: () => String(d.getUTCMonth() + 1),
+    DD: () => pad(d.getUTCDate()),
+    D: () => String(d.getUTCDate()),
+    HH: () => pad(d.getUTCHours()),
+    H: () => String(d.getUTCHours()),
+    mm: () => pad(d.getUTCMinutes()),
+    m: () => String(d.getUTCMinutes()),
+    ss: () => pad(d.getUTCSeconds()),
+    s: () => String(d.getUTCSeconds()),
+    SSS: () => pad(d.getUTCMilliseconds(), 3),
+    X: () => String(t / 1e3),
+    x: () => String(t)
+  };
+  return partsOf(format).map((p) => "token" in p ? field[p.token]() : p.literal).join("");
+}
+var MONTHS = ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"];
+var DAYS = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
+function strftime(t, format) {
+  const d = new Date(t);
+  const hour = d.getUTCHours();
+  const yearDay = Math.floor((t - Date.UTC(d.getUTCFullYear(), 0, 1)) / 864e5) + 1;
+  const field = {
+    Y: () => String(d.getUTCFullYear()),
+    y: () => pad(d.getUTCFullYear() % 100),
+    m: () => pad(d.getUTCMonth() + 1),
+    d: () => pad(d.getUTCDate()),
+    e: () => String(d.getUTCDate()).padStart(2, " "),
+    b: () => MONTHS[d.getUTCMonth()].slice(0, 3),
+    B: () => MONTHS[d.getUTCMonth()],
+    a: () => DAYS[d.getUTCDay()].slice(0, 3),
+    A: () => DAYS[d.getUTCDay()],
+    H: () => pad(hour),
+    I: () => pad(hour % 12 === 0 ? 12 : hour % 12),
+    M: () => pad(d.getUTCMinutes()),
+    S: () => pad(d.getUTCSeconds()),
+    p: () => hour < 12 ? "AM" : "PM",
+    j: () => pad(yearDay, 3),
+    "%": () => "%"
+  };
+  return format.replace(/%(.)/g, (all, c) => field[c]?.() ?? all);
+}
+
+// src/gantt/schedule.ts
+var DAY = 864e5;
+var HOUR = 36e5;
+var FIXED = { ms: 1, s: 1e3, m: 6e4, h: HOUR };
+var WALK_LIMIT = 1e5;
+var WEEKDAYS = ["sunday", "monday", "tuesday", "wednesday", "thursday", "friday", "saturday"];
+var dateFormatOf = (data) => data.dateFormat?.trim() || GANTT_DATE_FORMAT;
+var dayOf = (t) => Math.floor(t / DAY);
+function excludedDays(data) {
+  const format = dateFormatOf(data);
+  const weekdays = /* @__PURE__ */ new Set();
+  const dates = /* @__PURE__ */ new Set();
+  for (const raw of data.excludes ?? []) {
+    const word = raw.trim().toLowerCase();
+    if (word === "weekends") {
+      weekdays.add(0);
+      weekdays.add(6);
+    } else if (WEEKDAYS.includes(word)) {
+      weekdays.add(WEEKDAYS.indexOf(word));
+    } else {
+      const t = parseGanttDate(raw, format);
+      if (t !== null) dates.add(dayOf(t));
+    }
+  }
+  if (weekdays.size === 7) return () => false;
+  return (t) => weekdays.has(new Date(t).getUTCDay()) || dates.has(dayOf(t));
+}
+function addMonths(t, months) {
+  const whole = Math.trunc(months);
+  const d = new Date(t);
+  d.setUTCMonth(d.getUTCMonth() + whole);
+  return d.getTime() + (months - whole) * 30 * DAY;
+}
+function addGanttDuration(start, amount, unit2, excluded) {
+  const n2 = Number.isFinite(amount) ? amount : 0;
+  const fixed = FIXED[unit2];
+  if (fixed !== void 0) return start + n2 * fixed;
+  if (unit2 === "M" || unit2 === "y") return addMonths(start, unit2 === "y" ? n2 * 12 : n2);
+  const days = unit2 === "w" ? n2 * 7 : n2;
+  let end = start + days * DAY;
+  if (days > WALK_LIMIT) return end;
+  for (let t = start; t < end; t += DAY) if (excluded(t)) end += DAY;
+  return end;
+}
+function ganttDurationBetween(start, end, unit2, excluded) {
+  const fixed = FIXED[unit2];
+  if (fixed !== void 0) return Math.round((end - start) / fixed);
+  if (unit2 === "M" || unit2 === "y") return Math.round((end - start) / ((unit2 === "y" ? 365.25 : 30.44) * DAY));
+  const steps = Math.min(WALK_LIMIT, Math.round((end - start) / DAY));
+  let days = 0;
+  for (let k = 0; k < steps; k++) if (!excluded(start + k * DAY)) days++;
+  return unit2 === "w" ? Math.round(days / 7) : days;
+}
+function ganttTasks(data) {
+  return data.sections.flatMap((s, section) => s.tasks.map((task, index) => ({ task, section, index })));
+}
+function scheduleGantt(data, today = Date.now()) {
+  const format = dateFormatOf(data);
+  const excluded = excludedDays(data);
+  const flat = ganttTasks(data);
+  const byId = /* @__PURE__ */ new Map();
+  flat.forEach(({ task }, i) => {
+    if (task.id !== void 0 && !byId.has(task.id)) byId.set(task.id, i);
+  });
+  const written = flat.flatMap(({ task }) => task.start.kind === "date" ? [parseGanttDate(task.start.date, format)] : []).filter((t) => t !== null);
+  const first = written.length > 0 ? Math.min(...written) : dayOf(today) * DAY;
+  const starts = [];
+  const ends = [];
+  const busy = /* @__PURE__ */ new Set();
+  const memo = (cache, i, tag, compute) => {
+    if (cache[i] !== void 0) return cache[i];
+    if (busy.has(tag + i)) return first;
+    busy.add(tag + i);
+    const value = compute();
+    busy.delete(tag + i);
+    cache[i] = value;
+    return value;
+  };
+  const named2 = (ids2, of) => ids2.map((id) => byId.has(id) ? of(byId.get(id)) : first);
+  const startOf = (i) => memo(starts, i, "s", () => {
+    const start = flat[i].task.start;
+    if (start.kind === "date") return parseGanttDate(start.date, format) ?? first;
+    if (start.kind === "previous") return i === 0 ? first : endOf(i - 1);
+    const after = named2(start.ids, endOf);
+    return after.length > 0 ? Math.max(...after) : first;
+  });
+  const endOf = (i) => memo(ends, i, "e", () => {
+    const start = startOf(i);
+    const end = flat[i].task.end;
+    let at3;
+    if (end.kind === "date") at3 = parseGanttDate(end.date, format) ?? start;
+    else if (end.kind === "duration") at3 = addGanttDuration(start, end.amount, end.unit, excluded);
+    else {
+      const until = named2(end.ids, startOf);
+      at3 = until.length > 0 ? Math.min(...until) : start;
+    }
+    return Math.max(start, at3);
+  });
+  flat.forEach((_, i) => endOf(i));
+  const spans = data.sections.map(() => []);
+  flat.forEach(({ section }, i) => spans[section].push({ start: starts[i], end: Math.max(starts[i], ends[i]) }));
+  const all = spans.flat();
+  const lo = all.length > 0 ? Math.min(...all.map((s) => s.start)) : first;
+  const hi = all.length > 0 ? Math.max(...all.map((s) => s.end)) : first;
+  return { spans, domain: [lo, hi > lo ? hi : lo + DAY] };
+}
+
+// src/gantt/compile.ts
+var ROW_MAX = 32;
+var BAR = 0.7;
+var GAP3 = 8;
+var LABEL_GAP = 4;
+function ganttTimeScale(domain, range, axisFormat) {
+  const scale = timeScale({ domain, range });
+  return axisFormat ? { ...scale, format: (v) => strftime(v, axisFormat) } : scale;
+}
+function ganttTaskFill(tags, theme) {
+  const done = tags?.includes("done") ?? false;
+  if (tags?.includes("crit")) return { color: seriesColor(theme, 3), ...done ? { opacity: 0.5 } : {} };
+  if (done) return { color: theme.axis };
+  if (tags?.includes("active")) return { color: seriesColor(theme, 1) };
+  return { color: seriesColor(theme, 0) };
+}
+function todayStroke(style, theme) {
+  const color = /(?:^|[;,])\s*stroke\s*:\s*([^;,]+)/.exec(style ?? "")?.[1]?.trim();
+  const width2 = Number(/stroke-width\s*:\s*([\d.]+)/.exec(style ?? "")?.[1]);
+  return { color: color || seriesColor(theme, 9), width: Number.isFinite(width2) && width2 > 0 ? width2 : 2 };
+}
+function compileGantt(data, size, theme, measure) {
+  const { marks, top } = chartTitle(data.title, size.width, theme, measure);
+  const schedule = scheduleGantt(data);
+  const names = data.sections.map((s) => s.name ?? "");
+  const sectionWidth = names.some((n2) => n2 !== "") ? Math.max(...names.map((n2) => measure(n2, theme.font).width)) + 2 * GAP3 : 0;
+  const left = CHART_PAD + sectionWidth;
+  const right = Math.max(left + 1, size.width - CHART_PAD);
+  const axis = { theme, measure, side: "bottom" };
+  const room = axisRoom({ ...axis, scale: ganttTimeScale(schedule.domain, [0, 1], data.axisFormat)});
+  const rows = data.sections.reduce((n2, s) => n2 + s.tasks.length, 0);
+  const avail = Math.max(1, size.height - CHART_PAD - room - top);
+  const rowHeight = rows === 0 ? 0 : Math.min(ROW_MAX, avail / rows);
+  const bottom = top + (rows === 0 ? avail : rowHeight * rows);
+  const time = ganttTimeScale(schedule.domain, [left, right], data.axisFormat);
+  const layout = {
+    plot: { x: left, y: top, width: right - left, height: bottom - top },
+    time,
+    schedule,
+    snap: formatHasHours(dateFormatOf(data)) ? DAY / 24 : DAY
+  };
+  let row = 0;
+  data.sections.forEach((section, s) => {
+    const y = top + row * rowHeight;
+    const height = section.tasks.length * rowHeight;
+    row += section.tasks.length;
+    if (height === 0) return;
+    marks.push(spanMark({ key: `section:${s}:band`, x0: CHART_PAD, x1: right, y, height, color: theme.grid, opacity: s % 2 === 0 ? 0.45 : 0.2, datum: { section: s } }));
+    if (section.name) {
+      marks.push(textMark({
+        key: `section:${s}:label`,
+        text: section.name,
+        x: CHART_PAD + GAP3,
+        y: y + height / 2,
+        anchor: "start",
+        font: theme.font,
+        color: theme.text,
+        measure,
+        bold: true,
+        datum: { edit: "section", section: s }
+      }));
+    }
+  });
+  marks.push(...axisMarks({ ...axis, key: "axis:time", scale: time, at: bottom, gridTo: top }));
+  const today = Date.now();
+  const [d0, d1] = schedule.domain;
+  if (data.todayMarker?.trim() !== "off" && today >= d0 && today <= d1) {
+    const x = time.map(today);
+    marks.push(ruleMark({ key: "today", from: { x, y: top }, to: { x, y: bottom }, ...todayStroke(data.todayMarker, theme) }));
+  }
+  marks.push(...taskMarks(data, layout, rowHeight, theme, measure));
+  return { marks, layout };
+}
+function taskMarks(data, layout, rowHeight, theme, measure) {
+  const { time, plot } = layout;
+  const barHeight = rowHeight * BAR;
+  const marks = [];
+  const labels2 = [];
+  let row = 0;
+  data.sections.forEach((section, s) => section.tasks.forEach((task, t) => {
+    const span = layout.schedule.spans[s][t];
+    const cy = plot.y + (row++ + 0.5) * rowHeight;
+    const fill = ganttTaskFill(task.tags, theme);
+    const datum = { section: s, task: t };
+    const key = `task:${s}:${t}`;
+    let x0 = time.map(span.start);
+    let x1 = time.map(span.end);
+    if (task.tags?.includes("milestone")) {
+      const r = barHeight / 2;
+      const points = [{ x: x0 - r, y: cy }, { x: x0, y: cy - r }, { x: x0 + r, y: cy }, { x: x0, y: cy + r }];
+      marks.push(areaMark({ key, top: points, bottom: [], color: fill.color, opacity: fill.opacity ?? 1, datum }));
+      [x0, x1] = [x0 - r, x0 + r];
+    } else {
+      marks.push(spanMark({ key, x0, x1, y: cy - barHeight / 2, height: barHeight, ...fill, datum }));
+    }
+    const width2 = measure(task.name, theme.font).width;
+    const inside = !task.tags?.includes("milestone") && width2 + 2 * LABEL_GAP <= x1 - x0;
+    const after = x1 + LABEL_GAP + width2 <= plot.x + plot.width;
+    const [x, anchor] = inside ? [(x0 + x1) / 2, "middle"] : after ? [x1 + LABEL_GAP, "start"] : [x0 - LABEL_GAP, "end"];
+    labels2.push(textMark({
+      key: `${key}:label`,
+      text: task.name,
+      x,
+      y: cy,
+      anchor,
+      font: theme.font,
+      color: theme.text,
+      measure,
+      datum: { edit: "task", section: s, task: t }
+    }));
+  }));
+  return [...marks, ...labels2];
+}
+
+// src/gitgraph/replay.ts
+var headOf = (s, branch) => {
+  const b = s.branches.get(branch);
+  return b?.commits.at(-1) ?? b?.fork;
+};
+function add(s, command, id, rest) {
+  const seq = s.history.commits.length;
+  const name = id ?? `#${seq}`;
+  if (s.byId.has(name)) return `a commit "${name}" already exists`;
+  const commit = { command, id: name, branch: s.current, seq, ...rest };
+  s.history.commits.push(commit);
+  s.byId.set(name, commit);
+  s.branches.get(s.current).commits.push(name);
+  return null;
+}
+function merge(s, k, cmd) {
+  const other = cmd.branch;
+  const head = headOf(s, s.current);
+  if (other === s.current) return `"${other}" cannot be merged into itself`;
+  if (head === void 0) return `cannot merge into "${s.current}": it has no commits`;
+  if (!s.branches.has(other)) return `cannot merge "${other}": there is no such branch`;
+  const theirs = headOf(s, other);
+  if (theirs === void 0) return `cannot merge "${other}": it has no commits`;
+  if (theirs === head) return `cannot merge "${other}" into "${s.current}": both have the same head`;
+  return add(s, k, cmd.id, { parents: [head, theirs], type: cmd.type ?? "NORMAL" });
+}
+function cherryPick(s, k, cmd) {
+  const source = s.byId.get(cmd.id);
+  const head = headOf(s, s.current);
+  if (source === void 0) return `cannot cherry-pick "${cmd.id}": there is no such commit`;
+  if (source.branch === s.current) return `cannot cherry-pick "${cmd.id}": it is already on "${s.current}"`;
+  if (head === void 0) return `cannot cherry-pick onto "${s.current}": it has no commits`;
+  if (source.parents.length > 1 && (cmd.parent === void 0 || !source.parents.includes(cmd.parent))) {
+    return `cherry-picking the merge "${cmd.id}" needs a parent, one of ${source.parents.map((p) => `"${p}"`).join(", ")}`;
+  }
+  if (source.parents.length <= 1 && cmd.parent !== void 0) return `"${cmd.id}" is not a merge, so takes no parent`;
+  return add(s, k, void 0, { parents: [head], type: "NORMAL", source: source.id });
+}
+function step(s, k, cmd) {
+  switch (cmd.kind) {
+    case "commit": {
+      const head = headOf(s, s.current);
+      return add(s, k, cmd.id, { parents: head === void 0 ? [] : [head], type: cmd.type ?? "NORMAL" });
+    }
+    case "branch": {
+      if (s.branches.has(cmd.name)) return `a branch "${cmd.name}" already exists; check it out instead`;
+      const fork = headOf(s, s.current);
+      s.branches.set(cmd.name, {
+        name: cmd.name,
+        created: s.branches.size,
+        commits: [],
+        ...cmd.order !== void 0 ? { order: cmd.order } : {},
+        ...fork !== void 0 ? { fork } : {}
+      });
+      s.current = cmd.name;
+      return null;
+    }
+    case "checkout":
+      if (!s.branches.has(cmd.name)) return `cannot check out "${cmd.name}": there is no such branch; create it with "branch ${cmd.name}"`;
+      s.current = cmd.name;
+      return null;
+    case "merge":
+      return merge(s, k, cmd);
+    case "cherry-pick":
+      return cherryPick(s, k, cmd);
+  }
+}
+function replayGitGraph(data) {
+  const main = data.mainBranch ?? "main";
+  const s = {
+    history: { commits: [], branches: [] },
+    byId: /* @__PURE__ */ new Map(),
+    current: main,
+    branches: /* @__PURE__ */ new Map([[main, { name: main, created: 0, commits: [] }]])
+  };
+  for (let k = 0; k < data.commands.length; k++) {
+    const error = step(s, k, data.commands[k]);
+    if (error !== null) {
+      s.history.error = { command: k, message: error };
+      break;
+    }
+  }
+  const rank = (b) => b.name === main ? Number.NEGATIVE_INFINITY : b.order ?? b.created;
+  s.history.branches = [...s.branches.values()].sort((a, b) => rank(a) - rank(b) || a.created - b.created).map(({ created: _, ...b }) => b);
+  return s.history;
+}
+
+// src/gitgraph/compile.ts
+var RADIUS = 6;
+var GAP4 = 6;
+var MAX_STEP = 50;
+var MAX_LANE = 60;
+function place(data, history, box, labelRoom) {
+  const dir = data.orientation ?? "LR";
+  const lr = dir === "LR";
+  const along = lr ? { start: box.x + labelRoom, size: box.width - labelRoom } : { start: box.y + (dir === "TB" ? labelRoom : 0), size: box.height - labelRoom };
+  const across = lr ? { start: box.y, size: box.height } : { start: box.x, size: box.width };
+  const laneGap = Math.min(MAX_LANE, across.size / Math.max(1, history.branches.length));
+  const lanes = history.branches.map((_, i) => across.start + (i + 0.5) * laneGap);
+  const step2 = Math.min(MAX_STEP, Math.max(0, along.size) / Math.max(1, history.commits.length));
+  const laneOf = new Map(history.branches.map((b, i) => [b.name, lanes[i]]));
+  const points = history.commits.map((c) => {
+    const a = dir === "BT" ? along.start + along.size - (c.seq + 0.5) * step2 : along.start + (c.seq + 0.5) * step2;
+    const x = laneOf.get(c.branch);
+    return lr ? { x: a, y: x } : { x, y: a };
+  });
+  return { history, lanes, points };
+}
+var onLane = (lr, lane, p) => lr ? { x: p.x, y: lane } : { x: lane, y: p.y };
+function lines(layout, lr, theme) {
+  const { history, lanes, points } = layout;
+  const at3 = new Map(history.commits.map((c, i) => [c.id, points[i]]));
+  const laneIndex = new Map(history.branches.map((b, i) => [b.name, i]));
+  const marks = [];
+  history.branches.forEach((b, i) => {
+    const own = b.commits.map((id) => at3.get(id));
+    const fork = b.fork === void 0 ? void 0 : at3.get(b.fork);
+    const path = fork !== void 0 && own.length > 0 ? [fork, onLane(lr, lanes[i], fork), ...own] : own;
+    if (path.length > 1) marks.push(lineMark({ key: `branch:${i}`, points: path, color: seriesColor(theme, i), datum: { branch: b.name } }));
+  });
+  for (const c of history.commits) {
+    const from = c.source ?? (c.parents.length > 1 ? c.parents[1] : void 0);
+    if (from === void 0) continue;
+    const source = history.commits.find((x) => x.id === from);
+    const lane = laneIndex.get(source.branch);
+    const to = at3.get(c.id);
+    marks.push(lineMark({
+      key: `${c.source !== void 0 ? "pick" : "merge"}:${c.command}`,
+      points: [at3.get(from), onLane(lr, lanes[lane], to), to],
+      color: seriesColor(theme, lane),
+      datum: { command: c.command },
+      ...c.source !== void 0 ? { dash: [4, 3] } : {}
+    }));
+  }
+  return marks;
+}
+function commitMarks(c, p, color, theme) {
+  const key = `commit:${c.command}`;
+  const datum = { command: c.command };
+  if (c.type === "HIGHLIGHT") return [barMark({ key, x: p.x - RADIUS, width: 2 * RADIUS, from: p.y - RADIUS, to: p.y + RADIUS, color, datum })];
+  const dot = pointMark({ key, ...p, radius: RADIUS, color, datum });
+  if (c.type !== "REVERSE") return [dot];
+  const r = RADIUS * 0.7;
+  return [
+    dot,
+    ruleMark({ key: `${key}:cross:0`, from: { x: p.x - r, y: p.y - r }, to: { x: p.x + r, y: p.y + r }, color: theme.text, width: 2 }),
+    ruleMark({ key: `${key}:cross:1`, from: { x: p.x - r, y: p.y + r }, to: { x: p.x + r, y: p.y - r }, color: theme.text, width: 2 })
+  ];
+}
+function commitLabels(data, c, p, lr, theme, measure) {
+  const cmd = data.commands[c.command];
+  const small = { ...theme.font, fontSize: Math.round(theme.font.fontSize * 0.85) };
+  const off = RADIUS + 3;
+  const marks = [];
+  if ((cmd.kind === "commit" || cmd.kind === "merge") && cmd.id !== void 0) {
+    marks.push(textMark({
+      key: `commit:${c.command}:id`,
+      text: cmd.id,
+      font: small,
+      color: theme.text,
+      measure,
+      ...lr ? { x: p.x, y: p.y + off, baseline: "top" } : { x: p.x + off, y: p.y, anchor: "start" }
+    }));
+  }
+  if (cmd.kind !== "branch" && cmd.kind !== "checkout" && cmd.tag !== void 0) {
+    marks.push(textMark({
+      key: `commit:${c.command}:tag`,
+      text: cmd.tag,
+      font: theme.font,
+      color: theme.text,
+      measure,
+      bold: true,
+      datum: { edit: "tag", command: c.command },
+      ...lr ? { x: p.x, y: p.y - off, baseline: "bottom" } : { x: p.x - off, y: p.y, anchor: "end" }
+    }));
+  }
+  return marks;
+}
+function compileGitGraph(data, size, theme, measure) {
+  const { marks, top } = chartTitle(data.title, size.width, theme, measure);
+  const dir = data.orientation ?? "LR";
+  const lr = dir === "LR";
+  const history = replayGitGraph(data);
+  const names = history.branches.map((b) => measure(b.name, theme.font));
+  const labelRoom = GAP4 + Math.max(0, ...names.map((s) => lr ? s.width : s.height));
+  const box = { x: CHART_PAD, y: top, width: Math.max(1, size.width - 2 * CHART_PAD), height: Math.max(1, size.height - CHART_PAD - top) };
+  const layout = place(data, history, box, labelRoom);
+  marks.push(...lines(layout, lr, theme));
+  history.commits.forEach((c, i) => {
+    const lane = history.branches.findIndex((b) => b.name === c.branch);
+    marks.push(...commitMarks(c, layout.points[i], seriesColor(theme, lane), theme));
+  });
+  history.commits.forEach((c, i) => marks.push(...commitLabels(data, c, layout.points[i], lr, theme, measure)));
+  history.branches.forEach((b, i) => {
+    const lane = layout.lanes[i];
+    const at3 = lr ? { x: box.x, y: lane, anchor: "start" } : { x: lane, y: dir === "TB" ? box.y : box.y + box.height, baseline: dir === "TB" ? "top" : "bottom" };
+    marks.push(textMark({ key: `branch:${i}:label`, text: b.name, ...at3, font: theme.font, color: seriesColor(theme, i), measure, bold: true, datum: { branch: b.name } }));
+  });
+  return { marks, layout };
+}
+
+// src/journey/compile.ts
+var GAP5 = 6;
+var RADIUS2 = 8;
+var DOT = 3;
+var journeySteps = (data) => data.sections.flatMap((s, section) => s.tasks.map((_, task) => ({ section, task })));
+var journeyActors = (data) => [...new Set(data.sections.flatMap((s) => s.tasks.flatMap((t) => t.actors)))];
+function journeyLayout(data, size, top, legend2, theme, measure) {
+  const line = measure("Mg", theme.font).height;
+  const probe = linearScale({ domain: [0.5, 5.5], range: [0, 1] });
+  const left = CHART_PAD + axisRoom({ scale: probe, side: "left", theme, measure });
+  const right = size.width - CHART_PAD - (legend2 > 0 ? legend2 + 2 * GAP5 : 0);
+  const plotTop = top + line + 2 * GAP5;
+  const bottom = size.height - CHART_PAD - line - 3 * GAP5 - 2 * DOT;
+  const plot = { x: left, y: plotTop, width: Math.max(1, right - left), height: Math.max(1, bottom - plotTop) };
+  return {
+    plot,
+    score: linearScale({ domain: [0.5, 5.5], range: [plot.y + plot.height, plot.y] }),
+    steps: bandScale({ domain: journeySteps(data).map((_, k) => String(k)), range: [plot.x, plot.x + plot.width] })
+  };
+}
+function sectionMarks(data, layout, theme, measure) {
+  const marks = [];
+  const height = measure("Mg", theme.font).height + GAP5;
+  let k = 0;
+  data.sections.forEach((section, s) => {
+    const first = k;
+    k += section.tasks.length;
+    if (section.tasks.length === 0) return;
+    const x0 = layout.steps.start(String(first));
+    const x1 = layout.steps.start(String(k - 1)) + layout.steps.bandwidth;
+    const y = layout.plot.y - GAP5 - height;
+    marks.push(spanMark({ key: `section:${s}`, x0, x1, y, height, color: seriesColor(theme, s), opacity: 0.35, datum: { section: s } }));
+    if (section.name !== void 0) {
+      marks.push(textMark({
+        key: `section:label:${s}`,
+        text: section.name,
+        x: (x0 + x1) / 2,
+        y: y + height / 2,
+        font: theme.font,
+        color: theme.text,
+        measure,
+        bold: true,
+        datum: { edit: "section", section: s }
+      }));
+    }
+  });
+  return marks;
+}
+function stepMarks(data, layout, actors, theme, measure) {
+  const marks = [];
+  const baseline = layout.plot.y + layout.plot.height;
+  const line = measure("Mg", theme.font).height;
+  journeySteps(data).forEach(({ section, task }, k) => {
+    const step2 = data.sections[section].tasks[task];
+    const x = layout.steps.position(String(k));
+    const y = layout.score.map(Math.min(5, Math.max(1, step2.score)));
+    const id = `${section}:${task}`;
+    const datum = { section, task };
+    marks.push(ruleMark({ key: `task:rule:${id}`, from: { x, y: y + RADIUS2 }, to: { x, y: baseline }, color: theme.axis, datum }));
+    marks.push(pointMark({ key: `task:${id}`, x, y, radius: RADIUS2, color: seriesColor(theme, section), datum }));
+    marks.push(textMark({
+      key: `task:label:${id}`,
+      text: step2.name,
+      x,
+      y: baseline + GAP5,
+      baseline: "top",
+      font: theme.font,
+      color: theme.text,
+      measure,
+      datum: { edit: "task", section, task }
+    }));
+    const dotsY = baseline + GAP5 + line + GAP5 + DOT;
+    const spread = 3 * DOT;
+    step2.actors.forEach((actor, a) => {
+      marks.push(pointMark({
+        key: `task:actor:${id}:${a}`,
+        x: x + (a - (step2.actors.length - 1) / 2) * spread,
+        y: dotsY,
+        radius: DOT,
+        color: actors.map(actor),
+        datum: { section, task, actor }
+      }));
+    });
+  });
+  return marks;
+}
+function legendMarks(names, actors, x, midY, theme, measure) {
+  const row = measure("Mg", theme.font).height + GAP5;
+  const top = midY - (row * names.length - GAP5) / 2;
+  return names.flatMap((actor, k) => {
+    const y = top + k * row + (row - GAP5) / 2;
+    return [
+      pointMark({ key: `legend:actor:${k}`, x: x + 2 * DOT, y, radius: 2 * DOT, color: actors.map(actor), datum: { actor } }),
+      textMark({
+        key: `legend:label:${k}`,
+        text: actor,
+        x: x + 4 * DOT + GAP5,
+        y,
+        anchor: "start",
+        font: theme.font,
+        color: theme.text,
+        measure,
+        datum: { actor }
+      })
+    ];
+  });
+}
+function compileJourney(data, size, theme, measure) {
+  const { marks, top } = chartTitle(data.title, size.width, theme, measure);
+  const names = journeyActors(data);
+  const actors = ordinalScale({ domain: names, range: theme.series });
+  const legend2 = names.length === 0 ? 0 : 4 * DOT + GAP5 + Math.max(...names.map((n2) => measure(n2, theme.font).width));
+  const layout = journeyLayout(data, size, top, legend2, theme, measure);
+  marks.push(...axisMarks({ key: "axis:score", scale: layout.score, side: "left", at: layout.plot.x, gridTo: layout.plot.x + layout.plot.width, theme, measure }));
+  marks.push(...sectionMarks(data, layout, theme, measure), ...stepMarks(data, layout, actors, theme, measure));
+  marks.push(...legendMarks(names, actors, layout.plot.x + layout.plot.width + 2 * GAP5, layout.plot.y + layout.plot.height / 2, theme, measure));
+  return { marks, layout };
+}
+
+// src/packet/compile.ts
+var BOX = 32;
+var GAP6 = 6;
+var INSET = 2;
+var packetBitsPerRow = (data) => Math.max(1, Math.floor(data.bitsPerRow ?? 32));
+function packetPieces(field, bitsPerRow) {
+  if (!(field.start >= 0 && field.end >= field.start)) return [];
+  const pieces = [];
+  for (let row = Math.floor(field.start / bitsPerRow); row <= Math.floor(field.end / bitsPerRow); row++) {
+    pieces.push({ row, lo: Math.max(field.start, row * bitsPerRow), hi: Math.min(field.end, (row + 1) * bitsPerRow - 1) });
+  }
+  return pieces;
+}
+function packetLayout(data, size, top, theme, measure) {
+  const bitsPerRow = packetBitsPerRow(data);
+  const ends = data.fields.filter((f) => f.start >= 0 && f.end >= f.start).map((f) => f.end);
+  const rows = ends.length === 0 ? 0 : Math.floor(Math.max(...ends) / bitsPerRow) + 1;
+  const line = measure("0", theme.font).height;
+  const bits = bandScale({
+    domain: Array.from({ length: bitsPerRow }, (_, i) => String(i)),
+    range: [CHART_PAD, Math.max(CHART_PAD + 1, size.width - CHART_PAD)],
+    paddingInner: 0,
+    paddingOuter: 0
+  });
+  return { bits, bitsPerRow, rows, boxTop: (row) => top + row * (line + INSET + BOX + GAP6) + line + INSET, boxHeight: BOX };
+}
+function fieldMarks(field, i, layout, theme, measure) {
+  const { bits, bitsPerRow, boxHeight } = layout;
+  const marks = [];
+  const font = { font: theme.font, color: theme.text, measure };
+  let widest = null;
+  for (const { row, lo, hi } of packetPieces(field, bitsPerRow)) {
+    const x0 = bits.start(String(lo % bitsPerRow));
+    const x1 = bits.start(String(hi % bitsPerRow)) + bits.bandwidth;
+    const y = layout.boxTop(row);
+    const box = spanMark({ key: `field:${i}:${row}`, x0, x1, y, height: boxHeight, color: seriesColor(theme, i), opacity: 0.3, datum: { field: i } });
+    box.data.stroke = { paint: { color: theme.axis }, width: 1 };
+    marks.push(box);
+    if (widest === null || x1 - x0 > widest.x1 - widest.x0) widest = { x0, x1, y };
+    const numberAt = { y: y - INSET, baseline: "bottom" };
+    if (hi === lo) {
+      marks.push(textMark({ ...font, ...numberAt, key: `bit:${i}:${row}:start`, text: String(lo), x: (x0 + x1) / 2 }));
+      continue;
+    }
+    marks.push(textMark({ ...font, ...numberAt, key: `bit:${i}:${row}:start`, text: String(lo), x: x0 + INSET, anchor: "start" }));
+    marks.push(textMark({ ...font, ...numberAt, key: `bit:${i}:${row}:end`, text: String(hi), x: x1 - INSET, anchor: "end" }));
+  }
+  if (widest !== null) {
+    marks.push(textMark({
+      ...font,
+      key: `field:label:${i}`,
+      text: field.label,
+      x: (widest.x0 + widest.x1) / 2,
+      y: widest.y + boxHeight / 2,
+      datum: { edit: "label", field: i }
+    }));
+  }
+  return marks;
+}
+function compilePacket(data, size, theme, measure) {
+  const { marks, top } = chartTitle(data.title, size.width, theme, measure);
+  const layout = packetLayout(data, size, top, theme, measure);
+  data.fields.forEach((field, i) => marks.push(...fieldMarks(field, i, layout, theme, measure)));
+  return { marks, layout };
+}
+
+// src/pie/compile.ts
+var SWATCH = 12;
+var GAP7 = 6;
+var LEGEND_GAP = 16;
+var LABEL_RADIUS = 0.75;
+var piePercent = (value, total) => `${total > 0 ? (value / total * 100).toFixed(0) : "0"}%`;
+var pieValueText = (value) => `[${value}]`;
+function pieAngles(data) {
+  const values = data.slices.map((s) => Number.isFinite(s.value) && s.value > 0 ? s.value : 0);
+  const total = values.reduce((a, b) => a + b, 0);
+  let at3 = 0;
+  return values.map((v) => {
+    const start = at3;
+    at3 += total > 0 ? v / total * 2 * Math.PI : 0;
+    return { start, end: at3 };
+  });
+}
+function legendMarks2(data, x, midY, theme, measure) {
+  const row = measure("Mg", theme.font).height + GAP7;
+  const top = midY - (row * data.slices.length - GAP7) / 2;
+  const marks = [];
+  data.slices.forEach((slice, i) => {
+    const y = top + i * row;
+    const mid = y + (row - GAP7) / 2;
+    const base = { font: theme.font, color: theme.text, measure, anchor: "start", baseline: "middle" };
+    marks.push(spanMark({ key: `legend:swatch:${i}`, x0: x, x1: x + SWATCH, y: mid - SWATCH / 2, height: SWATCH, color: seriesColor(theme, i), datum: { slice: i } }));
+    const label = textMark({ ...base, key: `legend:label:${i}`, text: slice.label, x: x + SWATCH + GAP7, y: mid, datum: { edit: "label", slice: i } });
+    marks.push(label);
+    if (data.showData) {
+      marks.push(textMark({
+        ...base,
+        key: `legend:value:${i}`,
+        text: pieValueText(slice.value),
+        x: label.pose.x + label.pose.width + GAP7,
+        y: mid,
+        datum: { edit: "value", slice: i }
+      }));
+    }
+  });
+  return marks;
+}
+function legendWidth(data, theme, measure) {
+  if (data.slices.length === 0) return 0;
+  const widest = Math.max(...data.slices.map((s) => {
+    const label = measure(s.label, theme.font).width;
+    return data.showData ? label + GAP7 + measure(pieValueText(s.value), theme.font).width : label;
+  }));
+  return SWATCH + GAP7 + widest;
+}
+function compilePie(data, size, theme, measure) {
+  const { marks, top } = chartTitle(data.title, size.width, theme, measure);
+  const legend2 = legendWidth(data, theme, measure);
+  const right = size.width - CHART_PAD - (legend2 > 0 ? legend2 + LEGEND_GAP : 0);
+  const area = { width: Math.max(0, right - CHART_PAD), height: Math.max(0, size.height - CHART_PAD - top) };
+  const center = { x: CHART_PAD + area.width / 2, y: top + area.height / 2 };
+  const radius = Math.min(area.width, area.height) / 2;
+  const angles = pieAngles(data);
+  const total = data.slices.reduce((sum, s) => sum + (Number.isFinite(s.value) && s.value > 0 ? s.value : 0), 0);
+  data.slices.forEach((slice, i) => {
+    const { start, end } = angles[i];
+    if (end <= start || radius < 1) return;
+    marks.push(arcMark({ key: `slice:${i}`, center, innerRadius: 0, outerRadius: radius, startAngle: start, endAngle: end, color: seriesColor(theme, i), datum: { slice: i } }));
+    const text = piePercent(slice.value, total);
+    const room = measure(text, theme.font);
+    const mid = (start + end) / 2;
+    const r = radius * LABEL_RADIUS;
+    if ((end - start) * r < room.width + 4 || radius * (1 - LABEL_RADIUS) * 2 < room.height) return;
+    marks.push(textMark({
+      key: `percent:${i}`,
+      text,
+      x: center.x + r * Math.sin(mid),
+      y: center.y - r * Math.cos(mid),
+      font: theme.font,
+      color: theme.text,
+      measure,
+      datum: { slice: i }
+    }));
+  });
+  marks.push(...legendMarks2(data, right + (legend2 > 0 ? LEGEND_GAP : 0), center.y, theme, measure));
+  return { marks, layout: { center, radius, angles } };
+}
+
+// src/quadrant/compile.ts
+var GAP8 = 6;
+var RADIUS3 = 5;
+var quadrantAt = (layout, x, y) => ({
+  x: layout.plot.x + x * layout.plot.width,
+  y: layout.plot.y + (1 - y) * layout.plot.height
+});
+function quadrantValueAt(layout, at3) {
+  const unit2 = (v) => Math.round(Math.min(1, Math.max(0, v)) * 100) / 100;
+  return { x: unit2((at3.x - layout.plot.x) / layout.plot.width), y: unit2(1 - (at3.y - layout.plot.y) / layout.plot.height) };
+}
+function quadrantStyleOf(data, point) {
+  const cls = point.className !== void 0 ? data.classes?.[point.className] : void 0;
+  return { ...cls, ...point.style };
+}
+function quadrantLayout(size, top, theme, measure) {
+  const line = measure("Mg", theme.font).height;
+  const left = CHART_PAD + line + GAP8;
+  const bottom = size.height - CHART_PAD - line - GAP8;
+  return { plot: { x: left, y: top, width: Math.max(1, size.width - CHART_PAD - left), height: Math.max(1, bottom - top) } };
+}
+var CORNERS = [[0.5, 1], [0, 1], [0, 0.5], [0.5, 0.5]];
+function quadrantMarks(data, layout, theme, measure) {
+  const marks = [];
+  const { plot } = layout;
+  CORNERS.forEach(([x, y], i) => {
+    const corner = quadrantAt(layout, x, y);
+    marks.push(spanMark({
+      key: `quadrant:${i + 1}`,
+      x0: corner.x,
+      x1: corner.x + plot.width / 2,
+      y: corner.y,
+      height: plot.height / 2,
+      color: seriesColor(theme, i),
+      opacity: 0.15,
+      datum: { quadrant: i + 1 }
+    }));
+  });
+  const mid = quadrantAt(layout, 0.5, 0.5);
+  marks.push(ruleMark({ key: "divider:x", from: { x: mid.x, y: plot.y }, to: { x: mid.x, y: plot.y + plot.height }, color: theme.axis }));
+  marks.push(ruleMark({ key: "divider:y", from: { x: plot.x, y: mid.y }, to: { x: plot.x + plot.width, y: mid.y }, color: theme.axis }));
+  CORNERS.forEach(([x, y], i) => {
+    const text = data.quadrants?.[i];
+    if (!text) return;
+    const center = quadrantAt(layout, x + 0.25, y - 0.25);
+    marks.push(textMark({
+      key: `quadrant:label:${i + 1}`,
+      text,
+      ...center,
+      font: theme.font,
+      color: theme.text,
+      measure,
+      bold: true,
+      datum: { edit: "quadrant", quadrant: i + 1 }
+    }));
+  });
+  return marks;
+}
+function axisLabelMarks(data, layout, theme, measure) {
+  const { plot } = layout;
+  const marks = [];
+  const base = { font: theme.font, color: theme.text, measure };
+  for (const axis of ["x", "y"]) {
+    const ends = data[axis];
+    for (const end of ["low", "high"]) {
+      const text = ends?.[end];
+      if (!text) continue;
+      const along = ends?.high ? end === "low" ? 0.25 : 0.75 : 0.5;
+      const datum = { edit: "axis", axis, end };
+      marks.push(axis === "x" ? textMark({ ...base, key: `axis:x:${end}`, text, x: plot.x + along * plot.width, y: plot.y + plot.height + GAP8, baseline: "top", datum }) : textMark({ ...base, key: `axis:y:${end}`, text, x: plot.x - GAP8, y: plot.y + (1 - along) * plot.height, baseline: "bottom", vertical: true, datum }));
+    }
+  }
+  return marks;
+}
+function pointMarks(data, layout, theme, measure) {
+  const marks = [];
+  data.points.forEach((p, i) => {
+    const style = quadrantStyleOf(data, p);
+    const at3 = quadrantAt(layout, p.x, p.y);
+    const radius = style.radius ?? RADIUS3;
+    const mark = pointMark({ key: `point:${i}`, ...at3, radius, color: style.color ?? theme.text, datum: { point: i } });
+    if (style.strokeColor !== void 0 || style.strokeWidth !== void 0) {
+      mark.data.stroke = { paint: { color: style.strokeColor ?? theme.text }, width: style.strokeWidth ?? 1 };
+    }
+    marks.push(mark);
+    marks.push(textMark({
+      key: `point:label:${i}`,
+      text: p.name,
+      x: at3.x + radius + GAP8,
+      y: at3.y,
+      anchor: "start",
+      font: theme.font,
+      color: theme.text,
+      measure,
+      datum: { edit: "point", point: i }
+    }));
+  });
+  return marks;
+}
+function compileQuadrant(data, size, theme, measure) {
+  const { marks, top } = chartTitle(data.title, size.width, theme, measure);
+  const layout = quadrantLayout(size, top, theme, measure);
+  marks.push(...quadrantMarks(data, layout, theme, measure), ...axisLabelMarks(data, layout, theme, measure), ...pointMarks(data, layout, theme, measure));
+  return { marks, layout };
+}
+
+// src/radar/compile.ts
+var GAP9 = 6;
+var SWATCH2 = 10;
+var RING_STEPS = 72;
+function radarDomain(data) {
+  const values = data.curves.flatMap((c) => c.values).filter(Number.isFinite);
+  const min = data.min ?? 0;
+  const max = data.max ?? Math.max(min, ...values);
+  return max === min ? [min, min + 1] : [min, max];
+}
+var labelOf = (item) => item.label ?? item.id;
+function legend(data, top, width2, theme, measure) {
+  if (data.showLegend === false || data.curves.length === 0) return { marks: [], width: 0 };
+  const sizes = data.curves.map((c) => measure(labelOf(c), theme.font));
+  const room = SWATCH2 + GAP9 + Math.max(...sizes.map((s) => s.width));
+  const x = width2 - CHART_PAD - room;
+  const marks = [];
+  let y = top;
+  data.curves.forEach((c, i) => {
+    const h = Math.max(SWATCH2, sizes[i].height);
+    const color = seriesColor(theme, i);
+    marks.push(pointMark({ key: `legend:${i}:swatch`, x: x + SWATCH2 / 2, y: y + h / 2, radius: SWATCH2 / 2, color, datum: { curve: i } }));
+    marks.push(textMark({
+      key: `legend:${i}:label`,
+      text: labelOf(c),
+      x: x + SWATCH2 + GAP9,
+      y: y + h / 2,
+      anchor: "start",
+      font: theme.font,
+      color: theme.text,
+      measure,
+      datum: { edit: "curve", curve: i }
+    }));
+    y += h + GAP9;
+  });
+  return { marks, width: room + GAP9 };
+}
+function labelPlacement(angle) {
+  const s = Math.sin(angle);
+  const c = Math.cos(angle);
+  return {
+    anchor: s > 0.1 ? "start" : s < -0.1 ? "end" : "middle",
+    baseline: c > 0.1 ? "bottom" : c < -0.1 ? "top" : "middle"
+  };
+}
+function graticule(data, scale, theme, measure) {
+  const n2 = data.axes.length;
+  const rings = Math.max(1, Math.floor(data.ticks ?? 5));
+  const [d0, d1] = scale.domain;
+  const { center } = scale;
+  const marks = [];
+  for (let k = 1; k <= rings; k++) {
+    const v = d0 + (d1 - d0) * k / rings;
+    const r = scale.radiusAt(v);
+    const points = data.graticule === "polygon" && n2 >= 3 ? Array.from({ length: n2 + 1 }, (_, i) => scale.point(i % n2, v)) : Array.from({ length: RING_STEPS + 1 }, (_, j) => {
+      const a = 2 * Math.PI * j / RING_STEPS;
+      return { x: center.x + r * Math.sin(a), y: center.y - r * Math.cos(a) };
+    });
+    marks.push(lineMark({ key: `grid:ring:${k}`, points, color: theme.grid, width: 1 }));
+  }
+  data.axes.forEach((axis, i) => {
+    marks.push(ruleMark({ key: `grid:spoke:${i}`, from: scale.point(i, d0), to: scale.point(i, d1), color: theme.axis }));
+    const a = scale.angle(i);
+    const r = scale.radius[1] + GAP9;
+    marks.push(textMark({
+      key: `axis:${i}:label`,
+      text: labelOf(axis),
+      x: center.x + r * Math.sin(a),
+      y: center.y - r * Math.cos(a),
+      ...labelPlacement(a),
+      font: theme.font,
+      color: theme.text,
+      measure,
+      datum: { edit: "axis", axis: i }
+    }));
+  });
+  return marks;
+}
+function curveMarks(data, scale, theme) {
+  const marks = [];
+  data.curves.forEach((curve, c) => {
+    const color = seriesColor(theme, c);
+    const placed = data.axes.flatMap((_, i) => {
+      const v = curve.values[i];
+      return v !== void 0 && Number.isFinite(v) ? [{ i, at: scale.point(i, v) }] : [];
+    });
+    if (placed.length === 0) return;
+    const ring = placed.map((p) => p.at);
+    marks.push(areaMark({ key: `curve:${c}`, top: ring, color, datum: { curve: c } }));
+    marks.push(lineMark({ key: `curve:${c}:outline`, points: [...ring, ring[0]], color, datum: { curve: c } }));
+    for (const { i, at: at3 } of placed) marks.push(pointMark({ key: `point:${c}:${i}`, ...at3, radius: 3.5, color, datum: { curve: c, axis: i } }));
+  });
+  return marks;
+}
+function compileRadar(data, size, theme, measure) {
+  const { marks, top } = chartTitle(data.title, size.width, theme, measure);
+  const key = legend(data, top, size.width, theme, measure);
+  const labels2 = data.axes.map((a) => measure(labelOf(a), theme.font));
+  const across = GAP9 + Math.max(0, ...labels2.map((l) => l.width));
+  const down = GAP9 + Math.max(0, ...labels2.map((l) => l.height));
+  const box = { x: CHART_PAD, y: top, width: size.width - 2 * CHART_PAD - key.width, height: size.height - CHART_PAD - top };
+  const outer = Math.max(1, Math.min(box.width / 2 - across, box.height / 2 - down));
+  const scale = polarScale({
+    center: { x: box.x + box.width / 2, y: box.y + box.height / 2 },
+    radius: [0, outer],
+    domain: radarDomain(data),
+    axes: data.axes.length
+  });
+  marks.push(...graticule(data, scale, theme, measure), ...curveMarks(data, scale, theme), ...key.marks);
+  return { marks, layout: { scale } };
+}
+
+// src/sankey/layout.ts
+var SANKEY_NODE_WIDTH = 12;
+var NODE_GAP = 12;
+var SWEEPS = 4;
+var flowOf = (v) => Number.isFinite(v) && v > 0 ? v : 0;
+var sankeyNodes = (data) => [...new Set(data.links.flatMap((l) => [l.source, l.target]))];
+function depths(n2, edges) {
+  const out = Array.from({ length: n2 }, () => []);
+  for (const [s, t] of edges) out[s].push(t);
+  const state = new Array(n2).fill(0);
+  const order = [];
+  const forward = Array.from({ length: n2 }, () => []);
+  const visit = (root) => {
+    const stack = [{ node: root, next: 0 }];
+    state[root] = 1;
+    while (stack.length > 0) {
+      const top = stack[stack.length - 1];
+      const t = out[top.node][top.next++];
+      if (t === void 0) {
+        state[top.node] = 2;
+        order.push(top.node);
+        stack.pop();
+      } else if (state[t] !== 1) {
+        forward[top.node].push(t);
+        if (state[t] === 0) {
+          state[t] = 1;
+          stack.push({ node: t, next: 0 });
+        }
+      }
+    }
+  };
+  for (let k = 0; k < n2; k++) if (state[k] === 0) visit(k);
+  const depth = new Array(n2).fill(0);
+  for (const s of order.reverse()) for (const t of forward[s]) depth[t] = Math.max(depth[t], depth[s] + 1);
+  return depth;
+}
+function orderColumns(columns, center, edges, restack) {
+  const sweep = (col, near) => {
+    const key = new Map(col.map((k) => {
+      const ws = near(k);
+      const total = ws.reduce((a, [, w]) => a + w, 0);
+      return [k, total > 0 ? ws.reduce((a, [o, w]) => a + center(o) * w, 0) / total : center(k)];
+    }));
+    col.sort((a, b) => key.get(a) - key.get(b));
+    restack(col);
+  };
+  const into = (k) => edges.filter(([, t]) => t === k).map(([s, , w]) => [s, Math.max(w, 1e-9)]);
+  const outOf = (k) => edges.filter(([s]) => s === k).map(([, t, w]) => [t, Math.max(w, 1e-9)]);
+  for (let i = 0; i < SWEEPS; i++) {
+    for (let c = 1; c < columns.length; c++) sweep(columns[c], into);
+    for (let c = columns.length - 2; c >= 0; c--) sweep(columns[c], outOf);
+  }
+}
+function sankeyLayout(data, box) {
+  const labels2 = sankeyNodes(data);
+  const index = new Map(labels2.map((l, k) => [l, k]));
+  const edges = data.links.map((l) => [index.get(l.source), index.get(l.target), flowOf(l.value)]);
+  const column2 = depths(labels2.length, edges.map(([s, t]) => [s, t]));
+  const ins = labels2.map((_, k) => edges.filter(([, t]) => t === k).reduce((a, [, , w]) => a + w, 0));
+  const outs = labels2.map((_, k) => edges.filter(([s]) => s === k).reduce((a, [, , w]) => a + w, 0));
+  const value = labels2.map((_, k) => Math.max(ins[k], outs[k]));
+  const count = labels2.length === 0 ? 0 : Math.max(...column2) + 1;
+  const columns = Array.from({ length: count }, (_, c) => labels2.flatMap((_2, k) => column2[k] === c ? [k] : []));
+  const tallest = Math.max(1, ...columns.map((c) => c.length));
+  const gap = Math.min(NODE_GAP, box.height / 2 / tallest);
+  const ky = Math.max(0, Math.min(...columns.map((c) => {
+    const total = c.reduce((a, k) => a + value[k], 0);
+    return total > 0 ? (box.height - gap * (c.length - 1)) / total : Number.POSITIVE_INFINITY;
+  })));
+  const scale = Number.isFinite(ky) ? ky : 0;
+  const y = new Array(labels2.length).fill(0);
+  const stack = (col) => {
+    const total = col.reduce((a, k) => a + value[k] * scale, 0) + gap * (col.length - 1);
+    let at3 = box.y + (box.height - total) / 2;
+    for (const k of col) {
+      y[k] = at3;
+      at3 += value[k] * scale + gap;
+    }
+  };
+  columns.forEach(stack);
+  orderColumns(columns, (k) => y[k] + value[k] * scale / 2, edges, stack);
+  const step2 = count > 1 ? (box.width - SANKEY_NODE_WIDTH) / (count - 1) : 0;
+  const nodes = labels2.map((label, k) => ({
+    label,
+    column: column2[k],
+    value: value[k],
+    x: box.x + column2[k] * step2,
+    y: y[k],
+    width: SANKEY_NODE_WIDTH,
+    height: value[k] * scale
+  }));
+  return { nodes, links: ribbons(nodes, edges, scale), columns: count };
+}
+function ribbons(nodes, edges, scale) {
+  const mid = (k) => nodes[k].y + nodes[k].height / 2;
+  const offsets = (side) => {
+    const at3 = new Array(edges.length).fill(0);
+    nodes.forEach((node, k) => {
+      const mine = edges.map((e, i) => ({ e, i })).filter(({ e }) => e[side] === k);
+      mine.sort((a, b) => mid(a.e[1 - side]) - mid(b.e[1 - side]) || a.i - b.i);
+      let y = node.y;
+      for (const { e, i } of mine) {
+        at3[i] = y;
+        y += e[2] * scale;
+      }
+    });
+    return at3;
+  };
+  const leave = offsets(0);
+  const reach = offsets(1);
+  return edges.map(([s, t, w], i) => {
+    const h = w * scale;
+    return {
+      source: s,
+      target: t,
+      from: { x: nodes[s].x + nodes[s].width, y0: leave[i], y1: leave[i] + h },
+      to: { x: nodes[t].x, y0: reach[i], y1: reach[i] + h }
+    };
+  });
+}
+
+// src/sankey/compile.ts
+var LABEL_GAP2 = 6;
+var formatFlow = (v) => String(Number(v.toPrecision(12)));
+function nodeLabels(node, k, columns, theme, measure) {
+  const right = node.column * 2 < columns - 1 || columns === 1;
+  const x = right ? node.x + node.width + LABEL_GAP2 : node.x - LABEL_GAP2;
+  const y = node.y + node.height / 2;
+  const anchor = right ? "start" : "end";
+  const base = { x, anchor, font: theme.font, color: theme.text, measure };
+  return [
+    textMark({ ...base, key: `node:${k}:label`, text: node.label, y, baseline: "bottom", datum: { edit: "node", node: node.label } }),
+    textMark({ ...base, key: `node:${k}:value`, text: formatFlow(node.value), y, baseline: "top" })
+  ];
+}
+function compileSankey(data, size, theme, measure) {
+  const { marks, top } = chartTitle(data.title, size.width, theme, measure);
+  const box = { x: CHART_PAD, y: top, width: Math.max(1, size.width - 2 * CHART_PAD), height: Math.max(1, size.height - CHART_PAD - top) };
+  const layout = sankeyLayout(data, box);
+  layout.links.forEach((r, i) => {
+    marks.push(ribbonMark({ key: `link:${i}`, from: r.from, to: r.to, color: seriesColor(theme, r.source), datum: { link: i } }));
+  });
+  layout.nodes.forEach((node, k) => {
+    marks.push(barMark({ key: `node:${k}`, x: node.x, width: node.width, from: node.y, to: node.y + node.height, color: seriesColor(theme, k), datum: { node: node.label } }));
+  });
+  layout.links.forEach((r, i) => {
+    marks.push(textMark({
+      key: `link:${i}:value`,
+      text: formatFlow(data.links[i].value),
+      x: (r.from.x + r.to.x) / 2,
+      y: (r.from.y0 + r.from.y1 + r.to.y0 + r.to.y1) / 4,
+      font: theme.font,
+      color: theme.text,
+      measure,
+      datum: { edit: "value", link: i }
+    }));
+  });
+  layout.nodes.forEach((node, k) => marks.push(...nodeLabels(node, k, layout.columns, theme, measure)));
+  return { marks, layout };
+}
+
+// src/timeline/edit.ts
+function timelinePeriodAt(data, period) {
+  if (!Number.isInteger(period) || period < 0) return null;
+  let left = period;
+  for (let s = 0; s < data.sections.length; s++) {
+    const n2 = data.sections[s].periods.length;
+    if (left < n2) return { section: s, index: left };
+    left -= n2;
+  }
+  return null;
+}
+var timelineLength = (data) => data.sections.reduce((n2, s) => n2 + s.periods.length, 0);
+function locate(data, period, what) {
+  const at3 = timelinePeriodAt(data, period);
+  if (at3 === null) throw new Error(`${what}: the timeline holds no period ${period}`);
+  return at3;
+}
+function withPeriod(data, at3, next) {
+  return {
+    ...data,
+    sections: data.sections.map((s, i) => i === at3.section ? { ...s, periods: s.periods.map((p, j) => j === at3.index ? next : p) } : s)
+  };
+}
+function setTimelineSectionName(data, section, name) {
+  const target = data.sections[section];
+  if (target === void 0) throw new Error(`setTimelineSectionName: the timeline holds no section ${section}`);
+  const text = name.trim();
+  if (text === "" || text === target.name) return data;
+  return { ...data, sections: data.sections.map((s, i) => i === section ? { ...s, name: text } : s) };
+}
+function setTimelinePeriodLabel(data, period, label) {
+  const at3 = locate(data, period, "setTimelinePeriodLabel");
+  const target = data.sections[at3.section].periods[at3.index];
+  const text = label.trim();
+  if (text === "" || text === target.label) return data;
+  return withPeriod(data, at3, { ...target, label: text });
+}
+function setTimelineEvent(data, period, event, text) {
+  const at3 = locate(data, period, "setTimelineEvent");
+  const target = data.sections[at3.section].periods[at3.index];
+  if (!Number.isInteger(event) || event < 0 || event >= target.events.length) {
+    throw new Error(`setTimelineEvent: period ${period} holds no event ${event}`);
+  }
+  const value = text.trim();
+  if (value === target.events[event]) return data;
+  const events = value === "" ? target.events.filter((_, i) => i !== event) : target.events.map((e, i) => i === event ? value : e);
+  return withPeriod(data, at3, { ...target, events });
+}
+function moveTimelinePeriod(data, from, to) {
+  const n2 = timelineLength(data);
+  locate(data, from, "moveTimelinePeriod");
+  if (!Number.isInteger(to) || to < 0 || to >= n2) throw new Error(`moveTimelinePeriod: the timeline holds no period ${to}`);
+  if (from === to) return data;
+  const flat = data.sections.flatMap((s, section) => s.periods.map((period) => ({ section, period })));
+  const [moved] = flat.splice(from, 1);
+  const neighbor = to > from ? flat[to - 1] : flat[to];
+  flat.splice(to, 0, { section: neighbor.section, period: moved.period });
+  const sections = [];
+  data.sections.forEach((s, i) => {
+    const periods = flat.filter((f) => f.section === i).map((f) => f.period);
+    if (periods.length > 0) sections.push({ ...s, periods });
+  });
+  return { ...data, sections };
+}
+
+// src/timeline/compile.ts
+var BOX_PAD = 6;
+var INSET2 = 4;
+var GAP10 = 8;
+var LINE_GAP = 14;
+var EVENT_GAP = 6;
+function compileTimeline(data, size, theme, measure) {
+  const { marks, top } = chartTitle(data.title, size.width, theme, measure);
+  const n2 = timelineLength(data);
+  const columnWidth = Math.max(1, size.width - 2 * CHART_PAD) / Math.max(1, n2);
+  const slots = Array.from({ length: n2 }, (_, i) => CHART_PAD + columnWidth * (i + 0.5));
+  const boxHeight = measure("Mg", theme.font).height + 2 * BOX_PAD;
+  const named2 = data.sections.some((s) => s.name !== void 0);
+  const periodTop = top + (named2 ? boxHeight + GAP10 : 0);
+  const lineY = periodTop + boxHeight + LINE_GAP;
+  const bottom = Math.max(lineY, size.height - CHART_PAD);
+  const font = { font: theme.font, color: theme.text, measure };
+  const boxes = [];
+  const texts = [];
+  let p = 0;
+  data.sections.forEach((section, s) => {
+    const color = seriesColor(theme, s);
+    const first = p;
+    for (const period of section.periods) {
+      const x = CHART_PAD + columnWidth * p + INSET2;
+      const width2 = Math.max(1, columnWidth - 2 * INSET2);
+      boxes.push(spanMark({ key: `period:${p}:box`, x0: x, x1: x + width2, y: periodTop, height: boxHeight, color, datum: { period: p } }));
+      texts.push(textMark({ key: `period:${p}:label`, text: period.label, x: slots[p], y: periodTop + boxHeight / 2, ...font, bold: true, datum: { edit: "period", period: p } }));
+      boxes.push(ruleMark({ key: `period:${p}:stem`, from: { x: slots[p], y: lineY }, to: { x: slots[p], y: lineY + LINE_GAP }, color, dash: [3, 3] }));
+      let y = lineY + LINE_GAP;
+      period.events.forEach((event, e) => {
+        boxes.push(spanMark({ key: `event:${p}:${e}:box`, x0: x, x1: x + width2, y, height: boxHeight, color, opacity: 0.35, datum: { period: p, event: e } }));
+        texts.push(textMark({ key: `event:${p}:${e}:label`, text: event, x: slots[p], y: y + boxHeight / 2, ...font, datum: { edit: "event", period: p, event: e } }));
+        y += boxHeight + EVENT_GAP;
+      });
+      p++;
+    }
+    if (section.name === void 0 || p === first) return;
+    const x0 = CHART_PAD + columnWidth * first;
+    const x1 = CHART_PAD + columnWidth * p;
+    marks.push(spanMark({ key: `section:${s}:band`, x0, x1, y: top, height: bottom - top, color, opacity: 0.12, datum: { section: s } }));
+    boxes.push(spanMark({ key: `section:${s}:header`, x0: x0 + INSET2, x1: x1 - INSET2, y: top, height: boxHeight, color, datum: { section: s } }));
+    texts.push(textMark({ key: `section:${s}:label`, text: section.name, x: (x0 + x1) / 2, y: top + boxHeight / 2, ...font, bold: true, datum: { edit: "section", section: s } }));
+  });
+  if (n2 > 0) marks.push(ruleMark({ key: "line", from: { x: CHART_PAD, y: lineY }, to: { x: size.width - CHART_PAD, y: lineY }, color: theme.axis, width: 2 }));
+  marks.push(...boxes);
+  slots.forEach((x, i) => marks.push(pointMark({ key: `period:${i}:dot`, x, y: lineY, radius: 4, color: theme.axis, datum: { period: i } })));
+  marks.push(...texts);
+  return { marks, layout: { slots, columnWidth } };
+}
+function timelineSlotAt(layout, x) {
+  let best = -1;
+  layout.slots.forEach((slot, i) => {
+    if (best < 0 || Math.abs(slot - x) < Math.abs(layout.slots[best] - x)) best = i;
+  });
+  return best;
+}
+
+// src/xychart/compile.ts
+var BAND_PADDING = 0.2;
+var xyLength = (data) => Math.max(0, ...data.series.map((s) => s.values.length));
+function categoriesOf(data) {
+  if (data.x?.kind === "band" && data.x.categories.length > 0) return [...data.x.categories];
+  return Array.from({ length: xyLength(data) }, (_, i) => String(i + 1));
+}
+function xyValueDomain(data) {
+  const values = data.series.flatMap((s) => s.values).filter(Number.isFinite);
+  const lo = Math.min(0, ...values);
+  const hi = Math.max(0, ...values);
+  const [niceLo, niceHi] = niceDomain([lo, hi === lo ? lo + 1 : hi]);
+  const min = data.y?.min ?? niceLo;
+  const max = data.y?.max ?? niceHi;
+  return min === max ? [min, min + 1] : [min, max];
+}
+function categoryAxis(data, range) {
+  const n2 = xyLength(data);
+  if (data.x?.kind === "range") {
+    const scale2 = linearScale({ domain: [data.x.min, data.x.max], range });
+    const step2 = (range[1] - range[0]) / Math.max(1, n2);
+    const slots2 = Array.from({ length: n2 }, (_, i) => range[0] + step2 * (i + 0.5));
+    return { scale: scale2, slots: slots2, slotWidth: Math.abs(step2) * (1 - BAND_PADDING) };
+  }
+  const categories = categoriesOf(data);
+  const scale = bandScale({ domain: categories, range, paddingInner: BAND_PADDING });
+  const slots = Array.from({ length: n2 }, (_, i) => i < categories.length ? scale.position(categories[i]) : Number.NaN);
+  return { scale, slots, slotWidth: scale.bandwidth };
+}
+function compileXyChart(data, size, theme, measure) {
+  const vertical = data.orientation !== "horizontal";
+  const { marks, top } = chartTitle(data.title, size.width, theme, measure);
+  const domain = xyValueDomain(data);
+  const base = { theme, measure, at: 0 };
+  const valueTitle = data.y?.title !== void 0 ? { title: data.y.title } : {};
+  const categoryTitle = data.x?.title !== void 0 ? { title: data.x.title } : {};
+  const probe = categoryAxis(data, [0, 1]);
+  const valueRoom = axisRoom({ ...base, ...valueTitle, scale: linearScale({ domain, range: [0, 1] }), side: vertical ? "left" : "bottom" });
+  const categoryRoom = axisRoom({ ...base, ...categoryTitle, scale: probe.scale, side: vertical ? "bottom" : "left" });
+  const left = CHART_PAD + (vertical ? valueRoom : categoryRoom);
+  const bottom = size.height - CHART_PAD - (vertical ? categoryRoom : valueRoom);
+  const plot = { x: left, y: top, width: Math.max(1, size.width - CHART_PAD - left), height: Math.max(1, bottom - top) };
+  const right = plot.x + plot.width;
+  const value = linearScale({ domain, range: vertical ? [bottom, top] : [left, right] });
+  const category = categoryAxis(data, vertical ? [left, right] : [top, bottom]);
+  marks.push(...axisMarks({ ...base, ...valueTitle, key: "axis:value", scale: value, side: vertical ? "left" : "bottom", at: vertical ? left : bottom, gridTo: vertical ? right : top }));
+  marks.push(...axisMarks({ ...base, ...categoryTitle, key: "axis:category", scale: category.scale, side: vertical ? "bottom" : "left", at: vertical ? bottom : left }));
+  const layout = { orientation: vertical ? "vertical" : "horizontal", plot, value, slots: category.slots, slotWidth: category.slotWidth };
+  marks.push(...seriesMarks(data, layout, theme));
+  return { marks, layout };
+}
+function seriesMarks(data, layout, theme) {
+  const { value, slots, slotWidth } = layout;
+  const vertical = layout.orientation === "vertical";
+  const at3 = (along, v) => vertical ? { x: along, y: value.map(v) } : { x: value.map(v), y: along };
+  const [d0, d1] = value.domain;
+  const baseline = value.map(Math.min(Math.max(0, Math.min(d0, d1)), Math.max(d0, d1)));
+  const bars = data.series.filter((s) => s.kind === "bar");
+  const barWidth = slotWidth / Math.max(1, bars.length);
+  const categories = categoriesOf(data);
+  const marks = [];
+  data.series.forEach((series, s) => {
+    const color = seriesColor(theme, s);
+    const datum = (i) => ({ series: s, index: i, value: series.values[i], category: categories[i] ?? String(i + 1) });
+    const placed = series.values.map((v, i) => ({ v, i })).filter(({ v, i }) => Number.isFinite(v) && Number.isFinite(slots[i] ?? Number.NaN));
+    if (series.kind === "bar") {
+      const j = bars.indexOf(series);
+      for (const { v, i } of placed) {
+        marks.push(barMark({
+          key: `bar:${s}:${i}`,
+          x: slots[i] - slotWidth / 2 + j * barWidth,
+          width: barWidth,
+          from: baseline,
+          to: value.map(v),
+          color,
+          datum: datum(i),
+          orient: layout.orientation
+        }));
+      }
+      return;
+    }
+    if (placed.length > 0) {
+      marks.push(lineMark({ key: `line:${s}`, points: placed.map(({ v, i }) => at3(slots[i], v)), color, datum: { series: s } }));
+    }
+    for (const { v, i } of placed) marks.push(pointMark({ key: `point:${s}:${i}`, ...at3(slots[i], v), radius: 3.5, color, datum: datum(i) }));
+  });
+  return marks;
+}
+
+// src/plotData.ts
+var COMPILERS = {
+  xychart: compileXyChart,
+  gantt: compileGantt,
+  timeline: compileTimeline,
+  pie: compilePie,
+  quadrant: compileQuadrant,
+  journey: compileJourney,
+  gitgraph: compileGitGraph,
+  sankey: compileSankey,
+  packet: compilePacket,
+  radar: compileRadar
+};
+function compilePlot(data, size, theme, measure) {
+  const compile = COMPILERS[data.kind];
+  if (compile === void 0) throw new Error(`compilePlot: no chart of kind "${data.kind}"`);
+  return compile(data, size, theme, measure).marks;
+}
+
+// src/xychart/edit.ts
+var xyRows = (data) => Math.max(data.x?.kind === "band" ? data.x.categories.length : 0, xyLength(data));
+function setXyValue(data, series, index, value) {
+  const target = data.series[series];
+  if (target === void 0 || !Number.isInteger(index) || index < 0 || index >= xyRows(data)) {
+    throw new Error(`setXyValue: series ${series} holds no value ${index}`);
+  }
+  if (target.values[index] === value) return data;
+  const values = Array.from({ length: Math.max(target.values.length, index + 1) }, (_, i) => i === index ? value : target.values[i] ?? 0);
+  return { ...data, series: data.series.map((s, i) => i === series ? { ...s, values } : s) };
+}
+function xyValueAt(layout, at3) {
+  const raw = layout.value.invert(layout.orientation === "vertical" ? at3.y : at3.x);
+  const step2 = layout.value.tickStep() / 10;
+  return Number((Math.round(raw / step2) * step2).toFixed(decimalsOf(step2)));
+}
+
+// src/gantt/edit.ts
+function taskAt(data, section, task, what) {
+  const found = data.sections[section]?.tasks[task];
+  if (found === void 0) throw new Error(`${what}: the gantt holds no task ${task} in section ${section}`);
+  return found;
+}
+function withTask(data, section, task, next) {
+  return {
+    ...data,
+    sections: data.sections.map((s, i) => i === section ? { ...s, tasks: s.tasks.map((t, j) => j === task ? next : t) } : s)
+  };
+}
+var snapGantt = (t, step2) => Math.round(t / step2) * step2;
+function moveGanttTask(data, section, task, start) {
+  const target = taskAt(data, section, task, "moveGanttTask");
+  const date = formatGanttDate(start, dateFormatOf(data));
+  if (target.start.kind === "date" && target.start.date === date) return data;
+  return withTask(data, section, task, { ...target, start: { kind: "date", date } });
+}
+function setGanttEnd(data, section, task, end) {
+  const target = taskAt(data, section, task, "setGanttEnd");
+  const start = scheduleGantt(data).spans[section][task].start;
+  const old = target.end;
+  let next;
+  if (old.kind === "date") {
+    next = { kind: "date", date: formatGanttDate(Math.max(start, end), dateFormatOf(data)) };
+    if (next.date === old.date) return data;
+  } else {
+    const unit2 = old.kind === "duration" ? old.unit : "d";
+    const least = target.tags?.includes("milestone") ? 0 : 1;
+    const amount = Math.max(least, ganttDurationBetween(start, end, unit2, excludedDays(data)));
+    if (old.kind === "duration" && old.amount === amount) return data;
+    next = { kind: "duration", amount, unit: unit2 };
+  }
+  return withTask(data, section, task, { ...target, end: next });
+}
+function setGanttSectionName(data, section, name) {
+  const target = data.sections[section];
+  if (target === void 0) throw new Error(`setGanttSectionName: the gantt holds no section ${section}`);
+  const text = name.trim();
+  if (text === "" || text === target.name) return data;
+  return { ...data, sections: data.sections.map((s, i) => i === section ? { ...s, name: text } : s) };
+}
+function setGanttTaskName(data, section, task, name) {
+  const target = taskAt(data, section, task, "setGanttTaskName");
+  const text = name.trim();
+  if (text === "" || text === target.name) return data;
+  return withTask(data, section, task, { ...target, name: text });
+}
+
+// src/pie/edit.ts
+function withSlice(data, slice, change, who) {
+  const target = data.slices[slice];
+  if (target === void 0) throw new Error(`${who}: the pie holds no slice ${slice}`);
+  if (Object.entries(change).every(([k, v]) => target[k] === v)) return data;
+  return { ...data, slices: data.slices.map((s, i) => i === slice ? { ...s, ...change } : s) };
+}
+var setPieValue = (data, slice, value) => withSlice(data, slice, { value }, "setPieValue");
+var setPieLabel = (data, slice, label) => withSlice(data, slice, { label }, "setPieLabel");
+function pieValueOf(text) {
+  const bare = text.trim().replace(/^\[\s*(.*?)\s*\]$/, "$1");
+  if (!/^\+?(?:\d+\.?\d*|\.\d+)(?:e[+-]?\d+)?$/i.test(bare)) return null;
+  const value = Number(bare);
+  return Number.isFinite(value) ? value : null;
+}
+
+// src/quadrant/edit.ts
+function withPoint(data, point, change, who) {
+  const target = data.points[point];
+  if (target === void 0) throw new Error(`${who}: the chart holds no point ${point}`);
+  if (Object.entries(change).every(([k, v]) => target[k] === v)) return data;
+  return { ...data, points: data.points.map((p, i) => i === point ? { ...p, ...change } : p) };
+}
+var setQuadrantPoint = (data, point, at3) => withPoint(data, point, { x: at3.x, y: at3.y }, "setQuadrantPoint");
+var setQuadrantPointName = (data, point, name) => withPoint(data, point, { name }, "setQuadrantPointName");
+function setQuadrantAxisLabel(data, axis, end, text) {
+  const ends = data[axis] ?? {};
+  if ((ends[end] ?? "") === text) return data;
+  const { [end]: _, ...rest } = ends;
+  const next = text === "" ? rest : { ...rest, [end]: text };
+  const { [axis]: __, ...others } = data;
+  return Object.keys(next).length === 0 ? others : { ...others, [axis]: next };
+}
+function setQuadrantLabel(data, quadrant, text) {
+  if (![1, 2, 3, 4].includes(quadrant)) throw new Error(`setQuadrantLabel: there is no quadrant ${quadrant}`);
+  if ((data.quadrants?.[quadrant - 1] ?? "") === text) return data;
+  const q = data.quadrants;
+  const labels2 = [q?.[0], q?.[1], q?.[2], q?.[3]];
+  labels2[quadrant - 1] = text === "" ? void 0 : text;
+  const { quadrants: _, ...rest } = data;
+  while (labels2.length > 0 && labels2[labels2.length - 1] === void 0) labels2.pop();
+  return labels2.length === 0 ? rest : { ...rest, quadrants: labels2 };
+}
+
+// src/journey/edit.ts
+function withTask2(data, section, task, change, who) {
+  const target = data.sections[section]?.tasks[task];
+  if (target === void 0) throw new Error(`${who}: section ${section} holds no step ${task}`);
+  if (Object.entries(change).every(([k, v]) => target[k] === v)) return data;
+  return {
+    ...data,
+    sections: data.sections.map((s, i) => i === section ? { ...s, tasks: s.tasks.map((t, j) => j === task ? { ...t, ...change } : t) } : s)
+  };
+}
+var setJourneyScore = (data, section, task, score) => withTask2(data, section, task, { score }, "setJourneyScore");
+var setJourneyTaskName = (data, section, task, name) => withTask2(data, section, task, { name }, "setJourneyTaskName");
+function setJourneySectionName(data, section, name) {
+  const target = data.sections[section];
+  if (target === void 0) throw new Error(`setJourneySectionName: the journey holds no section ${section}`);
+  if (target.name === name) return data;
+  return { ...data, sections: data.sections.map((s, i) => i === section ? { ...s, name } : s) };
+}
+var journeyScoreAt = (layout, at3) => Math.min(5, Math.max(1, Math.round(layout.score.invert(at3.y))));
+
+// src/gitgraph/edit.ts
+function setGitTag(data, command, text) {
+  const cmd = data.commands[command];
+  if (cmd === void 0 || cmd.kind === "branch" || cmd.kind === "checkout") throw new Error(`setGitTag: command ${command} makes no commit`);
+  const tag = text.trim();
+  if ((cmd.tag ?? "") === tag) return data;
+  const { tag: _, ...rest } = cmd;
+  const next = tag === "" ? rest : { ...rest, tag };
+  return { ...data, commands: data.commands.map((c, i) => i === command ? next : c) };
+}
+
+// src/sankey/edit.ts
+function setSankeyValue(data, link, value) {
+  const target = data.links[link];
+  if (target === void 0) throw new Error(`setSankeyValue: no link ${link}`);
+  if (target.value === value) return data;
+  return { ...data, links: data.links.map((l, i) => i === link ? { ...l, value } : l) };
+}
+function renameSankeyNode(data, from, to) {
+  const nodes = sankeyNodes(data);
+  if (!nodes.includes(from)) throw new Error(`renameSankeyNode: no node "${from}"`);
+  if (from === to) return data;
+  if (nodes.includes(to)) throw new Error(`renameSankeyNode: a node is already called "${to}"`);
+  const named2 = (n2) => n2 === from ? to : n2;
+  return { ...data, links: data.links.map((l) => l.source === from || l.target === from ? { ...l, source: named2(l.source), target: named2(l.target) } : l) };
+}
+
+// src/packet/edit.ts
+function setPacketLabel(data, field, label) {
+  const target = data.fields[field];
+  if (target === void 0) throw new Error(`setPacketLabel: the packet holds no field ${field}`);
+  if (target.label === label) return data;
+  return { ...data, fields: data.fields.map((f, i) => i === field ? { ...f, label } : f) };
+}
+
+// src/radar/edit.ts
+function setRadarValue(data, curve, axis, value) {
+  const target = data.curves[curve];
+  if (target === void 0 || axis < 0 || axis >= data.axes.length) throw new Error(`setRadarValue: curve ${curve} holds no value on axis ${axis}`);
+  if (target.values[axis] === value) return data;
+  const values = data.axes.map((_, i) => i === axis ? value : target.values[i] ?? 0);
+  return { ...data, curves: data.curves.map((c, i) => i === curve ? { ...c, values } : c) };
+}
+function relabel(items, index, text, what) {
+  const item = items[index];
+  if (item === void 0) throw new Error(`${what}: no item ${index}`);
+  const label = text.trim();
+  const next = label === "" || label === item.id ? void 0 : label;
+  if (next === item.label) return null;
+  const { label: _, ...rest } = item;
+  return items.map((x, i) => i === index ? next === void 0 ? rest : { ...rest, label: next } : x);
+}
+function setRadarAxisLabel(data, axis, text) {
+  const axes = relabel(data.axes, axis, text, "setRadarAxisLabel");
+  return axes === null ? data : { ...data, axes };
+}
+function setRadarCurveLabel(data, curve, text) {
+  const curves = relabel(data.curves, curve, text, "setRadarCurveLabel");
+  return curves === null ? data : { ...data, curves };
+}
+function radarValueAt(layout, axis, at3) {
+  const raw = layout.scale.valueAt(axis, at3);
+  const step2 = layout.scale.tickStep() / 10;
+  return Number((Math.round(raw / step2) * step2).toFixed(decimalsOf(step2)));
+}
+
+// src/plotScene.ts
+function plotRootOf(node) {
+  const plot = node?.data?.plot;
+  return plot !== void 0 && plot !== null && typeof plot === "object" && typeof plot.data?.kind === "string" ? plot : null;
+}
+function plotMarkOf(node) {
+  const mark = node?.data?.plotMark;
+  return mark !== void 0 && mark !== null && typeof mark.kind === "string" ? mark : null;
+}
+var plotMarkId = (rootId, key) => `${rootId}/${key}`;
+function markSpecs(rootId, layer, marks) {
+  return marks.map((m) => ({
+    kind: "mark",
+    id: plotMarkId(rootId, m.key),
+    parent: rootId,
+    layer,
+    pose: { x: m.pose.x, y: m.pose.y, width: m.pose.width, height: m.pose.height, ...m.pose.rotation ? { rotation: m.pose.rotation } : {} },
+    data: m.data
+  }));
+}
+function plotSpecs(data, opts) {
+  const id = opts.id ?? "plot";
+  const layer = opts.layer ?? "main";
+  const theme = opts.theme ?? PLOT_THEME;
+  const { x, y, width: width2, height } = opts.box;
+  const marks = compilePlot(data, { width: width2, height }, theme, opts.measure ?? textMeasure);
+  const root = { kind: "group", id, layer, pose: { x, y, width: width2, height }, data: { plot: { data, theme } } };
+  return [root, ...markSpecs(id, layer, marks)];
+}
+function rootTrait(scene, rootId) {
+  const node = scene.get(rootId);
+  const trait = plotRootOf(node);
+  if (node === void 0 || trait === null) throw new Error(`replacePlotData: "${rootId}" is not a plot root`);
+  return { node, trait };
+}
+function replacePlotData(scene, rootId, data, opts = {}) {
+  const s = scene;
+  const { node, trait } = rootTrait(s, rootId);
+  const theme = opts.theme ?? trait.theme;
+  const pose = node.pose;
+  const marks = compilePlot(data, { width: pose.width, height: pose.height }, theme, opts.measure ?? textMeasure);
+  s.batch(opts.label ?? "Edit chart", () => {
+    s.update(node.id, { data: { ...node.data, plot: { data, theme } } });
+    const children = s.childrenOf(node.id);
+    if (children.length > 0) s.removeMany(children);
+    for (const spec of markSpecs(rootId, node.layer, marks)) s.add(spec);
+  });
+}
+function plotRootContaining(scene, id) {
+  const node = scene.get(id);
+  if (node === void 0) return null;
+  if (plotRootOf(node) !== null) return node.id;
+  const parent = plotMarkOf(node) !== null ? node.parent : null;
+  return parent !== null && parent !== void 0 && plotRootOf(scene.get(parent)) !== null ? parent : null;
+}
+function plotRootsIn(scene) {
+  return scene.renderOrderNodes().filter((n2) => plotRootOf(n2) !== null).map((n2) => n2.id);
+}
+
+// src/gantt/editor.ts
+function taskOf(data, datum) {
+  const { section, task } = datum ?? {};
+  if (typeof section !== "number" || typeof task !== "number") return null;
+  return data.sections[section]?.tasks[task] !== void 0 ? { section, task } : null;
+}
+function setText(data, datum, text) {
+  if (datum.edit === "title") return withTitle(data, text);
+  if (datum.edit === "section" && typeof datum.section === "number" && data.sections[datum.section] !== void 0) {
+    return setGanttSectionName(data, datum.section, text);
+  }
+  const at3 = datum.edit === "task" ? taskOf(data, datum) : null;
+  return at3 === null ? data : setGanttTaskName(data, at3.section, at3.task, text);
+}
+var ganttEditor = {
+  handle(data, { trait, pose }) {
+    if (trait.kind !== "span" && trait.kind !== "area" || taskOf(data, trait.datum) === null) return null;
+    const cy = pose.y + pose.height / 2;
+    if (trait.kind === "area") return { at: { x: pose.x + pose.width / 2, y: cy }, cursor: "move", part: "move", box: pose };
+    return [
+      { at: { x: pose.x, y: cy }, cursor: "move", part: "move", box: pose },
+      { at: { x: pose.x + pose.width, y: cy }, cursor: "ew-resize", part: "end" }
+    ];
+  },
+  drag(data, trait, size, theme, measure, part) {
+    const at3 = taskOf(data, trait.datum);
+    if (at3 === null || part !== "move" && part !== "end") return null;
+    const { layout } = compileGantt(data, size, theme, measure);
+    const instant = (x) => snapGantt(layout.time.invert(x), layout.snap);
+    if (part === "move") return (p) => moveGanttTask(data, at3.section, at3.task, instant(p.x));
+    const snaps = data.sections[at3.section].tasks[at3.task].end.kind === "date";
+    return (p) => setGanttEnd(data, at3.section, at3.task, snaps ? instant(p.x) : layout.time.invert(p.x));
+  },
+  text: setText
+};
+
+// src/gitgraph/editor.ts
+var gitgraphEditor = {
+  handle: () => null,
+  drag: () => null,
+  text(data, datum, text) {
+    if (datum.edit === "title") return withTitle(data, text);
+    if (datum.edit === "tag" && typeof datum.command === "number") return setGitTag(data, datum.command, text);
+    return data;
+  }
+};
+
+// src/journey/editor.ts
+var stepOf = (data, datum) => {
+  const d = datum;
+  if (typeof d?.section !== "number" || typeof d.task !== "number") return null;
+  return data.sections[d.section]?.tasks[d.task] !== void 0 ? { section: d.section, task: d.task } : null;
+};
+var journeyEditor = {
+  handle(data, { trait, pose }) {
+    if (trait.kind !== "point" || trait.datum?.actor !== void 0 || stepOf(data, trait.datum) === null) return null;
+    return { at: { x: pose.x + pose.width / 2, y: pose.y + pose.height / 2 }, cursor: "ns-resize" };
+  },
+  drag(data, trait, size, theme, measure) {
+    const step2 = stepOf(data, trait.datum);
+    if (step2 === null || trait.datum?.actor !== void 0) return null;
+    const { layout } = compileJourney(data, size, theme, measure);
+    return (at3) => setJourneyScore(data, step2.section, step2.task, journeyScoreAt(layout, at3));
+  },
+  text(data, datum, text) {
+    const t = text.trim();
+    if (datum.edit === "title") return withTitle(data, text);
+    if (datum.edit === "section" && typeof datum.section === "number" && data.sections[datum.section] !== void 0 && t !== "") {
+      return setJourneySectionName(data, datum.section, t);
+    }
+    const step2 = datum.edit === "task" ? stepOf(data, datum) : null;
+    return step2 === null || t === "" ? data : setJourneyTaskName(data, step2.section, step2.task, t);
+  }
+};
+
+// src/packet/editor.ts
+var packetEditor = {
+  handle: () => null,
+  drag: () => null,
+  text(data, datum, text) {
+    if (datum.edit === "title") return withTitle(data, text);
+    const label = text.trim();
+    const field = datum.field;
+    if (datum.edit !== "label" || typeof field !== "number" || data.fields[field] === void 0 || label === "") return data;
+    return setPacketLabel(data, field, label);
+  }
+};
+
+// src/pie/editor.ts
+var pieEditor = {
+  handle: () => null,
+  drag: () => null,
+  text(data, datum, text) {
+    if (datum.edit === "title") return withTitle(data, text);
+    const slice = datum.slice;
+    if (typeof slice !== "number" || data.slices[slice] === void 0) return data;
+    if (datum.edit === "label") {
+      const label = text.trim();
+      return label === "" ? data : setPieLabel(data, slice, label);
+    }
+    if (datum.edit === "value") {
+      const value = pieValueOf(text);
+      return value === null ? data : setPieValue(data, slice, value);
+    }
+    return data;
+  }
+};
+
+// src/quadrant/editor.ts
+var pointOf = (data, datum) => {
+  const p = datum?.point;
+  return typeof p === "number" && data.points[p] !== void 0 ? p : null;
+};
+var quadrantEditor = {
+  handle(data, { trait, pose }) {
+    if (trait.kind !== "point" || pointOf(data, trait.datum) === null) return null;
+    return { at: { x: pose.x + pose.width / 2, y: pose.y + pose.height / 2 }, cursor: "move" };
+  },
+  drag(data, trait, size, theme, measure) {
+    const point = pointOf(data, trait.datum);
+    if (point === null) return null;
+    const { layout } = compileQuadrant(data, size, theme, measure);
+    return (at3) => setQuadrantPoint(data, point, quadrantValueAt(layout, at3));
+  },
+  text(data, datum, text) {
+    const t = text.trim();
+    switch (datum.edit) {
+      case "title":
+        return withTitle(data, text);
+      case "axis":
+        return (datum.axis === "x" || datum.axis === "y") && (datum.end === "low" || datum.end === "high") ? setQuadrantAxisLabel(data, datum.axis, datum.end, t) : data;
+      case "quadrant":
+        return typeof datum.quadrant === "number" && [1, 2, 3, 4].includes(datum.quadrant) ? setQuadrantLabel(data, datum.quadrant, t) : data;
+      case "point": {
+        const point = pointOf(data, datum);
+        return point === null || t === "" ? data : setQuadrantPointName(data, point, t);
+      }
+      default:
+        return data;
+    }
+  }
+};
+
+// src/radar/editor.ts
+var curveAxis = (datum) => {
+  const d = datum;
+  return typeof d?.curve === "number" && typeof d.axis === "number" ? { curve: d.curve, axis: d.axis } : null;
+};
+var radarEditor = {
+  handle(_data, { trait, pose }) {
+    if (trait.kind !== "point" || curveAxis(trait.datum) === null) return null;
+    return { at: { x: pose.x + pose.width / 2, y: pose.y + pose.height / 2 }, cursor: "move" };
+  },
+  drag(data, trait, size, theme, measure) {
+    const which = curveAxis(trait.datum);
+    if (which === null) return null;
+    const { layout } = compileRadar(data, size, theme, measure);
+    return (at3) => setRadarValue(data, which.curve, which.axis, radarValueAt(layout, which.axis, at3));
+  },
+  text(data, datum, text) {
+    if (datum.edit === "title") return withTitle(data, text);
+    if (datum.edit === "axis" && typeof datum.axis === "number") return setRadarAxisLabel(data, datum.axis, text);
+    if (datum.edit === "curve" && typeof datum.curve === "number") return setRadarCurveLabel(data, datum.curve, text);
+    return data;
+  }
+};
+
+// src/sankey/editor.ts
+var flowOf2 = (text) => {
+  const t = text.trim();
+  const v = Number(t);
+  return t !== "" && Number.isFinite(v) && v >= 0 ? v : null;
+};
+var sankeyEditor = {
+  handle: () => null,
+  drag: () => null,
+  text(data, datum, text) {
+    if (datum.edit === "title") return withTitle(data, text);
+    if (datum.edit === "value" && typeof datum.link === "number") {
+      const v = flowOf2(text);
+      return v === null ? data : setSankeyValue(data, datum.link, v);
+    }
+    if (datum.edit === "node" && typeof datum.node === "string") {
+      const name = text.trim();
+      return name === "" || name === datum.node || sankeyNodes(data).includes(name) ? data : renameSankeyNode(data, datum.node, name);
+    }
+    return data;
+  }
+};
+
+// src/timeline/editor.ts
+var periodOf = (datum) => typeof datum?.period === "number" && datum.event === void 0 ? datum.period : null;
+var numberOf = (v) => typeof v === "number" ? v : null;
+function setText2(data, datum, text) {
+  const section = numberOf(datum.section);
+  const period = numberOf(datum.period);
+  const event = numberOf(datum.event);
+  switch (datum.edit) {
+    case "title":
+      return withTitle(data, text);
+    case "section":
+      return section !== null && data.sections[section] !== void 0 ? setTimelineSectionName(data, section, text) : data;
+    case "period":
+      return period !== null && timelinePeriodAt(data, period) !== null ? setTimelinePeriodLabel(data, period, text) : data;
+    case "event": {
+      const at3 = period === null ? null : timelinePeriodAt(data, period);
+      const held = at3 !== null && event !== null && event >= 0 && event < data.sections[at3.section].periods[at3.index].events.length;
+      return held ? setTimelineEvent(data, period, event, text) : data;
+    }
+    default:
+      return data;
+  }
+}
+var timelineEditor = {
+  handle(_data, { trait, pose }) {
+    if (trait.kind !== "span" || periodOf(trait.datum) === null) return null;
+    return { at: { x: pose.x + pose.width / 2, y: pose.y + pose.height / 2 }, cursor: "ew-resize", box: pose };
+  },
+  drag(data, trait, size, theme, measure) {
+    const from = periodOf(trait.datum);
+    if (from === null || timelinePeriodAt(data, from) === null) return null;
+    const { layout } = compileTimeline(data, size, theme, measure);
+    return (at3) => {
+      const to = timelineSlotAt(layout, at3.x);
+      return to < 0 ? data : moveTimelinePeriod(data, from, to);
+    };
+  },
+  text: setText2
+};
+
+// src/xychart/editor.ts
+var seriesIndex = (datum) => {
+  const d = datum;
+  return typeof d?.series === "number" && typeof d.index === "number" ? { series: d.series, index: d.index } : null;
+};
+var xyEditor = {
+  handle(data, { trait, pose }) {
+    if (trait.kind !== "bar" && trait.kind !== "point" || seriesIndex(trait.datum) === null) return null;
+    const vertical = data.orientation !== "horizontal";
+    const cursor = vertical ? "ns-resize" : "ew-resize";
+    const cx = pose.x + pose.width / 2;
+    const cy = pose.y + pose.height / 2;
+    if (trait.kind === "point") return { at: { x: cx, y: cy }, cursor };
+    const up = Number(trait.datum?.value ?? 0) >= 0;
+    return vertical ? { at: { x: cx, y: up ? pose.y : pose.y + pose.height }, cursor } : { at: { x: up ? pose.x + pose.width : pose.x, y: cy }, cursor };
+  },
+  drag(data, trait, size, theme, measure) {
+    const which = seriesIndex(trait.datum);
+    if (which === null) return null;
+    const { layout } = compileXyChart(data, size, theme, measure);
+    return (at3) => setXyValue(data, which.series, which.index, xyValueAt(layout, at3));
+  },
+  text: (data, datum, text) => datum.edit === "title" ? withTitle(data, text) : data
+};
+
+// src/editing/editors.ts
+var EDITORS = {
+  xychart: xyEditor,
+  gantt: ganttEditor,
+  timeline: timelineEditor,
+  pie: pieEditor,
+  quadrant: quadrantEditor,
+  journey: journeyEditor,
+  gitgraph: gitgraphEditor,
+  sankey: sankeyEditor,
+  packet: packetEditor,
+  radar: radarEditor
+};
+var plotEditorOf = (data) => EDITORS[data.kind] ?? null;
+var handlesOf = (h) => h === null ? [] : Array.isArray(h) ? h : [h];
+function plotTextOf(node) {
+  const mark = plotMarkOf(node);
+  return mark?.kind === "text" && typeof mark.datum?.edit === "string" ? mark.datum : null;
+}
+function compiledText(scene, rootId, markId) {
+  const root = scene.get(rootId);
+  const trait = plotRootOf(root);
+  const { width: width2, height } = root.pose;
+  const key = markId.slice(rootId.length + 1);
+  return compilePlot(trait.data, { width: width2, height }, trait.theme, textMeasure).find((m) => m.key === key)?.data.text;
+}
+var isPlotText = (data) => isTextData(data) && plotTextOf({ data }) !== null;
+function foldPlotText(scene, textId, commit) {
+  const node = scene.get(textId);
+  const datum = plotTextOf(node);
+  const rootId = datum === null ? null : node.parent;
+  const trait = rootId === null ? null : plotRootOf(scene.get(rootId));
+  const editor = trait === null ? null : plotEditorOf(trait.data);
+  const text = node?.data?.text;
+  if (datum === null || trait === null || editor?.text === void 0 || typeof text !== "string") return;
+  const next = editor.text(trait.data, datum, text);
+  if (next === trait.data) {
+    if (text !== compiledText(scene, rootId, textId)) scene.undo();
+    return;
+  }
+  scene.undo();
+  commit({ rootId, data: next, label: "Edit text" });
+}
+function usePlotTextEdit(scene, commit) {
+  const latest = useLatest(commit);
+  return useMemo(() => ({
+    isText: isPlotText,
+    onEnd: (id) => foldPlotText(scene, id, (edit) => latest.current(edit))
+  }), [scene, latest]);
+}
+var PLOT_HANDLE_LAYER_ID = "plot-handles";
+var PLOT_HANDLE_AFFORDANCE_KIND = `layer:${PLOT_HANDLE_LAYER_ID}`;
+function plotHandleScratchOf(hit) {
+  const p = hit?.payload;
+  return p !== void 0 && typeof p.rootId === "string" && typeof p.markId === "string" ? p : null;
+}
+function plotOrigin(scene, rootId) {
+  const pose = composeWorldPose(scenePoseAdapter(scene), rootId, scene.composition.compose);
+  return { x: pose.x, y: pose.y };
+}
+function* plotHandles(scene) {
+  for (const rootId of plotRootsIn(scene)) {
+    const root = scene.get(rootId);
+    const trait = plotRootOf(root);
+    const editor = trait && plotEditorOf(trait.data);
+    if (trait === null || editor === null || scene.isLocked(rootId) || scene.isHidden(rootId)) continue;
+    const origin = plotOrigin(scene, rootId);
+    for (const id of scene.childrenOf(rootId)) {
+      const node = scene.get(id);
+      const mark = plotMarkOf(node);
+      if (node === void 0 || mark === null) continue;
+      for (const handle of handlesOf(editor.handle(trait.data, { trait: mark, pose: node.pose }))) {
+        const { box, part } = handle;
+        yield {
+          rootId,
+          markId: id,
+          cursor: handle.cursor,
+          at: { x: origin.x + handle.at.x, y: origin.y + handle.at.y },
+          ...part !== void 0 ? { part } : {},
+          ...box !== void 0 ? { box: { x: origin.x + box.x, y: origin.y + box.y, width: box.width, height: box.height } } : {}
+        };
+      }
+    }
+  }
+}
+var HIT_RADIUS_PX = 6;
+function handleAffordance(scene) {
+  const regions = () => [...plotHandles(scene)].sort((a, b) => Number(b.box !== void 0) - Number(a.box !== void 0)).map(({ rootId, markId, at: at3, cursor, part, box }) => ({
+    id: part === void 0 ? markId : `${markId}#${part}`,
+    targetId: null,
+    shape: box !== void 0 ? { kind: "rect", ...box } : { kind: "point", x: at3.x, y: at3.y, hitRadiusPx: HIT_RADIUS_PX },
+    cursor,
+    strength: "exclusive",
+    claimedKinds: ["pointer"],
+    bind: () => ({ initialScratch: { rootId, markId, at: at3, ...part !== void 0 ? { part } : {} } })
+  }));
+  return { id: PLOT_HANDLE_LAYER_ID, regions, regionsAt: regions };
+}
+function plotHandleLayer(scene) {
+  return composeAffordanceLayer(PLOT_HANDLE_LAYER_ID, "Plot handles", [handleAffordance(scene)]);
+}
+
+// src/editing/dragAction.ts
+var PLOT_DRAG_ACTION_ID = "plot.dragValue";
+function pressOf(ctx, measure) {
+  const pressed = plotHandleScratchOf(ctx.drag?.affordance);
+  const scene = ctx.deps.scene;
+  const root = pressed === null ? void 0 : scene?.get(pressed.rootId);
+  const trait = plotRootOf(root);
+  const mark = plotMarkOf(pressed === null ? void 0 : scene?.get(pressed.markId));
+  const editor = trait && plotEditorOf(trait.data);
+  if (pressed === null || scene === void 0 || root === void 0 || trait === null || mark === null || editor === null) return null;
+  const size = { width: root.pose.width, height: root.pose.height };
+  const propose = editor.drag(trait.data, mark, size, trait.theme, measure, pressed.part);
+  if (propose === null) return null;
+  const origin = plotOrigin(scene, pressed.rootId);
+  const start = ctx.drag?.start ?? ctx.world;
+  const grab = { x: pressed.at.x - start.x, y: pressed.at.y - start.y };
+  return {
+    rootId: pressed.rootId,
+    propose,
+    toPlot: (w) => ({ x: w.x + grab.x - origin.x, y: w.y + grab.y - origin.y }),
+    redraw: (data) => markSpecs(pressed.rootId, root.layer, compilePlot(data, size, trait.theme, measure)),
+    deps: ctx.deps
+  };
+}
+function commitPlotToScene(edit, ctx, measure = textMeasure) {
+  const scene = ctx.deps.scene;
+  if (scene === void 0 || plotRootOf(scene.get(edit.rootId)) === null) return;
+  replacePlotData(scene, edit.rootId, edit.data, { label: "Edit value", measure });
+}
+function createPlotDragAction(opts = {}) {
+  const measure = opts.measure ?? textMeasure;
+  const commit = opts.commit ?? ((edit, ctx) => commitPlotToScene(edit, ctx, measure));
+  return {
+    id: opts.id ?? PLOT_DRAG_ACTION_ID,
+    label: "Edit value",
+    group: "plot",
+    requires: ["scene"],
+    eligible: { mode: "normal" },
+    invoker: {
+      timing: "ongoing",
+      start(ctx) {
+        const p = pressOf(ctx, measure);
+        if (p === null) return {};
+        let next = null;
+        let shown = /* @__PURE__ */ new Map();
+        let open = true;
+        const scene = ctx.deps.scene;
+        const previewing = () => open && next !== null ? shown : null;
+        return {
+          kind: "plot-drag-value",
+          onMove(moveCtx) {
+            next = p.propose(p.toPlot(moveCtx.world));
+            shown = new Map(p.redraw(next).map((spec) => [spec.id, spec]));
+          },
+          previewIds: () => {
+            const specs = previewing();
+            return specs === null ? null : [...specs.keys()].filter((id) => scene.get(id) !== void 0);
+          },
+          previewPose: (id) => previewing()?.get(id)?.pose ?? null,
+          previewData: (id) => previewing()?.get(id)?.data ?? null,
+          onEnd(endCtx, reason) {
+            open = false;
+            if (reason !== "commit" || next === null) return;
+            commit({ rootId: p.rootId, data: p.propose(p.toPlot(endCtx.world)) }, { ...endCtx, deps: p.deps });
+          }
+        };
+      }
+    },
+    enabled: () => true
+  };
+}
+
+// src/editing/plotEditing.ts
+var GRAB_PLOT_HANDLE_ACTION_ID = "plot.grabHandle";
+var grabHandleAction = {
+  id: GRAB_PLOT_HANDLE_ACTION_ID,
+  label: "Grab chart handle",
+  group: "plot",
+  invoker: { timing: "immediate", run: () => {
+  } },
+  enabled: () => true
+};
+function plotEditing(opts) {
+  const actionId = opts.id ?? PLOT_DRAG_ACTION_ID;
+  const target = `affordance:${PLOT_HANDLE_AFFORDANCE_KIND}`;
+  return {
+    layer: plotHandleLayer(opts.scene),
+    contribution: {
+      id: "weasel-plot-editing",
+      eligibility: { claimed: true },
+      actions: [createPlotDragAction({ ...opts, id: actionId }), grabHandleAction],
+      bindings: [
+        { spec: { kind: "drag", target }, actionId, opts: { id: "weasel-plot-editing.drag" } },
+        { spec: { kind: "pointerDown", target }, actionId: GRAB_PLOT_HANDLE_ACTION_ID, opts: { id: "weasel-plot-editing.pointerDown" } },
+        { spec: { kind: "click", target }, actionId: GRAB_PLOT_HANDLE_ACTION_ID, opts: { id: "weasel-plot-editing.click" } }
+      ]
+    }
+  };
+}
+var ROOT = "plot";
+var FEATURES = ["pick", "edit"];
+function PlotView(props) {
+  return /* @__PURE__ */ jsx(WeaselProvider, { children: /* @__PURE__ */ jsx(Inner, { ...props }) });
+}
+function Inner({ data, onChange, width: width2, height, theme, measure, background, className, "aria-label": label }) {
+  const [initial] = useState(() => plotSpecs(data, {
+    id: ROOT,
+    box: { x: 0, y: 0, width: width2, height },
+    ...theme ? { theme } : {},
+    ...measure ? { measure } : {}
+  }));
+  const scene = useScene({ systemLayers: [{ id: "main" }], initial });
+  const changed = useLatest(onChange);
+  useEffect(() => {
+    const root = scene.get(ROOT);
+    const pose = root?.pose;
+    const trait = plotRootOf(root);
+    const sized = pose !== void 0 && pose.width === width2 && pose.height === height;
+    if (trait === null || trait.data === data && sized && (theme === void 0 || trait.theme === theme)) return;
+    scene.untracked(() => {
+      if (!sized) scene.setPose(ROOT, { x: 0, y: 0, width: width2, height });
+      replacePlotData(scene, ROOT, data, { ...theme ? { theme } : {}, ...measure ? { measure } : {} });
+    });
+  }, [scene, data, width2, height, theme, measure]);
+  useEffect(() => {
+    let last = plotRootOf(scene.get(ROOT))?.data;
+    return scene.subscribe(() => {
+      const now = plotRootOf(scene.get(ROOT))?.data;
+      if (now === void 0 || now === last) return;
+      last = now;
+      changed.current?.(now);
+    });
+  }, [scene, changed]);
+  const editing = useMemo(() => plotEditing({ scene, ...measure ? { measure } : {} }), [scene, measure]);
+  const ambient = useMemo(() => [editing.contribution], [editing]);
+  const textEditor = usePlotTextEdit(scene, (edit) => replacePlotData(scene, edit.rootId, edit.data, {
+    label: edit.label,
+    ...measure ? { measure } : {}
+  }));
+  const [canvas, setCanvas] = useState(null);
+  useEffect(() => canvas === null ? void 0 : canvas.registerLayer(editing.layer), [canvas, editing]);
+  return /* @__PURE__ */ jsx("div", { className, "data-wzl-plot": "", children: /* @__PURE__ */ jsx(
+    SceneCanvas,
+    {
+      ref: setCanvas,
+      scene,
+      features: FEATURES,
+      enableKeybindings: true,
+      ambient,
+      textEditor,
+      width: width2,
+      height,
+      ...background ? { backgroundFill: background } : {},
+      ...label ? { "aria-label": label } : {}
+    }
+  ) });
+}
+
+// src/editing/schemaKit.ts
+var textOf = (v) => typeof v === "string" ? v : void 0;
+var numberOf2 = (v) => typeof v === "number" && Number.isFinite(v) ? v : void 0;
+var integerOf = (v) => {
+  const n2 = numberOf2(v);
+  return n2 !== void 0 && Number.isInteger(n2) ? n2 : void 0;
+};
+var choiceOf = (v, options) => options.includes(v) ? v : void 0;
+var listOf = (text) => text.split(",").map((s) => s.trim()).filter((s) => s !== "");
+var titleField = () => ({
+  key: "title",
+  label: "Title",
+  type: { kind: "string" },
+  optional: true,
+  get: (data) => data.title,
+  set: (data, v) => v === void 0 || typeof v === "string" ? withTitle(data, v ?? "") : data
+});
+
+// src/editing/lists.ts
+function insertAt(list, at3, item, who) {
+  if (!Number.isInteger(at3) || at3 < 0 || at3 > list.length) throw new Error(`${who}: cannot insert at ${at3} in a list of ${list.length}`);
+  return [...list.slice(0, at3), item, ...list.slice(at3)];
+}
+function removeAt(list, at3, who) {
+  if (!Number.isInteger(at3) || at3 < 0 || at3 >= list.length) throw new Error(`${who}: no item ${at3} in a list of ${list.length}`);
+  return list.filter((_, i) => i !== at3);
+}
+function moveAt(list, from, to, who) {
+  const out = removeAt(list, from, who);
+  if (!Number.isInteger(to) || to < 0 || to > out.length) throw new Error(`${who}: cannot move to ${to} in a list of ${list.length}`);
+  out.splice(to, 0, list[from]);
+  return out;
+}
+function updateAt(list, at3, change, who) {
+  if (!Number.isInteger(at3) || at3 < 0 || at3 >= list.length) throw new Error(`${who}: no item ${at3} in a list of ${list.length}`);
+  return list.map((x, i) => i === at3 ? change(x) : x);
+}
+function freshName(base, taken, from = 1, sep = " ") {
+  const used = new Set(taken);
+  let n2 = from;
+  while (used.has(`${base}${sep}${n2}`)) n2++;
+  return `${base}${sep}${n2}`;
+}
+function withOptional(obj, key, value) {
+  const { [key]: _, ...rest } = obj;
+  return value === void 0 ? rest : { ...rest, [key]: value };
+}
+
+// src/gantt/structure.ts
+var TAG_ORDER = ["done", "active", "crit", "milestone"];
+function freshTask(data) {
+  const names = ganttTasks(data).map((t) => t.task.name);
+  return { name: freshName("Task", names, names.length + 1), start: { kind: "previous" }, end: { kind: "duration", amount: 1, unit: "d" } };
+}
+function renameRefs(data, from, to) {
+  const swap = (ids2) => ids2.flatMap((id) => id !== from ? [id] : to === void 0 ? [] : [to]);
+  const start = (s) => {
+    if (s.kind !== "after" || !s.ids.includes(from)) return s;
+    const ids2 = swap(s.ids);
+    return ids2.length > 0 ? { kind: "after", ids: ids2 } : { kind: "previous" };
+  };
+  const end = (e) => {
+    if (e.kind !== "until" || !e.ids.includes(from)) return e;
+    const ids2 = swap(e.ids);
+    return ids2.length > 0 ? { kind: "until", ids: ids2 } : { kind: "duration", amount: 1, unit: "d" };
+  };
+  return {
+    ...data,
+    sections: data.sections.map((s) => ({ ...s, tasks: s.tasks.map((t) => ({ ...t, start: start(t.start), end: end(t.end) })) }))
+  };
+}
+var dropRefs = (data, tasks) => tasks.reduce((d, t) => t.id === void 0 ? d : renameRefs(d, t.id, void 0), data);
+function insertGanttSection(data, at3, section) {
+  const next = section ?? {
+    name: freshName("Section", data.sections.flatMap((s) => s.name === void 0 ? [] : [s.name]), data.sections.length + 1),
+    tasks: [freshTask(data)]
+  };
+  return { ...data, sections: insertAt(data.sections, at3, next, "insertGanttSection") };
+}
+function removeGanttSection(data, section) {
+  const sections = removeAt(data.sections, section, "removeGanttSection");
+  return dropRefs({ ...data, sections }, data.sections[section].tasks);
+}
+var moveGanttSection = (data, from, to) => from === to ? data : { ...data, sections: moveAt(data.sections, from, to, "moveGanttSection") };
+var withTasks = (data, section, change, who) => ({ ...data, sections: updateAt(data.sections, section, (s) => ({ ...s, tasks: change(s.tasks) }), who) });
+var insertGanttTask = (data, section, at3, task) => withTasks(data, section, (tasks) => insertAt(tasks, at3, task ?? freshTask(data), "insertGanttTask"), "insertGanttTask");
+function removeGanttTask(data, section, task) {
+  const gone = data.sections[section]?.tasks[task];
+  const next = withTasks(data, section, (tasks) => removeAt(tasks, task, "removeGanttTask"), "removeGanttTask");
+  return dropRefs(next, gone === void 0 ? [] : [gone]);
+}
+var reorderGanttTask = (data, section, from, to) => from === to ? data : withTasks(data, section, (tasks) => moveAt(tasks, from, to, "reorderGanttTask"), "reorderGanttTask");
+function moveGanttTaskToSection(data, from, task, to, at3) {
+  const moving = data.sections[from]?.tasks[task];
+  if (moving === void 0) throw new Error(`moveGanttTaskToSection: the gantt holds no task ${task} in section ${from}`);
+  if (data.sections[to] === void 0) throw new Error(`moveGanttTaskToSection: the gantt holds no section ${to}`);
+  if (from === to) return reorderGanttTask(data, from, task, at3 ?? data.sections[from].tasks.length - 1);
+  const taken = withTasks(data, from, (tasks) => removeAt(tasks, task, "moveGanttTaskToSection"), "moveGanttTaskToSection");
+  return withTasks(taken, to, (tasks) => insertAt(tasks, at3 ?? tasks.length, moving, "moveGanttTaskToSection"), "moveGanttTaskToSection");
+}
+function withTask3(data, section, task, change, who) {
+  const target = data.sections[section]?.tasks[task];
+  if (target === void 0) throw new Error(`${who}: the gantt holds no task ${task} in section ${section}`);
+  const next = change(target);
+  return next === target ? data : withTasks(data, section, (tasks) => tasks.map((t, i) => i === task ? next : t), who);
+}
+function setGanttTaskId(data, section, task, id) {
+  const next = id?.trim() || void 0;
+  const target = data.sections[section]?.tasks[task];
+  if (target === void 0) throw new Error(`setGanttTaskId: the gantt holds no task ${task} in section ${section}`);
+  if (target.id === next) return data;
+  if (next !== void 0 && /\s/.test(next)) throw new Error(`setGanttTaskId: an id holds no spaces, and "${next}" does`);
+  if (next !== void 0 && ganttTasks(data).some((t) => t.task.id === next)) throw new Error(`setGanttTaskId: a task already has id "${next}"`);
+  const renamed = withTask3(data, section, task, (t) => withOptional(t, "id", next), "setGanttTaskId");
+  return target.id === void 0 ? renamed : renameRefs(renamed, target.id, next);
+}
+var setGanttTaskTags = (data, section, task, tags) => withTask3(data, section, task, (t) => {
+  const next = TAG_ORDER.filter((tag) => tags.includes(tag));
+  const old = TAG_ORDER.filter((tag) => t.tags?.includes(tag));
+  return next.join() === old.join() ? t : withOptional(t, "tags", next.length > 0 ? next : void 0);
+}, "setGanttTaskTags");
+var setGanttTaskStart = (data, section, task, start) => withTask3(data, section, task, (t) => JSON.stringify(t.start) === JSON.stringify(start) ? t : { ...t, start }, "setGanttTaskStart");
+var setGanttTaskEnd = (data, section, task, end) => withTask3(data, section, task, (t) => JSON.stringify(t.end) === JSON.stringify(end) ? t : { ...t, end }, "setGanttTaskEnd");
+function setGanttSetting(data, key, value) {
+  const text = value?.trim() || void 0;
+  return data[key] === text ? data : withOptional(data, key, text);
+}
+function setGanttExcludes(data, excludes) {
+  const next = excludes.map((e) => e.trim()).filter((e) => e !== "");
+  if (next.join() === (data.excludes ?? []).join()) return data;
+  return withOptional(data, "excludes", next.length > 0 ? next : void 0);
+}
+
+// src/gantt/text.ts
+var DURATION = /^(\d+(?:\.\d+)?|\.\d+)(ms|[smhdwMy])$/;
+var ids = (text) => text.trim().split(/\s+/);
+var formatGanttStart = (start) => start.kind === "date" ? start.date : start.kind === "after" ? `after ${start.ids.join(" ")}` : "";
+function parseGanttStart(text) {
+  const t = text.trim();
+  if (t === "") return { kind: "previous" };
+  const after = /^after\s+(.+)$/.exec(t);
+  return after !== null ? { kind: "after", ids: ids(after[1]) } : { kind: "date", date: t };
+}
+function formatGanttEnd(end) {
+  if (end.kind === "date") return end.date;
+  if (end.kind === "until") return `until ${end.ids.join(" ")}`;
+  return `${end.amount}${end.unit}`;
+}
+function parseGanttEnd(text) {
+  const t = text.trim();
+  const until = /^until\s+(.+)$/.exec(t);
+  if (until !== null) return { kind: "until", ids: ids(until[1]) };
+  const d = DURATION.exec(t);
+  return d !== null ? { kind: "duration", amount: Number(d[1]), unit: d[2] } : { kind: "date", date: t };
+}
+
+// src/gantt/schema.ts
+var setting = (key, label, placeholder) => ({
+  key,
+  label,
+  type: { kind: "string", placeholder },
+  optional: true,
+  get: (d) => d[key],
+  set: (d, v) => v === void 0 || typeof v === "string" ? setGanttSetting(d, key, v) : d
+});
+var taskOf2 = (d, scope, row) => d.sections[scope[0]]?.tasks[row];
+var reads = (d, at3) => at3.kind !== "date" || parseGanttDate(at3.date, dateFormatOf(d)) !== null;
+var tagColumn = (tag, label) => ({
+  key: tag,
+  label,
+  type: { kind: "boolean" },
+  get: (d, s, r) => taskOf2(d, s, r)?.tags?.includes(tag) ?? false,
+  set: (d, s, r, v) => {
+    const tags = taskOf2(d, s, r)?.tags ?? [];
+    if (typeof v !== "boolean") return d;
+    return setGanttTaskTags(d, s[0], r, v ? [...tags, tag] : tags.filter((t) => t !== tag));
+  }
+});
+var sectionChoices = (d) => d.sections.map((s, i) => `${i + 1}. ${s.name ?? "Untitled section"}`);
+var sectionColumn = (d) => ({
+  key: "section",
+  label: "Section",
+  type: { kind: "enum", options: sectionChoices(d) },
+  get: (data, s) => sectionChoices(data)[s[0]],
+  set: (data, s, r, v) => {
+    const to = typeof v === "string" ? sectionChoices(data).indexOf(v) : -1;
+    return to < 0 || to === s[0] ? data : moveGanttTaskToSection(data, s[0], r, to);
+  }
+});
+var TASK_COLUMNS = [
+  {
+    key: "name",
+    label: "Task",
+    type: { kind: "string" },
+    get: (d, s, r) => taskOf2(d, s, r)?.name,
+    set: (d, s, r, v) => setGanttTaskName(d, s[0], r, textOf(v) ?? "")
+  },
+  {
+    key: "id",
+    label: "Id",
+    type: { kind: "string" },
+    optional: true,
+    get: (d, s, r) => taskOf2(d, s, r)?.id,
+    set: (d, s, r, v) => {
+      const id = textOf(v)?.trim() || void 0;
+      const taken = id !== void 0 && (/\s/.test(id) || d.sections.some((sec) => sec.tasks.some((t) => t.id === id)));
+      return v !== void 0 && typeof v !== "string" || taken ? d : setGanttTaskId(d, s[0], r, id);
+    }
+  },
+  {
+    key: "start",
+    label: "Start",
+    type: { kind: "string", placeholder: "after the task before" },
+    get: (d, s, r) => {
+      const t = taskOf2(d, s, r);
+      return t && formatGanttStart(t.start);
+    },
+    set: (d, s, r, v) => {
+      const start = parseGanttStart(textOf(v) ?? "");
+      return reads(d, start) ? setGanttTaskStart(d, s[0], r, start) : d;
+    }
+  },
+  {
+    key: "end",
+    label: "End",
+    type: { kind: "string", placeholder: "3d, a date, or until an id" },
+    get: (d, s, r) => {
+      const t = taskOf2(d, s, r);
+      return t && formatGanttEnd(t.end);
+    },
+    set: (d, s, r, v) => {
+      const text = textOf(v)?.trim();
+      if (!text) return d;
+      const end = parseGanttEnd(text);
+      return reads(d, end) ? setGanttTaskEnd(d, s[0], r, end) : d;
+    }
+  },
+  tagColumn("done", "Done"),
+  tagColumn("active", "Active"),
+  tagColumn("crit", "Critical"),
+  tagColumn("milestone", "Milestone")
+];
+var ganttSchema = {
+  fields: [
+    titleField(),
+    setting("dateFormat", "Date format", "YYYY-MM-DD"),
+    setting("axisFormat", "Axis format", "%Y-%m-%d"),
+    {
+      key: "excludes",
+      label: "Excludes",
+      type: { kind: "string", placeholder: "weekends, 2024-01-01" },
+      optional: true,
+      get: (d) => d.excludes && d.excludes.length > 0 ? d.excludes.join(", ") : void 0,
+      set: (d, v) => v === void 0 || typeof v === "string" ? setGanttExcludes(d, listOf(v ?? "")) : d
+    },
+    setting("todayMarker", "Today marker", "off, or a style")
+  ],
+  tables: [{
+    key: "sections",
+    label: "Sections",
+    item: "section",
+    count: (d) => d.sections.length,
+    columns: () => [{
+      key: "name",
+      label: "Section",
+      type: { kind: "string" },
+      get: (d, _, r) => d.sections[r]?.name,
+      set: (d, _, r, v) => setGanttSectionName(d, r, textOf(v) ?? "")
+    }],
+    insert: (d, _, at3) => insertGanttSection(d, at3),
+    remove: (d, _, r) => removeGanttSection(d, r),
+    move: (d, _, from, to) => moveGanttSection(d, from, to),
+    rowLabel: (d, _, r) => d.sections[r]?.name ?? "Untitled section",
+    children: [{
+      key: "tasks",
+      label: "Tasks",
+      item: "task",
+      count: (d, s) => d.sections[s[0]]?.tasks.length ?? 0,
+      columns: (d) => [...TASK_COLUMNS, sectionColumn(d)],
+      insert: (d, s, at3) => insertGanttTask(d, s[0], at3),
+      remove: (d, s, r) => removeGanttTask(d, s[0], r),
+      move: (d, s, from, to) => reorderGanttTask(d, s[0], from, to),
+      rowLabel: (d, s, r) => taskOf2(d, s, r)?.name ?? ""
+    }]
+  }]
+};
+
+// src/gitgraph/structure.ts
+var GIT_COMMAND_KINDS = ["commit", "branch", "checkout", "merge", "cherry-pick"];
+var GIT_COMMAND_FIELDS = {
+  commit: ["id", "type", "tag", "message"],
+  branch: ["name", "order"],
+  checkout: ["name"],
+  merge: ["branch", "id", "type", "tag"],
+  "cherry-pick": ["id", "tag", "parent"]
+};
+var mainOf = (data) => data.mainBranch ?? "main";
+var gitBranchNames = (data) => [mainOf(data), ...data.commands.flatMap((c) => c.kind === "branch" && c.name !== mainOf(data) ? [c.name] : [])];
+var insertGitCommand = (data, at3, command = { kind: "commit" }) => ({ ...data, commands: insertAt(data.commands, at3, command, "insertGitCommand") });
+var removeGitCommand = (data, command) => ({ ...data, commands: removeAt(data.commands, command, "removeGitCommand") });
+var moveGitCommand = (data, from, to) => from === to ? data : { ...data, commands: moveAt(data.commands, from, to, "moveGitCommand") };
+var setGitCommand = (data, at3, command) => data.commands[at3] === command ? data : { ...data, commands: updateAt(data.commands, at3, () => command, "setGitCommand") };
+function setGitCommandKind(data, at3, kind) {
+  const old = data.commands[at3];
+  if (old === void 0) throw new Error(`setGitCommandKind: no command ${at3}`);
+  if (old.kind === kind) return data;
+  const kept = Object.fromEntries(GIT_COMMAND_FIELDS[kind].flatMap((f) => {
+    const v = old[f];
+    return v === void 0 || f === "id" && old.kind === "cherry-pick" !== (kind === "cherry-pick") ? [] : [[f, v]];
+  }));
+  const branches = gitBranchNames(data);
+  const ids2 = data.commands.flatMap((c) => (c.kind === "commit" || c.kind === "merge") && c.id !== void 0 ? [c.id] : []);
+  const needs = kind === "branch" ? { name: freshName("branch", branches, branches.length, "-") } : kind === "checkout" ? { name: mainOf(data) } : kind === "merge" ? { branch: branches[branches.length - 1] } : kind === "cherry-pick" ? { id: ids2[ids2.length - 1] ?? "" } : {};
+  return setGitCommand(data, at3, { ...needs, ...kept, kind });
+}
+var TYPES = ["NORMAL", "REVERSE", "HIGHLIGHT"];
+function setGitCommandField(data, at3, field, value) {
+  const cmd = data.commands[at3];
+  if (cmd === void 0) throw new Error(`setGitCommandField: no command ${at3}`);
+  if (!GIT_COMMAND_FIELDS[cmd.kind].includes(field)) throw new Error(`setGitCommandField: a ${cmd.kind} holds no ${field}`);
+  const required = field === "name" || field === "branch" || field === "id" && cmd.kind === "cherry-pick";
+  if (value === void 0 && required) throw new Error(`setGitCommandField: a ${cmd.kind} needs its ${field}`);
+  if (value !== void 0 && field === "order" !== (typeof value === "number")) throw new Error(`setGitCommandField: ${field} takes a ${field === "order" ? "number" : "string"}`);
+  if (field === "type" && value !== void 0 && !TYPES.includes(value)) throw new Error(`setGitCommandField: no commit type "${value}"`);
+  if (cmd[field] === value) return data;
+  return setGitCommand(data, at3, withOptional(cmd, field, value));
+}
+var setGitOrientation = (data, orientation) => (data.orientation ?? "LR") === orientation ? data : withOptional(data, "orientation", orientation === "LR" ? void 0 : orientation);
+function setGitMainBranch(data, name) {
+  const next = name.trim();
+  const old = mainOf(data);
+  if (next === old) return data;
+  if (next === "") throw new Error("setGitMainBranch: a branch needs a name");
+  if (gitBranchNames(data).includes(next)) throw new Error(`setGitMainBranch: a branch is already called "${next}"`);
+  const commands = data.commands.map((c) => {
+    if (c.kind === "checkout" && c.name === old) return { ...c, name: next };
+    if (c.kind === "merge" && c.branch === old) return { ...c, branch: next };
+    return c;
+  });
+  return withOptional({ ...data, commands }, "mainBranch", next === "main" ? void 0 : next);
+}
+
+// src/gitgraph/schema.ts
+var ORIENTATIONS = ["LR", "TB", "BT"];
+var targetOf = (cmd) => cmd.kind === "branch" || cmd.kind === "checkout" ? "name" : cmd.kind === "merge" ? "branch" : cmd.kind === "cherry-pick" ? "id" : null;
+function column(key, label, type, field, optional) {
+  const fieldOf = (d, r) => {
+    const cmd = d.commands[r];
+    if (cmd === void 0) return null;
+    if (field === "target") return targetOf(cmd);
+    if (field === "id" && cmd.kind === "cherry-pick") return null;
+    return GIT_COMMAND_FIELDS[cmd.kind].includes(field) ? field : null;
+  };
+  return {
+    key,
+    label,
+    type,
+    optional,
+    applies: (d, _, r) => fieldOf(d, r) !== null,
+    get: (d, _, r) => {
+      const f = fieldOf(d, r);
+      return f === null ? void 0 : d.commands[r][f];
+    },
+    set: (d, _, r, v) => {
+      const f = fieldOf(d, r);
+      if (f === null) return d;
+      const value = f === "order" ? integerOf(v) : textOf(v)?.trim() || void 0;
+      if (value === void 0 && (v !== void 0 || !optional)) return d;
+      if (f === "type" && value !== void 0 && type.kind === "enum" && !type.options.includes(String(value))) return d;
+      return setGitCommandField(d, r, f, value);
+    }
+  };
+}
+var gitgraphSchema = {
+  fields: [
+    titleField(),
+    {
+      key: "orientation",
+      label: "Orientation",
+      type: { kind: "enum", options: ORIENTATIONS },
+      get: (d) => d.orientation ?? "LR",
+      set: (d, v) => {
+        const o = choiceOf(v, ORIENTATIONS);
+        return o ? setGitOrientation(d, o) : d;
+      }
+    },
+    {
+      key: "mainBranch",
+      label: "Main branch",
+      type: { kind: "string" },
+      get: (d) => d.mainBranch ?? "main",
+      set: (d, v) => {
+        const name = textOf(v)?.trim();
+        if (!name) return d;
+        try {
+          return setGitMainBranch(d, name);
+        } catch {
+          return d;
+        }
+      }
+    }
+  ],
+  tables: [{
+    key: "commands",
+    label: "Commands",
+    item: "command",
+    count: (d) => d.commands.length,
+    columns: () => [
+      {
+        key: "kind",
+        label: "Command",
+        type: { kind: "enum", options: GIT_COMMAND_KINDS },
+        get: (d, _, r) => d.commands[r]?.kind,
+        set: (d, _, r, v) => {
+          const k = choiceOf(v, GIT_COMMAND_KINDS);
+          return k ? setGitCommandKind(d, r, k) : d;
+        }
+      },
+      column("target", "Branch or commit", { kind: "string" }, "target", false),
+      column("id", "Id", { kind: "string" }, "id", true),
+      column("type", "Type", { kind: "enum", options: ["NORMAL", "REVERSE", "HIGHLIGHT"] }, "type", true),
+      column("tag", "Tag", { kind: "string" }, "tag", true),
+      column("message", "Message", { kind: "string" }, "message", true),
+      column("order", "Order", { kind: "number", step: 1 }, "order", true),
+      column("parent", "Parent", { kind: "string" }, "parent", true)
+    ],
+    insert: (d, _, at3) => insertGitCommand(d, at3),
+    remove: (d, _, r) => removeGitCommand(d, r),
+    move: (d, _, from, to) => moveGitCommand(d, from, to),
+    rowLabel: (d, _, r) => {
+      const c = d.commands[r];
+      return c === void 0 ? "" : [c.kind, ...targetOf(c) ? [c[targetOf(c)]] : []].join(" ");
+    }
+  }]
+};
+
+// src/journey/structure.ts
+var freshTask2 = (data) => {
+  const names = data.sections.flatMap((s) => s.tasks.map((t) => t.name));
+  return { name: freshName("Step", names, names.length + 1), score: 3, actors: [] };
+};
+function insertJourneySection(data, at3, section) {
+  const next = section ?? {
+    name: freshName("Section", data.sections.flatMap((s) => s.name === void 0 ? [] : [s.name]), data.sections.length + 1),
+    tasks: [freshTask2(data)]
+  };
+  return { ...data, sections: insertAt(data.sections, at3, next, "insertJourneySection") };
+}
+var removeJourneySection = (data, section) => ({ ...data, sections: removeAt(data.sections, section, "removeJourneySection") });
+var moveJourneySection = (data, from, to) => from === to ? data : { ...data, sections: moveAt(data.sections, from, to, "moveJourneySection") };
+var withTasks2 = (data, section, change, who) => ({ ...data, sections: updateAt(data.sections, section, (s) => ({ ...s, tasks: change(s.tasks) }), who) });
+var insertJourneyTask = (data, section, at3, task) => withTasks2(data, section, (ts) => insertAt(ts, at3, task ?? freshTask2(data), "insertJourneyTask"), "insertJourneyTask");
+var removeJourneyTask = (data, section, task) => withTasks2(data, section, (ts) => removeAt(ts, task, "removeJourneyTask"), "removeJourneyTask");
+var moveJourneyTask = (data, section, from, to) => from === to ? data : withTasks2(data, section, (ts) => moveAt(ts, from, to, "moveJourneyTask"), "moveJourneyTask");
+function setJourneyActors(data, section, task, actors) {
+  const next = [...new Set(actors.map((a) => a.trim()).filter((a) => a !== ""))];
+  const target = data.sections[section]?.tasks[task];
+  if (target === void 0) throw new Error(`setJourneyActors: section ${section} holds no step ${task}`);
+  if (next.join("\n") === target.actors.join("\n")) return data;
+  return withTasks2(data, section, (ts) => ts.map((t, i) => i === task ? { ...t, actors: next } : t), "setJourneyActors");
+}
+
+// src/journey/schema.ts
+var taskOf3 = (d, s, r) => d.sections[s[0]]?.tasks[r];
+var journeySchema = {
+  fields: [titleField()],
+  tables: [{
+    key: "sections",
+    label: "Sections",
+    item: "section",
+    count: (d) => d.sections.length,
+    columns: () => [{
+      key: "name",
+      label: "Section",
+      type: { kind: "string" },
+      get: (d, _, r) => d.sections[r]?.name,
+      set: (d, _, r, v) => {
+        const t = textOf(v)?.trim();
+        return t ? setJourneySectionName(d, r, t) : d;
+      }
+    }],
+    insert: (d, _, at3) => insertJourneySection(d, at3),
+    remove: (d, _, r) => removeJourneySection(d, r),
+    move: (d, _, from, to) => moveJourneySection(d, from, to),
+    rowLabel: (d, _, r) => d.sections[r]?.name ?? "Untitled section",
+    children: [{
+      key: "tasks",
+      label: "Steps",
+      item: "step",
+      count: (d, s) => d.sections[s[0]]?.tasks.length ?? 0,
+      columns: () => [
+        {
+          key: "name",
+          label: "Step",
+          type: { kind: "string" },
+          get: (d, s, r) => taskOf3(d, s, r)?.name,
+          set: (d, s, r, v) => {
+            const t = textOf(v)?.trim();
+            return t ? setJourneyTaskName(d, s[0], r, t) : d;
+          }
+        },
+        {
+          key: "score",
+          label: "Score",
+          type: { kind: "number", min: 1, max: 5, step: 1 },
+          get: (d, s, r) => taskOf3(d, s, r)?.score,
+          set: (d, s, r, v) => {
+            const n2 = integerOf(v);
+            return n2 !== void 0 && n2 >= 1 && n2 <= 5 ? setJourneyScore(d, s[0], r, n2) : d;
+          }
+        },
+        {
+          key: "actors",
+          label: "Actors",
+          type: { kind: "string", placeholder: "Me, Cat" },
+          get: (d, s, r) => taskOf3(d, s, r)?.actors.join(", "),
+          set: (d, s, r, v) => typeof v === "string" ? setJourneyActors(d, s[0], r, listOf(v)) : d
+        }
+      ],
+      insert: (d, s, at3) => insertJourneyTask(d, s[0], at3),
+      remove: (d, s, r) => removeJourneyTask(d, s[0], r),
+      move: (d, s, from, to) => moveJourneyTask(d, s[0], from, to),
+      rowLabel: (d, s, r) => taskOf3(d, s, r)?.name ?? ""
+    }]
+  }]
+};
+
+// src/packet/structure.ts
+var width = (f) => f.end - f.start + 1;
+var shifted = (fields, from, by) => fields.map((f, i) => i < from || by === 0 ? f : { ...f, start: f.start + by, end: f.end + by });
+function insertPacketField(data, at3, field) {
+  const start = at3 === 0 ? 0 : (data.fields[at3 - 1]?.end ?? -1) + 1;
+  const next = field ?? { start, end: start + 7, label: freshName("Field", data.fields.map((f) => f.label), data.fields.length + 1) };
+  const room = data.fields[at3] === void 0 ? 0 : Math.max(0, next.end + 1 - data.fields[at3].start);
+  return { ...data, fields: insertAt(shifted(data.fields, at3, room), at3, next, "insertPacketField") };
+}
+function removePacketField(data, field) {
+  const gone = data.fields[field];
+  const fields = removeAt(data.fields, field, "removePacketField");
+  return { ...data, fields: gone === void 0 ? fields : shifted(fields, field, -width(gone)) };
+}
+function movePacketField(data, from, to) {
+  if (from === to) return data;
+  const moved = moveAt(data.fields, from, to, "movePacketField");
+  const gaps = data.fields.map((g, i) => i === 0 ? g.start : g.start - data.fields[i - 1].end - 1);
+  let end = -1;
+  const fields = moved.map((g, i) => {
+    const start = end + 1 + gaps[i];
+    end = start + width(g) - 1;
+    return { ...g, start, end };
+  });
+  return { ...data, fields };
+}
+function setPacketBits(data, field, bits) {
+  if (!Number.isInteger(bits) || bits < 1) throw new Error(`setPacketBits: a field is a whole number of bits, at least 1, and ${bits} is not`);
+  const target = data.fields[field];
+  if (target === void 0) throw new Error(`setPacketBits: the packet holds no field ${field}`);
+  const by = bits - width(target);
+  if (by === 0) return data;
+  return { ...data, fields: shifted(updateAt(data.fields, field, (f) => ({ ...f, end: f.start + bits - 1 }), "setPacketBits"), field + 1, by) };
+}
+function setPacketStart(data, field, start) {
+  const target = data.fields[field];
+  if (target === void 0) throw new Error(`setPacketStart: the packet holds no field ${field}`);
+  const floor = field === 0 ? 0 : data.fields[field - 1].end + 1;
+  if (!Number.isInteger(start) || start < floor) throw new Error(`setPacketStart: field ${field} starts at bit ${floor} or later, and ${start} is earlier`);
+  return { ...data, fields: shifted(data.fields, field, start - target.start) };
+}
+var setPacketRelative = (data, field, relative) => {
+  const fields = updateAt(data.fields, field, (f) => (f.relative ?? false) === relative ? f : withOptional(f, "relative", relative ? true : void 0), "setPacketRelative");
+  return fields[field] === data.fields[field] ? data : { ...data, fields };
+};
+function setPacketBitsPerRow(data, bits) {
+  if (bits !== void 0 && (!Number.isInteger(bits) || bits < 1)) throw new Error(`setPacketBitsPerRow: a row is a whole number of bits, at least 1, and ${bits} is not`);
+  return data.bitsPerRow === bits ? data : withOptional(data, "bitsPerRow", bits);
+}
+
+// src/packet/schema.ts
+var packetSchema = {
+  fields: [
+    titleField(),
+    {
+      key: "bitsPerRow",
+      label: "Bits per row",
+      type: { kind: "number", min: 1, step: 1 },
+      optional: true,
+      get: (d) => d.bitsPerRow,
+      set: (d, v) => {
+        const n2 = integerOf(v);
+        return v === void 0 || n2 !== void 0 && n2 >= 1 ? setPacketBitsPerRow(d, n2) : d;
+      }
+    }
+  ],
+  tables: [{
+    key: "fields",
+    label: "Fields",
+    item: "field",
+    count: (d) => d.fields.length,
+    columns: () => [
+      {
+        key: "label",
+        label: "Label",
+        type: { kind: "string" },
+        get: (d, _, r) => d.fields[r]?.label,
+        set: (d, _, r, v) => typeof v === "string" ? setPacketLabel(d, r, v.trim()) : d
+      },
+      {
+        key: "start",
+        label: "Start",
+        type: { kind: "number", min: 0, step: 1 },
+        get: (d, _, r) => d.fields[r]?.start,
+        set: (d, _, r, v) => {
+          const n2 = integerOf(v);
+          const floor = r === 0 ? 0 : (d.fields[r - 1]?.end ?? -1) + 1;
+          return n2 !== void 0 && n2 >= floor ? setPacketStart(d, r, n2) : d;
+        }
+      },
+      {
+        key: "bits",
+        label: "Bits",
+        type: { kind: "number", min: 1, step: 1 },
+        get: (d, _, r) => {
+          const f = d.fields[r];
+          return f && f.end - f.start + 1;
+        },
+        set: (d, _, r, v) => {
+          const n2 = integerOf(v);
+          return n2 !== void 0 && n2 >= 1 ? setPacketBits(d, r, n2) : d;
+        }
+      },
+      {
+        key: "end",
+        label: "End",
+        type: { kind: "number" },
+        readOnly: true,
+        get: (d, _, r) => d.fields[r]?.end,
+        set: (d) => d
+      },
+      {
+        key: "relative",
+        label: "Relative",
+        type: { kind: "boolean" },
+        get: (d, _, r) => d.fields[r]?.relative ?? false,
+        set: (d, _, r, v) => typeof v === "boolean" ? setPacketRelative(d, r, v) : d
+      }
+    ],
+    insert: (d, _, at3) => insertPacketField(d, at3),
+    remove: (d, _, r) => removePacketField(d, r),
+    move: (d, _, from, to) => movePacketField(d, from, to),
+    rowLabel: (d, _, r) => d.fields[r]?.label ?? ""
+  }]
+};
+
+// src/pie/structure.ts
+function insertPieSlice(data, at3, slice) {
+  const next = slice ?? { label: freshName("Slice", data.slices.map((s) => s.label), data.slices.length + 1), value: 1 };
+  return { ...data, slices: insertAt(data.slices, at3, next, "insertPieSlice") };
+}
+var removePieSlice = (data, slice) => ({ ...data, slices: removeAt(data.slices, slice, "removePieSlice") });
+var movePieSlice = (data, from, to) => from === to ? data : { ...data, slices: moveAt(data.slices, from, to, "movePieSlice") };
+var setPieShowData = (data, show) => (data.showData ?? false) === show ? data : withOptional(data, "showData", show ? true : void 0);
+
+// src/pie/schema.ts
+var pieSchema = {
+  fields: [
+    titleField(),
+    {
+      key: "showData",
+      label: "Show values",
+      type: { kind: "boolean" },
+      get: (d) => d.showData ?? false,
+      set: (d, v) => typeof v === "boolean" ? setPieShowData(d, v) : d
+    }
+  ],
+  tables: [{
+    key: "slices",
+    label: "Slices",
+    item: "slice",
+    count: (d) => d.slices.length,
+    columns: () => [
+      {
+        key: "label",
+        label: "Label",
+        type: { kind: "string" },
+        get: (d, _, r) => d.slices[r]?.label,
+        set: (d, _, r, v) => {
+          const t = textOf(v)?.trim();
+          return t ? setPieLabel(d, r, t) : d;
+        }
+      },
+      {
+        key: "value",
+        label: "Value",
+        type: { kind: "number", min: 0 },
+        get: (d, _, r) => d.slices[r]?.value,
+        set: (d, _, r, v) => {
+          const n2 = numberOf2(v);
+          return n2 !== void 0 && n2 >= 0 ? setPieValue(d, r, n2) : d;
+        }
+      }
+    ],
+    insert: (d, _, at3) => insertPieSlice(d, at3),
+    remove: (d, _, r) => removePieSlice(d, r),
+    move: (d, _, from, to) => movePieSlice(d, from, to),
+    rowLabel: (d, _, r) => d.slices[r]?.label ?? ""
+  }]
+};
+
+// src/quadrant/structure.ts
+function insertQuadrantPoint(data, at3, point) {
+  const next = point ?? { name: freshName("Point", data.points.map((p) => p.name), data.points.length + 1), x: 0.5, y: 0.5 };
+  return { ...data, points: insertAt(data.points, at3, next, "insertQuadrantPoint") };
+}
+var removeQuadrantPoint = (data, point) => ({ ...data, points: removeAt(data.points, point, "removeQuadrantPoint") });
+var moveQuadrantPoint = (data, from, to) => from === to ? data : { ...data, points: moveAt(data.points, from, to, "moveQuadrantPoint") };
+function restyled(style, key, value) {
+  const next = withOptional(style ?? {}, key, value);
+  return Object.keys(next).length > 0 ? next : void 0;
+}
+var withPoint2 = (data, point, change, who) => {
+  const points = updateAt(data.points, point, change, who);
+  return points[point] === data.points[point] ? data : { ...data, points };
+};
+var setQuadrantPointStyle = (data, point, key, value) => withPoint2(data, point, (p) => p.style?.[key] === value ? p : withOptional(p, "style", restyled(p.style, key, value)), "setQuadrantPointStyle");
+function setQuadrantPointClass(data, point, className) {
+  if (className !== void 0 && data.classes?.[className] === void 0) throw new Error(`setQuadrantPointClass: no class "${className}"`);
+  return withPoint2(data, point, (p) => p.className === className ? p : withOptional(p, "className", className), "setQuadrantPointClass");
+}
+var quadrantClassNames = (data) => Object.keys(data.classes ?? {});
+var withClasses = (data, entries) => withOptional(data, "classes", entries.length > 0 ? Object.fromEntries(entries) : void 0);
+function insertQuadrantClass(data, at3, name, style = { radius: 8 }) {
+  const names = quadrantClassNames(data);
+  const next = name ?? freshName("class", names, names.length + 1, "");
+  if (!/^\w+$/.test(next)) throw new Error(`insertQuadrantClass: a class name is letters, digits and underscores, and "${next}" is not`);
+  if (names.includes(next)) throw new Error(`insertQuadrantClass: a class is already called "${next}"`);
+  return withClasses(data, insertAt(Object.entries(data.classes ?? {}), at3, [next, style], "insertQuadrantClass"));
+}
+function removeQuadrantClass(data, index) {
+  const name = quadrantClassNames(data)[index];
+  const next = withClasses(data, removeAt(Object.entries(data.classes ?? {}), index, "removeQuadrantClass"));
+  return { ...next, points: next.points.map((p) => p.className === name ? withOptional(p, "className", void 0) : p) };
+}
+var moveQuadrantClass = (data, from, to) => from === to ? data : withClasses(data, moveAt(Object.entries(data.classes ?? {}), from, to, "moveQuadrantClass"));
+function renameQuadrantClass(data, index, name) {
+  const names = quadrantClassNames(data);
+  const from = names[index];
+  if (from === void 0) throw new Error(`renameQuadrantClass: no class ${index}`);
+  if (from === name) return data;
+  if (!/^\w+$/.test(name)) throw new Error(`renameQuadrantClass: a class name is letters, digits and underscores, and "${name}" is not`);
+  if (names.includes(name)) throw new Error(`renameQuadrantClass: a class is already called "${name}"`);
+  const next = withClasses(data, Object.entries(data.classes).map(([n2, s]) => [n2 === from ? name : n2, s]));
+  return { ...next, points: next.points.map((p) => p.className === from ? { ...p, className: name } : p) };
+}
+function setQuadrantClassStyle(data, index, key, value) {
+  const entries = Object.entries(data.classes ?? {});
+  const target = entries[index];
+  if (target === void 0) throw new Error(`setQuadrantClassStyle: no class ${index}`);
+  if (target[1][key] === value) return data;
+  return withClasses(data, updateAt(entries, index, ([n2, s]) => [n2, restyled(s, key, value) ?? {}], "setQuadrantClassStyle"));
+}
+
+// src/quadrant/schema.ts
+var axisField = (axis, end, label) => ({
+  key: `${axis}.${end}`,
+  label,
+  type: { kind: "string" },
+  optional: true,
+  get: (d) => d[axis]?.[end],
+  set: (d, v) => v === void 0 || typeof v === "string" ? setQuadrantAxisLabel(d, axis, end, v?.trim() ?? "") : d
+});
+var quadrantField = (n2, label) => ({
+  key: `quadrant.${n2}`,
+  label,
+  type: { kind: "string" },
+  optional: true,
+  get: (d) => d.quadrants?.[n2 - 1],
+  set: (d, v) => v === void 0 || typeof v === "string" ? setQuadrantLabel(d, n2, v?.trim() ?? "") : d
+});
+var STYLE = [
+  { key: "radius", label: "Radius", color: false },
+  { key: "color", label: "Color", color: true },
+  { key: "strokeColor", label: "Stroke", color: true },
+  { key: "strokeWidth", label: "Stroke width", color: false }
+];
+var styleColumns = (styleOf, restyle) => STYLE.map(({ key, label, color }) => ({
+  key,
+  label,
+  optional: true,
+  type: color ? { kind: "color" } : { kind: "number", min: 0 },
+  get: (d, _, r) => styleOf(d, r)?.[key],
+  set: (d, _, r, v) => {
+    if (v === void 0) return restyle(d, r, key, void 0);
+    const value = color ? textOf(v) : numberOf2(v);
+    return value === void 0 || typeof value === "number" && value < 0 ? d : restyle(d, r, key, value);
+  }
+}));
+var unit = (axis, label) => ({
+  key: axis,
+  label,
+  type: { kind: "number", min: 0, max: 1, step: 0.01 },
+  get: (d, _, r) => d.points[r]?.[axis],
+  set: (d, _, r, v) => {
+    const n2 = numberOf2(v);
+    const p = d.points[r];
+    return n2 === void 0 || n2 < 0 || n2 > 1 || p === void 0 ? d : setQuadrantPoint(d, r, { x: p.x, y: p.y, [axis]: n2 });
+  }
+});
+var quadrantSchema = {
+  fields: [
+    titleField(),
+    axisField("x", "low", "X low"),
+    axisField("x", "high", "X high"),
+    axisField("y", "low", "Y low"),
+    axisField("y", "high", "Y high"),
+    quadrantField(1, "Top right"),
+    quadrantField(2, "Top left"),
+    quadrantField(3, "Bottom left"),
+    quadrantField(4, "Bottom right")
+  ],
+  tables: [
+    {
+      key: "points",
+      label: "Points",
+      item: "point",
+      count: (d) => d.points.length,
+      columns: (d) => [
+        {
+          key: "name",
+          label: "Name",
+          type: { kind: "string" },
+          get: (data, _, r) => data.points[r]?.name,
+          set: (data, _, r, v) => {
+            const t = textOf(v)?.trim();
+            return t ? setQuadrantPointName(data, r, t) : data;
+          }
+        },
+        unit("x", "X"),
+        unit("y", "Y"),
+        {
+          key: "className",
+          label: "Class",
+          type: { kind: "enum", options: quadrantClassNames(d) },
+          optional: true,
+          get: (data, _, r) => data.points[r]?.className,
+          set: (data, _, r, v) => v === void 0 || typeof v === "string" && data.classes?.[v] !== void 0 ? setQuadrantPointClass(data, r, v) : data
+        },
+        ...styleColumns((data, r) => data.points[r]?.style, (data, r, key, v) => setQuadrantPointStyle(data, r, key, v))
+      ],
+      insert: (d, _, at3) => insertQuadrantPoint(d, at3),
+      remove: (d, _, r) => removeQuadrantPoint(d, r),
+      move: (d, _, from, to) => moveQuadrantPoint(d, from, to),
+      rowLabel: (d, _, r) => d.points[r]?.name ?? ""
+    },
+    {
+      key: "classes",
+      label: "Classes",
+      item: "class",
+      count: (d) => quadrantClassNames(d).length,
+      columns: () => [
+        {
+          key: "name",
+          label: "Name",
+          type: { kind: "string" },
+          get: (d, _, r) => quadrantClassNames(d)[r],
+          set: (d, _, r, v) => {
+            const name = textOf(v)?.trim() ?? "";
+            return /^\w+$/.test(name) && !quadrantClassNames(d).includes(name) ? renameQuadrantClass(d, r, name) : d;
+          }
+        },
+        ...styleColumns((d, r) => Object.values(d.classes ?? {})[r], (d, r, key, v) => setQuadrantClassStyle(d, r, key, v))
+      ],
+      insert: (d, _, at3) => insertQuadrantClass(d, at3),
+      remove: (d, _, r) => removeQuadrantClass(d, r),
+      move: (d, _, from, to) => moveQuadrantClass(d, from, to),
+      rowLabel: (d, _, r) => quadrantClassNames(d)[r] ?? ""
+    }
+  ]
+};
+
+// src/radar/structure.ts
+var valuesOf = (data, c) => data.axes.map((_, i) => c.values[i] ?? 0);
+var ID = /^\w+$/;
+function insertRadarAxis(data, at3, axis) {
+  const next = axis ?? { id: freshName("axis", data.axes.map((a) => a.id), data.axes.length + 1, "") };
+  const axes = insertAt(data.axes, at3, next, "insertRadarAxis");
+  return { ...data, axes, curves: data.curves.map((c) => ({ ...c, values: insertAt(valuesOf(data, c), at3, 0, "insertRadarAxis") })) };
+}
+function removeRadarAxis(data, axis) {
+  const axes = removeAt(data.axes, axis, "removeRadarAxis");
+  return { ...data, axes, curves: data.curves.map((c) => ({ ...c, values: removeAt(valuesOf(data, c), axis, "removeRadarAxis") })) };
+}
+function moveRadarAxis(data, from, to) {
+  if (from === to) return data;
+  const axes = moveAt(data.axes, from, to, "moveRadarAxis");
+  return { ...data, axes, curves: data.curves.map((c) => ({ ...c, values: moveAt(valuesOf(data, c), from, to, "moveRadarAxis") })) };
+}
+function insertRadarCurve(data, at3, curve) {
+  const next = curve ?? { id: freshName("curve", data.curves.map((c) => c.id), data.curves.length + 1, ""), values: data.axes.map(() => 0) };
+  return { ...data, curves: insertAt(data.curves, at3, next, "insertRadarCurve") };
+}
+var removeRadarCurve = (data, curve) => ({ ...data, curves: removeAt(data.curves, curve, "removeRadarCurve") });
+var moveRadarCurve = (data, from, to) => from === to ? data : { ...data, curves: moveAt(data.curves, from, to, "moveRadarCurve") };
+function reid(items, index, id, who) {
+  const target = items[index];
+  if (target === void 0) throw new Error(`${who}: no item ${index}`);
+  if (target.id === id) return items;
+  if (!ID.test(id)) throw new Error(`${who}: an id is letters, digits and underscores, and "${id}" is not`);
+  if (items.some((x) => x.id === id)) throw new Error(`${who}: an item already has id "${id}"`);
+  return updateAt(items, index, (x) => ({ ...x, id }), who);
+}
+function setRadarAxisId(data, axis, id) {
+  const axes = reid(data.axes, axis, id, "setRadarAxisId");
+  return axes === data.axes ? data : { ...data, axes };
+}
+function setRadarCurveId(data, curve, id) {
+  const curves = reid(data.curves, curve, id, "setRadarCurveId");
+  return curves === data.curves ? data : { ...data, curves };
+}
+function setRadarOption(data, key, value) {
+  if (key === "ticks" && value !== void 0 && (!Number.isInteger(value) || value < 1)) {
+    throw new Error(`setRadarOption: ticks is a whole number at least 1, and ${String(value)} is not`);
+  }
+  return data[key] === value ? data : withOptional(data, key, value);
+}
+
+// src/radar/schema.ts
+var ID2 = /^\w+$/;
+var bound = (key, label) => ({
+  key,
+  label,
+  type: { kind: "number" },
+  optional: true,
+  get: (d) => d[key],
+  set: (d, v) => v === void 0 || numberOf2(v) !== void 0 ? setRadarOption(d, key, numberOf2(v)) : d
+});
+function named(list, setId, setLabel) {
+  return [
+    {
+      key: "id",
+      label: "Id",
+      type: { kind: "string" },
+      get: (d, _, r) => list(d)[r]?.id,
+      set: (d, _, r, v) => {
+        const id = textOf(v)?.trim() ?? "";
+        return ID2.test(id) && !list(d).some((x, i) => i !== r && x.id === id) ? setId(d, r, id) : d;
+      }
+    },
+    {
+      key: "label",
+      label: "Label",
+      type: { kind: "string" },
+      optional: true,
+      get: (d, _, r) => list(d)[r]?.label,
+      set: (d, _, r, v) => v === void 0 || typeof v === "string" ? setLabel(d, r, v ?? "") : d
+    }
+  ];
+}
+var valueColumn = (d, curve) => ({
+  key: `curve.${curve}`,
+  label: d.curves[curve]?.label ?? d.curves[curve]?.id ?? `Curve ${curve + 1}`,
+  type: { kind: "number" },
+  get: (data, _, r) => data.curves[curve]?.values[r] ?? 0,
+  set: (data, _, r, v) => {
+    const n2 = numberOf2(v);
+    return n2 !== void 0 ? setRadarValue(data, curve, r, n2) : data;
+  }
+});
+var radarSchema = {
+  fields: [
+    titleField(),
+    bound("min", "Center value"),
+    bound("max", "Rim value"),
+    {
+      key: "graticule",
+      label: "Graticule",
+      type: { kind: "enum", options: ["circle", "polygon"] },
+      get: (d) => d.graticule ?? "circle",
+      set: (d, v) => {
+        const g = choiceOf(v, ["circle", "polygon"]);
+        return g ? setRadarOption(d, "graticule", g === "circle" ? void 0 : g) : d;
+      }
+    },
+    {
+      key: "ticks",
+      label: "Rings",
+      type: { kind: "number", min: 1, step: 1 },
+      optional: true,
+      get: (d) => d.ticks,
+      set: (d, v) => {
+        const n2 = integerOf(v);
+        return v === void 0 || n2 !== void 0 && n2 >= 1 ? setRadarOption(d, "ticks", n2) : d;
+      }
+    },
+    {
+      key: "showLegend",
+      label: "Legend",
+      type: { kind: "boolean" },
+      get: (d) => d.showLegend ?? true,
+      set: (d, v) => typeof v === "boolean" ? setRadarOption(d, "showLegend", v ? void 0 : false) : d
+    }
+  ],
+  tables: [
+    {
+      key: "axes",
+      label: "Axes",
+      item: "axis",
+      count: (d) => d.axes.length,
+      columns: (d) => [
+        ...named((data) => data.axes, setRadarAxisId, setRadarAxisLabel),
+        ...d.curves.map((_, i) => valueColumn(d, i))
+      ],
+      insert: (d, _, at3) => insertRadarAxis(d, at3),
+      remove: (d, _, r) => removeRadarAxis(d, r),
+      move: (d, _, from, to) => moveRadarAxis(d, from, to),
+      rowLabel: (d, _, r) => d.axes[r]?.label ?? d.axes[r]?.id ?? ""
+    },
+    {
+      key: "curves",
+      label: "Curves",
+      item: "curve",
+      count: (d) => d.curves.length,
+      columns: () => named((data) => data.curves, setRadarCurveId, setRadarCurveLabel),
+      insert: (d, _, at3) => insertRadarCurve(d, at3),
+      remove: (d, _, r) => removeRadarCurve(d, r),
+      move: (d, _, from, to) => moveRadarCurve(d, from, to),
+      rowLabel: (d, _, r) => d.curves[r]?.label ?? d.curves[r]?.id ?? ""
+    }
+  ]
+};
+
+// src/sankey/structure.ts
+function insertSankeyLink(data, at3, link) {
+  const nodes = sankeyNodes(data);
+  const source = data.links[data.links.length - 1]?.target ?? freshName("Node", nodes, nodes.length + 1);
+  const next = link ?? { source, target: freshName("Node", [...nodes, source], nodes.length + 1), value: 1 };
+  return { ...data, links: insertAt(data.links, at3, next, "insertSankeyLink") };
+}
+var removeSankeyLink = (data, link) => ({ ...data, links: removeAt(data.links, link, "removeSankeyLink") });
+var moveSankeyLink = (data, from, to) => from === to ? data : { ...data, links: moveAt(data.links, from, to, "moveSankeyLink") };
+function setSankeyEnd(data, link, end, name) {
+  const next = name.trim();
+  if (next === "") throw new Error("setSankeyEnd: a node needs a name");
+  const links = updateAt(data.links, link, (l) => l[end] === next ? l : { ...l, [end]: next }, "setSankeyEnd");
+  return links[link] === data.links[link] ? data : { ...data, links };
+}
+function removeSankeyNode(data, name) {
+  if (!sankeyNodes(data).includes(name)) throw new Error(`removeSankeyNode: no node "${name}"`);
+  return { ...data, links: data.links.filter((l) => l.source !== name && l.target !== name) };
+}
+
+// src/sankey/schema.ts
+var endColumn = (end, label) => ({
+  key: end,
+  label,
+  type: { kind: "string" },
+  get: (d, _, r) => d.links[r]?.[end],
+  set: (d, _, r, v) => {
+    const t = textOf(v)?.trim();
+    return t ? setSankeyEnd(d, r, end, t) : d;
+  }
+});
+var sankeySchema = {
+  fields: [titleField()],
+  tables: [
+    {
+      key: "links",
+      label: "Links",
+      item: "link",
+      count: (d) => d.links.length,
+      columns: () => [
+        endColumn("source", "From"),
+        endColumn("target", "To"),
+        {
+          key: "value",
+          label: "Value",
+          type: { kind: "number", min: 0 },
+          get: (d, _, r) => d.links[r]?.value,
+          set: (d, _, r, v) => {
+            const n2 = numberOf2(v);
+            return n2 !== void 0 && n2 >= 0 ? setSankeyValue(d, r, n2) : d;
+          }
+        }
+      ],
+      insert: (d, _, at3) => insertSankeyLink(d, at3),
+      remove: (d, _, r) => removeSankeyLink(d, r),
+      move: (d, _, from, to) => moveSankeyLink(d, from, to),
+      rowLabel: (d, _, r) => `${d.links[r]?.source ?? ""} \u2192 ${d.links[r]?.target ?? ""}`
+    },
+    {
+      key: "nodes",
+      label: "Nodes",
+      item: "node",
+      count: (d) => sankeyNodes(d).length,
+      columns: () => [{
+        key: "name",
+        label: "Node",
+        type: { kind: "string" },
+        get: (d, _, r) => sankeyNodes(d)[r],
+        set: (d, _, r, v) => {
+          const name = textOf(v)?.trim();
+          const nodes = sankeyNodes(d);
+          return !name || nodes.includes(name) || nodes[r] === void 0 ? d : renameSankeyNode(d, nodes[r], name);
+        }
+      }],
+      remove: (d, _, r) => {
+        const name = sankeyNodes(d)[r];
+        return name === void 0 ? d : removeSankeyNode(d, name);
+      },
+      rowLabel: (d, _, r) => sankeyNodes(d)[r] ?? ""
+    }
+  ]
+};
+
+// src/timeline/structure.ts
+function timelineFlatIndex(data, section, index) {
+  if (data.sections[section]?.periods[index] === void 0) throw new Error(`timelineFlatIndex: section ${section} holds no period ${index}`);
+  return data.sections.slice(0, section).reduce((n2, s) => n2 + s.periods.length, 0) + index;
+}
+var allLabels = (data) => data.sections.flatMap((s) => s.periods.map((p) => p.label));
+var freshPeriod = (data) => {
+  const labels2 = allLabels(data);
+  return { label: freshName("Period", labels2, labels2.length + 1), events: [] };
+};
+function insertTimelineSection(data, at3, section) {
+  const next = section ?? {
+    name: freshName("Section", data.sections.flatMap((s) => s.name === void 0 ? [] : [s.name]), data.sections.length + 1),
+    periods: [freshPeriod(data)]
+  };
+  return { ...data, sections: insertAt(data.sections, at3, next, "insertTimelineSection") };
+}
+var removeTimelineSection = (data, section) => ({ ...data, sections: removeAt(data.sections, section, "removeTimelineSection") });
+var moveTimelineSection = (data, from, to) => from === to ? data : { ...data, sections: moveAt(data.sections, from, to, "moveTimelineSection") };
+var withPeriods = (data, section, change, who) => ({ ...data, sections: updateAt(data.sections, section, (s) => ({ ...s, periods: change(s.periods) }), who) });
+var insertTimelinePeriod = (data, section, at3, period) => withPeriods(data, section, (ps) => insertAt(ps, at3, period ?? freshPeriod(data), "insertTimelinePeriod"), "insertTimelinePeriod");
+var removeTimelinePeriod = (data, section, period) => withPeriods(data, section, (ps) => removeAt(ps, period, "removeTimelinePeriod"), "removeTimelinePeriod");
+var reorderTimelinePeriod = (data, section, from, to) => from === to ? data : withPeriods(data, section, (ps) => moveAt(ps, from, to, "reorderTimelinePeriod"), "reorderTimelinePeriod");
+var withEvents = (data, section, period, change, who) => withPeriods(data, section, (ps) => updateAt(ps, period, (p) => ({ ...p, events: change(p.events) }), who), who);
+var insertTimelineEvent = (data, section, period, at3, text) => withEvents(data, section, period, (es) => insertAt(es, at3, text ?? freshName("Event", es, es.length + 1), "insertTimelineEvent"), "insertTimelineEvent");
+var removeTimelineEvent = (data, section, period, event) => withEvents(data, section, period, (es) => removeAt(es, event, "removeTimelineEvent"), "removeTimelineEvent");
+var moveTimelineEvent = (data, section, period, from, to) => from === to ? data : withEvents(data, section, period, (es) => moveAt(es, from, to, "moveTimelineEvent"), "moveTimelineEvent");
+
+// src/timeline/schema.ts
+var periodOf2 = (d, section, period) => d.sections[section]?.periods[period];
+var at2 = (s) => [s[0], s[1]];
+var timelineSchema = {
+  fields: [titleField()],
+  tables: [{
+    key: "sections",
+    label: "Sections",
+    item: "section",
+    count: (d) => d.sections.length,
+    columns: () => [{
+      key: "name",
+      label: "Section",
+      type: { kind: "string" },
+      get: (d, _, r) => d.sections[r]?.name,
+      set: (d, _, r, v) => setTimelineSectionName(d, r, textOf(v) ?? "")
+    }],
+    insert: (d, _, i) => insertTimelineSection(d, i),
+    remove: (d, _, r) => removeTimelineSection(d, r),
+    move: (d, _, from, to) => moveTimelineSection(d, from, to),
+    rowLabel: (d, _, r) => d.sections[r]?.name ?? "Untitled section",
+    children: [{
+      key: "periods",
+      label: "Periods",
+      item: "period",
+      count: (d, s) => d.sections[s[0]]?.periods.length ?? 0,
+      columns: () => [{
+        key: "label",
+        label: "Period",
+        type: { kind: "string" },
+        get: (d, s, r) => periodOf2(d, s[0], r)?.label,
+        set: (d, s, r, v) => setTimelinePeriodLabel(d, timelineFlatIndex(d, s[0], r), textOf(v) ?? "")
+      }],
+      insert: (d, s, i) => insertTimelinePeriod(d, s[0], i),
+      remove: (d, s, r) => removeTimelinePeriod(d, s[0], r),
+      move: (d, s, from, to) => reorderTimelinePeriod(d, s[0], from, to),
+      rowLabel: (d, s, r) => periodOf2(d, s[0], r)?.label ?? "",
+      children: [{
+        key: "events",
+        label: "Events",
+        item: "event",
+        count: (d, s) => periodOf2(d, ...at2(s))?.events.length ?? 0,
+        columns: () => [{
+          key: "text",
+          label: "Event",
+          type: { kind: "string" },
+          get: (d, s, r) => periodOf2(d, ...at2(s))?.events[r],
+          set: (d, s, r, v) => {
+            const text = textOf(v)?.trim();
+            return text ? setTimelineEvent(d, timelineFlatIndex(d, ...at2(s)), r, text) : d;
+          }
+        }],
+        insert: (d, s, i) => insertTimelineEvent(d, ...at2(s), i),
+        remove: (d, s, r) => removeTimelineEvent(d, ...at2(s), r),
+        move: (d, s, from, to) => moveTimelineEvent(d, ...at2(s), from, to)
+      }]
+    }]
+  }]
+};
+
+// src/xychart/structure.ts
+var padded = (values, n2) => Array.from({ length: Math.max(n2, values.length) }, (_, i) => values[i] ?? 0);
+var labels = (categories, n2) => Array.from({ length: n2 }, (_, i) => categories[i] ?? String(i + 1));
+var labeled = (data) => data.x?.kind === "band" && data.x.categories.length > 0;
+function eachRow(data, values, names) {
+  const n2 = xyRows(data);
+  const series = data.series.map((s) => ({ ...s, values: values(padded(s.values, n2)) }));
+  if (!labeled(data) || data.x?.kind !== "band") return { ...data, series };
+  return { ...data, series, x: { ...data.x, categories: names(labels(data.x.categories, n2)) } };
+}
+function insertXyRow(data, at3, label) {
+  const n2 = xyRows(data);
+  if (!Number.isInteger(at3) || at3 < 0 || at3 > n2) throw new Error(`insertXyRow: cannot insert at ${at3} in ${n2} rows`);
+  const name = label ?? freshName("Category", data.x?.kind === "band" ? data.x.categories : [], n2 + 1);
+  return eachRow(data, (list) => insertAt(list, at3, 0, "insertXyRow"), (list) => insertAt(list, at3, name, "insertXyRow"));
+}
+function removeXyRow(data, at3) {
+  const n2 = xyRows(data);
+  if (!Number.isInteger(at3) || at3 < 0 || at3 >= n2) throw new Error(`removeXyRow: no row ${at3} in ${n2}`);
+  return eachRow(data, (list) => removeAt(list, at3, "removeXyRow"), (list) => removeAt(list, at3, "removeXyRow"));
+}
+var moveXyRow = (data, from, to) => from === to ? data : eachRow(data, (list) => moveAt(list, from, to, "moveXyRow"), (list) => moveAt(list, from, to, "moveXyRow"));
+function setXyCategory(data, index, label) {
+  const n2 = xyRows(data);
+  if (!Number.isInteger(index) || index < 0 || index >= n2) throw new Error(`setXyCategory: no row ${index} in ${n2}`);
+  if (data.x?.kind === "range") throw new Error("setXyCategory: the chart runs along a range, not categories");
+  const categories = labels(data.x?.categories ?? [], n2);
+  if (labeled(data) && categories[index] === label) return data;
+  categories[index] = label;
+  return { ...data, x: { ...data.x ?? { kind: "band" }, categories } };
+}
+function insertXySeries(data, at3, series) {
+  const next = series ?? {
+    kind: "bar",
+    name: freshName("Series", data.series.flatMap((s) => s.name === void 0 ? [] : [s.name]), data.series.length + 1),
+    values: padded([], xyRows(data))
+  };
+  return { ...data, series: insertAt(data.series, at3, next, "insertXySeries") };
+}
+var removeXySeries = (data, series) => ({ ...data, series: removeAt(data.series, series, "removeXySeries") });
+var moveXySeries = (data, from, to) => from === to ? data : { ...data, series: moveAt(data.series, from, to, "moveXySeries") };
+function withSeries(data, series, change, who) {
+  const next = updateAt(data.series, series, change, who);
+  return next[series] === data.series[series] ? data : { ...data, series: next };
+}
+var setXySeriesName = (data, series, name) => withSeries(data, series, (s) => {
+  const text = name?.trim() || void 0;
+  return s.name === text ? s : withOptional(s, "name", text);
+}, "setXySeriesName");
+var setXySeriesKind = (data, series, kind) => withSeries(data, series, (s) => s.kind === kind ? s : { ...s, kind }, "setXySeriesKind");
+var setXyOrientation = (data, orientation) => (data.orientation ?? "vertical") === orientation ? data : withOptional(data, "orientation", orientation === "horizontal" ? orientation : void 0);
+function setXyXKind(data, kind) {
+  if ((data.x?.kind ?? "band") === kind) return data;
+  const title = data.x?.title;
+  const n2 = xyRows(data);
+  const x = kind === "range" ? { kind, min: 0, max: n2 } : { kind, categories: labels([], n2) };
+  return { ...data, x: title === void 0 ? x : { ...x, title } };
+}
+function setXyAxisTitle(data, axis, title) {
+  const text = title?.trim() || void 0;
+  const current = data[axis];
+  if (current?.title === text) return data;
+  if (axis === "x") {
+    const x = data.x ?? { kind: "band", categories: [] };
+    return { ...data, x: withOptional(x, "title", text) };
+  }
+  return withAxis(data, withOptional(data.y ?? {}, "title", text));
+}
+var withAxis = (data, y) => withOptional(data, "y", Object.keys(y).length === 0 ? void 0 : y);
+function setXyValueBound(data, end, value) {
+  if (data.y?.[end] === value) return data;
+  return withAxis(data, withOptional(data.y ?? {}, end, value));
+}
+function setXyRangeBound(data, end, value) {
+  if (data.x?.kind !== "range") throw new Error("setXyRangeBound: the chart runs along categories, not a range");
+  return data.x[end] === value ? data : { ...data, x: { ...data.x, [end]: value } };
+}
+
+// src/xychart/schema.ts
+var isRange = (d) => d.x?.kind === "range";
+var X_KINDS = ["categories", "range"];
+var rangeField = (end, label) => ({
+  key: `x.${end}`,
+  label,
+  type: { kind: "number" },
+  applies: isRange,
+  get: (d) => d.x?.kind === "range" ? d.x[end] : void 0,
+  set: (d, v) => {
+    const n2 = numberOf2(v);
+    return n2 !== void 0 && isRange(d) ? setXyRangeBound(d, end, n2) : d;
+  }
+});
+var boundField = (end, label) => ({
+  key: `y.${end}`,
+  label,
+  type: { kind: "number" },
+  optional: true,
+  get: (d) => d.y?.[end],
+  set: (d, v) => v === void 0 || numberOf2(v) !== void 0 ? setXyValueBound(d, end, numberOf2(v)) : d
+});
+var axisTitle = (axis, label) => ({
+  key: `${axis}.title`,
+  label,
+  type: { kind: "string" },
+  optional: true,
+  get: (d) => d[axis]?.title,
+  set: (d, v) => v === void 0 || typeof v === "string" ? setXyAxisTitle(d, axis, v) : d
+});
+var categoryColumn = {
+  key: "category",
+  label: "Category",
+  type: { kind: "string" },
+  applies: (d) => !isRange(d),
+  get: (d, _, r) => d.x?.kind === "band" ? d.x.categories[r] ?? String(r + 1) : isRange(d) ? void 0 : String(r + 1),
+  set: (d, _, r, v) => {
+    const t = textOf(v)?.trim();
+    return t && !isRange(d) ? setXyCategory(d, r, t) : d;
+  }
+};
+var valueColumn2 = (d, series) => ({
+  key: `series.${series}`,
+  label: d.series[series]?.name ?? `Series ${series + 1}`,
+  type: { kind: "number" },
+  get: (data, _, r) => data.series[series]?.values[r] ?? 0,
+  set: (data, _, r, v) => {
+    const n2 = numberOf2(v);
+    return n2 !== void 0 ? setXyValue(data, series, r, n2) : data;
+  }
+});
+var xySchema = {
+  fields: [
+    titleField(),
+    {
+      key: "orientation",
+      label: "Orientation",
+      type: { kind: "enum", options: ["vertical", "horizontal"] },
+      get: (d) => d.orientation ?? "vertical",
+      set: (d, v) => {
+        const o = choiceOf(v, ["vertical", "horizontal"]);
+        return o ? setXyOrientation(d, o) : d;
+      }
+    },
+    {
+      key: "x.kind",
+      label: "X axis",
+      type: { kind: "enum", options: X_KINDS },
+      get: (d) => isRange(d) ? "range" : "categories",
+      set: (d, v) => {
+        const k = choiceOf(v, X_KINDS);
+        return k ? setXyXKind(d, k === "range" ? "range" : "band") : d;
+      }
+    },
+    axisTitle("x", "X title"),
+    rangeField("min", "X from"),
+    rangeField("max", "X to"),
+    axisTitle("y", "Y title"),
+    boundField("min", "Y from"),
+    boundField("max", "Y to")
+  ],
+  tables: [
+    {
+      key: "rows",
+      label: "Data",
+      item: "row",
+      count: xyRows,
+      columns: (d) => [categoryColumn, ...d.series.map((_, i) => valueColumn2(d, i))],
+      insert: (d, _, at3) => insertXyRow(d, at3),
+      remove: (d, _, r) => removeXyRow(d, r),
+      move: (d, _, from, to) => moveXyRow(d, from, to),
+      rowLabel: (d, _, r) => String(categoryColumn.get(d, [], r) ?? r + 1)
+    },
+    {
+      key: "series",
+      label: "Series",
+      item: "series",
+      count: (d) => d.series.length,
+      columns: () => [
+        {
+          key: "name",
+          label: "Name",
+          type: { kind: "string" },
+          optional: true,
+          get: (d, _, r) => d.series[r]?.name,
+          set: (d, _, r, v) => v === void 0 || typeof v === "string" ? setXySeriesName(d, r, v) : d
+        },
+        {
+          key: "kind",
+          label: "Drawn as",
+          type: { kind: "enum", options: ["bar", "line"] },
+          get: (d, _, r) => d.series[r]?.kind,
+          set: (d, _, r, v) => {
+            const k = choiceOf(v, ["bar", "line"]);
+            return k ? setXySeriesKind(d, r, k) : d;
+          }
+        }
+      ],
+      insert: (d, _, at3) => insertXySeries(d, at3),
+      remove: (d, _, r) => removeXySeries(d, r),
+      move: (d, _, from, to) => moveXySeries(d, from, to),
+      rowLabel: (d, _, r) => d.series[r]?.name ?? `Series ${r + 1}`
+    }
+  ]
+};
+
+// src/editing/schemas.ts
+var SCHEMAS = {
+  xychart: xySchema,
+  gantt: ganttSchema,
+  timeline: timelineSchema,
+  pie: pieSchema,
+  quadrant: quadrantSchema,
+  journey: journeySchema,
+  gitgraph: gitgraphSchema,
+  sankey: sankeySchema,
+  packet: packetSchema,
+  radar: radarSchema
+};
+function plotSchemaOf(data) {
+  const schema = SCHEMAS[data.kind];
+  if (schema === void 0) throw new Error(`plotSchemaOf: no schema for a chart of kind "${data.kind}"`);
+  return schema;
+}
+function plotTablesIn(schema, data) {
+  const out = [];
+  const walk = (tables, scope) => {
+    for (const table of tables) {
+      out.push({ table, scope });
+      if (table.children === void 0) continue;
+      for (let r = 0; r < table.count(data, scope); r++) walk(table.children, [...scope, r]);
+    }
+  };
+  walk(schema.tables, []);
+  return out;
+}
+
+export { CHART_PAD, GANTT_DATE_FORMAT, GIT_COMMAND_FIELDS, GIT_COMMAND_KINDS, GRAB_PLOT_HANDLE_ACTION_ID, PLOT_DRAG_ACTION_ID, PLOT_FONT, PLOT_HANDLE_AFFORDANCE_KIND, PLOT_HANDLE_LAYER_ID, PLOT_THEME, PlotView, arcMark, areaMark, axisMarks, axisRoom, barMark, chartTitle, commitPlotToScene, compileGantt, compileGitGraph, compileJourney, compilePacket, compilePie, compilePlot, compileQuadrant, compileRadar, compileSankey, compileTimeline, compileXyChart, createPlotDragAction, foldPlotText, formatGanttDate, formatGanttEnd, formatGanttStart, gitBranchNames, handlesOf, insertGanttSection, insertGanttTask, insertGitCommand, insertJourneySection, insertJourneyTask, insertPacketField, insertPieSlice, insertQuadrantClass, insertQuadrantPoint, insertRadarAxis, insertRadarCurve, insertSankeyLink, insertTimelineEvent, insertTimelinePeriod, insertTimelineSection, insertXyRow, insertXySeries, isPlotText, lineMark, markSpecs, moveGanttSection, moveGanttTask, moveGanttTaskToSection, moveGitCommand, moveJourneySection, moveJourneyTask, movePacketField, movePieSlice, moveQuadrantClass, moveQuadrantPoint, moveRadarAxis, moveRadarCurve, moveSankeyLink, moveTimelineEvent, moveTimelinePeriod, moveTimelineSection, moveXyRow, moveXySeries, parseGanttDate, parseGanttEnd, parseGanttStart, plotEditing, plotEditorOf, plotHandleLayer, plotHandleScratchOf, plotHandles, plotMarkId, plotMarkOf, plotOrigin, plotRootContaining, plotRootOf, plotRootsIn, plotSchemaOf, plotSpecs, plotTablesIn, plotTextOf, plotThemeFrom, pointMark, quadrantClassNames, removeGanttSection, removeGanttTask, removeGitCommand, removeJourneySection, removeJourneyTask, removePacketField, removePieSlice, removeQuadrantClass, removeQuadrantPoint, removeRadarAxis, removeRadarCurve, removeSankeyLink, removeSankeyNode, removeTimelineEvent, removeTimelinePeriod, removeTimelineSection, removeXyRow, removeXySeries, renameQuadrantClass, renameSankeyNode, reorderGanttTask, reorderTimelinePeriod, replacePlotData, replayGitGraph, ribbonMark, ruleMark, sankeyLayout, scheduleGantt, seriesColor, setGanttEnd, setGanttExcludes, setGanttSectionName, setGanttSetting, setGanttTaskEnd, setGanttTaskId, setGanttTaskName, setGanttTaskStart, setGanttTaskTags, setGitCommand, setGitCommandField, setGitCommandKind, setGitMainBranch, setGitOrientation, setGitTag, setJourneyActors, setJourneyScore, setJourneySectionName, setJourneyTaskName, setPacketBits, setPacketBitsPerRow, setPacketLabel, setPacketRelative, setPacketStart, setPieLabel, setPieShowData, setPieValue, setQuadrantAxisLabel, setQuadrantClassStyle, setQuadrantLabel, setQuadrantPoint, setQuadrantPointClass, setQuadrantPointName, setQuadrantPointStyle, setRadarAxisId, setRadarAxisLabel, setRadarCurveId, setRadarCurveLabel, setRadarOption, setRadarValue, setSankeyEnd, setSankeyValue, setTimelineEvent, setTimelinePeriodLabel, setTimelineSectionName, setXyAxisTitle, setXyCategory, setXyOrientation, setXyRangeBound, setXySeriesKind, setXySeriesName, setXyValue, setXyValueBound, setXyXKind, spanMark, textMark, textMeasure, timelineFlatIndex, usePlotTextEdit, withTitle, xyLength, xyRows, xyValueAt, xyValueDomain };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map