stringzy 3.0.0 → 4.1.0

package/dist/validations/index.d.ts

@@ -1,3 +1,4 @@
+export { isCoordinates } from './isCoordinates';
 export { isDate } from './isDate';
 export { isEmail } from './isEmail';
 export { isEmpty } from './isEmpty';
@@ -5,6 +6,15 @@ export { isSlug } from './isSlug';
 export { isURL } from './isURL';
 export { isIPv4 } from './isIPv4';
 export { isHexColor } from './isHexColor';
+export { isPalindrome } from './isPalindrome';
+export { isLowerCase } from './isLowerCase';
+export { isUpperCase } from './isUpperCase';
+export { isAlphabetic } from './isAlphabetic';
+export { isAlphaNumeric } from './isAlphaNumeric';
+export { isAnagram } from './isAnagram';
+export { isPanagram } from './isPanagram';
+export { isMacAddress } from './isMacAddress';
+import { isCoordinates } from './isCoordinates';
 import { isDate } from './isDate';
 import { isEmail } from './isEmail';
 import { isEmpty } from './isEmpty';
@@ -12,7 +22,16 @@ import { isSlug } from './isSlug';
 import { isURL } from './isURL';
 import { isIPv4 } from './isIPv4';
 import { isHexColor } from './isHexColor';
