@expressivecss/expressive 0.15.0 → 0.17.0

package/dist/types/components/pullToRefresh.d.ts

@@ -0,0 +1,80 @@
+import { Component, BaseOptions } from '../core/component';
+/** What `expressive:refresh` carries, and what `onRefresh` receives. */
+export interface PullToRefreshDetail {
+    /** Keeps the refresh running until the promise settles, fulfilled or rejected. */
+    waitUntil(promise: PromiseLike<unknown>): void;
+}
+/** What the container's status region announces. */
+export interface PullToRefreshI18nOptions {
+    /** Announced when a refresh starts. */
+    refreshing: string;
+    /** Announced when it finishes. */
+    refreshed: string;
+}
+export interface PullToRefreshOptions extends BaseOptions {
+    /**
+     * How far a finger must pull down, in pixels, for the release to refresh.
+     * A value that is not a positive number falls back to the default.
+     * @default 64
+     */
+    threshold: number;
+    /**
+     * Called when a refresh starts, with the event's detail.
+     * @default null
+     */
+    onRefresh: ((detail: PullToRefreshDetail) => void) | null;
+    /** What the status region announces when a refresh starts and finishes. */
+    i18n: Partial<PullToRefreshI18nOptions>;
+}
+/**
+ * Pull-to-refresh. A touch pull down from the top of the container, or a
+ * `[data-refresh]` button inside it, starts a refresh. The refresh runs until
+ * every promise passed to `waitUntil()` settles or the page calls `complete()`.
+ *
+ * Touch events rather than pointer events: a pointer drag the browser takes
+ * for a pan ends in `pointercancel`, and Safari has no directional
+ * `touch-action` to keep a downward pull from it. A mouse never fires touch
+ * events; a stylus does where the browser reports it as touch, as Safari on
+ * iPadOS does.
+ */
+export declare class PullToRefresh extends Component<PullToRefreshOptions> {
+    static key: string;
+    /** Where the finger went down and on what, while it may still become a pull. */
+    private _start;
+    private _pulling;
+    private _travel;
+    /** The running refresh. A new object each time, so a promise from an earlier one cannot end it. */
+    private _refresh;
+    /**
+     * Announces the start and the finish. The author's indicator cannot: it is
+     * hidden once the refresh ends, which would drop the finish.
+     */
+    private _status;
+    constructor(el: HTMLElement, options: Partial<PullToRefreshOptions>);
+    static get defaults(): PullToRefreshOptions;
+    /** Starts a refresh, as a pull or the refresh button does. Does nothing while one runs. */
+    refresh(): void;
+    /** Ends the running refresh: the indicator hides, `aria-busy` goes and the finish is announced. */
+    complete(): void;
+    destroy(): void;
+    /**
+     * Runs `onRefresh` and fires the event. A callback that throws ends the
+     * refresh it started, so later pulls still work, and the error still reaches the page.
+     */
+    private _fireRefresh;
+    /**
+     * Whether a downward drag from `target` would scroll something instead: a
+     * scrolled-down scroller inside the container, the container itself, or
+     * the scroller it sits in, which is the page when no ancestor scrolls.
+     */
+    private _canScrollUp;
+    private _onStart;
+    private _onMove;
+    /** Pulls once the finger moves down, or leaves the touch to scrolling when it moves another way first. */
+    private _decide;
+    /** Moves the indicator down with the finger, at half its travel, and fades it in toward the threshold. */
+    private _drag;
+    private _onEnd;
+    private _endPull;
+    private _onClick;
+}

package/dist/types/components/questionnaire.d.ts

