_wheelAndUpDownActions(e, isUp, isDown, step) {
        // 0) First, save the caret position so we can set it back once the value has been changed
        const selectionStart = e.target.selectionStart || 0;
        const selectionEnd = e.target.selectionEnd || 0;

        // 1) Get the unformatted value
        const currentUnformattedValue = this.rawValue;

        let result;
        if (AutoNumericHelper.isUndefinedOrNullOrEmpty(currentUnformattedValue)) {
            // If by default the input is empty, start at '0'
            if (this.settings.minimumValue > 0 || this.settings.maximumValue < 0) {
                // or if '0' is not between min and max value, 'minimumValue' if the user does a wheelup, 'maximumValue' if the user does a wheeldown
                if (isUp) {
                    result = this.settings.minimumValue;
                } else {
                    result = this.settings.maximumValue;
                }
            } else {
                result = 0;
            }
        } else {
            result = currentUnformattedValue;
        }

        result = +result; // Typecast to a number needed for the following addition/subtraction

        // 2) Increment/Decrement the value
        // But first, choose the increment/decrement method ; fixed or progressive
        if (AutoNumericHelper.isNumber(step)) {
            const stepToUse = +step; // Typecast to a number needed for the following addition/subtraction
            // Fixed method
            // This is the simplest method, where a fixed offset in added/subtracted from the current value
            if (isUp) { // Increment
                result += stepToUse;
            } else if (isDown) { // Decrement
                result -= stepToUse;
            }
        } else {
            // Progressive method
            // For this method, we calculate an offset that is in relation to the size of the current number (using only the integer part size).
            // The bigger the number, the bigger the offset (usually the number count in the integer part minus 3, except for small numbers where a different behavior is better for the user experience).
            //TODO Known limitation : The progressive method does not play well with numbers between 0 and 1 where to modify the decimal places the rawValue first has to go from '1' to '0'
            if (isUp) { // Increment
                result = AutoNumericHelper.addAndRoundToNearestAuto(result, this.settings.decimalPlacesRawValue);
            } else if (isDown) { // Decrement
                result = AutoNumericHelper.subtractAndRoundToNearestAuto(result, this.settings.decimalPlacesRawValue);
            }
        }

        // 3) Set the new value so it gets formatted
        // First clamp the result if needed
        result = AutoNumericHelper.clampToRangeLimits(result, this.settings);
        if (result !== +currentUnformattedValue) {
            // Only 'set' the value if it has changed. For instance 'set' should not happen if the user hits a limit and continue to try to go past it since we clamp the value.
            this.set(result);

            // Since we changed the input value, we send a native `input` event
            this._triggerEvent(AutoNumeric.events.native.input, e.target);
        }

        //XXX Do not prevent if the value is not modified? From a UX point of view, preventing the wheel event when the user use it on top of an autoNumeric element should always be done, even if the value does not change. Perhaps that could affect other scripts relying on this event to be sent though.
        e.preventDefault(); // We prevent the page to scroll while we increment/decrement the value

        // 4) Finally, we set back the caret position/selection
        // There is no need to take into account the fact that the number count could be different at the end of the wheel event ; it would be too complex and most of the time unreliable
        this._setSelection(selectionStart, selectionEnd);
    }
Helper function that DRY the similar behaviors of the mousewheel and up/down arrow keys, which increment/decrement the element value, either by a fixed value, or using the 'progressive' heuristic

@param {WheelEvent|KeyboardEvent} e The `wheel` or keyboard event
@param {boolean} isUp Defines if the event should increment the value
@param {boolean} isDown Defines if the event should decrement the value
@param {string|number} step The step to be applied to the increment/decrement action
@private