js-utils-kit 0.5.4 → 1.0.0

package/dist/string/index.d.ts

@@ -1,694 +0,0 @@
-/**
- * String trimming utilities.
- * Trims whitespace from a string (both sides by default) with methods for leading and trailing and normalizing whitespace.
- */
-interface Trim {
-    /**
-     * Removes whitespace from both ends of a string.
-     *
-     * @param str - The string to trim.
-     * @returns The trimmed string.
-     */
-    function(str: string): string;
-    /**
-     * Removes leading whitespace from a string.
-     *
-     * @param str - The string to trim.
-     * @returns The string with leading whitespace removed.
-     */
-    start(str: string): string;
-    /**
-     * Removes trailing whitespace from a string.
-     *
-     * @param str - The string to trim.
-     * @returns The string with trailing whitespace removed.
-     */
-    end(str: string): string;
-    /**
-     * Trims the string and replaces sequences of whitespace with a single space.
-     *
-     * @param str - The string to normalize.
-     * @returns The string with normalized whitespace.
-     */
-    normalizeWhitespace(str: string): string;
-}
-/**
- * String trimming utilities.
- * Trims whitespace from a string (both sides by default) with methods for leading and trailing and normalizing whitespace.
- *
- * @param str - The string to trim.
- *
- * @returns The string with leading and trailing whitespace removed.
- *
- * @remarks
- * - The main callable form behaves like {@link String.prototype.trim}, removing whitespace from both ends.
- * - `.start` removes only leading whitespace (like {@link String.prototype.trimStart}).
- * - `.end` removes only trailing whitespace (like {@link String.prototype.trimEnd}).
- * - `.normalizeWhitespace` trims the string and replaces any sequence of whitespace characters with a single space.
- *
- * @example
- * ```ts
- * // Trim both sides
- * console.log(trim("  hello  ")); // "hello"
- * console.log(trim("")); // ""
- * console.log(trim("hello")); // "hello"
- *
- * // Trim leading whitespace
- * console.log(trim.start("  hello  ")); // "hello  "
- * console.log(trim.start("")); // ""
- * console.log(trim.start("hello")); // "hello"
- *
- * // Trim trailing whitespace
- * console.log(trim.end("  hello  ")); // "  hello"
- * console.log(trim.end("")); // ""
- * console.log(trim.end("hello")); // "hello"
- *
- * // Normalize whitespace
- * console.log(trim.normalizeWhitespace("  hello   world  ")); // "hello world"
- * console.log(trim.normalizeWhitespace("hello\t  world")); // "hello world"
- * console.log(trim.normalizeWhitespace("")); // ""
- * ```
- */
-declare const trim: Trim;
-
-/**
- * Capitalizes the first character of a string using a regular expression.
- *
- * @param value - The string to capitalize.
- *
- * @returns The input string with its first character capitalized, or the original string if empty or not a string.
- *
- * @example
- * ```ts
- * capitalize("hello"); // "Hello"
- * capitalize("world"); // "World"
- * capitalize(""); // ""
- * capitalize("a"); // "A"
- * ```
- */
-declare function capitalize(value: string): string;
-
-/**
- * Splits a string into an array of substrings using a given delimiter.
- *
- * @remarks
- * - Defaults to splitting by whitespace using `/\s+/`.
- * - Does not trim leading/trailing spaces unless explicitly passed.
- * - Leading/trailing delimiters may produce empty strings.
- * - With `/\s+/` specifically, consecutive whitespace is collapsed (no interior empty tokens).
- *
- * @returns An array of substrings.
- *
- * @example
- * ```ts
- * splitString("a b  c");      // ["a", "b", "c"]
- * splitString("a,b,c", ",");  // ["a", "b", "c"]
- * splitString("a1b2c3", /\d/); // ["a", "b", "c", ""]
- * ```
- */
-declare function splitString(
-/** The input string to split. */
-str: string, 
-/**
- * The delimiter (string or RegExp)
- *
- * @default whitespace  `/\s+/`
- */
-val?: string | RegExp): string[];
-/**
- * Counts characters in a string.
- *
- * @remarks
- * - If `char` is provided, only that character’s occurrences are counted.
- * - If `char` is omitted, the function counts the number of substrings returned by {@link splitString} (similar to a word count).
- *
- * @returns Number of characters or character occurrences.
- *
- * @example
- * ```ts
- * countChars("banana");       // 6
- * countChars("banana", "a");  // 3
- * countChars("banana", "n");  // 2
- * ```
- */
-declare function countChars(
-/** The input string. */
-str: string, 
-/** Optional character to count. */
-char?: string): number;
-/**
- * Counts the number of words in a string.
- *
- * @returns Number of words in the string.
- *
- * @example
- * ```ts
- * countWords("js utils kit");         // 3
- * countWords("   js   utils   kit");  // 3
- * countWords("");                     // 0
- * ```
- */
-declare function countWords(
-/** The input string */
-str: string): number;
-/**
- * Counts how many times a substring occurs within a string.
- *
- * @remarks
- * - Overlapping substrings are not double-counted.
- * - Returns `0` if the substring is not found.
- *
- * @returns Number of times `sub` occurs in `str`.
- *
- * @example
- * ```ts
- * countSubstring("lololol", "lo"); // 3
- * countSubstring("aaaaa", "a");    // 5
- * countSubstring("hello", "z");    // 0
- * ```
- */
-declare function countSubstring(
-/** The input string. */
-str: string, 
-/** The substring to count. */
-sub: string): number;
-/**
- * Builds a frequency map of characters in a string.
- *
- * @remarks
- * - Returns an object where keys are characters and values are counts.
- * - Case-sensitive by default.
- *
- * @returns A mapping of each character to its frequency.
- *
- * @example
- * ```ts
- * countFrequencies("banana");
- * // { b: 1, a: 3, n: 2 }
- *
- * countFrequencies("");
- * // {}
- * ```
- */
-declare function countFrequencies(
-/** The input string. */
-str: string): Record<string, number>;
-/**
- * Counts the number of lines in a string.
- *
- * @remarks
- * - Handles Unix (`\n`), Windows (`\r\n`), and old Mac (`\r`) line endings.
- *
- * @returns Number of lines in the string.
- *
- * @example
- * ```ts
- * countLines("a\nb\nc");     // 3
- * countLines("a\r\nb\r\nc"); // 3
- * countLines("hello");       // 1
- * ```
- */
-declare function countLines(
-/** The input string. */
-str: string): number;
-/**
- * Returns an array of unique characters from a string.
- *
- * @remarks
- * - Preserves order of first appearance.
- *
- * @returns Array of unique characters.
- *
- * @example
- * ```ts
- * uniqueChars("banana"); // ["b", "a", "n"]
- * uniqueChars("");       // []
- * ```
- */
-declare function uniqueChars(
-/** The input string. */
-str: string): string[];
-/**
- * Finds the length of the longest word in a string.
- *
- * @remarks
- * - Words are split by whitespace (`/\s+/`).
- * - Symbols (punctuation, special chars) are removed using {@link stripSymbols}.
- * - Returns `0` if the string is empty or contains no words.
- *
- * @returns Length of the longest word.
- *
- * @example
- * ```ts
- * longestWordLength("js utils kit");              // 5
- * longestWordLength("short   longerword   mid"); // 10
- * longestWordLength("hello");                    // 5
- * longestWordLength("");                         // 0
- * ```
- */
-declare function longestWordLength(
-/** The input string. */
-str: string): number;
-/**
- * Finds the length of the shortest word in a string.
- *
- * @remarks
- * - Words are split by whitespace (`/\s+/`).
- * - Symbols (punctuation, special chars) are removed using {@link stripSymbols}.
- * - Returns `0` if the string is empty or contains no words.
- *
- * @returns Length of the shortest word.
- *
- * @example
- * ```ts
- * shortestWordLength("js utils kit"); // 2
- * shortestWordLength("one three five"); // 3
- * shortestWordLength(""); // 0
- * ```
- */
-declare function shortestWordLength(
-/** The input string. */
-str: string): number;
-/**
- * Finds the longest word(s) in a string.
- *
- * @remarks
- * - If only one longest word exists, returns it as a string.
- * - If multiple longest words have the same length, returns them as an array.
- * - Returns an empty string if there are no words.
- *
- * @returns The longest word as a string, or an array of tied words.
- *
- * @example
- * ```ts
- * longestWord("js utils kit");              // "utils"
- * longestWord("short   longerword   mid"); // "longerword"
- * longestWord("hello");                    // "hello"
- * longestWord("");                         // ""
- * ```
- */
-declare function longestWord(
-/** The input string. */
-str: string): string | string[];
-/**
- * Finds the shortest word(s) in a string.
- *
- * @remarks
- * - If only one shortest word exists, returns it as a string.
- * - If multiple shortest words have the same length, returns them as an array.
- * - Returns an empty string if there are no words.
- *
- * @returns The shortest word as a string, or an array of tied words.
- *
- * @example
- * ```ts
- * shortestWord("js utils kit"); // "js"
- * shortestWord("one three five"); // "one"
- * shortestWord("a ab abc abcd"); // "a"
- * shortestWord(""); // ""
- * ```
- */
-declare function shortestWord(
-/** The input string. */
-str: string): string | string[];
-
-/**
- * Pads a string on the left with a specified character until it reaches the desired length.
- * @param str - The string to pad.
- * @param length - The target length of the padded string.
- * @param char - The character to use for padding (defaults to a space).
- * @returns The padded string, or the original string if its length is already greater than or equal to the target length.
- * @example
- * ```ts
- * console.log(padLeft("hello", 8)); // "   hello"
- * console.log(padLeft("hi", 5, "*")); // "***hi"
- * console.log(padLeft("hello", 3)); // "hello"
- * console.log(padLeft("", 3, "0")); // "000"
- * ```
- */
-declare function padLeft(str: string, length: number, char?: string): string;
-/**
- * Pads a string on the right with a specified character until it reaches the desired length.
- * @param str - The string to pad.
- * @param length - The target length of the padded string.
- * @param char - The character to use for padding (defaults to a space).
- * @returns The padded string, or the original string if its length is already greater than or equal to the target length.
- * @example
- * ```ts
- * console.log(padRight("hello", 8)); // "hello   "
- * console.log(padRight("hi", 5, "*")); // "hi***"
- * console.log(padRight("hello", 3)); // "hello"
- * console.log(padRight("", 3, "0")); // "000"
- * ```
- */
-declare function padRight(str: string, length: number, char?: string): string;
-/**
- * Truncates a string to a specified length, appending a suffix if the string is too long.
- *
- * @returns The truncated string with the suffix if the original string exceeds the length, otherwise the original string.
- *
- * @example
- * ```ts
- * console.log(truncate("hello world", 8)); // "hello..."
- * console.log(truncate("hi", 5)); // "hi"
- * console.log(truncate("hello", 5, "...")); // "hello"
- * console.log(truncate("", 3)); // ""
- * ```
- */
-declare function truncate(
-/** The string to truncate */
-str: string, 
-/** The maximum length of the resulting string */
-length: number, 
-/**
- * The suffix to append if truncation occurs
- *
- * @default "..."
- */
-suffix?: string): string;
-/**
- * Repeats a string a specified number of times.
- * @param str - The string to repeat.
- * @param count - The number of times to repeat the string (must be non-negative).
- * @returns The string repeated the specified number of times.
- * @example
- * ```ts
- * console.log(repeatString("hi", 3)); // "hihihi"
- * console.log(repeatString("a", 2)); // "aa"
- * console.log(repeatString("test", 0)); // ""
- * console.log(repeatString("", 5)); // ""
- * ```
- */
-declare function repeatString(str: string, count: number): string;
-/**
- * Removes or replaces common symbol characters from a string.
- *
- * @remarks
- * - Strips symbols like `- _ @ ! $ % ^ & # * ( ) + = , . ; : ' " < > ? / \ | [ ] { }`.
- * - Keeps letters, numbers, and spaces intact.
- * - By default, removes symbols (replaces with `""`).
- *
- * @returns A new string with symbols removed or replaced.
- *
- * @example
- * ```ts
- * stripSymbols("hello-world!");              // "helloworld"
- * stripSymbols("hello-world!", " ");         // "hello world "
- * stripSymbols("user_name@test", "_");       // "user_nametest"
- * stripSymbols("symbols-only!!!", "*");      // "symbols-only***"
- * ```
- */
-declare function stripSymbols(
-/** The input string */
-str: string, 
-/**
- * Optional replacement string for removed symbols.
- *
- * @default ""
- */
-replacement?: string): string;
-
-/**
- * Determines whether the provided value is a string.
- *
- * This function returns `true` if the input is a non-null, non-undefined
- * primitive string. It acts as a type guard, so TypeScript will narrow
- * the type to `string` when used in conditionals.
- *
- * @template T - The type of the input value.
- * @param value - The value to be checked.
- * @returns - Whether the value is a string (`true`) or not (`false`).
- *
- * @example
- * ```ts
- * isString("hello"); // true
- * isString(123);     // false
- * isString(null);    // false
- * isString(undefined); // false
- *
- * const value: unknown = "test";
- * if (isString(value)) {
- *   console.log(value.toUpperCase());
- * }
- * ```
- */
-declare function isString<T>(value: T): boolean;
-/**
- * Determines whether the given value is a non-empty string.
- *
- * This function first checks if the input is a string using {@link isString}.
- * If it is not a string, the function returns `false`.
- * If it is a string, it then checks whether the string contains any non-empty content.
- *
- * By default, the function trims the string before checking its length,
- * which means strings containing only whitespace (e.g., `"   "`) will be considered empty.
- * This behavior can be controlled using the `trim` parameter.
- *
- * @template T - The type of the value being checked.
- *
- * @param value - The value to validate as a non-empty string.
- * @param trim - Whether to trim whitespace from the string before checking its length.
- *               Defaults to `true`.
- *
- * @returns - A boolean indicating whether the input is a non-empty string.
- *
- * @example
- * ```ts
- * isNonEmptyString('hello'); // true
- * isNonEmptyString('   '); // false (trim is true by default)
- * isNonEmptyString('   ', false); // true (whitespace is counted)
- * isNonEmptyString(123); // false
- * isNonEmptyString(null); // false
- * ```
- */
-declare function isNonEmptyString<T>(value: T, trim?: boolean): boolean;
-/**
- * Checks whether a given string is a valid absolute URL.
- *
- * This function uses the native `URL` constructor to determine if the input is a valid,
- * absolute URL with a supported protocol (e.g., `http`, `https`, `ftp`, etc.).
- *
- * @param value - The string to validate as a URL.
- * @returns - `true` if the string is a valid absolute URL; otherwise, `false`.
- *
- * @example
- * ```ts
- * isURL('https://example.com'); // true
- * isURL('ftp://files.example.com'); // true
- * isURL('invalid-url'); // false
- * isURL('/relative/path'); // false
- * ```
- */
-declare function isURL(value: string): boolean;
-/**
- * Checks whether a given string is a valid email address.
- *
- * @remarks
- * This function uses a practical regular expression to validate email addresses,
- * allowing most common formats while ignoring edge cases defined by full RFC 5322.
- * It requires the presence of an `@` symbol and at least one `.` after it.
- *
- * **Limits enforced**:
- * - Local part (before `@`): 1–64 characters
- * - Domain part (after `@`): 1–255 characters
- * - Total email length: ≤ 254 characters
- *
- * @param value - The string to validate as an email address.
- *
- * @throws {TypeError} Throws if value is not a string.
- *
- * @returns - `true` if the string is a valid email; otherwise, `false`.
- *
- * @example
- * ```ts
- * isEmail('user@example.com'); // true
- * isEmail('first.last@college.university.in'); // true
- * isEmail('invalid-email'); // false
- * isEmail('name@domain'); // false
- * ```
- */
-declare function isEmail(value: string): boolean;
-/**
- * Checks if a string contains only alphabetic characters (A–Z, a–z).
- *
- * @param value - The string to check.
- * @returns - `true` if the string contains only letters; otherwise, `false`.
- *
- * @example
- * ```ts
- * isAlphabetic("Hello"); // true
- * isAlphabetic("world123"); // false
- * isAlphabetic("Test!"); // false
- * ```
- */
-declare function isAlphabetic(value: string): boolean;
-/**
- * Checks whether a given string represents a valid numeric value.
- *
- * This function attempts to convert the input string to a number using
- * both `Number()` and `parseFloat()`. It returns `true` only if both
- * conversions do not result in `NaN`, ensuring that the input is
- * a fully numeric string.
- *
- * Accepts integers, decimals, scientific notation (e.g. "1e5"), and
- * ignores surrounding whitespace. Does not allow trailing or embedded characters
- * like "123abc" or "abc123".
- *
- * @param value - The string to validate.
- * @returns - `true` if the string represents a valid number; otherwise, `false`.
- *
- * @example
- * ```ts
- * isNumericString("42"); // true
- * isNumericString("-3.14"); // true
- * isNumericString("1e5"); // true
- * isNumericString("  123 "); // true
- * isNumericString("123abc"); // false
- * isNumericString("abc123"); // false
- * ```
- * See also:
- * - {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number Number()}
- * - {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/parseFloat parseFloat()}
- * - {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/isNaN isNaN()}
- */
-declare function isNumericString(value: string): boolean;
-/**
- * Checks if a string starts with an uppercase letter.
- * @param value - The input string to check.
- * @returns True if the first character is uppercase, false otherwise.
- * @example
- * ```ts
- * startsWithUppercase('Hello') // true
- * startsWithUppercase('world') // false
- * ```
- */
-declare function startsWithUppercase(value: string): boolean;
-/**
- * Checks if a string ends with any Unicode punctuation character.
- *
- * @param value - The string to check.
- * @returns True if the string ends with a punctuation character.
- * @example
- * ```ts
- * endsWithPunctuation("Hi!") // true
- * endsWithPunctuation("Hello—") // true
- * endsWithPunctuation("Okay") // false
- * ```
- */
-declare function endsWithPunctuation(value: string): boolean;
-/**
- * Checks if a string contains any whitespace.
- * @param value - The string to check.
- * @returns True if the string contains whitespace.
- * @example
- * ```ts
- * containsWhitespace("Hello world") // true
- * containsWhitespace("Nowordspace") // false
- * ```
- */
-declare function containsWhitespace(value: string): boolean;
-/**
- * Checks if a string is in camelCase format.
- * @param value - The input string.
- * @returns True if the string is camelCase.
- * @example
- * ```ts
- * isCamelCase("helloWorld") // true
- * isCamelCase("HelloWorld") // false
- * ```
- */
-declare function isCamelCase(value: string): boolean;
-/**
- * Checks if a string is in PascalCase format.
- * @param value - The input string.
- * @returns True if the string is PascalCase.
- * @example
- * ```ts
- * isPascalCase("HelloWorld") // true
- * isPascalCase("helloWorld") // false
- * ```
- */
-declare function isPascalCase(value: string): boolean;
-/**
- * Checks if a string is in kebab-case format.
- * @param value - The input string.
- * @returns True if the string is kebab-case.
- * @example
- * ```ts
- * isKebabCase("hello-world") // true
- * isKebabCase("hello_world") // false
- * ```
- */
-declare function isKebabCase(value: string): boolean;
-/**
- * Checks if a string is in snake_case format.
- * @param value - The input string.
- * @returns True if the string is snake_case.
- * @example
- * ```ts
- * isSnakeCase("hello_world") // true
- * isSnakeCase("hello-world") // false
- * ```
- */
-declare function isSnakeCase(value: string): boolean;
-/**
- * Checks if a string contains only uppercase letters.
- * @param value - The input string.
- * @returns True if all letters are uppercase.
- * @example
- * ```ts
- * isUpperCase("HELLO") // true
- * isUpperCase("Hello") // false
- * ```
- */
-declare function isUpperCase(value: string): boolean;
-/**
- * Checks if a string contains only lowercase letters.
- * @param value - The input string.
- * @returns True if all letters are lowercase.
- * @example
- * ```ts
- * isLowerCase("hello") // true
- * isLowerCase("Hello") // false
- * ```
- */
-declare function isLowerCase(value: string): boolean;
-
-declare const _default: {
-    capitalize: typeof capitalize;
-    splitString: typeof splitString;
-    countChars: typeof countChars;
-    countWords: typeof countWords;
-    countSubstring: typeof countSubstring;
-    countFrequencies: typeof countFrequencies;
-    countLines: typeof countLines;
-    uniqueChars: typeof uniqueChars;
-    longestWordLength: typeof longestWordLength;
-    shortestWordLength: typeof shortestWordLength;
-    longestWord: typeof longestWord;
-    shortestWord: typeof shortestWord;
-    padLeft: typeof padLeft;
-    padRight: typeof padRight;
-    truncate: typeof truncate;
-    repeatString: typeof repeatString;
-    stripSymbols: typeof stripSymbols;
-    trim: Trim;
-    isString: typeof isString;
-    isNonEmptyString: typeof isNonEmptyString;
-    isURL: typeof isURL;
-    isEmail: typeof isEmail;
-    isAlphabetic: typeof isAlphabetic;
-    isNumericString: typeof isNumericString;
-    startsWithUppercase: typeof startsWithUppercase;
-    endsWithPunctuation: typeof endsWithPunctuation;
-    containsWhitespace: typeof containsWhitespace;
-    isCamelCase: typeof isCamelCase;
-    isPascalCase: typeof isPascalCase;
-    isKebabCase: typeof isKebabCase;
-    isSnakeCase: typeof isSnakeCase;
-    isUpperCase: typeof isUpperCase;
-    isLowerCase: typeof isLowerCase;
-};
-
-export { capitalize, containsWhitespace, countChars, countFrequencies, countLines, countSubstring, countWords, _default as default, endsWithPunctuation, isAlphabetic, isCamelCase, isEmail, isKebabCase, isLowerCase, isNonEmptyString, isNumericString, isPascalCase, isSnakeCase, isString, isURL, isUpperCase, longestWord, longestWordLength, padLeft, padRight, repeatString, shortestWord, shortestWordLength, splitString, startsWithUppercase, stripSymbols, trim, truncate, uniqueChars };
-export type { Trim };

