@aceshooting/lyra-ui 3.6.0 → 3.8.0

package/dist/components/graph/graph-loader.d.ts

@@ -8,6 +8,12 @@ export interface D3Modules {
     forceCollide: <Node extends D3Module = D3Module>(radius?: number | ((node: Node) => number)) => D3Module;
     drag: <Element extends D3Module = D3Module, Datum extends D3Module = D3Module>() => D3Module;
     zoom: <Element extends D3Module = D3Module, Datum extends D3Module = D3Module>() => D3Module;
+    /** The identity transform (`k=1, x=0, y=0`) — the starting point for constructing an absolute
+     *  camera transform via `.translate(x, y).scale(k)`, used by `focusNode()`/`fit()`. */
+    zoomIdentity: D3Module;
+    /** Reads the transform currently bound to a DOM node via d3-zoom (its internal `__zoom`
+     *  datum) — used to read the current scale/position before tweening to a new one. */
+    zoomTransform: (node: Element) => D3Module;
     select: <Element extends D3Module = D3Module, Datum extends D3Module = D3Module>(node?: Element) => D3Module;
 }
 /**

package/dist/components/graph/graph-loader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph-loader.d.ts","sourceRoot":"","sources":["../../../src/components/graph/graph-loader.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uCAAuC,CAAC;AAE7E,KAAK,QAAQ,GAAG,eAAe,CAAC;AAEhC,MAAM,WAAW,SAAS;IACxB,eAAe,EAAE,CAAC,IAAI,SAAS,QAAQ,GAAG,QAAQ,EAAE,KAAK,CAAC,EAAE,QAAQ,CAAC,IAAI,CAAC,KAAK,QAAQ,CAAC;IACxF,SAAS,EAAE,CAAC,IAAI,SAAS,QAAQ,GAAG,QAAQ,EAAE,IAAI,SAAS,QAAQ,GAAG,QAAQ,EAC5E,KAAK,CAAC,EAAE,QAAQ,CAAC,IAAI,CAAC,KACnB,QAAQ,CAAC;IACd,aAAa,EAAE,CAAC,IAAI,SAAS,QAAQ,GAAG,QAAQ,OAAO,QAAQ,CAAC;IAChE,WAAW,EAAE,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,QAAQ,CAAC;IAClD,YAAY,EAAE,CAAC,IAAI,SAAS,QAAQ,GAAG,QAAQ,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,CAAC,CAAC,IAAI,EAAE,IAAI,KAAK,MAAM,CAAC,KAAK,QAAQ,CAAC;IACzG,IAAI,EAAE,CAAC,OAAO,SAAS,QAAQ,GAAG,QAAQ,EAAE,KAAK,SAAS,QAAQ,GAAG,QAAQ,OAAO,QAAQ,CAAC;IAC7F,IAAI,EAAE,CAAC,OAAO,SAAS,QAAQ,GAAG,QAAQ,EAAE,KAAK,SAAS,QAAQ,GAAG,QAAQ,OAAO,QAAQ,CAAC;IAC7F,MAAM,EAAE,CAAC,OAAO,SAAS,QAAQ,GAAG,QAAQ,EAAE,KAAK,SAAS,QAAQ,GAAG,QAAQ,EAAE,IAAI,CAAC,EAAE,OAAO,KAAK,QAAQ,CAAC;CAC9G;AAED;;;;;;GAMG;AACH,wBAAsB,aAAa,CACjC,WAAW,GAAE,MAAM,OAAO,CAAC,QAAQ,CAAiD,EACpF,UAAU,GAAE,MAAM,OAAO,CAAC,QAAQ,CAAgD,EAClF,UAAU,GAAE,MAAM,OAAO,CAAC,QAAQ,CAAgD,EAClF,eAAe,GAAE,MAAM,OAAO,CAAC,QAAQ,CAAqD,GAC3F,OAAO,CAAC,SAAS,GAAG,IAAI,CAAC,CA0B3B;AAID;;;;GAIG;AACH,wBAAgB,MAAM,IAAI,OAAO,CAAC,SAAS,GAAG,IAAI,CAAC,CAKlD"}
+{"version":3,"file":"graph-loader.d.ts","sourceRoot":"","sources":["../../../src/components/graph/graph-loader.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uCAAuC,CAAC;AAE7E,KAAK,QAAQ,GAAG,eAAe,CAAC;AAEhC,MAAM,WAAW,SAAS;IACxB,eAAe,EAAE,CAAC,IAAI,SAAS,QAAQ,GAAG,QAAQ,EAAE,KAAK,CAAC,EAAE,QAAQ,CAAC,IAAI,CAAC,KAAK,QAAQ,CAAC;IACxF,SAAS,EAAE,CAAC,IAAI,SAAS,QAAQ,GAAG,QAAQ,EAAE,IAAI,SAAS,QAAQ,GAAG,QAAQ,EAC5E,KAAK,CAAC,EAAE,QAAQ,CAAC,IAAI,CAAC,KACnB,QAAQ,CAAC;IACd,aAAa,EAAE,CAAC,IAAI,SAAS,QAAQ,GAAG,QAAQ,OAAO,QAAQ,CAAC;IAChE,WAAW,EAAE,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,QAAQ,CAAC;IAClD,YAAY,EAAE,CAAC,IAAI,SAAS,QAAQ,GAAG,QAAQ,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,CAAC,CAAC,IAAI,EAAE,IAAI,KAAK,MAAM,CAAC,KAAK,QAAQ,CAAC;IACzG,IAAI,EAAE,CAAC,OAAO,SAAS,QAAQ,GAAG,QAAQ,EAAE,KAAK,SAAS,QAAQ,GAAG,QAAQ,OAAO,QAAQ,CAAC;IAC7F,IAAI,EAAE,CAAC,OAAO,SAAS,QAAQ,GAAG,QAAQ,EAAE,KAAK,SAAS,QAAQ,GAAG,QAAQ,OAAO,QAAQ,CAAC;IAC7F;2FACuF;IACvF,YAAY,EAAE,QAAQ,CAAC;IACvB;yFACqF;IACrF,aAAa,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,QAAQ,CAAC;IAC3C,MAAM,EAAE,CAAC,OAAO,SAAS,QAAQ,GAAG,QAAQ,EAAE,KAAK,SAAS,QAAQ,GAAG,QAAQ,EAAE,IAAI,CAAC,EAAE,OAAO,KAAK,QAAQ,CAAC;CAC9G;AAED;;;;;;GAMG;AACH,wBAAsB,aAAa,CACjC,WAAW,GAAE,MAAM,OAAO,CAAC,QAAQ,CAAiD,EACpF,UAAU,GAAE,MAAM,OAAO,CAAC,QAAQ,CAAgD,EAClF,UAAU,GAAE,MAAM,OAAO,CAAC,QAAQ,CAAgD,EAClF,eAAe,GAAE,MAAM,OAAO,CAAC,QAAQ,CAAqD,GAC3F,OAAO,CAAC,SAAS,GAAG,IAAI,CAAC,CA4B3B;AAID;;;;GAIG;AACH,wBAAgB,MAAM,IAAI,OAAO,CAAC,SAAS,GAAG,IAAI,CAAC,CAKlD"}

package/dist/components/graph/graph-loader.js

@@ -21,6 +21,8 @@ export async function loadD3Modules(importForce = () => import('d3-force'), impo
             forceCollide: force.forceCollide,
             drag: dragMod.drag,
             zoom: zoomMod.zoom,
+            zoomIdentity: zoomMod.zoomIdentity,
+            zoomTransform: zoomMod.zoomTransform,
             select: selectionMod.select,
         };
     }

package/dist/components/graph/graph-loader.js.map

@@ -1 +1 @@
-{"version":3,"file":"graph-loader.js","sourceRoot":"","sources":["../../../src/components/graph/graph-loader.ts"],"names":[],"mappings":"AAiBA;;;;;;GAMG;AACH,MAAM,CAAC,KAAK,UAAU,aAAa,CACjC,WAAW,GAA4B,GAAG,EAAE,CAAC,MAAM,CAAC,UAAU,CAAsB,EACpF,UAAU,GAA4B,GAAG,EAAE,CAAC,MAAM,CAAC,SAAS,CAAsB,EAClF,UAAU,GAA4B,GAAG,EAAE,CAAC,MAAM,CAAC,SAAS,CAAsB,EAClF,eAAe,GAA4B,GAAG,EAAE,CAAC,MAAM,CAAC,cAAc,CAAsB;IAE5F,IAAI,CAAC;QACH,MAAM,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,YAAY,CAAC,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC;YAChE,WAAW,EAAE;YACb,UAAU,EAAE;YACZ,UAAU,EAAE;YACZ,eAAe,EAAE;SAClB,CAAC,CAAC;QACH,OAAO;YACL,eAAe,EAAE,KAAK,CAAC,eAAe;YACtC,SAAS,EAAE,KAAK,CAAC,SAAS;YAC1B,aAAa,EAAE,KAAK,CAAC,aAAa;YAClC,WAAW,EAAE,KAAK,CAAC,WAAW;YAC9B,YAAY,EAAE,KAAK,CAAC,YAAY;YAChC,IAAI,EAAE,OAAO,CAAC,IAAI;YAClB,IAAI,EAAE,OAAO,CAAC,IAAI;YAClB,MAAM,EAAE,YAAY,CAAC,MAAM;SAC5B,CAAC;IACJ,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,OAAO,CAAC,IAAI,CACV,2EAA2E;YACzE,qGAAqG,EACvG,GAAG,CACJ,CAAC;QACF,OAAO,IAAI,CAAC;IACd,CAAC;AACH,CAAC;AAED,IAAI,SAAgD,CAAC;AAErD;;;;GAIG;AACH,MAAM,UAAU,MAAM;IACpB,IAAI,CAAC,SAAS,EAAE,CAAC;QACf,SAAS,GAAG,aAAa,EAAE,CAAC;IAC9B,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC"}
+{"version":3,"file":"graph-loader.js","sourceRoot":"","sources":["../../../src/components/graph/graph-loader.ts"],"names":[],"mappings":"AAuBA;;;;;;GAMG;AACH,MAAM,CAAC,KAAK,UAAU,aAAa,CACjC,WAAW,GAA4B,GAAG,EAAE,CAAC,MAAM,CAAC,UAAU,CAAsB,EACpF,UAAU,GAA4B,GAAG,EAAE,CAAC,MAAM,CAAC,SAAS,CAAsB,EAClF,UAAU,GAA4B,GAAG,EAAE,CAAC,MAAM,CAAC,SAAS,CAAsB,EAClF,eAAe,GAA4B,GAAG,EAAE,CAAC,MAAM,CAAC,cAAc,CAAsB;IAE5F,IAAI,CAAC;QACH,MAAM,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,YAAY,CAAC,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC;YAChE,WAAW,EAAE;YACb,UAAU,EAAE;YACZ,UAAU,EAAE;YACZ,eAAe,EAAE;SAClB,CAAC,CAAC;QACH,OAAO;YACL,eAAe,EAAE,KAAK,CAAC,eAAe;YACtC,SAAS,EAAE,KAAK,CAAC,SAAS;YAC1B,aAAa,EAAE,KAAK,CAAC,aAAa;YAClC,WAAW,EAAE,KAAK,CAAC,WAAW;YAC9B,YAAY,EAAE,KAAK,CAAC,YAAY;YAChC,IAAI,EAAE,OAAO,CAAC,IAAI;YAClB,IAAI,EAAE,OAAO,CAAC,IAAI;YAClB,YAAY,EAAE,OAAO,CAAC,YAAY;YAClC,aAAa,EAAE,OAAO,CAAC,aAAa;YACpC,MAAM,EAAE,YAAY,CAAC,MAAM;SAC5B,CAAC;IACJ,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,OAAO,CAAC,IAAI,CACV,2EAA2E;YACzE,qGAAqG,EACvG,GAAG,CACJ,CAAC;QACF,OAAO,IAAI,CAAC;IACd,CAAC;AACH,CAAC;AAED,IAAI,SAAgD,CAAC;AAErD;;;;GAIG;AACH,MAAM,UAAU,MAAM;IACpB,IAAI,CAAC,SAAS,EAAE,CAAC;QACf,SAAS,GAAG,aAAa,EAAE,CAAC;IAC9B,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC"}

package/dist/components/graph/graph.class.d.ts

@@ -11,6 +11,36 @@ export interface GraphNode {
     /** Clamped to [6, 24] (a non-finite/missing value uses the midpoint, 15) — never rendered smaller/larger. */
     radius?: number;
     color?: string;
