@ethlete/core 0.2.0-next.1 → 0.2.0-next.11

package/fesm2015/ethlete-core.mjs

@@ -1,10 +1,46 @@
 import * as i0 from '@angular/core';
-import { InjectionToken, Directive, Input, Pipe, Injectable, Inject, Optional, inject } from '@angular/core';
-import { coerceNumberProperty } from '@angular/cdk/coercion';
+import { inject, Component, ChangeDetectionStrategy, ViewEncapsulation, Input, HostBinding, InjectionToken, Injectable, Inject, Optional, ElementRef, EventEmitter, Directive, Output, NgZone, Pipe } from '@angular/core';
+import { DomSanitizer, Meta, Title } from '@angular/platform-browser';
+import { coerceElement, coerceBooleanProperty, coerceNumberProperty } from '@angular/cdk/coercion';
+import { fromEvent, Observable, Subject, BehaviorSubject, combineLatest, map, shareReplay, takeUntil, distinctUntilChanged, startWith, debounceTime, tap, take } from 'rxjs';
+import { DOCUMENT } from '@angular/common';
 import { __decorate, __metadata } from 'tslib';
-import { BehaviorSubject, map, shareReplay } from 'rxjs';
 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.0", ngImport: i0, type: StructuredDataComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+StructuredDataComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.1.0", 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.0", 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');
 /**
@@ -37,7 +73,7 @@ function memoize(func, resolver, cache) {
     memoized.cache = cache;
     return memoized;
 }
-const defaultResolver = (...args) => args[0];
+const defaultResolver = (...args) => args.join('-');
 const Memo = (config = {}) => (_, __, descriptor) => {
     var _a, _b;
     if (typeof descriptor.value !== 'function') {
@@ -49,115 +85,269 @@ 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');
+    }
+}
+ClickObserverFactory.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: ClickObserverFactory, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+ClickObserverFactory.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: ClickObserverFactory, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: ClickObserverFactory, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+class ClickObserverService {
+    constructor(_clickObserverFactory) {
+        this._clickObserverFactory = _clickObserverFactory;
+        this._observedElements = new Map();
+    }
+    ngOnDestroy() {
+        this._observedElements.forEach((_, element) => this._cleanupObserver(element));
+    }
+    observe(elementOrRef) {
+        const element = coerceElement(elementOrRef);
+        return new Observable((observer) => {
+            const stream = this._observeElement(element);
+            const subscription = stream.subscribe(observer);
+            return () => {
+                subscription.unsubscribe();
+                this._unobserveElement(element);
+            };
+        });
+    }
+    _observeElement(element) {
+        if (!this._observedElements.has(element)) {
+            const stream = new Subject();
+            const observer = this._clickObserverFactory.create();
+            const sub = observer.subscribe((event) => stream.next(event));
+            this._observedElements.set(element, { observer: sub, stream, count: 1 });
+        }
+        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);
+        }
     }
 }
+ClickObserverService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: ClickObserverService, deps: [{ token: ClickObserverFactory }], target: i0.ɵɵFactoryTarget.Injectable });
+ClickObserverService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: ClickObserverService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: ClickObserverService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: ClickObserverFactory }]; } });
 
-class LetDirective {
-    constructor(_viewContainer, templateRef) {
-        this._viewContainer = _viewContainer;
-        this._context = new LetContext();
-        this._templateRef = null;
-        this._viewRef = null;
-        this._templateRef = templateRef;
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+class MutationObserverFactory {
+    create(callback) {
+        return typeof MutationObserver === 'undefined' ? null : new MutationObserver(callback);
     }
-    set etLet(value) {
-        this._context.$implicit = this._context.etLet = value;
-        this._updateView();
+}
+MutationObserverFactory.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: MutationObserverFactory, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+MutationObserverFactory.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: MutationObserverFactory, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: MutationObserverFactory, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+class ContentObserverService {
+    constructor(_mutationObserverFactory) {
+        this._mutationObserverFactory = _mutationObserverFactory;
+        this._observedElements = new Map();
     }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    static ngTemplateContextGuard(dir, ctx) {
-        return true;
+    ngOnDestroy() {
+        this._observedElements.forEach((_, element) => this._cleanupObserver(element));
     }
-    _updateView() {
-        if (!this._viewRef) {
-            this._viewContainer.clear();
-            if (this._templateRef) {
-                this._viewRef = this._viewContainer.createEmbeddedView(this._templateRef, this._context);
+    observe(elementOrRef) {
+        const element = coerceElement(elementOrRef);
+        return new Observable((observer) => {
+            const stream = this._observeElement(element);
+            const subscription = stream.subscribe(observer);
+            return () => {
+                subscription.unsubscribe();
+                this._unobserveElement(element);
+            };
+        });
+    }
+    _observeElement(element) {
+        if (!this._observedElements.has(element)) {
+            const stream = new Subject();
+            const observer = this._mutationObserverFactory.create((mutations) => stream.next(mutations));
+            if (observer) {
+                observer.observe(element, {
+                    characterData: true,
+                    childList: true,
+                    subtree: true,
+                });
+            }
+            this._observedElements.set(element, { observer, stream, count: 1 });
+        }
+        else {
+            this._observedElements.get(element).count++;
+        }
+        return this._observedElements.get(element).stream;
+    }
+    _unobserveElement(element) {
+        if (this._observedElements.has(element)) {
+            this._observedElements.get(element).count--;
+            if (!this._observedElements.get(element).count) {
+                this._cleanupObserver(element);
+            }
+        }
+    }
+    _cleanupObserver(element) {
+        if (this._observedElements.has(element)) {
+            const { observer, stream } = this._observedElements.get(element);
+            if (observer) {
+                observer.disconnect();
             }
+            stream.complete();
+            this._observedElements.delete(element);
         }
     }
 }
-LetDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.6", 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.6", type: LetDirective, isStandalone: true, selector: "[etLet]", inputs: { etLet: "etLet" }, ngImport: i0 });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.6", 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
-            }] } });
+ContentObserverService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: ContentObserverService, deps: [{ token: MutationObserverFactory }], target: i0.ɵɵFactoryTarget.Injectable });
+ContentObserverService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: ContentObserverService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: ContentObserverService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: MutationObserverFactory }]; } });
 
-class RepeatDirective {
-    constructor(_mainTemplateRef, _viewContainerRef) {
-        this._mainTemplateRef = _mainTemplateRef;
-        this._viewContainerRef = _viewContainerRef;
-        this._repeatCount = 2;
+class DestroyService {
+    constructor() {
+        this._destroy$ = new Subject();
+        this.destroy$ = this._destroy$.asObservable();
     }
-    get repeatCount() {
-        return this._repeatCount;
+    ngOnDestroy() {
+        this._destroy$.next(true);
+        this._destroy$.unsubscribe();
     }
-    set repeatCount(value) {
-        this._repeatCount = coerceNumberProperty(value);
+}
+DestroyService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: DestroyService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+DestroyService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: DestroyService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: DestroyService, decorators: [{
+            type: Injectable
+        }] });
+
+class FocusVisibleService {
+    get isFocusVisible() {
+        return this._hadKeyboardEvent;
     }
-    ngOnInit() {
-        this._render();
+    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);
     }
-    _render() {
-        for (let i = 0; i < this.repeatCount; i++) {
-            this._viewContainerRef.createEmbeddedView(this._mainTemplateRef);
+    onKeyDown(e) {
+        if (e.metaKey || e.altKey || e.ctrlKey) {
+            return;
         }
+        this._hadKeyboardEvent = true;
+    }
+    onPointerDown() {
+        this._hadKeyboardEvent = false;
     }
 }
-RepeatDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.6", 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.6", type: RepeatDirective, isStandalone: true, selector: "[etRepeat]", inputs: { repeatCount: ["etRepeat", "repeatCount"] }, ngImport: i0 });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.6", ngImport: i0, type: RepeatDirective, decorators: [{
-            type: Directive,
+FocusVisibleService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: FocusVisibleService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+FocusVisibleService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: FocusVisibleService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: FocusVisibleService, decorators: [{
+            type: Injectable,
             args: [{
-                    selector: '[etRepeat]',
-                    standalone: true,
+                    providedIn: 'root',
                 }]
-        }], ctorParameters: function () { return [{ type: i0.TemplateRef }, { type: i0.ViewContainerRef }]; }, propDecorators: { repeatCount: [{
-                type: Input,
-                args: ['etRepeat']
-            }] } });
-
-const toArray = (value) => {
-    return Array.from({ length: value }, (_, i) => i);
-};
-const toArrayTrackByFn = (_, item) => item;
+        }], ctorParameters: function () { return []; } });
 
-class ToArrayPipe {
-    constructor() {
-        this.transform = toArray;
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+class ResizeObserverFactory {
+    create(callback) {
+        return typeof ResizeObserver === 'undefined' ? null : new ResizeObserver(callback);
     }
 }
-ToArrayPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.6", ngImport: i0, type: ToArrayPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
-ToArrayPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "14.2.6", ngImport: i0, type: ToArrayPipe, isStandalone: true, name: "toArray" });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.6", ngImport: i0, type: ToArrayPipe, decorators: [{
-            type: Pipe,
-            args: [{ name: 'toArray', standalone: true }]
+ResizeObserverFactory.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: ResizeObserverFactory, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+ResizeObserverFactory.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: ResizeObserverFactory, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: ResizeObserverFactory, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
         }] });
+class ResizeObserverService {
+    constructor(_mutationObserverFactory) {
+        this._mutationObserverFactory = _mutationObserverFactory;
+        this._observedElements = new Map();
+    }
+    ngOnDestroy() {
+        this._observedElements.forEach((_, element) => this._cleanupObserver(element));
+    }
+    observe(elementOrRef) {
+        const element = coerceElement(elementOrRef);
+        return new Observable((observer) => {
+            const stream = this._observeElement(element);
+            const subscription = stream.subscribe(observer);
+            return () => {
+                subscription.unsubscribe();
+                this._unobserveElement(element);
+            };
+        });
+    }
+    _observeElement(element) {
+        if (!this._observedElements.has(element)) {
+            const stream = new Subject();
+            const observer = this._mutationObserverFactory.create((resizes) => stream.next(resizes));
+            if (observer) {
+                observer.observe(element);
+            }
+            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.0", ngImport: i0, type: ResizeObserverService, deps: [{ token: ResizeObserverFactory }], target: i0.ɵɵFactoryTarget.Injectable });
+ResizeObserverService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: ResizeObserverService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: ResizeObserverService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: ResizeObserverFactory }]; } });
 
 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._viewportConfig = _viewportConfig || DEFAULT_VIEWPORT_CONFIG;
-        this._observeDefaultBreakpoints();
-    }
     get isXs$() {
         return this._isXs$.asObservable();
     }
@@ -194,6 +384,21 @@ class ViewportService {
     get is2Xl() {
         return this._is2Xl$.value;
     }
+    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());
@@ -222,7 +427,7 @@ class ViewportService {
         // Due to scaling, the actual size of the viewport may be a decimal number.
         // Eg. on Windows 11 with 150% scaling, the viewport size may be 1535.33px
         // and thus not matching any of the default breakpoints.
-        return size + 0.9999;
+        return size + 0.9;
     }
     _buildMediaQuery(options) {
         if (!options.min && !options.max) {
@@ -250,9 +455,30 @@ class ViewportService {
         }
         return mediaQueryParts.join(' ');
     }
+    getCurrentViewport([isXs, isSm, isMd, isLg, isXl, is2Xl]) {
+        if (isXs) {
+            return 'xs';
+        }
+        else if (isSm) {
+            return 'sm';
+        }
+        else if (isMd) {
+            return 'md';
+        }
+        else if (isLg) {
+            return 'lg';
+        }
+        else if (isXl) {
+            return 'xl';
+        }
+        else if (is2Xl) {
+            return '2xl';
+        }
+        return 'xs';
+    }
 }
-ViewportService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.6", 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.6", ngImport: i0, type: ViewportService, providedIn: 'root' });
+ViewportService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", 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.0", ngImport: i0, type: ViewportService, providedIn: 'root' });
 __decorate([
     Memo(),
     __metadata("design:type", Function),
@@ -270,7 +496,7 @@ __decorate([
     __metadata("design:paramtypes", [Object]),
     __metadata("design:returntype", void 0)
 ], ViewportService.prototype, "_buildMediaQuery", null);
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.6", ngImport: i0, type: ViewportService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: ViewportService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
@@ -284,48 +510,1217 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.6", ngImpor
                     }] }, { 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() {
+        var _a;
+        (_a = this._subscription) === null || _a === void 0 ? void 0 : _a.unsubscribe();
     }
 }
-FocusVisibleService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.6", ngImport: i0, type: FocusVisibleService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-FocusVisibleService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.6", ngImport: i0, type: FocusVisibleService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.6", ngImport: i0, type: FocusVisibleService, decorators: [{
-            type: Injectable,
+ClickOutsideDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: ClickOutsideDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+ClickOutsideDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.1.0", type: ClickOutsideDirective, isStandalone: true, selector: "[etClickOutside]", outputs: { etClickOutside: "etClickOutside" }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: ClickOutsideDirective, decorators: [{
+            type: Directive,
             args: [{
-                    providedIn: 'root',
+                    selector: '[etClickOutside]',
+                    standalone: true,
                 }]
-        }], ctorParameters: function () { return []; } });
+        }], propDecorators: { etClickOutside: [{
+                type: Output
+            }] } });
+
+const clamp = (value, min = 0, max = 100) => {
+    return Math.max(min, Math.min(max, value));
+};
+
+const createReactiveBindings = (...values) => {
+    const elementRef = inject(ElementRef);
+    const destroy$ = inject(DestroyService).destroy$;
+    const subscriptions = [];
+    const pushedAttributes = [];
+    const defaults = {};
+    const push = (value) => {
+        const { attribute, observable } = value;
+        const attributes = Array.isArray(attribute) ? attribute : [attribute];
+        pushedAttributes.push(attributes);
+        for (const attribute of attributes) {
+            if (!defaults[attribute]) {
+                defaults[attribute] = elementRef.nativeElement.getAttribute(attribute) || undefined;
+            }
+        }
+        const subscription = observable
+            .pipe(takeUntil(destroy$), distinctUntilChanged((a, b) => a.render === b.render && a.value === b.value))
+            .subscribe((value) => {
+            const currentAttributes = pushedAttributes.find((s) => s.some((current) => attributes.includes(current))) || [];
+            for (const attribute of currentAttributes) {
+                if (!value.render) {
+                    elementRef.nativeElement.removeAttribute(attribute);
+                }
+                else {
+                    elementRef.nativeElement.setAttribute(attribute, `${value.value}`);
+                }
+            }
+        });
+        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 === null || attributeStack === void 0 ? void 0 : 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) {
+                elementRef.nativeElement.removeAttribute(attribute);
+            }
+            else {
+                elementRef.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 clamp = (value, min = 0, max = 100) => {
-    return Math.max(min, Math.min(max, value));
-};
+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).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) {
+        var _a;
+        if (!((_a = this._elementRef) === null || _a === void 0 ? void 0 : _a.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) {
+        var _a;
+        e.preventDefault();
+        if (!((_a = this._elementRef) === null || _a === void 0 ? void 0 : _a.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() {
+        var _a;
+        this._mouseUp$.next(true);
+        this._isScrolling = false;
+        if (!((_a = this._elementRef) === null || _a === void 0 ? void 0 : _a.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';
+        }
+    }
+}
+CursorDragScrollDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: CursorDragScrollDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+CursorDragScrollDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.1.0", 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.0", ngImport: i0, type: CursorDragScrollDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[etCursorDragScroll]',
+                    exportAs: 'etCursorDragScroll',
+                    standalone: true,
+                    providers: [DestroyService],
+                }]
+        }], propDecorators: { enabled: [{
+                type: Input,
+                args: ['etCursorDragScroll']
+            }] } });
+
+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.0", 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.0", type: LetDirective, isStandalone: true, selector: "[etLet]", inputs: { etLet: "etLet" }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", 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;
+        this._currentSubscription = null;
+    }
+    get disabled() {
+        return this._disabled;
+    }
+    set disabled(value) {
+        this._disabled = coerceBooleanProperty(value);
+        this._disabled ? this._unsubscribe() : this._subscribe();
+    }
+    get debounce() {
+        return this._debounce;
+    }
+    set debounce(value) {
+        this._debounce = coerceNumberProperty(value);
+        this._subscribe();
+    }
+    ngAfterContentInit() {
+        if (!this._currentSubscription && !this.disabled) {
+            this._subscribe();
+        }
+    }
+    ngOnDestroy() {
+        this._unsubscribe();
+    }
+    _subscribe() {
+        this._unsubscribe();
+        const stream = this._contentObserver.observe(this._elementRef);
+        this._ngZone.runOutsideAngular(() => {
+            this._currentSubscription = (this.debounce ? stream.pipe(debounceTime$1(this.debounce)) : stream).subscribe(this.event);
+        });
+    }
+    _unsubscribe() {
+        var _a;
+        (_a = this._currentSubscription) === null || _a === void 0 ? void 0 : _a.unsubscribe();
+    }
+}
+ObserveContentDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: ObserveContentDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+ObserveContentDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.1.0", 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.0", ngImport: i0, type: ObserveContentDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[etObserveContent]',
+                    exportAs: 'etObserveContent',
+                    standalone: true,
+                }]
+        }], propDecorators: { event: [{
+                type: Output,
+                args: ['etObserveContent']
+            }], disabled: [{
+                type: Input,
+                args: ['etObserveContentDisabled']
+            }], debounce: [{
+                type: Input,
+                args: ['etObserveContentDebounce']
+            }] } });
+
+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;
+        this._currentSubscription = null;
+    }
+    get disabled() {
+        return this._disabled;
+    }
+    set disabled(value) {
+        this._disabled = coerceBooleanProperty(value);
+        this._disabled ? this._unsubscribe() : this._subscribe();
+    }
+    get debounce() {
+        return this._debounce;
+    }
+    set debounce(value) {
+        this._debounce = coerceNumberProperty(value);
+        this._subscribe();
+    }
+    ngAfterContentInit() {
+        if (!this._currentSubscription && !this.disabled) {
+            this._subscribe();
+        }
+    }
+    ngOnDestroy() {
+        this._unsubscribe();
+    }
+    _subscribe() {
+        this._unsubscribe();
+        const stream = this._resizeObserver.observe(this._elementRef);
+        this._ngZone.runOutsideAngular(() => {
+            this._currentSubscription = (this.debounce ? stream.pipe(debounceTime(this.debounce)) : stream).subscribe(this.event);
+        });
+    }
+    _unsubscribe() {
+        var _a;
+        (_a = this._currentSubscription) === null || _a === void 0 ? void 0 : _a.unsubscribe();
+    }
+}
+ObserveResizeDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: ObserveResizeDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+ObserveResizeDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.1.0", 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.0", ngImport: i0, type: ObserveResizeDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[etObserveResize]',
+                    exportAs: 'etObserveResize',
+                    standalone: true,
+                }]
+        }], propDecorators: { event: [{
+                type: Output,
+                args: ['etObserveResize']
+            }], disabled: [{
+                type: Input,
+                args: ['etObserveResizeDisabled']
+            }], debounce: [{
+                type: Input,
+                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.0", ngImport: i0, type: ScrollObserverFirstElementDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+ScrollObserverFirstElementDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.1.0", 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.0", 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.0", ngImport: i0, type: ScrollObserverIgnoreTargetDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+ScrollObserverIgnoreTargetDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.1.0", type: ScrollObserverIgnoreTargetDirective, isStandalone: true, selector: "[etScrollObserverIgnoreTarget]", host: { classAttribute: "et-scroll-observer-ignore-target" }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", 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.0", ngImport: i0, type: ScrollObserverLastElementDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+ScrollObserverLastElementDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.1.0", 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.0", 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).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) => {
+            var _a, _b, _c, _d;
+            const { first, last } = this._observedChildren;
+            const isAtStart = (_b = (_a = entries.find((entry) => entry.target === first)) === null || _a === void 0 ? void 0 : _a.isIntersecting) !== null && _b !== void 0 ? _b : false;
+            const isAtEnd = (_d = (_c = entries.find((entry) => entry.target === last)) === null || _c === void 0 ? void 0 : _c.isIntersecting) !== null && _d !== void 0 ? _d : 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) {
+        var _a;
+        (_a = this._intersectionObserver) === null || _a === void 0 ? void 0 : _a.observe(element);
+        this._observedChildren[child] = element;
+        element.classList.add(`et-scroll-observer-observing-${child}-element`);
+    }
+    _unobserveChild(child) {
+        var _a;
+        const observedChild = this._observedChildren[child];
+        if (!observedChild) {
+            return;
+        }
+        observedChild.classList.remove('et-scroll-observer-observing-first-element', 'et-scroll-observer-observing-last-element');
+        (_a = this._intersectionObserver) === null || _a === void 0 ? void 0 : _a.unobserve(observedChild);
+        this._observedChildren[child] = null;
+    }
+    _clearIntersectionObserver() {
+        var _a;
+        (_a = this._intersectionObserver) === null || _a === void 0 ? void 0 : _a.disconnect();
+        this._intersectionObserver = null;
+    }
+    _getNonIgnoredChild(element, direction) {
+        if (!element) {
+            return null;
+        }
+        if (element === null || element === void 0 ? void 0 : 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.0", ngImport: i0, type: ObserveScrollStateDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+ObserveScrollStateDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.1.0", 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.0", 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.0", 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.0", type: RepeatDirective, isStandalone: true, selector: "[etRepeat]", inputs: { repeatCount: ["etRepeat", "repeatCount"] }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", 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 Object.assign(Object.assign({}, 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() {
+        var _a;
+        (_a = this.parent) === null || _a === void 0 ? void 0 : _a._deactivate();
+    }
+    ngOnDestroy() {
+        var _a;
+        this._deactivate();
+        this._cleanUp();
+        (_a = this.parent) === null || _a === void 0 ? void 0 : _a._activate();
+    }
+    // TODO(TRB): This should get split up into multiple methods to make it more readable
+    // - updateTitle
+    // - updateMeta
+    // - updateLink
+    updateConfig(config) {
+        var _a;
+        this._config = mergeSeoConfig(config, ((_a = this.parent) === null || _a === void 0 ? void 0 : _a.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() {
+        var _a, _b, _c, _d, _e;
+        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 = (_c = (_b = (_a = this.parent) === null || _a === void 0 ? void 0 : _a.config) === null || _b === void 0 ? void 0 : _b[key]) === null || _c === void 0 ? void 0 : _c[subKey];
+                    if (parentValue === undefined) {
+                        this._update(`${key}:${subKey}`, undefined);
+                    }
+                }
+            }
+            else {
+                const parentValue = (_e = (_d = this.parent) === null || _d === void 0 ? void 0 : _d.config) === null || _e === void 0 ? void 0 : _e[key];
+                if (parentValue === undefined) {
+                    this._update(key, null);
+                }
+            }
+        }
+    }
+}
+SeoDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: SeoDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+SeoDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.1.0", type: SeoDirective, isStandalone: true, providers: [{ provide: SEO_DIRECTIVE_TOKEN, useExisting: SeoDirective }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", 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.0", ngImport: i0, type: NormalizeGameResultTypePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+NormalizeGameResultTypePipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "15.1.0", ngImport: i0, type: NormalizeGameResultTypePipe, isStandalone: true, name: "etNormalizeGameResultType" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: NormalizeGameResultTypePipe, decorators: [{
+            type: Pipe,
+            args: [{ name: 'etNormalizeGameResultType', standalone: true }]
+        }] });
+
+const normalizeMatchState = (match) => {
+    if (match === null || match === void 0 ? void 0 : match.isCompletedByReferee) {
+        return "autoWin" /* MatchStateType.AUTO_WIN */;
+    }
+    else if ((match === null || match === void 0 ? void 0 : match.status) === 'preparing') {
+        return "preMatch" /* MatchStateType.PRE_MATCH */;
+    }
+    else if ((match === null || match === void 0 ? void 0 : match.status) === 'started') {
+        return "live" /* MatchStateType.LIVE */;
+    }
+    else if ((match === null || match === void 0 ? void 0 : match.status) === 'published' || (match === null || match === void 0 ? void 0 : match.status) === 'finished') {
+        return "postMatch" /* MatchStateType.POST_MATCH */;
+    }
+    else if ((match === null || match === void 0 ? void 0 : 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.0", ngImport: i0, type: NormalizeMatchStatePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+NormalizeMatchStatePipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "15.1.0", ngImport: i0, type: NormalizeMatchStatePipe, isStandalone: true, name: "etNormalizeMatchState" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", 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) => {
+    var _a, _b, _c, _d;
+    const matchState = normalizeMatchState(match);
+    if (!match || !matchState) {
+        return null;
+    }
+    const participant = match[side];
+    const participantType = (_d = (_b = (_a = match.home) === null || _a === void 0 ? void 0 : _a.type) !== null && _b !== void 0 ? _b : (_c = match.away) === null || _c === void 0 ? void 0 : _c.type) !== null && _d !== void 0 ? _d : '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.0", ngImport: i0, type: NormalizeMatchParticipantsPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+NormalizeMatchParticipantsPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "15.1.0", ngImport: i0, type: NormalizeMatchParticipantsPipe, isStandalone: true, name: "etNormalizeMatchParticipants" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", 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) => {
+    var _a, _b;
+    if (!match) {
+        return null;
+    }
+    const matchState = normalizeMatchState(match);
+    const subLine = getMatchScoreSubLine(match);
+    if (!match.homeScore && !match.awayScore) {
+        return Object.assign(Object.assign({}, EMPTY_SCORE), { subLine, isNumeric: false });
+    }
+    if (isKnockoutMatch(match)) {
+        if (matchState === "preMatch" /* MatchStateType.PRE_MATCH */ || matchState === "live" /* MatchStateType.LIVE */) {
+            return Object.assign(Object.assign({}, EMPTY_SCORE), { subLine, isNumeric: false });
+        }
+        return {
+            home: {
+                score: getKnockoutMatchScore(match.homeScore),
+                isWinner: ((_a = match.homeScore) === null || _a === void 0 ? void 0 : _a.status) === 'won',
+            },
+            away: {
+                score: getKnockoutMatchScore(match.awayScore),
+                isWinner: ((_b = match.awayScore) === null || _b === void 0 ? void 0 : _b.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 Object.assign(Object.assign({}, getGroupMatchScore(match)), { subLine, isNumeric: true });
+        }
+        else {
+            return Object.assign(Object.assign({}, getGroupMatchPoints(match)), { subLine, isNumeric: true });
+        }
+    }
+    else {
+        return Object.assign(Object.assign({}, 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 === null || score === void 0 ? void 0 : score.status) === 'won') {
+        return 'match-score.knockout.won';
+    }
+    else if ((score === null || score === void 0 ? void 0 : score.status) === 'lost') {
+        return 'match-score.knockout.lost';
+    }
+    else if ((score === null || score === void 0 ? void 0 : 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) => {
+    var _a, _b, _c, _d;
+    if (!match) {
+        return null;
+    }
+    return {
+        home: {
+            score: ((_a = match.homeScore) === null || _a === void 0 ? void 0 : _a.ownPoints) || 0,
+            isWinner: ((_b = match.homeScore) === null || _b === void 0 ? void 0 : _b.status) === 'won',
+        },
+        away: {
+            score: ((_c = match.awayScore) === null || _c === void 0 ? void 0 : _c.ownPoints) || 0,
+            isWinner: ((_d = match.awayScore) === null || _d === void 0 ? void 0 : _d.status) === 'won',
+        },
+    };
+};
+const getGroupMatchPoints = (match) => {
+    var _a, _b, _c, _d;
+    if (!match) {
+        return null;
+    }
+    return {
+        home: {
+            score: ((_a = match.homeScore) === null || _a === void 0 ? void 0 : _a.score) || 0,
+            isWinner: ((_b = match.homeScore) === null || _b === void 0 ? void 0 : _b.status) === 'won',
+        },
+        away: {
+            score: ((_c = match.awayScore) === null || _c === void 0 ? void 0 : _c.score) || 0,
+            isWinner: ((_d = match.awayScore) === null || _d === void 0 ? void 0 : _d.status) === 'won',
+        },
+    };
+};
+
+class NormalizeMatchScorePipe {
+    constructor() {
+        this.transform = normalizeMatchScore;
+    }
+}
+NormalizeMatchScorePipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: NormalizeMatchScorePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+NormalizeMatchScorePipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "15.1.0", ngImport: i0, type: NormalizeMatchScorePipe, isStandalone: true, name: "etNormalizeMatchScore" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", 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.0", ngImport: i0, type: NormalizeMatchTypePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+NormalizeMatchTypePipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "15.1.0", ngImport: i0, type: NormalizeMatchTypePipe, isStandalone: true, name: "etNormalizeMatchType" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: NormalizeMatchTypePipe, decorators: [{
+            type: Pipe,
+            args: [{ name: 'etNormalizeMatchType', standalone: true }]
+        }] });
+
+const toArray = (value) => {
+    return Array.from({ length: value }, (_, i) => i);
+};
+const toArrayTrackByFn = (_, item) => item;
+
+class ToArrayPipe {
+    constructor() {
+        this.transform = toArray;
+    }
+}
+ToArrayPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: ToArrayPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+ToArrayPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "15.1.0", ngImport: i0, type: ToArrayPipe, isStandalone: true, name: "toArray" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: ToArrayPipe, decorators: [{
+            type: Pipe,
+            args: [{ name: 'toArray', standalone: true }]
+        }] });
 
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { DEFAULT_VIEWPORT_CONFIG, FocusVisibleService, LetContext, LetDirective, Memo, RepeatDirective, 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, SCROLL_OBSERVER_FIRST_ELEMENT_CLASS, SCROLL_OBSERVER_IGNORE_TARGET_CLASS, SCROLL_OBSERVER_LAST_ELEMENT_CLASS, SEO_DIRECTIVE_TOKEN, ScrollObserverFirstElementDirective, ScrollObserverIgnoreTargetDirective, ScrollObserverLastElementDirective, SeoDirective, StructuredDataComponent, ToArrayPipe, VIEWPORT_CONFIG, ViewportService, clamp, createReactiveBindings, elementCanScroll, getGroupMatchPoints, getGroupMatchScore, getKnockoutMatchScore, getMatchScoreSubLine, isGroupMatch, isKnockoutMatch, mergeSeoConfig, normalizeGameResultType, normalizeMatchParticipant, normalizeMatchParticipants, normalizeMatchScore, normalizeMatchState, normalizeMatchType, provideViewportConfig, toArray, toArrayTrackByFn };
 //# sourceMappingURL=ethlete-core.mjs.map