clear-af.js 1.0.4 → 1.0.6

package/dist/index.d.ts

@@ -1,246 +1,5 @@
-/**
- * =======================
- * Functions for utilities
- * =======================
- */
-declare function getDate(time?: boolean): string;
-/**
- * Show a pretty error log message with optional date information
- * @category Logging
- * @function prettyError
- * @param err - Error message to display
- * @param time - Include or not a timestamp
- * @example
- * prettyError("Database connection failed");
- * // Output: ✕ - Database connection failed (in red)
- *
- * prettyError("Critical error", true);
- * // Output: ✕ [30/03/2026 10:30:45] - Critical error (in red with timestamp)
- */
-declare function prettyError(err: string, time?: boolean): void;
-/**
- * Show a pretty warn log message with optional date information
- * @category Logging
- * @function prettyWarn
- * @param warn - Warning message to display
- * @param time - Include or not a timestamp
- * @example
- * prettyWarn("Deprecated function used");
- * // Output: ⚠ - Deprecated function used (in orange)
- *
- * prettyWarn("Low memory", true);
- * // Output: ⚠ [30/03/2026 10:30:45] - Low memory (in orange with timestamp)
- */
-declare function prettyWarn(warn: string, time?: boolean): void;
-/**
- * Show a pretty success log message with optional date information
- * @category Logging
- * @function prettySuccess
- * @param success - Success message to display
- * @param time - Include or not a timestamp
- * @example
- * prettySuccess("User created successfully");
- * // Output: ✔ - User created successfully (in green)
- *
- * prettySuccess("Data saved", true);
- * // Output: ✔ [30/03/2026 10:30:45] - Data saved (in green with timestamp)
- */
-declare function prettySuccess(success: string, time?: boolean): void;
-/**
- * Show a pretty information log message with optional date information
- * @category Logging
- * @function prettyInfo
- * @param info - Information message to display
- * @param time - Include or not a timestamp
- * @example
- * prettyInfo("Server is running on port 3000");
- * // Output: ℹ - Server is running on port 3000 (in blue)
- *
- * prettyInfo("Cache cleared", true);
- * // Output: ℹ [30/03/2026 10:30:45] - Cache cleared (in blue with timestamp)
- */
-declare function prettyInfo(info: string, time?: boolean): void;
-/**
- * Show a pretty debug log message with optional date information
- * @category Logging
- * @function prettyDebug
- * @param debug - Debug message to display
- * @param time - Include or not a timestamp
- * @example
- * prettyDebug("Variable x = 42");
- * // Output: ⚙ - Variable x = 42 (in white)
- *
- * prettyDebug("Function call trace", true);
- * // Output: ⚙ [30/03/2026 10:30:45] - Function call trace (in white with timestamp)
- */
-declare function prettyDebug(debug: string, time?: boolean): void;
-/**
- * Show a separator line in console
- * @category Logging
- * @function logSeparator
- * @example
- * logSeparator();
- * // Output: ══════════════════════════════════════════════════
- */
-declare function logSeparator(): void;
-/**
- * Display a header with a title in the center
- * @category Logging
- * @function logHeader
- * @param title - The title of the header
- * @example
- * logHeader("Welcome");
- * // Output:
- * // ╔═════════╗
- * // ║ Welcome ║
- * // ╚═════════╝
- */
-declare function logHeader(title: string): void;
-/**
- *
- * Validation utilities
- *
- */
-/**
- * Check if any type of variable is empty
- * @category Validation
- * @function isEmpty
- * @param value - The variable to check
- * @returns {boolean} True if the value is empty, false otherwise
- * @example
- * isEmpty("");          // true
- * isEmpty("   ");       // true
- * isEmpty(null);        // true
- * isEmpty([]);          // true
- * isEmpty({});          // true
- * isEmpty("hello");     // false
- * isEmpty([1, 2]);      // false
- */
-declare function isEmpty(value: unknown): boolean;
-/**
- * Check if the variable is of the chosen type
- * @category Validation
- * @function isType
- * @param value - The variable to check
- * @param type - The type you want
- * @returns {boolean} True if the value is of the chosen type, false otherwise
- * @example
- * isType("hello", "string");    // true
- * isType(42, "number");         // true
- * isType([], "object");         // true
- * isType("42", "number");       // false
- */
-declare function isType(value: unknown, type: string): boolean;
-/**
- * Check if an email is valid
- * @category Validation
- * @function isEmail
- * @param email - The email to check
- * @returns {boolean} True if the email is valid, false otherwise
- * @example
- * isEmail("alice@example.com");      // true
- * isEmail("bob.smith@company.co.uk"); // true
- * isEmail("invalid@.com");           // false
- * isEmail("no-at-sign.com");         // false
- */
-declare function isEmail(email: string): boolean;
-/**
- * Check if a URL is valid
- * @category Validation
- * @function isURL
- * @param url - The URL to check
- * @returns {boolean} True if the URL is valid, false otherwise
- * @example
- * isURL("https://www.example.com");     // true
- * isURL("http://example.com/path");     // true
- * isURL("www.example.com");             // false (missing protocol)
- * isURL("not a url");                   // false
- */
-declare function isURL(url: string): boolean;
-/**
- *
- * Object manipulation
- *
- */
-/**
- * Create a deep clone of any object or array
- * @category Object Manipulation
- * @function deepClone
- * @param obj - The object or array to clone
- * @returns A deep clone of the object
- * @example
- * const user = { name: "Alice", skills: ["JS", "TS"] };
- * const clone = deepClone(user);
- * clone.name = "Bob";
- * clone.skills[0] = "Python";
- * console.log(user.name);    // "Alice" (unchanged)
- * console.log(user.skills[0]); // "JS" (unchanged)
- */
-declare function deepClone<T>(obj: T): T;
-/**
- * Remove duplicate values from an array
- * @category Object Manipulation
- * @function noTwins
- * @param arr - The array to remove duplicates from
- * @returns {unknown[]} A new array with unique values only
- * @example
- * noTwins([1, 2, 2, 3, 3, 3]);        // [1, 2, 3]
- * noTwins(["a", "b", "a", "c"]);      // ["a", "b", "c"]
- * noTwins([1, "1", 1, "1"]);          // [1, "1"]
- */
-declare function noTwins(arr: unknown[]): unknown[];
-/**
- *
- * Transformation utilites
- *
- */
-/**
- * Transform a string to camelCase format
- * @category Transformation
- * @function camelify
- * @param str - The string to transform
- * @returns {string} The string in camelCase format
- * @example
- * camelify("hello world");       // "helloWorld"
- * camelify("C'est un test");     // "cestUnTest"
- * camelify("foo bar baz");       // "fooBarBaz"
- */
-declare function camelify(str: string): string;
-/**
- * Transform a string to kebab-case format
- * @category Transformation
- * @function kebabify
- * @param str - The string to transform
- * @returns {string} The string in kebab-case format
- * @example
- * kebabify("hello world");       // "hello-world"
- * kebabify("C'est un test");     // "ceststun-test"
- * kebabify("foo bar baz");       // "foo-bar-baz"
- */
-declare function kebabify(str: string): string;
-/**
- * Transform a string to snake_case format
- * @category Transformation
- * @function snakify
- * @param str - The string to transform
- * @returns {string} The string in snake_case format
- * @example
- * snakify("hello world");        // "hello_world"
- * snakify("C'est un test");      // "ceststun_test"
- * snakify("foo bar baz");        // "foo_bar_baz"
- */
-declare function snakify(str: string): string;
-/**
- * Capitalize the first character of a string
- * @category Transformation
- * @function capitalize
- * @param str - The string to capitalize
- * @returns {string} The string with the first character in uppercase
- * @example
- * capitalize("hello");        // "Hello"
- * capitalize("hello world");  // "Hello world"
- * capitalize("");             // ""
- */
-declare function capitalize(str: string): string;
-export { getDate, prettyError, prettyWarn, prettySuccess, prettyInfo, prettyDebug, logSeparator, logHeader, isEmpty, isType, isEmail, isURL, deepClone, noTwins, camelify, kebabify, snakify, capitalize };
+export { prettyError, prettyWarn, prettySuccess, prettyInfo, prettyDebug, logSeparator, logHeader } from './logging';
+export * from './validation';
+export * from './transformation';
+export * from './object_manipulation';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AASA;;;;GAIG;AACH,iBAAS,OAAO,CAAC,IAAI,GAAE,OAAe,GAAG,MAAM,CAE9C;AAQD;;;;;;;;;;;;GAYG;AACH,iBAAS,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,UAAQ,GAAG,IAAI,CAGpD;AAED;;;;;;;;;;;;GAYG;AACH,iBAAS,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,UAAQ,GAAG,IAAI,CAGpD;AAED;;;;;;;;;;;;GAYG;AACH,iBAAS,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,UAAQ,GAAG,IAAI,CAG1D;AAED;;;;;;;;;;;;GAYG;AACH,iBAAS,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,UAAQ,GAAG,IAAI,CAGpD;AAED;;;;;;;;;;;;GAYG;AACH,iBAAS,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,UAAQ,GAAG,IAAI,CAGtD;AAED;;;;;;;GAOG;AACH,iBAAS,YAAY,IAAI,IAAI,CAE5B;AAED;;;;;;;;;;;GAWG;AACH,iBAAS,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAItC;AAED;;;;GAIG;AAEH;;;;;;;;;;;;;;GAcG;AACH,iBAAS,OAAO,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAMxC;AAED;;;;;;;;;;;;GAYG;AACH,iBAAS,MAAM,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAErD;AAED;;;;;;;;;;;GAWG;AACH,iBAAS,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAGvC;AAED;;;;;;;;;;;GAWG;AACH,iBAAS,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAOnC;AAED;;;;GAIG;AAEH;;;;;;;;;;;;;GAaG;AACH,iBAAS,SAAS,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,CAU/B;AAED;;;;;;;;;;GAUG;AACH,iBAAS,OAAO,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,OAAO,EAAE,CAE1C;AAED;;;;GAIG;AAEH;;;;;;;;;;GAUG;AACH,iBAAS,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAarC;AAED;;;;;;;;;;GAUG;AACH,iBAAS,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CASrC;AAED;;;;;;;;;;GAUG;AACH,iBAAS,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CASpC;AAED;;;;;;;;;;GAUG;AACH,iBAAS,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAGvC;AAKD,OAAO,EACH,OAAO,EACP,WAAW,EACX,UAAU,EACV,aAAa,EACb,UAAU,EACV,WAAW,EACX,YAAY,EACZ,SAAS,EACT,OAAO,EACP,MAAM,EACN,OAAO,EACP,KAAK,EACL,SAAS,EACT,OAAO,EACP,QAAQ,EACR,QAAQ,EACR,OAAO,EACP,UAAU,EACb,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,WAAW,EAAE,UAAU,EAAE,aAAa,EAAE,UAAU,EAAE,WAAW,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AACrH,cAAc,cAAc,CAAC;AAC7B,cAAc,kBAAkB,CAAC;AACjC,cAAc,uBAAuB,CAAC"}

