docs: function (entryStr, patternString, formatSymbols) {
              var patternDescription = this._explode(patternString);
              var regexpes, sign = '', grouping, decimal, strict, repeat = patternDescription.regularGroup, buildRegExp = !!formatSymbols;
  
              formatSymbols = this._normalizeSymbols(formatSymbols);
              grouping = formatSymbols.groupingSeparator;
              decimal = formatSymbols.decimalSeparator;
              strict = formatSymbols.strictGrouping;
  
              if (buildRegExp) {
                  regexpes = this._buildRegEx(grouping, decimal);
              } else {
                  regexpes = {
                      group : this._removeGrouping,
                      decimal : this._replaceDecimal
                  };
              }
  
              var first = entryStr.charAt(0);
              if (first === "+" || first === "-") {
                  sign = first;
  
                  entryStr = entryStr.substring(1);
                  first = entryStr.charAt(0);
              }
  
              var iOfEntry = entryStr.lastIndexOf(grouping);
              if (iOfEntry > -1) {
                  // avoid having grouping separator after a decimal symbol
                  var iOfDecimal = entryStr.indexOf(decimal);
                  if (iOfDecimal > -1 && iOfDecimal < iOfEntry) {
                      return null;
                  }
  
                  if (first === grouping) {
                      return null;
                  }
  
                  // strict false there's nothing else to check
                  if (strict) {
                      if (!patternDescription.hasGrouping) {
                          // a grouping separator was used in the string but not in the pattern
                          return null;
                      }
  
                      var patternTokens, tokens = entryStr.split(grouping);
                      if (repeat === 0) {
                          patternTokens = patternDescription.integer.split(",");
                          if (patternTokens.length < tokens.length) {
                              // entry string has more separator than the pattern (which is not regular)
                              return null;
                          }
                      }
  
                      // The first token has a length constraint only in regular patterns
                      var group = tokens[0];
  
                      if ((repeat > 0 && group.length > repeat) || !this._digitsOnly.test(group)) {
                          return null;
                      }
  
                      // Check the other tokens, except the last one (it might contain a comma)
                      for (var i = tokens.length - 2; i > 0; i -= 1) {
                          group = tokens[i];
                          var expectedLength = repeat || patternTokens[i].length;
  
                          if (group.length !== expectedLength || group.indexOf(decimal) !== -1) {
                              return null;
                          }
                      }
  
                      // Now check the last one, it's length can be bigger than regularGroup if it contains a
                      // decimal separator after regularGroup letters
                      group = tokens[tokens.length - 1];
                      expectedLength = repeat || patternTokens[patternTokens.length - 1].length;
                      if (group.length !== expectedLength && group.charAt(expectedLength) !== decimal) {
                          return null;
                      }
  
                  }
              }
  
              entryStr = sign + entryStr.replace(regexpes.group, "");
  
              // To be valid the string should contain only ., but if we localized the application to have
              // a different decimal separator, . is invalid, check that
              if (decimal !== "." && entryStr.indexOf(".") !== -1) {
                  return null;
              }
  
              // Only here it's safe to replace the decimal symbol with a dot.
              entryStr = entryStr.replace(regexpes.decimal, ".");
  
              if (!this._validDigits.test(entryStr)) {
                  return null;
              }
  
              return entryStr;
          }