stringzy 3.0.0 → 4.0.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,8 @@ export { isSlug } from './isSlug';
 export { isURL } from './isURL';
 export { isIPv4 } from './isIPv4';
 export { isHexColor } from './isHexColor';
+export { isPalindrome } from './isPalindrome';
+import { isCoordinates } from './isCoordinates';
 import { isDate } from './isDate';
 import { isEmail } from './isEmail';
 import { isEmpty } from './isEmpty';
@@ -12,7 +15,9 @@ import { isSlug } from './isSlug';
 import { isURL } from './isURL';
 import { isIPv4 } from './isIPv4';
 import { isHexColor } from './isHexColor';
+import { isPalindrome } from './isPalindrome';
 export declare const validations: {
+    isCoordinates: typeof isCoordinates;
     isDate: typeof isDate;
     isEmail: typeof isEmail;
     isEmpty: typeof isEmpty;
@@ -20,4 +25,5 @@ export declare const validations: {
     isURL: typeof isURL;
     isIPv4: typeof isIPv4;
     isHexColor: typeof isHexColor;
+    isPalindrome: typeof isPalindrome;
 };

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.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,9 @@ 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; } });
+const isCoordinates_2 = require("./isCoordinates");
 const isDate_2 = require("./isDate");
 const isEmail_2 = require("./isEmail");
 const isEmpty_2 = require("./isEmpty");
@@ -22,12 +27,15 @@ 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");
 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
 };

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/isPalindrome.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Checks whether the given string is a palindrome.
+ *
+ * The check is case-insensitive and ignores all non-alphanumeric characters.
+ *
+ * @param {string} str - The input string to check.
+ * @returns {boolean} True if the input is a palindrome, false otherwise.
+ * @throws {TypeError} If the input is not a string.
+ */
+export declare function isPalindrome(str: string): boolean;

package/dist/validations/isPalindrome.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPalindrome = isPalindrome;
+/**
+ * Checks whether the given string is a palindrome.
+ *
+ * The check is case-insensitive and ignores all non-alphanumeric characters.
+ *
+ * @param {string} str - The input string to check.
+ * @returns {boolean} True if the input is a palindrome, false otherwise.
+ * @throws {TypeError} If the input is not a string.
+ */
+function isPalindrome(str) {
+    if (typeof str !== 'string') {
+        throw new TypeError('Input must be a string');
+    }
+    const sanitized = str
+        .toLowerCase()
+        .replace(/[^a-z0-9]/gi, '');
+    return sanitized === sanitized.split('').reverse().join('');
+}

package/dist/validations/isSlug.d.ts

@@ -1 +1,28 @@
+/**
+ * Checks if a given string is a valid slug.
+ *
+ * A valid slug:
+ * - Contains only lowercase letters (`a-z`), numbers (`0-9`), and hyphens (`-`).
+ * - Does not start or end with a hyphen.
+ * - Does not contain consecutive hyphens.
+ * - Is not an empty string.
+ *
+ * @param {string} str - The string to validate as a slug.
+ * @returns {boolean} `true` if the string is a valid slug, otherwise `false`.
+ *
+ * @example
+ * isSlug("valid-slug-123"); // true
+ *
+ * @example
+ * isSlug("Invalid-Slug"); // false (uppercase letters)
+ *
+ * @example
+ * isSlug("-starts-with-hyphen"); // false
+ *
+ * @example
+ * isSlug("ends-with-hyphen-"); // false
+ *
+ * @example
+ * isSlug("double--hyphen"); // false
+ */
 export declare function isSlug(str: string): boolean;

package/dist/validations/isSlug.js

