@aceshooting/lyra-ui 17.0.0 → 18.1.0

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

@@ -4,15 +4,27 @@ export type LyraMapLegendPattern='solid'|'diagonal'|'dots'|'crosshatch';
 /** One immutable, bounded map-legend row. Pattern is required so color is never the sole cue. */
 export interface LyraMapLegendEntry{readonly color:string;readonly label:string;readonly pattern:LyraMapLegendPattern;
 /**
+* Category key this row stands for -- the same string a `point.colors` / `point.icons` entry
+* matches against `point.field` / `point.iconField`. Trimmed, bounded to 256 characters and
+* retained in the canonical readback, unlike the `value` on the `icon` record below, which is
+* still dropped. A row that carries one becomes a keyboard-operable visibility toggle under
+* `legendInteractive`; a row without one stays inert. An absent, non-string, empty or
+* whitespace-only key leaves no `value` key at all, so a legend that never used categories
+* reads back exactly as it did before this field existed.
+*/
+readonly value?:string;
+/**
 * Optional glyph painted inside `[part="legend-swatch"]`, in the entry's own color, instead of
 * the solid color block that would otherwise cover it. Deliberately the record `point.icons`
 * already carries, so a key can reproduce the symbol its point layer draws rather than
 * describing it in color alone — hand the legend the very icon object the layer renders.
 *
-* The point layer's `value` category key means nothing to a legend row: it is accepted so a
-* pass-through needs no reshaping, and left out of the canonical readback. Validation is the
-* point icon's own (path data only, at most 8192 characters, positive `viewBox` dimensions);
-* an unusable record is dropped and the row keeps rendering its color swatch.
+* The **icon record's own** `value` is accepted so a pass-through needs no reshaping, and is
+* left out of the canonical readback: a row's category key is the row-level `value` above, and
+* is never derived from the glyph's. Deriving it would silently make a row interactive that the
+* author never marked. Validation is the point icon's own (path data only, at most 8192
+* characters, positive `viewBox` dimensions); an unusable record is dropped and the row keeps
+* rendering its color swatch.
 *
 * That per-record 8192-character cap is deliberately the whole bound on path data, with no
 * aggregate budget of the kind `label` carries across the legend. Two reasons. The admission
@@ -25,7 +37,30 @@ export interface LyraMapLegendEntry{readonly color:string;readonly label:string;
 * most 8192 characters. A glyph omission is not counted in `legendProjection` either, because
 * the row it belongs to still renders — only dropped rows are omissions.
 */
-readonly icon?:LyraMapPointIcon|Omit<LyraMapPointIcon,'value'>;}
+readonly icon?:LyraMapPointIcon|Omit<LyraMapPointIcon,'value'>;
+/**
+* Optional section this row belongs to. A key describing two layers at once could previously
+* only be one flat list, with nothing saying which rows belonged to which.
+*
+* **The grouping rule, which is pinned rather than inferred:** CONSECUTIVE entries sharing an
+* identical `group` render as one section -- a visible heading plus a `role="group"` the heading
+* names. An entry with no `group` keeps its DECLARED position: it is never hoisted above or sunk
+* below a section, and a `group` that reappears after an interruption opens a SECOND section
+* rather than reordering rows to merge them. Declaration order is the one thing the legend never
+* rewrites, because the order is itself information about the map.
+*
+* It is caller-supplied DATA, so it renders verbatim and is never passed through the locale
+* catalog. It is trimmed and bounded to 256 characters (ellipsized, since it is rendered prose
+* rather than a matched key); a non-string, empty or whitespace-only value leaves no `group` key
+* at all, so an empty string means "ungrouped" instead of an empty heading, and a legend that
+* never used sections reads back exactly as it did before this field existed.
+*
+* Like the row-level `value`, it is NOT charged to the aggregate label budget: a budget bounds
+* rendered text, and the rendered total here is already finite and stated -- at most one heading
+* per rendered row, so at most 100 of them, each at most 256 characters. A section is also not a
+* row: the 100-row cap and the `legend-limit` summary count rows, never sections.
+*/
+readonly group?:string;}
 /**
 * One `[value, color]` stop of a continuous legend ramp — deliberately the same shape as
 * `LyraMapChoroplethLayer['stops']`, so a consumer passes the choropleth's own stops straight
@@ -325,7 +360,27 @@ export interface LyraMapInstance{getCanvas():HTMLCanvasElement;getCenter():{lng:
 */
 setMaxBounds?(bounds?:unknown):unknown;}
 /** A pan-constraining box, `[[west, south], [east, north]]`, in the order maplibre-gl takes. */
