@ethlete/core 0.2.0-next.2 → 0.2.0-next.20

package/fesm2020/ethlete-core.mjs

@@ -1,12 +1,48 @@
 import * as i0 from '@angular/core';
-import { InjectionToken, Directive, Input, Injectable, Inject, Optional, inject, EventEmitter, Output, Pipe } from '@angular/core';
-import { coerceNumberProperty, coerceElement, coerceBooleanProperty } from '@angular/cdk/coercion';
-import { BehaviorSubject, combineLatest, map, shareReplay, Observable, Subject, debounceTime } from 'rxjs';
+import { inject, Component, ChangeDetectionStrategy, ViewEncapsulation, Input, HostBinding, InjectionToken, Injectable, Inject, Optional, ElementRef, EventEmitter, Directive, Output, NgZone, Pipe, QueryList } from '@angular/core';
+import { DomSanitizer, Meta, Title } from '@angular/platform-browser';
+import { coerceElement, coerceBooleanProperty, coerceNumberProperty } from '@angular/cdk/coercion';
+import { fromEvent, Observable, Subject, BehaviorSubject, filter, distinctUntilChanged, map, pairwise, combineLatest, shareReplay, takeUntil, startWith, debounceTime, tap, take } from 'rxjs';
+import { DOCUMENT } from '@angular/common';
+import { Router, NavigationEnd } from '@angular/router';
 import { __decorate, __metadata } from 'tslib';
 import * as i1 from '@angular/cdk/layout';
-import { DOCUMENT } from '@angular/common';
 import { debounceTime as debounceTime$1 } from 'rxjs/operators';
 
