@daiso-tech/core 0.1.4 → 0.2.0

package/dist/esm/collection/iterable-collection/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 { CrossJoinIterable, SlidingIteralbe, ShuffleIterable, EntriesIterable, FilterIterable, ChunkIterable, ChunkWhileIterable, CollapseIterable, CountByIterable, FlatMapIterable, GroupByIterable, InsertAfterIterable, InsertBeforeIterable, MapIterable, MergeIterable, PadEndIterable, PadStartIterable, PartionIterable, SkipIterable, SkipUntilIterable, SortIterable, SplitIterable, TakeIterable, TakeUntilIterable, TapIterable, UniqueIterable, UpdateIterable, WhenIterable, ZipIterable, ReverseIterable, SliceIterable, RepeatIterable, } from "../../collection/iterable-collection/_shared/_module";
+import { simplifyLazyable } from "../../_shared/utilities";
 export class IterableCollection {
     iterable;
-    static THROW_ON_NUMBER_LIMIT = false;
     static DEFAULT_CHUNK_SIZE = 1024;
     static makeCollection = (iterable = []) => {
         return new IterableCollection(iterable);
@@ -15,8 +15,7 @@ export class IterableCollection {
             yield* this.iterable;
         }
         catch (error) {
-            if (error instanceof CollectionError ||
-                error instanceof TypeError) {
+            if (error instanceof CollectionError) {
                 throw error;
             }
             throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
@@ -25,38 +24,33 @@ export class IterableCollection {
     toIterator() {
         return this[Symbol.iterator]();
     }
-    entries(throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return new IterableCollection(new EntriesIterable(this, throwOnIndexOverflow));
+    entries() {
+        return new IterableCollection(new EntriesIterable(this));
     }
-    keys(throwOnIndexOverflow = IterableCollection.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(predicateFn, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return new IterableCollection(new FilterIterable(this, predicateFn, throwOnIndexOverflow));
+    filter(predicateFn) {
+        return new IterableCollection(new FilterIterable(this, predicateFn));
     }
-    reject(predicateFn, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return this.filter((...arguments_) => !predicateFn(...arguments_), throwOnIndexOverflow);
+    reject(predicateFn) {
+        return this.filter((...arguments_) => !predicateFn(...arguments_));
     }
-    map(mapFn, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return new IterableCollection(new MapIterable(this, mapFn, throwOnIndexOverflow));
+    map(mapFn) {
+        return new IterableCollection(new MapIterable(this, mapFn));
     }
-    reduce(settings) {
+    reduce(reduceFn, initialValue) {
         try {
-            const { reduceFn: reduce, initialValue, throwOnIndexOverflow, } = settings;
             if (initialValue === undefined && 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, index = 0;
                 for (const item of this) {
-                    if (throwOnIndexOverflow &&
-                        index === Number.MAX_SAFE_INTEGER) {
-                        throw new IndexOverflowError("Index has overflowed");
-                    }
-                    output = reduce(output, item, index, this);
+                    output = reduceFn(output, item, index, this);
                     index++;
                 }
                 return output;
@@ -64,11 +58,7 @@ export class IterableCollection {
             let output = this.firstOrFail(), index = 0, isFirstIteration = true;
             for (const item of this) {
                 if (!isFirstIteration) {
-                    if (throwOnIndexOverflow &&
-                        index === Number.MAX_SAFE_INTEGER) {
-                        throw new IndexOverflowError("Index has overflowed");
-                    }
-                    output = reduce(output, item, index, this);
+                    output = reduceFn(output, item, index, this);
                 }
                 isFirstIteration = false;
                 index++;
@@ -76,30 +66,30 @@ export class IterableCollection {
             return output;
         }
         catch (error) {
-            if (error instanceof CollectionError ||
-                error instanceof TypeError) {
+            if (error instanceof CollectionError) {
                 throw error;
             }
             throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
         }
     }
-    join(settings) {
+    join(separator = ",") {
         try {
-            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 ??
-                    IterableCollection.THROW_ON_NUMBER_LIMIT,
-            });
+            let str = null;
+            for (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;
         }
         catch (error) {
-            if (error instanceof CollectionError ||
-                error instanceof TypeError) {
+            if (error instanceof CollectionError) {
                 throw error;
             }
             throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
@@ -108,33 +98,34 @@ export class IterableCollection {
     collapse() {
         return new IterableCollection(new CollapseIterable(this));
     }
-    flatMap(mapFn, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return new IterableCollection(new FlatMapIterable(this, mapFn, throwOnIndexOverflow));
+    flatMap(mapFn) {
+        return new IterableCollection(new FlatMapIterable(this, mapFn));
     }
-    update(predicateFn, mapFn, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return new IterableCollection(new UpdateIterable(this, predicateFn, mapFn, throwOnIndexOverflow));
+    change(predicateFn, mapFn) {
+        return new IterableCollection(new UpdateIterable(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);
     }
     sum() {
         try {
+            if (this.isEmpty()) {
+                throw new EmptyCollectionError("Collection is empty therby operation cannot be performed");
+            }
             let sum = 0;
             for (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);
@@ -142,10 +133,13 @@ export class IterableCollection {
     }
     average() {
         try {
+            if (this.isEmpty()) {
+                throw new EmptyCollectionError("Collection is empty therby operation cannot be performed");
+            }
             let size = 0, sum = 0;
             for (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;
@@ -153,33 +147,32 @@ export class IterableCollection {
             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);
         }
     }
-    median(throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+    median() {
         if (this.isEmpty()) {
-            return 0;
+            throw new EmptyCollectionError("Collection is empty therby operation cannot be performed");
         }
-        const size = this.size(throwOnIndexOverflow);
+        const size = this.size();
         if (size === 0) {
             return 0;
         }
         const isEven = size % 2 === 0, items = 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;
@@ -199,10 +192,13 @@ export class IterableCollection {
     }
     min() {
         try {
+            if (this.isEmpty()) {
+                throw new EmptyCollectionError("Collection is empty therby operation cannot be performed");
+            }
             let min = 0;
             for (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;
@@ -214,8 +210,7 @@ export class IterableCollection {
             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);
@@ -223,10 +218,13 @@ export class IterableCollection {
     }
     max() {
         try {
+            if (this.isEmpty()) {
+                throw new EmptyCollectionError("Collection is empty therby operation cannot be performed");
+            }
             let max = 0;
             for (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;
@@ -238,23 +236,19 @@ export class IterableCollection {
             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);
         }
     }
-    percentage(predicateFn, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+    percentage(predicateFn) {
         try {
             if (this.isEmpty()) {
-                return 0;
+                throw new EmptyCollectionError("Collection is empty therby operation cannot be performed");
             }
             let part = 0, total = 0;
             for (const item of this) {
-                if (throwOnIndexOverflow && total === Number.MAX_SAFE_INTEGER) {
-                    throw new IndexOverflowError("The total amount has overflowed");
-                }
                 if (predicateFn(item, total, this)) {
                     part++;
                 }
@@ -263,20 +257,16 @@ export class IterableCollection {
             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);
         }
     }
-    some(predicateFn, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+    some(predicateFn) {
         try {
             let index = 0;
             for (const item of this) {
-                if (throwOnIndexOverflow && index === Number.MAX_SAFE_INTEGER) {
-                    throw new IndexOverflowError("Index has overflowed");
-                }
                 if (predicateFn(item, index, this)) {
                     return true;
                 }
@@ -285,20 +275,16 @@ export class IterableCollection {
             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);
         }
     }
-    every(predicateFn, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+    every(predicateFn) {
         try {
             let index = 0, isTrue = true;
             for (const item of this) {
-                if (throwOnIndexOverflow && index === Number.MAX_SAFE_INTEGER) {
-                    throw new IndexOverflowError("Index has overflowed");
-                }
                 isTrue &&= predicateFn(item, index, this);
                 if (!isTrue) {
                     break;
@@ -308,30 +294,29 @@ export class IterableCollection {
             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 = IterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return new IterableCollection(new TakeIterable(this, limit, throwOnIndexOverflow));
+    take(limit) {
+        return new IterableCollection(new TakeIterable(this, limit));
     }
-    takeUntil(predicateFn, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return new IterableCollection(new TakeUntilIterable(this, predicateFn, throwOnIndexOverflow));
+    takeUntil(predicateFn) {
+        return new IterableCollection(new TakeUntilIterable(this, predicateFn));
     }
-    takeWhile(predicateFn, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return this.takeUntil((...arguments_) => !predicateFn(...arguments_), throwOnIndexOverflow);
+    takeWhile(predicateFn) {
+        return this.takeUntil((...arguments_) => !predicateFn(...arguments_));
     }
-    skip(offset, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return new IterableCollection(new SkipIterable(this, offset, throwOnIndexOverflow));
+    skip(offset) {
+        return new IterableCollection(new SkipIterable(this, offset));
     }
-    skipUntil(predicateFn, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return new IterableCollection(new SkipUntilIterable(this, predicateFn, throwOnIndexOverflow));
+    skipUntil(predicateFn) {
+        return new IterableCollection(new SkipUntilIterable(this, predicateFn));
     }
-    skipWhile(predicateFn, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return this.skipUntil((...arguments_) => !predicateFn(...arguments_), throwOnIndexOverflow);
+    skipWhile(predicateFn) {
+        return this.skipUntil((...arguments_) => !predicateFn(...arguments_));
     }
     when(condition, callback) {
         return new IterableCollection(new WhenIterable(this, () => condition, callback));
@@ -350,8 +335,7 @@ export class IterableCollection {
             return 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);
@@ -363,30 +347,26 @@ export class IterableCollection {
     chunk(chunkSize) {
         return new IterableCollection(new ChunkIterable(this, chunkSize, IterableCollection.makeCollection));
     }
-    chunkWhile(predicateFn, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return new IterableCollection(new ChunkWhileIterable(this, predicateFn, throwOnIndexOverflow, (iterable) => new IterableCollection(iterable)));
+    chunkWhile(predicateFn) {
+        return new IterableCollection(new ChunkWhileIterable(this, predicateFn, IterableCollection.makeCollection));
     }
-    split(chunkAmount, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return new IterableCollection(new SplitIterable(this, chunkAmount, throwOnIndexOverflow, IterableCollection.makeCollection));
+    split(chunkAmount) {
+        return new IterableCollection(new SplitIterable(this, chunkAmount, IterableCollection.makeCollection));
     }
-    partition(predicateFn, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return new IterableCollection(new PartionIterable(this, predicateFn, throwOnIndexOverflow, IterableCollection.makeCollection));
+    partition(predicateFn) {
+        return new IterableCollection(new PartionIterable(this, predicateFn, IterableCollection.makeCollection));
     }
-    sliding(settings) {
-        const { chunkSize, step = chunkSize - 1, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT, } = settings;
-        return new IterableCollection(new SlidingIteralbe(this, chunkSize, step, throwOnIndexOverflow));
+    sliding(chunkSize, step = chunkSize - 1) {
+        return new IterableCollection(new SlidingIteralbe(this, chunkSize, step));
     }
-    groupBy(settings) {
-        return new IterableCollection(new GroupByIterable(this, settings?.selectFn, settings?.throwOnIndexOverflow ??
-            IterableCollection.THROW_ON_NUMBER_LIMIT, (iterable) => new IterableCollection(iterable)));
+    groupBy(selectFn) {
+        return new IterableCollection(new GroupByIterable(this, selectFn, IterableCollection.makeCollection));
     }
-    countBy(settings) {
-        return new IterableCollection(new CountByIterable(this, settings?.selectFn, settings?.throwOnIndexOverflow ??
-            IterableCollection.THROW_ON_NUMBER_LIMIT));
+    countBy(selectFn) {
+        return new IterableCollection(new CountByIterable(this, selectFn));
     }
-    unique(settings) {
-        return new IterableCollection(new UniqueIterable(this, settings?.selectFn, settings?.throwOnIndexOverflow ??
-            IterableCollection.THROW_ON_NUMBER_LIMIT));
+    unique(selectFn) {
+        return new IterableCollection(new UniqueIterable(this, selectFn));
     }
     difference(iterable, mapFn = (item) => item) {
         const differenceCollection = new IterableCollection(iterable);
@@ -406,9 +386,8 @@ export class IterableCollection {
     padEnd(maxLength, fillItems) {
         return new IterableCollection(new PadEndIterable(this, maxLength, fillItems, IterableCollection.makeCollection));
     }
-    slice(settings) {
-        return new IterableCollection(new SliceIterable(this, settings?.start, settings?.end, settings?.throwOnIndexOverflow ??
-            IterableCollection.THROW_ON_NUMBER_LIMIT));
+    slice(start, end) {
+        return new IterableCollection(new SliceIterable(this, start, end));
     }
     prepend(iterable) {
         return new IterableCollection(new MergeIterable(iterable, this));
@@ -416,14 +395,14 @@ export class IterableCollection {
     append(iterable) {
         return new IterableCollection(new MergeIterable(this, iterable));
     }
-    insertBefore(predicateFn, iterable, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return new IterableCollection(new InsertBeforeIterable(this, predicateFn, iterable, throwOnIndexOverflow));
+    insertBefore(predicateFn, iterable) {
+        return new IterableCollection(new InsertBeforeIterable(this, predicateFn, iterable));
     }
-    insertAfter(predicateFn, iterable, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return new IterableCollection(new InsertAfterIterable(this, predicateFn, iterable, throwOnIndexOverflow));
+    insertAfter(predicateFn, iterable) {
+        return new IterableCollection(new InsertAfterIterable(this, predicateFn, iterable));
     }
-    crossJoin(...iterables) {
-        return new IterableCollection(new CrossJoinIterable(this, iterables, IterableCollection.makeCollection));
+    crossJoin(iterable) {
+        return new IterableCollection(new CrossJoinIterable(this, iterable, IterableCollection.makeCollection));
     }
     zip(iterable) {
         return new IterableCollection(new ZipIterable(this, iterable));
@@ -431,90 +410,64 @@ export class IterableCollection {
     sort(comparator) {
         return new IterableCollection(new SortIterable(this, comparator));
     }
-    reverse(settings) {
-        return new IterableCollection(new ReverseIterable(this, settings?.chunkSize ?? IterableCollection.DEFAULT_CHUNK_SIZE, settings?.throwOnIndexOverflow ??
-            IterableCollection.THROW_ON_NUMBER_LIMIT, (iterable) => new IterableCollection(iterable)));
+    reverse(chunkSize = IterableCollection.DEFAULT_CHUNK_SIZE) {
+        return new IterableCollection(new ReverseIterable(this, chunkSize, IterableCollection.makeCollection));
     }
-    shuffle() {
-        return new IterableCollection(new ShuffleIterable(this));
+    shuffle(mathRandom = Math.random) {
+        return new IterableCollection(new ShuffleIterable(this, mathRandom));
     }
-    first(settings) {
+    first(predicateFn) {
         try {
-            return this.firstOr({
-                ...settings,
-                defaultValue: null,
-            });
+            return this.firstOr(null, predicateFn);
         }
         catch (error) {
-            if (error instanceof CollectionError ||
-                error instanceof TypeError) {
+            if (error instanceof CollectionError) {
                 throw error;
             }
             throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
         }
     }
-    firstOr(settings) {
+    firstOr(defaultValue, predicateFn = () => true) {
         try {
-            const throwOnIndexOverflow = settings.throwOnIndexOverflow ??
-                IterableCollection.THROW_ON_NUMBER_LIMIT;
             let index = 0;
-            const predicateFn = settings.predicateFn ?? (() => true);
             for (const item of this) {
-                if (throwOnIndexOverflow && index === Number.MAX_SAFE_INTEGER) {
-                    throw new IndexOverflowError("Index has overflowed");
-                }
                 if (predicateFn(item, index, this)) {
                     return item;
                 }
                 index++;
             }
-            if (typeof settings.defaultValue === "function") {
-                const defaultFn = settings.defaultValue;
-                return defaultFn();
-            }
-            return settings.defaultValue;
+            return simplifyLazyable(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);
         }
     }
-    firstOrFail(settings) {
-        const item = this.first(settings);
+    firstOrFail(predicateFn) {
+        const item = this.first(predicateFn);
         if (item === null) {
-            throw new ItemNotFoundError("Item was not found");
+            throw new ItemNotFoundCollectionError("Item was not found");
         }
         return item;
     }
-    last(settings) {
+    last(predicateFn) {
         try {
-            return this.lastOr({
-                ...settings,
-                defaultValue: null,
-            });
+            return this.lastOr(null, predicateFn);
         }
         catch (error) {
-            if (error instanceof CollectionError ||
-                error instanceof TypeError) {
+            if (error instanceof CollectionError) {
                 throw error;
             }
             throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
         }
     }
-    lastOr(settings) {
+    lastOr(defaultValue, predicateFn = () => true) {
         try {
-            const throwOnIndexOverflow = settings.throwOnIndexOverflow ??
-                IterableCollection.THROW_ON_NUMBER_LIMIT;
             let index = 0;
-            const predicateFn = settings.predicateFn ?? (() => true);
             let matchedItem = null;
             for (const item of this) {
-                if (throwOnIndexOverflow && index === Number.MAX_SAFE_INTEGER) {
-                    throw new IndexOverflowError("Index has overflowed");
-                }
                 if (predicateFn(item, index, this)) {
                     matchedItem = item;
                 }
@@ -523,124 +476,99 @@ export class IterableCollection {
             if (matchedItem) {
                 return matchedItem;
             }
-            if (typeof settings.defaultValue === "function") {
-                const defaultFn = settings.defaultValue;
-                return defaultFn();
-            }
-            return settings.defaultValue;
+            return simplifyLazyable(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);
         }
     }
-    lastOrFail(settings) {
-        const item = this.last(settings);
+    lastOrFail(predicateFn) {
+        const item = this.last(predicateFn);
         if (item === null) {
-            throw new ItemNotFoundError("Item was not found");
+            throw new ItemNotFoundCollectionError("Item was not found");
         }
         return item;
     }
-    before(predicateFn, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return this.beforeOr(null, predicateFn, throwOnIndexOverflow);
+    before(predicateFn) {
+        return this.beforeOr(null, predicateFn);
     }
-    beforeOr(defaultValue, predicateFn, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+    beforeOr(defaultValue, predicateFn) {
         try {
             let beforeItem = null, index = 0;
             for (const item of this) {
-                if (throwOnIndexOverflow && index === Number.MAX_SAFE_INTEGER) {
-                    throw new IndexOverflowError("Index has overflowed");
-                }
                 if (predicateFn(item, index, this) && beforeItem) {
                     return beforeItem;
                 }
                 index++;
                 beforeItem = item;
             }
-            if (typeof defaultValue === "function") {
-                const defaultFn = defaultValue;
-                return defaultFn();
-            }
-            return defaultValue;
+            return simplifyLazyable(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);
         }
     }
-    beforeOrFail(predicateFn, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
-        const item = this.before(predicateFn, throwOnIndexOverflow);
+    beforeOrFail(predicateFn) {
+        const item = this.before(predicateFn);
         if (item === null) {
-            throw new ItemNotFoundError("Item was not found");
+            throw new ItemNotFoundCollectionError("Item was not found");
         }
         return item;
     }
-    after(predicateFn, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return this.afterOr(null, predicateFn, throwOnIndexOverflow);
+    after(predicateFn) {
+        return this.afterOr(null, predicateFn);
     }
-    afterOr(defaultValue, predicateFn, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+    afterOr(defaultValue, predicateFn) {
         try {
             let hasMatched = false, index = 0;
             for (const item of this) {
                 if (hasMatched) {
                     return item;
                 }
-                if (throwOnIndexOverflow && index === Number.MAX_SAFE_INTEGER) {
-                    throw new IndexOverflowError("Index has overflowed");
-                }
                 hasMatched = predicateFn(item, index, this);
                 index++;
             }
-            if (typeof defaultValue === "function") {
-                const defaultFn = defaultValue;
-                return defaultFn();
-            }
-            return defaultValue;
+            return simplifyLazyable(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);
         }
     }
-    afterOrFail(predicateFn, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
-        const item = this.after(predicateFn, throwOnIndexOverflow);
+    afterOrFail(predicateFn) {
+        const item = this.after(predicateFn);
         if (item === null) {
-            throw new ItemNotFoundError("Item was not found");
+            throw new ItemNotFoundCollectionError("Item was not found");
         }
         return item;
     }
-    sole(predicateFn, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+    sole(predicateFn) {
         try {
             let index = 0, matchedItem = null;
             for (const item of this) {
-                if (throwOnIndexOverflow && index === Number.MAX_SAFE_INTEGER) {
-                    throw new IndexOverflowError("Index has overflowed");
-                }
                 if (predicateFn(item, index, this)) {
                     if (matchedItem !== null) {
-                        throw new MultipleItemsFoundError("Multiple items were found");
+                        throw new MultipleItemsFoundCollectionError("Multiple items were found");
                     }
                     matchedItem = item;
                 }
                 index++;
             }
             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);
@@ -649,13 +577,10 @@ export class IterableCollection {
     nth(step) {
         return this.filter((_item, index) => index % step === 0);
     }
-    count(predicateFn, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+    count(predicateFn) {
         try {
             let size = 0;
             for (const item of this) {
-                if (throwOnIndexOverflow && size === Number.MAX_SAFE_INTEGER) {
-                    throw new IndexOverflowError("Size has overflowed");
-                }
                 if (predicateFn(item, size, this)) {
                     size++;
                 }
@@ -663,15 +588,14 @@ export class IterableCollection {
             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);
         }
     }
-    size(throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return this.count(() => true, throwOnIndexOverflow);
+    size() {
+        return this.count(() => true);
     }
     isEmpty() {
         try {
@@ -681,8 +605,7 @@ export class IterableCollection {
             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);
@@ -691,13 +614,10 @@ export class IterableCollection {
     isNotEmpty() {
         return !this.isEmpty();
     }
-    searchFirst(predicateFn, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+    searchFirst(predicateFn) {
         try {
             let index = 0;
             for (const item of this) {
-                if (throwOnIndexOverflow && index === Number.MAX_SAFE_INTEGER) {
-                    throw new IndexOverflowError("Index has overflowed");
-                }
                 if (predicateFn(item, index, this)) {
                     return index;
                 }
@@ -706,21 +626,17 @@ export class IterableCollection {
             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);
         }
     }
-    searchLast(predicateFn, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+    searchLast(predicateFn) {
         try {
             let index = 0;
             let matchedIndex = -1;
             for (const item of this) {
-                if (throwOnIndexOverflow && index === Number.MAX_SAFE_INTEGER) {
-                    throw new IndexOverflowError("Index has overflowed");
-                }
                 if (predicateFn(item, index, this)) {
                     matchedIndex = index;
                 }
@@ -729,27 +645,22 @@ export class IterableCollection {
             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);
         }
     }
-    forEach(callback, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+    forEach(callback) {
         try {
             let index = 0;
             for (const item of this) {
-                if (throwOnIndexOverflow && index === Number.MAX_SAFE_INTEGER) {
-                    throw new IndexOverflowError("Index has overflowed");
-                }
                 callback(item, index, this);
                 index++;
             }
         }
         catch (error) {
-            if (error instanceof CollectionError ||
-                error instanceof TypeError) {
+            if (error instanceof CollectionError) {
                 throw error;
             }
             throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
@@ -760,8 +671,7 @@ export class IterableCollection {
             return [...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);