@daiso-tech/core 0.33.0 → 0.35.0

package/dist/collection/contracts/async-collection.contract.d.ts

@@ -2,40 +2,40 @@
  * @module Collection
  */
 import type { AsyncReduce, CrossJoinResult, AsyncPredicate, AsyncForEach, AsyncMap, AsyncModifier, Tap, AsyncTransform, Comparator, EnsureRecord, EnsureMap } from "../../collection/contracts/_shared/_module.js";
-import type { TimeSpan, AsyncLazyable, AsyncIterableValue } from "../../utilities/_module-exports.js";
+import type { AsyncLazyable, AsyncIterableValue } from "../../utilities/_module-exports.js";
 import type { LazyPromise } from "../../async/_module-exports.js";
 /**
  *
- * IMPORT_PATH: ```"@daiso-tech/core/collection/contracts"```
+ * IMPORT_PATH: `"@daiso-tech/core/collection/contracts"`
  */
 export type AsyncCollapse<TValue> = TValue extends Array<infer TItem> | Iterable<infer TItem> | IAsyncCollection<infer TItem> ? TItem : TValue;
 /**
- * The <i>IAsyncCollection</i> contract offers a fluent and efficient approach to working with {@link AsyncIterable} objects.
- * <i>IAsyncCollection</i> is immutable.
+ * The `IAsyncCollection` contract offers a fluent and efficient approach to working with {@link AsyncIterable} objects.
+ * `IAsyncCollection` is immutable.
  *
- * IMPORT_PATH: ```"@daiso-tech/core/collection/contracts"```
+ * IMPORT_PATH: `"@daiso-tech/core/collection/contracts"`
  * @group Contracts
  * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
  */
 export type IAsyncCollection<TInput = unknown> = AsyncIterable<TInput> & {
     /**
-     * The <i>toIterator</i> method converts the collection to a new iterator.
+     * The `toIterator` method converts the collection to a new iterator.
      */
     toIterator(): AsyncIterator<TInput, void>;
     /**
-     * The <i>entries</i> returns an IAsyncCollection of key, value pairs for every entry in the collection.
+     * The `entries` returns an IAsyncCollection of key, value pairs for every entry in the collection.
      */
     entries(): IAsyncCollection<[number, TInput]>;
     /**
-     * The <i>keys</i> method returns an IAsyncCollection of keys in the collection.
+     * The `keys` method returns an IAsyncCollection of keys in the collection.
      */
     keys(): IAsyncCollection<number>;
     /**
-     * The <i>values</i> method returns a copy of the collection.
+     * The `values` method returns a copy of the collection.
      */
     values(): IAsyncCollection<TInput>;
     /**
-     * The <i>filter</i> method filters the collection using <i>predicateFn</i>, keeping only those items that pass <i>predicateFn</i>.
+     * The `filter` method filters the collection using `predicateFn`, keeping only those items that pass `predicateFn`.
      * @example
      * ```ts
      * import type { IAsyncCollection } from "@daiso-tech/core";
@@ -52,7 +52,7 @@ export type IAsyncCollection<TInput = unknown> = AsyncIterable<TInput> & {
      */
     filter<TOutput extends TInput>(predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>, TOutput>): IAsyncCollection<TOutput>;
     /**
-     * The <i>reject</i> method filters the collection using <i>predicateFn</i>, keeping only those items that not pass <i>predicateFn</i>.
+     * The `reject` method filters the collection using `predicateFn`, keeping only those items that not pass `predicateFn`.
      * @example
      * ```ts
      * import type { IAsyncCollection } from "@daiso-tech/core";
@@ -69,8 +69,8 @@ export type IAsyncCollection<TInput = unknown> = AsyncIterable<TInput> & {
      */
     reject<TOutput extends TInput>(predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>, TOutput>): IAsyncCollection<Exclude<TInput, TOutput>>;
     /**
-     * The <i>map</i> method iterates through the collection and passes each item to <i>mapFn</i>.
-     * The <i>mapFn</i> is free to modify the item and return it, thus forming a new collection of modified items.
+     * The `map` method iterates through the collection and passes each item to `mapFn`.
+     * The `mapFn` is free to modify the item and return it, thus forming a new collection of modified items.
      * @example
      * ```ts
      * import type { IAsyncCollection } from "@daiso-tech/core";
@@ -87,7 +87,7 @@ export type IAsyncCollection<TInput = unknown> = AsyncIterable<TInput> & {
      */
     map<TOutput>(mapFn: AsyncMap<TInput, IAsyncCollection<TInput>, TOutput>): IAsyncCollection<TOutput>;
     /**
-     * The <i>reduce</i> method executes <i> reduceFn </i> function on each item of the array, passing in the return value from the calculation on the preceding item.
+     * The `reduce` method executes ` reduceFn ` function on each item of the array, passing in the return value from the calculation on the preceding item.
      * The final result of running the reducer across all items of the array is a single value.
      * @example
      * ```ts
@@ -125,7 +125,7 @@ export type IAsyncCollection<TInput = unknown> = AsyncIterable<TInput> & {
     reduce(reduceFn: AsyncReduce<TInput, IAsyncCollection<TInput>, TInput>, initialValue: TInput): LazyPromise<TInput>;
     reduce<TOutput>(reduceFn: AsyncReduce<TInput, IAsyncCollection<TInput>, TOutput>, initialValue: TOutput): LazyPromise<TOutput>;
     /**
-     * The <i>join</i> method joins the collection's items with <i> separator </i>. An error will be thrown when if a none string item is encounterd.
+     * The `join` method joins the collection's items with ` separator `. An error will be thrown when if a none string item is encounterd.
      * @throws {TypeCollectionError}
      * @example
      * ```ts
@@ -156,7 +156,7 @@ export type IAsyncCollection<TInput = unknown> = AsyncIterable<TInput> & {
      */
     join(separator?: string): LazyPromise<Extract<TInput, string>>;
     /**
-     * The <i>collapse</i> method collapses a collection of iterables into a single, flat collection.
+     * The `collapse` method collapses a collection of iterables into a single, flat collection.
      * @example
      * ```ts
      * import type { IAsyncCollection } from "@daiso-tech/core";
@@ -173,8 +173,8 @@ export type IAsyncCollection<TInput = unknown> = AsyncIterable<TInput> & {
      */
     collapse(): IAsyncCollection<AsyncCollapse<TInput>>;
     /**
-     * The <i>flatMap</i> method returns a new array formed by applying <i>mapFn</i> to each item of the array, and then collapses the result by one level.
-     * It is identical to a <i>map</i> method followed by a <i>collapse</i> method.
+     * The `flatMap` method returns a new array formed by applying `mapFn` to each item of the array, and then collapses the result by one level.
+     * It is identical to a `map` method followed by a `collapse` method.
      * @example
      * ```ts
      * import type { IAsyncCollection } from "@daiso-tech/core";
@@ -191,7 +191,7 @@ export type IAsyncCollection<TInput = unknown> = AsyncIterable<TInput> & {
      */
     flatMap<TOutput>(mapFn: AsyncMap<TInput, IAsyncCollection<TInput>, Iterable<TOutput>>): IAsyncCollection<TOutput>;
     /**
-     * The <i>change</i> method changes only the items that passes <i>predicateFn</i> using <i>mapFn</i>.
+     * The `change` method changes only the items that passes `predicateFn` using `mapFn`.
      * @example
      * ```ts
      * import type { IAsyncCollection } from "@daiso-tech/core";
@@ -208,7 +208,7 @@ export type IAsyncCollection<TInput = unknown> = AsyncIterable<TInput> & {
      */
     change<TFilterOutput extends TInput, TMapOutput>(predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>, TFilterOutput>, mapFn: AsyncMap<TFilterOutput, IAsyncCollection<TInput>, TMapOutput>): IAsyncCollection<TInput | TFilterOutput | TMapOutput>;
     /**
-     * The <i>set</i> method changes a item by i>index</i> using <i>value</i>.
+     * The `set` method changes a item by i>index` using `value`.
      * @example
      * ```ts
      * import type { IAsyncCollection } from "@daiso-tech/core";
@@ -238,7 +238,7 @@ export type IAsyncCollection<TInput = unknown> = AsyncIterable<TInput> & {
      */
     set(index: number, value: TInput | AsyncMap<TInput, IAsyncCollection<TInput>, TInput>): IAsyncCollection<TInput>;
     /**
-     * The <i>get</i> method returns the item by index. If the item is not found null will returned.
+     * The `get` method returns the item by index. If the item is not found null will returned.
      * @example
      * ```ts
      * import type { IAsyncCollection } from "@daiso-tech/core";
@@ -257,7 +257,7 @@ export type IAsyncCollection<TInput = unknown> = AsyncIterable<TInput> & {
      */
     get(index: number): LazyPromise<TInput | null>;
     /**
-     * The <i>getOrFail</i> method returns the item by index. If the item is not found an error will be thrown.
+     * The `getOrFail` method returns the item by index. If the item is not found an error will be thrown.
      * @throws {ItemNotFoundCollectionError} {@link ItemNotFoundCollectionError}
      * @example
      * ```ts
@@ -277,7 +277,7 @@ export type IAsyncCollection<TInput = unknown> = AsyncIterable<TInput> & {
      */
     getOrFail(index: number): LazyPromise<TInput>;
     /**
-     * The <i>page</i> method returns a new collection containing the items that would be present on <i> page </i> with custom <i> pageSize </i>.
+     * The `page` method returns a new collection containing the items that would be present on ` page ` with custom ` pageSize `.
      * @example
      * ```ts
      * import type { IAsyncCollection } from "@daiso-tech/core";
@@ -294,7 +294,7 @@ export type IAsyncCollection<TInput = unknown> = AsyncIterable<TInput> & {
      */
     page(page: number, pageSize: number): IAsyncCollection<TInput>;
     /**
-     * The <i>sum</i> method returns the sum of all items in the collection. If the collection includes other than number items an error will be thrown.
+     * The `sum` method returns the sum of all items in the collection. If the collection includes other than number items an error will be thrown.
      * @throws {TypeCollectionError} {@link TypeCollectionError}
      * @throws {EmptyCollectionError} {@link EmptyCollectionError}
      * @example
@@ -312,7 +312,7 @@ export type IAsyncCollection<TInput = unknown> = AsyncIterable<TInput> & {
      */
     sum(): LazyPromise<Extract<TInput, number>>;
     /**
-     * The <i>average</i> method returns the average of all items in the collection. If the collection includes other than number items an error will be thrown.
+     * The `average` method returns the average of all items in the collection. If the collection includes other than number items an error will be thrown.
      * @throws {TypeCollectionError} {@link TypeCollectionError}
      * @throws {EmptyCollectionError} {@link EmptyCollectionError}
      * @example
@@ -330,7 +330,7 @@ export type IAsyncCollection<TInput = unknown> = AsyncIterable<TInput> & {
      */
     average(): LazyPromise<Extract<TInput, number>>;
     /**
-     * The <i>median</i> method returns the median of all items in the collection. If the collection includes other than number items an error will be thrown.
+     * The `median` method returns the median of all items in the collection. If the collection includes other than number items an error will be thrown.
      * @throws {TypeCollectionError} {@link TypeCollectionError}
      * @throws {EmptyCollectionError} {@link EmptyCollectionError}
      * @example
@@ -348,7 +348,7 @@ export type IAsyncCollection<TInput = unknown> = AsyncIterable<TInput> & {
      */
     median(): LazyPromise<Extract<TInput, number>>;
     /**
-     * The <i>min</i> method returns the min of all items in the collection. If the collection includes other than number items an error will be thrown.
+     * The `min` method returns the min of all items in the collection. If the collection includes other than number items an error will be thrown.
      * @throws {TypeCollectionError} {@link TypeCollectionError}
      * @throws {EmptyCollectionError} {@link EmptyCollectionError}
      * @example
@@ -366,7 +366,7 @@ export type IAsyncCollection<TInput = unknown> = AsyncIterable<TInput> & {
      */
     min(): LazyPromise<Extract<TInput, number>>;
     /**
-     * The <i>max</i> method returns the max of all items in the collection. If the collection includes other than number items an error will be thrown.
+     * The `max` method returns the max of all items in the collection. If the collection includes other than number items an error will be thrown.
      * @throws {TypeCollectionError} {@link TypeCollectionError}
      * @throws {EmptyCollectionError} {@link EmptyCollectionError}
      * @example
@@ -384,7 +384,7 @@ export type IAsyncCollection<TInput = unknown> = AsyncIterable<TInput> & {
      */
     max(): LazyPromise<Extract<TInput, number>>;
     /**
-     * The <i>percentage</i> method may be used to quickly determine the percentage of items in the collection that pass <i>predicateFn</i>.
+     * The `percentage` method may be used to quickly determine the percentage of items in the collection that pass `predicateFn`.
      * @throws {EmptyCollectionError} {@link EmptyCollectionError}
      * @example
      * ```ts
@@ -401,7 +401,7 @@ export type IAsyncCollection<TInput = unknown> = AsyncIterable<TInput> & {
      */
     percentage(predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>): LazyPromise<number>;
     /**
-     * The <i>some</i> method determines whether at least one item in the collection matches <i>predicateFn</i>.
+     * The `some` method determines whether at least one item in the collection matches `predicateFn`.
      * @example
      * ```ts
      * import type { IAsyncCollection } from "@daiso-tech/core";
@@ -417,7 +417,7 @@ export type IAsyncCollection<TInput = unknown> = AsyncIterable<TInput> & {
      */
     some<TOutput extends TInput>(predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>, TOutput>): LazyPromise<boolean>;
     /**
-     * The <i>every</i> method determines whether all items in the collection matches <i>predicateFn</i>.
+     * The `every` method determines whether all items in the collection matches `predicateFn`.
      * @example
      * ```ts
      * import type { IAsyncCollection } from "@daiso-tech/core";
@@ -433,7 +433,7 @@ export type IAsyncCollection<TInput = unknown> = AsyncIterable<TInput> & {
      */
     every<TOutput extends TInput>(predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>, TOutput>): LazyPromise<boolean>;
     /**
-     * The <i>take</i> method takes the first <i>limit</i> items.
+     * The `take` method takes the first `limit` items.
      * @example
      * ```ts
      * import type { IAsyncCollection } from "@daiso-tech/core";
@@ -463,7 +463,7 @@ export type IAsyncCollection<TInput = unknown> = AsyncIterable<TInput> & {
      */
     take(limit: number): IAsyncCollection<TInput>;
     /**
-     * The <i>takeUntil</i> method takes items until <i>predicateFn</i> returns true.
+     * The `takeUntil` method takes items until `predicateFn` returns true.
      * @example
      * ```ts
      * import type { IAsyncCollection } from "@daiso-tech/core";
@@ -480,7 +480,7 @@ export type IAsyncCollection<TInput = unknown> = AsyncIterable<TInput> & {
      */
     takeUntil(predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>): IAsyncCollection<TInput>;
     /**
-     * The <i>takeWhile</i> method takes items until <i>predicateFn</i> returns false.
+     * The `takeWhile` method takes items until `predicateFn` returns false.
      * @example
      * ```ts
      * import type { IAsyncCollection } from "@daiso-tech/core";
@@ -497,7 +497,7 @@ export type IAsyncCollection<TInput = unknown> = AsyncIterable<TInput> & {
      */
     takeWhile(predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>): IAsyncCollection<TInput>;
     /**
-     * The <i>skip</i> method skips the first <i>offset</i> items.
+     * The `skip` method skips the first `offset` items.
      * @example
      * ```ts
      * import type { IAsyncCollection } from "@daiso-tech/core";
@@ -514,7 +514,7 @@ export type IAsyncCollection<TInput = unknown> = AsyncIterable<TInput> & {
      */
     skip(offset: number): IAsyncCollection<TInput>;
     /**
-     * The <i>skipUntil</i> method skips items until <i>predicateFn</i> returns true.
+     * The `skipUntil` method skips items until `predicateFn` returns true.
      * @example
      * ```ts
      * import type { IAsyncCollection } from "@daiso-tech/core";
@@ -531,7 +531,7 @@ export type IAsyncCollection<TInput = unknown> = AsyncIterable<TInput> & {
      */
     skipUntil(predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>): IAsyncCollection<TInput>;
     /**
-     * The <i>skipWhile</i> method skips items until <i>predicateFn</i> returns false.
+     * The `skipWhile` method skips items until `predicateFn` returns false.
      * @example
      * ```ts
      * import type { IAsyncCollection } from "@daiso-tech/core";
@@ -548,7 +548,7 @@ export type IAsyncCollection<TInput = unknown> = AsyncIterable<TInput> & {
      */
     skipWhile(predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>): IAsyncCollection<TInput>;
     /**
-     * The <i>when</i> method will execute <i>callback</i> when <i>condition</i> evaluates to true.
+     * The `when` method will execute `callback` when `condition` evaluates to true.
      * @example
      * ```ts
      * import type { IAsyncCollection } from "@daiso-tech/core";
@@ -566,7 +566,7 @@ export type IAsyncCollection<TInput = unknown> = AsyncIterable<TInput> & {
      */
     when<TExtended = TInput>(condition: boolean, callback: AsyncModifier<IAsyncCollection<TInput>, IAsyncCollection<TExtended>>): IAsyncCollection<TInput | TExtended>;
     /**
-     * The <i>whenEmpty</i> method will execute <i>callback</i> when the collection is empty.
+     * The `whenEmpty` method will execute `callback` when the collection is empty.
      * @example
      * ```ts
      * import type { IAsyncCollection } from "@daiso-tech/core";
@@ -596,7 +596,7 @@ export type IAsyncCollection<TInput = unknown> = AsyncIterable<TInput> & {
      */
     whenEmpty<TExtended = TInput>(callback: AsyncModifier<IAsyncCollection<TInput>, IAsyncCollection<TExtended>>): IAsyncCollection<TInput | TExtended>;
     /**
-     * The <i>whenNot</i> method will execute <i>callback</i> when <i>condition</i> evaluates to false.
+     * The `whenNot` method will execute `callback` when `condition` evaluates to false.
      * @example
      * ```ts
      * import type { IAsyncCollection } from "@daiso-tech/core";
@@ -614,7 +614,7 @@ export type IAsyncCollection<TInput = unknown> = AsyncIterable<TInput> & {
      */
     whenNot<TExtended = TInput>(condition: boolean, callback: AsyncModifier<IAsyncCollection<TInput>, IAsyncCollection<TExtended>>): IAsyncCollection<TInput | TExtended>;
     /**
-     * The <i>whenNotEmpty</i> method will execute <i>callback</i> when the collection is not empty.
+     * The `whenNotEmpty` method will execute `callback` when the collection is not empty.
      * @example
      * ```ts
      * import type { IAsyncCollection } from "@daiso-tech/core";
@@ -643,7 +643,7 @@ export type IAsyncCollection<TInput = unknown> = AsyncIterable<TInput> & {
      */
     whenNotEmpty<TExtended = TInput>(callback: AsyncModifier<IAsyncCollection<TInput>, IAsyncCollection<TExtended>>): IAsyncCollection<TInput | TExtended>;
     /**
-     * The <i>pipe</i> method passes the orignal collection to <i>callback</i> and returns the result from <i>callback</i>.
+     * The `pipe` method passes the orignal collection to `callback` and returns the result from `callback`.
      * This method is useful when you want compose multiple smaller functions.
      * @example
      * ```ts
@@ -671,7 +671,7 @@ export type IAsyncCollection<TInput = unknown> = AsyncIterable<TInput> & {
      */
     pipe<TOutput = TInput>(callback: AsyncTransform<IAsyncCollection<TInput>, TOutput>): LazyPromise<TOutput>;
     /**
-     * The <i>tap</i> method passes a copy of the original collection to <i>callback</i>, allowing you to do something with the items while not affecting the original collection.
+     * The `tap` method passes a copy of the original collection to `callback`, allowing you to do something with the items while not affecting the original collection.
      * @example
      * ```ts
      * import type { IAsyncCollection } from "@daiso-tech/core";
@@ -692,8 +692,8 @@ export type IAsyncCollection<TInput = unknown> = AsyncIterable<TInput> & {
      */
     tap(callback: Tap<IAsyncCollection<TInput>>): IAsyncCollection<TInput>;
     /**
-     * The <i>chunk</i> method breaks the collection into multiple, smaller collections of size <i>chunkSize</i>.
-     * If <i>chunkSize</i> is not divisible with total number of items then the last chunk will contain the remaining items.
+     * The `chunk` method breaks the collection into multiple, smaller collections of size `chunkSize`.
+     * If `chunkSize` is not divisible with total number of items then the last chunk will contain the remaining items.
      * @example
      * ```ts
      * import type { IAsyncCollection } from "@daiso-tech/core";
@@ -711,8 +711,8 @@ export type IAsyncCollection<TInput = unknown> = AsyncIterable<TInput> & {
      */
     chunk(chunkSize: number): IAsyncCollection<IAsyncCollection<TInput>>;
     /**
-     * The <i>chunkWhile</i> method breaks the collection into multiple, smaller collections based on the evaluation of <i>predicateFn</i>.
-     * The chunk variable passed to the <i>predicateFn</i> may be used to inspect the previous item.
+     * The `chunkWhile` method breaks the collection into multiple, smaller collections based on the evaluation of `predicateFn`.
+     * The chunk variable passed to the `predicateFn` may be used to inspect the previous item.
      * @example
      * ```ts
      * import type { IAsyncCollection } from "@daiso-tech/core";
@@ -732,7 +732,7 @@ export type IAsyncCollection<TInput = unknown> = AsyncIterable<TInput> & {
      */
     chunkWhile(predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>): IAsyncCollection<IAsyncCollection<TInput>>;
     /**
-     * The <i>split</i> method breaks a collection evenly into <i>chunkAmount</i> of chunks.
+     * The `split` method breaks a collection evenly into `chunkAmount` of chunks.
      * @example
      * ```ts
      * import type { IAsyncCollection } from "@daiso-tech/core";
@@ -777,7 +777,7 @@ export type IAsyncCollection<TInput = unknown> = AsyncIterable<TInput> & {
      */
     split(chunkAmount: number): IAsyncCollection<IAsyncCollection<TInput>>;
     /**
-     * The <i>partition</i> method is used to separate items that pass <i>predicateFn</i> from those that do not.
+     * The `partition` method is used to separate items that pass `predicateFn` from those that do not.
      * @example
      * ```ts
      * import type { IAsyncCollection } from "@daiso-tech/core";
@@ -795,7 +795,7 @@ export type IAsyncCollection<TInput = unknown> = AsyncIterable<TInput> & {
      */
     partition(predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>): IAsyncCollection<IAsyncCollection<TInput>>;
     /**
-     * The <i>sliding</i> method returns a new collection of chunks representing a "sliding window" view of the items in the collection.
+     * The `sliding` method returns a new collection of chunks representing a "sliding window" view of the items in the collection.
      * @example
      * ```ts
      * import type { IAsyncCollection } from "@daiso-tech/core";
@@ -813,7 +813,7 @@ export type IAsyncCollection<TInput = unknown> = AsyncIterable<TInput> & {
      */
     sliding(chunkSize: number, step?: number): IAsyncCollection<IAsyncCollection<TInput>>;
     /**
-     * The <i>groupBy</i> method groups the collection's items by <i> selectFn </i>.
+     * The `groupBy` method groups the collection's items by ` selectFn `.
      * By default the equality check occurs on the item.
      * @example
      * ```ts
@@ -868,7 +868,7 @@ export type IAsyncCollection<TInput = unknown> = AsyncIterable<TInput> & {
      */
     groupBy<TOutput = TInput>(selectFn?: AsyncMap<TInput, IAsyncCollection<TInput>, TOutput>): IAsyncCollection<[TOutput, IAsyncCollection<TInput>]>;
     /**
-     * The <i>countBy</i> method counts the occurrences of values in the collection by <i> selectFn </i>.
+     * The `countBy` method counts the occurrences of values in the collection by ` selectFn `.
      * By default the equality check occurs on the item.
      * @example
      * ```ts
@@ -907,7 +907,7 @@ export type IAsyncCollection<TInput = unknown> = AsyncIterable<TInput> & {
      */
     countBy<TOutput = TInput>(selectFn?: AsyncMap<TInput, IAsyncCollection<TInput>, TOutput>): IAsyncCollection<[TOutput, number]>;
     /**
-     * The <i>unique</i> method removes all duplicate values from the collection by <i> selectFn </i>.
+     * The `unique` method removes all duplicate values from the collection by ` selectFn `.
      * By default the equality check occurs on the item.
      * @example
      * ```ts
@@ -953,7 +953,7 @@ export type IAsyncCollection<TInput = unknown> = AsyncIterable<TInput> & {
      */
     unique<TOutput = TInput>(selectFn?: AsyncMap<TInput, IAsyncCollection<TInput>, TOutput>): IAsyncCollection<TInput>;
     /**
-     * The <i>difference</i> method will return the values in the original collection that are not present in <i>iterable</i>.
+     * The `difference` method will return the values in the original collection that are not present in `iterable`.
      * By default the equality check occurs on the item.
      * @example
      * ```ts
@@ -1005,7 +1005,7 @@ export type IAsyncCollection<TInput = unknown> = AsyncIterable<TInput> & {
      */
     difference<TOutput = TInput>(iterable: AsyncIterableValue<TInput>, selectFn?: AsyncMap<TInput, IAsyncCollection<TInput>, TOutput>): IAsyncCollection<TInput>;
     /**
-     * The <i>repeat</i> method will repeat the original collection <i>amount</i> times.
+     * The `repeat` method will repeat the original collection `amount` times.
      * @example
      * ```ts
      * import type { IAsyncCollection } from "@daiso-tech/core";
@@ -1022,7 +1022,7 @@ export type IAsyncCollection<TInput = unknown> = AsyncIterable<TInput> & {
      */
     repeat(amount: number): IAsyncCollection<TInput>;
     /**
-     * The <i>padStart</i> method pads this collection with <i>fillItems</i> until the resulting collection size reaches <i>maxLength</i>.
+     * The `padStart` method pads this collection with `fillItems` until the resulting collection size reaches `maxLength`.
      * The padding is applied from the start of this collection.
      * @example
      * ```ts
@@ -1070,7 +1070,7 @@ export type IAsyncCollection<TInput = unknown> = AsyncIterable<TInput> & {
      */
     padStart<TExtended = TInput>(maxLength: number, fillItems: AsyncIterableValue<TExtended>): IAsyncCollection<TInput | TExtended>;
     /**
-     * The <i>padEnd</i> method pads this collection with <i>fillItems</i> until the resulting collection size reaches <i>maxLength</i>.
+     * The `padEnd` method pads this collection with `fillItems` until the resulting collection size reaches `maxLength`.
      * The padding is applied from the end of this collection.
      * @example
      * ```ts
@@ -1118,8 +1118,8 @@ export type IAsyncCollection<TInput = unknown> = AsyncIterable<TInput> & {
      */
     padEnd<TExtended = TInput>(maxLength: number, fillItems: AsyncIterableValue<TExtended>): IAsyncCollection<TInput | TExtended>;
     /**
-     * The <i>slice</i> method creates porition of the original collection selected from <i>start</i> and <i>end</i>
-     * where <i>start</i> and <i>end</i> (end not included) represent the index of items in the collection.
+     * The `slice` method creates porition of the original collection selected from `start` and `end`
+     * where `start` and `end` (end not included) represent the index of items in the collection.
      * @example
      * ```ts
      * import type { IAsyncCollection } from "@daiso-tech/core";
@@ -1201,7 +1201,7 @@ export type IAsyncCollection<TInput = unknown> = AsyncIterable<TInput> & {
      */
     slice(start?: number, end?: number): IAsyncCollection<TInput>;
     /**
-     * The <i>prepend</i> method adds <i>iterable</i> to the beginning of the collection.
+     * The `prepend` method adds `iterable` to the beginning of the collection.
      * @example
      * ```ts
      * import type { IAsyncCollection } from "@daiso-tech/core";
@@ -1218,7 +1218,7 @@ export type IAsyncCollection<TInput = unknown> = AsyncIterable<TInput> & {
      */
     prepend<TExtended = TInput>(iterable: AsyncIterableValue<TInput | TExtended>): IAsyncCollection<TInput | TExtended>;
     /**
-     * The <i>append</i> method adds <i>iterable</i> to the end of the collection.
+     * The `append` method adds `iterable` to the end of the collection.
      * @example
      * ```ts
      * import type { IAsyncCollection } from "@daiso-tech/core";
@@ -1235,7 +1235,7 @@ export type IAsyncCollection<TInput = unknown> = AsyncIterable<TInput> & {
      */
     append<TExtended = TInput>(iterable: AsyncIterableValue<TInput | TExtended>): IAsyncCollection<TInput | TExtended>;
     /**
-     * The <i>insertBefore</i> method adds <i>iterable</i> before the first item that matches <i>predicateFn</i>.
+     * The `insertBefore` method adds `iterable` before the first item that matches `predicateFn`.
      * @example
      * ```ts
      * import type { IAsyncCollection } from "@daiso-tech/core";
@@ -1252,7 +1252,7 @@ export type IAsyncCollection<TInput = unknown> = AsyncIterable<TInput> & {
      */
     insertBefore<TExtended = TInput>(predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>, iterable: AsyncIterableValue<TInput | TExtended>): IAsyncCollection<TInput | TExtended>;
     /**
-     * The <i>insertAfter</i> method adds <i>iterable</i> after the first item that matches <i>predicateFn</i>.
+     * The `insertAfter` method adds `iterable` after the first item that matches `predicateFn`.
      * @example
      * ```ts
      * import type { IAsyncCollection } from "@daiso-tech/core";
@@ -1269,7 +1269,7 @@ export type IAsyncCollection<TInput = unknown> = AsyncIterable<TInput> & {
      */
     insertAfter<TExtended = TInput>(predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>, iterable: AsyncIterableValue<TInput | TExtended>): IAsyncCollection<TInput | TExtended>;
     /**
-     * The <i>crossJoin</i> method cross joins the collection's values among <i>iterables</i>, returning a Cartesian product with all possible permutations.
+     * The `crossJoin` method cross joins the collection's values among `iterables`, returning a Cartesian product with all possible permutations.
      * @example
      * ```ts
      * import { ICollection } from "@daiso-tech/core";;
@@ -1312,7 +1312,7 @@ export type IAsyncCollection<TInput = unknown> = AsyncIterable<TInput> & {
      */
     crossJoin<TExtended>(iterable: AsyncIterableValue<TExtended>): IAsyncCollection<CrossJoinResult<TInput, TExtended>>;
     /**
-     * The <i>zip</i> method merges together the values of <i>iterable</i> with the values of the collection at their corresponding index.
+     * The `zip` method merges together the values of `iterable` with the values of the collection at their corresponding index.
      * The returned collection has size of the shortest collection.
      * @example
      * ```ts
@@ -1356,7 +1356,7 @@ export type IAsyncCollection<TInput = unknown> = AsyncIterable<TInput> & {
      */
     zip<TExtended>(iterable: AsyncIterableValue<TExtended>): IAsyncCollection<[TInput, TExtended]>;
     /**
-     * The <i>sort</i> method sorts the collection. You can provide a <i>comparator</i> function.
+     * The `sort` method sorts the collection. You can provide a `comparator` function.
      * @example
      * ```ts
      * import type { IAsyncCollection } from "@daiso-tech/core";
@@ -1401,8 +1401,8 @@ export type IAsyncCollection<TInput = unknown> = AsyncIterable<TInput> & {
      */
     sort(comparator?: Comparator<TInput>): IAsyncCollection<TInput>;
     /**
-     * The <i>reverse</i> method will reverse the order of the collection.
-     * The reversing of the collection will be applied in chunks that are the size of <i> chunkSize </i>.
+     * The `reverse` method will reverse the order of the collection.
+     * The reversing of the collection will be applied in chunks that are the size of ` chunkSize `.
      * @example
      * ```ts
      * import type { IAsyncCollection } from "@daiso-tech/core";
@@ -1419,12 +1419,12 @@ export type IAsyncCollection<TInput = unknown> = AsyncIterable<TInput> & {
      */
     reverse(chunkSize?: number): IAsyncCollection<TInput>;
     /**
-     * The <i>shuffle</i> method randomly shuffles the items in the collection. You can provide a custom Math.random function by passing in <i>mathRandom</i>.
+     * The `shuffle` method randomly shuffles the items in the collection. You can provide a custom Math.random function by passing in `mathRandom`.
      */
     shuffle(mathRandom?: () => number): IAsyncCollection<TInput>;
     /**
-     * The <i>first</i> method returns the first item in the collection that passes <i> predicateFn </i>.
-     * By default it will get the first item. If the collection is empty or no items passes <i> predicateFn </i> than null i returned.
+     * The `first` method returns the first item in the collection that passes ` predicateFn `.
+     * By default it will get the first item. If the collection is empty or no items passes ` predicateFn ` than null i returned.
      * @example
      * ```ts
      * import type { IAsyncCollection } from "@daiso-tech/core";
@@ -1464,8 +1464,8 @@ export type IAsyncCollection<TInput = unknown> = AsyncIterable<TInput> & {
      */
     first<TOutput extends TInput>(predicateFn?: AsyncPredicate<TInput, IAsyncCollection<TInput>, TOutput>): LazyPromise<TOutput | null>;
     /**
-     * The <i>firstOr</i> method returns the first item in the collection that passes <i> predicateFn </i>
-     * By default it will get the first item. If the collection is empty or no items passes <i> predicateFn </i> than <i> defaultValue </i>.
+     * The `firstOr` method returns the first item in the collection that passes ` predicateFn `
+     * By default it will get the first item. If the collection is empty or no items passes ` predicateFn ` than ` defaultValue `.
      * @example
      * ```ts
      * import type { IAsyncCollection } from "@daiso-tech/core";
@@ -1516,7 +1516,7 @@ export type IAsyncCollection<TInput = unknown> = AsyncIterable<TInput> & {
      *   // -1
      * }
      * ```
-     * You can pass a <i>{@link LazyPromise}</i> as default value.
+     * You can pass a {@link LazyPromise| `LazyPromise`} as default value.
      * @example
      * ```ts
      * import type { IAsyncCollection, ICache } from "@daiso-tech/core";
@@ -1532,8 +1532,8 @@ export type IAsyncCollection<TInput = unknown> = AsyncIterable<TInput> & {
      */
     firstOr<TOutput extends TInput, TExtended = TInput>(defaultValue: AsyncLazyable<TExtended>, predicateFn?: AsyncPredicate<TInput, IAsyncCollection<TInput>, TOutput>): LazyPromise<TOutput | TExtended>;
     /**
-     * The <i>firstOrFail</i> method returns the first item in the collection that passes <i> predicateFn </i>.
-     * By default it will get the first item. If the collection is empty or no items passes <i> predicateFn </i> than error is thrown.
+     * The `firstOrFail` method returns the first item in the collection that passes ` predicateFn `.
+     * By default it will get the first item. If the collection is empty or no items passes ` predicateFn ` than error is thrown.
      * @throws {ItemNotFoundCollectionError} {@link ItemNotFoundCollectionError}
      * @example
      * ```ts
@@ -1574,8 +1574,8 @@ export type IAsyncCollection<TInput = unknown> = AsyncIterable<TInput> & {
      */
     firstOrFail<TOutput extends TInput>(predicateFn?: AsyncPredicate<TInput, IAsyncCollection<TInput>, TOutput>): LazyPromise<TOutput>;
     /**
-     * The <i>last</i> method returns the last item in the collection that passes <i> predicateFn </i>.
-     * By default it will get the last item. If the collection is empty or no items passes <i> predicateFn </i> than null i returned.
+     * The `last` method returns the last item in the collection that passes ` predicateFn `.
+     * By default it will get the last item. If the collection is empty or no items passes ` predicateFn ` than null i returned.
      * @example
      * ```ts
      * import type { IAsyncCollection } from "@daiso-tech/core";
@@ -1615,8 +1615,8 @@ export type IAsyncCollection<TInput = unknown> = AsyncIterable<TInput> & {
      */
     last<TOutput extends TInput>(predicateFn?: AsyncPredicate<TInput, IAsyncCollection<TInput>, TOutput>): LazyPromise<TOutput | null>;
     /**
-     * The <i>lastOr</i> method returns the last item in the collection that passes <i> predicateFn </i>.
-     * By default it will get the last item. If the collection is empty or no items passes <i> predicateFn </i> than <i> defaultValue </i>.
+     * The `lastOr` method returns the last item in the collection that passes ` predicateFn `.
+     * By default it will get the last item. If the collection is empty or no items passes ` predicateFn ` than ` defaultValue `.
      * @example
      * ```ts
      * import type { IAsyncCollection } from "@daiso-tech/core";
@@ -1667,7 +1667,7 @@ export type IAsyncCollection<TInput = unknown> = AsyncIterable<TInput> & {
      *   // -1
      * }
      * ```
-     * You can pass a <i>{@link LazyPromise}</i> as default value.
+     * You can pass a {@link LazyPromise| `LazyPromise`} as default value.
      * @example
      * ```ts
      * import type { IAsyncCollection, ICache } from "@daiso-tech/core";
@@ -1683,8 +1683,8 @@ export type IAsyncCollection<TInput = unknown> = AsyncIterable<TInput> & {
      */
     lastOr<TOutput extends TInput, TExtended = TInput>(defaultValue: AsyncLazyable<TExtended>, predicateFn?: AsyncPredicate<TInput, IAsyncCollection<TInput>, TOutput>): LazyPromise<TOutput | TExtended>;
     /**
-     * The <i>lastOrFail</i> method returns the last item in the collection that passes <i> predicateFn </i>.
-     * By default it will get the last item. If the collection is empty or no items passes <i> predicateFn </i> than error is thrown.
+     * The `lastOrFail` method returns the last item in the collection that passes ` predicateFn `.
+     * By default it will get the last item. If the collection is empty or no items passes ` predicateFn ` than error is thrown.
      * @throws {ItemNotFoundCollectionError} {@link ItemNotFoundCollectionError}
      * @example
      * ```ts
@@ -1725,8 +1725,8 @@ export type IAsyncCollection<TInput = unknown> = AsyncIterable<TInput> & {
      */
     lastOrFail<TOutput extends TInput>(predicateFn?: AsyncPredicate<TInput, IAsyncCollection<TInput>, TOutput>): LazyPromise<TOutput>;
     /**
-     * The <i>before</i> method returns the item that comes before the first item that matches <i>predicateFn</i>.
-     * If the <i>predicateFn</i> does not match or matches the first item then null is returned.
+     * The `before` method returns the item that comes before the first item that matches `predicateFn`.
+     * If the `predicateFn` does not match or matches the first item then null is returned.
      * @example
      * ```ts
      * import type { IAsyncCollection } from "@daiso-tech/core";
@@ -1754,8 +1754,8 @@ export type IAsyncCollection<TInput = unknown> = AsyncIterable<TInput> & {
      */
     before(predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>): LazyPromise<TInput | null>;
     /**
-     * The <i>beforeOr</i> method returns the item that comes before the first item that matches <i>predicateFn</i>.
-     * If the collection is empty or the <i>predicateFn</i> does not match or matches the first item then <i>defaultValue</i> is returned.
+     * The `beforeOr` method returns the item that comes before the first item that matches `predicateFn`.
+     * If the collection is empty or the `predicateFn` does not match or matches the first item then `defaultValue` is returned.
      * @example
      * ```ts
      * import type { IAsyncCollection } from "@daiso-tech/core";
@@ -1794,7 +1794,7 @@ export type IAsyncCollection<TInput = unknown> = AsyncIterable<TInput> & {
      *   // -1
      * }
      * ```
-     * You can pass a <i>{@link LazyPromise}</i> as default value.
+     * You can pass a {@link LazyPromise| `LazyPromise`} as default value.
      * @example
      * ```ts
      * import type { IAsyncCollection, ICache } from "@daiso-tech/core";
@@ -1810,8 +1810,8 @@ export type IAsyncCollection<TInput = unknown> = AsyncIterable<TInput> & {
      */
     beforeOr<TExtended = TInput>(defaultValue: AsyncLazyable<TExtended>, predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>): LazyPromise<TInput | TExtended>;
     /**
-     * The <i>beforeOrFail</i> method returns the item that comes before the first item that matches <i>predicateFn</i>.
-     * If the collection is empty or the <i>predicateFn</i> does not match or matches the first item then an error is thrown.
+     * The `beforeOrFail` method returns the item that comes before the first item that matches `predicateFn`.
+     * If the collection is empty or the `predicateFn` does not match or matches the first item then an error is thrown.
      * @throws {ItemNotFoundCollectionError} {@link ItemNotFoundCollectionError}
      * @example
      * ```ts
@@ -1840,8 +1840,8 @@ export type IAsyncCollection<TInput = unknown> = AsyncIterable<TInput> & {
      */
     beforeOrFail(predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>): LazyPromise<TInput>;
     /**
-     * The <i>after</i> method returns the item that comes after the first item that matches <i>predicateFn</i>.
-     * If the collection is empty or the <i>predicateFn</i> does not match or matches the last item then null is returned.
+     * The `after` method returns the item that comes after the first item that matches `predicateFn`.
+     * If the collection is empty or the `predicateFn` does not match or matches the last item then null is returned.
      * @example
      * ```ts
      * import type { IAsyncCollection } from "@daiso-tech/core";
@@ -1869,8 +1869,8 @@ export type IAsyncCollection<TInput = unknown> = AsyncIterable<TInput> & {
      */
     after(predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>): LazyPromise<TInput | null>;
     /**
-     * The <i>afterOr</i> method returns the item that comes after the first item that matches <i>predicateFn</i>.
-     * If the collection is empty or the <i>predicateFn</i> does not match or matches the last item then <i>defaultValue</i> is returned.
+     * The `afterOr` method returns the item that comes after the first item that matches `predicateFn`.
+     * If the collection is empty or the `predicateFn` does not match or matches the last item then `defaultValue` is returned.
      * @example
      * ```ts
      * import type { IAsyncCollection } from "@daiso-tech/core";
@@ -1909,7 +1909,7 @@ export type IAsyncCollection<TInput = unknown> = AsyncIterable<TInput> & {
      *   // -1
      * }
      * ```
-     * You can pass a <i>{@link LazyPromise}</i> as default value.
+     * You can pass a {@link LazyPromise| `LazyPromise`} as default value.
      * @example
      * ```ts
      * import type { IAsyncCollection, ICache } from "@daiso-tech/core";
@@ -1925,8 +1925,8 @@ export type IAsyncCollection<TInput = unknown> = AsyncIterable<TInput> & {
      */
     afterOr<TExtended = TInput>(defaultValue: AsyncLazyable<TExtended>, predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>): LazyPromise<TInput | TExtended>;
     /**
-     * The <i>afterOrFail</i> method returns the item that comes after the first item that matches <i>predicateFn</i>.
-     * If the collection is empty or the <i>predicateFn</i> does not match or matches the last item then an error is thrown.
+     * The `afterOrFail` method returns the item that comes after the first item that matches `predicateFn`.
+     * If the collection is empty or the `predicateFn` does not match or matches the last item then an error is thrown.
      * @throws {ItemNotFoundCollectionError} {@link ItemNotFoundCollectionError}
      * @example
      * ```ts
@@ -1955,7 +1955,7 @@ export type IAsyncCollection<TInput = unknown> = AsyncIterable<TInput> & {
      */
     afterOrFail(predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>): LazyPromise<TInput>;
     /**
-     * The <i>sole</i> method returns the first item in the collection that passes <i>predicateFn</i>, but only if <i>predicateFn</i> matches exactly one item.
+     * The `sole` method returns the first item in the collection that passes `predicateFn`, but only if `predicateFn` matches exactly one item.
      * If no items matches or multiple items are found an error will be thrown.
      * @throws {ItemNotFoundCollectionError} {@link ItemNotFoundCollectionError}
      * @throws {MultipleItemsFoundCollectionError} {@link MultipleItemsFoundCollectionError}
@@ -1998,7 +1998,7 @@ export type IAsyncCollection<TInput = unknown> = AsyncIterable<TInput> & {
      */
     sole<TOutput extends TInput>(predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>, TOutput>): LazyPromise<TOutput>;
     /**
-     * The <i>nth</i> method creates a new collection consisting of every n-th item.
+     * The `nth` method creates a new collection consisting of every n-th item.
      * @example
      * ```ts
      * import type { IAsyncCollection } from "@daiso-tech/core";
@@ -2014,7 +2014,7 @@ export type IAsyncCollection<TInput = unknown> = AsyncIterable<TInput> & {
      */
     nth(step: number): IAsyncCollection<TInput>;
     /**
-     * The <i>count</i> method returns the total number of items in the collection that passes <i>predicateFn</i>.
+     * The `count` method returns the total number of items in the collection that passes `predicateFn`.
      * @example
      * ```ts
      * import type { IAsyncCollection } from "@daiso-tech/core";
@@ -2030,19 +2030,19 @@ export type IAsyncCollection<TInput = unknown> = AsyncIterable<TInput> & {
      */
     count(predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>): LazyPromise<number>;
     /**
-     * The <i>size</i> returns the size of the collection.
+     * The `size` returns the size of the collection.
      */
     size(): LazyPromise<number>;
     /**
-     * The <i>isEmpty</i> returns true if the collection is empty.
+     * The `isEmpty` returns true if the collection is empty.
      */
     isEmpty(): LazyPromise<boolean>;
     /**
-     * The <i>isNotEmpty</i> returns true if the collection is not empty.
+     * The `isNotEmpty` returns true if the collection is not empty.
      */
     isNotEmpty(): LazyPromise<boolean>;
     /**
-     * The <i>searchFirst</i> return the index of the first item that matches <i>predicateFn</i>.
+     * The `searchFirst` return the index of the first item that matches `predicateFn`.
      * @example
      * ```ts
      * import type { IAsyncCollection } from "@daiso-tech/core";
@@ -2058,7 +2058,7 @@ export type IAsyncCollection<TInput = unknown> = AsyncIterable<TInput> & {
      */
     searchFirst(predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>): LazyPromise<number>;
     /**
-     * The <i>searchLast</i> return the index of the last item that matches <i>predicateFn</i>.
+     * The `searchLast` return the index of the last item that matches `predicateFn`.
      * @example
      * ```ts
      * import type { IAsyncCollection } from "@daiso-tech/core";
@@ -2074,110 +2074,21 @@ export type IAsyncCollection<TInput = unknown> = AsyncIterable<TInput> & {
      */
     searchLast(predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>): LazyPromise<number>;
     /**
-     * The <i>forEach</i> method iterates through all items in the collection.
+     * The `forEach` method iterates through all items in the collection.
      */
     forEach(callback: AsyncForEach<TInput, IAsyncCollection<TInput>>): LazyPromise<void>;
     /**
-     * The <i>delay</i> method will add delay between each iteration.
-     * This method is especially useful for situations where you may be interacting with external APIs that rate limit incoming requests:
-     * @example
-     * ```ts
-     * import type { IAsyncCollection } from "@daiso-tech/core";
-     *
-     * // Asume the inputed collection is empty.
-     * class MyIterable implements Iterable<number> {
-     *   async *[Symbol.asyncIterator]() {
-     *     for (let i = 0; i < 10; i++) {
-     *       yield i;
-     *     }
-     *   }
-     * }
-     *
-     * // Asume the inputed collection is empty.
-     * async function main(collection: IAsyncCollection<number>): Promise<void> {
-     *   const myIterable = new MyIterable();
-     *   await collection
-     *     .append(myIterable)
-     *     .delay(1000)
-     *     .forEach(user => console.log(user))
-     * }
-     * ```
-     */
-    delay(time: TimeSpan): IAsyncCollection<TInput>;
-    /**
-     * @experimental
-     * The <I>takeUntilAbort</i> method returns a new collection that will iterate values until aborted by passing in <i>{@link abortSignal | AbortSignal}</i>.
-     * After when aborted, the collection will stop iterating:
-     * @example
-     * ```ts
-     * import type { IAsyncCollection } from "@daiso-tech/core";
-     *
-     * class InfiniteIterable implements Iterable<number> {
-     *   async *[Symbol.asyncIterator]() {
-     *     let index = 0;
-     *     while(true) {
-     *       index++;
-     *       yield index;
-     *     }
-     *   }
-     * }
-     *
-     * // Asume the inputed collection is empty.
-     * async function main(collection: IAsyncCollection<number>): Promise<void> {
-     *   const abortController = new AbortController();
-     *   setTimeout(() => {
-     *     abortController.abort("My abort error");
-     *   }, 1000)
-     *   const infiniteIterable = new InfiniteIterable();
-     *   await collection
-     *     .append(infiniteIterable);
-     *     .takeUntilAbort(abortController)
-     *     .forEach(nbr => console.log(nbr))
-     * }
-     * ```
-     */
-    takeUntilAbort(abortSignal: AbortSignal, shouldThrow?: boolean): IAsyncCollection<TInput>;
-    /**
-     * @experimental
-     * The <I>takeUntilTimeout</i> method returns a new collection that will iterate values until the specified time.
-     * After that time, the collection will stop iterating:
-     * @example
-     * ```ts
-     * import type { IAsyncCollection } from "@daiso-tech/core";
-     *
-     * class InfiniteIterable implements AsyncIterable<number> {
-     *   async *[Symbol.asyncIterator]() {
-     *     let index = 0;
-     *     while(true) {
-     *       index++;
-     *       yield index;
-     *     }
-     *   }
-     * }
-     *
-     * // Asume the inputed collection is empty.
-     * async function main(collection: IAsyncCollection<number>): Promise<void> {
-     *   const infiniteIterable = new InfiniteIterable();
-     *   await collection
-     *     .append(infiniteIterable)
-     *     .takeUntilTimeout(1000)
-     *     .forEach(nbr => console.log(nbr))
-     * }
-     * ```
-     */
-    takeUntilTimeout(time: TimeSpan, shouldThrow?: boolean): IAsyncCollection<TInput>;
-    /**
-     * The <i>toArray</i> method converts the collection to a new <i>{@link Array}</i>.
+     * The `toArray` method converts the collection to a new {@link Array | `Array`}.
      */
     toArray(): LazyPromise<TInput[]>;
     /**
-     * The <i>toRecord</i> method converts the collection to a new <i>{@link Record}</i>.
+     * The `toRecord` method converts the collection to a new {@link Record | `Record`}.
      * An error will be thrown if item is not a tuple of size 2 where the first element is a string or a number.
      * @throws {TypeCollectionError} {@link TypeCollectionError}
      */
     toRecord(): LazyPromise<EnsureRecord<TInput>>;
     /**
-     * The <i>toMap</i> method converts the collection to a new <i>{@link AsyncMap}</i>.
+     * The `toMap` method converts the collection to a new {@link Map | `Map`}.
      * An error will be thrown if item is not a tuple of size 2.
      * @throws {TypeCollectionError} {@link TypeCollectionError}
      */