@weasel-js/plot 1.15.0 → 1.15.1

package/dist/index.d.ts

@@ -1,199 +1,9 @@
-import { Path } from '@weasel-js/geom';
+import { P as PlotDatum, a as PlotMark, b as PlotPoint, S as Scale, L as LinearScale, T as TimeScale, B as BandScale, c as PolarScale, d as PlotMarkData, e as PlotMarkTrait, f as PlotBox } from './scales.entry-BoLQpsxi.js';
+export { g as BandScaleOptions, C as ContinuousScale, h as ContinuousScaleFactory, i as LinearScaleOptions, j as LogScale, k as LogScaleOptions, M as MarkKind, O as OrdinalScale, l as OrdinalScaleOptions, m as PolarScaleOptions, n as SolidFill, o as SolidStroke, p as SpacedTickOptions, q as TickFormatCtx, r as TickFormatter, s as TickSet, t as TimeScaleOptions, u as bandScale, v as decimalsOf, w as formatInstant, x as formatNumber, y as formatTick, z as linearScale, A as logScale, D as niceDomain, E as niceStep, F as ordinalScale, G as polarScale, H as stepTicks, I as tickDecimals, J as tickStep, K as timeScale } from './scales.entry-BoLQpsxi.js';
 import { ResolvedTheme } from '@weasel-js/theme';
-import { AddNodeSpec, RectPose, Scene, NodeId, RenderLayer, InvocationCtx, Action, Contribution, Paint } from '@weasel-js/core';
+import { AddNodeSpec, RectPose, Scene, NodeId, InvocationCtx, Action, SceneCanvasTextEditor, RenderLayer, Contribution, Paint } from '@weasel-js/core';
 import { ReactElement } from 'react';
