@eui/ecl 19.3.3-snapshot-1754912586607 → 21.0.0-alpha.2

package/components/ecl-menu/index.d.ts

@@ -1,9 +1,510 @@
-import { EclMenuComponent, EclMenuItemComponent } from './ecl-menu';
-import { EclMenuMegaComponent, EclMenuMegaItemComponent } from './ecl-menu-mega';
-export * from './ecl-menu.module';
-export * from './ecl-menu/index';
-export * from './ecl-menu-mega/index';
-export * from './events/index';
-export * from './models/ecl-menu-item.model';
-export declare const EUI_ECL_MENU: readonly [typeof EclMenuComponent, typeof EclMenuItemComponent, typeof EclMenuMegaComponent, typeof EclMenuMegaItemComponent];
-//# sourceMappingURL=index.d.ts.map
+import * as i0 from '@angular/core';
+import { AfterViewInit, QueryList, ElementRef, EventEmitter, AfterContentInit, OnDestroy, OnInit } from '@angular/core';
+import { EclDomEvent, ECLBaseDirective } from '@eui/ecl/core';
+import { EclButtonComponent } from '@eui/ecl/components/ecl-button';
+import { Params, QueryParamsHandling } from '@angular/router';
+import { EclLinkDirective } from '@eui/ecl/components/ecl-link';
+import { EclIconComponent } from '@eui/ecl/components/ecl-icon';
+
+interface EclMenuItem {
+    id?: string;
+    label: string;
+    isHovered?: boolean;
+    isCurrent?: boolean;
+    isExpanded?: boolean;
+    isVisible?: boolean;
+    hasChildren?: boolean;
+    children?: Array<EclMenuItem>;
+}
+
+declare class EclMenuItemSelectEvent extends EclDomEvent<Event> {
+    menuItem: EclMenuItem;
+    domEvent: Event;
+    constructor(menuItem: EclMenuItem, domEvent?: Event);
+}
+declare class EclMenuItemHoverEvent extends EclDomEvent<MouseEvent> {
+    menuItem: EclMenuItem;
+    domEvent: MouseEvent;
+    constructor(menuItem: EclMenuItem, domEvent?: MouseEvent);
+}
+declare class EclMenuItemHoverOutEvent extends EclDomEvent<MouseEvent> {
+    menuItem: EclMenuItem;
+    domEvent: MouseEvent;
+    constructor(menuItem: EclMenuItem, domEvent?: MouseEvent);
+}
+declare class EclMenuItemFocusEvent extends EclDomEvent<FocusEvent> {
+    menuItem: EclMenuItem;
+    domEvent: FocusEvent;
+    constructor(menuItem: EclMenuItem, domEvent?: FocusEvent);
+}
+declare class EclMenuItemCaretEvent extends EclDomEvent<MouseEvent> {
+    menuItem: EclMenuItem;
+    domEvent: MouseEvent;
+    constructor(menuItem: EclMenuItem, domEvent?: MouseEvent);
+}
+declare class EclMenuItemKeydownEvent extends EclDomEvent<KeyboardEvent> {
+    menuItem: EclMenuItem;
+    domEvent: KeyboardEvent;
+    constructor(menuItem: EclMenuItem, domEvent?: KeyboardEvent);
+}
+declare class EclMenuItemParentFocusEvent {
+    menuItem: EclMenuItem;
+    constructor(menuItem: EclMenuItem);
+}
+
+/**
+ * This component represents a sub-menu item, that is on the second level of the ecl-menu.
+ * Adds some custom styling and functionality.
+ */
+declare class EclMenuMegaItemComponent extends ECLBaseDirective implements EclMenuItem, AfterViewInit {
+    id: string;
+    label: string;
+    routerLink: string | any[];
+    queryParams: Params | null;
+    queryParamsHandling: QueryParamsHandling;
+    href: string;
+    target: string;
+    cmpClass: boolean;
+    /**
+     * The default role of the DOM element is 'listitem', should not be changed.
+     */
+    role: string;
+    isCurrent: boolean;
+    /**
+     * An additional item, that represents a link.
+     */
+    isSeeAll: boolean;
+    linkExtraAttributes: {
+        [key: string]: string;
+    };
+    /**
+     * If menu item includes any icon, added by the user (for example for 'external' link).
+     */
+    iconComponents: QueryList<EclIconComponent>;
+    /**
+     * If menu item includes any links, added by the user.
+     */
+    links: QueryList<EclLinkDirective>;
+    /**
+     * The actual link of the menu item.
+     */
+    megaMenuLink: ElementRef;
+    menuItemSelect: EventEmitter<EclMenuItemSelectEvent>;
+    menuItemKeydown: EventEmitter<EclMenuItemKeydownEvent>;
+    hasChildren: boolean;
+    isExpanded: boolean;
+    children: Array<EclMenuItem>;
+    private renderer;
+    ngAfterViewInit(): void;
+    /**
+     *
+     * @param evt This event is emited, when the menu item is clicked.
+     */
+    onItemClick(evt: Event): void;
+    onHostClick(evt: MouseEvent): void;
+    /**
+     * When the item is the current active item, the 'aria-current' attribute is set to 'page'.
+     */
+    get ariaCurrent(): string | null;
+    /**
+     * Focus should be set on the underlying <a> element.
+     */
+    onFocus(): void;
+    onKeydown(evt: Event): void;
+    /**
+     * Adds specific classes to content children (icons or links).
+     */
+    private manageContentChildren;
+    private setExtraAttributesForLink;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EclMenuMegaItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EclMenuMegaItemComponent, "ecl-menu-mega-item", never, { "id": { "alias": "id"; "required": false; }; "label": { "alias": "label"; "required": false; }; "routerLink": { "alias": "routerLink"; "required": false; }; "queryParams": { "alias": "queryParams"; "required": false; }; "queryParamsHandling": { "alias": "queryParamsHandling"; "required": false; }; "href": { "alias": "href"; "required": false; }; "target": { "alias": "target"; "required": false; }; "isCurrent": { "alias": "isCurrent"; "required": false; }; "isSeeAll": { "alias": "isSeeAll"; "required": false; }; "linkExtraAttributes": { "alias": "linkExtraAttributes"; "required": false; }; }, { "menuItemSelect": "menuItemSelect"; "menuItemKeydown": "menuItemKeydown"; }, ["iconComponents", "links"], ["*"], true, never>;
+    static ngAcceptInputType_isCurrent: unknown;
+    static ngAcceptInputType_isSeeAll: unknown;
+}
+
+/**
+ * This component acts as a wrapper for the second level of menu items, that are children of one root item.
+ * Provides functionality for some common events like keyboard navigation and manages relations between sub items.
+ */
+declare class EclMenuMegaComponent extends ECLBaseDirective implements AfterContentInit, OnDestroy {
+    el: ElementRef<any>;
+    isRtlDisplay: boolean | any;
+    /**
+     * List of the sub items.
+     */
+    eclMenuMegaItems: QueryList<EclMenuMegaItemComponent>;
+    menuItemSelect: EventEmitter<EclMenuItemSelectEvent>;
+    /**
+     * Used in keyboard navigation, when focus has to be moved to the parent item.
+     */
+    menuMegaItemParentFocus: EventEmitter<EclMenuItemSelectEvent>;
+    /**
+     * Used when kyboard navigation with TAB reaches the last sub item.
+     */
+    menuMegaLastItemTab: EventEmitter<void>;
+    offsetLeft: number | null;
+    offsetRight: number | null;
+    get cssClasses(): string;
+    private differ;
+    private diff;
+    private destroy$;
+    private differs;
+    constructor();
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    selectFirstSubItem(): void;
+    private createContentChildrenMenuObservable;
+    private onMenuItemChanges;
+    private connectMenuItemEvents;
+    private onMenuItemKeydown;
+    private isLastItem;
+    private geMenuMegaItemsArray;
+    private onPrevMenuItemFocus;
+    private onNextMenuItemFocus;
+    private onMenuItemSelected;
+    private selectMenuItem;
+    private deselectAllMenuItems;
+    private sendMenuItemSelectEvent;
+    private getMegaMenuItemsArray;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EclMenuMegaComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EclMenuMegaComponent, "ecl-menu-mega", never, {}, { "menuItemSelect": "menuItemSelect"; "menuMegaItemParentFocus": "menuMegaItemParentFocus"; "menuMegaLastItemTab": "menuMegaLastItemTab"; }, ["eclMenuMegaItems"], ["*"], true, never>;
+}
+
+/**
+ * This component represents a root menu item. Adds styling and functionality to menu item.
+ */
+declare class EclMenuItemComponent extends ECLBaseDirective implements EclMenuItem, AfterContentInit, OnDestroy {
+    el: ElementRef<any>;
+    id: string;
+    label: string;
+    /**
+     * When in mobile view, use this property to set aria-label for the toggle items button (to expand item's children).
+     */
+    toggleAriaLabel: string;
+    routerLink: string | any[];
+    queryParams: Params | null;
+    queryParamsHandling: QueryParamsHandling;
+    href: string;
+    target: string;
+    isCurrent: boolean;
+    /**
+     * Custom attributes, to be added to the <a> tag of the menu item.
+     */
+    linkExtraAttributes: {
+        [key: string]: string;
+    };
+    isExpanded: boolean;
+    /**
+     * Set to 'true', when item has more than 13 chidren and the overlay needs to use the full available space.
+     */
+    isFull: boolean;
+    isHovered: boolean;
+    isMobileBreakpoint: boolean;
+    /**
+     * Used when menu has overlay, to show if the item is currently displayed.
+     */
+    isVisible: boolean;
+    /**
+     * The default role of the item is 'listitem' and should not be changed.
+     */
+    role: string;
+    get cssClasses(): string;
+    submenu: EclMenuMegaComponent;
+    /**
+     * The <a> element of the menu item, when there are no children.
+     */
+    menuLink: ElementRef<HTMLAnchorElement>;
+    /**
+     * The <button> element of the menu item, when item has children.
+     */
+    menuButton: EclButtonComponent;
+    menuItemSelect: EventEmitter<EclMenuItemSelectEvent>;
+    menuItemCaret: EventEmitter<EclMenuItemCaretEvent>;
+    /**
+     * Event that is emited on clicking the caret button to expand item's children in mobile mode.
+     */
+    menuItemHover: EventEmitter<EclMenuItemHoverEvent>;
+    menuItemHoverOut: EventEmitter<EclMenuItemHoverOutEvent>;
+    menuMegaItemSelect: EventEmitter<EclMenuItemSelectEvent>;
+    menuItemFocus: EventEmitter<EclMenuItemFocusEvent>;
+    menuItemKeydown: EventEmitter<EclMenuItemKeydownEvent>;
+    /**
+     * This event is emited when the keyboard nav reaches the last item in mobile view.
+     * Then the next focused element should be the 'close' btn.
+     */
+    menuMegaLastItemTab: EventEmitter<void>;
+    get hasEclChildrenDataAttribute(): boolean;
+    get isAriaExpanded(): boolean;
+    get ariaCurrent(): boolean;
+    get hasChildren(): boolean;
+    get children(): Array<EclMenuItem>;
+    private destroy$;
+    private renderer;
+    private cdkBreakpointObserver;
+    constructor();
+    onItemMouseEnter(evt: MouseEvent): void;
+    onItemMouseLeave(evt: MouseEvent): void;
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    onItemFocus(evt: FocusEvent): void;
+    onItemClick(evt: Event): void;
+    /**
+     * When clicking the caret button, to expand item's children. Used in mobile view.
+     * @param evt
+     */
+    onItemCaretClick(evt: MouseEvent): void;
+    /**
+     * Manages the state when the item is focused, when navigating with keyboard and the navigation is coming from the submenu.
+     */
+    onFocusFromSubmenu(): void;
+    /**
+     * Manages the state when the item is focused, when navigating with keyboard and the navigation is coming from
+     *  the next root menu item.
+     */
+    onFocusFromNext(): void;
+    /**
+     * Manages the state when the item is focused, when navigating with keyboard and the navigation is coming from
+     *  the previous root menu item.
+     */
+    onFocusFromPrev(): void;
+    /**
+     * Manages the keyboard navigation when the current element is the button of the menu item.
+     * @param evt
+     */
+    onButtonKeydown(evt: Event): void;
+    /**
+     * Manages the keyboard navigation when the current element is the <a> tag of the menu item.
+     * @param evt
+     */
+    onLinkKeydown(evt: Event): void;
+    /**
+     * This method calculates height and width of an item, depending the maximum of lines(rows) allowed.
+     * Depends on the 'maxLines' property of the parent menu component.
+     * @param maxLines - property that sets the maximum possible lines in a menu item.
+     * @param isMobileBreakpoint
+     * @returns
+     */
+    checkMenuItem(maxLines: number, isMobileBreakpoint: boolean): void;
+    private onLinkEscape;
+    private selectFirstMegaMenuItem;
+    private onLinkFocus;
+    private onLinkNextFocus;
+    private onButtonFocus;
+    private getMenuItemLinkMaxHeight;
+    /**
+     * Calculates width of a menu item, depending on maximum lines of text allowed.
+     * @param currentLink
+     * @param maxLines
+     * @param linkStyle
+     * @returns
+     */
+    private changeMenuItemLinkWidth;
+    private getClassDependingChildrenCnt;
+    private hasSubmenuAnySelections;
+    private setExtraAttributesForLink;
+    private observeBreakpointChanges;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EclMenuItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EclMenuItemComponent, "ecl-menu-item", never, { "id": { "alias": "id"; "required": false; }; "label": { "alias": "label"; "required": false; }; "toggleAriaLabel": { "alias": "toggleAriaLabel"; "required": false; }; "routerLink": { "alias": "routerLink"; "required": false; }; "queryParams": { "alias": "queryParams"; "required": false; }; "queryParamsHandling": { "alias": "queryParamsHandling"; "required": false; }; "href": { "alias": "href"; "required": false; }; "target": { "alias": "target"; "required": false; }; "isCurrent": { "alias": "isCurrent"; "required": false; }; "linkExtraAttributes": { "alias": "linkExtraAttributes"; "required": false; }; }, { "menuItemSelect": "menuItemSelect"; "menuItemCaret": "menuItemCaret"; "menuItemHover": "menuItemHover"; "menuItemHoverOut": "menuItemHoverOut"; "menuMegaItemSelect": "menuMegaItemSelect"; "menuItemFocus": "menuItemFocus"; "menuItemKeydown": "menuItemKeydown"; "menuMegaLastItemTab": "menuMegaLastItemTab"; }, ["submenu"], ["ecl-menu-mega", "*"], true, never>;
+}
+
+/**
+ * The horizontal menu is used as a primary navigation and it can display up to 2 levels.
+ * It directs users to the pages where they need to visit.
+ */
+declare class EclMenuComponent extends ECLBaseDirective implements OnInit, AfterContentInit, OnDestroy {
+    /**
+     * Adds some additional styling for the menu items' labels.
+     *  Depending on that value, the labels can drop on 2-3 lines, if they are longer.
+     */
+    maxLines: number;
+    /**
+     * The main items of the menu.
+     */
+    eclRootMenuItems: QueryList<EclMenuItemComponent>;
+    /**
+     * The element, that wraps the main menu items and the back and forth button.
+     */
+    innerSection: ElementRef;
+    /**
+     * The element that wraps the main menu items.
+     */
+    itemsList: ElementRef;
+    /**
+     * When there is an overflow of the menu, the 'previous' button to navigate back to first hidden items.
+     */
+    btnPrevious: EclButtonComponent;
+    /**
+     * When there is an overflow of the menu, the 'next' button to navigate to next hidden items.
+     */
+    btnNext: EclButtonComponent;
+    /**
+     * The button to open/close menu in mobile mode.
+     */
+    openCloseButton: EclButtonComponent;
+    menuItemSelect: EventEmitter<EclMenuItemSelectEvent>;
+    openHamburgerMenu: EventEmitter<any>;
+    get cssClasses(): string;
+    isHamburgerMenuOpened: boolean;
+    /**
+     * The default role is 'navigation', should not be changed.
+     */
+    role: string;
+    isTablet: boolean;
+    isMenuHidden: boolean;
+    isMobileBreakpoint: boolean;
+    hasOverflow: boolean;
+    isShowPrevBtn: boolean;
+    isShowNextBtn: boolean;
+    /**
+     * Show/hide the specific class for the 'previous' and 'next' buttons.
+     */
+    isPrevBtnCurrentClass: boolean;
+    menuListStyleRight: string;
+    menuListStyleLeft: string;
+    overlayStyleTop: number | null;
+    innerStyleTop: number | null;
+    private currentItem;
+    private destroy$;
+    private differ;
+    private diff;
+    private isRtl;
+    private totalItemsWidth;
+    private offsetLeft;
+    private lastVisibleItem;
+    private hammertime;
+    private resizeTimer;
+    private TIMEOUT_INTERVAL;
+    private el;
+    private differs;
+    private cdkBreakpointObserver;
+    private renderer;
+    private eclRtlService;
+    private eclUserDeviceService;
+    private platformId;
+    constructor();
+    /**
+     * On 'esc' key clicked - close/hide any open menus.
+     * @param event
+     */
+    keyEvent(event: KeyboardEvent): void;
+    ngOnInit(): void;
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    /**
+     * Swipe left gesture handling
+     */
+    onSwipeLeft(): void;
+    /**
+     * Swipe right gesture handling
+     */
+    onSwipeRight(): void;
+    /**
+     * Manages state on open/close button click, used in mobile view.
+     */
+    onMenuOpenCloseClick(evt: MouseEvent): void;
+    /**
+     * Manages state on close button click, used in mobile view, in EU theme.
+     */
+    onMenuCloseClick(evt: MouseEvent): void;
+    /**
+     * Manages state on back button click, used in mobile view.
+     */
+    onMenuBackClick(evt: MouseEvent): void;
+    /**
+     * Manages state on 'previous' button click. Used in desktop view. Slides the items and shows the previous hidden items.
+     */
+    onPrevBtnClick(): void;
+    /**
+     * Manages state on 'next' button click. Used in desktop view. Slides the items and shows the next hidden items.
+     */
+    onNextBtnClick(): void;
+    /**
+     * Postions overlay, depending on parent header position.
+     * This method is called from parent header, which uses the menu for navigation.
+     * @param bottomSpaceY
+     */
+    positionMenuOverlay(bottomSpaceY: number): void;
+    private observeElementSizeChanges;
+    private checkIsTabletDevice;
+    private slideMenuInitialState;
+    private showNextSlideLtr;
+    private showNextSlideRtl;
+    private refreshDisplay;
+    private checkMenuOverflow;
+    /**
+     * Manage items visibility when using overlfow. For both rtl and ltr cases.
+     */
+    private manageOverflowBeginning;
+    /**
+     * Manage items visibility when using overlfow, with the 'next' button. For both rtl and ltr cases.
+     */
+    private manageOverflowEnd;
+    private resetVisibilityIndicator;
+    private resetOverflowValues;
+    private setClassForPrevNextButtons;
+    private checkMenuItemsWidth;
+    get isMenuExpandedInMobile(): boolean;
+    private isAnyRootMenuItemExpanded;
+    private createRootMenuItemsChangesObservable;
+    private onMenuItemChanges;
+    private connectMenuItemEvents;
+    private onRootMenuItemFocused;
+    private onRootMenuItemKeydown;
+    private isLastItem;
+    private onRootMenuItemEscape;
+    private onPrevMenuItemFocus;
+    private onNextMenuItemFocus;
+    private findIndexInArray;
+    private isMoveNextOverflow;
+    private isMovePrevOverflow;
+    private onRootMenuItemSelected;
+    private managePrevNextButtonsClassOnItemSelected;
+    private onRootMenuItemHovered;
+    private onRootMenuItemEnter;
+    private openSubmenu;
+    private getRootMenuItemsArray;
+    private checkMegaMenu;
+    private checkEnoughSpaceForMegaMenu;
+    private onRootMenuItemHoveredOut;
+    private onRootMenuItemCaret;
+    private onMenuMegaItemSelected;
+    private deselectAllRootMenuItems;
+    private deselectAllSubmenusItems;
+    private deselectMenuItems;
+    private selectMenuItem;
+    private hideMenu;
+    private showMenu;
+    private closeRootMenu;
+    private closeRootMenuButOneItem;
+    private handleRtlChangeState;
+    private toggleExpandedForMenuItem;
+    private onOpenHamburgerMenu;
+    private onCloseHamburgerMenu;
+    private disableScroll;
+    private enableScroll;
+    private focusOnFirstItem;
+    private sendMenuItemSelectEvent;
+    private observeRootMenuItemsChanges;
+    private observeSwipeGestures;
+    private observeBreakpointChanges;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EclMenuComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EclMenuComponent, "ecl-menu", never, { "maxLines": { "alias": "maxLines"; "required": false; }; }, { "menuItemSelect": "menuItemSelect"; "openHamburgerMenu": "openHamburgerMenu"; }, ["eclRootMenuItems"], ["*"], true, never>;
+    static ngAcceptInputType_maxLines: unknown;
+}
+
+/**
+ * Module that provides the EclMenuComponent and its dependencies.
+ *
+ * @deprecated Use {@link EUI_ECL_MENU} instead.
+ */
+declare class EclMenuModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<EclMenuModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<EclMenuModule, never, [typeof EclMenuComponent, typeof EclMenuItemComponent, typeof EclMenuMegaComponent, typeof EclMenuMegaItemComponent], [typeof EclMenuComponent, typeof EclMenuItemComponent, typeof EclMenuMegaComponent, typeof EclMenuMegaItemComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<EclMenuModule>;
+}
+
+declare const EUI_ECL_MENU: readonly [typeof EclMenuComponent, typeof EclMenuItemComponent, typeof EclMenuMegaComponent, typeof EclMenuMegaItemComponent];
+
+export { EUI_ECL_MENU, EclMenuComponent, EclMenuItemCaretEvent, EclMenuItemComponent, EclMenuItemFocusEvent, EclMenuItemHoverEvent, EclMenuItemHoverOutEvent, EclMenuItemKeydownEvent, EclMenuItemParentFocusEvent, EclMenuItemSelectEvent, EclMenuMegaComponent, EclMenuMegaItemComponent, EclMenuModule };
+export type { EclMenuItem };
+//# sourceMappingURL=index.d.ts.map

