@daiso-tech/core 0.1.4 → 0.2.0

package/dist/esm/collection/async-iterable-collection/async-iterable-collection.js

@@ -1,8 +1,8 @@
-import { CollectionError, ItemNotFoundError, MultipleItemsFoundError, IndexOverflowError, UnexpectedCollectionError, } from "../../contracts/collection/_module";
+import { CollectionError, ItemNotFoundCollectionError, MultipleItemsFoundCollectionError, UnexpectedCollectionError, TypeCollectionError, EmptyCollectionError, } from "../../contracts/collection/_module";
 import { AsyncCrossJoinIterable, AsyncSlidingIteralbe, AsyncShuffleIterable, AsyncEntriesIterable, AsyncFilterIterable, AsyncChunkIterable, AsyncChunkWhileIterable, AsyncCollapseIterable, AsyncCountByIterable, AsyncFlatMapIterable, AsyncGroupByIterable, AsyncInsertAfterIterable, AsyncInsertBeforeIterable, AsyncMapIterable, AsyncMergeIterable, AsyncPadEndIterable, AsyncPadStartIterable, AsyncPartionIterable, AsyncSkipIterable, AsyncSkipUntilIterable, AsyncSortIterable, AsyncSplitIterable, AsyncTakeIterable, AsyncTakeUntilIterable, AsyncTapIterable, AsyncUniqueIterable, AsyncUpdateIterable, AsyncWhenIterable, AsyncZipIterable, AsyncReverseIterable, AsyncSliceIterable, AsyncRepeatIterable, AsyncAbortIterable, AsyncDelayIterable, AsyncTimeoutIterable, } from "../../collection/async-iterable-collection/_shared/_module";
