@ethlete/cdk 4.45.0 → 4.46.0

package/fesm2022/ethlete-cdk.mjs

@@ -1,6 +1,6 @@
 import * as i1 from '@angular/cdk/portal';
 import { CdkPortal, PortalModule, ComponentPortal, TemplatePortal, CdkPortalOutlet } from '@angular/cdk/portal';
-import { AsyncPipe, NgClass, NgTemplateOutlet, JsonPipe, NgComponentOutlet, DOCUMENT, Location } from '@angular/common';
+import { AsyncPipe, NgClass, NgTemplateOutlet, NgComponentOutlet, JsonPipe, DOCUMENT, Location } from '@angular/common';
 import * as i0 from '@angular/core';
 import { Component, ViewEncapsulation, ChangeDetectionStrategy, InjectionToken, Directive, booleanAttribute, Input, ContentChild, ContentChildren, inject, ElementRef, Injector, HostBinding, input, numberAttribute, computed, signal, contentChildren, viewChild, viewChildren, isDevMode, Injectable, ChangeDetectorRef, TemplateRef, ViewContainerRef, ViewChild, assertInInjectionContext, forwardRef, EventEmitter, Output, ViewChildren, runInInjectionContext, Optional, Inject, SkipSelf, HostListener, contentChild, effect, untracked, NgZone, NgModule, DestroyRef, isSignal, Attribute } from '@angular/core';
 import * as i1$1 from '@ethlete/core';
