@daiso-tech/core 0.1.1 → 0.1.3

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

@@ -2,12 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IterableCollection = void 0;
 const _module_1 = require("../../contracts/collection/_module");
-const _module_2 = require("../../collection/iterable-collection/iterable-helpers/_module");
+const _module_2 = require("../../collection/iterable-collection/_shared/_module");
 class IterableCollection {
     iterable;
     static THROW_ON_NUMBER_LIMIT = false;
     static DEFAULT_CHUNK_SIZE = 1024;
-    static makeCollection = (iterable) => {
+    static makeCollection = (iterable = []) => {
         return new IterableCollection(iterable);
     };
     constructor(iterable) {
@@ -25,34 +25,37 @@ class IterableCollection {
             throw new _module_1.UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
         }
     }
-    iterator() {
+    toIterator() {
         return this[Symbol.iterator]();
     }
-    entries(throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return new IterableCollection(new _module_2.EntriesIterable(this, throwOnNumberLimit));
+    entries(throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+        return new IterableCollection(new _module_2.EntriesIterable(this, throwOnIndexOverflow));
     }
-    keys(throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return this.entries(throwOnNumberLimit).map(([key]) => key);
+    keys(throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+        return this.entries(throwOnIndexOverflow).map(([key]) => key);
     }
     values() {
         return this.entries().map(([_key, value]) => value);
     }
-    filter(filter, throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return new IterableCollection(new _module_2.FilterIterable(this, filter, throwOnNumberLimit));
+    filter(predicateFn, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+        return new IterableCollection(new _module_2.FilterIterable(this, predicateFn, throwOnIndexOverflow));
     }
-    map(map, throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return new IterableCollection(new _module_2.MapIterable(this, map, throwOnNumberLimit));
+    reject(predicateFn, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+        return this.filter((...arguments_) => !predicateFn(...arguments_), throwOnIndexOverflow);
+    }
+    map(mapFn, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+        return new IterableCollection(new _module_2.MapIterable(this, mapFn, throwOnIndexOverflow));
     }
     reduce(settings) {
         try {
-            const { reduceFn: reduce, initialValue, throwOnNumberLimit, } = settings;
-            if (initialValue === undefined && this.empty()) {
+            const { reduceFn: reduce, initialValue, throwOnIndexOverflow, } = settings;
+            if (initialValue === undefined && this.isEmpty()) {
                 throw new TypeError("Reduce of empty array must be inputed a initial value");
             }
             if (initialValue !== undefined) {
                 let output = initialValue, index = 0;
                 for (const item of this) {
-                    if (throwOnNumberLimit &&
+                    if (throwOnIndexOverflow &&
                         index === Number.MAX_SAFE_INTEGER) {
                         throw new _module_1.IndexOverflowError("Index has overflowed");
                     }
@@ -64,7 +67,7 @@ class IterableCollection {
             let output = this.firstOrFail(), index = 0, isFirstIteration = true;
             for (const item of this) {
                 if (!isFirstIteration) {
-                    if (throwOnNumberLimit &&
+                    if (throwOnIndexOverflow &&
                         index === Number.MAX_SAFE_INTEGER) {
                         throw new _module_1.IndexOverflowError("Index has overflowed");
                     }
@@ -93,7 +96,7 @@ class IterableCollection {
                     const separator = settings?.seperator ?? ",";
                     return str + separator + item;
                 },
-                throwOnNumberLimit: settings?.throwOnNumberLimit ??
+                throwOnIndexOverflow: settings?.throwOnIndexOverflow ??
                     IterableCollection.THROW_ON_NUMBER_LIMIT,
             });
         }
@@ -108,26 +111,23 @@ class IterableCollection {
     collapse() {
         return new IterableCollection(new _module_2.CollapseIterable(this));
     }
-    flatMap(map, throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return new IterableCollection(new _module_2.FlatMapIterable(this, map, throwOnNumberLimit));
+    flatMap(mapFn, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+        return new IterableCollection(new _module_2.FlatMapIterable(this, mapFn, throwOnIndexOverflow));
     }
-    update(filter, map, throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return new IterableCollection(new _module_2.UpdateIterable(this, filter, map, throwOnNumberLimit));
+    update(predicateFn, mapFn, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+        return new IterableCollection(new _module_2.UpdateIterable(this, predicateFn, mapFn, throwOnIndexOverflow));
     }
     page(settings) {
-        const { page, pageSize, throwOnNumberLimit } = settings;
+        const { page, pageSize, throwOnIndexOverflow } = settings;
         if (page < 0) {
-            return this.skip(page * pageSize, throwOnNumberLimit).take(pageSize, throwOnNumberLimit);
+            return this.skip(page * pageSize, throwOnIndexOverflow).take(pageSize, throwOnIndexOverflow);
         }
-        return this.skip((page - 1) * pageSize, throwOnNumberLimit).take(page * pageSize, throwOnNumberLimit);
+        return this.skip((page - 1) * pageSize, throwOnIndexOverflow).take(page * pageSize, throwOnIndexOverflow);
     }
-    sum(throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+    sum() {
         try {
             let sum = 0;
             for (const item of this) {
-                if (throwOnNumberLimit && sum === Number.MAX_SAFE_INTEGER) {
-                    throw new _module_1.IndexOverflowError("Sum has overflowed");
-                }
                 if (typeof item !== "number") {
                     throw new TypeError("Item type is invalid must be number");
                 }
@@ -143,16 +143,10 @@ class IterableCollection {
             throw new _module_1.UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
         }
     }
-    average(throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+    average() {
         try {
             let size = 0, sum = 0;
             for (const item of this) {
-                if (throwOnNumberLimit && sum === Number.MAX_SAFE_INTEGER) {
-                    throw new _module_1.IndexOverflowError("The sum has overflowed");
-                }
-                if (throwOnNumberLimit && size === Number.MAX_SAFE_INTEGER) {
-                    throw new _module_1.IndexOverflowError("The size has overflowed");
-                }
                 if (typeof item !== "number") {
                     throw new TypeError("Item type is invalid must be number");
                 }
@@ -169,11 +163,11 @@ class IterableCollection {
             throw new _module_1.UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
         }
     }
-    median(throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
-        if (this.empty()) {
+    median(throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+        if (this.isEmpty()) {
             return 0;
         }
-        const size = this.size(throwOnNumberLimit);
+        const size = this.size(throwOnIndexOverflow);
         if (size === 0) {
             return 0;
         }
@@ -182,13 +176,13 @@ class IterableCollection {
                 throw new TypeError("Item type is invalid must be number");
             }
             return item;
-        }, throwOnNumberLimit)
+        }, throwOnIndexOverflow)
             .filter((_item, index) => {
             if (isEven) {
                 return index === size / 2 || index === size / 2 - 1;
             }
             return index === Math.floor(size / 2);
-        }, throwOnNumberLimit)
+        }, throwOnIndexOverflow)
             .toArray();
         if (isEven) {
             const [a, b] = items;
@@ -254,17 +248,17 @@ class IterableCollection {
             throw new _module_1.UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
         }
     }
-    percentage(filter, throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+    percentage(predicateFn, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
         try {
-            if (this.empty()) {
+            if (this.isEmpty()) {
                 return 0;
             }
             let part = 0, total = 0;
             for (const item of this) {
-                if (throwOnNumberLimit && total === Number.MAX_SAFE_INTEGER) {
+                if (throwOnIndexOverflow && total === Number.MAX_SAFE_INTEGER) {
                     throw new _module_1.IndexOverflowError("The total amount has overflowed");
                 }
-                if (filter(item, total, this)) {
+                if (predicateFn(item, total, this)) {
                     part++;
                 }
                 total++;
@@ -279,14 +273,14 @@ class IterableCollection {
             throw new _module_1.UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
         }
     }
-    some(filter, throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+    some(predicateFn, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
         try {
             let index = 0;
             for (const item of this) {
-                if (throwOnNumberLimit && index === Number.MAX_SAFE_INTEGER) {
+                if (throwOnIndexOverflow && index === Number.MAX_SAFE_INTEGER) {
                     throw new _module_1.IndexOverflowError("Index has overflowed");
                 }
-                if (filter(item, index, this)) {
+                if (predicateFn(item, index, this)) {
                     return true;
                 }
                 index++;
@@ -301,14 +295,14 @@ class IterableCollection {
             throw new _module_1.UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
         }
     }
-    every(filter, throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+    every(predicateFn, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
         try {
             let index = 0, isTrue = true;
             for (const item of this) {
-                if (throwOnNumberLimit && index === Number.MAX_SAFE_INTEGER) {
+                if (throwOnIndexOverflow && index === Number.MAX_SAFE_INTEGER) {
                     throw new _module_1.IndexOverflowError("Index has overflowed");
                 }
-                isTrue &&= filter(item, index, this);
+                isTrue &&= predicateFn(item, index, this);
                 if (!isTrue) {
                     break;
                 }
@@ -324,35 +318,35 @@ class IterableCollection {
             throw new _module_1.UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
         }
     }
-    take(limit, throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return new IterableCollection(new _module_2.TakeIterable(this, limit, throwOnNumberLimit));
+    take(limit, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+        return new IterableCollection(new _module_2.TakeIterable(this, limit, throwOnIndexOverflow));
     }
-    takeUntil(filter, throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return new IterableCollection(new _module_2.TakeUntilIterable(this, filter, throwOnNumberLimit));
+    takeUntil(predicateFn, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+        return new IterableCollection(new _module_2.TakeUntilIterable(this, predicateFn, throwOnIndexOverflow));
     }
-    takeWhile(filter, throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return this.takeUntil((...arguments_) => !filter(...arguments_), throwOnNumberLimit);
+    takeWhile(predicateFn, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+        return this.takeUntil((...arguments_) => !predicateFn(...arguments_), throwOnIndexOverflow);
     }
-    skip(offset, throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return new IterableCollection(new _module_2.SkipIterable(this, offset, throwOnNumberLimit));
+    skip(offset, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+        return new IterableCollection(new _module_2.SkipIterable(this, offset, throwOnIndexOverflow));
     }
-    skipUntil(filter, throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return new IterableCollection(new _module_2.SkipUntilIterable(this, filter, throwOnNumberLimit));
+    skipUntil(predicateFn, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+        return new IterableCollection(new _module_2.SkipUntilIterable(this, predicateFn, throwOnIndexOverflow));
     }
-    skipWhile(filter, throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return this.skipUntil((...arguments_) => !filter(...arguments_), throwOnNumberLimit);
+    skipWhile(predicateFn, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+        return this.skipUntil((...arguments_) => !predicateFn(...arguments_), throwOnIndexOverflow);
     }
     when(condition, callback) {
         return new IterableCollection(new _module_2.WhenIterable(this, () => condition, callback));
     }
     whenEmpty(callback) {
-        return new IterableCollection(new _module_2.WhenIterable(this, () => this.empty(), callback));
+        return new IterableCollection(new _module_2.WhenIterable(this, () => this.isEmpty(), callback));
     }
     whenNot(condition, callback) {
         return this.when(!condition, callback);
     }
     whenNotEmpty(callback) {
-        return new IterableCollection(new _module_2.WhenIterable(this, () => this.notEmpty(), callback));
+        return new IterableCollection(new _module_2.WhenIterable(this, () => this.isNotEmpty(), callback));
     }
     pipe(callback) {
         try {
@@ -372,37 +366,37 @@ class IterableCollection {
     chunk(chunkSize) {
         return new IterableCollection(new _module_2.ChunkIterable(this, chunkSize, IterableCollection.makeCollection));
     }
-    chunkWhile(filter, throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return new IterableCollection(new _module_2.ChunkWhileIterable(this, filter, throwOnNumberLimit, (iterable) => new IterableCollection(iterable)));
+    chunkWhile(predicateFn, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+        return new IterableCollection(new _module_2.ChunkWhileIterable(this, predicateFn, throwOnIndexOverflow, (iterable) => new IterableCollection(iterable)));
     }
-    split(chunkAmount, throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return new IterableCollection(new _module_2.SplitIterable(this, chunkAmount, throwOnNumberLimit, IterableCollection.makeCollection));
+    split(chunkAmount, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+        return new IterableCollection(new _module_2.SplitIterable(this, chunkAmount, throwOnIndexOverflow, IterableCollection.makeCollection));
     }
-    partition(filter, throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return new IterableCollection(new _module_2.PartionIterable(this, filter, throwOnNumberLimit, IterableCollection.makeCollection));
+    partition(predicateFn, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+        return new IterableCollection(new _module_2.PartionIterable(this, predicateFn, throwOnIndexOverflow, IterableCollection.makeCollection));
     }
     sliding(settings) {
-        const { chunkSize, step = chunkSize - 1, throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT, } = settings;
-        return new IterableCollection(new _module_2.SlidingIteralbe(this, chunkSize, step, throwOnNumberLimit));
+        const { chunkSize, step = chunkSize - 1, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT, } = settings;
+        return new IterableCollection(new _module_2.SlidingIteralbe(this, chunkSize, step, throwOnIndexOverflow));
     }
     groupBy(settings) {
-        return new IterableCollection(new _module_2.GroupByIterable(this, settings?.mapFn, settings?.throwOnNumberLimit ??
+        return new IterableCollection(new _module_2.GroupByIterable(this, settings?.selectFn, settings?.throwOnIndexOverflow ??
             IterableCollection.THROW_ON_NUMBER_LIMIT, (iterable) => new IterableCollection(iterable)));
     }
     countBy(settings) {
-        return new IterableCollection(new _module_2.CountByIterable(this, settings?.mapFn, settings?.throwOnNumberLimit ??
+        return new IterableCollection(new _module_2.CountByIterable(this, settings?.selectFn, settings?.throwOnIndexOverflow ??
             IterableCollection.THROW_ON_NUMBER_LIMIT));
     }
     unique(settings) {
-        return new IterableCollection(new _module_2.UniqueIterable(this, settings?.mapFn, settings?.throwOnNumberLimit ??
+        return new IterableCollection(new _module_2.UniqueIterable(this, settings?.selectFn, settings?.throwOnIndexOverflow ??
             IterableCollection.THROW_ON_NUMBER_LIMIT));
     }
-    difference(iterable, map = (item) => item) {
+    difference(iterable, mapFn = (item) => item) {
         const differenceCollection = new IterableCollection(iterable);
         return this.filter((item, index, collection) => {
             return !differenceCollection.some((matchItem, matchIndex, matchCollection) => {
-                return (map(item, index, collection) ===
-                    map(matchItem, matchIndex, matchCollection));
+                return (mapFn(item, index, collection) ===
+                    mapFn(matchItem, matchIndex, matchCollection));
             });
         });
     }
@@ -416,7 +410,7 @@ class IterableCollection {
         return new IterableCollection(new _module_2.PadEndIterable(this, maxLength, fillItems, IterableCollection.makeCollection));
     }
     slice(settings) {
-        return new IterableCollection(new _module_2.SliceIterable(this, settings?.start, settings?.end, settings?.throwOnNumberLimit ??
+        return new IterableCollection(new _module_2.SliceIterable(this, settings?.start, settings?.end, settings?.throwOnIndexOverflow ??
             IterableCollection.THROW_ON_NUMBER_LIMIT));
     }
     prepend(iterable) {
@@ -425,11 +419,11 @@ class IterableCollection {
     append(iterable) {
         return new IterableCollection(new _module_2.MergeIterable(this, iterable));
     }
-    insertBefore(filter, iterable, throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return new IterableCollection(new _module_2.InsertBeforeIterable(this, filter, iterable, throwOnNumberLimit));
+    insertBefore(predicateFn, iterable, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+        return new IterableCollection(new _module_2.InsertBeforeIterable(this, predicateFn, iterable, throwOnIndexOverflow));
     }
-    insertAfter(filter, iterable, throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return new IterableCollection(new _module_2.InsertAfterIterable(this, filter, iterable, throwOnNumberLimit));
+    insertAfter(predicateFn, iterable, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+        return new IterableCollection(new _module_2.InsertAfterIterable(this, predicateFn, iterable, throwOnIndexOverflow));
     }
     crossJoin(...iterables) {
         return new IterableCollection(new _module_2.CrossJoinIterable(this, iterables, IterableCollection.makeCollection));
@@ -437,11 +431,11 @@ class IterableCollection {
     zip(iterable) {
         return new IterableCollection(new _module_2.ZipIterable(this, iterable));
     }
-    sort(compare) {
-        return new IterableCollection(new _module_2.SortIterable(this, compare));
+    sort(comparator) {
+        return new IterableCollection(new _module_2.SortIterable(this, comparator));
     }
     reverse(settings) {
-        return new IterableCollection(new _module_2.ReverseIterable(this, settings?.chunkSize ?? IterableCollection.DEFAULT_CHUNK_SIZE, settings?.throwOnNumberLimit ??
+        return new IterableCollection(new _module_2.ReverseIterable(this, settings?.chunkSize ?? IterableCollection.DEFAULT_CHUNK_SIZE, settings?.throwOnIndexOverflow ??
             IterableCollection.THROW_ON_NUMBER_LIMIT, (iterable) => new IterableCollection(iterable)));
     }
     shuffle() {
@@ -464,15 +458,15 @@ class IterableCollection {
     }
     firstOr(settings) {
         try {
-            const throwOnNumberLimit = settings.throwOnNumberLimit ??
+            const throwOnIndexOverflow = settings.throwOnIndexOverflow ??
                 IterableCollection.THROW_ON_NUMBER_LIMIT;
             let index = 0;
-            const filter = settings.filterFn ?? (() => true);
+            const predicateFn = settings.predicateFn ?? (() => true);
             for (const item of this) {
-                if (throwOnNumberLimit && index === Number.MAX_SAFE_INTEGER) {
+                if (throwOnIndexOverflow && index === Number.MAX_SAFE_INTEGER) {
                     throw new _module_1.IndexOverflowError("Index has overflowed");
                 }
-                if (filter(item, index, this)) {
+                if (predicateFn(item, index, this)) {
                     return item;
                 }
                 index++;
@@ -515,16 +509,16 @@ class IterableCollection {
     }
     lastOr(settings) {
         try {
-            const throwOnNumberLimit = settings.throwOnNumberLimit ??
+            const throwOnIndexOverflow = settings.throwOnIndexOverflow ??
                 IterableCollection.THROW_ON_NUMBER_LIMIT;
             let index = 0;
-            const filter = settings.filterFn ?? (() => true);
+            const predicateFn = settings.predicateFn ?? (() => true);
             let matchedItem = null;
             for (const item of this) {
-                if (throwOnNumberLimit && index === Number.MAX_SAFE_INTEGER) {
+                if (throwOnIndexOverflow && index === Number.MAX_SAFE_INTEGER) {
                     throw new _module_1.IndexOverflowError("Index has overflowed");
                 }
-                if (filter(item, index, this)) {
+                if (predicateFn(item, index, this)) {
                     matchedItem = item;
                 }
                 index++;
@@ -553,17 +547,17 @@ class IterableCollection {
         }
         return item;
     }
-    before(filter, throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return this.beforeOr(null, filter, throwOnNumberLimit);
+    before(predicateFn, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+        return this.beforeOr(null, predicateFn, throwOnIndexOverflow);
     }
-    beforeOr(defaultValue, filter, throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+    beforeOr(defaultValue, predicateFn, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
         try {
             let beforeItem = null, index = 0;
             for (const item of this) {
-                if (throwOnNumberLimit && index === Number.MAX_SAFE_INTEGER) {
+                if (throwOnIndexOverflow && index === Number.MAX_SAFE_INTEGER) {
                     throw new _module_1.IndexOverflowError("Index has overflowed");
                 }
-                if (filter(item, index, this) && beforeItem) {
+                if (predicateFn(item, index, this) && beforeItem) {
                     return beforeItem;
                 }
                 index++;
@@ -583,27 +577,27 @@ class IterableCollection {
             throw new _module_1.UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
         }
     }
-    beforeOrFail(filter, throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
-        const item = this.before(filter, throwOnNumberLimit);
+    beforeOrFail(predicateFn, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+        const item = this.before(predicateFn, throwOnIndexOverflow);
         if (item === null) {
             throw new _module_1.ItemNotFoundError("Item was not found");
         }
         return item;
     }
-    after(filter, throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return this.afterOr(null, filter, throwOnNumberLimit);
+    after(predicateFn, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+        return this.afterOr(null, predicateFn, throwOnIndexOverflow);
     }
-    afterOr(defaultValue, filter, throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+    afterOr(defaultValue, predicateFn, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
         try {
             let hasMatched = false, index = 0;
             for (const item of this) {
                 if (hasMatched) {
                     return item;
                 }
-                if (throwOnNumberLimit && index === Number.MAX_SAFE_INTEGER) {
+                if (throwOnIndexOverflow && index === Number.MAX_SAFE_INTEGER) {
                     throw new _module_1.IndexOverflowError("Index has overflowed");
                 }
-                hasMatched = filter(item, index, this);
+                hasMatched = predicateFn(item, index, this);
                 index++;
             }
             if (typeof defaultValue === "function") {
@@ -620,21 +614,21 @@ class IterableCollection {
             throw new _module_1.UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
         }
     }
-    afterOrFail(filter, throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
-        const item = this.after(filter, throwOnNumberLimit);
+    afterOrFail(predicateFn, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+        const item = this.after(predicateFn, throwOnIndexOverflow);
         if (item === null) {
             throw new _module_1.ItemNotFoundError("Item was not found");
         }
         return item;
     }
-    sole(filter, throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+    sole(predicateFn, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
         try {
             let index = 0, matchedItem = null;
             for (const item of this) {
-                if (throwOnNumberLimit && index === Number.MAX_SAFE_INTEGER) {
+                if (throwOnIndexOverflow && index === Number.MAX_SAFE_INTEGER) {
                     throw new _module_1.IndexOverflowError("Index has overflowed");
                 }
-                if (filter(item, index, this)) {
+                if (predicateFn(item, index, this)) {
                     if (matchedItem !== null) {
                         throw new _module_1.MultipleItemsFoundError("Multiple items were found");
                     }
@@ -658,14 +652,14 @@ class IterableCollection {
     nth(step) {
         return this.filter((_item, index) => index % step === 0);
     }
-    count(filter, throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+    count(predicateFn, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
         try {
             let size = 0;
             for (const item of this) {
-                if (throwOnNumberLimit && size === Number.MAX_SAFE_INTEGER) {
+                if (throwOnIndexOverflow && size === Number.MAX_SAFE_INTEGER) {
                     throw new _module_1.IndexOverflowError("Size has overflowed");
                 }
-                if (filter(item, size, this)) {
+                if (predicateFn(item, size, this)) {
                     size++;
                 }
             }
@@ -679,10 +673,10 @@ class IterableCollection {
             throw new _module_1.UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
         }
     }
-    size(throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return this.count(() => true, throwOnNumberLimit);
+    size(throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+        return this.count(() => true, throwOnIndexOverflow);
     }
-    empty() {
+    isEmpty() {
         try {
             for (const _ of this) {
                 return false;
@@ -697,17 +691,17 @@ class IterableCollection {
             throw new _module_1.UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
         }
     }
-    notEmpty() {
-        return !this.empty();
+    isNotEmpty() {
+        return !this.isEmpty();
     }
-    search(filter, throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+    searchFirst(predicateFn, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
         try {
             let index = 0;
             for (const item of this) {
-                if (throwOnNumberLimit && index === Number.MAX_SAFE_INTEGER) {
+                if (throwOnIndexOverflow && index === Number.MAX_SAFE_INTEGER) {
                     throw new _module_1.IndexOverflowError("Index has overflowed");
                 }
-                if (filter(item, index, this)) {
+                if (predicateFn(item, index, this)) {
                     return index;
                 }
                 index++;
@@ -722,11 +716,34 @@ class IterableCollection {
             throw new _module_1.UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
         }
     }
-    forEach(callback, throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+    searchLast(predicateFn, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+        try {
+            let index = 0;
+            let matchedIndex = -1;
+            for (const item of this) {
+                if (throwOnIndexOverflow && index === Number.MAX_SAFE_INTEGER) {
+                    throw new _module_1.IndexOverflowError("Index has overflowed");
+                }
+                if (predicateFn(item, index, this)) {
+                    matchedIndex = index;
+                }
+                index++;
+            }
+            return matchedIndex;
+        }
+        catch (error) {
+            if (error instanceof _module_1.CollectionError ||
+                error instanceof TypeError) {
+                throw error;
+            }
+            throw new _module_1.UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
+        }
+    }
+    forEach(callback, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
         try {
             let index = 0;
             for (const item of this) {
-                if (throwOnNumberLimit && index === Number.MAX_SAFE_INTEGER) {
+                if (throwOnIndexOverflow && index === Number.MAX_SAFE_INTEGER) {
                     throw new _module_1.IndexOverflowError("Index has overflowed");
                 }
                 callback(item, index, this);