diff --git a/src/components/EffectDisplay.vue b/src/components/EffectDisplay.vue
index 2b9ccae876..4c2c9a3abc 100644
--- a/src/components/EffectDisplay.vue
+++ b/src/components/EffectDisplay.vue
@@ -16,8 +16,8 @@ export default {
     },
     label: {
       type: String,
-      default: "Currently",
-      required: false
+      required: false,
+      default: "Currently"
     },
     ignoreCapped: {
       type: Boolean,
@@ -72,8 +72,7 @@ export default {
         }
 
         if (!isFunction(effect)) {
-          throw new Error(`EffectDisplay config.effect has ` +
-            ` unsupported type "${typeof effect}"`);
+          throw new Error(`EffectDisplay config.effect has unsupported type "${typeof effect}"`);
         }
 
         const value = effect();
@@ -85,8 +84,8 @@ export default {
           this.effectValue = Decimal.fromDecimal(value);
           this.updateEffect = () => this.effectValue.copyFrom(effect());
         } else {
-          throw new Error(`EffectDisplay config.effect is a function which returns` +
-            ` unsupported type "${typeof effect}"`);
+          // eslint-disable-next-line max-len
+          throw new Error(`EffectDisplay config.effect is a function which returns unsupported type "${typeof effect}"`);
         }
 
         let cap = config.cap;
@@ -125,8 +124,7 @@ export default {
             return;
           }
 
-          throw new Error(`EffectDisplay config.cap is a function which returns` +
-            ` unsupported type "${typeof effect}"`);
+          throw new Error(`EffectDisplay config.cap is a function which returns unsupported type "${typeof effect}"`);
         }
       }
     },
diff --git a/src/components/SliderComponent.vue b/src/components/SliderComponent.vue
index 41705e5f95..a52f169c60 100644
--- a/src/components/SliderComponent.vue
+++ b/src/components/SliderComponent.vue
@@ -1,40 +1,39 @@
+<!-- eslint-disable vue/require-default-prop, max-len, no-unused-expressions, consistent-return, no-nested-ternary -->
 <script>
 import PlusMinusButton from "@/components/PlusMinusButton";
 
-/*
-* This is based on vue-slider-component
-* downloaded from https://github.com/NightCatSama/vue-slider-component
-* It's modified to support showing the slider value in the slider.
-*/
-/*
-The MIT License (MIT)
-
-Copyright (c) 2016 NightCatSama.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-*/
+// This is based on vue-slider-component
+// downloaded from https://github.com/NightCatSama/vue-slider-component
+// It's modified to support showing the slider value in the slider.
+//
+// The MIT License (MIT)
+//
+// Copyright (c) 2016 NightCatSama.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+//
 
 // Unsharp text [#166](https://github.com/NightCatSama/vue-slider-component/issues/166)
