@shzlx/ui-default 4.58.2

package/constant/record.js

@@ -0,0 +1,52 @@
+// Please note that accepted < others, rp system uses this feature.
+import { STATUS } from '@hydrooj/common';
+export { STATUS, STATUS_TEXTS } from '@hydrooj/common';
+
+export const STATUS_CODES = {
+  [STATUS.STATUS_WAITING]: 'pending',
+  [STATUS.STATUS_ACCEPTED]: 'pass',
+  [STATUS.STATUS_WRONG_ANSWER]: 'fail',
+  [STATUS.STATUS_TIME_LIMIT_EXCEEDED]: 'fail',
+  [STATUS.STATUS_MEMORY_LIMIT_EXCEEDED]: 'fail',
+  [STATUS.STATUS_OUTPUT_LIMIT_EXCEEDED]: 'fail',
+  [STATUS.STATUS_RUNTIME_ERROR]: 'fail',
+  [STATUS.STATUS_COMPILE_ERROR]: 'fail',
+  [STATUS.STATUS_SYSTEM_ERROR]: 'fail',
+  [STATUS.STATUS_CANCELED]: 'ignored',
+  [STATUS.STATUS_ETC]: 'fail',
+  [STATUS.STATUS_JUDGING]: 'progress',
+  [STATUS.STATUS_COMPILING]: 'progress',
+  [STATUS.STATTUS_FETCHED]: 'progress',
+  [STATUS.STATUS_IGNORED]: 'ignored',
+};
+
+/**
+ * Whether to show detail about each test case for a submission status
+ */
+export const STATUS_SCRATCHPAD_SHOW_DETAIL_FLAGS = {
+  [STATUS.STATUS_WAITING]: false,
+  [STATUS.STATUS_ACCEPTED]: true,
+  [STATUS.STATUS_WRONG_ANSWER]: true,
+  [STATUS.STATUS_TIME_LIMIT_EXCEEDED]: true,
+  [STATUS.STATUS_MEMORY_LIMIT_EXCEEDED]: true,
+  [STATUS.STATUS_RUNTIME_ERROR]: true,
+  [STATUS.STATUS_COMPILE_ERROR]: false,
+  [STATUS.STATUS_SYSTEM_ERROR]: false,
+  [STATUS.STATUS_CANCELED]: false,
+  [STATUS.STATUS_ETC]: false,
+  [STATUS.STATUS_JUDGING]: false,
+  [STATUS.STATUS_COMPILING]: false,
+  [STATUS.STATUS_FETCHED]: false,
+  [STATUS.STATUS_IGNORED]: false,
+};
+
+/**
+ * Short text to show in Scratchpad mode
+ */
+export const STATUS_SCRATCHPAD_SHORT_TEXTS = {
+  [STATUS.STATUS_ACCEPTED]: 'AC',
+  [STATUS.STATUS_WRONG_ANSWER]: 'WA',
+  [STATUS.STATUS_TIME_LIMIT_EXCEEDED]: 'TLE',
+  [STATUS.STATUS_MEMORY_LIMIT_EXCEEDED]: 'MLE',
+  [STATUS.STATUS_RUNTIME_ERROR]: 'RTE',
+};

package/context.ts

@@ -0,0 +1,11 @@
+import { Context } from 'cordis';
+import type { EventMap } from './api';
+
+declare module 'cordis' {
+  export interface Events extends EventMap { }
+}
+
+export type { Disposable, Plugin } from 'cordis';
+export { Context, Fiber, FiberState, Service } from 'cordis';
+
+export const ctx = new Context();

package/entry.js

