static modifyAndRoundToNearestAuto(value, isAddition, decimalPlacesRawValue) {
        value = Number(this.forceDecimalPlaces(value, decimalPlacesRawValue)); // Make sure that '0.13000000001' is converted to the number of rawValue decimal places '0.13'

        const absValue = Math.abs(value);
        if (absValue >= 0 && absValue < 1) {
            const rawValueMinimumOffset = Math.pow(10, -decimalPlacesRawValue);
            if (value === 0) {
                // 4 decimalPlacesRawValue : 0.0000 -> 0.0001 (0.0001)
                return (isAddition)?rawValueMinimumOffset:-rawValueMinimumOffset;
            }

            let offset;
            const minimumOffsetFirstDecimalPlaceIndex = decimalPlacesRawValue;
            // Find where is the first non-zero decimal places
            const indexFirstNonZeroDecimalPlace = this.indexFirstNonZeroDecimalPlace(value);
            if (indexFirstNonZeroDecimalPlace >= minimumOffsetFirstDecimalPlaceIndex - 1) {
                /* 4 decimalPlacesRawValue : 0.0041 -> 0.0042 (0.0001) : Math.pow(10, -4)
                 * 4 decimalPlacesRawValue : 0.0004 -> 0.0005 (0.0001)
                 */
                offset = rawValueMinimumOffset;
            } else {
                offset = Math.pow(10, -(indexFirstNonZeroDecimalPlace + 1));
            }

            let result;
            if (isAddition) {
                result = value + offset;
            } else {
                result = value - offset;
            }

            return this.roundToNearest(result, offset);
        } else {
            // For values >= 1
            value = parseInt(value, 10);
            const lengthValue = Math.abs(value).toString().length; // `Math.abs()` is needed here to omit the negative sign '-' in case of a negative value

            let pow;
            switch (lengthValue) {
                // Special cases for small numbers
                case 1:
                    pow = 0;
                    break;
                case 2:
                case 3:
                    pow = 1;
                    break;
                case 4:
                case 5:
                    pow = 2;
                    break;
                // Default behavior
                default:
                    pow = lengthValue - 3;
            }
            const offset = Math.pow(10, pow);

            let result;
            if (isAddition) {
                result = value + offset;
            } else {
                result = value - offset;
            }

            if (result <= 10 && result >= -10) {
                return result;
            }

            return this.roundToNearest(result, offset);
        }
    }
Return the 'nearest rounded' value by automatically adding or subtracting the calculated offset to the initial value.
This is done without having to pass a step to this function, and based on the size of the given `value`.

@example                    Calculated offset
          1 ->           1 (1)
         14 ->          10 (10)
        143 ->         140 (10)
      1.278 ->       1.300 (100)
     28.456 ->      28.500 (100)
    276.345 ->     276.000 (1.000)
  4.534.061 ->   4.530.000 (10.000)
 66.723.844 ->  66.700.000 (100.000)
257.833.411 -> 258.000.000 (1.000.000)

                          Initial   Added   Offset
2 decimalPlacesRawValue : 1.12   -> 2.00   (1)
3 decimalPlacesRawValue : 1.123  -> 2.000  (1)

Special case when the `value` to round is between -1 and 1, excluded :
@example
    Number of             Initial   Result  Calculated
    decimal places        value     (add)   offset
2 decimalPlacesRawValue : 0.12   -> 0.13    (0.01) : Math.pow(10, -2)
2 decimalPlacesRawValue : 0.01   -> 0.02    (0.01)
2 decimalPlacesRawValue : 0.00   -> 0.01    (0.01)

3 decimalPlacesRawValue : 0.123  -> 0.133   (0.01)  : Math.pow(10, -2)
3 decimalPlacesRawValue : 0.012  -> 0.013   (0.001) : Math.pow(10, -3)
3 decimalPlacesRawValue : 0.001  -> 0.001   (0.001)
3 decimalPlacesRawValue : 0.000  -> 0.001   (0.001)

4 decimalPlacesRawValue : 0.4123 -> 0.4200  (0.01)   : Math.pow(10, -2)
4 decimalPlacesRawValue : 0.0412 -> 0.0420  (0.001)  : Math.pow(10, -3)
4 decimalPlacesRawValue : 0.0041 -> 0.0042  (0.0001) : Math.pow(10, -4)
4 decimalPlacesRawValue : 0.0004 -> 0.0005  (0.0001)
4 decimalPlacesRawValue : 0.0000 -> 0.0001  (0.0001)

@param {number} value
@param {boolean} isAddition
@param {int} decimalPlacesRawValue The precision needed by the `rawValue`
@returns {*}