@algoux/standard-ranklist-renderer-component-angular 0.6.0 → 0.6.2

package/dist/esm2022/lib/ranklist/ranklist.component.mjs

@@ -0,0 +1,1010 @@
+import { CommonModule } from '@angular/common';
+import { ChangeDetectionStrategy, Component, ContentChild, EventEmitter, Input, Output, } from '@angular/core';
+import { EnumTheme, formatTimeDuration, numberToAlphabet, resolveStyle, resolveText, resolveUserMarkers, } from '@algoux/standard-ranklist-utils';
+import { calculateDirtPercentage, calculateProblemStatisticsFooter, calculateSEValue, caniuse, formatProblemStatisticsAcceptedMinute, formatProblemStatisticsAverageHardness, formatProblemStatisticsPercent, getMarkerPresentation, getProblemHeaderBackgroundImage, getRankProblemStatusCellPresentation, resolveSrkAssetUrl, shouldShowTimeColumn, srkSupportedVersions, } from '@algoux/standard-ranklist-renderer-component-core';
+import { captureModalTriggerPointFromMouseEvent } from '../modal/modal-interactions';
+import { SrkStatusCellTemplateDirective, } from './status-cell-template.directive';
+import { SrkUserCellTemplateDirective, } from './user-cell-template.directive';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+export class RanklistComponent {
+    data;
+    theme = EnumTheme.light;
+    rowBordered = false;
+    columnBordered = false;
+    rowStriped = false;
+    formatSrkAssetUrl;
+    splitOrganization = false;
+    columnTitles;
+    statusCellPreset = 'classic';
+    statusColorAsText = false;
+    showProblemStatisticsFooter = false;
+    showDirtColumn = false;
+    showSEColumn = false;
+    emptyStatusPlaceholder = null;
+    userAvatarPlacement = 'user';
+    userClick = new EventEmitter();
+    solutionClick = new EventEmitter();
+    statusCellTemplate;
+    userCellTemplate;
+    supportedVersions = srkSupportedVersions;
+    firstBloodStar = '\u2605';
+    statusSeparator = ' ';
+    problemStatisticsFooterRows = [
+        {
+            key: 'accepted',
+            label: 'Accepted',
+            tooltip: 'Number of participants who solved this problem',
+        },
+        {
+            key: 'tried',
+            label: 'Tried',
+            tooltip: 'Number of participants who attempted this problem',
+        },
+        {
+            key: 'submitted',
+            label: 'Submitted',
+            tooltip: 'Total number of valid submissions for this problem',
+        },
+        {
+            key: 'dirt',
+            label: 'Dirt',
+            tooltip: 'Wrong submissions among participants who solved this problem',
+        },
+        {
+            key: 'se',
+            label: 'SE',
+            tooltip: 'Average hardness, calculated as (participants - accepted) / participants',
+        },
+        {
+            key: 'firstAccepted',
+            label: 'FB at',
+            tooltip: 'First Blood at, also known as first solve time, in minutes',
+        },
+        {
+            key: 'lastAccepted',
+            label: 'LB at',
+            tooltip: 'Last Blood at, also known as last solve time, in minutes',
+        },
+    ];
+    problemStatisticsSource;
+    problemStatisticsCache;
+    get problemStatistics() {
+        if (!this.showProblemStatisticsFooter && !this.showSEColumn) {
+            return [];
+        }
+        if (this.problemStatisticsSource !== this.data || !this.problemStatisticsCache) {
+            this.problemStatisticsSource = this.data;
+            this.problemStatisticsCache = calculateProblemStatisticsFooter(this.data);
+        }
+        return this.problemStatisticsCache;
+    }
+    isSupportedVersion() {
+        return caniuse(this.data.version);
+    }
+    showTimeColumn() {
+        return shouldShowTimeColumn(this.data.rows);
+    }
+    showAvatarInOrganization() {
+        return this.splitOrganization && this.userAvatarPlacement === 'organization';
+    }
+    leftFooterColumnCount() {
+        return this.data.series.length + 1 + 1 + (this.showTimeColumn() ? 1 : 0) + (this.splitOrganization ? 1 : 0);
+    }
+    getRankValues(row) {
+        return row.rankValues || this.data.series.map(() => ({ rank: null, segmentIndex: null }));
+    }
+    getRankText(rankValue, row) {
+        return rankValue.rank ? rankValue.rank : row.user.official === false ? '＊' : '';
+    }
+    resolveDisplayText(text) {
+        return resolveText(text);
+    }
+    resolveSeriesColumnTitle(series, index) {
+        const seriesTitles = this.columnTitles?.series;
+        if (typeof seriesTitles === 'function') {
+            return seriesTitles(series, index) ?? series.title;
+        }
+        if (Array.isArray(seriesTitles)) {
+            return seriesTitles[index] ?? series.title;
+        }
+        return series.title;
+    }
+    resolveColumnTitle(key, fallback) {
+        return this.columnTitles?.[key] ?? fallback;
+    }
+    problemAlias(problem, problemIndex) {
+        return problem.alias || numberToAlphabet(problemIndex);
+    }
+    problemStatsTitle(statistics) {
+        const ratio = statistics.submitted ? ((statistics.accepted / statistics.submitted) * 100).toFixed(1) : 0;
+        return `${statistics.accepted} / ${statistics.submitted} (${ratio}%)`;
+    }
+    problemHeaderBackgroundImage(problem, gradientDirection = 180) {
+        return getProblemHeaderBackgroundImage(problem.style, this.theme, gradientDirection);
+    }
+    resolvedUserMarkers(user) {
+        return resolveUserMarkers(user, this.data.markers).map((marker) => ({
+            marker,
+            presentation: getMarkerPresentation(marker, this.theme),
+        }));
+    }
+    formatAssetUrl(url, field) {
+        return resolveSrkAssetUrl(url, field, this.formatSrkAssetUrl);
+    }
+    formatTime(time) {
+        return formatTimeDuration(time, 'min', Math.floor);
+    }
+    calculateDirtPercentage(row) {
+        return calculateDirtPercentage(row);
+    }
+    calculateSEValue(row, problemStatistics) {
+        return calculateSEValue(row, problemStatistics);
+    }
+    statusPresentation(status) {
+        return getRankProblemStatusCellPresentation(status, this.data, this.statusCellPreset);
+    }
+    isNumber(value) {
+        return typeof value === 'number';
+    }
+    getStatusSolutions(status) {
+        return [...(status.solutions || [])].reverse();
+    }
+    statusCellClass(status) {
+        const classNames = ['srk-prest-status-block', 'srk--text-center', 'srk--nowrap'];
+        if (this.isStatusClickable(status)) {
+            classNames.push('srk--cursor-pointer');
+        }
+        if (this.statusColorAsText) {
+            classNames.push('srk-prest-status-block-color-text');
+        }
+        if (status.result === 'FB') {
+            classNames.push('srk-prest-status-block-fb');
+        }
+        else if (status.result === 'AC') {
+            classNames.push('srk-prest-status-block-accepted');
+        }
+        else if (status.result === '?') {
+            classNames.push('srk-prest-status-block-frozen');
+        }
+        else if (status.result === 'RJ') {
+            classNames.push('srk-prest-status-block-failed');
+        }
+        return classNames.join(' ');
+    }
+    isStatusClickable(status) {
+        return this.getStatusSolutions(status).length > 0;
+    }
+    statusCellRole(status) {
+        return this.isStatusClickable(status) ? 'button' : null;
+    }
+    statusCellTabIndex(status) {
+        return this.isStatusClickable(status) ? 0 : null;
+    }
+    buildUserCellContext(row, rowIndex) {
+        return {
+            $implicit: row.user,
+            user: row.user,
+            row,
+            rowIndex,
+            ranklist: this.data,
+            markers: this.data.markers,
+            hideOrganization: this.splitOrganization,
+            hideAvatar: this.showAvatarInOrganization(),
+            onClick: (event) => this.emitUserClick(event, row, rowIndex),
+        };
+    }
+    buildStatusCellContext(row, rowIndex, status, problemIndex) {
+        return {
+            $implicit: status,
+            status,
+            problem: this.data.problems[problemIndex],
+            problemIndex,
+            user: row.user,
+            row,
+            rowIndex,
+            ranklist: this.data,
+            solutions: this.getStatusSolutions(status),
+            statusCellPreset: this.statusCellPreset,
+            statusColorAsText: this.statusColorAsText,
+            emptyStatusPlaceholder: this.emptyStatusPlaceholder,
+            onClick: (event) => this.emitSolutionClick(event, row, rowIndex, status, problemIndex),
+        };
+    }
+    activateUserCellFromKeyboard(event, row, rowIndex) {
+        event.preventDefault();
+        this.emitUserClick(undefined, row, rowIndex);
+    }
+    activateStatusCellFromKeyboard(event, row, rowIndex, status, problemIndex) {
+        event.preventDefault();
+        this.emitSolutionClick(undefined, row, rowIndex, status, problemIndex);
+    }
+    emitUserClick(event, row, rowIndex) {
+        if (event) {
+            captureModalTriggerPointFromMouseEvent(event, {
+                source: 'user-cell',
+                context: {
+                    rowIndex,
+                    userId: row.user.id || null,
+                    userName: this.resolveDisplayText(row.user.name),
+                },
+            });
+        }
+        this.userClick.emit({
+            user: row.user,
+            row,
+            rowIndex,
+            ranklist: this.data,
+        });
+    }
+    emitSolutionClick(event, row, rowIndex, status, problemIndex) {
+        const solutions = this.getStatusSolutions(status);
+        if (!solutions.length) {
+            return;
+        }
+        if (event) {
+            captureModalTriggerPointFromMouseEvent(event, {
+                source: 'status-cell',
+                context: {
+                    rowIndex,
+                    problemIndex,
+                    problemAlias: this.data.problems[problemIndex]?.alias || null,
+                    problemTitle: this.data.problems[problemIndex] ? this.resolveDisplayText(this.data.problems[problemIndex].title) : null,
+                    userId: row.user.id || null,
+                },
+            });
+        }
+        this.solutionClick.emit({
+            user: row.user,
+            row,
+            rowIndex,
+            problemIndex,
+            problem: this.data.problems[problemIndex],
+            status,
+            solutions,
+            ranklist: this.data,
+        });
+    }
+    resolveSeriesSegment(rankValue, series) {
+        const index = rankValue.segmentIndex || rankValue.segmentIndex === 0 ? rankValue.segmentIndex : -1;
+        return (series?.segments || [])[index] || {};
+    }
+    isSeriesSegmentedColumn(series) {
+        return (series?.segments || []).some((segment) => typeof segment.style === 'string');
+    }
+    getSeriesSegmentClass(rankValue, series) {
+        const segmentStyle = this.resolveSeriesSegment(rankValue, series).style;
+        return typeof segmentStyle === 'string' ? `srk-preset-series-segment-${segmentStyle}` : '';
+    }
+    getSeriesSegmentStyle(rankValue, series) {
+        const emptyColor = {
+            [EnumTheme.light]: undefined,
+            [EnumTheme.dark]: undefined,
+        };
+        const segmentStyle = this.resolveSeriesSegment(rankValue, series).style;
+        if (!segmentStyle || typeof segmentStyle === 'string') {
+            return {};
+        }
+        const style = resolveStyle(segmentStyle);
+        const textColor = style.textColor || emptyColor;
+        const backgroundColor = style.backgroundColor || emptyColor;
+        return {
+            color: textColor[this.theme],
+            backgroundColor: backgroundColor[this.theme],
+        };
+    }
+    getProblemStatisticsFooterCellPrimary(key, stat) {
+        switch (key) {
+            case 'accepted':
+                return stat.accepted;
+            case 'tried':
+                return stat.tried;
+            case 'submitted':
+                return stat.submitted;
+            case 'dirt':
+                return stat.dirt;
+            case 'se':
+                return formatProblemStatisticsAverageHardness(stat);
+            case 'firstAccepted':
+                return formatProblemStatisticsAcceptedMinute(stat.firstAcceptedTime);
+            case 'lastAccepted':
+                return formatProblemStatisticsAcceptedMinute(stat.lastAcceptedTime);
+            default:
+                return '';
+        }
+    }
+    getProblemStatisticsFooterCellSecondary(key, stat) {
+        switch (key) {
+            case 'accepted':
+                return formatProblemStatisticsPercent(stat.accepted, stat.participantCount);
+            case 'tried':
+                return formatProblemStatisticsPercent(stat.tried, stat.participantCount);
+            case 'dirt':
+                return formatProblemStatisticsPercent(stat.dirt, stat.dirtSubmitted);
+            default:
+                return undefined;
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: RanklistComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: RanklistComponent, isStandalone: true, selector: "srk-ranklist", inputs: { data: "data", theme: "theme", rowBordered: "rowBordered", columnBordered: "columnBordered", rowStriped: "rowStriped", formatSrkAssetUrl: "formatSrkAssetUrl", splitOrganization: "splitOrganization", columnTitles: "columnTitles", statusCellPreset: "statusCellPreset", statusColorAsText: "statusColorAsText", showProblemStatisticsFooter: "showProblemStatisticsFooter", showDirtColumn: "showDirtColumn", showSEColumn: "showSEColumn", emptyStatusPlaceholder: "emptyStatusPlaceholder", userAvatarPlacement: "userAvatarPlacement" }, outputs: { userClick: "userClick", solutionClick: "solutionClick" }, queries: [{ propertyName: "statusCellTemplate", first: true, predicate: SrkStatusCellTemplateDirective, descendants: true }, { propertyName: "userCellTemplate", first: true, predicate: SrkUserCellTemplateDirective, descendants: true }], ngImport: i0, template: `
+    <div *ngIf="data.type !== 'general'; else versionState">
+      srk type "{{ data.type }}" is not supported
+    </div>
+
+    <ng-template #versionState>
+      <div *ngIf="!isSupportedVersion(); else ranklistTable">
+        srk version "{{ data.version }}" is not supported (current supported: {{ supportedVersions }})
+      </div>
+    </ng-template>
+
+    <ng-template #ranklistTable>
+      <div class="srk-common-table srk-main">
+        <table
+          [class.srk-table-row-bordered]="rowBordered"
+          [class.srk-table-column-bordered]="columnBordered"
+          [class.srk-table-row-striped]="rowStriped"
+        >
+          <thead>
+            <tr>
+              <th
+                *ngFor="let seriesItem of data.series; let seriesIndex = index"
+                class="srk-series-header srk--text-right srk--nowrap"
+                [class.srk-series-segmented-column]="isSeriesSegmentedColumn(seriesItem)"
+              >
+                {{ resolveSeriesColumnTitle(seriesItem, seriesIndex) }}
+              </th>
+              <th
+                *ngIf="splitOrganization"
+                class="srk-organization-header srk--text-left srk--nowrap"
+              >
+                {{ resolveColumnTitle('organization', 'Organization') }}
+              </th>
+              <th class="srk--text-left srk--nowrap">{{ resolveColumnTitle('user', 'Name') }}</th>
+              <th class="srk--text-right srk--nowrap">{{ resolveColumnTitle('score', 'Score') }}</th>
+              <th *ngIf="showTimeColumn()" class="srk--text-right srk--nowrap">
+                {{ resolveColumnTitle('time', 'Time') }}
+              </th>
+              <th
+                *ngFor="let problem of data.problems; let problemIndex = index"
+                class="srk--nowrap srk-problem-header"
+                [style.background-image]="problemHeaderBackgroundImage(problem)"
+              >
+                <a
+                  *ngIf="problem.link; else unlinkedProblemHeader"
+                  [href]="problem.link"
+                  target="_blank"
+                  rel="noopener noreferrer"
+                  style="color: unset"
+                >
+                  <span class="srk--display-block">{{ problemAlias(problem, problemIndex) }}</span>
+                  <span
+                    *ngIf="problem.statistics"
+                    class="srk--display-block srk-problem-stats"
+                    [title]="problemStatsTitle(problem.statistics)"
+                  >
+                    {{ problem.statistics.accepted }}
+                  </span>
+                </a>
+                <ng-template #unlinkedProblemHeader>
+                  <span class="srk--display-block">{{ problemAlias(problem, problemIndex) }}</span>
+                  <span
+                    *ngIf="problem.statistics"
+                    class="srk--display-block srk-problem-stats"
+                    [title]="problemStatsTitle(problem.statistics)"
+                  >
+                    {{ problem.statistics.accepted }}
+                  </span>
+                </ng-template>
+              </th>
+              <th *ngIf="showDirtColumn" class="srk-dirt-header srk--text-right srk--nowrap">
+                {{ resolveColumnTitle('dirt', 'Dirt') }}
+              </th>
+              <th *ngIf="showSEColumn" class="srk-se-header srk--text-right srk--nowrap">
+                {{ resolveColumnTitle('se', 'SE') }}
+              </th>
+            </tr>
+          </thead>
+          <tbody>
+            <tr *ngFor="let row of data.rows; let rowIndex = index">
+              <td
+                *ngFor="let rankValue of getRankValues(row); let seriesIndex = index"
+                class="srk--text-right srk--nowrap"
+                [ngClass]="getSeriesSegmentClass(rankValue, data.series[seriesIndex])"
+                [class.srk-series-segmented-column]="isSeriesSegmentedColumn(data.series[seriesIndex])"
+                [ngStyle]="getSeriesSegmentStyle(rankValue, data.series[seriesIndex])"
+              >
+                {{ getRankText(rankValue, row) }}
+              </td>
+
+              <td
+                *ngIf="splitOrganization"
+                class="srk-organization-cell srk--text-left srk--nowrap"
+                [class.srk-organization-cell-avatar]="showAvatarInOrganization() && !!row.user.avatar"
+              >
+                <div class="srk-organization-cell-content">
+                  <div *ngIf="showAvatarInOrganization() && row.user.avatar" class="srk-user-avatar">
+                    <img
+                      [src]="formatAssetUrl(row.user.avatar, 'user.avatar')"
+                      alt="User Avatar"
+                    />
+                  </div>
+                  <span
+                    class="srk-organization-name-text"
+                    [title]="row.user.organization ? resolveDisplayText(row.user.organization) : ''"
+                    [textContent]="row.user.organization ? resolveDisplayText(row.user.organization) : ''"
+                  ></span>
+                </div>
+              </td>
+
+              <ng-container *ngIf="userCellTemplate; else defaultUserCell">
+                <ng-container
+                  [ngTemplateOutlet]="userCellTemplate.templateRef"
+                  [ngTemplateOutletContext]="buildUserCellContext(row, rowIndex)"
+                />
+              </ng-container>
+              <ng-template #defaultUserCell>
+                <td
+                  class="srk--text-left srk--nowrap srk-user-cell srk--cursor-pointer"
+                  role="button"
+                  tabindex="0"
+                  (click)="emitUserClick($event, row, rowIndex)"
+                  (keydown.enter)="activateUserCellFromKeyboard($event, row, rowIndex)"
+                  (keydown.space)="activateUserCellFromKeyboard($event, row, rowIndex)"
+                >
+                  <div class="srk-user-cell-content">
+                    <div *ngIf="row.user.avatar && !showAvatarInOrganization()" class="srk-user-avatar">
+                      <img
+                        [src]="formatAssetUrl(row.user.avatar, 'user.avatar')"
+                        alt="User Avatar"
+                      />
+                    </div>
+                    <div class="srk-user-body">
+                      <div class="srk-user-name-row">
+                        <span
+                          class="srk-user-name-text"
+                          [title]="resolveDisplayText(row.user.name)"
+                        >
+                          {{ resolveDisplayText(row.user.name) }}
+                        </span>
+                        <span class="srk-marker-dot-group">
+                          <span
+                            *ngFor="let marker of resolvedUserMarkers(row.user)"
+                            class="srk-marker srk-marker-dot srk--c-tooltip"
+                            [ngClass]="marker.presentation.className"
+                            [ngStyle]="marker.presentation.style"
+                            [attr.data-tooltip]="resolveDisplayText(marker.marker.label)"
+                          ></span>
+                        </span>
+                      </div>
+                      <p
+                        *ngIf="row.user.organization && !splitOrganization"
+                        class="srk-user-secondary-text srk--text-ellipsis"
+                        title=""
+                      >
+                        {{ resolveDisplayText(row.user.organization) }}
+                      </p>
+                    </div>
+                  </div>
+                </td>
+              </ng-template>
+
+              <td class="srk--text-right srk--nowrap">{{ row.score.value }}</td>
+              <td *ngIf="showTimeColumn()" class="srk--text-right srk--nowrap">
+                {{ row.score.time ? formatTime(row.score.time) : '-' }}
+              </td>
+
+              <ng-container *ngFor="let status of row.statuses; let problemIndex = index">
+                <ng-container *ngIf="statusCellTemplate; else defaultStatusCell">
+                  <ng-container
+                    [ngTemplateOutlet]="statusCellTemplate.templateRef"
+                    [ngTemplateOutletContext]="buildStatusCellContext(row, rowIndex, status, problemIndex)"
+                  />
+                </ng-container>
+                <ng-template #defaultStatusCell>
+                  <td
+                    *ngIf="status.result === 'FB' || status.result === 'AC'; else failedOrFrozenStatus"
+                    [ngClass]="statusCellClass(status)"
+                    [attr.role]="statusCellRole(status)"
+                    [attr.tabindex]="statusCellTabIndex(status)"
+                    (click)="emitSolutionClick($event, row, rowIndex, status, problemIndex)"
+                    (keydown.enter)="activateStatusCellFromKeyboard($event, row, rowIndex, status, problemIndex)"
+                    (keydown.space)="activateStatusCellFromKeyboard($event, row, rowIndex, status, problemIndex)"
+                  >
+                    <span
+                      *ngIf="statusColorAsText && status.result === 'FB'"
+                      class="srk-prest-status-block-fb-star"
+                      [textContent]="firstBloodStar"
+                    ></span>
+                    <ng-container *ngIf="statusPresentation(status) as presentation">
+                      <ng-container *ngIf="isNumber(presentation.score); else statusText">
+                        <span class="srk-prest-status-block-score">{{ presentation.score }}</span>
+                        <span class="srk-prest-status-block-score-details">
+                          {{ presentation.scoreDetails }}
+                        </span>
+                      </ng-container>
+                      <ng-template #statusText>
+                        <ng-container *ngIf="presentation.secondary !== undefined; else singleStatus">
+                          <span class="srk-prest-status-block-primary">{{ presentation.primary || '' }}</span>
+                          <span [textContent]="statusSeparator"></span>
+                          <span class="srk-prest-status-block-secondary">{{ presentation.secondary }}</span>
+                        </ng-container>
+                        <ng-template #singleStatus>{{ presentation.primary }}</ng-template>
+                      </ng-template>
+                    </ng-container>
+                  </td>
+                  <ng-template #failedOrFrozenStatus>
+                    <td
+                      *ngIf="status.result === '?' || status.result === 'RJ'; else emptyStatus"
+                      [ngClass]="statusCellClass(status)"
+                      [attr.role]="statusCellRole(status)"
+                      [attr.tabindex]="statusCellTabIndex(status)"
+                      (click)="emitSolutionClick($event, row, rowIndex, status, problemIndex)"
+                      (keydown.enter)="activateStatusCellFromKeyboard($event, row, rowIndex, status, problemIndex)"
+                      (keydown.space)="activateStatusCellFromKeyboard($event, row, rowIndex, status, problemIndex)"
+                    >
+                      <ng-container *ngIf="statusPresentation(status) as presentation">
+                        <ng-container *ngIf="presentation.secondary !== undefined; else singleStatus">
+                          <span class="srk-prest-status-block-primary">{{ presentation.primary || '' }}</span>
+                          <span [textContent]="statusSeparator"></span>
+                          <span class="srk-prest-status-block-secondary">{{ presentation.secondary }}</span>
+                        </ng-container>
+                        <ng-template #singleStatus>{{ presentation.primary }}</ng-template>
+                      </ng-container>
+                    </td>
+                  </ng-template>
+                  <ng-template #emptyStatus>
+                    <td class="srk-status-placeholder-cell srk--text-center srk--nowrap">
+                      {{ emptyStatusPlaceholder }}
+                    </td>
+                  </ng-template>
+                </ng-template>
+              </ng-container>
+
+              <td *ngIf="showDirtColumn" class="srk-dirt-cell srk--text-right srk--nowrap">
+                {{ calculateDirtPercentage(row) }}
+              </td>
+              <td *ngIf="showSEColumn" class="srk-se-cell srk--text-right srk--nowrap">
+                {{ calculateSEValue(row, problemStatistics) }}
+              </td>
+            </tr>
+          </tbody>
+          <tfoot *ngIf="showProblemStatisticsFooter">
+            <tr
+              *ngFor="let footerRow of problemStatisticsFooterRows"
+              class="srk-problem-statistics-footer-row"
+            >
+              <td
+                class="srk-problem-statistics-footer-labels srk--text-right srk--nowrap"
+                [attr.colspan]="leftFooterColumnCount()"
+              >
+                <span
+                  class="srk-problem-statistics-footer-label srk--c-tooltip"
+                  [attr.data-tooltip]="footerRow.tooltip"
+                >
+                  {{ footerRow.label }}
+                </span>
+              </td>
+              <td
+                *ngFor="let stat of problemStatistics"
+                class="srk-problem-statistics-footer-cell srk--text-center srk--nowrap"
+              >
+                <span class="srk-problem-statistics-footer-primary">
+                  {{ getProblemStatisticsFooterCellPrimary(footerRow.key, stat) }}
+                </span>
+                <ng-container *ngIf="getProblemStatisticsFooterCellSecondary(footerRow.key, stat) !== undefined">
+                  <span> </span>
+                  <span class="srk-problem-statistics-footer-secondary">
+                    {{ getProblemStatisticsFooterCellSecondary(footerRow.key, stat) }}
+                  </span>
+                </ng-container>
+              </td>
+              <td
+                *ngIf="showDirtColumn"
+                class="srk-problem-statistics-footer-cell srk-extra-statistics-footer-cell srk-dirt-footer-cell srk--nowrap"
+              >
+                <span class="srk-problem-statistics-footer-primary"></span>
+              </td>
+              <td
+                *ngIf="showSEColumn"
+                class="srk-problem-statistics-footer-cell srk-extra-statistics-footer-cell srk-se-footer-cell srk--nowrap"
+              >
+                <span class="srk-problem-statistics-footer-primary"></span>
+              </td>
+            </tr>
+            <tr class="srk-problem-statistics-footer-row srk-problem-statistics-footer-problem-label-row">
+              <td
+                class="srk-problem-statistics-footer-labels srk--text-right srk--nowrap"
+                [attr.colspan]="leftFooterColumnCount()"
+              ></td>
+              <td
+                *ngFor="let problem of data.problems; let problemIndex = index"
+                class="srk-problem-statistics-footer-cell srk-problem-statistics-footer-problem-header srk-problem-header srk--text-center srk--nowrap"
+                [style.background-image]="problemHeaderBackgroundImage(problem, 0)"
+              >
+                <span class="srk--display-block">{{ problemAlias(problem, problemIndex) }}</span>
+              </td>
+              <td
+                *ngIf="showDirtColumn"
+                class="srk-problem-statistics-footer-cell srk-extra-statistics-footer-cell srk-dirt-footer-cell srk--nowrap"
+              >
+                <span class="srk-problem-statistics-footer-primary"></span>
+              </td>
+              <td
+                *ngIf="showSEColumn"
+                class="srk-problem-statistics-footer-cell srk-extra-statistics-footer-cell srk-se-footer-cell srk--nowrap"
+              >
+                <span class="srk-problem-statistics-footer-primary"></span>
+              </td>
+            </tr>
+          </tfoot>
+        </table>
+      </div>
+    </ng-template>
+  `, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i1.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "directive", type: i1.NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: RanklistComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'srk-ranklist',
+                    standalone: true,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    imports: [CommonModule],
+                    template: `
+    <div *ngIf="data.type !== 'general'; else versionState">
+      srk type "{{ data.type }}" is not supported
+    </div>
+
+    <ng-template #versionState>
+      <div *ngIf="!isSupportedVersion(); else ranklistTable">
+        srk version "{{ data.version }}" is not supported (current supported: {{ supportedVersions }})
+      </div>
+    </ng-template>
+
+    <ng-template #ranklistTable>
+      <div class="srk-common-table srk-main">
+        <table
+          [class.srk-table-row-bordered]="rowBordered"
+          [class.srk-table-column-bordered]="columnBordered"
+          [class.srk-table-row-striped]="rowStriped"
+        >
+          <thead>
+            <tr>
+              <th
+                *ngFor="let seriesItem of data.series; let seriesIndex = index"
+                class="srk-series-header srk--text-right srk--nowrap"
+                [class.srk-series-segmented-column]="isSeriesSegmentedColumn(seriesItem)"
+              >
+                {{ resolveSeriesColumnTitle(seriesItem, seriesIndex) }}
+              </th>
+              <th
+                *ngIf="splitOrganization"
+                class="srk-organization-header srk--text-left srk--nowrap"
+              >
+                {{ resolveColumnTitle('organization', 'Organization') }}
+              </th>
+              <th class="srk--text-left srk--nowrap">{{ resolveColumnTitle('user', 'Name') }}</th>
+              <th class="srk--text-right srk--nowrap">{{ resolveColumnTitle('score', 'Score') }}</th>
+              <th *ngIf="showTimeColumn()" class="srk--text-right srk--nowrap">
+                {{ resolveColumnTitle('time', 'Time') }}
+              </th>
+              <th
+                *ngFor="let problem of data.problems; let problemIndex = index"
+                class="srk--nowrap srk-problem-header"
+                [style.background-image]="problemHeaderBackgroundImage(problem)"
+              >
+                <a
+                  *ngIf="problem.link; else unlinkedProblemHeader"
+                  [href]="problem.link"
+                  target="_blank"
+                  rel="noopener noreferrer"
+                  style="color: unset"
+                >
+                  <span class="srk--display-block">{{ problemAlias(problem, problemIndex) }}</span>
+                  <span
+                    *ngIf="problem.statistics"
+                    class="srk--display-block srk-problem-stats"
+                    [title]="problemStatsTitle(problem.statistics)"
+                  >
+                    {{ problem.statistics.accepted }}
+                  </span>
+                </a>
+                <ng-template #unlinkedProblemHeader>
+                  <span class="srk--display-block">{{ problemAlias(problem, problemIndex) }}</span>
+                  <span
+                    *ngIf="problem.statistics"
+                    class="srk--display-block srk-problem-stats"
+                    [title]="problemStatsTitle(problem.statistics)"
+                  >
+                    {{ problem.statistics.accepted }}
+                  </span>
+                </ng-template>
+              </th>
+              <th *ngIf="showDirtColumn" class="srk-dirt-header srk--text-right srk--nowrap">
+                {{ resolveColumnTitle('dirt', 'Dirt') }}
+              </th>
+              <th *ngIf="showSEColumn" class="srk-se-header srk--text-right srk--nowrap">
+                {{ resolveColumnTitle('se', 'SE') }}
+              </th>
+            </tr>
+          </thead>
+          <tbody>
+            <tr *ngFor="let row of data.rows; let rowIndex = index">
+              <td
+                *ngFor="let rankValue of getRankValues(row); let seriesIndex = index"
+                class="srk--text-right srk--nowrap"
+                [ngClass]="getSeriesSegmentClass(rankValue, data.series[seriesIndex])"
+                [class.srk-series-segmented-column]="isSeriesSegmentedColumn(data.series[seriesIndex])"
+                [ngStyle]="getSeriesSegmentStyle(rankValue, data.series[seriesIndex])"
+              >
+                {{ getRankText(rankValue, row) }}
+              </td>
+
+              <td
+                *ngIf="splitOrganization"
+                class="srk-organization-cell srk--text-left srk--nowrap"
+                [class.srk-organization-cell-avatar]="showAvatarInOrganization() && !!row.user.avatar"
+              >
+                <div class="srk-organization-cell-content">
+                  <div *ngIf="showAvatarInOrganization() && row.user.avatar" class="srk-user-avatar">
+                    <img
+                      [src]="formatAssetUrl(row.user.avatar, 'user.avatar')"
+                      alt="User Avatar"
+                    />
+                  </div>
+                  <span
+                    class="srk-organization-name-text"
+                    [title]="row.user.organization ? resolveDisplayText(row.user.organization) : ''"
+                    [textContent]="row.user.organization ? resolveDisplayText(row.user.organization) : ''"
+                  ></span>
+                </div>
+              </td>
+
+              <ng-container *ngIf="userCellTemplate; else defaultUserCell">
+                <ng-container
+                  [ngTemplateOutlet]="userCellTemplate.templateRef"
+                  [ngTemplateOutletContext]="buildUserCellContext(row, rowIndex)"
+                />
+              </ng-container>
+              <ng-template #defaultUserCell>
+                <td
+                  class="srk--text-left srk--nowrap srk-user-cell srk--cursor-pointer"
+                  role="button"
+                  tabindex="0"
+                  (click)="emitUserClick($event, row, rowIndex)"
+                  (keydown.enter)="activateUserCellFromKeyboard($event, row, rowIndex)"
+                  (keydown.space)="activateUserCellFromKeyboard($event, row, rowIndex)"
+                >
+                  <div class="srk-user-cell-content">
+                    <div *ngIf="row.user.avatar && !showAvatarInOrganization()" class="srk-user-avatar">
+                      <img
+                        [src]="formatAssetUrl(row.user.avatar, 'user.avatar')"
+                        alt="User Avatar"
+                      />
+                    </div>
+                    <div class="srk-user-body">
+                      <div class="srk-user-name-row">
+                        <span
+                          class="srk-user-name-text"
+                          [title]="resolveDisplayText(row.user.name)"
+                        >
+                          {{ resolveDisplayText(row.user.name) }}
+                        </span>
+                        <span class="srk-marker-dot-group">
+                          <span
+                            *ngFor="let marker of resolvedUserMarkers(row.user)"
+                            class="srk-marker srk-marker-dot srk--c-tooltip"
+                            [ngClass]="marker.presentation.className"
+                            [ngStyle]="marker.presentation.style"
+                            [attr.data-tooltip]="resolveDisplayText(marker.marker.label)"
+                          ></span>
+                        </span>
+                      </div>
+                      <p
+                        *ngIf="row.user.organization && !splitOrganization"
+                        class="srk-user-secondary-text srk--text-ellipsis"
+                        title=""
+                      >
+                        {{ resolveDisplayText(row.user.organization) }}
+                      </p>
+                    </div>
+                  </div>
+                </td>
+              </ng-template>
+
+              <td class="srk--text-right srk--nowrap">{{ row.score.value }}</td>
+              <td *ngIf="showTimeColumn()" class="srk--text-right srk--nowrap">
+                {{ row.score.time ? formatTime(row.score.time) : '-' }}
+              </td>
+
+              <ng-container *ngFor="let status of row.statuses; let problemIndex = index">
+                <ng-container *ngIf="statusCellTemplate; else defaultStatusCell">
+                  <ng-container
+                    [ngTemplateOutlet]="statusCellTemplate.templateRef"
+                    [ngTemplateOutletContext]="buildStatusCellContext(row, rowIndex, status, problemIndex)"
+                  />
+                </ng-container>
+                <ng-template #defaultStatusCell>
+                  <td
+                    *ngIf="status.result === 'FB' || status.result === 'AC'; else failedOrFrozenStatus"
+                    [ngClass]="statusCellClass(status)"
+                    [attr.role]="statusCellRole(status)"
+                    [attr.tabindex]="statusCellTabIndex(status)"
+                    (click)="emitSolutionClick($event, row, rowIndex, status, problemIndex)"
+                    (keydown.enter)="activateStatusCellFromKeyboard($event, row, rowIndex, status, problemIndex)"
+                    (keydown.space)="activateStatusCellFromKeyboard($event, row, rowIndex, status, problemIndex)"
+                  >
+                    <span
+                      *ngIf="statusColorAsText && status.result === 'FB'"
+                      class="srk-prest-status-block-fb-star"
+                      [textContent]="firstBloodStar"
+                    ></span>
+                    <ng-container *ngIf="statusPresentation(status) as presentation">
+                      <ng-container *ngIf="isNumber(presentation.score); else statusText">
+                        <span class="srk-prest-status-block-score">{{ presentation.score }}</span>
+                        <span class="srk-prest-status-block-score-details">
+                          {{ presentation.scoreDetails }}
+                        </span>
+                      </ng-container>
+                      <ng-template #statusText>
+                        <ng-container *ngIf="presentation.secondary !== undefined; else singleStatus">
+                          <span class="srk-prest-status-block-primary">{{ presentation.primary || '' }}</span>
+                          <span [textContent]="statusSeparator"></span>
+                          <span class="srk-prest-status-block-secondary">{{ presentation.secondary }}</span>
+                        </ng-container>
+                        <ng-template #singleStatus>{{ presentation.primary }}</ng-template>
+                      </ng-template>
+                    </ng-container>
+                  </td>
+                  <ng-template #failedOrFrozenStatus>
+                    <td
+                      *ngIf="status.result === '?' || status.result === 'RJ'; else emptyStatus"
+                      [ngClass]="statusCellClass(status)"
+                      [attr.role]="statusCellRole(status)"
+                      [attr.tabindex]="statusCellTabIndex(status)"
+                      (click)="emitSolutionClick($event, row, rowIndex, status, problemIndex)"
+                      (keydown.enter)="activateStatusCellFromKeyboard($event, row, rowIndex, status, problemIndex)"
+                      (keydown.space)="activateStatusCellFromKeyboard($event, row, rowIndex, status, problemIndex)"
+                    >
+                      <ng-container *ngIf="statusPresentation(status) as presentation">
+                        <ng-container *ngIf="presentation.secondary !== undefined; else singleStatus">
+                          <span class="srk-prest-status-block-primary">{{ presentation.primary || '' }}</span>
+                          <span [textContent]="statusSeparator"></span>
+                          <span class="srk-prest-status-block-secondary">{{ presentation.secondary }}</span>
+                        </ng-container>
+                        <ng-template #singleStatus>{{ presentation.primary }}</ng-template>
+                      </ng-container>
+                    </td>
+                  </ng-template>
+                  <ng-template #emptyStatus>
+                    <td class="srk-status-placeholder-cell srk--text-center srk--nowrap">
+                      {{ emptyStatusPlaceholder }}
+                    </td>
+                  </ng-template>
+                </ng-template>
+              </ng-container>
+
+              <td *ngIf="showDirtColumn" class="srk-dirt-cell srk--text-right srk--nowrap">
+                {{ calculateDirtPercentage(row) }}
+              </td>
+              <td *ngIf="showSEColumn" class="srk-se-cell srk--text-right srk--nowrap">
+                {{ calculateSEValue(row, problemStatistics) }}
+              </td>
+            </tr>
+          </tbody>
+          <tfoot *ngIf="showProblemStatisticsFooter">
+            <tr
+              *ngFor="let footerRow of problemStatisticsFooterRows"
+              class="srk-problem-statistics-footer-row"
+            >
+              <td
+                class="srk-problem-statistics-footer-labels srk--text-right srk--nowrap"
+                [attr.colspan]="leftFooterColumnCount()"
+              >
+                <span
+                  class="srk-problem-statistics-footer-label srk--c-tooltip"
+                  [attr.data-tooltip]="footerRow.tooltip"
+                >
+                  {{ footerRow.label }}
+                </span>
+              </td>
+              <td
+                *ngFor="let stat of problemStatistics"
+                class="srk-problem-statistics-footer-cell srk--text-center srk--nowrap"
+              >
+                <span class="srk-problem-statistics-footer-primary">
+                  {{ getProblemStatisticsFooterCellPrimary(footerRow.key, stat) }}
+                </span>
+                <ng-container *ngIf="getProblemStatisticsFooterCellSecondary(footerRow.key, stat) !== undefined">
+                  <span> </span>
+                  <span class="srk-problem-statistics-footer-secondary">
+                    {{ getProblemStatisticsFooterCellSecondary(footerRow.key, stat) }}
+                  </span>
+                </ng-container>
+              </td>
+              <td
+                *ngIf="showDirtColumn"
+                class="srk-problem-statistics-footer-cell srk-extra-statistics-footer-cell srk-dirt-footer-cell srk--nowrap"
+              >
+                <span class="srk-problem-statistics-footer-primary"></span>
+              </td>
+              <td
+                *ngIf="showSEColumn"
+                class="srk-problem-statistics-footer-cell srk-extra-statistics-footer-cell srk-se-footer-cell srk--nowrap"
+              >
+                <span class="srk-problem-statistics-footer-primary"></span>
+              </td>
+            </tr>
+            <tr class="srk-problem-statistics-footer-row srk-problem-statistics-footer-problem-label-row">
+              <td
+                class="srk-problem-statistics-footer-labels srk--text-right srk--nowrap"
+                [attr.colspan]="leftFooterColumnCount()"
+              ></td>
+              <td
+                *ngFor="let problem of data.problems; let problemIndex = index"
+                class="srk-problem-statistics-footer-cell srk-problem-statistics-footer-problem-header srk-problem-header srk--text-center srk--nowrap"
+                [style.background-image]="problemHeaderBackgroundImage(problem, 0)"
+              >
+                <span class="srk--display-block">{{ problemAlias(problem, problemIndex) }}</span>
+              </td>
+              <td
+                *ngIf="showDirtColumn"
+                class="srk-problem-statistics-footer-cell srk-extra-statistics-footer-cell srk-dirt-footer-cell srk--nowrap"
+              >
+                <span class="srk-problem-statistics-footer-primary"></span>
+              </td>
+              <td
+                *ngIf="showSEColumn"
+                class="srk-problem-statistics-footer-cell srk-extra-statistics-footer-cell srk-se-footer-cell srk--nowrap"
+              >
+                <span class="srk-problem-statistics-footer-primary"></span>
+              </td>
+            </tr>
+          </tfoot>
+        </table>
+      </div>
+    </ng-template>
+  `,
+                }]
+        }], propDecorators: { data: [{
+                type: Input,
+                args: [{ required: true }]
+            }], theme: [{
+                type: Input
+            }], rowBordered: [{
+                type: Input
+            }], columnBordered: [{
+                type: Input
+            }], rowStriped: [{
+                type: Input
+            }], formatSrkAssetUrl: [{
+                type: Input
+            }], splitOrganization: [{
+                type: Input
+            }], columnTitles: [{
+                type: Input
+            }], statusCellPreset: [{
+                type: Input
+            }], statusColorAsText: [{
+                type: Input
+            }], showProblemStatisticsFooter: [{
+                type: Input
+            }], showDirtColumn: [{
+                type: Input
+            }], showSEColumn: [{
+                type: Input
+            }], emptyStatusPlaceholder: [{
+                type: Input
+            }], userAvatarPlacement: [{
+                type: Input
+            }], userClick: [{
+                type: Output
+            }], solutionClick: [{
+                type: Output
+            }], statusCellTemplate: [{
+                type: ContentChild,
+                args: [SrkStatusCellTemplateDirective]
+            }], userCellTemplate: [{
+                type: ContentChild,
+                args: [SrkUserCellTemplateDirective]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ranklist.component.js","sourceRoot":"","sources":["../../../../src/lib/ranklist/ranklist.component.ts"],"names":[],"mappings":"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","sourcesContent":["import type * as srk from '@algoux/standard-ranklist';\nimport { CommonModule } from '@angular/common';\nimport {\n  ChangeDetectionStrategy,\n  Component,\n  ContentChild,\n  EventEmitter,\n  Input,\n  Output,\n} from '@angular/core';\nimport {\n  EnumTheme,\n  formatTimeDuration,\n  numberToAlphabet,\n  resolveStyle,\n  resolveText,\n  resolveUserMarkers,\n} from '@algoux/standard-ranklist-utils';\nimport type { ThemeColor } from '@algoux/standard-ranklist-utils';\nimport {\n  calculateDirtPercentage,\n  calculateProblemStatisticsFooter,\n  calculateSEValue,\n  caniuse,\n  formatProblemStatisticsAcceptedMinute,\n  formatProblemStatisticsAverageHardness,\n  formatProblemStatisticsPercent,\n  getMarkerPresentation,\n  getProblemHeaderBackgroundImage,\n  getRankProblemStatusCellPresentation,\n  resolveSrkAssetUrl,\n  shouldShowTimeColumn,\n  srkSupportedVersions,\n} from '@algoux/standard-ranklist-renderer-component-core';\nimport type {\n  ProblemStatisticsFooter,\n  RanklistColumnTitles,\n  RanklistStatusCellPreset,\n  RanklistUserAvatarPlacement,\n} from '@algoux/standard-ranklist-renderer-component-core';\nimport { captureModalTriggerPointFromMouseEvent } from '../modal/modal-interactions';\nimport type {\n  RankValue,\n  SolutionClickPayload,\n  StaticRanklist,\n  StaticRanklistRow,\n  UserClickPayload,\n} from '../types';\nimport {\n  SrkStatusCellTemplateDirective,\n  type StatusCellTemplateContext,\n} from './status-cell-template.directive';\nimport {\n  SrkUserCellTemplateDirective,\n  type UserCellTemplateContext,\n} from './user-cell-template.directive';\n\n@Component({\n  selector: 'srk-ranklist',\n  standalone: true,\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  imports: [CommonModule],\n  template: `\n    <div *ngIf=\"data.type !== 'general'; else versionState\">\n      srk type \"{{ data.type }}\" is not supported\n    </div>\n\n    <ng-template #versionState>\n      <div *ngIf=\"!isSupportedVersion(); else ranklistTable\">\n        srk version \"{{ data.version }}\" is not supported (current supported: {{ supportedVersions }})\n      </div>\n    </ng-template>\n\n    <ng-template #ranklistTable>\n      <div class=\"srk-common-table srk-main\">\n        <table\n          [class.srk-table-row-bordered]=\"rowBordered\"\n          [class.srk-table-column-bordered]=\"columnBordered\"\n          [class.srk-table-row-striped]=\"rowStriped\"\n        >\n          <thead>\n            <tr>\n              <th\n                *ngFor=\"let seriesItem of data.series; let seriesIndex = index\"\n                class=\"srk-series-header srk--text-right srk--nowrap\"\n                [class.srk-series-segmented-column]=\"isSeriesSegmentedColumn(seriesItem)\"\n              >\n                {{ resolveSeriesColumnTitle(seriesItem, seriesIndex) }}\n              </th>\n              <th\n                *ngIf=\"splitOrganization\"\n                class=\"srk-organization-header srk--text-left srk--nowrap\"\n              >\n                {{ resolveColumnTitle('organization', 'Organization') }}\n              </th>\n              <th class=\"srk--text-left srk--nowrap\">{{ resolveColumnTitle('user', 'Name') }}</th>\n              <th class=\"srk--text-right srk--nowrap\">{{ resolveColumnTitle('score', 'Score') }}</th>\n              <th *ngIf=\"showTimeColumn()\" class=\"srk--text-right srk--nowrap\">\n                {{ resolveColumnTitle('time', 'Time') }}\n              </th>\n              <th\n                *ngFor=\"let problem of data.problems; let problemIndex = index\"\n                class=\"srk--nowrap srk-problem-header\"\n                [style.background-image]=\"problemHeaderBackgroundImage(problem)\"\n              >\n                <a\n                  *ngIf=\"problem.link; else unlinkedProblemHeader\"\n                  [href]=\"problem.link\"\n                  target=\"_blank\"\n                  rel=\"noopener noreferrer\"\n                  style=\"color: unset\"\n                >\n                  <span class=\"srk--display-block\">{{ problemAlias(problem, problemIndex) }}</span>\n                  <span\n                    *ngIf=\"problem.statistics\"\n                    class=\"srk--display-block srk-problem-stats\"\n                    [title]=\"problemStatsTitle(problem.statistics)\"\n                  >\n                    {{ problem.statistics.accepted }}\n                  </span>\n                </a>\n                <ng-template #unlinkedProblemHeader>\n                  <span class=\"srk--display-block\">{{ problemAlias(problem, problemIndex) }}</span>\n                  <span\n                    *ngIf=\"problem.statistics\"\n                    class=\"srk--display-block srk-problem-stats\"\n                    [title]=\"problemStatsTitle(problem.statistics)\"\n                  >\n                    {{ problem.statistics.accepted }}\n                  </span>\n                </ng-template>\n              </th>\n              <th *ngIf=\"showDirtColumn\" class=\"srk-dirt-header srk--text-right srk--nowrap\">\n                {{ resolveColumnTitle('dirt', 'Dirt') }}\n              </th>\n              <th *ngIf=\"showSEColumn\" class=\"srk-se-header srk--text-right srk--nowrap\">\n                {{ resolveColumnTitle('se', 'SE') }}\n              </th>\n            </tr>\n          </thead>\n          <tbody>\n            <tr *ngFor=\"let row of data.rows; let rowIndex = index\">\n              <td\n                *ngFor=\"let rankValue of getRankValues(row); let seriesIndex = index\"\n                class=\"srk--text-right srk--nowrap\"\n                [ngClass]=\"getSeriesSegmentClass(rankValue, data.series[seriesIndex])\"\n                [class.srk-series-segmented-column]=\"isSeriesSegmentedColumn(data.series[seriesIndex])\"\n                [ngStyle]=\"getSeriesSegmentStyle(rankValue, data.series[seriesIndex])\"\n              >\n                {{ getRankText(rankValue, row) }}\n              </td>\n\n              <td\n                *ngIf=\"splitOrganization\"\n                class=\"srk-organization-cell srk--text-left srk--nowrap\"\n                [class.srk-organization-cell-avatar]=\"showAvatarInOrganization() && !!row.user.avatar\"\n              >\n                <div class=\"srk-organization-cell-content\">\n                  <div *ngIf=\"showAvatarInOrganization() && row.user.avatar\" class=\"srk-user-avatar\">\n                    <img\n                      [src]=\"formatAssetUrl(row.user.avatar, 'user.avatar')\"\n                      alt=\"User Avatar\"\n                    />\n                  </div>\n                  <span\n                    class=\"srk-organization-name-text\"\n                    [title]=\"row.user.organization ? resolveDisplayText(row.user.organization) : ''\"\n                    [textContent]=\"row.user.organization ? resolveDisplayText(row.user.organization) : ''\"\n                  ></span>\n                </div>\n              </td>\n\n              <ng-container *ngIf=\"userCellTemplate; else defaultUserCell\">\n                <ng-container\n                  [ngTemplateOutlet]=\"userCellTemplate.templateRef\"\n                  [ngTemplateOutletContext]=\"buildUserCellContext(row, rowIndex)\"\n                />\n              </ng-container>\n              <ng-template #defaultUserCell>\n                <td\n                  class=\"srk--text-left srk--nowrap srk-user-cell srk--cursor-pointer\"\n                  role=\"button\"\n                  tabindex=\"0\"\n                  (click)=\"emitUserClick($event, row, rowIndex)\"\n                  (keydown.enter)=\"activateUserCellFromKeyboard($event, row, rowIndex)\"\n                  (keydown.space)=\"activateUserCellFromKeyboard($event, row, rowIndex)\"\n                >\n                  <div class=\"srk-user-cell-content\">\n                    <div *ngIf=\"row.user.avatar && !showAvatarInOrganization()\" class=\"srk-user-avatar\">\n                      <img\n                        [src]=\"formatAssetUrl(row.user.avatar, 'user.avatar')\"\n                        alt=\"User Avatar\"\n                      />\n                    </div>\n                    <div class=\"srk-user-body\">\n                      <div class=\"srk-user-name-row\">\n                        <span\n                          class=\"srk-user-name-text\"\n                          [title]=\"resolveDisplayText(row.user.name)\"\n                        >\n                          {{ resolveDisplayText(row.user.name) }}\n                        </span>\n                        <span class=\"srk-marker-dot-group\">\n                          <span\n                            *ngFor=\"let marker of resolvedUserMarkers(row.user)\"\n                            class=\"srk-marker srk-marker-dot srk--c-tooltip\"\n                            [ngClass]=\"marker.presentation.className\"\n                            [ngStyle]=\"marker.presentation.style\"\n                            [attr.data-tooltip]=\"resolveDisplayText(marker.marker.label)\"\n                          ></span>\n                        </span>\n                      </div>\n                      <p\n                        *ngIf=\"row.user.organization && !splitOrganization\"\n                        class=\"srk-user-secondary-text srk--text-ellipsis\"\n                        title=\"\"\n                      >\n                        {{ resolveDisplayText(row.user.organization) }}\n                      </p>\n                    </div>\n                  </div>\n                </td>\n              </ng-template>\n\n              <td class=\"srk--text-right srk--nowrap\">{{ row.score.value }}</td>\n              <td *ngIf=\"showTimeColumn()\" class=\"srk--text-right srk--nowrap\">\n                {{ row.score.time ? formatTime(row.score.time) : '-' }}\n              </td>\n\n              <ng-container *ngFor=\"let status of row.statuses; let problemIndex = index\">\n                <ng-container *ngIf=\"statusCellTemplate; else defaultStatusCell\">\n                  <ng-container\n                    [ngTemplateOutlet]=\"statusCellTemplate.templateRef\"\n                    [ngTemplateOutletContext]=\"buildStatusCellContext(row, rowIndex, status, problemIndex)\"\n                  />\n                </ng-container>\n                <ng-template #defaultStatusCell>\n                  <td\n                    *ngIf=\"status.result === 'FB' || status.result === 'AC'; else failedOrFrozenStatus\"\n                    [ngClass]=\"statusCellClass(status)\"\n                    [attr.role]=\"statusCellRole(status)\"\n                    [attr.tabindex]=\"statusCellTabIndex(status)\"\n                    (click)=\"emitSolutionClick($event, row, rowIndex, status, problemIndex)\"\n                    (keydown.enter)=\"activateStatusCellFromKeyboard($event, row, rowIndex, status, problemIndex)\"\n                    (keydown.space)=\"activateStatusCellFromKeyboard($event, row, rowIndex, status, problemIndex)\"\n                  >\n                    <span\n                      *ngIf=\"statusColorAsText && status.result === 'FB'\"\n                      class=\"srk-prest-status-block-fb-star\"\n                      [textContent]=\"firstBloodStar\"\n                    ></span>\n                    <ng-container *ngIf=\"statusPresentation(status) as presentation\">\n                      <ng-container *ngIf=\"isNumber(presentation.score); else statusText\">\n                        <span class=\"srk-prest-status-block-score\">{{ presentation.score }}</span>\n                        <span class=\"srk-prest-status-block-score-details\">\n                          {{ presentation.scoreDetails }}\n                        </span>\n                      </ng-container>\n                      <ng-template #statusText>\n                        <ng-container *ngIf=\"presentation.secondary !== undefined; else singleStatus\">\n                          <span class=\"srk-prest-status-block-primary\">{{ presentation.primary || '' }}</span>\n                          <span [textContent]=\"statusSeparator\"></span>\n                          <span class=\"srk-prest-status-block-secondary\">{{ presentation.secondary }}</span>\n                        </ng-container>\n                        <ng-template #singleStatus>{{ presentation.primary }}</ng-template>\n                      </ng-template>\n                    </ng-container>\n                  </td>\n                  <ng-template #failedOrFrozenStatus>\n                    <td\n                      *ngIf=\"status.result === '?' || status.result === 'RJ'; else emptyStatus\"\n                      [ngClass]=\"statusCellClass(status)\"\n                      [attr.role]=\"statusCellRole(status)\"\n                      [attr.tabindex]=\"statusCellTabIndex(status)\"\n                      (click)=\"emitSolutionClick($event, row, rowIndex, status, problemIndex)\"\n                      (keydown.enter)=\"activateStatusCellFromKeyboard($event, row, rowIndex, status, problemIndex)\"\n                      (keydown.space)=\"activateStatusCellFromKeyboard($event, row, rowIndex, status, problemIndex)\"\n                    >\n                      <ng-container *ngIf=\"statusPresentation(status) as presentation\">\n                        <ng-container *ngIf=\"presentation.secondary !== undefined; else singleStatus\">\n                          <span class=\"srk-prest-status-block-primary\">{{ presentation.primary || '' }}</span>\n                          <span [textContent]=\"statusSeparator\"></span>\n                          <span class=\"srk-prest-status-block-secondary\">{{ presentation.secondary }}</span>\n                        </ng-container>\n                        <ng-template #singleStatus>{{ presentation.primary }}</ng-template>\n                      </ng-container>\n                    </td>\n                  </ng-template>\n                  <ng-template #emptyStatus>\n                    <td class=\"srk-status-placeholder-cell srk--text-center srk--nowrap\">\n                      {{ emptyStatusPlaceholder }}\n                    </td>\n                  </ng-template>\n                </ng-template>\n              </ng-container>\n\n              <td *ngIf=\"showDirtColumn\" class=\"srk-dirt-cell srk--text-right srk--nowrap\">\n                {{ calculateDirtPercentage(row) }}\n              </td>\n              <td *ngIf=\"showSEColumn\" class=\"srk-se-cell srk--text-right srk--nowrap\">\n                {{ calculateSEValue(row, problemStatistics) }}\n              </td>\n            </tr>\n          </tbody>\n          <tfoot *ngIf=\"showProblemStatisticsFooter\">\n            <tr\n              *ngFor=\"let footerRow of problemStatisticsFooterRows\"\n              class=\"srk-problem-statistics-footer-row\"\n            >\n              <td\n                class=\"srk-problem-statistics-footer-labels srk--text-right srk--nowrap\"\n                [attr.colspan]=\"leftFooterColumnCount()\"\n              >\n                <span\n                  class=\"srk-problem-statistics-footer-label srk--c-tooltip\"\n                  [attr.data-tooltip]=\"footerRow.tooltip\"\n                >\n                  {{ footerRow.label }}\n                </span>\n              </td>\n              <td\n                *ngFor=\"let stat of problemStatistics\"\n                class=\"srk-problem-statistics-footer-cell srk--text-center srk--nowrap\"\n              >\n                <span class=\"srk-problem-statistics-footer-primary\">\n                  {{ getProblemStatisticsFooterCellPrimary(footerRow.key, stat) }}\n                </span>\n                <ng-container *ngIf=\"getProblemStatisticsFooterCellSecondary(footerRow.key, stat) !== undefined\">\n                  <span> </span>\n                  <span class=\"srk-problem-statistics-footer-secondary\">\n                    {{ getProblemStatisticsFooterCellSecondary(footerRow.key, stat) }}\n                  </span>\n                </ng-container>\n              </td>\n              <td\n                *ngIf=\"showDirtColumn\"\n                class=\"srk-problem-statistics-footer-cell srk-extra-statistics-footer-cell srk-dirt-footer-cell srk--nowrap\"\n              >\n                <span class=\"srk-problem-statistics-footer-primary\"></span>\n              </td>\n              <td\n                *ngIf=\"showSEColumn\"\n                class=\"srk-problem-statistics-footer-cell srk-extra-statistics-footer-cell srk-se-footer-cell srk--nowrap\"\n              >\n                <span class=\"srk-problem-statistics-footer-primary\"></span>\n              </td>\n            </tr>\n            <tr class=\"srk-problem-statistics-footer-row srk-problem-statistics-footer-problem-label-row\">\n              <td\n                class=\"srk-problem-statistics-footer-labels srk--text-right srk--nowrap\"\n                [attr.colspan]=\"leftFooterColumnCount()\"\n              ></td>\n              <td\n                *ngFor=\"let problem of data.problems; let problemIndex = index\"\n                class=\"srk-problem-statistics-footer-cell srk-problem-statistics-footer-problem-header srk-problem-header srk--text-center srk--nowrap\"\n                [style.background-image]=\"problemHeaderBackgroundImage(problem, 0)\"\n              >\n                <span class=\"srk--display-block\">{{ problemAlias(problem, problemIndex) }}</span>\n              </td>\n              <td\n                *ngIf=\"showDirtColumn\"\n                class=\"srk-problem-statistics-footer-cell srk-extra-statistics-footer-cell srk-dirt-footer-cell srk--nowrap\"\n              >\n                <span class=\"srk-problem-statistics-footer-primary\"></span>\n              </td>\n              <td\n                *ngIf=\"showSEColumn\"\n                class=\"srk-problem-statistics-footer-cell srk-extra-statistics-footer-cell srk-se-footer-cell srk--nowrap\"\n              >\n                <span class=\"srk-problem-statistics-footer-primary\"></span>\n              </td>\n            </tr>\n          </tfoot>\n        </table>\n      </div>\n    </ng-template>\n  `,\n})\nexport class RanklistComponent {\n  @Input({ required: true }) data!: StaticRanklist;\n  @Input() theme: EnumTheme = EnumTheme.light;\n  @Input() rowBordered = false;\n  @Input() columnBordered = false;\n  @Input() rowStriped = false;\n  @Input() formatSrkAssetUrl?: (url: string, field: string) => string;\n  @Input() splitOrganization = false;\n  @Input() columnTitles?: RanklistColumnTitles;\n  @Input() statusCellPreset: RanklistStatusCellPreset = 'classic';\n  @Input() statusColorAsText = false;\n  @Input() showProblemStatisticsFooter = false;\n  @Input() showDirtColumn = false;\n  @Input() showSEColumn = false;\n  @Input() emptyStatusPlaceholder: string | null = null;\n  @Input() userAvatarPlacement: RanklistUserAvatarPlacement = 'user';\n\n  @Output() userClick = new EventEmitter<UserClickPayload>();\n  @Output() solutionClick = new EventEmitter<SolutionClickPayload>();\n\n  @ContentChild(SrkStatusCellTemplateDirective)\n  statusCellTemplate?: SrkStatusCellTemplateDirective;\n\n  @ContentChild(SrkUserCellTemplateDirective)\n  userCellTemplate?: SrkUserCellTemplateDirective;\n\n  readonly supportedVersions = srkSupportedVersions;\n  readonly firstBloodStar = '\\u2605';\n  readonly statusSeparator = ' ';\n  readonly problemStatisticsFooterRows = [\n    {\n      key: 'accepted',\n      label: 'Accepted',\n      tooltip: 'Number of participants who solved this problem',\n    },\n    {\n      key: 'tried',\n      label: 'Tried',\n      tooltip: 'Number of participants who attempted this problem',\n    },\n    {\n      key: 'submitted',\n      label: 'Submitted',\n      tooltip: 'Total number of valid submissions for this problem',\n    },\n    {\n      key: 'dirt',\n      label: 'Dirt',\n      tooltip: 'Wrong submissions among participants who solved this problem',\n    },\n    {\n      key: 'se',\n      label: 'SE',\n      tooltip: 'Average hardness, calculated as (participants - accepted) / participants',\n    },\n    {\n      key: 'firstAccepted',\n      label: 'FB at',\n      tooltip: 'First Blood at, also known as first solve time, in minutes',\n    },\n    {\n      key: 'lastAccepted',\n      label: 'LB at',\n      tooltip: 'Last Blood at, also known as last solve time, in minutes',\n    },\n  ];\n  private problemStatisticsSource?: StaticRanklist;\n  private problemStatisticsCache?: ProblemStatisticsFooter[];\n\n  get problemStatistics() {\n    if (!this.showProblemStatisticsFooter && !this.showSEColumn) {\n      return [];\n    }\n    if (this.problemStatisticsSource !== this.data || !this.problemStatisticsCache) {\n      this.problemStatisticsSource = this.data;\n      this.problemStatisticsCache = calculateProblemStatisticsFooter(this.data);\n    }\n    return this.problemStatisticsCache;\n  }\n\n  isSupportedVersion() {\n    return caniuse(this.data.version);\n  }\n\n  showTimeColumn() {\n    return shouldShowTimeColumn(this.data.rows);\n  }\n\n  showAvatarInOrganization() {\n    return this.splitOrganization && this.userAvatarPlacement === 'organization';\n  }\n\n  leftFooterColumnCount() {\n    return this.data.series.length + 1 + 1 + (this.showTimeColumn() ? 1 : 0) + (this.splitOrganization ? 1 : 0);\n  }\n\n  getRankValues(row: StaticRanklistRow): RankValue[] {\n    return row.rankValues || this.data.series.map(() => ({ rank: null, segmentIndex: null }));\n  }\n\n  getRankText(rankValue: RankValue, row: StaticRanklistRow) {\n    return rankValue.rank ? rankValue.rank : row.user.official === false ? '＊' : '';\n  }\n\n  resolveDisplayText(text: Parameters<typeof resolveText>[0]) {\n    return resolveText(text);\n  }\n\n  resolveSeriesColumnTitle(series: srk.RankSeries, index: number) {\n    const seriesTitles = this.columnTitles?.series;\n    if (typeof seriesTitles === 'function') {\n      return seriesTitles(series, index) ?? series.title;\n    }\n    if (Array.isArray(seriesTitles)) {\n      return seriesTitles[index] ?? series.title;\n    }\n    return series.title;\n  }\n\n  resolveColumnTitle(key: Exclude<keyof RanklistColumnTitles, 'series'>, fallback: string) {\n    return this.columnTitles?.[key] ?? fallback;\n  }\n\n  problemAlias(problem: srk.Problem, problemIndex: number) {\n    return problem.alias || numberToAlphabet(problemIndex);\n  }\n\n  problemStatsTitle(statistics: srk.ProblemStatistics) {\n    const ratio = statistics.submitted ? ((statistics.accepted / statistics.submitted) * 100).toFixed(1) : 0;\n    return `${statistics.accepted} / ${statistics.submitted} (${ratio}%)`;\n  }\n\n  problemHeaderBackgroundImage(problem: srk.Problem, gradientDirection = 180) {\n    return getProblemHeaderBackgroundImage(problem.style, this.theme, gradientDirection);\n  }\n\n  resolvedUserMarkers(user: srk.User) {\n    return resolveUserMarkers(user, this.data.markers).map((marker) => ({\n      marker,\n      presentation: getMarkerPresentation(marker, this.theme),\n    }));\n  }\n\n  formatAssetUrl(url: string, field: string) {\n    return resolveSrkAssetUrl(url, field, this.formatSrkAssetUrl);\n  }\n\n  formatTime(time: Parameters<typeof formatTimeDuration>[0]) {\n    return formatTimeDuration(time, 'min', Math.floor);\n  }\n\n  calculateDirtPercentage(row: StaticRanklistRow) {\n    return calculateDirtPercentage(row);\n  }\n\n  calculateSEValue(row: StaticRanklistRow, problemStatistics: ProblemStatisticsFooter[]) {\n    return calculateSEValue(row, problemStatistics);\n  }\n\n  statusPresentation(status: srk.RankProblemStatus) {\n    return getRankProblemStatusCellPresentation(status, this.data, this.statusCellPreset);\n  }\n\n  isNumber(value: unknown): value is number {\n    return typeof value === 'number';\n  }\n\n  getStatusSolutions(status: srk.RankProblemStatus) {\n    return [...(status.solutions || [])].reverse();\n  }\n\n  statusCellClass(status: srk.RankProblemStatus) {\n    const classNames = ['srk-prest-status-block', 'srk--text-center', 'srk--nowrap'];\n    if (this.isStatusClickable(status)) {\n      classNames.push('srk--cursor-pointer');\n    }\n    if (this.statusColorAsText) {\n      classNames.push('srk-prest-status-block-color-text');\n    }\n    if (status.result === 'FB') {\n      classNames.push('srk-prest-status-block-fb');\n    } else if (status.result === 'AC') {\n      classNames.push('srk-prest-status-block-accepted');\n    } else if (status.result === '?') {\n      classNames.push('srk-prest-status-block-frozen');\n    } else if (status.result === 'RJ') {\n      classNames.push('srk-prest-status-block-failed');\n    }\n    return classNames.join(' ');\n  }\n\n  isStatusClickable(status: srk.RankProblemStatus) {\n    return this.getStatusSolutions(status).length > 0;\n  }\n\n  statusCellRole(status: srk.RankProblemStatus) {\n    return this.isStatusClickable(status) ? 'button' : null;\n  }\n\n  statusCellTabIndex(status: srk.RankProblemStatus) {\n    return this.isStatusClickable(status) ? 0 : null;\n  }\n\n  buildUserCellContext(row: StaticRanklistRow, rowIndex: number): UserCellTemplateContext {\n    return {\n      $implicit: row.user,\n      user: row.user,\n      row,\n      rowIndex,\n      ranklist: this.data,\n      markers: this.data.markers,\n      hideOrganization: this.splitOrganization,\n      hideAvatar: this.showAvatarInOrganization(),\n      onClick: (event?: MouseEvent) => this.emitUserClick(event, row, rowIndex),\n    };\n  }\n\n  buildStatusCellContext(\n    row: StaticRanklistRow,\n    rowIndex: number,\n    status: srk.RankProblemStatus,\n    problemIndex: number,\n  ): StatusCellTemplateContext {\n    return {\n      $implicit: status,\n      status,\n      problem: this.data.problems[problemIndex],\n      problemIndex,\n      user: row.user,\n      row,\n      rowIndex,\n      ranklist: this.data,\n      solutions: this.getStatusSolutions(status),\n      statusCellPreset: this.statusCellPreset,\n      statusColorAsText: this.statusColorAsText,\n      emptyStatusPlaceholder: this.emptyStatusPlaceholder,\n      onClick: (event?: MouseEvent) => this.emitSolutionClick(event, row, rowIndex, status, problemIndex),\n    };\n  }\n\n  activateUserCellFromKeyboard(event: Event, row: StaticRanklistRow, rowIndex: number) {\n    event.preventDefault();\n    this.emitUserClick(undefined, row, rowIndex);\n  }\n\n  activateStatusCellFromKeyboard(\n    event: Event,\n    row: StaticRanklistRow,\n    rowIndex: number,\n    status: srk.RankProblemStatus,\n    problemIndex: number,\n  ) {\n    event.preventDefault();\n    this.emitSolutionClick(undefined, row, rowIndex, status, problemIndex);\n  }\n\n  emitUserClick(event: MouseEvent | undefined, row: StaticRanklistRow, rowIndex: number) {\n    if (event) {\n      captureModalTriggerPointFromMouseEvent(event, {\n        source: 'user-cell',\n        context: {\n          rowIndex,\n          userId: row.user.id || null,\n          userName: this.resolveDisplayText(row.user.name),\n        },\n      });\n    }\n    this.userClick.emit({\n      user: row.user,\n      row,\n      rowIndex,\n      ranklist: this.data,\n    });\n  }\n\n  emitSolutionClick(\n    event: MouseEvent | undefined,\n    row: StaticRanklistRow,\n    rowIndex: number,\n    status: srk.RankProblemStatus,\n    problemIndex: number,\n  ) {\n    const solutions = this.getStatusSolutions(status);\n    if (!solutions.length) {\n      return;\n    }\n    if (event) {\n      captureModalTriggerPointFromMouseEvent(event, {\n        source: 'status-cell',\n        context: {\n          rowIndex,\n          problemIndex,\n          problemAlias: this.data.problems[problemIndex]?.alias || null,\n          problemTitle: this.data.problems[problemIndex] ? this.resolveDisplayText(this.data.problems[problemIndex].title) : null,\n          userId: row.user.id || null,\n        },\n      });\n    }\n    this.solutionClick.emit({\n      user: row.user,\n      row,\n      rowIndex,\n      problemIndex,\n      problem: this.data.problems[problemIndex],\n      status,\n      solutions,\n      ranklist: this.data,\n    });\n  }\n\n  private resolveSeriesSegment(rankValue: RankValue, series: srk.RankSeries | undefined) {\n    const index = rankValue.segmentIndex || rankValue.segmentIndex === 0 ? rankValue.segmentIndex : -1;\n    return (series?.segments || [])[index] || {};\n  }\n\n  isSeriesSegmentedColumn(series: srk.RankSeries | undefined) {\n    return (series?.segments || []).some((segment) => typeof segment.style === 'string');\n  }\n\n  getSeriesSegmentClass(rankValue: RankValue, series: srk.RankSeries | undefined) {\n    const segmentStyle = this.resolveSeriesSegment(rankValue, series).style;\n    return typeof segmentStyle === 'string' ? `srk-preset-series-segment-${segmentStyle}` : '';\n  }\n\n  getSeriesSegmentStyle(rankValue: RankValue, series: srk.RankSeries | undefined) {\n    const emptyColor: ThemeColor = {\n      [EnumTheme.light]: undefined,\n      [EnumTheme.dark]: undefined,\n    };\n    const segmentStyle = this.resolveSeriesSegment(rankValue, series).style;\n    if (!segmentStyle || typeof segmentStyle === 'string') {\n      return {};\n    }\n    const style = resolveStyle(segmentStyle);\n    const textColor = style.textColor || emptyColor;\n    const backgroundColor = style.backgroundColor || emptyColor;\n    return {\n      color: textColor[this.theme],\n      backgroundColor: backgroundColor[this.theme],\n    };\n  }\n\n  getProblemStatisticsFooterCellPrimary(key: string, stat: ProblemStatisticsFooter) {\n    switch (key) {\n      case 'accepted':\n        return stat.accepted;\n      case 'tried':\n        return stat.tried;\n      case 'submitted':\n        return stat.submitted;\n      case 'dirt':\n        return stat.dirt;\n      case 'se':\n        return formatProblemStatisticsAverageHardness(stat);\n      case 'firstAccepted':\n        return formatProblemStatisticsAcceptedMinute(stat.firstAcceptedTime);\n      case 'lastAccepted':\n        return formatProblemStatisticsAcceptedMinute(stat.lastAcceptedTime);\n      default:\n        return '';\n    }\n  }\n\n  getProblemStatisticsFooterCellSecondary(key: string, stat: ProblemStatisticsFooter) {\n    switch (key) {\n      case 'accepted':\n        return formatProblemStatisticsPercent(stat.accepted, stat.participantCount);\n      case 'tried':\n        return formatProblemStatisticsPercent(stat.tried, stat.participantCount);\n      case 'dirt':\n        return formatProblemStatisticsPercent(stat.dirt, stat.dirtSubmitted);\n      default:\n        return undefined;\n    }\n  }\n}\n"]}