@ethlete/core 1.10.1 → 2.1.0

package/fesm2022/ethlete-core.mjs

@@ -1,11 +1,14 @@
 import * as i0 from '@angular/core';
-import { inject, Component, ChangeDetectionStrategy, ViewEncapsulation, Input, HostBinding, InjectionToken, Injectable, ElementRef, Inject, Optional, isDevMode, Directive, EventEmitter, Output, NgZone, Pipe, QueryList } from '@angular/core';
+import { inject, Component, ChangeDetectionStrategy, ViewEncapsulation, Input, HostBinding, InjectionToken, assertInInjectionContext, DestroyRef, ElementRef, isDevMode, Directive, Injector, ViewContainerRef, NgZone, Injectable, Inject, Optional, EventEmitter, Output, Pipe, QueryList } from '@angular/core';
 import { DomSanitizer, Meta, Title } from '@angular/platform-browser';
-import { fromEvent, Observable, Subject, combineLatest, startWith, map, takeUntil, distinctUntilChanged, BehaviorSubject, skip, take, tap, filter, pairwise, debounceTime, shareReplay, merge, switchMap } from 'rxjs';
-import { coerceElement, coerceCssPixelValue, coerceBooleanProperty, coerceNumberProperty } from '@angular/cdk/coercion';
+import { Observable, combineLatest, Subject, startWith, map, takeUntil, distinctUntilChanged, BehaviorSubject, skip, take, tap, debounceTime, merge, fromEvent, filter, switchMap, pairwise, shareReplay } from 'rxjs';
+import { coerceCssPixelValue, coerceElement, coerceBooleanProperty, coerceNumberProperty } from '@angular/cdk/coercion';
+import { supportsScrollBehavior } from '@angular/cdk/platform';
+import { Overlay } from '@angular/cdk/overlay';
+import { ComponentPortal } from '@angular/cdk/portal';
+import { createPopper } from '@popperjs/core';
 import { DOCUMENT } from '@angular/common';
 import { Router, NavigationEnd } from '@angular/router';
-import { supportsScrollBehavior } from '@angular/cdk/platform';
 import { __decorate, __metadata } from 'tslib';
 import * as i1 from '@angular/cdk/layout';
 import { debounceTime as debounceTime$1 } from 'rxjs/operators';
@@ -85,938 +88,1318 @@ const Memo = (config = {}) => (_, __, descriptor) => {
     return descriptor;
 };
 
