@weasel-js/plot 0.0.0-stage → 1.15.1

package/dist/index.d.ts

@@ -0,0 +1,1457 @@
+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, InvocationCtx, Action, SceneCanvasTextEditor, RenderLayer, Contribution, Paint } from '@weasel-js/core';
+import { ReactElement } from 'react';
+import '@weasel-js/geom';
+
+/** Options for {@link barMark}. */
+interface BarMarkOptions {
+    key: string;
+    /** Where the bar stands along the category axis: its left edge, or its top for a horizontal bar. */
+    x: number;
+    /** The bar's breadth across the category axis. */
+    width: number;
+    /** The baseline the bar rises from, and the end it reaches, along the value axis. */
+    from: number;
+    to: number;
+    color: string;
+    datum?: PlotDatum;
+    /** Default `'vertical'`: `x` and `width` run along x. */
+    orient?: 'vertical' | 'horizontal';
+}
+/** A bar from `from` to `to`, either way round. */
+declare function barMark(opts: BarMarkOptions): PlotMark;
+/** Options for {@link spanMark}. */
+interface SpanMarkOptions {
+    key: string;
+    /** Start and end along x. */
+    x0: number;
+    x1: number;
+    /** Its row: top and height. */
+    y: number;
+    height: number;
+    color: string;
+    opacity?: number;
+    datum?: PlotDatum;
+}
+/** A span across x, as a task's bar on a timeline is. */
+declare function spanMark(opts: SpanMarkOptions): PlotMark;
+/** Options for {@link pointMark}. */
+interface PointMarkOptions {
+    key: string;
+    x: number;
+    y: number;
+    /** Default 3. */
+    radius?: number;
+    color: string;
+    datum?: PlotDatum;
+}
+/** A dot centered on `x`, `y`. */
+declare function pointMark(opts: PointMarkOptions): PlotMark;
+
+/** Options for {@link lineMark}. */
+interface LineMarkOptions {
+    key: string;
+    /** At least one. */
+    points: readonly PlotPoint[];
+    color: string;
+    /** Default 2. */
+    width?: number;
+    dash?: number[];
+    datum?: PlotDatum;
+}
+/** A line through `points`, in order. */
+declare function lineMark(opts: LineMarkOptions): PlotMark;
+/** Options for {@link ruleMark}. */
+interface RuleMarkOptions {
+    key: string;
+    from: PlotPoint;
+    to: PlotPoint;
+    color: string;
+    /** Default 1. */
+    width?: number;
+    dash?: number[];
+    datum?: PlotDatum;
+}
+/** A straight rule from `from` to `to`: an axis line, a tick, a grid line, a marker. */
+declare function ruleMark(opts: RuleMarkOptions): PlotMark;
+/** Options for {@link areaMark}. */
+interface AreaMarkOptions {
+    key: string;
+    /** The upper edge, in order. */
+    top: readonly PlotPoint[];
+    /** The lower edge, in the same order as `top`. Default a baseline at `baseline` under each top point. */
+    bottom?: readonly PlotPoint[];
+    baseline?: number;
+    color: string;
+    /** Default 0.35. */
+    opacity?: number;
+    datum?: PlotDatum;
+}
+/** The region between two edges, as an area chart or a radar's polygon fills it. */
+declare function areaMark(opts: AreaMarkOptions): PlotMark;
+/** Options for {@link arcMark}. */
+interface ArcMarkOptions {
+    key: string;
+    center: PlotPoint;
+    /** 0 for a pie slice. */
+    innerRadius: number;
+    outerRadius: number;
+    /** Radians clockwise from twelve o'clock. */
+    startAngle: number;
+    endAngle: number;
+    color: string;
+    datum?: PlotDatum;
+}
+/** A slice of a ring, as a pie or a donut is cut. */
+declare function arcMark(opts: ArcMarkOptions): PlotMark;
+/** Options for {@link ribbonMark}. */
+interface RibbonMarkOptions {
+    key: string;
+    /** The end it leaves: an x, and the span along y it leaves across. */
+    from: {
+        x: number;
+        y0: number;
+        y1: number;
+    };
+    to: {
+        x: number;
+        y0: number;
+        y1: number;
+    };
+    color: string;
+    /** Default 0.45. */
+    opacity?: number;
+    datum?: PlotDatum;
+}
+/** A band curving from one span to another, as a flow between two nodes is drawn. */
+declare function ribbonMark(opts: RibbonMarkOptions): PlotMark;
+
+/** The face a chart's text is set in. */
+interface PlotFont {
+    fontFamily: string;
+    fontSize: number;
+}
+/** The colors a chart is drawn in, by role, and its face. Plain strings, so a scene can keep it. */
+interface PlotTheme {
+    /** Titles, labels and values. */
+    text: string;
+    /** Axis rules and ticks. */
+    axis: string;
+    /** Grid lines behind the marks. */
+    grid: string;
+    /** The colors series take in turn. Never empty. */
+    series: readonly string[];
+    font: PlotFont;
+}
+/** A plot theme from a resolved weasel theme: text in `fg`, axes in `border-strong`, grid in `border`, series in
+ *  its swatches. */
+declare function plotThemeFrom(resolved: Readonly<Record<string, string>> | ResolvedTheme, font?: PlotFont): PlotTheme;
+/** 12px sans-serif. */
+declare const PLOT_FONT: PlotFont;
+/** The weasel theme in its dark mode. */
+declare const PLOT_THEME: PlotTheme;
+/** The `i`th series' color, wrapping. */
+declare const seriesColor: (theme: PlotTheme, i: number) => string;
+
+/** How wide and tall one line of text is set in `font`. */
+type PlotMeasure = (text: string, font: PlotFont) => {
+    width: number;
+    height: number;
+};
+/** Measures as the kit's text renderer lays text out, from the registered face's metrics; a line is 1.2 sizes tall. */
+declare const textMeasure: PlotMeasure;
+
+/** Marks drawn as text: titles, tick labels, values. */
+
+/** Options for {@link textMark}. */
+interface TextMarkOptions {
+    key: string;
+    text: string;
+    /** The anchor point. */
+    x: number;
+    y: number;
+    /** Which part of the text stands on `x`. Default `'middle'`. */
+    anchor?: 'start' | 'middle' | 'end';
+    /** Which part of the text stands on `y`. Default `'middle'`. */
+    baseline?: 'top' | 'middle' | 'bottom';
+    font: PlotFont;
+    color: string;
+    measure: PlotMeasure;
+    /** Turns the text a quarter turn counterclockwise about the anchor, as a vertical axis's title reads. */
+    vertical?: boolean;
+    bold?: boolean;
+    datum?: PlotDatum;
+}
+/** One line of text, its box measured with `measure` and placed by its anchor. */
+declare function textMark(opts: TextMarkOptions): PlotMark;
+
+/** Which side of the plot an axis runs along. Its scale's range runs along x for top and bottom, along y otherwise. */
+type AxisSide = 'top' | 'bottom' | 'left' | 'right';
+/** Options for {@link axisMarks} and {@link axisRoom}. */
+interface AxisOptions<T> {
+    scale: Scale<T>;
+    side: AxisSide;
+    /** Where the axis line stands across its scale: a y for top and bottom, an x for left and right. */
+    at: number;
+    /** Draw a grid line at each tick, from the axis across to here. */
+    gridTo?: number;
+    title?: string;
+    /** How many ticks to ask the scale for. */
+    ticks?: number;
+    /** Prefixes every mark's key. Default `axis:<side>`. */
+    key?: string;
+    theme: PlotTheme;
+    measure: PlotMeasure;
+}
+/** How far an axis reaches out from its line: ticks, labels and title. */
+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';
+    title?: string;
+    categories: readonly string[];
+}
+/** A numeric axis from `min` to `max`, the series' values spread evenly across it. */
+interface XyRangeAxis {
+    kind: 'range';
+    title?: string;
+    min: number;
+    max: number;
+}
+/** The value axis. A missing end fits the series' values, zero included. */
+interface XyValueAxis {
+    title?: string;
+    min?: number;
+    max?: number;
+}
+/** One series: a value per category, drawn as bars or as a line. */
+interface XySeries {
+    kind: 'bar' | 'line';
+    name?: string;
+    values: readonly number[];
+}
+/** A bar and line chart over categories or a numeric range. */
+interface XyChartData {
+    kind: 'xychart';
+    title?: string;
+    /** Default `'vertical'`: categories along x, values up y. */
+    orientation?: 'vertical' | 'horizontal';
+    /** Absent, bands numbered from 1, one per value of the longest series. */
+    x?: XyBandAxis | XyRangeAxis;
+    y?: XyValueAxis;
+    series: readonly XySeries[];
+}
+
+/** A chart, as data: one spec per kind, told apart by `kind`. */
+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. */
+type PlotCompiler<D extends PlotData> = (data: D, size: {
+    width: number;
+    height: number;
+}, theme: PlotTheme, measure: PlotMeasure) => {
+    marks: PlotMark[];
+};
+/** `data` laid out in a box of `size`, as the marks it is drawn with, in drawing order. */
+declare function compilePlot(data: PlotData, size: {
+    width: number;
+    height: number;
+}, theme: PlotTheme, measure: PlotMeasure): PlotMark[];
+
+/** Where an xychart's parts landed: the plot area, the value scale, and each value index's place across it. */
+interface XyLayout {
+    orientation: 'vertical' | 'horizontal';
+    /** The area the marks are drawn in, inside the axes. */
+    plot: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    /** Values along y for a vertical chart, along x for a horizontal one. */
+    value: LinearScale;
+    /** Each value index's center along the category axis. */
+    slots: readonly number[];
+    /** How much of the category axis each index's bars share. */
+    slotWidth: number;
+}
+/** How many values the longest series holds. */
+declare const xyLength: (data: XyChartData) => number;
+/** The value axis's domain: its own ends, and where one is missing, the values' reach with zero in it, made round. */
+declare function xyValueDomain(data: XyChartData): [number, number];
+/** Lays out an xychart in a box of `size`: its title, axes, bars, lines and points. */
+declare function compileXyChart(data: XyChartData, size: {
+    width: number;
+    height: number;
+}, theme: PlotTheme, measure: PlotMeasure): {
+    marks: PlotMark[];
+    layout: XyLayout;
+};
+
+/** 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: {
+    x: number;
+    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
+ * as one undo entry.
+ */
+
+/** What a plot's root node keeps: the spec, and the theme its marks were drawn in. */
+interface PlotRootTrait {
+    data: PlotData;
+    theme: PlotTheme;
+}
+/** A plot root's scene data. */
+interface PlotRootData {
+    plot: PlotRootTrait;
+}
+/** The data of any node a plot puts in a scene. */
+type PlotSceneData = PlotRootData | PlotMarkData;
+/** A scene node spec, as {@link plotSpecs} returns them. */
+type PlotSpec<TLayer extends string = 'main'> = AddNodeSpec<PlotSceneData, TLayer, RectPose>;
+/** Options for {@link plotSpecs}. */
+interface PlotSpecsOptions<TLayer extends string = 'main'> {
+    /** The root's id. Default `'plot'`. */
+    id?: string;
+    /** The box the plot fills. */
+    box: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    /** Default `'main'`. */
+    layer?: TLayer;
+    /** Default {@link PLOT_THEME}. */
+    theme?: PlotTheme;
+    /** Default {@link textMeasure}. */
+    measure?: PlotMeasure;
+}
+/** The trait a plot root's data carries, or `null` for any other node. */
+declare function plotRootOf(node: {
+    data: unknown;
+} | undefined): PlotRootTrait | null;
+/** The trait a plot mark's data carries, or `null` for any other node. */
+declare function plotMarkOf(node: {
+    data: unknown;
+} | undefined): PlotMarkTrait | null;
+/** The id of the mark keyed `key` under the root `rootId`. */
+declare const plotMarkId: (rootId: string, key: string) => string;
+/** `marks` as children of the root `rootId`, in its frame. */
+declare function markSpecs<TLayer extends string>(rootId: string, layer: TLayer, marks: readonly PlotMark[]): PlotSpec<TLayer>[];
+/** The nodes a plot of `data` is: its root, a group filling `box`, then each mark under it, in drawing order. */
+declare function plotSpecs<TLayer extends string = 'main'>(data: PlotData, opts: PlotSpecsOptions<TLayer>): PlotSpec<TLayer>[];
+/** Options for {@link replacePlotData}. */
+interface ReplacePlotOptions {
+    /** The undo entry's label. Default `'Edit chart'`. */
+    label?: string;
+    /** Draw in this theme from now on. Default the one the root keeps. */
+    theme?: PlotTheme;
+    /** Default {@link textMeasure}. */
+    measure?: PlotMeasure;
+}
+/** 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[];
+
+/** 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 handles on a mark, or `null` for a mark a drag does not edit. */
+    handle(data: D, mark: {
+        trait: PlotMarkTrait;
+        pose: PlotBox;
+    }): 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, 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
+ * each handle its kind's editor names, composed into a layer whose id is the
+ * kind a press reports.
+ */
+
+/** The layer id the handles are composed into. */
+declare const PLOT_HANDLE_LAYER_ID = "plot-handles";
+/** The affordance kind a press on a handle reports. */
+declare const PLOT_HANDLE_AFFORDANCE_KIND: "layer:plot-handles";
+/** What a press on a handle hands the drag, as the hit's `payload`. */
+interface PlotHandleScratch {
+    rootId: string;
+    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: {
+    payload?: unknown;
+} | null | undefined): PlotHandleScratch | null;
+type AnyScene = Scene<unknown, string, unknown>;
+/** Where the plot root `rootId`'s corner stands in world coordinates. */
+declare function plotOrigin(scene: AnyScene, rootId: string): PlotPoint;
+/** Every handle in `scene` an edit may take, in world coordinates, in render order. */
+declare function plotHandles(scene: AnyScene): Iterable<PlotHandleScratch & PlotHandle>;
+/** The handle layer, for `CanvasExtensionApi.registerLayer`. */
+declare function plotHandleLayer(scene: Scene<unknown, string, unknown>): RenderLayer<unknown>;
+
+/** 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";
+/**
+ * Both halves of editing a scene's plots by dragging: the handle layer to
+ * `registerLayer`, and the contribution to pass as `ambient`, which binds a
+ * drag on a handle to `plot.dragValue`. One without the other fails quietly:
+ * the layer alone claims presses that start nothing, the contribution alone
+ * binds a kind nothing reports.
+ */
+declare function plotEditing(opts: PlotDragOptions & {
+    scene: Scene<unknown, string, unknown>;
+}): {
+    layer: RenderLayer<unknown>;
+    contribution: Contribution;
+};
+
+/** Props for {@link PlotView}. */
+interface PlotViewProps {
+    /** The chart. A new value redraws it, with no undo entry. */
+    data: PlotData;
+    /** 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;
+    /** Default the weasel theme's dark mode. */
+    theme?: PlotTheme;
+    measure?: PlotMeasure;
+    background?: Paint;
+    className?: string;
+    'aria-label'?: string;
+}
+/**
+ * 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;
+
+/**
+ * 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 };