+class StructuredDataComponent {
+    constructor() {
+        this._sanitizer = inject(DomSanitizer);
+    }
+    set data(currentValue) {
+        this.jsonLD = this.getSafeHTML(currentValue);
+    }
+    getSafeHTML(value) {
+        const json = value ? JSON.stringify(value, null, 2).replace(/<\/script>/g, '<\\/script>') : '';
+        const html = `<script type="application/ld+json">${json}</script>`;
+        return this._sanitizer.bypassSecurityTrustHtml(html);
+    }
+}
+StructuredDataComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.4", ngImport: i0, type: StructuredDataComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+StructuredDataComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.1.4", type: StructuredDataComponent, isStandalone: true, selector: "et-structured-data", inputs: { data: "data" }, host: { properties: { "innerHTML": "this.jsonLD" }, styleAttribute: "display: none" }, ngImport: i0, template: '', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.4", ngImport: i0, type: StructuredDataComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'et-structured-data',
+                    standalone: true,
+                    template: '',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    encapsulation: ViewEncapsulation.None,
+                    host: {
+                        style: 'display: none',
+                    },
+                }]
+        }], propDecorators: { data: [{
+                type: Input
+            }], jsonLD: [{
+                type: HostBinding,
+                args: ['innerHTML']
+            }] } });
+
 const VIEWPORT_CONFIG = new InjectionToken('ViewportConfig');
 /**
  * Default viewport config based on Tailwind CSS.
@@ -48,127 +84,374 @@ const Memo = (config = {}) => (_, __, descriptor) => {
     return descriptor;
 };
 
-class LetContext {
-    constructor() {
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        this.$implicit = null;
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        this.etLet = null;
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+class ClickObserverFactory {
+    create() {
+        return fromEvent(document, 'click');
     }
 }
-
-class LetDirective {
-    constructor(_viewContainer, templateRef) {
-        this._viewContainer = _viewContainer;
-        this._context = new LetContext();
-        this._templateRef = null;
-        this._viewRef = null;
-        this._templateRef = templateRef;
+ClickObserverFactory.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.4", ngImport: i0, type: ClickObserverFactory, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+ClickObserverFactory.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.4", ngImport: i0, type: ClickObserverFactory, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.4", ngImport: i0, type: ClickObserverFactory, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+class ClickObserverService {
+    constructor(_clickObserverFactory) {
+        this._clickObserverFactory = _clickObserverFactory;
+        this._observedElements = new Map();
     }
-    set etLet(value) {
-        this._context.$implicit = this._context.etLet = value;
-        this._updateView();
+    ngOnDestroy() {
+        this._observedElements.forEach((_, element) => this._cleanupObserver(element));
     }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    static ngTemplateContextGuard(dir, ctx) {
-        return true;
+    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);
+            };
+        });
     }
-    _updateView() {
-        if (!this._viewRef) {
-            this._viewContainer.clear();
-            if (this._templateRef) {
-                this._viewRef = this._viewContainer.createEmbeddedView(this._templateRef, this._context);
+    _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;
+    }
+    _unobserveElement(element) {
+        if (this._observedElements.has(element)) {
+            this._observedElements.get(element).count--;
+            if (!this._observedElements.get(element).count) {
+                this._cleanupObserver(element);
+            }
+        }
+    }
+    _cleanupObserver(element) {
+        if (this._observedElements.has(element)) {
+            const { observer, stream } = this._observedElements.get(element);
+            if (observer) {
+                observer.unsubscribe();
             }
+            stream.complete();
+            this._observedElements.delete(element);
         }
     }
 }
-LetDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: LetDirective, deps: [{ token: i0.ViewContainerRef }, { token: i0.TemplateRef }], target: i0.ɵɵFactoryTarget.Directive });
-LetDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.2.7", type: LetDirective, isStandalone: true, selector: "[etLet]", inputs: { etLet: "etLet" }, ngImport: i0 });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: LetDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    selector: '[etLet]',
-                    standalone: true,
-                }]
-        }], ctorParameters: function () { return [{ type: i0.ViewContainerRef }, { type: i0.TemplateRef }]; }, propDecorators: { etLet: [{
-                type: Input
-            }] } });
+ClickObserverService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.4", ngImport: i0, type: ClickObserverService, deps: [{ token: ClickObserverFactory }], target: i0.ɵɵFactoryTarget.Injectable });
+ClickObserverService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.4", ngImport: i0, type: ClickObserverService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.4", ngImport: i0, type: ClickObserverService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: ClickObserverFactory }]; } });
 
-class RepeatDirective {
-    constructor(_mainTemplateRef, _viewContainerRef) {
-        this._mainTemplateRef = _mainTemplateRef;
-        this._viewContainerRef = _viewContainerRef;
-        this._repeatCount = 2;
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+class MutationObserverFactory {
+    create(callback) {
+        return typeof MutationObserver === 'undefined' ? null : new MutationObserver(callback);
     }
-    get repeatCount() {
-        return this._repeatCount;
+}
+MutationObserverFactory.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.4", ngImport: i0, type: MutationObserverFactory, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+MutationObserverFactory.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.4", ngImport: i0, type: MutationObserverFactory, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.4", ngImport: i0, type: MutationObserverFactory, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+class ContentObserverService {
+    constructor(_mutationObserverFactory) {
+        this._mutationObserverFactory = _mutationObserverFactory;
+        this._observedElements = new Map();
     }
-    set repeatCount(value) {
-        this._repeatCount = coerceNumberProperty(value);
+    ngOnDestroy() {
+        this._observedElements.forEach((_, element) => this._cleanupObserver(element));
     }
-    ngOnInit() {
-        this._render();
+    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);
+            };
+        });
     }
-    _render() {
-        for (let i = 0; i < this.repeatCount; i++) {
-            this._viewContainerRef.createEmbeddedView(this._mainTemplateRef);
+    _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);
+            }
+        }
+    }
+    _cleanupObserver(element) {
+        if (this._observedElements.has(element)) {
+            const { observer, stream } = this._observedElements.get(element);
+            if (observer) {
+                observer.disconnect();
+            }
+            stream.complete();
+            this._observedElements.delete(element);
         }
     }
 }
-RepeatDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: RepeatDirective, deps: [{ token: i0.TemplateRef }, { token: i0.ViewContainerRef }], target: i0.ɵɵFactoryTarget.Directive });
-RepeatDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.2.7", type: RepeatDirective, isStandalone: true, selector: "[etRepeat]", inputs: { repeatCount: ["etRepeat", "repeatCount"] }, ngImport: i0 });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: RepeatDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    selector: '[etRepeat]',
-                    standalone: true,
-                }]
-        }], ctorParameters: function () { return [{ type: i0.TemplateRef }, { type: i0.ViewContainerRef }]; }, propDecorators: { repeatCount: [{
-                type: Input,
-                args: ['etRepeat']
-            }] } });
+ContentObserverService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.4", ngImport: i0, type: ContentObserverService, deps: [{ token: MutationObserverFactory }], target: i0.ɵɵFactoryTarget.Injectable });
+ContentObserverService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.4", ngImport: i0, type: ContentObserverService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.4", ngImport: i0, type: ContentObserverService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: MutationObserverFactory }]; } });
 
-class ViewportService {
-    constructor(_viewportConfig, _breakpointObserver) {
-        this._breakpointObserver = _breakpointObserver;
-        this._isXs$ = new BehaviorSubject(false);
-        this._isSm$ = new BehaviorSubject(false);
-        this._isMd$ = new BehaviorSubject(false);
-        this._isLg$ = new BehaviorSubject(false);
-        this._isXl$ = new BehaviorSubject(false);
-        this._is2Xl$ = new BehaviorSubject(false);
-        this.currentViewport$ = combineLatest([this.isXs$, this.isSm$, this.isMd$, this.isLg$, this.isXl$, this.is2Xl$]).pipe(map((val) => this.getCurrentViewport(val)), shareReplay());
-        this._viewportConfig = _viewportConfig || DEFAULT_VIEWPORT_CONFIG;
-        this._observeDefaultBreakpoints();
+class DestroyService {
+    constructor() {
+        this._destroy$ = new Subject();
+        this.destroy$ = this._destroy$.asObservable();
     }
-    get isXs$() {
-        return this._isXs$.asObservable();
+    ngOnDestroy() {
+        this._destroy$.next(true);
+        this._destroy$.unsubscribe();
     }
-    get isXs() {
-        return this._isXs$.value;
+}
+DestroyService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.4", ngImport: i0, type: DestroyService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+DestroyService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.4", ngImport: i0, type: DestroyService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.4", ngImport: i0, type: DestroyService, decorators: [{
+            type: Injectable
+        }] });
+
+class FocusVisibleService {
+    get isFocusVisible() {
+        return this._hadKeyboardEvent;
     }
-    get isSm$() {
-        return this._isSm$.asObservable();
+    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);
     }
-    get isSm() {
-        return this._isSm$.value;
+    onKeyDown(e) {
+        if (e.metaKey || e.altKey || e.ctrlKey) {
+            return;
+        }
+        this._hadKeyboardEvent = true;
     }
-    get isMd$() {
-        return this._isMd$.asObservable();
+    onPointerDown() {
+        this._hadKeyboardEvent = false;
     }
-    get isMd() {
-        return this._isMd$.value;
+}
+FocusVisibleService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.4", ngImport: i0, type: FocusVisibleService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+FocusVisibleService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.4", ngImport: i0, type: FocusVisibleService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.4", ngImport: i0, type: FocusVisibleService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return []; } });
+
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+class ResizeObserverFactory {
+    create(callback) {
+        return typeof ResizeObserver === 'undefined' ? null : new ResizeObserver(callback);
     }
-    get isLg$() {
-        return this._isLg$.asObservable();
+}
+ResizeObserverFactory.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.4", ngImport: i0, type: ResizeObserverFactory, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+ResizeObserverFactory.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.4", ngImport: i0, type: ResizeObserverFactory, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.4", ngImport: i0, type: ResizeObserverFactory, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+class ResizeObserverService {
+    constructor(_mutationObserverFactory) {
+        this._mutationObserverFactory = _mutationObserverFactory;
+        this._observedElements = new Map();
     }
-    get isLg() {
-        return this._isLg$.value;
+    ngOnDestroy() {
+        this._observedElements.forEach((_, element) => this._cleanupObserver(element));
     }
-    get isXl$() {
-        return this._isXl$.asObservable();
+    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);
+            };
+        });
     }
-    get isXl() {
+    _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 });
+        }
+        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);
+            }
+        }
+    }
+    _cleanupObserver(element) {
+        if (this._observedElements.has(element)) {
+            const { observer, stream } = this._observedElements.get(element);
+            if (observer) {
+                observer.disconnect();
+            }
+            stream.complete();
+            this._observedElements.delete(element);
+        }
+    }
+}
+ResizeObserverService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.4", ngImport: i0, type: ResizeObserverService, deps: [{ token: ResizeObserverFactory }], target: i0.ɵɵFactoryTarget.Injectable });
+ResizeObserverService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.4", ngImport: i0, type: ResizeObserverService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.4", ngImport: i0, type: ResizeObserverService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: ResizeObserverFactory }]; } });
+
+const routerDisableScrollTop = (config = {}) => {
+    if (!config.asReturnRoute) {
+        return {
+            disableScrollTop: true,
+        };
+    }
+    return {
+        disableScrollTopAsReturnRoute: true,
+    };
+};
+class RouterStateService {
+    get route$() {
+        return this._route$.asObservable();
+    }
+    get state$() {
+        return this._state$.asObservable();
+    }
+    constructor() {
+        this._isScrollTopOnNavigationEnabled = false;
+        this._router = inject(Router);
+        this._route$ = new BehaviorSubject('/');
+        this._state$ = new BehaviorSubject({
+            title: undefined,
+            data: {},
+            pathParams: {},
+            queryParams: {},
+        });
+        this._router.events
+            .pipe(filter((event) => event instanceof NavigationEnd), distinctUntilChanged((a, b) => a.url === b.url), map((event) => event.url))
+            .subscribe(this._route$);
+        this._route$
+            .pipe(map(() => {
+            let route = this._router.routerState.snapshot.root;
+            while (route.firstChild) {
+                route = route.firstChild;
+            }
+            const { data, params, queryParams, title } = route;
+            return {
+                data,
+                pathParams: params,
+                queryParams,
+                title,
+            };
+        }))
+            .subscribe(this._state$);
+    }
+    enableScrollTopOnNavigation(config = {}) {
+        if (this._isScrollTopOnNavigationEnabled) {
+            return;
+        }
+        this._isScrollTopOnNavigationEnabled = true;
+        this._state$.pipe(pairwise()).subscribe(([oldData, newData]) => {
+            if (!(newData.data['disableScrollTopAsReturnRoute'] && oldData.data['disableScrollTop']) &&
+                !newData.data['disableScrollTop']) {
+                (config.scrollElement ?? document.documentElement).scrollTop = 0;
+            }
+        });
+    }
+    selectQueryParam(key) {
+        return this._state$.pipe(map((state) => state.queryParams[key]));
+    }
+    selectPathParam(key) {
+        return this._state$.pipe(map((state) => state.pathParams[key]));
+    }
+    selectData(key) {
+        return this._state$.pipe(map((state) => state.data[key]));
+    }
+}
+RouterStateService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.4", ngImport: i0, type: RouterStateService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+RouterStateService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.4", ngImport: i0, type: RouterStateService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.4", ngImport: i0, type: RouterStateService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return []; } });
+
+class ViewportService {
+    get isXs$() {
+        return this._isXs$.asObservable();
+    }
+    get isXs() {
+        return this._isXs$.value;
+    }
+    get isSm$() {
+        return this._isSm$.asObservable();
+    }
+    get isSm() {
+        return this._isSm$.value;
+    }
+    get isMd$() {
+        return this._isMd$.asObservable();
+    }
+    get isMd() {
+        return this._isMd$.value;
+    }
+    get isLg$() {
+        return this._isLg$.asObservable();
+    }
+    get isLg() {
+        return this._isLg$.value;
+    }
+    get isXl$() {
+        return this._isXl$.asObservable();
+    }
+    get isXl() {
         return this._isXl$.value;
     }
     get is2Xl$() {
@@ -180,6 +463,18 @@ class ViewportService {
     get currentViewport() {
         return this.getCurrentViewport([this.isXs, this.isSm, this.isMd, this.isLg, this.isXl, this.is2Xl]);
     }
+    constructor(_viewportConfig, _breakpointObserver) {
+        this._breakpointObserver = _breakpointObserver;
+        this._isXs$ = new BehaviorSubject(false);
+        this._isSm$ = new BehaviorSubject(false);
+        this._isMd$ = new BehaviorSubject(false);
+        this._isLg$ = new BehaviorSubject(false);
+        this._isXl$ = new BehaviorSubject(false);
+        this._is2Xl$ = new BehaviorSubject(false);
+        this.currentViewport$ = combineLatest([this.isXs$, this.isSm$, this.isMd$, this.isLg$, this.isXl$, this.is2Xl$]).pipe(map((val) => this.getCurrentViewport(val)), shareReplay());
+        this._viewportConfig = _viewportConfig || DEFAULT_VIEWPORT_CONFIG;
+        this._observeDefaultBreakpoints();
+    }
     observe(options) {
         const mediaQuery = this._buildMediaQuery(options);
         return this._breakpointObserver.observe(mediaQuery).pipe(map((x) => x.matches), shareReplay());
@@ -258,8 +553,8 @@ class ViewportService {
         return 'xs';
     }
 }
-ViewportService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: ViewportService, deps: [{ token: VIEWPORT_CONFIG, optional: true }, { token: i1.BreakpointObserver }], target: i0.ɵɵFactoryTarget.Injectable });
-ViewportService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: ViewportService, providedIn: 'root' });
+ViewportService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.4", ngImport: i0, type: ViewportService, deps: [{ token: VIEWPORT_CONFIG, optional: true }, { token: i1.BreakpointObserver }], target: i0.ɵɵFactoryTarget.Injectable });
+ViewportService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.4", ngImport: i0, type: ViewportService, providedIn: 'root' });
 __decorate([
     Memo(),
     __metadata("design:type", Function),
@@ -276,7 +571,7 @@ __decorate([
     __metadata("design:paramtypes", [Object]),
     __metadata("design:returntype", void 0)
 ], ViewportService.prototype, "_buildMediaQuery", null);
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: ViewportService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.4", ngImport: i0, type: ViewportService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
@@ -288,188 +583,599 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.7", ngImpor
                     type: Optional
                 }] }, { type: i1.BreakpointObserver }]; }, propDecorators: { _getViewportSize: [], _buildMediaQuery: [] } });
 
-class FocusVisibleService {
+class ClickOutsideDirective {
     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);
-    }
-    get isFocusVisible() {
-        return this._hadKeyboardEvent;
+        this._elementRef = inject(ElementRef);
+        this._clickObserverService = inject(ClickObserverService);
+        this._subscription = null;
+        this.etClickOutside = new EventEmitter();
     }
-    onKeyDown(e) {
-        if (e.metaKey || e.altKey || e.ctrlKey) {
-            return;
-        }
-        this._hadKeyboardEvent = true;
+    ngOnInit() {
+        setTimeout(() => {
+            this._subscription = this._clickObserverService.observe(this._elementRef.nativeElement).subscribe((event) => {
+                const activeElement = event.target;
+                const isInside = this._elementRef.nativeElement.contains(activeElement);
+                if (!isInside) {
+                    this.etClickOutside.emit(event);
+                }
+            });
+        });
     }
-    onPointerDown() {
-        this._hadKeyboardEvent = false;
+    ngOnDestroy() {
+        this._subscription?.unsubscribe();
     }
 }
-FocusVisibleService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: FocusVisibleService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-FocusVisibleService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: FocusVisibleService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: FocusVisibleService, decorators: [{
-            type: Injectable,
+ClickOutsideDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.4", ngImport: i0, type: ClickOutsideDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+ClickOutsideDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.1.4", type: ClickOutsideDirective, isStandalone: true, selector: "[etClickOutside]", outputs: { etClickOutside: "etClickOutside" }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.4", ngImport: i0, type: ClickOutsideDirective, decorators: [{
+            type: Directive,
             args: [{
-                    providedIn: 'root',
+                    selector: '[etClickOutside]',
+                    standalone: true,
                 }]
-        }], ctorParameters: function () { return []; } });
+        }], propDecorators: { etClickOutside: [{
+                type: Output
+            }] } });
 
-/* eslint-disable @typescript-eslint/no-non-null-assertion */
-class ResizeObserverFactory {
-    create(callback) {
-        return typeof ResizeObserver === 'undefined' ? null : new ResizeObserver(callback);
+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);
+    }
+    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);
+    }
+    else if (str === '[object Array]') {
+        tmp = Array(_og.length);
+    }
+    else if (str === '[object Set]') {
+        tmp = new Set();
+        _og.forEach(function (val) {
+            tmp.add(clone(val));
+        });
     }
