@fusion.dev/helix-core 0.142.1 → 0.143.0

package/dist/mixins/mixin-field/mixin-field.js

@@ -16,6 +16,19 @@ export const MixinField = (Base) => {
             this.controlId = 'control';
             this.labelId = 'label';
             this.namedBy = null;
+            this.filledSlots = new Set();
+            this.noteSlotted = (event) => {
+                const slot = event.target;
+                if (slot.name !== 'label' && slot.name !== 'hint') {
+                    return;
+                }
+                const filled = slot.assignedNodes().length > 0;
+                if (filled !== this.filledSlots.has(slot.name)) {
+                    const next = new Set(this.filledSlots);
+                    next[filled ? 'add' : 'delete'](slot.name);
+                    this.filledSlots = next;
+                }
+            };
             this.feedback = '';
             this.hint = '';
             this.label = '';
@@ -24,7 +37,15 @@ export const MixinField = (Base) => {
             this.shownFeedback = '';
         }
         get labeled() {
-            return this.label !== '' || Boolean(this.getAttribute('aria-label'));
+            return (this.label !== '' ||
+                Boolean(this.getAttribute('aria-label')) ||
+                this.filledSlots.has('label'));
+        }
+        bareSlot(name) {
+            return name === 'label' ? html `<slot name="label"></slot>` : html `<slot name="hint"></slot>`;
+        }
+        get validityFeedback() {
+            return this.validates ? this.feedback : '';
         }
         get validates() {
             return this.constructor.formAssociated === true;
@@ -42,15 +63,15 @@ export const MixinField = (Base) => {
             if (this.resolvedFeedback !== '') {
                 return FEEDBACK_ID;
             }
-            return this.hint === '' ? undefined : HINT_ID;
+            return this.hint === '' && !this.filledSlots.has('hint') ? undefined : HINT_ID;
         }
         get invalidity() {
             return this.resolvedFeedback === '' ? undefined : 'true';
         }
         renderGroupLabel() {
             const hidden = this.label === '' ? this.getAttribute('aria-label') : null;
-            if (this.label === '' && !hidden) {
-                return nothing;
+            if (this.label === '' && !hidden && !this.filledSlots.has('label')) {
+                return this.bareSlot('label');
             }
             return html `<span part="label" id=${this.labelId} ?data-hidden=${hidden !== null}
         ><slot name="label">${this.label || hidden}</slot></span
@@ -58,8 +79,8 @@ export const MixinField = (Base) => {
         }
         renderLabel() {
             const hidden = this.label === '' ? this.getAttribute('aria-label') : null;
-            if (this.label === '' && !hidden) {
-                return nothing;
+            if (this.label === '' && !hidden && !this.filledSlots.has('label')) {
+                return this.bareSlot('label');
             }
             return html `<label
         part="label"
@@ -70,10 +91,15 @@ export const MixinField = (Base) => {
       >`;
         }
         renderHint() {
-            if (this.hint === '' || this.resolvedFeedback !== '') {
+            if (this.resolvedFeedback !== '') {
                 return nothing;
             }
-            return html `<p part="hint" id=${HINT_ID}><slot name="hint">${this.hint}</slot></p>`;
+            if (this.hint === '' && !this.filledSlots.has('hint')) {
+                return this.bareSlot('hint');
+            }
+            return html `<p part="hint" id=${HINT_ID}
+        ><slot name="hint">${this.hint}</slot></p
+      >`;
         }
         renderFeedback() {
             const message = this.resolvedFeedback;
@@ -133,11 +159,15 @@ export const MixinField = (Base) => {
             };
             this.addEventListener('invalid', touch);
             this.addEventListener('change', touch);
+            this.renderRoot.addEventListener('slotchange', this.noteSlotted);
         }
     }
     __decorate([
         property({ attribute: 'aria-label' })
     ], FieldElement.prototype, "namedBy", void 0);
+    __decorate([
+        state()
+    ], FieldElement.prototype, "filledSlots", void 0);
     __decorate([
         property()
     ], FieldElement.prototype, "feedback", void 0);

package/dist/mixins/mixin-picker-editing/mixin-picker-editing.d.ts

@@ -30,6 +30,11 @@ export declare class MixinPickerEditingInterface {
      * returns `false`.
      */
     requestValue(next: string): boolean;
+    /**
+     * Requests the panel open or closed. While `readOnly` is set, it does not
+     * open, and it returns `false`.
+     */
+    requestOpen(next: boolean): boolean;
 }
 /**
  * Grafts the typing half of a picker field: it opens on arrival, holds the
@@ -43,9 +48,9 @@ export declare class MixinPickerEditingInterface {
  * know when the caret is in the field, which is `editing`; and a reader who
  * reaches such a field is choosing, so arriving opens the picker. A color has
  * neither: `#ff0000` is what is typed and what is shown, and a reader who has
- * the hex pastes it and never opens anything. `readOnly` is the third thing
- * Color Input does not have, and a mixin cannot give it one without changing
- * its API.
+ * the hex pastes it and never opens anything. `readOnly` comes along here for
+ * the two that take this mixin; Color Input declares its own, the same
+ * property refusing the same two requests.
  */
 export declare const MixinPickerEditing: <T extends Constructor<EditingBase>>(Base: T) => Constructor<MixinPickerEditingInterface> & T;
 export {};

package/dist/mixins/mixin-picker-editing/mixin-picker-editing.js

@@ -32,6 +32,12 @@ export const MixinPickerEditing = (Base) => {
             }
             return super.requestValue(next);
         }
+        requestOpen(next) {
+            if (next && this.readOnly) {
+                return false;
+            }
+            return super.requestOpen(next);
+        }
     }
     __decorate([
         property({ attribute: 'readonly', reflect: true, type: Boolean })

package/dist/mixins/mixin-picker-field/mixin-picker-field.d.ts

@@ -45,7 +45,22 @@ export declare class MixinPickerFieldInterface {
     protected get display(): string;
     /** Puts the caret in the field, as clicking its label does. */
     focus(options?: FocusOptions): void;
-    /** Escape shuts the panel without moving the value. */
+    /**
+     * The text control's own `change`, which a reader's edit ends with, said
+     * under the host's name.
+     */
+    protected readonly handleCommit: (event: Event) => void;
+    /**
+     * The trigger's press: opens the panel with focus in the picker, or closes
+     * it.
+     */
+    protected readonly handleTriggerClick: () => void;
+    /** Enter in the text submits the form, as it does in a native text field. */
+    protected readonly handleKeypress: (event: KeyboardEvent) => void;
+    /**
+     * Escape shuts the panel without moving the value, Tab out of the text shuts
+     * a panel the reader is passing, and ArrowDown in the text moves into it.
+     */
     protected readonly handleKeydown: (event: KeyboardEvent) => void;
     /** The overlay, placed against the field rather than the trigger. */
     protected readonly panel: PopoverController;
@@ -56,6 +71,14 @@ export declare class MixinPickerFieldInterface {
      * Nothing, unless a family fits what its panel holds to the room it has.
      */
     protected placed(room: number | undefined): void;
+    /**
+     * Takes a value the reader picked in the panel, and says it is settled.
+     *
+     * Returns whether it was taken. A family whose typing announces `input`
+     * alone sends `change` from here for a pick, since a pick is a finished
+     * choice.
+     */
+    protected requestPicked(next: string): boolean;
     /** Puts the field back where the answer differs from what was typed. */
     protected restore(): void;
     /** Puts the caret back in the field without the field reopening the panel. */
@@ -103,9 +126,9 @@ export declare class MixinPickerFieldInterface {
  * applies it.
  *
  * **Opening on focus, `readOnly` and the idle rendering are not here.** They
- * are `MixinPickerEditing`'s, because Color Input has none of the three: a hex
- * is pasted and read at a glance, so its field neither renders nor opens on
- * arrival, and giving it `readOnly` would be a property its API does not have.
+ * are `MixinPickerEditing`'s, because Color Input takes neither of the first
+ * and last: a hex is pasted and read at a glance, so its field neither renders
+ * nor opens on arrival. Color Input declares its own `readOnly`.
  *
  * **Three things the two typed families share stay with them.** `renderTrigger`
  * differs only by its icon and would still be the wrong thing to lift: a part a

package/dist/mixins/mixin-picker-field/mixin-picker-field.js

@@ -29,7 +29,63 @@ export const MixinPickerField = (Base) => {
                     event.stopPropagation();
                     this.requestOpen(false);
                     this.returnFocus();
+                    return;
                 }
+                const fromText = event.composedPath()[0] === this.control;
+                if (event.key === 'Tab' && this.open && fromText) {
+                    this.requestOpen(false);
+                    return;
+                }
+                if (event.key === 'ArrowDown' && fromText && !this.isDisabled) {
+                    event.preventDefault();
+                    if (this.open) {
+                        this.partNamed('picker')?.focus();
+                    }
+                    else {
+                        this.fromTrigger = true;
+                        if (!this.requestOpen(true)) {
+                            this.fromTrigger = false;
+                        }
+                    }
+                }
+            };
+            this.handleSurfaceKeydown = (event) => {
+                const surface = this.partNamed('surface');
+                if (event.key !== 'Escape' ||
+                    !this.open ||
+                    event.defaultPrevented ||
+                    !surface ||
+                    !event.composedPath().includes(surface)) {
+                    return;
+                }
+                event.stopPropagation();
+                event.preventDefault();
+                this.requestOpen(false);
+                this.returnFocus();
+            };
+            this.handleFocusOut = (event) => {
+                const to = event.relatedTarget;
+                if (!this.open || !(to instanceof Node)) {
+                    return;
+                }
+                if (this.contains(to) || this.renderRoot?.contains?.(to)) {
+                    return;
+                }
+                this.requestOpen(false);
+            };
+            this.handleCommit = (event) => {
+                event.stopPropagation();
+                this.announceChange();
+            };
+            this.fromTrigger = false;
+            this.handleKeypress = (event) => {
+                if (event.key === 'Enter' && !event.defaultPrevented) {
+                    this.submitImplicitly();
+                }
+            };
+            this.handleTriggerClick = () => {
+                this.fromTrigger = !this.open;
+                this.toggleOpen();
             };
             this.returning = false;
         }
@@ -78,9 +134,29 @@ export const MixinPickerField = (Base) => {
             }
             this.refreshFeedback();
         }
+        get blocksImplicitSubmission() {
+            return this.control !== null;
+        }
+        requestPicked(next) {
+            const taken = this.requestValue(next);
+            if (taken && this.announcesInput) {
+                this.announceChange();
+            }
+            return taken;
+        }
+        connectedCallback() {
+            super.connectedCallback();
+            this.addEventListener('keydown', this.handleSurfaceKeydown);
+            this.addEventListener('focusout', this.handleFocusOut);
+        }
+        disconnectedCallback() {
+            super.disconnectedCallback();
+            this.removeEventListener('keydown', this.handleSurfaceKeydown);
+            this.removeEventListener('focusout', this.handleFocusOut);
+        }
         returnFocus() {
             this.returning = true;
-            this.control?.focus();
+            this.anchor?.focus();
             this.returning = false;
         }
         focus(options) {
@@ -92,6 +168,12 @@ export const MixinPickerField = (Base) => {
         }
         updated(changed) {
             super.updated(changed);
+            if (changed.has('open')) {
+                if (this.open && this.fromTrigger) {
+                    this.partNamed('picker')?.focus();
+                }
+                this.fromTrigger = false;
+            }
             this.sync();
         }
     }

package/dist/utils/draw-tooltip/draw-tooltip.d.ts

@@ -89,5 +89,8 @@ export interface TooltipAt {
  * **Hidden from assistive technology, on purpose.** The table is the accessible
  * representation and the drawing is `aria-hidden`; a reader on a keyboard gets
  * the table, which they can reach, rather than a tooltip which they cannot.
+ * The mark and the bubble carry `aria-hidden` themselves, so they stay hidden
+ * in a chart whose plot also holds something a reader should hear, such as
+ * the middle of a donut.
  */
 export declare const drawTooltip: (rows: Row[], at: number, tag: StaticValue, where?: TooltipAt, slotOf?: (cell: number) => number | undefined) => TemplateResult | typeof nothing;

package/dist/utils/draw-tooltip/draw-tooltip.js

@@ -3,6 +3,7 @@ import { styleMap } from 'lit/directives/style-map.js';
 import { html } from 'lit/static-html.js';
 import { seriesIndex } from '../../mixins/mixin-chart-source/mixin-chart-source.js';
 export const CHART_PLOT = 'helix-chart-plot';
+const CHART_TOOLTIP = 'helix-chart-tooltip';
 export const drawTooltip = (rows, at, tag, where, slotOf) => {
     const row = rows[at];
     if (!row || rows.length === 0) {
@@ -15,6 +16,8 @@ export const drawTooltip = (rows, at, tag, where, slotOf) => {
         y: '0%',
     };
     return html `<div
+      aria-describedby=${CHART_TOOLTIP}
+      aria-hidden="true"
       id="helix-chart-mark"
       part="mark"
       style=${styleMap(place.fixed
@@ -22,12 +25,14 @@ export const drawTooltip = (rows, at, tag, where, slotOf) => {
         : { insetBlockStart: place.y, insetInlineStart: place.x })}
     ></div>
     <${tag}
+      aria-hidden="true"
       dir=${place.dir ?? nothing}
       exportparts="arrow: tooltip-arrow, arrow-bottom: tooltip-arrow-bottom,
         arrow-left: tooltip-arrow-left, arrow-right: tooltip-arrow-right,
         arrow-top: tooltip-arrow-top, tooltip, tooltip-bottom, tooltip-left, tooltip-right,
         tooltip-top"
       for="helix-chart-mark"
+      id=${CHART_TOOLTIP}
       open
       part="tooltip-anchor"
       placement=${place.placement}

package/dist/utils/read-series/read-series.d.ts

@@ -1,5 +1,10 @@
 /** One point in a series: what it is called, what it is worth, and when. */
 export interface SeriesPoint {
+    /**
+     * The row the reading is in, counting from zero, which is its place among
+     * the rows `readRows` reads and so the category it is drawn at.
+     */
+    at: number;
     /**
      * The row's own label, taken from its header cell.
      */
@@ -50,8 +55,31 @@ export interface Series {
  * the second reads `12abc` as 12: a value that is nearly a number is a mistake
  * worth dropping rather than rounding off, and a dropped point is visible where
  * a silently truncated one is not.
+ *
+ * **A dropped point keeps its place.** Each point carries `at`, the row it was
+ * read from, and a chart draws it at that row's category. Counted by position
+ * in `points`, a blank in March slid April's reading under March's label, and a
+ * blank in the first column took a category off the axis for every series.
+ * `byRow` lays a series out one slot per row with the blanks left empty.
  */
 export declare const readSeries: (table: Element) => Series[];
+/**
+ * A series laid out one slot per row, with nothing in a slot whose cell was
+ * blank or did not parse.
+ *
+ * This is the shape a chart drawing categories wants: slot `i` is the reading at
+ * the `i`th row, which is the label under it and the row the tooltip reads.
+ */
+export declare const byRow: (series: Series | undefined, rows: number) => (SeriesPoint | undefined)[];
+/**
+ * A series cut into its unbroken runs, where a run ends at a row with no
+ * reading.
+ *
+ * A line drawn through a gap claims a value in the gap. Drawn as runs, the
+ * line stops at the last reading before a blank and starts again at the first
+ * one after it.
+ */
+export declare const unbroken: (series: Series) => SeriesPoint[][];
 /** One cell of a row, as a reader sees it and as a chart measures it. */
 export interface RowCell {
     /**

package/dist/utils/read-series/read-series.js

@@ -6,13 +6,13 @@ const isGrid = (element) => element.getAttribute('role') === 'table' ||
     /^helix-(headless-)?table$/i.test(element.tagName);
 const readGrid = (grid) => {
     const columns = [...grid.querySelectorAll(COLUMNS)];
-    const rows = [...grid.querySelectorAll(ROWS)];
+    const rows = gridRows(grid);
     const names = columns.slice(1).map((cell) => cell.textContent?.trim() ?? '');
     const cellsOf = (row) => [...row.querySelectorAll(CELLS)];
     const count = Math.max(0, ...rows.map((row) => cellsOf(row).length - 1));
     return Array.from({ length: count }, (_, column) => ({
         name: names[column] ?? grid.getAttribute('label') ?? '',
-        points: rows.flatMap((row) => {
+        points: rows.flatMap((row, at) => {
             const cells = cellsOf(row);
             const head = cells[0];
             const cell = cells[column + 1];
@@ -26,6 +26,7 @@ const readGrid = (grid) => {
             return Number.isFinite(value) && raw.trim() !== ''
                 ? [
                     {
+                        at,
                         label: head?.textContent?.trim() ?? '',
                         value,
                         ...(tone ? { tone } : {}),
@@ -36,6 +37,7 @@ const readGrid = (grid) => {
         }),
     }));
 };
+const gridRows = (grid) => [...grid.querySelectorAll(ROWS)].filter((row) => row.querySelector(CELLS) !== null);
 const plotted = (series) => series.filter((one) => one.points.length > 0);
 export const readSeries = (table) => {
     if (isGrid(table)) {
@@ -49,7 +51,7 @@ export const readSeries = (table) => {
     const columns = Math.max(0, ...rows.map((row) => row.cells.length - 1));
     return plotted(Array.from({ length: columns }, (_, column) => ({
         name: names[column] ?? element.caption?.textContent?.trim() ?? '',
-        points: rows.flatMap((row) => {
+        points: rows.flatMap((row, at) => {
             const head = row.cells[0];
             const cell = row.cells[column + 1];
             if (!cell) {
@@ -62,6 +64,7 @@ export const readSeries = (table) => {
             return Number.isFinite(value) && raw.trim() !== ''
                 ? [
                     {
+                        at,
                         label: head?.textContent?.trim() ?? '',
                         value,
                         ...(tone ? { tone } : {}),
@@ -72,6 +75,30 @@ export const readSeries = (table) => {
         }),
     })));
 };
+export const byRow = (series, rows) => {
+    const slots = Array.from({ length: rows }, () => undefined);
+    for (const point of series?.points ?? []) {
+        if (point.at >= 0 && point.at < rows) {
+            slots[point.at] = point;
+        }
+    }
+    return slots;
+};
+export const unbroken = (series) => {
+    const runs = [];
+    let previous;
+    for (const point of series.points) {
+        const run = runs.at(-1);
+        if (run && previous && point.at === previous.at + 1) {
+            run.push(point);
+        }
+        else {
+            runs.push([point]);
+        }
+        previous = point;
+    }
+    return runs;
+};
 export const readRows = (table) => {
     const cell = (name, element) => {
         if (!element) {
@@ -100,7 +127,7 @@ export const readRows = (table) => {
         const names = [...table.querySelectorAll(COLUMNS)]
             .slice(1)
             .map((one) => one.textContent?.trim() ?? '');
-        return [...table.querySelectorAll(ROWS)].map((one) => {
+        return gridRows(table).map((one) => {
             const cells = [...one.querySelectorAll(CELLS)];
             return row(cells[0], cells.slice(1), names);
         });

package/dist/utils/report-runtime/report-runtime.d.ts

@@ -26,6 +26,8 @@ export type RuntimeKind =
  | 'max-past-fold'
 /** A rating's `min` is no score between 0 and its `max`. */
  | 'min-out-of-range'
+/** A Stat was given one of Trend's directions, `up`, `down` or `neutral`, which lay nothing out. */
+ | 'misread-direction'
 /** A React handler prop names an event the element never dispatches itself. */
  | 'misplaced-handler'
 /** The three.js driver could not load its layout, so the notes stay where they started. */
@@ -34,6 +36,8 @@ export type RuntimeKind =
  | 'missing-row-key'
 /** A stencil names parts the shape does not have. */
  | 'missing-stencil-parts'
+/** A Skip Link's `href` names no element in its tree, so a press moves focus nowhere. */
+ | 'missing-target'
 /** A tooltip's `for` names no element in its own tree. */
  | 'missing-trigger'
 /** An area chart was handed a negative number, which it draws as none. */
@@ -42,6 +46,8 @@ export type RuntimeKind =
  | 'not-a-graph'
 /** The browser refused picture in picture. */
  | 'picture-in-picture-refused'
+/** A Grid's `min` is no length it can write, so the grid lays out by its column count. */
+ | 'refused-length'
 /** A React handler prop is a removed callback, which never ran from JSX. */
  | 'removed-callback'
 /** A React handler prop uses Solid's `on:`, which React reads as another event's name. */
@@ -56,8 +62,12 @@ export type RuntimeKind =
  | 'two-default-operators'
 /** A React handler prop names an event nothing dispatches. */
  | 'unknown-event'
+/** An Icon's `name` is in no icon set it can read, so it draws nothing. */
+ | 'unknown-icon'
 /** A tooltip's trigger does not name it in `aria-describedby`, so it is not read out. */
  | 'unlinked-trigger'
+/** A Text rendered as a label wraps or names a control, which its shadow root cannot reach. */
+ | 'unreachable-label'
 /** A virtualized list's box has no height of its own, so its window never settles. */
  | 'unsettled-window'
 /** A slotted trigger is a plain element, which cannot be told it opens something. */

package/dist/utils/scroll-lock/scroll-lock.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Stops the page behind a modal surface from scrolling.
+ *
+ * `showModal()` makes the page inert and leaves it scrollable, so a wheel over
+ * the backdrop moves the page under the dialog. `overflow: hidden` on the root
+ * stops that, and `scrollbar-gutter: stable` keeps the space a classic
+ * scrollbar took, so the page does not shift sideways when it goes. What the
+ * root carried before is put back when the last holder lets go.
+ *
+ * Dialog, Drawer and Lightbox hold it, and Toast reads who does.
+ */
+export declare const lockScroll: (holder: Element) => void;
+/** Lets go of the page, and gives it back once nothing else holds it. */
+export declare const unlockScroll: (holder: Element) => void;
+/** The surfaces holding the page still, in the order they took it. */
+export declare const scrollHolders: () => Element[];

package/dist/utils/scroll-lock/scroll-lock.js

@@ -0,0 +1,30 @@
+const SCROLL_LOCK = Symbol.for('fusion.helix.scroll-lock');
+const record = () => globalThis[SCROLL_LOCK];
+export const lockScroll = (holder) => {
+    const globals = globalThis;
+    const root = document.documentElement;
+    globals[SCROLL_LOCK] ??= { gutter: '', holders: new Set(), overflow: '' };
+    const lock = globals[SCROLL_LOCK];
+    if (lock.holders.has(holder)) {
+        return;
+    }
+    if (lock.holders.size === 0) {
+        lock.overflow = root.style.overflow;
+        lock.gutter = root.style.scrollbarGutter;
+        if (window.innerWidth > root.clientWidth) {
+            root.style.scrollbarGutter = 'stable';
+        }
+        root.style.overflow = 'hidden';
+    }
+    lock.holders.add(holder);
+};
+export const unlockScroll = (holder) => {
+    const lock = record();
+    if (!lock?.holders.delete(holder) || lock.holders.size > 0) {
+        return;
+    }
+    const root = document.documentElement;
+    root.style.overflow = lock.overflow;
+    root.style.scrollbarGutter = lock.gutter;
+};
+export const scrollHolders = () => [...(record()?.holders ?? [])];

package/dist/utils/written-list/written-list.d.ts

@@ -1,3 +1,12 @@
+/**
+ * What a list property may hold: what an attribute writes, or an array a
+ * framework assigned to the property.
+ *
+ * **An array as well, because React 19 sets the property.**
+ * `values={[1240, 1318]}` arrives as an array, and splitting it as a string
+ * threw inside the render and left the old drawing on the screen.
+ */
+export type WrittenList = string | readonly (number | string)[] | null | undefined;
 /**
  * A list a consumer wrote into an attribute, split the way they write one.
  *
@@ -20,7 +29,7 @@
  * `for` take whitespace and only whitespace, and accepting a comma there would
  * resolve an id nobody can write.
  */
-export declare const writtenList: (source: string | undefined) => string[];
+export declare const writtenList: (source: WrittenList) => string[];
 /**
  * The same list read as numbers, with everything that is not one dropped.
  *
@@ -33,4 +42,4 @@ export declare const writtenList: (source: string | undefined) => string[];
  * answer, because a number that makes sense here is a bound, a reading and a
  * playback rate, and only the caller knows that a rate of zero is not a rate.
  */
-export declare const writtenNumbers: (source: string | undefined) => number[];
+export declare const writtenNumbers: (source: WrittenList) => number[];

package/dist/utils/written-list/written-list.js

@@ -1,4 +1,6 @@
-export const writtenList = (source) => (source ?? '').split(/[\s,]+/).filter((one) => one !== '');
+export const writtenList = (source) => (Array.isArray(source) ? source.join(' ') : String(source ?? ''))
+    .split(/[\s,]+/)
+    .filter((one) => one !== '');
 export const writtenNumbers = (source) => writtenList(source)
     .map(Number)
     .filter((one) => Number.isFinite(one));

package/dist/version.d.ts

@@ -6,4 +6,4 @@
  * release, so the two never disagree; a spec beside this holds them to it.
  * Nothing else in the running code knows which release it is.
  */
-export declare const VERSION = "0.142.1";
+export declare const VERSION = "0.143.0";

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = '0.142.1';
+export const VERSION = '0.143.0';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@fusion.dev/helix-core",
   "description": "Helix element primitives: base classes, mixins, decorators, utilities.",
-  "version": "0.142.1",
+  "version": "0.143.0",
   "license": "MIT",
   "author": "Ross Sheppard <ross.sheppard@fusion.dev>",
   "repository": {
@@ -34,11 +34,11 @@
   "bugs": "https://github.com/project-fusion/fusion/issues",
   "dependencies": {
     "@floating-ui/dom": "^1.8.0",
-    "@fusion.dev/helix-icons": "0.142.1"
+    "@fusion.dev/helix-icons": "0.143.0"
   },
   "devDependencies": {
-    "@fusion.dev/helix-cem": "0.142.1",
-    "@fusion.dev/helix-testing": "0.142.1",
+    "@fusion.dev/helix-cem": "0.143.0",
+    "@fusion.dev/helix-testing": "0.143.0",
     "@lit-labs/ssr": "^4.1.0",
     "lit": "^3.2.1"
   },