@sitevision/api 2023.2.1 → 2023.2.2-beta.2

package/types/java/util/SortedSet/index.d.ts

@@ -0,0 +1,179 @@
+import type { Comparator } from "../Comparator";
+
+import type { Spliterator } from "../Spliterator";
+import type { Set } from "../Set";
+
+/**
+ * A {@link Set} that further provides a <i>total ordering</i> on its elements.
+ *  The elements are ordered using their {@linkplain Comparable natural
+ *  ordering}, or by a {@link Comparator} typically provided at sorted
+ *  set creation time.  The set's iterator will traverse the set in
+ *  ascending element order. Several additional operations are provided
+ *  to take advantage of the ordering.  (This interface is the set
+ *  analogue of {@link SortedMap}.)
+ *
+ *  <p>All elements inserted into a sorted set must implement the <tt>Comparable</tt>
+ *  interface (or be accepted by the specified comparator).  Furthermore, all
+ *  such elements must be <i>mutually comparable</i>: <tt>e1.compareTo(e2)</tt>
+ *  (or <tt>comparator.compare(e1, e2)</tt>) must not throw a
+ *  <tt>ClassCastException</tt> for any elements <tt>e1</tt> and <tt>e2</tt> in
+ *  the sorted set.  Attempts to violate this restriction will cause the
+ *  offending method or constructor invocation to throw a
+ *  <tt>ClassCastException</tt>.
+ *
+ *  <p>Note that the ordering maintained by a sorted set (whether or not an
+ *  explicit comparator is provided) must be <i>consistent with equals</i> if
+ *  the sorted set is to correctly implement the <tt>Set</tt> interface.  (See
+ *  the <tt>Comparable</tt> interface or <tt>Comparator</tt> interface for a
+ *  precise definition of <i>consistent with equals</i>.)  This is so because
+ *  the <tt>Set</tt> interface is defined in terms of the <tt>equals</tt>
+ *  operation, but a sorted set performs all element comparisons using its
+ *  <tt>compareTo</tt> (or <tt>compare</tt>) method, so two elements that are
+ *  deemed equal by this method are, from the standpoint of the sorted set,
+ *  equal.  The behavior of a sorted set <i>is</i> well-defined even if its
+ *  ordering is inconsistent with equals; it just fails to obey the general
+ *  contract of the <tt>Set</tt> interface.
+ *
+ *  <p>All general-purpose sorted set implementation classes should
+ *  provide four "standard" constructors: 1) A void (no arguments)
+ *  constructor, which creates an empty sorted set sorted according to
+ *  the natural ordering of its elements.  2) A constructor with a
+ *  single argument of type <tt>Comparator</tt>, which creates an empty
+ *  sorted set sorted according to the specified comparator.  3) A
+ *  constructor with a single argument of type <tt>Collection</tt>,
+ *  which creates a new sorted set with the same elements as its
+ *  argument, sorted according to the natural ordering of the elements.
+ *  4) A constructor with a single argument of type <tt>SortedSet</tt>,
+ *  which creates a new sorted set with the same elements and the same
+ *  ordering as the input sorted set.  There is no way to enforce this
+ *  recommendation, as interfaces cannot contain constructors.
+ *
+ *  <p>Note: several methods return subsets with restricted ranges.
+ *  Such ranges are <i>half-open</i>, that is, they include their low
+ *  endpoint but not their high endpoint (where applicable).
+ *  If you need a <i>closed range</i> (which includes both endpoints), and
+ *  the element type allows for calculation of the successor of a given
+ *  value, merely request the subrange from <tt>lowEndpoint</tt> to
+ *  <tt>successor(highEndpoint)</tt>.  For example, suppose that <tt>s</tt>
+ *  is a sorted set of strings.  The following idiom obtains a view
+ *  containing all of the strings in <tt>s</tt> from <tt>low</tt> to
+ *  <tt>high</tt>, inclusive:<pre>
+ *    SortedSet&lt;String&gt; sub = s.subSet(low, high+"\0");</pre>
+ *
+ *  A similar technique can be used to generate an <i>open range</i> (which
+ *  contains neither endpoint).  The following idiom obtains a view
+ *  containing all of the Strings in <tt>s</tt> from <tt>low</tt> to
+ *  <tt>high</tt>, exclusive:<pre>
+ *    SortedSet&lt;String&gt; sub = s.subSet(low+"\0", high);</pre>
+ *
+ *  <p>This interface is a member of the
+ *  <a href="{@docRoot}/../technotes/guides/collections/index.html">
+ *  Java Collections Framework</a>.
+ * @param <E> the type of elements maintained by this set
+ * @author Josh Bloch
+ * @see Set
+ * @see TreeSet
+ * @see SortedMap
+ * @see Collection
+ * @see Comparable
+ * @see Comparator
+ * @see ClassCastException
+ * @since 1.2
+ */
+export type SortedSet = Set & {
+  /**
+   * Returns the comparator used to order the elements in this set,
+   *  or <tt>null</tt> if this set uses the {@linkplain Comparable
+   *  natural ordering} of its elements.
+   * @return the comparator used to order the elements in this set,&#xA; or <tt>null</tt> if this set uses the natural ordering&#xA; of its elements
+   */
+  comparator(): Comparator;
+
+  /**
+   * Returns a view of the portion of this set whose elements range
+   *  from <tt>fromElement</tt>, inclusive, to <tt>toElement</tt>,
+   *  exclusive.  (If <tt>fromElement</tt> and <tt>toElement</tt> are
+   *  equal, the returned set is empty.)  The returned set is backed
+   *  by this set, so changes in the returned set are reflected in
+   *  this set, and vice-versa.  The returned set supports all
+   *  optional set operations that this set supports.
+   *
+   *  <p>The returned set will throw an <tt>IllegalArgumentException</tt>
+   *  on an attempt to insert an element outside its range.
+   * @param fromElement low endpoint (inclusive) of the returned set
+   * @param toElement high endpoint (exclusive) of the returned set
+   * @return a view of the portion of this set whose elements range from&#xA; <tt>fromElement</tt>, inclusive, to <tt>toElement</tt>, exclusive
+   * @throws ClassCastException if <tt>fromElement</tt> and&#xA; <tt>toElement</tt> cannot be compared to one another using this&#xA; set's comparator (or, if the set has no comparator, using&#xA; natural ordering). Implementations may, but are not required&#xA; to, throw this exception if <tt>fromElement</tt> or&#xA; <tt>toElement</tt> cannot be compared to elements currently in&#xA; the set.
+   * @throws NullPointerException if <tt>fromElement</tt> or&#xA; <tt>toElement</tt> is null and this set does not permit null&#xA; elements
+   * @throws IllegalArgumentException if <tt>fromElement</tt> is&#xA; greater than <tt>toElement</tt>; or if this set itself&#xA; has a restricted range, and <tt>fromElement</tt> or&#xA; <tt>toElement</tt> lies outside the bounds of the range
+   */
+  subSet(fromElement: unknown, toElement: unknown): SortedSet;
+
+  /**
+   * Returns a view of the portion of this set whose elements are
+   *  strictly less than <tt>toElement</tt>.  The returned set is
+   *  backed by this set, so changes in the returned set are
+   *  reflected in this set, and vice-versa.  The returned set
+   *  supports all optional set operations that this set supports.
+   *
+   *  <p>The returned set will throw an <tt>IllegalArgumentException</tt>
+   *  on an attempt to insert an element outside its range.
+   * @param toElement high endpoint (exclusive) of the returned set
+   * @return a view of the portion of this set whose elements are strictly&#xA; less than <tt>toElement</tt>
+   * @throws ClassCastException if <tt>toElement</tt> is not compatible&#xA; with this set's comparator (or, if the set has no comparator,&#xA; if <tt>toElement</tt> does not implement {@link Comparable}).&#xA; Implementations may, but are not required to, throw this&#xA; exception if <tt>toElement</tt> cannot be compared to elements&#xA; currently in the set.
+   * @throws NullPointerException if <tt>toElement</tt> is null and&#xA; this set does not permit null elements
+   * @throws IllegalArgumentException if this set itself has a&#xA; restricted range, and <tt>toElement</tt> lies outside the&#xA; bounds of the range
+   */
+  headSet(toElement: unknown): SortedSet;
+
+  /**
+   * Returns a view of the portion of this set whose elements are
+   *  greater than or equal to <tt>fromElement</tt>.  The returned
+   *  set is backed by this set, so changes in the returned set are
+   *  reflected in this set, and vice-versa.  The returned set
+   *  supports all optional set operations that this set supports.
+   *
+   *  <p>The returned set will throw an <tt>IllegalArgumentException</tt>
+   *  on an attempt to insert an element outside its range.
+   * @param fromElement low endpoint (inclusive) of the returned set
+   * @return a view of the portion of this set whose elements are greater&#xA; than or equal to <tt>fromElement</tt>
+   * @throws ClassCastException if <tt>fromElement</tt> is not compatible&#xA; with this set's comparator (or, if the set has no comparator,&#xA; if <tt>fromElement</tt> does not implement {@link Comparable}).&#xA; Implementations may, but are not required to, throw this&#xA; exception if <tt>fromElement</tt> cannot be compared to elements&#xA; currently in the set.
+   * @throws NullPointerException if <tt>fromElement</tt> is null&#xA; and this set does not permit null elements
+   * @throws IllegalArgumentException if this set itself has a&#xA; restricted range, and <tt>fromElement</tt> lies outside the&#xA; bounds of the range
+   */
+  tailSet(fromElement: unknown): SortedSet;
+
+  /**
+   * Returns the first (lowest) element currently in this set.
+   * @return the first (lowest) element currently in this set
+   * @throws NoSuchElementException if this set is empty
+   */
+  first(): unknown;
+
+  /**
+   * Returns the last (highest) element currently in this set.
+   * @return the last (highest) element currently in this set
+   * @throws NoSuchElementException if this set is empty
+   */
+  last(): unknown;
+
+  /**
+   * Creates a {@code Spliterator} over the elements in this sorted set.
+   *
+   *  <p>The {@code Spliterator} reports {@link Spliterator#DISTINCT},
+   *  {@link Spliterator#SORTED} and {@link Spliterator#ORDERED}.
+   *  Implementations should document the reporting of additional
+   *  characteristic values.
+   *
+   *  <p>The spliterator's comparator (see
+   *  {@link java.util.Spliterator#getComparator()}) must be {@code null} if
+   *  the sorted set's comparator (see {@link #comparator()}) is {@code null}.
+   *  Otherwise, the spliterator's comparator must be the same as or impose the
+   *  same total ordering as the sorted set's comparator.
+   * @implSpec The default implementation creates a&#xA; <em><a href="Spliterator.html#binding">late-binding</a></em> spliterator&#xA; from the sorted set's {@code Iterator}. The spliterator inherits the&#xA; <em>fail-fast</em> properties of the set's iterator. The&#xA; spliterator's comparator is the same as the sorted set's comparator.&#xA; <p>&#xA; The created {@code Spliterator} additionally reports&#xA; {@link Spliterator#SIZED}.
+   * @implNote The created {@code Spliterator} additionally reports&#xA; {@link Spliterator#SUBSIZED}.
+   * @return a {@code Spliterator} over the elements in this sorted set
+   * @since 1.8
+   */
+  spliterator(): Spliterator;
+};