-}
-ResizeObserverFactory.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: ResizeObserverFactory, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-ResizeObserverFactory.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: ResizeObserverFactory, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: ResizeObserverFactory, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }] });
-class ResizeObserverService {
-    constructor(_mutationObserverFactory) {
-        this._mutationObserverFactory = _mutationObserverFactory;
-        this._observedElements = new Map();
+    else if (str === '[object Map]') {
+        tmp = new Map();
+        _og.forEach(function (val, key) {
+            tmp.set(clone(key), clone(val));
+        });
     }
-    ngOnDestroy() {
-        this._observedElements.forEach((_, element) => this._cleanupObserver(element));
+    else if (str === '[object Date]') {
+        tmp = new Date(+_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);
-            };
-        });
+    else if (str === '[object RegExp]') {
+        tmp = new RegExp(_og.source, _og.flags);
     }
-    _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 });
-        }
-        else {
-            this._observedElements.get(element).count++;
-        }
-        return this._observedElements.get(element).stream;
+    else if (str === '[object DataView]') {
+        tmp = new _og.constructor(clone(_og.buffer));
     }
-    _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 ArrayBuffer]') {
+        tmp = _og.slice(0);
     }
-    _cleanupObserver(element) {
-        if (this._observedElements.has(element)) {
-            const { observer, stream } = this._observedElements.get(element);
-            if (observer) {
-                observer.disconnect();
-            }
-            stream.complete();
-            this._observedElements.delete(element);
+    else if (str.slice(-6) === 'Array]') {
+        // ArrayBuffer.isView(x)
+        // ~> `new` bcuz `Buffer.slice` => ref
+        tmp = new _og.constructor(_og);
+    }
+    if (tmp) {
+        for (list = Object.getOwnPropertySymbols(_og); i < list.length; i++) {
+            set(tmp, list[i], Object.getOwnPropertyDescriptor(_og, list[i]));
+        }
+        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));
         }
     }
-}
-ResizeObserverService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: ResizeObserverService, deps: [{ token: ResizeObserverFactory }], target: i0.ɵɵFactoryTarget.Injectable });
-ResizeObserverService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: ResizeObserverService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: ResizeObserverService, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }], ctorParameters: function () { return [{ type: ResizeObserverFactory }]; } });
+    return tmp || _og;
+};
 
-/* eslint-disable @typescript-eslint/no-non-null-assertion */
-class MutationObserverFactory {
-    create(callback) {
-        return typeof MutationObserver === 'undefined' ? null : new MutationObserver(callback);
+const hasCookie = (name) => {
+    if (typeof document === 'undefined') {
+        return false;
     }
-}
-MutationObserverFactory.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: MutationObserverFactory, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-MutationObserverFactory.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: MutationObserverFactory, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: MutationObserverFactory, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }] });
-class ContentObserverService {
-    constructor(_mutationObserverFactory) {
-        this._mutationObserverFactory = _mutationObserverFactory;
-        this._observedElements = new Map();
+    return document.cookie.split(';').some((c) => {
+        return c.trim().startsWith(name + '=');
+    });
+};
+const getCookie = (name) => {
+    if (typeof document === 'undefined') {
+        return null;
     }
-    ngOnDestroy() {
-        this._observedElements.forEach((_, element) => this._cleanupObserver(element));
+    // 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;
     }
-    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 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';
     }
-    _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,
-                });
+};
+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]))
+                    ;
             }
-            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;
+            }
+            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;
             }
+            return true;
+        }
+        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;
         }
     }
