@daiso-tech/core 0.3.0 → 0.5.0

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

@@ -1,5 +1,5 @@
 import { isIterable } from "../../collection/_shared";
-import { CollectionError, ItemNotFoundCollectionError, MultipleItemsFoundCollectionError, UnexpectedCollectionError, TypeCollectionError, EmptyCollectionError, } from "../../contracts/collection/_module";
+import { ItemNotFoundCollectionError, MultipleItemsFoundCollectionError, UnexpectedCollectionError, TypeCollectionError, EmptyCollectionError, } from "../../contracts/collection/_module";
 import { simplifyLazyable } from "../../_shared/utilities";
 export class ListCollection {
     array;
@@ -13,147 +13,65 @@ export class ListCollection {
         return this[Symbol.iterator]();
     }
     entries() {
-        try {
-            return new ListCollection(this.array.entries());
-        }
-        catch (error) {
-            if (error instanceof CollectionError) {
-                throw error;
-            }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
-        }
+        return new ListCollection(this.array.entries());
     }
     keys() {
-        try {
-            return new ListCollection(this.array.keys());
-        }
-        catch (error) {
-            if (error instanceof CollectionError) {
-                throw error;
-            }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
-        }
+        return new ListCollection(this.array.keys());
     }
     values() {
         return new ListCollection(this);
     }
     filter(predicateFn) {
-        try {
-            return new ListCollection(this.array.filter((item, index) => predicateFn(item, index, this)));
-        }
-        catch (error) {
-            if (error instanceof CollectionError) {
-                throw error;
-            }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
-        }
+        return new ListCollection(this.array.filter((item, index) => predicateFn(item, index, this)));
     }
     reject(predicateFn) {
-        try {
-            return new ListCollection(this.array.filter((item, index) => !predicateFn(item, index, this)));
-        }
-        catch (error) {
-            if (error instanceof CollectionError) {
-                throw error;
-            }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
-        }
+        return new ListCollection(this.array.filter((item, index) => !predicateFn(item, index, this)));
     }
     map(mapFn) {
-        try {
-            return new ListCollection(this.array.map((item, index) => mapFn(item, index, this)));
-        }
-        catch (error) {
-            if (error instanceof CollectionError) {
-                throw error;
-            }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
-        }
+        return new ListCollection(this.array.map((item, index) => mapFn(item, index, this)));
     }
     reduce(reduceFn, initialValue) {
-        try {
-            if (initialValue === undefined && this.isEmpty()) {
-                throw new TypeCollectionError("Reduce of empty array must be inputed a initial value");
-            }
-            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 = reduceFn;
-                return reduce(initialValue, item, index, this);
-            });
+        if (initialValue === undefined && this.isEmpty()) {
+            throw new TypeCollectionError("Reduce of empty array must be inputed a initial value");
         }
-        catch (error) {
-            if (error instanceof CollectionError) {
-                throw error;
-            }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
+        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 = reduceFn;
+            return reduce(initialValue, item, index, this);
+        });
     }
     join(separator = ",") {
-        try {
-            for (const item of this) {
-                if (typeof item !== "string") {
-                    throw new TypeCollectionError("Item type is invalid must be string");
-                }
+        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) {
-                throw error;
-            }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
         }
+        return this.array.join(separator);
     }
     collapse() {
-        try {
-            const items = [];
-            for (const item of this.array) {
-                if (isIterable(item)) {
-                    items.push(...item);
-                }
-                else {
-                    items.push(item);
-                }
+        const items = [];
+        for (const item of this.array) {
+            if (isIterable(item)) {
+                items.push(...item);
             }
-            return new ListCollection(items);
-        }
-        catch (error) {
-            if (error instanceof CollectionError) {
-                throw error;
+            else {
+                items.push(item);
             }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
         }
+        return new ListCollection(items);
     }
     flatMap(mapFn) {
-        try {
-            return new ListCollection(this.array.flatMap((item, index) => [
-                ...mapFn(item, index, this),
-            ]));
-        }
-        catch (error) {
-            if (error instanceof CollectionError) {
-                throw error;
-            }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
-        }
+        return new ListCollection(this.array.flatMap((item, index) => [...mapFn(item, index, this)]));
     }
     change(predicateFn, mapFn) {
-        try {
-            return new ListCollection(this.array.map((item, index) => {
-                if (predicateFn(item, index, this)) {
-                    return mapFn(item, index, this);
-                }
-                return item;
-            }));
-        }
-        catch (error) {
-            if (error instanceof CollectionError) {
-                throw error;
+        return new ListCollection(this.array.map((item, index) => {
+            if (predicateFn(item, index, this)) {
+                return mapFn(item, index, this);
             }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
-        }
+            return item;
+        }));
     }
     page(page, pageSize) {
         if (page < 0) {
@@ -179,1028 +97,527 @@ export class ListCollection {
         return (this.sum() / this.size());
     }
     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 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];
-            if (a === undefined) {
-                throw new UnexpectedCollectionError("Is in invalid state");
-            }
-            const b = nbrs[index - 1];
-            if (isEven) {
-                if (b === undefined) {
-                    throw new UnexpectedCollectionError("Is in invalid state");
-                }
-                return ((a + b) / 2);
+        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 TypeCollectionError("Item type is invalid must be number");
             }
-            return a;
+            return item;
+        }), index = Math.floor(this.array.length / 2), isEven = this.array.length % 2 === 0, a = nbrs[index];
+        if (a === undefined) {
+            throw new UnexpectedCollectionError("Is in invalid state");
         }
-        catch (error) {
-            if (error instanceof CollectionError) {
-                throw error;
+        const b = nbrs[index - 1];
+        if (isEven) {
+            if (b === undefined) {
+                throw new UnexpectedCollectionError("Is in invalid state");
             }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
+            return ((a + b) / 2);
         }
+        return a;
     }
     min() {
-        try {
-            if (this.isEmpty()) {
-                throw new EmptyCollectionError("Collection is empty therby operation cannot be performed");
+        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 TypeCollectionError("Item type is invalid must be number");
             }
-            let min = 0;
-            for (const item of this.array) {
-                if (typeof item !== "number") {
-                    throw new TypeCollectionError("Item type is invalid must be number");
-                }
-                if (min === 0) {
-                    min = item;
-                }
-                else if (min > item) {
-                    min = item;
-                }
+            if (min === 0) {
+                min = item;
             }
-            return min;
-        }
-        catch (error) {
-            if (error instanceof CollectionError) {
-                throw error;
+            else if (min > item) {
+                min = item;
             }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
         }
+        return min;
     }
     max() {
-        try {
-            if (this.isEmpty()) {
-                throw new EmptyCollectionError("Collection is empty therby operation cannot be performed");
+        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 TypeCollectionError("Item type is invalid must be number");
             }
-            let max = 0;
-            for (const item of this.array) {
-                if (typeof item !== "number") {
-                    throw new TypeCollectionError("Item type is invalid must be number");
-                }
-                if (max === 0) {
-                    max = item;
-                }
-                else if (max < item) {
-                    max = item;
-                }
+            if (max === 0) {
+                max = item;
             }
-            return max;
-        }
-        catch (error) {
-            if (error instanceof CollectionError) {
-                throw error;
+            else if (max < item) {
+                max = item;
             }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
         }
+        return max;
     }
     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) {
-                throw error;
-            }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
+        if (this.isEmpty()) {
+            throw new EmptyCollectionError("Collection is empty therby operation cannot be performed");
         }
+        return (this.count(predicateFn) / this.size()) * 100;
     }
     some(predicateFn) {
-        try {
-            return this.array.some((item, index) => predicateFn(item, index, this));
-        }
-        catch (error) {
-            if (error instanceof CollectionError) {
-                throw error;
-            }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
-        }
+        return this.array.some((item, index) => predicateFn(item, index, this));
     }
     every(predicateFn) {
-        try {
-            return this.array.every((item, index) => predicateFn(item, index, this));
-        }
-        catch (error) {
-            if (error instanceof CollectionError) {
-                throw error;
-            }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
-        }
+        return this.array.every((item, index) => predicateFn(item, index, this));
     }
     take(limit) {
-        try {
-            return new ListCollection(this.array.slice(0, limit));
-        }
-        catch (error) {
-            if (error instanceof CollectionError) {
-                throw error;
-            }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
-        }
+        return new ListCollection(this.array.slice(0, limit));
     }
     takeUntil(predicateFn) {
-        try {
-            const items = [];
-            for (const [index, item] of this.array.entries()) {
-                if (predicateFn(item, index, this)) {
-                    break;
-                }
-                items.push(item);
-            }
-            return new ListCollection(items);
-        }
-        catch (error) {
-            if (error instanceof CollectionError) {
-                throw error;
+        const items = [];
+        for (const [index, item] of this.array.entries()) {
+            if (predicateFn(item, index, this)) {
+                break;
             }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
+            items.push(item);
         }
+        return new ListCollection(items);
     }
     takeWhile(predicateFn) {
-        try {
-            return this.takeUntil((...arguments_) => !predicateFn(...arguments_));
-        }
-        catch (error) {
-            if (error instanceof CollectionError) {
-                throw error;
-            }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
-        }
+        return this.takeUntil((...arguments_) => !predicateFn(...arguments_));
     }
     skip(offset) {
-        try {
-            return new ListCollection(this.array.slice(offset));
-        }
-        catch (error) {
-            if (error instanceof CollectionError) {
-                throw error;
-            }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
-        }
+        return new ListCollection(this.array.slice(offset));
     }
     skipUntil(predicateFn) {
-        try {
-            let hasMatched = false;
-            const items = [];
-            for (const [index, item] of this.array.entries()) {
-                if (!hasMatched) {
-                    hasMatched = predicateFn(item, index, this);
-                }
-                if (hasMatched) {
-                    items.push(item);
-                }
+        let hasMatched = false;
+        const items = [];
+        for (const [index, item] of this.array.entries()) {
+            if (!hasMatched) {
+                hasMatched = predicateFn(item, index, this);
             }
-            return new ListCollection(items);
-        }
-        catch (error) {
-            if (error instanceof CollectionError) {
-                throw error;
+            if (hasMatched) {
+                items.push(item);
             }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
         }
+        return new ListCollection(items);
     }
     skipWhile(predicateFn) {
-        try {
-            return this.skipUntil((...arguments_) => !predicateFn(...arguments_));
-        }
-        catch (error) {
-            if (error instanceof CollectionError) {
-                throw error;
-            }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
-        }
+        return this.skipUntil((...arguments_) => !predicateFn(...arguments_));
     }
     when(condition, callback) {
-        try {
-            if (condition) {
-                return callback(this);
-            }
-            return this;
-        }
-        catch (error) {
-            if (error instanceof CollectionError) {
-                throw error;
-            }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
+        if (condition) {
+            return callback(this);
         }
+        return this;
     }
     whenEmpty(callback) {
-        try {
-            return this.when(this.isEmpty(), callback);
-        }
-        catch (error) {
-            if (error instanceof CollectionError) {
-                throw error;
-            }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
-        }
+        return this.when(this.isEmpty(), callback);
     }
     whenNot(condition, callback) {
-        try {
-            return this.when(!condition, callback);
-        }
-        catch (error) {
-            if (error instanceof CollectionError) {
-                throw error;
-            }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
-        }
+        return this.when(!condition, callback);
     }
     whenNotEmpty(callback) {
-        try {
-            return this.when(this.isNotEmpty(), callback);
-        }
-        catch (error) {
-            if (error instanceof CollectionError) {
-                throw error;
-            }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
-        }
+        return this.when(this.isNotEmpty(), callback);
     }
     pipe(callback) {
-        try {
-            return callback(this);
-        }
-        catch (error) {
-            if (error instanceof CollectionError) {
-                throw error;
-            }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
-        }
+        return callback(this);
     }
     tap(callback) {
-        try {
-            callback(this);
-            return new ListCollection(this);
-        }
-        catch (error) {
-            if (error instanceof CollectionError) {
-                throw error;
-            }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
-        }
+        callback(this);
+        return new ListCollection(this);
     }
     chunk(chunkSize) {
-        try {
-            const chunks = [];
-            for (let index = 0; index < this.size(); index += chunkSize) {
-                chunks.push(new ListCollection(this.array.slice(index, index + chunkSize)));
-            }
-            return new ListCollection(chunks);
-        }
-        catch (error) {
-            if (error instanceof CollectionError) {
-                throw error;
-            }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
+        const chunks = [];
+        for (let index = 0; index < this.size(); index += chunkSize) {
+            chunks.push(new ListCollection(this.array.slice(index, index + chunkSize)));
         }
+        return new ListCollection(chunks);
     }
     chunkWhile(predicateFn) {
-        try {
-            let currentChunk = new ListCollection([]);
-            const chunks = [];
-            for (const [index, item] of this.array.entries()) {
-                if (index === 0) {
-                    currentChunk = currentChunk.append([item]);
-                }
-                else if (predicateFn(item, index, currentChunk)) {
-                    currentChunk = currentChunk.append([item]);
-                }
-                else {
-                    chunks.push(currentChunk);
-                    currentChunk = new ListCollection([item]);
-                }
+        let currentChunk = new ListCollection([]);
+        const chunks = [];
+        for (const [index, item] of this.array.entries()) {
+            if (index === 0) {
+                currentChunk = currentChunk.append([item]);
             }
-            chunks.push(currentChunk);
-            return new ListCollection(chunks);
-        }
-        catch (error) {
-            if (error instanceof CollectionError) {
-                throw error;
+            else if (predicateFn(item, index, currentChunk)) {
+                currentChunk = currentChunk.append([item]);
+            }
+            else {
+                chunks.push(currentChunk);
+                currentChunk = new ListCollection([item]);
             }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
         }
+        chunks.push(currentChunk);
+        return new ListCollection(chunks);
     }
     split(chunkAmount) {
-        try {
-            const size = this.size(), minChunkSize = Math.floor(size / chunkAmount), restSize = size % chunkAmount, chunkSizes = Array.from({
-                length: chunkAmount,
-            }).fill(minChunkSize);
-            for (let index = 1; index <= restSize; index++) {
-                const chunkIndex = (index - 1) % chunkAmount;
-                if (chunkSizes[chunkIndex]) {
-                    chunkSizes[chunkIndex] = chunkSizes[chunkIndex] + 1;
-                }
+        const size = this.size(), minChunkSize = Math.floor(size / chunkAmount), restSize = size % chunkAmount, chunkSizes = Array.from({
+            length: chunkAmount,
+        }).fill(minChunkSize);
+        for (let index = 1; index <= restSize; index++) {
+            const chunkIndex = (index - 1) % chunkAmount;
+            if (chunkSizes[chunkIndex]) {
+                chunkSizes[chunkIndex] = chunkSizes[chunkIndex] + 1;
             }
-            let end = 0, start = 0;
-            const chunks = [];
-            for (const chunkSize of chunkSizes) {
-                end += chunkSize;
-                chunks.push(new ListCollection(this.array.slice(start, end)));
-                start += chunkSize;
-            }
-            return new ListCollection(chunks);
         }
-        catch (error) {
-            if (error instanceof CollectionError) {
-                throw error;
-            }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
+        let end = 0, start = 0;
+        const chunks = [];
+        for (const chunkSize of chunkSizes) {
+            end += chunkSize;
+            chunks.push(new ListCollection(this.array.slice(start, end)));
+            start += chunkSize;
         }
+        return new ListCollection(chunks);
     }
     partition(predicateFn) {
-        try {
-            const chunkA = [], chunkB = [];
-            for (const [index, item] of this.array.entries()) {
-                if (predicateFn(item, index, this)) {
-                    chunkA.push(item);
-                }
-                else {
-                    chunkB.push(item);
-                }
+        const chunkA = [], chunkB = [];
+        for (const [index, item] of this.array.entries()) {
+            if (predicateFn(item, index, this)) {
+                chunkA.push(item);
             }
-            return new ListCollection([
-                new ListCollection(chunkA),
-                new ListCollection(chunkB),
-            ]);
-        }
-        catch (error) {
-            if (error instanceof CollectionError) {
-                throw error;
+            else {
+                chunkB.push(item);
             }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
         }
+        return new ListCollection([
+            new ListCollection(chunkA),
+            new ListCollection(chunkB),
+        ]);
     }
     sliding(chunkSize, step = chunkSize - 1) {
-        try {
-            let chunks = new ListCollection([]);
-            if (step <= 0) {
-                return new ListCollection([]);
-            }
-            for (let index = 0; index < this.size(); index += step) {
-                const start = index;
-                const end = index + chunkSize;
-                chunks = chunks.append([this.slice(start, end)]);
-                if (end >= this.size()) {
-                    break;
-                }
-            }
-            return chunks;
+        let chunks = new ListCollection([]);
+        if (step <= 0) {
+            return new ListCollection([]);
         }
-        catch (error) {
-            if (error instanceof CollectionError) {
-                throw error;
+        for (let index = 0; index < this.size(); index += step) {
+            const start = index;
+            const end = index + chunkSize;
+            chunks = chunks.append([this.slice(start, end)]);
+            if (end >= this.size()) {
+                break;
             }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
         }
+        return chunks;
     }
     groupBy(selectFn = (item) => item) {
-        try {
-            const map = new Map();
-            for (const [index, item] of this.array.entries()) {
-                const key = selectFn(item, index, this);
-                let collection = map.get(key);
-                if (collection === undefined) {
-                    collection = new ListCollection([]);
-                    map.set(key, collection);
-                }
-                map.set(key, collection.append([item]));
-            }
-            return new ListCollection(map);
-        }
-        catch (error) {
-            if (error instanceof CollectionError) {
-                throw error;
+        const map = new Map();
+        for (const [index, item] of this.array.entries()) {
+            const key = selectFn(item, index, this);
+            let collection = map.get(key);
+            if (collection === undefined) {
+                collection = new ListCollection([]);
+                map.set(key, collection);
             }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
+            map.set(key, collection.append([item]));
         }
+        return new ListCollection(map);
     }
     countBy(selectFn = (item) => item) {
-        try {
-            const map = new Map();
-            for (const [index, item] of this.array.entries()) {
-                const key = selectFn(item, index, this);
-                if (!map.has(key)) {
-                    map.set(key, 0);
-                }
-                const counter = map.get(key);
-                if (counter !== undefined) {
-                    map.set(key, counter + 1);
-                }
+        const map = new Map();
+        for (const [index, item] of this.array.entries()) {
+            const key = selectFn(item, index, this);
+            if (!map.has(key)) {
+                map.set(key, 0);
             }
-            return new ListCollection(map);
-        }
-        catch (error) {
-            if (error instanceof CollectionError) {
-                throw error;
+            const counter = map.get(key);
+            if (counter !== undefined) {
+                map.set(key, counter + 1);
             }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
         }
+        return new ListCollection(map);
     }
     unique(selectFn = (item) => item) {
-        try {
-            const set = new Set([]), items = [];
-            for (const [index, item] of this.array.entries()) {
-                const item_ = selectFn(item, index, this);
-                if (!set.has(item_)) {
-                    items.push(item);
-                }
-                set.add(item_);
-            }
-            return new ListCollection(items);
-        }
-        catch (error) {
-            if (error instanceof CollectionError) {
-                throw error;
+        const set = new Set([]), items = [];
+        for (const [index, item] of this.array.entries()) {
+            const item_ = selectFn(item, index, this);
+            if (!set.has(item_)) {
+                items.push(item);
             }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
+            set.add(item_);
         }
+        return new ListCollection(items);
     }
     difference(iterable, selectFn = (item) => item) {
-        try {
-            const differenceCollection = new ListCollection(iterable);
-            return this.filter((item, index, collection) => {
-                return !differenceCollection.some((matchItem, matchIndex, matchCollection) => {
-                    return (selectFn(item, index, collection) ===
-                        selectFn(matchItem, matchIndex, matchCollection));
-                });
+        const differenceCollection = new ListCollection(iterable);
+        return this.filter((item, index, collection) => {
+            return !differenceCollection.some((matchItem, matchIndex, matchCollection) => {
+                return (selectFn(item, index, collection) ===
+                    selectFn(matchItem, matchIndex, matchCollection));
             });
-        }
-        catch (error) {
-            if (error instanceof CollectionError) {
-                throw error;
-            }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
-        }
+        });
     }
     repeat(amount) {
-        try {
-            let collection = new ListCollection([]);
-            for (let index = 0; index < amount; index++) {
-                collection = collection.append(this);
-            }
-            return collection;
-        }
-        catch (error) {
-            if (error instanceof CollectionError) {
-                throw error;
-            }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
+        let collection = new ListCollection([]);
+        for (let index = 0; index < amount; index++) {
+            collection = collection.append(this);
         }
+        return collection;
     }
     padStart(maxLength, fillItems) {
-        try {
-            const fillItemsArray = [...fillItems];
-            const size = this.size();
-            const repeat = Math.floor((maxLength - size) / fillItemsArray.length);
-            const resultItemsArray = [];
-            for (let index = 0; index < repeat; index++) {
-                resultItemsArray.push(...fillItemsArray);
-            }
-            const restAmount = maxLength - (repeat * fillItemsArray.length + size);
-            for (let index = 0; index < restAmount; index++) {
-                const fillItem = fillItemsArray[index];
-                if (fillItem) {
-                    resultItemsArray.push(fillItem);
-                }
-            }
-            resultItemsArray.push(...this);
-            return new ListCollection(resultItemsArray);
+        const fillItemsArray = [...fillItems];
+        const size = this.size();
+        const repeat = Math.floor((maxLength - size) / fillItemsArray.length);
+        const resultItemsArray = [];
+        for (let index = 0; index < repeat; index++) {
+            resultItemsArray.push(...fillItemsArray);
         }
-        catch (error) {
-            if (error instanceof CollectionError) {
-                throw error;
+        const restAmount = maxLength - (repeat * fillItemsArray.length + size);
+        for (let index = 0; index < restAmount; index++) {
+            const fillItem = fillItemsArray[index];
+            if (fillItem) {
+                resultItemsArray.push(fillItem);
             }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
         }
+        resultItemsArray.push(...this);
+        return new ListCollection(resultItemsArray);
     }
     padEnd(maxLength, fillItems) {
-        try {
-            const fillItemsArray = [...fillItems];
-            const size = this.size();
-            const repeat = Math.floor((maxLength - size) / fillItemsArray.length);
-            const resultItemsArray = [];
-            for (let index = 0; index < repeat; index++) {
-                resultItemsArray.push(...fillItemsArray);
-            }
-            const restAmount = maxLength - (repeat * fillItemsArray.length + size);
-            for (let index = 0; index < restAmount; index++) {
-                const fillItem = fillItemsArray[index];
-                if (fillItem) {
-                    resultItemsArray.push(fillItem);
-                }
-            }
-            resultItemsArray.unshift(...this);
-            return new ListCollection(resultItemsArray);
+        const fillItemsArray = [...fillItems];
+        const size = this.size();
+        const repeat = Math.floor((maxLength - size) / fillItemsArray.length);
+        const resultItemsArray = [];
+        for (let index = 0; index < repeat; index++) {
+            resultItemsArray.push(...fillItemsArray);
         }
-        catch (error) {
-            if (error instanceof CollectionError) {
-                throw error;
+        const restAmount = maxLength - (repeat * fillItemsArray.length + size);
+        for (let index = 0; index < restAmount; index++) {
+            const fillItem = fillItemsArray[index];
+            if (fillItem) {
+                resultItemsArray.push(fillItem);
             }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
         }
+        resultItemsArray.unshift(...this);
+        return new ListCollection(resultItemsArray);
     }
     slice(start, end) {
-        try {
-            return new ListCollection(this.array.slice(start, end));
-        }
-        catch (error) {
-            if (error instanceof CollectionError) {
-                throw error;
-            }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
-        }
+        return new ListCollection(this.array.slice(start, end));
     }
     prepend(iterable) {
-        try {
-            return new ListCollection([...iterable, ...this.array]);
-        }
-        catch (error) {
-            if (error instanceof CollectionError) {
-                throw error;
-            }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
-        }
+        return new ListCollection([...iterable, ...this.array]);
     }
     append(iterable) {
-        try {
-            return new ListCollection([...this.array, ...iterable]);
-        }
-        catch (error) {
-            if (error instanceof CollectionError) {
-                throw error;
-            }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
-        }
+        return new ListCollection([...this.array, ...iterable]);
     }
     insertBefore(predicateFn, iterable) {
-        try {
-            const index = this.array.findIndex((item, index) => predicateFn(item, index, this));
-            if (index === -1) {
-                return new ListCollection(this.array);
-            }
-            const newArray = [...this.array];
-            newArray.splice(index, 0, ...iterable);
-            return new ListCollection(newArray);
-        }
-        catch (error) {
-            if (error instanceof CollectionError) {
-                throw error;
-            }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
+        const index = this.array.findIndex((item, index) => predicateFn(item, index, this));
+        if (index === -1) {
+            return new ListCollection(this.array);
         }
+        const newArray = [...this.array];
+        newArray.splice(index, 0, ...iterable);
+        return new ListCollection(newArray);
     }
     insertAfter(predicateFn, iterable) {
-        try {
-            const index = this.array.findIndex((item, index) => predicateFn(item, index, this));
-            if (index === -1) {
-                return new ListCollection(this.array);
-            }
-            const firstPart = this.array.slice(0, index + 1), lastPart = this.array.slice(index + 1);
-            return new ListCollection([
-                ...firstPart,
-                ...iterable,
-                ...lastPart,
-            ]);
-        }
-        catch (error) {
-            if (error instanceof CollectionError) {
-                throw error;
-            }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
+        const index = this.array.findIndex((item, index) => predicateFn(item, index, this));
+        if (index === -1) {
+            return new ListCollection(this.array);
         }
+        const firstPart = this.array.slice(0, index + 1), lastPart = this.array.slice(index + 1);
+        return new ListCollection([
+            ...firstPart,
+            ...iterable,
+            ...lastPart,
+        ]);
     }
     crossJoin(iterable) {
-        try {
-            const array = [
-                [...this],
-                [...iterable],
-            ]
-                .reduce((a, b) => {
-                return a
-                    .map((x) => {
-                    return b.map((y) => {
-                        return [...x, y];
-                    });
-                })
-                    .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) {
-                throw error;
-            }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
-        }
+        const array = [
+            [...this],
+            [...iterable],
+        ]
+            .reduce((a, b) => {
+            return a
+                .map((x) => {
+                return b.map((y) => {
+                    return [...x, y];
+                });
+            })
+                .reduce((c, b) => [...c, ...b], []);
+        }, [[]])
+            .map((combination) => {
+            return combination.reduce((a, b) => {
+                return [...a, ...(isIterable(b) ? b : [b])];
+            }, []);
+        });
+        return new ListCollection(array);
     }
     zip(iterable) {
-        try {
-            const iterableArray = [...iterable];
-            let size = iterableArray.length;
-            if (size > this.size()) {
-                size = this.size();
-            }
-            const items = [];
-            for (let index = 0; index < size; index++) {
-                const itemA = this.array[index], itemB = iterableArray[index];
-                if (itemA === undefined || itemB === undefined) {
-                    continue;
-                }
-                items.push([itemA, itemB]);
-            }
-            return new ListCollection(items);
+        const iterableArray = [...iterable];
+        let size = iterableArray.length;
+        if (size > this.size()) {
+            size = this.size();
         }
-        catch (error) {
-            if (error instanceof CollectionError) {
-                throw error;
+        const items = [];
+        for (let index = 0; index < size; index++) {
+            const itemA = this.array[index], itemB = iterableArray[index];
+            if (itemA === undefined || itemB === undefined) {
+                continue;
             }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
+            items.push([itemA, itemB]);
         }
+        return new ListCollection(items);
     }
     sort(comparator) {
-        try {
-            return new ListCollection(this.array.sort(comparator));
-        }
-        catch (error) {
-            if (error instanceof CollectionError) {
-                throw error;
-            }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
-        }
+        return new ListCollection(this.array.sort(comparator));
     }
     reverse(_chunkSize) {
-        try {
-            return new ListCollection([...this.array].reverse());
-        }
-        catch (error) {
-            if (error instanceof CollectionError) {
-                throw error;
-            }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
-        }
+        return new ListCollection([...this.array].reverse());
     }
     shuffle(mathRandom = Math.random) {
-        try {
-            const newArray = [...this.array];
-            for (let i = newArray.length - 1; i > 0; i--) {
-                const j = Math.floor(mathRandom() * (i + 1));
-                const temp = newArray[i];
-                if (newArray[j] !== undefined) {
-                    newArray[i] = newArray[j];
-                }
-                if (temp !== undefined) {
-                    newArray[j] = temp;
-                }
+        const newArray = [...this.array];
+        for (let i = newArray.length - 1; i > 0; i--) {
+            const j = Math.floor(mathRandom() * (i + 1));
+            const temp = newArray[i];
+            if (newArray[j] !== undefined) {
+                newArray[i] = newArray[j];
             }
-            return new ListCollection(newArray);
-        }
-        catch (error) {
-            if (error instanceof CollectionError) {
-                throw error;
+            if (temp !== undefined) {
+                newArray[j] = temp;
             }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
         }
+        return new ListCollection(newArray);
     }
     first(predicateFn) {
-        try {
-            return this.firstOr(null, predicateFn);
-        }
-        catch (error) {
-            if (error instanceof CollectionError) {
-                throw error;
-            }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
-        }
+        return this.firstOr(null, predicateFn);
     }
     firstOr(defaultValue, predicateFn) {
-        try {
-            if (predicateFn) {
-                for (const [index, item] of this.array.entries()) {
-                    if (predicateFn(item, index, this)) {
-                        return item;
-                    }
-                }
-            }
-            else {
-                const firstItem = this.array[0];
-                if (firstItem) {
-                    return firstItem;
+        if (predicateFn) {
+            for (const [index, item] of this.array.entries()) {
+                if (predicateFn(item, index, this)) {
+                    return item;
                 }
             }
-            return simplifyLazyable(defaultValue);
         }
-        catch (error) {
-            if (error instanceof CollectionError) {
-                throw error;
+        else {
+            const firstItem = this.array[0];
+            if (firstItem) {
+                return firstItem;
             }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
         }
+        return simplifyLazyable(defaultValue);
     }
     firstOrFail(predicateFn) {
-        try {
-            const item = this.first(predicateFn);
-            if (item === null) {
-                throw new ItemNotFoundCollectionError("Item was not found");
-            }
-            return item;
-        }
-        catch (error) {
-            if (error instanceof CollectionError) {
-                throw error;
-            }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
+        const item = this.first(predicateFn);
+        if (item === null) {
+            throw new ItemNotFoundCollectionError("Item was not found");
         }
+        return item;
     }
     last(predicateFn) {
-        try {
-            return this.lastOr(null, predicateFn);
-        }
-        catch (error) {
-            if (error instanceof CollectionError) {
-                throw error;
-            }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
-        }
+        return this.lastOr(null, predicateFn);
     }
     lastOr(defaultValue, predicateFn) {
-        try {
-            if (predicateFn) {
-                let matchedItem = null;
-                for (const [index, item] of this.array.entries()) {
-                    if (predicateFn(item, index, this)) {
-                        matchedItem = item;
-                    }
-                }
-                if (matchedItem) {
-                    return matchedItem;
+        if (predicateFn) {
+            let matchedItem = null;
+            for (const [index, item] of this.array.entries()) {
+                if (predicateFn(item, index, this)) {
+                    matchedItem = item;
                 }
             }
-            else {
-                const lastItem = this.array.at(-1);
-                if (lastItem) {
-                    return lastItem;
-                }
+            if (matchedItem) {
+                return matchedItem;
             }
-            return simplifyLazyable(defaultValue);
         }
-        catch (error) {
-            if (error instanceof CollectionError) {
-                throw error;
+        else {
+            const lastItem = this.array.at(-1);
+            if (lastItem) {
+                return lastItem;
             }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
         }
+        return simplifyLazyable(defaultValue);
     }
     lastOrFail(predicateFn) {
-        try {
-            const item = this.last(predicateFn);
-            if (item === null) {
-                throw new ItemNotFoundCollectionError("Item was not found");
-            }
-            return item;
-        }
-        catch (error) {
-            if (error instanceof CollectionError) {
-                throw error;
-            }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
+        const item = this.last(predicateFn);
+        if (item === null) {
+            throw new ItemNotFoundCollectionError("Item was not found");
         }
+        return item;
     }
     before(predicateFn) {
-        try {
-            return this.beforeOr(null, predicateFn);
-        }
-        catch (error) {
-            if (error instanceof CollectionError) {
-                throw error;
-            }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
-        }
+        return this.beforeOr(null, predicateFn);
     }
     beforeOr(defaultValue, predicateFn) {
-        try {
-            for (const [index, item] of this.array.entries()) {
-                const beforeItem = this.array[index - 1];
-                if (predicateFn(item, index, this) &&
-                    beforeItem !== undefined) {
-                    return beforeItem;
-                }
+        for (const [index, item] of this.array.entries()) {
+            const beforeItem = this.array[index - 1];
+            if (predicateFn(item, index, this) && beforeItem !== undefined) {
+                return beforeItem;
             }
-            return simplifyLazyable(defaultValue);
-        }
-        catch (error) {
-            if (error instanceof CollectionError) {
-                throw error;
-            }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
         }
+        return simplifyLazyable(defaultValue);
     }
     beforeOrFail(predicateFn) {
-        try {
-            const item = this.before(predicateFn);
-            if (item === null) {
-                throw new ItemNotFoundCollectionError("Item was not found");
-            }
-            return item;
-        }
-        catch (error) {
-            if (error instanceof CollectionError) {
-                throw error;
-            }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
+        const item = this.before(predicateFn);
+        if (item === null) {
+            throw new ItemNotFoundCollectionError("Item was not found");
         }
+        return item;
     }
     after(predicateFn) {
-        try {
-            return this.afterOr(null, predicateFn);
-        }
-        catch (error) {
-            if (error instanceof CollectionError) {
-                throw error;
-            }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
-        }
+        return this.afterOr(null, predicateFn);
     }
     afterOr(defaultValue, predicateFn) {
-        try {
-            for (const [index, item] of this.array.entries()) {
-                const beforeItem = this.array[index + 1];
-                if (predicateFn(item, index, this) &&
-                    beforeItem !== undefined) {
-                    return beforeItem;
-                }
-            }
-            return simplifyLazyable(defaultValue);
-        }
-        catch (error) {
-            if (error instanceof CollectionError) {
-                throw error;
+        for (const [index, item] of this.array.entries()) {
+            const beforeItem = this.array[index + 1];
+            if (predicateFn(item, index, this) && beforeItem !== undefined) {
+                return beforeItem;
             }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
         }
+        return simplifyLazyable(defaultValue);
     }
     afterOrFail(predicateFn) {
-        try {
-            const item = this.after(predicateFn);
-            if (item === null) {
-                throw new ItemNotFoundCollectionError("Item was not found");
-            }
-            return item;
-        }
-        catch (error) {
-            if (error instanceof CollectionError) {
-                throw error;
-            }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
+        const item = this.after(predicateFn);
+        if (item === null) {
+            throw new ItemNotFoundCollectionError("Item was not found");
         }
+        return item;
     }
     sole(predicateFn) {
-        try {
-            const matchedItems = [];
-            for (const [index, item] of this.array.entries()) {
-                if (predicateFn(item, index, this)) {
-                    matchedItems.push(item);
-                }
-                if (matchedItems.length > 1) {
-                    throw new MultipleItemsFoundCollectionError("Multiple items were found");
-                }
+        const matchedItems = [];
+        for (const [index, item] of this.array.entries()) {
+            if (predicateFn(item, index, this)) {
+                matchedItems.push(item);
             }
-            const [matchedItem] = matchedItems;
-            if (matchedItem === undefined) {
-                throw new ItemNotFoundCollectionError("Item was not found");
+            if (matchedItems.length > 1) {
+                throw new MultipleItemsFoundCollectionError("Multiple items were found");
             }
-            return matchedItem;
         }
-        catch (error) {
-            if (error instanceof CollectionError) {
-                throw error;
-            }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
+        const [matchedItem] = matchedItems;
+        if (matchedItem === undefined) {
+            throw new ItemNotFoundCollectionError("Item was not found");
         }
+        return matchedItem;
     }
     nth(step) {
-        try {
-            return this.filter((_item, index) => index % step === 0);
-        }
-        catch (error) {
-            if (error instanceof CollectionError) {
-                throw error;
-            }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
-        }
+        return this.filter((_item, index) => index % step === 0);
     }
     count(predicateFn) {
-        try {
-            return this.filter(predicateFn).size();
-        }
-        catch (error) {
-            if (error instanceof CollectionError) {
-                throw error;
-            }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
-        }
+        return this.filter(predicateFn).size();
     }
     size() {
-        try {
-            return this.array.length;
-        }
-        catch (error) {
-            if (error instanceof CollectionError) {
-                throw error;
-            }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
-        }
+        return this.array.length;
     }
     isEmpty() {
-        try {
-            return this.array.length === 0;
-        }
-        catch (error) {
-            if (error instanceof CollectionError) {
-                throw error;
-            }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
-        }
+        return this.array.length === 0;
     }
     isNotEmpty() {
-        try {
-            return this.array.length !== 0;
-        }
-        catch (error) {
-            if (error instanceof CollectionError) {
-                throw error;
-            }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
-        }
+        return this.array.length !== 0;
     }
     searchFirst(predicateFn) {
-        try {
-            return this.array.findIndex((item, index) => predicateFn(item, index, this));
-        }
-        catch (error) {
-            if (error instanceof CollectionError) {
-                throw error;
-            }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
-        }
+        return this.array.findIndex((item, index) => predicateFn(item, index, this));
     }
     searchLast(predicateFn) {
-        try {
-            let matchedIndex = -1;
-            for (const [index, item] of this.array.entries()) {
-                if (predicateFn(item, index, this)) {
-                    matchedIndex = index;
-                }
+        let matchedIndex = -1;
+        for (const [index, item] of this.array.entries()) {
+            if (predicateFn(item, index, this)) {
+                matchedIndex = index;
             }
-            return matchedIndex;
-        }
-        catch (error) {
-            if (error instanceof CollectionError) {
-                throw error;
-            }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
         }
+        return matchedIndex;
     }
     forEach(callback) {
-        try {
-            for (const [index, item] of this.array.entries()) {
-                callback(item, index, this);
-            }
-        }
-        catch (error) {
-            if (error instanceof CollectionError) {
-                throw error;
-            }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
+        for (const [index, item] of this.array.entries()) {
+            callback(item, index, this);
         }
     }
     toArray() {
-        try {
-            return [...this.array];
-        }
-        catch (error) {
-            if (error instanceof CollectionError) {
-                throw error;
-            }
-            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
-        }
+        return [...this.array];
     }
 }
 //# sourceMappingURL=list-collection.js.map