package/types/java/util/SortedSet/index.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _default = {
+  comparator: function comparator() {},
+  subSet: function subSet() {},
+  headSet: function headSet() {},
+  tailSet: function tailSet() {},
+  first: function first() {},
+  last: function last() {},
+  spliterator: function spliterator() {}
+};
+exports["default"] = _default;

package/types/java/util/Spliterator/index.d.ts

@@ -0,0 +1,317 @@
+import type { Consumer } from "../function/Consumer";
+
+import type { Comparator } from "../Comparator";
+
+/**
+ * An object for traversing and partitioning elements of a source.  The source
+ *  of elements covered by a Spliterator could be, for example, an array, a
+ *  {@link Collection}, an IO channel, or a generator function.
+ *
+ *  <p>A Spliterator may traverse elements individually ({@link
+ *  #tryAdvance tryAdvance()}) or sequentially in bulk
+ *  ({@link #forEachRemaining forEachRemaining()}).
+ *
+ *  <p>A Spliterator may also partition off some of its elements (using
+ *  {@link #trySplit}) as another Spliterator, to be used in
+ *  possibly-parallel operations.  Operations using a Spliterator that
+ *  cannot split, or does so in a highly imbalanced or inefficient
+ *  manner, are unlikely to benefit from parallelism.  Traversal
+ *  and splitting exhaust elements; each Spliterator is useful for only a single
+ *  bulk computation.
+ *
+ *  <p>A Spliterator also reports a set of {@link #characteristics()} of its
+ *  structure, source, and elements from among {@link #ORDERED},
+ *  {@link #DISTINCT}, {@link #SORTED}, {@link #SIZED}, {@link #NONNULL},
+ *  {@link #IMMUTABLE}, {@link #CONCURRENT}, and {@link #SUBSIZED}. These may
+ *  be employed by Spliterator clients to control, specialize or simplify
+ *  computation.  For example, a Spliterator for a {@link Collection} would
+ *  report {@code SIZED}, a Spliterator for a {@link Set} would report
+ *  {@code DISTINCT}, and a Spliterator for a {@link SortedSet} would also
+ *  report {@code SORTED}.  Characteristics are reported as a simple unioned bit
+ *  set.
+ *
+ *  Some characteristics additionally constrain method behavior; for example if
+ *  {@code ORDERED}, traversal methods must conform to their documented ordering.
+ *  New characteristics may be defined in the future, so implementors should not
+ *  assign meanings to unlisted values.
+ *
+ *  <p><a name="binding">A Spliterator that does not report {@code IMMUTABLE} or
+ *  {@code CONCURRENT} is expected to have a documented policy concerning:
+ *  when the spliterator <em>binds</em> to the element source; and detection of
+ *  structural interference of the element source detected after binding.</a>  A
+ *  <em>late-binding</em> Spliterator binds to the source of elements at the
+ *  point of first traversal, first split, or first query for estimated size,
+ *  rather than at the time the Spliterator is created.  A Spliterator that is
+ *  not <em>late-binding</em> binds to the source of elements at the point of
+ *  construction or first invocation of any method.  Modifications made to the
+ *  source prior to binding are reflected when the Spliterator is traversed.
+ *  After binding a Spliterator should, on a best-effort basis, throw
+ *  {@link ConcurrentModificationException} if structural interference is
+ *  detected.  Spliterators that do this are called <em>fail-fast</em>.  The
+ *  bulk traversal method ({@link #forEachRemaining forEachRemaining()}) of a
+ *  Spliterator may optimize traversal and check for structural interference
+ *  after all elements have been traversed, rather than checking per-element and
+ *  failing immediately.
+ *
+ *  <p>Spliterators can provide an estimate of the number of remaining elements
+ *  via the {@link #estimateSize} method.  Ideally, as reflected in characteristic
+ *  {@link #SIZED}, this value corresponds exactly to the number of elements
+ *  that would be encountered in a successful traversal.  However, even when not
+ *  exactly known, an estimated value value may still be useful to operations
+ *  being performed on the source, such as helping to determine whether it is
+ *  preferable to split further or traverse the remaining elements sequentially.
+ *
+ *  <p>Despite their obvious utility in parallel algorithms, spliterators are not
+ *  expected to be thread-safe; instead, implementations of parallel algorithms
+ *  using spliterators should ensure that the spliterator is only used by one
+ *  thread at a time.  This is generally easy to attain via <em>serial
+ *  thread-confinement</em>, which often is a natural consequence of typical
+ *  parallel algorithms that work by recursive decomposition.  A thread calling
+ *  {@link #trySplit()} may hand over the returned Spliterator to another thread,
+ *  which in turn may traverse or further split that Spliterator.  The behaviour
+ *  of splitting and traversal is undefined if two or more threads operate
+ *  concurrently on the same spliterator.  If the original thread hands a
+ *  spliterator off to another thread for processing, it is best if that handoff
+ *  occurs before any elements are consumed with {@link #tryAdvance(Consumer)
+ *  tryAdvance()}, as certain guarantees (such as the accuracy of
+ *  {@link #estimateSize()} for {@code SIZED} spliterators) are only valid before
+ *  traversal has begun.
+ *
+ *  <p>Primitive subtype specializations of {@code Spliterator} are provided for
+ *  {@link OfInt int}, {@link OfLong long}, and {@link OfDouble double} values.
+ *  The subtype default implementations of
+ *  {@link Spliterator#tryAdvance(java.util.function.Consumer)}
+ *  and {@link Spliterator#forEachRemaining(java.util.function.Consumer)} box
+ *  primitive values to instances of their corresponding wrapper class.  Such
+ *  boxing may undermine any performance advantages gained by using the primitive
+ *  specializations.  To avoid boxing, the corresponding primitive-based methods
+ *  should be used.  For example,
+ *  {@link Spliterator.OfInt#tryAdvance(java.util.function.IntConsumer)}
+ *  and {@link Spliterator.OfInt#forEachRemaining(java.util.function.IntConsumer)}
+ *  should be used in preference to
+ *  {@link Spliterator.OfInt#tryAdvance(java.util.function.Consumer)} and
+ *  {@link Spliterator.OfInt#forEachRemaining(java.util.function.Consumer)}.
+ *  Traversal of primitive values using boxing-based methods
+ *  {@link #tryAdvance tryAdvance()} and
+ *  {@link #forEachRemaining(java.util.function.Consumer) forEachRemaining()}
+ *  does not affect the order in which the values, transformed to boxed values,
+ *  are encountered.
+ * @apiNote <p>Spliterators, like {@code Iterator}s, are for traversing the elements of&#xA; a source. The {@code Spliterator} API was designed to support efficient&#xA; parallel traversal in addition to sequential traversal, by supporting&#xA; decomposition as well as single-element iteration. In addition, the&#xA; protocol for accessing elements via a Spliterator is designed to impose&#xA; smaller per-element overhead than {@code Iterator}, and to avoid the inherent&#xA; race involved in having separate methods for {@code hasNext()} and&#xA; {@code next()}.&#xA;&#xA; <p>For mutable sources, arbitrary and non-deterministic behavior may occur if&#xA; the source is structurally interfered with (elements added, replaced, or&#xA; removed) between the time that the Spliterator binds to its data source and&#xA; the end of traversal. For example, such interference will produce arbitrary,&#xA; non-deterministic results when using the {@code java.util.stream} framework.&#xA;&#xA; <p>Structural interference of a source can be managed in the following ways&#xA; (in approximate order of decreasing desirability):&#xA; <ul>&#xA; <li>The source cannot be structurally interfered with.&#xA; <br>For example, an instance of&#xA; {@link java.util.concurrent.CopyOnWriteArrayList} is an immutable source.&#xA; A Spliterator created from the source reports a characteristic of&#xA; {@code IMMUTABLE}.</li>&#xA; <li>The source manages concurrent modifications.&#xA; <br>For example, a key set of a {@link java.util.concurrent.ConcurrentHashMap}&#xA; is a concurrent source. A Spliterator created from the source reports a&#xA; characteristic of {@code CONCURRENT}.</li>&#xA; <li>The mutable source provides a late-binding and fail-fast Spliterator.&#xA; <br>Late binding narrows the window during which interference can affect&#xA; the calculation; fail-fast detects, on a best-effort basis, that structural&#xA; interference has occurred after traversal has commenced and throws&#xA; {@link ConcurrentModificationException}. For example, {@link ArrayList},&#xA; and many other non-concurrent {@code Collection} classes in the JDK, provide&#xA; a late-binding, fail-fast spliterator.</li>&#xA; <li>The mutable source provides a non-late-binding but fail-fast Spliterator.&#xA; <br>The source increases the likelihood of throwing&#xA; {@code ConcurrentModificationException} since the window of potential&#xA; interference is larger.</li>&#xA; <li>The mutable source provides a late-binding and non-fail-fast Spliterator.&#xA; <br>The source risks arbitrary, non-deterministic behavior after traversal&#xA; has commenced since interference is not detected.&#xA; </li>&#xA; <li>The mutable source provides a non-late-binding and non-fail-fast&#xA; Spliterator.&#xA; <br>The source increases the risk of arbitrary, non-deterministic behavior&#xA; since non-detected interference may occur after construction.&#xA; </li>&#xA; </ul>&#xA;&#xA; <p><b>Example.</b> Here is a class (not a very useful one, except&#xA; for illustration) that maintains an array in which the actual data&#xA; are held in even locations, and unrelated tag data are held in odd&#xA; locations. Its Spliterator ignores the tags.&#xA;&#xA; <pre> {@code&#xA; class TaggedArray<T> {&#xA; private final Object[] elements; // immutable after construction&#xA; TaggedArray(T[] data, Object[] tags) {&#xA; int size = data.length;&#xA; if (tags.length != size) throw new IllegalArgumentException();&#xA; this.elements = new Object[2 * size];&#xA; for (int i = 0, j = 0; i < size; ++i) {&#xA; elements[j++] = data[i];&#xA; elements[j++] = tags[i];&#xA; }&#xA; }&#xA;&#xA; public Spliterator<T> spliterator() {&#xA; return new TaggedArraySpliterator<>(elements, 0, elements.length);&#xA; }&#xA;&#xA; static class TaggedArraySpliterator<T> implements Spliterator<T> {&#xA; private final Object[] array;&#xA; private int origin; // current index, advanced on split or traversal&#xA; private final int fence; // one past the greatest index&#xA;&#xA; TaggedArraySpliterator(Object[] array, int origin, int fence) {&#xA; this.array = array; this.origin = origin; this.fence = fence;&#xA; }&#xA;&#xA; public void forEachRemaining(Consumer<? super T> action) {&#xA; for (; origin < fence; origin += 2)&#xA; action.accept((T) array[origin]);&#xA; }&#xA;&#xA; public boolean tryAdvance(Consumer<? super T> action) {&#xA; if (origin < fence) {&#xA; action.accept((T) array[origin]);&#xA; origin += 2;&#xA; return true;&#xA; }&#xA; else // cannot advance&#xA; return false;&#xA; }&#xA;&#xA; public Spliterator<T> trySplit() {&#xA; int lo = origin; // divide range in half&#xA; int mid = ((lo + fence) >>> 1) & ~1; // force midpoint to be even&#xA; if (lo < mid) { // split out left half&#xA; origin = mid; // reset this Spliterator's origin&#xA; return new TaggedArraySpliterator<>(array, lo, mid);&#xA; }&#xA; else // too small to split&#xA; return null;&#xA; }&#xA;&#xA; public long estimateSize() {&#xA; return (long)((fence - origin) / 2);&#xA; }&#xA;&#xA; public int characteristics() {&#xA; return ORDERED | SIZED | IMMUTABLE | SUBSIZED;&#xA; }&#xA; }&#xA; }}</pre>&#xA;&#xA; <p>As an example how a parallel computation framework, such as the&#xA; {@code java.util.stream} package, would use Spliterator in a parallel&#xA; computation, here is one way to implement an associated parallel forEach,&#xA; that illustrates the primary usage idiom of splitting off subtasks until&#xA; the estimated amount of work is small enough to perform&#xA; sequentially. Here we assume that the order of processing across&#xA; subtasks doesn't matter; different (forked) tasks may further split&#xA; and process elements concurrently in undetermined order. This&#xA; example uses a {@link java.util.concurrent.CountedCompleter};&#xA; similar usages apply to other parallel task constructions.&#xA;&#xA; <pre>{@code&#xA; static <T> void parEach(TaggedArray<T> a, Consumer<T> action) {&#xA; Spliterator<T> s = a.spliterator();&#xA; long targetBatchSize = s.estimateSize() / (ForkJoinPool.getCommonPoolParallelism() * 8);&#xA; new ParEach(null, s, action, targetBatchSize).invoke();&#xA; }&#xA;&#xA; static class ParEach<T> extends CountedCompleter<Void> {&#xA; final Spliterator<T> spliterator;&#xA; final Consumer<T> action;&#xA; final long targetBatchSize;&#xA;&#xA; ParEach(ParEach<T> parent, Spliterator<T> spliterator,&#xA; Consumer<T> action, long targetBatchSize) {&#xA; super(parent);&#xA; this.spliterator = spliterator; this.action = action;&#xA; this.targetBatchSize = targetBatchSize;&#xA; }&#xA;&#xA; public void compute() {&#xA; Spliterator<T> sub;&#xA; while (spliterator.estimateSize() > targetBatchSize &&&#xA; (sub = spliterator.trySplit()) != null) {&#xA; addToPendingCount(1);&#xA; new ParEach<>(this, sub, action, targetBatchSize).fork();&#xA; }&#xA; spliterator.forEachRemaining(action);&#xA; propagateCompletion();&#xA; }&#xA; }}</pre>
+ * @implNote If the boolean system property {@code org.openjdk.java.util.stream.tripwire}&#xA; is set to {@code true} then diagnostic warnings are reported if boxing of&#xA; primitive values occur when operating on primitive subtype specializations.
+ * @param <T> the type of elements returned by this Spliterator
+ * @see Collection
+ * @since 1.8
+ */
+export type Spliterator = {
+  /**
+   * If a remaining element exists, performs the given action on it,
+   *  returning {@code true}; else returns {@code false}.  If this
+   *  Spliterator is {@link #ORDERED} the action is performed on the
+   *  next element in encounter order.  Exceptions thrown by the
+   *  action are relayed to the caller.
+   * @param action The action
+   * @return {@code false} if no remaining elements existed&#xA; upon entry to this method, else {@code true}.
+   * @throws NullPointerException if the specified action is null
+   */
+  tryAdvance(action: Consumer): boolean;
+
+  /**
+   * Performs the given action for each remaining element, sequentially in
+   *  the current thread, until all elements have been processed or the action
+   *  throws an exception.  If this Spliterator is {@link #ORDERED}, actions
+   *  are performed in encounter order.  Exceptions thrown by the action
+   *  are relayed to the caller.
+   * @implSpec The default implementation repeatedly invokes {@link #tryAdvance} until&#xA; it returns {@code false}. It should be overridden whenever possible.
+   * @param action The action
+   * @throws NullPointerException if the specified action is null
+   */
+  forEachRemaining(action: Consumer): void;
+
+  /**
+   * If this spliterator can be partitioned, returns a Spliterator
+   *  covering elements, that will, upon return from this method, not
+   *  be covered by this Spliterator.
+   *
+   *  <p>If this Spliterator is {@link #ORDERED}, the returned Spliterator
+   *  must cover a strict prefix of the elements.
+   *
+   *  <p>Unless this Spliterator covers an infinite number of elements,
+   *  repeated calls to {@code trySplit()} must eventually return {@code null}.
+   *  Upon non-null return:
+   *  <ul>
+   *  <li>the value reported for {@code estimateSize()} before splitting,
+   *  must, after splitting, be greater than or equal to {@code estimateSize()}
+   *  for this and the returned Spliterator; and</li>
+   *  <li>if this Spliterator is {@code SUBSIZED}, then {@code estimateSize()}
+   *  for this spliterator before splitting must be equal to the sum of
+   *  {@code estimateSize()} for this and the returned Spliterator after
+   *  splitting.</li>
+   *  </ul>
+   *
+   *  <p>This method may return {@code null} for any reason,
+   *  including emptiness, inability to split after traversal has
+   *  commenced, data structure constraints, and efficiency
+   *  considerations.
+   * @apiNote An ideal {@code trySplit} method efficiently (without&#xA; traversal) divides its elements exactly in half, allowing&#xA; balanced parallel computation. Many departures from this ideal&#xA; remain highly effective; for example, only approximately&#xA; splitting an approximately balanced tree, or for a tree in&#xA; which leaf nodes may contain either one or two elements,&#xA; failing to further split these nodes. However, large&#xA; deviations in balance and/or overly inefficient {@code&#xA; trySplit} mechanics typically result in poor parallel&#xA; performance.
+   * @return a {@code Spliterator} covering some portion of the&#xA; elements, or {@code null} if this spliterator cannot be split
+   */
+  trySplit(): Spliterator;
+
+  /**
+   * Returns an estimate of the number of elements that would be
+   *  encountered by a {@link #forEachRemaining} traversal, or returns {@link
+   *  Long#MAX_VALUE} if infinite, unknown, or too expensive to compute.
+   *
+   *  <p>If this Spliterator is {@link #SIZED} and has not yet been partially
+   *  traversed or split, or this Spliterator is {@link #SUBSIZED} and has
+   *  not yet been partially traversed, this estimate must be an accurate
+   *  count of elements that would be encountered by a complete traversal.
+   *  Otherwise, this estimate may be arbitrarily inaccurate, but must decrease
+   *  as specified across invocations of {@link #trySplit}.
+   * @apiNote Even an inexact estimate is often useful and inexpensive to compute.&#xA; For example, a sub-spliterator of an approximately balanced binary tree&#xA; may return a value that estimates the number of elements to be half of&#xA; that of its parent; if the root Spliterator does not maintain an&#xA; accurate count, it could estimate size to be the power of two&#xA; corresponding to its maximum depth.
+   * @return the estimated size, or {@code Long.MAX_VALUE} if infinite,&#xA; unknown, or too expensive to compute.
+   */
+  estimateSize(): number;
+
+  /**
+   * Convenience method that returns {@link #estimateSize()} if this
+   *  Spliterator is {@link #SIZED}, else {@code -1}.
+   * @implSpec The default implementation returns the result of {@code estimateSize()}&#xA; if the Spliterator reports a characteristic of {@code SIZED}, and&#xA; {@code -1} otherwise.
+   * @return the exact size, if known, else {@code -1}.
+   */
+  getExactSizeIfKnown(): number;
+
+  /**
+   * Returns a set of characteristics of this Spliterator and its
+   *  elements. The result is represented as ORed values from {@link
+   *  #ORDERED}, {@link #DISTINCT}, {@link #SORTED}, {@link #SIZED},
+   *  {@link #NONNULL}, {@link #IMMUTABLE}, {@link #CONCURRENT},
+   *  {@link #SUBSIZED}.  Repeated calls to {@code characteristics()} on
+   *  a given spliterator, prior to or in-between calls to {@code trySplit},
+   *  should always return the same result.
+   *
+   *  <p>If a Spliterator reports an inconsistent set of
+   *  characteristics (either those returned from a single invocation
+   *  or across multiple invocations), no guarantees can be made
+   *  about any computation using this Spliterator.
+   * @apiNote The characteristics of a given spliterator before splitting&#xA; may differ from the characteristics after splitting. For specific&#xA; examples see the characteristic values {@link #SIZED}, {@link #SUBSIZED}&#xA; and {@link #CONCURRENT}.
+   * @return a representation of characteristics
+   */
+  characteristics(): number;
+
+  /**
+   * Returns {@code true} if this Spliterator's {@link
+   *  #characteristics} contain all of the given characteristics.
+   * @implSpec The default implementation returns true if the corresponding bits&#xA; of the given characteristics are set.
+   * @param characteristics the characteristics to check for
+   * @return {@code true} if all the specified characteristics are present,&#xA; else {@code false}
+   */
+  hasCharacteristics(characteristics: number): boolean;
+
+  /**
+   * If this Spliterator's source is {@link #SORTED} by a {@link Comparator},
+   *  returns that {@code Comparator}. If the source is {@code SORTED} in
+   *  {@linkplain Comparable natural order}, returns {@code null}.  Otherwise,
+   *  if the source is not {@code SORTED}, throws {@link IllegalStateException}.
+   * @implSpec The default implementation always throws {@link IllegalStateException}.
+   * @return a Comparator, or {@code null} if the elements are sorted in the&#xA; natural order.
+   * @throws IllegalStateException if the spliterator does not report&#xA; a characteristic of {@code SORTED}.
+   */
+  getComparator(): Comparator;
+
+  /**
+   * Characteristic value signifying that an encounter order is defined for
+   *  elements. If so, this Spliterator guarantees that method
+   *  {@link #trySplit} splits a strict prefix of elements, that method
+   *  {@link #tryAdvance} steps by one element in prefix order, and that
+   *  {@link #forEachRemaining} performs actions in encounter order.
+   *
+   *  <p>A {@link Collection} has an encounter order if the corresponding
+   *  {@link Collection#iterator} documents an order. If so, the encounter
+   *  order is the same as the documented order. Otherwise, a collection does
+   *  not have an encounter order.
+   * @apiNote Encounter order is guaranteed to be ascending index order for&#xA; any {@link List}. But no order is guaranteed for hash-based collections&#xA; such as {@link HashSet}. Clients of a Spliterator that reports&#xA; {@code ORDERED} are expected to preserve ordering constraints in&#xA; non-commutative parallel computations.
+   */
+  ORDERED: number;
+
+  /**
+ * Characteristic value signifying that, for each pair of
+ *  encountered elements {@code x, y}, {@code !x.equals(y)}. This
+ *  applies for example, to a Spliterator based on a {@link Set}.
+  
+    */
+  DISTINCT: number;
+
+  /**
+   * Characteristic value signifying that encounter order follows a defined
+   *  sort order. If so, method {@link #getComparator()} returns the associated
+   *  Comparator, or {@code null} if all elements are {@link Comparable} and
+   *  are sorted by their natural ordering.
+   *
+   *  <p>A Spliterator that reports {@code SORTED} must also report
+   *  {@code ORDERED}.
+   * @apiNote The spliterators for {@code Collection} classes in the JDK that&#xA; implement {@link NavigableSet} or {@link SortedSet} report {@code SORTED}.
+   */
+  SORTED: number;
+
+  /**
+   * Characteristic value signifying that the value returned from
+   *  {@code estimateSize()} prior to traversal or splitting represents a
+   *  finite size that, in the absence of structural source modification,
+   *  represents an exact count of the number of elements that would be
+   *  encountered by a complete traversal.
+   * @apiNote Most Spliterators for Collections, that cover all elements of a&#xA; {@code Collection} report this characteristic. Sub-spliterators, such as&#xA; those for {@link HashSet}, that cover a sub-set of elements and&#xA; approximate their reported size do not.
+   */
+  SIZED: number;
+
+  /**
+ * Characteristic value signifying that the source guarantees that
+ *  encountered elements will not be {@code null}. (This applies,
+ *  for example, to most concurrent collections, queues, and maps.)
+  
+    */
+  NONNULL: number;
+
+  /**
+ * Characteristic value signifying that the element source cannot be
+ *  structurally modified; that is, elements cannot be added, replaced, or
+ *  removed, so such changes cannot occur during traversal. A Spliterator
+ *  that does not report {@code IMMUTABLE} or {@code CONCURRENT} is expected
+ *  to have a documented policy (for example throwing
+ *  {@link ConcurrentModificationException}) concerning structural
+ *  interference detected during traversal.
+  
+    */
+  IMMUTABLE: number;
+
+  /**
+   * Characteristic value signifying that the element source may be safely
+   *  concurrently modified (allowing additions, replacements, and/or removals)
+   *  by multiple threads without external synchronization. If so, the
+   *  Spliterator is expected to have a documented policy concerning the impact
+   *  of modifications during traversal.
+   *
+   *  <p>A top-level Spliterator should not report both {@code CONCURRENT} and
+   *  {@code SIZED}, since the finite size, if known, may change if the source
+   *  is concurrently modified during traversal. Such a Spliterator is
+   *  inconsistent and no guarantees can be made about any computation using
+   *  that Spliterator. Sub-spliterators may report {@code SIZED} if the
+   *  sub-split size is known and additions or removals to the source are not
+   *  reflected when traversing.
+   * @apiNote Most concurrent collections maintain a consistency policy&#xA; guaranteeing accuracy with respect to elements present at the point of&#xA; Spliterator construction, but possibly not reflecting subsequent&#xA; additions or removals.
+   */
+  CONCURRENT: number;
+
+  /**
+   * Characteristic value signifying that all Spliterators resulting from
+   *  {@code trySplit()} will be both {@link #SIZED} and {@link #SUBSIZED}.
+   *  (This means that all child Spliterators, whether direct or indirect, will
+   *  be {@code SIZED}.)
+   *
+   *  <p>A Spliterator that does not report {@code SIZED} as required by
+   *  {@code SUBSIZED} is inconsistent and no guarantees can be made about any
+   *  computation using that Spliterator.
+   * @apiNote Some spliterators, such as the top-level spliterator for an&#xA; approximately balanced binary tree, will report {@code SIZED} but not&#xA; {@code SUBSIZED}, since it is common to know the size of the entire tree&#xA; but not the exact sizes of subtrees.
+   */
+  SUBSIZED: number;
+};