-    _cleanupObserver(element) {
-        if (this._observedElements.has(element)) {
-            const { observer, stream } = this._observedElements.get(element);
-            if (observer) {
-                observer.disconnect();
+    return foo !== foo && bar !== bar;
+};
+
+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;
             }
-            stream.complete();
-            this._observedElements.delete(element);
+        }
+        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 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 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 {
+        push,
+        remove,
+        reset,
+    };
+};
+
+const elementCanScroll = (element) => {
+    const { scrollHeight, clientHeight, scrollWidth, clientWidth } = element;
+    return scrollHeight > clientHeight || scrollWidth > clientWidth;
+};
+
+const provideViewportConfig = (viewportConfig) => {
+    return { provide: VIEWPORT_CONFIG, useValue: viewportConfig };
+};
+
+const CURSOR_DRAG_SCROLLING_CLASS = 'et-cursor-drag-scroll--scrolling';
+const CURSOR_DRAG_SCROLLING_PREPARED_CLASS = 'et-cursor-drag-scroll--prepared';
+
+class CursorDragScrollDirective {
+    constructor() {
+        this._subscriptions = [];
+        this._destroy$ = inject(DestroyService, { host: true }).destroy$;
+        this._elementRef = inject(ElementRef);
+        this._contentObserverService = inject(ContentObserverService);
+        this._resizeObserverService = inject(ResizeObserverService);
+        this._bufferUntilScroll = 5;
+        this._mouseUp$ = new Subject();
+        this._isScrolling = false;
+        this._canScroll = false;
+        this._currentScrollState = {
+            top: 0,
+            left: 0,
+            x: 0,
+            y: 0,
+        };
+        this._enabled = false;
+    }
+    get enabled() {
+        return this._enabled;
+    }
+    set enabled(value) {
+        this._enabled = coerceBooleanProperty(value);
+        if (this._enabled) {
+            this._enableCursorDragScroll();
+        }
+        else {
+            this._disableCursorDragScroll();
+        }
+    }
+    ngAfterViewInit() {
+        if (this.enabled) {
+            this._enableCursorDragScroll();
+        }
+        else {
+            this._disableCursorDragScroll();
+        }
+    }
+    _enableCursorDragScroll() {
+        const contentResizeSub = combineLatest([
+            this._contentObserverService.observe(this._elementRef.nativeElement).pipe(startWith(null)),
+            this._resizeObserverService.observe(this._elementRef.nativeElement).pipe(startWith(null)),
+        ])
+            .pipe(debounceTime(25), tap(() => this._updateCanScrollState()), takeUntil(this._destroy$))
+            .subscribe();
+        const mousedownSub = fromEvent(this._elementRef.nativeElement, 'mousedown')
+            .pipe(tap((e) => this._onMouseDown(e)), takeUntil(this._destroy$))
+            .subscribe();
+        this._subscriptions.push(contentResizeSub, mousedownSub);
+        this._updateCanScrollState();
+    }
+    _disableCursorDragScroll() {
+        this._subscriptions.forEach((sub) => sub.unsubscribe());
+        this._subscriptions.length = 0;
+        this._elementRef.nativeElement.style.cursor = 'default';
+    }
+    _onMouseDown(e) {
+        if (!this._elementRef?.nativeElement || !this._canScroll) {
+            return;
+        }
+        const element = this._elementRef.nativeElement;
+        element.classList.add(CURSOR_DRAG_SCROLLING_PREPARED_CLASS);
+        this._elementRef.nativeElement.style.scrollSnapType = 'none';
+        this._elementRef.nativeElement.style.scrollBehavior = 'unset';
+        this._currentScrollState = {
+            left: this._elementRef.nativeElement.scrollLeft,
+            top: this._elementRef.nativeElement.scrollTop,
+            x: e.clientX,
+            y: e.clientY,
+        };
+        fromEvent(document, 'mousemove')
+            .pipe(tap((e) => this._mouseMoveHandler(e)), takeUntil(this._mouseUp$), takeUntil(this._destroy$))
+            .subscribe();
+        fromEvent(document, 'mouseup')
+            .pipe(tap(() => this._mouseUpHandler()), take(1), takeUntil(this._destroy$))
+            .subscribe();
+    }
+    _mouseMoveHandler(e) {
+        e.preventDefault();
+        if (!this._elementRef?.nativeElement) {
+            return;
+        }
+        const dx = e.clientX - this._currentScrollState.x;
+        const dy = e.clientY - this._currentScrollState.y;
+        if (Math.abs(dx) > this._bufferUntilScroll || Math.abs(dy) > this._bufferUntilScroll) {
+            const element = this._elementRef.nativeElement;
+            if (!this._isScrolling) {
+                this._isScrolling = true;
+                element.style.cursor = 'grabbing';
+                element.classList.add(CURSOR_DRAG_SCROLLING_CLASS);
+                element.scroll({
+                    top: this._currentScrollState.top - dy,
+                    left: this._currentScrollState.left - dx,
+                    behavior: 'smooth',
+                });
+            }
+            else {
+                element.scrollTop = this._currentScrollState.top - dy;
+                element.scrollLeft = this._currentScrollState.left - dx;
+            }
+        }
+    }
+    _mouseUpHandler() {
+        this._mouseUp$.next(true);
+        this._isScrolling = false;
+        if (!this._elementRef?.nativeElement) {
+            return;
+        }
+        this._elementRef.nativeElement.style.scrollSnapType = '';
+        this._elementRef.nativeElement.style.scrollBehavior = '';
+        this._elementRef.nativeElement.style.cursor = 'grab';
+        this._elementRef.nativeElement.classList.remove(CURSOR_DRAG_SCROLLING_CLASS);
+        this._elementRef.nativeElement.classList.remove(CURSOR_DRAG_SCROLLING_PREPARED_CLASS);
+    }
+    _updateCanScrollState() {
+        this._canScroll = elementCanScroll(this._elementRef.nativeElement);
+        if (this._canScroll) {
+            this._elementRef.nativeElement.style.cursor = 'grab';
+        }
+        else {
+            this._elementRef.nativeElement.style.cursor = 'default';
         }
     }
 }
-ContentObserverService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: ContentObserverService, deps: [{ token: MutationObserverFactory }], target: i0.ɵɵFactoryTarget.Injectable });
-ContentObserverService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: ContentObserverService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: ContentObserverService, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }], ctorParameters: function () { return [{ type: MutationObserverFactory }]; } });
+CursorDragScrollDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.4", ngImport: i0, type: CursorDragScrollDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+CursorDragScrollDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.1.4", type: CursorDragScrollDirective, isStandalone: true, selector: "[etCursorDragScroll]", inputs: { enabled: ["etCursorDragScroll", "enabled"] }, providers: [DestroyService], exportAs: ["etCursorDragScroll"], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.4", ngImport: i0, type: CursorDragScrollDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[etCursorDragScroll]',
+                    exportAs: 'etCursorDragScroll',
+                    standalone: true,
+                    providers: [DestroyService],
+                }]
+        }], propDecorators: { enabled: [{
+                type: Input,
+                args: ['etCursorDragScroll']
+            }] } });
 
-class ObserveResizeDirective {
-    constructor(_contentObserver, _elementRef, _ngZone) {
-        this._contentObserver = _contentObserver;
-        this._elementRef = _elementRef;
-        this._ngZone = _ngZone;
+class LetContext {
+    constructor() {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        this.$implicit = null;
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        this.etLet = null;
+    }
+}
+
+class LetDirective {
+    set etLet(value) {
+        this._context.$implicit = this._context.etLet = value;
+        this._updateView();
+    }
+    constructor(_viewContainer, templateRef) {
+        this._viewContainer = _viewContainer;
+        this._context = new LetContext();
+        this._templateRef = null;
+        this._viewRef = null;
+        this._templateRef = templateRef;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static ngTemplateContextGuard(dir, ctx) {
+        return true;
+    }
+    _updateView() {
+        if (!this._viewRef) {
+            this._viewContainer.clear();
+            if (this._templateRef) {
+                this._viewRef = this._viewContainer.createEmbeddedView(this._templateRef, this._context);
+            }
+        }
+    }
+}
+LetDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.4", ngImport: i0, type: LetDirective, deps: [{ token: i0.ViewContainerRef }, { token: i0.TemplateRef }], target: i0.ɵɵFactoryTarget.Directive });
+LetDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.1.4", type: LetDirective, isStandalone: true, selector: "[etLet]", inputs: { etLet: "etLet" }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.4", ngImport: i0, type: LetDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[etLet]',
+                    standalone: true,
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ViewContainerRef }, { type: i0.TemplateRef }]; }, propDecorators: { etLet: [{
+                type: Input
+            }] } });
+
+class ObserveContentDirective {
+    constructor() {
+        this._contentObserver = inject(ContentObserverService);
+        this._elementRef = inject(ElementRef);
+        this._ngZone = inject(NgZone);
         this.event = new EventEmitter();
         this._disabled = false;
         this._debounce = null;
@@ -501,38 +1207,38 @@ class ObserveResizeDirective {
         this._unsubscribe();
         const stream = this._contentObserver.observe(this._elementRef);
         this._ngZone.runOutsideAngular(() => {
-            this._currentSubscription = (this.debounce ? stream.pipe(debounceTime(this.debounce)) : stream).subscribe(this.event);
+            this._currentSubscription = (this.debounce ? stream.pipe(debounceTime$1(this.debounce)) : stream).subscribe(this.event);
         });
     }
     _unsubscribe() {
         this._currentSubscription?.unsubscribe();
     }
 }
-ObserveResizeDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: ObserveResizeDirective, deps: [{ token: ResizeObserverService }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Directive });
-ObserveResizeDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.2.7", type: ObserveResizeDirective, isStandalone: true, selector: "[etObserveResize]", inputs: { disabled: ["etObserveResizeDisabled", "disabled"], debounce: ["etObserveResizeDebounce", "debounce"] }, outputs: { event: "etObserveResize" }, exportAs: ["etObserveResize"], ngImport: i0 });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: ObserveResizeDirective, decorators: [{
+ObserveContentDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.4", ngImport: i0, type: ObserveContentDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+ObserveContentDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.1.4", type: ObserveContentDirective, isStandalone: true, selector: "[etObserveContent]", inputs: { disabled: ["etObserveContentDisabled", "disabled"], debounce: ["etObserveContentDebounce", "debounce"] }, outputs: { event: "etObserveContent" }, exportAs: ["etObserveContent"], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.4", ngImport: i0, type: ObserveContentDirective, decorators: [{
             type: Directive,
             args: [{
-                    selector: '[etObserveResize]',
-                    exportAs: 'etObserveResize',
+                    selector: '[etObserveContent]',
+                    exportAs: 'etObserveContent',
                     standalone: true,
                 }]