package/components/ecl-menu/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../components/ecl-menu/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AACpE,OAAO,EAAE,oBAAoB,EAAE,wBAAwB,EAAE,MAAM,iBAAiB,CAAC;AAEjF,cAAc,mBAAmB,CAAC;AAClC,cAAc,kBAAkB,CAAC;AACjC,cAAc,uBAAuB,CAAC;AACtC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,8BAA8B,CAAC;AAE7C,eAAO,MAAM,YAAY,+HAEf,CAAC"}
+{"version":3,"file":"index.d.ts","sources":["../../../components/ecl-menu/models/ecl-menu-item.model.ts","../../../components/ecl-menu/events/ecl-menu-item.event.ts","../../../components/ecl-menu/ecl-menu-mega/ecl-menu-mega-item.component.ts","../../../components/ecl-menu/ecl-menu-mega/ecl-menu-mega.component.ts","../../../components/ecl-menu/ecl-menu/ecl-menu-item.component.ts","../../../components/ecl-menu/ecl-menu/ecl-menu.component.ts","../../../components/ecl-menu/ecl-menu.module.ts","../../../components/ecl-menu/index.ts"],"sourcesContent":[null,null,null,null,null,null,null,null],"names":[],"mappings":";;;;;;;;;;;;;;;;AAQI;AACH;;ACND;AAEe;AACA;AADA;AAKd;AAED;AAEe;AACA;AADA;AAKd;AAED;AAEe;AACA;AADA;AAKd;AAED;AAEe;AACA;AADA;AAKd;AAED;AAEe;AACA;AADA;AAKd;AAED;AAEe;AACA;AADA;AAKd;AAED;AAEe;AAAA;AACd;;AClDD;;;AAGG;AACH;;;AAiBa;AACA;;AAEA;AACA;AAC+B;AACxC;;AAEG;AACuB;AAC+D;AACzF;;AAEG;AAC6E;AACvE;AAAuB;;AAEhC;;AAEG;AACkD;AACrD;;AAEG;AACkD;AACrD;;AAEG;;AAGO;AACA;AAEV;AACA;AAEA;;AAGA;AAKA;;;AAGG;AACH;AASA;AAIA;;AAEG;AACH;AAIA;;AAEG;AACH;AAIA;AAOA;;AAEG;AACH;AAkBA;;;;;AASH;;ACtID;;;AAGG;AACH;AAKG;AAG2C;AAE1C;;AAEG;AACwC;AAEjC;AACV;;AAEG;AACO;AACV;;AAEG;AACO;AAEoB;AACC;;;;;;;AAiB/B;AAMA;AAKA;AAMA;AAIA;AAcA;AASA;AA8BA;AAIA;AAIA;AASA;AAOA;AAMA;AAIA;AAMA;AAIA;;;AAGH;;ACpJD;;AAEG;AACH;AAOI;;;AAIA;;AAEG;;AAGM;AACA;;AAEA;AACA;AACA;AACT;;AAEG;AACM;AAAuB;;;AAGhC;;AAEG;AACH;AACA;AACA;AACA;;AAEG;AACH;AAEA;;AAEG;AACuB;;;AAc1B;;AAEG;AACoB;AACvB;;AAEG;;AAGO;AACA;AACV;;AAEG;AACO;AACA;AACA;AACA;AACA;AACV;;;AAGG;AACO;;;;;AAqBV;;;;;AAiBA;AAKA;AAIA;AAyBA;AAKA;AAIA;AAQA;;;AAGG;AACH;AAIA;;AAEG;AACH;AAMA;;;AAGG;AACH;AAQA;;;AAGG;AACH;AAIA;;;AAGG;AACH;AA8CA;;;AAGG;AACH;AAsCA;;;;;;AAMG;;AAqBH;AASA;AAIA;AAIA;AAQA;AAIA;AAIA;;;;;;AAMG;AACH;AAuBA;AAgBA;AAIA;AAUA;;;AAQH;;ACzbD;;;AAGG;AACH;AAcI;;;AAGG;AACoC;AAEvC;;AAEG;AACoC;AACvC;;AAEG;;AAEH;;AAEG;;AAEH;;AAEG;;AAEH;;AAEG;;AAEH;;AAEG;;AAGO;AACA;;AAWyB;AACnC;;AAEG;AACuB;AACoB;AACD;AAE7C;AACA;AACA;AACA;AACA;;AAEG;AACH;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;;;;;AAmCA;;;AAGG;AAEH;AAQA;AAQA;AAKA;AAQA;;AAEG;AACH;AAMA;;AAEG;AACH;AAMA;;AAEG;AACH;AASA;;AAEG;AACH;AAMA;;AAEG;AACH;AAKA;;AAEG;AACH;AAKA;;AAEG;AACH;AAaA;;;;AAIG;AACH;AAUA;AAaA;AAKA;AAcA;AAWA;AAWA;AAOA;AAiBA;;AAEG;AACH;AAmBA;;AAEG;AACH;AAqBA;AAIA;AAUA;AAWA;;AAWA;AAIA;AAIA;AAcA;AA2BA;AAYA;AAuCA;AAIA;AAOA;AAOA;AAOA;AAIA;AAIA;AAIA;AAcA;AAQA;AAIA;AAaA;AAWA;AAIA;AAYA;AAgBA;AAMA;AAOA;AAiBA;AAIA;AAMA;AAMA;AAKA;AAIA;AAIA;AAOA;AASA;AAYA;AAIA;AAOA;AAKA;AAIA;AAIA;AAIA;AAIA;AAKA;AAaA;;;;AAYH;;ACrwBD;;;;AAIG;AACH;;;;AAI6B;;ACN7B;;;"}