-const roundToDPR = (function () {
-  const r = typeof window !== 'undefined' ? window.devicePixelRatio || 1 : 1
-  return value => Math.round(value * r) / r
-})()
+const roundToDPR = (function() {
+  const r = typeof window === "undefined" ? 1 : window.devicePixelRatio || 1;
+  return value => Math.round(value * r) / r;
+}());
 
 export default {
   name: "SliderComponent",
@@ -44,7 +43,7 @@ export default {
   props: {
     width: {
       type: String,
-      default: 'auto'
+      default: "auto"
     },
     height: {
       type: String,
@@ -92,15 +91,15 @@ export default {
     },
     tooltip: {
       type: [String, Boolean],
-      default: 'always'
+      default: "always"
     },
     eventType: {
       type: String,
-      default: 'auto'
+      default: "auto"
     },
     direction: {
       type: String,
-      default: 'horizontal'
+      default: "horizontal"
     },
     reverse: {
       type: Boolean,
@@ -159,7 +158,7 @@ export default {
     actionsKeyboard: {
       type: Array,
       default() {
-        return [(i) => i - 1, (i) => i + 1]
+        return [i => i - 1, i => i + 1];
       }
     },
     piecewiseFilter: {
@@ -188,7 +187,8 @@ export default {
     sliderStyle: [Array, Object, Function],
     focusStyle: [Array, Object, Function],
     tooltipDir: [Array, String],
-    xformatter: [String, Function], // Global mixin defines formatter
+    // Global mixin defines formatter
+    xformatter: [String, Function],
     mergeFormatter: [String, Function],
     piecewiseStyle: Object,
     disabledStyle: Object,
@@ -220,7 +220,7 @@ export default {
       isComponentExists: true,
       isMounted: false,
       dotAxialSizePx: 1,
-    }
+    };
   },
   computed: {
     tooltipFormatHelper() {
@@ -229,10 +229,10 @@ export default {
       }
       if (this.xformatter) {
         if (this.val[0] === this.val[1]) return this.formatting(this.val[0]);
-        return this.formatting(this.val[0]) + "-" + this.formatting(this.val[1]);
+        return `${this.formatting(this.val[0])}-${this.formatting(this.val[1])}`;
       }
       if (this.val[0] === this.val[1]) return this.val[0];
-      return this.val[0] + "-" + this.val[1];
+      return `${this.val[0]}-${this.val[1]}`;
     },
     dotWidthVal() {
       return this.dotWidth || this.dotSize;
@@ -241,213 +241,231 @@ export default {
       return this.dotHeight || this.dotSize;
     },
     flowDirection() {
-      return `l-ad-slider--${this.direction + (this.reverse ? '-reverse' : '')}`
+      return `l-ad-slider--${this.direction + (this.reverse ? "-reverse" : "")}`;
     },
+    // eslint-disable-next-line vue/return-in-computed-property
     tooltipMergedPosition() {
-      if (!this.isMounted) return {}
-      const tooltipDirection = this.tooltipDirection[0]
+      if (!this.isMounted) return {};
+      const tooltipDirection = this.tooltipDirection[0];
       if (this.$refs.dot0) {
-        const style = {}
-        style[tooltipDirection] = `-${(this.dotAxialSizePx / 2) - (this.size / 2) + 9}px`
-        style['left'] = `50%`
-        return style
+        const style = {};
+        style[tooltipDirection] = `-${(this.dotAxialSizePx / 2) - (this.size / 2) + 9}px`;
+        style.left = `50%`;
+        return style;
       }
     },
     tooltipDirection() {
-      const dir = this.tooltipDir || (this.direction === 'vertical' ? 'left' : 'top')
+      const dir = this.tooltipDir || (this.direction === "vertical" ? "left" : "top");
       if (Array.isArray(dir)) {
-        return this.isRange ? dir : dir[1]
-      } else {
-        return this.isRange ? [dir, dir] : dir
+        return this.isRange ? dir : dir[1];
       }
+      return this.isRange ? [dir, dir] : dir;
     },
     tooltipStatus() {
-      return this.tooltip === 'hover' && this.flag ? 'ad-slider-always' : this.tooltip ? `ad-slider-${this.tooltip}` : ''
+      return this.tooltip === "hover" && this.flag
+        ? "ad-slider-always"
+        : this.tooltip
+          ? `ad-slider-${this.tooltip}`
+          : "";
     },
     tooltipClass() {
-      return [`ad-slider-tooltip-${this.tooltipDirection}`, 'ad-slider-tooltip']
+      return [`ad-slider-tooltip-${this.tooltipDirection}`, "ad-slider-tooltip"];
     },
     disabledArray() {
-      return Array.isArray(this.disabled) ? this.disabled : [this.disabled, this.disabled]
+      return Array.isArray(this.disabled) ? this.disabled : [this.disabled, this.disabled];
     },
     boolDisabled() {
-      return this.disabledArray.every(b => b === true)
+      return this.disabledArray.every(b => b === true);
     },
     isDisabled() {
-      return this.eventType === 'none' ? true : this.boolDisabled
+      return this.eventType === "none" ? true : this.boolDisabled;
     },
     disabledClass() {
-      return this.boolDisabled ? 'l-ad-slider--disabled' : ''
+      return this.boolDisabled ? "l-ad-slider--disabled" : "";
     },
     stateClass() {
       return {
-        'ad-slider-state-process-drag': this.processFlag,
-        'ad-slider-state-drag': this.flag && !this.processFlag && !this.keydownFlag,
-        'ad-slider-state-focus': this.focusFlag
-      }
+        "ad-slider-state-process-drag": this.processFlag,
+        "ad-slider-state-drag": this.flag && !this.processFlag && !this.keydownFlag,
+        "ad-slider-state-focus": this.focusFlag
+      };
     },
     isRange() {
-      return Array.isArray(this.value)
+      return Array.isArray(this.value);
     },
     slider() {
-      return this.isRange ? [this.$refs.dot0, this.$refs.dot1] : [this.$refs.dot0]
+      return this.isRange ? [this.$refs.dot0, this.$refs.dot1] : [this.$refs.dot0];
     },
     minimum() {
-      return this.data ? 0 : this.min
+      return this.data ? 0 : this.min;
     },
     val: {
       get() {
-        return this.data ? (this.isRange ? [this.data[this.currentValue[0]], this.data[this.currentValue[1]]] : this.data[this.currentValue]) : this.currentValue
+        return this.data
+          ? this.isRange
+            ? [this.data[this.currentValue[0]], this.data[this.currentValue[1]]]
+            : this.data[this.currentValue]
+          : this.currentValue;
       },
       set(val) {
         if (this.data) {
           if (this.isRange) {
-            const index0 = this.data.indexOf(val[0])
-            const index1 = this.data.indexOf(val[1])
+            const index0 = this.data.indexOf(val[0]);
+            const index1 = this.data.indexOf(val[1]);
             if (index0 > -1 && index1 > -1) {
-              this.currentValue = [index0, index1]
+              this.currentValue = [index0, index1];
             }
           } else {
-            const index = this.data.indexOf(val)
+            const index = this.data.indexOf(val);
             if (index > -1) {
-              this.currentValue = index
+              this.currentValue = index;
             }
           }
         } else {
-          this.currentValue = val
+          this.currentValue = val;
         }
       }
     },
     currentIndex() {
       if (this.isRange) {
-        return this.data ? this.currentValue : [this.getIndexByValue(this.currentValue[0]), this.getIndexByValue(this.currentValue[1])]
-      } else {
-        return this.getIndexByValue(this.currentValue)
+        return this.data
+          ? this.currentValue
+          : [this.getIndexByValue(this.currentValue[0]), this.getIndexByValue(this.currentValue[1])];
       }
+      return this.getIndexByValue(this.currentValue);
+
     },
     indexRange() {
       if (this.isRange) {
-        return this.currentIndex
-      } else {
-        return [0, this.currentIndex]
+        return this.currentIndex;
       }
+      return [0, this.currentIndex];
+
     },
     maximum() {
-      return this.data ? (this.data.length - 1) : this.max
+      return this.data ? (this.data.length - 1) : this.max;
     },
     multiple() {
-      const decimals = `${this.interval}`.split('.')[1]
-      return decimals ? Math.pow(10, decimals.length) : 1
+      const decimals = `${this.interval}`.split(".")[1];
+      return decimals ? Math.pow(10, decimals.length) : 1;
     },
     spacing() {
-      return this.data ? 1 : this.interval
+      return this.data ? 1 : this.interval;
     },
     total() {
       if (this.data) {
-        return this.data.length - 1
-      } else if (Math.floor((this.maximum - this.minimum) * this.multiple) % (this.interval * this.multiple) !== 0) {
-        this.printError('Prop[interval] is illegal, Please make sure that the interval can be divisible')
+        return this.data.length - 1;
+      // eslint-disable-next-line max-statements-per-line
+      } if (Math.floor((this.maximum - this.minimum) * this.multiple) % (this.interval * this.multiple) !== 0) {
+        this.printError("Prop[interval] is illegal, Please make sure that the interval can be divisible");
       }
-      return (this.maximum - this.minimum) / this.interval
+      return (this.maximum - this.minimum) / this.interval;
     },
     usableSize() {
       return this.size - this.dotAxialSizePx;
     },
     gap() {
-      return this.usableSize / this.total
+      return this.usableSize / this.total;
     },
     position() {
       if (this.isRange) {
-        return [(this.currentValue[0] - this.minimum) / this.spacing * this.gap + this.dotAxialSizePx / 2, (this.currentValue[1] - this.minimum) / this.spacing * this.gap + this.dotAxialSizePx / 2]
-      } else {
-        return ((this.currentValue - this.minimum) / this.spacing * this.gap + this.dotAxialSizePx / 2)
+        return [(this.currentValue[0] - this.minimum) / this.spacing * this.gap + this.dotAxialSizePx / 2, (this.currentValue[1] - this.minimum) / this.spacing * this.gap + this.dotAxialSizePx / 2];
       }
+      return (this.currentValue - this.minimum) / this.spacing * this.gap + this.dotAxialSizePx / 2;
+
     },
     isFixed() {
-      return this.fixed || this.minRange
+      return this.fixed || this.minRange;
     },
     limit() {
       if (this.isRange) {
         if (this.isFixed) {
-          return [[this.dotAxialSizePx / 2, this.dotAxialSizePx / 2 + (this.total - this.fixedValue) * this.gap], [this.fixedValue * this.gap + this.dotAxialSizePx / 2, this.size - this.dotAxialSizePx / 2]]
-        } else {
-          return [[this.dotAxialSizePx / 2, this.position[1]], [this.position[0], this.size - this.dotAxialSizePx / 2]];
+          return [[this.dotAxialSizePx / 2, this.dotAxialSizePx / 2 + (this.total - this.fixedValue) * this.gap], [this.fixedValue * this.gap + this.dotAxialSizePx / 2, this.size - this.dotAxialSizePx / 2]];
         }
-      } else {
-        return [this.dotAxialSizePx / 2, this.size - this.dotAxialSizePx / 2];
+        return [[this.dotAxialSizePx / 2, this.position[1]], [this.position[0], this.size - this.dotAxialSizePx / 2]];
+
       }
+      return [this.dotAxialSizePx / 2, this.size - this.dotAxialSizePx / 2];
+
     },
     valueLimit() {
-      return this.isRange ? this.isFixed ? [[this.minimum, this.maximum - (this.fixedValue * (this.spacing * this.multiple)) / this.multiple], [this.minimum + (this.fixedValue * (this.spacing * this.multiple)) / this.multiple, this.maximum]] : [[this.minimum, this.currentValue[1]], [this.currentValue[0], this.maximum]] : [this.minimum, this.maximum]
+      return this.isRange
+        ? this.isFixed
+          ? [[this.minimum, this.maximum - (this.fixedValue * (this.spacing * this.multiple)) / this.multiple], [this.minimum + (this.fixedValue * (this.spacing * this.multiple)) / this.multiple, this.maximum]]
+          : [[this.minimum, this.currentValue[1]], [this.currentValue[0], this.maximum]]
+        : [this.minimum, this.maximum];
     },
     idleSlider() {
-      return this.currentSlider === 0 ? 1 : 0
+      return this.currentSlider === 0 ? 1 : 0;
     },
     wrapStyles() {
-      let ret = this.direction === 'vertical' ? {
-        height: this.height,
-      } : {
-        width: this.width,
-      }
+      const styles = this.direction === "vertical"
+        ? { height: this.height }
+        : { width: this.width };
       if (this.plusMinusButtons) {
-        ret[this.direction === "vertical" ? "margin-top" : "margin-right"] = "0.5rem";
-        ret[this.direction === "vertical" ? "margin-bottom" : "margin-left"] = "0.5rem";
+        styles[this.direction === "vertical" ? "margin-top" : "margin-right"] = "0.5rem";
+        styles[this.direction === "vertical" ? "margin-bottom" : "margin-left"] = "0.5rem";
       }
-      return ret;
+      return styles;
     },
     sliderStyles() {
       if (Array.isArray(this.sliderStyle)) {
-        return this.isRange ? this.sliderStyle : this.sliderStyle[1]
-      } else if (typeof this.sliderStyle === 'function') {
-        return this.sliderStyle(this.val, this.currentIndex)
-      } else {
-        return this.isRange ? [this.sliderStyle, this.sliderStyle] : this.sliderStyle
+        return this.isRange ? this.sliderStyle : this.sliderStyle[1];
+      // eslint-disable-next-line max-statements-per-line
+      } if (typeof this.sliderStyle === "function") {
+        return this.sliderStyle(this.val, this.currentIndex);
       }
+      return this.isRange ? [this.sliderStyle, this.sliderStyle] : this.sliderStyle;
+
     },
     focusStyles() {
       if (Array.isArray(this.focusStyle)) {
-        return this.isRange ? this.focusStyle : this.focusStyle[1]
-      } else if (typeof this.focusStyle === 'function') {
-        return this.focusStyle(this.val, this.currentIndex)
-      } else {
-        return this.isRange ? [this.focusStyle, this.focusStyle] : this.focusStyle
+        return this.isRange ? this.focusStyle : this.focusStyle[1];
+      // eslint-disable-next-line max-statements-per-line
+      } if (typeof this.focusStyle === "function") {
+        return this.focusStyle(this.val, this.currentIndex);
       }
+      return this.isRange ? [this.focusStyle, this.focusStyle] : this.focusStyle;
+
     },
     disabledDotStyles() {
-      const disabledStyle = this.disabledDotStyle
+      const disabledStyle = this.disabledDotStyle;
       if (Array.isArray(disabledStyle)) {
-        return disabledStyle
-      } else if (typeof disabledStyle === 'function') {
-        const style = disabledStyle(this.val, this.currentIndex)
-        return Array.isArray(style) ? style : [style, style]
-      } else if (disabledStyle) {
-        return [disabledStyle, disabledStyle]
-      } else {
-        return [{
-          backgroundColor: '#ccc'
-        }, {
-          backgroundColor: '#ccc'
-        }]
-      }
+        return disabledStyle;
+      // eslint-disable-next-line max-statements-per-line
+      } if (typeof disabledStyle === "function") {
+        const style = disabledStyle(this.val, this.currentIndex);
+        return Array.isArray(style) ? style : [style, style];
+      // eslint-disable-next-line max-statements-per-line
+      } if (disabledStyle) {
+        return [disabledStyle, disabledStyle];
+      }
+      return [{
+        backgroundColor: "#ccc"
+      }, {
+        backgroundColor: "#ccc"
+      }];
+
     },
     tooltipStyles() {
       if (Array.isArray(this.tooltipStyle)) {
-        return this.isRange ? this.tooltipStyle : this.tooltipStyle[1]
-      } else if (typeof this.tooltipStyle === 'function') {
-        return this.tooltipStyle(this.val, this.currentIndex)
-      } else {
-        return this.isRange ? [this.tooltipStyle, this.tooltipStyle] : this.tooltipStyle
+        return this.isRange ? this.tooltipStyle : this.tooltipStyle[1];
+      // eslint-disable-next-line max-statements-per-line
+      } if (typeof this.tooltipStyle === "function") {
+        return this.tooltipStyle(this.val, this.currentIndex);
       }
+      return this.isRange ? [this.tooltipStyle, this.tooltipStyle] : this.tooltipStyle;
+
     },
     elemStyles() {
-      return this.direction === 'vertical' ? {
+      return this.direction === "vertical" ? {
         width: this.width,
-        height: '100%',
+        height: "100%",
         position: "relative"
       } : {
         height: this.height,
         position: "relative"
-      }
+      };
     },
     draggableStyle() {
       return {
@@ -455,27 +473,27 @@ export default {
       };
     },
     dotStyles() {
-      let ret = {
+      const styles = {
         width: this.dotWidthVal,
         height: this.dotHeightVal,
         position: "absolute",
-      }
+      };
       if (this.direction === "vertical") {
-        ret.left = "50%";
+        styles.left = "50%";
       } else {
-        ret.top = "50%";
-      }
-      return ret;
-      /*
-      return this.direction === 'vertical' ? {
-        width: this.dotWidthVal,
-        height: this.dotHeightVal,
-        left: `${(-(this.dotWidthVal - this.width) / 2)}px`
-      } : {
-          width: `${this.dotWidthVal}px`,
-          height: `${this.dotHeightVal}px`,
-          top: `${(-(this.dotHeightVal - this.height) / 2)}px`
-        }*/
+        styles.top = "50%";
+      }
+      return styles;
+      //
+      // return this.direction === 'vertical' ? {
+      // width: this.dotWidthVal,
+      // height: this.dotHeightVal,
+      // left: `${(-(this.dotWidthVal - this.width) / 2)}px`
+      // } : {
+      //     width: `${this.dotWidthVal}px`,
+      //     height: `${this.dotHeightVal}px`,
+      //     top: `${(-(this.dotHeightVal - this.height) / 2)}px`
+      // }
     },
     piecewiseDotStyle() {
       return {
@@ -485,354 +503,391 @@ export default {
     },
     piecewiseDotWrap() {
       if (!this.piecewise && !this.piecewiseLabel) {
-        return false
+        return false;
       }
-      let arr = []
+      const arr = [];
       for (let i = 0; i <= this.total; i++) {
-        const style = this.direction === 'vertical' ? {
-          bottom: `${this.gap * i - this.usableSize / 2 }px`,
+        const style = this.direction === "vertical" ? {
+          bottom: `${this.gap * i - this.usableSize / 2}px`,
           left: 0
         } : {
-          left: `${this.gap * i - this.usableSize / 2 }px`,
+          left: `${this.gap * i - this.usableSize / 2}px`,
           top: 0
-        }
-        const index = this.reverse ? (this.total - i) : i
-        const label = this.data ? this.data[index] : (this.spacing * index) + this.min
+        };
+        const index = this.reverse ? (this.total - i) : i;
+        const label = this.data ? this.data[index] : (this.spacing * index) + this.min;
         if (this.piecewiseFilter && !this.piecewiseFilter({ index, label })) {
-          continue
+          continue;
         }
         arr.push({
           style,
           index,
           label: this.xformatter ? this.formatting(label) : label
-        })
+        });
       }
-      return arr
+      return arr;
     },
   },
   watch: {
     value(val) {
-      this.flag || this.setValue(val, true)
+      this.flag || this.setValue(val, true);
     },
     max(val) {
       if (val < this.min) {
-        return this.printError('The maximum value can not be less than the minimum value.')
+        return this.printError("The maximum value can not be less than the minimum value.");
       }
-      const resetVal = this.limitValue(this.val)
-      this.setValue(resetVal)
-      this.refresh()
+      const resetVal = this.limitValue(this.val);
+      this.setValue(resetVal);
+      this.refresh();
     },
     min(val) {
       if (val > this.max) {
-        return this.printError('The minimum value can not be greater than the maximum value.')
+        return this.printError("The minimum value can not be greater than the maximum value.");
       }
-      const resetVal = this.limitValue(this.val)
-      this.setValue(resetVal)
-      this.refresh()
+      const resetVal = this.limitValue(this.val);
+      this.setValue(resetVal);
+      this.refresh();
     },
     show(bool) {
       if (bool && !this.size) {
         this.$nextTick(() => {
-          this.refresh()
-        })
+          this.refresh();
+        });
       }
     },
     fixed() {
-      this.computedFixedValue()
+      this.computedFixedValue();
     },
     minRange() {
-      this.computedFixedValue()
+      this.computedFixedValue();
     },
     reverse() {
-      this.$refs.process.style.cssText = ''
-      this.refresh()
+      this.$refs.process.style.cssText = "";
+      this.refresh();
     },
   },
+  mounted() {
+    this.isComponentExists = true;
+    if (typeof window === "undefined" || typeof document === "undefined") {
+      return this.printError("window or document is undefined, can not be initialization.");
+    }
+    this.$nextTick(() => {
+      if (this.isComponentExists) {
+        this.getStaticData();
+        this.setValue(this.limitValue(this.value), true, this.startAnimation ? this.speed : 0);
+        this.bindEvents();
+        if (this.isRange && this.tooltipMerge && !this.startAnimation) {
+          this.$nextTick(() => {
+            this.handleOverlapTooltip();
+          });
+        }
+      }
+    });
+    this.isMounted = true;
+  },
+  beforeDestroy() {
+    this.isComponentExists = false;
+    this.unbindEvents();
+  },
   methods: {
     bindEvents() {
-      document.addEventListener('touchmove', this.moving, { passive: false })
-      document.addEventListener('touchend', this.moveEnd, { passive: false })
-      document.addEventListener('mousedown', this.blurSlider)
-      document.addEventListener('mousemove', this.moving)
-      document.addEventListener('mouseup', this.moveEnd)
-      document.addEventListener('mouseleave', this.moveEnd)
-      document.addEventListener('keydown', this.handleKeydown)
-      document.addEventListener('keyup', this.handleKeyup)
-      window.addEventListener('resize', this.refresh)
+      document.addEventListener("touchmove", this.moving, { passive: false });
+      document.addEventListener("touchend", this.moveEnd, { passive: false });
+      document.addEventListener("mousedown", this.blurSlider);
+      document.addEventListener("mousemove", this.moving);
+      document.addEventListener("mouseup", this.moveEnd);
+      document.addEventListener("mouseleave", this.moveEnd);
+      document.addEventListener("keydown", this.handleKeydown);
+      document.addEventListener("keyup", this.handleKeyup);
+      window.addEventListener("resize", this.refresh);
       if (this.isRange && this.tooltipMerge) {
-        this.$refs.dot0.addEventListener('transitionend', this.handleOverlapTooltip)
-        this.$refs.dot1.addEventListener('transitionend', this.handleOverlapTooltip)
+        this.$refs.dot0.addEventListener("transitionend", this.handleOverlapTooltip);
+        this.$refs.dot1.addEventListener("transitionend", this.handleOverlapTooltip);
       }
     },
     unbindEvents() {
-      document.removeEventListener('touchmove', this.moving)
-      document.removeEventListener('touchend', this.moveEnd)
-      document.removeEventListener('mousedown', this.blurSlider)
-      document.removeEventListener('mousemove', this.moving)
-      document.removeEventListener('mouseup', this.moveEnd)
-      document.removeEventListener('mouseleave', this.moveEnd)
-      document.removeEventListener('keydown', this.handleKeydown)
-      document.removeEventListener('keyup', this.handleKeyup)
-      window.removeEventListener('resize', this.refresh)
+      document.removeEventListener("touchmove", this.moving);
+      document.removeEventListener("touchend", this.moveEnd);
+      document.removeEventListener("mousedown", this.blurSlider);
+      document.removeEventListener("mousemove", this.moving);
+      document.removeEventListener("mouseup", this.moveEnd);
+      document.removeEventListener("mouseleave", this.moveEnd);
+      document.removeEventListener("keydown", this.handleKeydown);
+      document.removeEventListener("keyup", this.handleKeyup);
+      window.removeEventListener("resize", this.refresh);
       if (this.isRange && this.tooltipMerge) {
-        this.$refs.dot0.removeEventListener('transitionend', this.handleOverlapTooltip)
-        this.$refs.dot1.removeEventListener('transitionend', this.handleOverlapTooltip)
+        this.$refs.dot0.removeEventListener("transitionend", this.handleOverlapTooltip);
+        this.$refs.dot1.removeEventListener("transitionend", this.handleOverlapTooltip);
       }
     },
     handleKeydown(e) {
       if (!this.useKeyboard || !this.focusFlag) {
-        return false
+        return false;
       }
       switch (e.keyCode) {
         case 37:
         case 40:
-          e.preventDefault()
-          this.keydownFlag = true
-          this.flag = true
-          this.changeFocusSlider(this.actionsKeyboard[0])
-          break
+          e.preventDefault();
+          this.keydownFlag = true;
+          this.flag = true;
+          this.changeFocusSlider(this.actionsKeyboard[0]);
+          break;
         case 38:
         case 39:
-          e.preventDefault()
-          this.keydownFlag = true
-          this.flag = true
-          this.changeFocusSlider(this.actionsKeyboard[1])
-          break
+          e.preventDefault();
+          this.keydownFlag = true;
+          this.flag = true;
+          this.changeFocusSlider(this.actionsKeyboard[1]);
+          break;
       }
     },
     handleKeyup() {
       if (this.keydownFlag) {
-        this.keydownFlag = false
-        this.flag = false
+        this.keydownFlag = false;
+        this.flag = false;
       }
     },
     changeFocusSlider(fn) {
       if (this.isRange) {
         let arr = this.currentIndex.map((index, i) => {
           if (i === this.focusSlider || this.fixed) {
-            const val = fn(index)
-            const range = this.fixed ? this.valueLimit[i] : [0, this.total]
+            const val = fn(index);
+            const range = this.fixed ? this.valueLimit[i] : [0, this.total];
             if (val <= range[1] && val >= range[0]) {
-              return val
+              return val;
             }
           }
-          return index
-        })
+          return index;
+        });
         if (arr[0] > arr[1]) {
-          this.focusSlider = this.focusSlider === 0 ? 1 : 0
-          arr = arr.reverse()
+          this.focusSlider = this.focusSlider === 0 ? 1 : 0;
+          arr = arr.reverse();
         }
-        this.setIndex(arr)
+        this.setIndex(arr);
       } else {
-        this.setIndex(fn(this.currentIndex))
+        this.setIndex(fn(this.currentIndex));
       }
     },
     blurSlider(e) {
-      const dot = this.isRange ? this.$refs[`dot${this.focusSlider}`] : this.$refs.dot
+      const dot = this.isRange ? this.$refs[`dot${this.focusSlider}`] : this.$refs.dot;
       if (!dot || dot === e.target || dot.contains(e.target)) {
-        return false
+        return false;
       }
-      this.focusFlag = false
+      this.focusFlag = false;
     },
     formatting(value) {
-      return typeof this.xformatter === 'string' ? this.xformatter.replace(/\{value\}/, value) : this.xformatter(value)
+      return typeof this.xformatter === "string"
+        ? this.xformatter.replace(/\{value\}/u, value)
+        : this.xformatter(value);
     },
     mergeFormatting(value1, value2) {
-      return typeof this.mergeFormatter === 'string' ? this.mergeFormatter.replace(/\{(value1|value2)\}/g, (_, key) => key === 'value1' ? value1 : value2) : this.mergeFormatter(value1, value2)
+      return typeof this.mergeFormatter === "string"
+        ? this.mergeFormatter.replace(/\{(value1|value2)\}/gu, (_, key) => (key === "value1" ? value1 : value2))
+        : this.mergeFormatter(value1, value2);
     },
     getPos(e) {
-      this.realTime && this.getStaticData()
-      var rect = this.$refs.elem.getBoundingClientRect();
-      return this.direction === 'vertical' ? (this.reverse ? (e.clientY - rect.top) : (this.size - (e.clientY - rect.top))) : (this.reverse ? (this.size - (e.clientX - rect.left)) : (e.clientX - rect.left))
+      this.realTime && this.getStaticData();
+      const rect = this.$refs.elem.getBoundingClientRect();
+      return this.direction === "vertical"
+        ? this.reverse
+          ? e.clientY - rect.top
+          : this.size - (e.clientY - rect.top)
+        : this.reverse
+          ? this.size - (e.clientX - rect.left)
+          : e.clientX - rect.left;
     },
     processClick(e) {
       if (this.fixed) {
-        e.stopPropagation()
+        e.stopPropagation();
       }
     },
     wrapClick(e) {
-      if (this.isDisabled || !this.clickable || this.processFlag || this.dragFlag) return false
-      const pos = this.getPos(e)
+      if (this.isDisabled || !this.clickable || this.processFlag || this.dragFlag) return false;
+      const pos = this.getPos(e);
       if (this.isRange) {
         if (this.disabledArray.every(b => b === false)) {
-          this.currentSlider = pos > ((this.position[1] - this.position[0]) / 2 + this.position[0]) ? 1 : 0
+          this.currentSlider = pos > ((this.position[1] - this.position[0]) / 2 + this.position[0]) ? 1 : 0;
         } else if (this.disabledArray[0]) {
-          if (pos < this.position[0]) return false
-          this.currentSlider = 1
+          if (pos < this.position[0]) return false;
+          this.currentSlider = 1;
         } else if (this.disabledArray[1]) {
-          if (pos > this.position[1]) return false
-          this.currentSlider = 0
+          if (pos > this.position[1]) return false;
+          this.currentSlider = 0;
         }
       }
       if (this.disabledArray[this.currentSlider]) {
-        return false
+        return false;
       }
-      this.setValueOnPos(pos)
+      this.setValueOnPos(pos);
       if (this.isRange && this.tooltipMerge) {
-        const timer = setInterval(() => this.handleOverlapTooltip(), 16.7)
-        setTimeout(() => window.clearInterval(timer), this.speed * 1000)
+        const timer = setInterval(() => this.handleOverlapTooltip(), 16.7);
+        setTimeout(() => window.clearInterval(timer), this.speed * 1000);
       }
     },
     moveStart(e, index = 0, isProcess) {
       if (this.disabledArray[index]) {
-        return false
+        return false;
       }
       if (this.stopPropagation) {
-        e.stopPropagation()
+        e.stopPropagation();
       }
       if (this.isRange) {
-        this.currentSlider = index
+        this.currentSlider = index;
         if (isProcess) {
           if (!this.processDraggable) {
-            return false
+            return false;
           }
-          this.processFlag = true
+          this.processFlag = true;
           this.processSign = {
             pos: this.position,
             start: this.getPos((e.targetTouches && e.targetTouches[0]) ? e.targetTouches[0] : e)
-          }
+          };
         }
         if (!this.enableCross && this.val[0] === this.val[1]) {
-          this.crossFlag = true
+          this.crossFlag = true;
         }
       }
       if (!isProcess && this.useKeyboard) {
-        this.focusFlag = true
-        this.focusSlider = index
+        this.focusFlag = true;
+        this.focusSlider = index;
       }
-      this.flag = true
-      this.$emit('drag-start', this)
+      this.flag = true;
+      this.$emit("drag-start", this);
     },
     moving(e) {
       if (this.stopPropagation) {
-        e.stopPropagation()
+        e.stopPropagation();
       }
-      if (!this.flag) return false
-      e.preventDefault()
-      if (e.targetTouches && e.targetTouches[0]) e = e.targetTouches[0]
+      if (!this.flag) return false;
+      e.preventDefault();
+      // eslint-disable-next-line no-param-reassign
+      if (e.targetTouches && e.targetTouches[0]) e = e.targetTouches[0];
       if (this.processFlag) {
-        this.currentSlider = 0
-        this.setValueOnPos(this.processSign.pos[0] + this.getPos(e) - this.processSign.start, true)
-        this.currentSlider = 1
-        this.setValueOnPos(this.processSign.pos[1] + this.getPos(e) - this.processSign.start, true)
+        this.currentSlider = 0;
+        this.setValueOnPos(this.processSign.pos[0] + this.getPos(e) - this.processSign.start, true);
+        this.currentSlider = 1;
+        this.setValueOnPos(this.processSign.pos[1] + this.getPos(e) - this.processSign.start, true);
       } else {
-        this.dragFlag = true
-        this.setValueOnPos(this.getPos(e), true)
+        this.dragFlag = true;
+        this.setValueOnPos(this.getPos(e), true);
       }
       if (this.isRange && this.tooltipMerge) {
-        this.handleOverlapTooltip()
+        this.handleOverlapTooltip();
       }
     },
     moveEnd(e) {
       if (this.stopPropagation) {
-        e.stopPropagation()
+        e.stopPropagation();
       }
       if (this.flag) {
-        this.$emit('drag-end', this)
+        this.$emit("drag-end", this);
         if (this.lazy && this.isDiff(this.val, this.value)) {
-          this.syncValue()
+          this.syncValue();
         }
       } else {
-        return false
+        return false;
       }
-      this.flag = false
+      this.flag = false;
       window.setTimeout(() => {
-        this.crossFlag = false
-        this.dragFlag = false
-        this.processFlag = false
-      }, 0)
-      this.setPosition()
+        this.crossFlag = false;
+        this.dragFlag = false;
+        this.processFlag = false;
+      }, 0);
+      this.setPosition();
     },