-        }], ctorParameters: function () { return [{ type: ResizeObserverService }, { type: i0.ElementRef }, { type: i0.NgZone }]; }, propDecorators: { event: [{
+        }], propDecorators: { event: [{
                 type: Output,
-                args: ['etObserveResize']
+                args: ['etObserveContent']
             }], disabled: [{
                 type: Input,
-                args: ['etObserveResizeDisabled']
+                args: ['etObserveContentDisabled']
             }], debounce: [{
                 type: Input,
-                args: ['etObserveResizeDebounce']
+                args: ['etObserveContentDebounce']
             }] } });
 
-class ObserveContentDirective {
-    constructor(_contentObserver, _elementRef, _ngZone) {
-        this._contentObserver = _contentObserver;
-        this._elementRef = _elementRef;
-        this._ngZone = _ngZone;
+class ObserveResizeDirective {
+    constructor() {
+        this._resizeObserver = inject(ResizeObserverService);
+        this._elementRef = inject(ElementRef);
+        this._ngZone = inject(NgZone);
         this.event = new EventEmitter();
         this._disabled = false;
         this._debounce = null;
@@ -562,34 +1268,797 @@ class ObserveContentDirective {
     }
     _subscribe() {
         this._unsubscribe();
-        const stream = this._contentObserver.observe(this._elementRef);
+        const stream = this._resizeObserver.observe(this._elementRef);
         this._ngZone.runOutsideAngular(() => {
-            this._currentSubscription = (this.debounce ? stream.pipe(debounceTime$1(this.debounce)) : stream).subscribe(this.event);
+            this._currentSubscription = (this.debounce ? stream.pipe(debounceTime(this.debounce)) : stream).subscribe(this.event);
         });
     }
     _unsubscribe() {
         this._currentSubscription?.unsubscribe();
     }
 }
-ObserveContentDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: ObserveContentDirective, deps: [{ token: ContentObserverService }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Directive });
-ObserveContentDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.2.7", type: ObserveContentDirective, selector: "[etObserveContent]", inputs: { disabled: ["etObserveContentDisabled", "disabled"], debounce: ["etObserveContentDebounce", "debounce"] }, outputs: { event: "etObserveContent" }, exportAs: ["etObserveContent"], ngImport: i0 });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: ObserveContentDirective, decorators: [{
+ObserveResizeDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.4", ngImport: i0, type: ObserveResizeDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+ObserveResizeDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.1.4", type: ObserveResizeDirective, isStandalone: true, selector: "[etObserveResize]", inputs: { disabled: ["etObserveResizeDisabled", "disabled"], debounce: ["etObserveResizeDebounce", "debounce"] }, outputs: { event: "etObserveResize" }, exportAs: ["etObserveResize"], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.4", ngImport: i0, type: ObserveResizeDirective, decorators: [{
             type: Directive,
             args: [{
-                    selector: '[etObserveContent]',
-                    exportAs: 'etObserveContent',
+                    selector: '[etObserveResize]',
+                    exportAs: 'etObserveResize',
+                    standalone: true,
                 }]
-        }], ctorParameters: function () { return [{ type: ContentObserverService }, { type: i0.ElementRef }, { type: i0.NgZone }]; }, propDecorators: { event: [{
+        }], propDecorators: { event: [{
                 type: Output,
-                args: ['etObserveContent']
+                args: ['etObserveResize']
             }], disabled: [{
                 type: Input,
-                args: ['etObserveContentDisabled']
+                args: ['etObserveResizeDisabled']
             }], debounce: [{
                 type: Input,
-                args: ['etObserveContentDebounce']
+                args: ['etObserveResizeDebounce']
+            }] } });
+
+const SCROLL_OBSERVER_FIRST_ELEMENT_CLASS = 'et-scroll-observer-first-element';
+class ScrollObserverFirstElementDirective {
+    constructor() {
+        this._isFirstElement = false;
+    }
+    get isFirstElement() {
+        return this._isFirstElement;
+    }
+    set isFirstElement(value) {
+        this._isFirstElement = coerceBooleanProperty(value);
+    }
+}
+ScrollObserverFirstElementDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.4", ngImport: i0, type: ScrollObserverFirstElementDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+ScrollObserverFirstElementDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.1.4", type: ScrollObserverFirstElementDirective, isStandalone: true, selector: "[etScrollObserverFirstElement]", inputs: { isFirstElement: ["etScrollObserverFirstElement", "isFirstElement"] }, host: { properties: { "class.et-scroll-observer-first-element": "this.isFirstElement" } }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.4", ngImport: i0, type: ScrollObserverFirstElementDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[etScrollObserverFirstElement]',
+                    standalone: true,
+                }]
+        }], propDecorators: { isFirstElement: [{
+                type: Input,
+                args: ['etScrollObserverFirstElement']
+            }, {
+                type: HostBinding,
+                args: [`class.${SCROLL_OBSERVER_FIRST_ELEMENT_CLASS}`]
+            }] } });
+
+const SCROLL_OBSERVER_IGNORE_TARGET_CLASS = 'et-scroll-observer-ignore-target';
+class ScrollObserverIgnoreTargetDirective {
+}
+ScrollObserverIgnoreTargetDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.4", ngImport: i0, type: ScrollObserverIgnoreTargetDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+ScrollObserverIgnoreTargetDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.1.4", type: ScrollObserverIgnoreTargetDirective, isStandalone: true, selector: "[etScrollObserverIgnoreTarget]", host: { classAttribute: "et-scroll-observer-ignore-target" }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.4", ngImport: i0, type: ScrollObserverIgnoreTargetDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[etScrollObserverIgnoreTarget]',
+                    standalone: true,
+                    host: {
+                        class: SCROLL_OBSERVER_IGNORE_TARGET_CLASS,
+                    },
+                }]
+        }] });
+
+const SCROLL_OBSERVER_LAST_ELEMENT_CLASS = 'et-scroll-observer-last-element';
+class ScrollObserverLastElementDirective {
+    constructor() {
+        this._isLastElement = false;
+    }
+    get isLastElement() {
+        return this._isLastElement;
+    }
+    set isLastElement(value) {
+        this._isLastElement = coerceBooleanProperty(value);
+    }
+}
+ScrollObserverLastElementDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.4", ngImport: i0, type: ScrollObserverLastElementDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+ScrollObserverLastElementDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.1.4", type: ScrollObserverLastElementDirective, isStandalone: true, selector: "[etScrollObserverLastElement]", inputs: { isLastElement: ["etScrollObserverLastElement", "isLastElement"] }, host: { properties: { "class.et-scroll-observer-last-element": "this.isLastElement" }, classAttribute: "et-scroll-observer-last-element" }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.4", ngImport: i0, type: ScrollObserverLastElementDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[etScrollObserverLastElement]',
+                    standalone: true,
+                    host: {
+                        class: SCROLL_OBSERVER_LAST_ELEMENT_CLASS,
+                    },
+                }]
+        }], propDecorators: { isLastElement: [{
+                type: Input,
+                args: ['etScrollObserverLastElement']
+            }, {
+                type: HostBinding,
+                args: [`class.${SCROLL_OBSERVER_LAST_ELEMENT_CLASS}`]
+            }] } });
+
+const OBSERVE_SCROLL_STATE = new InjectionToken('OBSERVE_SCROLL_STATE');
+
+class ObserveScrollStateDirective {
+    constructor() {
+        this._destroy$ = inject(DestroyService, { host: true }).destroy$;
+        this._elementRef = inject(ElementRef);
+        this._contentObserverService = inject(ContentObserverService);
+        this._resizeObserverService = inject(ResizeObserverService);
+        this._observedChildren = {
+            first: this._firstCurrentChild,
+            last: this._lastCurrentChild,
+        };
+        this._rootMargin = 0;
+        this._threshold = 1;
+        this._intersectionObserver = null;
+        this.etObserveScrollState = new EventEmitter();
+    }
+    get _firstCurrentChild() {
+        const explicitFirstElement = this._elementRef.nativeElement.querySelector(`.${SCROLL_OBSERVER_FIRST_ELEMENT_CLASS}`);
+        if (explicitFirstElement) {
+            return explicitFirstElement;
+        }
+        const element = this._elementRef.nativeElement.children[0];
+        return this._getNonIgnoredChild(element, 'next');
+    }
+    get _lastCurrentChild() {
+        const explicitLastElement = this._elementRef.nativeElement.querySelector(`.${SCROLL_OBSERVER_LAST_ELEMENT_CLASS}`);
+        if (explicitLastElement) {
+            return explicitLastElement;
+        }
+        const element = this._elementRef.nativeElement.children[this._elementRef.nativeElement.children.length - 1];
+        return this._getNonIgnoredChild(element, 'previous');
+    }
+    get observerRootMargin() {
+        return this._rootMargin;
+    }
+    set observerRootMargin(value) {
+        this._rootMargin = coerceNumberProperty(value);
+    }
+    get observerThreshold() {
+        return this._threshold;
+    }
+    set observerThreshold(value) {
+        this._threshold = coerceNumberProperty(value);
+    }
+    ngOnInit() {
+        this._contentObserverService
+            .observe(this._elementRef.nativeElement)
+            .pipe(tap(() => this._checkChildren()), takeUntil(this._destroy$))
+            .subscribe();
+        this._resizeObserverService
+            .observe(this._elementRef.nativeElement)
+            .pipe(debounceTime(25), tap(() => {
+            const canScroll = elementCanScroll(this._elementRef.nativeElement);
+            if ((!this._intersectionObserver && canScroll) || (this._intersectionObserver && !canScroll)) {
+                this._checkChildren();
+            }
+        }), takeUntil(this._destroy$))
+            .subscribe();
+        this._checkChildren();
+    }
+    ngOnDestroy() {
+        this._clearIntersectionObserver();
+    }
+    _checkChildren() {
+        this._clearIntersectionObserver();
+        if (this._firstCurrentChild === this._lastCurrentChild ||
+            !this._firstCurrentChild ||
+            !this._lastCurrentChild ||
+            !elementCanScroll(this._elementRef.nativeElement)) {
+            this._unobserveChild('first');
+            this._unobserveChild('last');
+            this.etObserveScrollState.emit({
+                isAtStart: true,
+                isAtEnd: true,
+                canScroll: false,
+            });
+        }
+        else {
+            this._intersectionObserver = this._initiateIntersectionObserver();
+            this._observeChild('first', this._firstCurrentChild);
+            this._observeChild('last', this._lastCurrentChild);
+        }
+    }
+    _initiateIntersectionObserver() {
+        const observer = new IntersectionObserver((entries) => {
+            const { first, last } = this._observedChildren;
+            const isAtStart = entries.find((entry) => entry.target === first)?.isIntersecting ?? false;
+            const isAtEnd = entries.find((entry) => entry.target === last)?.isIntersecting ?? false;
+            this.etObserveScrollState.emit({
+                isAtStart,
+                isAtEnd,
+                canScroll: !isAtStart || !isAtEnd,
+            });
+        }, {
+            root: this._elementRef.nativeElement,
+            rootMargin: `${this._rootMargin}px`,
+            threshold: this._threshold,
+        });
+        return observer;
+    }
+    _observeChild(child, element) {
+        this._intersectionObserver?.observe(element);
+        this._observedChildren[child] = element;
+        element.classList.add(`et-scroll-observer-observing-${child}-element`);
+    }
+    _unobserveChild(child) {
+        const observedChild = this._observedChildren[child];
+        if (!observedChild) {
+            return;
+        }
+        observedChild.classList.remove('et-scroll-observer-observing-first-element', 'et-scroll-observer-observing-last-element');
+        this._intersectionObserver?.unobserve(observedChild);
+        this._observedChildren[child] = null;
+    }
+    _clearIntersectionObserver() {
+        this._intersectionObserver?.disconnect();
+        this._intersectionObserver = null;
+    }
+    _getNonIgnoredChild(element, direction) {
+        if (!element) {
+            return null;
+        }
+        if (element?.classList.contains(SCROLL_OBSERVER_IGNORE_TARGET_CLASS)) {
+            const nextElement = element[`${direction}ElementSibling`];
+            if (!nextElement) {
+                return null;
+            }
+            return this._getNonIgnoredChild(nextElement, direction);
+        }
+        return element;
+    }
+}
+ObserveScrollStateDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.4", ngImport: i0, type: ObserveScrollStateDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+ObserveScrollStateDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.1.4", type: ObserveScrollStateDirective, isStandalone: true, selector: "[etObserveScrollState]", inputs: { observerRootMargin: "observerRootMargin", observerThreshold: "observerThreshold" }, outputs: { etObserveScrollState: "etObserveScrollState" }, providers: [
+        {
+            provide: OBSERVE_SCROLL_STATE,
+            useExisting: ObserveScrollStateDirective,
+        },
+        DestroyService,
+    ], exportAs: ["etObserveScrollState"], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.4", ngImport: i0, type: ObserveScrollStateDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[etObserveScrollState]',
+                    exportAs: 'etObserveScrollState',
+                    standalone: true,
+                    providers: [
+                        {
+                            provide: OBSERVE_SCROLL_STATE,
+                            useExisting: ObserveScrollStateDirective,
+                        },
+                        DestroyService,
+                    ],
+                }]
+        }], propDecorators: { observerRootMargin: [{
+                type: Input
+            }], observerThreshold: [{
+                type: Input
+            }], etObserveScrollState: [{
+                type: Output
+            }] } });
+
+class RepeatDirective {
+    get repeatCount() {
+        return this._repeatCount;
+    }
+    set repeatCount(value) {
+        this._repeatCount = coerceNumberProperty(value);
+        this._render();
+    }
+    constructor(_mainTemplateRef, _viewContainerRef) {
+        this._mainTemplateRef = _mainTemplateRef;
+        this._viewContainerRef = _viewContainerRef;
+        this._repeatCount = 2;
+    }
+    _render() {
+        this._viewContainerRef.clear();
+        for (let i = 0; i < this.repeatCount; i++) {
+            this._viewContainerRef.createEmbeddedView(this._mainTemplateRef);
+        }
+    }
+}
+RepeatDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.4", ngImport: i0, type: RepeatDirective, deps: [{ token: i0.TemplateRef }, { token: i0.ViewContainerRef }], target: i0.ɵɵFactoryTarget.Directive });
+RepeatDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.1.4", type: RepeatDirective, isStandalone: true, selector: "[etRepeat]", inputs: { repeatCount: ["etRepeat", "repeatCount"] }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.4", ngImport: i0, type: RepeatDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[etRepeat]',
+                    standalone: true,
+                }]
+        }], ctorParameters: function () { return [{ type: i0.TemplateRef }, { type: i0.ViewContainerRef }]; }, propDecorators: { repeatCount: [{
+                type: Input,
+                args: ['etRepeat']
             }] } });
 
