Changing front

front/app/node_modules/@angular/cdk/esm2020/menu/context-menu-trigger.mjs

@@ -0,0 +1,218 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { Directive, inject, Injectable, Input } from '@angular/core';
+import { Directionality } from '@angular/cdk/bidi';
+import { Overlay, OverlayConfig, STANDARD_DROPDOWN_BELOW_POSITIONS, } from '@angular/cdk/overlay';
+import { coerceBooleanProperty } from '@angular/cdk/coercion';
+import { _getEventTarget } from '@angular/cdk/platform';
+import { merge, partition } from 'rxjs';
+import { skip, takeUntil } from 'rxjs/operators';
+import { MENU_STACK, MenuStack } from './menu-stack';
+import { CdkMenuTriggerBase, MENU_TRIGGER } from './menu-trigger-base';
+import * as i0 from "@angular/core";
+/** The preferred menu positions for the context menu. */
+const CONTEXT_MENU_POSITIONS = STANDARD_DROPDOWN_BELOW_POSITIONS.map(position => {
+    // In cases where the first menu item in the context menu is a trigger the submenu opens on a
+    // hover event. We offset the context menu 2px by default to prevent this from occurring.
+    const offsetX = position.overlayX === 'start' ? 2 : -2;
+    const offsetY = position.overlayY === 'top' ? 2 : -2;
+    return { ...position, offsetX, offsetY };
+});
+/** Tracks the last open context menu trigger across the entire application. */
+export class ContextMenuTracker {
+    /**
+     * Close the previous open context menu and set the given one as being open.
+     * @param trigger The trigger for the currently open Context Menu.
+     */
+    update(trigger) {
+        if (ContextMenuTracker._openContextMenuTrigger !== trigger) {
+            ContextMenuTracker._openContextMenuTrigger?.close();
+            ContextMenuTracker._openContextMenuTrigger = trigger;
+        }
+    }
+}
+ContextMenuTracker.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: ContextMenuTracker, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+ContextMenuTracker.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: ContextMenuTracker, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: ContextMenuTracker, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+/**
+ * A directive that opens a menu when a user right-clicks within its host element.
+ * It is aware of nested context menus and will trigger only the lowest level non-disabled context menu.
+ */
+export class CdkContextMenuTrigger extends CdkMenuTriggerBase {
+    constructor() {
+        super();
+        /** The CDK overlay service. */
+        this._overlay = inject(Overlay);
+        /** The directionality of the page. */
+        this._directionality = inject(Directionality, { optional: true });
+        /** The app's context menu tracking registry */
+        this._contextMenuTracker = inject(ContextMenuTracker);
+        this._disabled = false;
+        this._setMenuStackCloseListener();
+    }
+    /** Whether the context menu is disabled. */
+    get disabled() {
+        return this._disabled;
+    }
+    set disabled(value) {
+        this._disabled = coerceBooleanProperty(value);
+    }
+    /**
+     * Open the attached menu at the specified location.
+     * @param coordinates where to open the context menu
+     */
+    open(coordinates) {
+        this._open(coordinates, false);
+    }
+    /** Close the currently opened context menu. */
+    close() {
+        this.menuStack.closeAll();
+    }
+    /**
+     * Open the context menu and closes any previously open menus.
+     * @param event the mouse event which opens the context menu.
+     */
+    _openOnContextMenu(event) {
+        if (!this.disabled) {
+            // Prevent the native context menu from opening because we're opening a custom one.
+            event.preventDefault();
+            // Stop event propagation to ensure that only the closest enabled context menu opens.
+            // Otherwise, any context menus attached to containing elements would *also* open,
+            // resulting in multiple stacked context menus being displayed.
+            event.stopPropagation();
+            this._contextMenuTracker.update(this);
+            this._open({ x: event.clientX, y: event.clientY }, true);
+            // A context menu can be triggered via a mouse right click or a keyboard shortcut.
+            if (event.button === 2) {
+                this.childMenu?.focusFirstItem('mouse');
+            }
+            else if (event.button === 0) {
+                this.childMenu?.focusFirstItem('keyboard');
+            }
+            else {
+                this.childMenu?.focusFirstItem('program');
+            }
+        }
+    }
+    /**
+     * Get the configuration object used to create the overlay.
+     * @param coordinates the location to place the opened menu
+     */
+    _getOverlayConfig(coordinates) {
+        return new OverlayConfig({
+            positionStrategy: this._getOverlayPositionStrategy(coordinates),
+            scrollStrategy: this._overlay.scrollStrategies.reposition(),
+            direction: this._directionality || undefined,
+        });
+    }
+    /**
+     * Get the position strategy for the overlay which specifies where to place the menu.
+     * @param coordinates the location to place the opened menu
+     */
+    _getOverlayPositionStrategy(coordinates) {
+        return this._overlay
+            .position()
+            .flexibleConnectedTo(coordinates)
+            .withLockedPosition()
+            .withGrowAfterOpen()
+            .withPositions(this.menuPosition ?? CONTEXT_MENU_POSITIONS);
+    }
+    /** Subscribe to the menu stack close events and close this menu when requested. */
+    _setMenuStackCloseListener() {
+        this.menuStack.closed.pipe(takeUntil(this.destroyed)).subscribe(({ item }) => {
+            if (item === this.childMenu && this.isOpen()) {
+                this.closed.next();
+                this.overlayRef.detach();
+            }
+        });
+    }
+    /**
+     * Subscribe to the overlays outside pointer events stream and handle closing out the stack if a
+     * click occurs outside the menus.
+     * @param ignoreFirstAuxClick Whether to ignore the first auxclick event outside the menu.
+     */
+    _subscribeToOutsideClicks(ignoreFirstAuxClick) {
+        if (this.overlayRef) {
+            let outsideClicks = this.overlayRef.outsidePointerEvents();
+            // If the menu was triggered by the `contextmenu` event, skip the first `auxclick` event
+            // because it fires when the mouse is released on the same click that opened the menu.
+            if (ignoreFirstAuxClick) {
+                const [auxClicks, nonAuxClicks] = partition(outsideClicks, ({ type }) => type === 'auxclick');
+                outsideClicks = merge(nonAuxClicks, auxClicks.pipe(skip(1)));
+            }
+            outsideClicks.pipe(takeUntil(this.stopOutsideClicksListener)).subscribe(event => {
+                if (!this.isElementInsideMenuStack(_getEventTarget(event))) {
+                    this.menuStack.closeAll();
+                }
+            });
+        }
+    }
+    /**
+     * Open the attached menu at the specified location.
+     * @param coordinates where to open the context menu
+     * @param ignoreFirstOutsideAuxClick Whether to ignore the first auxclick outside the menu after opening.
+     */
+    _open(coordinates, ignoreFirstOutsideAuxClick) {
+        if (this.disabled) {
+            return;
+        }
+        if (this.isOpen()) {
+            // since we're moving this menu we need to close any submenus first otherwise they end up
+            // disconnected from this one.
+            this.menuStack.closeSubMenuOf(this.childMenu);
+            this.overlayRef.getConfig().positionStrategy.setOrigin(coordinates);
+            this.overlayRef.updatePosition();
+        }
+        else {
+            this.opened.next();
+            if (this.overlayRef) {
+                this.overlayRef.getConfig().positionStrategy.setOrigin(coordinates);
+                this.overlayRef.updatePosition();
+            }
+            else {
+                this.overlayRef = this._overlay.create(this._getOverlayConfig(coordinates));
+            }
+            this.overlayRef.attach(this.getMenuContentPortal());
+            this._subscribeToOutsideClicks(ignoreFirstOutsideAuxClick);
+        }
+    }
+}
+CdkContextMenuTrigger.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: CdkContextMenuTrigger, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+CdkContextMenuTrigger.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.0.0", type: CdkContextMenuTrigger, isStandalone: true, selector: "[cdkContextMenuTriggerFor]", inputs: { menuTemplateRef: ["cdkContextMenuTriggerFor", "menuTemplateRef"], menuPosition: ["cdkContextMenuPosition", "menuPosition"], menuData: ["cdkContextMenuTriggerData", "menuData"], disabled: ["cdkContextMenuDisabled", "disabled"] }, outputs: { opened: "cdkContextMenuOpened", closed: "cdkContextMenuClosed" }, host: { listeners: { "contextmenu": "_openOnContextMenu($event)" }, properties: { "attr.data-cdk-menu-stack-id": "null" } }, providers: [
+        { provide: MENU_TRIGGER, useExisting: CdkContextMenuTrigger },
+        { provide: MENU_STACK, useClass: MenuStack },
+    ], exportAs: ["cdkContextMenuTriggerFor"], usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: CdkContextMenuTrigger, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[cdkContextMenuTriggerFor]',
+                    exportAs: 'cdkContextMenuTriggerFor',
+                    standalone: true,
+                    host: {
+                        '[attr.data-cdk-menu-stack-id]': 'null',
+                        '(contextmenu)': '_openOnContextMenu($event)',
+                    },
+                    inputs: [
+                        'menuTemplateRef: cdkContextMenuTriggerFor',
+                        'menuPosition: cdkContextMenuPosition',
+                        'menuData: cdkContextMenuTriggerData',
+                    ],
+                    outputs: ['opened: cdkContextMenuOpened', 'closed: cdkContextMenuClosed'],
+                    providers: [
+                        { provide: MENU_TRIGGER, useExisting: CdkContextMenuTrigger },
+                        { provide: MENU_STACK, useClass: MenuStack },
+                    ],
+                }]
+        }], ctorParameters: function () { return []; }, propDecorators: { disabled: [{
+                type: Input,
+                args: ['cdkContextMenuDisabled']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29udGV4dC1tZW51LXRyaWdnZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvY2RrL21lbnUvY29udGV4dC1tZW51LXRyaWdnZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztHQU1HO0FBRUgsT0FBTyxFQUFDLFNBQVMsRUFBRSxNQUFNLEVBQUUsVUFBVSxFQUFFLEtBQUssRUFBWSxNQUFNLGVBQWUsQ0FBQztBQUM5RSxPQUFPLEVBQUMsY0FBYyxFQUFDLE1BQU0sbUJBQW1CLENBQUM7QUFDakQsT0FBTyxFQUVMLE9BQU8sRUFDUCxhQUFhLEVBQ2IsaUNBQWlDLEdBQ2xDLE1BQU0sc0JBQXNCLENBQUM7QUFDOUIsT0FBTyxFQUFlLHFCQUFxQixFQUFDLE1BQU0sdUJBQXVCLENBQUM7QUFDMUUsT0FBTyxFQUFDLGVBQWUsRUFBQyxNQUFNLHVCQUF1QixDQUFDO0FBQ3RELE9BQU8sRUFBQyxLQUFLLEVBQUUsU0FBUyxFQUFDLE1BQU0sTUFBTSxDQUFDO0FBQ3RDLE9BQU8sRUFBQyxJQUFJLEVBQUUsU0FBUyxFQUFDLE1BQU0sZ0JBQWdCLENBQUM7QUFDL0MsT0FBTyxFQUFDLFVBQVUsRUFBRSxTQUFTLEVBQUMsTUFBTSxjQUFjLENBQUM7QUFDbkQsT0FBTyxFQUFDLGtCQUFrQixFQUFFLFlBQVksRUFBQyxNQUFNLHFCQUFxQixDQUFDOztBQUVyRSx5REFBeUQ7QUFDekQsTUFBTSxzQkFBc0IsR0FBRyxpQ0FBaUMsQ0FBQyxHQUFHLENBQUMsUUFBUSxDQUFDLEVBQUU7SUFDOUUsNkZBQTZGO0lBQzdGLHlGQUF5RjtJQUN6RixNQUFNLE9BQU8sR0FBRyxRQUFRLENBQUMsUUFBUSxLQUFLLE9BQU8sQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQztJQUN2RCxNQUFNLE9BQU8sR0FBRyxRQUFRLENBQUMsUUFBUSxLQUFLLEtBQUssQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQztJQUNyRCxPQUFPLEVBQUMsR0FBRyxRQUFRLEVBQUUsT0FBTyxFQUFFLE9BQU8sRUFBQyxDQUFDO0FBQ3pDLENBQUMsQ0FBQyxDQUFDO0FBRUgsK0VBQStFO0FBRS9FLE1BQU0sT0FBTyxrQkFBa0I7SUFJN0I7OztPQUdHO0lBQ0gsTUFBTSxDQUFDLE9BQThCO1FBQ25DLElBQUksa0JBQWtCLENBQUMsdUJBQXVCLEtBQUssT0FBTyxFQUFFO1lBQzFELGtCQUFrQixDQUFDLHVCQUF1QixFQUFFLEtBQUssRUFBRSxDQUFDO1lBQ3BELGtCQUFrQixDQUFDLHVCQUF1QixHQUFHLE9BQU8sQ0FBQztTQUN0RDtJQUNILENBQUM7OytHQWJVLGtCQUFrQjttSEFBbEIsa0JBQWtCLGNBRE4sTUFBTTsyRkFDbEIsa0JBQWtCO2tCQUQ5QixVQUFVO21CQUFDLEVBQUMsVUFBVSxFQUFFLE1BQU0sRUFBQzs7QUFvQmhDOzs7R0FHRztBQW9CSCxNQUFNLE9BQU8scUJBQXNCLFNBQVEsa0JBQWtCO0lBb0IzRDtRQUNFLEtBQUssRUFBRSxDQUFDO1FBcEJWLCtCQUErQjtRQUNkLGFBQVEsR0FBRyxNQUFNLENBQUMsT0FBTyxDQUFDLENBQUM7UUFFNUMsc0NBQXNDO1FBQ3JCLG9CQUFlLEdBQUcsTUFBTSxDQUFDLGNBQWMsRUFBRSxFQUFDLFFBQVEsRUFBRSxJQUFJLEVBQUMsQ0FBQyxDQUFDO1FBRTVFLCtDQUErQztRQUM5Qix3QkFBbUIsR0FBRyxNQUFNLENBQUMsa0JBQWtCLENBQUMsQ0FBQztRQVUxRCxjQUFTLEdBQUcsS0FBSyxDQUFDO1FBSXhCLElBQUksQ0FBQywwQkFBMEIsRUFBRSxDQUFDO0lBQ3BDLENBQUM7SUFiRCw0Q0FBNEM7SUFDNUMsSUFDSSxRQUFRO1FBQ1YsT0FBTyxJQUFJLENBQUMsU0FBUyxDQUFDO0lBQ3hCLENBQUM7SUFDRCxJQUFJLFFBQVEsQ0FBQyxLQUFtQjtRQUM5QixJQUFJLENBQUMsU0FBUyxHQUFHLHFCQUFxQixDQUFDLEtBQUssQ0FBQyxDQUFDO0lBQ2hELENBQUM7SUFRRDs7O09BR0c7SUFDSCxJQUFJLENBQUMsV0FBbUM7UUFDdEMsSUFBSSxDQUFDLEtBQUssQ0FBQyxXQUFXLEVBQUUsS0FBSyxDQUFDLENBQUM7SUFDakMsQ0FBQztJQUVELCtDQUErQztJQUMvQyxLQUFLO1FBQ0gsSUFBSSxDQUFDLFNBQVMsQ0FBQyxRQUFRLEVBQUUsQ0FBQztJQUM1QixDQUFDO0lBRUQ7OztPQUdHO0lBQ0gsa0JBQWtCLENBQUMsS0FBaUI7UUFDbEMsSUFBSSxDQUFDLElBQUksQ0FBQyxRQUFRLEVBQUU7WUFDbEIsbUZBQW1GO1lBQ25GLEtBQUssQ0FBQyxjQUFjLEVBQUUsQ0FBQztZQUV2QixxRkFBcUY7WUFDckYsa0ZBQWtGO1lBQ2xGLCtEQUErRDtZQUMvRCxLQUFLLENBQUMsZUFBZSxFQUFFLENBQUM7WUFFeEIsSUFBSSxDQUFDLG1CQUFtQixDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsQ0FBQztZQUN0QyxJQUFJLENBQUMsS0FBSyxDQUFDLEVBQUMsQ0FBQyxFQUFFLEtBQUssQ0FBQyxPQUFPLEVBQUUsQ0FBQyxFQUFFLEtBQUssQ0FBQyxPQUFPLEVBQUMsRUFBRSxJQUFJLENBQUMsQ0FBQztZQUV2RCxrRkFBa0Y7WUFDbEYsSUFBSSxLQUFLLENBQUMsTUFBTSxLQUFLLENBQUMsRUFBRTtnQkFDdEIsSUFBSSxDQUFDLFNBQVMsRUFBRSxjQUFjLENBQUMsT0FBTyxDQUFDLENBQUM7YUFDekM7aUJBQU0sSUFBSSxLQUFLLENBQUMsTUFBTSxLQUFLLENBQUMsRUFBRTtnQkFDN0IsSUFBSSxDQUFDLFNBQVMsRUFBRSxjQUFjLENBQUMsVUFBVSxDQUFDLENBQUM7YUFDNUM7aUJBQU07Z0JBQ0wsSUFBSSxDQUFDLFNBQVMsRUFBRSxjQUFjLENBQUMsU0FBUyxDQUFDLENBQUM7YUFDM0M7U0FDRjtJQUNILENBQUM7SUFFRDs7O09BR0c7SUFDSyxpQkFBaUIsQ0FBQyxXQUFtQztRQUMzRCxPQUFPLElBQUksYUFBYSxDQUFDO1lBQ3ZCLGdCQUFnQixFQUFFLElBQUksQ0FBQywyQkFBMkIsQ0FBQyxXQUFXLENBQUM7WUFDL0QsY0FBYyxFQUFFLElBQUksQ0FBQyxRQUFRLENBQUMsZ0JBQWdCLENBQUMsVUFBVSxFQUFFO1lBQzNELFNBQVMsRUFBRSxJQUFJLENBQUMsZUFBZSxJQUFJLFNBQVM7U0FDN0MsQ0FBQyxDQUFDO0lBQ0wsQ0FBQztJQUVEOzs7T0FHRztJQUNLLDJCQUEyQixDQUNqQyxXQUFtQztRQUVuQyxPQUFPLElBQUksQ0FBQyxRQUFRO2FBQ2pCLFFBQVEsRUFBRTthQUNWLG1CQUFtQixDQUFDLFdBQVcsQ0FBQzthQUNoQyxrQkFBa0IsRUFBRTthQUNwQixpQkFBaUIsRUFBRTthQUNuQixhQUFhLENBQUMsSUFBSSxDQUFDLFlBQVksSUFBSSxzQkFBc0IsQ0FBQyxDQUFDO0lBQ2hFLENBQUM7SUFFRCxtRkFBbUY7SUFDM0UsMEJBQTBCO1FBQ2hDLElBQUksQ0FBQyxTQUFTLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxTQUFTLENBQUMsSUFBSSxDQUFDLFNBQVMsQ0FBQyxDQUFDLENBQUMsU0FBUyxDQUFDLENBQUMsRUFBQyxJQUFJLEVBQUMsRUFBRSxFQUFFO1lBQ3pFLElBQUksSUFBSSxLQUFLLElBQUksQ0FBQyxTQUFTLElBQUksSUFBSSxDQUFDLE1BQU0sRUFBRSxFQUFFO2dCQUM1QyxJQUFJLENBQUMsTUFBTSxDQUFDLElBQUksRUFBRSxDQUFDO2dCQUNuQixJQUFJLENBQUMsVUFBVyxDQUFDLE1BQU0sRUFBRSxDQUFDO2FBQzNCO1FBQ0gsQ0FBQyxDQUFDLENBQUM7SUFDTCxDQUFDO0lBRUQ7Ozs7T0FJRztJQUNLLHlCQUF5QixDQUFDLG1CQUE0QjtRQUM1RCxJQUFJLElBQUksQ0FBQyxVQUFVLEVBQUU7WUFDbkIsSUFBSSxhQUFhLEdBQUcsSUFBSSxDQUFDLFVBQVUsQ0FBQyxvQkFBb0IsRUFBRSxDQUFDO1lBQzNELHdGQUF3RjtZQUN4RixzRkFBc0Y7WUFDdEYsSUFBSSxtQkFBbUIsRUFBRTtnQkFDdkIsTUFBTSxDQUFDLFNBQVMsRUFBRSxZQUFZLENBQUMsR0FBRyxTQUFTLENBQUMsYUFBYSxFQUFFLENBQUMsRUFBQyxJQUFJLEVBQUMsRUFBRSxFQUFFLENBQUMsSUFBSSxLQUFLLFVBQVUsQ0FBQyxDQUFDO2dCQ
Line truncated

front/app/node_modules/@angular/cdk/esm2020/menu/index.mjs

@@ -0,0 +1,9 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvY2RrL21lbnUvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztHQU1HO0FBRUgsY0FBYyxjQUFjLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIExMQyBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vYW5ndWxhci5pby9saWNlbnNlXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWMtYXBpJztcbiJdfQ==

front/app/node_modules/@angular/cdk/esm2020/menu/menu-aim.mjs

@@ -0,0 +1,204 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { Directive, inject, Injectable, InjectionToken, NgZone } from '@angular/core';
+import { fromEvent, Subject } from 'rxjs';
+import { filter, takeUntil } from 'rxjs/operators';
+import { throwMissingMenuReference, throwMissingPointerFocusTracker } from './menu-errors';
+import * as i0 from "@angular/core";
+/** Injection token used for an implementation of MenuAim. */
+export const MENU_AIM = new InjectionToken('cdk-menu-aim');
+/** Capture every nth mouse move event. */
+const MOUSE_MOVE_SAMPLE_FREQUENCY = 3;
+/** The number of mouse move events to track. */
+const NUM_POINTS = 5;
+/**
+ * How long to wait before closing a sibling menu if a user stops short of the submenu they were
+ * predicted to go into.
+ */
+const CLOSE_DELAY = 300;
+/** Calculate the slope between point a and b. */
+function getSlope(a, b) {
+    return (b.y - a.y) / (b.x - a.x);
+}
+/** Calculate the y intercept for the given point and slope. */
+function getYIntercept(point, slope) {
+    return point.y - slope * point.x;
+}
+/**
+ * Whether the given mouse trajectory line defined by the slope and y intercept falls within the
+ * submenu as defined by `submenuPoints`
+ * @param submenuPoints the submenu DOMRect points.
+ * @param m the slope of the trajectory line.
+ * @param b the y intercept of the trajectory line.
+ * @return true if any point on the line falls within the submenu.
+ */
+function isWithinSubmenu(submenuPoints, m, b) {
+    const { left, right, top, bottom } = submenuPoints;
+    // Check for intersection with each edge of the submenu (left, right, top, bottom)
+    // by fixing one coordinate to that edge's coordinate (either x or y) and checking if the
+    // other coordinate is within bounds.
+    return ((m * left + b >= top && m * left + b <= bottom) ||
+        (m * right + b >= top && m * right + b <= bottom) ||
+        ((top - b) / m >= left && (top - b) / m <= right) ||
+        ((bottom - b) / m >= left && (bottom - b) / m <= right));
+}
+/**
+ * TargetMenuAim predicts if a user is moving into a submenu. It calculates the
+ * trajectory of the user's mouse movement in the current menu to determine if the
+ * mouse is moving towards an open submenu.
+ *
+ * The determination is made by calculating the slope of the users last NUM_POINTS moves where each
+ * pair of points determines if the trajectory line points into the submenu. It uses consensus
+ * approach by checking if at least NUM_POINTS / 2 pairs determine that the user is moving towards
+ * to submenu.
+ */
+export class TargetMenuAim {
+    constructor() {
+        /** The Angular zone. */
+        this._ngZone = inject(NgZone);
+        /** The last NUM_POINTS mouse move events. */
+        this._points = [];
+        /** Emits when this service is destroyed. */
+        this._destroyed = new Subject();
+    }
+    ngOnDestroy() {
+        this._destroyed.next();
+        this._destroyed.complete();
+    }
+    /**
+     * Set the Menu and its PointerFocusTracker.
+     * @param menu The menu that this menu aim service controls.
+     * @param pointerTracker The `PointerFocusTracker` for the given menu.
+     */
+    initialize(menu, pointerTracker) {
+        this._menu = menu;
+        this._pointerTracker = pointerTracker;
+        this._subscribeToMouseMoves();
+    }
+    /**
+     * Calls the `doToggle` callback when it is deemed that the user is not moving towards
+     * the submenu.
+     * @param doToggle the function called when the user is not moving towards the submenu.
+     */
+    toggle(doToggle) {
+        // If the menu is horizontal the sub-menus open below and there is no risk of premature
+        // closing of any sub-menus therefore we automatically resolve the callback.
+        if (this._menu.orientation === 'horizontal') {
+            doToggle();
+        }
+        this._checkConfigured();
+        const siblingItemIsWaiting = !!this._timeoutId;
+        const hasPoints = this._points.length > 1;
+        if (hasPoints && !siblingItemIsWaiting) {
+            if (this._isMovingToSubmenu()) {
+                this._startTimeout(doToggle);
+            }
+            else {
+                doToggle();
+            }
+        }
+        else if (!siblingItemIsWaiting) {
+            doToggle();
+        }
+    }
+    /**
+     * Start the delayed toggle handler if one isn't running already.
+     *
+     * The delayed toggle handler executes the `doToggle` callback after some period of time iff the
+     * users mouse is on an item in the current menu.
+     *
+     * @param doToggle the function called when the user is not moving towards the submenu.
+     */
+    _startTimeout(doToggle) {
+        // If the users mouse is moving towards a submenu we don't want to immediately resolve.
+        // Wait for some period of time before determining if the previous menu should close in
+        // cases where the user may have moved towards the submenu but stopped on a sibling menu
+        // item intentionally.
+        const timeoutId = setTimeout(() => {
+            // Resolve if the user is currently moused over some element in the root menu
+            if (this._pointerTracker.activeElement && timeoutId === this._timeoutId) {
+                doToggle();
+            }
+            this._timeoutId = null;
+        }, CLOSE_DELAY);
+        this._timeoutId = timeoutId;
+    }
+    /** Whether the user is heading towards the open submenu. */
+    _isMovingToSubmenu() {
+        const submenuPoints = this._getSubmenuBounds();
+        if (!submenuPoints) {
+            return false;
+        }
+        let numMoving = 0;
+        const currPoint = this._points[this._points.length - 1];
+        // start from the second last point and calculate the slope between each point and the last
+        // point.
+        for (let i = this._points.length - 2; i >= 0; i--) {
+            const previous = this._points[i];
+            const slope = getSlope(currPoint, previous);
+            if (isWithinSubmenu(submenuPoints, slope, getYIntercept(currPoint, slope))) {
+                numMoving++;
+            }
+        }
+        return numMoving >= Math.floor(NUM_POINTS / 2);
+    }
+    /** Get the bounding DOMRect for the open submenu. */
+    _getSubmenuBounds() {
+        return this._pointerTracker?.previousElement?.getMenu()?.nativeElement.getBoundingClientRect();
+    }
+    /**
+     * Check if a reference to the PointerFocusTracker and menu element is provided.
+     * @throws an error if neither reference is provided.
+     */
+    _checkConfigured() {
+        if (typeof ngDevMode === 'undefined' || ngDevMode) {
+            if (!this._pointerTracker) {
+                throwMissingPointerFocusTracker();
+            }
+            if (!this._menu) {
+                throwMissingMenuReference();
+            }
+        }
+    }
+    /** Subscribe to the root menus mouse move events and update the tracked mouse points. */
+    _subscribeToMouseMoves() {
+        this._ngZone.runOutsideAngular(() => {
+            fromEvent(this._menu.nativeElement, 'mousemove')
+                .pipe(filter((_, index) => index % MOUSE_MOVE_SAMPLE_FREQUENCY === 0), takeUntil(this._destroyed))
+                .subscribe((event) => {
+                this._points.push({ x: event.clientX, y: event.clientY });
+                if (this._points.length > NUM_POINTS) {
+                    this._points.shift();
+                }
+            });
+        });
+    }
+}
+TargetMenuAim.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: TargetMenuAim, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+TargetMenuAim.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: TargetMenuAim });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: TargetMenuAim, decorators: [{
+            type: Injectable
+        }] });
+/**
+ * CdkTargetMenuAim is a provider for the TargetMenuAim service. It can be added to an
+ * element with either the `cdkMenu` or `cdkMenuBar` directive and child menu items.
+ */
+export class CdkTargetMenuAim {
+}
+CdkTargetMenuAim.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: CdkTargetMenuAim, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+CdkTargetMenuAim.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.0.0", type: CdkTargetMenuAim, isStandalone: true, selector: "[cdkTargetMenuAim]", providers: [{ provide: MENU_AIM, useClass: TargetMenuAim }], exportAs: ["cdkTargetMenuAim"], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: CdkTargetMenuAim, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[cdkTargetMenuAim]',
+                    exportAs: 'cdkTargetMenuAim',
+                    standalone: true,
+                    providers: [{ provide: MENU_AIM, useClass: TargetMenuAim }],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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
Line truncated

