code: public static <K, V> Map<K, V> dropWhile(Map<K, V> self, @ClosureParams(MapEntryOrKeyValue.class) Closure<?> condition) {
          if (self.isEmpty()) {
              return createSimilarMap(self);
          }
          Map<K, V> ret = createSimilarMap(self);
          boolean dropping = true;
          BooleanClosureWrapper bcw = new BooleanClosureWrapper(condition);
          for (Map.Entry<K, V> entry : self.entrySet()) {
              if (dropping && !bcw.callForMap(entry)) dropping = false;
              if (!dropping) ret.put(entry.getKey(), entry.getValue());
          }
          return ret;
      }
docs: Create a suffix of the given Map by dropping as many entries as possible from the
  front of the original Map such that calling the given closure condition evaluates to
  true when passed each of the dropped entries (or key/value pairs).
  <pre class="groovyTestCase">
  def shopping = [milk:1, bread:2, chocolate:3]
  assert shopping.dropWhile{ it.key.size() < 6 } == [chocolate:3]
  assert shopping.dropWhile{ it.value % 2 } == [bread:2, chocolate:3]
  assert shopping.dropWhile{ k, v -> k.size() + v <= 7 } == [chocolate:3]
  </pre>
  If the map instance does not have ordered keys, then this function could appear to drop random
  entries. Groovy by default uses LinkedHashMap, so this shouldn't be an issue in the main.
  
  @param self      a Map
  @param condition a 1 (or 2) arg Closure that must evaluate to true for the
  entry (or key and value) to continue dropping elements
  @return the shortest suffix of the given Map such that the given closure condition
  evaluates to true for each element dropped from the front of the Map
  @since 1.8.7