@daiso-tech/core 0.1.4 → 0.2.0

package/dist/esm/collection/list-collection/list-collection.js

@@ -1,5 +1,6 @@
 import { isIterable } from "../../collection/_shared";
-import { CollectionError, ItemNotFoundError, MultipleItemsFoundError, UnexpectedCollectionError, } from "../../contracts/collection/_module";
+import { CollectionError, ItemNotFoundCollectionError, MultipleItemsFoundCollectionError, UnexpectedCollectionError, TypeCollectionError, EmptyCollectionError, } from "../../contracts/collection/_module";
+import { simplifyLazyable } from "../../_shared/utilities";
 export class ListCollection {
     array;
     constructor(iterable = []) {
@@ -11,25 +12,23 @@ export class ListCollection {
     toIterator() {
         return this[Symbol.iterator]();
     }
-    entries(_throwOnIndexOverflow) {
+    entries() {
         try {
             return new ListCollection(this.array.entries());
         }
         catch (error) {
-            if (error instanceof CollectionError ||
-                error instanceof TypeError) {
+            if (error instanceof CollectionError) {
                 throw error;
             }
             throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
         }
     }
-    keys(_throwOnIndexOverflow) {
+    keys() {
         try {
             return new ListCollection(this.array.keys());
         }
         catch (error) {
-            if (error instanceof CollectionError ||
-                error instanceof TypeError) {
+            if (error instanceof CollectionError) {
                 throw error;
             }
             throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
@@ -38,89 +37,81 @@ export class ListCollection {
     values() {
         return new ListCollection(this);
     }
-    filter(predicateFn, _throwOnIndexOverflow) {
+    filter(predicateFn) {
         try {
             return new ListCollection(this.array.filter((item, index) => predicateFn(item, index, 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);
         }
     }
-    reject(predicateFn, _throwOnIndexOverflow) {
+    reject(predicateFn) {
         try {
             return new ListCollection(this.array.filter((item, index) => !predicateFn(item, index, 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);
         }
     }
-    map(mapFn, _throwOnIndexOverflow) {
+    map(mapFn) {
         try {
             return new ListCollection(this.array.map((item, index) => mapFn(item, index, 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);
         }
     }
-    reduce(settings) {
+    reduce(reduceFn, initialValue) {
         try {
-            if (settings.initialValue === undefined && this.isEmpty()) {
-                throw new TypeError("Reduce of empty array must be inputed a initial value");
+            if (initialValue === undefined && this.isEmpty()) {
+                throw new TypeCollectionError("Reduce of empty array must be inputed a initial value");
             }
-            if (settings.initialValue !== undefined) {
-                return this.array.reduce((initialValue, item, index) => settings.reduceFn(initialValue, item, index, this), settings.initialValue);
+            if (initialValue !== undefined) {
+                return this.array.reduce((initialValue, item, index) => reduceFn(initialValue, item, index, this), initialValue);
             }
             return this.array.reduce((initialValue, item, index) => {
-                const reduce = settings.reduceFn;
+                const reduce = reduceFn;
                 return reduce(initialValue, item, index, 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);
         }
     }
-    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;
-                },
-            });
+            for (const item of this) {
+                if (typeof item !== "string") {
+                    throw new TypeCollectionError("Item type is invalid must be string");
+                }
+            }
+            return this.array.join(separator);
         }
         catch (error) {
-            if (error instanceof CollectionError ||
-                error instanceof TypeError) {
+            if (error instanceof CollectionError) {
                 throw error;
             }
             throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
         }
     }
     collapse() {
-        const items = [];
         try {
+            const items = [];
             for (const item of this.array) {
                 if (isIterable(item)) {
-                    items.push(...items);
+                    items.push(...item);
                 }
                 else {
                     items.push(item);
@@ -129,28 +120,26 @@ export class ListCollection {
             return new ListCollection(items);
         }
         catch (error) {
-            if (error instanceof CollectionError ||
-                error instanceof TypeError) {
+            if (error instanceof CollectionError) {
                 throw error;
             }
             throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
         }
     }
-    flatMap(mapFn, _throwOnIndexOverflow) {
+    flatMap(mapFn) {
         try {
             return new ListCollection(this.array.flatMap((item, index) => [
                 ...mapFn(item, index, 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);
         }
     }
-    update(predicateFn, mapFn, _throwOnIndexOverflow) {
+    change(predicateFn, mapFn) {
         try {
             return new ListCollection(this.array.map((item, index) => {
                 if (predicateFn(item, index, this)) {
@@ -160,39 +149,43 @@ export class ListCollection {
             }));
         }
         catch (error) {
-            if (error instanceof CollectionError ||
-                error instanceof TypeError) {
+            if (error instanceof CollectionError) {
                 throw error;
             }
             throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
         }
     }
-    page(settings) {
-        const { page, pageSize } = settings;
+    page(page, pageSize) {
         if (page < 0) {
             return this.skip(page * pageSize).take(pageSize);
         }
-        return this.skip((page - 1) * pageSize).take(page * pageSize);
+        return this.skip((page - 1) * pageSize).take(pageSize);
     }
     sum() {
-        return this.reduce({
-            reduceFn: (sum, item) => {
-                if (typeof item !== "number") {
-                    throw new TypeError("Item type is invalid must be number");
-                }
-                return sum + item;
-            },
-            initialValue: 0,
-        });
+        if (this.isEmpty()) {
+            throw new EmptyCollectionError("Collection is empty therby operation cannot be performed");
+        }
+        return this.reduce((sum, item) => {
+            if (typeof item !== "number") {
+                throw new TypeCollectionError("Item type is invalid must be number");
+            }
+            return sum + item;
+        }, 0);
     }
     average() {
+        if (this.isEmpty()) {
+            throw new EmptyCollectionError("Collection is empty therby operation cannot be performed");
+        }
         return (this.sum() / this.size());
     }
-    median(_throwOnIndexOverflow) {
+    median() {
         try {
+            if (this.isEmpty()) {
+                throw new EmptyCollectionError("Collection is empty therby operation cannot be performed");
+            }
             const nbrs = this.array.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;
             }), index = Math.floor(this.array.length / 2), isEven = this.array.length % 2 === 0, a = nbrs[index];
@@ -209,8 +202,7 @@ export class ListCollection {
             return a;
         }
         catch (error) {
-            if (error instanceof CollectionError ||
-                error instanceof TypeError) {
+            if (error instanceof CollectionError) {
                 throw error;
             }
             throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
@@ -218,10 +210,13 @@ export class ListCollection {
     }
     min() {
         try {
+            if (this.isEmpty()) {
+                throw new EmptyCollectionError("Collection is empty therby operation cannot be performed");
+            }
             let min = 0;
             for (const item of this.array) {
                 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;
@@ -233,8 +228,7 @@ export class ListCollection {
             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);
@@ -242,10 +236,13 @@ export class ListCollection {
     }
     max() {
         try {
+            if (this.isEmpty()) {
+                throw new EmptyCollectionError("Collection is empty therby operation cannot be performed");
+            }
             let max = 0;
             for (const item of this.array) {
                 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;
@@ -257,62 +254,60 @@ export class ListCollection {
             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) {
+    percentage(predicateFn) {
         try {
+            if (this.isEmpty()) {
+                throw new EmptyCollectionError("Collection is empty therby operation cannot be performed");
+            }
             return (this.count(predicateFn) / this.size()) * 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) {
+    some(predicateFn) {
         try {
             return this.array.some((item, index) => predicateFn(item, index, 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);
         }
     }
-    every(predicateFn, _throwOnIndexOverflow) {
+    every(predicateFn) {
         try {
             return this.array.every((item, index) => predicateFn(item, index, 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);
         }
     }
-    take(limit, _throwOnIndexOverflow) {
+    take(limit) {
         try {
             return new ListCollection(this.array.slice(0, limit));
         }
         catch (error) {
-            if (error instanceof CollectionError ||
-                error instanceof TypeError) {
+            if (error instanceof CollectionError) {
                 throw error;
             }
             throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
         }
     }
-    takeUntil(predicateFn, _throwOnIndexOverflow) {
+    takeUntil(predicateFn) {
         try {
             const items = [];
             for (const [index, item] of this.array.entries()) {
@@ -324,38 +319,35 @@ export class ListCollection {
             return new ListCollection(items);
         }
         catch (error) {
-            if (error instanceof CollectionError ||
-                error instanceof TypeError) {
+            if (error instanceof CollectionError) {
                 throw error;
             }
             throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
         }
     }
-    takeWhile(predicateFn, _throwOnIndexOverflow) {
+    takeWhile(predicateFn) {
         try {
             return this.takeUntil((...arguments_) => !predicateFn(...arguments_));
         }
         catch (error) {
-            if (error instanceof CollectionError ||
-                error instanceof TypeError) {
+            if (error instanceof CollectionError) {
                 throw error;
             }
             throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
         }
     }
-    skip(offset, _throwOnIndexOverflow) {
+    skip(offset) {
         try {
             return new ListCollection(this.array.slice(offset));
         }
         catch (error) {
-            if (error instanceof CollectionError ||
-                error instanceof TypeError) {
+            if (error instanceof CollectionError) {
                 throw error;
             }
             throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
         }
     }
-    skipUntil(predicateFn, _throwOnIndexOverflow) {
+    skipUntil(predicateFn) {
         try {
             let hasMatched = false;
             const items = [];
@@ -370,20 +362,18 @@ export class ListCollection {
             return new ListCollection(items);
         }
         catch (error) {
-            if (error instanceof CollectionError ||
-                error instanceof TypeError) {
+            if (error instanceof CollectionError) {
                 throw error;
             }
             throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
         }
     }
-    skipWhile(predicateFn, _throwOnIndexOverflow) {
+    skipWhile(predicateFn) {
         try {
             return this.skipUntil((...arguments_) => !predicateFn(...arguments_));
         }
         catch (error) {
-            if (error instanceof CollectionError ||
-                error instanceof TypeError) {
+            if (error instanceof CollectionError) {
                 throw error;
             }
             throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
@@ -397,8 +387,7 @@ export class ListCollection {
             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);
@@ -409,8 +398,7 @@ export class ListCollection {
             return this.when(this.isEmpty(), callback);
         }
         catch (error) {
-            if (error instanceof CollectionError ||
-                error instanceof TypeError) {
+            if (error instanceof CollectionError) {
                 throw error;
             }
             throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
@@ -421,8 +409,7 @@ export class ListCollection {
             return this.when(!condition, callback);
         }
         catch (error) {
-            if (error instanceof CollectionError ||
-                error instanceof TypeError) {
+            if (error instanceof CollectionError) {
                 throw error;
             }
             throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
@@ -433,8 +420,7 @@ export class ListCollection {
             return this.when(this.isNotEmpty(), callback);
         }
         catch (error) {
-            if (error instanceof CollectionError ||
-                error instanceof TypeError) {
+            if (error instanceof CollectionError) {
                 throw error;
             }
             throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
@@ -445,8 +431,7 @@ export class ListCollection {
             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);
@@ -458,8 +443,7 @@ export class ListCollection {
             return new ListCollection(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);
@@ -474,14 +458,13 @@ export class ListCollection {
             return new ListCollection(chunks);
         }
         catch (error) {
-            if (error instanceof CollectionError ||
-                error instanceof TypeError) {
+            if (error instanceof CollectionError) {
                 throw error;
             }
             throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
         }
     }
-    chunkWhile(predicateFn, _throwOnIndexOverflow) {
+    chunkWhile(predicateFn) {
         try {
             let currentChunk = new ListCollection([]);
             const chunks = [];
@@ -501,14 +484,13 @@ export class ListCollection {
             return new ListCollection(chunks);
         }
         catch (error) {
-            if (error instanceof CollectionError ||
-                error instanceof TypeError) {
+            if (error instanceof CollectionError) {
                 throw error;
             }
             throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
         }
     }
-    split(chunkAmount, _throwOnIndexOverflow) {
+    split(chunkAmount) {
         try {
             const size = this.size(), minChunkSize = Math.floor(size / chunkAmount), restSize = size % chunkAmount, chunkSizes = Array.from({
                 length: chunkAmount,
@@ -529,14 +511,13 @@ export class ListCollection {
             return new ListCollection(chunks);
         }
         catch (error) {
-            if (error instanceof CollectionError ||
-                error instanceof TypeError) {
+            if (error instanceof CollectionError) {
                 throw error;
             }
             throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
         }
     }
-    partition(predicateFn, _throwOnIndexOverflow) {
+    partition(predicateFn) {
         try {
             const chunkA = [], chunkB = [];
             for (const [index, item] of this.array.entries()) {
@@ -553,16 +534,14 @@ export class ListCollection {
             ]);
         }
         catch (error) {
-            if (error instanceof CollectionError ||
-                error instanceof TypeError) {
+            if (error instanceof CollectionError) {
                 throw error;
             }
             throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
         }
     }
-    sliding(settings) {
+    sliding(chunkSize, step = chunkSize - 1) {
         try {
-            const { chunkSize, step = chunkSize - 1 } = settings;
             let chunks = new ListCollection([]);
             if (step <= 0) {
                 return new ListCollection([]);
@@ -570,12 +549,7 @@ export class ListCollection {
             for (let index = 0; index < this.size(); index += step) {
                 const start = index;
                 const end = index + chunkSize;
-                chunks = chunks.append([
-                    this.slice({
-                        start,
-                        end,
-                    }),
-                ]);
+                chunks = chunks.append([this.slice(start, end)]);
                 if (end >= this.size()) {
                     break;
                 }
@@ -583,18 +557,17 @@ export class ListCollection {
             return chunks;
         }
         catch (error) {
-            if (error instanceof CollectionError ||
-                error instanceof TypeError) {
+            if (error instanceof CollectionError) {
                 throw error;
             }
             throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
         }
     }
-    groupBy(settings) {
+    groupBy(selectFn = (item) => item) {
         try {
-            const map = new Map(), callback = (settings?.selectFn ?? ((item) => item));
+            const map = new Map();
             for (const [index, item] of this.array.entries()) {
-                const key = callback(item, index, this);
+                const key = selectFn(item, index, this);
                 let collection = map.get(key);
                 if (collection === undefined) {
                     collection = new ListCollection([]);
@@ -605,18 +578,17 @@ export class ListCollection {
             return new ListCollection(map);
         }
         catch (error) {
-            if (error instanceof CollectionError ||
-                error instanceof TypeError) {
+            if (error instanceof CollectionError) {
                 throw error;
             }
             throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
         }
     }
-    countBy(settings) {
+    countBy(selectFn = (item) => item) {
         try {
-            const map = new Map(), callback = (settings?.selectFn ?? ((item) => item));
+            const map = new Map();
             for (const [index, item] of this.array.entries()) {
-                const key = callback(item, index, this);
+                const key = selectFn(item, index, this);
                 if (!map.has(key)) {
                     map.set(key, 0);
                 }
@@ -628,18 +600,17 @@ export class ListCollection {
             return new ListCollection(map);
         }
         catch (error) {
-            if (error instanceof CollectionError ||
-                error instanceof TypeError) {
+            if (error instanceof CollectionError) {
                 throw error;
             }
             throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
         }
     }
-    unique(settings) {
+    unique(selectFn = (item) => item) {
         try {
-            const set = new Set([]), callback = (settings?.selectFn ?? ((item) => item)), items = [];
+            const set = new Set([]), items = [];
             for (const [index, item] of this.array.entries()) {
-                const item_ = callback(item, index, this);
+                const item_ = selectFn(item, index, this);
                 if (!set.has(item_)) {
                     items.push(item);
                 }
@@ -648,8 +619,7 @@ export class ListCollection {
             return new ListCollection(items);
         }
         catch (error) {
-            if (error instanceof CollectionError ||
-                error instanceof TypeError) {
+            if (error instanceof CollectionError) {
                 throw error;
             }
             throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
@@ -666,8 +636,7 @@ export class ListCollection {
             });
         }
         catch (error) {
-            if (error instanceof CollectionError ||
-                error instanceof TypeError) {
+            if (error instanceof CollectionError) {
                 throw error;
             }
             throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
@@ -676,14 +645,13 @@ export class ListCollection {
     repeat(amount) {
         try {
             let collection = new ListCollection([]);
-            for (let index = 0; index < amount - 1; index++) {
+            for (let index = 0; index < amount; index++) {
                 collection = collection.append(this);
             }
             return collection;
         }
         catch (error) {
-            if (error instanceof CollectionError ||
-                error instanceof TypeError) {
+            if (error instanceof CollectionError) {
                 throw error;
             }
             throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
@@ -709,8 +677,7 @@ export class ListCollection {
             return new ListCollection(resultItemsArray);
         }
         catch (error) {
-            if (error instanceof CollectionError ||
-                error instanceof TypeError) {
+            if (error instanceof CollectionError) {
                 throw error;
             }
             throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
@@ -736,20 +703,18 @@ export class ListCollection {
             return new ListCollection(resultItemsArray);
         }
         catch (error) {
-            if (error instanceof CollectionError ||
-                error instanceof TypeError) {
+            if (error instanceof CollectionError) {
                 throw error;
             }
             throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
         }
     }
-    slice(settings) {
+    slice(start, end) {
         try {
-            return new ListCollection(this.array.slice(settings?.start, settings?.end));
+            return new ListCollection(this.array.slice(start, end));
         }
         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 +725,7 @@ export class ListCollection {
             return new ListCollection([...iterable, ...this.array]);
         }
         catch (error) {
-            if (error instanceof CollectionError ||
-                error instanceof TypeError) {
+            if (error instanceof CollectionError) {
                 throw error;
             }
             throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
@@ -772,14 +736,13 @@ export class ListCollection {
             return new ListCollection([...this.array, ...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);
         }
     }
-    insertBefore(predicateFn, iterable, _throwOnIndexOverflow) {
+    insertBefore(predicateFn, iterable) {
         try {
             const index = this.array.findIndex((item, index) => predicateFn(item, index, this));
             if (index === -1) {
@@ -790,14 +753,13 @@ export class ListCollection {
             return new ListCollection(newArray);
         }
         catch (error) {
-            if (error instanceof CollectionError ||
-                error instanceof TypeError) {
+            if (error instanceof CollectionError) {
                 throw error;
             }
             throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
         }
     }
-    insertAfter(predicateFn, iterable, _throwOnIndexOverflow) {
+    insertAfter(predicateFn, iterable) {
         try {
             const index = this.array.findIndex((item, index) => predicateFn(item, index, this));
             if (index === -1) {
@@ -811,35 +773,39 @@ export class ListCollection {
             ]);
         }
         catch (error) {
-            if (error instanceof CollectionError ||
-                error instanceof TypeError) {
+            if (error instanceof CollectionError) {
                 throw error;
             }
             throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
         }
     }
-    crossJoin(...iterables) {
+    crossJoin(iterable) {
         try {
-            return new ListCollection([
-                this,
-                ...iterables.map((iterable) => new ListCollection(iterable)),
-            ]).reduce({
-                reduceFn: (a, b) => {
-                    return a
-                        .map((x) => b.map((y) => {
-                        return x.append([y]);
-                    }))
-                        .reduce({
-                        reduceFn: (c, b) => c.append(b),
-                        initialValue: new ListCollection([]),
+            const array = [
+                [...this],
+                [...iterable],
+            ]
+                .reduce((a, b) => {
+                return a
+                    .map((x) => {
+                    return b.map((y) => {
+                        return [...x, y];
                     });
-                },
-                initialValue: new ListCollection([new ListCollection([])]),
+                })
+                    .reduce((c, b) => [...c, ...b], []);
+            }, [[]])
+                .map((combination) => {
+                return combination.reduce((a, b) => {
+                    return [
+                        ...a,
+                        ...(isIterable(b) ? b : [b]),
+                    ];
+                }, []);
             });
+            return new ListCollection(array);
         }
         catch (error) {
-            if (error instanceof CollectionError ||
-                error instanceof TypeError) {
+            if (error instanceof CollectionError) {
                 throw error;
             }
             throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
@@ -863,8 +829,7 @@ export class ListCollection {
             return new ListCollection(items);
         }
         catch (error) {
-            if (error instanceof CollectionError ||
-                error instanceof TypeError) {
+            if (error instanceof CollectionError) {
                 throw error;
             }
             throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
@@ -875,30 +840,28 @@ export class ListCollection {
             return new ListCollection(this.array.sort(comparator));
         }
         catch (error) {
-            if (error instanceof CollectionError ||
-                error instanceof TypeError) {
+            if (error instanceof CollectionError) {
                 throw error;
             }
             throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
         }
     }
-    reverse(_settings) {
+    reverse(_chunkSize) {
         try {
             return new ListCollection([...this.array].reverse());
         }
         catch (error) {
-            if (error instanceof CollectionError ||
-                error instanceof TypeError) {
+            if (error instanceof CollectionError) {
                 throw error;
             }
             throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
         }
     }
-    shuffle() {
+    shuffle(mathRandom = Math.random) {
         try {
             const newArray = [...this.array];
             for (let i = newArray.length - 1; i > 0; i--) {
-                const j = Math.floor(Math.random() * (i + 1));
+                const j = Math.floor(mathRandom() * (i + 1));
                 const temp = newArray[i];
                 if (newArray[j] !== undefined) {
                     newArray[i] = newArray[j];
@@ -910,34 +873,28 @@ export class ListCollection {
             return new ListCollection(newArray);
         }
         catch (error) {
-            if (error instanceof CollectionError ||
-                error instanceof TypeError) {
+            if (error instanceof CollectionError) {
                 throw error;
             }
             throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
         }
     }
-    first(settings) {
+    first(predicateFn) {
         try {
-            return this.firstOr({
-                defaultValue: null,
-                ...settings,
-            });
+            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) {
         try {
-            const { predicateFn: filter } = settings;
-            if (filter) {
+            if (predicateFn) {
                 for (const [index, item] of this.array.entries()) {
-                    if (filter(item, index, this)) {
+                    if (predicateFn(item, index, this)) {
                         return item;
                     }
                 }
@@ -948,59 +905,47 @@ export class ListCollection {
                     return firstItem;
                 }
             }
-            const { defaultValue } = settings;
-            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);
         }
     }
-    firstOrFail(settings) {
+    firstOrFail(predicateFn) {
         try {
-            const item = this.first(settings);
+            const item = this.first(predicateFn);
             if (item === null) {
-                throw new ItemNotFoundError("Item was not found");
+                throw new ItemNotFoundCollectionError("Item was not found");
             }
             return item;
         }
         catch (error) {
-            if (error instanceof CollectionError ||
-                error instanceof TypeError) {
+            if (error instanceof CollectionError) {
                 throw error;
             }
             throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
         }
     }
-    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) {
         try {
-            const { predicateFn: filter } = settings;
-            if (filter) {
+            if (predicateFn) {
                 let matchedItem = null;
                 for (const [index, item] of this.array.entries()) {
-                    if (filter(item, index, this)) {
+                    if (predicateFn(item, index, this)) {
                         matchedItem = item;
                     }
                 }
@@ -1014,50 +959,42 @@ export class ListCollection {
                     return lastItem;
                 }
             }
-            const { defaultValue } = settings;
-            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);
         }
     }
-    lastOrFail(settings) {
+    lastOrFail(predicateFn) {
         try {
-            const item = this.last(settings);
+            const item = this.last(predicateFn);
             if (item === null) {
-                throw new ItemNotFoundError("Item was not found");
+                throw new ItemNotFoundCollectionError("Item was not found");
             }
             return item;
         }
         catch (error) {
-            if (error instanceof CollectionError ||
-                error instanceof TypeError) {
+            if (error instanceof CollectionError) {
                 throw error;
             }
             throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
         }
     }
-    before(predicateFn, _throwOnIndexOverflow) {
+    before(predicateFn) {
         try {
             return this.beforeOr(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);
         }
     }
-    beforeOr(defaultValue, predicateFn, _throwOnIndexOverflow) {
+    beforeOr(defaultValue, predicateFn) {
         try {
             for (const [index, item] of this.array.entries()) {
                 const beforeItem = this.array[index - 1];
@@ -1066,49 +1003,42 @@ export class ListCollection {
                     return beforeItem;
                 }
             }
-            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) {
+    beforeOrFail(predicateFn) {
         try {
             const item = this.before(predicateFn);
             if (item === null) {
-                throw new ItemNotFoundError("Item was not found");
+                throw new ItemNotFoundCollectionError("Item was not found");
             }
             return item;
         }
         catch (error) {
-            if (error instanceof CollectionError ||
-                error instanceof TypeError) {
+            if (error instanceof CollectionError) {
                 throw error;
             }
             throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
         }
     }
-    after(predicateFn, _throwOnIndexOverflow) {
+    after(predicateFn) {
         try {
             return this.afterOr(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);
         }
     }
-    afterOr(defaultValue, predicateFn, _throwOnIndexOverflow) {
+    afterOr(defaultValue, predicateFn) {
         try {
             for (const [index, item] of this.array.entries()) {
                 const beforeItem = this.array[index + 1];
@@ -1117,37 +1047,31 @@ export class ListCollection {
                     return beforeItem;
                 }
             }
-            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) {
+    afterOrFail(predicateFn) {
         try {
             const item = this.after(predicateFn);
             if (item === null) {
-                throw new ItemNotFoundError("Item was not found");
+                throw new ItemNotFoundCollectionError("Item was not found");
             }
             return item;
         }
         catch (error) {
-            if (error instanceof CollectionError ||
-                error instanceof TypeError) {
+            if (error instanceof CollectionError) {
                 throw error;
             }
             throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
         }
     }
-    sole(predicateFn, _throwOnIndexOverflow) {
+    sole(predicateFn) {
         try {
             const matchedItems = [];
             for (const [index, item] of this.array.entries()) {
@@ -1155,18 +1079,17 @@ export class ListCollection {
                     matchedItems.push(item);
                 }
                 if (matchedItems.length > 1) {
-                    throw new MultipleItemsFoundError("Multiple items were found");
+                    throw new MultipleItemsFoundCollectionError("Multiple items were found");
                 }
             }
             const [matchedItem] = matchedItems;
             if (matchedItem === undefined) {
-                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);
@@ -1177,32 +1100,29 @@ export class ListCollection {
             return this.filter((_item, index) => index % step === 0);
         }
         catch (error) {
-            if (error instanceof CollectionError ||
-                error instanceof TypeError) {
+            if (error instanceof CollectionError) {
                 throw error;
             }
             throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
         }
     }
-    count(predicateFn, _throwOnIndexOverflow) {
+    count(predicateFn) {
         try {
             return this.filter(predicateFn).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) {
+    size() {
         try {
             return this.array.length;
         }
         catch (error) {
-            if (error instanceof CollectionError ||
-                error instanceof TypeError) {
+            if (error instanceof CollectionError) {
                 throw error;
             }
             throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
@@ -1213,8 +1133,7 @@ export class ListCollection {
             return this.array.length === 0;
         }
         catch (error) {
-            if (error instanceof CollectionError ||
-                error instanceof TypeError) {
+            if (error instanceof CollectionError) {
                 throw error;
             }
             throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
@@ -1225,26 +1144,24 @@ export class ListCollection {
             return this.array.length !== 0;
         }
         catch (error) {
-            if (error instanceof CollectionError ||
-                error instanceof TypeError) {
+            if (error instanceof CollectionError) {
                 throw error;
             }
             throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
         }
     }
-    searchFirst(predicateFn, _throwOnIndexOverflow) {
+    searchFirst(predicateFn) {
         try {
             return this.array.findIndex((item, index) => predicateFn(item, index, 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);
         }
     }
-    searchLast(predicateFn, _throwOnIndexOverflow) {
+    searchLast(predicateFn) {
         try {
             let matchedIndex = -1;
             for (const [index, item] of this.array.entries()) {
@@ -1255,22 +1172,20 @@ export class ListCollection {
             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) {
+    forEach(callback) {
         try {
             for (const [index, item] of this.array.entries()) {
                 callback(item, index, 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);
@@ -1281,8 +1196,7 @@ export class ListCollection {
             return [...this.array];
         }
         catch (error) {
-            if (error instanceof CollectionError ||
-                error instanceof TypeError) {
+            if (error instanceof CollectionError) {
                 throw error;
             }
             throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);