front/app/node_modules/@angular/cdk/esm2020/menu/menu-bar.mjs

@@ -0,0 +1,134 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { Directive } from '@angular/core';
+import { DOWN_ARROW, ESCAPE, hasModifierKey, LEFT_ARROW, RIGHT_ARROW, TAB, UP_ARROW, } from '@angular/cdk/keycodes';
+import { takeUntil } from 'rxjs/operators';
+import { CdkMenuGroup } from './menu-group';
+import { CDK_MENU } from './menu-interface';
+import { MENU_STACK, MenuStack } from './menu-stack';
+import { CdkMenuBase } from './menu-base';
+import * as i0 from "@angular/core";
+/**
+ * Directive applied to an element which configures it as a MenuBar by setting the appropriate
+ * role, aria attributes, and accessible keyboard and mouse handling logic. The component that
+ * this directive is applied to should contain components marked with CdkMenuItem.
+ *
+ */
+export class CdkMenuBar extends CdkMenuBase {
+    constructor() {
+        super(...arguments);
+        /** The direction items in the menu flow. */
+        this.orientation = 'horizontal';
+        /** Whether the menu is displayed inline (i.e. always present vs a conditional popup that the user triggers with a trigger element). */
+        this.isInline = true;
+    }
+    ngAfterContentInit() {
+        super.ngAfterContentInit();
+        this._subscribeToMenuStackEmptied();
+    }
+    /**
+     * Handle keyboard events for the Menu.
+     * @param event The keyboard event to be handled.
+     */
+    _handleKeyEvent(event) {
+        const keyManager = this.keyManager;
+        switch (event.keyCode) {
+            case UP_ARROW:
+            case DOWN_ARROW:
+            case LEFT_ARROW:
+            case RIGHT_ARROW:
+                if (!hasModifierKey(event)) {
+                    const horizontalArrows = event.keyCode === LEFT_ARROW || event.keyCode === RIGHT_ARROW;
+                    // For a horizontal menu if the left/right keys were clicked, or a vertical menu if the
+                    // up/down keys were clicked: if the current menu is open, close it then focus and open the
+                    // next  menu.
+                    if (horizontalArrows) {
+                        event.preventDefault();
+                        const prevIsOpen = keyManager.activeItem?.isMenuOpen();
+                        keyManager.activeItem?.getMenuTrigger()?.close();
+                        keyManager.setFocusOrigin('keyboard');
+                        keyManager.onKeydown(event);
+                        if (prevIsOpen) {
+                            keyManager.activeItem?.getMenuTrigger()?.open();
+                        }
+                    }
+                }
+                break;
+            case ESCAPE:
+                if (!hasModifierKey(event)) {
+                    event.preventDefault();
+                    keyManager.activeItem?.getMenuTrigger()?.close();
+                }
+                break;
+            case TAB:
+                if (!hasModifierKey(event, 'altKey', 'metaKey', 'ctrlKey')) {
+                    keyManager.activeItem?.getMenuTrigger()?.close();
+                }
+                break;
+            default:
+                keyManager.onKeydown(event);
+        }
+    }
+    /**
+     * Set focus to either the current, previous or next item based on the FocusNext event, then
+     * open the previous or next item.
+     * @param focusNext The element to focus.
+     */
+    _toggleOpenMenu(focusNext) {
+        const keyManager = this.keyManager;
+        switch (focusNext) {
+            case 0 /* FocusNext.nextItem */:
+                keyManager.setFocusOrigin('keyboard');
+                keyManager.setNextItemActive();
+                keyManager.activeItem?.getMenuTrigger()?.open();
+                break;
+            case 1 /* FocusNext.previousItem */:
+                keyManager.setFocusOrigin('keyboard');
+                keyManager.setPreviousItemActive();
+                keyManager.activeItem?.getMenuTrigger()?.open();
+                break;
+            case 2 /* FocusNext.currentItem */:
+                if (keyManager.activeItem) {
+                    keyManager.setFocusOrigin('keyboard');
+                    keyManager.setActiveItem(keyManager.activeItem);
+                }
+                break;
+        }
+    }
+    /** Subscribe to the MenuStack emptied events. */
+    _subscribeToMenuStackEmptied() {
+        this.menuStack?.emptied
+            .pipe(takeUntil(this.destroyed))
+            .subscribe(event => this._toggleOpenMenu(event));
+    }
+}
+CdkMenuBar.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: CdkMenuBar, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+CdkMenuBar.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.0.0", type: CdkMenuBar, isStandalone: true, selector: "[cdkMenuBar]", host: { attributes: { "role": "menubar" }, listeners: { "keydown": "_handleKeyEvent($event)" }, classAttribute: "cdk-menu-bar" }, providers: [
+        { provide: CdkMenuGroup, useExisting: CdkMenuBar },
+        { provide: CDK_MENU, useExisting: CdkMenuBar },
+        { provide: MENU_STACK, useFactory: () => MenuStack.inline('horizontal') },
+    ], exportAs: ["cdkMenuBar"], usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: CdkMenuBar, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[cdkMenuBar]',
+                    exportAs: 'cdkMenuBar',
+                    standalone: true,
+                    host: {
+                        'role': 'menubar',
+                        'class': 'cdk-menu-bar',
+                        '(keydown)': '_handleKeyEvent($event)',
+                    },
+                    providers: [
+                        { provide: CdkMenuGroup, useExisting: CdkMenuBar },
+                        { provide: CDK_MENU, useExisting: CdkMenuBar },
+                        { provide: MENU_STACK, useFactory: () => MenuStack.inline('horizontal') },
+                    ],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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
Line truncated