@@ -0,0 +1,72 @@
+import './polyfill';
+
+import $ from 'jquery';
+
+window.Hydro = {
+  extraPages: [],
+  components: {},
+  version: process.env.VERSION,
+};
+window.externalModules = {};
+window.lazyModuleResolver = {};
+
+console.log(
+  '%c%s%c%s',
+  'color:red;font-size:24px;',
+  '   Welcome to\n',
+  'color:blue;font-weight:bold;',
+  `\
+    __  __          __         
+   / / / /_  ______/ /________ 
+  / /_/ / / / / __  / ___/ __ \\
+ / __  / /_/ / /_/ / /  / /_/ /
+/_/ /_/\\__, /\\__,_/_/   \\____/ 
+      /____/                   
+`,
+);
+
+window.UiContext = JSON.parse(window.UiContext);
+window.UserContext = JSON.parse(window.UserContext);
+try {
+  __webpack_public_path__ = UiContext.cdn_prefix;
+} catch (e) { }
+if ('serviceWorker' in navigator) {
+  const sendConfig = () => fetch('/service-worker-config', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(UiContext.SWConfig),
+  });
+  navigator.serviceWorker.register('/service-worker.js').then((registration) => {
+    console.log('SW registered: ', registration);
+    const sw = registration.active || registration.waiting || registration.installing;
+    if (sw.state === 'activated') sendConfig();
+    else {
+      sw.addEventListener('statechange', (e) => {
+        if (e.target.state === 'activated') sendConfig();
+      });
+    }
+  }).catch((registrationError) => {
+    console.log('SW registration failed: ', registrationError);
+  });
+}
+
+const PageLoader = '<div class="page-loader nojs--hide" style="display:none;"><div class="loader"></div></div>';
+$('body').prepend(PageLoader);
+$('.page-loader').fadeIn(500);
+if (process.env.NODE_ENV === 'production' && UiContext.sentry_dsn) {
+  window._sentryEvents = [];
+  window.captureException = (e) => {
+    if (!e.isUserFacingError) window._sentryEvents.push(e);
+  };
+  const script = document.createElement('script');
+  script.src = '/sentry.js';
+  document.body.appendChild(script);
+}
+
+document.addEventListener('DOMContentLoaded', async () => {
+  Object.assign(window.UiContext, JSON.parse(window.UiContextNew));
+  Object.assign(window.UserContext, JSON.parse(window.UserContextNew));
+  window.HydroExports = await import('./api');
+  await window._hydroLoad();
+  await window.HydroExports.initPageLoader();
+}, false);

package/hydro.ts

@@ -0,0 +1,112 @@
+import 'jquery.transit';
+
+import $ from 'jquery';
+import _ from 'lodash';
+import Notification from 'vj/components/notification';
+import PageLoader from 'vj/misc/PageLoader';
+import { delay } from 'vj/utils';
+
+declare global {
+  interface Window {
+    UserContext: any;
+    UiContext: any;
+    Hydro: any;
+    /** @deprecated */
+    externalModules: Record<string, string>;
+    captureException?: (e: Error) => void;
+  }
+}
+
+const start = new Date();
+
+function buildSequence(pages, type) {
+  if (process.env.NODE_ENV !== 'production') {
+    if (!['before', 'after'].includes(type)) {
+      throw new Error("'type' should be one of 'before' or 'after'");
+    }
+  }
+  return pages
+    .filter((p) => p && p[`${type}Loading`])
+    .map((p) => ({
+      page: p,
+      func: p[`${type}Loading`],
+      type,
+    }));
+}
+
+function rounded() {
+  if (!UserContext.rounded) return;
+  const style = document.createElement('style');
+  style.innerHTML = `
+    .section { border-radius: 8px; }
+    .section__table-header { border-radius: 8px 8px 0 0; }
+  `;
+  document.head.append(style);
+}
+
+async function animate() {
+  if (UserContext.skipAnimate) return;
+  const style = document.createElement('style');
+  style.innerHTML = `.section {
+    transition: transform .5s, opacity .5s;
+    transition-timing-function: ease-out-cubic;
+  }`;
+  document.head.append(style);
+  const sections = _.map($('.section').get(), (section, idx) => ({
+    shouldDelay: idx < 5, // only animate first 5 sections
+    $element: $(section),
+  }));
+  for (const { $element, shouldDelay } of sections) {
+    $element.addClass('visible');
+    if (shouldDelay) await delay(50);
+  }
+}
+
+export async function initPageLoader() {
+  const pageLoader = new PageLoader();
+  rounded();
+
+  const currentPageName = document.documentElement.getAttribute('data-page');
+  const currentPage = pageLoader.getNamedPage(currentPageName);
+  const includedPages = pageLoader.getAutoloadPages();
+  const loadSequence = [
+    ...buildSequence(includedPages, 'before'),
+    ...buildSequence(currentPage, 'before'),
+    ...buildSequence(includedPages, 'after'),
+    ...buildSequence(currentPage, 'after'),
+  ];
+  const loadPage = (depth: number, type: 'before' | 'after') => async (name: string) => {
+    if (depth > 32) {
+      console.error('loadPage depth', depth);
+      return;
+    }
+    for (const { func } of buildSequence(pageLoader.getPage(name), type)) {
+      await func(name, loadPage(depth + 1, type));
+    }
+  };
+  for (const { page, func, type } of loadSequence) {
+    const ts = Date.now();
+    try {
+      await func(currentPageName, loadPage(1, type));
+    } catch (e) {
+      (window as any).captureException?.(e);
+      Notification.warn(`Failed to call '${type}Loading' of ${page.name}`);
+      console.error(`Failed to call '${type}Loading' of ${page.name}\n${e.stack}`);
+      console.error(e);
+    }
+    if (process.env.NODE_ENV !== 'production') {
+      console.time(`${page.name}: ${type}Loading`);
+    }
+    const time = Date.now() - ts;
+    if ((process.env.NODE_ENV !== 'production' && time > 16) || time > 256) {
+      console.log(`${page.name}: ${type}Loading took ${time}ms`);
+    }
+  }
+  console.log('done! %d ms', Date.now() - start.getTime());
+  $('.page-loader').hide();
+  await animate();
+  $('.section').addClass('visible');
+  await delay(500);
+  $('.section').trigger('vjLayout');
+  $(document).trigger('vjPageFullyInitialized');
+}

