@ethlete/cdk 4.45.0 → 4.46.0

package/esm2022/lib/components/bracket/components/new-bracket/draw-man.mjs

@@ -0,0 +1,66 @@
+const LINE_WIDTH = 1;
+const path = (d) => `<path d="${d}" stroke="red" fill="none" stroke-width="${LINE_WIDTH}" />`;
+export const drawMan = (items, roundRelations, dimensions) => {
+    const { columnWidth, matchHeight, rowGap, columnGap, roundHeaderHeight, gridDefinitions } = dimensions;
+    const roundHeaderRowGap = roundHeaderHeight ? rowGap : 0;
+    const baseOffsetY = roundHeaderHeight + roundHeaderRowGap;
+    const columnGapCenter = columnGap / 2;
+    const totalHeight = (gridDefinitions.rowCount - 1) * matchHeight + (gridDefinitions.rowCount - 1) * rowGap + roundHeaderHeight; // TODO: This is not correct in double elimination
+    const svgParts = [];
+    // a nothing to one draws nothing
+    // a one to nothing draws nothing
+    // a one to one draws a line
+    // a one to two draws a line that splits into in the middle
+    // a two to one draws two lines that merge into one in the middle
+    // WE ONLY EVER DRAW THE LEFT SIDE (on-to, nothing-to, two-to)
+    for (const round of items.values()) {
+        const rows = round.roundRelation.currentRound.matchCount;
+        const rowGaps = rows - 1;
+        const rowHeight = (totalHeight - baseOffsetY) / rows - rowGaps * rowGap;
+        const rowWhitespace = (rowHeight - matchHeight) / 2;
+        const matchHeightOffset = rowWhitespace + matchHeight / 2; // the vertical middle of a match in this row
+        for (const item of round.items.values()) {
+            if (item.type === 'round')
+                continue; // we don't draw lines for round headers
+            switch (item.matchRelation.type) {
+                case 'nothing-to-one': {
+                    continue;
+                }
+                case 'one-to-nothing':
+                case 'one-to-one': {
+                    // draw a straight line
+                    const previousRound = items.get(item.matchRelation.previousRound.id);
+                    if (!previousRound)
+                        throw new Error('Previous round or match is missing');
+                    const previousMatch = previousRound.items.get(item.matchRelation.previousMatch.id);
+                    if (!previousMatch || previousMatch.type !== 'match')
+                        throw new Error('Previous round or match is missing');
+                    const previousRoundRows = previousRound.roundRelation.currentRound.matchCount;
+                    const previousRoundRowGaps = previousRoundRows - 1;
+                    const previousRoundRowHeight = (totalHeight - baseOffsetY) / previousRoundRows - previousRoundRowGaps * rowGap;
+                    const previousRoundRowWhitespace = (previousRoundRowHeight - matchHeight) / 2;
+                    const previousRoundMatchHeightOffset = previousRoundRowWhitespace + matchHeight / 2;
+                    const fromX = previousRound.columnStart * columnWidth + (round.columnStart - 2) * columnGap;
+                    const toX = (round.columnStart - 1) * columnWidth + (round.columnStart - 1) * columnGap;
+                    const fromY = previousMatch.matchRelation.currentMatch.indexInRound * previousRoundRowWhitespace +
+                        previousMatch.matchRelation.currentMatch.indexInRound * rowGap +
+                        baseOffsetY +
+                        previousRoundMatchHeightOffset;
+                    const toY = item.matchRelation.currentMatch.indexInRound * rowWhitespace +
+                        item.matchRelation.currentMatch.indexInRound * rowGap +
+                        baseOffsetY +
+                        matchHeightOffset;
+                    svgParts.push(path(`M ${fromX} ${fromY} L ${toX} ${toY}`));
+                    break;
+                }
+                case 'two-to-nothing':
+                case 'two-to-one': {
+                    // draw two lines that merge into one in the middle
+                    break;
+                }
+            }
+        }
+    }
+    return svgParts.join(' /n');
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"draw-man.js","sourceRoot":"","sources":["../../../../../../../../../libs/cdk/src/lib/components/bracket/components/new-bracket/draw-man.ts"],"names":[],"mappings":"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","sourcesContent":["import { BracketRoundId, BracketRoundRelations } from './bracket-new';\nimport { BracketGridDefinitions } from './grid-definitions';\nimport { BracketGridRoundItem } from './grid-placements';\n\nexport type DrawManDimensions = {\n  columnWidth: number;\n  matchHeight: number;\n  roundHeaderHeight: number;\n  columnGap: number;\n  rowGap: number;\n  gridDefinitions: BracketGridDefinitions;\n};\n\nconst LINE_WIDTH = 1;\n\nconst path = (d: string) => `<path d=\"${d}\" stroke=\"red\" fill=\"none\" stroke-width=\"${LINE_WIDTH}\" />`;\n\nexport const drawMan = <TRoundData, TMatchData>(\n  items: Map<BracketRoundId, BracketGridRoundItem<TRoundData, TMatchData>>,\n  roundRelations: BracketRoundRelations<TRoundData, TMatchData>,\n  dimensions: DrawManDimensions,\n) => {\n  const { columnWidth, matchHeight, rowGap, columnGap, roundHeaderHeight, gridDefinitions } = dimensions;\n  const roundHeaderRowGap = roundHeaderHeight ? rowGap : 0;\n  const baseOffsetY = roundHeaderHeight + roundHeaderRowGap;\n\n  const columnGapCenter = columnGap / 2;\n  const totalHeight =\n    (gridDefinitions.rowCount - 1) * matchHeight + (gridDefinitions.rowCount - 1) * rowGap + roundHeaderHeight; // TODO: This is not correct in double elimination\n  const svgParts: string[] = [];\n\n  // a nothing to one draws nothing\n  // a one to nothing draws nothing\n  // a one to one draws a line\n  // a one to two draws a line that splits into in the middle\n  // a two to one draws two lines that merge into one in the middle\n\n  // WE ONLY EVER DRAW THE LEFT SIDE (on-to, nothing-to, two-to)\n\n  for (const round of items.values()) {\n    const rows = round.roundRelation.currentRound.matchCount;\n    const rowGaps = rows - 1;\n    const rowHeight = (totalHeight - baseOffsetY) / rows - rowGaps * rowGap;\n    const rowWhitespace = (rowHeight - matchHeight) / 2;\n    const matchHeightOffset = rowWhitespace + matchHeight / 2; // the vertical middle of a match in this row\n\n    for (const item of round.items.values()) {\n      if (item.type === 'round') continue; // we don't draw lines for round headers\n\n      switch (item.matchRelation.type) {\n        case 'nothing-to-one': {\n          continue;\n        }\n        case 'one-to-nothing':\n        case 'one-to-one': {\n          // draw a straight line\n          const previousRound = items.get(item.matchRelation.previousRound.id);\n          if (!previousRound) throw new Error('Previous round or match is missing');\n          const previousMatch = previousRound.items.get(item.matchRelation.previousMatch.id);\n          if (!previousMatch || previousMatch.type !== 'match') throw new Error('Previous round or match is missing');\n\n          const previousRoundRows = previousRound.roundRelation.currentRound.matchCount;\n          const previousRoundRowGaps = previousRoundRows - 1;\n\n          const previousRoundRowHeight =\n            (totalHeight - baseOffsetY) / previousRoundRows - previousRoundRowGaps * rowGap;\n\n          const previousRoundRowWhitespace = (previousRoundRowHeight - matchHeight) / 2;\n          const previousRoundMatchHeightOffset = previousRoundRowWhitespace + matchHeight / 2;\n\n          const fromX = previousRound.columnStart * columnWidth + (round.columnStart - 2) * columnGap;\n          const toX = (round.columnStart - 1) * columnWidth + (round.columnStart - 1) * columnGap;\n\n          const fromY =\n            previousMatch.matchRelation.currentMatch.indexInRound * previousRoundRowWhitespace +\n            previousMatch.matchRelation.currentMatch.indexInRound * rowGap +\n            baseOffsetY +\n            previousRoundMatchHeightOffset;\n          const toY =\n            item.matchRelation.currentMatch.indexInRound * rowWhitespace +\n            item.matchRelation.currentMatch.indexInRound * rowGap +\n            baseOffsetY +\n            matchHeightOffset;\n\n          svgParts.push(path(`M ${fromX} ${fromY} L ${toX} ${toY}`));\n\n          break;\n        }\n        case 'two-to-nothing':\n        case 'two-to-one': {\n          // draw two lines that merge into one in the middle\n\n          break;\n        }\n      }\n    }\n  }\n\n  return svgParts.join(' /n');\n};\n"]}

