@gzl10/ts-helpers 4.2.1

package/dist/cjs/strings.js

@@ -0,0 +1,253 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/strings.ts
+var strings_exports = {};
+__export(strings_exports, {
+  capitalizeEachWord: () => capitalizeEachWord,
+  capitalizeFirst: () => capitalizeFirst,
+  cleanJsonChars: () => cleanJsonChars,
+  contains: () => contains,
+  countOccurrences: () => countOccurrences,
+  endsWith: () => endsWith,
+  ensureEndsWith: () => ensureEndsWith,
+  ensureStartsWith: () => ensureStartsWith,
+  envKeyToPath: () => envKeyToPath,
+  escapeHtmlChars: () => escapeHtmlChars,
+  isEmail: () => isEmail,
+  isEmpty: () => isEmpty,
+  matchPathPattern: () => matchPathPattern,
+  padEnd: () => padEnd,
+  padStart: () => padStart,
+  pathToEnvKey: () => pathToEnvKey,
+  removeAccents: () => removeAccents,
+  repeatString: () => repeatString,
+  replaceAllOccurrences: () => replaceAllOccurrences,
+  reverseString: () => reverseString,
+  sanitizeString: () => sanitizeString,
+  startsWith: () => startsWith,
+  stripFromEnd: () => stripFromEnd,
+  stripFromStart: () => stripFromStart,
+  toCamelCase: () => toCamelCase,
+  toKebabCase: () => toKebabCase,
+  toLowerCase: () => toLowerCase,
+  toPascalCase: () => toPascalCase,
+  toSnakeCase: () => toSnakeCase,
+  toUpperCase: () => toUpperCase,
+  toUrlSlug: () => toUrlSlug,
+  trim: () => trim,
+  trimEnd: () => trimEnd,
+  trimStart: () => trimStart,
+  truncateString: () => truncateString,
+  unescapeHtmlChars: () => unescapeHtmlChars,
+  unescapeUnicode: () => unescapeUnicode
+});
+module.exports = __toCommonJS(strings_exports);
+var sanitizeString = (instr) => {
+  if (!instr) return "";
+  return addDash(instr.replace(/[^a-zA-Z0-9 ]/g, "")).toLowerCase();
+};
+function addDash(str) {
+  const str2 = str.replace(/[`~!@#$%^&*()_|+\-=?;:'",.<>{}[\]\\/]/gi, "");
+  return str2.replace(/ /g, "-");
+}
+var cleanJsonChars = (texto) => {
+  if (!texto) return "";
+  return texto.replace(/({|}|&amp;|amp;|gt;)/g, "");
+};
+var truncateString = (str, maxlength = 80, suffix = "...") => {
+  if (!str) return "";
+  return str.length > maxlength ? str.substring(0, maxlength) + suffix : str;
+};
+var unescapeUnicode = (input) => {
+  return JSON.stringify(JSON.parse(`"${input}"`)).replace(/^"(.*)"$/, "$1");
+};
+var ensureEndsWith = (str, trailing) => {
+  return str.endsWith(trailing) ? str : `${str}${trailing}`;
+};
+var stripFromEnd = (str, trailing) => {
+  return str.endsWith(trailing) ? str.slice(0, -1 * trailing.length) : str;
+};
+var ensureStartsWith = (str, leading) => {
+  return str.startsWith(leading) ? str : `${leading}${str}`;
+};
+var stripFromStart = (str, leading) => {
+  return str.startsWith(leading) ? str.slice(leading.length) : str;
+};
+var toLowerCase = (str) => {
+  return str.toLowerCase();
+};
+var toUpperCase = (str) => {
+  return str.toUpperCase();
+};
+var capitalizeFirst = (str) => {
+  if (!str) return "";
+  return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
+};
+var capitalizeEachWord = (str) => {
+  if (!str) return "";
+  return str.split(" ").map((word) => capitalizeFirst(word)).join(" ");
+};
+var toCamelCase = (str) => {
+  if (!str) return "";
+  const words = str.replace(/([a-z])([A-Z])/g, "$1 $2").split(/[-_\s]+/).filter((word) => word.length > 0).map((word) => word.toLowerCase());
+  if (words.length === 0) return "";
+  return words[0] + words.slice(1).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
+};
+var toSnakeCase = (str) => {
+  if (!str) return "";
+  return str.replace(/\W+/g, " ").split(/ |\B(?=[A-Z])/).map((word) => word.toLowerCase()).join("_");
+};
+var toKebabCase = (str) => {
+  if (!str) return "";
+  return str.replace(/[_\s]+/g, "-").replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+};
+var toPascalCase = (str) => {
+  if (!str) return "";
+  return str.replace(/[-_\s]+(.)?/g, (_, char) => char ? char.toUpperCase() : "").replace(/^./, (char) => char.toUpperCase());
+};
+var contains = (str, searchStr, caseSensitive = false) => {
+  if (caseSensitive) {
+    return str.includes(searchStr);
+  }
+  return str.toLowerCase().includes(searchStr.toLowerCase());
+};
+var startsWith = (str, searchStr, caseSensitive = false) => {
+  if (caseSensitive) {
+    return str.startsWith(searchStr);
+  }
+  return str.toLowerCase().startsWith(searchStr.toLowerCase());
+};
+var endsWith = (str, searchStr, caseSensitive = false) => {
+  if (caseSensitive) {
+    return str.endsWith(searchStr);
+  }
+  return str.toLowerCase().endsWith(searchStr.toLowerCase());
+};
+var padStart = (str, length, padChar = " ") => {
+  return str.padStart(length, padChar);
+};
+var padEnd = (str, length, padChar = " ") => {
+  if (str.length >= length) return str;
+  return str + padChar.repeat(length - str.length);
+};
+var trim = (str) => {
+  return str.trim();
+};
+var trimStart = (str) => {
+  return str.trimStart();
+};
+var trimEnd = (str) => {
+  return str.trimEnd();
+};
+var reverseString = (str) => {
+  return str.split("").reverse().join("");
+};
+var repeatString = (str, times) => {
+  return str.repeat(times);
+};
+var replaceAllOccurrences = (str, searchStr, replaceStr) => {
+  return str.split(searchStr).join(replaceStr);
+};
+var countOccurrences = (str, searchStr) => {
+  if (!searchStr) return 0;
+  let count = 0;
+  let position = 0;
+  while ((position = str.indexOf(searchStr, position)) !== -1) {
+    count++;
+    position += 1;
+  }
+  return count;
+};
+var isEmpty = (str) => {
+  return !str || str.trim().length === 0;
+};
+var isEmail = (str) => {
+  const re = /^(([^<>()[\]\\.,;:\s@"]+(\.[^<>()[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
+  return re.test(str.toLowerCase());
+};
+var toUrlSlug = (str) => {
+  return str.toLowerCase().trim().replace(/[^\w\s-]/g, "").replace(/[\s_-]+/g, "-").replace(/^-+|-+$/g, "");
+};
+var removeAccents = (str) => {
+  return str.normalize("NFD").replace(/[\u0300-\u036f]/g, "");
+};
+var escapeHtmlChars = (str) => {
+  const htmlEscapes = {
+    "&": "&amp;",
+    "<": "&lt;",
+    ">": "&gt;",
+    '"': "&quot;",
+    "'": "&#39;"
+  };
+  return str.replace(/[&<>"']/g, (match) => htmlEscapes[match]);
+};
+var unescapeHtmlChars = (str) => {
+  const htmlUnescapes = {
+    "&amp;": "&",
+    "&lt;": "<",
+    "&gt;": ">",
+    "&quot;": '"',
+    "&#39;": "'"
+  };
+  return str.replace(/&amp;|&lt;|&gt;|&quot;|&#39;/g, (match) => htmlUnescapes[match]);
+};
+function matchPathPattern(path, pattern) {
+  if (!path || typeof path !== "string" || !pattern || typeof pattern !== "string") {
+    return false;
+  }
+  if (path === pattern) {
+    return true;
+  }
+  if (!pattern.includes("*")) {
+    return path === pattern;
+  }
+  const regexPattern = pattern.split(".").map((segment) => {
+    if (segment === "*") {
+      return "[^.]+";
+    }
+    return segment.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  }).join("\\.");
+  const regex = new RegExp(`^${regexPattern}$`);
+  return regex.test(path);
+}
+function envKeyToPath(envKey, prefix = "NX") {
+  if (!envKey || typeof envKey !== "string") {
+    return "";
+  }
+  let key = envKey.trim();
+  if (prefix && key.startsWith(`${prefix}_`)) {
+    key = key.substring(prefix.length + 1);
+  }
+  return key.toLowerCase().replace(/_/g, ".");
+}
+function pathToEnvKey(path, prefix = "NX") {
+  if (!path || typeof path !== "string") {
+    return "";
+  }
+  const key = path.trim().toUpperCase().replace(/\./g, "_");
+  if (key.length === 0) {
+    return "";
+  }
+  if (prefix && prefix.length > 0) {
+    return `${prefix.toUpperCase()}_${key}`;
+  }
+  return key;
+}
+//# sourceMappingURL=strings.js.map

package/dist/cjs/strings.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/strings.ts"],"sourcesContent":["/**\n * String manipulation utilities\n * Consolidated from primitives/string module\n */\n\n/**\n * Sanitizes a string by removing special characters and converting to lowercase with dashes\n *\n * Produces clean, URL-friendly strings by removing special characters and normalizing whitespace.\n * Useful for slugs, IDs, CSS class names, and filename generation.\n *\n * Transformation rules:\n * 1. Remove all non-alphanumeric characters except spaces\n * 2. Remove additional punctuation (`~!@#$%^&*()_|+-=?;:'\",.<>{}[]\\\\/`)\n * 3. Replace spaces with dashes\n * 4. Convert to lowercase\n *\n * @param instr - Input string to sanitize (null returns empty string)\n * @returns Sanitized string in lowercase with dashes replacing spaces\n *\n * @example\n * ```typescript\n * // Basic sanitization\n * sanitizeString('Hello World!')        // 'hello-world'\n * sanitizeString('user@example.com')    // 'userexamplecom'\n * sanitizeString('Price: $19.99')       // 'price-1999'\n *\n * // Remove accents and special chars\n * sanitizeString('Café Münchën')        // 'caf-mnchen'\n * sanitizeString('北京 2024')            // '2024'\n *\n * // Multiple spaces/dashes\n * sanitizeString('hello   world')       // 'hello---world'\n * sanitizeString('foo-bar_baz')         // 'foo-barbaz'\n *\n * // Edge cases\n * sanitizeString(null)                  // ''\n * sanitizeString('')                    // ''\n * sanitizeString('   ')                 // '---'\n * sanitizeString('123')                 // '123'\n * ```\n *\n * @example\n * ```typescript\n * // Real-world: Generate CSS class names from user input\n * function generateClassName(userInput: string): string {\n *   return `custom-${sanitizeString(userInput)}`\n * }\n *\n * generateClassName('My Component!')     // 'custom-my-component'\n * generateClassName('Button (Primary)')  // 'custom-button-primary'\n * ```\n *\n * @example\n * ```typescript\n * // Real-world: Clean product names for file export\n * const products = [\n *   { name: 'T-Shirt (Blue)', sku: 'TS-001' },\n *   { name: 'Shoes & Accessories', sku: 'SH-042' }\n * ]\n *\n * products.forEach(p => {\n *   const filename = `${sanitizeString(p.name)}-${p.sku}.json`\n *   console.log(filename)\n *   // 't-shirt-blue-TS-001.json'\n *   // 'shoes-accessories-SH-042.json'\n * })\n * ```\n *\n * @see {@link toUrlSlug} for more sophisticated URL slug generation with accent removal\n * @see {@link toKebabCase} for case conversion to kebab-case\n */\nexport const sanitizeString = (instr: string | null): string => {\n  if (!instr) return ''\n  return addDash(instr.replace(/[^a-zA-Z0-9 ]/g, '')).toLowerCase()\n}\n\nfunction addDash(str: string): string {\n  const str2 = str.replace(/[`~!@#$%^&*()_|+\\-=?;:'\",.<>{}[\\]\\\\/]/gi, '')\n  return str2.replace(/ /g, '-')\n}\n\n/**\n * Removes JSON-like characters and HTML entities from a string\n * @param texto Input string to clean\n * @returns String with JSON characters and HTML entities removed\n */\nexport const cleanJsonChars = (texto: string | null): string => {\n  if (!texto) return ''\n  return texto.replace(/({|}|&amp;|amp;|gt;)/g, '')\n}\n\n/**\n * Truncates a string to a specified maximum length with optional suffix\n *\n * Shortens long strings for display in UI components, tables, previews, and tooltips.\n * Preserves readability while fitting space constraints.\n *\n * Behavior:\n * - If string length ≤ maxlength: returns original string unchanged\n * - If string length > maxlength: returns `str.substring(0, maxlength) + suffix`\n * - Suffix is included in addition to maxlength (not counted within limit)\n * - Null/empty strings return empty string\n *\n * @param str - String to truncate (null/empty returns '')\n * @param maxlength - Maximum length before truncation (default: 80 characters)\n * @param suffix - Suffix to append when truncated (default: '...')\n * @returns Truncated string with suffix if needed, original string if shorter\n *\n * @example\n * ```typescript\n * // Basic truncation (default 80 chars)\n * truncateString('Short text')  // 'Short text' (no truncation)\n *\n * const long = 'Lorem ipsum dolor sit amet, consectetur adipiscing elit'\n * truncateString(long, 20)  // 'Lorem ipsum dolor si...' (20 + 3 = 23 chars total)\n *\n * // Custom max length\n * truncateString('Hello World', 5)        // 'Hello...'\n * truncateString('Hello World', 11)       // 'Hello World' (no truncation)\n *\n * // Custom suffix\n * truncateString('Long text here', 8, '…')       // 'Long tex…'\n * truncateString('Long text here', 8, ' [more]') // 'Long tex [more]'\n * truncateString('Long text here', 8, '')        // 'Long tex' (no suffix)\n *\n * // Edge cases\n * truncateString('', 10)          // ''\n * truncateString(null as any, 10) // '' (graceful handling)\n * truncateString('Hi', 0)         // '...' (edge case: 0 maxlength)\n * ```\n *\n * @example\n * ```typescript\n * // Real-world: Truncate product descriptions in table\n * const products = [\n *   { name: 'Laptop', description: 'High-performance laptop with 16GB RAM and 512GB SSD' },\n *   { name: 'Mouse', description: 'Wireless ergonomic mouse' }\n * ]\n *\n * products.forEach(p => {\n *   console.log(`${p.name}: ${truncateString(p.description, 30)}`)\n * })\n * // Output:\n * // Laptop: High-performance laptop with 1...\n * // Mouse: Wireless ergonomic mouse\n * ```\n *\n * @example\n * ```typescript\n * // Real-world: Truncate user comments for preview\n * function renderCommentPreview(comment: string): string {\n *   return `<div class=\"preview\">${truncateString(comment, 100)}</div>`\n * }\n *\n * renderCommentPreview('This is a very long comment that needs to be shortened for display...')\n * // '<div class=\"preview\">This is a very long comment that needs to be shortened for display in the UI without taking too m...</div>'\n * ```\n *\n * @example\n * ```typescript\n * // Real-world: Email subject line truncation\n * function formatEmailSubject(subject: string): string {\n *   // Gmail displays ~60 chars on desktop\n *   return truncateString(subject, 60, '…')\n * }\n *\n * formatEmailSubject('Re: Important meeting about Q4 planning and budget review')\n * // 'Re: Important meeting about Q4 planning and budget review' (fits)\n *\n * formatEmailSubject('Re: [URGENT] Critical system outage affecting all production servers and databases')\n * // 'Re: [URGENT] Critical system outage affecting all production…'\n * ```\n *\n * @see {@link isEmpty} for checking empty strings\n */\nexport const truncateString = (str: string, maxlength = 80, suffix = '...'): string => {\n  if (!str) return ''\n  return str.length > maxlength ? str.substring(0, maxlength) + suffix : str\n}\n\n/**\n * Converts Unicode escape sequences to their actual characters\n * @param input String containing Unicode escape sequences\n * @returns String with escape sequences converted to actual characters\n */\nexport const unescapeUnicode = (input: string): string => {\n  return JSON.stringify(JSON.parse(`\"${input}\"`)).replace(/^\"(.*)\"$/, '$1')\n}\n\n/**\n * Ensures a string ends with a specific suffix, adding it if not present\n * @param str Input string to check\n * @param trailing Suffix string to ensure is present at the end\n * @returns String guaranteed to end with the trailing string\n */\nexport const ensureEndsWith = (str: string, trailing: string): string => {\n  return str.endsWith(trailing) ? str : `${str}${trailing}`\n}\n\n/**\n * Removes a specific suffix from the end of a string if present\n * @param str Input string to process\n * @param trailing Suffix string to remove from the end\n * @returns String with trailing suffix removed, original if suffix not found\n */\nexport const stripFromEnd = (str: string, trailing: string): string => {\n  return str.endsWith(trailing) ? str.slice(0, -1 * trailing.length) : str\n}\n\n/**\n * Ensures a string starts with a specific prefix, adding it if not present\n * @param str Input string to check\n * @param leading Prefix string to ensure is present at the start\n * @returns String guaranteed to start with the leading string\n */\nexport const ensureStartsWith = (str: string, leading: string): string => {\n  return str.startsWith(leading) ? str : `${leading}${str}`\n}\n\n/**\n * Removes a specific prefix from the start of a string if present\n * @param str Input string to process\n * @param leading Prefix string to remove from the start\n * @returns String with leading prefix removed, original if prefix not found\n */\nexport const stripFromStart = (str: string, leading: string): string => {\n  return str.startsWith(leading) ? str.slice(leading.length) : str\n}\n\n/**\n * Converts all characters in a string to lowercase\n * @param str Input string to convert\n * @returns String with all characters in lowercase\n */\nexport const toLowerCase = (str: string): string => {\n  return str.toLowerCase()\n}\n\n/**\n * Converts all characters in a string to uppercase\n * @param str Input string to convert\n * @returns String with all characters in uppercase\n */\nexport const toUpperCase = (str: string): string => {\n  return str.toUpperCase()\n}\n\n/**\n * Capitalizes the first letter of a string and lowercases the rest\n * @param str Input string to capitalize\n * @returns String with first letter capitalized and rest in lowercase\n */\nexport const capitalizeFirst = (str: string): string => {\n  if (!str) return ''\n  return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase()\n}\n\n/**\n * Capitalizes the first letter of each word in a string\n * @param str Input string with words separated by spaces\n * @returns String with each word's first letter capitalized\n */\nexport const capitalizeEachWord = (str: string): string => {\n  if (!str) return ''\n  return str\n    .split(' ')\n    .map(word => capitalizeFirst(word))\n    .join(' ')\n}\n\n/**\n * Converts a string to camelCase format\n *\n * Transforms strings from any case convention (kebab-case, snake_case, PascalCase, spaces)\n * to camelCase following JavaScript/TypeScript naming conventions.\n *\n * Algorithm:\n * 1. Detect word boundaries (spaces, hyphens, underscores, case transitions)\n * 2. Split into words and normalize to lowercase\n * 3. First word: keep lowercase\n * 4. Remaining words: capitalize first letter\n * 5. Join without separators\n *\n * Format: `firstWordSecondWordThirdWord`\n *\n * @param str - Input string in any case format (empty returns '')\n * @returns String in camelCase format\n *\n * @example\n * ```typescript\n * // From kebab-case\n * toCamelCase('hello-world')           // 'helloWorld'\n * toCamelCase('user-profile-page')     // 'userProfilePage'\n *\n * // From snake_case\n * toCamelCase('hello_world')           // 'helloWorld'\n * toCamelCase('user_first_name')       // 'userFirstName'\n *\n * // From PascalCase\n * toCamelCase('HelloWorld')            // 'helloWorld'\n * toCamelCase('UserProfile')           // 'userProfile'\n *\n * // From space-separated\n * toCamelCase('hello world')           // 'helloWorld'\n * toCamelCase('First Name')            // 'firstName'\n *\n * // Mixed formats\n * toCamelCase('hello-World_test')      // 'helloWorldTest'\n * toCamelCase('API_Response-data')     // 'apiResponseData'\n *\n * // Edge cases\n * toCamelCase('')                      // ''\n * toCamelCase('a')                     // 'a'\n * toCamelCase('UPPERCASE')             // 'uppercase'\n * toCamelCase('123-test')              // '123Test'\n * ```\n *\n * @example\n * ```typescript\n * // Real-world: Convert database column names to JS properties\n * const dbColumns = ['user_id', 'first_name', 'last_name', 'created_at']\n *\n * const jsProperties = dbColumns.map(toCamelCase)\n * console.log(jsProperties)\n * // ['userId', 'firstName', 'lastName', 'createdAt']\n *\n * // Transform database row to JS object\n * function transformRow(row: Record<string, any>): Record<string, any> {\n *   return Object.fromEntries(\n *     Object.entries(row).map(([key, value]) => [toCamelCase(key), value])\n *   )\n * }\n *\n * transformRow({ user_id: 123, first_name: 'Alice' })\n * // { userId: 123, firstName: 'Alice' }\n * ```\n *\n * @example\n * ```typescript\n * // Real-world: Convert CSS property names to JS style properties\n * const cssProperties = [\n *   'background-color',\n *   'font-size',\n *   'margin-top',\n *   'border-bottom-width'\n * ]\n *\n * cssProperties.forEach(prop => {\n *   const jsProp = toCamelCase(prop)\n *   console.log(`${prop} → ${jsProp}`)\n * })\n * // background-color → backgroundColor\n * // font-size → fontSize\n * // margin-top → marginTop\n * // border-bottom-width → borderBottomWidth\n * ```\n *\n * @example\n * ```typescript\n * // Real-world: API response transformation\n * interface ApiUser {\n *   user_id: number\n *   first_name: string\n *   last_name: string\n *   created_at: string\n * }\n *\n * function transformApiResponse(apiData: ApiUser) {\n *   return {\n *     userId: apiData.user_id,\n *     firstName: apiData.first_name,\n *     lastName: apiData.last_name,\n *     createdAt: new Date(apiData.created_at)\n *   }\n * }\n *\n * // Or generically:\n * function autoTransformKeys<T extends Record<string, any>>(obj: T) {\n *   return Object.fromEntries(\n *     Object.entries(obj).map(([k, v]) => [toCamelCase(k), v])\n *   )\n * }\n * ```\n *\n * @see {@link toPascalCase} for PascalCase conversion (first letter uppercase)\n * @see {@link toSnakeCase} for snake_case conversion\n * @see {@link toKebabCase} for kebab-case conversion\n */\nexport const toCamelCase = (str: string): string => {\n  if (!str) return ''\n\n  // Split by word boundaries (spaces, hyphens, underscores, camelCase boundaries)\n  const words = str\n    .replace(/([a-z])([A-Z])/g, '$1 $2') // Split camelCase\n    .split(/[-_\\s]+/) // Split by separators\n    .filter(word => word.length > 0)\n    .map(word => word.toLowerCase())\n\n  if (words.length === 0) return ''\n\n  // First word lowercase, rest capitalize first letter\n  return (\n    words[0] +\n    words\n      .slice(1)\n      .map(word => word.charAt(0).toUpperCase() + word.slice(1))\n      .join('')\n  )\n}\n\n/**\n * Converts a string to snake_case format\n *\n * Transforms strings from any case convention to snake_case, commonly used in\n * Python, Ruby, database column names, and environment variables.\n *\n * Algorithm:\n * 1. Replace non-word characters with spaces\n * 2. Split on spaces and camelCase boundaries\n * 3. Convert all words to lowercase\n * 4. Join with underscores\n *\n * Format: `first_word_second_word_third_word`\n *\n * @param str - Input string in any case format (empty returns '')\n * @returns String in snake_case format\n *\n * @example\n * ```typescript\n * // From camelCase\n * toSnakeCase('helloWorld')            // 'hello_world'\n * toSnakeCase('userFirstName')         // 'user_first_name'\n *\n * // From PascalCase\n * toSnakeCase('HelloWorld')            // 'hello_world'\n * toSnakeCase('UserProfile')           // 'user_profile'\n *\n * // From kebab-case\n * toSnakeCase('hello-world')           // 'hello_world'\n * toSnakeCase('user-profile-page')     // 'user_profile_page'\n *\n * // From space-separated\n * toSnakeCase('hello world')           // 'hello_world'\n * toSnakeCase('First Name')            // 'first_name'\n *\n * // Mixed formats\n * toSnakeCase('helloWorld-test')       // 'hello_world_test'\n * toSnakeCase('APIResponse')           // 'a_p_i_response'\n *\n * // Edge cases\n * toSnakeCase('')                      // ''\n * toSnakeCase('a')                     // 'a'\n * toSnakeCase('UPPERCASE')             // 'u_p_p_e_r_c_a_s_e'\n * ```\n *\n * @example\n * ```typescript\n * // Real-world: Convert JS properties to database column names\n * const jsObject = {\n *   userId: 123,\n *   firstName: 'Alice',\n *   lastName: 'Smith',\n *   createdAt: new Date()\n * }\n *\n * const dbColumns = Object.keys(jsObject).map(toSnakeCase)\n * console.log(dbColumns)\n * // ['user_id', 'first_name', 'last_name', 'created_at']\n *\n * // Generate SQL INSERT statement\n * const columns = Object.keys(jsObject).map(toSnakeCase).join(', ')\n * const sql = `INSERT INTO users (${columns}) VALUES (?)`\n * ```\n *\n * @example\n * ```typescript\n * // Real-world: Environment variable generation\n * const configKeys = ['databaseHost', 'databasePort', 'apiBaseUrl']\n *\n * configKeys.forEach(key => {\n *   const envVar = toSnakeCase(key).toUpperCase()\n *   console.log(`${envVar}=value`)\n * })\n * // DATABASE_HOST=value\n * // DATABASE_PORT=value\n * // API_BASE_URL=value\n * ```\n *\n * @see {@link toCamelCase} for camelCase conversion\n * @see {@link toKebabCase} for kebab-case conversion\n * @see {@link toPascalCase} for PascalCase conversion\n */\nexport const toSnakeCase = (str: string): string => {\n  if (!str) return ''\n  return str\n    .replace(/\\W+/g, ' ')\n    .split(/ |\\B(?=[A-Z])/)\n    .map(word => word.toLowerCase())\n    .join('_')\n}\n\n/**\n * Converts a string to kebab-case format\n *\n * Transforms strings from any case convention to kebab-case (also called dash-case or hyphen-case).\n * Widely used in URLs, HTML attributes, CSS classes, and file names.\n *\n * Algorithm:\n * 1. Replace underscores and spaces with hyphens\n * 2. Insert hyphens before uppercase letters (handle camelCase)\n * 3. Convert all to lowercase\n * 4. Remove non-alphanumeric characters (except hyphens)\n * 5. Collapse multiple consecutive hyphens\n * 6. Remove leading/trailing hyphens\n *\n * Format: `first-word-second-word-third-word`\n *\n * @param str - Input string in any case format (empty returns '')\n * @returns String in kebab-case format\n *\n * @example\n * ```typescript\n * // From camelCase\n * toKebabCase('helloWorld')            // 'hello-world'\n * toKebabCase('userFirstName')         // 'user-first-name'\n *\n * // From PascalCase\n * toKebabCase('HelloWorld')            // 'hello-world'\n * toKebabCase('UserProfile')           // 'user-profile'\n *\n * // From snake_case\n * toKebabCase('hello_world')           // 'hello-world'\n * toKebabCase('user_first_name')       // 'user-first-name'\n *\n * // From space-separated\n * toKebabCase('hello world')           // 'hello-world'\n * toKebabCase('First Name')            // 'first-name'\n *\n * // Mixed formats\n * toKebabCase('helloWorld_test')       // 'hello-world-test'\n * toKebabCase('API-Response')          // 'api-response'\n *\n * // Edge cases\n * toKebabCase('')                      // ''\n * toKebabCase('a')                     // 'a'\n * toKebabCase('UPPERCASE')             // 'uppercase'\n * toKebabCase('123Test')               // '123-test'\n * toKebabCase('--multiple--dashes--')  // 'multiple-dashes'\n * ```\n *\n * @example\n * ```typescript\n * // Real-world: Generate URL slugs from page titles\n * const pageTitle = 'My Awesome Blog Post'\n * const urlSlug = toKebabCase(pageTitle)\n * const url = `https://example.com/blog/${urlSlug}`\n * // https://example.com/blog/my-awesome-blog-post\n *\n * // Multiple pages\n * const pages = [\n *   { title: 'Getting Started', component: 'GettingStarted' },\n *   { title: 'API Reference', component: 'ApiReference' },\n *   { title: 'Best Practices', component: 'BestPractices' }\n * ]\n *\n * const routes = pages.map(p => ({\n *   path: `/${toKebabCase(p.title)}`,\n *   component: p.component\n * }))\n * // [\n * //   { path: '/getting-started', component: 'GettingStarted' },\n * //   { path: '/api-reference', component: 'ApiReference' },\n * //   { path: '/best-practices', component: 'BestPractices' }\n * // ]\n * ```\n *\n * @example\n * ```typescript\n * // Real-world: CSS class name generation\n * function generateClassName(componentName: string, modifier?: string): string {\n *   const base = `component-${toKebabCase(componentName)}`\n *   return modifier ? `${base}--${toKebabCase(modifier)}` : base\n * }\n *\n * generateClassName('UserProfile')                    // 'component-user-profile'\n * generateClassName('UserProfile', 'isActive')        // 'component-user-profile--is-active'\n * generateClassName('ButtonPrimary', 'largeSize')     // 'component-button-primary--large-size'\n * ```\n *\n * @example\n * ```typescript\n * // Real-world: HTML attribute generation\n * function generateDataAttribute(key: string, value: string): string {\n *   return `data-${toKebabCase(key)}=\"${value}\"`\n * }\n *\n * generateDataAttribute('userId', '123')              // 'data-user-id=\"123\"'\n * generateDataAttribute('testEnvironment', 'staging') // 'data-test-environment=\"staging\"'\n * ```\n *\n * @see {@link toCamelCase} for camelCase conversion\n * @see {@link toSnakeCase} for snake_case conversion\n * @see {@link toPascalCase} for PascalCase conversion\n * @see {@link toUrlSlug} for URL-safe slug generation with accent removal\n */\nexport const toKebabCase = (str: string): string => {\n  if (!str) return ''\n  return str\n    .replace(/[_\\s]+/g, '-')\n    .replace(/([a-z0-9])([A-Z])/g, '$1-$2') // Handle numbers before capitals too\n    .toLowerCase()\n    .replace(/[^a-z0-9-]/g, '-')\n    .replace(/-+/g, '-')\n    .replace(/^-|-$/g, '')\n}\n\n/**\n * Converts a string to PascalCase format\n *\n * Transforms strings from any case convention to PascalCase (also called UpperCamelCase).\n * Commonly used for class names, component names, type names, and constructor functions\n * in JavaScript/TypeScript.\n *\n * Algorithm:\n * 1. Split on word boundaries (hyphens, underscores, spaces)\n * 2. Capitalize first letter of each word\n * 3. Join without separators\n * 4. Ensure first character is uppercase\n *\n * Format: `FirstWordSecondWordThirdWord`\n *\n * @param str - Input string in any case format (empty returns '')\n * @returns String in PascalCase format\n *\n * @example\n * ```typescript\n * // From camelCase\n * toPascalCase('helloWorld')           // 'HelloWorld'\n * toPascalCase('userFirstName')        // 'UserFirstName'\n *\n * // From kebab-case\n * toPascalCase('hello-world')          // 'HelloWorld'\n * toPascalCase('user-profile-page')    // 'UserProfilePage'\n *\n * // From snake_case\n * toPascalCase('hello_world')          // 'HelloWorld'\n * toPascalCase('user_first_name')      // 'UserFirstName'\n *\n * // From space-separated\n * toPascalCase('hello world')          // 'HelloWorld'\n * toPascalCase('first name')           // 'FirstName'\n *\n * // Mixed formats\n * toPascalCase('hello-World_test')     // 'HelloWorldTest'\n * toPascalCase('api_response-data')    // 'ApiResponseData'\n *\n * // Edge cases\n * toPascalCase('')                     // ''\n * toPascalCase('a')                    // 'A'\n * toPascalCase('UPPERCASE')            // 'UPPERCASE'\n * ```\n *\n * @example\n * ```typescript\n * // Real-world: Generate React component names\n * const componentNames = ['user-profile', 'navigation-bar', 'footer-links']\n *\n * componentNames.forEach(name => {\n *   const pascalName = toPascalCase(name)\n *   console.log(`export function ${pascalName}() { ... }`)\n * })\n * // export function UserProfile() { ... }\n * // export function NavigationBar() { ... }\n * // export function FooterLinks() { ... }\n * ```\n *\n * @example\n * ```typescript\n * // Real-world: TypeScript type name generation\n * interface GenerateTypeOptions {\n *   name: string\n *   fields: Array<{ name: string; type: string }>\n * }\n *\n * function generateTypeDefinition(options: GenerateTypeOptions): string {\n *   const typeName = toPascalCase(options.name)\n *   const fields = options.fields\n *     .map(f => `  ${f.name}: ${f.type}`)\n *     .join('\\n')\n *\n *   return `interface ${typeName} {\\n${fields}\\n}`\n * }\n *\n * generateTypeDefinition({\n *   name: 'user-profile',\n *   fields: [\n *     { name: 'userId', type: 'number' },\n *     { name: 'name', type: 'string' }\n *   ]\n * })\n * // interface UserProfile {\n * //   userId: number\n * //   name: string\n * // }\n * ```\n *\n * @example\n * ```typescript\n * // Real-world: Class name generation for dynamic imports\n * async function loadService(serviceName: string) {\n *   const className = toPascalCase(serviceName)\n *   const module = await import(`./services/${serviceName}`)\n *   return new module[className]()\n * }\n *\n * await loadService('user-service')     // new UserService()\n * await loadService('payment-gateway')  // new PaymentGateway()\n * ```\n *\n * @see {@link toCamelCase} for camelCase conversion (first letter lowercase)\n * @see {@link toSnakeCase} for snake_case conversion\n * @see {@link toKebabCase} for kebab-case conversion\n */\nexport const toPascalCase = (str: string): string => {\n  if (!str) return ''\n  return str\n    .replace(/[-_\\s]+(.)?/g, (_, char) => (char ? char.toUpperCase() : ''))\n    .replace(/^./, char => char.toUpperCase())\n}\n\n/**\n * Checks if a string contains another string with optional case sensitivity\n * @param str String to search within\n * @param searchStr Substring to search for\n * @param caseSensitive Whether to perform case-sensitive search (default: false)\n * @returns True if the string contains the search string, false otherwise\n */\nexport const contains = (str: string, searchStr: string, caseSensitive = false): boolean => {\n  if (caseSensitive) {\n    return str.includes(searchStr)\n  }\n  return str.toLowerCase().includes(searchStr.toLowerCase())\n}\n\n/**\n * Checks if a string starts with another string with optional case sensitivity\n * @param str String to check\n * @param searchStr Prefix to search for\n * @param caseSensitive Whether to perform case-sensitive search (default: false)\n * @returns True if the string starts with the search string, false otherwise\n */\nexport const startsWith = (str: string, searchStr: string, caseSensitive = false): boolean => {\n  if (caseSensitive) {\n    return str.startsWith(searchStr)\n  }\n  return str.toLowerCase().startsWith(searchStr.toLowerCase())\n}\n\n/**\n * Checks if a string ends with another string with optional case sensitivity\n * @param str String to check\n * @param searchStr Suffix to search for\n * @param caseSensitive Whether to perform case-sensitive search (default: false)\n * @returns True if the string ends with the search string, false otherwise\n */\nexport const endsWith = (str: string, searchStr: string, caseSensitive = false): boolean => {\n  if (caseSensitive) {\n    return str.endsWith(searchStr)\n  }\n  return str.toLowerCase().endsWith(searchStr.toLowerCase())\n}\n\n/**\n * Pads a string at the start (left) with a specific character to reach target length\n * @param str String to pad\n * @param length Target length for the resulting string\n * @param padChar Character to use for padding (default: space)\n * @returns String padded to target length, original if already longer\n */\nexport const padStart = (str: string, length: number, padChar = ' '): string => {\n  return str.padStart(length, padChar)\n}\n\n/**\n * Pads a string at the end (right) with a specific character to reach target length\n * @param str String to pad\n * @param length Target length for the resulting string\n * @param padChar Character to use for padding (default: space)\n * @returns String padded to target length, original if already longer\n */\nexport const padEnd = (str: string, length: number, padChar = ' '): string => {\n  if (str.length >= length) return str\n  return str + padChar.repeat(length - str.length)\n}\n\n/**\n * Removes leading and trailing whitespace from a string\n * @param str String to trim\n * @returns String with leading and trailing whitespace removed\n */\nexport const trim = (str: string): string => {\n  return str.trim()\n}\n\n/**\n * Removes leading (start) whitespace from a string\n * @param str String to trim\n * @returns String with leading whitespace removed\n */\nexport const trimStart = (str: string): string => {\n  return str.trimStart()\n}\n\n/**\n * Removes trailing (end) whitespace from a string\n * @param str String to trim\n * @returns String with trailing whitespace removed\n */\nexport const trimEnd = (str: string): string => {\n  return str.trimEnd()\n}\n\n/**\n * Reverses the character order in a string\n * @param str String to reverse\n * @returns String with characters in reverse order\n */\nexport const reverseString = (str: string): string => {\n  return str.split('').reverse().join('')\n}\n\n/**\n * Repeats a string a specified number of times\n * @param str String to repeat\n * @param times Number of times to repeat the string\n * @returns String repeated the specified number of times\n */\nexport const repeatString = (str: string, times: number): string => {\n  return str.repeat(times)\n}\n\n/**\n * Replaces all occurrences of a substring with a replacement string\n * @param str String to search in\n * @param searchStr Substring to find and replace\n * @param replaceStr String to replace each occurrence with\n * @returns String with all occurrences replaced\n */\nexport const replaceAllOccurrences = (\n  str: string,\n  searchStr: string,\n  replaceStr: string\n): string => {\n  return str.split(searchStr).join(replaceStr)\n}\n\n/**\n * Counts the number of occurrences of a substring within a string\n * @param str String to search within\n * @param searchStr Substring to count occurrences of\n * @returns Number of times the substring appears in the string\n */\nexport const countOccurrences = (str: string, searchStr: string): number => {\n  if (!searchStr) return 0\n  let count = 0\n  let position = 0\n\n  while ((position = str.indexOf(searchStr, position)) !== -1) {\n    count++\n    position += 1 // Move only 1 position to allow overlapping matches\n  }\n\n  return count\n}\n\n/**\n * Checks if a string is empty, null, undefined, or contains only whitespace\n * @param str String to check (can be null or undefined)\n * @returns True if string is empty/null/undefined or only whitespace, false otherwise\n */\nexport const isEmpty = (str: string | null | undefined): boolean => {\n  return !str || str.trim().length === 0\n}\n\n/**\n * Validates if a string is a properly formatted email address\n * @param str String to validate as email\n * @returns True if string matches email format, false otherwise\n */\nexport const isEmail = (str: string): boolean => {\n  const re =\n    /^(([^<>()[\\]\\\\.,;:\\s@\"]+(\\.[^<>()[\\]\\\\.,;:\\s@\"]+)*)|(\".+\"))@((\\[[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}\\])|(([a-zA-Z\\-0-9]+\\.)+[a-zA-Z]{2,}))$/\n  return re.test(str.toLowerCase())\n}\n\n/**\n * Generates a URL-friendly slug from a string\n *\n * Creates clean, SEO-friendly URL slugs by normalizing strings for use in web addresses.\n * Removes special characters, normalizes whitespace, and converts to lowercase with hyphens.\n *\n * Algorithm:\n * 1. Convert to lowercase\n * 2. Trim leading/trailing whitespace\n * 3. Remove non-word characters (except spaces, hyphens, underscores)\n * 4. Replace spaces/underscores/multiple-hyphens with single hyphen\n * 5. Remove leading/trailing hyphens\n *\n * Format: `url-friendly-slug-text`\n *\n * ⚠️ NOTE: Does NOT remove accents. For accent removal, use {@link removeAccents} first.\n *\n * @param str - String to convert to URL slug (special chars removed)\n * @returns URL-friendly slug string in lowercase with hyphens\n *\n * @example\n * ```typescript\n * // Basic slug generation\n * toUrlSlug('Hello World')              // 'hello-world'\n * toUrlSlug('My Blog Post Title')       // 'my-blog-post-title'\n *\n * // Remove special characters\n * toUrlSlug('User: John Doe!')          // 'user-john-doe'\n * toUrlSlug('Price: $19.99')            // 'price-1999'\n * toUrlSlug('Hello @ World #2024')      // 'hello-world-2024'\n *\n * // Normalize whitespace and separators\n * toUrlSlug('hello   world')            // 'hello-world'\n * toUrlSlug('hello_world_test')         // 'hello-world-test'\n * toUrlSlug('---multiple---dashes---')  // 'multiple-dashes'\n *\n * // Preserve numbers and hyphens\n * toUrlSlug('Article 123')              // 'article-123'\n * toUrlSlug('ES6-Features')             // 'es6-features'\n *\n * // Edge cases\n * toUrlSlug('')                         // ''\n * toUrlSlug('   ')                      // ''\n * toUrlSlug('123')                      // '123'\n * toUrlSlug('a-b-c')                    // 'a-b-c'\n * ```\n *\n * @example\n * ```typescript\n * // Real-world: Generate blog post URL from title\n * function createBlogPostUrl(title: string, id: number): string {\n *   const slug = toUrlSlug(title)\n *   return `/blog/${id}/${slug}`\n * }\n *\n * createBlogPostUrl('10 Tips for TypeScript', 42)\n * // '/blog/42/10-tips-for-typescript'\n *\n * createBlogPostUrl('Getting Started with React!', 1)\n * // '/blog/1/getting-started-with-react'\n * ```\n *\n * @example\n * ```typescript\n * // Real-world: Generate product URLs for e-commerce\n * interface Product {\n *   id: string\n *   name: string\n *   category: string\n * }\n *\n * function getProductUrl(product: Product): string {\n *   const categorySlug = toUrlSlug(product.category)\n *   const nameSlug = toUrlSlug(product.name)\n *   return `/products/${categorySlug}/${product.id}/${nameSlug}`\n * }\n *\n * getProductUrl({\n *   id: 'SKU-123',\n *   name: 'Wireless Mouse (Ergonomic)',\n *   category: 'Computer Accessories'\n * })\n * // '/products/computer-accessories/SKU-123/wireless-mouse-ergonomic'\n * ```\n *\n * @example\n * ```typescript\n * // Real-world: SEO-friendly URLs with accent handling\n * function createSeoUrl(title: string): string {\n *   // Remove accents BEFORE slug generation for better URL compatibility\n *   return toUrlSlug(removeAccents(title))\n * }\n *\n * createSeoUrl('Café Münchën 2024')\n * // 'cafe-munchen-2024' (accents removed)\n *\n * // Without accent removal:\n * toUrlSlug('Café Münchën 2024')\n * // 'caf-mnchen-2024' (accents become invalid chars, get removed)\n * ```\n *\n * @example\n * ```typescript\n * // Real-world: Generate unique slugs for duplicate titles\n * const existingSlugs = new Set(['hello-world', 'hello-world-1'])\n *\n * function generateUniqueSlug(title: string): string {\n *   let slug = toUrlSlug(title)\n *   let counter = 1\n *\n *   while (existingSlugs.has(slug)) {\n *     slug = `${toUrlSlug(title)}-${counter}`\n *     counter++\n *   }\n *\n *   existingSlugs.add(slug)\n *   return slug\n * }\n *\n * generateUniqueSlug('Hello World')  // 'hello-world-2' (avoiding existing)\n * generateUniqueSlug('New Article')  // 'new-article'\n * ```\n *\n * @see {@link toKebabCase} for case conversion to kebab-case\n * @see {@link removeAccents} for removing accents before slug generation\n * @see {@link sanitizeString} for basic string sanitization\n */\nexport const toUrlSlug = (str: string): string => {\n  return str\n    .toLowerCase()\n    .trim()\n    .replace(/[^\\w\\s-]/g, '')\n    .replace(/[\\s_-]+/g, '-')\n    .replace(/^-+|-+$/g, '')\n}\n\n/**\n * Removes accents and diacritical marks from characters in a string\n *\n * Uses Unicode normalization (NFD) to decompose accented characters, then removes\n * combining diacritical marks. Essential for search, sorting, URL slugs, and ASCII compatibility.\n *\n * Algorithm:\n * 1. Normalize string to NFD (Normalization Form Decomposed)\n * 2. Remove Unicode combining diacritical marks (U+0300–U+036F)\n * 3. Return ASCII-compatible base characters\n *\n * Supported diacritics: acute (´), grave (`), circumflex (^), tilde (~), umlaut (¨),\n * cedilla (¸), and many more.\n *\n * @param str - String containing accented characters (e.g., 'café', 'Münchën')\n * @returns String with accents removed to base ASCII characters (e.g., 'cafe', 'Munchen')\n *\n * @example\n * ```typescript\n * // Basic accent removal - Romance languages\n * removeAccents('café')              // 'cafe'\n * removeAccents('naïve')             // 'naive'\n * removeAccents('résumé')            // 'resume'\n * removeAccents('à côté')            // 'a cote'\n *\n * // Spanish accents\n * removeAccents('Español')           // 'Espanol'\n * removeAccents('niño')              // 'nino'\n * removeAccents('José María')        // 'Jose Maria'\n *\n * // German umlauts\n * removeAccents('Münchën')           // 'Munchen'\n * removeAccents('Köln')              // 'Koln'\n * removeAccents('Zürich')            // 'Zurich'\n *\n * // Portuguese\n * removeAccents('São Paulo')         // 'Sao Paulo'\n * removeAccents('Brasília')          // 'Brasilia'\n *\n * // French\n * removeAccents('Côte d'Ivoire')     // 'Cote d'Ivoire'\n * removeAccents('Françoise')         // 'Francoise'\n *\n * // Mixed\n * removeAccents('Crème brûlée')      // 'Creme brulee'\n * removeAccents('Åre, Malmö')        // 'Are, Malmo'\n *\n * // Edge cases\n * removeAccents('')                  // ''\n * removeAccents('ASCII text')        // 'ASCII text' (unchanged)\n * ```\n *\n * @example\n * ```typescript\n * // Real-world: Search normalization (case + accent insensitive)\n * function normalizeForSearch(text: string): string {\n *   return removeAccents(text.toLowerCase().trim())\n * }\n *\n * const searchQuery = normalizeForSearch('Café')           // 'cafe'\n * const productName = normalizeForSearch('CAFÉ PREMIUM')   // 'cafe premium'\n *\n * if (productName.includes(searchQuery)) {\n *   console.log('Match found!')\n * }\n * ```\n *\n * @example\n * ```typescript\n * // Real-world: Generate SEO-friendly URLs\n * function createSeoUrl(title: string): string {\n *   return toUrlSlug(removeAccents(title))\n * }\n *\n * createSeoUrl('Guía de Español')\n * // 'guia-de-espanol'\n *\n * createSeoUrl('Café Münchën 2024')\n * // 'cafe-munchen-2024'\n *\n * createSeoUrl('São Paulo: Best Restaurants')\n * // 'sao-paulo-best-restaurants'\n * ```\n *\n * @example\n * ```typescript\n * // Real-world: Sort names alphabetically (accent-insensitive)\n * const names = ['Álvarez', 'Andersen', 'Ängel', 'Adams']\n *\n * const sorted = names.sort((a, b) =>\n *   removeAccents(a).localeCompare(removeAccents(b))\n * )\n * // ['Adams', 'Álvarez', 'Andersen', 'Ängel']\n * // (sorted by: Adams, Alvarez, Andersen, Angel)\n * ```\n *\n * @example\n * ```typescript\n * // Real-world: Filename sanitization\n * function sanitizeFilename(filename: string): string {\n *   // Remove accents, then sanitize\n *   const withoutAccents = removeAccents(filename)\n *   return sanitizeString(withoutAccents)\n * }\n *\n * sanitizeFilename('Presentación_2024.pdf')\n * // 'presentacion-2024pdf'\n *\n * sanitizeFilename('Föräldrar & Barn.docx')\n * // 'foraldrar-barn-docx'\n * ```\n *\n * @example\n * ```typescript\n * // Real-world: Email address generation\n * function generateEmail(firstName: string, lastName: string): string {\n *   const first = removeAccents(firstName.toLowerCase())\n *   const last = removeAccents(lastName.toLowerCase())\n *   return `${first}.${last}@company.com`\n * }\n *\n * generateEmail('José', 'García')\n * // 'jose.garcia@company.com'\n *\n * generateEmail('François', 'Müller')\n * // 'francois.muller@company.com'\n * ```\n *\n * @see {@link toUrlSlug} for URL slug generation (combine with removeAccents for best results)\n * @see {@link sanitizeString} for string sanitization\n * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/normalize String.normalize() Documentation}\n */\nexport const removeAccents = (str: string): string => {\n  return str.normalize('NFD').replace(/[\\u0300-\\u036f]/g, '')\n}\n\n/**\n * Escapes HTML special characters to prevent XSS and display issues\n *\n * Converts dangerous HTML characters to their HTML entity equivalents, preventing\n * script injection (XSS) and ensuring proper text display in HTML contexts.\n *\n * Escaped characters:\n * - `&` → `&amp;` (must be first to avoid double-escaping)\n * - `<` → `&lt;` (prevents opening tags)\n * - `>` → `&gt;` (prevents closing tags)\n * - `\"` → `&quot;` (prevents attribute injection)\n * - `'` → `&#39;` (prevents attribute injection)\n *\n * ⚠️ SECURITY WARNING: This provides basic XSS protection but is NOT a complete solution.\n * For production HTML sanitization, use DOMPurify or similar dedicated libraries.\n * This function is safe for:\n * - Displaying user input as plain text in HTML\n * - Escaping attribute values in HTML\n * - Simple content rendering\n *\n * NOT sufficient for:\n * - Rich HTML content (use DOMPurify)\n * - JavaScript context (use different escaping)\n * - URL context (use encodeURIComponent)\n * - CSS context (use CSS-specific escaping)\n *\n * @param str - String containing HTML characters to escape\n * @returns String with HTML characters safely escaped as HTML entities\n *\n * @example\n * ```typescript\n * // Basic escaping\n * escapeHtmlChars('<script>alert(\"XSS\")</script>')\n * // '&lt;script&gt;alert(&quot;XSS&quot;)&lt;/script&gt;'\n *\n * escapeHtmlChars('5 < 10 & 10 > 5')\n * // '5 &lt; 10 &amp; 10 &gt; 5'\n *\n * escapeHtmlChars('Say \"Hello\" & \\'Goodbye\\'')\n * // 'Say &quot;Hello&quot; &amp; &#39;Goodbye&#39;'\n *\n * // Edge cases\n * escapeHtmlChars('')                  // ''\n * escapeHtmlChars('No special chars')  // 'No special chars'\n * escapeHtmlChars('&lt;')              // '&amp;lt;' (escapes already-escaped)\n * ```\n *\n * @example\n * ```typescript\n * // Real-world: Safely display user comments in HTML\n * interface Comment {\n *   author: string\n *   content: string\n * }\n *\n * function renderComment(comment: Comment): string {\n *   const safeAuthor = escapeHtmlChars(comment.author)\n *   const safeContent = escapeHtmlChars(comment.content)\n *\n *   return `\n *     <div class=\"comment\">\n *       <strong>${safeAuthor}</strong>\n *       <p>${safeContent}</p>\n *     </div>\n *   `\n * }\n *\n * renderComment({\n *   author: '<script>alert(\"XSS\")</script>',\n *   content: 'Great post! <3'\n * })\n * // Safe HTML output with escaped tags\n * ```\n *\n * @example\n * ```typescript\n * // Real-world: Generate safe HTML attributes\n * function generateDataAttribute(key: string, value: string): string {\n *   const safeKey = toKebabCase(key)\n *   const safeValue = escapeHtmlChars(value)\n *   return `data-${safeKey}=\"${safeValue}\"`\n * }\n *\n * generateDataAttribute('userInput', '<script>alert(1)</script>')\n * // 'data-user-input=\"&lt;script&gt;alert(1)&lt;/script&gt;\"'\n *\n * generateDataAttribute('description', 'Product \"Premium\" & more')\n * // 'data-description=\"Product &quot;Premium&quot; &amp; more\"'\n * ```\n *\n * @example\n * ```typescript\n * // Real-world: Escape user search query for display\n * function displaySearchResults(query: string, results: any[]): string {\n *   const safeQuery = escapeHtmlChars(query)\n *\n *   return `\n *     <div class=\"search-results\">\n *       <h2>Results for: ${safeQuery}</h2>\n *       <p>${results.length} results found</p>\n *     </div>\n *   `\n * }\n *\n * displaySearchResults('<img src=x onerror=alert(1)>', [])\n * // Safe display: \"Results for: &lt;img src=x onerror=alert(1)&gt;\"\n * ```\n *\n * @example\n * ```typescript\n * // Real-world: CSV to HTML table with safe content\n * function csvRowToHtmlRow(cells: string[]): string {\n *   const safeCells = cells.map(cell => escapeHtmlChars(cell))\n *   const tdElements = safeCells.map(cell => `<td>${cell}</td>`).join('')\n *   return `<tr>${tdElements}</tr>`\n * }\n *\n * csvRowToHtmlRow(['Alice', '<script>evil</script>', '25'])\n * // '<tr><td>Alice</td><td>&lt;script&gt;evil&lt;/script&gt;</td><td>25</td></tr>'\n * ```\n *\n * @example\n * ```typescript\n * // Edge case: Preventing double-escaping\n * const userInput = 'Hello & Goodbye'\n * const escaped = escapeHtmlChars(userInput)\n * // 'Hello &amp; Goodbye'\n *\n * const doubleEscaped = escapeHtmlChars(escaped)\n * // 'Hello &amp;amp; Goodbye' ⚠️ Over-escaped!\n *\n * // Solution: Only escape once, track escaped state\n * interface SafeString {\n *   value: string\n *   isEscaped: boolean\n * }\n *\n * function safeEscape(str: string | SafeString): SafeString {\n *   if (typeof str === 'object' && str.isEscaped) {\n *     return str\n *   }\n *   const value = typeof str === 'string' ? str : str.value\n *   return { value: escapeHtmlChars(value), isEscaped: true }\n * }\n * ```\n *\n * @see {@link unescapeHtmlChars} for reversing HTML entity escaping\n * @see {@link sanitizeString} for basic string sanitization\n * @see {@link https://owasp.org/www-community/attacks/xss/ OWASP XSS Prevention Cheat Sheet}\n * @see {@link https://github.com/cure53/DOMPurify DOMPurify for production HTML sanitization}\n */\nexport const escapeHtmlChars = (str: string): string => {\n  const htmlEscapes: { [key: string]: string } = {\n    '&': '&amp;',\n    '<': '&lt;',\n    '>': '&gt;',\n    '\"': '&quot;',\n    \"'\": '&#39;',\n  }\n  return str.replace(/[&<>\"']/g, match => htmlEscapes[match])\n}\n\n/**\n * Converts HTML entities back to their original characters\n * @param str String containing HTML entities to unescape\n * @returns String with HTML entities converted back to original characters\n */\nexport const unescapeHtmlChars = (str: string): string => {\n  const htmlUnescapes: { [key: string]: string } = {\n    '&amp;': '&',\n    '&lt;': '<',\n    '&gt;': '>',\n    '&quot;': '\"',\n    '&#39;': \"'\",\n  }\n  return str.replace(/&amp;|&lt;|&gt;|&quot;|&#39;/g, match => htmlUnescapes[match])\n}\n\n/**\n * Checks if a path matches a wildcard pattern using dot notation\n *\n * Supports wildcards (*) to match any segment at that position.\n * Useful for configuration paths, routing, permissions, and feature flags.\n *\n * @param path - Dot-notation path to test (e.g., 'features.auth.enabled')\n * @param pattern - Pattern with optional wildcards (e.g., 'features.*', 'features.*.enabled')\n * @returns True if path matches pattern, false otherwise\n *\n * @example\n * ```typescript\n * // Exact match\n * matchPathPattern('features.auth', 'features.auth')  // true\n *\n * // Wildcard at end\n * matchPathPattern('features.auth', 'features.*')     // true\n * matchPathPattern('features.payments', 'features.*') // true\n * matchPathPattern('other.value', 'features.*')       // false\n *\n * // Wildcard in middle\n * matchPathPattern('features.auth.enabled', 'features.*.enabled')     // true\n * matchPathPattern('features.payments.enabled', 'features.*.enabled') // true\n * matchPathPattern('features.auth.disabled', 'features.*.enabled')    // false\n *\n * // Multiple wildcards\n * matchPathPattern('app.features.auth.oauth', 'app.*.*.oauth')        // true\n * matchPathPattern('app.features.auth.saml', 'app.*.*.oauth')         // false\n *\n * // No wildcard\n * matchPathPattern('exact.path.match', 'exact.path.match')            // true\n * matchPathPattern('exact.path.nomatch', 'exact.path.match')          // false\n * ```\n *\n * @example\n * ```typescript\n * // Real-world: Feature flag matching\n * const enabledFeatures = [\n *   'features.auth.oauth',\n *   'features.auth.saml',\n *   'features.payments.stripe',\n * ]\n *\n * const hasAuth = enabledFeatures.some(f =>\n *   matchPathPattern(f, 'features.auth.*')\n * ) // true\n *\n * const hasPayments = enabledFeatures.some(f =>\n *   matchPathPattern(f, 'features.payments.*')\n * ) // true\n *\n * // Permission matching\n * const userPermissions = ['admin.users.read', 'admin.users.write']\n * const canManageUsers = userPermissions.some(p =>\n *   matchPathPattern(p, 'admin.users.*')\n * ) // true\n * ```\n */\nexport function matchPathPattern(path: string, pattern: string): boolean {\n  if (!path || typeof path !== 'string' || !pattern || typeof pattern !== 'string') {\n    return false\n  }\n\n  // Exact match\n  if (path === pattern) {\n    return true\n  }\n\n  // No wildcard in pattern\n  if (!pattern.includes('*')) {\n    return path === pattern\n  }\n\n  // Convert pattern to regex\n  // Escape special regex characters except *\n  const regexPattern = pattern\n    .split('.')\n    .map(segment => {\n      if (segment === '*') {\n        return '[^.]+'\n      }\n      // Escape special regex chars\n      return segment.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&')\n    })\n    .join('\\\\.')\n\n  const regex = new RegExp(`^${regexPattern}$`)\n  return regex.test(path)\n}\n\n/**\n * Converts an environment variable key to dot-notation path\n *\n * Transforms uppercase underscore-separated env var names to lowercase\n * dot-notation paths. Optionally removes a prefix.\n *\n * Common convention: ENV_VAR_NAME → env.var.name\n *\n * @param envKey - Environment variable key (e.g., 'NX_FEATURES_AUTH', 'APP_DATABASE_HOST')\n * @param prefix - Optional prefix to remove (e.g., 'NX', 'APP'). Default: 'NX'\n * @returns Dot-notation path in lowercase\n *\n * @example\n * ```typescript\n * // Default prefix (NX)\n * envKeyToPath('NX_FEATURES_AUTH')           // 'features.auth'\n * envKeyToPath('NX_FEATURES_PAYMENTS')       // 'features.payments'\n * envKeyToPath('NX_DATABASE_HOST')           // 'database.host'\n *\n * // Custom prefix\n * envKeyToPath('APP_DATABASE_HOST', 'APP')   // 'database.host'\n * envKeyToPath('MY_CONFIG_VALUE', 'MY')      // 'config.value'\n *\n * // No prefix\n * envKeyToPath('DATABASE_HOST', '')          // 'database.host'\n * envKeyToPath('FEATURES_AUTH', '')          // 'features.auth'\n * ```\n *\n * @example\n * ```typescript\n * // Real-world: Parse environment variables to config object\n * const envVars = {\n *   'APP_DATABASE_HOST': 'localhost',\n *   'APP_DATABASE_PORT': '5432',\n *   'APP_CACHE_TTL': '3600',\n * }\n *\n * const config = {}\n * Object.entries(envVars).forEach(([key, value]) => {\n *   const path = envKeyToPath(key, 'APP')\n *   // Use with setDeepValue: setDeepValue(config, path, value)\n * })\n * // Paths: 'database.host', 'database.port', 'cache.ttl'\n * ```\n */\nexport function envKeyToPath(envKey: string, prefix: string = 'NX'): string {\n  if (!envKey || typeof envKey !== 'string') {\n    return ''\n  }\n\n  let key = envKey.trim()\n\n  // Remove prefix if provided and matches\n  if (prefix && key.startsWith(`${prefix}_`)) {\n    key = key.substring(prefix.length + 1)\n  }\n\n  // Convert to lowercase and replace underscores with dots\n  return key.toLowerCase().replace(/_/g, '.')\n}\n\n/**\n * Converts a dot-notation path to environment variable key format\n *\n * Transforms lowercase dot-notation paths to uppercase underscore-separated\n * env var names. Optionally adds a prefix.\n *\n * Common convention: env.var.name → ENV_VAR_NAME\n *\n * @param path - Dot-notation path (e.g., 'features.auth', 'database.host')\n * @param prefix - Optional prefix to add (e.g., 'NX', 'APP'). Default: 'NX'\n * @returns Environment variable key in uppercase\n *\n * @example\n * ```typescript\n * // Default prefix (NX)\n * pathToEnvKey('features.auth')              // 'NX_FEATURES_AUTH'\n * pathToEnvKey('features.payments')          // 'NX_FEATURES_PAYMENTS'\n * pathToEnvKey('database.host')              // 'NX_DATABASE_HOST'\n *\n * // Custom prefix\n * pathToEnvKey('database.host', 'APP')       // 'APP_DATABASE_HOST'\n * pathToEnvKey('config.value', 'MY')         // 'MY_CONFIG_VALUE'\n *\n * // No prefix\n * pathToEnvKey('database.host', '')          // 'DATABASE_HOST'\n * pathToEnvKey('features.auth', '')          // 'FEATURES_AUTH'\n * ```\n *\n * @example\n * ```typescript\n * // Real-world: Generate .env file from config object\n * const config = {\n *   database: { host: 'localhost', port: 5432 },\n *   cache: { ttl: 3600 }\n * }\n *\n * const envVars = [\n *   `${pathToEnvKey('database.host', 'APP')}=localhost`,\n *   `${pathToEnvKey('database.port', 'APP')}=5432`,\n *   `${pathToEnvKey('cache.ttl', 'APP')}=3600`,\n * ]\n * // Output:\n * // APP_DATABASE_HOST=localhost\n * // APP_DATABASE_PORT=5432\n * // APP_CACHE_TTL=3600\n * ```\n */\nexport function pathToEnvKey(path: string, prefix: string = 'NX'): string {\n  if (!path || typeof path !== 'string') {\n    return ''\n  }\n\n  // Convert dots to underscores and uppercase\n  const key = path.trim().toUpperCase().replace(/\\./g, '_')\n\n  // Return empty if path was just whitespace\n  if (key.length === 0) {\n    return ''\n  }\n\n  // Add prefix if provided\n  if (prefix && prefix.length > 0) {\n    return `${prefix.toUpperCase()}_${key}`\n  }\n\n  return key\n}\n"],"mappings":"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","names":[]}