@rzl-zone/utils-js 3.2.6-beta.0 → 3.3.0

package/dist/strings/index.d.ts

@@ -1,7 +1,7 @@
-import{c as Nilable}from'../nils-DMz3kU7M.js';import{E as Extends}from'../extends-Bk_SBGdT.js';import'../if-CvT4R7Kh.js';import'../never-BfayMBF9.js';type CapitalizeFirstOptions={
+import{c as Nilable}from'../nils-CO8zLHSB.js';import{E as Extends}from'../extends-DtdRjDyU.js';import'../if-ChM35c_q.js';import'../never-D89PbPh5.js';type CapitalizeFirstOptions={
 /** If true **(default)**, the rest of the string will be converted to lowercase after capitalizing the first letter.
  *
- *  @default true
+ * @default true
  */
 lowerCaseNextRest?:boolean;
 /** If true, the string will trimmed, default: `false`.
@@ -20,20 +20,20 @@ trim?:boolean;};
  * @returns {string} The processed string, returns `""` if input is `null`, `undefined`, or `not a valid string`.
  * @example
  * ```ts
- * capitalizeFirst(" hello WORLD ")
+ * capitalizeFirst(" hello WORLD ");
  * // ➔ " Hello world"
- * capitalizeFirst(" hello WORLD ", { trim: true })
+ * capitalizeFirst(" hello WORLD ", { trim: true });
  * // ➔ "Hello world"
- * capitalizeFirst("FOO", { lowerCaseNextRest: false })
+ * capitalizeFirst("FOO", { lowerCaseNextRest: false });
  * // ➔ "FOO"
- * capitalizeFirst("   foo BAR   ", { trim: true, lowerCaseNextRest: false })
+ * capitalizeFirst("   foo BAR   ", { trim: true, lowerCaseNextRest: false });
  * // ➔ "Foo BAR"
  * ```
  * #### ℹ️ If null, undefined, or not a valid string input, return `""`.
  * ```ts
- * capitalizeFirst(123)
- * capitalizeFirst(null)
- * capitalizeFirst(undefined)
+ * capitalizeFirst(123);
+ * capitalizeFirst(null);
+ * capitalizeFirst(undefined);
  * // ➔ ""
  * ```
  */
@@ -53,10 +53,10 @@ collapseSpaces?:boolean;};
  * ----------------------------------------------------------
  * **Capitalizes the first letter of each word in a string while converting the rest to lowercase.**
  * @param {string | null | undefined} value
- *  The input string to be processed.
+ *  ***The input string to be processed.***
  *   - If `null` or `undefined`, returns an empty-string (`""`).
  * @param {CapitalizeWordsOptions} [options]
- *  Optional settings to control the output:
+ *  ***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 {string} A new string where each word starts with an uppercase letter
@@ -85,28 +85,83 @@ declare const capitalizeWords:(value:string|null|undefined,options?:CapitalizeWo
 /** --------------------------------------------------
  * * ***Represents a string input.***
  * --------------------------------------------------
- *
  * - **Can be one of:**
  *    - A single `string`
  *    - An array of strings (`string[]`)
  *    - A readonly array of strings (`readonly string[]`)
  *    - `null` or `undefined`
- *
  * @template T - A string or array of strings.
+ * @private ***types input for {@link toCamelCase}, {@link toPascalCaseSpace}, {@link toPascalCase}, {@link toLowerCase}, {@link toKebabCase}, {@link toSnakeCase}, {@link toDotCase} and {@link slugify}.***
  */
 type StringLike=Nilable<string|string[]|ReadonlyArray<string>>;
 /** --------------------------------------------------
  * * ***Represents a collection of strings.***
  * --------------------------------------------------
- *
  * - **Can be one of:**
  *    - A single `string`
  *    - An array of strings (`string[]`)
  *    - A readonly array of strings (`readonly string[]`)
  *    - A `Set<string>`
  *    - A `ReadonlySet<string>`
+ * @private ***types options for {@link toCamelCase}, {@link toPascalCaseSpace}, {@link toPascalCase}, {@link toLowerCase}, {@link toKebabCase}, {@link toSnakeCase}, {@link toDotCase} and {@link slugify}.***
  */
 type StringCollection=string|string[]|ReadonlyArray<string>|Set<string>|ReadonlySet<string>;
+/** ----------------------------------------------------------
+ * * ***Utility: `slugify`.***
+ * ----------------------------------------------------------
+ * **Slugifies a string (or array of strings) for safe use in URLs, with optionally leaving specific words unchanged.**
+ * - **Behavior:**
+ *    - 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"
+ *
+ * // Array input is joined before conversion
+ * slugify(["Join", "Words", "Here"]);
+ * // ➔ "join-words-here"
+ *
+ * // Trims and cleans input
+ * slugify(" --- Convert to Slug? --- ");
+ * // ➔ "convert-to-slug"
+ *
+ * // Ignore single word
+ * slugify("This URL path", "URL");
+ * // ➔ "this-URL-path"
+ *
+ * // Ignore multiple words
+ * slugify("ignore API and URL", ["API", "URL"]);
+ * // ➔ "ignore-API-and-URL"
+ *
+ * // Ignore using Set
+ * slugify("ignore API and URL", new Set(["API", "URL"]));
+ * // ➔ "ignore-API-and-URL"
+ *
+ * // Supports emojis and symbols
+ * slugify("🔥 Fire_and_ice ❄️");
+ * // ➔ "fire-and-ice"
+ *
+ * // Null, Undefined or empty (string or array) input returns empty string
+ * slugify(undefined);
+ * // ➔ ""
+ */
+declare const slugify:(input:StringLike,ignoreWord?:StringCollection)=>string;
 /** ----------------------------------------------------------
  * * ***Utility: `toCamelCase`.***
  * ----------------------------------------------------------
@@ -160,9 +215,9 @@ type StringCollection=string|string[]|ReadonlyArray<string>|Set<string>|Readonly
  */
 declare const toCamelCase:(input:StringLike,ignoreWord?:StringCollection)=>string;
 /** ----------------------------------------------------------
- * * ***Utility: `toPascalCaseSpace`.***
+ * * ***Utility: `toDotCase`.***
  * ----------------------------------------------------------
- * **Converts a string (or array of strings) into `PascalCaseSpace`, with optionally leaving specific words unchanged.**
+ * **Converts a string (or array of strings) into `dot.case`, with optionally leaving specific words unchanged.**
  * - **Behavior:**
  *    - Accepts a `string` or an `array of strings`:
  *      - If an array is provided, elements are trimmed, empty ones removed,
@@ -180,49 +235,49 @@ declare const toCamelCase:(input:StringLike,ignoreWord?:StringCollection)=>strin
  *    - 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.
+ * @returns {string} The dot.case formatted string.
  * @example
  * // Basic usage
- * toPascalCaseSpace("hello world");
- * // ➔ "Hello World"
+ * toDotCase("Hello World");
+ * // ➔ "hello.world"
  *
  * // Array input is joined before conversion
- * toPascalCaseSpace(["Join", "Words", "Here"]);
- * // ➔ "Join Words Here"
+ * toDotCase(["Join", "Words", "Here"]);
+ * // ➔ "join.words.here"
  *
  * // Handles underscores and hyphens
- * toPascalCaseSpace("convert_to-pascal case");
- * // ➔ "Convert To Pascal Case Space"
+ * toDotCase("convert-to_dot case");
+ * // ➔ "convert.to.dot.case"
  *
- * // Trims extra delimiters
- * toPascalCaseSpace("___hello--world__ again!!");
- * // ➔ "Hello World Again"
+ * // Multiple delimiters and trimming
+ * toDotCase("___Hello--World__ again!!");
+ * // ➔ "hello.world.again"
  *
  * // Supports emojis and symbols
- * toPascalCaseSpace("🔥fire_and-ice❄️");
- * // ➔ "Fire And Ice"
+ * toDotCase("🔥Fire_and-ice❄️");
+ * // ➔ "fire.and.ice"
  *
  * // Ignore single word
- * toPascalCaseSpace("this URL path will ignore", "URL");
- * // ➔ "This URL Path Will Ignore"
+ * toDotCase("this URL path", "URL");
+ * // ➔ "this.URL.path"
  *
  * // Ignore multiple words
- * toPascalCaseSpace("ignore API and URL", ["API", "URL"]);
- * // ➔ "Ignore API And URL"
+ * toDotCase("ignore API and URL", ["API", "URL"]);
+ * // ➔ "ignore.API.and.URL"
  *
  * // Ignore using Set
- * toPascalCaseSpace("ignore API and URL", new Set(["API", "URL"]));
- * // ➔ "Ignore API And URL"
+ * toDotCase("ignore API and URL", new Set(["API", "URL"]));
+ * // ➔ "ignore.API.and.URL"
  *
  * // Null, Undefined or empty (string or array) input returns empty string
- * toPascalCaseSpace(undefined);
+ * toDotCase(undefined);
  * // ➔ ""
  */
-declare const toPascalCaseSpace:(input:StringLike,ignoreWord?:StringCollection)=>string;
+declare const toDotCase:(input:StringLike,ignoreWord?:StringCollection)=>string;
 /** ----------------------------------------------------------
- * * ***Utility: `toPascalCase`.***
+ * * ***Utility: `toKebabCase`.***
  * ----------------------------------------------------------
- * **Converts a string (or array of strings) into `PascalCase`, with optionally leaving specific words unchanged.**
+ * **Converts a string (or array of strings) into `kebab-case`, with optionally leaving specific words unchanged.**
  * - **Behavior:**
  *    - Accepts a `string` or an `array of strings`:
  *      - If an array is provided, elements are trimmed, empty ones removed,
@@ -240,45 +295,41 @@ declare const toPascalCaseSpace:(input:StringLike,ignoreWord?:StringCollection)=
  *    - 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.
+ * @returns {string} The kebab-case formatted string.
  * @example
  * // Basic usage
- * toPascalCase("hello world");
- * // ➔ "HelloWorld"
+ * toKebabCase("Hello World");
+ * // ➔ "hello-world"
  *
  * // Array input is joined before conversion
- * toPascalCase(["Join", "Words", "Here"]);
- * // ➔ "JoinWordsHere"
+ * toKebabCase(["Join", "Words", "Here"]);
+ * // ➔ "join-words-here"
  *
  * // Handles underscores and hyphens
- * toPascalCase("convert_to-pascal case");
- * // ➔ "ConvertToPascalCase"
- *
- * // Trims extra delimiters
- * toPascalCase("___hello--world__ again!!");
- * // ➔ "HelloWorldAgain"
+ * toKebabCase("convert_to-kebab case");
+ * // ➔ "convert-to-kebab-case"
  *
- * // Supports emojis and symbols
- * toPascalCase("🔥fire_and-ice❄️");
- * // ➔ "FireAndIce"
+ * // Handles emojis and symbols
+ * toKebabCase("🔥fire___and--ice❄️");
+ * // ➔ "fire-and-ice"
  *
- * // Ignore single word
- * toPascalCase("this URL path will ignore", "URL");
- * // ➔ "ThisURLPathWillIgnore"
+ * // Ignore specific word
+ * toKebabCase("ignore URL case", "URL");
+ * // ➔ "ignore-URL-case"
  *
  * // Ignore multiple words
- * toPascalCase("ignore API and URL", ["API", "URL"]);
- * // ➔ "IgnoreAPIAndURL"
+ * toKebabCase("ignore API and URL", ["API", "URL"]);
+ * // ➔ "ignore-API-and-URL"
  *
- * // Ignore using Set
- * toPascalCase("ignore API and URL", new Set(["API", "URL"]));
- * // ➔ "IgnoreAPIAndURL"
+ * // Ignore with Set
+ * toKebabCase("ignore API and URL", new Set(["API", "URL"]));
+ * // ➔ "ignore-API-and-URL"
  *
  * // Null, Undefined or empty (string or array) input returns empty string
- * toPascalCase(undefined);
+ * toKebabCase(null);
  * // ➔ ""
  */
-declare const toPascalCase:(input:StringLike,ignoreWord?:StringCollection)=>string;
+declare const toKebabCase:(input:StringLike,ignoreWord?:StringCollection)=>string;
 /** ----------------------------------------------------------
  * * ***Utility: `toLowerCase`.***
  * ----------------------------------------------------------
@@ -340,9 +391,9 @@ declare const toPascalCase:(input:StringLike,ignoreWord?:StringCollection)=>stri
  */
 declare const toLowerCase:(input:StringLike,ignoreWord?:StringCollection)=>string;
 /** ----------------------------------------------------------
- * * ***Utility: `toKebabCase`.***
+ * * ***Utility: `toPascalCase`.***
  * ----------------------------------------------------------
- * **Converts a string (or array of strings) into `kebab-case`, with optionally leaving specific words unchanged.**
+ * **Converts a string (or array of strings) into `PascalCase`, with optionally leaving specific words unchanged.**
  * - **Behavior:**
  *    - Accepts a `string` or an `array of strings`:
  *      - If an array is provided, elements are trimmed, empty ones removed,
@@ -360,101 +411,49 @@ declare const toLowerCase:(input:StringLike,ignoreWord?:StringCollection)=>strin
  *    - 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.
+ * @returns {string} The PascalCase formatted string.
  * @example
  * // Basic usage
- * toKebabCase("Hello World");
- * // ➔ "hello-world"
+ * toPascalCase("hello world");
+ * // ➔ "HelloWorld"
  *
  * // Array input is joined before conversion
- * toKebabCase(["Join", "Words", "Here"]);
- * // ➔ "join-words-here"
+ * toPascalCase(["Join", "Words", "Here"]);
+ * // ➔ "JoinWordsHere"
  *
  * // Handles underscores and hyphens
- * toKebabCase("convert_to-kebab case");
- * // ➔ "convert-to-kebab-case"
- *
- * // Handles emojis and symbols
- * toKebabCase("🔥fire___and--ice❄️");
- * // ➔ "fire-and-ice"
- *
- * // Ignore specific word
- * toKebabCase("ignore URL case", "URL");
- * // ➔ "ignore-URL-case"
- *
- * // Ignore multiple words
- * toKebabCase("ignore API and URL", ["API", "URL"]);
- * // ➔ "ignore-API-and-URL"
- *
- * // Ignore with Set
- * toKebabCase("ignore API and URL", new Set(["API", "URL"]));
- * // ➔ "ignore-API-and-URL"
- *
- * // Null, Undefined or empty (string or array) input returns empty string
- * toKebabCase(null);
- * // ➔ ""
- */
-declare const toKebabCase:(input:StringLike,ignoreWord?:StringCollection)=>string;
-/** ----------------------------------------------------------
- * * ***Utility: `toSnakeCase`.***
- * ----------------------------------------------------------
- * **Converts a string (or array of strings) into `snake_case`, with optionally leaving specific words unchanged.**
- * - **Behavior:**
- *    - 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"
- *
- * // Array input is joined before conversion
- * toSnakeCase(["Join", "Words", "Here"]);
- * // ➔ "join_words_here"
+ * toPascalCase("convert_to-pascal case");
+ * // ➔ "ConvertToPascalCase"
  *
- * // Handles underscores, hyphens, spaces
- * toSnakeCase("convert-to_snake case");
- * // ➔ "convert_to_snake_case"
+ * // Trims extra delimiters
+ * toPascalCase("___hello--world__ again!!");
+ * // ➔ "HelloWorldAgain"
  *
- * // Handles emojis and symbols
- * toSnakeCase("🔥fire___and--ice❄️");
- * // ➔ "fire_and_ice"
+ * // Supports emojis and symbols
+ * toPascalCase("🔥fire_and-ice❄️");
+ * // ➔ "FireAndIce"
  *
- * // Ignore specific word
- * toSnakeCase("ignore URL case", "URL");
- * // ➔ "ignore_URL_case"
+ * // Ignore single word
+ * toPascalCase("this URL path will ignore", "URL");
+ * // ➔ "ThisURLPathWillIgnore"
  *
  * // Ignore multiple words
- * toSnakeCase("ignore API and URL", ["API", "URL"]);
- * // ➔ "ignore_API_and_URL"
+ * toPascalCase("ignore API and URL", ["API", "URL"]);
+ * // ➔ "IgnoreAPIAndURL"
  *
- * // Ignore with Set
- * toSnakeCase("ignore API and URL", new Set(["API", "URL"]));
- * // ➔ "ignore_API_and_URL"
+ * // Ignore using Set
+ * toPascalCase("ignore API and URL", new Set(["API", "URL"]));
+ * // ➔ "IgnoreAPIAndURL"
  *
  * // Null, Undefined or empty (string or array) input returns empty string
- * toSnakeCase(null);
+ * toPascalCase(undefined);
  * // ➔ ""
  */
-declare const toSnakeCase:(input:StringLike,ignoreWord?:StringCollection)=>string;
+declare const toPascalCase:(input:StringLike,ignoreWord?:StringCollection)=>string;
 /** ----------------------------------------------------------
- * * ***Utility: `toDotCase`.***
+ * * ***Utility: `toPascalCaseSpace`.***
  * ----------------------------------------------------------
- * **Converts a string (or array of strings) into `dot.case`, with optionally leaving specific words unchanged.**
+ * **Converts a string (or array of strings) into `PascalCaseSpace`, with optionally leaving specific words unchanged.**
  * - **Behavior:**
  *    - Accepts a `string` or an `array of strings`:
  *      - If an array is provided, elements are trimmed, empty ones removed,
@@ -472,49 +471,49 @@ declare const toSnakeCase:(input:StringLike,ignoreWord?:StringCollection)=>strin
  *    - 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.
+ * @returns {string} The PascalCaseSpace formatted string.
  * @example
  * // Basic usage
- * toDotCase("Hello World");
- * // ➔ "hello.world"
+ * toPascalCaseSpace("hello world");
+ * // ➔ "Hello World"
  *
  * // Array input is joined before conversion
- * toDotCase(["Join", "Words", "Here"]);
- * // ➔ "join.words.here"
+ * toPascalCaseSpace(["Join", "Words", "Here"]);
+ * // ➔ "Join Words Here"
  *
  * // Handles underscores and hyphens
- * toDotCase("convert-to_dot case");
- * // ➔ "convert.to.dot.case"
+ * toPascalCaseSpace("convert_to-pascal case");
+ * // ➔ "Convert To Pascal Case Space"
  *
- * // Multiple delimiters and trimming
- * toDotCase("___Hello--World__ again!!");
- * // ➔ "hello.world.again"
+ * // Trims extra delimiters
+ * toPascalCaseSpace("___hello--world__ again!!");
+ * // ➔ "Hello World Again"
  *
  * // Supports emojis and symbols
- * toDotCase("🔥Fire_and-ice❄️");
- * // ➔ "fire.and.ice"
+ * toPascalCaseSpace("🔥fire_and-ice❄️");
+ * // ➔ "Fire And Ice"
  *
  * // Ignore single word
- * toDotCase("this URL path", "URL");
- * // ➔ "this.URL.path"
+ * toPascalCaseSpace("this URL path will ignore", "URL");
+ * // ➔ "This URL Path Will Ignore"
  *
  * // Ignore multiple words
- * toDotCase("ignore API and URL", ["API", "URL"]);
- * // ➔ "ignore.API.and.URL"
+ * toPascalCaseSpace("ignore API and URL", ["API", "URL"]);
+ * // ➔ "Ignore API And URL"
  *
  * // Ignore using Set
- * toDotCase("ignore API and URL", new Set(["API", "URL"]));
- * // ➔ "ignore.API.and.URL"
+ * toPascalCaseSpace("ignore API and URL", new Set(["API", "URL"]));
+ * // ➔ "Ignore API And URL"
  *
  * // Null, Undefined or empty (string or array) input returns empty string
- * toDotCase(undefined);
+ * toPascalCaseSpace(undefined);
  * // ➔ ""
  */
-declare const toDotCase:(input:StringLike,ignoreWord?:StringCollection)=>string;
+declare const toPascalCaseSpace:(input:StringLike,ignoreWord?:StringCollection)=>string;
 /** ----------------------------------------------------------
- * * ***Utility: `slugify`.***
+ * * ***Utility: `toSnakeCase`.***
  * ----------------------------------------------------------
- * **Slugifies a string (or array of strings) for safe use in URLs, with optionally leaving specific words unchanged.**
+ * **Converts a string (or array of strings) into `snake_case`, with optionally leaving specific words unchanged.**
  * - **Behavior:**
  *    - Accepts a `string` or an `array of strings`:
  *      - If an array is provided, elements are trimmed, empty ones removed,
@@ -532,41 +531,41 @@ declare const toDotCase:(input:StringLike,ignoreWord?:StringCollection)=>string;
  *    - 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.
+ * @returns {string} The snake_case formatted string.
  * @example
  * // Basic usage
- * slugify("Hello World!");
- * // ➔ "hello-world"
+ * toSnakeCase("Hello World");
+ * // ➔ "hello_world"
  *
  * // Array input is joined before conversion
- * slugify(["Join", "Words", "Here"]);
- * // ➔ "join-words-here"
+ * toSnakeCase(["Join", "Words", "Here"]);
+ * // ➔ "join_words_here"
  *
- * // Trims and cleans input
- * slugify(" --- Convert to Slug? --- ");
- * // ➔ "convert-to-slug"
+ * // Handles underscores, hyphens, spaces
+ * toSnakeCase("convert-to_snake case");
+ * // ➔ "convert_to_snake_case"
  *
- * // Ignore single word
- * slugify("This URL path", "URL");
- * // ➔ "this-URL-path"
+ * // Handles emojis and symbols
+ * toSnakeCase("🔥fire___and--ice❄️");
+ * // ➔ "fire_and_ice"
  *
- * // Ignore multiple words
- * slugify("ignore API and URL", ["API", "URL"]);
- * // ➔ "ignore-API-and-URL"
+ * // Ignore specific word
+ * toSnakeCase("ignore URL case", "URL");
+ * // ➔ "ignore_URL_case"
  *
- * // Ignore using Set
- * slugify("ignore API and URL", new Set(["API", "URL"]));
- * // ➔ "ignore-API-and-URL"
+ * // Ignore multiple words
+ * toSnakeCase("ignore API and URL", ["API", "URL"]);
+ * // ➔ "ignore_API_and_URL"
  *
- * // Supports emojis and symbols
- * slugify("🔥 Fire_and_ice ❄️");
- * // ➔ "fire-and-ice"
+ * // Ignore with Set
+ * toSnakeCase("ignore API and URL", new Set(["API", "URL"]));
+ * // ➔ "ignore_API_and_URL"
  *
  * // Null, Undefined or empty (string or array) input returns empty string
- * slugify(undefined);
+ * toSnakeCase(null);
  * // ➔ ""
  */
-declare const slugify:(input:StringLike,ignoreWord?:StringCollection)=>string;type NormalizeSpacesOptions={
+declare const toSnakeCase:(input:StringLike,ignoreWord?:StringCollection)=>string;type NormalizeSpacesOptions={
 /** If `true`, skips normalization and only trims whitespace from start & end, defaultValue: `false`.
  *
  * @default false
@@ -681,6 +680,30 @@ declare const removeSpaces:(value:string|null|undefined,options?:RemoveSpacesOpt
  * // ➔ undefined
  */
 declare function stripHtmlTags(input:string):string;declare function stripHtmlTags<T>(input:T):Extends<string,T>extends true?string|undefined:undefined;
+/** ----------------------------------------------------------
+ * * ***Utility: `getInitialsName`.***
+ * ----------------------------------------------------------
+ * **Extracts initials from the given name string.**
+ * - **Behavior:**
+ *    - 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`, `undefined` or `whitespace-only input`, returns an empty string (`""`).
+ * @param {string | null | undefined} 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|undefined)=>string;
 /** ----------------------------------------------------------
  *  * ***Utility: `replaceAt`.***
  * ----------------------------------------------------------
@@ -714,28 +737,4 @@ declare function stripHtmlTags(input:string):string;declare function stripHtmlTa
  * replaceAt(2, null, "X");
  * // ➔ ❌ TypeError: First parameter `index` must be of type `number`, second parameter `originalString` and third parameter `replaceTo` must be of type `string`, but received: "['index': `string`,...]."
  */
-declare const replaceAt:(index:number,originalString:string,replaceTo:string)=>string;
-/** ----------------------------------------------------------
- * * ***Utility: `getInitialsName`.***
- * ----------------------------------------------------------
- * **Extracts initials from the given name string.**
- * - **Behavior:**
- *    - 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`, `undefined` or `whitespace-only input`, returns an empty string (`""`).
- * @param {string | null | undefined} 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|undefined)=>string;export{capitalizeFirst,capitalizeWords,getInitialsName,normalizeSpaces,normalizeString,removeSpaces,replaceAt,slugify,stripHtmlTags,toCamelCase,toDotCase,toKebabCase,toLowerCase,toPascalCase,toPascalCaseSpace,toSnakeCase};
+declare const replaceAt:(index:number,originalString:string,replaceTo:string)=>string;export{capitalizeFirst,capitalizeWords,getInitialsName,normalizeSpaces,normalizeString,removeSpaces,replaceAt,slugify,stripHtmlTags,toCamelCase,toDotCase,toKebabCase,toLowerCase,toPascalCase,toPascalCaseSpace,toSnakeCase};

package/dist/strings/index.js

@@ -1 +1 @@
-export{getInitialsName,replaceAt}from"../chunk-RV2WK5E6.js";export{normalizeSpaces,normalizeString,removeSpaces,stripHtmlTags}from"../chunk-MISCBZJC.js";import"../chunk-KOVO72OM.js";export{capitalizeFirst,capitalizeWords,slugify,toCamelCase,toDotCase,toKebabCase,toLowerCase,toPascalCase,toPascalCaseSpace,toSnakeCase}from"../chunk-EW3I4O7X.js";
+export{capitalizeFirst,capitalizeWords,getInitialsName,replaceAt,stripHtmlTags}from"../chunk-JEQEF5WD.js";export{normalizeString}from"../chunk-IZPBKKPO.js";export{normalizeSpaces}from"../chunk-T2T7K3KR.js";export{removeSpaces}from"../chunk-XEDXFSGI.js";import"../chunk-W2WNBUDE.js";export{slugify,toCamelCase,toDotCase,toKebabCase,toLowerCase,toPascalCase,toPascalCaseSpace,toSnakeCase}from"../chunk-CMW2TBOQ.js";

package/dist/tailwind/index.cjs

@@ -1 +1 @@
-"use strict";var e=require("../chunk-X74TUJSE.cjs");require("../chunk-VHAPTHEA.cjs"),require("../chunk-D3VSHABU.cjs"),Object.defineProperty(exports,"cnV3",{enumerable:!0,get:function(){return e.cnV3}}),Object.defineProperty(exports,"cnV4",{enumerable:!0,get:function(){return e.cnV4}}),Object.defineProperty(exports,"customCnV3",{enumerable:!0,get:function(){return e.customCnV3}}),Object.defineProperty(exports,"customCnV4",{enumerable:!0,get:function(){return e.customCnV4}}),Object.defineProperty(exports,"shouldForwardProp",{enumerable:!0,get:function(){return e.shouldForwardProp}}),Object.defineProperty(exports,"twMergeDefaultV3",{enumerable:!0,get:function(){return e.twMergeDefaultV3}}),Object.defineProperty(exports,"twMergeDefaultV4",{enumerable:!0,get:function(){return e.twMergeDefaultV4}});
+"use strict";var e=require("../chunk-YLA3DURS.cjs");require("../chunk-6JFZL7YE.cjs"),require("../chunk-PZQ6I4JJ.cjs"),Object.defineProperty(exports,"cnV3",{enumerable:!0,get:function(){return e.cnV3}}),Object.defineProperty(exports,"cnV4",{enumerable:!0,get:function(){return e.cnV4}}),Object.defineProperty(exports,"customCnV3",{enumerable:!0,get:function(){return e.customCnV3}}),Object.defineProperty(exports,"customCnV4",{enumerable:!0,get:function(){return e.customCnV4}}),Object.defineProperty(exports,"shouldForwardProp",{enumerable:!0,get:function(){return e.shouldForwardProp}}),Object.defineProperty(exports,"twMergeDefaultV3",{enumerable:!0,get:function(){return e.twMergeDefaultV3}}),Object.defineProperty(exports,"twMergeDefaultV4",{enumerable:!0,get:function(){return e.twMergeDefaultV4}});