@fusion.dev/helix-core 0.144.0 → 0.146.0

package/dist/events/select.d.ts

@@ -0,0 +1,12 @@
+import type { SelectDetail } from './details.js';
+/**
+ * Fired when the reader selects an item in a set.
+ *
+ * Bubbles and is composed, because this is how a set coordinates: a tree, a
+ * tab list and a toggle group all learn which of their children was chosen by
+ * hearing it arrive.
+ */
+export declare class HelixSelectEvent extends CustomEvent<SelectDetail> {
+    static readonly eventName = "helix-select";
+    constructor(detail: SelectDetail);
+}

package/dist/events/select.js

@@ -0,0 +1,11 @@
+export class HelixSelectEvent extends CustomEvent {
+    static { this.eventName = 'helix-select'; }
+    constructor(detail) {
+        super(HelixSelectEvent.eventName, {
+            bubbles: true,
+            cancelable: true,
+            composed: true,
+            detail,
+        });
+    }
+}

package/dist/events/selected.d.ts

@@ -0,0 +1,12 @@
+import type { SelectDetail } from './details.js';
+/**
+ * A set holds a different selection.
+ *
+ * The notification after a `helix-select` that asked to change what is
+ * selected, sent once the selection has moved, with the selection now in
+ * force. Not cancelable, and past tense for the reason `helix-sorted` is.
+ */
+export declare class HelixSelectedEvent extends CustomEvent<SelectDetail> {
+    static readonly eventName = "helix-selected";
+    constructor(detail: SelectDetail);
+}

package/dist/events/selected.js

@@ -0,0 +1,11 @@
+export class HelixSelectedEvent extends CustomEvent {
+    static { this.eventName = 'helix-selected'; }
+    constructor(detail) {
+        super(HelixSelectedEvent.eventName, {
+            bubbles: true,
+            cancelable: false,
+            composed: true,
+            detail,
+        });
+    }
+}

package/dist/events/send.d.ts

@@ -0,0 +1,18 @@
+import type { SendDetail } from './details.js';
+/**
+ * Fired when the reader offers something they wrote.
+ *
+ * **Cancelable, and the composer clears only when nobody refused.** Sending is a
+ * round trip: a composer that empties itself and then hears the request failed
+ * has thrown away the only copy of what the reader typed, and a reader who has
+ * just written three paragraphs is exactly who cannot afford that. Refusing
+ * leaves the text where it is.
+ *
+ * Not `helix-create`, which is the combobox's event for a value a list does not
+ * hold, and not `helix-change`, because nothing about a value changed: the
+ * reader finished something and handed it over.
+ */
+export declare class HelixSendEvent extends CustomEvent<SendDetail> {
+    static readonly eventName = "helix-send";
+    constructor(detail: SendDetail);
+}

package/dist/events/send.js

@@ -0,0 +1,11 @@
+export class HelixSendEvent extends CustomEvent {
+    static { this.eventName = 'helix-send'; }
+    constructor(detail) {
+        super(HelixSendEvent.eventName, {
+            bubbles: true,
+            cancelable: true,
+            composed: true,
+            detail,
+        });
+    }
+}

package/dist/events/shortcut.d.ts

@@ -0,0 +1,13 @@
+import type { ShortcutDetail } from './details.js';
+/**
+ * Fired when a shortcut's chord is pressed.
+ *
+ * Cancelable, and the key event is only consumed where this is not refused: a
+ * consumer that decides the moment is wrong, a dialog is over the control or
+ * the reader is mid-composition, calls `preventDefault()` and the keystroke
+ * goes on to whatever would have had it.
+ */
+export declare class HelixShortcutEvent extends CustomEvent<ShortcutDetail> {
+    static readonly eventName = "helix-shortcut";
+    constructor(detail: ShortcutDetail);
+}

package/dist/events/shortcut.js

@@ -0,0 +1,11 @@
+export class HelixShortcutEvent extends CustomEvent {
+    static { this.eventName = 'helix-shortcut'; }
+    constructor(detail) {
+        super(HelixShortcutEvent.eventName, {
+            bubbles: true,
+            cancelable: true,
+            composed: true,
+            detail,
+        });
+    }
+}

package/dist/events/sort.d.ts