package/index.ts

@@ -0,0 +1,226 @@
+import { readFileSync } from 'fs';
+import { join } from 'path';
+import {
+  ContestModel, Context, Handler, ObjectId, param, PERM, PRIV, ProblemModel, Schema,
+  SettingModel, SystemModel, Types, UserModel, yaml,
+} from 'hydrooj';
+import convert from 'schemastery-jsonschema';
+import markdown from './backendlib/markdown';
+import { TemplateService } from './backendlib/template';
+
+class WikiHelpHandler extends Handler {
+  noCheckPermView = true;
+
+  async get() {
+    this.response.template = 'wiki_help.html';
+  }
+}
+
+class WikiAboutHandler extends Handler {
+  noCheckPermView = true;
+
+  async get() {
+    let raw = SystemModel.get('ui-default.about') || '';
+    // TODO template engine
+    raw = raw.replace(/\{\{ name \}\}/g, this.domain.ui?.name || SystemModel.get('server.name')).trim();
+    const lines = raw.split('\n');
+    const sections: { id: string, title: string, content: string }[] = [];
+    for (const line of lines) {
+      if (line.startsWith('# ')) {
+        const id = line.split(' ')[1];
+        sections.push({
+          id,
+          title: line.split(id)[1].trim(),
+          content: '',
+        });
+      } else sections[sections.length - 1].content += `${line}\n`;
+    }
+    this.response.template = 'about.html';
+    this.response.body = { sections };
+  }
+}
+
+class SetThemeHandler extends Handler {
+  noCheckPermView = true;
+
+  async get({ theme }) {
+    this.checkPriv(PRIV.PRIV_USER_PROFILE);
+    await UserModel.setById(this.user._id, { theme });
+    this.back();
+  }
+}
+
+class LegacyModeHandler extends Handler {
+  noCheckPermView = true;
+
+  @param('legacy', Types.Boolean)
+  @param('nohint', Types.Boolean)
+  async get({ }, legacy = false, nohint = false) {
+    this.session.legacy = legacy;
+    this.session.nohint = nohint;
+    this.back();
+  }
+}
+
+class MarkdownHandler extends Handler {
+  noCheckPermView = true;
+
+  async post({ text, inline = false }) {
+    this.response.body = inline
+      ? markdown.renderInline(text)
+      : markdown.render(text);
+    this.response.type = 'text/html';
+    this.response.status = 200;
+  }
+}
+
+class SystemConfigSchemaHandler extends Handler {
+  async get() {
+    const schema = convert(Schema.intersect(this.ctx.setting.settings) as any, true);
+    this.response.body = schema;
+  }
+}
+
+class RichMediaHandler extends Handler {
+  async renderUser(domainId, payload) {
+    let d = payload.domainId || domainId;
+    const cur = payload.domainId ? await UserModel.getById(payload.domainId, this.user._id) : this.user;
+    if (!cur.hasPerm(PERM.PERM_VIEW)) d = domainId;
+    const udoc = Number.isNaN(+payload.id) ? await UserModel.getByUname(d, payload.id) : await UserModel.getById(d, +payload.id);
+    return await this.renderHTML('partials/user.html', { udoc });
+  }
+
+  async renderProblem(domainId, payload) {
+    const cur = payload.domainId ? await UserModel.getById(payload.domainId, this.user._id) : this.user;
+    let pdoc = cur.hasPerm(PERM.PERM_VIEW | PERM.PERM_VIEW_PROBLEM)
+      ? await ProblemModel.get(payload.domainId || domainId, payload.id) || ProblemModel.default
+      : ProblemModel.default;
+    if (pdoc.hidden && !cur.own(pdoc) && !cur.hasPerm(PERM.PERM_VIEW_PROBLEM_HIDDEN)) pdoc = ProblemModel.default;
+    return await this.renderHTML('partials/problem.html', { pdoc });
+  }
+
+  async renderContest(domainId, payload) {
+    const cur = payload.domainId ? await UserModel.getById(payload.domainId, this.user._id) : this.user;
+    const tdoc = cur.hasPerm(PERM.PERM_VIEW | PERM.PERM_VIEW_CONTEST)
+      ? await ContestModel.get(payload.domainId || domainId, new ObjectId(payload.id))
+      : null;
+    if (tdoc) return await this.renderHTML('partials/contest.html', { tdoc });
+    return '';
+  }
+
+  async renderHomework(domainId, payload) {
+    const cur = payload.domainId ? await UserModel.getById(payload.domainId, this.user._id) : this.user;
+    const tdoc = cur.hasPerm(PERM.PERM_VIEW | PERM.PERM_VIEW_HOMEWORK)
+      ? await ContestModel.get(payload.domainId || domainId, new ObjectId(payload.id))
+      : null;
+    if (tdoc) return await this.renderHTML('partials/homework.html', { tdoc });
+    return '';
+  }
+
+  async post({ domainId, items }) {
+    const res: any[] = [];
+    for (const item of items || []) {
+      if (item.domainId && item.domainId === domainId) delete item.domainId;
+      if (item.type === 'user') res.push(this.renderUser(domainId, item).catch(() => ''));
+      else if (item.type === 'problem') res.push(this.renderProblem(domainId, item).catch(() => ''));
+      else if (item.type === 'contest') res.push(this.renderContest(domainId, item).catch(() => ''));
+      else if (item.type === 'homework') res.push(this.renderHomework(domainId, item).catch(() => ''));
+      else res.push('');
+    }
+    this.response.body = await Promise.all(res);
+  }
+}
+
+/* eslint-disable style/quote-props */
+const fontRange = {
+  'Open Sans': 'Open Sans',
+  'Seravek': 'Seravek',
+  'Segoe UI': 'Segoe UI',
+  'Verdana': 'Verdana',
+  'PingFang SC': 'PingFang SC',
+  'Hiragino Sans GB': 'Hiragino Sans GB',
+  'Microsoft Yahei': 'Microsoft Yahei',
+  'WenQuanYi Micro Hei': 'WenQuanYi Micro Hei',
+  'sans': 'sans',
+  'XiaoLai SC': '小赖 SC',
+};
+const codeFontRange = {
+  'monaco': 'Monaco',
+  'Source Code Pro': 'Source Code Pro',
+  'Consolas': 'Consolas',
+  'Lucida Console': 'Lucida Console',
+  'Fira Code': 'Fira Code',
+  'Roboto Mono': 'Roboto Mono',
+  'Inconsolata': 'Inconsolata',
+  'Hack': 'Hack',
+  'Jetbrains Mono': 'Jetbrains Mono',
+  'DM Mono': 'DM Mono',
+  'Ubuntu Mono': 'Ubuntu Mono',
+  'PT Mono': 'PT Mono',
+  'SF Mono': 'SF Mono',
+};
+
+const defaultAbout = (yaml.load(readFileSync(join(__dirname, 'setting.yaml'), 'utf-8')) as any).about.value;
+
+export const name = 'ui-default';
+export const Config = Schema.object({
+  serviceWorker: Schema.object({
+    preload: Schema.string().default(''),
+    assets: Schema.array(Schema.string()).default([]),
+    domains: Schema.array(Schema.string()).default([]),
+  }).description('Service worker optimization settings').experimental(),
+});
+
+export function apply(ctx: Context, config: ReturnType<typeof Config>) {
+  ctx.inject(['setting'], (c) => {
+    c.setting.PreferenceSetting(
+      SettingModel.Setting('setting_display', 'rounded', false, 'boolean', 'Rounded Corners'),
+      SettingModel.Setting('setting_display', 'skipAnimate', false, 'boolean', 'Skip Animation'),
+      SettingModel.Setting('setting_display', 'showTimeAgo', true, 'boolean', 'Enable Time Ago'),
+      SettingModel.Setting('setting_display', 'fontFamily', 'Open Sans', fontRange, 'Font Family'),
+      SettingModel.Setting('setting_display', 'codeFontFamily', 'Source Code Pro', codeFontRange, 'Code Font Family'),
+      SettingModel.Setting('setting_display', 'theme', 'light', { light: 'Light', dark: 'Dark' }, 'Theme'),
+      SettingModel.Setting('setting_markdown', 'preferredEditorType', 'sv', { sv: 'Split View', monaco: 'Monaco Editor' }, 'Preferred Editor Type'),
+      SettingModel.Setting('setting_highlight', 'showInvisibleChar', false, 'boolean', 'Show Invisible Characters'),
+      SettingModel.Setting('setting_highlight', 'formatCode', true, 'boolean', 'Auto Format Code'),
+    );
+    c.setting.SystemSetting(Schema.object({
+      'ui-default': Schema.object({
+        footer_extra_html: Schema.string().role('textarea').default(''),
+        nav_logo_dark: Schema.string().default('/components/navigation/nav-logo-small_dark.png'),
+        domainNavigation: Schema.boolean().default(true).description('Show Domain Navigation'),
+        about: Schema.string().role('markdown').default(defaultAbout),
+        enableScratchpad: Schema.boolean().default(true).description('Enable Scratchpad Mode'),
+      }),
+    }));
+    ctx.Route('config_schema', '/manage/config/schema.json', SystemConfigSchemaHandler, PRIV.PRIV_EDIT_SYSTEM);
+  });
+  if (process.env.HYDRO_CLI) return;
+  ctx.Route('wiki_help', '/wiki/help', WikiHelpHandler);
+  ctx.Route('wiki_about', '/wiki/about', WikiAboutHandler);
+  ctx.Route('set_theme', '/set_theme/:theme', SetThemeHandler);
+  ctx.Route('set_legacy', '/legacy', LegacyModeHandler);
+  ctx.Route('markdown', '/markdown', MarkdownHandler);
+  ctx.Route('media', '/media', RichMediaHandler);
+  ctx.on('handler/after/DiscussionRaw', async (that) => {
+    if (that.args.render && that.response.type === 'text/markdown') {
+      that.response.type = 'text/html';
+      that.response.body = await markdown.render(that.response.body);
+    }
+  });
+  ctx.on('handler/after', async (that) => {
+    that.UiContext.SWConfig = {
+      preload: config.serviceWorker.preload,
+      hosts: [
+        `http://${that.request.host}`,
+        `https://${that.request.host}`,
+        SystemModel.get('server.url'),
+        SystemModel.get('server.cdn'),
+      ],
+      assets: config.serviceWorker.assets,
+      domains: config.serviceWorker.domains,
+    };
+  });
+  ctx.plugin(TemplateService);
+  ctx.plugin(require('./backendlib/builder'));
+}