package/dist/index.js

@@ -7,365 +7,30 @@
 
 Made by FroostDev | https://github.com/FroostDev - MIT Licence
 */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getDate = getDate;
-exports.prettyError = prettyError;
-exports.prettyWarn = prettyWarn;
-exports.prettySuccess = prettySuccess;
-exports.prettyInfo = prettyInfo;
-exports.prettyDebug = prettyDebug;
-exports.logSeparator = logSeparator;
-exports.logHeader = logHeader;
-exports.isEmpty = isEmpty;
-exports.isType = isType;
-exports.isEmail = isEmail;
-exports.isURL = isURL;
-exports.deepClone = deepClone;
-exports.noTwins = noTwins;
-exports.camelify = camelify;
-exports.kebabify = kebabify;
-exports.snakify = snakify;
-exports.capitalize = capitalize;
-/**
- * =======================
- * Functions for utilities
- * =======================
- */
-function getDate(time = false) {
-    return time ? `[${new Date().toLocaleString()}]` : '';
-}
-/*
- * =================
- * Logging utilities
- * =================
- */
-/**
- * Show a pretty error log message with optional date information
- * @category Logging
- * @function prettyError
- * @param err - Error message to display
- * @param time - Include or not a timestamp
- * @example
- * prettyError("Database connection failed");
- * // Output: ✕ - Database connection failed (in red)
- *
- * prettyError("Critical error", true);
- * // Output: ✕ [30/03/2026 10:30:45] - Critical error (in red with timestamp)
- */
-function prettyError(err, time = false) {
-    const date = getDate(time);
-    console.log(`\x1b[1;41m ✕ ${date} - ${err} \x1b[0m`);
-}
-/**
- * Show a pretty warn log message with optional date information
- * @category Logging
- * @function prettyWarn
- * @param warn - Warning message to display
- * @param time - Include or not a timestamp
- * @example
- * prettyWarn("Deprecated function used");
- * // Output: ⚠ - Deprecated function used (in orange)
- *
- * prettyWarn("Low memory", true);
- * // Output: ⚠ [30/03/2026 10:30:45] - Low memory (in orange with timestamp)
- */
-function prettyWarn(warn, time = false) {
-    const date = getDate(time);
-    console.log(`\x1b[1;43m ⚠ ${date} - ${warn} \x1b[0m`);
-}
-/**
- * Show a pretty success log message with optional date information
- * @category Logging
- * @function prettySuccess
- * @param success - Success message to display
- * @param time - Include or not a timestamp
- * @example
- * prettySuccess("User created successfully");
- * // Output: ✔ - User created successfully (in green)
- *
- * prettySuccess("Data saved", true);
- * // Output: ✔ [30/03/2026 10:30:45] - Data saved (in green with timestamp)
- */
-function prettySuccess(success, time = false) {
-    const date = getDate(time);
-    console.log(`\x1b[1;42m ✔ ${date} - ${success} \x1b[0m`);
-}
-/**
- * Show a pretty information log message with optional date information
- * @category Logging
- * @function prettyInfo
- * @param info - Information message to display
- * @param time - Include or not a timestamp
- * @example
- * prettyInfo("Server is running on port 3000");
- * // Output: ℹ - Server is running on port 3000 (in blue)
- *
- * prettyInfo("Cache cleared", true);
- * // Output: ℹ [30/03/2026 10:30:45] - Cache cleared (in blue with timestamp)
- */
-function prettyInfo(info, time = false) {
-    const date = getDate(time);
-    console.log(`\x1b[1;44m ℹ ${date} - ${info} \x1b[0m`);
-}
-/**
- * Show a pretty debug log message with optional date information
- * @category Logging
- * @function prettyDebug
- * @param debug - Debug message to display
- * @param time - Include or not a timestamp
- * @example
- * prettyDebug("Variable x = 42");
- * // Output: ⚙ - Variable x = 42 (in white)
- *
- * prettyDebug("Function call trace", true);
- * // Output: ⚙ [30/03/2026 10:30:45] - Function call trace (in white with timestamp)
- */
-function prettyDebug(debug, time = false) {
-    const date = getDate(time);
-    console.log(`\x1b[1;97m ⚙ ${date} - ${debug} \x1b[0m`);
-}
-/**
- * Show a separator line in console
- * @category Logging
- * @function logSeparator
- * @example
- * logSeparator();
- * // Output: ══════════════════════════════════════════════════
- */
-function logSeparator() {
-    console.log(`\x1b[1m${'═'.repeat(50)}\x1b[0m`);
-}
-/**
- * Display a header with a title in the center
- * @category Logging
- * @function logHeader
- * @param title - The title of the header
- * @example
- * logHeader("Welcome");
- * // Output:
- * // ╔═════════╗
- * // ║ Welcome ║
- * // ╚═════════╝
- */
-function logHeader(title) {
-    console.log(`\x1b[1m╔${'═'.repeat(title.length + 2)}╗\x1b[0m`);
-    console.log(`\x1b[1m║ ${title} ║\x1b[0m`);
-    console.log(`\x1b[1m╚${'═'.repeat(title.length + 2)}╝\x1b[0m`);
-}
-/**
- *
- * Validation utilities
- *
- */
-/**
- * Check if any type of variable is empty
- * @category Validation
- * @function isEmpty
- * @param value - The variable to check
- * @returns {boolean} True if the value is empty, false otherwise
- * @example
- * isEmpty("");          // true
- * isEmpty("   ");       // true
- * isEmpty(null);        // true
- * isEmpty([]);          // true
- * isEmpty({});          // true
- * isEmpty("hello");     // false
- * isEmpty([1, 2]);      // false
- */
-function isEmpty(value) {
-    if (value === null || value === undefined)
-        return true;
-    if (typeof value === "string")
-        return value.trim().length === 0;
-    if (Array.isArray(value))
-        return value.length === 0;
-    if (typeof value === "object")
-        return Object.keys(value).length === 0;
-    return false;
-}
-/**
- * Check if the variable is of the chosen type
- * @category Validation
- * @function isType
- * @param value - The variable to check
- * @param type - The type you want
- * @returns {boolean} True if the value is of the chosen type, false otherwise
- * @example
- * isType("hello", "string");    // true
- * isType(42, "number");         // true
- * isType([], "object");         // true
- * isType("42", "number");       // false
- */
-function isType(value, type) {
-    return typeof value === type;
-}
-/**
- * Check if an email is valid
- * @category Validation
- * @function isEmail
- * @param email - The email to check
- * @returns {boolean} True if the email is valid, false otherwise
- * @example
- * isEmail("alice@example.com");      // true
- * isEmail("bob.smith@company.co.uk"); // true
- * isEmail("invalid@.com");           // false
- * isEmail("no-at-sign.com");         // false
- */
-function isEmail(email) {
-    const regex = /^[a-zA-Z0-9._%-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/;
-    return regex.test(email);
-}
-/**
- * Check if a URL is valid
- * @category Validation
- * @function isURL
- * @param url - The URL to check
- * @returns {boolean} True if the URL is valid, false otherwise
- * @example
- * isURL("https://www.example.com");     // true
- * isURL("http://example.com/path");     // true
- * isURL("www.example.com");             // false (missing protocol)
- * isURL("not a url");                   // false
- */
-function isURL(url) {
-    try {
-        new URL(url);
-        return true;
-    }
-    catch (error) {
-        return false;
-    }
-}
-/**
- *
- * Object manipulation
- *
- */
-/**
- * Create a deep clone of any object or array
- * @category Object Manipulation
- * @function deepClone
- * @param obj - The object or array to clone
- * @returns A deep clone of the object
- * @example
- * const user = { name: "Alice", skills: ["JS", "TS"] };
- * const clone = deepClone(user);
- * clone.name = "Bob";
- * clone.skills[0] = "Python";
- * console.log(user.name);    // "Alice" (unchanged)
- * console.log(user.skills[0]); // "JS" (unchanged)
- */
-function deepClone(obj) {
-    if (obj === null || typeof obj !== "object")
-        return obj;
-    if (Array.isArray(obj))
-        return obj.map(item => deepClone(item));
-    const cloned = {};
-    for (const key in obj) {
-        if (obj.hasOwnProperty(key))
-            cloned[key] = deepClone(obj[key]);
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
     }
-    return cloned;
-}
-/**
- * Remove duplicate values from an array
- * @category Object Manipulation
- * @function noTwins
- * @param arr - The array to remove duplicates from
- * @returns {unknown[]} A new array with unique values only
- * @example
- * noTwins([1, 2, 2, 3, 3, 3]);        // [1, 2, 3]
- * noTwins(["a", "b", "a", "c"]);      // ["a", "b", "c"]
- * noTwins([1, "1", 1, "1"]);          // [1, "1"]
- */
-function noTwins(arr) {
-    return Array.from(new Set(arr));
-}
-/**
- *
- * Transformation utilites
- *
- */
-/**
- * Transform a string to camelCase format
- * @category Transformation
- * @function camelify
- * @param str - The string to transform
- * @returns {string} The string in camelCase format
- * @example
- * camelify("hello world");       // "helloWorld"
- * camelify("C'est un test");     // "cestUnTest"
- * camelify("foo bar baz");       // "fooBarBaz"
- */
-function camelify(str) {
-    let camelCased = "";
-    if (!isEmpty(str)) {
-        let cleaned = str.replace(/[^a-zA-Z0-9\s]/g, "");
-        let toCamelify = cleaned.split(" ");
-        camelCased = toCamelify.map((word, index) => {
-            if (index === 0)
-                return word.toLowerCase();
-            return word[0].toUpperCase() + word.slice(1).toLowerCase();
-        })
-            .join('');
-    }
-    return camelCased;
-}
-/**
- * Transform a string to kebab-case format
- * @category Transformation
- * @function kebabify
- * @param str - The string to transform
- * @returns {string} The string in kebab-case format
- * @example
- * kebabify("hello world");       // "hello-world"
- * kebabify("C'est un test");     // "ceststun-test"
- * kebabify("foo bar baz");       // "foo-bar-baz"
- */
-function kebabify(str) {
-    let kebabised = "";
-    if (!isEmpty(str)) {
-        let cleaned = str.replace(/[^a-zA-Z0-9\s]/g, "");
-        let toKebabify = cleaned.split(" ");
-        kebabised = toKebabify.map(word => word.toLowerCase())
-            .join("-");
-    }
-    return kebabised;
-}
-/**
- * Transform a string to snake_case format
- * @category Transformation
- * @function snakify
- * @param str - The string to transform
- * @returns {string} The string in snake_case format
- * @example
- * snakify("hello world");        // "hello_world"
- * snakify("C'est un test");      // "ceststun_test"
- * snakify("foo bar baz");        // "foo_bar_baz"
- */
-function snakify(str) {
-    let snaked = "";
-    if (!isEmpty(str)) {
-        let cleaned = str.replace(/[^a-zA-Z0-9\s]/g, "");
-        let toSnakify = cleaned.split(" ");
-        snaked = toSnakify.map(word => word.toLowerCase())
-            .join("_");
-    }
-    return snaked;
-}
-/**
- * Capitalize the first character of a string
- * @category Transformation
- * @function capitalize
- * @param str - The string to capitalize
- * @returns {string} The string with the first character in uppercase
- * @example
- * capitalize("hello");        // "Hello"
- * capitalize("hello world");  // "Hello world"
- * capitalize("");             // ""
- */
-function capitalize(str) {
-    if (isEmpty(str))
-        return str;
-    return str[0].toUpperCase() + str.slice(1);
-}
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logHeader = exports.logSeparator = exports.prettyDebug = exports.prettyInfo = exports.prettySuccess = exports.prettyWarn = exports.prettyError = void 0;
+var logging_1 = require("./logging");
+Object.defineProperty(exports, "prettyError", { enumerable: true, get: function () { return logging_1.prettyError; } });
+Object.defineProperty(exports, "prettyWarn", { enumerable: true, get: function () { return logging_1.prettyWarn; } });
+Object.defineProperty(exports, "prettySuccess", { enumerable: true, get: function () { return logging_1.prettySuccess; } });
+Object.defineProperty(exports, "prettyInfo", { enumerable: true, get: function () { return logging_1.prettyInfo; } });
+Object.defineProperty(exports, "prettyDebug", { enumerable: true, get: function () { return logging_1.prettyDebug; } });
+Object.defineProperty(exports, "logSeparator", { enumerable: true, get: function () { return logging_1.logSeparator; } });
+Object.defineProperty(exports, "logHeader", { enumerable: true, get: function () { return logging_1.logHeader; } });
+__exportStar(require("./validation"), exports);
+__exportStar(require("./transformation"), exports);
+__exportStar(require("./object_manipulation"), exports);

package/dist/logging.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Show a pretty error log message with optional date information
+ * @category Logging
+ * @function prettyError
+ * @param err - Error message to display
+ * @param time - Include or not a timestamp
+ * @example
+ * prettyError("Database connection failed");
+ * // Output: ✕ - Database connection failed (in red)
+ *
+ * prettyError("Critical error", true);
+ * // Output: ✕ [30/03/2026 10:30:45] - Critical error (in red with timestamp)
+ */
+declare function prettyError(err: string, time?: boolean): void;
+/**
+ * Show a pretty warn log message with optional date information
+ * @category Logging
+ * @function prettyWarn
+ * @param warn - Warning message to display
+ * @param time - Include or not a timestamp
+ * @example
+ * prettyWarn("Deprecated function used");
+ * // Output: ⚠ - Deprecated function used (in orange)
+ *
+ * prettyWarn("Low memory", true);
+ * // Output: ⚠ [30/03/2026 10:30:45] - Low memory (in orange with timestamp)
+ */
+declare function prettyWarn(warn: string, time?: boolean): void;
+/**
+ * Show a pretty success log message with optional date information
+ * @category Logging
+ * @function prettySuccess
+ * @param success - Success message to display
+ * @param time - Include or not a timestamp
+ * @example
+ * prettySuccess("User created successfully");
+ * // Output: ✔ - User created successfully (in green)
+ *
+ * prettySuccess("Data saved", true);
+ * // Output: ✔ [30/03/2026 10:30:45] - Data saved (in green with timestamp)
+ */
+declare function prettySuccess(success: string, time?: boolean): void;
+/**
+ * Show a pretty information log message with optional date information
+ * @category Logging
+ * @function prettyInfo
+ * @param info - Information message to display
+ * @param time - Include or not a timestamp
+ * @example
+ * prettyInfo("Server is running on port 3000");
+ * // Output: ℹ - Server is running on port 3000 (in blue)
+ *
+ * prettyInfo("Cache cleared", true);
+ * // Output: ℹ [30/03/2026 10:30:45] - Cache cleared (in blue with timestamp)
+ */
+declare function prettyInfo(info: string, time?: boolean): void;
+/**
+ * Show a pretty debug log message with optional date information
+ * @category Logging
+ * @function prettyDebug
+ * @param debug - Debug message to display
+ * @param time - Include or not a timestamp
+ * @example
+ * prettyDebug("Variable x = 42");
+ * // Output: ⚙ - Variable x = 42 (in white)
+ *
+ * prettyDebug("Function call trace", true);
+ * // Output: ⚙ [30/03/2026 10:30:45] - Function call trace (in white with timestamp)
+ */
+declare function prettyDebug(debug: string, time?: boolean): void;
+/**
+ * Show a separator line in console
+ * @category Logging
+ * @function logSeparator
+ * @example
+ * logSeparator();
+ * // Output: ══════════════════════════════════════════════════
+ */
+declare function logSeparator(): void;
+/**
+ * Display a header with a title in the center
+ * @category Logging
+ * @function logHeader
+ * @param title - The title of the header
+ * @example
+ * logHeader("Welcome");
+ * // Output:
+ * // ╔═════════╗
+ * // ║ Welcome ║
+ * // ╚═════════╝
+ */
+declare function logHeader(title: string): void;
+export { prettyError, prettyWarn, prettySuccess, prettyInfo, prettyDebug, logSeparator, logHeader };
+//# sourceMappingURL=logging.d.ts.map

package/dist/logging.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logging.d.ts","sourceRoot":"","sources":["../src/logging.ts"],"names":[],"mappings":"AAQA;;;;;;;;;;;;GAYG;AACH,iBAAS,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,UAAQ,GAAG,IAAI,CAGpD;AAED;;;;;;;;;;;;GAYG;AACH,iBAAS,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,UAAQ,GAAG,IAAI,CAGpD;AAED;;;;;;;;;;;;GAYG;AACH,iBAAS,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,UAAQ,GAAG,IAAI,CAG1D;AAED;;;;;;;;;;;;GAYG;AACH,iBAAS,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,UAAQ,GAAG,IAAI,CAGpD;AAED;;;;;;;;;;;;GAYG;AACH,iBAAS,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,UAAQ,GAAG,IAAI,CAGtD;AAED;;;;;;;GAOG;AACH,iBAAS,YAAY,IAAI,IAAI,CAE5B;AAED;;;;;;;;;;;GAWG;AACH,iBAAS,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAItC;AAED,OAAO,EAAE,WAAW,EAAE,UAAU,EAAE,aAAa,EAAE,UAAU,EAAE,WAAW,EAAE,YAAY,EAAE,SAAS,EAAE,CAAC"}

package/dist/logging.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prettyError = prettyError;
+exports.prettyWarn = prettyWarn;
+exports.prettySuccess = prettySuccess;
+exports.prettyInfo = prettyInfo;
+exports.prettyDebug = prettyDebug;
+exports.logSeparator = logSeparator;
+exports.logHeader = logHeader;
+/**
+ * Helper function to get formatted date
+ * @internal
+ */
+function getDate(time = false) {
+    return time ? `[${new Date().toLocaleString()}]` : '';
+}
+/**
+ * Show a pretty error log message with optional date information
+ * @category Logging
+ * @function prettyError
+ * @param err - Error message to display
+ * @param time - Include or not a timestamp
+ * @example
+ * prettyError("Database connection failed");
+ * // Output: ✕ - Database connection failed (in red)
+ *
+ * prettyError("Critical error", true);
+ * // Output: ✕ [30/03/2026 10:30:45] - Critical error (in red with timestamp)
+ */
+function prettyError(err, time = false) {
+    const date = getDate(time);
+    console.log(`\x1b[1;41m ✕ ${date} - ${err} \x1b[0m`);
+}
+/**
+ * Show a pretty warn log message with optional date information
+ * @category Logging
+ * @function prettyWarn
+ * @param warn - Warning message to display
+ * @param time - Include or not a timestamp
+ * @example
+ * prettyWarn("Deprecated function used");
+ * // Output: ⚠ - Deprecated function used (in orange)
+ *
+ * prettyWarn("Low memory", true);
+ * // Output: ⚠ [30/03/2026 10:30:45] - Low memory (in orange with timestamp)
+ */
+function prettyWarn(warn, time = false) {
+    const date = getDate(time);
+    console.log(`\x1b[1;43m ⚠ ${date} - ${warn} \x1b[0m`);
+}
+/**
+ * Show a pretty success log message with optional date information
+ * @category Logging
+ * @function prettySuccess
+ * @param success - Success message to display
+ * @param time - Include or not a timestamp
+ * @example
+ * prettySuccess("User created successfully");
+ * // Output: ✔ - User created successfully (in green)
+ *
+ * prettySuccess("Data saved", true);
+ * // Output: ✔ [30/03/2026 10:30:45] - Data saved (in green with timestamp)
+ */
+function prettySuccess(success, time = false) {
+    const date = getDate(time);
+    console.log(`\x1b[1;42m ✔ ${date} - ${success} \x1b[0m`);
+}
+/**
+ * Show a pretty information log message with optional date information
+ * @category Logging
+ * @function prettyInfo
+ * @param info - Information message to display
+ * @param time - Include or not a timestamp
+ * @example
+ * prettyInfo("Server is running on port 3000");
+ * // Output: ℹ - Server is running on port 3000 (in blue)
+ *
+ * prettyInfo("Cache cleared", true);
+ * // Output: ℹ [30/03/2026 10:30:45] - Cache cleared (in blue with timestamp)
+ */
+function prettyInfo(info, time = false) {
+    const date = getDate(time);
+    console.log(`\x1b[1;44m ℹ ${date} - ${info} \x1b[0m`);
+}
+/**
+ * Show a pretty debug log message with optional date information
+ * @category Logging
+ * @function prettyDebug
+ * @param debug - Debug message to display
+ * @param time - Include or not a timestamp
+ * @example
+ * prettyDebug("Variable x = 42");
+ * // Output: ⚙ - Variable x = 42 (in white)
+ *
+ * prettyDebug("Function call trace", true);
+ * // Output: ⚙ [30/03/2026 10:30:45] - Function call trace (in white with timestamp)
+ */
+function prettyDebug(debug, time = false) {
+    const date = getDate(time);
+    console.log(`\x1b[1;97m ⚙ ${date} - ${debug} \x1b[0m`);
+}
+/**
+ * Show a separator line in console
+ * @category Logging
+ * @function logSeparator
+ * @example
+ * logSeparator();
+ * // Output: ══════════════════════════════════════════════════
+ */
+function logSeparator() {
+    console.log(`\x1b[1m${'═'.repeat(50)}\x1b[0m`);
+}
+/**
+ * Display a header with a title in the center
+ * @category Logging
+ * @function logHeader
+ * @param title - The title of the header
+ * @example
+ * logHeader("Welcome");
+ * // Output:
+ * // ╔═════════╗
+ * // ║ Welcome ║
+ * // ╚═════════╝
+ */
+function logHeader(title) {
+    console.log(`\x1b[1m╔${'═'.repeat(title.length + 2)}╗\x1b[0m`);
+    console.log(`\x1b[1m║ ${title} ║\x1b[0m`);
+    console.log(`\x1b[1m╚${'═'.repeat(title.length + 2)}╝\x1b[0m`);
+}

package/dist/object_manipulation.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Create a deep clone of any object or array
+ * @category Object Manipulation
+ * @function deepClone
+ * @param obj - The object or array to clone
+ * @returns A deep clone of the object
+ * @example
+ * const user = { name: "Alice", skills: ["JS", "TS"] };
+ * const clone = deepClone(user);
+ * clone.name = "Bob";
+ * clone.skills[0] = "Python";
+ * console.log(user.name);    // "Alice" (unchanged)
+ * console.log(user.skills[0]); // "JS" (unchanged)
+ */
+declare function deepClone<T>(obj: T): T;
+/**
+ * Remove duplicate values from an array
+ * @category Object Manipulation
+ * @function noTwins
+ * @param arr - The array to remove duplicates from
+ * @returns {unknown[]} A new array with unique values only
+ * @example
+ * noTwins([1, 2, 2, 3, 3, 3]);        // [1, 2, 3]
+ * noTwins(["a", "b", "a", "c"]);      // ["a", "b", "c"]
+ * noTwins([1, "1", 1, "1"]);          // [1, "1"]
+ */
+declare function noTwins(arr: unknown[]): unknown[];
+export { deepClone, noTwins };
+//# sourceMappingURL=object_manipulation.d.ts.map

package/dist/object_manipulation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"object_manipulation.d.ts","sourceRoot":"","sources":["../src/object_manipulation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,iBAAS,SAAS,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,CAU/B;AAED;;;;;;;;;;GAUG;AACH,iBAAS,OAAO,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,OAAO,EAAE,CAE1C;AAED,OAAO,EAAC,SAAS,EAAE,OAAO,EAAC,CAAC"}

package/dist/object_manipulation.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deepClone = deepClone;
+exports.noTwins = noTwins;
+/**
+ * Create a deep clone of any object or array
+ * @category Object Manipulation
+ * @function deepClone
+ * @param obj - The object or array to clone
+ * @returns A deep clone of the object
+ * @example
+ * const user = { name: "Alice", skills: ["JS", "TS"] };
+ * const clone = deepClone(user);
+ * clone.name = "Bob";
+ * clone.skills[0] = "Python";
+ * console.log(user.name);    // "Alice" (unchanged)
+ * console.log(user.skills[0]); // "JS" (unchanged)
+ */
+function deepClone(obj) {
+    if (obj === null || typeof obj !== "object")
+        return obj;
+    if (Array.isArray(obj))
+        return obj.map(item => deepClone(item));
+    const cloned = {};
+    for (const key in obj) {
+        if (obj.hasOwnProperty(key))
+            cloned[key] = deepClone(obj[key]);
+    }
+    return cloned;
+}
+/**
+ * Remove duplicate values from an array
+ * @category Object Manipulation
+ * @function noTwins
+ * @param arr - The array to remove duplicates from
+ * @returns {unknown[]} A new array with unique values only
+ * @example
+ * noTwins([1, 2, 2, 3, 3, 3]);        // [1, 2, 3]
+ * noTwins(["a", "b", "a", "c"]);      // ["a", "b", "c"]
+ * noTwins([1, "1", 1, "1"]);          // [1, "1"]
+ */
+function noTwins(arr) {
+    return Array.from(new Set(arr));
+}

package/dist/transformation.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Transform a string to camelCase format
+ * @category Transformation
+ * @function camelify
+ * @param str - The string to transform
+ * @returns {string} The string in camelCase format
+ * @example
+ * camelify("hello world");       // "helloWorld"
+ * camelify("C'est un test");     // "cestUnTest"
+ * camelify("foo bar baz");       // "fooBarBaz"
+ */
+declare function camelify(str: string): string;
+/**
+ * Transform a string to kebab-case format
+ * @category Transformation
+ * @function kebabify
+ * @param str - The string to transform
+ * @returns {string} The string in kebab-case format
+ * @example
+ * kebabify("hello world");       // "hello-world"
+ * kebabify("C'est un test");     // "ceststun-test"
+ * kebabify("foo bar baz");       // "foo-bar-baz"
+ */
+declare function kebabify(str: string): string;
+/**
+ * Transform a string to snake_case format
+ * @category Transformation
+ * @function snakify
+ * @param str - The string to transform
+ * @returns {string} The string in snake_case format
+ * @example
+ * snakify("hello world");        // "hello_world"
+ * snakify("C'est un test");      // "ceststun_test"
+ * snakify("foo bar baz");        // "foo_bar_baz"
+ */
+declare function snakify(str: string): string;
+/**
+ * Capitalize the first character of a string
+ * @category Transformation
+ * @function capitalize
+ * @param str - The string to capitalize
+ * @returns {string} The string with the first character in uppercase
+ * @example
+ * capitalize("hello");        // "Hello"
+ * capitalize("hello world");  // "Hello world"
+ * capitalize("");             // ""
+ */
+declare function capitalize(str: string): string;
+export { camelify, kebabify, snakify, capitalize };
+//# sourceMappingURL=transformation.d.ts.map

package/dist/transformation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transformation.d.ts","sourceRoot":"","sources":["../src/transformation.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AACH,iBAAS,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAarC;AAED;;;;;;;;;;GAUG;AACH,iBAAS,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CASrC;AAED;;;;;;;;;;GAUG;AACH,iBAAS,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CASpC;AAED;;;;;;;;;;GAUG;AACH,iBAAS,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAGvC;AAED,OAAO,EAAC,QAAQ,EAAE,QAAQ,EAAE,OAAO,EAAE,UAAU,EAAC,CAAC"}

package/dist/transformation.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.camelify = camelify;
+exports.kebabify = kebabify;
+exports.snakify = snakify;
+exports.capitalize = capitalize;
+const validation_1 = require("./validation");
+/**
+ * Transform a string to camelCase format
+ * @category Transformation
+ * @function camelify
+ * @param str - The string to transform
+ * @returns {string} The string in camelCase format
+ * @example
+ * camelify("hello world");       // "helloWorld"
+ * camelify("C'est un test");     // "cestUnTest"
+ * camelify("foo bar baz");       // "fooBarBaz"
+ */
+function camelify(str) {
+    let camelCased = "";
+    if (!(0, validation_1.isEmpty)(str)) {
+        let cleaned = str.replace(/[^a-zA-Z0-9\s]/g, "");
+        let toCamelify = cleaned.split(" ");
+        camelCased = toCamelify.map((word, index) => {
+            if (index === 0)
+                return word.toLowerCase();
+            return word[0].toUpperCase() + word.slice(1).toLowerCase();
+        })
+            .join('');
+    }
+    return camelCased;
+}
+/**
+ * Transform a string to kebab-case format
+ * @category Transformation
+ * @function kebabify
+ * @param str - The string to transform
+ * @returns {string} The string in kebab-case format
+ * @example
+ * kebabify("hello world");       // "hello-world"
+ * kebabify("C'est un test");     // "ceststun-test"
+ * kebabify("foo bar baz");       // "foo-bar-baz"
+ */
+function kebabify(str) {
+    let kebabised = "";
+    if (!(0, validation_1.isEmpty)(str)) {
+        let cleaned = str.replace(/[^a-zA-Z0-9\s]/g, "");
+        let toKebabify = cleaned.split(" ");
+        kebabised = toKebabify.map(word => word.toLowerCase())
+            .join("-");
+    }
+    return kebabised;
+}
+/**
+ * Transform a string to snake_case format
+ * @category Transformation
+ * @function snakify
+ * @param str - The string to transform
+ * @returns {string} The string in snake_case format
+ * @example
+ * snakify("hello world");        // "hello_world"
+ * snakify("C'est un test");      // "ceststun_test"
+ * snakify("foo bar baz");        // "foo_bar_baz"
+ */
+function snakify(str) {
+    let snaked = "";
+    if (!(0, validation_1.isEmpty)(str)) {
+        let cleaned = str.replace(/[^a-zA-Z0-9\s]/g, "");
+        let toSnakify = cleaned.split(" ");
+        snaked = toSnakify.map(word => word.toLowerCase())
+            .join("_");
+    }
+    return snaked;
+}
+/**
+ * Capitalize the first character of a string
+ * @category Transformation
+ * @function capitalize
+ * @param str - The string to capitalize
+ * @returns {string} The string with the first character in uppercase
+ * @example
+ * capitalize("hello");        // "Hello"
+ * capitalize("hello world");  // "Hello world"
+ * capitalize("");             // ""
+ */
+function capitalize(str) {
+    if ((0, validation_1.isEmpty)(str))
+        return str;
+    return str[0].toUpperCase() + str.slice(1);
+}

package/dist/validation.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Check if any type of variable is empty
+ * @category Validation
+ * @function isEmpty
+ * @param value - The variable to check
+ * @returns {boolean} True if the value is empty, false otherwise
+ * @example
+ * isEmpty("");          // true
+ * isEmpty("   ");       // true
+ * isEmpty(null);        // true
+ * isEmpty([]);          // true
+ * isEmpty({});          // true
+ * isEmpty("hello");     // false
+ * isEmpty([1, 2]);      // false
+ */
+declare function isEmpty(value: unknown): boolean;
+/**
+ * Check if the variable is of the chosen type
+ * @category Validation
+ * @function isType
+ * @param value - The variable to check
+ * @param type - The type you want
+ * @returns {boolean} True if the value is of the chosen type, false otherwise
+ * @example
+ * isType("hello", "string");    // true
+ * isType(42, "number");         // true
+ * isType([], "object");         // true
+ * isType("42", "number");       // false
+ */
+declare function isType(value: unknown, type: string): boolean;
+/**
+ * Check if an email is valid
+ * @category Validation
+ * @function isEmail
+ * @param email - The email to check
+ * @returns {boolean} True if the email is valid, false otherwise
+ * @example
+ * isEmail("alice@example.com");      // true
+ * isEmail("bob.smith@company.co.uk"); // true
+ * isEmail("invalid@.com");           // false
+ * isEmail("no-at-sign.com");         // false
+ */
+declare function isEmail(email: string): boolean;
+/**
+ * Check if a URL is valid
+ * @category Validation
+ * @function isURL
+ * @param url - The URL to check
+ * @returns {boolean} True if the URL is valid, false otherwise
+ * @example
+ * isURL("https://www.example.com");     // true
+ * isURL("http://example.com/path");     // true
+ * isURL("www.example.com");             // false (missing protocol)
+ * isURL("not a url");                   // false
+ */
+declare function isURL(url: string): boolean;
+export { isEmpty, isType, isEmail, isURL };
+//# sourceMappingURL=validation.d.ts.map

package/dist/validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../src/validation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,iBAAS,OAAO,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAMxC;AAED;;;;;;;;;;;;GAYG;AACH,iBAAS,MAAM,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAErD;AAED;;;;;;;;;;;GAWG;AACH,iBAAS,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAGvC;AAED;;;;;;;;;;;GAWG;AACH,iBAAS,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAOnC;AAED,OAAO,EAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,KAAK,EAAC,CAAC"}

package/dist/validation.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEmpty = isEmpty;
+exports.isType = isType;
+exports.isEmail = isEmail;
+exports.isURL = isURL;
+/**
+ * Check if any type of variable is empty
+ * @category Validation
+ * @function isEmpty
+ * @param value - The variable to check
+ * @returns {boolean} True if the value is empty, false otherwise
+ * @example
+ * isEmpty("");          // true
+ * isEmpty("   ");       // true
+ * isEmpty(null);        // true
+ * isEmpty([]);          // true
+ * isEmpty({});          // true
+ * isEmpty("hello");     // false
+ * isEmpty([1, 2]);      // false
+ */
+function isEmpty(value) {
+    if (value === null || value === undefined)
+        return true;
+    if (typeof value === "string")
+        return value.trim().length === 0;
+    if (Array.isArray(value))
+        return value.length === 0;
+    if (typeof value === "object")
+        return Object.keys(value).length === 0;
+    return false;
+}
+/**
+ * Check if the variable is of the chosen type
+ * @category Validation
+ * @function isType
+ * @param value - The variable to check
+ * @param type - The type you want
+ * @returns {boolean} True if the value is of the chosen type, false otherwise
+ * @example
+ * isType("hello", "string");    // true
+ * isType(42, "number");         // true
+ * isType([], "object");         // true
+ * isType("42", "number");       // false
+ */
+function isType(value, type) {
+    return typeof value === type;
+}
+/**
+ * Check if an email is valid
+ * @category Validation
+ * @function isEmail
+ * @param email - The email to check
+ * @returns {boolean} True if the email is valid, false otherwise
+ * @example
+ * isEmail("alice@example.com");      // true
+ * isEmail("bob.smith@company.co.uk"); // true
+ * isEmail("invalid@.com");           // false
+ * isEmail("no-at-sign.com");         // false
+ */
+function isEmail(email) {
+    const regex = /^[a-zA-Z0-9._%-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/;
+    return regex.test(email);
+}
+/**
+ * Check if a URL is valid
+ * @category Validation
+ * @function isURL
+ * @param url - The URL to check
+ * @returns {boolean} True if the URL is valid, false otherwise
+ * @example
+ * isURL("https://www.example.com");     // true
+ * isURL("http://example.com/path");     // true
+ * isURL("www.example.com");             // false (missing protocol)
+ * isURL("not a url");                   // false
+ */
+function isURL(url) {
+    try {
+        new URL(url);
+        return true;
+    }
+    catch (error) {
+        return false;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clear-af.js",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "description": "Make your code readable af with zero bullsh*t utilities.",
   "keywords": [
     "javascript",

package/typedoc.json

@@ -0,0 +1,10 @@
+{
+    "entryPoints": [
+        "src/index.ts"
+    ],
+    "out": "docs",
+    "readme": "src/index.md",
+    "excludePrivate": true,
+    "excludeInternal": true,
+    "name": "clear-af.js"
+}