@fundamental-ngx/cdk 0.43.2 → 0.44.0-rc.1

package/esm2022/utils/directives/focusable-list/focusable-list.directive.mjs

@@ -0,0 +1,330 @@
+import { DOCUMENT } from '@angular/common';
+import { ContentChildren, Directive, ElementRef, EventEmitter, HostBinding, HostListener, inject, Input, Output, QueryList, Renderer2 } from '@angular/core';
+import { finalize, map, startWith, takeUntil, tap } from 'rxjs/operators';
+import { DestroyedService } from '../../services/destroyed.service';
+import { DeprecatedSelector, FD_DEPRECATED_DIRECTIVE_SELECTOR, getDeprecatedModel } from '../../deprecated-selector.class';
+import { FDK_FOCUSABLE_ITEM_DIRECTIVE, FocusableObserver } from '../focusable-item';
+import { FDK_FOCUSABLE_LIST_DIRECTIVE } from './focusable-list.tokens';
+import { merge, Subject } from 'rxjs';
+import { FocusKeyManager, LiveAnnouncer } from '@angular/cdk/a11y';
+import { getNativeElement } from '../../helpers';
+import { coerceBooleanProperty } from '@angular/cdk/coercion';
+import { intersectionObservable, KeyUtil } from '../../functions';
+import { ENTER, ESCAPE, F2, MAC_ENTER } from '@angular/cdk/keycodes';
+import { scrollIntoView } from './scroll';
+import * as i0 from "@angular/core";
+export class DeprecatedFocusableListDirective extends DeprecatedSelector {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.0", ngImport: i0, type: DeprecatedFocusableListDirective, deps: null, target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.1.0", type: DeprecatedFocusableListDirective, isStandalone: true, selector: "[fnFocusableList]", providers: [
+            {
+                provide: FD_DEPRECATED_DIRECTIVE_SELECTOR,
+                useValue: getDeprecatedModel('[fdkFocusableList]', '[fnFocusableList]')
+            }
+        ], usesInheritance: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.0", ngImport: i0, type: DeprecatedFocusableListDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    // eslint-disable-next-line @angular-eslint/directive-selector
+                    selector: '[fnFocusableList]',
+                    standalone: true,
+                    providers: [
+                        {
+                            provide: FD_DEPRECATED_DIRECTIVE_SELECTOR,
+                            useValue: getDeprecatedModel('[fdkFocusableList]', '[fnFocusableList]')
+                        }
+                    ]
+                }]
+        }] });
+export class FocusableListDirective {
+    /** Whether the whole list should be focusable, handy in grids. */
+    set focusable(value) {
+        this._focusable = coerceBooleanProperty(value);
+        this.setTabbable(this._focusable);
+    }
+    get focusable() {
+        return this._focusable;
+    }
+    /** @hidden */
+    get _focusableItems() {
+        return this._items ? this._items : this._projectedFocusableItems;
+    }
+    /** @hidden */
+    get _tabindex() {
+        return this._tabbable ? 0 : -1;
+    }
+    /** @hidden */
+    constructor() {
+        /** @hidden */
+        this._focusable = false;
+        /** Direction of navigation. Should be set to 'grid' when list is a part of grid. */
+        this.navigationDirection = 'vertical';
+        /** Direction of the content. */
+        this.contentDirection = 'ltr';
+        /**
+         * Configures wrapping mode which determines whether the active item will wrap to the other end of list when there are no more items in the given direction.
+         */
+        this.wrap = false;
+        /** Function, which returns a string to be announced by screen-reader whenever an row which is in grid receives focus. */
+        this.listFocusedEventAnnouncer = this._defaultListFocusedEventAnnouncer;
+        /** Event emitted when list's item focused, contains item's position info. */
+        this.itemFocused = new EventEmitter();
+        /** @hidden */
+        this._gridItemFocused$ = new Subject();
+        /** @hidden */
+        this._gridListFocused$ = new Subject();
+        /** @hidden */
+        this._keydown$ = new Subject();
+        /** @hidden */
+        this._tabbable = false;
+        /** @hidden */
+        this._refreshItems$ = new Subject();
+        /** @hidden */
+        this._refresh$ = new Subject();
+        /** @hidden */
+        this._renderer = inject(Renderer2);
+        /** @hidden */
+        this._destroy$ = inject(DestroyedService);
+        /** @hidden */
+        this._elementRef = inject(ElementRef);
+        /** @hidden */
+        this._liveAnnouncer = inject(LiveAnnouncer);
+        /** @hidden */
+        this._focusableObserver = inject(FocusableObserver);
+        /** @hidden */
+        this._document = inject(DOCUMENT);
+        /** @hidden */
+        this._isVisible = false;
+        intersectionObservable(this._elementRef.nativeElement, { threshold: 0.25 })
+            .pipe(takeUntil(this._destroy$))
+            .subscribe((isVisible) => (this._isVisible = isVisible[0]?.isIntersecting));
+        this._focusableObserver
+            .observe(this._elementRef, false)
+            .pipe(takeUntil(this._destroy$))
+            .subscribe((isFocusable) => {
+            if (!isFocusable && isFocusable !== this.focusable) {
+                this.focusable = isFocusable;
+            }
+        });
+    }
+    /** @hidden */
+    ngOnChanges(changes) {
+        if (!this._keyManager) {
+            return;
+        }
+        if (changes['wrap']) {
+            this._keyManager = this._keyManager.withWrap(changes['wrap'].currentValue);
+        }
+        if (changes['navigationDirection']) {
+            this._updateNavigationDirection();
+        }
+    }
+    /** @hidden */
+    ngAfterViewInit() {
+        this._listenOnItems();
+    }
+    /** Set items programmatically. */
+    setItems(items) {
+        this._items = items;
+        this._listenOnItems();
+    }
+    /** @hidden */
+    _listenOnItems() {
+        const refresh$ = merge(this._refresh$, this._destroy$);
+        this._refresh$.next();
+        this._focusableItems.changes
+            .pipe(startWith(null), map(() => this._focusableItems.toArray()), tap((items) => {
+            const focusableItems = items.map((item, index) => ({
+                index,
+                focusable: () => item.fdkFocusableItem,
+                elementRef: item.elementRef,
+                focus: () => item.elementRef.nativeElement.focus(),
+                keydown: item._keydown$
+            }));
+            const direction = this.navigationDirection === 'grid' ? 'horizontal' : this.navigationDirection;
+            this._initializeFocusManager(focusableItems, this, {
+                direction,
+                contentDirection: this.contentDirection,
+                wrap: this.wrap
+            });
+        }), takeUntil(refresh$))
+            .subscribe();
+    }
+    /** @hidden */
+    ngOnDestroy() {
+        this._keyManager?.destroy();
+    }
+    /** @hidden */
+    _onKeydown(event) {
+        // Already handled
+        if (event.defaultPrevented) {
+            return;
+        }
+        const isFocused = this._document.activeElement === this._elementRef.nativeElement;
+        const shouldFocusChild = KeyUtil.isKeyCode(event, [ENTER, MAC_ENTER, F2]) && !event.shiftKey && isFocused;
+        const shouldFocusList = ((KeyUtil.isKeyCode(event, F2) && event.shiftKey) || KeyUtil.isKeyCode(event, ESCAPE)) && !isFocused;
+        if (shouldFocusChild) {
+            event.stopPropagation();
+            this.setActiveItem(0);
+            return;
+        }
+        else if (shouldFocusList) {
+            event.stopPropagation();
+            this.focus();
+            return;
+        }
+        this._keydown$.next({ list: this, event, activeItemIndex: this._keyManager?.activeItemIndex ?? null });
+    }
+    /** Set active item in list */
+    setActiveItem(index, scrollPosition) {
+        let availableIndex;
+        this._focusableItems.find((item, itemIndex) => {
+            if (itemIndex >= index && item.fdkFocusableItem) {
+                availableIndex = itemIndex;
+                return true;
+            }
+            return false;
+        });
+        if (availableIndex != null) {
+            scrollIntoView(this._focusableItems.get(availableIndex)?.elementRef.nativeElement, scrollPosition);
+            this._keyManager?.setActiveItem(availableIndex);
+        }
+    }
+    /** Focus whole list */
+    focus(scrollPosition) {
+        if (this.focusable) {
+            scrollIntoView(this._elementRef.nativeElement, scrollPosition);
+            this._elementRef.nativeElement.focus();
+        }
+    }
+    /** Set tabbable state */
+    setTabbable(state) {
+        this._tabbable = state;
+    }
+    /** @hidden */
+    async _onFocus() {
+        if (this._gridPosition) {
+            this._gridListFocused$.next(this._gridPosition);
+            this._liveAnnouncer.clear();
+            await this._liveAnnouncer.announce(this.listFocusedEventAnnouncer(this._gridPosition));
+            this.setTabbable(true);
+        }
+    }
+    /** @hidden */
+    _updateNavigationDirection() {
+        if (!this._keyManager) {
+            return;
+        }
+        if (this.navigationDirection === 'vertical') {
+            this._keyManager = this._keyManager.withVerticalOrientation(true);
+            this._keyManager = this._keyManager.withHorizontalOrientation(null);
+        }
+        else {
+            this._keyManager = this._keyManager.withVerticalOrientation(false);
+            this._keyManager = this._keyManager.withHorizontalOrientation(this.contentDirection || 'ltr');
+        }
+    }
+    /** @hidden */
+    _setItemsTabbable(state) {
+        this._focusableItems.forEach((item) => item.setTabbable(state));
+    }
+    /** @hidden */
+    _setGridPosition(position) {
+        this._gridPosition = position;
+        this._focusableItems.changes
+            .pipe(startWith(this._focusableItems), takeUntil(this._destroy$))
+            .subscribe((items) => items.forEach((item, index) => (item._position = {
+            ...this._gridPosition,
+            colIndex: index,
+            totalCols: this._focusableItems.length
+        })));
+    }
+    /** @hidden */
+    _initializeFocusManager(items, list, config = {}) {
+        this._refreshItems$.next();
+        let keyManager = new FocusKeyManager(items).withHomeAndEnd();
+        if (config.wrap !== false) {
+            keyManager = keyManager.withWrap();
+        }
+        if (config.direction === 'horizontal') {
+            keyManager = keyManager.withHorizontalOrientation(config.contentDirection || 'ltr'); // should be replaced
+            // Vertical is enabled by default, so let's disable it here in consistency purposes
+            keyManager = keyManager.withVerticalOrientation(false);
+        }
+        keyManager.skipPredicate((item) => !(typeof item.focusable === 'boolean' ? item.focusable : item.focusable()));
+        this._keyManager = keyManager;
+        const focusListenerDestroyers = items.map((item, index) => this._renderer.listen(getNativeElement(item), 'focus', () => {
+            const directiveItem = this._focusableItems.get(index);
+            if (!directiveItem) {
+                return;
+            }
+            if (this._gridPosition) {
+                this._gridItemFocused$.next(directiveItem._position);
+            }
+            this.itemFocused.next({ index: item.index, total: items.length });
+            this._focusableItems.forEach((i) => i.setTabbable(i === directiveItem));
+            this._keyManager?.setActiveItem(item.index);
+        }));
+        merge(...items.map((item) => item.keydown))
+            .pipe(tap((event) => {
+            // Already handled
+            if (event.defaultPrevented) {
+                return;
+            }
+            this._keyManager?.onKeydown(event);
+        }), takeUntil(merge(this._refreshItems$, this._destroy$)), finalize(() => focusListenerDestroyers.forEach((d) => d())))
+            .subscribe();
+    }
+    /** @hidden */
+    _defaultListFocusedEventAnnouncer(position) {
+        return `Row: ${position.rowIndex + 1} of ${position.totalRows}, use F2 button to dive in and focus list's item`;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.0", ngImport: i0, type: FocusableListDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.1.0", type: FocusableListDirective, isStandalone: true, selector: "[fdkFocusableList]", inputs: { focusable: "focusable", navigationDirection: "navigationDirection", contentDirection: "contentDirection", wrap: "wrap", listFocusedEventAnnouncer: "listFocusedEventAnnouncer" }, outputs: { itemFocused: "itemFocused" }, host: { listeners: { "keydown": "_onKeydown($event)", "focus": "_onFocus()" }, properties: { "attr.tabindex": "this._tabindex" } }, providers: [
+            {
+                provide: FDK_FOCUSABLE_LIST_DIRECTIVE,
+                useExisting: FocusableListDirective
+            },
+            DestroyedService
+        ], queries: [{ propertyName: "_projectedFocusableItems", predicate: FDK_FOCUSABLE_ITEM_DIRECTIVE, descendants: true }], exportAs: ["fdkFocusableList"], usesOnChanges: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.0", ngImport: i0, type: FocusableListDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[fdkFocusableList]',
+                    exportAs: 'fdkFocusableList',
+                    standalone: true,
+                    providers: [
+                        {
+                            provide: FDK_FOCUSABLE_LIST_DIRECTIVE,
+                            useExisting: FocusableListDirective
+                        },
+                        DestroyedService
+                    ]
+                }]
+        }], ctorParameters: function () { return []; }, propDecorators: { focusable: [{
+                type: Input
+            }], navigationDirection: [{
+                type: Input
+            }], contentDirection: [{
+                type: Input
+            }], wrap: [{
+                type: Input
+            }], listFocusedEventAnnouncer: [{
+                type: Input
+            }], itemFocused: [{
+                type: Output
+            }], _projectedFocusableItems: [{
+                type: ContentChildren,
+                args: [FDK_FOCUSABLE_ITEM_DIRECTIVE, { descendants: true }]
+            }], _tabindex: [{
+                type: HostBinding,
+                args: ['attr.tabindex']
+            }], _onKeydown: [{
+                type: HostListener,
+                args: ['keydown', ['$event']]
+            }], _onFocus: [{
+                type: HostListener,
+                args: ['focus']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"focusable-list.directive.js","sourceRoot":"","sources":["../../../../../../../libs/cdk/src/lib/utils/directives/focusable-list/focusable-list.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { DOCUMENT } from '@angular/common';\nimport {\n    AfterViewInit,\n    ContentChildren,\n    Directive,\n    ElementRef,\n    EventEmitter,\n    HostBinding,\n    HostListener,\n    inject,\n    Input,\n    OnChanges,\n    OnDestroy,\n    Output,\n    QueryList,\n    Renderer2,\n    SimpleChanges\n} from '@angular/core';\nimport { finalize, map, startWith, takeUntil, tap } from 'rxjs/operators';\nimport { FocusableItemDirective, FocusableItemPosition } from '../focusable-item/focusable-item.directive';\nimport { DestroyedService } from '../../services/destroyed.service';\nimport {\n    DeprecatedSelector,\n    FD_DEPRECATED_DIRECTIVE_SELECTOR,\n    getDeprecatedModel\n} from '../../deprecated-selector.class';\nimport { FDK_FOCUSABLE_ITEM_DIRECTIVE, FocusableObserver } from '../focusable-item';\nimport { FDK_FOCUSABLE_LIST_DIRECTIVE } from './focusable-list.tokens';\nimport { merge, Subject } from 'rxjs';\nimport { Nullable } from '../../models/nullable';\nimport { FocusableOption, FocusKeyManager, LiveAnnouncer } from '@angular/cdk/a11y';\nimport { getNativeElement } from '../../helpers';\nimport { HasElementRef } from '../../interfaces';\nimport { BooleanInput, coerceBooleanProperty } from '@angular/cdk/coercion';\nimport { intersectionObservable, KeyUtil } from '../../functions';\nimport { ENTER, ESCAPE, F2, MAC_ENTER } from '@angular/cdk/keycodes';\nimport { scrollIntoView, ScrollPosition } from './scroll';\n\nexport interface FocusableListPosition {\n    rowIndex: number;\n    totalRows: number;\n}\n\nexport interface FocusableListItemFocusedEvent {\n    index: number;\n    total: number;\n}\n\nexport interface FocusableListKeydownEvent {\n    list: FocusableListDirective;\n    event: KeyboardEvent;\n    activeItemIndex: Nullable<number>;\n}\n\ninterface FocusableListConfig {\n    wrap?: boolean;\n    direction?: 'vertical' | 'horizontal';\n    contentDirection?: 'ltr' | 'rtl' | null;\n}\n\nexport type FocusableItem = FocusableOption &\n    HasElementRef & { index: number; focusable: (() => boolean) | boolean; keydown: Subject<KeyboardEvent> };\n\n@Directive({\n    // eslint-disable-next-line @angular-eslint/directive-selector\n    selector: '[fnFocusableList]',\n    standalone: true,\n    providers: [\n        {\n            provide: FD_DEPRECATED_DIRECTIVE_SELECTOR,\n            useValue: getDeprecatedModel('[fdkFocusableList]', '[fnFocusableList]')\n        }\n    ]\n})\nexport class DeprecatedFocusableListDirective extends DeprecatedSelector {}\n\n@Directive({\n    selector: '[fdkFocusableList]',\n    exportAs: 'fdkFocusableList',\n    standalone: true,\n    providers: [\n        {\n            provide: FDK_FOCUSABLE_LIST_DIRECTIVE,\n            useExisting: FocusableListDirective\n        },\n        DestroyedService\n    ]\n})\nexport class FocusableListDirective implements OnChanges, AfterViewInit, OnDestroy {\n    /** Whether the whole list should be focusable, handy in grids. */\n    @Input()\n    set focusable(value: BooleanInput) {\n        this._focusable = coerceBooleanProperty(value);\n\n        this.setTabbable(this._focusable);\n    }\n    get focusable(): boolean {\n        return this._focusable;\n    }\n\n    /** @hidden */\n    protected _focusable = false;\n\n    /** Direction of navigation. Should be set to 'grid' when list is a part of grid. */\n    @Input()\n    navigationDirection: 'horizontal' | 'vertical' | 'grid' = 'vertical';\n\n    /** Direction of the content. */\n    @Input()\n    contentDirection: 'ltr' | 'rtl' | null = 'ltr';\n\n    /**\n     * Configures wrapping mode which determines whether the active item will wrap to the other end of list when there are no more items in the given direction.\n     */\n    @Input()\n    wrap = false;\n\n    /** Function, which returns a string to be announced by screen-reader whenever an row which is in grid receives focus. */\n    @Input()\n    listFocusedEventAnnouncer: (position: FocusableListPosition) => string = this._defaultListFocusedEventAnnouncer;\n\n    /** Event emitted when list's item focused, contains item's position info. */\n    @Output()\n    readonly itemFocused = new EventEmitter<FocusableListItemFocusedEvent>();\n\n    /** @hidden */\n    @ContentChildren(FDK_FOCUSABLE_ITEM_DIRECTIVE, { descendants: true })\n    public readonly _projectedFocusableItems: QueryList<FocusableItemDirective>;\n\n    /** @hidden */\n    get _focusableItems(): QueryList<FocusableItemDirective> {\n        return this._items ? this._items : this._projectedFocusableItems;\n    }\n\n    /** @hidden */\n    _items: QueryList<FocusableItemDirective> | undefined;\n\n    /** @hidden */\n    public readonly _gridItemFocused$ = new Subject<FocusableItemPosition>();\n\n    /** @hidden */\n    public readonly _gridListFocused$ = new Subject<FocusableListPosition>();\n\n    /** @hidden */\n    public readonly _keydown$ = new Subject<FocusableListKeydownEvent>();\n\n    /** @hidden */\n    private _gridPosition: { rowIndex: number; totalRows: number };\n\n    /** @hidden */\n    private _keyManager?: FocusKeyManager<FocusableItem>;\n\n    /** @hidden */\n    private _tabbable = false;\n\n    /** @hidden */\n    private readonly _refreshItems$ = new Subject<void>();\n\n    /** @hidden */\n    private readonly _refresh$ = new Subject<void>();\n\n    /** @hidden */\n    private readonly _renderer = inject(Renderer2);\n    /** @hidden */\n    protected readonly _destroy$ = inject(DestroyedService);\n    /** @hidden */\n    private readonly _elementRef: ElementRef<HTMLElement> = inject(ElementRef);\n    /** @hidden */\n    private readonly _liveAnnouncer = inject(LiveAnnouncer);\n    /** @hidden */\n    private readonly _focusableObserver = inject(FocusableObserver);\n    /** @hidden */\n    private readonly _document = inject(DOCUMENT);\n\n    /** @hidden */\n    @HostBinding('attr.tabindex')\n    get _tabindex(): number {\n        return this._tabbable ? 0 : -1;\n    }\n\n    /** @hidden */\n    _isVisible = false;\n\n    /** @hidden */\n    constructor() {\n        intersectionObservable(this._elementRef.nativeElement, { threshold: 0.25 })\n            .pipe(takeUntil(this._destroy$))\n            .subscribe((isVisible) => (this._isVisible = isVisible[0]?.isIntersecting));\n\n        this._focusableObserver\n            .observe(this._elementRef, false)\n            .pipe(takeUntil(this._destroy$))\n            .subscribe((isFocusable) => {\n                if (!isFocusable && isFocusable !== this.focusable) {\n                    this.focusable = isFocusable;\n                }\n            });\n    }\n\n    /** @hidden */\n    ngOnChanges(changes: SimpleChanges): void {\n        if (!this._keyManager) {\n            return;\n        }\n\n        if (changes['wrap']) {\n            this._keyManager = this._keyManager.withWrap(changes['wrap'].currentValue);\n        }\n\n        if (changes['navigationDirection']) {\n            this._updateNavigationDirection();\n        }\n    }\n\n    /** @hidden */\n    ngAfterViewInit(): void {\n        this._listenOnItems();\n    }\n\n    /** Set items programmatically. */\n    setItems(items: QueryList<FocusableItemDirective>): void {\n        this._items = items;\n        this._listenOnItems();\n    }\n\n    /** @hidden */\n    private _listenOnItems(): void {\n        const refresh$ = merge(this._refresh$, this._destroy$);\n        this._refresh$.next();\n        this._focusableItems.changes\n            .pipe(\n                startWith(null),\n                map(() => this._focusableItems.toArray()),\n                tap((items: FocusableItemDirective[]): void => {\n                    const focusableItems: FocusableItem[] = items.map((item, index) => ({\n                        index,\n                        focusable: () => item.fdkFocusableItem,\n                        elementRef: item.elementRef,\n                        focus: () => item.elementRef.nativeElement.focus(),\n                        keydown: item._keydown$\n                    }));\n\n                    const direction = this.navigationDirection === 'grid' ? 'horizontal' : this.navigationDirection;\n\n                    this._initializeFocusManager(focusableItems, this, {\n                        direction,\n                        contentDirection: this.contentDirection,\n                        wrap: this.wrap\n                    });\n                }),\n                takeUntil(refresh$)\n            )\n            .subscribe();\n    }\n\n    /** @hidden */\n    ngOnDestroy(): void {\n        this._keyManager?.destroy();\n    }\n\n    /** @hidden */\n    @HostListener('keydown', ['$event'])\n    _onKeydown(event: KeyboardEvent): void {\n        // Already handled\n        if (event.defaultPrevented) {\n            return;\n        }\n\n        const isFocused = this._document.activeElement === this._elementRef.nativeElement;\n        const shouldFocusChild = KeyUtil.isKeyCode(event, [ENTER, MAC_ENTER, F2]) && !event.shiftKey && isFocused;\n        const shouldFocusList =\n            ((KeyUtil.isKeyCode(event, F2) && event.shiftKey) || KeyUtil.isKeyCode(event, ESCAPE)) && !isFocused;\n\n        if (shouldFocusChild) {\n            event.stopPropagation();\n\n            this.setActiveItem(0);\n\n            return;\n        } else if (shouldFocusList) {\n            event.stopPropagation();\n\n            this.focus();\n\n            return;\n        }\n\n        this._keydown$.next({ list: this, event, activeItemIndex: this._keyManager?.activeItemIndex ?? null });\n    }\n\n    /** Set active item in list */\n    setActiveItem(index: number, scrollPosition?: ScrollPosition): void {\n        let availableIndex;\n\n        this._focusableItems.find((item, itemIndex) => {\n            if (itemIndex >= index && item.fdkFocusableItem) {\n                availableIndex = itemIndex;\n                return true;\n            }\n\n            return false;\n        });\n\n        if (availableIndex != null) {\n            scrollIntoView(this._focusableItems.get(availableIndex)?.elementRef.nativeElement, scrollPosition);\n            this._keyManager?.setActiveItem(availableIndex);\n        }\n    }\n\n    /** Focus whole list */\n    focus(scrollPosition?: ScrollPosition): void {\n        if (this.focusable) {\n            scrollIntoView(this._elementRef.nativeElement, scrollPosition);\n            this._elementRef.nativeElement.focus();\n        }\n    }\n\n    /** Set tabbable state */\n    setTabbable(state: boolean): void {\n        this._tabbable = state;\n    }\n\n    /** @hidden */\n    @HostListener('focus')\n    async _onFocus(): Promise<void> {\n        if (this._gridPosition) {\n            this._gridListFocused$.next(this._gridPosition);\n\n            this._liveAnnouncer.clear();\n            await this._liveAnnouncer.announce(this.listFocusedEventAnnouncer(this._gridPosition));\n\n            this.setTabbable(true);\n        }\n    }\n\n    /** @hidden */\n    _updateNavigationDirection(): void {\n        if (!this._keyManager) {\n            return;\n        }\n\n        if (this.navigationDirection === 'vertical') {\n            this._keyManager = this._keyManager.withVerticalOrientation(true);\n            this._keyManager = this._keyManager.withHorizontalOrientation(null);\n        } else {\n            this._keyManager = this._keyManager.withVerticalOrientation(false);\n            this._keyManager = this._keyManager.withHorizontalOrientation(this.contentDirection || 'ltr');\n        }\n    }\n\n    /** @hidden */\n    _setItemsTabbable(state: boolean): void {\n        this._focusableItems.forEach((item) => item.setTabbable(state));\n    }\n\n    /** @hidden */\n    _setGridPosition(position: FocusableListPosition): void {\n        this._gridPosition = position;\n\n        this._focusableItems.changes\n            .pipe(startWith(this._focusableItems), takeUntil(this._destroy$))\n            .subscribe((items) =>\n                items.forEach(\n                    (item, index) =>\n                        (item._position = {\n                            ...this._gridPosition,\n                            colIndex: index,\n                            totalCols: this._focusableItems.length\n                        })\n                )\n            );\n    }\n\n    /** @hidden */\n    private _initializeFocusManager(\n        items: FocusableItem[],\n        list: FocusableListDirective,\n        config: FocusableListConfig = {}\n    ): void {\n        this._refreshItems$.next();\n\n        let keyManager = new FocusKeyManager<any>(items).withHomeAndEnd();\n\n        if (config.wrap !== false) {\n            keyManager = keyManager.withWrap();\n        }\n\n        if (config.direction === 'horizontal') {\n            keyManager = keyManager.withHorizontalOrientation(config.contentDirection || 'ltr'); // should be replaced\n\n            // Vertical is enabled by default, so let's disable it here in consistency purposes\n            keyManager = keyManager.withVerticalOrientation(false);\n        }\n\n        keyManager.skipPredicate((item) => !(typeof item.focusable === 'boolean' ? item.focusable : item.focusable()));\n\n        this._keyManager = keyManager;\n\n        const focusListenerDestroyers = items.map((item, index) =>\n            this._renderer.listen(getNativeElement(item), 'focus', () => {\n                const directiveItem = this._focusableItems.get(index);\n                if (!directiveItem) {\n                    return;\n                }\n\n                if (this._gridPosition) {\n                    this._gridItemFocused$.next(directiveItem._position);\n                }\n\n                this.itemFocused.next({ index: item.index, total: items.length });\n                this._focusableItems.forEach((i) => i.setTabbable(i === directiveItem));\n                this._keyManager?.setActiveItem(item.index);\n            })\n        );\n\n        merge(...items.map((item) => item.keydown))\n            .pipe(\n                tap((event: KeyboardEvent) => {\n                    // Already handled\n                    if (event.defaultPrevented) {\n                        return;\n                    }\n\n                    this._keyManager?.onKeydown(event);\n                }),\n                takeUntil(merge(this._refreshItems$, this._destroy$)),\n                finalize(() => focusListenerDestroyers.forEach((d) => d()))\n            )\n            .subscribe();\n    }\n\n    /** @hidden */\n    private _defaultListFocusedEventAnnouncer(position: FocusableListPosition): string {\n        return `Row: ${position.rowIndex + 1} of ${position.totalRows}, use F2 button to dive in and focus list's item`;\n    }\n}\n"]}

package/{esm2020 → esm2022}/utils/directives/focusable-list/focusable-list.module.mjs

@@ -3,15 +3,15 @@ import { FocusableListDirective, DeprecatedFocusableListDirective } from './focu
 import { FocusableItemModule } from '../focusable-item';
 import * as i0 from "@angular/core";
 export class FocusableListModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.0", ngImport: i0, type: FocusableListModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.1.0", ngImport: i0, type: FocusableListModule, imports: [FocusableItemModule, FocusableListDirective, DeprecatedFocusableListDirective], exports: [FocusableListDirective, FocusableItemModule, DeprecatedFocusableListDirective] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.1.0", ngImport: i0, type: FocusableListModule, imports: [FocusableItemModule, FocusableItemModule] }); }
 }
-FocusableListModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: FocusableListModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-FocusableListModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.9", ngImport: i0, type: FocusableListModule, imports: [FocusableItemModule, FocusableListDirective, DeprecatedFocusableListDirective], exports: [FocusableListDirective, FocusableItemModule, DeprecatedFocusableListDirective] });
-FocusableListModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: FocusableListModule, imports: [FocusableItemModule, FocusableItemModule] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: FocusableListModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.0", ngImport: i0, type: FocusableListModule, decorators: [{
             type: NgModule,
             args: [{
                     imports: [FocusableItemModule, FocusableListDirective, DeprecatedFocusableListDirective],
                     exports: [FocusableListDirective, FocusableItemModule, DeprecatedFocusableListDirective]
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZm9jdXNhYmxlLWxpc3QubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9jZGsvc3JjL2xpYi91dGlscy9kaXJlY3RpdmVzL2ZvY3VzYWJsZS1saXN0L2ZvY3VzYWJsZS1saXN0Lm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQ3pDLE9BQU8sRUFBRSxzQkFBc0IsRUFBRSxnQ0FBZ0MsRUFBRSxNQUFNLDRCQUE0QixDQUFDO0FBQ3RHLE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxNQUFNLG1CQUFtQixDQUFDOztBQU14RCxNQUFNLE9BQU8sbUJBQW1COztnSEFBbkIsbUJBQW1CO2lIQUFuQixtQkFBbUIsWUFIbEIsbUJBQW1CLEVBQUUsc0JBQXNCLEVBQUUsZ0NBQWdDLGFBQzdFLHNCQUFzQixFQUFFLG1CQUFtQixFQUFFLGdDQUFnQztpSEFFOUUsbUJBQW1CLFlBSGxCLG1CQUFtQixFQUNLLG1CQUFtQjsyRkFFNUMsbUJBQW1CO2tCQUovQixRQUFRO21CQUFDO29CQUNOLE9BQU8sRUFBRSxDQUFDLG1CQUFtQixFQUFFLHNCQUFzQixFQUFFLGdDQUFnQyxDQUFDO29CQUN4RixPQUFPLEVBQUUsQ0FBQyxzQkFBc0IsRUFBRSxtQkFBbUIsRUFBRSxnQ0FBZ0MsQ0FBQztpQkFDM0YiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBOZ01vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgRm9jdXNhYmxlTGlzdERpcmVjdGl2ZSwgRGVwcmVjYXRlZEZvY3VzYWJsZUxpc3REaXJlY3RpdmUgfSBmcm9tICcuL2ZvY3VzYWJsZS1saXN0LmRpcmVjdGl2ZSc7XG5pbXBvcnQgeyBGb2N1c2FibGVJdGVtTW9kdWxlIH0gZnJvbSAnLi4vZm9jdXNhYmxlLWl0ZW0nO1xuXG5ATmdNb2R1bGUoe1xuICAgIGltcG9ydHM6IFtGb2N1c2FibGVJdGVtTW9kdWxlLCBGb2N1c2FibGVMaXN0RGlyZWN0aXZlLCBEZXByZWNhdGVkRm9jdXNhYmxlTGlzdERpcmVjdGl2ZV0sXG4gICAgZXhwb3J0czogW0ZvY3VzYWJsZUxpc3REaXJlY3RpdmUsIEZvY3VzYWJsZUl0ZW1Nb2R1bGUsIERlcHJlY2F0ZWRGb2N1c2FibGVMaXN0RGlyZWN0aXZlXVxufSlcbmV4cG9ydCBjbGFzcyBGb2N1c2FibGVMaXN0TW9kdWxlIHt9XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZm9jdXNhYmxlLWxpc3QubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9jZGsvc3JjL2xpYi91dGlscy9kaXJlY3RpdmVzL2ZvY3VzYWJsZS1saXN0L2ZvY3VzYWJsZS1saXN0Lm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQ3pDLE9BQU8sRUFBRSxzQkFBc0IsRUFBRSxnQ0FBZ0MsRUFBRSxNQUFNLDRCQUE0QixDQUFDO0FBQ3RHLE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxNQUFNLG1CQUFtQixDQUFDOztBQU14RCxNQUFNLE9BQU8sbUJBQW1COzhHQUFuQixtQkFBbUI7K0dBQW5CLG1CQUFtQixZQUhsQixtQkFBbUIsRUFBRSxzQkFBc0IsRUFBRSxnQ0FBZ0MsYUFDN0Usc0JBQXNCLEVBQUUsbUJBQW1CLEVBQUUsZ0NBQWdDOytHQUU5RSxtQkFBbUIsWUFIbEIsbUJBQW1CLEVBQ0ssbUJBQW1COzsyRkFFNUMsbUJBQW1CO2tCQUovQixRQUFRO21CQUFDO29CQUNOLE9BQU8sRUFBRSxDQUFDLG1CQUFtQixFQUFFLHNCQUFzQixFQUFFLGdDQUFnQyxDQUFDO29CQUN4RixPQUFPLEVBQUUsQ0FBQyxzQkFBc0IsRUFBRSxtQkFBbUIsRUFBRSxnQ0FBZ0MsQ0FBQztpQkFDM0YiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBOZ01vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgRm9jdXNhYmxlTGlzdERpcmVjdGl2ZSwgRGVwcmVjYXRlZEZvY3VzYWJsZUxpc3REaXJlY3RpdmUgfSBmcm9tICcuL2ZvY3VzYWJsZS1saXN0LmRpcmVjdGl2ZSc7XG5pbXBvcnQgeyBGb2N1c2FibGVJdGVtTW9kdWxlIH0gZnJvbSAnLi4vZm9jdXNhYmxlLWl0ZW0nO1xuXG5ATmdNb2R1bGUoe1xuICAgIGltcG9ydHM6IFtGb2N1c2FibGVJdGVtTW9kdWxlLCBGb2N1c2FibGVMaXN0RGlyZWN0aXZlLCBEZXByZWNhdGVkRm9jdXNhYmxlTGlzdERpcmVjdGl2ZV0sXG4gICAgZXhwb3J0czogW0ZvY3VzYWJsZUxpc3REaXJlY3RpdmUsIEZvY3VzYWJsZUl0ZW1Nb2R1bGUsIERlcHJlY2F0ZWRGb2N1c2FibGVMaXN0RGlyZWN0aXZlXVxufSlcbmV4cG9ydCBjbGFzcyBGb2N1c2FibGVMaXN0TW9kdWxlIHt9XG4iXX0=

package/esm2022/utils/directives/ignore-click-on-selection/ignore-click-on-selection.directive.mjs

@@ -0,0 +1,79 @@
+import { Directive, ElementRef, HostListener, Inject } from '@angular/core';
+import { DOCUMENT } from '@angular/common';
+import { IgnoreClickOnSelectionDirectiveToken } from './tokens';
+import { DeprecatedSelector, FD_DEPRECATED_DIRECTIVE_SELECTOR, getDeprecatedModel } from '../../deprecated-selector.class';
+import * as i0 from "@angular/core";
+export class DeprecatedIgnoreClickOnSelectionDirective extends DeprecatedSelector {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.0", ngImport: i0, type: DeprecatedIgnoreClickOnSelectionDirective, deps: null, target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.1.0", type: DeprecatedIgnoreClickOnSelectionDirective, isStandalone: true, selector: "[fdIgnoreClickOnSelection]", providers: [
+            {
+                provide: FD_DEPRECATED_DIRECTIVE_SELECTOR,
+                useValue: getDeprecatedModel('[fdkIgnoreClickOnSelection]', '[fdIgnoreClickOnSelection]')
+            }
+        ], usesInheritance: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.0", ngImport: i0, type: DeprecatedIgnoreClickOnSelectionDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    // eslint-disable-next-line @angular-eslint/directive-selector
+                    selector: '[fdIgnoreClickOnSelection]',
+                    standalone: true,
+                    providers: [
+                        {
+                            provide: FD_DEPRECATED_DIRECTIVE_SELECTOR,
+                            useValue: getDeprecatedModel('[fdkIgnoreClickOnSelection]', '[fdIgnoreClickOnSelection]')
+                        }
+                    ]
+                }]
+        }] });
+/**
+ * Directive will stop propagation and prevent default of click, if selected area is coming from
+ * directive's host element. This gives ability to not cancel all clicks on element, just the ones
+ * which include selection
+ */
+export class IgnoreClickOnSelectionDirective {
+    /** @hidden */
+    constructor(document, _elementRef) {
+        this.document = document;
+        this._elementRef = _elementRef;
+    }
+    /** Host click listener. Checks for selection existence and if finds one, checks anchor */
+    clicked($event) {
+        const selection = this.document.getSelection();
+        if (selection?.toString()) {
+            if (selection.anchorNode &&
+                (this._elementRef.nativeElement.isSameNode(selection.anchorNode) ||
+                    this._elementRef.nativeElement.isSameNode(selection.anchorNode.parentElement))) {
+                $event.stopPropagation();
+                $event.preventDefault();
+            }
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.0", ngImport: i0, type: IgnoreClickOnSelectionDirective, deps: [{ token: DOCUMENT }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.1.0", type: IgnoreClickOnSelectionDirective, isStandalone: true, selector: "[fdkIgnoreClickOnSelection], [fdIgnoreClickOnSelection]", host: { listeners: { "click": "clicked($event)" } }, providers: [
+            {
+                provide: IgnoreClickOnSelectionDirectiveToken,
+                useExisting: IgnoreClickOnSelectionDirective
+            }
+        ], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.0", ngImport: i0, type: IgnoreClickOnSelectionDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[fdkIgnoreClickOnSelection], [fdIgnoreClickOnSelection]',
+                    standalone: true,
+                    providers: [
+                        {
+                            provide: IgnoreClickOnSelectionDirectiveToken,
+                            useExisting: IgnoreClickOnSelectionDirective
+                        }
+                    ]
+                }]
+        }], ctorParameters: function () { return [{ type: Document, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }, { type: i0.ElementRef }]; }, propDecorators: { clicked: [{
+                type: HostListener,
+                args: ['click', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2020 → esm2022}/utils/directives/ignore-click-on-selection/ignore-click-on-selection.module.mjs

@@ -2,15 +2,15 @@ import { NgModule } from '@angular/core';
 import { IgnoreClickOnSelectionDirective, DeprecatedIgnoreClickOnSelectionDirective } from './ignore-click-on-selection.directive';
 import * as i0 from "@angular/core";
 export class IgnoreClickOnSelectionModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.0", ngImport: i0, type: IgnoreClickOnSelectionModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.1.0", ngImport: i0, type: IgnoreClickOnSelectionModule, imports: [IgnoreClickOnSelectionDirective, DeprecatedIgnoreClickOnSelectionDirective], exports: [IgnoreClickOnSelectionDirective, DeprecatedIgnoreClickOnSelectionDirective] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.1.0", ngImport: i0, type: IgnoreClickOnSelectionModule }); }
 }
-IgnoreClickOnSelectionModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: IgnoreClickOnSelectionModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-IgnoreClickOnSelectionModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.9", ngImport: i0, type: IgnoreClickOnSelectionModule, imports: [IgnoreClickOnSelectionDirective, DeprecatedIgnoreClickOnSelectionDirective], exports: [IgnoreClickOnSelectionDirective, DeprecatedIgnoreClickOnSelectionDirective] });
-IgnoreClickOnSelectionModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: IgnoreClickOnSelectionModule });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: IgnoreClickOnSelectionModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.0", ngImport: i0, type: IgnoreClickOnSelectionModule, decorators: [{
             type: NgModule,
             args: [{
                     imports: [IgnoreClickOnSelectionDirective, DeprecatedIgnoreClickOnSelectionDirective],
                     exports: [IgnoreClickOnSelectionDirective, DeprecatedIgnoreClickOnSelectionDirective]
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaWdub3JlLWNsaWNrLW9uLXNlbGVjdGlvbi5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2Nkay9zcmMvbGliL3V0aWxzL2RpcmVjdGl2ZXMvaWdub3JlLWNsaWNrLW9uLXNlbGVjdGlvbi9pZ25vcmUtY2xpY2stb24tc2VsZWN0aW9uLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQ3pDLE9BQU8sRUFDSCwrQkFBK0IsRUFDL0IseUNBQXlDLEVBQzVDLE1BQU0sdUNBQXVDLENBQUM7O0FBTS9DLE1BQU0sT0FBTyw0QkFBNEI7O3lIQUE1Qiw0QkFBNEI7MEhBQTVCLDRCQUE0QixZQUgzQiwrQkFBK0IsRUFBRSx5Q0FBeUMsYUFDMUUsK0JBQStCLEVBQUUseUNBQXlDOzBIQUUzRSw0QkFBNEI7MkZBQTVCLDRCQUE0QjtrQkFKeEMsUUFBUTttQkFBQztvQkFDTixPQUFPLEVBQUUsQ0FBQywrQkFBK0IsRUFBRSx5Q0FBeUMsQ0FBQztvQkFDckYsT0FBTyxFQUFFLENBQUMsK0JBQStCLEVBQUUseUNBQXlDLENBQUM7aUJBQ3hGIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTmdNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7XG4gICAgSWdub3JlQ2xpY2tPblNlbGVjdGlvbkRpcmVjdGl2ZSxcbiAgICBEZXByZWNhdGVkSWdub3JlQ2xpY2tPblNlbGVjdGlvbkRpcmVjdGl2ZVxufSBmcm9tICcuL2lnbm9yZS1jbGljay1vbi1zZWxlY3Rpb24uZGlyZWN0aXZlJztcblxuQE5nTW9kdWxlKHtcbiAgICBpbXBvcnRzOiBbSWdub3JlQ2xpY2tPblNlbGVjdGlvbkRpcmVjdGl2ZSwgRGVwcmVjYXRlZElnbm9yZUNsaWNrT25TZWxlY3Rpb25EaXJlY3RpdmVdLFxuICAgIGV4cG9ydHM6IFtJZ25vcmVDbGlja09uU2VsZWN0aW9uRGlyZWN0aXZlLCBEZXByZWNhdGVkSWdub3JlQ2xpY2tPblNlbGVjdGlvbkRpcmVjdGl2ZV1cbn0pXG5leHBvcnQgY2xhc3MgSWdub3JlQ2xpY2tPblNlbGVjdGlvbk1vZHVsZSB7fVxuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaWdub3JlLWNsaWNrLW9uLXNlbGVjdGlvbi5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2Nkay9zcmMvbGliL3V0aWxzL2RpcmVjdGl2ZXMvaWdub3JlLWNsaWNrLW9uLXNlbGVjdGlvbi9pZ25vcmUtY2xpY2stb24tc2VsZWN0aW9uLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQ3pDLE9BQU8sRUFDSCwrQkFBK0IsRUFDL0IseUNBQXlDLEVBQzVDLE1BQU0sdUNBQXVDLENBQUM7O0FBTS9DLE1BQU0sT0FBTyw0QkFBNEI7OEdBQTVCLDRCQUE0QjsrR0FBNUIsNEJBQTRCLFlBSDNCLCtCQUErQixFQUFFLHlDQUF5QyxhQUMxRSwrQkFBK0IsRUFBRSx5Q0FBeUM7K0dBRTNFLDRCQUE0Qjs7MkZBQTVCLDRCQUE0QjtrQkFKeEMsUUFBUTttQkFBQztvQkFDTixPQUFPLEVBQUUsQ0FBQywrQkFBK0IsRUFBRSx5Q0FBeUMsQ0FBQztvQkFDckYsT0FBTyxFQUFFLENBQUMsK0JBQStCLEVBQUUseUNBQXlDLENBQUM7aUJBQ3hGIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTmdNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7XG4gICAgSWdub3JlQ2xpY2tPblNlbGVjdGlvbkRpcmVjdGl2ZSxcbiAgICBEZXByZWNhdGVkSWdub3JlQ2xpY2tPblNlbGVjdGlvbkRpcmVjdGl2ZVxufSBmcm9tICcuL2lnbm9yZS1jbGljay1vbi1zZWxlY3Rpb24uZGlyZWN0aXZlJztcblxuQE5nTW9kdWxlKHtcbiAgICBpbXBvcnRzOiBbSWdub3JlQ2xpY2tPblNlbGVjdGlvbkRpcmVjdGl2ZSwgRGVwcmVjYXRlZElnbm9yZUNsaWNrT25TZWxlY3Rpb25EaXJlY3RpdmVdLFxuICAgIGV4cG9ydHM6IFtJZ25vcmVDbGlja09uU2VsZWN0aW9uRGlyZWN0aXZlLCBEZXByZWNhdGVkSWdub3JlQ2xpY2tPblNlbGVjdGlvbkRpcmVjdGl2ZV1cbn0pXG5leHBvcnQgY2xhc3MgSWdub3JlQ2xpY2tPblNlbGVjdGlvbk1vZHVsZSB7fVxuIl19