@@ -0,0 +1,17 @@
+import type { SortDetail } from './details.js';
+/**
+ * Fired when the reader asks for a different order.
+ *
+ * Cancelable, and refusing it leaves the order alone, which is what makes a
+ * server-side sort expressible: the consumer refuses the local reorder, fetches,
+ * and hands back a new set. This is the element reporting that a heading was
+ * clicked, before it acts on it.
+ *
+ * Not `helix-change`: nothing about the data changed, only the order it is read
+ * in, and a consumer listening for changes to a value should not hear a sort.
+ * That is the same distinction `helix-filter` is drawn on.
+ */
+export declare class HelixSortEvent extends CustomEvent<SortDetail> {
+    static readonly eventName = "helix-sort";
+    constructor(detail: SortDetail);
+}

package/dist/events/sort.js

@@ -0,0 +1,11 @@
+export class HelixSortEvent extends CustomEvent {
+    static { this.eventName = 'helix-sort'; }
+    constructor(detail) {
+        super(HelixSortEvent.eventName, {
+            bubbles: true,
+            cancelable: true,
+            composed: true,
+            detail,
+        });
+    }
+}

package/dist/events/sorted.d.ts

@@ -0,0 +1,15 @@
+import type { SortDetail } from './details.js';
+/**
+ * The rows are in a different order.
+ *
+ * The notification after `helix-sort`, sent once `sort` has moved, with the
+ * order now in force. Not cancelable: the decision was the request's.
+ *
+ * **Past tense, because the plain verb is the request.** `helix-sort` was
+ * cancelable before the library had a word for its notification, and
+ * consumers bind it by that name, so the notification takes the one after it.
+ */
+export declare class HelixSortedEvent extends CustomEvent<SortDetail> {
+    static readonly eventName = "helix-sorted";
+    constructor(detail: SortDetail);
+}

package/dist/events/sorted.js

@@ -0,0 +1,11 @@
+export class HelixSortedEvent extends CustomEvent {
+    static { this.eventName = 'helix-sorted'; }
+    constructor(detail) {
+        super(HelixSortedEvent.eventName, {
+            bubbles: true,
+            cancelable: false,
+            composed: true,
+            detail,
+        });
+    }
+}

package/dist/events/split.d.ts

@@ -0,0 +1,12 @@
+import type { ChangeDetail } from './details.js';
+/**
+ * The divider between a sandbox's panes settled somewhere new.
+ *
+ * The notification half of `helix-before-split`, sent once `split` has moved,
+ * with the lead pane's new share. Not cancelable: the decision was the
+ * request's.
+ */
+export declare class HelixSplitEvent extends CustomEvent<ChangeDetail> {
+    static readonly eventName = "helix-split";
+    constructor(detail: ChangeDetail);
+}

package/dist/events/split.js

@@ -0,0 +1,11 @@
+export class HelixSplitEvent extends CustomEvent {
+    static { this.eventName = 'helix-split'; }
+    constructor(detail) {
+        super(HelixSplitEvent.eventName, {
+            bubbles: true,
+            cancelable: false,
+            composed: true,
+            detail,
+        });
+    }
+}

package/dist/events/toggle.d.ts

@@ -0,0 +1,15 @@
+import type { ToggleDetail } from './details.js';
+/**
+ * A checked state changed after `helix-before-toggle` let it: a map layer
+ * shown or hidden from the layers menu. Sent from what changed, with the state
+ * it now holds.
+ *
+ * **Not the native `toggle`.** That one is a `ToggleEvent` saying a popover or
+ * a `<details>` opened or closed, with `newState` of `open` or `closed`, and a
+ * layer shown on a map is neither: it is the request's own verb without
+ * `before`, carrying the same `checked` the request did.
+ */
+export declare class HelixToggleEvent extends CustomEvent<ToggleDetail> {
+    static readonly eventName = "helix-toggle";
+    constructor(detail: ToggleDetail);
+}

package/dist/events/toggle.js

@@ -0,0 +1,11 @@
+export class HelixToggleEvent extends CustomEvent {
+    static { this.eventName = 'helix-toggle'; }
+    constructor(detail) {
+        super(HelixToggleEvent.eventName, {
+            bubbles: true,
+            cancelable: false,
+            composed: true,
+            detail,
+        });
+    }
+}

package/dist/events/tour-ask.d.ts

@@ -0,0 +1,16 @@
+import type { TourAskDetail } from './details.js';
+/**
+ * A stop asking the tour to move.
+ *
+ * Composed and bubbling, because a stop is slotted into the root and the root
+ * has to hear it across that boundary.
+ *
+ * **A class rather than a hand-rolled `CustomEvent`.** A dispatch is matched as
+ * `new HelixSomethingEvent(`, so a raw `CustomEvent` is not held to being
+ * declared and nothing carries it into the manifest: consumers can hear it and
+ * cannot find it.
+ */
+export declare class HelixTourAskEvent extends CustomEvent<TourAskDetail> {
+    static readonly eventName = "helix-tour-ask";
+    constructor(detail: TourAskDetail);
+}