front/app/node_modules/@angular/cdk/esm2020/menu/menu-base.mjs

@@ -0,0 +1,188 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { CdkMenuGroup } from './menu-group';
+import { ContentChildren, Directive, ElementRef, inject, Input, NgZone, QueryList, } from '@angular/core';
+import { FocusKeyManager } from '@angular/cdk/a11y';
+import { CdkMenuItem } from './menu-item';
+import { merge, Subject } from 'rxjs';
+import { Directionality } from '@angular/cdk/bidi';
+import { mapTo, mergeAll, mergeMap, startWith, switchMap, takeUntil } from 'rxjs/operators';
+import { MENU_STACK } from './menu-stack';
+import { PointerFocusTracker } from './pointer-focus-tracker';
+import { MENU_AIM } from './menu-aim';
+import * as i0 from "@angular/core";
+/** Counter used to create unique IDs for menus. */
+let nextId = 0;
+/**
+ * Abstract directive that implements shared logic common to all menus.
+ * This class can be extended to create custom menu types.
+ */
+export class CdkMenuBase extends CdkMenuGroup {
+    constructor() {
+        super(...arguments);
+        /** The menu's native DOM host element. */
+        this.nativeElement = inject(ElementRef).nativeElement;
+        /** The Angular zone. */
+        this.ngZone = inject(NgZone);
+        /** The stack of menus this menu belongs to. */
+        this.menuStack = inject(MENU_STACK);
+        /** The menu aim service used by this menu. */
+        this.menuAim = inject(MENU_AIM, { optional: true, self: true });
+        /** The directionality (text direction) of the current page. */
+        this.dir = inject(Directionality, { optional: true });
+        /** The id of the menu's host element. */
+        this.id = `cdk-menu-${nextId++}`;
+        /** The direction items in the menu flow. */
+        this.orientation = 'vertical';
+        /**
+         * Whether the menu is displayed inline (i.e. always present vs a conditional popup that the
+         * user triggers with a trigger element).
+         */
+        this.isInline = false;
+        /** Emits when the MenuBar is destroyed. */
+        this.destroyed = new Subject();
+        /** Whether this menu's menu stack has focus. */
+        this._menuStackHasFocus = false;
+    }
+    ngAfterContentInit() {
+        if (!this.isInline) {
+            this.menuStack.push(this);
+        }
+        this._setKeyManager();
+        this._subscribeToMenuStackHasFocus();
+        this._subscribeToMenuOpen();
+        this._subscribeToMenuStackClosed();
+        this._setUpPointerTracker();
+    }
+    ngOnDestroy() {
+        this.keyManager?.destroy();
+        this.destroyed.next();
+        this.destroyed.complete();
+        this.pointerTracker?.destroy();
+    }
+    /**
+     * Place focus on the first MenuItem in the menu and set the focus origin.
+     * @param focusOrigin The origin input mode of the focus event.
+     */
+    focusFirstItem(focusOrigin = 'program') {
+        this.keyManager.setFocusOrigin(focusOrigin);
+        this.keyManager.setFirstItemActive();
+    }
+    /**
+     * Place focus on the last MenuItem in the menu and set the focus origin.
+     * @param focusOrigin The origin input mode of the focus event.
+     */
+    focusLastItem(focusOrigin = 'program') {
+        this.keyManager.setFocusOrigin(focusOrigin);
+        this.keyManager.setLastItemActive();
+    }
+    /** Gets the tabindex for this menu. */
+    _getTabIndex() {
+        const tabindexIfInline = this._menuStackHasFocus ? -1 : 0;
+        return this.isInline ? tabindexIfInline : null;
+    }
+    /**
+     * Close the open menu if the current active item opened the requested MenuStackItem.
+     * @param menu The menu requested to be closed.
+     * @param options Options to configure the behavior on close.
+     *   - `focusParentTrigger` Whether to focus the parent trigger after closing the menu.
+     */
+    closeOpenMenu(menu, options) {
+        const { focusParentTrigger } = { ...options };
+        const keyManager = this.keyManager;
+        const trigger = this.triggerItem;
+        if (menu === trigger?.getMenuTrigger()?.getMenu()) {
+            trigger?.getMenuTrigger()?.close();
+            // If the user has moused over a sibling item we want to focus the element under mouse focus
+            // not the trigger which previously opened the now closed menu.
+            if (focusParentTrigger) {
+                if (trigger) {
+                    keyManager.setActiveItem(trigger);
+                }
+                else {
+                    keyManager.setFirstItemActive();
+                }
+            }
+        }
+    }
+    /** Setup the FocusKeyManager with the correct orientation for the menu. */
+    _setKeyManager() {
+        this.keyManager = new FocusKeyManager(this.items).withWrap().withTypeAhead().withHomeAndEnd();
+        if (this.orientation === 'horizontal') {
+            this.keyManager.withHorizontalOrientation(this.dir?.value || 'ltr');
+        }
+        else {
+            this.keyManager.withVerticalOrientation();
+        }
+    }
+    /**
+     * Subscribe to the menu trigger's open events in order to track the trigger which opened the menu
+     * and stop tracking it when the menu is closed.
+     */
+    _subscribeToMenuOpen() {
+        const exitCondition = merge(this.items.changes, this.destroyed);
+        this.items.changes
+            .pipe(startWith(this.items), mergeMap((list) => list
+            .filter(item => item.hasMenu)
+            .map(item => item.getMenuTrigger().opened.pipe(mapTo(item), takeUntil(exitCondition)))), mergeAll(), switchMap((item) => {
+            this.triggerItem = item;
+            return item.getMenuTrigger().closed;
+        }), takeUntil(this.destroyed))
+            .subscribe(() => (this.triggerItem = undefined));
+    }
+    /** Subscribe to the MenuStack close events. */
+    _subscribeToMenuStackClosed() {
+        this.menuStack.closed
+            .pipe(takeUntil(this.destroyed))
+            .subscribe(({ item, focusParentTrigger }) => this.closeOpenMenu(item, { focusParentTrigger }));
+    }
+    /** Subscribe to the MenuStack hasFocus events. */
+    _subscribeToMenuStackHasFocus() {
+        if (this.isInline) {
+            this.menuStack.hasFocus.pipe(takeUntil(this.destroyed)).subscribe(hasFocus => {
+                this._menuStackHasFocus = hasFocus;
+            });
+        }
+    }
+    /**
+     * Set the PointerFocusTracker and ensure that when mouse focus changes the key manager is updated
+     * with the latest menu item under mouse focus.
+     */
+    _setUpPointerTracker() {
+        if (this.menuAim) {
+            this.ngZone.runOutsideAngular(() => {
+                this.pointerTracker = new PointerFocusTracker(this.items);
+            });
+            this.menuAim.initialize(this, this.pointerTracker);
+        }
+    }
+}
+CdkMenuBase.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: CdkMenuBase, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+CdkMenuBase.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.0.0", type: CdkMenuBase, inputs: { id: "id" }, host: { attributes: { "role": "menu" }, listeners: { "focus": "focusFirstItem()", "focusin": "menuStack.setHasFocus(true)", "focusout": "menuStack.setHasFocus(false)" }, properties: { "tabindex": "_getTabIndex()", "id": "id", "attr.aria-orientation": "orientation", "attr.data-cdk-menu-stack-id": "menuStack.id" } }, queries: [{ propertyName: "items", predicate: CdkMenuItem, descendants: true }], usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: CdkMenuBase, decorators: [{
+            type: Directive,
+            args: [{
+                    host: {
+                        'role': 'menu',
+                        'class': '',
+                        '[tabindex]': '_getTabIndex()',
+                        '[id]': 'id',
+                        '[attr.aria-orientation]': 'orientation',
+                        '[attr.data-cdk-menu-stack-id]': 'menuStack.id',
+                        '(focus)': 'focusFirstItem()',
+                        '(focusin)': 'menuStack.setHasFocus(true)',
+                        '(focusout)': 'menuStack.setHasFocus(false)',
+                    },
+                }]
+        }], propDecorators: { id: [{
+                type: Input
+            }], items: [{
+                type: ContentChildren,
+                args: [CdkMenuItem, { descendants: true }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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
Line truncated

front/app/node_modules/@angular/cdk/esm2020/menu/menu-errors.mjs

@@ -0,0 +1,22 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+/**
+ * Throws an exception when an instance of the PointerFocusTracker is not provided.
+ * @docs-private
+ */
+export function throwMissingPointerFocusTracker() {
+    throw Error('expected an instance of PointerFocusTracker to be provided');
+}
+/**
+ * Throws an exception when a reference to the parent menu is not provided.
+ * @docs-private
+ */
+export function throwMissingMenuReference() {
+    throw Error('expected a reference to the parent menu');
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWVudS1lcnJvcnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvY2RrL21lbnUvbWVudS1lcnJvcnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztHQU1HO0FBRUg7OztHQUdHO0FBQ0gsTUFBTSxVQUFVLCtCQUErQjtJQUM3QyxNQUFNLEtBQUssQ0FBQyw0REFBNEQsQ0FBQyxDQUFDO0FBQzVFLENBQUM7QUFFRDs7O0dBR0c7QUFDSCxNQUFNLFVBQVUseUJBQXlCO0lBQ3ZDLE1BQU0sS0FBSyxDQUFDLHlDQUF5QyxDQUFDLENBQUM7QUFDekQsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgTExDIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG4vKipcbiAqIFRocm93cyBhbiBleGNlcHRpb24gd2hlbiBhbiBpbnN0YW5jZSBvZiB0aGUgUG9pbnRlckZvY3VzVHJhY2tlciBpcyBub3QgcHJvdmlkZWQuXG4gKiBAZG9jcy1wcml2YXRlXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiB0aHJvd01pc3NpbmdQb2ludGVyRm9jdXNUcmFja2VyKCkge1xuICB0aHJvdyBFcnJvcignZXhwZWN0ZWQgYW4gaW5zdGFuY2Ugb2YgUG9pbnRlckZvY3VzVHJhY2tlciB0byBiZSBwcm92aWRlZCcpO1xufVxuXG4vKipcbiAqIFRocm93cyBhbiBleGNlcHRpb24gd2hlbiBhIHJlZmVyZW5jZSB0byB0aGUgcGFyZW50IG1lbnUgaXMgbm90IHByb3ZpZGVkLlxuICogQGRvY3MtcHJpdmF0ZVxuICovXG5leHBvcnQgZnVuY3Rpb24gdGhyb3dNaXNzaW5nTWVudVJlZmVyZW5jZSgpIHtcbiAgdGhyb3cgRXJyb3IoJ2V4cGVjdGVkIGEgcmVmZXJlbmNlIHRvIHRoZSBwYXJlbnQgbWVudScpO1xufVxuIl19

front/app/node_modules/@angular/cdk/esm2020/menu/menu-group.mjs

@@ -0,0 +1,31 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { Directive } from '@angular/core';
+import { UniqueSelectionDispatcher } from '@angular/cdk/collections';
+import * as i0 from "@angular/core";
+/**
+ * A grouping container for `CdkMenuItemRadio` instances, similar to a `role="radiogroup"` element.
+ */
+export class CdkMenuGroup {
+}
+CdkMenuGroup.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: CdkMenuGroup, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+CdkMenuGroup.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.0.0", type: CdkMenuGroup, isStandalone: true, selector: "[cdkMenuGroup]", host: { attributes: { "role": "group" }, classAttribute: "cdk-menu-group" }, providers: [{ provide: UniqueSelectionDispatcher, useClass: UniqueSelectionDispatcher }], exportAs: ["cdkMenuGroup"], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: CdkMenuGroup, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[cdkMenuGroup]',
+                    exportAs: 'cdkMenuGroup',
+                    standalone: true,
+                    host: {
+                        'role': 'group',
+                        'class': 'cdk-menu-group',
+                    },
+                    providers: [{ provide: UniqueSelectionDispatcher, useClass: UniqueSelectionDispatcher }],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWVudS1ncm91cC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3NyYy9jZGsvbWVudS9tZW51LWdyb3VwLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7R0FNRztBQUVILE9BQU8sRUFBQyxTQUFTLEVBQUMsTUFBTSxlQUFlLENBQUM7QUFDeEMsT0FBTyxFQUFDLHlCQUF5QixFQUFDLE1BQU0sMEJBQTBCLENBQUM7O0FBRW5FOztHQUVHO0FBV0gsTUFBTSxPQUFPLFlBQVk7O3lHQUFaLFlBQVk7NkZBQVosWUFBWSwwSUFGWixDQUFDLEVBQUMsT0FBTyxFQUFFLHlCQUF5QixFQUFFLFFBQVEsRUFBRSx5QkFBeUIsRUFBQyxDQUFDOzJGQUUzRSxZQUFZO2tCQVZ4QixTQUFTO21CQUFDO29CQUNULFFBQVEsRUFBRSxnQkFBZ0I7b0JBQzFCLFFBQVEsRUFBRSxjQUFjO29CQUN4QixVQUFVLEVBQUUsSUFBSTtvQkFDaEIsSUFBSSxFQUFFO3dCQUNKLE1BQU0sRUFBRSxPQUFPO3dCQUNmLE9BQU8sRUFBRSxnQkFBZ0I7cUJBQzFCO29CQUNELFNBQVMsRUFBRSxDQUFDLEVBQUMsT0FBTyxFQUFFLHlCQUF5QixFQUFFLFFBQVEsRUFBRSx5QkFBeUIsRUFBQyxDQUFDO2lCQUN2RiIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgTExDIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG5pbXBvcnQge0RpcmVjdGl2ZX0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQge1VuaXF1ZVNlbGVjdGlvbkRpc3BhdGNoZXJ9IGZyb20gJ0Bhbmd1bGFyL2Nkay9jb2xsZWN0aW9ucyc7XG5cbi8qKlxuICogQSBncm91cGluZyBjb250YWluZXIgZm9yIGBDZGtNZW51SXRlbVJhZGlvYCBpbnN0YW5jZXMsIHNpbWlsYXIgdG8gYSBgcm9sZT1cInJhZGlvZ3JvdXBcImAgZWxlbWVudC5cbiAqL1xuQERpcmVjdGl2ZSh7XG4gIHNlbGVjdG9yOiAnW2Nka01lbnVHcm91cF0nLFxuICBleHBvcnRBczogJ2Nka01lbnVHcm91cCcsXG4gIHN0YW5kYWxvbmU6IHRydWUsXG4gIGhvc3Q6IHtcbiAgICAncm9sZSc6ICdncm91cCcsXG4gICAgJ2NsYXNzJzogJ2Nkay1tZW51LWdyb3VwJyxcbiAgfSxcbiAgcHJvdmlkZXJzOiBbe3Byb3ZpZGU6IFVuaXF1ZVNlbGVjdGlvbkRpc3BhdGNoZXIsIHVzZUNsYXNzOiBVbmlxdWVTZWxlY3Rpb25EaXNwYXRjaGVyfV0sXG59KVxuZXhwb3J0IGNsYXNzIENka01lbnVHcm91cCB7fVxuIl19

front/app/node_modules/@angular/cdk/esm2020/menu/menu-interface.mjs

@@ -0,0 +1,11 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { InjectionToken } from '@angular/core';
+/** Injection token used to return classes implementing the Menu interface */
+export const CDK_MENU = new InjectionToken('cdk-menu');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWVudS1pbnRlcmZhY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvY2RrL21lbnUvbWVudS1pbnRlcmZhY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztHQU1HO0FBRUgsT0FBTyxFQUFDLGNBQWMsRUFBQyxNQUFNLGVBQWUsQ0FBQztBQUk3Qyw2RUFBNkU7QUFDN0UsTUFBTSxDQUFDLE1BQU0sUUFBUSxHQUFHLElBQUksY0FBYyxDQUFPLFVBQVUsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IEdvb2dsZSBMTEMgQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbiAqXG4gKiBVc2Ugb2YgdGhpcyBzb3VyY2UgY29kZSBpcyBnb3Zlcm5lZCBieSBhbiBNSVQtc3R5bGUgbGljZW5zZSB0aGF0IGNhbiBiZVxuICogZm91bmQgaW4gdGhlIExJQ0VOU0UgZmlsZSBhdCBodHRwczovL2FuZ3VsYXIuaW8vbGljZW5zZVxuICovXG5cbmltcG9ydCB7SW5qZWN0aW9uVG9rZW59IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHtNZW51U3RhY2tJdGVtfSBmcm9tICcuL21lbnUtc3RhY2snO1xuaW1wb3J0IHtGb2N1c09yaWdpbn0gZnJvbSAnQGFuZ3VsYXIvY2RrL2ExMXknO1xuXG4vKiogSW5qZWN0aW9uIHRva2VuIHVzZWQgdG8gcmV0dXJuIGNsYXNzZXMgaW1wbGVtZW50aW5nIHRoZSBNZW51IGludGVyZmFjZSAqL1xuZXhwb3J0IGNvbnN0IENES19NRU5VID0gbmV3IEluamVjdGlvblRva2VuPE1lbnU+KCdjZGstbWVudScpO1xuXG4vKiogSW50ZXJmYWNlIHdoaWNoIHNwZWNpZmllcyBNZW51IG9wZXJhdGlvbnMgYW5kIHVzZWQgdG8gYnJlYWsgY2lyY3VsYXIgZGVwZW5kZW5jeSBpc3N1ZXMgKi9cbmV4cG9ydCBpbnRlcmZhY2UgTWVudSBleHRlbmRzIE1lbnVTdGFja0l0ZW0ge1xuICAvKiogVGhlIGlkIG9mIHRoZSBtZW51J3MgaG9zdCBlbGVtZW50LiAqL1xuICBpZDogc3RyaW5nO1xuXG4gIC8qKiBUaGUgbWVudSdzIG5hdGl2ZSBET00gaG9zdCBlbGVtZW50LiAqL1xuICBuYXRpdmVFbGVtZW50OiBIVE1MRWxlbWVudDtcblxuICAvKiogVGhlIGRpcmVjdGlvbiBpdGVtcyBpbiB0aGUgbWVudSBmbG93LiAqL1xuICByZWFkb25seSBvcmllbnRhdGlvbjogJ2hvcml6b250YWwnIHwgJ3ZlcnRpY2FsJztcblxuICAvKiogUGxhY2UgZm9jdXMgb24gdGhlIGZpcnN0IE1lbnVJdGVtIGluIHRoZSBtZW51LiAqL1xuICBmb2N1c0ZpcnN0SXRlbShmb2N1c09yaWdpbjogRm9jdXNPcmlnaW4pOiB2b2lkO1xuXG4gIC8qKiBQbGFjZSBmb2N1cyBvbiB0aGUgbGFzdCBNZW51SXRlbSBpbiB0aGUgbWVudS4gKi9cbiAgZm9jdXNMYXN0SXRlbShmb2N1c09yaWdpbjogRm9jdXNPcmlnaW4pOiB2b2lkO1xufVxuIl19

front/app/node_modules/@angular/cdk/esm2020/menu/menu-item-checkbox.mjs

@@ -0,0 +1,50 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { Directive } from '@angular/core';
+import { CdkMenuItemSelectable } from './menu-item-selectable';
+import { CdkMenuItem } from './menu-item';
+import * as i0 from "@angular/core";
+/**
+ * A directive providing behavior for the "menuitemcheckbox" ARIA role, which behaves similarly to a
+ * conventional checkbox.
+ */
+export class CdkMenuItemCheckbox extends CdkMenuItemSelectable {
+    /**
+     * Toggle the checked state of the checkbox.
+     * @param options Options the configure how the item is triggered
+     *   - keepOpen: specifies that the menu should be kept open after triggering the item.
+     */
+    trigger(options) {
+        super.trigger(options);
+        if (!this.disabled) {
+            this.checked = !this.checked;
+        }
+    }
+}
+CdkMenuItemCheckbox.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: CdkMenuItemCheckbox, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+CdkMenuItemCheckbox.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.0.0", type: CdkMenuItemCheckbox, isStandalone: true, selector: "[cdkMenuItemCheckbox]", host: { attributes: { "role": "menuitemcheckbox" }, properties: { "class.cdk-menu-item-checkbox": "true" } }, providers: [
+        { provide: CdkMenuItemSelectable, useExisting: CdkMenuItemCheckbox },
+        { provide: CdkMenuItem, useExisting: CdkMenuItemSelectable },
+    ], exportAs: ["cdkMenuItemCheckbox"], usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: CdkMenuItemCheckbox, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[cdkMenuItemCheckbox]',
+                    exportAs: 'cdkMenuItemCheckbox',
+                    standalone: true,
+                    host: {
+                        'role': 'menuitemcheckbox',
+                        '[class.cdk-menu-item-checkbox]': 'true',
+                    },
+                    providers: [
+                        { provide: CdkMenuItemSelectable, useExisting: CdkMenuItemCheckbox },
+                        { provide: CdkMenuItem, useExisting: CdkMenuItemSelectable },
+                    ],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

front/app/node_modules/@angular/cdk/esm2020/menu/menu-item-radio.mjs

@@ -0,0 +1,72 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { UniqueSelectionDispatcher } from '@angular/cdk/collections';
+import { Directive, inject } from '@angular/core';
+import { CdkMenuItemSelectable } from './menu-item-selectable';
+import { CdkMenuItem } from './menu-item';
+import * as i0 from "@angular/core";
+/** Counter used to set a unique id and name for a selectable item */
+let nextId = 0;
+/**
+ * A directive providing behavior for the "menuitemradio" ARIA role, which behaves similarly to
+ * a conventional radio-button. Any sibling `CdkMenuItemRadio` instances within the same `CdkMenu`
+ * or `CdkMenuGroup` comprise a radio group with unique selection enforced.
+ */
+export class CdkMenuItemRadio extends CdkMenuItemSelectable {
+    constructor() {
+        super();
+        /** The unique selection dispatcher for this radio's `CdkMenuGroup`. */
+        this._selectionDispatcher = inject(UniqueSelectionDispatcher);
+        /** An ID to identify this radio item to the `UniqueSelectionDispatcher`. */
+        this._id = `${nextId++}`;
+        this._registerDispatcherListener();
+    }
+    ngOnDestroy() {
+        super.ngOnDestroy();
+        this._removeDispatcherListener();
+    }
+    /**
+     * Toggles the checked state of the radio-button.
+     * @param options Options the configure how the item is triggered
+     *   - keepOpen: specifies that the menu should be kept open after triggering the item.
+     */
+    trigger(options) {
+        super.trigger(options);
+        if (!this.disabled) {
+            this._selectionDispatcher.notify(this._id, '');
+        }
+    }
+    /** Configure the unique selection dispatcher listener in order to toggle the checked state  */
+    _registerDispatcherListener() {
+        this._removeDispatcherListener = this._selectionDispatcher.listen((id) => {
+            this.checked = this._id === id;
+        });
+    }
+}
+CdkMenuItemRadio.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: CdkMenuItemRadio, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+CdkMenuItemRadio.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.0.0", type: CdkMenuItemRadio, isStandalone: true, selector: "[cdkMenuItemRadio]", host: { attributes: { "role": "menuitemradio" }, properties: { "class.cdk-menu-item-radio": "true" } }, providers: [
+        { provide: CdkMenuItemSelectable, useExisting: CdkMenuItemRadio },
+        { provide: CdkMenuItem, useExisting: CdkMenuItemSelectable },
+    ], exportAs: ["cdkMenuItemRadio"], usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: CdkMenuItemRadio, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[cdkMenuItemRadio]',
+                    exportAs: 'cdkMenuItemRadio',
+                    standalone: true,
+                    host: {
+                        'role': 'menuitemradio',
+                        '[class.cdk-menu-item-radio]': 'true',
+                    },
+                    providers: [
+                        { provide: CdkMenuItemSelectable, useExisting: CdkMenuItemRadio },
+                        { provide: CdkMenuItem, useExisting: CdkMenuItemSelectable },
+                    ],
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,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
Line truncated

front/app/node_modules/@angular/cdk/esm2020/menu/menu-item-selectable.mjs

@@ -0,0 +1,42 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { coerceBooleanProperty } from '@angular/cdk/coercion';
+import { Directive, Input } from '@angular/core';
+import { CdkMenuItem } from './menu-item';
+import * as i0 from "@angular/core";
+/** Base class providing checked state for selectable MenuItems. */
+export class CdkMenuItemSelectable extends CdkMenuItem {
+    constructor() {
+        super(...arguments);
+        this._checked = false;
+        /** Whether the item should close the menu if triggered by the spacebar. */
+        this.closeOnSpacebarTrigger = false;
+    }
+    /** Whether the element is checked */
+    get checked() {
+        return this._checked;
+    }
+    set checked(value) {
+        this._checked = coerceBooleanProperty(value);
+    }
+}
+CdkMenuItemSelectable.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: CdkMenuItemSelectable, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+CdkMenuItemSelectable.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.0.0", type: CdkMenuItemSelectable, inputs: { checked: ["cdkMenuItemChecked", "checked"] }, host: { properties: { "attr.aria-checked": "!!checked", "attr.aria-disabled": "disabled || null" } }, usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: CdkMenuItemSelectable, decorators: [{
+            type: Directive,
+            args: [{
+                    host: {
+                        '[attr.aria-checked]': '!!checked',
+                        '[attr.aria-disabled]': 'disabled || null',
+                    },
+                }]
+        }], propDecorators: { checked: [{
+                type: Input,
+                args: ['cdkMenuItemChecked']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

front/app/node_modules/@angular/cdk/esm2020/menu/menu-item.mjs

@@ -0,0 +1,269 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { Directive, ElementRef, EventEmitter, inject, Input, NgZone, Output, } from '@angular/core';
+import { coerceBooleanProperty } from '@angular/cdk/coercion';
+import { ENTER, hasModifierKey, LEFT_ARROW, RIGHT_ARROW, SPACE } from '@angular/cdk/keycodes';
+import { Directionality } from '@angular/cdk/bidi';
+import { fromEvent, Subject } from 'rxjs';
+import { filter, takeUntil } from 'rxjs/operators';
+import { CdkMenuTrigger } from './menu-trigger';
+import { CDK_MENU } from './menu-interface';
+import { MENU_STACK } from './menu-stack';
+import { MENU_AIM } from './menu-aim';
+import * as i0 from "@angular/core";
+/**
+ * Directive which provides the ability for an element to be focused and navigated to using the
+ * keyboard when residing in a CdkMenu, CdkMenuBar, or CdkMenuGroup. It performs user defined
+ * behavior when clicked.
+ */
+export class CdkMenuItem {
+    constructor() {
+        /** The directionality (text direction) of the current page. */
+        this._dir = inject(Directionality, { optional: true });
+        /** The menu's native DOM host element. */
+        this._elementRef = inject(ElementRef);
+        /** The Angular zone. */
+        this._ngZone = inject(NgZone);
+        /** The menu aim service used by this menu. */
+        this._menuAim = inject(MENU_AIM, { optional: true });
+        /** The stack of menus this menu belongs to. */
+        this._menuStack = inject(MENU_STACK);
+        /** The parent menu in which this menuitem resides. */
+        this._parentMenu = inject(CDK_MENU, { optional: true });
+        /** Reference to the CdkMenuItemTrigger directive if one is added to the same element */
+        this._menuTrigger = inject(CdkMenuTrigger, { optional: true, self: true });
+        this._disabled = false;
+        /**
+         * If this MenuItem is a regular MenuItem, outputs when it is triggered by a keyboard or mouse
+         * event.
+         */
+        this.triggered = new EventEmitter();
+        /** Whether the menu item opens a menu. */
+        this.hasMenu = !!this._menuTrigger;
+        /**
+         * The tabindex for this menu item managed internally and used for implementing roving a
+         * tab index.
+         */
+        this._tabindex = -1;
+        /** Whether the item should close the menu if triggered by the spacebar. */
+        this.closeOnSpacebarTrigger = true;
+        /** Emits when the menu item is destroyed. */
+        this.destroyed = new Subject();
+        this._setupMouseEnter();
+        this._setType();
+        if (this._isStandaloneItem()) {
+            this._tabindex = 0;
+        }
+    }
+    /**  Whether the CdkMenuItem is disabled - defaults to false */
+    get disabled() {
+        return this._disabled;
+    }
+    set disabled(value) {
+        this._disabled = coerceBooleanProperty(value);
+    }
+    ngOnDestroy() {
+        this.destroyed.next();
+        this.destroyed.complete();
+    }
+    /** Place focus on the element. */
+    focus() {
+        this._elementRef.nativeElement.focus();
+    }
+    /**
+     * If the menu item is not disabled and the element does not have a menu trigger attached, emit
+     * on the cdkMenuItemTriggered emitter and close all open menus.
+     * @param options Options the configure how the item is triggered
+     *   - keepOpen: specifies that the menu should be kept open after triggering the item.
+     */
+    trigger(options) {
+        const { keepOpen } = { ...options };
+        if (!this.disabled && !this.hasMenu) {
+            this.triggered.next();
+            if (!keepOpen) {
+                this._menuStack.closeAll({ focusParentTrigger: true });
+            }
+        }
+    }
+    /** Return true if this MenuItem has an attached menu and it is open. */
+    isMenuOpen() {
+        return !!this._menuTrigger?.isOpen();
+    }
+    /**
+     * Get a reference to the rendered Menu if the Menu is open and it is visible in the DOM.
+     * @return the menu if it is open, otherwise undefined.
+     */
+    getMenu() {
+        return this._menuTrigger?.getMenu();
+    }
+    /** Get the CdkMenuTrigger associated with this element. */
+    getMenuTrigger() {
+        return this._menuTrigger;
+    }
+    /** Get the label for this element which is required by the FocusableOption interface. */
+    getLabel() {
+        return this.typeaheadLabel || this._elementRef.nativeElement.textContent?.trim() || '';
+    }
+    /** Reset the tabindex to -1. */
+    _resetTabIndex() {
+        if (!this._isStandaloneItem()) {
+            this._tabindex = -1;
+        }
+    }
+    /**
+     * Set the tab index to 0 if not disabled and it's a focus event, or a mouse enter if this element
+     * is not in a menu bar.
+     */
+    _setTabIndex(event) {
+        if (this.disabled) {
+            return;
+        }
+        // don't set the tabindex if there are no open sibling or parent menus
+        if (!event || !this._menuStack.isEmpty()) {
+            this._tabindex = 0;
+        }
+    }
+    /**
+     * Handles keyboard events for the menu item, specifically either triggering the user defined
+     * callback or opening/closing the current menu based on whether the left or right arrow key was
+     * pressed.
+     * @param event the keyboard event to handle
+     */
+    _onKeydown(event) {
+        switch (event.keyCode) {
+            case SPACE:
+            case ENTER:
+                if (!hasModifierKey(event)) {
+                    event.preventDefault();
+                    this.trigger({ keepOpen: event.keyCode === SPACE && !this.closeOnSpacebarTrigger });
+                }
+                break;
+            case RIGHT_ARROW:
+                if (!hasModifierKey(event)) {
+                    if (this._parentMenu && this._isParentVertical()) {
+                        if (this._dir?.value !== 'rtl') {
+                            this._forwardArrowPressed(event);
+                        }
+                        else {
+                            this._backArrowPressed(event);
+                        }
+                    }
+                }
+                break;
+            case LEFT_ARROW:
+                if (!hasModifierKey(event)) {
+                    if (this._parentMenu && this._isParentVertical()) {
+                        if (this._dir?.value !== 'rtl') {
+                            this._backArrowPressed(event);
+                        }
+                        else {
+                            this._forwardArrowPressed(event);
+                        }
+                    }
+                }
+                break;
+        }
+    }
+    /** Whether this menu item is standalone or within a menu or menu bar. */
+    _isStandaloneItem() {
+        return !this._parentMenu;
+    }
+    /**
+     * Handles the user pressing the back arrow key.
+     * @param event The keyboard event.
+     */
+    _backArrowPressed(event) {
+        const parentMenu = this._parentMenu;
+        if (this._menuStack.hasInlineMenu() || this._menuStack.length() > 1) {
+            event.preventDefault();
+            this._menuStack.close(parentMenu, {
+                focusNextOnEmpty: this._menuStack.inlineMenuOrientation() === 'horizontal'
+                    ? 1 /* FocusNext.previousItem */
+                    : 2 /* FocusNext.currentItem */,
+                focusParentTrigger: true,
+            });
+        }
+    }
+    /**
+     * Handles the user pressing the forward arrow key.
+     * @param event The keyboard event.
+     */
+    _forwardArrowPressed(event) {
+        if (!this.hasMenu && this._menuStack.inlineMenuOrientation() === 'horizontal') {
+            event.preventDefault();
+            this._menuStack.closeAll({
+                focusNextOnEmpty: 0 /* FocusNext.nextItem */,
+                focusParentTrigger: true,
+            });
+        }
+    }
+    /**
+     * Subscribe to the mouseenter events and close any sibling menu items if this element is moused
+     * into.
+     */
+    _setupMouseEnter() {
+        if (!this._isStandaloneItem()) {
+            const closeOpenSiblings = () => this._ngZone.run(() => this._menuStack.closeSubMenuOf(this._parentMenu));
+            this._ngZone.runOutsideAngular(() => fromEvent(this._elementRef.nativeElement, 'mouseenter')
+                .pipe(filter(() => !this._menuStack.isEmpty() && !this.hasMenu), takeUntil(this.destroyed))
+                .subscribe(() => {
+                if (this._menuAim) {
+                    this._menuAim.toggle(closeOpenSiblings);
+                }
+                else {
+                    closeOpenSiblings();
+                }
+            }));
+        }
+    }
+    /**
+     * Return true if the enclosing parent menu is configured in a horizontal orientation, false
+     * otherwise or if no parent.
+     */
+    _isParentVertical() {
+        return this._parentMenu?.orientation === 'vertical';
+    }
+    /** Sets the `type` attribute of the menu item. */
+    _setType() {
+        const element = this._elementRef.nativeElement;
+        if (element.nodeName === 'BUTTON' && !element.getAttribute('type')) {
+            // Prevent form submissions.
+            element.setAttribute('type', 'button');
+        }
+    }
+}
+CdkMenuItem.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: CdkMenuItem, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+CdkMenuItem.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.0.0", type: CdkMenuItem, isStandalone: true, selector: "[cdkMenuItem]", inputs: { disabled: ["cdkMenuItemDisabled", "disabled"], typeaheadLabel: ["cdkMenuitemTypeaheadLabel", "typeaheadLabel"] }, outputs: { triggered: "cdkMenuItemTriggered" }, host: { attributes: { "role": "menuitem" }, listeners: { "blur": "_resetTabIndex()", "focus": "_setTabIndex()", "click": "trigger()", "keydown": "_onKeydown($event)" }, properties: { "tabindex": "_tabindex", "attr.aria-disabled": "disabled || null" }, classAttribute: "cdk-menu-item" }, exportAs: ["cdkMenuItem"], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: CdkMenuItem, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[cdkMenuItem]',
+                    exportAs: 'cdkMenuItem',
+                    standalone: true,
+                    host: {
+                        'role': 'menuitem',
+                        'class': 'cdk-menu-item',
+                        '[tabindex]': '_tabindex',
+                        '[attr.aria-disabled]': 'disabled || null',
+                        '(blur)': '_resetTabIndex()',
+                        '(focus)': '_setTabIndex()',
+                        '(click)': 'trigger()',
+                        '(keydown)': '_onKeydown($event)',
+                    },
+                }]
+        }], ctorParameters: function () { return []; }, propDecorators: { disabled: [{
+                type: Input,
+                args: ['cdkMenuItemDisabled']
+            }], typeaheadLabel: [{
+                type: Input,
+                args: ['cdkMenuitemTypeaheadLabel']
+            }], triggered: [{
+                type: Output,
+                args: ['cdkMenuItemTriggered']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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
Line truncated

front/app/node_modules/@angular/cdk/esm2020/menu/menu-module.mjs

@@ -0,0 +1,60 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { NgModule } from '@angular/core';
+import { OverlayModule } from '@angular/cdk/overlay';
+import { CdkMenu } from './menu';
+import { CdkMenuBar } from './menu-bar';
+import { CdkMenuItem } from './menu-item';
+import { CdkMenuGroup } from './menu-group';
+import { CdkMenuItemRadio } from './menu-item-radio';
+import { CdkMenuItemCheckbox } from './menu-item-checkbox';
+import { CdkMenuTrigger } from './menu-trigger';
+import { CdkContextMenuTrigger } from './context-menu-trigger';
+import { CdkTargetMenuAim } from './menu-aim';
+import * as i0 from "@angular/core";
+const MENU_DIRECTIVES = [
+    CdkMenuBar,
+    CdkMenu,
+    CdkMenuItem,
+    CdkMenuItemRadio,
+    CdkMenuItemCheckbox,
+    CdkMenuTrigger,
+    CdkMenuGroup,
+    CdkContextMenuTrigger,
+    CdkTargetMenuAim,
+];
+/** Module that declares components and directives for the CDK menu. */
+export class CdkMenuModule {
+}
+CdkMenuModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: CdkMenuModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+CdkMenuModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.0.0", ngImport: i0, type: CdkMenuModule, imports: [OverlayModule, CdkMenuBar,
+        CdkMenu,
+        CdkMenuItem,
+        CdkMenuItemRadio,
+        CdkMenuItemCheckbox,
+        CdkMenuTrigger,
+        CdkMenuGroup,
+        CdkContextMenuTrigger,
+        CdkTargetMenuAim], exports: [CdkMenuBar,
+        CdkMenu,
+        CdkMenuItem,
+        CdkMenuItemRadio,
+        CdkMenuItemCheckbox,
+        CdkMenuTrigger,
+        CdkMenuGroup,
+        CdkContextMenuTrigger,
+        CdkTargetMenuAim] });
+CdkMenuModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: CdkMenuModule, imports: [OverlayModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: CdkMenuModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [OverlayModule, ...MENU_DIRECTIVES],
+                    exports: MENU_DIRECTIVES,
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

front/app/node_modules/@angular/cdk/esm2020/menu/menu-stack.mjs

@@ -0,0 +1,156 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { Inject, Injectable, InjectionToken, Optional, SkipSelf } from '@angular/core';
+import { Subject } from 'rxjs';
+import { debounceTime, distinctUntilChanged, startWith } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+/** Injection token used for an implementation of MenuStack. */
+export const MENU_STACK = new InjectionToken('cdk-menu-stack');
+/** Provider that provides the parent menu stack, or a new menu stack if there is no parent one. */
+export const PARENT_OR_NEW_MENU_STACK_PROVIDER = {
+    provide: MENU_STACK,
+    deps: [[new Optional(), new SkipSelf(), new Inject(MENU_STACK)]],
+    useFactory: (parentMenuStack) => parentMenuStack || new MenuStack(),
+};
+/** Provider that provides the parent menu stack, or a new inline menu stack if there is no parent one. */
+export const PARENT_OR_NEW_INLINE_MENU_STACK_PROVIDER = (orientation) => ({
+    provide: MENU_STACK,
+    deps: [[new Optional(), new SkipSelf(), new Inject(MENU_STACK)]],
+    useFactory: (parentMenuStack) => parentMenuStack || MenuStack.inline(orientation),
+});
+/** The next available menu stack ID. */
+let nextId = 0;
+/**
+ * MenuStack allows subscribers to listen for close events (when a MenuStackItem is popped off
+ * of the stack) in order to perform closing actions. Upon the MenuStack being empty it emits
+ * from the `empty` observable specifying the next focus action which the listener should perform
+ * as requested by the closer.
+ */
+export class MenuStack {
+    constructor() {
+        /** The ID of this menu stack. */
+        this.id = `${nextId++}`;
+        /** All MenuStackItems tracked by this MenuStack. */
+        this._elements = [];
+        /** Emits the element which was popped off of the stack when requested by a closer. */
+        this._close = new Subject();
+        /** Emits once the MenuStack has become empty after popping off elements. */
+        this._empty = new Subject();
+        /** Emits whether any menu in the menu stack has focus. */
+        this._hasFocus = new Subject();
+        /** Observable which emits the MenuStackItem which has been requested to close. */
+        this.closed = this._close;
+        /** Observable which emits whether any menu in the menu stack has focus. */
+        this.hasFocus = this._hasFocus.pipe(startWith(false), debounceTime(0), distinctUntilChanged());
+        /**
+         * Observable which emits when the MenuStack is empty after popping off the last element. It
+         * emits a FocusNext event which specifies the action the closer has requested the listener
+         * perform.
+         */
+        this.emptied = this._empty;
+        /**
+         * Whether the inline menu associated with this menu stack is vertical or horizontal.
+         * `null` indicates there is no inline menu associated with this menu stack.
+         */
+        this._inlineMenuOrientation = null;
+    }
+    /** Creates a menu stack that originates from an inline menu. */
+    static inline(orientation) {
+        const stack = new MenuStack();
+        stack._inlineMenuOrientation = orientation;
+        return stack;
+    }
+    /**
+     * Adds an item to the menu stack.
+     * @param menu the MenuStackItem to put on the stack.
+     */
+    push(menu) {
+        this._elements.push(menu);
+    }
+    /**
+     * Pop items off of the stack up to and including `lastItem` and emit each on the close
+     * observable. If the stack is empty or `lastItem` is not on the stack it does nothing.
+     * @param lastItem the last item to pop off the stack.
+     * @param options Options that configure behavior on close.
+     */
+    close(lastItem, options) {
+        const { focusNextOnEmpty, focusParentTrigger } = { ...options };
+        if (this._elements.indexOf(lastItem) >= 0) {
+            let poppedElement;
+            do {
+                poppedElement = this._elements.pop();
+                this._close.next({ item: poppedElement, focusParentTrigger });
+            } while (poppedElement !== lastItem);
+            if (this.isEmpty()) {
+                this._empty.next(focusNextOnEmpty);
+            }
+        }
+    }
+    /**
+     * Pop items off of the stack up to but excluding `lastItem` and emit each on the close
+     * observable. If the stack is empty or `lastItem` is not on the stack it does nothing.
+     * @param lastItem the element which should be left on the stack
+     * @return whether or not an item was removed from the stack
+     */
+    closeSubMenuOf(lastItem) {
+        let removed = false;
+        if (this._elements.indexOf(lastItem) >= 0) {
+            removed = this.peek() !== lastItem;
+            while (this.peek() !== lastItem) {
+                this._close.next({ item: this._elements.pop() });
+            }
+        }
+        return removed;
+    }
+    /**
+     * Pop off all MenuStackItems and emit each one on the `close` observable one by one.
+     * @param options Options that configure behavior on close.
+     */
+    closeAll(options) {
+        const { focusNextOnEmpty, focusParentTrigger } = { ...options };
+        if (!this.isEmpty()) {
+            while (!this.isEmpty()) {
+                const menuStackItem = this._elements.pop();
+                if (menuStackItem) {
+                    this._close.next({ item: menuStackItem, focusParentTrigger });
+                }
+            }
+            this._empty.next(focusNextOnEmpty);
+        }
+    }
+    /** Return true if this stack is empty. */
+    isEmpty() {
+        return !this._elements.length;
+    }
+    /** Return the length of the stack. */
+    length() {
+        return this._elements.length;
+    }
+    /** Get the top most element on the stack. */
+    peek() {
+        return this._elements[this._elements.length - 1];
+    }
+    /** Whether the menu stack is associated with an inline menu. */
+    hasInlineMenu() {
+        return this._inlineMenuOrientation != null;
+    }
+    /** The orientation of the associated inline menu. */
+    inlineMenuOrientation() {
+        return this._inlineMenuOrientation;
+    }
+    /** Sets whether the menu stack contains the focused element. */
+    setHasFocus(hasFocus) {
+        this._hasFocus.next(hasFocus);
+    }
+}
+MenuStack.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: MenuStack, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+MenuStack.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: MenuStack });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: MenuStack, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,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
Line truncated

