☰

AtCoder Auto Pager

Support finding a page on AtCoder standings

  1. // ==UserScript==
  2. // @name         AtCoder Auto Pager
  3. // @namespace    https://github.com/mihatsu-s/
  4. // @version      1.1.0
  5. // @description  Support finding a page on AtCoder standings
  6. // @author       Mihatsu
  7. // @license      MIT
  8. // @supportURL   https://github.com/mihatsu-s/atcoder-auto-pager/issues
  9. // @match        https://atcoder.jp/contests/*/standings
  10. // @match        https://atcoder.jp/contests/*/standings?*
  11. // @match        https://atcoder.jp/contests/*/standings/
  12. // @match        https://atcoder.jp/contests/*/standings/?*
  13. // @match        https://atcoder.jp/contests/*/standings/virtual
  14. // @match        https://atcoder.jp/contests/*/standings/virtual?*
  15. // @match        https://atcoder.jp/contests/*/standings/virtual/
  16. // @match        https://atcoder.jp/contests/*/standings/virtual/?*
  17. // @match        https://atcoder.jp/contests/*/results
  18. // @match        https://atcoder.jp/contests/*/results?*
  19. // @match        https://atcoder.jp/contests/*/results/
  20. // @match        https://atcoder.jp/contests/*/results/?*
  21. // @exclude      https://atcoder.jp/*/json
  22. // ==/UserScript==
  23.  
  24. /******/ (() => { // webpackBootstrap
  25. /******/ 	"use strict";
  26. /******/ 	var __webpack_modules__ = ({
  27.  
  28. /***/ 426:
  29. /***/ ((module, __webpack_exports__, __webpack_require__) => {
  30.  
  31. /* harmony export */ __webpack_require__.d(__webpack_exports__, {
  32. /* harmony export */   "Z": () => (__WEBPACK_DEFAULT_EXPORT__)
  33. /* harmony export */ });
  34. /* harmony import */ var _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(645);
  35. /* harmony import */ var _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_0__);
  36. // Imports
  37.  
  38. var ___CSS_LOADER_EXPORT___ = _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_0___default()(function(i){return i[1]});
  39. // Module
  40. ___CSS_LOADER_EXPORT___.push([module.id, "#vue-standings thead th, #vue-results thead th {\n    vertical-align: middle;\n}\n\n.auto-pager-input {\n    width: 100%;\n    font-size: 80%;\n    font-weight: normal;\n    border: 1px solid #ccc;\n    border-radius: 2px;\n}\n\n.auto-pager-input.error {\n    background-color: #fcc;\n}\n\n.auto-pager-input.active {\n    background-color: #cfc;\n    border-color: #6c6;\n    color: #093;\n}\n\n.auto-pager-input.watching {\n    background-color: #cef;\n    border-color: #9bd;\n    color: #17f;\n}\n", ""]);
  41. // Exports
  42. /* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___);
  43.  
  44.  
  45. /***/ }),
  46.  
  47. /***/ 645:
  48. /***/ ((module) => {
  49.  
  50.  
  51.  
  52. /*
  53.   MIT License http://www.opensource.org/licenses/mit-license.php
  54.   Author Tobias Koppers @sokra
  55. */
  56. // css base code, injected by the css-loader
  57. // eslint-disable-next-line func-names
  58. module.exports = function (cssWithMappingToString) {
  59.   var list = []; // return the list of modules as css string
  60.  
  61.   list.toString = function toString() {
  62.     return this.map(function (item) {
  63.       var content = cssWithMappingToString(item);
  64.  
  65.       if (item[2]) {
  66.         return "@media ".concat(item[2], " {").concat(content, "}");
  67.       }
  68.  
  69.       return content;
  70.     }).join("");
  71.   }; // import a list of modules into the list
  72.   // eslint-disable-next-line func-names
  73.  
  74.  
  75.   list.i = function (modules, mediaQuery, dedupe) {
  76.     if (typeof modules === "string") {
  77.       // eslint-disable-next-line no-param-reassign
  78.       modules = [[null, modules, ""]];
  79.     }
  80.  
  81.     var alreadyImportedModules = {};
  82.  
  83.     if (dedupe) {
  84.       for (var i = 0; i < this.length; i++) {
  85.         // eslint-disable-next-line prefer-destructuring
  86.         var id = this[i][0];
  87.  
  88.         if (id != null) {
  89.           alreadyImportedModules[id] = true;
  90.         }
  91.       }
  92.     }
  93.  
  94.     for (var _i = 0; _i < modules.length; _i++) {
  95.       var item = [].concat(modules[_i]);
  96.  
  97.       if (dedupe && alreadyImportedModules[item[0]]) {
  98.         // eslint-disable-next-line no-continue
  99.         continue;
  100.       }
  101.  
  102.       if (mediaQuery) {
  103.         if (!item[2]) {
  104.           item[2] = mediaQuery;
  105.         } else {
  106.           item[2] = "".concat(mediaQuery, " and ").concat(item[2]);
  107.         }
  108.       }
  109.  
  110.       list.push(item);
  111.     }
  112.   };
  113.  
  114.   return list;
  115. };
  116.  
  117. /***/ }),
  118.  
  119. /***/ 379:
  120. /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
  121.  
  122.  
  123.  
  124. var isOldIE = function isOldIE() {
  125.   var memo;
  126.   return function memorize() {
  127.     if (typeof memo === 'undefined') {
  128.       // Test for IE <= 9 as proposed by Browserhacks
  129.       // @see http://browserhacks.com/#hack-e71d8692f65334173fee715c222cb805
  130.       // Tests for existence of standard globals is to allow style-loader
  131.       // to operate correctly into non-standard environments
  132.       // @see https://github.com/webpack-contrib/style-loader/issues/177
  133.       memo = Boolean(window && document && document.all && !window.atob);
  134.     }
  135.  
  136.     return memo;
  137.   };
  138. }();
  139.  
  140. var getTarget = function getTarget() {
  141.   var memo = {};
  142.   return function memorize(target) {
  143.     if (typeof memo[target] === 'undefined') {
  144.       var styleTarget = document.querySelector(target); // Special case to return head of iframe instead of iframe itself
  145.  
  146.       if (window.HTMLIFrameElement && styleTarget instanceof window.HTMLIFrameElement) {
  147.         try {
  148.           // This will throw an exception if access to iframe is blocked
  149.           // due to cross-origin restrictions
  150.           styleTarget = styleTarget.contentDocument.head;
  151.         } catch (e) {
  152.           // istanbul ignore next
  153.           styleTarget = null;
  154.         }
  155.       }
  156.  
  157.       memo[target] = styleTarget;
  158.     }
  159.  
  160.     return memo[target];
  161.   };
  162. }();
  163.  
  164. var stylesInDom = [];
  165.  
  166. function getIndexByIdentifier(identifier) {
  167.   var result = -1;
  168.  
  169.   for (var i = 0; i < stylesInDom.length; i++) {
  170.     if (stylesInDom[i].identifier === identifier) {
  171.       result = i;
  172.       break;
  173.     }
  174.   }
  175.  
  176.   return result;
  177. }
  178.  
  179. function modulesToDom(list, options) {
  180.   var idCountMap = {};
  181.   var identifiers = [];
  182.  
  183.   for (var i = 0; i < list.length; i++) {
  184.     var item = list[i];
  185.     var id = options.base ? item[0] + options.base : item[0];
  186.     var count = idCountMap[id] || 0;
  187.     var identifier = "".concat(id, " ").concat(count);
  188.     idCountMap[id] = count + 1;
  189.     var index = getIndexByIdentifier(identifier);
  190.     var obj = {
  191.       css: item[1],
  192.       media: item[2],
  193.       sourceMap: item[3]
  194.     };
  195.  
  196.     if (index !== -1) {
  197.       stylesInDom[index].references++;
  198.       stylesInDom[index].updater(obj);
  199.     } else {
  200.       stylesInDom.push({
  201.         identifier: identifier,
  202.         updater: addStyle(obj, options),
  203.         references: 1
  204.       });
  205.     }
  206.  
  207.     identifiers.push(identifier);
  208.   }
  209.  
  210.   return identifiers;
  211. }
  212.  
  213. function insertStyleElement(options) {
  214.   var style = document.createElement('style');
  215.   var attributes = options.attributes || {};
  216.  
  217.   if (typeof attributes.nonce === 'undefined') {
  218.     var nonce =  true ? __webpack_require__.nc : 0;
  219.  
  220.     if (nonce) {
  221.       attributes.nonce = nonce;
  222.     }
  223.   }
  224.  
  225.   Object.keys(attributes).forEach(function (key) {
  226.     style.setAttribute(key, attributes[key]);
  227.   });
  228.  
  229.   if (typeof options.insert === 'function') {
  230.     options.insert(style);
  231.   } else {
  232.     var target = getTarget(options.insert || 'head');
  233.  
  234.     if (!target) {
  235.       throw new Error("Couldn't find a style target. This probably means that the value for the 'insert' parameter is invalid.");
  236.     }
  237.  
  238.     target.appendChild(style);
  239.   }
  240.  
  241.   return style;
  242. }
  243.  
  244. function removeStyleElement(style) {
  245.   // istanbul ignore if
  246.   if (style.parentNode === null) {
  247.     return false;
  248.   }
  249.  
  250.   style.parentNode.removeChild(style);
  251. }
  252. /* istanbul ignore next  */
  253.  
  254.  
  255. var replaceText = function replaceText() {
  256.   var textStore = [];
  257.   return function replace(index, replacement) {
  258.     textStore[index] = replacement;
  259.     return textStore.filter(Boolean).join('\n');
  260.   };
  261. }();
  262.  
  263. function applyToSingletonTag(style, index, remove, obj) {
  264.   var css = remove ? '' : obj.media ? "@media ".concat(obj.media, " {").concat(obj.css, "}") : obj.css; // For old IE
  265.  
  266.   /* istanbul ignore if  */
  267.  
  268.   if (style.styleSheet) {
  269.     style.styleSheet.cssText = replaceText(index, css);
  270.   } else {
  271.     var cssNode = document.createTextNode(css);
  272.     var childNodes = style.childNodes;
  273.  
  274.     if (childNodes[index]) {
  275.       style.removeChild(childNodes[index]);
  276.     }
  277.  
  278.     if (childNodes.length) {
  279.       style.insertBefore(cssNode, childNodes[index]);
  280.     } else {
  281.       style.appendChild(cssNode);
  282.     }
  283.   }
  284. }
  285.  
  286. function applyToTag(style, options, obj) {
  287.   var css = obj.css;
  288.   var media = obj.media;
  289.   var sourceMap = obj.sourceMap;
  290.  
  291.   if (media) {
  292.     style.setAttribute('media', media);
  293.   } else {
  294.     style.removeAttribute('media');
  295.   }
  296.  
  297.   if (sourceMap && typeof btoa !== 'undefined') {
  298.     css += "\n/*# sourceMappingURL=data:application/json;base64,".concat(btoa(unescape(encodeURIComponent(JSON.stringify(sourceMap)))), " */");
  299.   } // For old IE
  300.  
  301.   /* istanbul ignore if  */
  302.  
  303.  
  304.   if (style.styleSheet) {
  305.     style.styleSheet.cssText = css;
  306.   } else {
  307.     while (style.firstChild) {
  308.       style.removeChild(style.firstChild);
  309.     }
  310.  
  311.     style.appendChild(document.createTextNode(css));
  312.   }
  313. }
  314.  
  315. var singleton = null;
  316. var singletonCounter = 0;
  317.  
  318. function addStyle(obj, options) {
  319.   var style;
  320.   var update;
  321.   var remove;
  322.  
  323.   if (options.singleton) {
  324.     var styleIndex = singletonCounter++;
  325.     style = singleton || (singleton = insertStyleElement(options));
  326.     update = applyToSingletonTag.bind(null, style, styleIndex, false);
  327.     remove = applyToSingletonTag.bind(null, style, styleIndex, true);
  328.   } else {
  329.     style = insertStyleElement(options);
  330.     update = applyToTag.bind(null, style, options);
  331.  
  332.     remove = function remove() {
  333.       removeStyleElement(style);
  334.     };
  335.   }
  336.  
  337.   update(obj);
  338.   return function updateStyle(newObj) {
  339.     if (newObj) {
  340.       if (newObj.css === obj.css && newObj.media === obj.media && newObj.sourceMap === obj.sourceMap) {
  341.         return;
  342.       }
  343.  
  344.       update(obj = newObj);
  345.     } else {
  346.       remove();
  347.     }
  348.   };
  349. }
  350.  
  351. module.exports = function (list, options) {
  352.   options = options || {}; // Force single-tag solution on IE6-9, which has a hard limit on the # of <style>
  353.   // tags it will allow on a page
  354.  
  355.   if (!options.singleton && typeof options.singleton !== 'boolean') {
  356.     options.singleton = isOldIE();
  357.   }
  358.  
  359.   list = list || [];
  360.   var lastIdentifiers = modulesToDom(list, options);
  361.   return function update(newList) {
  362.     newList = newList || [];
  363.  
  364.     if (Object.prototype.toString.call(newList) !== '[object Array]') {
  365.       return;
  366.     }
  367.  
  368.     for (var i = 0; i < lastIdentifiers.length; i++) {
  369.       var identifier = lastIdentifiers[i];
  370.       var index = getIndexByIdentifier(identifier);
  371.       stylesInDom[index].references--;
  372.     }
  373.  
  374.     var newLastIdentifiers = modulesToDom(newList, options);
  375.  
  376.     for (var _i = 0; _i < lastIdentifiers.length; _i++) {
  377.       var _identifier = lastIdentifiers[_i];
  378.  
  379.       var _index = getIndexByIdentifier(_identifier);
  380.  
  381.       if (stylesInDom[_index].references === 0) {
  382.         stylesInDom[_index].updater();
  383.  
  384.         stylesInDom.splice(_index, 1);
  385.       }
  386.     }
  387.  
  388.     lastIdentifiers = newLastIdentifiers;
  389.   };
  390. };
  391.  
  392. /***/ })
  393.  
  394. /******/ 	});
  395. /************************************************************************/
  396. /******/ 	// The module cache
  397. /******/ 	var __webpack_module_cache__ = {};
  398. /******/ 	
  399. /******/ 	// The require function
  400. /******/ 	function __webpack_require__(moduleId) {
  401. /******/ 		// Check if module is in cache
  402. /******/ 		if(__webpack_module_cache__[moduleId]) {
  403. /******/ 			return __webpack_module_cache__[moduleId].exports;
  404. /******/ 		}
  405. /******/ 		// Create a new module (and put it into the cache)
  406. /******/ 		var module = __webpack_module_cache__[moduleId] = {
  407. /******/ 			id: moduleId,
  408. /******/ 			// no module.loaded needed
  409. /******/ 			exports: {}
  410. /******/ 		};
  411. /******/ 	
  412. /******/ 		// Execute the module function
  413. /******/ 		__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
  414. /******/ 	
  415. /******/ 		// Return the exports of the module
  416. /******/ 		return module.exports;
  417. /******/ 	}
  418. /******/ 	
  419. /************************************************************************/
  420. /******/ 	/* webpack/runtime/compat get default export */
  421. /******/ 	(() => {
  422. /******/ 		// getDefaultExport function for compatibility with non-harmony modules
  423. /******/ 		__webpack_require__.n = (module) => {
  424. /******/ 			var getter = module && module.__esModule ?
  425. /******/ 				() => (module['default']) :
  426. /******/ 				() => (module);
  427. /******/ 			__webpack_require__.d(getter, { a: getter });
  428. /******/ 			return getter;
  429. /******/ 		};
  430. /******/ 	})();
  431. /******/ 	
  432. /******/ 	/* webpack/runtime/define property getters */
  433. /******/ 	(() => {
  434. /******/ 		// define getter functions for harmony exports
  435. /******/ 		__webpack_require__.d = (exports, definition) => {
  436. /******/ 			for(var key in definition) {
  437. /******/ 				if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
  438. /******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
  439. /******/ 				}
  440. /******/ 			}
  441. /******/ 		};
  442. /******/ 	})();
  443. /******/ 	
  444. /******/ 	/* webpack/runtime/hasOwnProperty shorthand */
  445. /******/ 	(() => {
  446. /******/ 		__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
  447. /******/ 	})();
  448. /******/ 	
  449. /************************************************************************/
  450. var __webpack_exports__ = {};
  451. // This entry need to be wrapped in an IIFE because it need to be isolated against other modules in the chunk.
  452. (() => {
  453.  
  454. // EXTERNAL MODULE: ./node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js
  455. var injectStylesIntoStyleTag = __webpack_require__(379);
  456. var injectStylesIntoStyleTag_default = /*#__PURE__*/__webpack_require__.n(injectStylesIntoStyleTag);
  457. // EXTERNAL MODULE: ./node_modules/css-loader/dist/cjs.js!./src/style.css
  458. var style = __webpack_require__(426);
  459. ;// CONCATENATED MODULE: ./src/style.css
  460.  
  461.             
  462.  
  463. var options = {};
  464.  
  465. options.insert = "head";
  466. options.singleton = false;
  467.  
  468. var update = injectStylesIntoStyleTag_default()(style/* default */.Z, options);
  469.  
  470.  
  471.  
  472. /* harmony default export */ const src_style = (style/* default.locals */.Z.locals || {});
  473. ;// CONCATENATED MODULE: ./src/lib/dom-util.ts
  474. var __awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
  475.     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
  476.     return new (P || (P = Promise))(function (resolve, reject) {
  477.         function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
  478.         function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
  479.         function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
  480.         step((generator = generator.apply(thisArg, _arguments || [])).next());
  481.     });
  482. };
  483. function sleep(time) {
  484.     return new Promise(resolve => {
  485.         setTimeout(resolve, time);
  486.     });
  487. }
  488. function asyncQuerySelector(selectors) {
  489.     return __awaiter(this, void 0, void 0, function* () {
  490.         while (true) {
  491.             const result = document.querySelector(selectors);
  492.             if (result)
  493.                 return result;
  494.             yield sleep(200);
  495.         }
  496.     });
  497. }
  498. function waitForVueJsNextTick() {
  499.     return new Promise(resolve => {
  500.         Vue.nextTick(resolve);
  501.     });
  502. }
  503.  
  504. ;// CONCATENATED MODULE: ./src/lib/general-util.ts
  505. function observeProperties(obj, propertyNames, callback, interval = 100) {
  506.     function getValues() {
  507.         return propertyNames.map(key => obj[key]);
  508.     }
  509.     function arrayEquals(a, b) {
  510.         if (a.length !== b.length)
  511.             return false;
  512.         for (let i = 0, imax = a.length; i < imax; ++i) {
  513.             if (a[i] !== b[i])
  514.                 return false;
  515.         }
  516.         return true;
  517.     }
  518.     let previousValue = getValues();
  519.     setInterval(() => {
  520.         const currentValue = getValues();
  521.         if (!arrayEquals(currentValue, previousValue)) {
  522.             callback();
  523.             previousValue = currentValue;
  524.         }
  525.     }, interval);
  526. }
  527.  
  528. ;// CONCATENATED MODULE: ./src/feature/text-to-ordering-target.ts
  529. function textToNumber(text) {
  530.     let value = NaN;
  531.     if (!text.match(/^,|,$|,,|\..*,|[eE].*,|,.*[eE]/)) {
  532.         value = Number(text.replace(/,/g, ""));
  533.     }
  534.     if (isNaN(value)) {
  535.         throw new Error(`Cannot convert '${text}' to a number.`);
  536.     }
  537.     return value;
  538. }
  539. function mmssToSeconds(text) {
  540.     const parts = text.split(":").map(Number);
  541.     if (parts.length !== 2
  542.         || !isFinite(parts[1]) || parts[1] < 0 || parts[1] >= 60
  543.         || !isFinite(parts[0]) || parts[0] % 1 !== 0) {
  544.         throw new Error(`Cannot interpret '${text} as a time'`);
  545.     }
  546.     return parts[0] * 60 + parts[1];
  547. }
  548. /**
  549.  * @returns a value treated as a first entry in the default compareFn
  550.  */
  551. function veryFirstStandingsEntry(desc) {
  552.     return {
  553.         Rank: desc ? Infinity : -Infinity,
  554.         Rating: desc ? -Infinity : Infinity,
  555.         OldRating: desc ? -Infinity : Infinity,
  556.         TotalResult: {
  557.             Count: 1,
  558.             Score: desc ? -Infinity : Infinity,
  559.             Elapsed: desc ? Infinity : -Infinity,
  560.         },
  561.         TaskResults: {},
  562.     };
  563. }
  564. /**
  565.  * @returns a value treated as a first entry in the default compareFn
  566.  */
  567. function veryFirstResultsEntry(desc) {
  568.     return {
  569.         Rank: desc ? Infinity : -Infinity,
  570.         Place: desc ? Infinity : -Infinity,
  571.         Performance: desc ? -Infinity : Infinity,
  572.         OldRating: desc ? -Infinity : Infinity,
  573.         Difference: desc ? -Infinity : Infinity,
  574.         NewRating: desc ? -Infinity : Infinity,
  575.         Rating: desc ? -Infinity : Infinity,
  576.     };
  577. }
  578. var TextToOrderingTarget;
  579. (function (TextToOrderingTarget) {
  580.     let Standings;
  581.     (function (Standings) {
  582.         function numeric(key) {
  583.             return function (text, desc) {
  584.                 const res = veryFirstStandingsEntry(desc);
  585.                 res[key] = textToNumber(text);
  586.                 return res;
  587.             };
  588.         }
  589.         Standings.numeric = numeric;
  590.         /**
  591.          * @param taskAlphabet Set null for the total score
  592.          */
  593.         function score(taskAlphabet) {
  594.             return function (text, desc, showInLogScale, taskInfo) {
  595.                 // set default value
  596.                 let elapsed = desc ? -Infinity : Infinity; // most bottom
  597.                 let point = 0;
  598.                 if (taskAlphabet !== null && taskAlphabet in taskInfo) {
  599.                     point = taskInfo[taskAlphabet].maximumScore;
  600.                 }
  601.                 else {
  602.                     // sum of all tasks point
  603.                     for (const alphabet in taskInfo) {
  604.                         point += taskInfo[alphabet].maximumScore;
  605.                     }
  606.                 }
  607.                 const parts = text.split(/\s/).filter(s => !!s);
  608.                 // read a time
  609.                 try {
  610.                     elapsed = mmssToSeconds(parts[parts.length - 1]) * 1e9;
  611.                     parts.pop();
  612.                 }
  613.                 catch (_a) { }
  614.                 // read a point
  615.                 if (parts.length === 1) {
  616.                     point = 0;
  617.                     let pointText = parts[0];
  618.                     try {
  619.                         point = textToNumber(pointText);
  620.                         if (showInLogScale) {
  621.                             point = 100 * Math.exp(point * LOG_BASE);
  622.                         }
  623.                         else {
  624.                             point *= 100;
  625.                         }
  626.                     }
  627.                     catch (e) {
  628.                         if (taskAlphabet === null) {
  629.                             // convert task alphabets to point
  630.                             function testTaskExistance(alphabet) {
  631.                                 if (!(alphabet in taskInfo)) {
  632.                                     throw new Error(`Task '${alphabet}' does not exist`);
  633.                                 }
  634.                             }
  635.                             function addTaskPoint(alphabet) {
  636.                                 testTaskExistance(alphabet);
  637.                                 point += taskInfo[alphabet].maximumScore;
  638.                             }
  639.                             pointText = pointText.toUpperCase();
  640.                             if (pointText[0] === "-") {
  641.                                 const firstTaskAlphabet = Object.keys(taskInfo).sort()[0];
  642.                                 pointText = firstTaskAlphabet + pointText;
  643.                             }
  644.                             if (pointText[pointText.length - 1] === "-") {
  645.                                 const lastTaskAlphabet = Object.keys(taskInfo).sort((a, b) => a < b ? 1 : a > b ? -1 : 0)[0];
  646.                                 pointText += lastTaskAlphabet;
  647.                             }
  648.                             for (let i = 0, imax = pointText.length; i < imax; ++i) {
  649.                                 if (pointText[i + 1] === "-") {
  650.                                     testTaskExistance(pointText[i]);
  651.                                     testTaskExistance(pointText[i + 2]);
  652.                                     for (let j = pointText.charCodeAt(i), jmax = pointText.charCodeAt(i + 2); j <= jmax; ++j) {
  653.                                         addTaskPoint(String.fromCharCode(j));
  654.                                     }
  655.                                     i += 2;
  656.                                 }
  657.                                 else {
  658.                                     addTaskPoint(pointText[i]);
  659.                                 }
  660.                             }
  661.                         }
  662.                         else {
  663.                             throw e;
  664.                         }
  665.                     }
  666.                 }
  667.                 else if (parts.length >= 2) {
  668.                     throw new Error(`'${text}' is not a score specifier (format: '[point] [time]')`);
  669.                 }
  670.                 const res = veryFirstStandingsEntry(desc);
  671.                 if (taskAlphabet === null) {
  672.                     res.TotalResult = {
  673.                         Count: 1,
  674.                         Score: point,
  675.                         Elapsed: elapsed,
  676.                     };
  677.                 }
  678.                 else {
  679.                     res.TaskResults[taskInfo[taskAlphabet].screenName] = {
  680.                         Count: 1,
  681.                         Score: point,
  682.                         Elapsed: elapsed,
  683.                     };
  684.                 }
  685.                 return res;
  686.             };
  687.         }
  688.         Standings.score = score;
  689.     })(Standings = TextToOrderingTarget.Standings || (TextToOrderingTarget.Standings = {}));
  690.     ;
  691.     let Results;
  692.     (function (Results) {
  693.         function numeric(key) {
  694.             return function (text, desc) {
  695.                 const res = veryFirstResultsEntry(desc);
  696.                 res[key] = textToNumber(text);
  697.                 return res;
  698.             };
  699.         }
  700.         Results.numeric = numeric;
  701.     })(Results = TextToOrderingTarget.Results || (TextToOrderingTarget.Results = {}));
  702.     ;
  703. })(TextToOrderingTarget || (TextToOrderingTarget = {}));
  704.  
  705. ;// CONCATENATED MODULE: ./src/feature/pager/base.ts
  706. class Pager {
  707.     constructor(paginationFn, orderFn) {
  708.         this.paginationFn = paginationFn;
  709.         this.orderFn = orderFn;
  710.     }
  711.     convertTargetText(fn, ...args) {
  712.         try {
  713.             return fn(...args);
  714.         }
  715.         catch (e) {
  716.             throw new TargetTextConvertionError(e);
  717.         }
  718.     }
  719. }
  720. class TargetTextConvertionError extends Error {
  721. }
  722.  
  723. ;// CONCATENATED MODULE: ./src/lib/math-util.ts
  724. function binarySearch(array, compareFn, target) {
  725.     const test = arguments.length >= 3 ?
  726.         (n) => compareFn(array[n], target) >= 0 :
  727.         (n) => compareFn(array[n]);
  728.     let low = 0, high = array.length;
  729.     if (test(0))
  730.         return 0;
  731.     while (high - low > 1) {
  732.         const mid = (high + low) >> 1;
  733.         if (test(mid)) {
  734.             high = mid;
  735.         }
  736.         else {
  737.             low = mid;
  738.         }
  739.     }
  740.     return high;
  741. }
  742. function linearPrediction(x1, y1, x2, y2, x) {
  743.     return y1 + (y2 - y1) * (x - x1) / (x2 - x1);
  744. }
  745.  
  746. ;// CONCATENATED MODULE: ./src/lib/atcoder/info-reader.ts
  747. function readTaskScore(pageSource) {
  748.     const match = pageSource.match(/(?:配点|Score).*<var>(\d+)<\/var>/);
  749.     if (match) {
  750.         const score = Number(match[1]);
  751.         if (!isNaN(score)) {
  752.             return score;
  753.         }
  754.     }
  755.     throw new Error("Cannot read the score point");
  756. }
  757. function readRatedRange(pageSource) {
  758.     const match = pageSource.match(/>[\s\r\n]*(?:Rated対象|Rated Range)[\s\r\n]*:([^<>]*)</);
  759.     if (match) {
  760.         const text = match[1].replace(/[\s\r\n]/g, "").toLowerCase();
  761.         if (text === "-") {
  762.             return [-Infinity, -Infinity];
  763.         }
  764.         else if (text === "all") {
  765.             return [-Infinity, Infinity];
  766.         }
  767.         const parts = text.split(/-|~/);
  768.         if (parts.length === 2) {
  769.             const parsed = [
  770.                 parts[0] === "" ? -Infinity : Number(parts[0]),
  771.                 parts[1] === "" ? Infinity : Number(parts[1])
  772.             ];
  773.             if (!isNaN(parsed[0]) && !isNaN(parsed[1])) {
  774.                 return parsed;
  775.             }
  776.         }
  777.     }
  778.     throw new Error("Cannot read the rated range");
  779. }
  780.  
  781. ;// CONCATENATED MODULE: ./src/lib/atcoder/time.ts
  782. function internalTimeToJsDate(internalTime) {
  783.     return internalTime.toDate();
  784. }
  785.  
  786. ;// CONCATENATED MODULE: ./src/lib/net-util.ts
  787. var net_util_awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
  788.     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
  789.     return new (P || (P = Promise))(function (resolve, reject) {
  790.         function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
  791.         function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
  792.         function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
  793.         step((generator = generator.apply(thisArg, _arguments || [])).next());
  794.     });
  795. };
  796. class FetchResponseError extends Error {
  797.     constructor(res) {
  798.         super();
  799.         this.res = res;
  800.     }
  801. }
  802. function fetchText(input, init) {
  803.     return net_util_awaiter(this, void 0, void 0, function* () {
  804.         const res = yield fetch(input, init);
  805.         if (res.status !== 200) {
  806.             throw new FetchResponseError(res);
  807.         }
  808.         return yield res.text();
  809.     });
  810. }
  811.  
  812. ;// CONCATENATED MODULE: ./src/feature/get-task-info.ts
  813. var get_task_info_awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
  814.     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
  815.     return new (P || (P = Promise))(function (resolve, reject) {
  816.         function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
  817.         function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
  818.         function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
  819.         step((generator = generator.apply(thisArg, _arguments || [])).next());
  820.     });
  821. };
  822.  
  823.  
  824.  
  825. let cache = null;
  826. let previousStandings = null;
  827. let maximumScoreRecord = {};
  828. function getAndRecordMaximumScore(taskAlphabet, taskScreenName) {
  829.     return get_task_info_awaiter(this, void 0, void 0, function* () {
  830.         maximumScoreRecord[taskAlphabet] = null;
  831.         const url = location.href.replace(/(?<=\/contests\/[^\/]*\/).*$/, "tasks/" + taskScreenName);
  832.         try {
  833.             const score = readTaskScore(yield fetchText(url)) * 100;
  834.             maximumScoreRecord[taskAlphabet] = score;
  835.             if (cache) {
  836.                 cache[taskAlphabet].maximumScore = score;
  837.             }
  838.         }
  839.         catch (e) {
  840.             console.error(`Cannot get the score point from ${url}`);
  841.         }
  842.     });
  843. }
  844. let contestStartTimerEnabled = false;
  845. function generateTaskInfo(standings) {
  846.     const started = contestIsStarted();
  847.     if (!started) {
  848.         if (!contestStartTimerEnabled) {
  849.             contestStartTimerEnabled = true;
  850.             const timerId = setInterval(() => {
  851.                 if (contestIsStarted()) {
  852.                     for (const task of standings.TaskInfo) {
  853.                         getAndRecordMaximumScore(task.Assignment, task.TaskScreenName);
  854.                     }
  855.                     clearInterval(timerId);
  856.                 }
  857.             }, 1000);
  858.         }
  859.     }
  860.     const result = {};
  861.     for (const info of standings.TaskInfo) {
  862.         const alphabet = info.Assignment;
  863.         const screenName = info.TaskScreenName;
  864.         let maximumScore = 0;
  865.         if (started) {
  866.             if (alphabet in maximumScoreRecord && maximumScoreRecord[alphabet] !== null) {
  867.                 maximumScore = maximumScoreRecord[alphabet];
  868.             }
  869.             else {
  870.                 if (!(alphabet in maximumScoreRecord)) {
  871.                     // Do not wait (request only)
  872.                     getAndRecordMaximumScore(alphabet, screenName);
  873.                 }
  874.                 for (const entry of standings.StandingsData) {
  875.                     const taskResults = entry.TaskResults;
  876.                     if (screenName in taskResults) {
  877.                         maximumScore = Math.max(maximumScore, taskResults[screenName].Score);
  878.                     }
  879.                 }
  880.             }
  881.         }
  882.         result[alphabet] = { screenName, maximumScore };
  883.     }
  884.     return result;
  885. }
  886. function getTaskInfo() {
  887.     const currentStandings = vueStandings.standings;
  888.     // Check if standings has been updated
  889.     if (cache && currentStandings === previousStandings)
  890.         return cache;
  891.     previousStandings = currentStandings;
  892.     return cache = generateTaskInfo(currentStandings);
  893. }
  894. ;
  895. function contestIsStarted() {
  896.     return internalTimeToJsDate(getServerTime()).getTime() >= internalTimeToJsDate(startTime).getTime();
  897. }
  898.  
  899. ;// CONCATENATED MODULE: ./src/feature/pager/standings-order.ts
  900. var standings_order_awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
  901.     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
  902.     return new (P || (P = Promise))(function (resolve, reject) {
  903.         function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
  904.         function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
  905.         function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
  906.         step((generator = generator.apply(thisArg, _arguments || [])).next());
  907.     });
  908. };
  909.  
  910.  
  911.  
  912. class StandingsOrderPager extends Pager {
  913.     constructor(paginationFn, orderFn, orderBy, textToOrderingTarget) {
  914.         super(paginationFn, orderFn);
  915.         this.paginationFn = paginationFn;
  916.         this.orderFn = orderFn;
  917.         this.orderBy = orderBy;
  918.         this.textToOrderingTarget = textToOrderingTarget;
  919.     }
  920.     exec(text) {
  921.         return standings_order_awaiter(this, void 0, void 0, function* () {
  922.             const target = this.convertTargetText(this.textToOrderingTarget, text, vueStandings.desc, vueStandings.showInLogScale, getTaskInfo());
  923.             this.orderFn(this.orderBy); // Do not wait for DOM updated
  924.             const array = vueStandings.orderedStandings;
  925.             if (array.length === 0)
  926.                 return;
  927.             const index = Math.min(binarySearch(array, vueStandings.comp, target), array.length - 1);
  928.             yield this.paginationFn(Math.floor(index / vueStandings.perPage) + 1);
  929.         });
  930.     }
  931. }
  932. class TaskInfo {
  933. }
  934.  
  935. ;// CONCATENATED MODULE: ./src/feature/pager/results-order.ts
  936. var results_order_awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
  937.     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
  938.     return new (P || (P = Promise))(function (resolve, reject) {
  939.         function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
  940.         function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
  941.         function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
  942.         step((generator = generator.apply(thisArg, _arguments || [])).next());
  943.     });
  944. };
  945.  
  946.  
  947. class ResultsOrderPager extends Pager {
  948.     constructor(paginationFn, orderFn, orderBy, textToOrderingTarget) {
  949.         super(paginationFn, orderFn);
  950.         this.paginationFn = paginationFn;
  951.         this.orderFn = orderFn;
  952.         this.orderBy = orderBy;
  953.         this.textToOrderingTarget = textToOrderingTarget;
  954.     }
  955.     exec(text) {
  956.         return results_order_awaiter(this, void 0, void 0, function* () {
  957.             const target = this.convertTargetText(this.textToOrderingTarget, text, vueResults.desc);
  958.             this.orderFn(this.orderBy); // Do not wait for DOM updated
  959.             const array = vueResults.orderedResults;
  960.             if (array.length === 0)
  961.                 return;
  962.             const index = Math.min(binarySearch(array, vueResults.comp, target), array.length - 1);
  963.             yield this.paginationFn(Math.floor(index / vueResults.perPage) + 1);
  964.         });
  965.     }
  966. }
  967.  
  968. ;// CONCATENATED MODULE: ./src/feature/rank-to-rated-rank.ts
  969. var rank_to_rated_rank_awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
  970.     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
  971.     return new (P || (P = Promise))(function (resolve, reject) {
  972.         function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
  973.         function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
  974.         function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
  975.         step((generator = generator.apply(thisArg, _arguments || [])).next());
  976.     });
  977. };
  978.  
  979.  
  980. let rank_to_rated_rank_cache = null;
  981. let rank_to_rated_rank_previousStandings = null;
  982. function getRankToRatedRankMap() {
  983.     const currentStandings = vueStandings.standings;
  984.     // Check if standings has been updated
  985.     if (rank_to_rated_rank_cache && currentStandings === rank_to_rated_rank_previousStandings)
  986.         return rank_to_rated_rank_cache;
  987.     rank_to_rated_rank_previousStandings = currentStandings;
  988.     return rank_to_rated_rank_cache = generateRankToRatedRankMap(currentStandings);
  989. }
  990. function generateRankToRatedRankMap(standings) {
  991.     const data = standings.StandingsData;
  992.     const res0 = calculateRatedRanks(data, e => e.IsRated && e.TotalResult.Count > 0);
  993.     if (res0.ratedNum === 0 && ratedRange !== null) {
  994.         const res1 = calculateRatedRanks(data, e => ratedRange[0] <= e.OldRating && e.OldRating <= ratedRange[1] && e.TotalResult.Count > 0);
  995.         return res1.map;
  996.     }
  997.     else {
  998.         return res0.map;
  999.     }
  1000. }
  1001. function calculateRatedRanks(data, ratedFn) {
  1002.     const size = data.length;
  1003.     const result = Array(size);
  1004.     let ratedRank = 0;
  1005.     let ratedNumOfCurrentRank = 0;
  1006.     let unrateds = [];
  1007.     let _ratedAdded = 0;
  1008.     for (let i = 0; i < size; ++i) {
  1009.         const rank = data[i].Rank;
  1010.         if (ratedFn(data[i])) {
  1011.             ratedNumOfCurrentRank += 1;
  1012.         }
  1013.         else {
  1014.             unrateds.push(rank);
  1015.         }
  1016.         if (i === size - 1 || data[i + 1].Rank !== rank) {
  1017.             if (i === size - 1 && ratedNumOfCurrentRank === 0) {
  1018.                 ratedNumOfCurrentRank = 1;
  1019.                 _ratedAdded = 1;
  1020.             }
  1021.             if (ratedNumOfCurrentRank > 0) {
  1022.                 result[rank] = ((ratedRank + 1) + (ratedRank + ratedNumOfCurrentRank)) / 2;
  1023.                 const unratedsNum = unrateds.filter(r => r !== rank).length;
  1024.                 function unratedSubRankToRatedRank(subRank) {
  1025.                     return ratedRank;
  1026.                     // return ratedRank + subRank / (unratedsNum + 1);
  1027.                 }
  1028.                 let unratedSubRank = 0;
  1029.                 let unratedNumOfCurrentSubRank = 0;
  1030.                 for (let j = 0; j < unratedsNum; ++j) {
  1031.                     const rank = unrateds[j];
  1032.                     unratedNumOfCurrentSubRank += 1;
  1033.                     if (j === unratedsNum - 1 || unrateds[j + 1] !== rank) {
  1034.                         const subRank = ((unratedSubRank + 1) + (unratedSubRank + unratedNumOfCurrentSubRank)) / 2;
  1035.                         result[rank] = unratedSubRankToRatedRank(subRank);
  1036.                         unratedSubRank += unratedNumOfCurrentSubRank;
  1037.                         unratedNumOfCurrentSubRank = 0;
  1038.                     }
  1039.                 }
  1040.                 unrateds = [];
  1041.                 ratedRank += ratedNumOfCurrentRank;
  1042.                 ratedNumOfCurrentRank = 0;
  1043.             }
  1044.         }
  1045.     }
  1046.     return {
  1047.         map: result,
  1048.         ratedNum: ratedRank - _ratedAdded
  1049.     };
  1050. }
  1051. let ratedRange = null;
  1052. (() => rank_to_rated_rank_awaiter(void 0, void 0, void 0, function* () {
  1053.     const contestUrl = location.href.replace(/(?<=\/contests\/[^\/]+)\/.*$/g, "");
  1054.     try {
  1055.         ratedRange = readRatedRange(yield fetchText(contestUrl));
  1056.     }
  1057.     catch (e) {
  1058.         console.error(`Cannot get the rated range from ${contestUrl}`);
  1059.     }
  1060. }))();
  1061.  
  1062. ;// CONCATENATED MODULE: ./src/feature/pager/ac-predictor.ts
  1063. var ac_predictor_awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
  1064.     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
  1065.     return new (P || (P = Promise))(function (resolve, reject) {
  1066.         function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
  1067.         function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
  1068.         function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
  1069.         step((generator = generator.apply(thisArg, _arguments || [])).next());
  1070.     });
  1071. };
  1072.  
  1073.  
  1074.  
  1075.  
  1076. // Get ac-predictor's internal function
  1077. let predictor_onRankInput = null;
  1078. let predictor_onPerfInput = null;
  1079. const addEventListener_raw = HTMLInputElement.prototype.addEventListener;
  1080. HTMLInputElement.prototype.addEventListener =
  1081.     function (type, fn, ...args) {
  1082.         if (type === "keyup") {
  1083.             if (this.id === "predictor-input-rank") {
  1084.                 predictor_onRankInput = fn;
  1085.             }
  1086.             else if (this.id === "predictor-input-perf") {
  1087.                 predictor_onPerfInput = fn;
  1088.             }
  1089.         }
  1090.         addEventListener_raw.call(this, type, fn, ...args);
  1091.     };
  1092. class AcPredictorPager extends Pager {
  1093.     constructor(paginationFn, orderFn, headerRow, beforePaginationFn) {
  1094.         super(paginationFn, orderFn);
  1095.         this.paginationFn = paginationFn;
  1096.         this.orderFn = orderFn;
  1097.         this.headerRow = headerRow;
  1098.         this.beforePaginationFn = beforePaginationFn;
  1099.     }
  1100.     exec(text) {
  1101.         return ac_predictor_awaiter(this, void 0, void 0, function* () {
  1102.             const target = this.convertTargetText(textToNumber, text);
  1103.             yield this.orderFn("rank");
  1104.             if (predictor_onRankInput && predictor_onPerfInput) {
  1105.                 yield this.paginateBasedOnPredictor(target);
  1106.             }
  1107.             else {
  1108.                 yield this.paginateBasedOnDOM(target);
  1109.             }
  1110.         });
  1111.     }
  1112.     paginateBasedOnDOM(target) {
  1113.         return ac_predictor_awaiter(this, void 0, void 0, function* () {
  1114.             if (vueStandings.pages === 0)
  1115.                 return;
  1116.             const desc = vueStandings.desc;
  1117.             if (!desc)
  1118.                 target *= -1;
  1119.             let columnNumber = -1;
  1120.             this.headerRow.querySelectorAll("th").forEach((th, i) => {
  1121.                 if (th.textContent.replace(/\s/g, "") === "perf") {
  1122.                     columnNumber = i;
  1123.                 }
  1124.             });
  1125.             if (columnNumber < 0)
  1126.                 throw new Error('Cannot find perf column');
  1127.             const tbody = this.headerRow.parentElement.parentElement.querySelector("tbody");
  1128.             // Search page binarily
  1129.             let low = null;
  1130.             let high = null;
  1131.             while (true) {
  1132.                 let [v0, v1] = this.readCurrentPagePerf(tbody, columnNumber);
  1133.                 if (!desc) {
  1134.                     v0 *= -1;
  1135.                     v1 *= -1;
  1136.                 }
  1137.                 if (v0 < target && target <= v1) {
  1138.                     break;
  1139.                 }
  1140.                 else if (target <= v0) {
  1141.                     // too high
  1142.                     if (vueStandings.page === 1)
  1143.                         break;
  1144.                     high = { page: vueStandings.page, value: (v0 + v1) / 2 };
  1145.                 }
  1146.                 else {
  1147.                     // too low
  1148.                     if (vueStandings.page === vueStandings.pages)
  1149.                         break;
  1150.                     low = { page: vueStandings.page, value: (v0 + v1) / 2 };
  1151.                 }
  1152.                 let nextPage;
  1153.                 let endNext = false;
  1154.                 if (high && low) {
  1155.                     if (high.page - low.page <= 1) {
  1156.                         // goal
  1157.                         nextPage = high.page;
  1158.                         endNext = true;
  1159.                     }
  1160.                     else if ( /* v0 !== v1 */false) {}
  1161.                     else {
  1162.                         // Use midpoint
  1163.                         nextPage = Math.ceil((high.page + low.page) / 2);
  1164.                     }
  1165.                     if (nextPage >= high.page) {
  1166.                         nextPage = high.page - 1;
  1167.                     }
  1168.                     else if (nextPage <= low.page) {
  1169.                         nextPage = low.page + 1;
  1170.                     }
  1171.                 }
  1172.                 else if (high) {
  1173.                     nextPage = 1;
  1174.                 }
  1175.                 else if (low) {
  1176.                     nextPage = vueStandings.pages;
  1177.                 }
  1178.                 yield this.paginationFn(nextPage);
  1179.                 if (endNext)
  1180.                     break;
  1181.             }
  1182.         });
  1183.     }
  1184.     readPerfFromTableCell(cell) {
  1185.         if (!cell)
  1186.             return 0;
  1187.         const text = cell.textContent.replace(/\s/g, "");
  1188.         const value = Number(text);
  1189.         return isNaN(value) ? 0 : value;
  1190.     }
  1191.     readCurrentPagePerf(tbody, perfColumnIndex) {
  1192.         const rows = [];
  1193.         let infoRowIndex = -1;
  1194.         let warningRowIndex = -1;
  1195.         tbody.childNodes.forEach(node => {
  1196.             if (node instanceof HTMLTableRowElement
  1197.                 && !node.classList.contains("standings-fa")
  1198.                 && !node.classList.contains("standings-statistics")) {
  1199.                 rows.push(node);
  1200.                 if (node.classList.contains("info"))
  1201.                     infoRowIndex = rows.length - 1;
  1202.                 if (node.classList.contains("warning"))
  1203.                     warningRowIndex = rows.length - 1;
  1204.             }
  1205.         });
  1206.         if (rows.length > vueStandings.perPage || vueStandings.page === vueStandings.pages) {
  1207.             if (infoRowIndex < 0 && warningRowIndex >= 0) {
  1208.                 rows.splice(warningRowIndex, 1);
  1209.             }
  1210.             else if (infoRowIndex >= 0) {
  1211.                 rows.splice(infoRowIndex, 1);
  1212.             }
  1213.         }
  1214.         return [rows[0], rows[rows.length - 1]].map(row => this.readPerfFromTableCell(row.children[perfColumnIndex]));
  1215.     }
  1216.     paginateBasedOnPredictor(target) {
  1217.         return ac_predictor_awaiter(this, void 0, void 0, function* () {
  1218.             const standings = vueStandings.orderedStandings;
  1219.             if (standings.length === 0)
  1220.                 return;
  1221.             const desc = vueStandings.desc;
  1222.             const ratedRankMap = getRankToRatedRankMap();
  1223.             const maxPerf = this.rankToPerf(1);
  1224.             const index = binarySearch(standings, entry => {
  1225.                 const ratedRank = ratedRankMap[entry.EntireRank];
  1226.                 const perf = entry.TotalResult.Count === 0
  1227.                     ? -Infinity
  1228.                     : Math.round(this.positivizeRating(Math.min(this.rankToPerf(ratedRank), maxPerf)));
  1229.                 return desc ? (perf >= target) : (perf <= target);
  1230.             });
  1231.             yield this.paginationFn(Math.floor(index / vueStandings.perPage) + 1);
  1232.         });
  1233.     }
  1234.     rankToPerf(rank) {
  1235.         if (this.beforePaginationFn) {
  1236.             this.beforePaginationFn();
  1237.         }
  1238.         const predictorElements = [
  1239.             "predictor-input-rank",
  1240.             "predictor-input-perf",
  1241.             "predictor-input-rate",
  1242.         ].map(s => this.headerRow.ownerDocument.getElementById(s));
  1243.         const temp = predictorElements.map(e => e.value);
  1244.         predictorElements[0].value = rank.toString();
  1245.         predictor_onRankInput();
  1246.         const result = Number(predictorElements[1].value);
  1247.         temp.forEach((v, i) => {
  1248.             predictorElements[i].value = v;
  1249.         });
  1250.         return result;
  1251.     }
  1252.     perfToRank(perf) {
  1253.         if (this.beforePaginationFn) {
  1254.             this.beforePaginationFn();
  1255.         }
  1256.         const predictorElements = [
  1257.             "predictor-input-rank",
  1258.             "predictor-input-perf",
  1259.             "predictor-input-rate",
  1260.         ].map(s => this.headerRow.ownerDocument.getElementById(s));
  1261.         const temp = predictorElements.map(e => e.value);
  1262.         predictorElements[1].value = perf.toString();
  1263.         predictor_onPerfInput();
  1264.         const result = Number(predictorElements[0].value);
  1265.         temp.forEach((v, i) => {
  1266.             predictorElements[i].value = v;
  1267.         });
  1268.         return result;
  1269.     }
  1270.     positivizeRating(rating) {
  1271.         if (rating >= 400.0)
  1272.             return rating;
  1273.         return 400.0 * Math.exp((rating - 400.0) / 400.0);
  1274.     }
  1275.     unpositivizeRating(rating) {
  1276.         if (rating >= 400.0)
  1277.             return rating;
  1278.         return 400.0 + 400.0 * Math.log(rating / 400.0);
  1279.     }
  1280. }
  1281.  
  1282. ;// CONCATENATED MODULE: ./src/index.ts
  1283. var src_awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
  1284.     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
  1285.     return new (P || (P = Promise))(function (resolve, reject) {
  1286.         function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
  1287.         function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
  1288.         function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
  1289.         step((generator = generator.apply(thisArg, _arguments || [])).next());
  1290.     });
  1291. };
  1292.  
  1293.  
  1294.  
  1295.  
  1296.  
  1297.  
  1298.  
  1299.  
  1300.  
  1301. var CLASS_NAMES;
  1302. (function (CLASS_NAMES) {
  1303.     CLASS_NAMES.input = "auto-pager-input";
  1304.     CLASS_NAMES.active = "active";
  1305.     CLASS_NAMES.error = "error";
  1306.     CLASS_NAMES.watching = "watching";
  1307. })(CLASS_NAMES || (CLASS_NAMES = {}));
  1308. (() => src_awaiter(void 0, void 0, void 0, function* () {
  1309.     function getPagerFromHeaderCell(headerCell) {
  1310.         const title = headerCell.textContent.replace(/\s/g, "");
  1311.         if (tableType === "results") {
  1312.             let rule = null;
  1313.             if (title === "順位" || title === "Rank") {
  1314.                 rule = {
  1315.                     orderBy: "Place",
  1316.                     converter: TextToOrderingTarget.Results.numeric("Place"),
  1317.                 };
  1318.             }
  1319.             if (title === "パフォーマンス" || title === "Performance") {
  1320.                 rule = {
  1321.                     orderBy: "Performance",
  1322.                     converter: TextToOrderingTarget.Results.numeric("Performance"),
  1323.                 };
  1324.             }
  1325.             if (title === "旧Rating" || title === "OldRating") {
  1326.                 rule = {
  1327.                     orderBy: "OldRating",
  1328.                     converter: TextToOrderingTarget.Results.numeric("OldRating"),
  1329.                 };
  1330.             }
  1331.             if (title === "差分" || title === "Diff") {
  1332.                 rule = {
  1333.                     orderBy: "Difference",
  1334.                     converter: TextToOrderingTarget.Results.numeric("Difference"),
  1335.                 };
  1336.             }
  1337.             if (title === "新Rating" || title === "NewRating") {
  1338.                 rule = {
  1339.                     orderBy: "NewRating",
  1340.                     converter: TextToOrderingTarget.Results.numeric("NewRating"),
  1341.                 };
  1342.             }
  1343.             if (rule) {
  1344.                 return new ResultsOrderPager(goToPage, changeOrder, rule.orderBy, rule.converter);
  1345.             }
  1346.         }
  1347.         else {
  1348.             let rule = null;
  1349.             if (title === "順位" || title === "Rank") {
  1350.                 rule = {
  1351.                     orderBy: "rank",
  1352.                     converter: TextToOrderingTarget.Standings.numeric("Rank"),
  1353.                 };
  1354.             }
  1355.             if (title === "得点" || title === "Score") {
  1356.                 rule = {
  1357.                     orderBy: "score",
  1358.                     converter: TextToOrderingTarget.Standings.score(null),
  1359.                 };
  1360.             }
  1361.             const taskInfo = getTaskInfo();
  1362.             if (title in taskInfo) {
  1363.                 rule = {
  1364.                     orderBy: "task-" + taskInfo[title].screenName,
  1365.                     converter: TextToOrderingTarget.Standings.score(title),
  1366.                 };
  1367.             }
  1368.             if (rule) {
  1369.                 return new StandingsOrderPager(goToPage, changeOrder, rule.orderBy, rule.converter);
  1370.             }
  1371.             if (title === "perf") {
  1372.                 return new AcPredictorPager(goToPage, changeOrder, headerRow, () => {
  1373.                     if (perfColumnInputElement) {
  1374.                         keepPerfInputState(perfColumnInputElement);
  1375.                     }
  1376.                 });
  1377.             }
  1378.         }
  1379.         return null;
  1380.     }
  1381.     function addInputElementToHeaderCell(headerCell) {
  1382.         const document = headerCell.ownerDocument;
  1383.         const div = document.createElement("div");
  1384.         const input = document.createElement("input");
  1385.         div.append(input);
  1386.         headerCell.append(div);
  1387.         input.classList.add(CLASS_NAMES.input);
  1388.         input.addEventListener("click", e => {
  1389.             e.stopPropagation();
  1390.         });
  1391.         return input;
  1392.     }
  1393.     function columnInit(headerCell) {
  1394.         const pager = getPagerFromHeaderCell(headerCell);
  1395.         if (pager === null)
  1396.             return;
  1397.         const input = addInputElementToHeaderCell(headerCell);
  1398.         input.addEventListener("input", () => src_awaiter(this, void 0, void 0, function* () {
  1399.             input.classList.remove(CLASS_NAMES.active);
  1400.             input.classList.remove(CLASS_NAMES.error);
  1401.             if (watching && watching.element === input) {
  1402.                 input.classList.remove(CLASS_NAMES.watching);
  1403.                 watching = null;
  1404.             }
  1405.         }));
  1406.         input.addEventListener("keypress", (e) => src_awaiter(this, void 0, void 0, function* () {
  1407.             if (e.code === "Enter") {
  1408.                 yield execPagerFromInputElement(input, pager, tableType === "standings" && e.ctrlKey);
  1409.             }
  1410.         }));
  1411.         if (pager instanceof AcPredictorPager) {
  1412.             perfColumnInputElement = input;
  1413.             if (__perfInputState) {
  1414.                 input.focus();
  1415.                 input.value = __perfInputState.value;
  1416.                 input.selectionStart = __perfInputState.selectionStart;
  1417.                 input.selectionEnd = __perfInputState.selectionEnd;
  1418.                 input.classList.add(CLASS_NAMES.active);
  1419.                 setTimeout(() => {
  1420.                     __perfInputState = null;
  1421.                 }, 0);
  1422.             }
  1423.             if (watching && watching.perf !== null) {
  1424.                 input.classList.add(CLASS_NAMES.watching);
  1425.                 input.value = watching.perf.value;
  1426.                 watching = {
  1427.                     element: input,
  1428.                     pager: watching.perf.pager,
  1429.                     perf: watching.perf,
  1430.                 };
  1431.             }
  1432.         }
  1433.     }
  1434.     function execPagerFromInputElement(input, pager, watch = false) {
  1435.         return src_awaiter(this, void 0, void 0, function* () {
  1436.             if (input.value.replace(/\s/g, "") === "")
  1437.                 return;
  1438.             input.classList.remove(CLASS_NAMES.error);
  1439.             input.classList.add(CLASS_NAMES.active);
  1440.             input.classList.remove(CLASS_NAMES.watching);
  1441.             const preWatching = watching;
  1442.             if (watch) {
  1443.                 input.classList.add(CLASS_NAMES.watching);
  1444.                 watching = {
  1445.                     element: input,
  1446.                     pager,
  1447.                     perf: pager instanceof AcPredictorPager ? { value: input.value, pager } : null,
  1448.                 };
  1449.             }
  1450.             else if (watching && watching.element === input) {
  1451.                 watching = null;
  1452.             }
  1453.             try {
  1454.                 yield pager.exec(input.value);
  1455.             }
  1456.             catch (e) {
  1457.                 input.classList.remove(CLASS_NAMES.active);
  1458.                 input.classList.remove(CLASS_NAMES.watching);
  1459.                 input.classList.add(CLASS_NAMES.error);
  1460.                 if (watch)
  1461.                     watching = preWatching;
  1462.                 if (e instanceof TargetTextConvertionError) {
  1463.                     // TODO: Show error message
  1464.                     // console.error(e);
  1465.                 }
  1466.                 else {
  1467.                     throw e;
  1468.                 }
  1469.             }
  1470.         });
  1471.     }
  1472.     function goToPage(page) {
  1473.         return src_awaiter(this, void 0, void 0, function* () {
  1474.             if (page === vueObject.page)
  1475.                 return;
  1476.             if (document.activeElement === perfColumnInputElement) {
  1477.                 keepPerfInputState(perfColumnInputElement);
  1478.             }
  1479.             vueObject.page = page;
  1480.             vueObject.watchIndex = -1;
  1481.             yield waitForVueJsNextTick();
  1482.         });
  1483.     }
  1484.     function changeOrder(orderBy, desc = null) {
  1485.         return src_awaiter(this, void 0, void 0, function* () {
  1486.             if (orderBy === vueObject.orderBy) {
  1487.                 if (desc === null || desc === vueObject.desc)
  1488.                     return;
  1489.             }
  1490.             else {
  1491.                 if (desc === null)
  1492.                     desc = false;
  1493.             }
  1494.             if (document.activeElement === perfColumnInputElement) {
  1495.                 keepPerfInputState(perfColumnInputElement);
  1496.             }
  1497.             vueObject.orderBy = orderBy;
  1498.             if (desc !== null)
  1499.                 vueObject.desc = desc;
  1500.             yield waitForVueJsNextTick();
  1501.         });
  1502.     }
  1503.     let watching = null;
  1504.     let perfColumnInputElement = null;
  1505.     let __perfInputState = null;
  1506.     function keepPerfInputState(input) {
  1507.         __perfInputState = {
  1508.             value: input.value,
  1509.             selectionStart: input.selectionStart,
  1510.             selectionEnd: input.selectionEnd,
  1511.         };
  1512.     }
  1513.     function resetPagers() {
  1514.         for (const input of headerRow.querySelectorAll("." + CLASS_NAMES.input)) {
  1515.             if (headerRow.ownerDocument.activeElement === input)
  1516.                 continue;
  1517.             input.classList.remove(CLASS_NAMES.active);
  1518.             input.classList.remove(CLASS_NAMES.error);
  1519.             input.classList.remove(CLASS_NAMES.watching);
  1520.             input.value = "";
  1521.         }
  1522.         if (watching && watching.element !== headerRow.ownerDocument.activeElement) {
  1523.             watching = null;
  1524.         }
  1525.     }
  1526.     // main
  1527.     const headerRow = (yield asyncQuerySelector("#vue-standings thead tr, #vue-results thead tr"));
  1528.     const tableType = typeof vueStandings === "undefined" ? "results" : "standings";
  1529.     const vueObject = tableType === "standings" ? vueStandings : vueResults;
  1530.     // Launch auto-pager for each column
  1531.     headerRow.querySelectorAll("th").forEach(columnInit);
  1532.     new MutationObserver(mutations => {
  1533.         for (const mutation of mutations) {
  1534.             for (const node of mutation.addedNodes) {
  1535.                 if (node instanceof HTMLElement)
  1536.                     columnInit(node);
  1537.             }
  1538.         }
  1539.     }).observe(headerRow, { childList: true });
  1540.     // Detect pagination
  1541.     observeProperties(vueObject, ["page", "orderBy", "desc"], () => {
  1542.         resetPagers();
  1543.     });
  1544.     if (tableType === "standings") {
  1545.         // Detect updating
  1546.         observeProperties(vueStandings, ["standings"], () => {
  1547.             if (watching) {
  1548.                 execPagerFromInputElement(watching.element, watching.pager, true);
  1549.             }
  1550.         });
  1551.     }
  1552. }))();
  1553.  
  1554. })();
  1555.  
  1556. /******/ })()
  1557. ;