package/dist/string/index.js

@@ -1 +0,0 @@
-function t(t){return t.replace(/^\w/,t=>t.toUpperCase())}function n(t,n,e=" "){return t.padStart(n,e)}function e(t,n,e=" "){return t.padEnd(n,e)}function r(t,n,e="..."){return n<=0?"":t.length<=n?t:e.length>=n?e.slice(0,n):t.trim().slice(0,n)+e}function i(t,n){return t.repeat(n)}function u(t,n=""){return t.replace(/[^\p{L}\p{N}\s]/gu,n)}function s(t,n=/\s+/){return t.split(n)}function o(t,n){return n?[...t].filter(t=>t===n).length:s(t).length}function a(t){return s(t.trim()).length}function c(t,n){return 0===n.length?0:s(t,n).length-1}function l(t){return[...t].reduce((t,n)=>(t[n]=(t[n]||0)+1,t),{})}function f(t){return t?s(t,/\r\n|\r|\n/).length:0}function h(t){return[...new Set(t)]}function g(t){const n=s(t).map(t=>u(t)).filter(Boolean);return 0===n.length?0:n.reduce((t,n)=>Math.max(t,n.length),0)}function p(t){const n=s(t.trim()).map(t=>u(t)).filter(Boolean);return 0===n.length?0:n.reduce((t,n)=>Math.min(t,n.length),1/0)}function m(t){const n=s(t.trim()).map(t=>u(t)).filter(Boolean);if(0===n.length)return"";const e=Math.max(...n.map(t=>t.length)),r=n.filter(t=>t.length===e),i=[...new Set(r)];return 1===i.length?i[0]:i}function d(t){const n=s(t.trim()).map(t=>u(t)).filter(Boolean);if(0===n.length)return"";const e=Math.min(...n.map(t=>t.length)),r=n.filter(t=>t.length===e),i=[...new Set(r)];return 1===i.length?i[0]:i}const z={function:t=>t.trim(),start:t=>t.trimStart(),end:t=>t.trimEnd(),normalizeWhitespace:t=>t.trim().replace(/\s+/g," ")};function S(t){return null!=t&&"string"==typeof t}function A(t,n=!0){return!!S(t)&&("string"==typeof t&&(n?t.trim().length>0:t.length>0))}function Z(t){try{return new URL(t),!0}catch{return!1}}function C(t){if("string"!=typeof t)throw new TypeError("Expected a string");if(t.length>254)return!1;const n=t.split("@");if(2!==n.length)return!1;const[e,r]=n;if(0===e.length||e.length>64)return!1;if(0===r.length||r.length>255)return!1;return!!/^[a-zA-Z0-9_%+-]+(\.[a-zA-Z0-9_%+-]+)*$/.test(e)&&!!/^(?!.*\.\.)(?!-)[A-Za-z0-9-]{1,63}(?<!-)(\.[A-Za-z0-9-]{1,63}(?<!-))*\.[A-Za-z]{2,}$/.test(r)}function $(t){return/^[a-zA-Z]+$/.test(t)}function W(t){return!isNaN(Number(t))&&!isNaN(parseFloat(t))}function w(t){return/^[A-Z]/.test(t)}function L(t){return/[\p{P}]$/u.test(t)}function N(t){return/\s/.test(t)}function y(t){return/^[a-z][a-zA-Z0-9]*$/.test(t)}function b(t){return/^[A-Z][a-zA-Z0-9]*$/.test(t)}function E(t){return/^[a-z0-9]+(-[a-z0-9]+)*$/.test(t)}function U(t){return/^[a-z0-9]+(_[a-z0-9]+)*$/.test(t)}function x(t){return/^[A-Z]+$/.test(t)}function B(t){return/^[a-z]+$/.test(t)}var M={capitalize:t,splitString:s,countChars:o,countWords:a,countSubstring:c,countFrequencies:l,countLines:f,uniqueChars:h,longestWordLength:g,shortestWordLength:p,longestWord:m,shortestWord:d,padLeft:n,padRight:e,truncate:r,repeatString:i,stripSymbols:u,trim:z,isString:S,isNonEmptyString:A,isURL:Z,isEmail:C,isAlphabetic:$,isNumericString:W,startsWithUppercase:w,endsWithPunctuation:L,containsWhitespace:N,isCamelCase:y,isPascalCase:b,isKebabCase:E,isSnakeCase:U,isUpperCase:x,isLowerCase:B};export{t as capitalize,N as containsWhitespace,o as countChars,l as countFrequencies,f as countLines,c as countSubstring,a as countWords,M as default,L as endsWithPunctuation,$ as isAlphabetic,y as isCamelCase,C as isEmail,E as isKebabCase,B as isLowerCase,A as isNonEmptyString,W as isNumericString,b as isPascalCase,U as isSnakeCase,S as isString,Z as isURL,x as isUpperCase,m as longestWord,g as longestWordLength,n as padLeft,e as padRight,i as repeatString,d as shortestWord,p as shortestWordLength,s as splitString,w as startsWithUppercase,u as stripSymbols,z as trim,r as truncate,h as uniqueChars};

package/dist/validate-BKQ-HFTd.js

@@ -1 +0,0 @@
-"use strict";function r(r){return null!=r}exports.isArray=function(n){return r(n)&&Array.isArray(n)},exports.isDefined=r,exports.isUndefinedOrNull=function(r){return null==r};