+    /** Key into `nodeTypes` (by `GraphNodeType.id`) and `hiddenTypes`. Unknown/absent = untyped
+     *  (renders as a default circle with the token fill, but still participates in `hiddenTypes`
+     *  filtering by its raw string value even with no matching `nodeTypes` entry). */
+    type?: string;
+    /** Renders a "+" adornment (`part="expand-indicator"`) and marks the node expandable in spoken
+     *  text via `graphExpandableItem`. Controlled -- the component never clears this on its own; a
+     *  consumer flips it (or leaves it) after appending neighbors in response to a `lyra-node-expand`.
+     *  Does not gate the `lyra-node-expand` event itself, which fires for any node's double-activate. */
+    expandable?: boolean;
+    /** Community membership shorthand, unioned with any `GraphCommunity.memberIds` that also lists
+     *  this node's id. */
+    communityId?: string;
+}
+/** One entry in `nodeTypes` — declares a node type's legend label, optional fill color (sanitized
+ *  like `GraphNode.color`), and rendered shape. */
+export interface GraphNodeType {
+    id: string;
+    label: string;
+    color?: string;
+    shape?: 'circle' | 'square' | 'diamond';
+}
+/** One entry in `communities` — declares a hull's id, optional label/fill color (sanitized like
+ *  `GraphNode.color`), and explicit membership. A node also joins this hull when its own
+ *  `GraphNode.communityId` matches this entry's `id`, so `memberIds` and `communityId` are two
+ *  ways to express the same membership relationship. */
+export interface GraphCommunity {
+    id: string;
+    label?: string;
+    memberIds: string[];
+    color?: string;
 }
 /** A link whose `target` id has no matching node renders as a short dashed stub off `source`'s
  *  own position instead of being silently dropped -- e.g. for a wiki-style `[[link]]` reference to
@@ -39,12 +69,40 @@ export interface GraphLink {
 export interface LyraGraphEventMap {
     'lyra-node-click': CustomEvent<{
         id: string;
+        x: number;
+        y: number;
     }>;
     'lyra-link-click': CustomEvent<{
         source: string;
         target: string;
         id?: string;
     }>;
+    'lyra-node-enter': CustomEvent<{
+        id: string;
+    }>;
+    'lyra-node-leave': CustomEvent<{
+        id: string;
+    }>;
+    'lyra-link-enter': CustomEvent<{
+        source: string;
+        target: string;
+        id?: string;
+    }>;
+    'lyra-link-leave': CustomEvent<{
+        source: string;
+        target: string;
+        id?: string;
+    }>;
+    'lyra-node-expand': CustomEvent<{
+        id: string;
+    }>;
+    'lyra-selection-change': CustomEvent<{
+        nodeIds: string[];
+        linkIds: string[];
+    }>;
+    'lyra-community-click': CustomEvent<{
+        id: string;
+    }>;
 }
 /**
  * `<lyra-graph>` — a force-directed node-link diagram with pan/zoom/drag.
@@ -61,25 +119,113 @@ export interface LyraGraphEventMap {
  * already-rendered graph is a no-op; nothing re-derives already-positioned
  * nodes' x/y from the new value.
  *
+ * `hiddenTypes` filters nodes/links by `GraphNode.type` without discarding position state --
+ * `lastPositionById` remembers every node's last settled x/y across a hide/show round-trip, so
+ * toggling a type off and back on restores each node where it was instead of re-randomizing it.
+ *
+ * `communities` draws one translucent convex-hull blob per entry, behind links/nodes -- a hull's
+ * membership is the union of its own `memberIds` and every node whose `communityId` matches its
+ * `id`. A community with no currently-visible members (all its nodes hidden by `hiddenTypes`, or
+ * simply empty) renders no hull.
+ *
+ * `layout="layered"` swaps the d3-force simulation for a deterministic layered layout (see
+ * `src/internal/layered-layout.ts`) -- node drag is disabled in that mode, and `chargeStrength` is
+ * a documented no-op.
+ *
+ * `renderer="canvas"` swaps the per-node/per-link SVG DOM for a single DPR-aware `<canvas>` --
+ * every event/method/property behaves identically to `renderer="svg"` (the default), with hit-
+ * testing resolved via an offscreen color-picking canvas instead of DOM event targets. The
+ * documented trade-offs: no `::part(node)`/`::part(link)` styling (pixels, not elements -- theme
+ * via cssprops instead), no native SVG `<title>` tooltip (replaced by `part="tooltip"`), and a
+ * drawn focus ring instead of a CSS one. Keyboard roving/announcements are preserved through an
+ * offscreen `part="cursor-item"` button per node/link/hull, driving the identical roving-tabindex
+ * logic as `renderer="svg"`.
+ *
  * @customElement lyra-graph
- * @event lyra-node-click - `detail: { id }`.
+ * @event lyra-node-click - `detail: { id, x, y }`, where `x` and `y` are the
+ *   node's current coordinates in the graph's local drawing space.
  * @event lyra-link-click - `detail: { source, target, id? }`.
+ * @event lyra-node-enter - A node was hovered. `detail: { id }`. Suppressed while dragging or
+ *   panning. Also toggles a `data-hovered` attribute on that node's `[part="node"]` element for
+ *   pure-CSS theming (not a substitute for this event — a consumer computing its own
+ *   adjacency-based highlight needs the id, which only the event carries).
+ * @event lyra-node-leave - The hover from `lyra-node-enter` ended. `detail: { id }`.
+ * @event lyra-link-enter - A link was hovered. `detail: { source, target, id? }`. Same
+ *   suppression/`data-hovered` behavior as `lyra-node-enter`.
+ * @event lyra-link-leave - The hover from `lyra-link-enter` ended. `detail: { source, target, id?
+ *   }`.
+ * @event lyra-node-expand - A node was double-activated (native `dblclick`, or two Enter/Space
+ *   activations of the same focused node within 500ms). `detail: { id }`. Fires for any node
+ *   regardless of `GraphNode.expandable` -- that flag only controls the visual "+" affordance and
+ *   spoken "expandable" suffix.
+ * @event lyra-selection-change - `detail: { nodeIds, linkIds }`. Fires when `selectionMode` is not
+ *   `'none'` and the user activates/clears a node or link. The component never assigns
+ *   `selectedNodeIds`/`selectedLinkIds` itself -- controlled, mirroring `lyra-heatmap.selectedCell`.
+ * @event lyra-community-click - A hull was activated. `detail: { id }`.
  * @csspart base - The graph wrapper.
  * @csspart svg - The graph SVG.
  * @csspart node - A graph node.
  * @csspart link - A graph link.
  * @csspart arrowhead - The marker used by directed graph links.
  * @csspart label - A node label.
+ * @csspart link-label - A drawn edge label (only rendered when `showEdgeLabels` is set).
+ * @csspart expand-indicator - The "+" badge rendered on a node with `expandable: true`.
+ * @csspart focus-halo - The persistent ring tracking `focusId`'s node.
+ * @csspart hull - A community hull (behind links/nodes; role="button").
+ * @csspart community-label - A hull's label text.
  * @csspart live-region - The current graph item announcement.
  * @csspart data-list - A visually hidden list alternative for graph data.
  * @csspart empty - The empty-state message, shown when `nodes` is empty.
+ * @csspart canvas - The single canvas surface (`renderer="canvas"` only).
+ * @csspart tooltip - The hover tooltip (`renderer="canvas"` only; the SVG `<title>` replacement).
+ * @csspart cursor-items - The container of offscreen keyboard-roving items (`renderer="canvas"` only).
+ * @csspart cursor-item - An offscreen keyboard-roving item (`renderer="canvas"`'s a11y virtual cursor).
  * @cssprop [--lyra-node-fill=var(--lyra-color-brand)] - Default node fill, overridden per-node by `GraphNode.color`.
  * @cssprop [--lyra-link-color=var(--lyra-color-border)] - Default link stroke, overridden per-link by a link's own `color`.
+ * @cssprop [--lyra-graph-cat-1..8] - Ordered categorical fallback palette for a typed node with no
+ *   `GraphNodeType.color`, assigned by the type's index in `nodeTypes` (wraps every 8 entries).
+ *   Declared centrally in `tokens.styles.ts` so `<lyra-graph>` and any future `<lyra-graph-legend>`-
+ *   style component resolve the identical default.
+ * @cssprop [--lyra-graph-edge-label-halo=var(--lyra-color-surface)] - Legibility halo (`stroke`)
+ *   behind a drawn edge label, painted under the fill via `paint-order: stroke`.
+ * @cssprop [--lyra-graph-focus-halo-color=var(--lyra-color-brand)] - `focus-halo` stroke color.
+ * @cssprop [--lyra-graph-selected-color=var(--lyra-color-success)] - Selected node/link stroke.
+ * @cssprop [--lyra-graph-hull-fill=var(--lyra-color-brand)] - Hull fill/stroke color.
+ * @cssprop [--lyra-graph-hull-opacity=0.12] - Hull element opacity (composites fill+stroke as one
+ *   group, avoiding a double-opacity seam at the fill/stroke boundary).
  */
 export declare class LyraGraph extends LyraElement<LyraGraphEventMap> {
     static styles: import("lit").CSSResultGroup[];
     nodes: GraphNode[];
     links: GraphLink[];
+    /** Declares each `GraphNode.type` value's legend label, fill color, and shape. A typed node with
+     *  no matching entry here renders as untyped (default circle, token fill) but still participates
+     *  in `hiddenTypes` filtering by its raw `type` string. */
+    nodeTypes: GraphNodeType[];
+    /** Hides every node whose raw `type` value is listed here (no matching `nodeTypes` entry
+     *  required), plus every link incident to a hidden node -- removed from the render, the
+     *  simulation input, the keyboard roving ring, the sr-only data list, and the accessible
+     *  diagram counts, as if absent. Positions round-trip via `lastPositionById`: toggling a type
+     *  off and back on restores each node where it was. */
+    hiddenTypes: string[];
+    /** Renders one translucent hull per entry, behind links/nodes. Membership is the union of
+     *  `memberIds` and every node whose `communityId` matches this entry's `id`. */
+    communities: GraphCommunity[];
+    /** `'force'` (default) runs the existing d3-force simulation, untouched. `'layered'` computes a
+     *  deterministic Sugiyama-lite layout (`src/internal/layered-layout.ts`, a shared,
+     *  dependency-free util suitable for any future layered-diagram consumer) instead -- no settle
+     *  animation, node drag disabled (dragging would fight a computed layout), `chargeStrength` a
+     *  documented no-op, `linkDistance` retunes the layer gap. Switching at runtime repositions
+     *  without a tween. */
+    layout: 'force' | 'layered';
+    /** `'svg'` (default, unchanged) renders the existing per-node/per-link DOM. `'canvas'` swaps to
+     *  a single `<canvas part="canvas">` -- the scale path (an honest ceiling for `'svg'`: dozens to
+     *  low hundreds of nodes; `'canvas'` targets roughly 5,000 nodes / 10,000 links). Feature-reduced
+     *  by design: no `::part(node)`/`::part(link)` styling (pixels, not elements -- theme via
+     *  cssprops), no SVG `<title>`, a drawn focus ring instead of a CSS one. All events/methods/
+     *  props otherwise behave identically across renderers. Runtime changes tear down and rebuild
+     *  the surface; positions survive via `prevById`/`lastPositionById`. */
+    renderer: 'svg' | 'canvas';
     width: number;
     height: number;
     chargeStrength: number;
@@ -97,12 +243,42 @@ export declare class LyraGraph extends LyraElement<LyraGraphEventMap> {
      *  not retroactively reposition already-settled nodes; there is currently
      *  no way to make an already-rendered graph reproducible after the fact. */
     seed?: number;
+    /** Draws each resolved (non-dangling) link's `label` as visible SVG text at the segment
+     *  midpoint. Off by default — `GraphLink.label` stays spoken/tooltip-only, matching today's
+     *  behavior, unless this is set. */
+    showEdgeLabels: boolean;
+    /** Below this zoom scale, every drawn edge label is hidden (a `data-edge-labels-hidden`
+     *  attribute toggled on the zoomed `<g>`, no Lit re-render). Ignored when `showEdgeLabels` is
+     *  false. */
+    edgeLabelMinZoom: number;
+    /** Declaratively centers the camera on this node id once, the first time it resolves (on mount
+     *  or when the id first appears in `nodes`) -- does not re-center on later mutations, so it
+     *  can't fight a user's panning on a streaming graph. Renders a persistent halo
+     *  (`part="focus-halo"`) around the node while set. See `focusNode()` for the imperative twin. */
+    focusId: string | null;
+    /** `'none'` (default) preserves today's behavior exactly -- no `aria-pressed`/`data-selected`,
+     *  no `lyra-selection-change`. Controlled, mirroring `lyra-heatmap.selectedCell`: the component
+     *  never mutates `selectedNodeIds`/`selectedLinkIds` itself, only emits intent; the host assigns
+     *  them back. */
+    selectionMode: 'none' | 'single' | 'multiple';
+    selectedNodeIds: string[];
+    selectedLinkIds: string[];
     private readonly arrowMarkerId;
     /** True until the lazy-loaded d3 peer dependencies have settled (success or failure). */
     private loading;
     private simNodes;
     private simLinks;
     private danglingLinks;
+    /** Every node's last-known settled position, keyed by id, independent of current visibility --
+     *  consulted by `rebuildSimulation()` (after the existing carried-over-position map) so a
+     *  `hiddenTypes` toggle restores a node where it was instead of re-randomizing it. Pruned to ids
+     *  present in `this.nodes` (not just currently-visible ones) on every rebuild. */
+    private lastPositionById;
+    /** The `hiddenNodeCount` computed by the most recent `rebuildSimulation()` -- lets that method
+     *  tell "nothing has ever been hidden" (never touch `graphLiveText`, so a consumer that never
+     *  sets `hiddenTypes` keeps today's exact live-region output) apart from "a hide was just
+     *  cleared" (still announce the resulting "0 of N" count). */
+    private lastHiddenNodeCount;
     /** One roving tab stop across all nodes and links; nodes are the initial entry order. */
     private activeGraphItem;
     private graphLiveText;
@@ -113,7 +289,8 @@ export declare class LyraGraph extends LyraElement<LyraGraphEventMap> {
     private chargeForce?;
     private linkForce?;
     private d3?;
-    /** The `<svg>` currently wired up with d3-zoom (guards a one-time bind). */
+    /** The `<svg>` (or, in `renderer="canvas"` mode, the `<canvas>`) currently wired up with d3-zoom
+     *  (guards a one-time bind per element). */
     private zoomedEl?;
     /** The pan/zoom `<g>`, cached alongside `zoomedEl` so the zoom handler can
      *  write the transform straight to the DOM (see applyInteractions()) instead
@@ -132,7 +309,73 @@ export declare class LyraGraph extends LyraElement<LyraGraphEventMap> {
      *  simNodes/simLinks properties (see rebuildSimulation()'s doc comment). */
     private nodeEls;
     private nodeLabelEls;
+    private expandIndicatorEls;
+    /** Tracks the index/time of the last Enter/Space activation, for double-Enter expand detection
+     *  (mirroring native dblclick semantics for keyboard users). */
+    private lastKeyActivateIndex;
+    private lastKeyActivateTime;
+    /** The last `focusId` value `focusNode()` was auto-invoked for by `updated()`'s declarative
+     *  centering branch -- guards against re-centering on every update while `focusId` stays set
+     *  (see the `focusId` property doc for why it only ever centers once per value). Reset to `null`
+     *  whenever `focusId` itself is cleared, so the same id can center again later. */
+    private lastAppliedFocusId;
+    private focusHaloEl?;
+    private communityHullEls;
+    private communityLabelEls;
+    private canvasEl?;
+    private canvasCtx?;
+    /** Offscreen, same-size, same-camera-transform canvas used only for hit-testing (see
+     *  `redrawPickCanvas()`/`hitTest()`) -- never attached to the DOM or painted to the screen. */
+    private pickCanvas?;
+    private pickCtx?;
+    private canvasResizeObserver?;
+    private canvasDprQuery?;
+    private canvasDrawRafId?;
+    private pickDirty;
+    private canvasCamera;
+    private canvasTooltipEl?;
+    /** Flat, index-aligned list matching `drawPickingScene()`'s own hulls-then-links-then-nodes pick
+     *  order -- rebuilt by `redrawPickCanvas()` alongside the pick canvas itself, so a pick color's
+     *  decoded index always maps back to the exact item it was drawn for. */
+    private pickItems;
+    private canvasDragNode?;
+    private canvasPointerId?;
+    private canvasPointerDownAt?;
+    /** The latest hover pointer position awaiting a hit test -- `pointermove` can fire far more
+     *  often than the display refreshes, and each hit test costs a bounding-rect read plus a
+     *  pick-pixel readback, so hover resolution is coalesced to at most one per animation frame. */
+    private pendingHover?;
+    private hoverRafId?;
+    /** Cached world-space draw scene, reused for camera-only repaints (pan/zoom moves the camera,
+     *  not the scene) -- building it costs a `getComputedStyle()` pass plus full per-node/per-link
+     *  array rebuilds, so it's only invalidated (`markCanvasDirty()`) when data/selection/style
+     *  state or node positions actually change. */
+    private canvasScene?;
+    /** Whether `canvasScene` was built with edge labels included -- the zoom gate makes the scene
+     *  camera-dependent at exactly two thresholds (`edgeLabelMinZoom`, `CANVAS_NODE_LABEL_MIN_ZOOM`),
+     *  so a camera-only draw that crosses either must rebuild instead of reusing the cache. */
+    private canvasSceneHasEdgeLabels;
+    /** The in-flight `requestAnimationFrame` id for a camera tween (`focusNode()`/`fit()`), if any --
+     *  canceled by a new tween request or a user pan/zoom gesture (see `applyInteractions()`'s zoom
+     *  `'start'` handler). */
+    private cameraTweenId?;
+    /** The current tween's own `resolve`, so cancellation (a superseding tween, or a real user
+     *  pan/zoom gesture) settles it with `false` instead of leaving the caller's `Promise` hanging
+     *  forever -- `cancelAnimationFrame()` alone stops the rAF loop but never touches the Promise. */
+    private cameraTweenResolve?;
+    /** True for a camera tween's whole duration (set before its first frame, cleared on
+     *  resolution) -- `isPanning` alone doesn't cover this: `applyZoomTransform()`'s per-frame
+     *  `zoomBehavior.transform()` call on a non-transition selection fires d3-zoom's
+     *  start/zoom/end synchronously within that single call, so `isPanning` flips true-then-false
+     *  within one frame rather than staying true for the tween's real duration the way an actual
+     *  user gesture does. */
+    private isCameraTweening;
     private linkEls;
+    private linkLabelEls;
+    /** Per-simLink-index flip cache for the length declutter gate -- `onTick()` only writes
+     *  `visibility` when the boolean actually changes, not every tick. */
+    private linkLabelHiddenByLength;
+    private edgeLabelWidthCache;
     /** Dangling-stub `<line>`s, index-aligned with `danglingLinks` -- cached separately from
      *  `linkEls` (real, simulated links only) so onTick() can write their positions too; see
      *  onTick()'s own comment for why a stub needs this at all. */
@@ -147,8 +390,164 @@ export declare class LyraGraph extends LyraElement<LyraGraphEventMap> {
      * focusable/clickable control with no visible focus indicator.
      */
     private nodeRadius;
+    /** `width`/`height` normalized to a finite, positive viewport size — an invalid attribute value
+     *  would otherwise flow straight into `forceCenter`, the SVG `viewBox`, and the canvas backing
+     *  store's `width`/`height`, producing `NaN` geometry/transforms that silently render nothing
+     *  instead of erroring. */
+    private get safeWidth();
+    private get safeHeight();
+    /** `minZoom`/`maxZoom` normalized to finite, positive scale bounds before ever reaching
+     *  d3-zoom's `scaleExtent()` or a camera-clamp `Math.min`/`Math.max` — a non-finite bound would
+     *  otherwise poison every subsequent zoom/pan computation with `NaN`. */
+    private get safeMinZoom();
+    private get safeMaxZoom();
+    /** `edgeLabelMinZoom` is compared directly against the live camera scale (same domain as
+     *  `minZoom`/`maxZoom`), so it's normalized with the same bounds -- a non-finite value would
+     *  otherwise make every `>=`/`<` comparison against it silently `false`/`true` forever. */
+    private get safeEdgeLabelMinZoom();
+    /** `seed`, normalized to a finite integer when set -- `undefined` (unseeded/random) is left
+     *  untouched, since it's a meaningful third state, not a missing number. Without this,
+     *  `hashNodeSeed`/`mulberry32`'s `>>> 0` coercion would silently fold `NaN`/`Infinity` to `0`
+     *  instead of normalizing an out-of-range attribute value the way every other numeric prop here
+     *  does. */
+    private get safeSeed();
+    /** `chargeStrength` is a signed d3-force strength (negative = repulsion, positive = attraction)
+     *  — only guarded for finiteness, not clamped to a range, since either sign is a legitimate
+     *  value. */
+    private get safeChargeStrength();
+    /** `linkDistance` normalized to a finite, non-negative pixel distance — feeds `forceLink()`'s
+     *  `distance()`, the layered layout's `gapY`, and the neighbor-jitter spawn radius, none of
+     *  which have a sane meaning for a negative/non-finite value. */
+    private get safeLinkDistance();
+    private resolveNodeType;
+    private nodeShape;
+    /** Resolution precedence: `node.color` (existing, most specific) > matched `GraphNodeType.color`
+     *  > the ordered categorical fallback palette by the type's index in `nodeTypes` > (returns
+     *  `undefined`, letting the untyped `--lyra-node-fill` token default apply). Both data-driven
+     *  color sources pass the existing `sanitizeNodeColor()`. */
+    private nodeFill;
+    /** `this.nodes` filtered down to the ids `hiddenTypes` doesn't hide -- an untyped node (`type ==
+     *  null`) is never hidden, regardless of `hiddenTypes`' contents. */
+    private visibleNodes;
+    /** Resolves `this.links` against an already-built `byId` node map: a link whose source isn't in
+     *  `byId` is dropped (hidden source, or a genuinely missing one); a link whose target isn't in
+     *  `byId` either stubs as a dangling link (target id doesn't exist in `this.nodes` at all) or is
+     *  dropped (target exists but is hidden by `hiddenTypes`). Shared by both the force and layered
+     *  layout paths in `rebuildSimulation()`. */
+    private resolveLinksAgainst;
+    /** A community's currently-visible members -- the union of `memberIds` and every currently
+     *  simulated node (already filtered by `hiddenTypes`) whose `communityId` matches. */
+    private communityMembers;
+    /** Memoized `visibleCommunities()` result -- `undefined` means "stale, recompute on next call".
+     *  Cleared from `willUpdate()` whenever `simNodes`/`communities` actually change, the same
+     *  structural-change gate `applyInteractions()` re-caches its own DOM lookups on, so every other
+     *  call site (roving-ring math, `render()`'s template, keyboard navigation) shares one
+     *  `O(communities × simNodes)` computation per structural update instead of repeating it. */
+    private visibleCommunitiesCache?;
+    /** `communities` narrowed to entries with at least one currently-visible member -- a community
+     *  whose members are all hidden by `hiddenTypes` (or that starts out empty) draws no hull and
+     *  doesn't occupy a roving-ring slot. */
+    private visibleCommunities;
+    private communityHull;
+    private onCommunityClick;
+    private cameraTransitionMs;
+    private cancelCameraTween;
+    /** Writing a transform on a plain (non-transition) selection makes d3-zoom fire its own
+     *  start/zoom/end sequence synchronously, in this same call -- `isApplyingZoomTransform` lets
+     *  the zoom `'start'` handler tell that self-triggered echo apart from a genuine external
+     *  gesture, so a camera tween's own per-frame write doesn't cancel itself. */
+    private isApplyingZoomTransform;
+    private applyZoomTransform;
+    /** Animates from the zoom behavior's current transform toward `computeTarget()`'s result via a
+     *  rAF tween that calls `zoomBehavior.transform()` every frame -- keeps d3-zoom's own internal
+     *  state consistent (so the next user pan doesn't jump), unlike writing the `<g>` transform
+     *  attribute directly. `computeTarget` is re-invoked on every single frame (not read once
+     *  up-front) so the tween keeps tracking a still-settling force simulation's live node positions
+     *  instead of tweening toward a stale snapshot from the moment the call was made --
+     *  `focusNode()`/`fit()` are just as likely to run while the graph is still animating its initial
+     *  layout as after it's settled. `prefers-reduced-motion` jumps straight to one write of the
+     *  then-current target. A concurrent call cancels the previous tween -- resolves `true` on
+     *  genuine arrival, `false` if superseded or interrupted by a user gesture before completing. */
+    private tweenCamera;
+    /** Animates the camera so `id` centers in the viewport (the `width` x `height` viewBox), at
+     *  `options.zoom` (clamped to `[minZoom, maxZoom]`) or the current scale when omitted. Resolves
+     *  `true` on arrival; `false` for an id with no matching entry in `simNodes` -- there's nothing
+     *  to center on. Announces `graphNodeFocused` through the existing live region. Does not move DOM
+     *  focus -- this is a camera operation, not a roving-focus one. */
+    focusNode(id: string, options?: {
+        zoom?: number;
+    }): Promise<boolean>;
+    /** Animates the camera to frame the bounding box of every currently visible node position (plus
+     *  each node's own radius) at the largest scale that fits within `width` x `height` minus
+     *  `padding` viewport-px on each side (clamped to `[minZoom, maxZoom]`). Silent -- no data
+     *  changed, so no announcement. A no-op with no visible nodes. */
+    fit(options?: {
+        padding?: number;
+    }): void;
+    private updateFocusHalo;
+    private setUpCanvasSurface;
+    private watchCanvasResize;
+    private watchCanvasDpr;
+    private onCanvasDprChange;
+    private markCanvasDirty;
+    /** The camera-only sibling of `markCanvasDirty()`: a pan/zoom moves the camera but leaves every
+     *  world-space scene value (positions, colors, labels) untouched, so the cached `canvasScene`
+     *  stays valid and only needs redrawing under the new transform. The pick canvas bakes the
+     *  camera transform into its pixels, though, so it still needs a redraw before the next hit
+     *  test. */
+    private markCanvasCameraDirty;
+    private scheduleCanvasDraw;
+    /** Canvas 2D's `fillStyle`/`strokeStyle` don't accept a raw `var(--x)` string the way an inline
+     *  SVG `style` attribute does -- resolves it to the actual cascaded color via `getComputedStyle`
+     *  first (the same "canvas can't consume var() directly" resolution `<lyra-heatmap>` already
+     *  uses for its own canvas-drawn tokens). `value` untouched when it isn't a bare `var(...)` ref
+     *  (a literal `GraphNode.color`/`GraphLink.color` hex/rgb string already resolves fine as-is). */
+    private resolveCssColorValue;
+    private buildCanvasScene;
+    /** Sizes the backing store to the canvas's own rendered CSS box (`clientWidth`/`clientHeight`,
+     *  themselves stretched to fill the host via `[part="base"]`/`[part="canvas"]`'s `100%` sizing)
+     *  times `devicePixelRatio`, only touching `width`/`height` when the target actually changed --
+     *  reassigning either unconditionally would implicitly clear the canvas and reset its transform
+     *  on every single draw, even a pure pan/zoom repaint. Mirrors `<lyra-heatmap>`'s own DPR-scaled
+     *  backing-store convention (`watchDpr()`/`onDprChange()`), adapted to `setTransform()` (an
+     *  absolute reset) rather than a relative `scale()`, since this canvas -- unlike heatmap's, which
+     *  always resizes its backing store on every draw -- only resizes conditionally. */
+    private drawCanvas;
+    private rebuildPickItems;
+    private redrawPickCanvas;
+    private hitTest;
+    private bindCanvasZoom;
+    private bindCanvasPointer;
+    private onCanvasPointerDown;
+    private onCanvasPointerMove;
+    /** `alpha` decays toward `alphaMin` and d3-force stops its internal timer once it crosses below
+     *  it, so `alpha > alphaMin` mirrors the simulation's own running condition -- including a drag's
+     *  `alphaTarget(0.3)` reheat, and correctly excluding a seeded/reduced-motion graph whose settle
+     *  loop already converged synchronously. */
+    private simulationIsTicking;
+    private onCanvasPointerUp;
+    private onCanvasPointerLeave;
+    private onCanvasDblClick;
+    /** Geometric fallback for dblclick: browsers can deliver the event before the offscreen pick
+     * canvas has painted the latest frame, while the simulation coordinates are already current. */
+    private nodeAtCanvasPoint;
+    private updateCanvasTooltip;
+    private isSelected;
+    private linkKey;
+    /** Computes and emits the selection intent for activating `id`; never assigns
+     *  `selectedNodeIds`/`selectedLinkIds` itself -- see the class doc's controlled-selection note. */
+    private emitSelectionIntent;
+    private clearSelection;
     protected willUpdate(changed: PropertyValues): void;
     protected updated(changed: PropertyValues): void;
+    /** Suppresses hover events/`data-hovered` while a node drag is in progress (tracked from the
+     *  existing d3-drag `.on('start')`/`.on('end')` handlers in `applyInteractions()`) — a drag
+     *  crossing over other nodes/links would otherwise spam enter/leave pairs unrelated to genuine
+     *  pointer hovering. */
+    private isDragging;
+    /** Same purpose as `isDragging`, for d3-zoom pan/zoom gestures (tracked from `applyInteractions()`'s
+     *  zoom `.on('start')`/`.on('end')` handlers, added by this same change). */
+    private isPanning;
     /**
      * Imperatively wires up d3-zoom (pan/zoom on the `<svg>`) and d3-drag
      * (per-node drag) against the just-rendered DOM. The zoom bind itself is a
@@ -171,6 +570,14 @@ export declare class LyraGraph extends LyraElement<LyraGraphEventMap> {
      * single event, the same class of cost `onTick()` already avoids for ticks.
      */
     private applyInteractions;
+    /** The `renderer="canvas"` twin of `applyInteractions()`'s svg zoom-bind branch -- binds d3-zoom
+     *  and the pointer/hit-testing handlers to the just-rendered `<canvas>` once (guarded by the same
+     *  `zoomedEl` field `applyInteractions()` uses, so `focusNode()`/`fit()`/`tweenCamera()` keep
+     *  working unmodified against whichever element -- svg or canvas -- is currently bound), then
+     *  marks the canvas dirty on every call so any structural/style-affecting change (new nodes/
+     *  links, a selection change, a hiddenTypes toggle, ...) schedules a fresh draw the same way a
+     *  Lit re-render already does for svg mode. */
+    private applyCanvasInteractions;
     /**
      * Runs on every d3-force simulation tick (up to ~300 while a graph settles
      * on load, continuously while a node is being dragged via
@@ -185,11 +592,49 @@ export declare class LyraGraph extends LyraElement<LyraGraphEventMap> {
      */
     private onTick;
     private rebuildSimulation;
+    /** Announces the current hidden-node count via the live region -- shared by both the force and
+     *  layered rebuild paths (each calls this with its own final visible-node count) so `hiddenTypes`
+     *  filtering announces identically regardless of `layout`. Called from right here (not from
+     *  willUpdate()/updated() gated on a 'hiddenTypes'/'nodes' PropertyValues diff) because
+     *  rebuildSimulation() itself is also invoked directly from connectedCallback() once the lazy d3
+     *  peer deps resolve -- a call that never goes through Lit's changed-property diffing at all.
+     *  Computing it there instead would miss that path entirely: a graph mounted with hiddenTypes
+     *  already set would compute this from a still-empty simNodes (0 settled nodes yet) on the
+     *  property-driven pass, then never get a chance to correct it once the real simNodes became
+     *  available. Only ever touches graphLiveText when there's something to say -- a node is
+     *  currently hidden, or one just stopped being hidden -- so a consumer that never sets
+     *  hiddenTypes keeps today's exact live-region output. */
+    private announceHiddenNodeCount;
+    /** The `layout="layered"` path: computes final positions synchronously via the shared
+     *  `layeredLayout()` util (2r x 2r boxes, `gapY = linkDistance`, `gapX = 12`), centers the
+     *  drawing in `width` x `height`, and skips forceSimulation() entirely -- no `this.simulation`,
+     *  no ticking, no `prevById` carry-over (deterministic input -> output makes it unnecessary; a
+     *  structural change simply recomputes wholesale). `lyra-graph` never passes `fixedPositions`. */
+    private rebuildLayeredLayout;
     private onNodeClick;
+    /** Returns a node's current position in the graph's local drawing space. */
+    getNodePosition(id: string): {
+        x: number;
+        y: number;
+    } | undefined;
     private onLinkClick;
+    private onNodeEnter;
+    private onNodeLeave;
+    private onNodeDblClick;
+    private onLinkEnter;
+    private onLinkLeave;
     private nodeAccessibleText;
     private linkAccessibleText;
     private linkCoordinates;
+    /** World-space midpoint of a link, offset EDGE_LABEL_OFFSET_PX perpendicular to the segment
+     *  (horizontal, unrotated text — rotated edge-label text is a readability and RTL hazard). */
+    private edgeLabelPosition;
+    private edgeLabelFontPx;
+    private edgeLabelWidth;
+    /** Toggles `data-edge-labels-hidden` on the cached zoomed `<g>` when crossing `edgeLabelMinZoom`
+     *  -- called from the d3-zoom `'zoom'` handler (render-free, CSS hides `[part="link-label"]`
+     *  beneath the attribute) so this scales with every pan/zoom event without a Lit re-render. */
+    private updateEdgeLabelZoomGate;
     private graphItemCount;
     private normalizedGraphItem;
     private graphItemText;

package/dist/components/graph/graph.class.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph.class.d.ts","sourceRoot":"","sources":["../../../src/components/graph/graph.class.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"graph.class.d.ts","sourceRoot":"","sources":["../../../src/components/graph/graph.class.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,KAAK,cAAc,EAAE,KAAK,cAAc,EAAE,MAAM,KAAK,CAAC;AAGnF,OAAO,EAAE,WAAW,EAAE,MAAM,gCAAgC,CAAC;AAY7D,OAAO,+BAA+B,CAAC;AAEvC,MAAM,WAAW,SAAS;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,sEAAsE;IACtE,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,wCAAwC;IACxC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,6GAA6G;IAC7G,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;sFAEkF;IAClF,IAAI,CAAC,EAAE,MAAM,CAAC;IACd;;;yGAGqG;IACrG,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB;0BACsB;IACtB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;mDACmD;AACnD,MAAM,WAAW,aAAa;IAC5B,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,QAAQ,GAAG,QAAQ,GAAG,SAAS,CAAC;CACzC;AAED;;;wDAGwD;AACxD,MAAM,WAAW,cAAc;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AACD;;;2DAG2D;AAC3D,MAAM,WAAW,SAAS;IACxB,wDAAwD;IACxD,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;qDACiD;IACjD,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,mDAAmD;IACnD,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,wCAAwC;IACxC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,2CAA2C;IAC3C,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,6EAA6E;IAC7E,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,kFAAkF;IAClF,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;CACjB;AAgHD,MAAM,WAAW,iBAAiB;IAChC,iBAAiB,EAAE,WAAW,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACrE,iBAAiB,EAAE,WAAW,CAAC;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,EAAE,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAChF,iBAAiB,EAAE,WAAW,CAAC;QAAE,EAAE,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC/C,iBAAiB,EAAE,WAAW,CAAC;QAAE,EAAE,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC/C,iBAAiB,EAAE,WAAW,CAAC;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,EAAE,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAChF,iBAAiB,EAAE,WAAW,CAAC;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,EAAE,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAChF,kBAAkB,EAAE,WAAW,CAAC;QAAE,EAAE,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAChD,uBAAuB,EAAE,WAAW,CAAC;QAAE,OAAO,EAAE,MAAM,EAAE,CAAC;QAAC,OAAO,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC,CAAC;IAC/E,sBAAsB,EAAE,WAAW,CAAC;QAAE,EAAE,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACrD;AACD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyFG;AACH,qBAAa,SAAU,SAAQ,WAAW,CAAC,iBAAiB,CAAC;IAC3D,MAAM,CAAC,MAAM,iCAAwC;IAErB,KAAK,EAAE,SAAS,EAAE,CAAM;IACxB,KAAK,EAAE,SAAS,EAAE,CAAM;IACxD;;+DAE2D;IAC3B,SAAS,EAAE,aAAa,EAAE,CAAM;IAChE;;;;2DAIuD;IACvB,WAAW,EAAE,MAAM,EAAE,CAAM;IAC3D;oFACgF;IAChD,WAAW,EAAE,cAAc,EAAE,CAAM;IACnE;;;;;2BAKuB;IACX,MAAM,EAAE,OAAO,GAAG,SAAS,CAAW;IAClD;;;;;;4EAMwE;IAC5D,QAAQ,EAAE,KAAK,GAAG,QAAQ,CAAS;IACnB,KAAK,SAAO;IACZ,MAAM,SAAO;IACiB,cAAc,SAAQ;IACxB,YAAY,SAAO;IACxB,OAAO,SAAO;IACd,OAAO,SAAK;IAC/D,yEAAyE;IAClC,eAAe,EAAE,MAAM,GAAG,IAAI,CAAQ;IAC7E;;;;;;;gFAO4E;IAChD,IAAI,CAAC,EAAE,MAAM,CAAC;IAC1C;;wCAEoC;IACwB,cAAc,UAAS;IACnF;;iBAEa;IACiD,gBAAgB,SAAO;IACrF;;;sGAGkG;IAC7D,OAAO,EAAE,MAAM,GAAG,IAAI,CAAQ;IACnE;;;qBAGiB;IAC0B,aAAa,EAAE,MAAM,GAAG,QAAQ,GAAG,UAAU,CAAU;IAClE,eAAe,EAAE,MAAM,EAAE,CAAM;IAC/B,eAAe,EAAE,MAAM,EAAE,CAAM;IAE/D,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAyB;IAEvD,yFAAyF;IAChF,OAAO,CAAC,OAAO,CAAQ;IAEvB,OAAO,CAAC,QAAQ,CAAiB;IACjC,OAAO,CAAC,QAAQ,CAAiB;IAC1C,OAAO,CAAC,aAAa,CAAiB;IACtC;;;sFAGkF;IAClF,OAAO,CAAC,gBAAgB,CAA+C;IACvE;;;kEAG8D;IAC9D,OAAO,CAAC,mBAAmB,CAAK;IAChC,yFAAyF;IAChF,OAAO,CAAC,eAAe,CAAK;IAC5B,OAAO,CAAC,aAAa,CAAM;IAEpC,OAAO,CAAC,UAAU,CAAC,CAAkD;IACrE;;oCAEgC;IAChC,OAAO,CAAC,WAAW,CAAC,CAA4C;IAChE,OAAO,CAAC,SAAS,CAAC,CAAiD;IACnE,OAAO,CAAC,EAAE,CAAC,CAAY;IACvB;gDAC4C;IAC5C,OAAO,CAAC,QAAQ,CAAC,CAAoC;IACrD;;qFAEiF;IACjF,OAAO,CAAC,GAAG,CAAC,CAAc;IAC1B;;iCAE6B;IAC7B,OAAO,CAAC,YAAY,CAAC,CAA6E;IAClG;wFACoF;IACpF,OAAO,CAAC,YAAY,CAA0B;IAC9C;;;gFAG4E;IAC5E,OAAO,CAAC,OAAO,CAAoB;IACnC,OAAO,CAAC,YAAY,CAAiC;IACrD,OAAO,CAAC,kBAAkB,CAA8B;IACxD;oEACgE;IAChE,OAAO,CAAC,oBAAoB,CAAuB;IACnD,OAAO,CAAC,mBAAmB,CAAK;IAChC;;;uFAGmF;IACnF,OAAO,CAAC,kBAAkB,CAAuB;IACjD,OAAO,CAAC,WAAW,CAAC,CAAmB;IACvC,OAAO,CAAC,gBAAgB,CAAwB;IAChD,OAAO,CAAC,iBAAiB,CAAwB;IAChC,OAAO,CAAC,QAAQ,CAAC,CAAoB;IACtD,OAAO,CAAC,SAAS,CAAC,CAA2B;IAC7C;mGAC+F;IAC/F,OAAO,CAAC,UAAU,CAAC,CAAoB;IACvC,OAAO,CAAC,OAAO,CAAC,CAAkC;IAClD,OAAO,CAAC,oBAAoB,CAAC,CAAiB;IAC9C,OAAO,CAAC,cAAc,CAAC,CAAiB;IACxC,OAAO,CAAC,eAAe,CAAC,CAAS;IACjC,OAAO,CAAC,SAAS,CAAQ;IACzB,OAAO,CAAC,YAAY,CAAsC;IAC1D,OAAO,CAAC,eAAe,CAAC,CAAiB;IACzC;;6EAEyE;IACzE,OAAO,CAAC,SAAS,CAIR;IACT,OAAO,CAAC,cAAc,CAAC,CAAU;IACjC,OAAO,CAAC,eAAe,CAAC,CAAS;IACjC,OAAO,CAAC,mBAAmB,CAAC,CAA2B;IACvD;;oGAEgG;IAChG,OAAO,CAAC,YAAY,CAAC,CAA2B;IAChD,OAAO,CAAC,UAAU,CAAC,CAAS;IAC5B;;;mDAG+C;IAC/C,OAAO,CAAC,WAAW,CAAC,CAAc;IAClC;;+FAE2F;IAC3F,OAAO,CAAC,wBAAwB,CAAS;IACzC;;8BAE0B;IAC1B,OAAO,CAAC,aAAa,CAAC,CAAS;IAC/B;;sGAEkG;IAClG,OAAO,CAAC,kBAAkB,CAAC,CAA6B;IACxD;;;;;6BAKyB;IACzB,OAAO,CAAC,gBAAgB,CAAS;IACjC,OAAO,CAAC,OAAO,CAAwB;IACvC,OAAO,CAAC,YAAY,CAAiC;IACrD;0EACsE;IACtE,OAAO,CAAC,uBAAuB,CAAiB;IAChD,OAAO,CAAC,mBAAmB,CAA6B;IACxD;;mEAE+D;IAC/D,OAAO,CAAC,eAAe,CAAwB;IAE/C,iBAAiB,IAAI,IAAI,CAkCxB;IAED,oBAAoB,IAAI,IAAI,CAkB3B;IAED;;;;;;OAMG;IACH,OAAO,CAAC,UAAU;IAKlB;;;+BAG2B;IAC3B,OAAO,KAAK,SAAS,GAEpB;IACD,OAAO,KAAK,UAAU,GAErB;IAED;;6EAEyE;IACzE,OAAO,KAAK,WAAW,GAEtB;IACD,OAAO,KAAK,WAAW,GAEtB;IAED;;+FAE2F;IAC3F,OAAO,KAAK,oBAAoB,GAE/B;IAED;;;;gBAIY;IACZ,OAAO,KAAK,QAAQ,GAEnB;IAED;;iBAEa;IACb,OAAO,KAAK,kBAAkB,GAE7B;IAED;;qEAEiE;IACjE,OAAO,KAAK,gBAAgB,GAE3B;IAED,OAAO,CAAC,eAAe;IAIvB,OAAO,CAAC,SAAS;IAIjB;;;iEAG6D;IAC7D,OAAO,CAAC,QAAQ;IAUhB;yEACqE;IACrE,OAAO,CAAC,YAAY;IAMpB;;;;iDAI6C;IAC7C,OAAO,CAAC,mBAAmB;IAiB3B;0FACsF;IACtF,OAAO,CAAC,gBAAgB;IAKxB;;;;iGAI6F;IAC7F,OAAO,CAAC,uBAAuB,CAAC,CAAsD;IAEtF;;6CAEyC;IACzC,OAAO,CAAC,kBAAkB;IAS1B,OAAO,CAAC,aAAa;IAIrB,OAAO,CAAC,gBAAgB;IAIxB,OAAO,CAAC,kBAAkB;IAK1B,OAAO,CAAC,iBAAiB;IAazB;;;kFAG8E;IAC9E,OAAO,CAAC,uBAAuB,CAAS;IAExC,OAAO,CAAC,kBAAkB;IAU1B;;;;;;;;;qGASiG;IACjG,OAAO,CAAC,WAAW;IA8CnB;;;;uEAImE;IAC7D,SAAS,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;QAAE,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,OAAO,CAAC,CAczE;IAED;;;sEAGkE;IAClE,GAAG,CAAC,OAAO,CAAC,EAAE;QAAE,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAgCxC;IAED,OAAO,CAAC,eAAe;IAiBvB,OAAO,CAAC,kBAAkB;IAiB1B,OAAO,CAAC,iBAAiB;IASzB,OAAO,CAAC,cAAc;IAStB,OAAO,CAAC,iBAAiB,CAGvB;IAEF,OAAO,CAAC,eAAe;IAMvB;;;;gBAIY;IACZ,OAAO,CAAC,qBAAqB;IAK7B,OAAO,CAAC,kBAAkB;IAQ1B;;;;sGAIkG;IAClG,OAAO,CAAC,oBAAoB;IAM5B,OAAO,CAAC,gBAAgB;IAmFxB;;;;;;;wFAOoF;IACpF,OAAO,CAAC,UAAU;IAkClB,OAAO,CAAC,gBAAgB;IAQxB,OAAO,CAAC,gBAAgB;IA+BxB,OAAO,CAAC,OAAO;IAaf,OAAO,CAAC,cAAc;IAwBtB,OAAO,CAAC,iBAAiB;IASzB,OAAO,CAAC,mBAAmB,CAazB;IAEF,OAAO,CAAC,mBAAmB,CA2BzB;IAEF;;;gDAG4C;IAC5C,OAAO,CAAC,mBAAmB;IAI3B,OAAO,CAAC,iBAAiB,CA4BvB;IAEF,OAAO,CAAC,oBAAoB,CAS1B;IAEF,OAAO,CAAC,gBAAgB,CAUtB;IAEF;oGACgG;IAChG,OAAO,CAAC,iBAAiB;IAiBzB,OAAO,CAAC,mBAAmB;IAiB3B,OAAO,CAAC,UAAU;IAIlB,OAAO,CAAC,OAAO;IAMf;uGACmG;IACnG,OAAO,CAAC,mBAAmB;IA6B3B,OAAO,CAAC,cAAc;IAMtB,SAAS,CAAC,UAAU,CAAC,OAAO,EAAE,cAAc,GAAG,IAAI,CA8BlD;IAED,SAAS,CAAC,OAAO,CAAC,OAAO,EAAE,cAAc,GAAG,IAAI,CAqC/C;IAED;;;4BAGwB;IACxB,OAAO,CAAC,UAAU,CAAS;IAC3B;iFAC6E;IAC7E,OAAO,CAAC,SAAS,CAAS;IAE1B;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,OAAO,CAAC,iBAAiB;IA4GzB;;;;;;mDAM+C;IAC/C,OAAO,CAAC,uBAAuB;IAS/B;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,MAAM;IAgGd,OAAO,CAAC,iBAAiB;IA4JzB;;;;;;;;;;;8DAW0D;IAC1D,OAAO,CAAC,uBAAuB;IAY/B;;;;sGAIkG;IAClG,OAAO,CAAC,oBAAoB;IAwC5B,OAAO,CAAC,WAAW;IAKnB,4EAA4E;IAC5E,eAAe,CAAC,EAAE,EAAE,MAAM,GAAG;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,SAAS,CAIhE;IAED,OAAO,CAAC,WAAW;IAOnB,OAAO,CAAC,WAAW;IAMnB,OAAO,CAAC,WAAW;IAMnB,OAAO,CAAC,cAAc;IAOtB,OAAO,CAAC,WAAW;IAQnB,OAAO,CAAC,WAAW;IAQnB,OAAO,CAAC,kBAAkB;IAQ1B,OAAO,CAAC,kBAAkB;IAa1B,OAAO,CAAC,eAAe;IAqBvB;kGAC8F;IAC9F,OAAO,CAAC,iBAAiB;IAczB,OAAO,CAAC,eAAe;IASvB,OAAO,CAAC,cAAc;IAuBtB;;mGAE+F;IAC/F,OAAO,CAAC,uBAAuB;IAM/B,OAAO,CAAC,cAAc;IAItB,OAAO,CAAC,mBAAmB;IAK3B,OAAO,CAAC,aAAa;IAoBrB,OAAO,CAAC,qBAAqB;IAQ7B,OAAO,CAAC,gBAAgB;IAMxB,OAAO,CAAC,cAAc;IAsBtB;;;;;;;;OAQG;IACH,OAAO,CAAC,cAAc;IAiCtB,MAAM,IAAI,cAAc,CA8SvB;CACF;AAGD,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAC7B,YAAY,EAAE,SAAS,CAAC;KACzB;CACF"}