☰

Ironwood RPG - Pancake-Scripts

A collection of scripts to enhance Ironwood RPG - https://github.com/Boldy97/ironwood-scripts

当前为 2024-05-21 提交的版本，查看 最新版本。

  1. // ==UserScript==
  2. // @name         Ironwood RPG - Pancake-Scripts
  3. // @namespace    http://tampermonkey.net/
  4. // @version      4.4.0
  5. // @description  A collection of scripts to enhance Ironwood RPG - https://github.com/Boldy97/ironwood-scripts
  6. // @author       Pancake
  7. // @match        https://ironwoodrpg.com/*
  8. // @icon         https://www.google.com/s2/favicons?sz=64&domain=ironwoodrpg.com
  9. // @grant        none
  10. // @require      https://code.jquery.com/jquery-3.6.4.min.js
  11. // @require      https://cdnjs.cloudflare.com/ajax/libs/Chart.js/4.4.0/chart.umd.js
  12. // ==/UserScript==
  13.  
  14. window.PANCAKE_ROOT = 'https://iwrpg.vectordungeon.com';
  15. window.PANCAKE_VERSION = '4.4.0';
  16. (() => {
  17.  
  18.     if(window.moduleRegistry) {
  19.         return;
  20.     }
  21.  
  22.     window.moduleRegistry = {
  23.         add,
  24.         get,
  25.         build
  26.     };
  27.  
  28.     const modules = {};
  29.  
  30.     function add(name, initialiser) {
  31.         modules[name] = createModule(name, initialiser);
  32.     }
  33.  
  34.     function get(name) {
  35.         return modules[name] || null;
  36.     }
  37.  
  38.     async function build() {
  39.         for(const module of Object.values(modules)) {
  40.             await buildModule(module);
  41.         }
  42.     }
  43.  
  44.     function createModule(name, initialiser) {
  45.         const dependencies = extractParametersFromFunction(initialiser).map(dependency => {
  46.             const name = dependency.replaceAll('_', '');
  47.             const module = get(name);
  48.             const optional = dependency.startsWith('_');
  49.             return { name, module, optional };
  50.         });
  51.         const module = {
  52.             name,
  53.             initialiser,
  54.             dependencies
  55.         };
  56.         for(const other of Object.values(modules)) {
  57.             for(const dependency of other.dependencies) {
  58.                 if(dependency.name === name) {
  59.                     dependency.module = module;
  60.                 }
  61.             }
  62.         }
  63.         return module;
  64.     }
  65.  
  66.     async function buildModule(module, partial, chain) {
  67.         if(module.built) {
  68.             return true;
  69.         }
  70.  
  71.         chain = chain || [];
  72.         if(chain.includes(module.name)) {
  73.             chain.push(module.name);
  74.             throw `Circular dependency in chain : ${chain.join(' -> ')}`;
  75.         }
  76.         chain.push(module.name);
  77.  
  78.         for(const dependency of module.dependencies) {
  79.             if(!dependency.module) {
  80.                 if(partial) {
  81.                     return false;
  82.                 }
  83.                 if(dependency.optional) {
  84.                     continue;
  85.                 }
  86.                 throw `Unresolved dependency : ${dependency.name}`;
  87.             }
  88.             const built = await buildModule(dependency.module, partial, chain);
  89.             if(!built) {
  90.                 return false;
  91.             }
  92.         }
  93.  
  94.         const parameters = module.dependencies.map(a => a.module?.reference);
  95.         try {
  96.             module.reference = await module.initialiser.apply(null, parameters);
  97.         } catch(e) {
  98.             console.error(`Failed building ${module.name}`, e);
  99.             return false;
  100.         }
  101.         module.built = true;
  102.  
  103.         chain.pop();
  104.         return true;
  105.     }
  106.  
  107.     function extractParametersFromFunction(fn) {
  108.         const PARAMETER_NAMES = /([^\s,]+)/g;
  109.         var fnStr = fn.toString();
  110.         var result = fnStr.slice(fnStr.indexOf('(')+1, fnStr.indexOf(')')).match(PARAMETER_NAMES);
  111.         return result || [];
  112.     }
  113.  
  114. })();
  115. // colorMapper
  116. window.moduleRegistry.add('colorMapper', () => {
  117.  
  118.     const colorMappings = {
  119.         // https://colorswall.com/palette/3
  120.         primary: '#0275d8',
  121.         success: '#5cb85c',
  122.         info: '#5bc0de',
  123.         warning: '#f0ad4e',
  124.         danger: '#d9534f',
  125.         inverse: '#292b2c',
  126.         // component styling
  127.         componentLight: '#393532',
  128.         componentRegular: '#28211b',
  129.         componentDark: '#211a12'
  130.     };
  131.  
  132.     function mapColor(color) {
  133.         return colorMappings[color] || color;
  134.     }
  135.  
  136.     return mapColor;
  137.  
  138. }
  139. );
  140. // components
  141. window.moduleRegistry.add('components', (elementWatcher, colorMapper, elementCreator, localDatabase, Promise) => {
  142.  
  143.     const exports = {
  144.         addComponent,
  145.         removeComponent,
  146.         search
  147.     };
  148.  
  149.     const initialised = new Promise.Expiring(2000, 'components');
  150.     const STORE_NAME = 'component-tabs';
  151.     const rowTypeMappings = {
  152.         item: createRow_Item,
  153.         input: createRow_Input,
  154.         break: createRow_Break,
  155.         buttons: createRow_Button,
  156.         dropdown: createRow_Select,
  157.         header: createRow_Header,
  158.         checkbox: createRow_Checkbox,
  159.         segment: createRow_Segment,
  160.         progress: createRow_Progress,
  161.         chart: createRow_Chart,
  162.         list: createRow_List
  163.     };
  164.     let selectedTabs = null;
  165.  
  166.     async function initialise() {
  167.         elementCreator.addStyles(styles);
  168.         selectedTabs = await localDatabase.getAllEntries(STORE_NAME);
  169.         initialised.resolve(exports);
  170.     }
  171.  
  172.     function removeComponent(blueprint) {
  173.         $(`#${blueprint.componentId}`).remove();
  174.     }
  175.  
  176.     async function addComponent(blueprint) {
  177.         if($(blueprint.dependsOn).length) {
  178.             actualAddComponent(blueprint);
  179.             return;
  180.         }
  181.         await elementWatcher.exists(blueprint.dependsOn);
  182.         actualAddComponent(blueprint);
  183.     }
  184.  
  185.     function actualAddComponent(blueprint) {
  186.         const component =
  187.             $('<div/>')
  188.                 .addClass('customComponent')
  189.                 .attr('id', blueprint.componentId);
  190.         if(blueprint.onClick) {
  191.             component
  192.                 .click(blueprint.onClick)
  193.                 .css('cursor', 'pointer');
  194.         }
  195.  
  196.         // TABS
  197.         const selectedTabMatch = selectedTabs.find(a => a.key === blueprint.componentId);
  198.         if(selectedTabMatch) {
  199.             blueprint.selectedTabIndex = selectedTabMatch.value;
  200.             selectedTabs = selectedTabs.filter(a => a.key !== blueprint.componentId);
  201.         }
  202.         const theTabs = createTab(blueprint);
  203.         component.append(theTabs);
  204.  
  205.         // PAGE
  206.         const selectedTabBlueprint = blueprint.tabs[blueprint.selectedTabIndex] || blueprint.tabs[0];
  207.         selectedTabBlueprint.rows.forEach((rowBlueprint, index) => {
  208.             component.append(createRow(rowBlueprint));
  209.         });
  210.  
  211.         const existing = $(`#${blueprint.componentId}`);
  212.         if(existing.length) {
  213.             existing.replaceWith(component);
  214.         } else if(blueprint.prepend) {
  215.             $(blueprint.parent).prepend(component);
  216.         } else {
  217.             $(blueprint.parent).append(component);
  218.         }
  219.     }
  220.  
  221.     function createTab(blueprint) {
  222.         if(!blueprint.selectedTabIndex) {
  223.             blueprint.selectedTabIndex = 0;
  224.         }
  225.         if(blueprint.tabs.length === 1) {
  226.             return;
  227.         }
  228.         const tabContainer = $('<div/>').addClass('tabs');
  229.         blueprint.tabs.forEach((element, index) => {
  230.             if(element.hidden) {
  231.                 return;
  232.             }
  233.             const tab = $('<button/>')
  234.                 .attr('type', 'button')
  235.                 .addClass('tabButton')
  236.                 .text(element.title)
  237.                 .click(changeTab.bind(null, blueprint, index));
  238.             if(blueprint.selectedTabIndex !== index) {
  239.                 tab.addClass('tabButtonInactive')
  240.             }
  241.             if(index !== 0) {
  242.                 tab.addClass('lineLeft')
  243.             }
  244.             tabContainer.append(tab);
  245.         });
  246.         return tabContainer;
  247.     }
  248.  
  249.     function createRow(rowBlueprint) {
  250.         if(!rowTypeMappings[rowBlueprint.type]) {
  251.             console.warn(`Skipping unknown row type in blueprint: ${rowBlueprint.type}`, rowBlueprint);
  252.             return;
  253.         }
  254.         if(rowBlueprint.hidden) {
  255.             return;
  256.         }
  257.         return rowTypeMappings[rowBlueprint.type](rowBlueprint);
  258.     }
  259.  
  260.     function createRow_Item(itemBlueprint) {
  261.         const parentRow = $('<div/>').addClass('customRow');
  262.         if(itemBlueprint.image) {
  263.             parentRow.append(createImage(itemBlueprint));
  264.         }
  265.         if(itemBlueprint?.name) {
  266.             parentRow
  267.                 .append(
  268.                     $('<div/>')
  269.                         .addClass('myItemName name')
  270.                         .text(itemBlueprint.name)
  271.                 );
  272.         }
  273.         parentRow // always added because it spreads pushes name left and value right !
  274.             .append(
  275.                 $('<div/>')
  276.                     .addClass('myItemValue')
  277.                     .text(itemBlueprint?.extra || '')
  278.             );
  279.         if(itemBlueprint?.value) {
  280.             parentRow
  281.                 .append(
  282.                     $('<div/>')
  283.                         .addClass('myItemWorth')
  284.                         .text(itemBlueprint.value)
  285.                 )
  286.         }
  287.         return parentRow;
  288.     }
  289.  
  290.     function createRow_Input(inputBlueprint) {
  291.         const parentRow = $('<div/>').addClass('customRow');
  292.         if(inputBlueprint.text) {
  293.             parentRow
  294.                 .append(
  295.                     $('<div/>')
  296.                         .addClass('myItemInputText')
  297.                         .addClass(inputBlueprint.class || '')
  298.                         .text(inputBlueprint.text)
  299.                         .css('flex', `${inputBlueprint.layout?.split('/')[0] || 1}`)
  300.                 )
  301.         }
  302.         parentRow
  303.             .append(
  304.                 $('<input/>')
  305.                     .attr('id', inputBlueprint.id)
  306.                     .addClass('myItemInput')
  307.                     .addClass(inputBlueprint.class || '')
  308.                     .attr('type', inputBlueprint.inputType || 'text')
  309.                     .attr('placeholder', inputBlueprint.name)
  310.                     .attr('value', inputBlueprint.value || '')
  311.                     .css('flex', `${inputBlueprint.layout?.split('/')[1] || 1}`)
  312.                     .keyup(inputDelay(function(e) {
  313.                         inputBlueprint.value = e.target.value;
  314.                         if(inputBlueprint.action) {
  315.                             inputBlueprint.action(inputBlueprint.value);
  316.                         }
  317.                     }, inputBlueprint.delay || 0))
  318.             )
  319.         return parentRow;
  320.     }
  321.  
  322.     function createRow_Break(breakBlueprint) {
  323.         const parentRow = $('<div/>').addClass('customRow');
  324.         parentRow.append('<br/>');
  325.         return parentRow;
  326.     }
  327.  
  328.     function createRow_Button(buttonBlueprint) {
  329.         const parentRow = $('<div/>').addClass('customRow');
  330.         for(const button of buttonBlueprint.buttons) {
  331.             parentRow
  332.                 .append(
  333.                     $(`<button class='myButton'>${button.text}</button>`)
  334.                         .css('background-color', button.disabled ? '#ffffff0a' : colorMapper(button.color || 'primary'))
  335.                         .css('flex', `${button.size || 1} 1 0`)
  336.                         .prop('disabled', !!button.disabled)
  337.                         .addClass(button.class || '')
  338.                         .click(button.action)
  339.                 );
  340.         }
  341.         return parentRow;
  342.     }
  343.  
  344.     function createRow_Select(selectBlueprint) {
  345.         const parentRow = $('<div/>').addClass('customRow');
  346.         const select = $('<select/>')
  347.             .addClass('myItemSelect')
  348.             .addClass(selectBlueprint.class || '')
  349.             .change(inputDelay(function(e) {
  350.                 for(const option of selectBlueprint.options) {
  351.                     option.selected = this.value === option.value;
  352.                 }
  353.                 if(selectBlueprint.action) {
  354.                     selectBlueprint.action(this.value);
  355.                 }
  356.             }, selectBlueprint.delay || 0));
  357.         for(const option of selectBlueprint.options) {
  358.             select.append(`<option value='${option.value}' ${option.selected ? 'selected' : ''}>${option.text}</option>`);
  359.         }
  360.         parentRow.append(select);
  361.         return parentRow;
  362.     }
  363.  
  364.     function createRow_Header(headerBlueprint) {
  365.         const parentRow =
  366.             $('<div/>')
  367.                 .addClass('myHeader lineTop')
  368.         if(headerBlueprint.image) {
  369.             parentRow.append(createImage(headerBlueprint));
  370.         }
  371.         parentRow.append(
  372.             $('<div/>')
  373.                 .addClass('myName')
  374.                 .text(headerBlueprint.title)
  375.         )
  376.         if(headerBlueprint.action) {
  377.             parentRow
  378.                 .append(
  379.                     $('<button/>')
  380.                         .addClass('myHeaderAction')
  381.                         .text(headerBlueprint.name)
  382.                         .attr('type', 'button')
  383.                         .css('background-color', colorMapper(headerBlueprint.color || 'success'))
  384.                         .click(headerBlueprint.action)
  385.                 )
  386.         } else if(headerBlueprint.textRight) {
  387.             parentRow.append(
  388.                 $('<div/>')
  389.                     .addClass('level')
  390.                     .text(headerBlueprint.title)
  391.                     .css('margin-left', 'auto')
  392.                     .html(headerBlueprint.textRight)
  393.             )
  394.         }
  395.         if(headerBlueprint.centered) {
  396.             parentRow.css('justify-content', 'center');
  397.         }
  398.         return parentRow;
  399.     }
  400.  
  401.     function createRow_Checkbox(checkboxBlueprint) {
  402.         const checked_false = `<svg xmlns='http://www.w3.org/2000/svg' width='44' height='44' viewBox='0 0 24 24' stroke-width='1.5' stroke='currentColor' fill='none' stroke-linecap='round' stroke-linejoin='round' class='customCheckBoxDisabled ng-star-inserted'><path stroke='none' d='M0 0h24v24H0z' fill='none'></path><rect x='4' y='4' width='16' height='16' rx='2'></rect></svg>`;
  403.         const checked_true = `<svg xmlns='http://www.w3.org/2000/svg' width='44' height='44' viewBox='0 0 24 24' stroke-width='1.5' stroke='currentColor' fill='none' stroke-linecap='round' stroke-linejoin='round' class='customCheckBoxEnabled ng-star-inserted'><path stroke='none' d='M0 0h24v24H0z' fill='none'></path><rect x='4' y='4' width='16' height='16' rx='2'></rect><path d='M9 12l2 2l4 -4'></path></svg>`;
  404.  
  405.         const buttonInnerHTML = checkboxBlueprint.checked ? checked_true : checked_false;
  406.  
  407.         const parentRow = $('<div/>').addClass('customRow')
  408.             .append(
  409.                 $('<div/>')
  410.                     .addClass('customCheckBoxText')
  411.                     .text(checkboxBlueprint?.text || '')
  412.             )
  413.             .append(
  414.                 $('<div/>')
  415.                     .addClass('customCheckboxCheckbox')
  416.                     .append(
  417.                         $(`<button>${buttonInnerHTML}</button>`)
  418.                             .html(buttonInnerHTML)
  419.                             .click(() => {
  420.                                 checkboxBlueprint.checked = !checkboxBlueprint.checked;
  421.                                 if(checkboxBlueprint.action) {
  422.                                     checkboxBlueprint.action(checkboxBlueprint.checked);
  423.                                 }
  424.                             })
  425.                     )
  426.  
  427.             );
  428.  
  429.         return parentRow;
  430.     }
  431.  
  432.     function createRow_Segment(segmentBlueprint) {
  433.         if(segmentBlueprint.hidden) {
  434.             return;
  435.         }
  436.         return segmentBlueprint.rows.flatMap(createRow);
  437.     }
  438.  
  439.     function createRow_Progress(progressBlueprint) {
  440.         const parentRow = $('<div/>').addClass('customRow');
  441.         const up = progressBlueprint.numerator;
  442.         const down = progressBlueprint.denominator;
  443.         parentRow.append(
  444.             $('<div/>')
  445.                 .addClass('myBar')
  446.                 .append(
  447.                     $('<div/>')
  448.                         .css('height', '100%')
  449.                         .css('width', progressBlueprint.progressPercent + '%')
  450.                         .css('background-color', colorMapper(progressBlueprint.color || 'rgb(122, 118, 118)'))
  451.                 )
  452.         );
  453.         parentRow.append(
  454.             $('<div/>')
  455.                 .addClass('myPercent')
  456.                 .text(progressBlueprint.progressPercent + '%')
  457.         )
  458.         parentRow.append(
  459.             $('<div/>')
  460.                 .css('margin-left', 'auto')
  461.                 .text(progressBlueprint.progressText)
  462.         )
  463.         return parentRow;
  464.     }
  465.  
  466.     function createRow_Chart(chartBlueprint) {
  467.         const parentRow = $('<div/>')
  468.         .addClass('lineTop')
  469.             .append(
  470.                 $('<canvas/>')
  471.                     .attr('id', chartBlueprint.chartId)
  472.             );
  473.         return parentRow;
  474.     }
  475.  
  476.     function createRow_List(listBlueprint) {
  477.         const parentRow = $('<div/>').addClass('customRow');
  478.         parentRow // always added because it spreads pushes name left and value right !
  479.             .append(
  480.                 $('<ul/>')
  481.                     .addClass('myListDescription')
  482.                     .append(...listBlueprint.entries.map(entry =>
  483.                         $('<li/>')
  484.                             .addClass('myListLine')
  485.                             .text(entry)
  486.                     ))
  487.             );
  488.         return parentRow;
  489.     }
  490.     
  491.     function createImage(blueprint) {
  492.         return $('<div/>')
  493.             .addClass('myItemImage image')
  494.             .append(
  495.                 $('<img/>')
  496.                     .attr('src', `${blueprint.image}`)
  497.                     .css('filter', `${blueprint.imageFilter}`)
  498.                     .css('image-rendering', blueprint.imagePixelated ? 'pixelated' : 'auto')
  499.             )
  500.     }
  501.  
  502.     function changeTab(blueprint, index) {
  503.         blueprint.selectedTabIndex = index;
  504.         localDatabase.saveEntry(STORE_NAME, {
  505.             key: blueprint.componentId,
  506.             value: index
  507.         });
  508.         selectedTabs = selectedTabs.filter(a => a.key !== blueprint.componentId);
  509.         addComponent(blueprint);
  510.     }
  511.  
  512.     function inputDelay(callback, ms) {
  513.         var timer = 0;
  514.         return function() {
  515.             var context = this, args = arguments;
  516.             window.clearTimeout(timer);
  517.             timer = window.setTimeout(function() {
  518.                 callback.apply(context, args);
  519.             }, ms || 0);
  520.         };
  521.     }
  522.  
  523.     function search(blueprint, query) {
  524.         if(!blueprint.idMappings) {
  525.             generateIdMappings(blueprint);
  526.         }
  527.         if(!blueprint.idMappings[query]) {
  528.             throw `Could not find id ${query} in blueprint ${blueprint.componentId}`;
  529.         }
  530.         return blueprint.idMappings[query];
  531.     }
  532.  
  533.     function generateIdMappings(blueprint) {
  534.         blueprint.idMappings = {};
  535.         for(const tab of blueprint.tabs) {
  536.             addIdMapping(blueprint, tab);
  537.             for(const row of tab.rows) {
  538.                 addIdMapping(blueprint, row);
  539.             }
  540.         }
  541.     }
  542.  
  543.     function addIdMapping(blueprint, element) {
  544.         if(element.id) {
  545.             if(blueprint.idMappings[element.id]) {
  546.                 throw `Detected duplicate id ${element.id} in blueprint ${blueprint.componentId}`;
  547.             }
  548.             blueprint.idMappings[element.id] = element;
  549.         }
  550.         let subelements = null;
  551.         if(element.type === 'segment') {
  552.             subelements = element.rows;
  553.         }
  554.         if(element.type === 'buttons') {
  555.             subelements = element.buttons;
  556.         }
  557.         if(subelements) {
  558.             for(const subelement of subelements) {
  559.                 addIdMapping(blueprint, subelement);
  560.             }
  561.         }
  562.     }
  563.  
  564.     const styles = `
  565.         :root {
  566.             --background-color: ${colorMapper('componentRegular')};
  567.             --border-color: ${colorMapper('componentLight')};
  568.             --darker-color: ${colorMapper('componentDark')};
  569.         }
  570.         .customComponent {
  571.             margin-top: var(--gap);
  572.             background-color: var(--background-color);
  573.             box-shadow: 0 6px 12px -6px #0006;
  574.             border-radius: 4px;
  575.             width: 100%;
  576.         }
  577.         .myHeader {
  578.             display: flex;
  579.             align-items: center;
  580.             padding: 12px var(--gap);
  581.             gap: var(--gap);
  582.         }
  583.         .myName {
  584.             font-weight: 600;
  585.             letter-spacing: .25px;
  586.         }
  587.         .myHeaderAction{
  588.             margin: 0px 0px 0px auto;
  589.             border: 1px solid var(--border-color);
  590.             border-radius: 4px;
  591.             padding: 0px 5px;
  592.         }
  593.         .customRow {
  594.             display: flex;
  595.             justify-content: center;
  596.             align-items: center;
  597.             border-top: 1px solid var(--border-color);
  598.             /*padding: 5px 12px 5px 6px;*/
  599.             min-height: 0px;
  600.             min-width: 0px;
  601.             gap: var(--margin);
  602.             padding: calc(var(--gap) / 2) var(--gap);
  603.         }
  604.         .myItemImage {
  605.             position: relative;
  606.             display: flex;
  607.             align-items: center;
  608.             justify-content: center;
  609.             height: 24px;
  610.             width: 24px;
  611.             min-height: 0px;
  612.             min-width: 0px;
  613.         }
  614.         .myItemImage > img {
  615.             max-width: 100%;
  616.             max-height: 100%;
  617.             width: 100%;
  618.             height: 100%;
  619.         }
  620.         .myItemValue {
  621.             display: flex;
  622.             align-items: center;
  623.             flex: 1;
  624.             color: #aaa;
  625.         }
  626.         .myItemInputText {
  627.             height: 40px;
  628.             width: 100%;
  629.             display: flex;
  630.             align-items: center;
  631.             padding: 12px var(--gap);
  632.         }
  633.         .myItemInput {
  634.             height: 40px;
  635.             width: 100%;
  636.             background-color: #ffffff0a;
  637.             padding: 0 12px;
  638.             text-align: center;
  639.             border-radius: 4px;
  640.             border: 1px solid var(--border-color);
  641.         }
  642.         .myItemSelect {
  643.             height: 40px;
  644.             width: 100%;
  645.             background-color: #ffffff0a;
  646.             padding: 0 12px;
  647.             text-align: center;
  648.             border-radius: 4px;
  649.             border: 1px solid var(--border-color);
  650.         }
  651.         .myItemSelect > option {
  652.             background-color: var(--darker-color);
  653.         }
  654.         .myButton {
  655.             flex: 1;
  656.             display: flex;
  657.             align-items: center;
  658.             justify-content: center;
  659.             border-radius: 4px;
  660.             height: 40px;
  661.             font-weight: 600;
  662.             letter-spacing: .25px;
  663.         }
  664.         .myButton[disabled] {
  665.             pointer-events: none;
  666.         }
  667.         .sort {
  668.            padding: 12px var(--gap);
  669.            border-top: 1px solid var(--border-color);
  670.            display: flex;
  671.            align-items: center;
  672.            justify-content: space-between;
  673.         }
  674.         .sortButtonContainer {
  675.             display: flex;
  676.             align-items: center;
  677.             border-radius: 4px;
  678.             box-shadow: 0 1px 2px #0003;
  679.             border: 1px solid var(--border-color);
  680.             overflow: hidden;
  681.         }
  682.         .sortButton {
  683.            display: flex;
  684.            border: none;
  685.            background: transparent;
  686.            font-family: inherit;
  687.            font-size: inherit;
  688.            line-height: 1.5;
  689.            font-weight: inherit;
  690.            color: inherit;
  691.            resize: none;
  692.            text-transform: inherit;
  693.            letter-spacing: inherit;
  694.            cursor: pointer;
  695.            padding: 4px var(--gap);
  696.            flex: 1;
  697.            text-align: center;
  698.            justify-content: center;
  699.            background-color: var(--darker-color);
  700.         }
  701.         .tabs {
  702.            display: flex;
  703.            align-items: center;
  704.            overflow: hidden;
  705.            border-radius: inherit;
  706.         }
  707.         .tabButton {
  708.             border: none;
  709.             border-radius: 0px !important;
  710.             background: transparent;
  711.             font-family: inherit;
  712.             font-size: inherit;
  713.             line-height: 1.5;
  714.             color: inherit;
  715.             resize: none;
  716.             text-transform: inherit;
  717.             cursor: pointer;
  718.             flex: 1;
  719.             display: flex;
  720.             align-items: center;
  721.             justify-content: center;
  722.             height: 48px;
  723.             font-weight: 600;
  724.             letter-spacing: .25px;
  725.             padding: 0 var(--gap);
  726.             border-radius: 4px 0 0;
  727.         }
  728.         .tabButtonInactive{
  729.             background-color: var(--darker-color);
  730.         }
  731.         .lineRight {
  732.             border-right: 1px solid var(--border-color);
  733.         }
  734.         .lineLeft {
  735.             border-left: 1px solid var(--border-color);
  736.         }
  737.         .lineTop {
  738.             border-top: 1px solid var(--border-color);
  739.         }
  740.         .customCheckBoxText {
  741.             flex: 1;
  742.             color: #aaa
  743.         }
  744.         .customCheckboxCheckbox {
  745.             display: flex;
  746.             justify-content: flex-end;
  747.             min-width: 32px;
  748.             margin-left: var(--margin);
  749.         }
  750.         .customCheckBoxEnabled {
  751.             color: #53bd73
  752.         }
  753.         .customCheckBoxDisabled {
  754.             color: #aaa
  755.         }
  756.         .myBar {
  757.             height: 12px;
  758.             flex: 1;
  759.             background-color: #ffffff0a;
  760.             overflow: hidden;
  761.             max-width: 50%;
  762.             border-radius: 999px;
  763.         }
  764.         .myPercent {
  765.             margin-left: var(--margin);
  766.             margin-right: var(--margin);
  767.             color: #aaa;
  768.         }
  769.         .myListDescription {
  770.             list-style: disc;
  771.             width: 100%;
  772.         }
  773.         .myListLine {
  774.             margin-left: 20px;
  775.         }
  776.     `;
  777.  
  778.     initialise();
  779.  
  780.     return initialised;
  781.  
  782. }
  783. );
  784. // configuration
  785. window.moduleRegistry.add('configuration', (Promise, configurationStore) => {
  786.  
  787.     const exports = {
  788.         registerCheckbox,
  789.         registerInput,
  790.         registerDropdown,
  791.         registerJson,
  792.         items: []
  793.     };
  794.  
  795.     const configs = configurationStore.getConfigs();
  796.  
  797.     const CHECKBOX_KEYS = ['category', 'key', 'name', 'default', 'handler'];
  798.     function registerCheckbox(item) {
  799.         validate(item, CHECKBOX_KEYS);
  800.         return register(Object.assign(item, {
  801.             type: 'checkbox'
  802.         }));
  803.     }
  804.  
  805.     const INPUT_KEYS = ['category', 'key', 'name', 'default', 'inputType', 'handler'];
  806.     function registerInput(item) {
  807.         validate(item, INPUT_KEYS);
  808.         return register(Object.assign(item, {
  809.             type: 'input'
  810.         }));
  811.     }
  812.  
  813.     const DROPDOWN_KEYS = ['category', 'key', 'name', 'options', 'default', 'handler'];
  814.     function registerDropdown(item) {
  815.         validate(item, DROPDOWN_KEYS);
  816.         return register(Object.assign(item, {
  817.             type: 'dropdown'
  818.         }));
  819.     }
  820.  
  821.     const JSON_KEYS = ['key', 'default', 'handler'];
  822.     function registerJson(item) {
  823.         validate(item, JSON_KEYS);
  824.         return register(Object.assign(item, {
  825.             type: 'json'
  826.         }));
  827.     }
  828.  
  829.     function register(item) {
  830.         const handler = item.handler;
  831.         item.handler = (value, isInitial) => {
  832.             item.value = value;
  833.             handler(value, item.key, isInitial);
  834.             if(!isInitial) {
  835.                 save(item, value);
  836.             }
  837.         }
  838.         let initialValue;
  839.         if(item.key in configs) {
  840.             initialValue = configs[item.key];
  841.         } else {
  842.             initialValue = item.default;
  843.         }
  844.         item.handler(initialValue, true);
  845.         exports.items.push(item);
  846.         return item;
  847.     }
  848.  
  849.     async function save(item, value) {
  850.         if(item.type === 'toggle') {
  851.             value = !!value;
  852.         }
  853.         if(item.type === 'input' || item.type === 'json') {
  854.             value = JSON.stringify(value);
  855.         }
  856.         await configurationStore.save(item.key, value);
  857.     }
  858.  
  859.     function validate(item, keys) {
  860.         for(const key of keys) {
  861.             if(!(key in item)) {
  862.                 throw `Missing ${key} while registering a configuration item`;
  863.             }
  864.         }
  865.     }
  866.  
  867.     return exports;
  868.  
  869. }
  870. );
  871. // Distribution
  872. window.moduleRegistry.add('Distribution', () => {
  873.  
  874.     class Distribution {
  875.  
  876.         #map = new Map();
  877.  
  878.         constructor(initial) {
  879.             if(initial) {
  880.                 this.add(initial, 1);
  881.             }
  882.         }
  883.  
  884.         add(value, probability) {
  885.             if(this.#map.has(value)) {
  886.                 this.#map.set(value, this.#map.get(value) + probability);
  887.             } else {
  888.                 this.#map.set(value, probability);
  889.             }
  890.         }
  891.  
  892.         addDistribution(other, weight) {
  893.             other.#map.forEach((probability, value) => {
  894.                 this.add(value, probability * weight);
  895.             });
  896.         }
  897.  
  898.         convolution(other, multiplier) {
  899.             const old = this.#map;
  900.             this.#map = new Map();
  901.             old.forEach((probability, value) => {
  902.                 other.#map.forEach((probability2, value2) => {
  903.                     this.add(multiplier(value, value2), probability * probability2);
  904.                 });
  905.             });
  906.         }
  907.  
  908.         convolutionWithGenerator(generator, multiplier) {
  909.             const result = new Distribution();
  910.             this.#map.forEach((probability, value) => {
  911.                 const other = generator(value);
  912.                 other.#map.forEach((probability2, value2) => {
  913.                     result.add(multiplier(value, value2), probability * probability2);
  914.                 });
  915.             });
  916.             return result;
  917.         }
  918.  
  919.         count() {
  920.             return this.#map.size;
  921.         }
  922.  
  923.         average() {
  924.             let result = 0;
  925.             this.#map.forEach((probability, value) => {
  926.                 result += value * probability;
  927.             });
  928.             return result;
  929.         }
  930.  
  931.         sum() {
  932.             let result = 0;
  933.             this.#map.forEach(probability => {
  934.                 result += probability;
  935.             });
  936.             return result;
  937.         }
  938.  
  939.         min() {
  940.             return Array.from(this.#map, ([k, v]) => k).reduce((a,b) => Math.min(a,b), Infinity);
  941.         }
  942.  
  943.         max() {
  944.             return Array.from(this.#map, ([k, v]) => k).reduce((a,b) => Math.max(a,b), -Infinity);
  945.         }
  946.  
  947.         variance() {
  948.             let result = 0;
  949.             const average = this.average();
  950.             this.#map.forEach((probability, value) => {
  951.                 const dist = average - value;
  952.                 result += dist * dist * probability;
  953.             });
  954.             return result;
  955.         }
  956.  
  957.         normalize() {
  958.             const sum = this.sum();
  959.             this.#map = new Map(Array.from(this.#map, ([k, v]) => [k, v / sum]));
  960.         }
  961.  
  962.         expectedRollsUntill(limit) {
  963.             const x = (this.count() - 1) / 2.0;
  964.             const y = x * (x + 1) * (2 * x + 1) / 6;
  965.             const z = 2*y / this.variance();
  966.             const average = this.average();
  967.             const a = y + average * (average - 1) * z / 2;
  968.             const b = z * average * average;
  969.             return limit / average + a / b;
  970.         }
  971.  
  972.         clone() {
  973.             const result = new Distribution();
  974.             result.#map = new Map(this.#map);
  975.             return result;
  976.         }
  977.  
  978.         getLeftTail(rolls, cutoff) {
  979.             const mean = rolls * this.average();
  980.             const variance = rolls * this.variance();
  981.             const stdev = Math.sqrt(variance);
  982.             return Distribution.cdf(cutoff, mean, stdev);
  983.         }
  984.  
  985.         getRightTail(rolls, cutoff) {
  986.             return 1 - this.getLeftTail(rolls, cutoff);
  987.         }
  988.  
  989.         getRange(rolls, left, right) {
  990.             return 1 - this.getLeftTail(rolls, left) - this.getRightTail(rolls, right);
  991.         }
  992.  
  993.         getMeanLeftTail(rolls, cutoff) {
  994.             return this.getMeanRange(rolls, -Infinity, cutoff);
  995.         }
  996.  
  997.         getMeanRightTail(rolls, cutoff) {
  998.             return this.getMeanRange(rolls, cutoff, Infinity);
  999.         }
  1000.  
  1001.         getMeanRange(rolls, left, right) {
  1002.             const mean = rolls * this.average();
  1003.             const variance = rolls * this.variance();
  1004.             const stdev = Math.sqrt(variance);
  1005.             const alpha = (left - mean) / stdev;
  1006.             const beta = (right - mean) / stdev;
  1007.             const c = Distribution.pdf(beta) - Distribution.pdf(alpha);
  1008.             const d = Distribution.cdf(beta, 0, 1) - Distribution.cdf(alpha, 0, 1);
  1009.             if(!c || !d) {
  1010.                 return (left + right) / 2;
  1011.             }
  1012.             return mean - stdev * c / d;
  1013.         }
  1014.  
  1015.         toChart(other) {
  1016.             if(other) {
  1017.                 const min = Math.min(this.min(), other.min());
  1018.                 const max = Math.max(this.max(), other.max());
  1019.                 for(let i=min;i<=max;i++) {
  1020.                     if(!this.#map.has(i)) {
  1021.                         this.#map.set(i, 0);
  1022.                     }
  1023.                 }
  1024.             }
  1025.             const result = Array.from(this.#map, ([k, v]) => ({x:k,y:v}));
  1026.             result.sort((a,b) => a.x - b.x);
  1027.             return result;
  1028.         }
  1029.  
  1030.         redistribute(value, exceptions) {
  1031.             // redistributes this single value across all others, except the exceptions
  1032.             const probability = this.#map.get(value);
  1033.             if(!probability) {
  1034.                 return;
  1035.             }
  1036.             this.#map.delete(value);
  1037.  
  1038.             let sum = 0;
  1039.             this.#map.forEach((p, v) => {
  1040.                 if(!exceptions.includes(v)) {
  1041.                     sum += p;
  1042.                 }
  1043.             });
  1044.             this.#map.forEach((p, v) => {
  1045.                 if(!exceptions.includes(v)) {
  1046.                     this.#map.set(v, p + probability*p/sum);
  1047.                 }
  1048.             });
  1049.         }
  1050.  
  1051.     };
  1052.  
  1053.     Distribution.getRandomChance = function(probability) {
  1054.         const result = new Distribution();
  1055.         result.add(true, probability);
  1056.         result.add(false, 1-probability);
  1057.         return result;
  1058.     };
  1059.  
  1060.     // probability density function -> probability mass function
  1061.     Distribution.getRandomOutcomeFloored = function(min, max) {
  1062.         const result = new Distribution();
  1063.         const rangeMult = 1 / (max - min);
  1064.         for(let value=Math.floor(min); value<max; value++) {
  1065.             let lower = value;
  1066.             let upper = value + 1;
  1067.             if(lower < min) {
  1068.                 lower = min;
  1069.             }
  1070.             if(upper > max) {
  1071.                 upper = max;
  1072.             }
  1073.             result.add(value, (upper - lower) * rangeMult);
  1074.         }
  1075.         return result;
  1076.     };
  1077.  
  1078.     Distribution.getRandomOutcomeRounded = function(min, max) {
  1079.         return Distribution.getRandomOutcomeFloored(min + 0.5, max + 0.5);
  1080.     }
  1081.  
  1082.     // Cumulative Distribution Function
  1083.     // https://stackoverflow.com/a/59217784
  1084.     Distribution.cdf = function(value, mean, std) {
  1085.         const z = (value - mean) / std;
  1086.         const t = 1 / (1 + .2315419 * Math.abs(z));
  1087.         const d =.3989423 * Math.exp( -z * z / 2);
  1088.         let prob = d * t * (.3193815 + t * ( -.3565638 + t * (1.781478 + t * (-1.821256 + t * 1.330274))));
  1089.         if(z > 0 ) {
  1090.             prob = 1 - prob;
  1091.         }
  1092.         return prob
  1093.     };
  1094.  
  1095.     Distribution.pdf = function(zScore) {
  1096.         return (Math.E ** (-zScore*zScore/2)) / Math.sqrt(2 * Math.PI);
  1097.     };
  1098.  
  1099.     return Distribution;
  1100.  
  1101. }
  1102. );
  1103. // elementCreator
  1104. window.moduleRegistry.add('elementCreator', (colorMapper) => {
  1105.  
  1106.     const exports = {
  1107.         addStyles,
  1108.         getButton,
  1109.         getTag
  1110.     };
  1111.  
  1112.     function addStyles(css) {
  1113.         const head = document.getElementsByTagName('head')[0]
  1114.         if(!head) {
  1115.             console.error('Could not add styles, missing head');
  1116.             return;
  1117.         }
  1118.         const style = document.createElement('style');
  1119.         style.type = 'text/css';
  1120.         style.innerHTML = css;
  1121.         head.appendChild(style);
  1122.     }
  1123.  
  1124.     function getButton(text, onClick) {
  1125.         const element = $(`<button class='myButton'>${text}</button>`)
  1126.             .css('background-color', colorMapper('componentRegular'))
  1127.             .css('display', 'inline-block')
  1128.             .css('padding', '0 5px')
  1129.             .css('margin', '0 5px');
  1130.         if(onClick) {
  1131.             element.click(onClick);
  1132.         }
  1133.         return element;
  1134.     }
  1135.  
  1136.     function getTag(text, image, clazz) {
  1137.         const element = $(`<div>${text}</div>`)
  1138.             .css('border-radius', '4px')
  1139.             .css('padding', '2px 6px')
  1140.             .css('border', '1px solid #263849')
  1141.             .css('font-size', '14px')
  1142.             .css('color', '#aaa')
  1143.             .css('display', 'flex')
  1144.             .css('align-items', 'center')
  1145.             .addClass(clazz);
  1146.         if(image) {
  1147.             const imageElement = $(`<img src='${image}'/>`)
  1148.                 .css('width', '16px')
  1149.                 .css('height', '16px')
  1150.                 .css('image-rendering', 'auto');
  1151.             element.prepend(imageElement);
  1152.         }
  1153.         return element;
  1154.     }
  1155.  
  1156.     return exports;
  1157.  
  1158. }
  1159. );
  1160. // elementWatcher
  1161. window.moduleRegistry.add('elementWatcher', (Promise, polyfill) => {
  1162.  
  1163.     const exports = {
  1164.         exists,
  1165.         childAdded,
  1166.         childAddedContinuous,
  1167.         idle,
  1168.         addRecursiveObserver
  1169.     }
  1170.  
  1171.     const $ = window.$;
  1172.  
  1173.     async function exists(selector, delay, timeout, inverted) {
  1174.         delay = delay !== undefined ? delay : 10;
  1175.         timeout = timeout !== undefined ? timeout : 5000;
  1176.         const promiseWrapper = new Promise.Checking(() => {
  1177.             let result = $(selector)[0];
  1178.             return inverted ? !result : result;
  1179.         }, delay, timeout, `elementWatcher - exists - ${selector}`);
  1180.         return promiseWrapper;
  1181.     }
  1182.  
  1183.     async function childAdded(selector) {
  1184.         const promiseWrapper = new Promise.Expiring(5000, `elementWatcher - childAdded - ${selector}`);
  1185.  
  1186.         try {
  1187.             const parent = await exists(selector);
  1188.             const observer = new MutationObserver(function(mutations, observer) {
  1189.                 for(const mutation of mutations) {
  1190.                     if(mutation.addedNodes?.length) {
  1191.                         observer.disconnect();
  1192.                         promiseWrapper.resolve();
  1193.                     }
  1194.                 }
  1195.             });
  1196.             observer.observe(parent, { childList: true });
  1197.         } catch(error) {
  1198.             promiseWrapper.reject(error);
  1199.         }
  1200.  
  1201.         return promiseWrapper;
  1202.     }
  1203.  
  1204.     async function childAddedContinuous(selector, callback) {
  1205.         const parent = await exists(selector);
  1206.         const observer = new MutationObserver(function(mutations, observer) {
  1207.             if(mutations.find(a => a.addedNodes?.length)) {
  1208.                 callback();
  1209.             }
  1210.         });
  1211.         observer.observe(parent, { childList: true });
  1212.     }
  1213.  
  1214.     async function addRecursiveObserver(callback, ...chain) {
  1215.         const root = await exists(chain[0]);
  1216.         chain = chain.slice(1).map(a => a.toUpperCase());
  1217.         _addRecursiveObserver(callback, root, chain);
  1218.     }
  1219.  
  1220.     function _addRecursiveObserver(callback, element, chain) {
  1221.         if(chain.length === 0) {
  1222.             callback(element);
  1223.         }
  1224.         const observer = new MutationObserver(function(mutations, observer) {
  1225.             const match = mutations
  1226.                 .flatMap(a => Array.from(a.addedNodes))
  1227.                 .find(a => a.tagName === chain[0]);
  1228.             if(match) {
  1229.                 _addRecursiveObserver(callback, match, chain.slice(1));
  1230.             }
  1231.         });
  1232.         observer.observe(element, { childList: true });
  1233.         for(const child of element.children) {
  1234.             if(child.tagName === chain[0]) {
  1235.                 _addRecursiveObserver(callback, child, chain.slice(1));
  1236.             }
  1237.         }
  1238.     }
  1239.  
  1240.     async function idle() {
  1241.         const promise = new Promise.Expiring(1000, 'elementWatcher - idle');
  1242.         polyfill.requestIdleCallback(() => {
  1243.             promise.resolve();
  1244.         });
  1245.         return promise;
  1246.     }
  1247.  
  1248.     return exports;
  1249.  
  1250. }
  1251. );
  1252. // EstimationGenerator
  1253. window.moduleRegistry.add('EstimationGenerator', (events, estimator, statsStore, util, skillCache, itemCache, structuresCache) => {
  1254.  
  1255.     const EVENTS = {
  1256.         exp: {
  1257.             event: 'state-exp',
  1258.             default: skillCache.list.reduce((a,b) => (a[b.id] = {id:b.id,exp:0,level:1}, a), {})
  1259.         },
  1260.         tomes: {
  1261.             event: 'state-equipment-tomes',
  1262.             default: {}
  1263.         },
  1264.         equipment: {
  1265.             event: 'state-equipment-equipment',
  1266.             default: {}
  1267.         },
  1268.         runes: {
  1269.             event: 'state-equipment-runes',
  1270.             default: {}
  1271.         },
  1272.         structures: {
  1273.             event: 'state-structures',
  1274.             default: {}
  1275.         },
  1276.         enhancements: {
  1277.             event: 'state-enhancements',
  1278.             default: {}
  1279.         },
  1280.         guild: {
  1281.             event: 'state-structures-guild',
  1282.             default: {}
  1283.         }
  1284.     };
  1285.  
  1286.     class EstimationGenerator {
  1287.  
  1288.         #backup;
  1289.         #state;
  1290.  
  1291.         constructor() {
  1292.             this.#backup = {};
  1293.             this.#state = this.#backup;
  1294.             for(const name in EVENTS) {
  1295.                 this.#backup[name] = events.getLast(EVENTS[name].event);
  1296.             }
  1297.         }
  1298.  
  1299.         reset() {
  1300.             for(const name in EVENTS) {
  1301.                 this.#state[name] = structuredClone(EVENTS[name].default);
  1302.             }
  1303.             return this;
  1304.         }
  1305.  
  1306.         run(skillId, actionId) {
  1307.             this.#sendCustomEvents();
  1308.             statsStore.update(new Set());
  1309.             const estimation = estimator.get(skillId, actionId);
  1310.             this.#sendBackupEvents();
  1311.             return estimation;
  1312.         }
  1313.  
  1314.         #sendCustomEvents() {
  1315.             for(const name in this.#state) {
  1316.                 events.emit(EVENTS[name].event, this.#state[name]);
  1317.             }
  1318.         }
  1319.  
  1320.         #sendBackupEvents() {
  1321.             for(const name in this.#backup) {
  1322.                 events.emit(EVENTS[name].event, this.#backup[name]);
  1323.             }
  1324.         }
  1325.  
  1326.         level(skill, level, exp = 0) {
  1327.             if(typeof skill === 'string') {
  1328.                 const match = skillCache.byName[skill];
  1329.                 if(!match) {
  1330.                     throw `Could not find skill ${skill}`;
  1331.                 }
  1332.                 skill = match.id;
  1333.             }
  1334.             if(!exp) {
  1335.                 exp = util.levelToExp(level);
  1336.             }
  1337.             this.#state.exp[skill] = {
  1338.                 id: skill,
  1339.                 exp,
  1340.                 level
  1341.             };
  1342.             return this;
  1343.         }
  1344.  
  1345.         equipment(item, amount = 1) {
  1346.             if(typeof item === 'string') {
  1347.                 const match = itemCache.byName[item];
  1348.                 if(!match) {
  1349.                     throw `Could not find item ${item}`;
  1350.                 }
  1351.                 item = match.id;
  1352.             }
  1353.             this.#state.equipment[item] = amount;
  1354.             return this;
  1355.         }
  1356.  
  1357.         rune(item, amount = 1) {
  1358.             if(typeof item === 'string') {
  1359.                 const match = itemCache.byName[item];
  1360.                 if(!match) {
  1361.                     throw `Could not find item ${item}`;
  1362.                 }
  1363.                 item = match.id;
  1364.             }
  1365.             this.#state.runes[item] = amount;
  1366.             return this;
  1367.         }
  1368.  
  1369.         tome(item) {
  1370.             if(typeof item === 'string') {
  1371.                 const match = itemCache.byName[item];
  1372.                 if(!match) {
  1373.                     throw `Could not find item ${item}`;
  1374.                 }
  1375.                 item = match.id;
  1376.             }
  1377.             this.#state.tomes[item] = 1;
  1378.             return this;
  1379.         }
  1380.  
  1381.         structure(structure, level) {
  1382.             if(typeof structure === 'string') {
  1383.                 const match = structuresCache.byName[structure];
  1384.                 if(!match) {
  1385.                     throw `Could not find structure ${structure}`;
  1386.                 }
  1387.                 structure = match.id;
  1388.             }
  1389.             this.#state.structures[structure] = level;
  1390.             return this;
  1391.         }
  1392.  
  1393.         enhancement(structure, level) {
  1394.             if(typeof structure === 'string') {
  1395.                 const match = structuresCache.byName[structure];
  1396.                 if(!match) {
  1397.                     throw `Could not find structure ${structure}`;
  1398.                 }
  1399.                 structure = match.id;
  1400.             }
  1401.             this.#state.enhancements[structure] = level;
  1402.             return this;
  1403.         }
  1404.  
  1405.         guild(structure, level) {
  1406.             if(typeof structure === 'string') {
  1407.                 const match = structuresCache.byName[structure];
  1408.                 if(!match) {
  1409.                     throw `Could not find structure ${structure}`;
  1410.                 }
  1411.                 structure = match.id;
  1412.             }
  1413.             this.#state.guild[structure] = level;
  1414.             return this;
  1415.         }
  1416.  
  1417.         export() {
  1418.             return structuredClone(this.#state);
  1419.         }
  1420.  
  1421.         import(state) {
  1422.             this.#state = structuredClone(state);
  1423.             return this;
  1424.         }
  1425.  
  1426.     }
  1427.  
  1428.     return EstimationGenerator;
  1429.  
  1430. }
  1431. );
  1432. // events
  1433. window.moduleRegistry.add('events', () => {
  1434.  
  1435.     const exports = {
  1436.         register,
  1437.         emit,
  1438.         getLast,
  1439.         getLastCache
  1440.     };
  1441.  
  1442.     const handlers = {};
  1443.     const lastCache = {};
  1444.  
  1445.     function register(name, handler) {
  1446.         if(!handlers[name]) {
  1447.             handlers[name] = [];
  1448.         }
  1449.         handlers[name].push(handler);
  1450.         if(lastCache[name]) {
  1451.             handle(handler, lastCache[name]);
  1452.         }
  1453.     }
  1454.  
  1455.     // options = { skipCache }
  1456.     function emit(name, data, options) {
  1457.         if(!options?.skipCache) {
  1458.             lastCache[name] = data;
  1459.         }
  1460.         if(!handlers[name]) {
  1461.             return;
  1462.         }
  1463.         for(const handler of handlers[name]) {
  1464.             handle(handler, data);
  1465.         }
  1466.     }
  1467.  
  1468.     function handle(handler, data) {
  1469.         try {
  1470.             handler(data);
  1471.         } catch(e) {
  1472.             console.error('Something went wrong', e);
  1473.         }
  1474.     }
  1475.  
  1476.     function getLast(name) {
  1477.         return lastCache[name];
  1478.     }
  1479.  
  1480.     function getLastCache() {
  1481.         return lastCache;
  1482.     }
  1483.  
  1484.     return exports;
  1485.  
  1486. }
  1487. );
  1488. // interceptor
  1489. window.moduleRegistry.add('interceptor', (events) => {
  1490.  
  1491.     function initialise() {
  1492.         registerInterceptorUrlChange();
  1493.         events.emit('url', window.location.href);
  1494.     }
  1495.  
  1496.     function registerInterceptorUrlChange() {
  1497.         const pushState = history.pushState;
  1498.         history.pushState = function() {
  1499.             pushState.apply(history, arguments);
  1500.             console.debug(`Detected page ${arguments[2]}`);
  1501.             events.emit('url', arguments[2]);
  1502.         };
  1503.         const replaceState = history.replaceState;
  1504.         history.replaceState = function() {
  1505.             replaceState.apply(history, arguments);
  1506.             console.debug(`Detected page ${arguments[2]}`);
  1507.             events.emit('url', arguments[2]);
  1508.         }
  1509.     }
  1510.  
  1511.     initialise();
  1512.  
  1513. }
  1514. );
  1515. // itemUtil
  1516. window.moduleRegistry.add('itemUtil', (util, itemCache) => {
  1517.  
  1518.     const exports = {
  1519.         extractItem
  1520.     };
  1521.  
  1522.     function extractItem(element, target, ignoreMissing) {
  1523.         element = $(element);
  1524.         const name = element.find('.name').text();
  1525.         let item = itemCache.byName[name];
  1526.         if(!item) {
  1527.             const src = element.find('img').attr('src');
  1528.             if(src) {
  1529.                 const image = src.split('/').at(-1);
  1530.                 item = itemCache.byImage[image];
  1531.             }
  1532.         }
  1533.         if(!item) {
  1534.             if(!ignoreMissing) {
  1535.                 console.warn(`Could not find item with name [${name}]`);
  1536.             }
  1537.             return false;
  1538.         }
  1539.         let amount = 1;
  1540.         let amountElements = element.find('.amount, .value');
  1541.         let uses = 0;
  1542.         if(amountElements.length) {
  1543.             var amountText = amountElements.text();
  1544.             if(!amountText) {
  1545.                 return false;
  1546.             }
  1547.             if(amountText.includes(' / ')) {
  1548.                 amountText = amountText.split(' / ')[0];
  1549.             }
  1550.             amount = util.parseNumber(amountText);
  1551.             if(amountText.includes('&')) {
  1552.                 const usesText = amountText.split('&')[1];
  1553.                 uses = util.parseNumber(usesText);
  1554.             }
  1555.         }
  1556.         if(!uses) {
  1557.             const usesText = element.find('.uses, .use').text();
  1558.             if(usesText && !usesText.endsWith('HP')) {
  1559.                 uses = util.parseNumber(usesText);
  1560.             }
  1561.         }
  1562.         amount += uses;
  1563.         target[item.id] = (target[item.id] || 0) + amount;
  1564.         return item;
  1565.     }
  1566.  
  1567.     return exports;
  1568.  
  1569. }
  1570. );
  1571. // localDatabase
  1572. window.moduleRegistry.add('localDatabase', (Promise) => {
  1573.  
  1574.     const exports = {
  1575.         getAllEntries,
  1576.         saveEntry,
  1577.         removeEntry
  1578.     };
  1579.  
  1580.     const initialised = new Promise.Expiring(2000, 'localDatabase');
  1581.     let database = null;
  1582.  
  1583.     const databaseName = 'PancakeScripts';
  1584.  
  1585.     function initialise() {
  1586.         const request = window.indexedDB.open(databaseName, 5);
  1587.         request.onsuccess = function(event) {
  1588.             database = this.result;
  1589.             initialised.resolve(exports);
  1590.         };
  1591.         request.onerror = function(event) {
  1592.             console.error(`Failed creating IndexedDB : ${event.target.errorCode}`);
  1593.         };
  1594.         request.onupgradeneeded = function(event) {
  1595.             const db = event.target.result;
  1596.             if(event.oldVersion <= 0) {
  1597.                 console.debug('Creating IndexedDB');
  1598.                 db
  1599.                     .createObjectStore('settings', { keyPath: 'key' })
  1600.                     .createIndex('key', 'key', { unique: true });
  1601.             }
  1602.             if(event.oldVersion <= 1) {
  1603.                 db
  1604.                     .createObjectStore('sync-tracking', { keyPath: 'key' })
  1605.                     .createIndex('key', 'key', { unique: true });
  1606.             }
  1607.             if(event.oldVersion <= 2) {
  1608.                 db
  1609.                     .createObjectStore('market-filters', { keyPath: 'key' })
  1610.                     .createIndex('key', 'key', { unique: true });
  1611.             }
  1612.             if(event.oldVersion <= 3) {
  1613.                 db
  1614.                     .createObjectStore('component-tabs', { keyPath: 'key' })
  1615.                     .createIndex('key', 'key', { unique: true });
  1616.             }
  1617.             if(event.oldVersion <= 4) {
  1618.                 db
  1619.                     .createObjectStore('various', { keyPath: 'key' })
  1620.                     .createIndex('key', 'key', { unique: true });
  1621.             }
  1622.         };
  1623.     }
  1624.  
  1625.     async function getAllEntries(storeName) {
  1626.         const result = new Promise.Expiring(1000, 'localDatabase - getAllEntries');
  1627.         const entries = [];
  1628.         const store = database.transaction(storeName, 'readonly').objectStore(storeName);
  1629.         const request = store.openCursor();
  1630.         request.onsuccess = function(event) {
  1631.             const cursor = event.target.result;
  1632.             if(cursor) {
  1633.                 entries.push(cursor.value);
  1634.                 cursor.continue();
  1635.             } else {
  1636.                 result.resolve(entries);
  1637.             }
  1638.         };
  1639.         request.onerror = function(event) {
  1640.             result.reject(event.error);
  1641.         };
  1642.         return result;
  1643.     }
  1644.  
  1645.     async function saveEntry(storeName, entry) {
  1646.         const result = new Promise.Expiring(1000, 'localDatabase - saveEntry');
  1647.         const store = database.transaction(storeName, 'readwrite').objectStore(storeName);
  1648.         const request = store.put(entry);
  1649.         request.onsuccess = function(event) {
  1650.             result.resolve();
  1651.         };
  1652.         request.onerror = function(event) {
  1653.             result.reject(event.error);
  1654.         };
  1655.         return result;
  1656.     }
  1657.  
  1658.     async function removeEntry(storeName, key) {
  1659.         const result = new Promise.Expiring(1000, 'localDatabase - removeEntry');
  1660.         const store = database.transaction(storeName, 'readwrite').objectStore(storeName);
  1661.         const request = store.delete(key);
  1662.         request.onsuccess = function(event) {
  1663.             result.resolve();
  1664.         };
  1665.         request.onerror = function(event) {
  1666.             result.reject(event.error);
  1667.         };
  1668.         return result;
  1669.     }
  1670.  
  1671.     initialise();
  1672.  
  1673.     return initialised;
  1674.  
  1675. }
  1676. );
  1677. // logService
  1678. window.moduleRegistry.add('logService', () => {
  1679.  
  1680.     const exports = {
  1681.         error,
  1682.         get
  1683.     };
  1684.  
  1685.     const errors = [];
  1686.  
  1687.     function initialise() {
  1688.         window.onerror = function(message, url, lineNumber, columnNumber, error) {
  1689.             errors.push({
  1690.                 time: Date.now(),
  1691.                 message,
  1692.                 url,
  1693.                 lineNumber,
  1694.                 columnNumber,
  1695.                 error
  1696.             });
  1697.             return false;
  1698.         };
  1699.     }
  1700.  
  1701.     function error() {
  1702.         errors.push({
  1703.             time: Date.now(),
  1704.             value: [...arguments]
  1705.         });
  1706.     }
  1707.  
  1708.     function get() {
  1709.         return errors;
  1710.     }
  1711.  
  1712.     initialise();
  1713.  
  1714.     return exports;
  1715.  
  1716. });
  1717. // pageDetector
  1718. window.moduleRegistry.add('pageDetector', (events, elementWatcher, util) => {
  1719.  
  1720.     const emitEvent = events.emit.bind(null, 'page');
  1721.     const debouncedUpdate = util.debounce(update, 100);
  1722.  
  1723.     async function initialise() {
  1724.         events.register('url', debouncedUpdate);
  1725.         $(document).on('click', 'taming-page .header:contains("Menu") ~ button', () => debouncedUpdate());
  1726.         $(document).on('click', 'taming-page .header:contains("Expeditions") ~ button', () => debouncedUpdate());
  1727.         $(document).on('click', 'taming-page .header:contains("Expeditions") > button', () => debouncedUpdate());
  1728.     }
  1729.  
  1730.     async function update(url) {
  1731.         if(!url) {
  1732.             url = events.getLast('url');
  1733.         }
  1734.         let result = null;
  1735.         const parts = url.split('/');
  1736.         await elementWatcher.idle();
  1737.         if(url.includes('/skill/15')) {
  1738.             const menu = $('taming-page .header:contains("Menu") ~ button.row-active .name').text().toLowerCase();
  1739.             let tier = 0;
  1740.             if(menu === 'expeditions') {
  1741.                 const level = util.parseNumber($('taming-page .header:contains("Expeditions") ~ button.row-active .level').text());
  1742.                 tier = util.levelToTier(level);
  1743.             }
  1744.             result = {
  1745.                 type: 'taming',
  1746.                 menu,
  1747.                 tier
  1748.             };
  1749.         } else if(url.includes('/skill/') && url.includes('/action/')) {
  1750.             result = {
  1751.                 type: 'action',
  1752.                 skill: +parts[parts.length-3],
  1753.                 action: +parts[parts.length-1]
  1754.             };
  1755.         } else if(url.includes('house/build')) {
  1756.             result = {
  1757.                 type: 'structure',
  1758.                 structure: +parts[parts.length-1]
  1759.             };
  1760.         } else if(url.includes('house/enhance')) {
  1761.             result = {
  1762.                 type: 'enhancement',
  1763.                 structure: +parts[parts.length-1]
  1764.             };
  1765.         } else if(url.includes('house/produce')) {
  1766.             result = {
  1767.                 type: 'automation',
  1768.                 structure: +parts[parts.length-2],
  1769.                 action: +parts[parts.length-1]
  1770.             };
  1771.         } else {
  1772.             result = {
  1773.                 type: parts.pop()
  1774.             };
  1775.         }
  1776.         emitEvent(result);
  1777.     }
  1778.  
  1779.     initialise();
  1780.  
  1781. }
  1782. );
  1783. // pages
  1784. window.moduleRegistry.add('pages', (elementWatcher, events, colorMapper, util, skillCache, elementCreator) => {
  1785.  
  1786.     const registerPageHandler = events.register.bind(null, 'page');
  1787.     const getLastPage = events.getLast.bind(null, 'page');
  1788.  
  1789.     const exports = {
  1790.         register,
  1791.         requestRender,
  1792.         show,
  1793.         hide,
  1794.         open: visitPage
  1795.     }
  1796.  
  1797.     const pages = [];
  1798.  
  1799.     function initialise() {
  1800.         registerPageHandler(handlePage);
  1801.         elementCreator.addStyles(styles);
  1802.     }
  1803.  
  1804.     function handlePage(page) {
  1805.         // handle navigating away
  1806.         if(!pages.some(p => p.path === page.type)) {
  1807.             $('custom-page').remove();
  1808.             $('nav-component > div.nav > div.scroll > button')
  1809.                 .removeClass('customActiveLink');
  1810.             $('header-component div.wrapper > div.image > img')
  1811.                 .css('image-rendering', '');
  1812.             headerPageNameChangeBugFix(page);
  1813.         }
  1814.     }
  1815.  
  1816.     async function register(page) {
  1817.         if(pages.some(p => p.name === page.name)) {
  1818.             console.error(`Custom page already registered : ${page.name}`);
  1819.             return;
  1820.         }
  1821.         page.path = page.name.toLowerCase().replaceAll(' ', '-');
  1822.         page.class = `customMenuButton_${page.path}`;
  1823.         page.image = page.image || 'https://ironwoodrpg.com/assets/misc/settings.png';
  1824.         page.category = page.category?.toUpperCase() || 'MISC';
  1825.         page.columns = page.columns || 1;
  1826.         pages.push(page);
  1827.         console.debug('Registered pages', pages);
  1828.         await setupNavigation(page);
  1829.     }
  1830.  
  1831.     function show(name) {
  1832.         const page = pages.find(p => p.name === name)
  1833.         if(!page) {
  1834.             console.error(`Could not find page : ${name}`);
  1835.             return;
  1836.         }
  1837.         $(`.${page.class}`).show();
  1838.     }
  1839.  
  1840.     function hide(name) {
  1841.         const page = pages.find(p => p.name === name)
  1842.         if(!page) {
  1843.             console.error(`Could not find page : ${name}`);
  1844.             return;
  1845.         }
  1846.         $(`.${page.class}`).hide();
  1847.     }
  1848.  
  1849.     function requestRender(name) {
  1850.         const page = pages.find(p => p.name === name)
  1851.         if(!page) {
  1852.             console.error(`Could not find page : ${name}`);
  1853.             return;
  1854.         }
  1855.         if(getLastPage()?.type === page.path) {
  1856.             render(page);
  1857.         }
  1858.     }
  1859.  
  1860.     function render(page) {
  1861.         $('.customComponent').remove();
  1862.         page.render();
  1863.     }
  1864.  
  1865.     async function setupNavigation(page) {
  1866.         await elementWatcher.exists('div.nav > div.scroll');
  1867.         // MENU HEADER / CATEGORY
  1868.         let menuHeader = $(`nav-component > div.nav > div.scroll > div.header:contains('${page.category}'), div.customMenuHeader:contains('${page.category}')`);
  1869.         if(!menuHeader.length) {
  1870.             menuHeader = createMenuHeader(page.category);
  1871.         }
  1872.         // MENU BUTTON / PAGE LINK
  1873.         const menuButton = createMenuButton(page)
  1874.         // POSITIONING
  1875.         if(page.after) {
  1876.             $(`nav-component button:contains('${page.after}')`).after(menuButton);
  1877.         } else {
  1878.             menuHeader.after(menuButton);
  1879.         }
  1880.     }
  1881.  
  1882.     function createMenuHeader(text) {
  1883.         const menuHeader =
  1884.             $('<div/>')
  1885.                 .addClass('header customMenuHeader')
  1886.                 .append(
  1887.                     $('<div/>')
  1888.                         .addClass('customMenuHeaderText')
  1889.                         .text(text)
  1890.                 );
  1891.         $('nav-component > div.nav > div.scroll')
  1892.             .prepend(menuHeader);
  1893.         return menuHeader;
  1894.     }
  1895.  
  1896.     function createMenuButton(page) {
  1897.         const menuButton =
  1898.             $('<button/>')
  1899.                 .attr('type', 'button')
  1900.                 .addClass(`customMenuButton ${page.class}`)
  1901.                 .css('display', 'none')
  1902.                 .click(() => visitPage(page.name))
  1903.                 .append(
  1904.                     $('<img/>')
  1905.                         .addClass('customMenuButtonImage')
  1906.                         .attr('src', page.image)
  1907.                         .css('image-rendering', page.imagePixelated ? 'pixelated' : 'auto')
  1908.                 )
  1909.                 .append(
  1910.                     $('<div/>')
  1911.                         .addClass('customMenuButtonText')
  1912.                         .text(page.name)
  1913.                 );
  1914.         return menuButton;
  1915.     }
  1916.  
  1917.     async function visitPage(name) {
  1918.         const page = pages.find(p => p.name === name);
  1919.         if($('custom-page').length) {
  1920.             $('custom-page').remove();
  1921.         } else {
  1922.             await setupEmptyPage();
  1923.         }
  1924.         createPage(page.columns);
  1925.         updatePageHeader(page);
  1926.         updateActivePageInNav(page.name);
  1927.         history.pushState({}, '', page.path);
  1928.         page.render();
  1929.     }
  1930.  
  1931.     async function setupEmptyPage() {
  1932.         util.goToPage('settings');
  1933.         await elementWatcher.exists('settings-page');
  1934.         $('settings-page').remove();
  1935.     }
  1936.  
  1937.     function createPage(columnCount) {
  1938.         const custompage = $('<custom-page/>');
  1939.         const columns = $('<div/>')
  1940.             .addClass('customGroups');
  1941.         for(let columnIndex = 0; columnIndex < columnCount; columnIndex++) {
  1942.             columns.append(
  1943.                 $('<div/>')
  1944.                     .addClass('customGroup')
  1945.                     .addClass(`column${columnIndex}`)
  1946.             )
  1947.         };
  1948.         custompage.append(columns);
  1949.         $('div.padding > div.wrapper > router-outlet').after(custompage);
  1950.     }
  1951.  
  1952.     function updatePageHeader(page) {
  1953.         $('header-component div.wrapper > div.image > img')
  1954.             .attr('src', page.image)
  1955.             .css('image-rendering', page.imagePixelated ? 'pixelated' : 'auto');
  1956.         $('header-component div.wrapper > div.title').text(page.name);
  1957.     }
  1958.  
  1959.     function updateActivePageInNav(name) {
  1960.         //Set other pages as inactive
  1961.         $(`nav-component > div.nav > div.scroll > button`)
  1962.             .removeClass('active-link')
  1963.             .removeClass('customActiveLink');
  1964.         //Set this page as active
  1965.         $(`nav-component > div.nav > div.scroll > button > div.customMenuButtonText:contains('${name}')`)
  1966.             .parent()
  1967.             .addClass('customActiveLink');
  1968.     }
  1969.  
  1970.     // hacky shit, idk why angular stops updating page header title ???
  1971.     async function headerPageNameChangeBugFix(page) {
  1972.         await elementWatcher.exists('nav-component > div.nav');
  1973.         let headerName = null;
  1974.         if(page.type === 'action') {
  1975.             headerName = skillCache.byId[page.skill].displayName;
  1976.         } else if(page.type === 'structure') {
  1977.             headerName = 'House';
  1978.         } else if(page.type === 'enhancement') {
  1979.             headerName = 'House';
  1980.         } else if(page.type === 'automation') {
  1981.             headerName = 'House';
  1982.         } else if(page.type === 'taming') {
  1983.             headerName = 'Taming';
  1984.         } else {
  1985.             headerName = page.type;
  1986.             headerName = headerName.charAt(0).toUpperCase() + headerName.slice(1);
  1987.         }
  1988.         $('header-component div.wrapper > div.title').text(headerName);
  1989.     }
  1990.  
  1991.     const styles = `
  1992.         :root {
  1993.             --background-color: ${colorMapper('componentRegular')};
  1994.             --border-color: ${colorMapper('componentLight')};
  1995.             --darker-color: ${colorMapper('componentDark')};
  1996.         }
  1997.         .customMenuHeader {
  1998.             height: 56px;
  1999.             display: flex;
  2000.             align-items: center;
  2001.             padding: 0 24px;
  2002.             color: #aaa;
  2003.             font-size: .875rem;
  2004.             font-weight: 600;
  2005.             letter-spacing: 1px;
  2006.             text-transform: uppercase;
  2007.             border-bottom: 1px solid var(--border-color);
  2008.             background-color: var(--background-color);
  2009.         }
  2010.         .customMenuHeaderText {
  2011.             flex: 1;
  2012.         }
  2013.         .customMenuButton {
  2014.             border: none;
  2015.             background: transparent;
  2016.             font-family: inherit;
  2017.             font-size: inherit;
  2018.             line-height: 1.5;
  2019.             font-weight: inherit;
  2020.             color: inherit;
  2021.             resize: none;
  2022.             text-transform: inherit;
  2023.             letter-spacing: inherit;
  2024.             cursor: pointer;
  2025.             height: 56px;
  2026.             display: flex;
  2027.             align-items: center;
  2028.             padding: 0 24px;
  2029.             border-bottom: 1px solid var(--border-color);
  2030.             width: 100%;
  2031.             text-align: left;
  2032.             position: relative;
  2033.             background-color: var(--background-color);
  2034.         }
  2035.         .customMenuButtonImage {
  2036.             max-width: 100%;
  2037.             max-height: 100%;
  2038.             height: 32px;
  2039.             width: 32px;
  2040.         }
  2041.         .customMenuButtonText {
  2042.             margin-left: var(--margin);
  2043.             flex: 1;
  2044.         }
  2045.         .customGroups {
  2046.             display: flex;
  2047.             gap: var(--gap);
  2048.             flex-wrap: wrap;
  2049.         }
  2050.         .customGroup {
  2051.             flex: 1;
  2052.             min-width: 360px;
  2053.         }
  2054.         .customActiveLink {
  2055.             background-color: var(--darker-color);
  2056.         }
  2057.     `;
  2058.  
  2059.     initialise();
  2060.  
  2061.     return exports
  2062. }
  2063. );
  2064. // petUtil
  2065. window.moduleRegistry.add('petUtil', (petCache, petTraitCache, petPassiveCache, expeditionCache, util) => {
  2066.  
  2067.     const STATS_BASE = ['health', 'speed', 'attack', 'specialAttack', 'defense', 'specialDefense'];
  2068.     const STATS_SPECIAL = ['hunger', 'stealth', 'loot'];
  2069.     const STATS_ABILITIES = ['bones', 'fish', 'flowers', 'ore', 'veges', 'wood'];
  2070.     const IMAGES = {
  2071.         health: 'https://cdn-icons-png.flaticon.com/512/2589/2589054.png',
  2072.         speed: 'https://img.icons8.com/?size=48&id=TE1T4XfT3xeN',
  2073.         attack: 'https://cdn-icons-png.flaticon.com/512/9743/9743017.png',
  2074.         defense: 'https://cdn-icons-png.flaticon.com/512/2592/2592488.png',
  2075.         specialAttack: 'https://img.icons8.com/?size=48&id=18515',
  2076.         specialDefense: 'https://img.icons8.com/?size=48&id=CWksSHWEtOtX',
  2077.         hunger: 'https://img.icons8.com/?size=48&id=AXExnoyylJdK',
  2078.         stealth: 'https://img.icons8.com/?size=48&id=4GYmMTXrMp8g',
  2079.         loot: 'https://img.icons8.com/?size=48&id=M2yQkpBAlIS8'
  2080.     };
  2081.     const exports = {
  2082.         STATS_BASE,
  2083.         STATS_SPECIAL,
  2084.         IMAGES,
  2085.         petToText,
  2086.         textToPet,
  2087.         isEncodedPetName,
  2088.         petToStats,
  2089.         getExpeditionStats
  2090.     };
  2091.  
  2092.     const SPECIAL_CHAR = '_';
  2093.     const VALID_CHARS = '!"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_abcdefghijklmnopqrstuvwxyz{|}'.split('');
  2094.     const VALID_CHARS_LENGTH = BigInt(VALID_CHARS.length);
  2095.     const OPTIONS = [
  2096.         petCache.list.length, // species
  2097.         petTraitCache.list.length, // traits
  2098.         ...Array(6).fill(50), // stats
  2099.         ...Array(4).fill(petPassiveCache.list.length+1) // passives, 0 = empty
  2100.     ];
  2101.  
  2102.     const MILLIS_PER_MINUTE = 1000*60;
  2103.     const MILLIS_PER_WEEK = 1000*60*60*24*7;
  2104.  
  2105.     function numberToText(number) {
  2106.         let text = SPECIAL_CHAR;
  2107.         while(number > 0) {
  2108.             text += VALID_CHARS[number%VALID_CHARS_LENGTH];
  2109.             number /= VALID_CHARS_LENGTH;
  2110.         }
  2111.         return text;
  2112.     }
  2113.  
  2114.     function textToNumber(text) {
  2115.         let number = 0n;
  2116.         text = text.slice(1);
  2117.         while(text.length) {
  2118.             number *= VALID_CHARS_LENGTH;
  2119.             number += BigInt(VALID_CHARS.indexOf(text[text.length-1]));
  2120.             text = text.slice(0,-1);
  2121.         }
  2122.         return number;
  2123.     }
  2124.  
  2125.     function choicesToNumber(choices, options) {
  2126.         if(choices.length !== options.length) {
  2127.             throw `Expected lengths to be equal : ${choices.length} and ${options.length}`;
  2128.         }
  2129.         let number = 0n;
  2130.         for(let i=0;i<choices.length;i++) {
  2131.             if(choices[i] >= options[i]) {
  2132.                 throw `${choices[i]} is outside of options range ${options[i]}`;
  2133.             }
  2134.             number *= BigInt(options[i]);
  2135.             number += BigInt(choices[i]);
  2136.         }
  2137.         return number;
  2138.     }
  2139.  
  2140.     function numberToChoices(number, options) {
  2141.         const choices = [];
  2142.         for(let i=options.length-1;i>=0;i--) {
  2143.             if(i > 0) {
  2144.                 choices.unshift(Number(number % BigInt(options[i])));
  2145.                 number /= BigInt(options[i]);
  2146.             } else {
  2147.                 choices.unshift(Number(number));
  2148.             }
  2149.         }
  2150.         return choices;
  2151.     }
  2152.  
  2153.     function petToChoices(pet) {
  2154.         const passives = pet.passives.map(a => petPassiveCache.idToIndex[a]+1);
  2155.         while(passives.length < 4) {
  2156.             passives.push(0);
  2157.         }
  2158.         return [
  2159.             petCache.idToIndex[pet.species], // species
  2160.             petTraitCache.idToIndex[pet.traits], // traits
  2161.             pet.health/2-1,
  2162.             pet.attack/2-1,
  2163.             pet.defense/2-1,
  2164.             pet.specialAttack/2-1,
  2165.             pet.specialDefense/2-1,
  2166.             pet.speed/2-1, // stats
  2167.             ...passives // passives, 0 = empty
  2168.         ];
  2169.     }
  2170.  
  2171.     function choicesToPet(choices, text) {
  2172.         return {
  2173.             parsed: true,
  2174.             species: petCache.list[choices[0]].id,
  2175.             name: text,
  2176.             traits: petTraitCache.list[choices[1]].id,
  2177.             health: (choices[2]+1)*2,
  2178.             attack: (choices[3]+1)*2,
  2179.             defense: (choices[4]+1)*2,
  2180.             specialAttack: (choices[5]+1)*2,
  2181.             specialDefense: (choices[6]+1)*2,
  2182.             speed: (choices[7]+1)*2,
  2183.             passives: choices.slice(8).filter(a => a).map(a => petPassiveCache.list[a-1].id)
  2184.         };
  2185.     }
  2186.  
  2187.     function petToText(pet) {
  2188.         const choices = petToChoices(pet);
  2189.         const number = choicesToNumber(choices, OPTIONS);
  2190.         return numberToText(number);
  2191.     }
  2192.  
  2193.     function textToPet(text) {
  2194.         const number = textToNumber(text);
  2195.         const choices = numberToChoices(number, OPTIONS);
  2196.         return choicesToPet(choices, text);
  2197.     }
  2198.  
  2199.     function isEncodedPetName(text) {
  2200.         return text.startsWith(SPECIAL_CHAR);
  2201.     }
  2202.  
  2203.     function petToStats(pet) {
  2204.         const result = {};
  2205.         const passives = pet.passives.map(id => petPassiveCache.byId[id]);
  2206.         const traits = petTraitCache.byId[pet.traits];
  2207.         for(const stat of STATS_BASE) {
  2208.             result[stat] = 0;
  2209.             let value = (petCache.byId[pet.species].power + pet[stat] / 2 - 10) / 100 * pet.level + 10;
  2210.             value *= traits[stat] ? 1.25 : 1;
  2211.             const passive = passives.find(a => a.stats.name === stat + 'Percent');
  2212.             if(passive) {
  2213.                 value *= 1 + passive.stats.value / 100;
  2214.             }
  2215.             result[stat] += value;
  2216.         }
  2217.         for(const stat of STATS_SPECIAL) {
  2218.             result[stat] = 0;
  2219.             const passive = passives.find(a => a.stats.name === stat + 'Percent');
  2220.             if(passive) {
  2221.                 result[stat] += passive.stats.value;
  2222.             }
  2223.         }
  2224.         for(const ability of STATS_ABILITIES) {
  2225.             result[ability] = 0;
  2226.         }
  2227.         const abilities = petCache.byId[pet.species].abilities;
  2228.         for(const ability of abilities) {
  2229.             const key = Object.keys(ability)[0];
  2230.             result[key] = ability[key];
  2231.         }
  2232.         for(const key of Object.keys(result)) {
  2233.             result[key] = Math.round(result[key]);
  2234.         }
  2235.         return result;
  2236.     }
  2237.  
  2238.     function getExpeditionStats(tier) {
  2239.         const expedition = expeditionCache.byTier[tier];
  2240.         const rotation = getCurrentRotation(expedition.tier);
  2241.         const stats = {};
  2242.         for(const stat of STATS_BASE) {
  2243.             stats[stat] = expedition.power;
  2244.             if(rotation[stat]) {
  2245.                 stats[stat] *= 1.25;
  2246.             }
  2247.         }
  2248.         return Object.assign({rotation,stats}, expedition);
  2249.     }
  2250.  
  2251.     function getCurrentRotation(offset) {
  2252.         const now = new Date();
  2253.         const date = new Date(now.getTime() + MILLIS_PER_MINUTE * now.getTimezoneOffset());
  2254.         const millisPassed = util.startOfWeek(date) - util.startOfWeek(util.startOfYear(date));
  2255.         const startOfWeek = util.startOfWeek(date);
  2256.         let index = 2 + offset + Math.round(millisPassed / MILLIS_PER_WEEK);
  2257.         index %= petTraitCache.list.length;
  2258.         return petTraitCache.byId[index];
  2259.     }
  2260.  
  2261.     return exports;
  2262.  
  2263. });
  2264. // polyfill
  2265. window.moduleRegistry.add('polyfill', () => {
  2266.  
  2267.     const exports = {
  2268.         requestIdleCallback
  2269.     };
  2270.  
  2271.     function requestIdleCallback() {
  2272.         if(!window.requestIdleCallback) {
  2273.             window.requestIdleCallback = function(callback, options) {
  2274.                 var options = options || {};
  2275.                 var relaxation = 1;
  2276.                 var timeout = options.timeout || relaxation;
  2277.                 var start = performance.now();
  2278.                 return setTimeout(function () {
  2279.                     callback({
  2280.                         get didTimeout() {
  2281.                             return options.timeout ? false : (performance.now() - start) - relaxation > timeout;
  2282.                         },
  2283.                         timeRemaining: function () {
  2284.                             return Math.max(0, relaxation + (performance.now() - start));
  2285.                         },
  2286.                     });
  2287.                 }, relaxation);
  2288.             };
  2289.         }
  2290.         return window.requestIdleCallback(...arguments);
  2291.     }
  2292.  
  2293.     return exports;
  2294.  
  2295. }
  2296. );
  2297. // Promise
  2298. window.moduleRegistry.add('Promise', (logService) => {
  2299.  
  2300.     class Deferred {
  2301.         #name;
  2302.         #promise;
  2303.         resolve;
  2304.         reject;
  2305.         constructor(name) {
  2306.             this.#name = name;
  2307.             this.#promise = new Promise((resolve, reject) => {
  2308.                 this.resolve = resolve;
  2309.                 this.reject = reject;
  2310.             }).catch(error => {
  2311.                 if(error) {
  2312.                     console.warn(error);
  2313.                     logService.error(`error in ${this.constructor.name} (${this.#name})`, error);
  2314.                 }
  2315.                 throw error;
  2316.             });
  2317.         }
  2318.  
  2319.         then() {
  2320.             this.#promise.then.apply(this.#promise, arguments);
  2321.             return this;
  2322.         }
  2323.  
  2324.         catch() {
  2325.             this.#promise.catch.apply(this.#promise, arguments);
  2326.             return this;
  2327.         }
  2328.  
  2329.         finally() {
  2330.             this.#promise.finally.apply(this.#promise, arguments);
  2331.             return this;
  2332.         }
  2333.     }
  2334.  
  2335.     class Delayed extends Deferred {
  2336.         constructor(timeout, name) {
  2337.             super(name);
  2338.             const timeoutReference = window.setTimeout(() => {
  2339.                 this.resolve();
  2340.             }, timeout);
  2341.             this.finally(() => {
  2342.                 window.clearTimeout(timeoutReference)
  2343.             });
  2344.         }
  2345.     }
  2346.  
  2347.     class Expiring extends Deferred {
  2348.         constructor(timeout, name) {
  2349.             super(name);
  2350.             if(timeout <= 0) {
  2351.                 return;
  2352.             }
  2353.             const timeoutReference = window.setTimeout(() => {
  2354.                 this.reject(`Timed out after ${timeout} ms`);
  2355.             }, timeout);
  2356.             this.finally(() => {
  2357.                 window.clearTimeout(timeoutReference)
  2358.             });
  2359.         }
  2360.     }
  2361.  
  2362.     class Checking extends Expiring {
  2363.         #checker;
  2364.         constructor(checker, interval, timeout, name) {
  2365.             super(timeout, name);
  2366.             this.#checker = checker;
  2367.             this.#check();
  2368.             const intervalReference = window.setInterval(this.#check.bind(this), interval);
  2369.             this.finally(() => {
  2370.                 window.clearInterval(intervalReference)
  2371.             });
  2372.         }
  2373.         #check() {
  2374.             const checkResult = this.#checker();
  2375.             if(!checkResult) {
  2376.                 return;
  2377.             }
  2378.             this.resolve(checkResult);
  2379.         }
  2380.     }
  2381.  
  2382.     return {
  2383.         Deferred,
  2384.         Delayed,
  2385.         Expiring,
  2386.         Checking
  2387.     };
  2388.  
  2389. }
  2390. );
  2391. // request
  2392. window.moduleRegistry.add('request', () => {
  2393.  
  2394.     async function request(url, body, headers) {
  2395.         if(!headers) {
  2396.             headers = {};
  2397.         }
  2398.         headers['Content-Type'] = 'application/json';
  2399.         const method = body ? 'POST' : 'GET';
  2400.         try {
  2401.             if(body) {
  2402.                 body = JSON.stringify(body);
  2403.             }
  2404.             const fetchResponse = await fetch(`${window.PANCAKE_ROOT}/${url}`, {method, headers, body});
  2405.             if(fetchResponse.status !== 200) {
  2406.                 console.error(await fetchResponse.text());
  2407.                 console.log('response', fetchResponse);
  2408.                 throw fetchResponse;
  2409.             }
  2410.             try {
  2411.                 const contentType = fetchResponse.headers.get('Content-Type');
  2412.                 if(contentType.startsWith('text/plain')) {
  2413.                     return await fetchResponse.text();
  2414.                 } else if(contentType.startsWith('application/json')) {
  2415.                     return await fetchResponse.json();
  2416.                 } else {
  2417.                     console.error(`Unknown content type : ${contentType}`);
  2418.                 }
  2419.             } catch(e) {
  2420.                 if(body) {
  2421.                     return 'OK';
  2422.                 }
  2423.             }
  2424.         } catch(e) {
  2425.             console.log('error', e);
  2426.             throw `Failed fetching ${url} : ${e}`;
  2427.         }
  2428.     }
  2429.  
  2430.     // alphabetical
  2431.  
  2432.     request.listActions = () => request('public/list/action');
  2433.     request.listDrops = () => request('public/list/drop');
  2434.     request.listExpeditions = () => request('public/list/expedition');
  2435.     request.listExpeditionDrops = () => request('public/list/expeditionDrop');
  2436.     request.listItems = () => request('public/list/item');
  2437.     request.listItemAttributes = () => request('public/list/itemAttribute');
  2438.     request.listIngredients = () => request('public/list/ingredient');
  2439.     request.listMonsters = () => request('public/list/monster');
  2440.     request.listPets = () => request('public/list/pet');
  2441.     request.listPetPassives = () => request('public/list/petPassive');
  2442.     request.listRecipes = () => request('public/list/recipe');
  2443.     request.listSkills = () => request('public/list/skill');
  2444.     request.listStructures = () => request('public/list/structure');
  2445.  
  2446.     request.report = (data) => request('public/report', data);
  2447.  
  2448.     request.getChangelogs = () => request('public/settings/changelog');
  2449.     request.getVersion = () => request('public/settings/version');
  2450.  
  2451.     return request;
  2452.  
  2453. }
  2454. );
  2455. // toast
  2456. window.moduleRegistry.add('toast', (util, elementCreator) => {
  2457.  
  2458.     const exports = {
  2459.         create,
  2460.         copyToClipboard
  2461.     };
  2462.  
  2463.     function initialise() {
  2464.         elementCreator.addStyles(styles);
  2465.     }
  2466.  
  2467.     // text, time, image
  2468.     async function create(config) {
  2469.         config.time ||= 2000;
  2470.         config.image ||= 'https://ironwoodrpg.com/assets/misc/quests.png';
  2471.         const notificationId = `customNotification_${Math.floor(Date.now() * Math.random())}`
  2472.         const notificationDiv =
  2473.             $('<div/>')
  2474.                 .addClass('customNotification')
  2475.                 .attr('id', notificationId)
  2476.                 .append(
  2477.                     $('<div/>')
  2478.                         .addClass('customNotificationImageDiv')
  2479.                         .append(
  2480.                             $('<img/>')
  2481.                                 .addClass('customNotificationImage')
  2482.                                 .attr('src', config.image)
  2483.                         )
  2484.                 )
  2485.                 .append(
  2486.                     $('<div/>')
  2487.                         .addClass('customNotificationDetails')
  2488.                         .html(config.text)
  2489.                 );
  2490.         $('div.notifications').append(notificationDiv);
  2491.         await util.sleep(config.time);
  2492.         $(`#${notificationId}`).fadeOut('slow', () => {
  2493.             $(`#${notificationId}`).remove();
  2494.         });
  2495.     }
  2496.  
  2497.     function copyToClipboard(text, message) {
  2498.         navigator.clipboard.writeText(text);
  2499.         create({
  2500.             text: message,
  2501.             image: 'https://img.icons8.com/?size=48&id=22244'
  2502.         });
  2503.     }
  2504.  
  2505.     const styles = `
  2506.         .customNotification {
  2507.             padding: 8px 16px 8px 12px;
  2508.             border-radius: 4px;
  2509.             backdrop-filter: blur(8px);
  2510.             background: rgba(255,255,255,.15);
  2511.             box-shadow: 0 8px 16px -4px #00000080;
  2512.             display: flex;
  2513.             align-items: center;
  2514.             min-height: 48px;
  2515.             margin-top: 12px;
  2516.             pointer-events: all;
  2517.         }
  2518.         .customNotificationImageDiv {
  2519.             display: flex;
  2520.             align-items: center;
  2521.             justify-content: center;
  2522.             width: 32px;
  2523.             height: 32px;
  2524.         }
  2525.         .customNotificationImage {
  2526.             filter: drop-shadow(0px 8px 4px rgba(0,0,0,.1));
  2527.             image-rendering: auto;
  2528.         }
  2529.         .customNotificationDetails {
  2530.             margin-left: 8px;
  2531.             text-align: center;
  2532.         }
  2533.     `;
  2534.  
  2535.     initialise();
  2536.  
  2537.     return exports;
  2538. }
  2539. );
  2540. // util
  2541. window.moduleRegistry.add('util', () => {
  2542.  
  2543.     const exports = {
  2544.         levelToExp,
  2545.         expToLevel,
  2546.         expToCurrentExp,
  2547.         expToNextLevel,
  2548.         expToNextTier,
  2549.         tierToLevel,
  2550.         levelToTier,
  2551.         formatNumber,
  2552.         parseNumber,
  2553.         secondsToDuration,
  2554.         parseDuration,
  2555.         divmod,
  2556.         sleep,
  2557.         goToPage,
  2558.         compareObjects,
  2559.         debounce,
  2560.         distinct,
  2561.         getDuplicates,
  2562.         sumObjects,
  2563.         startOfWeek,
  2564.         startOfYear,
  2565.         generateCombinations
  2566.     };
  2567.  
  2568.     function levelToExp(level) {
  2569.         if(level === 1) {
  2570.             return 0;
  2571.         }
  2572.         if(level <= 100) {
  2573.             return Math.floor(Math.pow(level, 3.5) * 6 / 5);
  2574.         }
  2575.         return Math.round(12_000_000 * Math.pow(Math.pow(3500, .01), level - 100));
  2576.     }
  2577.  
  2578.     function expToLevel(exp) {
  2579.         if(exp <= 0) {
  2580.             return 1;
  2581.         }
  2582.         if(exp <= 12_000_000) {
  2583.             return Math.floor(Math.pow((exp + 1) / 1.2, 1 / 3.5));
  2584.         }
  2585.         return 100 + Math.floor(Math.log((exp + 1) / 12_000_000) / Math.log(Math.pow(3500, .01)));
  2586.     }
  2587.  
  2588.     function expToCurrentExp(exp) {
  2589.         const level = expToLevel(exp);
  2590.         return exp - levelToExp(level);
  2591.     }
  2592.  
  2593.     function expToNextLevel(exp) {
  2594.         const level = expToLevel(exp);
  2595.         return levelToExp(level + 1) - exp;
  2596.     }
  2597.  
  2598.     function expToNextTier(exp) {
  2599.         const level = expToLevel(exp);
  2600.         let target = 10;
  2601.         while(target <= level) {
  2602.             target += 15;
  2603.         }
  2604.         return levelToExp(target) - exp;
  2605.     }
  2606.  
  2607.     function tierToLevel(tier) {
  2608.         if(tier <= 1) {
  2609.             return tier;
  2610.         }
  2611.         return tier * 15 - 20;
  2612.     }
  2613.  
  2614.     function levelToTier(level) {
  2615.         if(level <= 1) {
  2616.             return level;
  2617.         }
  2618.         return (level + 20) / 15;
  2619.     }
  2620.  
  2621.     function formatNumber(number) {
  2622.         let digits = 2;
  2623.         if(number < .1 && number > -.1) {
  2624.             digits = 3;
  2625.         }
  2626.         if(number < .01 && number > -.01) {
  2627.             digits = 4;
  2628.         }
  2629.         return number.toLocaleString(undefined, {maximumFractionDigits:digits});
  2630.     }
  2631.  
  2632.     function parseNumber(text) {
  2633.         if(!text) {
  2634.             return 0;
  2635.         }
  2636.         if(text.includes('Empty')) {
  2637.             return 0;
  2638.         }
  2639.         const regexMatch = /\d+[^\s]*/.exec(text);
  2640.         if(!regexMatch) {
  2641.             return 0;
  2642.         }
  2643.         text = regexMatch[0];
  2644.         text = text.replaceAll(/,/g, '');
  2645.         text = text.replaceAll(/&.*$/g, '');
  2646.         let multiplier = 1;
  2647.         if(text.endsWith('%')) {
  2648.             multiplier = 1 / 100;
  2649.         }
  2650.         if(text.endsWith('K')) {
  2651.             multiplier = 1_000;
  2652.         }
  2653.         if(text.endsWith('M')) {
  2654.             multiplier = 1_000_000;
  2655.         }
  2656.         return (parseFloat(text) || 0) * multiplier;
  2657.     }
  2658.  
  2659.     function secondsToDuration(seconds) {
  2660.         seconds = Math.floor(seconds);
  2661.         if(seconds > 60 * 60 * 24 * 100) {
  2662.             // > 100 days
  2663.             return 'A very long time';
  2664.         }
  2665.  
  2666.         var [minutes, seconds] = divmod(seconds, 60);
  2667.         var [hours, minutes] = divmod(minutes, 60);
  2668.         var [days, hours] = divmod(hours, 24);
  2669.  
  2670.         seconds = `${seconds}`.padStart(2, '0');
  2671.         minutes = `${minutes}`.padStart(2, '0');
  2672.         hours = `${hours}`.padStart(2, '0');
  2673.         days = `${days}`.padStart(2, '0');
  2674.  
  2675.         let result = '';
  2676.         if(result || +days) {
  2677.             result += `${days}d `;
  2678.         }
  2679.         if(result || +hours) {
  2680.             result += `${hours}h `;
  2681.         }
  2682.         if(result || +minutes) {
  2683.             result += `${minutes}m `;
  2684.         }
  2685.         result += `${seconds}s`;
  2686.  
  2687.         return result;
  2688.     }
  2689.  
  2690.     function parseDuration(duration) {
  2691.         const parts = duration.split(' ');
  2692.         let seconds = 0;
  2693.         for(const part of parts) {
  2694.             const value = parseFloat(part);
  2695.             if(part.endsWith('m')) {
  2696.                 seconds += value * 60;
  2697.             } else if(part.endsWith('h')) {
  2698.                 seconds += value * 60 * 60;
  2699.             } else if(part.endsWith('d')) {
  2700.                 seconds += value * 60 * 60 * 24;
  2701.             } else {
  2702.                 console.warn(`Unexpected duration being parsed : ${part}`);
  2703.             }
  2704.         }
  2705.         return seconds;
  2706.     }
  2707.  
  2708.     function divmod(x, y) {
  2709.         return [Math.floor(x / y), x % y];
  2710.     }
  2711.  
  2712.     function goToPage(page) {
  2713.         window.history.pushState({}, '', page);
  2714.         window.history.pushState({}, '', page);
  2715.         window.history.back();
  2716.     }
  2717.  
  2718.     async function sleep(millis) {
  2719.         await new Promise(r => window.setTimeout(r, millis));
  2720.     }
  2721.  
  2722.     function compareObjects(object1, object2, doLog) {
  2723.         const keys1 = Object.keys(object1);
  2724.         const keys2 = Object.keys(object2);
  2725.         if(keys1.length !== keys2.length) {
  2726.             if(doLog) {
  2727.                 console.warn(`key length not matching`, object1, object2);
  2728.             }
  2729.             return false;
  2730.         }
  2731.         keys1.sort();
  2732.         keys2.sort();
  2733.         for(let i=0;i<keys1.length;i++) {
  2734.             if(keys1[i] !== keys2[i]) {
  2735.                 if(doLog) {
  2736.                     console.warn(`keys not matching`, keys1[i], keys2[i], object1, object2);
  2737.                 }
  2738.                 return false;
  2739.             }
  2740.             if(typeof object1[keys1[i]] === 'object' && typeof object2[keys2[i]] === 'object') {
  2741.                 if(!compareObjects(object1[keys1[i]], object2[keys2[i]], doLog)) {
  2742.                     return false;
  2743.                 }
  2744.             } else if(object1[keys1[i]] !== object2[keys2[i]]) {
  2745.                 if(doLog) {
  2746.                     console.warn(`values not matching`, object1[keys1[i]], object2[keys2[i]], object1, object2);
  2747.                 }
  2748.                 return false;
  2749.             }
  2750.         }
  2751.         return true;
  2752.     }
  2753.  
  2754.     function debounce(callback, delay) {
  2755.         let timer;
  2756.         return function(...args) {
  2757.             clearTimeout(timer);
  2758.             timer = setTimeout(() => {
  2759.                 callback(...args);
  2760.             }, delay);
  2761.         }
  2762.     }
  2763.  
  2764.     function distinct(array) {
  2765.         return array.filter((value, index) => {
  2766.           return array.indexOf(value) === index;
  2767.         });
  2768.     }
  2769.  
  2770.     function getDuplicates(array) {
  2771.         const sorted = array.slice().sort();
  2772.         const result = [];
  2773.         for(let i=0;i<sorted.length-1;i++) {
  2774.             if(sorted[i+1] == sorted[i]) {
  2775.                 result.push(sorted[i]);
  2776.             }
  2777.         }
  2778.         return result;
  2779.     }
  2780.  
  2781.     function sumObjects(array) {
  2782.         const result = {};
  2783.         for(const element of array) {
  2784.             for(const key of Object.keys(element)) {
  2785.                 if(typeof element[key] === 'number') {
  2786.                     result[key] = (result[key] || 0) + element[key];
  2787.                 }
  2788.             }
  2789.         }
  2790.         return result;
  2791.     }
  2792.  
  2793.     function startOfWeek(date) {
  2794.         const result = new Date();
  2795.         result.setDate(date.getDate() - date.getDay());
  2796.         result.setHours(0,0,0,0);
  2797.         return result;
  2798.     }
  2799.  
  2800.     function startOfYear(date) {
  2801.         const result = new Date(date.getFullYear(), 0, 1);
  2802.         return result;
  2803.     }
  2804.  
  2805.     function generateCombinations(objects, count, grouper) {
  2806.         const objectsByGroup = {};
  2807.         for(const object of objects) {
  2808.             const group = grouper(object);
  2809.             if(!objectsByGroup[group]) {
  2810.                 objectsByGroup[group] = [];
  2811.             }
  2812.             objectsByGroup[group].push(object);
  2813.         }
  2814.         const result = [];
  2815.         const groups = Object.keys(objectsByGroup);
  2816.         addOneCombination(result, objectsByGroup, groups, count);
  2817.         return result;
  2818.     }
  2819.  
  2820.     function addOneCombination(result, objectsByGroup, groups, count, combination = [], groupStart = 0) {
  2821.         if(!count) {
  2822.             result.push(combination);
  2823.             return;
  2824.         }
  2825.         for(let i=groupStart;i<groups.length-count+1;i++) {
  2826.             const contents = objectsByGroup[groups[i]];
  2827.             for(let j=0;j<contents.length;j++) {
  2828.                 addOneCombination(result, objectsByGroup, groups, count-1, combination.concat([contents[j]]), i+1);
  2829.             }
  2830.         }
  2831.     }
  2832.  
  2833.     return exports;
  2834.  
  2835. }
  2836. );
  2837. // enhancementsReader
  2838. window.moduleRegistry.add('enhancementsReader', (events, util, structuresCache) => {
  2839.  
  2840.     const emitEvent = events.emit.bind(null, 'reader-enhancements');
  2841.  
  2842.     function initialise() {
  2843.         events.register('page', update);
  2844.         window.setInterval(update, 1000);
  2845.     }
  2846.  
  2847.     function update() {
  2848.         const page = events.getLast('page');
  2849.         if(!page) {
  2850.             return;
  2851.         }
  2852.         if(page.type === 'enhancement' && $('home-page .categories .category-active').text() === 'Enhance') {
  2853.             readEnhancementsScreen();
  2854.         }
  2855.     }
  2856.  
  2857.     function readEnhancementsScreen() {
  2858.         const enhancements = {};
  2859.         $('home-page .categories + .card button').each((i,element) => {
  2860.             element = $(element);
  2861.             const name = element.find('.name').text();
  2862.             const structure = structuresCache.byName[name];
  2863.             if(!structure) {
  2864.                 return;
  2865.             }
  2866.             const level = util.parseNumber(element.find('.level').text());
  2867.             enhancements[structure.id] = level;
  2868.         });
  2869.         emitEvent({
  2870.             type: 'full',
  2871.             value: enhancements
  2872.         });
  2873.     }
  2874.  
  2875.     initialise();
  2876.  
  2877. }
  2878. );
  2879. // equipmentReader
  2880. window.moduleRegistry.add('equipmentReader', (events, itemCache, util, itemUtil) => {
  2881.  
  2882.     function initialise() {
  2883.         events.register('page', update);
  2884.         window.setInterval(update, 1000);
  2885.     }
  2886.  
  2887.     function update() {
  2888.         const page = events.getLast('page');
  2889.         if(!page) {
  2890.             return;
  2891.         }
  2892.         if(page.type === 'equipment') {
  2893.             readEquipmentScreen();
  2894.         }
  2895.         if(page.type === 'action') {
  2896.             readActionScreen();
  2897.         }
  2898.     }
  2899.  
  2900.     function readEquipmentScreen() {
  2901.         const equipment = {};
  2902.         const activeTab = $('equipment-page .categories button[disabled]').text().toLowerCase();
  2903.         $('equipment-page .header + .items > .item > .description').parent().each((i,element) => {
  2904.             itemUtil.extractItem(element, equipment);
  2905.         });
  2906.         events.emit(`reader-equipment-${activeTab}`, {
  2907.             type: 'full',
  2908.             value: equipment
  2909.         });
  2910.     }
  2911.  
  2912.     function readActionScreen() {
  2913.         const equipment = {};
  2914.         $('skill-page .header > .name:contains("Consumables")').closest('.card').find('button > .name:not(.placeholder)').parent().each((i,element) => {
  2915.             itemUtil.extractItem(element, equipment);
  2916.         });
  2917.         events.emit('reader-equipment-equipment', {
  2918.             type: 'partial',
  2919.             value: equipment
  2920.         });
  2921.     }
  2922.  
  2923.     initialise();
  2924.  
  2925. }
  2926. );
  2927. // expReader
  2928. window.moduleRegistry.add('expReader', (events, skillCache, util) => {
  2929.  
  2930.     const emitEvent = events.emit.bind(null, 'reader-exp');
  2931.  
  2932.     function initialise() {
  2933.         events.register('page', update);
  2934.         window.setInterval(update, 1000);
  2935.     }
  2936.  
  2937.     function update() {
  2938.         const page = events.getLast('page');
  2939.         if(!page) {
  2940.             return;
  2941.         }
  2942.         if(page.type === 'action') {
  2943.             readActionScreen(page.skill);
  2944.         }
  2945.         if(page.type === 'taming') {
  2946.             readTamingScreen();
  2947.         }
  2948.         readSidebar();
  2949.     }
  2950.  
  2951.     function readActionScreen(id) {
  2952.         const text = $('skill-page .header > .name:contains("Stats")')
  2953.             .closest('.card')
  2954.             .find('.row > .name:contains("Total"):contains("XP")')
  2955.             .closest('.row')
  2956.             .find('.value')
  2957.             .text();
  2958.         const exp = util.parseNumber(text);
  2959.         emitEvent([{ id, exp }]);
  2960.     }
  2961.  
  2962.     function readTamingScreen() {
  2963.         const text = $('taming-page .header > .name:contains("Stats")')
  2964.             .closest('.card')
  2965.             .find('.row > .name:contains("Total"):contains("XP")')
  2966.             .closest('.row')
  2967.             .find('.amount')
  2968.             .text();
  2969.         const exp = util.parseNumber(text);
  2970.         emitEvent([{
  2971.             exp,
  2972.             id: skillCache.byName['Taming'].id
  2973.         }]);
  2974.     }
  2975.  
  2976.     function readSidebar() {
  2977.         const levels = [];
  2978.         $('nav-component button.skill').each((i,element) => {
  2979.             element = $(element);
  2980.             const name = element.find('.name').text();
  2981.             const id = skillCache.byName[name].id;
  2982.             const level = +(/\d+/.exec(element.find('.level').text())?.[0]);
  2983.             const exp = util.levelToExp(level);
  2984.             levels.push({ id, exp });
  2985.         });
  2986.         emitEvent(levels);
  2987.     }
  2988.  
  2989.     initialise();
  2990.  
  2991. }
  2992. );
  2993. // guildStructuresReader
  2994. window.moduleRegistry.add('guildStructuresReader', (events, util, structuresCache) => {
  2995.  
  2996.     const emitEvent = events.emit.bind(null, 'reader-structures-guild');
  2997.  
  2998.     function initialise() {
  2999.         events.register('page', update);
  3000.         window.setInterval(update, 1000);
  3001.     }
  3002.  
  3003.     function update() {
  3004.         const page = events.getLast('page');
  3005.         if(!page) {
  3006.             return;
  3007.         }
  3008.         if(page.type === 'guild' && $('guild-page .tracker ~ div button.row-active').text() === 'Buildings') {
  3009.             readGuildStructuresScreen();
  3010.         }
  3011.     }
  3012.  
  3013.     function readGuildStructuresScreen() {
  3014.         const structures = {};
  3015.         $('guild-page .card').first().find('button').each((i,element) => {
  3016.             element = $(element);
  3017.             const name = element.find('.name').text();
  3018.             const structure = structuresCache.byName[name];
  3019.             if(!structure) {
  3020.                 return;
  3021.             }
  3022.             const level = util.parseNumber(element.find('.amount').text());
  3023.             structures[structure.id] = level;
  3024.         });
  3025.         emitEvent({
  3026.             type: 'full',
  3027.             value: structures
  3028.         });
  3029.     }
  3030.  
  3031.     initialise();
  3032.  
  3033. }
  3034. );
  3035. // inventoryReader
  3036. window.moduleRegistry.add('inventoryReader', (events, itemCache, util, itemUtil) => {
  3037.  
  3038.     const emitEvent = events.emit.bind(null, 'reader-inventory');
  3039.  
  3040.     function initialise() {
  3041.         events.register('page', update);
  3042.         window.setInterval(update, 1000);
  3043.     }
  3044.  
  3045.     function update() {
  3046.         const page = events.getLast('page');
  3047.         if(!page) {
  3048.             return;
  3049.         }
  3050.         if(page.type === 'inventory') {
  3051.             readInventoryScreen();
  3052.         }
  3053.         if(page.type === 'action') {
  3054.             readActionScreen();
  3055.         }
  3056.         if(page.type === 'taming' && page.menu === 'expeditions') {
  3057.             readExpeditionsScreen();
  3058.         }
  3059.     }
  3060.  
  3061.     function readInventoryScreen() {
  3062.         const inventory = {};
  3063.         $('inventory-page .items > .item').each((i,element) => {
  3064.             itemUtil.extractItem(element, inventory, true);
  3065.         });
  3066.         emitEvent({
  3067.             type: 'full',
  3068.             value: inventory
  3069.         });
  3070.     }
  3071.  
  3072.     function readActionScreen() {
  3073.         const inventory = {};
  3074.         $('skill-page .header > .name:contains("Materials")').closest('.card').find('.row').each((i,element) => {
  3075.             itemUtil.extractItem(element, inventory);
  3076.         });
  3077.         emitEvent({
  3078.             type: 'partial',
  3079.             value: inventory
  3080.         });
  3081.     }
  3082.  
  3083.     function readExpeditionsScreen() {
  3084.         const inventory = {};
  3085.         $('taming-page .heading:contains("Materials") + button').each((i,element) => {
  3086.             itemUtil.extractItem(element, inventory);
  3087.         });
  3088.         emitEvent({
  3089.             type: 'partial',
  3090.             value: inventory
  3091.         });
  3092.     }
  3093.  
  3094.     initialise();
  3095.  
  3096. }
  3097. );
  3098. // marketReader
  3099. window.moduleRegistry.add('marketReader', (events, elementWatcher, itemCache, util) => {
  3100.  
  3101.     const emitEvent = events.emit.bind(null, 'reader-market');
  3102.     let inProgress = false;
  3103.  
  3104.     const exports = {
  3105.         trigger: update
  3106.     };
  3107.  
  3108.     function initialise() {
  3109.         events.register('page', update);
  3110.         window.setInterval(update, 10000);
  3111.     }
  3112.  
  3113.     function update() {
  3114.         const page = events.getLast('page');
  3115.         if(!page) {
  3116.             return;
  3117.         }
  3118.         if(page.type === 'market') {
  3119.             readMarketScreen();
  3120.         }
  3121.     }
  3122.  
  3123.     async function readMarketScreen() {
  3124.         if(inProgress) {
  3125.             return;
  3126.         }
  3127.         try {
  3128.             inProgress = true;
  3129.             const selectedTab = $('market-listings-component .card > .tabs > button.tab-active').text().toLowerCase();
  3130.             const type = selectedTab === 'orders' ? 'BUY' : selectedTab === 'listings' ? 'OWN' : 'SELL';
  3131.             await elementWatcher.exists('market-listings-component .search ~ button', undefined, 10000);
  3132.             if($('market-listings-component .search > input').val()) {
  3133.                 return;
  3134.             }
  3135.             const listings = [];
  3136.             $('market-listings-component .search ~ button').each((i,element) => {
  3137.                 element = $(element);
  3138.                 const name = element.find('.name').text();
  3139.                 const item = itemCache.byName[name];
  3140.                 if(!item) {
  3141.                     return;
  3142.                 }
  3143.                 const amount = util.parseNumber(element.find('.amount').text());
  3144.                 const price = util.parseNumber(element.find('.cost').text());
  3145.                 const listingType = type !== 'OWN' ? type : element.find('.tag').length ? 'BUY' : 'SELL';
  3146.                 const isOwn = !!element.attr('disabled');
  3147.                 listings.push({
  3148.                     type: listingType,
  3149.                     item: item.id,
  3150.                     amount,
  3151.                     price,
  3152.                     isOwn,
  3153.                     element
  3154.                 });
  3155.             });
  3156.             emitEvent({
  3157.                 type,
  3158.                 listings,
  3159.             });
  3160.         } catch(e) {
  3161.             console.error('error in market reader', e);
  3162.             return;
  3163.         } finally {
  3164.             inProgress = false;
  3165.         }
  3166.     }
  3167.  
  3168.     initialise();
  3169.  
  3170.     return exports;
  3171.  
  3172. }
  3173. );
  3174. // petReader
  3175. window.moduleRegistry.add('petReader', (events, petCache, petPassiveCache, petTraitCache, elementWatcher, util) => {
  3176.  
  3177.     const emitEvent = events.emit.bind(null, 'reader-pet');
  3178.  
  3179.     function initialise() {
  3180.         events.register('page', handlePage);
  3181.         elementWatcher.addRecursiveObserver(readPetModal, 'app-component > div.scroll div.wrapper', 'taming-page', 'modal-component');
  3182.     }
  3183.  
  3184.     function handlePage(page) {
  3185.         if(page.type === 'taming' && page.menu === 'pets') {
  3186.             readTamingScreen();
  3187.         }
  3188.     }
  3189.  
  3190.     function readTamingScreen() {
  3191.         const elements = $('button.row.ng-star-inserted').get();
  3192.         const values = [];
  3193.         for(let element of elements) {
  3194.             element = $(element);
  3195.             const image = element.find('.image img').attr('src').split('/').at(-1);
  3196.             const name = element.find('.image').next().find('.flex > :nth-child(1)')[0].textContent;
  3197.             const level = util.parseNumber(element.find('.image').next().find('.flex > :nth-child(2)')[0].textContent);
  3198.             const partOfTeam = !!element.closest('.card').find('.header:contains("Expedition Team")').length;
  3199.             values.push({
  3200.                 parsed: false,
  3201.                 species: petCache.byImage[image].id,
  3202.                 family: petCache.byImage[image].family,
  3203.                 name,
  3204.                 level,
  3205.                 partOfTeam,
  3206.                 element: element.get()
  3207.             });
  3208.         }
  3209.         emitEvent({
  3210.             type: 'list',
  3211.             value: values
  3212.         });
  3213.     }
  3214.  
  3215.     function readPetModal(modal) {
  3216.         if(!$(modal).find('.name:contains("Traits")').length) {
  3217.             return; // avoid triggering on other modals
  3218.         }
  3219.         const image = $(modal).find('.header img').attr('src').split('/').at(-1);
  3220.         const name = $(modal).find('.header .description button').text().trim();
  3221.         const traits = $(modal).find('.name:contains("Traits")').next().text();
  3222.         const health = +($(modal).find('.name:contains("Health") + .mono').text().match('\\((\\d+)%\\)')[1]);
  3223.         const attack = +($(modal).find('.name:contains("Attack") + .mono').text().match('\\((\\d+)%\\)')[1]);
  3224.         const defense = +($(modal).find('.name:contains("Defense") + .mono').text().match('\\((\\d+)%\\)')[1]);
  3225.         const specialAttack = +($(modal).find('.name:contains("Sp. Atk") + .mono').text().match('\\((\\d+)%\\)')[1]);
  3226.         const specialDefense = +($(modal).find('.name:contains("Sp. Def") + .mono').text().match('\\((\\d+)%\\)')[1]);
  3227.         const speed = +($(modal).find('.name:contains("Speed") + .mono').text().match('\\((\\d+)%\\)')[1]);
  3228.         const passives = $(modal).find('.name:contains("Total")').parent().nextAll('.row').find('.name').get().map(a => a.innerText);
  3229.         const pet = {
  3230.             parsed: true,
  3231.             species: petCache.byImage[image].id,
  3232.             family: petCache.byImage[image].family,
  3233.             name,
  3234.             traits: petTraitCache.byName[traits].id,
  3235.             health,
  3236.             attack,
  3237.             defense,
  3238.             specialAttack,
  3239.             specialDefense,
  3240.             speed,
  3241.             passives: passives.map(a => petPassiveCache.byName[a].id)
  3242.         };
  3243.         const healthRow = $(modal).find('.name:contains("Health") + .mono').parent();
  3244.         if(!healthRow.hasClass('stat-health')) {
  3245.             $(modal).find('.name:contains("Health") + .mono').parent().addClass('stat-health');
  3246.             $(modal).find('.name:contains("Attack") + .mono').parent().addClass('stat-attack');
  3247.             $(modal).find('.name:contains("Defense") + .mono').parent().addClass('stat-defense');
  3248.             $(modal).find('.name:contains("Sp. Atk") + .mono').parent().addClass('stat-specialAttack');
  3249.             $(modal).find('.name:contains("Sp. Def") + .mono').parent().addClass('stat-specialDefense');
  3250.             $(modal).find('.name:contains("Speed") + .mono').parent().addClass('stat-speed');
  3251.             for(const id of pet.passives) {
  3252.                 const passive = petPassiveCache.byId[id];
  3253.                 $(modal).find(`.name:contains("${passive.name}")`).parent().addClass(`passive-${passive.stats.name}`);
  3254.             }
  3255.         }
  3256.         emitEvent({
  3257.             type: 'single',
  3258.             value: pet,
  3259.             modal: modal
  3260.         });
  3261.     }
  3262.  
  3263.     initialise();
  3264.  
  3265. }
  3266. );
  3267. // structuresReader
  3268. window.moduleRegistry.add('structuresReader', (events, util, structuresCache) => {
  3269.  
  3270.     const emitEvent = events.emit.bind(null, 'reader-structures');
  3271.  
  3272.     function initialise() {
  3273.         events.register('page', update);
  3274.         window.setInterval(update, 1000);
  3275.     }
  3276.  
  3277.     function update() {
  3278.         const page = events.getLast('page');
  3279.         if(!page) {
  3280.             return;
  3281.         }
  3282.         if(page.type === 'structure' && $('home-page .categories .category-active').text() === 'Build') {
  3283.             readStructuresScreen();
  3284.         }
  3285.     }
  3286.  
  3287.     function readStructuresScreen() {
  3288.         const structures = {};
  3289.         $('home-page .categories + .card button').each((i,element) => {
  3290.             element = $(element);
  3291.             const name = element.find('.name').text();
  3292.             const structure = structuresCache.byName[name];
  3293.             if(!structure) {
  3294.                 return;
  3295.             }
  3296.             const level = util.parseNumber(element.find('.level').text());
  3297.             structures[structure.id] = level;
  3298.         });
  3299.         emitEvent({
  3300.             type: 'full',
  3301.             value: structures
  3302.         });
  3303.     }
  3304.  
  3305.     initialise();
  3306.  
  3307. }
  3308. );
  3309. // variousReader
  3310. window.moduleRegistry.add('variousReader', (events, util) => {
  3311.  
  3312.     const emitEvent = events.emit.bind(null, 'reader-various');
  3313.  
  3314.     function initialise() {
  3315.         events.register('page', update);
  3316.         window.setInterval(update, 1000);
  3317.     }
  3318.  
  3319.     function update() {
  3320.         const page = events.getLast('page');
  3321.         if(!page) {
  3322.             return;
  3323.         }
  3324.         const various = {};
  3325.         if(page.type === 'action') {
  3326.             readActionScreen(various, page.skill);
  3327.         }
  3328.         if(page.type === 'settings') {
  3329.             readSettingsScreen(various);
  3330.         }
  3331.         emitEvent(various);
  3332.     }
  3333.  
  3334.     function readActionScreen(various, skillId) {
  3335.         const amountText = $('skill-page .header > .name:contains("Loot")').parent().find('.amount').text();
  3336.         const amountValue = !amountText ? null : util.parseNumber(amountText.split(' / ')[1]) - util.parseNumber(amountText.split(' / ')[0]);
  3337.         various.maxAmount = {
  3338.             [skillId]: amountValue
  3339.         };
  3340.     }
  3341.  
  3342.     function readSettingsScreen(various) {
  3343.         const username = $('settings-page .row:contains("Username") :last-child').text();
  3344.         if(username) {
  3345.             various.username = username;
  3346.         }
  3347.     }
  3348.  
  3349.     initialise();
  3350.  
  3351. }
  3352. );
  3353. // authToast
  3354. window.moduleRegistry.add('authToast', (toast) => {
  3355.  
  3356.     function initialise() {
  3357.         toast.create({
  3358.             text: 'Pancake-Scripts initialised!',
  3359.             image: 'https://img.icons8.com/?size=48&id=1ODJ62iG96gX&format=png'
  3360.         });
  3361.     }
  3362.  
  3363.     initialise();
  3364.  
  3365. }
  3366. );
  3367. // changelog
  3368. window.moduleRegistry.add('changelog', (Promise, pages, components, request, util, configuration) => {
  3369.  
  3370.     const PAGE_NAME = 'Plugin changelog';
  3371.     const loaded = new Promise.Deferred('changelog');
  3372.  
  3373.     let changelogs = null;
  3374.  
  3375.     async function initialise() {
  3376.         await pages.register({
  3377.             category: 'Skills',
  3378.             after: 'Changelog',
  3379.             name: PAGE_NAME,
  3380.             image: 'https://ironwoodrpg.com/assets/misc/changelog.png',
  3381.             render: renderPage
  3382.         });
  3383.         configuration.registerCheckbox({
  3384.             category: 'Pages',
  3385.             key: 'changelog-enabled',
  3386.             name: 'Changelog',
  3387.             default: true,
  3388.             handler: handleConfigStateChange
  3389.         });
  3390.         load();
  3391.     }
  3392.  
  3393.     function handleConfigStateChange(state, name) {
  3394.         if(state) {
  3395.             pages.show(PAGE_NAME);
  3396.         } else {
  3397.             pages.hide(PAGE_NAME);
  3398.         }
  3399.     }
  3400.  
  3401.     async function load() {
  3402.         changelogs = await request.getChangelogs();
  3403.         loaded.resolve();
  3404.     }
  3405.  
  3406.     async function renderPage() {
  3407.         await loaded;
  3408.         const header = components.search(componentBlueprint, 'header');
  3409.         const list = components.search(componentBlueprint, 'list');
  3410.         for(const index in changelogs) {
  3411.             componentBlueprint.componentId = `changelogComponent_${index}`;
  3412.             header.title = changelogs[index].title;
  3413.             header.textRight = new Date(changelogs[index].time).toLocaleDateString();
  3414.             list.entries = changelogs[index].entries;
  3415.             components.addComponent(componentBlueprint);
  3416.         }
  3417.     }
  3418.  
  3419.     const componentBlueprint = {
  3420.         componentId: 'changelogComponent',
  3421.         dependsOn: 'custom-page',
  3422.         parent: '.column0',
  3423.         selectedTabIndex: 0,
  3424.         tabs: [{
  3425.             title: 'tab',
  3426.             rows: [{
  3427.                 id: 'header',
  3428.                 type: 'header',
  3429.                 title: '',
  3430.                 textRight: ''
  3431.             },{
  3432.                 id: 'list',
  3433.                 type: 'list',
  3434.                 entries: []
  3435.             }]
  3436.         }]
  3437.     };
  3438.  
  3439.     initialise();
  3440.  
  3441. }
  3442. );
  3443. // configurationPage
  3444. window.moduleRegistry.add('configurationPage', (pages, components, elementWatcher, configuration, elementCreator) => {
  3445.  
  3446.     const PAGE_NAME = 'Configuration';
  3447.  
  3448.     async function initialise() {
  3449.         await pages.register({
  3450.             category: 'Misc',
  3451.             after: 'Settings',
  3452.             name: PAGE_NAME,
  3453.             image: 'https://cdn-icons-png.flaticon.com/512/3953/3953226.png',
  3454.             columns: '2',
  3455.             render: renderPage
  3456.         });
  3457.         elementCreator.addStyles(styles);
  3458.         pages.show(PAGE_NAME);
  3459.     }
  3460.  
  3461.     function generateBlueprint() {
  3462.         const categories = {};
  3463.         for(const item of configuration.items) {
  3464.             if(!categories[item.category]) {
  3465.                 categories[item.category] = {
  3466.                     name: item.category,
  3467.                     items: []
  3468.                 }
  3469.             }
  3470.             categories[item.category].items.push(item);
  3471.         }
  3472.         const blueprints = [];
  3473.         let column = 1;
  3474.         for(const category in categories) {
  3475.             column = 1 - column;
  3476.             const rows = [{
  3477.                 type: 'header',
  3478.                 title: category,
  3479.                 centered: true
  3480.             }];
  3481.             rows.push(...categories[category].items.flatMap(createRows));
  3482.             blueprints.push({
  3483.                 componentId: `configurationComponent_${category}`,
  3484.                 dependsOn: 'custom-page',
  3485.                 parent: `.column${column}`,
  3486.                 selectedTabIndex: 0,
  3487.                 tabs: [{
  3488.                     rows: rows
  3489.                 }]
  3490.             });
  3491.         }
  3492.         return blueprints;
  3493.     }
  3494.  
  3495.     function createRows(item) {
  3496.         switch(item.type) {
  3497.             case 'checkbox': return createRows_Checkbox(item);
  3498.             case 'input': return createRows_Input(item);
  3499.             case 'dropdown': return createRows_Dropdown(item);
  3500.             case 'json': break;
  3501.             default: throw `Unknown configuration type : ${item.type}`;
  3502.         }
  3503.     }
  3504.  
  3505.     function createRows_Checkbox(item) {
  3506.         return [{
  3507.             type: 'checkbox',
  3508.             text: item.name,
  3509.             checked: item.value,
  3510.             delay: 500,
  3511.             action: (value) => {
  3512.                 item.handler(value);
  3513.                 pages.requestRender(PAGE_NAME);
  3514.             }
  3515.         }]
  3516.     }
  3517.  
  3518.     function createRows_Input(item) {
  3519.         const value = item.value || item.default;
  3520.         return [{
  3521.             type: 'item',
  3522.             name: item.name
  3523.         },{
  3524.             type: 'input',
  3525.             name: item.name,
  3526.             value: value,
  3527.             inputType: item.inputType,
  3528.             delay: 500,
  3529.             action: (value) => {
  3530.                 item.handler(value);
  3531.             }
  3532.         }]
  3533.     }
  3534.  
  3535.     function createRows_Dropdown(item) {
  3536.         const value = item.value || item.default;
  3537.         const options = item.options.map(option => ({
  3538.             text: option,
  3539.             value: option,
  3540.             selected: option === value
  3541.         }));
  3542.         return [{
  3543.             type: 'item',
  3544.             name: item.name
  3545.         },{
  3546.             type: 'dropdown',
  3547.             options: options,
  3548.             delay: 500,
  3549.             action: (value) => {
  3550.                 item.handler(value);
  3551.             }
  3552.         }]
  3553.     }
  3554.  
  3555.     function renderPage() {
  3556.         const blueprints = generateBlueprint();
  3557.         for(const blueprint of blueprints) {
  3558.             components.addComponent(blueprint);
  3559.         }
  3560.     }
  3561.  
  3562.     const styles = `
  3563.         .modifiedHeight {
  3564.             height: 28px;
  3565.         }
  3566.     `;
  3567.  
  3568.     initialise();
  3569. }
  3570. );
  3571. // debugService
  3572. window.moduleRegistry.add('debugService', (request, toast, statsStore, EstimationGenerator, logService, events, util) => {
  3573.  
  3574.     const exports = {
  3575.         submit
  3576.     };
  3577.  
  3578.     async function submit() {
  3579.         const data = get();
  3580.         try {
  3581.             await forward(data);
  3582.         } catch(e) {
  3583.             exportToClipboard(data);
  3584.         }
  3585.     }
  3586.  
  3587.     function get() {
  3588.         return {
  3589.             stats: statsStore.get(),
  3590.             state: (new EstimationGenerator()).export(),
  3591.             logs: logService.get(),
  3592.             events: events.getLastCache()
  3593.         };
  3594.     }
  3595.  
  3596.     async function forward(data) {
  3597.         await request.report(data);
  3598.         toast.create({
  3599.             text: 'Forwarded debug data',
  3600.             image: 'https://img.icons8.com/?size=48&id=13809'
  3601.         });
  3602.     }
  3603.  
  3604.     function exportToClipboard(data) {
  3605.         toast.copyToClipboard(JSON.stringify(data), 'Failed to forward, exported to clipboard instead');
  3606.     }
  3607.  
  3608.     return exports;
  3609.  
  3610. });
  3611. // estimator
  3612. window.moduleRegistry.add('estimator', (configuration, events, skillCache, actionCache, itemCache, estimatorAction, estimatorOutskirts, estimatorActivity, estimatorCombat, components, util, statsStore) => {
  3613.  
  3614.     let enabled = false;
  3615.  
  3616.     const exports = {
  3617.         get,
  3618.         enrichTimings,
  3619.         enrichValues,
  3620.         preRenderItems
  3621.     }
  3622.  
  3623.     function initialise() {
  3624.         configuration.registerCheckbox({
  3625.             category: 'Data',
  3626.             key: 'estimations',
  3627.             name: 'Estimations',
  3628.             default: true,
  3629.             handler: handleConfigStateChange
  3630.         });
  3631.         events.register('page', update);
  3632.         events.register('state-stats', update);
  3633.         $(document).on('click', '.close', update);
  3634.     }
  3635.  
  3636.     function handleConfigStateChange(state) {
  3637.         enabled = state;
  3638.     }
  3639.  
  3640.     function update() {
  3641.         if(!enabled) {
  3642.             return;
  3643.         }
  3644.         const page = events.getLast('page');
  3645.         if(page?.type === 'action') {
  3646.             const stats = events.getLast('state-stats');
  3647.             if(stats) {
  3648.                 const estimation = get(page.skill, page.action);
  3649.                 enrichTimings(estimation);
  3650.                 enrichValues(estimation);
  3651.                 preRender(estimation, componentBlueprint);
  3652.                 preRenderItems(estimation, componentBlueprint);
  3653.                 components.addComponent(componentBlueprint);
  3654.             }
  3655.         }
  3656.     }
  3657.  
  3658.     function get(skillId, actionId) {
  3659.         const skill = skillCache.byId[skillId];
  3660.         const action = actionCache.byId[actionId];
  3661.         if(action.type === 'OUTSKIRTS') {
  3662.             return estimatorOutskirts.get(skillId, actionId);
  3663.         } else if(skill.type === 'Gathering' || skill.type === 'Crafting') {
  3664.             return estimatorActivity.get(skillId, actionId);
  3665.         } else if(skill.type === 'Combat') {
  3666.             return estimatorCombat.get(skillId, actionId);
  3667.         }
  3668.     }
  3669.  
  3670.     function enrichTimings(estimation) {
  3671.         const inventory = Object.entries(estimation.ingredients).map(([id,amount]) => ({
  3672.             id,
  3673.             stored: statsStore.getInventoryItem(id),
  3674.             secondsLeft: statsStore.getInventoryItem(id) * 3600 / amount
  3675.         })).reduce((a,b) => (a[b.id] = b, a), {});
  3676.         const equipment = Object.entries(estimation.equipments).map(([id,amount]) => ({
  3677.             id,
  3678.             stored: statsStore.getEquipmentItem(id),
  3679.             secondsLeft: statsStore.getEquipmentItem(id) * 3600 / amount
  3680.         })).reduce((a,b) => (a[b.id] = b, a), {});
  3681.         let maxAmount = statsStore.get('MAX_AMOUNT', estimation.skill);
  3682.         maxAmount = {
  3683.             value: maxAmount,
  3684.             secondsLeft: estimation.productionSpeed / 10 * (maxAmount || Infinity)
  3685.         };
  3686.         const merchantSellChance = statsStore.get('MERCHANT_SELL_CHANCE', estimation.skill) / 100;
  3687.         if(merchantSellChance) {
  3688.             maxAmount.secondsLeft /= 1 - merchantSellChance;
  3689.         }
  3690.         const levelState = statsStore.getLevel(estimation.skill);
  3691.         estimation.timings = {
  3692.             inventory,
  3693.             equipment,
  3694.             maxAmount,
  3695.             finished: Math.min(maxAmount.secondsLeft, ...Object.values(inventory).concat(Object.values(equipment)).map(a => a.secondsLeft)),
  3696.             level: util.expToNextLevel(levelState.exp) * 3600 / estimation.exp,
  3697.             tier: levelState.level >= 100 ? 0 : util.expToNextTier(levelState.exp) * 3600 / estimation.exp,
  3698.         };
  3699.     }
  3700.  
  3701.     function enrichValues(estimation) {
  3702.         estimation.values = {
  3703.             drop: getSellPrice(estimation.drops),
  3704.             ingredient: getSellPrice(estimation.ingredients),
  3705.             equipment: getSellPrice(estimation.equipments),
  3706.             net: 0
  3707.         };
  3708.         estimation.values.net = estimation.values.drop - estimation.values.ingredient - estimation.values.equipment;
  3709.     }
  3710.  
  3711.     function getSellPrice(object) {
  3712.         return Object.entries(object)
  3713.             .map(a => a[1] * itemCache.byId[a[0]].attributes.SELL_PRICE)
  3714.             .filter(a => a)
  3715.             .reduce((a,b) => a+b, 0);
  3716.     }
  3717.  
  3718.     function preRender(estimation, blueprint) {
  3719.         components.search(blueprint, 'actions').value
  3720.             = util.formatNumber(estimatorAction.LOOPS_PER_HOUR / estimation.speed);
  3721.         components.search(blueprint, 'exp').hidden
  3722.             = estimation.exp === 0;
  3723.         components.search(blueprint, 'exp').value
  3724.             = util.formatNumber(estimation.exp);
  3725.         components.search(blueprint, 'survivalChance').hidden
  3726.             = estimation.type === 'ACTIVITY';
  3727.         components.search(blueprint, 'survivalChance').value
  3728.             = util.formatNumber(estimation.survivalChance * 100) + ' %';
  3729.         components.search(blueprint, 'finishedTime').value
  3730.             = util.secondsToDuration(estimation.timings.finished);
  3731.         components.search(blueprint, 'levelTime').hidden
  3732.             = estimation.exp === 0 || estimation.timings.level === 0;
  3733.         components.search(blueprint, 'levelTime').value
  3734.             = util.secondsToDuration(estimation.timings.level);
  3735.         components.search(blueprint, 'tierTime').hidden
  3736.             = estimation.exp === 0 || estimation.timings.tier === 0;
  3737.         components.search(blueprint, 'tierTime').value
  3738.             = util.secondsToDuration(estimation.timings.tier);
  3739.         components.search(blueprint, 'dropValue').hidden
  3740.             = estimation.values.drop === 0;
  3741.         components.search(blueprint, 'dropValue').value
  3742.             = util.formatNumber(estimation.values.drop);
  3743.         components.search(blueprint, 'ingredientValue').hidden
  3744.             = estimation.values.ingredient === 0;
  3745.         components.search(blueprint, 'ingredientValue').value
  3746.             = util.formatNumber(estimation.values.ingredient);
  3747.         components.search(blueprint, 'equipmentValue').hidden
  3748.             = estimation.values.equipment === 0;
  3749.         components.search(blueprint, 'equipmentValue').value
  3750.             = util.formatNumber(estimation.values.equipment);
  3751.         components.search(blueprint, 'netValue').hidden
  3752.             = estimation.values.net === 0;
  3753.         components.search(blueprint, 'netValue').value
  3754.             = util.formatNumber(estimation.values.net);
  3755.         components.search(blueprint, 'tabTime').hidden
  3756.             = (estimation.timings.inventory.length + estimation.timings.equipment.length) === 0;
  3757.     }
  3758.  
  3759.     function preRenderItems(estimation, blueprint) {
  3760.         const dropRows = components.search(blueprint, 'dropRows');
  3761.         const ingredientRows = components.search(blueprint, 'ingredientRows');
  3762.         const timeRows = components.search(blueprint, 'timeRows');
  3763.         dropRows.rows = [];
  3764.         ingredientRows.rows = [];
  3765.         timeRows.rows = [];
  3766.         if(estimation.timings.maxAmount.value) {
  3767.             timeRows.rows.push({
  3768.                 type: 'item',
  3769.                 image: 'https://img.icons8.com/?size=48&id=1HQMXezy5LeT&format=png',
  3770.                 imageFilter: 'invert(100%)',
  3771.                 name: `Max amount [${util.formatNumber(estimation.timings.maxAmount.value)}]`,
  3772.                 value: util.secondsToDuration(estimation.timings.maxAmount.secondsLeft)
  3773.             });
  3774.         }
  3775.         for(const id in estimation.drops) {
  3776.             const item = itemCache.byId[id];
  3777.             dropRows.rows.push({
  3778.                 type: 'item',
  3779.                 image: `/assets/${item.image}`,
  3780.                 imagePixelated: true,
  3781.                 name: item.name,
  3782.                 value: util.formatNumber(estimation.drops[id]) + ' / hour'
  3783.             });
  3784.         }
  3785.         for(const id in estimation.ingredients) {
  3786.             const item = itemCache.byId[id];
  3787.             const timing = estimation.timings.inventory[id];
  3788.             ingredientRows.rows.push({
  3789.                 type: 'item',
  3790.                 image: `/assets/${item.image}`,
  3791.                 imagePixelated: true,
  3792.                 name: item.name,
  3793.                 value: util.formatNumber(estimation.ingredients[id]) + ' / hour'
  3794.             });
  3795.             timeRows.rows.push({
  3796.                 type: 'item',
  3797.                 image: `/assets/${item.image}`,
  3798.                 imagePixelated: true,
  3799.                 name: `${item.name} [${util.formatNumber(timing.stored)}]`,
  3800.                 value: util.secondsToDuration(timing.secondsLeft)
  3801.             });
  3802.         }
  3803.         for(const id in estimation.equipments) {
  3804.             const item = itemCache.byId[id];
  3805.             const timing = estimation.timings.equipment[id];
  3806.             ingredientRows.rows.push({
  3807.                 type: 'item',
  3808.                 image: `/assets/${item.image}`,
  3809.                 imagePixelated: true,
  3810.                 name: item.name,
  3811.                 value: util.formatNumber(estimation.equipments[id]) + ' / hour'
  3812.             });
  3813.             timeRows.rows.push({
  3814.                 type: 'item',
  3815.                 image: `/assets/${item.image}`,
  3816.                 imagePixelated: true,
  3817.                 name: `${item.name} [${util.formatNumber(timing.stored)}]`,
  3818.                 value: util.secondsToDuration(timing.secondsLeft)
  3819.             });
  3820.         }
  3821.     }
  3822.  
  3823.     const componentBlueprint = {
  3824.         componentId: 'estimatorComponent',
  3825.         dependsOn: 'skill-page',
  3826.         parent: 'actions-component',
  3827.         selectedTabIndex: 0,
  3828.         tabs: [{
  3829.             title: 'Overview',
  3830.             rows: [{
  3831.                 type: 'item',
  3832.                 id: 'actions',
  3833.                 name: 'Actions/hour',
  3834.                 image: 'https://cdn-icons-png.flaticon.com/512/3563/3563395.png',
  3835.                 value: ''
  3836.             },{
  3837.                 type: 'item',
  3838.                 id: 'exp',
  3839.                 name: 'Exp/hour',
  3840.                 image: 'https://cdn-icons-png.flaticon.com/512/616/616490.png',
  3841.                 value: ''
  3842.             },{
  3843.                 type: 'item',
  3844.                 id: 'survivalChance',
  3845.                 name: 'Survival chance',
  3846.                 image: 'https://cdn-icons-png.flaticon.com/512/3004/3004458.png',
  3847.                 value: ''
  3848.             },{
  3849.                 type: 'item',
  3850.                 id: 'finishedTime',
  3851.                 name: 'Finished',
  3852.                 image: 'https://cdn-icons-png.flaticon.com/512/1505/1505471.png',
  3853.                 value: ''
  3854.             },{
  3855.                 type: 'item',
  3856.                 id: 'levelTime',
  3857.                 name: 'Level up',
  3858.                 image: 'https://cdn-icons-png.flaticon.com/512/4614/4614145.png',
  3859.                 value: ''
  3860.             },{
  3861.                 type: 'item',
  3862.                 id: 'tierTime',
  3863.                 name: 'Tier up',
  3864.                 image: 'https://cdn-icons-png.flaticon.com/512/4789/4789514.png',
  3865.                 value: ''
  3866.             },{
  3867.                 type: 'item',
  3868.                 id: 'dropValue',
  3869.                 name: 'Gold/hour (loot)',
  3870.                 image: 'https://cdn-icons-png.flaticon.com/512/9028/9028024.png',
  3871.                 imageFilter: 'invert(100%) sepia(47%) saturate(3361%) hue-rotate(313deg) brightness(106%) contrast(108%)',
  3872.                 value: ''
  3873.             },{
  3874.                 type: 'item',
  3875.                 id: 'ingredientValue',
  3876.                 name: 'Gold/hour (materials)',
  3877.                 image: 'https://cdn-icons-png.flaticon.com/512/9028/9028031.png',
  3878.                 imageFilter: 'invert(100%) sepia(47%) saturate(3361%) hue-rotate(313deg) brightness(106%) contrast(108%)',
  3879.                 value: ''
  3880.             },{
  3881.                 type: 'item',
  3882.                 id: 'equipmentValue',
  3883.                 name: 'Gold/hour (equipments)',
  3884.                 image: 'https://cdn-icons-png.flaticon.com/512/9028/9028031.png',
  3885.                 imageFilter: 'invert(100%) sepia(47%) saturate(3361%) hue-rotate(313deg) brightness(106%) contrast(108%)',
  3886.                 value: ''
  3887.             },{
  3888.                 type: 'item',
  3889.                 id: 'netValue',
  3890.                 name: 'Gold/hour (total)',
  3891.                 image: 'https://cdn-icons-png.flaticon.com/512/11937/11937869.png',
  3892.                 imageFilter: 'invert(100%) sepia(47%) saturate(3361%) hue-rotate(313deg) brightness(106%) contrast(108%)',
  3893.                 value: ''
  3894.             }]
  3895.         },{
  3896.             title: 'Items',
  3897.             rows: [{
  3898.                 type: 'header',
  3899.                 title: 'Produced'
  3900.             },{
  3901.                 type: 'segment',
  3902.                 id: 'dropRows',
  3903.                 rows: []
  3904.             },{
  3905.                 type: 'header',
  3906.                 title: 'Consumed'
  3907.             },{
  3908.                 type: 'segment',
  3909.                 id: 'ingredientRows',
  3910.                 rows: []
  3911.             }]
  3912.         },{
  3913.             title: 'Time',
  3914.             id: 'tabTime',
  3915.             rows: [{
  3916.                 type: 'segment',
  3917.                 id: 'timeRows',
  3918.                 rows: []
  3919.             }]
  3920.         }]
  3921.     };
  3922.  
  3923.     initialise();
  3924.  
  3925.     return exports;
  3926.  
  3927. }
  3928. );
  3929. // estimatorAction
  3930. window.moduleRegistry.add('estimatorAction', (dropCache, actionCache, ingredientCache, skillCache, itemCache, statsStore) => {
  3931.  
  3932.     const SECONDS_PER_HOUR = 60 * 60;
  3933.     const LOOPS_PER_HOUR = 10 * SECONDS_PER_HOUR; // 1 second = 10 loops
  3934.     const LOOPS_PER_FOOD = 150;
  3935.  
  3936.     const exports = {
  3937.         LOOPS_PER_HOUR,
  3938.         LOOPS_PER_FOOD,
  3939.         getDrops,
  3940.         getIngredients,
  3941.         getEquipmentUses
  3942.     };
  3943.  
  3944.     function getDrops(skillId, actionId, isCombat, multiplier = 1) {
  3945.         const drops = dropCache.byAction[actionId];
  3946.         if(!drops) {
  3947.             return [];
  3948.         }
  3949.         const hasFailDrops = !!drops.find(a => a.type === 'FAILED');
  3950.         const hasMonsterDrops = !!drops.find(a => a.type === 'MONSTER');
  3951.         const successChance = hasFailDrops ? getSuccessChance(skillId, actionId) / 100 : 1;
  3952.         return drops.map(drop => {
  3953.             let amount = (1 + drop.amount) / 2 * multiplier * drop.chance;
  3954.             if(drop.type !== 'MONSTER' && isCombat && hasMonsterDrops) {
  3955.                 amount = 0;
  3956.             } else if(drop.type === 'MONSTER' && !isCombat) {
  3957.                 amount = 0;
  3958.             } else if(drop.type === 'FAILED') {
  3959.                 amount *= 1 - successChance;
  3960.             } else {
  3961.                 amount *= successChance;
  3962.             }
  3963.             if(amount) {
  3964.                 return {
  3965.                     id: drop.item,
  3966.                     amount
  3967.                 };
  3968.             }
  3969.         })
  3970.         .filter(a => a)
  3971.         .map(a => {
  3972.             const mapFindChance = statsStore.get('MAP_FIND_CHANCE', skillId) / 100;
  3973.             if(!mapFindChance || !itemCache.specialIds.dungeonMap.includes(a.id)) {
  3974.                 return a;
  3975.             }
  3976.             a.amount *= 1 + mapFindChance;
  3977.             return a;
  3978.         })
  3979.         .reduce((a,b) => (a[b.id] = b.amount, a), {});
  3980.     }
  3981.  
  3982.     function getSuccessChance(skillId, actionId) {
  3983.         const action = actionCache.byId[actionId];
  3984.         const level = statsStore.getLevel(skillId).level;
  3985.         return Math.min(95, 80 + level - action.level) + Math.floor(level / 20);
  3986.     }
  3987.  
  3988.     function getIngredients(actionId, multiplier = 1) {
  3989.         const ingredients = ingredientCache.byAction[actionId];
  3990.         if(!ingredients) {
  3991.             return [];
  3992.         }
  3993.         return ingredients.map(ingredient => ({
  3994.             id: ingredient.item,
  3995.             amount: ingredient.amount * multiplier
  3996.         }))
  3997.         .reduce((a,b) => (a[b.id] = b.amount, a), {});
  3998.     }
  3999.  
  4000.     function getEquipmentUses(skillId, actionId, isCombat = false, foodPerHour = 0) {
  4001.         const skill = skillCache.byId[skillId];
  4002.         const action = actionCache.byId[actionId];
  4003.         const result = {};
  4004.         const potionMultiplier = 1 + statsStore.get('DECREASED_POTION_DURATION') / 100;
  4005.         if(isCombat) {
  4006.             if(action.type !== 'OUTSKIRTS') {
  4007.                 // combat potions
  4008.                 statsStore.getManyEquipmentItems(itemCache.specialIds.combatPotion)
  4009.                     .forEach(a => result[a.id] = 20 * potionMultiplier);
  4010.             }
  4011.             if(action.type === 'DUNGEON') {
  4012.                 // dungeon map
  4013.                 const lanternMultiplier = 1 + statsStore.get('DUNGEON_TIME') / 100;
  4014.                 statsStore.getManyEquipmentItems(itemCache.specialIds.dungeonMap)
  4015.                     .forEach(a => result[a.id] = 3 / 24 / lanternMultiplier);
  4016.             }
  4017.             if(foodPerHour && action.type !== 'OUTSKIRTS' && statsStore.get('HEAL')) {
  4018.                 // active food
  4019.                 statsStore.getManyEquipmentItems(itemCache.specialIds.food)
  4020.                     .forEach(a => result[a.id] = foodPerHour);
  4021.             }
  4022.             if(statsStore.getWeapon()?.name?.endsWith('Bow')) {
  4023.                 // ammo
  4024.                 const attacksPerHour = SECONDS_PER_HOUR / statsStore.get('ATTACK_SPEED');
  4025.                 const ammoPerHour = attacksPerHour * (1 - statsStore.get('AMMO_PRESERVATION_CHANCE') / 100);
  4026.                 statsStore.getManyEquipmentItems(itemCache.specialIds.ammo)
  4027.                     .forEach(a => result[a.id] = ammoPerHour);
  4028.             }
  4029.         } else {
  4030.             if(skill.type === 'Gathering') {
  4031.                 // gathering potions
  4032.                 statsStore.getManyEquipmentItems(itemCache.specialIds.gatheringPotion)
  4033.                     .forEach(a => result[a.id] = 20 * potionMultiplier);
  4034.             }
  4035.             if(skill.type === 'Crafting') {
  4036.                 // crafting potions
  4037.                 statsStore.getManyEquipmentItems(itemCache.specialIds.craftingPotion)
  4038.                     .forEach(a => result[a.id] = 20 * potionMultiplier);
  4039.             }
  4040.         }
  4041.         if(statsStore.get('PASSIVE_FOOD_CONSUMPTION') && statsStore.get('HEAL')) {
  4042.             // passive food
  4043.             statsStore.getManyEquipmentItems(itemCache.specialIds.food)
  4044.                 .forEach(a => result[a.id] = (result[a.id] || 0) + statsStore.get('PASSIVE_FOOD_CONSUMPTION') * 3600 / 5 / statsStore.get('HEAL'));
  4045.         }
  4046.         return result;
  4047.     }
  4048.  
  4049.     return exports;
  4050.  
  4051. }
  4052. );
  4053. // estimatorActivity
  4054. window.moduleRegistry.add('estimatorActivity', (skillCache, actionCache, estimatorAction, statsStore, itemCache, dropCache) => {
  4055.  
  4056.     const exports = {
  4057.         get
  4058.     };
  4059.  
  4060.     function get(skillId, actionId) {
  4061.         const skill = skillCache.byId[skillId];
  4062.         const action = actionCache.byId[actionId];
  4063.         const speed = getSpeed(skill.technicalName, action);
  4064.         const actionCount = estimatorAction.LOOPS_PER_HOUR / speed;
  4065.         const actualActionCount = actionCount * (1 + statsStore.get('EFFICIENCY', skill.technicalName) / 100);
  4066.         const dropCount = actualActionCount * (1 + statsStore.get('DOUBLE_DROP', skill.technicalName) / 100);
  4067.         const ingredientCount = actualActionCount * (1 - statsStore.get('PRESERVATION', skill.technicalName) / 100);
  4068.         const exp = actualActionCount * action.exp * (1 + statsStore.get('DOUBLE_EXP', skill.technicalName) / 100);
  4069.         const drops = estimatorAction.getDrops(skillId, actionId, false, dropCount);
  4070.         const ingredients = estimatorAction.getIngredients(actionId, ingredientCount);
  4071.         const equipments = estimatorAction.getEquipmentUses(skillId, actionId);
  4072.  
  4073.         let statLowerTierChance;
  4074.         if(skill.type === 'Gathering' && (statLowerTierChance = statsStore.get('LOWER_TIER_CHANCE', skill.technicalName) / 100)) {
  4075.             for(const item in drops) {
  4076.                 const mappings = dropCache.lowerGatherMappings[item];
  4077.                 if(mappings) {
  4078.                     for(const other of mappings) {
  4079.                         drops[other] = (drops[other] || 0) + statLowerTierChance * drops[item] / mappings.length;
  4080.                     }
  4081.                     drops[item] *= 1 - statLowerTierChance;
  4082.                 }
  4083.             }
  4084.         }
  4085.  
  4086.         let statMerchantSellChance;
  4087.         if(skill.type === 'Crafting' && (statMerchantSellChance = statsStore.get('MERCHANT_SELL_CHANCE', skill.technicalName) / 100)) {
  4088.             for(const item in drops) {
  4089.                 drops[itemCache.specialIds.coins] = (drops[itemCache.specialIds.coins] || 0) + 2 * statMerchantSellChance * drops[item] * itemCache.byId[item].attributes.SELL_PRICE;
  4090.                 drops[item] *= 1 - statMerchantSellChance;
  4091.             }
  4092.         }
  4093.  
  4094.         return {
  4095.             type: 'ACTIVITY',
  4096.             skill: skillId,
  4097.             speed,
  4098.             productionSpeed: speed * actionCount / dropCount,
  4099.             exp,
  4100.             drops,
  4101.             ingredients,
  4102.             equipments
  4103.         };
  4104.     }
  4105.  
  4106.     function getSpeed(skillName, action) {
  4107.         const speedBonus = statsStore.get('SKILL_SPEED', skillName);
  4108.         return Math.round(action.speed * 1000 / (100 + speedBonus)) + 1;
  4109.     }
  4110.  
  4111.     return exports;
  4112.  
  4113. }
  4114. );
  4115. // estimatorCombat
  4116. window.moduleRegistry.add('estimatorCombat', (skillCache, actionCache, monsterCache, itemCache, dropCache, statsStore, Distribution, estimatorAction) => {
  4117.  
  4118.     const exports = {
  4119.         get,
  4120.         getDamageDistributions,
  4121.         getSurvivalChance
  4122.     };
  4123.  
  4124.     function get(skillId, actionId) {
  4125.         const skill = skillCache.byId[skillId];
  4126.         const action = actionCache.byId[actionId];
  4127.         const monsterIds = action.monster ? [action.monster] : action.monsterGroup;
  4128.         const playerStats = getPlayerStats();
  4129.         const sampleMonsterStats = getMonsterStats(monsterIds[Math.floor(monsterIds.length / 2)]);
  4130.         playerStats.damage_ = new Distribution();
  4131.         sampleMonsterStats.damage_ = new Distribution();
  4132.         for(const monsterId of monsterIds) {
  4133.             const monsterStats = getMonsterStats(monsterId);
  4134.             let damage_ = getInternalDamageDistribution(playerStats, monsterStats, monsterIds.length > 1);
  4135.             const weight = damage_.expectedRollsUntill(monsterStats.health);
  4136.             playerStats.damage_.addDistribution(damage_, weight);
  4137.             damage_ = getInternalDamageDistribution(monsterStats, playerStats, monsterIds.length > 1);
  4138.             sampleMonsterStats.damage_.addDistribution(damage_, weight);
  4139.         }
  4140.         playerStats.damage_.normalize();
  4141.         sampleMonsterStats.damage_.normalize();
  4142.  
  4143.         const loopsPerKill = playerStats.attackSpeed * playerStats.damage_.expectedRollsUntill(sampleMonsterStats.health) * 10 + 5;
  4144.         const actionCount = estimatorAction.LOOPS_PER_HOUR / loopsPerKill;
  4145.         const efficiency = 1 + statsStore.get('EFFICIENCY', skill.technicalName) / 100;
  4146.         const actualActionCount = actionCount * efficiency;
  4147.         const dropCount = actualActionCount * (1 + statsStore.get('DOUBLE_DROP', skill.technicalName) / 100);
  4148.         const attacksReceivedPerHour = estimatorAction.LOOPS_PER_HOUR / 10 / sampleMonsterStats.attackSpeed;
  4149.         const healPerFood = statsStore.get('HEAL') * (1 + statsStore.get('FOOD_EFFECT') / 100);
  4150.         const damagePerHour = attacksReceivedPerHour * sampleMonsterStats.damage_.average();
  4151.         const foodPerHour = damagePerHour / healPerFood * (1 - statsStore.get('FOOD_PRESERVATION_CHANCE') / 100);
  4152.  
  4153.         let exp = estimatorAction.LOOPS_PER_HOUR * action.exp / 1000;
  4154.         exp *= efficiency;
  4155.         exp *= 1 + statsStore.get('DOUBLE_EXP', skill.technicalName) / 100;
  4156.         exp *= 1 + statsStore.get('COMBAT_EXP', skill.technicalName) / 100;
  4157.         exp *= getExpTriangleModifier(playerStats, sampleMonsterStats);
  4158.         const drops = estimatorAction.getDrops(skillId, actionId, true, dropCount);
  4159.         const equipments = estimatorAction.getEquipmentUses(skillId, actionId, true, foodPerHour);
  4160.         const survivalChance = getSurvivalChance(playerStats, sampleMonsterStats, loopsPerKill);
  4161.  
  4162.         let statCoinSnatch;
  4163.         if(statCoinSnatch = statsStore.get('COIN_SNATCH')) {
  4164.             const attacksPerHour = estimatorAction.LOOPS_PER_HOUR / 10 / playerStats.attackSpeed;
  4165.             const coinsPerHour = (statCoinSnatch + 1) / 2 * attacksPerHour;
  4166.             drops[itemCache.specialIds.coins] = (drops[itemCache.specialIds.coins] || 0) + coinsPerHour;
  4167.         }
  4168.  
  4169.         let statCarveChance = 0.1;
  4170.         if(action.type !== 'OUTSKIRTS' && (statCarveChance = statsStore.get('CARVE_CHANCE') / 100)) {
  4171.             const boneDrop = dropCache.byAction[actionId].find(a => a.chance === 1);
  4172.             const boneDropCount = drops[boneDrop.item];
  4173.             const coinDrop = dropCache.byAction[actionId].find(a => a.item === itemCache.specialIds.coins);
  4174.             const averageAmount = (1 + coinDrop.amount) / 2;
  4175.             drops[itemCache.specialIds.coins] -= statCarveChance * coinDrop.chance * averageAmount / 2 * boneDropCount;
  4176.             const mappings = dropCache.boneCarveMappings[boneDrop.item];
  4177.             for(const other of mappings) {
  4178.                 drops[other] = (drops[other] || 0) + statCarveChance * coinDrop.chance * boneDropCount / mappings.length;
  4179.             }
  4180.         }
  4181.  
  4182.         return {
  4183.             type: 'COMBAT',
  4184.             skill: skillId,
  4185.             speed: loopsPerKill,
  4186.             productionSpeed: loopsPerKill * actionCount / dropCount,
  4187.             exp,
  4188.             drops,
  4189.             ingredients: {},
  4190.             equipments,
  4191.             player: playerStats,
  4192.             monster: sampleMonsterStats,
  4193.             survivalChance
  4194.         };
  4195.     }
  4196.  
  4197.     function getPlayerStats() {
  4198.         const attackStyle = statsStore.getAttackStyle();
  4199.         const attackSkill = skillCache.byTechnicalName[attackStyle];
  4200.         const attackLevel = statsStore.getLevel(attackSkill.id).level;
  4201.         const defenseLevel = statsStore.getLevel(8).level;
  4202.         return {
  4203.             isPlayer: true,
  4204.             attackStyle,
  4205.             attackSpeed: statsStore.get('ATTACK_SPEED'),
  4206.             damage: statsStore.get('DAMAGE'),
  4207.             armour: statsStore.get('ARMOUR'),
  4208.             health: statsStore.get('HEALTH'),
  4209.             blockChance: statsStore.get('BLOCK_CHANCE')/100,
  4210.             critChance: statsStore.get('CRIT_CHANCE')/100,
  4211.             stunChance: statsStore.get('STUN_CHANCE')/100,
  4212.             parryChance: statsStore.get('PARRY_CHANCE')/100,
  4213.             bleedChance: statsStore.get('BLEED_CHANCE')/100,
  4214.             damageRange: (75 + statsStore.get('DAMAGE_RANGE'))/100,
  4215.             dungeonDamage: 1 + statsStore.get('DUNGEON_DAMAGE')/100,
  4216.             attackLevel,
  4217.             defenseLevel
  4218.         };
  4219.     }
  4220.  
  4221.     function getMonsterStats(monsterId) {
  4222.         const monster = monsterCache.byId[monsterId];
  4223.         return {
  4224.             isPlayer: false,
  4225.             attackStyle: monster.attackStyle,
  4226.             attackSpeed: monster.speed,
  4227.             damage: monster.attack,
  4228.             armour: monster.armour,
  4229.             health: monster.health,
  4230.             blockChance: 0,
  4231.             critChance: 0,
  4232.             stunChance: 0,
  4233.             parryChance: 0,
  4234.             bleedChance: 0,
  4235.             damageRange: 0.75,
  4236.             dungeonDamage: 1,
  4237.             attackLevel: monster.level,
  4238.             defenseLevel: monster.level
  4239.         };
  4240.     }
  4241.  
  4242.     function getInternalDamageDistribution(attacker, defender, isDungeon) {
  4243.         let damage = attacker.damage;
  4244.         damage *= getDamageTriangleModifier(attacker, defender);
  4245.         damage *= getDamageScalingRatio(attacker, defender);
  4246.         damage *= getDamageArmourRatio(attacker, defender);
  4247.         damage *= !isDungeon ? 1 : attacker.dungeonDamage;
  4248.  
  4249.         const maxDamage_ = new Distribution(damage);
  4250.         // crit
  4251.         if(attacker.critChance) {
  4252.             maxDamage_.convolution(
  4253.                 Distribution.getRandomChance(attacker.critChance),
  4254.                 (dmg, crit) => dmg * (crit ? 1.5 : 1)
  4255.             );
  4256.         }
  4257.         // damage range
  4258.         const result = maxDamage_.convolutionWithGenerator(
  4259.             dmg => Distribution.getRandomOutcomeRounded(dmg * attacker.damageRange, dmg),
  4260.             (dmg, randomDamage) => randomDamage
  4261.         );
  4262.         // block
  4263.         if(defender.blockChance) {
  4264.             result.convolution(
  4265.                 Distribution.getRandomChance(defender.blockChance),
  4266.                 (dmg, blocked) => blocked ? 0 : dmg
  4267.             );
  4268.         }
  4269.         // stun
  4270.         if(defender.stunChance) {
  4271.             let stunChance = defender.stunChance;
  4272.             // only when defender accurate
  4273.             stunChance *= getAccuracy(defender, attacker);
  4274.             // can also happen on defender parries
  4275.             stunChance *= 1 + defender.parryChance;
  4276.             // modifier based on speed
  4277.             stunChance *= attacker.attackSpeed / defender.attackSpeed;
  4278.             // convert to actual stunned percentage
  4279.             const stunnedPercentage = stunChance * 2.5 / attacker.attackSpeed;
  4280.             result.convolution(
  4281.                 Distribution.getRandomChance(stunnedPercentage),
  4282.                 (dmg, stunned) => stunned ? 0 : dmg
  4283.             );
  4284.         }
  4285.         // accuracy
  4286.         const accuracy = getAccuracy(attacker, defender);
  4287.         result.convolution(
  4288.             Distribution.getRandomChance(accuracy),
  4289.             (dmg, accurate) => accurate ? dmg : 0
  4290.         );
  4291.         // === special effects ===
  4292.         const intermediateClone_ = result.clone();
  4293.         // parry attacker - deal back 25% of a regular attack
  4294.         if(attacker.parryChance) {
  4295.             let parryChance = attacker.parryChance;
  4296.             if(attacker.attackSpeed < defender.attackSpeed) {
  4297.                 parryChance *= attacker.attackSpeed / defender.attackSpeed;
  4298.             }
  4299.             const parried_ = intermediateClone_.clone();
  4300.             parried_.convolution(
  4301.                 Distribution.getRandomChance(parryChance),
  4302.                 (dmg, parried) => parried ? Math.round(dmg/4.0) : 0
  4303.             );
  4304.             result.convolution(
  4305.                 parried_,
  4306.                 (dmg, extra) => dmg + extra
  4307.             );
  4308.             if(attacker.attackSpeed > defender.attackSpeed) {
  4309.                 // we can parry multiple times during one turn
  4310.                 parryChance *= (attacker.attackSpeed - defender.attackSpeed) / attacker.attackSpeed;
  4311.                 parried_.convolution(
  4312.                     Distribution.getRandomChance(parryChance),
  4313.                     (dmg, parried) => parried ? dmg : 0
  4314.                 );
  4315.                 result.convolution(
  4316.                     parried_,
  4317.                     (dmg, extra) => dmg + extra
  4318.                 );
  4319.             }
  4320.         }
  4321.         // parry defender - deal 50% of a regular attack
  4322.         if(defender.parryChance) {
  4323.             result.convolution(
  4324.                 Distribution.getRandomChance(defender.parryChance),
  4325.                 (dmg, parried) => parried ? Math.round(dmg/2) : dmg
  4326.             );
  4327.         }
  4328.         // bleed - 50% of damage over 3 seconds (assuming to be within one attack round)
  4329.         if(attacker.bleedChance) {
  4330.             const bleed_ = intermediateClone_.clone();
  4331.             bleed_.convolution(
  4332.                 Distribution.getRandomChance(attacker.bleedChance),
  4333.                 (dmg, bleed) => bleed ? 5 * Math.round(dmg/10) : 0
  4334.             );
  4335.             result.convolution(
  4336.                 bleed_,
  4337.                 (dmg, extra) => dmg + extra
  4338.             );
  4339.         }
  4340.         return result;
  4341.     }
  4342.  
  4343.     function getDamageTriangleModifier(attacker, defender) {
  4344.         if(!attacker.attackStyle || !defender.attackStyle) {
  4345.             return 1.0;
  4346.         }
  4347.         if(attacker.attackStyle === defender.attackStyle) {
  4348.             return 1.0;
  4349.         }
  4350.         if(attacker.attackStyle === 'OneHanded' && defender.attackStyle === 'Ranged') {
  4351.             return 1.1;
  4352.         }
  4353.         if(attacker.attackStyle === 'Ranged' && defender.attackStyle === 'TwoHanded') {
  4354.             return 1.1;
  4355.         }
  4356.         if(attacker.attackStyle === 'TwoHanded' && defender.attackStyle === 'OneHanded') {
  4357.             return 1.1;
  4358.         }
  4359.         return 0.9;
  4360.     }
  4361.  
  4362.     function getExpTriangleModifier(attacker, defender) {
  4363.         if(!attacker.attackStyle || !defender.attackStyle) {
  4364.             return 1;
  4365.         }
  4366.         return getDamageTriangleModifier(attacker, defender) - 0.1;
  4367.     }
  4368.  
  4369.     function getDamageScalingRatio(attacker, defender) {
  4370.         const ratio = attacker.attackLevel / defender.defenseLevel;
  4371.         if(attacker.isPlayer) {
  4372.             return Math.min(1, ratio);
  4373.         }
  4374.         return Math.max(1, ratio);
  4375.     }
  4376.  
  4377.     function getDamageArmourRatio(attacker, defender) {
  4378.         if(!defender.armour) {
  4379.             return 1;
  4380.         }
  4381.         const scale = 25 + Math.min(70, (defender.armour - 25) * 50 / 105);
  4382.         return (100 - scale) / 100;
  4383.     }
  4384.  
  4385.     function getAccuracy(attacker, defender) {
  4386.         let accuracy = 75 + (attacker.attackLevel - defender.defenseLevel) / 2.0;
  4387.         accuracy = Math.max(60, accuracy);
  4388.         accuracy = Math.min(90, accuracy);
  4389.         return accuracy / 100;
  4390.     }
  4391.  
  4392.     function getDamageDistributions(monsterId) {
  4393.         const playerStats = getPlayerStats();
  4394.         const monsterStats = getMonsterStats(monsterId);
  4395.         const playerDamage_ = getInternalDamageDistribution(playerStats, monsterStats);
  4396.         const monsterDamage_ = getInternalDamageDistribution(monsterStats, playerStats);
  4397.         playerDamage_.normalize();
  4398.         monsterDamage_.normalize();
  4399.         return [playerDamage_, monsterDamage_];
  4400.     }
  4401.  
  4402.     function getSurvivalChance(player, monster, loopsPerFight, fights = 10, applyCringeMultiplier = false) {
  4403.         const loopsPerAttack = monster.attackSpeed * 10;
  4404.         let attacksPerFight = loopsPerFight / loopsPerAttack;
  4405.         if(fights === 1 && applyCringeMultiplier) {
  4406.             const playerLoopsPerAttack = player.attackSpeed * 10;
  4407.             const playerAttacksPerFight = loopsPerFight / playerLoopsPerAttack;
  4408.             const cringeMultiplier = Math.min(1.4, Math.max(1, 1.4 - playerAttacksPerFight / 50));
  4409.             attacksPerFight *= cringeMultiplier;
  4410.         }
  4411.         const foodPerAttack = loopsPerAttack / estimatorAction.LOOPS_PER_FOOD;
  4412.         const healPerFood = statsStore.get('HEAL') * (1 + statsStore.get('FOOD_EFFECT') / 100);
  4413.         const healPerAttack = Math.round(healPerFood * foodPerAttack);
  4414.         const healPerFight = healPerAttack * attacksPerFight;
  4415.         let deathChance = 0;
  4416.         let scenarioChance = 1;
  4417.         let health = player.health;
  4418.         for(let i=0;i<fights;i++) {
  4419.             const currentDeathChance = monster.damage_.getRightTail(attacksPerFight, health + healPerFight);
  4420.             deathChance += currentDeathChance * scenarioChance;
  4421.             scenarioChance *= 1 - currentDeathChance;
  4422.             const damage = monster.damage_.getMeanRange(attacksPerFight, healPerFight, health + healPerFight);
  4423.             health -= damage - healPerFight;
  4424.             if(isNaN(health) || health === Infinity || health === -Infinity) {
  4425.                 // TODO NaN / Infinity result from above?
  4426.                 break;
  4427.             }
  4428.         }
  4429.         const cringeCutoff = 0.10;
  4430.         if(fights === 1 && !applyCringeMultiplier && deathChance < cringeCutoff) {
  4431.             const other = getSurvivalChance(player, monster, loopsPerFight, fights, true);
  4432.             const avg = (1 - deathChance + other) / 2;
  4433.             if(avg > 1 - cringeCutoff / 2) {
  4434.                 return avg;
  4435.             }
  4436.         }
  4437.         return 1 - deathChance;
  4438.     }
  4439.  
  4440.     return exports;
  4441.  
  4442. }
  4443. );
  4444. // estimatorExpeditions
  4445. window.moduleRegistry.add('estimatorExpeditions', (events, estimator, components, petUtil, util, skillCache, itemCache, petCache, colorMapper, petHighlighter, configuration, expeditionDropCache) => {
  4446.  
  4447.     let enabled = false;
  4448.  
  4449.     const exports = {
  4450.         get
  4451.     };
  4452.  
  4453.     function initialise() {
  4454.         configuration.registerCheckbox({
  4455.             category: 'Pets',
  4456.             key: 'pet-estimations',
  4457.             name: 'Estimations',
  4458.             default: true,
  4459.             handler: handleConfigStateChange
  4460.         });
  4461.         events.register('page', update);
  4462.         events.register('state-stats', update);
  4463.     }
  4464.  
  4465.     function handleConfigStateChange(state) {
  4466.         enabled = state;
  4467.     }
  4468.  
  4469.     function update() {
  4470.         if(!enabled) {
  4471.             return;
  4472.         }
  4473.         const page = events.getLast('page');
  4474.         if(page?.type === 'taming' && page.menu === 'expeditions' && page.tier) {
  4475.             const estimation = get(page.tier);
  4476.             estimator.enrichTimings(estimation);
  4477.             estimator.enrichValues(estimation);
  4478.             preRender(estimation, componentBlueprint);
  4479.             estimator.preRenderItems(estimation, componentBlueprint);
  4480.             components.addComponent(componentBlueprint);
  4481.             return;
  4482.         }
  4483.         components.removeComponent(componentBlueprint);
  4484.     }
  4485.  
  4486.     function get(tier) {
  4487.         const teamStats = events.getLast('state-pet')
  4488.             .filter(pet => pet.partOfTeam)
  4489.             .map(petUtil.petToStats);
  4490.         const totalStats = util.sumObjects(teamStats);
  4491.         const expedition = petUtil.getExpeditionStats(tier);
  4492.         const successChance = getSuccessChance(totalStats, expedition);
  4493.  
  4494.         const ingredients = {
  4495.             [itemCache.byName['Pet Snacks'].id]: Math.floor(expedition.food / 4 * (1 + totalStats.hunger / 100)) * 4
  4496.         };
  4497.  
  4498.         const drops = {};
  4499.         const expeditionDrops = expeditionDropCache.byExpedition[expedition.id];
  4500.         for(const drop of expeditionDrops) {
  4501.             if(totalStats[drop.type]) {
  4502.                 drops[drop.item] = drop.amount * totalStats[drop.type];
  4503.             }
  4504.         }
  4505.  
  4506.         return {
  4507.             tier,
  4508.             successChance,
  4509.             ingredients,
  4510.             drops,
  4511.             teamStats,
  4512.             totalStats,
  4513.             exp: expedition.exp,
  4514.             skill: skillCache.byName['Taming'].id,
  4515.             equipments: {}
  4516.         };
  4517.     }
  4518.  
  4519.     function getSuccessChance(stats, expedition) {
  4520.         const attackRatio = Math.max(stats.attack / expedition.stats.defense, stats.specialAttack / expedition.stats.specialDefense);
  4521.         let defenseRatio = 0;
  4522.         if(expedition.rotation.attack) {
  4523.             defenseRatio = expedition.stats.attack / stats.defense;
  4524.         } else {
  4525.             defenseRatio = expedition.stats.specialAttack / stats.specialDefense;
  4526.         }
  4527.         const damageRatio = attackRatio / defenseRatio;
  4528.         const healthRatio = stats.health / expedition.stats.health;
  4529.         const speedRatio = stats.speed / expedition.stats.speed;
  4530.         const successChance = 100 * damageRatio * healthRatio * speedRatio + stats.stealth;
  4531.         return Math.min(100, Math.max(0, successChance));
  4532.     }
  4533.  
  4534.     function preRender(estimation, blueprint) {
  4535.         components.search(blueprint, 'successChance').value
  4536.             = util.formatNumber(estimation.successChance);
  4537.         components.search(blueprint, 'exp').value
  4538.             = util.formatNumber(estimation.exp);
  4539.         components.search(blueprint, 'expActual').value
  4540.             = util.formatNumber(estimation.exp * estimation.successChance / 100);
  4541.         components.search(blueprint, 'levelTime').value
  4542.             = util.secondsToDuration(estimation.timings.level);
  4543.         components.search(blueprint, 'tierTime').value
  4544.             = util.secondsToDuration(estimation.timings.tier);
  4545.         components.search(blueprint, 'dropValue').value
  4546.             = util.formatNumber(estimation.values.drop);
  4547.         components.search(blueprint, 'ingredientValue').value
  4548.             = util.formatNumber(estimation.values.ingredient);
  4549.         components.search(blueprint, 'netValue').value
  4550.             = util.formatNumber(estimation.values.net);
  4551.         components.search(blueprint, 'teamSize').value
  4552.             = util.formatNumber(estimation.teamStats.length);
  4553.         for(const stat of petUtil.STATS_BASE) {
  4554.             components.search(blueprint, `teamStat-${stat}`).value
  4555.                 = util.formatNumber(estimation.totalStats[stat]);
  4556.         }
  4557.         for(const stat of petUtil.STATS_SPECIAL) {
  4558.             components.search(blueprint, `teamStat-${stat}`).value
  4559.                 = util.formatNumber(estimation.totalStats[stat]) + ' %';
  4560.         }
  4561.     }
  4562.  
  4563.     function calculateOptimizedTeam() {
  4564.         const petsAndStats = events.getLast('state-pet')
  4565.             .filter(pet => pet.parsed)
  4566.             .map(pet => ({
  4567.                 pet,
  4568.                 stats: petUtil.petToStats(pet)
  4569.             }));
  4570.         // make all combinations of 3 pets of different species (same family is allowed)
  4571.         const combinations = util.generateCombinations(petsAndStats, 3, object => object.pet.species);
  4572.         if(!combinations.length) {
  4573.             return;
  4574.         }
  4575.         console.debug(`Calculating ${combinations.length} team combinations`);
  4576.         const tier = events.getLast('page').tier;
  4577.         const expedition = petUtil.getExpeditionStats(tier);
  4578.         let bestSuccessChance = 0;
  4579.         let bestCombination = null;
  4580.         for(const combination of combinations) {
  4581.             const teamStats = combination.map(a => a.stats);
  4582.             const totalStats = util.sumObjects(teamStats);
  4583.             const successChance = getSuccessChance(totalStats, expedition);
  4584.             if(successChance > bestSuccessChance) {
  4585.                 bestCombination = combination;
  4586.             }
  4587.         }
  4588.  
  4589.         const teamRows = components.search(componentBlueprint, 'optimalTeamRows');
  4590.         teamRows.rows = [{
  4591.             type: 'header',
  4592.             title: `Expedition T${tier} : ${expedition.name} (${combinations.length} combinations)`,
  4593.             name: 'Highlight',
  4594.             action: () => {
  4595.                 const color = colorMapper('success');
  4596.                 petHighlighter.highlight(color, bestCombination.map(a => a.pet.name));
  4597.                 $('taming-page .header:contains("Menu") ~ button:contains("Pets")').click()
  4598.             }
  4599.         }];
  4600.         for(const object of bestCombination) {
  4601.             teamRows.rows.push({
  4602.                 type: 'item',
  4603.                 name: object.pet.name,
  4604.                 image: `/assets/${petCache.byId[object.pet.species].image}`,
  4605.                 imagePixelated: true,
  4606.             });
  4607.         }
  4608.         components.addComponent(componentBlueprint);
  4609.     }
  4610.  
  4611.     const componentBlueprint = {
  4612.         componentId: 'tamingEstimatorComponent',
  4613.         dependsOn: 'taming-page',
  4614.         parent: 'taming-page > .groups > .group:last-child',
  4615.         selectedTabIndex: 0,
  4616.         tabs: [{
  4617.             title: 'Overview',
  4618.             rows: [{
  4619.                 type: 'item',
  4620.                 id: 'successChance',
  4621.                 name: 'Success chance',
  4622.                 image: 'https://cdn-icons-png.flaticon.com/512/3004/3004458.png',
  4623.                 value: ''
  4624.             },{
  4625.                 type: 'item',
  4626.                 id: 'exp',
  4627.                 name: 'Exp/hour',
  4628.                 image: 'https://cdn-icons-png.flaticon.com/512/616/616490.png',
  4629.                 value: ''
  4630.             },{
  4631.                 type: 'item',
  4632.                 id: 'expActual',
  4633.                 name: 'Exp/hour (weighted)',
  4634.                 image: 'https://cdn-icons-png.flaticon.com/512/616/616490.png',
  4635.                 value: ''
  4636.             },{
  4637.                 type: 'item',
  4638.                 id: 'levelTime',
  4639.                 name: 'Level up',
  4640.                 image: 'https://cdn-icons-png.flaticon.com/512/4614/4614145.png',
  4641.                 value: ''
  4642.             },{
  4643.                 type: 'item',
  4644.                 id: 'tierTime',
  4645.                 name: 'Tier up',
  4646.                 image: 'https://cdn-icons-png.flaticon.com/512/4789/4789514.png',
  4647.                 value: ''
  4648.             },{
  4649.                 type: 'item',
  4650.                 id: 'dropValue',
  4651.                 name: 'Gold/hour (loot)',
  4652.                 image: 'https://cdn-icons-png.flaticon.com/512/9028/9028024.png',
  4653.                 imageFilter: 'invert(100%) sepia(47%) saturate(3361%) hue-rotate(313deg) brightness(106%) contrast(108%)',
  4654.                 value: ''
  4655.             },{
  4656.                 type: 'item',
  4657.                 id: 'ingredientValue',
  4658.                 name: 'Gold/hour (materials)',
  4659.                 image: 'https://cdn-icons-png.flaticon.com/512/9028/9028031.png',
  4660.                 imageFilter: 'invert(100%) sepia(47%) saturate(3361%) hue-rotate(313deg) brightness(106%) contrast(108%)',
  4661.                 value: ''
  4662.             },{
  4663.                 type: 'item',
  4664.                 id: 'netValue',
  4665.                 name: 'Gold/hour (total)',
  4666.                 image: 'https://cdn-icons-png.flaticon.com/512/11937/11937869.png',
  4667.                 imageFilter: 'invert(100%) sepia(47%) saturate(3361%) hue-rotate(313deg) brightness(106%) contrast(108%)',
  4668.                 value: ''
  4669.             }]
  4670.         },{
  4671.             title: 'Items',
  4672.             rows: [{
  4673.                 type: 'header',
  4674.                 title: 'Produced'
  4675.             },{
  4676.                 type: 'segment',
  4677.                 id: 'dropRows',
  4678.                 rows: []
  4679.             },{
  4680.                 type: 'header',
  4681.                 title: 'Consumed'
  4682.             },{
  4683.                 type: 'segment',
  4684.                 id: 'ingredientRows',
  4685.                 rows: []
  4686.             }]
  4687.         },{
  4688.             title: 'Time',
  4689.             rows: [{
  4690.                 type: 'segment',
  4691.                 id: 'timeRows',
  4692.                 rows: []
  4693.             }]
  4694.         },{
  4695.             title: 'Team',
  4696.             rows: [{
  4697.                 type: 'header',
  4698.                 title: 'Calculate optimal team',
  4699.                 name: 'Run',
  4700.                 action: calculateOptimizedTeam
  4701.             },{
  4702.                 type: 'segment',
  4703.                 id: 'optimalTeamRows',
  4704.                 rows: []
  4705.             },{
  4706.                 type: 'header',
  4707.                 title: 'Stats'
  4708.             },{
  4709.                 type: 'item',
  4710.                 id: 'teamSize',
  4711.                 name: 'Size',
  4712.                 image: 'https://img.icons8.com/?size=48&id=8183',
  4713.                 value: ''
  4714.             },{
  4715.                 type: 'item',
  4716.                 id: 'teamStat-health',
  4717.                 name: 'Health',
  4718.                 image: petUtil.IMAGES.health,
  4719.                 value: ''
  4720.             },{
  4721.                 type: 'item',
  4722.                 id: 'teamStat-speed',
  4723.                 name: 'Speed',
  4724.                 image: petUtil.IMAGES.speed,
  4725.                 value: ''
  4726.             },{
  4727.                 type: 'item',
  4728.                 id: 'teamStat-attack',
  4729.                 name: 'Attack',
  4730.                 image: petUtil.IMAGES.attack,
  4731.                 value: ''
  4732.             },{
  4733.                 type: 'item',
  4734.                 id: 'teamStat-specialAttack',
  4735.                 name: 'Special Attack',
  4736.                 image: petUtil.IMAGES.specialAttack,
  4737.                 value: ''
  4738.             },{
  4739.                 type: 'item',
  4740.                 id: 'teamStat-defense',
  4741.                 name: 'Defense',
  4742.                 image: petUtil.IMAGES.defense,
  4743.                 value: ''
  4744.             },{
  4745.                 type: 'item',
  4746.                 id: 'teamStat-specialDefense',
  4747.                 name: 'Special Defense',
  4748.                 image: petUtil.IMAGES.specialDefense,
  4749.                 value: ''
  4750.             },{
  4751.                 type: 'item',
  4752.                 id: 'teamStat-hunger',
  4753.                 name: 'Hunger',
  4754.                 image: petUtil.IMAGES.hunger,
  4755.                 value: ''
  4756.             },{
  4757.                 type: 'item',
  4758.                 id: 'teamStat-stealth',
  4759.                 name: 'Stealth',
  4760.                 image: petUtil.IMAGES.stealth,
  4761.                 value: ''
  4762.             },{
  4763.                 type: 'item',
  4764.                 id: 'teamStat-loot',
  4765.                 name: 'Loot',
  4766.                 image: petUtil.IMAGES.loot,
  4767.                 value: ''
  4768.             }]
  4769.         }]
  4770.     };
  4771.  
  4772.     initialise();
  4773.  
  4774.     return exports;
  4775.  
  4776. }
  4777. );
  4778. // estimatorOutskirts
  4779. window.moduleRegistry.add('estimatorOutskirts', (actionCache, itemCache, statsStore, estimatorActivity, estimatorCombat) => {
  4780.  
  4781.     const exports = {
  4782.         get
  4783.     };
  4784.  
  4785.     function get(skillId, actionId) {
  4786.         try {
  4787.             const action = actionCache.byId[actionId];
  4788.  
  4789.             const activityEstimation = estimatorActivity.get(skillId, actionId);
  4790.             const excludedItemIds = itemCache.specialIds.food.concat(itemCache.specialIds.combatPotion);
  4791.             statsStore.update(new Set(excludedItemIds));
  4792.             const combatEstimation = estimatorCombat.get(skillId, actionId);
  4793.             const monsterChance = (1000 - action.outskirtsMonsterChance) / 1000;
  4794.  
  4795.             // Axioms:
  4796.             // combatRatio = 1 - activityRatio
  4797.             // activityLoops = totalLoops * activityRatio
  4798.             // combatLoops = totalLoops * combatRatio
  4799.             // fights = combatLoops / combatSpeed
  4800.             // actions = activityLoops / activitySpeed
  4801.             // encounterChance = fights / (fights + actions)
  4802.             const combatRatio = combatEstimation.speed / (activityEstimation.speed * (1 / monsterChance + combatEstimation.speed / activityEstimation.speed - 1));
  4803.             const activityRatio = 1 - combatRatio;
  4804.  
  4805.             const survivalChance = estimatorCombat.getSurvivalChance(combatEstimation.player, combatEstimation.monster, combatEstimation.speed, 1);
  4806.  
  4807.             const exp = activityEstimation.exp * activityRatio;
  4808.             const drops = {};
  4809.             merge(drops, activityEstimation.drops, activityRatio);
  4810.             merge(drops, combatEstimation.drops, combatRatio);
  4811.             const ingredients = {};
  4812.             merge(ingredients, activityEstimation.ingredients, activityRatio);
  4813.             merge(ingredients, combatEstimation.ingredients, combatRatio);
  4814.             const equipments = {};
  4815.             merge(equipments, activityEstimation.equipments, activityRatio);
  4816.             merge(equipments, combatEstimation.equipments, combatRatio);
  4817.  
  4818.             return {
  4819.                 type: 'OUTSKIRTS',
  4820.                 skill: skillId,
  4821.                 speed: activityEstimation.speed,
  4822.                 productionSpeed: activityEstimation.productionSpeed,
  4823.                 exp,
  4824.                 drops,
  4825.                 ingredients,
  4826.                 equipments,
  4827.                 player: combatEstimation.player,
  4828.                 monster: combatEstimation.monster,
  4829.                 survivalChance
  4830.             };
  4831.         } finally {
  4832.             statsStore.update(new Set());
  4833.         }
  4834.     }
  4835.  
  4836.     function merge(target, source, ratio) {
  4837.         for(const key in source) {
  4838.             target[key] = (target[key] || 0) + source[key] * ratio;
  4839.         }
  4840.     }
  4841.  
  4842.     return exports;
  4843.  
  4844.  
  4845.  
  4846. }
  4847. );
  4848. // guildSorts
  4849. window.moduleRegistry.add('guildSorts', (events, elementWatcher, util, elementCreator, configuration, colorMapper) => {
  4850.  
  4851.     let enabled = false;
  4852.  
  4853.     function initialise() {
  4854.         configuration.registerCheckbox({
  4855.             category: 'UI Features',
  4856.             key: 'guild-sorts',
  4857.             name: 'Guild sorts',
  4858.             default: true,
  4859.             handler: handleConfigStateChange
  4860.         });
  4861.         elementCreator.addStyles(styles);
  4862.         events.register('page', setup);
  4863.     }
  4864.  
  4865.     function handleConfigStateChange(state) {
  4866.         enabled = state;
  4867.     }
  4868.  
  4869.     async function setup() {
  4870.         if(!enabled) {
  4871.             return;
  4872.         }
  4873.         try {
  4874.             await elementWatcher.exists('.card > .row');
  4875.             if(events.getLast('page').type !== 'guild') {
  4876.                 return;
  4877.             }
  4878.             await addAdditionGuildSortButtons();
  4879.             setupGuildMenuButtons();
  4880.         } catch(e) {}
  4881.     }
  4882.  
  4883.     function setupGuildMenuButtons() {
  4884.         $(`button > div.name:contains('Members')`).parent().on('click', async function () {
  4885.             await util.sleep(50);
  4886.             await addAdditionGuildSortButtons();
  4887.         });
  4888.     }
  4889.  
  4890.     async function addAdditionGuildSortButtons() {
  4891.         await elementWatcher.exists('div.sort');
  4892.         const orginalButtonGroup = $('div.sort').find('div.container');
  4893.  
  4894.         // rename daily to daily xp
  4895.         $(`button:contains('Daily')`).text('Daily XP');
  4896.         // fix text on 2 lines
  4897.         $('div.sort').find('button').addClass('overrideFlex');
  4898.         // attach clear custom to game own sorts
  4899.         $('div.sort').find('button').on('click', function() {
  4900.             clearCustomActiveButtons()
  4901.         });
  4902.  
  4903.         const customButtonGroup = $('<div/>')
  4904.             .addClass('customButtonGroup')
  4905.             .addClass('alignButtonGroupLeft')
  4906.             .attr('id', 'guildSortButtonGroup')
  4907.             .append(
  4908.                 $('<button/>')
  4909.                     .attr('type', 'button')
  4910.                     .addClass('customButtonGroupButton')
  4911.                     .addClass('customSortByLevel')
  4912.                     .text('Level')
  4913.                     .click(sortByLevel)
  4914.             )
  4915.             .append(
  4916.                 $('<button/>')
  4917.                     .attr('type', 'button')
  4918.                     .addClass('customButtonGroupButton')
  4919.                     .addClass('customSortByIdle')
  4920.                     .text('Idle')
  4921.                     .click(sortByIdle)
  4922.             )
  4923.             .append(
  4924.                 $('<button/>')
  4925.                     .attr('type', 'button')
  4926.                     .addClass('customButtonGroupButton')
  4927.                     .addClass('customSortByTotalXP')
  4928.                     .text('Total XP')
  4929.                     .click(sortByXp)
  4930.             );
  4931.  
  4932.         customButtonGroup.insertAfter(orginalButtonGroup);
  4933.     }
  4934.  
  4935.     function clearCustomActiveButtons() {
  4936.         $('.customButtonGroupButton').removeClass('custom-sort-active');
  4937.     }
  4938.  
  4939.     function clearActiveButtons() {
  4940.         $('div.sort').find('button').removeClass('sort-active');
  4941.     }
  4942.  
  4943.     function sortByXp() {
  4944.         $(`button:contains('Date')`).trigger('click');
  4945.  
  4946.         clearCustomActiveButtons();
  4947.         clearActiveButtons();
  4948.         $('.customSortByTotalXP').addClass('custom-sort-active');
  4949.  
  4950.         const parent = $('div.sort').parent();
  4951.         sortElements({
  4952.             elements: parent.find('button.row'),
  4953.             extractor: a => util.parseNumber($(a).find('div.amount').text()),
  4954.             sorter: (a,b) => b-a,
  4955.             target: parent
  4956.         });
  4957.     }
  4958.  
  4959.     function sortByIdle() {
  4960.         // make sure the last contributed time is visible
  4961.         if(
  4962.             !$(`div.sort button:contains('Date')`).hasClass('sort-active') &&
  4963.             !$(`button:contains('Daily XP')`).hasClass('sort-active')
  4964.         ) {
  4965.             $(`button:contains('Date')`).trigger('click');
  4966.         }
  4967.  
  4968.         clearCustomActiveButtons();
  4969.         clearActiveButtons();
  4970.         $('.customSortByIdle').addClass('custom-sort-active');
  4971.  
  4972.         const parent = $('div.sort').parent();
  4973.         sortElements({
  4974.             elements: parent.find('button.row'),
  4975.             extractor: a => util.parseDuration($(a).find('div.time').text()),
  4976.             sorter: (a,b) => b-a,
  4977.             target: parent
  4978.         });
  4979.     }
  4980.  
  4981.     function sortByLevel() {
  4982.         clearCustomActiveButtons();
  4983.         clearActiveButtons();
  4984.         $('.customSortByLevel').addClass('custom-sort-active');
  4985.  
  4986.         const parent = $('div.sort').parent();
  4987.         sortElements({
  4988.             elements: parent.find('button.row'),
  4989.             extractor: a => util.parseNumber($(a).find('div.level').text().replace('Lv. ', '')),
  4990.             sorter: (a,b) => b-a,
  4991.             target: parent
  4992.         });
  4993.     }
  4994.  
  4995.     // sorts a list of `elements` according to the extracted property from `extractor`,
  4996.     // sorts them using `sorter`, and appends them to the `target`
  4997.     // elements is a jquery list
  4998.     // target is a jquery element
  4999.     // { elements, target, extractor, sorter }
  5000.     function sortElements(config) {
  5001.         const list = config.elements.get().map(element => ({
  5002.             element,
  5003.             value: config.extractor(element)
  5004.         }));
  5005.         list.sort((a,b) => config.sorter(a.value, b.value));
  5006.         for(const item of list) {
  5007.             config.target.append(item.element);
  5008.         }
  5009.     }
  5010.  
  5011.     const styles = `
  5012.         .alignButtonGroupLeft {
  5013.             margin-right: auto;
  5014.             margin-left: 8px;
  5015.         }
  5016.         .customButtonGroup {
  5017.             display: flex;
  5018.             align-items: center;
  5019.             border-radius: 4px;
  5020.             box-shadow: 0 1px 2px #0003;
  5021.             border: 1px solid #263849;
  5022.             overflow: hidden;
  5023.         }
  5024.         .customButtonGroupButton {
  5025.             padding: 4px var(--gap);
  5026.             flex: none !important;
  5027.             text-align: center;
  5028.             justify-content: center;
  5029.             background-color: ${colorMapper('componentRegular')};
  5030.         }
  5031.         .customButtonGroupButton:not(:first-of-type) {
  5032.             border-left: 1px solid #263849;
  5033.         }
  5034.         .overrideFlex {
  5035.             flex: none !important
  5036.         }
  5037.         .custom-sort-active {
  5038.             background-color: ${colorMapper('componentLight')};
  5039.         }
  5040.     `;
  5041.  
  5042.     initialise();
  5043. }
  5044. );
  5045. // idleBeep
  5046. window.moduleRegistry.add('idleBeep', (configuration, events, util) => {
  5047.  
  5048.     const audio = new Audio('data:audio/mpeg;base64,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');
  5049.     const sleepAmount = 2000;
  5050.     let enabled = false;
  5051.     let started = false;
  5052.  
  5053.     function initialise() {
  5054.         configuration.registerCheckbox({
  5055.             category: 'Other',
  5056.             key: 'idle-beep-enabled',
  5057.             name: 'Idle beep',
  5058.             default: false,
  5059.             handler: handleConfigStateChange
  5060.         });
  5061.         events.register('xhr', handleXhr);
  5062.     }
  5063.  
  5064.     function handleConfigStateChange(state, name) {
  5065.         enabled = state;
  5066.     }
  5067.  
  5068.     async function handleXhr(xhr) {
  5069.         if(!enabled) {
  5070.             return;
  5071.         }
  5072.         if(xhr.url.endsWith('startAction')) {
  5073.             started = true;
  5074.         }
  5075.         if(xhr.url.endsWith('stopAction')) {
  5076.             started = false;
  5077.             console.debug(`Triggering beep in ${sleepAmount}ms`);
  5078.             await util.sleep(sleepAmount);
  5079.             beep();
  5080.         }
  5081.     }
  5082.  
  5083.     function beep() {
  5084.         if(!started) {
  5085.             audio.play();
  5086.         }
  5087.     }
  5088.  
  5089.     initialise();
  5090.  
  5091. }
  5092. );
  5093. // itemHover
  5094. window.moduleRegistry.add('itemHover', (configuration, itemCache, util) => {
  5095.  
  5096.     let enabled = false;
  5097.     let entered = false;
  5098.     let element;
  5099.     const converters = {
  5100.         SPEED: a => a/2,
  5101.         DURATION: a => util.secondsToDuration(a/10)
  5102.     }
  5103.  
  5104.     function initialise() {
  5105.         configuration.registerCheckbox({
  5106.             category: 'UI Features',
  5107.             key: 'item-hover',
  5108.             name: 'Item hover info',
  5109.             default: true,
  5110.             handler: handleConfigStateChange
  5111.         });
  5112.         setup();
  5113.         $(document).on('mouseenter', 'div.image > img', handleMouseEnter);
  5114.         $(document).on('mouseleave', 'div.image > img', handleMouseLeave);
  5115.         $(document).on('click', 'div.image > img', handleMouseLeave);
  5116.     }
  5117.  
  5118.     function handleConfigStateChange(state) {
  5119.         enabled = state;
  5120.     }
  5121.  
  5122.     function handleMouseEnter(event) {
  5123.         if(!enabled || entered || !itemCache.byId) {
  5124.             return;
  5125.         }
  5126.         entered = true;
  5127.         const name = $(event.relatedTarget).find('.name').text();
  5128.         const nameMatch = itemCache.byName[name];
  5129.         if(nameMatch) {
  5130.             return show(nameMatch);
  5131.         }
  5132.  
  5133.         const parts = event.target.src.split('/');
  5134.         const lastPart = parts[parts.length-1];
  5135.         const imageMatch = itemCache.byImage[lastPart];
  5136.         if(imageMatch) {
  5137.             return show(imageMatch);
  5138.         }
  5139.     }
  5140.  
  5141.     function handleMouseLeave(event) {
  5142.         if(!enabled || !itemCache.byId) {
  5143.             return;
  5144.         }
  5145.         entered = false;
  5146.         hide();
  5147.     }
  5148.  
  5149.     function show(item) {
  5150.         element.find('.image').attr('src', `/assets/${item.image}`);
  5151.         element.find('.name').text(item.name);
  5152.         for(const attribute of itemCache.attributes) {
  5153.             let value = item.attributes[attribute.technicalName];
  5154.             if(value && converters[attribute.technicalName]) {
  5155.                 value = converters[attribute.technicalName](value);
  5156.             }
  5157.             if(value && Number.isInteger(value)) {
  5158.                 value = util.formatNumber(value);
  5159.             }
  5160.             updateRow(attribute.technicalName, value);
  5161.         }
  5162.         element.show();
  5163.     }
  5164.  
  5165.     function updateRow(name, value) {
  5166.         if(!value) {
  5167.             element.find(`.${name}-row`).hide();
  5168.         } else {
  5169.             element.find(`.${name}`).text(value);
  5170.             element.find(`.${name}-row`).show();
  5171.         }
  5172.     }
  5173.  
  5174.     function hide() {
  5175.         element.hide();
  5176.     }
  5177.  
  5178.     function setup() {
  5179.         const attributesHtml = itemCache.attributes
  5180.             .map(a => `<div class='${a.technicalName}-row'><img src='${a.image}'/><span>${a.name}</span><span class='${a.technicalName}'/></div>`)
  5181.             .join('');
  5182.         $('head').append(`
  5183.             <style>
  5184.                 #custom-item-hover {
  5185.                     position: fixed;
  5186.                     right: .5em;
  5187.                     top: .5em;
  5188.                     display: flex;
  5189.                     font-family: Jost,Helvetica Neue,Arial,sans-serif;
  5190.                     flex-direction: column;
  5191.                     white-space: nowrap;
  5192.                     z-index: 1;
  5193.                     background-color: black;
  5194.                     padding: .4rem;
  5195.                     border: 1px solid #3e3e3e;
  5196.                     border-radius: .4em;
  5197.                     gap: .4em;
  5198.                 }
  5199.                 #custom-item-hover > div {
  5200.                     display: flex;
  5201.                     gap: .4em;
  5202.                 }
  5203.                 #custom-item-hover > div > *:last-child {
  5204.                     margin-left: auto;
  5205.                 }
  5206.                 #custom-item-hover img {
  5207.                     width: 24px;
  5208.                     height: 24px;
  5209.                     image-rendering: auto;
  5210.                 }
  5211.                 #custom-item-hover img.pixelated {
  5212.                     image-rendering: pixelated;
  5213.                 }
  5214.             </style>
  5215.         `);
  5216.         element = $(`
  5217.             <div id='custom-item-hover' style='display:none'>
  5218.                 <div>
  5219.                     <img class='image pixelated'/>
  5220.                     <span class='name'/>
  5221.                 </div>
  5222.                 ${attributesHtml}
  5223.             </div>
  5224.         `);
  5225.         $('body').append(element);
  5226.     }
  5227.  
  5228.     initialise();
  5229.  
  5230. }
  5231. );
  5232. // marketCompetition
  5233. window.moduleRegistry.add('marketCompetition', (configuration, events, toast, util, elementCreator, colorMapper) => {
  5234.  
  5235.     let enabled = false;
  5236.  
  5237.     function initialise() {
  5238.         configuration.registerCheckbox({
  5239.             category: 'Data',
  5240.             key: 'market-competition',
  5241.             name: 'Market competition indicator',
  5242.             default: false,
  5243.             handler: handleConfigStateChange
  5244.         });
  5245.         events.register('state-market', handleMarketData);
  5246.         elementCreator.addStyles(styles);
  5247.     }
  5248.  
  5249.     function handleConfigStateChange(state) {
  5250.         enabled = state;
  5251.     }
  5252.  
  5253.     function handleMarketData(marketData) {
  5254.         if(!enabled || marketData.lastType !== 'OWN') {
  5255.             return;
  5256.         }
  5257.         const page = events.getLast('page');
  5258.         if(page.type !== 'market') {
  5259.             return;
  5260.         }
  5261.         showToasts(marketData);
  5262.         showCircles(marketData);
  5263.     }
  5264.  
  5265.     function showToasts(marketData) {
  5266.         if(!marketData.SELL) {
  5267.             toast.create({
  5268.                 text: 'Missing "Buy" listing data for the competition checker'
  5269.             });
  5270.         }
  5271.         if(!marketData.BUY) {
  5272.             toast.create({
  5273.                 text: 'Missing "Orders" listing data for the competition checker'
  5274.             });
  5275.         }
  5276.     }
  5277.  
  5278.     function showCircles(marketData) {
  5279.         $('.market-competition').remove();
  5280.         for(const listing of marketData.OWN) {
  5281.             if(!marketData[listing.type]) {
  5282.                 continue;
  5283.             }
  5284.             const matching = marketData[listing.type].filter(a => !a.isOwn && a.item === listing.item);
  5285.             const same = matching.filter(a => a.price === listing.price);
  5286.             const better = matching.filter(a =>
  5287.                 (listing.type === 'SELL' && a.price < listing.price) ||
  5288.                 (listing.type === 'BUY' && a.price > listing.price)
  5289.             );
  5290.             if(!same.length && !better.length) {
  5291.                 continue;
  5292.             }
  5293.             const color = better.length ? 'danger' : 'warning';
  5294.             const text = better.concat(same)
  5295.                     .map(a => `${util.formatNumber(a.amount)} @ ${util.formatNumber(a.price)}`)
  5296.                     .join(' / ');
  5297.             listing.element.find('.cost').before(`<div class='market-competition market-competition-${color}' title='${text}'></div>`);
  5298.         }
  5299.     }
  5300.  
  5301.     const styles = `
  5302.         .market-competition {
  5303.             width: 16px;
  5304.             height: 16px;
  5305.             border-radius: 50%;
  5306.         }
  5307.  
  5308.         .market-competition-warning {
  5309.             background-color: ${colorMapper('warning')}
  5310.         }
  5311.  
  5312.         .market-competition-danger {
  5313.             background-color: ${colorMapper('danger')}
  5314.         }
  5315.     `;
  5316.  
  5317.     initialise();
  5318.  
  5319. }
  5320. );
  5321. // marketFilter
  5322. window.moduleRegistry.add('marketFilter', (configuration, localDatabase, events, components, elementWatcher, Promise, itemCache, dropCache, marketReader, elementCreator) => {
  5323.  
  5324.     const STORE_NAME = 'market-filters';
  5325.     const TYPE_TO_ITEM = {
  5326.         'Food': itemCache.byName['Health'].id,
  5327.         'Charcoal': itemCache.byName['Charcoal'].id,
  5328.         'Compost': itemCache.byName['Compost'].id,
  5329.         'Arcane Powder': itemCache.byName['Arcane Powder'].id,
  5330.         'Pet Snacks': itemCache.byName['Pet Snacks'].id,
  5331.     };
  5332.     let savedFilters = [];
  5333.     let enabled = false;
  5334.     let currentFilter = {
  5335.         type: 'None',
  5336.         amount: 0,
  5337.         key: 'SELL-None'
  5338.     };
  5339.     let pageInitialised = false;
  5340.     let listingsUpdatePromise = null;
  5341.  
  5342.     async function initialise() {
  5343.         configuration.registerCheckbox({
  5344.             category: 'Data',
  5345.             key: 'market-filter',
  5346.             name: 'Market filter',
  5347.             default: true,
  5348.             handler: handleConfigStateChange
  5349.         });
  5350.         events.register('page', update);
  5351.         events.register('state-market', update);
  5352.  
  5353.         savedFilters = await localDatabase.getAllEntries(STORE_NAME);
  5354.  
  5355.         // detect elements changing
  5356.  
  5357.         // clear filters when searching yourself
  5358.         $(document).on('click', 'market-listings-component .search > .clear-button', clearFilter);
  5359.         $(document).on('input', 'market-listings-component .search > input', clearFilter);
  5360.  
  5361.         // Buy tab -> trigger update
  5362.         $(document).on('click', 'market-listings-component .card > .tabs > :nth-child(1)', function() {
  5363.             showComponent();
  5364.             marketReader.trigger();
  5365.         });
  5366.         $(document).on('click', 'market-listings-component .card > .tabs > :nth-child(2)', function() {
  5367.             showComponent();
  5368.             marketReader.trigger();
  5369.         });
  5370.         $(document).on('click', 'market-listings-component .card > .tabs > :nth-child(3)', function() {
  5371.             hideComponent();
  5372.             marketReader.trigger();
  5373.         });
  5374.  
  5375.         elementCreator.addStyles(`
  5376.             .greenOutline {
  5377.                 outline: 2px solid rgb(83, 189, 115) !important;
  5378.             }
  5379.         `);
  5380.  
  5381.         // on save hover, highlight saved fields
  5382.         $(document).on('mouseenter mouseleave click', '.saveFilterHoverTrigger', function(e) {
  5383.             switch(e.type) {
  5384.                 case 'mouseenter':
  5385.                     if(currentFilter.type === 'None') {
  5386.                         return $('.saveFilterHover.search').addClass('greenOutline');
  5387.                     }
  5388.                     return $('.saveFilterHover:not(.search)').addClass('greenOutline');
  5389.                 case 'mouseleave':
  5390.                 case 'click':
  5391.                     return $('.saveFilterHover').removeClass('greenOutline');
  5392.             }
  5393.         });
  5394.     }
  5395.  
  5396.     function handleConfigStateChange(state) {
  5397.         enabled = state;
  5398.     }
  5399.  
  5400.     function update() {
  5401.         if(!enabled) {
  5402.             return;
  5403.         }
  5404.         if(events.getLast('page')?.type !== 'market') {
  5405.             pageInitialised = false;
  5406.             return;
  5407.         }
  5408.         initialisePage();
  5409.         $('market-listings-component .search').addClass('saveFilterHover');
  5410.         syncListingsView();
  5411.     }
  5412.  
  5413.     async function initialisePage() {
  5414.         if(pageInitialised) {
  5415.             return;
  5416.         }
  5417.         clearFilter();
  5418.         try {
  5419.             await elementWatcher.childAddedContinuous('market-listings-component .card', () => {
  5420.                 if(listingsUpdatePromise) {
  5421.                     listingsUpdatePromise.resolve();
  5422.                     listingsUpdatePromise = null;
  5423.                 }
  5424.             });
  5425.             pageInitialised = true;
  5426.         } catch(error) {
  5427.             console.warn(`Could probably not detect the market listing component, cause : ${error}`);
  5428.         }
  5429.     }
  5430.  
  5431.     async function clearFilter() {
  5432.         await applyFilter({
  5433.             type: 'None',
  5434.             amount: 0
  5435.         });
  5436.         syncCustomView();
  5437.     }
  5438.  
  5439.     async function applyFilter(filter) {
  5440.         Object.assign(currentFilter, {search:null}, filter);
  5441.         currentFilter.key = `${currentFilter.listingType}-${currentFilter.type}`;
  5442.         if(currentFilter.type && currentFilter.type !== 'None') {
  5443.             await clearSearch();
  5444.         }
  5445.         syncListingsView();
  5446.     }
  5447.  
  5448.     async function clearSearch() {
  5449.         if(!$('market-listings-component .search > input').val()) {
  5450.             return;
  5451.         }
  5452.         listingsUpdatePromise = new Promise.Expiring(5000, 'marketFilter - clearSearch');
  5453.         setSearch('');
  5454.         await listingsUpdatePromise;
  5455.         marketReader.trigger();
  5456.     }
  5457.  
  5458.     function setSearch(value) {
  5459.         const searchReference = $('market-listings-component .search > input');
  5460.         searchReference.val(value);
  5461.         searchReference[0].dispatchEvent(new Event('input'));
  5462.     }
  5463.  
  5464.     async function saveFilter() {
  5465.         let filter = structuredClone(currentFilter);
  5466.         if(currentFilter.type === 'None') {
  5467.             filter.search = $('market-listings-component .search > input').val();
  5468.             if(!filter.search) {
  5469.                 return;
  5470.             }
  5471.         }
  5472.         if(filter.search) {
  5473.             filter.key = `SEARCH-${filter.search}`;
  5474.         } else {
  5475.             filter.key = `${filter.type}-${filter.amount}`;
  5476.         }
  5477.         if(!savedFilters.find(a => a.key === filter.key)) {
  5478.             localDatabase.saveEntry(STORE_NAME, filter);
  5479.             savedFilters.push(filter);
  5480.         }
  5481.         componentBlueprint.selectedTabIndex = 0;
  5482.         syncCustomView();
  5483.     }
  5484.  
  5485.     async function removeFilter(filter) {
  5486.         localDatabase.removeEntry(STORE_NAME, filter.key);
  5487.         savedFilters = savedFilters.filter(a => a.key !== filter.key);
  5488.         syncCustomView();
  5489.     }
  5490.  
  5491.     function syncListingsView() {
  5492.         const marketData = events.getLast('state-market');
  5493.         if(!marketData) {
  5494.             return;
  5495.         }
  5496.         // do nothing on own listings tab
  5497.         if(marketData.lastType === 'OWN') {
  5498.             resetListingsView(marketData);
  5499.             return;
  5500.         }
  5501.         // search
  5502.         if(currentFilter.search) {
  5503.             resetListingsView(marketData);
  5504.             setSearch(currentFilter.search);
  5505.             return;
  5506.         }
  5507.         // no type
  5508.         if(currentFilter.type === 'None') {
  5509.             resetListingsView(marketData);
  5510.             return;
  5511.         }
  5512.         // type
  5513.         const itemId = TYPE_TO_ITEM[currentFilter.type];
  5514.         const conversionsByItem = dropCache.conversionMappings[itemId].reduce((a,b) => (a[b.from] = b, a), {});
  5515.         let matchingListings = marketData.last.filter(listing => listing.item in conversionsByItem);
  5516.         for(const listing of matchingListings) {
  5517.             listing.ratio = listing.price / conversionsByItem[listing.item].amount;
  5518.         }
  5519.         matchingListings.sort((a,b) => (a.type === 'BUY' ? 1 : -1) * (b.ratio - a.ratio));
  5520.         if(currentFilter.amount) {
  5521.             matchingListings = matchingListings.slice(0, currentFilter.amount);
  5522.         }
  5523.         for(const listing of marketData.last) {
  5524.             if(matchingListings.includes(listing)) {
  5525.                 listing.element.show();
  5526.                 if(!listing.element.find('.ratio').length) {
  5527.                     listing.element.find('.amount').after(`<div class='ratio'>(${listing.ratio.toFixed(2)})</div>`);
  5528.                 }
  5529.             } else {
  5530.                 listing.element.hide();
  5531.             }
  5532.         }
  5533.     }
  5534.  
  5535.     function resetListingsView(marketData) {
  5536.         for(const element of marketData.last.map(a => a.element)) {
  5537.             element.find('.ratio').remove();
  5538.             element.show();
  5539.         }
  5540.     }
  5541.  
  5542.     function syncCustomView() {
  5543.         for(const option of components.search(componentBlueprint, 'filterDropdown').options) {
  5544.             option.selected = option.value === currentFilter.type;
  5545.         }
  5546.         components.search(componentBlueprint, 'amountInput').value = currentFilter.amount;
  5547.         components.search(componentBlueprint, 'savedFiltersTab').hidden = !savedFilters.length;
  5548.         if(!savedFilters.length) {
  5549.             componentBlueprint.selectedTabIndex = 1;
  5550.         }
  5551.         const savedFiltersSegment = components.search(componentBlueprint, 'savedFiltersSegment');
  5552.         savedFiltersSegment.rows = [];
  5553.         for(const savedFilter of savedFilters) {
  5554.             let text = `Type : ${savedFilter.type}`;
  5555.             if(savedFilter.amount) {
  5556.                 text = `Type : ${savedFilter.amount} x ${savedFilter.type}`;
  5557.             }
  5558.             if(savedFilter.search) {
  5559.                 text = `Search : ${savedFilter.search}`;
  5560.             }
  5561.             savedFiltersSegment.rows.push({
  5562.                 type: 'buttons',
  5563.                 buttons: [{
  5564.                     text: text,
  5565.                     size: 3,
  5566.                     color: 'primary',
  5567.                     action: async function() {
  5568.                         await applyFilter(savedFilter);
  5569.                         syncCustomView();
  5570.                     }
  5571.                 },{
  5572.                     text: 'Remove',
  5573.                     color: 'danger',
  5574.                     action: removeFilter.bind(null,savedFilter)
  5575.                 }]
  5576.             });
  5577.         }
  5578.         showComponent();
  5579.     }
  5580.  
  5581.     function hideComponent() {
  5582.         components.removeComponent(componentBlueprint);
  5583.     }
  5584.  
  5585.     function showComponent() {
  5586.         componentBlueprint.prepend = screen.width < 750;
  5587.         components.addComponent(componentBlueprint);
  5588.     }
  5589.  
  5590.     const componentBlueprint = {
  5591.         componentId : 'marketFilterComponent',
  5592.         dependsOn: 'market-page',
  5593.         parent : 'market-listings-component > .groups > :last-child',
  5594.         prepend: false,
  5595.         selectedTabIndex : 0,
  5596.         tabs : [{
  5597.             id: 'savedFiltersTab',
  5598.             title : 'Saved filters',
  5599.             hidden: true,
  5600.             rows: [{
  5601.                 type: 'segment',
  5602.                 id: 'savedFiltersSegment',
  5603.                 rows: []
  5604.             }, {
  5605.                 type: 'buttons',
  5606.                 buttons: [{
  5607.                     text: 'Clear filter',
  5608.                     color: 'warning',
  5609.                     action: async function() {
  5610.                         await clearFilter();
  5611.                         await clearSearch();
  5612.                     }
  5613.                 }]
  5614.             }]
  5615.         }, {
  5616.             title : 'Filter',
  5617.             rows: [{
  5618.                 type: 'dropdown',
  5619.                 id: 'filterDropdown',
  5620.                 action: type => applyFilter({type}),
  5621.                 class: 'saveFilterHover',
  5622.                 options: [{
  5623.                     text: 'None',
  5624.                     value: 'None',
  5625.                     selected: false
  5626.                 }].concat(Object.keys(TYPE_TO_ITEM).map(a => ({
  5627.                     text: a,
  5628.                     value: a,
  5629.                     selected: false
  5630.                 })))
  5631.             }, {
  5632.                 type: 'input',
  5633.                 id: 'amountInput',
  5634.                 name: 'Amount',
  5635.                 value: '',
  5636.                 inputType: 'number',
  5637.                 action: amount => applyFilter({amount:+amount}),
  5638.                 class: 'saveFilterHover'
  5639.             }, {
  5640.                 type: 'buttons',
  5641.                 buttons: [{
  5642.                     text: 'Save filter',
  5643.                     action: saveFilter,
  5644.                     color: 'success',
  5645.                     class: 'saveFilterHoverTrigger'
  5646.                 }]
  5647.             }, {
  5648.                 type: 'buttons',
  5649.                 buttons: [{
  5650.                     text: 'Clear filter',
  5651.                     color: 'warning',
  5652.                     action: async function() {
  5653.                         await clearFilter();
  5654.                         await clearSearch();
  5655.                     }
  5656.                 }]
  5657.             }]
  5658.         }]
  5659.     };
  5660.  
  5661.     initialise();
  5662.  
  5663. }
  5664. );
  5665. // petHighlighter
  5666. window.moduleRegistry.add('petHighlighter', (events) => {
  5667.  
  5668.     const exports = {
  5669.         highlight
  5670.     };
  5671.  
  5672.     let currentColor = null;
  5673.     let currentNames = null;
  5674.  
  5675.     function initialise() {
  5676.         events.register('page', update);
  5677.         events.register('state-pet', update);
  5678.     }
  5679.  
  5680.     function highlight(color, names) {
  5681.         currentColor = color;
  5682.         currentNames = names;
  5683.     }
  5684.  
  5685.     function update() {
  5686.         if(!currentColor || !currentNames || !currentNames.length) {
  5687.             return;
  5688.         }
  5689.         const page = events.getLast('page');
  5690.         if(page?.type === 'taming' && page.menu === 'pets') {
  5691.             events.getLast('state-pet')
  5692.                 .filter(pet => currentNames.includes(pet.name) && pet.element)
  5693.                 .forEach(pet => {
  5694.                     $(pet.element).css('box-shadow', `inset 0px 0px 8px 0px ${currentColor}`)
  5695.                 });
  5696.         }
  5697.     }
  5698.  
  5699.     initialise();
  5700.  
  5701.     return exports;
  5702.  
  5703. }
  5704. );
  5705. // petRenamer
  5706. window.moduleRegistry.add('petRenamer', (configuration, events, petUtil, elementCreator, toast) => {
  5707.  
  5708.     let enabled = false;
  5709.     let lastSeenPet;
  5710.     let pasteButton;
  5711.  
  5712.     function initialise() {
  5713.         configuration.registerCheckbox({
  5714.             category: 'Pets',
  5715.             key: 'pet-rename',
  5716.             name: 'Name suggestions',
  5717.             default: false,
  5718.             handler: handleConfigStateChange
  5719.         });
  5720.         events.register('reader-pet', handlePetReader);
  5721.         $(document).on('click', 'modal-component .header .heading', onRename);
  5722.         pasteButton = elementCreator.getButton('Paste encoded name', pasteName);
  5723.     }
  5724.  
  5725.     function handleConfigStateChange(state, name) {
  5726.         enabled = state;
  5727.     }
  5728.  
  5729.     function handlePetReader(event) {
  5730.         if(event.type === 'single') {
  5731.             lastSeenPet = event.value;
  5732.         }
  5733.     }
  5734.  
  5735.     function onRename() {
  5736.         if(!enabled) {
  5737.             return;
  5738.         }
  5739.         const page = events.getLast('page');
  5740.         if(!page || page.type !== 'taming') {
  5741.             return;
  5742.         }
  5743.         $('modal-component .header > .name').append(pasteButton);
  5744.     }
  5745.  
  5746.     function pasteName() {
  5747.         const text = petUtil.petToText(lastSeenPet);
  5748.         const input = $('modal-component input');
  5749.         input.val(text);
  5750.         input[0].dispatchEvent(new Event('input'));
  5751.         toast.create({
  5752.             text: 'Pasted encoded name',
  5753.             image: 'https://img.icons8.com/?size=48&id=22244'
  5754.         });
  5755.     }
  5756.  
  5757.     initialise();
  5758.  
  5759. });
  5760. // petStatHighlighter
  5761. window.moduleRegistry.add('petStatHighlighter', (configuration, events, util, colorMapper, petCache, petPassiveCache, petUtil) => {
  5762.  
  5763.     let enabled = false;
  5764.     const stats = petUtil.STATS_BASE;
  5765.     const passiveStats = util.distinct(petPassiveCache.list.map(a => a.stats.name));
  5766.     let highestValues = null;
  5767.  
  5768.     function initialise() {
  5769.         configuration.registerCheckbox({
  5770.             category: 'Pets',
  5771.             key: 'pet-stat-highlighter',
  5772.             name: 'Highlight best stats [needs stat redesign]',
  5773.             default: false,
  5774.             handler: handleConfigStateChange
  5775.         });
  5776.         events.register('redesign-pet', renderMain);
  5777.         events.register('reader-pet', renderSingle);
  5778.     }
  5779.  
  5780.     function handleConfigStateChange(state, name) {
  5781.         enabled = state;
  5782.     }
  5783.  
  5784.     function renderMain(pets) {
  5785.         if(!enabled || !pets.length) {
  5786.             return;
  5787.         }
  5788.         highestValues = getHighestValuesByFamily(pets);
  5789.         const color = colorMapper('success');
  5790.         for(const pet of pets) {
  5791.             const tags = $(pet.element).find('.tags');
  5792.             highlight(pet, color, tags);
  5793.         }
  5794.     }
  5795.  
  5796.     function renderSingle(event) {
  5797.         if(!enabled || event.type !== 'single') {
  5798.             return;
  5799.         }
  5800.         const pets = events.getLast('redesign-pet').slice(0);
  5801.         pets.push(event.value);
  5802.         highestValues = getHighestValuesByFamily(pets);
  5803.         const color = colorMapper('success');
  5804.         highlight(event.value, color, $(event.modal));
  5805.     }
  5806.  
  5807.     function highlight(pet, color, root) {
  5808.         for(const stat of stats) {
  5809.             if(pet[stat] === highestValues[pet.family][stat]) {
  5810.                 root.find(`.stat-${stat}`).css('box-shadow', `inset 0px 0px 8px 0px ${color}`);
  5811.             } else {
  5812.                 root.find(`.stat-${stat}`).css('box-shadow', '');
  5813.             }
  5814.         }
  5815.         for(const id of pet.passives) {
  5816.             const passive = petPassiveCache.byId[id].stats;
  5817.             if(passive.value === highestValues[pet.family][passive.name]) {
  5818.                 root.find(`.passive-${passive.name}`).css('box-shadow', `inset 0px 0px 8px 0px ${color}`);
  5819.             } else {
  5820.                 root.find(`.passive-${passive.name}`).css('box-shadow', '');
  5821.             }
  5822.         }
  5823.     }
  5824.  
  5825.     function getHighestValuesByFamily(pets) {
  5826.         const result = {};
  5827.         for(const pet of pets) {
  5828.             pet.family = petCache.byId[pet.species].family;
  5829.         }
  5830.         const families = util.distinct(pets.map(pet => pet.family));
  5831.         for(const family of families) {
  5832.             result[family] = {};
  5833.             for(const stat of stats) {
  5834.                 result[family][stat] = pets
  5835.                     .filter(pet => pet.family === family)
  5836.                     .map(pet => pet[stat])
  5837.                     .sort((a,b) => b-a)[0] || 0;
  5838.             }
  5839.             for(const stat of passiveStats) {
  5840.                 result[family][stat] = pets
  5841.                     .filter(pet => pet.family === family)
  5842.                     .flatMap(pet => pet.passives)
  5843.                     .map(id => petPassiveCache.byId[id])
  5844.                     .filter(passive => passive.stats.name === stat)
  5845.                     .map(passive => passive.stats.value)
  5846.                     .sort((a,b) => b-a)[0] || 0;
  5847.             }
  5848.         }
  5849.         return result;
  5850.     }
  5851.  
  5852.     initialise();
  5853.  
  5854. }
  5855. );
  5856. // petStatRedesign
  5857. window.moduleRegistry.add('petStatRedesign', (configuration, events, elementCreator, petTraitCache, petPassiveCache, colorMapper, petUtil) => {
  5858.  
  5859.     let enabled = false;
  5860.     const emitEvent = events.emit.bind(null, 'redesign-pet');
  5861.  
  5862.     function initialise() {
  5863.         configuration.registerCheckbox({
  5864.             category: 'Pets',
  5865.             key: 'pet-stat-redesign',
  5866.             name: 'Stat redesign',
  5867.             default: true,
  5868.             handler: handleConfigStateChange
  5869.         });
  5870.         events.register('state-pet', update);
  5871.     }
  5872.  
  5873.     function handleConfigStateChange(state, name) {
  5874.         enabled = state;
  5875.     }
  5876.  
  5877.     function update(state) {
  5878.         if(!enabled) {
  5879.             return;
  5880.         }
  5881.         let changed = false;
  5882.         for(const pet of state.filter(pet => pet.default)) {
  5883.             renderDefault(pet);
  5884.         }
  5885.         for(const pet of state.filter(pet => !pet.default && pet.duplicate)) {
  5886.             renderDuplicate(pet);
  5887.         }
  5888.         const pets = state.filter(pet => !pet.default && !pet.duplicate && pet.parsed);
  5889.         for(const pet of pets) {
  5890.             if(renderParsed(pet)) {
  5891.                 changed = true;
  5892.             }
  5893.         }
  5894.         if(changed) {
  5895.             emitEvent(pets);
  5896.         }
  5897.     }
  5898.  
  5899.     function renderDefault(pet) {
  5900.         const tags = $(pet.element).find('.tags');
  5901.         if(tags.find('.tag-default').length) {
  5902.             return false;
  5903.         }
  5904.         const color = colorMapper('warning');
  5905.         const tag = elementCreator.getTag('Default name', undefined, 'tag-default')
  5906.             .css('box-shadow', `inset 0px 0px 8px 0px ${color}`);
  5907.         tags.append(tag);
  5908.         return true;
  5909.     }
  5910.  
  5911.     function renderDuplicate(pet) {
  5912.         const tags = $(pet.element).find('.tags');
  5913.         if(tags.find('.tag-duplicate').length) {
  5914.             return false;
  5915.         }
  5916.         const color = colorMapper('warning');
  5917.         const tag = elementCreator.getTag('Duplicate name', undefined, 'tag-duplicate')
  5918.             .css('box-shadow', `inset 0px 0px 8px 0px ${color}`);
  5919.         tags.append(tag);
  5920.         return true;
  5921.     }
  5922.  
  5923.     function renderParsed(pet) {
  5924.         const tags = $(pet.element).find('.tags');
  5925.         if(tags.find('.stat-health').length) {
  5926.             return false;
  5927.         }
  5928.         tags.empty();
  5929.         const table = $(`<div style='display:inline-grid;grid-template-rows:1fr 1fr;grid-auto-flow:column'></div>`);
  5930.         tags.append(table);
  5931.         // traits
  5932.         const traits = petTraitCache.byId[pet.traits];
  5933.         if(traits.attack) {
  5934.             table.append(elementCreator.getTag('', petUtil.IMAGES.attack));
  5935.         }
  5936.         if(traits.specialAttack) {
  5937.             table.append(elementCreator.getTag('', petUtil.IMAGES.specialAttack));
  5938.         }
  5939.         if(traits.defense) {
  5940.             table.append(elementCreator.getTag('', petUtil.IMAGES.defense));
  5941.         }
  5942.         if(traits.specialDefense) {
  5943.             table.append(elementCreator.getTag('', petUtil.IMAGES.specialDefense));
  5944.         }
  5945.         // spacing
  5946.         table.append(`<div style='padding:5px'></div>`);
  5947.         table.append(`<div style='padding:5px'></div>`);
  5948.         // stats
  5949.         table.append(elementCreator.getTag(`${pet.health}%`, petUtil.IMAGES.health, 'stat-health'));
  5950.         table.append(elementCreator.getTag(`${pet.speed}%`, petUtil.IMAGES.speed, 'stat-speed'));
  5951.         table.append(elementCreator.getTag(`${pet.attack}%`, petUtil.IMAGES.attack, 'stat-attack'));
  5952.         table.append(elementCreator.getTag(`${pet.specialAttack}%`, petUtil.IMAGES.specialAttack, 'stat-specialAttack'));
  5953.         table.append(elementCreator.getTag(`${pet.defense}%`, petUtil.IMAGES.defense, 'stat-defense'));
  5954.         table.append(elementCreator.getTag(`${pet.specialDefense}%`, petUtil.IMAGES.specialDefense, 'stat-specialDefense'));
  5955.         // spacing
  5956.         table.append(`<div style='padding:5px'></div>`);
  5957.         table.append(`<div style='padding:5px'></div>`);
  5958.         // passives
  5959.         for(const id of pet.passives) {
  5960.             const passive = petPassiveCache.byId[id];
  5961.             table.append(elementCreator.getTag(passive.name, null, `passive-${passive.stats.name}`));
  5962.         }
  5963.         return true;
  5964.     }
  5965.  
  5966.     function render(pet) {
  5967.         if(!pet.parsed && !pet.duplicate) {
  5968.             return;
  5969.         }
  5970.         if(pet.duplicate || pet.default) {
  5971.             return false;
  5972.         }
  5973.         const tags = $(pet.element).find('.tags');
  5974.         if(tags.find('.stat-health').length) {
  5975.             return false;
  5976.         }
  5977.         tags.empty();
  5978.         const table = $(`<div style='display:inline-grid;grid-template-rows:1fr 1fr;grid-auto-flow:column'></div>`);
  5979.         tags.append(table);
  5980.         if(!pet.parsed) {
  5981.             return;
  5982.         }
  5983.         // traits
  5984.         const traits = petTraitCache.byId[pet.traits];
  5985.         if(traits.hasAttack) {
  5986.             table.append(elementCreator.getTag('', petUtil.IMAGES.attack));
  5987.         }
  5988.         if(traits.hasSpecialAttack) {
  5989.             table.append(elementCreator.getTag('', petUtil.IMAGES.specialAttack));
  5990.         }
  5991.         if(traits.hasDefense) {
  5992.             table.append(elementCreator.getTag('', petUtil.IMAGES.defense));
  5993.         }
  5994.         if(traits.hasSpecialDefense) {
  5995.             table.append(elementCreator.getTag('', petUtil.IMAGES.specialDefense));
  5996.         }
  5997.         // spacing
  5998.         table.append(`<div style='padding:5px'></div>`);
  5999.         table.append(`<div style='padding:5px'></div>`);
  6000.         // stats
  6001.         table.append(elementCreator.getTag(`${pet.health}%`, petUtil.IMAGES.health, 'stat-health'));
  6002.         table.append(elementCreator.getTag(`${pet.speed}%`, petUtil.IMAGES.speed, 'stat-speed'));
  6003.         table.append(elementCreator.getTag(`${pet.attack}%`, petUtil.IMAGES.attack, 'stat-attack'));
  6004.         table.append(elementCreator.getTag(`${pet.specialAttack}%`, petUtil.IMAGES.specialAttack, 'stat-specialAttack'));
  6005.         table.append(elementCreator.getTag(`${pet.defense}%`, petUtil.IMAGES.defense, 'stat-defense'));
  6006.         table.append(elementCreator.getTag(`${pet.specialDefense}%`, petUtil.IMAGES.specialDefense, 'stat-specialDefense'));
  6007.         // spacing
  6008.         table.append(`<div style='padding:5px'></div>`);
  6009.         table.append(`<div style='padding:5px'></div>`);
  6010.         // passives
  6011.         for(const id of pet.passives) {
  6012.             const passive = petPassiveCache.byId[id];
  6013.             table.append(elementCreator.getTag(passive.name, null, `passive-${passive.stats.name}`));
  6014.         }
  6015.         return true;
  6016.     }
  6017.  
  6018.     initialise();
  6019.  
  6020. });
  6021. // recipeClickthrough
  6022. window.moduleRegistry.add('recipeClickthrough', (recipeCache, configuration, util) => {
  6023.  
  6024.     let enabled = false;
  6025.  
  6026.     function initialise() {
  6027.         configuration.registerCheckbox({
  6028.             category: 'UI Features',
  6029.             key: 'recipe-click',
  6030.             name: 'Recipe clickthrough',
  6031.             default: true,
  6032.             handler: handleConfigStateChange
  6033.         });
  6034.         $(document).on('click', 'div.image > img', handleClick);
  6035.     }
  6036.  
  6037.     function handleConfigStateChange(state) {
  6038.         enabled = state;
  6039.     }
  6040.  
  6041.     function handleClick(event) {
  6042.         if(!enabled) {
  6043.             return;
  6044.         }
  6045.         if($(event.currentTarget).closest('button').length) {
  6046.             return;
  6047.         }
  6048.         event.stopPropagation();
  6049.         const name = $(event.relatedTarget).find('.name').text();
  6050.         const nameMatch = recipeCache.byName[name];
  6051.         if(nameMatch) {
  6052.             return followRecipe(nameMatch);
  6053.         }
  6054.  
  6055.         const parts = event.target.src.split('/');
  6056.         const lastPart = parts[parts.length-1];
  6057.         const imageMatch = recipeCache.byImage[lastPart];
  6058.         if(imageMatch) {
  6059.             return followRecipe(imageMatch);
  6060.         }
  6061.     }
  6062.  
  6063.     function followRecipe(recipe) {
  6064.         util.goToPage(recipe.url);
  6065.     }
  6066.  
  6067.     initialise();
  6068.  
  6069. }
  6070. );
  6071. // syncTracker
  6072. window.moduleRegistry.add('syncTracker', (events, localDatabase, pages, components, util, toast, elementWatcher, debugService) => {
  6073.  
  6074.     const STORE_NAME = 'sync-tracking';
  6075.     const PAGE_NAME = 'Sync State';
  6076.     const TOAST_SUCCESS_TIME = 1000*60*5; // 5 minutes
  6077.     const TOAST_WARN_TIME = 1000*60*60*24*3; // 3 days
  6078.     const TOAST_REWARN_TIME = 1000*60*60*4; // 4 hours
  6079.  
  6080.     const sources = {
  6081.         inventory: {
  6082.             name: 'Inventory',
  6083.             event: 'reader-inventory',
  6084.             page: 'inventory'
  6085.         },
  6086.         'equipment-equipment': {
  6087.             name: 'Equipment',
  6088.             event: 'reader-equipment-equipment',
  6089.             page: 'equipment'
  6090.         },
  6091.         'equipment-runes': {
  6092.             name: 'Runes',
  6093.             event: 'reader-equipment-runes',
  6094.             page: 'equipment',
  6095.             element: 'equipment-page .categories button:contains("Runes")'
  6096.         },
  6097.         'equipment-tomes': {
  6098.             name: 'Tomes',
  6099.             event: 'reader-equipment-tomes',
  6100.             page: 'equipment',
  6101.             element: 'equipment-page .categories button:contains("Tomes")'
  6102.         },
  6103.         structures: {
  6104.             name: 'Buildings',
  6105.             event: 'reader-structures',
  6106.             page: 'house/build/2'
  6107.         },
  6108.         enhancements: {
  6109.             name: 'Building enhancements',
  6110.             event: 'reader-enhancements',
  6111.             page: 'house/enhance/2'
  6112.         },
  6113.         'structures-guild': {
  6114.             name: 'Guild buildings',
  6115.             event: 'reader-structures-guild',
  6116.             page: 'guild',
  6117.             element: 'guild-page button:contains("Buildings")'
  6118.         }
  6119.     };
  6120.  
  6121.     let autoVisiting = false;
  6122.  
  6123.     async function initialise() {
  6124.         await loadSavedData();
  6125.         for(const key of Object.keys(sources)) {
  6126.             events.register(sources[key].event, handleReader.bind(null, key));
  6127.         }
  6128.         await pages.register({
  6129.             category: 'Misc',
  6130.             name: PAGE_NAME,
  6131.             image: 'https://img.icons8.com/?size=48&id=1ODJ62iG96gX&format=png',
  6132.             columns: '3',
  6133.             render: renderPage
  6134.         });
  6135.         pages.show(PAGE_NAME);
  6136.         setInterval(update, 1000);
  6137.     }
  6138.  
  6139.     async function loadSavedData() {
  6140.         const entries = await localDatabase.getAllEntries(STORE_NAME);
  6141.         for(const entry of entries) {
  6142.             if(!sources[entry.key]) {
  6143.                 continue;
  6144.             }
  6145.             sources[entry.key].lastSeen = entry.value.time;
  6146.             events.emit(`reader-${entry.key}`, {
  6147.                 type: 'cache',
  6148.                 value: entry.value.value
  6149.             });
  6150.         }
  6151.     }
  6152.  
  6153.     function handleReader(key, event) {
  6154.         if(event.type !== 'full') {
  6155.             return;
  6156.         }
  6157.         const time = Date.now();
  6158.         let newData = false;
  6159.         if(!sources[key].lastSeen || sources[key].lastSeen + TOAST_SUCCESS_TIME < time) {
  6160.             newData = true;
  6161.         }
  6162.         sources[key].lastSeen = time;
  6163.         sources[key].notified = false;
  6164.         localDatabase.saveEntry(STORE_NAME, {
  6165.             key: key,
  6166.             value: {
  6167.                 time,
  6168.                 value: event.value
  6169.             }
  6170.         });
  6171.         if(newData) {
  6172.             toast.create({
  6173.                 text: `${sources[key].name} synced`,
  6174.                 image: 'https://img.icons8.com/?size=48&id=1ODJ62iG96gX&format=png'
  6175.             });
  6176.             if(autoVisiting) {
  6177.                 triggerAutoVisitor();
  6178.             }
  6179.         }
  6180.     }
  6181.  
  6182.     function update() {
  6183.         pages.requestRender(PAGE_NAME);
  6184.         const time = Date.now();
  6185.         for(const source of Object.values(sources)) {
  6186.             if(source.lastSeen && source.lastSeen + TOAST_WARN_TIME >= time) {
  6187.                 continue;
  6188.             }
  6189.             if(source.notified && source.notified + TOAST_REWARN_TIME >= time) {
  6190.                 continue;
  6191.             }
  6192.             toast.create({
  6193.                 text: `${source.name} needs a sync`,
  6194.                 image: 'https://img.icons8.com/?size=48&id=1ODJ62iG96gX&format=png',
  6195.                 time: 5000
  6196.             });
  6197.             source.notified = time;
  6198.         }
  6199.     }
  6200.  
  6201.     async function visit(source) {
  6202.         if(!source.page) {
  6203.             return;
  6204.         }
  6205.         util.goToPage(source.page);
  6206.         if(source.element) {
  6207.             await elementWatcher.exists(source.element);
  6208.             $(source.element).click();
  6209.         }
  6210.     }
  6211.  
  6212.     function startAutoVisiting() {
  6213.         autoVisiting = true;
  6214.         triggerAutoVisitor();
  6215.     }
  6216.  
  6217.     const stopAutoVisiting = util.debounce(function() {
  6218.         autoVisiting = false;
  6219.         pages.open(PAGE_NAME);
  6220.         toast.create({
  6221.             text: `Auto sync finished`,
  6222.             image: 'https://img.icons8.com/?size=48&id=1ODJ62iG96gX&format=png'
  6223.         });
  6224.     }, 1500);
  6225.  
  6226.     function triggerAutoVisitor() {
  6227.         try {
  6228.             const time = Date.now();
  6229.             for(const source of Object.values(sources)) {
  6230.                 let secondsAgo = (time - source.lastSeen) / 1000;
  6231.                 if(source.page && (!source.lastSeen || secondsAgo >= 60*60)) {
  6232.                     visit(source);
  6233.                     return;
  6234.                 }
  6235.             }
  6236.         } finally {
  6237.             stopAutoVisiting();
  6238.         }
  6239.     }
  6240.  
  6241.     function renderPage() {
  6242.         components.addComponent(autoVisitBlueprint);
  6243.         const header = components.search(sourceBlueprint, 'header');
  6244.         const item = components.search(sourceBlueprint, 'item');
  6245.         const buttons = components.search(sourceBlueprint, 'buttons');
  6246.         const time = Date.now();
  6247.         for(const source of Object.values(sources)) {
  6248.             sourceBlueprint.componentId = `syncTrackerSourceComponent_${source.name}`;
  6249.             header.title = source.name;
  6250.             let secondsAgo = (time - source.lastSeen) / 1000;
  6251.             if(!secondsAgo) {
  6252.                 secondsAgo = Number.MAX_VALUE;
  6253.             }
  6254.             item.value = util.secondsToDuration(secondsAgo);
  6255.             buttons.hidden = secondsAgo < 60*60;
  6256.             buttons.buttons[0].action = visit.bind(null, source);
  6257.             components.addComponent(sourceBlueprint);
  6258.         }
  6259.     }
  6260.  
  6261.     const autoVisitBlueprint = {
  6262.         componentId: 'syncTrackerAutoVisitComponent',
  6263.         dependsOn: 'custom-page',
  6264.         parent: '.column0',
  6265.         selectedTabIndex: 0,
  6266.         tabs: [
  6267.             {
  6268.                 rows: [
  6269.                     {
  6270.                         type: 'buttons',
  6271.                         buttons: [
  6272.                             {
  6273.                                 text: 'Auto sync',
  6274.                                 color: 'primary',
  6275.                                 action: startAutoVisiting
  6276.                             }
  6277.                         ]
  6278.                     },
  6279.                     {
  6280.                         type: 'buttons',
  6281.                         buttons: [
  6282.                             {
  6283.                                 text: 'Submit debug info',
  6284.                                 color: 'primary',
  6285.                                 action: debugService.submit
  6286.                             }
  6287.                         ]
  6288.                     }
  6289.                 ]
  6290.             }
  6291.         ]
  6292.     };
  6293.  
  6294.     const sourceBlueprint = {
  6295.         componentId: 'syncTrackerSourceComponent',
  6296.         dependsOn: 'custom-page',
  6297.         parent: '.column0',
  6298.         selectedTabIndex: 0,
  6299.         tabs: [
  6300.             {
  6301.                 rows: [
  6302.                     {
  6303.                         type: 'header',
  6304.                         id: 'header',
  6305.                         title: '',
  6306.                         centered: true
  6307.                     }, {
  6308.                         type: 'item',
  6309.                         id: 'item',
  6310.                         name: 'Last detected',
  6311.                         value: ''
  6312.                     }, {
  6313.                         type: 'buttons',
  6314.                         id: 'buttons',
  6315.                         buttons: [
  6316.                             {
  6317.                                 text: 'Visit',
  6318.                                 color: 'danger',
  6319.                                 action: undefined
  6320.                             }
  6321.                         ]
  6322.                     }
  6323.                 ]
  6324.             },
  6325.         ]
  6326.     };
  6327.  
  6328.     initialise();
  6329.  
  6330. }
  6331. );
  6332. // ui
  6333. window.moduleRegistry.add('ui', (configuration) => {
  6334.  
  6335.     const id = crypto.randomUUID();
  6336.     const sections = [
  6337.         'challenges-page',
  6338.         'changelog-page',
  6339.         'daily-quest-page',
  6340.         'equipment-page',
  6341.         'guild-page',
  6342.         'home-page',
  6343.         'leaderboards-page',
  6344.         'market-page',
  6345.         'merchant-page',
  6346.         'quests-page',
  6347.         'settings-page',
  6348.         'skill-page',
  6349.         'upgrade-page',
  6350.         'taming-page'
  6351.     ].join(', ');
  6352.     const selector = `:is(${sections})`;
  6353.  
  6354.     function initialise() {
  6355.         configuration.registerCheckbox({
  6356.             category: 'UI Features',
  6357.             key: 'ui-changes',
  6358.             name: 'UI changes',
  6359.             default: true,
  6360.             handler: handleConfigStateChange
  6361.         });
  6362.     }
  6363.  
  6364.     function handleConfigStateChange(state) {
  6365.         if(state) {
  6366.             add();
  6367.         } else {
  6368.             remove();
  6369.         }
  6370.     }
  6371.  
  6372.     function add() {
  6373.         document.documentElement.style.setProperty('--gap', '8px');
  6374.         const element = $(`
  6375.             <style>
  6376.                 ${selector} :not(.multi-row) > :is(
  6377.                     button.item,
  6378.                     button.row,
  6379.                     button.socket-button,
  6380.                     button.level-button,
  6381.                     div.item,
  6382.                     div.row
  6383.                 ) {
  6384.                     padding: 2px 6px !important;
  6385.                     min-height: 0 !important;
  6386.                 }
  6387.  
  6388.                 ${selector} :not(.multi-row) > :is(
  6389.                     button.item div.image,
  6390.                     button.row div.image,
  6391.                     div.item div.image,
  6392.                     div.item div.placeholder-image,
  6393.                     div.row div.image
  6394.                 ) {
  6395.                     height: 32px !important;
  6396.                     width: 32px !important;
  6397.                     min-height: 0 !important;
  6398.                     min-width: 0 !important;
  6399.                 }
  6400.  
  6401.                 ${selector} div.lock {
  6402.                     height: unset !important;
  6403.                     padding: 0 !important;
  6404.                 }
  6405.  
  6406.                 action-component div.body >  div.image,
  6407.                 produce-component div.body > div.image,
  6408.                 daily-quest-page div.body > div.image {
  6409.                     height: 48px !important;
  6410.                     width: 48px !important;
  6411.                 }
  6412.  
  6413.                 div.progress div.body {
  6414.                     padding: 8px !important;
  6415.                 }
  6416.  
  6417.                 action-component div.bars {
  6418.                     padding: 0 !important;
  6419.                 }
  6420.  
  6421.                 equipment-component button {
  6422.                     padding: 0 !important;
  6423.                 }
  6424.  
  6425.                 inventory-page .items {
  6426.                     grid-gap: 0 !important;
  6427.                 }
  6428.  
  6429.                 div.scroll.custom-scrollbar .header,
  6430.                 div.scroll.custom-scrollbar button {
  6431.                     height: 28px !important;
  6432.                 }
  6433.  
  6434.                 div.scroll.custom-scrollbar img {
  6435.                     height: 16px !important;
  6436.                     width: 16px !important;
  6437.                 }
  6438.  
  6439.                 .scroll {
  6440.                     overflow-y: auto !important;
  6441.                 }
  6442.                 .scroll {
  6443.                     -ms-overflow-style: none;  /* Internet Explorer 10+ */
  6444.                     scrollbar-width: none;  /* Firefox */
  6445.                 }
  6446.                 .scroll::-webkit-scrollbar {
  6447.                     display: none;  /* Safari and Chrome */
  6448.                 }
  6449.             </style>
  6450.         `).attr('id', id);
  6451.         window.$('head').append(element);
  6452.     }
  6453.  
  6454.     function remove() {
  6455.         document.documentElement.style.removeProperty('--gap');
  6456.         $(`#${id}`).remove();
  6457.     }
  6458.  
  6459.     initialise();
  6460.  
  6461. }
  6462. );
  6463. // versionWarning
  6464. window.moduleRegistry.add('versionWarning', (request, toast) => {
  6465.  
  6466.     function initialise() {
  6467.         setInterval(run, 1000 * 60 * 5);
  6468.         run();
  6469.     }
  6470.  
  6471.     async function run() {
  6472.         const version = await request.getVersion();
  6473.         if(!window.PANCAKE_VERSION || version === window.PANCAKE_VERSION) {
  6474.             return;
  6475.         }
  6476.         toast.create({
  6477.             text: `<a href='https://greasyfork.org/en/scripts/475356-ironwood-rpg-pancake-scripts' target='_blank'>Consider updating Pancake-Scripts to ${version}!<br>Click here to go to GreasyFork</a`,
  6478.             image: 'https://img.icons8.com/?size=48&id=iAqIpjeFjcYz&format=png',
  6479.             time: 5000
  6480.         });
  6481.     }
  6482.  
  6483.     initialise();
  6484.  
  6485. }
  6486. );
  6487. // abstractStateStore
  6488. window.moduleRegistry.add('abstractStateStore', (events, util) => {
  6489.  
  6490.     const SOURCES = [
  6491.         'inventory',
  6492.         'equipment-runes',
  6493.         'equipment-tomes',
  6494.         'structures',
  6495.         'enhancements',
  6496.         'structures-guild'
  6497.     ];
  6498.  
  6499.     const stateBySource = {};
  6500.  
  6501.     function initialise() {
  6502.         for(const source of SOURCES) {
  6503.             stateBySource[source] = {};
  6504.             events.register(`reader-${source}`, handleReader.bind(null, source));
  6505.         }
  6506.     }
  6507.  
  6508.     function handleReader(source, event) {
  6509.         let updated = false;
  6510.         if(event.type === 'full' || event.type === 'cache') {
  6511.             if(util.compareObjects(stateBySource[source], event.value)) {
  6512.                 return;
  6513.             }
  6514.             updated = true;
  6515.             stateBySource[source] = event.value;
  6516.         }
  6517.         if(event.type === 'partial') {
  6518.             for(const key of Object.keys(event.value)) {
  6519.                 if(stateBySource[source][key] === event.value[key]) {
  6520.                     continue;
  6521.                 }
  6522.                 updated = true;
  6523.                 stateBySource[source][key] = event.value[key];
  6524.             }
  6525.         }
  6526.         if(updated) {
  6527.             events.emit(`state-${source}`, stateBySource[source]);
  6528.         }
  6529.     }
  6530.  
  6531.     initialise();
  6532.  
  6533. }
  6534. );
  6535. // configurationStore
  6536. window.moduleRegistry.add('configurationStore', (Promise, localConfigurationStore, _remoteConfigurationStore) =>  {
  6537.  
  6538.     const initialised = new Promise.Expiring(2000, 'configurationStore');
  6539.     let configs = null;
  6540.  
  6541.     const exports = {
  6542.         save,
  6543.         getConfigs
  6544.     };
  6545.  
  6546.     const configurationStore = _remoteConfigurationStore || localConfigurationStore;
  6547.  
  6548.     async function initialise() {
  6549.         configs = await configurationStore.load();
  6550.         for(const key in configs) {
  6551.             configs[key] = JSON.parse(configs[key]);
  6552.         }
  6553.         initialised.resolve(exports);
  6554.     }
  6555.  
  6556.     async function save(key, value) {
  6557.         await configurationStore.save(key, value);
  6558.         configs[key] = value;
  6559.     }
  6560.  
  6561.     function getConfigs() {
  6562.         return configs;
  6563.     }
  6564.  
  6565.     initialise();
  6566.  
  6567.     return initialised;
  6568.  
  6569. }
  6570. );
  6571. // equipmentStateStore
  6572. window.moduleRegistry.add('equipmentStateStore', (events, util, itemCache) => {
  6573.  
  6574.     let state = {};
  6575.  
  6576.     function initialise() {
  6577.         events.register('reader-equipment-equipment', handleEquipmentReader);
  6578.     }
  6579.  
  6580.     function handleEquipmentReader(event) {
  6581.         let updated = false;
  6582.         if(event.type === 'full' || event.type === 'cache') {
  6583.             if(util.compareObjects(state, event.value)) {
  6584.                 return;
  6585.             }
  6586.             updated = true;
  6587.             state = event.value;
  6588.         }
  6589.         if(event.type === 'partial') {
  6590.             for(const key of Object.keys(event.value)) {
  6591.                 if(state[key] === event.value[key]) {
  6592.                     continue;
  6593.                 }
  6594.                 updated = true;
  6595.                 // remove items of similar type
  6596.                 for(const itemType in itemCache.specialIds) {
  6597.                     if(Array.isArray(itemCache.specialIds[itemType]) && itemCache.specialIds[itemType].includes(+key)) {
  6598.                         for(const itemId of itemCache.specialIds[itemType]) {
  6599.                             delete state[itemId];
  6600.                         }
  6601.                     }
  6602.                 }
  6603.                 state[key] = event.value[key];
  6604.             }
  6605.         }
  6606.         if(updated) {
  6607.             events.emit('state-equipment-equipment', state);
  6608.         }
  6609.     }
  6610.  
  6611.     initialise();
  6612.  
  6613. }
  6614. );
  6615. // expStateStore
  6616. window.moduleRegistry.add('expStateStore', (events, util) => {
  6617.  
  6618.     const emitEvent = events.emit.bind(null, 'state-exp');
  6619.     const state = {};
  6620.  
  6621.     function initialise() {
  6622.         events.register('reader-exp', handleExpReader);
  6623.     }
  6624.  
  6625.     function handleExpReader(event) {
  6626.         let updated = false;
  6627.         for(const skill of event) {
  6628.             if(!state[skill.id]) {
  6629.                 state[skill.id] = {
  6630.                     id: skill.id,
  6631.                     exp: 0,
  6632.                     level: 1
  6633.                 };
  6634.             }
  6635.             if(skill.exp > state[skill.id].exp) {
  6636.                 updated = true;
  6637.                 state[skill.id].exp = skill.exp;
  6638.                 state[skill.id].level = util.expToLevel(skill.exp);
  6639.             }
  6640.         }
  6641.         if(updated) {
  6642.             emitEvent(state);
  6643.         }
  6644.     }
  6645.  
  6646.     initialise();
  6647.  
  6648. }
  6649. );
  6650. // localConfigurationStore
  6651. window.moduleRegistry.add('localConfigurationStore', (localDatabase) => {
  6652.  
  6653.     const exports = {
  6654.         load,
  6655.         save
  6656.     };
  6657.  
  6658.     const STORE_NAME = 'settings';
  6659.  
  6660.     async function load() {
  6661.         const entries = await localDatabase.getAllEntries(STORE_NAME);
  6662.         const configurations = {};
  6663.         for(const entry of entries) {
  6664.             configurations[entry.key] = entry.value;
  6665.         }
  6666.         return configurations;
  6667.     }
  6668.  
  6669.     async function save(key, value) {
  6670.         await localDatabase.saveEntry(STORE_NAME, {key, value});
  6671.     }
  6672.  
  6673.     return exports;
  6674.  
  6675. }
  6676. );
  6677. // marketStore
  6678. window.moduleRegistry.add('marketStore', (events) => {
  6679.  
  6680.     const emitEvent = events.emit.bind(null, 'state-market');
  6681.     let state = {};
  6682.  
  6683.     function initialise() {
  6684.         events.register('page', handlePage);
  6685.         events.register('reader-market', handleMarketReader);
  6686.     }
  6687.  
  6688.     function handlePage(event) {
  6689.         if(event.type == 'market') {
  6690.             state = {};
  6691.         }
  6692.     }
  6693.  
  6694.     function handleMarketReader(event) {
  6695.         state[event.type] = event.listings;
  6696.         state.lastType = event.type;
  6697.         state.last = event.listings;
  6698.         emitEvent(state);
  6699.     }
  6700.  
  6701.     initialise();
  6702.  
  6703. }
  6704. );
  6705. // petStateStore
  6706. window.moduleRegistry.add('petStateStore', (events, petUtil, util, localDatabase, petCache) => {
  6707.  
  6708.     const STORE_NAME = 'various';
  6709.     const KEY_NAME = 'pets';
  6710.     let state = [];
  6711.  
  6712.     async function initialise() {
  6713.         await loadSavedData();
  6714.         events.register('page', handlePage);
  6715.         events.register('reader-pet', handlePetReader);
  6716.     }
  6717.  
  6718.     async function loadSavedData() {
  6719.         const entries = await localDatabase.getAllEntries(STORE_NAME);
  6720.         const entry = entries.find(entry => entry.key === KEY_NAME);
  6721.         if(entry) {
  6722.             state = entry.value;
  6723.         }
  6724.     }
  6725.  
  6726.     function handlePage(page) {
  6727.         if(page.type === 'taming' && page.menu === 'pets') {
  6728.             emitEvent(state);
  6729.         }
  6730.     }
  6731.  
  6732.     function handlePetReader(event) {
  6733.         let updated = false;
  6734.         if(event.type === 'list') {
  6735.             const duplicateNames = new Set(util.getDuplicates(event.value.map(a => a.name)));
  6736.             const defaultNames = new Set(petCache.list.map(a => a.name));
  6737.             const newState = event.value.map(pet => {
  6738.                 pet.duplicate = duplicateNames.has(pet.name);
  6739.                 pet.default = defaultNames.has(pet.name);
  6740.                 if(pet.duplicate || pet.default) {
  6741.                     return pet;
  6742.                 }
  6743.                 const match = find(pet);
  6744.                 if(match) {
  6745.                     delete pet.parsed;
  6746.                     Object.assign(match, pet);
  6747.                     return match;
  6748.                 }
  6749.                 updated = true;
  6750.                 if(petUtil.isEncodedPetName(pet.name)) {
  6751.                     Object.assign(pet, petUtil.textToPet(pet.name));
  6752.                 }
  6753.                 return pet;
  6754.             });
  6755.             if(state.length !== newState.length) {
  6756.                 updated = true;
  6757.             }
  6758.             state = newState;
  6759.         } else if(event.type === 'single') {
  6760.             const match = find(event.value);
  6761.             if(match && !match.duplicate && !match.default && !match.parsed) {
  6762.                 Object.assign(match, event.value);
  6763.                 updated = true;
  6764.             }
  6765.         }
  6766.         if(updated) {
  6767.             emitEvent(state);
  6768.         }
  6769.     }
  6770.  
  6771.     function find(pet) {
  6772.         return state.find(pet2 => pet2.name === pet.name);
  6773.     }
  6774.  
  6775.     async function emitEvent(state) {
  6776.         const savedState = state.map(pet => Object.assign({}, pet));
  6777.         for(const pet of savedState) {
  6778.             delete pet.element;
  6779.         }
  6780.         await localDatabase.saveEntry(STORE_NAME, {
  6781.             key: KEY_NAME,
  6782.             value: savedState
  6783.         });
  6784.         events.emit('state-pet', state);
  6785.     }
  6786.  
  6787.     initialise();
  6788.  
  6789. }
  6790. );
  6791. // statsStore
  6792. window.moduleRegistry.add('statsStore', (events, util, skillCache, itemCache, structuresCache, statNameCache) => {
  6793.  
  6794.     const emitEvent = events.emit.bind(null, 'state-stats');
  6795.  
  6796.     const exports = {
  6797.         get,
  6798.         getLevel,
  6799.         getInventoryItem,
  6800.         getEquipmentItem,
  6801.         getManyEquipmentItems,
  6802.         getWeapon,
  6803.         getAttackStyle,
  6804.         update
  6805.     };
  6806.  
  6807.     let exp = {};
  6808.     let inventory = {};
  6809.     let tomes = {};
  6810.     let equipment = {};
  6811.     let runes = {};
  6812.     let structures = {};
  6813.     let enhancements = {};
  6814.     let guildStructures = {};
  6815.     let various = {};
  6816.  
  6817.     let stats;
  6818.  
  6819.     function initialise() {
  6820.         let _update = util.debounce(update, 200);
  6821.         events.register('state-exp', event => (exp = event, _update()));
  6822.         events.register('state-inventory', event => (inventory = event, _update()));
  6823.         events.register('state-equipment-tomes', event => (tomes = event, _update()));
  6824.         events.register('state-equipment-equipment', event => (equipment = event, _update()));
  6825.         events.register('state-equipment-runes', event => (runes = event, _update()));
  6826.         events.register('state-structures', event => (structures = event, _update()));
  6827.         events.register('state-enhancements', event => (enhancements = event, _update()));
  6828.         events.register('state-structures-guild', event => (guildStructures = event, _update()));
  6829.         events.register('state-various', event => (various = event, _update()));
  6830.     }
  6831.  
  6832.     function get(stat, skill) {
  6833.         if(!stat) {
  6834.             return stats;
  6835.         }
  6836.         statNameCache.validate(stat);
  6837.         let value = 0;
  6838.         if(stats && stats.global[stat]) {
  6839.             value += stats.global[stat] || 0;
  6840.         }
  6841.         if(Number.isInteger(skill)) {
  6842.             skill = skillCache.byId[skill]?.technicalName;
  6843.         }
  6844.         if(stats && stats.bySkill[stat] && stats.bySkill[stat][skill]) {
  6845.             value += stats.bySkill[stat][skill];
  6846.         }
  6847.         return value;
  6848.     }
  6849.  
  6850.     function getLevel(skillId) {
  6851.         return exp[skillId] || {
  6852.             id: skillId,
  6853.             exp: 0,
  6854.             level: 1
  6855.         };
  6856.     }
  6857.  
  6858.     function getInventoryItem(itemId) {
  6859.         return inventory[itemId] || 0;
  6860.     }
  6861.  
  6862.     function getEquipmentItem(itemId) {
  6863.         return equipment[itemId] || tomes[itemId] || runes[itemId] || 0;
  6864.     }
  6865.  
  6866.     function getManyEquipmentItems(ids) {
  6867.         return ids.map(id => ({
  6868.             id,
  6869.             amount: getEquipmentItem(id)
  6870.         })).filter(a => a.amount);
  6871.     }
  6872.  
  6873.     function getWeapon() {
  6874.         return stats.weapon;
  6875.     }
  6876.  
  6877.     function getAttackStyle() {
  6878.         return stats.attackStyle;
  6879.     }
  6880.  
  6881.     function update(excludedItemIds) {
  6882.         reset();
  6883.         processExp();
  6884.         processTomes();
  6885.         processEquipment(excludedItemIds);
  6886.         processRunes();
  6887.         processStructures();
  6888.         processEnhancements();
  6889.         processGuildStructures();
  6890.         processVarious();
  6891.         cleanup();
  6892.         if(!excludedItemIds) {
  6893.             emitEvent(stats);
  6894.         }
  6895.     }
  6896.  
  6897.     function reset() {
  6898.         stats = {
  6899.             weapon: null,
  6900.             attackStyle: null,
  6901.             bySkill: {},
  6902.             global: {}
  6903.         };
  6904.     }
  6905.  
  6906.     function processExp() {
  6907.         for(const id in exp) {
  6908.             const skill = skillCache.byId[id];
  6909.             addStats({
  6910.                 bySkill: {
  6911.                     EFFICIENCY : {
  6912.                         [skill.technicalName]: 0.25
  6913.                     }
  6914.                 }
  6915.             }, exp[id].level, 4);
  6916.             if(skill.displayName === 'Ranged') {
  6917.                 addStats({
  6918.                     global: {
  6919.                         AMMO_PRESERVATION_CHANCE : 0.5
  6920.                     }
  6921.                 }, exp[id].level, 2);
  6922.             }
  6923.         }
  6924.     }
  6925.  
  6926.     // first tomes, then equipments
  6927.     // because we need to know the potion effect multiplier first
  6928.     function processTomes() {
  6929.         for(const id in tomes) {
  6930.             const item = itemCache.byId[id];
  6931.             if(!item) {
  6932.                 continue;
  6933.             }
  6934.             addStats(item.stats);
  6935.         }
  6936.     }
  6937.  
  6938.     function processEquipment(excludedItemIds) {
  6939.         let arrow;
  6940.         let bow;
  6941.         const potionMultiplier = get('INCREASED_POTION_EFFECT');
  6942.         for(const id in equipment) {
  6943.             if(equipment[id] <= 0) {
  6944.                 continue;
  6945.             }
  6946.             if(excludedItemIds && excludedItemIds.has(+id)) {
  6947.                 continue;
  6948.             }
  6949.             const item = itemCache.byId[id];
  6950.             if(!item) {
  6951.                 continue;
  6952.             }
  6953.             if(item.stats.global.ATTACK_SPEED) {
  6954.                 stats.weapon = item;
  6955.                 stats.attackStyle = item.skill;
  6956.             }
  6957.             if(item.name.endsWith('Arrow')) {
  6958.                 arrow = item;
  6959.                 addStats({
  6960.                     global: {
  6961.                         AMMO_PRESERVATION_CHANCE : -0.5
  6962.                     }
  6963.                 }, util.tierToLevel(item.tier), 2);
  6964.                 continue;
  6965.             }
  6966.             if(item.name.endsWith('Bow')) {
  6967.                 bow = item;
  6968.             }
  6969.             let multiplier = 1;
  6970.             let accuracy = 2;
  6971.             if(potionMultiplier && /(Potion|Mix)$/.exec(item.name)) {
  6972.                 multiplier = 1 + potionMultiplier / 100;
  6973.                 accuracy = 10;
  6974.             }
  6975.             if(item.name.endsWith('Rune')) {
  6976.                 multiplier = equipment[id];
  6977.                 accuracy = 10;
  6978.             }
  6979.             addStats(item.stats, multiplier, accuracy);
  6980.         }
  6981.         if(bow && arrow) {
  6982.             addStats(arrow.stats);
  6983.         }
  6984.     }
  6985.     function processRunes() {
  6986.         for(const id in runes) {
  6987.             const item = itemCache.byId[id];
  6988.             if(!item) {
  6989.                 continue;
  6990.             }
  6991.             addStats(item.stats, runes[id]);
  6992.         }
  6993.     }
  6994.  
  6995.     function processStructures() {
  6996.         for(const id in structures) {
  6997.             const structure = structuresCache.byId[id];
  6998.             if(!structure) {
  6999.                 continue;
  7000.             }
  7001.             addStats(structure.regular, structures[id] + 2/3);
  7002.         }
  7003.     }
  7004.  
  7005.     function processEnhancements() {
  7006.         for(const id in enhancements) {
  7007.             const structure = structuresCache.byId[id];
  7008.             if(!structure) {
  7009.                 continue;
  7010.             }
  7011.             addStats(structure.enhance, enhancements[id]);
  7012.         }
  7013.     }
  7014.  
  7015.     function processGuildStructures() {
  7016.         for(const id in guildStructures) {
  7017.             const structure = structuresCache.byId[id];
  7018.             if(!structure) {
  7019.                 continue;
  7020.             }
  7021.             addStats(structure.regular, guildStructures[id]);
  7022.         }
  7023.     }
  7024.  
  7025.     function processVarious() {
  7026.         if(various.maxAmount) {
  7027.             const stats = {
  7028.                 bySkill: {
  7029.                     MAX_AMOUNT: {}
  7030.                 }
  7031.             };
  7032.             for(const skillId in various.maxAmount) {
  7033.                 const skill = skillCache.byId[skillId];
  7034.                 if(various.maxAmount[skillId]) {
  7035.                     stats.bySkill.MAX_AMOUNT[skill.technicalName] = various.maxAmount[skillId];
  7036.                 }
  7037.             }
  7038.             addStats(stats);
  7039.         }
  7040.     }
  7041.  
  7042.     function cleanup() {
  7043.         // base
  7044.         addStats({
  7045.             global: {
  7046.                 HEALTH: 10,
  7047.                 AMMO_PRESERVATION_CHANCE : 65
  7048.             }
  7049.         });
  7050.         // fallback
  7051.         if(!stats.weapon) {
  7052.             stats.weapon = null;
  7053.             stats.attackStyle = '';
  7054.             stats.global.ATTACK_SPEED = 3;
  7055.         }
  7056.         // health percent
  7057.         const healthPercent = get('HEALTH_PERCENT');
  7058.         if(healthPercent) {
  7059.             const health = get('HEALTH');
  7060.             addStats({
  7061.                 global: {
  7062.                     HEALTH : Math.floor(healthPercent * health / 100)
  7063.                 }
  7064.             })
  7065.         }
  7066.         // damage percent
  7067.         const damagePercent = get('DAMAGE_PERCENT');
  7068.         if(damagePercent) {
  7069.             const damage = get('DAMAGE');
  7070.             addStats({
  7071.                 global: {
  7072.                     DAMAGE : Math.floor(damagePercent * damage / 100)
  7073.                 }
  7074.             })
  7075.         }
  7076.         // bonus level efficiency
  7077.         if(stats.bySkill['BONUS_LEVEL']) {
  7078.             for(const skill in stats.bySkill['BONUS_LEVEL']) {
  7079.                 addStats({
  7080.                     bySkill: {
  7081.                         EFFICIENCY: {
  7082.                             [skill]: 0.25
  7083.                         }
  7084.                     }
  7085.                 }, Math.round(stats.bySkill['BONUS_LEVEL'][skill]), 4);
  7086.             }
  7087.         }
  7088.         // clamping
  7089.         if(stats.global['AMMO_PRESERVATION_CHANCE'] < 65) {
  7090.             stats.global['AMMO_PRESERVATION_CHANCE'] = 65;
  7091.         }
  7092.         if(stats.global['AMMO_PRESERVATION_CHANCE'] > 80) {
  7093.             stats.global['AMMO_PRESERVATION_CHANCE'] = 80;
  7094.         }
  7095.     }
  7096.  
  7097.     function addStats(newStats, multiplier = 1, accuracy = 1) {
  7098.         if(newStats.global) {
  7099.             for(const stat in newStats.global) {
  7100.                 if(!stats.global[stat]) {
  7101.                     stats.global[stat] = 0;
  7102.                 }
  7103.                 stats.global[stat] += Math.round(accuracy * multiplier * newStats.global[stat]) / accuracy;
  7104.             }
  7105.         }
  7106.         if(newStats.bySkill) {
  7107.             for(const stat in newStats.bySkill) {
  7108.                 if(!stats.bySkill[stat]) {
  7109.                     stats.bySkill[stat] = {};
  7110.                 }
  7111.                 for(const skill in newStats.bySkill[stat]) {
  7112.                     if(!stats.bySkill[stat][skill]) {
  7113.                         stats.bySkill[stat][skill] = 0;
  7114.                     }
  7115.                     stats.bySkill[stat][skill] += Math.round(accuracy * multiplier * newStats.bySkill[stat][skill]) / accuracy;
  7116.                 }
  7117.             }
  7118.         }
  7119.     }
  7120.  
  7121.     initialise();
  7122.  
  7123.     return exports;
  7124.  
  7125. }
  7126. );
  7127. // variousStateStore
  7128. window.moduleRegistry.add('variousStateStore', (events, skillCache) => {
  7129.  
  7130.     const emitEvent = events.emit.bind(null, 'state-various');
  7131.     const state = {};
  7132.  
  7133.     function initialise() {
  7134.         events.register('reader-various', handleReader);
  7135.     }
  7136.  
  7137.     function handleReader(event) {
  7138.         const updated = merge(state, event);
  7139.         if(updated) {
  7140.             emitEvent(state);
  7141.         }
  7142.     }
  7143.  
  7144.     function merge(target, source) {
  7145.         let updated = false;
  7146.         for(const key in source) {
  7147.             if(!(key in target)) {
  7148.                 target[key] = source[key];
  7149.                 updated = true;
  7150.                 continue;
  7151.             }
  7152.             if(typeof target[key] === 'object' && typeof source[key] === 'object') {
  7153.                 updated |= merge(target[key], source[key]);
  7154.                 continue;
  7155.             }
  7156.             if(target[key] !== source[key]) {
  7157.                 target[key] = source[key];
  7158.                 updated = true;
  7159.                 continue;
  7160.             }
  7161.         }
  7162.         return updated;
  7163.     }
  7164.  
  7165.     initialise();
  7166.  
  7167. }
  7168. );
  7169. // actionCache
  7170. window.moduleRegistry.add('actionCache', (request, Promise) => {
  7171.  
  7172.     const initialised = new Promise.Expiring(2000, 'actionCache');
  7173.  
  7174.     const exports = {
  7175.         list: [],
  7176.         byId: {},
  7177.         byName: {}
  7178.     };
  7179.  
  7180.     async function tryInitialise() {
  7181.         try {
  7182.             await initialise();
  7183.             initialised.resolve(exports);
  7184.         } catch(e) {
  7185.             initialised.reject(e);
  7186.         }
  7187.     }
  7188.  
  7189.     async function initialise() {
  7190.         const actions = await request.listActions();
  7191.         for(const action of actions) {
  7192.             exports.list.push(action);
  7193.             exports.byId[action.id] = action;
  7194.             exports.byName[action.name] = action;
  7195.         }
  7196.     }
  7197.  
  7198.     tryInitialise();
  7199.  
  7200.     return initialised;
  7201.  
  7202. }
  7203. );
  7204. // dropCache
  7205. window.moduleRegistry.add('dropCache', (request, Promise, itemCache, actionCache, skillCache, ingredientCache) => {
  7206.  
  7207.     const initialised = new Promise.Expiring(2000, 'dropCache');
  7208.  
  7209.     const exports = {
  7210.         list: [],
  7211.         byAction: {},
  7212.         byItem: {},
  7213.         boneCarveMappings: null,
  7214.         lowerGatherMappings: null,
  7215.         conversionMappings: null
  7216.     };
  7217.  
  7218.     Object.defineProperty(Array.prototype, '_groupBy', {
  7219.         enumerable: false,
  7220.         value: function(selector) {
  7221.             return Object.values(this.reduce(function(rv, x) {
  7222.                 (rv[selector(x)] = rv[selector(x)] || []).push(x);
  7223.                 return rv;
  7224.             }, {}));
  7225.         }
  7226.     });
  7227.  
  7228.     Object.defineProperty(Array.prototype, '_distinct', {
  7229.         enumerable: false,
  7230.         value: function(selector) {
  7231.             return [...new Set(this)];
  7232.         }
  7233.     });
  7234.  
  7235.     async function tryInitialise() {
  7236.         try {
  7237.             await initialise();
  7238.             initialised.resolve(exports);
  7239.         } catch(e) {
  7240.             initialised.reject(e);
  7241.         }
  7242.     }
  7243.  
  7244.     async function initialise() {
  7245.         const drops = await request.listDrops();
  7246.         for(const drop of drops) {
  7247.             exports.list.push(drop);
  7248.             if(!exports.byAction[drop.action]) {
  7249.                 exports.byAction[drop.action] = [];
  7250.             }
  7251.             exports.byAction[drop.action].push(drop);
  7252.             if(!exports.byItem[drop.item]) {
  7253.                 exports.byItem[drop.item] = [];
  7254.             }
  7255.             exports.byItem[drop.item].push(drop);
  7256.         }
  7257.         extractBoneCarvings();
  7258.         extractLowerGathers();
  7259.         extractConversions();
  7260.     }
  7261.  
  7262.     // I'm sorry for what follows
  7263.     function extractBoneCarvings() {
  7264.         let name;
  7265.         exports.boneCarveMappings = exports.list
  7266.             // filtering
  7267.             .filter(drop => drop.type === 'GUARANTEED')
  7268.             .filter(drop => (name = itemCache.byId[drop.item].name, name.endsWith('Bone') || name.endsWith('Fang')))
  7269.             .filter(drop => actionCache.byId[drop.action].skill === 'Combat')
  7270.             // sort
  7271.             .sort((a,b) => actionCache.byId[a.action].level - actionCache.byId[b.action].level)
  7272.             // per level
  7273.             ._groupBy(drop => actionCache.byId[drop.action].level)
  7274.             .map(a => a[0].item)
  7275.             .map((item,i,all) => ({
  7276.                 from: item,
  7277.                 to: [].concat([all[i-1]]).concat([all[i-2]]).filter(a => a)
  7278.             }))
  7279.             .reduce((a,b) => (a[b.from] = b.to, a), {});
  7280.     }
  7281.  
  7282.     function extractLowerGathers() {
  7283.         exports.lowerGatherMappings = exports.list
  7284.             // filtering
  7285.             .filter(drop => drop.type === 'REGULAR')
  7286.             .filter(drop => skillCache.byName[actionCache.byId[drop.action].skill].type === 'Gathering')
  7287.             // sort
  7288.             .sort((a,b) => actionCache.byId[a.action].level - actionCache.byId[b.action].level)
  7289.             // per action, the highest chance drop
  7290.             ._groupBy(drop => drop.action)
  7291.             .map(a => a.reduce((a,b) => a.chance >= b.chance ? a : b))
  7292.             // per skill, and for farming,
  7293.             ._groupBy(drop => {
  7294.                 const action = actionCache.byId[drop.action];
  7295.                 let skill = action.skill
  7296.                 if(skill === 'Farming') {
  7297.                     // add flower or vegetable suffix
  7298.                     skill += `-${action.image.split('/')[1].split('-')[0]}`;
  7299.                 }
  7300.                 return skill;
  7301.             })
  7302.             .flatMap(a => a
  7303.                 ._groupBy(drop => actionCache.byId[drop.action].level)
  7304.                 .map(b => b.map(drop => drop.item)._distinct())
  7305.                 .flatMap((b,i,all) => b.map(item => ({
  7306.                     from: item,
  7307.                     to: [].concat(all[i-1]).concat(all[i-2]).filter(a => a)
  7308.                 })))
  7309.             )
  7310.             .reduce((a,b) => (a[b.from] = b.to, a), {});
  7311.     }
  7312.  
  7313.     function extractConversions() {
  7314.         exports.conversionMappings = exports.list
  7315.             .filter(a => actionCache.byId[a.action].type === 'CONVERSION')
  7316.             .map(drop => ({
  7317.                 from: ingredientCache.byAction[drop.action][0].item,
  7318.                 to: drop.item,
  7319.                 amount: drop.amount
  7320.             }))
  7321.             ._groupBy(a => a.to)
  7322.             .reduce((a,b) => (a[b[0].to] = b, a), {});
  7323.     }
  7324.  
  7325.     tryInitialise();
  7326.  
  7327.     return initialised;
  7328.  
  7329. }
  7330. );
  7331. // expeditionCache
  7332. window.moduleRegistry.add('expeditionCache', (request, Promise) => {
  7333.  
  7334.     const initialised = new Promise.Expiring(2000, 'expeditionCache');
  7335.  
  7336.     const exports = {
  7337.         list: [],
  7338.         byId: {},
  7339.         byName: {},
  7340.         byTier: {}
  7341.     };
  7342.  
  7343.     async function tryInitialise() {
  7344.         try {
  7345.             await initialise();
  7346.             initialised.resolve(exports);
  7347.         } catch(e) {
  7348.             initialised.reject(e);
  7349.         }
  7350.     }
  7351.  
  7352.     async function initialise() {
  7353.         const expeditions = await request.listExpeditions();
  7354.         for(const expedition of expeditions) {
  7355.             exports.list.push(expedition);
  7356.             exports.byId[expedition.id] = expedition;
  7357.             exports.byName[expedition.name] = expedition;
  7358.             exports.byTier[expedition.tier] = expedition;
  7359.         }
  7360.     }
  7361.  
  7362.     tryInitialise();
  7363.  
  7364.     return initialised;
  7365.  
  7366. }
  7367. );
  7368. // expeditionDropCache
  7369. window.moduleRegistry.add('expeditionDropCache', (request, Promise) => {
  7370.  
  7371.     const initialised = new Promise.Expiring(2000, 'expeditionDropCache');
  7372.  
  7373.     const exports = {
  7374.         list: [],
  7375.         byExpedition: {},
  7376.         byItem: {}
  7377.     };
  7378.  
  7379.     async function tryInitialise() {
  7380.         try {
  7381.             await initialise();
  7382.             initialised.resolve(exports);
  7383.         } catch(e) {
  7384.             initialised.reject(e);
  7385.         }
  7386.     }
  7387.  
  7388.     async function initialise() {
  7389.         const drops = await request.listExpeditionDrops();
  7390.         for(const drop of drops) {
  7391.             exports.list.push(drop);
  7392.             if(!exports.byExpedition[drop.expedition]) {
  7393.                 exports.byExpedition[drop.expedition] = [];
  7394.             }
  7395.             exports.byExpedition[drop.expedition].push(drop);
  7396.             if(!exports.byItem[drop.item]) {
  7397.                 exports.byItem[drop.item] = [];
  7398.             }
  7399.             exports.byItem[drop.item].push(drop);
  7400.         }
  7401.     }
  7402.  
  7403.     tryInitialise();
  7404.  
  7405.     return initialised;
  7406.  
  7407. }
  7408. );
  7409. // ingredientCache
  7410. window.moduleRegistry.add('ingredientCache', (request, Promise) => {
  7411.  
  7412.     const initialised = new Promise.Expiring(2000, 'ingredientCache');
  7413.  
  7414.     const exports = {
  7415.         list: [],
  7416.         byAction: {},
  7417.         byItem: {}
  7418.     };
  7419.  
  7420.     async function tryInitialise() {
  7421.         try {
  7422.             await initialise();
  7423.             initialised.resolve(exports);
  7424.         } catch(e) {
  7425.             initialised.reject(e);
  7426.         }
  7427.     }
  7428.  
  7429.     async function initialise() {
  7430.         const ingredients = await request.listIngredients();
  7431.         for(const ingredient of ingredients) {
  7432.             if(!exports.byAction[ingredient.action]) {
  7433.                 exports.byAction[ingredient.action] = [];
  7434.             }
  7435.             exports.byAction[ingredient.action].push(ingredient);
  7436.             if(!exports.byItem[ingredient.item]) {
  7437.                 exports.byItem[ingredient.item] = [];
  7438.             }
  7439.             exports.byItem[ingredient.item].push(ingredient);
  7440.         }
  7441.     }
  7442.  
  7443.     tryInitialise();
  7444.  
  7445.     return initialised;
  7446.  
  7447. }
  7448. );
  7449. // itemCache
  7450. window.moduleRegistry.add('itemCache', (request, Promise) => {
  7451.  
  7452.     const initialised = new Promise.Expiring(2000, 'itemCache');
  7453.  
  7454.     const exports = {
  7455.         list: [],
  7456.         byId: {},
  7457.         byName: {},
  7458.         byImage: {},
  7459.         attributes: null,
  7460.         specialIds: {
  7461.             coins: null,
  7462.             mainHand: null,
  7463.             offHand: null,
  7464.             helmet: null,
  7465.             body: null,
  7466.             gloves: null,
  7467.             boots: null,
  7468.             amulet: null,
  7469.             ring: null,
  7470.             bracelet: null,
  7471.             hatchet: null,
  7472.             pickaxe: null,
  7473.             spade: null,
  7474.             rod: null,
  7475.             dagger: null,
  7476.             telescope: null,
  7477.             lantern: null,
  7478.             food: null,
  7479.             ammo: null,
  7480.             gatheringPotion: null,
  7481.             craftingPotion: null,
  7482.             combatPotion: null,
  7483.             dungeonMap: null,
  7484.             woodcuttingRune: null,
  7485.             miningRune: null,
  7486.             farmingRune: null,
  7487.             fishingRune: null,
  7488.             gatheringRune: null,
  7489.             oneHandedRune: null,
  7490.             twoHandedRune: null,
  7491.             rangedRune: null,
  7492.             defenseRune: null,
  7493.             utilityRune: null,
  7494.             savageLootingTome: null,
  7495.             bountifulHarvestTome: null,
  7496.             opulentCraftingTome: null,
  7497.             eternalLifeTome: null,
  7498.             insatiablePowerTome: null,
  7499.             potentConcoctionTome: null,
  7500.         }
  7501.     };
  7502.  
  7503.     async function tryInitialise() {
  7504.         try {
  7505.             await initialise();
  7506.             initialised.resolve(exports);
  7507.         } catch(e) {
  7508.             initialised.reject(e);
  7509.         }
  7510.     }
  7511.  
  7512.     async function initialise() {
  7513.         const enrichedItems = await request.listItems();
  7514.         for(const enrichedItem of enrichedItems) {
  7515.             const item = Object.assign(enrichedItem.item, enrichedItem);
  7516.             delete item.item;
  7517.             exports.list.push(item);
  7518.             exports.byId[item.id] = item;
  7519.             exports.byName[item.name] = item;
  7520.             const lastPart = item.image.split('/').at(-1);
  7521.             if(exports.byImage[lastPart]) {
  7522.                 exports.byImage[lastPart].duplicate = true;
  7523.             } else {
  7524.                 exports.byImage[lastPart] = item;
  7525.             }
  7526.             if(!item.attributes) {
  7527.                 item.attributes = {};
  7528.             }
  7529.             if(item.charcoal) {
  7530.                 item.attributes.CHARCOAL = item.charcoal;
  7531.             }
  7532.             if(item.compost) {
  7533.                 item.attributes.COMPOST = item.compost;
  7534.             }
  7535.             if(item.arcanePowder) {
  7536.                 item.attributes.ARCANE_POWDER = item.arcanePowder;
  7537.             }
  7538.             if(item.petSnacks) {
  7539.                 item.attributes.PET_SNACKS = item.petSnacks;
  7540.             }
  7541.             if(item.attributes.ATTACK_SPEED) {
  7542.                 item.attributes.ATTACK_SPEED /= 2;
  7543.             }
  7544.             for(const stat in item.stats.bySkill) {
  7545.                 if(item.stats.bySkill[stat].All) {
  7546.                     item.stats.global[stat] = item.stats.bySkill[stat].All;
  7547.                     delete item.stats.bySkill[stat].All;
  7548.                     if(!Object.keys(item.stats.bySkill[stat]).length) {
  7549.                         delete item.stats.bySkill[stat];
  7550.                     }
  7551.                 }
  7552.             }
  7553.         }
  7554.         for(const image of Object.keys(exports.byImage)) {
  7555.             if(exports.byImage[image].duplicate) {
  7556.                 delete exports.byImage[image];
  7557.             }
  7558.         }
  7559.         exports.attributes = await request.listItemAttributes();
  7560.         exports.attributes.push({
  7561.             technicalName: 'CHARCOAL',
  7562.             name: 'Charcoal',
  7563.             image: '/assets/items/charcoal.png'
  7564.         },{
  7565.             technicalName: 'COMPOST',
  7566.             name: 'Compost',
  7567.             image: '/assets/misc/compost.png'
  7568.         },{
  7569.             technicalName: 'ARCANE_POWDER',
  7570.             name: 'Arcane Powder',
  7571.             image: '/assets/misc/arcane-powder.png'
  7572.         },{
  7573.             technicalName: 'PET_SNACKS',
  7574.             name: 'Pet Snacks',
  7575.             image: '/assets/misc/pet-snacks.png'
  7576.         });
  7577.         const potions = exports.list.filter(a => /(Potion|Mix)$/.exec(a.name));
  7578.         // we do not cover any event items
  7579.         exports.specialIds.coins = exports.byName['Coins'].id;
  7580.         exports.specialIds.mainHand = getAllIdsEnding('Sword', 'Hammer', 'Spear', 'Scythe', 'Bow', 'Boomerang');
  7581.         exports.specialIds.offHand = getAllIdsEnding('Shield');
  7582.         exports.specialIds.helmet = getAllIdsEnding('Helmet');
  7583.         exports.specialIds.body = getAllIdsEnding('Body');
  7584.         exports.specialIds.gloves = getAllIdsEnding('Gloves');
  7585.         exports.specialIds.boots = getAllIdsEnding('Boots');
  7586.         exports.specialIds.amulet = getAllIdsEnding('Amulet');
  7587.         exports.specialIds.ring = getAllIdsEnding('Ring');
  7588.         exports.specialIds.bracelet = getAllIdsEnding('Bracelet');
  7589.         exports.specialIds.hatchet = getAllIdsEnding('Hatchet');
  7590.         exports.specialIds.pickaxe = getAllIdsEnding('Pickaxe');
  7591.         exports.specialIds.spade = getAllIdsEnding('Spade');
  7592.         exports.specialIds.rod = getAllIdsEnding('Rod');
  7593.         exports.specialIds.dagger = getAllIdsEnding('Dagger');
  7594.         exports.specialIds.telescope = getAllIdsEnding('Telescope');
  7595.         exports.specialIds.lantern = getAllIdsEnding('Lantern');
  7596.         exports.specialIds.food = exports.list.filter(a => a.stats.global.HEAL).map(a => a.id);
  7597.         exports.specialIds.ammo = getAllIdsEnding('Arrow');
  7598.         exports.specialIds.gatheringPotion = potions.filter(a => a.name.includes('Gather')).map(a => a.id);
  7599.         exports.specialIds.craftingPotion = potions.filter(a => a.name.includes('Craft') || a.name.includes('Preservation')).map(a => a.id);
  7600.         exports.specialIds.combatPotion = potions.filter(a => !a.name.includes('Gather') && !a.name.includes('Craft') && !a.name.includes('Preservation')).map(a => a.id);
  7601.         exports.specialIds.dungeonMap = getAllIdsStarting('Dungeon Map');
  7602.         exports.specialIds.woodcuttingRune = getAllIdsEnding('Woodcutting Rune');
  7603.         exports.specialIds.miningRune = getAllIdsEnding('Mining Rune');
  7604.         exports.specialIds.farmingRune = getAllIdsEnding('Farming Rune');
  7605.         exports.specialIds.fishingRune = getAllIdsEnding('Fishing Rune');
  7606.         exports.specialIds.gatheringRune = [
  7607.             ...exports.specialIds.woodcuttingRune,
  7608.             ...exports.specialIds.miningRune,
  7609.             ...exports.specialIds.farmingRune,
  7610.             ...exports.specialIds.fishingRune
  7611.         ];
  7612.         exports.specialIds.oneHandedRune = getAllIdsEnding('One-handed Rune');
  7613.         exports.specialIds.twoHandedRune = getAllIdsEnding('Two-handed Rune');
  7614.         exports.specialIds.rangedRune = getAllIdsEnding('Ranged Rune');
  7615.         exports.specialIds.defenseRune = getAllIdsEnding('Defense Rune');
  7616.         exports.specialIds.utilityRune = getAllIdsEnding('Crit Rune', 'Damage Rune', 'Block Rune', 'Stun Rune', 'Bleed Rune', 'Parry Rune');
  7617.         exports.specialIds.savageLootingTome = getAllIdsStarting('Savage Looting Tome');
  7618.         exports.specialIds.bountifulHarvestTome = getAllIdsStarting('Bountiful Harvest Tome');
  7619.         exports.specialIds.opulentCraftingTome = getAllIdsStarting('Opulent Crafting Tome');
  7620.         exports.specialIds.eternalLifeTome = getAllIdsStarting('Eternal Life Tome');
  7621.         exports.specialIds.insatiablePowerTome = getAllIdsStarting('Insatiable Power Tome');
  7622.         exports.specialIds.potentConcoctionTome = getAllIdsStarting('Potent Concoction Tome');
  7623.     }
  7624.  
  7625.     function getAllIdsEnding() {
  7626.         const suffixes = Array.prototype.slice.call(arguments);
  7627.         return exports.list.filter(a => new RegExp(`(${suffixes.join('|')})$`).exec(a.name)).map(a => a.id);
  7628.     }
  7629.  
  7630.     function getAllIdsStarting() {
  7631.         const prefixes = Array.prototype.slice.call(arguments);
  7632.         return exports.list.filter(a => new RegExp(`^(${prefixes.join('|')})`).exec(a.name)).map(a => a.id);
  7633.     }
  7634.  
  7635.     tryInitialise();
  7636.  
  7637.     return initialised;
  7638.  
  7639. }
  7640. );
  7641. // monsterCache
  7642. window.moduleRegistry.add('monsterCache', (request, Promise) => {
  7643.  
  7644.     const initialised = new Promise.Expiring(2000, 'monsterCache');
  7645.  
  7646.     const exports = {
  7647.         list: [],
  7648.         byId: {},
  7649.         byName: {}
  7650.     };
  7651.  
  7652.     async function tryInitialise() {
  7653.         try {
  7654.             await initialise();
  7655.             initialised.resolve(exports);
  7656.         } catch(e) {
  7657.             initialised.reject(e);
  7658.         }
  7659.     }
  7660.  
  7661.     async function initialise() {
  7662.         const monsters = await request.listMonsters();
  7663.         for(const monster of monsters) {
  7664.             exports.list.push(monster);
  7665.             exports.byId[monster.id] = monster;
  7666.             exports.byName[monster.name] = monster;
  7667.         }
  7668.     }
  7669.  
  7670.     tryInitialise();
  7671.  
  7672.     return initialised;
  7673.  
  7674. }
  7675. );
  7676. // petCache
  7677. window.moduleRegistry.add('petCache', (request, Promise) => {
  7678.  
  7679.     const initialised = new Promise.Expiring(2000, 'petCache');
  7680.  
  7681.     const exports = {
  7682.         list: [],
  7683.         byId: {},
  7684.         byName: {},
  7685.         byImage: {},
  7686.         idToIndex: {}
  7687.     };
  7688.  
  7689.     async function tryInitialise() {
  7690.         try {
  7691.             await initialise();
  7692.             initialised.resolve(exports);
  7693.         } catch(e) {
  7694.             initialised.reject(e);
  7695.         }
  7696.     }
  7697.  
  7698.     async function initialise() {
  7699.         const pets = await request.listPets();
  7700.         for(const pet of pets) {
  7701.             exports.list.push(pet);
  7702.             exports.byId[pet.id] = pet;
  7703.             exports.byName[pet.name] = pet;
  7704.             exports.idToIndex[pet.id] = exports.list.length-1;
  7705.             const lastPart = pet.image.split('/').at(-1);
  7706.             exports.byImage[lastPart] = pet;
  7707.             pet.abilities = [{
  7708.                 [pet.abilityName1]: pet.abilityValue1
  7709.             }];
  7710.             if(pet.abilityName2) {
  7711.                 pet.abilities.push({
  7712.                     [pet.abilityName2]: pet.abilityValue2
  7713.                 });
  7714.             }
  7715.             delete pet.abilityName1;
  7716.             delete pet.abilityValue1;
  7717.             delete pet.abilityName2;
  7718.             delete pet.abilityValue2;
  7719.         }
  7720.     }
  7721.  
  7722.     tryInitialise();
  7723.  
  7724.     return initialised;
  7725.  
  7726. }
  7727. );
  7728. // petPassiveCache
  7729. window.moduleRegistry.add('petPassiveCache', (request, Promise) => {
  7730.  
  7731.     const initialised = new Promise.Expiring(2000, 'petPassiveCache');
  7732.  
  7733.     const exports = {
  7734.         list: [],
  7735.         byId: {},
  7736.         byName: {},
  7737.         idToIndex: {}
  7738.     };
  7739.  
  7740.     async function tryInitialise() {
  7741.         try {
  7742.             await initialise();
  7743.             initialised.resolve(exports);
  7744.         } catch(e) {
  7745.             initialised.reject(e);
  7746.         }
  7747.     }
  7748.  
  7749.     async function initialise() {
  7750.         const petPassives = await request.listPetPassives();
  7751.         for(const petPassive of petPassives) {
  7752.             exports.list.push(petPassive);
  7753.             exports.byId[petPassive.id] = petPassive;
  7754.             exports.byName[petPassive.name] = petPassive;
  7755.             exports.idToIndex[petPassive.id] = exports.list.length-1;
  7756.             petPassive.stats = {
  7757.                 name: petPassive.statName,
  7758.                 value: petPassive.statValue
  7759.             };
  7760.             delete petPassive.statName;
  7761.             delete petPassive.statValue;
  7762.         }
  7763.     }
  7764.  
  7765.     tryInitialise();
  7766.  
  7767.     return initialised;
  7768.  
  7769. }
  7770. );
  7771. // petTraitCache
  7772. window.moduleRegistry.add('petTraitCache', () => {
  7773.  
  7774.     const exports = {
  7775.         list: [],
  7776.         byId: {},
  7777.         byName: {},
  7778.         idToIndex: {}
  7779.     };
  7780.  
  7781.     function initialise() {
  7782.         const traits = ['Attack & Defense', 'Attack & Special Def', 'Special Atk & Defense', 'Special Atk & Special Def'];
  7783.         for(const trait of traits) {
  7784.             const value = {
  7785.                 id: exports.list.length,
  7786.                 name: trait,
  7787.                 attack: trait.startsWith('Attack'),
  7788.                 defense: trait.endsWith('Defense'),
  7789.                 specialAttack: trait.startsWith('Special Atk'),
  7790.                 specialDefense: trait.endsWith('Special Def')
  7791.             };
  7792.             exports.list.push(value);
  7793.             exports.byId[value.id] = value;
  7794.             exports.byName[value.name] = value;
  7795.             exports.idToIndex[value.id] = exports.list.length-1;
  7796.         }
  7797.     }
  7798.  
  7799.     initialise();
  7800.  
  7801.     return exports;
  7802.  
  7803. }
  7804. );
  7805. // recipeCache
  7806. window.moduleRegistry.add('recipeCache', (request, Promise) => {
  7807.  
  7808.     const initialised = new Promise.Expiring(2000, 'recipeCache');
  7809.  
  7810.     const exports = {
  7811.         list: [],
  7812.         byId: {},
  7813.         byName: {},
  7814.         byImage: {}
  7815.     };
  7816.  
  7817.     async function tryInitialise() {
  7818.         try {
  7819.             await initialise();
  7820.             initialised.resolve(exports);
  7821.         } catch(e) {
  7822.             initialised.reject(e);
  7823.         }
  7824.     }
  7825.  
  7826.     async function initialise() {
  7827.         exports.list = await request.listRecipes();
  7828.         for(const recipe of exports.list) {
  7829.             exports.byId[recipe.id] = recipe;
  7830.             exports.byName[recipe.name] = recipe;
  7831.             const lastPart = recipe.image.split('/').at(-1);
  7832.             exports.byImage[lastPart] = recipe;
  7833.         }
  7834.     }
  7835.  
  7836.     tryInitialise();
  7837.  
  7838.     return initialised;
  7839.  
  7840. }
  7841. );
  7842. // skillCache
  7843. window.moduleRegistry.add('skillCache', (request, Promise) => {
  7844.  
  7845.     const initialised = new Promise.Expiring(2000, 'skillCache');
  7846.  
  7847.     const exports = {
  7848.         list: [],
  7849.         byId: {},
  7850.         byName: {},
  7851.         byTechnicalName: {},
  7852.     };
  7853.  
  7854.     async function tryInitialise() {
  7855.         try {
  7856.             await initialise();
  7857.             initialised.resolve(exports);
  7858.         } catch(e) {
  7859.             initialised.reject(e);
  7860.         }
  7861.     }
  7862.  
  7863.     async function initialise() {
  7864.         const skills = await request.listSkills();
  7865.         for(const skill of skills) {
  7866.             exports.list.push(skill);
  7867.             exports.byId[skill.id] = skill;
  7868.             exports.byName[skill.displayName] = skill;
  7869.             exports.byTechnicalName[skill.technicalName] = skill;
  7870.         }
  7871.     }
  7872.  
  7873.     tryInitialise();
  7874.  
  7875.     return initialised;
  7876.  
  7877. }
  7878. );
  7879. // statNameCache
  7880. window.moduleRegistry.add('statNameCache', () => {
  7881.  
  7882.     const exports = {
  7883.         validate
  7884.     };
  7885.  
  7886.     const statNames = new Set([
  7887.         // ITEM_STAT_ATTRIBUTE
  7888.         'AMMO_PRESERVATION_CHANCE',
  7889.         'ATTACK_SPEED',
  7890.         'BONUS_LEVEL',
  7891.         'COIN_SNATCH',
  7892.         'COMBAT_EXP',
  7893.         'DOUBLE_EXP',
  7894.         'DOUBLE_DROP',
  7895.         'EFFICIENCY',
  7896.         'LOWER_TIER_CHANCE',
  7897.         'MERCHANT_SELL_CHANCE',
  7898.         'PRESERVATION',
  7899.         'SKILL_SPEED',
  7900.         // ITEM_ATTRIBUTE
  7901.         'ARMOUR',
  7902.         'BLEED_CHANCE',
  7903.         'BLOCK_CHANCE',
  7904.         'CARVE_CHANCE',
  7905.         'COIN_SNATCH',
  7906.         'COMBAT_EXP',
  7907.         'CRIT_CHANCE',
  7908.         'DAMAGE',
  7909.         'DAMAGE_PERCENT',
  7910.         'DAMAGE_RANGE',
  7911.         'DECREASED_POTION_DURATION',
  7912.         'DUNGEON_DAMAGE',
  7913.         'FOOD_EFFECT',
  7914.         'FOOD_PRESERVATION_CHANCE',
  7915.         'HEAL',
  7916.         'HEALTH',
  7917.         'HEALTH_PERCENT',
  7918.         'INCREASED_POTION_EFFECT',
  7919.         'MAP_FIND_CHANCE',
  7920.         'PARRY_CHANCE',
  7921.         'PASSIVE_FOOD_CONSUMPTION',
  7922.         'REVIVE_TIME',
  7923.         'STUN_CHANCE',
  7924.         'DUNGEON_TIME',
  7925.         // FRONTEND ONLY
  7926.         'MAX_AMOUNT'
  7927.     ]);
  7928.  
  7929.     function validate(name) {
  7930.         if(!statNames.has(name)) {
  7931.             throw `Unsupported stat usage : ${name}`;
  7932.         }
  7933.     }
  7934.  
  7935.     return exports;
  7936.  
  7937. });
  7938. // structuresCache
  7939. window.moduleRegistry.add('structuresCache', (request, Promise) => {
  7940.  
  7941.     const initialised = new Promise.Expiring(2000, 'structuresCache');
  7942.  
  7943.     const exports = {
  7944.         list: [],
  7945.         byId: {},
  7946.         byName: {}
  7947.     };
  7948.  
  7949.     async function tryInitialise() {
  7950.         try {
  7951.             await initialise();
  7952.             initialised.resolve(exports);
  7953.         } catch(e) {
  7954.             initialised.reject(e);
  7955.         }
  7956.     }
  7957.  
  7958.     async function initialise() {
  7959.         const structures = await request.listStructures();
  7960.         for(const structure of structures) {
  7961.             exports.list.push(structure);
  7962.             exports.byId[structure.id] = structure;
  7963.             exports.byName[structure.name] = structure;
  7964.         }
  7965.     }
  7966.  
  7967.     tryInitialise();
  7968.  
  7969.     return initialised;
  7970.  
  7971. }
  7972. );
  7973. window.moduleRegistry.build();