collection.forEach(element -> arraySettings.add(new Tuple<>(key, element)));
                } else if (value instanceof Object[]) {
                    for (final Object element : (Object[]) value) {
                        arraySettings.add(new Tuple<>(key, element));
                    }
                } else {
                    defaultSettings.put(key, value);

urn document.querySelector(t)}},{key:"defaultText",value:function(t){return m("text",t)}},{key:"destroy",value:function(){this.listener.destroy()}}])&&d(t.prototype,e),n&&d(t,n),r}()},828:function(t){var e;"undefined"==typeof Element||Element.prototype.matches||((e=Element.prototype).matches=e.matchesSelector||e.mozMatchesSelector||e.msMatchesSelector||e.oMatchesSelector||e.webkitMatchesSelector),t.exports=function(t,e){for(;t&&9!==t.nodeType;){if("function"==typeof t.matches&&t.matches(e))return...

            return parent.get(index);
        }

        @Override
        public E set(final int index, final E element) {
            return parent.set(index, element);
        }

        @Override
        public void add(final int index, final E element) {
            parent.add(index, element);
        }

        @Override
        public E remove(final int index) {
            return parent.remove(index);

     */
    ParameterizedClassDesc[] getParameterizedClassDescs();

    /**
     * Returns the element type if the parameter type of the method is a parameterized {@link Collection}.
     *
     * @param index
     *            The index of the parameter
     * @return The element type if the parameter type is a parameterized {@link Collection}, otherwise {@literal null}
     */

        assertTrue(exception.getStackTrace().length > 0);

        // Should contain this test method in stack trace
        boolean foundTestMethod = false;
        for (StackTraceElement element : exception.getStackTrace()) {
            if (element.getMethodName().contains("testStackTracePreservation")) {
                foundTestMethod = true;
                break;
            }
        }
        assertTrue(foundTestMethod);

      int tmp = array[i];
      array[i] = array[j];
      array[j] = tmp;
    }
  }

  /**
   * Performs a right rotation of {@code array} of "distance" places, so that the first element is
   * moved to index "distance", and the element at index {@code i} ends up at index {@code (distance
   * + i) mod array.length}. This is equivalent to {@code Collections.rotate(Ints.asList(array),

         * If the given {@code paths} argument contains no element, then this method returns an empty string.
         *
         * @param paths the path to format as a string
         * @return the option associated to this path type followed by the given path elements,
         *         or an empty array if there is no path element.
         */
        @Nonnull
        @Override

    List<Object> list = new ArrayList<>(equalityGroup.length);
    for (int i = 0; i < equalityGroup.length; i++) {
      Object element = equalityGroup[i];
      if (element == null) {
        throw new NullPointerException("at index " + i);
      }
      list.add(element);
    }
    equalityGroups.add(list);
    return this;
  }

  /** Run tests on equals method, throwing a failure on an invalid test */

    /**
     * Returns {@code true} if reported problem count exceeded allowed count, and issues were lost. When this
     * method returns {@code true}, it means that element count of stream returned by method {@link #problems()}
     * and the counter returned by {@link #totalProblemsReported()} are not equal (latter is bigger than former).
     *

      stackWithLastReturnedElementAtTop.pop();
      stackWithLastReturnedElementAtTop.push(e);
    }

    /**
     * Moves the given element from its current position in {@link #nextElements} to the top of the
     * stack so that it is returned by the next call to {@link Iterator#next()}. If the element is
     * not in {@link #nextElements}, this method throws an {@link UnknownElementException}.
     *