@ethlete/cdk 4.61.1 → 4.61.2

package/fesm2022/ethlete-cdk.mjs

@@ -1,5 +1,5 @@
 import * as i0 from '@angular/core';
-import { InjectionToken, inject, TemplateRef, ViewContainerRef, Directive, input, booleanAttribute, computed, isDevMode, model, contentChild, effect, untracked, ChangeDetectionStrategy, ViewEncapsulation, Component, contentChildren, ElementRef, Injector, HostBinding, Input, numberAttribute, PLATFORM_ID, Renderer2, DestroyRef, signal, viewChild, viewChildren, ContentChild, Injectable, ChangeDetectorRef, ViewChild, ContentChildren, assertInInjectionContext, forwardRef, runInInjectionContext, EventEmitter, Output, ViewChildren, Optional, Inject, NgZone, HostListener, SkipSelf, NgModule, isSignal, IterableDiffers, ComponentFactoryResolver, HostAttributeToken } from '@angular/core';
+import { InjectionToken, inject, TemplateRef, ViewContainerRef, Directive, input, booleanAttribute, computed, isDevMode, model, contentChild, effect, untracked, ChangeDetectionStrategy, ViewEncapsulation, Component, contentChildren, ElementRef, Injector, HostBinding, Input, numberAttribute, Renderer2, DOCUMENT, signal, viewChild, viewChildren, ContentChild, Injectable, ChangeDetectorRef, ViewChild, ContentChildren, assertInInjectionContext, forwardRef, runInInjectionContext, EventEmitter, Output, ViewChildren, Optional, Inject, NgZone, HostListener, SkipSelf, NgModule, DestroyRef, isSignal, IterableDiffers, ComponentFactoryResolver, HostAttributeToken } from '@angular/core';
 import * as i2 from '@angular/cdk/portal';
 import { CdkPortal, PortalModule, ComponentPortal, TemplatePortal, CdkPortalOutlet } from '@angular/cdk/portal';
 import { DomSanitizer, Title } from '@angular/platform-browser';
@@ -7,7 +7,7 @@ import { trigger, state, transition, style, animate } from '@angular/animations'
 import { toObservable, takeUntilDestroyed, toSignal, outputFromObservable } from '@angular/core/rxjs-interop';
 import { map, switchMap, combineLatest, pairwise, tap, BehaviorSubject, takeUntil, skip, of, merge, timer, takeWhile, filter, fromEvent, Subject, Observable, startWith, debounceTime, withLatestFrom, distinctUntilChanged, take, skipUntil, skipWhile, catchError, throwError, defer, partition, from, finalize, Subscription } from 'rxjs';
 import { __decorate, __metadata } from 'tslib';
-import { AsyncPipe, isPlatformBrowser, NgComponentOutlet, NgClass, NgTemplateOutlet, DOCUMENT, Location, NgStyle } from '@angular/common';
+import { AsyncPipe, NgComponentOutlet, NgClass, NgTemplateOutlet, DOCUMENT as DOCUMENT$1, Location, NgStyle } from '@angular/common';
 import * as i1 from '@ethlete/core';
 import { Memo, createComponentId, signalHostAttributes, signalHostClasses, createDestroy, previousSignalValue, signalHostStyles, nextFrame, syncSignal, signalStyles, injectHostElement, ObserveVisibilityDirective, signalVisibilityChangeClasses, IS_EMAIL, MUST_MATCH, IS_ARRAY_NOT_EMPTY, AT_LEAST_ONE_REQUIRED, equal, switchQueryListChanges, controlValueSignal, signalAttributes, ResizeObserverService, createFlipAnimation, AnimatedOverlayDirective, RuntimeError, SelectionModel, ActiveSelectionModel, KeyPressManager, signalClasses, scrollToElement, isEmptyArray, isObjectArray, isPrimitiveArray, ClickOutsideDirective, AnimatedLifecycleDirective, ANIMATED_LIFECYCLE_TOKEN, ObserveContentDirective, clamp, DELAYABLE_TOKEN, ObserveResizeDirective, SmartBlockScrollStrategy, signalElementDimensions, signalElementScrollState, createIsRenderedSignal, createCanAnimateSignal, useCursorDragScroll, signalElementIntersection, signalElementChildren, getIntersectionInfo, getElementScrollCoordinates, ClickObserverService, RootBoundaryDirective, elementCanScroll, cloneFormGroup, getFormGroupValue, ViewportService, injectRoute, ROOT_BOUNDARY_TOKEN, injectQueryParam, RouterStateService, fromNextFrame, isElementVisible, AnimatedIfDirective, FocusVisibleService, inferMimeType, TypedQueryList } from '@ethlete/core';
 import { extractQuery, isQueryStateSuccess, isQueryStateFailure, isQueryStateLoading, QueryDirective, queryComputed, switchQueryState, shouldRetryRequest, ExperimentalQuery, isClassValidatorError, isSymfonyFormViolationListError, isSymfonyListError } from '@ethlete/query';