+const SEO_DIRECTIVE_TOKEN = new InjectionToken('SEO_DIRECTIVE_TOKEN');
+
+const mergeSeoConfig = (config, parentConfig) => {
+    return {
+        ...parentConfig,
+        ...config,
+    };
+};
+
+class SeoDirective {
+    constructor() {
+        this._metaService = inject(Meta);
+        this._titleService = inject(Title);
+        this._onDeactivate$ = new Subject();
+        this._isDeactivated = false;
+        this.parent = inject(SEO_DIRECTIVE_TOKEN, { optional: true, skipSelf: true });
+        this._config = {};
+    }
+    get config() {
+        return this._config;
+    }
+    ngOnInit() {
+        this.parent?._deactivate();
+    }
+    ngOnDestroy() {
+        this._deactivate();
+        this._cleanUp();
+        this.parent?._activate();
+    }
+    // TODO(TRB): This should get split up into multiple methods to make it more readable
+    // - updateTitle
+    // - updateMeta
+    // - updateLink
+    updateConfig(config) {
+        this._config = mergeSeoConfig(config, this.parent?.config || {});
+        if (this._isDeactivated) {
+            return;
+        }
+        this._deactivate();
+        this._activate();
+    }
+    _activate() {
+        this._onDeactivate$.next(false);
+        this._isDeactivated = false;
+        for (const [key, value] of Object.entries(this._config)) {
+            if (value instanceof Observable) {
+                value.pipe(takeUntil(this._onDeactivate$)).subscribe((value) => this._update(key, value));
+            }
+            else if (Array.isArray(value)) {
+                value.forEach((value) => {
+                    if (value instanceof Observable) {
+                        value.pipe(takeUntil(this._onDeactivate$)).subscribe((value) => this._update(key, value));
+                    }
+                    else {
+                        this._update(key, value);
+                    }
+                });
+            }
+            else if (typeof value === 'object' && value !== null) {
+                for (const [subKey, subValue] of Object.entries(value)) {
+                    if (subValue instanceof Observable) {
+                        subValue.pipe(takeUntil(this._onDeactivate$)).subscribe((value) => this._update(`${key}:${subKey}`, value));
+                    }
+                    else {
+                        this._update(`${key}:${subKey}`, subValue);
+                    }
+                }
+            }
+            else {
+                this._update(key, value);
+            }
+        }
+    }
+    _deactivate() {
+        this._onDeactivate$.next(true);
+        this._isDeactivated = true;
+    }
+    _update(key, value) {
+        switch (key) {
+            case 'title':
+                if (value && typeof value === 'string') {
+                    this._titleService.setTitle(value);
+                }
+                break;
+            case 'canonical':
+                {
+                    const link = document.querySelector(`link[rel="${key}"]`);
+                    if (link) {
+                        link.setAttribute('href', value);
+                    }
+                    else {
+                        const newLink = document.createElement('link');
+                        newLink.setAttribute('rel', key);
+                        newLink.setAttribute('href', value);
+                        document.head.appendChild(newLink);
+                    }
+                }
+                break;
+            case 'alternate':
+                {
+                    const link = document.querySelector(`link[rel="${key}"][hreflang="${value.hreflang}"]`);
+                    if (link) {
+                        link.setAttribute('href', value.href);
+                    }
+                    else {
+                        const newLink = document.createElement('link');
+                        newLink.setAttribute('rel', key);
+                        newLink.setAttribute('hreflang', value.hreflang);
+                        newLink.setAttribute('href', value.href);
+                        document.head.appendChild(newLink);
+                    }
+                }
+                break;
+            default:
+                if (value !== undefined && value !== null) {
+                    const val = Array.isArray(value) ? value.join(', ') : value;
+                    this._metaService.updateTag({ name: key, content: val });
+                }
+                else {
+                    this._metaService.removeTag(`name="${key}"`);
+                }
+                break;
+        }
+    }
+    _cleanUp() {
+        for (const key in this._config) {
+            if (key === 'alternate') {
+                const links = document.querySelectorAll(`link[rel="${key}"]`);
+                links.forEach((link) => {
+                    link.remove();
+                });
+                continue;
+            }
+            if (key === 'canonical') {
+                const link = document.querySelector(`link[rel="${key}"]`);
+                if (link) {
+                    link.remove();
+                }
+                continue;
+            }
+            if (typeof this._config[key] === 'object' &&
+                this._config[key] !== null &&
+                !(this._config[key] instanceof Observable)) {
+                for (const subKey in this._config[key]) {
+                    const parentValue = this.parent?.config?.[key]?.[subKey];
+                    if (parentValue === undefined) {
+                        this._update(`${key}:${subKey}`, undefined);
+                    }
+                }
+            }
+            else {
+                const parentValue = this.parent?.config?.[key];
+                if (parentValue === undefined) {
+                    this._update(key, null);
+                }
+            }
+        }
+    }
+}
+SeoDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.4", ngImport: i0, type: SeoDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+SeoDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.1.4", type: SeoDirective, isStandalone: true, providers: [{ provide: SEO_DIRECTIVE_TOKEN, useExisting: SeoDirective }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.4", ngImport: i0, type: SeoDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    standalone: true,
+                    providers: [{ provide: SEO_DIRECTIVE_TOKEN, useExisting: SeoDirective }],
+                }]
+        }] });
+
+// TODO(TRB): Add correct type once provided by API
+const normalizeGameResultType = (type) => {
+    if (!type) {
+        return null;
+    }
+    switch (type) {
+        case 'extra_time':
+            return {
+                i18n: 'game-result-type.extra-time',
+                shortCode: 'AET',
+                text: 'After Extra Time',
+            };
+        case 'penalty':
+            return {
+                i18n: 'game-result-type.penalty',
+                shortCode: 'PSO',
+                text: 'Penalty shootout',
+            };
+        case 'golden_goal':
+            return {
+                i18n: 'game-result-type.golden-goal',
+                shortCode: 'GG',
+                text: 'Golden Goal',
+            };
+        case 'default':
+        default:
+            return {
+                i18n: 'game-result-type.full-time',
+                shortCode: 'FT',
+                text: 'Full Time',
+            };
+    }
+};
+
+class NormalizeGameResultTypePipe {
+    constructor() {
+        this.transform = normalizeGameResultType;
+    }
+}
+NormalizeGameResultTypePipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.4", ngImport: i0, type: NormalizeGameResultTypePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+NormalizeGameResultTypePipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "15.1.4", ngImport: i0, type: NormalizeGameResultTypePipe, isStandalone: true, name: "etNormalizeGameResultType" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.4", ngImport: i0, type: NormalizeGameResultTypePipe, decorators: [{
+            type: Pipe,
+            args: [{ name: 'etNormalizeGameResultType', standalone: true }]
+        }] });
+
+const normalizeMatchState = (match) => {
+    if (match?.isCompletedByReferee) {
+        return "autoWin" /* MatchStateType.AUTO_WIN */;
+    }
+    else if (match?.status === 'preparing') {
+        return "preMatch" /* MatchStateType.PRE_MATCH */;
+    }
+    else if (match?.status === 'started') {
+        return "live" /* MatchStateType.LIVE */;
+    }
+    else if (match?.status === 'published' || match?.status === 'finished') {
+        return "postMatch" /* MatchStateType.POST_MATCH */;
+    }
+    else if (match?.round.state !== 'preparing') {
+        return "preparingRound" /* MatchStateType.PREPARING_ROUND */;
+    }
+    return null;
+};
+
+class NormalizeMatchStatePipe {
+    constructor() {
+        this.transform = normalizeMatchState;
+    }
+}
+NormalizeMatchStatePipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.4", ngImport: i0, type: NormalizeMatchStatePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+NormalizeMatchStatePipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "15.1.4", ngImport: i0, type: NormalizeMatchStatePipe, isStandalone: true, name: "etNormalizeMatchState" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.4", ngImport: i0, type: NormalizeMatchStatePipe, decorators: [{
+            type: Pipe,
+            args: [{ name: 'etNormalizeMatchState', standalone: true }]
+        }] });
+
+const normalizeMatchParticipants = (match) => {
+    const matchState = normalizeMatchState(match);
+    if (!match || !matchState) {
+        return null;
+    }
+    return {
+        home: normalizeMatchParticipant(match, 'home'),
+        away: normalizeMatchParticipant(match, 'away'),
+    };
+};
+const normalizeMatchParticipant = (match, side) => {
+    const matchState = normalizeMatchState(match);
+    if (!match || !matchState) {
+        return null;
+    }
+    const participant = match[side];
+    const participantType = match.home?.type ?? match.away?.type ?? 'unknown';
+    if (!participant) {
+        if (matchState === "postMatch" /* MatchStateType.POST_MATCH */ || matchState === "autoWin" /* MatchStateType.AUTO_WIN */) {
+            return {
+                participantType,
+                type: 'none',
+                i18n: 'match-participant.none',
+                text: 'No opponent',
+                data: participant,
+            };
+        }
+        else {
+            return {
+                participantType,
+                type: 'tbd',
+                i18n: 'match-participant.tbd',
+                text: 'TBD',
+                data: participant,
+            };
+        }
+    }
+    else {
+        return {
+            participantType,
+            type: 'participant',
+            data: participant,
+        };
+    }
+};
+
+class NormalizeMatchParticipantsPipe {
+    constructor() {
+        this.transform = normalizeMatchParticipants;
+    }
+}
+NormalizeMatchParticipantsPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.4", ngImport: i0, type: NormalizeMatchParticipantsPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+NormalizeMatchParticipantsPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "15.1.4", ngImport: i0, type: NormalizeMatchParticipantsPipe, isStandalone: true, name: "etNormalizeMatchParticipants" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.4", ngImport: i0, type: NormalizeMatchParticipantsPipe, decorators: [{
+            type: Pipe,
+            args: [{ name: 'etNormalizeMatchParticipants', standalone: true }]
+        }] });
+
+const EMPTY_SCORE = {
+    home: { score: 'match-score.placeholder', isWinner: false },
+    away: { score: 'match-score.placeholder', isWinner: false },
+    isNumeric: false,
+    subLine: null,
+};
+const normalizeMatchScore = (match) => {
+    if (!match) {
+        return null;
+    }
+    const matchState = normalizeMatchState(match);
+    const subLine = getMatchScoreSubLine(match);
+    if (!match.homeScore && !match.awayScore) {
+        return { ...EMPTY_SCORE, subLine, isNumeric: false };
+    }
+    if (isKnockoutMatch(match)) {
+        if (matchState === "preMatch" /* MatchStateType.PRE_MATCH */ || matchState === "live" /* MatchStateType.LIVE */) {
+            return { ...EMPTY_SCORE, subLine, isNumeric: false };
+        }
+        return {
+            home: {
+                score: getKnockoutMatchScore(match.homeScore),
+                isWinner: match.homeScore?.status === 'won',
+            },
+            away: {
+                score: getKnockoutMatchScore(match.awayScore),
+                isWinner: match.awayScore?.status === 'won',
+            },
+            subLine,
+            isNumeric: false,
+        };
+    }
+    else if (isGroupMatch(match)) {
+        if (match.games.length === 1) {
+            // Return the score if only one game has been played
+            return {
+                ...getGroupMatchScore(match),
+                subLine,
+                isNumeric: true,
+            };
+        }
+        else {
+            return {
+                ...getGroupMatchPoints(match),
+                subLine,
+                isNumeric: true,
+            };
+        }
+    }
+    else {
+        return {
+            ...getGroupMatchScore(match),
+            subLine,
+            isNumeric: true,
+        };
+    }
+};
+const isKnockoutMatch = (match) => {
+    if (!match) {
+        return false;
+    }
+    return (match.matchType === 'single_elimination' ||
+        match.matchType === 'double_elimination' ||
+        match.matchType === 'fifa_swiss');
+};
+const isGroupMatch = (match) => {
+    if (!match) {
+        return false;
+    }
+    return match.matchType === 'groups' || match.matchType === 'league';
+};
+const getKnockoutMatchScore = (score) => {
+    if (score?.status === 'won') {
+        return 'match-score.knockout.won';
+    }
+    else if (score?.status === 'lost') {
+        return 'match-score.knockout.lost';
+    }
+    else if (score?.status === 'tie') {
+        return 'match-score.knockout.tie';
+    }
+    return null;
+};
+const getMatchScoreSubLine = (match) => {
+    if (isKnockoutMatch(match)) {
+        return null;
+    }
+    else if (isGroupMatch(match)) {
+        return 'match-score.groups.sub-line';
+    }
+    else {
+        return null;
+    }
+};
+const getGroupMatchScore = (match) => {
+    if (!match) {
+        return null;
+    }
+    return {
+        home: {
+            score: match.homeScore?.ownPoints || 0,
+            isWinner: match.homeScore?.status === 'won',
+        },
+        away: {
+            score: match.awayScore?.ownPoints || 0,
+            isWinner: match.awayScore?.status === 'won',
+        },
+    };
+};
+const getGroupMatchPoints = (match) => {
+    if (!match) {
+        return null;
+    }
+    return {
+        home: {
+            score: match.homeScore?.score || 0,
+            isWinner: match.homeScore?.status === 'won',
+        },
+        away: {
+            score: match.awayScore?.score || 0,
+            isWinner: match.awayScore?.status === 'won',
+        },
+    };
+};
+
+class NormalizeMatchScorePipe {
+    constructor() {
+        this.transform = normalizeMatchScore;
+    }
+}
+NormalizeMatchScorePipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.4", ngImport: i0, type: NormalizeMatchScorePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+NormalizeMatchScorePipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "15.1.4", ngImport: i0, type: NormalizeMatchScorePipe, isStandalone: true, name: "etNormalizeMatchScore" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.4", ngImport: i0, type: NormalizeMatchScorePipe, decorators: [{
+            type: Pipe,
+            args: [{ name: 'etNormalizeMatchScore', standalone: true }]
+        }] });
+
+const normalizeMatchType = (matchType) => {
+    if (!matchType) {
+        return null;
+    }
+    switch (matchType) {
+        case 'double_elimination':
+            return {
+                i18n: 'match-type.double-elimination',
+                text: 'Double Elimination',
+            };
+        case 'single_elimination':
+            return {
+                i18n: 'match-type.single-elimination',
+                text: 'Single Elimination',
+            };
+        case 'fifa_swiss':
+            return {
+                i18n: 'match-type.fifa-swiss',
+                text: 'FIFA Swiss',
+            };
+        case 'groups':
+            return {
+                i18n: 'match-type.groups',
+                text: 'Groups',
+            };
+        case 'league':
+            return {
+                i18n: 'match-type.league',
+                text: 'League',
+            };
+        case 'pools':
+            return {
+                i18n: 'match-type.pools',
+                text: 'Pools',
+            };
+    }
+};
+
+class NormalizeMatchTypePipe {
+    constructor() {
+        this.transform = normalizeMatchType;
+    }
+}
+NormalizeMatchTypePipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.4", ngImport: i0, type: NormalizeMatchTypePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+NormalizeMatchTypePipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "15.1.4", ngImport: i0, type: NormalizeMatchTypePipe, isStandalone: true, name: "etNormalizeMatchType" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.4", ngImport: i0, type: NormalizeMatchTypePipe, decorators: [{
+            type: Pipe,
+            args: [{ name: 'etNormalizeMatchType', standalone: true }]
+        }] });
+
 const toArray = (value) => {
     return Array.from({ length: value }, (_, i) => i);
 };
