docs: private void findNestedClasspathElements(final List<SimpleEntry<String, ClasspathElement>> classpathElts,
              final LogNode log) {
          // Sort classpath elements into lexicographic order
          CollectionUtils.sortIfNotEmpty(classpathElts, new Comparator<SimpleEntry<String, ClasspathElement>>() {
              @Override
              public int compare(final SimpleEntry<String, ClasspathElement> o1,
                      final SimpleEntry<String, ClasspathElement> o2) {
                  return o1.getKey().compareTo(o2.getKey());
              }
          });
          // Find any nesting of elements within other elements
          for (int i = 0; i < classpathElts.size(); i++) {
              // See if each classpath element is a prefix of any others (if so, they will immediately follow
              // in lexicographic order)
              final SimpleEntry<String, ClasspathElement> ei = classpathElts.get(i);
              final String basePath = ei.getKey();
              final int basePathLen = basePath.length();
              for (int j = i + 1; j < classpathElts.size(); j++) {
                  final SimpleEntry<String, ClasspathElement> ej = classpathElts.get(j);
                  final String comparePath = ej.getKey();
                  final int comparePathLen = comparePath.length();
                  boolean foundNestedClasspathRoot = false;
                  if (comparePath.startsWith(basePath) && comparePathLen > basePathLen) {
                      // Require a separator after the prefix
                      final char nextChar = comparePath.charAt(basePathLen);
                      if (nextChar == '/' || nextChar == '!') {
                          // basePath is a path prefix of comparePath. Ensure that the nested classpath does
                          // not contain another '!' zip-separator (since classpath scanning does not recurse
                          // to jars-within-jars unless they are explicitly listed on the classpath)
                          final String nestedClasspathRelativePath = comparePath.substring(basePathLen + 1);
                          if (nestedClasspathRelativePath.indexOf('!') < 0) {
                              // Found a nested classpath root
                              foundNestedClasspathRoot = true;
                              // Store link from prefix element to nested elements
                              final ClasspathElement baseElement = ei.getValue();
                              if (baseElement.nestedClasspathRootPrefixes == null) {
                                  baseElement.nestedClasspathRootPrefixes = new ArrayList<>();
                              }
                              baseElement.nestedClasspathRootPrefixes.add(nestedClasspathRelativePath + "/");
                              if (log != null) {
                                  log.log(basePath + " is a prefix of the nested element " + comparePath);
                              }
                          }
                      }
                  }
                  if (!foundNestedClasspathRoot) {
                      // After the first non-match, there can be no more prefix matches in the sorted order
                      break;
                  }
              }
          }
      }