@@ -8,6 +8,7 @@ import { LetDirective, createDestroy, Memo, signalHostAttributes, signalHostClas
 import { BehaviorSubject, startWith, map, switchMap, combineLatest, pairwise, tap, takeUntil, skip, of, merge, timer, takeWhile, filter, fromEvent, Subject, Observable, debounceTime, withLatestFrom, distinctUntilChanged, take, skipUntil, skipWhile, catchError, throwError, defer, partition, from, finalize, Subscription } from 'rxjs';
 import { trigger, state, style, transition, animate } from '@angular/animations';
 import { __decorate, __metadata } from 'tslib';
+import { DomSanitizer, Title } from '@angular/platform-browser';
 import { toSignal, toObservable, takeUntilDestroyed, outputFromObservable } from '@angular/core/rxjs-interop';
 import { extractQuery, isQueryStateSuccess, isQueryStateFailure, isQueryStateLoading, QueryDirective, queryComputed, switchQueryState, shouldRetryRequest, isClassValidatorError, isSymfonyFormViolationListError, isSymfonyListError } from '@ethlete/query';
 import * as i1$2 from '@angular/cdk/a11y';
@@ -28,7 +29,6 @@ import { startWith as startWith$1, debounceTime as debounceTime$1, distinctUntil
 import { UniqueSelectionDispatcher, _VIEW_REPEATER_STRATEGY, _DisposeViewRepeaterStrategy, _RecycleViewRepeaterStrategy, DataSource } from '@angular/cdk/collections';
 import * as i1$3 from '@angular/router';
 import { Router, RouterLink, RouterLinkActive, NavigationEnd } from '@angular/router';
-import { Title } from '@angular/platform-browser';
 import * as i1$4 from '@angular/cdk/table';
 import { CdkColumnDef, CDK_TABLE, CdkTable, _COALESCED_STYLE_SCHEDULER, _CoalescedStyleScheduler, STICKY_POSITIONING_LISTENER, HeaderRowOutlet, DataRowOutlet, NoDataRowOutlet, FooterRowOutlet, CdkCell, CdkCellDef, CdkFooterCell, CdkFooterCellDef, CdkHeaderCell, CdkHeaderCellDef, CdkTextColumn, TEXT_COLUMN_OPTIONS, CdkFooterRow, CdkTableModule, CDK_ROW_TEMPLATE, CdkFooterRowDef, CdkHeaderRow, CdkHeaderRowDef, CdkNoDataRow, CdkRow, CdkRowDef } from '@angular/cdk/table';
 import * as i1$5 from '@angular/cdk/scrolling';
@@ -1010,6 +1010,1099 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.11", ngImpo
 
 const BracketImports = [BracketComponent, BracketMatchComponent, BracketRoundHeaderComponent];
 
+const FALLBACK_MATCH_POSITION = -1;
+const TOURNAMENT_MODE = {
+    SINGLE_ELIMINATION: 'single-elimination',
+    DOUBLE_ELIMINATION: 'double-elimination',
+    GROUP: 'group',
+    SWISS: 'swiss',
+    SWISS_WITH_ELIMINATION: 'swiss-with-elimination',
+};
+const COMMON_BRACKET_ROUND_TYPE = {
+    THIRD_PLACE: 'third-place',
+    FINAL: 'final',
+};
+const SINGLE_ELIMINATION_BRACKET_ROUND_TYPE = {
+    SINGLE_ELIMINATION_BRACKET: 'single-elimination-bracket',
+};
+const DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE = {
+    UPPER_BRACKET: 'upper-bracket',
+    LOWER_BRACKET: 'lower-bracket',
+    REVERSE_FINAL: 'reverse-final',
+};
+const SWISS_BRACKET_ROUND_TYPE = {
+    SWISS: 'swiss',
+};
+const GROUP_BRACKET_ROUND_TYPE = {
+    GROUP: 'group',
+};
+const generateRoundTypeFromEthleteRoundType = (type, tournamentMode) => {
+    switch (type) {
+        case 'normal':
+            switch (tournamentMode) {
+                case 'single-elimination':
+                    return SINGLE_ELIMINATION_BRACKET_ROUND_TYPE.SINGLE_ELIMINATION_BRACKET;
+                case 'group':
+                    return GROUP_BRACKET_ROUND_TYPE.GROUP;
+                case 'swiss':
+                    return SWISS_BRACKET_ROUND_TYPE.SWISS;
+                default:
+                    throw new Error(`Unsupported tournament mode for a normal type round: ${tournamentMode}`);
+            }
+        case 'third_place':
+            return COMMON_BRACKET_ROUND_TYPE.THIRD_PLACE;
+        case 'final':
+            return COMMON_BRACKET_ROUND_TYPE.FINAL;
+        case 'reverse_final':
+            return DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE.REVERSE_FINAL;
+        case 'winner_bracket':
+            return DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE.UPPER_BRACKET;
+        case 'loser_bracket':
+            return DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE.LOWER_BRACKET;
+    }
+};
+const generateTournamentModeFormEthleteRounds = (source) => {
+    const firstRound = source[0];
+    const firstMatch = firstRound?.matches[0];
+    if (!firstRound)
+        throw new Error('No rounds found');
+    if (!firstMatch)
+        throw new Error('No matches found');
+    switch (firstMatch.matchType) {
+        case 'groups':
+            return TOURNAMENT_MODE.GROUP;
+        case 'fifa_swiss': {
+            const lastRound = source[source.length - 1];
+            if (!lastRound)
+                throw new Error('No last round found');
+            if (lastRound.matches.length !== firstRound.matches.length) {
+                return TOURNAMENT_MODE.SWISS_WITH_ELIMINATION;
+            }
+            else {
+                return TOURNAMENT_MODE.SWISS;
+            }
+        }
+        case 'double_elimination':
+            return TOURNAMENT_MODE.DOUBLE_ELIMINATION;
+        case 'single_elimination':
+            return TOURNAMENT_MODE.SINGLE_ELIMINATION;
+        default:
+            throw new Error(`Unsupported tournament mode: ${firstMatch.matchType}`);
+    }
+};
+const generateBracketDataForEthlete = (source) => {
+    const tournamentMode = generateTournamentModeFormEthleteRounds(source);
+    const bracketData = {
+        rounds: new Map(),
+        matches: new Map(),
+        participants: new Map(),
+        mode: tournamentMode,
+    };
+    let currentUpperBracketIndex = 0;
+    let currentLowerBracketIndex = 0;
+    for (const currentItem of source) {
+        if (bracketData.rounds.has(currentItem.round.id)) {
+            throw new Error(`Round with id ${currentItem.round.id} already exists in the bracket data.`);
+        }
+        const roundType = generateRoundTypeFromEthleteRoundType(currentItem.round.type, tournamentMode);
+        const isLowerBracket = roundType === DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE.LOWER_BRACKET;
+        const bracketRound = {
+            type: roundType,
+            id: currentItem.round.id,
+            index: isLowerBracket ? currentLowerBracketIndex : currentUpperBracketIndex,
+            data: currentItem.round,
+            position: currentItem.round.number,
+            name: currentItem.round.name || currentItem.round.type,
+            matchCount: currentItem.matches.length,
+            matches: new Map(),
+        };
+        bracketData.rounds.set(currentItem.round.id, bracketRound);
+        for (const [matchIndex, match] of currentItem.matches.entries()) {
+            if (bracketData.matches.has(match.id)) {
+                throw new Error(`Match with id ${match.id} already exists in the bracket data.`);
+            }
+            const bracketMatch = {
+                id: match.id,
+                indexInRound: matchIndex,
+                position: (matchIndex + 1),
+                data: match,
+                round: bracketRound,
+                home: match.home?.id || null,
+                away: match.away?.id || null,
+                winner: match.winningSide,
+                status: match.status === 'published' ? 'completed' : 'pending',
+            };
+            bracketData.matches.set(match.id, bracketMatch);
+            bracketRound.matches.set(match.id, bracketMatch);
+            const participants = [match.home, match.away];
+            for (const participant of participants) {
+                if (!participant)
+                    continue;
+                const participantId = participant.id;
+                if (!bracketData.participants.has(participantId)) {
+                    bracketData.participants.set(participantId, {
+                        id: participantId,
+                        name: participant.name || 'Unknown',
+                        matches: new Map(),
+                    });
+                }
+                const participantData = bracketData.participants.get(participantId);
+                if (!participantData.matches.has(match.id)) {
+                    participantData.matches.set(match.id, {
+                        side: match.home?.id === participantId ? 'home' : 'away',
+                        bracketMatch,
+                    });
+                }
+            }
+        }
+        if (isLowerBracket) {
+            currentLowerBracketIndex++;
+        }
+        else {
+            currentUpperBracketIndex++;
+        }
+    }
+    return bracketData;
+};
+const generateMatchPositionMaps = (bracketData) => {
+    const matchPositionMaps = new Map();
+    for (const round of bracketData.rounds.values()) {
+        const matchMap = new Map([...round.matches.values()].map((m) => [m.position, m]));
+        matchPositionMaps.set(round.id, matchMap);
+    }
+    return matchPositionMaps;
+};
+const generateBracketRoundTypeMap = (bracketData) => {
+    const roundAmountMap = new Map();
+    for (const round of bracketData.rounds.values()) {
+        if (!roundAmountMap.has(round.type)) {
+            roundAmountMap.set(round.type, new Map([[round.id, round]]));
+        }
+        else {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            roundAmountMap.set(round.type, roundAmountMap.get(round.type).set(round.id, round));
+        }
+    }
+    return roundAmountMap;
+};
+const UPPER_LOOP_ORDER = [
+    SINGLE_ELIMINATION_BRACKET_ROUND_TYPE.SINGLE_ELIMINATION_BRACKET,
+    DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE.UPPER_BRACKET,
+    SWISS_BRACKET_ROUND_TYPE.SWISS,
+    GROUP_BRACKET_ROUND_TYPE.GROUP,
+    COMMON_BRACKET_ROUND_TYPE.FINAL,
+    DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE.REVERSE_FINAL,
+    COMMON_BRACKET_ROUND_TYPE.THIRD_PLACE,
+];
+const LOWER_LOOP_ORDER = [DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE.LOWER_BRACKET];
+const generateRoundRelations = (bracketData) => {
+    const roundRelations = new Map();
+    const sortedRoundsByType = new Map();
+    for (const round of bracketData.rounds.values()) {
+        if (!sortedRoundsByType.has(round.type)) {
+            sortedRoundsByType.set(round.type, [round]);
+        }
+        else {
+            sortedRoundsByType.get(round.type)?.push(round);
+        }
+    }
+    for (const rounds of sortedRoundsByType.values()) {
+        if (rounds.length === 1)
+            continue;
+        rounds.sort((a, b) => a.position - b.position);
+    }
+    const sortedUpperRounds = UPPER_LOOP_ORDER.map((t) => sortedRoundsByType.get(t))
+        .filter((r) => !!r)
+        .flat();
+    const sortedLowerRounds = LOWER_LOOP_ORDER.map((t) => sortedRoundsByType.get(t))
+        .filter((r) => !!r)
+        .flat();
+    const firstUpperRound = sortedUpperRounds[0] || null;
+    const firstLowerRound = sortedLowerRounds[0] || null;
+    if (!firstUpperRound)
+        throw new Error('firstUpperRound is null');
+    const hasLowerRounds = sortedLowerRounds.length > 0;
+    const lastLowerRound = sortedLowerRounds[sortedLowerRounds.length - 1] || null;
+    for (const [currentUpperRoundIndex, currentUpperRound] of sortedUpperRounds.entries()) {
+        const previousUpperRound = sortedUpperRounds[currentUpperRoundIndex - 1] || null;
+        const nextUpperRound = sortedUpperRounds[currentUpperRoundIndex + 1] || null;
+        const currentLowerRound = sortedLowerRounds[currentUpperRoundIndex] || null;
+        const previousLowerRound = sortedLowerRounds[currentUpperRoundIndex - 1] || null;
+        const nextLowerRound = sortedLowerRounds[currentUpperRoundIndex + 1] || null;
+        const isFirstRound = currentUpperRoundIndex === 0;
+        const isLastUpperRound = currentUpperRoundIndex === sortedUpperRounds.length - 1;
+        const isFinal = currentUpperRound.type === COMMON_BRACKET_ROUND_TYPE.FINAL;
+        if (isFinal && hasLowerRounds) {
+            // two to one relation
+            if (!lastLowerRound || !currentLowerRound || !previousUpperRound)
+                throw new Error('lastLowerRound or currentLowerRound or previousUpperRound is null');
+            // in a sync double elimination bracket, the final round has the same index as the last lower round
+            // in an async one, there is always one more round in the lower bracket since we only display a section of the whole tournament
+            const isAsyncBracket = currentLowerRound.id !== lastLowerRound.id;
+            const finalLowerRound = isAsyncBracket ? nextLowerRound : currentLowerRound;
+            if (!finalLowerRound)
+                throw new Error('finalLowerRound is null');
+            if (!firstLowerRound)
+                throw new Error('firstLowerRound is null');
+            if (finalLowerRound.id !== lastLowerRound.id)
+                throw new Error('finalLowerRound is not the last lower round');
+            // if we have a reverse final
+            if (nextUpperRound) {
+                // for the final
+                roundRelations.set(currentUpperRound.id, {
+                    type: 'two-to-one',
+                    previousUpperRound: previousUpperRound,
+                    previousLowerRound: finalLowerRound,
+                    nextRound: nextUpperRound,
+                    currentRound: currentUpperRound,
+                    nextRoundMatchFactor: nextUpperRound.matchCount / currentUpperRound.matchCount,
+                    previousUpperRoundMatchFactor: previousUpperRound.matchCount / currentUpperRound.matchCount,
+                    previousLowerRoundMatchFactor: finalLowerRound.matchCount / currentUpperRound.matchCount,
+                    upperRootRoundMatchFactor: firstUpperRound.matchCount / currentUpperRound.matchCount,
+                    lowerRootRoundMatchFactor: firstLowerRound.matchCount / currentUpperRound.matchCount,
+                });
+            }
+            else {
+                // no reverse final means the final is the last round
+                // for the final
+                roundRelations.set(currentUpperRound.id, {
+                    type: 'two-to-nothing',
+                    previousUpperRound: previousUpperRound,
+                    previousLowerRound: finalLowerRound,
+                    currentRound: currentUpperRound,
+                    previousLowerRoundMatchFactor: finalLowerRound.matchCount / currentUpperRound.matchCount,
+                    previousUpperRoundMatchFactor: previousUpperRound.matchCount / currentUpperRound.matchCount,
+                    lowerRootRoundMatchFactor: firstLowerRound.matchCount / currentUpperRound.matchCount,
+                    upperRootRoundMatchFactor: firstUpperRound.matchCount / currentUpperRound.matchCount,
+                });
+            }
+            if (isAsyncBracket) {
+                // if this is an async bracket, we need to set the relations for the 2 last lower rounds since they will be skipped by the default one to one logic
+                const preFinalLowerRound = sortedLowerRounds[sortedLowerRounds.length - 2] || null;
+                const prePreFinalLowerRound = sortedLowerRounds[sortedLowerRounds.length - 3] || null;
+                if (!preFinalLowerRound)
+                    throw new Error('preFinalLowerRound is null');
+                if (!firstLowerRound)
+                    throw new Error('firstLowerRound is null');
+                // for the last lower round
+                roundRelations.set(finalLowerRound.id, {
+                    type: 'one-to-one',
+                    previousRound: preFinalLowerRound,
+                    nextRound: currentUpperRound,
+                    currentRound: finalLowerRound,
+                    nextRoundMatchFactor: currentUpperRound.matchCount / finalLowerRound.matchCount,
+                    previousRoundMatchFactor: preFinalLowerRound.matchCount / finalLowerRound.matchCount,
+                    rootRoundMatchFactor: firstLowerRound.matchCount / finalLowerRound.matchCount,
+                });
+                if (prePreFinalLowerRound) {
+                    // for the pre final lower round
+                    roundRelations.set(preFinalLowerRound.id, {
+                        type: 'one-to-one',
+                        previousRound: prePreFinalLowerRound,
+                        nextRound: finalLowerRound,
+                        currentRound: preFinalLowerRound,
+                        nextRoundMatchFactor: finalLowerRound.matchCount / preFinalLowerRound.matchCount,
+                        previousRoundMatchFactor: prePreFinalLowerRound.matchCount / preFinalLowerRound.matchCount,
+                        rootRoundMatchFactor: firstLowerRound.matchCount / preFinalLowerRound.matchCount,
+                    });
+                }
+                else {
+                    // for the first lower round
+                    roundRelations.set(preFinalLowerRound.id, {
+                        type: 'nothing-to-one',
+                        nextRound: finalLowerRound,
+                        currentRound: preFinalLowerRound,
+                        nextRoundMatchFactor: finalLowerRound.matchCount / preFinalLowerRound.matchCount,
+                    });
+                }
+            }
+            else {
+                // this is a sync bracket, we only need to set the relation for the last lower round
+                if (!previousLowerRound)
+                    throw new Error('previousLowerRound is null');
+                if (!firstLowerRound)
+                    throw new Error('firstLowerRound is null');
+                // for the last lower round
+                roundRelations.set(finalLowerRound.id, {
+                    type: 'one-to-one',
+                    previousRound: previousLowerRound,
+                    nextRound: currentUpperRound,
+                    currentRound: finalLowerRound,
+                    nextRoundMatchFactor: currentUpperRound.matchCount / finalLowerRound.matchCount,
+                    previousRoundMatchFactor: previousLowerRound.matchCount / finalLowerRound.matchCount,
+                    rootRoundMatchFactor: firstLowerRound.matchCount / finalLowerRound.matchCount,
+                });
+            }
+        }
+        else if (isLastUpperRound) {
+            // one to nothing relation
+            if (!previousUpperRound)
+                throw new Error('previousUpperRound is null');
+            roundRelations.set(currentUpperRound.id, {
+                type: 'one-to-nothing',
+                previousRound: previousUpperRound,
+                currentRound: currentUpperRound,
+                previousRoundMatchFactor: previousUpperRound.matchCount / currentUpperRound.matchCount,
+                rootRoundMatchFactor: firstUpperRound.matchCount / currentUpperRound.matchCount,
+            });
+        }
+        else if (isFirstRound) {
+            // nothing to one relation
+            if (!nextUpperRound)
+                throw new Error('nextUpperRound is null');
+            roundRelations.set(currentUpperRound.id, {
+                type: 'nothing-to-one',
+                nextRound: nextUpperRound,
+                currentRound: currentUpperRound,
+                nextRoundMatchFactor: nextUpperRound.matchCount / currentUpperRound.matchCount,
+            });
+            if (currentLowerRound) {
+                if (!nextLowerRound)
+                    throw new Error('nextLowerRound is null');
+                roundRelations.set(currentLowerRound.id, {
+                    type: 'nothing-to-one',
+                    nextRound: nextLowerRound,
+                    currentRound: currentLowerRound,
+                    nextRoundMatchFactor: nextLowerRound.matchCount / currentLowerRound.matchCount,
+                });
+            }
+        }
+        else {
+            // one to one relation
+            if (!previousUpperRound)
+                throw new Error('previousUpperRound is null');
+            if (!nextUpperRound)
+                throw new Error('nextUpperRound is null');
+            roundRelations.set(currentUpperRound.id, {
+                type: 'one-to-one',
+                previousRound: previousUpperRound,
+                nextRound: nextUpperRound,
+                currentRound: currentUpperRound,
+                nextRoundMatchFactor: nextUpperRound.matchCount / currentUpperRound.matchCount,
+                previousRoundMatchFactor: previousUpperRound.matchCount / currentUpperRound.matchCount,
+                rootRoundMatchFactor: firstUpperRound.matchCount / currentUpperRound.matchCount,
+            });
+            // we only want to set lower rounds here until the special merging point of the final.
+            // lower bracket rounds after and including the final will be set in the final round block
+            if (currentLowerRound && currentUpperRound.type === DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE.UPPER_BRACKET) {
+                if (!previousLowerRound)
+                    throw new Error('previousLowerRound is null');
+                if (!nextLowerRound)
+                    throw new Error('nextLowerRound is null');
+                if (!firstLowerRound)
+                    throw new Error('firstLowerRound is null');
+                roundRelations.set(currentLowerRound.id, {
+                    type: 'one-to-one',
+                    previousRound: previousLowerRound,
+                    nextRound: nextLowerRound,
+                    currentRound: currentLowerRound,
+                    nextRoundMatchFactor: nextLowerRound.matchCount / currentLowerRound.matchCount,
+                    previousRoundMatchFactor: previousLowerRound.matchCount / currentLowerRound.matchCount,
+                    rootRoundMatchFactor: firstLowerRound.matchCount / currentLowerRound.matchCount,
+                });
+            }
+        }
+    }
+    return roundRelations;
+};
+const generateMatchRelations = (bracketData, roundRelations, matchPositionMaps) => {
+    const matchRelations = new Map();
+    for (const match of bracketData.matches.values()) {
+        const currentRelation = roundRelations.get(match.round.id);
+        if (!currentRelation)
+            throw new Error('Match round not found');
+        const { nextRoundMatchPosition, previousLowerRoundMatchPosition, previousUpperRoundMatchPosition } = generateMatchRelationPositions(currentRelation, match);
+        switch (currentRelation.type) {
+            case 'nothing-to-one': {
+                const nextMatch = matchPositionMaps.get(currentRelation.nextRound.id)?.get(nextRoundMatchPosition);
+                if (!nextMatch)
+                    throw new Error('Next round match not found');
+                // means left is nothing. right is one
+                matchRelations.set(match.id, {
+                    type: 'nothing-to-one',
+                    currentMatch: match,
+                    currentRound: currentRelation.currentRound,
+                    nextRound: currentRelation.nextRound,
+                    nextMatch,
+                });
+                break;
+            }
+            case 'one-to-nothing': {
+                const previousUpperMatch = matchPositionMaps
+                    .get(currentRelation.previousRound.id)
+                    ?.get(previousUpperRoundMatchPosition);
+                const previousLowerMatch = matchPositionMaps
+                    .get(currentRelation.previousRound.id)
+                    ?.get(previousLowerRoundMatchPosition);
+                if (!previousUpperMatch)
+                    throw new Error('Previous round match not found');
+                if (previousUpperRoundMatchPosition !== previousLowerRoundMatchPosition) {
+                    // means left is two. right is one
+                    if (!previousLowerMatch)
+                        throw new Error('Previous lower round match not found');
+                    matchRelations.set(match.id, {
+                        type: 'two-to-nothing',
+                        currentMatch: match,
+                        currentRound: currentRelation.currentRound,
+                        previousUpperMatch,
+                        previousUpperRound: currentRelation.previousRound,
+                        previousLowerMatch,
+                        previousLowerRound: currentRelation.previousRound,
+                    });
+                }
+                else {
+                    // means left is one. right is nothing
+                    matchRelations.set(match.id, {
+                        type: 'one-to-nothing',
+                        currentMatch: match,
+                        currentRound: currentRelation.currentRound,
+                        previousMatch: previousUpperMatch,
+                        previousRound: currentRelation.previousRound,
+                    });
+                }
+                break;
+            }
+            case 'one-to-one': {
+                const nextMatch = matchPositionMaps.get(currentRelation.nextRound.id)?.get(nextRoundMatchPosition);
+                const previousUpperMatch = matchPositionMaps
+                    .get(currentRelation.previousRound.id)
+                    ?.get(previousUpperRoundMatchPosition);
+                const previousLowerMatch = matchPositionMaps
+                    .get(currentRelation.previousRound.id)
+                    ?.get(previousLowerRoundMatchPosition);
+                if (!nextMatch)
+                    throw new Error('Next round match not found');
+                if (!previousUpperMatch)
+                    throw new Error(`Previous upper round match not found`);
+                if (!previousLowerMatch)
+                    throw new Error('Previous lower round match not found');
+                // can be either one to one or two to one
+                const isLeftOne = previousUpperRoundMatchPosition === previousLowerRoundMatchPosition;
+                if (isLeftOne) {
+                    // one-to-one
+                    matchRelations.set(match.id, {
+                        type: 'one-to-one',
+                        currentMatch: match,
+                        currentRound: currentRelation.currentRound,
+                        previousMatch: previousUpperMatch,
+                        previousRound: currentRelation.previousRound,
+                        nextMatch,
+                        nextRound: currentRelation.nextRound,
+                    });
+                }
+                else {
+                    // two-to-one
+                    matchRelations.set(match.id, {
+                        type: 'two-to-one',
+                        currentMatch: match,
+                        currentRound: currentRelation.currentRound,
+                        previousUpperMatch,
+                        previousUpperRound: currentRelation.previousRound,
+                        previousLowerMatch,
+                        previousLowerRound: currentRelation.previousRound,
+                        nextMatch,
+                        nextRound: currentRelation.nextRound,
+                    });
+                }
+                break;
+            }
+            case 'two-to-one': {
+                const nextMatch = matchPositionMaps.get(currentRelation.nextRound.id)?.get(nextRoundMatchPosition);
+                const previousUpperMatch = matchPositionMaps
+                    .get(currentRelation.previousUpperRound.id)
+                    ?.get(previousUpperRoundMatchPosition);
+                const previousLowerMatch = matchPositionMaps
+                    .get(currentRelation.previousLowerRound.id)
+                    ?.get(previousLowerRoundMatchPosition);
+                if (!nextMatch)
+                    throw new Error('Next round match not found');
+                if (!previousUpperMatch)
+                    throw new Error(`Previous upper round match not found`);
+                if (!previousLowerMatch)
+                    throw new Error('Previous lower round match not found');
+                matchRelations.set(match.id, {
+                    type: 'two-to-one',
+                    currentMatch: match,
+                    currentRound: currentRelation.currentRound,
+                    previousUpperMatch,
+                    previousUpperRound: currentRelation.previousUpperRound,
+                    previousLowerMatch,
+                    previousLowerRound: currentRelation.previousLowerRound,
+                    nextMatch,
+                    nextRound: currentRelation.nextRound,
+                });
+                break;
+            }
+            case 'two-to-nothing': {
+                const previousUpperMatch = matchPositionMaps
+                    .get(currentRelation.previousUpperRound.id)
+                    ?.get(previousUpperRoundMatchPosition);
+                const previousLowerMatch = matchPositionMaps
+                    .get(currentRelation.previousUpperRound.id)
+                    ?.get(previousLowerRoundMatchPosition);
+                if (!previousUpperMatch)
+                    throw new Error(`Previous upper round match not found`);
+                if (!previousLowerMatch)
+                    throw new Error('Previous lower round match not found');
+                matchRelations.set(match.id, {
+                    type: 'two-to-nothing',
+                    currentMatch: match,
+                    currentRound: currentRelation.currentRound,
+                    previousUpperMatch,
+                    previousUpperRound: currentRelation.previousUpperRound,
+                    previousLowerMatch,
+                    previousLowerRound: currentRelation.previousUpperRound,
+                });
+                break;
+            }
+        }
+    }
+    return matchRelations;
+};
+const generateMatchRelationPositions = (currentRelation, match) => {
+    switch (currentRelation.type) {
+        case 'nothing-to-one': {
+            return {
+                nextRoundMatchPosition: generateMatchPosition(match, currentRelation.nextRoundMatchFactor),
+                previousUpperRoundMatchPosition: FALLBACK_MATCH_POSITION,
+                previousLowerRoundMatchPosition: FALLBACK_MATCH_POSITION,
+            };
+        }
+        case 'one-to-nothing': {
+            const previousRoundHasDoubleTheMatchCount = currentRelation.previousRoundMatchFactor === 2;
+            const doubleUpperMatchCountShift = previousRoundHasDoubleTheMatchCount ? 1 : 0;
+            return {
+                nextRoundMatchPosition: FALLBACK_MATCH_POSITION,
+                previousUpperRoundMatchPosition: (generateMatchPosition(match, currentRelation.previousRoundMatchFactor) -
+                    doubleUpperMatchCountShift),
+                previousLowerRoundMatchPosition: generateMatchPosition(match, currentRelation.previousRoundMatchFactor),
+            };
+        }
+        case 'one-to-one': {
+            const previousRoundHasDoubleTheMatchCount = currentRelation.previousRoundMatchFactor === 2;
+            const doubleUpperMatchCountShift = previousRoundHasDoubleTheMatchCount ? 1 : 0;
+            return {
+                nextRoundMatchPosition: generateMatchPosition(match, currentRelation.nextRoundMatchFactor),
+                previousUpperRoundMatchPosition: (generateMatchPosition(match, currentRelation.previousRoundMatchFactor) -
+                    doubleUpperMatchCountShift),
+                previousLowerRoundMatchPosition: generateMatchPosition(match, currentRelation.previousRoundMatchFactor),
+            };
+        }
+        case 'two-to-one': {
+            return {
+                nextRoundMatchPosition: generateMatchPosition(match, currentRelation.nextRoundMatchFactor),
+                previousUpperRoundMatchPosition: generateMatchPosition(match, currentRelation.previousUpperRoundMatchFactor),
+                previousLowerRoundMatchPosition: generateMatchPosition(match, currentRelation.previousLowerRoundMatchFactor),
+            };
+        }
+        case 'two-to-nothing': {
+            return {
+                nextRoundMatchPosition: FALLBACK_MATCH_POSITION,
+                previousUpperRoundMatchPosition: generateMatchPosition(match, currentRelation.previousUpperRoundMatchFactor),
+                previousLowerRoundMatchPosition: generateMatchPosition(match, currentRelation.previousLowerRoundMatchFactor),
+            };
+        }
+    }
+};
+const generateMatchPosition = (match, factor) => {
+    return Math.ceil(match.position * factor);
+};
+const logRoundRelations = (roundRelations, bracketData) => {
+    for (const [roundId, relation] of roundRelations.entries()) {
+        const round = bracketData.rounds.get(roundId);
+        if (!round) {
+            console.error(`Round with id ${roundId} not found in bracket data. The bracket will be malformed.`);
+            continue;
+        }
+        switch (relation.type) {
+            case 'nothing-to-one':
+                console.log(`START: ${round.name} -> ${relation.nextRound.name} (F: ${relation.nextRoundMatchFactor})`);
+                break;
+            case 'one-to-nothing':
+                console.log(`${relation.previousRound.name} (F: ${relation.previousRoundMatchFactor}) <- ENDING: ${round.name}`);
+                break;
+            case 'one-to-one':
+                console.log(`${relation.previousRound.name} (F: ${relation.previousRoundMatchFactor}) <- ${round.name} -> ${relation.nextRound.name} (F: ${relation.nextRoundMatchFactor})`);
+                break;
+            case 'two-to-one':
+                console.log(`MERGER: ${relation.previousUpperRound.name} (F: ${relation.previousUpperRoundMatchFactor}) AND ${relation.previousLowerRound.name} (F: ${relation.previousLowerRoundMatchFactor}) <- ${round.name} -> ${relation.nextRound.name} (F: ${relation.nextRoundMatchFactor})`);
+                break;
+            case 'two-to-nothing':
+                console.log(`MERGER: ${relation.previousUpperRound.name} (F: ${relation.previousUpperRoundMatchFactor}) AND ${relation.previousLowerRound.name} (F: ${relation.previousLowerRoundMatchFactor}) <- ENDING: ${round.name}`);
+                break;
+        }
+    }
+};
+const generateMatchParticipantMap = (bracketData) => {
+    const matchParticipantMap = new Map();
+    const hasElimination = bracketData.mode === TOURNAMENT_MODE.SINGLE_ELIMINATION ||
+        bracketData.mode === TOURNAMENT_MODE.DOUBLE_ELIMINATION ||
+        bracketData.mode === TOURNAMENT_MODE.SWISS_WITH_ELIMINATION;
+    for (const participant of bracketData.participants.values()) {
+        let winsTilNow = 0;
+        let lossesTilNow = 0;
+        let tiesTilNow = 0;
+        for (const matchParticipantMatch of participant.matches.values()) {
+            const isWinner = matchParticipantMatch.bracketMatch.winner === matchParticipantMatch.side;
+            const isLooser = matchParticipantMatch.bracketMatch.winner &&
+                matchParticipantMatch.bracketMatch.winner !== matchParticipantMatch.side;
+            const isTie = matchParticipantMatch.bracketMatch.status === 'completed' && !matchParticipantMatch.bracketMatch.winner;
+            if (isWinner) {
+                winsTilNow++;
+            }
+            else if (isLooser) {
+                lossesTilNow++;
+            }
+            else if (isTie) {
+                tiesTilNow++;
+            }
+            let isEliminated = false;
+            let isEliminationMatch = false;
+            if (hasElimination) {
+                // TODO: Implement elimination logic
+                // Means the current match is loss and it's the last match of the participant
+                isEliminated = false;
+                // Always true for single elimination, never for e.g. groups, depends on the round for double elimination, depends on the loss count for swiss with elimination
+                isEliminationMatch = false;
+            }
+            // TODO: Implement round logic
+            // true if its the first round of the bracket
+            const isFirstRound = false;
+            // true if its the last round of the bracket (eg. final for single elimination)
+            const isLastRound = false;
+            const participantMatchData = {
+                bracketMatch: matchParticipantMatch.bracketMatch,
+                result: isWinner ? 'win' : isLooser ? 'loss' : isTie ? 'tie' : null,
+                isEliminated,
+                isEliminationMatch,
+                isFirstRound,
+                isLastRound,
+                tieCount: tiesTilNow,
+                winCount: winsTilNow,
+                lossCount: lossesTilNow,
+            };
+            if (!matchParticipantMap.has(participant.id)) {
+                matchParticipantMap.set(participant.id, {
+                    id: participant.id,
+                    name: participant.name,
+                    matches: new Map(),
+                });
+            }
+            const participantData = matchParticipantMap.get(participant.id);
+            participantData.matches.set(matchParticipantMatch.bracketMatch.id, participantMatchData);
+        }
+    }
+    return matchParticipantMap;
+};
+const factorialCache = new Map();
+const getAvailableSwissGroupsForRound = (roundNumber, totalMatchesInRound) => {
+    const ADVANCE_WINS = 3;
+    const ELIMINATE_LOSSES = 3;
+    // Cache factorial calculations
+    const getFactorial = (n) => {
+        if (n <= 1)
+            return 1;
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        if (factorialCache.has(n))
+            return factorialCache.get(n);
+        const result = n * getFactorial(n - 1);
+        factorialCache.set(n, result);
+        return result;
+    };
+    // Pre-calculate roundFactorial
+    const roundFact = getFactorial(roundNumber);
+    let totalCombinations = 0;
+    const validGroups = [];
+    // Single loop to gather valid groups and total combinations
+    for (let wins = roundNumber; wins >= 0; wins--) {
+        const losses = roundNumber - wins;
+        const remainingGames = ADVANCE_WINS + ELIMINATE_LOSSES - (wins + losses) - 1;
+        const notYetEliminated = losses < ELIMINATE_LOSSES;
+        const canStillAdvance = wins < ADVANCE_WINS && remainingGames >= 0;
+        if (!canStillAdvance || !notYetEliminated)
+            continue;
+        const combinations = roundFact / (getFactorial(wins) * getFactorial(losses));
+        totalCombinations += combinations;
+        validGroups.push({ wins, losses, combinations });
+    }
+    // Create final groups with calculated proportions
+    return validGroups.map(({ wins, losses, combinations }) => ({
+        id: `${wins}-${losses}`,
+        name: `${wins}-${losses}`,
+        matchesInGroup: Math.round((combinations / totalCombinations) * totalMatchesInRound),
+    }));
+};
+const generateBracketRoundSwissGroupMaps = (bracketData, matchParticipantMap) => {
+    if (bracketData.mode !== TOURNAMENT_MODE.SWISS_WITH_ELIMINATION) {
+        return null;
+    }
+    const roundsWithSwissGroups = new Map();
+    let roundNumber = 0;
+    for (const bracketRound of bracketData.rounds.values()) {
+        const availableGroups = getAvailableSwissGroupsForRound(roundNumber, bracketRound.matchCount);
+        const roundSwissData = {
+            groups: new Map(),
+        };
+        for (const group of availableGroups) {
+            const subGroup = {
+                id: group.id,
+                name: group.name,
+                matches: new Map(),
+                allowedMatchCount: group.matchesInGroup,
+            };
+            roundSwissData.groups.set(group.id, subGroup);
+        }
+        const emptyMatchIds = [];
+        for (const match of bracketRound.matches.values()) {
+            const participantHome = match.home ? (matchParticipantMap.get(match.home) ?? null) : null;
+            const participantAway = match.away ? (matchParticipantMap.get(match.away) ?? null) : null;
+            const anyParticipant = participantHome || participantAway;
+            if (!anyParticipant) {
+                emptyMatchIds.push(match.id);
+                continue;
+            }
+            const matchParticipantMatch = anyParticipant.matches.get(match.id);
+            if (!matchParticipantMatch)
+                throw new Error('Match participant match not found');
+            const wins = matchParticipantMatch.winCount;
+            const losses = matchParticipantMatch.lossCount;
+            const group = roundSwissData.groups.get(`${wins}-${losses}`);
+            if (!group)
+                throw new Error('Group not found for match: ' + match.id);
+            group.matches.set(match.id, match);
+        }
+        for (const emptyMatchId of emptyMatchIds) {
+            const match = bracketRound.matches.get(emptyMatchId);
+            if (!match)
+                throw new Error('Empty match not found');
+            let groupFound = false;
+            for (const group of roundSwissData.groups.values()) {
+                if (group.matches.size < group.allowedMatchCount) {
+                    group.matches.set(match.id, match);
+                    groupFound = true;
+                    break;
+                }
+            }
+            if (!groupFound) {
+                throw new Error('No group found for empty match');
+            }
+        }
+        roundNumber++;
+    }
+    return roundsWithSwissGroups;
+};
+
+const LINE_WIDTH = 1;
+const path = (d) => `<path d="${d}" stroke="red" fill="none" stroke-width="${LINE_WIDTH}" />`;
+const drawMan = (items, roundRelations, dimensions) => {
+    const { columnWidth, matchHeight, rowGap, columnGap, roundHeaderHeight, gridDefinitions } = dimensions;
+    const roundHeaderRowGap = roundHeaderHeight ? rowGap : 0;
+    const baseOffsetY = roundHeaderHeight + roundHeaderRowGap;
+    const columnGapCenter = columnGap / 2;
+    const totalHeight = (gridDefinitions.rowCount - 1) * matchHeight + (gridDefinitions.rowCount - 1) * rowGap + roundHeaderHeight; // TODO: This is not correct in double elimination
+    const svgParts = [];
+    // a nothing to one draws nothing
+    // a one to nothing draws nothing
+    // a one to one draws a line
+    // a one to two draws a line that splits into in the middle
+    // a two to one draws two lines that merge into one in the middle
+    // WE ONLY EVER DRAW THE LEFT SIDE (on-to, nothing-to, two-to)
+    for (const round of items.values()) {
+        const rows = round.roundRelation.currentRound.matchCount;
+        const rowGaps = rows - 1;
+        const rowHeight = (totalHeight - baseOffsetY) / rows - rowGaps * rowGap;
+        const rowWhitespace = (rowHeight - matchHeight) / 2;
+        const matchHeightOffset = rowWhitespace + matchHeight / 2; // the vertical middle of a match in this row
+        for (const item of round.items.values()) {
+            if (item.type === 'round')
+                continue; // we don't draw lines for round headers
+            switch (item.matchRelation.type) {
+                case 'nothing-to-one': {
+                    continue;
+                }
+                case 'one-to-nothing':
+                case 'one-to-one': {
+                    // draw a straight line
+                    const previousRound = items.get(item.matchRelation.previousRound.id);
+                    if (!previousRound)
+                        throw new Error('Previous round or match is missing');
+                    const previousMatch = previousRound.items.get(item.matchRelation.previousMatch.id);
+                    if (!previousMatch || previousMatch.type !== 'match')
+                        throw new Error('Previous round or match is missing');
+                    const previousRoundRows = previousRound.roundRelation.currentRound.matchCount;
+                    const previousRoundRowGaps = previousRoundRows - 1;
+                    const previousRoundRowHeight = (totalHeight - baseOffsetY) / previousRoundRows - previousRoundRowGaps * rowGap;
+                    const previousRoundRowWhitespace = (previousRoundRowHeight - matchHeight) / 2;
+                    const previousRoundMatchHeightOffset = previousRoundRowWhitespace + matchHeight / 2;
+                    const fromX = previousRound.columnStart * columnWidth + (round.columnStart - 2) * columnGap;
+                    const toX = (round.columnStart - 1) * columnWidth + (round.columnStart - 1) * columnGap;
+                    const fromY = previousMatch.matchRelation.currentMatch.indexInRound * previousRoundRowWhitespace +
+                        previousMatch.matchRelation.currentMatch.indexInRound * rowGap +
+                        baseOffsetY +
+                        previousRoundMatchHeightOffset;
+                    const toY = item.matchRelation.currentMatch.indexInRound * rowWhitespace +
+                        item.matchRelation.currentMatch.indexInRound * rowGap +
+                        baseOffsetY +
+                        matchHeightOffset;
+                    svgParts.push(path(`M ${fromX} ${fromY} L ${toX} ${toY}`));
+                    break;
+                }
+                case 'two-to-nothing':
+                case 'two-to-one': {
+                    // draw two lines that merge into one in the middle
+                    break;
+                }
+            }
+        }
+    }
+    return svgParts.join(' /n');
+};
+
+const generateColumnCount = (bracketData, roundTypeMap) => {
+    const thirdPlaceRoundSize = roundTypeMap.get(COMMON_BRACKET_ROUND_TYPE.THIRD_PLACE)?.size || 0;
+    switch (bracketData.mode) {
+        case TOURNAMENT_MODE.DOUBLE_ELIMINATION: {
+            const upperBracketSize = roundTypeMap.get(DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE.UPPER_BRACKET)?.size || 0;
+            const lowerBracketSize = roundTypeMap.get(DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE.LOWER_BRACKET)?.size || 0;
+            // the total columns are the bigger number of winner bracket rounds vs looser bracket rounds + all other rounds excluding third place
+            return bracketData.rounds.size - thirdPlaceRoundSize + Math.max(upperBracketSize, lowerBracketSize);
+        }
+        default: {
+            // the total columns are the amount of rounds excluding third place
+            return bracketData.rounds.size - thirdPlaceRoundSize;
+        }
+    }
+};
+const generateRowCount = (bracketData, roundTypeMap, options) => {
+    switch (bracketData.mode) {
+        case TOURNAMENT_MODE.DOUBLE_ELIMINATION: {
+            const upperBracketSize = roundTypeMap.get(DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE.UPPER_BRACKET)?.values().next()
+                .value?.matchCount;
+            const lowerBracketSize = roundTypeMap.get(DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE.LOWER_BRACKET)?.values().next()
+                .value?.matchCount;
+            const roundHeadersCount = options.includeRoundHeaders ? 2 : 0;
+            if (upperBracketSize === undefined || lowerBracketSize === undefined) {
+                throw new Error('Upper or lower bracket size is undefined');
+            }
+            // the total rows the amount of matches in the first upper bracket round + first lower bracket round + if true, the round header row for both
+            return upperBracketSize + lowerBracketSize + roundHeadersCount;
+        }
+        default: {
+            const firstRoundSize = bracketData.rounds.values().next().value?.matchCount;
+            const roundHeadersCount = options.includeRoundHeaders ? 1 : 0;
+            if (firstRoundSize === undefined) {
+                throw new Error('First round size is undefined');
+            }
+            // the total rows are the amount of matches in the first round + if true, the round header row
+            return firstRoundSize + roundHeadersCount;
+        }
+    }
+};
+const generateBracketGridDefinitions = (bracketData, roundTypeMap, options) => {
+    const columnCount = generateColumnCount(bracketData, roundTypeMap);
+    const rowCount = generateRowCount(bracketData, roundTypeMap, options);
+    return { columnCount, rowCount };
+};
+
+class NewBracketDefaultMatchComponent {
+    constructor() {
+        this.bracketRound = input.required();
+        this.bracketMatch = input.required();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.11", ngImport: i0, type: NewBracketDefaultMatchComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "18.2.11", type: NewBracketDefaultMatchComponent, isStandalone: true, selector: "et-new-bracket-default-match", inputs: { bracketRound: { classPropertyName: "bracketRound", publicName: "bracketRound", isSignal: true, isRequired: true, transformFunction: null }, bracketMatch: { classPropertyName: "bracketMatch", publicName: "bracketMatch", isSignal: true, isRequired: true, transformFunction: null } }, host: { classAttribute: "et-new-bracket-default-match-host" }, ngImport: i0, template: ` {{ bracketMatch().id }} `, isInline: true, styles: [".et-new-bracket-default-match-host{display:block;padding:8px;border:1px solid yellow;inline-size:250px;block-size:75px;display:flex;justify-content:center;align-items:center;box-sizing:border-box;font-size:12px}\n"], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.11", ngImport: i0, type: NewBracketDefaultMatchComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'et-new-bracket-default-match', template: ` {{ bracketMatch().id }} `, standalone: true, changeDetection: ChangeDetectionStrategy.OnPush, encapsulation: ViewEncapsulation.None, host: {
+                        class: 'et-new-bracket-default-match-host',
+                    }, styles: [".et-new-bracket-default-match-host{display:block;padding:8px;border:1px solid yellow;inline-size:250px;block-size:75px;display:flex;justify-content:center;align-items:center;box-sizing:border-box;font-size:12px}\n"] }]
+        }] });
+
+class NewBracketDefaultRoundHeaderComponent {
+    constructor() {
+        this.bracketRound = input.required();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.11", ngImport: i0, type: NewBracketDefaultRoundHeaderComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "18.2.11", type: NewBracketDefaultRoundHeaderComponent, isStandalone: true, selector: "et-new-bracket-default-round-header", inputs: { bracketRound: { classPropertyName: "bracketRound", publicName: "bracketRound", isSignal: true, isRequired: true, transformFunction: null } }, host: { classAttribute: "et-new-bracket-default-round-header-host" }, ngImport: i0, template: ` {{ bracketRound().name }} `, isInline: true, styles: [".et-new-bracket-default-round-header-host{display:block;padding:8px;border:1px solid green;inline-size:250px;block-size:50px;display:flex;justify-content:center;align-items:center;box-sizing:border-box}\n"], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.11", ngImport: i0, type: NewBracketDefaultRoundHeaderComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'et-new-bracket-default-round-header', template: ` {{ bracketRound().name }} `, standalone: true, changeDetection: ChangeDetectionStrategy.OnPush, encapsulation: ViewEncapsulation.None, host: {
+                        class: 'et-new-bracket-default-round-header-host',
+                    }, styles: [".et-new-bracket-default-round-header-host{display:block;padding:8px;border:1px solid green;inline-size:250px;block-size:50px;display:flex;justify-content:center;align-items:center;box-sizing:border-box}\n"] }]
+        }] });
+
+const generateBracketGridItems = (bracketData, roundTypeMap, swissGroups, roundRelations, matchRelations, options) => {
+    const roundHeaderComponent = options.headerComponent ?? NewBracketDefaultRoundHeaderComponent;
+    const matchComponent = options.matchComponent ?? NewBracketDefaultMatchComponent;
+    const optionsWithDefaults = {
+        ...options,
+        headerComponent: roundHeaderComponent,
+        matchComponent: matchComponent,
+    };
+    switch (bracketData.mode) {
+        case TOURNAMENT_MODE.DOUBLE_ELIMINATION:
+            return generateDoubleEliminationGridPlacements(bracketData, roundTypeMap, roundRelations, matchRelations, optionsWithDefaults);
+        case TOURNAMENT_MODE.SWISS_WITH_ELIMINATION: {
+            if (!swissGroups)
+                throw new Error('Swiss groups are required for swiss with elimination mode');
+            return generateSwissWithEliminationGridPlacements(bracketData, roundTypeMap, swissGroups, roundRelations, matchRelations, optionsWithDefaults);
+        }
+        default:
+            return generateGenericGridPlacements(bracketData, roundTypeMap, roundRelations, matchRelations, optionsWithDefaults);
+    }
+};
+const generateGenericGridPlacements = (bracketData, roundTypeMap, roundRelations, matchRelations, options) => {
+    const gridItems = new Map();
+    const firstRound = bracketData.rounds.values().next().value;
+    if (!firstRound) {
+        throw new Error('First round is missing');
+    }
+    for (const round of bracketData.rounds.values()) {
+        const roundRelation = roundRelations.get(round.id);
+        let currentMatchRow = 1;
+        const columnStart = round.index + 1;
+        const columnEnd = columnStart + 1;
+        if (!roundRelation) {
+            throw new Error('Round relation is missing');
+        }
+        if (roundRelation.type === 'two-to-nothing' || roundRelation.type === 'two-to-one') {
+            throw new Error(`Invalid relation type ${roundRelation.type}`);
+        }
+        const roundItem = {
+            id: round.id,
+            columnStart,
+            columnEnd,
+            roundRelation,
+            items: new Map(),
+        };
+        if (options.includeRoundHeaders) {
+            const roundHeaderItem = {
+                type: 'round',
+                id: round.id,
+                rowStart: currentMatchRow,
+                rowEnd: ++currentMatchRow,
+                component: options.headerComponent,
+                roundRelation,
+                data: {
+                    bracketRound: round,
+                },
+            };
+            roundItem.items.set(round.id, roundHeaderItem);
+        }
+        const rootRoundMatchFactor = roundRelation.type !== 'nothing-to-one' ? roundRelation.rootRoundMatchFactor : null;
+        const matchHeight = rootRoundMatchFactor ? rootRoundMatchFactor : 1;
+        for (const match of round.matches.values()) {
+            const matchRelation = matchRelations.get(match.id);
+            if (!matchRelation) {
+                throw new Error('Match relation is missing');
+            }
+            const baseRow = match.indexInRound * matchHeight;
+            const matchItem = {
+                type: 'match',
+                id: match.id,
+                rowStart: baseRow + currentMatchRow,
+                rowEnd: baseRow + currentMatchRow + matchHeight,
+                component: options.matchComponent,
+                matchRelation,
+                roundRelation,
+                data: {
+                    bracketRound: round,
+                    bracketMatch: match,
+                },
+            };
+            roundItem.items.set(match.id, matchItem);
+        }
+        gridItems.set(round.id, roundItem);
+    }
+    return gridItems;
+};
+const generateDoubleEliminationGridPlacements = (bracketData, roundTypeMap, roundRelations, matchRelations, options) => {
+    const gridItems = new Map();
+    return gridItems;
+};
+const generateSwissWithEliminationGridPlacements = (bracketData, roundTypeMap, swissGroups, roundRelations, matchRelations, options) => {
+    const gridItems = new Map();
+    return gridItems;
+};
+
+class NewBracketComponent {
+    constructor() {
+        this.#domSanitizer = inject(DomSanitizer);
+        this.bracketData = input.required();
+        this.columnWidth = input(250, { transform: numberAttribute });
+        this.matchHeight = input(75, { transform: numberAttribute });
+        this.roundHeaderHeight = input(50, { transform: numberAttribute });
+        this.columnGap = input(60, { transform: numberAttribute });
+        this.rowGap = input(30, { transform: numberAttribute });
+        this.hideRoundHeaders = input(false, { transform: booleanAttribute });
+        this.roundHeaderComponent = input();
+        this.matchComponent = input();
+        this.roundTypeMap = computed(() => generateBracketRoundTypeMap(this.bracketData()));
+        this.matchParticipantMap = computed(() => generateMatchParticipantMap(this.bracketData()));
+        this.matchPositionsMap = computed(() => generateMatchPositionMaps(this.bracketData()));
+        this.roundRelations = computed(() => generateRoundRelations(this.bracketData()));
+        this.matchRelations = computed(() => generateMatchRelations(this.bracketData(), this.roundRelations(), this.matchPositionsMap()));
+        this.swissGroups = computed(() => generateBracketRoundSwissGroupMaps(this.bracketData(), this.matchParticipantMap()));
+        this.items = computed(() => generateBracketGridItems(this.bracketData(), this.roundTypeMap(), this.swissGroups(), this.roundRelations(), this.matchRelations(), {
+            includeRoundHeaders: !this.hideRoundHeaders(),
+            headerComponent: this.roundHeaderComponent(),
+            matchComponent: this.matchComponent(),
+        }));
+        this.definitions = computed(() => generateBracketGridDefinitions(this.bracketData(), this.roundTypeMap(), {
+            includeRoundHeaders: !this.hideRoundHeaders(),
+        }));
+        this.drawManData = computed(() => this.#domSanitizer.bypassSecurityTrustHtml(drawMan(this.items(), this.roundRelations(), {
+            columnGap: this.columnGap(),
+            columnWidth: this.columnWidth(),
+            matchHeight: this.matchHeight(),
+            roundHeaderHeight: this.hideRoundHeaders() ? 0 : this.roundHeaderHeight(),
+            rowGap: this.rowGap(),
+            gridDefinitions: this.definitions(),
+        })));
+    }
+    #domSanitizer;
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.11", ngImport: i0, type: NewBracketComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.11", type: NewBracketComponent, isStandalone: true, selector: "et-new-bracket", inputs: { bracketData: { classPropertyName: "bracketData", publicName: "bracketData", isSignal: true, isRequired: true, transformFunction: null }, columnWidth: { classPropertyName: "columnWidth", publicName: "columnWidth", isSignal: true, isRequired: false, transformFunction: null }, matchHeight: { classPropertyName: "matchHeight", publicName: "matchHeight", isSignal: true, isRequired: false, transformFunction: null }, roundHeaderHeight: { classPropertyName: "roundHeaderHeight", publicName: "roundHeaderHeight", isSignal: true, isRequired: false, transformFunction: null }, columnGap: { classPropertyName: "columnGap", publicName: "columnGap", isSignal: true, isRequired: false, transformFunction: null }, rowGap: { classPropertyName: "rowGap", publicName: "rowGap", isSignal: true, isRequired: false, transformFunction: null }, hideRoundHeaders: { classPropertyName: "hideRoundHeaders", publicName: "hideRoundHeaders", isSignal: true, isRequired: false, transformFunction: null }, roundHeaderComponent: { classPropertyName: "roundHeaderComponent", publicName: "roundHeaderComponent", isSignal: true, isRequired: false, transformFunction: null }, matchComponent: { classPropertyName: "matchComponent", publicName: "matchComponent", isSignal: true, isRequired: false, transformFunction: null } }, host: { classAttribute: "et-new-bracket-host" }, ngImport: i0, template: "<section\n  [style.--_cw.px]=\"columnWidth()\"\n  [style.--_mh.px]=\"matchHeight()\"\n  [style.--_rhh.px]=\"roundHeaderHeight()\"\n  [style.--_cg.px]=\"columnGap()\"\n  [style.--_rg.px]=\"rowGap()\"\n  [style.--_bcc]=\"definitions().columnCount\"\n  [style.--_brc]=\"definitions().rowCount\"\n  class=\"et-bracket-new\"\n>\n  <svg [innerHTML]=\"drawManData()\" class=\"et-bracket-new-svg\" xmlns=\"http://www.w3.org/2000/svg\" />\n\n  @for (round of items().values(); track round.id) {\n    <ul [style.--_c]=\"round.columnStart + ' / ' + round.columnEnd\" class=\"et-bracket-new-round\">\n      @for (item of round.items.values(); track item.id) {\n        <li [style.--_r]=\"item.rowStart + ' / ' + item.rowEnd\" class=\"et-bracket-new-item\">\n          <ng-container *ngComponentOutlet=\"item.component; inputs: item.data\" />\n        </li>\n      }\n    </ul>\n  }\n</section>\n", styles: [".et-bracket-new{display:grid;gap:var(--_cg);grid-auto-columns:var(--_cw)}.et-bracket-new-round{display:grid;grid-column:var(--_c);grid-row:1;list-style:none;margin:0;padding:0;gap:var(--_rg);grid-template-rows:var(--_rhh);grid-auto-rows:var(--_mh)}.et-bracket-new-item{grid-row:var(--_r);place-self:center}.et-bracket-new-svg{grid-column:1/calc(var(--_bcc) + 1);grid-row:1/2;inline-size:100%;block-size:100%}\n"], dependencies: [{ kind: "directive", type: NgComponentOutlet, selector: "[ngComponentOutlet]", inputs: ["ngComponentOutlet", "ngComponentOutletInputs", "ngComponentOutletInjector", "ngComponentOutletContent", "ngComponentOutletNgModule", "ngComponentOutletNgModuleFactory"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.11", ngImport: i0, type: NewBracketComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'et-new-bracket', standalone: true, changeDetection: ChangeDetectionStrategy.OnPush, encapsulation: ViewEncapsulation.None, host: {
+                        class: 'et-new-bracket-host',
+                    }, imports: [NgComponentOutlet], template: "<section\n  [style.--_cw.px]=\"columnWidth()\"\n  [style.--_mh.px]=\"matchHeight()\"\n  [style.--_rhh.px]=\"roundHeaderHeight()\"\n  [style.--_cg.px]=\"columnGap()\"\n  [style.--_rg.px]=\"rowGap()\"\n  [style.--_bcc]=\"definitions().columnCount\"\n  [style.--_brc]=\"definitions().rowCount\"\n  class=\"et-bracket-new\"\n>\n  <svg [innerHTML]=\"drawManData()\" class=\"et-bracket-new-svg\" xmlns=\"http://www.w3.org/2000/svg\" />\n\n  @for (round of items().values(); track round.id) {\n    <ul [style.--_c]=\"round.columnStart + ' / ' + round.columnEnd\" class=\"et-bracket-new-round\">\n      @for (item of round.items.values(); track item.id) {\n        <li [style.--_r]=\"item.rowStart + ' / ' + item.rowEnd\" class=\"et-bracket-new-item\">\n          <ng-container *ngComponentOutlet=\"item.component; inputs: item.data\" />\n        </li>\n      }\n    </ul>\n  }\n</section>\n", styles: [".et-bracket-new{display:grid;gap:var(--_cg);grid-auto-columns:var(--_cw)}.et-bracket-new-round{display:grid;grid-column:var(--_c);grid-row:1;list-style:none;margin:0;padding:0;gap:var(--_rg);grid-template-rows:var(--_rhh);grid-auto-rows:var(--_mh)}.et-bracket-new-item{grid-row:var(--_r);place-self:center}.et-bracket-new-svg{grid-column:1/calc(var(--_bcc) + 1);grid-row:1/2;inline-size:100%;block-size:100%}\n"] }]
+        }] });
+
+var index = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  COMMON_BRACKET_ROUND_TYPE: COMMON_BRACKET_ROUND_TYPE,
+  DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE: DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE,
+  FALLBACK_MATCH_POSITION: FALLBACK_MATCH_POSITION,
+  GROUP_BRACKET_ROUND_TYPE: GROUP_BRACKET_ROUND_TYPE,
+  NewBracketComponent: NewBracketComponent,
+  NewBracketDefaultMatchComponent: NewBracketDefaultMatchComponent,
+  NewBracketDefaultRoundHeaderComponent: NewBracketDefaultRoundHeaderComponent,
+  SINGLE_ELIMINATION_BRACKET_ROUND_TYPE: SINGLE_ELIMINATION_BRACKET_ROUND_TYPE,
+  SWISS_BRACKET_ROUND_TYPE: SWISS_BRACKET_ROUND_TYPE,
+  TOURNAMENT_MODE: TOURNAMENT_MODE,
+  drawMan: drawMan,
+  generateBracketDataForEthlete: generateBracketDataForEthlete,
+  generateBracketGridDefinitions: generateBracketGridDefinitions,
+  generateBracketGridItems: generateBracketGridItems,
+  generateBracketRoundSwissGroupMaps: generateBracketRoundSwissGroupMaps,
+  generateBracketRoundTypeMap: generateBracketRoundTypeMap,
+  generateMatchParticipantMap: generateMatchParticipantMap,
+  generateMatchPosition: generateMatchPosition,
+  generateMatchPositionMaps: generateMatchPositionMaps,
+  generateMatchRelationPositions: generateMatchRelationPositions,
+  generateMatchRelations: generateMatchRelations,
+  generateRoundRelations: generateRoundRelations,
+  generateRoundTypeFromEthleteRoundType: generateRoundTypeFromEthleteRoundType,
+  generateTournamentModeFormEthleteRounds: generateTournamentModeFormEthleteRounds,
+  getAvailableSwissGroupsForRound: getAvailableSwissGroupsForRound,
+  logRoundRelations: logRoundRelations
+});
+
 class ButtonDirective {
     constructor() {
         this.isButton = inject(ElementRef).nativeElement.tagName === 'BUTTON';
@@ -18081,5 +19174,5 @@ const FLOATING_UI_PLACEMENTS = [
  * Generated bundle index. Do not edit.
  */
 
-export { ACCORDION_COMPONENT, ACCORDION_HINT_WRAPPER_DIRECTIVE, ACCORDION_LABEL_WRAPPER_DIRECTIVE, AccordionComponent, AccordionGroupComponent, AccordionHintDirective, AccordionHintWrapperDirective, AccordionImports, AccordionLabelDirective, AccordionLabelWrapperDirective, ActiveTabUnderlineBarManager, ActiveTabUnderlineDirective, AutosizeTextareaDirective, BOTTOM_SHEET_CONFIG, BOTTOM_SHEET_DATA, BOTTOM_SHEET_DEFAULT_CONFIG, BOTTOM_SHEET_DEFAULT_OPTIONS, BOTTOM_SHEET_MIN_SWIPE_TO_CLOSE_LENGTH, BOTTOM_SHEET_MIN_VELOCITY_TO_CLOSE, BOTTOM_SHEET_SCROLL_STRATEGY, BOTTOM_SHEET_SCROLL_STRATEGY_PROVIDER, BOTTOM_SHEET_SCROLL_STRATEGY_PROVIDER_FACTORY, BRACKET_CONFIG_TOKEN, BRACKET_DEFAULT_CONFIG, BRACKET_MATCH_ID_TOKEN, BRACKET_ROUND_ID_TOKEN, BRACKET_TOKEN, BottomSheetContainerBaseComponent, BottomSheetContainerComponent, BottomSheetDragHandleComponent, BottomSheetImports, BottomSheetRef, BottomSheetService, BottomSheetServiceBase, BottomSheetSwipeHandlerService, BottomSheetTitleDirective, Bracket, BracketComponent, BracketImports, BracketMatchComponent, BracketMatchDirective, BracketRoundDirective, BracketRoundHeaderComponent, ButtonComponent, ButtonDirective, ButtonImports, CAROUSEL_ITEM_NAV_TOKEN, CAROUSEL_ITEM_TOKEN, CAROUSEL_NEXT_BUTTON_TOKEN, CAROUSEL_PREVIOUS_BUTTON_TOKEN, CAROUSEL_TOGGLE_AUTO_PLAY_BUTTON_TOKEN, CAROUSEL_TOKEN, CDK_MENU, CHECKBOX_FIELD_TOKEN, CHECKBOX_GROUP_CONTROL_TOKEN, CHECKBOX_GROUP_TOKEN, CHECKBOX_TOKEN, COLOR_INPUT_TOKEN, COMBOBOX_BODY_EMPTY_TEMPLATE_TOKEN, COMBOBOX_BODY_ERROR_TEMPLATE_TOKEN, COMBOBOX_BODY_LOADING_TEMPLATE_TOKEN, COMBOBOX_BODY_MORE_ITEMS_HINT_TEMPLATE_TOKEN, COMBOBOX_BODY_TOKEN, COMBOBOX_CONFIG_TOKEN, COMBOBOX_DEFAULT_CONFIG, COMBOBOX_OPTION_TEMPLATE_TOKEN, COMBOBOX_OPTION_TOKEN, COMBOBOX_SELECTED_OPTION_TEMPLATE_TOKEN, COMBOBOX_TOKEN, CarouselComponent, CarouselDirective, CarouselImports, CarouselItemComponent, CarouselItemDirective, CarouselItemNavComponent, CarouselItemNavDirective, CarouselNextButtonDirective, CarouselPreviousButtonDirective, CarouselToggleAutoPlayButtonDirective, CdkContextMenuTrigger, CdkMenu, CdkMenuBar, CdkMenuBase, CdkMenuGroup, CdkMenuItem, CdkMenuItemCheckbox, CdkMenuItemRadio, CdkMenuItemSelectable, CdkMenuModule, CdkMenuTrigger, CdkMenuTriggerBase, CdkTargetMenuAim, CellDefDirective, CellDirective, CheckboxComponent, CheckboxDirective, CheckboxFieldComponent, CheckboxFieldDirective, CheckboxGroupComponent, CheckboxGroupControlDirective, CheckboxGroupDirective, CheckboxImports, ChevronIconComponent, ColorInputComponent, ColorInputDirective, ColumnDefDirective, ComboboxBodyComponent, ComboboxBodyEmptyTemplateDirective, ComboboxBodyErrorTemplateDirective, ComboboxBodyLoadingTemplateDirective, ComboboxBodyMoreItemsHintTemplateDirective, ComboboxComponent, ComboboxDirective, ComboboxImports, ComboboxOptionComponent, ComboboxOptionTemplateDirective, ComboboxSelectedOptionTemplateDirective, ContextMenuTracker, DATE_INPUT_FORMAT_TOKEN, DATE_INPUT_TOKEN, DATE_TIME_INPUT_FORMAT_TOKEN, DATE_TIME_INPUT_TOKEN, DEFAULT_DATE_INPUT_FORMAT, DEFAULT_DATE_TIME_INPUT_FORMAT, DEFAULT_TIME_INPUT_FORMAT, DIALOG_CONFIG, DIALOG_DATA, DIALOG_DEFAULT_CONFIG, DIALOG_DEFAULT_OPTIONS, DIALOG_SCROLL_STRATEGY, DIALOG_SCROLL_STRATEGY_PROVIDER, DIALOG_SCROLL_STRATEGY_PROVIDER_FACTORY, DYNAMIC_FORM_FIELD_TOKEN, DYNAMIC_FORM_GROUP_TOKEN, DateInputComponent, DateInputDirective, DateTimeInputComponent, DateTimeInputDirective, DecoratedFormFieldBase, DecoratedInputBase, DefaultValidatorErrorsService, DialogCloseDirective, DialogContainerBaseComponent, DialogContainerComponent, DialogImports, DialogRef, DialogService, DialogServiceBase, DialogTitleDirective, DynamicFormFieldDirective, DynamicFormGroupDirective, DynamicOverlayService, DynamicOverlayTitleDirective, EMAIL_INPUT_TOKEN, ET_OVERLAY_BOTTOM_SHEET_CLASS, ET_OVERLAY_CONFIG_CLASS_KEYS, ET_OVERLAY_DIALOG_CLASS, ET_OVERLAY_FULL_SCREEN_DIALOG_CLASS, ET_OVERLAY_LAYOUT_CLASSES, ET_OVERLAY_LEFT_SHEET_CLASS, ET_OVERLAY_RIGHT_SHEET_CLASS, ET_OVERLAY_TOP_SHEET_CLASS, EXPOSE_INPUT_VARS_TOKEN, EmailInputComponent, EmailInputDirective, ErrorComponent, ExposeInputVarsDirective, FILTER_OVERLAY_CONFIG, FLOATING_UI_PLACEMENTS, FilterOverlayService, FooterCellDefDirective, FooterCellDirective, FooterRowComponent, FooterRowDefDirective, FormFieldStateService, FormGroupStateService, HeaderCellDefDirective, HeaderCellDirective, HeaderRowComponent, HeaderRowDefDirective, IMAGE_CONFIG_TOKEN, INPUT_PREFIX_TOKEN, INPUT_SUFFIX_TOKEN, INPUT_TOKEN, IconImports, IfInputEmptyDirective, IfInputFilledDirective, IfSupportsShowPickerDirective, InlineTabBodyComponent, InlineTabBodyHostDirective, InlineTabChangeEvent, InlineTabComponent, InlineTabContentDirective, InlineTabHeaderComponent, InlineTabLabelDirective, InlineTabLabelWrapperDirective, InlineTabsComponent, InputBase, InputDirective, InputFieldComponent, InputImports, InputPrefixDirective, InputStateService, InputSuffixDirective, LABEL_TOKEN, LabelComponent, LabelImports, LabelSuffixDirective, MASONRY_ITEM_TOKEN, MAX_SAFE_INTEGER, MENU, MENU_AIM, MENU_CHECKBOX_GROUP_TOKEN, MENU_CONTAINER, MENU_GROUP_TITLE_TOKEN, MENU_GROUP_TOKEN, MENU_ITEM_TOKEN, MENU_RADIO_GROUP_TOKEN, MENU_SEARCH_TEMPLATE_TOKEN, MENU_STACK, MENU_TEMPLATE, MENU_TRIGGER, MENU_TRIGGER_TOKEN, MasonryComponent, MasonryImports, MasonryItemComponent, MenuCheckboxGroupDirective, MenuCheckboxItemComponent, MenuComponent, MenuContainerComponent, MenuGroupDirective, MenuGroupTitleDirective, MenuImports, MenuItemDirective, MenuRadioGroupDirective, MenuRadioItemComponent, MenuSearchTemplateDirective, MenuStack, MenuTriggerDirective, NATIVE_INPUT_REF_TOKEN, NATIVE_SELECT_INPUT_TOKEN, NATIVE_SELECT_OPTION_TOKEN, NUMBER_INPUT_TOKEN, NativeInputRefDirective, NativeSelectImports, NativeSelectInputComponent, NativeSelectInputDirective, NativeSelectOptionComponent, NativeSelectOptionDirective, NavTabLinkComponent, NavTabsComponent, NavTabsOutletComponent, NoDataRowDirective, NumberInputComponent, NumberInputDirective, OVERLAY_BACK_OR_CLOSE_TOKEN, OVERLAY_BODY_TOKEN, OVERLAY_CLOSE_BLOCKER_TOKEN, OVERLAY_CONFIG, OVERLAY_DATA, OVERLAY_DEFAULT_CONFIG, OVERLAY_DEFAULT_OPTIONS, OVERLAY_FOOTER_TOKEN, OVERLAY_HEADER_TEMPLATE_TOKEN, OVERLAY_HEADER_TOKEN, OVERLAY_MAIN_TOKEN, OVERLAY_QUERY_PARAM_INPUT_NAME, OVERLAY_ROUTER_CONFIG_TOKEN, OVERLAY_ROUTER_LINK_TOKEN, OVERLAY_ROUTER_OUTLET_DISABLED_TEMPLATE_TOKEN, OVERLAY_ROUTER_OUTLET_TOKEN, OVERLAY_SCROLL_STRATEGY, OVERLAY_SHARED_ROUTE_TEMPLATE_TOKEN, OVERLAY_STATE, OverlayBackOrCloseDirective, OverlayBodyComponent, OverlayCloseBlockerDirective, OverlayCloseDirective, OverlayContainerComponent, OverlayFooterDirective, OverlayHandlerLinkDirective, OverlayHeaderDirective, OverlayHeaderTemplateDirective, OverlayImports, OverlayMainDirective, OverlayPositionBuilder, OverlayRef, OverlayRouteHeaderTemplateOutletComponent, OverlayRouterLinkDirective, OverlayRouterOutletComponent, OverlayRouterOutletDisabledTemplateDirective, OverlayRouterService, OverlayService, OverlaySharedRouteTemplateDirective, OverlaySharedRouteTemplateOutletComponent, OverlaySidebarComponent, OverlaySidebarPageComponent, OverlayTitleDirective, OverlayWithRoutingImports, OverlayWithSidebarImports, PARENT_OR_NEW_INLINE_MENU_STACK_PROVIDER, PARENT_OR_NEW_MENU_STACK_PROVIDER, PASSWORD_INPUT_TOKEN, PROGRESS_SPINNER_DEFAULT_OPTIONS, PROGRESS_SPINNER_DEFAULT_OPTIONS_FACTORY, PaginatedTabHeaderDirective, PaginationComponent, PaginationHeadService, PaginationImports, PaginationLinkDirective, PasswordInputComponent, PasswordInputDirective, PasswordInputToggleComponent, PictureComponent, PointerFocusTracker, ProgressSpinnerComponent, QUERY_ERROR_TOKEN, QueryButtonComponent, QueryButtonDirective, QueryErrorComponent, QueryErrorDirective, RADIO_FIELD_TOKEN, RADIO_GROUP_TOKEN, RADIO_TOKEN, RICH_FILTER_BUTTON_SLOT_TOKEN, RICH_FILTER_BUTTON_TOKEN, RICH_FILTER_CONTENT_TOKEN, RICH_FILTER_TOP_TOKEN, RadioComponent, RadioDirective, RadioFieldComponent, RadioFieldDirective, RadioGroupComponent, RadioGroupDirective, RadioImports, RecycleRowsDirective, RichFilterButtonDirective, RichFilterButtonSlotDirective, RichFilterContentDirective, RichFilterHostComponent, RichFilterImports, RichFilterTopDirective, RowComponent, RowDefDirective, SCROLLABLE_IGNORE_CHILD_ATTRIBUTE, SCROLLABLE_IGNORE_CHILD_TOKEN, SCROLLABLE_IS_ACTIVE_CHILD_ATTRIBUTE, SCROLLABLE_IS_ACTIVE_CHILD_TOKEN, SCROLLABLE_LOADING_TEMPLATE_TOKEN, SCROLLABLE_PLACEHOLDER_ITEM_TEMPLATE_TOKEN, SCROLLABLE_PLACEHOLDER_OVERLAY_TEMPLATE_TOKEN, SEARCH_INPUT_TOKEN, SEGMENTED_BUTTON_FIELD_TOKEN, SEGMENTED_BUTTON_GROUP_TOKEN, SEGMENTED_BUTTON_TOKEN, SELECTION_LIST_FIELD, SELECTION_LIST_OPTION, SELECT_BODY_TOKEN, SELECT_FIELD_TOKEN, SELECT_OPTION_TOKEN, SELECT_TOKEN, SHOW_PICKER_TRIGGER_TOKEN, SIDEBAR_OVERLAY_CONFIG, SLIDE_TOGGLE_TOKEN, SORT_DEFAULT_OPTIONS, SORT_HEADER_COLUMN_DEF, SORT_HEADER_INTL_PROVIDER, SORT_HEADER_INTL_PROVIDER_FACTORY, STATIC_FORM_FIELD_TOKEN, STATIC_FORM_GROUP_TOKEN, ScrollableComponent, ScrollableIgnoreChildDirective, ScrollableImports, ScrollableIsActiveChildDirective, ScrollableLoadingTemplateDirective, ScrollablePlaceholderComponent, ScrollablePlaceholderItemTemplateDirective, ScrollablePlaceholderOverlayTemplateDirective, SearchInputClearComponent, SearchInputComponent, SearchInputDirective, SegmentedButtonComponent, SegmentedButtonDirective, SegmentedButtonFieldComponent, SegmentedButtonFieldDirective, SegmentedButtonGroupComponent, SegmentedButtonGroupDirective, SegmentedButtonImports, SelectBodyComponent, SelectBodyDirective, SelectComponent, SelectDirective, SelectFieldComponent, SelectFieldDirective, SelectImports, SelectOptionComponent, SelectOptionDirective, SelectionListFieldComponent, SelectionListFieldDirective, SelectionListImports, SelectionListOptionComponent, SelectionListOptionDirective, ShowPickerTriggerDirective, SidebarOverlayService, SkeletonComponent, SkeletonImports, SkeletonItemComponent, SlideToggleComponent, SlideToggleDirective, SlideToggleFieldComponent, SlideToggleImports, SliderComponent, SliderFieldComponent, SliderImports, SortDirective, SortHeaderComponent, SortHeaderIntl, SortImports, StaticFormFieldDirective, StaticFormGroupDirective, SwipeHandlerService, TAB, TABS_CONFIG, TAB_CONTENT, TAB_GROUP, TAB_LABEL, TEL_INPUT_TOKEN, TEXTAREA_INPUT_TOKEN, TEXT_INPUT_TOKEN, TIME_INPUT_FORMAT_TOKEN, TIME_INPUT_TOKEN, TOGGLETIP, TOGGLETIP_CONFIG, TOGGLETIP_DEFAULT_CONFIG, TOGGLETIP_DIRECTIVE, TOGGLETIP_TEMPLATE, TOGGLETIP_TEXT, TOOLTIP, TOOLTIP_CONFIG, TOOLTIP_DEFAULT_CONFIG, TOOLTIP_DIRECTIVE, TOOLTIP_TEMPLATE, TOOLTIP_TEXT, TabImports, TableBusyDirective, TableBusyOutletDirective, TableComponent, TableDataSource, TableImports, TargetMenuAim, TelInputComponent, TelInputDirective, TextColumnComponent, TextInputComponent, TextInputDirective, TextareaInputComponent, TextareaInputDirective, TimeInputComponent, TimeInputDirective, TimesIconComponent, ToggletipCloseDirective, ToggletipComponent, ToggletipDirective, ToggletipImports, TooltipComponent, TooltipDirective, TooltipImports, VALIDATOR_ERROR_SERVICE_TOKEN, WRITEABLE_INPUT_TOKEN, WRITEABLE_INPUT_VALUE_ACCESSOR, WriteableInputDirective, _MAT_INK_BAR_POSITIONER, _MAT_INK_BAR_POSITIONER_FACTORY, accordionAnimations, convertHttpStatusCodeToMessageDe, convertHttpStatusCodeToMessageEn, convertHttpStatusCodeToTitleDe, convertHttpStatusCodeToTitleEn, createBottomSheetConfig, createBracketConfig, createComboboxConfig, createDialogConfig, createFormChangesTracker, createOverlayConfig, createOverlayDismissChecker, createOverlayHandler, createOverlayHandlerWithQueryParamLifecycle, createToggletipConfig, createTooltipConfig, defaultSubmitButtonConfigFn, getClosestBottomSheet, getClosestDialog, getClosestOverlay, isScrollableChildActive, isScrollableChildIgnored, isUpperBracketMatch, normalizePictureSizes, normalizePictureSource, normalizeRoundType, orderRounds, orderRoundsByRoundNumber, paginate, provideBottomSheet, provideBottomSheetDefaultConfig, provideBracketConfig, provideComboboxConfig, provideDateFormat, provideDateTimeFormat, provideDialog, provideDialogDefaultConfig, provideFilterOverlayConfig, provideImageConfig, provideOverlay, provideOverlayDefaultConfig, provideOverlayRouterConfig, provideSidebarOverlayConfig, provideSort, provideTimeFormat, provideToggletipConfig, provideTooltipConfig, provideValidatorErrorsService, tabAnimations };
+export { ACCORDION_COMPONENT, ACCORDION_HINT_WRAPPER_DIRECTIVE, ACCORDION_LABEL_WRAPPER_DIRECTIVE, AccordionComponent, AccordionGroupComponent, AccordionHintDirective, AccordionHintWrapperDirective, AccordionImports, AccordionLabelDirective, AccordionLabelWrapperDirective, ActiveTabUnderlineBarManager, ActiveTabUnderlineDirective, AutosizeTextareaDirective, BOTTOM_SHEET_CONFIG, BOTTOM_SHEET_DATA, BOTTOM_SHEET_DEFAULT_CONFIG, BOTTOM_SHEET_DEFAULT_OPTIONS, BOTTOM_SHEET_MIN_SWIPE_TO_CLOSE_LENGTH, BOTTOM_SHEET_MIN_VELOCITY_TO_CLOSE, BOTTOM_SHEET_SCROLL_STRATEGY, BOTTOM_SHEET_SCROLL_STRATEGY_PROVIDER, BOTTOM_SHEET_SCROLL_STRATEGY_PROVIDER_FACTORY, BRACKET_CONFIG_TOKEN, BRACKET_DEFAULT_CONFIG, BRACKET_MATCH_ID_TOKEN, BRACKET_ROUND_ID_TOKEN, BRACKET_TOKEN, BottomSheetContainerBaseComponent, BottomSheetContainerComponent, BottomSheetDragHandleComponent, BottomSheetImports, BottomSheetRef, BottomSheetService, BottomSheetServiceBase, BottomSheetSwipeHandlerService, BottomSheetTitleDirective, Bracket, BracketComponent, BracketImports, BracketMatchComponent, BracketMatchDirective, index as BracketNew, BracketRoundDirective, BracketRoundHeaderComponent, ButtonComponent, ButtonDirective, ButtonImports, CAROUSEL_ITEM_NAV_TOKEN, CAROUSEL_ITEM_TOKEN, CAROUSEL_NEXT_BUTTON_TOKEN, CAROUSEL_PREVIOUS_BUTTON_TOKEN, CAROUSEL_TOGGLE_AUTO_PLAY_BUTTON_TOKEN, CAROUSEL_TOKEN, CDK_MENU, CHECKBOX_FIELD_TOKEN, CHECKBOX_GROUP_CONTROL_TOKEN, CHECKBOX_GROUP_TOKEN, CHECKBOX_TOKEN, COLOR_INPUT_TOKEN, COMBOBOX_BODY_EMPTY_TEMPLATE_TOKEN, COMBOBOX_BODY_ERROR_TEMPLATE_TOKEN, COMBOBOX_BODY_LOADING_TEMPLATE_TOKEN, COMBOBOX_BODY_MORE_ITEMS_HINT_TEMPLATE_TOKEN, COMBOBOX_BODY_TOKEN, COMBOBOX_CONFIG_TOKEN, COMBOBOX_DEFAULT_CONFIG, COMBOBOX_OPTION_TEMPLATE_TOKEN, COMBOBOX_OPTION_TOKEN, COMBOBOX_SELECTED_OPTION_TEMPLATE_TOKEN, COMBOBOX_TOKEN, CarouselComponent, CarouselDirective, CarouselImports, CarouselItemComponent, CarouselItemDirective, CarouselItemNavComponent, CarouselItemNavDirective, CarouselNextButtonDirective, CarouselPreviousButtonDirective, CarouselToggleAutoPlayButtonDirective, CdkContextMenuTrigger, CdkMenu, CdkMenuBar, CdkMenuBase, CdkMenuGroup, CdkMenuItem, CdkMenuItemCheckbox, CdkMenuItemRadio, CdkMenuItemSelectable, CdkMenuModule, CdkMenuTrigger, CdkMenuTriggerBase, CdkTargetMenuAim, CellDefDirective, CellDirective, CheckboxComponent, CheckboxDirective, CheckboxFieldComponent, CheckboxFieldDirective, CheckboxGroupComponent, CheckboxGroupControlDirective, CheckboxGroupDirective, CheckboxImports, ChevronIconComponent, ColorInputComponent, ColorInputDirective, ColumnDefDirective, ComboboxBodyComponent, ComboboxBodyEmptyTemplateDirective, ComboboxBodyErrorTemplateDirective, ComboboxBodyLoadingTemplateDirective, ComboboxBodyMoreItemsHintTemplateDirective, ComboboxComponent, ComboboxDirective, ComboboxImports, ComboboxOptionComponent, ComboboxOptionTemplateDirective, ComboboxSelectedOptionTemplateDirective, ContextMenuTracker, DATE_INPUT_FORMAT_TOKEN, DATE_INPUT_TOKEN, DATE_TIME_INPUT_FORMAT_TOKEN, DATE_TIME_INPUT_TOKEN, DEFAULT_DATE_INPUT_FORMAT, DEFAULT_DATE_TIME_INPUT_FORMAT, DEFAULT_TIME_INPUT_FORMAT, DIALOG_CONFIG, DIALOG_DATA, DIALOG_DEFAULT_CONFIG, DIALOG_DEFAULT_OPTIONS, DIALOG_SCROLL_STRATEGY, DIALOG_SCROLL_STRATEGY_PROVIDER, DIALOG_SCROLL_STRATEGY_PROVIDER_FACTORY, DYNAMIC_FORM_FIELD_TOKEN, DYNAMIC_FORM_GROUP_TOKEN, DateInputComponent, DateInputDirective, DateTimeInputComponent, DateTimeInputDirective, DecoratedFormFieldBase, DecoratedInputBase, DefaultValidatorErrorsService, DialogCloseDirective, DialogContainerBaseComponent, DialogContainerComponent, DialogImports, DialogRef, DialogService, DialogServiceBase, DialogTitleDirective, DynamicFormFieldDirective, DynamicFormGroupDirective, DynamicOverlayService, DynamicOverlayTitleDirective, EMAIL_INPUT_TOKEN, ET_OVERLAY_BOTTOM_SHEET_CLASS, ET_OVERLAY_CONFIG_CLASS_KEYS, ET_OVERLAY_DIALOG_CLASS, ET_OVERLAY_FULL_SCREEN_DIALOG_CLASS, ET_OVERLAY_LAYOUT_CLASSES, ET_OVERLAY_LEFT_SHEET_CLASS, ET_OVERLAY_RIGHT_SHEET_CLASS, ET_OVERLAY_TOP_SHEET_CLASS, EXPOSE_INPUT_VARS_TOKEN, EmailInputComponent, EmailInputDirective, ErrorComponent, ExposeInputVarsDirective, FILTER_OVERLAY_CONFIG, FLOATING_UI_PLACEMENTS, FilterOverlayService, FooterCellDefDirective, FooterCellDirective, FooterRowComponent, FooterRowDefDirective, FormFieldStateService, FormGroupStateService, HeaderCellDefDirective, HeaderCellDirective, HeaderRowComponent, HeaderRowDefDirective, IMAGE_CONFIG_TOKEN, INPUT_PREFIX_TOKEN, INPUT_SUFFIX_TOKEN, INPUT_TOKEN, IconImports, IfInputEmptyDirective, IfInputFilledDirective, IfSupportsShowPickerDirective, InlineTabBodyComponent, InlineTabBodyHostDirective, InlineTabChangeEvent, InlineTabComponent, InlineTabContentDirective, InlineTabHeaderComponent, InlineTabLabelDirective, InlineTabLabelWrapperDirective, InlineTabsComponent, InputBase, InputDirective, InputFieldComponent, InputImports, InputPrefixDirective, InputStateService, InputSuffixDirective, LABEL_TOKEN, LabelComponent, LabelImports, LabelSuffixDirective, MASONRY_ITEM_TOKEN, MAX_SAFE_INTEGER, MENU, MENU_AIM, MENU_CHECKBOX_GROUP_TOKEN, MENU_CONTAINER, MENU_GROUP_TITLE_TOKEN, MENU_GROUP_TOKEN, MENU_ITEM_TOKEN, MENU_RADIO_GROUP_TOKEN, MENU_SEARCH_TEMPLATE_TOKEN, MENU_STACK, MENU_TEMPLATE, MENU_TRIGGER, MENU_TRIGGER_TOKEN, MasonryComponent, MasonryImports, MasonryItemComponent, MenuCheckboxGroupDirective, MenuCheckboxItemComponent, MenuComponent, MenuContainerComponent, MenuGroupDirective, MenuGroupTitleDirective, MenuImports, MenuItemDirective, MenuRadioGroupDirective, MenuRadioItemComponent, MenuSearchTemplateDirective, MenuStack, MenuTriggerDirective, NATIVE_INPUT_REF_TOKEN, NATIVE_SELECT_INPUT_TOKEN, NATIVE_SELECT_OPTION_TOKEN, NUMBER_INPUT_TOKEN, NativeInputRefDirective, NativeSelectImports, NativeSelectInputComponent, NativeSelectInputDirective, NativeSelectOptionComponent, NativeSelectOptionDirective, NavTabLinkComponent, NavTabsComponent, NavTabsOutletComponent, NoDataRowDirective, NumberInputComponent, NumberInputDirective, OVERLAY_BACK_OR_CLOSE_TOKEN, OVERLAY_BODY_TOKEN, OVERLAY_CLOSE_BLOCKER_TOKEN, OVERLAY_CONFIG, OVERLAY_DATA, OVERLAY_DEFAULT_CONFIG, OVERLAY_DEFAULT_OPTIONS, OVERLAY_FOOTER_TOKEN, OVERLAY_HEADER_TEMPLATE_TOKEN, OVERLAY_HEADER_TOKEN, OVERLAY_MAIN_TOKEN, OVERLAY_QUERY_PARAM_INPUT_NAME, OVERLAY_ROUTER_CONFIG_TOKEN, OVERLAY_ROUTER_LINK_TOKEN, OVERLAY_ROUTER_OUTLET_DISABLED_TEMPLATE_TOKEN, OVERLAY_ROUTER_OUTLET_TOKEN, OVERLAY_SCROLL_STRATEGY, OVERLAY_SHARED_ROUTE_TEMPLATE_TOKEN, OVERLAY_STATE, OverlayBackOrCloseDirective, OverlayBodyComponent, OverlayCloseBlockerDirective, OverlayCloseDirective, OverlayContainerComponent, OverlayFooterDirective, OverlayHandlerLinkDirective, OverlayHeaderDirective, OverlayHeaderTemplateDirective, OverlayImports, OverlayMainDirective, OverlayPositionBuilder, OverlayRef, OverlayRouteHeaderTemplateOutletComponent, OverlayRouterLinkDirective, OverlayRouterOutletComponent, OverlayRouterOutletDisabledTemplateDirective, OverlayRouterService, OverlayService, OverlaySharedRouteTemplateDirective, OverlaySharedRouteTemplateOutletComponent, OverlaySidebarComponent, OverlaySidebarPageComponent, OverlayTitleDirective, OverlayWithRoutingImports, OverlayWithSidebarImports, PARENT_OR_NEW_INLINE_MENU_STACK_PROVIDER, PARENT_OR_NEW_MENU_STACK_PROVIDER, PASSWORD_INPUT_TOKEN, PROGRESS_SPINNER_DEFAULT_OPTIONS, PROGRESS_SPINNER_DEFAULT_OPTIONS_FACTORY, PaginatedTabHeaderDirective, PaginationComponent, PaginationHeadService, PaginationImports, PaginationLinkDirective, PasswordInputComponent, PasswordInputDirective, PasswordInputToggleComponent, PictureComponent, PointerFocusTracker, ProgressSpinnerComponent, QUERY_ERROR_TOKEN, QueryButtonComponent, QueryButtonDirective, QueryErrorComponent, QueryErrorDirective, RADIO_FIELD_TOKEN, RADIO_GROUP_TOKEN, RADIO_TOKEN, RICH_FILTER_BUTTON_SLOT_TOKEN, RICH_FILTER_BUTTON_TOKEN, RICH_FILTER_CONTENT_TOKEN, RICH_FILTER_TOP_TOKEN, RadioComponent, RadioDirective, RadioFieldComponent, RadioFieldDirective, RadioGroupComponent, RadioGroupDirective, RadioImports, RecycleRowsDirective, RichFilterButtonDirective, RichFilterButtonSlotDirective, RichFilterContentDirective, RichFilterHostComponent, RichFilterImports, RichFilterTopDirective, RowComponent, RowDefDirective, SCROLLABLE_IGNORE_CHILD_ATTRIBUTE, SCROLLABLE_IGNORE_CHILD_TOKEN, SCROLLABLE_IS_ACTIVE_CHILD_ATTRIBUTE, SCROLLABLE_IS_ACTIVE_CHILD_TOKEN, SCROLLABLE_LOADING_TEMPLATE_TOKEN, SCROLLABLE_PLACEHOLDER_ITEM_TEMPLATE_TOKEN, SCROLLABLE_PLACEHOLDER_OVERLAY_TEMPLATE_TOKEN, SEARCH_INPUT_TOKEN, SEGMENTED_BUTTON_FIELD_TOKEN, SEGMENTED_BUTTON_GROUP_TOKEN, SEGMENTED_BUTTON_TOKEN, SELECTION_LIST_FIELD, SELECTION_LIST_OPTION, SELECT_BODY_TOKEN, SELECT_FIELD_TOKEN, SELECT_OPTION_TOKEN, SELECT_TOKEN, SHOW_PICKER_TRIGGER_TOKEN, SIDEBAR_OVERLAY_CONFIG, SLIDE_TOGGLE_TOKEN, SORT_DEFAULT_OPTIONS, SORT_HEADER_COLUMN_DEF, SORT_HEADER_INTL_PROVIDER, SORT_HEADER_INTL_PROVIDER_FACTORY, STATIC_FORM_FIELD_TOKEN, STATIC_FORM_GROUP_TOKEN, ScrollableComponent, ScrollableIgnoreChildDirective, ScrollableImports, ScrollableIsActiveChildDirective, ScrollableLoadingTemplateDirective, ScrollablePlaceholderComponent, ScrollablePlaceholderItemTemplateDirective, ScrollablePlaceholderOverlayTemplateDirective, SearchInputClearComponent, SearchInputComponent, SearchInputDirective, SegmentedButtonComponent, SegmentedButtonDirective, SegmentedButtonFieldComponent, SegmentedButtonFieldDirective, SegmentedButtonGroupComponent, SegmentedButtonGroupDirective, SegmentedButtonImports, SelectBodyComponent, SelectBodyDirective, SelectComponent, SelectDirective, SelectFieldComponent, SelectFieldDirective, SelectImports, SelectOptionComponent, SelectOptionDirective, SelectionListFieldComponent, SelectionListFieldDirective, SelectionListImports, SelectionListOptionComponent, SelectionListOptionDirective, ShowPickerTriggerDirective, SidebarOverlayService, SkeletonComponent, SkeletonImports, SkeletonItemComponent, SlideToggleComponent, SlideToggleDirective, SlideToggleFieldComponent, SlideToggleImports, SliderComponent, SliderFieldComponent, SliderImports, SortDirective, SortHeaderComponent, SortHeaderIntl, SortImports, StaticFormFieldDirective, StaticFormGroupDirective, SwipeHandlerService, TAB, TABS_CONFIG, TAB_CONTENT, TAB_GROUP, TAB_LABEL, TEL_INPUT_TOKEN, TEXTAREA_INPUT_TOKEN, TEXT_INPUT_TOKEN, TIME_INPUT_FORMAT_TOKEN, TIME_INPUT_TOKEN, TOGGLETIP, TOGGLETIP_CONFIG, TOGGLETIP_DEFAULT_CONFIG, TOGGLETIP_DIRECTIVE, TOGGLETIP_TEMPLATE, TOGGLETIP_TEXT, TOOLTIP, TOOLTIP_CONFIG, TOOLTIP_DEFAULT_CONFIG, TOOLTIP_DIRECTIVE, TOOLTIP_TEMPLATE, TOOLTIP_TEXT, TabImports, TableBusyDirective, TableBusyOutletDirective, TableComponent, TableDataSource, TableImports, TargetMenuAim, TelInputComponent, TelInputDirective, TextColumnComponent, TextInputComponent, TextInputDirective, TextareaInputComponent, TextareaInputDirective, TimeInputComponent, TimeInputDirective, TimesIconComponent, ToggletipCloseDirective, ToggletipComponent, ToggletipDirective, ToggletipImports, TooltipComponent, TooltipDirective, TooltipImports, VALIDATOR_ERROR_SERVICE_TOKEN, WRITEABLE_INPUT_TOKEN, WRITEABLE_INPUT_VALUE_ACCESSOR, WriteableInputDirective, _MAT_INK_BAR_POSITIONER, _MAT_INK_BAR_POSITIONER_FACTORY, accordionAnimations, convertHttpStatusCodeToMessageDe, convertHttpStatusCodeToMessageEn, convertHttpStatusCodeToTitleDe, convertHttpStatusCodeToTitleEn, createBottomSheetConfig, createBracketConfig, createComboboxConfig, createDialogConfig, createFormChangesTracker, createOverlayConfig, createOverlayDismissChecker, createOverlayHandler, createOverlayHandlerWithQueryParamLifecycle, createToggletipConfig, createTooltipConfig, defaultSubmitButtonConfigFn, getClosestBottomSheet, getClosestDialog, getClosestOverlay, isScrollableChildActive, isScrollableChildIgnored, isUpperBracketMatch, normalizePictureSizes, normalizePictureSource, normalizeRoundType, orderRounds, orderRoundsByRoundNumber, paginate, provideBottomSheet, provideBottomSheetDefaultConfig, provideBracketConfig, provideComboboxConfig, provideDateFormat, provideDateTimeFormat, provideDialog, provideDialogDefaultConfig, provideFilterOverlayConfig, provideImageConfig, provideOverlay, provideOverlayDefaultConfig, provideOverlayRouterConfig, provideSidebarOverlayConfig, provideSort, provideTimeFormat, provideToggletipConfig, provideTooltipConfig, provideValidatorErrorsService, tabAnimations };
 //# sourceMappingURL=ethlete-cdk.mjs.map