E[] elements = createSamplesArray();
    E duplicate = elements[(elements.length / 2) - 1];
    elements[(elements.length / 2) + 1] = duplicate;
    return new ArrayWithDuplicate<>(elements, duplicate);
  }

  // Helper methods to improve readability of derived classes

  protected int getNumElements() {
    return getSubjectGenerator().getCollectionSize().getNumElements();
  }

    }

    @Override
    public boolean add(T element) {
      return standardAdd(element);
    }

    @Override
    public boolean addAll(Collection<? extends T> collection) {
      return standardAddAll(collection);
    }

    @Override
    public boolean addAll(int index, Collection<? extends T> elements) {
      return standardAddAll(index, elements);
    }

    @Override
    public void clear() {

   * default initial capacity, load factor, and concurrency settings.
   *
   * <p>This implementation is highly efficient when {@code elements} is itself a {@link Multiset}.
   *
   * @param elements the elements that the multiset should contain
   */
  public static <E> ConcurrentHashMultiset<E> create(Iterable<? extends E> elements) {

            Element moduleBRoot = moduleBDoc.root();
            Element build = moduleBRoot.child("build").orElse(null);
            Element plugins = build.child("plugins").orElse(null);
            Element plugin = plugins.child("plugin").orElse(null);
            Element dependencies = plugin.child("dependencies").orElse(null);
            Element dependency = dependencies.child("dependency").orElse(null);

 *   <li>{@code merge} (default): Merges elements with matching names</li>
 *   <li>{@code append}: Adds elements as siblings</li>
 * </ul>
 *
 * <p>Self combination modes (specified by {@code combine.self} attribute):</p>
 * <ul>
 *   <li>{@code merge} (default): Merges attributes and values</li>
 *   <li>{@code override}: Completely replaces the element</li>
 *   <li>{@code remove}: Removes the element</li>
 * </ul>
 *

    }

    /**
     * Adds an element to the beginning of a sequenced collection.
     *
     * @param <E> the element type
     * @param collection the sequenced collection
     * @param element the element to add
     * @since Java 21
     */
    public static <E> void addFirst(final SequencedCollection<E> collection, final E element) {
        collection.addFirst(element);
    }

    /**

////

//// tab | Info

„title“-Attribute von „abbr“-Elementen werden nach bestimmten Anweisungen übersetzt.

Übersetzungen können eigene „abbr“-Elemente hinzufügen, die das LLM nicht entfernen soll. Z. B. um englische Wörter zu erklären.

Siehe Abschnitt `### HTML abbr elements` im allgemeinen Prompt in `scripts/translate.py`.

////

## Überschriften { #headings }

 * <i>lesser</i> are considered to refer to the comparator on the elements, and the terms
 * <i>first</i> and <i>last</i> are considered to refer to the elements' ordering in a list.
 *
 * @author Louis Wasserman
 */
@GwtCompatible
final class SortedLists {
  private SortedLists() {}

  /**
   * A specification for which index to return if the list contains at least one element that
   * compares as equal to the key.
   */

  @JsMethod(name = "of")
  static <E> ImmutableList<E> jsOf(E... elements) {
    return copyOf(elements);
  }

  public static <E> ImmutableList<E> copyOf(Iterable<? extends E> elements) {
    checkNotNull(elements); // for GWT
    return (elements instanceof Collection)
        ? copyOf((Collection<? extends E>) elements)
        : copyOf(elements.iterator());
  }

      return standardAddAll(collection);
    }

    @Override
    public boolean add(T element) {
      return standardAdd(element);
    }

    @Override
    public void clear() {
      standardClear();
    }

    @Override
    public int count(Object element) {
      return standardCount(element);
    }

    @Override
    public boolean contains(Object object) {