@fusion.dev/helix-headless 0.145.0 → 0.147.0

package/dist/quote/marks.js

@@ -0,0 +1,5 @@
+const MARKS = new Set(['"', "'", '“', '”', '‘', '’', '„', '«', '»', '‹', '›', '「', '」']);
+export const typedMarks = (text) => {
+    const trimmed = text.trim();
+    return trimmed !== '' && (MARKS.has(trimmed[0] ?? '') || MARKS.has(trimmed.at(-1) ?? ''));
+};

package/dist/quote/root/quote-root.d.ts

@@ -1,5 +1,5 @@
 import { HelixElement } from '@fusion.dev/helix-core';
-import { type TemplateResult } from 'lit';
+import { type PropertyValues, type TemplateResult } from 'lit';
 /**
  * @summary A short quotation, set inline with the text around it.
  *
@@ -7,7 +7,10 @@ import { type TemplateResult } from 'lit';
  * Renders a real `<q>`, so the browser supplies the quotation marks. It inserts
  * the correct marks for the document's language and nests them correctly when
  * one quotation sits inside another. Do not type quotation marks into the
- * content.
+ * content: one that starts or ends with a typed mark warns once, with the
+ * runtime kind `typed-marks`. A quotation in a language other than the page's takes `lang` on the
+ * element, and its marks follow it: `lang="de"` sets „…“ and `lang="fr"` «…»
+ * inside an English page.
  *
  * For a passage set off from the surrounding text, use a blockquote.
  *
@@ -26,6 +29,15 @@ export declare class HelixHeadlessQuote extends HelixElement {
      * URL identifying where the quotation came from.
      */
     cite: string;
