@ixfx/components 0.13.2 → 0.13.4

package/bundle/index.d.ts

@@ -1,9 +1,4 @@
 import { CSSResult, CSSResultGroup, LitElement, PropertyValues, ReactiveController, ReactiveControllerHost, TemplateResult, html, nothing } from "lit";
-import { FzfOptions } from "fzf";
-import { CommandId, CommandRegistry, KeyboardManager } from "@clinth/ui-commands";
-import { Colour } from "@ixfx/visual";
-import { TraversableTree } from "@ixfx/collections";
-import "@clinth/vcanvas";
 //#region src/icons/icon.d.ts
 declare class IxfxIconElement extends LitElement {
   #private;
@@ -285,6 +280,179 @@ interface AcTokenElement {
   addEventListener: (<K extends keyof AcTokenElementEventMap>(type: K, listener: (this: AcTokenElement, event: AcTokenElementEventMap[K]) => void, options?: boolean | AddEventListenerOptions) => void) & ((type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions) => void);
 }
 //#endregion
+//#region node_modules/.pnpm/@clinth+ui-commands@1.1.0/node_modules/@clinth/ui-commands/dist/types.d.ts
+type CommandId = string;
+type CommandOptions = Readonly<{
+  onInvoke?: (id: CommandId, args?: Record<string, unknown>) => void;
+  onInvokeError?: (id: CommandId, error: Error, stage: `on-invoke` | `listener` | `execute`) => void;
+  onCommandNotFound?: (id: CommandId) => void;
+}>;
+type Command<TState = unknown> = Readonly<{
+  id: CommandId;
+  label: string;
+  icon?: string;
+  description: string;
+  enabledWhen?: (state: TState) => boolean;
+  execute: (args?: Record<string, unknown>) => void;
+}>;
+type InputSource = `keyboard` | `pointer` | `midi`;
+type InputContext = Readonly<{
+  source: InputSource;
+  element: HTMLElement | null;
+  commandContext?: string;
+}>;
+type ModifierKey = `ctrl` | `shift` | `alt` | `meta`;
+interface Modifiers {
+  ctrl: boolean;
+  shift: boolean;
+  alt: boolean;
+  meta: boolean;
+}
+interface KeyBinding<TAppModes extends string = string> {
+  key: string;
+  modifiers: Set<ModifierKey>;
+  mode?: TAppModes | `all`;
+  nonExclusive?: boolean;
+  commandContext?: string;
+  commandId: CommandId;
+}
+type KeyEventHandler = (commandId: CommandId, modifiers: Modifiers, context: InputContext) => void;
+//#endregion
+//#region node_modules/.pnpm/@clinth+ui-commands@1.1.0/node_modules/@clinth/ui-commands/dist/command-registry.d.ts
+/**
+ * Command registry.
+ */
+declare class CommandRegistry<TState = unknown> {
+  private commands;
+  private invokeListeners;
+  private options;
+  /**
+   * Creates, with options.
+   * @param options
+   */
+  constructor(options?: CommandOptions);
+  /**
+   * Registers a command.
+   * @throws If command with this id is already registered
+   * @param command
+   */
+  register(command: Command<TState>): void;
+  /**
+   * Unregisters a command.
+   * @param id - Command ID to unregister
+   * @returns _true_ if a command was removed
+   */
+  unregister(id: CommandId): boolean;
+  /**
+   * Runs a command by its id.
+   *
+   * If the id was not found, the `onCommandNotFound` callback is used.
+   *
+   * Order is:
+   * command.execute
+   * options onInvoke handler executed
+   * each invoke listener executed
+   * @param id
+   * @param args
+   * @returns _false_ if command could not be executed or was not found.
+   */
+  invoke(id: CommandId, args?: Record<string, unknown>): boolean;
+  /**
+   * Adds a function to call when a command is invoked.
+   * @param handler - Handler to add
+   * @returns Function to unsubscribe the handler
+   */
+  addOnInvokeHandler(handler: (id: CommandId, args?: Record<string, unknown>) => void): () => void;
+  /**
+   * Gets a command by id.
+   * @param id - Command ID to retrieve
+   * @returns The command or _undefined_ if not found
+   */
+  get(id: CommandId): Command<TState> | undefined;
+  /**
+   * Returns a copy of all commands.
+   * @returns Array of all commands
+   */
+  getAll(): ReadonlyArray<Command<TState>>;
+  /**
+   * Returns a filtered array of all commands that are enabled for the given state.
+   * @param state - Current application state
+   * @returns Array of enabled commands
+   */
+  getEnabled(state: TState): ReadonlyArray<Command<TState>>;
+  /**
+   * Returns _true_ if this command is registered.
+   * @param id - Command ID to check
+   * @returns _true_ if the command exists
+   */
+  has(id: CommandId): boolean;
+}
+//#endregion
+//#region node_modules/.pnpm/@clinth+ui-commands@1.1.0/node_modules/@clinth/ui-commands/dist/keyboard-manager.d.ts
+/**
+ * Manages keyboard bindings and event handling.
+ * @typeParam M - The mode type (e.g., 'detail' | 'coarse')
+ */
+declare class KeyboardManager<M extends string = string> {
+  private bindings;
+  private active;
+  private element;
+  private eventHandlers;
+  private modeGetter;
+  /**
+   * Sets the function that returns the current application mode.
+   * @param getter - Function that returns the current mode
+   */
+  setModeGetter(getter: () => M): void;
+  /**
+   * Adds a key binding.
+   * @param binding - The binding to add
+   */
+  bind(binding: KeyBinding<M>): void;
+  /**
+   * Removes a key binding.
+   * @param key - The key to unbind
+   * @param modifiers - The modifiers set required for the binding
+   */
+  unbind(key: string, modifiers: Set<ModifierKey>): void;
+  /**
+   * Enables or disables keyboard event handling.
+   * @param active - Whether keyboard handling should be active
+   */
+  setActive(active: boolean): void;
+  /**
+   * Adds a handler for key events.
+   * @param handler - The handler to call when a key event matches a binding
+   * @returns Function to unsubscribe the handler
+   */
+  onKeyEvent(handler: KeyEventHandler): () => void;
+  /**
+   * Attaches keyboard event listeners to an element.
+   * @param element - The element to attach to
+   */
+  attach(element: HTMLElement): void;
+  /**
+   * Removes keyboard event listeners.
+   */
+  detach(): void;
+  /**
+   * Returns all registered bindings.
+   * @returns Readonly array of bindings
+   */
+  getBindings(): ReadonlyArray<KeyBinding<M>>;
+  private handleKeydown;
+  private getInputContext;
+  private getModifiers;
+  private findBinding;
+  private pickBestBinding;
+  private matchesCommandContext;
+  private hasOverlap;
+  private formatModifiers;
+  private isSubset;
+  private setsEqual;
+  private toModifiers;
+}
+//#endregion
 //#region src/titlebar/titlebar.d.ts
 type TitlebarOrientation = `horizontal` | `vertical`;
 type TitlebarVariant = `titlebar` | `midline` | `tree`;
@@ -685,122 +853,1218 @@ declare global {
   }
 }
 //#endregion