+    // eslint-disable-next-line complexity
     setValueOnPos(pos, isDrag) {
-      const range = this.isRange ? this.limit[this.currentSlider] : this.limit
-      const valueRange = this.isRange ? this.valueLimit[this.currentSlider] : this.valueLimit
-      const index = Math.round((pos - this.dotAxialSizePx / 2) / this.gap)
+      const range = this.isRange ? this.limit[this.currentSlider] : this.limit;
+      const valueRange = this.isRange ? this.valueLimit[this.currentSlider] : this.valueLimit;
+      const index = Math.round((pos - this.dotAxialSizePx / 2) / this.gap);
       if (pos >= range[0] && pos <= range[1]) {
-        const v = this.getValueByIndex(index)
-        this.setTransform(pos)
-        this.setCurrentValue(v, isDrag)
+        const v = this.getValueByIndex(index);
+        this.setTransform(pos);
+        this.setCurrentValue(v, isDrag);
         if (this.isRange && (this.fixed || this.isLessRange(pos, index))) {
-          this.setTransform(pos + ((this.fixedValue * this.gap) * (this.currentSlider === 0 ? 1 : -1)), true)
-          this.setCurrentValue((v * this.multiple + (this.fixedValue * this.spacing * this.multiple * (this.currentSlider === 0 ? 1 : -1))) / this.multiple, isDrag, true)
+          this.setTransform(pos + ((this.fixedValue * this.gap) * (this.currentSlider === 0 ? 1 : -1)), true);
+          this.setCurrentValue((v * this.multiple + (this.fixedValue * this.spacing * this.multiple * (this.currentSlider === 0 ? 1 : -1))) / this.multiple, isDrag, true);
         }
       } else {
-        const anotherSlider = pos < range[0] ? 0 : 1
-        const currentSlider = anotherSlider === 0 ? 1 : 0
-        this.setTransform(range[anotherSlider])
-        this.setCurrentValue(valueRange[anotherSlider])
+        const anotherSlider = pos < range[0] ? 0 : 1;
+        const currentSlider = anotherSlider === 0 ? 1 : 0;
+        this.setTransform(range[anotherSlider]);
+        this.setCurrentValue(valueRange[anotherSlider]);
         if (this.isRange && (this.fixed || this.isLessRange(pos, index))) {
-          this.setTransform(this.limit[this.idleSlider][anotherSlider], true)
-          this.setCurrentValue(this.valueLimit[this.idleSlider][anotherSlider], isDrag, true)
+          this.setTransform(this.limit[this.idleSlider][anotherSlider], true);
+          this.setCurrentValue(this.valueLimit[this.idleSlider][anotherSlider], isDrag, true);
         } else if (this.isRange && (this.enableCross || this.crossFlag) && !this.isFixed && !this.disabledArray[anotherSlider] && this.currentSlider === currentSlider) {
-          this.focusSlider = anotherSlider
-          this.currentSlider = anotherSlider
+          this.focusSlider = anotherSlider;
+          this.currentSlider = anotherSlider;
         }
       }
-      this.crossFlag = false
+      this.crossFlag = false;
     },
     isLessRange(pos, index) {
       if (!this.isRange || (!this.minRange && !this.maxRange)) {
-        return false
+        return false;
       }
-      const diff = this.currentSlider === 0 ? this.currentIndex[1] - index : index - this.currentIndex[0]
+      const diff = this.currentSlider === 0 ? this.currentIndex[1] - index : index - this.currentIndex[0];
       if (this.minRange && diff <= this.minRange) {
-        this.fixedValue = this.minRange
-        return true
+        this.fixedValue = this.minRange;
+        return true;
       }
       if (this.maxRange && diff >= this.maxRange) {
-        this.fixedValue = this.maxRange
-        return true
+        this.fixedValue = this.maxRange;
+        return true;
       }
-      this.computedFixedValue()
-      return false
+      this.computedFixedValue();
+      return false;
     },
     isDiff(a, b) {
       if (Object.prototype.toString.call(a) !== Object.prototype.toString.call(b)) {
-        return true
-      } else if (Array.isArray(a) && a.length === b.length) {
-        return a.some((v, i) => v !== b[i])
+        return true;
+      // eslint-disable-next-line max-statements-per-line
+      } if (Array.isArray(a) && a.length === b.length) {
+        return a.some((v, i) => v !== b[i]);
       }
-      return a !== b
+      return a !== b;
     },
     setCurrentValue(val, isDrag, isIdleSlider) {
-      const slider = isIdleSlider ? this.idleSlider : this.currentSlider
-      if (val < this.minimum || val > this.maximum) return false
+      const slider = isIdleSlider ? this.idleSlider : this.currentSlider;
+      if (val < this.minimum || val > this.maximum) return false;
       if (this.isRange) {
         if (this.isDiff(this.currentValue[slider], val)) {
-          this.currentValue.splice(slider, 1, val)
+          this.currentValue.splice(slider, 1, val);
           if (!this.lazy || !this.flag) {
-            this.syncValue()
+            this.syncValue();
           }
         }
       } else if (this.isDiff(this.currentValue, val)) {
-        this.currentValue = val
+        this.currentValue = val;
         if (!this.lazy || !this.flag) {
-          this.syncValue()
+          this.syncValue();
         }
       }
-      isDrag || this.setPosition()
+      isDrag || this.setPosition();
     },
     getValueByIndex(index) {
-      return ((this.spacing * this.multiple) * index + (this.minimum * this.multiple)) / this.multiple
+      return ((this.spacing * this.multiple) * index + (this.minimum * this.multiple)) / this.multiple;
     },
     getIndexByValue(value) {
-      return Math.round((value - this.minimum) * this.multiple) / (this.spacing * this.multiple)
+      return Math.round((value - this.minimum) * this.multiple) / (this.spacing * this.multiple);
     },
     setIndex(val) {
       if (Array.isArray(val) && this.isRange) {
-        let value
+        let value;
         if (this.data) {
-          value = [this.data[val[0]], this.data[val[1]]]
+          value = [this.data[val[0]], this.data[val[1]]];
         } else {
-          value = [this.getValueByIndex(val[0]), this.getValueByIndex(val[1])]
+          value = [this.getValueByIndex(val[0]), this.getValueByIndex(val[1])];
         }
-        this.setValue(value)
+        this.setValue(value);
       } else {
-        val = this.getValueByIndex(val)
+        // eslint-disable-next-line no-param-reassign
+        val = this.getValueByIndex(val);
         if (this.isRange) {
-          this.currentSlider = val > ((this.currentValue[1] - this.currentValue[0]) / 2 + this.currentValue[0]) ? 1 : 0
+          this.currentSlider = val > ((this.currentValue[1] - this.currentValue[0]) / 2 + this.currentValue[0]) ? 1 : 0;
         }
-        this.setCurrentValue(val)
+        this.setCurrentValue(val);
       }
     },
     increment(dir) {
@@ -843,201 +898,203 @@ export default {
     },
     setValue(val, noCb, speed) {
       if (this.isDiff(this.val, val)) {
-        const resetVal = this.limitValue(val)
-        this.val = this.isRange ? resetVal.concat() : resetVal
-        this.computedFixedValue()
-        this.syncValue(noCb)
+        const resetVal = this.limitValue(val);
+        this.val = this.isRange ? resetVal.concat() : resetVal;
+        this.computedFixedValue();
+        this.syncValue(noCb);
       }
-      this.$nextTick(() => this.setPosition(speed))
+      this.$nextTick(() => this.setPosition(speed));
     },
     computedFixedValue() {
       if (!this.isFixed) {
-        this.fixedValue = 0
-        return false
+        this.fixedValue = 0;
+        return false;
       }
-      this.fixedValue = Math.max(this.fixed ? this.currentIndex[1] - this.currentIndex[0] : 0, this.minRange || 0)
+      this.fixedValue = Math.max(this.fixed ? this.currentIndex[1] - this.currentIndex[0] : 0, this.minRange || 0);
     },
     setPosition(speed) {
-      this.flag || this.setTransitionTime(speed === undefined ? this.speed : speed)
+      this.flag || this.setTransitionTime(speed === undefined ? this.speed : speed);
       if (this.isRange) {
-        this.setTransform(this.position[0], this.currentSlider === 1)
-        this.setTransform(this.position[1], this.currentSlider === 0)
+        this.setTransform(this.position[0], this.currentSlider === 1);
+        this.setTransform(this.position[1], this.currentSlider === 0);
       } else {
-        this.setTransform(this.position)
+        this.setTransform(this.position);
       }
-      this.flag || this.setTransitionTime(0)
+      this.flag || this.setTransitionTime(0);
     },
     setTransform(val, isIdleSlider) {
-      const slider = isIdleSlider ? this.idleSlider : this.currentSlider
-      const value = roundToDPR((this.direction === 'vertical' ? ((this.dotAxialSizePx / 2) - val) : (val - (this.dotAxialSizePx / 2))) * (this.reverse ? -1 : 1))
-      const translateValue = this.direction === 'vertical' ? `translate(-50%, ${value}px)` : `translate(${value}px, -50%)`
-      const processSize = this.fixed ? `${this.fixedValue * this.gap}px` : `${slider === 0 ? this.position[1] - val : val - this.position[0]}px`
-      const processPos = this.fixed ? `${slider === 0 ? val : (val - this.fixedValue * this.gap)}px` : `${slider === 0 ? val : this.position[0]}px`
-      this.slider[slider].style.transform = translateValue
-      this.slider[slider].style.WebkitTransform = translateValue
-      this.slider[slider].style.msTransform = translateValue
+      const slider = isIdleSlider ? this.idleSlider : this.currentSlider;
+      const value = roundToDPR((this.direction === "vertical"
+        ? ((this.dotAxialSizePx / 2) - val)
+        : (val - (this.dotAxialSizePx / 2))) * (this.reverse ? -1 : 1));
+      const translateValue = this.direction === "vertical"
+        ? `translate(-50%, ${value}px)`
+        : `translate(${value}px, -50%)`;
+      const processSize = this.fixed
+        ? `${this.fixedValue * this.gap}px`
+        : `${slider === 0
+          ? this.position[1] - val
+          : val - this.position[0]}px`;
+      const processPos = this.fixed
+        ? `${slider === 0
+          ? val
+          : (val - this.fixedValue * this.gap)}px`
+        : `${slider === 0 ? val : this.position[0]}px`;
+      this.slider[slider].style.transform = translateValue;
+      this.slider[slider].style.WebkitTransform = translateValue;
+      this.slider[slider].style.msTransform = translateValue;
       if (this.isRange) {
-        if (this.direction === 'vertical') {
-          this.$refs.process.style.height = processSize
-          this.$refs.process.style[this.reverse ? 'top' : 'bottom'] = processPos
+        if (this.direction === "vertical") {
+          this.$refs.process.style.height = processSize;
+          this.$refs.process.style[this.reverse ? "top" : "bottom"] = processPos;
         } else {
-          this.$refs.process.style.width = processSize
-          this.$refs.process.style[this.reverse ? 'right' : 'left'] = processPos
+          this.$refs.process.style.width = processSize;
+          this.$refs.process.style[this.reverse ? "right" : "left"] = processPos;
         }
+      } else if (this.direction === "vertical") {
+        this.$refs.process.style.height = `${val}px`;
+        this.$refs.process.style[this.reverse ? "top" : "bottom"] = 0;
       } else {
-        if (this.direction === 'vertical') {
-          this.$refs.process.style.height = `${val}px`
-          this.$refs.process.style[this.reverse ? 'top' : 'bottom'] = 0
-        } else {
-          this.$refs.process.style.width = `${val}px`
-          this.$refs.process.style[this.reverse ? 'right' : 'left'] = 0
-        }
+        this.$refs.process.style.width = `${val}px`;
+        this.$refs.process.style[this.reverse ? "right" : "left"] = 0;
       }
     },
     setTransitionTime(time) {
       // In order to avoid browser merge style and modify together
-      time || this.$refs.process.offsetWidth
+      time || this.$refs.process.offsetWidth;
       for (let i = 0; i < this.slider.length; i++) {
-        this.slider[i].style.transitionDuration = `${time}s`
-        this.slider[i].style.WebkitTransitionDuration = `${time}s`
+        this.slider[i].style.transitionDuration = `${time}s`;
+        this.slider[i].style.WebkitTransitionDuration = `${time}s`;
       }
       if (this.isRange) {
-        this.$refs.process.style.transitionDuration = `${time}s`
-        this.$refs.process.style.WebkitTransitionDuration = `${time}s`
+        this.$refs.process.style.transitionDuration = `${time}s`;
+        this.$refs.process.style.WebkitTransitionDuration = `${time}s`;
       } else {
-        this.$refs.process.style.transitionDuration = `${time}s`
-        this.$refs.process.style.WebkitTransitionDuration = `${time}s`
+        this.$refs.process.style.transitionDuration = `${time}s`;
+        this.$refs.process.style.WebkitTransitionDuration = `${time}s`;
       }
     },
     limitValue(val) {
       if (this.data) {
-        return val
+        return val;
       }
-      const inRange = (v) => {
+      const inRange = v => {
         if (v < this.min) {
-          this.printError(`The value of the slider is ${val}, the minimum value is ${this.min}, the value of this slider can not be less than the minimum value`)
-          return this.min
-        } else if (v > this.max) {
-          this.printError(`The value of the slider is ${val}, the maximum value is ${this.max}, the value of this slider can not be greater than the maximum value`)
-          return this.max
+          this.printError(`The value of the slider is ${val}, the minimum value is ${this.min}, the value of this slider can not be less than the minimum value`);
+          return this.min;
+        // eslint-disable-next-line max-statements-per-line
+        } if (v > this.max) {
+          this.printError(`The value of the slider is ${val}, the maximum value is ${this.max}, the value of this slider can not be greater than the maximum value`);
+          return this.max;
         }
-        return v
-      }
+        return v;
+      };
       if (this.isRange) {
-        return val.map((v) => inRange(v))
-      } else {
-        return inRange(val)
+        return val.map(v => inRange(v));
       }
+      return inRange(val);
+
     },
     isActive(index) {
-      return index >= this.indexRange[0] && index <= this.indexRange[1]
+      return index >= this.indexRange[0] && index <= this.indexRange[1];
     },
     syncValue(noCb) {
-      let val = this.isRange ? this.val.concat() : this.val
-      this.$emit('input', val)
-      this.keydownFlag && this.$emit('on-keypress', val)
-      noCb || this.$emit('callback', val)
+      const val = this.isRange ? this.val.concat() : this.val;
+      this.$emit("input", val);
+      this.keydownFlag && this.$emit("on-keypress", val);
+      noCb || this.$emit("callback", val);
     },
     getValue() {
-      return this.val
+      return this.val;
     },
     getIndex() {
-      return this.currentIndex
+      return this.currentIndex;
     },
     getStaticData() {
       if (this.$refs.elem) {
-        this.size = this.direction === 'vertical' ? this.$refs.elem.offsetHeight : this.$refs.elem.offsetWidth
-        this.dotAxialSizePx = this.direction === 'vertical' ? this.$refs.dot0.clientHeight : this.$refs.dot0.clientWidth;
+        this.size = this.direction === "vertical" ? this.$refs.elem.offsetHeight : this.$refs.elem.offsetWidth;
+        this.dotAxialSizePx = this.direction === "vertical"
+          ? this.$refs.dot0.clientHeight
+          : this.$refs.dot0.clientWidth;
       }
     },
     refresh() {
       if (this.$refs.elem) {
-        this.getStaticData()
-        this.computedFixedValue()
-        this.setPosition(0)
+        this.getStaticData();
+        this.computedFixedValue();
+        this.setPosition(0);
       }
     },
     printError(msg) {
       if (this.debug) {
-        console.error(`[VueSlider error]: ${msg}`)
+        // eslint-disable-next-line no-console
+        console.error(`[VueSlider error]: ${msg}`);
       }
     },
     handleOverlapTooltip() {
-      const isDirectionSame = this.tooltipDirection[0] === this.tooltipDirection[1]
+      const isDirectionSame = this.tooltipDirection[0] === this.tooltipDirection[1];
       if (this.isRange && isDirectionSame) {
-        const tooltip0 = this.reverse ? this.$refs.tooltip1 : this.$refs.tooltip0
-        const tooltip1 = this.reverse ? this.$refs.tooltip0 : this.$refs.tooltip1
-        const tooltip0Rect = tooltip0.getBoundingClientRect()
-        const tooltip1Rect = tooltip1.getBoundingClientRect()
-        const tooltip0Right = tooltip0Rect.right
-        const tooltip1Left = tooltip1Rect.left
-        const tooltip0Y = tooltip0Rect.top
-        const tooltip1Y = tooltip1Rect.top + tooltip1Rect.height
-        const horizontalOverlap = this.direction === 'horizontal' && tooltip0Right > tooltip1Left
-        const verticalOverlap = this.direction === 'vertical' && tooltip1Y > tooltip0Y
+        const tooltip0 = this.reverse ? this.$refs.tooltip1 : this.$refs.tooltip0;
+        const tooltip1 = this.reverse ? this.$refs.tooltip0 : this.$refs.tooltip1;
+        const tooltip0Rect = tooltip0.getBoundingClientRect();
+        const tooltip1Rect = tooltip1.getBoundingClientRect();
+        const tooltip0Right = tooltip0Rect.right;
+        const tooltip1Left = tooltip1Rect.left;
+        const tooltip0Y = tooltip0Rect.top;
+        const tooltip1Y = tooltip1Rect.top + tooltip1Rect.height;
+        const horizontalOverlap = this.direction === "horizontal" && tooltip0Right > tooltip1Left;
+        const verticalOverlap = this.direction === "vertical" && tooltip1Y > tooltip0Y;
         if (horizontalOverlap || verticalOverlap) {
-          this.handleDisplayMergedTooltip(true)
+          this.handleDisplayMergedTooltip(true);
         } else {
-          this.handleDisplayMergedTooltip(false)
+          this.handleDisplayMergedTooltip(false);
         }
       }
     },
     handleDisplayMergedTooltip(show) {
-      const tooltip0 = this.$refs.tooltip0
-      const tooltip1 = this.$refs.tooltip1
-      const mergedTooltip = this.$refs.process.getElementsByClassName('vue-merged-tooltip')[0]
+      const tooltip0 = this.$refs.tooltip0;
+      const tooltip1 = this.$refs.tooltip1;
+      const mergedTooltip = this.$refs.process.getElementsByClassName("vue-merged-tooltip")[0];
       if (show) {
-        tooltip0.style.visibility = 'hidden'
-        tooltip1.style.visibility = 'hidden'
-        mergedTooltip.style.visibility = 'visible'
+        tooltip0.style.visibility = "hidden";
+        tooltip1.style.visibility = "hidden";
+        mergedTooltip.style.visibility = "visible";
       } else {
-        tooltip0.style.visibility = 'visible'
-        tooltip1.style.visibility = 'visible'
-        mergedTooltip.style.visibility = 'hidden'
+        tooltip0.style.visibility = "visible";
+        tooltip1.style.visibility = "visible";
+        mergedTooltip.style.visibility = "hidden";
       }
     },
     dotContents() {
-      if (Notations.current.name === "Blind" || Theme.current().name === "S9" ) return "";
+      if (Notations.current.name === "Blind" || Theme.current().name === "S9") return "";
       // Doesn't work if the slider needs to show more precision than integers,
       // but I don't think we have any such sliders.
-      return this.valueInDot ? Math.round(this.getValue()) : '';
+      return this.valueInDot ? Math.round(this.getValue()) : "";
     },
-  },
-  mounted() {
-    this.isComponentExists = true
-    if (typeof window === 'undefined' || typeof document === 'undefined') {
-      return this.printError('window or document is undefined, can not be initialization.')
-    }
-    this.$nextTick(() => {
-      if (this.isComponentExists) {
-        this.getStaticData()
-        this.setValue(this.limitValue(this.value), true, this.startAnimation ? this.speed : 0)
-        this.bindEvents()
-        if (this.isRange && this.tooltipMerge && !this.startAnimation) {
-          this.$nextTick(() => {
-            this.handleOverlapTooltip()
-          })
-        }
-      }
-    })
-    this.isMounted = true
-  },
-  beforeDestroy() {
-    this.isComponentExists = false
-    this.unbindEvents()
   }
 };
 </script>
 
 <template>
