code: public Set<Deque<Archive>> inverseDependences() throws IOException {
          // create a new dependency finder to do the analysis
          DependencyFinder dependencyFinder = new DependencyFinder(configuration, DEFAULT_FILTER);
          try {
              // parse all archives in unnamed module to get compile-time dependences
              Stream<Archive> archives =
                  Stream.concat(configuration.initialArchives().stream(),
                                configuration.classPathArchives().stream());
              if (apiOnly) {
                  dependencyFinder.parseExportedAPIs(archives);
              } else {
                  dependencyFinder.parse(archives);
              }
  
              Graph.Builder<Archive> builder = new Graph.Builder<>();
              // include all target nodes
              targets().forEach(builder::addNode);
  
              // transpose the module graph
              configuration.getModules().values().stream()
                  .forEach(m -> {
                      builder.addNode(m);
                      m.descriptor().requires().stream()
                          .map(Requires::name)
                          .map(configuration::findModule)  // must be present
                          .forEach(v -> builder.addEdge(v.get(), m));
                  });
  
              // add the dependences from the analysis
              Map<Archive, Set<Archive>> dependences = dependencyFinder.dependences();
              dependences.entrySet().stream()
                  .forEach(e -> {
                      Archive u = e.getKey();
                      builder.addNode(u);
                      e.getValue().forEach(v -> builder.addEdge(v, u));
                  });
  
              // transposed dependence graph.
              Graph<Archive> graph = builder.build();
              trace("targets: %s%n", targets());
  
              // Traverse from the targets and find all paths
              // rebuild a graph with all nodes that depends on targets
              // targets directly and indirectly
              return targets().stream()
                  .map(t -> findPaths(graph, t))
                  .flatMap(Set::stream)
                  .collect(Collectors.toSet());
          } finally {
              dependencyFinder.shutdown();
          }
      }
docs: Finds all inverse transitive dependencies using the given requires set
  as the targets, if non-empty.  If the given requires set is empty,
  use the archives depending the packages specified in -regex or -p options.