@@ -1,4 +1,4 @@
-import { Component, BaseOptions, InitElements, InitElement } from '../core/component';
+import { Component, BaseOptions } from '../core/component';
 export interface QuestionnaireOptions extends BaseOptions {
     /**
      * Text above the progress bar. `{current}` and `{total}` are replaced with
@@ -14,6 +14,16 @@ export interface QuestionnaireOptions extends BaseOptions {
      * @default 'Choose an answer to continue.'
      */
     requiredMessage: string;
+    /**
+     * With `data-summary`, the heading of the review step and the text above
+     * the progress bar there.
+     * @default 'Review your answers'
+     */
+    summaryLabel: string;
+    /** With `data-summary`, the text of each answer's edit button. @default 'Edit' */
+    editLabel: string;
+    /** With `data-summary`, the answer shown for a question left blank. @default 'Not answered' */
+    skippedLabel: string;
 }
 /**
  * A multi-step questionnaire: a <form class="questionnaire"> whose
@@ -28,6 +38,12 @@ export interface QuestionnaireOptions extends BaseOptions {
  * clears its answer. A disabled fieldset is left out, so a page can switch
  * questions on and off from earlier answers.
  *
+ * Three attributes on the form add to that: `data-shortcuts` lets a letter or
+ * digit pick an answer, `data-summary` adds a review step listing every
+ * answer before the submit button, and `data-save="key"` keeps the answers
+ * and the shown question in localStorage under that key until the form is
+ * submitted.
+ *
  * Without JavaScript every question shows at once and the submit button sends
  * the form. The answers are ordinary form controls, so FormData reads them.
  */
