@slotted/angular 0.0.0-stage → 0.1.0-beta.1

package/types/slotted-angular-calendar.d.ts

@@ -0,0 +1,280 @@
+import * as _slotted_core_date from '@slotted/core/date';
+import { PlainDate, CalendarWeek, CalendarDay } from '@slotted/core/date';
+import * as _slotted_core_i18n from '@slotted/core/i18n';
+import { PartialMessages, CalendarMessages } from '@slotted/core/i18n';
+import * as _angular_core from '@angular/core';
+import { InjectionToken, OnInit } from '@angular/core';
+import { ChangeRequest, ChangeReason } from '@slotted/core/state';
+
+/** A run of days, either end of which may still be open while it is drawn. */
+interface DateRange {
+    readonly start: PlainDate | null;
+    readonly end: PlainDate | null;
+}
+/**
+ * What the calendar holds, which depends on what it was asked to collect: one
+ * date, a run of them, or a set.
+ */
+type CalendarValue = PlainDate | DateRange | PlainDate[] | null;
+/** How many dates the reader may choose. */
+type CalendarSelectionMode = 'single' | 'range' | 'multiple';
+/** Which grid the calendar is showing. The heading walks up; Escape walks down. */
+type CalendarView = 'day' | 'month' | 'year';
+/** What happens to a day belonging to the month either side. */
+type CalendarOutsideDays = 'shown' | 'selectable' | 'hidden';
+/**
+ * The calendar system the value is written in. One value today, and an axis
+ * rather than a silence: a second calendar system is a second arithmetic, and
+ * declaring the axis now is what keeps its arrival from being a contract break.
+ */
+type CalendarCalendar = 'gregory';
+interface CalendarDefaults {
+    calendar: CalendarCalendar;
+    firstDayOfWeek: number | undefined;
+    fixedWeeks: boolean;
+    months: number;
+    /**
+     * Unset is not `shown`: a calendar showing one month draws the days either
+     * side of it, and a calendar showing two would draw the same six days in
+     * both grids. See the resolution in `calendar.ts`.
+     */
+    outsideDays: CalendarOutsideDays | undefined;
+    timeZone: string | undefined;
+    weekNumbers: boolean;
+}
+declare const CALENDAR_DEFAULTS: InjectionToken<CalendarDefaults>;
+/**
+ * An application decides once which day its weeks start on, which zone answers
+ * "today" and whether its calendars keep a fixed six-row grid — rather than
+ * repeating the same inputs on every instance. Its words and the locale that
+ * writes its months come from the language in force (`provideSlotted`).
+ *
+ * `fixedWeeks` is the one worth setting where calendars live in popovers: a
+ * surface that grows a row between one press of "next" and the next moves the
+ * target the reader was aiming at.
+ */
+declare function provideCalendarDefaults(defaults: Partial<CalendarDefaults>): {
+    provide: InjectionToken<CalendarDefaults>;
+    useFactory: () => CalendarDefaults;
+};
+/** What a calendar renders as here, before it states anything of its own. */
+declare function injectCalendarDefaults(): CalendarDefaults;
+
+/**
+ * A month grid, and the two pages above it.
+ *
+ * **It is a real `table` with the `grid` role on it.** The APG's own note is
+ * why nothing here writes `row`, `columnheader` or `gridcell`: those are
+ * implied by `tr`, `th` and `td`, and writing them again would duplicate
+ * semantics the platform already gives.
+ *
+ * **The date the reader is on and the date the reader has chosen are two
+ * values**, and each has a model of its own — a product that pages a calendar
+ * from outside it has nowhere else to say so.
+ *
+ * **A date the predicate refuses stays reachable.** It carries `aria-disabled`
+ * rather than being taken out of the grid, so a reader can arrow onto it, hear
+ * why it is out, and arrow past it.
+ */
+declare class SlCalendar implements OnInit {
+    /** Present means the consumer owns the value. */
+    readonly value: _angular_core.InputSignal<CalendarValue | undefined>;
+    readonly defaultValue: _angular_core.InputSignal<CalendarValue | undefined>;
+    /** The date the reader is on. Present means the consumer owns it. */
+    readonly focusedDate: _angular_core.InputSignal<PlainDate | undefined>;
+    readonly defaultFocusedDate: _angular_core.InputSignal<PlainDate | undefined>;
+    readonly min: _angular_core.InputSignal<PlainDate | undefined>;
+    readonly max: _angular_core.InputSignal<PlainDate | undefined>;
+    readonly isDateUnavailable: _angular_core.InputSignal<((date: PlainDate) => boolean) | undefined>;
+    readonly selectionMode: _angular_core.InputSignal<CalendarSelectionMode>;
+    readonly months: _angular_core.InputSignalWithTransform<number | undefined, unknown>;
+    /** Present means the consumer owns which grid is showing. */
+    readonly view: _angular_core.InputSignal<CalendarView | undefined>;
+    readonly defaultView: _angular_core.InputSignal<CalendarView | undefined>;
+    readonly weekNumbers: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly fixedWeeks: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly outsideDays: _angular_core.InputSignal<CalendarOutsideDays | undefined>;
+    /** The locale that writes months and days. Unset, the language in force decides. */
+    readonly locale: _angular_core.InputSignal<string | undefined>;
+    readonly timeZone: _angular_core.InputSignal<string | undefined>;
+    readonly firstDayOfWeek: _angular_core.InputSignalWithTransform<number | undefined, unknown>;
+    readonly calendar: _angular_core.InputSignal<"gregory" | undefined>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly readOnly: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    /**
+     * Words laid over the catalog of the language in force, key by key: the
+     * names of the previous and next triggers.
+     */
+    readonly messages: _angular_core.InputSignal<PartialMessages<CalendarMessages> | undefined>;
+    readonly valueChange: _angular_core.OutputEmitterRef<ChangeRequest<CalendarValue>>;
+    readonly focusedDateChange: _angular_core.OutputEmitterRef<ChangeRequest<PlainDate>>;
+    readonly viewChange: _angular_core.OutputEmitterRef<CalendarView>;
+    /**
+     * The pending end of an open run: the day under the pointer, or the focused
+     * day when no pointer is over the grid, and `null` while no run is open. A
+     * fact the grid states rather than a value the consumer owns, which is why
+     * it is an output and not a model — `date-range-picker` reads it to say how
+     * long the run would be.
+     */
+    readonly previewChange: _angular_core.OutputEmitterRef<PlainDate | null>;
+    private readonly element;
+    private readonly injector;
+    private readonly defaults;
+    private readonly appLocale;
+    /** The family's words in the language in force, with this calendar's `messages` laid over them. */
+    readonly t: _slotted_core_i18n.FamilyTranslator<CalendarMessages>;
+    protected readonly headingId: string;
+    private readonly ownValue;
+    private readonly ownFocused;
+    private readonly ownView;
+    /**
+     * The first month on screen, which is **not** the month the reader is on.
+     *
+     * Drawing two months from the focused date meant that choosing a day in the
+     * second one scrolled the pair: a reader looking at June and July who chose
+     * 9 June was shown July and August, with half of what they had just chosen
+     * off screen. The page moves only when the reader leaves it.
+     */
+    private readonly page;
+    private readonly today;
+    /** Focus is only moved into the DOM after a key, never on a render. */
+    private restoreFocus;
+    protected readonly held: _angular_core.Signal<CalendarValue>;
+    protected readonly focused: _angular_core.Signal<PlainDate>;
+    /** Which grid is showing. Public, so a template reaches it through `exportAs`. */
+    readonly currentView: _angular_core.Signal<CalendarView>;
+    protected readonly resolvedMonths: _angular_core.Signal<number>;
+    protected readonly resolvedWeekNumbers: _angular_core.Signal<boolean>;
+    protected readonly resolvedFixedWeeks: _angular_core.Signal<boolean>;
+    /**
+     * One month draws the days either side of it, because a week that starts on
+     * the 30th of the month before has to say what that cell is. Two months
+     * cannot: September's grid ends with the first three days of October and
+     * October's begins with the last four of September, so a range across the
+     * boundary is painted twice and a reader sees an interval twice as long as
+     * the one chosen. Every surveyed multi-month calendar hides them, and so
+     * does this one — until the consumer says otherwise, on the instance or on
+     * the provider.
+     */
+    protected readonly resolvedOutsideDays: _angular_core.Signal<CalendarOutsideDays>;
+    protected readonly resolvedCalendar: _angular_core.Signal<"gregory">;
+    protected readonly editable: _angular_core.Signal<boolean>;
+    protected readonly format: _angular_core.Signal<_slotted_core_date.DateFormat>;
+    protected readonly weekdayLong: _angular_core.Signal<string[]>;
+    protected readonly weekdayNarrow: _angular_core.Signal<string[]>;
+    protected readonly monthNames: _angular_core.Signal<string[]>;
+    protected readonly years: _angular_core.Signal<number[]>;
+    protected readonly shownMonths: _angular_core.Signal<{
+        year: number;
+        month: number;
+    }[]>;
+    protected readonly heading: _angular_core.Signal<string>;
+    constructor();
+    ngOnInit(): void;
+    /** Puts focus on the cell holding the roving tab stop. */
+    focus(): void;
+    /** Moves the reader to a date, paging the grid to reach it. */
+    focusDate(date: PlainDate): void;
+    /** The date, the run or the set the calendar holds. */
+    readonly selection: _angular_core.Signal<CalendarValue>;
+    protected captionOf(month: {
+        year: number;
+        month: number;
+    }): string;
+    protected weeksOf(month: {
+        year: number;
+        month: number;
+    }): CalendarWeek[];
+    protected unavailable(date: PlainDate): boolean;
+    /** Unavailable, or an outside day the axis says may not be chosen. */
+    /** Whether the cell carries a day at all, or stands empty to fill the row. */
+    protected drawn(day: CalendarDay): boolean;
+    /**
+     * The grid already knows which month a day belongs to, and asking the first
+     * shown month instead refused every day of the second one in a pair.
+     */
+    protected refused(day: CalendarDay): boolean;
+    protected chosen(date: PlainDate): boolean;
+    /**
+     * The day under the pointer, held only to name the pending end of an open
+     * run. It never moves the roving focus: a pointer crossing the grid is not
+     * the reader choosing where they are.
+     */
+    protected readonly hovered: _angular_core.WritableSignal<PlainDate | null>;
+    /** The run as it would close on the pending end; `null` while no run is open. */
+    private readonly pending;
+    private readonly previewEnd;
+    protected rangeState(date: PlainDate): "start" | "end" | "inside" | null;
+    /** Every cell of the pending band is a proposal except the start the reader chose. */
+    protected proposed(date: PlainDate): boolean;
+    protected isToday(date: PlainDate): boolean;
+    protected tabIndexOf(date: PlainDate): number;
+    protected select(date: PlainDate, reason: ChangeReason, source: Event | undefined): void;
+    /** The reader moves with the page rather than staying behind it. */
+    protected turnPage(direction: 1 | -1, source: Event): void;
+    protected walkUp(): void;
+    protected pickMonth(month: number, source: Event): void;
+    protected pickYear(year: number, source: Event): void;
+    protected onKeyDown(event: KeyboardEvent): void;
+    /**
+     * The first date the reader is put on: what a consumer said, then the value
+     * it holds, then today. A calendar that opened on an arbitrary month would
+     * make the reader page to now before doing anything at all.
+     */
+    private startingDate;
+    private setView;
+    private requestValue;
+    private requestFocused;
+    /**
+     * Focus follows a key onto the cell that holds the roving tab stop, once the
+     * page holding it is rendered.
+     *
+     * A key that crosses the month edge lands on the old page's trailing day
+     * first, and the page follows one render later. Focused before that, the
+     * cell was replaced under the reader and focus fell to the document — which
+     * a consumer owning `focusedDate` met on every crossing. Focus is moved only
+     * while it is still in the calendar or was lost to the document, so a
+     * consumer that refused the move never has focus taken from elsewhere.
+     */
+    private followFocus;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlCalendar, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlCalendar, "[slCalendar]", ["slCalendar"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "defaultValue": { "alias": "defaultValue"; "required": false; "isSignal": true; }; "focusedDate": { "alias": "focusedDate"; "required": false; "isSignal": true; }; "defaultFocusedDate": { "alias": "defaultFocusedDate"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "isDateUnavailable": { "alias": "isDateUnavailable"; "required": false; "isSignal": true; }; "selectionMode": { "alias": "selectionMode"; "required": false; "isSignal": true; }; "months": { "alias": "months"; "required": false; "isSignal": true; }; "view": { "alias": "view"; "required": false; "isSignal": true; }; "defaultView": { "alias": "defaultView"; "required": false; "isSignal": true; }; "weekNumbers": { "alias": "weekNumbers"; "required": false; "isSignal": true; }; "fixedWeeks": { "alias": "fixedWeeks"; "required": false; "isSignal": true; }; "outsideDays": { "alias": "outsideDays"; "required": false; "isSignal": true; }; "locale": { "alias": "locale"; "required": false; "isSignal": true; }; "timeZone": { "alias": "timeZone"; "required": false; "isSignal": true; }; "firstDayOfWeek": { "alias": "firstDayOfWeek"; "required": false; "isSignal": true; }; "calendar": { "alias": "calendar"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readOnly": { "alias": "readOnly"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "messages": { "alias": "messages"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; "focusedDateChange": "focusedDateChange"; "viewChange": "viewChange"; "previewChange": "previewChange"; }, never, never, true, never>;
+}
+
+/**
+ * What choosing a date does to a value, in the three modes the family ships.
+ *
+ * It is separate from the component because none of it touches the DOM: a
+ * range that is completed, a range that is restarted, and a set that a second
+ * press takes a date back out of are all arithmetic over `PlainDate`, and the
+ * two bindings must not each decide them.
+ */
+
+declare function isRange(value: CalendarValue): value is DateRange;
+declare function asDates(value: CalendarValue): PlainDate[];
+/**
+ * Whether a date is one of the two ends of a run, inside it, or none of the
+ * three. A range with one end open has a start and no run, which is what the
+ * calendar draws while the reader is choosing the second date.
+ */
+declare function rangeStateOf(date: PlainDate, value: CalendarValue): 'start' | 'end' | 'inside' | null;
+declare function isSelected(date: PlainDate, value: CalendarValue): boolean;
+/**
+ * The value a press produces.
+ *
+ * A range takes two presses and the second one may come first: a reader who
+ * chooses the 11th and then the 7th means the 7th to the 11th, not a range
+ * that runs backwards. A third press starts again, because a range that grew
+ * on every press could never be narrowed.
+ *
+ * A set removes a date a second press lands on, which is the only way to take
+ * one back out without a second control.
+ */
+declare function nextValue(date: PlainDate, value: CalendarValue, mode: CalendarSelectionMode): CalendarValue;
+/** Value equality, which `Object.is` cannot give for a run or a set. */
+declare function isSameValue(a: CalendarValue, b: CalendarValue): boolean;
+
+export { CALENDAR_DEFAULTS, SlCalendar, asDates, injectCalendarDefaults, isRange, isSameValue, isSelected, nextValue, provideCalendarDefaults, rangeStateOf };
+export type { CalendarCalendar, CalendarDefaults, CalendarOutsideDays, CalendarSelectionMode, CalendarValue, CalendarView, DateRange };
+//# sourceMappingURL=slotted-angular-calendar.d.ts.map

package/types/slotted-angular-calendar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slotted-angular-calendar.d.ts","sources":["../../calendar/src/calendar-defaults.ts","../../calendar/src/calendar.ts","../../calendar/src/calendar-selection.ts"],"mappings":"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","names":[]}

package/types/slotted-angular-card.d.ts

@@ -0,0 +1,140 @@
+import * as i0 from '@angular/core';
+import { InjectionToken } from '@angular/core';
+
+type CardOrientation = 'vertical' | 'horizontal';
+/** How the surface is bounded: by an edge, by elevation, or by a fill. */
+type CardFill = 'outline' | 'elevated' | 'subtle';
+/** The card's own inset. Density is the application's choice; this is not. */
+type CardSize = 'sm' | 'md' | 'lg';
+interface CardDefaults {
+    fill: CardFill;
+    orientation: CardOrientation;
+    size: CardSize;
+}
+declare const CARD_DEFAULTS: InjectionToken<CardDefaults>;
+/**
+ * An application decides once how its cards are bounded and how far they are
+ * inset, rather than repeating two inputs on every card. A card that states
+ * either itself still wins: an explicit input is never overridden by the token.
+ */
+declare function provideCardDefaults(defaults: Partial<CardDefaults>): {
+    provide: InjectionToken<CardDefaults>;
+    useFactory: () => CardDefaults;
+};
+/** What a card renders as here, before it states anything of its own. */
+declare function injectCardDefaults(): CardDefaults;
+
+/**
+ * A bounded surface that groups one subject. It claims nothing about what that
+ * subject is: the directive is written on the element the page chose, so an
+ * `article` with its own heading, the `li` of a list of results and the
+ * `label` of a chooser are all the same card.
+ *
+ * The card holds no state. `selected` and `disabled` mirror state that belongs
+ * to the control inside it, which is also what announces them.
+ */
+declare class SlCard {
+    /**
+     * `horizontal` puts the media beside the regions and answers the card's own
+     * inline size, returning the media to the top in a narrow container.
+     */
+    readonly orientation: i0.InputSignal<CardOrientation | undefined>;
+    /** How the surface is bounded. Falls back to the injected default. */
+    readonly fill: i0.InputSignal<CardFill | undefined>;
+    /** The card's own inset. Falls back to the injected default. */
+    readonly size: i0.InputSignal<CardSize | undefined>;
+    /**
+     * Mirrors a selection the page owns. The card paints it; the control inside
+     * announces it.
+     */
+    readonly selected: i0.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Mirrors a control the page has disabled: the card dims, stops answering
+     * hover and withdraws the hit area it added. It disables nothing, because
+     * only the control inside can refuse an interaction.
+     */
+    readonly disabled: i0.InputSignalWithTransform<boolean, unknown>;
+    private readonly defaults;
+    protected readonly resolvedOrientation: i0.Signal<CardOrientation>;
+    protected readonly resolvedFill: i0.Signal<CardFill>;
+    protected readonly resolvedSize: i0.Signal<CardSize>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlCard, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SlCard, "[slCard]", ["slCard"], { "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "fill": { "alias": "fill"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "selected": { "alias": "selected"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * The corner of the header: a badge, a status, a menu button. It stays on the
+ * first row, so a title that wraps to two lines does not drag it down, and it
+ * sits above the hit area a card link stretches, so it stays operable.
+ */
+declare class SlCardActions {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlCardActions, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SlCardActions, "[slCardActions]", ["slCardActions"], {}, {}, never, never, true, never>;
+}
+
+/** The content. It takes whatever a card stretched to a row height has left. */
+declare class SlCardBody {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlCardBody, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SlCardBody, "[slCardBody]", ["slCardBody"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * Actions and metadata. The footer sits above the hit area a card action
+ * stretches, so a secondary action inside it stays operable.
+ */
+declare class SlCardFooter {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlCardFooter, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SlCardFooter, "[slCardFooter]", ["slCardFooter"], {}, {}, never, never, true, never>;
+}
+
+/** A title and the line that supports it. Both of them are Typography. */
+declare class SlCardHeader {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlCardHeader, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SlCardHeader, "[slCardHeader]", ["slCardHeader"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * The one destination a card resolves to, written on the anchor the page
+ * already has. Its hit area covers the whole surface, so the card is clickable
+ * without the root becoming a link: the accessible name stays the title rather
+ * than every string in the card, and Enter, the context menu and middle-click
+ * stay the platform's.
+ *
+ * A card carries at most one. Two would be two destinations for one surface.
+ */
+declare class SlCardLink {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlCardLink, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SlCardLink, "a[slCardLink]", ["slCardLink"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * Media that bleeds to the card's edge and rounds the corners it touches. It
+ * clips itself, because a card that clipped its own content would cut off an
+ * overlay opened inside it.
+ */
+declare class SlCardMedia {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlCardMedia, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SlCardMedia, "[slCardMedia]", ["slCardMedia"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * The place a choice card keeps for its control: a native checkbox or radio,
+ * and `slCheckbox` when the family that owns the check ships it.
+ *
+ * It is the slot and not the glyph. The card sizes the control from the icon
+ * scale density moves, tints the platform's own check with the accent, and
+ * centres it on the title's first row; what a check and a dot look like is one
+ * decision, and it belongs to `checkbox`.
+ *
+ * The control inside keeps its own `ControlValueAccessor`, so `[(ngModel)]` and
+ * a Reactive Form control both reach it untouched. The card is the `<label>`
+ * around it and holds no value of its own.
+ */
+declare class SlCardSelection {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlCardSelection, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SlCardSelection, "[slCardSelection]", ["slCardSelection"], {}, {}, never, never, true, never>;
+}
+
+export { CARD_DEFAULTS, SlCard, SlCardActions, SlCardBody, SlCardFooter, SlCardHeader, SlCardLink, SlCardMedia, SlCardSelection, injectCardDefaults, provideCardDefaults };
+export type { CardDefaults, CardFill, CardOrientation, CardSize };
+//# sourceMappingURL=slotted-angular-card.d.ts.map

package/types/slotted-angular-card.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slotted-angular-card.d.ts","sources":["../../card/src/card-defaults.ts","../../card/src/card.ts","../../card/src/card-actions.ts","../../card/src/card-body.ts","../../card/src/card-footer.ts","../../card/src/card-header.ts","../../card/src/card-link.ts","../../card/src/card-media.ts","../../card/src/card-selection.ts"],"mappings":";;;KAEY,eAAe;AAE3B;AACM,KAAM,QAAQ;AAEpB;AACM,KAAM,QAAQ;UAEH,YAAY;UACrB,QAAQ;iBACD,eAAe;UACtB,QAAQ;AACf;AAED,cAAa,aAAa,EAAA,cAAA,CAAA,YAAA;AAK1B;;;;AAIG;AACH,iBAAgB,mBAAmB,WAAW,OAAO,CAAC,YAAY;;sBAG9C,YAAY;AAM/B;AAED;AACA,iBAAgB,kBAAkB,IAAI,YAAY;;ACxBlD;;;;;;;;AAQG;AACH,cAkBa,MAAM;AACjB;;;AAGG;0BACiBA,EAAA,CAAA,WAAA,CAAA,eAAA;;mBAEPA,EAAA,CAAA,WAAA,CAAA,QAAA;;mBAEAA,EAAA,CAAA,WAAA,CAAA,QAAA;AACb;;;AAGG;uBACcA,EAAA,CAAA,wBAAA;AACjB;;;;AAIG;uBACcA,EAAA,CAAA,wBAAA;AAEjB;AAEA,4CAAsCA,EAAA,CAAA,MAAA,CAAA,eAAA;AAGtC,qCAA+BA,EAAA,CAAA,MAAA,CAAA,QAAA;AAC/B,qCAA+BA,EAAA,CAAA,MAAA,CAAA,QAAA;yCA5BpB,MAAM;2CAAN,MAAM;AA6BlB;;ACpED;;;;AAIG;AACH,cAMa,aAAa;yCAAb,aAAa;2CAAb,aAAa;AAAG;;ACX7B;AACA,cAMa,UAAU;yCAAV,UAAU;2CAAV,UAAU;AAAG;;ACP1B;;;AAGG;AACH,cAMa,YAAY;yCAAZ,YAAY;2CAAZ,YAAY;AAAG;;ACV5B;AACA,cAMa,YAAY;yCAAZ,YAAY;2CAAZ,YAAY;AAAG;;ACP5B;;;;;;;;AAQG;AACH,cAMa,UAAU;yCAAV,UAAU;2CAAV,UAAU;AAAG;;ACf1B;;;;AAIG;AACH,cAMa,WAAW;yCAAX,WAAW;2CAAX,WAAW;AAAG;;ACX3B;;;;;;;;;;;;AAYG;AACH,cAMa,eAAe;yCAAf,eAAe;2CAAf,eAAe;AAAG;;","names":["_angular_core"]}