utilitish 0.0.11 → 0.0.15

package/LICENSE.txt

@@ -1,25 +1,25 @@
-GNU GENERAL PUBLIC LICENSE
-Version 3, 29 June 2007
-
-Copyright (C) 2025 Donovan Ferreira
-
-Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed.
-
-                            Preamble
-
-The GNU General Public License is a free, copyleft license for
-software and other kinds of works.
-
-The licenses for most software and other practical works are designed
-to take away your freedom to share and change the works. By contrast,
-the GNU General Public License is intended to guarantee your freedom to
-share and change all versions of a program--to make sure it remains free
-software for all its users. We, the Free Software Foundation, use the
-GNU General Public License for most of our software; it applies also to
-any other work released this way by its authors. You can apply it to
-your programs, too.
-
-[... contenu tronqué pour l’aperçu ...]
-
-You should have received a copy of the GNU General Public License
-along with this program. If not, see <https://www.gnu.org/licenses/>.
+GNU GENERAL PUBLIC LICENSE
+Version 3, 29 June 2007
+
+Copyright (C) 2025 Donovan Ferreira
+
+Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed.
+
+                            Preamble
+
+The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works. By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users. We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors. You can apply it to
+your programs, too.
+
+[... contenu tronqué pour l’aperçu ...]
+
+You should have received a copy of the GNU General Public License
+along with this program. If not, see <https://www.gnu.org/licenses/>.

package/README.md