-//#region src/checkbox/checkbox.d.ts
-declare class Checkbox extends LitElement {
-  #private;
-  static styles: import("lit").CSSResult[];
-  checked: boolean;
-  disabled: boolean;
-  indeterminate: boolean;
-  readonly: boolean;
-  label: string;
-  name: string;
-  value: string;
-  /** Focus the inner input, so the host can be focused like a native checkbox. */
-  focus(options?: FocusOptions): void;
-  render(): ReturnType<typeof html>;
-}
-type CheckboxChangeDetail = {
-  readonly checked: boolean;
-};
-type CheckboxChangeEvent = CustomEvent<CheckboxChangeDetail>;
-declare global {
-  interface HTMLElementTagNameMap {
-    'ixfx-checkbox': Checkbox;
-  }
-}
-interface CheckboxEventMap {
-  change: CheckboxChangeEvent;
+//#region src/checkbox/checkbox.d.ts
+declare class Checkbox extends LitElement {
+  #private;
+  static styles: import("lit").CSSResult[];
+  checked: boolean;
+  disabled: boolean;
+  indeterminate: boolean;
+  readonly: boolean;
+  label: string;
+  name: string;
+  value: string;
+  /** Focus the inner input, so the host can be focused like a native checkbox. */
+  focus(options?: FocusOptions): void;
+  render(): ReturnType<typeof html>;
+}
+type CheckboxChangeDetail = {
+  readonly checked: boolean;
+};
+type CheckboxChangeEvent = CustomEvent<CheckboxChangeDetail>;
+declare global {
+  interface HTMLElementTagNameMap {
+    'ixfx-checkbox': Checkbox;
+  }
+}
+interface CheckboxEventMap {
+  change: CheckboxChangeEvent;
+}
+interface Checkbox {
+  addEventListener: (<K extends keyof CheckboxEventMap>(type: K, listener: (this: Checkbox, event: CheckboxEventMap[K]) => void, options?: boolean | AddEventListenerOptions) => void) & ((type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions) => void);
+}
+//#endregion
+//#region src/checked-select/types.d.ts
+type CheckState = `true` | `false` | `indeterminate`;
+type CheckedSelectItem = {
+  readonly value: string;
+  readonly label: string;
+  readonly checked: CheckState;
+};
+type ItemDisplay = `checkbox` | `text`;
+type ItemOrientation = `horizontal` | `vertical`;
+//#endregion
+//#region src/checked-select/checked-select.d.ts
+declare class CheckedSelect extends LitElement {
+  #private;
+  static styles: import("lit").CSSResult[];
+  items: readonly CheckedSelectItem[];
+  multiline: boolean;
+  /** At-rest checkboxes are display-only; clicking them just opens the popup. (Not `inert`: that native attribute would block the whole element.) */
+  itemsInert: boolean;
+  /** How at-rest items are shown: as `checkbox`es, or as comma-separated `text`. */
+  itemDisplay: ItemDisplay;
+  /** Direction the resting items flow: `horizontal` (default) or `vertical` (one per row). */
+  orientation: ItemOrientation;
+  placeholder: string;
+  disabled: boolean;
+  private _open;
+  private _draft;
+  private _order;
+  private _size;
+  get isOpen(): boolean;
+  disconnectedCallback(): void;
+  willUpdate(changed: PropertyValues): void;
+  open(): Promise<void>;
+  commit(): void;
+  cancel(): void;
+  protected render(): import("lit").TemplateResult<1>;
+}
+type CheckedSelectChangeDetail = {
+  /** Every item, with its committed state. */
+  readonly items: readonly CheckedSelectItem[];
+  /** Only the items whose state changed. */
+  readonly changed: readonly CheckedSelectItem[];
+};
+type CheckedSelectChangeEvent = CustomEvent<CheckedSelectChangeDetail>;
+declare global {
+  interface HTMLElementTagNameMap {
+    'ixfx-checked-select': CheckedSelect;
+  }
+}
+interface CheckedSelectEventMap {
+  change: CheckedSelectChangeEvent;
+}
+interface CheckedSelect {
+  addEventListener: (<K extends keyof CheckedSelectEventMap>(type: K, listener: (this: CheckedSelect, event: CheckedSelectEventMap[K]) => void, options?: boolean | AddEventListenerOptions) => void) & ((type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions) => void);
+}
+//#endregion
+//#region src/colour-picker/types.d.ts
+/**
+ * OKLCH colour value representation
+ */
+type OklchValue = {
+  readonly l: number;
+  readonly c: number;
+  readonly h: number;
+  readonly a?: number;
+  readonly unit: `scalar`;
+  readonly space: `oklch`;
+};
+/**
+ * Event detail for colour picker input/change events
+ */
+type ColourPickerEventDetail = OklchValue;
+/**
+ * Colour picker custom events
+ */
+type ColourPickerInputEvent = CustomEvent<ColourPickerEventDetail>;
+type ColourPickerChangeEvent = CustomEvent<ColourPickerEventDetail>;
+type Range = readonly [number, number];
+type RangeInput$1 = readonly [number, number] | readonly number[];
+/**
+ * Augment HTMLElementTagNameMap for the custom element
+ */
+declare global {
+  interface HTMLElementTagNameMap {
+    'ixfx-colour-picker': ColourPicker;
+  }
+}
+//#endregion
+//#region node_modules/.pnpm/@ixfx+geometry@0.56.14/node_modules/@ixfx/geometry/dist/angles.d.ts
+/**
+ * A angle with unit.
+ * - [Degrees](https://en.wikipedia.org/wiki/Degree_(angle)): 0..360
+ * - [Radians](https://en.wikipedia.org/wiki/Radian): 0...2Pi
+ * - [Gradians](https://en.wikipedia.org/wiki/Gradian): 0..400
+ * - [Turns](https://en.wikipedia.org/wiki/Turn_(angle)): 0..1
+ *
+ *
+ * ```
+ *             100 grad
+ *             1/4 turn
+ *              90 deg
+ *             PI/2 rad
+ *                |
+ *  Pi rad        |        0 or 2PI rad
+ *  180deg -------+------- 0 or 360 deg
+ *  1/2 turn      |        0 or 1 turn
+ *  200 grad      |        0 or 400 grad
+ *                |
+ *             270 deg
+ *            3PI/2 rad
+ *             3/4 turn
+ *             300 grad
+ * ```
+ */
+type Angle = {
+  value: number;
+  unit: `deg` | `rad` | `turn` | `grad`;
+};
+//#endregion
+//#region node_modules/.pnpm/@ixfx+collections@0.56.14/node_modules/@ixfx/collections/dist/index-rrpZOWbs.d.ts
+/**
+ * Traversable Tree.
+ *
+ * Creatable from:
+ * {@link Trees.FromObject.asDynamicTraversable}: Create based on dynamic reading of an object
+ * {@link Trees.TraversableTree}: Create based on an {@link Trees.TreeNode}, a {@link Trees.TraversableTree} or an object (same as calling asDynamicTraversable).
+ * Use {@link Trees.isTraversable} to check if an object is this type.
+ */
+type TraversableTree<TValue> = {
+  /**
+   * Direct children of node
+   */
+  children: () => IterableIterator<TraversableTree<TValue>>;
+  /**
+   * Direct parent of node
+   */
+  getParent: () => TraversableTree<TValue> | undefined;
+  /**
+   * Value of node
+   */
+  getValue: () => TValue;
+  /**
+   * Object reference that acts as the identity of the node
+   */
+  getIdentity: () => any;
+};
+//#endregion
+//#region node_modules/.pnpm/@ixfx+random@0.56.14/node_modules/@ixfx/random/dist/index.d.ts
+//#region src/types.d.ts
+/**
+ * A random source.
+ *
+ * Predefined sources: Math.random, {@link gaussianSource}, {@link weightedSource}
+ */
+type RandomSource = () => number;
+//#endregion
+//#region node_modules/.pnpm/@ixfx+visual@0.56.14/node_modules/@ixfx/visual/dist/index-a3KMyMEu.d.ts
+//#region src/colour/types.d.ts
+type HslBase = {
+  /**
+   * Hue
+   */
+  h: number;
+  /**
+   * Saturation
+   */
+  s: number;
+  /**
+   * Lightness
+   */
+  l: number;
+  /**
+   * Opacity
+   */
+  opacity?: number;
+  space?: `hsl`;
+};
+/**
+ * [YCbCr format](https://en.wikipedia.org/wiki/YCbCr)
+ */
+type YCbCrBase = {
+  /**
+   * Luma
+   */
+  y: number;
+  /**
+   * Blue difference
+   */
+  cb: number;
+  /**
+   * Red difference
+   */
+  cr: number;
+  /**
+   * Opacity
+   */
+  opacity?: number;
+  space?: `ycbcr`;
+};
+/**
+ * Scalar values use 0..1 for each field
+ */
+type YCbCrScalar = YCbCrBase & {
+  unit: `scalar`;
+};
+/**
+ * Absolute colour use 0..255 for each field
+ */
+type YCbCr8bit = YCbCrBase & {
+  unit: `8bit`;
+};
+/**
+ * [YCbCr format](https://en.wikipedia.org/wiki/YCbCr).
+ *
+ * By default assumes scalar coordinates (0..1) for each field.
+ * Use '8bit' unit for 0..255 ranged values.
+ */
+type YCbCr = YCbCrScalar | YCbCr8bit;
+type ColourSpaces = `srgb` | `hsl` | `oklch` | `ycbcr`;
+/**
+ * Scalar values use 0..1 for each field
+ */
+type HslScalar = HslBase & {
+  unit: `scalar`;
+};
+/**
+ * Absolute values use hue:0..360, all other fields 0..100
+ */
+type HslAbsolute = HslBase & {
+  unit: `absolute`;
+};
+/**
+ * HSL value.
+ * By default assumes scalar coordinates (0..1) for each field.
+ * Use 'absolute' unit for hue:0...360, all other fields on 0..100 scale.
+ */
+type Hsl = HslScalar | HslAbsolute;
+/**
+ * Rgb.
+ * Units determine how to interperet rgb values.
+ * 'scalar': 0..1 range for RGB & opacity
+ * '8bit': 0..255 range for RGB & opacity
+ */
+type RgbBase = {
+  r: number;
+  g: number;
+  b: number;
+  opacity?: number;
+  space?: `srgb`;
+};
+type RgbScalar = RgbBase & {
+  unit: `scalar`;
+};
+/**
+ * RGB in 0...255 range, including opacity.
+ */
+type Rgb8Bit = RgbBase & {
+  unit: `8bit`;
+};
+/**
+ * Rgb.
+ * Units determine how to interperet rgb values.
+ * 'scalar': 0..1 range for RGB & opacity
+ * '8bit': 0..255 range for RGB & opacity
+ */
+type Rgb = RgbScalar | Rgb8Bit;
+type LchBase = {
+  /**
+   * Lightness/perceived brightnes
+   */
+  l: number;
+  /**
+   * Chroma ('amount of colour')
+   */
+  c: number;
+  /**
+   * Hue
+   */
+  h: number;
+  /**
+   * Opacity on 0..1 scale
+   */
+  opacity?: number;
+  space: `lch` | `oklch`;
+};
+type ColourInterpolator<T extends Colour> = (amount: number) => T;
+type OkLchBase = LchBase & {
+  space: `oklch`;
+};
+/**
+ * Oklch colour expressed in 0..1 scalar values for LCH & opacity
+ */
+type OkLchScalar = OkLchBase & {
+  unit: `scalar`;
+};
+/**
+ * Oklch colour expressed with:
+ * l: 0..1
+ * c: 0..4
+ * h: 0..360 degrees
+ * opacity: 0..1
+ */
+type OkLchAbsolute = OkLchBase & {
+  unit: `absolute`;
+};
+type OkLch = OkLchAbsolute | OkLchScalar;
+type Colour = {
+  opacity?: number;
+} & (Hsl | OkLch | Rgb | YCbCr);
+/**
+ * A representation of colour. Eg: `blue`, `rgb(255,0,0)`, `hsl(20,100%,50%)`
+ */
+type Colourish = Colour | string;
+/**
+ * Options for interpolation
+ */
+type ColourInterpolationOpts = {
+  direction: `longer` | `shorter`;
+  /**
+   * Space to do calculations in
+   */
+  space: ColourSpaces;
+  /**
+   * Destination of calculated colour
+   */
+  destination: ConvertDestinations;
+};
+type ColourStepOpts = ColourInterpolationOpts & {
+  /**
+   * If set, determines total number of steps, including colour stops.
+   * Use this _or_ `stepsBetween`.
+   */
+  stepsTotal?: number;
+  /**
+   * If set, determines number of steps between colour stops.
+   * Use this _or_ `stepsTotal`.
+   */
+  stepsBetween?: number;
+};
+type ParsingOptions<T> = Partial<{
+  scalar: boolean;
+  ensureSafe: boolean;
+  /**
+   * Value to use if input is invalid
+   */
+  fallbackString: string;
+  /**
+   * Fallback colour to use if value cannot be parsed
+   */
+  fallbackColour: T;
+}>;
+type ConvertDestinations = `hsl-scalar` | `hsl-absolute` | `oklch-scalar` | `oklch-absolute` | `srgb-8bit` | `srgb-scalar` | `ycbcr-scalar` | `ycbcr-8bit`;
+//#endregion
+//#region ../../node_modules/.pnpm/colorizr@4.0.1/node_modules/colorizr/dist/index.d.mts
+type ColorType = 'hex' | 'hsl' | 'oklab' | 'oklch' | 'rgb';
+type HEX = `#${string}`;
+interface Analysis {
+  brightnessDifference: number;
+  colorDifference: number;
+  compliant: number;
+  contrast: number;
+  largeAA: boolean;
+  largeAAA: boolean;
+  normalAA: boolean;
+  normalAAA: boolean;
+}
+interface HSL {
+  /** The alpha/opacity value (0-1). */
+  alpha?: number;
+  h: number;
+  l: number;
+  s: number;
+}
+interface LAB {
+  a: number;
+  /** The alpha/opacity value (0-1). */
+  alpha?: number;
+  b: number;
+  l: number;
+}
+interface LCH {
+  /** The alpha/opacity value (0-1). */
+  alpha?: number;
+  c: number;
+  h: number;
+  l: number;
+}
+interface RGB {
+  /** The alpha/opacity value (0-1). */
+  alpha?: number;
+  b: number;
+  g: number;
+  r: number;
+}
+interface ColorizrOptions {
+  /**
+   * Output color format.
+   *
+   * If not specified, the output will use the same format as the input color.
+   */
+  format?: ColorType;
+}
+declare class Colorizr {
+  /** The alpha/opacity value (0-1). */
+  alpha: number;
+  hex: HEX;
+  hsl: HSL;
+  oklab: LAB;
+  oklch: LCH;
+  rgb: RGB;
+  type: ColorType;
+  constructor(color: string | HSL | LAB | LCH | RGB, options?: ColorizrOptions);
+  /**
+   * Get CSS string
+   */
+  get css(): string;
+  /**
+   * Get the red value
+   */
+  get red(): number;
+  /**
+   * Get the green value
+   */
+  get green(): number;
+  /**
+   * Get the blue value
+   */
+  get blue(): number;
+  /**
+   * Get the hue value
+   */
+  get hue(): number;
+  /**
+   * Get the saturation value
+   */
+  get saturation(): number;
+  /**
+   * Get the lightness value
+   */
+  get lightness(): number;
+  /**
+   * Get the luminance value
+   */
+  get luminance(): number;
+  /**
+   * Get the chroma value
+   */
+  get chroma(): number;
+  get opacity(): number;
+  /**
+   * Get the most readable color (light or dark) for this color as a background.
+   */
+  get readableColor(): string;
+  private get currentColor();
+  /**
+   * Get the brightness difference between this color and another.
+   *
+   * @param input - The color to compare against.
+   * @returns The brightness difference value.
+   */
+  brightnessDifference(input: string): number;
+  /**
+   * Get the color difference between this color and another.
+   *
+   * @param input - The color to compare against.
+   * @returns The color difference value.
+   */
+  colorDifference(input: string): number;
+  /**
+   * Test 2 colors for WCAG compliance.
+   *
+   * @param input - The color to compare against.
+   * @returns Analysis object with compliance information.
+   */
+  compare(input: string): Analysis;
+  /**
+   * Get the contrast ratio between this color and another.
+   *
+   * @param input - The color to compare against.
+   * @returns The contrast ratio.
+   */
+  contrast(input: string): number;
+  /**
+   * Format the color to a specific type.
+   *
+   * @param type - The color format to convert to.
+   * @param precision - The decimal precision for the output.
+   * @returns The formatted color string.
+   */
+  format(type: ColorType, precision?: number): string;
+  /**
+   * Increase lightness.
+   *
+   * @param amount - A number between 0 and 100.
+   * @returns The lightened color string.
+   */
+  lighten(amount: number): string;
+  /**
+   * Decrease lightness.
+   *
+   * @param amount - A number between 0 and 100.
+   * @returns The darkened color string.
+   */
+  darken(amount: number): string;
+  /**
+   * Increase saturation.
+   *
+   * @param amount - A number between 0 and 100.
+   * @returns The saturated color string.
+   */
+  saturate(amount: number): string;
+  /**
+   * Decrease saturation.
+   *
+   * @param amount - A number between 0 and 100.
+   * @returns The desaturated color string.
+   */
+  desaturate(amount: number): string;
+  /**
+   * Convert to grayscale.
+   *
+   * @returns The grayscale color string.
+   */
+  grayscale(): string;
+  /**
+   * Invert color.
+   *
+   * @returns The inverted color string.
+   */
+  invert(): string;
+  /**
+   * Mix with another color.
+   *
+   * @param color - The color to mix with.
+   * @param ratio - A number between 0 and 1 (0 = this color, 1 = input color).
+   * @returns The mixed color string.
+   */
+  mix(color: string, ratio?: number): string;
+  /**
+   * Add opacity to the color.
+   *
+   * @param alpha - A number between 0 and 1.
+   * @returns The opacified color string.
+   */
+  opacify(alpha?: number): string;
+  /**
+   * Rotate color hue.
+   *
+   * @param degrees - A number between -360 and 360.
+   * @returns The rotated color string.
+   */
+  rotate(degrees: number): string;
+  /**
+   * Make the color more transparent.
+   *
+   * @param alpha - A number between -1 and 1.
+   * @returns The transparentized color string.
+   */
+  transparentize(alpha?: number): string;
+}
+/**
+ * Check 2 colors for WCAG compliance.
+ *
+ * @param left - The first color string.
+ * @param right - The second color string.
+ * @returns Analysis object with WCAG compliance information.
+ */
+//#endregion
+//#region src/colour/conversion.d.ts
+declare function convert<T extends ConvertDestinations>(colour: Colourish, destination: T): T extends `oklch-absolute` ? OkLchAbsolute : T extends `oklch-scalar` ? OkLchScalar : T extends `srgb-8bit` ? Rgb8Bit : T extends `srgb-scalar` ? RgbScalar : T extends `hsl-scalar` ? HslScalar : T extends `hsl-absolute` ? HslAbsolute : never;
+/**
+ * Like {@link convert}, but result is a CSS colour string
+ * @param colour
+ * @param destination
+ */
+declare function convertToString(colour: Colourish, destination: ConvertDestinations): string;
+/**
+ * Converts some kind of colour into a scalar representation. Supports oklch, hsl and srgb.
+ * @param colour Colour to convert
+ * @param destination Destination colour format
+ */
+declare function convertScalar<T extends ColourSpaces>(colour: Colourish, destination: T): T extends `oklch` ? OkLchScalar : T extends `hsl` ? HslScalar : T extends `srgb` ? RgbScalar : never;
+declare function toCssColour(colour: Colourish | object): string;
+declare function toHexColour(colour: Colourish | object): string;
+declare function toLibraryColour(colour: Colourish): Colorizr;
+declare function guard$4(colour: Colour): void;
+declare function toColour(colourish: any): Colour;
+/**
+ * Returns a CSS-ready string
+ * representation.
+ * ```js
+ * element.style.backgroundColor = resolveToString(`red`);
+ * ```
+ *
+ * Tries each parameter in turn, returning the value
+ * for the first that resolves. This can be useful for
+ * having fallback values.
+ *
+ * ```js
+ * // Try a CSS variable, a object property or finally fallback to red.
+ * element.style.backgroundColor = toStringFirst('--some-var', opts.background, `red`);
+ * ```
+ * @param colours Array of colours to resolve
+ */
+declare function toStringFirst(...colours: Array<Colourish | undefined>): string;
+declare function rgbToHsl(rgb: Rgb, scalarResult: true): HslScalar;
+declare function rgbToHsl(rgb: Rgb, scalarResult: false): HslAbsolute;
+//#endregion
+//#region src/colour/css-colours.d.ts
+/**
+ * Converts from some kind of colour that is legal in CSS
+ * into a structured Colour type.
+ *
+ * Handles: hex format, CSS variables, colour names
+ * ```js
+ * fromCssColour(`#ffffff`);
+ * fromCssColour(`blue`);
+ * fromCssColour(`--some-variable`);
+ * fromCssColour(`hsl(50, 50%, 50%)`);
+ * fromCssColour(`rgb(50, 100, 100)`);
+ * ```
+ * @param colour
+ * @returns
+ */
+declare const fromCssColour: (colour: string) => Colour;
+/**
+ * Resolves a named colour to a colour string.
+ *
+ * ```js
+ * resolveCss(`red`);
+ * ```
+ * @param colour CSS named colour
+ * @returns
+ */
+declare function resolveCss(colour: CssColourNames): string;
+type CssColourNames = keyof typeof cssDefinedHexColours;
+declare const cssDefinedHexColours: Record<string, string>;
+//#endregion
+//#region src/colour/generate.d.ts
+/**
+ * Returns a full HSL colour string (eg `hsl(20,50%,75%)`) based on a index.
+ * It's useful for generating perceptually different shades as the index increments.
+ *
+ * ```
+ * el.style.backgroundColor = goldenAgeColour(10);
+ * ```
+ *
+ * Saturation and lightness can be specified, as numeric ranges of 0-1.
+ *
+ * @param saturation Saturation (0-1), defaults to 0.5
+ * @param lightness Lightness (0-1), defaults to 0.75
+ * @param alpha Opacity (0-1), defaults to 1.0
+ * @returns HSL colour string eg `hsl(20,50%,75%)`
+ */
+declare const goldenAngleColour: (index: number, saturation?: number, lightness?: number, alpha?: number) => string;
+/**
+ * Returns a random hue component (0..359)
+ *
+ * ```
+ * // Generate hue
+ * const h = randomHue(); // 0-359
+ *
+ * // Generate hue and assign as part of a HSL string
+ * el.style.backgroundColor = `hsl(${randomHue(), 50%, 75%})`;
+ * ```
+ * @param rand
+ * @returns
+ */
+declare const randomHue: (rand?: RandomSource) => number;
+//#endregion
+//#region src/colour/guards.d.ts
+declare function isHsl(v: any): v is Hsl;
+declare function isRgb(v: any): v is Rgb;
+/**
+ * If the input object has r,g&b properties, it will return a fully-
+ * formed Rgb type with `unit` and `space` properties.
+ *
+ * If it lacks these basic three properties or they are out of range,
+ *  _undefined_ is returned.
+ *
+ * If RGB values are less than 1 assumes unit:scalar. Otherwise unit:8bit.
+ * If RGB values exceed 255, _undefined_ returned.
+ * @param v
+ * @returns
+ */
+declare function tryParseObjectToRgb(v: any): Rgb | undefined;
+declare function tryParseObjectToHsl(v: any): Hsl | undefined;
+declare function isOkLch(v: any): v is OkLch;
+declare function isColourish(v: any): v is Colourish;
+declare namespace hsl_d_exports {
+  export { absolute$1 as absolute, changeLightness$1 as changeLightness, fromCss$3 as fromCss, fromHexString$3 as fromHexString, generateScalar$1 as generateScalar, guard$3 as guard, interpolator$3 as interpolator, parseCssHslFunction, scalar$3 as scalar, toAbsolute$1 as toAbsolute, toCssString$2 as toCssString, toHexString$3 as toHexString, toLibraryRgb, toScalar$3 as toScalar, withOpacity$3 as withOpacity };
+}
+/**
+ * Scales the opacity value of an input HSL value
+ * ```js
+ * withOpacity()
+ * ```
+ * @param value Colour
+ * @param fn Function that calcules opacity based on input scalar value
+ */
+declare function withOpacity$3<T extends Hsl>(value: T, fn: (opacityScalar: number, value: T) => number): T;
+/**
+ * Increases or decreases lightness by this percentage, returning new colour
+ *
+ * Amount to change:
+ * 'fixed': a fixed amount
+ * 'delta': increase/decrease by this amount
+ * 'pdelta': proportion of current value to change by ('percentage delta')
+ *
+ * ```
+ * const colour = { h: 0.5, s: 0.5, l: 0.5, space: `hsl`, unit: `scalar` };
+ * changeLightness(colour, { pdelta: 0.1 }); // l: 0.55
+ * changeLightness(colour, { delta: 0.1 });  // l: 0.6
+ * changeLightness(colour, { fixed: 0.5 });  // l: 0.5
+ * ```
+ *
+ * Keep in mind the numerical value will depend on the unit of `value`. If it's scalar,
+ * lightness is 0..1 scale, otherwise 0..100 scale.
+ *
+ * Use negative values to decrease (does not apply to 'fixed')
+ * @param value Hsl colour
+ * @param amount Amount to change
+ */
+declare function changeLightness$1(value: Hsl, amount: Partial<{
+  pdelta: number;
+  delta: number;
+  fixed: number;
+}>): Hsl;
+declare function fromHexString$3<T extends ParsingOptions<Hsl>>(hexString: string, scalar: T): T extends {
+  scalar: true;
+} ? HslScalar : HslAbsolute;
+declare function fromCss$3<T extends ParsingOptions<Hsl>>(value: string, options?: T): T extends {
+  scalar: true;
+} ? HslScalar : HslAbsolute;
+declare function toCssString$2(hsl: Hsl): string;
+declare function toHexString$3(hsl: Hsl): string;
+declare function toAbsolute$1(hslOrString: Hsl | Rgb | string): HslAbsolute;
+/**
+ * Generates a {@link HslScalar} value.
+ *
+ * ```js
+ * generateScaler(10); // 10deg, default to full saturation, half lightness and full opacity
+ *
+ * // Generate HSL value from radian angle and 50% saturation
+ * generateScalar(`10rad`, 0.5);
+ *
+ * // Generate from numeric CSS variable
+ * generateScalar(`--hue`);
+ * ```
+ * @param absoluteHslOrVariable Hue angle or CSS variable
+ * @param saturation
+ * @param lightness
+ * @param opacity
+ */
+declare function generateScalar$1(absoluteHslOrVariable: string | number | Angle, saturation?: number, lightness?: number, opacity?: number): HslScalar;
+/**
+ * Converts a {@link Hsl} value to scalar units, or parses a colour string
+ * and converts it.
+ *
+ * ```js
+ * toScalar({ h: 100, s: 50, l: 100, unit: `absolute` });
+ * toScalar(`red`);
+ * ```
+ * @param colour
+ */
+declare function toScalar$3(colour: Rgb | Hsl | string): HslScalar;
+declare function guard$3(hsl: Hsl): void;
+declare function interpolator$3(a: Hsl | string, b: Hsl | string, direction?: `longer` | `shorter`): (amount: number) => HslScalar;
+/**
+ * Creates a HslScalar value from scalar (0..1) values
+ * @param hue
+ * @param sat
+ * @param lightness
+ * @param opacity
+ */
+declare function scalar$3(hue?: number, sat?: number, lightness?: number, opacity?: number): HslScalar;
+declare function absolute$1(hue?: number, sat?: number, lightness?: number, opacity?: number): HslAbsolute;
+/**
+ * It seems Colorizr can't handle 'deg' units
+ * @param value
+ */
+declare function parseCssHslFunction(value: string): Hsl;
+/**
+ * Converts a Hsl structure (or CSS string) to Colorizr's RGB format
+ * @param hsl HSL colour
+ */
+declare function toLibraryRgb(hsl: Hsl | string): RGB;
+//#endregion
+//#region src/colour/interpolate.d.ts
+/**
+ * Returns a function to interpolate between colours, with results as a structured {@link Colour} object.
+ * ```js
+ * const i = interpolator([`orange`, `yellow`, `red`]);
+ *
+ * // Get a random colour on the above spectrum
+ * i(Math.random());
+ * ```
+ *
+ * Results will vary depending on the colour space used, play with the options.
+ * When using a hue-based colour space, the `hue` option sets the logic for how hue values wrap.
+ *
+ * ```js
+ * interpolator([`orange`, `yellow`, `red`], { space: `hsl`, hue: `longer })
+ * ```
+ *
+ * Example: Draw the interpolation as a spectrum on a canvas, where each pixel is one step
+ * ```js
+ * let v = 0;
+ * let incrementBy = 0.01;
+ * while (v <= 1) {
+ *  // Get colour at this interpolation point 0..1
+ *  const colour = fn(v);
+ *  // Convert to a CSS string
+ *  ctx.fillStyle = Colour.toCssColour(colour);
+ *  // Draw a 1px wide rect, and shuffle along to the next x position
+ *  ctx.fillRect(x, y, 1, h);
+ *  x += 1;
+ *  v += incrementBy;
+ * }
+ * ```
+ * @param colours Colours to interpolate between
+ * @param opts Options for interpolation
+ * @returns Function that interpolates based on an amount, returning a structured Colour
+ */
+declare function interpolator$2(colours: Colourish[], opts?: Partial<ColourInterpolationOpts>): (amt: number) => Colour;
+/**
+ * Returns a CSS `linear-gradient` with stops corresponding to the given list of `colours`.
+ * ```js
+ * element.style.background = Colour.cssLinearGradient(['red','green','blue']);
+ * ```
+ * @param colours
+ * @returns A 'linear-gradient' string for use in CSS, eg for background.
+ */
+declare function cssLinearGradient(colours: Colourish[]): string;
+/**
+ * Returns a function that interpolates between two colours. Returns string colour values.
+ * If you want the result as a structured colour, use {@link interpolatorDual} instead.
+ *
+ * By default takes a shorter direction and uses the OkLCH colourspace.
+ * ```js
+ * const i = interpolator(`blue`, `red`);
+ * i(0.5); // Get the colour at 50%, as a string.
+ * ```
+ *
+ * To work with structured colour values, use one of the space's `interpolate` functions.
+ *
+ * If you want to create discrete steps, consider {@link createSteps} or {@link scale}.
+ *
+ * @param colourA First colour
+ * @param colourB Second colour
+ * @param options Interpolation options. By default uses shorter direction and OkLCH colour space.
+ */
+declare function interpolatorDualToString(colourA: Colourish, colourB: Colourish, options?: Partial<ColourInterpolationOpts>): ((amount: number) => string);
+/**
+ * Returns a function that interpolates between two colours. Returns structured colour values.
+ * If you want the result as a ready-to-use CSS string, use {@link interpolatorDualToString} instead.
+ *
+ * By default takes a shorter direction and uses the OkLCH colourspace.
+ * ```js
+ * const i = interpolator(`blue`, `red`);
+ * i(0.5); // Get the colour at 50%, as a Colour structure.
+ * ```
+ *
+ * If you want to create discrete steps, consider {@link createSteps} or {@link scale}.
+ * @param colourA First colour
+ * @param colourB Second colour
+ * @param options Interpolation options. By default uses shorter direction and OkLCH colour space.
+ * @returns Function that interpolates between two colours, returning a structured Colour
+ */
+declare function interpolatorDual(colourA: Colourish, colourB: Colourish, options?: Partial<ColourInterpolationOpts>): (amount: number) => Colour;
+/**
+ * Produces a stepped scale of colours.
+ *
+ * Builds off {@link createSteps} which can only step between two colours.
+ *
+ * ```js
+ * // A scale of from red to green, with three colours in-between
+ * const steps = Colour.scale([ `red`, `green` ], { stepsBetween: 3 });
+ * for (const step of steps) {
+ *  // A CSS colour string
+ * }
+ * ```
+ *
+ * {@link cssLinearGradient} can produce a smooth gradient in CSS on the basis
+ * of the stepped colours.
+ * @param colours
+ * @param opts
+ * @returns Array of colours in string form
+ */
+declare function scale(colours: Colourish[], opts?: Partial<ColourStepOpts>): string[];
+type CreateStepsOptions = Partial<{
+  space: ColourSpaces;
+  steps: number;
+  direction: `longer` | `shorter`;
+  exclusive: boolean;
+}>;
+/**
+ * Creates discrete colour steps between two colours.
+ *
+ * Use {@link scale} to create steps between any number of colours.
+ *
+ * Start and end colours are included (and counted as a step) unless `exclusive` is set to _true_
+ *
+ * ```js
+ * // Array of five HslScalar
+ * createSteps(`red`,`blue`, { steps: 5 });
+ * ```
+ *
+ * Defaults to the oklch colour space, 5 steps and non-exclusive.
+ * @param a Start colour
+ * @param b End colour
+ * @param options
+ * @returns Colour steps
+ */
+declare function createSteps<T extends CreateStepsOptions>(a: Colourish | string, b: Colourish, options: T): T extends {
+  space: `oklch`;
+} ? OkLchScalar[] : T extends {
+  space: `srgb`;
+} ? RgbScalar[] : T extends {
+  space: `hsl`;
+} ? HslScalar[] : OkLchScalar[];
+//#endregion
+//#region src/colour/math.d.ts
+declare function multiplyOpacity<T extends Colourish>(colourish: T, amount: number): T extends string ? string : T extends Hsl ? Hsl : T extends OkLch ? OkLch : T extends Rgb ? Rgb : never;
+/**
+ * Does a computation with the opacity of a colour, returning colour string
+ * @param colourish Colour
+ * @param fn Function that takes original opacity as input and returns output opacity
+ */
+/**
+ * Does a computation with the opacity of a colour in a HSL structure
+ * @param hsl Colour
+ * @param fn Function that takes original opacity as input and returns output opacity
+ */
+/**
+ * Does a computation with the opacity of a colour in a RGB structure
+ * @param colourish Colour
+ * @param fn Function that takes original opacity as input and returns output opacity
+ */
+declare function withOpacity$2<T extends Colourish>(colourish: T, fn: (scalarOpacity: number) => number): T extends string ? string : T extends Hsl ? Hsl : T extends OkLch ? OkLch : T extends Rgb ? Rgb : never;
+declare function setOpacity<T extends Colourish>(colourish: T, amount: number): T extends string ? string : T extends Hsl ? Hsl : T extends OkLch ? OkLch : T extends Rgb ? Rgb : never;
+declare namespace oklch_d_exports {
+  export { OKLCH_CHROMA_MAX, absolute, fromCss$2 as fromCss, fromHexString$2 as fromHexString, fromLibrary, generateScalar, guard$2 as guard, interpolator$1 as interpolator, scalar$2 as scalar, toAbsolute, toCssString$1 as toCssString, toHexString$2 as toHexString, toScalar$2 as toScalar, withOpacity$1 as withOpacity };
 }
-interface Checkbox {
-  addEventListener: (<K extends keyof CheckboxEventMap>(type: K, listener: (this: Checkbox, event: CheckboxEventMap[K]) => void, options?: boolean | AddEventListenerOptions) => void) & ((type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions) => void);
+declare const OKLCH_CHROMA_MAX = .4;
+declare function guard$2(lch: OkLch): void;
+/**
+ * Coverts from the Colorizr library
+ * Tests ranges:
+ * l: 0..1
+ * c: 0..1
+ * h: 0..360
+ * alpha: 0..1
+ *
+ * Default option: { scalar: true }
+ * @param lch LCH value
+ * @param parsingOptions Options for parsing
+ */
+declare function fromLibrary<T extends ParsingOptions<OkLch>>(lch: LCH, parsingOptions: T): T extends {
+  scalar: true;
+} ? OkLchScalar : OkLchAbsolute;
+/**
+ * Parse a HEX-formatted colour into OkLch structured format
+ * @param hexString
+ * @param options
+ */
+declare function fromHexString$2(hexString: string, options?: ParsingOptions<OkLch>): OkLch;
+/**
+ * Converts from some CSS-representation of colour to a structured OkLch format.
+ *
+ * ```js
+ * fromCss(`yellow`);
+ * fromCss(`rgb(100,200,90)`);
+ * fromCss(`#ff00ff`);
+ * ```
+ *
+ * By default returns a {@link OkLchScalar} (relative) representation. Use the flag 'scalar:true' to get back
+ * {@link OkLchAbsolute}.
+ * @param value
+ * @param options
+ */
+declare function fromCss$2<T extends ParsingOptions<OkLch>>(value: string, options: T): T extends {
+  scalar: true;
+} ? OkLchScalar : OkLchAbsolute;
+/**
+ * Returns a string or {@link OkLch} value to absolute form.
+ *
+ * This means ranges are:
+ * lightness: 0..1
+ * chroma: 0...CHROMA_MAX (0.4)
+ * hue: 0..360
+ * @param lchOrString
+ */
+declare function toAbsolute(lchOrString: OkLch | string): OkLchAbsolute;
+declare function toScalar$2(lchOrString: OkLch | string): OkLchScalar;
+/**
+ * Returns the colour as a CSS colour string: `oklch(l c h / opacity)`.
+ *
+ * @param lch Colour
+ * @param precision Set precision of numbers, defaults to 3
+ * @returns CSS colour string
+ */
+declare function toCssString$1(lch: OkLch, precision?: number): string;
+declare function toHexString$2(lch: OkLch): string;
+declare function generateScalar(absoluteHslOrVariable: string | number | Angle, chroma?: number, lightness?: number, opacity?: number): OkLchScalar;
+/**
+ * Scales the opacity value of an input Oklch value
+ * ```js
+ * withOpacity()
+ * ```
+ * @param value
+ * @param fn
+ */
+declare function withOpacity$1<T extends OkLch>(value: T, fn: (opacityScalar: number, value: T) => number): T;
+declare function interpolator$1(a: OkLch | string, b: OkLch | string, direction?: `longer` | `shorter`): (amount: number) => OkLchScalar;
+declare function scalar$2(lightness?: number, chroma?: number, hue?: number, opacity?: number): OkLchScalar;
+/**
+ * Create an LCH colour using absolute hue
+ * @param l Lightness 0..1
+ * @param c Chroma 0..4
+ * @param h Hue 0..360
+ * @param opacity
+ */
+declare function absolute(l: number, c: number, h: number, opacity?: number): OkLchAbsolute;
+declare namespace srgb_d_exports {
+  export { changeLightness, eightBit$1 as eightBit, fromCss$1 as fromCss, fromHexString$1 as fromHexString, guard$1 as guard, interpolator, lightness, parseCssRgbFunction, scalar$1 as scalar, to8bit$1 as to8bit, toCssString, toHexString$1 as toHexString, toLibraryHsl, toScalar$1 as toScalar, withOpacity };
 }
+declare function withOpacity<T extends Rgb>(value: T, fn: (opacityScalar: number, value: T) => number): T;
+declare function fromHexString$1<T extends boolean>(hexString: string, scalar: T): T extends true ? RgbScalar : Rgb8Bit;
+declare function fromCss$1<T extends ParsingOptions<Rgb>>(value: string, options: T): T extends {
+  scalar: true;
+} ? RgbScalar : Rgb8Bit;
+declare function toHexString$1(rgb: Rgb): string;
+declare function toCssString(rgb: Rgb): string;
+declare function to8bit$1(rgbOrString: Rgb | string): Rgb8Bit;
+declare function toScalar$1(rgbOrString: Rgb | Hsl | string): RgbScalar;
+declare function guard$1(rgb: Rgb): void;
+/**
+ * Sets the lightness value.
+ *
+ * Amount to change:
+ * 'fixed': a fixed amount
+ * 'delta': increase/decrease by this amount
+ * 'pdelta': proportion of current value to change by ('percentage delta')
+ *
+ * Use negative values to decrease
+ * @param rgb Colour
+ * @param amount Amount to change
+ */
+declare function changeLightness(rgb: Rgb, amount: Partial<{
+  pdelta: number;
+  delta: number;
+  fixed: number;
+}>): Rgb;
+/**
+ * Returns a lightness value (0..1) for an RGB input
+ *
+ * Calculates lightness by converting to Oklab and using the 'L' value
+ * @param rgb
+ */
+declare function lightness(rgb: Rgb): number;
+/**
+ * Creates a Rgb8Bit value from 8bit (0..255) values
+ * @param red
+ * @param green
+ * @param blue
+ * @param opacity
+ */
+declare function eightBit$1(red?: number, green?: number, blue?: number, opacity?: number): Rgb8Bit;
+/**
+ * Creates a RgbScalar value from scalar (0..1) values
+ * @param red
+ * @param green
+ * @param blue
+ * @param opacity
+ */
+declare function scalar$1(red?: number, green?: number, blue?: number, opacity?: number): RgbScalar;
+/**
+ * It seems Colorizr can't handle % values properly :'(
+ * @param value
+ */
+declare function parseCssRgbFunction(value: string): Rgb;
+/**
+ * Interpolates colours in Srgb space. Probably
+ * really ugly, use OkLch space isntead.
+ *
+ * ```js
+ * const i = interpolator(`red`, `blue`);
+ * i(0.5); // Get 50% between these colours
+ * ```
+ * @param colourA
+ * @param colourB
+ */
+declare function interpolator(colourA: Rgb | string, colourB: Rgb | string): (amount: number) => RgbScalar;
+/**
+ * Converts a Rgb structure (or CSS string) to Colorizr's HSL format
+ * @param rgb
+ */
+declare function toLibraryHsl(rgb: Rgb | string): HSL;
 //#endregion
-//#region src/checked-select/types.d.ts
-type CheckState = `true` | `false` | `indeterminate`;
-type CheckedSelectItem = {
-  readonly value: string;
-  readonly label: string;
-  readonly checked: CheckState;
-};
-type ItemDisplay = `checkbox` | `text`;
-type ItemOrientation = `horizontal` | `vertical`;
-//#endregion
-//#region src/checked-select/checked-select.d.ts
-declare class CheckedSelect extends LitElement {
-  #private;
-  static styles: import("lit").CSSResult[];
-  items: readonly CheckedSelectItem[];
-  multiline: boolean;
-  /** At-rest checkboxes are display-only; clicking them just opens the popup. (Not `inert`: that native attribute would block the whole element.) */
-  itemsInert: boolean;
-  /** How at-rest items are shown: as `checkbox`es, or as comma-separated `text`. */
-  itemDisplay: ItemDisplay;
-  /** Direction the resting items flow: `horizontal` (default) or `vertical` (one per row). */
-  orientation: ItemOrientation;
-  placeholder: string;
-  disabled: boolean;
-  private _open;
-  private _draft;
-  private _order;
-  private _size;
-  get isOpen(): boolean;
-  disconnectedCallback(): void;
-  willUpdate(changed: PropertyValues): void;
-  open(): Promise<void>;
-  commit(): void;
-  cancel(): void;
-  protected render(): import("lit").TemplateResult<1>;
-}
-type CheckedSelectChangeDetail = {
-  /** Every item, with its committed state. */
-  readonly items: readonly CheckedSelectItem[];
-  /** Only the items whose state changed. */
-  readonly changed: readonly CheckedSelectItem[];
-};
-type CheckedSelectChangeEvent = CustomEvent<CheckedSelectChangeDetail>;
-declare global {
-  interface HTMLElementTagNameMap {
-    'ixfx-checked-select': CheckedSelect;
-  }
-}
-interface CheckedSelectEventMap {
-  change: CheckedSelectChangeEvent;
-}
-interface CheckedSelect {
-  addEventListener: (<K extends keyof CheckedSelectEventMap>(type: K, listener: (this: CheckedSelect, event: CheckedSelectEventMap[K]) => void, options?: boolean | AddEventListenerOptions) => void) & ((type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions) => void);
+//#region src/colour/to-integer.d.ts
+/**
+ * Encode 8-bit RGB values into a 24-bit value (0...16_777_215)
+ *
+ * Assumes RGB values are within 0..255 range
+ * @param rgb
+ * @returns
+ */
+declare function encodeRgbTo24Bit(rgb: Rgb8Bit | RgbBase): number;
+/**
+ * Decode a 24-bit number (0...16_777_215) into 8-bit RGB
+ * @param colour
+ * @returns
+ */
+declare function decodeRgbFrom24Bit(colour: number): Rgb8Bit;
+/**
+ * Encodes 8-bit RGB value into 16-bit RGB565 (0..65_535)
+ * 5-bit are used for R & B channels, 6 bits for G
+ *
+ * Read more: https://rgbcolorpicker.com/565
+ * @param rgb
+ * @returns
+ */
+declare function encodeRgbTo16Bit565(rgb: Rgb8Bit | RgbBase): number;
+/**
+ * Decodes 8-bit RGB value from a 16-bit RGB565 value (0...65_535)
+ * Read more: https://rgbcolorpicker.com/565
+ * @param colour
+ * @returns
+ */
+declare function decodeRgbFrom16Bit565(colour: number): Rgb8Bit;
+declare namespace ycbcr_d_exports {
+  export { eightBit, fromCss, fromHexString, fromSrgTo8bit, guard, scalar, to8bit, toHexString, toScalar, toSrgb8bit };
 }
-//#endregion
-//#region src/colour-picker/types.d.ts
 /**
- * OKLCH colour value representation
+ * Creates a YCbCr8bit value from 8bit (0..255) values
+ * @param y Luma 0..255
+ * @param cb Chroma blue 0..255
+ * @param cr Chroma red 0..255
+ * @param opacity 0..255
+ * @returns YCbCr8bit
  */
-type OklchValue = {
-  readonly l: number;
-  readonly c: number;
-  readonly h: number;
-  readonly a?: number;
-  readonly unit: `scalar`;
-  readonly space: `oklch`;
-};
+declare function eightBit(y?: number, cb?: number, cr?: number, opacity?: number): YCbCr8bit;
 /**
- * Event detail for colour picker input/change events
+ * Creates a YCbCr8bit value from scalar (0..1) values
+ * @param y Luma 0..1
+ * @param cb Chroma blue 0..1
+ * @param cr Chroma red 0..1
+ * @param opacity 0..1
+ * @returns YCbCrScalar
  */
-type ColourPickerEventDetail = OklchValue;
+declare function scalar(y?: number, cb?: number, cr?: number, opacity?: number): YCbCrScalar;
 /**
- * Colour picker custom events
+ * Converts from scalar or 8bit RGB to YCbCr8bit
+ * @param rgb
+ * @returns
  */
-type ColourPickerInputEvent = CustomEvent<ColourPickerEventDetail>;
-type ColourPickerChangeEvent = CustomEvent<ColourPickerEventDetail>;
-type Range = readonly [number, number];
-type RangeInput$1 = readonly [number, number] | readonly number[];
+declare function fromSrgTo8bit(rgb: Rgb): YCbCr8bit;
+declare function toSrgb8bit(ycbcr: YCbCr): Rgb8Bit;
 /**
- * Augment HTMLElementTagNameMap for the custom element
+ * Returns a YCbCr8bit format from either scalar or 8bit.
+ * If the input is already 8bit, it is returned as-is.
+ * @param ycbcr 8bit or scalar YCbCr value
+ * @returns YCbCr8bit
  */
-declare global {
-  interface HTMLElementTagNameMap {
-    'ixfx-colour-picker': ColourPicker;
-  }
+declare function to8bit(ycbcr: YCbCr): YCbCr8bit;
+declare function fromHexString<T extends ParsingOptions<YCbCr>>(hexString: string, scalar: T): T extends {
+  scalar: true;
+} ? YCbCrScalar : YCbCr8bit;
+declare function fromCss<T extends ParsingOptions<YCbCr>>(value: string, options: T): T extends {
+  scalar: true;
+} ? YCbCrScalar : YCbCr8bit;
+declare function toScalar(colour: YCbCr | Rgb | string): YCbCrScalar;
+declare function guard(rgb: YCbCr): void;
+/**
+ * Converts a YCbCr colour to a RGB hex string.
+ * @param ycbcr
+ * @returns
+ */
+declare function toHexString(ycbcr: YCbCr): string;
+declare namespace index_d_exports$1 {
+  export { Colour, ColourInterpolationOpts, ColourInterpolator, ColourSpaces, ColourStepOpts, Colourish, ConvertDestinations, CreateStepsOptions, CssColourNames, Hsl, HslAbsolute, HslBase, HslScalar, hsl_d_exports as HslSpace, LchBase, OkLch, OkLchAbsolute, OkLchBase, OkLchScalar, oklch_d_exports as OklchSpace, ParsingOptions, Rgb, Rgb8Bit, RgbBase, RgbScalar, srgb_d_exports as SrgbSpace, YCbCr, YCbCr8bit, YCbCrBase, YCbCrScalar, ycbcr_d_exports as YCbCrSpace, convert, convertScalar, convertToString, createSteps, cssDefinedHexColours, cssLinearGradient, decodeRgbFrom16Bit565, decodeRgbFrom24Bit, encodeRgbTo16Bit565, encodeRgbTo24Bit, fromCssColour, goldenAngleColour, guard$4 as guard, interpolator$2 as interpolator, interpolatorDual, interpolatorDualToString, isColourish, isHsl, isOkLch, isRgb, multiplyOpacity, randomHue, resolveCss, rgbToHsl, scale, setOpacity, toColour, toCssColour, toHexColour, toLibraryColour, toStringFirst, tryParseObjectToHsl, tryParseObjectToRgb, withOpacity$2 as withOpacity };
 }
 //#endregion
 //#region src/mixins/labelled-input-base.d.ts
@@ -898,7 +2162,7 @@ declare class ColourPicker extends LitElement {
    * HSL object, etc.). Also updates the double-click reset defaults for all
    * sliders.
    */
-  setColour(colour: Colour.Colourish): void;
+  setColour(colour: index_d_exports$1.Colourish): void;
   get rangeL(): Range;
   set rangeL(range: RangeInput$1);
   get rangeC(): Range;
@@ -987,10 +2251,10 @@ declare class ColourPickerPopup extends LitElement {
   private _pendingConfirmed;
   constructor();
   get value(): string;
-  set value(colour: Colour.Colourish);
+  set value(colour: index_d_exports$1.Colourish);
   private get _innerHidePreview();
   private get _pickerDimensions();
-  setColour(colour: Colour.Colourish): void;
+  setColour(colour: index_d_exports$1.Colourish): void;
   firstUpdated(changedProperties: PropertyValues): void;
   updated(changedProperties: PropertyValues): void;
   private _applyAnchorPositioning;
@@ -2095,6 +3359,181 @@ type DataGridGroupLabel = (groupKey: string, rows: readonly unknown[]) => string
 /** Whether the data-grid renders its built-in header column/group menu. */
 type DataGridColumnMenu = `auto` | `none`;
 //#endregion
+//#region node_modules/.pnpm/fzf@0.5.2/node_modules/fzf/dist/types/slab.d.ts
+interface Slab {
+  i16: Int16Array;
+  i32: Int32Array;
+}
+//#endregion
+//#region node_modules/.pnpm/fzf@0.5.2/node_modules/fzf/dist/types/numerics.d.ts
+type Int32 = Int32Array[0];
+//#endregion
+//#region node_modules/.pnpm/fzf@0.5.2/node_modules/fzf/dist/types/runes.d.ts
+type Rune = Int32;
+//#endregion
+//#region node_modules/.pnpm/fzf@0.5.2/node_modules/fzf/dist/types/algo.d.ts
+interface Result {
+  start: number;
+  end: number;
+  score: number;
+}
+type AlgoFn = (caseSensitive: boolean, normalize: boolean, forward: boolean, input: Rune[], pattern: Rune[], withPos: boolean, slab: Slab | null) => [Result, Set<number> | null];
+//#endregion
+//#region node_modules/.pnpm/fzf@0.5.2/node_modules/fzf/dist/types/types.d.ts
+type Casing = "smart-case" | "case-sensitive" | "case-insensitive";
+interface FzfResultItem<U = string> extends Result {
+  item: U;
+  positions: Set<number>;
+}
+type Selector<U> = BaseOptions<U>["selector"];
+type Tiebreaker<U> = (a: FzfResultItem<U>, b: FzfResultItem<U>, selector: Selector<U>) => number;
+interface BaseOptions<U> {
+  /**
+   * If `limit` is 32, top 32 items that matches your query will be returned.
+   * By default all matched items are returned.
+   *
+   * @defaultValue `Infinity`
+   */
+  limit: number;
+  /**
+   * For each item in the list, target a specific property of the item to search for.
+   */
+  selector: (v: U) => string;
+  /**
+   * Defines what type of case sensitive search you want.
+   *
+   * @defaultValue `"smart-case"`
+   */
+  casing: Casing;
+  /**
+   * If true, FZF will try to remove diacritics from list items.
+   * This is useful if the list contains items with diacritics but
+   * you want to query with plain A-Z letters.
+   *
+   * @example
+   * Zoë →  Zoe
+   * blessèd →  blessed
+   *
+   * @defaultValue `true`
+   */
+  normalize: boolean;
+  /**
+   * Fuzzy algo to choose. Each algo has their own advantages, see here:
+   * https://github.com/junegunn/fzf/blob/4c9cab3f8ae7b55f7124d7c3cf7ac6b4cc3db210/src/algo/algo.go#L5
+   * If asssigned `false`, an exact match will be made instead of a fuzzy one.
+   *
+   * @defaultValue `"v2"`
+   */
+  fuzzy: "v1" | "v2" | false;
+  /**
+   * A list of functions that act as fallback and help to
+   * sort result entries when the score between two entries is tied.
+   *
+   * Consider a tiebreaker to be a [JS array sort](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort)
+   * compare function with an added third argument which is `options.selector`.
+   *
+   * If multiple tiebreakers are given, they are evaluated left to right until
+   * one breaks the tie.
+   *
+   * Note that tiebreakers cannot be used if `sort=false`.
+   *
+   * FZF ships with these tiebreakers:
+   * - `byLengthAsc`
+   * - `byStartAsc`
+   *
+   * @defaultValue `[]`
+   *
+   * @example
+   * ```js
+   * function byLengthAsc(a, b, selector) {
+   *   return selector(a.item).length - selector(b.item).length;
+   * }
+   *
+   * const fzf = new Fzf(list, { tiebreakers: [byLengthAsc] })
+   * ```
+   * This will result in following result entries having same score sorted like this:
+   *    FROM                TO
+   * axaa                axaa
+   * bxbbbb              bxbbbb
+   * cxcccccccccc        dxddddddd
+   * dxddddddd           cxcccccccccc
+   */
+  tiebreakers: Tiebreaker<U>[];
+  /**
+   * If `true`, result items will be sorted in descending order by their score.
+   *
+   * If `false`, result items won't be sorted and tiebreakers won't affect the
+   * sort order either. In this case, the items are returned in the same order
+   * as they are in the input list.
+   *
+   * @defaultValue `true`
+   */
+  sort: boolean;
+  /**
+   * If `false`, matching will be done from backwards.
+   *
+   * @defaultValue `true`
+   *
+   * @example
+   * /breeds/pyrenees when queried with "re"
+   * with forward=true  : /b**re**eds/pyrenees
+   * with forward=false : /breeds/py**re**nees
+   *
+   * Doing forward=false is useful, for example, if one needs to match a file
+   * path and they prefer querying for the file name over directory names
+   * present in the path.
+   */
+  forward: boolean;
+}
+type SyncOptions<U> = BaseOptions<U> & {
+  /**
+   * A function that is responsible for matching list items with the query.
+   *
+   * We ship with two match functions - `basicMatch` and `extendedMatch`.
+   *
+   * If `extendedMatch` is used, you can add special patterns to narrow down your search.
+   * To read about how they can be used, see [this section](https://github.com/junegunn/fzf/tree/7191ebb615f5d6ebbf51d598d8ec853a65e2274d#search-syntax).
+   * For a quick glance, see [this piece](https://github.com/junegunn/fzf/blob/764316a53d0eb60b315f0bbcd513de58ed57a876/src/pattern.go#L12-L19).
+   *
+   * @defaultValue `basicMatch`
+   */
+  match: (this: SyncFinder<ReadonlyArray<U>>, query: string) => FzfResultItem<U>[];
+};
+//#endregion
+//#region node_modules/.pnpm/fzf@0.5.2/node_modules/fzf/dist/types/finders.d.ts
+type ArrayElement<ArrayType extends readonly unknown[]> = ArrayType extends readonly (infer ElementType)[] ? ElementType : never;
+type SortAttrs<U> = {
+  sort?: true;
+  tiebreakers?: Tiebreaker<U>[];
+} | {
+  sort: false;
+};
+type BaseOptsToUse<U> = Omit<Partial<BaseOptions<U>>, "sort" | "tiebreakers"> & SortAttrs<U>;
+type BaseOptionsTuple<U> = U extends string ? [options?: BaseOptsToUse<U>] : [options: BaseOptsToUse<U> & {
+  selector: Selector<U>;
+}];
+declare abstract class BaseFinder<L extends ReadonlyArray<any>> {
+  runesList: Rune[][];
+  items: L;
+  readonly opts: BaseOptions<ArrayElement<L>>;
+  algoFn: AlgoFn;
+  constructor(list: L, ...optionsTuple: BaseOptionsTuple<ArrayElement<L>>);
+}
+type SyncOptsToUse<U> = BaseOptsToUse<U> & Partial<Pick<SyncOptions<U>, "match">>;
+type SyncOptionsTuple<U> = U extends string ? [options?: SyncOptsToUse<U>] : [options: SyncOptsToUse<U> & {
+  selector: Selector<U>;
+}];
+declare class SyncFinder<L extends ReadonlyArray<any>> extends BaseFinder<L> {
+  readonly opts: SyncOptions<ArrayElement<L>>;
+  constructor(list: L, ...optionsTuple: SyncOptionsTuple<ArrayElement<L>>);
+  find(query: string): FzfResultItem<ArrayElement<L>>[];
+}
+//#endregion
+//#region node_modules/.pnpm/fzf@0.5.2/node_modules/fzf/dist/types/main.d.ts
+type FzfOptions<U = string> = U extends string ? SyncOptsToUse<U> : SyncOptsToUse<U> & {
+  selector: SyncOptions<U>["selector"];
+};
+//#endregion
 //#region src/incr-search/types.d.ts
 type IncrSearchResult<T> = {
   readonly item: T;
@@ -2333,6 +3772,8 @@ declare class ListSearchController<TItem> implements ReactiveController {
   commit(): void;
   /** Rebuild the searchable item set from the adapter. Called on open and on container mutation. */
   refresh(): void;
+  /** Re-paint highlights without rebuilding the item set. Use when the rendered window changes. */
+  repaintHighlights(): void;
   /** Popover markup. Pair with `listSearchStyles` in the host's `static styles`. */
   renderField(): TemplateResult | typeof nothing;
 }
@@ -2377,6 +3818,7 @@ declare function createDataListSearchAdapter(host: {
 interface ElementListSearchHost extends HTMLElement {
   focusKey: (key: string) => void;
   selectKeys: (keys: Iterable<string>) => void;
+  activateKey?: (key: string) => void;
 }
 interface ElementListSearchAdapterOptions {
   /** Selector for item elements, relative to the host. Default `:scope > *`. */
@@ -2385,6 +3827,10 @@ interface ElementListSearchAdapterOptions {
   getKey?: (el: Element) => string;
   /** `CSS.highlights` registry key for matched-character highlights. */
   highlightKey?: string;
+  /** Full ordered item set, including rows not currently in the DOM (virtualised hosts). Defaults to querying `itemSelector`. */
+  getAllItems?: () => Element[];
+  /** Observe host child-list mutations to refresh the item set. Default true. */
+  observeContainer?: boolean;
 }
 /**
  * A {@link ListSearchAdapter} over the light-DOM item elements of a list
@@ -2813,9 +4259,9 @@ declare class DataGridElement extends LitElement {
   groupableColumns: string[] | undefined;
   crossGroupSelection: boolean;
   /**
-   * `auto` (default): render the built-in header column/group menu.
-   * `none`: don't render it — for hosts that supply their own column UI via
-   * `column.visible` + `datagrid-column-visibility`.
+   * `none` (default): don't render the built-in header column/group menu — hosts can
+   * supply their own column UI via `column.visible` + `datagrid-column-visibility`.
+   * `auto`: opt in to the built-in menu.
    */
   columnMenu: DataGridColumnMenu;
   globalFormatter?: GlobalFormatter;
@@ -2868,7 +4314,9 @@ declare class DataGridElement extends LitElement {
   private _resizingColKey;
   private _animatingColKeys;
   private _selectedKeys;
+  /** Not reactive: `_onScroll` only re-renders when the row window actually moves. */
   private _scrollTop;
+  /** Not reactive: columns aren't virtualised, so render never reads it. */
   private _scrollLeft;
   private _viewportH;
   private _viewportW;
@@ -2879,7 +4327,7 @@ declare class DataGridElement extends LitElement {
   private _lastClickedCell;
   private _editValue;
   private _viewportEl;
-  private _headerScrollEl;
+  private _headerRowEl;
   private _tickled;
   private _sortedRows;
   private _flat;
@@ -3574,6 +5022,7 @@ declare class VerticalListElement extends LitElement {
   private _onClick;
   private _onDblClick;
   private _activateItem;
+  activateKey(key: string): void;
   private _onDragOver;
   private _onDragLeave;
   private _onDrop;
@@ -3826,6 +5275,10 @@ declare class DetailListElement extends LitElement {
   toggleGroup(groupKey: string): void;
   collapseAllGroups(): void;
   expandAllGroups(): void;
+  /**
+   * Visible items in DOM order. Cached — every per-hover / per-frame path
+   * reads it — and validated on each call, so it is never stale.
+   */
   private _getVisibleItems;
   /**
    * Set the column width to fit the widest visible item.
@@ -3839,6 +5292,11 @@ declare class DetailListElement extends LitElement {
   private _isCheckable;
   /** Appends the caption span; returns it so callers can style it per item. */
   private _setLabel;
+  /**
+   * Reflect cursor / selection / checked state onto the items. After the item
+   * set changes (or the interaction mode does) every item is visited; otherwise
+   * only the items whose state changed are touched, so hovering is O(1).
+   */
   private _syncItemStates;
   private _syncCheckboxes;
   /**
@@ -4355,9 +5813,8 @@ declare class TabListItemElement extends LitElement {
   private _compact;
   private _hasToolbarContent;
   private _hasStatusContent;
-  private _resizeObserver?;
   private _commandCleanup?;
-  private _labelObserver;
+  private _onLabelMutation;
   connectedCallback(): void;
   disconnectedCallback(): void;
   updated(changed: PropertyValues): void;
@@ -6353,6 +7810,13 @@ declare class GridListElement<T = unknown> extends LitElement {
    * Auto-assigned keyless-item keys are omitted.
    */
   visibleKeys(): string[];
+  /**
+   * Mirror cursor / selection onto the light-DOM items as `data-tickled` /
+   * `data-selected`. Only the items whose state changed are touched, so a
+   * cursor move costs O(selection), not O(items). `full` re-checks every item —
+   * used when the child list changes, so markers set before the item was
+   * ours (or left on a removed item) are corrected.
+   */
   private _syncItemStates;
   private _dispatch;
   protected render(): ReturnType<typeof html>;
@@ -6523,6 +7987,11 @@ interface GroupedItemListerElement<T> {
 }
 //#endregion
 //#region src/tree/tree-base.d.ts
+/**
+ * `auto` windows the list once it has more than `virtualizeThreshold` visible
+ * rows; `on` / `off` force it.
+ */
+type TreeVirtualize = `auto` | `on` | `off`;
 declare class TreeBaseElement extends LitElement implements TreeComponent, TreeSearchHost {
   #private;
   root: TreeNode | undefined;
@@ -6562,13 +8031,37 @@ declare class TreeBaseElement extends LitElement implements TreeComponent, TreeS
    * expansion. On by default — set `sticky-headers="false"` to opt out.
    */
   stickyHeaders: boolean;
+  /**
+   * Windowed rendering: only the rows near the viewport exist in the DOM, so a
+   * node with tens of thousands of children stays fast. `auto` (default)
+   * switches on above `virtualizeThreshold` visible rows; `on` / `off` force it.
+   * While windowed, rows are a fixed `--tree-item-height` tall and expand /
+   * collapse rows do not animate.
+   */
+  virtualize: TreeVirtualize;
+  /** Visible-row count above which `virtualize="auto"` windows the list. */
+  virtualizeThreshold: number;
   dragPreviewRenderer: ListDragPreviewRenderer<TreeNode> | undefined;
   dragPreviewSource: ListDragPreviewSourceResolver<TreeNode> | undefined;
   canDrag: ((ctx: TreeDragContext) => boolean) | undefined;
   canDrop: ((ctx: TreeDropContext) => boolean) | undefined;
   parseExternalDrop: ((dt: DataTransfer) => TreeNode[] | undefined) | undefined;
   applyInternalDrop: boolean;
-  protected _expandedKeys: Set<string>;
+  /** Immutable: replace via `#setExpanded` so the flat-row cache is invalidated. */
+  protected _expandedKeys: ReadonlySet<string>;
+  /** Bumped whenever `_selectedNodes` content may have changed. */
+  protected _selectionVersion: number;
+  /**
+   * Call after editing `node.children` / `node.item` in place (outside
+   * `TreeDataModel`). Drops the cached whole-tree indexes and re-renders.
+   */
+  invalidateStructure(): void;
+  /** Scroll offset used for the last render; kept in sync with the container's. */
+  private _scrollTop;
+  /** Structure version for cache keys in subclasses (bumped on root / model change and lazy loads). */
+  protected get _structureVersion(): number;
+  /** Depths at which any loaded node carries an icon (stable across expansion). */
+  protected get _depthsWithIcons(): ReadonlySet<number>;
   protected tickled: TickledController<string>;
   protected _focusedDepth: number;
   /** Incremental search (navigate / select / filter). See `docs/infra-incremental.md`. */
@@ -6589,10 +8082,11 @@ declare class TreeBaseElement extends LitElement implements TreeComponent, TreeS
   /** True while `node` is a fading ghost row (removed / collapsed, still animating out). */
   protected _isLeaving(node: TreeNode): boolean;
   /**
-   * True when `filterPredicate` is set and neither `node` nor any descendant
-   * matches — the row should carry the `filtered` class (`display: none`).
+   * Kept for subclass compatibility. Filtered-out rows are no longer rendered
+   * at all (they are omitted from the flat list), so this is `false` for every
+   * rendered row.
    */
-  protected _isFilteredOut(node: TreeNode, depth: number): boolean;
+  protected _isFilteredOut(_node: TreeNode, _depth: number): boolean;
   updated(changedProps: PropertyValues): void;
   connectedCallback(): void;
   disconnectedCallback(): void;
@@ -6618,10 +8112,18 @@ declare class TreeBaseElement extends LitElement implements TreeComponent, TreeS
   protected _handleCheckboxClick(event: MouseEvent, node: TreeNode, _depth: number): void;
   protected _isSelected(node: TreeNode): boolean;
   protected _isFocused(node: TreeNode): boolean;
-  protected _isExpanded(node: TreeNode, depth?: number): boolean;
+  protected _isExpanded(node: TreeNode, _depth?: number): boolean;
   protected get _pendingNode(): TreeNode | undefined;
   protected renderLoadingIndicator(): TemplateResult | typeof nothing;
   protected render(): TemplateResult<1>;
+  /**
+   * `{ posinset, setsize }` for `aria-posinset` / `aria-setsize`. A windowed
+   * list has most siblings out of the DOM, so assistive tech cannot count them.
+   */
+  protected _ariaSetInfo(node: TreeNode): {
+    posInSet: number;
+    setSize: number;
+  } | undefined;
   /** Shared drag-and-drop render state for a row, used by every `_renderNode` variant. */
   protected _dndRowState(node: TreeNode): {
     draggable: boolean;
@@ -6657,9 +8159,11 @@ interface TreeBaseElement {
   removeEventListener: (<K extends keyof TreeBaseElementEventMap>(type: K, listener: (this: TreeBaseElement, event: TreeBaseElementEventMap[K]) => void, options?: boolean | EventListenerOptions) => void) & ((type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions) => void);
 }
 //#endregion
-//#region src/tree/tree-list.d.ts
+//#region src/tree/tree-flat.d.ts
 /** Checkbox tri-state in `checked` interactionMode: a branch node is `indeterminate` when some but not all of its descendants are selected. */
 type TreeCheckboxState = `checked` | `unchecked` | `indeterminate`;
+//#endregion
+//#region src/tree/tree-list.d.ts
 declare class TreeListElement extends TreeBaseElement {
   #private;
   /**
@@ -6682,7 +8186,7 @@ declare class TreeListElement extends TreeBaseElement {
    *       </svg>`;
    */
   checkboxRenderer: ((state: TreeCheckboxState) => unknown) | undefined;
-  protected render(): TemplateResult<1>;
+  willUpdate(changedProps: PropertyValues): void;
   protected renderNodeContent(node: TreeNode, depth: number): TemplateResult;
   protected _renderNode(node: TreeNode, depth: number): TemplateResult;
   static styles: import("lit").CSSResult[];
@@ -10637,8 +12141,17 @@ interface TreeDropVisibleRow {
   readonly key: string;
   readonly node: TreeNode;
   readonly depth: number;
+  /** Index of this row in the full flat (visible) list — not in the `rows` array. */
+  readonly index: number;
   readonly rect: DOMRect;
 }
+/** Structural facts about a visible row, independent of geometry. */
+interface TreeDropRowInfo {
+  readonly node: TreeNode;
+  readonly depth: number;
+  /** Parent key, or `undefined` for a root-level row. */
+  readonly parentKey: string | undefined;
+}
 /** What a `dragover` / `drop` DataTransfer resolved to for this tree. */
 interface TreeDropResolvedDrag {
   readonly source: `internal` | `external`;
@@ -10650,8 +12163,17 @@ interface TreeDropResolvedDrag {
 type TreeDropControllerConfig = {
   getDndMode: () => `none` | `internal` | `external` | `both`;
   getExpandHoverMs: () => number;
-  /** Visible rows in display order, each with a fresh viewport rect. Host may cache. */
+  /**
+   * Measured rows in display order, each with a fresh viewport rect. May be
+   * limited to the rows intersecting the scroll container — ancestors and
+   * siblings are resolved through `getRowInfo` / `getChildren`, not from here.
+   * Host may cache.
+   */
   getVisibleRows: () => TreeDropVisibleRow[];
+  /** Flat-list info for a visible key (no geometry), or `undefined` if not visible. */
+  getRowInfo: (key: string) => TreeDropRowInfo | undefined;
+  /** Children of `parentKey`, or the root's children when undefined. */
+  getChildren: (parentKey: string | undefined) => readonly TreeNode[];
   getIndentPx: () => number;
   getScrollContainer: () => HTMLElement | undefined;
   /** True when `key` is `ancestorKey` or a descendant of it. */
@@ -11172,5 +12694,4 @@ interface XyPad {
 //#region src/index.d.ts
 declare function init(): void;
 //#endregion
-export { AcTextChangeDetail, AcTextChangeEvent, AcTextCompletionProvider, AcTextElement, AcTextItem, AcTextSelectDetail, AcTextSelectEvent, type AcTokenAddDetail, type AcTokenAddEvent, AcTokenElement, type AcTokenElementEventMap, type AcTokenItem, type AcTokenRemoveDetail, type AcTokenRemoveEvent, type AcTokenizerFn, type AcTokensChangeDetail, type AcTokensChangeEvent, AddItemOptions, Axis, BottomDrawerCloseEvent, BottomDrawerCommand, BottomDrawerElement, BottomDrawerElementEventMap, BottomDrawerResizeDetail, BottomDrawerResizeEvent, type BuiltInFormatterName, type BuiltInFormatterOptions, ButtonElement, ButtonElementEventMap, ButtonToggleDetail, ButtonToggleEvent, type CheckState, Checkbox, CheckboxChangeDetail, CheckboxChangeEvent, CheckboxEventMap, CheckedSelect, CheckedSelectChangeDetail, CheckedSelectChangeEvent, CheckedSelectEventMap, type CheckedSelectItem, ClickSnapMode, ColourMapConfig, ColourMode, ColourPicker, type ColourPickerChangeEvent, type ColourPickerEventDetail, type ColourPickerInputEvent, ColourPickerPopup, ColourResult, type ComputeHyperbolicLayoutOptions, ComputeIcicleLayoutOptions, type ComputeTreemapLayoutOptions, ConfigEntry, ContiguousSelectEventDetail, CrossoverBehaviour, CrumbDragStartDetail, CrumbDragStartEvent, CrumbDropDetail, CrumbDropEvent, CrumbExternalDropParser, CrumbNavChangeDetail, CrumbNavChangeEvent, CrumbNavExpandDetail, CrumbNavExpandEvent, CrumbNavNavigateDetail, CrumbNavNavigateEvent, CrumbNavigationChangeDetail, CrumbNavigationChangeEvent, CrumbNavigationElement, CrumbNavigationElementEventMap, CrumbNavigationExpandDetail, CrumbNavigationExpandEvent, CrumbNavigationItemClickDetail, CrumbNavigationItemClickEvent, CrumbPathController, CrumbPathControllerOptions, CrumbPathElement, CrumbPathElementEventMap, CrumbSegment, CrumbSegmentDragData, CrumbSegmentDragLookupFn, CrumbSiblingLookupFn, type CssVars, CustomCheckboxOptions, DEFAULT_SIBLING_SPACING, DataBatch, DataController, DataControllerOptions, DataDisplayComponent, DataGridCellClickDetail, DataGridCellClickEvent, DataGridCellEditDetail, DataGridCellEditEvent, type DataGridColumn, type DataGridColumnMenu, DataGridColumnReorderDetail, DataGridColumnReorderEvent, DataGridColumnResizeDetail, DataGridColumnResizeEvent, DataGridColumnVisibilityDetail, DataGridColumnVisibilityEvent, type DataGridDataType, type DataGridEditability, type DataGridEditorContext, type DataGridEditorFactory, type DataGridEditorType, DataGridElement, DataGridElementEventMap, type DataGridGetRowKey, type DataGridGroupBy, DataGridGroupChangeDetail, DataGridGroupChangeEvent, type DataGridGroupLabel, type DataGridInteractionMode, DataGridRowActivateDetail, DataGridRowActivateEvent, type DataGridRowLook, DataGridSelectDetail, DataGridSelectEvent, type DataGridSelectionMode, DataGridSortDetail, type DataGridSortDirection, DataGridSortEvent, type DataGridSortState, DataGridViewportChangeDetail, DataGridViewportChangeEvent, type DataListSearchAdapterOptions, type DataListSearchItem, DataProviderResult, DataTableElement, DataTableElementEventMap, DataTableRow, DataTableRowClickDetail, DataTableRowClickEvent, type DetailFormatter, type DetailGroupBy, DetailListElement, DetailListElementEventMap, type DetailSortComparator, type DetailSortItem, type DetailSortMode, DiskIsometry, DisplayTextLogic, DistributeResult, DockAddPanelTarget, DockAxis, DockChangeDetail, DockChangeEvent, DockDirection, DockDragBoundaryDetail, DockDragBoundaryEvent, DockDropTarget, type DockDropZone, DockEdge, DockHostElement, DockHostElementEventMap, DockLayout, DockLeafContentRules, DockLeafInfo, DockLeafPlacementPolicy, DockLeafPlacementPolicyResolved, DockLeafRef, DockNeighbours, DockNode, DockOperation, DockPanelActivatedDetail, DockPanelActivatedEvent, DockPanelAddedDetail, DockPanelAddedEvent, DockPanelDragStartDetail, DockPanelDragStartEvent, DockPanelElement, DockPanelElementEventMap, DockPanelInit, DockPanelRemovedDetail, DockPanelRemovedEvent, DockPanelSnapshot, DockPanelTearOutDetail, DockPanelTearOutEvent, DockRect, DockSplitNode, DockStackNode, type DragSelectRect, DragSnappingFn, DragTarget, EMPTY_GROUP_LABEL, EditableLabel, EditableLabelChangeDetail, EditableLabelChangeEvent, EditableMode, EditableNumber, Effect, type ElementIncrSearch, type ElementIncrSearchOptions, type ElementListSearchAdapterOptions, type ElementListSearchHost, Endpoints, EntryMode, type FlatListActivateDetail, type FlatListActivateEvent, type FlatListBranchOrder, type FlatListContextMenuDetail, type FlatListContextMenuEvent, type FlatListDropDetail, type FlatListDropEvent, type FlatListEditCancelDetail, type FlatListEditCancelEvent, type FlatListEditCommitDetail, type FlatListEditCommitEvent, FlatListElement, type FlatListElementEventMap, type FlatListNavigateDetail, type FlatListNavigateEvent, type FlatListSelectDetail, type FlatListSelectEvent, FormElement, FormGroupElement, FormPartElement, FormatValueForHuman, FormattingOptions, type FuzzySearch, type FuzzySearchOptions, FuzzySearchResult, GeodesicSegment, type GlobalFormatter, type GridListActivateDetail, type GridListActivateEvent, type GridListCaptionAlign, type GridListCaptionBackdrop, type GridListCaptionPosition, type GridListCaptionStyle, type GridListDataAdapter, GridListElement, type GridListElementEventMap, type GridListFullElementEventMap, type GridListItemClickDetail, type GridListItemClickEvent, type GridListItemEventDetail, type GridListOrientation, type GridListSelectDetail, type GridListSelectEvent, type GridListTickleDetail, type GridListTickleEvent, type GridListViewportChangeDetail, type GridListViewportChangeEvent, GridMode, GridResolution, GroupNode, GroupedItemListerElement, type GroupedItemListerElementEventMap, type GroupedSelectDetail, type GroupedSelectEvent, HexChangeDetail, HexChangeEvent, type HighlightOptions, type HighlightTarget, type HyperbolicEdgeRenderContext, type HyperbolicEdgeRenderer, type HyperbolicFocusDetail, type HyperbolicFocusEvent, type HyperbolicInteractionMode, type HyperbolicLayoutEdge, type HyperbolicLayoutNode, type HyperbolicNodeShape, type Point as HyperbolicPoint, HyperbolicTreeListElement, HyperbolicTreeListElementEventMap, ICON_CARET_RIGHT, ICON_CHECK, ICON_CHEVRON_DOWN, ICON_CLOSE, IDataProvider, type IGroupedSubComponent, type IGroupedSubComponentEventMap, IcicleInteractionMode, IcicleOrientation, IcicleRect, IcicleTreeListElement, IcicleTreeListElementEventMap, IcicleValueAccessor, IcicleZoomDetail, IcicleZoomEvent, type IconChangedDetail, type IconChangedEvent, type IconEntry, type IncrSearch, type IncrSearchChangeCallback, IncrSearchTreeController as IncrSearchMillerController, IncrSearchTreeController, type IncrSearchTreeOptions as IncrSearchMillerOptions, type IncrSearchTreeOptions, type IncrSearchOptions, type IncrSearchResult, type IncrSearchState, type InputMode, type ItemDisplay, type ItemOrientation, ItemsProvider, IxfxHexEditorElement, IxfxIconElement, IxfxRatingElement, IxfxTimelineElement, KeyedElementIndex, LIST_ITEM_MOTION_MS, LIST_SEARCH_COMMAND_IDS, LIST_SEARCH_MODES, LabelledRadialInput, LabelledRangeInput, LabelledSliderInput, LaneData, LaneType, LayoutNode, LayoutSnapshot, LeafGeom, LedElement, LedMode, type ListActivateDetail, type ListActivateEvent, type ListContextMenuDetail, type ListContextMenuEvent, type ListDragEntry, type ListDragLeaveDetail, type ListDragLeaveEvent, type ListDragOverEvent, type ListDragPreview, type ListDragPreviewContext, type ListDragPreviewRenderer, type ListDragPreviewSourceResolver, ListDragSelectController, type ListDragSelectControllerConfig, type ListDragSource, type ListDropDetail, type ListDropEvent, type ListEditCancelDetail, type ListEditCancelEvent, type ListEditCommitDetail, type ListEditCommitEvent, type ListElementEventMap, type ListGroupBy, type ListGroupChangeDetail, type ListGroupChangeEvent, type ListGroupEventMap, ListGroupHeaderElement, type ListGroupInfo, type ListGroupLabel, type ListGroupPartition, type ListGroupToggleDetail, type ListGroupToggleEvent, type ListInteractionMode, type ListItemClickDetail, type ListItemClickEvent, type ListItemMotionOptions, type ListItemOutResult, ListNativeDragController, type ListNativeDragControllerConfig, type ListNativeDragStartDetail, type ListNativeDragStartEvent, type ListSearchAdapter, ListSearchController, type ListSearchControllerOptions, type ListSearchHost, type ListSearchMode, type ListSelectDetail, type ListSelectEvent, ListSelectionController, type ListSelectionControllerConfig, type ListSelectionGesture, type ListSelectionMode, type ListSelectionModes, type ListTickleDetail, type ListTickleEvent, type ListViewportChangeDetail, type ListViewportChangeEvent, LoadChildrenCallback, MarkerStyle, index_d_exports as Menu, type TreeActivateDetail as MillerActivateDetail, TreeActivateDetail, type TreeActivateEvent as MillerActivateEvent, TreeActivateEvent, MillerBaseElement, MillerBaseElementEventMap, type TreeCollapseDetail as MillerCollapseDetail, TreeCollapseDetail, type TreeCollapseEvent as MillerCollapseEvent, TreeCollapseEvent, MillerConfig, type TreeExpandDetail as MillerExpandDetail, TreeExpandDetail, type TreeExpandEvent as MillerExpandEvent, TreeExpandEvent, MillerHeaderClickDetail, MillerHeaderClickEvent, MillerHeaderRightClickDetail, MillerHeaderRightClickEvent, type TreeItem as MillerItem, TreeItem, type TreeItemClickDetail as MillerItemClickDetail, TreeItemClickDetail, type TreeItemClickEvent as MillerItemClickEvent, TreeItemClickEvent, MillerItemDblClickDetail, MillerItemDblClickEvent, MillerItemRightClickDetail, MillerItemRightClickEvent, MillerItemState, MillerListElement, type TreeNode as MillerNode, TreeNode, MillerRebaseDetail, MillerRebaseEvent, type TreeSelectDetail as MillerSelectDetail, TreeSelectDetail, type TreeSelectEvent as MillerSelectEvent, TreeSelectEvent, MillerSelectionMode, type TreeTickleDetail as MillerTickleDetail, TreeTickleDetail, type TreeTickleEvent as MillerTickleEvent, TreeTickleEvent, MillerTreeController, MillerTreeControllerOptions, type MulticolCategory, type MulticolColumnState, MulticolColumnsChangeDetail, MulticolColumnsChangeEvent, type MulticolColumnsChangeReason, type MulticolItem, MulticolListElement, MulticolListElementEventMap, type MulticolQuery, type MulticolSelectDetail, MulticolSelectEvent, NarrowedTextChangeDetail, NarrowedTextChangeEvent, NarrowedTextElement, NarrowedTextItem, NoneSelectEventDetail, Notification, NotificationContent, NotificationManager, NotificationPillElement, NotificationPillElementEventMap, NotificationRenderer, NotificationRendererHooks, NotificationType, NotifierOptions, type OklchValue, Orientation, PanTextElement, PanTextMode, PanelCloseEvent, PanelElement, PanelElementEventMap, PanelGroupElement, PanelGroupElementEventMap, PanelGroupOrientation, PanelGroupReorderDetail, PanelGroupReorderEvent, PanelInfo, PanelNode, PanelOrientation, PanelToggleDetail, PanelToggleEvent, PanelToggleInteraction, PanelVariant, PillPosition, PillQueueDisplay, PillRendererOptions, PillSafeArea, PillTapDetail, PillTapEvent, PlotDataSeries, PlotDataSeriesOptions, PlotHistogram, PlotHistogramBucketClickDetail, PlotHistogramBucketClickEvent, PlotHistogramElementEventMap, PlotHistogramInteractionMode, PlotHistogramOrientation, PlotHistogramSelectionChangeDetail, PlotHistogramSelectionChangeEvent, PlotHistogramSelectionRange, PlotHistogramValueTooltips, PlotMultiAxis, PlotMultiAxisDataPointClickDetail, PlotMultiAxisDataPointClickEvent, PlotMultiAxisElementEventMap, PlotMultiAxisLayout, PlotSingleAxis, PlotSingleAxisElementEventMap, PlotSingleAxisPointerMoveDetail, PlotSingleAxisPointerMoveEvent, PlotXyAxis, PolarPad, PolarPadInputDetail, PolarPadInputEvent, PopupItem, RadialInputChangeDetail, RadialInputChangeEvent, RadialInputElement, RadialInputInputDetail, RadialInputInputEvent, RadioGroup, RadioGroupChangeDetail, RadioGroupChangeEvent, RadioGroupMode, RadioItem, RangeElement, RangeInput, RangeMultiElement, RangeMultiInputDetail, RangeMultiInputEvent, RatingChangeDetail, RatingChangeEvent, RatingElement, RatingElementEventMap, RatingInputEvent, RatingVariant, type Rect, RectangularSelectEventDetail, type RegisterListSearchCommandsOptions, RendererStyle, ResizeMode, SegmentIconLookupFn, SelectEventDetail, SelectHorizChangeDetail, SelectHorizChangeEvent, SelectHorizElement, SelectHorizEventMap, SelectionMode, ShapefillDisplay, ShapefillFillMode, ShapefillValueChangeDetail, ShapefillValueChangeEvent, ShapefillValueElement, ShapefillValueInputDetail, ShapefillValueInputEvent, SingleAxisAgeStyle, SingleAxisDrawStyle, SingleSelectEventDetail, SliderChangedField, SliderCrossover, SliderHandleKey, SliderInputChangeDetail, SliderInputChangeEvent, SliderInputElement, SliderInputElementEventMap, SliderInputInputDetail, SliderInputInputEvent, SliderLaneData, SliderLaneType, SliderMarkerStyle, SliderOrientation, SliderSingleStyle, SliderValueCFollow, SliderValueDrag, SliderValueMode, SlidingNumberElement, SlidingNumberTrend, SnackbarDismiss, SnackbarElement, SnackbarMode, SnackbarPlacement, SnapChangeDetail, SnapChangeEvent, SnapContainer, SnapInputDetail, SnapInputEvent, SnapLogic, SnapshotNode, SortCompareFn, type SortDirection, SplitButton, SplitButtonMode, SplitButtonSelectDetail, SplitButtonSelectEvent, SplitChangeDetail, SplitChangeEvent, SplitCloseDetail, SplitCloseEvent, SplitCollapseDetail, SplitCollapseEvent, SplitExpandDetail, SplitExpandEvent, SplitLayoutElement, SplitLayoutElementEventMap, SplitPanelElement, SplitResizeDetail, SplitResizeEvent, type SubComponentActivateDetail, type SubComponentActivateEvent, type SubComponentFactory, type SubComponentItemClickDetail, type SubComponentItemClickEvent, type SubComponentSelectDetail, type SubComponentSelectEvent, type SubComponentTickleDetail, type SubComponentTickleEvent, SwipeElement, SwipeElementEventMap, SwipeInputDetail, SwipeInputEvent, SwitcherItem, Tab, TabAddOptions, TabController, TabControllerOptions, TabListChangeDetail, TabListChangeEvent, TabListDragMode, TabListElement, TabListItemElement, TabListReorderDetail, TabListReorderEvent, TabPanelElement, TabPanelsElement, TextShimmerElement, TickledController, type TickledControllerConfig, type TickledItem, TimelineController, TimelineControllerConfig, TimelineDraggingCallbackDetail, TimelineDraggingDetail, TimelineDraggingEvent, TimelineElementEventMap, TimelineEvent, TimelineEventMoveDetail, TimelineEventMoveEvent, TimelineEventResizeDetail, TimelineEventResizeEvent, TimelineSelectionChangeDetail, TimelineSelectionChangeEvent, TimelineTickleChangeDetail, TimelineTickleChangeEvent, TimelineTrack, TimelineTrackReorderDetail, TimelineTrackReorderEvent, TimelineTrackResizeDetail, TimelineTrackResizeEvent, TimelineTrackSelectDetail, TimelineTrackSelectEvent, TimelineTrackTabElement, TitlebarCloseEvent, TitlebarElement, TitlebarElementEventMap, TitlebarOrientation, TitlebarToggleDetail, TitlebarToggleEvent, TitlebarToggleInteraction, TitlebarVariant, ToolbarAlign, ToolbarElement, ToolbarElementEventMap, ToolbarGroupElement, ToolbarGroupReorderDetail, ToolbarGroupReorderEvent, ToolbarLayout, ToolbarLayoutSnapshot, ToolbarOrientation, ToolbarVerticalWriting, TooltipElement, TooltipOrientations, TrackHeightMode, TrackLayout, TransitoryLabelElement, TreeBaseElement, TreeBaseElementEventMap, TreeCheckboxState, TreeComponent, TreeComponentEventMap, TreeConfig, TreeController, TreeControllerOptions, TreeDataModel, TreeDataModelOptions, TreeDndMode, TreeDragContext, TreeDragEndEvent, TreeDragOverEvent, TreeDragStartEvent, TreeDropApplyContext, TreeDropContext, TreeDropController, TreeDropControllerConfig, TreeDropDetail, TreeDropEvent, TreeDropPosition, TreeDropResolvedDrag, TreeDropTarget, TreeDropVisibleRow, TreeExclusivity, TreeFilterPredicate, TreeInteractionMode, TreeItemDblClickDetail, TreeItemDblClickEvent, type TreeKeyboardNavCallbacks, TreeKeyboardNavController, type TreeKeyboardNavControllerConfig, type TreeKeyboardNavItemId, TreeListAdapterOptions, TreeListElement, type TreeListSearchAdapterOptions, TreeSearchHost, TreeSelectionFilter, type TreemapInteractionMode, TreemapListElement, TreemapListElementEventMap, type TreemapRect, type TreemapTilingMethod, type TreemapValueAccessor, TreemapZoomDetail, TreemapZoomEvent, TwoSplitLayoutElement, UserScale, ValueMode, VerticalListAdapterOptions, VerticalListElement, VerticalListElementEventMap, ViewRange, WhenSmall, XyAgeStyle, XyDrawStyle, XyPad, XyPadEventMap, XyPadInputDetail, XyPadInputEvent, addPanelToStack, animateListItemIn, animateListItemOut, applyAgeModification, applyHighlights, applyIsometry, applySnapshot, applyTreeDrop, attachTimelineInteractions, bottomDrawerCommandId, buildHighlightTargets, buildModel, captionForEntry, clampToDisk, clearHighlights, collectContainerNames, collectDataResult, collectPanelIds, collectStackPaths, composeIsometry, computeCanonicalPositions, computeColour, computeHyperbolicLayout, computeIcicleLayout, computeLeafGeoms, computeTreemapLayout, createAcCompletionProvider, createDataListSearchAdapter, createDefaultListDragPreview, createElementIncrSearch, createElementListSearchAdapter, createEmptyLayout, createEmptyStack, createFuzzySearch, createIncrSearch, createPillRenderer, createSplit, createStack, createTreeListAdapter, createTreeListSearchAdapter, createVerticalListAdapter, decomposeViewIsometry, defaultGroupLabel, distribute, dropTargetFor, euclideanRadiusForHyperbolicDistance, extractStack, findHyperbolicIdOf, findHyperbolicKeyPath, findHyperbolicNode, findHyperbolicPath, findHyperbolicPathById, findIcicleNode, findIciclePath, findNode, findPanelNode, findParentOf, findStackOf, findStackPathByName, findTreemapNode, findTreemapPath, geodesicInterpolate, geodesicPath, geodesicSegment, getActiveDragPanelId, getIcon, getIconEntry, getIconFont, getLeafNeighbours, hasIcon, hyperbolicBranchId, hyperbolicChildIds, hyperbolicDistanceForEuclideanRadius, hyperbolicIdDepth, hyperbolicRelativeFrame, iconBus, identityIsometry, init, insertBeside, invertIsometry, isDragging, isHyperbolicDescendantId, isMultiMode, isSplit, isStack, keyForElement, listItemFadeKeyframes, listSearchStyles, mobiusAdd, mobiusFromOrigin, mobiusToOrigin, monitorIndeterminate, moveLeafNodeToEdge, moveLeafStep, norm, normalise, normaliseValue, normalize, panelGapIndex, parseColourScaleAttr, parseLayout, partitionByGroup, poincareDistance, pointerOverAnyHost, prefersReducedMotion, preserveRestoreWeights, pruneDraggedDescendants, readBaseColour, registerFontIcon, registerIcon, registerListSearchCommands, removePanelFromStack, resolveCssVars, resolveGrid, resolveGroupKey, resolveLeafPath, resolveTracks, rotationIsometry, serializeLayout, setActive, setIconFont, setPanelRestoreWeight, startListItemOutAnimation, svgToDataUri, swapLeaves, tickledItemStyles, tickledStyles, timelineStyles, toGroupKey, toSnapshot, toggleInSet, toolbarGapIndex, translationFromOrigin, viewIsometry, walk, wrapRoot };
-//# sourceMappingURL=index.d.ts.map
+export { AcTextChangeDetail, AcTextChangeEvent, AcTextCompletionProvider, AcTextElement, AcTextItem, AcTextSelectDetail, AcTextSelectEvent, type AcTokenAddDetail, type AcTokenAddEvent, AcTokenElement, type AcTokenElementEventMap, type AcTokenItem, type AcTokenRemoveDetail, type AcTokenRemoveEvent, type AcTokenizerFn, type AcTokensChangeDetail, type AcTokensChangeEvent, AddItemOptions, Axis, BottomDrawerCloseEvent, BottomDrawerCommand, BottomDrawerElement, BottomDrawerElementEventMap, BottomDrawerResizeDetail, BottomDrawerResizeEvent, type BuiltInFormatterName, type BuiltInFormatterOptions, ButtonElement, ButtonElementEventMap, ButtonToggleDetail, ButtonToggleEvent, type CheckState, Checkbox, CheckboxChangeDetail, CheckboxChangeEvent, CheckboxEventMap, CheckedSelect, CheckedSelectChangeDetail, CheckedSelectChangeEvent, CheckedSelectEventMap, type CheckedSelectItem, ClickSnapMode, ColourMapConfig, ColourMode, ColourPicker, type ColourPickerChangeEvent, type ColourPickerEventDetail, type ColourPickerInputEvent, ColourPickerPopup, ColourResult, type ComputeHyperbolicLayoutOptions, ComputeIcicleLayoutOptions, type ComputeTreemapLayoutOptions, ConfigEntry, ContiguousSelectEventDetail, CrossoverBehaviour, CrumbDragStartDetail, CrumbDragStartEvent, CrumbDropDetail, CrumbDropEvent, CrumbExternalDropParser, CrumbNavChangeDetail, CrumbNavChangeEvent, CrumbNavExpandDetail, CrumbNavExpandEvent, CrumbNavNavigateDetail, CrumbNavNavigateEvent, CrumbNavigationChangeDetail, CrumbNavigationChangeEvent, CrumbNavigationElement, CrumbNavigationElementEventMap, CrumbNavigationExpandDetail, CrumbNavigationExpandEvent, CrumbNavigationItemClickDetail, CrumbNavigationItemClickEvent, CrumbPathController, CrumbPathControllerOptions, CrumbPathElement, CrumbPathElementEventMap, CrumbSegment, CrumbSegmentDragData, CrumbSegmentDragLookupFn, CrumbSiblingLookupFn, type CssVars, CustomCheckboxOptions, DEFAULT_SIBLING_SPACING, DataBatch, DataController, DataControllerOptions, DataDisplayComponent, DataGridCellClickDetail, DataGridCellClickEvent, DataGridCellEditDetail, DataGridCellEditEvent, type DataGridColumn, type DataGridColumnMenu, DataGridColumnReorderDetail, DataGridColumnReorderEvent, DataGridColumnResizeDetail, DataGridColumnResizeEvent, DataGridColumnVisibilityDetail, DataGridColumnVisibilityEvent, type DataGridDataType, type DataGridEditability, type DataGridEditorContext, type DataGridEditorFactory, type DataGridEditorType, DataGridElement, DataGridElementEventMap, type DataGridGetRowKey, type DataGridGroupBy, DataGridGroupChangeDetail, DataGridGroupChangeEvent, type DataGridGroupLabel, type DataGridInteractionMode, DataGridRowActivateDetail, DataGridRowActivateEvent, type DataGridRowLook, DataGridSelectDetail, DataGridSelectEvent, type DataGridSelectionMode, DataGridSortDetail, type DataGridSortDirection, DataGridSortEvent, type DataGridSortState, DataGridViewportChangeDetail, DataGridViewportChangeEvent, type DataListSearchAdapterOptions, type DataListSearchItem, DataProviderResult, DataTableElement, DataTableElementEventMap, DataTableRow, DataTableRowClickDetail, DataTableRowClickEvent, type DetailFormatter, type DetailGroupBy, DetailListElement, DetailListElementEventMap, type DetailSortComparator, type DetailSortItem, type DetailSortMode, DiskIsometry, DisplayTextLogic, DistributeResult, DockAddPanelTarget, DockAxis, DockChangeDetail, DockChangeEvent, DockDirection, DockDragBoundaryDetail, DockDragBoundaryEvent, DockDropTarget, type DockDropZone, DockEdge, DockHostElement, DockHostElementEventMap, DockLayout, DockLeafContentRules, DockLeafInfo, DockLeafPlacementPolicy, DockLeafPlacementPolicyResolved, DockLeafRef, DockNeighbours, DockNode, DockOperation, DockPanelActivatedDetail, DockPanelActivatedEvent, DockPanelAddedDetail, DockPanelAddedEvent, DockPanelDragStartDetail, DockPanelDragStartEvent, DockPanelElement, DockPanelElementEventMap, DockPanelInit, DockPanelRemovedDetail, DockPanelRemovedEvent, DockPanelSnapshot, DockPanelTearOutDetail, DockPanelTearOutEvent, DockRect, DockSplitNode, DockStackNode, type DragSelectRect, DragSnappingFn, DragTarget, EMPTY_GROUP_LABEL, EditableLabel, EditableLabelChangeDetail, EditableLabelChangeEvent, EditableMode, EditableNumber, Effect, type ElementIncrSearch, type ElementIncrSearchOptions, type ElementListSearchAdapterOptions, type ElementListSearchHost, Endpoints, EntryMode, type FlatListActivateDetail, type FlatListActivateEvent, type FlatListBranchOrder, type FlatListContextMenuDetail, type FlatListContextMenuEvent, type FlatListDropDetail, type FlatListDropEvent, type FlatListEditCancelDetail, type FlatListEditCancelEvent, type FlatListEditCommitDetail, type FlatListEditCommitEvent, FlatListElement, type FlatListElementEventMap, type FlatListNavigateDetail, type FlatListNavigateEvent, type FlatListSelectDetail, type FlatListSelectEvent, FormElement, FormGroupElement, FormPartElement, FormatValueForHuman, FormattingOptions, type FuzzySearch, type FuzzySearchOptions, FuzzySearchResult, GeodesicSegment, type GlobalFormatter, type GridListActivateDetail, type GridListActivateEvent, type GridListCaptionAlign, type GridListCaptionBackdrop, type GridListCaptionPosition, type GridListCaptionStyle, type GridListDataAdapter, GridListElement, type GridListElementEventMap, type GridListFullElementEventMap, type GridListItemClickDetail, type GridListItemClickEvent, type GridListItemEventDetail, type GridListOrientation, type GridListSelectDetail, type GridListSelectEvent, type GridListTickleDetail, type GridListTickleEvent, type GridListViewportChangeDetail, type GridListViewportChangeEvent, GridMode, GridResolution, GroupNode, GroupedItemListerElement, type GroupedItemListerElementEventMap, type GroupedSelectDetail, type GroupedSelectEvent, HexChangeDetail, HexChangeEvent, type HighlightOptions, type HighlightTarget, type HyperbolicEdgeRenderContext, type HyperbolicEdgeRenderer, type HyperbolicFocusDetail, type HyperbolicFocusEvent, type HyperbolicInteractionMode, type HyperbolicLayoutEdge, type HyperbolicLayoutNode, type HyperbolicNodeShape, type Point as HyperbolicPoint, HyperbolicTreeListElement, HyperbolicTreeListElementEventMap, ICON_CARET_RIGHT, ICON_CHECK, ICON_CHEVRON_DOWN, ICON_CLOSE, IDataProvider, type IGroupedSubComponent, type IGroupedSubComponentEventMap, IcicleInteractionMode, IcicleOrientation, IcicleRect, IcicleTreeListElement, IcicleTreeListElementEventMap, IcicleValueAccessor, IcicleZoomDetail, IcicleZoomEvent, type IconChangedDetail, type IconChangedEvent, type IconEntry, type IncrSearch, type IncrSearchChangeCallback, IncrSearchTreeController as IncrSearchMillerController, IncrSearchTreeController, type IncrSearchTreeOptions as IncrSearchMillerOptions, type IncrSearchTreeOptions, type IncrSearchOptions, type IncrSearchResult, type IncrSearchState, type InputMode, type ItemDisplay, type ItemOrientation, ItemsProvider, IxfxHexEditorElement, IxfxIconElement, IxfxRatingElement, IxfxTimelineElement, KeyedElementIndex, LIST_ITEM_MOTION_MS, LIST_SEARCH_COMMAND_IDS, LIST_SEARCH_MODES, LabelledRadialInput, LabelledRangeInput, LabelledSliderInput, LaneData, LaneType, LayoutNode, LayoutSnapshot, LeafGeom, LedElement, LedMode, type ListActivateDetail, type ListActivateEvent, type ListContextMenuDetail, type ListContextMenuEvent, type ListDragEntry, type ListDragLeaveDetail, type ListDragLeaveEvent, type ListDragOverEvent, type ListDragPreview, type ListDragPreviewContext, type ListDragPreviewRenderer, type ListDragPreviewSourceResolver, ListDragSelectController, type ListDragSelectControllerConfig, type ListDragSource, type ListDropDetail, type ListDropEvent, type ListEditCancelDetail, type ListEditCancelEvent, type ListEditCommitDetail, type ListEditCommitEvent, type ListElementEventMap, type ListGroupBy, type ListGroupChangeDetail, type ListGroupChangeEvent, type ListGroupEventMap, ListGroupHeaderElement, type ListGroupInfo, type ListGroupLabel, type ListGroupPartition, type ListGroupToggleDetail, type ListGroupToggleEvent, type ListInteractionMode, type ListItemClickDetail, type ListItemClickEvent, type ListItemMotionOptions, type ListItemOutResult, ListNativeDragController, type ListNativeDragControllerConfig, type ListNativeDragStartDetail, type ListNativeDragStartEvent, type ListSearchAdapter, ListSearchController, type ListSearchControllerOptions, type ListSearchHost, type ListSearchMode, type ListSelectDetail, type ListSelectEvent, ListSelectionController, type ListSelectionControllerConfig, type ListSelectionGesture, type ListSelectionMode, type ListSelectionModes, type ListTickleDetail, type ListTickleEvent, type ListViewportChangeDetail, type ListViewportChangeEvent, LoadChildrenCallback, MarkerStyle, index_d_exports as Menu, type TreeActivateDetail as MillerActivateDetail, TreeActivateDetail, type TreeActivateEvent as MillerActivateEvent, TreeActivateEvent, MillerBaseElement, MillerBaseElementEventMap, type TreeCollapseDetail as MillerCollapseDetail, TreeCollapseDetail, type TreeCollapseEvent as MillerCollapseEvent, TreeCollapseEvent, MillerConfig, type TreeExpandDetail as MillerExpandDetail, TreeExpandDetail, type TreeExpandEvent as MillerExpandEvent, TreeExpandEvent, MillerHeaderClickDetail, MillerHeaderClickEvent, MillerHeaderRightClickDetail, MillerHeaderRightClickEvent, type TreeItem as MillerItem, TreeItem, type TreeItemClickDetail as MillerItemClickDetail, TreeItemClickDetail, type TreeItemClickEvent as MillerItemClickEvent, TreeItemClickEvent, MillerItemDblClickDetail, MillerItemDblClickEvent, MillerItemRightClickDetail, MillerItemRightClickEvent, MillerItemState, MillerListElement, type TreeNode as MillerNode, TreeNode, MillerRebaseDetail, MillerRebaseEvent, type TreeSelectDetail as MillerSelectDetail, TreeSelectDetail, type TreeSelectEvent as MillerSelectEvent, TreeSelectEvent, MillerSelectionMode, type TreeTickleDetail as MillerTickleDetail, TreeTickleDetail, type TreeTickleEvent as MillerTickleEvent, TreeTickleEvent, MillerTreeController, MillerTreeControllerOptions, type MulticolCategory, type MulticolColumnState, MulticolColumnsChangeDetail, MulticolColumnsChangeEvent, type MulticolColumnsChangeReason, type MulticolItem, MulticolListElement, MulticolListElementEventMap, type MulticolQuery, type MulticolSelectDetail, MulticolSelectEvent, NarrowedTextChangeDetail, NarrowedTextChangeEvent, NarrowedTextElement, NarrowedTextItem, NoneSelectEventDetail, Notification, NotificationContent, NotificationManager, NotificationPillElement, NotificationPillElementEventMap, NotificationRenderer, NotificationRendererHooks, NotificationType, NotifierOptions, type OklchValue, Orientation, PanTextElement, PanTextMode, PanelCloseEvent, PanelElement, PanelElementEventMap, PanelGroupElement, PanelGroupElementEventMap, PanelGroupOrientation, PanelGroupReorderDetail, PanelGroupReorderEvent, PanelInfo, PanelNode, PanelOrientation, PanelToggleDetail, PanelToggleEvent, PanelToggleInteraction, PanelVariant, PillPosition, PillQueueDisplay, PillRendererOptions, PillSafeArea, PillTapDetail, PillTapEvent, PlotDataSeries, PlotDataSeriesOptions, PlotHistogram, PlotHistogramBucketClickDetail, PlotHistogramBucketClickEvent, PlotHistogramElementEventMap, PlotHistogramInteractionMode, PlotHistogramOrientation, PlotHistogramSelectionChangeDetail, PlotHistogramSelectionChangeEvent, PlotHistogramSelectionRange, PlotHistogramValueTooltips, PlotMultiAxis, PlotMultiAxisDataPointClickDetail, PlotMultiAxisDataPointClickEvent, PlotMultiAxisElementEventMap, PlotMultiAxisLayout, PlotSingleAxis, PlotSingleAxisElementEventMap, PlotSingleAxisPointerMoveDetail, PlotSingleAxisPointerMoveEvent, PlotXyAxis, PolarPad, PolarPadInputDetail, PolarPadInputEvent, PopupItem, RadialInputChangeDetail, RadialInputChangeEvent, RadialInputElement, RadialInputInputDetail, RadialInputInputEvent, RadioGroup, RadioGroupChangeDetail, RadioGroupChangeEvent, RadioGroupMode, RadioItem, RangeElement, RangeInput, RangeMultiElement, RangeMultiInputDetail, RangeMultiInputEvent, RatingChangeDetail, RatingChangeEvent, RatingElement, RatingElementEventMap, RatingInputEvent, RatingVariant, type Rect, RectangularSelectEventDetail, type RegisterListSearchCommandsOptions, RendererStyle, ResizeMode, SegmentIconLookupFn, SelectEventDetail, SelectHorizChangeDetail, SelectHorizChangeEvent, SelectHorizElement, SelectHorizEventMap, SelectionMode, ShapefillDisplay, ShapefillFillMode, ShapefillValueChangeDetail, ShapefillValueChangeEvent, ShapefillValueElement, ShapefillValueInputDetail, ShapefillValueInputEvent, SingleAxisAgeStyle, SingleAxisDrawStyle, SingleSelectEventDetail, SliderChangedField, SliderCrossover, SliderHandleKey, SliderInputChangeDetail, SliderInputChangeEvent, SliderInputElement, SliderInputElementEventMap, SliderInputInputDetail, SliderInputInputEvent, SliderLaneData, SliderLaneType, SliderMarkerStyle, SliderOrientation, SliderSingleStyle, SliderValueCFollow, SliderValueDrag, SliderValueMode, SlidingNumberElement, SlidingNumberTrend, SnackbarDismiss, SnackbarElement, SnackbarMode, SnackbarPlacement, SnapChangeDetail, SnapChangeEvent, SnapContainer, SnapInputDetail, SnapInputEvent, SnapLogic, SnapshotNode, SortCompareFn, type SortDirection, SplitButton, SplitButtonMode, SplitButtonSelectDetail, SplitButtonSelectEvent, SplitChangeDetail, SplitChangeEvent, SplitCloseDetail, SplitCloseEvent, SplitCollapseDetail, SplitCollapseEvent, SplitExpandDetail, SplitExpandEvent, SplitLayoutElement, SplitLayoutElementEventMap, SplitPanelElement, SplitResizeDetail, SplitResizeEvent, type SubComponentActivateDetail, type SubComponentActivateEvent, type SubComponentFactory, type SubComponentItemClickDetail, type SubComponentItemClickEvent, type SubComponentSelectDetail, type SubComponentSelectEvent, type SubComponentTickleDetail, type SubComponentTickleEvent, SwipeElement, SwipeElementEventMap, SwipeInputDetail, SwipeInputEvent, SwitcherItem, Tab, TabAddOptions, TabController, TabControllerOptions, TabListChangeDetail, TabListChangeEvent, TabListDragMode, TabListElement, TabListItemElement, TabListReorderDetail, TabListReorderEvent, TabPanelElement, TabPanelsElement, TextShimmerElement, TickledController, type TickledControllerConfig, type TickledItem, TimelineController, TimelineControllerConfig, TimelineDraggingCallbackDetail, TimelineDraggingDetail, TimelineDraggingEvent, TimelineElementEventMap, TimelineEvent, TimelineEventMoveDetail, TimelineEventMoveEvent, TimelineEventResizeDetail, TimelineEventResizeEvent, TimelineSelectionChangeDetail, TimelineSelectionChangeEvent, TimelineTickleChangeDetail, TimelineTickleChangeEvent, TimelineTrack, TimelineTrackReorderDetail, TimelineTrackReorderEvent, TimelineTrackResizeDetail, TimelineTrackResizeEvent, TimelineTrackSelectDetail, TimelineTrackSelectEvent, TimelineTrackTabElement, TitlebarCloseEvent, TitlebarElement, TitlebarElementEventMap, TitlebarOrientation, TitlebarToggleDetail, TitlebarToggleEvent, TitlebarToggleInteraction, TitlebarVariant, ToolbarAlign, ToolbarElement, ToolbarElementEventMap, ToolbarGroupElement, ToolbarGroupReorderDetail, ToolbarGroupReorderEvent, ToolbarLayout, ToolbarLayoutSnapshot, ToolbarOrientation, ToolbarVerticalWriting, TooltipElement, TooltipOrientations, TrackHeightMode, TrackLayout, TransitoryLabelElement, TreeBaseElement, TreeBaseElementEventMap, type TreeCheckboxState, TreeComponent, TreeComponentEventMap, TreeConfig, TreeController, TreeControllerOptions, TreeDataModel, TreeDataModelOptions, TreeDndMode, TreeDragContext, TreeDragEndEvent, TreeDragOverEvent, TreeDragStartEvent, TreeDropApplyContext, TreeDropContext, TreeDropController, TreeDropControllerConfig, TreeDropDetail, TreeDropEvent, TreeDropPosition, TreeDropResolvedDrag, TreeDropRowInfo, TreeDropTarget, TreeDropVisibleRow, TreeExclusivity, TreeFilterPredicate, TreeInteractionMode, TreeItemDblClickDetail, TreeItemDblClickEvent, type TreeKeyboardNavCallbacks, TreeKeyboardNavController, type TreeKeyboardNavControllerConfig, type TreeKeyboardNavItemId, TreeListAdapterOptions, TreeListElement, type TreeListSearchAdapterOptions, TreeSearchHost, TreeSelectionFilter, TreeVirtualize, type TreemapInteractionMode, TreemapListElement, TreemapListElementEventMap, type TreemapRect, type TreemapTilingMethod, type TreemapValueAccessor, TreemapZoomDetail, TreemapZoomEvent, TwoSplitLayoutElement, UserScale, ValueMode, VerticalListAdapterOptions, VerticalListElement, VerticalListElementEventMap, ViewRange, WhenSmall, XyAgeStyle, XyDrawStyle, XyPad, XyPadEventMap, XyPadInputDetail, XyPadInputEvent, addPanelToStack, animateListItemIn, animateListItemOut, applyAgeModification, applyHighlights, applyIsometry, applySnapshot, applyTreeDrop, attachTimelineInteractions, bottomDrawerCommandId, buildHighlightTargets, buildModel, captionForEntry, clampToDisk, clearHighlights, collectContainerNames, collectDataResult, collectPanelIds, collectStackPaths, composeIsometry, computeCanonicalPositions, computeColour, computeHyperbolicLayout, computeIcicleLayout, computeLeafGeoms, computeTreemapLayout, createAcCompletionProvider, createDataListSearchAdapter, createDefaultListDragPreview, createElementIncrSearch, createElementListSearchAdapter, createEmptyLayout, createEmptyStack, createFuzzySearch, createIncrSearch, createPillRenderer, createSplit, createStack, createTreeListAdapter, createTreeListSearchAdapter, createVerticalListAdapter, decomposeViewIsometry, defaultGroupLabel, distribute, dropTargetFor, euclideanRadiusForHyperbolicDistance, extractStack, findHyperbolicIdOf, findHyperbolicKeyPath, findHyperbolicNode, findHyperbolicPath, findHyperbolicPathById, findIcicleNode, findIciclePath, findNode, findPanelNode, findParentOf, findStackOf, findStackPathByName, findTreemapNode, findTreemapPath, geodesicInterpolate, geodesicPath, geodesicSegment, getActiveDragPanelId, getIcon, getIconEntry, getIconFont, getLeafNeighbours, hasIcon, hyperbolicBranchId, hyperbolicChildIds, hyperbolicDistanceForEuclideanRadius, hyperbolicIdDepth, hyperbolicRelativeFrame, iconBus, identityIsometry, init, insertBeside, invertIsometry, isDragging, isHyperbolicDescendantId, isMultiMode, isSplit, isStack, keyForElement, listItemFadeKeyframes, listSearchStyles, mobiusAdd, mobiusFromOrigin, mobiusToOrigin, monitorIndeterminate, moveLeafNodeToEdge, moveLeafStep, norm, normalise, normaliseValue, normalize, panelGapIndex, parseColourScaleAttr, parseLayout, partitionByGroup, poincareDistance, pointerOverAnyHost, prefersReducedMotion, preserveRestoreWeights, pruneDraggedDescendants, readBaseColour, registerFontIcon, registerIcon, registerListSearchCommands, removePanelFromStack, resolveCssVars, resolveGrid, resolveGroupKey, resolveLeafPath, resolveTracks, rotationIsometry, serializeLayout, setActive, setIconFont, setPanelRestoreWeight, startListItemOutAnimation, svgToDataUri, swapLeaves, tickledItemStyles, tickledStyles, timelineStyles, toGroupKey, toSnapshot, toggleInSet, toolbarGapIndex, translationFromOrigin, viewIsometry, walk, wrapRoot };