code: public static Collection<AbstractHtml> findAllTags(final boolean parallel,
              final AbstractHtml... fromTags) throws NullValueException {
  
          if (fromTags == null) {
              throw new NullValueException("fromTags cannot be null");
          }
  
          final Collection<Lock> locks = getReadLocks(fromTags);
          for (final Lock lock : locks) {
              lock.lock();
          }
  
          try {
              return getAllNestedChildrenIncludingParent(parallel, fromTags)
                      .collect(Collectors.toSet());
  
          } finally {
              for (final Lock lock : locks) {
                  lock.unlock();
              }
          }
      }
docs: Finds all tags including the nested tags (and including {@code NoTag})
  from the given tags.
  
  @param parallel
  true to internally use parallel stream. If true it
  will split the finding task to different batches and
  will execute the batches in different threads in
  parallel consuming all CPUs. It will perform faster
  in finding from extremely large number of tags but at
  the same time it will less efficient in finding from
  small number of tags.
  
  @param fromTags
  to find all tags from these tags
  @return all tags including the nested tags from the given tags.
  @throws NullValueException
  if {@code fromTags} is null
  @since 3.0.0
  @author WFF