@@ -1,68 +1,68 @@
-## Licence
-
-Ce projet est distribué sous licence [GPL v3](https://www.gnu.org/licenses/gpl-3.0.html) © 2025 Donovan Ferreira.
-
-Ceci est une petite librairie qui ajoute plusieurs méthodes au prototype JavaScript.
-
-## Configuration Slugify
-
-La méthode `slugify()` peut être personnalisée pour répondre à vos besoins spécifiques. Consultez la JSDoc dans votre IDE pour voir tous les exemples disponibles.
-
-### Configuration globale
-
-Vous pouvez définir une configuration globale qui s'appliquera à tous les appels `slugify()` :
-
-```typescript
-import { setSlugifyConfig } from 'utilitish';
-
-// Configuration pour remplacer les symboles de genre
-setSlugifyConfig(
-    SlugifyConfig.builder()
-        .withSeparator('_')
-        .withCustomReplacements({
-            '♀': 'feminin',
-            '♂': 'masculin',
-            '@': 'at',
-        })
-        .build(),
-);
-
-'Test ♀'.slugify(); // "test_feminin"
-'User♂@domain.com'.slugify(); // "usermasculinatdomain_com"
-```
-
-### Configuration par appel
-
-Vous pouvez aussi passer une configuration spécifique à chaque appel :
-
-```typescript
-// Utilise la config globale
-'Hello World'.slugify(); // "hello-world"
-
-// Override la config pour cet appel
-'Hello World'.slugify(SlugifyConfig.builder().withSeparator('_').build()); // "hello_world"
-```
-
-### Options de configuration
-
-- **`customReplacements`**: Remplacer des caractères spécifiques (ex: "♀" → "feminin")
-- **`separator`**: Caractère de séparation (défaut: "-")
-- **`lowercase`**: Convertir en minuscules (défaut: true)
-- **`removeAccents`**: Supprimer les accents (défaut: true)
-- **`allowedChars`**: Regex des caractères autorisés (défaut: /[a-zA-Z0-9]/)
-- **`maxLength`**: Longueur maximale du slug
-- **`transformers`**: Fonctions de transformation personnalisées
-
-### Gestion de la configuration
-
-```typescript
-import { getSlugifyConfig, resetSlugifyConfig } from 'utilitish';
-
-// Obtenir la config actuelle
-const currentConfig = getSlugifyConfig();
-
-// Réinitialiser aux valeurs par défaut
-resetSlugifyConfig();
-```
-
-Pour plus d'exemples et cas d'usage avancés, consultez les JSDoc intégrées dans votre IDE.
+## Licence
+
+Ce projet est distribué sous licence [GPL v3](https://www.gnu.org/licenses/gpl-3.0.html) © 2025 Donovan Ferreira.
+
+Ceci est une petite librairie qui ajoute plusieurs méthodes au prototype JavaScript.
+
+## Configuration Slugify
+
+La méthode `slugify()` peut être personnalisée pour répondre à vos besoins spécifiques. Consultez la JSDoc dans votre IDE pour voir tous les exemples disponibles.
+
+### Configuration globale
+
+Vous pouvez définir une configuration globale qui s'appliquera à tous les appels `slugify()` :
+
+```typescript
+import { setSlugifyConfig } from 'utilitish';
+
+// Configuration pour remplacer les symboles de genre
+setSlugifyConfig(
+    SlugifyConfig.builder()
+        .withSeparator('_')
+        .withCustomReplacements({
+            '♀': 'feminin',
+            '♂': 'masculin',
+            '@': 'at',
+        })
+        .build(),
+);
+
+'Test ♀'.slugify(); // "test_feminin"
+'User♂@domain.com'.slugify(); // "usermasculinatdomain_com"
+```
+
+### Configuration par appel
+
+Vous pouvez aussi passer une configuration spécifique à chaque appel :
+
+```typescript
+// Utilise la config globale
+'Hello World'.slugify(); // "hello-world"
+
+// Override la config pour cet appel
+'Hello World'.slugify(SlugifyConfig.builder().withSeparator('_').build()); // "hello_world"
+```
+
+### Options de configuration
+
+- **`customReplacements`**: Remplacer des caractères spécifiques (ex: "♀" → "feminin")
+- **`separator`**: Caractère de séparation (défaut: "-")
+- **`lowercase`**: Convertir en minuscules (défaut: true)
+- **`removeAccents`**: Supprimer les accents (défaut: true)
+- **`allowedChars`**: Regex des caractères autorisés (défaut: /[a-zA-Z0-9]/)
+- **`maxLength`**: Longueur maximale du slug
+- **`transformers`**: Fonctions de transformation personnalisées
+
+### Gestion de la configuration
+
+```typescript
+import { getSlugifyConfig, resetSlugifyConfig } from 'utilitish';
+
+// Obtenir la config actuelle
+const currentConfig = getSlugifyConfig();
+
+// Réinitialiser aux valeurs par défaut
+resetSlugifyConfig();
+```
+
+Pour plus d'exemples et cas d'usage avancés, consultez les JSDoc intégrées dans votre IDE.

package/dist/array/array-constructor.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const core_utils_1 = require("../utils/core.utils");
+const core_utils_2 = require("./../utils/core.utils");
 /**
  * @see Array.zip
  */
@@ -19,7 +20,7 @@ const core_utils_1 = require("../utils/core.utils");
         start = 0;
     }
     if (step === 0)
-        throw new Error('step must not be 0');
+        (0, core_utils_2.utilitishError)('Array.range', 'step must not be 0', undefined, RangeError);
     const result = [];
     const condition = step > 0 ? (i) => i < end : (i) => i > end;
     for (let i = start; condition(i); i += step) {
@@ -31,9 +32,12 @@ const core_utils_1 = require("../utils/core.utils");
  * @see Array.repeat
  */
 (0, core_utils_1.defineStaticIfNotExists)(Array, 'repeat', function (length, value) {
-    if (typeof length !== 'number' || !Number.isInteger(length) || length < 0) {
-        throw new TypeError('Length must be a non-negative integer');
-    }
+    if (typeof length !== 'number')
+        (0, core_utils_2.utilitishError)('Array.repeat', 'n must be a number', length);
+    if (!Number.isInteger(length))
+        (0, core_utils_2.utilitishError)('Array.repeat', 'n must be an integer', length);
+    if (length < 0)
+        (0, core_utils_2.utilitishError)('Array.repeat', 'n must be non-negative', length, RangeError);
     return Array.from({ length }, () => (typeof value === 'function' ? value() : value));
 });
 /**

package/dist/array/array-prototype.d.ts

@@ -386,5 +386,26 @@ declare global {
          * - Empty array returns empty Map
          */
         countBy<K>(this: T[], selector?: Selector<T, K>): Map<T | K, number>;
+        /**
+         * Checks if the slugified version of a value matches any slugified string in this array.
+         * Useful for case-insensitive and accent-insensitive array search.
+         *
+         * @this {string[]} The array of strings to search in.
+         * @param {string} value - The string to search for.
+         * @returns {boolean} `true` if any slugified item in the array equals the slugified `value`, `false` otherwise.
+         * @throws {TypeError} If `value` is not a string.
+         * @throws {TypeError} If any item in the array is not a string.
+         *
+         * @example
+         * ['Hello World', 'Foo Bar'].slugifyIncludes('hello-world'); // true
+         * ['Héllo World', 'Foo Bar'].slugifyIncludes('hello-world'); // true
+         * ['Hello World', 'Foo Bar'].slugifyIncludes('baz');         // false
+         *
+         * @remarks
+         * - All strings are slugified before comparison.
+         * - Since `slugify` is idempotent, passing an already-slugified value works as expected.
+         * - Throws on the first non-string item encountered in the array.
+         */
+        slugifyIncludes(value: string): boolean;
     }
 }

