docs: private Matcher<?> getMatcher(String matcherName, String[] matcherParameter) {
          try {
              if (noArgumentMatchers.contains(matcherName)) {
                  Method matcherMethod = ReflectionUtils.findMethod(Matchers.class, matcherName);
  
                  if (matcherMethod != null) {
                      return (Matcher) matcherMethod.invoke(null);
                  }
              }
  
              if (noArgumentCollectionMatchers.contains(matcherName)) {
                  Method matcherMethod = ReflectionUtils.findMethod(Matchers.class, matcherName);
  
                  if (matcherMethod != null) {
                      return (Matcher) matcherMethod.invoke(null);
                  }
              }
  
              Assert.isTrue(matcherParameter.length > 0, "Missing matcher parameter");
  
              if (containerMatchers.contains(matcherName)) {
                  Method matcherMethod = ReflectionUtils.findMethod(Matchers.class, matcherName, Matcher.class);
  
                  if (matcherMethod != null) {
                      String matcherExpression = matcherParameter[0];
  
                      if (matcherExpression.contains("(") && matcherExpression.contains(")")) {
                          String nestedMatcherName = matcherExpression.trim().substring(0, matcherExpression.trim().indexOf("("));
                          String[] nestedMatcherParameter = matcherExpression.trim().substring(nestedMatcherName.length() + 1, matcherExpression.trim().length() - 1).split(",");
  
                          return (Matcher) matcherMethod.invoke(null, getMatcher(nestedMatcherName, nestedMatcherParameter));
                      }
                  }
              }
  
              if (iterableMatchers.contains(matcherName)) {
                  Method matcherMethod = ReflectionUtils.findMethod(Matchers.class, matcherName, Iterable.class);
  
                  if (matcherMethod != null) {
                      List<Matcher> nestedMatchers = new ArrayList<>();
                      for (String matcherExpression : matcherParameter) {
                          String nestedMatcherName = matcherExpression.trim().substring(0, matcherExpression.trim().indexOf("("));
                          String nestedMatcherParameter = matcherExpression.trim().substring(nestedMatcherName.length() + 1, matcherExpression.trim().length() - 1);
                          nestedMatchers.add(getMatcher(nestedMatcherName, new String[] { nestedMatcherParameter }));
                      }
  
                      return (Matcher) matcherMethod.invoke(null, nestedMatchers);
                  }
              }
  
              Optional<HamcrestMatcherProvider> matcherProvider = customMatchers.stream()
                                                                                  .filter(provider -> provider.getName().equals(matcherName))
                                                                                  .findFirst();
              if (matcherProvider.isPresent()) {
                  return matcherProvider.get().provideMatcher(matcherParameter[0]);
              }
  
              if (matchers.contains(matcherName)) {
                  Method matcherMethod = ReflectionUtils.findMethod(Matchers.class, matcherName, String.class);
  
                  if (matcherMethod == null) {
                      matcherMethod =  ReflectionUtils.findMethod(Matchers.class, matcherName, Object.class);
                  }
  
                  if (matcherMethod != null) {
                      return (Matcher) matcherMethod.invoke(null, matcherParameter[0]);
                  }
              }
  
              if (numericMatchers.contains(matcherName)) {
                  Method matcherMethod = ReflectionUtils.findMethod(Matchers.class, matcherName, double.class, double.class);
  
                  if (matcherMethod != null) {
                      return (Matcher) matcherMethod.invoke(null, Double.valueOf(matcherParameter[0]), matcherParameter.length > 1 ? Double.valueOf(matcherParameter[1]) : 0.0D);
                  }
  
                  matcherMethod = ReflectionUtils.findMethod(Matchers.class, matcherName, Comparable.class);
  
                  if (matcherMethod != null) {
                      return (Matcher) matcherMethod.invoke(null, matcherParameter[0]);
                  }
              }
  
              if (collectionMatchers.contains(matcherName)) {
                  Method matcherMethod = ReflectionUtils.findMethod(Matchers.class, matcherName, int.class);
  
                  if (matcherMethod != null) {
                      return (Matcher) matcherMethod.invoke(null, Integer.valueOf(matcherParameter[0]));
                  }
  
                  matcherMethod =  ReflectionUtils.findMethod(Matchers.class, matcherName, Object.class);
  
                  if (matcherMethod != null) {
                      return (Matcher) matcherMethod.invoke(null, matcherParameter[0]);
                  }
  
                  matcherMethod =  ReflectionUtils.findMethod(Matchers.class, matcherName, Object[].class);
  
                  if (matcherMethod != null) {
                      return (Matcher) matcherMethod.invoke(null, new Object[] { matcherParameter });
                  }
              }
  
              if (mapMatchers.contains(matcherName)) {
                  Method matcherMethod =  ReflectionUtils.findMethod(Matchers.class, matcherName, Object.class);
  
                  if (matcherMethod != null) {
                      return (Matcher) matcherMethod.invoke(null, matcherParameter[0]);
                  }
  
                  matcherMethod =  ReflectionUtils.findMethod(Matchers.class, matcherName, Object.class, Object.class);
  
                  if (matcherMethod != null) {
                      return (Matcher) matcherMethod.invoke(null, matcherParameter[0], matcherParameter[1]);
                  }
              }
  
              if (optionMatchers.contains(matcherName)) {
                  Method matcherMethod =  ReflectionUtils.findMethod(Matchers.class, matcherName, Object[].class);
  
                  if (matcherMethod != null) {
                      return (Matcher) matcherMethod.invoke(null, new Object[] { matcherParameter });
                  }
  
                  matcherMethod =  ReflectionUtils.findMethod(Matchers.class, matcherName, Collection.class);
  
                  if (matcherMethod != null) {
                      return (Matcher) matcherMethod.invoke(null, new Object[] { getCollection(StringUtils.arrayToCommaDelimitedString(matcherParameter)) });
                  }
              }
          } catch (InvocationTargetException | IllegalAccessException e) {
              throw new CitrusRuntimeException("Failed to invoke matcher", e);
          }
  
          throw new CitrusRuntimeException("Unsupported matcher: " + matcherName);
      }