@daiso-tech/core 0.1.4 → 0.2.0

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

@@ -3,9 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AsyncIterableCollection = void 0;
 const _module_1 = require("../../contracts/collection/_module");
 const _module_2 = require("../../collection/async-iterable-collection/_shared/_module");
+const utilities_1 = require("../../_shared/utilities");
 class AsyncIterableCollection {
     iterable;
-    static THROW_ON_NUMBER_LIMIT = false;
     static DEFAULT_CHUNK_SIZE = 1024;
     static makeCollection = (iterable) => {
         return new AsyncIterableCollection(iterable);
@@ -19,92 +19,91 @@ class AsyncIterableCollection {
     toIterator() {
         return this[Symbol.asyncIterator]();
     }
-    entries(throwOnIndexOverflow = AsyncIterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return new AsyncIterableCollection(new _module_2.AsyncEntriesIterable(this, throwOnIndexOverflow));
+    entries() {
+        return new AsyncIterableCollection(new _module_2.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 _module_2.AsyncFilterIterable(this, filter, throwOnIndexOverflow));
+    filter(predicateFn) {
+        return new AsyncIterableCollection(new _module_2.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 _module_2.AsyncMapIterable(this, mapFn, throwOnIndexOverflow));
+    map(mapFn) {
+        return new AsyncIterableCollection(new _module_2.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 _module_1.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 _module_1.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 _module_1.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 _module_2.AsyncCollapseIterable(this));
     }
-    flatMap(mapFn, throwOnIndexOverflow = AsyncIterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return new AsyncIterableCollection(new _module_2.AsyncFlatMapIterable(this, mapFn, throwOnIndexOverflow));
+    flatMap(mapFn) {
+        return new AsyncIterableCollection(new _module_2.AsyncFlatMapIterable(this, mapFn));
     }
-    update(filter, mapFn, throwOnIndexOverflow = AsyncIterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return new AsyncIterableCollection(new _module_2.AsyncUpdateIterable(this, filter, mapFn, throwOnIndexOverflow));
+    change(predicateFn, mapFn) {
+        return new AsyncIterableCollection(new _module_2.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 _module_1.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 _module_1.TypeCollectionError("Item type is invalid must be number");
                 }
                 sum += item;
             }
             return sum;
         }
         catch (error) {
-            if (error instanceof _module_1.CollectionError ||
-                error instanceof TypeError) {
+            if (error instanceof _module_1.CollectionError) {
                 throw error;
             }
             throw new _module_1.UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
@@ -112,10 +111,13 @@ class AsyncIterableCollection {
     }
     async average() {
         try {
+            if (await this.isEmpty()) {
+                throw new _module_1.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 _module_1.TypeCollectionError("Item type is invalid must be number");
                 }
                 size++;
                 sum += item;
@@ -123,33 +125,32 @@ class AsyncIterableCollection {
             return (sum / size);
         }
         catch (error) {
-            if (error instanceof _module_1.CollectionError ||
-                error instanceof TypeError) {
+            if (error instanceof _module_1.CollectionError) {
                 throw error;
             }
             throw new _module_1.UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
         }
     }
-    async median(throwOnIndexOverflow) {
+    async median() {
         if (await this.isEmpty()) {
-            return 0;
+            throw new _module_1.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 _module_1.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;
@@ -169,10 +170,13 @@ class AsyncIterableCollection {
     }
     async min() {
         try {
+            if (await this.isEmpty()) {
+                throw new _module_1.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 _module_1.TypeCollectionError("Item type is invalid must be number");
                 }
                 if (min === 0) {
                     min = item;
@@ -184,8 +188,7 @@ class AsyncIterableCollection {
             return min;
         }
         catch (error) {
-            if (error instanceof _module_1.CollectionError ||
-                error instanceof TypeError) {
+            if (error instanceof _module_1.CollectionError) {
                 throw error;
             }
             throw new _module_1.UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
@@ -193,10 +196,13 @@ class AsyncIterableCollection {
     }
     async max() {
         try {
+            if (await this.isEmpty()) {
+                throw new _module_1.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 _module_1.TypeCollectionError("Item type is invalid must be number");
                 }
                 if (max === 0) {
                     max = item;
@@ -208,24 +214,20 @@ class AsyncIterableCollection {
             return max;
         }
         catch (error) {
-            if (error instanceof _module_1.CollectionError ||
-                error instanceof TypeError) {
+            if (error instanceof _module_1.CollectionError) {
                 throw error;
             }
             throw new _module_1.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 _module_1.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 _module_1.IndexOverflowError("The total amount has overflowed");
-                }
-                if (await filter(item, total, this)) {
+                if (await predicateFn(item, total, this)) {
                     part++;
                 }
                 total++;
@@ -233,35 +235,33 @@ class AsyncIterableCollection {
             return (part / total) * 100;
         }
         catch (error) {
-            if (error instanceof _module_1.CollectionError ||
-                error instanceof TypeError) {
+            if (error instanceof _module_1.CollectionError) {
                 throw error;
             }
             throw new _module_1.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 _module_1.CollectionError ||
-                error instanceof TypeError) {
+            if (error instanceof _module_1.CollectionError) {
                 throw error;
             }
             throw new _module_1.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;
                 }
@@ -269,30 +269,29 @@ class AsyncIterableCollection {
             return isTrue;
         }
         catch (error) {
-            if (error instanceof _module_1.CollectionError ||
-                error instanceof TypeError) {
+            if (error instanceof _module_1.CollectionError) {
                 throw error;
             }
             throw new _module_1.UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
         }
     }
-    take(limit, throwOnIndexOverflow = AsyncIterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return new AsyncIterableCollection(new _module_2.AsyncTakeIterable(this, limit, throwOnIndexOverflow));
+    take(limit) {
+        return new AsyncIterableCollection(new _module_2.AsyncTakeIterable(this, limit));
     }
-    takeUntil(filter, throwOnIndexOverflow = AsyncIterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return new AsyncIterableCollection(new _module_2.AsyncTakeUntilIterable(this, filter, throwOnIndexOverflow));
+    takeUntil(predicateFn) {
+        return new AsyncIterableCollection(new _module_2.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 _module_2.AsyncSkipIterable(this, offset, throwOnIndexOverflow));
+    skip(offset) {
+        return new AsyncIterableCollection(new _module_2.AsyncSkipIterable(this, offset));
     }
-    skipUntil(filter, throwOnIndexOverflow = AsyncIterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return new AsyncIterableCollection(new _module_2.AsyncSkipUntilIterable(this, filter, throwOnIndexOverflow));
+    skipUntil(predicateFn) {
+        return new AsyncIterableCollection(new _module_2.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 _module_2.AsyncWhenIterable(this, () => condition, callback));
@@ -311,8 +310,7 @@ class AsyncIterableCollection {
             return await callback(this);
         }
         catch (error) {
-            if (error instanceof _module_1.CollectionError ||
-                error instanceof TypeError) {
+            if (error instanceof _module_1.CollectionError) {
                 throw error;
             }
             throw new _module_1.UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
@@ -324,30 +322,26 @@ class AsyncIterableCollection {
     chunk(chunkSize) {
         return new AsyncIterableCollection(new _module_2.AsyncChunkIterable(this, chunkSize, AsyncIterableCollection.makeCollection));
     }
-    chunkWhile(filter, throwOnIndexOverflow = AsyncIterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return new AsyncIterableCollection(new _module_2.AsyncChunkWhileIterable(this, filter, throwOnIndexOverflow, AsyncIterableCollection.makeCollection));
+    chunkWhile(predicateFn) {
+        return new AsyncIterableCollection(new _module_2.AsyncChunkWhileIterable(this, predicateFn, AsyncIterableCollection.makeCollection));
     }
-    split(chunkAmount, throwOnIndexOverflow = AsyncIterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return new AsyncIterableCollection(new _module_2.AsyncSplitIterable(this, chunkAmount, throwOnIndexOverflow, AsyncIterableCollection.makeCollection));
+    split(chunkAmount) {
+        return new AsyncIterableCollection(new _module_2.AsyncSplitIterable(this, chunkAmount, AsyncIterableCollection.makeCollection));
     }
-    partition(filter, throwOnIndexOverflow = AsyncIterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return new AsyncIterableCollection(new _module_2.AsyncPartionIterable(this, filter, throwOnIndexOverflow, AsyncIterableCollection.makeCollection));
+    partition(predicateFn) {
+        return new AsyncIterableCollection(new _module_2.AsyncPartionIterable(this, predicateFn, AsyncIterableCollection.makeCollection));
     }
-    sliding(settings) {
-        const { chunkSize, step = chunkSize - 1, throwOnIndexOverflow = AsyncIterableCollection.THROW_ON_NUMBER_LIMIT, } = settings;
-        return new AsyncIterableCollection(new _module_2.AsyncSlidingIteralbe(this, chunkSize, step, throwOnIndexOverflow));
+    sliding(chunkSize, step = chunkSize - 1) {
+        return new AsyncIterableCollection(new _module_2.AsyncSlidingIteralbe(this, chunkSize, step));
     }
-    groupBy(settings) {
-        return new AsyncIterableCollection(new _module_2.AsyncGroupByIterable(this, settings?.selectFn, settings?.throwOnIndexOverflow ??
-            AsyncIterableCollection.THROW_ON_NUMBER_LIMIT, AsyncIterableCollection.makeCollection));
+    groupBy(selectFn) {
+        return new AsyncIterableCollection(new _module_2.AsyncGroupByIterable(this, selectFn, AsyncIterableCollection.makeCollection));
     }
-    countBy(settings) {
-        return new AsyncIterableCollection(new _module_2.AsyncCountByIterable(this, settings?.selectFn, settings?.throwOnIndexOverflow ??
-            AsyncIterableCollection.THROW_ON_NUMBER_LIMIT));
+    countBy(selectFn) {
+        return new AsyncIterableCollection(new _module_2.AsyncCountByIterable(this, selectFn));
     }
-    unique(settings) {
-        return new AsyncIterableCollection(new _module_2.AsyncUniqueIterable(this, settings?.selectFn, settings?.throwOnIndexOverflow ??
-            AsyncIterableCollection.THROW_ON_NUMBER_LIMIT));
+    unique(selectFn) {
+        return new AsyncIterableCollection(new _module_2.AsyncUniqueIterable(this, selectFn));
     }
     difference(iterable, selectFn = (item) => item) {
         const differenceCollection = new AsyncIterableCollection(iterable);
@@ -367,9 +361,8 @@ class AsyncIterableCollection {
     padEnd(maxLength, fillItems) {
         return new AsyncIterableCollection(new _module_2.AsyncPadEndIterable(this, maxLength, fillItems, AsyncIterableCollection.makeCollection));
     }
-    slice(settings) {
-        return new AsyncIterableCollection(new _module_2.AsyncSliceIterable(this, settings?.start, settings?.end, settings?.throwOnIndexOverflow ??
-            AsyncIterableCollection.THROW_ON_NUMBER_LIMIT));
+    slice(start, end) {
+        return new AsyncIterableCollection(new _module_2.AsyncSliceIterable(this, start, end));
     }
     prepend(iterable) {
         return new AsyncIterableCollection(new _module_2.AsyncMergeIterable(iterable, this));
@@ -377,14 +370,14 @@ class AsyncIterableCollection {
     append(iterable) {
         return new AsyncIterableCollection(new _module_2.AsyncMergeIterable(this, iterable));
     }
-    insertBefore(filter, iterable, throwOnIndexOverflow = AsyncIterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return new AsyncIterableCollection(new _module_2.AsyncInsertBeforeIterable(this, filter, iterable, throwOnIndexOverflow));
+    insertBefore(predicateFn, iterable) {
+        return new AsyncIterableCollection(new _module_2.AsyncInsertBeforeIterable(this, predicateFn, iterable));
     }
-    insertAfter(filter, iterable, throwOnIndexOverflow = AsyncIterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return new AsyncIterableCollection(new _module_2.AsyncInsertAfterIterable(this, filter, iterable, throwOnIndexOverflow));
+    insertAfter(predicateFn, iterable) {
+        return new AsyncIterableCollection(new _module_2.AsyncInsertAfterIterable(this, predicateFn, iterable));
     }
-    crossJoin(...iterables) {
-        return new AsyncIterableCollection(new _module_2.AsyncCrossJoinIterable(this, iterables, AsyncIterableCollection.makeCollection));
+    crossJoin(iterable) {
+        return new AsyncIterableCollection(new _module_2.AsyncCrossJoinIterable(this, iterable, AsyncIterableCollection.makeCollection));
     }
     zip(iterable) {
         return new AsyncIterableCollection(new _module_2.AsyncZipIterable(this, iterable));
@@ -392,150 +385,111 @@ class AsyncIterableCollection {
     sort(comparator) {
         return new AsyncIterableCollection(new _module_2.AsyncSortIterable(this, comparator));
     }
-    reverse(settings) {
-        return new AsyncIterableCollection(new _module_2.AsyncReverseIterable(this, settings?.chunkSize ??
-            AsyncIterableCollection.DEFAULT_CHUNK_SIZE, settings?.throwOnIndexOverflow ??
-            AsyncIterableCollection.THROW_ON_NUMBER_LIMIT, AsyncIterableCollection.makeCollection));
+    reverse(chunkSize) {
+        return new AsyncIterableCollection(new _module_2.AsyncReverseIterable(this, chunkSize ?? AsyncIterableCollection.DEFAULT_CHUNK_SIZE, AsyncIterableCollection.makeCollection));
     }
-    shuffle() {
-        return new AsyncIterableCollection(new _module_2.AsyncShuffleIterable(this));
+    shuffle(mathRandom = Math.random) {
+        return new AsyncIterableCollection(new _module_2.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 (0, utilities_1.simplifyAsyncLazyable)(defaultValue);
         }
         catch (error) {
-            if (error instanceof _module_1.CollectionError ||
-                error instanceof TypeError) {
+            if (error instanceof _module_1.CollectionError) {
                 throw error;
             }
             throw new _module_1.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 _module_1.ItemNotFoundError("Item was not found");
+            throw new _module_1.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 (0, utilities_1.simplifyAsyncLazyable)(defaultValue);
         }
         catch (error) {
-            if (error instanceof _module_1.CollectionError ||
-                error instanceof TypeError) {
+            if (error instanceof _module_1.CollectionError) {
                 throw error;
             }
             throw new _module_1.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 _module_1.ItemNotFoundError("Item was not found");
+            throw new _module_1.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 _module_1.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 (0, utilities_1.simplifyAsyncLazyable)(defaultValue);
         }
         catch (error) {
-            if (error instanceof _module_1.CollectionError ||
-                error instanceof TypeError) {
+            if (error instanceof _module_1.CollectionError) {
                 throw error;
             }
             throw new _module_1.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 _module_1.ItemNotFoundError("Item was not found");
+            throw new _module_1.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 _module_1.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 (0, utilities_1.simplifyAsyncLazyable)(defaultValue);
         }
         catch (error) {
             if (error instanceof _module_1.CollectionError) {
@@ -544,32 +498,31 @@ class AsyncIterableCollection {
             throw new _module_1.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 _module_1.ItemNotFoundError("Item was not found");
+            throw new _module_1.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 _module_1.MultipleItemsFoundError("Multiple items were found");
+                        throw new _module_1.MultipleItemsFoundCollectionError("Multiple items were found");
                     }
                     matchedItem = item;
                 }
             }
             if (matchedItem === null) {
-                throw new _module_1.ItemNotFoundError("Item was not found");
+                throw new _module_1.ItemNotFoundCollectionError("Item was not found");
             }
             return matchedItem;
         }
         catch (error) {
-            if (error instanceof _module_1.CollectionError ||
-                error instanceof TypeError) {
+            if (error instanceof _module_1.CollectionError) {
                 throw error;
             }
             throw new _module_1.UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
@@ -587,29 +540,25 @@ class AsyncIterableCollection {
     timeout(timeInMs) {
         return new AsyncIterableCollection(new _module_2.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 _module_1.IndexOverflowError("Size has overflowed");
-                }
-                if (await filter(item, size, this)) {
+                if (await predicateFn(item, size, this)) {
                     size++;
                 }
             }
             return size;
         }
         catch (error) {
-            if (error instanceof _module_1.CollectionError ||
-                error instanceof TypeError) {
+            if (error instanceof _module_1.CollectionError) {
                 throw error;
             }
             throw new _module_1.UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
         }
     }
-    async size(throwOnIndexOverflow) {
-        return this.count(() => true, throwOnIndexOverflow);
+    async size() {
+        return this.count(() => true);
     }
     async isEmpty() {
         try {
@@ -619,8 +568,7 @@ class AsyncIterableCollection {
             return true;
         }
         catch (error) {
-            if (error instanceof _module_1.CollectionError ||
-                error instanceof TypeError) {
+            if (error instanceof _module_1.CollectionError) {
                 throw error;
             }
             throw new _module_1.UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
@@ -629,43 +577,41 @@ 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 _module_1.CollectionError ||
-                error instanceof TypeError) {
+            if (error instanceof _module_1.CollectionError) {
                 throw error;
             }
             throw new _module_1.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 _module_1.CollectionError ||
-                error instanceof TypeError) {
+            if (error instanceof _module_1.CollectionError) {
                 throw error;
             }
             throw new _module_1.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);
         }
     }
@@ -678,8 +624,7 @@ class AsyncIterableCollection {
             return items;
         }
         catch (error) {
-            if (error instanceof _module_1.CollectionError ||
-                error instanceof TypeError) {
+            if (error instanceof _module_1.CollectionError) {
                 throw error;
             }
             throw new _module_1.UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);