+import { isPalindrome } from './isPalindrome';
+import { isLowerCase } from './isLowerCase';
+import { isUpperCase } from './isUpperCase';
+import { isAlphabetic } from './isAlphabetic';
+import { isAlphaNumeric } from './isAlphaNumeric';
+import { isAnagram } from './isAnagram';
+import { isPanagram } from './isPanagram';
+import { isMacAddress } from './isMacAddress';
 export declare const validations: {
+    isCoordinates: typeof isCoordinates;
     isDate: typeof isDate;
     isEmail: typeof isEmail;
     isEmpty: typeof isEmpty;
@@ -20,4 +39,12 @@ export declare const validations: {
     isURL: typeof isURL;
     isIPv4: typeof isIPv4;
     isHexColor: typeof isHexColor;
+    isPalindrome: typeof isPalindrome;
+    isLowerCase: typeof isLowerCase;
+    isUpperCase: typeof isUpperCase;
+    isAlphabetic: typeof isAlphabetic;
+    isAlphaNumeric: typeof isAlphaNumeric;
+    isAnagram: typeof isAnagram;
+    isPanagram: typeof isPanagram;
+    isMacAddress: typeof isMacAddress;
 };

package/dist/validations/index.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validations = exports.isHexColor = exports.isIPv4 = exports.isURL = exports.isSlug = exports.isEmpty = exports.isEmail = exports.isDate = void 0;
+exports.validations = exports.isMacAddress = exports.isPanagram = exports.isAnagram = exports.isAlphaNumeric = exports.isAlphabetic = exports.isUpperCase = exports.isLowerCase = exports.isPalindrome = exports.isHexColor = exports.isIPv4 = exports.isURL = exports.isSlug = exports.isEmpty = exports.isEmail = exports.isDate = exports.isCoordinates = void 0;
+var isCoordinates_1 = require("./isCoordinates");
+Object.defineProperty(exports, "isCoordinates", { enumerable: true, get: function () { return isCoordinates_1.isCoordinates; } });
 var isDate_1 = require("./isDate");
 Object.defineProperty(exports, "isDate", { enumerable: true, get: function () { return isDate_1.isDate; } });
 var isEmail_1 = require("./isEmail");
@@ -15,6 +17,23 @@ var isIPv4_1 = require("./isIPv4");
 Object.defineProperty(exports, "isIPv4", { enumerable: true, get: function () { return isIPv4_1.isIPv4; } });
 var isHexColor_1 = require("./isHexColor");
 Object.defineProperty(exports, "isHexColor", { enumerable: true, get: function () { return isHexColor_1.isHexColor; } });
+var isPalindrome_1 = require("./isPalindrome");
+Object.defineProperty(exports, "isPalindrome", { enumerable: true, get: function () { return isPalindrome_1.isPalindrome; } });
+var isLowerCase_1 = require("./isLowerCase");
+Object.defineProperty(exports, "isLowerCase", { enumerable: true, get: function () { return isLowerCase_1.isLowerCase; } });
+var isUpperCase_1 = require("./isUpperCase");
+Object.defineProperty(exports, "isUpperCase", { enumerable: true, get: function () { return isUpperCase_1.isUpperCase; } });
+var isAlphabetic_1 = require("./isAlphabetic");
+Object.defineProperty(exports, "isAlphabetic", { enumerable: true, get: function () { return isAlphabetic_1.isAlphabetic; } });
+var isAlphaNumeric_1 = require("./isAlphaNumeric");
+Object.defineProperty(exports, "isAlphaNumeric", { enumerable: true, get: function () { return isAlphaNumeric_1.isAlphaNumeric; } });
+var isAnagram_1 = require("./isAnagram");
+Object.defineProperty(exports, "isAnagram", { enumerable: true, get: function () { return isAnagram_1.isAnagram; } });
+var isPanagram_1 = require("./isPanagram");
+Object.defineProperty(exports, "isPanagram", { enumerable: true, get: function () { return isPanagram_1.isPanagram; } });
+var isMacAddress_1 = require("./isMacAddress");
+Object.defineProperty(exports, "isMacAddress", { enumerable: true, get: function () { return isMacAddress_1.isMacAddress; } });
+const isCoordinates_2 = require("./isCoordinates");
 const isDate_2 = require("./isDate");
 const isEmail_2 = require("./isEmail");
 const isEmpty_2 = require("./isEmpty");
@@ -22,12 +41,29 @@ const isSlug_2 = require("./isSlug");
 const isURL_2 = require("./isURL");
 const isIPv4_2 = require("./isIPv4");
 const isHexColor_2 = require("./isHexColor");
+const isPalindrome_2 = require("./isPalindrome");
+const isLowerCase_2 = require("./isLowerCase");
+const isUpperCase_2 = require("./isUpperCase");
+const isAlphabetic_2 = require("./isAlphabetic");
+const isAlphaNumeric_2 = require("./isAlphaNumeric");
+const isAnagram_2 = require("./isAnagram");
+const isPanagram_2 = require("./isPanagram");
+const isMacAddress_2 = require("./isMacAddress");
 exports.validations = {
+    isCoordinates: isCoordinates_2.isCoordinates,
     isDate: isDate_2.isDate,
     isEmail: isEmail_2.isEmail,
     isEmpty: isEmpty_2.isEmpty,
     isSlug: isSlug_2.isSlug,
     isURL: isURL_2.isURL,
     isIPv4: isIPv4_2.isIPv4,
-    isHexColor: isHexColor_2.isHexColor
+    isHexColor: isHexColor_2.isHexColor,
+    isPalindrome: isPalindrome_2.isPalindrome,
+    isLowerCase: isLowerCase_2.isLowerCase,
+    isUpperCase: isUpperCase_2.isUpperCase,
+    isAlphabetic: isAlphabetic_2.isAlphabetic,
+    isAlphaNumeric: isAlphaNumeric_2.isAlphaNumeric,
+    isAnagram: isAnagram_2.isAnagram,
+    isPanagram: isPanagram_2.isPanagram,
+    isMacAddress: isMacAddress_2.isMacAddress
 };

package/dist/validations/isAlphaNumeric.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Checks whether the given string is alphanumeric.
+ *
+ * The check ensures that the string contains only
+ * letters (a-z, A-Z) and digits (0-9).
+ *
+ * @param {string} str - The input string to check.
+ * @returns {boolean} True if the input is alphanumeric, false otherwise.
+ * @throws {TypeError} If the input is not a string.
+ */
+export declare function isAlphaNumeric(str: string): boolean;

package/dist/validations/isAlphaNumeric.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAlphaNumeric = isAlphaNumeric;
+/**
+ * Checks whether the given string is alphanumeric.
+ *
+ * The check ensures that the string contains only
+ * letters (a-z, A-Z) and digits (0-9).
+ *
+ * @param {string} str - The input string to check.
+ * @returns {boolean} True if the input is alphanumeric, false otherwise.
+ * @throws {TypeError} If the input is not a string.
+ */
+function isAlphaNumeric(str) {
+    if (typeof str !== 'string') {
+        throw new TypeError('Input must be a string');
+    }
+    if (str.length === 0) {
+        return false;
+    }
+    return /^[a-z0-9]+$/i.test(str);
+}

package/dist/validations/isAlphabetic.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Checks whether a given string contains only alphabetic characters (A-Z, a-z).
+ *
+ *
+ * @param {string} str - The input string to check.
+ * @returns {boolean} True if the input contains only alphabetic characters, otherwise false.
+ * @throws {TypeError} If the input is not a string.
+ */
+export declare function isAlphabetic(str: string): boolean;

package/dist/validations/isAlphabetic.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAlphabetic = isAlphabetic;
+/**
+ * Checks whether a given string contains only alphabetic characters (A-Z, a-z).
+ *
+ *
+ * @param {string} str - The input string to check.
+ * @returns {boolean} True if the input contains only alphabetic characters, otherwise false.
+ * @throws {TypeError} If the input is not a string.
+ */
+function isAlphabetic(str) {
+    if (typeof str !== 'string') {
+        throw new TypeError('Input must be a string');
+    }
+    // empty string is not considered alphabetic
+    if (str === '')
+        return false;
+    // Regular expression to match only alphabetic characters
+    return /^[A-Za-z]+$/.test(str);
+}

package/dist/validations/isAnagram.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Checks whether two strings are anagrams of each other.
+ *
+ * Rules:
+ * - Comparison is case-insensitive.
+ * - Spaces and punctuation are ignored.
+ *
+ * @param {string} str1 - The first input string.
+ * @param {string} str2 - The second input string.
+ * @returns {boolean} True if the inputs are anagrams, otherwise false.
+ * @throws {TypeError} If either input is not a string.
+ */
+export declare function isAnagram(str1: string, str2: string): boolean;

package/dist/validations/isAnagram.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAnagram = isAnagram;
+/**
+ * Checks whether two strings are anagrams of each other.
+ *
+ * Rules:
+ * - Comparison is case-insensitive.
+ * - Spaces and punctuation are ignored.
+ *
+ * @param {string} str1 - The first input string.
+ * @param {string} str2 - The second input string.
+ * @returns {boolean} True if the inputs are anagrams, otherwise false.
+ * @throws {TypeError} If either input is not a string.
+ */
+function isAnagram(str1, str2) {
+    if (typeof str1 !== 'string' || typeof str2 !== 'string') {
+        throw new TypeError('Both inputs must be strings');
+    }
+    // Normalize: lowercase, remove spaces & punctuation
+    const normalize = (str) => str.toLowerCase().replace(/[^a-z0-9]/g, '').split('').sort().join('');
+    return normalize(str1) === normalize(str2);
+}

package/dist/validations/isCoordinates.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Checks if given latitude and longitude are valid coordinates.
+ *
+ * @param {number} lat - The latitude to check.
+ * @param {number} long - The longitude to check.
+ * @returns {boolean} True if both latitude and longitude are valid, false otherwise.
+ */
+export declare function isCoordinates(lat: number, long: number): boolean;

package/dist/validations/isCoordinates.js

@@ -0,0 +1,19 @@
+"use strict";
+/**
+ * Checks if given latitude and longitude are valid coordinates.
+ *
+ * @param {number} lat - The latitude to check.
+ * @param {number} long - The longitude to check.
+ * @returns {boolean} True if both latitude and longitude are valid, false otherwise.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isCoordinates = isCoordinates;
+function isCoordinates(lat, long) {
+    return isLatitude(lat) && isLongitude(long);
+}
+function isLatitude(num) {
+    return Number.isFinite(num) && Math.abs(num) <= 90;
+}
+function isLongitude(num) {
+    return Number.isFinite(num) && Math.abs(num) <= 180;
+}

package/dist/validations/isDate.d.ts

@@ -4,7 +4,7 @@ export declare enum DateFormats {
     DDMMYYYY = "DDMMYYYY"
 }
 declare const VALID_SEPARATORS: readonly [".", "-", "/"];
-type ValidSeparators = typeof VALID_SEPARATORS[number];
+type ValidSeparators = (typeof VALID_SEPARATORS)[number];
 /**
  * Takes a date and a format and returns whether or not the date matches the specified format.
  * Optionally takes a separator that can be used instead of the default hyphen.

package/dist/validations/isDate.js

@@ -19,7 +19,7 @@ const VALID_SEPARATORS = ['.', '-', '/'];
  * @example 01-01-00 -> False
  */
 function isDate(input, format, separator = '-') {
-    if (typeof input !== "string")
+    if (typeof input !== 'string')
         return false;
     if (input.length !== 10)
         return false;
@@ -31,22 +31,22 @@ function isDate(input, format, separator = '-') {
             // Format: YYYY-MM-DD
             format: DateFormats.YYYYMMDD,
             regex: new RegExp(`^\\d{4}${separator}\\d{2}${separator}\\d{2}$`),
-            order: ["Y", "M", "D"],
+            order: ['Y', 'M', 'D'],
         },
         {
             // Format: MM-DD-YYYY
             format: DateFormats.MMDDYYYY,
             regex: new RegExp(`^\d{2}${separator}\d{2}${separator}\d{4}$/`),
-            order: ["M", "D", "Y"],
+            order: ['M', 'D', 'Y'],
         },
         {
             // Format: DD-MM-YYYY
             format: DateFormats.DDMMYYYY,
             regex: new RegExp(`^\d{2}${separator}\d{2}${separator}\d{4}$`),
-            order: ["D", "M", "Y"],
+            order: ['D', 'M', 'Y'],
         },
     ];
-    const targetFormat = formats.find(f => f.format === format);
+    const targetFormat = formats.find((f) => f.format === format);
     const parts = input.split(separator).map(Number);
     const dateParts = {};
     targetFormat === null || targetFormat === void 0 ? void 0 : targetFormat.order.forEach((k, i) => {
@@ -56,8 +56,6 @@ function isDate(input, format, separator = '-') {
     const checkDate = new Date(Y, M - 1, D); // Months are 0 indexed
     if (checkDate.toString() === 'Invalid Date')
         return false;
-    const isValid = checkDate.getFullYear() === Y &&
-        checkDate.getMonth() === M - 1 &&
-        checkDate.getDate() === D;
+    const isValid = checkDate.getFullYear() === Y && checkDate.getMonth() === M - 1 && checkDate.getDate() === D;
     return isValid;
 }

package/dist/validations/isEmail.d.ts

@@ -1 +1,13 @@
-export declare function isEmail(str: string): boolean;
+/**
+ * Checks if a given string is a valid email address.
+ *
+ * Uses a regular expression to verify the format: it must contain
+ * one "@" symbol, no spaces, and at least one dot after the "@"
+ * (e.g., "example@domain.com").
+ *
+ * @param {string} str - The string to be checked.
+ * @returns {boolean} True if the string is a valid email address, false otherwise.
+ */
+export declare function isEmail(str: string, opts?: {
+    smtpUTF8?: boolean;
+}): boolean;

package/dist/validations/isEmail.js

@@ -1,7 +1,180 @@
 "use strict";
+/**
+ * Checks if a given string is a valid email address.
+ *
+ * Uses a regular expression to verify the format: it must contain
+ * one "@" symbol, no spaces, and at least one dot after the "@"
+ * (e.g., "example@domain.com").
+ *
+ * @param {string} str - The string to be checked.
+ * @returns {boolean} True if the string is a valid email address, false otherwise.
+ */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isEmail = isEmail;
-function isEmail(str) {
-    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-    return emailRegex.test(str);
+function isEmail(str, opts) {
+    if (typeof str !== 'string')
+        return false;
+    if (!str)
+        return false;
+    // Enable SMTPUTF8 by default; set opts.smtpUTF8=false to enforce ASCII-only
+    const smtpUTF8 = (opts === null || opts === void 0 ? void 0 : opts.smtpUTF8) !== false;
+    // Quick overall length guard
+    if (str.length > 254)
+        return false;
+    // Find the separator '@' by scanning from right to left and skipping those inside quotes
+    let inQuote = false;
+    let atIndex = -1;
+    for (let i = str.length - 1; i >= 0; i--) {
+        const ch = str[i];
+        if (ch === '"') {
+            // toggle quote state if this quote is not escaped by a backslash
+            const prev = str[i - 1];
+            if (prev !== '\\')
+                inQuote = !inQuote;
+            continue;
+        }
+        if (ch === '@' && !inQuote) {
+            atIndex = i;
+            break;
+        }
+    }
+    if (inQuote)
+        return false; // unbalanced quotes
+    if (atIndex <= 0 || atIndex === str.length - 1)
+        return false;
+    const local = str.slice(0, atIndex);
+    const domain = str.slice(atIndex + 1);
+    // Local-part length limit (64 octets)
+    if (local.length > 64)
+        return false;
+    // Validate local part as dot-separated of atoms or quoted-strings
+    // Validate local with a robust FSM that supports nested unescaped quotes inside quoted strings
+    const isAsciiAtext = (ch) => /[A-Za-z0-9!#$%&'*+\/=?^_`{|}~-]/.test(ch);
+    const isUnicodeAtext = (ch) => {
+        if (!smtpUTF8)
+            return false;
+        // Disallow obvious separators and specials used by the parser
+        if (ch === '.' || ch === ' ' || ch === '"' || ch === '\\' || ch === '@')
+            return false;
+        // Disallow whitespace/control
+        if (/\s/u.test(ch))
+            return false;
+        // Allow Unicode Letters, Marks, Numbers and Symbols (e.g., emoji)
+        return /[\p{L}\p{N}\p{M}\p{S}]/u.test(ch);
+    };
+    let lastWasDot = false; // disallow consecutive or leading/trailing dots anywhere
+    let inQ = false; // inside a quoted token
+    let qDepth = 0; // quote nesting depth (>=1 when inside outer quotes)
+    let escQ = false; // backslash escape inside quotes
+    let needDotAfterQuoted = false; // require a dot right after a quoted token if not at end
+    for (let i = 0; i < local.length; i++) {
+        const c = local[i];
+        // If we just closed a quoted token, the very next char must be a dot
+        if (!inQ && needDotAfterQuoted) {
+            if (c !== '.')
+                return false;
+            needDotAfterQuoted = false;
+            lastWasDot = true;
+            continue;
+        }
+        if (inQ) {
+            if (escQ) {
+                // After a backslash, allow any non-newline character (broader under SMTPUTF8)
+                if (/\r|\n/.test(c))
+                    return false;
+                escQ = false;
+                continue;
+            }
+            if (c === '\\') {
+                escQ = true;
+                continue;
+            }
+            if (c === '"') {
+                // Support nested unescaped quotes within a quoted token.
+                // Only close the quoted token when depth returns to 0 and we're at end-of-local
+                // or the next character is a dot (separator between tokens).
+                if (qDepth > 1) {
+                    qDepth -= 1;
+                    lastWasDot = false;
+                    continue;
+                }
+                // qDepth === 1: decide whether to close or to start nesting
+                if (i + 1 === local.length || local[i + 1] === '.') {
+                    // this quote closes the quoted token
+                    inQ = false;
+                    qDepth = 0;
+                    // require a dot if not at end
+                    if (i + 1 < local.length)
+                        needDotAfterQuoted = true;
+                    lastWasDot = false;
+                    continue;
+                }
+                else {
+                    // start a nested quote level
+                    qDepth += 1; // becomes 2
+                    lastWasDot = false;
+                    continue;
+                }
+            }
+            // Inside quotes: allow ASCII VCHAR and space by default; with SMTPUTF8 allow any char except control newlines
+            if (smtpUTF8) {
+                if (/\r|\n/.test(c))
+                    return false;
+            }
+            else {
+                const code = c.charCodeAt(0);
+                if (code < 0x20 || code > 0x7E)
+                    return false;
+            }
+            // Dots inside quoted string are allowed freely
+            continue;
+        }
+        // outside quotes
+        if (c === '"') {
+            // quotes can only start at token boundaries (start or right after a dot)
+            if (i > 0 && !lastWasDot)
+                return false;
+            inQ = true;
+            qDepth = 1;
+            escQ = false;
+            lastWasDot = false;
+            continue;
+        }
+        if (c === '.') {
+            if (i === 0 || lastWasDot)
+                return false; // leading or consecutive dot
+            lastWasDot = true;
+            continue;
+        }
+        if (c === ' ')
+            return false; // no spaces outside quotes
+        // must be atext outside quotes
+        if (!(isAsciiAtext(c) || isUnicodeAtext(c)))
+            return false;
+        lastWasDot = false;
+    }
+    if (inQ || qDepth !== 0 || escQ)
+        return false; // unbalanced quotes or dangling escape
+    if (lastWasDot)
+        return false; // trailing dot
+    // Validate domain
+    const labelRe = /^[A-Za-z0-9](?:[A-Za-z0-9-]{0,61}[A-Za-z0-9])?$/;
+    const ipv4Re = /^(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}$/;
+    const ipv6Re = /^IPv6:(?:[A-Fa-f0-9:]+)$/; // coarse check; detailed covered by overall tests
+    if (domain.startsWith('[') && domain.endsWith(']')) {
+        const literal = domain.slice(1, -1);
+        if (ipv4Re.test(literal))
+            return true;
+        if (ipv6Re.test(literal))
+            return true; // accept canonical IPv6 forms used in tests
+        return false;
+    }
+    const parts = domain.split('.');
+    if (parts.some(p => p.length === 0))
+        return false;
+    for (const p of parts) {
+        if (!labelRe.test(p))
+            return false;
+    }
+    return true;
 }

package/dist/validations/isEmpty.d.ts

@@ -1 +1,10 @@
+/**
+ * Checks whether a given string is empty or consists only of whitespace.
+ *
+ * Trims the input string and returns true if the resulting length is 0,
+ * indicating that the string is either empty or contains only whitespace characters.
+ *
+ * @param {string} str - The string to check.
+ * @returns {boolean} True if the string is empty or whitespace only, false otherwise.
+ */
 export declare function isEmpty(str: string): boolean;

package/dist/validations/isEmpty.js

@@ -1,4 +1,13 @@
 "use strict";
+/**
+ * Checks whether a given string is empty or consists only of whitespace.
+ *
+ * Trims the input string and returns true if the resulting length is 0,
+ * indicating that the string is either empty or contains only whitespace characters.
+ *
+ * @param {string} str - The string to check.
+ * @returns {boolean} True if the string is empty or whitespace only, false otherwise.
+ */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isEmpty = isEmpty;
 function isEmpty(str) {

package/dist/validations/isHexColor.js

@@ -8,7 +8,7 @@ exports.isHexColor = isHexColor;
  * @returns True if the string is a valid hex color, false otherwise.
  */
 function isHexColor(text) {
-    if (typeof text !== "string" || text.length === 0) {
+    if (typeof text !== 'string' || text.length === 0) {
         return false;
     }
     return /^#?([0-9A-Fa-f]{3}|[0-9A-Fa-f]{6})$/.test(text.trim());

package/dist/validations/isIPv4.d.ts

@@ -1 +1,22 @@
+/**
+ * Checks if a given string is a valid IPv4 address.
+ *
+ * Valid IPv4 addresses consist of four decimal numbers (0-255) separated by dots.
+ * Leading zeros are not allowed (e.g., "01" is invalid).
+ *
+ * @param {string} str - The string to validate as an IPv4 address.
+ * @returns {boolean} `true` if the string is a valid IPv4 address, otherwise `false`.
+ *
+ * @example
+ * isIPv4("192.168.1.1"); // true
+ *
+ * @example
+ * isIPv4("255.255.255.255"); // true
+ *
+ * @example
+ * isIPv4("256.100.50.0"); // false (256 is out of range)
+ *
+ * @example
+ * isIPv4("192.168.1"); // false (not enough parts)
+ */
 export declare function isIPv4(str: string): boolean;

package/dist/validations/isIPv4.js

@@ -1,13 +1,33 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isIPv4 = isIPv4;
+/**
+ * Checks if a given string is a valid IPv4 address.
+ *
+ * Valid IPv4 addresses consist of four decimal numbers (0-255) separated by dots.
+ * Leading zeros are not allowed (e.g., "01" is invalid).
+ *
+ * @param {string} str - The string to validate as an IPv4 address.
+ * @returns {boolean} `true` if the string is a valid IPv4 address, otherwise `false`.
+ *
+ * @example
+ * isIPv4("192.168.1.1"); // true
+ *
+ * @example
+ * isIPv4("255.255.255.255"); // true
+ *
+ * @example
+ * isIPv4("256.100.50.0"); // false (256 is out of range)
+ *
+ * @example
+ * isIPv4("192.168.1"); // false (not enough parts)
+ */
 function isIPv4(str) {
     const parts = str.split('.');
     if (parts.length !== 4)
         return false;
-    return parts.every(part => {
+    return parts.every((part) => {
         const num = parseInt(part, 10);
         return !isNaN(num) && num >= 0 && num <= 255 && part === num.toString();
     });
 }
-;

package/dist/validations/isLowerCase.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Checks whether the given string contains only lowercase alphabetic characters.
+ *
+ * - At least one alphabetic character must be present.
+ * - Digits, spaces, and special characters are ignored.
+ * - If any uppercase alphabetic character is found, it returns false.
+ *
+ * @param {string} str - The input string to check.
+ * @returns {boolean} True if all alphabetic characters are lowercase and at least one exists, false otherwise.
+ * @throws {TypeError} If the input is not a string.
+ */
+export declare function isLowerCase(str: string): boolean;

package/dist/validations/isLowerCase.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isLowerCase = isLowerCase;
+/**
+ * Checks whether the given string contains only lowercase alphabetic characters.
+ *
+ * - At least one alphabetic character must be present.
+ * - Digits, spaces, and special characters are ignored.
+ * - If any uppercase alphabetic character is found, it returns false.
+ *
+ * @param {string} str - The input string to check.
+ * @returns {boolean} True if all alphabetic characters are lowercase and at least one exists, false otherwise.
+ * @throws {TypeError} If the input is not a string.
+ */
+function isLowerCase(str) {
+    if (typeof str !== 'string') {
+        throw new TypeError('Input must be a string');
+    }
+    if (str.length === 0) {
+        return false;
+    }
+    let hasLetter = false;
+    for (const char of str) {
+        if (/[A-Z]/.test(char)) {
+            return false;
+        }
+        if (/[a-z]/.test(char)) {
+            hasLetter = true;
+        }
+    }
+    return hasLetter;
+}