package/dist/events/tour-ask.js

@@ -0,0 +1,11 @@
+export class HelixTourAskEvent extends CustomEvent {
+    static { this.eventName = 'helix-tour-ask'; }
+    constructor(detail) {
+        super(HelixTourAskEvent.eventName, {
+            bubbles: true,
+            cancelable: false,
+            composed: true,
+            detail,
+        });
+    }
+}

package/dist/events/tour-status.d.ts

@@ -0,0 +1,14 @@
+import type { TourStatusDetail } from './details.js';
+/**
+ * A tour's progress changed in a way no stop says: it is waiting at a stop
+ * for its target, or it was skipped, or it was completed. Zag's
+ * `onStatusChange`.
+ *
+ * `index` is the stop it happened at. Not cancelable: `helix-before-close`
+ * is the refusable half of ending a tour, and this reports what happened.
+ * Bubbles and is composed.
+ */
+export declare class HelixTourStatusEvent extends CustomEvent<TourStatusDetail> {
+    static readonly eventName = "helix-tour-status";
+    constructor(detail: TourStatusDetail);
+}

package/dist/events/tour-status.js

@@ -0,0 +1,11 @@
+export class HelixTourStatusEvent extends CustomEvent {
+    static { this.eventName = 'helix-tour-status'; }
+    constructor(detail) {
+        super(HelixTourStatusEvent.eventName, {
+            bubbles: true,
+            cancelable: false,
+            composed: true,
+            detail,
+        });
+    }
+}

package/dist/events/typing.d.ts

@@ -0,0 +1,10 @@
+import type { TypingDetail } from './details.js';
+/**
+ * The user started or stopped writing: a chat composer, for a typing
+ * indicator on the other side. Carries which, as the composer's `typing` does.
+ * Not cancelable: it reports what the user did.
+ */
+export declare class HelixTypingEvent extends CustomEvent<TypingDetail> {
+    static readonly eventName = "helix-typing";
+    constructor(detail: TypingDetail);
+}

package/dist/events/typing.js

@@ -0,0 +1,11 @@
+export class HelixTypingEvent extends CustomEvent {
+    static { this.eventName = 'helix-typing'; }
+    constructor(detail) {
+        super(HelixTypingEvent.eventName, {
+            bubbles: true,
+            cancelable: false,
+            composed: true,
+            detail,
+        });
+    }
+}

package/dist/helix-element/helix-element.js

@@ -20,6 +20,11 @@ const SCROLLER = css `
     overflow: auto;
   }
 `;
