@skra/ui 0.2.0

package/types/skra-ui-combobox.d.ts

@@ -0,0 +1,95 @@
+import * as _skra_ui_core from '@skra/ui/core';
+import { _SkraListboxWidgetBase, SkraListboxKeyboardItem } from '@skra/ui/core';
+export { SkraOption, SkraOptionDetail, SkraOptionLeading } from '@skra/ui/core';
+import * as _angular_core from '@angular/core';
+
+/**
+ * SkraCombobox — the WAI-ARIA APG **Editable Combobox** (list autocomplete, manual selection): an
+ * editable `<input role="combobox" aria-autocomplete="list">` whose top-layer listbox (Popover API,
+ * `popover="auto"`, ADR 0044) of projected `skra-option` children NARROWS as the user types. The first
+ * Tier-3 / higher-order component. Single-cardinality (ADR 0046); the multi sibling is future work.
+ *
+ * - **Filtering + option set are CONSUMER-OWNED (ADR 0049):** Forge emits the typed text via
+ *   `filterChange` (no debounce — timing is the consumer's); the consumer projects the matching
+ *   `skra-option` subset (sync computed OR async fetch). There is NO `[items]` input and NO internal
+ *   matcher — Forge renders exactly what is projected.
+ * - **Value is OPTION-BOUND (ADR 0049):** `value = input<T>()` + `valueChange` (consumer-owned, ADR 037);
+ *   a committed value is always an existing option's `T`. On cancel/blur the input text reverts to the
+ *   selected option's label — typed text that matched nothing NEVER leaks as the value (free-text commit
+ *   is the separate `skra-autocomplete`).
+ * - **Async (ADR 0049/028):** `loading` reflects `aria-busy` + drives a panel loading branch
+ *   (`[skraLoadingIndicator]` slot + fallback); an empty projected set drives the `[skraComboboxEmpty]`
+ *   branch; both are announced via `aria-live`.
+ *
+ * The trigger-shape-agnostic substrate (field cascade, panel toggle/positioner, keyboard wiring,
+ * open/close, the `SkraListboxPanel` selection seam) lives in {@link _SkraListboxWidgetBase}, shared
+ * verbatim with the select family (ADR 0046 amendment). `skra-option` is reused verbatim — combobox
+ * provides the `SKRA_LISTBOX_PANEL` token so the option's selection/keyboard/indicator wiring works
+ * unchanged.
+ *
+ * Full contract: adr/specs/component-combobox-spec.md.
+ */
+declare class SkraCombobox<T = unknown> extends _SkraListboxWidgetBase<T> {
+    /** Combobox panel token namespace — `--skra-comp-combobox-panel-*`. */
+    protected readonly panelTokenPrefix = "combobox";
+    /** Consumer-owned value channel (ADR 037) — single, option-bound `T`. */
+    readonly value: _angular_core.InputSignal<T | undefined>;
+    /** Fires ONLY on user selection of an option — never on a programmatic `value()` change (ADR 037). */
+    readonly valueChange: _angular_core.OutputEmitterRef<T>;
+    /** The typed text, emitted on EVERY input change. Consumer-driven projection; NO Forge debounce (ADR 0049). */
+    readonly filterChange: _angular_core.OutputEmitterRef<string>;
+    /** Async hint (ADR 0049/028) — reflects `aria-busy` + drives the panel loading branch. */
+    readonly loading: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Cardinality hint (ADR 0046) — single-select. */
+    readonly multiple = false;
+    /** Internal editable-text state; emitted out via `filterChange`. NOT the value (ADR 0049). */
+    protected readonly query: _angular_core.WritableSignal<string>;
+    private readonly isFocused;
+    private readonly hostEl;
+    /**
+     * Position the panel against — and match its width to — the HOST box, not the inner input. The input
+     * is inset (host padding + chevron), so anchoring to it would make a narrower, misaligned panel; the
+     * host gives full-width parity with `skra-select`.
+     */
+    protected positioningAnchor(): HTMLElement;
+    /** The option whose value matches `value()` (ADR 037 selection model) — feeds the displayed text + active seed. */
+    protected readonly selectedOption: _angular_core.Signal<_skra_ui_core.SkraOption<any> | null>;
+    /**
+     * The text shown in the input: the live query while editing (focused), otherwise the selected option's
+     * label. This is the controlled-input seam that enforces the option-bound value (ADR 0049) — on blur the
+     * input snaps back to the selected label, so unmatched typed text never persists.
+     */
+    protected readonly displayValue: _angular_core.Signal<string>;
+    constructor();
+    isSelected(value: unknown): boolean;
+    selectValue(value: unknown): void;
+    protected activeSeedItem(): SkraListboxKeyboardItem | null;
+    protected onFocus(): void;
+    protected onInput(event: Event): void;
+    protected onBlur(): void;
+    protected onTriggerKeydown(event: KeyboardEvent): void;
+    protected toggle(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SkraCombobox<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SkraCombobox<any>, "skra-combobox", ["skraCombobox"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; "filterChange": "filterChange"; }, never, ["[skraLoadingIndicator]", "[skraComboboxEmpty]", "*"], true, never>;
+}
+
+/**
+ * SkraComboboxEmpty — the no-results marker (ADR 0049). Place on the element that should show inside the
+ * combobox listbox when the consumer's filter yields zero `skra-option` children:
+ *
+ *   <skra-combobox (filterChange)="query.set($event)" [value]="city()" (valueChange)="city.set($event)">
+ *     @for (c of visible(); track c.id) { <skra-option [value]="c.id">{{ c.name }}</skra-option> }
+ *     <span skraComboboxEmpty>No matches</span>
+ *   </skra-combobox>
+ *
+ * The text is consumer-supplied (i18n is the consumer's concern — Forge ships no hardcoded string).
+ * Forge toggles its visibility via `@if (!loading() && options().length === 0)`; the marker only carries
+ * the projection selector, so no logic lives here.
+ */
+declare class SkraComboboxEmpty {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SkraComboboxEmpty, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SkraComboboxEmpty, "[skraComboboxEmpty]", never, {}, {}, never, never, true, never>;
+}
+
+export { SkraCombobox, SkraComboboxEmpty };
+//# sourceMappingURL=skra-ui-combobox.d.ts.map

package/types/skra-ui-combobox.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skra-ui-combobox.d.ts","sources":["../../../../libs/ui/combobox/src/lib/combobox/combobox.ts","../../../../libs/ui/combobox/src/lib/combobox/combobox-empty.ts"],"mappings":";;;;;AAsBA;;;;;;;;;;;;;;;;;;;;;;;;;AAyBG;AACH,cA2Ea,YAAY,sBAAsB,sBAAsB;;AAEnE;;oBAGc,aAAA,CAAA,WAAA;;0BAEM,aAAA,CAAA,gBAAA;;2BAEC,aAAA,CAAA,gBAAA;;sBAEL,aAAA,CAAA,wBAAA;;;;AAKhB,8BAAwB,aAAA,CAAA,cAAA;AACxB;AAEA;AAEA;;;;AAIG;AACgB,mCAAqB,WAAW;;AAKnD,uCAAiC,aAAA,CAAA,MAAA,CAAA,aAAA,CAAA,UAAA;AAIjC;;;;AAIG;AACH,qCAA+B,aAAA,CAAA,MAAA;;AA8B/B;AAKA;AAWA,gCAA4B,uBAAuB;;AAWnD,6BAAyB,KAAK;;AAa9B,sCAAkC,aAAa;;oDA9GpC,YAAY;sDAAZ,YAAY;AA8JxB;;ACvRD;;;;;;;;;;;;AAYG;AACH,cAIa,iBAAiB;oDAAjB,iBAAiB;sDAAjB,iBAAiB;AAAG;;;;","names":[]}

package/types/skra-ui-core.d.ts

@@ -0,0 +1,314 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken, ElementRef, TemplateRef } from '@angular/core';
+import { SkraFieldContext } from '@skra/ui/field';
+
+/**
+ * What a `skra-option` needs from its listbox parent — a narrow contract that breaks the
+ * parent↔option import cycle (the `SKRA_MENU` precedent). A token (not a concrete class) so the option
+ * file never imports a widget file — no runtime import cycle. Implemented by `_SkraListboxWidgetBase`,
+ * so it is shared by `skra-select`, `skra-multi-select` AND `skra-combobox` (ADR 0046 amendment).
+ */
+interface SkraListboxPanel {
+    /** Live selection test for an option's value (signal-driven: default `Object.is` or consumer `compareWith`). */
+    isSelected(value: unknown): boolean;
+    /**
+     * A user picked this value (pointer/keyboard). Single-select emits `valueChange` + closes; multi-select
+     * TOGGLES membership and keeps the panel open (ADR 0046); combobox replaces + closes (ADR 0049).
+     * Consumer owns `value` (ADR 037).
+     */
+    selectValue(value: unknown): void;
+    /**
+     * Cardinality hint (ADR 0046) — `false` on single widgets (`skra-select`/`skra-combobox`), `true` on
+     * `skra-multi-select`. The ONLY thing `skra-option` reads to swap its component-rendered indicator
+     * (checkmark ↔ checkbox). NOT an Angular input; cardinality is a component identity, never a runtime flag.
+     */
+    readonly multiple: boolean;
+}
+/**
+ * The item shape the listbox keyboard controller drives. Structurally a CDK `Highlightable`
+ * (`setActiveStyles`/`setInactiveStyles`) + `ListKeyManagerOption` (`getLabel`/`disabled`), plus the
+ * option's `id` (→ `aria-activedescendant`) and `getValue()` (Enter-to-select). Declared HERE — cdk-free —
+ * so the only `@angular/cdk` importer stays `listbox-keyboard.ts` (the `menu-types.ts` precedent).
+ */
+interface SkraListboxKeyboardItem {
+    readonly optionId: string;
+    setActiveStyles(): void;
+    setInactiveStyles(): void;
+    getLabel(): string;
+    getValue(): unknown;
+    readonly disabled: boolean;
+}
+/**
+ * DI token a listbox widget provides (`useExisting`) and a `skra-option` injects. A token (not a concrete
+ * class) so the option file never imports a widget file — no runtime import cycle. Provided by
+ * `skra-select`, `skra-multi-select`, and `skra-combobox`.
+ */
+declare const SKRA_LISTBOX_PANEL: InjectionToken<SkraListboxPanel>;
+
+/**
+ * SkraOption — one selectable row in a `skra-select` listbox, a Component on the custom-element host
+ * `skra-option` (ADR 040 content-bearing host; there is no native option element that holds rich content
+ * outside `<select>`). Carries `value` + rich projected content: a leading icon (`[skra-option-leading]`)
+ * and a primary label = the IDENTITY (→ `getLabel()` / the default trigger, ADR 0045), plus an optional
+ * secondary `[skra-option-detail]` that is list-only (excluded from the trigger). The selection
+ * indicator (trailing checkmark) is component-rendered, driven by `aria-selected` — NOT a slot; iteration 2
+ * swaps it for a per-row checkbox with no API change.
+ *
+ * Implements `SkraListboxKeyboardItem` so `_SkraListboxKeyboard` (CDK `ActiveDescendantKeyManager`) can
+ * highlight it (`setActiveStyles`/`setInactiveStyles` → `data-skra-active`) and type-ahead to it
+ * (`getLabel`). Disabled is native-attr-first (Menu precedent): the consumer sets `aria-disabled="true"`
+ * and Forge OBSERVES it — disabled options stay navigable (discoverable) but cannot be selected.
+ *
+ * Full contract: adr/specs/component-select-spec.md.
+ */
+declare class SkraOption<T = unknown> implements SkraListboxKeyboardItem {
+    /** The option's value (ADR 037 — consumer-owned; compared against the select's `value()`). */
+    readonly value: _angular_core.InputSignal<T>;
+    /** Stable id, the target of the trigger's `aria-activedescendant`. Internal — never consumer-facing. */
+    readonly optionId: string;
+    private readonly el;
+    private readonly select;
+    private readonly leadingSlot;
+    private readonly detailSlot;
+    protected readonly hasLeading: _angular_core.Signal<boolean>;
+    protected readonly hasDetail: _angular_core.Signal<boolean>;
+    /** Keyboard active-descendant highlight (ADR 0044 §7 — Highlightable, NOT roving focus). */
+    protected readonly active: _angular_core.WritableSignal<boolean>;
+    /**
+     * Cardinality hint from the parent panel (ADR 0046): `false` under `skra-select` → checkmark
+     * indicator; `true` under `skra-multi-select` → checkbox indicator. The only thing the shared
+     * `skra-option` reads to swap the component-rendered indicator. No public-API change.
+     */
+    protected readonly multiple: _angular_core.Signal<boolean>;
+    /** Selection is signal-derived (ADR 0045 / ADR 037): re-derives on parent `value()`/`compareWith()` or own `value()`. */
+    protected readonly selected: _angular_core.Signal<boolean>;
+    constructor();
+    setActiveStyles(): void;
+    setInactiveStyles(): void;
+    /**
+     * ADR 0045 Rule 1: the option's IDENTITY text (leading + label), EXCLUDING `[skra-option-detail]` and
+     * the component-rendered indicator. Own-host `textContent` walk (the `skraMenuItem.getLabel()`
+     * precedent) — drives the default trigger text AND type-ahead. Reading own content, NOT
+     * `document.querySelector` (ADR 001-clean).
+     */
+    getLabel(): string;
+    getValue(): unknown;
+    /** Soft-disabled = the consumer's `aria-disabled="true"` (native-attr-first, Menu precedent); read live. */
+    get disabled(): boolean;
+    protected onActivate(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SkraOption<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SkraOption<any>, "skra-option", ["skraOption"], { "value": { "alias": "value"; "required": true; "isSignal": true; }; }, {}, ["leadingSlot", "detailSlot"], ["[skra-option-leading]", "*", "[skra-option-detail]"], true, never>;
+}
+
+/**
+ * Slot marker: the leading icon/flag of a `skra-option` — part of the option IDENTITY (ADR 0045
+ * Rule 4), so it flows into `getLabel()` (emoji/glyph leading appears in the default trigger for free).
+ */
+declare class SkraOptionLeading {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SkraOptionLeading, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SkraOptionLeading, "[skra-option-leading]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Slot marker: secondary DETAIL text of a `skra-option` (e.g. a dial code, a description) — list-only
+ * (ADR 0045 Rule 4), EXCLUDED from `getLabel()` and the trigger summary.
+ */
+declare class SkraOptionDetail {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SkraOptionDetail, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SkraOptionDetail, "[skra-option-detail]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * SkraSelectTrigger — the opt-in rich-trigger marker (ADR 0045 Rule 2). Place on an `<ng-template>`
+ * inside `<skra-select>`; the select reads it as a `TemplateRef` and stamps it in the trigger via
+ * `ngTemplateOutlet` with `{ $implicit: value, option: selectedOption }` context — the ONLY supported
+ * path for non-text (SVG/`<img>`) trigger presentation. With no trigger template the default trigger is
+ * the selected option's `getLabel()` text (emoji/glyph leading content appears for free).
+ *
+ *   <skra-select [value]="country()" (valueChange)="country.set($event)">
+ *     <ng-template skraSelectTrigger let-value>
+ *       <skra-icon [innerSVG]="flagOf(value)"></skra-icon> {{ nameOf(value) }}
+ *     </ng-template>
+ *     <skra-option value="de"><skra-icon [innerSVG]="flagOf('de')"></skra-icon> Germany</skra-option>
+ *   </skra-select>
+ */
+declare class SkraSelectTrigger {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SkraSelectTrigger, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SkraSelectTrigger, "[skraSelectTrigger]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Forge's single overlay positioning abstraction (ADR 0044 §3 rules 4–5).
+ *
+ * Wraps `@floating-ui/dom` so the library is an IMPLEMENTATION DETAIL: nothing outside this folder
+ * imports it, and swapping the engine (e.g. to native CSS Anchor Positioning once it is baseline
+ * cross-browser) is a one-file change with zero public-API impact.
+ *
+ * It writes **geometry only** (`left`/`top` + the resolved-side `data-skra-placement`) inline on the
+ * floating element — the scoped geometry-only exception to ADR 021 / Visual Purism granted by
+ * ADR 0044 §3 rule 4. It MUST NOT write any theme/state/token value inline (those stay `var(--skra-*)`
+ * + `data-skra-*`). No portal, no z-index, no CDK, no library stylesheet.
+ *
+ * Decided at the first anchored component (Tooltip, 2026-06-06): a single JS path on all engines
+ * (not native-CSS-primary + JS-fallback) — see ADR 0044 §7 + the rule-4 refinement note.
+ */
+/** Forge placement intent — the base four sides; flip/shift adjust at runtime. */
+type SkraPlacement = 'top' | 'bottom' | 'left' | 'right';
+interface _PositionerOptions {
+    /** Preferred side; `flip` re-sides on viewport collision. */
+    placement: SkraPlacement;
+    /** Gap between trigger and floating element, in px (resolved from a comp token by the caller). */
+    offset?: number;
+    /** Minimum distance from the viewport edge for `shift`, in px. */
+    viewportPadding?: number;
+}
+interface _PositionerHandle {
+    /** Stop repositioning and release the `autoUpdate` listeners. Idempotent. */
+    destroy(): void;
+}
+/**
+ * Anchor `floating` to `reference` and keep it positioned while visible. Returns a handle whose
+ * `destroy()` MUST be called when the overlay hides or the owner is destroyed (no listener leak).
+ *
+ * `options` is a getter so live token values (offset) are re-read on every reposition.
+ */
+declare function _attachPositioner(reference: HTMLElement, floating: HTMLElement, options: () => _PositionerOptions): _PositionerHandle;
+
+/**
+ * _SkraListboxKeyboard — the WAI-ARIA APG **Select-Only Combobox** listbox keyboard model, confined to
+ * ONE file. Sibling to `menu-keyboard.ts`: per ADR 0044 §7 (2026-06-07), `@angular/cdk/a11y` is confined
+ * to one swappable `*-keyboard.ts` controller PER APG pattern. Menu uses `FocusKeyManager` (roving REAL
+ * focus); the listbox uses **`ActiveDescendantKeyManager`** — focus STAYS on the combobox trigger and the
+ * active option is virtual (`aria-activedescendant`), the APG-canonical select-only model. Swapping the
+ * engine is a one-file change, exactly as `SkraPositioner` wraps `@floating-ui/dom`.
+ *
+ * Owns: Down/Up active-descendant movement, Home/End, and type-ahead. Enter/Space (select), Escape and
+ * light-dismiss (`popover="auto"`) stay with the select / platform — this controller never touches them.
+ */
+declare class _SkraListboxKeyboard {
+    private manager?;
+    private items;
+    private changeHandler?;
+    /** Notified whenever the active descendant changes — the select mirrors it to `aria-activedescendant`. */
+    onActiveChange(handler: (item: SkraListboxKeyboardItem | null) => void): void;
+    /**
+     * (Re)build the manager from the current projected option set. Called from an `effect` on the select's
+     * signal `contentChildren` — a passed array is a static snapshot (it does not auto-track like a live
+     * `QueryList`), so the manager is rebuilt whenever the option set changes (the documented signal↔CDK seam).
+     */
+    setItems(items: readonly SkraListboxKeyboardItem[]): void;
+    /** Delegate Down/Up/Home/End/type-ahead. Enter/Space/Escape are intentionally left to the select/platform. */
+    onKeydown(event: KeyboardEvent): void;
+    get activeItem(): SkraListboxKeyboardItem | null;
+    /** Seed the active descendant on open: the selected option, else the first. */
+    setActive(item: SkraListboxKeyboardItem | null): void;
+    /** Deactivate (close): `setActiveItem(-1)` clears `_activeItem` and the highlight. */
+    clearActive(): void;
+    destroy(): void;
+}
+
+/**
+ * _SkraListboxWidgetBase — the **trigger-shape-agnostic** core shared by every Forge listbox widget,
+ * per the **ADR 0046 amendment (2026-06-13)**. It owns ONLY the substrate that does not depend on what
+ * the trigger looks like: the `SkraFieldContext` cascade (ADR 013), the panel `(toggle)` →
+ * `SkraPositioner` lifecycle + active-descendant seeding, the `_SkraListboxKeyboard` wiring
+ * (CDK `ActiveDescendantKeyManager`, ADR 0044 §7), imperative `open()`/`close()`, teardown, and the
+ * abstract `SkraListboxPanel` selection seam.
+ *
+ * Trigger BEHAVIOUR lives one level down, in a per-shape base:
+ *   - `_SkraSelectBase` adds the button + native `popovertarget` + type-ahead trigger (Select-Only
+ *     Combobox) and the ADR 0045 `[skraSelectTrigger]` rich-trigger template.
+ *   - `SkraCombobox` (no extra base) adds the editable `<input>` + filter-output trigger (ADR 0049).
+ *
+ * The keydown skeleton is NOT here — each trigger shape routes keys differently (the select selects on
+ * Space and type-aheads; the combobox types into the input and never type-aheads). Forcing one keydown
+ * through both shapes is the wrong abstraction.
+ *
+ * `panelTokenPrefix` makes the panel comp-token namespace overridable so each widget reads its OWN
+ * `--skra-comp-<prefix>-panel-*` tokens (`select` for the select family, `combobox` for the combobox).
+ *
+ * Full contracts: adr/specs/component-{select,multi-select,combobox}-spec.md.
+ */
+declare abstract class _SkraListboxWidgetBase<T = unknown> implements SkraListboxPanel {
+    /** Equality strategy seam (ADR 037 selection model): default `Object.is`; object values pass a custom comparator. */
+    readonly compareWith: _angular_core.InputSignal<(a: T, b: T) => boolean>;
+    /** Value-empty hint shown in the trigger (NOT the accessible name — ADR 033). */
+    readonly placeholder: _angular_core.InputSignal<string>;
+    /** Placement intent; flip/shift adjust at runtime. */
+    readonly placement: _angular_core.InputSignal<SkraPlacement>;
+    /** Standalone availability source (Q-1) — `SkraFieldContext` wins when present. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly readonly: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    protected readonly options: _angular_core.Signal<readonly SkraOption<any>[]>;
+    protected readonly triggerRef: _angular_core.Signal<ElementRef<HTMLElement> | undefined>;
+    protected readonly panelRef: _angular_core.Signal<ElementRef<HTMLElement> | undefined>;
+    protected readonly context: SkraFieldContext | null;
+    protected readonly keyboard: _SkraListboxKeyboard;
+    readonly panelId: string;
+    protected readonly isOpen: _angular_core.WritableSignal<boolean>;
+    protected readonly activeOptionId: _angular_core.WritableSignal<string | null>;
+    private positioner?;
+    /** Panel comp-token namespace — `--skra-comp-<panelTokenPrefix>-panel-*`. Overridden per widget. */
+    protected abstract readonly panelTokenPrefix: string;
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    protected readonly isReadonly: _angular_core.Signal<boolean>;
+    protected readonly hasError: _angular_core.Signal<boolean>;
+    protected readonly isRequired: _angular_core.Signal<boolean>;
+    protected readonly triggerId: _angular_core.Signal<string | null>;
+    protected readonly describedBy: _angular_core.Signal<string | null>;
+    constructor();
+    /** Live selection test: single = equality, multi = membership (both via `compareWith`). */
+    abstract isSelected(value: unknown): boolean;
+    /** User picked a value: single = replace + close; multi = toggle membership + keep open. */
+    abstract selectValue(value: unknown): void;
+    /** Cardinality hint read by `skra-option` for the indicator swap — `false` single / `true` multi. */
+    abstract readonly multiple: boolean;
+    /** Seed the active descendant on open: single = the selected option; multi = the first selected. */
+    protected abstract activeSeedItem(): SkraListboxKeyboardItem | null;
+    protected onPanelToggle(event: Event): void;
+    /**
+     * The element the panel is positioned against AND matched in width to (Q-5). Defaults to the trigger
+     * — correct for the select family, whose trigger button fills the host. The combobox overrides it to
+     * the host box, because its trigger is the INNER input (narrower than the bordered box + chevron), so
+     * the panel must align to and match the box, not the input — visual parity with select.
+     */
+    protected positioningAnchor(): HTMLElement | undefined;
+    private onOpen;
+    private onClose;
+    /** Select the keyboard's active option (Enter), unless it is soft-disabled. Shared by every trigger shape. */
+    protected selectActive(): void;
+    protected open(): void;
+    protected close(): void;
+    /** Read a length comp token (px/rem) off the panel computed style for the positioner. */
+    private cssLenPx;
+    private teardown;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<_SkraListboxWidgetBase<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<_SkraListboxWidgetBase<any>, never, never, { "compareWith": { "alias": "compareWith"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "placement": { "alias": "placement"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; }, {}, ["options"], never, true, never>;
+}
+
+/**
+ * _SkraSelectBase — the SELECT-family trigger model over {@link _SkraListboxWidgetBase}: the WAI-ARIA APG
+ * **Select-Only Combobox** trigger. It adds the `<button>` + native `popovertarget` interaction, the
+ * type-ahead keydown skeleton, and the ADR 0045 `[skraSelectTrigger]` rich-trigger template. Shared by
+ * `skra-select` (single) and `skra-multi-select` (multi) — the cardinality split (ADR 0046) lives in
+ * those concretes (the `SkraListboxPanel` seam: single replaces + closes, multi toggles + stays open).
+ *
+ * The trigger-shape-agnostic substrate (field cascade, panel toggle/positioner, keyboard wiring,
+ * open/close, the selection seam) lives in the parent base, shared verbatim with `skra-combobox`
+ * (which has a different — editable input — trigger; ADR 0046 amendment 2026-06-13).
+ *
+ * Full contract: adr/specs/component-select-spec.md + adr/specs/component-multi-select-spec.md.
+ */
+declare abstract class _SkraSelectBase<T = unknown> extends _SkraListboxWidgetBase<T> {
+    /** Select-family panel token namespace — `--skra-comp-select-panel-*` (shared single + multi). */
+    protected readonly panelTokenPrefix = "select";
+    /** Opt-in rich trigger template (ADR 0045 Rule 2). Select-family only — a combobox input shows text. */
+    protected readonly triggerTemplate: _angular_core.Signal<TemplateRef<any> | undefined>;
+    protected onTriggerClick(event: MouseEvent): void;
+    protected onTriggerKeydown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<_SkraSelectBase<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<_SkraSelectBase<any>, never, never, {}, {}, ["triggerTemplate"], never, true, never>;
+}
+
+export { SKRA_LISTBOX_PANEL, SkraOption, SkraOptionDetail, SkraOptionLeading, SkraSelectTrigger, _SkraListboxWidgetBase, _SkraSelectBase, _attachPositioner };
+export type { SkraListboxKeyboardItem, SkraListboxPanel, SkraPlacement, _PositionerHandle, _PositionerOptions };
+//# sourceMappingURL=skra-ui-core.d.ts.map

package/types/skra-ui-core.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skra-ui-core.d.ts","sources":["../../../../libs/ui/core/src/lib/select/select-types.ts","../../../../libs/ui/core/src/lib/select/option.ts","../../../../libs/ui/core/src/lib/select/option.directives.ts","../../../../libs/ui/core/src/lib/select/select-trigger.ts","../../../../libs/ui/core/src/lib/positioning/positioner.ts","../../../../libs/ui/core/src/lib/select/listbox-keyboard.ts","../../../../libs/ui/core/src/lib/select/listbox-widget-base.ts","../../../../libs/ui/core/src/lib/select/select-base.ts"],"mappings":";;;;AAEA;;;;;AAKG;UACc,gBAAgB;;AAE/B;AACA;;;;AAIG;AACH;AACA;;;;AAIG;AACH;AACD;AAED;;;;;AAKG;UACc,uBAAuB;AACtC;;;;;AAKA;AACD;AAED;;;;AAIG;AACH,cAAa,kBAAkB,EAAA,cAAA,CAAA,gBAAA;;ACvB/B;;;;;;;;;;;;;;;AAeG;AACH,cAkCa,UAAU,yBAAyB,uBAAuB;;oBAEvD,aAAA,CAAA,WAAA;;;AAKd;AACA;AAEA;AACA;AACA,mCAA6B,aAAA,CAAA,MAAA;AAC7B,kCAA4B,aAAA,CAAA,MAAA;;AAG5B,+BAAyB,aAAA,CAAA,cAAA;AAEzB;;;;AAIG;AACH,iCAA2B,aAAA,CAAA,MAAA;;AAG3B,iCAA2B,aAAA,CAAA,MAAA;;AAgB3B;AAGA;AAIA;;;;;AAKG;AACH;AAqBA;;;;oDA5EW,UAAU;sDAAV,UAAU;AAyFtB;;AC/JD;;;AAGG;AACH,cAIa,iBAAiB;oDAAjB,iBAAiB;sDAAjB,iBAAiB;AAAG;AAEjC;;;AAGG;AACH,cAIa,gBAAgB;oDAAhB,gBAAgB;sDAAhB,gBAAgB;AAAG;;AClBhC;;;;;;;;;;;;;AAaG;AACH,cAIa,iBAAiB;oDAAjB,iBAAiB;sDAAjB,iBAAiB;AAAG;;ACXjC;;;;;;;;;;;;;;AAcG;AAEH;AACM,KAAM,aAAa;UAER,kBAAkB;;eAEtB,aAAa;;;;;AAKzB;UAEgB,iBAAiB;;;AAGjC;AAED;;;;;AAKG;AACH,iBAAgB,iBAAiB,YACpB,WAAW,YACZ,WAAW,iBACN,kBAAkB,GAChC,iBAAiB;;AChDpB;;;;;;;;;;AAUG;AACH,cAAa,oBAAoB;;;;;AAM/B,mCACkB,uBAAuB;AAKzC;;;;AAIG;AACH,6BAAyB,uBAAuB;;AAiBhD,qBAAiB,aAAa;AAI9B,sBAAkB,uBAAuB;;AAKzC,oBAAgB,uBAAuB;;AAOvC;AAIA;AAID;;AC/CD;;;;;;;;;;;;;;;;;;;;;AAqBG;AACH,uBAQsB,sBAAsB,yBAC/B,gBAAgB;;0BAGP,aAAA,CAAA,WAAA;;0BAEA,aAAA,CAAA,WAAA;;wBAEF,aAAA,CAAA,WAAA,CAAA,aAAA;;uBAED,aAAA,CAAA,wBAAA;uBACA,aAAA,CAAA,wBAAA;AAEjB,gCAA0B,aAAA,CAAA,MAAA,UAAA,UAAA;AAE1B,mCAA6B,aAAA,CAAA,MAAA,CAAA,UAAA,CAAA,WAAA;AAC7B,iCAA2B,aAAA,CAAA,MAAA,CAAA,UAAA,CAAA,WAAA;AAE3B,gCAA0B,gBAAA;AAC1B,iCAA2B,oBAAA;;AAG3B,+BAAyB,aAAA,CAAA,cAAA;AACzB,uCAAiC,aAAA,CAAA,cAAA;;;;AAQjC,mCAA6B,aAAA,CAAA,MAAA;AAG7B,mCAA6B,aAAA,CAAA,MAAA;AAG7B,iCAA2B,aAAA,CAAA,MAAA;AAG3B,mCAA6B,aAAA,CAAA,MAAA;AAG7B,kCAA4B,aAAA,CAAA,MAAA;AAG5B,oCAA8B,aAAA,CAAA,MAAA;;;AAgB9B;;AAEA;;AAEA;;AAEA,yCAAqC,uBAAuB;AAG5D,mCAA+B,KAAK;AAOpC;;;;;AAKG;AACH,mCAA+B,WAAW;AAI1C;AAqBA;;;;;;AAqBA;AAaA;oDA/IoB,sBAAsB;sDAAtB,sBAAsB;AAmJ3C;;ACtMD;;;;;;;;;;;;AAYG;AACH,uBACsB,eAAe,sBAE3B,sBAAsB;;AAE9B;;AAGA,wCAAkC,aAAA,CAAA,MAAA,CAAA,WAAA;AAKlC,oCAAgC,UAAU;AAK1C,sCAAkC,aAAa;oDAjB3B,eAAe;sDAAf,eAAe;AAuDpC;;;;","names":[]}

package/types/skra-ui-counter.d.ts

@@ -0,0 +1,33 @@
+import * as _angular_core from '@angular/core';
+
+/**
+ * Status atom rendering `{value.length}` or `{value.length}/{max}` for a
+ * sibling form control. Pure UI primitive — agnostic of form binding strategy
+ * per ADR 037: consumer wires `[value]` from their chosen source (Signal Forms
+ * `field().value()`, Reactive Forms `ctrl.value`, `ngModel`, raw signal).
+ *
+ * Counter does NOT subscribe to SkraFieldContext for value — ADR 037 §3.3
+ * explicitly forbids a value channel in the context. The atom remains
+ * independently testable and works outside `<skra-field>` if desired.
+ *
+ *   <skra-field>
+ *     <label skraLabelFor>Bio</label>
+ *     <textarea skraTextarea [formField]="form.bio" maxlength="500"></textarea>
+ *     <skra-counter [value]="form.bio().value()" [max]="500" />
+ *   </skra-field>
+ *
+ * `max` is optional — without it, the counter shows just the current length
+ * (e.g. for free-form "characters typed" indicators). Native `maxlength` on
+ * the form control is a separate concern (browser enforces the cap); `[max]`
+ * here is the displayed reference value.
+ */
+declare class SkraCounter {
+    readonly value: _angular_core.InputSignal<string>;
+    readonly max: _angular_core.InputSignal<number | null>;
+    readonly display: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SkraCounter, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SkraCounter, "skra-counter", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { SkraCounter };
+//# sourceMappingURL=skra-ui-counter.d.ts.map

package/types/skra-ui-counter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skra-ui-counter.d.ts","sources":["../../../../libs/ui/counter/src/lib/counter/counter.component.ts"],"mappings":";;AAQA;;;;;;;;;;;;;;;;;;;;AAoBG;AACH,cAgBa,WAAW;oBACR,aAAA,CAAA,WAAA;kBACF,aAAA,CAAA,WAAA;sBAEI,aAAA,CAAA,MAAA;oDAJL,WAAW;sDAAX,WAAW;AASvB;;;;","names":[]}

package/types/skra-ui-datepicker.d.ts

@@ -0,0 +1,164 @@
+import * as _angular_core from '@angular/core';
+import { SkraPlacement } from '@skra/ui/core';
+export { SkraPlacement } from '@skra/ui/core';
+
+/** A localized weekday column header (short label + full name for the `<abbr title>`). */
+interface WeekdayHeader {
+    /** ISO weekday 1=Mon … 7=Sun — a stable `@for` track key. */
+    readonly key: number;
+    readonly short: string;
+    readonly long: string;
+}
+
+interface DayCell {
+    readonly key: string;
+    readonly iso: string | null;
+    readonly dayNum: string;
+    readonly srName: string;
+    readonly today: boolean;
+    readonly selected: boolean;
+    readonly disabled: boolean;
+    readonly focused: boolean;
+}
+interface WeekRow {
+    readonly key: number;
+    readonly days: DayCell[];
+}
+/**
+ * SkraDatePicker — pick a single **calendar date** from an APG Date Picker grid in the native top layer.
+ * Second Tier-3 component. A value-display **trigger** (`<button>`) opens a non-modal top-layer **calendar
+ * panel** (Popover API, `popover="auto"`, ADR 0044). The value is an **ISO 8601 date-only string**
+ * (`YYYY-MM-DD`), consumer-owned (ADR 0050/037 — NO `@angular/forms`); all date math is the zoneless
+ * UTC-calculator discipline in `calendar-math` (no date library). Localization (month/weekday names,
+ * first-day-of-week, digits) is `Intl`-derived in `calendar-intl`; the 2-D grid keyboard is the
+ * hand-rolled `SkraCalendarKeyboard` (ADR 0044 §7 — roving REAL focus, not aria-activedescendant).
+ *
+ * No projected content: the calendar days are GENERATED (the structural divergence from select/combobox —
+ * there is no `skra-option` reuse). The only focusable element in the open panel is the roving day cell;
+ * the month-nav buttons are pointer affordances (`tabindex="-1"`, driven by PageUp/PageDown on keyboard),
+ * and Tab dismisses — so no focus-containment machinery is needed (spec Q-1).
+ *
+ * Full contract: adr/specs/component-datepicker-spec.md.
+ */
+declare class SkraDatePicker {
+    /** Consumer-owned value: ISO 8601 date-only (`YYYY-MM-DD`); `''` = unset. NEVER a Date (ADR 0050/037). */
+    readonly value: _angular_core.InputSignal<string>;
+    /** Inclusive lower bound (ISO); `''` = unbounded (ADR 0050 §2). */
+    readonly min: _angular_core.InputSignal<string>;
+    /** Inclusive upper bound (ISO); `''` = unbounded. */
+    readonly max: _angular_core.InputSignal<string>;
+    /** `Intl` locale (BCP-47); `undefined` → host default (ADR 0050 §5). */
+    readonly locale: _angular_core.InputSignal<string | undefined>;
+    /** First day of week, ISO 1=Mon … 7=Sun; overrides `Intl.getWeekInfo` (the MVP safety valve, ADR 0050 §5). */
+    readonly firstDayOfWeek: _angular_core.InputSignal<number | undefined>;
+    /** Value-empty hint in the trigger (NOT the accessible name — ADR 033). */
+    readonly placeholder: _angular_core.InputSignal<string>;
+    /** Placement intent; flip/shift adjust at runtime. */
+    readonly placement: _angular_core.InputSignal<SkraPlacement>;
+    /** Standalone availability source — `SkraFieldContext` wins when present. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly readonly: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Fires ONLY on user date selection — never on a programmatic `value()` change (ADR 037/0050). */
+    readonly valueChange: _angular_core.OutputEmitterRef<string>;
+    private readonly triggerRef;
+    private readonly panelRef;
+    private readonly context;
+    private readonly injector;
+    private readonly keyboard;
+    readonly panelId: string;
+    readonly monthYearId: string;
+    protected readonly isOpen: _angular_core.WritableSignal<boolean>;
+    /** Today's LOCAL date (ADR 0050 §3) — stable for the session. */
+    private readonly todayIso;
+    /** The roving-focus day; SINGLE source of truth for what the grid shows AND which cell is focusable. */
+    private readonly focusedIso;
+    private positioner?;
+    /** Set when a close should return focus to the trigger (keyboard/select), not on outside-click. */
+    private returnFocus;
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    protected readonly isReadonly: _angular_core.Signal<boolean>;
+    protected readonly hasError: _angular_core.Signal<boolean>;
+    protected readonly isRequired: _angular_core.Signal<boolean>;
+    protected readonly triggerId: _angular_core.Signal<string | null>;
+    protected readonly describedBy: _angular_core.Signal<string | null>;
+    /** The committed value, defensively normalized: invalid/out-of-range → `''` for display (ADR 0050 §1). */
+    protected readonly selectedIso: _angular_core.Signal<string>;
+    protected readonly formattedValue: _angular_core.Signal<string>;
+    private readonly firstDow;
+    /** The month being shown — always the focused day's month (keeps the roving tabindex valid). */
+    private readonly displayedMonth;
+    protected readonly monthYearLabel: _angular_core.Signal<string>;
+    protected readonly prevMonthLabel: _angular_core.Signal<string>;
+    protected readonly nextMonthLabel: _angular_core.Signal<string>;
+    protected readonly weekdayHeadersView: _angular_core.Signal<WeekdayHeader[]>;
+    protected readonly weeks: _angular_core.Signal<WeekRow[]>;
+    constructor();
+    protected onTriggerClick(event: MouseEvent): void;
+    protected onTriggerKeydown(event: KeyboardEvent): void;
+    protected onGridKeydown(event: KeyboardEvent): void;
+    protected goToPreviousMonth(): void;
+    protected goToNextMonth(): void;
+    protected selectDate(iso: string): void;
+    protected onPanelToggle(event: Event): void;
+    private onOpen;
+    private onClose;
+    private open;
+    private close;
+    /** Seed the focused day on open: the valid current value, else today, clamped into `[min,max]`. */
+    private seedFocus;
+    private monthOffsetLabel;
+    private emptyCell;
+    private scheduleFocus;
+    private focusActiveDay;
+    /** Read a length comp token (px/rem) off the panel computed style for the positioner. */
+    private cssLenPx;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SkraDatePicker, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SkraDatePicker, "skra-datepicker", ["skraDatePicker"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "locale": { "alias": "locale"; "required": false; "isSignal": true; }; "firstDayOfWeek": { "alias": "firstDayOfWeek"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "placement": { "alias": "placement"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+}
+
+/**
+ * The intent a key produces in the calendar grid. The controller is PURE (no DOM, no focus, no signals);
+ * the `skra-datepicker` component applies the intent — sets `focusedIso`/`displayedMonth` and moves REAL
+ * DOM focus (roving). `monthChanged` tells the component the grid will re-stamp so it must re-`focus()`.
+ */
+type CalendarKeyIntent = {
+    readonly type: 'focus';
+    readonly iso: string;
+    readonly monthChanged: boolean;
+} | {
+    readonly type: 'select';
+} | {
+    readonly type: 'close';
+} | {
+    readonly type: 'none';
+};
+interface CalendarKeyContext {
+    /** The currently focused day (ISO). */
+    readonly focusedIso: string;
+    /** First day of week, ISO 1=Mon … 7=Sun (already resolved by `calendar-intl`). */
+    readonly firstDayOfWeek: number;
+}
+/**
+ * SkraCalendarKeyboard — the WAI-ARIA APG **Date Picker Dialog** grid keyboard model (2-D), confined to
+ * ONE file. The THIRD per-pattern keyboard controller and the FIRST that does NOT wrap a CDK key manager:
+ * neither `FocusKeyManager` (Menu) nor `ActiveDescendantKeyManager` (Select/Combobox) models a 2-D grid
+ * whose focusable cell set is recomputed on month change (ADR 0044 §7 note, 2026-06-14). Date arithmetic
+ * is delegated to `calendar-math` (the ADR 0050 single math site); this controller only maps keys to
+ * intents. Roving REAL focus (NOT `aria-activedescendant`) — the divergence from Select/Combobox.
+ *
+ * Navigation is unclamped (a user may move onto a disabled out-of-range day — APG-discoverable); only
+ * SELECTION is range-guarded, and that guard lives in the component (one place, shared with pointer click).
+ */
+declare class SkraCalendarKeyboard {
+    resolve(event: {
+        key: string;
+        shiftKey: boolean;
+    }, ctx: CalendarKeyContext): CalendarKeyIntent;
+    private toFocus;
+    private monthChanged;
+    private weekStart;
+}
+
+export { SkraCalendarKeyboard, SkraDatePicker };
+export type { CalendarKeyContext, CalendarKeyIntent };
+//# sourceMappingURL=skra-ui-datepicker.d.ts.map

package/types/skra-ui-datepicker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skra-ui-datepicker.d.ts","sources":["../../../../libs/ui/datepicker/src/lib/datepicker/calendar-intl.ts","../../../../libs/ui/datepicker/src/lib/datepicker/datepicker.ts","../../../../libs/ui/datepicker/src/lib/datepicker/calendar-keyboard.ts"],"mappings":";;;;AAWA;UACiB,aAAa;;AAE5B;AACA;AACA;AACD;;AC2BD,UAAU,OAAO;AACf;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACD;AAED,UAAU,OAAO;AACf;AACA,mBAAe,OAAO;AACvB;AAID;;;;;;;;;;;;;;;AAeG;AACH,cAyJa,cAAc;;oBAEX,aAAA,CAAA,WAAA;;kBAEF,aAAA,CAAA,WAAA;;kBAEA,aAAA,CAAA,WAAA;;qBAEG,aAAA,CAAA,WAAA;;6BAEQ,aAAA,CAAA,WAAA;;0BAEH,aAAA,CAAA,WAAA;;wBAEF,aAAA,CAAA,WAAA,CAAA,aAAA;;uBAED,aAAA,CAAA,wBAAA;uBACA,aAAA,CAAA,wBAAA;;0BAGG,aAAA,CAAA,gBAAA;AAEpB;AAEA;AAEA;AACA;AACA;;;AAIA,+BAAyB,aAAA,CAAA,cAAA;;AAGzB;;AAEA;;;;AAOA,mCAA6B,aAAA,CAAA,MAAA;AAG7B,mCAA6B,aAAA,CAAA,MAAA;AAG7B,iCAA2B,aAAA,CAAA,MAAA;AAG3B,mCAA6B,aAAA,CAAA,MAAA;AAG7B,kCAA4B,aAAA,CAAA,MAAA;AAG5B,oCAA8B,aAAA,CAAA,MAAA;;AAM9B,oCAA8B,aAAA,CAAA,MAAA;AAI9B,uCAAiC,aAAA,CAAA,MAAA;AAGjC;;AAIA;AAIA,uCAAiC,aAAA,CAAA,MAAA;AAOjC,uCAAiC,aAAA,CAAA,MAAA;AACjC,uCAAiC,aAAA,CAAA,MAAA;AACjC,2CAAqC,aAAA,CAAA,MAAA,CAAAA,aAAA;AAGrC,8BAAwB,aAAA,CAAA,MAAA,CAAA,OAAA;;AAqDxB,oCAAgC,UAAU;AAI1C,sCAAkC,aAAa;AAS/C,mCAA+B,aAAa;;;AAwC5C;AAQA,mCAA+B,KAAK;AAOpC;AAiBA;AASA;AAGA;;AAKA;AAMA;AAMA;AAaA;AAIA;;AASA;oDA7RW,cAAc;sDAAd,cAAc;AAyS1B;;ACxgBD;;;;AAIG;AACG,KAAM,iBAAiB;AAEvB;AACA;AACA;;AAEA;;AACA;;AACA;;UAEW,kBAAkB;;AAEjC;;AAEA;AACD;AAID;;;;;;;;;;AAUG;AACH,cAAa,oBAAoB;;;;AAEY,YACpC,kBAAkB,GACtB,iBAAiB;AA8CpB;AAQA;AAMA;AAMD;;;;","names":["__calendar_intl.WeekdayHeader"]}