+    /** Whether this quote has said its text carries typed marks, so it says so once. */
+    private warned;
+    /**
+     * Reads the quoted text as it first renders and as it changes, for marks the
+     * `<q>` would double. On the shadow root rather than in the template, so the
+     * served markup is the `<q>` and its slot and nothing else.
+     */
+    private readonly readText;
+    protected firstUpdated(changed: PropertyValues): void;
     protected render(): TemplateResult;
 }
 declare global {

package/dist/quote/root/quote-root.js

@@ -4,13 +4,35 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-import { customElement, HelixElement } from '@fusion.dev/helix-core';
+import { customElement, HelixElement, reportRuntime } from '@fusion.dev/helix-core';
 import { html, nothing } from 'lit';
 import { property } from 'lit/decorators.js';
+import { typedMarks } from '../marks.js';
 let HelixHeadlessQuote = class HelixHeadlessQuote extends HelixElement {
     constructor() {
         super(...arguments);
         this.cite = '';
+        this.warned = false;
+        this.readText = () => {
+            const text = [...this.childNodes]
+                .filter((node) => !(node instanceof Element) || !node.slot)
+                .map((node) => node.textContent ?? '')
+                .join('');
+            if (this.warned || !typedMarks(text)) {
+                return;
+            }
+            this.warned = true;
+            reportRuntime({
+                kind: 'typed-marks',
+                message: `<${this.localName}> starts or ends with a typed quotation mark, and the browser sets its own, so the marks show twice. Take the typed marks out.`,
+                tag: this.localName,
+            });
+        };
+    }
+    firstUpdated(changed) {
+        super.firstUpdated(changed);
+        this.readText();
+        this.renderRoot.addEventListener('slotchange', this.readText);
     }
     render() {
         return html `<q part="quote" cite=${this.cite || nothing}><slot></slot></q>`;

package/dist/radio/group/radio-group.d.ts

@@ -30,6 +30,21 @@ declare const HelixHeadlessRadioGroup_base: (new (...args: any[]) => import("@fu
  * `helix-select`. A native radio sends `input` and `change` in the same task as
  * the click.
  *
+ * **Keyboard.** The group is one tab stop: the chosen radio, or the first that
+ * can be chosen.
+ *
+ * | Key | What it does |
+ * |---|---|
+ * | Right, Down | Chooses the next radio, from the last back to the first. |
+ * | Left, Up | Chooses the radio before, from the first round to the last. |
+ * | Home, End | Chooses the first or the last radio. |
+ * | Space, Enter | Chooses the focused radio. |
+ *
+ * Left and Right swap on a right-to-left page, and a disabled radio is passed
+ * over. Under `readonly` the arrows move focus and choose nothing. The group
+ * is a `radiogroup` named by `label`, and each radio is a `role="radio"`
+ * button with `aria-checked`.
+ *
  * @since 0.1.0
  * @status stable
  * @aliases RadioButtons, Choice group

package/dist/radio/root/radio-root.d.ts

@@ -29,15 +29,19 @@ declare const HelixHeadlessRadio_base: (new (...args: any[]) => import("@fusion.
  * replaces the visible label, and the label becomes the name read by screen
  * readers. The icon has its own slot so the chip can hide the label and show
  * the icon.
+ * @slot indicator - An icon drawn inside the circle in place of the dot, such
+ * as a check mark.
  *
  * @event {HelixSelectEvent} helix-select - Fired when the radio is chosen. Cancelable: call `preventDefault()` to keep the current choice.
  *
  * @csspart box - The circle. Draw the dot inside it with `::part(box)::after` in
- * your stylesheet. This tier ships no CSS, so it renders no separate element for
- * the dot, which would add an empty child to your layout.
+ * your stylesheet, or slot an icon into `indicator`. This tier ships no CSS, so
+ * it renders no separate element for the dot, which would add an empty child to
+ * your layout.
  * @csspart item - The button, which covers the whole row.
  * @csspart label - The label beside the circle.
  *
+ * @cssstate has-indicator - An icon is slotted into `indicator`.
  * @cssstate selected - The radio is chosen.
  */
 export declare class HelixHeadlessRadio extends HelixHeadlessRadio_base {

package/dist/radio/root/radio-root.js

@@ -4,7 +4,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-import { customElement, HelixElement, HostClickController, MixinSelectableItem, } from '@fusion.dev/helix-core';
+import { customElement, HelixElement, HostClickController, MixinSelectableItem, slotFilled, } from '@fusion.dev/helix-core';
 import { html } from 'lit';
 import { property } from 'lit/decorators.js';
 let HelixHeadlessRadio = class HelixHeadlessRadio extends MixinSelectableItem(HelixElement) {
@@ -32,7 +32,12 @@ let HelixHeadlessRadio = class HelixHeadlessRadio extends MixinSelectableItem(He
       tabindex=${(this.focusable ?? this.selected) || !this.childrenKnown ? '0' : '-1'}
       @click=${() => this.select()}
     >
-      <span part="box"></span>
+      <span part="box" aria-hidden="true"
+        ><slot
+          name="indicator"
+          @slotchange=${(event) => this.toggleState('has-indicator', slotFilled(event.target))}
+        ></slot
+      ></span>
       <slot name="icon"></slot>
       <span part="label"><slot></slot></span>
     </button>`;

package/dist/rating/root/rating-root.d.ts

@@ -18,12 +18,27 @@ declare const HelixHeadlessRating_base: (new (...args: any[]) => import("@fusion
  * With `clearable`, pressing the chosen score again, or Backspace or Delete on
  * the marks, takes the rating back to unrated and sends `helix-clear`.
  *
+ * **Keyboard.** The marks are one tab stop, on the chosen score or the first.
+ *
+ * | Key | What it does |
+ * |---|---|
+ * | Right, Down | Chooses the next score up, and stops at the highest. |
+ * | Left, Up | Chooses the next score down, and stops at the lowest. |
+ * | Home, End | Chooses the lowest or the highest score. |
+ * | Space, Enter | Chooses the focused score, or clears it under `clearable` when it is already chosen. |
+ * | Backspace, Delete | Clears the rating, under `clearable`. |
+ *
+ * Left and Right swap on a right-to-left page. The marks are a `radiogroup`
+ * named by `label`, and each score is a `radio` named by `option-label`, such
+ * as "3 out of 5". A read-only rating is one `img` named by its score.
+ *
  * @since 0.1.0
  * @status stable
  * @category forms
  * @aliases Stars, Score, Review score
  * @documentation https://fusion.dev/helix/components/rating
  *
+ * @slot empty-mark - The shape of an unfilled mark, copied into every position of the track, such as an outlined star beside a filled `mark`. Without it, the track copies `mark`.
  * @slot feedback - The message that says what is wrong, for content richer than a string. It shows while there is a message.
  * @slot hint - Help under the control, for content richer than the `hint` text.
  * @slot label - The label, for content richer than the `label` text.
@@ -32,6 +47,7 @@ declare const HelixHeadlessRating_base: (new (...args: any[]) => import("@fusion
  * @event {Event} change - The score was chosen. Sent together with `input`, because each choice commits the score.
  * @event {HelixBeforeChangeEvent} helix-before-change - The score is about to change. Cancelable: cancel it to keep the current score.
  * @event {HelixClearEvent} helix-clear - The rating went back to unrated, under `clearable`. Sent after `input` and `change`.
+ * @event {HelixPreviewEvent} helix-preview - The score under the pointer, shown before it is chosen, or `''` once the marks show the score again. Sent once each time the preview changes.
  * @event {Event} input - The score changed.
  *
  * @csspart feedback - The message that says what is wrong.
@@ -170,8 +186,8 @@ export declare class HelixHeadlessRating extends HelixHeadlessRating_base {
      * each of its own options. Anything past the first slotted element is
      * ignored.
      */
-    private markSource;
-    /** Whether `markSource` has had its first answer from the children. */
+    private readonly mark;
+    /** Whether `mark` has had its first answer from the children. */
     private markRead;
     /**
      * What the pointer is over, which is shown instead of the score while it is.
@@ -213,16 +229,17 @@ export declare class HelixHeadlessRating extends HelixHeadlessRating_base {
     /** The pointer drawing a score, while one is. */
     private dragging;
     /**
-     * One clone per place a mark goes, kept so a render does not remake them.
+     * The shape for one place, or nothing when the stylesheet is drawing it.
      *
-     * A drag renders on every pointer move, and handing Lit a fresh node each
-     * time would swap every mark in the row on every frame of a gesture whose
-     * whole point is that only the fill moves.
+     * One copy per place, kept so a render does not remake them: a drag renders
+     * on every pointer move, and handing Lit a fresh node each time would swap
+     * every mark in the row on every frame of a gesture whose whole point is
+     * that only the fill moves.
      */
-    private readonly clones;
-    /** The shape for one place, or nothing when the stylesheet is drawing it. */
     private markFor;
     private readonly handleMarkSlot;
+    /** The element slotted into `empty-mark`, which the track copies. */
+    private readonly empty;
     /**
      * The step under a point on the row, or the nearest one to it.
      *
@@ -297,10 +314,11 @@ export declare class HelixHeadlessRating extends HelixHeadlessRating_base {
     /** The name of one score, as `optionLabel` writes it. */
     private nameFor;
     /**
-     * The option holding the tab stop: the chosen one, or for a score between
-     * steps, such as an average of 3.5 on whole marks, the step below it, and
-     * the first while nothing is chosen. Between steps no option matched, and
-     * the rating left the tab order.
+     * The option that is checked and holds the tab stop: the chosen one, or for
+     * a score between steps, such as an average of 3.4 on whole marks, the
+     * nearest step, and the first while nothing is chosen. Between steps no
+     * option matched, so no option was checked and the rating left the tab
+     * order.
      */
     private stopAt;
     protected render(): TemplateResult;

package/dist/rating/root/rating-root.js

@@ -4,7 +4,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-import { AriaForwardController, valueAsNumber as asNumber, customElement, fillTemplate, numberAsValue as fromNumber, HelixClearEvent, HelixFormElement, KeyboardNavigationController, MixinControllerValue, MixinField, reportRuntime, } from '@fusion.dev/helix-core';
+import { AriaForwardController, valueAsNumber as asNumber, customElement, fillTemplate, numberAsValue as fromNumber, HelixClearEvent, HelixFormElement, HelixPreviewEvent, KeyboardNavigationController, MixinControllerValue, MixinField, nearest, reportRuntime, SlottedGlyph, } from '@fusion.dev/helix-core';
 import { html, nothing } from 'lit';
 import { property, state } from 'lit/decorators.js';
 let HelixHeadlessRating = class HelixHeadlessRating extends MixinControllerValue(MixinField(HelixFormElement)) {
@@ -22,7 +22,7 @@ let HelixHeadlessRating = class HelixHeadlessRating extends MixinControllerValue
         this.aria = new AriaForwardController(this, {
             target: () => this.partNamed('marks'),
         });
-        this.markSource = undefined;
+        this.mark = new SlottedGlyph();
         this.markRead = false;
         this.previewing = undefined;
         this.keys = new KeyboardNavigationController(this, {
@@ -31,11 +31,12 @@ let HelixHeadlessRating = class HelixHeadlessRating extends MixinControllerValue
             wrap: false,
         });
         this.dragging = undefined;
-        this.clones = new Map();
         this.handleMarkSlot = (event) => {
-            this.clones.clear();
-            this.markSource = event.target.assignedElements({ flatten: true })[0];
+            const slot = event.target;
+            (slot.name === 'empty-mark' ? this.empty : this.mark).read(slot);
+            this.requestUpdate();
         };
+        this.empty = new SlottedGlyph();
         this.handleDragStart = (event) => {
             if (this.isDisabled || this.readOnly || event.button !== 0) {
                 return;
@@ -158,20 +159,11 @@ let HelixHeadlessRating = class HelixHeadlessRating extends MixinControllerValue
         }));
     }
     markFor(layer, index) {
-        if (!this.markSource) {
-            return undefined;
-        }
-        const key = `${layer}:${index}`;
-        const held = this.clones.get(key);
-        if (held) {
-            return held;
-        }
-        const clone = this.markSource.cloneNode(true);
-        this.clones.set(key, clone);
-        return clone;
+        const glyph = layer === 'track' && this.empty.slotted ? this.empty : this.mark;
+        return glyph.copyFor(`${layer}:${index}`);
     }
     scoreAt(clientX) {
-        let nearest;
+        let closest;
         let best = Number.POSITIVE_INFINITY;
         for (const option of this.renderRoot?.querySelectorAll('[part="option"]') ?? []) {
             const box = option.getBoundingClientRect();
@@ -181,10 +173,10 @@ let HelixHeadlessRating = class HelixHeadlessRating extends MixinControllerValue
             const away = clientX < box.left ? box.left - clientX : clientX - box.right;
             if (away < best) {
                 best = away;
-                nearest = option.dataset.score;
+                closest = option.dataset.score;
             }
         }
-        return nearest;
+        return closest;
     }
     clearsAt(score) {
         return this.clearable && this.value !== '' && Number(score) === Number(this.value);
@@ -208,6 +200,11 @@ let HelixHeadlessRating = class HelixHeadlessRating extends MixinControllerValue
     }
     updated(changed) {
         super.updated?.(changed);
+        if (changed.has('previewing')) {
+            this.dispatchEvent(new HelixPreviewEvent({
+                value: this.previewing === undefined ? '' : String(this.previewing),
+            }));
+        }
         this.sync();
         if (this.floor !== this.min && !this.warned) {
             this.warned = true;
@@ -224,7 +221,8 @@ let HelixHeadlessRating = class HelixHeadlessRating extends MixinControllerValue
         super.willUpdate(changed);
         if (!this.markRead && this.childrenKnown) {
             this.markRead = true;
-            this.markSource = this.knownChildren.find((child) => child.slot === 'mark');
+            this.mark.take(this.knownChildren.find((child) => child.slot === 'mark'));
+            this.empty.take(this.knownChildren.find((child) => child.slot === 'empty-mark'));
         }
     }
     firstUpdated(changed) {
@@ -239,8 +237,7 @@ let HelixHeadlessRating = class HelixHeadlessRating extends MixinControllerValue
         if (!answered) {
             return first;
         }
-        const below = this.steps.filter((score) => score <= this.score);
-        return below.at(-1) ?? first;
+        return nearest(this.steps, this.score) ?? first;
     }
     render() {
         const showing = this.previewing ?? this.score;
@@ -261,7 +258,7 @@ let HelixHeadlessRating = class HelixHeadlessRating extends MixinControllerValue
       aria-describedby=${this.describedBy ?? nothing}
       aria-invalid=${this.invalidity ?? nothing}
       aria-required=${this.required && !this.readOnly ? 'true' : nothing}
-      data-slotted=${this.markSource ? '' : nothing}
+      data-slotted=${this.mark.slotted ? '' : nothing}
       style=${`--rating-full: ${Math.floor(showing)}; --rating-part: ${showing - Math.floor(showing)}; --rating-steps: ${this.positions.length}`}
       @pointercancel=${this.handleDragCancel}
       @keydown=${this.handleClearKey}
@@ -276,9 +273,15 @@ let HelixHeadlessRating = class HelixHeadlessRating extends MixinControllerValue
         hidden
         @slotchange=${this.handleMarkSlot}
       ></slot>
+      <slot
+        name="empty-mark"
+        hidden
+        @slotchange=${this.handleMarkSlot}
+      ></slot>
       <span
         part="track"
         aria-hidden="true"
+        data-slotted=${this.empty.slotted ? '' : nothing}
         >${marksIn('track')}</span
       >
       <span
@@ -295,7 +298,7 @@ let HelixHeadlessRating = class HelixHeadlessRating extends MixinControllerValue
                 part="option"
                 role="radio"
                 type="button"
-                aria-checked=${answered && this.score === score ? 'true' : 'false'}
+                aria-checked=${answered && score === stop ? 'true' : 'false'}
                 aria-label=${this.nameFor(score)}
                 data-score=${String(score)}
                 style=${`--rating-step: ${index + 1}`}
@@ -346,9 +349,6 @@ __decorate([
 __decorate([
     property({ attribute: 'value-text' })
 ], HelixHeadlessRating.prototype, "valueText", void 0);
-__decorate([
-    state()
-], HelixHeadlessRating.prototype, "markSource", void 0);
 __decorate([
     state()
 ], HelixHeadlessRating.prototype, "previewing", void 0);

package/dist/scatter-chart/fit.d.ts

@@ -0,0 +1,15 @@
+/** Pearson's r, or nothing where there are too few points or no spread to have one. */
+export declare const correlation: (pairs: ReadonlyArray<readonly [number, number]>) => number | undefined;
+/** A straight line, as the measure up at any measure across. */
+export interface Fit {
+    /** The measure up where the measure across is zero. */
+    intercept: number;
+    /** How far up the line goes for each step across. */
+    slope: number;
+}
+/**
+ * The straight line nearest the points, by least squares, or nothing where
+ * there are fewer than two points or they share one measure across, which no
+ * line up the page can be fitted to.
+ */
+export declare const leastSquares: (pairs: ReadonlyArray<readonly [number, number]>) => Fit | undefined;

package/dist/scatter-chart/fit.js

@@ -0,0 +1,35 @@
+const mean = (values) => values.reduce((sum, one) => sum + one, 0) / values.length;
+export const correlation = (pairs) => {
+    if (pairs.length < 3) {
+        return undefined;
+    }
+    const across = mean(pairs.map(([x]) => x));
+    const up = mean(pairs.map(([, y]) => y));
+    let both = 0;
+    let xs = 0;
+    let ys = 0;
+    for (const [x, y] of pairs) {
+        both += (x - across) * (y - up);
+        xs += (x - across) ** 2;
+        ys += (y - up) ** 2;
+    }
+    return xs === 0 || ys === 0 ? undefined : both / Math.sqrt(xs * ys);
+};
+export const leastSquares = (pairs) => {
+    if (pairs.length < 2) {
+        return undefined;
+    }
+    const across = mean(pairs.map(([x]) => x));
+    const up = mean(pairs.map(([, y]) => y));
+    let both = 0;
+    let xs = 0;
+    for (const [x, y] of pairs) {
+        both += (x - across) * (y - up);
+        xs += (x - across) ** 2;
+    }
+    if (xs === 0) {
+        return undefined;
+    }
+    const slope = both / xs;
+    return { intercept: up - slope * across, slope };
+};

package/dist/scatter-chart/root/scatter-chart-root.d.ts

@@ -5,6 +5,11 @@ import '../../tooltip/index.js';
 export interface ScatterPoint {
     depth: number;
     row: number;
+    /**
+     * How large the point is drawn under `size-by`, from 0 to 1: the square root
+     * of its share of the largest size, so its area follows the measure.
+     */
+    weight?: number | undefined;
     x: number;
     y: number;
 }
@@ -32,6 +37,14 @@ declare const HelixHeadlessScatterChart_base: typeof HelixElement & (new (...arg
  * Both axes are labeled, because both positions are values. The ticks sit at
  * round numbers, and the range extends to them.
  *
+ * `trend` draws each series' line of best fit, by least squares, across the
+ * plot in the series' color.
+ *
+ * **`size-by` names a third measure, drawn as each point's size**, as a bubble
+ * chart does: `size-by="Population"` takes that column out of the series and
+ * gives each point an area in proportion to its row's number there. The
+ * tooltip and the table still say the number.
+ *
  * The summary gives each series' correlation coefficient and its number of
  * points. The table has every number, and the drawing is hidden from screen
  * readers.
@@ -66,7 +79,7 @@ declare const HelixHeadlessScatterChart_base: typeof HelixElement & (new (...arg
  * @csspart point - One row, as a point.
  * @csspart point-active - A point in the row under the pointer. Set alongside `point`.
  * @csspart summary - The text that says how strongly the measures relate, for people who cannot see the points.
- * @csspart svg - The drawing surface the gridlines sit on.
+ * @csspart svg - The drawing surface the gridlines and the trend lines sit on.
  * @csspart tooltip - The bubble, forwarded from `Tooltip`.
  * @csspart tooltip-anchor - The `Tooltip` element itself.
  * @csspart tooltip-arrow - The bubble's point, forwarded from `Tooltip`.
@@ -83,6 +96,7 @@ declare const HelixHeadlessScatterChart_base: typeof HelixElement & (new (...arg
  * @csspart tooltip-right - The bubble while it is right of the reading. Set alongside `tooltip`.
  * @csspart tooltip-top - The bubble while it is above the reading. Set alongside `tooltip`.
  * @csspart tooltip-value - A column's value inside the tooltip.
+ * @csspart trend - One series' line of best fit, under `trend`. Carries its series color as `--chart-series`.
  * @csspart x-axis - The values along the horizontal axis, under the plot.
  * @csspart x-name - The name of the horizontal measure.
  * @csspart x-tick - One labeled value on the horizontal axis. Each axis has its own tick part, because `::part()` cannot tell which axis a tick is on.
@@ -90,6 +104,7 @@ declare const HelixHeadlessScatterChart_base: typeof HelixElement & (new (...arg
  * @csspart y-name - The name of the vertical measure.
  * @csspart y-tick - One labeled value on the vertical axis.
  *
+ * @cssproperty --chart-point-weight - How large a point is drawn under `size-by`, from 0 to 1, by area. The component writes it, and the stylesheet that sizes the point reads it.
  * @cssproperty --chart-point-x - A point's horizontal position, as a percentage. The component writes it.
  * @cssproperty --chart-point-y - A point's vertical position, as a percentage from the top. The component writes it.
  * @cssproperty --chart-tick - A tick's position along its axis, as a percentage. The component writes it.
@@ -112,6 +127,25 @@ export declare class HelixHeadlessScatterChart extends HelixHeadlessScatterChart
      * The word the summary uses for a row when it counts them.
      */
     pointsLabel: string;
+    /**
+     * The heading of a column whose numbers size the points, such as
+     * `Population`, which makes the chart a bubble chart.
+     *
+     * That column is then a measure and no series: it draws no points of its
+     * own, and each point's area follows its row's number in it. Absent, every
+     * point is one size.
+     */
+    sizeBy: string;
+    /**
+     * Draws each series' line of best fit across the plot, by least squares, in
+     * the series' color: the regression line a reader would otherwise draw by
+     * eye.
+     *
+     * Absent draws none. A series with fewer than two points, or with every
+     * point at one measure across, has no line to draw. The summary already
+     * gives each series' correlation, which says how near the points are to it.
+     */
+    trend: boolean;
     /** The points as last drawn, which the pointer searches. */
     private drawn;
     /** The point a pointer is resting nearest, which the tooltip sits on. */
@@ -134,6 +168,16 @@ export declare class HelixHeadlessScatterChart extends HelixHeadlessScatterChart
      * which is where a reader is told what it is.
      */
     seriesOf(cell: number): number | undefined;
+    /**
+     * The numeric columns by what they measure: the first across, the column
+     * `size-by` names as the size, and every other one up, as a series.
+     */
+    protected get measures(): {
+        across: number | undefined;
+        size: number | undefined;
+        ups: number[];
+    };
+    showsColumn(cell: number): boolean;
     /** Whether the levels across are ruled. */
     protected get rulesX(): boolean;
     /** Whether the levels up are ruled. */
@@ -150,6 +194,12 @@ export declare class HelixHeadlessScatterChart extends HelixHeadlessScatterChart
     protected render(): TemplateResult;
     /** The rules and the points, behind a seam the styled tier can move. */
     protected renderPlot(field: ScatterField, along: (value: number) => number, up: (value: number) => number): TemplateResult;
+    /**
+     * Each shown series' line of best fit, from one end of the measure across
+     * to the other, under `trend`. The drawing clips a line that leaves the
+     * plot.
+     */
+    protected renderTrends(field: ScatterField, along: (value: number) => number, up: (value: number) => number): TemplateResult[] | typeof nothing;
     /**
      * What a reader who cannot see the points is told.
      *