utilitify-core 1.0.0

package/dist/chunk-BMQ6YPKV.js

@@ -0,0 +1,876 @@
+// src/string/case.ts
+function toCamelCase(str) {
+  if (!str || typeof str !== "string") return "";
+  const normalized = /^[A-Z_\s-]+$/.test(str.trim()) ? str.toLowerCase() : str;
+  return normalized.trim().replace(/[-_\s]+(.)?/g, (_, char) => char ? char.toUpperCase() : "").replace(/^[A-Z]/, (char) => char.toLowerCase());
+}
+function toPascalCase(str) {
+  if (!str || typeof str !== "string") return "";
+  const camel = toCamelCase(str);
+  return camel.charAt(0).toUpperCase() + camel.slice(1);
+}
+function toSnakeCase(str) {
+  if (!str || typeof str !== "string") return "";
+  return str.trim().replace(/([a-z])([A-Z])/g, "$1_$2").replace(/[-\s]+/g, "_").toLowerCase();
+}
+function toKebabCase(str) {
+  if (!str || typeof str !== "string") return "";
+  return str.trim().replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[_\s]+/g, "-").toLowerCase();
+}
+function toTitleCase(str) {
+  if (!str || typeof str !== "string") return "";
+  const smallWords = /* @__PURE__ */ new Set([
+    "a",
+    "an",
+    "and",
+    "as",
+    "at",
+    "but",
+    "by",
+    "for",
+    "in",
+    "nor",
+    "of",
+    "on",
+    "or",
+    "so",
+    "the",
+    "to",
+    "up",
+    "yet"
+  ]);
+  return str.toLowerCase().split(/\s+/).map((word, index) => {
+    if (index === 0) {
+      return word.charAt(0).toUpperCase() + word.slice(1);
+    }
+    if (smallWords.has(word)) {
+      return word;
+    }
+    return word.charAt(0).toUpperCase() + word.slice(1);
+  }).join(" ");
+}
+function toConstantCase(str) {
+  if (!str || typeof str !== "string") return "";
+  return toSnakeCase(str).toUpperCase();
+}
+function toSentenceCase(str) {
+  if (!str || typeof str !== "string") return "";
+  const lower = str.toLowerCase().trim();
+  return lower.charAt(0).toUpperCase() + lower.slice(1);
+}
+function toDotCase(str) {
+  if (!str || typeof str !== "string") return "";
+  return str.trim().replace(/([a-z])([A-Z])/g, "$1.$2").replace(/[-_\s]+/g, ".").toLowerCase();
+}
+function capitalize(str) {
+  if (!str || typeof str !== "string") return "";
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+function uncapitalize(str) {
+  if (!str || typeof str !== "string") return "";
+  return str.charAt(0).toLowerCase() + str.slice(1);
+}
+function swapCase(str) {
+  if (!str || typeof str !== "string") return "";
+  return [...str].map((char) => {
+    if (char === char.toUpperCase()) {
+      return char.toLowerCase();
+    }
+    return char.toUpperCase();
+  }).join("");
+}
+
+// src/string/slug.ts
+var TRANSLITERATION_MAP = {
+  // Latin Extended
+  "à": "a",
+  "á": "a",
+  "â": "a",
+  "ã": "a",
+  "ä": "a",
+  "å": "a",
+  "æ": "ae",
+  "ç": "c",
+  "è": "e",
+  "é": "e",
+  "ê": "e",
+  "ë": "e",
+  "ì": "i",
+  "í": "i",
+  "î": "i",
+  "ï": "i",
+  "ð": "d",
+  "ñ": "n",
+  "ò": "o",
+  "ó": "o",
+  "ô": "o",
+  "õ": "o",
+  "ö": "o",
+  "ø": "o",
+  "ù": "u",
+  "ú": "u",
+  "û": "u",
+  "ü": "u",
+  "ý": "y",
+  "ÿ": "y",
+  "þ": "th",
+  "ß": "ss",
+  // Polish
+  "ą": "a",
+  "ć": "c",
+  "ę": "e",
+  "ł": "l",
+  "ń": "n",
+  "ś": "s",
+  "ź": "z",
+  "ż": "z",
+  // Czech/Slovak
+  "č": "c",
+  "ď": "d",
+  "ě": "e",
+  "ň": "n",
+  "ř": "r",
+  "š": "s",
+  "ť": "t",
+  "ů": "u",
+  "ž": "z",
+  // German
+  "Ä": "Ae",
+  "Ö": "Oe",
+  "Ü": "Ue",
+  // Turkish
+  "ğ": "g",
+  "ı": "i",
+  "ş": "s",
+  // Romanian
+  "ă": "a",
+  "ș": "s",
+  "ț": "t",
+  // Symbols
+  "©": "c",
+  "®": "r",
+  "™": "tm",
+  "&": "and",
+  "@": "at"
+};
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  "a",
+  "an",
+  "and",
+  "are",
+  "as",
+  "at",
+  "be",
+  "by",
+  "for",
+  "from",
+  "has",
+  "he",
+  "in",
+  "is",
+  "it",
+  "its",
+  "of",
+  "on",
+  "that",
+  "the",
+  "to",
+  "was",
+  "were",
+  "will",
+  "with"
+]);
+var DEFAULT_OPTIONS = {
+  lowercase: true,
+  separator: "-",
+  transliterate: true,
+  removeStopWords: false
+};
+function toSlug(str, options = {}) {
+  if (!str || typeof str !== "string") return "";
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  let result = str.trim();
+  if (opts.transliterate) {
+    result = transliterate(result);
+  }
+  if (opts.lowercase) {
+    result = result.toLowerCase();
+  }
+  if (opts.removeStopWords) {
+    result = result.split(/\s+/).filter((word) => !STOP_WORDS.has(word.toLowerCase())).join(" ");
+  }
+  result = result.replace(/[^\w\s-]/g, "").replace(/[\s_]+/g, opts.separator || "-").replace(new RegExp(`${opts.separator}+`, "g"), opts.separator || "-").replace(new RegExp(`^${opts.separator}|${opts.separator}$`, "g"), "");
+  if (opts.maxLength && result.length > opts.maxLength) {
+    result = result.slice(0, opts.maxLength);
+    const lastSep = result.lastIndexOf(opts.separator || "-");
+    if (lastSep > opts.maxLength * 0.5) {
+      result = result.slice(0, lastSep);
+    }
+  }
+  return result;
+}
+function transliterate(str) {
+  if (!str || typeof str !== "string") return "";
+  return [...str].map((char) => {
+    const lower = char.toLowerCase();
+    if (TRANSLITERATION_MAP[lower]) {
+      const replacement = TRANSLITERATION_MAP[lower];
+      if (char === char.toUpperCase()) {
+        return replacement.charAt(0).toUpperCase() + replacement.slice(1);
+      }
+      return replacement;
+    }
+    return char;
+  }).join("");
+}
+function slugify(str) {
+  return toSlug(str);
+}
+function uniqueSlug(str, existingSlugs, options = {}) {
+  const existing = existingSlugs instanceof Set ? existingSlugs : new Set(existingSlugs);
+  const baseSlug = toSlug(str, options);
+  if (!existing.has(baseSlug)) {
+    return baseSlug;
+  }
+  let counter = 1;
+  let uniqueSlugStr = `${baseSlug}${options.separator || "-"}${counter}`;
+  while (existing.has(uniqueSlugStr)) {
+    counter++;
+    uniqueSlugStr = `${baseSlug}${options.separator || "-"}${counter}`;
+  }
+  return uniqueSlugStr;
+}
+function isValidSlug(str) {
+  if (!str || typeof str !== "string") return false;
+  return /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(str);
+}
+
+// src/string/mask.ts
+var DEFAULT_OPTIONS2 = {
+  maskChar: "*",
+  minLength: 4
+};
+function maskEmail(email, options = {}) {
+  if (!email || typeof email !== "string") return "";
+  const [localPart, domain] = email.split("@");
+  if (!localPart || !domain) return email;
+  const maskChar = options.maskChar || "*";
+  const visibleStart = options.visibleStart ?? 1;
+  if (localPart.length <= visibleStart) {
+    return `${maskChar.repeat(3)}@${domain}`;
+  }
+  const visible = localPart.slice(0, visibleStart);
+  const masked = maskChar.repeat(Math.min(localPart.length - visibleStart, 5));
+  return `${visible}${masked}@${domain}`;
+}
+function maskPhone(phone, options = {}) {
+  if (!phone || typeof phone !== "string") return "";
+  const maskChar = options.maskChar || "*";
+  const visibleStart = options.visibleStart ?? 3;
+  const visibleEnd = options.visibleEnd ?? 4;
+  const digits = phone.replace(/\D/g, "");
+  if (digits.length < visibleStart + visibleEnd) {
+    return phone;
+  }
+  let result = "";
+  let digitIndex = 0;
+  for (const char of phone) {
+    if (/\d/.test(char)) {
+      if (digitIndex < visibleStart || digitIndex >= digits.length - visibleEnd) {
+        result += char;
+      } else {
+        result += maskChar;
+      }
+      digitIndex++;
+    } else {
+      result += char;
+    }
+  }
+  return result;
+}
+function maskCreditCard(card, options = {}) {
+  if (!card || typeof card !== "string") return "";
+  const maskChar = options.maskChar || "*";
+  const visibleEnd = options.visibleEnd ?? 4;
+  const digits = card.replace(/\D/g, "");
+  if (digits.length < visibleEnd + 1) {
+    return card;
+  }
+  let result = "";
+  let digitIndex = 0;
+  for (const char of card) {
+    if (/\d/.test(char)) {
+      if (digitIndex >= digits.length - visibleEnd) {
+        result += char;
+      } else {
+        result += maskChar;
+      }
+      digitIndex++;
+    } else {
+      result += char;
+    }
+  }
+  return result;
+}
+function maskString(str, options = {}) {
+  if (!str || typeof str !== "string") return "";
+  const opts = { ...DEFAULT_OPTIONS2, ...options };
+  if (str.length < (opts.minLength || 4)) {
+    return str;
+  }
+  const visibleStart = opts.visibleStart ?? 0;
+  const visibleEnd = opts.visibleEnd ?? 0;
+  if (str.length <= visibleStart + visibleEnd) {
+    return str;
+  }
+  const start = str.slice(0, visibleStart);
+  const end = str.slice(-visibleEnd || str.length);
+  const maskLength = str.length - visibleStart - visibleEnd;
+  return `${start}${(opts.maskChar || "*").repeat(maskLength)}${visibleEnd > 0 ? end : ""}`;
+}
+function maskIP(ip) {
+  if (!ip || typeof ip !== "string") return "";
+  const parts = ip.split(".");
+  if (parts.length !== 4) return ip;
+  return `${parts[0]}.${parts[1]}.***.***`;
+}
+function maskName(name) {
+  if (!name || typeof name !== "string") return "";
+  return name.split(" ").map((part) => {
+    if (part.length <= 1) return part;
+    return part[0] + "*".repeat(Math.min(part.length - 1, 3));
+  }).join(" ");
+}
+
+// src/string/random.ts
+var CHAR_SETS = {
+  uppercase: "ABCDEFGHIJKLMNOPQRSTUVWXYZ",
+  uppercaseUnambiguous: "ABCDEFGHJKLMNPQRSTUVWXYZ",
+  lowercase: "abcdefghijklmnopqrstuvwxyz",
+  lowercaseUnambiguous: "abcdefghjkmnpqrstuvwxyz",
+  numbers: "0123456789",
+  numbersUnambiguous: "23456789",
+  symbols: "!@#$%^&*()_+-=[]{}|;:,.<>?"
+};
+var DEFAULT_PASSWORD_OPTIONS = {
+  length: 16,
+  uppercase: true,
+  lowercase: true,
+  numbers: true,
+  symbols: true,
+  excludeAmbiguous: false,
+  minOfEachType: 1
+};
+function generatePassword(options = {}) {
+  const opts = { ...DEFAULT_PASSWORD_OPTIONS, ...options };
+  const length = Math.max(4, opts.length || 16);
+  let charset = "";
+  const requiredChars = [];
+  if (opts.uppercase) {
+    const chars = opts.excludeAmbiguous ? CHAR_SETS.uppercaseUnambiguous : CHAR_SETS.uppercase;
+    charset += chars;
+    for (let i = 0; i < (opts.minOfEachType || 1); i++) {
+      requiredChars.push(getRandomChar(chars));
+    }
+  }
+  if (opts.lowercase) {
+    const chars = opts.excludeAmbiguous ? CHAR_SETS.lowercaseUnambiguous : CHAR_SETS.lowercase;
+    charset += chars;
+    for (let i = 0; i < (opts.minOfEachType || 1); i++) {
+      requiredChars.push(getRandomChar(chars));
+    }
+  }
+  if (opts.numbers) {
+    const chars = opts.excludeAmbiguous ? CHAR_SETS.numbersUnambiguous : CHAR_SETS.numbers;
+    charset += chars;
+    for (let i = 0; i < (opts.minOfEachType || 1); i++) {
+      requiredChars.push(getRandomChar(chars));
+    }
+  }
+  if (opts.symbols) {
+    charset += CHAR_SETS.symbols;
+    for (let i = 0; i < (opts.minOfEachType || 1); i++) {
+      requiredChars.push(getRandomChar(CHAR_SETS.symbols));
+    }
+  }
+  if (opts.customChars) {
+    charset += opts.customChars;
+  }
+  if (!charset) {
+    charset = CHAR_SETS.lowercase + CHAR_SETS.numbers;
+  }
+  const passwordChars = [...requiredChars];
+  while (passwordChars.length < length) {
+    passwordChars.push(getRandomChar(charset));
+  }
+  if (passwordChars.length > length) {
+    passwordChars.length = length;
+  }
+  return shuffleArray(passwordChars).join("");
+}
+function generateRandomString(length = 16, charset = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789") {
+  if (length <= 0) return "";
+  if (!charset) charset = "abcdefghijklmnopqrstuvwxyz0123456789";
+  let result = "";
+  for (let i = 0; i < length; i++) {
+    result += getRandomChar(charset);
+  }
+  return result;
+}
+function generateOTP(length = 6) {
+  return generateRandomString(length, "0123456789");
+}
+function generatePassphrase(wordCount = 4, separator = "-") {
+  const words = [
+    // Nature & Weather (32)
+    "apple",
+    "banana",
+    "cherry",
+    "dragon",
+    "eagle",
+    "forest",
+    "garden",
+    "harbor",
+    "island",
+    "jungle",
+    "kitten",
+    "lemon",
+    "mountain",
+    "nature",
+    "ocean",
+    "planet",
+    "river",
+    "sunset",
+    "thunder",
+    "umbrella",
+    "violet",
+    "window",
+    "yellow",
+    "zebra",
+    "anchor",
+    "bridge",
+    "castle",
+    "dolphin",
+    "ember",
+    "falcon",
+    "glacier",
+    "horizon",
+    // Objects & Places (32)
+    "ivory",
+    "jasmine",
+    "kingdom",
+    "lantern",
+    "meadow",
+    "nebula",
+    "orchid",
+    "phoenix",
+    "quartz",
+    "rainbow",
+    "shadow",
+    "tornado",
+    "unicorn",
+    "volcano",
+    "whisper",
+    "crystal",
+    "diamond",
+    "eclipse",
+    "feather",
+    "granite",
+    "helmet",
+    "jigsaw",
+    "kayak",
+    "ladder",
+    "magnet",
+    "needle",
+    "orange",
+    "panther",
+    "puzzle",
+    "rabbit",
+    "saddle",
+    "tablet",
+    // Actions & Concepts (32)
+    "beacon",
+    "candle",
+    "dancer",
+    "flight",
+    "golden",
+    "hunter",
+    "insect",
+    "jacket",
+    "keeper",
+    "leader",
+    "master",
+    "native",
+    "offset",
+    "parade",
+    "radius",
+    "sailor",
+    "target",
+    "uplift",
+    "vector",
+    "walker",
+    "zenith",
+    "arctic",
+    "basket",
+    "camera",
+    "dinner",
+    "escape",
+    "finger",
+    "guitar",
+    "hammer",
+    "ignite",
+    "jacket",
+    "kernel",
+    // Animals (32)
+    "lizard",
+    "monkey",
+    "narwhal",
+    "oyster",
+    "parrot",
+    "quiver",
+    "racoon",
+    "salmon",
+    "turtle",
+    "urchin",
+    "viking",
+    "walrus",
+    "jaguar",
+    "badger",
+    "condor",
+    "donkey",
+    "ferret",
+    "gopher",
+    "hornet",
+    "iguana",
+    "jackal",
+    "kitten",
+    "llama",
+    "marmot",
+    "newt",
+    "osprey",
+    "panda",
+    "quail",
+    "raven",
+    "spider",
+    "toucan",
+    "vampire",
+    // Food & Drinks (32)
+    "waffle",
+    "yogurt",
+    "almond",
+    "butter",
+    "celery",
+    "donut",
+    "endive",
+    "fennel",
+    "ginger",
+    "hazel",
+    "icecap",
+    "jelly",
+    "kimchi",
+    "lentil",
+    "mango",
+    "noodle",
+    "olive",
+    "papaya",
+    "quinoa",
+    "radish",
+    "sesame",
+    "tomato",
+    "umami",
+    "vanilla",
+    "wasabi",
+    "xylose",
+    "yeast",
+    "zephyr",
+    "acorn",
+    "breeze",
+    "clover",
+    "dahlia",
+    // Colors & Materials (32)
+    "silver",
+    "bronze",
+    "copper",
+    "purple",
+    "maroon",
+    "indigo",
+    "scarlet",
+    "crimson",
+    "velvet",
+    "cotton",
+    "denim",
+    "linen",
+    "marble",
+    "bamboo",
+    "cedar",
+    "maple",
+    "willow",
+    "birch",
+    "coral",
+    "pearl",
+    "amber",
+    "topaz",
+    "garnet",
+    "onyx",
+    "jasper",
+    "opal",
+    "ruby",
+    "sapphire",
+    "cobalt",
+    "chrome",
+    "steel",
+    "brass",
+    // Technology & Science (32)
+    "binary",
+    "cipher",
+    "domain",
+    "engine",
+    "filter",
+    "gadget",
+    "hybrid",
+    "index",
+    "joystick",
+    "kernel",
+    "lambda",
+    "module",
+    "neural",
+    "output",
+    "pixel",
+    "quantum",
+    "router",
+    "sensor",
+    "toggle",
+    "upload",
+    "vertex",
+    "widget",
+    "system",
+    "crypto",
+    "buffer",
+    "cache",
+    "delta",
+    "epoch",
+    "format",
+    "global",
+    "header",
+    "input",
+    // Misc & Abstract (32)
+    "action",
+    "balance",
+    "center",
+    "design",
+    "energy",
+    "focus",
+    "growth",
+    "health",
+    "impact",
+    "justice",
+    "knight",
+    "legacy",
+    "motion",
+    "nexus",
+    "origin",
+    "prime",
+    "quest",
+    "reward",
+    "spirit",
+    "talent",
+    "unity",
+    "vision",
+    "wisdom",
+    "expert",
+    "factor",
+    "giant",
+    "humble",
+    "jovial",
+    "kinetic",
+    "lunar",
+    "metric",
+    "novel"
+  ];
+  const result = [];
+  for (let i = 0; i < wordCount; i++) {
+    result.push(words[getSecureRandomIndex(words.length)]);
+  }
+  return result.join(separator);
+}
+function generateHexString(length = 16) {
+  return generateRandomString(length * 2, "0123456789abcdef");
+}
+function generateBase64String(length = 16) {
+  const charset = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+  return generateRandomString(length, charset);
+}
+function generateUrlSafeString(length = 16) {
+  const charset = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+  return generateRandomString(length, charset);
+}
+function getSecureRandomIndex(max) {
+  if (typeof globalThis.crypto?.getRandomValues === "function") {
+    const array = new Uint32Array(1);
+    globalThis.crypto.getRandomValues(array);
+    return array[0] % max;
+  }
+  const isProduction = typeof process !== "undefined" && process.env?.NODE_ENV === "production";
+  if (isProduction) {
+    throw new Error(
+      "[utilitify] Web Crypto API not available. Cannot generate secure random values in production. Ensure you are running in an environment with crypto support (Node.js 15+, modern browsers)."
+    );
+  }
+  console.warn(
+    "[utilitify] Using Math.random() fallback - NOT CRYPTOGRAPHICALLY SECURE. This is only acceptable for development/testing. Install with crypto support for production."
+  );
+  return Math.floor(Math.random() * max);
+}
+function getRandomChar(charset) {
+  return charset[getSecureRandomIndex(charset.length)];
+}
+function shuffleArray(array) {
+  const result = [...array];
+  for (let i = result.length - 1; i > 0; i--) {
+    const j = getSecureRandomIndex(i + 1);
+    [result[i], result[j]] = [result[j], result[i]];
+  }
+  return result;
+}
+
+// src/string/truncate.ts
+var DEFAULT_OPTIONS3 = {
+  suffix: "...",
+  preserveWords: true,
+  position: "end",
+  graphemeAware: false
+};
+function truncate(str, length, options = {}) {
+  if (!str || typeof str !== "string") return "";
+  if (length < 0) {
+    throw new RangeError("maxLength must be a non-negative number");
+  }
+  if (length === 0) return "";
+  const opts = { ...DEFAULT_OPTIONS3, ...options };
+  const suffix = opts.suffix ?? "...";
+  const strLength = opts.graphemeAware ? getGraphemeLength(str) : str.length;
+  if (strLength <= length) return str;
+  const maxContentLength = length - (opts.graphemeAware ? getGraphemeLength(suffix) : suffix.length);
+  if (maxContentLength <= 0) {
+    return opts.graphemeAware ? sliceGraphemes(suffix, 0, length) : suffix.slice(0, length);
+  }
+  switch (opts.position) {
+    case "start":
+      return opts.graphemeAware ? truncateStartGrapheme(str, maxContentLength, suffix) : truncateStart(str, maxContentLength, suffix);
+    case "middle":
+      return opts.graphemeAware ? truncateMiddleGrapheme(str, length, suffix) : truncateMiddle(str, length, suffix);
+    default:
+      return opts.graphemeAware ? truncateEndGrapheme(str, maxContentLength, suffix, opts.preserveWords ?? true) : truncateEnd(str, maxContentLength, suffix, opts.preserveWords ?? true);
+  }
+}
+function truncateEnd(str, maxContentLength, suffix, preserveWords) {
+  let truncated = str.slice(0, maxContentLength);
+  if (preserveWords) {
+    const lastSpace = truncated.lastIndexOf(" ");
+    if (lastSpace > maxContentLength * 0.3) {
+      truncated = truncated.slice(0, lastSpace);
+    }
+  }
+  truncated = truncated.replace(/[\s.,!?;:]+$/, "");
+  return truncated + suffix;
+}
+function truncateStart(str, maxContentLength, suffix) {
+  return suffix + str.slice(-maxContentLength);
+}
+function truncateMiddle(str, totalLength, suffix) {
+  if (str.length <= totalLength) return str;
+  const contentLength = totalLength - suffix.length;
+  if (contentLength <= 0) return suffix.slice(0, totalLength);
+  const startLength = Math.ceil(contentLength / 2);
+  const endLength = Math.floor(contentLength / 2);
+  return str.slice(0, startLength) + suffix + str.slice(-endLength);
+}
+function truncateWords(str, wordCount, suffix = "...") {
+  if (!str || typeof str !== "string") return "";
+  if (wordCount <= 0) return "";
+  const words = str.trim().split(/\s+/);
+  if (words.length <= wordCount) return str;
+  return words.slice(0, wordCount).join(" ") + suffix;
+}
+function truncateSentences(str, sentenceCount, suffix = "") {
+  if (!str || typeof str !== "string") return "";
+  if (sentenceCount <= 0) return "";
+  const sentences = str.match(/[^.!?]+[.!?]+/g) || [];
+  if (sentences.length <= sentenceCount) return str;
+  return sentences.slice(0, sentenceCount).join("").trim() + suffix;
+}
+function truncateFilename(filename, length, separator = "...") {
+  if (!filename || typeof filename !== "string") return "";
+  if (filename.length <= length) return filename;
+  const lastDot = filename.lastIndexOf(".");
+  if (lastDot === -1 || lastDot === 0) {
+    return truncateMiddle(filename, length, separator);
+  }
+  const name = filename.slice(0, lastDot);
+  const ext = filename.slice(lastDot);
+  const availableForName = length - ext.length - separator.length;
+  if (availableForName <= 0) {
+    return truncateMiddle(filename, length, separator);
+  }
+  const startLength = Math.ceil(availableForName / 2);
+  const endLength = Math.floor(availableForName / 2);
+  return name.slice(0, startLength) + separator + name.slice(-endLength) + ext;
+}
+function ellipsis(str, length) {
+  return truncate(str, length, { suffix: "…", preserveWords: false });
+}
+function truncateHtml(html, length, suffix = "...") {
+  if (!html || typeof html !== "string") return "";
+  const text = html.replace(/<[^>]*>/g, " ").replace(/\s+/g, " ").trim();
+  return truncate(text, length, { suffix, preserveWords: true });
+}
+function needsTruncation(str, length) {
+  if (!str || typeof str !== "string") return false;
+  return str.length > length;
+}
+function getGraphemeLength(str) {
+  if (!str) return 0;
+  if (typeof Intl !== "undefined" && "Segmenter" in Intl) {
+    const segmenter = new Intl.Segmenter("en", { granularity: "grapheme" });
+    return [...segmenter.segment(str)].length;
+  }
+  return [...str].length;
+}
+function sliceGraphemes(str, start, end) {
+  if (!str) return "";
+  if (typeof Intl !== "undefined" && "Segmenter" in Intl) {
+    const segmenter = new Intl.Segmenter("en", { granularity: "grapheme" });
+    const segments = [...segmenter.segment(str)].map((s) => s.segment);
+    return segments.slice(start, end).join("");
+  }
+  return [...str].slice(start, end).join("");
+}
+function truncateEndGrapheme(str, maxContentLength, suffix, preserveWords) {
+  let truncated = sliceGraphemes(str, 0, maxContentLength);
+  if (preserveWords) {
+    const lastSpace = truncated.lastIndexOf(" ");
+    if (lastSpace > maxContentLength * 0.3) {
+      truncated = truncated.slice(0, lastSpace);
+    }
+  }
+  truncated = truncated.replace(/[\s.,!?;:]+$/, "");
+  return truncated + suffix;
+}
+function truncateStartGrapheme(str, maxContentLength, suffix) {
+  const graphemeLength = getGraphemeLength(str);
+  return suffix + sliceGraphemes(str, graphemeLength - maxContentLength);
+}
+function truncateMiddleGrapheme(str, totalLength, suffix) {
+  const graphemeLength = getGraphemeLength(str);
+  if (graphemeLength <= totalLength) return str;
+  const suffixLength = getGraphemeLength(suffix);
+  const contentLength = totalLength - suffixLength;
+  if (contentLength <= 0) return sliceGraphemes(suffix, 0, totalLength);
+  const startLength = Math.ceil(contentLength / 2);
+  const endLength = Math.floor(contentLength / 2);
+  return sliceGraphemes(str, 0, startLength) + suffix + sliceGraphemes(str, graphemeLength - endLength);
+}
+
+export { capitalize, ellipsis, generateBase64String, generateHexString, generateOTP, generatePassphrase, generatePassword, generateRandomString, generateUrlSafeString, isValidSlug, maskCreditCard, maskEmail, maskIP, maskName, maskPhone, maskString, needsTruncation, slugify, swapCase, toCamelCase, toConstantCase, toDotCase, toKebabCase, toPascalCase, toSentenceCase, toSlug, toSnakeCase, toTitleCase, transliterate, truncate, truncateFilename, truncateHtml, truncateSentences, truncateWords, uncapitalize, uniqueSlug };
+//# sourceMappingURL=chunk-BMQ6YPKV.js.map
+//# sourceMappingURL=chunk-BMQ6YPKV.js.map