@@ -600,24 +2069,51 @@ class ToArrayPipe {
         this.transform = toArray;
     }
 }
-ToArrayPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: ToArrayPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
-ToArrayPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "14.2.7", ngImport: i0, type: ToArrayPipe, isStandalone: true, name: "toArray" });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: ToArrayPipe, decorators: [{
+ToArrayPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.4", ngImport: i0, type: ToArrayPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+ToArrayPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "15.1.4", ngImport: i0, type: ToArrayPipe, isStandalone: true, name: "toArray" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.4", ngImport: i0, type: ToArrayPipe, decorators: [{
             type: Pipe,
             args: [{ name: 'toArray', standalone: true }]
         }] });
 
-const provideViewportConfig = (viewportConfig) => {
-    return { provide: VIEWPORT_CONFIG, useValue: viewportConfig };
-};
-
-const clamp = (value, min = 0, max = 100) => {
-    return Math.max(min, Math.min(max, value));
-};
+var _a;
+class TypedQueryList extends QueryList {
+    constructor() {
+        super(...arguments);
+        this[_a] = () => {
+            return super[Symbol.iterator]();
+        };
+    }
+    get changes() {
+        return super.changes;
+    }
+    toArray() {
+        return super.toArray();
+    }
+    forEach(fn) {
+        super.forEach(fn);
+    }
+    filter(fn) {
+        return super.filter(fn);
+    }
+    map(fn) {
+        return super.map(fn);
+    }
+    reduce(fn, initialValue) {
+        return super.reduce(fn, initialValue);
+    }
+    some(fn) {
+        return super.some(fn);
+    }
+    find(fn) {
+        return super.find(fn);
+    }
+}
+_a = Symbol.iterator;
 
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { ContentObserverService, DEFAULT_VIEWPORT_CONFIG, FocusVisibleService, LetContext, LetDirective, Memo, MutationObserverFactory, ObserveContentDirective, ObserveResizeDirective, RepeatDirective, ResizeObserverFactory, ResizeObserverService, ToArrayPipe, VIEWPORT_CONFIG, ViewportService, clamp, provideViewportConfig, toArray, toArrayTrackByFn };
+export { ClickObserverFactory, ClickObserverService, ClickOutsideDirective, ContentObserverService, CursorDragScrollDirective, DEFAULT_VIEWPORT_CONFIG, DestroyService, FocusVisibleService, LetContext, LetDirective, Memo, 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, StructuredDataComponent, ToArrayPipe, TypedQueryList, VIEWPORT_CONFIG, ViewportService, clamp, clone, createReactiveBindings, deleteCookie, elementCanScroll, equal, getCookie, getDomain, getGroupMatchPoints, getGroupMatchScore, getKnockoutMatchScore, getMatchScoreSubLine, hasCookie, isGroupMatch, isKnockoutMatch, mergeSeoConfig, normalizeGameResultType, normalizeMatchParticipant, normalizeMatchParticipants, normalizeMatchScore, normalizeMatchState, normalizeMatchType, provideViewportConfig, routerDisableScrollTop, setCookie, toArray, toArrayTrackByFn };
 //# sourceMappingURL=ethlete-core.mjs.map