@xcpcio/core 0.52.1 → 0.53.0

package/dist/index.mjs

@@ -1,22 +1,281 @@
+import _ from 'lodash';
+import chroma from 'chroma-js';
+import { furthest } from 'color-diff';
 import { SubmissionStatus, ContestState } from '@xcpcio/types';
+import { Base64 } from 'js-base64';
 import dayjs from 'dayjs';
 export { default as dayjs } from 'dayjs';
-import duration from 'dayjs/plugin/duration';
-import utc from 'dayjs/plugin/utc';
-import timezone from 'dayjs/plugin/timezone';
 import advancedFormat from 'dayjs/plugin/advancedFormat';
-import isSameOrBefore from 'dayjs/plugin/isSameOrBefore';
+import duration from 'dayjs/plugin/duration';
 import isSameOrAfter from 'dayjs/plugin/isSameOrAfter';
+import isSameOrBefore from 'dayjs/plugin/isSameOrBefore';
 import minMax from 'dayjs/plugin/minMax';
 import relativeTime from 'dayjs/plugin/relativeTime';
-import _ from 'lodash';
-import * as XLSX from 'xlsx-js-style';
+import timezone from 'dayjs/plugin/timezone';
+import utc from 'dayjs/plugin/utc';
 import stringWidth from 'string-width';
-import Papa from 'papaparse';
+import * as XLSX from 'xlsx-js-style';
 import ordinal from 'ordinal';
