_onFocusOutAndMouseLeave(e) {
        //TODO Create separate handlers for blur and mouseleave
        this.isEditing = false; // Just in case no `keyUp` event have been sent (if the user lost the focus on the window while typing)

        if (e.type === 'mouseleave' && this.formulaMode) {
            return;
        }

        //FIXME Do not call `set()` if the current raw value is the same as the one we are trying to set (currently, on focus out, `set()` is always called, even if the value has not changed
        if (this.settings.unformatOnHover && e.type === 'mouseleave' && this.hoveredWithAlt) {
            this.constructor._reformatAltHovered(this);

            return;
        }

        if ((e.type === 'mouseleave' && !this.isFocused) || e.type === 'blur') {
            if (e.type === 'blur' && this.formulaMode) {
                this._exitFormulaMode();
            }

            this._saveValueToPersistentStorage();
            if (this.settings.showOnlyNumbersOnFocus === AutoNumeric.options.showOnlyNumbersOnFocus.onlyNumbers) {
                this.settings.digitGroupSeparator = this.originalDigitGroupSeparator;
                this.settings.currencySymbol = this.originalCurrencySymbol;
                this.settings.suffixText = this.originalSuffixText;
            }

            // Use the rawValue, multiplied by `rawValueDivisor` if defined
            const rawValueToFormat = this._getRawValueToFormat(this.rawValue);
            const isRawValueNull = AutoNumericHelper.isNull(rawValueToFormat);
            const [minTest, maxTest] = this.constructor._checkIfInRangeWithOverrideOption(rawValueToFormat, this.settings);

            // Directly set the formatted value if the `rawValue` is found in `valuesToStrings`
            let elementValueIsAlreadySet = false;
            if (rawValueToFormat !== '' && !isRawValueNull) {
                this._triggerRangeEvents(minTest, maxTest);

                if (this.settings.valuesToStrings && this._checkValuesToStrings(rawValueToFormat)) {
                    // Set the formatted value with the corresponding string
                    this._setElementValue(this.settings.valuesToStrings[rawValueToFormat]);
                    elementValueIsAlreadySet = true;
                }
            }

            // Only generate the formatted value if no `valuesToStrings` have been found
            if (!elementValueIsAlreadySet) {
                let value;
                if (isRawValueNull || rawValueToFormat === '') {
                    value = rawValueToFormat;
                } else {
                    value = String(rawValueToFormat);
                }

                if (rawValueToFormat !== '' && !isRawValueNull) {
                    if (minTest && maxTest && !this.constructor._isElementValueEmptyOrOnlyTheNegativeSign(rawValueToFormat, this.settings)) {
                        value = this._modifyNegativeSignAndDecimalCharacterForRawValue(value);

                        if (this.settings.divisorWhenUnfocused && !AutoNumericHelper.isNull(value)) {
                            value = value / this.settings.divisorWhenUnfocused;
                            value = value.toString();
                        }

                        value = this.constructor._roundFormattedValueShownOnBlur(value, this.settings);
                        value = this.constructor._modifyNegativeSignAndDecimalCharacterForFormattedValue(value, this.settings);
                    } else {
                        this._triggerRangeEvents(minTest, maxTest);
                    }
                } else if (rawValueToFormat === '') {
                    switch (this.settings.emptyInputBehavior) {
                        case AutoNumeric.options.emptyInputBehavior.zero:
                            this._setRawValue('0');
                            value = this.constructor._roundValue('0', this.settings, 0); 
                            break;
                        case AutoNumeric.options.emptyInputBehavior.min:
                            this._setRawValue(this.settings.minimumValue);
                            value = this.constructor._roundFormattedValueShownOnFocusOrBlur(this.settings.minimumValue, this.settings, this.isFocused); 
                            break;
                        case AutoNumeric.options.emptyInputBehavior.max:
                            this._setRawValue(this.settings.maximumValue);
                            value = this.constructor._roundFormattedValueShownOnFocusOrBlur(this.settings.maximumValue, this.settings, this.isFocused); 
                            break;
                        default:
                            if (AutoNumericHelper.isNumber(this.settings.emptyInputBehavior)) {
                                this._setRawValue(this.settings.emptyInputBehavior);
                                value = this.constructor._roundFormattedValueShownOnFocusOrBlur(this.settings.emptyInputBehavior, this.settings, this.isFocused);
                            }
                    }
                }

                let groupedValue = this.constructor._orderValueCurrencySymbolAndSuffixText(value, this.settings, false);
                if (!(this.constructor._isElementValueEmptyOrOnlyTheNegativeSign(value, this.settings) ||
                        (isRawValueNull && this.settings.emptyInputBehavior === AutoNumeric.options.emptyInputBehavior.null))) {
                    groupedValue = this.constructor._addGroupSeparators(value, this.settings, false, rawValueToFormat);
                }

                // Testing for `allowDecimalPadding.never` or `allowDecimalPadding.floats` is needed to make sure we do not keep a trailing decimalCharacter (like '500.') in the element, since the raw value would still be a correctly formatted integer ('500')
                if (groupedValue !== rawValueToFormat ||
                    rawValueToFormat === '' || // This make sure we get rid on any currency symbol or suffix that might have been added on focus
                    this.settings.allowDecimalPadding === AutoNumeric.options.allowDecimalPadding.never ||
                    this.settings.allowDecimalPadding === AutoNumeric.options.allowDecimalPadding.floats) {
                    if (this.settings.symbolWhenUnfocused && rawValueToFormat !== '' && rawValueToFormat !== null) {
                        groupedValue = `${groupedValue}${this.settings.symbolWhenUnfocused}`;
                    }

                    this._setElementValue(groupedValue);
                }
            }

            this._setValidOrInvalidState(this.rawValue);

            if (e.type === 'blur') {
                //TODO Create separate handlers for blur and mouseleave, really.
                this._onBlur(e);
            }
        }
    }
Handler for 'focusout' events
On focusout, multiple things happens :
- The element value is formatted back if the `Alt` key was pressed,
- The element value is formatted back if `showOnlyNumbersOnFocus` was set to only show numbers,
- The element value is multiplied by `rawValueDivisor` on `blur`

Note: On focusout, the `rawValue` is never changed. Only the formatted value can be modified.

@param {Event} e