static unformat(numericStringOrDomElement, ...options) {
        if (AutoNumericHelper.isNumberStrict(numericStringOrDomElement)) {
            // Giving an unformatted value should return the same unformatted value, whatever the options passed as a parameter
            return numericStringOrDomElement;
        }

        // Retrieve the value to unformat
        let value;
        if (AutoNumericHelper.isElement(numericStringOrDomElement)) {
            value = AutoNumericHelper.getElementValue(numericStringOrDomElement);
        } else {
            value = numericStringOrDomElement;
        }

        if (value === '') {
            // This allows to be coherent when serializing forms with empty inputs. Fix issue #512.
            return '';
        }

        if (AutoNumericHelper.isUndefined(value) || value === null) {
            return null;
        }

        if (AutoNumericHelper.isArray(value) || AutoNumericHelper.isObject(value)) {
            // Check the validity of the `value` parameter
            AutoNumericHelper.throwError(`A number or a string representing a number is needed to be able to unformat it, [${value}] given.`);
        }

        // Manage options
        const optionsToUse = this._generateOptionsObjectFromOptionsArray(options);

        // Generate the settings
        const settings = Object.assign({}, this.getDefaultConfig(), optionsToUse);
        settings.isNegativeSignAllowed = false;
        settings.isPositiveSignAllowed = true;
        value = value.toString();

        // Directly unformat any `valuesToStrings` values, if found
        if (settings.valuesToStrings && this._checkStringsToValuesSettings(value, settings)) {
            return AutoNumericHelper.objectKeyLookup(settings.valuesToStrings, value);
        }

        // This checks if a negative sign is anywhere in the `value`, not just on the very first character (i.e. '12345.67-')
        if (AutoNumericHelper.isNegative(value, settings.negativeSignCharacter)) {
            settings.isNegativeSignAllowed = true;
            settings.isPositiveSignAllowed = false;
        } else if (!AutoNumericHelper.isNull(settings.negativeBracketsTypeOnBlur)) {
            [settings.firstBracket, settings.lastBracket] = settings.negativeBracketsTypeOnBlur.split(',');
            if (value.charAt(0) === settings.firstBracket &&
                value.charAt(value.length - 1) === settings.lastBracket) {
                settings.isNegativeSignAllowed = true;
                settings.isPositiveSignAllowed = false;
                value = this._removeBrackets(value, settings, false);
            }
        }

        value = this._convertToNumericString(value, settings);
        if (AutoNumericHelper.isNumber(Number(value))) { // In case of numbers with the scientific notation (#757)
            value = AutoNumericHelper.scientificToDecimal(value);
        }

        const unwantedCharacters = new RegExp(`[^+-0123456789.]`, 'gi');
        if (unwantedCharacters.test(value)) {
            return NaN;
        }

        // Generate the `negativePositiveSignPlacement` option as needed
        this._correctNegativePositiveSignPlacementOption(settings);
        // Calculate the needed decimal places
        if (settings.decimalPlacesRawValue) { // `originalDecimalPlacesRawValue` needs to be defined
            settings.originalDecimalPlacesRawValue = settings.decimalPlacesRawValue;
        } else {
            settings.originalDecimalPlacesRawValue = settings.decimalPlaces;
        }

        this._calculateDecimalPlacesOnInit(settings);

        // Divide the raw value with `rawValueDivisor` if defined
        if ((!AutoNumericHelper.isUndefinedOrNullOrEmpty(settings.rawValueDivisor) && settings.rawValueDivisor !== 0) && // Only divide if the `rawValueDivisor` option is set
            value !== '' && value !== null) { // Do not modify the `value` if it's an empty string or null
            value /= settings.rawValueDivisor;
        }

        value = this._roundRawValue(value, settings);
        value = value.replace(settings.decimalCharacter, '.'); // Here we need to convert back the decimal character to a period since `_roundValue` adds it in some cases
        value = this._toLocale(value, settings.outputFormat, settings);

        return value;
    }
Unformat the given formatted string with the given options. This returns a numeric string.
It can also unformat the given DOM element value with the given options and returns the unformatted numeric string.
Note: This does *not* update that element value.
This basically allows to get the unformatted value without first having to initialize an AutoNumeric object.

@param {string|number|HTMLElement|HTMLInputElement} numericStringOrDomElement A number, or a string that represent a javascript number, or a DOM element
@param {object|null} options Multiple objects can be passed, the latter overwriting the settings from the former ones
@returns {string|number|NaN}