package/types/java/util/Spliterator/index.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _default = {
+  tryAdvance: function tryAdvance() {},
+  forEachRemaining: function forEachRemaining() {},
+  trySplit: function trySplit() {},
+  estimateSize: function estimateSize() {},
+  getExactSizeIfKnown: function getExactSizeIfKnown() {},
+  characteristics: function characteristics() {},
+  hasCharacteristics: function hasCharacteristics() {},
+  getComparator: function getComparator() {}
+};
+exports["default"] = _default;

package/types/java/util/Spliterator.OfDouble/index.d.ts

@@ -0,0 +1,28 @@
+import type { DoubleConsumer } from "../function/DoubleConsumer";
+
+import type { Consumer } from "../function/Consumer";
+import type { OfPrimitive } from "../Spliterator.OfPrimitive";
+
+/**
+ * A Spliterator specialized for {@code double} values.
+ * @since 1.8
+ */
+export type OfDouble = OfPrimitive & {
+  trySplit(): OfDouble;
+
+  tryAdvance(action: DoubleConsumer): boolean;
+
+  forEachRemaining(action: DoubleConsumer): void;
+
+  /**
+   * {@inheritDoc}
+   * @implSpec If the action is an instance of {@code DoubleConsumer} then it is
 cast to {@code DoubleConsumer} and passed to
 {@link #tryAdvance(java.util.function.DoubleConsumer)}; otherwise
 the action is adapted to an instance of {@code DoubleConsumer}, by
 boxing the argument of {@code DoubleConsumer}, and then passed to
 {@link #tryAdvance(java.util.function.DoubleConsumer)}.
+   */
+  tryAdvance(action: Consumer): boolean;
+
+  /**
+   * {@inheritDoc}
+   * @implSpec If the action is an instance of {@code DoubleConsumer} then it is
 cast to {@code DoubleConsumer} and passed to
 {@link #forEachRemaining(java.util.function.DoubleConsumer)};
 otherwise the action is adapted to an instance of
 {@code DoubleConsumer}, by boxing the argument of
 {@code DoubleConsumer}, and then passed to
 {@link #forEachRemaining(java.util.function.DoubleConsumer)}.
+   */
+  forEachRemaining(action: Consumer): void;
+};