-import chroma from 'chroma-js';
-import { furthest } from 'color-diff';
-import { Base64 } from 'js-base64';
+import Papa from 'papaparse';
+
+var __defProp$j = Object.defineProperty;
+var __defNormalProp$j = (obj, key, value) => key in obj ? __defProp$j(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$j = (obj, key, value) => {
+  __defNormalProp$j(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+var MedalType = /* @__PURE__ */ ((MedalType2) => {
+  MedalType2["UNKNOWN"] = "Unknown";
+  MedalType2["GOLD"] = "Gold";
+  MedalType2["SILVER"] = "Silver";
+  MedalType2["BRONZE"] = "Bronze";
+  MedalType2["HONORABLE"] = "Honorable";
+  return MedalType2;
+})(MedalType || {});
+class Award {
+  constructor() {
+    __publicField$j(this, "medalType");
+    __publicField$j(this, "minRank");
+    __publicField$j(this, "maxRank");
+    this.medalType = "Unknown" /* UNKNOWN */;
+    this.minRank = 0;
+    this.maxRank = 0;
+  }
+}
+function isValidMedalType(medal) {
+  const validMedalType = [
+    "Gold" /* GOLD */,
+    "Silver" /* SILVER */,
+    "Bronze" /* BRONZE */,
+    "Honorable" /* HONORABLE */
+  ];
+  return validMedalType.includes(medal);
+}
+
+function calcDirt(attemptedNum, solvedNum) {
+  if (solvedNum === 0) {
+    return 0;
+  }
+  return Math.floor((attemptedNum - solvedNum) * 100 / attemptedNum);
+}
+
+function getWhiteOrBlackColorV1(background) {
+  const [R, G, B] = chroma(background).rgb();
+  const color = { R, G, B };
+  const palette = [
+    { R: 0, G: 0, B: 0 },
+    { R: 255, G: 255, B: 255 }
+  ];
+  const f = furthest(color, palette);
+  if (f.R === 0 && f.G === 0 && f.B === 0) {
+    return "#000";
+  } else {
+    return "#fff";
+  }
+}
+function getWhiteOrBlackColor(background) {
+  const [R, G, B] = chroma(background).rgb();
+  const brightness = (R * 299 + G * 587 + B * 114) / 1e3;
+  const threshold = 148;
+  return brightness <= threshold ? "#fff" : "#000";
+}
+
+dayjs.extend(duration);
+dayjs.extend(utc);
+dayjs.extend(timezone);
+dayjs.extend(advancedFormat);
+dayjs.extend(isSameOrBefore);
+dayjs.extend(isSameOrAfter);
+dayjs.extend(minMax);
+dayjs.extend(relativeTime);
+function createDayJS(time = void 0) {
+  if (time === void 0) {
+    return dayjs();
+  }
+  if (typeof time == "number" && String(time).length === 10) {
+    return dayjs.unix(time);
+  }
+  return dayjs(time);
+}
+function getTimestamp(time) {
+  if (typeof time === "number") {
+    return time;
+  }
+  return time.unix();
+}
+function getTimeDiff(seconds) {
+  const two = (a) => {
+    if (a < 10) {
+      return `0${a}`;
+    }
+    return String(a);
+  };
+  const h = Math.floor(seconds / 3600);
+  const m = Math.floor(seconds % 3600 / 60);
+  const s = seconds % 60;
+  return [two(h), two(m), two(s)].join(":");
+}
+
+var __defProp$i = Object.defineProperty;
+var __defNormalProp$i = (obj, key, value) => key in obj ? __defProp$i(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$i = (obj, key, value) => {
+  __defNormalProp$i(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class ProblemStatistics {
+  constructor() {
+    __publicField$i(this, "acceptedNum");
+    __publicField$i(this, "rejectedNum");
+    __publicField$i(this, "pendingNum");
+    __publicField$i(this, "submittedNum");
+    __publicField$i(this, "attemptedNum");
+    __publicField$i(this, "ignoreNum");
+    __publicField$i(this, "firstSolveSubmissions");
+    __publicField$i(this, "lastSolveSubmissions");
+    __publicField$i(this, "se");
+    this.acceptedNum = 0;
+    this.rejectedNum = 0;
+    this.pendingNum = 0;
+    this.submittedNum = 0;
+    this.attemptedNum = 0;
+    this.ignoreNum = 0;
+    this.se = 0;
+    this.firstSolveSubmissions = [];
+    this.lastSolveSubmissions = [];
+  }
+  reset() {
+    this.acceptedNum = 0;
+    this.rejectedNum = 0;
+    this.pendingNum = 0;
+    this.submittedNum = 0;
+    this.attemptedNum = 0;
+    this.ignoreNum = 0;
+    this.se = 0;
+    this.firstSolveSubmissions = [];
+    this.lastSolveSubmissions = [];
+  }
+  get dirt() {
+    if (this.acceptedNum === 0) {
+      return 0;
+    }
+    return calcDirt(this.attemptedNum, this.acceptedNum);
+  }
+  calcSE(totalTeams) {
+    const res = (totalTeams - this.acceptedNum) / totalTeams;
+    this.se = Math.round(res * 100) / 100;
+    return this.se;
+  }
+}
+class Problem {
+  constructor() {
+    __publicField$i(this, "id");
+    __publicField$i(this, "label");
+    __publicField$i(this, "name");
+    __publicField$i(this, "timeLimit");
+    __publicField$i(this, "memoryLimit");
+    __publicField$i(this, "balloonColor");
+    __publicField$i(this, "statistics");
+    this.id = "";
+    this.label = "";
+    this.name = "";
+    this.statistics = new ProblemStatistics();
+    this.balloonColor = {
+      background_color: "#a0f0a0",
+      color: "#000"
+    };
+  }
+}
+function createProblem(problemJSON) {
+  const p = new Problem();
+  p.id = String(problemJSON.id);
+  p.label = problemJSON.label;
+  p.name = problemJSON.name ?? "";
+  p.timeLimit = problemJSON.time_limit;
+  p.memoryLimit = problemJSON.memory_limit;
+  if (problemJSON.balloon_color) {
+    p.balloonColor = _.cloneDeep(problemJSON.balloon_color);
+  }
+  p.balloonColor.color = getWhiteOrBlackColor(p.balloonColor.background_color);
+  return p;
+}
+function createProblems(problemsJSON) {
+  return problemsJSON.map((pJSON) => createProblem(pJSON));
+}
+function createProblemsByProblemIds(problemIds, balloonColors) {
+  const problems = problemIds.map((label, index) => {
+    const p = new Problem();
+    p.id = String(index);
+    p.label = label;
+    return p;
+  });
+  if (balloonColors !== void 0 && balloonColors !== null) {
+    for (const index in balloonColors) {
+      problems[index].balloonColor = _.cloneDeep(balloonColors[index]);
+    }
+  }
+  problems.forEach((p) => {
+    p.balloonColor.color = getWhiteOrBlackColor(p.balloonColor.background_color);
+  });
+  return problems;
+}
+class TeamProblemStatistics {
+  constructor(options) {
+    __publicField$i(this, "isFirstSolved");
+    __publicField$i(this, "isSolved");
+    __publicField$i(this, "solvedTimestamp");
+    __publicField$i(this, "isSubmitted");
+    __publicField$i(this, "lastSubmitTimestamp");
+    __publicField$i(this, "failedCount");
+    __publicField$i(this, "pendingCount");
+    __publicField$i(this, "ignoreCount");
+    __publicField$i(this, "totalCount");
+    __publicField$i(this, "submissions");
+    __publicField$i(this, "problem");
+    __publicField$i(this, "contestPenalty");
+    this.isFirstSolved = options?.teamProblemStatistics?.isFirstSolved ?? false;
+    this.isSolved = options?.teamProblemStatistics?.isSolved ?? false;
+    this.solvedTimestamp = options?.teamProblemStatistics?.solvedTimestamp ?? 0;
+    this.isSubmitted = options?.teamProblemStatistics?.isSubmitted ?? false;
+    this.lastSubmitTimestamp = options?.teamProblemStatistics?.lastSubmitTimestamp ?? 0;
+    this.failedCount = options?.teamProblemStatistics?.failedCount ?? 0;
+    this.pendingCount = options?.teamProblemStatistics?.pendingCount ?? 0;
+    this.ignoreCount = options?.teamProblemStatistics?.ignoreCount ?? 0;
+    this.totalCount = options?.teamProblemStatistics?.totalCount ?? 0;
+    this.submissions = options?.teamProblemStatistics?.submissions ?? [];
+    this.problem = options?.teamProblemStatistics?.problem ?? new Problem();
+    this.contestPenalty = options?.teamProblemStatistics?.contestPenalty ?? 20 * 60;
+  }
+  get isAccepted() {
+    return this.isSolved;
+  }
+  get isWrongAnswer() {
+    return !this.isSolved && this.pendingCount === 0 && this.failedCount > 0;
+  }
+  get isPending() {
+    return !this.isSolved && this.pendingCount > 0;
+  }
+  get isUnSubmitted() {
+    return this.totalCount === 0;
+  }
+  get solvedTimestampToMinute() {
+    return Math.floor(this.solvedTimestamp / 60);
+  }
+  get penalty() {
+    if (this.isSolved === false) {
+      return 0;
+    }
+    return this.solvedTimestampToMinute * 60 + this.failedCount * this.contestPenalty;
+  }
+  get penaltyToMinute() {
+    return Math.floor(this.penalty / 60);
+  }
+  get penaltyInSecond() {
+    if (this.isSolved === false) {
+      return 0;
+    }
+    return this.solvedTimestamp + this.failedCount * this.contestPenalty;
+  }
+}
 
 function stringToSubmissionStatus(status) {
   status = status.toUpperCase().replace(" ", "_");
@@ -140,1675 +399,1233 @@ function isNotCalculatedPenaltyStatus(status) {
   return isNotCalculatedPenaltyArray.includes(status);
 }
 
-dayjs.extend(duration);
-dayjs.extend(utc);
-dayjs.extend(timezone);
-dayjs.extend(advancedFormat);
-dayjs.extend(isSameOrBefore);
-dayjs.extend(isSameOrAfter);
-dayjs.extend(minMax);
-dayjs.extend(relativeTime);
-function createDayJS(time = void 0) {
-  if (time === void 0) {
-    return dayjs();
-  }
-  if (typeof time == "number" && String(time).length === 10) {
-    return dayjs.unix(time);
-  }
-  return dayjs(time);
-}
-function getTimestamp(time) {
-  if (typeof time === "number") {
-    return time;
-  }
-  return time.unix();
-}
-function getTimeDiff(seconds) {
-  const two = (a) => {
-    if (a < 10) {
-      return `0${a}`;
-    }
-    return String(a);
-  };
-  const h = Math.floor(seconds / 3600);
-  const m = Math.floor(seconds % 3600 / 60);
-  const s = seconds % 60;
-  return [two(h), two(m), two(s)].join(":");
-}
-
-class CodeforcesGymGhostDATConverter {
+var __defProp$h = Object.defineProperty;
+var __defNormalProp$h = (obj, key, value) => key in obj ? __defProp$h(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$h = (obj, key, value) => {
+  __defNormalProp$h(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class Submission {
   constructor() {
+    __publicField$h(this, "id");
+    __publicField$h(this, "teamId");
+    __publicField$h(this, "problemId");
+    __publicField$h(this, "timestamp");
+    __publicField$h(this, "timestampUnit");
+    __publicField$h(this, "time");
+    __publicField$h(this, "language");
+    __publicField$h(this, "reaction");
+    __publicField$h(this, "status", SubmissionStatus.UNKNOWN);
+    __publicField$h(this, "isIgnore", false);
+    __publicField$h(this, "isSolved", false);
+    __publicField$h(this, "isFirstSolved", false);
+    this.id = "";
+    this.teamId = "";
+    this.problemId = "";
+    this.timestamp = 0;
+    this.timestampUnit = "second";
   }
-  convert(rank) {
-    let res = "";
-    res += `@contest "${rank.contest.name}"
-@contlen ${Math.floor(dayjs.duration(rank.contest.endTime.diff(rank.contest.startTime)).asMinutes())}
-@problems ${rank.contest.problems.length}
-@teams ${rank.teams.length + 100}
-@submissions ${rank.submissions.length}
-`;
-    rank.contest.problems.forEach((p) => {
-      res += `@p ${p.label},${p.label},20,0
-`;
-    });
-    let teamIndex = 1;
-    const teamIdMap = /* @__PURE__ */ new Map();
-    const submissionsIdMap = /* @__PURE__ */ new Map();
-    rank.teams.forEach((team) => {
-      let name = team.name;
-      if (team.organization) {
-        name = `${team.organization} - ${name}`;
-      }
-      if (team.members) {
-        name = `${name} - ${team.membersToString}`;
-      }
-      res += `@t ${teamIndex},0,1,"${name}"
-`;
-      teamIdMap.set(team.id, teamIndex);
-      teamIndex++;
-      {
-        const mp = /* @__PURE__ */ new Map();
-        rank.contest.problems.forEach((p) => {
-          mp.set(p.id, 0);
-        });
-        submissionsIdMap.set(team.id, mp);
-      }
-    });
-    for (let i = 0; i < 100; i++) {
-      res += `@t ${teamIndex},0,1,"\u041F\u043E\u043F\u043E\u043B\u043D\u0438\u0442\u044C \u043A\u043E\u043C\u0430\u043D\u0434\u0443"
-`;
-      teamIndex++;
-    }
-    rank.getSubmissions().forEach((submission) => {
-      const teamId = submission.teamId;
-      const problemId = submission.problemId;
-      const problem = rank.contest.problemsMap.get(problemId);
-      const teamIndex2 = teamIdMap.get(teamId);
-      if (!problem) {
-        return;
-      }
-      if (!teamIndex2) {
-        return;
-      }
-      const status = this.submissionStatusToCodeforcesGymDatStatus(submission.status);
-      submissionsIdMap.get(teamId).set(problemId, submissionsIdMap.get(teamId).get(problemId) + 1);
-      res += `@s ${teamIndex2},${problem.label},${submissionsIdMap.get(teamId)?.get(problemId)},${submission.timestampToSecond},${status}
-`;
-    });
-    return res;
+  isAccepted() {
+    return isAccepted(this.status);
   }
-  submissionStatusToCodeforcesGymDatStatus(status) {
-    if (isAccepted(status)) {
-      return "OK";
+  isRejected() {
+    return isRejected(this.status);
+  }
+  isPending() {
+    return isPending(this.status);
+  }
+  isNotCalculatedPenaltyStatus() {
+    return isNotCalculatedPenaltyStatus(this.status);
+  }
+  get timestampToMinute() {
+    if (this.timestampUnit === "nanosecond") {
+      return Math.floor(this.timestamp / 60 / 1e3 / 1e3 / 1e3);
     }
-    if (status === SubmissionStatus.WRONG_ANSWER) {
-      return "WA";
+    if (this.timestampUnit === "microsecond") {
+      return Math.floor(this.timestamp / 60 / 1e3 / 1e3);
     }
-    if (status === SubmissionStatus.TIME_LIMIT_EXCEEDED) {
-      return "TL";
+    if (this.timestampUnit === "millisecond") {
+      return Math.floor(this.timestamp / 60 / 1e3);
     }
-    if (status === SubmissionStatus.MEMORY_LIMIT_EXCEEDED) {
-      return "ML";
+    return Math.floor(this.timestamp / 60);
+  }
+  get timestampToSecond() {
+    if (this.timestampUnit === "nanosecond") {
+      return Math.floor(this.timestamp / 1e3 / 1e3 / 1e3);
     }
-    if (status === SubmissionStatus.OUTPUT_LIMIT_EXCEEDED) {
-      return "IL";
+    if (this.timestampUnit === "microsecond") {
+      return Math.floor(this.timestamp / 1e3 / 1e3);
     }
-    if (status === SubmissionStatus.PRESENTATION_ERROR) {
-      return "PE";
+    if (this.timestampUnit === "millisecond") {
+      return Math.floor(this.timestamp / 1e3);
     }
-    if (status === SubmissionStatus.RUNTIME_ERROR) {
-      return "RT";
+    return this.timestamp;
+  }
+  get timestampDisplayFormatWithSecond() {
+    const second = this.timestampToSecond;
+    const h = Math.floor(second / 3600);
+    const m = Math.floor(second % 3600 / 60);
+    const s = second % 60;
+    const f = (x) => x.toString().padStart(2, "0");
+    const res = `${f(h)}:${f(m)}:${f(s)}`;
+    return res;
+  }
+  get timestampDisplayFormatWithMilliSecond() {
+    let res = this.timestampDisplayFormatWithSecond;
+    if (this.timestampUnit === "millisecond") {
+      const fl = (this.timestamp % 1e3).toString().padStart(3, "0");
+      res += `.${fl}`;
     }
-    if (status === SubmissionStatus.COMPILATION_ERROR || isNotCalculatedPenaltyStatus(status)) {
-      return "CE";
+    return res;
+  }
+  static compare(lhs, rhs) {
+    if (lhs.timestamp !== rhs.timestamp) {
+      return lhs.timestamp - rhs.timestamp;
     }
-    if (isPending(status)) {
-      return "PD";
+    if (lhs.teamId === rhs.teamId) {
+      if (lhs.isAccepted() && !rhs.isAccepted()) {
+        return -1;
+      }
+      if (!lhs.isAccepted() && rhs.isAccepted()) {
+        return 1;
+      }
+    }
+    if (lhs.id < rhs.id) {
+      return -1;
+    } else if (lhs.id === rhs.id) {
+      return 0;
+    } else {
+      return 1;
     }
-    return "RJ";
   }
 }
-
-var MedalType = /* @__PURE__ */ ((MedalType2) => {
-  MedalType2["UNKNOWN"] = "Unknown";
-  MedalType2["GOLD"] = "Gold";
-  MedalType2["SILVER"] = "Silver";
-  MedalType2["BRONZE"] = "Bronze";
-  MedalType2["HONORABLE"] = "Honorable";
-  return MedalType2;
-})(MedalType || {});
-class Award {
-  constructor() {
-    this.medalType = "Unknown" /* UNKNOWN */;
-    this.minRank = 0;
-    this.maxRank = 0;
+function createSubmission(submissionJSON) {
+  const s = new Submission();
+  s.id = String(submissionJSON.id ?? submissionJSON.submission_id ?? "");
+  s.teamId = String(submissionJSON.team_id);
+  s.problemId = String(submissionJSON.problem_id);
+  s.timestamp = submissionJSON.timestamp;
+  s.status = stringToSubmissionStatus(submissionJSON.status);
+  s.isIgnore = submissionJSON.is_ignore ?? false;
+  if (submissionJSON.time) {
+    s.time = submissionJSON.time;
+  }
+  if (submissionJSON.language) {
+    s.language = submissionJSON.language;
   }
+  if (submissionJSON.reaction) {
+    s.reaction = submissionJSON.reaction;
+  }
+  return s;
 }
-function isValidMedalType(medal) {
-  const validMedalType = [
-    "Gold" /* GOLD */,
-    "Silver" /* SILVER */,
-    "Bronze" /* BRONZE */,
-    "Honorable" /* HONORABLE */
-  ];
-  return validMedalType.includes(medal);
+function createSubmissions(submissionsJSON) {
+  if (Array.isArray(submissionsJSON)) {
+    return submissionsJSON.map((s, index) => createSubmission({ ...s, id: s.submission_id ?? String(index) }));
+  } else {
+    const submissions = Object.entries(submissionsJSON).map(
+      ([submissionId, s]) => createSubmission({ ...s, id: s.submission_id ?? submissionId })
+    );
+    return submissions;
+  }
 }
 
-class GeneralExcelConverter {
+var __defProp$g = Object.defineProperty;
+var __defNormalProp$g = (obj, key, value) => key in obj ? __defProp$g(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$g = (obj, key, value) => {
+  __defNormalProp$g(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class PlaceChartPointData {
   constructor() {
+    __publicField$g(this, "timePoint");
+    __publicField$g(this, "rank");
+    __publicField$g(this, "lastSolvedProblem");
+    this.timePoint = 0;
+    this.rank = 0;
+    this.lastSolvedProblem = null;
   }
-  convert(oriRank) {
-    const rank = _.cloneDeep(oriRank);
-    rank.options.disableFilterTeamsByGroup();
-    rank.options.disableFilterSubmissionByTimestamp();
-    const workbook = XLSX.utils.book_new();
-    for (const [k, v] of rank.contest.group) {
-      rank.options.setGroup(k);
-      rank.buildRank();
-      const sheet = this.convertToSheet(rank);
-      XLSX.utils.book_append_sheet(workbook, sheet, v.names.get(v.defaultLang));
-    }
-    return workbook;
+}
+class Team {
+  constructor() {
+    __publicField$g(this, "id");
+    __publicField$g(this, "name");
+    __publicField$g(this, "organization");
+    __publicField$g(this, "badge");
+    __publicField$g(this, "group");
+    __publicField$g(this, "tag");
+    __publicField$g(this, "coach");
+    __publicField$g(this, "members");
+    __publicField$g(this, "rank");
+    __publicField$g(this, "originalRank");
+    __publicField$g(this, "organizationRank");
+    __publicField$g(this, "solvedProblemNum");
+    __publicField$g(this, "attemptedProblemNum");
+    __publicField$g(this, "lastSolvedProblem");
+    __publicField$g(this, "lastSolvedProblemStatistics");
+    __publicField$g(this, "penalty");
+    __publicField$g(this, "problemStatistics");
+    __publicField$g(this, "problemStatisticsMap");
+    __publicField$g(this, "submissions");
+    __publicField$g(this, "placeChartPoints");
+    __publicField$g(this, "awards");
+    __publicField$g(this, "location");
+    __publicField$g(this, "icpcID");
+    __publicField$g(this, "se");
+    this.id = "";
+    this.name = "";
+    this.organization = "";
+    this.group = [];
+    this.tag = [];
+    this.rank = 0;
+    this.originalRank = 0;
+    this.organizationRank = -1;
+    this.solvedProblemNum = 0;
+    this.attemptedProblemNum = 0;
+    this.lastSolvedProblem = null;
+    this.lastSolvedProblemStatistics = null;
+    this.penalty = 0;
+    this.problemStatistics = [];
+    this.problemStatisticsMap = /* @__PURE__ */ new Map();
+    this.submissions = [];
+    this.placeChartPoints = [];
+    this.awards = [];
+    this.se = 0;
   }
-  convertAndWrite(rank, filename) {
-    return XLSX.writeFile(
-      this.convert(rank),
-      filename,
-      {
-        compression: true
-      }
-    );
+  reset() {
+    this.rank = 0;
+    this.originalRank = 0;
+    this.organizationRank = -1;
+    this.solvedProblemNum = 0;
+    this.attemptedProblemNum = 0;
+    this.lastSolvedProblem = null;
+    this.lastSolvedProblemStatistics = null;
+    this.penalty = 0;
+    this.problemStatistics = [];
+    this.problemStatisticsMap = /* @__PURE__ */ new Map();
+    this.submissions = [];
+    this.placeChartPoints = [];
+    this.awards = [];
+    this.se = 0;
   }
-  convertToSheet(rank) {
-    const aoa = this.convertToAoa(rank);
-    const sheet = XLSX.utils.aoa_to_sheet(aoa);
-    const cols = [];
-    const head = aoa[1];
-    for (let j = 0; j < head.length; j++) {
-      let wch = 10;
-      for (let i = 1; i < aoa.length; i++) {
-        wch = Math.max(wch, stringWidth(aoa[i][j]) + 2);
-      }
-      cols.push({
-        wch
-      });
-    }
-    sheet["!cols"] = cols;
-    {
-      const mergeRange = { s: { r: 0, c: 0 }, e: { r: 0, c: head.length - 1 } };
-      const merges = [{ s: mergeRange.s, e: mergeRange.e }];
-      sheet["!merges"] = merges;
+  get penaltyToMinute() {
+    return Math.floor(this.penalty / 60);
+  }
+  get isUnofficial() {
+    return this.group.includes("unofficial");
+  }
+  get isGirl() {
+    return this.group.includes("girl");
+  }
+  get membersToArray() {
+    if (Array.isArray(this.members)) {
+      return this.members;
     }
-    const font = {
-      name: "Arial Unicode MS",
-      bold: false,
-      italic: false,
-      sz: 12
-    };
-    const borderStyle = {
-      style: "thin"
-    };
-    const cellStyle = {
-      alignment: {
-        vertical: "center",
-        horizontal: "center"
-      },
-      border: {
-        top: borderStyle,
-        bottom: borderStyle,
-        left: borderStyle,
-        right: borderStyle
-      },
-      font
-    };
-    for (let i = 1; i < aoa.length; i++) {
-      for (let j = 0; j < aoa[i].length; j++) {
-        const cellAddress = XLSX.utils.encode_cell({ r: i, c: j });
-        const cell = sheet[cellAddress];
-        cell.s = cellStyle;
+    if (typeof this.members === "string") {
+      if (this.members.includes(", ")) {
+        return this.members.split(", ");
+      }
+      if (this.members.includes("\u3001")) {
+        return this.members.split("\u3001");
       }
     }
-    {
-      const cellAddress = XLSX.utils.encode_cell({ r: 0, c: 0 });
-      const cell = sheet[cellAddress];
-      const titleStyle = _.cloneDeep(cellStyle);
-      titleStyle.font.sz = 28;
-      titleStyle.font.bold = true;
-      cell.s = titleStyle;
-    }
-    return sheet;
+    return [];
   }
-  convertToAoa(rank) {
-    const aoa = [];
-    const enableAwards = rank.contest.isEnableAwards(rank.options.group);
-    const enableMembers = (Array.isArray(rank.teams) && rank.teams[0]?.members) ?? false;
-    const enableCoach = rank.teams[0]?.coach ?? false;
-    {
-      aoa.push([rank.contest.name]);
+  get membersToString() {
+    if (typeof this.members === "string") {
+      return this.members;
     }
-    {
-      const head = [];
-      head.push("Rank");
-      if (rank.contest.organization) {
-        head.push(`${rank.contest.organization} Rank`);
-        head.push(rank.contest.organization);
-      }
-      head.push("Team", "Solved", "Penalty", ...rank.contest.problems.map((p) => p.label), "Dirt");
-      if (enableAwards) {
-        head.push("Medal");
-      }
-      if (enableMembers) {
-        head.push("Member1", "Member2", "Member3");
-      }
-      if (enableCoach) {
-        head.push("Coach");
+    return this.members?.join(", ");
+  }
+  get isEffectiveTeam() {
+    return this.solvedProblemNum > 0;
+  }
+  get dirt() {
+    const attemptedNum = this.attemptedProblemNum;
+    const solvedNum = this.solvedProblemNum;
+    return calcDirt(attemptedNum, solvedNum);
+  }
+  calcSE(totalTeams) {
+    let acceptedProblemNums = 0;
+    let total = 0;
+    this.problemStatistics.forEach((p) => {
+      if (p.isSolved) {
+        acceptedProblemNums += 1;
+        total += p.problem.statistics.acceptedNum;
       }
-      head.push("Unofficial");
-      head.push("Girl");
-      aoa.push(head);
+    });
+    if (totalTeams === 0 || acceptedProblemNums === 0) {
+      return 0;
     }
-    for (const team of rank.teams) {
-      const arr = [];
-      arr.push(team.rank.toString());
-      if (team.organization) {
-        if (team.organizationRank !== -1) {
-          arr.push(team.organizationRank.toString());
-        } else {
-          arr.push("");
-        }
-        arr.push(team.organization);
-      }
-      arr.push(team.name, team.solvedProblemNum.toString(), team.penaltyToMinute.toString());
-      for (const p of team.problemStatistics) {
-        if (p.isUnSubmitted) {
-          arr.push("-");
-        }
-        if (p.isSolved) {
-          arr.push(`+${p.totalCount}(${p.solvedTimestampToMinute})`);
-        }
-        if (p.isWrongAnswer) {
-          arr.push(`-${p.failedCount}`);
-        }
-        if (p.isPending) {
-          arr.push(`? ${p.failedCount} + ${p.pendingCount}`);
-        }
-      }
-      arr.push(`${team.dirt}%`);
-      if (enableAwards) {
-        const medals = team.awards.filter((a) => isValidMedalType(a)).map((a) => a.toString());
-        arr.push(medals.join(", "));
-      }
-      if (enableMembers) {
-        const members = team.members;
-        if (Array.isArray(members)) {
-          arr.push(members[0] ?? "");
-          arr.push(members[1] ?? "");
-          arr.push(members[2] ?? "");
-        } else {
-          arr.push("", "", "");
-        }
-      }
-      if (enableCoach) {
-        if (typeof team.coach === "string") {
-          arr.push(team.coach ?? "");
+    const res = (acceptedProblemNums * totalTeams - total) / totalTeams / acceptedProblemNums;
+    this.se = Math.round(res * 100) / 100;
+    return this.se;
+  }
+  calcSolvedData(options) {
+    this.solvedProblemNum = 0;
+    this.attemptedProblemNum = 0;
+    this.penalty = 0;
+    for (const p of this.problemStatistics) {
+      if (p.isAccepted) {
+        this.solvedProblemNum++;
+        this.attemptedProblemNum += p.failedCount + 1;
+        if (options?.calculationOfPenalty === "in_seconds" || options?.calculationOfPenalty === "accumulate_in_seconds_and_finally_to_the_minute") {
+          this.penalty += p.penaltyInSecond;
         } else {
-          arr.push("");
+          this.penalty += p.penalty;
         }
       }
-      arr.push(team.isUnofficial ? "Y" : "N");
-      arr.push(team.isGirl ? "Y" : "N");
-      aoa.push(arr);
     }
-    return aoa;
-  }
-}
-
-class ICPCStandingsCsvConverter {
-  constructor() {
-  }
-  convert(oriRank) {
-    const rank = _.cloneDeep(oriRank);
-    rank.options.disableFilterTeamsByGroup();
-    rank.options.disableFilterSubmissionByTimestamp();
-    rank.options.setGroup("official");
-    rank.buildRank();
-    const resList = [];
-    for (const team of rank.teams) {
-      const res = {
-        teamId: team.icpcID ?? "",
-        rank: team.rank,
-        medalCitation: this.getMedalCitation(team),
-        problemsSolved: team.solvedProblemNum,
-        totalTime: team.penaltyToMinute,
-        lastProblemTime: team.lastSolvedProblemStatistics?.solvedTimestampToMinute ?? 0,
-        siteCitation: rank.contest.name,
-        citation: ordinal(team.rank),
-        teamName: team.name,
-        institution: team.organization
-      };
-      resList.push(res);
+    if (options?.calculationOfPenalty === "accumulate_in_seconds_and_finally_to_the_minute") {
+      this.penalty = Math.floor(this.penalty / 60) * 60;
     }
-    const csv = Papa.unparse(resList);
-    return csv;
   }
-  getMedalCitation(team) {
-    if (team.solvedProblemNum === 0) {
-      return "";
+  calcAwards(awards) {
+    if (!awards) {
+      return;
     }
-    const medals = team.awards.filter((a) => isValidMedalType(a)).map((a) => a.toString());
-    if (medals.length === 1) {
-      const medal = medals[0];
-      if (medal === "Gold") {
-        return "Gold Medal";
-      }
-      if (medal === "Silver") {
-        return "Silver Medal";
-      }
-      if (medal === "Bronze") {
-        return "Bronze Medal";
-      }
-      if (medal === "Honorable") {
-        return "Honorable Mention";
+    for (const award of awards) {
+      if (this.rank >= award.minRank && this.rank <= award.maxRank) {
+        this.awards.push(award.medalType);
       }
     }
-    return "";
   }
-}
-
-class Person {
-  constructor(name = "") {
-    this.name = name;
+  isEqualRank(otherTeam) {
+    return this.solvedProblemNum === otherTeam.solvedProblemNum && this.penalty === otherTeam.penalty;
   }
-  toJSON() {
-    return {
-      name: this.name
-    };
+  postProcessPlaceChartPoints() {
+    if (this.placeChartPoints.length === 0) {
+      return;
+    }
+    const res = [];
+    res.push(this.placeChartPoints[0]);
+    for (let i = 1; i < this.placeChartPoints.length - 1; i++) {
+      const p = this.placeChartPoints[i];
+      const preP = res[res.length - 1];
+      if (p.rank !== preP.rank || p.lastSolvedProblem !== preP.lastSolvedProblem) {
+        res.push(p);
+      }
+    }
+    if (this.placeChartPoints.length > 1) {
+      res.push(this.placeChartPoints[this.placeChartPoints.length - 1]);
+    }
+    this.placeChartPoints = res;
   }
-  static fromJSON(iPerson) {
-    if (typeof iPerson === "string") {
-      iPerson = JSON.parse(iPerson);
+  static compare(lhs, rhs) {
+    if (lhs.solvedProblemNum !== rhs.solvedProblemNum) {
+      return rhs.solvedProblemNum - lhs.solvedProblemNum;
     }
-    const person = new Person();
-    person.name = iPerson.name;
-    return person;
+    if (lhs.penalty !== rhs.penalty) {
+      return lhs.penalty - rhs.penalty;
+    }
+    if (lhs.lastSolvedProblemStatistics && rhs.lastSolvedProblemStatistics) {
+      return lhs.lastSolvedProblemStatistics.solvedTimestampToMinute - rhs.lastSolvedProblemStatistics.solvedTimestampToMinute;
+    }
+    if (lhs.name < rhs.name) {
+      return -1;
+    } else if (lhs.name > rhs.name) {
+      return 1;
+    }
+    return 0;
   }
 }
-function createPersons(iPersons) {
-  if (typeof iPersons === "string") {
-    for (const c of " ,\u3001|") {
-      if (iPersons.includes(c)) {
-        return iPersons.split(c).map((name) => new Person(name));
+function createTeam(teamJSON) {
+  const t = new Team();
+  t.id = teamJSON.id ?? teamJSON.team_id ?? "";
+  t.name = teamJSON.name ?? teamJSON.team_name ?? "";
+  t.organization = teamJSON.organization ?? "";
+  t.badge = teamJSON.badge;
+  t.group = _.cloneDeep(teamJSON.group ?? []);
+  t.tag = _.cloneDeep(teamJSON.tag ?? []);
+  t.coach = teamJSON.coach;
+  t.members = teamJSON.members;
+  if (Boolean(teamJSON.official) === true) {
+    t.group.push("official");
+  }
+  if (Boolean(teamJSON.unofficial) === true) {
+    t.group.push("unofficial");
+  }
+  if (Boolean(teamJSON.girl) === true) {
+    t.group.push("girl");
+  }
+  {
+    const tt = teamJSON;
+    for (const key of Object.keys(tt)) {
+      if (tt[key] === 1 || tt[key] === true) {
+        t.group.push(key);
       }
     }
-    return [new Person(iPersons)];
   }
-  return iPersons.map((name) => new Person(name));
-}
-
-function calcDirt(attemptedNum, solvedNum) {
-  if (solvedNum === 0) {
-    return 0;
+  t.group = [...new Set(t.group)];
+  t.group.sort();
+  if (teamJSON.location) {
+    t.location = teamJSON.location;
   }
-  return Math.floor((attemptedNum - solvedNum) * 100 / attemptedNum);
+  if (teamJSON.icpc_id) {
+    t.icpcID = teamJSON.icpc_id;
+  }
+  return t;
 }
-
-function getWhiteOrBlackColorV1(background) {
-  const [R, G, B] = chroma(background).rgb();
-  const color = { R, G, B };
-  const palette = [
-    { R: 0, G: 0, B: 0 },
-    { R: 255, G: 255, B: 255 }
-  ];
-  const f = furthest(color, palette);
-  if (f.R === 0 && f.G === 0 && f.B === 0) {
-    return "#000";
+function createTeams(teamsJSON) {
+  if (Array.isArray(teamsJSON)) {
+    return teamsJSON.map((t) => createTeam(t));
   } else {
-    return "#fff";
+    const teams = Object.entries(teamsJSON).map(
+      ([teamId, team]) => createTeam({ ...team, team_id: team.team_id ?? teamId })
+    );
+    return teams;
   }
 }
-function getWhiteOrBlackColor(background) {
-  const [R, G, B] = chroma(background).rgb();
-  const brightness = (R * 299 + G * 587 + B * 114) / 1e3;
-  const threshold = 148;
-  return brightness <= threshold ? "#fff" : "#000";
-}
 
-class RatingHistory {
+var __defProp$f = Object.defineProperty;
+var __defNormalProp$f = (obj, key, value) => key in obj ? __defProp$f(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$f = (obj, key, value) => {
+  __defNormalProp$f(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class Balloon {
   constructor() {
-    this.rank = 0;
-    this.rating = 0;
-    this.teamName = "";
-    this.organization = "";
-    this.members = [];
-    this.coaches = [];
-    this.contestID = "";
-    this.contestName = "";
-    this.contestLink = "";
-    this.contestTime = createDayJS();
+    __publicField$f(this, "problem");
+    __publicField$f(this, "team");
+    __publicField$f(this, "submission");
+    this.problem = new Problem();
+    this.team = new Team();
+    this.submission = new Submission();
   }
-  toJSON() {
-    return {
-      rank: this.rank,
-      rating: this.rating,
-      teamName: this.teamName,
-      organization: this.organization,
-      members: this.members.map((member) => member.toJSON()),
-      coaches: this.coaches.map((coach) => coach.toJSON()),
-      contestID: this.contestID,
-      contestName: this.contestName,
-      contestLink: this.contestLink,
-      contestTime: this.contestTime.toDate()
-    };
+  get key() {
+    return `balloon-${this.team.id}-${this.problem.id}`;
   }
-  static fromJSON(iRatingHistory) {
-    if (typeof iRatingHistory === "string") {
-      iRatingHistory = JSON.parse(iRatingHistory);
-    }
-    const ratingHistory = new RatingHistory();
-    ratingHistory.rank = iRatingHistory.rank;
-    ratingHistory.rating = iRatingHistory.rating;
-    ratingHistory.teamName = iRatingHistory.teamName;
-    ratingHistory.organization = iRatingHistory.organization;
-    ratingHistory.members = iRatingHistory.members.map((iMember) => Person.fromJSON(iMember));
-    ratingHistory.coaches = iRatingHistory.coaches.map((iCoach) => Person.fromJSON(iCoach));
-    ratingHistory.contestID = iRatingHistory.contestID;
-    ratingHistory.contestName = iRatingHistory.contestName;
-    ratingHistory.contestLink = iRatingHistory.contestLink;
-    ratingHistory.contestTime = createDayJS(iRatingHistory.contestTime);
-    return ratingHistory;
+  static compare(lhs, rhs) {
+    return Submission.compare(lhs.submission, rhs.submission);
   }
 }
 
-class RatingUser {
-  constructor() {
-    this.id = "";
-    this.name = "";
-    this.organization = "";
-    this.members = [];
-    this.coaches = [];
-    this.rating = 0;
-    this.minRating = 1061109567;
-    this.maxRating = -1061109567;
-    this.rank = 0;
-    this.oldRating = 0;
-    this.seed = 1;
-    this.delta = 0;
-    this.ratingHistories = [];
+var __defProp$e = Object.defineProperty;
+var __defNormalProp$e = (obj, key, value) => key in obj ? __defProp$e(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$e = (obj, key, value) => {
+  __defNormalProp$e(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+var GiantsType = /* @__PURE__ */ ((GiantsType2) => {
+  GiantsType2[GiantsType2["BLUE"] = 0] = "BLUE";
+  GiantsType2[GiantsType2["RED"] = 1] = "RED";
+  return GiantsType2;
+})(GiantsType || {});
+class Giants {
+  constructor(type = 0 /* BLUE */) {
+    __publicField$e(this, "type");
+    __publicField$e(this, "name");
+    __publicField$e(this, "filterOrganizations");
+    __publicField$e(this, "filterOrganizationMap");
+    __publicField$e(this, "filterTeams");
+    __publicField$e(this, "filterTeamMap");
+    __publicField$e(this, "teams");
+    this.type = type;
+    this.name = `${type === 0 /* BLUE */ ? "Blue" : "Red"} Team`;
+    this.teams = [];
+    this.filterOrganizations = [];
+    this.filterOrganizationMap = /* @__PURE__ */ new Map();
+    this.filterTeams = [];
+    this.filterTeamMap = /* @__PURE__ */ new Map();
   }
-  UpdateRating(rating) {
-    this.rating = rating;
-    this.minRating = Math.min(this.minRating, rating);
-    this.maxRating = Math.max(this.maxRating, rating);
+  setFilterOrganizations(filterOrganizations) {
+    const m = /* @__PURE__ */ new Map();
+    filterOrganizations.forEach((item) => {
+      m.set(item.value, item);
+    });
+    this.filterOrganizations = filterOrganizations;
+    this.filterOrganizationMap = m;
   }
-  toJSON() {
-    return {
-      id: this.id,
-      name: this.name,
-      organization: this.organization,
-      members: this.members.map((member) => member.toJSON()),
-      coaches: this.coaches.map((coach) => coach.toJSON()),
-      rating: this.rating,
-      minRating: this.minRating,
-      maxRating: this.maxRating,
-      ratingHistories: this.ratingHistories.map((ratingHistory) => ratingHistory.toJSON())
-    };
+  setFilterTeams(filterTeams) {
+    const m = /* @__PURE__ */ new Map();
+    filterTeams.forEach((item) => {
+      m.set(item.value, item);
+    });
+    this.filterTeams = filterTeams;
+    this.filterTeamMap = m;
   }
-  static fromJSON(iRatingUser) {
-    if (typeof iRatingUser === "string") {
-      iRatingUser = JSON.parse(iRatingUser);
-    }
-    const ratingUser = new RatingUser();
-    ratingUser.id = iRatingUser.id;
-    ratingUser.name = iRatingUser.name;
-    ratingUser.organization = iRatingUser.organization;
-    ratingUser.members = iRatingUser.members.map((member) => Person.fromJSON(member));
-    ratingUser.coaches = iRatingUser.coaches.map((coach) => Person.fromJSON(coach));
-    ratingUser.rating = iRatingUser.rating;
-    ratingUser.minRating = iRatingUser.minRating;
-    ratingUser.maxRating = iRatingUser.maxRating;
-    for (const iRatingHistory of iRatingUser.ratingHistories) {
-      ratingUser.ratingHistories.push(RatingHistory.fromJSON(iRatingHistory));
+  refreshName() {
+    if (this.filterOrganizations.length > 0) {
+      this.name = this.filterOrganizations[0].text;
+    } else {
+      this.name = `${this.type === 0 /* BLUE */ ? "Blue" : "Red"} Team`;
     }
-    return ratingUser;
+    return this.name;
   }
-}
-
-class RatingCalculator {
-  constructor() {
-    this.users = [];
-  }
-  calculate() {
-    this.calculateInternal();
-  }
-  calcP(userA, userB) {
-    return 1 / (1 + 10 ** ((userB.oldRating - userA.oldRating) / 400));
+  get totalSolvedProblemNum() {
+    let total = 0;
+    this.teams.forEach((team) => {
+      total += team.solvedProblemNum;
+    });
+    return total;
   }
-  getExSeed(users, rating, ownUser) {
-    const exUser = new RatingUser();
-    exUser.oldRating = rating;
-    let res = 0;
-    users.forEach((user) => {
-      if (user.id !== ownUser.id) {
-        res += this.calcP(user, exUser);
-      }
+  get totalPenalty() {
+    let total = 0;
+    this.teams.forEach((team) => {
+      total += team.penaltyToMinute;
     });
-    return res;
+    return total;
   }
-  calcRating(users, rank, user) {
-    let left = 1;
-    let right = 8e3;
-    while (right - left > 1) {
-      const mid = Math.floor((left + right) / 2);
-      if (this.getExSeed(users, mid, user) < rank) {
-        right = mid;
-      } else {
-        left = mid;
+  get totalPenaltyToString() {
+    const penalty = this.totalPenalty;
+    const two = (a) => {
+      if (a < 10) {
+        return `0${a}`;
       }
-    }
-    return left;
+      return String(a);
+    };
+    const h = Math.floor(penalty / 60);
+    const m = Math.floor(penalty % 60);
+    return [two(h), two(m)].join(":");
   }
-  calculateInternal() {
-    for (let i = 0; i < this.users.length; i++) {
-      const u = this.users[i];
-      u.seed = 1;
-      for (let j = 0; j < this.users.length; j++) {
-        if (i !== j) {
-          const otherUser = this.users[j];
-          u.seed += this.calcP(otherUser, u);
-        }
-      }
-    }
-    let sumDelta = 0;
-    for (let i = 0; i < this.users.length; i++) {
-      const u = this.users[i];
-      u.delta = Math.floor(
-        (this.calcRating(this.users, Math.sqrt(u.rank * u.seed), u) - u.oldRating) / 2
-      );
-      sumDelta += u.delta;
-    }
-    let inc = Math.floor(-sumDelta / this.users.length) - 1;
-    for (let i = 0; i < this.users.length; i++) {
-      const u = this.users[i];
-      u.delta += inc;
+  toJSON() {
+    return {
+      type: this.type,
+      name: this.name,
+      filterOrganizations: this.filterOrganizations,
+      filterTeams: this.filterTeams
+    };
+  }
+}
+class BattleOfGiants {
+  constructor() {
+    __publicField$e(this, "enable");
+    __publicField$e(this, "topX");
+    __publicField$e(this, "equalTeams");
+    __publicField$e(this, "persist");
+    __publicField$e(this, "blueTeam");
+    __publicField$e(this, "redTeam");
+    this.enable = false;
+    this.topX = 5;
+    this.equalTeams = true;
+    this.persist = false;
+    this.blueTeam = new Giants(0 /* BLUE */);
+    this.redTeam = new Giants(1 /* RED */);
+  }
+  ToBase64() {
+    return Base64.encode(JSON.stringify(this));
+  }
+  FromBase64(base64) {
+    if (base64.length === 0) {
+      return;
     }
-    this.users = this.users.sort((a, b) => b.oldRating - a.oldRating);
-    const s = Math.min(this.users.length, Math.floor(4 * Math.round(Math.sqrt(this.users.length))));
-    let sumS = 0;
-    for (let i = 0; i < s; i++) {
-      sumS += this.users[i].delta;
+    if (Base64.isValid(base64) === false) {
+      return;
     }
-    inc = Math.min(Math.max(Math.floor(-sumS / s), -10), 0);
-    this.users.forEach((u) => {
-      u.delta += inc;
-      u.UpdateRating(u.oldRating + u.delta);
-    });
-    this.users = this.users.sort((a, b) => a.rank - b.rank);
+    const j = JSON.parse(Base64.decode(base64));
+    this.enable = j.enable;
+    this.topX = j.topX;
+    this.equalTeams = j.equalTeams;
+    this.persist = j.persist;
+    this.blueTeam = new Giants(0 /* BLUE */);
+    this.blueTeam.name = j.blueTeam.name;
+    this.blueTeam.setFilterOrganizations(j.blueTeam.filterOrganizations);
+    this.blueTeam.setFilterTeams(j.blueTeam.filterTeams);
+    this.redTeam = new Giants(1 /* RED */);
+    this.redTeam.name = j.redTeam.name;
+    this.redTeam.setFilterOrganizations(j.redTeam.filterOrganizations);
+    this.redTeam.setFilterTeams(j.redTeam.filterTeams);
   }
 }
 
-var RatingLevel = /* @__PURE__ */ ((RatingLevel2) => {
-  RatingLevel2["NEWBIE"] = "NEWBIE";
-  RatingLevel2["PUPIL"] = "PUPIL";
-  RatingLevel2["SPECIALIST"] = "SPECIALIST";
-  RatingLevel2["EXPERT"] = "EXPERT";
-  RatingLevel2["CANDIDATE_MASTER"] = "CANDIDATE_MASTER";
-  RatingLevel2["MASTER"] = "MASTER";
-  RatingLevel2["INTERNATIONAL_MASTER"] = "INTERNATIONAL_MASTER";
-  RatingLevel2["GRANDMASTER"] = "GRANDMASTER";
-  RatingLevel2["INTERNATIONAL_GRANDMASTER"] = "INTERNATIONAL_GRANDMASTER";
-  RatingLevel2["LEGENDARY_GRANDMASTER"] = "LEGENDARY_GRANDMASTER";
-  return RatingLevel2;
-})(RatingLevel || {});
-const RatingLevelToString = {
-  ["NEWBIE" /* NEWBIE */]: "Newbie",
-  ["PUPIL" /* PUPIL */]: "Pupil",
-  ["SPECIALIST" /* SPECIALIST */]: "Specialist",
-  ["EXPERT" /* EXPERT */]: "Expert",
-  ["CANDIDATE_MASTER" /* CANDIDATE_MASTER */]: "Candidate Master",
-  ["MASTER" /* MASTER */]: "Master",
-  ["INTERNATIONAL_MASTER" /* INTERNATIONAL_MASTER */]: "International Master",
-  ["GRANDMASTER" /* GRANDMASTER */]: "Grandmaster",
-  ["INTERNATIONAL_GRANDMASTER" /* INTERNATIONAL_GRANDMASTER */]: "International Grandmaster",
-  ["LEGENDARY_GRANDMASTER" /* LEGENDARY_GRANDMASTER */]: "Legendary Grandmaster"
+var __defProp$d = Object.defineProperty;
+var __defNormalProp$d = (obj, key, value) => key in obj ? __defProp$d(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$d = (obj, key, value) => {
+  __defNormalProp$d(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
 };
-class RatingUtility {
-  static getRatingLevel(rating) {
-    if (rating >= 3e3) {
-      return "LEGENDARY_GRANDMASTER" /* LEGENDARY_GRANDMASTER */;
-    } else if (rating >= 2600) {
-      return "INTERNATIONAL_GRANDMASTER" /* INTERNATIONAL_GRANDMASTER */;
-    } else if (rating >= 2400) {
-      return "GRANDMASTER" /* GRANDMASTER */;
-    } else if (rating >= 2300) {
-      return "INTERNATIONAL_MASTER" /* INTERNATIONAL_MASTER */;
-    } else if (rating >= 2100) {
-      return "MASTER" /* MASTER */;
-    } else if (rating >= 1900) {
-      return "CANDIDATE_MASTER" /* CANDIDATE_MASTER */;
-    } else if (rating >= 1600) {
-      return "EXPERT" /* EXPERT */;
-    } else if (rating >= 1400) {
-      return "SPECIALIST" /* SPECIALIST */;
-    } else if (rating >= 1200) {
-      return "PUPIL" /* PUPIL */;
-    }
-    return "NEWBIE" /* NEWBIE */;
+class ContestOptions {
+  constructor() {
+    __publicField$d(this, "calculationOfPenalty");
+    __publicField$d(this, "submissionTimestampUnit");
+    __publicField$d(this, "submissionHasTimeField");
+    __publicField$d(this, "submissionHasLanguageField");
+    __publicField$d(this, "submissionEnableActionField");
+    this.calculationOfPenalty = "in_minutes";
+    this.submissionTimestampUnit = "second";
+    this.submissionHasTimeField = false;
+    this.submissionHasLanguageField = false;
+    this.submissionEnableActionField = false;
   }
-  static getRatingLevelClass(ratingLevel) {
-    if (typeof ratingLevel === "number") {
-      return this.getRatingLevelClass(this.getRatingLevel(ratingLevel));
-    }
-    switch (ratingLevel) {
-      case "NEWBIE" /* NEWBIE */:
-        return "user-gray";
-      case "PUPIL" /* PUPIL */:
-        return "user-green";
-      case "SPECIALIST" /* SPECIALIST */:
-        return "user-cyan";
-      case "EXPERT" /* EXPERT */:
-        return "user-blue";
-      case "CANDIDATE_MASTER" /* CANDIDATE_MASTER */:
-        return "user-violet";
-      case "MASTER" /* MASTER */:
-        return "user-orange";
-      case "INTERNATIONAL_MASTER" /* INTERNATIONAL_MASTER */:
-        return "user-orange";
-      case "GRANDMASTER" /* GRANDMASTER */:
-        return "user-red";
-      case "INTERNATIONAL_GRANDMASTER" /* INTERNATIONAL_GRANDMASTER */:
-        return "user-red";
-      case "LEGENDARY_GRANDMASTER" /* LEGENDARY_GRANDMASTER */:
-        return "user-legendary";
-    }
+}
+function createContestOptions(contestOptionsJSON = {}) {
+  const j = contestOptionsJSON;
+  const o = new ContestOptions();
+  if (j.calculation_of_penalty) {
+    o.calculationOfPenalty = j.calculation_of_penalty;
+  }
+  if (j.submission_timestamp_unit) {
+    o.submissionTimestampUnit = j.submission_timestamp_unit;
+  }
+  if (j.submission_has_reaction) {
+    o.submissionEnableActionField = j.submission_has_reaction;
   }
+  return o;
 }
 
-class Rating {
+var __defProp$c = Object.defineProperty;
+var __defNormalProp$c = (obj, key, value) => key in obj ? __defProp$c(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$c = (obj, key, value) => {
+  __defNormalProp$c(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class Group {
   constructor() {
-    this.id = "";
-    this.name = "";
-    this.baseRating = 1500;
-    this.contestIDs = [];
-    this.users = [];
-    this.ranks = [];
-    this.userMap = /* @__PURE__ */ new Map();
-  }
-  buildRating() {
-    for (const rank of this.ranks) {
-      rank.buildRank();
-      const ratingCalculator = new RatingCalculator();
-      for (const t of rank.teams) {
-        const id = this.generateTeamId(t);
-        let u = null;
-        if (!this.userMap.has(id)) {
-          u = new RatingUser();
-          u.id = id;
-          u.name = t.name;
-          u.organization = t.organization;
-          u.members = createPersons(t.members ?? []);
-          u.coaches = createPersons(t.coach ?? []);
-          u.rank = t.rank;
-          u.oldRating = this.baseRating;
-          u.UpdateRating(this.baseRating);
-          this.userMap.set(id, u);
-          this.users.push(u);
-          ratingCalculator.users.push(u);
-        } else {
-          u = this.userMap.get(id);
-          u.rank = t.rank;
-          u.oldRating = u.rating;
-          ratingCalculator.users.push(u);
-        }
-        {
-          const h = new RatingHistory();
-          h.rank = t.rank;
-          h.rating = u.rating;
-          h.teamName = t.name;
-          h.organization = t.organization;
-          h.members = createPersons(t.members ?? []);
-          h.coaches = createPersons(t.coach ?? []);
-          h.contestID = rank.contest.id;
-          h.contestLink = h.contestID;
-          h.contestName = rank.contest.name;
-          h.contestTime = rank.contest.startTime;
-          u.ratingHistories.push(h);
-        }
-      }
-      ratingCalculator.calculate();
-      for (const u of ratingCalculator.users) {
-        u.ratingHistories.at(-1).rating = u.rating;
-      }
-    }
-  }
-  generateTeamId(t) {
-    const persons = createPersons(t.members ?? []);
-    if (persons.length > 0) {
-      return persons.map((person) => person.name.trim()).sort().join("|");
-    }
-    return `${t.organization}-${t.name}`;
-  }
-  toJSON() {
-    return {
-      id: this.id,
-      name: this.name,
-      baseRating: this.baseRating,
-      contestIDs: this.contestIDs,
-      users: this.users.map((ratingUser) => ratingUser.toJSON())
-    };
-  }
-  static fromJSON(iRating) {
-    if (typeof iRating === "string") {
-      iRating = JSON.parse(iRating);
-    }
-    const rating = new Rating();
-    rating.id = iRating.id;
-    rating.name = iRating.name;
-    rating.baseRating = iRating.baseRating;
-    rating.contestIDs = iRating.contestIDs;
-    for (const iUser of iRating.users) {
-      rating.users.push(RatingUser.fromJSON(iUser));
-    }
-    return rating;
+    __publicField$c(this, "names");
+    __publicField$c(this, "defaultLang");
+    __publicField$c(this, "isDefault");
+    this.names = /* @__PURE__ */ new Map();
+    this.defaultLang = "zh-CN";
+    this.isDefault = false;
   }
 }
 
-class ProblemStatistics {
-  constructor() {
-    this.acceptedNum = 0;
-    this.rejectedNum = 0;
-    this.pendingNum = 0;
-    this.submittedNum = 0;
-    this.attemptedNum = 0;
-    this.ignoreNum = 0;
-    this.se = 0;
-    this.firstSolveSubmissions = [];
-    this.lastSolveSubmissions = [];
-  }
-  reset() {
-    this.acceptedNum = 0;
-    this.rejectedNum = 0;
-    this.pendingNum = 0;
-    this.submittedNum = 0;
-    this.attemptedNum = 0;
-    this.ignoreNum = 0;
-    this.se = 0;
-    this.firstSolveSubmissions = [];
-    this.lastSolveSubmissions = [];
-  }
-  get dirt() {
-    if (this.acceptedNum === 0) {
-      return 0;
-    }
-    return calcDirt(this.attemptedNum, this.acceptedNum);
-  }
-  calcSE(totalTeams) {
-    const res = (totalTeams - this.acceptedNum) / totalTeams;
-    this.se = Math.round(res * 100) / 100;
-    return this.se;
-  }
-}
-class Problem {
+var __defProp$b = Object.defineProperty;
+var __defNormalProp$b = (obj, key, value) => key in obj ? __defProp$b(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$b = (obj, key, value) => {
+  __defNormalProp$b(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class Contest {
   constructor() {
-    this.id = "";
-    this.label = "";
-    this.name = "";
-    this.statistics = new ProblemStatistics();
-    this.balloonColor = {
-      background_color: "#a0f0a0",
-      color: "#000"
+    __publicField$b(this, "id", "");
+    __publicField$b(this, "name", "");
+    __publicField$b(this, "startTime");
+    __publicField$b(this, "endTime");
+    __publicField$b(this, "freezeTime");
+    __publicField$b(this, "replayStartTime");
+    __publicField$b(this, "replayEndTime");
+    __publicField$b(this, "replayFreezeTime");
+    __publicField$b(this, "replayNowTime");
+    __publicField$b(this, "replayContestStartTimestamp");
+    __publicField$b(this, "totalDurationTimestamp");
+    __publicField$b(this, "freezeDurationTimestamp");
+    __publicField$b(this, "unFreezeDurationTimestamp");
+    __publicField$b(this, "penalty");
+    __publicField$b(this, "problems");
+    __publicField$b(this, "problemsMap");
+    __publicField$b(this, "statusTimeDisplay");
+    __publicField$b(this, "badge");
+    __publicField$b(this, "medal");
+    __publicField$b(this, "awards");
+    __publicField$b(this, "organization");
+    __publicField$b(this, "group");
+    __publicField$b(this, "tag");
+    __publicField$b(this, "logo");
+    __publicField$b(this, "banner");
+    __publicField$b(this, "bannerMode");
+    __publicField$b(this, "boardLink");
+    __publicField$b(this, "options");
+    this.startTime = createDayJS();
+    this.endTime = createDayJS();
+    this.freezeTime = createDayJS();
+    this.totalDurationTimestamp = 0;
+    this.freezeDurationTimestamp = 0;
+    this.unFreezeDurationTimestamp = 0;
+    this.penalty = 20 * 60;
+    this.problems = [];
+    this.problemsMap = /* @__PURE__ */ new Map();
+    this.statusTimeDisplay = {
+      correct: true,
+      incorrect: true,
+      pending: true
     };
+    this.group = /* @__PURE__ */ new Map();
+    this.tag = /* @__PURE__ */ new Map();
+    this.options = new ContestOptions();
   }
-}
-function createProblem(problemJSON) {
-  const p = new Problem();
-  p.id = String(problemJSON.id);
-  p.label = problemJSON.label;
-  p.name = problemJSON.name ?? "";
-  p.timeLimit = problemJSON.time_limit;
-  p.memoryLimit = problemJSON.memory_limit;
-  if (problemJSON.balloon_color) {
-    p.balloonColor = _.cloneDeep(problemJSON.balloon_color);
+  getStartTime() {
+    return this.replayStartTime ?? this.startTime;
   }
-  p.balloonColor.color = getWhiteOrBlackColor(p.balloonColor.background_color);
-  return p;
-}
-function createProblems(problemsJSON) {
-  return problemsJSON.map((pJSON) => createProblem(pJSON));
-}
-function createProblemsByProblemIds(problemIds, balloonColors) {
-  const problems = problemIds.map((label, index) => {
-    const p = new Problem();
-    p.id = String(index);
-    p.label = label;
-    return p;
-  });
-  if (balloonColors !== void 0 && balloonColors !== null) {
-    for (const index in balloonColors) {
-      problems[index].balloonColor = _.cloneDeep(balloonColors[index]);
-    }
+  getEndTime() {
+    return this.replayEndTime ?? this.endTime;
   }
-  problems.forEach((p) => {
-    p.balloonColor.color = getWhiteOrBlackColor(p.balloonColor.background_color);
-  });
-  return problems;
-}
-class TeamProblemStatistics {
-  constructor(options) {
-    this.isFirstSolved = options?.teamProblemStatistics?.isFirstSolved ?? false;
-    this.isSolved = options?.teamProblemStatistics?.isSolved ?? false;
-    this.solvedTimestamp = options?.teamProblemStatistics?.solvedTimestamp ?? 0;
-    this.isSubmitted = options?.teamProblemStatistics?.isSubmitted ?? false;
-    this.lastSubmitTimestamp = options?.teamProblemStatistics?.lastSubmitTimestamp ?? 0;
-    this.failedCount = options?.teamProblemStatistics?.failedCount ?? 0;
-    this.pendingCount = options?.teamProblemStatistics?.pendingCount ?? 0;
-    this.ignoreCount = options?.teamProblemStatistics?.ignoreCount ?? 0;
-    this.totalCount = options?.teamProblemStatistics?.totalCount ?? 0;
-    this.submissions = options?.teamProblemStatistics?.submissions ?? [];
-    this.problem = options?.teamProblemStatistics?.problem ?? new Problem();
-    this.contestPenalty = options?.teamProblemStatistics?.contestPenalty ?? 20 * 60;
+  getFreezeTime() {
+    return this.replayFreezeTime ?? this.freezeTime;
   }
-  get isAccepted() {
-    return this.isSolved;
+  getContestDuration(timeFormat = "HH:mm:ss") {
+    return dayjs.duration(this.getEndTime().diff(this.getStartTime())).format(timeFormat);
   }
-  get isWrongAnswer() {
-    return !this.isSolved && this.pendingCount === 0 && this.failedCount > 0;
+  getContestState(nowTime) {
+    const now = createDayJS(nowTime);
+    if (now.isBefore(this.getStartTime())) {
+      return ContestState.PENDING;
+    }
+    if (now.isSameOrAfter(this.getEndTime())) {
+      return ContestState.FINISHED;
+    }
+    if (now.isSameOrAfter(this.getFreezeTime())) {
+      return ContestState.FROZEN;
+    }
+    return ContestState.RUNNING;
   }
-  get isPending() {
-    return !this.isSolved && this.pendingCount > 0;
+  getContestPendingTime(nowTime) {
+    let baseTime = createDayJS(nowTime);
+    if (baseTime.isAfter(this.getStartTime())) {
+      baseTime = this.getStartTime();
+    }
+    return getTimeDiff(Math.floor(dayjs.duration(this.getStartTime().diff(baseTime)).asSeconds()));
   }
-  get isUnSubmitted() {
-    return this.totalCount === 0;
+  getContestElapsedTime(nowTime) {
+    let baseTime = createDayJS(nowTime);
+    if (baseTime.isAfter(this.getEndTime())) {
+      baseTime = this.getEndTime();
+    }
+    if (baseTime.isBefore(this.getStartTime())) {
+      baseTime = this.getStartTime();
+    }
+    return getTimeDiff(Math.floor(dayjs.duration(baseTime.diff(this.getStartTime())).asSeconds()));
   }
-  get solvedTimestampToMinute() {
-    return Math.floor(this.solvedTimestamp / 60);
+  getContestRemainingTime(nowTime) {
+    let baseTime = createDayJS(nowTime);
+    if (baseTime.isAfter(this.getEndTime())) {
+      baseTime = this.getEndTime();
+    }
+    if (baseTime.isBefore(this.getStartTime())) {
+      baseTime = this.getStartTime();
+    }
+    return getTimeDiff(Math.floor(dayjs.duration(this.getEndTime().diff(baseTime)).asSeconds()));
   }
-  get penalty() {
-    if (this.isSolved === false) {
+  getContestProgressRatio(nowTime) {
+    const baseTime = createDayJS(nowTime);
+    if (this.getStartTime().isSameOrAfter(baseTime)) {
       return 0;
     }
-    return this.solvedTimestampToMinute * 60 + this.failedCount * this.contestPenalty;
+    if (this.getEndTime().isSameOrBefore(baseTime)) {
+      return 100;
+    }
+    const total = this.getEndTime().diff(this.getStartTime(), "s");
+    const pass = baseTime.diff(this.getStartTime(), "s");
+    return Math.round(pass * 100 / total);
   }
-  get penaltyToMinute() {
-    return Math.floor(this.penalty / 60);
+  isEnableAwards(group) {
+    if (!this.awards) {
+      return false;
+    }
+    if (!this.awards.has(group)) {
+      return false;
+    }
+    return true;
   }
-  get penaltyInSecond() {
-    if (this.isSolved === false) {
-      return 0;
+  resetReplayTime() {
+    this.replayStartTime = void 0;
+    this.replayEndTime = void 0;
+    this.replayFreezeTime = void 0;
+    this.replayNowTime = void 0;
+    this.replayContestStartTimestamp = void 0;
+  }
+  setReplayTime(replayStartTimestamp) {
+    if (replayStartTimestamp === 0) {
+      this.resetReplayTime();
+      return;
     }
-    return this.solvedTimestamp + this.failedCount * this.contestPenalty;
+    const replayStartTime = createDayJS(replayStartTimestamp);
+    const diff = replayStartTime.diff(this.startTime, "s");
+    this.replayStartTime = this.startTime.add(diff, "s");
+    this.replayEndTime = this.endTime.add(diff, "s");
+    this.replayFreezeTime = this.freezeTime.add(diff, "s");
+    this.replayNowTime = createDayJS();
+    this.replayContestStartTimestamp = this.replayNowTime.diff(this.replayStartTime, "s");
   }
 }
-
-class PlaceChartPointData {
-  constructor() {
-    this.timePoint = 0;
-    this.rank = 0;
-    this.lastSolvedProblem = null;
-  }
-}
-class Team {
-  constructor() {
-    this.id = "";
-    this.name = "";
-    this.organization = "";
-    this.group = [];
-    this.tag = [];
-    this.rank = 0;
-    this.originalRank = 0;
-    this.organizationRank = -1;
-    this.solvedProblemNum = 0;
-    this.attemptedProblemNum = 0;
-    this.lastSolvedProblem = null;
-    this.lastSolvedProblemStatistics = null;
-    this.penalty = 0;
-    this.problemStatistics = [];
-    this.problemStatisticsMap = /* @__PURE__ */ new Map();
-    this.submissions = [];
-    this.placeChartPoints = [];
-    this.awards = [];
-    this.se = 0;
-  }
-  reset() {
-    this.rank = 0;
-    this.originalRank = 0;
-    this.organizationRank = -1;
-    this.solvedProblemNum = 0;
-    this.attemptedProblemNum = 0;
-    this.lastSolvedProblem = null;
-    this.lastSolvedProblemStatistics = null;
-    this.penalty = 0;
-    this.problemStatistics = [];
-    this.problemStatisticsMap = /* @__PURE__ */ new Map();
-    this.submissions = [];
-    this.placeChartPoints = [];
-    this.awards = [];
-    this.se = 0;
-  }
-  get penaltyToMinute() {
-    return Math.floor(this.penalty / 60);
-  }
-  get isUnofficial() {
-    return this.group.includes("unofficial");
-  }
-  get isGirl() {
-    return this.group.includes("girl");
-  }
-  get membersToArray() {
-    if (Array.isArray(this.members)) {
-      return this.members;
-    }
-    if (typeof this.members === "string") {
-      if (this.members.includes(", ")) {
-        return this.members.split(", ");
-      }
-      if (this.members.includes("\u3001")) {
-        return this.members.split("\u3001");
-      }
-    }
-    return [];
-  }
-  get membersToString() {
-    if (typeof this.members === "string") {
-      return this.members;
-    }
-    return this.members?.join(", ");
-  }
-  get isEffectiveTeam() {
-    return this.solvedProblemNum > 0;
-  }
-  get dirt() {
-    const attemptedNum = this.attemptedProblemNum;
-    const solvedNum = this.solvedProblemNum;
-    return calcDirt(attemptedNum, solvedNum);
-  }
-  calcSE(totalTeams) {
-    let acceptedProblemNums = 0;
-    let total = 0;
-    this.problemStatistics.forEach((p) => {
-      if (p.isSolved) {
-        acceptedProblemNums += 1;
-        total += p.problem.statistics.acceptedNum;
-      }
-    });
-    if (totalTeams === 0 || acceptedProblemNums === 0) {
-      return 0;
-    }
-    const res = (acceptedProblemNums * totalTeams - total) / totalTeams / acceptedProblemNums;
-    this.se = Math.round(res * 100) / 100;
-    return this.se;
-  }
-  calcSolvedData(options) {
-    this.solvedProblemNum = 0;
-    this.attemptedProblemNum = 0;
-    this.penalty = 0;
-    for (const p of this.problemStatistics) {
-      if (p.isAccepted) {
-        this.solvedProblemNum++;
-        this.attemptedProblemNum += p.failedCount + 1;
-        if (options?.calculationOfPenalty === "in_seconds" || options?.calculationOfPenalty === "accumulate_in_seconds_and_finally_to_the_minute") {
-          this.penalty += p.penaltyInSecond;
-        } else {
-          this.penalty += p.penalty;
-        }
-      }
+function createContest(contestJSON) {
+  const c = new Contest();
+  c.name = contestJSON.contest_name;
+  c.startTime = createDayJS(contestJSON.start_time);
+  c.endTime = createDayJS(contestJSON.end_time);
+  c.totalDurationTimestamp = c.endTime.unix() - c.startTime.unix();
+  {
+    c.freezeTime = c.endTime;
+    c.freezeDurationTimestamp = 0;
+    if (contestJSON.frozen_time !== void 0 && contestJSON.frozen_time != null) {
+      const frozenTime = Number(contestJSON.frozen_time);
+      c.freezeTime = createDayJS(c.endTime.unix() - frozenTime);
+      c.freezeDurationTimestamp = frozenTime;
     }
-    if (options?.calculationOfPenalty === "accumulate_in_seconds_and_finally_to_the_minute") {
-      this.penalty = Math.floor(this.penalty / 60) * 60;
+    if (contestJSON.freeze_time !== void 0 && contestJSON.freeze_time !== null) {
+      c.freezeTime = createDayJS(contestJSON.freeze_time);
+      c.freezeDurationTimestamp = c.endTime.unix() - c.freezeTime.unix();
     }
+    c.unFreezeDurationTimestamp = c.totalDurationTimestamp - c.freezeDurationTimestamp;
   }
-  calcAwards(awards) {
-    if (!awards) {
-      return;
+  c.penalty = contestJSON.penalty;
+  {
+    if (contestJSON.problem_id !== void 0 && contestJSON.problem_id !== null) {
+      c.problems = createProblemsByProblemIds(contestJSON.problem_id, contestJSON.balloon_color);
     }
-    for (const award of awards) {
-      if (this.rank >= award.minRank && this.rank <= award.maxRank) {
-        this.awards.push(award.medalType);
-      }
+    if (contestJSON.problems !== void 0 && contestJSON.problems !== null) {
+      c.problems = createProblems(contestJSON.problems);
     }
+    c.problemsMap = new Map(c.problems.map((p) => [p.id, p]));
   }
-  isEqualRank(otherTeam) {
-    return this.solvedProblemNum === otherTeam.solvedProblemNum && this.penalty === otherTeam.penalty;
+  if (contestJSON.status_time_display !== void 0 && contestJSON.status_time_display !== null) {
+    c.statusTimeDisplay = {
+      correct: Boolean(contestJSON.status_time_display.correct ?? false),
+      incorrect: Boolean(contestJSON.status_time_display.incorrect ?? false),
+      pending: Boolean(contestJSON.status_time_display.pending ?? false)
+    };
   }
-  postProcessPlaceChartPoints() {
-    if (this.placeChartPoints.length === 0) {
+  c.badge = contestJSON.badge;
+  c.medal = contestJSON.medal;
+  (() => {
+    if (contestJSON.medal === void 0 || contestJSON.medal === null) {
       return;
     }
-    const res = [];
-    res.push(this.placeChartPoints[0]);
-    for (let i = 1; i < this.placeChartPoints.length - 1; i++) {
-      const p = this.placeChartPoints[i];
-      const preP = res[res.length - 1];
-      if (p.rank !== preP.rank || p.lastSolvedProblem !== preP.lastSolvedProblem) {
-        res.push(p);
+    c.awards = /* @__PURE__ */ new Map();
+    if (typeof contestJSON.medal === "string") ; else {
+      for (const k in contestJSON.medal) {
+        const v = contestJSON.medal[k];
+        {
+          const award = [];
+          let rank = 1;
+          const work = (key, medalType) => {
+            if (Object.keys(v).includes(key)) {
+              const a = new Award();
+              a.medalType = medalType;
+              a.minRank = rank;
+              rank += Number(v[key]);
+              a.maxRank = rank - 1;
+              award.push(a);
+            }
+          };
+          work("gold", MedalType.GOLD);
+          work("silver", MedalType.SILVER);
+          work("bronze", MedalType.BRONZE);
+          {
+            const a = new Award();
+            a.medalType = MedalType.HONORABLE;
+            a.minRank = rank;
+            a.maxRank = 1061109567;
+            award.push(a);
+          }
+          c.awards.set(k, award);
+        }
       }
     }
-    if (this.placeChartPoints.length > 1) {
-      res.push(this.placeChartPoints[this.placeChartPoints.length - 1]);
-    }
-    this.placeChartPoints = res;
+  })();
+  c.organization = contestJSON.organization;
+  {
+    const g = new Group();
+    g.names.set("en", "All");
+    g.names.set("zh-CN", "\u6240\u6709\u961F\u4F0D");
+    g.isDefault = true;
+    c.group.set("all", g);
   }
-  static compare(lhs, rhs) {
-    if (lhs.solvedProblemNum !== rhs.solvedProblemNum) {
-      return rhs.solvedProblemNum - lhs.solvedProblemNum;
-    }
-    if (lhs.penalty !== rhs.penalty) {
-      return lhs.penalty - rhs.penalty;
+  for (const [k, v] of Object.entries(contestJSON?.group ?? {})) {
+    let key = k;
+    const g = new Group();
+    g.names.set("zh-CN", v);
+    if (k === "official") {
+      g.names.set("en", "Official");
     }
-    if (lhs.lastSolvedProblemStatistics && rhs.lastSolvedProblemStatistics) {
-      return lhs.lastSolvedProblemStatistics.solvedTimestampToMinute - rhs.lastSolvedProblemStatistics.solvedTimestampToMinute;
+    if (k === "unofficial") {
+      g.names.set("en", "Unofficial");
     }
-    if (lhs.name < rhs.name) {
-      return -1;
-    } else if (lhs.name > rhs.name) {
-      return 1;
+    if (k === "girl" || k === "girls") {
+      g.names.set("en", "Girls");
+      key = "girl";
     }
-    return 0;
+    c.group.set(key, g);
   }
-}
-function createTeam(teamJSON) {
-  const t = new Team();
-  t.id = teamJSON.id ?? teamJSON.team_id ?? "";
-  t.name = teamJSON.name ?? teamJSON.team_name ?? "";
-  t.organization = teamJSON.organization ?? "";
-  t.badge = teamJSON.badge;
-  t.group = _.cloneDeep(teamJSON.group ?? []);
-  t.tag = _.cloneDeep(teamJSON.tag ?? []);
-  t.coach = teamJSON.coach;
-  t.members = teamJSON.members;
-  if (Boolean(teamJSON.official) === true) {
-    t.group.push("official");
+  c.banner = contestJSON.banner;
+  if (c.banner) {
+    c.bannerMode = contestJSON.banner_mode ?? "ALL";
   }
-  if (Boolean(teamJSON.unofficial) === true) {
-    t.group.push("unofficial");
-  }
-  if (Boolean(teamJSON.girl) === true) {
-    t.group.push("girl");
-  }
-  {
-    const tt = teamJSON;
-    for (const key of Object.keys(tt)) {
-      if (tt[key] === 1 || tt[key] === true) {
-        t.group.push(key);
-      }
-    }
-  }
-  t.group = [...new Set(t.group)];
-  t.group.sort();
-  if (teamJSON.location) {
-    t.location = teamJSON.location;
-  }
-  if (teamJSON.icpc_id) {
-    t.icpcID = teamJSON.icpc_id;
-  }
-  return t;
-}
-function createTeams(teamsJSON) {
-  if (Array.isArray(teamsJSON)) {
-    return teamsJSON.map((t) => createTeam(t));
-  } else {
-    const teams = Object.entries(teamsJSON).map(
-      ([teamId, team]) => createTeam({ ...team, team_id: team.team_id ?? teamId })
-    );
-    return teams;
+  c.logo = contestJSON.logo;
+  c.boardLink = contestJSON.board_link;
+  if (contestJSON.options) {
+    c.options = createContestOptions(contestJSON.options);
   }
+  return c;
 }
 
-class Submission {
+var __defProp$a = Object.defineProperty;
+var __defNormalProp$a = (obj, key, value) => key in obj ? __defProp$a(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$a = (obj, key, value) => {
+  __defNormalProp$a(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class ContestIndexConfig {
   constructor() {
-    this.status = SubmissionStatus.UNKNOWN;
-    this.isIgnore = false;
-    this.isSolved = false;
-    this.isFirstSolved = false;
-    this.id = "";
-    this.teamId = "";
-    this.problemId = "";
-    this.timestamp = 0;
-    this.timestampUnit = "second";
-  }
-  isAccepted() {
-    return isAccepted(this.status);
-  }
-  isRejected() {
-    return isRejected(this.status);
-  }
-  isPending() {
-    return isPending(this.status);
+    __publicField$a(this, "contestName");
+    __publicField$a(this, "startTime");
+    __publicField$a(this, "endTime");
+    __publicField$a(this, "freezeTime");
+    __publicField$a(this, "totalDurationTimestamp");
+    __publicField$a(this, "freezeDurationTimestamp");
+    __publicField$a(this, "unFreezeDurationTimestamp");
+    __publicField$a(this, "logo");
+    this.contestName = "";
+    this.startTime = createDayJS();
+    this.endTime = createDayJS();
+    this.freezeTime = createDayJS();
+    this.totalDurationTimestamp = 0;
+    this.freezeDurationTimestamp = 0;
+    this.unFreezeDurationTimestamp = 0;
   }
-  isNotCalculatedPenaltyStatus() {
-    return isNotCalculatedPenaltyStatus(this.status);
+}
+class ContestIndex {
+  constructor() {
+    __publicField$a(this, "contest");
+    __publicField$a(this, "boardLink");
+    this.contest = new Contest();
+    this.boardLink = "";
   }
-  get timestampToMinute() {
-    if (this.timestampUnit === "nanosecond") {
-      return Math.floor(this.timestamp / 60 / 1e3 / 1e3 / 1e3);
+}
+function createContestIndex(contestIndexJSON) {
+  const c = new ContestIndex();
+  const cjc = contestIndexJSON.config;
+  c.contest = createContest(cjc);
+  c.boardLink = contestIndexJSON.board_link;
+  return c;
+}
+function createContestIndexList(contestListJSON) {
+  const contestIndexList = [];
+  const dfs = (contestList) => {
+    if (Object.prototype.hasOwnProperty.call(contestList, "config")) {
+      contestIndexList.push(createContestIndex(contestList));
+    } else {
+      for (const k in contestList) {
+        dfs(contestList[k]);
+      }
     }
-    if (this.timestampUnit === "microsecond") {
-      return Math.floor(this.timestamp / 60 / 1e3 / 1e3);
+  };
+  dfs(contestListJSON);
+  contestIndexList.sort((a, b) => {
+    if (a.contest.startTime.isBefore(b.contest.startTime)) {
+      return 1;
     }
-    if (this.timestampUnit === "millisecond") {
-      return Math.floor(this.timestamp / 60 / 1e3);
+    if (a.contest.startTime.isAfter(b.contest.startTime)) {
+      return -1;
     }
-    return Math.floor(this.timestamp / 60);
-  }
-  get timestampToSecond() {
-    if (this.timestampUnit === "nanosecond") {
-      return Math.floor(this.timestamp / 1e3 / 1e3 / 1e3);
+    if (a.contest.endTime.isBefore(b.contest.endTime)) {
+      return 1;
     }
-    if (this.timestampUnit === "microsecond") {
-      return Math.floor(this.timestamp / 1e3 / 1e3);
+    if (a.contest.endTime.isAfter(b.contest.endTime)) {
+      return -1;
     }
-    if (this.timestampUnit === "millisecond") {
-      return Math.floor(this.timestamp / 1e3);
+    if (a.contest.name < b.contest.name) {
+      return 1;
     }
-    return this.timestamp;
-  }
-  get timestampDisplayFormatWithSecond() {
-    const second = this.timestampToSecond;
-    const h = Math.floor(second / 3600);
-    const m = Math.floor(second % 3600 / 60);
-    const s = second % 60;
-    const f = (x) => x.toString().padStart(2, "0");
-    const res = `${f(h)}:${f(m)}:${f(s)}`;
-    return res;
-  }
-  get timestampDisplayFormatWithMilliSecond() {
-    let res = this.timestampDisplayFormatWithSecond;
-    if (this.timestampUnit === "millisecond") {
-      const fl = (this.timestamp % 1e3).toString().padStart(3, "0");
-      res += `.${fl}`;
+    if (a.contest.name > b.contest.name) {
+      return -1;
     }
-    return res;
+    return 0;
+  });
+  return contestIndexList;
+}
+
+class CodeforcesGymGhostDATConverter {
+  constructor() {
   }
-  static compare(lhs, rhs) {
-    if (lhs.timestamp !== rhs.timestamp) {
-      return lhs.timestamp - rhs.timestamp;
+  convert(rank) {
+    let res = "";
+    res += `@contest "${rank.contest.name}"
+@contlen ${Math.floor(dayjs.duration(rank.contest.endTime.diff(rank.contest.startTime)).asMinutes())}
+@problems ${rank.contest.problems.length}
+@teams ${rank.teams.length + 100}
+@submissions ${rank.submissions.length}
+`;
+    rank.contest.problems.forEach((p) => {
+      res += `@p ${p.label},${p.label},20,0
+`;
+    });
+    let teamIndex = 1;
+    const teamIdMap = /* @__PURE__ */ new Map();
+    const submissionsIdMap = /* @__PURE__ */ new Map();
+    rank.teams.forEach((team) => {
+      let name = team.name;
+      if (team.organization) {
+        name = `${team.organization} - ${name}`;
+      }
+      if (team.members) {
+        name = `${name} - ${team.membersToString}`;
+      }
+      res += `@t ${teamIndex},0,1,"${name}"
+`;
+      teamIdMap.set(team.id, teamIndex);
+      teamIndex++;
+      {
+        const mp = /* @__PURE__ */ new Map();
+        rank.contest.problems.forEach((p) => {
+          mp.set(p.id, 0);
+        });
+        submissionsIdMap.set(team.id, mp);
+      }
+    });
+    for (let i = 0; i < 100; i++) {
+      res += `@t ${teamIndex},0,1,"\u041F\u043E\u043F\u043E\u043B\u043D\u0438\u0442\u044C \u043A\u043E\u043C\u0430\u043D\u0434\u0443"
+`;
+      teamIndex++;
     }
-    if (lhs.teamId === rhs.teamId) {
-      if (lhs.isAccepted() && !rhs.isAccepted()) {
-        return -1;
+    rank.getSubmissions().forEach((submission) => {
+      const teamId = submission.teamId;
+      const problemId = submission.problemId;
+      const problem = rank.contest.problemsMap.get(problemId);
+      const teamIndex2 = teamIdMap.get(teamId);
+      if (!problem) {
+        return;
       }
-      if (!lhs.isAccepted() && rhs.isAccepted()) {
-        return 1;
+      if (!teamIndex2) {
+        return;
       }
+      const status = this.submissionStatusToCodeforcesGymDatStatus(submission.status);
+      submissionsIdMap.get(teamId).set(problemId, submissionsIdMap.get(teamId).get(problemId) + 1);
+      res += `@s ${teamIndex2},${problem.label},${submissionsIdMap.get(teamId)?.get(problemId)},${submission.timestampToSecond},${status}
+`;
+    });
+    return res;
+  }
+  submissionStatusToCodeforcesGymDatStatus(status) {
+    if (isAccepted(status)) {
+      return "OK";
     }
-    if (lhs.id < rhs.id) {
-      return -1;
-    } else if (lhs.id === rhs.id) {
-      return 0;
-    } else {
-      return 1;
+    if (status === SubmissionStatus.WRONG_ANSWER) {
+      return "WA";
+    }
+    if (status === SubmissionStatus.TIME_LIMIT_EXCEEDED) {
+      return "TL";
+    }
+    if (status === SubmissionStatus.MEMORY_LIMIT_EXCEEDED) {
+      return "ML";
+    }
+    if (status === SubmissionStatus.OUTPUT_LIMIT_EXCEEDED) {
+      return "IL";
+    }
+    if (status === SubmissionStatus.PRESENTATION_ERROR) {
+      return "PE";
+    }
+    if (status === SubmissionStatus.RUNTIME_ERROR) {
+      return "RT";
+    }
+    if (status === SubmissionStatus.COMPILATION_ERROR || isNotCalculatedPenaltyStatus(status)) {
+      return "CE";
+    }
+    if (isPending(status)) {
+      return "PD";
     }
+    return "RJ";
   }
 }
-function createSubmission(submissionJSON) {
-  const s = new Submission();
-  s.id = String(submissionJSON.id ?? submissionJSON.submission_id ?? "");
-  s.teamId = String(submissionJSON.team_id);
-  s.problemId = String(submissionJSON.problem_id);
-  s.timestamp = submissionJSON.timestamp;
-  s.status = stringToSubmissionStatus(submissionJSON.status);
-  s.isIgnore = submissionJSON.is_ignore ?? false;
-  if (submissionJSON.time) {
-    s.time = submissionJSON.time;
+
+class GeneralExcelConverter {
+  constructor() {
   }
-  if (submissionJSON.language) {
-    s.language = submissionJSON.language;
+  convert(oriRank) {
+    const rank = _.cloneDeep(oriRank);
+    rank.options.disableFilterTeamsByGroup();
+    rank.options.disableFilterSubmissionByTimestamp();
+    const workbook = XLSX.utils.book_new();
+    for (const [k, v] of rank.contest.group) {
+      rank.options.setGroup(k);
+      rank.buildRank();
+      const sheet = this.convertToSheet(rank);
+      XLSX.utils.book_append_sheet(workbook, sheet, v.names.get(v.defaultLang));
+    }
+    return workbook;
   }
-  if (submissionJSON.reaction) {
-    s.reaction = submissionJSON.reaction;
-  }
-  return s;
-}
-function createSubmissions(submissionsJSON) {
-  if (Array.isArray(submissionsJSON)) {
-    return submissionsJSON.map((s, index) => createSubmission({ ...s, id: s.submission_id ?? String(index) }));
-  } else {
-    const submissions = Object.entries(submissionsJSON).map(
-      ([submissionId, s]) => createSubmission({ ...s, id: s.submission_id ?? submissionId })
+  convertAndWrite(rank, filename) {
+    return XLSX.writeFile(
+      this.convert(rank),
+      filename,
+      {
+        compression: true
+      }
     );
-    return submissions;
-  }
-}
-
-class Balloon {
-  constructor() {
-    this.problem = new Problem();
-    this.team = new Team();
-    this.submission = new Submission();
-  }
-  get key() {
-    return `balloon-${this.team.id}-${this.problem.id}`;
-  }
-  static compare(lhs, rhs) {
-    return Submission.compare(lhs.submission, rhs.submission);
-  }
-}
-
-var GiantsType = /* @__PURE__ */ ((GiantsType2) => {
-  GiantsType2[GiantsType2["BLUE"] = 0] = "BLUE";
-  GiantsType2[GiantsType2["RED"] = 1] = "RED";
-  return GiantsType2;
-})(GiantsType || {});
-class Giants {
-  constructor(type = 0 /* BLUE */) {
-    this.type = type;
-    this.name = `${type === 0 /* BLUE */ ? "Blue" : "Red"} Team`;
-    this.teams = [];
-    this.filterOrganizations = [];
-    this.filterOrganizationMap = /* @__PURE__ */ new Map();
-    this.filterTeams = [];
-    this.filterTeamMap = /* @__PURE__ */ new Map();
-  }
-  setFilterOrganizations(filterOrganizations) {
-    const m = /* @__PURE__ */ new Map();
-    filterOrganizations.forEach((item) => {
-      m.set(item.value, item);
-    });
-    this.filterOrganizations = filterOrganizations;
-    this.filterOrganizationMap = m;
-  }
-  setFilterTeams(filterTeams) {
-    const m = /* @__PURE__ */ new Map();
-    filterTeams.forEach((item) => {
-      m.set(item.value, item);
-    });
-    this.filterTeams = filterTeams;
-    this.filterTeamMap = m;
-  }
-  refreshName() {
-    if (this.filterOrganizations.length > 0) {
-      this.name = this.filterOrganizations[0].text;
-    } else {
-      this.name = `${this.type === 0 /* BLUE */ ? "Blue" : "Red"} Team`;
-    }
-    return this.name;
-  }
-  get totalSolvedProblemNum() {
-    let total = 0;
-    this.teams.forEach((team) => {
-      total += team.solvedProblemNum;
-    });
-    return total;
-  }
-  get totalPenalty() {
-    let total = 0;
-    this.teams.forEach((team) => {
-      total += team.penaltyToMinute;
-    });
-    return total;
   }
-  get totalPenaltyToString() {
-    const penalty = this.totalPenalty;
-    const two = (a) => {
-      if (a < 10) {
-        return `0${a}`;
+  convertToSheet(rank) {
+    const aoa = this.convertToAoa(rank);
+    const sheet = XLSX.utils.aoa_to_sheet(aoa);
+    const cols = [];
+    const head = aoa[1];
+    for (let j = 0; j < head.length; j++) {
+      let wch = 10;
+      for (let i = 1; i < aoa.length; i++) {
+        wch = Math.max(wch, stringWidth(aoa[i][j]) + 2);
       }
-      return String(a);
-    };
-    const h = Math.floor(penalty / 60);
-    const m = Math.floor(penalty % 60);
-    return [two(h), two(m)].join(":");
-  }
-  toJSON() {
-    return {
-      type: this.type,
-      name: this.name,
-      filterOrganizations: this.filterOrganizations,
-      filterTeams: this.filterTeams
-    };
-  }
-}
-class BattleOfGiants {
-  constructor() {
-    this.enable = false;
-    this.topX = 5;
-    this.equalTeams = true;
-    this.persist = false;
-    this.blueTeam = new Giants(0 /* BLUE */);
-    this.redTeam = new Giants(1 /* RED */);
-  }
-  ToBase64() {
-    return Base64.encode(JSON.stringify(this));
-  }
-  FromBase64(base64) {
-    if (base64.length === 0) {
-      return;
+      cols.push({
+        wch
+      });
     }
-    if (Base64.isValid(base64) === false) {
-      return;
+    sheet["!cols"] = cols;
+    {
+      const mergeRange = { s: { r: 0, c: 0 }, e: { r: 0, c: head.length - 1 } };
+      const merges = [{ s: mergeRange.s, e: mergeRange.e }];
+      sheet["!merges"] = merges;
     }
-    const j = JSON.parse(Base64.decode(base64));
-    this.enable = j.enable;
-    this.topX = j.topX;
-    this.equalTeams = j.equalTeams;
-    this.persist = j.persist;
-    this.blueTeam = new Giants(0 /* BLUE */);
-    this.blueTeam.name = j.blueTeam.name;
-    this.blueTeam.setFilterOrganizations(j.blueTeam.filterOrganizations);
-    this.blueTeam.setFilterTeams(j.blueTeam.filterTeams);
-    this.redTeam = new Giants(1 /* RED */);
-    this.redTeam.name = j.redTeam.name;
-    this.redTeam.setFilterOrganizations(j.redTeam.filterOrganizations);
-    this.redTeam.setFilterTeams(j.redTeam.filterTeams);
-  }
-}
-
-class Group {
-  constructor() {
-    this.names = /* @__PURE__ */ new Map();
-    this.defaultLang = "zh-CN";
-    this.isDefault = false;
-  }
-}
-
-class ContestOptions {
-  constructor() {
-    this.calculationOfPenalty = "in_minutes";
-    this.submissionTimestampUnit = "second";
-    this.submissionHasTimeField = false;
-    this.submissionHasLanguageField = false;
-    this.submissionEnableActionField = false;
-  }
-}
-function createContestOptions(contestOptionsJSON = {}) {
-  const j = contestOptionsJSON;
-  const o = new ContestOptions();
-  if (j.calculation_of_penalty) {
-    o.calculationOfPenalty = j.calculation_of_penalty;
-  }
-  if (j.submission_timestamp_unit) {
-    o.submissionTimestampUnit = j.submission_timestamp_unit;
-  }
-  if (j.submission_has_reaction) {
-    o.submissionEnableActionField = j.submission_has_reaction;
-  }
-  return o;
-}
-
-class Contest {
-  constructor() {
-    this.id = "";
-    this.name = "";
-    this.startTime = createDayJS();
-    this.endTime = createDayJS();
-    this.freezeTime = createDayJS();
-    this.totalDurationTimestamp = 0;
-    this.freezeDurationTimestamp = 0;
-    this.unFreezeDurationTimestamp = 0;
-    this.penalty = 20 * 60;
-    this.problems = [];
-    this.problemsMap = /* @__PURE__ */ new Map();
-    this.statusTimeDisplay = {
-      correct: true,
-      incorrect: true,
-      pending: true
+    const font = {
+      name: "Arial Unicode MS",
+      bold: false,
+      italic: false,
+      sz: 12
     };
-    this.group = /* @__PURE__ */ new Map();
-    this.tag = /* @__PURE__ */ new Map();
-    this.options = new ContestOptions();
-  }
-  getStartTime() {
-    return this.replayStartTime ?? this.startTime;
-  }
-  getEndTime() {
-    return this.replayEndTime ?? this.endTime;
-  }
-  getFreezeTime() {
-    return this.replayFreezeTime ?? this.freezeTime;
-  }
-  getContestDuration(timeFormat = "HH:mm:ss") {
-    return dayjs.duration(this.getEndTime().diff(this.getStartTime())).format(timeFormat);
-  }
-  getContestState(nowTime) {
-    const now = createDayJS(nowTime);
-    if (now.isBefore(this.getStartTime())) {
-      return ContestState.PENDING;
-    }
-    if (now.isSameOrAfter(this.getEndTime())) {
-      return ContestState.FINISHED;
-    }
-    if (now.isSameOrAfter(this.getFreezeTime())) {
-      return ContestState.FROZEN;
-    }
-    return ContestState.RUNNING;
-  }
-  getContestPendingTime(nowTime) {
-    let baseTime = createDayJS(nowTime);
-    if (baseTime.isAfter(this.getStartTime())) {
-      baseTime = this.getStartTime();
-    }
-    return getTimeDiff(Math.floor(dayjs.duration(this.getStartTime().diff(baseTime)).asSeconds()));
-  }
-  getContestElapsedTime(nowTime) {
-    let baseTime = createDayJS(nowTime);
-    if (baseTime.isAfter(this.getEndTime())) {
-      baseTime = this.getEndTime();
-    }
-    if (baseTime.isBefore(this.getStartTime())) {
-      baseTime = this.getStartTime();
-    }
-    return getTimeDiff(Math.floor(dayjs.duration(baseTime.diff(this.getStartTime())).asSeconds()));
-  }
-  getContestRemainingTime(nowTime) {
-    let baseTime = createDayJS(nowTime);
-    if (baseTime.isAfter(this.getEndTime())) {
-      baseTime = this.getEndTime();
-    }
-    if (baseTime.isBefore(this.getStartTime())) {
-      baseTime = this.getStartTime();
-    }
-    return getTimeDiff(Math.floor(dayjs.duration(this.getEndTime().diff(baseTime)).asSeconds()));
-  }
-  getContestProgressRatio(nowTime) {
-    const baseTime = createDayJS(nowTime);
-    if (this.getStartTime().isSameOrAfter(baseTime)) {
-      return 0;
-    }
-    if (this.getEndTime().isSameOrBefore(baseTime)) {
-      return 100;
-    }
-    const total = this.getEndTime().diff(this.getStartTime(), "s");
-    const pass = baseTime.diff(this.getStartTime(), "s");
-    return Math.round(pass * 100 / total);
-  }
-  isEnableAwards(group) {
-    if (!this.awards) {
-      return false;
-    }
-    if (!this.awards.has(group)) {
-      return false;
-    }
-    return true;
-  }
-  resetReplayTime() {
-    this.replayStartTime = void 0;
-    this.replayEndTime = void 0;
-    this.replayFreezeTime = void 0;
-    this.replayNowTime = void 0;
-    this.replayContestStartTimestamp = void 0;
-  }
-  setReplayTime(replayStartTimestamp) {
-    if (replayStartTimestamp === 0) {
-      this.resetReplayTime();
-      return;
-    }
-    const replayStartTime = createDayJS(replayStartTimestamp);
-    const diff = replayStartTime.diff(this.startTime, "s");
-    this.replayStartTime = this.startTime.add(diff, "s");
-    this.replayEndTime = this.endTime.add(diff, "s");
-    this.replayFreezeTime = this.freezeTime.add(diff, "s");
-    this.replayNowTime = createDayJS();
-    this.replayContestStartTimestamp = this.replayNowTime.diff(this.replayStartTime, "s");
-  }
-}
-function createContest(contestJSON) {
-  const c = new Contest();
-  c.name = contestJSON.contest_name;
-  c.startTime = createDayJS(contestJSON.start_time);
-  c.endTime = createDayJS(contestJSON.end_time);
-  c.totalDurationTimestamp = c.endTime.unix() - c.startTime.unix();
-  {
-    c.freezeTime = c.endTime;
-    c.freezeDurationTimestamp = 0;
-    if (contestJSON.frozen_time !== void 0 && contestJSON.frozen_time != null) {
-      const frozenTime = Number(contestJSON.frozen_time);
-      c.freezeTime = createDayJS(c.endTime.unix() - frozenTime);
-      c.freezeDurationTimestamp = frozenTime;
+    const borderStyle = {
+      style: "thin"
+    };
+    const cellStyle = {
+      alignment: {
+        vertical: "center",
+        horizontal: "center"
+      },
+      border: {
+        top: borderStyle,
+        bottom: borderStyle,
+        left: borderStyle,
+        right: borderStyle
+      },
+      font
+    };
+    for (let i = 1; i < aoa.length; i++) {
+      for (let j = 0; j < aoa[i].length; j++) {
+        const cellAddress = XLSX.utils.encode_cell({ r: i, c: j });
+        const cell = sheet[cellAddress];
+        cell.s = cellStyle;
+      }
     }
-    if (contestJSON.freeze_time !== void 0 && contestJSON.freeze_time !== null) {
-      c.freezeTime = createDayJS(contestJSON.freeze_time);
-      c.freezeDurationTimestamp = c.endTime.unix() - c.freezeTime.unix();
+    {
+      const cellAddress = XLSX.utils.encode_cell({ r: 0, c: 0 });
+      const cell = sheet[cellAddress];
+      const titleStyle = _.cloneDeep(cellStyle);
+      titleStyle.font.sz = 28;
+      titleStyle.font.bold = true;
+      cell.s = titleStyle;
     }
-    c.unFreezeDurationTimestamp = c.totalDurationTimestamp - c.freezeDurationTimestamp;
+    return sheet;
   }
-  c.penalty = contestJSON.penalty;
-  {
-    if (contestJSON.problem_id !== void 0 && contestJSON.problem_id !== null) {
-      c.problems = createProblemsByProblemIds(contestJSON.problem_id, contestJSON.balloon_color);
-    }
-    if (contestJSON.problems !== void 0 && contestJSON.problems !== null) {
-      c.problems = createProblems(contestJSON.problems);
+  convertToAoa(rank) {
+    const aoa = [];
+    const enableAwards = rank.contest.isEnableAwards(rank.options.group);
+    const enableMembers = (Array.isArray(rank.teams) && rank.teams[0]?.members) ?? false;
+    const enableCoach = rank.teams[0]?.coach ?? false;
+    {
+      aoa.push([rank.contest.name]);
     }
-    c.problemsMap = new Map(c.problems.map((p) => [p.id, p]));
-  }
-  if (contestJSON.status_time_display !== void 0 && contestJSON.status_time_display !== null) {
-    c.statusTimeDisplay = {
-      correct: Boolean(contestJSON.status_time_display.correct ?? false),
-      incorrect: Boolean(contestJSON.status_time_display.incorrect ?? false),
-      pending: Boolean(contestJSON.status_time_display.pending ?? false)
-    };
-  }
-  c.badge = contestJSON.badge;
-  c.medal = contestJSON.medal;
-  (() => {
-    if (contestJSON.medal === void 0 || contestJSON.medal === null) {
-      return;
+    {
+      const head = [];
+      head.push("Rank");
+      if (rank.contest.organization) {
+        head.push(`${rank.contest.organization} Rank`);
+        head.push(rank.contest.organization);
+      }
+      head.push("Team", "Solved", "Penalty", ...rank.contest.problems.map((p) => p.label), "Dirt");
+      if (enableAwards) {
+        head.push("Medal");
+      }
+      if (enableMembers) {
+        head.push("Member1", "Member2", "Member3");
+      }
+      if (enableCoach) {
+        head.push("Coach");
+      }
+      head.push("Unofficial");
+      head.push("Girl");
+      aoa.push(head);
     }
-    c.awards = /* @__PURE__ */ new Map();
-    if (typeof contestJSON.medal === "string") ; else {
-      for (const k in contestJSON.medal) {
-        const v = contestJSON.medal[k];
-        {
-          const award = [];
-          let rank = 1;
-          const work = (key, medalType) => {
-            if (Object.keys(v).includes(key)) {
-              const a = new Award();
-              a.medalType = medalType;
-              a.minRank = rank;
-              rank += Number(v[key]);
-              a.maxRank = rank - 1;
-              award.push(a);
-            }
-          };
-          work("gold", MedalType.GOLD);
-          work("silver", MedalType.SILVER);
-          work("bronze", MedalType.BRONZE);
-          {
-            const a = new Award();
-            a.medalType = MedalType.HONORABLE;
-            a.minRank = rank;
-            a.maxRank = 1061109567;
-            award.push(a);
-          }
-          c.awards.set(k, award);
+    for (const team of rank.teams) {
+      const arr = [];
+      arr.push(team.rank.toString());
+      if (team.organization) {
+        if (team.organizationRank !== -1) {
+          arr.push(team.organizationRank.toString());
+        } else {
+          arr.push("");
         }
+        arr.push(team.organization);
       }
-    }
-  })();
-  c.organization = contestJSON.organization;
-  {
-    const g = new Group();
-    g.names.set("en", "All");
-    g.names.set("zh-CN", "\u6240\u6709\u961F\u4F0D");
-    g.isDefault = true;
-    c.group.set("all", g);
-  }
-  for (const [k, v] of Object.entries(contestJSON?.group ?? {})) {
-    let key = k;
-    const g = new Group();
-    g.names.set("zh-CN", v);
-    if (k === "official") {
-      g.names.set("en", "Official");
-    }
-    if (k === "unofficial") {
-      g.names.set("en", "Unofficial");
-    }
-    if (k === "girl" || k === "girls") {
-      g.names.set("en", "Girls");
-      key = "girl";
-    }
-    c.group.set(key, g);
-  }
-  c.banner = contestJSON.banner;
-  if (c.banner) {
-    c.bannerMode = contestJSON.banner_mode ?? "ALL";
-  }
-  c.logo = contestJSON.logo;
-  c.boardLink = contestJSON.board_link;
-  if (contestJSON.options) {
-    c.options = createContestOptions(contestJSON.options);
+      arr.push(team.name, team.solvedProblemNum.toString(), team.penaltyToMinute.toString());
+      for (const p of team.problemStatistics) {
+        if (p.isUnSubmitted) {
+          arr.push("-");
+        }
+        if (p.isSolved) {
+          arr.push(`+${p.totalCount}(${p.solvedTimestampToMinute})`);
+        }
+        if (p.isWrongAnswer) {
+          arr.push(`-${p.failedCount}`);
+        }
+        if (p.isPending) {
+          arr.push(`? ${p.failedCount} + ${p.pendingCount}`);
+        }
+      }
+      arr.push(`${team.dirt}%`);
+      if (enableAwards) {
+        const medals = team.awards.filter((a) => isValidMedalType(a)).map((a) => a.toString());
+        arr.push(medals.join(", "));
+      }
+      if (enableMembers) {
+        const members = team.members;
+        if (Array.isArray(members)) {
+          arr.push(members[0] ?? "");
+          arr.push(members[1] ?? "");
+          arr.push(members[2] ?? "");
+        } else {
+          arr.push("", "", "");
+        }
+      }
+      if (enableCoach) {
+        if (typeof team.coach === "string") {
+          arr.push(team.coach ?? "");
+        } else {
+          arr.push("");
+        }
+      }
+      arr.push(team.isUnofficial ? "Y" : "N");
+      arr.push(team.isGirl ? "Y" : "N");
+      aoa.push(arr);
+    }
+    return aoa;
   }
-  return c;
 }
 
-class ContestIndexConfig {
-  constructor() {
-    this.contestName = "";
-    this.startTime = createDayJS();
-    this.endTime = createDayJS();
-    this.freezeTime = createDayJS();
-    this.totalDurationTimestamp = 0;
-    this.freezeDurationTimestamp = 0;
-    this.unFreezeDurationTimestamp = 0;
-  }
-}
-class ContestIndex {
+class ICPCStandingsCsvConverter {
   constructor() {
-    this.contest = new Contest();
-    this.boardLink = "";
   }
-}
-function createContestIndex(contestIndexJSON) {
-  const c = new ContestIndex();
-  const cjc = contestIndexJSON.config;
-  c.contest = createContest(cjc);
-  c.boardLink = contestIndexJSON.board_link;
-  return c;
-}
-function createContestIndexList(contestListJSON) {
-  const contestIndexList = [];
-  const dfs = (contestList) => {
-    if (Object.prototype.hasOwnProperty.call(contestList, "config")) {
-      contestIndexList.push(createContestIndex(contestList));
-    } else {
-      for (const k in contestList) {
-        dfs(contestList[k]);
-      }
-    }
-  };
-  dfs(contestListJSON);
-  contestIndexList.sort((a, b) => {
-    if (a.contest.startTime.isBefore(b.contest.startTime)) {
-      return 1;
-    }
-    if (a.contest.startTime.isAfter(b.contest.startTime)) {
-      return -1;
-    }
-    if (a.contest.endTime.isBefore(b.contest.endTime)) {
-      return 1;
-    }
-    if (a.contest.endTime.isAfter(b.contest.endTime)) {
-      return -1;
+  convert(oriRank) {
+    const rank = _.cloneDeep(oriRank);
+    rank.options.disableFilterTeamsByGroup();
+    rank.options.disableFilterSubmissionByTimestamp();
+    rank.options.setGroup("official");
+    rank.buildRank();
+    const resList = [];
+    for (const team of rank.teams) {
+      const res = {
+        teamId: team.icpcID ?? "",
+        rank: team.rank,
+        medalCitation: this.getMedalCitation(team),
+        problemsSolved: team.solvedProblemNum,
+        totalTime: team.penaltyToMinute,
+        lastProblemTime: team.lastSolvedProblemStatistics?.solvedTimestampToMinute ?? 0,
+        siteCitation: rank.contest.name,
+        citation: ordinal(team.rank),
+        teamName: team.name,
+        institution: team.organization
+      };
+      resList.push(res);
     }
-    if (a.contest.name < b.contest.name) {
-      return 1;
+    const csv = Papa.unparse(resList);
+    return csv;
+  }
+  getMedalCitation(team) {
+    if (team.solvedProblemNum === 0) {
+      return "";
     }
-    if (a.contest.name > b.contest.name) {
-      return -1;
+    const medals = team.awards.filter((a) => isValidMedalType(a)).map((a) => a.toString());
+    if (medals.length === 1) {
+      const medal = medals[0];
+      if (medal === "Gold") {
+        return "Gold Medal";
+      }
+      if (medal === "Silver") {
+        return "Silver Medal";
+      }
+      if (medal === "Bronze") {
+        return "Bronze Medal";
+      }
+      if (medal === "Honorable") {
+        return "Honorable Mention";
+      }
     }
-    return 0;
-  });
-  return contestIndexList;
+    return "";
+  }
 }
 
 function getImageSource(image, asset_host) {
@@ -1827,8 +1644,56 @@ function getImageSource(image, asset_host) {
   return "";
 }
 
+var __defProp$9 = Object.defineProperty;
+var __defNormalProp$9 = (obj, key, value) => key in obj ? __defProp$9(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$9 = (obj, key, value) => {
+  __defNormalProp$9(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class Person {
+  constructor(name = "") {
+    __publicField$9(this, "name");
+    this.name = name;
+  }
+  toJSON() {
+    return {
+      name: this.name
+    };
+  }
+  static fromJSON(iPerson) {
+    if (typeof iPerson === "string") {
+      iPerson = JSON.parse(iPerson);
+    }
+    const person = new Person();
+    person.name = iPerson.name;
+    return person;
+  }
+}
+function createPersons(iPersons) {
+  if (typeof iPersons === "string") {
+    for (const c of " ,\u3001|") {
+      if (iPersons.includes(c)) {
+        return iPersons.split(c).map((name) => new Person(name));
+      }
+    }
+    return [new Person(iPersons)];
+  }
+  return iPersons.map((name) => new Person(name));
+}
+
+var __defProp$8 = Object.defineProperty;
+var __defNormalProp$8 = (obj, key, value) => key in obj ? __defProp$8(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$8 = (obj, key, value) => {
+  __defNormalProp$8(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
 class RankStatistics {
   constructor() {
+    __publicField$8(this, "teamSolvedNum");
+    __publicField$8(this, "teamSolvedNumIndex");
+    __publicField$8(this, "maxSolvedProblems");
+    __publicField$8(this, "effectiveTeamNum");
+    __publicField$8(this, "totalTeamNum");
     this.teamSolvedNum = [];
     this.teamSolvedNumIndex = [];
     this.maxSolvedProblems = 0;
@@ -1847,8 +1712,25 @@ class RankStatistics {
   }
 }
 
+var __defProp$7 = Object.defineProperty;
+var __defNormalProp$7 = (obj, key, value) => key in obj ? __defProp$7(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$7 = (obj, key, value) => {
+  __defNormalProp$7(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
 class RankOptions {
   constructor() {
+    __publicField$7(this, "enableFilterSubmissionsByTimestamp");
+    __publicField$7(this, "width");
+    __publicField$7(this, "timestamp");
+    __publicField$7(this, "enableFilterTeamsByGroup");
+    __publicField$7(this, "group");
+    __publicField$7(this, "filterOrganizations");
+    __publicField$7(this, "filterOrganizationMap");
+    __publicField$7(this, "filterTeams");
+    __publicField$7(this, "filterTeamMap");
+    __publicField$7(this, "enableAnimatedSubmissions");
+    __publicField$7(this, "battleOfGiants");
     this.enableFilterSubmissionsByTimestamp = false;
     this.width = 0;
     this.timestamp = 0;
@@ -1930,6 +1812,18 @@ class RankOptions {
 }
 class Rank {
   constructor(contest, teams, submissions) {
+    __publicField$7(this, "contest");
+    __publicField$7(this, "teams");
+    __publicField$7(this, "teamsMap");
+    __publicField$7(this, "submissions");
+    __publicField$7(this, "submissionsMap");
+    __publicField$7(this, "organizations");
+    __publicField$7(this, "originTeams");
+    __publicField$7(this, "rankStatistics");
+    __publicField$7(this, "options");
+    __publicField$7(this, "balloons");
+    __publicField$7(this, "languages");
+    __publicField$7(this, "statuses");
     this.contest = contest;
     this.teams = _.cloneDeep(teams);
     this.teamsMap = new Map(this.teams.map((t) => [t.id, t]));
@@ -2007,8 +1901,8 @@ class Rank {
       );
       (() => {
         this.rankStatistics.reset();
-        this.rankStatistics.teamSolvedNum = Array(this.contest.problems.length + 1).fill(0);
-        this.rankStatistics.teamSolvedNumIndex = Array(this.contest.problems.length + 1).fill(0);
+        this.rankStatistics.teamSolvedNum = Array.from({ length: this.contest.problems.length + 1 }).fill(0);
+        this.rankStatistics.teamSolvedNumIndex = Array.from({ length: this.contest.problems.length + 1 }).fill(0);
       })();
       let preSubmissionTimestampToMinute = 0;
       const allSubmissions = this.getSubmissions();
@@ -2108,178 +2002,583 @@ class Rank {
           teamSolvedNumIndex[i] = current;
         }
       }
-      if (this.teams.length > 0) {
-        this.rankStatistics.maxSolvedProblems = this.teams[0].solvedProblemNum;
+      if (this.teams.length > 0) {
+        this.rankStatistics.maxSolvedProblems = this.teams[0].solvedProblemNum;
+      }
+    })();
+    return this;
+  }
+  buildTeamRank() {
+    let rank = 1;
+    let originalRank = 1;
+    let preTeam = null;
+    for (const t of this.teams) {
+      t.rank = rank++;
+      t.originalRank = originalRank++;
+      if (preTeam !== null) {
+        if (t.isEqualRank(preTeam)) {
+          t.rank = preTeam.rank;
+        }
+      }
+      preTeam = t;
+    }
+  }
+  buildOrgRank() {
+    if (!this.contest.organization) {
+      return;
+    }
+    let rank = 1;
+    let preTeam = null;
+    const se = /* @__PURE__ */ new Set();
+    for (const t of this.teams) {
+      const org = t.organization;
+      if (se.has(org)) {
+        continue;
+      }
+      se.add(org);
+      t.organizationRank = rank++;
+      if (preTeam !== null) {
+        if (t.isEqualRank(preTeam)) {
+          t.organizationRank = preTeam.organizationRank;
+        }
+      }
+      preTeam = t;
+    }
+  }
+  buildOrganizations() {
+    if (!this.contest.organization) {
+      return [];
+    }
+    const res = new Array();
+    const se = /* @__PURE__ */ new Set();
+    this.teams.forEach((t) => {
+      const org = t.organization;
+      if (se.has(org)) {
+        return;
+      }
+      res.push(org);
+      se.add(org);
+    });
+    res.sort();
+    return res;
+  }
+  buildAwards() {
+    if (this.contest.medal === "ccpc") {
+      this.contest.awards = /* @__PURE__ */ new Map();
+      const tot = this.rankStatistics.effectiveTeamNum;
+      const award = [];
+      const gold = new Award();
+      const silver = new Award();
+      const bronze = new Award();
+      const honorable = new Award();
+      {
+        gold.medalType = MedalType.GOLD;
+        gold.minRank = 1;
+        gold.maxRank = Math.ceil(tot * 0.1);
+        if (gold.maxRank >= gold.minRank) {
+          award.push(gold);
+        }
+      }
+      {
+        silver.medalType = MedalType.SILVER;
+        silver.minRank = gold.maxRank + 1;
+        silver.maxRank = Math.ceil(tot * 0.3);
+        if (silver.maxRank >= silver.minRank) {
+          award.push(silver);
+        }
+      }
+      {
+        bronze.medalType = MedalType.BRONZE;
+        bronze.minRank = silver.maxRank + 1;
+        bronze.maxRank = Math.ceil(tot * 0.6);
+        if (bronze.maxRank >= bronze.minRank) {
+          award.push(bronze);
+        }
+      }
+      {
+        honorable.medalType = MedalType.HONORABLE;
+        honorable.minRank = bronze.maxRank + 1;
+        this.teams.forEach((t) => {
+          if (t.solvedProblemNum > 0) {
+            honorable.maxRank = Math.max(honorable.maxRank, t.rank);
+          }
+        });
+        if (honorable.maxRank >= honorable.minRank) {
+          award.push(honorable);
+        }
+      }
+      this.contest.awards.set("official", award);
+    }
+  }
+  filterTeamByOrg(team) {
+    const o = this.options;
+    if (o.enableFilterTeamsByGroup) {
+      if (!team.group?.includes(o.group)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  getSubmissions() {
+    if (this.contest.replayContestStartTimestamp === void 0 && this.options.enableFilterSubmissionsByTimestamp === false) {
+      return this.submissions;
+    }
+    return this.submissions.filter((s) => {
+      if (this.contest.replayContestStartTimestamp !== void 0) {
+        if (s.timestampToSecond > this.contest.replayContestStartTimestamp) {
+          return false;
+        }
+      }
+      if (this.options.enableFilterSubmissionsByTimestamp) {
+        if (s.timestampToSecond > this.options.timestamp) {
+          return false;
+        }
       }
-    })();
-    return this;
+      return true;
+    });
   }
-  buildTeamRank() {
-    let rank = 1;
-    let originalRank = 1;
-    let preTeam = null;
-    for (const t of this.teams) {
-      t.rank = rank++;
-      t.originalRank = originalRank++;
-      if (preTeam !== null) {
-        if (t.isEqualRank(preTeam)) {
-          t.rank = preTeam.rank;
+  buildBalloons() {
+    this.balloons = [];
+    this.cleanRank();
+    const allSubmissions = this.getSubmissions();
+    for (let ix = 0; ix < allSubmissions.length; ix++) {
+      const s = allSubmissions[ix];
+      const teamId = s.teamId;
+      const problemId = s.problemId;
+      const team = this.teamsMap.get(teamId);
+      const problem = this.contest.problemsMap.get(problemId);
+      (() => {
+        if (team === void 0 || problem === void 0) {
+          return;
         }
-      }
-      preTeam = t;
+        const problemStatistics = team.problemStatisticsMap.get(problemId);
+        if (problemStatistics.isSolved) {
+          return;
+        }
+        if (s.isAccepted()) {
+          problemStatistics.isSolved = true;
+          problemStatistics.solvedTimestamp = s.timestampToSecond;
+          const b = new Balloon();
+          b.team = team;
+          b.problem = problem;
+          b.submission = s;
+          this.balloons.push(b);
+        }
+      })();
     }
   }
-  buildOrgRank() {
-    if (!this.contest.organization) {
-      return;
+  setReplayTime(replayStartTimestamp) {
+    this.contest.setReplayTime(replayStartTimestamp);
+  }
+}
+
+var __defProp$6 = Object.defineProperty;
+var __defNormalProp$6 = (obj, key, value) => key in obj ? __defProp$6(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$6 = (obj, key, value) => {
+  __defNormalProp$6(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class RatingHistory {
+  constructor() {
+    __publicField$6(this, "rank");
+    __publicField$6(this, "rating");
+    __publicField$6(this, "teamName");
+    __publicField$6(this, "organization");
+    __publicField$6(this, "members");
+    __publicField$6(this, "coaches");
+    __publicField$6(this, "contestID");
+    __publicField$6(this, "contestName");
+    __publicField$6(this, "contestLink");
+    __publicField$6(this, "contestTime");
+    this.rank = 0;
+    this.rating = 0;
+    this.teamName = "";
+    this.organization = "";
+    this.members = [];
+    this.coaches = [];
+    this.contestID = "";
+    this.contestName = "";
+    this.contestLink = "";
+    this.contestTime = createDayJS();
+  }
+  toJSON() {
+    return {
+      rank: this.rank,
+      rating: this.rating,
+      teamName: this.teamName,
+      organization: this.organization,
+      members: this.members.map((member) => member.toJSON()),
+      coaches: this.coaches.map((coach) => coach.toJSON()),
+      contestID: this.contestID,
+      contestName: this.contestName,
+      contestLink: this.contestLink,
+      contestTime: this.contestTime.toDate()
+    };
+  }
+  static fromJSON(iRatingHistory) {
+    if (typeof iRatingHistory === "string") {
+      iRatingHistory = JSON.parse(iRatingHistory);
     }
-    let rank = 1;
-    let preTeam = null;
-    const se = /* @__PURE__ */ new Set();
-    for (const t of this.teams) {
-      const org = t.organization;
-      if (se.has(org)) {
-        continue;
+    const ratingHistory = new RatingHistory();
+    ratingHistory.rank = iRatingHistory.rank;
+    ratingHistory.rating = iRatingHistory.rating;
+    ratingHistory.teamName = iRatingHistory.teamName;
+    ratingHistory.organization = iRatingHistory.organization;
+    ratingHistory.members = iRatingHistory.members.map((iMember) => Person.fromJSON(iMember));
+    ratingHistory.coaches = iRatingHistory.coaches.map((iCoach) => Person.fromJSON(iCoach));
+    ratingHistory.contestID = iRatingHistory.contestID;
+    ratingHistory.contestName = iRatingHistory.contestName;
+    ratingHistory.contestLink = iRatingHistory.contestLink;
+    ratingHistory.contestTime = createDayJS(iRatingHistory.contestTime);
+    return ratingHistory;
+  }
+}
+
+var __defProp$5 = Object.defineProperty;
+var __defNormalProp$5 = (obj, key, value) => key in obj ? __defProp$5(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$5 = (obj, key, value) => {
+  __defNormalProp$5(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class RatingUser {
+  constructor() {
+    __publicField$5(this, "id");
+    __publicField$5(this, "name");
+    __publicField$5(this, "organization");
+    __publicField$5(this, "members");
+    __publicField$5(this, "coaches");
+    __publicField$5(this, "rating");
+    __publicField$5(this, "minRating");
+    __publicField$5(this, "maxRating");
+    __publicField$5(this, "rank");
+    __publicField$5(this, "oldRating");
+    __publicField$5(this, "seed");
+    __publicField$5(this, "delta");
+    __publicField$5(this, "ratingHistories");
+    this.id = "";
+    this.name = "";
+    this.organization = "";
+    this.members = [];
+    this.coaches = [];
+    this.rating = 0;
+    this.minRating = 1061109567;
+    this.maxRating = -1061109567;
+    this.rank = 0;
+    this.oldRating = 0;
+    this.seed = 1;
+    this.delta = 0;
+    this.ratingHistories = [];
+  }
+  UpdateRating(rating) {
+    this.rating = rating;
+    this.minRating = Math.min(this.minRating, rating);
+    this.maxRating = Math.max(this.maxRating, rating);
+  }
+  toJSON() {
+    return {
+      id: this.id,
+      name: this.name,
+      organization: this.organization,
+      members: this.members.map((member) => member.toJSON()),
+      coaches: this.coaches.map((coach) => coach.toJSON()),
+      rating: this.rating,
+      minRating: this.minRating,
+      maxRating: this.maxRating,
+      ratingHistories: this.ratingHistories.map((ratingHistory) => ratingHistory.toJSON())
+    };
+  }
+  static fromJSON(iRatingUser) {
+    if (typeof iRatingUser === "string") {
+      iRatingUser = JSON.parse(iRatingUser);
+    }
+    const ratingUser = new RatingUser();
+    ratingUser.id = iRatingUser.id;
+    ratingUser.name = iRatingUser.name;
+    ratingUser.organization = iRatingUser.organization;
+    ratingUser.members = iRatingUser.members.map((member) => Person.fromJSON(member));
+    ratingUser.coaches = iRatingUser.coaches.map((coach) => Person.fromJSON(coach));
+    ratingUser.rating = iRatingUser.rating;
+    ratingUser.minRating = iRatingUser.minRating;
+    ratingUser.maxRating = iRatingUser.maxRating;
+    for (const iRatingHistory of iRatingUser.ratingHistories) {
+      ratingUser.ratingHistories.push(RatingHistory.fromJSON(iRatingHistory));
+    }
+    return ratingUser;
+  }
+}
+
+var __defProp$4 = Object.defineProperty;
+var __defNormalProp$4 = (obj, key, value) => key in obj ? __defProp$4(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$4 = (obj, key, value) => {
+  __defNormalProp$4(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class RatingCalculator {
+  constructor() {
+    __publicField$4(this, "users");
+    this.users = [];
+  }
+  calculate() {
+    this.calculateInternal();
+  }
+  calcP(userA, userB) {
+    return 1 / (1 + 10 ** ((userB.oldRating - userA.oldRating) / 400));
+  }
+  getExSeed(users, rating, ownUser) {
+    const exUser = new RatingUser();
+    exUser.oldRating = rating;
+    let res = 0;
+    users.forEach((user) => {
+      if (user.id !== ownUser.id) {
+        res += this.calcP(user, exUser);
       }
-      se.add(org);
-      t.organizationRank = rank++;
-      if (preTeam !== null) {
-        if (t.isEqualRank(preTeam)) {
-          t.organizationRank = preTeam.organizationRank;
-        }
+    });
+    return res;
+  }
+  calcRating(users, rank, user) {
+    let left = 1;
+    let right = 8e3;
+    while (right - left > 1) {
+      const mid = Math.floor((left + right) / 2);
+      if (this.getExSeed(users, mid, user) < rank) {
+        right = mid;
+      } else {
+        left = mid;
       }
-      preTeam = t;
     }
+    return left;
   }
-  buildOrganizations() {
-    if (!this.contest.organization) {
-      return [];
-    }
-    const res = new Array();
-    const se = /* @__PURE__ */ new Set();
-    this.teams.forEach((t) => {
-      const org = t.organization;
-      if (se.has(org)) {
-        return;
+  calculateInternal() {
+    for (let i = 0; i < this.users.length; i++) {
+      const u = this.users[i];
+      u.seed = 1;
+      for (let j = 0; j < this.users.length; j++) {
+        if (i !== j) {
+          const otherUser = this.users[j];
+          u.seed += this.calcP(otherUser, u);
+        }
       }
-      res.push(org);
-      se.add(org);
+    }
+    let sumDelta = 0;
+    for (let i = 0; i < this.users.length; i++) {
+      const u = this.users[i];
+      u.delta = Math.floor(
+        (this.calcRating(this.users, Math.sqrt(u.rank * u.seed), u) - u.oldRating) / 2
+      );
+      sumDelta += u.delta;
+    }
+    let inc = Math.floor(-sumDelta / this.users.length) - 1;
+    for (let i = 0; i < this.users.length; i++) {
+      const u = this.users[i];
+      u.delta += inc;
+    }
+    this.users = this.users.sort((a, b) => b.oldRating - a.oldRating);
+    const s = Math.min(this.users.length, Math.floor(4 * Math.round(Math.sqrt(this.users.length))));
+    let sumS = 0;
+    for (let i = 0; i < s; i++) {
+      sumS += this.users[i].delta;
+    }
+    inc = Math.min(Math.max(Math.floor(-sumS / s), -10), 0);
+    this.users.forEach((u) => {
+      u.delta += inc;
+      u.UpdateRating(u.oldRating + u.delta);
     });
-    res.sort();
-    return res;
+    this.users = this.users.sort((a, b) => a.rank - b.rank);
   }
-  buildAwards() {
-    if (this.contest.medal === "ccpc") {
-      this.contest.awards = /* @__PURE__ */ new Map();
-      const tot = this.rankStatistics.effectiveTeamNum;
-      const award = [];
-      const gold = new Award();
-      const silver = new Award();
-      const bronze = new Award();
-      const honorable = new Award();
-      {
-        gold.medalType = MedalType.GOLD;
-        gold.minRank = 1;
-        gold.maxRank = Math.ceil(tot * 0.1);
-        if (gold.maxRank >= gold.minRank) {
-          award.push(gold);
-        }
-      }
-      {
-        silver.medalType = MedalType.SILVER;
-        silver.minRank = gold.maxRank + 1;
-        silver.maxRank = Math.ceil(tot * 0.3);
-        if (silver.maxRank >= silver.minRank) {
-          award.push(silver);
+}
+
+var __defProp$3 = Object.defineProperty;
+var __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$3 = (obj, key, value) => {
+  __defNormalProp$3(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class Rating {
+  constructor() {
+    __publicField$3(this, "id");
+    __publicField$3(this, "name");
+    __publicField$3(this, "baseRating");
+    __publicField$3(this, "contestIDs");
+    __publicField$3(this, "users");
+    __publicField$3(this, "ranks");
+    __publicField$3(this, "userMap");
+    this.id = "";
+    this.name = "";
+    this.baseRating = 1500;
+    this.contestIDs = [];
+    this.users = [];
+    this.ranks = [];
+    this.userMap = /* @__PURE__ */ new Map();
+  }
+  buildRating() {
+    for (const rank of this.ranks) {
+      rank.buildRank();
+      const ratingCalculator = new RatingCalculator();
+      for (const t of rank.teams) {
+        const id = this.generateTeamId(t);
+        let u = null;
+        if (!this.userMap.has(id)) {
+          u = new RatingUser();
+          u.id = id;
+          u.name = t.name;
+          u.organization = t.organization;
+          u.members = createPersons(t.members ?? []);
+          u.coaches = createPersons(t.coach ?? []);
+          u.rank = t.rank;
+          u.oldRating = this.baseRating;
+          u.UpdateRating(this.baseRating);
+          this.userMap.set(id, u);
+          this.users.push(u);
+          ratingCalculator.users.push(u);
+        } else {
+          u = this.userMap.get(id);
+          u.rank = t.rank;
+          u.oldRating = u.rating;
+          ratingCalculator.users.push(u);
         }
-      }
-      {
-        bronze.medalType = MedalType.BRONZE;
-        bronze.minRank = silver.maxRank + 1;
-        bronze.maxRank = Math.ceil(tot * 0.6);
-        if (bronze.maxRank >= bronze.minRank) {
-          award.push(bronze);
+        {
+          const h = new RatingHistory();
+          h.rank = t.rank;
+          h.rating = u.rating;
+          h.teamName = t.name;
+          h.organization = t.organization;
+          h.members = createPersons(t.members ?? []);
+          h.coaches = createPersons(t.coach ?? []);
+          h.contestID = rank.contest.id;
+          h.contestLink = h.contestID;
+          h.contestName = rank.contest.name;
+          h.contestTime = rank.contest.startTime;
+          u.ratingHistories.push(h);
         }
       }
-      {
-        honorable.medalType = MedalType.HONORABLE;
-        honorable.minRank = bronze.maxRank + 1;
-        this.teams.forEach((t) => {
-          if (t.solvedProblemNum > 0) {
-            honorable.maxRank = Math.max(honorable.maxRank, t.rank);
-          }
-        });
-        if (honorable.maxRank >= honorable.minRank) {
-          award.push(honorable);
-        }
+      ratingCalculator.calculate();
+      for (const u of ratingCalculator.users) {
+        u.ratingHistories.at(-1).rating = u.rating;
       }
-      this.contest.awards.set("official", award);
     }
   }
-  filterTeamByOrg(team) {
-    const o = this.options;
-    if (o.enableFilterTeamsByGroup) {
-      if (!team.group?.includes(o.group)) {
-        return true;
-      }
+  generateTeamId(t) {
+    const persons = createPersons(t.members ?? []);
+    if (persons.length > 0) {
+      return persons.map((person) => person.name.trim()).sort().join("|");
     }
-    return false;
+    return `${t.organization}-${t.name}`;
   }
-  getSubmissions() {
-    if (this.contest.replayContestStartTimestamp === void 0 && this.options.enableFilterSubmissionsByTimestamp === false) {
-      return this.submissions;
+  toJSON() {
+    return {
+      id: this.id,
+      name: this.name,
+      baseRating: this.baseRating,
+      contestIDs: this.contestIDs,
+      users: this.users.map((ratingUser) => ratingUser.toJSON())
+    };
+  }
+  static fromJSON(iRating) {
+    if (typeof iRating === "string") {
+      iRating = JSON.parse(iRating);
     }
-    return this.submissions.filter((s) => {
-      if (this.contest.replayContestStartTimestamp !== void 0) {
-        if (s.timestampToSecond > this.contest.replayContestStartTimestamp) {
-          return false;
-        }
-      }
-      if (this.options.enableFilterSubmissionsByTimestamp) {
-        if (s.timestampToSecond > this.options.timestamp) {
-          return false;
-        }
-      }
-      return true;
-    });
+    const rating = new Rating();
+    rating.id = iRating.id;
+    rating.name = iRating.name;
+    rating.baseRating = iRating.baseRating;
+    rating.contestIDs = iRating.contestIDs;
+    for (const iUser of iRating.users) {
+      rating.users.push(RatingUser.fromJSON(iUser));
+    }
+    return rating;
   }
-  buildBalloons() {
-    this.balloons = [];
-    this.cleanRank();
-    const allSubmissions = this.getSubmissions();
-    for (let ix = 0; ix < allSubmissions.length; ix++) {
-      const s = allSubmissions[ix];
-      const teamId = s.teamId;
-      const problemId = s.problemId;
-      const team = this.teamsMap.get(teamId);
-      const problem = this.contest.problemsMap.get(problemId);
-      (() => {
-        if (team === void 0 || problem === void 0) {
-          return;
-        }
-        const problemStatistics = team.problemStatisticsMap.get(problemId);
-        if (problemStatistics.isSolved) {
-          return;
-        }
-        if (s.isAccepted()) {
-          problemStatistics.isSolved = true;
-          problemStatistics.solvedTimestamp = s.timestampToSecond;
-          const b = new Balloon();
-          b.team = team;
-          b.problem = problem;
-          b.submission = s;
-          this.balloons.push(b);
-        }
-      })();
+}
+
+var RatingLevel = /* @__PURE__ */ ((RatingLevel2) => {
+  RatingLevel2["NEWBIE"] = "NEWBIE";
+  RatingLevel2["PUPIL"] = "PUPIL";
+  RatingLevel2["SPECIALIST"] = "SPECIALIST";
+  RatingLevel2["EXPERT"] = "EXPERT";
+  RatingLevel2["CANDIDATE_MASTER"] = "CANDIDATE_MASTER";
+  RatingLevel2["MASTER"] = "MASTER";
+  RatingLevel2["INTERNATIONAL_MASTER"] = "INTERNATIONAL_MASTER";
+  RatingLevel2["GRANDMASTER"] = "GRANDMASTER";
+  RatingLevel2["INTERNATIONAL_GRANDMASTER"] = "INTERNATIONAL_GRANDMASTER";
+  RatingLevel2["LEGENDARY_GRANDMASTER"] = "LEGENDARY_GRANDMASTER";
+  return RatingLevel2;
+})(RatingLevel || {});
+const RatingLevelToString = {
+  ["NEWBIE" /* NEWBIE */]: "Newbie",
+  ["PUPIL" /* PUPIL */]: "Pupil",
+  ["SPECIALIST" /* SPECIALIST */]: "Specialist",
+  ["EXPERT" /* EXPERT */]: "Expert",
+  ["CANDIDATE_MASTER" /* CANDIDATE_MASTER */]: "Candidate Master",
+  ["MASTER" /* MASTER */]: "Master",
+  ["INTERNATIONAL_MASTER" /* INTERNATIONAL_MASTER */]: "International Master",
+  ["GRANDMASTER" /* GRANDMASTER */]: "Grandmaster",
+  ["INTERNATIONAL_GRANDMASTER" /* INTERNATIONAL_GRANDMASTER */]: "International Grandmaster",
+  ["LEGENDARY_GRANDMASTER" /* LEGENDARY_GRANDMASTER */]: "Legendary Grandmaster"
+};
+class RatingUtility {
+  static getRatingLevel(rating) {
+    if (rating >= 3e3) {
+      return "LEGENDARY_GRANDMASTER" /* LEGENDARY_GRANDMASTER */;
+    } else if (rating >= 2600) {
+      return "INTERNATIONAL_GRANDMASTER" /* INTERNATIONAL_GRANDMASTER */;
+    } else if (rating >= 2400) {
+      return "GRANDMASTER" /* GRANDMASTER */;
+    } else if (rating >= 2300) {
+      return "INTERNATIONAL_MASTER" /* INTERNATIONAL_MASTER */;
+    } else if (rating >= 2100) {
+      return "MASTER" /* MASTER */;
+    } else if (rating >= 1900) {
+      return "CANDIDATE_MASTER" /* CANDIDATE_MASTER */;
+    } else if (rating >= 1600) {
+      return "EXPERT" /* EXPERT */;
+    } else if (rating >= 1400) {
+      return "SPECIALIST" /* SPECIALIST */;
+    } else if (rating >= 1200) {
+      return "PUPIL" /* PUPIL */;
     }
+    return "NEWBIE" /* NEWBIE */;
   }
-  setReplayTime(replayStartTimestamp) {
-    this.contest.setReplayTime(replayStartTimestamp);
+  static getRatingLevelClass(ratingLevel) {
+    if (typeof ratingLevel === "number") {
+      return this.getRatingLevelClass(this.getRatingLevel(ratingLevel));
+    }
+    switch (ratingLevel) {
+      case "NEWBIE" /* NEWBIE */:
+        return "user-gray";
+      case "PUPIL" /* PUPIL */:
+        return "user-green";
+      case "SPECIALIST" /* SPECIALIST */:
+        return "user-cyan";
+      case "EXPERT" /* EXPERT */:
+        return "user-blue";
+      case "CANDIDATE_MASTER" /* CANDIDATE_MASTER */:
+        return "user-violet";
+      case "MASTER" /* MASTER */:
+        return "user-orange";
+      case "INTERNATIONAL_MASTER" /* INTERNATIONAL_MASTER */:
+        return "user-orange";
+      case "GRANDMASTER" /* GRANDMASTER */:
+        return "user-red";
+      case "INTERNATIONAL_GRANDMASTER" /* INTERNATIONAL_GRANDMASTER */:
+        return "user-red";
+      case "LEGENDARY_GRANDMASTER" /* LEGENDARY_GRANDMASTER */:
+        return "user-legendary";
+    }
   }
 }
 
+var __defProp$2 = Object.defineProperty;
+var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$2 = (obj, key, value) => {
+  __defNormalProp$2(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
 class ResolverOperation {
   constructor() {
+    __publicField$2(this, "id");
+    __publicField$2(this, "team");
+    __publicField$2(this, "problemIx");
+    __publicField$2(this, "beforeTeamProblemStatistics");
+    __publicField$2(this, "afterTeamProblemStatistics");
     this.id = 0;
     this.team = new Team();
     this.problemIx = 0;
@@ -2288,6 +2587,12 @@ class ResolverOperation {
   }
 }
 
+var __defProp$1 = Object.defineProperty;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$1 = (obj, key, value) => {
+  __defNormalProp$1(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
 class Resolver extends Rank {
   constructor(contest, teams, submissions) {
     submissions.sort(Submission.compare);
@@ -2312,6 +2617,10 @@ class Resolver extends Rank {
       afterFreezeSubmissions = submissions.slice(ix, -1);
     }
     super(contest, teams, beforeFreezeSubmissions);
+    __publicField$1(this, "finalRank");
+    __publicField$1(this, "operations");
+    __publicField$1(this, "beforeFreezeSubmissions");
+    __publicField$1(this, "afterFreezeSubmissions");
     this.finalRank = new Rank(contest, teams, submissions);
     this.operations = [];
     this.beforeFreezeSubmissions = beforeFreezeSubmissions;
@@ -2378,11 +2687,29 @@ class Resolver extends Rank {
   }
 }
 
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
 class ResolverVue extends Resolver {
   constructor(contest, teams, submissions) {
     super(contest, teams, submissions);
-    this.FLASHING_TIME_MS = 100;
-    this.ROLLING_TIME_MS = 600;
+    __publicField(this, "FLASHING_TIME_MS", 100);
+    __publicField(this, "ROLLING_TIME_MS", 600);
+    __publicField(this, "maxIndex");
+    __publicField(this, "currentIndex");
+    __publicField(this, "maxOpIndex");
+    __publicField(this, "currentOpIndex");
+    __publicField(this, "oldRank");
+    __publicField(this, "newRank");
+    __publicField(this, "currentTeamId");
+    __publicField(this, "currentProblemIndex");
+    __publicField(this, "problemFlashingEnded");
+    __publicField(this, "duringAnimation");
+    __publicField(this, "startScrollUp");
+    __publicField(this, "startScrollDown");
     this.maxIndex = 0;
     this.currentIndex = 0;
     this.maxOpIndex = 0;