-  <div :class="['l-ad-slider', flowDirection, disabledClass, { 'l-ad-slider--has-label': piecewiseLabel }]"
-       v-show="show">
-    <PlusMinusButton v-if="plusMinusButtons" type="minus" @click="increment(-1)"/>
-    <div ref="wrap"
-         :class="['l-ad-slider__wrap', stateClass]"
-         :style="[wrapStyles, boolDisabled ? disabledStyle : null]"
-         @click="wrapClick">
-      <div ref="elem" aria-hidden="true" :class="['l-ad-slider__bg', 'c-ad-slider__bg', bgClass]"
+  <div
+    v-show="show"
+    :class="['l-ad-slider', flowDirection, disabledClass, { 'l-ad-slider--has-label': piecewiseLabel }]"
+  >
+    <PlusMinusButton
+      v-if="plusMinusButtons"
+      type="minus"
+      @click="increment(-1)"
+    />
+    <div
+      ref="wrap"
+      :class="['l-ad-slider__wrap', stateClass]"
+      :style="[wrapStyles, boolDisabled ? disabledStyle : null]"
+      @click="wrapClick"
+    >
+      <div
+        ref="elem"
+        aria-hidden="true"
+        :class="['l-ad-slider__bg', 'c-ad-slider__bg', bgClass]"
         :style="[elemStyles, bgStyle, draggableStyle]"
         @mousedown="moveStart($event, 0, true)"
         @touchstart="moveStart($event, 0, true)"
@@ -1047,12 +1104,12 @@ export default {
             ref="dot0"
             key="dot0"
             :class="[tooltipStatus, 'l-ad-slider__dot', 'c-ad-slider__dot',
-            {
-              'l-ad-slider__dot--focus': focusFlag && focusSlider === 0,
-              'l-ad-slider__dot--dragging': flag && currentSlider === 0,
-              'l-ad-slider__dot--disabled': !boolDisabled && disabledArray[0]
-            }
-          ]"
+                     {
+                       'l-ad-slider__dot--focus': focusFlag && focusSlider === 0,
+                       'l-ad-slider__dot--dragging': flag && currentSlider === 0,
+                       'l-ad-slider__dot--disabled': !boolDisabled && disabledArray[0]
+                     }
+            ]"
             :style="dotStyles"
             @mousedown="moveStart"
             @touchstart="moveStart"
@@ -1060,27 +1117,33 @@ export default {
             <div
               :class="['l-ad-slider__dot-handle', 'c-ad-slider__dot-handle', dotClass]"
               :style="[
-              (!boolDisabled && disabledArray[0])
-              ? disabledDotStyles[0]
-              : null,
-              sliderStyles[0],
-              focusFlag && focusSlider === 0 ? focusStyles[0]: null
-            ]"
-            ></div>
-            <div ref="tooltip0" :class="['ad-slider-tooltip-' + tooltipDirection[0], 'ad-slider-tooltip-wrap']">
-              <span class="ad-slider-tooltip" :style="tooltipStyles[0]">{{ xformatter ? formatting(val[0]) : val[0] }}</span>
+                (!boolDisabled && disabledArray[0])
+                  ? disabledDotStyles[0]
+                  : null,
+                sliderStyles[0],
+                focusFlag && focusSlider === 0 ? focusStyles[0]: null
+              ]"
+            />
+            <div
+              ref="tooltip0"
+              :class="['ad-slider-tooltip-' + tooltipDirection[0], 'ad-slider-tooltip-wrap']"
+            >
+              <span
+                class="ad-slider-tooltip"
+                :style="tooltipStyles[0]"
+              >{{ xformatter ? formatting(val[0]) : val[0] }}</span>
             </div>
           </div>
           <div
             ref="dot1"
             key="dot1"
             :class="[tooltipStatus, 'l-ad-slider__dot', 'c-ad-slider__dot',
-            {
-              'l-ad-slider__dot--focus': focusFlag && focusSlider === 1,
-              'l-ad-slider__dot--dragging': flag && currentSlider === 1,
-              'l-ad-slider__dot--disabled': !boolDisabled && disabledArray[1]
-            }
-          ]"
+                     {
+                       'l-ad-slider__dot--focus': focusFlag && focusSlider === 1,
+                       'l-ad-slider__dot--dragging': flag && currentSlider === 1,
+                       'l-ad-slider__dot--disabled': !boolDisabled && disabledArray[1]
+                     }
+            ]"
             :style="dotStyles"
             @mousedown="moveStart($event, 1)"
             @touchstart="moveStart($event, 1)"
@@ -1088,15 +1151,21 @@ export default {
             <div
               :class="['l-ad-slider__dot-handle', 'c-ad-slider__dot-handle', dotClass]"
               :style="[
-              (!boolDisabled && disabledArray[1])
-              ? disabledDotStyles[1]
-              : null,
-              sliderStyles[1],
-              focusFlag && focusSlider === 1 ? focusStyles[1]: null
-            ]"
-            ></div>
-            <div ref="tooltip1" :class="['ad-slider-tooltip-' + tooltipDirection[1], 'ad-slider-tooltip-wrap']">
-              <span class="ad-slider-tooltip" :style="tooltipStyles[1]">{{ xformatter ? formatting(val[1]) : val[1] }}</span>
+                (!boolDisabled && disabledArray[1])
+                  ? disabledDotStyles[1]
+                  : null,
+                sliderStyles[1],
+                focusFlag && focusSlider === 1 ? focusStyles[1]: null
+              ]"
+            />
+            <div
+              ref="tooltip1"
+              :class="['ad-slider-tooltip-' + tooltipDirection[1], 'ad-slider-tooltip-wrap']"
+            >
+              <span
+                class="ad-slider-tooltip"
+                :style="tooltipStyles[1]"
+              >{{ xformatter ? formatting(val[1]) : val[1] }}</span>
             </div>
           </div>
         </template>
@@ -1105,36 +1174,41 @@ export default {
             ref="dot0"
             key="dot0"
             :class="[tooltipStatus, 'l-ad-slider__dot', 'c-ad-slider__dot',
-            {
-              'l-ad-slider__dot--focus': focusFlag && focusSlider === 0,
-              'l-ad-slider__dot--dragging': flag && currentSlider === 0
-            }
-          ]"
+                     {
+                       'l-ad-slider__dot--focus': focusFlag && focusSlider === 0,
+                       'l-ad-slider__dot--dragging': flag && currentSlider === 0
+                     }
+            ]"
             :style="dotStyles"
             @mousedown="moveStart"
             @touchstart="moveStart"
           >
-            <div :class="['l-ad-slider__dot-handle', 'c-ad-slider__dot-handle', dotClass]"
-                 :style="[sliderStyles, focusFlag && focusSlider === 0 ? focusStyles : null]">
-              {{dotContents(0)}}
+            <div
+              :class="['l-ad-slider__dot-handle', 'c-ad-slider__dot-handle', dotClass]"
+              :style="[sliderStyles, focusFlag && focusSlider === 0 ? focusStyles : null]"
+            >
+              {{ dotContents(0) }}
             </div>
             <div :class="['ad-slider-tooltip-' + tooltipDirection, 'ad-slider-tooltip-wrap']">
-              <span class="ad-slider-tooltip" :style="tooltipStyles">{{ xformatter ? formatting(val) : val }}</span>
+              <span
+                class="ad-slider-tooltip"
+                :style="tooltipStyles"
+              >{{ xformatter ? formatting(val) : val }}</span>
             </div>
           </div>
         </template>
         <ul class="ad-slider-piecewise">
           <li
             v-for="(piecewiseObj, index) in piecewiseDotWrap"
+            :key="index"
             class="ad-slider-piecewise-item"
             :style="[piecewiseDotStyle, piecewiseObj.style]"
-            :key="index"
           >
             <span
               v-if="piecewise"
               class="ad-slider-piecewise-dot"
               :style="[ piecewiseStyle, isActive(piecewiseObj.index) ? piecewiseActiveStyle : null ]"
-            ></span>
+            />
 
             <span
               v-if="piecewiseLabel"