+import { simplifyAsyncLazyable } from "../../_shared/utilities";
 export class AsyncIterableCollection {
     iterable;
-    static THROW_ON_NUMBER_LIMIT = false;
     static DEFAULT_CHUNK_SIZE = 1024;
     static makeCollection = (iterable) => {
         return new AsyncIterableCollection(iterable);
@@ -16,92 +16,91 @@ export class AsyncIterableCollection {
     toIterator() {
         return this[Symbol.asyncIterator]();
     }
-    entries(throwOnIndexOverflow = AsyncIterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return new AsyncIterableCollection(new AsyncEntriesIterable(this, throwOnIndexOverflow));
+    entries() {
+        return new AsyncIterableCollection(new AsyncEntriesIterable(this));
     }
-    keys(throwOnIndexOverflow = AsyncIterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return this.entries(throwOnIndexOverflow).map(([key]) => key);
+    keys() {
+        return this.entries().map(([key]) => key);
     }
     values() {
         return this.entries().map(([_key, value]) => value);
     }
-    filter(filter, throwOnIndexOverflow = AsyncIterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return new AsyncIterableCollection(new AsyncFilterIterable(this, filter, throwOnIndexOverflow));
+    filter(predicateFn) {
+        return new AsyncIterableCollection(new AsyncFilterIterable(this, predicateFn));
     }
-    reject(filter, throwOnIndexOverflow = AsyncIterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return this.filter(async (...arguments_) => !(await filter(...arguments_)), throwOnIndexOverflow);
+    reject(predicateFn) {
+        return this.filter(async (...arguments_) => !(await predicateFn(...arguments_)));
     }
-    map(mapFn, throwOnIndexOverflow = AsyncIterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return new AsyncIterableCollection(new AsyncMapIterable(this, mapFn, throwOnIndexOverflow));
+    map(mapFn) {
+        return new AsyncIterableCollection(new AsyncMapIterable(this, mapFn));
     }
-    async reduce(settings) {
-        const { reduceFn: reduce, initialValue, throwOnIndexOverflow, } = settings;
+    async reduce(reduceFn, initialValue) {
         if (initialValue === undefined && (await this.isEmpty())) {
-            throw new TypeError("Reduce of empty array must be inputed a initial value");
+            throw new TypeCollectionError("Reduce of empty array must be inputed a initial value");
         }
         if (initialValue !== undefined) {
             let output = initialValue;
             for await (const [index, item] of this.entries()) {
-                output = await reduce(output, item, index, this);
+                output = await reduceFn(output, item, index, this);
             }
             return output;
         }
         let output = (await this.firstOrFail()), index = 0, isFirstIteration = true;
         for await (const item of this) {
             if (!isFirstIteration) {
-                if (throwOnIndexOverflow && index === Number.MAX_SAFE_INTEGER) {
-                    throw new IndexOverflowError("Index has overflowed");
-                }
-                output = await reduce(output, item, index, this);
+                output = await reduceFn(output, item, index, this);
             }
             isFirstIteration = false;
             index++;
         }
         return output;
     }
-    async join(settings) {
-        return this.reduce({
-            reduceFn(str, item) {
-                if (typeof item !== "string") {
-                    throw new TypeError("Item type is invalid must be string");
-                }
-                const separator = settings?.seperator ?? ",";
-                return str + separator + item;
-            },
-            throwOnIndexOverflow: settings?.throwOnIndexOverflow ??
-                AsyncIterableCollection.THROW_ON_NUMBER_LIMIT,
-        });
+    async join(separator = ",") {
+        let str = null;
+        for await (const item of this) {
+            if (typeof item !== "string") {
+                throw new TypeCollectionError("Item type is invalid must be string");
+            }
+            if (str === null) {
+                str = item;
+            }
+            else {
+                str = str + separator + item;
+            }
+        }
+        return str;
     }
     collapse() {
         return new AsyncIterableCollection(new AsyncCollapseIterable(this));
     }
-    flatMap(mapFn, throwOnIndexOverflow = AsyncIterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return new AsyncIterableCollection(new AsyncFlatMapIterable(this, mapFn, throwOnIndexOverflow));
+    flatMap(mapFn) {
+        return new AsyncIterableCollection(new AsyncFlatMapIterable(this, mapFn));
     }
-    update(filter, mapFn, throwOnIndexOverflow = AsyncIterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return new AsyncIterableCollection(new AsyncUpdateIterable(this, filter, mapFn, throwOnIndexOverflow));
+    change(predicateFn, mapFn) {
+        return new AsyncIterableCollection(new AsyncUpdateIterable(this, predicateFn, mapFn));
     }
-    page(settings) {
-        const { page, pageSize, throwOnIndexOverflow } = settings;
+    page(page, pageSize) {
         if (page < 0) {
-            return this.skip(page * pageSize, throwOnIndexOverflow).take(pageSize, throwOnIndexOverflow);
+            return this.skip(page * pageSize).take(pageSize);
         }
-        return this.skip((page - 1) * pageSize, throwOnIndexOverflow).take(page * pageSize, throwOnIndexOverflow);
+        return this.skip((page - 1) * pageSize).take(pageSize);
     }
     async sum() {
         try {
+            if (await this.isEmpty()) {
+                throw new EmptyCollectionError("Collection is empty therby operation cannot be performed");
+            }
             let sum = 0;
             for await (const item of this) {
                 if (typeof item !== "number") {
-                    throw new TypeError("Item type is invalid must be number");
+                    throw new TypeCollectionError("Item type is invalid must be number");
                 }
                 sum += item;
             }
             return sum;
         }
         catch (error) {
-            if (error instanceof CollectionError ||
-                error instanceof TypeError) {
+            if (error instanceof CollectionError) {
                 throw error;
             }
             throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
@@ -109,10 +108,13 @@ export class AsyncIterableCollection {
     }
     async average() {
         try {
+            if (await this.isEmpty()) {
+                throw new EmptyCollectionError("Collection is empty therby operation cannot be performed");
+            }
             let size = 0, sum = 0;
             for await (const item of this) {
                 if (typeof item !== "number") {
-                    throw new TypeError("Item type is invalid must be number");
+                    throw new TypeCollectionError("Item type is invalid must be number");
                 }
                 size++;
                 sum += item;
@@ -120,33 +122,32 @@ export class AsyncIterableCollection {
             return (sum / size);
         }
         catch (error) {
-            if (error instanceof CollectionError ||
-                error instanceof TypeError) {
+            if (error instanceof CollectionError) {
                 throw error;
             }
             throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
         }
     }
-    async median(throwOnIndexOverflow) {
+    async median() {
         if (await this.isEmpty()) {
-            return 0;
+            throw new EmptyCollectionError("Collection is empty therby operation cannot be performed");
         }
-        const size = await this.size(throwOnIndexOverflow);
+        const size = await this.size();
         if (size === 0) {
             return 0;
         }
         const isEven = size % 2 === 0, items = await this.map((item) => {
             if (typeof item !== "number") {
-                throw new TypeError("Item type is invalid must be number");
+                throw new TypeCollectionError("Item type is invalid must be number");
             }
             return item;
-        }, throwOnIndexOverflow)
+        })
             .filter((_item, index) => {
             if (isEven) {
                 return index === size / 2 || index === size / 2 - 1;
             }
             return index === Math.floor(size / 2);
-        }, throwOnIndexOverflow)
+        })
             .toArray();
         if (isEven) {
             const [a, b] = items;
@@ -166,10 +167,13 @@ export class AsyncIterableCollection {
     }
     async min() {
         try {
+            if (await this.isEmpty()) {
+                throw new EmptyCollectionError("Collection is empty therby operation cannot be performed");
+            }
             let min = 0;
             for await (const item of this) {
                 if (typeof item !== "number") {
-                    throw new TypeError("Item type is invalid must be number");
+                    throw new TypeCollectionError("Item type is invalid must be number");
                 }
                 if (min === 0) {
                     min = item;
@@ -181,8 +185,7 @@ export class AsyncIterableCollection {
             return min;
         }
         catch (error) {
-            if (error instanceof CollectionError ||
-                error instanceof TypeError) {
+            if (error instanceof CollectionError) {
                 throw error;
             }
             throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
@@ -190,10 +193,13 @@ export class AsyncIterableCollection {
     }
     async max() {
         try {
+            if (await this.isEmpty()) {
+                throw new EmptyCollectionError("Collection is empty therby operation cannot be performed");
+            }
             let max = 0;
             for await (const item of this) {
                 if (typeof item !== "number") {
-                    throw new TypeError("Item type is invalid must be number");
+                    throw new TypeCollectionError("Item type is invalid must be number");
                 }
                 if (max === 0) {
                     max = item;
@@ -205,24 +211,20 @@ export class AsyncIterableCollection {
             return max;
         }
         catch (error) {
-            if (error instanceof CollectionError ||
-                error instanceof TypeError) {
+            if (error instanceof CollectionError) {
                 throw error;
             }
             throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
         }
     }
-    async percentage(filter, throwOnIndexOverflow = AsyncIterableCollection.THROW_ON_NUMBER_LIMIT) {
+    async percentage(predicateFn) {
         try {
             if (await this.isEmpty()) {
-                return 0;
+                throw new EmptyCollectionError("Collection is empty therby operation cannot be performed");
             }
             let part = 0, total = 0;
             for await (const item of this) {
-                if (throwOnIndexOverflow && total === Number.MAX_SAFE_INTEGER) {
-                    throw new IndexOverflowError("The total amount has overflowed");
-                }
-                if (await filter(item, total, this)) {
+                if (await predicateFn(item, total, this)) {
                     part++;
                 }
                 total++;
@@ -230,35 +232,33 @@ export class AsyncIterableCollection {
             return (part / total) * 100;
         }
         catch (error) {
-            if (error instanceof CollectionError ||
-                error instanceof TypeError) {
+            if (error instanceof CollectionError) {
                 throw error;
             }
             throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
         }
     }
-    async some(filter, throwOnIndexOverflow = AsyncIterableCollection.THROW_ON_NUMBER_LIMIT) {
+    async some(predicateFn) {
         try {
-            for await (const [index, item] of this.entries(throwOnIndexOverflow)) {
-                if (await filter(item, index, this)) {
+            for await (const [index, item] of this.entries()) {
+                if (await predicateFn(item, index, this)) {
                     return true;
                 }
             }
             return false;
         }
         catch (error) {
-            if (error instanceof CollectionError ||
-                error instanceof TypeError) {
+            if (error instanceof CollectionError) {
                 throw error;
             }
             throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
         }
     }
-    async every(filter, throwOnIndexOverflow = AsyncIterableCollection.THROW_ON_NUMBER_LIMIT) {
+    async every(predicateFn) {
         try {
             let isTrue = true;
-            for await (const [index, item] of this.entries(throwOnIndexOverflow)) {
-                isTrue &&= await filter(item, index, this);
+            for await (const [index, item] of this.entries()) {
+                isTrue &&= await predicateFn(item, index, this);
                 if (!isTrue) {
                     break;
                 }
@@ -266,30 +266,29 @@ export class AsyncIterableCollection {
             return isTrue;
         }
         catch (error) {
-            if (error instanceof CollectionError ||
-                error instanceof TypeError) {
+            if (error instanceof CollectionError) {
                 throw error;
             }
             throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
         }
     }
-    take(limit, throwOnIndexOverflow = AsyncIterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return new AsyncIterableCollection(new AsyncTakeIterable(this, limit, throwOnIndexOverflow));
+    take(limit) {
+        return new AsyncIterableCollection(new AsyncTakeIterable(this, limit));
     }
-    takeUntil(filter, throwOnIndexOverflow = AsyncIterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return new AsyncIterableCollection(new AsyncTakeUntilIterable(this, filter, throwOnIndexOverflow));
+    takeUntil(predicateFn) {
+        return new AsyncIterableCollection(new AsyncTakeUntilIterable(this, predicateFn));
     }
-    takeWhile(filter, throwOnIndexOverflow = AsyncIterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return this.takeUntil(async (...arguments_) => !(await filter(...arguments_)), throwOnIndexOverflow);
+    takeWhile(predicateFn) {
+        return this.takeUntil(async (...arguments_) => !(await predicateFn(...arguments_)));
     }
-    skip(offset, throwOnIndexOverflow = AsyncIterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return new AsyncIterableCollection(new AsyncSkipIterable(this, offset, throwOnIndexOverflow));
+    skip(offset) {
+        return new AsyncIterableCollection(new AsyncSkipIterable(this, offset));
     }
-    skipUntil(filter, throwOnIndexOverflow = AsyncIterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return new AsyncIterableCollection(new AsyncSkipUntilIterable(this, filter, throwOnIndexOverflow));
+    skipUntil(predicateFn) {
+        return new AsyncIterableCollection(new AsyncSkipUntilIterable(this, predicateFn));
     }
-    skipWhile(filter, throwOnIndexOverflow = AsyncIterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return this.skipUntil(async (...arguments_) => !(await filter(...arguments_)), throwOnIndexOverflow);
+    skipWhile(predicateFn) {
+        return this.skipUntil(async (...arguments_) => !(await predicateFn(...arguments_)));
     }
     when(condition, callback) {
         return new AsyncIterableCollection(new AsyncWhenIterable(this, () => condition, callback));
@@ -308,8 +307,7 @@ export class AsyncIterableCollection {
             return await callback(this);
         }
         catch (error) {
-            if (error instanceof CollectionError ||
-                error instanceof TypeError) {
+            if (error instanceof CollectionError) {
                 throw error;
             }
             throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
@@ -321,30 +319,26 @@ export class AsyncIterableCollection {
     chunk(chunkSize) {
         return new AsyncIterableCollection(new AsyncChunkIterable(this, chunkSize, AsyncIterableCollection.makeCollection));
     }
-    chunkWhile(filter, throwOnIndexOverflow = AsyncIterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return new AsyncIterableCollection(new AsyncChunkWhileIterable(this, filter, throwOnIndexOverflow, AsyncIterableCollection.makeCollection));
+    chunkWhile(predicateFn) {
+        return new AsyncIterableCollection(new AsyncChunkWhileIterable(this, predicateFn, AsyncIterableCollection.makeCollection));
     }
-    split(chunkAmount, throwOnIndexOverflow = AsyncIterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return new AsyncIterableCollection(new AsyncSplitIterable(this, chunkAmount, throwOnIndexOverflow, AsyncIterableCollection.makeCollection));
+    split(chunkAmount) {
+        return new AsyncIterableCollection(new AsyncSplitIterable(this, chunkAmount, AsyncIterableCollection.makeCollection));
     }
-    partition(filter, throwOnIndexOverflow = AsyncIterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return new AsyncIterableCollection(new AsyncPartionIterable(this, filter, throwOnIndexOverflow, AsyncIterableCollection.makeCollection));
+    partition(predicateFn) {
+        return new AsyncIterableCollection(new AsyncPartionIterable(this, predicateFn, AsyncIterableCollection.makeCollection));
     }
-    sliding(settings) {
-        const { chunkSize, step = chunkSize - 1, throwOnIndexOverflow = AsyncIterableCollection.THROW_ON_NUMBER_LIMIT, } = settings;
-        return new AsyncIterableCollection(new AsyncSlidingIteralbe(this, chunkSize, step, throwOnIndexOverflow));
+    sliding(chunkSize, step = chunkSize - 1) {
+        return new AsyncIterableCollection(new AsyncSlidingIteralbe(this, chunkSize, step));
     }
-    groupBy(settings) {
-        return new AsyncIterableCollection(new AsyncGroupByIterable(this, settings?.selectFn, settings?.throwOnIndexOverflow ??
-            AsyncIterableCollection.THROW_ON_NUMBER_LIMIT, AsyncIterableCollection.makeCollection));
+    groupBy(selectFn) {
+        return new AsyncIterableCollection(new AsyncGroupByIterable(this, selectFn, AsyncIterableCollection.makeCollection));
     }
-    countBy(settings) {
-        return new AsyncIterableCollection(new AsyncCountByIterable(this, settings?.selectFn, settings?.throwOnIndexOverflow ??
-            AsyncIterableCollection.THROW_ON_NUMBER_LIMIT));
+    countBy(selectFn) {
+        return new AsyncIterableCollection(new AsyncCountByIterable(this, selectFn));
     }
-    unique(settings) {
-        return new AsyncIterableCollection(new AsyncUniqueIterable(this, settings?.selectFn, settings?.throwOnIndexOverflow ??
-            AsyncIterableCollection.THROW_ON_NUMBER_LIMIT));
+    unique(selectFn) {
+        return new AsyncIterableCollection(new AsyncUniqueIterable(this, selectFn));
     }
     difference(iterable, selectFn = (item) => item) {
         const differenceCollection = new AsyncIterableCollection(iterable);
@@ -364,9 +358,8 @@ export class AsyncIterableCollection {
     padEnd(maxLength, fillItems) {
         return new AsyncIterableCollection(new AsyncPadEndIterable(this, maxLength, fillItems, AsyncIterableCollection.makeCollection));
     }
-    slice(settings) {
-        return new AsyncIterableCollection(new AsyncSliceIterable(this, settings?.start, settings?.end, settings?.throwOnIndexOverflow ??
-            AsyncIterableCollection.THROW_ON_NUMBER_LIMIT));
+    slice(start, end) {
+        return new AsyncIterableCollection(new AsyncSliceIterable(this, start, end));
     }
     prepend(iterable) {
         return new AsyncIterableCollection(new AsyncMergeIterable(iterable, this));
@@ -374,14 +367,14 @@ export class AsyncIterableCollection {
     append(iterable) {
         return new AsyncIterableCollection(new AsyncMergeIterable(this, iterable));
     }
-    insertBefore(filter, iterable, throwOnIndexOverflow = AsyncIterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return new AsyncIterableCollection(new AsyncInsertBeforeIterable(this, filter, iterable, throwOnIndexOverflow));
+    insertBefore(predicateFn, iterable) {
+        return new AsyncIterableCollection(new AsyncInsertBeforeIterable(this, predicateFn, iterable));
     }
-    insertAfter(filter, iterable, throwOnIndexOverflow = AsyncIterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return new AsyncIterableCollection(new AsyncInsertAfterIterable(this, filter, iterable, throwOnIndexOverflow));
+    insertAfter(predicateFn, iterable) {
+        return new AsyncIterableCollection(new AsyncInsertAfterIterable(this, predicateFn, iterable));
     }
-    crossJoin(...iterables) {
-        return new AsyncIterableCollection(new AsyncCrossJoinIterable(this, iterables, AsyncIterableCollection.makeCollection));
+    crossJoin(iterable) {
+        return new AsyncIterableCollection(new AsyncCrossJoinIterable(this, iterable, AsyncIterableCollection.makeCollection));
     }
     zip(iterable) {
         return new AsyncIterableCollection(new AsyncZipIterable(this, iterable));
@@ -389,150 +382,111 @@ export class AsyncIterableCollection {
     sort(comparator) {
         return new AsyncIterableCollection(new AsyncSortIterable(this, comparator));
     }
-    reverse(settings) {
-        return new AsyncIterableCollection(new AsyncReverseIterable(this, settings?.chunkSize ??
-            AsyncIterableCollection.DEFAULT_CHUNK_SIZE, settings?.throwOnIndexOverflow ??
-            AsyncIterableCollection.THROW_ON_NUMBER_LIMIT, AsyncIterableCollection.makeCollection));
+    reverse(chunkSize) {
+        return new AsyncIterableCollection(new AsyncReverseIterable(this, chunkSize ?? AsyncIterableCollection.DEFAULT_CHUNK_SIZE, AsyncIterableCollection.makeCollection));
     }
-    shuffle() {
-        return new AsyncIterableCollection(new AsyncShuffleIterable(this));
+    shuffle(mathRandom = Math.random) {
+        return new AsyncIterableCollection(new AsyncShuffleIterable(this, mathRandom));
     }
-    async first(settings) {
-        return this.firstOr({
-            ...settings,
-            defaultValue: null,
-        });
+    async first(predicateFn) {
+        return this.firstOr(null, predicateFn);
     }
-    async firstOr(settings) {
+    async firstOr(defaultValue, predicateFn = () => true) {
         try {
-            const throwOnIndexOverflow = settings.throwOnIndexOverflow ??
-                AsyncIterableCollection.THROW_ON_NUMBER_LIMIT;
-            const filter = settings.predicateFn ?? (() => true);
-            for await (const [index, item] of this.entries(throwOnIndexOverflow)) {
-                if (await filter(item, index, this)) {
+            for await (const [index, item] of this.entries()) {
+                if (await predicateFn(item, index, this)) {
                     return item;
                 }
             }
-            if (typeof settings.defaultValue === "function") {
-                const defaultFn = settings.defaultValue;
-                return defaultFn();
-            }
-            return settings.defaultValue;
+            return await simplifyAsyncLazyable(defaultValue);
         }
         catch (error) {
-            if (error instanceof CollectionError ||
-                error instanceof TypeError) {
+            if (error instanceof CollectionError) {
                 throw error;
             }
             throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
         }
     }
-    async firstOrFail(settings) {
-        const item = await this.first(settings);
+    async firstOrFail(predicateFn) {
+        const item = await this.first(predicateFn);
         if (item === null) {
-            throw new ItemNotFoundError("Item was not found");
+            throw new ItemNotFoundCollectionError("Item was not found");
         }
         return item;
     }
-    async last(settings) {
-        return this.lastOr({
-            ...settings,
-            defaultValue: null,
-        });
+    async last(predicateFn) {
+        return this.lastOr(null, predicateFn);
     }
-    async lastOr(settings) {
+    async lastOr(defaultValue, predicateFn = () => true) {
         try {
-            const throwOnIndexOverflow = settings.throwOnIndexOverflow ??
-                AsyncIterableCollection.THROW_ON_NUMBER_LIMIT;
-            const filter = settings.predicateFn ?? (() => true);
             let matchedItem = null;
-            for await (const [index, item] of this.entries(throwOnIndexOverflow)) {
-                if (await filter(item, index, this)) {
+            for await (const [index, item] of this.entries()) {
+                if (await predicateFn(item, index, this)) {
                     matchedItem = item;
                 }
             }
             if (matchedItem) {
                 return matchedItem;
             }
-            if (typeof settings.defaultValue === "function") {
-                const defaultFn = settings.defaultValue;
-                return defaultFn();
-            }
-            return settings.defaultValue;
+            return await simplifyAsyncLazyable(defaultValue);
         }
         catch (error) {
-            if (error instanceof CollectionError ||
-                error instanceof TypeError) {
+            if (error instanceof CollectionError) {
                 throw error;
             }
             throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
         }
     }
-    async lastOrFail(settings) {
-        const item = await this.last(settings);
+    async lastOrFail(predicateFn) {
+        const item = await this.last(predicateFn);
         if (item === null) {
-            throw new ItemNotFoundError("Item was not found");
+            throw new ItemNotFoundCollectionError("Item was not found");
         }
         return item;
     }
-    async before(filter, throwOnIndexOverflow = AsyncIterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return this.beforeOr(null, filter, throwOnIndexOverflow);
+    async before(predicateFn) {
+        return this.beforeOr(null, predicateFn);
     }
-    async beforeOr(defaultValue, filter, throwOnIndexOverflow = AsyncIterableCollection.THROW_ON_NUMBER_LIMIT) {
+    async beforeOr(defaultValue, predicateFn) {
         try {
             let beforeItem = null, index = 0;
             for await (const item of this) {
-                if (throwOnIndexOverflow && index === Number.MAX_SAFE_INTEGER) {
-                    throw new IndexOverflowError("Index has overflowed");
-                }
-                if ((await filter(item, index, this)) && beforeItem) {
+                if ((await predicateFn(item, index, this)) && beforeItem) {
                     return beforeItem;
                 }
                 index++;
                 beforeItem = item;
             }
-            if (typeof defaultValue === "function") {
-                const defaultFn = defaultValue;
-                return defaultFn();
-            }
-            return defaultValue;
+            return await simplifyAsyncLazyable(defaultValue);
         }
         catch (error) {
-            if (error instanceof CollectionError ||
-                error instanceof TypeError) {
+            if (error instanceof CollectionError) {
                 throw error;
             }
             throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
         }
     }
-    async beforeOrFail(filter, throwOnIndexOverflow = AsyncIterableCollection.THROW_ON_NUMBER_LIMIT) {
-        const item = await this.before(filter, throwOnIndexOverflow);
+    async beforeOrFail(predicateFn) {
+        const item = await this.before(predicateFn);
         if (item === null) {
-            throw new ItemNotFoundError("Item was not found");
+            throw new ItemNotFoundCollectionError("Item was not found");
         }
         return item;
     }
-    async after(filter, throwOnIndexOverflow = AsyncIterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return this.afterOr(null, filter, throwOnIndexOverflow);
+    async after(predicateFn) {
+        return this.afterOr(null, predicateFn);
     }
-    async afterOr(defaultValue, filter, throwOnIndexOverflow = AsyncIterableCollection.THROW_ON_NUMBER_LIMIT) {
+    async afterOr(defaultValue, predicateFn) {
         try {
             let hasMatched = false, index = 0;
             for await (const item of this) {
                 if (hasMatched) {
                     return item;
                 }
-                if (throwOnIndexOverflow && index === Number.MAX_SAFE_INTEGER) {
-                    throw new IndexOverflowError("Index has overflowed");
-                }
-                hasMatched = await filter(item, index, this);
+                hasMatched = await predicateFn(item, index, this);
                 index++;
             }
-            if (typeof defaultValue === "function") {
-                const defaultFn = defaultValue;
-                return defaultFn();
-            }
-            return defaultValue;
+            return await simplifyAsyncLazyable(defaultValue);
         }
         catch (error) {
             if (error instanceof CollectionError) {
@@ -541,32 +495,31 @@ export class AsyncIterableCollection {
             throw new UnexpectedCollectionError("!!__messge__!!", error);
         }
     }
-    async afterOrFail(filter, throwOnIndexOverflow = AsyncIterableCollection.THROW_ON_NUMBER_LIMIT) {
-        const item = await this.after(filter, throwOnIndexOverflow);
+    async afterOrFail(predicateFn) {
+        const item = await this.after(predicateFn);
         if (item === null) {
-            throw new ItemNotFoundError("Item was not found");
+            throw new ItemNotFoundCollectionError("Item was not found");
         }
         return item;
     }
-    async sole(filter, throwOnIndexOverflow = AsyncIterableCollection.THROW_ON_NUMBER_LIMIT) {
+    async sole(predicateFn) {
         try {
             let matchedItem = null;
-            for await (const [index, item] of this.entries(throwOnIndexOverflow)) {
-                if (await filter(item, index, this)) {
+            for await (const [index, item] of this.entries()) {
+                if (await predicateFn(item, index, this)) {
                     if (matchedItem !== null) {
-                        throw new MultipleItemsFoundError("Multiple items were found");
+                        throw new MultipleItemsFoundCollectionError("Multiple items were found");
                     }
                     matchedItem = item;
                 }
             }
             if (matchedItem === null) {
-                throw new ItemNotFoundError("Item was not found");
+                throw new ItemNotFoundCollectionError("Item was not found");
             }
             return matchedItem;
         }
         catch (error) {
-            if (error instanceof CollectionError ||
-                error instanceof TypeError) {
+            if (error instanceof CollectionError) {
                 throw error;
             }
             throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
@@ -584,29 +537,25 @@ export class AsyncIterableCollection {
     timeout(timeInMs) {
         return new AsyncIterableCollection(new AsyncTimeoutIterable(this, timeInMs));
     }
-    async count(filter, throwOnIndexOverflow = AsyncIterableCollection.THROW_ON_NUMBER_LIMIT) {
+    async count(predicateFn) {
         try {
             let size = 0;
             for await (const item of this) {
-                if (throwOnIndexOverflow && size === Number.MAX_SAFE_INTEGER) {
-                    throw new IndexOverflowError("Size has overflowed");
-                }
-                if (await filter(item, size, this)) {
+                if (await predicateFn(item, size, this)) {
                     size++;
                 }
             }
             return size;
         }
         catch (error) {
-            if (error instanceof CollectionError ||
-                error instanceof TypeError) {
+            if (error instanceof CollectionError) {
                 throw error;
             }
             throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
         }
     }
-    async size(throwOnIndexOverflow) {
-        return this.count(() => true, throwOnIndexOverflow);
+    async size() {
+        return this.count(() => true);
     }
     async isEmpty() {
         try {
@@ -616,8 +565,7 @@ export class AsyncIterableCollection {
             return true;
         }
         catch (error) {
-            if (error instanceof CollectionError ||
-                error instanceof TypeError) {
+            if (error instanceof CollectionError) {
                 throw error;
             }
             throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
@@ -626,43 +574,41 @@ export class AsyncIterableCollection {
     async isNotEmpty() {
         return !(await this.isEmpty());
     }
-    async searchFirst(filter, throwOnIndexOverflow = AsyncIterableCollection.THROW_ON_NUMBER_LIMIT) {
+    async searchFirst(predicateFn) {
         try {
-            for await (const [index, item] of this.entries(throwOnIndexOverflow)) {
-                if (await filter(item, index, this)) {
+            for await (const [index, item] of this.entries()) {
+                if (await predicateFn(item, index, this)) {
                     return index;
                 }
             }
             return -1;
         }
         catch (error) {
-            if (error instanceof CollectionError ||
-                error instanceof TypeError) {
+            if (error instanceof CollectionError) {
                 throw error;
             }
             throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
         }
     }
-    async searchLast(filter, throwOnIndexOverflow = AsyncIterableCollection.THROW_ON_NUMBER_LIMIT) {
+    async searchLast(predicateFn) {
         try {
             let matchedIndex = -1;
-            for await (const [index, item] of this.entries(throwOnIndexOverflow)) {
-                if (await filter(item, index, this)) {
+            for await (const [index, item] of this.entries()) {
+                if (await predicateFn(item, index, this)) {
                     matchedIndex = index;
                 }
             }
             return matchedIndex;
         }
         catch (error) {
-            if (error instanceof CollectionError ||
-                error instanceof TypeError) {
+            if (error instanceof CollectionError) {
                 throw error;
             }
             throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
         }
     }
-    async forEach(callback, throwOnIndexOverflow = AsyncIterableCollection.THROW_ON_NUMBER_LIMIT) {
-        for await (const [index, item] of this.entries(throwOnIndexOverflow)) {
+    async forEach(callback) {
+        for await (const [index, item] of this.entries()) {
             await callback(item, index, this);
         }
     }
@@ -675,8 +621,7 @@ export class AsyncIterableCollection {
             return items;
         }
         catch (error) {
-            if (error instanceof CollectionError ||
-                error instanceof TypeError) {
+            if (error instanceof CollectionError) {
                 throw error;
             }
             throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);