* @throws IllegalArgumentException if this is not a well-formed media type.
     */
    @JvmStatic
    @JvmName("get")
    fun String.toMediaType(): MediaType {
      val typeSubtype =
        TYPE_SUBTYPE.matchAt(this, 0)
          ?: throw IllegalArgumentException("No subtype found for: \"$this\"")
      val type = typeSubtype.groupValues[1].lowercase()
      val subtype = typeSubtype.groupValues[2].lowercase()

  private static final class IsEither extends FastMatcher {

    private final char match1;
    private final char match2;

    IsEither(char match1, char match2) {
      this.match1 = match1;
      this.match2 = match2;
    }

    @Override
    public boolean matches(char c) {
      return c == match1 || c == match2;
    }

    @GwtIncompatible // used only from other GwtIncompatible code

  private static final class IsEither extends FastMatcher {

    private final char match1;
    private final char match2;

    IsEither(char match1, char match2) {
      this.match1 = match1;
      this.match2 = match2;
    }

    @Override
    public boolean matches(char c) {
      return c == match1 || c == match2;
    }

    @GwtIncompatible // used only from other GwtIncompatible code

        assertTrue(pattern.matcher("text/xml-external-parsed-entity").matches());
    }

    @Test
    public void test_webHtmlRulePattern() {
        Pattern pattern = Pattern.compile(WEB_HTML_RULE_PATTERN);
        assertTrue(pattern.matcher("text/html").matches());
        assertFalse(pattern.matcher("application/xml").matches());
    }

    @Test

        }

        /**
         * Matches the given path.
         *
         * @param path The path to match.
         * @return True if the path matches, otherwise false.
         */
        public boolean match(final String path) {
            if (includedPaths == null) {
                if (excludedPaths != null && excludedPaths.matcher(path).matches()) {
                    if (logger.isDebugEnabled()) {

    assertFalse(matcher.matches(s.charAt(0)));
    assertFalse(matcher.apply(s.charAt(0)));
    assertEquals(-1, matcher.indexIn(s));
    assertEquals(-1, matcher.indexIn(s, 0));
    assertEquals(-1, matcher.indexIn(s, 1));
    assertEquals(-1, matcher.lastIndexIn(s));
    assertFalse(matcher.matchesAnyOf(s));
    assertFalse(matcher.matchesAllOf(s));
    assertTrue(matcher.matchesNoneOf(s));

    checkArgument(
        !separatorPattern.matcher("").matches(),
        "The pattern may not match the empty string: %s",
        separatorPattern);

    return new Splitter(
        (splitter, toSplit) -> {
          CommonMatcher matcher = separatorPattern.matcher(toSplit);
          return new SplittingIterator(splitter, toSplit) {
            @Override

    checkArgument(
        !separatorPattern.matcher("").matches(),
        "The pattern may not match the empty string: %s",
        separatorPattern);

    return new Splitter(
        (splitter, toSplit) -> {
          CommonMatcher matcher = separatorPattern.matcher(toSplit);
          return new SplittingIterator(splitter, toSplit) {
            @Override

      var month = -1
      var year = -1
      val matcher = TIME_PATTERN.matcher(s)

      while (pos < limit) {
        val end = dateCharacterOffset(s, pos + 1, limit, true)
        matcher.region(pos, end)

        when {
          hour == -1 && matcher.usePattern(TIME_PATTERN).matches() -> {
            hour = matcher.group(1).toInt()
            minute = matcher.group(2).toInt()

        Matcher matcher = linkPattern.matcher(line);
        while (matcher.find()) {
            MatchResult xrefMatcher = matcher.toMatchResult();
            String link = xrefMatcher.group(1);
            if (link.contains("#")) {
                Matcher linkMatcher = linkWithHashPattern.matcher(link);
                if (linkMatcher.matches()) {