@byloth/core 2.0.0-rc.9 → 2.0.0

package/dist/core.js

@@ -1,148 +1,366 @@
-var Ne = Object.defineProperty;
-var Ye = (i, t, e) => t in i ? Ne(i, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : i[t] = e;
-var a = (i, t, e) => Ye(i, typeof t != "symbol" ? t + "" : t, e);
+var ze = Object.defineProperty;
+var De = (i, t, e) => t in i ? ze(i, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : i[t] = e;
+var a = (i, t, e) => De(i, typeof t != "symbol" ? t + "" : t, e);
 const Oe = typeof window < "u" && typeof window.document < "u";
-var O;
-const Qe = typeof process < "u" && ((O = process.versions) == null ? void 0 : O.node);
+var I;
+const Ze = typeof process < "u" && !!((I = process.versions) != null && I.node);
 var A;
-const Xe = typeof self == "object" && ((A = self.constructor) == null ? void 0 : A.name) === "DedicatedWorkerGlobalScope";
-var $, q;
-class f extends (q = Error, $ = Symbol.toStringTag, q) {
+const We = typeof self == "object" && ((A = self.constructor) == null ? void 0 : A.name) === "DedicatedWorkerGlobalScope";
+var N, O;
+class c extends (O = Error, N = Symbol.toStringTag, O) {
+  /**
+   * Initializes a new instance of the {@link Exception} class.
+   *
+   * ```ts
+   * throw new Exception("An error occurred while processing the request.");
+   * ```
+   *
+   * @param message The message that describes the error.
+   * @param cause The previous caught error that caused this one, if any.
+   * @param name The name of the exception. Default is `"Exception"`.
+   */
   constructor(e, n, s = "Exception") {
     super(e);
-    a(this, $, "Exception");
+    a(this, N, "Exception");
     this.cause = n, this.name = s, n && (n instanceof Error ? this.stack += `
 
 Caused by ${n.stack}` : this.stack += `
 
 Caused by ${n}`);
   }
+  /**
+   * A static method to convert a generic caught error, ensuring it's an instance of the {@link Exception} class.
+   *
+   * ```ts
+   * try { [...] }
+   * catch (error)
+   * {
+   *     const exc = Exception.FromUnknown(error);
+   *
+   *     [...]
+   * }
+   * ```
+   *
+   * @param error The caught error to convert.
+   *
+   * @returns An instance of the {@link Exception} class.
+   */
   static FromUnknown(e) {
-    if (e instanceof f)
+    if (e instanceof c)
       return e;
     if (e instanceof Error) {
-      const n = new f(e.message);
+      const n = new c(e.message);
       return n.stack = e.stack, n.name = e.name, n;
     }
-    return new f(`${e}`);
+    return new c(`${e}`);
   }
 }
-var N, Y;
-class k extends (Y = f, N = Symbol.toStringTag, Y) {
+var $, q;
+class x extends (q = c, $ = Symbol.toStringTag, q) {
+  /**
+   * Initializes a new instance of the {@link FatalErrorException} class.
+   *
+   * ```ts
+   * throw new FatalErrorException("This error should never happen. Please, contact the support team.");
+   * ```
+   *
+   * @param message The message that describes the error.
+   * @param cause The previous caught error that caused this one, if any.
+   * @param name The name of the exception. Default is `"FatalErrorException"`.
+   */
   constructor(e, n, s = "FatalErrorException") {
     e === void 0 && (e = "The program has encountered an unrecoverable error and cannot continue as expected. Please, try again later. If the problem persists, contact the support team.");
     super(e, n, s);
-    a(this, N, "FatalErrorException");
+    a(this, $, "FatalErrorException");
   }
 }
-var z, J;
-class ze extends (J = k, z = Symbol.toStringTag, J) {
+var z, D;
+class Be extends (D = x, z = Symbol.toStringTag, D) {
+  /**
+   * Initializes a new instance of the {@link NotImplementedException} class.
+   *
+   * ```ts
+   * throw new NotImplementedException("This method hasn't been implemented yet. Check back later.");
+   * ```
+   *
+   * @param message The message that describes the error.
+   * @param cause The previous caught error that caused this one, if any.
+   * @param name The name of the exception. Default is `"NotImplementedException"`.
+   */
   constructor(e, n, s = "NotImplementedException") {
-    e === void 0 && (e = "This feature is not implemented yet. Please, try again later.");
+    e === void 0 && (e = "This feature isn't implemented yet. Please, try again later.");
     super(e, n, s);
     a(this, z, "NotImplementedException");
   }
 }
-var V, W;
-class Ae extends (W = f, V = Symbol.toStringTag, W) {
+var B, J;
+class $e extends (J = c, B = Symbol.toStringTag, J) {
+  /**
+   * Initializes a new instance of the {@link FileException} class.
+   *
+   * ```ts
+   * throw new FileException("An error occurred while trying to read the file.");
+   * ```
+   *
+   * @param message The message that describes the error.
+   * @param cause The previous caught error that caused this one, if any.
+   * @param name The name of the exception. Default is `"FileException"`.
+   */
   constructor(e, n, s = "FileException") {
     super(e, n, s);
-    a(this, V, "FileException");
+    a(this, B, "FileException");
   }
 }
-var B, G;
-class Ze extends (G = Ae, B = Symbol.toStringTag, G) {
+var Y, L;
+class Ue extends (L = $e, Y = Symbol.toStringTag, L) {
+  /**
+   * Initializes a new instance of the {@link FileExistsException} class.
+   *
+   * ```ts
+   * throw new FileExistsException("The file named 'data.json' already exists on the server.");
+   * ```
+   *
+   * @param message The message that describes the error.
+   * @param cause The previous caught error that caused this one, if any.
+   * @param name The name of the exception. Default is `"FileExistsException"`.
+   */
   constructor(e, n, s = "FileExistsException") {
     super(e, n, s);
-    a(this, B, "FileExistsException");
+    a(this, Y, "FileExistsException");
   }
 }
-var K, L;
-class Ue extends (L = Ae, K = Symbol.toStringTag, L) {
+var G, K;
+class et extends (K = $e, G = Symbol.toStringTag, K) {
+  /**
+   * Initializes a new instance of the {@link FileNotFoundException} class.
+   *
+   * ```ts
+   * throw new FileNotFoundException("The file named 'data.json' wasn't found on the server.");
+   * ```
+   *
+   * @param message The message that describes the error.
+   * @param cause The previous caught error that caused this one, if any.
+   * @param name The name of the exception. Default is `"FileNotFoundException"`.
+   */
   constructor(e, n, s = "FileNotFoundException") {
     super(e, n, s);
-    a(this, K, "FileNotFoundException");
+    a(this, G, "FileNotFoundException");
   }
 }
 var H, Q;
-class x extends (Q = f, H = Symbol.toStringTag, Q) {
+class b extends (Q = c, H = Symbol.toStringTag, Q) {
+  /**
+   * Initializes a new instance of the {@link KeyException} class.
+   *
+   * ```ts
+   * throw new KeyException("The 'id' key wasn't found in the dictionary.");
+   * ```
+   *
+   * @param message The message that describes the error.
+   * @param cause The previous caught error that caused this one, if any.
+   * @param name The name of the exception. Default is `"KeyException"`.
+   */
   constructor(e, n, s = "KeyException") {
     super(e, n, s);
     a(this, H, "KeyException");
   }
 }
-var X, Z;
-class et extends (Z = f, X = Symbol.toStringTag, Z) {
+var V, X;
+class tt extends (X = c, V = Symbol.toStringTag, X) {
+  /**
+   * Initializes a new instance of the {@link NetworkException} class.
+   *
+   * ```ts
+   * throw new NetworkException("Couldn't connect to the server. Please, try again later.");
+   * ```
+   *
+   * @param message The message that describes the error.
+   * @param cause The previous caught error that caused this one, if any.
+   * @param name The name of the exception. Default is `"NetworkException"`.
+   */
   constructor(e, n, s = "NetworkException") {
     super(e, n, s);
-    a(this, X, "NetworkException");
+    a(this, V, "NetworkException");
   }
 }
-var U, ee;
-class tt extends (ee = f, U = Symbol.toStringTag, ee) {
+var Z, W;
+class nt extends (W = c, Z = Symbol.toStringTag, W) {
+  /**
+   * Initializes a new instance of the {@link PermissionException} class.
+   *
+   * ```ts
+   * throw new PermissionException("You don't have permission to access this resource.");
+   * ```
+   *
+   * @param message The message that describes the error.
+   * @param cause The previous caught error that caused this one, if any.
+   * @param name The name of the exception. Default is `"PermissionException"`.
+   */
   constructor(e, n, s = "PermissionException") {
     super(e, n, s);
-    a(this, U, "PermissionException");
+    a(this, Z, "PermissionException");
   }
 }
-var te, ne;
-class Je extends (ne = f, te = Symbol.toStringTag, ne) {
+var U, ee;
+class C extends (ee = c, U = Symbol.toStringTag, ee) {
+  /**
+   * Initializes a new instance of the {@link ReferenceException} class.
+   *
+   * ```ts
+   * throw new ReferenceException("The 'canvas' element wasn't found in the document.");
+   * ```
+   *
+   * @param message The message that describes the error.
+   * @param cause The previous caught error that caused this one, if any.
+   * @param name The name of the exception. Default is `"ReferenceException"`.
+   */
   constructor(e, n, s = "ReferenceException") {
     super(e, n, s);
-    a(this, te, "ReferenceException");
+    a(this, U, "ReferenceException");
   }
 }
-var se, re;
-class m extends (re = f, se = Symbol.toStringTag, re) {
+var te, ne;
+class y extends (ne = c, te = Symbol.toStringTag, ne) {
+  /**
+   * Initializes a new instance of the {@link RuntimeException} class.
+   *
+   * ```ts
+   * throw new RuntimeException("The received input seems to be malformed or corrupted.");
+   * ```
+   *
+   * @param message The message that describes the error.
+   * @param cause The previous caught error that caused this one, if any.
+   * @param name The name of the exception. Default is `"RuntimeException"`.
+   */
   constructor(e, n, s = "RuntimeException") {
     super(e, n, s);
-    a(this, se, "RuntimeException");
+    a(this, te, "RuntimeException");
   }
 }
-var ie, oe;
-class Ve extends (oe = m, ie = Symbol.toStringTag, oe) {
+var se, re;
+class Je extends (re = y, se = Symbol.toStringTag, re) {
+  /**
+   * Initializes a new instance of the {@link EnvironmentException} class.
+   *
+   * ```ts
+   * throw new EnvironmentException("The required environment variable 'API_KEY' isn't set.");
+   * ```
+   *
+   * @param message The message that describes the error.
+   * @param cause The previous caught error that caused this one, if any.
+   * @param name The name of the exception. Default is `"EnvironmentException"`.
+   */
   constructor(e, n, s = "EnvironmentException") {
     super(e, n, s);
-    a(this, ie, "EnvironmentException");
+    a(this, se, "EnvironmentException");
   }
 }
-var ae, le;
-class We extends (le = f, ae = Symbol.toStringTag, le) {
+var ie, oe;
+class Ye extends (oe = c, ie = Symbol.toStringTag, oe) {
+  /**
+   * Initializes a new instance of the {@link TimeoutException} class.
+   *
+   * ```ts
+   * throw new TimeoutException("The task took too long to complete.");
+   * ```
+   *
+   * @param message The message that describes the error.
+   * @param cause The previous caught error that caused this one, if any.
+   * @param name The name of the exception. Default is `"TimeoutException"`.
+   */
   constructor(e, n, s = "TimeoutException") {
     super(e, n, s);
-    a(this, ae, "TimeoutException");
+    a(this, ie, "TimeoutException");
   }
 }
-var ue, ce;
-class nt extends (ce = f, ue = Symbol.toStringTag, ce) {
+var ae, le;
+class st extends (le = c, ae = Symbol.toStringTag, le) {
+  /**
+   * Initializes a new instance of the {@link TypeException} class.
+   *
+   * ```ts
+   * throw new TypeException("The 'username' argument must be a valid string.");
+   * ```
+   *
+   * @param message The message that describes the error.
+   * @param cause The previous caught error that caused this one, if any.
+   * @param name The name of the exception. Default is `"TypeException"`.
+   */
   constructor(e, n, s = "TypeException") {
     super(e, n, s);
-    a(this, ue, "TypeException");
+    a(this, ae, "TypeException");
   }
 }
-var he, fe;
-class p extends (fe = f, he = Symbol.toStringTag, fe) {
+var ue, ce;
+class d extends (ce = c, ue = Symbol.toStringTag, ce) {
+  /**
+   * Initializes a new instance of the {@link ValueException} class.
+   *
+   * ```ts
+   * throw new ValueException("The 'grade' argument cannot be negative.");
+   * ```
+   *
+   * @param message The message that describes the error.
+   * @param cause The previous caught error that caused this one, if any.
+   * @param name The name of the exception. Default is `"ValueException"`.
+   */
   constructor(e, n, s = "ValueException") {
     super(e, n, s);
-    a(this, he, "ValueException");
+    a(this, ue, "ValueException");
   }
 }
-var de, me;
-class $e extends (me = p, de = Symbol.toStringTag, me) {
+var he, fe;
+class p extends (fe = d, he = Symbol.toStringTag, fe) {
+  /**
+   * Initializes a new instance of the {@link RangeException} class.
+   *
+   * ```ts
+   * throw new RangeException("The 'percentage' argument must be between 0 and 100.");
+   * ```
+   *
+   * @param message The message that describes the error.
+   * @param cause The previous caught error that caused this one, if any.
+   * @param name The name of the exception. Default is `"RangeException"`.
+   */
   constructor(e, n, s = "RangeException") {
     super(e, n, s);
-    a(this, de, "RangeException");
+    a(this, he, "RangeException");
   }
 }
-var _e;
-class c {
+var de;
+class u {
   constructor(t) {
+    /**
+     * The native {@link Iterator} object that is being wrapped by this instance.
+     */
     a(this, "_iterator");
-    a(this, "return");
-    a(this, "throw");
-    a(this, _e, "SmartIterator");
-    t instanceof Function ? this._iterator = t() : Symbol.iterator in t ? this._iterator = t[Symbol.iterator]() : this._iterator = t, this._iterator.return && (this.return = (e) => this._iterator.return(e)), this._iterator.throw && (this.throw = (e) => this._iterator.throw(e));
+    a(this, de, "SmartIterator");
+    t instanceof Function ? this._iterator = t() : Symbol.iterator in t ? this._iterator = t[Symbol.iterator]() : this._iterator = t;
   }
+  /**
+   * Determines whether all elements of the iterator satisfy a given condition.
+   * See also {@link SmartIterator.some}.
+   *
+   * This method will iterate over all elements of the iterator checking if they satisfy the condition.  
+   * Once a single element doesn't satisfy the condition, the method will return `false` immediately.
+   *
+   * This may lead to an unknown final state of the iterator, which may be entirely or partially consumed.  
+   * For this reason, it's recommended to consider it as consumed in any case and to not use it anymore.  
+   * Consider using {@link SmartIterator.find} instead.
+   *
+   * If the iterator is infinite and every element satisfies the condition, the method will never return.
+   *
+   * ```ts
+   * const iterator = new SmartIterator<number>([-2, -1, 0, 1, 2]);
+   * const result = iterator.every((value) => value < 0);
+   *
+   * console.log(result); // false
+   * ```
+   *
+   * @param predicate The condition to check for each element of the iterator.
+   *
+   * @returns `true` if all elements satisfy the condition, `false` otherwise.
+   */
   every(t) {
     let e = 0;
     for (; ; ) {
@@ -154,6 +372,30 @@ class c {
       e += 1;
     }
   }
+  /**
+   * Determines whether any element of the iterator satisfies a given condition.
+   * See also {@link SmartIterator.every}.
+   *
+   * This method will iterate over all elements of the iterator checking if they satisfy the condition.  
+   * Once a single element satisfies the condition, the method will return `true` immediately.
+   *
+   * This may lead to an unknown final state of the iterator, which may be entirely or partially consumed.  
+   * For this reason, it's recommended to consider it as consumed in any case and to not use it anymore.  
+   * Consider using {@link SmartIterator.find} instead.
+   *
+   * If the iterator is infinite and no element satisfies the condition, the method will never return.
+   *
+   * ```ts
+   * const iterator = new SmartIterator<number>([-2, -1, 0, 1, 2]);
+   * const result = iterator.some((value) => value < 0);
+   *
+   * console.log(result); // true
+   * ```
+   *
+   * @param predicate The condition to check for each element of the iterator.
+   *
+   * @returns `true` if any element satisfies the condition, `false` otherwise.
+   */
   some(t) {
     let e = 0;
     for (; ; ) {
@@ -167,7 +409,7 @@ class c {
   }
   filter(t) {
     const e = this._iterator;
-    return new c(function* () {
+    return new u(function* () {
       let n = 0;
       for (; ; ) {
         const s = e.next();
@@ -177,9 +419,35 @@ class c {
       }
     });
   }
+  /**
+   * Maps the elements of the iterator using a given transformation function.
+   *
+   * This method will iterate over all elements of the iterator applying the transformation function.  
+   * The result of each transformation will be included in the new iterator.
+   *
+   * Since the iterator is lazy, the mapping process will
+   * be executed once the resulting iterator is materialized.
+   *
+   * A new iterator will be created, holding the reference to the original one.  
+   * This means that the original iterator won't be consumed until the
+   * new one is and that consuming one of them will consume the other as well.
+   *
+   * ```ts
+   * const iterator = new SmartIterator<number>([-2, -1, 0, 1, 2]);
+   * const result = iterator.map((value) => Math.abs(value));
+   *
+   * console.log(result.toArray()); // [2, 1, 0, 1, 2]
+   * ```
+   *
+   * @template V The type of the elements after the transformation.
+   *
+   * @param iteratee The transformation function to apply to each element of the iterator.
+   *
+   * @returns A new {@link SmartIterator} containing the transformed elements.
+   */
   map(t) {
     const e = this._iterator;
-    return new c(function* () {
+    return new u(function* () {
       let n = 0;
       for (; ; ) {
         const s = e.next();
@@ -194,7 +462,7 @@ class c {
     if (s === void 0) {
       const r = this._iterator.next();
       if (r.done)
-        throw new p("Cannot reduce an empty iterator without an initial value.");
+        throw new d("Cannot reduce an empty iterator without an initial value.");
       s = r.value, n += 1;
     }
     for (; ; ) {
@@ -204,24 +472,79 @@ class c {
       s = t(s, r.value, n), n += 1;
     }
   }
+  /**
+   * Flattens the elements of the iterator using a given transformation function.
+   *
+   * This method will iterate over all elements of the iterator applying the transformation function.  
+   * The result of each transformation will be flattened into the new iterator.
+   *
+   * Since the iterator is lazy, the flattening process will
+   * be executed once the resulting iterator is materialized.
+   *
+   * A new iterator will be created, holding the reference to the original one.  
+   * This means that the original iterator won't be consumed until the
+   * new one is and that consuming one of them will consume the other as well.
+   *
+   * ```ts
+   * const iterator = new SmartIterator<number[]>([[-2, -1], 0, 1, 2, [3, 4, 5]]);
+   * const result = iterator.flatMap((value) => value);
+   *
+   * console.log(result.toArray()); // [-2, -1, 0, 1, 2, 3, 4, 5]
+   * ```
+   *
+   * @template V The type of the elements after the transformation.
+   *
+   * @param iteratee The transformation function to apply to each element of the iterator.
+   *
+   * @returns A new {@link SmartIterator} containing the flattened elements.
+   */
   flatMap(t) {
     const e = this._iterator;
-    return new c(function* () {
+    return new u(function* () {
       let n = 0;
       for (; ; ) {
         const s = e.next();
         if (s.done)
           return s.value;
         const r = t(s.value, n);
-        for (const o of r)
-          yield o;
+        if (r instanceof Array)
+          for (const o of r)
+            yield o;
+        else
+          yield r;
         n += 1;
       }
     });
   }
+  /**
+   * Drops a given number of elements at the beginning of the iterator.  
+   * The remaining elements will be included in a new iterator.
+   * See also {@link SmartIterator.take}.
+   *
+   * Since the iterator is lazy, the dropping process will
+   * be executed once the resulting iterator is materialized.
+   *
+   * A new iterator will be created, holding the reference to the original one.  
+   * This means that the original iterator won't be consumed until the
+   * new one is and that consuming one of them will consume the other as well.
+   *
+   * Only the dropped elements will be consumed in the process.  
+   * The rest of the iterator will be consumed only once the new one is.
+   *
+   * ```ts
+   * const iterator = new SmartIterator<number>([-2, -1, 0, 1, 2]);
+   * const result = iterator.drop(3);
+   *
+   * console.log(result.toArray()); // [1, 2]
+   * ```
+   *
+   * @param count The number of elements to drop.
+   *
+   * @returns A new {@link SmartIterator} containing the remaining elements.
+   */
   drop(t) {
     const e = this._iterator;
-    return new c(function* () {
+    return new u(function* () {
       let n = 0;
       for (; n < t; ) {
         if (e.next().done)
@@ -236,9 +559,36 @@ class c {
       }
     });
   }
+  /**
+   * Takes a given number of elements at the beginning of the iterator.  
+   * These elements will be included in a new iterator.
+   * See also {@link SmartIterator.drop}.
+   *
+   * Since the iterator is lazy, the taking process will
+   * be executed once the resulting iterator is materialized.
+   *
+   * A new iterator will be created, holding the reference to the original one.  
+   * This means that the original iterator won't be consumed until the
+   * new one is and that consuming one of them will consume the other as well.
+   *
+   * Only the taken elements will be consumed from the original iterator.  
+   * The rest of the original iterator will be available for further consumption.
+   *
+   * ```ts
+   * const iterator = new SmartIterator<number>([-2, -1, 0, 1, 2]);
+   * const result = iterator.take(3);
+   *
+   * console.log(result.toArray()); // [-2, -1, 0]
+   * console.log(iterator.toArray()); // [1, 2]
+   * ```
+   *
+   * @param limit The number of elements to take.
+   *
+   * @returns A new {@link SmartIterator} containing the taken elements.
+   */
   take(t) {
     const e = this._iterator;
-    return new c(function* () {
+    return new u(function* () {
       let n = 0;
       for (; n < t; ) {
         const s = e.next();
@@ -259,12 +609,52 @@ class c {
       e += 1;
     }
   }
+  /**
+   * Enumerates the elements of the iterator.  
+   * Each element is be paired with its index in a new iterator.
+   *
+   * Since the iterator is lazy, the enumeration process will
+   * be executed once the resulting iterator is materialized.
+   *
+   * A new iterator will be created, holding the reference to the original one.  
+   * This means that the original iterator won't be consumed until the
+   * new one is and that consuming one of them will consume the other as well.
+   *
+   * ```ts
+   * const iterator = new SmartIterator<string>(["A", "M", "N", "Z"]);
+   * const result = iterator.enumerate();
+   *
+   * console.log(result.toArray()); // [[0, "A"], [1, "M"], [2, "N"], [3, "Z"]]
+   * ```
+   *
+   * @returns A new {@link SmartIterator} containing the enumerated elements.
+   */
   enumerate() {
     return this.map((t, e) => [e, t]);
   }
+  /**
+   * Removes all duplicate elements from the iterator.  
+   * The first occurrence of each element will be kept.
+   *
+   * Since the iterator is lazy, the deduplication process will
+   * be executed once the resulting iterator is materialized.
+   *
+   * A new iterator will be created, holding the reference to the original one.  
+   * This means that the original iterator won't be consumed until the
+   * new one is and that consuming one of them will consume the other as well.
+   *
+   * ```ts
+   * const iterator = new SmartIterator<number>([1, 1, 2, 3, 2, 3, 4, 5, 5, 4]);
+   * const result = iterator.unique();
+   *
+   * console.log(result.toArray()); // [1, 2, 3, 4, 5]
+   * ```
+   *
+   * @returns A new {@link SmartIterator} containing only the unique elements.
+   */
   unique() {
     const t = this._iterator;
-    return new c(function* () {
+    return new u(function* () {
       const e = /* @__PURE__ */ new Set();
       for (; ; ) {
         const n = t.next();
@@ -274,6 +664,21 @@ class c {
       }
     });
   }
+  /**
+   * Counts the number of elements in the iterator.  
+   * This method will consume the entire iterator in the process.
+   *
+   * If the iterator is infinite, the method will never return.
+   *
+   * ```ts
+   * const iterator = new SmartIterator<number>([1, 2, 3, 4, 5]);
+   * const result = iterator.count();
+   *
+   * console.log(result); // 5
+   * ```
+   *
+   * @returns The number of elements in the iterator.
+   */
   count() {
     let t = 0;
     for (; ; ) {
@@ -282,6 +687,23 @@ class c {
       t += 1;
     }
   }
+  /**
+   * Iterates over all elements of the iterator.  
+   * The elements are passed to the function along with their index.
+   *
+   * This method will consume the entire iterator in the process.  
+   * If the iterator is infinite, the method will never return.
+   *
+   * ```ts
+   * const iterator = new SmartIterator<number>(["A", "M", "N", "Z"]);
+   * iterator.forEach((value, index) =>
+   * {
+   *     console.log(`${index}: ${value}`); // "0: A", "1: M", "2: N", "3: Z"
+   * }
+   * ```
+   *
+   * @param iteratee The function to apply to each element of the iterator.
+   */
   forEach(t) {
     let e = 0;
     for (; ; ) {
@@ -291,33 +713,226 @@ class c {
       t(n.value, e), e += 1;
     }
   }
+  /**
+   * Advances the iterator to the next element and returns the result.  
+   * If the iterator requires it, a value must be provided to be passed to the next element.
+   *
+   * Once the iterator is done, the method will return an object with the `done` property set to `true`.
+   *
+   * ```ts
+   * const iterator = new SmartIterator<number>([1, 2, 3, 4, 5]);
+   *
+   * let result = iterator.next();
+   * while (!result.done)
+   * {
+   *     console.log(result.value); // 1, 2, 3, 4, 5
+   *
+   *     result = iterator.next();
+   * }
+   *
+   * console.log(result); // { done: true, value: undefined }
+   * ```
+   *
+   * @param values The value to pass to the next element, if required.
+   *
+   * @returns The result of the iteration, containing the value of the operation.
+   */
   next(...t) {
     return this._iterator.next(...t);
   }
+  /**
+   * An utility method that may be used to close the iterator gracefully,
+   * free the resources and perform any cleanup operation.  
+   * It may also be used to signal the end or to compute a specific final result of the iteration process.
+   *
+   * ```ts
+   * const iterator = new SmartIterator<number>({
+   *     _index: 0,
+   *     next: function()
+   *     {
+   *         return { done: false, value: this._index += 1 };
+   *     },
+   *     return: function() { console.log("Closing the iterator..."); }
+   * });
+   *
+   * for (const value of iterator)
+   * {
+   *     if (value > 5) { break; } // Closing the iterator...
+   *
+   *     console.log(value); // 1, 2, 3, 4, 5
+   * }
+   * ```
+   *
+   * @param value The final value of the iterator.
+   *
+   * @returns The result of the iterator.
+   */
+  return(t) {
+    return this._iterator.return ? this._iterator.return(t) : { done: !0, value: t };
+  }
+  /**
+   * An utility method that may be used to close the iterator due to an error,
+   * free the resources and perform any cleanup operation.  
+   * It may also be used to signal that an error occurred during the iteration process or to handle it.
+   *
+   * ```ts
+   * const iterator = new SmartIterator<number>({
+   *     _index: 0,
+   *     next: function()
+   *     {
+   *         return { done: this._index > 10, value: this._index += 1 };
+   *     },
+   *     throw: function(error)
+   *     {
+   *         console.warn(error.message);
+   *
+   *         this._index = 0;
+   *     }
+   * });
+   *
+   * for (const value of iterator) // 1, 2, 3, 4, 5, "The index is too high.", 1, 2, 3, 4, 5, ...
+   * {
+   *     try
+   *     {
+   *         if (value > 5) { throw new Error("The index is too high."); }
+   *
+   *         console.log(value); // 1, 2, 3, 4, 5
+   *     }
+   *     catch (error) { iterator.throw(error); }
+   * }
+   * ```
+   *
+   * @param error The error to throw into the iterator.
+   *
+   * @returns The final result of the iterator.
+   */
+  throw(t) {
+    if (this._iterator.throw)
+      return this._iterator.throw(t);
+    throw t;
+  }
+  /**
+   * An utility method that aggregates the elements of the iterator using a given key function.  
+   * The elements will be grouped by the resulting keys in a new specialized iterator.
+   * See {@link AggregatedIterator}.
+   *
+   * Since the iterator is lazy, the grouping process will
+   * be executed once the resulting iterator is materialized.
+   *
+   * A new iterator will be created, holding the reference to the original one.  
+   * This means that the original iterator won't be consumed until the
+   * the new one is and that consuming one of them will consume the other as well.
+   *
+   * ```ts
+   * const iterator = new SmartIterator<number>([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
+   * const result = iterator.groupBy<string>((value) => value % 2 === 0 ? "even" : "odd");
+   *
+   * console.log(result.toObject()); // { odd: [1, 3, 5, 7, 9], even: [2, 4, 6, 8, 10] }
+   * ```
+   *
+   * @template K The type of the keys used to group the elements.
+   *
+   * @param iteratee The key function to apply to each element of the iterator.
+   *
+   * @returns A new instance of the {@link AggregatedIterator} class containing the grouped elements.
+   */
   groupBy(t) {
-    return new S(this.map((e, n) => [t(e, n), e]));
+    return new g(this.map((e, n) => [t(e, n), e]));
   }
+  /**
+   * Materializes the iterator into an array.  
+   * This method will consume the entire iterator in the process.
+   *
+   * If the iterator is infinite, the method will never return.
+   *
+   * ```ts
+   * const iterator = new SmartIterator(function* ()
+   * {
+   *     for (let i = 0; i < 5; i += 1) { yield i; }
+   * });
+   * const result = iterator.toArray();
+   *
+   * console.log(result); // [0, 1, 2, 3, 4]
+   * ```
+   *
+   * @returns The {@link Array} containing all elements of the iterator.
+   */
   toArray() {
     return Array.from(this);
   }
-  [(_e = Symbol.toStringTag, Symbol.iterator)]() {
+  [(de = Symbol.toStringTag, Symbol.iterator)]() {
     return this;
   }
 }
-var we;
-we = Symbol.toStringTag;
-const b = class b {
+var me;
+me = Symbol.toStringTag;
+const _ = class _ {
   constructor(t) {
+    /**
+     * The internal {@link SmartIterator} object that holds the reduced elements.
+     */
     a(this, "_elements");
-    a(this, we, "ReducedIterator");
-    this._elements = new c(t);
+    a(this, me, "ReducedIterator");
+    this._elements = new u(t);
   }
+  /**
+   * Determines whether all elements of the reduced iterator satisfy the given condition.
+   * See also {@link ReducedIterator.some}.
+   *
+   * This method will iterate over all the elements of the iterator checking if they satisfy the condition.  
+   * Once a single element doesn't satisfy the condition, the method will return `false` immediately.
+   *
+   * This may lead to an unknown final state of the iterator, which may be entirely or partially consumed.  
+   * For this reason, it's recommended to consider it as consumed in any case and to not use it anymore.  
+   * Consider using {@link ReducedIterator.find} instead.
+   *
+   * If the iterator is infinite and every element satisfies the condition, the method will never return.
+   *
+   * ```ts
+   * const results = new SmartIterator<number>([-3, -1, 0, 2, 3, 5, 6, 8])
+   *     .groupBy((value) => value % 2 === 0 ? "even" : "odd")
+   *     .reduce((key, accumulator, value) => accumulator + value)
+   *     .every((key, value) => value > 0);
+   *
+   * console.log(results); // true
+   * ```
+   *
+   * @param predicate The condition to check for each element of the iterator.
+   *
+   * @returns `true` if all elements satisfy the condition, `false` otherwise.
+   */
   every(t) {
     for (const [e, [n, s]] of this._elements.enumerate())
       if (!t(n, s, e))
         return !1;
     return !0;
   }
+  /**
+   * Determines whether any element of the reduced iterator satisfies the given condition.
+   * See also {@link ReducedIterator.every}.
+   *
+   * This method will iterate over all the elements of the iterator checking if they satisfy the condition.  
+   * Once a single element satisfies the condition, the method will return `true` immediately.
+   *
+   * This may lead to an unknown final state of the iterator, which may be entirely or partially consumed.  
+   * For this reason, it's recommended to consider it as consumed in any case and to not use it anymore.  
+   * Consider using {@link ReducedIterator.find} instead.
+   *
+   * If the iterator is infinite and no element satisfies the condition, the method will never return.
+   *
+   * ```ts
+   * const results = new SmartIterator<number>([-3, -1, 0, 2, 3, 5, 6, 8])
+   *     .groupBy((value) => value % 2 === 0 ? "even" : "odd")
+   *     .reduce((key, accumulator, value) => accumulator + value)
+   *     .some((key, value) => value > 0);
+   *
+   * console.log(results); // true
+   * ```
+   *
+   * @param predicate The condition to check for each element of the iterator.
+   *
+   * @returns `true` if any element satisfies the condition, `false` otherwise.
+   */
   some(t) {
     for (const [e, [n, s]] of this._elements.enumerate())
       if (t(n, s, e))
@@ -326,14 +941,42 @@ const b = class b {
   }
   filter(t) {
     const e = this._elements.enumerate();
-    return new b(function* () {
+    return new _(function* () {
       for (const [n, [s, r]] of e)
         t(s, r, n) && (yield [s, r]);
     });
   }
+  /**
+   * Maps the elements of the reduced iterator using a given transformation function.
+   *
+   * This method will iterate over all the elements of the iterator applying the transformation function.  
+   * The result of the transformation will be included in the new iterator.
+   *
+   * Since the iterator is lazy, the mapping process will
+   * be executed once the resulting iterator is materialized.
+   *
+   * A new iterator will be created, holding the reference to the original one.  
+   * This means that the original iterator won't be consumed until the
+   * new one is and that consuming one of them will consume the other as well.
+   *
+   * ```ts
+   * const results = new SmartIterator<number>([-3, -1, 0, 2, 3, 5, 6, 8])
+   *     .groupBy((value) => value % 2 === 0 ? "even" : "odd")
+   *     .reduce((key, accumulator, value) => accumulator + value)
+   *     .map((key, value) => value * 2);
+   *
+   * console.log(results.toObject()); // { odd: 8, even: 32 }
+   * ```
+   *
+   * @template V The type of the elements after the transformation.
+   *
+   * @param iteratee The transformation function to apply to each element of the iterator.
+   *
+   * @returns A new {@link ReducedIterator} containing the transformed elements.
+   */
   map(t) {
     const e = this._elements.enumerate();
-    return new b(function* () {
+    return new _(function* () {
       for (const [n, [s, r]] of e)
         yield [s, t(s, r, n)];
     });
@@ -343,31 +986,122 @@ const b = class b {
     if (s === void 0) {
       const r = this._elements.next();
       if (r.done)
-        throw new p("Cannot reduce an empty iterator without an initial value.");
+        throw new d("Cannot reduce an empty iterator without an initial value.");
       s = r.value[1], n += 1;
     }
     for (const [r, o] of this._elements)
       s = t(r, s, o, n), n += 1;
     return s;
   }
+  /**
+   * Flattens the elements of the reduced iterator using a given transformation function.
+   *
+   * This method will iterate over all the elements of the iterator applying the transformation function.  
+   * The result of each transformation will be flattened into the new iterator.
+   *
+   * Since the iterator is lazy, the flattening process will
+   * be executed once the resulting iterator is materialized.
+   *
+   * A new iterator will be created, holding the reference to the original one.  
+   * This means that the original iterator won't be consumed until the
+   * new one is and that consuming one of them will consume the other as well.
+   *
+   * ```ts
+   * const results = new SmartIterator<number>([-3, -1, 0, 2, 3, 5, 6, 8])
+   *     .groupBy((value) => value % 2 === 0 ? "even" : "odd")
+   *     .reduce((key, accumulator, value) => accumulator.concat([value]), () => [])
+   *     .flatMap((key, value) => value);
+   *
+   * console.log(results.toObject()); // { odd: [-3, -1, 3, 5], even: [0, 2, 6, 8] }
+   * ```
+   *
+   * @template V The type of the elements after the transformation.
+   *
+   * @param iteratee The transformation function to apply to each element of the iterator.
+   *
+   * @returns A new {@link AggregatedIterator} containing the flattened elements.
+   */
   flatMap(t) {
     const e = this._elements.enumerate();
-    return new S(function* () {
-      for (const [n, [s, r]] of e)
-        for (const o of t(s, r, n))
+    return new g(function* () {
+      for (const [n, [s, r]] of e) {
+        const o = t(s, r, n);
+        if (o instanceof Array)
+          for (const l of o)
+            yield [s, l];
+        else
           yield [s, o];
+      }
     });
   }
-  drop(t) {
-    const e = this._elements.enumerate();
-    return new b(function* () {
-      for (const [n, [s, r]] of e)
+  /**
+   * Drops a given number of elements at the beginning of the reduced iterator.  
+   * The remaining elements will be included in the new iterator.
+   * See also {@link ReducedIterator.take}.
+   *
+   * Since the iterator is lazy, the dropping process will
+   * be executed once the resulting iterator is materialized.
+   *
+   * A new iterator will be created, holding the reference to the original one.  
+   * This means that the original iterator won't be consumed until the
+   * new one is and that consuming one of them will consume the other as well.
+   *
+   * Only the dropped elements will be consumed in the process.  
+   * The rest of the iterator will be consumed once the new iterator is.
+   *
+   * ```ts
+   * const results = new SmartIterator<number>([-3, -1, 0, 2, 3, 5, 6, 8])
+   *     .groupBy((value) => value % 2 === 0 ? "even" : "odd")
+   *     .reduce((key, accumulator, value) => accumulator.concat(value), () => [])
+   *     .drop(1);
+   *
+   * console.log(results.toObject()); // { even: [0, 2, 6, 8] }
+   * ```
+   * 
+   * @param count The number of elements to drop.
+   *
+   * @returns A new {@link ReducedIterator} containing the remaining elements.
+   */
+  drop(t) {
+    const e = this._elements.enumerate();
+    return new _(function* () {
+      for (const [n, [s, r]] of e)
         n >= t && (yield [s, r]);
     });
   }
+  /**
+   * Takes a given number of elements at the beginning of the reduced iterator.  
+   * The elements will be included in the new iterator.
+   * See also {@link ReducedIterator.drop}.
+   *
+   * Since the iterator is lazy, the taking process will
+   * be executed once the resulting iterator is materialized.
+   *
+   * A new iterator will be created, holding the reference to the original one.  
+   * This means that the original iterator won't be consumed until the
+   * new one is and that consuming one of them will consume the other as well.
+   *
+   * Only the taken elements will be consumed from the original reduced iterator.  
+   * The rest of the original reduced iterator will be available for further consumption.
+   *
+   * ```ts
+   * const reduced = new SmartIterator<number>([-3, -1, 0, 2, 3, 5, 6, 8])
+   *     .groupBy((value) => value % 2 === 0 ? "even" : "odd")
+   *     .reduce((key, accumulator, value) => accumulator.concat(value), () => []);
+   *
+   * const results = iterator.take(1);
+   *
+   * console.log(results.toObject()); // { odd: [-3, -1, 3, 5] }
+   * console.log(reduced.toObject()); // { even: [0, 2, 6, 8] }
+   * ```
+   *
+   * @param count The number of elements to take.
+   *
+   * @returns A new {@link ReducedIterator} containing the taken elements.
+   */
   take(t) {
     const e = this._elements.enumerate();
-    return new b(function* () {
+    return new _(function* () {
       for (const [n, [s, r]] of e) {
         if (n >= t)
           break;
@@ -375,88 +1109,377 @@ const b = class b {
       }
     });
   }
+  find(t) {
+    for (const [e, [n, s]] of this._elements.enumerate())
+      if (t(n, s, e))
+        return s;
+  }
+  /**
+   * Enumerates the elements of the reduced iterator.  
+   * Each element is paired with its index in a new iterator.
+   *
+   * Since the iterator is lazy, the enumeration process will
+   * be executed once the resulting iterator is materialized.
+   *
+   * A new iterator will be created, holding the reference to the original one.  
+   * This means that the original iterator won't be consumed until the
+   * new one is and that consuming one of them will consume the other as well.
+   *
+   * ```ts
+   * const results = new ReducedIterator<number>([-3, -1, 0, 2, 3, 5, 6, 8])
+   *     .groupBy((value) => value % 2 === 0 ? "even" : "odd")
+   *     .reduce((key, accumulator, value) => accumulator + value)
+   *     .enumerate();
+   *
+   * console.log(results.toObject()); // [[0, 4], [1, 16]]
+   * ```
+   *
+   * @returns A new {@link ReducedIterator} object containing the enumerated elements.
+   */
   enumerate() {
     return this.map((t, e, n) => [n, e]);
   }
+  /**
+   * Removes all duplicate elements from the reduced iterator.  
+   * The first occurrence of each element will be kept.
+   *
+   * Since the iterator is lazy, the deduplication process will
+   * be executed once the resulting iterator is materialized.
+   *
+   * A new iterator will be created, holding the reference to the original one.  
+   * This means that the original iterator won't be consumed until the
+   * new one is and that consuming one of them will consume the other as well.
+   *
+   * ```ts
+   * const results = new ReducedIterator<number>([-3, -1, 0, 2, 3, 6, -3, -1, 1, 5, 6, 8, 7, 2])
+   *     .groupBy((value) => value % 2 === 0 ? "even" : "odd")
+   *     .map((key, value) => Math.abs(value))
+   *     .reduce((key, accumulator, value) => accumulator + value)
+   *     .unique();
+   *
+   * console.log(results.toObject()); // { odd: 24 }
+   *
+   * @returns A new {@link ReducedIterator} containing only the unique elements.
+   */
   unique() {
     const t = this._elements;
-    return new b(function* () {
+    return new _(function* () {
       const e = /* @__PURE__ */ new Set();
       for (const [n, s] of t)
         e.has(s) || (e.add(s), yield [n, s]);
     });
   }
+  /**
+   * Counts the number of elements in the reduced iterator.  
+   * This method will consume the entire iterator in the process.
+   *
+   * If the iterator is infinite, the method will never return.
+   *
+   * ```ts
+   * const results = new SmartIterator<number>([-3, -1, 0, 2, 3, 5, 6, 8])
+   *     .groupBy((value) => value % 2 === 0 ? "even" : "odd")
+   *     .reduce((key, accumulator, value) => accumulator + value)
+   *     .count();
+   *
+   * console.log(results); // 2
+   * ```
+   *
+   * @returns The number of elements in the iterator.
+   */
   count() {
     let t = 0;
     for (const e of this._elements)
       t += 1;
     return t;
   }
+  /**
+   * Iterates over all elements of the reduced iterator.  
+   * The elements are passed to the function along with their key and index.
+   *
+   * This method will consume the entire iterator in the process.  
+   * If the iterator is infinite, the method will never return.
+   *
+   * ```ts
+   * const reduced = new SmartIterator<number>([-3, -1, 0, 2, 3, 5, 6, 8])
+   *     .groupBy((value) => value % 2 === 0 ? "even" : "odd")
+   *     .reduce((key, accumulator, value) => accumulator + value);
+   * 
+   * reduced.forEach((key, value, index) =>
+   * {
+   *     console.log(`#${index} - ${key}: ${value}`); // "#0 - odd: 4", "#1 - even: 16"
+   * });
+   * ```
+   *
+   * @param iteratee The function to apply to each element of the reduced iterator.
+   */
   forEach(t) {
     for (const [e, [n, s]] of this._elements.enumerate())
       t(n, s, e);
   }
+  /**
+   * Reaggregates the elements of the reduced iterator.  
+   * The elements are grouped by a new key computed by the given iteratee function.
+   *
+   * Since the iterator is lazy, the reorganizing process will
+   * be executed once the resulting iterator is materialized.
+   *
+   * A new iterator will be created, holding the reference to the original one.  
+   * This means that the original iterator won't be consumed until the
+   * new one is and that consuming one of them will consume the other as well.
+   *
+   * ```ts
+   * const results = new SmartIterator<number>([-3, -1, 0, 2, 3, 5, -6, -8])
+   *     .groupBy((value) => value % 2 === 0 ? "even" : "odd")
+   *     .reduce((key, accumulator, value) => accumulator + value)
+   *     .reorganizeBy((key, value) => value > 0 ? "positive" : "negative");
+   *
+   * console.log(results.toObject()); // { positive: 4, negative: -12 }
+   * ```
+   *
+   * @template J The type of the new keys used to group the elements.
+   *
+   * @param iteratee The function to determine the new key of each element of the iterator.
+   *
+   * @returns A new {@link AggregatedIterator} containing the elements reorganized by the new keys.
+   */
+  reorganizeBy(t) {
+    const e = this._elements.enumerate();
+    return new g(function* () {
+      for (const [n, [s, r]] of e)
+        yield [t(s, r, n), r];
+    });
+  }
+  /**
+   * An utility method that returns a new {@link SmartIterator}
+   * object containing all the keys of the iterator.
+   *
+   * Since the iterator is lazy, the keys will be extracted
+   * be executed once the resulting iterator is materialized.
+   *
+   * A new iterator will be created, holding the reference to the original one.  
+   * This means that the original iterator won't be consumed until the
+   * new one is and that consuming one of them will consume the other as well.
+   *
+   * ```ts
+   * const keys = new SmartIterator<number>([-3, -1, 0, 2, 3, 5, 6, 8])
+   *     .groupBy((value) => value % 2 === 0 ? "even" : "odd")
+   *     .reduce((key, accumulator, value) => accumulator + value)
+   *     .keys();
+   *
+   * console.log(keys.toArray()); // ["odd", "even"]
+   * ```
+   *
+   * @returns A new {@link SmartIterator} containing all the keys of the iterator.
+   */
   keys() {
     const t = this._elements;
-    return new c(function* () {
+    return new u(function* () {
       for (const [e] of t)
         yield e;
     });
   }
-  items() {
+  /**
+   * An utility method that returns a new {@link SmartIterator}
+   * object containing all the entries of the iterator.  
+   * Each entry is a tuple containing the key and the element.
+   *
+   * Since the iterator is lazy, the entries will be extracted
+   * be executed once the resulting iterator is materialized.
+   *
+   * A new iterator will be created, holding the reference to the original one.  
+   * This means that the original iterator won't be consumed until the
+   * new one is and that consuming one of them will consume the other as well.
+   *
+   * ```ts
+   * const entries = new SmartIterator<number>([-3, -1, 0, 2, 3, 5, 6, 8])
+   *     .groupBy((value) => value % 2 === 0 ? "even" : "odd")
+   *     .reduce((key, accumulator, value) => accumulator + value)
+   *     .entries();
+   *
+   * console.log(entries.toArray()); // [["odd", 4], ["even", 16]]
+   * ```
+   *
+   * @returns A new {@link SmartIterator} containing all the entries of the iterator.
+   */
+  entries() {
     return this._elements;
   }
+  /**
+   * An utility method that returns a new {@link SmartIterator}
+   * object containing all the values of the iterator.
+   *
+   * Since the iterator is lazy, the values will be extracted
+   * be executed once the resulting iterator is materialized.
+   *
+   * A new iterator will be created, holding the reference to the original one.  
+   * This means that the original iterator won't be consumed until the
+   * new one is and that consuming one of them will consume the other as well.
+   *
+   * ```ts
+   * const values = new SmartIterator<number>([-3, -1, 0, 2, 3, 5, 6, 8])
+   *     .groupBy((value) => value % 2 === 0 ? "even" : "odd")
+   *     .reduce((key, accumulator, value) => accumulator + value)
+   *     .values();
+   *
+   * console.log(values.toArray()); // [4, 16]
+   * ```
+   *
+   * @returns A new {@link SmartIterator} containing all the values of the iterator.
+   */
   values() {
     const t = this._elements;
-    return new c(function* () {
+    return new u(function* () {
       for (const [e, n] of t)
         yield n;
     });
   }
+  /**
+   * Materializes the iterator into an array.  
+   * This method will consume the entire iterator in the process.
+   *
+   * If the iterator is infinite, the method will never return.
+   *
+   * ```ts
+   * const reduced = new SmartIterator<number>([-3, -1, 0, 2, 3, 5, 6, 8])
+   *     .groupBy((value) => value % 2 === 0 ? "even" : "odd")
+   *     .reduce((key, accumulator, value) => accumulator + value);
+   *
+   * console.log(reduced.toArray()); // [4, 16]
+   * ```
+   *
+   * @returns The {@link Array} containing all elements of the iterator.
+   */
   toArray() {
     return Array.from(this.values());
   }
+  /**
+   * Materializes the iterator into a map.  
+   * This method will consume the entire iterator in the process.
+   *
+   * If the iterator is infinite, the method will never return.
+   *
+   * ```ts
+   * const reduced = new SmartIterator<number>([-3, -1, 0, 2, 3, 5, 6, 8])
+   *     .groupBy((value) => value % 2 === 0 ? "even" : "odd")
+   *     .reduce((key, accumulator, value) => accumulator + value);
+   *
+   * console.log(reduced.toMap()); // Map(2) { "odd" => 4, "even" => 16 }
+   * ```
+   *
+   * @returns The {@link Map} containing all elements of the iterator.
+   */
   toMap() {
-    return new Map(this.items());
+    return new Map(this.entries());
   }
+  /**
+   * Materializes the iterator into an object.  
+   * This method will consume the entire iterator in the process.
+   *
+   * If the iterator is infinite, the method will never return.
+   *
+   * ```ts
+   * const reduced = new SmartIterator<number>([-3, -1, 0, 2, 3, 5, 6, 8])
+   *     .groupBy((value) => value % 2 === 0 ? "even" : "odd")
+   *     .reduce((key, accumulator, value) => accumulator + value);
+   *
+   * console.log(reduced.toObject()); // { odd: 4, even: 16 }
+   * ```
+   *
+   * @returns The {@link Object} containing all elements of the iterator.
+   */
   toObject() {
-    return Object.fromEntries(this.items());
+    return Object.fromEntries(this.entries());
   }
 };
-let d = b;
-var pe;
-pe = Symbol.toStringTag;
-const y = class y {
+let h = _;
+var we;
+we = Symbol.toStringTag;
+const m = class m {
   constructor(t) {
+    /**
+     * The internal {@link SmartAsyncIterator} object that holds the elements to aggregate.
+     */
     a(this, "_elements");
-    a(this, pe, "AggregatedAsyncIterator");
-    this._elements = new w(t);
+    a(this, we, "AggregatedAsyncIterator");
+    this._elements = new f(t);
   }
+  /**
+   * Determines whether all elements of each group of the iterator satisfy a given condition.
+   * See also {@link AggregatedAsyncIterator.some}.  
+   * This method will consume the entire iterator in the process.
+   *
+   * It will iterate over all elements of the iterator checjing if they satisfy the condition.  
+   * Once a single element of one group doesn't satisfy the condition,
+   * the result for the respective group will be `false`.
+   *
+   * Eventually, it will return a new {@link ReducedIterator}
+   * object that will contain all the boolean results for each group.  
+   * If the iterator is infinite, the method will never return.
+   *
+   * ```ts
+   * const results = new SmartAsyncIterator<number>([-3, -1, 0, 2, 3, 5, 6, 8])
+   *     .groupBy(async (value) => value % 2 === 0 ? "even" : "odd")
+   *     .every(async (key, value) => value >= 0);
+   *
+   * console.log(await results.toObject()); // { odd: false, even: true }
+   * ```
+   *
+   * @param predicate The condition to check for each element of the iterator.
+   *
+   * @returns
+   * A {@link Promise} resolving to a new {@link ReducedIterator} containing the boolean results for each group.
+   */
   async every(t) {
     const e = /* @__PURE__ */ new Map();
     for await (const [n, s] of this._elements) {
       const [r, o] = e.get(n) ?? [0, !0];
       o && e.set(n, [r + 1, await t(n, s, r)]);
     }
-    return new d(function* () {
+    return new h(function* () {
       for (const [n, [s, r]] of e)
         yield [n, r];
     });
   }
+  /**
+   * Determines whether any element of each group of the iterator satisfies a given condition.
+   * See also {@link AggregatedAsyncIterator.every}.  
+   * This method will consume the entire iterator in the process.
+   *
+   * It will iterate over all elements of the iterator checjing if they satisfy the condition.  
+   * Once a single element of one group satisfies the condition,
+   * the result for the respective group will be `true`.
+   *
+   * Eventually, it will return a new {@link ReducedIterator}
+   * object that will contain all the boolean results for each group.  
+   * If the iterator is infinite, the method will never return.
+   *
+   * ```ts
+   * const results = new SmartAsyncIterator<number>([-5, -4, -3, -2, -1, 0])
+   *     .groupBy(async (value) => value % 2 === 0 ? "even" : "odd")
+   *     .some(async (key, value) => value >= 0);
+   *
+   * console.log(await results.toObject()); // { odd: false, even: true }
+   * ```
+   *
+   * @param predicate The condition to check for each element of the iterator.
+   *
+   * @returns
+   * A {@link Promise} resolving to a new {@link ReducedIterator} containing the boolean results for each group.
+   */
   async some(t) {
     const e = /* @__PURE__ */ new Map();
     for await (const [n, s] of this._elements) {
       const [r, o] = e.get(n) ?? [0, !1];
       o || e.set(n, [r + 1, await t(n, s, r)]);
     }
-    return new d(function* () {
+    return new h(function* () {
       for (const [n, [s, r]] of e)
         yield [n, r];
     });
   }
   filter(t) {
     const e = this._elements;
-    return new y(async function* () {
+    return new m(async function* () {
       const n = /* @__PURE__ */ new Map();
       for await (const [s, r] of e) {
         const o = n.get(s) ?? 0;
@@ -464,9 +1487,36 @@ const y = class y {
       }
     });
   }
+  /**
+   * Maps the elements of the iterator using a given transformation function.
+   *
+   * This method will iterate over all elements of the iterator applying the condition.  
+   * The result of each transformation will be included in the new iterator.
+   *
+   * Since the iterator is lazy, the mapping process will
+   * be executed once the resulting iterator is materialized.
+   *
+   * A new iterator will be created, holding the reference to the original one.  
+   * This means that the original iterator won't be consumed until the
+   * new one is and that consuming one of them will consume the other as well.
+   *
+   * ```ts
+   * const results = new SmartAsyncIterator<number>([-3, -1, 0, 2, 3, 5, 6, 8])
+   *     .groupBy(async (value) => value % 2 === 0 ? "even" : "odd")
+   *     .map(async (key, value) => Math.abs(value));
+   *
+   * console.log(await results.toObject()); // { odd: [3, 1, 3, 5], even: [0, 2, 6, 8] }
+   * ```
+   *
+   * @template V The type of the elements after the transformation.
+   *
+   * @param iteratee The transformation function to apply to each element of the iterator.
+   *
+   * @returns A new {@link AggregatedAsyncIterator} containing the transformed elements.
+   */
   map(t) {
     const e = this._elements;
-    return new y(async function* () {
+    return new m(async function* () {
       const n = /* @__PURE__ */ new Map();
       for await (const [s, r] of e) {
         const o = n.get(s) ?? 0;
@@ -481,33 +1531,91 @@ const y = class y {
       if (n.has(s))
         [o, l] = n.get(s);
       else if (e !== void 0)
-        o = 0, l = await e(s);
+        o = 0, e instanceof Function ? l = await e(s) : l = await e;
       else {
         n.set(s, [0, r]);
         continue;
       }
       n.set(s, [o + 1, await t(s, l, r, o)]);
     }
-    return new d(function* () {
+    return new h(function* () {
       for (const [s, [r, o]] of n)
         yield [s, o];
     });
   }
+  /**
+   * Flattens the elements of the iterator using a given transformation function.
+   *
+   * This method will iterate over all elements of the iterator applying the transformation function.  
+   * The result of each transformation will be included in the new iterator.
+   *
+   * Since the iterator is lazy, the mapping process will
+   * be executed once the resulting iterator is materialized.
+   *
+   * A new iterator will be created, holding the reference to the original one.  
+   * This means that the original iterator won't be consumed until the
+   * new one is and that consuming one of them will consume the other as well.
+   *
+   * ```ts
+   * const results = new SmartAsyncIterator<number>([[-3, -1], 0, 2, 3, 5, [6, 8]])
+   *      .groupBy(async (values) =>
+   *      {
+   *          const value = values instanceof Array ? values[0] : values;
+   *          return value % 2 === 0 ? "even" : "odd";
+   *      })
+   *     .flatMap(async (key, values) => values);
+   *
+   * console.log(await results.toObject()); // { odd: [-3, -1, 3, 5], even: [0, 2, 6, 8] }
+   * ```
+   *
+   * @template V The type of the elements after the transformation.
+   *
+   * @param iteratee The transformation function to apply to each element of the iterator.
+   *
+   * @returns A new {@link AggregatedAsyncIterator} containing the transformed elements.
+   */
   flatMap(t) {
     const e = this._elements;
-    return new y(async function* () {
+    return new m(async function* () {
       const n = /* @__PURE__ */ new Map();
       for await (const [s, r] of e) {
         const o = n.get(s) ?? 0, l = await t(s, r, o);
-        for await (const u of l)
-          yield [s, u];
+        if (l instanceof Array)
+          for (const v of l)
+            yield [s, v];
+        else
+          yield [s, l];
         n.set(s, o + 1);
       }
     });
   }
+  /**
+   * Drops a given number of elements from the beginning of each group of the iterator.  
+   * The remaining elements will be included in the new iterator.
+   * See also {@link AggregatedAsyncIterator.take}.
+   *
+   * Since the iterator is lazy, the dropping process will
+   * be executed once the resulting iterator is materialized.
+   *
+   * A new iterator will be created, holding the reference to the original one.  
+   * This means that the original iterator won't be consumed until the
+   * new one is and that consuming one of them will consume the other as well.
+   *
+   * ```ts
+   * const results = new SmartAsyncIterator<number>([-3, -1, 0, 2, 3, 5, 6, 8])
+   *     .groupBy(async (value) => value % 2 === 0 ? "even" : "odd")
+   *     .drop(2);
+   *
+   * console.log(await results.toObject()); // { odd: [3, 5], even: [6, 8] }
+   * ```
+   *
+   * @param count The number of elements to drop from the beginning of each group.
+   *
+   * @returns A new {@link AggregatedAsyncIterator} containing the remaining elements.
+   */
   drop(t) {
     const e = this._elements;
-    return new y(async function* () {
+    return new m(async function* () {
       const n = /* @__PURE__ */ new Map();
       for await (const [s, r] of e) {
         const o = n.get(s) ?? 0;
@@ -519,9 +1627,33 @@ const y = class y {
       }
     });
   }
+  /**
+   * Takes a given number of elements from the beginning of each group of the iterator.  
+   * The elements will be included in the new iterator.
+   * See also {@link AggregatedAsyncIterator.drop}.
+   *
+   * Since the iterator is lazy, the taking process will
+   * be executed once the resulting iterator is materialized.
+   *
+   * A new iterator will be created, holding the reference to the original one.  
+   * This means that the original iterator won't be consumed until the
+   * new one is and that consuming one of them will consume the other as well.
+   *
+   * ```ts
+   * const results = new SmartAsyncIterator<number>([-3, -1, 0, 2, 3, 5, 6, 8])
+   *     .groupBy(async (value) => value % 2 === 0 ? "even" : "odd")
+   *     .take(2);
+   *
+   * console.log(await results.toObject()); // { odd: [-3, -1], even: [0, 2] }
+   * ```
+   *
+   * @param count The number of elements to take from the beginning of each group.
+   *
+   * @returns A new {@link AggregatedAsyncIterator} containing the taken elements.
+   */
   take(t) {
     const e = this._elements;
-    return new y(async function* () {
+    return new m(async function* () {
       const n = /* @__PURE__ */ new Map();
       for await (const [s, r] of e) {
         const o = n.get(s) ?? 0;
@@ -535,14 +1667,59 @@ const y = class y {
       let [r, o] = e.get(n) ?? [0, void 0];
       o === void 0 && (await t(n, s, r) && (o = s), e.set(n, [r + 1, o]));
     }
-    return new d(function* () {
+    return new h(function* () {
       for (const [n, [s, r]] of e)
         yield [n, r];
     });
   }
+  /**
+   * Enumerates the elements of the iterator.  
+   * Each element is paired with its index within the group in the new iterator.
+   *
+   * Since the iterator is lazy, the enumeration process will
+   * be executed once the resulting iterator is materialized.
+   *
+   * A new iterator will be created, holding the reference to the original one.  
+   * This means that the original iterator won't be consumed until the
+   * new one is and that consuming one of them will consume the other as well.
+   *
+   * ```ts
+   * const results = new SmartAsyncIterator<number>([-3, 0, 2, -1, 3])
+   *     .groupBy(async (value) => value % 2 === 0 ? "even" : "odd")
+   *     .enumerate();
+   *
+   * console.log(results.toObject()); // { odd: [[0, -3], [1, -1], [2, 3]], even: [[0, 0], [1, 2]] }
+   * ```
+   *
+   * @returns A new {@link AggregatedAsyncIterator} containing the enumerated elements.
+   */
+  enumerate() {
+    return this.map((t, e, n) => [n, e]);
+  }
+  /**
+   * Removes all duplicate elements from within each group of the iterator.  
+   * The first occurrence of each element will be included in the new iterator.
+   *
+   * Since the iterator is lazy, the deduplication process will
+   * be executed once the resulting iterator is materialized.
+   *
+   * A new iterator will be created, holding the reference to the original one.  
+   * This means that the original iterator won't be consumed until the
+   * new one is and that consuming one of them will consume the other as well.
+   *
+   * ```ts
+   * const results = new SmartAsyncIterator<number>([-3, -1, 0, 2, 3, 6, -3, -1, 0, 5, 6, 8, 0, 2])
+   *     .groupBy(async (value) => value % 2 === 0 ? "even" : "odd")
+   *     .unique();
+   *
+   * console.log(await results.toObject()); // { odd: [-3, -1, 3, 5], even: [0, 2, 6, 8] }
+   * ```
+   *
+   * @returns A new {@link AggregatedAsyncIterator} containing only the unique elements.
+   */
   unique() {
     const t = this._elements;
-    return new y(async function* () {
+    return new m(async function* () {
       const e = /* @__PURE__ */ new Map();
       for await (const [n, s] of t) {
         const r = e.get(n) ?? /* @__PURE__ */ new Set();
@@ -550,46 +1727,214 @@ const y = class y {
       }
     });
   }
+  /**
+   * Counts the number of elements within each group of the iterator.  
+   * This method will consume the entire iterator in the process.
+   *
+   * If the iterator is infinite, the method will never return.
+   *
+   * ```ts
+   * const results = new SmartAsyncIterator<number>([-3, -1, 0, 2, 3, 5, 6, 8])
+   *     .groupBy(async (value) => value % 2 === 0 ? "even" : "odd")
+   *     .count();
+   *
+   * console.log(await results.toObject()); // { odd: 4, even: 4 }
+   * ```
+   *
+   * @returns
+   * A {@link Promise} resolving to a new {@link ReducedIterator} containing the number of elements for each group.
+   */
   async count() {
     const t = /* @__PURE__ */ new Map();
     for await (const [e] of this._elements) {
       const n = t.get(e) ?? 0;
       t.set(e, n + 1);
     }
-    return new d(function* () {
+    return new h(function* () {
       for (const [e, n] of t)
         yield [e, n];
     });
   }
+  /**
+   * Iterates over the elements of the iterator.  
+   * The elements are passed to the given iteratee function along with their key and index within the group.
+   *
+   * This method will consume the entire iterator in the process.  
+   * If the iterator is infinite, the method will never return.
+   *
+   * ```ts
+   * const aggregator = new SmartAsyncIterator<number>([-3, 0, 2, -1, 3])
+   *     .groupBy(async (value) => value % 2 === 0 ? "even" : "odd");
+   *
+   * await aggregator.forEach(async (key, value, index) =>
+   * {
+   *     console.log(`${index}: ${value}`); // "0: -3", "0: 0", "1: 2", "1: -1", "2: 3"
+   * };
+   * ```
+   *
+   * @param iteratee The function to execute for each element of the iterator.
+   *
+   * @returns A {@link Promise} that will resolve once the iteration is complete.
+   */
   async forEach(t) {
     const e = /* @__PURE__ */ new Map();
     for await (const [n, s] of this._elements) {
       const r = e.get(n) ?? 0;
-      t(n, s, r), e.set(n, r + 1);
+      await t(n, s, r), e.set(n, r + 1);
     }
   }
+  /**
+   * Changes the key of each element on which the iterator is aggregated.  
+   * The new key is determined by the given iteratee function.
+   *
+   * Since the iterator is lazy, the reorganization process will
+   * be executed once the resulting iterator is materialized.
+   *
+   * A new iterator will be created, holding the reference to the original one.  
+   * This means that the original iterator won't be consumed until the
+   * new one is and that consuming one of them will consume the other as well.
+   *
+   * ```ts
+   * const results = new SmartAsyncIterator<number>([-3, -1, 0, 2, 3, 5, 6, 8])
+   *     .groupBy(async (value) => value % 2 === 0 ? "even" : "odd")
+   *     .map(async (key, value, index) => index % 2 === 0 ? value : -value)
+   *     .reorganizeBy(async (key, value) => value >= 0 ? "+" : "-");
+   *
+   * console.log(await results.toObject()); // { "+": [1, 0, 3, 6], "-": [-3, -2, -5, -8] }
+   * ```
+   *
+   * @template J The type of the new key.
+   *
+   * @param iteratee The function to determine the new key for each element of the iterator.
+   *
+   * @returns A new {@link AggregatedAsyncIterator} containing the elements reorganized by the new keys.
+   */
+  reorganizeBy(t) {
+    const e = this._elements;
+    return new m(async function* () {
+      const n = /* @__PURE__ */ new Map();
+      for await (const [s, r] of e) {
+        const o = n.get(s) ?? 0;
+        yield [await t(s, r, o), r], n.set(s, o + 1);
+      }
+    });
+  }
+  /**
+   * An utility method that returns a new {@link SmartAsyncIterator}
+   * object containing all the keys of the iterator.
+   *
+   * Since the iterator is lazy, the keys will be extracted
+   * be executed once the resulting iterator is materialized.
+   *
+   * A new iterator will be created, holding the reference to the original one.  
+   * This means that the original iterator won't be consumed until the
+   * new one is and that consuming one of them will consume the other as well.
+   *
+   * ```ts
+   * const keys = new SmartAsyncIterator([-3, Symbol(), "A", { }, null, [1 , 2, 3], false])
+   *     .groupBy(async (value) => typeof value)
+   *     .keys();
+   *
+   * console.log(await keys.toArray()); // ["number", "symbol", "string", "object", "boolean"]
+   * ```
+   *
+   * @returns A new {@link SmartAsyncIterator} containing all the keys of the iterator.
+   */
   keys() {
     const t = this._elements;
-    return new w(async function* () {
+    return new f(async function* () {
       const e = /* @__PURE__ */ new Set();
       for await (const [n] of t)
         e.has(n) || (e.add(n), yield n);
     });
   }
-  items() {
+  /**
+   * An utility method that returns a new {@link SmartAsyncIterator}
+   * object containing all the entries of the iterator.  
+   * Each entry is a tuple containing the key and the element.
+   *
+   * Since the iterator is lazy, the entries will be extracted
+   * be executed once the resulting iterator is materialized.
+   *
+   * A new iterator will be created, holding the reference to the original one.  
+   * This means that the original iterator won't be consumed until the
+   * new one is and that consuming one of them will consume the other as well.
+   *
+   * ```ts
+   * const entries = new SmartAsyncIterator<number>([-3, 0, 2, -1, 3])
+   *     .groupBy(async (value) => value % 2 === 0 ? "even" : "odd")
+   *     .entries();
+   *
+   * console.log(await entries.toArray()); // [["odd", -3], ["even", 0], ["even", 2], ["odd", -1], ["odd", 3]]
+   * ```
+   *
+   * @returns A new {@link SmartAsyncIterator} containing all the entries of the iterator.
+   */
+  entries() {
     return this._elements;
   }
+  /**
+   * An utility method that returns a new {@link SmartAsyncIterator}
+   * object containing all the values of the iterator.
+   *
+   * Since the iterator is lazy, the values will be extracted
+   * be executed once the resulting iterator is materialized.
+   *
+   * A new iterator will be created, holding the reference to the original one.  
+   * This means that the original iterator won't be consumed until the
+   * new one is and that consuming one of them will consume the other as well.
+   *
+   * ```ts
+   * const values = new SmartAsyncIterator<number>([-3, -1, 0, 2, 3, 5, 6, 8])
+   *     .groupBy(async (value) => value % 2 === 0 ? "even" : "odd")
+   *     .values();
+   *
+   * console.log(await values.toArray()); // [-3, -1, 0, 2, 3, 5, 6, 8]
+   * ```
+   *
+   * @returns A new {@link SmartAsyncIterator} containing all the values of the iterator.
+   */
   values() {
     const t = this._elements;
-    return new w(async function* () {
+    return new f(async function* () {
       for await (const [e, n] of t)
         yield n;
     });
   }
+  /**
+   * Materializes the iterator into an array of arrays.  
+   * This method will consume the entire iterator in the process.
+   *
+   * If the iterator is infinite, the method will never return.
+   *
+   * ```ts
+   * const aggregator = new SmartAsyncIterator<number>([-3, -1, 0, 2, 3, 5, 6, 8])
+   *     .groupBy(async (value) => value % 2 === 0 ? "even" : "odd");
+   *
+   * console.log(await aggregator.toArray()); // [[-3, -1, 3, 5], [0, 2, 6, 8]]
+   * ```
+   *
+   * @returns A {@link Promise} resolving to an {@link Array} containing all the values of the iterator.
+   */
   async toArray() {
     const t = await this.toMap();
     return Array.from(t.values());
   }
+  /**
+   * Materializes the iterator into a map.  
+   * This method will consume the entire iterator in the process.
+   *
+   * If the iterator is infinite, the method will never return.
+   *
+   * ```ts
+   * const aggregator = new SmartAsyncIterator<number>([-3, -1, 0, 2, 3, 5, 6, 8])
+   *     .groupBy(async (value) => value % 2 === 0 ? "even" : "odd");
+   *
+   * console.log(await aggregator.toMap()); // Map(2) { "odd" => [-3, -1, 3, 5], "even" => [0, 2, 6, 8] }
+   * ```
+   *
+   * @returns A {@link Promise} resolving to a {@link Map} containing all the entries of the iterator.
+   */
   async toMap() {
     const t = /* @__PURE__ */ new Map();
     for await (const [e, n] of this._elements) {
@@ -598,6 +1943,21 @@ const y = class y {
     }
     return t;
   }
+  /**
+   * Materializes the iterator into an object.  
+   * This method will consume the entire iterator in the process.
+   *
+   * If the iterator is infinite, the method will never return.
+   *
+   * ```ts
+   * const aggregator = new SmartAsyncIterator<number>([-3, -1, 0, 2, 3, 5, 6, 8])
+   *     .groupBy(async (value) => value % 2 === 0 ? "even" : "odd");
+   *
+   * console.log(await aggregator.toObject()); // { odd: [-3, -1, 3, 5], even: [0, 2, 6, 8] }
+   * ```
+   *
+   * @returns A {@link Promise} resolving to an object containing all the entries of the iterator.
+   */
   async toObject() {
     const t = {};
     for await (const [e, n] of this._elements) {
@@ -607,13 +1967,14 @@ const y = class y {
     return t;
   }
 };
-let E = y;
+let T = m;
 var ye;
-class w {
+class f {
   constructor(t) {
+    /**
+     * The native {@link AsyncIterator} object that is being wrapped by this instance.
+     */
     a(this, "_iterator");
-    a(this, "return");
-    a(this, "throw");
     a(this, ye, "SmartAsyncIterator");
     if (t instanceof Function) {
       const e = t();
@@ -648,8 +2009,32 @@ class w {
           e = [yield n.value];
         }
       }();
-    this._iterator.return && (this.return = (e) => this._iterator.return(e)), this._iterator.throw && (this.throw = (e) => this._iterator.throw(e));
   }
+  /**
+   * Determines whether all elements of the iterator satisfy a given condition.
+   * See also {@link SmartAsyncIterator.some}.
+   *
+   * This method will iterate over all elements of the iterator checking if they satisfy the condition.  
+   * Once a single element doesn't satisfy the condition, the method will return `false` immediately.
+   *
+   * This may lead to an unknown final state of the iterator, which may be entirely or partially consumed.  
+   * For this reason, it's recommended to consider it as consumed in any case and to not use it anymore.  
+   * Consider using {@link SmartAsyncIterator.find} instead.
+   *
+   * If the iterator is infinite and every element satisfies the condition, the method will never return.
+   *
+   * ```ts
+   * const iterator = new SmartAsyncIterator<number>([-2, -1, 0, 1, 2]);
+   * const result = await iterator.every(async (value) => value < 0);
+   *
+   * console.log(result); // false
+   * ```
+   *
+   * @param predicate The condition to check for each element of the iterator.
+   *
+   * @returns
+   * A {@link Promise} that will resolve to `true` if all elements satisfy the condition, `false` otherwise.
+   */
   async every(t) {
     let e = 0;
     for (; ; ) {
@@ -661,9 +2046,34 @@ class w {
       e += 1;
     }
   }
-  async some(t) {
-    let e = 0;
-    for (; ; ) {
+  /**
+   * Determines whether any element of the iterator satisfies a given condition.
+   * See also {@link SmartAsyncIterator.every}.
+   *
+   * This method will iterate over all elements of the iterator checking if they satisfy the condition.  
+   * Once a single element satisfies the condition, the method will return `true` immediately.
+   *
+   * This may lead to an unknown final state of the iterator, which may be entirely or partially consumed.  
+   * For this reason, it's recommended to consider it as consumed in any case and to not use it anymore.  
+   * Consider using {@link SmartAsyncIterator.find} instead.
+   *
+   * If the iterator is infinite and no element satisfies the condition, the method will never return.
+   *
+   * ```ts
+   * const iterator = new SmartAsyncIterator<number>([-2, -1, 0, 1, 2]);
+   * const result = await iterator.some(async (value) => value > 0);
+   *
+   * console.log(result); // true
+   * ```
+   *
+   * @param predicate The condition to check for each element of the iterator.
+   *
+   * @returns
+   * A {@link Promise} that will resolve to `true` if any element satisfies the condition, `false` otherwise.
+   */
+  async some(t) {
+    let e = 0;
+    for (; ; ) {
       const n = await this._iterator.next();
       if (n.done)
         return !1;
@@ -674,7 +2084,7 @@ class w {
   }
   filter(t) {
     const e = this._iterator;
-    return new w(async function* () {
+    return new f(async function* () {
       let n = 0;
       for (; ; ) {
         const s = await e.next();
@@ -684,9 +2094,35 @@ class w {
       }
     });
   }
+  /**
+   * Maps the elements of the iterator using a given transformation function.
+   *
+   * This method will iterate over all elements of the iterator applying the transformation function.  
+   * The result of each transformation will be included in the new iterator.
+   *
+   * Since the iterator is lazy, the mapping process will
+   * be executed once the resulting iterator is materialized.
+   *
+   * A new iterator will be created, holding the reference to the original one.  
+   * This means that the original iterator won't be consumed until the
+   * new one is and that consuming one of them will consume the other as well.
+   *
+   * ```ts
+   * const iterator = new SmartAsyncIterator<number>([-2, -1, 0, 1, 2]);
+   * const result = iterator.map(async (value) => Math.abs(value));
+   *
+   * console.log(await result.toArray()); // [2, 1, 0, 1, 2]
+   * ```
+   *
+   * @template V The type of the elements after the transformation.
+   *
+   * @param iteratee The transformation function to apply to each element of the iterator.
+   *
+   * @returns A new {@link SmartAsyncIterator} containing the transformed elements.
+   */
   map(t) {
     const e = this._iterator;
-    return new w(async function* () {
+    return new f(async function* () {
       let n = 0;
       for (; ; ) {
         const s = await e.next();
@@ -701,7 +2137,7 @@ class w {
     if (s === void 0) {
       const r = await this._iterator.next();
       if (r.done)
-        throw new p("Cannot reduce an empty iterator without an initial value.");
+        throw new d("Cannot reduce an empty iterator without an initial value.");
       s = r.value, n += 1;
     }
     for (; ; ) {
@@ -711,24 +2147,79 @@ class w {
       s = await t(s, r.value, n), n += 1;
     }
   }
+  /**
+   * Flattens the elements of the iterator using a given transformation function.
+   *
+   * This method will iterate over all elements of the iterator applying the transformation function.  
+   * The result of each transformation will be flattened and included in the new iterator.
+   *
+   * Since the iterator is lazy, the flattening process will
+   * be executed once the resulting iterator is materialized.
+   *
+   * A new iterator will be created, holding the reference to the original one.  
+   * This means that the original iterator won't be consumed until the
+   * new one is and that consuming one of them will consume the other as well.
+   *
+   * ```ts
+   * const iterator = new SmartAsyncIterator<number[]>([[-2, -1], 0, 1, 2, [3, 4, 5]]);
+   * const result = iterator.flatMap(async (value) => value);
+   *
+   * console.log(await result.toArray()); // [-2, -1, 0, 1, 2, 3, 4, 5]
+   * ```
+   *
+   * @template V The type of the elements after the transformation.
+   *
+   * @param iteratee The transformation function to apply to each element of the iterator.
+   *
+   * @returns A new {@link SmartAsyncIterator} containing the flattened elements.
+   */
   flatMap(t) {
     const e = this._iterator;
-    return new w(async function* () {
+    return new f(async function* () {
       let n = 0;
       for (; ; ) {
         const s = await e.next();
         if (s.done)
           return s.value;
         const r = await t(s.value, n);
-        for await (const o of r)
-          yield o;
+        if (r instanceof Array)
+          for (const o of r)
+            yield o;
+        else
+          yield r;
         n += 1;
       }
     });
   }
+  /**
+   * Drops a given number of elements at the beginning of the iterator.  
+   * The remaining elements will be included in a new iterator.
+   * See also {@link SmartAsyncIterator.take}.
+   *
+   * Since the iterator is lazy, the dropping process will
+   * be executed once the resulting iterator is materialized.
+   *
+   * A new iterator will be created, holding the reference to the original one.  
+   * This means that the original iterator won't be consumed until the
+   * new one is and that consuming one of them will consume the other as well.
+   *
+   * Only the dropped elements will be consumed in the process.  
+   * The rest of the iterator will be consumed only once the new one is.
+   *
+   * ```ts
+   * const iterator = new SmartAsyncIterator<number>([-2, -1, 0, 1, 2]);
+   * const result = iterator.drop(3);
+   *
+   * console.log(await result.toArray()); // [1, 2]
+   * ```
+   *
+   * @param count The number of elements to drop.
+   *
+   * @returns A new {@link SmartAsyncIterator} containing the remaining elements.
+   */
   drop(t) {
     const e = this._iterator;
-    return new w(async function* () {
+    return new f(async function* () {
       let n = 0;
       for (; n < t; ) {
         if ((await e.next()).done)
@@ -743,9 +2234,36 @@ class w {
       }
     });
   }
+  /**
+   * Takes a given number of elements at the beginning of the iterator.  
+   * These elements will be included in a new iterator.
+   * See also {@link SmartAsyncIterator.drop}.
+   *
+   * Since the iterator is lazy, the taking process will
+   * be executed once the resulting iterator is materialized.
+   *
+   * A new iterator will be created, holding the reference to the original one.  
+   * This means that the original iterator won't be consumed until the
+   * new one is and that consuming one of them will consume the other as well.
+   *
+   * Only the taken elements will be consumed from the original iterator.  
+   * The rest of the original iterator will be available for further consumption.
+   *
+   * ```ts
+   * const iterator = new SmartAsyncIterator<number>([-2, -1, 0, 1, 2]);
+   * const result = iterator.take(3);
+   *
+   * console.log(await result.toArray()); // [-2, -1, 0]
+   * console.log(await iterator.toArray()); // [1, 2]
+   * ```
+   *
+   * @param limit The number of elements to take.
+   *
+   * @returns A new {@link SmartAsyncIterator} containing the taken elements.
+   */
   take(t) {
     const e = this._iterator;
-    return new w(async function* () {
+    return new f(async function* () {
       let n = 0;
       for (; n < t; ) {
         const s = await e.next();
@@ -766,12 +2284,55 @@ class w {
       e += 1;
     }
   }
+  /**
+   * Enumerates the elements of the iterator.  
+   * Each element is be paired with its index in a new iterator.
+   *
+   * Since the iterator is lazy, the enumeration process will
+   * be executed once the resulting iterator is materialized.
+   *
+   * A new iterator will be created, holding the reference to the original one.  
+   * This means that the original iterator won't be consumed until the
+   * new one is and that consuming one of them will consume the other as well.
+   *
+   * ```ts
+   * const iterator = new SmartAsyncIterator<string>(["A", "M", "N", "Z"]);
+   * const result = iterator.enumerate();
+   *
+   * for await (const [index, value] of result)
+   * {
+   *     console.log(`${index}: ${value}`); // "0: A", "1: M", "2: N", "3: Z"
+   * }
+   * ```
+   *
+   * @returns A new {@link SmartAsyncIterator} containing the enumerated elements.
+   */
   enumerate() {
     return this.map((t, e) => [e, t]);
   }
+  /**
+   * Removes all duplicate elements from the iterator.  
+   * The first occurrence of each element will be kept.
+   *
+   * Since the iterator is lazy, the deduplication process will
+   * be executed once the resulting iterator is materialized.
+   *
+   * A new iterator will be created, holding the reference to the original one.  
+   * This means that the original iterator won't be consumed until the
+   * new one is and that consuming one of them will consume the other as well.
+   *
+   * ```ts
+   * const iterator = new SmartAsyncIterator<number>([1, 1, 2, 3, 2, 3, 4, 5, 5, 4]);
+   * const result = iterator.unique();
+   *
+   * console.log(await result.toArray()); // [1, 2, 3, 4, 5]
+   * ```
+   *
+   * @returns A new {@link SmartAsyncIterator} containing only the unique elements.
+   */
   unique() {
     const t = this._iterator;
-    return new w(async function* () {
+    return new f(async function* () {
       const e = /* @__PURE__ */ new Set();
       for (; ; ) {
         const n = await t.next();
@@ -781,6 +2342,21 @@ class w {
       }
     });
   }
+  /**
+   * Counts the number of elements in the iterator.  
+   * This method will consume the entire iterator in the process.
+   *
+   * If the iterator is infinite, the method will never return.
+   *
+   * ```ts
+   * const iterator = new SmartAsyncIterator<number>([1, 2, 3, 4, 5]);
+   * const result = await iterator.count();
+   *
+   * console.log(result); // 5
+   * ```
+   *
+   * @returns A {@link Promise} that will resolve to the number of elements in the iterator.
+   */
   async count() {
     let t = 0;
     for (; ; ) {
@@ -789,6 +2365,25 @@ class w {
       t += 1;
     }
   }
+  /**
+   * Iterates over all elements of the iterator.  
+   * The elements are passed to the function along with their index.
+   *
+   * This method will consume the entire iterator in the process.  
+   * If the iterator is infinite, the method will never return.
+   *
+   * ```ts
+   * const iterator = new SmartAsyncIterator<number>(["A", "M", "N", "Z"]);
+   * await iterator.forEach(async (value, index) =>
+   * {
+   *     console.log(`${index}: ${value}`); // "0: A", "1: M", "2: N", "3: Z"
+   * }
+   * ```
+   *
+   * @param iteratee The function to apply to each element of the iterator.
+   *
+   * @returns A {@link Promise} that will resolve once the iteration is complete.
+   */
   async forEach(t) {
     let e = 0;
     for (; ; ) {
@@ -798,12 +2393,152 @@ class w {
       await t(n.value, e), e += 1;
     }
   }
+  /**
+   * Advances the iterator to the next element and returns the result.  
+   * If the iterator requires it, a value must be provided to be passed to the next element.
+   *
+   * Once the iterator is done, the method will return an object with the `done` property set to `true`.
+   *
+   * ```ts
+   * const iterator = new SmartAsyncIterator<number>([1, 2, 3, 4, 5]);
+   *
+   * let result = await iterator.next();
+   * while (!result.done)
+   * {
+   *     console.log(result.value); // 1, 2, 3, 4, 5
+   *
+   *     result = await iterator.next();
+   * }
+   *
+   * console.log(result); // { done: true, value: undefined }
+   * ```
+   *
+   * @param values The value to pass to the next element, if required.
+   *
+   * @returns
+   * A {@link Promise} that will resolve to the result of the iteration, containing the value of the operation.
+   */
   next(...t) {
     return this._iterator.next(...t);
   }
+  /**
+   * An utility method that may be used to close the iterator gracefully,
+   * free the resources and perform any cleanup operation.  
+   * It may also be used to signal the end or to compute a specific final result of the iteration process.
+   *
+   * ```ts
+   * const iterator = new SmartAsyncIterator<number>({
+   *     _index: 0,
+   *     next: async function()
+   *     {
+   *         return { done: false, value: this._index += 1 };
+   *     },
+   *     return: async function() { console.log("Closing the iterator..."); }
+   * });
+   *
+   * for await (const value of iterator)
+   * {
+   *     if (value > 5) { break; } // Closing the iterator...
+   *
+   *     console.log(value); // 1, 2, 3, 4, 5
+   * }
+   * ```
+   *
+   * @param value The final value of the iterator.
+   *
+   * @returns A {@link Promise} that will resolve to the final result of the iterator.
+   */
+  async return(t) {
+    const e = await t;
+    return this._iterator.return ? await this._iterator.return(e) : { done: !0, value: e };
+  }
+  /**
+   * An utility method that may be used to close the iterator due to an error,
+   * free the resources and perform any cleanup operation.  
+   * It may also be used to signal that an error occurred during the iteration process or to handle it.
+   *
+   * ```ts
+   * const iterator = new SmartAsyncIterator<number>({
+   *     _index: 0,
+   *     next: async function()
+   *     {
+   *         return { done: this._index > 10, value: this._index += 1 };
+   *     },
+   *     throw: async function(error)
+   *     {
+   *         console.warn(error.message);
+   *
+   *         this._index = 0;
+   *     }
+   * });
+   *
+   * for await (const value of iterator) // 1, 2, 3, 4, 5, "The index is too high.", 1, 2, 3, 4, 5, ...
+   * {
+   *     try
+   *     {
+   *         if (value > 5) { throw new Error("The index is too high."); }
+   *
+   *         console.log(value); // 1, 2, 3, 4, 5
+   *     }
+   *     catch (error) { await iterator.throw(error); }
+   * }
+   * ```
+   *
+   * @param error The error to throw into the iterator.
+   *
+   * @returns A {@link Promise} that will resolve to the final result of the iterator.
+   */
+  throw(t) {
+    if (this._iterator.throw)
+      return this._iterator.throw(t);
+    throw t;
+  }
+  /**
+   * An utility method that aggregates the elements of the iterator using a given key function.  
+   * The elements will be grouped by the resulting keys in a new specialized iterator.
+   * See {@link AggregatedAsyncIterator}.
+   *
+   * Since the iterator is lazy, the grouping process will
+   * be executed once the resulting iterator is materialized.
+   *
+   * A new iterator will be created, holding the reference to the original one.  
+   * This means that the original iterator won't be consumed until the
+   * the new one is and that consuming one of them will consume the other as well.
+   *
+   * ```ts
+   * const iterator = new SmartAsyncIterator<number>([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
+   * const result = iterator.groupBy<string>(async (value) => value % 2 === 0 ? "even" : "odd");
+   *
+   * console.log(await result.toObject()); // { odd: [1, 3, 5, 7, 9], even: [2, 4, 6, 8, 10] }
+   * ```
+   *
+   * @template K The type of the keys used to group the elements.
+   *
+   * @param iteratee The key function to apply to each element of the iterator.
+   *
+   * @returns A new instance of the {@link AggregatedAsyncIterator} class containing the grouped elements.
+   */
   groupBy(t) {
-    return new E(this.map(async (e, n) => [await t(e, n), e]));
+    return new T(this.map(async (e, n) => [await t(e, n), e]));
   }
+  /**
+   * Materializes the iterator into an array.  
+   * This method will consume the entire iterator in the process.
+   *
+   * If the iterator is infinite, the method will never return.
+   *
+   * ```ts
+   * const iterator = new SmartAsyncIterator(async function* ()
+   * {
+   *     for (let i = 0; i < 5; i += 1) { yield i; }
+   * });
+   * const result = await iterator.toArray();
+   *
+   * console.log(result); // [0, 1, 2, 3, 4]
+   * ```
+   *
+   * @returns A {@link Promise} that will resolve to an array containing all elements of the iterator.
+   */
   toArray() {
     return Array.fromAsync(this);
   }
@@ -811,39 +2546,92 @@ class w {
     return this;
   }
 }
-var ge;
-ge = Symbol.toStringTag;
-const g = class g {
+var _e;
+_e = Symbol.toStringTag;
+const w = class w {
   constructor(t) {
+    /**
+     * The internal {@link SmartIterator} object that holds the elements to aggregate.
+     */
     a(this, "_elements");
-    a(this, ge, "AggregatedIterator");
-    this._elements = new c(t);
+    a(this, _e, "AggregatedIterator");
+    this._elements = new u(t);
   }
+  /**
+   * Determines whether all elements of each group of the iterator satisfy a given condition.
+   * See also {@link AggregatedIterator.some}.  
+   * This method will consume the entire iterator in the process.
+   *
+   * It will iterate over all elements of the iterator checking if they satisfy the condition.  
+   * Once a single element of one group doesn't satisfy the condition,
+   * the result for the respective group will be `false`.
+   *
+   * Eventually, it will return a new {@link ReducedIterator}
+   * object that will contain all the boolean results for each group.  
+   * If the iterator is infinite, the method will never return.
+   *
+   * ```ts
+   * const results = new SmartIterator<number>([-3, -1, 0, 2, 3, 5, 6, 8])
+   *     .groupBy((value) => value % 2 === 0 ? "even" : "odd")
+   *     .every((key, value) => value >= 0);
+   *
+   * console.log(results.toObject()); // { odd: false, even: true }
+   * ```
+   *
+   * @param predicate The condition to check for each element of the iterator.
+   *
+   * @returns A new {@link ReducedIterator} containing the boolean results for each group.
+   */
   every(t) {
     const e = /* @__PURE__ */ new Map();
     for (const [n, s] of this._elements) {
       const [r, o] = e.get(n) ?? [0, !0];
       o && e.set(n, [r + 1, t(n, s, r)]);
     }
-    return new d(function* () {
+    return new h(function* () {
       for (const [n, [s, r]] of e)
         yield [n, r];
     });
   }
+  /**
+   * Determines whether any elements of each group of the iterator satisfy a given condition.
+   * See also {@link AggregatedIterator.every}.  
+   * This method will consume the entire iterator in the process.
+   *
+   * It will iterate over all elements of the iterator checking if they satisfy the condition.  
+   * Once a single element of one group satisfies the condition,
+   * the result for the respective group will be `true`.
+   *
+   * Eventually, it will return a new {@link ReducedIterator}
+   * object that will contain all the boolean results for each group.  
+   * If the iterator is infinite, the method will never return.
+   *
+   * ```ts
+   * const results = new SmartIterator<number>([-5, -4, -3, -2, -1, 0])
+   *     .groupBy((value) => value % 2 === 0 ? "even" : "odd")
+   *     .some((key, value) => value >= 0);
+   *
+   * console.log(results.toObject()); // { odd: false, even: true }
+   * ```
+   *
+   * @param predicate The condition to check for each element of the iterator.
+   *
+   * @returns A {@link ReducedIterator} containing the boolean results for each group.
+   */
   some(t) {
     const e = /* @__PURE__ */ new Map();
     for (const [n, s] of this._elements) {
       const [r, o] = e.get(n) ?? [0, !1];
       o || e.set(n, [r + 1, t(n, s, r)]);
     }
-    return new d(function* () {
+    return new h(function* () {
       for (const [n, [s, r]] of e)
         yield [n, r];
     });
   }
   filter(t) {
     const e = this._elements;
-    return new g(function* () {
+    return new w(function* () {
       const n = /* @__PURE__ */ new Map();
       for (const [s, r] of e) {
         const o = n.get(s) ?? 0;
@@ -851,9 +2639,36 @@ const g = class g {
       }
     });
   }
+  /**
+   * Maps the elements of the iterator using a given transformation function.
+   *
+   * This method will iterate over all elements of the iterator applying the transformation function.  
+   * The result of each transformation will be included in the new iterator.
+   *
+   * Since the iterator is lazy, the mapping process will
+   * be executed once the resulting iterator is materialized.
+   *
+   * A new iterator will be created, holding the reference to the original one.  
+   * This means that the original iterator won't be consumed until the
+   * new one is and that consuming one of them will consume the other as well.
+   *
+   * ```ts
+   * const results = new SmartIterator<number>([-3, -1, 0, 2, 3, 5, 6, 8])
+   *     .groupBy((value) => value % 2 === 0 ? "even" : "odd")
+   *     .map((key, value) => Math.abs(value));
+   *
+   * console.log(results.toObject()); // { odd: [3, 1, 3, 5], even: [0, 2, 6, 8] }
+   * ```
+   *
+   * @template V The type of the elements after the transformation.
+   *
+   * @param iteratee The transformation function to apply to each element of the iterator.
+   *
+   * @returns A new {@link AggregatedIterator} containing the transformed elements.
+   */
   map(t) {
     const e = this._elements;
-    return new g(function* () {
+    return new w(function* () {
       const n = /* @__PURE__ */ new Map();
       for (const [s, r] of e) {
         const o = n.get(s) ?? 0;
@@ -868,33 +2683,91 @@ const g = class g {
       if (n.has(s))
         [o, l] = n.get(s);
       else if (e !== void 0)
-        o = 0, l = e(s);
+        o = 0, e instanceof Function ? l = e(s) : l = e;
       else {
         n.set(s, [0, r]);
         continue;
       }
       n.set(s, [o + 1, t(s, l, r, o)]);
     }
-    return new d(function* () {
+    return new h(function* () {
       for (const [s, [r, o]] of n)
         yield [s, o];
     });
   }
+  /**
+   * Flattens the elements of the iterator using a given transformation function.
+   *
+   * This method will iterate over all elements of the iterator applying the transformation function.  
+   * The result of each transformation will be included in the new iterator.
+   *
+   * Since the iterator is lazy, the flattening process will
+   * be executed once the resulting iterator is materialized.
+   *
+   * A new iterator will be created, holding the reference to the original one.  
+   * This means that the original iterator won't be consumed until the
+   * new one is and that consuming one of them will consume the other as well.
+   *
+   * ```ts
+   * const results = new SmartIterator<number[]>([[-3, -1], 0, 2, 3, 5, [6, 8]])
+   *      .groupBy((values) =>
+   *      {
+   *          const value = values instanceof Array ? values[0] : values;
+   *          return value % 2 === 0 ? "even" : "odd";
+   *      })
+   *     .flatMap((key, values) => values);
+   *
+   * console.log(results.toObject()); // { odd: [-3, -1, 3, 5], even: [0, 2, 6, 8] }
+   * ```
+   *
+   * @template V The type of the elements after the transformation.
+   *
+   * @param iteratee The transformation function to apply to each element of the iterator.
+   *
+   * @returns A new {@link AggregatedIterator} containing the transformed elements.
+   */
   flatMap(t) {
     const e = this._elements;
-    return new g(function* () {
+    return new w(function* () {
       const n = /* @__PURE__ */ new Map();
       for (const [s, r] of e) {
         const o = n.get(s) ?? 0, l = t(s, r, o);
-        for (const u of l)
-          yield [s, u];
+        if (l instanceof Array)
+          for (const v of l)
+            yield [s, v];
+        else
+          yield [s, l];
         n.set(s, o + 1);
       }
     });
   }
+  /**
+   * Drops a given number of elements from the beginning of each group of the iterator.  
+   * The remaining elements will be included in the new iterator.
+   * See also {@link AggregatedIterator.take}.
+   *
+   * Since the iterator is lazy, the dropping process will
+   * be executed once the resulting iterator is materialized.
+   *
+   * A new iterator will be created, holding the reference to the original one.  
+   * This means that the original iterator won't be consumed until the
+   * new one is and that consuming one of them will consume the other as well.
+   *
+   * ```ts
+   * const results = new SmartIterator<number>([-3, -1, 0, 2, 3, 5, 6, 8])
+   *     .groupBy((value) => value % 2 === 0 ? "even" : "odd")
+   *     .drop(2);
+   *
+   * console.log(results.toObject()); // { odd: [3, 5], even: [6, 8] }
+   * ```
+   *
+   * @param count The number of elements to drop from the beginning of each group.
+   *
+   * @returns A new {@link AggregatedIterator} containing the remaining elements.
+   */
   drop(t) {
     const e = this._elements;
-    return new g(function* () {
+    return new w(function* () {
       const n = /* @__PURE__ */ new Map();
       for (const [s, r] of e) {
         const o = n.get(s) ?? 0;
@@ -906,9 +2779,33 @@ const g = class g {
       }
     });
   }
+  /**
+   * Takes a given number of elements from the beginning of each group of the iterator.  
+   * The elements will be included in the new iterator.
+   * See also {@link AggregatedIterator.drop}.
+   *
+   * Since the iterator is lazy, the taking process will
+   * be executed once the resulting iterator is materialized.
+   *
+   * A new iterator will be created, holding the reference to the original one.  
+   * This means that the original iterator won't be consumed until the
+   * new one is and that consuming one of them will consume the other as well.
+   *
+   * ```ts
+   * const results = new SmartIterator<number>([-3, -1, 0, 2, 3, 5, 6, 8])
+   *     .groupBy((value) => value % 2 === 0 ? "even" : "odd")
+   *     .take(2);
+   *
+   * console.log(results.toObject()); // { odd: [-3, -1], even: [0, 2] }
+   * ```
+   *
+   * @param count The number of elements to take from the beginning of each group.
+   *
+   * @returns A new {@link AggregatedIterator} containing the taken elements.
+   */
   take(t) {
     const e = this._elements;
-    return new g(function* () {
+    return new w(function* () {
       const n = /* @__PURE__ */ new Map();
       for (const [s, r] of e) {
         const o = n.get(s) ?? 0;
@@ -922,17 +2819,59 @@ const g = class g {
       let [r, o] = e.get(n) ?? [0, void 0];
       o === void 0 && (t(n, s, r) && (o = s), e.set(n, [r + 1, o]));
     }
-    return new d(function* () {
+    return new h(function* () {
       for (const [n, [s, r]] of e)
         yield [n, r];
     });
   }
+  /**
+   * Enumerates the elements of the iterator.  
+   * Each element is paired with its index within the group in a new iterator.
+   *
+   * Since the iterator is lazy, the enumeration process will
+   * be executed once the resulting iterator is materialized.
+   *
+   * A new iterator will be created, holding the reference to the original one.  
+   * This means that the original iterator won't be consumed until the
+   * new one is and that consuming one of them will consume the other as well.
+   *
+   * ```ts
+   * const results = new SmartIterator<number>([-3, 0, 2, -1, 3])
+   *     .groupBy((value) => value % 2 === 0 ? "even" : "odd")
+   *     .enumerate();
+   *
+   * console.log(results.toObject()); // { odd: [[0, -3], [1, -1], [2, 3]], even: [[0, 0], [1, 2]] }
+   * ```
+   *
+   * @returns A new {@link AggregatedIterator} containing the enumerated elements.
+   */
   enumerate() {
     return this.map((t, e, n) => [n, e]);
   }
+  /**
+   * Removes all duplicate elements from within each group of the iterator.  
+   * The first occurrence of each element will be included in the new iterator.
+   *
+   * Since the iterator is lazy, the deduplication process will
+   * be executed once the resulting iterator is materialized.
+   *
+   * A new iterator will be created, holding the reference to the original one.  
+   * This means that the original iterator won't be consumed until the
+   * new one is and that consuming one of them will consume the other as well.
+   *
+   * ```ts
+   * const results = new SmartIterator<number>([-3, -1, 0, 2, 3, 6, -3, -1, 0, 5, 6, 8, 0, 2])
+   *     .groupBy((value) => value % 2 === 0 ? "even" : "odd")
+   *     .unique();
+   *
+   * console.log(results.toObject()); // { odd: [-3, -1, 3, 5], even: [0, 2, 6, 8] }
+   * ```
+   *
+   * @returns A new {@link AggregatedIterator} containing only the unique elements.
+   */
   unique() {
     const t = this._elements;
-    return new g(function* () {
+    return new w(function* () {
       const e = /* @__PURE__ */ new Map();
       for (const [n, s] of t) {
         const r = e.get(n) ?? /* @__PURE__ */ new Set();
@@ -940,17 +2879,52 @@ const g = class g {
       }
     });
   }
+  /**
+   * Counts the number of elements within each group of the iterator.  
+   * This method will consume the entire iterator in the process.
+   *
+   * If the iterator is infinite, the method will never return.
+   *
+   * ```ts
+   * const results = new SmartIterator<number>([-3, -1, 0, 2, 3, 5, 6, 8])
+   *     .groupBy((value) => value % 2 === 0 ? "even" : "odd")
+   *     .count();
+   *
+   * console.log(results.toObject()); // { odd: 4, even: 4 }
+   * ```
+   *
+   * @returns A new {@link ReducedIterator} containing the number of elements for each group.
+   */
   count() {
     const t = /* @__PURE__ */ new Map();
     for (const [e] of this._elements) {
       const n = t.get(e) ?? 0;
       t.set(e, n + 1);
     }
-    return new d(function* () {
+    return new h(function* () {
       for (const [e, n] of t)
         yield [e, n];
     });
   }
+  /**
+   * Iterates over the elements of the iterator.  
+   * The elements are passed to the given iteratee function along with their key and index within the group.
+   *
+   * This method will consume the entire iterator in the process.  
+   * If the iterator is infinite, the method will never return.
+   *
+   * ```ts
+   * const aggregator = new SmartIterator<number>([-3, 0, 2, -1, 3])
+   *     .groupBy((value) => value % 2 === 0 ? "even" : "odd");
+   *
+   * aggregator.forEach((key, value, index) =>
+   * {
+   *     console.log(`${index}: ${value}`); // "0: -3", "0: 0", "1: 2", "1: -1", "2: 3"
+   * };
+   * ```
+   *
+   * @param iteratee The function to execute for each element of the iterator.
+   */
   forEach(t) {
     const e = /* @__PURE__ */ new Map();
     for (const [n, s] of this._elements) {
@@ -958,28 +2932,158 @@ const g = class g {
       t(n, s, r), e.set(n, r + 1);
     }
   }
+  /**
+   * Changes the key of each element on which the iterator is aggregated.  
+   * The new key is determined by the given iteratee function.
+   *
+   * Since the iterator is lazy, the reorganization process will
+   * be executed once the resulting iterator is materialized.
+   *
+   * A new iterator will be created, holding the reference to the original one.  
+   * This means that the original iterator won't be consumed until the
+   * new one is and that consuming one of them will consume the other as well.
+   *
+   * ```ts
+   * const results = new SmartIterator<number>([-3, -1, 0, 2, 3, 5, 6, 8])
+   *     .groupBy((value) => value % 2 === 0 ? "even" : "odd")
+   *     .map((key, value, index) => index % 2 === 0 ? value : -value)
+   *     .reorganizeBy((key, value) => value >= 0 ? "+" : "-");
+   *
+   * console.log(results.toObject()); // { "+": [1, 0, 3, 6], "-": [-3, -2, -5, -8] }
+   * ```
+   *
+   * @template J The type of the new key.
+   *
+   * @param iteratee The function to determine the new key for each element of the iterator.
+   *
+   * @returns A new {@link AggregatedIterator} containing the elements reorganized by the new keys.
+   */
+  reorganizeBy(t) {
+    const e = this._elements;
+    return new w(function* () {
+      const n = /* @__PURE__ */ new Map();
+      for (const [s, r] of e) {
+        const o = n.get(s) ?? 0;
+        yield [t(s, r, o), r], n.set(s, o + 1);
+      }
+    });
+  }
+  /**
+   * An utility method that returns a new {@link SmartIterator}
+   * object containing all the keys of the iterator.
+   *
+   * Since the iterator is lazy, the keys will be extracted
+   * be executed once the resulting iterator is materialized.
+   *
+   * A new iterator will be created, holding the reference to the original one.  
+   * This means that the original iterator won't be consumed until the
+   * new one is and that consuming one of them will consume the other as well.
+   *
+   * ```ts
+   * const keys = new SmartIterator([-3, Symbol(), "A", { }, null, [1 , 2, 3], false])
+   *     .groupBy((value) => typeof value)
+   *     .keys();
+   *
+   * console.log(keys.toArray()); // ["number", "symbol", "string", "object", "boolean"]
+   * ```
+   *
+   * @returns A new {@link SmartIterator} containing all the keys of the iterator.
+   */
   keys() {
     const t = this._elements;
-    return new c(function* () {
+    return new u(function* () {
       const e = /* @__PURE__ */ new Set();
       for (const [n] of t)
         e.has(n) || (e.add(n), yield n);
     });
   }
-  items() {
+  /**
+   * An utility method that returns a new {@link SmartIterator}
+   * object containing all the entries of the iterator.  
+   * Each entry is a tuple containing the key and the element.
+   *
+   * Since the iterator is lazy, the entries will be extracted
+   * be executed once the resulting iterator is materialized.
+   *
+   * A new iterator will be created, holding the reference to the original one.  
+   * This means that the original iterator won't be consumed until the
+   * new one is and that consuming one of them will consume the other as well.
+   *
+   * ```ts
+   * const entries = new SmartIterator<number>([-3, 0, 2, -1, 3])
+   *     .groupBy((value) => value % 2 === 0 ? "even" : "odd")
+   *     .entries();
+   *
+   * console.log(entries.toArray()); // [["odd", -3], ["even", 0], ["even", 2], ["odd", -1], ["odd", 3]]
+   * ```
+   *
+   * @returns A new {@link SmartIterator} containing all the entries of the iterator.
+   */
+  entries() {
     return this._elements;
   }
+  /**
+   * An utility method that returns a new {@link SmartIterator}
+   * object containing all the values of the iterator.
+   *
+   * Since the iterator is lazy, the values will be extracted
+   * be executed once the resulting iterator is materialized.
+   *
+   * A new iterator will be created, holding the reference to the original one.  
+   * This means that the original iterator won't be consumed until the
+   * new one is and that consuming one of them will consume the other as well.
+   *
+   * ```ts
+   * const values = new SmartIterator<number>([-3, -1, 0, 2, 3, 5, 6, 8])
+   *     .groupBy((value) => value % 2 === 0 ? "even" : "odd")
+   *     .values();
+   *
+   * console.log(values.toArray()); // [-3, -1, 0, 2, 3, 5, 6, 8]
+   * ```
+   *
+   * @returns A new {@link SmartIterator} containing all the values of the iterator.
+   */
   values() {
     const t = this._elements;
-    return new c(function* () {
+    return new u(function* () {
       for (const [e, n] of t)
         yield n;
     });
   }
+  /**
+   * Materializes the iterator into an array of arrays.  
+   * This method will consume the entire iterator in the process.
+   *
+   * If the iterator is infinite, the method will never return.
+   *
+   * ```ts
+   * const aggregator = new SmartIterator<number>([-3, -1, 0, 2, 3, 5, 6, 8])
+   *     .groupBy((value) => value % 2 === 0 ? "even" : "odd");
+   *
+   * console.log(aggregator.toArray()); // [[-3, -1, 3, 5], [0, 2, 6, 8]]
+   * ```
+   *
+   * @returns An {@link Array} of arrays containing the elements of the iterator.
+   */
   toArray() {
     const t = this.toMap();
     return Array.from(t.values());
   }
+  /**
+   * Materializes the iterator into a map.  
+   * This method will consume the entire iterator in the process.
+   *
+   * If the iterator is infinite, the method will never return.
+   *
+   * ```ts
+   * const aggregator = new SmartIterator<number>([-3, -1, 0, 2, 3, 5, 6, 8])
+   *     .groupBy((value) => value % 2 === 0 ? "even" : "odd");
+   *
+   * console.log(aggregator.toMap()); // Map(2) { "odd" => [-3, -1, 3, 5], "even" => [0, 2, 6, 8] }
+   * ```
+   *
+   * @returns A {@link Map} containing the elements of the iterator.
+   */
   toMap() {
     const t = /* @__PURE__ */ new Map();
     for (const [e, n] of this._elements) {
@@ -988,154 +3092,360 @@ const g = class g {
     }
     return t;
   }
-  toObject() {
-    const t = {};
-    for (const [e, n] of this._elements) {
-      const s = t[e] ?? [];
-      s.push(n), t[e] = s;
+  /**
+   * Materializes the iterator into an object.  
+   * This method will consume the entire iterator in the process.
+   *
+   * If the iterator is infinite, the method will never return.
+   *
+   * ```ts
+   * const aggregator = new SmartIterator<number>([-3, -1, 0, 2, 3, 5, 6, 8])
+   *     .groupBy((value) => value % 2 === 0 ? "even" : "odd");
+   *
+   * console.log(aggregator.toObject()); // { odd: [-3, -1, 3, 5], even: [0, 2, 6, 8] }
+   * ```
+   *
+   * @returns An {@link Object} containing the elements of the iterator.
+   */
+  toObject() {
+    const t = {};
+    for (const [e, n] of this._elements) {
+      const s = t[e] ?? [];
+      s.push(n), t[e] = s;
     }
     return t;
   }
 };
-let S = g;
-const Be = Function;
-class Ge extends Be {
+let g = w;
+const Le = Function;
+var pe, be;
+class Ge extends (be = Le, pe = Symbol.toStringTag, be) {
+  /**
+   * Initializes a new instance of the {@link CallableObject} class.
+   */
   constructor() {
-    super("return this.invoke(...arguments);");
-    const t = this.bind(this);
-    return Object.setPrototypeOf(this, t), t;
+    super("return this._invoke(...arguments);");
+    a(this, pe, "CallableObject");
+    const e = this.bind(this);
+    return Object.setPrototypeOf(this, e), e;
   }
 }
-var be;
-be = Symbol.toStringTag;
-class M {
+var xe;
+xe = Symbol.toStringTag;
+class E {
+  /**
+   * Initializes a new instance of the {@link Publisher} class.
+   *
+   * ```ts
+   * const publisher = new Publisher();
+   * ```
+   */
   constructor() {
+    /**
+     * A map containing all the subscribers for each event.
+     *
+     * The keys are the names of the events they are subscribed to.  
+     * The values are the arrays of the subscribers themselves.
+     */
     a(this, "_subscribers");
-    a(this, be, "Publisher");
+    a(this, xe, "Publisher");
     this._subscribers = /* @__PURE__ */ new Map();
   }
+  /**
+   * Unsubscribes all the subscribers from all the events.
+   *
+   * ```ts
+   * publisher.subscribe("player:spawn", (evt) => { [...] });
+   * publisher.subscribe("player:move", (coords) => { [...] });
+   * publisher.subscribe("player:move", () => { [...] });
+   * publisher.subscribe("player:move", ({ x, y }) => { [...] });
+   * publisher.subscribe("player:death", () => { [...] });
+   *
+   * // All these subscribers are working fine...
+   *
+   * publisher.clear();
+   *
+   * // ... but now they're all gone!
+   * ```
+   */
+  clear() {
+    this._subscribers.clear();
+  }
+  /**
+   * Publishes an event to all the subscribers.
+   *
+   * ```ts
+   * publisher.subscribe("player:move", (coords) => { [...] });
+   * publisher.subscribe("player:move", ({ x, y }) => { [...] });
+   * publisher.subscribe("player:move", (evt) => { [...] });
+   *
+   * publisher.publish("player:move", { x: 10, y: 20 });
+   * ```
+   *
+   * @template K The key of the map containing the callback signature to publish.
+   *
+   * @param event The name of the event to publish.
+   * @param args The arguments to pass to the subscribers.
+   *
+   * @returns An array containing the return values of all the subscribers.
+   */
+  publish(t, ...e) {
+    const n = this._subscribers.get(t);
+    return n ? n.slice().map((s) => s(...e)) : [];
+  }
+  /**
+   * Subscribes a new subscriber to an event.
+   *
+   * ```ts
+   * let unsubscribe: () => void;
+   * publisher.subscribe("player:death", unsubscribe);
+   * publisher.subscribe("player:spawn", (evt) =>
+   * {
+   *     unsubscribe = publisher.subscribe("player:move", ({ x, y }) => { [...] });
+   * });
+   * ```
+   *
+   * @template K The key of the map containing the callback signature to subscribe.
+   *
+   * @param event The name of the event to subscribe to.
+   * @param subscriber The subscriber to add to the event.
+   *
+   * @returns A function that can be used to unsubscribe the subscriber.
+   */
   subscribe(t, e) {
     this._subscribers.has(t) || this._subscribers.set(t, []);
     const n = this._subscribers.get(t);
     return n.push(e), () => {
       const s = n.indexOf(e);
       if (s < 0)
-        throw new Je("Unable to unsubscribe the required subscriber. The subscription was already unsubscribed.");
+        throw new C("Unable to unsubscribe the required subscriber. The subscription was already unsubscribed.");
       n.splice(s, 1);
     };
   }
-  publish(t, ...e) {
+  /**
+   * Unsubscribes a subscriber from an event.
+   *
+   * ```ts
+   * const onPlayerMove = ({ x, y }: Point) => { [...] };
+   *
+   * publisher.subscribe("player:spawn", (evt) => publisher.subscribe("player:move", onPlayerMove));
+   * publisher.subscribe("player:death", () => publisher.unsubscribe("player:move", onPlayerMove));
+   * ```
+   *
+   * @template K The key of the map containing the callback signature to unsubscribe.
+   *
+   * @param event The name of the event to unsubscribe from.
+   * @param subscriber The subscriber to remove from the event.
+   */
+  unsubscribe(t, e) {
     const n = this._subscribers.get(t);
-    return n ? n.slice().map((s) => s(...e)) : [];
+    if (!n)
+      return;
+    const s = n.indexOf(e);
+    if (s < 0)
+      throw new C("Unable to unsubscribe the required subscriber. The subscription was already unsubscribed or was never subscribed.");
+    n.splice(s, 1);
   }
 }
-class st extends Ge {
+var ge, ve;
+class rt extends (ve = Ge, ge = Symbol.toStringTag, ve) {
+  /**
+   * Initializes a new instance of the {@link SwitchableCallback} class.
+   *
+   * ```ts
+   * const onPointerMove = new SwitchableCallback<(evt: PointerEvent) => void>();
+   * ```
+   */
   constructor() {
     const e = () => {
-      throw new ze(
+      throw new Be(
         "The `SwitchableCallback` has no callback defined yet. Did you forget to call the `register` method?"
       );
     };
     super();
+    /**
+     * The currently selected implementation of the callback.
+     */
     a(this, "_callback");
+    /**
+     * All the implementations that have been registered for the callback.
+     *
+     * The keys are the names of the implementations they were registered with.  
+     * The values are the implementations themselves.
+     */
     a(this, "_callbacks");
+    /**
+     * A flag indicating whether the callback is enabled or not.
+     *
+     * This protected property is the only one that can be modified directly by the derived classes.  
+     * If you're looking for the public and readonly property, use
+     * the {@link SwitchableCallback.isEnabled} getter instead.
+     */
     a(this, "_isEnabled");
+    /**
+     * The key that is associated with the currently selected implementation.
+     *
+     * This protected property is the only one that can be modified directly by the derived classes.  
+     * If you're looking for the public and readonly property, use the {@link SwitchableCallback.key} getter instead.
+     */
     a(this, "_key");
-    a(this, "invoke");
-    this._callback = e, this._callbacks = /* @__PURE__ */ new Map(), this._isEnabled = !1, this._key = "", this.invoke = (...n) => this._callback(...n);
+    /**
+     * The function that will be called by the extended class when the object is invoked as a function.
+     */
+    a(this, "_invoke");
+    a(this, ge, "SwitchableCallback");
+    this._callback = e, this._callbacks = /* @__PURE__ */ new Map(), this._isEnabled = !0, this._key = "", this._invoke = (...n) => this._callback(...n);
   }
+  /**
+   * A flag indicating whether the callback is enabled or not.
+   *
+   * It indicates whether the callback is currently able to execute the currently selected implementation.  
+   * If it's disabled, the callback will be invoked without executing anything.
+   */
   get isEnabled() {
     return this._isEnabled;
   }
+  /**
+   * The key that is associated with the currently selected implementation.
+   */
   get key() {
     return this._key;
   }
+  /**
+   * Enables the callback, allowing it to execute the currently selected implementation.
+   *
+   * Also note that:
+   * - If any implementation has been registered yet, a {@link KeyException} will be thrown.  
+   * - If the callback is already enabled, a {@link RuntimeException} will be thrown.
+   *
+   * ```ts
+   * window.addEventListener("pointerdown", () => { onPointerMove.enable(); });
+   * window.addEventListener("pointermove", onPointerMove);
+   * ```
+   */
   enable() {
     if (!this._key)
-      throw new x(
+      throw new b(
         "The `SwitchableCallback` has no callback defined yet. Did you forget to call the `register` method?"
       );
     if (this._isEnabled)
-      throw new m("The `SwitchableCallback` is already enabled.");
+      throw new y("The `SwitchableCallback` is already enabled.");
     this._callback = this._callbacks.get(this._key), this._isEnabled = !0;
   }
+  /**
+   * Disables the callback, allowing it to be invoked without executing any implementation.
+   *
+   * If the callback is already disabled, a {@link RuntimeException} will be thrown.
+   *
+   * ```ts
+   * window.addEventListener("pointermove", onPointerMove);
+   * window.addEventListener("pointerup", () => { onPointerMove.disable(); });
+   * ```
+   */
   disable() {
     if (!this._isEnabled)
-      throw new m("The `SwitchableCallback` is already disabled.");
+      throw new y("The `SwitchableCallback` is already disabled.");
     this._callback = () => {
     }, this._isEnabled = !1;
   }
+  /**
+   * Registers a new implementation for the callback.
+   *
+   * Also note that:
+   * - If the callback has no other implementation registered yet, this one will be selected as default.
+   * - If the key has already been used for another implementation, a {@link KeyException} will be thrown.
+   *
+   * ```ts
+   * onPointerMove.register("pressed", () => { [...] });
+   * onPointerMove.register("released", () => { [...] });
+   * ```
+   *
+   * @param key The key that will be associated with the implementation.
+   * @param callback The implementation to register.
+   */
   register(e, n) {
     if (this._callbacks.size === 0)
       this._key = e, this._callback = n;
     else if (this._callbacks.has(e))
-      throw new x(`The key '${e}' has already been used for another callback.`);
+      throw new b(`The key '${e}' has already been used for another callback.`);
     this._callbacks.set(e, n);
   }
+  /**
+   * Unregisters an implementation for the callback.
+   *
+   * Also note that:
+   * - If the key is the currently selected implementation, a {@link KeyException} will be thrown.
+   * - If the key has no associated implementation yet, a {@link KeyException} will be thrown.
+   *
+   * ```ts
+   * onPointerMove.unregister("released");
+   * ```
+   *
+   * @param key The key that is associated with the implementation to unregister.
+   */
   unregister(e) {
+    if (this._key === e)
+      throw new b("Unable to unregister the currently selected callback.");
     if (!this._callbacks.has(e))
-      throw new x(`The key '${e}' doesn't yet have any associated callback.`);
+      throw new b(`The key '${e}' doesn't yet have any associated callback.`);
     this._callbacks.delete(e);
   }
+  /**
+   * Switches the callback to the implementation associated with the given key.
+   *
+   * If the key has no associated implementation yet, a {@link KeyException} will be thrown.
+   *
+   * ```ts
+   * window.addEventListener("pointerdown", () => { onPointerMove.switch("pressed"); });
+   * window.addEventListener("pointermove", onPointerMove);
+   * window.addEventListener("pointerup", () => { onPointerMove.switch("released"); });
+   * ```
+   *
+   * @param key The key that is associated with the implementation to switch to.
+   */
   switch(e) {
     if (!this._callbacks.has(e))
-      throw new x(`The key '${e}' doesn't yet have any associated callback.`);
+      throw new b(`The key '${e}' doesn't yet have any associated callback.`);
     this._key = e, this._isEnabled && (this._callback = this._callbacks.get(e));
   }
 }
-var xe;
-xe = Symbol.toStringTag;
-class qe {
-  constructor(t, e = 40) {
-    a(this, "_handle");
-    a(this, "_startTime");
-    a(this, "_isRunning");
-    a(this, "_start");
-    a(this, "_stop");
-    a(this, xe, "GameLoop");
-    this._startTime = 0, this._isRunning = !1, Oe ? (this._start = () => {
-      t(this.elapsedTime), this._handle = window.requestAnimationFrame(this._start);
-    }, this._stop = () => window.cancelAnimationFrame(this._handle)) : (console.warn(
-      `Not a browser environment detected. Using setInterval@${e}ms instead of requestAnimationFrame...`
-    ), this._start = () => {
-      this._handle = setInterval(() => t(this.elapsedTime), e);
-    }, this._stop = () => clearInterval(this._handle));
-  }
-  get startTime() {
-    return this._startTime;
-  }
-  get isRunning() {
-    return this._isRunning;
-  }
-  get elapsedTime() {
-    return performance.now() - this._startTime;
-  }
-  start(t = 0) {
-    if (this._isRunning)
-      throw new m("The game loop has already been started.");
-    this._startTime = performance.now() - t, this._start(), this._isRunning = !0;
-  }
-  stop() {
-    if (!this._isRunning)
-      throw new m("The game loop hadn't yet started.");
-    if (!this._handle)
-      throw new k();
-    this._stop(), this._handle = void 0, this._isRunning = !1;
-  }
-}
-var ve;
-ve = Symbol.toStringTag;
-class rt {
+var ke;
+ke = Symbol.toStringTag;
+class it {
+  /**
+   * Initializes a new instance of the {@link JSONStorage} class.  
+   * It cannot be instantiated outside of a browser environment or an {@link EnvironmentException} is thrown.
+   *
+   * ```ts
+   * const jsonStorage = new JSONStorage();
+   * ```
+   *
+   * @param preferPersistence
+   * Whether to prefer the {@link localStorage} over the {@link sessionStorage} when calling an ambivalent method.  
+   * If omitted, it defaults to `true` to prefer the persistent storage.
+   */
   constructor(t = !0) {
+    /**
+     * Whether to prefer the {@link localStorage} over the {@link sessionStorage} when calling an ambivalent method.
+     *
+     * If `true`, the persistent storage is preferred. If `false`, the volatile storage is preferred.  
+     * Default is `true`.
+     */
     a(this, "_preferPersistence");
+    /**
+     * A reference to the volatile {@link sessionStorage} storage.
+     */
     a(this, "_volatile");
+    /**
+     * A reference to the persistent {@link localStorage} storage.
+     */
     a(this, "_persistent");
-    a(this, ve, "JSONStorage");
-    if (this._preferPersistence = t, !Oe)
-      throw new Ve(
+    a(this, ke, "JSONStorage");
+    if (!Oe)
+      throw new Je(
         "The `JSONStorage` class can only be instantiated within a browser environment."
       );
-    this._volatile = window.sessionStorage, this._persistent = window.localStorage;
+    this._preferPersistence = t, this._volatile = window.sessionStorage, this._persistent = window.localStorage;
   }
   _get(t, e, n) {
     const s = t.getItem(e);
@@ -1167,128 +3477,274 @@ class rt {
     return this._get(this._persistent, t, e);
   }
   /**
-   * Checks whether the property with the specified name exists in the corresponding storage.
+   * Checks whether the value with the specified key exists within the default storage.
+   *
+   * ```ts
+   * if (jsonStorage.has("key"))
+   * {
+   *    // The key exists. Do something...
+   * }
+   * ```
    *
-   * @param propertyName The name of the property to check.
-   * @param persistent Whether to use the persistent `localStorage` or the volatile `sessionStorage`.
+   * @param key The key of the value to check.
+   * @param persistent
+   * Whether to prefer the persistent {@link localStorage} over the volatile {@link sessionStorage}.  
+   * If omitted, it defaults to the `preferPersistence` value set in the constructor.
    *
-   * @returns `true` if the property exists, `false` otherwise.
+   * @returns `true` if the key exists, `false` otherwise.
    */
   has(t, e) {
     return (e ? this._persistent : this._volatile).getItem(t) !== null;
   }
   /**
-   * Checks whether the property with the specified name exists in the volatile `sessionStorage`.
+   * Checks whether the value with the specified key exists within the volatile {@link sessionStorage}.
    *
-   * @param propertyName The name of the property to check.
+   * ```ts
+   * if (jsonStorage.knows("key"))
+   * {
+   *    // The key exists. Do something...
+   * }
+   * ```
    *
-   * @returns `true` if the property exists, `false` otherwise.
+   * @param key The key of the value to check.
+   *
+   * @returns `true` if the key exists, `false` otherwise.
    */
   knows(t) {
     return this._volatile.getItem(t) !== null;
   }
   /**
-   * Checks whether the property with the specified name exists looking first in the
-   * volatile `sessionStorage` and then in the persistent `localStorage`.
+   * Checks whether the value with the specified key exists looking first in the
+   * volatile {@link sessionStorage} and then, if not found, in the persistent {@link localStorage}.
+   *
+   * ```ts
+   * if (jsonStorage.find("key"))
+   * {
+   *    // The key exists. Do something...
+   * }
+   * ```
    *
-   * @param propertyName The name of the property to check.
+   * @param key The key of the value to check.
    *
-   * @returns `true` if the property exists, `false` otherwise.
+   * @returns `true` if the key exists, `false` otherwise.
    */
   find(t) {
     return this.knows(t) ?? this.exists(t);
   }
   /**
-   * Checks whether the property with the specified name exists in the persistent `localStorage`.
+   * Checks whether the value with the specified key exists within the persistent {@link localStorage}.
    *
-   * @param propertyName The name of the property to check.
+   * ```ts
+   * if (jsonStorage.exists("key"))
+   * {
+   *    // The key exists. Do something...
+   * }
+   * ```
    *
-   * @returns `true` if the property exists, `false` otherwise.
+   * @param key The key of the value to check.
+   *
+   * @returns `true` if the key exists, `false` otherwise.
    */
   exists(t) {
     return this._persistent.getItem(t) !== null;
   }
   /**
-   * Sets the value with the specified name in the corresponding storage.
-   * If the value is `undefined`, the property is removed from the storage.
+   * Sets the value with the specified key in the default storage.  
+   * If the value is `undefined` or omitted, the key is removed from the storage.
+   *
+   * ```ts
+   * jsonStorage.set("key");
+   * jsonStorage.set("key", value);
+   * jsonStorage.set("key", obj?.value);
+   * ```
+   *
+   * @template T The type of the value to set.
    *
-   * @param propertyName The name of the property to set.
-   * @param newValue The new value to set.
-   * @param persistent Whether to use the persistent `localStorage` or the volatile `sessionStorage`.
+   * @param key The key of the value to set.
+   * @param newValue The new value to set. If it's `undefined` or omitted, the key is removed instead.
+   * @param persistent
+   * Whether to prefer the persistent {@link localStorage} over the volatile {@link sessionStorage}.  
+   * If omitted, it defaults to the `preferPersistence` value set in the constructor.
    */
   set(t, e, n = this._preferPersistence) {
     const s = n ? this._persistent : this._volatile;
     this._set(s, t, e);
   }
   /**
-   * Sets the value with the specified name in the volatile `sessionStorage`.
-   * If the value is `undefined`, the property is removed from the storage.
+   * Sets the value with the specified key in the volatile {@link sessionStorage}.  
+   * If the value is `undefined` or omitted, the key is removed from the storage.
    *
-   * @param propertyName The name of the property to set.
-   * @param newValue The new value to set.
+   * ```ts
+   * jsonStorage.remember("key");
+   * jsonStorage.remember("key", value);
+   * jsonStorage.remember("key", obj?.value);
+   * ```
+   *
+   * @template T The type of the value to set.
+   *
+   * @param key The key of the value to set.
+   * @param newValue The new value to set. If it's `undefined` or omitted, the key is removed instead.
    */
   remember(t, e) {
     this._set(this._volatile, t, e);
   }
   /**
-   * Sets the value with the specified name in the persistent `localStorage`.
-   * If the value is `undefined`, the property is removed from the storage.
+   * Sets the value with the specified key in the persistent {@link localStorage}.  
+   * If the value is `undefined` or omitted, the key is removed from the storage.
+   *
+   * ```ts
+   * jsonStorage.write("key");
+   * jsonStorage.write("key", value);
+   * jsonStorage.write("key", obj?.value);
+   * ```
    *
-   * @param propertyName The name of the property to set.
-   * @param newValue The new value to set.
+   * @template T The type of the value to set.
+   *
+   * @param key The key of the value to set.
+   * @param newValue The new value to set. If it's `undefined` or omitted, the key is removed instead.
    */
   write(t, e) {
     this._set(this._persistent, t, e);
   }
   /**
-   * Removes the value with the specified name from the volatile `sessionStorage`.
+   * Removes the value with the specified key from the default storage.
+   *
+   * ```ts
+   * jsonStorage.delete("key");
+   * ```
    *
-   * @param propertyName The name of the property to remove.
+   * @param key The key of the value to remove.
+   * @param persistent
+   * Whether to prefer the persistent {@link localStorage} over the volatile {@link sessionStorage}.  
+   * If omitted, it defaults to the `preferPersistence` value set in the constructor.
+   */
+  delete(t, e) {
+    (e ? this._persistent : this._volatile).removeItem(t);
+  }
+  /**
+   * Removes the value with the specified key from the volatile {@link sessionStorage}.
+   *
+   * ```ts
+   * jsonStorage.forget("key");
+   * ```
+   *
+   * @param key The key of the value to remove.
    */
   forget(t) {
     this._volatile.removeItem(t);
   }
   /**
-   * Removes the value with the specified name from the persistent `localStorage`.
+   * Removes the value with the specified key from the persistent {@link localStorage}.
    *
-   * @param propertyName The name of the property to remove.
+   * ```ts
+   * jsonStorage.erase("key");
+   * ```
+   *
+   * @param key The key of the value to remove.
    */
   erase(t) {
     this._persistent.removeItem(t);
   }
   /**
-   * Removes the value with the specified name from all the storages.
+   * Removes the value with the specified key from both the
+   * volatile {@link sessionStorage} and the persistent {@link localStorage}.
+   *
+   * ```ts
+   * jsonStorage.clear("key");
+   * ```
    *
-   * @param propertyName The name of the property to remove.
+   * @param key The key of the value to remove.
    */
   clear(t) {
     this._volatile.removeItem(t), this._persistent.removeItem(t);
   }
 }
-var ke;
-ke = Symbol.toStringTag;
+var Se;
+Se = Symbol.toStringTag;
 const R = class R {
+  /**
+   * Initializes a new instance of the {@link SmartPromise} class.
+   *
+   * ```ts
+   * const promise = new SmartPromise<string>((resolve, reject) =>
+   * {
+   *     setTimeout(() => resolve("Hello, World!"), 1_000);
+   * });
+   * ```
+   *
+   * @param executor
+   * The function responsible for eventually resolving or rejecting the promise.  
+   * Similarly to the native {@link Promise} object, it's immediately executed after the promise is created.
+   */
   constructor(t) {
+    /**
+     * A flag indicating whether the promise is still pending or not.
+     *
+     * The protected property is the only one that can be modified directly by the derived classes.  
+     * If you're looking for the public and readonly property, use the {@link SmartPromise.isPending} getter instead.
+     */
     a(this, "_isPending");
+    /**
+     * A flag indicating whether the promise has been fulfilled or not.
+     *
+     * The protected property is the only one that can be modified directly by the derived classes.  
+     * If you're looking for the public and readonly property, use the {@link SmartPromise.isFulfilled} getter instead.
+     */
     a(this, "_isFulfilled");
+    /**
+     * A flag indicating whether the promise has been rejected or not.
+     *
+     * The protected property is the only one that can be modified directly by the derived classes.  
+     * If you're looking for the public and readonly property, use the {@link SmartPromise.isRejected} getter instead.
+     */
     a(this, "_isRejected");
+    /**
+     * The native {@link Promise} object wrapped by this instance.
+     */
     a(this, "_promise");
-    a(this, ke, "SmartPromise");
+    a(this, Se, "SmartPromise");
     this._isPending = !0, this._isFulfilled = !1, this._isRejected = !1;
     const e = (s) => (this._isPending = !1, this._isFulfilled = !0, s), n = (s) => {
       throw this._isPending = !1, this._isRejected = !0, s;
     };
     this._promise = new Promise(t).then(e, n);
   }
+  /**
+   * Wraps a new {@link SmartPromise} object around an existing native {@link Promise} object.
+   *
+   * ```ts
+   * const request = fetch("https://api.example.com/data");
+   * const smartRequest = SmartPromise.FromPromise(request);
+   *
+   * console.log(request.isPending); // Throws an error: `isPending` is not a property of `Promise`.
+   * console.log(smartRequest.isPending); // true
+   *
+   * const response = await request;
+   * console.log(smartRequest.isFulfilled); // true
+   * ```
+   *
+   * @param promise The promise to wrap.
+   *
+   * @returns A new {@link SmartPromise} object that wraps the provided promise.
+   */
   static FromPromise(t) {
     return new R((e, n) => t.then(e, n));
   }
+  /**
+   * A flag indicating whether the promise is still pending or not.
+   */
   get isPending() {
     return this._isPending;
   }
+  /**
+   * A flag indicating whether the promise has been fulfilled or not.
+   */
   get isFulfilled() {
     return this._isFulfilled;
   }
+  /**
+   * A flag indicating whether the promise has been rejected or not.
+   */
   get isRejected() {
     return this._isRejected;
   }
@@ -1298,296 +3754,384 @@ const R = class R {
   catch(t) {
     return this._promise.catch(t);
   }
+  /**
+   * Attaches a callback that executes right after the promise is settled, regardless of the outcome.
+   *
+   * ```ts
+   * const promise = new SmartPromise((resolve, reject) =>
+   * {
+   *     setTimeout(resolve, Math.random() * 1_000);
+   *     setTimeout(reject, Math.random() * 1_000);
+   * });
+   *
+   *
+   * promise
+   *     .then(() => console.log("OK!")) // Logs "OK!" if the promise is fulfilled.
+   *     .catch(() => console.log("KO!")) // Logs "KO!" if the promise is rejected.
+   *     .finally(() => console.log("Done!")); // Always logs "Done!".
+   * ```
+   *
+   * @param onFinally The callback to execute when once promise is settled.
+   *
+   * @returns A new {@link Promise} that executes the callback once the promise is settled.
+   */
   finally(t) {
     return this._promise.finally(t);
   }
 };
-let T = R;
-var Se, Te;
-class Ke extends (Te = T, Se = Symbol.toStringTag, Te) {
+let k = R;
+var Te, Ee;
+class Ke extends (Ee = k, Te = Symbol.toStringTag, Ee) {
+  /**
+   * Initializes a new instance of the {@link DeferredPromise} class.
+   *
+   * ```ts
+   * const promise = new DeferredPromise<string, string[]>((value: string) => value.split(" "));
+   * ```
+   *
+   * @param onFulfilled The callback to execute once the promise is fulfilled.
+   * @param onRejected The callback to execute once the promise is rejected.
+   */
   constructor(e, n) {
     let s, r;
     super((o, l) => {
       s = o, r = l;
     });
+    /**
+     * The exposed function that allows to resolve the promise.
+     *
+     * This protected property is the only one that can be modified directly by the derived classes.  
+     * If you're looking for the public and readonly property, use the {@link DeferredPromise.resolve} getter instead.
+     */
     a(this, "_resolve");
+    /**
+     * The exposed function that allows to reject the promise.
+     *
+     * This protected property is the only one that can be modified directly by the derived classes.  
+     * If you're looking for the public and readonly property, use the {@link DeferredPromise.reject} getter instead.
+     */
     a(this, "_reject");
-    a(this, Se, "DeferredPromise");
-    this._promise.then(e, n), this._resolve = s, this._reject = r;
+    a(this, Te, "DeferredPromise");
+    this._promise = this._promise.then(e, n), this._resolve = s, this._reject = r;
   }
+  /**
+   * The exposed function that allows to reject the promise.
+   */
   get resolve() {
     return this._resolve;
   }
+  /**
+   * The exposed function that allows to reject the promise.
+   */
   get reject() {
     return this._reject;
   }
+  /**
+   * Watches another promise and resolves or rejects this promise when the other one is settled.
+   *
+   * ```ts
+   * const promise = new Promise<string>((resolve) => setTimeout(() => resolve("Hello, World!"), 1_000));
+   * const deferred = new DeferredPromise<string, string[]>((value: string) => value.split(" "));
+   *
+   * deferred.then((result) => console.log(result)); // ["Hello,", "World!"]
+   * deferred.watch(promise);
+   * ```
+   *
+   * @param otherPromise The promise to watch.
+   *
+   * @returns The current instance of the {@link DeferredPromise} class.
+   */
   watch(e) {
     return e.then(this.resolve, this.reject), this;
   }
 }
-function it(i) {
-  return new Promise((t) => setTimeout(t, i));
+var Me, Re;
+class ot extends (Re = k, Me = Symbol.toStringTag, Re) {
+  /**
+   * Initializes a new instance of the {@link TimedPromise} class.
+   *
+   * ```ts
+   * const promise = new TimedPromise<string>((resolve, reject) =>
+   * {
+   *    setTimeout(() => resolve("Hello, World!"), Math.random() * 10_000);
+   *
+   * }, 5_000);
+   * ```
+   *
+   * @param executor
+   * The function responsible for eventually resolving or rejecting the promise.  
+   * Similarly to the native {@link Promise} object, it's immediately executed after the promise is created.
+   *
+   * @param timeout The maximum time in milliseconds that the operation can take before timing out.
+   */
+  constructor(e, n) {
+    super((s, r) => {
+      const o = (S) => {
+        clearTimeout(P), s(S);
+      }, l = (S) => {
+        clearTimeout(P), r(S);
+      }, P = setTimeout(() => l(new Ye("The operation has timed out.")), n);
+      e(o, l);
+    });
+    a(this, Me, "TimedPromise");
+  }
 }
-function ot() {
-  return new Promise((i) => requestAnimationFrame(() => i()));
+var M = /* @__PURE__ */ ((i) => (i[i.Millisecond = 1] = "Millisecond", i[i.Second = 1e3] = "Second", i[i.Minute = 6e4] = "Minute", i[i.Hour = 36e5] = "Hour", i[i.Day = 864e5] = "Day", i[i.Week = 6048e5] = "Week", i[i.Month = 2592e6] = "Month", i[i.Year = 31536e6] = "Year", i))(M || {}), He = /* @__PURE__ */ ((i) => (i[i.Sunday = 0] = "Sunday", i[i.Monday = 1] = "Monday", i[i.Tuesday = 2] = "Tuesday", i[i.Wednesday = 3] = "Wednesday", i[i.Thursday = 4] = "Thursday", i[i.Friday = 5] = "Friday", i[i.Saturday = 6] = "Saturday", i))(He || {});
+function at(i, t, e = 864e5) {
+  let n;
+  return i = new Date(i), t = new Date(t), i < t ? n = Math.floor : n = Math.ceil, n((t.getTime() - i.getTime()) / e);
 }
-function v() {
-  return new Promise((i) => setTimeout(i));
+function lt(i, t, e = 864e5) {
+  if (i >= t)
+    throw new p("The end date must be greater than the start date.");
+  return new u(function* () {
+    const n = new Date(t).getTime();
+    let s = new Date(i).getTime();
+    for (; s < n; )
+      yield new Date(s), s += e;
+  });
+}
+function Qe(i, t = 864e5) {
+  if (t <= 1)
+    throw new p(
+      "Rounding a timestamp by milliseconds or less makes no sense.Use the timestamp value directly instead."
+    );
+  if (t > 864e5)
+    throw new p(
+      "Rounding by more than a day leads to unexpected results. Consider using other methods to round dates by weeks, months or years."
+    );
+  return i = new Date(i), new Date(Math.floor(i.getTime() / t) * t);
 }
-var Ee;
-Ee = Symbol.toStringTag;
-const P = class P {
-  constructor(t, e) {
+function ut(i, t = 0) {
+  i = new Date(i);
+  const e = 7 - t, n = (i.getUTCDay() + e) % 7, s = i.getTime() - 864e5 * n;
+  return Qe(new Date(s));
+}
+var Fe;
+Fe = Symbol.toStringTag;
+class qe {
+  /**
+   * Initializes a new instance of the {@link GameLoop} class.
+   *
+   * ```ts
+   * const loop = new GameLoop((elapsedTime: number) => { [...] });
+   * ```
+   *
+   * @param callback The function that will be executed at each iteration of the game loop.
+   * @param msIfNotBrowser
+   * The interval in milliseconds that will be used if the current environment isn't a browser. Default is `40`.
+   */
+  constructor(t, e = 40) {
+    /**
+     * The handle of the interval or the animation frame, depending on the environment.  
+     * It's used to stop the game loop when the {@link GameLoop._stop} method is called.
+     */
+    a(this, "_handle");
+    /**
+     * The time when the game loop has started.  
+     * In addition to indicating the {@link https://en.wikipedia.org/wiki/Unix_time|Unix timestamp}
+     * of the start of the game loop, it's also used to calculate the elapsed time.
+     *
+     * This protected property is the only one that can be modified directly by the derived classes.  
+     * If you're looking for the public and readonly property, use the {@link GameLoop.startTime} getter instead.
+     */
     a(this, "_startTime");
-    a(this, "_estimatedTime");
-    a(this, "_endTime");
-    a(this, "_currentStep");
-    a(this, "_percentage");
+    /**
+     * A flag indicating whether the game loop is currently running or not.
+     *
+     * This protected property is the only one that can be modified directly by the derived classes.  
+     * If you're looking for the public and readonly property, use the {@link GameLoop.isRunning} getter instead.
+     */
     a(this, "_isRunning");
-    a(this, "_hasCompleted");
-    a(this, "_hasFailed");
-    a(this, "_promise");
+    /**
+     * The {@link Publisher} object that will be used to publish the events of the game loop.
+     */
     a(this, "_publisher");
-    a(this, Ee, "LongRunningTask");
-    this._startTime = 0, this._estimatedTime = 0, this._currentStep = 0, this._percentage = 0, this._isRunning = !0, this._hasCompleted = !1, this._hasFailed = !1;
-    const n = (o) => (this._estimatedTime = 0, this._endTime = Date.now(), this._percentage = 100, this._isRunning = !1, this._hasCompleted = !0, o), s = (o) => {
-      throw this._endTime = Date.now(), this._isRunning = !1, this._hasFailed = !0, o;
-    };
-    let r;
-    if (e = { ...P._DefaultOptions, ...e }, e.trackProgress) {
-      let o;
-      this._publisher = new M(), e.totalSteps ? e.stepIncrement ? o = (l) => {
-        l ? this._currentStep += l : this._currentStep += e.stepIncrement, this._percentage = this._currentStep / e.totalSteps * 100;
-        const u = Date.now() - this._startTime, h = e.totalSteps - this._currentStep;
-        this._estimatedTime = u / this._currentStep * h;
-      } : o = (l) => {
-        if (l) {
-          this._currentStep += l, this._percentage = this._currentStep / e.totalSteps * 100;
-          const u = Date.now() - this._startTime, h = e.totalSteps - this._currentStep;
-          this._estimatedTime = u / this._currentStep * h;
-        }
-      } : e.stepIncrement ? o = (l) => {
-        l ? this._currentStep += l : this._currentStep += e.stepIncrement;
-      } : o = (l) => {
-        l && (this._currentStep += l);
-      }, e.ignoreErrors ? r = async (l) => {
-        const u = t();
-        for (this._startTime = Date.now(); ; ) {
-          try {
-            const { done: h, value: _ } = await u.next();
-            if (h)
-              return l(_);
-            o(_);
-          } catch (h) {
-            console.error(h);
-          }
-          this._publisher.publish("progress"), await v();
-        }
-      } : r = async (l, u) => {
-        try {
-          const h = t();
-          for (this._startTime = Date.now(); ; ) {
-            const { done: _, value: I } = await h.next();
-            if (_)
-              return l(I);
-            o(I), this._publisher.publish("progress"), await v();
-          }
-        } catch (h) {
-          u(h);
-        }
-      };
-    } else e.ignoreErrors ? r = async (o) => {
-      const l = t();
-      for (this._startTime = Date.now(); ; ) {
-        try {
-          const { done: u, value: h } = await l.next();
-          if (u)
-            return o(h);
-        } catch (u) {
-          console.error(u);
-        }
-        await v();
-      }
-    } : r = async (o, l) => {
-      try {
-        const u = t();
-        for (this._startTime = Date.now(); ; ) {
-          const { done: h, value: _ } = await u.next();
-          if (h)
-            return o(_);
-          await v();
-        }
-      } catch (u) {
-        l(u);
-      }
-    };
-    this._promise = new Promise(r).then(n, s);
-  }
-  static get _DefaultOptions() {
-    return {
-      ignoreErrors: !1,
-      stepIncrement: 1,
-      totalSteps: null,
-      trackProgress: !1
-    };
+    /**
+     * The internal method actually responsible for starting the game loop.
+     *
+     * Depending on the current environment, it could use the
+     * {@link requestAnimationFrame} or the {@link setInterval} function.
+     */
+    a(this, "_start");
+    /**
+     * The internal method actually responsible for stopping the game loop.
+     *
+     * Depending on the current environment, it could use the
+     * {@link cancelAnimationFrame} or the {@link clearInterval} function.
+     */
+    a(this, "_stop");
+    a(this, Fe, "GameLoop");
+    this._startTime = 0, this._isRunning = !1, Oe ? (this._start = () => {
+      t(this.elapsedTime), this._handle = window.requestAnimationFrame(this._start);
+    }, this._stop = () => window.cancelAnimationFrame(this._handle)) : (console.warn(
+      `Not a browser environment detected. Using setInterval@${e}ms instead of requestAnimationFrame...`
+    ), this._start = () => {
+      this._handle = setInterval(() => t(this.elapsedTime), e);
+    }, this._stop = () => clearInterval(this._handle)), this._publisher = new E();
   }
+  /**
+   * The time when the game loop has started.  
+   * In addition to indicating the {@link https://en.wikipedia.org/wiki/Unix_time|Unix timestamp}
+   * of the start of the game loop, it's also used to calculate the elapsed time.
+   */
   get startTime() {
     return this._startTime;
   }
-  get elapsedTime() {
-    return this._isRunning ? Date.now() - this._startTime : this._endTime - this._startTime;
-  }
-  get estimatedTime() {
-    return this._estimatedTime;
-  }
-  get endTime() {
-    if (this._isRunning)
-      throw new m("The task is still running and has no end time yet.");
-    return this._endTime;
-  }
-  get currentStep() {
-    return this._currentStep;
-  }
-  get percentage() {
-    return this._percentage;
-  }
+  /**
+   * A flag indicating whether the game loop is currently running or not.
+   */
   get isRunning() {
     return this._isRunning;
   }
-  get hasCompleted() {
-    return this._hasCompleted;
-  }
-  get hasFailed() {
-    return this._hasFailed;
-  }
-  then(t, e) {
-    return this._promise.then(t, e);
-  }
-  catch(t) {
-    return this._promise.catch(t);
-  }
-  finally(t) {
-    return this._promise.finally(t);
-  }
-  onProgress(t) {
-    if (!this._publisher)
-      throw new m(
-        "You cannot subscribe to progress events without enabling progress tracking. Did you forget to set the `trackProgress` option to `true` when creating the task?"
-      );
-    return this._publisher.subscribe("progress", t);
-  }
-};
-let C = P;
-var Me;
-Me = Symbol.toStringTag;
-class at {
-  constructor() {
-    a(this, "_onFulfilled");
-    a(this, Me, "Thenable");
-    this._onFulfilled = (t) => t;
-  }
-  _resolve(t) {
-    return this._onFulfilled(t);
+  /**
+   * The elapsed time since the start of the game loop.  
+   * It's calculated as the difference between the current time and the {@link GameLoop.startTime}.
+   */
+  get elapsedTime() {
+    return performance.now() - this._startTime;
   }
-  then(t, e) {
-    if (e) {
-      const n = this._onFulfilled;
-      this._onFulfilled = (s) => {
-        try {
-          return s = n(s), t(s);
-        } catch (r) {
-          return e(r);
-        }
-      };
-    } else if (t) {
-      const n = this._onFulfilled;
-      this._onFulfilled = (s) => (s = n(s), t(s));
-    }
-    return this;
+  /**
+   * Starts the execution of the game loop.
+   *
+   * If the game loop is already running, a {@link RuntimeException} will be thrown.
+   *
+   * ```ts
+   * loop.onStart(() => { [...] }); // This callback will be executed.
+   * loop.start();
+   * ```
+   *
+   * @param elapsedTime The elapsed time to set as default when the game loop starts. Default is `0`.
+   */
+  start(t = 0) {
+    if (this._isRunning)
+      throw new y("The game loop has already been started.");
+    this._startTime = performance.now() - t, this._start(), this._isRunning = !0, this._publisher.publish("start");
   }
-  catch(t) {
-    if (t) {
-      const e = this._onFulfilled;
-      this._onFulfilled = (n) => {
-        try {
-          return e(n);
-        } catch (s) {
-          return t(s);
-        }
-      };
-    }
-    return this;
+  /**
+   * Stops the execution of the game loop.
+   *
+   * If the game loop hasn't yet started, a {@link RuntimeException} will be thrown.
+   *
+   * ```ts
+   * loop.onStop(() => { [...] }); // This callback will be executed.
+   * loop.stop();
+   * ```
+   */
+  stop() {
+    if (!this._isRunning)
+      throw new y("The game loop had already stopped or hadn't yet started.");
+    if (!this._handle)
+      throw new x();
+    this._stop(), this._handle = void 0, this._isRunning = !1, this._publisher.publish("stop");
   }
-  finally(t) {
-    if (t) {
-      const e = this._onFulfilled;
-      this._onFulfilled = (n) => {
-        try {
-          return e(n);
-        } finally {
-          t();
-        }
-      };
-    }
-    return this;
+  /**
+   * Subscribes to the `start` event of the game loop.
+   *
+   * ```ts
+   * loop.onStart(() => { console.log("The game loop has started."); });
+   * ```
+   *
+   * @param callback The function that will be executed when the game loop starts.
+   *
+   * @returns A function that can be used to unsubscribe from the event.
+   */
+  onStart(t) {
+    return this._publisher.subscribe("start", t);
   }
-}
-var Fe, Re;
-class lt extends (Re = T, Fe = Symbol.toStringTag, Re) {
-  constructor(e, n) {
-    super((s, r) => {
-      const o = (_) => {
-        clearTimeout(h), s(_);
-      }, l = (_) => {
-        clearTimeout(h), r(_);
-      }, h = setTimeout(() => l(new We("The operation has timed out.")), n);
-      e(o, l);
-    });
-    a(this, Fe, "TimedPromise");
+  /**
+   * Subscribes to the `stop` event of the game loop.
+   *
+   * ```ts
+   * loop.onStop(() => { console.log("The game loop has stopped."); });
+   * ```
+   *
+   * @param callback The function that will be executed when the game loop stops.
+   *
+   * @returns A function that can be used to unsubscribe from the event.
+   */
+  onStop(t) {
+    return this._publisher.subscribe("stop", t);
   }
 }
-var F = /* @__PURE__ */ ((i) => (i[i.Millisecond = 1] = "Millisecond", i[i.Second = 1e3] = "Second", i[i.Minute = 6e4] = "Minute", i[i.Hour = 36e5] = "Hour", i[i.Day = 864e5] = "Day", i[i.Week = 6048e5] = "Week", i[i.Month = 2592e6] = "Month", i[i.Year = 31536e6] = "Year", i))(F || {});
-function ut(i, t, e = 864e5) {
-  return i = new Date(i), t = new Date(t), Math.floor((t.getTime() - i.getTime()) / e);
-}
-function ct(i, t, e = 864e5) {
-  return i = new Date(i), t = new Date(t), new c(function* () {
-    const n = t.getTime();
-    let s = i.getTime();
-    for (; s < n; )
-      yield new Date(s), s += e;
-  });
-}
-function ht(i, t = 864e5) {
-  return i = new Date(i), new Date(Math.floor(i.getTime() / t) * t);
-}
-var Pe, De;
-class ft extends (De = qe, Pe = Symbol.toStringTag, De) {
-  constructor(e = F.Second) {
+var Pe, Ce;
+class ct extends (Ce = qe, Pe = Symbol.toStringTag, Ce) {
+  /**
+   * Initializes a new instance of the {@link Clock} class.
+   *
+   * ```ts
+   * const clock = new Clock();
+   * ```
+   *
+   * @param msIfNotBrowser
+   * The interval in milliseconds at which the clock will tick if the environment is not a browser.  
+   * `TimeUnit.Second` by default.
+   */
+  constructor(e = M.Second) {
     super((n) => this._publisher.publish("tick", n), e);
+    /**
+     * The {@link Publisher} object that will be used to publish the events of the clock.
+     */
     a(this, "_publisher");
     a(this, Pe, "Clock");
-    this._publisher = new M();
+    this._publisher = new E();
   }
+  /**
+   * Starts the execution of the clock.
+   *
+   * If the clock is already running, a {@link RuntimeException} will be thrown.
+   *
+   * ```ts
+   * clock.onStart(() => { [...] }); // This callback will be executed.
+   * clock.start();
+   * ```
+   *
+   * @param elapsedTime The elapsed time to set as default when the clock starts. Default is `0`.
+   */
   start(e = 0) {
     if (this._isRunning)
-      throw new m("The clock has already been started.");
-    super.start(e), this._publisher.publish("start");
+      throw new y("The clock has already been started.");
+    this._startTime = performance.now() - e, this._start(), this._isRunning = !0, this._publisher.publish("start");
   }
+  /**
+   * Stops the execution of the clock.
+   *
+   * If the clock hasn't yet started, a {@link RuntimeException} will be thrown.
+   *
+   * ```ts
+   * clock.onStop(() => { [...] }); // This callback will be executed.
+   * clock.stop();
+   * ```
+   */
   stop() {
     if (!this._isRunning)
-      throw new m("The clock hadn't yet started.");
-    super.stop(), this._publisher.publish("stop");
-  }
-  onStart(e) {
-    return this._publisher.subscribe("start", e);
-  }
-  onStop(e) {
-    return this._publisher.subscribe("stop", e);
+      throw new y("The clock had already stopped or hadn't yet started.");
+    if (!this._handle)
+      throw new x();
+    this._stop(), this._handle = void 0, this._isRunning = !1, this._publisher.publish("stop");
   }
+  /**
+   * Subscribes to the `tick` event of the clock.
+   *
+   * ```ts
+   * clock.onTick((elapsedTime) => { [...] }); // This callback will be executed.
+   * clock.start();
+   * ```
+   *
+   * @param callback The callback that will be executed when the clock ticks.
+   * @param tickStep
+   * The minimum time in milliseconds that must pass from the previous execution of the callback to the next one.
+   *
+   * - If it's a positive number, the callback will be executed only if the
+   * time passed from the previous execution is greater than this number.
+   * - If it's `0`, the callback will be executed every tick without even checking for the time.
+   * - If it's a negative number, a {@link RangeException} will be thrown.
+   *
+   * @returns A function that can be used to unsubscribe from the event.
+   */
   onTick(e, n = 0) {
     if (n < 0)
-      throw new $e("The tick step must be a non-negative number.");
+      throw new p("The tick step must be a non-negative number.");
     if (n === 0)
       return this._publisher.subscribe("tick", e);
     let s = 0;
@@ -1596,68 +4140,246 @@ class ft extends (De = qe, Pe = Symbol.toStringTag, De) {
     });
   }
 }
-var Ie, Ce;
-class dt extends (Ce = qe, Ie = Symbol.toStringTag, Ce) {
-  constructor(e, n = F.Second) {
+var je, Ie;
+class ht extends (Ie = qe, je = Symbol.toStringTag, Ie) {
+  /**
+   * Initializes a new instance of the {@link Countdown} class.
+   *
+   * ```ts
+   * const countdown = new Countdown(10_000);
+   * ```
+   *
+   * @param duration
+   * The total duration of the countdown in milliseconds.
+   *
+   * @param msIfNotBrowser
+   * The interval in milliseconds at which the countdown will tick if the environment is not a browser.  
+   * `TimeUnit.Second` by default.
+   */
+  constructor(e, n = M.Second) {
     super(() => {
       const r = this.remainingTime;
-      this._publisher.publish("tick", r), r <= 0 && (this._deferrerStop(), this._publisher.publish("expire"));
+      r <= 0 ? (this._deferrerStop(), this._publisher.publish("tick", 0), this._publisher.publish("expire")) : this._publisher.publish("tick", r);
     }, n);
-    a(this, "_deferrer");
+    /**
+     * The {@link Publisher} object that will be used to publish the events of the countdown.
+     */
     a(this, "_publisher");
+    /**
+     * The total duration of the countdown in milliseconds.
+     *
+     * This protected property is the only one that can be modified directly by the derived classes.  
+     * If you're looking for the public and readonly property, use the {@link Countdown.duration} getter instead.
+     */
     a(this, "_duration");
-    a(this, Ie, "Countdown");
-    this._publisher = new M(), this._duration = e;
+    /**
+     * The {@link DeferredPromise} that will be resolved or rejected when the countdown expires or stops.
+     */
+    a(this, "_deferrer");
+    a(this, je, "Countdown");
+    this._publisher = new E(), this._duration = e;
   }
+  /**
+   * The total duration of the countdown in milliseconds.
+   */
   get duration() {
     return this._duration;
   }
+  /**
+   * The remaining time of the countdown in milliseconds.  
+   * It's calculated as the difference between the total duration and the elapsed time.
+   */
   get remainingTime() {
     return this._duration - this.elapsedTime;
   }
+  /**
+   * The internal method actually responsible for stopping the
+   * countdown and resolving or rejecting the {@link Countdown._deferrer} promise.
+   *
+   * @param reason
+   * The reason why the countdown has stopped.
+   *
+   * - If it's `undefined`, the promise will be resolved.
+   * - If it's a value, the promise will be rejected with that value.
+   */
   _deferrerStop(e) {
     if (!this._isRunning)
-      throw new m("The countdown hadn't yet started.");
+      throw new y("The countdown hadn't yet started.");
     if (!this._deferrer)
-      throw new k();
-    super.stop(), e !== void 0 ? this._deferrer.reject(e) : this._deferrer.resolve(), this._deferrer = void 0;
+      throw new x();
+    this._stop(), this._handle = void 0, this._isRunning = !1, e !== void 0 ? this._deferrer.reject(e) : this._deferrer.resolve(), this._deferrer = void 0;
   }
+  /**
+   * Starts the execution of the countdown.
+   *
+   * If the countdown is already running, a {@link RuntimeException} will be thrown.
+   *
+   * ```ts
+   * countdown.onStart(() => { [...] }); // This callback will be executed.
+   * countdown.start();
+   * ```
+   *
+   * @param remainingTime
+   * The remaining time to set as default when the countdown starts.  
+   * Default is the {@link Countdown.duration} itself.
+   *
+   * @returns A {@link SmartPromise} that will be resolved or rejected when the countdown expires or stops.
+   */
   start(e = this.duration) {
     if (this._isRunning)
-      throw new m("The countdown has already been started.");
+      throw new y("The countdown had already stopped or hadn't yet started.");
     if (this._deferrer)
-      throw new k();
+      throw new x();
     return this._deferrer = new Ke(), super.start(this.duration - e), this._publisher.publish("start"), this._deferrer;
   }
+  /**
+   * Stops the execution of the countdown.
+   *
+   * If the countdown hasn't yet started, a {@link RuntimeException} will be thrown.
+   *
+   * ```ts
+   * countdown.onStop(() => { [...] }); // This callback will be executed.
+   * countdown.stop();
+   * ```
+   *
+   * @param reason
+   * The reason why the countdown has stopped.
+   *
+   * - If it's `undefined`, the promise will be resolved.
+   * - If it's a value, the promise will be rejected with that value.
+   */
   stop(e) {
     this._deferrerStop(e), this._publisher.publish("stop", e);
   }
+  /**
+   * Subscribes to the `expire` event of the countdown.
+   *
+   * ```ts
+   * countdown.onExpire(() => { [...] }); // This callback will be executed once the countdown has expired.
+   * countdown.start();
+   * ```
+   *
+   * @param callback The callback that will be executed when the countdown expires.
+   *
+   * @returns A function that can be used to unsubscribe from the event.
+   */
   onExpire(e) {
     return this._publisher.subscribe("expire", e);
   }
-  onStart(e) {
-    return this._publisher.subscribe("start", e);
-  }
-  onStop(e) {
-    return this._publisher.subscribe("stop", e);
-  }
+  /**
+   * Subscribes to the `tick` event of the countdown.
+   *
+   * ```ts
+   * countdown.onTick((remainingTime) => { [...] }); // This callback will be executed.
+   * countdown.start();
+   * ```
+   *
+   * @param callback The callback that will be executed when the countdown ticks.
+   * @param tickStep
+   * The minimum time in milliseconds that must pass from the previous execution of the callback to the next one.
+   *
+   * - If it's a positive number, the callback will be executed only if the
+   * time passed from the previous execution is greater than this number.
+   * - If it's `0`, the callback will be executed every tick without even checking for the time.
+   * - If it's a negative number, a {@link RangeException} will be thrown.
+   *
+   * @returns A function that can be used to unsubscribe from the event.
+   */
   onTick(e, n = 0) {
     if (n < 0)
-      throw new $e("The tick step must be a non-negative number.");
+      throw new p("The tick step must be a non-negative number.");
     if (n === 0)
       return this._publisher.subscribe("tick", e);
-    let s = 0;
+    let s = this.remainingTime;
     return this._publisher.subscribe("tick", (r) => {
       s - r < n || (e(r), s = r);
     });
   }
 }
-var je;
-je = Symbol.toStringTag;
-const D = class D {
+var Ae;
+Ae = Symbol.toStringTag;
+class ft {
   constructor() {
-    a(this, je, "Random");
+    a(this, Ae, "Curve");
   }
+  /**
+   * Generates a given number of values following a linear curve.  
+   * The values are equally spaced and normalized between 0 and 1.
+   *
+   * ```ts
+   * for (const value of Curve.Linear(5))
+   * {
+   *     console.log(value); // 0, 0.25, 0.5, 0.75, 1
+   * }
+   * ```
+   *
+   * @param values The number of values to generate.
+   *
+   * @returns A {@link SmartIterator} object that generates the values following a linear curve.
+   */
+  static Linear(t) {
+    const e = t - 1;
+    return new u(function* () {
+      for (let n = 0; n < t; n += 1)
+        yield n / e;
+    });
+  }
+  /**
+   * Generates a given number of values following an exponential curve.  
+   * The values are equally spaced and normalized between 0 and 1.
+   *
+   * ```ts
+   * for (const value of Curve.Exponential(6))
+   * {
+   *     console.log(value); // 0, 0.04, 0.16, 0.36, 0.64, 1
+   * }
+   * ```
+   *
+   * @param values The number of values to generate.
+   * @param base
+   * The base of the exponential curve. Default is `2`.
+   *
+   * Also note that:
+   * - If it's equal to `1`, the curve will be linear.
+   * - If it's included between `0` and `1`, the curve will be logarithmic.
+   *
+   * The base cannot be negative. If so, a {@link ValueException} will be thrown.
+   *
+   * @returns A {@link SmartIterator} object that generates the values following an exponential curve.
+   */
+  static Exponential(t, e = 2) {
+    if (e < 0)
+      throw new d("The base of the exponential curve cannot be negative.");
+    const n = t - 1;
+    return new u(function* () {
+      for (let s = 0; s < t; s += 1)
+        yield Math.pow(s / n, e);
+    });
+  }
+}
+var Ne;
+Ne = Symbol.toStringTag;
+const F = class F {
+  constructor() {
+    a(this, Ne, "Random");
+  }
+  /**
+   * Generates a random boolean value.
+   *
+   * ```ts
+   * if (Random.Boolean())
+   * {
+   *    // Do something...
+   * }
+   * ```
+   *
+   * @param ratio
+   * The probability of generating `true`.
+   *
+   * It must be included between `0` and `1`. Default is `0.5`.
+   *
+   * @returns A random boolean value.
+   */
   static Boolean(t = 0.5) {
     return Math.random() < t;
   }
@@ -1667,47 +4389,86 @@ const D = class D {
   static Decimal(t, e) {
     return t === void 0 ? Math.random() : e === void 0 ? Math.random() * t : Math.random() * (e - t) + t;
   }
+  /**
+   * Picks a random valid index from a given array of elements.
+   *
+   * @template T The type of the elements in the array.
+   *
+   * @param elements
+   * The array of elements to pick from.
+   *
+   * It must contain at least one element. Otherwise, a {@link ValueException} will be thrown.
+   *
+   * @returns A valid random index from the given array.
+   */
   static Index(t) {
     if (t.length === 0)
-      throw new p("You must provide at least one element.");
+      throw new d("You must provide at least one element.");
     return this.Integer(t.length);
   }
+  /**
+   * Picks a random element from a given array of elements.
+   *
+   * @template T The type of the elements in the array.
+   *
+   * @param elements
+   * The array of elements to pick from.
+   *
+   * It must contain at least one element. Otherwise, a {@link ValueException} will be thrown.
+   *
+   * @returns A random element from the given array.
+   */
   static Choice(t) {
-    return t[D.Index(t)];
+    return t[F.Index(t)];
   }
 };
-let j = D;
-function mt(i, t = "text/javascript") {
+let j = F;
+function dt(i) {
+  return new Promise((t) => setTimeout(t, i));
+}
+function mt() {
+  return new Promise((i) => requestAnimationFrame(() => i()));
+}
+function wt() {
+  return new Promise((i) => setTimeout(i));
+}
+function yt(i, t = "text/javascript") {
   return new Promise((e, n) => {
     const s = document.createElement("script");
-    s.async = !0, s.defer = !0, s.src = i, s.type = t, s.onload = () => e(), s.onerror = () => n(), document.body.appendChild(s);
+    s.async = !0, s.defer = !0, s.src = i, s.type = t, s.onload = (r) => e(), s.onerror = (r) => n(r), document.body.appendChild(s);
   });
 }
 function _t(...i) {
-  return new c(function* () {
+  return new u(function* () {
     for (const t of i)
       for (const e of t)
         yield e;
   });
 }
-function wt(i) {
-  if (Array.isArray(i))
+function pt(i) {
+  if (i instanceof Array)
     return i.length;
   let t = 0;
   for (const e of i)
     t += 1;
   return t;
 }
-function pt(i) {
-  return new c(function* () {
+function bt(i) {
+  return new u(function* () {
     let t = 0;
     for (const e of i)
       yield [t, e], t += 1;
   });
 }
-function yt(i, t, e = 1) {
-  return new c(function* () {
-    t === void 0 && (t = i, i = 0), i > t && (e = e ?? -1);
+function xt(i, t, e = 1) {
+  if (e <= 0)
+    throw new p(
+      "Step must be always a positive number, even when generating numbers in reverse order."
+    );
+  return t === void 0 && (t = i, i = 0), i > t ? new u(function* () {
+    for (let n = i; n > t; n -= e)
+      yield n;
+  }) : new u(function* () {
     for (let n = i; n < t; n += e)
       yield n;
   });
@@ -1720,16 +4481,16 @@ function gt(i) {
   }
   return t;
 }
-function bt(i) {
-  return new c(function* () {
+function vt(i) {
+  return new u(function* () {
     const t = /* @__PURE__ */ new Set();
     for (const e of i)
       t.has(e) || (t.add(e), yield e);
   });
 }
-function Le(i, t) {
-  return new c(function* () {
-    const e = i[Symbol.iterator](), n = t[Symbol.iterator]();
+function Ve(i, t) {
+  const e = i[Symbol.iterator](), n = t[Symbol.iterator]();
+  return new u(function* () {
     for (; ; ) {
       const s = e.next(), r = n.next();
       if (s.done || r.done)
@@ -1738,28 +4499,28 @@ function Le(i, t) {
     }
   });
 }
-function xt(i, t) {
+function kt(i, t) {
   if (t === void 0) {
     let r = 0, o = 0;
     for (const l of i)
       r += l, o += 1;
     if (o === 0)
-      throw new p("You must provide at least one value.");
+      throw new d("You must provide at least one value.");
     return r / o;
   }
   let e = 0, n = 0, s = 0;
-  for (const [r, o] of Le(i, t)) {
+  for (const [r, o] of Ve(i, t)) {
     if (o <= 0)
-      throw new p(`The weight for the value #${s} must be greater than zero.`);
+      throw new d(`The weight for the value #${s} must be greater than zero.`);
     e += r * o, n += o, s += 1;
   }
   if (s === 0)
-    throw new p("You must provide at least one value and weight.");
-  if (n > 0)
-    throw new p("The sum of weights must be greater than zero.");
+    throw new d("You must provide at least one value and weight.");
+  if (n <= 0)
+    throw new d("The sum of weights must be greater than zero.");
   return e / n;
 }
-function vt(i) {
+function St(i) {
   let t = 0;
   for (let e = 0; e < i.length; e += 1) {
     const n = i.charCodeAt(e);
@@ -1767,72 +4528,74 @@ function vt(i) {
   }
   return t;
 }
-function kt(i) {
+function Tt(i) {
   let t = 0;
   for (const e of i)
     t += e;
   return t;
 }
-function St(i) {
+function Et(i) {
   return `${i.charAt(0).toUpperCase()}${i.slice(1)}`;
 }
-const Tt = "2.0.0-rc.9";
+const Mt = "2.0.0";
 export {
-  E as AggregatedAsyncIterator,
-  S as AggregatedIterator,
+  T as AggregatedAsyncIterator,
+  g as AggregatedIterator,
   Ge as CallableObject,
-  ft as Clock,
-  dt as Countdown,
+  ct as Clock,
+  ht as Countdown,
+  ft as Curve,
   Ke as DeferredPromise,
-  f as Exception,
-  k as FatalErrorException,
-  Ae as FileException,
-  Ze as FileExistsException,
-  Ue as FileNotFoundException,
+  Je as EnvironmentException,
+  c as Exception,
+  x as FatalErrorException,
+  $e as FileException,
+  Ue as FileExistsException,
+  et as FileNotFoundException,
   qe as GameLoop,
-  rt as JSONStorage,
-  x as KeyException,
-  C as LongRunningTask,
-  et as NetworkException,
-  ze as NotImplementedException,
-  tt as PermissionException,
-  M as Publisher,
+  it as JSONStorage,
+  b as KeyException,
+  tt as NetworkException,
+  Be as NotImplementedException,
+  nt as PermissionException,
+  E as Publisher,
   j as Random,
-  $e as RangeException,
-  d as ReducedIterator,
-  Je as ReferenceException,
-  m as RuntimeException,
-  w as SmartAsyncIterator,
-  c as SmartIterator,
-  T as SmartPromise,
-  st as SwitchableCallback,
-  at as Thenable,
-  F as TimeUnit,
-  lt as TimedPromise,
-  We as TimeoutException,
-  nt as TypeException,
-  Tt as VERSION,
-  p as ValueException,
-  xt as average,
-  St as capitalize,
+  p as RangeException,
+  h as ReducedIterator,
+  C as ReferenceException,
+  y as RuntimeException,
+  f as SmartAsyncIterator,
+  u as SmartIterator,
+  k as SmartPromise,
+  rt as SwitchableCallback,
+  M as TimeUnit,
+  ot as TimedPromise,
+  Ye as TimeoutException,
+  st as TypeException,
+  Mt as VERSION,
+  d as ValueException,
+  He as WeekDay,
+  kt as average,
+  Et as capitalize,
   _t as chain,
-  wt as count,
-  ut as dateDifference,
-  ct as dateRange,
-  ht as dateRound,
-  it as delay,
-  pt as enumerate,
-  vt as hash,
+  pt as count,
+  at as dateDifference,
+  lt as dateRange,
+  Qe as dateRound,
+  dt as delay,
+  bt as enumerate,
+  ut as getWeek,
+  St as hash,
   Oe as isBrowser,
-  Qe as isNode,
-  Xe as isWebWorker,
-  mt as loadScript,
-  ot as nextAnimationFrame,
-  yt as range,
+  Ze as isNode,
+  We as isWorker,
+  yt as loadScript,
+  mt as nextAnimationFrame,
+  xt as range,
   gt as shuffle,
-  kt as sum,
-  bt as unique,
-  v as yieldToEventLoop,
-  Le as zip
+  Tt as sum,
+  vt as unique,
+  wt as yieldToEventLoop,
+  Ve as zip
 };
 //# sourceMappingURL=core.js.map