utilitish 0.0.14 → 0.0.15

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;
 });

package/dist/object/object-prototype.js

@@ -11,9 +11,10 @@ const core_utils_1 = require("../utils/core.utils");
  * @see Object.prototype.deepMerge
  */
 (0, core_utils_1.defineIfNotExists)(Object.prototype, 'deepMerge', function (source) {
-    if (typeof source !== 'object' || source === null) {
-        throw new TypeError('Source must be a non-null object');
-    }
+    if (typeof source !== 'object')
+        (0, core_utils_1.utilitishError)('Object.prototype.deepMerge', 'source must be an object', source);
+    if (source === null)
+        (0, core_utils_1.utilitishError)('Object.prototype.deepMerge', 'source cannot be null', source);
     const isObject = (val) => val !== null && typeof val === 'object' && !Array.isArray(val);
     const merge = (target, source) => {
         for (const key of Object.keys(source)) {

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

@@ -24,13 +24,11 @@ describe('Object.prototype', () => {
             const source = { b: { d: 3 }, e: 4 };
             const merged = obj.deepMerge(source);
             expect(merged).toEqual({ a: 1, b: { c: 2, d: 3 }, e: 4 });
-            console.log(merged);
         });
         it('should overwrite primitive values', () => {
             const obj = { a: 1, b: 2 };
             const merged = obj.deepMerge({ b: 3 });
             expect(merged).toEqual({ a: 1, b: 3 });
-            console.log(merged);
         });
         describe('error handling', () => {
             it('should throw if source is not an object', () => {

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

@@ -15,7 +15,7 @@ declare global {
          * - Returns a new array instance each time; modifying it does not affect the Set
          * - Empty sets return an empty array
          */
-        toList<T>(): T[];
+        toList(): T[];
         /**
          * Returns true if at least one of the given items is present in the Set.
          *

package/dist/set/set-prototype.js

@@ -13,7 +13,7 @@ const core_utils_1 = require("../utils/core.utils");
  */
 (0, core_utils_1.defineIfNotExists)(Set.prototype, 'hasAny', function (...items) {
     if (!Array.isArray(items))
-        throw new TypeError('Arguments must be an array');
+        (0, core_utils_1.utilitishError)('Set.prototype.hasAny', 'arguments must be an array', items);
     if (items.length === 0)
         return false;
     return items.some((item) => this.has(item));
@@ -32,7 +32,7 @@ const core_utils_1 = require("../utils/core.utils");
         values = args;
     }
     if (!Array.isArray(values))
-        throw new TypeError('Arguments must be an array or a Set');
+        (0, core_utils_1.utilitishError)('Set.prototype.includes', 'arguments must be an array or a Set', args);
     return values.every((item) => this.has(item));
 });
 /**
@@ -42,7 +42,7 @@ const core_utils_1 = require("../utils/core.utils");
     const result = new Set(this);
     for (const other of others) {
         if (!(other instanceof Set))
-            throw new TypeError('Arguments must be Sets');
+            (0, core_utils_1.utilitishError)('Set.prototype.union', 'arguments must be Sets', other);
         for (const item of other) {
             result.add(item);
         }
@@ -54,7 +54,7 @@ const core_utils_1 = require("../utils/core.utils");
  */
 (0, core_utils_1.defineIfNotExists)(Set.prototype, 'intersection', function (...others) {
     if (others.some((s) => !(s instanceof Set)))
-        throw new TypeError('Arguments must be Sets');
+        (0, core_utils_1.utilitishError)('Set.prototype.intersection', 'arguments must be Sets', others);
     const result = new Set();
     for (const item of this) {
         if (others.every((set) => set.has(item))) {

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

@@ -194,6 +194,103 @@ declare global {
          */
         slugify(): string;
         slugify(config: SlugifyConfig): string;
+        /**
+         * Compares two strings by slugifying both and checking if they are equal.
+         * Useful for case-insensitive and accent-insensitive string comparison.
+         *
+         * @this {string} The first string to compare.
+         * @param {string} other - The second string to compare.
+         * @returns {boolean} `true` if both slugified strings are equal, `false` otherwise.
+         * @throws {TypeError} If `other` is not a string.
+         *
+         * @example
+         * 'Hello World'.slugifyEquals('hello-world');   // true
+         * 'Héllo World'.slugifyEquals('hello-world');   // true
+         * 'Hello World'.slugifyEquals('goodbye-world'); // false
+         *
+         * @remarks
+         * - Both strings are slugified before comparison.
+         * - Since `slugify` is idempotent, passing an already-slugified string works as expected.
+         * - Useful for comparing user-provided strings with stored slugs.
+         */
+        slugifyEquals(other: string): boolean;
+        /**
+         * Checks if the slugified version of this string includes the slugified version of another.
+         * Useful for case-insensitive and accent-insensitive substring search.
+         *
+         * @this {string} The string to search in.
+         * @param {string} other - The string to search for.
+         * @returns {boolean} `true` if the slugified string contains the slugified `other`, `false` otherwise.
+         * @throws {TypeError} If `other` is not a string.
+         *
+         * @example
+         * 'Hello World'.slugifyIncludes('hello');      // true
+         * 'Héllo World'.slugifyIncludes('hello');      // true
+         * 'Hello World'.slugifyIncludes('goodbye');    // false
+         *
+         * @remarks
+         * - Both strings are slugified before comparison.
+         * - Since `slugify` is idempotent, passing an already-slugified string works as expected.
+         */
+        slugifyIncludes(other: string): boolean;
+        /**
+         * Checks if the slugified version of this string starts with the slugified version of another.
+         * Useful for case-insensitive and accent-insensitive prefix matching.
+         *
+         * @this {string} The string to check.
+         * @param {string} other - The prefix to check against.
+         * @returns {boolean} `true` if the slugified string starts with the slugified `other`, `false` otherwise.
+         * @throws {TypeError} If `other` is not a string.
+         *
+         * @example
+         * 'Hello World'.slugifyStartsWith('hello');    // true
+         * 'Héllo World'.slugifyStartsWith('hello');    // true
+         * 'Hello World'.slugifyStartsWith('world');    // false
+         *
+         * @remarks
+         * - Both strings are slugified before comparison.
+         * - Since `slugify` is idempotent, passing an already-slugified string works as expected.
+         */
+        slugifyStartsWith(other: string): boolean;
+        /**
+         * Checks if the slugified version of this string ends with the slugified version of another.
+         * Useful for case-insensitive and accent-insensitive suffix matching.
+         *
+         * @this {string} The string to check.
+         * @param {string} other - The suffix to check against.
+         * @returns {boolean} `true` if the slugified string ends with the slugified `other`, `false` otherwise.
+         * @throws {TypeError} If `other` is not a string.
+         *
+         * @example
+         * 'Hello World'.slugifyEndsWith('world');      // true
+         * 'Héllo World'.slugifyEndsWith('world');      // true
+         * 'Hello World'.slugifyEndsWith('hello');      // false
+         *
+         * @remarks
+         * - Both strings are slugified before comparison.
+         * - Since `slugify` is idempotent, passing an already-slugified string works as expected.
+         */
+        slugifyEndsWith(other: string): boolean;
+        /**
+         * Checks if the slugified version of this string matches any slugified string in a list.
+         * Useful for case-insensitive and accent-insensitive list lookup.
+         *
+         * @this {string} The string to search for.
+         * @param {string[]} list - The array of strings to search in.
+         * @returns {boolean} `true` if any slugified item in the list equals the slugified string, `false` otherwise.
+         * @throws {TypeError} If `list` is not an array.
+         * @throws {TypeError} If `list` contains non-string items.
+         *
+         * @example
+         * 'Hello World'.slugifyIn(['hello-world', 'foo']); // true
+         * 'Héllo World'.slugifyIn(['hello-world', 'foo']); // true
+         * 'Hello World'.slugifyIn(['foo', 'bar']);          // false
+         *
+         * @remarks
+         * - All strings are slugified before comparison.
+         * - Since `slugify` is idempotent, mixing raw and already-slugified strings in the list works as expected.
+         */
+        slugifyIn(list: string[]): boolean;
         /**
          * Replaces a substring between `start` and `end` indices with a given string.
          * Provides precise control over which portion of the string to replace.