-
-/** What every positional scale answers, and what an axis is drawn from: where a value sits along its range, the
- *  values an axis marks, and how one reads. */
-interface Scale<T> {
-    readonly kind: 'linear' | 'log' | 'band' | 'time';
-    /** Where the scale's output runs, in drawing units: start to end, either way round. */
-    readonly range: readonly [number, number];
-    /** Where `value` sits along the range. A band scale answers its band's center. */
-    position(value: T): number;
-    /** The values an axis marks, about `count` of them where the scale chooses. */
-    ticks(count?: number): T[];
-    /** `value` as an axis label reads it. */
-    format(value: T): string;
-}
-/** A scale over numbers that maps both ways. */
-interface ContinuousScale extends Scale<number> {
-    readonly kind: 'linear' | 'log' | 'time';
-    readonly domain: readonly [number, number];
-    /** `value` along the range; the same as {@link Scale.position}. */
-    map(value: number): number;
-    /** The value at `at` along the range. */
-    invert(at: number): number;
-}
-
-/** Options for {@link linearScale}. */
-interface LinearScaleOptions {
-    domain: readonly [number, number];
-    range: readonly [number, number];
-    /** Widen the domain out to whole tick steps for about this many ticks. Default no widening. */
-    nice?: number;
-}
-/** A scale that maps numbers proportionally, as a value axis does. */
-interface LinearScale extends ContinuousScale {
-    readonly kind: 'linear';
-    /** The distance between ticks when about `count` are asked for. */
-    tickStep(count?: number): number;
-}
-/** The round step, 1, 2 or 5 times a power of ten, that cuts `lo`..`hi` into about `count` pieces. */
-declare function tickStep(lo: number, hi: number, count?: number): number;
-/** Every multiple of `step` from `lo` to `hi`, inclusive. */
-declare function stepTicks(lo: number, hi: number, step: number): number[];
-/** `value` written as plainly as a grid of `step` allows: no trailing zeros, no exponent. */
-declare function formatNumber(value: number, step: number): string;
-/** `domain` widened to whole steps of a tick grid of about `count` ticks. */
-declare function niceDomain(domain: readonly [number, number], count?: number): [number, number];
-/** A linear scale from `domain` onto `range`. */
-declare function linearScale(opts: LinearScaleOptions): LinearScale;
-
-/** Options for {@link logScale}. */
-interface LogScaleOptions {
-    /** Both ends above zero. */
-    domain: readonly [number, number];
-    range: readonly [number, number];
-    /** Default 10. */
-    base?: number;
-}
-/** A scale that maps the logarithm of a value proportionally. */
-interface LogScale extends ContinuousScale {
-    readonly kind: 'log';
-    readonly base: number;
-}
-/** A logarithmic scale from `domain`, whose ends must both be above zero, onto `range`. */
-declare function logScale(opts: LogScaleOptions): LogScale;
-
-/** Options for {@link bandScale}. */
-interface BandScaleOptions {
-    /** The categories, one band each, in order. */
-    domain: readonly string[];
-    range: readonly [number, number];
-    /** The share of each step left empty between bands, 0 to 1. Default 0.2. */
-    paddingInner?: number;
-    /** The room before the first band and after the last, in steps. Default half of `paddingInner`. */
-    paddingOuter?: number;
-}
-/** A scale that cuts its range into equal bands, one per category, as a bar chart's category axis does. */
-interface BandScale extends Scale<string> {
-    readonly kind: 'band';
-    readonly domain: readonly string[];
-    /** The width of each band. */
-    readonly bandwidth: number;
-    /** From one band's start to the next's. */
-    readonly step: number;
-    /** Where `key`'s band starts, or `NaN` for a key not in the domain. */
-    start(key: string): number;
-    /** The key whose band is nearest `at`; `undefined` for an empty domain. */
-    invert(at: number): string | undefined;
-}
-/** A band scale over `domain`. */
-declare function bandScale(opts: BandScaleOptions): BandScale;
-
-/** Options for {@link timeScale}. */
-interface TimeScaleOptions {
-    /** Milliseconds since the epoch, as `Date.getTime` gives them. */
-    domain: readonly [number, number];
-    range: readonly [number, number];
-}
-/** A scale over instants, whose ticks fall on whole seconds, minutes, hours, days, months or years, in UTC. */
-interface TimeScale extends ContinuousScale {
-    readonly kind: 'time';
-}
-type Unit = 'second' | 'minute' | 'hour' | 'day' | 'month' | 'year';
-/** `t` written to the precision of `unit`. */
-declare function formatInstant(t: number, unit: Unit): string;
-/** A time scale from `domain`, in milliseconds since the epoch, onto `range`. */
-declare function timeScale(opts: TimeScaleOptions): TimeScale;
-
-/** Options for {@link ordinalScale}. */
-interface OrdinalScaleOptions<T> {
-    /** The keys, in order. */
-    domain: readonly string[];
-    /** What each key maps to, in domain order, wrapping when there are fewer than keys. */
-    range: readonly T[];
-}
-/** A scale from keys to values in turn, as a series' colors are chosen. */
-interface OrdinalScale<T> {
-    readonly kind: 'ordinal';
-    readonly domain: readonly string[];
-    readonly range: readonly T[];
-    /** `key`'s value; a key not in the domain takes the next value after the last, and joins the domain. */
-    map(key: string): T;
-    /** The keys a legend lists. */
-    ticks(): string[];
-    format(key: string): string;
-}
-/** An ordinal scale from `domain` to `range`. Throws on an empty range. */
-declare function ordinalScale<T>(opts: OrdinalScaleOptions<T>): OrdinalScale<T>;
-
-/** The kinds of mark a chart is drawn with. */
-type MarkKind = 'bar' | 'span' | 'line' | 'area' | 'point' | 'arc' | 'ribbon' | 'rule' | 'text';
-/** The value a mark stands for, as plain fields: a series and index, a category, a value. */
-type PlotDatum = Readonly<Record<string, string | number | boolean>>;
-/** What a mark's scene data says about it: its kind, and the datum it draws. */
-interface PlotMarkTrait {
-    kind: MarkKind;
-    datum?: PlotDatum;
-}
-/** A solid paint, as the kit's painters read one. */
-interface SolidFill {
-    paint: {
-        color: string;
-        opacity?: number;
-    };
-}
-/** A solid stroke, as the kit's painters read one. */
-interface SolidStroke {
-    paint: {
-        color: string;
-    };
-    width: number;
-    dash?: number[];
-    cap?: 'butt' | 'round' | 'square';
-    join?: 'miter' | 'round' | 'bevel';
-}
-/**
- * A mark's scene data: the trait under `plotMark`, and the fields the kit's
- * painters draw it from — `path` for a shape, a line or a region, `text` for
- * a label.
- */
-interface PlotMarkData {
-    plotMark: PlotMarkTrait;
-    path?: Path;
-    fill?: SolidFill;
-    stroke?: SolidStroke;
-    text?: string;
-    style?: {
-        fontFamily: string;
-        fontSize: number;
-        align?: 'left' | 'center' | 'right';
-        fontWeight?: number;
-    };
-    verticalAlign?: 'top' | 'center' | 'bottom';
-}
-/** A box, in the plot's own coordinates: from its root's corner. */
-interface PlotBox {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-    /** Radians about the box's center. */
-    rotation?: number;
-}
-/** One mark, ready to be a scene node: a key unique within its plot, where it is drawn, and its data. */
-interface PlotMark {
-    key: string;
-    pose: PlotBox;
-    data: PlotMarkData;
-}
-/** A point in the plot's coordinates. */
-interface PlotPoint {
-    x: number;
-    y: number;
-}
+import '@weasel-js/geom';
 
 /** Options for {@link barMark}. */
 interface BarMarkOptions {
@@ -400,6 +210,248 @@ declare function axisRoom<T>(opts: AxisOptions<T>): number;
 /** Every mark one axis is drawn with. Keys: `<key>:rule`, `<key>:tick:<i>`, `<key>:label:<i>`, `<key>:grid:<i>`, `<key>:title`. */
 declare function axisMarks<T>(opts: AxisOptions<T>): PlotMark[];
 
+/** A tag on a task: finished, under way, on the critical path, or a milestone drawn as a diamond at its start. */
+type GanttTag = 'done' | 'active' | 'crit' | 'milestone';
+/** Where a task starts: a date written in the chart's `dateFormat`, when the last of some tasks ends, or (absent
+ *  both) when the task before it ends. */
+type GanttStart = {
+    kind: 'date';
+    date: string;
+} | {
+    kind: 'after';
+    ids: readonly string[];
+} | {
+    kind: 'previous';
+};
+/** A unit a duration counts in: milliseconds to weeks, or calendar months and years. */
+type GanttUnit = 'ms' | 's' | 'm' | 'h' | 'd' | 'w' | 'M' | 'y';
+/** Where a task ends: a date in the chart's `dateFormat`, a length from its start (days skip excluded days), or
+ *  when the first of some tasks starts. */
+type GanttEnd = {
+    kind: 'date';
+    date: string;
+} | {
+    kind: 'duration';
+    amount: number;
+    unit: GanttUnit;
+} | {
+    kind: 'until';
+    ids: readonly string[];
+};
+/** One task. Its start and end are stored as written, so a task after another moves with it. */
+interface GanttTask {
+    name: string;
+    /** What `after` and `until` name it by. */
+    id?: string;
+    tags?: readonly GanttTag[];
+    start: GanttStart;
+    end: GanttEnd;
+}
+/** A run of tasks under one heading; the first may have none, holding the tasks before any `section`. */
+interface GanttSection {
+    name?: string;
+    tasks: readonly GanttTask[];
+}
+/** A Gantt chart: tasks in sections, laid on a time axis. */
+interface GanttData {
+    kind: 'gantt';
+    title?: string;
+    /** How dates are written, in Day.js tokens. Default `'YYYY-MM-DD'`. */
+    dateFormat?: string;
+    /** How the axis writes dates, in strftime tokens (`%Y-%m-%d`). Default the time scale's own. */
+    axisFormat?: string;
+    /** Days a duration in days skips: `'weekends'`, a weekday name (`'sunday'`), or a date in `dateFormat`. */
+    excludes?: readonly string[];
+    /** `'off'` hides the line at today; anything else is its style, as written. Default a line at today. */
+    todayMarker?: string;
+    sections: readonly GanttSection[];
+}
+
+/** How a commit is drawn: a plain dot, a crossed one for a revert, a square to stand out. */
+type GitCommitType = 'NORMAL' | 'REVERSE' | 'HIGHLIGHT';
+/** One line of a git graph, in the order it runs. */
+type GitCommand = {
+    kind: 'commit';
+    id?: string;
+    type?: GitCommitType;
+    tag?: string;
+    message?: string;
+} | {
+    kind: 'branch';
+    name: string;
+    order?: number;
+} | {
+    kind: 'checkout';
+    name: string;
+} | {
+    kind: 'merge';
+    branch: string;
+    id?: string;
+    type?: GitCommitType;
+    tag?: string;
+} | {
+    kind: 'cherry-pick';
+    id: string;
+    tag?: string;
+    parent?: string;
+};
+/** A git graph: the commands that build its history, replayed to lay out a lane per branch. */
+interface GitGraphData {
+    kind: 'gitgraph';
+    title?: string;
+    /** Default `'LR'`: commits run left to right, branches stack downward. */
+    orientation?: 'LR' | 'TB' | 'BT';
+    /** Default `'main'`. */
+    mainBranch?: string;
+    commands: readonly GitCommand[];
+}
+
+/** One step of a journey: how it went, 1 to 5, and who took part. */
+interface JourneyTask {
+    name: string;
+    /** A whole number, 1 to 5. */
+    score: number;
+    actors: readonly string[];
+}
+/** A run of steps under one heading; the first may have none, holding the steps before any `section`. */
+interface JourneySection {
+    name?: string;
+    tasks: readonly JourneyTask[];
+}
+/** A user journey: steps left to right in sections, each scored 1 to 5. */
+interface JourneyData {
+    kind: 'journey';
+    title?: string;
+    sections: readonly JourneySection[];
+}
+
+/** One field: bits `start` to `end`, inclusive. */
+interface PacketField {
+    start: number;
+    end: number;
+    label: string;
+    /** Written as a bit count (`+8`) after the field before it, rather than as a range. */
+    relative?: boolean;
+}
+/** A packet diagram: fields laid along rows of bits. */
+interface PacketData {
+    kind: 'packet';
+    title?: string;
+    /** Default 32. */
+    bitsPerRow?: number;
+    fields: readonly PacketField[];
+}
+
+/** One slice: its label and value. */
+interface PieSlice {
+    label: string;
+    value: number;
+}
+/** A pie chart: a slice per value, in order clockwise from twelve o'clock, with a legend. */
+interface PieData {
+    kind: 'pie';
+    title?: string;
+    /** Write each slice's value in the legend, where a text edit can change it. */
+    showData?: boolean;
+    slices: readonly PieSlice[];
+}
+
+/** How a point is drawn. Any field absent takes the class's, then the theme's. */
+interface QuadrantPointStyle {
+    radius?: number;
+    color?: string;
+    strokeColor?: string;
+    /** In pixels. */
+    strokeWidth?: number;
+}
+/** One point, at `x` and `y` from 0 to 1. */
+interface QuadrantPoint {
+    name: string;
+    x: number;
+    y: number;
+    /** A key into the chart's `classes`. */
+    className?: string;
+    style?: QuadrantPointStyle;
+}
+/** An axis's two ends' labels. */
+interface QuadrantAxis {
+    low?: string;
+    high?: string;
+}
+/** A quadrant chart: points in the unit square, cut into four labeled quadrants. */
+interface QuadrantData {
+    kind: 'quadrant';
+    title?: string;
+    x?: QuadrantAxis;
+    y?: QuadrantAxis;
+    /** Quadrant labels, in Mermaid's order: top right, top left, bottom left, bottom right. */
+    quadrants?: readonly [string?, string?, string?, string?];
+    points: readonly QuadrantPoint[];
+    /** Named point styles. */
+    classes?: Readonly<Record<string, QuadrantPointStyle>>;
+}
+
+/** One spoke of a radar chart. */
+interface RadarAxis {
+    id: string;
+    /** Default its id. */
+    label?: string;
+}
+/** One curve: a value on each axis, in axis order. */
+interface RadarCurve {
+    id: string;
+    /** Default its id. */
+    label?: string;
+    values: readonly number[];
+}
+/** A radar chart: curves drawn as areas over spokes from a center. */
+interface RadarData {
+    kind: 'radar';
+    title?: string;
+    axes: readonly RadarAxis[];
+    curves: readonly RadarCurve[];
+    /** The value at the center. Default 0. */
+    min?: number;
+    /** The value at the rim. Default the largest value. */
+    max?: number;
+    /** Default `'circle'`. */
+    graticule?: 'circle' | 'polygon';
+    /** How many rings the graticule has. Default 5. */
+    ticks?: number;
+    /** Default true. */
+    showLegend?: boolean;
+}
+
+/** A flow of `value` from one node to another, named by their labels. */
+interface SankeyLink {
+    source: string;
+    target: string;
+    value: number;
+}
+/** A sankey diagram: nodes in columns by depth, joined by ribbons as thick as their flow. */
+interface SankeyData {
+    kind: 'sankey';
+    title?: string;
+    links: readonly SankeyLink[];
+}
+
+/** One period on a timeline, and what happened in it. */
+interface TimelinePeriod {
+    label: string;
+    events: readonly string[];
+}
+/** A run of periods under one heading; the first may have none, holding the periods before any `section`. */
+interface TimelineSection {
+    name?: string;
+    periods: readonly TimelinePeriod[];
+}
+/** A timeline: periods left to right, each with its events stacked under it. */
+interface TimelineData {
+    kind: 'timeline';
+    title?: string;
+    sections: readonly TimelineSection[];
+}
+
 /** A category axis: one band per label, in order; with none, bands numbered from 1. */
 interface XyBandAxis {
     kind: 'band';
@@ -437,10 +489,8 @@ interface XyChartData {
     series: readonly XySeries[];
 }
 
-/** Chart specs, and the one table that compiles each kind to marks. */
-
 /** A chart, as data: one spec per kind, told apart by `kind`. */
-type PlotData = XyChartData;
+type PlotData = XyChartData | GanttData | TimelineData | PieData | QuadrantData | JourneyData | GitGraphData | SankeyData | PacketData | RadarData;
 /** The kinds of chart {@link PlotData} holds. */
 type PlotKind = PlotData['kind'];
 /** What a kind's compiler is given and gives back: its spec laid out in a box of `size`, as marks. */
@@ -486,7 +536,10 @@ declare function compileXyChart(data: XyChartData, size: {
     layout: XyLayout;
 };
 
-/** `data` with series `series`'s value at `index` set to `value`. Throws on an index the series does not hold. */
+/** How many rows the chart has: its categories, or its longest series where that is longer. */
+declare const xyRows: (data: XyChartData) => number;
+/** `data` with series `series`'s value at `index` set to `value`, a shorter series padded with zeros. Throws on a series
+ *  the chart does not hold or an index past its last row. */
 declare function setXyValue(data: XyChartData, series: number, index: number, value: number): XyChartData;
 /** The value a point stands at along `layout`'s value axis, rounded to a tenth of its tick step. */
 declare function xyValueAt(layout: XyLayout, at: {
@@ -494,6 +547,374 @@ declare function xyValueAt(layout: XyLayout, at: {
     y: number;
 }): number;
 
+/** Where one task runs, in milliseconds since the epoch. */
+interface GanttSpan {
+    start: number;
+    end: number;
+}
+/** Every task's span, by section and place in it, and the instants they cover between them. */
+interface GanttSchedule {
+    spans: readonly (readonly GanttSpan[])[];
+    domain: readonly [number, number];
+}
+/**
+ * Every task's span. A date that does not read in the `dateFormat`, an id no task holds, and the far end of a
+ * dependency cycle all resolve to the chart's first date: its earliest written start, else the start of `today`'s
+ * day. An end before its start is moved up to the start.
+ */
+declare function scheduleGantt(data: GanttData, today?: number): GanttSchedule;
+
+/** Where a gantt's parts landed: the plot area, its time scale, and every task's resolved span. */
+interface GanttLayout {
+    /** The area the rows are drawn in, right of the section names and above the axis. */
+    plot: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    time: TimeScale;
+    schedule: GanttSchedule;
+    /** What a drag snaps to, in milliseconds: an hour when the `dateFormat` carries hours, else a day. */
+    snap: number;
+}
+/** Lays out a gantt in a box of `size`: its title, section bands and names, task spans and names, axis, and today. */
+declare function compileGantt(data: GanttData, size: {
+    width: number;
+    height: number;
+}, theme: PlotTheme, measure: PlotMeasure): {
+    marks: PlotMark[];
+    layout: GanttLayout;
+};
+
+/** Dates as a gantt writes them: Day.js formats read and written, strftime for the axis. Every instant is UTC. */
+/** The default `dateFormat`. */
+declare const GANTT_DATE_FORMAT = "YYYY-MM-DD";
+/** `text` read strictly in Day.js `format`, as milliseconds since the epoch; `null` when it does not read. Fields the
+ *  format lacks default to 1970-01-01 00:00. */
+declare function parseGanttDate(text: string, format: string): number | null;
+/** `t` written in Day.js `format`. */
+declare function formatGanttDate(t: number, format: string): string;
+
+/**
+ * `data` with a task starting at `start`, written in the chart's `dateFormat`. A task that started after others, or
+ * after the task before it, leaves that dependency: it starts on the date from then on. Its end is kept as written,
+ * so a duration moves with it and a date stays put.
+ */
+declare function moveGanttTask(data: GanttData, section: number, task: number, start: number): GanttData;
+/**
+ * `data` with a task ending at `end`. A duration keeps its unit and takes the whole number of units nearest the span,
+ * at least 1 (0 for a milestone), days and weeks counted past excluded days; a date takes the new date, not before the
+ * start; an `until` end becomes a duration in days.
+ */
+declare function setGanttEnd(data: GanttData, section: number, task: number, end: number): GanttData;
+/** `data` with section `section` named `name`, trimmed. An empty name changes nothing. */
+declare function setGanttSectionName(data: GanttData, section: number, name: string): GanttData;
+/** `data` with a task named `name`, trimmed. An empty name changes nothing. */
+declare function setGanttTaskName(data: GanttData, section: number, task: number, name: string): GanttData;
+
+/** Where a timeline's columns landed: one per period, counted flat across sections. */
+interface TimelineLayout {
+    /** Each period's column center along x. */
+    slots: readonly number[];
+    columnWidth: number;
+}
+/** Lays out a timeline in a box of `size`: its title, section headers, period boxes, the line across, and events. */
+declare function compileTimeline(data: TimelineData, size: {
+    width: number;
+    height: number;
+}, theme: PlotTheme, measure: PlotMeasure): {
+    marks: PlotMark[];
+    layout: TimelineLayout;
+};
+
+/** Edits to a timeline, as plain data in and out. Periods are counted flat, left to right across every section. */
+
+/** `data` with section `section` named `name`, trimmed. An empty name changes nothing. Throws on a section it does not hold. */
+declare function setTimelineSectionName(data: TimelineData, section: number, name: string): TimelineData;
+/** `data` with period `period`'s label set to `label`, trimmed. An empty label changes nothing. */
+declare function setTimelinePeriodLabel(data: TimelineData, period: number, label: string): TimelineData;
+/** `data` with event `event` of period `period` set to `text`, trimmed; an empty one removes the event. */
+declare function setTimelineEvent(data: TimelineData, period: number, event: number, text: string): TimelineData;
+/**
+ * `data` with the period at flat index `from` moved to flat index `to`, counted after it is taken out. Moved right,
+ * it joins the section of the period before it; moved left, the section of the period after it. A section the move
+ * leaves empty is dropped. Throws on an index the timeline does not hold.
+ */
+declare function moveTimelinePeriod(data: TimelineData, from: number, to: number): TimelineData;
+
+/** Where a pie's parts landed: its center and radius, and each slice's angles, clockwise from twelve o'clock. */
+interface PieLayout {
+    center: PlotPoint;
+    radius: number;
+    /** One per slice; a zero-valued slice's two angles are equal. */
+    angles: readonly {
+        start: number;
+        end: number;
+    }[];
+}
+/** Lays out a pie in a box of `size`: its title, a slice per value with its share written on it where it fits, and
+ *  a legend at the right. */
+declare function compilePie(data: PieData, size: {
+    width: number;
+    height: number;
+}, theme: PlotTheme, measure: PlotMeasure): {
+    marks: PlotMark[];
+    layout: PieLayout;
+};
+
+/** Edits to a pie, as plain data in and out. */
+
+/** `data` with slice `slice`'s value set to `value`. Throws on a slice the pie does not hold. */
+declare const setPieValue: (data: PieData, slice: number, value: number) => PieData;
+/** `data` with slice `slice`'s label set to `label`. Throws on a slice the pie does not hold. */
+declare const setPieLabel: (data: PieData, slice: number, label: string) => PieData;
+
+/** Where a quadrant chart's unit square landed. */
+interface QuadrantLayout {
+    plot: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+}
+/** Lays out a quadrant chart in a box of `size`: its title, the four quadrants and their labels, the axis labels,
+ *  and each point with its name beside it. */
+declare function compileQuadrant(data: QuadrantData, size: {
+    width: number;
+    height: number;
+}, theme: PlotTheme, measure: PlotMeasure): {
+    marks: PlotMark[];
+    layout: QuadrantLayout;
+};
+
+/** Edits to a quadrant chart, as plain data in and out. */
+
+/** `data` with point `point` moved to `x`, `y`. Throws on a point the chart does not hold. */
+declare const setQuadrantPoint: (data: QuadrantData, point: number, at: {
+    x: number;
+    y: number;
+}) => QuadrantData;
+/** `data` with point `point` named `name`. Throws on a point the chart does not hold. */
+declare const setQuadrantPointName: (data: QuadrantData, point: number, name: string) => QuadrantData;
+/** `data` with an axis's end labeled `text`; an empty one drops it. */
+declare function setQuadrantAxisLabel(data: QuadrantData, axis: 'x' | 'y', end: 'low' | 'high', text: string): QuadrantData;
+/** `data` with quadrant `quadrant` (1 to 4, Mermaid's numbering) labeled `text`; an empty one drops it. Throws on any other number. */
+declare function setQuadrantLabel(data: QuadrantData, quadrant: number, text: string): QuadrantData;
+
+/** Where a journey's parts landed: the plot area, the score scale up it, and each step's band across it. */
+interface JourneyLayout {
+    plot: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    score: LinearScale;
+    /** Over every step in order, keyed by its place among them all from `'0'`. */
+    steps: BandScale;
+}
+/** Lays out a journey in a box of `size`: its title, its steps left to right under their sections' headers, each at
+ *  its score up a 1-to-5 axis with its name and its actors' dots under it, and a legend of actors at the right. */
+declare function compileJourney(data: JourneyData, size: {
+    width: number;
+    height: number;
+}, theme: PlotTheme, measure: PlotMeasure): {
+    marks: PlotMark[];
+    layout: JourneyLayout;
+};
+
+/** Edits to a user journey, as plain data in and out. */
+
+/** `data` with a step's score set to `score`. Throws on a step the journey does not hold. */
+declare const setJourneyScore: (data: JourneyData, section: number, task: number, score: number) => JourneyData;
+/** `data` with a step named `name`. Throws on a step the journey does not hold. */
+declare const setJourneyTaskName: (data: JourneyData, section: number, task: number, name: string) => JourneyData;
+/** `data` with section `section` named `name`. Throws on a section the journey does not hold. */
+declare function setJourneySectionName(data: JourneyData, section: number, name: string): JourneyData;
+
+/** A git graph's commands replayed into its history: the commits each made, and the branches they sit on. */
+
+/** One commit, as the replay made it. */
+interface GitCommit {
+    /** The index in `commands` of the command that made it. */
+    command: number;
+    /** The command's own id, else one the replay gave it. */
+    id: string;
+    branch: string;
+    /** Its place in the whole history, from 0. */
+    seq: number;
+    /** The commit it follows, then for a merge the one it merges. */
+    parents: readonly string[];
+    type: GitCommitType;
+    /** For a cherry-pick, the commit it copies. */
+    source?: string;
+}
+/** One branch: its name, where it forked, and its commits in order. */
+interface GitBranch {
+    name: string;
+    order?: number;
+    /** The commit it was branched from; none for the main branch, or one branched before any commit. */
+    fork?: string;
+    commits: string[];
+}
+/** A replayed history. `branches` in lane order: the main branch first, then by `order`, then as created. */
+interface GitHistory {
+    commits: GitCommit[];
+    branches: GitBranch[];
+    /** The first command that could not run, and why; the history holds what ran before it. */
+    error?: {
+        command: number;
+        message: string;
+    };
+}
+/** Replays `data`'s commands from an empty main branch, stopping at the first one that cannot run, as Mermaid does. */
+declare function replayGitGraph(data: GitGraphData): GitHistory;
+
+/** Where a gitgraph's parts landed: each lane's place across the run, and each commit's point. */
+interface GitGraphLayout {
+    history: GitHistory;
+    /** Each branch's place across the run, in `history.branches` order: a y for `'LR'`, an x otherwise. */
+    lanes: readonly number[];
+    /** Each commit's point, in `history.commits` order. */
+    points: readonly PlotPoint[];
+}
+/** Lays out a gitgraph in a box of `size`: its title, a lane per branch with its name, commits along it, merge links. */
+declare function compileGitGraph(data: GitGraphData, size: {
+    width: number;
+    height: number;
+}, theme: PlotTheme, measure: PlotMeasure): {
+    marks: PlotMark[];
+    layout: GitGraphLayout;
+};
+
+/** Edits to a gitgraph, as plain data in and out. */
+
+/** `data` with command `command`'s tag set to `text`, trimmed; an empty one removes it. Throws on a command that
+ *  does not exist or makes no commit. */
+declare function setGitTag(data: GitGraphData, command: number, text: string): GitGraphData;
+
+/** Where a sankey's nodes and ribbons stand: columns by depth, heights by flow, ordered to cross less. */
+
+/** One node, placed. */
+interface SankeyNodeBox {
+    label: string;
+    column: number;
+    /** The larger of what flows in and what flows out. */
+    value: number;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/** One link's ribbon: the span it leaves its source across, and the span it reaches its target across. */
+interface SankeyRibbon {
+    source: number;
+    target: number;
+    from: {
+        x: number;
+        y0: number;
+        y1: number;
+    };
+    to: {
+        x: number;
+        y0: number;
+        y1: number;
+    };
+}
+/** Where a sankey's parts landed. `nodes` in order of first mention; `links` in the spec's order. */
+interface SankeyLayout {
+    nodes: SankeyNodeBox[];
+    links: SankeyRibbon[];
+    columns: number;
+}
+/** Lays `data` out in `box`: a column per depth, each node as tall as its flow, ribbons stacked within each node. */
+declare function sankeyLayout(data: SankeyData, box: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}): SankeyLayout;
+
+/** Lays out a sankey in a box of `size`: its title, a bar per node with its label and value, a ribbon per link with its value. */
+declare function compileSankey(data: SankeyData, size: {
+    width: number;
+    height: number;
+}, theme: PlotTheme, measure: PlotMeasure): {
+    marks: PlotMark[];
+    layout: SankeyLayout;
+};
+
+/** `data` with link `link`'s value set to `value`. Throws on a link it does not hold. */
+declare function setSankeyValue(data: SankeyData, link: number, value: number): SankeyData;
+/** `data` with node `from` called `to` in every link. Throws on a node it does not hold, or a name another node has. */
+declare function renameSankeyNode(data: SankeyData, from: string, to: string): SankeyData;
+
+/** Where a packet's rows landed: a band per bit of a row across, and each row's box from `boxTop(row)` down. */
+interface PacketLayout {
+    /** Over a row's bits, keyed `'0'` to one less than the bits per row. */
+    bits: BandScale;
+    bitsPerRow: number;
+    rows: number;
+    /** The top of row `row`'s field boxes, under its bit numbers. */
+    boxTop(row: number): number;
+    boxHeight: number;
+}
+/** One row's share of a field: its first and last bit there. */
+interface PacketPiece {
+    row: number;
+    lo: number;
+    hi: number;
+}
+/** Lays out a packet in a box of `size`: its title, then its fields along rows of bits, each a box per row it covers
+ *  with its label in the widest, and the bit numbers at each piece's ends above it. */
+declare function compilePacket(data: PacketData, size: {
+    width: number;
+    height: number;
+}, theme: PlotTheme, measure: PlotMeasure): {
+    marks: PlotMark[];
+    layout: PacketLayout;
+};
+
+/** Edits to a packet diagram, as plain data in and out. */
+
+/** `data` with field `field` labeled `label`. Throws on a field the packet does not hold. */
+declare function setPacketLabel(data: PacketData, field: number, label: string): PacketData;
+
+/** Where a radar's parts landed: the scale its spokes are drawn on. */
+interface RadarLayout {
+    scale: PolarScale;
+}
+/** Lays out a radar in a box of `size`: its title, graticule, axis labels, curves and legend. */
+declare function compileRadar(data: RadarData, size: {
+    width: number;
+    height: number;
+}, theme: PlotTheme, measure: PlotMeasure): {
+    marks: PlotMark[];
+    layout: RadarLayout;
+};
+
+/** `data` with curve `curve`'s value on axis `axis` set to `value`. Throws on a curve or axis it does not hold. */
+declare function setRadarValue(data: RadarData, curve: number, axis: number, value: number): RadarData;
+/** `data` with axis `axis`'s label set to `text`; an empty label falls back to the axis's id. Throws on an axis it does not hold. */
+declare function setRadarAxisLabel(data: RadarData, axis: number, text: string): RadarData;
+/** `data` with curve `curve`'s label set to `text`; an empty label falls back to the curve's id. Throws on a curve it does not hold. */
+declare function setRadarCurveLabel(data: RadarData, curve: number, text: string): RadarData;
+
+/** The room every chart leaves around its edge. */
+declare const CHART_PAD = 12;
+/** `title` centered across the top of a box `width` wide, keyed `title`, and where the rest of the chart starts below
+ *  it: {@link CHART_PAD} down when there is no title. */
+declare function chartTitle(title: string | undefined, width: number, theme: PlotTheme, measure: PlotMeasure): {
+    marks: PlotMark[];
+    top: number;
+};
+/** `data` with its title set to `text`, trimmed; an empty one drops it. `data` itself when that changes nothing. */
+declare function withTitle<D extends {
+    title?: string;
+}>(data: D, text: string): D;
+
 /**
  * A plot in a scene: one root node holding the spec, its marks derived
  * children rebuilt from it. An edit replaces the spec and rebuilds the marks
@@ -556,32 +977,99 @@ interface ReplacePlotOptions {
 }
 /** Replaces the spec of the plot rooted at `rootId` with `data` and rebuilds its marks, as one undo entry. */
 declare function replacePlotData<TData, TLayer extends string, TPose>(scene: Scene<TData, TLayer, TPose>, rootId: string, data: PlotData, opts?: ReplacePlotOptions): void;
+/** The id of the plot root `id` is, or is a mark of; `null` for a node outside every plot. */
+declare function plotRootContaining(scene: Scene<unknown, string, unknown>, id: string): NodeId | null;
 /** Every plot root in `scene`, in render order. */
 declare function plotRootsIn(scene: Scene<unknown, string, unknown>): NodeId[];
 
-/** What each chart kind lets a drag edit: which marks carry a handle, and the spec a drag of one proposes. */
-
 /** A handle a press can take: where it stands in the plot's coordinates, and the cursor over it. */
 interface PlotHandle {
     at: PlotPoint;
     cursor: 'ns-resize' | 'ew-resize' | 'move';
+    /** Which of a mark's handles this is, handed back to {@link PlotEditor.drag}; for a mark with more than one. */
+    part?: string;
+    /** Takes a press anywhere in this box, in the plot's coordinates, rather than near `at`. */
+    box?: PlotBox;
 }
 /** One chart kind's edits. */
 interface PlotEditor<D extends PlotData> {
-    /** The handle on a mark, or `null` for a mark a drag does not edit. */
+    /** The handles on a mark, or `null` for a mark a drag does not edit. */
     handle(data: D, mark: {
         trait: PlotMarkTrait;
         pose: PlotBox;
-    }): PlotHandle | null;
-    /** A drag that took the handle on `mark`: the spec it proposes with the pointer at a point in the plot's coordinates.
-     *  `null` when the mark has nothing to edit. */
+    }): PlotHandle | readonly PlotHandle[] | null;
+    /** A drag that took the handle `part` on `mark`: the spec it proposes with the pointer at a point in the plot's
+     *  coordinates. `null` when the mark has nothing to edit. */
     drag(data: D, mark: PlotMarkTrait, size: {
         width: number;
         height: number;
-    }, theme: PlotTheme, measure: PlotMeasure): ((at: PlotPoint) => D) | null;
+    }, theme: PlotTheme, measure: PlotMeasure, part?: string): ((at: PlotPoint) => D) | null;
+    /** The spec with the text a text mark of `datum` stands for set to `text`; `data` itself when that changes
+     *  nothing or `text` does not read (a value that is not a number). Absent for a kind with no text edits. */
+    text?(data: D, datum: PlotDatum, text: string): D;
 }
 /** The edits `data`'s kind allows, or `null` for a kind with none. */
 declare const plotEditorOf: (data: PlotData) => PlotEditor<PlotData> | null;
+/** A handle list as an array, whatever {@link PlotEditor.handle} returned. */
+declare const handlesOf: (h: PlotHandle | readonly PlotHandle[] | null) => readonly PlotHandle[];
+
+/**
+ * Dragging a plot's handle to edit the value behind it. The handle layer
+ * claims the press; this action previews every mark the proposed spec
+ * redraws, and commits the spec as one edit of the plot's root.
+ */
+
+/** The action that drags a plot's handle. */
+declare const PLOT_DRAG_ACTION_ID = "plot.dragValue";
+/** A plot edited: the root, and the spec it now holds. */
+interface PlotEdit {
+    rootId: string;
+    data: PlotData;
+}
+/** Options for {@link createPlotDragAction}. */
+interface PlotDragOptions {
+    id?: string;
+    /** Default {@link textMeasure}. */
+    measure?: PlotMeasure;
+    /** Defaults to {@link replacePlotData} against `deps.scene`, labeled "Edit value". */
+    commit?: (edit: PlotEdit, ctx: InvocationCtx) => void;
+}
+/** The default commit: the spec into the root, its marks rebuilt, as one history entry, "Edit value". */
+declare function commitPlotToScene(edit: PlotEdit, ctx: InvocationCtx, measure?: PlotMeasure): void;
+/** The `plot.dragValue` action: an ongoing drag that moves one value of a plot, previewing the marks it redraws. */
+declare function createPlotDragAction(opts?: PlotDragOptions): Action;
+
+/**
+ * Editing a chart's text in place, through a canvas's own text editor: a text
+ * mark whose datum names an `edit` is the spec's text, and closing the editor
+ * folds what was typed into one edit of the spec.
+ */
+
+type AnyScene$1 = Scene<unknown, string, unknown>;
+/** The datum of a text mark an edit can set: one naming what it edits under `edit`, or `null` for any other node. */
+declare function plotTextOf(node: {
+    data: unknown;
+} | undefined): PlotDatum | null;
+/** Whether `data` is a chart's text an edit can set. */
+declare const isPlotText: (data: unknown) => boolean;
+/**
+ * Folds a text edit just written to one of a chart's text marks into its
+ * root's spec: the edit is undone and `commit` gets the spec with the new
+ * text, so the change is one entry on the spec, not a mark the next compile
+ * would overwrite. Does nothing for any other node, or text that changes
+ * nothing. Text that does not read (a value that is not a number) is undone,
+ * so the mark shows the spec again.
+ */
+declare function foldPlotText(scene: AnyScene$1, textId: string, commit: (edit: PlotEdit & {
+    label: string;
+}) => void): void;
+/**
+ * The `<SceneCanvas textEditor>` options that open on a chart's text and, as
+ * the edit closes, fold it into one edit of the spec for `commit`.
+ */
+declare function usePlotTextEdit(scene: AnyScene$1, commit: (edit: PlotEdit & {
+    label: string;
+}) => void): Exclude<SceneCanvasTextEditor<unknown>, false>;
 
 /**
  * What makes a plot's editable marks grabbable: a hit-only point region at
@@ -599,6 +1087,8 @@ interface PlotHandleScratch {
     markId: string;
     /** The handle, in world coordinates. */
     at: PlotPoint;
+    /** Which of the mark's handles, for a mark with more than one. */
+    part?: string;
 }
 /** A press's scratch, read back off the hit an action was handed. */
 declare function plotHandleScratchOf(hit: {
@@ -612,32 +1102,6 @@ declare function plotHandles(scene: AnyScene): Iterable<PlotHandleScratch & Plot
 /** The handle layer, for `CanvasExtensionApi.registerLayer`. */
 declare function plotHandleLayer(scene: Scene<unknown, string, unknown>): RenderLayer<unknown>;
 
-/**
- * Dragging a plot's handle to edit the value behind it. The handle layer
- * claims the press; this action previews every mark the proposed spec
- * redraws, and commits the spec as one edit of the plot's root.
- */
-
-/** The action that drags a plot's handle. */
-declare const PLOT_DRAG_ACTION_ID = "plot.dragValue";
-/** A plot edited: the root, and the spec it now holds. */
-interface PlotEdit {
-    rootId: string;
-    data: PlotData;
-}
-/** Options for {@link createPlotDragAction}. */
-interface PlotDragOptions {
-    id?: string;
-    /** Default {@link textMeasure}. */
-    measure?: PlotMeasure;
-    /** Defaults to {@link replacePlotData} against `deps.scene`, labeled "Edit value". */
-    commit?: (edit: PlotEdit, ctx: InvocationCtx) => void;
-}
-/** The default commit: the spec into the root, its marks rebuilt, as one history entry, "Edit value". */
-declare function commitPlotToScene(edit: PlotEdit, ctx: InvocationCtx, measure?: PlotMeasure): void;
-/** The `plot.dragValue` action: an ongoing drag that moves one value of a plot, previewing the marks it redraws. */
-declare function createPlotDragAction(opts?: PlotDragOptions): Action;
-
 /** The action id that absorbs a press on a handle, so it reaches neither marquee nor pan. */
 declare const GRAB_PLOT_HANDLE_ACTION_ID = "plot.grabHandle";
 /**
@@ -658,7 +1122,7 @@ declare function plotEditing(opts: PlotDragOptions & {
 interface PlotViewProps {
     /** The chart. A new value redraws it, with no undo entry. */
     data: PlotData;
-    /** Hears each edit a drag commits, with the spec it leaves. Undo and redo in the view report too. */
+    /** Hears each edit a drag or a text edit commits, with the spec it leaves. Undo and redo in the view report too. */
     onChange?: (data: PlotData) => void;
     width: number;
     height: number;
@@ -670,10 +1134,324 @@ interface PlotViewProps {
     'aria-label'?: string;
 }
 /**
- * A chart on its own canvas, edited by dragging its marks: a bar's end or a
- * line's point moves its value. Each drag is one undo entry. Text paints only
+ * A chart on its own canvas, edited by dragging its marks (a bar's end, a
+ * line's point, a task's span) and by double-clicking its text to edit it in
+ * place. Each edit is one undo entry. Text paints only
  * in a registered font family, so register the theme's (`registerCanvasFont`).
  */
 declare function PlotView(props: PlotViewProps): ReactElement;
 
-export { type ArcMarkOptions, type AreaMarkOptions, type AxisOptions, type AxisSide, type BandScale, type BandScaleOptions, type BarMarkOptions, type ContinuousScale, GRAB_PLOT_HANDLE_ACTION_ID, type LineMarkOptions, type LinearScale, type LinearScaleOptions, type LogScale, type LogScaleOptions, type MarkKind, type OrdinalScale, type OrdinalScaleOptions, PLOT_DRAG_ACTION_ID, PLOT_FONT, PLOT_HANDLE_AFFORDANCE_KIND, PLOT_HANDLE_LAYER_ID, PLOT_THEME, type PlotBox, type PlotCompiler, type PlotData, type PlotDatum, type PlotDragOptions, type PlotEdit, type PlotEditor, type PlotFont, type PlotHandle, type PlotHandleScratch, type PlotKind, type PlotMark, type PlotMarkData, type PlotMarkTrait, type PlotMeasure, type PlotPoint, type PlotRootData, type PlotRootTrait, type PlotSceneData, type PlotSpec, type PlotSpecsOptions, type PlotTheme, PlotView, type PlotViewProps, type PointMarkOptions, type ReplacePlotOptions, type RibbonMarkOptions, type RuleMarkOptions, type Scale, type SolidFill, type SolidStroke, type SpanMarkOptions, type TextMarkOptions, type TimeScale, type TimeScaleOptions, type XyBandAxis, type XyChartData, type XyLayout, type XyRangeAxis, type XySeries, type XyValueAxis, arcMark, areaMark, axisMarks, axisRoom, bandScale, barMark, commitPlotToScene, compilePlot, compileXyChart, createPlotDragAction, formatInstant, formatNumber, lineMark, linearScale, logScale, markSpecs, niceDomain, ordinalScale, plotEditing, plotEditorOf, plotHandleLayer, plotHandleScratchOf, plotHandles, plotMarkId, plotMarkOf, plotOrigin, plotRootOf, plotRootsIn, plotSpecs, plotThemeFrom, pointMark, replacePlotData, ribbonMark, ruleMark, seriesColor, setXyValue, spanMark, stepTicks, textMark, textMeasure, tickStep, timeScale, xyLength, xyValueAt, xyValueDomain };
+/**
+ * A chart's data as a host sees it to build a form or a grid: fields set once
+ * per chart, and tables of rows, some holding further tables under each row.
+ * Every read and write goes through the kind's own edits, so a host needs to
+ * know no kind to author one.
+ */
+
+/** What a field or cell holds; `undefined` for one left unset. */
+type PlotValue = string | number | boolean | undefined;
+/** What a field or cell takes, and so the control a host gives it. */
+type PlotValueType = {
+    kind: 'string';
+    placeholder?: string;
+} | {
+    kind: 'number';
+    min?: number;
+    max?: number;
+    step?: number;
+} | {
+    kind: 'boolean';
+} | {
+    kind: 'enum';
+    options: readonly string[];
+} | {
+    kind: 'color';
+};
+/** Where a nested table sits: the row it hangs under in each table above it, outermost first. `[]` for a top-level table. */
+type PlotScope = readonly number[];
+/** One value per chart: a title, an axis's end, an option. */
+interface PlotField<D extends PlotData = PlotData> {
+    key: string;
+    label: string;
+    type: PlotValueType;
+    /** May be left unset: setting `undefined` clears it, and the chart falls back to a default. */
+    optional?: boolean;
+    /** Whether the field means anything for `data` as it stands (a range axis's ends, only on a range axis). Absent, always. */
+    applies?(data: D): boolean;
+    get(data: D): PlotValue;
+    /** `data` with the field set to `value`; `data` itself when that changes nothing or does not read. */
+    set(data: D, value: PlotValue): D;
+}
+/** One column of a table. */
+interface PlotColumn<D extends PlotData = PlotData> {
+    key: string;
+    label: string;
+    type: PlotValueType;
+    /** May be left unset; see {@link PlotField.optional}. */
+    optional?: boolean;
+    /** Shown and never set: a value derived from others. */
+    readOnly?: boolean;
+    /** Whether the column means anything on this row (a commit's message, not a checkout's). Absent, every row. */
+    applies?(data: D, scope: PlotScope, row: number): boolean;
+    get(data: D, scope: PlotScope, row: number): PlotValue;
+    /** `data` with the cell set to `value`; `data` itself when that changes nothing or does not read. */
+    set(data: D, scope: PlotScope, row: number, value: PlotValue): D;
+}
+/** A collection a chart holds: slices, series, tasks, links. Each missing edit is one the collection does not allow. */
+interface PlotTable<D extends PlotData = PlotData> {
+    key: string;
+    label: string;
+    /** What one row is called, for a button or a handle's name: `'slice'`. */
+    item: string;
+    count(data: D, scope: PlotScope): number;
+    columns(data: D, scope: PlotScope): readonly PlotColumn<D>[];
+    /** `data` with a new row before row `at`; `at` equal to the count appends. */
+    insert?(data: D, scope: PlotScope, at: number): D;
+    remove?(data: D, scope: PlotScope, row: number): D;
+    /** `data` with row `from` moved to index `to`, counted once it is taken out. */
+    move?(data: D, scope: PlotScope, from: number, to: number): D;
+    /** What row `row` is called, for a heading over its nested tables. */
+    rowLabel?(data: D, scope: PlotScope, row: number): string;
+    /** Tables held under each row of this one; their scope is this one's with the row appended. */
+    children?: readonly PlotTable<D>[];
+}
+/** A chart kind's data, as fields and tables. */
+interface PlotSchema<D extends PlotData = PlotData> {
+    fields: readonly PlotField<D>[];
+    tables: readonly PlotTable<D>[];
+}
+
+/** `data`'s kind as fields and tables. Throws on a kind with none. */
+declare function plotSchemaOf(data: PlotData): PlotSchema;
+/** Every table in `schema` with the scope of each place it appears in `data`, outermost first: a nested table once
+ *  under each row of its parent. */
+declare function plotTablesIn(schema: PlotSchema, data: PlotData): {
+    table: PlotTable;
+    scope: PlotScope;
+}[];
+
+/** `data` with a row before row `at`: a zero in every series and, where rows are labeled, `label` (absent, a fresh one). */
+declare function insertXyRow(data: XyChartData, at: number, label?: string): XyChartData;
+/** `data` without row `at`, in every series and the labels. Throws on a row it does not hold. */
+declare function removeXyRow(data: XyChartData, at: number): XyChartData;
+/** `data` with row `from` moved to index `to`, counted once it is taken out, in every series and the labels. */
+declare const moveXyRow: (data: XyChartData, from: number, to: number) => XyChartData;
+/** `data` with row `index` labeled `label`, the axis turned to categories when it was numbered. */
+declare function setXyCategory(data: XyChartData, index: number, label: string): XyChartData;
+/** `data` with `series` inserted before series `at`; absent, a bar series of zeros under a fresh name. */
+declare function insertXySeries(data: XyChartData, at: number, series?: XySeries): XyChartData;
+/** `data` without series `series`. Throws on a series it does not hold. */
+declare const removeXySeries: (data: XyChartData, series: number) => XyChartData;
+/** `data` with series `from` moved to index `to`, counted once it is taken out. */
+declare const moveXySeries: (data: XyChartData, from: number, to: number) => XyChartData;
+/** `data` with series `series` named `name`, trimmed; an empty name drops it. */
+declare const setXySeriesName: (data: XyChartData, series: number, name: string | undefined) => XyChartData;
+/** `data` with series `series` drawn as bars or as a line. */
+declare const setXySeriesKind: (data: XyChartData, series: number, kind: XySeries["kind"]) => XyChartData;
+/** `data` with categories along x and values along y, or (`'horizontal'`) the other way round. */
+declare const setXyOrientation: (data: XyChartData, orientation: "vertical" | "horizontal") => XyChartData;
+/** `data` running along categories (each row labeled, numbered ones kept as written) or a numeric range from 0 to the
+ *  row count. The axis keeps its title. */
+declare function setXyXKind(data: XyChartData, kind: 'band' | 'range'): XyChartData;
+/** `data` with an axis titled `title`, trimmed; an empty one drops it. */
+declare function setXyAxisTitle(data: XyChartData, axis: 'x' | 'y', title: string | undefined): XyChartData;
+/** `data` with the value axis's end `end` at `value`; `undefined` lets it fit the values. */
+declare function setXyValueBound(data: XyChartData, end: 'min' | 'max', value: number | undefined): XyChartData;
+/** `data` with the range axis's end `end` at `value`. Throws on a chart not running along a range. */
+declare function setXyRangeBound(data: XyChartData, end: 'min' | 'max', value: number): XyChartData;
+
+/** `data` with `section` inserted before section `at`; absent, a section of one fresh task under a fresh name. */
+declare function insertGanttSection(data: GanttData, at: number, section?: GanttSection): GanttData;
+/** `data` without section `section` and its tasks. Throws on a section it does not hold. */
+declare function removeGanttSection(data: GanttData, section: number): GanttData;
+/** `data` with section `from` moved to index `to`, counted once it is taken out. */
+declare const moveGanttSection: (data: GanttData, from: number, to: number) => GanttData;
+/** `data` with `task` inserted before task `at` of section `section`; absent, a day-long task after the one before. */
+declare const insertGanttTask: (data: GanttData, section: number, at: number, task?: GanttTask) => GanttData;
+/** `data` without task `task` of section `section`. Throws on a task it does not hold. */
+declare function removeGanttTask(data: GanttData, section: number, task: number): GanttData;
+/** `data` with task `from` of section `section` moved to index `to` in it, counted once it is taken out. */
+declare const reorderGanttTask: (data: GanttData, section: number, from: number, to: number) => GanttData;
+/** `data` with task `task` of section `from` moved into section `to` before its task `at` (absent, last). Its id and
+ *  every dependency on it are kept. Throws on a task or section it does not hold. */
+declare function moveGanttTaskToSection(data: GanttData, from: number, task: number, to: number, at?: number): GanttData;
+/**
+ * `data` with a task's id set to `id`, trimmed, every dependency naming the old id following it; an empty id drops
+ * it and the dependencies on it. Throws on an id another task holds.
+ */
+declare function setGanttTaskId(data: GanttData, section: number, task: number, id: string | undefined): GanttData;
+/** `data` with a task carrying `tags`, kept in one order and each once; none drops them. */
+declare const setGanttTaskTags: (data: GanttData, section: number, task: number, tags: readonly GanttTag[]) => GanttData;
+/** `data` with a task starting at `start`, as written. */
+declare const setGanttTaskStart: (data: GanttData, section: number, task: number, start: GanttStart) => GanttData;
+/** `data` with a task ending at `end`, as written. */
+declare const setGanttTaskEnd: (data: GanttData, section: number, task: number, end: GanttEnd) => GanttData;
+/** `data` with one of its text settings set to `value`, trimmed; an empty one drops it, for the default. */
+declare function setGanttSetting(data: GanttData, key: 'dateFormat' | 'axisFormat' | 'todayMarker', value: string | undefined): GanttData;
+/** `data` skipping `excludes` in durations counted in days, each trimmed; none drops them. */
+declare function setGanttExcludes(data: GanttData, excludes: readonly string[]): GanttData;
+
+/** A task's start and end as written in Mermaid: `after a b`, `until a b`, a duration (`3d`, `1.5h`), or a date. */
+
+/** `start` as written: `after a b`, a date, or `''` for one that follows the task before it. */
+declare const formatGanttStart: (start: GanttStart) => string;
+/** Text read as a start: `after a b` as its ids, `''` as following the task before, anything else as a date. */
+declare function parseGanttStart(text: string): GanttStart;
+/** `end` as written: `until a b`, a duration, or a date. */
+declare function formatGanttEnd(end: GanttEnd): string;
+/** Text read as an end: `until a b` as its ids, a duration as its amount and unit, anything else as a date. */
+declare function parseGanttEnd(text: string): GanttEnd;
+
+/** The flat index, counted across every section, of period `index` of section `section`. */
+declare function timelineFlatIndex(data: TimelineData, section: number, index: number): number;
+/** `data` with `section` inserted before section `at`; absent, one fresh period under a fresh name. */
+declare function insertTimelineSection(data: TimelineData, at: number, section?: TimelineSection): TimelineData;
+/** `data` without section `section` and its periods. Throws on a section it does not hold. */
+declare const removeTimelineSection: (data: TimelineData, section: number) => TimelineData;
+/** `data` with section `from` moved to index `to`, counted once it is taken out. */
+declare const moveTimelineSection: (data: TimelineData, from: number, to: number) => TimelineData;
+/** `data` with `period` inserted before period `at` of section `section`; absent, a fresh period with no events. */
+declare const insertTimelinePeriod: (data: TimelineData, section: number, at: number, period?: TimelinePeriod) => TimelineData;
+/** `data` without period `period` of section `section`. Throws on a period it does not hold. */
+declare const removeTimelinePeriod: (data: TimelineData, section: number, period: number) => TimelineData;
+/** `data` with period `from` of section `section` moved to index `to` in it, counted once it is taken out. */
+declare const reorderTimelinePeriod: (data: TimelineData, section: number, from: number, to: number) => TimelineData;
+/** `data` with event `text` inserted before event `at` of one period; absent, a fresh one. */
+declare const insertTimelineEvent: (data: TimelineData, section: number, period: number, at: number, text?: string) => TimelineData;
+/** `data` without event `event` of one period. Throws on an event it does not hold. */
+declare const removeTimelineEvent: (data: TimelineData, section: number, period: number, event: number) => TimelineData;
+/** `data` with event `from` of one period moved to index `to` in it, counted once it is taken out. */
+declare const moveTimelineEvent: (data: TimelineData, section: number, period: number, from: number, to: number) => TimelineData;
+
+/** `data` with `slice` inserted before slice `at`; absent, a slice of 1 under a label no slice holds. */
+declare function insertPieSlice(data: PieData, at: number, slice?: PieSlice): PieData;
+/** `data` without slice `slice`. Throws on a slice it does not hold. */
+declare const removePieSlice: (data: PieData, slice: number) => PieData;
+/** `data` with slice `from` moved to index `to`, counted once it is taken out. */
+declare const movePieSlice: (data: PieData, from: number, to: number) => PieData;
+/** `data` writing, or not, each slice's value in the legend. */
+declare const setPieShowData: (data: PieData, show: boolean) => PieData;
+
+/** `data` with `point` inserted before point `at`; absent, a point at the center under a fresh name. */
+declare function insertQuadrantPoint(data: QuadrantData, at: number, point?: QuadrantPoint): QuadrantData;
+/** `data` without point `point`. Throws on a point it does not hold. */
+declare const removeQuadrantPoint: (data: QuadrantData, point: number) => QuadrantData;
+/** `data` with point `from` moved to index `to`, counted once it is taken out. */
+declare const moveQuadrantPoint: (data: QuadrantData, from: number, to: number) => QuadrantData;
+/** `data` with a point's style `key` set to `value`; `undefined` drops it, for its class's or the theme's. */
+declare const setQuadrantPointStyle: <K extends keyof QuadrantPointStyle>(data: QuadrantData, point: number, key: K, value: QuadrantPointStyle[K] | undefined) => QuadrantData;
+/** `data` with a point drawn in class `className`; `undefined` drops it. Throws on a class the chart does not hold. */
+declare function setQuadrantPointClass(data: QuadrantData, point: number, className: string | undefined): QuadrantData;
+/** The names of the chart's classes, in order. */
+declare const quadrantClassNames: (data: QuadrantData) => string[];
+/** `data` with a class `name` (absent, a fresh one) of `style` inserted before class `at`. Throws on a name it holds. */
+declare function insertQuadrantClass(data: QuadrantData, at: number, name?: string, style?: QuadrantPointStyle): QuadrantData;
+/** `data` without class `index`, every point that used it drawn in its own style. Throws on a class it does not hold. */
+declare function removeQuadrantClass(data: QuadrantData, index: number): QuadrantData;
+/** `data` with class `from` moved to index `to`, counted once it is taken out. */
+declare const moveQuadrantClass: (data: QuadrantData, from: number, to: number) => QuadrantData;
+/** `data` with class `index` called `name`, on every point that used it too. Throws on a name another class holds. */
+declare function renameQuadrantClass(data: QuadrantData, index: number, name: string): QuadrantData;
+/** `data` with class `index`'s style `key` set to `value`; `undefined` drops it, for the theme's. */
+declare function setQuadrantClassStyle<K extends keyof QuadrantPointStyle>(data: QuadrantData, index: number, key: K, value: QuadrantPointStyle[K] | undefined): QuadrantData;
+
+/** `data` with `section` inserted before section `at`; absent, one fresh step under a fresh name. */
+declare function insertJourneySection(data: JourneyData, at: number, section?: JourneySection): JourneyData;
+/** `data` without section `section` and its steps. Throws on a section it does not hold. */
+declare const removeJourneySection: (data: JourneyData, section: number) => JourneyData;
+/** `data` with section `from` moved to index `to`, counted once it is taken out. */
+declare const moveJourneySection: (data: JourneyData, from: number, to: number) => JourneyData;
+/** `data` with `task` inserted before step `at` of section `section`; absent, a fresh step scored 3 with no actors. */
+declare const insertJourneyTask: (data: JourneyData, section: number, at: number, task?: JourneyTask) => JourneyData;
+/** `data` without step `task` of section `section`. Throws on a step it does not hold. */
+declare const removeJourneyTask: (data: JourneyData, section: number, task: number) => JourneyData;
+/** `data` with step `from` of section `section` moved to index `to` in it, counted once it is taken out. */
+declare const moveJourneyTask: (data: JourneyData, section: number, from: number, to: number) => JourneyData;
+/** `data` with a step taken part in by `actors`, each trimmed and once. */
+declare function setJourneyActors(data: JourneyData, section: number, task: number, actors: readonly string[]): JourneyData;
+
+/** The kinds of command a graph runs. */
+declare const GIT_COMMAND_KINDS: readonly ["commit", "branch", "checkout", "merge", "cherry-pick"];
+/** A command's fields besides its kind. */
+type GitCommandField = 'id' | 'type' | 'tag' | 'message' | 'name' | 'branch' | 'order' | 'parent';
+/** The fields each kind of command holds; `id` on a cherry-pick names the commit it picks. */
+declare const GIT_COMMAND_FIELDS: {
+    readonly [K in GitCommand['kind']]: readonly GitCommandField[];
+};
+/** The branches the graph names, its main branch first. */
+declare const gitBranchNames: (data: GitGraphData) => string[];
+/** `data` with `command` inserted before command `at`; absent, a plain commit. */
+declare const insertGitCommand: (data: GitGraphData, at: number, command?: GitCommand) => GitGraphData;
+/** `data` without command `command`. Throws on a command it does not hold. */
+declare const removeGitCommand: (data: GitGraphData, command: number) => GitGraphData;
+/** `data` with command `from` moved to index `to`, counted once it is taken out. */
+declare const moveGitCommand: (data: GitGraphData, from: number, to: number) => GitGraphData;
+/** `data` with command `at` replaced by `command`. Throws on a command it does not hold. */
+declare const setGitCommand: (data: GitGraphData, at: number, command: GitCommand) => GitGraphData;
+/**
+ * `data` with command `at` turned into a command of `kind`, keeping the fields both kinds hold. What the new kind needs
+ * and the old did not hold is filled in: a fresh name for a branch, the main branch to check out, the last branch
+ * created to merge, the last commit id to pick.
+ */
+declare function setGitCommandKind(data: GitGraphData, at: number, kind: GitCommand['kind']): GitGraphData;
+/**
+ * `data` with field `field` of command `at` set to `value`; `undefined` drops an optional field. Throws on a field its
+ * kind does not hold, a value of the wrong type, or dropping a field the kind needs.
+ */
+declare function setGitCommandField(data: GitGraphData, at: number, field: GitCommandField, value: string | number | undefined): GitGraphData;
+/** `data` drawn left to right (the default), top to bottom, or bottom to top. */
+declare const setGitOrientation: (data: GitGraphData, orientation: "LR" | "TB" | "BT") => GitGraphData;
+/** `data` with its main branch called `name`, trimmed, every checkout and merge of it renamed too. Throws on an empty
+ *  name or one another branch holds. */
+declare function setGitMainBranch(data: GitGraphData, name: string): GitGraphData;
+
+/** `data` with `link` inserted before link `at`; absent, a flow of 1 from the last link's target to a fresh node. */
+declare function insertSankeyLink(data: SankeyData, at: number, link?: SankeyLink): SankeyData;
+/** `data` without link `link`. Throws on a link it does not hold. */
+declare const removeSankeyLink: (data: SankeyData, link: number) => SankeyData;
+/** `data` with link `from` moved to index `to`, counted once it is taken out. */
+declare const moveSankeyLink: (data: SankeyData, from: number, to: number) => SankeyData;
+/** `data` with link `link` running from (`'source'`) or to (`'target'`) node `name`, trimmed; a node it names that no
+ *  link did is added. Throws on an empty name. */
+declare function setSankeyEnd(data: SankeyData, link: number, end: 'source' | 'target', name: string): SankeyData;
+/** `data` without node `name`: every link to or from it is taken out. Throws on a node it does not hold. */
+declare function removeSankeyNode(data: SankeyData, name: string): SankeyData;
+
+/** `data` with `field` inserted before field `at`, the fields after it moved along by its width; absent, an 8-bit
+ *  field just after the one before, under a fresh label. */
+declare function insertPacketField(data: PacketData, at: number, field?: PacketField): PacketData;
+/** `data` without field `field`, the fields after it moved back by its width. Throws on a field it does not hold. */
+declare function removePacketField(data: PacketData, field: number): PacketData;
+/** `data` with field `from` moved to index `to`, counted once it is taken out. Each field keeps its width and the
+ *  gap before each place is kept, so the fields are laid again from the first one's start. */
+declare function movePacketField(data: PacketData, from: number, to: number): PacketData;
+/** `data` with field `field` `bits` wide, a whole number at least 1, the fields after it moved by the change. */
+declare function setPacketBits(data: PacketData, field: number, bits: number): PacketData;
+/** `data` with field `field` starting at bit `start`, the fields after it moved along with it. Throws on a start
+ *  inside the field before it. */
+declare function setPacketStart(data: PacketData, field: number, start: number): PacketData;
+/** `data` with field `field` written as a count of bits after the field before (`+8`), or as a range. */
+declare const setPacketRelative: (data: PacketData, field: number, relative: boolean) => PacketData;
+/** `data` with `bits` to a row; `undefined` for the default 32. */
+declare function setPacketBitsPerRow(data: PacketData, bits: number | undefined): PacketData;
+
+/** `data` with `axis` inserted before axis `at`, every curve 0 on it; absent, an axis under a fresh id. */
+declare function insertRadarAxis(data: RadarData, at: number, axis?: RadarAxis): RadarData;
+/** `data` without axis `axis` and each curve's value on it. Throws on an axis it does not hold. */
+declare function removeRadarAxis(data: RadarData, axis: number): RadarData;
+/** `data` with axis `from` moved to index `to`, counted once it is taken out, each curve's value on it moving too. */
+declare function moveRadarAxis(data: RadarData, from: number, to: number): RadarData;
+/** `data` with `curve` inserted before curve `at`; absent, a curve of zeros under a fresh id. */
+declare function insertRadarCurve(data: RadarData, at: number, curve?: RadarCurve): RadarData;
+/** `data` without curve `curve`. Throws on a curve it does not hold. */
+declare const removeRadarCurve: (data: RadarData, curve: number) => RadarData;
+/** `data` with curve `from` moved to index `to`, counted once it is taken out. */
+declare const moveRadarCurve: (data: RadarData, from: number, to: number) => RadarData;
+/** `data` with axis `axis`'s id set to `id`. Throws on an id that is not a word or another axis holds. */
+declare function setRadarAxisId(data: RadarData, axis: number, id: string): RadarData;
+/** `data` with curve `curve`'s id set to `id`. Throws on an id that is not a word or another curve holds. */
+declare function setRadarCurveId(data: RadarData, curve: number, id: string): RadarData;
+/** `data` with option `key` set to `value`; `undefined` drops it, for its default. */
+declare function setRadarOption<K extends 'min' | 'max' | 'ticks' | 'graticule' | 'showLegend'>(data: RadarData, key: K, value: RadarData[K] | undefined): RadarData;
+
+export { type ArcMarkOptions, type AreaMarkOptions, type AxisOptions, type AxisSide, BandScale, type BarMarkOptions, CHART_PAD, GANTT_DATE_FORMAT, GIT_COMMAND_FIELDS, GIT_COMMAND_KINDS, GRAB_PLOT_HANDLE_ACTION_ID, type GanttData, type GanttEnd, type GanttLayout, type GanttSchedule, type GanttSection, type GanttSpan, type GanttStart, type GanttTag, type GanttTask, type GanttUnit, type GitBranch, type GitCommand, type GitCommandField, type GitCommit, type GitCommitType, type GitGraphData, type GitGraphLayout, type GitHistory, type JourneyData, type JourneyLayout, type JourneySection, type JourneyTask, type LineMarkOptions, LinearScale, PLOT_DRAG_ACTION_ID, PLOT_FONT, PLOT_HANDLE_AFFORDANCE_KIND, PLOT_HANDLE_LAYER_ID, PLOT_THEME, type PacketData, type PacketField, type PacketLayout, type PacketPiece, type PieData, type PieLayout, type PieSlice, PlotBox, type PlotColumn, type PlotCompiler, type PlotData, PlotDatum, type PlotDragOptions, type PlotEdit, type PlotEditor, type PlotField, type PlotFont, type PlotHandle, type PlotHandleScratch, type PlotKind, PlotMark, PlotMarkData, PlotMarkTrait, type PlotMeasure, PlotPoint, type PlotRootData, type PlotRootTrait, type PlotSceneData, type PlotSchema, type PlotScope, type PlotSpec, type PlotSpecsOptions, type PlotTable, type PlotTheme, type PlotValue, type PlotValueType, PlotView, type PlotViewProps, type PointMarkOptions, PolarScale, type QuadrantAxis, type QuadrantData, type QuadrantLayout, type QuadrantPoint, type QuadrantPointStyle, type RadarAxis, type RadarCurve, type RadarData, type RadarLayout, type ReplacePlotOptions, type RibbonMarkOptions, type RuleMarkOptions, type SankeyData, type SankeyLayout, type SankeyLink, type SankeyNodeBox, type SankeyRibbon, Scale, type SpanMarkOptions, type TextMarkOptions, TimeScale, type TimelineData, type TimelineLayout, type TimelinePeriod, type TimelineSection, type XyBandAxis, type XyChartData, type XyLayout, type XyRangeAxis, type XySeries, type XyValueAxis, 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 };