@@ -42,21 +58,12 @@ export declare class Questionnaire extends Component<QuestionnaireOptions> {
     private _observer;
     /** Set while one submission's invalid events arrive, so only the first opens. */
     private _reporting;
-    constructor(el: HTMLFormElement, options: Partial<QuestionnaireOptions>);
+    /** With data-summary, the review step, and whether it is shown. */
+    private _summary;
+    private _reviewing;
+    constructor(el: HTMLElement, options: Partial<QuestionnaireOptions>);
     static get defaults(): QuestionnaireOptions;
-    /**
-     * Initializes instance of Questionnaire.
-     * @param el HTML element.
-     * @param options Component options.
-     */
-    static init(el: HTMLElement, options?: Partial<QuestionnaireOptions>): Questionnaire;
-    /**
-     * Initializes instances of Questionnaire.
-     * @param els HTML elements.
-     * @param options Component options.
-     */
-    static init(els: InitElements<InitElement>, options?: Partial<QuestionnaireOptions>): Questionnaire[];
-    static getInstance(el: HTMLElement): Questionnaire;
+    static key: string;
     /** The questions that apply: every fieldset child that is not disabled. */
     get items(): HTMLFieldSetElement[];
     /** Position of the shown question in `items`. */
@@ -65,8 +72,12 @@ export declare class Questionnaire extends Component<QuestionnaireOptions> {
     goTo: (index: number) => void;
     /** Checks the shown question and moves to the next one if it is answered. */
     next: () => void;
-    /** Moves to the previous question. */
+    /** Moves to the previous question, or from the review step back to the last one. */
     previous: () => void;
+    /** Shows the review step of a questionnaire with data-summary. */
+    review: () => void;
+    /** The next question, or after the last one the review step. */
+    private _advance;
     /** Clears the answer to the shown question and moves to the next one. */
     skip: () => void;
     destroy(): void;
@@ -77,6 +88,34 @@ export declare class Questionnaire extends Component<QuestionnaireOptions> {
     private _required;
     private _ensureId;
     private _render;
+    /** The question after the shown one, which was switched off, or the last that applies. */
+    private _after;
+    /** Whether the shown step is the one that submits: the review step, or without one the last question. */
+    private get _end();
+    /** Whether a footer button applies to the shown step. */
+    private _shows;
+    /** Whether the shown question may be skipped: it applies and needs no answer. */
+    private _skippable;
+    private _renderProgress;
+    /** With data-summary, the review step: a list of the questions and their answers, before the footer. */
+    private _createSummary;
+    /** Lists each question that applies with its answer and a button back to it. */
+    private _fillSummary;
+    /** The storage key from data-save, or '' without it. */
+    private get _key();
+    /**
+     * Every answer control that can be saved, in order. A file cannot be put back,
+     * a password must not sit in storage, and a hidden input is the server's.
+     */
+    private _allControls;
+    /** With data-save, stores the answers and the shown question. */
+    private _save;
+    /** Puts back saved answers and the question they reached, if the questions are the same. */
+    private _restore;
+    /** The saved state, or null for none or a broken one. */
+    private _read;
+    /** A submitted questionnaire has nothing left to resume. */
+    private _forget;
     /**
      * Puts "choose at least one" on the first enabled checkbox of each
      * data-required group with none checked, so the browser's validation, and
@@ -91,6 +130,9 @@ export declare class Questionnaire extends Component<QuestionnaireOptions> {
     private _setInvalid;
     private _handleClick;
     private _handleKeydown;
+    /** Whether a shortcut key can pick an answer now: data-shortcuts is set and a question shows. */
+    private get _shortcuts();
+    private _handleShortcut;
     private _handleInvalid;
     private _handleInput;
 }

package/dist/types/components/radarChart.d.ts

@@ -1,4 +1,3 @@
-import { InitElements, InitElement } from '../core/component';
 import { LineChart, LineChartOptions } from './lineChart';
 export type RadarChartOptions = LineChartOptions;
 /**
@@ -7,17 +6,15 @@ export type RadarChartOptions = LineChartOptions;
  * shape joining its values on the spokes, from zero in the middle to the
  * scale's top at the rim. The row labels sit round the rim.
  *
- * Re-run `RadarChart.init(el)` after changing the table.
+ * Call `update()` after changing the table, or start it with `watch` or
+ * `data-watch`.
  */
 export declare class RadarChart extends LineChart {
     protected get _type(): string;
-    protected get _key(): string;
     /** The scale starts at zero, the middle, so shapes compare by size. */
     protected get _fromZero(): boolean;
     protected get _circular(): boolean;
-    static init(el: HTMLElement, options?: Partial<RadarChartOptions>): RadarChart;
-    static init(els: InitElements<InitElement>, options?: Partial<RadarChartOptions>): RadarChart[];
-    static getInstance(el: HTMLElement): RadarChart;
+    static key: string;
     /**
      * The cursor is a spoke turned by --turn, and the tooltip sits past its
      * tip. LineChart's points on the spoke keep their top, a share of the
@@ -30,6 +27,13 @@ export declare class RadarChart extends LineChart {
     protected _guides(): Element[];
     /** The nearest spoke to the pointer, by its angle from the middle. */
     protected _indexAt(e: PointerEvent): number;
+    /** The grid rings' shares of the radius: one per .axis label above zero, or quarters. */
+    private _rings;
+    /**
+     * One series' group: its outline, broken at a gap like a line chart's,
+     * its .area fill and its .points.
+     */
+    private _series;
     /**
      * An SVG in a -50 to 50 box: the rings and spokes of the grid, then each
      * series' shape, with its points for .points. The rim is the box's edge;

package/dist/types/components/radialChart.d.ts

@@ -1,31 +1,58 @@
-import { InitElements, InitElement } from '../core/component';
 import { LineChart, LineChartOptions } from './lineChart';
 export type RadialChartOptions = LineChartOptions;
 /**
  * Radial chart. It reads its <table> like LineChart, but draws each row of
  * the first value column as a ring, outermost first, filled clockwise from
  * the top as a share of `data-max` above zero (100 by default). With `.gauge` the rings
- * are half circles over the middle. A <tfoot> row shows in the middle, and
+ * are half circles over the middle. With `.labels` they are three quarters
+ * of a circle, leaving the top left quarter for each row's name at the
+ * ring's start; a gauge's names hang under its base line instead.
+ * `data-segments` splits each ring into that many segments, filled whole,
+ * and `.gradient` shades each fill along the ring, from a light tint at its
+ * start to its full color at its end. A <tfoot>
+ * row shows in the middle, and
  * a legend lists the rows when there is more than one. Further columns show
  * in the tooltip.
  *
- * Re-run `RadialChart.init(el)` after changing the table or the ring tokens.
+ * Call `update()` after changing the ring tokens, and after changing the table
+ * unless it was started with `watch` or `data-watch`.
  */
 export declare class RadialChart extends LineChart {
     /** Each ring's middle radius, and their shared width. */
     private _radii;
     private _width;
+    /** The gap between rings, and between segments. */
+    private _gap;
     /** Each row's share of the maximum, from 0 to 1. */
     private _fractions;
     private _rings;
+    /** With .gradient, each ring's fill drawn again as a conic gradient, or null for none. */
+    private _sweeps;
     protected get _type(): string;
-    protected get _key(): string;
+    /** The rings fill to data-max, so there is no value axis. */
+    protected get _axis(): boolean;
     protected get _points(): boolean;
     protected get _circular(): boolean;
     private get _gauge();
-    static init(el: HTMLElement, options?: Partial<RadialChartOptions>): RadialChart;
-    static init(els: InitElements<InitElement>, options?: Partial<RadialChartOptions>): RadialChart[];
-    static getInstance(el: HTMLElement): RadialChart;
+    /** Whether .labels names the rings, which a sparkline never does. */
+    private get _labeled();
+    /** How much of a circle a full ring spans. */
+    private get _span();
+    /** The number of segments data-segments asks for, or 0 for whole rings. */
+    private get _segments();
+    /** A share as drawn: with segments, to the nearest whole segment. */
+    private _lit;
+    /**
+     * A ring's dash pattern for a share of its span. Round caps reach half the
+     * width past each end of a dash, so a capped dash is one width shorter and
+     * its gap one width longer; one shorter than the width is a dot. With
+     * segments, each lit segment is a dash with the ring gap after it, and
+     * the last gap runs out the circle so the pattern does not repeat.
+     */
+    private _dash;
+    /** The distance between rings' middles, or one ring's width. */
+    private get _step();
+    static key: string;
     show(index: number): void;
     /** The tooltip sits where the ring's fill ends. */
     protected _place(index: number): void;
@@ -35,6 +62,30 @@ export declare class RadialChart extends LineChart {
     protected _guides(): Element[];
     /** The ring under the pointer by its distance from the middle, or -1. */
     protected _indexAt(e: PointerEvent): number;
+    /**
+     * How far a point is from the middle in the SVG's 100-unit box. In the
+     * top left quarter .labels leaves empty, the names run straight across,
+     * so only the height counts and a name picks its own ring.
+     */
+    private _distance;
+    /** Under a gauge's base line, the ring whose name is under the pointer, or -1. */
+    private _nameAt;
+    /** The rings' turn, from three o'clock to the top or, for a gauge, to nine, and the SVG's box. */
+    private get _frame();
+    /**
+     * With .gradient, a ring's fill drawn again in HTML: a conic gradient from
+     * a tint of its colour at the ring's start to the full colour where the
+     * fill ends, masked to the fill's own dash, so it follows the ring round.
+     * An SVG stroke takes no conic gradient.
+     */
+    private _sweep;
+    /**
+     * With .labels, each row's name left of its ring's start at the top,
+     * ending at the middle line. CSS shrinks the text to fit crowded rings.
+     * A gauge's names hang under its base line in a row each, innermost
+     * first, starting below their rings' starts.
+     */
+    private _names;
     /**
      * An SVG of rings in a -50 to 50 box, the top half for a gauge. Each row
      * is a track circle and a fill circle whose dash is its share; CSS draws

package/dist/types/components/registry.d.ts

@@ -11,7 +11,7 @@ import { isCardReveal } from "./cards";
  * is forgotten.
  *
  * A component that should only ever be constructed explicitly (Snackbar,
- * CharacterCounter, Range, ...) simply stays out of this table.
+ * CharacterCounter, ...) simply stays out of this table.
  */
 export declare const AUTO_INIT_COMPONENTS: {
     AppBar: {
@@ -55,6 +55,10 @@ export declare const AUTO_INIT_COMPONENTS: {
         component: typeof Components.Keypad;
         selector: string;
     };
+    ColorPicker: {
+        component: typeof Components.ColorPicker;
+        selector: string;
+    };
     ColumnChart: {
         component: typeof Components.ColumnChart;
         selector: string;
@@ -83,6 +87,22 @@ export declare const AUTO_INIT_COMPONENTS: {
         component: typeof Components.MixedChart;
         selector: string;
     };
+    ScatterChart: {
+        component: typeof Components.ScatterChart;
+        selector: string;
+    };
+    FunnelChart: {
+        component: typeof Components.FunnelChart;
+        selector: string;
+    };
+    SankeyChart: {
+        component: typeof Components.SankeyChart;
+        selector: string;
+    };
+    TreemapChart: {
+        component: typeof Components.TreemapChart;
+        selector: string;
+    };
     CommandPalette: {
         component: typeof Components.CommandPalette;
         selector: string;
@@ -107,6 +127,30 @@ export declare const AUTO_INIT_COMPONENTS: {
         component: typeof Components.MessageScroller;
         selector: string;
     };
+    PullToRefresh: {
+        component: typeof Components.PullToRefresh;
+        selector: string;
+    };
+    LoadingOverlay: {
+        component: typeof Components.LoadingOverlay;
+        selector: string;
+    };
+    SwipeActions: {
+        component: typeof Components.SwipeActions;
+        selector: string;
+    };
+    InputMask: {
+        component: typeof Components.InputMask;
+        selector: string;
+    };
+    ShowMore: {
+        component: typeof Components.ShowMore;
+        selector: string;
+    };
+    CurrencyInput: {
+        component: typeof Components.CurrencyInput;
+        selector: string;
+    };
     Lightbox: {
         component: typeof Components.Lightbox;
         selector: string;
@@ -115,10 +159,22 @@ export declare const AUTO_INIT_COMPONENTS: {
         component: typeof Components.ScrollSpy;
         selector: string;
     };
+    BackToTop: {
+        component: typeof Components.BackToTop;
+        selector: string;
+    };
     FormSelect: {
         component: typeof Components.FormSelect;
         selector: string;
     };
+    TreeSelect: {
+        component: typeof Components.TreeSelect;
+        selector: string;
+    };
+    Cascader: {
+        component: typeof Components.Cascader;
+        selector: string;
+    };
     NavigationRail: {
         component: typeof Components.NavigationRail;
         selector: string;
@@ -135,10 +191,18 @@ export declare const AUTO_INIT_COMPONENTS: {
         component: typeof Components.Tooltip;
         selector: string;
     };
+    HoverCard: {
+        component: typeof Components.HoverCard;
+        selector: string;
+    };
     FloatingActionButton: {
         component: typeof Components.FloatingActionButton;
         selector: string;
     };
+    Menubar: {
+        component: typeof Components.Menubar;
+        selector: string;
+    };
 };
 type Registry = typeof AUTO_INIT_COMPONENTS;
 /**
@@ -150,8 +214,14 @@ export type AutoInitOptions = {
 };
 /**
  * Automatically initialize components.
- * @param context Root element to initialize. Defaults to `document.body`.
+ * @param context Root element or shadow root to initialize. Defaults to
+ * `document.body`. Shadow roots inside it are not entered.
  * @param options Options for each component.
+ * @param settings With `watch: true`, keep starting components in markup
+ * added to `context` later, and destroy them when their markup is removed.
+ * @returns A function that stops watching. It does nothing without `watch`.
  */
-export declare function AutoInit(context?: HTMLElement, options?: Partial<AutoInitOptions>): void;
+export declare function AutoInit(context?: HTMLElement | ShadowRoot, options?: Partial<AutoInitOptions>, settings?: {
+    watch?: boolean;
+}): () => void;
 export {};

package/dist/types/components/richTextEditor.d.ts

@@ -1,27 +1,44 @@
-import { Component, BaseOptions, InitElements, InitElement } from '../core/component';
+import { Component, BaseOptions, InitElement, InitElements } from '../core/component';
 /**
  * The parts of a Tiptap `Editor` this component uses. Declared here so the
  * published types do not depend on Tiptap.
  */
+/** A Tiptap command chain. Commands by name come through `command()`. */
+export interface RichTextEditorChain {
+    focus(): RichTextEditorChain;
+    run(): boolean;
+}
+/**
+ * What `new Editor()` gets. Only these are declared; the extensions and
+ * `editorProps` ride along, and Tiptap types them itself.
+ */
+export interface RichTextEditorConfig {
+    element: HTMLElement;
+    content: string;
+    editable: boolean;
+}
 export interface RichTextEditorInstance {
     commands: object;
     isEditable: boolean;
     isEmpty: boolean;
-    chain(): any;
-    can(): any;
+    chain(): RichTextEditorChain;
+    /** Each command as a check that reports whether it can run now. */
+    can(): object;
     isActive(name: string, attributes?: object): boolean;
     getHTML(): string;
     on(event: string, callback: () => void): unknown;
     off(event: string, callback: () => void): unknown;
     destroy(): void;
 }
-export interface RichTextEditorOptions extends BaseOptions {
+/** Tiptap's `Editor` class, or any class with the parts this component uses. */
+export type RichTextEditorClass = new (options: RichTextEditorConfig) => RichTextEditorInstance;
+export interface RichTextEditorOptions<E extends RichTextEditorClass = RichTextEditorClass> extends BaseOptions {
     /**
      * Tiptap's `Editor` class. ExpressiveCSS does not bundle Tiptap, so the
      * page imports it and passes it in.
      * @default null
      */
-    Editor: (new (options: any) => RichTextEditorInstance) | null;
+    Editor: E | null;
     /**
      * Tiptap extensions, usually `[StarterKit]`.
      * @default []
@@ -39,33 +56,39 @@ export interface RichTextEditorOptions extends BaseOptions {
  * disabled when their command cannot run, and `toggle*` commands report their
  * state with `aria-pressed` and `.active`.
  */
-export declare class RichTextEditor extends Component<RichTextEditorOptions> {
-    /** The Tiptap editor. */
-    editor: RichTextEditorInstance | null;
+export declare class RichTextEditor<E extends RichTextEditorClass = RichTextEditorClass> extends Component<RichTextEditorOptions<E>> {
+    /**
+     * The Tiptap editor, with the full type of the `Editor` passed to the
+     * constructor; `init()` and `getInstance()` see the `RichTextEditorInstance`
+     * subset.
+     */
+    editor: InstanceType<E> | null;
     /** The form value. */
     textarea: HTMLTextAreaElement | null;
     /** The element the editor is mounted in. */
     content: HTMLElement | null;
     private _actions;
     private _label;
-    constructor(el: HTMLElement, options: Partial<RichTextEditorOptions>);
+    private _required;
+    private _form;
+    /** Initializes an editor, typed by the `Editor` passed in. */
+    static init<E extends RichTextEditorClass>(this: typeof RichTextEditor, el: HTMLElement, options?: Partial<RichTextEditorOptions<E>>): RichTextEditor<E>;
+    /** Initializes an editor on each element, typed by the `Editor` passed in. */
+    static init<E extends RichTextEditorClass>(this: typeof RichTextEditor, els: InitElements<InitElement>, options?: Partial<RichTextEditorOptions<E>>): RichTextEditor<E>[];
+    constructor(el: HTMLElement, options: Partial<RichTextEditorOptions<E>>);
     static get defaults(): RichTextEditorOptions;
-    /**
-     * Initializes instance of RichTextEditor.
-     * @param el HTML element.
-     * @param options Component options.
-     */
-    static init(el: HTMLElement, options?: Partial<RichTextEditorOptions>): RichTextEditor;
-    /**
-     * Initializes instances of RichTextEditor.
-     * @param els HTML elements.
-     * @param options Component options.
-     */
-    static init(els: InitElements<InitElement>, options?: Partial<RichTextEditorOptions>): RichTextEditor[];
-    static getInstance(el: HTMLElement): RichTextEditor;
+    static key: string;
     destroy(): void;
     private _handleClick;
     private _handleLabelClick;
+    private _skipsValidation;
+    private _handleSubmit;
+    /**
+     * The form restores the textarea after the reset event, so the editor reads
+     * it back a task later. Without this the editor kept the typed text while the
+     * form submitted the default. No update is emitted, so a reset fires no input.
+     */
+    private _handleReset;
     private _handleUpdate;
     private _handleTransaction;
 }

package/dist/types/components/sankeyChart.d.ts

@@ -0,0 +1,72 @@
+import { LineChart, LineChartOptions } from './lineChart';
+export type SankeyChartOptions = LineChartOptions;
+/**
+ * Sankey chart. Each row of its <table> is a flow: the first cell names the
+ * source node, the second the target node, and the third holds the value.
+ * Nodes stand in columns, a node with no incoming flow in the first and any
+ * other one column past the furthest of its sources, and stack in the order
+ * their names first appear. Each link is as thick as its value, and each
+ * node as tall as the larger of its in and out totals, on one scale. A row
+ * without both names or a positive value, or whose link would close a
+ * cycle, draws nothing.
+ *
+ * Call `update()` after changing the table, or start it with `watch` or
+ * `data-watch`.
+ */
+export declare class SankeyChart extends LineChart {
+    private _nodes;
+    /** The drawn links, in table order. */
+    private _links;
+    /** The links' paths, in the same order. */
+    private _paths;
+    /** Each drawn shape's path data, by its link's source and target names or its node's name, which update() moves from. */
+    private _shapes;
+    protected get _type(): string;
+    /** The value column is the one series; the target column is read on its own. */
+    protected get _seriesFrom(): number;
+    protected get _seriesTo(): number;
+    /** The links carry the values, so there is no value axis. */
+    protected get _axis(): boolean;
+    static key: string;
+    /** The links the keys and pointer reach. */
+    protected get _count(): number;
+    /** Highlights one link, numbered in table order among those drawn. Pass -1 to hide the tooltip. */
+    show(index: number): void;
+    /**
+     * Fills the tooltip beside the link's middle: its source and target under
+     * their column headers, with their nodes' colors, and the value cell's
+     * text, as the author wrote them. Past the middle it opens back over the plot.
+     */
+    private _fill;
+    /** The link under the pointer, or -1 off every link. By position, since a touch keeps its first target as it drags. */
+    protected _indexAt(e: PointerEvent): number;
+    /**
+     * Steps through the links in table order. The arrows keep their meaning
+     * in a right-to-left chart, since table order is no direction on screen.
+     */
+    protected _keyTarget(key: string): number | undefined;
+    /** Reads the flows and lays out their nodes and links. Without a link to draw, the chart draws nothing. */
+    protected _read(): void;
+    /** An x position in hundredths of the plot, mirrored in a right-to-left chart. */
+    private _across;
+    /** A node as path data: a rectangle. */
+    private _nodePath;
+    /** A link as path data: two curves from the source's edge to the target's, closed between them. */
+    private _linkPath;
+    /**
+     * The links, then the nodes over their ends. Neither has a stroke, so the
+     * stretched SVG keeps their sizes. After update(), each shape still in the
+     * table moves from where it was: a link found by its source and target
+     * names, a node by its name.
+     */
+    protected _draw(): Element;
+    /**
+     * The node names, over the drawing, each level with its node and toward
+     * the plot's middle: after the node, or before it in the last column.
+     * They are placed from the inline start, so they need no mirroring.
+     */
+    protected _axes(): Element[];
+    private _name;
+    /** No row labels or legend: the nodes carry the names. */
+    protected _guides(): Element[];
+}