@@ -238,13 +238,13 @@ class AccordionComponent {
         this.isOpen.set(false);
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: AccordionComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "20.0.3", type: AccordionComponent, isStandalone: true, selector: "et-accordion", inputs: { isOpenByDefault: { classPropertyName: "isOpenByDefault", publicName: "isOpenByDefault", isSignal: true, isRequired: false, transformFunction: null }, disabled: { classPropertyName: "disabled", publicName: "disabled", isSignal: true, isRequired: false, transformFunction: null }, label: { classPropertyName: "label", publicName: "label", isSignal: true, isRequired: false, transformFunction: null }, isOpen: { classPropertyName: "isOpen", publicName: "isOpen", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { isOpen: "isOpenChange" }, host: { classAttribute: "et-accordion" }, providers: [{ provide: ACCORDION_COMPONENT, useExisting: AccordionComponent }, provideIcons(CHEVRON_ICON)], queries: [{ propertyName: "templateLabel", first: true, predicate: ACCORDION_LABEL_WRAPPER_DIRECTIVE, descendants: true, isSignal: true }, { propertyName: "templateHint", first: true, predicate: ACCORDION_HINT_WRAPPER_DIRECTIVE, descendants: true, isSignal: true }], ngImport: i0, template: "<div class=\"et-accordion-container\">\n  <h3 class=\"et-accordion-header-wrapper\">\n    <button\n      [disabled]=\"disabled()\"\n      [id]=\"HEADER_ID\"\n      [attr.aria-controls]=\"BODY_ID\"\n      [attr.aria-expanded]=\"isOpen()\"\n      [class.et-accordion-has-hint]=\"!!templateHint\"\n      (click)=\"toggleAccordionOpen()\"\n      class=\"et-accordion-header\"\n      type=\"button\"\n    >\n      <div>\n        @if (templateLabel(); as templateLabel) {\n          <ng-template [cdkPortalOutlet]=\"templateLabel\" />\n        } @else {\n          <span et-accordion-label>{{ label() }} </span>\n        }\n      </div>\n\n      @if (templateHint(); as templateHint) {\n        <ng-template [cdkPortalOutlet]=\"templateHint\" />\n      }\n\n      <i etIcon=\"et-chevron\"> </i>\n    </button>\n  </h3>\n  <div\n    [@animateOpenClose]=\"isOpen() ? 'open' : 'close'\"\n    [attr.aria-labelledby]=\"HEADER_ID\"\n    [id]=\"BODY_ID\"\n    class=\"et-accordion-body\"\n    role=\"region\"\n  >\n    <div class=\"et-accordion-body-container\">\n      <ng-content />\n    </div>\n  </div>\n  <hr class=\"et-accordion-separator\" />\n</div>\n", styles: [":where(.et-accordion){--chevron-size: 15px}.et-accordion .et-accordion-container{position:relative;z-index:1}.et-accordion .et-icon--et-chevron{display:block;transform:rotate(180deg);transition:transform .3s var(--ease-5);inline-size:var(--chevron-size);block-size:var(--chevron-size)}.et-accordion [aria-expanded=true] .et-icon--et-chevron{transform:rotate(0)}.et-accordion .et-accordion-header{display:grid;grid-template-columns:1fr auto;inline-size:100%;block-size:100%;text-align:left;background-color:transparent;border:none;align-items:center;padding:0;gap:15px}.et-accordion .et-accordion-header:not(:disabled){cursor:pointer}.et-accordion .et-accordion-header.et-accordion-has-hint{grid-template-columns:1fr auto auto}.et-accordion .et-accordion-header-wrapper{margin:0}.et-accordion .et-accordion-body{overflow:hidden}.et-accordion .et-accordion-separator{position:relative;z-index:-1}\n"], dependencies: [{ kind: "directive", type: AccordionLabelDirective, selector: "[et-accordion-label]" }, { kind: "ngmodule", type: PortalModule }, { kind: "directive", type: i2.CdkPortalOutlet, selector: "[cdkPortalOutlet]", inputs: ["cdkPortalOutlet"], outputs: ["attached"], exportAs: ["cdkPortalOutlet"] }, { kind: "directive", type: IconDirective, selector: "[etIcon]", inputs: ["etIcon", "allowHardcodedColor"] }], animations: [accordionAnimations.animateOpenClose], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "20.0.3", type: AccordionComponent, isStandalone: true, selector: "et-accordion", inputs: { isOpenByDefault: { classPropertyName: "isOpenByDefault", publicName: "isOpenByDefault", isSignal: true, isRequired: false, transformFunction: null }, disabled: { classPropertyName: "disabled", publicName: "disabled", isSignal: true, isRequired: false, transformFunction: null }, label: { classPropertyName: "label", publicName: "label", isSignal: true, isRequired: false, transformFunction: null }, isOpen: { classPropertyName: "isOpen", publicName: "isOpen", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { isOpen: "isOpenChange" }, host: { classAttribute: "et-accordion" }, providers: [{ provide: ACCORDION_COMPONENT, useExisting: AccordionComponent }, provideIcons(CHEVRON_ICON)], queries: [{ propertyName: "templateLabel", first: true, predicate: ACCORDION_LABEL_WRAPPER_DIRECTIVE, descendants: true, isSignal: true }, { propertyName: "templateHint", first: true, predicate: ACCORDION_HINT_WRAPPER_DIRECTIVE, descendants: true, isSignal: true }], ngImport: i0, template: "<div class=\"et-accordion-container\">\n  <h3 class=\"et-accordion-header-wrapper\">\n    <button\n      [disabled]=\"disabled()\"\n      [id]=\"HEADER_ID\"\n      [attr.aria-controls]=\"BODY_ID\"\n      [attr.aria-expanded]=\"isOpen()\"\n      [class.et-accordion-has-hint]=\"!!templateHint()\"\n      (click)=\"toggleAccordionOpen()\"\n      class=\"et-accordion-header\"\n      type=\"button\"\n    >\n      <div>\n        @if (templateLabel(); as templateLabel) {\n          <ng-template [cdkPortalOutlet]=\"templateLabel\" />\n        } @else {\n          <span et-accordion-label>{{ label() }} </span>\n        }\n      </div>\n\n      @if (templateHint(); as templateHint) {\n        <ng-template [cdkPortalOutlet]=\"templateHint\" />\n      }\n      <i etIcon=\"et-chevron\"> </i>\n    </button>\n  </h3>\n\n  <div\n    [@animateOpenClose]=\"isOpen() ? 'open' : 'close'\"\n    [attr.aria-labelledby]=\"HEADER_ID\"\n    [id]=\"BODY_ID\"\n    class=\"et-accordion-body\"\n    role=\"region\"\n  >\n    <div class=\"et-accordion-body-container\"><ng-content /></div>\n  </div>\n\n  <hr class=\"et-accordion-separator\" />\n</div>\n", styles: [":where(.et-accordion){--chevron-size: 15px}.et-accordion .et-accordion-container{position:relative;z-index:1}.et-accordion .et-icon--et-chevron{display:block;transform:rotate(180deg);transition:transform .3s var(--ease-5);inline-size:var(--chevron-size);block-size:var(--chevron-size)}.et-accordion [aria-expanded=true] .et-icon--et-chevron{transform:rotate(0)}.et-accordion .et-accordion-header{display:grid;grid-template-columns:1fr auto;inline-size:100%;block-size:100%;text-align:left;background-color:transparent;border:none;align-items:center;padding:0;gap:15px}.et-accordion .et-accordion-header:not(:disabled){cursor:pointer}.et-accordion .et-accordion-header.et-accordion-has-hint{grid-template-columns:1fr auto auto}.et-accordion .et-accordion-header-wrapper{margin:0}.et-accordion .et-accordion-body{overflow:hidden}.et-accordion .et-accordion-separator{position:relative;z-index:-1}\n"], dependencies: [{ kind: "directive", type: AccordionLabelDirective, selector: "[et-accordion-label]" }, { kind: "ngmodule", type: PortalModule }, { kind: "directive", type: i2.CdkPortalOutlet, selector: "[cdkPortalOutlet]", inputs: ["cdkPortalOutlet"], outputs: ["attached"], exportAs: ["cdkPortalOutlet"] }, { kind: "directive", type: IconDirective, selector: "[etIcon]", inputs: ["etIcon", "allowHardcodedColor"] }], animations: [accordionAnimations.animateOpenClose], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: AccordionComponent, decorators: [{
             type: Component,
             args: [{ selector: 'et-accordion', encapsulation: ViewEncapsulation.None, changeDetection: ChangeDetectionStrategy.OnPush, providers: [{ provide: ACCORDION_COMPONENT, useExisting: AccordionComponent }, provideIcons(CHEVRON_ICON)], imports: [AccordionLabelDirective, PortalModule, IconDirective], animations: [accordionAnimations.animateOpenClose], host: {
                         class: 'et-accordion',
-                    }, template: "<div class=\"et-accordion-container\">\n  <h3 class=\"et-accordion-header-wrapper\">\n    <button\n      [disabled]=\"disabled()\"\n      [id]=\"HEADER_ID\"\n      [attr.aria-controls]=\"BODY_ID\"\n      [attr.aria-expanded]=\"isOpen()\"\n      [class.et-accordion-has-hint]=\"!!templateHint\"\n      (click)=\"toggleAccordionOpen()\"\n      class=\"et-accordion-header\"\n      type=\"button\"\n    >\n      <div>\n        @if (templateLabel(); as templateLabel) {\n          <ng-template [cdkPortalOutlet]=\"templateLabel\" />\n        } @else {\n          <span et-accordion-label>{{ label() }} </span>\n        }\n      </div>\n\n      @if (templateHint(); as templateHint) {\n        <ng-template [cdkPortalOutlet]=\"templateHint\" />\n      }\n\n      <i etIcon=\"et-chevron\"> </i>\n    </button>\n  </h3>\n  <div\n    [@animateOpenClose]=\"isOpen() ? 'open' : 'close'\"\n    [attr.aria-labelledby]=\"HEADER_ID\"\n    [id]=\"BODY_ID\"\n    class=\"et-accordion-body\"\n    role=\"region\"\n  >\n    <div class=\"et-accordion-body-container\">\n      <ng-content />\n    </div>\n  </div>\n  <hr class=\"et-accordion-separator\" />\n</div>\n", styles: [":where(.et-accordion){--chevron-size: 15px}.et-accordion .et-accordion-container{position:relative;z-index:1}.et-accordion .et-icon--et-chevron{display:block;transform:rotate(180deg);transition:transform .3s var(--ease-5);inline-size:var(--chevron-size);block-size:var(--chevron-size)}.et-accordion [aria-expanded=true] .et-icon--et-chevron{transform:rotate(0)}.et-accordion .et-accordion-header{display:grid;grid-template-columns:1fr auto;inline-size:100%;block-size:100%;text-align:left;background-color:transparent;border:none;align-items:center;padding:0;gap:15px}.et-accordion .et-accordion-header:not(:disabled){cursor:pointer}.et-accordion .et-accordion-header.et-accordion-has-hint{grid-template-columns:1fr auto auto}.et-accordion .et-accordion-header-wrapper{margin:0}.et-accordion .et-accordion-body{overflow:hidden}.et-accordion .et-accordion-separator{position:relative;z-index:-1}\n"] }]
+                    }, template: "<div class=\"et-accordion-container\">\n  <h3 class=\"et-accordion-header-wrapper\">\n    <button\n      [disabled]=\"disabled()\"\n      [id]=\"HEADER_ID\"\n      [attr.aria-controls]=\"BODY_ID\"\n      [attr.aria-expanded]=\"isOpen()\"\n      [class.et-accordion-has-hint]=\"!!templateHint()\"\n      (click)=\"toggleAccordionOpen()\"\n      class=\"et-accordion-header\"\n      type=\"button\"\n    >\n      <div>\n        @if (templateLabel(); as templateLabel) {\n          <ng-template [cdkPortalOutlet]=\"templateLabel\" />\n        } @else {\n          <span et-accordion-label>{{ label() }} </span>\n        }\n      </div>\n\n      @if (templateHint(); as templateHint) {\n        <ng-template [cdkPortalOutlet]=\"templateHint\" />\n      }\n      <i etIcon=\"et-chevron\"> </i>\n    </button>\n  </h3>\n\n  <div\n    [@animateOpenClose]=\"isOpen() ? 'open' : 'close'\"\n    [attr.aria-labelledby]=\"HEADER_ID\"\n    [id]=\"BODY_ID\"\n    class=\"et-accordion-body\"\n    role=\"region\"\n  >\n    <div class=\"et-accordion-body-container\"><ng-content /></div>\n  </div>\n\n  <hr class=\"et-accordion-separator\" />\n</div>\n", styles: [":where(.et-accordion){--chevron-size: 15px}.et-accordion .et-accordion-container{position:relative;z-index:1}.et-accordion .et-icon--et-chevron{display:block;transform:rotate(180deg);transition:transform .3s var(--ease-5);inline-size:var(--chevron-size);block-size:var(--chevron-size)}.et-accordion [aria-expanded=true] .et-icon--et-chevron{transform:rotate(0)}.et-accordion .et-accordion-header{display:grid;grid-template-columns:1fr auto;inline-size:100%;block-size:100%;text-align:left;background-color:transparent;border:none;align-items:center;padding:0;gap:15px}.et-accordion .et-accordion-header:not(:disabled){cursor:pointer}.et-accordion .et-accordion-header.et-accordion-has-hint{grid-template-columns:1fr auto auto}.et-accordion .et-accordion-header-wrapper{margin:0}.et-accordion .et-accordion-body{overflow:hidden}.et-accordion .et-accordion-separator{position:relative;z-index:-1}\n"] }]
         }], ctorParameters: () => [] });
 
 class AccordionGroupComponent {
@@ -1032,7 +1032,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.3", ngImpor
 
 const BracketImports = [BracketComponent, BracketMatchComponent, BracketRoundHeaderComponent];
 
-const FALLBACK_MATCH_POSITION = -1;
 const TOURNAMENT_MODE = {
     SINGLE_ELIMINATION: 'single-elimination',
     DOUBLE_ELIMINATION: 'double-elimination',
@@ -1040,6 +1039,45 @@ const TOURNAMENT_MODE = {
     SWISS: 'swiss',
     SWISS_WITH_ELIMINATION: 'swiss-with-elimination',
 };
+
+const canRenderLayoutInTournamentMode = (layout, mode) => {
+    switch (mode) {
+        case TOURNAMENT_MODE.SINGLE_ELIMINATION:
+            return layout === BRACKET_DATA_LAYOUT.LEFT_TO_RIGHT || layout === BRACKET_DATA_LAYOUT.MIRRORED;
+        default:
+            return layout === BRACKET_DATA_LAYOUT.LEFT_TO_RIGHT;
+    }
+};
+const BRACKET_DATA_LAYOUT = {
+    LEFT_TO_RIGHT: 'left-to-right',
+    // Currently only supported in single elimination brackets. Will throw an error if used in other bracket types
+    MIRRORED: 'mirrored',
+};
+
+class BracketMap extends Map {
+    constructor() {
+        super();
+    }
+    getOrThrow(key) {
+        const value = super.get(key);
+        if (value === undefined) {
+            throw new Error(`Value for key ${key} not found in bracket map`);
+        }
+        return value;
+    }
+    first() {
+        return this.values().next().value;
+    }
+    last() {
+        const values = Array.from(this.values());
+        return values.length > 0 ? values[values.length - 1] : undefined;
+    }
+}
+
+const BRACKET_ROUND_MIRROR_TYPE = {
+    LEFT: 'left',
+    RIGHT: 'right',
+};
 const COMMON_BRACKET_ROUND_TYPE = {
     THIRD_PLACE: 'third-place',
     FINAL: 'final',
@@ -1058,10 +1096,283 @@ const SWISS_BRACKET_ROUND_TYPE = {
 const GROUP_BRACKET_ROUND_TYPE = {
     GROUP: 'group',
 };
-const BRACKET_ROUND_MIRROR_TYPE = {
-    LEFT: 'left',
-    RIGHT: 'right',
+const createRoundsMapBase = (source, options) => {
+    const map = new BracketMap();
+    const shouldSplitRoundsInTwo = options.layout === BRACKET_DATA_LAYOUT.MIRRORED;
+    const isDoubleElimination = source.mode === TOURNAMENT_MODE.DOUBLE_ELIMINATION;
+    let currentUpperBracketIndex = 0;
+    let currentLowerBracketIndex = 0;
+    const splitRoundsRest = [];
+    for (const [roundIndex, round] of source.rounds.entries()) {
+        const isUpperBracket = round.type === DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE.UPPER_BRACKET;
+        const isLowerBracket = round.type === DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE.LOWER_BRACKET;
+        const isCommonDoubleEliminationRound = !isUpperBracket && !isLowerBracket && isDoubleElimination;
+        const matches = source.matches.filter((m) => m.roundId === round.id);
+        const roundId = round.id;
+        const shouldSplitRound = shouldSplitRoundsInTwo && matches.length % 2 === 0;
+        const isFirstRound = roundIndex === 0;
+        const isLastRound = roundIndex === source.rounds.length - 1;
+        const isFirstOfType = source.rounds.findIndex((r) => r.type === round.type) === roundIndex;
+        const isLastOfType = source.rounds
+            .slice()
+            .reverse()
+            .findIndex((r) => r.type === round.type) ===
+            source.rounds.length - roundIndex - 1;
+        if (shouldSplitRound) {
+            const firstHalfRoundId = `${roundId}--half-1`;
+            const secondHalfRoundId = `${roundId}--half-2`;
+            const firstHalfMatchesMaxIndex = matches.length / 2 - 1;
+            const bracketRoundFirstHalf = {
+                type: round.type,
+                id: firstHalfRoundId,
+                logicalIndex: isLowerBracket || isCommonDoubleEliminationRound ? currentLowerBracketIndex : currentUpperBracketIndex,
+                data: round.data,
+                position: ((isLowerBracket || isCommonDoubleEliminationRound
+                    ? currentLowerBracketIndex
+                    : currentUpperBracketIndex) + 1),
+                name: round.name,
+                matchCount: matches.length / 2,
+                matchIds: matches.slice(0, firstHalfMatchesMaxIndex + 1).map((m) => m.id),
+                mirrorRoundType: BRACKET_ROUND_MIRROR_TYPE.LEFT,
+                isFirstRound,
+                isLastRound,
+                isFirstOfType,
+                isLastOfType,
+            };
+            const bracketRoundSecondHalf = {
+                type: round.type,
+                id: secondHalfRoundId,
+                logicalIndex: -1,
+                data: round.data,
+                position: -1,
+                name: round.name,
+                matchCount: matches.length / 2,
+                matchIds: matches.slice(firstHalfMatchesMaxIndex + 1).map((m) => m.id),
+                mirrorRoundType: BRACKET_ROUND_MIRROR_TYPE.RIGHT,
+                isFirstRound,
+                isLastRound,
+                isFirstOfType,
+                isLastOfType,
+            };
+            map.set(firstHalfRoundId, bracketRoundFirstHalf);
+            splitRoundsRest.unshift(bracketRoundSecondHalf);
+        }
+        else {
+            const bracketRound = {
+                type: round.type,
+                id: roundId,
+                logicalIndex: isLowerBracket || isCommonDoubleEliminationRound ? currentLowerBracketIndex : currentUpperBracketIndex,
+                data: round.data,
+                position: ((isLowerBracket || isCommonDoubleEliminationRound
+                    ? currentLowerBracketIndex
+                    : currentUpperBracketIndex) + 1),
+                name: round.name,
+                matchCount: matches.length,
+                matchIds: matches.map((m) => m.id),
+                mirrorRoundType: null,
+                isFirstRound,
+                isLastRound,
+                isFirstOfType,
+                isLastOfType,
+            };
+            map.set(roundId, bracketRound);
+        }
+        if (isLowerBracket || isCommonDoubleEliminationRound) {
+            currentLowerBracketIndex++;
+        }
+        else {
+            currentUpperBracketIndex++;
+        }
+    }
+    if (splitRoundsRest.length) {
+        const lastRound = map.last();
+        if (!lastRound)
+            throw new Error('Last round not found');
+        for (const [splitRoundIndex, splitRound] of splitRoundsRest.entries()) {
+            splitRound.logicalIndex = lastRound.logicalIndex + splitRoundIndex + 1;
+            splitRound.position = (lastRound.position + splitRoundIndex + 1);
+            map.set(splitRound.id, splitRound);
+        }
+    }
+    return map;
+};
+
+const createNewMatchParticipantBase = (source, participantId, match, rounds, matchRoundId, participants) => {
+    if (!participantId)
+        return null;
+    const participantBase = participants.getOrThrow(participantId);
+    const roundBase = rounds.getOrThrow(matchRoundId);
+    const matchIndex = participantBase.matchIds.indexOf(match.id);
+    if (matchIndex === -1)
+        throw new Error(`Match with id ${match.id} not found in participant with id ${participantId}`);
+    const participantSide = match.home === participantId ? 'home' : 'away';
+    const isWinner = match.winner === participantSide;
+    const isLooser = match.winner && match.winner !== participantSide;
+    const isTie = match.status === 'completed' && !match.winner;
+    let winsTilNow = isWinner ? 1 : 0;
+    let lossesTilNow = isLooser ? 1 : 0;
+    let tiesTilNow = isTie ? 1 : 0;
+    for (let i = 0; i < matchIndex; i++) {
+        const previousMatchId = participantBase.matchIds[i];
+        const previousMatch = source.matches.find((m) => m.id === previousMatchId);
+        const myPreviousMatchSide = previousMatch?.home === participantId ? 'home' : previousMatch?.away === participantId ? 'away' : null;
+        if (!previousMatch || !myPreviousMatchSide)
+            continue;
+        const previousIsWinner = previousMatch.winner === myPreviousMatchSide;
+        const previousIsLooser = previousMatch.winner && previousMatch.winner !== myPreviousMatchSide;
+        const previousIsTie = previousMatch.status === 'completed' && !previousMatch.winner;
+        if (previousIsWinner) {
+            winsTilNow++;
+        }
+        else if (previousIsLooser) {
+            lossesTilNow++;
+        }
+        else if (previousIsTie) {
+            tiesTilNow++;
+        }
+    }
+    const hasElimination = source.mode === TOURNAMENT_MODE.SINGLE_ELIMINATION ||
+        source.mode === TOURNAMENT_MODE.DOUBLE_ELIMINATION ||
+        source.mode === TOURNAMENT_MODE.SWISS_WITH_ELIMINATION;
+    // Means the current match is loss and it's the last match of the participant
+    let 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
+    let isEliminationMatch = false;
+    if (hasElimination) {
+        switch (source.mode) {
+            case TOURNAMENT_MODE.SINGLE_ELIMINATION: {
+                isEliminationMatch = true;
+                isEliminated = isLooser ?? false;
+                break;
+            }
+            case TOURNAMENT_MODE.DOUBLE_ELIMINATION: {
+                isEliminationMatch =
+                    roundBase.type === DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE.LOWER_BRACKET ||
+                        roundBase.type === DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE.REVERSE_FINAL ||
+                        roundBase.type === COMMON_BRACKET_ROUND_TYPE.THIRD_PLACE;
+                // Final is only an elimination match if there is no reverse final or there is one and this participant came from the lower bracket
+                if (roundBase.type === COMMON_BRACKET_ROUND_TYPE.FINAL) {
+                    const hasReverseFinal = source.rounds.some((r) => r.type === DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE.REVERSE_FINAL);
+                    if (!hasReverseFinal)
+                        break;
+                    const currentMatchIndex = participantBase.matchIds.indexOf(match.id);
+                    if (currentMatchIndex === -1)
+                        throw new Error(`Match with id ${match.id} not found in participant with id ${participantId}`);
+                    if (currentMatchIndex === 0)
+                        break;
+                    const previousMatchIndex = currentMatchIndex - 1;
+                    const previousMatchId = participantBase.matchIds[previousMatchIndex];
+                    const previousMatch = source.matches.find((m) => m.id === previousMatchId);
+                    if (!previousMatch)
+                        throw new Error(`Previous match with id ${previousMatchId} not found`);
+                    const previousRound = rounds.getOrThrow(previousMatch.roundId);
+                    isEliminationMatch = previousRound.type === DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE.LOWER_BRACKET;
+                }
+                isEliminated = (isEliminationMatch && isLooser) ?? false;
+                break;
+            }
+            case TOURNAMENT_MODE.SWISS_WITH_ELIMINATION: {
+                // In swiss you are eliminated after 3 losses, so we need to track the loss count
+                isEliminationMatch = lossesTilNow >= 2;
+                isEliminated = (isEliminationMatch && isLooser) ?? false;
+            }
+        }
+    }
+    const matchParticipantBase = {
+        ...participantBase,
+        isEliminated,
+        isEliminationMatch,
+        lossCount: lossesTilNow,
+        tieCount: tiesTilNow,
+        winCount: winsTilNow,
+        result: isWinner ? 'win' : isLooser ? 'loss' : isTie ? 'tie' : null,
+        side: participantSide,
+    };
+    return matchParticipantBase;
+};
+
+const createMatchesMapBase = (source, rounds, participants) => {
+    const map = new BracketMap();
+    for (const match of source.matches) {
+        const genericRound = rounds.get(match.roundId);
+        const splitRound = rounds.get(`${match.roundId}--half-1`);
+        const splitRound2 = rounds.get(`${match.roundId}--half-2`);
+        const genericRoundMatchIndex = genericRound?.matchIds.indexOf(match.id) ?? -1;
+        const splitRoundMatchIndex = splitRound?.matchIds.indexOf(match.id) ?? -1;
+        const splitRound2MatchIndex = splitRound2?.matchIds.indexOf(match.id) ?? -1;
+        const roundToUse = genericRoundMatchIndex !== -1
+            ? genericRound
+            : splitRoundMatchIndex !== -1
+                ? splitRound
+                : splitRound2MatchIndex !== -1
+                    ? splitRound2
+                    : null;
+        if (!roundToUse)
+            throw new Error(`Round for match with id ${match.id} not found`);
+        const indexInRound = genericRoundMatchIndex !== -1
+            ? genericRoundMatchIndex
+            : splitRoundMatchIndex !== -1
+                ? splitRoundMatchIndex
+                : splitRound2MatchIndex !== -1
+                    ? splitRound2MatchIndex
+                    : -1;
+        if (indexInRound === -1)
+            throw new Error(`Match with id ${match.id} not found in round with id ${roundToUse.id}`);
+        const home = createNewMatchParticipantBase(source, match.home, match, rounds, roundToUse.id, participants);
+        const away = createNewMatchParticipantBase(source, match.away, match, rounds, roundToUse.id, participants);
+        const winner = match.winner === 'home' ? home : match.winner === 'away' ? away : null;
+        const matchBase = {
+            home,
+            away,
+            data: match.data,
+            id: match.id,
+            indexInRound,
+            position: (indexInRound + 1),
+            roundId: roundToUse?.id,
+            status: match.status,
+            winner,
+            winnerSide: match.winner,
+        };
+        map.set(matchBase.id, matchBase);
+    }
+    return map;
+};
+
+const createParticipantsMapBase = (source) => {
+    const map = new BracketMap();
+    const participantIds = new Set(source.matches
+        .map((m) => [m.home, m.away])
+        .flat()
+        .filter((p) => !!p));
+    for (const [index, participantId] of participantIds.entries()) {
+        const participantBase = {
+            id: participantId,
+            shortId: `p${index}`,
+            matchIds: source.matches
+                .filter((m) => m.home === participantId || m.away === participantId)
+                .map((m) => m.id),
+        };
+        map.set(participantId, participantBase);
+    }
+    return map;
+};
+
+const createNewBracketBase = (source, options) => {
+    if (!canRenderLayoutInTournamentMode(options.layout, source.mode)) {
+        throw new Error(`Cannot render layout ${options.layout} in mode ${source.mode}`);
+    }
+    const participants = createParticipantsMapBase(source);
+    const rounds = createRoundsMapBase(source, options);
+    const matches = createMatchesMapBase(source, rounds, participants);
+    const bracketData = {
+        matches,
+        rounds,
+        participants,
+        mode: source.mode,
+    };
+    return bracketData;
 };
+
 const generateRoundTypeFromEthleteRoundType = (type, tournamentMode, roundMatchCount) => {
     switch (type) {
         case 'normal':
@@ -1122,1029 +1433,976 @@ const generateTournamentModeFormEthleteRounds = (source) => {
             throw new Error(`Unsupported tournament mode: ${firstMatch.matchType}`);
     }
 };
-const canRenderLayoutInTournamentMode = (layout, mode) => {
-    switch (mode) {
-        case TOURNAMENT_MODE.SINGLE_ELIMINATION:
-            return layout === BRACKET_DATA_LAYOUT.LEFT_TO_RIGHT || layout === BRACKET_DATA_LAYOUT.MIRRORED;
-        default:
-            return layout === BRACKET_DATA_LAYOUT.LEFT_TO_RIGHT;
-    }
-};
-const BRACKET_DATA_LAYOUT = {
-    LEFT_TO_RIGHT: 'left-to-right',
-    // Currently only supported in single elimination brackets. Will throw an error if used in other bracket types
-    MIRRORED: 'mirrored',
-};
-const FIRST_ROUNDS_TYPE = {
-    SINGLE: 'single',
-    DOUBLE: 'double',
-};
-const getFirstRounds = (bracketData, roundTypeMap) => {
-    if (bracketData.mode === TOURNAMENT_MODE.DOUBLE_ELIMINATION) {
-        const upper = roundTypeMap.get(DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE.UPPER_BRACKET)?.values().next().value;
-        const lower = roundTypeMap.get(DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE.LOWER_BRACKET)?.values().next().value;
-        if (!upper || !lower)
-            throw new Error('Upper or lower bracket is null');
-        return {
-            type: FIRST_ROUNDS_TYPE.DOUBLE,
-            upper,
-            lower,
+const generateBracketDataForEthlete = (source) => {
+    const tournamentMode = generateTournamentModeFormEthleteRounds(source);
+    const bracketData = {
+        rounds: [],
+        matches: [],
+        mode: tournamentMode,
+    };
+    for (const currentItem of source) {
+        if (bracketData.rounds.some((r) => r.id === 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, currentItem.matches.length);
+        const bracketRound = {
+            type: roundType,
+            id: currentItem.round.id,
+            data: currentItem.round,
+            name: currentItem.round.name || currentItem.round.type,
         };
+        bracketData.rounds.push(bracketRound);
+        for (const match of currentItem.matches) {
+            if (bracketData.matches.some((m) => m.id === match.id)) {
+                throw new Error(`Match with id ${match.id} already exists in the bracket data.`);
+            }
+            const bracketMatch = {
+                id: match.id,
+                data: match,
+                roundId: currentItem.round.id,
+                home: match.home?.id || null,
+                away: match.away?.id || null,
+                winner: match.winningSide,
+                status: match.status === 'published' ? 'completed' : 'pending',
+            };
+            bracketData.matches.push(bracketMatch);
+        }
     }
-    const first = bracketData.rounds.values().next().value;
-    if (!first)
-        throw new Error('First round is null');
-    return {
-        type: FIRST_ROUNDS_TYPE.SINGLE,
-        first,
-    };
+    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);
+
+const generateTournamentModeFormGgData = (source) => {
+    switch (source.mode) {
+        // 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: ${source.mode}`);
     }
-    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));
+const generateRoundTypeFromGgMatch = (tournamentMode, bracketType, // 'winner' | 'looser' | null,
+stageNumber, matchCount) => {
+    switch (tournamentMode) {
+        case 'double-elimination': {
+            switch (stageNumber) {
+                case 1: {
+                    switch (bracketType) {
+                        case 'winner':
+                            return DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE.UPPER_BRACKET;
+                        case 'looser':
+                            return DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE.LOWER_BRACKET;
+                        default:
+                            throw new Error(`Unsupported bracket type: ${bracketType}`);
+                    }
+                }
+                case 2: {
+                    return COMMON_BRACKET_ROUND_TYPE.FINAL;
+                }
+                case 3: {
+                    return DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE.REVERSE_FINAL;
+                }
+                default: {
+                    throw new Error(`Unsupported stage number: ${stageNumber}`);
+                }
+            }
         }
-    }
-    return roundAmountMap;
-};
-const generateRoundRelations = (bracketData) => {
-    const roundRelations = new Map();
-    const allRounds = bracketData.roundIds.map((id) => bracketData.rounds.get(id)).filter((r) => !!r);
-    const upperRounds = allRounds.filter((r) => r.type !== DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE.LOWER_BRACKET);
-    const lowerRounds = allRounds.filter((r) => r.type === DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE.LOWER_BRACKET);
-    const firstUpperRound = upperRounds[0] || null;
-    const firstLowerRound = lowerRounds[0] || null;
-    if (!firstUpperRound)
-        throw new Error('firstUpperRound is null');
-    const hasLowerRounds = lowerRounds.length > 0;
-    const lastLowerRound = lowerRounds[lowerRounds.length - 1] || null;
-    for (const [currentUpperRoundIndex, currentUpperRound] of upperRounds.entries()) {
-        const isLeftToRight = currentUpperRound.mirrorRoundType === null ||
-            currentUpperRound.mirrorRoundType === BRACKET_ROUND_MIRROR_TYPE.LEFT;
-        const relativePreviousUpperRound = upperRounds[currentUpperRoundIndex - 1] || null;
-        const relativeNextUpperRound = upperRounds[currentUpperRoundIndex + 1] || null;
-        const previousUpperRound = isLeftToRight ? relativePreviousUpperRound : relativeNextUpperRound;
-        const nextUpperRound = isLeftToRight ? relativeNextUpperRound : relativePreviousUpperRound;
-        const currentLowerRound = lowerRounds[currentUpperRoundIndex] || null;
-        const previousLowerRound = lowerRounds[currentUpperRoundIndex - 1] || null;
-        const nextLowerRound = lowerRounds[currentUpperRoundIndex + 1] || null;
-        const isLastUpperRound = !nextUpperRound ||
-            (nextUpperRound.mirrorRoundType === BRACKET_ROUND_MIRROR_TYPE.RIGHT &&
-                currentUpperRound.mirrorRoundType === null);
-        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,
-                });
+        case 'single-elimination': {
+            if (matchCount === 1) {
+                return COMMON_BRACKET_ROUND_TYPE.FINAL;
             }
             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 = lowerRounds[lowerRounds.length - 2] || null;
-                const prePreFinalLowerRound = lowerRounds[lowerRounds.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 (currentUpperRound.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,
-                });
+                return SINGLE_ELIMINATION_BRACKET_ROUND_TYPE.SINGLE_ELIMINATION_BRACKET;
             }
         }
-        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,
-                });
-            }
+        default: {
+            throw new Error(`Unsupported tournament mode: ${tournamentMode}`);
         }
     }
-    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;
-            }
+const generateBracketDataForGg = (source) => {
+    const tournamentMode = generateTournamentModeFormGgData(source);
+    const bracketData = {
+        rounds: [],
+        matches: [],
+        mode: tournamentMode,
+    };
+    const matchesGrouped = new Map();
+    for (const match of source.matches) {
+        const roundId = `${match.roundNumber}-${match.stageNumber}-${match.bracketType || null}`;
+        if (!matchesGrouped.has(roundId)) {
+            matchesGrouped.set(roundId, []);
         }
+        matchesGrouped.get(roundId)?.push(match);
     }
-    return matchRelations;
+    for (const [roundId, matches] of matchesGrouped.entries()) {
+        const firstMatch = matches[0];
+        if (!firstMatch)
+            throw new Error('First match not found');
+        const roundType = generateRoundTypeFromGgMatch(tournamentMode, firstMatch.bracketType, firstMatch.stageNumber, matches.length);
+        const bracketRound = {
+            type: roundType,
+            id: roundId,
+            data: null,
+            name: firstMatch.roundTitle,
+        };
+        bracketData.rounds.push(bracketRound);
+        for (const match of matches) {
+            const bracketMatch = {
+                id: match.id,
+                data: match,
+                roundId: roundId,
+                home: match.homeMatchSide.participant?.id || null,
+                away: match.awayMatchSide.participant?.id || null,
+                winner: match.winningSide,
+                status: match.status === 'completed' ? 'completed' : 'pending',
+            };
+            bracketData.matches.push(bracketMatch);
+        }
+    }
+    return bracketData;
 };
-const generateMatchRelationPositions = (currentRelation, match) => {
-    switch (currentRelation.type) {
-        case 'nothing-to-one': {
+
+class NewBracketDefaultMatchComponent {
+    constructor() {
+        this.bracketRound = input.required();
+        this.bracketMatch = input.required();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: NewBracketDefaultMatchComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "20.0.3", 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: "20.0.3", 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: "20.0.3", ngImport: i0, type: NewBracketDefaultRoundHeaderComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "20.0.3", 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: "20.0.3", 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 FALLBACK_MATCH_RELATION_POSITION = -1;
+const generateMatchPosition = (match, factor) => Math.ceil(match.position * factor);
+const generateMatchRelationPositions = (relation, match) => {
+    switch (relation.type) {
+        case 'nothing-to-one':
             return {
-                nextRoundMatchPosition: generateMatchPosition(match, currentRelation.nextRoundMatchFactor),
-                previousUpperRoundMatchPosition: FALLBACK_MATCH_POSITION,
-                previousLowerRoundMatchPosition: FALLBACK_MATCH_POSITION,
+                nextRoundMatchPosition: generateMatchPosition(match, relation.nextRoundMatchFactor),
+                previousUpperRoundMatchPosition: FALLBACK_MATCH_RELATION_POSITION,
+                previousLowerRoundMatchPosition: FALLBACK_MATCH_RELATION_POSITION,
             };
-        }
         case 'one-to-nothing': {
-            const previousRoundHasDoubleTheMatchCount = currentRelation.previousRoundMatchFactor === 2;
-            const doubleUpperMatchCountShift = previousRoundHasDoubleTheMatchCount ? 1 : 0;
+            const double = relation.previousRoundMatchFactor === 2 ? 1 : 0;
             return {
-                nextRoundMatchPosition: FALLBACK_MATCH_POSITION,
-                previousUpperRoundMatchPosition: (generateMatchPosition(match, currentRelation.previousRoundMatchFactor) -
-                    doubleUpperMatchCountShift),
-                previousLowerRoundMatchPosition: generateMatchPosition(match, currentRelation.previousRoundMatchFactor),
+                nextRoundMatchPosition: FALLBACK_MATCH_RELATION_POSITION,
+                previousUpperRoundMatchPosition: (generateMatchPosition(match, relation.previousRoundMatchFactor) -
+                    double),
+                previousLowerRoundMatchPosition: generateMatchPosition(match, relation.previousRoundMatchFactor),
             };
         }
         case 'one-to-one': {
-            const previousRoundHasDoubleTheMatchCount = currentRelation.previousRoundMatchFactor === 2;
-            const doubleUpperMatchCountShift = previousRoundHasDoubleTheMatchCount ? 1 : 0;
+            const double = relation.previousRoundMatchFactor === 2 ? 1 : 0;
             return {
-                nextRoundMatchPosition: generateMatchPosition(match, currentRelation.nextRoundMatchFactor),
-                previousUpperRoundMatchPosition: (generateMatchPosition(match, currentRelation.previousRoundMatchFactor) -
-                    doubleUpperMatchCountShift),
-                previousLowerRoundMatchPosition: generateMatchPosition(match, currentRelation.previousRoundMatchFactor),
+                nextRoundMatchPosition: generateMatchPosition(match, relation.nextRoundMatchFactor),
+                previousUpperRoundMatchPosition: (generateMatchPosition(match, relation.previousRoundMatchFactor) -
+                    double),
+                previousLowerRoundMatchPosition: generateMatchPosition(match, relation.previousRoundMatchFactor),
             };
         }
-        case 'two-to-one': {
+        case 'two-to-one':
             return {
-                nextRoundMatchPosition: generateMatchPosition(match, currentRelation.nextRoundMatchFactor),
-                previousUpperRoundMatchPosition: generateMatchPosition(match, currentRelation.previousUpperRoundMatchFactor),
-                previousLowerRoundMatchPosition: generateMatchPosition(match, currentRelation.previousLowerRoundMatchFactor),
+                nextRoundMatchPosition: generateMatchPosition(match, relation.nextRoundMatchFactor),
+                previousUpperRoundMatchPosition: generateMatchPosition(match, relation.previousUpperRoundMatchFactor),
+                previousLowerRoundMatchPosition: generateMatchPosition(match, relation.previousLowerRoundMatchFactor),
             };
-        }
-        case 'two-to-nothing': {
+        case 'two-to-nothing':
             return {
-                nextRoundMatchPosition: FALLBACK_MATCH_POSITION,
-                previousUpperRoundMatchPosition: generateMatchPosition(match, currentRelation.previousUpperRoundMatchFactor),
-                previousLowerRoundMatchPosition: generateMatchPosition(match, currentRelation.previousLowerRoundMatchFactor),
+                nextRoundMatchPosition: FALLBACK_MATCH_RELATION_POSITION,
+                previousUpperRoundMatchPosition: generateMatchPosition(match, relation.previousUpperRoundMatchFactor),
+                previousLowerRoundMatchPosition: generateMatchPosition(match, relation.previousLowerRoundMatchFactor),
             };
-        }
     }
 };
-const generateMatchPosition = (match, factor) => {
-    return Math.ceil(match.position * factor);
+const createNothingToOneRelation$1 = (params) => {
+    const { match, relation, matchPositionMaps, nextRoundMatchPosition } = params;
+    const nextMatch = matchPositionMaps.get(relation.nextRound.id)?.get(nextRoundMatchPosition);
+    if (!nextMatch)
+        throw new Error('Next round match not found');
+    return {
+        type: 'nothing-to-one',
+        currentMatch: match,
+        currentRound: relation.currentRound,
+        nextMatch,
+        nextRound: relation.nextRound,
+    };
 };
-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;
-        }
+const createOneToNothingOrTwoToNothingRelation = (params) => {
+    const { match, relation, matchPositionMaps, previousUpperRoundMatchPosition, previousLowerRoundMatchPosition } = params;
+    const previousUpperMatch = matchPositionMaps.get(relation.previousRound.id)?.get(previousUpperRoundMatchPosition);
+    const previousLowerMatch = matchPositionMaps.get(relation.previousRound.id)?.get(previousLowerRoundMatchPosition);
+    if (!previousUpperMatch)
+        throw new Error('Previous round match not found');
+    if (previousUpperRoundMatchPosition !== previousLowerRoundMatchPosition) {
+        if (!previousLowerMatch)
+            throw new Error('Previous lower round match not found');
+        return {
+            type: 'two-to-nothing',
+            currentMatch: match,
+            currentRound: relation.currentRound,
+            previousUpperMatch,
+            previousUpperRound: relation.previousRound,
+            previousLowerMatch,
+            previousLowerRound: relation.previousRound,
+        };
+    }
+    else {
+        return {
+            type: 'one-to-nothing',
+            currentMatch: match,
+            currentRound: relation.currentRound,
+            previousMatch: previousUpperMatch,
+            previousRound: relation.previousRound,
+        };
+    }
+};
+const createOneToOneOrTwoToOneRelation = (params) => {
+    const { match, relation, matchPositionMaps, nextRoundMatchPosition, previousUpperRoundMatchPosition, previousLowerRoundMatchPosition, } = params;
+    const nextMatch = matchPositionMaps.get(relation.nextRound.id)?.get(nextRoundMatchPosition);
+    const previousUpperMatch = matchPositionMaps.get(relation.previousRound.id)?.get(previousUpperRoundMatchPosition);
+    const previousLowerMatch = matchPositionMaps.get(relation.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');
+    if (previousUpperRoundMatchPosition === previousLowerRoundMatchPosition) {
+        return {
+            type: 'one-to-one',
+            currentMatch: match,
+            currentRound: relation.currentRound,
+            previousMatch: previousUpperMatch,
+            previousRound: relation.previousRound,
+            nextMatch,
+            nextRound: relation.nextRound,
+        };
+    }
+    else {
+        return {
+            type: 'two-to-one',
+            currentMatch: match,
+            currentRound: relation.currentRound,
+            previousUpperMatch,
+            previousUpperRound: relation.previousRound,
+            previousLowerMatch,
+            previousLowerRound: relation.previousRound,
+            nextMatch,
+            nextRound: relation.nextRound,
+        };
+    }
+};
+const createTwoToOneRelation$1 = (params) => {
+    const { match, relation, matchPositionMaps, nextRoundMatchPosition, previousUpperRoundMatchPosition, previousLowerRoundMatchPosition, } = params;
+    const nextMatch = matchPositionMaps.get(relation.nextRound.id)?.get(nextRoundMatchPosition);
+    const previousUpperMatch = matchPositionMaps
+        .get(relation.previousUpperRound.id)
+        ?.get(previousUpperRoundMatchPosition);
+    const previousLowerMatch = matchPositionMaps
+        .get(relation.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');
+    return {
+        type: 'two-to-one',
+        currentMatch: match,
+        currentRound: relation.currentRound,
+        previousUpperMatch,
+        previousUpperRound: relation.previousUpperRound,
+        previousLowerMatch,
+        previousLowerRound: relation.previousLowerRound,
+        nextMatch,
+        nextRound: relation.nextRound,
+    };
+};
+const createTwoToNothingRelation$1 = (params) => {
+    const { match, relation, matchPositionMaps, previousUpperRoundMatchPosition, previousLowerRoundMatchPosition } = params;
+    const previousUpperMatch = matchPositionMaps
+        .get(relation.previousUpperRound.id)
+        ?.get(previousUpperRoundMatchPosition);
+    const previousLowerMatch = matchPositionMaps
+        .get(relation.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');
+    return {
+        type: 'two-to-nothing',
+        currentMatch: match,
+        currentRound: relation.currentRound,
+        previousUpperMatch,
+        previousUpperRound: relation.previousUpperRound,
+        previousLowerMatch,
+        previousLowerRound: relation.previousUpperRound,
+    };
+};
+const generateMatchRelationsNew = (bracketData) => {
+    const matchRelations = [];
+    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);
+    }
+    for (const match of bracketData.matches.values()) {
+        const relation = match.round.relation;
+        const { nextRoundMatchPosition, previousUpperRoundMatchPosition, previousLowerRoundMatchPosition } = generateMatchRelationPositions(relation, match);
         switch (relation.type) {
             case 'nothing-to-one':
-                console.log(`START: ${round.name} -> ${relation.nextRound.name} (F: ${relation.nextRoundMatchFactor})`);
+                matchRelations.push(createNothingToOneRelation$1({
+                    match,
+                    relation,
+                    matchPositionMaps,
+                    nextRoundMatchPosition,
+                }));
                 break;
             case 'one-to-nothing':
-                console.log(`${relation.previousRound.name} (F: ${relation.previousRoundMatchFactor}) <- ENDING: ${round.name}`);
+                matchRelations.push(createOneToNothingOrTwoToNothingRelation({
+                    match,
+                    relation,
+                    matchPositionMaps,
+                    previousUpperRoundMatchPosition,
+                    previousLowerRoundMatchPosition,
+                }));
                 break;
             case 'one-to-one':
-                console.log(`${relation.previousRound.name} (F: ${relation.previousRoundMatchFactor}) <- ${round.name} -> ${relation.nextRound.name} (F: ${relation.nextRoundMatchFactor})`);
+                matchRelations.push(createOneToOneOrTwoToOneRelation({
+                    match,
+                    relation,
+                    matchPositionMaps,
+                    nextRoundMatchPosition,
+                    previousUpperRoundMatchPosition,
+                    previousLowerRoundMatchPosition,
+                }));
                 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})`);
+                matchRelations.push(createTwoToOneRelation$1({
+                    match,
+                    relation,
+                    matchPositionMaps,
+                    nextRoundMatchPosition,
+                    previousUpperRoundMatchPosition,
+                    previousLowerRoundMatchPosition,
+                }));
                 break;
             case 'two-to-nothing':
-                console.log(`MERGER: ${relation.previousUpperRound.name} (F: ${relation.previousUpperRoundMatchFactor}) AND ${relation.previousLowerRound.name} (F: ${relation.previousLowerRoundMatchFactor}) <- ENDING: ${round.name}`);
+                matchRelations.push(createTwoToNothingRelation$1({
+                    match,
+                    relation,
+                    matchPositionMaps,
+                    previousUpperRoundMatchPosition,
+                    previousLowerRoundMatchPosition,
+                }));
                 break;
         }
     }
+    return matchRelations;
 };
-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.winnerSide === matchParticipantMatch.side;
-            const isLooser = matchParticipantMatch.bracketMatch.winnerSide &&
-                matchParticipantMatch.bracketMatch.winnerSide !== 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;
+
+const calculateMatchFactor = (numeratorRound, denominatorRound) => numeratorRound.matchCount / denominatorRound.matchCount;
+const createNothingToOneRelation = (params) => ({
+    type: 'nothing-to-one',
+    currentRound: params.currentRound,
+    nextRound: params.nextRound,
+    nextRoundMatchFactor: calculateMatchFactor(params.nextRound, params.currentRound),
+});
+const createOneToNothingRelation = (params) => ({
+    type: 'one-to-nothing',
+    currentRound: params.currentRound,
+    previousRound: params.previousRound,
+    previousRoundMatchFactor: calculateMatchFactor(params.previousRound, params.currentRound),
+    rootRoundMatchFactor: calculateMatchFactor(params.rootRound, params.currentRound),
+});
+const createOneToOneRelation = (params) => ({
+    type: 'one-to-one',
+    currentRound: params.currentRound,
+    previousRound: params.previousRound,
+    nextRound: params.nextRound,
+    nextRoundMatchFactor: calculateMatchFactor(params.nextRound, params.currentRound),
+    previousRoundMatchFactor: calculateMatchFactor(params.previousRound, params.currentRound),
+    rootRoundMatchFactor: calculateMatchFactor(params.rootRound, params.currentRound),
+});
+const createTwoToOneRelation = (params) => ({
+    type: 'two-to-one',
+    currentRound: params.currentRound,
+    previousUpperRound: params.previousUpperRound,
+    previousLowerRound: params.previousLowerRound,
+    nextRound: params.nextRound,
+    nextRoundMatchFactor: calculateMatchFactor(params.nextRound, params.currentRound),
+    previousUpperRoundMatchFactor: calculateMatchFactor(params.previousUpperRound, params.currentRound),
+    previousLowerRoundMatchFactor: calculateMatchFactor(params.previousLowerRound, params.currentRound),
+    upperRootRoundMatchFactor: calculateMatchFactor(params.firstUpperRound, params.currentRound),
+    lowerRootRoundMatchFactor: calculateMatchFactor(params.firstLowerRound, params.currentRound),
+});
+const createTwoToNothingRelation = (params) => ({
+    type: 'two-to-nothing',
+    currentRound: params.currentRound,
+    previousUpperRound: params.previousUpperRound,
+    previousLowerRound: params.previousLowerRound,
+    previousUpperRoundMatchFactor: calculateMatchFactor(params.previousUpperRound, params.currentRound),
+    previousLowerRoundMatchFactor: calculateMatchFactor(params.previousLowerRound, params.currentRound),
+    upperRootRoundMatchFactor: calculateMatchFactor(params.firstUpperRound, params.currentRound),
+    lowerRootRoundMatchFactor: calculateMatchFactor(params.firstLowerRound, params.currentRound),
+});
+const getNavigationContext = (params) => {
+    const { upperRounds, currentUpperRoundIndex } = params;
+    const currentUpperRound = upperRounds[currentUpperRoundIndex];
+    if (!currentUpperRound)
+        throw new Error('currentUpperRound is null');
+    const isLeftToRight = !currentUpperRound.mirrorRoundType || currentUpperRound.mirrorRoundType === BRACKET_ROUND_MIRROR_TYPE.LEFT;
+    const relativePrevious = upperRounds[currentUpperRoundIndex - 1] || null;
+    const relativeNext = upperRounds[currentUpperRoundIndex + 1] || null;
+    const previousUpperRound = isLeftToRight ? relativePrevious : relativeNext;
+    const nextUpperRound = isLeftToRight ? relativeNext : relativePrevious;
+    const isLastUpperRound = !nextUpperRound ||
+        (nextUpperRound.mirrorRoundType === BRACKET_ROUND_MIRROR_TYPE.RIGHT && !currentUpperRound.mirrorRoundType);
+    const isFinal = currentUpperRound.type === COMMON_BRACKET_ROUND_TYPE.FINAL;
+    return {
+        currentUpperRound,
+        previousUpperRound,
+        nextUpperRound,
+        isLastUpperRound,
+        isFinal,
     };
-    // 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 handleFinalRound = (params) => {
+    const { relations, currentUpperRound, previousUpperRound, nextUpperRound, lowerRounds, currentUpperRoundIndex, firstUpperRound, firstLowerRound, lastLowerRound, } = params;
+    const currentLowerRound = lowerRounds[currentUpperRoundIndex] || null;
+    const nextLowerRound = lowerRounds[currentUpperRoundIndex + 1] || null;
+    const previousLowerRound = lowerRounds[currentUpperRoundIndex - 1] || null;
+    if (!currentLowerRound)
+        throw new Error('currentLowerRound is null');
+    const isAsyncBracket = currentLowerRound.id !== lastLowerRound.id;
+    const finalLowerRound = isAsyncBracket ? nextLowerRound : currentLowerRound;
+    if (!finalLowerRound)
+        throw new Error('finalLowerRound is null');
+    if (finalLowerRound.id !== lastLowerRound.id)
+        throw new Error('finalLowerRound is not the last lower round');
+    if (nextUpperRound) {
+        relations.push(createTwoToOneRelation({
+            currentRound: currentUpperRound,
+            previousUpperRound,
+            previousLowerRound: finalLowerRound,
+            nextRound: nextUpperRound,
+            firstUpperRound,
+            firstLowerRound,
+        }));
     }
-    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.id) ?? null) : null;
-            const participantAway = match.away ? (matchParticipantMap.get(match.away.id) ?? 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);
+    else {
+        relations.push(createTwoToNothingRelation({
+            currentRound: currentUpperRound,
+            previousUpperRound,
+            previousLowerRound: finalLowerRound,
+            firstUpperRound,
+            firstLowerRound,
+        }));
+    }
+    if (isAsyncBracket) {
+        const preFinalLowerRound = lowerRounds[lowerRounds.length - 2];
+        const prePreFinalLowerRound = lowerRounds[lowerRounds.length - 3] || null;
+        if (!preFinalLowerRound)
+            throw new Error('preFinalLowerRound is null');
+        relations.push(createOneToOneRelation({
+            currentRound: finalLowerRound,
+            previousRound: preFinalLowerRound,
+            nextRound: currentUpperRound,
+            rootRound: firstLowerRound,
+        }));
+        if (prePreFinalLowerRound) {
+            relations.push(createOneToOneRelation({
+                currentRound: preFinalLowerRound,
+                previousRound: prePreFinalLowerRound,
+                nextRound: finalLowerRound,
+                rootRound: firstLowerRound,
+            }));
         }
-        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');
-            }
+        else {
+            relations.push(createNothingToOneRelation({
+                currentRound: preFinalLowerRound,
+                nextRound: finalLowerRound,
+            }));
         }
-        roundNumber++;
     }
-    return roundsWithSwissGroups;
+    else {
+        if (!previousLowerRound)
+            throw new Error('previousLowerRound is null');
+        relations.push(createOneToOneRelation({
+            currentRound: finalLowerRound,
+            previousRound: previousLowerRound,
+            nextRound: currentUpperRound,
+            rootRound: firstLowerRound,
+        }));
+    }
 };
-const generateBracketDataForEthlete = (source) => {
-    const tournamentMode = generateTournamentModeFormEthleteRounds(source);
-    const bracketData = {
-        rounds: [],
-        matches: [],
-        mode: tournamentMode,
-    };
-    for (const currentItem of source) {
-        if (bracketData.rounds.some((r) => r.id === 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, currentItem.matches.length);
-        const bracketRound = {
-            type: roundType,
-            id: currentItem.round.id,
-            data: currentItem.round,
-            name: currentItem.round.name || currentItem.round.type,
-        };
-        bracketData.rounds.push(bracketRound);
-        for (const match of currentItem.matches) {
-            if (bracketData.matches.some((m) => m.id === match.id)) {
-                throw new Error(`Match with id ${match.id} already exists in the bracket data.`);
-            }
-            const bracketMatch = {
-                id: match.id,
-                data: match,
-                roundId: currentItem.round.id,
-                home: match.home?.id || null,
-                away: match.away?.id || null,
-                winner: match.winningSide,
-                status: match.status === 'published' ? 'completed' : 'pending',
-            };
-            bracketData.matches.push(bracketMatch);
-        }
+const handleFirstRound = (params) => {
+    const { relations, currentUpperRound, nextUpperRound, lowerRounds, currentUpperRoundIndex } = params;
+    relations.push(createNothingToOneRelation({
+        currentRound: currentUpperRound,
+        nextRound: nextUpperRound,
+    }));
+    const currentLowerRound = lowerRounds[currentUpperRoundIndex] || null;
+    const nextLowerRound = lowerRounds[currentUpperRoundIndex + 1] || null;
+    if (currentLowerRound && nextLowerRound) {
+        relations.push(createNothingToOneRelation({
+            currentRound: currentLowerRound,
+            nextRound: nextLowerRound,
+        }));
     }
-    return bracketData;
 };
-const generateAndSetBracketMatchWithParticipants = (match, options) => {
-    const matchId = match.id;
-    const { bracketData, bracketRound, currentIndexInRound, participantCounter } = options;
-    let localParticipantCounter = participantCounter;
-    const bracketMatch = {
-        id: matchId,
-        indexInRound: currentIndexInRound,
-        position: (currentIndexInRound + 1),
-        data: match.data,
-        round: bracketRound,
-        home: null,
-        away: null,
-        status: match.status,
-        winnerSide: match.winner,
-        winner: null,
-    };
-    bracketData.matches.set(matchId, bracketMatch);
-    bracketRound.matches.set(matchId, bracketMatch);
-    const participantIds = [match.home, match.away];
-    for (const [participantIndex, participantId] of participantIds.entries()) {
-        if (!participantId)
-            continue;
-        const side = participantIndex === 0 ? 'home' : 'away';
-        if (!bracketData.participants.has(participantId)) {
-            bracketData.participants.set(participantId, {
-                id: participantId,
-                shortId: `p${localParticipantCounter++}`,
-                name: `${side} ${currentIndexInRound}`,
-                matches: new Map(),
+const handleRegularRound = (params) => {
+    const { relations, currentUpperRound, previousUpperRound, nextUpperRound, lowerRounds, currentUpperRoundIndex, firstUpperRound, firstLowerRound, } = params;
+    relations.push(createOneToOneRelation({
+        currentRound: currentUpperRound,
+        previousRound: previousUpperRound,
+        nextRound: nextUpperRound,
+        rootRound: firstUpperRound,
+    }));
+    const currentLowerRound = lowerRounds[currentUpperRoundIndex] || null;
+    const previousLowerRound = lowerRounds[currentUpperRoundIndex - 1] || null;
+    const nextLowerRound = lowerRounds[currentUpperRoundIndex + 1] || null;
+    if (currentLowerRound &&
+        currentUpperRound.type === DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE.UPPER_BRACKET &&
+        previousLowerRound &&
+        nextLowerRound &&
+        firstLowerRound) {
+        relations.push(createOneToOneRelation({
+            currentRound: currentLowerRound,
+            previousRound: previousLowerRound,
+            nextRound: nextLowerRound,
+            rootRound: firstLowerRound,
+        }));
+    }
+};
+const generateRoundRelationsNew = (bracketData) => {
+    const relations = [];
+    const allRounds = [...bracketData.rounds.values()];
+    const upperRounds = allRounds.filter((r) => r.type !== DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE.LOWER_BRACKET);
+    const lowerRounds = allRounds.filter((r) => r.type === DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE.LOWER_BRACKET);
+    const firstUpperRound = upperRounds[0];
+    const firstLowerRound = lowerRounds[0] || null;
+    const lastLowerRound = lowerRounds[lowerRounds.length - 1] || null;
+    if (!firstUpperRound)
+        throw new Error('No upper rounds found');
+    const hasLowerRounds = lowerRounds.length > 0;
+    for (const [currentUpperRoundIndex] of upperRounds.entries()) {
+        const nav = getNavigationContext({
+            upperRounds,
+            currentUpperRoundIndex,
+        });
+        if (nav.isFinal && hasLowerRounds && lastLowerRound && firstLowerRound && nav.previousUpperRound) {
+            handleFinalRound({
+                relations,
+                currentUpperRound: nav.currentUpperRound,
+                previousUpperRound: nav.previousUpperRound,
+                nextUpperRound: nav.nextUpperRound,
+                lowerRounds,
+                currentUpperRoundIndex,
+                firstUpperRound,
+                firstLowerRound,
+                lastLowerRound,
             });
         }
-        const participantData = bracketData.participants.get(participantId);
-        if (!participantData.matches.has(bracketMatch.id)) {
-            participantData.matches.set(bracketMatch.id, {
-                side: match.home === participantId ? 'home' : 'away',
-                bracketMatch,
+        else if (nav.isLastUpperRound && nav.previousUpperRound) {
+            relations.push(createOneToNothingRelation({
+                currentRound: nav.currentUpperRound,
+                previousRound: nav.previousUpperRound,
+                rootRound: firstUpperRound,
+            }));
+        }
+        else if (nav.currentUpperRound.isFirstRound && nav.nextUpperRound) {
+            handleFirstRound({
+                relations,
+                currentUpperRound: nav.currentUpperRound,
+                nextUpperRound: nav.nextUpperRound,
+                lowerRounds,
+                currentUpperRoundIndex,
             });
         }
-        bracketMatch[side] = participantData;
-        if (bracketMatch.winnerSide === side) {
-            bracketMatch.winner = participantData;
+        else if (nav.previousUpperRound && nav.nextUpperRound) {
+            handleRegularRound({
+                relations,
+                currentUpperRound: nav.currentUpperRound,
+                previousUpperRound: nav.previousUpperRound,
+                nextUpperRound: nav.nextUpperRound,
+                lowerRounds,
+                currentUpperRoundIndex,
+                firstUpperRound,
+                firstLowerRound,
+            });
         }
     }
-    return bracketMatch;
+    return relations;
 };
-const generateBracketData = (source, options) => {
-    if (!canRenderLayoutInTournamentMode(options.layout, source.mode)) {
-        throw new Error(`Cannot render layout ${options.layout} in mode ${source.mode}`);
-    }
-    const shouldSplitRoundsInTwo = options.layout === BRACKET_DATA_LAYOUT.MIRRORED;
-    const bracketData = {
-        matches: new Map(),
-        mode: source.mode,
-        participants: new Map(),
-        rounds: new Map(),
-        roundIds: [],
-        matchIds: [],
-    };
-    let currentUpperBracketIndex = 0;
-    let currentLowerBracketIndex = 0;
-    const splitRoundsRest = [];
-    for (const [roundIndex, round] of source.rounds.entries()) {
-        const isLowerBracket = round.type === DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE.LOWER_BRACKET;
-        const matches = source.matches.filter((m) => m.roundId === round.id);
-        const roundId = round.id;
-        const shouldSplitRound = shouldSplitRoundsInTwo && matches.length % 2 === 0;
-        const isFirstRound = roundIndex === 0;
-        if (shouldSplitRound) {
-            const firstHalfMatchesMaxIndex = matches.length / 2 - 1;
-            const firstHalfRoundId = `${roundId}--half-1`;
-            const secondHalfRoundId = `${roundId}--half-2`;
-            const bracketRoundFirstHalf = {
-                type: round.type,
-                id: firstHalfRoundId,
-                index: isLowerBracket ? currentLowerBracketIndex : currentUpperBracketIndex,
-                data: round.data,
-                position: ((isLowerBracket ? currentLowerBracketIndex : currentUpperBracketIndex) + 1),
-                name: round.name,
-                matchCount: matches.length / 2,
-                matches: new Map(),
-                mirrorRoundType: BRACKET_ROUND_MIRROR_TYPE.LEFT,
-                isFirstRound,
-            };
-            const bracketRoundSecondHalf = {
-                type: round.type,
-                id: secondHalfRoundId,
-                index: -1,
-                data: round.data,
-                position: -1,
-                name: round.name,
-                matchCount: matches.length / 2,
-                matches: new Map(),
-                mirrorRoundType: BRACKET_ROUND_MIRROR_TYPE.RIGHT,
-                isFirstRound,
-            };
-            bracketData.roundIds.push(firstHalfRoundId);
-            bracketData.rounds.set(firstHalfRoundId, bracketRoundFirstHalf);
-            splitRoundsRest.unshift(bracketRoundSecondHalf);
-            for (let index = 0; index <= firstHalfMatchesMaxIndex; index++) {
-                const matchFirst = matches[index];
-                const matchSecond = matches[firstHalfMatchesMaxIndex + 1 + index];
-                if (!matchFirst || !matchSecond)
-                    throw new Error('Match not found');
-                const participantCounter = bracketData.participants.size;
-                const bracketMatchFirst = generateAndSetBracketMatchWithParticipants(matchFirst, {
-                    bracketData,
-                    bracketRound: bracketRoundFirstHalf,
-                    currentIndexInRound: index,
-                    participantCounter,
-                });
-                // The participant counter might have changed after the first half
-                const updatedParticipantCounter = bracketData.participants.size;
-                const bracketMatchSecond = generateAndSetBracketMatchWithParticipants(matchSecond, {
-                    bracketData,
-                    bracketRound: bracketRoundSecondHalf,
-                    currentIndexInRound: index,
-                    participantCounter: updatedParticipantCounter,
-                });
-                bracketData.matchIds.push(bracketMatchFirst.id, bracketMatchSecond.id);
-            }
-        }
-        else {
-            const bracketRound = {
-                type: round.type,
-                id: roundId,
-                index: isLowerBracket ? currentLowerBracketIndex : currentUpperBracketIndex,
-                data: round.data,
-                position: ((isLowerBracket ? currentLowerBracketIndex : currentUpperBracketIndex) + 1),
-                name: round.name,
-                matchCount: matches.length,
-                matches: new Map(),
-                mirrorRoundType: null,
-                isFirstRound,
-            };
-            bracketData.roundIds.push(roundId);
-            bracketData.rounds.set(roundId, bracketRound);
-            let currentIndexInRound = 0;
-            for (const match of matches) {
-                const participantCounter = bracketData.participants.size;
-                const bracketMatch = generateAndSetBracketMatchWithParticipants(match, {
-                    bracketData,
-                    bracketRound,
-                    currentIndexInRound,
-                    participantCounter,
-                });
-                bracketData.matchIds.push(bracketMatch.id);
-                currentIndexInRound++;
-            }
+
+const createNewBracket = (source, options) => {
+    const bracketNewBase = createNewBracketBase(source, options);
+    const rounds = new BracketMap();
+    const roundsByType = new BracketMap();
+    for (const roundBase of bracketNewBase.rounds.values()) {
+        const newRound = {
+            ...roundBase,
+            matches: new BracketMap(),
+            relation: { type: 'dummy' },
+        };
+        rounds.set(roundBase.id, newRound);
+        if (!roundsByType.has(roundBase.type)) {
+            roundsByType.set(roundBase.type, new BracketMap());
         }
-        if (isLowerBracket) {
-            currentLowerBracketIndex++;
+        roundsByType.getOrThrow(roundBase.type).set(roundBase.id, newRound);
+    }
+    const participants = new BracketMap();
+    for (const participantBase of bracketNewBase.participants.values()) {
+        participants.set(participantBase.id, {
+            ...participantBase,
+            matches: new BracketMap(),
+        });
+    }
+    const matches = new BracketMap();
+    for (const matchBase of bracketNewBase.matches.values()) {
+        const round = rounds.getOrThrow(matchBase.roundId);
+        const homeParticipant = matchBase.home
+            ? { ...matchBase.home, matches: new BracketMap() }
+            : null;
+        const awayParticipant = matchBase.away
+            ? { ...matchBase.away, matches: new BracketMap() }
+            : null;
+        const newMatch = {
+            ...matchBase,
+            home: homeParticipant,
+            away: awayParticipant,
+            winner: null,
+            round,
+            relation: { type: 'dummy' },
+        };
+        if (matchBase.winner) {
+            const winnerParticipant = homeParticipant?.id === matchBase.winner.id ? homeParticipant : awayParticipant;
+            if (!winnerParticipant)
+                throw new Error(`Winner participant with id ${matchBase.winner.id} not found in match base`);
+            newMatch.winner = winnerParticipant;
+        }
+        matches.set(matchBase.id, newMatch);
+        round.matches.set(matchBase.id, newMatch);
+        if (homeParticipant) {
+            const participant = participants.getOrThrow(homeParticipant.id);
+            participant.matches.set(matchBase.id, {
+                ...newMatch,
+                me: homeParticipant,
+                opponent: awayParticipant,
+            });
         }
-        else {
-            currentUpperBracketIndex++;
+        if (awayParticipant) {
+            const participant = participants.getOrThrow(awayParticipant.id);
+            participant.matches.set(matchBase.id, {
+                ...newMatch,
+                me: awayParticipant,
+                opponent: homeParticipant,
+            });
         }
     }
-    if (splitRoundsRest.length) {
-        const lastRoundId = bracketData.roundIds[bracketData.roundIds.length - 1];
-        if (!lastRoundId)
-            throw new Error('Last round id not found');
-        const lastRound = bracketData.rounds.get(lastRoundId);
-        if (!lastRound)
-            throw new Error('Last round not found');
-        for (const [splitRoundIndex, splitRound] of splitRoundsRest.entries()) {
-            splitRound.index = lastRound.index + splitRoundIndex + 1;
-            splitRound.position = (lastRound.position + splitRoundIndex + 1);
-            bracketData.rounds.set(splitRound.id, splitRound);
-            bracketData.roundIds.push(splitRound.id);
+    for (const participant of participants.values()) {
+        for (const match of participant.matches.values()) {
+            if (match.home?.id === participant.id)
+                match.home.matches = participant.matches;
+            if (match.away?.id === participant.id)
+                match.away.matches = participant.matches;
+            if (match.winner?.id === participant.id)
+                match.winner.matches = participant.matches;
         }
     }
-    return bracketData;
-};
-const generateTournamentModeFormGgData = (source) => {
-    switch (source.mode) {
-        // 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: ${source.mode}`);
+    const newBracket = {
+        matches,
+        participants,
+        rounds,
+        roundsByType,
+        mode: bracketNewBase.mode,
+    };
+    const roundRelations = generateRoundRelationsNew(newBracket);
+    for (const roundRelation of roundRelations) {
+        roundRelation.currentRound.relation = roundRelation;
+    }
+    const matchRelations = generateMatchRelationsNew(newBracket);
+    for (const matchRelation of matchRelations) {
+        matchRelation.currentMatch.relation = matchRelation;
     }
+    return newBracket;
 };
-const generateRoundTypeFromGgMatch = (tournamentMode, bracketType, // 'winner' | 'looser' | null,
-stageNumber, matchCount) => {
-    switch (tournamentMode) {
-        case 'double-elimination': {
-            switch (stageNumber) {
-                case 1: {
-                    switch (bracketType) {
-                        case 'winner':
-                            return DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE.UPPER_BRACKET;
-                        case 'looser':
-                            return DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE.LOWER_BRACKET;
-                        default:
-                            throw new Error(`Unsupported bracket type: ${bracketType}`);
-                    }
-                }
-                case 2: {
-                    return COMMON_BRACKET_ROUND_TYPE.FINAL;
-                }
-                case 3: {
-                    return DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE.REVERSE_FINAL;
-                }
-                default: {
-                    throw new Error(`Unsupported stage number: ${stageNumber}`);
-                }
-            }
-        }
-        case 'single-elimination': {
-            if (matchCount === 1) {
-                return COMMON_BRACKET_ROUND_TYPE.FINAL;
-            }
-            else {
-                return SINGLE_ELIMINATION_BRACKET_ROUND_TYPE.SINGLE_ELIMINATION_BRACKET;
-            }
+
+const pad = (str, len) => str.padEnd(len, ' ');
+const color = (str, code) => `\x1b[${code}m${str}\x1b[0m`;
+const roundColor = (str) => color(str, 36); // cyan
+const arrowColor = (str) => color(str, 90); // gray
+const labelColor = (str) => color(str, 33); // yellow
+const factorColor = (str) => color(str, 32); // green
+const logRoundRelations = (bracketData) => {
+    // Find max round name length for alignment
+    let maxNameLen = 0;
+    for (const round of bracketData.rounds.values()) {
+        maxNameLen = Math.max(maxNameLen, round.name.length);
+    }
+    const colWidth = maxNameLen + 2;
+    // Build rows
+    const rows = [];
+    for (const round of bracketData.rounds.values()) {
+        const relation = round.relation;
+        switch (relation.type) {
+            case 'nothing-to-one':
+                rows.push([
+                    labelColor(pad('START', colWidth)),
+                    arrowColor('──▶'),
+                    roundColor(pad(round.name, colWidth)),
+                    arrowColor('──▶'),
+                    roundColor(pad(relation.nextRound.name, colWidth)),
+                    factorColor(`[${relation.nextRoundMatchFactor}]`),
+                ]);
+                break;
+            case 'one-to-nothing':
+                rows.push([
+                    roundColor(pad(relation.previousRound.name, colWidth)),
+                    arrowColor('──▶'),
+                    roundColor(pad(round.name, colWidth)),
+                    arrowColor('──▶'),
+                    labelColor(pad('END', colWidth)),
+                    factorColor(`[${relation.previousRoundMatchFactor}]`),
+                ]);
+                break;
+            case 'one-to-one':
+                rows.push([
+                    roundColor(pad(relation.previousRound.name, colWidth)),
+                    arrowColor('──▶'),
+                    roundColor(pad(round.name, colWidth)),
+                    arrowColor('──▶'),
+                    roundColor(pad(relation.nextRound.name, colWidth)),
+                    factorColor(`[Prev: ${relation.previousRoundMatchFactor}, Next: ${relation.nextRoundMatchFactor}]`),
+                ]);
+                break;
+            case 'two-to-one':
+                rows.push([
+                    roundColor(pad(relation.previousUpperRound.name, colWidth)),
+                    arrowColor(' │ '),
+                    roundColor(pad(relation.previousLowerRound.name, colWidth)),
+                    arrowColor('──▶'),
+                    roundColor(pad(round.name, colWidth)),
+                    arrowColor('──▶'),
+                    roundColor(pad(relation.nextRound.name, colWidth)),
+                    factorColor(`[Upper: ${relation.previousUpperRoundMatchFactor}, Lower: ${relation.previousLowerRoundMatchFactor}, Next: ${relation.nextRoundMatchFactor}]`),
+                ]);
+                break;
+            case 'two-to-nothing':
+                rows.push([
+                    roundColor(pad(relation.previousUpperRound.name, colWidth)),
+                    arrowColor('   │'),
+                    roundColor(pad(relation.previousLowerRound.name, colWidth)),
+                    arrowColor('   ▼'),
+                    roundColor(pad(round.name, colWidth)),
+                    arrowColor('──▶'),
+                    labelColor(pad('END', colWidth)),
+                    factorColor(`[Upper: ${relation.previousUpperRoundMatchFactor}, Lower: ${relation.previousLowerRoundMatchFactor}]`),
+                ]);
+                break;
         }
-        default: {
-            throw new Error(`Unsupported tournament mode: ${tournamentMode}`);
+    }
+    // Print header
+    const divider = (label) => {
+        // eslint-disable-next-line no-control-regex
+        const width = rows[0]?.reduce((w, col) => w + col.replace(/\x1b\[[0-9;]*m/g, '').length + 2, 0) || 60;
+        return `\n${'='.repeat(width)}\n${labelColor(label)}\n${'='.repeat(width)}\n`;
+    };
+    console.log(divider('Bracket Structure'));
+    // Print rows
+    for (const row of rows) {
+        console.log(row.join(' '));
+    }
+    console.log();
+};
+
+const FIRST_ROUNDS_TYPE = {
+    SINGLE: 'single',
+    DOUBLE: 'double',
+};
+const getFirstRounds = (bracketData) => {
+    if (bracketData.mode === TOURNAMENT_MODE.DOUBLE_ELIMINATION) {
+        const upper = bracketData.roundsByType.getOrThrow(DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE.UPPER_BRACKET).first();
+        const lower = bracketData.roundsByType.getOrThrow(DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE.LOWER_BRACKET).first();
+        if (!upper || !lower) {
+            throw new Error('Upper or lower first round is null');
         }
+        return {
+            type: FIRST_ROUNDS_TYPE.DOUBLE,
+            upper,
+            lower,
+        };
     }
+    const first = bracketData.rounds.first();
+    if (!first)
+        throw new Error('First round is null');
+    return {
+        type: FIRST_ROUNDS_TYPE.SINGLE,
+        first,
+    };
 };
-const generateBracketDataForGg = (source) => {
-    const tournamentMode = generateTournamentModeFormGgData(source);
-    const bracketData = {
-        rounds: [],
-        matches: [],
-        mode: tournamentMode,
+
+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;
     };
-    const matchesGrouped = new Map();
-    for (const match of source.matches) {
-        const roundId = `${match.roundNumber}-${match.stageNumber}-${match.bracketType || null}`;
-        if (!matchesGrouped.has(roundId)) {
-            matchesGrouped.set(roundId, []);
-        }
-        matchesGrouped.get(roundId)?.push(match);
+    // Pre-calculate roundFactorial
+    const roundFactorial = 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 = roundFactorial / (getFactorial(wins) * getFactorial(losses));
+        totalCombinations += combinations;
+        validGroups.push({ wins, losses, combinations });
     }
-    for (const [roundId, matches] of matchesGrouped.entries()) {
-        const firstMatch = matches[0];
-        if (!firstMatch)
-            throw new Error('First match not found');
-        const roundType = generateRoundTypeFromGgMatch(tournamentMode, firstMatch.bracketType, firstMatch.stageNumber, matches.length);
-        const bracketRound = {
-            type: roundType,
-            id: roundId,
-            data: null,
-            name: firstMatch.roundTitle,
+    // 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) => {
+    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(),
         };
-        bracketData.rounds.push(bracketRound);
-        for (const match of matches) {
-            const bracketMatch = {
-                id: match.id,
-                data: match,
-                roundId: roundId,
-                home: match.homeMatchSide.participant?.id || null,
-                away: match.awayMatchSide.participant?.id || null,
-                winner: match.winningSide,
-                status: match.status === 'completed' ? 'completed' : 'pending',
+        for (const group of availableGroups) {
+            const subGroup = {
+                id: group.id,
+                name: group.name,
+                matches: new BracketMap(),
+                allowedMatchCount: group.matchesInGroup,
             };
-            bracketData.matches.push(bracketMatch);
+            roundSwissData.groups.set(group.id, subGroup);
+        }
+        const emptyMatchIds = [];
+        for (const match of bracketRound.matches.values()) {
+            const anyParticipant = match.home || match.away;
+            if (!anyParticipant) {
+                emptyMatchIds.push(match.id);
+                continue;
+            }
+            const wins = anyParticipant.winCount;
+            const losses = anyParticipant.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.getOrThrow(emptyMatchId);
+            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 bracketData;
+    return roundsWithSwissGroups;
 };
 
 const path = (d, options) => `<path d="${d.replace(/\s+/g, ' ').trim()}" stroke="currentColor" fill="none" stroke-width="${options.width}" stroke-dasharray="${options.dashArray}" stroke-dashoffset="${options.dashOffset}" class="${options.className}" />`;
-const curve = (from, to, direction, options) => {
-    const fromInline = from.inline.end;
-    const toInline = to.inline.start;
-    const toBlock = to.block.center;
-    const fromBlock = from.block.center;
-    const startingCurveAmount = options.lineStartingCurveAmount;
-    const endingCurveAmount = options.lineEndingCurveAmount;
-    const totalSpace = toInline - fromInline;
-    const totalSpaceMinusCurve = totalSpace - startingCurveAmount - endingCurveAmount;
-    const lineLength = totalSpaceMinusCurve / 2;
-    const straightLeftEnd = fromInline + lineLength;
-    const straightRightStart = toInline - lineLength;
-    // first 90 degree curve down
-    const firstCurveStartX = straightLeftEnd;
-    const firstCurveEndX = straightLeftEnd + startingCurveAmount;
-    const firstCurveEndY = direction === 'down' ? fromBlock + startingCurveAmount : fromBlock - startingCurveAmount;
-    const firstCurveBezierX = straightLeftEnd + startingCurveAmount;
-    const firstCurveBezierY = fromBlock;
-    // second 90 degree curve to the right
-    const secondCurveStartY = direction === 'down' ? toBlock - endingCurveAmount : toBlock + endingCurveAmount;
-    const secondCurveEndX = straightRightStart;
-    const secondCurveEndY = toBlock;
-    const secondCurveBezierX = straightRightStart - endingCurveAmount;
-    const secondCurveBezierY = toBlock;
-    const pathStr = `
-    M ${fromInline} ${fromBlock} 
-    H ${firstCurveStartX} 
-    Q ${firstCurveBezierX} ${firstCurveBezierY}, ${firstCurveEndX} ${firstCurveEndY} 
-    V ${secondCurveStartY} 
-    Q ${secondCurveBezierX} ${secondCurveBezierY}, ${secondCurveEndX} ${secondCurveEndY} 
-    H ${toInline}
-  `;
-    return path(pathStr, options.path);
-};
-const curveInverted = (from, to, direction, options) => {
-    const fromInline = from.inline.start;
+const curvePath = (from, to, direction, options) => {
+    const inverted = options.inverted ?? false;
+    // Inline/block coordinates depending on direction and inversion
+    const fromInline = inverted ? from.inline.start : from.inline.end;
+    const toInline = inverted ? to.inline.end : to.inline.start;
     const fromBlock = from.block.center;
-    const toInline = to.inline.end;
     const toBlock = to.block.center;
-    const startingCurveAmount = options.lineStartingCurveAmount;
-    const endingCurveAmount = options.lineEndingCurveAmount;
-    const totalSpace = fromInline - toInline;
-    const totalSpaceMinusCurve = totalSpace - startingCurveAmount - endingCurveAmount;
-    const lineLength = totalSpaceMinusCurve / 2;
-    const straightRightEnd = fromInline - lineLength;
-    const straightLeftStart = toInline + lineLength;
-    const firstCurveStartX = straightRightEnd;
-    const firstCurveEndX = straightRightEnd - startingCurveAmount;
-    const firstCurveEndY = direction === 'down' ? fromBlock + startingCurveAmount : fromBlock - startingCurveAmount;
-    const firstCurveBezierX = straightRightEnd - startingCurveAmount;
-    const firstCurveBezierY = fromBlock;
-    // second 90 degree curve to the right
-    const secondCurveStartY = direction === 'down' ? toBlock - endingCurveAmount : toBlock + endingCurveAmount;
-    const secondCurveEndX = straightLeftStart;
+    // Curve parameters
+    const startCurve = options.lineStartingCurveAmount;
+    const endCurve = options.lineEndingCurveAmount;
+    const totalInline = Math.abs(toInline - fromInline);
+    const straightLength = (totalInline - startCurve - endCurve) / 2;
+    // Calculate key points for the path
+    const straightEnd = inverted ? fromInline - straightLength : fromInline + straightLength;
+    const straightStart = inverted ? toInline + straightLength : toInline - straightLength;
+    // First curve (from start)
+    const firstCurveEndX = inverted ? straightEnd - startCurve : straightEnd + startCurve;
+    const firstCurveEndY = direction === 'down' ? fromBlock + startCurve : fromBlock - startCurve;
+    // Second curve (to end)
+    const secondCurveStartY = direction === 'down' ? toBlock - endCurve : toBlock + endCurve;
+    const secondCurveEndX = straightStart;
     const secondCurveEndY = toBlock;
-    const secondCurveBezierX = straightLeftStart + endingCurveAmount;
-    const secondCurveBezierY = toBlock;
-    const pathStr = `
-    M ${fromInline} ${fromBlock} 
-    H ${firstCurveStartX} 
-    Q ${firstCurveBezierX} ${firstCurveBezierY}, ${firstCurveEndX} ${firstCurveEndY} 
-    V ${secondCurveStartY}
-    Q ${secondCurveBezierX} ${secondCurveBezierY}, ${secondCurveEndX} ${secondCurveEndY} 
-    H ${toInline}
-  `;
-    return path(pathStr, options.path);
+    const secondCurveBezierX = inverted ? straightStart + endCurve : straightStart - endCurve;
+    // SVG path string
+    const d = [
+        `M ${fromInline} ${fromBlock}`,
+        `H ${straightEnd}`,
+        `Q ${firstCurveEndX} ${fromBlock}, ${firstCurveEndX} ${firstCurveEndY}`,
+        `V ${secondCurveStartY}`,
+        `Q ${secondCurveBezierX} ${toBlock}, ${secondCurveEndX} ${secondCurveEndY}`,
+        `H ${toInline}`,
+    ].join(' ');
+    return path(d, options.path);
 };
-const line = (from, to, options) => {
+const linePath = (from, to, options) => {
     return path(`M ${from.inline.end} ${from.block.center} L ${to.inline.start} ${to.block.center}`, options.path);
 };
 const getMatchPosition = (roundItem, matchId, staticMeasurements) => {
@@ -2236,24 +2494,25 @@ const drawMan = (items, firstRounds, dimensions) => {
                 case 'one-to-one': {
                     const previousMatchPosition = getMatchPosition(items.get(item.matchRelation.previousRound.id), item.matchRelation.previousMatch.id, staticMeasurements);
                     // draw a straight line
-                    svgParts.push(line(previousMatchPosition, currentMatchPosition, { path: pathOptions }));
+                    svgParts.push(linePath(previousMatchPosition, currentMatchPosition, { path: pathOptions }));
                     break;
                 }
                 case 'two-to-nothing':
                 case 'two-to-one': {
                     const previousUpper = getMatchPosition(items.get(item.matchRelation.previousUpperRound.id), item.matchRelation.previousUpperMatch.id, staticMeasurements);
                     const previousLower = getMatchPosition(items.get(item.matchRelation.previousLowerRound.id), item.matchRelation.previousLowerMatch.id, staticMeasurements);
+                    const invertCurve = item.roundRelation.currentRound.mirrorRoundType === BRACKET_ROUND_MIRROR_TYPE.RIGHT;
                     const curveOptions = {
                         ...dimensions.curve,
+                        inverted: invertCurve,
                         path: { ...dimensions.path, className: '' },
                     };
-                    const curveFn = item.roundRelation.currentRound.mirrorRoundType === BRACKET_ROUND_MIRROR_TYPE.RIGHT ? curveInverted : curve;
                     // draw two lines that merge into one in the middle
-                    svgParts.push(curveFn(previousUpper, currentMatchPosition, 'down', {
+                    svgParts.push(curvePath(previousUpper, currentMatchPosition, 'down', {
                         ...curveOptions,
                         path: { ...curveOptions.path, className: item.matchRelation.previousUpperMatch.winner?.shortId || '' },
                     }));
-                    svgParts.push(curveFn(previousLower, currentMatchPosition, 'up', {
+                    svgParts.push(curvePath(previousLower, currentMatchPosition, 'up', {
                         ...curveOptions,
                         path: { ...curveOptions.path, className: item.matchRelation.previousLowerMatch.winner?.shortId || '' },
                     }));
@@ -2262,7 +2521,7 @@ const drawMan = (items, firstRounds, dimensions) => {
                         item.matchRelation.nextRound.mirrorRoundType === null) {
                         // draw a straight line for the special case of connecting the final match to the mirrored semi final match
                         const next = getMatchPosition(items.get(item.matchRelation.nextRound.id), item.matchRelation.nextMatch.id, staticMeasurements);
-                        svgParts.push(line(next, currentMatchPosition, { path: pathOptions }));
+                        svgParts.push(linePath(next, currentMatchPosition, { path: pathOptions }));
                     }
                     break;
                 }
@@ -2272,14 +2531,18 @@ const drawMan = (items, firstRounds, dimensions) => {
     return svgParts.join('');
 };
 
-const generateColumnCount = (bracketData, roundTypeMap) => {
-    const thirdPlaceRoundSize = roundTypeMap.get(COMMON_BRACKET_ROUND_TYPE.THIRD_PLACE)?.size || 0;
+const generateColumnCount = (bracketData) => {
+    const thirdPlaceRoundSize = bracketData.roundsByType.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;
+            const upperBracketSize = bracketData.roundsByType.get(DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE.UPPER_BRACKET)?.size || 0;
+            const lowerBracketSize = bracketData.roundsByType.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);
+            return (bracketData.rounds.size -
+                upperBracketSize -
+                lowerBracketSize -
+                thirdPlaceRoundSize +
+                Math.max(upperBracketSize, lowerBracketSize));
         }
         default: {
             // the total columns are the amount of rounds excluding third place
@@ -2287,13 +2550,15 @@ const generateColumnCount = (bracketData, roundTypeMap) => {
         }
     }
 };
-const generateRowCount = (bracketData, roundTypeMap, options) => {
+const generateRowCount = (bracketData, 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 upperBracketSize = bracketData.roundsByType
+                .getOrThrow(DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE.UPPER_BRACKET)
+                .first()?.matchCount;
+            const lowerBracketSize = bracketData.roundsByType
+                .getOrThrow(DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE.LOWER_BRACKET)
+                ?.first()?.matchCount;
             const roundHeadersCount = options.includeRoundHeaders ? 2 : 0;
             if (upperBracketSize === undefined || lowerBracketSize === undefined) {
                 throw new Error('Upper or lower bracket size is undefined');
@@ -2312,42 +2577,14 @@ const generateRowCount = (bracketData, roundTypeMap, options) => {
         }
     }
 };
-const generateBracketGridDefinitions = (bracketData, roundTypeMap, options) => {
-    const columnCount = generateColumnCount(bracketData, roundTypeMap);
-    const rowCount = generateRowCount(bracketData, roundTypeMap, options);
+const generateBracketGridDefinitions = (bracketData, options) => {
+    const columnCount = generateColumnCount(bracketData);
+    const rowCount = generateRowCount(bracketData, 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: "20.0.3", ngImport: i0, type: NewBracketDefaultMatchComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "20.0.3", 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: "20.0.3", 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: "20.0.3", ngImport: i0, type: NewBracketDefaultRoundHeaderComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "20.0.3", 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: "20.0.3", 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 generateBracketGridItems = (data) => {
+    const { bracketData, swissGroups, options } = data;
     const roundHeaderComponent = options.headerComponent ?? NewBracketDefaultRoundHeaderComponent;
     const matchComponent = options.matchComponent ?? NewBracketDefaultMatchComponent;
     const finalMatchComponent = options.finalMatchComponent ?? matchComponent;
@@ -2357,32 +2594,33 @@ const generateBracketGridItems = (bracketData, roundTypeMap, swissGroups, roundR
         matchComponent: matchComponent,
         finalMatchComponent: finalMatchComponent,
     };
+    const config = {
+        bracketData,
+        swissGroups,
+        options: optionsWithDefaults,
+    };
     switch (bracketData.mode) {
         case TOURNAMENT_MODE.DOUBLE_ELIMINATION:
-            return generateDoubleEliminationGridPlacements(bracketData, roundTypeMap, roundRelations, matchRelations, optionsWithDefaults);
+            return generateDoubleEliminationGridPlacements(config);
         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);
+            return generateSwissWithEliminationGridPlacements(config);
         }
         default:
-            return generateGenericGridPlacements(bracketData, roundTypeMap, roundRelations, matchRelations, optionsWithDefaults);
+            return generateGenericGridPlacements(config);
     }
 };
-const generateGenericGridPlacements = (bracketData, roundTypeMap, roundRelations, matchRelations, options) => {
+const generateGenericGridPlacements = (config) => {
     const gridItems = new Map();
-    const firstRound = bracketData.rounds.values().next().value;
+    const { bracketData, options } = config;
+    const firstRound = bracketData.rounds.first();
     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 columnStart = round.logicalIndex + 1;
         const columnEnd = columnStart + 1;
-        if (!roundRelation) {
-            throw new Error('Round relation is missing');
-        }
+        const roundRelation = round.relation;
         if (roundRelation.type === 'two-to-nothing' || roundRelation.type === 'two-to-one') {
             throw new Error(`Invalid relation type ${roundRelation.type}`);
         }
@@ -2391,6 +2629,8 @@ const generateGenericGridPlacements = (bracketData, roundTypeMap, roundRelations
             layoutId: `${round.id}-layout`,
             columnStart,
             columnEnd,
+            rowStart: 1,
+            rowEnd: firstRound.matchCount + 1,
             roundRelation,
             items: new Map(),
         };
@@ -2413,10 +2653,7 @@ const generateGenericGridPlacements = (bracketData, roundTypeMap, roundRelations
         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 matchRelation = match.relation;
             const baseRow = match.indexInRound * matchHeight;
             const participantShortIds = [match.home?.shortId, match.away?.shortId].filter((id) => !!id).join(' ');
             const matchItem = {
@@ -2440,11 +2677,131 @@ const generateGenericGridPlacements = (bracketData, roundTypeMap, roundRelations
     }
     return gridItems;
 };
-const generateDoubleEliminationGridPlacements = (bracketData, roundTypeMap, roundRelations, matchRelations, options) => {
+const generateDoubleEliminationGridPlacements = (config) => {
     const gridItems = new Map();
+    const { bracketData, options } = config;
+    const upperBracketRounds = bracketData.roundsByType.getOrThrow(DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE.UPPER_BRACKET);
+    const lowerBracketRounds = bracketData.roundsByType.getOrThrow(DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE.LOWER_BRACKET);
+    const hasReverseFinal = !!bracketData.roundsByType.get(DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE.REVERSE_FINAL);
+    const firstUpperRound = upperBracketRounds.first();
+    const firstLowerRound = lowerBracketRounds.first();
+    const headerRowMod = options.includeRoundHeaders ? 1 : 0;
+    if (!firstUpperRound) {
+        throw new Error('First round is missing');
+    }
+    if (!firstLowerRound) {
+        throw new Error('First lower round is missing');
+    }
+    const roundDelta = lowerBracketRounds.size - upperBracketRounds.size;
+    const isAsyncBracket = roundDelta === 2;
+    let currentUpperColumn = 1;
+    for (const round of bracketData.rounds.values()) {
+        let currentMatchRow = 1;
+        const columnStart = round.logicalIndex + 1;
+        const columnEnd = columnStart + 1;
+        const roundRelation = round.relation;
+        const isUpperBracket = round.type === DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE.UPPER_BRACKET;
+        const isUpperNeitherStartNorEnd = !round.isFirstOfType && !round.isLastOfType && isUpperBracket;
+        const upperRowSpan = isUpperNeitherStartNorEnd || (isAsyncBracket && round.isLastOfType) ? 2 : 1;
+        const isLowerBracket = round.type === DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE.LOWER_BRACKET;
+        const upperBracketRowStart = 1;
+        const upperBracketRowEnd = firstUpperRound.matchCount + headerRowMod + 1;
+        const lowerBracketRowStart = upperBracketRowEnd;
+        const lowerBracketRowEnd = lowerBracketRowStart + headerRowMod + firstLowerRound.matchCount;
+        const fullBracketRowStart = 1;
+        const fullBracketRowEnd = lowerBracketRowEnd;
+        const roundRowStart = isUpperBracket
+            ? upperBracketRowStart
+            : isLowerBracket
+                ? lowerBracketRowStart
+                : fullBracketRowStart;
+        const roundRowEnd = isUpperBracket ? upperBracketRowEnd : isLowerBracket ? lowerBracketRowEnd : fullBracketRowEnd;
+        const upperBracketColumnStart = currentUpperColumn;
+        const upperBracketColumnEnd = currentUpperColumn + upperRowSpan;
+        currentUpperColumn += upperRowSpan;
+        const lowerBracketColumnStart = columnStart;
+        const lowerBracketColumnEnd = columnEnd;
+        const fullBracketColumnStart = columnStart;
+        const fullBracketColumnEnd = columnEnd;
+        const roundColumnStart = isUpperBracket
+            ? upperBracketColumnStart
+            : isLowerBracket
+                ? lowerBracketColumnStart
+                : fullBracketColumnStart;
+        const roundColumnEnd = isUpperBracket
+            ? upperBracketColumnEnd
+            : isLowerBracket
+                ? lowerBracketColumnEnd
+                : fullBracketColumnEnd;
+        const roundItem = {
+            id: round.id,
+            layoutId: `${round.id}-layout`,
+            columnStart: roundColumnStart,
+            columnEnd: roundColumnEnd,
+            rowStart: roundRowStart,
+            rowEnd: roundRowEnd,
+            roundRelation,
+            items: new Map(),
+        };
+        if (options.includeRoundHeaders) {
+            const roundHeaderItem = {
+                type: 'round',
+                id: round.id,
+                layoutId: `${round.id}-layout`,
+                rowStart: currentMatchRow,
+                rowEnd: ++currentMatchRow,
+                component: options.headerComponent,
+                className: 'et-bracket-new-item et-bracket-round-header-container',
+                roundRelation,
+                data: {
+                    bracketRound: round,
+                },
+            };
+            roundItem.items.set(round.id, roundHeaderItem);
+        }
+        const rootRoundMatchFactor = roundRelation.type !== 'nothing-to-one' &&
+            roundRelation.type !== 'two-to-nothing' &&
+            roundRelation.type !== 'two-to-one'
+            ? roundRelation.rootRoundMatchFactor
+            : roundRelation.type === 'two-to-nothing' || roundRelation.type === 'two-to-one'
+                ? roundRelation.upperRootRoundMatchFactor
+                : null;
+        const matchHeight = rootRoundMatchFactor ? rootRoundMatchFactor : 1;
+        for (const match of round.matches.values()) {
+            const matchRelation = match.relation;
+            const baseRow = match.indexInRound * matchHeight;
+            const participantShortIds = [match.home?.shortId, match.away?.shortId].filter((id) => !!id).join(' ');
+            const matchItem = {
+                type: 'match',
+                id: match.id,
+                layoutId: `${match.id}-layout`,
+                rowStart: baseRow + currentMatchRow,
+                rowEnd: baseRow + currentMatchRow + matchHeight,
+                component: hasReverseFinal
+                    ? round.type === DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE.REVERSE_FINAL
+                        ? options.finalMatchComponent
+                        : options.matchComponent
+                    : round.type === COMMON_BRACKET_ROUND_TYPE.FINAL
+                        ? options.finalMatchComponent
+                        : options.matchComponent,
+                matchRelation,
+                roundRelation,
+                className: `et-bracket-new-item et-bracket-match-container ${participantShortIds}`,
+                data: {
+                    bracketRound: round,
+                    bracketMatch: match,
+                },
+            };
+            roundItem.items.set(match.id, matchItem);
+        }
+        gridItems.set(round.id, roundItem);
+    }
     return gridItems;
 };
-const generateSwissWithEliminationGridPlacements = (bracketData, roundTypeMap, swissGroups, roundRelations, matchRelations, options) => {
+const generateSwissWithEliminationGridPlacements = (config) => {
+    const { swissGroups } = config;
+    if (!swissGroups)
+        throw new Error('Swiss groups are required for swiss with elimination mode');
     const gridItems = new Map();
     return gridItems;
 };
@@ -2468,17 +2825,16 @@ const createJourneyHighlight = (bracketData) => {
 };
 
 class NewBracketComponent {
-    #domSanitizer;
-    #elementId;
     constructor() {
-        this.#domSanitizer = inject(DomSanitizer);
-        this.#elementId = createComponentId('et-new-bracket');
+        this.domSanitizer = inject(DomSanitizer);
+        this.elementId = createComponentId('et-new-bracket');
         this.source = 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.upperLowerGap = input(50, { transform: numberAttribute });
         this.lineStartingCurveAmount = input(10, { transform: numberAttribute });
         this.lineEndingCurveAmount = input(0, { transform: numberAttribute });
         this.lineWidth = input(2, { transform: numberAttribute });
@@ -2490,50 +2846,59 @@ class NewBracketComponent {
         this.roundHeaderComponent = input();
         this.matchComponent = input();
         this.finalMatchComponent = input();
-        this.bracketData = computed(() => generateBracketData(this.source(), { layout: this.layout() }));
-        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(),
-            finalMatchComponent: this.finalMatchComponent(),
+        this.bracketData = computed(() => createNewBracket(this.source(), { layout: this.layout() }));
+        this.swissGroups = computed(() => generateBracketRoundSwissGroupMaps(this.bracketData()));
+        this.items = computed(() => generateBracketGridItems({
+            bracketData: this.bracketData(),
+            swissGroups: this.swissGroups(),
+            options: {
+                includeRoundHeaders: !this.hideRoundHeaders(),
+                headerComponent: this.roundHeaderComponent(),
+                matchComponent: this.matchComponent(),
+                finalMatchComponent: this.finalMatchComponent(),
+            },
         }));
-        this.definitions = computed(() => generateBracketGridDefinitions(this.bracketData(), this.roundTypeMap(), {
+        this.definitions = computed(() => generateBracketGridDefinitions(this.bracketData(), {
             includeRoundHeaders: !this.hideRoundHeaders(),
         }));
-        this.firstRounds = computed(() => getFirstRounds(this.bracketData(), this.roundTypeMap()));
-        this.drawManData = computed(() => this.#domSanitizer.bypassSecurityTrustHtml(drawMan(this.items(), this.firstRounds(), {
-            columnGap: this.columnGap(),
-            columnWidth: this.columnWidth(),
-            matchHeight: this.matchHeight(),
-            roundHeaderHeight: this.hideRoundHeaders() ? 0 : this.roundHeaderHeight(),
-            rowGap: this.rowGap(),
-            gridDefinitions: this.definitions(),
-            curve: {
-                lineEndingCurveAmount: this.lineEndingCurveAmount(),
-                lineStartingCurveAmount: this.lineStartingCurveAmount(),
-            },
-            path: {
-                dashArray: this.lineDashArray(),
-                dashOffset: this.lineDashOffset(),
-                width: this.lineWidth(),
-            },
-        })));
+        this.firstRounds = computed(() => getFirstRounds(this.bracketData()));
+        this.drawManData = computed(() => {
+            if (this.bracketData().mode !== TOURNAMENT_MODE.SINGLE_ELIMINATION)
+                return '';
+            return this.domSanitizer.bypassSecurityTrustHtml(drawMan(this.items(), this.firstRounds(), {
+                columnGap: this.columnGap(),
+                upperLowerGap: this.bracketData().mode === TOURNAMENT_MODE.DOUBLE_ELIMINATION ? this.upperLowerGap() : 0,
+                columnWidth: this.columnWidth(),
+                matchHeight: this.matchHeight(),
+                roundHeaderHeight: this.hideRoundHeaders() ? 0 : this.roundHeaderHeight(),
+                rowGap: this.rowGap(),
+                gridDefinitions: this.definitions(),
+                curve: {
+                    lineEndingCurveAmount: this.lineEndingCurveAmount(),
+                    lineStartingCurveAmount: this.lineStartingCurveAmount(),
+                },
+                path: {
+                    dashArray: this.lineDashArray(),
+                    dashOffset: this.lineDashOffset(),
+                    width: this.lineWidth(),
+                },
+            }));
+        });
         this.journeyHighlight = computed(() => this.disableJourneyHighlight() ? null : createJourneyHighlight(this.bracketData()));
-        const isBrowser = isPlatformBrowser(inject(PLATFORM_ID));
-        if (!isBrowser)
-            return;
+        this.setupJourneyHighlight();
+        effect(() => {
+            logRoundRelations(this.bracketData());
+            console.log(this.bracketData());
+        });
+    }
+    setupJourneyHighlight() {
         const renderer = inject(Renderer2);
-        const styleId = `et-new-bracket-journey-highlight--${this.#elementId}`;
+        const doc = inject(DOCUMENT);
+        const styleId = `et-new-bracket-journey-highlight--${this.elementId}`;
         let oldStyleEl = null;
         effect(() => {
             const newHighlightStyle = this.journeyHighlight();
-            const head = document.head;
+            const head = doc.head;
             if (oldStyleEl) {
                 renderer.removeChild(head, oldStyleEl);
             }
@@ -2547,31 +2912,31 @@ class NewBracketComponent {
             else {
                 oldStyleEl = null;
             }
-        });
-        inject(DestroyRef).onDestroy(() => {
-            if (oldStyleEl) {
-                renderer.removeChild(document.head, oldStyleEl);
-            }
+            return () => {
+                if (oldStyleEl) {
+                    renderer.removeChild(head, oldStyleEl);
+                    oldStyleEl = null;
+                }
+            };
         });
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: NewBracketComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "20.0.3", type: NewBracketComponent, isStandalone: true, selector: "et-new-bracket", inputs: { source: { classPropertyName: "source", publicName: "source", 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 }, lineStartingCurveAmount: { classPropertyName: "lineStartingCurveAmount", publicName: "lineStartingCurveAmount", isSignal: true, isRequired: false, transformFunction: null }, lineEndingCurveAmount: { classPropertyName: "lineEndingCurveAmount", publicName: "lineEndingCurveAmount", isSignal: true, isRequired: false, transformFunction: null }, lineWidth: { classPropertyName: "lineWidth", publicName: "lineWidth", isSignal: true, isRequired: false, transformFunction: null }, lineDashArray: { classPropertyName: "lineDashArray", publicName: "lineDashArray", isSignal: true, isRequired: false, transformFunction: null }, lineDashOffset: { classPropertyName: "lineDashOffset", publicName: "lineDashOffset", isSignal: true, isRequired: false, transformFunction: null }, disableJourneyHighlight: { classPropertyName: "disableJourneyHighlight", publicName: "disableJourneyHighlight", isSignal: true, isRequired: false, transformFunction: null }, layout: { classPropertyName: "layout", publicName: "layout", 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 }, finalMatchComponent: { classPropertyName: "finalMatchComponent", publicName: "finalMatchComponent", 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]=\"hideRoundHeaders() ? matchHeight() : 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.layoutId) {\n    <ul [style.--_c]=\"round.columnStart + ' / ' + round.columnEnd\" class=\"et-bracket-new-round\">\n      @for (item of round.items.values(); track item.layoutId) {\n        <li [style.--_r]=\"item.rowStart + ' / ' + item.rowEnd\" [class]=\"item.className\">\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);--bracket-line-color: red}.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;transition:opacity .2s}.et-bracket-new-svg{grid-column:1/calc(var(--_bcc) + 1);grid-row:1/2;inline-size:100%;block-size:100%}.et-bracket-new-svg path{color:var(--bracket-line-color);transition:opacity .2s}\n"], dependencies: [{ kind: "directive", type: NgComponentOutlet, selector: "[ngComponentOutlet]", inputs: ["ngComponentOutlet", "ngComponentOutletInputs", "ngComponentOutletInjector", "ngComponentOutletContent", "ngComponentOutletNgModule", "ngComponentOutletNgModuleFactory"], exportAs: ["ngComponentOutlet"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "20.0.3", type: NewBracketComponent, isStandalone: true, selector: "et-new-bracket", inputs: { source: { classPropertyName: "source", publicName: "source", 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 }, upperLowerGap: { classPropertyName: "upperLowerGap", publicName: "upperLowerGap", isSignal: true, isRequired: false, transformFunction: null }, lineStartingCurveAmount: { classPropertyName: "lineStartingCurveAmount", publicName: "lineStartingCurveAmount", isSignal: true, isRequired: false, transformFunction: null }, lineEndingCurveAmount: { classPropertyName: "lineEndingCurveAmount", publicName: "lineEndingCurveAmount", isSignal: true, isRequired: false, transformFunction: null }, lineWidth: { classPropertyName: "lineWidth", publicName: "lineWidth", isSignal: true, isRequired: false, transformFunction: null }, lineDashArray: { classPropertyName: "lineDashArray", publicName: "lineDashArray", isSignal: true, isRequired: false, transformFunction: null }, lineDashOffset: { classPropertyName: "lineDashOffset", publicName: "lineDashOffset", isSignal: true, isRequired: false, transformFunction: null }, disableJourneyHighlight: { classPropertyName: "disableJourneyHighlight", publicName: "disableJourneyHighlight", isSignal: true, isRequired: false, transformFunction: null }, layout: { classPropertyName: "layout", publicName: "layout", 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 }, finalMatchComponent: { classPropertyName: "finalMatchComponent", publicName: "finalMatchComponent", 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]=\"hideRoundHeaders() ? matchHeight() : roundHeaderHeight()\"\n  [style.--_cg.px]=\"columnGap()\"\n  [style.--_ulg.px]=\"upperLowerGap()\"\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.layoutId) {\n    <ul\n      [style.--_c]=\"round.columnStart + ' / ' + round.columnEnd\"\n      [style.--_r]=\"round.rowStart + ' / ' + round.rowEnd\"\n      class=\"et-bracket-new-round\"\n    >\n      @for (item of round.items.values(); track item.layoutId) {\n        <li [style.--_r]=\"item.rowStart + ' / ' + item.rowEnd\" [class]=\"item.className\">\n          <ng-container *ngComponentOutlet=\"item.component; inputs: item.data\" />\n        </li>\n      }\n    </ul>\n  }\n</section>\n", styles: [".et-bracket-new{display:grid;column-gap:var(--_cg);row-gap:var(--_ulg);grid-auto-columns:var(--_cw);--bracket-line-color: red}.et-bracket-new-round{display:grid;grid-column:var(--_c);grid-row:var(--_r);list-style:none;margin:0;padding:0;row-gap:var(--_rg);grid-template-rows:var(--_rhh);grid-auto-rows:var(--_mh)}.et-bracket-new-item{grid-row:var(--_r);place-self:center;transition:opacity .2s}.et-bracket-new-svg{grid-column:1/calc(var(--_bcc) + 1);grid-row:1/var(--_brc);inline-size:100%;block-size:100%}.et-bracket-new-svg path{color:var(--bracket-line-color);transition:opacity .2s}\n"], dependencies: [{ kind: "directive", type: NgComponentOutlet, selector: "[ngComponentOutlet]", inputs: ["ngComponentOutlet", "ngComponentOutletInputs", "ngComponentOutletInjector", "ngComponentOutletContent", "ngComponentOutletNgModule", "ngComponentOutletNgModuleFactory"], exportAs: ["ngComponentOutlet"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: NewBracketComponent, decorators: [{
             type: Component,
             args: [{ selector: 'et-new-bracket', 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]=\"hideRoundHeaders() ? matchHeight() : 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.layoutId) {\n    <ul [style.--_c]=\"round.columnStart + ' / ' + round.columnEnd\" class=\"et-bracket-new-round\">\n      @for (item of round.items.values(); track item.layoutId) {\n        <li [style.--_r]=\"item.rowStart + ' / ' + item.rowEnd\" [class]=\"item.className\">\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);--bracket-line-color: red}.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;transition:opacity .2s}.et-bracket-new-svg{grid-column:1/calc(var(--_bcc) + 1);grid-row:1/2;inline-size:100%;block-size:100%}.et-bracket-new-svg path{color:var(--bracket-line-color);transition:opacity .2s}\n"] }]
+                    }, imports: [NgComponentOutlet], template: "<section\n  [style.--_cw.px]=\"columnWidth()\"\n  [style.--_mh.px]=\"matchHeight()\"\n  [style.--_rhh.px]=\"hideRoundHeaders() ? matchHeight() : roundHeaderHeight()\"\n  [style.--_cg.px]=\"columnGap()\"\n  [style.--_ulg.px]=\"upperLowerGap()\"\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.layoutId) {\n    <ul\n      [style.--_c]=\"round.columnStart + ' / ' + round.columnEnd\"\n      [style.--_r]=\"round.rowStart + ' / ' + round.rowEnd\"\n      class=\"et-bracket-new-round\"\n    >\n      @for (item of round.items.values(); track item.layoutId) {\n        <li [style.--_r]=\"item.rowStart + ' / ' + item.rowEnd\" [class]=\"item.className\">\n          <ng-container *ngComponentOutlet=\"item.component; inputs: item.data\" />\n        </li>\n      }\n    </ul>\n  }\n</section>\n", styles: [".et-bracket-new{display:grid;column-gap:var(--_cg);row-gap:var(--_ulg);grid-auto-columns:var(--_cw);--bracket-line-color: red}.et-bracket-new-round{display:grid;grid-column:var(--_c);grid-row:var(--_r);list-style:none;margin:0;padding:0;row-gap:var(--_rg);grid-template-rows:var(--_rhh);grid-auto-rows:var(--_mh)}.et-bracket-new-item{grid-row:var(--_r);place-self:center;transition:opacity .2s}.et-bracket-new-svg{grid-column:1/calc(var(--_bcc) + 1);grid-row:1/var(--_brc);inline-size:100%;block-size:100%}.et-bracket-new-svg path{color:var(--bracket-line-color);transition:opacity .2s}\n"] }]
         }], ctorParameters: () => [] });
 
 var index = /*#__PURE__*/Object.freeze({
     __proto__: null,
     BRACKET_DATA_LAYOUT: BRACKET_DATA_LAYOUT,
     BRACKET_ROUND_MIRROR_TYPE: BRACKET_ROUND_MIRROR_TYPE,
+    BracketMap: BracketMap,
     COMMON_BRACKET_ROUND_TYPE: COMMON_BRACKET_ROUND_TYPE,
     DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE: DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE,
-    FALLBACK_MATCH_POSITION: FALLBACK_MATCH_POSITION,
-    FIRST_ROUNDS_TYPE: FIRST_ROUNDS_TYPE,
     GROUP_BRACKET_ROUND_TYPE: GROUP_BRACKET_ROUND_TYPE,
     NewBracketComponent: NewBracketComponent,
     NewBracketDefaultMatchComponent: NewBracketDefaultMatchComponent,
@@ -2580,27 +2945,17 @@ var index = /*#__PURE__*/Object.freeze({
     SWISS_BRACKET_ROUND_TYPE: SWISS_BRACKET_ROUND_TYPE,
     TOURNAMENT_MODE: TOURNAMENT_MODE,
     canRenderLayoutInTournamentMode: canRenderLayoutInTournamentMode,
-    drawMan: drawMan,
-    generateBracketData: generateBracketData,
+    createMatchesMapBase: createMatchesMapBase,
+    createNewBracketBase: createNewBracketBase,
+    createNewMatchParticipantBase: createNewMatchParticipantBase,
+    createParticipantsMapBase: createParticipantsMapBase,
+    createRoundsMapBase: createRoundsMapBase,
     generateBracketDataForEthlete: generateBracketDataForEthlete,
     generateBracketDataForGg: generateBracketDataForGg,
-    generateBracketGridDefinitions: generateBracketGridDefinitions,
-    generateBracketGridItems: generateBracketGridItems,
-    generateBracketRoundSwissGroupMaps: generateBracketRoundSwissGroupMaps,
-    generateBracketRoundTypeMap: generateBracketRoundTypeMap,
-    generateMatchParticipantMap: generateMatchParticipantMap,
-    generateMatchPosition: generateMatchPosition,
-    generateMatchPositionMaps: generateMatchPositionMaps,
-    generateMatchRelationPositions: generateMatchRelationPositions,
-    generateMatchRelations: generateMatchRelations,
-    generateRoundRelations: generateRoundRelations,
     generateRoundTypeFromEthleteRoundType: generateRoundTypeFromEthleteRoundType,
     generateRoundTypeFromGgMatch: generateRoundTypeFromGgMatch,
     generateTournamentModeFormEthleteRounds: generateTournamentModeFormEthleteRounds,
-    generateTournamentModeFormGgData: generateTournamentModeFormGgData,
-    getAvailableSwissGroupsForRound: getAvailableSwissGroupsForRound,
-    getFirstRounds: getFirstRounds,
-    logRoundRelations: logRoundRelations
+    generateTournamentModeFormGgData: generateTournamentModeFormGgData
 });
 
 class ButtonDirective {
@@ -8902,7 +9257,7 @@ class SliderComponent {
     constructor() {
         this._elementRef = inject(ElementRef);
         this._dirService = inject(Directionality);
-        this._document = inject(DOCUMENT);
+        this._document = inject(DOCUMENT$1);
         this._destroy$ = createDestroy();
         this._mouseDown$ = fromEvent(this._elementRef.nativeElement, 'mousedown', { passive: false });
         this._touchStart$ = fromEvent(this._elementRef.nativeElement, 'touchstart', {
@@ -9589,7 +9944,7 @@ class BottomSheetContainerBaseComponent extends CdkDialogContainer {
             this._trapFocus();
         }
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: BottomSheetContainerBaseComponent, deps: [{ token: i0.ElementRef }, { token: i1$1.FocusTrapFactory }, { token: DOCUMENT, optional: true }, { token: BOTTOM_SHEET_CONFIG }, { token: i1$1.InteractivityChecker }, { token: i0.NgZone }, { token: i2$1.OverlayRef }, { token: i1$1.FocusMonitor }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: BottomSheetContainerBaseComponent, deps: [{ token: i0.ElementRef }, { token: i1$1.FocusTrapFactory }, { token: DOCUMENT$1, optional: true }, { token: BOTTOM_SHEET_CONFIG }, { token: i1$1.InteractivityChecker }, { token: i0.NgZone }, { token: i2$1.OverlayRef }, { token: i1$1.FocusMonitor }], target: i0.ɵɵFactoryTarget.Component }); }
     static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "20.0.3", type: BottomSheetContainerBaseComponent, isStandalone: true, selector: "et-bottom-sheet-container-base", usesInheritance: true, ngImport: i0, template: '', isInline: true }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: BottomSheetContainerBaseComponent, decorators: [{
@@ -9602,7 +9957,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.3", ngImpor
                     type: Optional
                 }, {
                     type: Inject,
-                    args: [DOCUMENT]
+                    args: [DOCUMENT$1]
                 }] }, { type: undefined, decorators: [{
                     type: Inject,
                     args: [BOTTOM_SHEET_CONFIG]
@@ -9619,7 +9974,7 @@ class BottomSheetContainerComponent extends BottomSheetContainerBaseComponent {
     constructor() {
         const elementRef = inject(ElementRef);
         const focusTrapFactory = inject(FocusTrapFactory);
-        const document = inject(DOCUMENT);
+        const document = inject(DOCUMENT$1);
         const bottomSheetConfig = inject(BOTTOM_SHEET_CONFIG);
         const checker = inject(InteractivityChecker);
         const ngZone = inject(NgZone);
@@ -10290,7 +10645,7 @@ class DialogContainerBaseComponent extends CdkDialogContainer {
             this._trapFocus();
         }
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: DialogContainerBaseComponent, deps: [{ token: i0.ElementRef }, { token: i1$1.FocusTrapFactory }, { token: DOCUMENT, optional: true }, { token: DIALOG_CONFIG }, { token: i1$1.InteractivityChecker }, { token: i0.NgZone }, { token: i2$1.OverlayRef }, { token: i1$1.FocusMonitor }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: DialogContainerBaseComponent, deps: [{ token: i0.ElementRef }, { token: i1$1.FocusTrapFactory }, { token: DOCUMENT$1, optional: true }, { token: DIALOG_CONFIG }, { token: i1$1.InteractivityChecker }, { token: i0.NgZone }, { token: i2$1.OverlayRef }, { token: i1$1.FocusMonitor }], target: i0.ɵɵFactoryTarget.Component }); }
     static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "20.0.3", type: DialogContainerBaseComponent, isStandalone: true, selector: "et-dialog-container-base", usesInheritance: true, ngImport: i0, template: '', isInline: true }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: DialogContainerBaseComponent, decorators: [{
@@ -10303,7 +10658,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.3", ngImpor
                     type: Optional
                 }, {
                     type: Inject,
-                    args: [DOCUMENT]
+                    args: [DOCUMENT$1]
                 }] }, { type: undefined, decorators: [{
                     type: Inject,
                     args: [DIALOG_CONFIG]
@@ -10320,7 +10675,7 @@ class DialogContainerComponent extends DialogContainerBaseComponent {
     constructor() {
         const elementRef = inject(ElementRef);
         const focusTrapFactory = inject(FocusTrapFactory);
-        const document = inject(DOCUMENT);
+        const document = inject(DOCUMENT$1);
         const dialogConfig = inject(DIALOG_CONFIG);
         const checker = inject(InteractivityChecker);
         const ngZone = inject(NgZone);
@@ -13661,7 +14016,7 @@ class OverlayContainerComponent extends CdkDialogContainer {
         return super._ariaLabelledBy;
     }
     constructor() {
-        super(inject(ElementRef), inject(FocusTrapFactory), inject(DOCUMENT), inject(OVERLAY_CONFIG), inject(InteractivityChecker), inject(NgZone), inject(OverlayRef$1), inject(FocusMonitor));
+        super(inject(ElementRef), inject(FocusTrapFactory), inject(DOCUMENT$1), inject(OVERLAY_CONFIG), inject(InteractivityChecker), inject(NgZone), inject(OverlayRef$1), inject(FocusMonitor));
         this._swipeHandlerService = inject(SwipeHandlerService);
         this._dragToDismissStop$ = new Subject();
         this._themeProvider = inject(THEME_PROVIDER);
@@ -16528,7 +16883,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.3", ngImpor
 class PaginationHeadService {
     constructor() {
         this._config = null;
-        this._document = inject(DOCUMENT);
+        this._document = inject(DOCUMENT$1);
         this._titleService = inject(Title);
         this._router = inject(Router);
         this._head = this._document.getElementsByTagName('head')[0];
@@ -18411,7 +18766,7 @@ class InlineTabBodyHostDirective extends CdkPortalOutlet {
     constructor() {
         const componentFactoryResolver = inject(ComponentFactoryResolver);
         const viewContainerRef = inject(ViewContainerRef);
-        const _document = inject(DOCUMENT);
+        const _document = inject(DOCUMENT$1);
         super(componentFactoryResolver, viewContainerRef, _document);
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: InlineTabBodyHostDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }