@rzl-zone/utils-js 2.1.0 → 3.0.0-beta.0

package/dist/strings/index.d.ts

@@ -0,0 +1,816 @@
+import{c as Nilable}from'../nils-DMz3kU7M.js';
+/** ----------------------------------------------------------
+* * Capitalizes the first letter of a string.
+* * Optionally lowercases the rest and trims whitespace.
+* ----------------------------------------------------------
+*
+* @param string - The string to be processed.
+* @param options - Options to control behavior.
+* @param options.lowerCaseNextRest - If true, lowercases the rest (next first letter) (default: true).
+* @param options.trim - If true, trims the string before processing (default: false).
+* @returns The processed string. Returns "" if input is null, undefined, or not a valid string.
+*
+* @example
+* capitalizeFirst(" hello WORLD ") // " Hello world"
+* capitalizeFirst(" hello WORLD ", { trim: true }) // "Hello world"
+* capitalizeFirst("FOO", { lowerCaseNextRest: false }) // "FOO"
+* capitalizeFirst("   foo BAR   ", { trim: true, lowerCaseNextRest: false }) // "Foo BAR"
+*/
+declare const capitalizeFirst:(string?:string|null,options?:{
+/**
+* @description If true, the rest of the string will be converted to lowercase after capitalizing the first letter.
+*  @default true
+*/
+lowerCaseNextRest?:boolean;
+/**
+* @description If true, the string will trimmed.
+*  @default false
+*/
+trim?:boolean;})=>string;
+/** ----------------------------------------------------------
+* * ***Capitalizes the first letter of each word in a string
+* while converting the rest to lowercase.***
+* ----------------------------------------------------------
+*
+* @param value - The input string to be processed. If `null` or `undefined`, returns an empty string.
+* @param options - Optional settings to control the output:
+*   - `trim`: If `true`, removes leading and trailing spaces, defaultValue: `false`.
+*   - `collapseSpaces`: If `true`, collapses multiple spaces **between words** into a single space (while preserving leading/trailing spaces), defaultValue: `false`.
+*
+* @returns A new string where each word starts with an uppercase letter
+* and the remaining letters are lowercase. If `value` is empty, `null`, or `undefined`,
+* returns an empty string.
+*
+* @example
+* capitalizeWords("  hello   world  ");
+* // => "  Hello   World  "
+*
+* capitalizeWords("  hello   world  ", { trim: true });
+* // => "Hello   World"
+*
+* capitalizeWords("  hello   world  ", { collapseSpaces: true });
+* // => "  Hello World  "
+*
+* capitalizeWords("  hello   world  ", { trim: true, collapseSpaces: true });
+* // => "Hello World"
+*/
+declare const capitalizeWords:(value?:string|null,options?:{
+/** If `true`, removes leading and trailing spaces, default `false`. */
+trim?:boolean;
+/** If `true`, collapses multiple spaces **between words** into a single space (while preserving leading/trailing spaces), default `false`. */
+collapseSpaces?:boolean;})=>string;
+/** --------------------------------------------------
+* * ***Represents a string input that may be:***
+*   - a single string,
+*   - an array of strings,
+*   - a readonly array of strings,
+*   - or `null` / `undefined`.
+* --------------------------------------------------
+*
+* @template T A string or array of strings.
+*/
+type StringLike=Nilable<string|string[]|ReadonlyArray<string>>;
+/** --------------------------------------------------
+* * ***Represents a collection of strings, which can be:***
+*   - a single string,
+*   - an array of strings,
+*   - a readonly array of strings,
+*   - a `Set` of strings, or
+*   - a `ReadonlySet` of strings.
+* --------------------------------------------------
+*/
+type StringCollection=string|string[]|ReadonlyArray<string>|Set<string>|ReadonlySet<string>;
+/** ----------------------------------------------------------
+* * ***Converts a string (or array of strings) into `camelCase`, with optionally leaving specific words unchanged.***
+* ----------------------------------------------------------
+*
+* @description
+* - Accepts a `string` or an array of `strings`:
+*   - If an array is provided, elements are trimmed, empty ones removed,
+*     then joined with `"-"` before conversion.
+* - Splits the input by non-alphanumeric characters
+*   (spaces, punctuation, symbols, hyphens, underscores, emojis, etc.).
+* - The first word is fully lowercase; subsequent words are capitalized.
+* - Words listed in `ignoreWord` remain unchanged in the output.
+* - `ignoreWord` is normalized (trimmed, delimiters removed); empty values ignored.
+* - `ignoreWord` accepts:
+*   - a single string,
+*   - an array of strings, or
+*   - a `Set` of strings.
+* - Multiple delimiters collapse into one; empty segments ignored.
+* - Returns `""` if the input is `null`, `undefined`, or empty.
+*
+* @param {StringLike} input - The string or array to convert. Returns `""` if empty, `null`, or `undefined`.
+* @param {StringCollection} [ignoreWord] - Optional word(s) to leave unchanged in the output.
+* @returns {string} The camelCase formatted string.
+*
+* @example
+* // Basic usage
+* toCamelCase("hello world");
+* // ➔ "helloWorld"
+*
+* @example
+* // Array input is joined before conversion
+* toCamelCase(["Join", "Words", "Here"]);
+* // ➔ "joinWordsHere"
+*
+* @example
+* // Supports mixed delimiters
+* toCamelCase("convert_to-camel case");
+* // ➔ "convertToCamelCase"
+*
+* @example
+* // Words in ignoreWord stay unchanged
+* toCamelCase("this URL path will ignore", "URL");
+* // ➔ "thisURLPathWillIgnore"
+*
+* @example
+* // Multiple ignored words
+* toCamelCase("ignore API and URL", ["API", "URL"]);
+* // ➔ "ignoreAPIAndURL"
+*
+* @example
+* // Set can also be used
+* toCamelCase("ignore API and URL", new Set(["API", "URL"]));
+* // ➔ "ignoreAPIAndURL"
+*
+* @example
+* // Null or empty input returns empty string
+* toCamelCase(null);
+* // ➔ ""
+*/
+declare const toCamelCase:(input:StringLike,ignoreWord?:StringCollection)=>string;
+/** ----------------------------------------------------------
+* * ***Converts a string (or array of strings) into `PascalCaseSpace`, with optionally leaving specific words unchanged.***
+* ----------------------------------------------------------
+*
+* @description
+* - Accepts a `string` or an array of `strings`:
+*   - If an array is provided, elements are trimmed, empty ones removed,
+*     then joined with `"-"` before conversion.
+* - Splits the input by non-alphanumeric characters
+*   (spaces, punctuation, symbols, hyphens, underscores, emojis, etc.).
+* - The first word is fully lowercase; subsequent words are capitalized.
+* - Words listed in `ignoreWord` remain unchanged in the output.
+* - `ignoreWord` is normalized (trimmed, delimiters removed); empty values ignored.
+* - `ignoreWord` accepts:
+*   - a single string,
+*   - an array of strings, or
+*   - a `Set` of strings.
+* - Multiple delimiters collapse into one; empty segments ignored.
+* - Returns `""` if the input is `null`, `undefined`, or empty.
+*
+* @param {StringLike} input - The string or array to convert. Returns `""` if empty, `null`, or `undefined`.
+* @param {StringCollection} [ignoreWord] - Optional word(s) to leave unchanged in the output.
+* @returns {string} The PascalCaseSpace formatted string.
+*
+* @example
+* // Basic usage
+* toPascalCaseSpace("hello world");
+* // ➔ "Hello World"
+*
+* @example
+* // Array input is joined before conversion
+* toPascalCaseSpace(["Join", "Words", "Here"]);
+* // ➔ "Join Words Here"
+*
+* @example
+* // Handles underscores and hyphens
+* toPascalCaseSpace("convert_to-pascal case");
+* // ➔ "Convert To Pascal Case Space"
+*
+* @example
+* // Trims extra delimiters
+* toPascalCaseSpace("___hello--world__ again!!");
+* // ➔ "Hello World Again"
+*
+* @example
+* // Supports emojis and symbols
+* toPascalCaseSpace("🔥fire_and-ice❄️");
+* // ➔ "Fire And Ice"
+*
+* @example
+* // Ignore single word
+* toPascalCaseSpace("this URL path will ignore", "URL");
+* // ➔ "This URL Path Will Ignore"
+*
+* @example
+* // Ignore multiple words
+* toPascalCaseSpace("ignore API and URL", ["API", "URL"]);
+* // ➔ "Ignore API And URL"
+*
+* @example
+* // Ignore using Set
+* toPascalCaseSpace("ignore API and URL", new Set(["API", "URL"]));
+* // ➔ "Ignore API And URL"
+*
+* @example
+* // Null or empty returns empty string
+* toPascalCaseSpace(undefined);
+* // ➔ ""
+*/
+declare const toPascalCaseSpace:(input:StringLike,ignoreWord?:StringCollection)=>string;
+/** ----------------------------------------------------------
+* * ***Converts a string (or array of strings) into `PascalCase`, with optionally leaving specific words unchanged.***
+* ----------------------------------------------------------
+*
+* @description
+* - Accepts a `string` or an array of `strings`:
+*   - If an array is provided, elements are trimmed, empty ones removed,
+*     then joined with `"-"` before conversion.
+* - Splits the input by non-alphanumeric characters
+*   (spaces, punctuation, symbols, hyphens, underscores, emojis, etc.).
+* - The first word is fully lowercase; subsequent words are capitalized.
+* - Words listed in `ignoreWord` remain unchanged in the output.
+* - `ignoreWord` is normalized (trimmed, delimiters removed); empty values ignored.
+* - `ignoreWord` accepts:
+*   - a single string,
+*   - an array of strings, or
+*   - a `Set` of strings.
+* - Multiple delimiters collapse into one; empty segments ignored.
+* - Returns `""` if the input is `null`, `undefined`, or empty.
+*
+* @param {StringLike} input - The string or array to convert. Returns `""` if empty, `null`, or `undefined`.
+* @param {StringCollection} [ignoreWord] - Optional word(s) to leave unchanged in the output.
+* @returns {string} The PascalCase formatted string.
+*
+* @example
+* // Basic usage
+* toPascalCase("hello world");
+* // ➔ "HelloWorld"
+*
+* @example
+* // Array input is joined before conversion
+* toPascalCase(["Join", "Words", "Here"]);
+* // ➔ "JoinWordsHere"
+*
+* @example
+* // Handles underscores and hyphens
+* toPascalCase("convert_to-pascal case");
+* // ➔ "ConvertToPascalCase"
+*
+* @example
+* // Trims extra delimiters
+* toPascalCase("___hello--world__ again!!");
+* // ➔ "HelloWorldAgain"
+*
+* @example
+* // Supports emojis and symbols
+* toPascalCase("🔥fire_and-ice❄️");
+* // ➔ "FireAndIce"
+*
+* @example
+* // Ignore single word
+* toPascalCase("this URL path will ignore", "URL");
+* // ➔ "ThisURLPathWillIgnore"
+*
+* @example
+* // Ignore multiple words
+* toPascalCase("ignore API and URL", ["API", "URL"]);
+* // ➔ "IgnoreAPIAndURL"
+*
+* @example
+* // Ignore using Set
+* toPascalCase("ignore API and URL", new Set(["API", "URL"]));
+* // ➔ "IgnoreAPIAndURL"
+*
+* @example
+* // Null or empty returns empty string
+* toPascalCase(undefined);
+* // ➔ ""
+*/
+declare const toPascalCase:(input:StringLike,ignoreWord?:StringCollection)=>string;
+/** ----------------------------------------------------------
+* * ***Converts a string (or array of strings) into `LowerCase`, with optionally leaving specific words unchanged.***
+* ----------------------------------------------------------
+*
+* @description
+* - Accepts a `string` or an array of `strings`:
+*   - If an array is provided, elements are trimmed, empty ones removed,
+*     then joined with `"-"` before conversion.
+* - Splits the input by non-alphanumeric characters
+*   (spaces, punctuation, symbols, hyphens, underscores, emojis, etc.).
+* - The first word is fully lowercase; subsequent words are capitalized.
+* - Words listed in `ignoreWord` remain unchanged in the output.
+* - `ignoreWord` is normalized (trimmed, delimiters removed); empty values ignored.
+* - `ignoreWord` accepts:
+*   - a single string,
+*   - an array of strings, or
+*   - a `Set` of strings.
+* - Multiple delimiters collapse into one; empty segments ignored.
+* - Returns `""` if the input is `null`, `undefined`, or empty.
+*
+* @param {StringLike} input - The string or array to convert. Returns `""` if empty, `null`, or `undefined`.
+* @param {StringCollection} [ignoreWord] - Optional word(s) to leave unchanged in the output.
+* @returns {string} The LowerCase formatted string.
+*
+* @example
+* // Basic usage
+* toLowerCase("Hello World");
+* // ➔ "hello world"
+*
+* @example
+* // Array input is joined before conversion
+* toLowerCase(["Join", "WORLD", "Here"]);
+* // ➔ "join words here"
+*
+* @example
+* // Handles underscores and hyphens
+* toLowerCase("convert_to-pascal case");
+* // ➔ "convert to lower case"
+*
+* @example
+* // Trims extra delimiters
+* toLowerCase("___hello--world__ again!!");
+* // ➔ "hello world again"
+*
+* @example
+* // Supports emojis and symbols
+* toLowerCase("🔥fire_and-ice❄️");
+* // ➔ "fire and ice"
+*
+* @example
+* // Ignore single word
+* toLowerCase("this URL path will ignore", "URL");
+* // ➔ "this URL path will ignore"
+*
+* @example
+* // Ignore multiple words
+* toLowerCase("ignore API and URL", ["API", "URL"]);
+* // ➔ "ignore API and URL"
+*
+* @example
+* // Ignore using Set
+* toLowerCase("ignore API and URL", new Set(["API", "URL"]));
+* // ➔ "ignore API and URL"
+*
+* @example
+* // Null or empty returns empty string
+* toLowerCase(undefined);
+* // ➔ ""
+*/
+declare const toLowerCase:(input:StringLike,ignoreWord?:StringCollection)=>string;
+/** ----------------------------------------------------------
+* * ***Converts a string (or array of strings) into `kebab-case`, with optionally leaving specific words unchanged.***
+* ----------------------------------------------------------
+*
+* @description
+* - Accepts a `string` or an array of `strings`:
+*   - If an array is provided, elements are trimmed, empty ones removed,
+*     then joined with `"-"` before conversion.
+* - Splits the input by non-alphanumeric characters
+*   (spaces, punctuation, symbols, hyphens, underscores, emojis, etc.).
+* - The first word is fully lowercase; subsequent words are capitalized.
+* - Words listed in `ignoreWord` remain unchanged in the output.
+* - `ignoreWord` is normalized (trimmed, delimiters removed); empty values ignored.
+* - `ignoreWord` accepts:
+*   - a single string,
+*   - an array of strings, or
+*   - a `Set` of strings.
+* - Multiple delimiters collapse into one; empty segments ignored.
+* - Returns `""` if the input is `null`, `undefined`, or empty.
+*
+* @param {StringLike} input - The string or array to convert. Returns `""` if empty, `null`, or `undefined`.
+* @param {StringCollection} [ignoreWord] - Optional word(s) to leave unchanged in the output.
+* @returns {string} The kebab-case formatted string.
+*
+* @example
+* // Basic usage
+* toKebabCase("Hello World");
+* // ➔ "hello-world"
+*
+* @example
+* // Array input is joined before conversion
+* toKebabCase(["Join", "Words", "Here"]);
+* // ➔ "join-words-here"
+*
+* @example
+* // Handles underscores and hyphens
+* toKebabCase("convert_to-kebab case");
+* // ➔ "convert-to-kebab-case"
+*
+* @example
+* // Handles emojis and symbols
+* toKebabCase("🔥fire___and--ice❄️");
+* // ➔ "fire-and-ice"
+*
+* @example
+* // Ignore specific word
+* toKebabCase("ignore URL case", "URL");
+* // ➔ "ignore-URL-case"
+*
+* @example
+* // Ignore multiple words
+* toKebabCase("ignore API and URL", ["API", "URL"]);
+* // ➔ "ignore-API-and-URL"
+*
+* @example
+* // Ignore with Set
+* toKebabCase("ignore API and URL", new Set(["API", "URL"]));
+* // ➔ "ignore-API-and-URL"
+*
+* @example
+* // Null or empty input
+* toKebabCase(null);
+* // ➔ ""
+*/
+declare const toKebabCase:(input:StringLike,ignoreWord?:StringCollection)=>string;
+/** ----------------------------------------------------------
+* * ***Converts a string (or array of strings) into `snake_case`, with optionally leaving specific words unchanged.***
+* ----------------------------------------------------------
+*
+* @description
+* - Accepts a `string` or an array of `strings`:
+*   - If an array is provided, elements are trimmed, empty ones removed,
+*     then joined with `"-"` before conversion.
+* - Splits the input by non-alphanumeric characters
+*   (spaces, punctuation, symbols, hyphens, underscores, emojis, etc.).
+* - The first word is fully lowercase; subsequent words are capitalized.
+* - Words listed in `ignoreWord` remain unchanged in the output.
+* - `ignoreWord` is normalized (trimmed, delimiters removed); empty values ignored.
+* - `ignoreWord` accepts:
+*   - a single string,
+*   - an array of strings, or
+*   - a `Set` of strings.
+* - Multiple delimiters collapse into one; empty segments ignored.
+* - Returns `""` if the input is `null`, `undefined`, or empty.
+*
+* @param {StringLike} input - The string or array to convert. Returns `""` if empty, `null`, or `undefined`.
+* @param {StringCollection} [ignoreWord] - Optional word(s) to leave unchanged in the output.
+* @returns {string} The snake_case formatted string.
+*
+* @example
+* // Basic usage
+* toSnakeCase("Hello World");
+* // ➔ "hello_world"
+*
+* @example
+* // Array input is joined before conversion
+* toSnakeCase(["Join", "Words", "Here"]);
+* // ➔ "join_words_here"
+*
+* @example
+* // Handles underscores, hyphens, spaces
+* toSnakeCase("convert-to_snake case");
+* // ➔ "convert_to_snake_case"
+*
+* @example
+* // Handles emojis and symbols
+* toSnakeCase("🔥fire___and--ice❄️");
+* // ➔ "fire_and_ice"
+*
+* @example
+* // Ignore specific word
+* toSnakeCase("ignore URL case", "URL");
+* // ➔ "ignore_URL_case"
+*
+* @example
+* // Ignore multiple words
+* toSnakeCase("ignore API and URL", ["API", "URL"]);
+* // ➔ "ignore_API_and_URL"
+*
+* @example
+* // Ignore with Set
+* toSnakeCase("ignore API and URL", new Set(["API", "URL"]));
+* // ➔ "ignore_API_and_URL"
+*
+* @example
+* // Null or empty input
+* toSnakeCase(null);
+* // ➔ ""
+*/
+declare const toSnakeCase:(input:StringLike,ignoreWord?:StringCollection)=>string;
+/** ----------------------------------------------------------
+* * ***Converts a string (or array of strings) into `dot.case`, with optionally leaving specific words unchanged.***
+* ----------------------------------------------------------
+*
+* @description
+* - Accepts a `string` or an array of `strings`:
+*   - If an array is provided, elements are trimmed, empty ones removed,
+*     then joined with `"-"` before conversion.
+* - Splits the input by non-alphanumeric characters
+*   (spaces, punctuation, symbols, hyphens, underscores, emojis, etc.).
+* - The first word is fully lowercase; subsequent words are capitalized.
+* - Words listed in `ignoreWord` remain unchanged in the output.
+* - `ignoreWord` is normalized (trimmed, delimiters removed); empty values ignored.
+* - `ignoreWord` accepts:
+*   - a single string,
+*   - an array of strings, or
+*   - a `Set` of strings.
+* - Multiple delimiters collapse into one; empty segments ignored.
+* - Returns `""` if the input is `null`, `undefined`, or empty.
+*
+* @param {StringLike} input - The string or array to convert. Returns `""` if empty, `null`, or `undefined`.
+* @param {StringCollection} [ignoreWord] - Optional word(s) to leave unchanged in the output.
+* @returns {string} The dot.case formatted string.
+*
+* @example
+* // Basic usage
+* toDotCase("Hello World");
+* // ➔ "hello.world"
+*
+* @example
+* // Array input is joined before conversion
+* toDotCase(["Join", "Words", "Here"]);
+* // ➔ "join.words.here"
+*
+* @example
+* // Handles underscores and hyphens
+* toDotCase("convert-to_dot case");
+* // ➔ "convert.to.dot.case"
+*
+* @example
+* // Multiple delimiters and trimming
+* toDotCase("___Hello--World__ again!!");
+* // ➔ "hello.world.again"
+*
+* @example
+* // Supports emojis and symbols
+* toDotCase("🔥Fire_and-ice❄️");
+* // ➔ "fire.and.ice"
+*
+* @example
+* // Ignore single word
+* toDotCase("this URL path", "URL");
+* // ➔ "this.URL.path"
+*
+* @example
+* // Ignore multiple words
+* toDotCase("ignore API and URL", ["API", "URL"]);
+* // ➔ "ignore.API.and.URL"
+*
+* @example
+* // Ignore using Set
+* toDotCase("ignore API and URL", new Set(["API", "URL"]));
+* // ➔ "ignore.API.and.URL"
+*
+* @example
+* // Null or empty returns empty string
+* toDotCase(undefined);
+* // ➔ ""
+*/
+declare const toDotCase:(input:StringLike,ignoreWord?:StringCollection)=>string;
+/** ----------------------------------------------------------
+* * ***Slugifies a string (or array of strings) for safe use in URLs, with optionally leaving specific words unchanged.***
+* ----------------------------------------------------------
+*
+* @description
+* - Accepts a `string` or an array of `strings`:
+*   - If an array is provided, elements are trimmed, empty ones removed,
+*     then joined with `"-"` before conversion.
+* - Splits the input by non-alphanumeric characters
+*   (spaces, punctuation, symbols, hyphens, underscores, emojis, etc.).
+* - The first word is fully lowercase; subsequent words are capitalized.
+* - Words listed in `ignoreWord` remain unchanged in the output.
+* - `ignoreWord` is normalized (trimmed, delimiters removed); empty values ignored.
+* - `ignoreWord` accepts:
+*   - a single string,
+*   - an array of strings, or
+*   - a `Set` of strings.
+* - Multiple delimiters collapse into one; empty segments ignored.
+* - Returns `""` if the input is `null`, `undefined`, or empty.
+*
+* @param {StringLike} input - The string or array to convert. Returns `""` if empty, `null`, or `undefined`.
+* @param {StringCollection} [ignoreWord] - Optional word(s) to leave unchanged in the output.
+* @returns {string} The slugified string.
+*
+* @example
+* // Basic usage
+* slugify("Hello World!");
+* // ➔ "hello-world"
+*
+* @example
+* // Array input is joined before conversion
+* slugify(["Join", "Words", "Here"]);
+* // ➔ "join-words-here"
+*
+* @example
+* // Trims and cleans input
+* slugify(" --- Convert to Slug? --- ");
+* // ➔ "convert-to-slug"
+*
+* @example
+* // Ignore single word
+* slugify("This URL path", "URL");
+* // ➔ "this-URL-path"
+*
+* @example
+* // Ignore multiple words
+* slugify("ignore API and URL", ["API", "URL"]);
+* // ➔ "ignore-API-and-URL"
+*
+* @example
+* // Ignore using Set
+* slugify("ignore API and URL", new Set(["API", "URL"]));
+* // ➔ "ignore-API-and-URL"
+*
+* @example
+* // Supports emojis and symbols
+* slugify("🔥 Fire_and_ice ❄️");
+* // ➔ "fire-and-ice"
+*
+* @example
+* // Null or empty returns empty string
+* slugify(undefined);
+* // ➔ ""
+*/
+declare const slugify:(input:StringLike,ignoreWord?:StringCollection)=>string;
+/** ----------------------------------------------------------
+* * ***Normalizes whitespace in a string by reducing multiple spaces
+* to a single space, optionally trims, or only trims based on options.***
+* ----------------------------------------------------------
+*
+* - ✅ Collapses all consecutive whitespace (spaces, tabs, newlines) into a single space.
+* - ✅ Can trim leading/trailing spaces (default behavior), or preserve them with `withTrim: false`.
+* - ✅ Can skip normalization entirely and only trim using `trimOnly: true`.
+* - ✅ Returns an empty string if input is `null` or `undefined`.
+*
+* @param {string} [value] - The input string to be processed. If `null` or `undefined`, returns an empty string.
+* @param {object} [options] - Configuration options.
+* @param {boolean} [options.trimOnly=false] - If `true`, skips normalization and only trims the string.
+* @param {boolean} [options.withTrim=true] - If `false`, preserves leading/trailing whitespace.
+*
+* @returns {string} The processed string.
+*
+* @example
+* normalizeSpaces("   Hello    World\tthis   is\n\nok ");
+* // ➔ "Hello World this is ok"
+*
+* normalizeSpaces("   Hello    World\tthis   is\n\nok ", { trimOnly: true });
+* // ➔ "Hello    World	this   is\n\nok"
+*
+* normalizeSpaces("   Hello    World   ", { withTrim: false });
+* // ➔ " Hello World "
+*
+* normalizeSpaces(null);
+* // ➔ ""
+*/
+declare const normalizeSpaces:(value?:string|null,options?:{
+/**
+* If `true`, skips normalization and only trims whitespace from start & end.
+* @default false */
+trimOnly?:boolean;
+/**
+* If `false`, skips trimming value.
+* @default true */
+withTrim?:boolean;})=>string;
+/** ----------------------------------------------------------
+* * ***Normalizes a string by ensuring it is a valid string and trimming whitespace.***
+* ----------------------------------------------------------
+*
+* @description
+* If the input is `undefined`, `null`, or an `empty string` after trimming,
+* it returns an empty string `("")`.
+*
+* @param {string | undefined | null} input - The input string to be normalize. If `null` or `undefined`, returns an empty string.
+* @returns {string} A trimmed string or an empty string if the input is invalid.
+*
+* @example
+* normalizeString("   Hello World   ");
+* // ➔ "Hello World"
+* normalizeString("   Hello    World   ");
+* // ➔ "Hello    World"
+* normalizeString("");
+* // ➔ ""
+* normalizeString(null);
+* // ➔ ""
+* normalizeString(undefined);
+* // ➔ ""
+*/
+declare const normalizeString:(input?:string|null)=>string;
+/** ----------------------------------------------------------
+* * ***Removes all spaces from a string or trims only, based on the options provided.***
+* ----------------------------------------------------------
+*
+* @description
+* - If `trimOnly` is `true`, the string is simply trimmed.
+* - Otherwise, removes **all spaces**, tabs, newlines, etc.
+* - If the input is `null` or `undefined`, returns an empty string `("")`.
+*
+* @param {string | null | undefined} value - The input string to be processed. If `null` or `undefined`, returns an empty string.
+* @param {object} [options] - The options object.
+* @param {boolean} [options.trimOnly=false] - If `true`, only trims the string without removing spaces inside.
+* @returns {string} The processed string.
+*
+* @example
+* removeSpaces("  Hello   World  ");
+* // ➔ "HelloWorld"
+*
+* removeSpaces("  Hello   World  ", { trimOnly: true });
+* // ➔ "Hello   World"
+*
+* removeSpaces(null);
+* // ➔ ""
+*/
+declare const removeSpaces:(value?:string|null,options?:{
+/**
+* @description If true, only trims the string.
+*
+* @default false */
+trimOnly?:boolean;})=>string;
+/** ----------------------------------------------------------
+* * ***Removes all HTML tags from a given string.***
+* ----------------------------------------------------------
+*
+* This function removes valid HTML tags (including nested and self-closing ones)
+* by replacing them with spaces, then collapses multiple whitespaces into a single space.
+*
+* It handles the following cases:
+* - If the input is not a string (`null`, `undefined`, or any non-string), it is returned as undefined.
+* - If the input is an empty or whitespace-only string, it returns an empty string (`""`).
+* - Otherwise, it returns the cleaned string with tags removed and normalized whitespace.
+*
+* @template T - Input string type (string | null | undefined).
+* @param {T} [input] - A string potentially containing HTML tags.
+* @returns {T extends string ? string : T} - Cleaned string if input is string, or original input otherwise.
+*
+* @example
+* stripHtmlTags("<p>Hello</p>");
+* // ➔ "Hello"
+* stripHtmlTags("<div><b>Bold</b> text</div>");
+* // ➔ "Bold text"
+* stripHtmlTags("Line<br/>Break");
+* // ➔ "Line Break"
+* stripHtmlTags("2 < 5 and 5 > 2");
+* // ➔ "2 < 5 and 5 > 2"
+* stripHtmlTags("");
+* // ➔ ""
+* stripHtmlTags("   ");
+* // ➔ ""
+* stripHtmlTags(null);
+* // ➔ undefined
+* stripHtmlTags(undefined);
+* // ➔ undefined
+*/
+declare const stripHtmlTags:<T extends string|null|undefined=undefined>(input?:T)=>T extends string?string:undefined;
+/** ----------------------------------------------------------
+* * ***Replaces a substring at a specified index within a string.***
+* ----------------------------------------------------------
+*
+* @description
+* Replaces exactly one character at the specified index in the original string
+* with the provided `replaceTo` string. If `replaceTo` has more than one character,
+* the result will expand accordingly.
+*
+* @param {number} index - The starting index where the replacement should occur.
+* @param {string} originalString - The original string to modify.
+* @param {string} replaceTo - The string to insert at the specified index.
+* @returns {string} - The modified string with the replacement applied.
+*
+* @example
+* replaceAt(3, "hello", "X");
+* // ➔ "helXo"
+*
+* replaceAt(1, "world", "AB");
+* // ➔ "wABrld"
+*
+* replaceAt(0, "cat", "br");
+* // ➔ "brat"
+*
+* replaceAt(2, "12345", "-");
+* // ➔ "12-45"
+*
+* replaceAt(4, "ABCDE", "Z");
+* // ➔ "ABCDZ"
+*
+* // ❌ Examples that throw:
+* replaceAt(10, "short", "X");
+* // ➔ ❌ RangeError: Index parameter is out of range at function `replaceAt`
+*
+* replaceAt(-1, "test", "X");
+* // ➔ ❌ RangeError: Index parameter is out of range at function `replaceAt`
+*
+* replaceAt("1", "test", "X");
+* // ➔ ❌ TypeError: Expected 'index' to be a number, and 'replaceTo' and 'originalString' to be strings
+*
+* replaceAt(2, null, "X");
+* // ➔ ❌ TypeError: Expected 'index' to be a number, and 'replaceTo' and 'originalString' to be strings
+*/
+declare const replaceAt:(index:number,originalString:string,replaceTo:string)=>string;
+/** ----------------------------------------------------------
+* * ***Extracts initials from a given name.***
+* ----------------------------------------------------------
+*
+* @description
+* Extracts initials from the given name string.
+* - For names with two or more words, returns the first letter of the first and second words.
+* - For a single word with 2+ characters, returns the first two letters.
+* - For a single character, returns that character.
+* - For empty, null, or whitespace-only input, returns an empty string.
+*
+* @param {string} [name=""] - The name to extract initials from.
+* @returns {string} The extracted initials (e.g., "JD" for "John Doe").
+*
+* @example
+* getInitialsName("Alice");             // ➔ "AL"
+* getInitialsName("John Doe");          // ➔ "JD"
+* getInitialsName(" Bob Marley ");      // ➔ "BM"
+* getInitialsName("John Ronald Donal"); // ➔ "JR"
+* getInitialsName("Lord John Doe Moe"); // ➔ "LJ"
+* getInitialsName("X");                 // ➔ "X"
+* getInitialsName("  ");                // ➔ "" (empty string)
+* getInitialsName("");                  // ➔ "" (empty string)
+* getInitialsName(null);                // ➔ "" (null input)
+* getInitialsName(undefined);           // ➔ "" (undefined input)
+*/
+declare const getInitialsName:(name?:string|null)=>string;export{capitalizeFirst,capitalizeWords,getInitialsName,normalizeSpaces,normalizeString,removeSpaces,replaceAt,slugify,stripHtmlTags,toCamelCase,toDotCase,toKebabCase,toLowerCase,toPascalCase,toPascalCaseSpace,toSnakeCase};