front/app/node_modules/@angular/cdk/esm2020/menu/menu-trigger-base.mjs

@@ -0,0 +1,107 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { Directive, EventEmitter, inject, InjectionToken, Injector, ViewContainerRef, } from '@angular/core';
+import { MENU_STACK } from './menu-stack';
+import { TemplatePortal } from '@angular/cdk/portal';
+import { merge, Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+/** Injection token used for an implementation of MenuStack. */
+export const MENU_TRIGGER = new InjectionToken('cdk-menu-trigger');
+/**
+ * Abstract directive that implements shared logic common to all menu triggers.
+ * This class can be extended to create custom menu trigger types.
+ */
+export class CdkMenuTriggerBase {
+    constructor() {
+        /** The DI injector for this component. */
+        this.injector = inject(Injector);
+        /** The view container ref for this component */
+        this.viewContainerRef = inject(ViewContainerRef);
+        /** The menu stack in which this menu resides. */
+        this.menuStack = inject(MENU_STACK);
+        /** Emits when the attached menu is requested to open */
+        this.opened = new EventEmitter();
+        /** Emits when the attached menu is requested to close */
+        this.closed = new EventEmitter();
+        /** A reference to the overlay which manages the triggered menu */
+        this.overlayRef = null;
+        /** Emits when this trigger is destroyed. */
+        this.destroyed = new Subject();
+        /** Emits when the outside pointer events listener on the overlay should be stopped. */
+        this.stopOutsideClicksListener = merge(this.closed, this.destroyed);
+    }
+    ngOnDestroy() {
+        this._destroyOverlay();
+        this.destroyed.next();
+        this.destroyed.complete();
+    }
+    /** Whether the attached menu is open. */
+    isOpen() {
+        return !!this.overlayRef?.hasAttached();
+    }
+    /** Registers a child menu as having been opened by this trigger. */
+    registerChildMenu(child) {
+        this.childMenu = child;
+    }
+    /**
+     * Get the portal to be attached to the overlay which contains the menu. Allows for the menu
+     * content to change dynamically and be reflected in the application.
+     */
+    getMenuContentPortal() {
+        const hasMenuContentChanged = this.menuTemplateRef !== this._menuPortal?.templateRef;
+        if (this.menuTemplateRef && (!this._menuPortal || hasMenuContentChanged)) {
+            this._menuPortal = new TemplatePortal(this.menuTemplateRef, this.viewContainerRef, this.menuData, this._getChildMenuInjector());
+        }
+        return this._menuPortal;
+    }
+    /**
+     * Whether the given element is inside the scope of this trigger's menu stack.
+     * @param element The element to check.
+     * @return Whether the element is inside the scope of this trigger's menu stack.
+     */
+    isElementInsideMenuStack(element) {
+        for (let el = element; el; el = el?.parentElement ?? null) {
+            if (el.getAttribute('data-cdk-menu-stack-id') === this.menuStack.id) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /** Destroy and unset the overlay reference it if exists */
+    _destroyOverlay() {
+        if (this.overlayRef) {
+            this.overlayRef.dispose();
+            this.overlayRef = null;
+        }
+    }
+    /** Gets the injector to use when creating a child menu. */
+    _getChildMenuInjector() {
+        this._childMenuInjector =
+            this._childMenuInjector ||
+                Injector.create({
+                    providers: [
+                        { provide: MENU_TRIGGER, useValue: this },
+                        { provide: MENU_STACK, useValue: this.menuStack },
+                    ],
+                    parent: this.injector,
+                });
+        return this._childMenuInjector;
+    }
+}
+CdkMenuTriggerBase.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: CdkMenuTriggerBase, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+CdkMenuTriggerBase.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.0.0", type: CdkMenuTriggerBase, host: { properties: { "attr.aria-controls": "childMenu?.id", "attr.data-cdk-menu-stack-id": "menuStack.id" } }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: CdkMenuTriggerBase, decorators: [{
+            type: Directive,
+            args: [{
+                    host: {
+                        '[attr.aria-controls]': 'childMenu?.id',
+                        '[attr.data-cdk-menu-stack-id]': 'menuStack.id',
+                    },
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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
Line truncated

front/app/node_modules/@angular/cdk/esm2020/menu/menu-trigger.mjs

@@ -0,0 +1,300 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { Directive, ElementRef, inject, NgZone } from '@angular/core';
+import { Directionality } from '@angular/cdk/bidi';
+import { Overlay, OverlayConfig, STANDARD_DROPDOWN_ADJACENT_POSITIONS, STANDARD_DROPDOWN_BELOW_POSITIONS, } from '@angular/cdk/overlay';
+import { DOWN_ARROW, ENTER, hasModifierKey, LEFT_ARROW, RIGHT_ARROW, SPACE, UP_ARROW, } from '@angular/cdk/keycodes';
+import { _getEventTarget } from '@angular/cdk/platform';
+import { fromEvent } from 'rxjs';
+import { filter, takeUntil } from 'rxjs/operators';
+import { CDK_MENU } from './menu-interface';
+import { PARENT_OR_NEW_MENU_STACK_PROVIDER } from './menu-stack';
+import { MENU_AIM } from './menu-aim';
+import { CdkMenuTriggerBase, MENU_TRIGGER } from './menu-trigger-base';
+import * as i0 from "@angular/core";
+/**
+ * A directive that turns its host element into a trigger for a popup menu.
+ * It can be combined with cdkMenuItem to create sub-menus. If the element is in a top level
+ * MenuBar it will open the menu on click, or if a sibling is already opened it will open on hover.
+ * If it is inside of a Menu it will open the attached Submenu on hover regardless of its sibling
+ * state.
+ */
+export class CdkMenuTrigger extends CdkMenuTriggerBase {
+    constructor() {
+        super();
+        /** The host element. */
+        this._elementRef = inject(ElementRef);
+        /** The CDK overlay service. */
+        this._overlay = inject(Overlay);
+        /** The Angular zone. */
+        this._ngZone = inject(NgZone);
+        /** The parent menu this trigger belongs to. */
+        this._parentMenu = inject(CDK_MENU, { optional: true });
+        /** The menu aim service used by this menu. */
+        this._menuAim = inject(MENU_AIM, { optional: true });
+        /** The directionality of the page. */
+        this._directionality = inject(Directionality, { optional: true });
+        this._setRole();
+        this._registerCloseHandler();
+        this._subscribeToMenuStackClosed();
+        this._subscribeToMouseEnter();
+        this._subscribeToMenuStackHasFocus();
+        this._setType();
+    }
+    /** Toggle the attached menu. */
+    toggle() {
+        this.isOpen() ? this.close() : this.open();
+    }
+    /** Open the attached menu. */
+    open() {
+        if (!this.isOpen()) {
+            this.opened.next();
+            this.overlayRef = this.overlayRef || this._overlay.create(this._getOverlayConfig());
+            this.overlayRef.attach(this.getMenuContentPortal());
+            this._subscribeToOutsideClicks();
+        }
+    }
+    /** Close the opened menu. */
+    close() {
+        if (this.isOpen()) {
+            this.closed.next();
+            this.overlayRef.detach();
+        }
+        this._closeSiblingTriggers();
+    }
+    /**
+     * Get a reference to the rendered Menu if the Menu is open and rendered in the DOM.
+     */
+    getMenu() {
+        return this.childMenu;
+    }
+    /**
+     * Handles keyboard events for the menu item.
+     * @param event The keyboard event to handle
+     */
+    _toggleOnKeydown(event) {
+        const isParentVertical = this._parentMenu?.orientation === 'vertical';
+        switch (event.keyCode) {
+            case SPACE:
+            case ENTER:
+                if (!hasModifierKey(event)) {
+                    event.preventDefault();
+                    this.toggle();
+                    this.childMenu?.focusFirstItem('keyboard');
+                }
+                break;
+            case RIGHT_ARROW:
+                if (!hasModifierKey(event)) {
+                    if (this._parentMenu && isParentVertical && this._directionality?.value !== 'rtl') {
+                        event.preventDefault();
+                        this.open();
+                        this.childMenu?.focusFirstItem('keyboard');
+                    }
+                }
+                break;
+            case LEFT_ARROW:
+                if (!hasModifierKey(event)) {
+                    if (this._parentMenu && isParentVertical && this._directionality?.value === 'rtl') {
+                        event.preventDefault();
+                        this.open();
+                        this.childMenu?.focusFirstItem('keyboard');
+                    }
+                }
+                break;
+            case DOWN_ARROW:
+            case UP_ARROW:
+                if (!hasModifierKey(event)) {
+                    if (!isParentVertical) {
+                        event.preventDefault();
+                        this.open();
+                        event.keyCode === DOWN_ARROW
+                            ? this.childMenu?.focusFirstItem('keyboard')
+                            : this.childMenu?.focusLastItem('keyboard');
+                    }
+                }
+                break;
+        }
+    }
+    /**
+     * Sets whether the trigger's menu stack has focus.
+     * @param hasFocus Whether the menu stack has focus.
+     */
+    _setHasFocus(hasFocus) {
+        if (!this._parentMenu) {
+            this.menuStack.setHasFocus(hasFocus);
+        }
+    }
+    /**
+     * Subscribe to the mouseenter events and close any sibling menu items if this element is moused
+     * into.
+     */
+    _subscribeToMouseEnter() {
+        this._ngZone.runOutsideAngular(() => {
+            fromEvent(this._elementRef.nativeElement, 'mouseenter')
+                .pipe(filter(() => !this.menuStack.isEmpty() && !this.isOpen()), takeUntil(this.destroyed))
+                .subscribe(() => {
+                // Closes any sibling menu items and opens the menu associated with this trigger.
+                const toggleMenus = () => this._ngZone.run(() => {
+                    this._closeSiblingTriggers();
+                    this.open();
+                });
+                if (this._menuAim) {
+                    this._menuAim.toggle(toggleMenus);
+                }
+                else {
+                    toggleMenus();
+                }
+            });
+        });
+    }
+    /** Close out any sibling menu trigger menus. */
+    _closeSiblingTriggers() {
+        if (this._parentMenu) {
+            // If nothing was removed from the stack and the last element is not the parent item
+            // that means that the parent menu is a menu bar since we don't put the menu bar on the
+            // stack
+            const isParentMenuBar = !this.menuStack.closeSubMenuOf(this._parentMenu) &&
+                this.menuStack.peek() !== this._parentMenu;
+            if (isParentMenuBar) {
+                this.menuStack.closeAll();
+            }
+        }
+        else {
+            this.menuStack.closeAll();
+        }
+    }
+    /** Get the configuration object used to create the overlay. */
+    _getOverlayConfig() {
+        return new OverlayConfig({
+            positionStrategy: this._getOverlayPositionStrategy(),
+            scrollStrategy: this._overlay.scrollStrategies.reposition(),
+            direction: this._directionality || undefined,
+        });
+    }
+    /** Build the position strategy for the overlay which specifies where to place the menu. */
+    _getOverlayPositionStrategy() {
+        return this._overlay
+            .position()
+            .flexibleConnectedTo(this._elementRef)
+            .withLockedPosition()
+            .withGrowAfterOpen()
+            .withPositions(this._getOverlayPositions());
+    }
+    /** Get the preferred positions for the opened menu relative to the menu item. */
+    _getOverlayPositions() {
+        return (this.menuPosition ??
+            (!this._parentMenu || this._parentMenu.orientation === 'horizontal'
+                ? STANDARD_DROPDOWN_BELOW_POSITIONS
+                : STANDARD_DROPDOWN_ADJACENT_POSITIONS));
+    }
+    /**
+     * Subscribe to the MenuStack close events if this is a standalone trigger and close out the menu
+     * this triggers when requested.
+     */
+    _registerCloseHandler() {
+        if (!this._parentMenu) {
+            this.menuStack.closed.pipe(takeUntil(this.destroyed)).subscribe(({ item }) => {
+                if (item === this.childMenu) {
+                    this.close();
+                }
+            });
+        }
+    }
+    /**
+     * Subscribe to the overlays outside pointer events stream and handle closing out the stack if a
+     * click occurs outside the menus.
+     */
+    _subscribeToOutsideClicks() {
+        if (this.overlayRef) {
+            this.overlayRef
+                .outsidePointerEvents()
+                .pipe(takeUntil(this.stopOutsideClicksListener))
+                .subscribe(event => {
+                const target = _getEventTarget(event);
+                const element = this._elementRef.nativeElement;
+                if (target !== element && !element.contains(target)) {
+                    if (!this.isElementInsideMenuStack(target)) {
+                        this.menuStack.closeAll();
+                    }
+                    else {
+                        this._closeSiblingTriggers();
+                    }
+                }
+            });
+        }
+    }
+    /** Subscribe to the MenuStack hasFocus events. */
+    _subscribeToMenuStackHasFocus() {
+        if (!this._parentMenu) {
+            this.menuStack.hasFocus.pipe(takeUntil(this.destroyed)).subscribe(hasFocus => {
+                if (!hasFocus) {
+                    this.menuStack.closeAll();
+                }
+            });
+        }
+    }
+    /** Subscribe to the MenuStack closed events. */
+    _subscribeToMenuStackClosed() {
+        if (!this._parentMenu) {
+            this.menuStack.closed.subscribe(({ focusParentTrigger }) => {
+                if (focusParentTrigger && !this.menuStack.length()) {
+                    this._elementRef.nativeElement.focus();
+                }
+            });
+        }
+    }
+    /** Sets the role attribute for this trigger if needed. */
+    _setRole() {
+        // If this trigger is part of another menu, the cdkMenuItem directive will handle setting the
+        // role, otherwise this is a standalone trigger, and we should ensure it has role="button".
+        if (!this._parentMenu) {
+            this._elementRef.nativeElement.setAttribute('role', 'button');
+        }
+    }
+    /** Sets thte `type` attribute of the trigger. */
+    _setType() {
+        const element = this._elementRef.nativeElement;
+        if (element.nodeName === 'BUTTON' && !element.getAttribute('type')) {
+            // Prevents form submissions.
+            element.setAttribute('type', 'button');
+        }
+    }
+}
+CdkMenuTrigger.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: CdkMenuTrigger, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+CdkMenuTrigger.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.0.0", type: CdkMenuTrigger, isStandalone: true, selector: "[cdkMenuTriggerFor]", inputs: { menuTemplateRef: ["cdkMenuTriggerFor", "menuTemplateRef"], menuPosition: ["cdkMenuPosition", "menuPosition"], menuData: ["cdkMenuTriggerData", "menuData"] }, outputs: { opened: "cdkMenuOpened", closed: "cdkMenuClosed" }, host: { attributes: { "aria-haspopup": "menu" }, listeners: { "focusin": "_setHasFocus(true)", "focusout": "_setHasFocus(false)", "keydown": "_toggleOnKeydown($event)", "click": "toggle()" }, properties: { "attr.aria-expanded": "isOpen()" }, classAttribute: "cdk-menu-trigger" }, providers: [
+        { provide: MENU_TRIGGER, useExisting: CdkMenuTrigger },
+        PARENT_OR_NEW_MENU_STACK_PROVIDER,
+    ], exportAs: ["cdkMenuTriggerFor"], usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: CdkMenuTrigger, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[cdkMenuTriggerFor]',
+                    exportAs: 'cdkMenuTriggerFor',
+                    standalone: true,
+                    host: {
+                        'class': 'cdk-menu-trigger',
+                        'aria-haspopup': 'menu',
+                        '[attr.aria-expanded]': 'isOpen()',
+                        '(focusin)': '_setHasFocus(true)',
+                        '(focusout)': '_setHasFocus(false)',
+                        '(keydown)': '_toggleOnKeydown($event)',
+                        '(click)': 'toggle()',
+                    },
+                    inputs: [
+                        'menuTemplateRef: cdkMenuTriggerFor',
+                        'menuPosition: cdkMenuPosition',
+                        'menuData: cdkMenuTriggerData',
+                    ],
+                    outputs: ['opened: cdkMenuOpened', 'closed: cdkMenuClosed'],
+                    providers: [
+                        { provide: MENU_TRIGGER, useExisting: CdkMenuTrigger },
+                        PARENT_OR_NEW_MENU_STACK_PROVIDER,
+                    ],
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,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
Line truncated

front/app/node_modules/@angular/cdk/esm2020/menu/menu.mjs

@@ -0,0 +1,135 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { Directive, EventEmitter, inject, Output } from '@angular/core';
+import { ESCAPE, hasModifierKey, LEFT_ARROW, RIGHT_ARROW, TAB } from '@angular/cdk/keycodes';
+import { takeUntil } from 'rxjs/operators';
+import { CdkMenuGroup } from './menu-group';
+import { CDK_MENU } from './menu-interface';
+import { PARENT_OR_NEW_INLINE_MENU_STACK_PROVIDER } from './menu-stack';
+import { MENU_TRIGGER } from './menu-trigger-base';
+import { CdkMenuBase } from './menu-base';
+import * as i0 from "@angular/core";
+/**
+ * Directive which configures the element as a Menu which should contain child elements marked as
+ * CdkMenuItem or CdkMenuGroup. Sets the appropriate role and aria-attributes for a menu and
+ * contains accessible keyboard and mouse handling logic.
+ *
+ * It also acts as a RadioGroup for elements marked with role `menuitemradio`.
+ */
+export class CdkMenu extends CdkMenuBase {
+    constructor() {
+        super();
+        this._parentTrigger = inject(MENU_TRIGGER, { optional: true });
+        /** Event emitted when the menu is closed. */
+        this.closed = new EventEmitter();
+        /** The direction items in the menu flow. */
+        this.orientation = 'vertical';
+        /** Whether the menu is displayed inline (i.e. always present vs a conditional popup that the user triggers with a trigger element). */
+        this.isInline = !this._parentTrigger;
+        this.destroyed.subscribe(this.closed);
+        this._parentTrigger?.registerChildMenu(this);
+    }
+    ngAfterContentInit() {
+        super.ngAfterContentInit();
+        this._subscribeToMenuStackEmptied();
+    }
+    ngOnDestroy() {
+        super.ngOnDestroy();
+        this.closed.complete();
+    }
+    /**
+     * Handle keyboard events for the Menu.
+     * @param event The keyboard event to be handled.
+     */
+    _handleKeyEvent(event) {
+        const keyManager = this.keyManager;
+        switch (event.keyCode) {
+            case LEFT_ARROW:
+            case RIGHT_ARROW:
+                if (!hasModifierKey(event)) {
+                    event.preventDefault();
+                    keyManager.setFocusOrigin('keyboard');
+                    keyManager.onKeydown(event);
+                }
+                break;
+            case ESCAPE:
+                if (!hasModifierKey(event)) {
+                    event.preventDefault();
+                    this.menuStack.close(this, {
+                        focusNextOnEmpty: 2 /* FocusNext.currentItem */,
+                        focusParentTrigger: true,
+                    });
+                }
+                break;
+            case TAB:
+                if (!hasModifierKey(event, 'altKey', 'metaKey', 'ctrlKey')) {
+                    this.menuStack.closeAll({ focusParentTrigger: true });
+                }
+                break;
+            default:
+                keyManager.onKeydown(event);
+        }
+    }
+    /**
+     * Set focus the either the current, previous or next item based on the FocusNext event.
+     * @param focusNext The element to focus.
+     */
+    _toggleMenuFocus(focusNext) {
+        const keyManager = this.keyManager;
+        switch (focusNext) {
+            case 0 /* FocusNext.nextItem */:
+                keyManager.setFocusOrigin('keyboard');
+                keyManager.setNextItemActive();
+                break;
+            case 1 /* FocusNext.previousItem */:
+                keyManager.setFocusOrigin('keyboard');
+                keyManager.setPreviousItemActive();
+                break;
+            case 2 /* FocusNext.currentItem */:
+                if (keyManager.activeItem) {
+                    keyManager.setFocusOrigin('keyboard');
+                    keyManager.setActiveItem(keyManager.activeItem);
+                }
+                break;
+        }
+    }
+    /** Subscribe to the MenuStack emptied events. */
+    _subscribeToMenuStackEmptied() {
+        this.menuStack.emptied
+            .pipe(takeUntil(this.destroyed))
+            .subscribe(event => this._toggleMenuFocus(event));
+    }
+}
+CdkMenu.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: CdkMenu, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+CdkMenu.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.0.0", type: CdkMenu, isStandalone: true, selector: "[cdkMenu]", outputs: { closed: "closed" }, host: { attributes: { "role": "menu" }, listeners: { "keydown": "_handleKeyEvent($event)" }, properties: { "class.cdk-menu-inline": "isInline" }, classAttribute: "cdk-menu" }, providers: [
+        { provide: CdkMenuGroup, useExisting: CdkMenu },
+        { provide: CDK_MENU, useExisting: CdkMenu },
+        PARENT_OR_NEW_INLINE_MENU_STACK_PROVIDER('vertical'),
+    ], exportAs: ["cdkMenu"], usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: CdkMenu, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[cdkMenu]',
+                    exportAs: 'cdkMenu',
+                    standalone: true,
+                    host: {
+                        'role': 'menu',
+                        'class': 'cdk-menu',
+                        '[class.cdk-menu-inline]': 'isInline',
+                        '(keydown)': '_handleKeyEvent($event)',
+                    },
+                    providers: [
+                        { provide: CdkMenuGroup, useExisting: CdkMenu },
+                        { provide: CDK_MENU, useExisting: CdkMenu },
+                        PARENT_OR_NEW_INLINE_MENU_STACK_PROVIDER('vertical'),
+                    ],
+                }]
+        }], ctorParameters: function () { return []; }, propDecorators: { closed: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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
Line truncated

front/app/node_modules/@angular/cdk/esm2020/menu/menu_public_index.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWVudV9wdWJsaWNfaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvY2RrL21lbnUvbWVudV9wdWJsaWNfaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLFNBQVMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9pbmRleCc7XG4iXX0=

front/app/node_modules/@angular/cdk/esm2020/menu/pointer-focus-tracker.mjs

@@ -0,0 +1,51 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { defer, fromEvent, Subject } from 'rxjs';
+import { mapTo, mergeAll, mergeMap, startWith, takeUntil } from 'rxjs/operators';
+/**
+ * PointerFocusTracker keeps track of the currently active item under mouse focus. It also has
+ * observables which emit when the users mouse enters and leaves a tracked element.
+ */
+export class PointerFocusTracker {
+    constructor(
+    /** The list of items being tracked. */
+    _items) {
+        this._items = _items;
+        /** Emits when an element is moused into. */
+        this.entered = this._getItemPointerEntries();
+        /** Emits when an element is moused out. */
+        this.exited = this._getItemPointerExits();
+        /** Emits when this is destroyed. */
+        this._destroyed = new Subject();
+        this.entered.subscribe(element => (this.activeElement = element));
+        this.exited.subscribe(() => {
+            this.previousElement = this.activeElement;
+            this.activeElement = undefined;
+        });
+    }
+    /** Stop the managers listeners. */
+    destroy() {
+        this._destroyed.next();
+        this._destroyed.complete();
+    }
+    /**
+     * Gets a stream of pointer (mouse) entries into the given items.
+     * This should typically run outside the Angular zone.
+     */
+    _getItemPointerEntries() {
+        return defer(() => this._items.changes.pipe(startWith(this._items), mergeMap((list) => list.map(element => fromEvent(element._elementRef.nativeElement, 'mouseenter').pipe(mapTo(element), takeUntil(this._items.changes)))), mergeAll()));
+    }
+    /**
+     * Gets a stream of pointer (mouse) exits out of the given items.
+     * This should typically run outside the Angular zone.
+     */
+    _getItemPointerExits() {
+        return defer(() => this._items.changes.pipe(startWith(this._items), mergeMap((list) => list.map(element => fromEvent(element._elementRef.nativeElement, 'mouseout').pipe(mapTo(element), takeUntil(this._items.changes)))), mergeAll()));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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
Line truncated

front/app/node_modules/@angular/cdk/esm2020/menu/public-api.mjs

@@ -0,0 +1,24 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+export * from './menu-module';
+export * from './menu-bar';
+export * from './menu';
+export * from './menu-base';
+export * from './menu-item';
+export * from './menu-item-checkbox';
+export * from './menu-item-radio';
+export * from './menu-trigger';
+export * from './menu-group';
+export * from './menu-item-selectable';
+export * from './context-menu-trigger';
+export * from './menu-trigger-base';
+export * from './pointer-focus-tracker';
+export * from './menu-stack';
+export * from './menu-interface';
+export * from './menu-aim';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3NyYy9jZGsvbWVudS9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7R0FNRztBQUVILGNBQWMsZUFBZSxDQUFDO0FBQzlCLGNBQWMsWUFBWSxDQUFDO0FBQzNCLGNBQWMsUUFBUSxDQUFDO0FBQ3ZCLGNBQWMsYUFBYSxDQUFDO0FBQzVCLGNBQWMsYUFBYSxDQUFDO0FBQzVCLGNBQWMsc0JBQXNCLENBQUM7QUFDckMsY0FBYyxtQkFBbUIsQ0FBQztBQUNsQyxjQUFjLGdCQUFnQixDQUFDO0FBQy9CLGNBQWMsY0FBYyxDQUFDO0FBQzdCLGNBQWMsd0JBQXdCLENBQUM7QUFDdkMsY0FBYyx3QkFBd0IsQ0FBQztBQUN2QyxjQUFjLHFCQUFxQixDQUFDO0FBQ3BDLGNBQWMseUJBQXlCLENBQUM7QUFDeEMsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxrQkFBa0IsQ0FBQztBQUNqQyxjQUFjLFlBQVksQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgTExDIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL21lbnUtbW9kdWxlJztcbmV4cG9ydCAqIGZyb20gJy4vbWVudS1iYXInO1xuZXhwb3J0ICogZnJvbSAnLi9tZW51JztcbmV4cG9ydCAqIGZyb20gJy4vbWVudS1iYXNlJztcbmV4cG9ydCAqIGZyb20gJy4vbWVudS1pdGVtJztcbmV4cG9ydCAqIGZyb20gJy4vbWVudS1pdGVtLWNoZWNrYm94JztcbmV4cG9ydCAqIGZyb20gJy4vbWVudS1pdGVtLXJhZGlvJztcbmV4cG9ydCAqIGZyb20gJy4vbWVudS10cmlnZ2VyJztcbmV4cG9ydCAqIGZyb20gJy4vbWVudS1ncm91cCc7XG5leHBvcnQgKiBmcm9tICcuL21lbnUtaXRlbS1zZWxlY3RhYmxlJztcbmV4cG9ydCAqIGZyb20gJy4vY29udGV4dC1tZW51LXRyaWdnZXInO1xuZXhwb3J0ICogZnJvbSAnLi9tZW51LXRyaWdnZXItYmFzZSc7XG5leHBvcnQgKiBmcm9tICcuL3BvaW50ZXItZm9jdXMtdHJhY2tlcic7XG5leHBvcnQgKiBmcm9tICcuL21lbnUtc3RhY2snO1xuZXhwb3J0ICogZnJvbSAnLi9tZW51LWludGVyZmFjZSc7XG5leHBvcnQgKiBmcm9tICcuL21lbnUtYWltJztcbiJdfQ==