-export type LyraMapBounds=readonly[readonly[number,number],readonly[number,number]];export declare function buildGeoJsonPropertyDiff(previous:unknown,next:unknown):MapLibreGeoJsonDiff|null;export interface LyraMapEventMap{'lr-map-load':CustomEvent<null>;'lr-map-marker-activate':CustomEvent<LyraMapMarkerActivationDetail>;'lr-map-click':CustomEvent<{readonly lngLat:readonly[number,number];readonly feature:Feature|undefined;
+export type LyraMapBounds=readonly[readonly[number,number],readonly[number,number]];export declare function buildGeoJsonPropertyDiff(previous:unknown,next:unknown):MapLibreGeoJsonDiff|null;
+/**
+* Complete proposed visibility snapshot for one map legend category, mirroring
+* `LyraChartLegendVisibilityChangeDetail`'s shape so a host that already reconciles a chart legend
+* reconciles this one the same way. Frozen, and detached from the component's own state.
+*/
+export interface LyraMapLegendToggleDetail{
+/** The activated row's `value` category key, exactly as it was admitted. */
+readonly value:string;
+/** Proposed visibility of `value` after this toggle. */
+readonly visible:boolean;
+/** Complete canonical proposed hidden-category set, in the order it would be committed. */
+readonly hiddenCategories:readonly string[];}
+/**
+* Proposed disclosure state for the legend PANEL, which is a different thing from one category's
+* visibility -- hence its own detail type rather than a reuse of `LyraMapLegendToggleDetail`.
+* Frozen, and detached from the component's own state.
+*/
+export interface LyraMapLegendPanelToggleDetail{
+/** Proposed `legendOpen` after this activation. */
+readonly open:boolean;}export interface LyraMapEventMap{'lr-map-load':CustomEvent<null>;'lr-map-marker-activate':CustomEvent<LyraMapMarkerActivationDetail>;'lr-map-legend-toggle':CustomEvent<LyraMapLegendToggleDetail>;'lr-map-legend-panel-toggle':CustomEvent<LyraMapLegendPanelToggleDetail>;'lr-map-click':CustomEvent<{readonly lngLat:readonly[number,number];readonly feature:Feature|undefined;
 /** Which layer `feature` was hit on, so a click is attributable when both a choropleth and
 *  `dataLayers` are painted. `'cluster'` marks a hit on a clustered entry's aggregate circle,
 *  whose `point_count`/`cluster_id` properties describe the group rather than one feature.
@@ -370,6 +425,25 @@ readonly sourceId:string|undefined;}>;}
 *
 * @customElement lr-map
 * @event lr-map-load - Fired once the underlying maplibregl.Map loads.
+* @event lr-map-legend-toggle - **Cancelable.** Fired once when an interactive legend row is
+*   activated by pointer or by Enter/Space, carrying the immutable
+*   `detail: { value, visible, hiddenCategories }` -- the activated category key, its proposed
+*   visibility, and the complete proposed hidden set in the order it would be committed.
+*   `preventDefault()` is a real veto: `hiddenCategories` is not written, the row's `aria-pressed`
+*   does not change, the MapLibre paint is untouched, and nothing is announced, which is what lets
+*   a host own the set and write it itself. There is deliberately no second confirmation event:
+*   the committed state is `hiddenCategories`, which the host already observes, so a paired
+*   before/after vocabulary would be permanent public surface nobody asked for. A programmatic
+*   `hiddenCategories` assignment reconciles without emitting anything -- this event is a
+*   DOM-interaction proposal only.
+* @event lr-map-legend-panel-toggle - **Cancelable.** Fired once when the `legendCollapsible`
+*   disclosure is activated by pointer or by Enter/Space, carrying the immutable
+*   `detail: { open }` -- the proposed `legendOpen` value. It is the *panel's* disclosure, not a
+*   *category's* visibility, so it deliberately does not reuse `lr-map-legend-toggle`.
+*   `preventDefault()` is a real veto: `legendOpen` is not written, the rendered rows and the
+*   disclosure's `aria-expanded` do not change, which is what lets a host own the open state and
+*   write it itself. A programmatic `legendOpen` assignment reconciles without emitting anything,
+*   so a controlled host cannot loop.
 * @event lr-map-marker-activate - Fired once when an accepted declarative marker is activated by
 *   pointer/click or by Enter/Space. The immutable detail carries its normalized `id`, validated
 *   `lngLat`, accepted marker snapshot, and activation `source`.
@@ -384,12 +458,37 @@ readonly sourceId:string|undefined;}>;}
 * @csspart container - The MapLibre container. Its generated canvas is the actual focusable map
 *   region and receives the host-first accessible name and effective locale.
 * @slot legend - Custom legend content, rendered inside the legend panel's own layout so it stays
-*  positioned with the map instead of floating beside it.
+*  positioned with the map instead of floating beside it. Slotted content is never made
+*  interactive by `legendInteractive`, which only reaches rows projected from `legend`.
+* @slot legend-start - The same extension point at the TOP of the legend panel: it renders ahead
+*  of the gradient bar and every projected row, where `legend` renders after them. A panel header
+*  -- a title, a source note, a host-built control -- could previously only ever be a footer,
+*  because `legend` was the only slot. Content here alone opens the panel, exactly as `legend`
+*  content alone does, and it is never made interactive by `legendInteractive`.
 * @csspart legend - The map legend.
 * @csspart legend-swatch - A legend color swatch, or the entry's glyph when it carries an `icon`
 *   — in which case the swatch drops its color block and pattern overlay, keeps the `pattern`
 *   border framing the glyph as its non-color cue, carries `data-icon="true"`, and paints the
-*   glyph itself in the entry color.
+*   glyph itself in the entry color. It nests inside `legend-toggle` on an interactive row and
+*   stays `aria-hidden`/`inert` there, so it never contributes to the button's accessible name.
+* @csspart legend-toggle - The `button` an interactive legend row renders around its swatch and
+*   label when `legendInteractive` is set and the row carries a `value`. Absent entirely when
+*   either is missing, so an unset map's legend markup is unchanged.
+* @csspart legend-toggle-hidden - Second token carried alongside `legend-toggle` while that row's
+*   category is in `hiddenCategories`. State lives in the part name rather than a separate
+*   attribute, so `::part(legend-toggle-hidden)` is a reachable styling hook.
+* @csspart legend-group - The `role="group"` wrapping one consecutive run of legend rows that
+*   share a `group`. Absent entirely when no admitted entry carries one, so an ungrouped legend's
+*   markup is unchanged.
+* @csspart legend-group-heading - The visible heading naming a `legend-group`. It renders the
+*   caller-supplied `group` string verbatim and names the group through `aria-labelledby`.
+* @csspart legend-disclosure - The `button` that collapses and expands the whole legend panel.
+*   Rendered only when `legendCollapsible` is set, so an unset map's legend markup is unchanged.
+*   It carries the localized panel name as its visible, accessible label plus `aria-expanded`
+*   rendered as the literal `"true"`/`"false"`, and it grows to the shared `--lr-icon-button-size`
+*   hit-area floor.
+* @csspart legend-disclosure-icon - The decorative chevron inside `legend-disclosure`. It is the
+*   wrapping part that rotates (per the shared icon set's contract), including under RTL.
 * @csspart legend-gradient - The continuous ramp bar rendered from `legendGradient`.
 * @csspart legend-lo - The low endpoint caption of the `legendGradient` bar (mirrors `lr-heatmap`).
 * @csspart legend-hi - The high endpoint caption of the `legendGradient` bar (mirrors `lr-heatmap`).
@@ -414,6 +513,12 @@ readonly sourceId:string|undefined;}>;}
 * @cssprop [--lr-map-choropleth-fill-opacity=0.75] - Fill opacity for choropleth and polygon
 *   `dataLayers` fills. Read from the resolved cascade whenever those layers are applied or painted
 *   after a theme change.
+* @cssprop [--lr-map-hidden-category-opacity=0.15] - Opacity a hidden category's points, point
+*   strokes and point icons are muted to in the rendered MapLibre paint. Read from the resolved
+*   cascade on every paint, because MapLibre draws to a WebGL canvas the CSS cascade never reaches.
+* @cssprop [--lr-map-legend-hidden-swatch-opacity=0.5] - Opacity of a hidden interactive legend
+*   row's decorative swatch. Only the `aria-hidden` swatch dims; the label re-colors through the
+*   quiet text token instead, so it keeps AA contrast.
 * @cssprop [--lr-map-popup-close-button-hover-bg=var(--lr-color-brand-quiet)] - Hover background
 *   of `popup-close-button`.
 * @cssprop [--lr-map-popup-close-button-hover-color=var(--lr-color-brand)] - Hover foreground of
@@ -422,6 +527,18 @@ readonly sourceId:string|undefined;}>;}
 * @cssprop [--lr-map-popup-close-button-active-color=var(--lr-color-brand)] - Pressed foreground
 *   of `popup-close-button`.
 *
+* The legend is read-only unless `legendInteractive` is set, which is opt-in for a reason: an
+* unset map renders exactly the key it rendered before, with no button, no extra attribute and no
+* extra MapLibre paint key. Only a row that carries its own `value` becomes a toggle -- the key is
+* never derived from an `icon` record's `value`, which would silently make a row operable the
+* author never marked. Each toggle is a native `button`, so it is one independent tab stop per row
+* (a 100-row legend contributes 100, exactly as a 100-series `lr-chart` legend does) and it grows
+* to the shared `--lr-icon-button-size` hit-area floor. Activation emits the cancelable
+* `lr-map-legend-toggle`; there is deliberately no confirmation event, because the committed state
+* is `hiddenCategories` and the host already observes it. A hidden category mutes its points,
+* point strokes and point icons through `--lr-map-hidden-category-opacity`; a `kind: 'heatmap'`
+* entry is deliberately out of scope, having no per-category field to mute.
+*
 * No style or tile provider is selected implicitly. Set `mapStyle` explicitly before connection;
 * this prevents a bare component from making an undeclared third-party request.
 * @status stable
@@ -459,7 +576,7 @@ renderWorldCopies?:boolean;
 maxBounds:LyraMapBounds|null;
 /** Required MapLibre style URL or peer-neutral style specification. No provider is contacted
 * unless a consumer assigns this property. */
-mapStyle?:Readonly<LyraMapStyleSpecification> |string;private _legend;private _legendProjection;
+mapStyle?:Readonly<LyraMapStyleSpecification> |string;private _legend;private _legendProjection;private _legendGrouped;
 /** Immutable, bounded entries rendered in the optional map legend. A required pattern keeps
 * category identity available when authored colors collapse or are unavailable. */
 get legend():readonly LyraMapLegendEntry[];set legend(value:readonly LyraMapLegendEntry[]);
@@ -471,6 +588,9 @@ get legend():readonly LyraMapLegendEntry[];set legend(value:readonly LyraMapLege
 * it. `slotchange` still runs afterwards to track content added or removed later.
 */
 private hasLegendSlot;
+/** The same presence flag for `slot="legend-start"`, tracked separately so a header alone opens
+*  the panel and so the two extension points never stand in for one another. */
+private hasLegendStartSlot;
 /** Light-DOM probe for slotted legend content, valid before the slot itself has ever rendered. */
 private probeLegendSlot;private _legendGradient;
 /**
@@ -500,6 +620,73 @@ legendGradientHiLabel:string|null;
 /** Counts from the latest bounded legend normalization. `truncated` covers omitted rows or
 * shortened labels; the returned record is frozen and never aliases caller input. */
 get legendProjection():LyraMapLegendProjection;
+/**
+* Turns every legend row that carries a `value` into a keyboard-operable visibility toggle;
+* rows without one stay inert. Default `false`, and an unset map renders exactly the read-only
+* key it rendered before this property existed -- no button, no extra attribute, and no extra
+* MapLibre paint key.
+*
+* Each toggle is an independently tabbable native `button`, so Enter and Space are the
+* platform's own activation and no roving tabindex is involved. The consequence is stated
+* rather than hidden: a 100-row interactive legend contributes 100 tab stops, exactly as a
+* 100-series `lr-chart` legend does. Each row also grows to the `--lr-icon-button-size` hit-area
+* floor; the legend panel's own `max-block-size`/`overflow: auto` contains the taller list.
+*/
+legendInteractive:boolean;
+/**
+* Renders a disclosure button inside the legend panel that collapses the key down to its header.
+* Default `false`, and an unset map renders exactly the panel it rendered before this property
+* existed -- no button, no `id` minted on the row list, and no `hidden` attribute anywhere.
+*
+* A collapsed panel hides the gradient bar, the rows, the `legend-limit` summary and the
+* trailing `legend` slot; the `legend-start` slot and the disclosure itself stay visible, so a
+* slotted header survives the collapse and the control that would restore the key is never the
+* thing the collapse hides.
+*/
+legendCollapsible:boolean;
+/**
+* Whether a `legendCollapsible` panel is expanded. Defaults **open**, so adding only
+* `legendCollapsible` never hides an existing key; it does nothing at all while
+* `legendCollapsible` is unset.
+*
+* It is a `true`-defaulting boolean, so it uses `trueDefaultBooleanConverter` rather than Lit's
+* presence-based boolean converter, which cannot express `legend-open="false"` at all. The
+* reflection follows the same converter: open (the default) reflects as an ABSENT attribute and
+* collapsed reflects as `legend-open="false"`.
+*
+* Controlled public state, so -- exactly like `hiddenCategories` -- it deliberately survives a
+* disconnect and reconnect: the "reset transient open-state in `disconnectedCallback()`" rule
+* covers dropdown/preview/tooltip `@state`, not a documented property a host owns and re-reads.
+* A programmatic assignment reconciles the rendered panel without emitting
+* `lr-map-legend-panel-toggle`, so a controlled host cannot loop.
+*/
+legendOpen:boolean;
+/** True only when a collapsible panel is actually collapsed. `legendOpen` alone never hides
+*  anything, so an author who sets `legend-open="false"` without `legendCollapsible` -- and
+*  therefore renders no control to restore it -- still gets a readable key. */
+private get legendCollapsed();
+/**
+* Flips the whole panel's disclosure from the `legendCollapsible` button.
+*
+* The veto is the absence of a write, not a write that is undone afterwards: a listener that
+* owns the open state can assign its own `legendOpen` without this handler clobbering it.
+*/
+private toggleLegendPanel;
+/** The panel disclosure, or nothing at all when the panel cannot collapse. The chevron is
+*  decorative: the button's own visible, localized text carries its name, and `aria-expanded`
+*  carries the state. */
+private renderLegendDisclosure;private _hiddenCategories;
+/**
+* Complete controlled set of muted category keys, mirroring `lr-chart`'s `hiddenDatasets`.
+* Clone-owned and frozen; non-string, empty, whitespace-only and duplicate entries are dropped,
+* and at most 100 keys are retained. Honoured on the first render and the first MapLibre paint,
+* not only after a user toggle. An empty array deliberately means every category is visible.
+*
+* Controlled public state, so it deliberately survives a disconnect and reconnect: the
+* "reset transient open-state in `disconnectedCallback()`" rule covers dropdown/preview/tooltip
+* `@state`, not a documented property a host owns and re-reads.
+*/
+get hiddenCategories():readonly string[];set hiddenCategories(value:readonly string[]);
 /** Optional GeoJSON choropleth layer and value-to-color configuration. */
 choropleth?:Readonly<LyraMapChoroplethLayer>;
 /** Point markers rendered over the map. Explicit IDs are unique-nonempty first-wins. An idless
@@ -530,7 +717,7 @@ label:string;
 private loading;
 /** Classified failure rendered as localized ordinary text and announced through the owner
 * document's assertive sink. */
-private failure?;private errorAnnouncementSink?;private loadLibrary;private visible;private intersectionObserver?;private containerEl?;private _map?;private _styleLoaded;private _appliedChoroplethSourceId?;private _appliedFillLayerId?;private _appliedDataLayerIds;
+private failure?;private errorAnnouncementSink?;private legendAnnouncementSink?;private loadLibrary;private visible;private intersectionObserver?;private containerEl?;private _map?;private _styleLoaded;private _appliedChoroplethSourceId?;private _appliedFillLayerId?;private _appliedDataLayerIds;
 /**
 * The rendering shape (`'auto'`, a cluster signature, `'heatmap'`) each applied data layer was
 * built with, keyed identically to `_appliedDataLayerIds`.
@@ -543,7 +730,12 @@ private failure?;private errorAnnouncementSink?;private loadLibrary;private visi
 private _appliedDataLayerShapes;
 /** Last GeoJSON applied per resolved source id, so an update can be diffed against it rather
 *  than replacing the whole source. Holds a reference, not a copy -- it is only ever compared. */
-private _appliedGeoJson;private _nextDataLayerId;private nextPointIconId;private appliedPointPaint;private appliedPointIcons;private _maplibreModule?;
+private _appliedGeoJson;private _nextDataLayerId;private nextPointIconId;private appliedPointPaint;
+/** Layer ids whose paint currently carries a muting opacity, so the first paint after the last
+*  category is un-hidden can restore it -- and a layer that was never muted keeps its paint
+*  object free of the key entirely. Keyed by layer id, not source id, because one source's
+*  circle and point-icon layers mute independently on different fields. */
+private appliedPointMuting;private appliedPointIcons;private _maplibreModule?;
 /** True only after WebGL2 has been proved in the current owner-document realm. */
 private _webglReady;private _markerInstances;private _markerLabels;private _markerPopupIds;private readonly markerActivationDetails;private _configuredPopups;private _nextPopupId;private peerChromeObserver?;private observedPeerContainer?;private mapResizeObserver?;private observedMapContainer?;private _markerColors;private _connectGeneration;
 /** The underlying runtime `maplibregl.Map`, declared through Lyra's peer-neutral common-method
@@ -596,7 +788,9 @@ private get safeCenter();connectedCallback():void;disconnectedCallback():void;pr
 * below without risking a double construction.
 */
 private tryConstructMap;protected updated(changed:PropertyValues):void;protected willUpdate(changed:PropertyValues):void;
-/** Repaints token-derived MapLibre values without touching sources, layers, or map geometry. */
+/** Repaints token-derived and visibility-derived MapLibre values without touching sources,
+*  layers, or map geometry -- which is exactly what a theme change and a `hiddenCategories`
+*  change each need. */
 private refreshThemePaint;private applyChoropleth;private choroplethColorExpression;
 /**
 * Keeps the choropleth out of every caller-controlled data-layer namespace. Repeatedly prefixing
@@ -630,7 +824,18 @@ private paintDataLayer;
 /** The pre-existing geometry split: polygons filled, lines/outlines stroked, points circled. */
 private applyGeometryLayers;
 /** Paint-only half of `applyGeometryLayers`. See `paintDataLayer` for why the halves are split. */
-private paintGeometryLayers;private lineColor;private paintPoints;private pointIconColor;private removePointIcons;private applyPointIcons;private paintPointIcons;
+private paintGeometryLayers;private lineColor;
+/**
+* A `match` expression over `['get', field]` while any admitted category is hidden; a literal
+* `1` on the first paint after the last category is un-hidden; and `undefined` whenever nothing
+* is or was muted on `layerId` -- which is what leaves a `legendInteractive`-unset map
+* byte-identical: the paint key is never written, so MapLibre keeps its own default and the
+* layer's paint object gains no extra property.
+*
+* The flat `label, output` pair form is deliberately the shape `point.colors` already emits two
+* lines above its own `match`, so this file speaks one expression idiom rather than two.
+*/
+private mutedPointOpacity;private paintPoints;private pointIconColor;private removePointIcons;private applyPointIcons;private paintPointIcons;
 /**
 * `['step', ['get', 'point_count'], …]` over the authored cluster color breaks, or the layer's
 * own flat color when none were supplied.
@@ -686,4 +891,54 @@ private syncPeerChromeParts;private observePeerChrome;private syncPopupSemantics
 * holds fewer than two usable stops. Part names mirror `lr-heatmap`'s
 * `legend-lo`/`legend-hi` so a consumer styling both components learns one vocabulary.
 */
-private renderLegendGradient;render():TemplateResult;}declare global{interface HTMLElementTagNameMap{'lr-map':LyraMap;}}
+/**
+* The swatch-plus-label pair every legend row renders: directly inside the row when the row is
+* inert, and inside the row's toggle button when `legendInteractive` has made it operable. One
+* source of truth, so the two branches can never drift, and an unset map keeps rendering exactly
+* the markup it rendered before the toggle existed.
+*/
+private renderLegendRowContent;
+/**
+* Flips one category's visibility from a legend toggle activation.
+*
+* `hiddenCategories` is a key set, so every row carrying the activated key flips together --
+* self-consistent by construction rather than by a per-row visibility flag that two rows
+* describing one category could disagree about.
+*/
+private toggleLegendCategory;
+/**
+* The state change belongs in a live region because the thing that changed -- the map, and the
+* legend row's own styling -- is not the focused element, and `aria-pressed` alone only reports
+* the button's new state once focus is already on it.
+*/
+private announceLegendVisibility;
+/** Acquired lazily on the first toggle, and re-acquired against a new owner document, so a map
+*  that never renders an interactive legend never mounts a live region at all. */
+private syncLegendAnnouncementSink;private releaseLegendAnnouncementSink;
+/**
+* One legend row. Extracted verbatim from the list template so the grouped and ungrouped section
+* paths below render the same node rather than two copies that can drift.
+*
+* `aria-posinset`/`aria-setsize` deliberately stay whole-key values inside a section too.
+* `aria-setsize` already reports the *input* count rather than the rendered one, so a bounded key
+* stays honest; per-section input counts do not exist, because a row dropped by the bound carries
+* no attributable group. A section adds a labelled sub-region; it does not renumber the key.
+*/
+private renderLegendRow;
+/**
+* The row list's children: bare rows when no admitted entry carries a `group`, and otherwise one
+* `role="group"` per CONSECUTIVE run sharing a group name, with ungrouped rows left exactly where
+* they were declared. The ungrouped branch is literally the expression this list has always been,
+* so a legend that uses no sections keeps rendering the markup it rendered before they existed.
+*
+* `group` is caller-supplied data: the heading renders it verbatim and never resolves it through
+* the locale catalog.
+*
+* Each section owns its OWN `role="list"` rather than the sections sitting directly inside the
+* outer one. `list` requires `listitem` children, and a `group` is not one -- axe reports both
+* `aria-required-children` on the outer list and `aria-required-parent` on every row inside the
+* group, critical, which is how this shape was caught. So a grouped legend renders one list per
+* run (including each ungrouped run) and the outer element drops its own `role`, while an
+* ungrouped legend keeps the single `role="list"` it has always had.
+*/
+private renderLegendRows;private renderLegendGradient;render():TemplateResult;}declare global{interface HTMLElementTagNameMap{'lr-map':LyraMap;}}