@fusion.dev/helix-headless 0.104.1 → 0.106.0

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

@@ -4,25 +4,23 @@ import { type PropertyValues, type TemplateResult } from 'lit';
 export type InputType = 'email' | 'number' | 'password' | 'search' | 'tel' | 'text' | 'url';
 declare const HelixHeadlessInput_base: (new (...args: any[]) => import("@fusion.dev/helix-core").MixinControllerValueInterface) & (new (...args: any[]) => import("@fusion.dev/helix-core").MixinFieldInterface) & typeof HelixFormElement;
 /**
- * @summary A single line of text a reader types into.
+ * @summary A field for a single line of text.
  *
  * @description
- * Renders a real `<input>`, so the caret, selection, autofill, spellcheck, the
- * password manager and the on-screen keyboard a phone chooses are all the
- * platform's. It serializes into the server's markup, so the field is usable
- * before any script loads.
+ * Renders a real `<input>`, so the caret, selection, autofill, spellcheck,
+ * password managers, and a phone's on-screen keyboard all work natively. The
+ * field is in the server markup, so it works before any script loads.
  *
- * **The input inside a shadow root submits nothing**, the form being on the
- * other side of the boundary. The host is form-associated instead and reports
- * its own value through `ElementInternals`, which also carries validity and
- * answers a form reset.
+ * An input inside a shadow root does not submit with a form outside it, so the
+ * host is form-associated and reports its value through `ElementInternals`.
+ * That also carries validity and handles a form reset.
  *
- * `value` and `defaultValue` are separate the way `checked` and
- * `defaultChecked` are: `value` is what is in the field now, `defaultValue` is
- * what the markup asked for and where a reset returns to.
+ * `value` and `defaultValue` work like `checked` and `defaultChecked`. `value`
+ * is what is in the field now, and `defaultValue` is the value from the markup,
+ * which a reset restores.
  *
- * **Validity is the platform's.** `type` and `required` are set on the real
- * input and its `validity` is copied onto the host.
+ * Validity comes from the browser. `type` and `required` are set on the real
+ * input, and its `validity` is copied to the host.
  *
  * @since 0.1.0
  * @status stable
@@ -33,34 +31,35 @@ declare const HelixHeadlessInput_base: (new (...args: any[]) => import("@fusion.
  * @slot end - After the text, for an icon or a unit.
  * @slot start - Before the text, for an icon or a prefix.
  *
- * @event {Event} change - Relayed from the input once the reader has finished.
- * @event {HelixBeforeChangeEvent} helix-before-change - Fired as the text changes, and cancelable.
- * @event {Event} input - Announced once the value has moved.
+ * @event {Event} change - Sent when the user finishes changing the value. Relayed from the native input.
+ * @event {HelixBeforeChangeEvent} helix-before-change - The text is about to change. Cancelable: cancel it to keep the current text.
+ * @event {Event} input - Fired as the value changes.
  *
  * @csspart clear - The button that empties the field.
- * @csspart control - The input itself.
- * @csspart feedback - What is wrong with it.
- * @csspart field - The box holding everything.
- * @csspart hint - Help under the field, while nothing is wrong.
- * @csspart label - The question, over the field.
+ * @csspart control - The native input.
+ * @csspart feedback - The message that says what is wrong with the value.
+ * @csspart field - The box around the input, its slots, and its buttons.
+ * @csspart hint - Help text under the field, shown while there is no feedback.
+ * @csspart label - The label above the field.
  * @csspart reveal - The button that shows and hides a password.
- * @csspart reveal-pressed - The reveal button while the password shows, beside `reveal`.
+ * @csspart reveal-pressed - The reveal button while the password is shown, added beside `reveal`.
  *
- * @cssstate invalid - While there is feedback to show: the platform's verdict, or the consumer's `feedback`.
+ * @cssstate invalid - The control has an error to show, from the browser's validation or from your `feedback`.
  */
 export declare class HelixHeadlessInput extends HelixHeadlessInput_base {
     protected readonly aria: AriaForwardController;
     /** Typed or dragged, so every edit is announced. See `announcesInput`. */
     protected readonly announcesInput = true;
     /**
-     * What the browser may autofill here, as one of the platform's own tokens.
+     * What the browser may autofill in the field, as an HTML `autocomplete`
+     * token.
      *
      * Empty leaves the attribute off, which is the browser's default. Set it to
      * a token like `email` or `bday` to ask for autofill, or to `off` to refuse.
      */
     autocomplete: string;
     /**
-     * Whether the field offers a button that empties it.
+     * Whether the field shows a button that empties it.
      *
      * Shown only while there is something to clear, because a control that does
      * nothing is worse than no control: a reader who presses it and sees no
@@ -69,7 +68,7 @@ export declare class HelixHeadlessInput extends HelixHeadlessInput_base {
      */
     clearable: boolean;
     /**
-     * What the clear button is called, since an icon has no name of its own.
+     * The accessible name of the clear button, which shows only an icon.
      */
     clearLabel: string;
     /**
@@ -89,13 +88,14 @@ export declare class HelixHeadlessInput extends HelixHeadlessInput_base {
      */
     pattern: string;
     /**
-     * Shown while the field is empty.
+     * The text shown while the field is empty.
      *
      * Not a label: it goes when typing starts.
      */
     placeholder: string;
     /**
-     * Whether the field refuses input while still submitting its value.
+     * Whether the field blocks editing. A read-only field still submits its
+     * value.
      *
      * **The attribute is `readonly`, which is the platform's spelling.** A
      * camelCase property needs an explicit `attribute`, and dash-casing a word
@@ -128,7 +128,7 @@ export declare class HelixHeadlessInput extends HelixHeadlessInput_base {
     /** Focus is delegated to the input, so the host is never the focus target. */
     static shadowRootOptions: ShadowRootInit;
     /**
-     * The caret and the selection, under the platform's own names.
+     * The direction of the selection, as the native input names it.
      *
      * The `<input>` is inside this shadow root, so a consumer had no way to ask
      * where the selection is, let alone move it: `querySelector` does not cross
@@ -149,8 +149,8 @@ export declare class HelixHeadlessInput extends HelixHeadlessInput_base {
     get selectionStart(): number;
     set selectionStart(at: number);
     /**
-     * Selects a range, which is the one operation the three accessors above
-     * cannot express between them.
+     * Selects the range from `start` to `end` in one call, which setting
+     * `selectionStart` and `selectionEnd` one at a time cannot always do.
      *
      * Setting `selectionStart` past the current `selectionEnd` drags the end
      * along, so the two writes a consumer would make in sequence do not compose
@@ -185,7 +185,7 @@ export declare class HelixHeadlessInput extends HelixHeadlessInput_base {
     private readonly handleChange;
     /** Reports the value and the validity the host stands behind. */
     private sync;
-    /** Puts the caret in the field, the way a label pointing at one would. */
+    /** Puts the caret in the field, as clicking its label does. */
     focus(options?: FocusOptions): void;
     /** Selects everything in the field. */
     select(): void;
@@ -208,13 +208,14 @@ export declare class HelixHeadlessInput extends HelixHeadlessInput_base {
      */
     reveal: boolean;
     /**
-     * What the reveal toggle is called.
+     * The accessible name of the reveal toggle.
      *
      * The state is `aria-pressed`, not this.
      */
     revealLabel: string;
     /**
-     * What the field accepts, which decides the keyboard and the validation.
+     * The kind of text the field accepts. It sets the on-screen keyboard and the
+     * validation.
      *
      * **Not reflected.** Reflection exists so a selector can reach a value, and
      * no stylesheet in this repository selects on `type`. Reflecting it writes

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

@@ -4,21 +4,18 @@ import { type PropertyValues, type TemplateResult } from 'lit';
  * @summary A keyboard key or chord, set inline with text.
  *
  * @description
- * Renders a real `<kbd>`, so the passage still means "press this" to anything
- * reading the markup.
+ * Renders a `<kbd>` element.
  *
- * **One key per element, with `keys` as the stated exception.** A sequence is
- * several of these with the separator written between them as ordinary text,
- * because that separator is prose: "then" in a sequence, "plus" in a chord, and
- * a component inserting one would have to guess which.
+ * Each element holds one key, except when you use `keys`. For a sequence or a
+ * chord, write one element per key and put the separator between them as text,
+ * such as "then" or "plus".
  *
- * **`keys` exists because the glyphs were being typed by hand and were wrong.**
- * A literal `⌘K` in a template tells a reader on Windows to press a key their
- * keyboard does not have, and nothing catches it. Given `mod` this renders
- * `⌘K` on Apple and `Ctrl+K` everywhere else.
+ * `keys` renders the right glyphs for the platform. Given `mod`, it renders
+ * `⌘K` on Apple devices and `Ctrl+K` everywhere else. A `⌘K` typed into a
+ * template is wrong for anyone on Windows.
  *
- * **`within` is what binds it, and it is absent by default**, so this draws a
- * key and listens for nothing unless asked.
+ * The element binds the shortcut only when `within` is set. By default it draws
+ * the key and listens for nothing.
  *
  * @since 0.1.0
  * @status stable
@@ -28,13 +25,13 @@ import { type PropertyValues, type TemplateResult } from 'lit';
  *
  * @slot - The key's label, where `keys` is not set.
  *
- * @event {HelixShortcutEvent} helix-shortcut - Fired when the chord is pressed, and cancelable.
+ * @event {HelixShortcutEvent} helix-shortcut - The chord was pressed. Cancelable: cancel it to let the key press keep its usual effect.
  *
  * @csspart kbd - The key.
  */
 export declare class HelixHeadlessKbd extends HelixElement {
     /**
-     * The chord, written plainly: `mod+k`, `shift+?`, `/`.
+     * The key or chord to show, such as `mod+k`, `shift+?`, or `/`.
      *
      * `mod` is the platform's own command modifier, which is the reason to write
      * a chord here rather than a glyph: it is the one token whose right answer
@@ -42,7 +39,8 @@ export declare class HelixHeadlessKbd extends HelixElement {
      */
     keys: string;
     /**
-     * Where the chord is listened for, and whether it is listened for at all.
+     * Where the chord is listened for. `control` listens inside the control the
+     * key sits in, and `document` listens on the whole page.
      *
      * Unset draws a key and binds nothing.
      *

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

@@ -1,20 +1,22 @@
 import { HelixElement, SourceController } from '@fusion.dev/helix-core';
 import { type PropertyValues, type TemplateResult } from 'lit';
 /**
- * @summary The names a chart draws, each beside the color it is drawn in.
+ * @summary A list of the series in a chart, each name beside the color it is drawn in.
  *
  * @description
- * A legend is a list, so it is a list: not part of a chart, and shared by
- * whichever of them needs one. It takes its entries from the same table the
- * chart reads, through `for`, so the two cannot disagree.
+ * Renders a legend as a list, separate from any chart, so any chart can use
+ * one. Set `for` to the table the chart reads, and the legend takes its entries
+ * from that table, so the two always match.
  *
- * `entries` picks which way to read that table. `series` is one entry per data
- * column, named by the header row, which is a line or a bar chart.
- * `categories` is one entry per body row, which is a donut: its slices are the
- * rows and it has no axis to write their names along. `measures` drops the
- * first data column, which is a scatter.
+ * `entries` sets how the table is read:
  *
- * **The table is resolved on the client and there is no server pass.**
+ * - `series`: one entry per data column, named by the header row. Use it for a
+ *   line or bar chart.
+ * - `categories`: one entry per body row. Use it for a donut, whose slices are
+ *   the rows and which has no axis to name them on.
+ * - `measures`: drops the first data column. Use it for a scatter.
+ *
+ * The table is resolved on the client. There is no server pass.
  *
  * @since 0.1.0
  * @status stable
@@ -22,16 +24,16 @@ import { type PropertyValues, type TemplateResult } from 'lit';
  * @aliases Key, Series Key
  * @documentation https://fusion.dev/helix/components/legend
  *
- * @csspart entry - One name and its swatch. The swatch is drawn on the entry,
- * which is `::part(entry)::before` from a consumer's sheet: the series is
- * already on the entry as `--chart-series`, so a box would have carried nothing,
- * and this tier ships no CSS.
- * @csspart list - The list itself.
+ * @csspart entry - One name and its swatch. Draw the swatch with
+ * `::part(entry)::before` in your stylesheet. The entry holds its series color
+ * as `--chart-series`, and this tier ships no CSS.
+ * @csspart list - The list of entries.
  * @csspart name - One series name.
  */
 export declare class HelixHeadlessLegend extends HelixElement {
     /**
-     * Which way to read the table.
+     * How the entries are read from the table: `series`, `categories`, or
+     * `measures`.
      *
      * Absent is `series`, one entry per data column. `categories` reads one entry
      * per body row instead, for a donut, whose slices are the rows.

package/dist/lightbox/item/lightbox-item.d.ts

@@ -1,18 +1,16 @@
 import { HelixElement } from '@fusion.dev/helix-core';
 import { type PropertyValues, type TemplateResult } from 'lit';
 /**
- * @summary One thing a lightbox can show.
+ * @summary One item a lightbox can show, such as a picture, a video frame, or a chart.
  *
  * @description
- * A wrapper around whatever the consumer opened, which is the whole of what it
- * is: a picture, a frame of video, a chart. The family shows one at a time and
- * this is how it says which, so the content stays the consumer's and the
- * arithmetic stays the root's.
+ * Wraps one piece of content in the lightbox, such as a picture, a video frame,
+ * or a chart. The lightbox shows one item at a time, and the root decides
+ * which.
  *
- * Hidden rather than unmounted while another item is current, for the reason
- * `TabPanel` gives: what is in the markup is what a crawler reads and what a
- * server sent, and an `<img>` that has already decoded does not decode again
- * when the reader walks back to it.
+ * An item that is not current is hidden and stays in the DOM, as a `TabPanel`
+ * does. Crawlers can read it, it is in the server-rendered markup, and an
+ * `<img>` that has decoded does not decode again when you go back to it.
  *
  * @since 0.100.0
  * @status stable
@@ -20,26 +18,26 @@ import { type PropertyValues, type TemplateResult } from 'lit';
  * @aliases LightboxSlide, GalleryItem
  * @documentation https://fusion.dev/helix/components/lightbox
  *
- * @slot - What is being shown.
- * @slot description - A line under it saying what it is.
+ * @slot - The content to show.
+ * @slot description - A line under the content that describes it.
  *
  * @csspart item - The box the content is shown in.
  *
- * @cssstate current - While this is the item the lightbox is showing.
+ * @cssstate current - The item the lightbox is showing.
  */
 export declare class HelixHeadlessLightboxItem extends HelixElement {
     /**
-     * Whether this is the one being shown.
+     * Whether this item is the one shown.
      *
      * Written by the root, which is the only thing that sees the set.
      */
     current: boolean;
     /**
-     * What this item is called, for the reading that says where the reader is.
+     * The item's name, used in the status text that says which item is shown.
      */
     label: string;
     /**
-     * What names this item, and what `active` on the root is compared against.
+     * The item's identifier. The root compares its `active` value against it.
      */
     value: string;
     /**

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

@@ -2,33 +2,25 @@ import { CommandController, HelixElement } from '@fusion.dev/helix-core';
 import { type PropertyValues, type TemplateResult } from 'lit';
 declare const HelixHeadlessLightbox_base: (new (...args: any[]) => import("@fusion.dev/helix-core").MixinControllerActiveInterface) & (new (...args: any[]) => import("@fusion.dev/helix-core").MixinControllerOpenInterface) & typeof HelixElement;
 /**
- * @summary A viewer that opens one thing over the page.
+ * @summary A viewer that shows one item at a time over the page.
  *
  * @description
- * **A lightbox is chrome around a picture rather than a picture.** It draws
- * nothing of its own: what it shows is whatever the consumer opened, so this
- * earns its place on the frame, the keyboard and the reading that says where in
- * the set the reader is.
+ * The frame around content you open, such as a picture, a video frame, or a
+ * chart. The lightbox draws no content of its own. It provides the frame, the
+ * keyboard behavior, and text that states the current position in the set.
  *
- * **The modal half is the platform's.** A real `<dialog>` opened with
- * `showModal()` brings the top layer, a backdrop, Escape and `inert` behind it,
- * and this repository has already removed one hand-written focus trap for being
- * worse than that: `inert` on the rest of the document is something no
- * JavaScript trap can achieve. Every way it can close comes back through
- * `requestOpen`, which is what `Dialog` and `Drawer` both do and for the reason
- * they both give.
+ * The modal behavior comes from a native `<dialog>` opened with `showModal()`,
+ * which provides the top layer, a backdrop, Escape to close, and `inert` on the
+ * rest of the document. Every way of closing goes through `requestOpen`, as in
+ * `Dialog` and `Drawer`.
  *
- * **The set is this component's own and not `Carousel`'s.** A carousel is a
- * track: a scroller with snap points, per-view arithmetic and stops it can rest
- * between. A lightbox shows one thing at a time and has no track, so what it
- * needs is which item is current, which is `active` and the same pair `Tabs`
- * uses. The arrow keys move the picture under a reader whose focus stays in the
- * dialog, which is also why `KeyboardNavigationController` is not the right
- * tool: that one moves focus between focusable items, and these are pictures.
+ * A lightbox shows one item at a time and has no scrolling track, so `active`
+ * holds the current item, as in `Tabs`. The arrow keys change the item while
+ * focus stays in the dialog.
  *
- * **Chrome hides while the reader is still**, on `IdleController`, and comes
- * back on a pointer move or a focus. `fullscreen` is `FullscreenController`, the
- * same pair `Video` holds and the only two it shares.
+ * The chrome hides when there is no input, through `IdleController`, and comes
+ * back on a pointer move or a focus. `fullscreen` uses `FullscreenController`,
+ * as `Video` does.
  *
  * @since 0.100.0
  * @status stable
@@ -37,27 +29,28 @@ declare const HelixHeadlessLightbox_base: (new (...args: any[]) => import("@fusi
  * @documentation https://fusion.dev/helix/components/lightbox
  *
  * @slot - The items, which are `<helix-headless-lightbox-item>` elements.
- * @slot footer - Chrome below the item, such as a counter or a thumbnail strip.
- * @slot header - Chrome above the item, such as a title and a close button.
+ * @slot footer - Content below the item, such as a counter or a thumbnail strip.
+ * @slot header - Content above the item, such as a title and a close button.
  *
- * @event {Event} close - Relayed, because the platform's own does not escape.
- * @event {HelixActivateEvent} helix-activate - Fired once the shown item has moved, so the element already holds it.
- * @event {HelixBeforeActivateEvent} helix-before-activate - Fired before the shown item changes, and cancelable. The only way to refuse one.
- * @event {HelixBeforeCloseEvent} helix-before-close - Fired before it closes, and cancelable.
- * @event {HelixBeforeOpenEvent} helix-before-open - Fired before it opens, and cancelable.
- * @event {Event} toggle - Says the state moved, carrying `newState` and `oldState`.
+ * @event {Event} close - Fired when the viewer closes. The component dispatches it again from the host, because the dialog's own event does not leave the shadow root.
+ * @event {HelixActivateEvent} helix-activate - Fired after the shown item changes, when the element already holds the new item.
+ * @event {HelixBeforeActivateEvent} helix-before-activate - Fired before the shown item changes. Cancelable: cancel it to keep the current item. It is the only way to stop the change.
+ * @event {HelixBeforeCloseEvent} helix-before-close - Fired before the viewer closes. Cancelable.
+ * @event {HelixBeforeOpenEvent} helix-before-open - Fired before the viewer opens. Cancelable.
+ * @event {Event} toggle - Fired when the viewer opens or closes, with `newState` and `oldState`.
  *
  * @csspart dialog - The native dialog element.
- * @csspart live - The region that says which item is shown.
+ * @csspart live - The live region that announces which item is shown.
  * @csspart viewport - The box the current item is shown in.
  *
  * @cssstate fullscreen - While the viewer fills the screen.
- * @cssstate idle - While the reader has been still long enough to hide the chrome.
+ * @cssstate idle - The user has been still long enough for the controls to hide.
  * @cssstate open - While the viewer is open.
  */
 export declare class HelixHeadlessLightbox extends HelixHeadlessLightbox_base {
     /**
-     * How long the reader may be still before the chrome hides, in milliseconds.
+     * How long the user can be idle before the header and footer hide, in
+     * milliseconds.
      *
      * Zero keeps it up, which is what a viewer with a caption worth reading
      * wants. The wait is only ever about idling: whether anything else should
@@ -65,16 +58,16 @@ export declare class HelixHeadlessLightbox extends HelixHeadlessLightbox_base {
      */
     idleDelay: number;
     /**
-     * Accessible name for the viewer.
+     * The viewer's name, read by screen readers.
      */
     label: string;
     /**
-     * Whether walking past the end comes back to the beginning.
+     * Whether moving past the last item returns to the first.
      */
     loop: boolean;
     /**
-     * The reading that says where in the set the reader is, with `{index}` and
-     * `{count}` filled in.
+     * The status text that says which item is shown, with `{index}` and `{count}`
+     * filled in.
      *
      * Announced rather than only drawn, because the picture changing under a
      * reader who cannot see it is otherwise silent. A consumer who has their own
@@ -102,13 +95,19 @@ export declare class HelixHeadlessLightbox extends HelixHeadlessLightbox_base {
     private get dialog();
     /** Opens the viewer, which makes the rest of the page inert. */
     show(): void;
-    /** Asks to close, which a consumer may refuse. */
+    /** Closes the viewer, unless a `helix-before-close` listener cancels it. */
     close(): void;
-    /** Shows the next item, or the first where it is past the end and looping. */
+    /**
+     * Shows the next item. After the last item, it shows the first when `loop`
+     * is set.
+     */
     next(): void;
-    /** Shows the previous item, or the last where it is past the start and looping. */
+    /**
+     * Shows the previous item. Before the first item, it shows the last when
+     * `loop` is set.
+     */
     previous(): void;
-    /** Fills the screen with the viewer, or comes back. */
+    /** Makes the viewer fill the screen, or exits fullscreen. */
     toggleFullscreen(): void;
     /**
      * Moves the shown item, through `requestActive` so a consumer can refuse.

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

@@ -3,37 +3,28 @@ import { nothing, type TemplateResult } from 'lit';
 import '../../tooltip/index.js';
 declare const HelixHeadlessLineChart_base: typeof HelixElement & (new (...args: any[]) => import("@fusion.dev/helix-core").MixinChartSourceInterface);
 /**
- * @summary A series over time as a line, read from a table.
+ * @summary A chart that draws series over time as lines, read from a table.
  *
  * @description
- * The chart for a shape rather than for a quantity, which is what decides the
- * one thing a bar chart is not allowed to do.
+ * A line chart shows the shape of each series: where the readings went.
  *
- * **It measures from its own range and not from zero, deliberately.** `BarChart`
- * refuses that switch because a bar's length *is* its value, so a baseline
- * anywhere else makes the lengths proportional to nothing. A line claims no
- * such thing: it says where the readings went, and forcing zero into the range
- * of a series that moves between 980 and 1020 flattens the entire shape into a
- * rule across the top of the box. The two rules are opposite because the two
- * charts answer opposite questions, and `zero` is here for the case where the
- * distance from nothing is the point.
+ * The scale covers the range of the data. Including zero in the range of a
+ * series that moves between 980 and 1020 would flatten the line into a rule
+ * across the top of the box. `BarChart` always starts at zero, because a bar's
+ * length is its value. Set `zero` when the distance from zero is the point.
  *
- * **One scale across every series**, the same as the bar chart, because two
- * series drawn to different scales are two charts sharing a picture.
+ * Every series shares one scale, as in the bar chart.
  *
- * **Not the chart for a total made of parts.** `area` washes each series from
- * the floor on its own, so they overlap; `Area Chart` stacks them, so the top
- * edge is the total and each band is a share. A line chart answers how each
- * series moved, an area chart how the whole is made up.
+ * `area` fills each series down to the floor on its own, so the fills overlap.
+ * For a total made of parts, use `Area Chart`, which stacks the series so the
+ * top edge is the total and each band is a share.
  *
- * **The labels are HTML beside the drawing rather than `<text>` inside it**, for
- * the reason `BarChart` records: an `<svg>` that fills its box scales its type
- * with everything else, the same `font-size` arriving at 10px in a narrow chart
- * and 43px in a wide one, and there is no non-scaling-font to answer it the way
- * `vector-effect` answers strokes.
+ * The labels are HTML beside the drawing, as in `BarChart`. Text inside an
+ * `<svg>` that fills its box scales with the box, so the same `font-size` can
+ * render at 10px in a narrow chart and 43px in a wide one.
  *
- * The table is the accessible representation and this drawing is `aria-hidden`.
- * A reader who wants the numbers gets the numbers, not a described picture.
+ * The table is the accessible representation, and the drawing is `aria-hidden`.
+ * Screen reader users get the numbers.
  *
  * @since 0.1.0
  * @status stable
@@ -42,13 +33,13 @@ declare const HelixHeadlessLineChart_base: typeof HelixElement & (new (...args:
  * @documentation https://fusion.dev/helix/components/line-chart
  *
  * @csspart area - The wash under one line, where `area` is set.
- * @csspart band - The slot the pointer is resting in.
+ * @csspart band - The band around the reading under the pointer.
  * @csspart baseline - The rule at zero, where zero is inside the range.
  * @csspart gridline - One rule across the plot, under `gridlines`.
  * @csspart guide - A rule down the reading a pointer is resting on.
  * @csspart label - One reading's name.
  * @csspart labels - The row of reading names.
- * @csspart line - One series.
+ * @csspart line - The line for one series.
  * @csspart mark - The invisible point the tooltip is anchored to.
  * @csspart plot - The drawing.
  * @csspart svg - The drawing surface the lines and areas sit on.
@@ -74,8 +65,8 @@ declare const HelixHeadlessLineChart_base: typeof HelixElement & (new (...args:
  */
 export declare class HelixHeadlessLineChart extends HelixHeadlessLineChart_base {
     /**
-     * Whether a wash is drawn under each line, each from the floor on its own.
-     * The washes overlap rather than add up: for parts that make a total, use
+     * Draws a wash under each line, down to the floor of the plot. The washes
+     * overlap and do not add up, so for parts that make a total, use
      * `Area Chart`, which stacks them.
      *
      * Absent is lines alone, which is what suits more than one series: washes
@@ -174,7 +165,7 @@ export declare class HelixHeadlessLineChart extends HelixHeadlessLineChart_base
     /** The domain every series is drawn against, which the tooltip also needs. */
     private range;
     /**
-     * Whether zero is forced into the range.
+     * Whether the range always includes zero.
      *
      * Absent measures from the data's own extent, which is what a line is for.
      * Set it where the distance from nothing is the point rather than the shape,