@ixfx/components 0.11.3 → 0.11.5

package/bundle/index.d.ts

@@ -542,6 +542,7 @@ declare class MenuTrigger extends LitElement {
   private _isOpen;
   private _hasMenu;
   private _hasTriggerSlot;
+  private _hasContextTarget;
   private _triggerBtn;
   private _popup;
   private static _count;
@@ -555,6 +556,7 @@ declare class MenuTrigger extends LitElement {
   private _propagateContext;
   private _handleSlotChange;
   private _handleTriggerSlotChange;
+  private _handleContextTargetSlotChange;
   get isOpen(): boolean;
   openMenu(): void;
   closeMenu(): void;
@@ -1071,6 +1073,26 @@ type TreeItem = {
   data?: unknown;
   /** Icon name passed to an icon component, if icons are enabled. */
   icon?: string;
+  /**
+   * CSS colour applied to the node's icon, overriding the inherited text
+   * colour. Only meaningful when `icon` is set. Components that render the
+   * icon from `icon` honour this; the rest ignore it.
+   */
+  iconColor?: string;
+  /**
+   * CSS colour applied to the node's label. Inline, so it wins over the
+   * selected/tickled text colours — keep it legible against both, or leave
+   * it unset and let the component's theming handle selection contrast.
+   */
+  textColor?: string;
+  /**
+   * Finder-style badge rendered alongside the label — e.g. a colour-tag chip
+   * or a stack of them. Anything Lit can render (usually a `TemplateResult`),
+   * or a DOM `Node` for the components that build their rows imperatively.
+   * Placement is per-component: thumbnails-style lists put it before the
+   * name, list-style views right-justify it on the same line.
+   */
+  badge?: unknown;
   /** Tooltip text shown on hover. */
   tooltip?: string;
   /** Optional string value, e.g. for use as a command/route. */
@@ -1784,6 +1806,13 @@ declare class CrumbPathElement extends LitElement {
   segmentDragLookup: CrumbSegmentDragLookupFn | undefined;
   /** Interprets drops landing on segments; enables drop targeting when set. */
   parseExternalDrop: CrumbExternalDropParser | undefined;
+  /**
+   * When enabled, navigating up (clicking an earlier real segment) keeps
+   * rendering the segments beyond it as translucent, non-interactive-drag,
+   * click-to-restore "virtual" segments — for as long as the current path
+   * stays a prefix of the deepest path visited. See `#recordHintOnShorten`.
+   */
+  hintPrevious: boolean;
   private _openIdx;
   private _editing;
   private _cachedSiblings;
@@ -1797,6 +1826,8 @@ declare class CrumbPathElement extends LitElement {
   private _dragCumPath;
   /** Cumulative path of the segment currently hovered by an external drag (`.drop-into`). */
   private _dropCumPath;
+  /** Deepest relative-segment path visited, kept so it can be restored via virtual segments. */
+  private _hintSegments;
   protected updated(changedProperties: PropertyValues): void;
   setPath(newPath: string): void;
   getPath(): string;
@@ -1938,6 +1969,27 @@ type DataGridColumn<R = unknown> = {
   formatter?: (value: unknown, row: R, col: DataGridColumn<R>) => unknown;
 };
 type GlobalFormatter = (value: unknown, columnName: string, row: unknown) => unknown;
+/**
+ * Optional appearance fields a row may carry, honoured only in the column
+ * nominated by the matching grid property (`textColorColumn`, `iconColumn`,
+ * `badgeColumn`). Read off the *row*, not off the nominated column's own
+ * value, so one row can tint just one of its cells:
+ *
+ * ```ts
+ * grid.textColorColumn = 'status';
+ * grid.rows = [{ status: 'failed', statusTextColor: 'crimson' }];
+ * ```
+ */
+type DataGridRowLook = {
+  /** CSS colour applied to the cell nominated by `textColorColumn`. */
+  textColor?: string;
+  /** Icon content for the cell nominated by `iconColumn` — anything Lit can render. */
+  icon?: unknown;
+  /** CSS colour tinting the row's `icon`. */
+  iconColor?: string;
+  /** Finder-style badge for the cell nominated by `badgeColumn` — anything Lit can render. */
+  badge?: unknown;
+};
 type DataGridEditability = `disabled` | `manual` | `user` | `immediate`;
 /**
  * How cell text that's too long for its column width is handled.
@@ -2680,6 +2732,20 @@ declare class DataGridElement extends LitElement {
    */
   columnMenu: DataGridColumnMenu;
   globalFormatter?: GlobalFormatter;
+  /**
+   * Key of the column whose cell text takes the row's `textColor` — e.g. a
+   * status column that renders a red "Failed" only on some rows.
+   */
+  textColorColumn: string;
+  /**
+   * Key of the column that renders the row's `icon` (tinted by `iconColor`).
+   */
+  iconColumn: string;
+  /**
+   * Key of the column that renders the row's `badge`, right-justified in the
+   * cell after the cell's own value.
+   */
+  badgeColumn: string;
   /**
    * Predicate used by incremental filter-search (and callable directly). Rows
    * for which it returns `false` are dropped from the flat list — hidden from
@@ -2807,6 +2873,13 @@ declare class DataGridElement extends LitElement {
   stopEdit(): void;
   setColumnFormatter(columnKey: string, formatter: ((value: unknown) => unknown) | BuiltInFormatterName | null, options?: BuiltInFormatterOptions): void;
   private _formatValue;
+  /**
+   * Resolve the per-row appearance for the cell at `colKey`, honouring the
+   * nominated columns. Additive — `col.renderer` / `col.formatter` still own
+   * the cell's value; this only decorates it. Returns all-`undefined` for
+   * every cell when nothing is nominated (the common case).
+   */
+  private _cellLook;
   private _handleCellSecondClick;
   private _commitEdit;
   private _suppressBlurCommit;
@@ -3047,6 +3120,29 @@ declare class VerticalListElement extends LitElement {
    * appended.
    */
   formatter: ((item: unknown, index: number) => unknown) | undefined;
+  /**
+   * Per-item icon for adapter (`items`) mode, prepended to the row — a DOM
+   * `Node` or anything Lit can render (usually a `TemplateResult` wrapping an
+   * `<ixfx-icon>` or an inline SVG). Ignored when the `formatter` returns a
+   * full row element (the formatter then owns the whole row, icon included).
+   */
+  icon: ((item: unknown, index: number) => unknown) | undefined;
+  /**
+   * CSS colour tinting the per-item `icon`. Icons paint from `currentColor`,
+   * so this recolours them. Inline, so it wins over selection styling.
+   */
+  iconColor: ((item: unknown, index: number) => string | undefined) | undefined;
+  /**
+   * CSS colour for the row's text. Inline, so it wins over the selected /
+   * tickled text colours — keep it legible against both.
+   */
+  textColor: ((item: unknown, index: number) => string | undefined) | undefined;
+  /**
+   * Finder-style badge for the row, right-justified after the text — a
+   * `TemplateResult`, a DOM `Node`, or anything Lit can render. The row is
+   * flex, so the badge self-justifies to the trailing edge.
+   */
+  badge: ((item: unknown, index: number) => unknown) | undefined;
   /**
    * Virtualize the list: only the overscanned viewport window exists in the
    * DOM; offscreen rows are recycled through an off-DOM pool as the list
@@ -3252,6 +3348,22 @@ declare class DetailListElement extends LitElement {
   displayProperty: string;
   formatter: DetailFormatter | undefined;
   iconProperty: string;
+  /**
+   * Property on each `items` entry holding a CSS colour for the item's
+   * `<ixfx-icon>`. Only read when `iconProperty` also resolves an icon.
+   */
+  iconColorProperty: string;
+  /**
+   * Property on each `items` entry holding a CSS colour for the item's caption
+   * text. Inline, so it wins over the selected/tickled text colours.
+   */
+  textColorProperty: string;
+  /**
+   * Property on each `items` entry holding a Finder-style badge — a
+   * `TemplateResult`, a DOM `Node`, or anything Lit can render. Rendered
+   * right-justified on the row, after the caption.
+   */
+  badgeProperty: string;
   keyProperty: string;
   filterPredicate: ((el: Element) => boolean) | undefined;
   /**
@@ -3366,6 +3478,7 @@ declare class DetailListElement extends LitElement {
    */
   fitColumnWidth(): Promise<number>;
   private _isCheckable;
+  /** Appends the caption span; returns it so callers can style it per item. */
   private _setLabel;
   private _syncItemStates;
   private _syncCheckboxes;
@@ -5377,6 +5490,29 @@ type GridListDataAdapter<T> = {
   render: (item: T, index: number) => unknown;
   disabled?: (item: T, index: number) => boolean;
   searchableText?: (item: T, index: number) => string;
+  /**
+   * Per-item icon, rendered above `render`'s output inside the cell's content
+   * well. Anything Lit can render — a `TemplateResult` (e.g.
+   * `html`<ixfx-icon name=${...}></ixfx-icon>``), a DOM `Node`, or a string.
+   * Return `undefined` for items without an icon.
+   */
+  icon?: (item: T, index: number) => unknown;
+  /**
+   * CSS colour applied to this item's icon, tinting any `currentColor` glyph.
+   * Ignored when `icon` returns nothing. Inline, so it wins over selection
+   * styling.
+   */
+  iconColor?: (item: T, index: number) => string | undefined;
+  /**
+   * CSS colour applied to this item's caption. Inline, so it wins over the
+   * selected/tickled caption colours — keep it legible against both.
+   */
+  textColor?: (item: T, index: number) => string | undefined;
+  /**
+   * Finder-style badge rendered inline at the head of the caption, before the
+   * filename — anything Lit can render, e.g. a colour-tag chip as inline SVG.
+   */
+  badge?: (item: T, index: number) => unknown;
 };
 /**
  * Common detail for per-item events (activate, click, tickle), key-first in
@@ -6286,6 +6422,92 @@ declare global {
   }
 }
 //#endregion
+//#region src/hyperbolic-tree/poincare-math.d.ts
+/** Euclidean norm (`|z|`) of a point. */
+declare function norm(a: Point): number;
+/** Clamp a point to stay strictly inside the unit disk (the Poincaré model's boundary is never reached). */
+declare function clampToDisk(p: Point, maxNorm?: number): Point;
+/**
+ * Möbius transform that translates `a` to the origin: `(z - a) / (1 - conj(a) * z)`.
+ * A hyperbolic isometry — preserves all pairwise Poincaré distances.
+ */
+declare function mobiusToOrigin(z: Point, a: Point): Point;
+/**
+ * Inverse of {@link mobiusToOrigin}: translates the origin back to `a`, i.e.
+ * `(z + a) / (1 + conj(a) * z)`.
+ */
+declare function mobiusFromOrigin(z: Point, a: Point): Point;
+/**
+ * Möbius addition (gyrogroup composition) of two disk-translations: the
+ * canonical-space point reached by translating the origin to `a`, then
+ * translating that local frame's origin by `b`.
+ */
+declare function mobiusAdd(a: Point, b: Point): Point;
+/** Euclidean Poincaré-disk radius corresponding to hyperbolic distance `d` from the origin. */
+declare function euclideanRadiusForHyperbolicDistance(d: number): number;
+/** Hyperbolic distance from the origin corresponding to Euclidean disk radius `r`. */
+declare function hyperbolicDistanceForEuclideanRadius(r: number): number;
+/** Hyperbolic (Poincaré) distance between two points in the unit disk. */
+declare function poincareDistance(p: Point, q: Point): number;
+/**
+ * Point at parameter `t` (0–1) along the hyperbolic geodesic from `a` to `b`.
+ * `t=0` yields `a`, `t=1` yields `b`; intermediate values move at constant
+ * hyperbolic speed along the geodesic (not the Euclidean straight line).
+ */
+declare function geodesicInterpolate(a: Point, b: Point, t: number): Point;
+/**
+ * An orientation-preserving isometry of the Poincaré disk, stored as the
+ * SU(1,1) pair `(a, b)` of the map `z ↦ (a·z + b) / (conj(b)·z + conj(a))`.
+ *
+ * Every disk isometry is a translation *plus a rotation*, and composing two
+ * translations generally yields a rotation too (the hyperbolic "gyration").
+ * Tracking the full map — rather than just "the point that goes to the
+ * origin" — is what keeps a recursively-built local frame correctly oriented.
+ */
+type DiskIsometry = {
+  readonly a: Point;
+  readonly b: Point;
+};
+declare const identityIsometry: DiskIsometry;
+/** Apply `m` to `z`. */
+declare function applyIsometry(m: DiskIsometry, z: Point): Point;
+/** `outer ∘ inner` — apply `inner` first, then `outer`. */
+declare function composeIsometry(outer: DiskIsometry, inner: DiskIsometry): DiskIsometry;
+declare function invertIsometry(m: DiskIsometry): DiskIsometry;
+/** Pure translation carrying the origin to `p` (same map as {@link mobiusFromOrigin}). */
+declare function translationFromOrigin(p: Point): DiskIsometry;
+/** `z ↦ e^{iθ}·z`. */
+declare function rotationIsometry(theta: number): DiskIsometry;
+/**
+ * The view map that sends canonical point `center` to the origin, then
+ * rotates by `rotation` radians: `z ↦ e^{i·rotation}·mobiusToOrigin(z, center)`.
+ */
+declare function viewIsometry(center: Point, rotation?: number): DiskIsometry;
+/** Decompose `m` into the `{ center, rotation }` accepted by {@link viewIsometry}. */
+declare function decomposeViewIsometry(m: DiskIsometry): {
+  center: Point;
+  rotation: number;
+};
+/**
+ * Exact geodesic between `p` and `q`, for rendering: either a straight
+ * segment (when the geodesic is a diameter) or a circular arc orthogonal to
+ * the unit circle. `sweep` follows SVG's `sweep-flag` convention in the
+ * points' own (unflipped) coordinate system; the in-disk segment of an
+ * orthogonal circle is always less than a semicircle, so it's always the
+ * minor arc.
+ */
+type GeodesicSegment = {
+  readonly kind: `line`;
+} | {
+  readonly kind: `arc`;
+  readonly center: Point;
+  readonly radius: number;
+  readonly sweep: 0 | 1;
+};
+declare function geodesicSegment(p: Point, q: Point): GeodesicSegment;
+/** SVG path `d` for the geodesic from `p` to `q`, with coordinates multiplied by `scale`. */
+declare function geodesicPath(p: Point, q: Point, scale?: number): string;
+//#endregion
 //#region src/hyperbolic-tree/types.d.ts
 /**
  * Pointer/keyboard gesture mapping (subset of `TreeInteractionMode`).
@@ -6301,20 +6523,27 @@ type Point = {
 /** A single node positioned on the Poincaré disk. */
 type HyperbolicLayoutNode = {
   readonly node: TreeNode;
+  /** `node.item.key`. Not necessarily unique if the data repeats keys — use {@link id} for identity. */
   readonly key: string;
+  /**
+   * Layout id derived from the key path from the root — unique even when
+   * `item.key`s repeat across the tree (e.g. `readme.md` in many folders).
+   */
+  readonly id: string;
   /** Absolute depth from the true root (root is depth 0). */
   readonly depth: number;
   /** Tree-graph distance (steps) from the current focus — `0` for the focused node itself. */
   readonly ring: number;
   readonly parentKey: string | undefined;
+  readonly parentId: string | undefined;
   /** Poincaré-disk position with the focus projected to the origin. */
   readonly position: Point;
   /**
    * Angular width (radians) this node was allocated by its parent's
-   * partition — root is `2π`. Siblings sharing a narrow wedge (a bushy
-   * ancestor elsewhere in the tree, or many siblings at this level) get a
-   * small value here; renderers can use it to shrink crowded nodes further
-   * than distance-from-focus alone would, so they don't visually overlap.
+   * partition — root is `2π`. Measured in the *parent's canonical local
+   * frame*, not on screen: after refocusing, the same share can look very
+   * different in size. For on-screen crowding use the projected `position`s
+   * (the built-in renderer caps node size by nearest-neighbour distance).
    */
   readonly angularShare: number;
   /** This node's raw `TreeItem.weight`, if set. */
@@ -6331,6 +6560,9 @@ type HyperbolicLayoutNode = {
 type HyperbolicLayoutEdge = {
   readonly fromKey: string;
   readonly toKey: string;
+  /** Layout ids of the endpoints — see {@link HyperbolicLayoutNode.id}. */
+  readonly fromId: string;
+  readonly toId: string;
   readonly from: Point;
   readonly to: Point;
   /**
@@ -6340,7 +6572,10 @@ type HyperbolicLayoutEdge = {
   readonly weightNormalized: number;
 };
 type ComputeHyperbolicLayoutOptions = {
-  /** Key of the node to center the view on. Defaults to the true root. */
+  /**
+   * Node to center the view on: a layout id ({@link HyperbolicLayoutNode.id})
+   * or a plain `item.key` (first depth-first match). Defaults to the true root.
+   */
   focusedKey?: string;
   /** Tree-graph steps from the focus to lay out and render. Defaults to unlimited. */
   maxRadius?: number;
@@ -6350,19 +6585,34 @@ type ComputeHyperbolicLayoutOptions = {
    */
   maxDepth?: number;
   /**
-   * Project around this canonical-space point instead of the focus node's own
-   * canonical position — used mid-animation to interpolate the view smoothly
-   * while `focusedKey` (and therefore the visible node set) stays fixed at
-   * its final value.
+   * Center the view on this point of the focus's local frame instead of the
+   * focus itself (which is that frame's origin).
    */
   centerOverride?: Point;
   /**
-   * Hyperbolic distance placed between each generation. Default `1`.
+   * Full focus-local → screen isometry to project through, taking
+   * precedence over `centerOverride`. Unlike a bare center, this can also
+   * carry a rotation — needed for panning to track the pointer faithfully.
+   * Views are expressed relative to the focus (not the root) so they stay
+   * precise however deep the focus is.
+   */
+  view?: DiskIsometry;
+  /**
+   * Minimum hyperbolic distance placed between each generation (bushy
+   * nodes' children go further, per `siblingSpacing`). Default `1`.
    * Raising it exaggerates the disk's fisheye compression (distant
    * generations crowd the boundary faster, reading as "zooming in" on the
    * focus); lowering it flattens the layout toward a Euclidean-feeling one.
    */
   curvature?: number;
+  /**
+   * Minimum hyperbolic distance between adjacent siblings. Children of a
+   * bushy node are pushed further from it until they're at least this far
+   * apart — so dragging a crowded fan towards the center always spreads it
+   * out (panning can't change hyperbolic distances, only magnify them).
+   * `0` disables it (every child at exactly `curvature`). Default `0.5`.
+   */
+  siblingSpacing?: number;
 };
 type HyperbolicEdgeRenderContext = {
   readonly edge: HyperbolicLayoutEdge;
@@ -6381,6 +6631,15 @@ type HyperbolicFocusDetail = {
 };
 type HyperbolicFocusEvent = CustomEvent<HyperbolicFocusDetail>;
 //#endregion
+//#region src/hyperbolic-tree/render-utils.d.ts
+/**
+ * How nodes are drawn:
+ * - `dot` — a filled circle with the label beside it (thinned when crowded).
+ * - `box` — a rectangle containing the label, shrinking with distance from
+ *   the focus the way the space itself does.
+ */
+type HyperbolicNodeShape = `dot` | `box`;
+//#endregion
 //#region src/hyperbolic-tree/hyperbolictree-list.d.ts
 interface HyperbolicTreeListElementEventMap extends TreeComponentEventMap {
   'select': TreeSelectEvent;
@@ -6399,49 +6658,15 @@ interface HyperbolicTreeListElementEventMap extends TreeComponentEventMap {
  * shared `TreeComponent` interface so existing infrastructure (`TreeDataModel`,
  * `IncrSearchTreeController`, `TreeComponent`-typed code) works unmodified.
  *
- * Differences from `ixfx-tree-list` (deliberate):
- * - **Expand/collapse is reinterpreted as focus change.** Every loaded node is
- *   always laid out; clicking a node re-centers the disk on it (an animated
- *   Möbius transform of the same fixed layout, not a re-layout). `expand`/
- *   `collapse` fire when the new focus is a descendant/ancestor of the
- *   previous one, for interop with existing listeners.
- * - **`interactionMode` drops `checked`** — no checkbox affordance at
- *   disk-edge node scale.
- * - **`exclusivity` is accepted but ignored** — nothing is independently open.
- * - **`filterPredicate` dims** non-matching nodes instead of hiding them.
- * - Dragging empty disk space pans the view without changing focus or
- *   selection — a gesture with no indented-tree analog.
- * - Drag-and-drop and `checkboxRenderer` are out of scope.
- *
- * **Zoom vs. curvature.** `zoom` (default `1`) magnifies the rendered disk
- * around the focus — a post-layout SVG scale, not a re-layout. `curvature`
- * (default `1`) instead changes the layout itself: the hyperbolic distance
- * placed between generations, i.e. how strongly the disk's own compression
- * curves the space. Raising `curvature` crowds distant generations toward
- * the boundary faster (a stronger fisheye) which — unlike `zoom` — also
- * reshapes the relative sizes/spacing of what's near vs. far from the focus,
- * so it reads as "zooming in" on the focus even at `zoom: 1`. Both are also
- * independent of `maxRadius`, which changes how many tree-graph rings get
- * laid out at all.
- *
- * **Weighting.** Set `TreeItem.weight` on any node to influence its visuals.
- * Weight is normalized to `0..1` across the currently-visible node set and
- * exposed as the `--node-weight` CSS custom property on each node's `<g
- * part="node">` (raw value also available as `--node-weight-raw`), and as
- * `--edge-weight` (average of the two endpoints) on each edge's `<path
- * part="edge">`. By default this scales node radius (via `minWeightScale`/
- * `maxWeightScale`), tints node fill toward `--accent`, and thickens edge
- * strokes — override any of that with CSS targeting `::part(dot)`/
- * `::part(edge)`, or the vars themselves.
- *
- * A specific node or edge can be targeted from outside the shadow root by
- * key — each node also exports `node-<key>` and each edge `edge-to-<key>`/
- * `edge-from-<key>` (non-identifier key characters replaced with `-`), e.g.
- * `::part(edge-to-library) { stroke-dasharray: 4 2; }`. (A plain attribute
- * selector like `[data-to="..."]` can't reach across the shadow boundary —
- * those `data-from`/`data-to` attributes are there for JS introspection via
- * `shadowRoot.querySelector`, not CSS from the light DOM.) For anything CSS
- * can't express, use `edgeRenderer` for full custom edges.
+ * Deliberate differences from `ixfx-tree-list`: expand/collapse is
+ * reinterpreted as focus change (`expand`/`collapse` still fire, for
+ * interop); `interactionMode` drops `checked`; `exclusivity` is ignored;
+ * `filterPredicate` dims rather than hides; dragging empty space pans;
+ * drag-and-drop and `checkboxRenderer` are out of scope.
+ *
+ * See `src/hyperbolic-tree/README.md` for zoom vs. curvature, crowded fans,
+ * label legibility, weighting, branch colours, `::part()` targeting and the
+ * full CSS variable list.
  */
 declare class HyperbolicTreeListElement extends LitElement implements TreeComponent, TreeSearchHost {
   #private;
@@ -6471,6 +6696,28 @@ declare class HyperbolicTreeListElement extends LitElement implements TreeCompon
   interactionMode: HyperbolicInteractionMode;
   /** Tree-graph steps from the focus to lay out and render. */
   maxRadius: number;
+  /**
+   * How nodes are drawn: `dot` (filled circle, label beside it) or `box`
+   * (a rectangle containing the label, shrinking with distance from focus).
+   * @default 'dot'
+   */
+  nodeShape: HyperbolicNodeShape;
+  /** `box` mode: labels longer than this are truncated with `…`. `0` disables truncation. */
+  boxMaxChars: number;
+  /**
+   * `box` mode: smallest on-screen label size (CSS px) worth drawing. Boxes
+   * whose label would render smaller — or that would overlap a
+   * higher-priority label — are drawn as small text-less markers instead
+   * (hover one to reveal its label).
+   */
+  minLabelSize: number;
+  /**
+   * Tint each top-level branch (each child of the root, and everything under
+   * it) its own hue, like a classic hyperbolic browser — makes it obvious
+   * which subtree a distant node belongs to. Hues are spread evenly around
+   * the colour wheel from `--hyperbolictree-branch-hue-start`.
+   */
+  colorByBranch: boolean;
   /** Base node dot radius, as a fraction of the disk radius (the disk has radius 1). */
   nodeRadius: number;
   /** Nodes whose scaled radius falls below this (same fraction-of-disk-radius units) render without a label. */
@@ -6480,26 +6727,49 @@ declare class HyperbolicTreeListElement extends LitElement implements TreeCompon
   /** Radius multiplier applied to a node with `weight` at the high end of the currently-visible range. */
   maxWeightScale: number;
   /**
-   * Visual magnification of the rendered disk, centered on the focus — a
-   * plain SVG scale applied after layout, distinct from {@link maxRadius}
-   * (which changes *how many rings* are laid out, and so how much the
-   * Poincaré projection itself compresses distant nodes). `1` is unscaled;
-   * `>1` zooms in, `<1` zooms out. Panning (dragging empty disk space) still
-   * operates in the same pre-zoom disk coordinates, so it keeps feeling
-   * consistent at any zoom level.
+   * Visual (Euclidean) magnification of the rendered disk — a post-layout
+   * scale, distinct from {@link curvature} (which reshapes the layout) and
+   * {@link maxRadius} (how many rings are laid out). Labels stay the same
+   * size on screen, so zooming in spreads crowded labels apart. Zoom
+   * gestures update it; see {@link disableZoomGestures}.
    */
   zoom: number;
   /**
-   * Hyperbolic distance placed between each generation — how much the space
-   * itself is curved, as distinct from {@link zoom} (a flat post-layout
-   * magnification). `1` is the standard Poincaré-disk layout. Raising it
-   * pushes each generation further out, so the disk's own `tanh` compression
-   * crowds distant generations toward the boundary faster: a stronger
-   * fisheye, which reads as "zooming in" on the focus even though `zoom`
-   * hasn't changed. Lowering it spreads generations out more evenly,
-   * flattening the view toward a Euclidean-feeling layout.
+   * Turn off zoom gestures: trackpad pinch / Ctrl-⌘-wheel (over the tree),
+   * plain wheel (while the tree has keyboard focus), and two-finger touch
+   * pinch. All zoom around the pointer, and update {@link zoom}.
+   */
+  disableZoomGestures: boolean;
+  /**
+   * Turn off radial labels. By default a label runs along its node's
+   * incoming edge (flipped on the left half so it never reads upside-down),
+   * so a fan of siblings only needs room for each label's height, not its
+   * width. Disabled, every label is horizontal.
+   */
+  disableRadialLabels: boolean;
+  /**
+   * Turn off the child preview: hovering (or keyboard-tickling) a node whose
+   * children aren't all legible in the current view — labels culled, or
+   * beyond `maxRadius` — pops up a clickable list of them.
+   */
+  disableChildPreview: boolean;
+  /**
+   * Minimum hyperbolic distance placed between generations — how curved the
+   * space is. Raising it crowds distant generations toward the boundary
+   * faster (a stronger fisheye that reads as "zooming in" on the focus);
+   * lowering it flattens the view toward a Euclidean-feeling layout.
    */
   curvature: number;
+  /**
+   * Minimum hyperbolic distance between adjacent siblings. A bushy node's
+   * children are pushed further out until they're at least this far apart,
+   * so dragging a crowded fan towards the center always spreads it out —
+   * panning can't change hyperbolic distances, only magnify them, so without
+   * this a tightly-packed fan stays packed wherever it's dragged. Larger
+   * values fan out more when inspected, at the cost of pushing crowds further
+   * towards the edge in the overview. `0` disables it.
+   */
+  siblingSpacing: number;
   /** Duration (ms) of the animated re-center on focus change. `0` snaps instantly. */
   focusAnimationDuration: number;
   /** Optional custom renderer for edges, in place of the default geodesic-arc path. */
@@ -6518,17 +6788,37 @@ declare class HyperbolicTreeListElement extends LitElement implements TreeCompon
   searchModes: string | undefined;
   /** The node currently centered on the disk. Pure view-state — `root` is never mutated by focus changes. */
   get focusedNode(): TreeNode | undefined;
-  private _focusKey;
-  /** Interpolated canonical-space view center while a focus-change animation is in flight; `undefined` when settled. */
-  private _animCenter;
-  /** Extra pan offset applied on top of the focus center, from dragging empty disk space. */
-  private _panOffset;
+  /**
+   * Layout id (see `HyperbolicLayoutNode.id`) of the focused node —
+   * `undefined` means the root. Ids rather than `item.key`s, so data that
+   * repeats keys across branches still focuses the node actually clicked.
+   */
+  private _focusId;
+  /**
+   * Canonical → screen projection overriding the settled "focus at the
+   * center" view — set per-frame while a focus change animates, and by
+   * panning. `undefined` when settled on the focus.
+   */
+  private _viewOverride;
+  /**
+   * Orientation of the settled view (focus at the center). Views are
+   * expressed in the focus's own local frame, and focus changes keep
+   * whatever orientation the tree had when the animation started, so there
+   * is no global "up" to snap back to — and no spin on refocus.
+   */
+  private _focusRotation;
+  /** Pan of the zoomed disk, in screen units — see {@link ZoomState}. */
+  private _zoomOffset;
+  /** Layout id of the node whose children are being previewed. */
+  private _previewId;
   /** Incremental search (navigate / select / filter). See `docs/infra-incremental.md`. */
   readonly search: ListSearchController<{
     node: TreeNode;
     depth: number;
   }>;
   private tickled;
+  /** The host's size in CSS px. */
+  private _hostSize;
   connectedCallback(): void;
   disconnectedCallback(): void;
   protected updated(changedProps: PropertyValues): void;
@@ -6582,12 +6872,54 @@ interface HyperbolicTreeListElement {
 //#region src/hyperbolic-tree/layout.d.ts
 type CanonicalEntry = {
   readonly node: TreeNode;
+  /** Path-derived id, unique even when `item.key`s repeat — see {@link hyperbolicChildIds}. */
+  readonly id: string;
   readonly depth: number;
   readonly parentKey: string | undefined;
+  readonly parentId: string | undefined;
+  /**
+   * Root-anchored position. Informational only: every step away from the
+   * root pushes it exponentially closer to the disk boundary, so beyond
+   * ~14 hyperbolic units (e.g. depth 5 at `curvature` 3) it saturates to the
+   * clamp limit and distinct nodes collapse together. Views are built from
+   * {@link toParent} instead — see {@link hyperbolicRelativeFrame}.
+   */
   readonly position: Point;
+  /**
+   * This node's local frame expressed in its parent's local frame — the
+   * single short hop (a translation by one generation) from parent to
+   * child. Identity for the root. Composing these outward from the focus
+   * keeps every visible position precise, however deep the focus sits.
+   */
+  readonly toParent: DiskIsometry;
   /** Angular width (radians) this node's own parent allocated to it — root is `2π`. */
   readonly angularShare: number;
 };
+/**
+ * Path-derived ids for `children` of the node with id `parentId`. `TreeItem.key`
+ * is meant to be unique, but real data (e.g. a file system, where `readme.md`
+ * recurs in many folders) often only has keys unique among siblings. Keying
+ * the layout on `item.key` alone would silently merge those nodes — edges get
+ * attached to the wrong parent and clicks focus the wrong node — so the
+ * layout identifies nodes by their key path instead. Repeated keys among
+ * siblings are disambiguated by occurrence count. The root's id is its key.
+ */
+declare function hyperbolicChildIds(parentId: string, children: readonly TreeNode[]): string[];
+/** Depth (root is 0) of the node with layout id `id`. */
+declare function hyperbolicIdDepth(id: string): number;
+/**
+ * Layout id of the root's child that `id` descends from (or is) — i.e. which
+ * top-level branch it belongs to. `undefined` for the root itself.
+ */
+declare function hyperbolicBranchId(id: string): string | undefined;
+/** Whether layout id `id` is a strict descendant of `ancestorId`. */
+declare function isHyperbolicDescendantId(id: string, ancestorId: string): boolean;
+/** Chain of nodes from `root` down to the node with layout id `id`, or `undefined` if absent. */
+declare function findHyperbolicPathById(root: TreeNode | undefined, id: string): TreeNode[] | undefined;
+/** Layout id of `target` (matched by object identity) within `root`, or `undefined` if absent. */
+declare function findHyperbolicIdOf(root: TreeNode | undefined, target: TreeNode): string | undefined;
+/** Key path (from the root's children) to the first node, depth-first, satisfying `predicate`. */
+declare function findHyperbolicKeyPath(nodes: readonly TreeNode[], predicate: (node: TreeNode) => boolean, prefix?: readonly string[]): string[] | undefined;
 /** Depth-first search for the node with `key`. Returns `undefined` when absent. */
 declare function findHyperbolicNode(root: TreeNode | undefined, key: string): TreeNode | undefined;
 /**
@@ -6595,21 +6927,37 @@ declare function findHyperbolicNode(root: TreeNode | undefined, key: string): Tr
  * Returns `undefined` when the key is absent. The first entry is always `root`.
  */
 declare function findHyperbolicPath(root: TreeNode | undefined, key: string): TreeNode[] | undefined;
+/** Default minimum hyperbolic distance between adjacent siblings. See {@link childDistance}. */
+declare const DEFAULT_SIBLING_SPACING = 0.5;
 /**
  * Canonical (true-root-anchored) hyperbolic position of every currently-loaded
- * node, keyed by node key. Positions never depend on the current focus —
+ * node, keyed by layout id (see {@link hyperbolicChildIds}). Positions never depend on the current focus —
  * refocusing is purely a Möbius re-projection of these fixed coordinates, so
  * the tree never needs to be re-laid-out when the focus changes.
  *
  * Each node holds an angular wedge — inherited from its parent, expressed in
  * its *own* local frame (root starts with the full `[-π, π]`) — across which
- * its children are placed at hyperbolic distance `curvature` (default `1`).
- * That wedge is partitioned among the children, weighted by each child's own
+ * its children are placed at hyperbolic distance of at least `curvature`
+ * (default `1`) — further for a thin slice, per `siblingSpacing` (see
+ * {@link childDistance}).
+ * That wedge is partitioned among the children, weighted by √ of each child's own
  * subtree size rather than split evenly, and each child's own share is
  * carried into its local frame via {@link boundaryAngleInLocalFrame} before
- * recursing. This is a strict partition (slices never overlap and always sum
- * to the parent's own wedge), which is what guarantees sibling subtrees never
- * spatially cross regardless of how deep or bushy they are.
+ * recursing. This is a strict partition, and each child's wedge region
+ * (bounded by geodesic rays to the same two ideal boundary points as its
+ * slice) nests inside its parent's, which is what guarantees sibling
+ * subtrees never spatially cross regardless of how deep or bushy they are.
+ *
+ * Every node's local frame is tracked as a full {@link DiskIsometry}
+ * (local → canonical), built by composing its parent's frame with the
+ * translation to the child. Composing Möbius translations introduces a
+ * rotation (gyration); dropping it — i.e. assuming a node's frame is simply
+ * `mobiusToOrigin(·, position)` — makes every wedge from depth 3 onward
+ * point in a subtly wrong direction, so subtrees cross each other.
+ *
+ * A wedge wider than π is narrowed to π (around the same bisector) before
+ * the child recurses into it: a near-full-circle wedge would otherwise fan
+ * that child's own children back around towards — and across — its parent.
  *
  * `curvature` scales how far apart (in hyperbolic distance) each generation
  * sits. Raising it pushes each generation further out, so the Poincaré
@@ -6618,58 +6966,34 @@ declare function findHyperbolicPath(root: TreeNode | undefined, key: string): Tr
  * in" on the focus. Lowering it spreads generations out more evenly,
  * flattening the view toward a Euclidean-feeling layout.
  */
-declare function computeCanonicalPositions(root: TreeNode | undefined, maxDepth?: number, curvature?: number): Map<string, CanonicalEntry>;
+declare function computeCanonicalPositions(root: TreeNode | undefined, maxDepth?: number, curvature?: number, siblingSpacing?: number): Map<string, CanonicalEntry>;
+/**
+ * The frame of node `toId` expressed in node `fromId`'s local frame (maps
+ * `toId`-local coordinates to `fromId`-local ones), composed along the tree
+ * path between them via their lowest common ancestor. Used to hand a view
+ * over from one focus to another without passing through root-anchored
+ * coordinates. `undefined` if either id is absent.
+ */
+declare function hyperbolicRelativeFrame(entries: ReadonlyMap<string, CanonicalEntry>, fromId: string, toId: string): DiskIsometry | undefined;
 /**
  * Compute the visible nodes/edges of a hyperbolic tree view: every
  * currently-loaded node within `maxRadius` tree-graph steps of the focused
  * node, projected onto the Poincaré disk with the focus at its center.
  *
  * @param root True tree root. `undefined` yields an empty layout.
- * @param options `focusedKey` (default the true root; unknown keys fall back
- *   to the true root), `maxRadius` (default unlimited), `maxDepth` (safety
- *   cap on canonical-position recursion depth, default 24), `centerOverride`
- *   (project around this canonical-space point instead of the focus node's
- *   own position — used to animate smoothly between foci).
+ * @param options `focusedKey` (a layout id or plain `item.key`; default the
+ *   true root; unknown keys fall back to the true root), `maxRadius` (default unlimited), `maxDepth` (safety
+ *   cap on layout recursion depth, default 24), `curvature`,
+ *   `siblingSpacing`, `centerOverride` (put this point of the focus's local
+ *   frame at the center instead of the focus itself), `view` (a full
+ *   focus-local → screen isometry, taking precedence over `centerOverride` —
+ *   used for panning and animation, which also rotate).
  */
 declare function computeHyperbolicLayout(root: TreeNode | undefined, options?: ComputeHyperbolicLayoutOptions): {
   nodes: HyperbolicLayoutNode[];
   edges: HyperbolicLayoutEdge[];
 };
 //#endregion
-//#region src/hyperbolic-tree/poincare-math.d.ts
-/** Euclidean norm (`|z|`) of a point. */
-declare function norm(a: Point): number;
-/** Clamp a point to stay strictly inside the unit disk (the Poincaré model's boundary is never reached). */
-declare function clampToDisk(p: Point, maxNorm?: number): Point;
-/**
- * Möbius transform that translates `a` to the origin: `(z - a) / (1 - conj(a) * z)`.
- * A hyperbolic isometry — preserves all pairwise Poincaré distances.
- */
-declare function mobiusToOrigin(z: Point, a: Point): Point;
-/**
- * Inverse of {@link mobiusToOrigin}: translates the origin back to `a`, i.e.
- * `(z + a) / (1 + conj(a) * z)`.
- */
-declare function mobiusFromOrigin(z: Point, a: Point): Point;
-/**
- * Möbius addition (gyrogroup composition) of two disk-translations: the
- * canonical-space point reached by translating the origin to `a`, then
- * translating that local frame's origin by `b`.
- */
-declare function mobiusAdd(a: Point, b: Point): Point;
-/** Euclidean Poincaré-disk radius corresponding to hyperbolic distance `d` from the origin. */
-declare function euclideanRadiusForHyperbolicDistance(d: number): number;
-/** Hyperbolic distance from the origin corresponding to Euclidean disk radius `r`. */
-declare function hyperbolicDistanceForEuclideanRadius(r: number): number;
-/** Hyperbolic (Poincaré) distance between two points in the unit disk. */
-declare function poincareDistance(p: Point, q: Point): number;
-/**
- * Point at parameter `t` (0–1) along the hyperbolic geodesic from `a` to `b`.
- * `t=0` yields `a`, `t=1` yields `b`; intermediate values move at constant
- * hyperbolic speed along the geodesic (not the Euclidean straight line).
- */
-declare function geodesicInterpolate(a: Point, b: Point, t: number): Point;
-//#endregion
 //#region src/icicle-tree/types.d.ts
 /**
  * Weight accessor — returns the area share of `item` within its siblings.
@@ -10339,5 +10663,5 @@ 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, Checkbox, CheckboxChangeDetail, CheckboxChangeEvent, CheckboxEventMap, 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, 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, DataGridSelectDetail, DataGridSelectEvent, type DataGridSelectionMode, DataGridSortDetail, type DataGridSortDirection, DataGridSortEvent, type DataGridSortState, DataGridViewportChangeDetail, DataGridViewportChangeEvent, type DataListSearchAdapterOptions, type DataListSearchItem, DataProviderResult, DataTableElement, DataTableElementEventMap, DataTableRow, DataTableRowClickDetail, DataTableRowClickEvent, type DetailFormatter, DetailListElement, DetailListElementEventMap, type DetailSortComparator, type DetailSortItem, type DetailSortMode, 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, EditableLabel, EditableLabelChangeDetail, EditableLabelChangeEvent, EditableMode, EditableNumber, Effect, type ElementIncrSearch, type ElementIncrSearchOptions, type ElementListSearchAdapterOptions, type ElementListSearchHost, Endpoints, EntryMode, FormElement, FormGroupElement, FormPartElement, FormatValueForHuman, FormattingOptions, type FuzzySearch, type FuzzySearchOptions, FuzzySearchResult, 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 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, 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 ListDragEntry, type ListDragPreview, type ListDragPreviewContext, type ListDragPreviewRenderer, type ListDragPreviewSourceResolver, ListDragSelectController, type ListDragSelectControllerConfig, type ListDragSource, type ListElementEventMap, 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, applySnapshot, applyTreeDrop, attachTimelineInteractions, bottomDrawerCommandId, buildHighlightTargets, buildModel, captionForEntry, clampToDisk, clearHighlights, collectContainerNames, collectDataResult, collectPanelIds, collectStackPaths, computeCanonicalPositions, computeColour, computeHyperbolicLayout, computeIcicleLayout, computeLeafGeoms, computeTreemapLayout, createAcCompletionProvider, createDataListSearchAdapter, createDefaultListDragPreview, createElementIncrSearch, createElementListSearchAdapter, createEmptyLayout, createEmptyStack, createFuzzySearch, createIncrSearch, createPillRenderer, createSplit, createStack, createTreeListAdapter, createTreeListSearchAdapter, createVerticalListAdapter, distribute, dropTargetFor, euclideanRadiusForHyperbolicDistance, extractStack, findHyperbolicNode, findHyperbolicPath, findIcicleNode, findIciclePath, findNode, findPanelNode, findParentOf, findStackOf, findStackPathByName, findTreemapNode, findTreemapPath, geodesicInterpolate, getActiveDragPanelId, getIcon, getIconEntry, getIconFont, getLeafNeighbours, hasIcon, hyperbolicDistanceForEuclideanRadius, iconBus, init, insertBeside, isDragging, isMultiMode, isSplit, isStack, keyForElement, listItemFadeKeyframes, listSearchStyles, mobiusAdd, mobiusFromOrigin, mobiusToOrigin, monitorIndeterminate, moveLeafNodeToEdge, moveLeafStep, norm, normalise, normaliseValue, normalize, panelGapIndex, parseColourScaleAttr, parseLayout, poincareDistance, pointerOverAnyHost, prefersReducedMotion, preserveRestoreWeights, pruneDraggedDescendants, readBaseColour, registerFontIcon, registerIcon, registerListSearchCommands, removePanelFromStack, resolveCssVars, resolveGrid, resolveLeafPath, resolveTracks, serializeLayout, setActive, setIconFont, setPanelRestoreWeight, startListItemOutAnimation, svgToDataUri, swapLeaves, tickledItemStyles, tickledStyles, timelineStyles, toSnapshot, toolbarGapIndex, walk, wrapRoot };
+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, Checkbox, CheckboxChangeDetail, CheckboxChangeEvent, CheckboxEventMap, 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, 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, EditableLabel, EditableLabelChangeDetail, EditableLabelChangeEvent, EditableMode, EditableNumber, Effect, type ElementIncrSearch, type ElementIncrSearchOptions, type ElementListSearchAdapterOptions, type ElementListSearchHost, Endpoints, EntryMode, 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, 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 ListDragEntry, type ListDragPreview, type ListDragPreviewContext, type ListDragPreviewRenderer, type ListDragPreviewSourceResolver, ListDragSelectController, type ListDragSelectControllerConfig, type ListDragSource, type ListElementEventMap, 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, 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, poincareDistance, pointerOverAnyHost, prefersReducedMotion, preserveRestoreWeights, pruneDraggedDescendants, readBaseColour, registerFontIcon, registerIcon, registerListSearchCommands, removePanelFromStack, resolveCssVars, resolveGrid, resolveLeafPath, resolveTracks, rotationIsometry, serializeLayout, setActive, setIconFont, setPanelRestoreWeight, startListItemOutAnimation, svgToDataUri, swapLeaves, tickledItemStyles, tickledStyles, timelineStyles, toSnapshot, toolbarGapIndex, translationFromOrigin, viewIsometry, walk, wrapRoot };
 //# sourceMappingURL=index.d.ts.map