private final boolean digit;

    private final boolean letter;

    public CharTypeFilterFactory(final IndexSettings indexSettings, final Environment environment, final String name,
            final Settings settings) {
        super(indexSettings, name, settings);

        alphabetic = settings.getAsBoolean("alphabetic", true);
        digit = settings.getAsBoolean("digit", true);

//
// The serialization format is:
//
// ```
// <quantity>        ::= <signedNumber><suffix>
//
// 	(Note that <suffix> may be empty, from the "" case in <decimalSI>.)
//
// <digit>           ::= 0 | 1 | ... | 9
// <digits>          ::= <digit> | <digit><digits>
// <number>          ::= <digits> | <digits>.<digits> | <digits>. | .<digits>
// <sign>            ::= "+" | "-"
// <signedNumber>    ::= <number> | <sign><number>

constraints.LuhnCheck.message               = The check digit for ${value} is invalid, Luhn Modulo 10 checksum failed.
constraints.Mod10Check.message              = The check digit for ${value} is invalid, Modulo 10 checksum failed.
constraints.Mod11Check.message              = The check digit for ${value} is invalid, Modulo 11 checksum failed.
constraints.ModCheck.message                = The check digit for ${value} is invalid, ${modType} checksum failed.

1F106         ; disallowed_STD3_mapped ; 0035 002C     # 5.2  DIGIT FIVE COMMA
1F107         ; disallowed_STD3_mapped ; 0036 002C     # 5.2  DIGIT SIX COMMA
1F108         ; disallowed_STD3_mapped ; 0037 002C     # 5.2  DIGIT SEVEN COMMA
1F109         ; disallowed_STD3_mapped ; 0038 002C     # 5.2  DIGIT EIGHT COMMA
1F10A         ; disallowed_STD3_mapped ; 0039 002C     # 5.2  DIGIT NINE COMMA

      int digit = Character.digit(string.charAt(pos), radix);
      if (digit == -1) {
        throw new NumberFormatException(string);
      }
      if (pos > maxSafePos && ParseOverflowDetection.overflowInParse(value, digit, radix)) {
        throw new NumberFormatException("Too large for unsigned long: " + string);
      }
      value = (value * radix) + digit;
    }

    return value;
  }

        run: |
          # [[:digit:]] searches for numbers and \+ joins them together
          major_version=$(grep "^#define TF_MAJOR_VERSION" ./tensorflow/core/public/version.h | grep -o "[[:digit:]]\+")
          minor_version=$(grep "^#define TF_MINOR_VERSION" ./tensorflow/core/public/version.h | grep -o "[[:digit:]]\+")
          echo "TF_VERSION=${major_version}.${minor_version}" >> "$GITHUB_OUTPUT"

      throw new NumberFormatException();
    }
    int octet = 0;
    for (int i = start; i < end; i++) {
      octet *= 10;
      int digit = Character.digit(ipString.charAt(i), 10);
      if (digit < 0) {
        throw new NumberFormatException();
      }
      octet += digit;
    }
    if (octet > 255) {
      throw new NumberFormatException();
    }
    return (byte) octet;
  }

        if (pos == limit) return false // Malformed.
        val c = string[pos++]
        val digit =
          when (c) {
            in 'a'..'z' -> c - 'a'
            in 'A'..'Z' -> c - 'A'
            in '0'..'9' -> c - '0' + 26
            else -> return false // Malformed.
          }
        val deltaI = digit * w
        if (i > Int.MAX_VALUE - deltaI) return false // Prevent overflow.
        i += deltaI

     */
    @Test
    void testMng6572() {
        String a = "20190126.230843"; // resembles a SNAPSHOT
        String b = "1234567890.12345"; // 10 digit number
        String c = "123456789012345.1H.5-beta"; // 15 digit number
        String d = "12345678901234567890.1H.5-beta"; // 20 digit number

        checkVersionsOrder(a, b);
        checkVersionsOrder(b, c);
        checkVersionsOrder(a, c);
        checkVersionsOrder(c, d);

   *   <li>All other characters are converted into one or more bytes using UTF-8 encoding and each
   *       byte is then represented by the 3-character string "%XY", where "XY" is the two-digit,
   *       uppercase, hexadecimal representation of the byte value.
   * </ul>
   *
   * <p>This escaper is suitable for escaping parameter names and values even when <a