package/dist/array/array-prototype.js

@@ -2,43 +2,67 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const core_utils_1 = require("../utils/core.utils");
 const logic_utils_1 = require("../utils/logic.utils");
+/**
+ * @see Array.prototype.first
+ */
 (0, core_utils_1.defineIfNotExists)(Array.prototype, 'first', function () {
     return this[0];
 });
+/**
+ * @see Array.prototype.last
+ */
 (0, core_utils_1.defineIfNotExists)(Array.prototype, 'last', function () {
     return this[this.length - 1];
 });
+/**
+ * @see Array.prototype.sum
+ */
 (0, core_utils_1.defineIfNotExists)(Array.prototype, 'sum', function (selector) {
     if (this.length === 0)
         return 0;
     const getValue = (0, core_utils_1.resolveSelector)(selector, (item) => item);
-    if (this.every((item) => typeof getValue(item) === 'number')) {
-        return this.reduce((acc, item) => getValue(item) + acc, 0);
+    if (!this.every((item) => typeof getValue(item) === 'number')) {
+        (0, core_utils_1.utilitishError)('Array.prototype.sum', 'requires a selector that returns a number unless array is number[]');
     }
-    throw new TypeError('Array.prototype.sum() requires a selector who return a number unless array is number[]');
+    return this.reduce((acc, item) => getValue(item) + acc, 0);
 });
+/**
+ * @see Array.prototype.unique
+ */
 (0, core_utils_1.defineIfNotExists)(Array.prototype, 'unique', function () {
     return [...new Set(this)];
 });
+/**
+ * @see Array.prototype.chunk
+ */
 (0, core_utils_1.defineIfNotExists)(Array.prototype, 'chunk', function (size) {
-    if (typeof size !== 'number' || !Number.isInteger(size) || size <= 0) {
-        throw new TypeError('Chunk size must be a positive integer');
-    }
+    if (typeof size !== 'number')
+        (0, core_utils_1.utilitishError)('Array.prototype.chunk', 'size must be a number', size);
+    if (!Number.isInteger(size))
+        (0, core_utils_1.utilitishError)('Array.prototype.chunk', 'size must be an integer', size);
+    if (size <= 0)
+        (0, core_utils_1.utilitishError)('Array.prototype.chunk', 'size must be positive', size, RangeError);
     const result = [];
     for (let i = 0; i < this.length; i += size) {
         result.push(this.slice(i, i + size));
     }
     return result;
 });
+/**
+ * @see Array.prototype.average
+ */
 (0, core_utils_1.defineIfNotExists)(Array.prototype, 'average', function (selector) {
     if (this.length === 0)
         return 0;
     const getValue = (0, core_utils_1.resolveSelector)(selector, (item) => item);
-    if (this.every((item) => typeof getValue(item) === 'number')) {
-        return this.reduce((acc, item) => getValue(item) + acc, 0) / this.length;
+    if (!this.every((item) => typeof getValue(item) === 'number')) {
+        (0, core_utils_1.utilitishError)('Array.prototype.average', 'requires a selector that returns a number unless array is number[]');
     }
-    throw new TypeError('Array.prototype.average() requires a selector who return a number unless array is number[]');
+    return this.reduce((acc, item) => getValue(item) + acc, 0) / this.length;
 });
+/**
+ * @see Array.prototype.groupBy
+ */
 (0, core_utils_1.defineIfNotExists)(Array.prototype, 'groupBy', function (selector) {
     const getKey = (0, core_utils_1.resolveSelector)(selector, (item) => item);
     const map = new Map();
@@ -51,24 +75,34 @@ const logic_utils_1 = require("../utils/logic.utils");
     }
     return map;
 });
+/**
+ * @see Array.prototype.compact
+ */
 (0, core_utils_1.defineIfNotExists)(Array.prototype, 'compact', function () {
     return this.filter(Boolean);
 });
+/**
+ * @see Array.prototype.enumerate
+ */
 (0, core_utils_1.defineIfNotExists)(Array.prototype, 'enumerate', function () {
     return this.map((value, index) => [value, index]);
 });
+/**
+ * @see Array.prototype.sortAsc
+ * @see Array.prototype.sortDesc
+ */
 (0, core_utils_1.defineIfNotExists)(Array.prototype, 'sortBy', function (direction, selector) {
     if (this.length === 0)
         return this.slice();
     const getValue = (0, core_utils_1.resolveSelector)(selector, (item) => item);
     if (!selector && !this.every((item) => (0, core_utils_1.isNumberOrString)(item))) {
-        throw new TypeError('Array elements must be number or string if no selector is provided');
+        (0, core_utils_1.utilitishError)('Array.prototype.sortBy', 'array elements must be number or string if no selector is provided');
     }
     return this.slice().sort((a, b) => {
         const valA = getValue(a);
         const valB = getValue(b);
         if (!(0, core_utils_1.isNumberOrString)(valA) || !(0, core_utils_1.isNumberOrString)(valB)) {
-            throw new TypeError('Selector must return number or string');
+            (0, core_utils_1.utilitishError)('Array.prototype.sortBy', 'selector must return number or string');
         }
         if (valA > valB)
             return direction === 'asc' ? 1 : -1;
@@ -77,19 +111,34 @@ const logic_utils_1 = require("../utils/logic.utils");
         return 0;
     });
 });
+/**
+ * @see Array.prototype.sortAsc
+ */
 (0, core_utils_1.defineIfNotExists)(Array.prototype, 'sortAsc', function (selector) {
     return (0, logic_utils_1.sortBy)(this, 'asc', selector);
 });
+/**
+ * @see Array.prototype.sortDesc
+ */
 (0, core_utils_1.defineIfNotExists)(Array.prototype, 'sortDesc', function (selector) {
     return (0, logic_utils_1.sortBy)(this, 'desc', selector);
 });
+/**
+ * @see Array.prototype.swap
+ */
 (0, core_utils_1.defineIfNotExists)(Array.prototype, 'swap', function (i, j) {
-    if (typeof i !== 'number' || typeof j !== 'number' || !Number.isInteger(i) || !Number.isInteger(j)) {
-        throw new TypeError('Indices must be integers');
-    }
-    if (i < 0 || i >= this.length || j < 0 || j >= this.length) {
-        throw new RangeError('Index out of bounds');
-    }
+    if (typeof i !== 'number')
+        (0, core_utils_1.utilitishError)('Array.prototype.swap', 'i must be a number', i);
+    if (typeof j !== 'number')
+        (0, core_utils_1.utilitishError)('Array.prototype.swap', 'j must be a number', j);
+    if (!Number.isInteger(i))
+        (0, core_utils_1.utilitishError)('Array.prototype.swap', 'i must be an integer', i);
+    if (!Number.isInteger(j))
+        (0, core_utils_1.utilitishError)('Array.prototype.swap', 'j must be an integer', j);
+    if (i < 0 || i >= this.length)
+        (0, core_utils_1.utilitishError)('Array.prototype.swap', 'i is out of bounds', i, RangeError);
+    if (j < 0 || j >= this.length)
+        (0, core_utils_1.utilitishError)('Array.prototype.swap', 'j is out of bounds', j, RangeError);
     if (i !== j) {
         const temp = this[i];
         this[i] = this[j];
@@ -97,6 +146,9 @@ const logic_utils_1 = require("../utils/logic.utils");
     }
     return this;
 });
+/**
+ * @see Array.prototype.shuffle
+ */
 (0, core_utils_1.defineIfNotExists)(Array.prototype, 'shuffle', function () {
     const arr = this.slice();
     for (let i = arr.length - 1; i > 0; i--) {
@@ -105,6 +157,9 @@ const logic_utils_1 = require("../utils/logic.utils");
     }
     return arr;
 });
+/**
+ * @see Array.prototype.toMap
+ */
 (0, core_utils_1.defineIfNotExists)(Array.prototype, 'toMap', function (keySelector, valueSelector) {
     if (!keySelector && this.length && this.every((item) => Array.isArray(item) && item.length === 2)) {
         return new Map(this);
@@ -120,6 +175,9 @@ const logic_utils_1 = require("../utils/logic.utils");
     }
     return map;
 });
+/**
+ * @see Array.prototype.toObject
+ */
 (0, core_utils_1.defineIfNotExists)(Array.prototype, 'toObject', function (keySelector, valueSelector) {
     let entries;
     if (!keySelector && this.length && this.every((item) => Array.isArray(item) && item.length === 2)) {
@@ -142,10 +200,16 @@ const logic_utils_1 = require("../utils/logic.utils");
     }
     return Object.fromEntries(entries);
 });
+/**
+ * @see Array.prototype.toSet
+ */
 (0, core_utils_1.defineIfNotExists)(Array.prototype, 'toSet', function (selector) {
     const getValue = (0, core_utils_1.resolveSelector)(selector, (item) => item);
     return new Set(this.map(getValue));
 });
+/**
+ * @see Array.prototype.countBy
+ */
 (0, core_utils_1.defineIfNotExists)(Array.prototype, 'countBy', function (selector) {
     const getKey = (0, core_utils_1.resolveSelector)(selector, (item) => item);
     const map = new Map();
@@ -155,3 +219,16 @@ const logic_utils_1 = require("../utils/logic.utils");
     }
     return map;
 });