package/lazyload.ts

@@ -0,0 +1,69 @@
+const lazyModules = {};
+const features: Record<string, string | (() => Promise<any>)> = {};
+const host = UiContext.cdn_dynamic ? UiContext.cdn_prefix : '/';
+export default async function load(name: string) {
+  if (name === 'echarts') return import('echarts');
+  if (name === 'moment') return import('moment');
+  if (!window.lazyloadMetadata?.[`${name}.lazy.js`]) throw new Error(`Module ${name} not found`);
+  if (lazyModules[name]) return lazyModules[name];
+  const tag = document.createElement('script');
+  tag.src = `${host}lazy/${window.lazyloadMetadata[`${name}.lazy.js`]}/${name}.lazy.js`;
+  console.log('loading module: ', name);
+  lazyModules[name] = new Promise((resolve, reject) => {
+    tag.onerror = reject;
+    const timeout = setTimeout(reject, 30000);
+    window.lazyModuleResolver[name] = (item) => {
+      clearTimeout(timeout);
+      resolve(item);
+    };
+  });
+  document.body.appendChild(tag);
+  return lazyModules[name];
+}
+
+const val: Record<string, any> = {};
+/** @deprecated */
+async function legacyLoadExternalModule(target: string) {
+  if (val[target]) return val[target];
+  const ele = document.createElement('script');
+  ele.src = target;
+  await new Promise((resolve, reject) => {
+    ele.onload = resolve;
+    ele.onerror = reject;
+    document.head.appendChild(ele);
+  });
+  val[target] = window.exports;
+  return val[target];
+}
+
+export { load };
+export async function getFeatures(name: string) {
+  const legacy = Object.keys(window.externalModules).filter((i) => i === name || i.startsWith(`${name}@`))
+    .map((i) => window.externalModules[i]);
+  const c = Object.keys(features).filter((i) => i === name || i.startsWith(`${name}@`))
+    .map((i) => features[i]);
+  console.log('query features for:', name, 'legacy:', legacy, 'selected:', c, 'all:', features);
+  return [...c, ...legacy];
+}
+
+export const loaded = [];
+export async function loadFeatures(name: string, ...args: any[]) {
+  if (loaded.includes(name)) return;
+  loaded.push(name);
+  for (const item of await getFeatures(name)) {
+    let apply = typeof item === 'function'
+      ? item
+      : (item.startsWith('http') || item.startsWith('/'))
+        ? await legacyLoadExternalModule(item)
+        : (await load(item)).apply;
+    if (typeof apply !== 'function') apply = apply.default || apply.apply;
+    if (typeof apply === 'function') await apply(...args);
+  }
+}
+
+export function provideFeature(name: string, content: string | (() => Promise<any>)) {
+  console.debug('Providing feature', name);
+  if (features[name]) console.warn('Feature', name, 'already provided');
+  features[name] = content;
+  if (loaded.includes(name)) console.warn('Feature', name, 'already loaded');
+}