package/esm2022/lib/components/bracket/components/new-bracket/grid-definitions.mjs

@@ -0,0 +1,47 @@
+import { COMMON_BRACKET_ROUND_TYPE, DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE, TOURNAMENT_MODE, } from './bracket-new';
+const generateColumnCount = (bracketData, roundTypeMap) => {
+    const thirdPlaceRoundSize = roundTypeMap.get(COMMON_BRACKET_ROUND_TYPE.THIRD_PLACE)?.size || 0;
+    switch (bracketData.mode) {
+        case TOURNAMENT_MODE.DOUBLE_ELIMINATION: {
+            const upperBracketSize = roundTypeMap.get(DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE.UPPER_BRACKET)?.size || 0;
+            const lowerBracketSize = roundTypeMap.get(DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE.LOWER_BRACKET)?.size || 0;
+            // the total columns are the bigger number of winner bracket rounds vs looser bracket rounds + all other rounds excluding third place
+            return bracketData.rounds.size - thirdPlaceRoundSize + Math.max(upperBracketSize, lowerBracketSize);
+        }
+        default: {
+            // the total columns are the amount of rounds excluding third place
+            return bracketData.rounds.size - thirdPlaceRoundSize;
+        }
+    }
+};
+const generateRowCount = (bracketData, roundTypeMap, options) => {
+    switch (bracketData.mode) {
+        case TOURNAMENT_MODE.DOUBLE_ELIMINATION: {
+            const upperBracketSize = roundTypeMap.get(DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE.UPPER_BRACKET)?.values().next()
+                .value?.matchCount;
+            const lowerBracketSize = roundTypeMap.get(DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE.LOWER_BRACKET)?.values().next()
+                .value?.matchCount;
+            const roundHeadersCount = options.includeRoundHeaders ? 2 : 0;
+            if (upperBracketSize === undefined || lowerBracketSize === undefined) {
+                throw new Error('Upper or lower bracket size is undefined');
+            }
+            // the total rows the amount of matches in the first upper bracket round + first lower bracket round + if true, the round header row for both
+            return upperBracketSize + lowerBracketSize + roundHeadersCount;
+        }
+        default: {
+            const firstRoundSize = bracketData.rounds.values().next().value?.matchCount;
+            const roundHeadersCount = options.includeRoundHeaders ? 1 : 0;
+            if (firstRoundSize === undefined) {
+                throw new Error('First round size is undefined');
+            }
+            // the total rows are the amount of matches in the first round + if true, the round header row
+            return firstRoundSize + roundHeadersCount;
+        }
+    }
+};
+export const generateBracketGridDefinitions = (bracketData, roundTypeMap, options) => {
+    const columnCount = generateColumnCount(bracketData, roundTypeMap);
+    const rowCount = generateRowCount(bracketData, roundTypeMap, options);
+    return { columnCount, rowCount };
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/components/bracket/components/new-bracket/grid-placements.mjs

@@ -0,0 +1,97 @@
+import { TOURNAMENT_MODE, } from './bracket-new';
+import { NewBracketDefaultMatchComponent } from './new-bracket-default-match.component';
+import { NewBracketDefaultRoundHeaderComponent } from './new-bracket-default-round-header.component';
+export const generateBracketGridItems = (bracketData, roundTypeMap, swissGroups, roundRelations, matchRelations, options) => {
+    const roundHeaderComponent = options.headerComponent ?? NewBracketDefaultRoundHeaderComponent;
+    const matchComponent = options.matchComponent ?? NewBracketDefaultMatchComponent;
+    const optionsWithDefaults = {
+        ...options,
+        headerComponent: roundHeaderComponent,
+        matchComponent: matchComponent,
+    };
+    switch (bracketData.mode) {
+        case TOURNAMENT_MODE.DOUBLE_ELIMINATION:
+            return generateDoubleEliminationGridPlacements(bracketData, roundTypeMap, roundRelations, matchRelations, optionsWithDefaults);
+        case TOURNAMENT_MODE.SWISS_WITH_ELIMINATION: {
+            if (!swissGroups)
+                throw new Error('Swiss groups are required for swiss with elimination mode');
+            return generateSwissWithEliminationGridPlacements(bracketData, roundTypeMap, swissGroups, roundRelations, matchRelations, optionsWithDefaults);
+        }
+        default:
+            return generateGenericGridPlacements(bracketData, roundTypeMap, roundRelations, matchRelations, optionsWithDefaults);
+    }
+};
+const generateGenericGridPlacements = (bracketData, roundTypeMap, roundRelations, matchRelations, options) => {
+    const gridItems = new Map();
+    const firstRound = bracketData.rounds.values().next().value;
+    if (!firstRound) {
+        throw new Error('First round is missing');
+    }
+    for (const round of bracketData.rounds.values()) {
+        const roundRelation = roundRelations.get(round.id);
+        let currentMatchRow = 1;
+        const columnStart = round.index + 1;
+        const columnEnd = columnStart + 1;
+        if (!roundRelation) {
+            throw new Error('Round relation is missing');
+        }
+        if (roundRelation.type === 'two-to-nothing' || roundRelation.type === 'two-to-one') {
+            throw new Error(`Invalid relation type ${roundRelation.type}`);
+        }
+        const roundItem = {
+            id: round.id,
+            columnStart,
+            columnEnd,
+            roundRelation,
+            items: new Map(),
+        };
+        if (options.includeRoundHeaders) {
+            const roundHeaderItem = {
+                type: 'round',
+                id: round.id,
+                rowStart: currentMatchRow,
+                rowEnd: ++currentMatchRow,
+                component: options.headerComponent,
+                roundRelation,
+                data: {
+                    bracketRound: round,
+                },
+            };
+            roundItem.items.set(round.id, roundHeaderItem);
+        }
+        const rootRoundMatchFactor = roundRelation.type !== 'nothing-to-one' ? roundRelation.rootRoundMatchFactor : null;
+        const matchHeight = rootRoundMatchFactor ? rootRoundMatchFactor : 1;
+        for (const match of round.matches.values()) {
+            const matchRelation = matchRelations.get(match.id);
+            if (!matchRelation) {
+                throw new Error('Match relation is missing');
+            }
+            const baseRow = match.indexInRound * matchHeight;
+            const matchItem = {
+                type: 'match',
+                id: match.id,
+                rowStart: baseRow + currentMatchRow,
+                rowEnd: baseRow + currentMatchRow + matchHeight,
+                component: options.matchComponent,
+                matchRelation,
+                roundRelation,
+                data: {
+                    bracketRound: round,
+                    bracketMatch: match,
+                },
+            };
+            roundItem.items.set(match.id, matchItem);
+        }
+        gridItems.set(round.id, roundItem);
+    }
+    return gridItems;
+};
+const generateDoubleEliminationGridPlacements = (bracketData, roundTypeMap, roundRelations, matchRelations, options) => {
+    const gridItems = new Map();
+    return gridItems;
+};
+const generateSwissWithEliminationGridPlacements = (bracketData, roundTypeMap, swissGroups, roundRelations, matchRelations, options) => {
+    const gridItems = new Map();
+    return gridItems;
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"grid-placements.js","sourceRoot":"","sources":["../../../../../../../../../libs/cdk/src/lib/components/bracket/components/new-bracket/grid-placements.ts"],"names":[],"mappings":"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","sourcesContent":["import { ComponentType } from '@angular/cdk/portal';\nimport { InputSignal } from '@angular/core';\nimport {\n  BracketData,\n  BracketMatch,\n  BracketMatchId,\n  BracketMatchRelation,\n  BracketMatchRelationsMap,\n  BracketRound,\n  BracketRoundId,\n  BracketRoundMapWithSwissData,\n  BracketRoundRelation,\n  BracketRoundRelations,\n  BracketRoundTypeMap,\n  TOURNAMENT_MODE,\n} from './bracket-new';\nimport { NewBracketDefaultMatchComponent } from './new-bracket-default-match.component';\nimport { NewBracketDefaultRoundHeaderComponent } from './new-bracket-default-round-header.component';\n\nexport type BracketRoundHeaderComponent<TRoundData, TMatchData> = ComponentType<{\n  bracketRound: InputSignal<BracketRound<TRoundData, TMatchData>>;\n}>;\n\nexport type ComponentInputValue<T> = () => {\n  [P in keyof T]: T[P] extends InputSignal<infer U> ? U : never;\n};\n\nexport type BracketMatchComponent<TRoundData, TMatchData> = ComponentType<{\n  bracketRound: InputSignal<BracketRound<TRoundData, TMatchData>>;\n  bracketMatch: InputSignal<BracketMatch<TRoundData, TMatchData>>;\n}>;\n\nexport type BracketGridRoundItem<TRoundData, TMatchData> = {\n  id: string;\n  columnStart: number;\n  columnEnd: number;\n  roundRelation: BracketRoundRelation<TRoundData, TMatchData>;\n  items: Map<BracketRoundId | BracketMatchId, BracketGridItem<TRoundData, TMatchData>>;\n};\n\nexport type BracketGridRoundHeaderItem<TRoundData, TMatchData> = {\n  type: 'round';\n  id: string;\n  rowStart: number;\n  rowEnd: number;\n  component: BracketRoundHeaderComponent<TRoundData, TMatchData>;\n  roundRelation: BracketRoundRelation<TRoundData, TMatchData>;\n  data: {\n    bracketRound: BracketRound<TRoundData, TMatchData>;\n  };\n};\n\nexport type BracketGridMatchItem<TRoundData, TMatchData> = {\n  type: 'match';\n  id: string;\n  rowStart: number;\n  rowEnd: number;\n  component: BracketMatchComponent<TRoundData, TMatchData>;\n  matchRelation: BracketMatchRelation<TRoundData, TMatchData>;\n  roundRelation: BracketRoundRelation<TRoundData, TMatchData>;\n  data: {\n    bracketRound: BracketRound<TRoundData, TMatchData>;\n    bracketMatch: BracketMatch<TRoundData, TMatchData>;\n  };\n};\n\nexport type BracketGridItem<TRoundData, TMatchData> =\n  | BracketGridRoundHeaderItem<TRoundData, TMatchData>\n  | BracketGridMatchItem<TRoundData, TMatchData>;\n\nexport type GenerateBracketGridItemsOptions<TRoundData, TMatchData> = {\n  includeRoundHeaders: boolean;\n  headerComponent?: BracketRoundHeaderComponent<TRoundData, TMatchData>;\n  matchComponent?: BracketMatchComponent<TRoundData, TMatchData>;\n};\n\nexport type GenerateBracketGridItemsOptionsWithDefaults<TRoundData, TMatchData> = {\n  includeRoundHeaders: boolean;\n  headerComponent: BracketRoundHeaderComponent<TRoundData, TMatchData>;\n  matchComponent: BracketMatchComponent<TRoundData, TMatchData>;\n};\n\nexport const generateBracketGridItems = <TRoundData, TMatchData>(\n  bracketData: BracketData<TRoundData, TMatchData>,\n  roundTypeMap: BracketRoundTypeMap<TRoundData, TMatchData>,\n  swissGroups: BracketRoundMapWithSwissData<TRoundData, TMatchData> | null,\n  roundRelations: BracketRoundRelations<TRoundData, TMatchData>,\n  matchRelations: BracketMatchRelationsMap<TRoundData, TMatchData>,\n  options: GenerateBracketGridItemsOptions<TRoundData, TMatchData>,\n) => {\n  const roundHeaderComponent = options.headerComponent ?? NewBracketDefaultRoundHeaderComponent;\n  const matchComponent = options.matchComponent ?? NewBracketDefaultMatchComponent;\n\n  const optionsWithDefaults: GenerateBracketGridItemsOptionsWithDefaults<TRoundData, TMatchData> = {\n    ...options,\n    headerComponent: roundHeaderComponent,\n    matchComponent: matchComponent,\n  };\n\n  switch (bracketData.mode) {\n    case TOURNAMENT_MODE.DOUBLE_ELIMINATION:\n      return generateDoubleEliminationGridPlacements(\n        bracketData,\n        roundTypeMap,\n        roundRelations,\n        matchRelations,\n        optionsWithDefaults,\n      );\n    case TOURNAMENT_MODE.SWISS_WITH_ELIMINATION: {\n      if (!swissGroups) throw new Error('Swiss groups are required for swiss with elimination mode');\n\n      return generateSwissWithEliminationGridPlacements(\n        bracketData,\n        roundTypeMap,\n        swissGroups,\n        roundRelations,\n        matchRelations,\n        optionsWithDefaults,\n      );\n    }\n\n    default:\n      return generateGenericGridPlacements(\n        bracketData,\n        roundTypeMap,\n        roundRelations,\n        matchRelations,\n        optionsWithDefaults,\n      );\n  }\n};\n\nconst generateGenericGridPlacements = <TRoundData, TMatchData>(\n  bracketData: BracketData<TRoundData, TMatchData>,\n  roundTypeMap: BracketRoundTypeMap<TRoundData, TMatchData>,\n  roundRelations: BracketRoundRelations<TRoundData, TMatchData>,\n  matchRelations: BracketMatchRelationsMap<TRoundData, TMatchData>,\n  options: GenerateBracketGridItemsOptionsWithDefaults<TRoundData, TMatchData>,\n) => {\n  const gridItems: Map<BracketRoundId, BracketGridRoundItem<TRoundData, TMatchData>> = new Map();\n  const firstRound = bracketData.rounds.values().next().value;\n\n  if (!firstRound) {\n    throw new Error('First round is missing');\n  }\n\n  for (const round of bracketData.rounds.values()) {\n    const roundRelation = roundRelations.get(round.id);\n\n    let currentMatchRow = 1;\n\n    const columnStart = round.index + 1;\n    const columnEnd = columnStart + 1;\n\n    if (!roundRelation) {\n      throw new Error('Round relation is missing');\n    }\n\n    if (roundRelation.type === 'two-to-nothing' || roundRelation.type === 'two-to-one') {\n      throw new Error(`Invalid relation type ${roundRelation.type}`);\n    }\n\n    const roundItem: BracketGridRoundItem<TRoundData, TMatchData> = {\n      id: round.id,\n      columnStart,\n      columnEnd,\n      roundRelation,\n      items: new Map(),\n    };\n\n    if (options.includeRoundHeaders) {\n      const roundHeaderItem: BracketGridRoundHeaderItem<TRoundData, TMatchData> = {\n        type: 'round',\n        id: round.id,\n        rowStart: currentMatchRow,\n        rowEnd: ++currentMatchRow,\n        component: options.headerComponent,\n        roundRelation,\n        data: {\n          bracketRound: round,\n        },\n      };\n\n      roundItem.items.set(round.id, roundHeaderItem);\n    }\n\n    const rootRoundMatchFactor = roundRelation.type !== 'nothing-to-one' ? roundRelation.rootRoundMatchFactor : null;\n    const matchHeight = rootRoundMatchFactor ? rootRoundMatchFactor : 1;\n\n    for (const match of round.matches.values()) {\n      const matchRelation = matchRelations.get(match.id);\n\n      if (!matchRelation) {\n        throw new Error('Match relation is missing');\n      }\n\n      const baseRow = match.indexInRound * matchHeight;\n\n      const matchItem: BracketGridMatchItem<TRoundData, TMatchData> = {\n        type: 'match',\n        id: match.id,\n        rowStart: baseRow + currentMatchRow,\n        rowEnd: baseRow + currentMatchRow + matchHeight,\n        component: options.matchComponent,\n        matchRelation,\n        roundRelation,\n        data: {\n          bracketRound: round,\n          bracketMatch: match,\n        },\n      };\n\n      roundItem.items.set(match.id, matchItem);\n    }\n\n    gridItems.set(round.id, roundItem);\n  }\n\n  return gridItems;\n};\n\nconst generateDoubleEliminationGridPlacements = <TRoundData, TMatchData>(\n  bracketData: BracketData<TRoundData, TMatchData>,\n  roundTypeMap: BracketRoundTypeMap<TRoundData, TMatchData>,\n  roundRelations: BracketRoundRelations<TRoundData, TMatchData>,\n  matchRelations: BracketMatchRelationsMap<TRoundData, TMatchData>,\n  options: GenerateBracketGridItemsOptionsWithDefaults<TRoundData, TMatchData>,\n) => {\n  const gridItems: Map<BracketRoundId, BracketGridRoundItem<TRoundData, TMatchData>> = new Map();\n\n  return gridItems;\n};\n\nconst generateSwissWithEliminationGridPlacements = <TRoundData, TMatchData>(\n  bracketData: BracketData<TRoundData, TMatchData>,\n  roundTypeMap: BracketRoundTypeMap<TRoundData, TMatchData>,\n  swissGroups: BracketRoundMapWithSwissData<TRoundData, TMatchData>,\n  roundRelations: BracketRoundRelations<TRoundData, TMatchData>,\n  matchRelations: BracketMatchRelationsMap<TRoundData, TMatchData>,\n  options: GenerateBracketGridItemsOptionsWithDefaults<TRoundData, TMatchData>,\n) => {\n  const gridItems: Map<BracketRoundId, BracketGridRoundItem<TRoundData, TMatchData>> = new Map();\n\n  return gridItems;\n};\n"]}

package/esm2022/lib/components/bracket/components/new-bracket/index.mjs

@@ -0,0 +1,8 @@
+export * from './bracket-new';
+export * from './draw-man';
+export * from './grid-definitions';
+export * from './grid-placements';
+export * from './new-bracket-default-match.component';
+export * from './new-bracket-default-round-header.component';
+export * from './new-bracket.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2Nkay9zcmMvbGliL2NvbXBvbmVudHMvYnJhY2tldC9jb21wb25lbnRzL25ldy1icmFja2V0L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsZUFBZSxDQUFDO0FBQzlCLGNBQWMsWUFBWSxDQUFDO0FBQzNCLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsY0FBYyxtQkFBbUIsQ0FBQztBQUNsQyxjQUFjLHVDQUF1QyxDQUFDO0FBQ3RELGNBQWMsOENBQThDLENBQUM7QUFDN0QsY0FBYyx5QkFBeUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vYnJhY2tldC1uZXcnO1xuZXhwb3J0ICogZnJvbSAnLi9kcmF3LW1hbic7XG5leHBvcnQgKiBmcm9tICcuL2dyaWQtZGVmaW5pdGlvbnMnO1xuZXhwb3J0ICogZnJvbSAnLi9ncmlkLXBsYWNlbWVudHMnO1xuZXhwb3J0ICogZnJvbSAnLi9uZXctYnJhY2tldC1kZWZhdWx0LW1hdGNoLmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL25ldy1icmFja2V0LWRlZmF1bHQtcm91bmQtaGVhZGVyLmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL25ldy1icmFja2V0LmNvbXBvbmVudCc7XG4iXX0=

package/esm2022/lib/components/bracket/components/new-bracket/new-bracket-default-match.component.mjs

@@ -0,0 +1,17 @@
+import { ChangeDetectionStrategy, Component, input, ViewEncapsulation } from '@angular/core';
+import * as i0 from "@angular/core";
+export class NewBracketDefaultMatchComponent {
+    constructor() {
+        this.bracketRound = input.required();
+        this.bracketMatch = input.required();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.11", ngImport: i0, type: NewBracketDefaultMatchComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "18.2.11", type: NewBracketDefaultMatchComponent, isStandalone: true, selector: "et-new-bracket-default-match", inputs: { bracketRound: { classPropertyName: "bracketRound", publicName: "bracketRound", isSignal: true, isRequired: true, transformFunction: null }, bracketMatch: { classPropertyName: "bracketMatch", publicName: "bracketMatch", isSignal: true, isRequired: true, transformFunction: null } }, host: { classAttribute: "et-new-bracket-default-match-host" }, ngImport: i0, template: ` {{ bracketMatch().id }} `, isInline: true, styles: [".et-new-bracket-default-match-host{display:block;padding:8px;border:1px solid yellow;inline-size:250px;block-size:75px;display:flex;justify-content:center;align-items:center;box-sizing:border-box;font-size:12px}\n"], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.11", ngImport: i0, type: NewBracketDefaultMatchComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'et-new-bracket-default-match', template: ` {{ bracketMatch().id }} `, standalone: true, changeDetection: ChangeDetectionStrategy.OnPush, encapsulation: ViewEncapsulation.None, host: {
+                        class: 'et-new-bracket-default-match-host',
+                    }, styles: [".et-new-bracket-default-match-host{display:block;padding:8px;border:1px solid yellow;inline-size:250px;block-size:75px;display:flex;justify-content:center;align-items:center;box-sizing:border-box;font-size:12px}\n"] }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/components/bracket/components/new-bracket/new-bracket-default-round-header.component.mjs

@@ -0,0 +1,16 @@
+import { ChangeDetectionStrategy, Component, input, ViewEncapsulation } from '@angular/core';
+import * as i0 from "@angular/core";
+export class NewBracketDefaultRoundHeaderComponent {
+    constructor() {
+        this.bracketRound = input.required();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.11", ngImport: i0, type: NewBracketDefaultRoundHeaderComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "18.2.11", type: NewBracketDefaultRoundHeaderComponent, isStandalone: true, selector: "et-new-bracket-default-round-header", inputs: { bracketRound: { classPropertyName: "bracketRound", publicName: "bracketRound", isSignal: true, isRequired: true, transformFunction: null } }, host: { classAttribute: "et-new-bracket-default-round-header-host" }, ngImport: i0, template: ` {{ bracketRound().name }} `, isInline: true, styles: [".et-new-bracket-default-round-header-host{display:block;padding:8px;border:1px solid green;inline-size:250px;block-size:50px;display:flex;justify-content:center;align-items:center;box-sizing:border-box}\n"], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.11", ngImport: i0, type: NewBracketDefaultRoundHeaderComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'et-new-bracket-default-round-header', template: ` {{ bracketRound().name }} `, standalone: true, changeDetection: ChangeDetectionStrategy.OnPush, encapsulation: ViewEncapsulation.None, host: {
+                        class: 'et-new-bracket-default-round-header-host',
+                    }, styles: [".et-new-bracket-default-round-header-host{display:block;padding:8px;border:1px solid green;inline-size:250px;block-size:50px;display:flex;justify-content:center;align-items:center;box-sizing:border-box}\n"] }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/components/bracket/components/new-bracket/new-bracket.component.mjs

@@ -0,0 +1,54 @@
+import { NgComponentOutlet } from '@angular/common';
+import { booleanAttribute, ChangeDetectionStrategy, Component, computed, inject, input, numberAttribute, ViewEncapsulation, } from '@angular/core';
+import { DomSanitizer } from '@angular/platform-browser';
+import { generateBracketRoundSwissGroupMaps, generateBracketRoundTypeMap, generateMatchParticipantMap, generateMatchPositionMaps, generateMatchRelations, generateRoundRelations, } from './bracket-new';
+import { drawMan } from './draw-man';
+import { generateBracketGridDefinitions } from './grid-definitions';
+import { generateBracketGridItems } from './grid-placements';
+import * as i0 from "@angular/core";
+export class NewBracketComponent {
+    constructor() {
+        this.#domSanitizer = inject(DomSanitizer);
+        this.bracketData = input.required();
+        this.columnWidth = input(250, { transform: numberAttribute });
+        this.matchHeight = input(75, { transform: numberAttribute });
+        this.roundHeaderHeight = input(50, { transform: numberAttribute });
+        this.columnGap = input(60, { transform: numberAttribute });
+        this.rowGap = input(30, { transform: numberAttribute });
+        this.hideRoundHeaders = input(false, { transform: booleanAttribute });
+        this.roundHeaderComponent = input();
+        this.matchComponent = input();
+        this.roundTypeMap = computed(() => generateBracketRoundTypeMap(this.bracketData()));
+        this.matchParticipantMap = computed(() => generateMatchParticipantMap(this.bracketData()));
+        this.matchPositionsMap = computed(() => generateMatchPositionMaps(this.bracketData()));
+        this.roundRelations = computed(() => generateRoundRelations(this.bracketData()));
+        this.matchRelations = computed(() => generateMatchRelations(this.bracketData(), this.roundRelations(), this.matchPositionsMap()));
+        this.swissGroups = computed(() => generateBracketRoundSwissGroupMaps(this.bracketData(), this.matchParticipantMap()));
+        this.items = computed(() => generateBracketGridItems(this.bracketData(), this.roundTypeMap(), this.swissGroups(), this.roundRelations(), this.matchRelations(), {
+            includeRoundHeaders: !this.hideRoundHeaders(),
+            headerComponent: this.roundHeaderComponent(),
+            matchComponent: this.matchComponent(),
+        }));
+        this.definitions = computed(() => generateBracketGridDefinitions(this.bracketData(), this.roundTypeMap(), {
+            includeRoundHeaders: !this.hideRoundHeaders(),
+        }));
+        this.drawManData = computed(() => this.#domSanitizer.bypassSecurityTrustHtml(drawMan(this.items(), this.roundRelations(), {
+            columnGap: this.columnGap(),
+            columnWidth: this.columnWidth(),
+            matchHeight: this.matchHeight(),
+            roundHeaderHeight: this.hideRoundHeaders() ? 0 : this.roundHeaderHeight(),
+            rowGap: this.rowGap(),
+            gridDefinitions: this.definitions(),
+        })));
+    }
+    #domSanitizer;
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.11", ngImport: i0, type: NewBracketComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.11", type: NewBracketComponent, isStandalone: true, selector: "et-new-bracket", inputs: { bracketData: { classPropertyName: "bracketData", publicName: "bracketData", isSignal: true, isRequired: true, transformFunction: null }, columnWidth: { classPropertyName: "columnWidth", publicName: "columnWidth", isSignal: true, isRequired: false, transformFunction: null }, matchHeight: { classPropertyName: "matchHeight", publicName: "matchHeight", isSignal: true, isRequired: false, transformFunction: null }, roundHeaderHeight: { classPropertyName: "roundHeaderHeight", publicName: "roundHeaderHeight", isSignal: true, isRequired: false, transformFunction: null }, columnGap: { classPropertyName: "columnGap", publicName: "columnGap", isSignal: true, isRequired: false, transformFunction: null }, rowGap: { classPropertyName: "rowGap", publicName: "rowGap", isSignal: true, isRequired: false, transformFunction: null }, hideRoundHeaders: { classPropertyName: "hideRoundHeaders", publicName: "hideRoundHeaders", isSignal: true, isRequired: false, transformFunction: null }, roundHeaderComponent: { classPropertyName: "roundHeaderComponent", publicName: "roundHeaderComponent", isSignal: true, isRequired: false, transformFunction: null }, matchComponent: { classPropertyName: "matchComponent", publicName: "matchComponent", isSignal: true, isRequired: false, transformFunction: null } }, host: { classAttribute: "et-new-bracket-host" }, ngImport: i0, template: "<section\n  [style.--_cw.px]=\"columnWidth()\"\n  [style.--_mh.px]=\"matchHeight()\"\n  [style.--_rhh.px]=\"roundHeaderHeight()\"\n  [style.--_cg.px]=\"columnGap()\"\n  [style.--_rg.px]=\"rowGap()\"\n  [style.--_bcc]=\"definitions().columnCount\"\n  [style.--_brc]=\"definitions().rowCount\"\n  class=\"et-bracket-new\"\n>\n  <svg [innerHTML]=\"drawManData()\" class=\"et-bracket-new-svg\" xmlns=\"http://www.w3.org/2000/svg\" />\n\n  @for (round of items().values(); track round.id) {\n    <ul [style.--_c]=\"round.columnStart + ' / ' + round.columnEnd\" class=\"et-bracket-new-round\">\n      @for (item of round.items.values(); track item.id) {\n        <li [style.--_r]=\"item.rowStart + ' / ' + item.rowEnd\" class=\"et-bracket-new-item\">\n          <ng-container *ngComponentOutlet=\"item.component; inputs: item.data\" />\n        </li>\n      }\n    </ul>\n  }\n</section>\n", styles: [".et-bracket-new{display:grid;gap:var(--_cg);grid-auto-columns:var(--_cw)}.et-bracket-new-round{display:grid;grid-column:var(--_c);grid-row:1;list-style:none;margin:0;padding:0;gap:var(--_rg);grid-template-rows:var(--_rhh);grid-auto-rows:var(--_mh)}.et-bracket-new-item{grid-row:var(--_r);place-self:center}.et-bracket-new-svg{grid-column:1/calc(var(--_bcc) + 1);grid-row:1/2;inline-size:100%;block-size:100%}\n"], dependencies: [{ kind: "directive", type: NgComponentOutlet, selector: "[ngComponentOutlet]", inputs: ["ngComponentOutlet", "ngComponentOutletInputs", "ngComponentOutletInjector", "ngComponentOutletContent", "ngComponentOutletNgModule", "ngComponentOutletNgModuleFactory"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.11", ngImport: i0, type: NewBracketComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'et-new-bracket', standalone: true, changeDetection: ChangeDetectionStrategy.OnPush, encapsulation: ViewEncapsulation.None, host: {
+                        class: 'et-new-bracket-host',
+                    }, imports: [NgComponentOutlet], template: "<section\n  [style.--_cw.px]=\"columnWidth()\"\n  [style.--_mh.px]=\"matchHeight()\"\n  [style.--_rhh.px]=\"roundHeaderHeight()\"\n  [style.--_cg.px]=\"columnGap()\"\n  [style.--_rg.px]=\"rowGap()\"\n  [style.--_bcc]=\"definitions().columnCount\"\n  [style.--_brc]=\"definitions().rowCount\"\n  class=\"et-bracket-new\"\n>\n  <svg [innerHTML]=\"drawManData()\" class=\"et-bracket-new-svg\" xmlns=\"http://www.w3.org/2000/svg\" />\n\n  @for (round of items().values(); track round.id) {\n    <ul [style.--_c]=\"round.columnStart + ' / ' + round.columnEnd\" class=\"et-bracket-new-round\">\n      @for (item of round.items.values(); track item.id) {\n        <li [style.--_r]=\"item.rowStart + ' / ' + item.rowEnd\" class=\"et-bracket-new-item\">\n          <ng-container *ngComponentOutlet=\"item.component; inputs: item.data\" />\n        </li>\n      }\n    </ul>\n  }\n</section>\n", styles: [".et-bracket-new{display:grid;gap:var(--_cg);grid-auto-columns:var(--_cw)}.et-bracket-new-round{display:grid;grid-column:var(--_c);grid-row:1;list-style:none;margin:0;padding:0;gap:var(--_rg);grid-template-rows:var(--_rhh);grid-auto-rows:var(--_mh)}.et-bracket-new-item{grid-row:var(--_r);place-self:center}.et-bracket-new-svg{grid-column:1/calc(var(--_bcc) + 1);grid-row:1/2;inline-size:100%;block-size:100%}\n"] }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"new-bracket.component.js","sourceRoot":"","sources":["../../../../../../../../../libs/cdk/src/lib/components/bracket/components/new-bracket/new-bracket.component.ts","../../../../../../../../../libs/cdk/src/lib/components/bracket/components/new-bracket/new-bracket.component.html"],"names":[],"mappings":"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","sourcesContent":["import { NgComponentOutlet } from '@angular/common';\nimport {\n  booleanAttribute,\n  ChangeDetectionStrategy,\n  Component,\n  computed,\n  inject,\n  input,\n  numberAttribute,\n  ViewEncapsulation,\n} from '@angular/core';\nimport { DomSanitizer } from '@angular/platform-browser';\nimport {\n  BracketData,\n  generateBracketRoundSwissGroupMaps,\n  generateBracketRoundTypeMap,\n  generateMatchParticipantMap,\n  generateMatchPositionMaps,\n  generateMatchRelations,\n  generateRoundRelations,\n} from './bracket-new';\nimport { drawMan } from './draw-man';\nimport { generateBracketGridDefinitions } from './grid-definitions';\nimport { BracketMatchComponent, BracketRoundHeaderComponent, generateBracketGridItems } from './grid-placements';\n\n@Component({\n  selector: 'et-new-bracket',\n  templateUrl: './new-bracket.component.html',\n  styleUrl: './new-bracket.component.scss',\n  standalone: true,\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  encapsulation: ViewEncapsulation.None,\n  host: {\n    class: 'et-new-bracket-host',\n  },\n  imports: [NgComponentOutlet],\n})\nexport class NewBracketComponent<TRoundData = unknown, TMatchData = unknown> {\n  #domSanitizer = inject(DomSanitizer);\n  bracketData = input.required<BracketData<TRoundData, TMatchData>>();\n\n  columnWidth = input(250, { transform: numberAttribute });\n  matchHeight = input(75, { transform: numberAttribute });\n  roundHeaderHeight = input(50, { transform: numberAttribute });\n  columnGap = input(60, { transform: numberAttribute });\n  rowGap = input(30, { transform: numberAttribute });\n\n  hideRoundHeaders = input(false, { transform: booleanAttribute });\n\n  roundHeaderComponent = input<BracketRoundHeaderComponent<TRoundData, TMatchData> | undefined>();\n  matchComponent = input<BracketMatchComponent<TRoundData, TMatchData> | undefined>();\n\n  roundTypeMap = computed(() => generateBracketRoundTypeMap(this.bracketData()));\n  matchParticipantMap = computed(() => generateMatchParticipantMap(this.bracketData()));\n  matchPositionsMap = computed(() => generateMatchPositionMaps(this.bracketData()));\n\n  roundRelations = computed(() => generateRoundRelations(this.bracketData()));\n  matchRelations = computed(() =>\n    generateMatchRelations(this.bracketData(), this.roundRelations(), this.matchPositionsMap()),\n  );\n\n  swissGroups = computed(() => generateBracketRoundSwissGroupMaps(this.bracketData(), this.matchParticipantMap()));\n\n  items = computed(() =>\n    generateBracketGridItems(\n      this.bracketData(),\n      this.roundTypeMap(),\n      this.swissGroups(),\n      this.roundRelations(),\n      this.matchRelations(),\n      {\n        includeRoundHeaders: !this.hideRoundHeaders(),\n        headerComponent: this.roundHeaderComponent(),\n        matchComponent: this.matchComponent(),\n      },\n    ),\n  );\n\n  definitions = computed(() =>\n    generateBracketGridDefinitions(this.bracketData(), this.roundTypeMap(), {\n      includeRoundHeaders: !this.hideRoundHeaders(),\n    }),\n  );\n\n  drawManData = computed(() =>\n    this.#domSanitizer.bypassSecurityTrustHtml(\n      drawMan(this.items(), this.roundRelations(), {\n        columnGap: this.columnGap(),\n        columnWidth: this.columnWidth(),\n        matchHeight: this.matchHeight(),\n        roundHeaderHeight: this.hideRoundHeaders() ? 0 : this.roundHeaderHeight(),\n        rowGap: this.rowGap(),\n        gridDefinitions: this.definitions(),\n      }),\n    ),\n  );\n}\n","<section\n  [style.--_cw.px]=\"columnWidth()\"\n  [style.--_mh.px]=\"matchHeight()\"\n  [style.--_rhh.px]=\"roundHeaderHeight()\"\n  [style.--_cg.px]=\"columnGap()\"\n  [style.--_rg.px]=\"rowGap()\"\n  [style.--_bcc]=\"definitions().columnCount\"\n  [style.--_brc]=\"definitions().rowCount\"\n  class=\"et-bracket-new\"\n>\n  <svg [innerHTML]=\"drawManData()\" class=\"et-bracket-new-svg\" xmlns=\"http://www.w3.org/2000/svg\" />\n\n  @for (round of items().values(); track round.id) {\n    <ul [style.--_c]=\"round.columnStart + ' / ' + round.columnEnd\" class=\"et-bracket-new-round\">\n      @for (item of round.items.values(); track item.id) {\n        <li [style.--_r]=\"item.rowStart + ' / ' + item.rowEnd\" class=\"et-bracket-new-item\">\n          <ng-container *ngComponentOutlet=\"item.component; inputs: item.data\" />\n        </li>\n      }\n    </ul>\n  }\n</section>\n"]}

package/esm2022/lib/components/bracket/public-api/index.mjs

@@ -1,5 +1,6 @@
 export * from '../bracket.imports';
 export * from '../components/bracket';
+export * as BracketNew from '../components/new-bracket';
 export * from '../constants';
 export * from '../directives/bracket-match';
 export * from '../directives/bracket-round';
@@ -7,4 +8,4 @@ export * from '../partials/bracket-match';
 export * from '../partials/bracket-round-header';
 export * from '../types';
 export * from '../utils';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2Nkay9zcmMvbGliL2NvbXBvbmVudHMvYnJhY2tldC9wdWJsaWMtYXBpL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsY0FBYyx1QkFBdUIsQ0FBQztBQUN0QyxjQUFjLGNBQWMsQ0FBQztBQUM3QixjQUFjLDZCQUE2QixDQUFDO0FBQzVDLGNBQWMsNkJBQTZCLENBQUM7QUFDNUMsY0FBYywyQkFBMkIsQ0FBQztBQUMxQyxjQUFjLGtDQUFrQyxDQUFDO0FBQ2pELGNBQWMsVUFBVSxDQUFDO0FBQ3pCLGNBQWMsVUFBVSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi4vYnJhY2tldC5pbXBvcnRzJztcbmV4cG9ydCAqIGZyb20gJy4uL2NvbXBvbmVudHMvYnJhY2tldCc7XG5leHBvcnQgKiBmcm9tICcuLi9jb25zdGFudHMnO1xuZXhwb3J0ICogZnJvbSAnLi4vZGlyZWN0aXZlcy9icmFja2V0LW1hdGNoJztcbmV4cG9ydCAqIGZyb20gJy4uL2RpcmVjdGl2ZXMvYnJhY2tldC1yb3VuZCc7XG5leHBvcnQgKiBmcm9tICcuLi9wYXJ0aWFscy9icmFja2V0LW1hdGNoJztcbmV4cG9ydCAqIGZyb20gJy4uL3BhcnRpYWxzL2JyYWNrZXQtcm91bmQtaGVhZGVyJztcbmV4cG9ydCAqIGZyb20gJy4uL3R5cGVzJztcbmV4cG9ydCAqIGZyb20gJy4uL3V0aWxzJztcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2Nkay9zcmMvbGliL2NvbXBvbmVudHMvYnJhY2tldC9wdWJsaWMtYXBpL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsY0FBYyx1QkFBdUIsQ0FBQztBQUN0QyxPQUFPLEtBQUssVUFBVSxNQUFNLDJCQUEyQixDQUFDO0FBQ3hELGNBQWMsY0FBYyxDQUFDO0FBQzdCLGNBQWMsNkJBQTZCLENBQUM7QUFDNUMsY0FBYyw2QkFBNkIsQ0FBQztBQUM1QyxjQUFjLDJCQUEyQixDQUFDO0FBQzFDLGNBQWMsa0NBQWtDLENBQUM7QUFDakQsY0FBYyxVQUFVLENBQUM7QUFDekIsY0FBYyxVQUFVLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuLi9icmFja2V0LmltcG9ydHMnO1xuZXhwb3J0ICogZnJvbSAnLi4vY29tcG9uZW50cy9icmFja2V0JztcbmV4cG9ydCAqIGFzIEJyYWNrZXROZXcgZnJvbSAnLi4vY29tcG9uZW50cy9uZXctYnJhY2tldCc7XG5leHBvcnQgKiBmcm9tICcuLi9jb25zdGFudHMnO1xuZXhwb3J0ICogZnJvbSAnLi4vZGlyZWN0aXZlcy9icmFja2V0LW1hdGNoJztcbmV4cG9ydCAqIGZyb20gJy4uL2RpcmVjdGl2ZXMvYnJhY2tldC1yb3VuZCc7XG5leHBvcnQgKiBmcm9tICcuLi9wYXJ0aWFscy9icmFja2V0LW1hdGNoJztcbmV4cG9ydCAqIGZyb20gJy4uL3BhcnRpYWxzL2JyYWNrZXQtcm91bmQtaGVhZGVyJztcbmV4cG9ydCAqIGZyb20gJy4uL3R5cGVzJztcbmV4cG9ydCAqIGZyb20gJy4uL3V0aWxzJztcbiJdfQ==