@@ -1,6 +1,33 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isSlug = isSlug;
+/**
+ * Checks if a given string is a valid slug.
+ *
+ * A valid slug:
+ * - Contains only lowercase letters (`a-z`), numbers (`0-9`), and hyphens (`-`).
+ * - Does not start or end with a hyphen.
+ * - Does not contain consecutive hyphens.
+ * - Is not an empty string.
+ *
+ * @param {string} str - The string to validate as a slug.
+ * @returns {boolean} `true` if the string is a valid slug, otherwise `false`.
+ *
+ * @example
+ * isSlug("valid-slug-123"); // true
+ *
+ * @example
+ * isSlug("Invalid-Slug"); // false (uppercase letters)
+ *
+ * @example
+ * isSlug("-starts-with-hyphen"); // false
+ *
+ * @example
+ * isSlug("ends-with-hyphen-"); // false
+ *
+ * @example
+ * isSlug("double--hyphen"); // false
+ */
 function isSlug(str) {
     if (typeof str !== 'string' || str.length === 0) {
         return false;

package/dist/validations/isTypeOf.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Checks if a file name or URL string has a valid extension for a given type.
+ *
+ * @param {string} input - File name or URL.
+ * @param {string} type - The type category to validate.
+ * @returns {boolean}
+ * @throws error when input is not string or type is not defined
+ */
+export declare function isTypeOf(input: string, type: string): boolean;

package/dist/validations/isTypeOf.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTypeOf = isTypeOf;
+/**
+ * Checks if a file name or URL string has a valid extension for a given type.
+ *
+ * @param {string} input - File name or URL.
+ * @param {string} type - The type category to validate.
+ * @returns {boolean}
+ * @throws error when input is not string or type is not defined
+ */
+function isTypeOf(input, type) {
+    var _a;
+    if (typeof input !== "string" || typeof type !== "string")
+        return false;
+    // Gets the substring after the last (.), then converts to lowercase, removes (?) and (#)
+    // Example: "image.png?version=2#top", returns "png"
+    const extension = (_a = input.split(".").pop()) === null || _a === void 0 ? void 0 : _a.toLowerCase().split("?")[0].split("#")[0];
+    if (!extension)
+        return false;
+    const typeMap = {
+        image: ["png", "jpg", "jpeg", "gif", "bmp", "svg", "webp", "ico"],
+        video: ["mp4", "webm", "avi", "mkv", "mov", "flv"],
+        audio: ["mp3", "wav", "ogg", "flac", "aac"],
+        document: ["pdf", "doc", "docx", "xls", "xlsx", "ppt", "pptx", "txt", "md"],
+        archive: ["zip", "rar", "tar", "gz", "7z"],
+    };
+    const allowed = typeMap[type.toLowerCase()];
+    return allowed ? allowed.includes(extension) : false;
+}

package/dist/validations/isURL.d.ts

@@ -1 +1,22 @@
+/**
+ * Checks if a given string is a valid URL.
+ *
+ * Uses the built-in `URL` constructor to attempt parsing the input string.
+ * Returns `true` if the string is a valid URL, otherwise `false`.
+ *
+ * @param {string} str - The string to validate as a URL.
+ * @returns {boolean} `true` if the string is a valid URL, otherwise `false`.
+ *
+ * @example
+ * isURL("https://www.example.com"); // true
+ *
+ * @example
+ * isURL("ftp://ftp.example.com/resource.txt"); // true
+ *
+ * @example
+ * isURL("not a url"); // false
+ *
+ * @example
+ * isURL("http:/invalid-url"); // false
+ */
 export declare function isURL(str: string): boolean;

package/dist/validations/isURL.js

@@ -1,6 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isURL = isURL;
+/**
+ * Checks if a given string is a valid URL.
+ *
+ * Uses the built-in `URL` constructor to attempt parsing the input string.
+ * Returns `true` if the string is a valid URL, otherwise `false`.
+ *
+ * @param {string} str - The string to validate as a URL.
+ * @returns {boolean} `true` if the string is a valid URL, otherwise `false`.
+ *
+ * @example
+ * isURL("https://www.example.com"); // true
+ *
+ * @example
+ * isURL("ftp://ftp.example.com/resource.txt"); // true
+ *
+ * @example
+ * isURL("not a url"); // false
+ *
+ * @example
+ * isURL("http:/invalid-url"); // false
+ */
 function isURL(str) {
     try {
         new URL(str);

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "stringzy",
-  "version": "3.0.0",
+  "version": "4.0.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
     "build": "tsc",
     "test": "npm run build && node --test",
-    "prepublishOnly": "npm run build"
+    "prepublishOnly": "npm run build",
+    "format": "prettier --write ."
   },
   "author": "Samarth Ruia",
   "readmeFilename": "README.md",
@@ -44,7 +45,8 @@
     "url": "git+https://github.com/Samarth2190/stringzy.git"
   },
   "devDependencies": {
-    "@types/node": "^24.0.0",
+    "@types/node": "^24.0.4",
+    "prettier": "^3.6.2",
     "typescript": "^5.8.3"
   }
 }