+const VIRTUAL = css `
+  [data-virtual] {
+    overflow-anchor: none;
+  }
+`;
 const MIRROR = css `
   :host(:dir(rtl)) [data-mirror] {
     scale: -1 1;
@@ -112,7 +117,15 @@ export class HelixElement extends LitElement {
         }));
     }
     static finalizeStyles(styles) {
-        return [BOX_SIZING, HIDDEN, SCROLLER, MIRROR, SETTLED, ...LitElement.finalizeStyles(styles)];
+        return [
+            BOX_SIZING,
+            HIDDEN,
+            SCROLLER,
+            VIRTUAL,
+            MIRROR,
+            SETTLED,
+            ...LitElement.finalizeStyles(styles),
+        ];
     }
     performUpdate() {
         if (this.hasUpdated || !measuring()) {

package/dist/helix-element/react-bridge.d.ts

@@ -52,12 +52,27 @@ export declare const auditReactProps: (host: EventTarget, props: Record<string,
  * declared public API and all of them otherwise silent in React.
  *
  * The name is React's own casing, `onError` rather than `onerror`, because that
- * is what a consumer writes and therefore what is in the props bag. Every
- * native we relay is a single word, so capitalising the first letter is the
- * whole of the rule; a two-word name like `loadeddata` would be `onLoadedData`
- * and needs the list extending rather than the rule generalising.
+ * is what a consumer writes and therefore what is in the props bag. See
+ * `reactNativeProp`.
  */
 export declare const reactPropFor: (event: Event) => string | undefined;
+/**
+ * The prop React reads for a native event: `onError` for `error`, and
+ * `onTimeUpdate` for `timeupdate`.
+ *
+ * The JSX typings name the same props, so a consumer writes what this binds.
+ */
+export declare const reactNativeProp: (type: string) => string;
+/**
+ * Binds the handler React is holding for an event the host is about to send,
+ * where React never bound it: under the event's React prop and its lowercase
+ * spelling.
+ *
+ * Called by the host as it dispatches, which is the first moment it knows the
+ * event's name. A host React does not render holds no props, and nothing is
+ * bound. The props are audited on the way, so a handler attached to nothing
+ * warns.
+ */
 export declare const bindReactHandler: (host: EventTarget, event: Event) => void;
 /**
  * Assigns the object and function properties React is holding and never applied.

package/dist/helix-element/react-bridge.js

@@ -1,5 +1,5 @@
 import { eventsForTag } from '../events/element-events.js';
-import { helixEventNames } from '../events/events.js';
+import { helixEventNames } from '../events/names.js';
 import { reportRuntime } from '../utils/report-runtime/report-runtime.js';
 const REACT_PROPS = '__reactProps$';
 let reactPropsKey;
@@ -76,8 +76,21 @@ export const reactPropFor = (event) => {
     if (event.bubbles || REACT_WIRES.has(event.type)) {
         return undefined;
     }
-    return `on${event.type.charAt(0).toUpperCase()}${event.type.slice(1)}`;
+    return reactNativeProp(event.type);
 };
+const REACT_CASING = {
+    canplay: 'onCanPlay',
+    canplaythrough: 'onCanPlayThrough',
+    durationchange: 'onDurationChange',
+    loadeddata: 'onLoadedData',
+    loadedmetadata: 'onLoadedMetadata',
+    loadstart: 'onLoadStart',
+    ratechange: 'onRateChange',
+    scrollend: 'onScrollEnd',
+    timeupdate: 'onTimeUpdate',
+    volumechange: 'onVolumeChange',
+};
+export const reactNativeProp = (type) => REACT_CASING[type] ?? `on${type.charAt(0).toUpperCase()}${type.slice(1)}`;
 const lowercasePropFor = (event) => event.type.includes('-') || REACT_WIRES.has(event.type) ? undefined : `on${event.type}`;
 export const bindReactHandler = (host, event) => {
     const props = reactPropsOf(host);

package/dist/helix-form-element/helix-form-element.d.ts

@@ -257,36 +257,21 @@ export declare class HelixFormElement extends HelixElement {
      * was the best there was.
      */
     private readonly refreshAnchor;
+    /** Stops listening for the labels in this control's tree. */
+    private unwatchLabels;
     connectedCallback(): void;
     disconnectedCallback(): void;
     /**
      * @internal Whether this control is a field that counts against implicit
-     * submission: a single line of text, as `<input type="text">` is.
+     * submission: a single line of text, as `<input type="text">` is. Read by
+     * `submitImplicitly` in `utils/implicit-submit`, which only the controls
+     * that submit on Enter import.
      */
     protected get blocksImplicitSubmission(): boolean;
     /** @internal Whether this control submits its form, for finding the form's default button. */
     protected get submitsForm(): boolean;
     /** @internal Activates the control as its form's default button. */
     protected activate(): void;
-    /**
-     * Submits the form the way pressing Enter in a native text field does.
-     *
-     * The control's own input is in a shadow root and has no form owner, so the
-     * platform never runs implicit submission for it. This runs it: the form's
-     * default button is activated, the first submit button in it, a Helix one
-     * included. With none, the form is submitted when it holds no more than one
-     * field that counts against implicit submission, and nothing happens
-     * otherwise.
-     *
-     * @reference https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#implicit-submission implicit submission
-     */
-    protected submitImplicitly(): void;
-    /** The form's default button, the first submit button in it, native or Helix. */
-    protected static defaultButton(form: HTMLFormElement): Element | undefined;
-    /** Whether `target` is a native field of `form` that Enter submits it from. */
-    protected static submitsOnEnter(target: EventTarget | undefined, form: HTMLFormElement): boolean;
-    /** Whether `element` is a submit button, native or Helix. */
-    protected static submits(element: Element): boolean;
     /**
      * The form the control belongs to, or `null`.
      *

package/dist/helix-form-element/helix-form-element.js

@@ -6,6 +6,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 import { property, state } from 'lit/decorators.js';
 import { HelixElement } from '../helix-element/helix-element.js';
+import { watchLabels } from '../utils/watch-labels/watch-labels.js';
 const VALIDITY_FLAGS = [
     'badInput',
     'customError',
@@ -18,20 +19,6 @@ const VALIDITY_FLAGS = [
     'typeMismatch',
     'valueMissing',
 ];
-const BLOCKING_TYPES = new Set([
-    'date',
-    'datetime-local',
-    'email',
-    'month',
-    'number',
-    'password',
-    'search',
-    'tel',
-    'text',
-    'time',
-    'url',
-    'week',
-]);
 const takesFocus = (element) => (element.tabIndex >= 0 || element.hasAttribute('tabindex')) &&
     !element.disabled &&
     (typeof element.checkVisibility !== 'function' || element.checkVisibility());
@@ -184,11 +171,14 @@ export class HelixFormElement extends HelixElement {
         super.connectedCallback();
         this.addEventListener('click', this.focusFromLabel);
         this.addEventListener('invalid', this.refreshAnchor);
+        this.unwatchLabels = watchLabels(this, () => this.requestUpdate());
     }
     disconnectedCallback() {
         super.disconnectedCallback();
         this.removeEventListener('click', this.focusFromLabel);
         this.removeEventListener('invalid', this.refreshAnchor);
+        this.unwatchLabels?.();
+        this.unwatchLabels = undefined;
     }
     get blocksImplicitSubmission() {
         return false;
@@ -199,48 +189,6 @@ export class HelixFormElement extends HelixElement {
     activate() {
         this.click();
     }
-    submitImplicitly() {
-        const { form } = this;
-        if (!form) {
-            return;
-        }
-        const elements = [...form.elements];
-        const button = HelixFormElement.defaultButton(form);
-        if (button) {
-            if (button.matches(':disabled')) {
-                return;
-            }
-            if (button instanceof HelixFormElement) {
-                button.activate();
-            }
-            else {
-                ;
-                button.click();
-            }
-            return;
-        }
-        const blocking = elements.filter((element) => element instanceof HelixFormElement
-            ? element.blocksImplicitSubmission
-            : element instanceof HTMLInputElement && BLOCKING_TYPES.has(element.type));
-        if (blocking.length <= 1) {
-            form.requestSubmit();
-        }
-    }
-    static defaultButton(form) {
-        return [...form.elements].find((element) => HelixFormElement.submits(element));
-    }
-    static submitsOnEnter(target, form) {
-        return (target instanceof HTMLInputElement && target.form === form && BLOCKING_TYPES.has(target.type));
-    }
-    static submits(element) {
-        if (element instanceof HelixFormElement) {
-            return element.submitsForm;
-        }
-        if (element instanceof HTMLButtonElement) {
-            return element.type === 'submit';
-        }
-        return (element instanceof HTMLInputElement && (element.type === 'submit' || element.type === 'image'));
-    }
     get form() {
         return this.internals.form;
     }

package/dist/index.d.ts

@@ -1,8 +1,10 @@
+export { auditName } from '#audit-name';
 export { AriaForwardController, type AriaForwardOptions, } from './controllers/aria-forward-controller/aria-forward-controller.js';
 export { ArrivalController, type ArrivalOptions, } from './controllers/arrival-controller/arrival-controller.js';
 export { ChartPointerController, type ChartPointerHost, } from './controllers/chart-pointer-controller/chart-pointer-controller.js';
 export { CommandController, type CommandOptions, HelixFallbackCommandEvent, supportsInvokers, } from './controllers/command-controller/command-controller.js';
 export { CopyController, type CopyOptions, } from './controllers/copy-controller/copy-controller.js';
+export { CountdownController, type CountdownOptions, } from './controllers/countdown-controller/countdown-controller.js';
 export { activeCue, adoptTrack, type Caption, CueController, captionsAmong, captionTracks, showCaption, } from './controllers/cue-controller/cue-controller.js';
 export { DelayController, type DelayOptions, } from './controllers/delay-controller/delay-controller.js';
 export { DisabledCascadeController, type DisabledCascadeOptions, } from './controllers/disabled-cascade-controller/disabled-cascade-controller.js';
@@ -14,12 +16,13 @@ export { FullscreenController } from './controllers/fullscreen-controller/fullsc
 export { HostClickController } from './controllers/host-click-controller/host-click-controller.js';
 export { IdleController } from './controllers/idle-controller/idle-controller.js';
 export { IndicatorController, type IndicatorOptions, } from './controllers/indicator-controller/indicator-controller.js';
-export { KeyboardNavigationController, type KeyboardNavigationOptions, type NavigableItem, Typeahead, typesCharacter, } from './controllers/keyboard-navigation-controller/keyboard-navigation-controller.js';
+export { KeyboardNavigationController, type KeyboardNavigationOptions, type KeyboardOrigin, type NavigableItem, } from './controllers/keyboard-navigation-controller/keyboard-navigation-controller.js';
 export { MediaSessionController, type SessionHandlers, SKIP_SECONDS, } from './controllers/media-session-controller/media-session-controller.js';
 export { animationsSettled, type OpenPhase, OpenPhaseController, type OpenPhaseOptions, } from './controllers/open-phase-controller/open-phase-controller.js';
 export { MAX_FRAME_STEP, PaintGateController, type PaintGateOptions, } from './controllers/paint-gate-controller/paint-gate-controller.js';
 export { PlacementController } from './controllers/placement-controller/placement-controller.js';
 export { PopoverController, type PopoverOptions, } from './controllers/popover-controller/popover-controller.js';
+export { RelativeClockController, type RelativeClockOptions, } from './controllers/relative-clock-controller/relative-clock-controller.js';
 export { RemotePlaybackController, type RemoteReport, } from './controllers/remote-playback-controller/remote-playback-controller.js';
 export { SourceController, type SourceHost, } from './controllers/source-controller/source-controller.js';
 export { drawStatus, type SayOptions, StatusController, } from './controllers/status-controller/status-controller.js';
@@ -27,7 +30,7 @@ export { SwipeController, type SwipeOptions, } from './controllers/swipe-control
 export { type TokenColor, TokenColorController, } from './controllers/token-color-controller/token-color-controller.js';
 export { type Rendered, VirtualizeController, type VirtualizeOptions, type Window as VirtualizeWindow, } from './controllers/virtualize-controller/virtualize-controller.js';
 export { eventsForTag, registerElementEvents } from './events/element-events.js';
-export { type CanvasView, type CaretDetail, type ChangeDetail, type CompleteDetail, type ConnectDetail, type ConsoleDetail, type CopyDetail, type CreateDetail, type DismissDetail, type FacetDetail, type FilterDetail, type GraphFilterDetail, type GraphLayoutDetail, type GraphPartChangeDetail, type GraphSignalDetail, HelixActivateEvent, HelixBeforeActivateEvent, HelixBeforeChangeEvent, HelixBeforeCloseEvent, HelixBeforeCollapseEvent, HelixBeforeEditEvent, HelixBeforeMoveEvent, HelixBeforeOpenEvent, HelixBeforePanelResizeEvent, HelixBeforePinEvent, HelixBeforeReconnectEvent, HelixBeforeRelabelEvent, HelixBeforeResizeEvent, HelixBeforeSplitEvent, HelixBeforeToggleEvent, HelixCanvasEditEvent, HelixCanvasPanEvent, HelixCanvasViewEvent, HelixCanvasZoomEvent, HelixCaretEvent, HelixCollapseEvent, HelixCompleteEvent, HelixConnectEvent, HelixConsoleEvent, HelixCopyEvent, HelixCreateEvent, HelixDismissEvent, HelixFacetEvent, HelixFilterEvent, HelixFilteredEvent, HelixGraphFilterEvent, HelixGraphLayoutEvent, HelixGraphPanEvent, HelixGraphPartChangeEvent, HelixGraphReadyEvent, HelixGraphSignalEvent, HelixGraphZoomEvent, HelixHistoryEvent, HelixMapClusterEvent, HelixMapPanEvent, HelixMapPartChangeEvent, HelixMapReadyEvent, HelixMapRotateEvent, HelixMapTiltEvent, HelixMapZoomEvent, HelixMoveEvent, HelixNavigateEvent, HelixNextEvent, HelixPinEvent, HelixPreviousEvent, HelixReadEvent, HelixReconnectEvent, HelixRejectEvent, HelixRelabelEvent, HelixRemoveEvent, HelixReorderEvent, HelixReorderedEvent, HelixResizedEvent, HelixResizeEvent, HelixSampleEndEvent, HelixSampleStartEvent, HelixScrolledEvent, HelixSelectEvent, HelixSelectedEvent, HelixSendEvent, HelixShortcutEvent, HelixSortEvent, HelixSortedEvent, HelixTourAskEvent, type MapClusterDetail, type MapPanDetail, type MapPartChangeDetail, type MapRotateDetail, type MapTiltDetail, type MapZoomDetail, type MoveDetail, type NavigateDetail, type OpenDetail, type ReadDetail, type ReconnectDetail, type Refusal, type RefusedFile, type RejectDetail, type RelabelDetail, type RemoveDetail, type ResizeDetail, type ScrolledDetail, type SelectDetail, type SendDetail, type ShortcutDetail, type SkipDetail, type SortDetail, type ToggleDetail, type ViewportPanDetail, type ViewportZoomDetail, } from './events/events.js';
+export { type ActivateDetail, type AuraFallbackDetail, type CanvasView, type CaretDetail, type ChangeDetail, type CompleteDetail, type ConnectDetail, type ConsoleDetail, type CopyDetail, type CreateDetail, type DismissDetail, type FacetDetail, type FilterDetail, type GraphFilterDetail, type GraphLayoutDetail, type GraphPartChangeDetail, type GraphSignalDetail, HelixActionEvent, HelixActivateEvent, HelixAuraFallbackEvent, HelixBeforeActivateEvent, HelixBeforeChangeEvent, HelixBeforeCloseEvent, HelixBeforeCollapseEvent, HelixBeforeEditEvent, HelixBeforeMoveEvent, HelixBeforeOpenEvent, HelixBeforePanelResizeEvent, HelixBeforePinEvent, HelixBeforeReconnectEvent, HelixBeforeRelabelEvent, HelixBeforeResizeEvent, HelixBeforeSplitEvent, HelixBeforeToggleEvent, HelixCanvasEditEvent, HelixCanvasPanEvent, HelixCanvasViewEvent, HelixCanvasZoomEvent, HelixCaretEvent, HelixClearEvent, HelixCollapseEvent, HelixCompleteEvent, HelixConnectEvent, HelixConsoleEvent, HelixCopyErrorEvent, HelixCopyEvent, HelixCreateEvent, HelixDismissEvent, HelixEditEvent, HelixEndEvent, HelixExpandEvent, HelixFacetEvent, HelixFilterEvent, HelixFilteredEvent, HelixGraphFilterEvent, HelixGraphLayoutEvent, HelixGraphPanEvent, HelixGraphPartChangeEvent, HelixGraphReadyEvent, HelixGraphSignalEvent, HelixGraphZoomEvent, HelixHistoryEvent, HelixLoadEvent, HelixLoadMoreEvent, HelixMapClusterEvent, HelixMapPanEvent, HelixMapPartChangeEvent, HelixMapReadyEvent, HelixMapRotateEvent, HelixMapTiltEvent, HelixMapZoomEvent, HelixMoveEvent, HelixNavigateEvent, HelixNextEvent, HelixPanelResizeEvent, HelixPinEvent, HelixPressEvent, HelixPreviewEvent, HelixPreviousEvent, HelixRangeChangeEvent, HelixReadEvent, HelixReconnectEvent, HelixRejectEvent, HelixRelabelEvent, HelixRemoveEvent, HelixReorderEvent, HelixReorderedEvent, HelixResizedEvent, HelixResizeEvent, HelixSampleEndEvent, HelixSampleStartEvent, HelixScrolledEvent, HelixSelectEvent, HelixSelectedEvent, HelixSendEvent, HelixShortcutEvent, HelixSortEvent, HelixSortedEvent, HelixSplitEvent, HelixToggleEvent, HelixTourAskEvent, HelixTourStatusEvent, HelixTypingEvent, type MapClusterDetail, type MapPanDetail, type MapPartChangeDetail, type MapRotateDetail, type MapTiltDetail, type MapZoomDetail, type MoveDetail, type NavigateDetail, type OpenDetail, type PressDetail, type PressPointerType, type RangeDetail, type ReadDetail, type ReconnectDetail, type Refusal, type RefusedFile, type RejectDetail, type RelabelDetail, type RemoveDetail, type ResizeDetail, type ScrolledDetail, type SelectDetail, type SendDetail, type ShortcutDetail, type SkipDetail, type SortDetail, type ToggleDetail, type TourStatusDetail, type TypingDetail, type ViewportPanDetail, type ViewportZoomDetail, } from './events/events.js';
 export { HelixElement, whenHydrated } from './helix-element/helix-element.js';
 export { HelixFormElement } from './helix-form-element/helix-form-element.js';
 export { MixinChartSource, type MixinChartSourceInterface, PALETTE, PLOT_HEIGHT, PLOT_WIDTH, seriesIndex, seriesNames, } from './mixins/mixin-chart-source/mixin-chart-source.js';
@@ -56,6 +59,7 @@ export { countLabel } from './utils/count-label/count-label.js';
 export { createSheet } from './utils/create-sheet/create-sheet.js';
 export { type Color, type ColorFormat, formatColor, parseColor, toCss, toHsl, toRgb, } from './utils/css-color/css-color.js';
 export { customElement, definedTags, duplicateRegistrations, } from './utils/custom-element/custom-element.js';
+export { segmentName } from './utils/date-segments/date-segments.js';
 export { type DrawDismissOptions, drawDismiss, drawDismissGlyph, } from './utils/draw-dismiss/draw-dismiss.js';
 export { type DrawIconOptions, drawIcon } from './utils/draw-icon/draw-icon.js';
 export { CHART_PLOT, drawTooltip } from './utils/draw-tooltip/draw-tooltip.js';
@@ -66,7 +70,9 @@ export { deepActiveElement, deepContains, focusableElements, } from './utils/foc
 export { afterLinkFollowed, followLink, type LinkModifiers, type LinkTarget, } from './utils/follow-link/follow-link.js';
 export { formatNumbers } from './utils/format-numbers/format-numbers.js';
 export { headingIn, headingsIn } from './utils/heading-in/heading-in.js';
+export { headingLevel } from './utils/heading-level/heading-level.js';
 export { type HostAria, hostAria } from './utils/host-aria/host-aria.js';
+export { defaultButton, submitImplicitly, submits, submitsOnEnter, } from './utils/implicit-submit/implicit-submit.js';
 export { type DisableableItem, forgetDisabled, inheritDisabled, } from './utils/inherit-disabled/inherit-disabled.js';
 export { inlineStep } from './utils/inline-step/inline-step.js';
 export { isRtl } from './utils/is-rtl/is-rtl.js';
@@ -76,7 +82,10 @@ export { markRegion, type RegionOptions } from './utils/mark-region/mark-region.
 export { copiesOf, type MediaCopy, sameCopies, } from './utils/media-copy/media-copy.js';
 export { formatNumber, parseNumber } from './utils/number-format/number-format.js';
 export { onUnlessFalse } from './utils/on-unless-false/on-unless-false.js';
+export { plainClick } from './utils/plain-click/plain-click.js';
 export { appleTouch, onApple, type Platform } from './utils/platform/platform.js';
+export { pressType, type RecentPress } from './utils/press-type/press-type.js';
+export { rangeAdd } from './utils/range-add/range-add.js';
 export { type ColorBytes, readColor, rgbOf } from './utils/read-color/read-color.js';
 export { byRow, type Row, type RowCell, readRows, readSeries, type Series, type SeriesPoint, seriesKey, unbroken, } from './utils/read-series/read-series.js';
 export { type ElementsProperty, linkDescription, reflectElements, unlinkDescription, } from './utils/reflect-elements/reflect-elements.js';
@@ -89,6 +98,8 @@ export { type ChangeRequestOptions, requestChange, } from './utils/request-chang
 export { type ActivatableItem, resolveActiveItem, } from './utils/resolve-active-item/resolve-active-item.js';
 export { holdCaret, restoreValue } from './utils/restore-value/restore-value.js';
 export { type RovingOptions, rovingStop } from './utils/roving-stop/roving-stop.js';
+export { valueAt } from './utils/row-data/row-data.js';
+export { type Arranged, type Axis, arranged, cycle, type DataRow, filter, format, type Ordered, ordered, parse, type Sort, sort, window_, } from './utils/row-order/row-order.js';
 export { extent, linear, type Scale } from './utils/scale/scale.js';
 export { ticks } from './utils/scale/ticks.js';
 export { type ScrollItemOptions, scrollItemIntoView, } from './utils/scroll-item-into-view/scroll-item-into-view.js';
@@ -100,8 +111,11 @@ export { edgeOffset, FLING, parseSnapPoints, type SwipeAxis, type SwipeEdge, typ
 export { tellDisclosure } from './utils/tell-disclosure/tell-disclosure.js';
 export { subscribe } from './utils/ticker/ticker.js';
 export { type HelixStatusTone, TONE_MARKS, type ToneMark, toneMark, } from './utils/tone-marks/tone-marks.js';
+export { type TreeArrow, type TreeArrowRow, treeArrow } from './utils/tree-arrow/tree-arrow.js';
+export { Typeahead, type TypeaheadBy, typeaheadBy, typesCharacter, } from './utils/typeahead/typeahead.js';
 export { dateAsValue, isClockValue, isDateValue, isTimeValue, minutesAsValue, numberAsValue, secondsAsValue, timeAsValue, valueAsDate, valueAsMinutes, valueAsNumber, valueAsSeconds, valueAsTime, } from './utils/value-as/value-as.js';
 export { watchTheme } from './utils/watch-theme/watch-theme.js';
+export { wordsConverter } from './utils/words-converter/words-converter.js';
 export { writeClock, writeTime } from './utils/write-time/write-time.js';
-export { commaList, toggleValue, writtenList, writtenNumbers, } from './utils/written-list/written-list.js';
+export { commaList, pressedValue, prunedValue, type SelectionMode, toggleEvery, toggleValue, writtenList, writtenNumbers, } from './utils/written-list/written-list.js';
 export { VERSION } from './version.js';