package/locales/en.yaml

@@ -0,0 +1,71 @@
+__langname: English
+'File IO: {0}': 'File IO: {0}'
+'Tip: You are entering sudo mode.': 'Tip: You are entering <a href="https://docs.github.com/articles/sudo-mode">sudo mode</a>.'
+Can be Extended For: Extension
+Current Status: Status
+Handled Requests: Req
+Hint::icon::difficulty: The difficulty of the problems in Hydro will be calculated by algorithm, depending on current submission, sometimes the difficulty may not so exact.
+Hint::icon::switch_account: As a superadmin, you can switch to anyone's account.
+manage: System Manage
+no_translation_warn: <blockquote class="warn">This part of content is under translation.</blockquote>
+page.problem_detail.sidebar.show_category: Click to Show
+page.training_detail.invalid_when_not_enrolled: You cannot view problem details unless enrolled.
+pager_first: « First
+pager_last: Last »
+pager_next: Next ›
+pager_previous: ‹ Previous
+perm_contest: Contests
+perm_discussion: Discussions
+perm_general: General
+perm_problem_solution: Problem Solutions
+perm_problem: Problems
+perm_record: Records
+perm_training: Trainings
+preferredPrefix_hint: This is used for re-organizing problem IDs. For example, if the ID of the problem in the problemset are P1001, P1002, P1003, and you set "T" in this option, those problem will be imported with ID T1001, T1002 and T1003.
+problem_create: Problem Create
+problem_edit: Problem Edit
+problem_import: Import Problem
+problem_main: Problem Set
+problem_solution: Problem Solution
+problem_submit: Problem Submit
+problem_type.communication: 'Type: Communication'
+problem_type.default: 'Type: Default'
+problem_type.interactive: 'Type: Interactive'
+problem_type.objective: 'Type: Objective'
+problem_type.remote_judge: 'Type: RemoteJudge'
+problem_type.submit_answer: 'Type: SubmitAnswer'
+problem-category-delim: '|'
+problem-subcategory-delim: ', '
+problem.import.additional_file: '## Additional Files'
+problem.import.hint: '## Hint'
+problem.import.input_format: '## Input Format'
+problem.import.limit_and_hint: '## Limits'
+problem.import.output_format: '## Output Format'
+problem.import.problem_description: '## Description'
+ranking: Ranking
+record_detail: Record Detail
+record_main: Record
+rpDetailText_contest: Contest
+rpDetailText_problem: Problem
+setting_customize: Customize
+setting_display: Display Preference
+setting_function: Function
+setting_info_domain: Personal Info
+setting_info: Personal Info
+setting_preference: Preference
+setting_privacy: Privacy
+setting_usage: Usage Preference
+sort::default: Default
+sort::recent: Recent
+tasks_list: Task list
+timeago_locale: en_US
+training_create: Training Create
+training_edit: Training Edit
+training_main: Training
+user_detail: User Detail
+user_login: Login
+user_logout: Logout
+user_lostpass: Lost Password
+user_register: Register
+wiki_help: Help
+You can also upload your avatar to Gravatar and it will be automatically updated here.: You can also upload your avatar to <a href="https://gravatar.com/">Gravatar</a> and it will be automatically updated here.