package/types/java/util/Spliterator.OfDouble/index.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _default = {
+  trySplit: function trySplit() {},
+  tryAdvance: function tryAdvance() {},
+  forEachRemaining: function forEachRemaining() {}
+};
+exports["default"] = _default;

package/types/java/util/Spliterator.OfInt/index.d.ts

@@ -0,0 +1,28 @@
+import type { IntConsumer } from "../function/IntConsumer";
+
+import type { Consumer } from "../function/Consumer";
+import type { OfPrimitive } from "../Spliterator.OfPrimitive";
+
+/**
+ * A Spliterator specialized for {@code int} values.
+ * @since 1.8
+ */
+export type OfInt = OfPrimitive & {
+  trySplit(): OfInt;
+
+  tryAdvance(action: IntConsumer): boolean;
+
+  forEachRemaining(action: IntConsumer): void;
+
+  /**
+   * {@inheritDoc}
+   * @implSpec If the action is an instance of {@code IntConsumer} then it is cast
 to {@code IntConsumer} and passed to
 {@link #tryAdvance(java.util.function.IntConsumer)}; otherwise
 the action is adapted to an instance of {@code IntConsumer}, by
 boxing the argument of {@code IntConsumer}, and then passed to
 {@link #tryAdvance(java.util.function.IntConsumer)}.
+   */
+  tryAdvance(action: Consumer): boolean;
+
+  /**
+   * {@inheritDoc}
+   * @implSpec If the action is an instance of {@code IntConsumer} then it is cast
 to {@code IntConsumer} and passed to
 {@link #forEachRemaining(java.util.function.IntConsumer)}; otherwise
 the action is adapted to an instance of {@code IntConsumer}, by
 boxing the argument of {@code IntConsumer}, and then passed to
 {@link #forEachRemaining(java.util.function.IntConsumer)}.
+   */
+  forEachRemaining(action: Consumer): void;
+};

package/types/java/util/Spliterator.OfInt/index.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _default = {
+  trySplit: function trySplit() {},
+  tryAdvance: function tryAdvance() {},
+  forEachRemaining: function forEachRemaining() {}
+};
+exports["default"] = _default;