@algoux/standard-ranklist-utils 0.1.1 → 0.2.0

package/README.md

@@ -2,6 +2,14 @@
 
 Utilities for standard ranklist.
 
+## Usage
+
+Make sure you have installed the `@algoux/standard-ranklist` package, then install this package:
+
+```shell
+npm i -S @algoux/standard-ranklist-utils
+```
+
 ## Utilities
 
 ### formatters

package/dist/index.cjs

@@ -0,0 +1,689 @@
+'use strict';
+
+var TEXTColor = require('textcolor');
+var bcp47Match = require('bcp-47-match');
+var semver = require('semver');
+var BigNumber = require('bignumber.js');
+
+const MIN_REGEN_SUPPORTED_VERSION = "0.3.0";
+
+var EnumTheme = /* @__PURE__ */ ((EnumTheme2) => {
+  EnumTheme2["light"] = "light";
+  EnumTheme2["dark"] = "dark";
+  return EnumTheme2;
+})(EnumTheme || {});
+
+function formatTimeDuration(time, targetUnit = "ms", fmt = (num) => num) {
+  let ms = -1;
+  switch (time[1]) {
+    case "ms":
+      ms = time[0];
+      break;
+    case "s":
+      ms = time[0] * 1e3;
+      break;
+    case "min":
+      ms = time[0] * 1e3 * 60;
+      break;
+    case "h":
+      ms = time[0] * 1e3 * 60 * 60;
+      break;
+    case "d":
+      ms = time[0] * 1e3 * 60 * 60 * 24;
+      break;
+    default:
+      throw new Error(`Invalid source time unit ${time[1]}`);
+  }
+  switch (targetUnit) {
+    case "ms":
+      return ms;
+    case "s":
+      return fmt(ms / 1e3);
+    case "min":
+      return fmt(ms / 1e3 / 60);
+    case "h":
+      return fmt(ms / 1e3 / 60 / 60);
+    case "d":
+      return fmt(ms / 1e3 / 60 / 60 / 24);
+    default:
+      throw new Error(`Invalid target time unit ${targetUnit}`);
+  }
+}
+function preZeroFill(num, size) {
+  if (num >= Math.pow(10, size)) {
+    return num.toString();
+  } else {
+    let str = Array(size + 1).join("0") + num;
+    return str.slice(str.length - size);
+  }
+}
+function secToTimeStr(second, options = {}) {
+  let sec = second;
+  let d = 0;
+  const { fillHour = false, showDay = false } = options;
+  if (showDay) {
+    d = Math.floor(sec / 86400);
+    sec %= 86400;
+  }
+  let h = Math.floor(sec / 3600);
+  sec %= 3600;
+  let m = Math.floor(sec / 60);
+  sec %= 60;
+  let s = Math.floor(sec);
+  let dayStr = "";
+  if (showDay && d >= 1) {
+    dayStr = d + "D ";
+  }
+  if (sec < 0) {
+    return "--";
+  }
+  return dayStr + (fillHour ? preZeroFill(h, 2) : `${h}`) + ":" + preZeroFill(m, 2) + ":" + preZeroFill(s, 2);
+}
+function numberToAlphabet(number) {
+  let n = ~~number;
+  const radix = 26;
+  let cnt = 1;
+  let p = radix;
+  while (n >= p) {
+    n -= p;
+    cnt++;
+    p *= radix;
+  }
+  let res = [];
+  for (; cnt > 0; cnt--) {
+    res.push(String.fromCharCode(n % radix + 65));
+    n = Math.trunc(n / radix);
+  }
+  return res.reverse().join("");
+}
+function alphabetToNumber(alphabet) {
+  if (typeof alphabet !== "string" || !alphabet.length) {
+    return -1;
+  }
+  const chars = `${alphabet}`.toUpperCase().split("").reverse();
+  const radix = 26;
+  let p = 1;
+  let res = -1;
+  chars.forEach((ch) => {
+    res += (ch.charCodeAt(0) - 65) * p + p;
+    p *= radix;
+  });
+  return res;
+}
+
+function resolveText(text) {
+  var _a;
+  if (text === void 0) {
+    return "";
+  }
+  if (typeof text === "string") {
+    return text;
+  } else {
+    const langs = Object.keys(text).filter((k) => k && k !== "fallback").sort().reverse();
+    const userLangs = typeof navigator !== "undefined" && [...navigator.languages] || [];
+    const usingLang = bcp47Match.lookup(userLangs, langs) || "fallback";
+    return (_a = text[usingLang]) != null ? _a : "";
+  }
+}
+function resolveContributor(contributor) {
+  if (!contributor) {
+    return null;
+  }
+  let name = "";
+  let email;
+  let url;
+  const words = contributor.split(" ").map((s) => s.trim());
+  let index = words.length - 1;
+  while (index > 0) {
+    const word = words[index];
+    if (word.startsWith("<") && word.endsWith(">")) {
+      email = word.slice(1, -1);
+      index--;
+      continue;
+    }
+    if (word.startsWith("(") && word.endsWith(")")) {
+      url = word.slice(1, -1);
+      index--;
+      continue;
+    }
+    break;
+  }
+  name = words.slice(0, index + 1).join(" ");
+  return { name, email, url };
+}
+function resolveColor(color) {
+  if (Array.isArray(color)) {
+    return `rgba(${color[0]},${color[1]},${color[2]},${color[3]})`;
+  } else if (color) {
+    return color;
+  }
+  return void 0;
+}
+function resolveThemeColor(themeColor) {
+  let light = resolveColor(typeof themeColor === "string" ? themeColor : themeColor.light);
+  let dark = resolveColor(typeof themeColor === "string" ? themeColor : themeColor.dark);
+  return {
+    [EnumTheme.light]: light,
+    [EnumTheme.dark]: dark
+  };
+}
+function resolveStyle(style) {
+  const { textColor, backgroundColor } = style;
+  let usingTextColor = textColor;
+  if (backgroundColor && !textColor) {
+    if (typeof backgroundColor === "string") {
+      usingTextColor = TEXTColor.findTextColor(backgroundColor);
+    } else {
+      const { light, dark } = backgroundColor;
+      usingTextColor = {
+        light: light && TEXTColor.findTextColor(light),
+        dark: dark && TEXTColor.findTextColor(dark)
+      };
+    }
+  }
+  const textThemeColor = resolveThemeColor(usingTextColor || "");
+  const backgroundThemeColor = resolveThemeColor(backgroundColor || "");
+  return {
+    textColor: textThemeColor,
+    backgroundColor: backgroundThemeColor
+  };
+}
+
+function canRegenerateRanklist(ranklist) {
+  var _a;
+  try {
+    if (!semver.gte(ranklist.version, MIN_REGEN_SUPPORTED_VERSION)) {
+      return false;
+    }
+    if (((_a = ranklist.sorter) == null ? void 0 : _a.algorithm) !== "ICPC") {
+      return false;
+    }
+  } catch (e) {
+    return false;
+  }
+  return true;
+}
+function getSortedCalculatedRawSolutions(rows) {
+  const solutions = [];
+  for (const row of rows) {
+    const { user, statuses } = row;
+    const userId = user.id && `${user.id}` || `${typeof user.name === "string" ? user.name : JSON.stringify(user.name)}`;
+    statuses.forEach((status, index) => {
+      var _a;
+      if (Array.isArray(status.solutions) && status.solutions.length) {
+        solutions.push(
+          ...status.solutions.map(
+            (solution) => [userId, index, solution.result, solution.time]
+          )
+        );
+      } else if (status.result && ((_a = status.time) == null ? void 0 : _a[0])) {
+        if (status.result === "AC" || status.result === "FB") {
+          for (let i = 1; i < (status.tries || 0); i++) {
+            solutions.push([userId, index, "RJ", status.time]);
+          }
+          solutions.push([userId, index, status.result, status.time]);
+        }
+      }
+    });
+  }
+  return solutions.sort((a, b) => {
+    const ta = a[3];
+    const tb = b[3];
+    const timeComp = ta[1] === tb[1] ? ta[0] - tb[0] : formatTimeDuration(ta) - formatTimeDuration(tb);
+    if (timeComp !== 0) {
+      return timeComp;
+    }
+    const resultValue = {
+      FB: 998,
+      AC: 999,
+      "?": 1e3
+    };
+    const resultA = resultValue[a[2]] || 0;
+    const resultB = resultValue[b[2]] || 0;
+    return resultA - resultB;
+  });
+}
+function filterSolutionsUntil(solutions, time) {
+  const timeValue = formatTimeDuration(time);
+  const check = (tetrad) => formatTimeDuration(tetrad[3]) <= timeValue;
+  let lastIndex = -1;
+  let low = 0;
+  let high = solutions.length - 1;
+  while (low <= high) {
+    const mid = low + high >> 1;
+    if (check(solutions[mid])) {
+      lastIndex = mid;
+      low = mid + 1;
+    } else {
+      high = mid - 1;
+    }
+  }
+  return solutions.slice(0, lastIndex + 1);
+}
+function sortRows(rows) {
+  rows.sort((a, b) => {
+    if (a.score.value !== b.score.value) {
+      return b.score.value - a.score.value;
+    }
+    return formatTimeDuration(a.score.time) - formatTimeDuration(b.score.time);
+  });
+  return rows;
+}
+function regenerateRanklistBySolutions(originalRanklist, solutions) {
+  var _a;
+  if (!canRegenerateRanklist(originalRanklist)) {
+    throw new Error("The ranklist is not supported to regenerate");
+  }
+  const sorterConfig = {
+    penalty: [20, "min"],
+    noPenaltyResults: ["FB", "AC", "?", "CE", "UKE", null],
+    timeRounding: "floor",
+    ...JSON.parse(JSON.stringify(((_a = originalRanklist.sorter) == null ? void 0 : _a.config) || {}))
+  };
+  const ranklist = {
+    ...originalRanklist,
+    rows: []
+  };
+  const rows = [];
+  const userRowMap = /* @__PURE__ */ new Map();
+  const problemCount = originalRanklist.problems.length;
+  originalRanklist.rows.forEach((row) => {
+    const userId = row.user.id && `${row.user.id}` || `${typeof row.user.name === "string" ? row.user.name : JSON.stringify(row.user.name)}`;
+    userRowMap.set(userId, {
+      user: row.user,
+      score: {
+        value: 0
+      },
+      statuses: new Array(problemCount).fill(null).map(() => ({ result: null, solutions: [] }))
+    });
+  });
+  for (const tetrad of solutions) {
+    const [userId, problemIndex, result, time] = tetrad;
+    let row = userRowMap.get(userId);
+    if (!row) {
+      console.error(`Invalid user id ${userId} found when regenerating ranklist`);
+      break;
+    }
+    const status = row.statuses[problemIndex];
+    status.solutions.push({ result, time });
+  }
+  const problemAcceptedCount = new Array(problemCount).fill(0);
+  const problemSubmittedCount = new Array(problemCount).fill(0);
+  for (const row of userRowMap.values()) {
+    const { statuses } = row;
+    let scoreValue = 0;
+    let totalTimeMs = 0;
+    for (let i = 0; i < statuses.length; ++i) {
+      const status = statuses[i];
+      const solutions2 = status.solutions;
+      for (const solution of solutions2) {
+        if (!solution.result) {
+          continue;
+        }
+        if (solution.result === "?") {
+          status.result = solution.result;
+          status.tries = (status.tries || 0) + 1;
+          problemSubmittedCount[i] += 1;
+          continue;
+        }
+        if (solution.result === "AC" || solution.result === "FB") {
+          status.result = solution.result;
+          status.time = solution.time;
+          status.tries = (status.tries || 0) + 1;
+          problemAcceptedCount[i] += 1;
+          problemSubmittedCount[i] += 1;
+          break;
+        }
+        if ((sorterConfig.noPenaltyResults || []).includes(solution.result)) {
+          continue;
+        }
+        status.result = "RJ";
+        status.tries = (status.tries || 0) + 1;
+        problemSubmittedCount[i] += 1;
+      }
+      if (status.result === "AC" || status.result === "FB") {
+        const targetTime = [
+          formatTimeDuration(
+            status.time,
+            sorterConfig.timePrecision || "ms",
+            sorterConfig.timeRounding === "ceil" ? Math.ceil : sorterConfig.timeRounding === "round" ? Math.round : Math.floor
+          ),
+          sorterConfig.timePrecision || "ms"
+        ];
+        scoreValue += 1;
+        totalTimeMs += formatTimeDuration(targetTime, "ms") + (status.tries - 1) * formatTimeDuration(sorterConfig.penalty, "ms");
+      }
+    }
+    row.score = {
+      value: scoreValue,
+      time: [totalTimeMs, "ms"]
+    };
+    rows.push(row);
+  }
+  ranklist.rows = sortRows(rows);
+  ranklist.problems.forEach((problem, index) => {
+    if (!problem.statistics) {
+      problem.statistics = {
+        accepted: 0,
+        submitted: 0
+      };
+    }
+    problem.statistics.accepted = problemAcceptedCount[index];
+    problem.statistics.submitted = problemSubmittedCount[index];
+  });
+  return ranklist;
+}
+function regenerateRowsByIncrementalSolutions(originalRanklist, solutions) {
+  var _a;
+  if (!canRegenerateRanklist(originalRanklist)) {
+    throw new Error("The ranklist is not supported to regenerate");
+  }
+  const sorterConfig = {
+    penalty: [20, "min"],
+    noPenaltyResults: ["FB", "AC", "?", "CE", "UKE", null],
+    timeRounding: "floor",
+    ...JSON.parse(JSON.stringify(((_a = originalRanklist.sorter) == null ? void 0 : _a.config) || {}))
+  };
+  const userRowIndexMap = /* @__PURE__ */ new Map();
+  const rows = [...originalRanklist.rows];
+  rows.forEach((row, index) => {
+    const userId = row.user.id && `${row.user.id}` || `${typeof row.user.name === "string" ? row.user.name : JSON.stringify(row.user.name)}`;
+    userRowIndexMap.set(userId, index);
+  });
+  const clonedRowMap = /* @__PURE__ */ new Set();
+  const clonedRowStatusMap = /* @__PURE__ */ new Set();
+  for (const tetrad of solutions) {
+    const [userId, problemIndex, result, time] = tetrad;
+    let rowIndex = userRowIndexMap.get(userId);
+    if (rowIndex === void 0) {
+      console.error(`Invalid user id ${userId} found when regenerating ranklist`);
+      break;
+    }
+    let row = rows[rowIndex];
+    if (!clonedRowMap.has(userId)) {
+      row = { ...row };
+      row.score = { ...row.score };
+      row.statuses = [...row.statuses];
+      rows[rowIndex] = row;
+      clonedRowMap.add(userId);
+    }
+    if (!clonedRowStatusMap.has(`${userId}_${problemIndex}`)) {
+      row.statuses[problemIndex] = { ...row.statuses[problemIndex] };
+      row.statuses[problemIndex].solutions = [...row.statuses[problemIndex].solutions];
+      clonedRowStatusMap.add(`${userId}_${problemIndex}`);
+    }
+    const status = row.statuses[problemIndex];
+    status.solutions.push({ result, time });
+    if (status.result === "AC" || status.result === "FB") {
+      continue;
+    }
+    if (result === "?") {
+      status.result = result;
+      status.tries = (status.tries || 0) + 1;
+      continue;
+    }
+    if (result === "AC" || result === "FB") {
+      status.result = result;
+      status.time = time;
+      status.tries = (status.tries || 0) + 1;
+      row.score.value += 1;
+      const targetTime = [
+        formatTimeDuration(
+          status.time,
+          sorterConfig.timePrecision || "ms",
+          sorterConfig.timeRounding === "ceil" ? Math.ceil : sorterConfig.timeRounding === "round" ? Math.round : Math.floor
+        ),
+        sorterConfig.timePrecision || "ms"
+      ];
+      const totalTime = formatTimeDuration(row.score.time, "ms") || 0;
+      row.score.time = [
+        totalTime + formatTimeDuration(targetTime, "ms") + (status.tries - 1) * formatTimeDuration(sorterConfig.penalty, "ms"),
+        "ms"
+      ];
+      continue;
+    }
+    if ((sorterConfig.noPenaltyResults || []).includes(result)) {
+      continue;
+    }
+    status.result = "RJ";
+    status.tries = (status.tries || 0) + 1;
+  }
+  return sortRows(rows);
+}
+function genSeriesCalcFns(series, rows, ranks, officialRanks) {
+  const fallbackSeriesCalcFn = () => ({
+    rank: null,
+    segmentIndex: null
+  });
+  const fns = series.map((seriesConfig) => {
+    const { rule } = seriesConfig;
+    if (!rule) {
+      return fallbackSeriesCalcFn;
+    }
+    const { preset } = rule;
+    switch (preset) {
+      case "Normal": {
+        const options = rule.options;
+        return (row, index) => {
+          if ((options == null ? void 0 : options.includeOfficialOnly) && row.user.official === false) {
+            return {
+              rank: null,
+              segmentIndex: null
+            };
+          }
+          return {
+            rank: (options == null ? void 0 : options.includeOfficialOnly) ? officialRanks[index] : ranks[index],
+            segmentIndex: null
+          };
+        };
+      }
+      case "UniqByUserField": {
+        const options = rule.options;
+        const field = options == null ? void 0 : options.field;
+        const assignedRanksMap = /* @__PURE__ */ new Map();
+        const valueSet = /* @__PURE__ */ new Set();
+        const stringify = (v) => typeof v === "object" ? JSON.stringify(v) : `${v}`;
+        let lastOuterRank = 0;
+        let lastRank = 0;
+        rows.forEach((row, index) => {
+          if (options.includeOfficialOnly && row.user.official === false) {
+            return;
+          }
+          const value = stringify(row.user[field]);
+          if (value && !valueSet.has(value)) {
+            const outerRank = options.includeOfficialOnly ? officialRanks[index] : ranks[index];
+            valueSet.add(value);
+            if (outerRank !== lastOuterRank) {
+              lastOuterRank = outerRank;
+              lastRank = assignedRanksMap.size + 1;
+              assignedRanksMap.set(index, lastRank);
+            }
+            assignedRanksMap.set(index, lastRank);
+          }
+        });
+        return (row, index) => {
+          var _a;
+          return {
+            rank: (_a = assignedRanksMap.get(index)) != null ? _a : null,
+            segmentIndex: null
+          };
+        };
+      }
+      case "ICPC": {
+        const options = rule.options;
+        let filteredRows = rows.filter((row) => row.user.official === void 0 || row.user.official === true);
+        let filteredOfficialRanks = [...officialRanks];
+        if (options.filter) {
+          if (Array.isArray(options.filter.byUserFields) && options.filter.byUserFields.length) {
+            const currentFilteredRows = [];
+            filteredOfficialRanks = filteredOfficialRanks.map(() => null);
+            let currentOfficialRank2 = 0;
+            let currentOfficialRankOld = 0;
+            rows.forEach((row, index) => {
+              const shouldInclude = options.filter.byUserFields.every((filter) => {
+                const { field, rule: rule2 } = filter;
+                const value = row.user[field];
+                if (value === void 0) {
+                  return false;
+                }
+                return new RegExp(rule2).test(`${value}`);
+              });
+              if (shouldInclude) {
+                currentFilteredRows.push(row);
+                const oldRank = officialRanks[index];
+                if (oldRank !== null) {
+                  if (currentOfficialRankOld !== oldRank) {
+                    currentOfficialRank2++;
+                    currentOfficialRankOld = oldRank;
+                  }
+                  filteredOfficialRanks[index] = currentOfficialRank2;
+                } else {
+                  filteredOfficialRanks[index] = null;
+                }
+              }
+            });
+            filteredRows = currentFilteredRows;
+          }
+        }
+        const usingEndpointRules = [];
+        let noTied = false;
+        if (options.ratio) {
+          const { value, rounding = "ceil", denominator = "all" } = options.ratio;
+          const officialRows = filteredRows;
+          let total = denominator === "submitted" ? officialRows.filter((row) => !row.statuses.every((s) => s.result === null)).length : officialRows.length;
+          const accValues = [];
+          for (let i = 0; i < value.length; i++) {
+            if (i === 0) {
+              accValues[i] = new BigNumber(value[i]);
+            } else {
+              accValues[i] = accValues[i - 1].plus(new BigNumber(value[i]));
+            }
+          }
+          const segmentRawEndpoints = accValues.map((v) => v.times(total).toNumber());
+          usingEndpointRules.push(
+            segmentRawEndpoints.map((v) => {
+              return rounding === "floor" ? Math.floor(v) : rounding === "round" ? Math.round(v) : Math.ceil(v);
+            })
+          );
+          if (options.ratio.noTied) {
+            noTied = true;
+          }
+        }
+        if (options.count) {
+          const { value } = options.count;
+          const accValues = [];
+          for (let i = 0; i < value.length; i++) {
+            accValues[i] = (i > 0 ? accValues[i - 1] : 0) + value[i];
+          }
+          usingEndpointRules.push(accValues);
+          if (options.count.noTied) {
+            noTied = true;
+          }
+        }
+        const officialRanksNoTied = [];
+        let currentOfficialRank = 0;
+        for (let i = 0; i < filteredOfficialRanks.length; i++) {
+          officialRanksNoTied.push(filteredOfficialRanks[i] === null ? null : ++currentOfficialRank);
+        }
+        return (row, index) => {
+          if (row.user.official === false || !filteredRows.find((r) => r.user.id === row.user.id)) {
+            return {
+              rank: null,
+              segmentIndex: null
+            };
+          }
+          const usingSegmentIndex = (seriesConfig.segments || []).findIndex((_, segIndex) => {
+            return usingEndpointRules.map((e) => e[segIndex]).every((endpoints) => (noTied ? officialRanksNoTied : filteredOfficialRanks)[index] <= endpoints);
+          });
+          return {
+            rank: filteredOfficialRanks[index],
+            segmentIndex: usingSegmentIndex > -1 ? usingSegmentIndex : null
+          };
+        };
+      }
+      default:
+        console.warn("Unknown series rule preset\uFF1A", preset);
+        return fallbackSeriesCalcFn;
+    }
+  });
+  return fns;
+}
+function genRowRanks(rows) {
+  const compareScoreEqual = (a, b) => {
+    if (a.value !== b.value) {
+      return false;
+    }
+    const da = a.time ? formatTimeDuration(a.time) : 0;
+    const db = b.time ? formatTimeDuration(b.time) : 0;
+    return da === db;
+  };
+  const genRanks = (rows2) => {
+    let ranks2 = new Array(rows2.length).fill(null);
+    for (let i = 0; i < rows2.length; ++i) {
+      if (i === 0) {
+        ranks2[i] = 1;
+        continue;
+      }
+      if (compareScoreEqual(rows2[i].score, rows2[i - 1].score)) {
+        ranks2[i] = ranks2[i - 1];
+      } else {
+        ranks2[i] = i + 1;
+      }
+    }
+    return ranks2;
+  };
+  const ranks = genRanks(rows);
+  const officialPartialRows = [];
+  const officialIndexBackMap = /* @__PURE__ */ new Map();
+  rows.forEach((row, index) => {
+    if (row.user.official !== false) {
+      officialIndexBackMap.set(index, officialPartialRows.length);
+      officialPartialRows.push(row);
+    }
+  });
+  const officialPartialRanks = genRanks(officialPartialRows);
+  const officialRanks = new Array(rows.length).fill(null).map(
+    (_, index) => officialIndexBackMap.get(index) === void 0 ? null : officialPartialRanks[officialIndexBackMap.get(index)]
+  );
+  return {
+    ranks,
+    officialRanks
+  };
+}
+function convertToStaticRanklist(ranklist) {
+  if (!ranklist) {
+    return ranklist;
+  }
+  const { series, rows } = ranklist;
+  const rowRanks = genRowRanks(rows);
+  const seriesCalcFns = genSeriesCalcFns(series, rows, rowRanks.ranks, rowRanks.officialRanks);
+  return {
+    ...ranklist,
+    rows: rows.map((row, index) => {
+      return {
+        ...row,
+        rankValues: seriesCalcFns.map((fn) => fn(row, index))
+      };
+    })
+  };
+}
+
+exports.EnumTheme = EnumTheme;
+exports.MIN_REGEN_SUPPORTED_VERSION = MIN_REGEN_SUPPORTED_VERSION;
+exports.alphabetToNumber = alphabetToNumber;
+exports.canRegenerateRanklist = canRegenerateRanklist;
+exports.convertToStaticRanklist = convertToStaticRanklist;
+exports.filterSolutionsUntil = filterSolutionsUntil;
+exports.formatTimeDuration = formatTimeDuration;
+exports.getSortedCalculatedRawSolutions = getSortedCalculatedRawSolutions;
+exports.numberToAlphabet = numberToAlphabet;
+exports.preZeroFill = preZeroFill;
+exports.regenerateRanklistBySolutions = regenerateRanklistBySolutions;
+exports.regenerateRowsByIncrementalSolutions = regenerateRowsByIncrementalSolutions;
+exports.resolveColor = resolveColor;
+exports.resolveContributor = resolveContributor;
+exports.resolveStyle = resolveStyle;
+exports.resolveText = resolveText;
+exports.resolveThemeColor = resolveThemeColor;
+exports.secToTimeStr = secToTimeStr;
+exports.sortRows = sortRows;