+/**
+ * @see Array.prototype.slugifyIncludes
+ */
+(0, core_utils_1.defineIfNotExists)(Array.prototype, 'slugifyIncludes', function (value) {
+    if (typeof value !== 'string')
+        (0, core_utils_1.utilitishError)('Array.prototype.slugifyIncludes', 'must be a string', value);
+    const slugified = value.slugify();
+    return this.some((item) => {
+        if (typeof item !== 'string')
+            (0, core_utils_1.utilitishError)('Array.prototype.slugifyIncludes', 'all array items must be strings', item);
+        return item.slugify() === slugified;
+    });
+});

package/dist/array/array-prototype.spec.js

@@ -97,8 +97,8 @@ describe('Array.prototype', () => {
         describe('error handling', () => {
             it('should throw TypeError when size is not a positive integer', () => {
                 const arr = [1, 2, 3];
-                expect(() => arr.chunk(0)).toThrow(TypeError);
-                expect(() => arr.chunk(-1)).toThrow(TypeError);
+                expect(() => arr.chunk(0)).toThrow(RangeError);
+                expect(() => arr.chunk(-1)).toThrow(RangeError);
                 expect(() => arr.chunk(1.5)).toThrow(TypeError);
                 expect(() => arr.chunk('a')).toThrow(TypeError);
             });
@@ -409,7 +409,7 @@ describe('Array.prototype', () => {
         });
     });
     describe('Array.prototype.toObject', () => {
-        it('converts array of pairs to object', () => {
+        it('should converts array of pairs to object', () => {
             const arr = [
                 ['a', 1],
                 ['b', 2],
@@ -419,7 +419,7 @@ describe('Array.prototype', () => {
             expect(obj).toEqual({ a: 1, b: 2, c: 3 });
             expect(typeof obj).toBe('object');
         });
-        it('converts array of pairs with numeric keys to object', () => {
+        it('should converts array of pairs with numeric keys to object', () => {
             const arr = [
                 [1, 'a'],
                 [2, 'b'],
@@ -428,7 +428,7 @@ describe('Array.prototype', () => {
             const obj = arr.toObject();
             expect(obj).toEqual({ 1: 'a', 2: 'b', 3: 'c' });
         });
-        it('converts array of objects to object using key string', () => {
+        it('should converts array of objects to object using key string', () => {
             const arr = [
                 { id: 1, name: 'foo' },
                 { id: 2, name: 'bar' },
@@ -439,7 +439,7 @@ describe('Array.prototype', () => {
                 2: { id: 2, name: 'bar' },
             });
         });
-        it('converts array of objects to object using key callback', () => {
+        it('should converts array of objects to object using key callback', () => {
             const arr = [
                 { id: 1, name: 'foo' },
                 { id: 2, name: 'bar' },
@@ -450,7 +450,7 @@ describe('Array.prototype', () => {
                 2: { id: 2, name: 'bar' },
             });
         });
-        it('converts array of objects using key callback and value callback', () => {
+        it('should converts array of objects using key callback and value callback', () => {
             const arr = [
                 { id: 1, name: 'foo' },
                 { id: 2, name: 'bar' },
@@ -461,7 +461,7 @@ describe('Array.prototype', () => {
                 2: 'bar',
             });
         });
-        it('converts array without selector (uses index as key)', () => {
+        it('should converts array without selector (uses index as key)', () => {
             const arr = ['a', 'b', 'c'];
             const obj = arr.toObject();
             expect(obj).toEqual({
@@ -470,12 +470,12 @@ describe('Array.prototype', () => {
                 2: 'c',
             });
         });
-        it('converts empty array to empty object', () => {
+        it('should converts empty array to empty object', () => {
             const arr = [];
             const obj = arr.toObject();
             expect(obj).toEqual({});
         });
-        it('handles objects with string and numeric keys', () => {
+        it('should handles objects with string and numeric keys', () => {
             const arr = [
                 { key: 'name', value: 'Alice' },
                 { key: 'age', value: 30 },
@@ -486,19 +486,19 @@ describe('Array.prototype', () => {
                 age: 30,
             });
         });
-        it('throws error when key selector returns null', () => {
+        it('should throws error when key selector returns null', () => {
             const arr = [{ id: 1, name: 'foo' }];
             expect(() => arr.toObject((x) => null, (x) => x.name)).toThrow(TypeError);
         });
-        it('throws error when key selector returns undefined', () => {
+        it('should throws error when key selector returns undefined', () => {
             const arr = [{ id: 1, name: 'foo' }];
             expect(() => arr.toObject((x) => undefined, (x) => x.name)).toThrow(TypeError);
         });
-        it('throws error when key is not a string or number', () => {
+        it('should throws error when key is not a string or number', () => {
             const arr = [{ id: { nested: 1 }, name: 'foo' }];
             expect(() => arr.toObject((x) => x.id)).toThrow(TypeError);
         });
-        it('overwrites duplicate keys with the last value', () => {
+        it('should overwrites duplicate keys with the last value', () => {
             const arr = [
                 { id: 1, value: 'first' },
                 { id: 1, value: 'second' },
@@ -508,7 +508,7 @@ describe('Array.prototype', () => {
                 1: 'second',
             });
         });
-        it('handles mixed types in array', () => {
+        it('should handles mixed types in array', () => {
             const arr = [
                 { id: 'x', value: 10 },
                 { id: 'y', value: 20 },
@@ -519,7 +519,7 @@ describe('Array.prototype', () => {
                 y: 20,
             });
         });
-        it('converts with string key and different value types', () => {
+        it('should converts with string key and different value types', () => {
             const arr = [
                 { id: 1, data: 'text' },
                 { id: 2, data: 42 },

package/dist/map/map-prototype.js

@@ -13,20 +13,17 @@ const core_utils_1 = require("../utils/core.utils");
         case 'object': {
             const obj = {};
             for (const [key, value] of this) {
-                if (typeof key === 'string' || typeof key === 'number' || typeof key === 'symbol') {
-                    // For number keys, convert to string (object keys are always strings or symbols)
-                    obj[String(key)] = value;
-                }
-                else {
-                    throw new TypeError(`Map.prototype.toList('object') only supports string, number, or symbol keys. Got: ${typeof key}`);
+                if (typeof key !== 'string' && typeof key !== 'number' && typeof key !== 'symbol') {
+                    (0, core_utils_1.utilitishError)('Map.prototype.toList', `only supports string, number, or symbol keys`, key);
                 }
+                obj[String(key)] = value;
             }
             return obj;
         }
         case 'entries':
             return Array.from(this.entries());
         default:
-            throw new TypeError(`Unknown type "${type}" for Map.prototype.toList`);
+            return (0, core_utils_1.utilitishError)('Map.prototype.toList', `unknown type`, type);
     }
 });
 /**
@@ -35,12 +32,13 @@ const core_utils_1 = require("../utils/core.utils");
 (0, core_utils_1.defineIfNotExists)(Map.prototype, 'toObject', function () {
     const entries = Array.from(this.entries());
     for (const [key] of entries) {
-        if (key === null || key === undefined) {
-            throw new TypeError(`Invalid key: key cannot be null or undefined. Key received: ${String(key)}`);
-        }
+        if (key === null)
+            (0, core_utils_1.utilitishError)('Map.prototype.toObject', 'key cannot be null');
+        if (key === undefined)
+            (0, core_utils_1.utilitishError)('Map.prototype.toObject', 'key cannot be undefined');
         const keyType = typeof key;
         if (keyType !== 'string' && keyType !== 'number' && keyType !== 'symbol') {
-            throw new TypeError(`Invalid key type: keys must be string, number, or symbol, received ${keyType}. Key value: ${String(key)}`);
+            (0, core_utils_1.utilitishError)('Map.prototype.toObject', `keys must be string, number, or symbol`, key);
         }
     }
     return Object.fromEntries(entries);
@@ -49,15 +47,17 @@ const core_utils_1 = require("../utils/core.utils");
  * @see Map.prototype.ensureArray
  */
 (0, core_utils_1.defineIfNotExists)(Map.prototype, 'ensureArray', function (key) {
-    if (key === null || key === undefined) {
-        throw new TypeError('Key cannot be null or undefined');
-    }
-    if (!this.has(key)) {
-        this.set(key, []);
+    if (key === null)
+        (0, core_utils_1.utilitishError)('Map.prototype.ensureArray', 'key cannot be null');
+    if (key === undefined)
+        (0, core_utils_1.utilitishError)('Map.prototype.ensureArray', 'key cannot be undefined');
+    let arr = this.get(key);
+    if (arr === undefined) {
+        arr = [];
+        this.set(key, arr);
     }
-    const arr = this.get(key);
     if (!Array.isArray(arr)) {
-        throw new TypeError('Value for the key is not an array');
+        (0, core_utils_1.utilitishError)('Map.prototype.ensureArray', 'value for the key is not an array', arr);
     }
     return arr;
 });