-/* eslint-disable @typescript-eslint/no-non-null-assertion */
-class ClickObserverFactory {
-    create() {
-        return fromEvent(document, 'click');
+const nextFrame = (cb) => {
+    requestAnimationFrame(() => {
+        requestAnimationFrame(cb);
+    });
+};
+const fromNextFrame = () => {
+    return new Observable((observer) => {
+        nextFrame(() => {
+            observer.next();
+            observer.complete();
+        });
+    });
+};
+const forceReflow = (element = document.body) => {
+    return element.offsetHeight;
+};
+const createFlipAnimationGroup = (config) => {
+    const { elements, duration = 250, easing = 'cubic-bezier(0.4, 0, 0.2, 1)' } = config;
+    const flips = elements.map((el) => {
+        const element = 'element' in el ? el.element : el;
+        const originElement = 'originElement' in el ? el.originElement : undefined;
+        return createFlipAnimation({ element, originElement, duration, easing });
+    });
+    const onStart$ = combineLatest(flips.map((animation) => animation.onStart$));
+    const onFinish$ = combineLatest(flips.map((animation) => animation.onFinish$));
+    const onCancel$ = combineLatest(flips.map((animation) => animation.onCancel$));
+    const updateInit = () => {
+        flips.forEach((animation) => animation.updateInit());
+    };
+    const play = () => {
+        flips.forEach((animation) => animation.play());
+    };
+    const cancel = () => {
+        flips.forEach((animation) => animation.cancel());
+    };
+    return {
+        updateInit,
+        play,
+        cancel,
+        onStart$,
+        onFinish$,
+        onCancel$,
+    };
+};
+const createFlipAnimation = (config) => {
+    const { element: el, originElement = el, duration = 250, easing = 'cubic-bezier(0.4, 0, 0.2, 1)' } = config;
+    let initialRect = originElement.getBoundingClientRect();
+    let animation = null;
+    const onStart$ = new Subject();
+    const onFinish$ = new Subject();
+    const onCancel$ = new Subject();
+    const onAnimationFinish = () => {
+        cleanup();
+        onFinish$.next();
+    };
+    const onAnimationCancel = () => {
+        cleanup();
+        onCancel$.next();
+    };
+    const cleanup = () => {
+        if (!animation) {
+            return;
+        }
+        animation.removeEventListener('finish', onAnimationFinish);
+        animation.removeEventListener('cancel', onAnimationCancel);
+    };
+    const updateInit = () => {
+        initialRect = originElement.getBoundingClientRect();
+    };
+    const play = () => {
+        const lastRect = el.getBoundingClientRect();
+        const delta = {
+            x: initialRect.left - lastRect.left,
+            y: initialRect.top - lastRect.top,
+            scaleX: initialRect.width / lastRect.width,
+            scaleY: initialRect.height / lastRect.height,
+        };
+        animation = el.animate([
+            {
+                transformOrigin: 'top left',
+                transform: `
+          translate(${delta.x}px, ${delta.y}px)
+          scale(${delta.scaleX}, ${delta.scaleY})
+        `,
+            },
+            {
+                transformOrigin: 'top left',
+                transform: 'none',
+            },
+        ], {
+            duration,
+            easing,
+            fill: 'both',
+        });
+        animation.addEventListener('finish', onAnimationFinish);
+        animation.addEventListener('cancel', onAnimationCancel);
+        onStart$.next();
+    };
+    const cancel = () => {
+        animation?.cancel();
+        cleanup();
+    };
+    return {
+        updateInit,
+        play,
+        cancel,
+        onStart$: onStart$.asObservable(),
+        onFinish$: onFinish$.asObservable(),
+        onCancel$: onCancel$.asObservable(),
+    };
+};
+
+const clamp = (value, min = 0, max = 100) => {
+    return Math.max(min, Math.min(max, value));
+};
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable no-var */
+/**
+ * Stolen from klona to avoid adding a dependency
+ * https://github.com/lukeed/klona
+ *
+ * MIT License
+ *
+ * Copyright (c) Luke Edwards <luke.edwards05@gmail.com> (lukeed.com)
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+const set = (obj, key, val) => {
+    if (typeof val.value === 'object')
+        val.value = clone(val.value);
+    if (!val.enumerable || val.get || val.set || !val.configurable || !val.writable || key === '__proto__') {
+        Object.defineProperty(obj, key, val);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: ClickObserverFactory, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: ClickObserverFactory, providedIn: 'root' }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: ClickObserverFactory, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }] });
-class ClickObserverService {
-    constructor(_clickObserverFactory) {
-        this._clickObserverFactory = _clickObserverFactory;
-        this._observedElements = new Map();
+    else
+        obj[key] = val.value;
+};
+const clone = (original) => {
+    if (typeof original !== 'object')
+        return original;
+    var _og = original;
+    var i = 0, k, list, tmp, str = Object.prototype.toString.call(_og);
+    if (str === '[object Object]') {
+        tmp = Object.create(_og.__proto__ || null);
     }
-    ngOnDestroy() {
-        this._observedElements.forEach((_, element) => this._cleanupObserver(element));
+    else if (str === '[object Array]') {
+        tmp = Array(_og.length);
     }
-    observe(elementOrRef) {
-        const element = coerceElement(elementOrRef);
-        return new Observable((observer) => {
-            const stream = this._observeElement(element);
-            const subscription = stream.subscribe(observer);
-            return () => {
-                subscription.unsubscribe();
-                this._unobserveElement(element);
-            };
+    else if (str === '[object Set]') {
+        tmp = new Set();
+        _og.forEach(function (val) {
+            tmp.add(clone(val));
         });
     }
-    _observeElement(element) {
-        if (!this._observedElements.has(element)) {
-            const stream = new Subject();
-            const observer = this._clickObserverFactory.create();
-            const sub = observer.subscribe((event) => stream.next(event));
-            this._observedElements.set(element, { observer: sub, stream, count: 1 });
-        }
-        else {
-            this._observedElements.get(element).count++;
-        }
-        return this._observedElements.get(element).stream;
+    else if (str === '[object Map]') {
+        tmp = new Map();
+        _og.forEach(function (val, key) {
+            tmp.set(clone(key), clone(val));
+        });
     }
-    _unobserveElement(element) {
-        if (this._observedElements.has(element)) {
-            this._observedElements.get(element).count--;
-            if (!this._observedElements.get(element).count) {
-                this._cleanupObserver(element);
-            }
-        }
+    else if (str === '[object Date]') {
+        tmp = new Date(+_og);
     }
-    _cleanupObserver(element) {
-        if (this._observedElements.has(element)) {
-            const { observer, stream } = this._observedElements.get(element);
-            if (observer) {
-                observer.unsubscribe();
-            }
-            stream.complete();
-            this._observedElements.delete(element);
-        }
+    else if (str === '[object RegExp]') {
+        tmp = new RegExp(_og.source, _og.flags);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: ClickObserverService, deps: [{ token: ClickObserverFactory }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: ClickObserverService, providedIn: 'root' }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: ClickObserverService, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }], ctorParameters: function () { return [{ type: ClickObserverFactory }]; } });
-
-/* eslint-disable @typescript-eslint/no-non-null-assertion */
-class MutationObserverFactory {
-    create(callback) {
-        return typeof MutationObserver === 'undefined' ? null : new MutationObserver(callback);
+    else if (str === '[object DataView]') {
+        tmp = new _og.constructor(clone(_og.buffer));
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: MutationObserverFactory, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: MutationObserverFactory, providedIn: 'root' }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: MutationObserverFactory, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }] });
-class ContentObserverService {
-    constructor(_mutationObserverFactory) {
-        this._mutationObserverFactory = _mutationObserverFactory;
-        this._observedElements = new Map();
+    else if (str === '[object ArrayBuffer]') {
+        tmp = _og.slice(0);
     }
-    ngOnDestroy() {
-        this._observedElements.forEach((_, element) => this._cleanupObserver(element));
+    else if (str.slice(-6) === 'Array]') {
+        // ArrayBuffer.isView(x)
+        // ~> `new` bcuz `Buffer.slice` => ref
+        tmp = new _og.constructor(_og);
     }
-    observe(elementOrRef) {
-        const element = coerceElement(elementOrRef);
-        return new Observable((observer) => {
-            const stream = this._observeElement(element);
-            const subscription = stream.subscribe(observer);
-            return () => {
-                subscription.unsubscribe();
-                this._unobserveElement(element);
-            };
-        });
-    }
-    _observeElement(element) {
-        if (!this._observedElements.has(element)) {
-            const stream = new Subject();
-            const observer = this._mutationObserverFactory.create((mutations) => stream.next(mutations));
-            if (observer) {
-                observer.observe(element, {
-                    characterData: true,
-                    childList: true,
-                    subtree: true,
-                });
-            }
-            this._observedElements.set(element, { observer, stream, count: 1 });
-        }
-        else {
-            this._observedElements.get(element).count++;
-        }
-        return this._observedElements.get(element).stream;
-    }
-    _unobserveElement(element) {
-        if (this._observedElements.has(element)) {
-            this._observedElements.get(element).count--;
-            if (!this._observedElements.get(element).count) {
-                this._cleanupObserver(element);
-            }
+    if (tmp) {
+        for (list = Object.getOwnPropertySymbols(_og); i < list.length; i++) {
+            set(tmp, list[i], Object.getOwnPropertyDescriptor(_og, list[i]));
         }
-    }
-    _cleanupObserver(element) {
-        if (this._observedElements.has(element)) {
-            const { observer, stream } = this._observedElements.get(element);
-            if (observer) {
-                observer.disconnect();
-            }
-            stream.complete();
-            this._observedElements.delete(element);
+        for (i = 0, list = Object.getOwnPropertyNames(_og); i < list.length; i++) {
+            if (Object.hasOwnProperty.call(tmp, (k = list[i])) && tmp[k] === _og[k])
+                continue;
+            set(tmp, k, Object.getOwnPropertyDescriptor(_og, k));
         }
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: ContentObserverService, deps: [{ token: MutationObserverFactory }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: ContentObserverService, providedIn: 'root' }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: ContentObserverService, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }], ctorParameters: function () { return [{ type: MutationObserverFactory }]; } });
+    return tmp || _og;
+};
 
-/**
- * @deprecated Will be replaced with the upcoming Angular 16 `DestroyRef` feature.
- */
-// TODO: Replace with Angular 16 `DestroyRef` feature when available.
-class DestroyService {
-    constructor() {
-        this._destroy$ = new Subject();
-        this.destroy$ = this._destroy$.asObservable();
+const hasCookie = (name) => {
+    if (typeof document === 'undefined') {
+        return false;
     }
-    ngOnDestroy() {
-        this._destroy$.next(true);
-        this._destroy$.unsubscribe();
+    return document.cookie.split(';').some((c) => {
+        return c.trim().startsWith(name + '=');
+    });
+};
+const getCookie = (name) => {
+    if (typeof document === 'undefined') {
+        return null;
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: DestroyService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: DestroyService }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: DestroyService, decorators: [{
-            type: Injectable
-        }] });
-
-class FocusVisibleService {
-    get isFocusVisible() {
-        return this._hadKeyboardEvent;
+    // From https://stackoverflow.com/questions/10730362/get-cookie-by-name
+    return ('; ' + document.cookie).split(`; ${name}=`).pop()?.split(';')[0];
+};
+const setCookie = (name, data, expiresInDays = 30, domain = getDomain()) => {
+    if (typeof document === 'undefined') {
+        return;
     }
-    constructor() {
-        this._document = inject(DOCUMENT);
-        this._hadKeyboardEvent = false;
-        this._document.addEventListener('keydown', this.onKeyDown.bind(this), true);
-        this._document.addEventListener('mousedown', this.onPointerDown.bind(this), true);
-        this._document.addEventListener('pointerdown', this.onPointerDown.bind(this), true);
-        this._document.addEventListener('touchstart', this.onPointerDown.bind(this), true);
+    const date = new Date();
+    date.setTime(date.getTime() + expiresInDays * 24 * 60 * 60 * 1000);
+    document.cookie = `${name}=${data}; path=/; expires=${date.toUTCString()}; domain=${domain}; SameSite=Lax;`;
+};
+const deleteCookie = (name, path, domain = getDomain()) => {
+    if (hasCookie(name)) {
+        document.cookie =
+            name +
+                '=' +
+                (path ? ';path=' + path : '') +
+                (domain ? ';domain=' + domain : '') +
+                ';expires=Thu, 01 Jan 1970 00:00:01 GMT';
     }
-    onKeyDown(e) {
-        if (e.metaKey || e.altKey || e.ctrlKey) {
-            return;
-        }
-        this._hadKeyboardEvent = true;
+};
+const getDomain = () => {
+    if (typeof navigator === 'undefined') {
+        return null;
     }
-    onPointerDown() {
-        this._hadKeyboardEvent = false;
+    const hostname = window.location.hostname;
+    if (hostname.includes('localhost')) {
+        return 'localhost';
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: FocusVisibleService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: FocusVisibleService, providedIn: 'root' }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: FocusVisibleService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }], ctorParameters: function () { return []; } });
+    const splitHost = hostname.split('.');
+    if (splitHost.length > 2) {
+        return `${splitHost[splitHost.length - 2]}.${splitHost[splitHost.length - 1]}`;
+    }
+    return hostname;
+};
 
-/* eslint-disable @typescript-eslint/no-non-null-assertion */
-class ResizeObserverFactory {
-    create(callback) {
-        return typeof ResizeObserver === 'undefined' ? null : new ResizeObserver(callback);
+const createDestroy = () => {
+    assertInInjectionContext(createDestroy);
+    const destroy$ = new Subject();
+    const ref = inject(DestroyRef);
+    ref.onDestroy(() => {
+        destroy$.next(true);
+        destroy$.complete();
+    });
+    return destroy$.asObservable();
+};
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable no-var */
+/**
+ * Stolen from dequal to avoid adding a dependency
+ * https://github.com/lukeed/dequal
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) Luke Edwards <luke.edwards05@gmail.com> (lukeed.com)
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+const has = Object.prototype.hasOwnProperty;
+function find(iter, tar, key) {
+    for (key of iter.keys()) {
+        if (equal(key, tar))
+            return key;
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: ResizeObserverFactory, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: ResizeObserverFactory, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: ResizeObserverFactory, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }] });
-class ResizeObserverService {
-    constructor(_mutationObserverFactory) {
-        this._mutationObserverFactory = _mutationObserverFactory;
-        this._observedElements = new Map();
-    }
-    ngOnDestroy() {
-        this._observedElements.forEach((_, element) => this._cleanupObserver(element));
-    }
-    observe(elementOrRef) {
-        const element = coerceElement(elementOrRef);
-        return new Observable((observer) => {
-            const stream = this._observeElement(element);
-            const subscription = stream.subscribe(observer);
-            return () => {
-                subscription.unsubscribe();
-                this._unobserveElement(element);
-            };
-        });
-    }
-    _observeElement(element) {
-        if (!this._observedElements.has(element)) {
-            const stream = new Subject();
-            const observer = this._mutationObserverFactory.create((resizes) => stream.next(resizes));
-            if (observer) {
-                observer.observe(element);
+const equal = (foo, bar) => {
+    var ctor, len, tmp;
+    if (foo === bar)
+        return true;
+    if (foo && bar && (ctor = foo.constructor) === bar.constructor) {
+        if (ctor === Date)
+            return foo.getTime() === bar.getTime();
+        if (ctor === RegExp)
+            return foo.toString() === bar.toString();
+        if (ctor === Array) {
+            if ((len = foo.length) === bar.length) {
+                while (len-- && equal(foo[len], bar[len]))
+                    ;
             }
-            this._observedElements.set(element, { observer, stream, count: 1 });
-        }
-        else {
-            this._observedElements.get(element).count++;
+            return len === -1;
         }
-        return this._observedElements.get(element).stream;
-    }
-    _unobserveElement(element) {
-        if (this._observedElements.has(element)) {
-            this._observedElements.get(element).count--;
-            if (!this._observedElements.get(element).count) {
-                this._cleanupObserver(element);
+        if (ctor === Set) {
+            if (foo.size !== bar.size) {
+                return false;
             }
-        }
-    }
-    _cleanupObserver(element) {
-        if (this._observedElements.has(element)) {
-            const { observer, stream } = this._observedElements.get(element);
-            if (observer) {
-                observer.disconnect();
+            for (len of foo) {
+                tmp = len;
+                if (tmp && typeof tmp === 'object') {
+                    tmp = find(bar, tmp);
+                    if (!tmp)
+                        return false;
+                }
+                if (!bar.has(tmp))
+                    return false;
             }
-            stream.complete();
-            this._observedElements.delete(element);
+            return true;
         }
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: ResizeObserverService, deps: [{ token: ResizeObserverFactory }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: ResizeObserverService, providedIn: 'root' }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: ResizeObserverService, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }], ctorParameters: function () { return [{ type: ResizeObserverFactory }]; } });
-
-const nextFrame = (cb) => {
-    requestAnimationFrame(() => {
-        requestAnimationFrame(cb);
-    });
-};
-const fromNextFrame = () => {
-    return new Observable((observer) => {
-        nextFrame(() => {
-            observer.next();
-            observer.complete();
-        });
-    });
+        if (ctor === Map) {
+            if (foo.size !== bar.size) {
+                return false;
+            }
+            for (len of foo) {
+                tmp = len[0];
+                if (tmp && typeof tmp === 'object') {
+                    tmp = find(bar, tmp);
+                    if (!tmp)
+                        return false;
+                }
+                if (!equal(len[1], bar.get(tmp))) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        if (ctor === ArrayBuffer) {
+            foo = new Uint8Array(foo);
+            bar = new Uint8Array(bar);
+        }
+        else if (ctor === DataView) {
+            if ((len = foo.byteLength) === bar.byteLength) {
+                while (len-- && foo.getInt8(len) === bar.getInt8(len))
+                    ;
+            }
+            return len === -1;
+        }
+        if (ArrayBuffer.isView(foo)) {
+            if ((len = foo.byteLength) === bar.byteLength) {
+                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                //@ts-ignore
+                while (len-- && foo[len] === bar[len])
+                    ;
+            }
+            return len === -1;
+        }
+        if (!ctor || typeof foo === 'object') {
+            len = 0;
+            for (ctor in foo) {
+                if (has.call(foo, ctor) && ++len && !has.call(bar, ctor))
+                    return false;
+                if (!(ctor in bar) || !equal(foo[ctor], bar[ctor]))
+                    return false;
+            }
+            return Object.keys(bar).length === len;
+        }
+    }
+    return foo !== foo && bar !== bar;
 };
-const forceReflow = (element = document.body) => {
-    return element.offsetHeight;
+
+const createMediaQueryObservable = (query) => {
+    const mq = window.matchMedia(query);
+    const observable = new Observable((observer) => {
+        const eventHandler = (event) => {
+            observer.next(event);
+        };
+        mq.addEventListener('change', eventHandler);
+        return () => {
+            mq.removeEventListener('change', eventHandler);
+        };
+    }).pipe(startWith(mq), map(({ matches }) => ({
+        matches,
+        query,
+    })));
+    return observable;
 };
-const createFlipAnimationGroup = (config) => {
-    const { elements, duration = 250, easing = 'cubic-bezier(0.4, 0, 0.2, 1)' } = config;
-    const flips = elements.map((el) => {
-        const element = 'element' in el ? el.element : el;
-        const originElement = 'originElement' in el ? el.originElement : undefined;
-        return createFlipAnimation({ element, originElement, duration, easing });
-    });
-    const onStart$ = combineLatest(flips.map((animation) => animation.onStart$));
-    const onFinish$ = combineLatest(flips.map((animation) => animation.onFinish$));
-    const onCancel$ = combineLatest(flips.map((animation) => animation.onCancel$));
-    const updateInit = () => {
-        flips.forEach((animation) => animation.updateInit());
+
+const isAttributeRenderBinding = (value) => typeof value === 'boolean';
+const isAttributeValueBinding = (value) => typeof value === 'object';
+const createReactiveBindings = (...values) => {
+    assertInInjectionContext(createReactiveBindings);
+    const rootElementRef = inject(ElementRef);
+    const destroy$ = createDestroy();
+    const subscriptions = [];
+    const pushedAttributes = [];
+    const defaults = {};
+    const push = (value) => {
+        const { attribute, observable, elementRef } = value;
+        const elRef = elementRef || rootElementRef;
+        const attributes = Array.isArray(attribute) ? attribute : [attribute];
+        pushedAttributes.push(attributes);
+        for (const attribute of attributes) {
+            if (!defaults[attribute]) {
+                defaults[attribute] = elRef.nativeElement.getAttribute(attribute) || undefined;
+            }
+        }
+        const subscription = observable
+            .pipe(takeUntil(destroy$), distinctUntilChanged((a, b) => {
+            if (isAttributeRenderBinding(a) && isAttributeRenderBinding(b)) {
+                return a === b;
+            }
+            else if (isAttributeValueBinding(a) && isAttributeValueBinding(b)) {
+                return a.render === b.render && a.value === b.value;
+            }
+            return false;
+        }))
+            .subscribe((value) => {
+            const currentAttributes = pushedAttributes.find((s) => s.some((current) => attributes.includes(current))) || [];
+            for (const attribute of currentAttributes) {
+                const isSingleClassMutation = attribute.startsWith('class.');
+                const isMultipleClassMutation = attribute === 'class';
+                const render = isAttributeRenderBinding(value) ? value : value.render;
+                if (isSingleClassMutation) {
+                    const className = attribute.replace('class.', '');
+                    if (!className) {
+                        continue;
+                    }
+                    if (!render) {
+                        elRef.nativeElement.classList.remove(className);
+                    }
+                    else {
+                        elRef.nativeElement.classList.add(className);
+                    }
+                }
+                else if (isMultipleClassMutation) {
+                    const classes = isAttributeRenderBinding(value) ? '' : `${value.value}`;
+                    if (!classes) {
+                        continue;
+                    }
+                    if (!render) {
+                        elRef.nativeElement.classList.remove(...classes.split(' '));
+                    }
+                    else {
+                        elRef.nativeElement.classList.add(...classes.split(' '));
+                    }
+                }
+                else {
+                    const attributeValue = isAttributeRenderBinding(value) ? true : `${value.value}`;
+                    if (!attribute) {
+                        continue;
+                    }
+                    if (!render) {
+                        elRef.nativeElement.removeAttribute(attribute);
+                    }
+                    else {
+                        elRef.nativeElement.setAttribute(attribute, `${attributeValue}`);
+                    }
+                }
+            }
+        });
+        subscriptions.push({ attributes, subscription });
     };
-    const play = () => {
-        flips.forEach((animation) => animation.play());
+    const remove = (...attributes) => {
+        for (const attribute of attributes) {
+            const sub = subscriptions.find((s) => s.attributes.includes(attribute));
+            const attributeStack = pushedAttributes.find((a) => a.includes(attribute));
+            if (sub) {
+                sub.attributes = sub.attributes.filter((a) => a !== attribute);
+                attributeStack?.splice(attributeStack.indexOf(attribute), 1);
+                if (sub.attributes.length === 0) {
+                    sub.subscription.unsubscribe();
+                    subscriptions.splice(subscriptions.indexOf(sub), 1);
+                }
+            }
+        }
     };
-    const cancel = () => {
-        flips.forEach((animation) => animation.cancel());
+    const reset = () => {
+        for (const attribute in defaults) {
+            if (defaults[attribute] === undefined) {
+                rootElementRef.nativeElement.removeAttribute(attribute);
+            }
+            else {
+                rootElementRef.nativeElement.setAttribute(attribute, defaults[attribute]);
+            }
+        }
     };
+    for (const value of values) {
+        push(value);
+    }
     return {
-        updateInit,
-        play,
-        cancel,
-        onStart$,
-        onFinish$,
-        onCancel$,
+        push,
+        remove,
+        reset,
     };
 };
-const createFlipAnimation = (config) => {
-    const { element: el, originElement = el, duration = 250, easing = 'cubic-bezier(0.4, 0, 0.2, 1)' } = config;
-    let initialRect = originElement.getBoundingClientRect();
-    let animation = null;
-    const onStart$ = new Subject();
-    const onFinish$ = new Subject();
-    const onCancel$ = new Subject();
-    const onAnimationFinish = () => {
-        cleanup();
-        onFinish$.next();
-    };
-    const onAnimationCancel = () => {
-        cleanup();
-        onCancel$.next();
-    };
-    const cleanup = () => {
-        if (!animation) {
-            return;
-        }
-        animation.removeEventListener('finish', onAnimationFinish);
-        animation.removeEventListener('cancel', onAnimationCancel);
-    };
-    const updateInit = () => {
-        initialRect = originElement.getBoundingClientRect();
-    };
-    const play = () => {
-        const lastRect = el.getBoundingClientRect();
-        const delta = {
-            x: initialRect.left - lastRect.left,
-            y: initialRect.top - lastRect.top,
-            scaleX: initialRect.width / lastRect.width,
-            scaleY: initialRect.height / lastRect.height,
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+class BehaviorSubjectWithSubscriberCount extends BehaviorSubject {
+    constructor() {
+        super(...arguments);
+        this._subscriberCount = 0;
+    }
+    get subscriberCount() {
+        return this._subscriberCount;
+    }
+    subscribe(observerOrNext) {
+        this._subscriberCount++;
+        const sub = super.subscribe(observerOrNext);
+        return {
+            ...sub,
+            unsubscribe: () => {
+                sub.unsubscribe();
+                this._subscriberCount--;
+            },
         };
-        animation = el.animate([
-            {
-                transformOrigin: 'top left',
-                transform: `
-          translate(${delta.x}px, ${delta.y}px)
-          scale(${delta.scaleX}, ${delta.scaleY})
-        `,
-            },
-            {
-                transformOrigin: 'top left',
-                transform: 'none',
-            },
-        ], {
-            duration,
-            easing,
-            fill: 'both',
-        });
-        animation.addEventListener('finish', onAnimationFinish);
-        animation.addEventListener('cancel', onAnimationCancel);
-        onStart$.next();
-    };
-    const cancel = () => {
-        animation?.cancel();
-        cleanup();
-    };
-    return {
-        updateInit,
-        play,
-        cancel,
-        onStart$: onStart$.asObservable(),
-        onFinish$: onFinish$.asObservable(),
-        onCancel$: onCancel$.asObservable(),
-    };
-};
+    }
+    unsubscribe() {
+        this._subscriberCount--;
+        return super.unsubscribe();
+    }
+}
 
-const clamp = (value, min = 0, max = 100) => {
-    return Math.max(min, Math.min(max, value));
+const elementCanScroll = (element) => {
+    const { scrollHeight, clientHeight, scrollWidth, clientWidth } = element;
+    return scrollHeight > clientHeight || scrollWidth > clientWidth;
+};
+const isElementVisible = (options) => {
+    let { container } = options;
+    const { element } = options;
+    if (!element || container === null) {
+        return null;
+    }
+    container ||= document.documentElement;
+    const canScroll = elementCanScroll(container);
+    if (!canScroll) {
+        return { inline: true, block: true };
+    }
+    const elementRect = element.getBoundingClientRect();
+    const containerRect = container.getBoundingClientRect();
+    const elementInlineStart = elementRect.left;
+    const elementBlockStart = elementRect.top;
+    const containerInlineStart = containerRect.left;
+    const containerBlockStart = containerRect.top;
+    const elementInlineEnd = elementInlineStart + elementRect.width;
+    const elementBlockEnd = elementBlockStart + elementRect.height;
+    const containerInlineEnd = containerInlineStart + containerRect.width;
+    const containerBlockEnd = containerBlockStart + containerRect.height;
+    const isElementInlineVisible = elementInlineStart >= containerInlineStart && elementInlineEnd <= containerInlineEnd;
+    const isElementBlockVisible = elementBlockStart >= containerBlockStart && elementBlockEnd <= containerBlockEnd;
+    return { inline: isElementInlineVisible, block: isElementBlockVisible };
+};
+const scrollToElement = (options) => {
+    let { container } = options;
+    const { element, direction, behavior = 'smooth', origin = 'nearest', scrollBlockMargin = 0, scrollInlineMargin = 0, } = options;
+    if (!element || container === null) {
+        return;
+    }
+    container ||= document.documentElement;
+    const canScroll = elementCanScroll(container);
+    if (!canScroll) {
+        return;
+    }
+    const elementRect = element.getBoundingClientRect();
+    const containerRect = container.getBoundingClientRect();
+    const elementInlineSize = elementRect.width;
+    const elementBlockSize = elementRect.height;
+    const containerInlineSize = containerRect.width;
+    const containerBlockSize = containerRect.height;
+    const elementInlineStart = elementRect.left;
+    const elementBlockStart = elementRect.top;
+    const containerInlineStart = containerRect.left;
+    const containerBlockStart = containerRect.top;
+    const elementInlineEnd = elementInlineStart + elementInlineSize;
+    const elementBlockEnd = elementBlockStart + elementBlockSize;
+    const containerInlineEnd = containerInlineStart + containerInlineSize;
+    const containerBlockEnd = containerBlockStart + containerBlockSize;
+    const elementInlineCenter = elementInlineStart + elementInlineSize / 2;
+    const elementBlockCenter = elementBlockStart + elementBlockSize / 2;
+    const containerInlineCenter = containerInlineStart + containerInlineSize / 2;
+    const containerBlockCenter = containerBlockStart + containerBlockSize / 2;
+    const elementInlineOrigin = origin === 'center' ? elementInlineCenter : origin === 'end' ? elementInlineEnd : elementInlineStart;
+    const elementBlockOrigin = origin === 'center' ? elementBlockCenter : origin === 'end' ? elementBlockEnd : elementBlockStart;
+    const containerInlineOrigin = origin === 'center' ? containerInlineCenter : origin === 'end' ? containerInlineEnd : containerInlineStart;
+    const containerBlockOrigin = origin === 'center' ? containerBlockCenter : origin === 'end' ? containerBlockEnd : containerBlockStart;
+    const inlineOffset = elementInlineOrigin - containerInlineOrigin - scrollInlineMargin;
+    const blockOffset = elementBlockOrigin - containerBlockOrigin - scrollBlockMargin;
+    let inlineScroll = direction === 'block' ? undefined : inlineOffset;
+    let blockScroll = direction === 'inline' ? undefined : blockOffset;
+    if (origin === 'nearest') {
+        const elVisible = isElementVisible({ element, container });
+        if (elVisible?.inline && elVisible?.block) {
+            return;
+        }
+        if (elVisible?.inline) {
+            inlineScroll = undefined;
+        }
+        if (elVisible?.block) {
+            blockScroll = undefined;
+        }
+    }
+    container.scrollTo({
+        left: inlineScroll,
+        top: blockScroll,
+        behavior,
+    });
 };
 
-/* eslint-disable @typescript-eslint/no-explicit-any */
-/* eslint-disable no-var */
-/**
- * Stolen from klona to avoid adding a dependency
- * https://github.com/lukeed/klona
- *
- * MIT License
- *
- * Copyright (c) Luke Edwards <luke.edwards05@gmail.com> (lukeed.com)
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- */
-const set = (obj, key, val) => {
-    if (typeof val.value === 'object')
-        val.value = clone(val.value);
-    if (!val.enumerable || val.get || val.set || !val.configurable || !val.writable || key === '__proto__') {
-        Object.defineProperty(obj, key, val);
+const scrollBehaviorSupported = supportsScrollBehavior();
+class SmartBlockScrollStrategy {
+    constructor(_viewportRuler, _routerState, document) {
+        this._viewportRuler = _viewportRuler;
+        this._routerState = _routerState;
+        this._previousHTMLStyles = { top: '', left: '' };
+        this._previousScrollPosition = { top: 0, left: 0 };
+        this._isEnabled = false;
+        this._urlSubscription = null;
+        this._didNavigate = false;
+        this._document = document;
     }
-    else
-        obj[key] = val.value;
+    attach() {
+        // noop
+    }
+    enable() {
+        if (this._canBeEnabled()) {
+            const root = this._document.documentElement;
+            this._previousScrollPosition = this._viewportRuler.getViewportScrollPosition();
+            this._didNavigate = false;
+            this._previousHTMLStyles.left = root.style.left || '';
+            this._previousHTMLStyles.top = root.style.top || '';
+            root.style.left = coerceCssPixelValue(-this._previousScrollPosition.left);
+            root.style.top = coerceCssPixelValue(-this._previousScrollPosition.top);
+            root.classList.add('cdk-global-scrollblock');
+            this._isEnabled = true;
+            this._urlSubscription = this._routerState.route$
+                .pipe(skip(1), take(1), tap(() => {
+                this._didNavigate = true;
+            }))
+                .subscribe();
+        }
+    }
+    disable() {
+        if (this._isEnabled) {
+            this._urlSubscription?.unsubscribe();
+            const html = this._document.documentElement;
+            const body = this._document.body;
+            const htmlStyle = html.style;
+            const bodyStyle = body.style;
+            const previousHtmlScrollBehavior = htmlStyle.scrollBehavior || '';
+            const previousBodyScrollBehavior = bodyStyle.scrollBehavior || '';
+            this._isEnabled = false;
+            htmlStyle.left = this._previousHTMLStyles.left;
+            htmlStyle.top = this._previousHTMLStyles.top;
+            html.classList.remove('cdk-global-scrollblock');
+            if (scrollBehaviorSupported) {
+                htmlStyle.scrollBehavior = bodyStyle.scrollBehavior = 'auto';
+            }
+            if (!this._didNavigate) {
+                window.scroll(this._previousScrollPosition.left, this._previousScrollPosition.top);
+            }
+            if (scrollBehaviorSupported) {
+                htmlStyle.scrollBehavior = previousHtmlScrollBehavior;
+                bodyStyle.scrollBehavior = previousBodyScrollBehavior;
+            }
+        }
+    }
+    _canBeEnabled() {
+        const html = this._document.documentElement;
+        if (html.classList.contains('cdk-global-scrollblock') || this._isEnabled) {
+            return false;
+        }
+        return true;
+    }
+}
+
+const provideViewportConfig = (viewportConfig) => {
+    return { provide: VIEWPORT_CONFIG, useValue: viewportConfig };
 };
-const clone = (original) => {
-    if (typeof original !== 'object')
-        return original;
-    var _og = original;
-    var i = 0, k, list, tmp, str = Object.prototype.toString.call(_og);
-    if (str === '[object Object]') {
-        tmp = Object.create(_og.__proto__ || null);
+
+const ANIMATABLE_TOKEN = new InjectionToken('ANIMATABLE_DIRECTIVE_TOKEN');
+class AnimatableDirective {
+    constructor() {
+        this._didEmitStart = false;
+        this._parent = inject(ANIMATABLE_TOKEN, { optional: true, skipSelf: true });
+        this._destroy$ = createDestroy();
+        this._elementRef = inject(ElementRef);
+        this._animationStart$ = new Subject();
+        this._animationEnd$ = new Subject();
+        this._animatedElement$ = new BehaviorSubject(this._elementRef.nativeElement);
+        this.animationStart$ = this._animationStart$.asObservable().pipe(debounceTime(0));
+        this.animationEnd$ = this._animationEnd$.asObservable().pipe(debounceTime(0));
+        this._hostActiveAnimationCount$ = new BehaviorSubject(0);
+        this._totalActiveAnimationCount$ = new BehaviorSubject(0);
+        this.isAnimating$ = this._totalActiveAnimationCount$.pipe(map((count) => count > 0), debounceTime(0));
     }
-    else if (str === '[object Array]') {
-        tmp = Array(_og.length);
+    set animatedElement(value) {
+        let newElement = null;
+        if (value === null || value === undefined) {
+            newElement = this._elementRef.nativeElement;
+        }
+        else if (typeof value === 'string') {
+            const el = document.querySelector(value);
+            if (el) {
+                newElement = el;
+            }
+            else {
+                if (isDevMode()) {
+                    console.warn(`Element with selector ${value} not found. Animatable directive will use host element.`);
+                }
+                newElement = this._elementRef.nativeElement;
+            }
+        }
+        else {
+            newElement = value;
+        }
+        if (this._animatedElement$.value !== newElement) {
+            this._animatedElement$.next(newElement);
+        }
     }
-    else if (str === '[object Set]') {
-        tmp = new Set();
-        _og.forEach(function (val) {
-            tmp.add(clone(val));
-        });
+    ngOnInit() {
+        this._animatedElement$
+            .pipe(tap((el) => {
+            this._totalActiveAnimationCount$.next(this._totalActiveAnimationCount$.value - this._hostActiveAnimationCount$.value);
+            this._hostActiveAnimationCount$.next(0);
+            merge(fromEvent(el, 'animationstart'), fromEvent(el, 'transitionstart'))
+                .pipe(filter((e) => e.target === el), // skip events from children
+            tap(() => {
+                const count = this._hostActiveAnimationCount$.value + 1;
+                this._hostActiveAnimationCount$.next(count);
+                this._totalActiveAnimationCount$.next(count);
+            }), takeUntil(this._destroy$), takeUntil(this._animatedElement$.pipe(skip(1))))
+                .subscribe();
+            merge(fromEvent(el, 'animationend'), fromEvent(el, 'animationcancel'), fromEvent(el, 'transitionend'), fromEvent(el, 'transitioncancel'))
+                .pipe(filter((e) => e.target === el), // skip events from children
+            tap(() => {
+                const count = this._hostActiveAnimationCount$.value - 1;
+                this._hostActiveAnimationCount$.next(count);
+                this._totalActiveAnimationCount$.next(count);
+            }), takeUntil(this._destroy$), takeUntil(this._animatedElement$.pipe(skip(1))))
+                .subscribe();
+        }), takeUntil(this._destroy$))
+            .subscribe();
+        this._totalActiveAnimationCount$
+            .pipe(tap((count) => {
+            if (count > 0 && !this._didEmitStart) {
+                this._animationStart$.next();
+                this._didEmitStart = true;
+            }
+            else if (count === 0) {
+                this._animationEnd$.next();
+                this._didEmitStart = false;
+            }
+        }), takeUntil(this._destroy$))
+            .subscribe();
+        if (this._parent) {
+            this._parent._hostActiveAnimationCount$
+                .pipe(takeUntil(this._destroy$), tap((count) => {
+                this._totalActiveAnimationCount$.next(count + this._hostActiveAnimationCount$.value);
+            }))
+                .subscribe();
+        }
     }
-    else if (str === '[object Map]') {
-        tmp = new Map();
-        _og.forEach(function (val, key) {
-            tmp.set(clone(key), clone(val));
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: AnimatableDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.0", type: AnimatableDirective, isStandalone: true, selector: "[etAnimatable]", inputs: { animatedElement: ["etAnimatable", "animatedElement"] }, providers: [
+            {
+                provide: ANIMATABLE_TOKEN,
+                useExisting: AnimatableDirective,
+            },
+        ], exportAs: ["etAnimatable"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: AnimatableDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[etAnimatable]',
+                    exportAs: 'etAnimatable',
+                    standalone: true,
+                    providers: [
+                        {
+                            provide: ANIMATABLE_TOKEN,
+                            useExisting: AnimatableDirective,
+                        },
+                    ],
+                }]
+        }], propDecorators: { animatedElement: [{
+                type: Input,
+                args: ['etAnimatable']
+            }] } });
+
+const ANIMATED_LIFECYCLE_TOKEN = new InjectionToken('ANIMATED_LIFECYCLE_DIRECTIVE_TOKEN');
+const ANIMATION_CLASSES = {
+    enterFrom: 'et-animation-enter-from',
+    enterActive: 'et-animation-enter-active',
+    enterTo: 'et-animation-enter-to',
+    leaveFrom: 'et-animation-leave-from',
+    leaveActive: 'et-animation-leave-active',
+    leaveTo: 'et-animation-leave-to',
+};
+class AnimatedLifecycleDirective {
+    constructor() {
+        this._destroy$ = createDestroy();
+        this._elementRef = inject(ElementRef);
+        this._animatable = inject(ANIMATABLE_TOKEN);
+        this._classList = this._elementRef.nativeElement.classList;
+        this._state$ = new BehaviorSubject('init');
+        this.state$ = this._state$.asObservable();
+        this._bindings = createReactiveBindings({
+            attribute: 'class.et-force-invisible',
+            observable: this._state$.pipe(map((state) => state === 'init')),
         });
     }
-    else if (str === '[object Date]') {
-        tmp = new Date(+_og);
-    }
-    else if (str === '[object RegExp]') {
-        tmp = new RegExp(_og.source, _og.flags);
-    }
-    else if (str === '[object DataView]') {
-        tmp = new _og.constructor(clone(_og.buffer));
-    }
-    else if (str === '[object ArrayBuffer]') {
-        tmp = _og.slice(0);
-    }
-    else if (str.slice(-6) === 'Array]') {
-        // ArrayBuffer.isView(x)
-        // ~> `new` bcuz `Buffer.slice` => ref
-        tmp = new _og.constructor(_og);
+    get state() {
+        return this._state$.value;
     }
-    if (tmp) {
-        for (list = Object.getOwnPropertySymbols(_og); i < list.length; i++) {
-            set(tmp, list[i], Object.getOwnPropertyDescriptor(_og, list[i]));
+    enter(config) {
+        if (this.state !== 'init' && this.state !== 'left' && isDevMode()) {
+            console.warn('Tried to enter but the element is not in the initial state. This may result in unexpected behavior.', this);
         }
-        for (i = 0, list = Object.getOwnPropertyNames(_og); i < list.length; i++) {
-            if (Object.hasOwnProperty.call(tmp, (k = list[i])) && tmp[k] === _og[k])
-                continue;
-            set(tmp, k, Object.getOwnPropertyDescriptor(_og, k));
+        this._state$.next('entering');
+        if (!config?.onlyTransition) {
+            this._classList.add(ANIMATION_CLASSES.enterFrom);
         }
-    }
-    return tmp || _og;
-};
-
-const hasCookie = (name) => {
-    if (typeof document === 'undefined') {
-        return false;
-    }
-    return document.cookie.split(';').some((c) => {
-        return c.trim().startsWith(name + '=');
-    });
-};
-const getCookie = (name) => {
-    if (typeof document === 'undefined') {
-        return null;
-    }
-    // From https://stackoverflow.com/questions/10730362/get-cookie-by-name
-    return ('; ' + document.cookie).split(`; ${name}=`).pop()?.split(';')[0];
-};
-const setCookie = (name, data, expiresInDays = 30, domain = getDomain()) => {
-    if (typeof document === 'undefined') {
-        return;
-    }
-    const date = new Date();
-    date.setTime(date.getTime() + expiresInDays * 24 * 60 * 60 * 1000);
-    document.cookie = `${name}=${data}; path=/; expires=${date.toUTCString()}; domain=${domain}; SameSite=Lax;`;
-};
-const deleteCookie = (name, path, domain = getDomain()) => {
-    if (hasCookie(name)) {
-        document.cookie =
-            name +
-                '=' +
-                (path ? ';path=' + path : '') +
-                (domain ? ';domain=' + domain : '') +
-                ';expires=Thu, 01 Jan 1970 00:00:01 GMT';
-    }
-};
-const getDomain = () => {
-    if (typeof navigator === 'undefined') {
-        return null;
-    }
-    const hostname = window.location.hostname;
-    if (hostname.includes('localhost')) {
-        return 'localhost';
-    }
-    const splitHost = hostname.split('.');
-    if (splitHost.length > 2) {
-        return `${splitHost[splitHost.length - 2]}.${splitHost[splitHost.length - 1]}`;
-    }
-    return hostname;
-};
-
-/* eslint-disable @typescript-eslint/no-explicit-any */
-/* eslint-disable no-var */
-/**
- * Stolen from dequal to avoid adding a dependency
- * https://github.com/lukeed/dequal
- *
- * The MIT License (MIT)
- *
- * Copyright (c) Luke Edwards <luke.edwards05@gmail.com> (lukeed.com)
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- */
-const has = Object.prototype.hasOwnProperty;
-function find(iter, tar, key) {
-    for (key of iter.keys()) {
-        if (equal(key, tar))
-            return key;
-    }
-}
-const equal = (foo, bar) => {
-    var ctor, len, tmp;
-    if (foo === bar)
-        return true;
-    if (foo && bar && (ctor = foo.constructor) === bar.constructor) {
-        if (ctor === Date)
-            return foo.getTime() === bar.getTime();
-        if (ctor === RegExp)
-            return foo.toString() === bar.toString();
-        if (ctor === Array) {
-            if ((len = foo.length) === bar.length) {
-                while (len-- && equal(foo[len], bar[len]))
-                    ;
+        forceReflow();
+        this._classList.add(ANIMATION_CLASSES.enterActive);
+        fromNextFrame()
+            .pipe(tap(() => {
+            if (!config?.onlyTransition) {
+                this._classList.remove(ANIMATION_CLASSES.enterFrom);
+                this._classList.add(ANIMATION_CLASSES.enterTo);
             }
-            return len === -1;
+        }), switchMap(() => this._animatable.animationEnd$), tap(() => {
+            this._state$.next('entered');
+            this._classList.remove(ANIMATION_CLASSES.enterActive);
+            if (!config?.onlyTransition) {
+                this._classList.remove(ANIMATION_CLASSES.enterTo);
+            }
+        }), takeUntil(this._destroy$), take(1))
+            .subscribe();
+    }
+    leave(config) {
+        if (this.state !== 'entered' && this.state !== 'entering' && isDevMode()) {
+            console.warn('Tried to leave while already leaving or left. This may result in unexpected behavior.', this);
         }
-        if (ctor === Set) {
-            if (foo.size !== bar.size) {
-                return false;
+        if (this._classList.contains(ANIMATION_CLASSES.enterFrom) ||
+            this._classList.contains(ANIMATION_CLASSES.enterActive) ||
+            this._classList.contains(ANIMATION_CLASSES.enterTo)) {
+            this._classList.remove(ANIMATION_CLASSES.enterFrom);
+            this._classList.remove(ANIMATION_CLASSES.enterActive);
+            this._classList.remove(ANIMATION_CLASSES.enterTo);
+        }
+        this._state$.next('leaving');
+        if (!config?.onlyTransition) {
+            this._classList.add(ANIMATION_CLASSES.leaveFrom);
+        }
+        forceReflow();
+        this._classList.add(ANIMATION_CLASSES.leaveActive);
+        fromNextFrame()
+            .pipe(tap(() => {
+            if (!config?.onlyTransition) {
+                this._classList.remove(ANIMATION_CLASSES.leaveFrom);
+                this._classList.add(ANIMATION_CLASSES.leaveTo);
             }
-            for (len of foo) {
-                tmp = len;
-                if (tmp && typeof tmp === 'object') {
-                    tmp = find(bar, tmp);
-                    if (!tmp)
-                        return false;
-                }
-                if (!bar.has(tmp))
-                    return false;
+        }), switchMap(() => this._animatable.animationEnd$), tap(() => {
+            this._state$.next('left');
+            this._classList.remove(ANIMATION_CLASSES.leaveActive);
+            if (!config?.onlyTransition) {
+                this._classList.remove(ANIMATION_CLASSES.leaveTo);
             }
-            return true;
-        }
-        if (ctor === Map) {
-            if (foo.size !== bar.size) {
-                return false;
+        }), takeUntil(this._destroy$), take(1))
+            .subscribe();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: AnimatedLifecycleDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.0", type: AnimatedLifecycleDirective, isStandalone: true, selector: "[etAnimatedLifecycle]", providers: [
+            {
+                provide: ANIMATED_LIFECYCLE_TOKEN,
+                useExisting: AnimatedLifecycleDirective,
+            },
+        ], exportAs: ["etAnimatedLifecycle"], hostDirectives: [{ directive: AnimatableDirective }], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: AnimatedLifecycleDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[etAnimatedLifecycle]',
+                    exportAs: 'etAnimatedLifecycle',
+                    standalone: true,
+                    providers: [
+                        {
+                            provide: ANIMATED_LIFECYCLE_TOKEN,
+                            useExisting: AnimatedLifecycleDirective,
+                        },
+                    ],
+                    hostDirectives: [AnimatableDirective],
+                }]
+        }] });
+
+class AnimatedOverlayDirective {
+    constructor() {
+        this._destroy$ = createDestroy();
+        this._overlayService = inject(Overlay);
+        this._injector = inject(Injector);
+        this._viewContainerRef = inject(ViewContainerRef);
+        this._zone = inject(NgZone);
+        this._elementRef = inject(ElementRef);
+        this._portal = null;
+        this._overlayRef = null;
+        this._componentRef = null;
+        this._popper = null;
+        this._beforeOpened = null;
+        this._afterOpened = null;
+        this._beforeClosed = null;
+        this._afterClosed = null;
+        /**
+         * The placement of the tooltip.
+         * @default 'auto'
+         */
+        this.placement = 'auto';
+        /**
+         * The offset of the tooltip.
+         * @see https://popper.js.org/docs/v2/modifiers/offset/#offset-1
+         */
+        this.offset = null;
+        /**
+         * The arrow padding.
+         * @see https://popper.js.org/docs/v2/modifiers/arrow/#padding
+         * @default 4
+         */
+        this.arrowPadding = null;
+    }
+    get isMounted() {
+        return !!this._componentRef;
+    }
+    get portal() {
+        return this._portal;
+    }
+    get overlayRef() {
+        return this._overlayRef;
+    }
+    get componentRef() {
+        return this._componentRef;
+    }
+    get popper() {
+        return this._popper;
+    }
+    mount(config) {
+        const { component, providers, data } = config;
+        this._beforeOpened?.next();
+        const injector = Injector.create({
+            parent: this._injector,
+            providers: providers ?? [],
+        });
+        this._overlayRef = this._overlayService.create();
+        this._portal = this._portal ?? new ComponentPortal(component, this._viewContainerRef, injector);
+        this._componentRef = this._overlayRef.attach(this._portal);
+        if (data) {
+            Object.assign(this._componentRef.instance, data);
+        }
+        this._componentRef.instance._markForCheck?.();
+        this._zone.runOutsideAngular(() => {
+            if (!this._componentRef) {
+                return;
             }
-            for (len of foo) {
-                tmp = len[0];
-                if (tmp && typeof tmp === 'object') {
-                    tmp = find(bar, tmp);
-                    if (!tmp)
-                        return false;
-                }
-                if (!equal(len[1], bar.get(tmp))) {
-                    return false;
+            this._popper = createPopper(this._elementRef.nativeElement, this._componentRef.location.nativeElement, {
+                placement: this.placement,
+                modifiers: [
+                    ...(this.offset
+                        ? [
+                            {
+                                name: 'offset',
+                                options: {
+                                    offset: this.offset,
+                                },
+                            },
+                        ]
+                        : []),
+                    ...(this.arrowPadding
+                        ? [
+                            {
+                                name: 'arrow',
+                                options: {
+                                    padding: this.arrowPadding,
+                                },
+                            },
+                        ]
+                        : []),
+                ],
+            });
+            // We need to wait for the tooltip content to be rendered
+            nextFrame(() => {
+                if (!this._componentRef) {
+                    return;
                 }
-            }
-            return true;
+                this._popper?.update();
+                this._componentRef.instance._animatedLifecycle?.enter();
+                this._componentRef.instance._animatedLifecycle?.state$
+                    .pipe(tap((s) => {
+                    if (s === 'entered') {
+                        this._afterOpened?.next();
+                    }
+                }), take(1), takeUntil(this._destroy$))
+                    .subscribe();
+            });
+        });
+    }
+    unmount() {
+        if (!this._componentRef) {
+            return;
         }
-        if (ctor === ArrayBuffer) {
-            foo = new Uint8Array(foo);
-            bar = new Uint8Array(bar);
+        this._beforeClosed?.next();
+        this._componentRef.instance._animatedLifecycle?.leave();
+        this._componentRef.instance._animatedLifecycle?.state$
+            .pipe(filter((s) => s === 'left'), take(1))
+            .subscribe(() => this._destroy());
+    }
+    beforeOpened() {
+        if (!this._beforeOpened) {
+            this._beforeOpened = new Subject();
         }
-        else if (ctor === DataView) {
-            if ((len = foo.byteLength) === bar.byteLength) {
-                while (len-- && foo.getInt8(len) === bar.getInt8(len))
-                    ;
-            }
-            return len === -1;
+        return this._beforeOpened;
+    }
+    afterOpened() {
+        if (!this._afterOpened) {
+            this._afterOpened = new Subject();
         }
-        if (ArrayBuffer.isView(foo)) {
-            if ((len = foo.byteLength) === bar.byteLength) {
-                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-                //@ts-ignore
-                while (len-- && foo[len] === bar[len])
-                    ;
-            }
-            return len === -1;
+        return this._afterOpened;
+    }
+    beforeClosed() {
+        if (!this._beforeClosed) {
+            this._beforeClosed = new Subject();
         }
-        if (!ctor || typeof foo === 'object') {
-            len = 0;
-            for (ctor in foo) {
-                if (has.call(foo, ctor) && ++len && !has.call(bar, ctor))
-                    return false;
-                if (!(ctor in bar) || !equal(foo[ctor], bar[ctor]))
-                    return false;
-            }
-            return Object.keys(bar).length === len;
+        return this._beforeClosed;
+    }
+    afterClosed() {
+        if (!this._afterClosed) {
+            this._afterClosed = new Subject();
         }
+        return this._afterClosed;
     }
-    return foo !== foo && bar !== bar;
-};
-
-const createMediaQueryObservable = (query) => {
-    const mq = window.matchMedia(query);
-    const observable = new Observable((observer) => {
-        const eventHandler = (event) => {
-            observer.next(event);
-        };
-        mq.addEventListener('change', eventHandler);
-        return () => {
-            mq.removeEventListener('change', eventHandler);
-        };
-    }).pipe(startWith(mq), map(({ matches }) => ({
-        matches,
-        query,
-    })));
-    return observable;
-};
+    _destroy() {
+        this._zone.runOutsideAngular(() => {
+            this._popper?.destroy();
+            this._popper = null;
+        });
+        if (this._overlayRef) {
+            this._overlayRef.dispose();
+            this._overlayRef = null;
+        }
+        if (this._componentRef) {
+            this._componentRef.destroy();
+            this._componentRef = null;
+        }
+        this._afterClosed?.next();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: AnimatedOverlayDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.0", type: AnimatedOverlayDirective, isStandalone: true, inputs: { placement: "placement", offset: "offset", arrowPadding: "arrowPadding" }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: AnimatedOverlayDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    standalone: true,
+                }]
+        }], propDecorators: { placement: [{
+                type: Input
+            }], offset: [{
+                type: Input
+            }], arrowPadding: [{
+                type: Input
+            }] } });
 
-const isAttributeRenderBinding = (value) => typeof value === 'boolean';
-const isAttributeValueBinding = (value) => typeof value === 'object';
-const createReactiveBindings = (...values) => {
-    const rootElementRef = inject(ElementRef);
-    const destroy$ = inject(DestroyService, { host: true }).destroy$;
-    const subscriptions = [];
-    const pushedAttributes = [];
-    const defaults = {};
-    const push = (value) => {
-        const { attribute, observable, elementRef } = value;
-        const elRef = elementRef || rootElementRef;
-        const attributes = Array.isArray(attribute) ? attribute : [attribute];
-        pushedAttributes.push(attributes);
-        for (const attribute of attributes) {
-            if (!defaults[attribute]) {
-                defaults[attribute] = elRef.nativeElement.getAttribute(attribute) || undefined;
-            }
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+class ClickObserverFactory {
+    create() {
+        return fromEvent(document, 'click');
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: ClickObserverFactory, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: ClickObserverFactory, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: ClickObserverFactory, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+class ClickObserverService {
+    constructor(_clickObserverFactory) {
+        this._clickObserverFactory = _clickObserverFactory;
+        this._observedElements = new Map();
+    }
+    ngOnDestroy() {
+        this._observedElements.forEach((_, element) => this._cleanupObserver(element));
+    }
+    observe(elementOrRef) {
+        const element = coerceElement(elementOrRef);
+        return new Observable((observer) => {
+            const stream = this._observeElement(element);
+            const subscription = stream.subscribe(observer);
+            return () => {
+                subscription.unsubscribe();
+                this._unobserveElement(element);
+            };
+        });
+    }
+    _observeElement(element) {
+        if (!this._observedElements.has(element)) {
+            const stream = new Subject();
+            const observer = this._clickObserverFactory.create();
+            const sub = observer.subscribe((event) => stream.next(event));
+            this._observedElements.set(element, { observer: sub, stream, count: 1 });
         }
-        const subscription = observable
-            .pipe(takeUntil(destroy$), distinctUntilChanged((a, b) => {
-            if (isAttributeRenderBinding(a) && isAttributeRenderBinding(b)) {
-                return a === b;
-            }
-            else if (isAttributeValueBinding(a) && isAttributeValueBinding(b)) {
-                return a.render === b.render && a.value === b.value;
+        else {
+            this._observedElements.get(element).count++;
+        }
+        return this._observedElements.get(element).stream;
+    }
+    _unobserveElement(element) {
+        if (this._observedElements.has(element)) {
+            this._observedElements.get(element).count--;
+            if (!this._observedElements.get(element).count) {
+                this._cleanupObserver(element);
             }
-            return false;
-        }))
-            .subscribe((value) => {
-            const currentAttributes = pushedAttributes.find((s) => s.some((current) => attributes.includes(current))) || [];
-            for (const attribute of currentAttributes) {
-                const isSingleClassMutation = attribute.startsWith('class.');
-                const isMultipleClassMutation = attribute === 'class';
-                const render = isAttributeRenderBinding(value) ? value : value.render;
-                if (isSingleClassMutation) {
-                    const className = attribute.replace('class.', '');
-                    if (!className) {
-                        continue;
-                    }
-                    if (!render) {
-                        elRef.nativeElement.classList.remove(className);
-                    }
-                    else {
-                        elRef.nativeElement.classList.add(className);
-                    }
-                }
-                else if (isMultipleClassMutation) {
-                    const classes = isAttributeRenderBinding(value) ? '' : `${value.value}`;
-                    if (!classes) {
-                        continue;
-                    }
-                    if (!render) {
-                        elRef.nativeElement.classList.remove(...classes.split(' '));
-                    }
-                    else {
-                        elRef.nativeElement.classList.add(...classes.split(' '));
-                    }
-                }
-                else {
-                    const attributeValue = isAttributeRenderBinding(value) ? true : `${value.value}`;
-                    if (!attribute) {
-                        continue;
-                    }
-                    if (!render) {
-                        elRef.nativeElement.removeAttribute(attribute);
-                    }
-                    else {
-                        elRef.nativeElement.setAttribute(attribute, `${attributeValue}`);
-                    }
-                }
+        }
+    }
+    _cleanupObserver(element) {
+        if (this._observedElements.has(element)) {
+            const { observer, stream } = this._observedElements.get(element);
+            if (observer) {
+                observer.unsubscribe();
             }
+            stream.complete();
+            this._observedElements.delete(element);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: ClickObserverService, deps: [{ token: ClickObserverFactory }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: ClickObserverService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: ClickObserverService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: ClickObserverFactory }]; } });
+
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+class MutationObserverFactory {
+    create(callback) {
+        return typeof MutationObserver === 'undefined' ? null : new MutationObserver(callback);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: MutationObserverFactory, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: MutationObserverFactory, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: MutationObserverFactory, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+class ContentObserverService {
+    constructor(_mutationObserverFactory) {
+        this._mutationObserverFactory = _mutationObserverFactory;
+        this._observedElements = new Map();
+    }
+    ngOnDestroy() {
+        this._observedElements.forEach((_, element) => this._cleanupObserver(element));
+    }
+    observe(elementOrRef) {
+        const element = coerceElement(elementOrRef);
+        return new Observable((observer) => {
+            const stream = this._observeElement(element);
+            const subscription = stream.subscribe(observer);
+            return () => {
+                subscription.unsubscribe();
+                this._unobserveElement(element);
+            };
         });
-        subscriptions.push({ attributes, subscription });
-    };
-    const remove = (...attributes) => {
-        for (const attribute of attributes) {
-            const sub = subscriptions.find((s) => s.attributes.includes(attribute));
-            const attributeStack = pushedAttributes.find((a) => a.includes(attribute));
-            if (sub) {
-                sub.attributes = sub.attributes.filter((a) => a !== attribute);
-                attributeStack?.splice(attributeStack.indexOf(attribute), 1);
-                if (sub.attributes.length === 0) {
-                    sub.subscription.unsubscribe();
-                    subscriptions.splice(subscriptions.indexOf(sub), 1);
-                }
+    }
+    _observeElement(element) {
+        if (!this._observedElements.has(element)) {
+            const stream = new Subject();
+            const observer = this._mutationObserverFactory.create((mutations) => stream.next(mutations));
+            if (observer) {
+                observer.observe(element, {
+                    characterData: true,
+                    childList: true,
+                    subtree: true,
+                });
+            }
+            this._observedElements.set(element, { observer, stream, count: 1 });
+        }
+        else {
+            this._observedElements.get(element).count++;
+        }
+        return this._observedElements.get(element).stream;
+    }
+    _unobserveElement(element) {
+        if (this._observedElements.has(element)) {
+            this._observedElements.get(element).count--;
+            if (!this._observedElements.get(element).count) {
+                this._cleanupObserver(element);
             }
         }
-    };
-    const reset = () => {
-        for (const attribute in defaults) {
-            if (defaults[attribute] === undefined) {
-                rootElementRef.nativeElement.removeAttribute(attribute);
-            }
-            else {
-                rootElementRef.nativeElement.setAttribute(attribute, defaults[attribute]);
+    }
+    _cleanupObserver(element) {
+        if (this._observedElements.has(element)) {
+            const { observer, stream } = this._observedElements.get(element);
+            if (observer) {
+                observer.disconnect();
             }
+            stream.complete();
+            this._observedElements.delete(element);
         }
-    };
-    for (const value of values) {
-        push(value);
     }
-    return {
-        push,
-        remove,
-        reset,
-    };
-};
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: ContentObserverService, deps: [{ token: MutationObserverFactory }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: ContentObserverService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: ContentObserverService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: MutationObserverFactory }]; } });
 
-/* eslint-disable @typescript-eslint/no-explicit-any */
-class BehaviorSubjectWithSubscriberCount extends BehaviorSubject {
-    constructor() {
-        super(...arguments);
-        this._subscriberCount = 0;
+class FocusVisibleService {
+    get isFocusVisible() {
+        return this._hadKeyboardEvent;
     }
-    get subscriberCount() {
-        return this._subscriberCount;
+    constructor() {
+        this._document = inject(DOCUMENT);
+        this._hadKeyboardEvent = false;
+        this._document.addEventListener('keydown', this.onKeyDown.bind(this), true);
+        this._document.addEventListener('mousedown', this.onPointerDown.bind(this), true);
+        this._document.addEventListener('pointerdown', this.onPointerDown.bind(this), true);
+        this._document.addEventListener('touchstart', this.onPointerDown.bind(this), true);
     }
-    subscribe(observerOrNext) {
-        this._subscriberCount++;
-        const sub = super.subscribe(observerOrNext);
-        return {
-            ...sub,
-            unsubscribe: () => {
-                sub.unsubscribe();
-                this._subscriberCount--;
-            },
-        };
+    onKeyDown(e) {
+        if (e.metaKey || e.altKey || e.ctrlKey) {
+            return;
+        }
+        this._hadKeyboardEvent = true;
     }
-    unsubscribe() {
-        this._subscriberCount--;
-        return super.unsubscribe();
+    onPointerDown() {
+        this._hadKeyboardEvent = false;
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: FocusVisibleService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: FocusVisibleService, providedIn: 'root' }); }
 }
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: FocusVisibleService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return []; } });
 
-const elementCanScroll = (element) => {
-    const { scrollHeight, clientHeight, scrollWidth, clientWidth } = element;
-    return scrollHeight > clientHeight || scrollWidth > clientWidth;
-};
-const isElementVisible = (options) => {
-    let { container } = options;
-    const { element } = options;
-    if (!element || container === null) {
-        return null;
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+class ResizeObserverFactory {
+    create(callback) {
+        return typeof ResizeObserver === 'undefined' ? null : new ResizeObserver(callback);
     }
-    container ||= document.documentElement;
-    const canScroll = elementCanScroll(container);
-    if (!canScroll) {
-        return { inline: true, block: true };
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: ResizeObserverFactory, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: ResizeObserverFactory, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: ResizeObserverFactory, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+class ResizeObserverService {
+    constructor(_mutationObserverFactory) {
+        this._mutationObserverFactory = _mutationObserverFactory;
+        this._observedElements = new Map();
     }
-    const elementRect = element.getBoundingClientRect();
-    const containerRect = container.getBoundingClientRect();
-    const elementInlineStart = elementRect.left;
-    const elementBlockStart = elementRect.top;
-    const containerInlineStart = containerRect.left;
-    const containerBlockStart = containerRect.top;
-    const elementInlineEnd = elementInlineStart + elementRect.width;
-    const elementBlockEnd = elementBlockStart + elementRect.height;
-    const containerInlineEnd = containerInlineStart + containerRect.width;
-    const containerBlockEnd = containerBlockStart + containerRect.height;
-    const isElementInlineVisible = elementInlineStart >= containerInlineStart && elementInlineEnd <= containerInlineEnd;
-    const isElementBlockVisible = elementBlockStart >= containerBlockStart && elementBlockEnd <= containerBlockEnd;
-    return { inline: isElementInlineVisible, block: isElementBlockVisible };
-};
-const scrollToElement = (options) => {
-    let { container } = options;
-    const { element, direction, behavior = 'smooth', origin = 'nearest', scrollBlockMargin = 0, scrollInlineMargin = 0, } = options;
-    if (!element || container === null) {
-        return;
+    ngOnDestroy() {
+        this._observedElements.forEach((_, element) => this._cleanupObserver(element));
     }
-    container ||= document.documentElement;
-    const canScroll = elementCanScroll(container);
-    if (!canScroll) {
-        return;
+    observe(elementOrRef) {
+        const element = coerceElement(elementOrRef);
+        return new Observable((observer) => {
+            const stream = this._observeElement(element);
+            const subscription = stream.subscribe(observer);
+            return () => {
+                subscription.unsubscribe();
+                this._unobserveElement(element);
+            };
+        });
     }
-    const elementRect = element.getBoundingClientRect();
-    const containerRect = container.getBoundingClientRect();
-    const elementInlineSize = elementRect.width;
-    const elementBlockSize = elementRect.height;
-    const containerInlineSize = containerRect.width;
-    const containerBlockSize = containerRect.height;
-    const elementInlineStart = elementRect.left;
-    const elementBlockStart = elementRect.top;
-    const containerInlineStart = containerRect.left;
-    const containerBlockStart = containerRect.top;
-    const elementInlineEnd = elementInlineStart + elementInlineSize;
-    const elementBlockEnd = elementBlockStart + elementBlockSize;
-    const containerInlineEnd = containerInlineStart + containerInlineSize;
-    const containerBlockEnd = containerBlockStart + containerBlockSize;
-    const elementInlineCenter = elementInlineStart + elementInlineSize / 2;
-    const elementBlockCenter = elementBlockStart + elementBlockSize / 2;
-    const containerInlineCenter = containerInlineStart + containerInlineSize / 2;
-    const containerBlockCenter = containerBlockStart + containerBlockSize / 2;
-    const elementInlineOrigin = origin === 'center' ? elementInlineCenter : origin === 'end' ? elementInlineEnd : elementInlineStart;
-    const elementBlockOrigin = origin === 'center' ? elementBlockCenter : origin === 'end' ? elementBlockEnd : elementBlockStart;
-    const containerInlineOrigin = origin === 'center' ? containerInlineCenter : origin === 'end' ? containerInlineEnd : containerInlineStart;
-    const containerBlockOrigin = origin === 'center' ? containerBlockCenter : origin === 'end' ? containerBlockEnd : containerBlockStart;
-    const inlineOffset = elementInlineOrigin - containerInlineOrigin - scrollInlineMargin;
-    const blockOffset = elementBlockOrigin - containerBlockOrigin - scrollBlockMargin;
-    let inlineScroll = direction === 'block' ? undefined : inlineOffset;
-    let blockScroll = direction === 'inline' ? undefined : blockOffset;
-    if (origin === 'nearest') {
-        const elVisible = isElementVisible({ element, container });
-        if (elVisible?.inline && elVisible?.block) {
-            return;
-        }
-        if (elVisible?.inline) {
-            inlineScroll = undefined;
-        }
-        if (elVisible?.block) {
-            blockScroll = undefined;
+    _observeElement(element) {
+        if (!this._observedElements.has(element)) {
+            const stream = new Subject();
+            const observer = this._mutationObserverFactory.create((resizes) => stream.next(resizes));
+            if (observer) {
+                observer.observe(element);
+            }
+            this._observedElements.set(element, { observer, stream, count: 1 });
         }
-    }
-    container.scrollTo({
-        left: inlineScroll,
-        top: blockScroll,
-        behavior,
-    });
-};
-
-const scrollBehaviorSupported = supportsScrollBehavior();
-class SmartBlockScrollStrategy {
-    constructor(_viewportRuler, _routerState, document) {
-        this._viewportRuler = _viewportRuler;
-        this._routerState = _routerState;
-        this._previousHTMLStyles = { top: '', left: '' };
-        this._previousScrollPosition = { top: 0, left: 0 };
-        this._isEnabled = false;
-        this._urlSubscription = null;
-        this._didNavigate = false;
-        this._document = document;
-    }
-    attach() {
-        // noop
-    }
-    enable() {
-        if (this._canBeEnabled()) {
-            const root = this._document.documentElement;
-            this._previousScrollPosition = this._viewportRuler.getViewportScrollPosition();
-            this._didNavigate = false;
-            this._previousHTMLStyles.left = root.style.left || '';
-            this._previousHTMLStyles.top = root.style.top || '';
-            root.style.left = coerceCssPixelValue(-this._previousScrollPosition.left);
-            root.style.top = coerceCssPixelValue(-this._previousScrollPosition.top);
-            root.classList.add('cdk-global-scrollblock');
-            this._isEnabled = true;
-            this._urlSubscription = this._routerState.route$
-                .pipe(skip(1), take(1), tap(() => {
-                this._didNavigate = true;
-            }))
-                .subscribe();
+        else {
+            this._observedElements.get(element).count++;
         }
+        return this._observedElements.get(element).stream;
     }
-    disable() {
-        if (this._isEnabled) {
-            this._urlSubscription?.unsubscribe();
-            const html = this._document.documentElement;
-            const body = this._document.body;
-            const htmlStyle = html.style;
-            const bodyStyle = body.style;
-            const previousHtmlScrollBehavior = htmlStyle.scrollBehavior || '';
-            const previousBodyScrollBehavior = bodyStyle.scrollBehavior || '';
-            this._isEnabled = false;
-            htmlStyle.left = this._previousHTMLStyles.left;
-            htmlStyle.top = this._previousHTMLStyles.top;
-            html.classList.remove('cdk-global-scrollblock');
-            if (scrollBehaviorSupported) {
-                htmlStyle.scrollBehavior = bodyStyle.scrollBehavior = 'auto';
-            }
-            if (!this._didNavigate) {
-                window.scroll(this._previousScrollPosition.left, this._previousScrollPosition.top);
-            }
-            if (scrollBehaviorSupported) {
-                htmlStyle.scrollBehavior = previousHtmlScrollBehavior;
-                bodyStyle.scrollBehavior = previousBodyScrollBehavior;
+    _unobserveElement(element) {
+        if (this._observedElements.has(element)) {
+            this._observedElements.get(element).count--;
+            if (!this._observedElements.get(element).count) {
+                this._cleanupObserver(element);
             }
         }
     }
-    _canBeEnabled() {
-        const html = this._document.documentElement;
-        if (html.classList.contains('cdk-global-scrollblock') || this._isEnabled) {
-            return false;
+    _cleanupObserver(element) {
+        if (this._observedElements.has(element)) {
+            const { observer, stream } = this._observedElements.get(element);
+            if (observer) {
+                observer.disconnect();
+            }
+            stream.complete();
+            this._observedElements.delete(element);
         }
-        return true;
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: ResizeObserverService, deps: [{ token: ResizeObserverFactory }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: ResizeObserverService, providedIn: 'root' }); }
 }
-
-const provideViewportConfig = (viewportConfig) => {
-    return { provide: VIEWPORT_CONFIG, useValue: viewportConfig };
-};
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: ResizeObserverService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: ResizeObserverFactory }]; } });
 
 const routerDisableScrollTop = (config = {}) => {
     if (!config.asReturnRoute) {
@@ -1288,225 +1671,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImpor
                     type: Optional
                 }] }, { type: i1.BreakpointObserver }]; }, propDecorators: { _getViewportSize: [], _buildMediaQuery: [] } });
 
-const ANIMATABLE_TOKEN = new InjectionToken('ANIMATABLE_DIRECTIVE_TOKEN');
-class AnimatableDirective {
-    constructor() {
-        this._didEmitStart = false;
-        this._parent = inject(ANIMATABLE_TOKEN, { optional: true, skipSelf: true });
-        this._destroy$ = inject(DestroyService, { host: true }).destroy$;
-        this._elementRef = inject(ElementRef);
-        this._animationStart$ = new Subject();
-        this._animationEnd$ = new Subject();
-        this._animatedElement$ = new BehaviorSubject(this._elementRef.nativeElement);
-        this.animationStart$ = this._animationStart$.asObservable().pipe(debounceTime(0));
-        this.animationEnd$ = this._animationEnd$.asObservable().pipe(debounceTime(0));
-        this._hostActiveAnimationCount$ = new BehaviorSubject(0);
-        this._totalActiveAnimationCount$ = new BehaviorSubject(0);
-        this.isAnimating$ = this._totalActiveAnimationCount$.pipe(map((count) => count > 0), debounceTime(0));
-    }
-    set animatedElement(value) {
-        let newElement = null;
-        if (value === null || value === undefined) {
-            newElement = this._elementRef.nativeElement;
-        }
-        else if (typeof value === 'string') {
-            const el = document.querySelector(value);
-            if (el) {
-                newElement = el;
-            }
-            else {
-                if (isDevMode()) {
-                    console.warn(`Element with selector ${value} not found. Animatable directive will use host element.`);
-                }
-                newElement = this._elementRef.nativeElement;
-            }
-        }
-        else {
-            newElement = value;
-        }
-        if (this._animatedElement$.value !== newElement) {
-            this._animatedElement$.next(newElement);
-        }
-    }
-    ngOnInit() {
-        this._animatedElement$
-            .pipe(tap((el) => {
-            this._totalActiveAnimationCount$.next(this._totalActiveAnimationCount$.value - this._hostActiveAnimationCount$.value);
-            this._hostActiveAnimationCount$.next(0);
-            merge(fromEvent(el, 'animationstart'), fromEvent(el, 'transitionstart'))
-                .pipe(filter((e) => e.target === el), // skip events from children
-            tap(() => {
-                const count = this._hostActiveAnimationCount$.value + 1;
-                this._hostActiveAnimationCount$.next(count);
-                this._totalActiveAnimationCount$.next(count);
-            }), takeUntil(this._destroy$), takeUntil(this._animatedElement$.pipe(skip(1))))
-                .subscribe();
-            merge(fromEvent(el, 'animationend'), fromEvent(el, 'animationcancel'), fromEvent(el, 'transitionend'), fromEvent(el, 'transitioncancel'))
-                .pipe(filter((e) => e.target === el), // skip events from children
-            tap(() => {
-                const count = this._hostActiveAnimationCount$.value - 1;
-                this._hostActiveAnimationCount$.next(count);
-                this._totalActiveAnimationCount$.next(count);
-            }), takeUntil(this._destroy$), takeUntil(this._animatedElement$.pipe(skip(1))))
-                .subscribe();
-        }), takeUntil(this._destroy$))
-            .subscribe();
-        this._totalActiveAnimationCount$
-            .pipe(tap((count) => {
-            if (count > 0 && !this._didEmitStart) {
-                this._animationStart$.next();
-                this._didEmitStart = true;
-            }
-            else if (count === 0) {
-                this._animationEnd$.next();
-                this._didEmitStart = false;
-            }
-        }), takeUntil(this._destroy$))
-            .subscribe();
-        if (this._parent) {
-            this._parent._hostActiveAnimationCount$
-                .pipe(takeUntil(this._destroy$), tap((count) => {
-                this._totalActiveAnimationCount$.next(count + this._hostActiveAnimationCount$.value);
-            }))
-                .subscribe();
-        }
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: AnimatableDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.0", type: AnimatableDirective, isStandalone: true, selector: "[etAnimatable]", inputs: { animatedElement: ["etAnimatable", "animatedElement"] }, providers: [
-            {
-                provide: ANIMATABLE_TOKEN,
-                useExisting: AnimatableDirective,
-            },
-            DestroyService,
-        ], exportAs: ["etAnimatable"], ngImport: i0 }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: AnimatableDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    selector: '[etAnimatable]',
-                    exportAs: 'etAnimatable',
-                    standalone: true,
-                    providers: [
-                        {
-                            provide: ANIMATABLE_TOKEN,
-                            useExisting: AnimatableDirective,
-                        },
-                        DestroyService,
-                    ],
-                }]
-        }], propDecorators: { animatedElement: [{
-                type: Input,
-                args: ['etAnimatable']
-            }] } });
-
-const ANIMATED_LIFECYCLE_TOKEN = new InjectionToken('ANIMATED_LIFECYCLE_DIRECTIVE_TOKEN');
-const ANIMATION_CLASSES = {
-    enterFrom: 'et-animation-enter-from',
-    enterActive: 'et-animation-enter-active',
-    enterTo: 'et-animation-enter-to',
-    leaveFrom: 'et-animation-leave-from',
-    leaveActive: 'et-animation-leave-active',
-    leaveTo: 'et-animation-leave-to',
-};
-class AnimatedLifecycleDirective {
-    constructor() {
-        this._destroy$ = inject(DestroyService, { host: true }).destroy$;
-        this._elementRef = inject(ElementRef);
-        this._animatable = inject(ANIMATABLE_TOKEN);
-        this._classList = this._elementRef.nativeElement.classList;
-        this._state$ = new BehaviorSubject('init');
-        this.state$ = this._state$.asObservable();
-        this._bindings = createReactiveBindings({
-            attribute: 'class.et-force-invisible',
-            observable: this._state$.pipe(map((state) => state === 'init')),
-        });
-    }
-    get state() {
-        return this._state$.value;
-    }
-    enter(config) {
-        if (this.state !== 'init' && this.state !== 'left' && isDevMode()) {
-            console.warn('Tried to enter but the element is not in the initial state. This may result in unexpected behavior.', this);
-        }
-        this._state$.next('entering');
-        if (!config?.onlyTransition) {
-            this._classList.add(ANIMATION_CLASSES.enterFrom);
-        }
-        forceReflow();
-        this._classList.add(ANIMATION_CLASSES.enterActive);
-        fromNextFrame()
-            .pipe(tap(() => {
-            if (!config?.onlyTransition) {
-                this._classList.remove(ANIMATION_CLASSES.enterFrom);
-                this._classList.add(ANIMATION_CLASSES.enterTo);
-            }
-        }), switchMap(() => this._animatable.animationEnd$), tap(() => {
-            this._state$.next('entered');
-            this._classList.remove(ANIMATION_CLASSES.enterActive);
-            if (!config?.onlyTransition) {
-                this._classList.remove(ANIMATION_CLASSES.enterTo);
-            }
-        }), takeUntil(this._destroy$), take(1))
-            .subscribe();
-    }
-    leave(config) {
-        if (this.state !== 'entered' && this.state !== 'entering' && isDevMode()) {
-            console.warn('Tried to leave while already leaving or left. This may result in unexpected behavior.', this);
-        }
-        if (this._classList.contains(ANIMATION_CLASSES.enterFrom) ||
-            this._classList.contains(ANIMATION_CLASSES.enterActive) ||
-            this._classList.contains(ANIMATION_CLASSES.enterTo)) {
-            this._classList.remove(ANIMATION_CLASSES.enterFrom);
-            this._classList.remove(ANIMATION_CLASSES.enterActive);
-            this._classList.remove(ANIMATION_CLASSES.enterTo);
-        }
-        this._state$.next('leaving');
-        if (!config?.onlyTransition) {
-            this._classList.add(ANIMATION_CLASSES.leaveFrom);
-        }
-        forceReflow();
-        this._classList.add(ANIMATION_CLASSES.leaveActive);
-        fromNextFrame()
-            .pipe(tap(() => {
-            if (!config?.onlyTransition) {
-                this._classList.remove(ANIMATION_CLASSES.leaveFrom);
-                this._classList.add(ANIMATION_CLASSES.leaveTo);
-            }
-        }), switchMap(() => this._animatable.animationEnd$), tap(() => {
-            this._state$.next('left');
-            this._classList.remove(ANIMATION_CLASSES.leaveActive);
-            if (!config?.onlyTransition) {
-                this._classList.remove(ANIMATION_CLASSES.leaveTo);
-            }
-        }), takeUntil(this._destroy$), take(1))
-            .subscribe();
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: AnimatedLifecycleDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.0", type: AnimatedLifecycleDirective, isStandalone: true, selector: "[etAnimatedLifecycle]", providers: [
-            {
-                provide: ANIMATED_LIFECYCLE_TOKEN,
-                useExisting: AnimatedLifecycleDirective,
-            },
-            DestroyService,
-        ], exportAs: ["etAnimatedLifecycle"], hostDirectives: [{ directive: AnimatableDirective }], ngImport: i0 }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: AnimatedLifecycleDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    selector: '[etAnimatedLifecycle]',
-                    exportAs: 'etAnimatedLifecycle',
-                    standalone: true,
-                    providers: [
-                        {
-                            provide: ANIMATED_LIFECYCLE_TOKEN,
-                            useExisting: AnimatedLifecycleDirective,
-                        },
-                        DestroyService,
-                    ],
-                    hostDirectives: [AnimatableDirective],
-                }]
-        }] });
-
 class ClickOutsideDirective {
     constructor() {
         this._elementRef = inject(ElementRef);
@@ -1547,7 +1711,7 @@ const CURSOR_DRAG_SCROLLING_PREPARED_CLASS = 'et-cursor-drag-scroll--prepared';
 class CursorDragScrollDirective {
     constructor() {
         this._subscriptions = [];
-        this._destroy$ = inject(DestroyService, { host: true }).destroy$;
+        this._destroy$ = createDestroy();
         this._elementRef = inject(ElementRef);
         this._contentObserverService = inject(ContentObserverService);
         this._resizeObserverService = inject(ResizeObserverService);
@@ -1669,7 +1833,7 @@ class CursorDragScrollDirective {
         }
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: CursorDragScrollDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.0", type: CursorDragScrollDirective, isStandalone: true, selector: "[etCursorDragScroll]", inputs: { enabled: ["etCursorDragScroll", "enabled"] }, providers: [DestroyService], exportAs: ["etCursorDragScroll"], ngImport: i0 }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.0", type: CursorDragScrollDirective, isStandalone: true, selector: "[etCursorDragScroll]", inputs: { enabled: ["etCursorDragScroll", "enabled"] }, exportAs: ["etCursorDragScroll"], ngImport: i0 }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: CursorDragScrollDirective, decorators: [{
             type: Directive,
@@ -1677,7 +1841,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImpor
                     selector: '[etCursorDragScroll]',
                     exportAs: 'etCursorDragScroll',
                     standalone: true,
-                    providers: [DestroyService],
                 }]
         }], propDecorators: { enabled: [{
                 type: Input,
@@ -1736,6 +1899,43 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImpor
                 }]
         }] });
 
+const IS_ACTIVE_ELEMENT = new InjectionToken('ET_IS_ACTIVE_ELEMENT');
+class IsActiveElementDirective {
+    constructor() {
+        this.elementRef = inject(ElementRef);
+        this._isActiveElement = false;
+    }
+    get isActiveElement() {
+        return this._isActiveElement;
+    }
+    set isActiveElement(value) {
+        this._isActiveElement = coerceBooleanProperty(value);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: IsActiveElementDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.0", type: IsActiveElementDirective, isStandalone: true, selector: "[etIsActiveElement]", inputs: { isActiveElement: ["etIsActiveElement", "isActiveElement"] }, providers: [
+            {
+                provide: IS_ACTIVE_ELEMENT,
+                useExisting: IsActiveElementDirective,
+            },
+        ], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: IsActiveElementDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[etIsActiveElement]',
+                    standalone: true,
+                    providers: [
+                        {
+                            provide: IS_ACTIVE_ELEMENT,
+                            useExisting: IsActiveElementDirective,
+                        },
+                    ],
+                }]
+        }], propDecorators: { isActiveElement: [{
+                type: Input,
+                args: ['etIsActiveElement']
+            }] } });
+
 class LetContext {
     constructor() {
         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
@@ -1987,7 +2187,7 @@ const OBSERVE_SCROLL_STATE = new InjectionToken('OBSERVE_SCROLL_STATE');
 
 class ObserveScrollStateDirective {
     constructor() {
-        this._destroy$ = inject(DestroyService, { host: true }).destroy$;
+        this._destroy$ = createDestroy();
         this._elementRef = inject(ElementRef);
         this._contentObserverService = inject(ContentObserverService);
         this._resizeObserverService = inject(ResizeObserverService);
@@ -2125,7 +2325,6 @@ class ObserveScrollStateDirective {
                 provide: OBSERVE_SCROLL_STATE,
                 useExisting: ObserveScrollStateDirective,
             },
-            DestroyService,
         ], exportAs: ["etObserveScrollState"], ngImport: i0 }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: ObserveScrollStateDirective, decorators: [{
@@ -2139,7 +2338,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImpor
                             provide: OBSERVE_SCROLL_STATE,
                             useExisting: ObserveScrollStateDirective,
                         },
-                        DestroyService,
                     ],
                 }]
         }], propDecorators: { observerRootMargin: [{
@@ -2754,5 +2952,5 @@ const Validators = {
  * Generated bundle index. Do not edit.
  */
 
-export { ANIMATABLE_TOKEN, ANIMATED_LIFECYCLE_TOKEN, AnimatableDirective, AnimatedLifecycleDirective, BehaviorSubjectWithSubscriberCount, ClickObserverFactory, ClickObserverService, ClickOutsideDirective, ContentObserverService, CursorDragScrollDirective, DEFAULT_VIEWPORT_CONFIG, DELAYABLE_TOKEN, DelayableDirective, DestroyService, FocusVisibleService, IS_ARRAY_NOT_EMPTY, IS_EMAIL, IsArrayNotEmpty, IsEmail, LetContext, LetDirective, MUST_MATCH, Memo, MustMatch, MutationObserverFactory, NormalizeGameResultTypePipe, NormalizeMatchParticipantsPipe, NormalizeMatchScorePipe, NormalizeMatchStatePipe, NormalizeMatchTypePipe, OBSERVE_SCROLL_STATE, ObserveContentDirective, ObserveResizeDirective, ObserveScrollStateDirective, RepeatDirective, ResizeObserverFactory, ResizeObserverService, RouterStateService, SCROLL_OBSERVER_FIRST_ELEMENT_CLASS, SCROLL_OBSERVER_IGNORE_TARGET_CLASS, SCROLL_OBSERVER_LAST_ELEMENT_CLASS, SEO_DIRECTIVE_TOKEN, ScrollObserverFirstElementDirective, ScrollObserverIgnoreTargetDirective, ScrollObserverLastElementDirective, SeoDirective, SmartBlockScrollStrategy, StructuredDataComponent, ToArrayPipe, TypedQueryList, VIEWPORT_CONFIG, Validators, ViewportService, clamp, clone, createFlipAnimation, createFlipAnimationGroup, createMediaQueryObservable, createReactiveBindings, deleteCookie, elementCanScroll, equal, forceReflow, fromNextFrame, getCookie, getDomain, getGroupMatchPoints, getGroupMatchScore, getKnockoutMatchScore, getMatchScoreSubLine, hasCookie, isElementVisible, isGroupMatch, isKnockoutMatch, mergeSeoConfig, nextFrame, normalizeGameResultType, normalizeMatchParticipant, normalizeMatchParticipants, normalizeMatchScore, normalizeMatchState, normalizeMatchType, provideViewportConfig, routerDisableScrollTop, scrollToElement, setCookie, toArray, toArrayTrackByFn };
+export { ANIMATABLE_TOKEN, ANIMATED_LIFECYCLE_TOKEN, AnimatableDirective, AnimatedLifecycleDirective, AnimatedOverlayDirective, BehaviorSubjectWithSubscriberCount, ClickObserverFactory, ClickObserverService, ClickOutsideDirective, ContentObserverService, CursorDragScrollDirective, DEFAULT_VIEWPORT_CONFIG, DELAYABLE_TOKEN, DelayableDirective, FocusVisibleService, IS_ACTIVE_ELEMENT, IS_ARRAY_NOT_EMPTY, IS_EMAIL, IsActiveElementDirective, IsArrayNotEmpty, IsEmail, LetContext, LetDirective, MUST_MATCH, Memo, MustMatch, MutationObserverFactory, NormalizeGameResultTypePipe, NormalizeMatchParticipantsPipe, NormalizeMatchScorePipe, NormalizeMatchStatePipe, NormalizeMatchTypePipe, OBSERVE_SCROLL_STATE, ObserveContentDirective, ObserveResizeDirective, ObserveScrollStateDirective, RepeatDirective, ResizeObserverFactory, ResizeObserverService, RouterStateService, SCROLL_OBSERVER_FIRST_ELEMENT_CLASS, SCROLL_OBSERVER_IGNORE_TARGET_CLASS, SCROLL_OBSERVER_LAST_ELEMENT_CLASS, SEO_DIRECTIVE_TOKEN, ScrollObserverFirstElementDirective, ScrollObserverIgnoreTargetDirective, ScrollObserverLastElementDirective, SeoDirective, SmartBlockScrollStrategy, StructuredDataComponent, ToArrayPipe, TypedQueryList, VIEWPORT_CONFIG, Validators, ViewportService, clamp, clone, createDestroy, createFlipAnimation, createFlipAnimationGroup, createMediaQueryObservable, createReactiveBindings, deleteCookie, elementCanScroll, equal, forceReflow, fromNextFrame, getCookie, getDomain, getGroupMatchPoints, getGroupMatchScore, getKnockoutMatchScore, getMatchScoreSubLine, hasCookie, isElementVisible, isGroupMatch, isKnockoutMatch, mergeSeoConfig, nextFrame, normalizeGameResultType, normalizeMatchParticipant, normalizeMatchParticipants, normalizeMatchScore, normalizeMatchState, normalizeMatchType, provideViewportConfig, routerDisableScrollTop, scrollToElement, setCookie, toArray, toArrayTrackByFn };
 //# sourceMappingURL=ethlete-core.mjs.map