@@ -1156,13 +1230,20 @@ export default {
             :class="['vue-merged-tooltip', 'ad-slider-tooltip-' + tooltipDirection[0], 'ad-slider-tooltip-wrap']"
             :style="tooltipMergedPosition"
           >
-            <span class="ad-slider-tooltip" :style="tooltipStyles">
+            <span
+              class="ad-slider-tooltip"
+              :style="tooltipStyles"
+            >
               {{ tooltipFormatHelper }}
             </span>
           </div>
         </div>
       </div>
     </div>
-    <PlusMinusButton v-if="plusMinusButtons" type="plus" @click="increment(1)"/>
+    <PlusMinusButton
+      v-if="plusMinusButtons"
+      type="plus"
+      @click="increment(1)"
+    />
   </div>
 </template>
diff --git a/src/components/modals/StdStoreModal.vue b/src/components/modals/StdStoreModal.vue
index 61cd16f085..e9e1e82806 100644
--- a/src/components/modals/StdStoreModal.vue
+++ b/src/components/modals/StdStoreModal.vue
@@ -31,7 +31,10 @@ export default {
       Support The Developer - coins
     </template>
     <span v-if="macPurchaser">
-      <button class="o-shop-button-button" @click="macConfirm()">Confirm Purchase to Receive STDs</button>
+      <button
+        class="o-shop-button-button"
+        @click="macConfirm()"
+      >Confirm Purchase to Receive STDs</button>
       <br><span>(Required on Mac)</span><br>
     </span>
     <div class="l-modal-store-content">
diff --git a/src/components/modals/StdStoreRow.vue b/src/components/modals/StdStoreRow.vue
index d3ca0379f6..ae393d1296 100644
--- a/src/components/modals/StdStoreRow.vue
+++ b/src/components/modals/StdStoreRow.vue
@@ -1,7 +1,7 @@
 <script>
+import Payments from "@/core/payments";
 import { STEAM } from "@/env";
 import { SteamRuntime } from "@/steam";
-import Payments from "@/core/payments";
 
 export default {
   name: "StdStoreRow",
diff --git a/src/components/tabs/autobuyers/AutobuyerInput.vue b/src/components/tabs/autobuyers/AutobuyerInput.vue
index 320917904f..6f04875396 100644
--- a/src/components/tabs/autobuyers/AutobuyerInput.vue
+++ b/src/components/tabs/autobuyers/AutobuyerInput.vue
@@ -74,6 +74,7 @@ export default {
         SecretAchievement(28).unlock();
       }
       if (this.isValid) {
+        // eslint-disable-next-line vue/no-mutating-props
         this.autobuyer[this.property] = this.typeFunctions.copyValue(this.actualValue);
       } else {
         this.updateActualValue();
diff --git a/src/components/tabs/automator/AutomatorBlockSingleRow.vue b/src/components/tabs/automator/AutomatorBlockSingleRow.vue
index 8f1cbf3967..99ef66b63e 100644
--- a/src/components/tabs/automator/AutomatorBlockSingleRow.vue
+++ b/src/components/tabs/automator/AutomatorBlockSingleRow.vue
@@ -147,12 +147,8 @@ export default {
         X
       </div>
     </div>
-    <draggable
-      v-if="block.nested"
-      v-model="block.nest"
-      class="l-automator-nested-block"
-      group="code-blocks"
-    >
+    <!-- eslint-disable-next-line vue/no-mutating-props, vue/max-attributes-per-line -->
+    <draggable v-if="block.nested" v-model="block.nest" class="l-automator-nested-block" group="code-blocks">
       <AutomatorBlockSingleRow
         v-for="subblock in block.nest"
         :key="subblock.id"
diff --git a/src/components/tabs/automator/AutomatorEventLog.vue b/src/components/tabs/automator/AutomatorEventLog.vue
index 2609eecf7b..32d39e47d6 100644
--- a/src/components/tabs/automator/AutomatorEventLog.vue
+++ b/src/components/tabs/automator/AutomatorEventLog.vue
@@ -15,7 +15,7 @@ export default {
   computed: {
     events() {
       // eslint-disable-next-line no-nested-ternary
-      const sorted = this.unsortedEvents.sort((a, b) => (a.timestamp === b.timestamp
+      const sorted = this.unsortedEvents.slice(0).sort((a, b) => (a.timestamp === b.timestamp
         ? (a.thisReality === b.thisReality
           ? a.line - b.line
           : a.thisReality - b.thisReality)
diff --git a/src/components/tabs/glyphs/sidebar/GlyphFilterPanel.vue b/src/components/tabs/glyphs/sidebar/GlyphFilterPanel.vue
index 541a471450..0fff3d786b 100644
--- a/src/components/tabs/glyphs/sidebar/GlyphFilterPanel.vue
+++ b/src/components/tabs/glyphs/sidebar/GlyphFilterPanel.vue
@@ -22,6 +22,7 @@ export default {
       // Note: there are two units at play: strength is from 1..3.5+; rarity is 0..100
       rarityThresholds: GLYPH_TYPES.mapToObject(e => e, () => 0),
       autoRealityForFilter: player.options.autoRealityForFilter,
+      isRefining: false,
     };
   },
   computed: {
@@ -58,8 +59,8 @@ export default {
     },
     questionmarkTooltip() {
       return `All Glyph choices are given a score and compared to a threshold based on the chosen mode. 
-        The Glyph with the highest score is picked, but will still be Sacrificed if below the threshold.
-        (click for more detail)`;
+        The Glyph with the highest score is picked, but will still be ${this.isRefining ? "Refined" : "Sacrificed"}
+        if below the threshold. (click for more detail)`;
     },
     autoRealityTooltip() {
       return `If Auto-Reality is on, ignore all other settings and immediately Reality if no upcoming
@@ -78,6 +79,7 @@ export default {
       }
       this.lockedTypes = GlyphTypes.locked.map(e => e.id);
       this.alchemyUnlocked = Ra.unlocks.unlockGlyphAlchemy.canBeApplied;
+      this.isRefining = GlyphSacrificeHandler.isRefining;
     },
     optionClass(idx) {
       const icon = this.modeIcon(idx);
diff --git a/src/components/tabs/options-visual/OptionsVisualTab.vue b/src/components/tabs/options-visual/OptionsVisualTab.vue
index 8c892dcc9e..f17e02eb31 100644
--- a/src/components/tabs/options-visual/OptionsVisualTab.vue
+++ b/src/components/tabs/options-visual/OptionsVisualTab.vue
@@ -4,8 +4,8 @@ import OpenModalHotkeysButton from "@/components/OpenModalHotkeysButton";
 import OptionsButton from "@/components/OptionsButton";
 import PrimaryToggleButton from "@/components/PrimaryToggleButton";
 import SelectNotationDropdown from "@/components/tabs/options-visual/SelectNotationDropdown";
-import SelectThemeDropdown from "@/components/tabs/options-visual/SelectThemeDropdown";
 import SelectSidebarDropdown from "@/components/tabs/options-visual/SelectSidebarDropdown";
+import SelectThemeDropdown from "@/components/tabs/options-visual/SelectThemeDropdown";
 import UpdateRateSlider from "./UpdateRateSlider";
 
 export default {
diff --git a/src/components/tabs/speedrun-milestones/PreviousSpeedrunInfo.vue b/src/components/tabs/speedrun-milestones/PreviousSpeedrunInfo.vue
index 7d1c2333ad..97c23a34f5 100644
--- a/src/components/tabs/speedrun-milestones/PreviousSpeedrunInfo.vue
+++ b/src/components/tabs/speedrun-milestones/PreviousSpeedrunInfo.vue
@@ -6,6 +6,7 @@ export default {
     prevRunInfo: {
       type: Object,
       required: false,
+      // eslint-disable-next-line no-empty-function
       default: () => {}
     },
     index: {
diff --git a/src/components/tabs/speedrun-milestones/SpeedrunMilestoneSingle.vue b/src/components/tabs/speedrun-milestones/SpeedrunMilestoneSingle.vue
index 725fc7420a..7f361c5b56 100644
--- a/src/components/tabs/speedrun-milestones/SpeedrunMilestoneSingle.vue
+++ b/src/components/tabs/speedrun-milestones/SpeedrunMilestoneSingle.vue
@@ -29,7 +29,7 @@ export default {
     },
     timeDisplay() {
       return this.time
-        ? `Completed in ${TimeSpan.fromMilliseconds(this.time).toStringShort(true, true)}`
+        ? `Completed in ${TimeSpan.fromMilliseconds(this.time).toStringShort(true, true, true)}`
         : "Not reached yet";
     },
     classObject() {
diff --git a/src/core/async-utils.js b/src/core/async-utils.js
index 81758a1719..173530c16f 100644
--- a/src/core/async-utils.js
+++ b/src/core/async-utils.js
@@ -47,6 +47,7 @@ window.Async = {
    * @param {function} [config.then] Run after everything is done
    * @returns {Promise|undefined}
    */
+  // eslint-disable-next-line consistent-return
   run(fun, maxIter, config) {
     if (this.enabled) {
       // Disable async if we're already doing async
diff --git a/src/core/autobuyers/autobuyers.js b/src/core/autobuyers/autobuyers.js
index 8e992c4c2e..20d5633892 100644
--- a/src/core/autobuyers/autobuyers.js
+++ b/src/core/autobuyers/autobuyers.js
@@ -1,3 +1,4 @@
+import { EPMultAutobuyerState, IPMultAutobuyerState } from "./prestige-currency-multiplier-autobuyer";
 import { AnnihilationAutobuyerState } from "./annihilation-autobuyer";
 import { AntimatterDimensionAutobuyerState } from "./antimatter-dimension-autobuyer";
 import { BigCrunchAutobuyerState } from "./big-crunch-autobuyer";
@@ -10,7 +11,6 @@ import { EternityAutobuyerState } from "./eternity-autobuyer";
 import { GalaxyAutobuyerState } from "./galaxy-autobuyer";
 import { ImaginaryUpgradeAutobuyerState } from "./imaginary-upgrade-autobuyer";
 import { InfinityDimensionAutobuyerState } from "./infinity-dimension-autobuyer";
-import { EPMultAutobuyerState, IPMultAutobuyerState } from "./prestige-currency-multiplier-autobuyer";
 import { RealityAutobuyerState } from "./reality-autobuyer";
 import { RealityUpgradeAutobuyerState } from "./reality-upgrade-autobuyer";
 import { ReplicantiGalaxyAutobuyerState } from "./replicanti-galaxy-autobuyer";
diff --git a/src/core/automator/automator-backend.js b/src/core/automator/automator-backend.js
index 2004c5201e..9f689f4f85 100644
--- a/src/core/automator/automator-backend.js
+++ b/src/core/automator/automator-backend.js
@@ -964,7 +964,7 @@ export const AutomatorBackend = {
     this.state.mode = AUTOMATOR_MODE.PAUSE;
   },
 
-  start(scriptID = this.state.topLevelScript, initialMode = AUTOMATOR_MODE.RUN, compile = true) {
+  start(scriptID = this.state.topLevelScript, initialMode = AUTOMATOR_MODE.RUN, compileScript = true) {
     // Automator execution behaves oddly across new games, so we explicitly stop it from running if not unlocked
     if (!Player.automatorUnlocked) return;
     this.hasJustCompleted = false;
@@ -972,7 +972,7 @@ export const AutomatorBackend = {
     player.reality.automator.execTimer = 0;
     const scriptObject = this.findScript(scriptID);
     if (!scriptObject) return;
-    if (compile) scriptObject.compile();
+    if (compileScript) scriptObject.compile();
     if (scriptObject.commands) {
       this.reset(scriptObject.commands);
       this.state.mode = initialMode;
diff --git a/src/core/black-hole.js b/src/core/black-hole.js
index cee79a43c2..04ddb53fa0 100644
--- a/src/core/black-hole.js
+++ b/src/core/black-hole.js
@@ -1,5 +1,4 @@
 import { DC } from "./constants";
-import { SpeedrunMilestones } from "./speedrun";
 
 class BlackHoleUpgradeState {
   constructor(config) {
diff --git a/src/core/break-infinity-upgrades.js b/src/core/break-infinity-upgrades.js
index 84683523ab..6de7de2c2f 100644
--- a/src/core/break-infinity-upgrades.js
+++ b/src/core/break-infinity-upgrades.js
@@ -1,5 +1,5 @@
 import { RebuyableMechanicState, SetPurchasableMechanicState } from "./game-mechanics";
-import { SpeedrunMilestones } from "./speedrun";
+import { SpeedrunMilestone } from "./speedrun";
 
 export class BreakInfinityUpgradeState extends SetPurchasableMechanicState {
   get currency() {
@@ -12,7 +12,7 @@ export class BreakInfinityUpgradeState extends SetPurchasableMechanicState {
 
   onPurchased() {
     if (this.id === "postGalaxy") {
-      SpeedrunMilestones(7).tryComplete();
+      SpeedrunMilestone.upgrade5e11IP.tryComplete();
       PelleStrikes.powerGalaxies.trigger();
     }
   }
diff --git a/src/core/celestials/V.js b/src/core/celestials/V.js
index f85e0238b1..0f62dcb1b0 100644
--- a/src/core/celestials/V.js
+++ b/src/core/celestials/V.js
@@ -1,7 +1,7 @@
 import { BitUpgradeState, GameMechanicState } from "../game-mechanics";
 import { GameDatabase } from "../secret-formula/game-database";
 
-import { SpeedrunMilestones } from "../speedrun";
+import { SpeedrunMilestone } from "../speedrun";
 
 import { Quotes } from "./quotes";
 
@@ -166,7 +166,7 @@ export const V = {
       for (const unlock of VRunUnlocks.all) {
         unlock.tryComplete();
       }
-      if (this.spaceTheorems >= 36) SpeedrunMilestones(22).tryComplete();
+      if (this.spaceTheorems >= 36) SpeedrunMilestone.complete36VAchievement.tryComplete();
     }
 
     if (VUnlocks.raUnlock.canBeApplied && !Ra.unlocks.autoTP.canBeApplied) {
diff --git a/src/core/celestials/pelle/rifts.js b/src/core/celestials/pelle/rifts.js
index 59c6020cc4..b447bde717 100644
--- a/src/core/celestials/pelle/rifts.js
+++ b/src/core/celestials/pelle/rifts.js
@@ -1,8 +1,10 @@
 import { GameMechanicState } from "../../utils";
 
 class RiftMilestoneState extends GameMechanicState {
-
-  lastChecked = false;
+  constructor(config) {
+    super(config);
+    this.lastChecked = false;
+  }
 
   get requirement() {
     return this.config.requirement;
diff --git a/src/core/crash.js b/src/core/crash.js
index 5ff398e35e..b0456b86c5 100644
--- a/src/core/crash.js
+++ b/src/core/crash.js
@@ -1,5 +1,3 @@
-import { DEV } from "@/env";
-
 window.NotImplementedError = class NotImplementedError extends Error {
   constructor() {
     super("The method is not implemented.");
diff --git a/src/core/currency.js b/src/core/currency.js
index cb16d1ce79..ba0cd2be93 100644
--- a/src/core/currency.js
+++ b/src/core/currency.js
@@ -198,7 +198,6 @@ window.DecimalCurrency = DecimalCurrency;
 
 Currency.antimatter = new class extends DecimalCurrency {
   get value() { return player.antimatter; }
-
   set value(value) {
     if (InfinityChallenges.nextIC) InfinityChallenges.notifyICUnlock(value);
     if (GameCache.cheapestAntimatterAutobuyer.value && value.gte(GameCache.cheapestAntimatterAutobuyer.value)) {
diff --git a/src/core/devtools.js b/src/core/devtools.js
index 0ee652f5ab..1a1009ebbc 100644
--- a/src/core/devtools.js
+++ b/src/core/devtools.js
@@ -4,8 +4,7 @@ import { DC } from "./constants";
 import FullScreenAnimationHandler from "./full-screen-animation-handler";
 
 /* eslint-disable no-console */
-// Disabling no-console here seems
-// reasonable, since these are the devtools after all
+// Disabling no-console here seems reasonable, since these are the devtools after all
 export const dev = {};
 
 dev.hardReset = function() {
@@ -17,35 +16,28 @@ dev.giveAllAchievements = function() {
   for (const achievement of allAchievements) achievement.unlock();
 };
 
-// Know that both dev.doubleEverything and dev.tripleEverything are both broken
-// with this error https://i.imgur.com/ZMEBNTv.png
-
-dev.doubleEverything = function() {
+dev.multiplyEverythingBy = function(amount) {
+  // eslint-disable-next-line no-param-reassign
+  amount = new Decimal(amount);
   Object.keys(player).forEach(key => {
-    if (typeof player[key] === "number") player[key] *= 2;
-    if (typeof player[key] === "object" && player[key].constructor !== Object) player[key] = player[key].times(2);
-    if (typeof player[key] === "object" && !isFinite(player[key])) {
+    if (typeof player[key] === "number") player[key] *= amount.toNumber();
+    if (player[key] instanceof Decimal && Decimal.isFinite(player[key])) player[key] = player[key].times(amount);
+    if (typeof player[key] === "object" && !Decimal.isFinite(player[key])) {
       Object.keys(player[key]).forEach(key2 => {
-        if (typeof player[key][key2] === "number") player[key][key2] *= 2;
-        if (typeof player[key][key2] === "object" && player[key][key2].constructor !== Object)
-          player[key][key2] = player[key][key2].times(2);
+        if (typeof player[key][key2] === "number" && !Decimal.isFinite(player[key][key2]))
+          player[key][key2] *= amount.toNumber();
+        if (player[key][key2] instanceof Decimal) player[key][key2] = player[key][key2].times(amount);
       });
     }
   });
 };
 
+dev.doubleEverything = function() {
+  dev.multiplyEverythingBy(2);
+};
+
 dev.tripleEverything = function() {
-  Object.keys(player).forEach(key => {
-    if (typeof player[key] === "number") player[key] *= 3;
-    if (typeof player[key] === "object" && player[key].constructor !== Object) player[key] = player[key].times(3);
-    if (typeof player[key] === "object" && !isFinite(player[key])) {
-      Object.keys(player[key]).forEach(key3 => {
-        if (typeof player[key][key3] === "number") player[key][key3] *= 3;
-        if (typeof player[key][key3] === "object" && player[key][key3].constructor !== Object)
-          player[key][key3] = player[key][key3].times(3);
-      });
-    }
-  });
+  dev.multiplyEverythingBy(3);
 };
 
 dev.barrelRoll = function() {
diff --git a/src/core/dilation.js b/src/core/dilation.js
index 9e5228f87a..c130fc896d 100644
--- a/src/core/dilation.js
+++ b/src/core/dilation.js
@@ -1,7 +1,7 @@
 import { RebuyableMechanicState, SetPurchasableMechanicState } from "./game-mechanics";
 import { DC } from "./constants";
 import FullScreenAnimationHandler from "./full-screen-animation-handler";
-import { SpeedrunMilestones } from "./speedrun";
+import { SpeedrunMilestone } from "./speedrun";
 
 export function animateAndDilate() {
   FullScreenAnimationHandler.display("a-dilate", 2);
@@ -230,7 +230,7 @@ class DilationUpgradeState extends SetPurchasableMechanicState {
 
   onPurchased() {
     if (this.id === 4) player.dilation.totalTachyonGalaxies *= 2;
-    if (this.id === 10) SpeedrunMilestones(15).tryComplete();
+    if (this.id === 10) SpeedrunMilestone.upgradeTTgen.tryComplete();
   }
 }
 
diff --git a/src/core/eternity.js b/src/core/eternity.js
index 60d2c357b8..cfbec80440 100644
--- a/src/core/eternity.js
+++ b/src/core/eternity.js
@@ -254,9 +254,7 @@ export class EternityMilestoneState {
 }
 export const EternityMilestone = mapGameDataToObject(
   GameDatabase.eternity.milestones,
-  config => (config.isBaseResource
-    ? new EternityMilestoneState(config)
-    : new EternityMilestoneState(config))
+  config => new EternityMilestoneState(config)
 );
 
 class EternityUpgradeState extends SetPurchasableMechanicState {
diff --git a/src/core/extensions.js b/src/core/extensions.js
index a10e94c462..55fc9ddb6f 100644
--- a/src/core/extensions.js
+++ b/src/core/extensions.js
@@ -1,7 +1,7 @@
+import { isDecimal } from "../utility/type-check";
+
 Array.prototype.distinct = function() {
-    return this.filter(function (value, index, self) {
-        return self.indexOf(value) === index;
-    });
+  return this.filter((value, index, self) => self.indexOf(value) === index);
 };
 
 Math.wrap = function(number, min, max) {
@@ -73,17 +73,18 @@ Decimal.prototype.copyFrom = function(decimal) {
 };
 
 window.copyToClipboard = (function() {
-  let el = document.createElement('textarea');
+  const el = document.createElement("textarea");
   document.body.appendChild(el);
   el.style.position = "absolute";
-  el.style.left = '-9999999px';
-  el.setAttribute('readonly', '');
+  el.style.left = "-9999999px";
+  el.setAttribute("readonly", "");
   return function(str) {
     try {
       el.value = str;
       el.select();
-      return document.execCommand('copy');
-    } catch(ex) {
+      return document.execCommand("copy");
+    } catch (ex) {
+      // eslint-disable-next-line no-console
       console.log(ex);
       return false;
     }
@@ -91,8 +92,8 @@ window.copyToClipboard = (function() {
 }());
 
 window.safeCall = function safeCall(fn) {
-    if (fn) fn();
-}
+  if (fn) fn();
+};
 
 String.prototype.capitalize = function() {
   return this.toLowerCase().replace(/^\w/u, c => c.toUpperCase());
@@ -158,12 +159,12 @@ Array.prototype.last = function(predicate) {
 Array.prototype.mapToObject = function(keyFun, valueFun) {
   if (typeof keyFun !== "function" || typeof valueFun !== "function")
     throw "keyFun and valueFun must be functions";
-  let out = {}
+  const out = {};
   for (let idx = 0; idx < this.length; ++idx) {
     out[keyFun(this[idx], idx)] = valueFun(this[idx], idx);
   }
   return out;
-}
+};
 
 /**
  * @type {number[]}
@@ -289,3 +290,8 @@ Array.fromBitmask = function(mask) {
 String.isWhiteSpace = function(value) {
   return value && !value.trim();
 };
+
+Decimal.isFinite = function(value) {
+  if (!isDecimal(value)) return isFinite(value);
+  return (isFinite(value.m) || isFinite(value.e)) && !(value.e >= 9e15);
+};
\ No newline at end of file
diff --git a/src/core/format.js b/src/core/format.js
index 98f723ea5c..5de499e80c 100644
--- a/src/core/format.js
+++ b/src/core/format.js
@@ -6,13 +6,14 @@ function isEND() {
   return player.celestials.pelle.doomed && Math.random() < threshold;
 }
 
-window.format = function format(value, places = 0, placesUnder1000 = 0) {
-  if (isEND()) return "END";
+// eslint-disable-next-line max-params
+window.format = function format(value, places = 0, placesUnder1000 = 0, bypassEND = false) {
+  if (isEND() && !bypassEND) return "END";
   return Notations.current.format(value, places, placesUnder1000, 3);
 };
 
-window.formatInt = function formatInt(value) {
-  if (isEND()) return "END";
+window.formatInt = function formatInt(value, bypassEND = false) {
+  if (isEND() && !bypassEND) return "END";
   // Suppress painful formatting for Standard because it's the most commonly used and arguably "least painful"
   // of the painful notations. Prevents numbers like 5004 from appearing imprecisely as "5.00 K" for example
   if (Notations.current.isPainful && Notations.current.name !== "Standard") {
@@ -21,16 +22,17 @@ window.formatInt = function formatInt(value) {
   return formatWithCommas(typeof value === "number" ? value.toFixed(0) : value.toNumber().toFixed(0));
 };
 
-window.formatFloat = function formatFloat(value, digits) {
-  if (isEND()) return "END";
+window.formatFloat = function formatFloat(value, digits, bypassEND = false) {
+  if (isEND() && !bypassEND) return "END";
   if (Notations.current.isPainful) {
     return format(value, Math.max(2, digits), digits);
   }
   return formatWithCommas(value.toFixed(digits));
 };
 
-window.formatPostBreak = function formatPostBreak(value, places, placesUnder1000) {
-  if (isEND()) return "END";
+// eslint-disable-next-line max-params
+window.formatPostBreak = function formatPostBreak(value, places, placesUnder1000, bypassEND = false) {
+  if (isEND() && !bypassEND) return "END";
   const notation = Notations.current;
   // This is basically just a copy of the format method from notations library,
   // with the pre-break case removed.
@@ -78,8 +80,8 @@ window.formatRarity = function formatRarity(value) {
 };
 
 // We assume 2/0, 2/2 decimal places to keep parameter count sensible; this is used very rarely
-window.formatMachines = function formatMachines(realPart, imagPart) {
-  if (isEND()) return "END";
+window.formatMachines = function formatMachines(realPart, imagPart, bypassEND = false) {
+  if (isEND() && !bypassEND) return "END";
   const parts = [];
   if (Decimal.neq(realPart, 0)) parts.push(format(realPart, 2));
   if (Decimal.neq(imagPart, 0)) parts.push(`${format(imagPart, 2, 2)}i`);
@@ -108,17 +110,6 @@ window.formatWithCommas = function formatWithCommas(value) {
   return decimalPointSplit.join(".");
 };
 
-/**
- * Check if a number or Decimal is equal to 1.
- * @param  {number|Decimal} amount
- * @return {Boolean} - if the {amount} was equal to 1.
- */
-window.isSingular = function isSingular(amount) {
-  if (typeof amount === "number") return amount === 1;
-  if (amount instanceof Decimal) return amount.eq(1);
-  throw `Amount must be either a number or Decimal. Instead, amount was ${amount}`;
-};
-
 // Some letters in the english language pluralize in a different manner than simply adding an 's' to the end.
 // As such, the regex match should be placed in the first location, followed by the desired string it
 // should be replaced with. Note that $ refers to the EndOfLine for regex, and should be included if the plural occurs
@@ -135,6 +126,8 @@ const PLURAL_HELPER = new Map([
 const pluralDatabase = new Map([
   ["Antimatter", "Antimatter"],
   ["Dilated Time", "Dilated Time"],
+  ["Matter", "Matter"],
+  ["Replicanti", "Replicanti"]
 ]);
 
 /**
@@ -148,7 +141,7 @@ const pluralDatabase = new Map([
 window.pluralize = function pluralize(word, amount, plural) {
   if (word === undefined || amount === undefined) throw "Arguments must be defined";
 
-  if (isSingular(amount)) return word;
+  if (Decimal.eq(amount, 1)) return word;
   const existingPlural = plural ?? pluralDatabase.get(word);
   if (existingPlural !== undefined) return existingPlural;
 
diff --git a/src/core/hotkeys.js b/src/core/hotkeys.js
index 4a86929271..eb83db44d7 100644
--- a/src/core/hotkeys.js
+++ b/src/core/hotkeys.js
@@ -309,6 +309,7 @@ export const shortcuts = [
     name: "Fullscreen",
     keys: ["F10"],
     type: "bind",
+    // eslint-disable-next-line no-empty-function
     function: () => {},
     visible: () => false
   },
diff --git a/src/core/player.js b/src/core/player.js
index eac84b0214..36bb64682c 100644
--- a/src/core/player.js
+++ b/src/core/player.js
@@ -1071,6 +1071,7 @@ export function guardFromNaNValues(obj) {
         enumerable: true,
         configurable: true,
         get: () => value,
+        // eslint-disable-next-line no-loop-func
         set: function guardedSetter(newValue) {
           if (newValue === null || newValue === undefined) {
             throw new Error("null/undefined player property assignment");
diff --git a/src/core/polyfill.js b/src/core/polyfill.js
index 39cdb2871c..de15386b24 100644
--- a/src/core/polyfill.js
+++ b/src/core/polyfill.js
@@ -1,31 +1,32 @@
 if (!String.prototype.includes) {
   String.prototype.includes = function(search, start) {
-    if (typeof start !== 'number') {
+    if (typeof start !== "number") {
+      // eslint-disable-next-line no-param-reassign
       start = 0;
     }
 
     if (start + search.length > this.length) {
       return false;
-    } else {
-      return this.indexOf(search, start) !== -1;
     }
+    return this.indexOf(search, start) !== -1;
+
   };
 }
 
 
 if (!Array.prototype.includes) {
-  Object.defineProperty(Array.prototype, 'includes', {
-    value: function(searchElement, fromIndex) {
+  Object.defineProperty(Array.prototype, "includes", {
+    value(searchElement, fromIndex) {
 
       // 1. Let O be ? ToObject(this value).
-      if (this == null) {
+      if (this === null) {
         throw new TypeError('"this" is null or not defined');
       }
 
-      var o = Object(this);
+      const o = Object(this);
 
       // 2. Let len be ? ToLength(? Get(O, "length")).
-      var len = o.length >>> 0;
+      const len = o.length >>> 0;
 
       // 3. If len is 0, return false.
       if (len === 0) {
@@ -34,22 +35,22 @@ if (!Array.prototype.includes) {
 
       // 4. Let n be ? ToInteger(fromIndex).
       //    (If fromIndex is undefined, this step produces the value 0.)
-      var n = fromIndex | 0;
+      const n = fromIndex | 0;
 
       // 5. If n ≥ 0, then
       //  a. Let k be n.
       // 6. Else n < 0,
       //  a. Let k be len + n.
       //  b. If k < 0, let k be 0.
-      var k = Math.max(n >= 0 ? n : len - Math.abs(n), 0);
+      let k = Math.max(n >= 0 ? n : len - Math.abs(n), 0);
 
       function sameValueZero(x, y) {
-        return x === y || (typeof x === 'number' && typeof y === 'number' && isNaN(x) && isNaN(y));
+        return x === y || (typeof x === "number" && typeof y === "number" && isNaN(x) && isNaN(y));
       }
 
       // 7. Repeat, while k < len
       while (k < len) {
-        // a. Let elementK be the result of ? Get(O, ! ToString(k)).
+        // A. Let elementK be the result of ? Get(O, ! ToString(k)).
         // b. If SameValueZero(searchElement, elementK) is true, return true.
         // c. Increase k by 1.
         if (sameValueZero(o[k], searchElement)) {
@@ -64,114 +65,121 @@ if (!Array.prototype.includes) {
   });
 }
 
-  if (!Math.log10) {
-      Math.log10 = Math.log10 || function(x) {
-          return Math.log(x) * Math.LOG10E;
-      };
-  }
+if (!Math.log10) {
+  Math.log10 = Math.log10 || function(x) {
+    return Math.log(x) * Math.LOG10E;
+  };
+}
 
-  if (!Math.log2) {
-      Math.log2 = Math.log2 || function(x) {
-          return Math.log(x) * Math.LOG2E;
-      };
-  }
+if (!Math.log2) {
+  Math.log2 = Math.log2 || function(x) {
+    return Math.log(x) * Math.LOG2E;
+  };
+}
 
-  if (window.NodeList && !NodeList.prototype.forEach) {
-      NodeList.prototype.forEach = function (callback, thisArg) {
-          thisArg = thisArg || window;
-          for (var i = 0; i < this.length; i++) {
-              callback.call(thisArg, this[i], i, this);
-          }
-      };
-  }
+if (window.NodeList && !NodeList.prototype.forEach) {
+  NodeList.prototype.forEach = function(callback, thisArg) {
+    // eslint-disable-next-line no-param-reassign
+    thisArg = thisArg || window;
+    for (let i = 0; i < this.length; i++) {
+      callback.call(thisArg, this[i], i, this);
+    }
+  };
+}
 
-  if (!Array.prototype.find) {
-      Object.defineProperty(Array.prototype, 'find', {
-        value: function(predicate) {
-         // 1. Let O be ? ToObject(this value).
-          if (this == null) {
-            throw new TypeError('"this" is null or not defined');
-          }
+if (!Array.prototype.find) {
+  Object.defineProperty(Array.prototype, "find", {
+    value(predicate) {
+      // 1. Let O be ? ToObject(this value).
+      if (this === null) {
+        throw new TypeError('"this" is null or not defined');
+      }
 
-          var o = Object(this);
+      const o = Object(this);
 
-          // 2. Let len be ? ToLength(? Get(O, "length")).
-          var len = o.length >>> 0;
+      // 2. Let len be ? ToLength(? Get(O, "length")).
+      const len = o.length >>> 0;
 
-          // 3. If IsCallable(predicate) is false, throw a TypeError exception.
-          if (typeof predicate !== 'function') {
-            throw new TypeError('predicate must be a function');
-          }
+      // 3. If IsCallable(predicate) is false, throw a TypeError exception.
+      if (typeof predicate !== "function") {
+        throw new TypeError("predicate must be a function");
+      }
 
-          // 4. If thisArg was supplied, let T be thisArg; else let T be undefined.
-          var thisArg = arguments[1];
-
-          // 5. Let k be 0.
-          var k = 0;
-
-          // 6. Repeat, while k < len
-          while (k < len) {
-            // a. Let Pk be ! ToString(k).
-            // b. Let kValue be ? Get(O, Pk).
-            // c. Let testResult be ToBoolean(? Call(predicate, T, « kValue, k, O »)).
-            // d. If testResult is true, return kValue.
-            var kValue = o[k];
-            if (predicate.call(thisArg, kValue, k, o)) {
-              return kValue;
-            }
-            // e. Increase k by 1.
-            k++;
-          }
+      // 4. If thisArg was supplied, let T be thisArg; else let T be undefined.
+      // eslint-disable-next-line prefer-rest-params
+      const thisArg = arguments[1];
+
+      // 5. Let k be 0.
+      let k = 0;
 
-          // 7. Return undefined.
-          return undefined;
+      // 6. Repeat, while k < len
+      while (k < len) {
+        // A. Let Pk be ! ToString(k).
+        // b. Let kValue be ? Get(O, Pk).
+        // c. Let testResult be ToBoolean(? Call(predicate, T, « kValue, k, O »)).
+        // d. If testResult is true, return kValue.
+        const kValue = o[k];
+        if (predicate.call(thisArg, kValue, k, o)) {
+          return kValue;
         }
-      });
+        // E. Increase k by 1.
+        k++;
+      }
+
+      // 7. Return undefined.
+      return undefined;
     }
+  });
+}
 
-    Array.max = function( array ){
-      return Math.max.apply( Math, array );
-  };
+Array.max = function(array) {
+  return Math.max(...array);
+};
 
-  Array.min = function( array ){
-      return Math.min.apply( Math, array );
-  };
+Array.min = function(array) {
+  return Math.min(...array);
+};
 
-  Object.invert = function(obj) {
-      var result = {};
-      var keys = Object.keys(obj);
-      for (var i = 0, length = keys.length; i < length; i++) {
-        result[obj[keys[i]]] = keys[i];
+Object.invert = function(obj) {
+  const result = {};
+  const keys = Object.keys(obj);
+  for (let i = 0, length = keys.length; i < length; i++) {
+    result[obj[keys[i]]] = keys[i];
+  }
+  return result;
+};
+
+if (typeof Object.assign !== "function") {
+  // Must be writable: true, enumerable: false, configurable: true
+  Object.defineProperty(Object, "assign", {
+    // .length of function is 2
+    // eslint-disable-next-line no-unused-vars
+    value: function assign(target, varArgs) {
+
+      // TypeError if undefined or null
+      if (target === null) {
+        throw new TypeError("Cannot convert undefined or null to object");
       }
-      return result;
-  };
-
-if (typeof Object.assign != 'function') {
-    // Must be writable: true, enumerable: false, configurable: true
-    Object.defineProperty(Object, "assign", {
-        value: function assign(target, varArgs) { // .length of function is 2
-            'use strict';
-            if (target == null) { // TypeError if undefined or null
-                throw new TypeError('Cannot convert undefined or null to object');
-            }
 
-            var to = Object(target);
+      const to = Object(target);
 
-            for (var index = 1; index < arguments.length; index++) {
-                var nextSource = arguments[index];
+      for (let index = 1; index < arguments.length; index++) {
+        // eslint-disable-next-line prefer-rest-params
+        const nextSource = arguments[index];
 
-                if (nextSource != null) { // Skip over if undefined or null
-                    for (var nextKey in nextSource) {
-                        // Avoid bugs when hasOwnProperty is shadowed
-                        if (Object.prototype.hasOwnProperty.call(nextSource, nextKey)) {
-                            to[nextKey] = nextSource[nextKey];
-                        }
-                    }
-                }
+        // Skip over if undefined or null
+        if (nextSource !== null) {
+          for (const nextKey in nextSource) {
+            // Avoid bugs when hasOwnProperty is shadowed
+            if (Object.prototype.hasOwnProperty.call(nextSource, nextKey)) {
+              to[nextKey] = nextSource[nextKey];
             }
-            return to;
-        },
-        writable: true,
-        configurable: true
-    });
+          }
+        }
+      }
+      return to;
+    },
+    writable: true,
+    configurable: true
+  });
 }
diff --git a/src/core/secret-formula/celestials/effarig.js b/src/core/secret-formula/celestials/effarig.js
index e837b4f187..aaf35b01f0 100644
--- a/src/core/secret-formula/celestials/effarig.js
+++ b/src/core/secret-formula/celestials/effarig.js
@@ -51,7 +51,7 @@ export const effarigUnlocks = {
     id: 5,
     label: "Eternity",
     get description() {
-      return ` Eternities generates Infinities
+      return ` Eternities generate Infinities
         Infinity Points are no longer limited in any way in Effarig's Reality
         You have unlocked The Nameless Ones`;
     },
diff --git a/src/core/secret-formula/celestials/index.js b/src/core/secret-formula/celestials/index.js
index 5b9ab4792c..024c116e2d 100644
--- a/src/core/secret-formula/celestials/index.js
+++ b/src/core/secret-formula/celestials/index.js
@@ -1,18 +1,18 @@
-import { finalSigil } from "./navigation-sigils/final-sigil";
-import { galaxyIcon } from "./navigation-sigils/galaxy-icon";
 import { alchemyResources } from "./alchemy";
+import { celestialNavigation } from "./navigation";
 import { effarigUnlocks } from "./effarig";
 import { enslaved } from "./enslaved";
+import { finalSigil } from "./navigation-sigils/final-sigil";
+import { galaxyIcon } from "./navigation-sigils/galaxy-icon";
 import { pelleGalaxyGeneratorUpgrades } from "./galaxy-generator";
-import { celestialNavigation } from "./navigation";
+import { pelleRifts } from "./rifts";
+import { pelleStrikes } from "./strikes";
 import { pelleUpgrades } from "./pelle-upgrades";
 import { perkShop } from "./perk-shop";
+import { quotes } from "./quotes";
 import { ra } from "./ra";
-import { pelleRifts } from "./rifts";
 import { singularityMilestones } from "./singularity-milestones";
-import { pelleStrikes } from "./strikes";
 import { teresa } from "./teresa";
-import { quotes } from "./quotes";
 import { v } from "./v";
 
 export const celestials = {
diff --git a/src/core/secret-formula/discord-rich-presence.js b/src/core/secret-formula/discord-rich-presence.js
index ac0fa7bce9..b976b8bf30 100644
--- a/src/core/secret-formula/discord-rich-presence.js
+++ b/src/core/secret-formula/discord-rich-presence.js
@@ -9,14 +9,6 @@ function formatInt(value) {
   return formatWithCommas(typeof value === "number" ? value.toFixed(0) : value.toNumber().toFixed(0));
 }
 
-function formatMachines(realPart, imagPart) {
-  const parts = [];
-  if (Decimal.neq(realPart, 0)) parts.push(format(realPart, 2));
-  if (Decimal.neq(imagPart, 0)) parts.push(`${format(imagPart, 2, 2)}i`);
-  if (Decimal.eq(realPart, 0) && Decimal.eq(imagPart, 0)) return format(0);
-  return parts.join(" + ");
-}
-
 // This is used for Discord Rich Presence, the information which shows up on a person's profile badge in Discord if
 // they are playing a game on Steam which has integration that pushes the info to Discord
 export const discordRichPresence = {
diff --git a/src/core/secret-formula/eternity/eternity-milestones.js b/src/core/secret-formula/eternity/eternity-milestones.js
index 8c1ce41ee7..c1b86f1a9b 100644
--- a/src/core/secret-formula/eternity/eternity-milestones.js
+++ b/src/core/secret-formula/eternity/eternity-milestones.js
@@ -154,18 +154,16 @@ export const eternityMilestones = {
         progress is currently disabled`;
       const eternities = getEternitiedMilestoneReward(TimeSpan.fromHours(1).totalMilliseconds,
         player.eternities.gte(200));
-      // As far as I can tell, using templates here as Codefactor wants would lead to nested templates,
-      // which seems messy to say the least.
       const realTime = PlayerProgress.seenAlteredSpeed() ? " real-time" : "";
-      // eslint-disable-next-line prefer-template
-      return `While offline, gain Eternities at ${formatPercents(0.5)} the rate of your fastest${realTime} Eternity ` +
-        (eternities.gt(0) ? `(Currently ${format(eternities, 2, 2)}/hour)` : "(Inactive)");
+      const effectText = eternities.gt(0) ? `Currently ${format(eternities, 2, 2)}/hour` : "Inactive";
+      return `While offline, gain Eternities at ${formatPercents(0.5)} the rate of your fastest${realTime} Eternity
+        (${effectText})`;
     },
     activeCondition: () => (player.options.offlineProgress
       ? `Must be outside of all Challenges and Dilation, and the Eternity Autobuyer must be set to Eternity at zero EP.
         This milestone's effect is capped at ${formatInt(33)}ms.`
       : ""),
-      pelleUseless: true
+    pelleUseless: true
   },
   autoInfinities: {
     eternities: 1000,
@@ -174,16 +172,15 @@ export const eternityMilestones = {
         progress is currently disabled`;
       const infinities = getInfinitiedMilestoneReward(TimeSpan.fromHours(1).totalMilliseconds,
         player.eternities.gte(1000));
-      // eslint-disable-next-line prefer-template
-      return `While offline, gain Infinities equal to ${formatPercents(0.5)}
-        your best Infinities/hour this Eternity ` +
-        (infinities.gt(0) ? `(Currently ${format(infinities, 2, 2)}/hour)` : "(Inactive)");
+      const effectText = infinities.gt(0) ? `Currently ${format(infinities, 2, 2)}/hour` : "Inactive";
+      return `While offline, gain Infinities equal to ${formatPercents(0.5)} your best Infinities/hour this Eternity
+        (${effectText})`;
     },
     activeCondition: () => (player.options.offlineProgress
       ? `Must be outside of Normal/Infinity Challenges and outside of EC4 and EC12,
         the Big Crunch Autobuyer must be turned on and set to time mode with ${formatInt(5)} seconds or less,
         and the Eternity Autobuyer must be turned off.`
       : ""),
-      pelleUseless: true
+    pelleUseless: true
   }
 };
diff --git a/src/core/secret-formula/multiplier-tab/values.js b/src/core/secret-formula/multiplier-tab/values.js
index 4626cc9d9b..5c70cc21e7 100644
--- a/src/core/secret-formula/multiplier-tab/values.js
+++ b/src/core/secret-formula/multiplier-tab/values.js
@@ -1,18 +1,18 @@
-import { AM } from "./antimatter";
+import { tickspeed, tickspeedUpgrades } from "./tickspeed";
 import { AD } from "./antimatter-dimensions";
+import { AM } from "./antimatter";
 import { DT } from "./dilated-time";
-import { eternities } from "./eternities";
 import { EP } from "./eternity-points";
+import { eternities } from "./eternities";
 import { galaxies } from "./galaxies";
 import { gamespeed } from "./gamespeed";
 import { general } from "./general";
-import { infinities } from "./infinities";
 import { ID } from "./infinity-dimensions";
+import { infinities } from "./infinities";
 import { IP } from "./infinity-points";
 import { replicanti } from "./replicanti";
-import { TP } from "./tachyon-particles";
-import { tickspeed, tickspeedUpgrades } from "./tickspeed";
 import { TD } from "./time-dimensions";
+import { TP } from "./tachyon-particles";
 
 export const multiplierTabValues = {
   general,
diff --git a/src/core/secret-formula/news.js b/src/core/secret-formula/news.js
index 41e28148f1..86a6a1a069 100644
--- a/src/core/secret-formula/news.js
+++ b/src/core/secret-formula/news.js
@@ -904,7 +904,20 @@ export const news = [
   },
   {
     id: "a171",
-    text: "<a href='https://www.youtube.com/watch?v=P945A5Tndp8' target='_blank'>This link is not a rick roll.</a>"
+    get text() {
+      const links = [
+        // Get trolled
+        "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
+        // Rite of spring
+        "https://youtu.be/rP42C-4zL3w?t=2",
+        // Aleph 0 which for some reason caught on for a while
+        "https://www.youtube.com/watch?v=fTaWKbD3UK8",
+        // "If you have not listened to first suite in E flat by Gustav Holst do it now" -Erf
+        "https://www.youtube.com/watch?v=fLbP6qpI1YI",
+      ];
+      // eslint-disable-next-line max-len
+      return `<a href='${links[Math.floor(Math.random() * links.length)]}' target='_blank'>This link is not a rick roll.</a>`;
+    }
   },
   {
     id: "a172",
diff --git a/src/core/secret-formula/speedrun-milestones.js b/src/core/secret-formula/speedrun-milestones.js
index 921a019ab2..bce06bbcab 100644
--- a/src/core/secret-formula/speedrun-milestones.js
+++ b/src/core/secret-formula/speedrun-milestones.js
@@ -1,5 +1,5 @@
-export const speedrunMilestones = [
-  {
+export const speedrunMilestones = {
+  firstBoost: {
     id: 1,
     key: "firstBoost",
     name: "First Dimboost",
@@ -7,7 +7,7 @@ export const speedrunMilestones = [
     checkRequirement: () => true,
     checkEvent: GAME_EVENT.DIMBOOST_AFTER,
   },
-  {
+  firstGalaxy: {
     id: 2,
     key: "firstGalaxy",
     name: "First Galaxy",
@@ -15,7 +15,7 @@ export const speedrunMilestones = [
     checkRequirement: () => true,
     checkEvent: GAME_EVENT.GALAXY_RESET_AFTER,
   },
-  {
+  firstInfinity: {
     id: 3,
     key: "firstInfinity",
     name: "First Infinity",
@@ -23,7 +23,7 @@ export const speedrunMilestones = [
     checkRequirement: () => true,
     checkEvent: GAME_EVENT.BIG_CRUNCH_AFTER,
   },
-  {
+  completeC9: {
     id: 4,
     key: "completeC9",
     name: "Tickspeed Challenge",
@@ -31,7 +31,7 @@ export const speedrunMilestones = [
     checkRequirement: () => NormalChallenge(9).isCompleted,
     checkEvent: GAME_EVENT.BIG_CRUNCH_AFTER,
   },
-  {
+  completeAllNC: {
     id: 5,
     key: "completeAllNC",
     name: "All Normal Challenges",
@@ -39,7 +39,7 @@ export const speedrunMilestones = [
     checkRequirement: () => NormalChallenges.all.countWhere(c => !c.isCompleted) === 0,
     checkEvent: GAME_EVENT.BIG_CRUNCH_AFTER,
   },
-  {
+  breakInfinity: {
     id: 6,
     key: "breakInfinity",
     name: "Break Infinity",
@@ -47,7 +47,7 @@ export const speedrunMilestones = [
     checkRequirement: () => player.break,
     checkEvent: GAME_EVENT.BREAK_INFINITY,
   },
-  {
+  upgrade5e11IP: {
     id: 7,
     key: "upgrade5e11IP",
     get name() { return `${format(5e11)} IP Upgrade`; },
@@ -55,7 +55,7 @@ export const speedrunMilestones = [
     checkRequirement: () => true,
     // This is checked within BreakInfinityUpgrade.onPurchased
   },
-  {
+  completeIC5: {
     id: 8,
     key: "completeIC5",
     name: "Infinity Challenge 5",
@@ -63,7 +63,7 @@ export const speedrunMilestones = [
     checkRequirement: () => InfinityChallenge(5).isCompleted,
     checkEvent: GAME_EVENT.BIG_CRUNCH_AFTER,
   },
-  {
+  unlockReplicanti: {
     id: 9,
     key: "unlockReplicanti",
     name: "Replicanti",
@@ -71,7 +71,7 @@ export const speedrunMilestones = [
     checkRequirement: () => player.replicanti.unl,
     checkEvent: GAME_EVENT.REPLICANTI_TICK_AFTER,
   },
-  {
+  firstEternity: {
     id: 10,
     key: "firstEternity",
     name: "First Eternity",
@@ -79,7 +79,7 @@ export const speedrunMilestones = [
     checkRequirement: () => true,
     checkEvent: GAME_EVENT.ETERNITY_RESET_AFTER,
   },
-  {
+  allEternityMilestones: {
     id: 11,
     key: "allEternityMilestones",
     name: "All Eternity Milestones",
@@ -87,7 +87,7 @@ export const speedrunMilestones = [
     checkRequirement: () => EternityMilestone.all.every(m => m.isReached),
     checkEvent: GAME_EVENT.ETERNITY_RESET_AFTER,
   },
-  {
+  completeFirstEC: {
     id: 12,
     key: "completeFirstEC",
     name: "First Eternity Challenge",
@@ -95,7 +95,7 @@ export const speedrunMilestones = [
     checkRequirement: () => EternityChallenges.completions > 0,
     checkEvent: GAME_EVENT.ETERNITY_RESET_AFTER,
   },
-  {
+  completeEC10: {
     id: 13,
     key: "completeEC10",
     name: "Eternity Challenge 10",
@@ -103,7 +103,7 @@ export const speedrunMilestones = [
     checkRequirement: () => EternityChallenge(10).completions > 0,
     checkEvent: GAME_EVENT.ETERNITY_RESET_AFTER,
   },
-  {
+  firstDilation: {
     id: 14,
     key: "firstDilation",
     name: "First Dilated Eternity",
@@ -111,7 +111,7 @@ export const speedrunMilestones = [
     checkRequirement: () => player.dilation.active,
     checkEvent: GAME_EVENT.ETERNITY_RESET_BEFORE,
   },
-  {
+  upgradeTTgen: {
     id: 15,
     key: "upgradeTTgen",
     name: "Time Theorem Generation",
@@ -119,7 +119,7 @@ export const speedrunMilestones = [
     checkRequirement: () => true,
     // This is checked within DilationUpgradeState.onPurchased
   },
-  {
+  firstReality: {
     id: 16,
     key: "firstReality",
     name: "First Reality",
@@ -127,7 +127,7 @@ export const speedrunMilestones = [
     checkRequirement: () => true,
     checkEvent: GAME_EVENT.REALITY_RESET_AFTER,
   },
-  {
+  upgradeBlackHole: {
     id: 17,
     key: "upgradeBlackHole",
     name: "Black Hole",
@@ -135,7 +135,7 @@ export const speedrunMilestones = [
     checkRequirement: () => true,
     checkEvent: GAME_EVENT.BLACK_HOLE_UNLOCKED,
   },
-  {
+  allRealityUpgrades: {
     id: 18,
     key: "allRealityUpgrades",
     name: "All Reality Upgrades",
@@ -143,7 +143,7 @@ export const speedrunMilestones = [
     checkRequirement: () => RealityUpgrades.allBought,
     checkEvent: GAME_EVENT.REALITY_UPGRADE_BOUGHT,
   },
-  {
+  completeTeresaReality: {
     id: 19,
     key: "completeTeresaReality",
     name: "Teresa's Reality",
@@ -151,7 +151,7 @@ export const speedrunMilestones = [
     checkRequirement: () => Teresa.isRunning,
     checkEvent: GAME_EVENT.REALITY_RESET_BEFORE,
   },
-  {
+  completeEffarigReality: {
     id: 20,
     key: "completeEffarigReality",
     name: "Effarig's Reality",
@@ -159,7 +159,7 @@ export const speedrunMilestones = [
     checkRequirement: () => Effarig.currentStage === EFFARIG_STAGES.COMPLETED,
     checkEvent: GAME_EVENT.REALITY_RESET_AFTER,
   },
-  {
+  completeEnslavedReality: {
     id: 21,
     key: "completeEnslavedReality",
     name: "The Nameless Ones' Reality",
@@ -167,7 +167,7 @@ export const speedrunMilestones = [
     checkRequirement: () => Enslaved.isRunning,
     checkEvent: GAME_EVENT.REALITY_RESET_BEFORE,
   },
-  {
+  complete36VAchievement: {
     id: 22,
     key: "complete36VAchievement",
     name: "All basic V-Achievements",
@@ -175,7 +175,7 @@ export const speedrunMilestones = [
     checkRequirement: () => true,
     // In order to avoid unnecessary overhead, this is checked within V.checkForUnlocks instead of every tick
   },
-  {
+  completeRaMemories: {
     id: 23,
     key: "completeRaMemories",
     name: "Regain Ra's Memories",
@@ -183,7 +183,7 @@ export const speedrunMilestones = [
     checkRequirement: () => Ra.totalPetLevel >= Ra.maxTotalPetLevel,
     checkEvent: GAME_EVENT.GAME_TICK_AFTER,
   },
-  {
+  completeFullDestabilize: {
     id: 24,
     key: "completeFullDestabilize",
     name: "Full Destabilization",
@@ -191,7 +191,7 @@ export const speedrunMilestones = [
     checkRequirement: () => Laitela.isFullyDestabilized,
     // Destabilization isn't a reality reset because it shortcuts gameLoop; this is checked in laitelaRealityTick
   },
-  {
+  completeFullGame: {
     id: 25,
     key: "completeFullGame",
     name: "Game Completed!",
@@ -199,4 +199,4 @@ export const speedrunMilestones = [
     checkRequirement: () => Achievement(188).isUnlocked,
     checkEvent: GAME_EVENT.ACHIEVEMENT_UNLOCKED,
   },
-];
+};
diff --git a/src/core/speedrun.js b/src/core/speedrun.js
index 425ff37ba8..790fddc3ca 100644
--- a/src/core/speedrun.js
+++ b/src/core/speedrun.js
@@ -125,7 +125,7 @@ export const Speedrun = {
   }
 };
 
-class SpeedrunMilestone extends GameMechanicState {
+class SpeedrunMilestoneState extends GameMechanicState {
   constructor(config) {
     super(config);
     this.registerEvents(config.checkEvent, args => this.tryComplete(args));
@@ -152,4 +152,7 @@ class SpeedrunMilestone extends GameMechanicState {
   }
 }
 
-export const SpeedrunMilestones = SpeedrunMilestone.createAccessor(GameDatabase.speedrunMilestones);
+export const SpeedrunMilestone = mapGameDataToObject(
+  GameDatabase.speedrunMilestones,
+  config => new SpeedrunMilestoneState(config)
+);
\ No newline at end of file
diff --git a/src/core/storage/cloud-saving.js b/src/core/storage/cloud-saving.js
index fe5b750a56..10347404b6 100644
--- a/src/core/storage/cloud-saving.js
+++ b/src/core/storage/cloud-saving.js
@@ -97,6 +97,7 @@ export const Cloud = {
     if (snapshot.exists) {
       const encoded = snapshot.val();
       const uintArray = decodeBase64Binary(encoded.replace(/-/gu, "+").replace(/_/gu, "/"));
+      // eslint-disable-next-line no-unused-vars
       const save = pako.ungzip(uintArray, { to: "string" });
     }
   },
diff --git a/src/core/timespan.js b/src/core/timespan.js
index 7f6fa151fc..4298a404f1 100644
--- a/src/core/timespan.js
+++ b/src/core/timespan.js
@@ -207,7 +207,7 @@ window.TimeSpan = class TimeSpan {
   /**
    * @returns {String}
    */
-  toStringNoDecimals() {
+  toStringNoDecimals(bypassEND = false) {
     const parts = [];
     function addCheckedComponent(value, name) {
       if (value === 0) {
@@ -216,7 +216,7 @@ window.TimeSpan = class TimeSpan {
       addComponent(value, name);
     }
     function addComponent(value, name) {
-      parts.push(value === 1 ? `${formatInt(value)} ${name}` : `${formatInt(value)} ${name}s`);
+      parts.push(value === 1 ? `${formatInt(value, bypassEND)} ${name}` : `${formatInt(value, bypassEND)} ${name}s`);
     }
     addCheckedComponent(this.years, "year");
     addCheckedComponent(this.days, "day");
@@ -229,22 +229,22 @@ window.TimeSpan = class TimeSpan {
   }
 
   /**
-   * Note: For speedruns, we give 3 digits of hours on HMS formatting, a decimal point on seconds, and
-   *  suppress END formatting on the speedrun record tabs
+   * Note: For speedruns, we give 3 digits of hours on HMS formatting, a decimal point on seconds
    * @param {boolean} useHMS If true, will display times as HH:MM:SS in between a minute and 100 hours.
+   * @param {boolean} bypassEND Supress END formatting
    * @returns {String}
    */
-  toStringShort(useHMS = true, isSpeedrun = false) {
+  toStringShort(useHMS = true, isSpeedrun = false, bypassEND = false) {
     // Probably not worth the trouble of importing the isEND function from formatting since this accomplishes the same
     // thing; we do however need this to prevent strings like "02:32" from showing up though
-    if (format(0) === "END" && !isSpeedrun) return "END";
+    if (format(0) === "END" && !bypassEND) return "END";
 
     const totalSeconds = this.totalSeconds;
     if (totalSeconds > 5e-7 && totalSeconds < 1e-3) {
       // This conditional happens when when the time is less than 1 millisecond
       // but big enough not to round to 0 with 3 decimal places (so showing decimal places
       // won't just show 0 and waste space).
-      return `${format(1000 * totalSeconds, 0, 3)} ms`;
+      return `${format(1000 * totalSeconds, 0, 3, bypassEND)} ms`;
     }
     if (totalSeconds < 1) {
       // This catches all the cases when totalSeconds is less than 1 but not
@@ -253,13 +253,13 @@ window.TimeSpan = class TimeSpan {
       // (the most notable case of this kind is 0 itself).
       // (2) those greater than or equal to 1e-3, which will be formatted with default settings
       // (for most notations, rounding to the nearest integer number of milliseconds)
-      return `${format(1000 * totalSeconds)} ms`;
+      return `${format(1000 * totalSeconds, 0, 0, bypassEND)} ms`;
     }
     if (totalSeconds < 10) {
-      return `${format(totalSeconds, 0, 3)} seconds`;
+      return `${format(totalSeconds, 0, 3, bypassEND)} seconds`;
     }
     if (totalSeconds < 60) {
-      return `${format(totalSeconds, 0, 2)} seconds`;
+      return `${format(totalSeconds, 0, 2, bypassEND)} seconds`;
     }
     if (this.totalHours < 100 || (isSpeedrun && this.totalHours < 1000)) {
       if (useHMS && !Notations.current.isPainful) {
@@ -268,16 +268,16 @@ window.TimeSpan = class TimeSpan {
         return `${formatHMS(Math.floor(this.totalHours))}:${formatHMS(this.minutes)}:${sec}`;
       }
       if (this.totalMinutes < 60) {
-        return `${format(this.totalMinutes, 0, 2)} minutes`;
+        return `${format(this.totalMinutes, 0, 2, bypassEND)} minutes`;
       }
       if (this.totalHours < 24) {
-        return `${format(this.totalHours, 0, 2)} hours`;
+        return `${format(this.totalHours, 0, 2, bypassEND)} hours`;
       }
     }
     if (this.totalDays < 500) {
-      return `${isSpeedrun ? this.totalDays.toFixed(2) : format(this.totalDays, 0, 2)} days`;
+      return `${isSpeedrun ? this.totalDays.toFixed(2) : format(this.totalDays, 0, 2, bypassEND)} days`;
     }
-    return `${isSpeedrun ? this.totalYears.toFixed(3) : format(this.totalYears, 3, 2)} years`;
+    return `${isSpeedrun ? this.totalYears.toFixed(3) : format(this.totalYears, 3, 2, bypassEND)} years`;
 
     function formatHMS(value) {
       const s = value.toString();
diff --git a/src/core/ui.js b/src/core/ui.js
index 61c1dfeb1d..20ade6468d 100644
--- a/src/core/ui.js
+++ b/src/core/ui.js
@@ -51,27 +51,13 @@ Vue.mixin({
     on$(event, fn) {
       EventHub.ui.on(event, fn, this);
     },
-    format(value, places, placesUnder1000) {
-      return format(value, places, placesUnder1000);
-    },
-    formatInt(value) {
-      return formatInt(value);
-    },
-    formatPercents(value, places) {
-      return formatPercents(value, places);
-    },
-    formatRarity(value) {
-      return formatRarity(value);
-    },
-    formatX(value, places, placesUnder1000) {
-      return formatX(value, places, placesUnder1000);
-    },
-    formatPow(value, places, placesUnder1000) {
-      return formatPow(value, places, placesUnder1000);
-    },
-    formatPostBreak(value, places, placesUnder1000) {
-      return formatPostBreak(value, places, placesUnder1000);
-    },
+    format,
+    formatInt,
+    formatPercents,
+    formatRarity,
+    formatX,
+    formatPow,
+    formatPostBreak,
     pluralize,
     quantify,
     quantifyInt
diff --git a/src/game.js b/src/game.js
index 41a77d0f5e..490d59c7aa 100644
--- a/src/game.js
+++ b/src/game.js
@@ -2,11 +2,11 @@ import TWEEN from "tween.js";
 
 import { ElectronRuntime, SteamRuntime } from "@/steam";
 
+import { Cloud } from "./core/storage";
 import { DC } from "./core/constants";
 import { deepmergeAll } from "@/utility/deepmerge";
 import { DEV } from "@/env";
-import { SpeedrunMilestones } from "./core/speedrun";
-import { Cloud } from "./core/storage";
+import { SpeedrunMilestone } from "./core/speedrun";
 import { supportedBrowsers } from "./supported-browsers";
 
 import Payments from "./core/payments";
@@ -740,7 +740,8 @@ function laitelaRealityTick(realDiff) {
     laitelaInfo.thisCompletion = Time.thisRealityRealTime.totalSeconds;
     laitelaInfo.fastestCompletion = Math.min(laitelaInfo.thisCompletion, laitelaInfo.fastestCompletion);
     clearCelestialRuns();
-    if (Time.thisRealityRealTime.totalSeconds < 30) {
+    const destabilizing = Time.thisRealityRealTime.totalSeconds < 30;
+    if (destabilizing) {
       laitelaInfo.difficultyTier++;
       laitelaInfo.fastestCompletion = 300;
       completionText += laitelaBeatText(Laitela.maxAllowedDimension + 1);
@@ -752,37 +753,19 @@ function laitelaRealityTick(realDiff) {
     }
     if (Laitela.realityReward > oldInfo.realityReward) {
       completionText += `<br><br>Dark Matter Multiplier: ${formatX(oldInfo.realityReward, 2, 2)}
-      ➜ ${formatX(Laitela.realityReward, 2, 2)}`;
-      if (oldInfo.fastestCompletion === 3600 || oldInfo.fastestCompletion === 300 && oldInfo.difficultyTier > 0) {
-        if (Time.thisRealityRealTime.totalSeconds < 30) {
-          // First attempt - destabilising
-          completionText += `<br>Best Completion Time: None ➜ Destabilized
-          <br>Highest Active Dimension: ${formatInt(8 - oldInfo.difficultyTier)} ➜
-          ${formatInt(8 - laitelaInfo.difficultyTier)}`;
-        } else {
-          // First attempt - not destabilising
-          completionText += `<br>Best Completion Time: None ➜
-            ${TimeSpan.fromSeconds(laitelaInfo.fastestCompletion).toStringShort()}
-            <br>Highest Active Dimension: ${formatInt(8 - laitelaInfo.difficultyTier)}`;
-        }
-      } else if (Time.thisRealityRealTime.totalSeconds < 30) {
-        // Second+ attempt - destabilising
-        completionText += `<br>Best Completion Time: ${TimeSpan.fromSeconds(oldInfo.fastestCompletion).toStringShort()}
-          ➜ Destabilized
-          <br>Highest Active Dimension: ${formatInt(8 - oldInfo.difficultyTier)} ➜
-          ${formatInt(8 - laitelaInfo.difficultyTier)}`;
-      } else {
-        // Second+ attempt - not destabilising
-        completionText += `<br>Best Completion Time: ${TimeSpan.fromSeconds(oldInfo.fastestCompletion).toStringShort()}
-        ➜ ${TimeSpan.fromSeconds(laitelaInfo.fastestCompletion).toStringShort()}
-        <br>Highest Active Dimension: ${formatInt(8 - oldInfo.difficultyTier)}`;
-      }
+      ➜ ${formatX(Laitela.realityReward, 2, 2)}<br>Best Completion Time: `;
+      const firstAttempt =
+        oldInfo.fastestCompletion === 3600 || oldInfo.fastestCompletion === 300 && oldInfo.difficultyTier > 0;
+      completionText += `${firstAttempt ? "None" : TimeSpan.fromSeconds(oldInfo.fastestCompletion).toStringShort()} ➜
+        ${destabilizing ? "Destabilized" : TimeSpan.fromSeconds(laitelaInfo.fastestCompletion).toStringShort()}
+        <br>Highest Active Dimension: ${destabilising ? `${formatInt(8 - oldInfo.difficultyTier)} ➜` : ""}
+        ${formatInt(8 - laitelaInfo.difficultyTier)}`;
       player.records.bestReality.laitelaSet = Glyphs.copyForRecords(Glyphs.active.filter(g => g !== null));
     } else {
       completionText += ` You need to destabilize in faster than
         ${TimeSpan.fromSeconds(laitelaInfo.fastestCompletion).toStringShort()} to improve your multiplier.`;
     }
-    if (Laitela.isFullyDestabilized) SpeedrunMilestones(24).tryComplete();
+    if (Laitela.isFullyDestabilized) SpeedrunMilestone.completeFullDestabilize.tryComplete();
     Modal.message.show(completionText, {}, 2);
   }
 }
@@ -1039,9 +1022,7 @@ export function simulateTime(seconds, real, fast) {
           // .postLoadStuff will restart GameIntervals
           GameStorage.postLoadStuff();
         },
-        then: () => {
-          afterSimulation(seconds, playerStart);
-        },
+        then: () => afterSimulation(seconds, playerStart),
         progress
       });
   }
diff --git a/src/steam/steam-purchases.js b/src/steam/steam-purchases.js
index 6af6caea11..a92c81daf0 100644
--- a/src/steam/steam-purchases.js
+++ b/src/steam/steam-purchases.js
@@ -1,6 +1,6 @@
+import * as PlayFab from "./bindings/playfab";
 import { MAC } from "@/env";
 import { openExternalLink } from "@/utility/open-external-link";
-import * as PlayFab from "./bindings/playfab";
 
 export async function loginPlayFabWithSteam(ticket, screenName) {
   await PlayFab.LoginWithSteam(ticket);