@visulima/string 2.0.6 → 3.0.0-alpha.10

package/dist/case/sentence-case.js

@@ -1,10 +1,10 @@
-import { R as RE_FAST_ANSI } from '../packem_shared/constants-CTzC6Gjg.js';
+import { R as RE_FAST_ANSI } from '../packem_shared/constants-BsZS5f0z.js';
 import LRUCache from '../packem_shared/LRUCache-3r3SovvR.js';
 import { splitByCase } from './split-by-case.js';
 import upperFirst from './upper-first.js';
 import { g as generateCacheKey } from '../packem_shared/generate-cache-key-DdayDfjV.js';
-import joinSegments from '../packem_shared/joinSegments-CuU8RGpP.js';
-import { n as normalizeGermanEszett } from '../packem_shared/normalize-german-eszett-DEB8-ZPT.js';
+import joinSegments from '../packem_shared/joinSegments-CvxSgKz0.js';
+import { n as normalizeGermanEszett } from '../packem_shared/normalize-german-eszett-4p3yKEzn.js';
 
 const defaultCacheStore = new LRUCache(1e3);
 const sentenceCase = (value, options) => {
@@ -35,13 +35,13 @@ const sentenceCase = (value, options) => {
       if (options?.handleAnsi && RE_FAST_ANSI.test(word)) {
         return word;
       }
-      word = options?.locale?.startsWith("de") ? normalizeGermanEszett(word) : word;
-      word = options?.locale ? word.toLocaleLowerCase(options.locale) : word.toLowerCase();
+      const normalized = options?.locale?.startsWith("de") ? normalizeGermanEszett(word) : word;
+      const lowered = options?.locale ? normalized.toLocaleLowerCase(options.locale) : normalized.toLowerCase();
       if (firstWord) {
         firstWord = false;
-        return upperFirst(word, options);
+        return upperFirst(lowered, options);
       }
-      return word;
+      return lowered;
     }),
     " "
   );

package/dist/case/snake-case.d.ts

@@ -1,7 +1,5 @@
-import { C as CaseOptions, h as SnakeCase } from '../packem_shared/types-CfPsw9ix.js';
-import '../packem_shared/types-Daae0hGf.js';
-import '../packem_shared/lru-cache-B_t27XwI.js';
-
+import { C as CaseOptions, h as SnakeCase } from "../packem_shared/types.d-DfgbcNKh.js";
+import "../packem_shared/types.d-BVNv675q.js";
+import "../packem_shared/lru-cache.d-BsP6kbVJ.js";
 declare const snakeCase: <T extends string = string>(value?: T, options?: CaseOptions) => SnakeCase<T>;
-
 export { snakeCase as default };

package/dist/case/split-by-case.d.ts

@@ -1,17 +1,14 @@
-import { L as LocaleOptions, i as SplitByCase } from '../packem_shared/types-CfPsw9ix.js';
-import '../packem_shared/types-Daae0hGf.js';
-import '../packem_shared/lru-cache-B_t27XwI.js';
-
+import { L as LocaleOptions, i as SplitByCase } from "../packem_shared/types.d-DfgbcNKh.js";
+import "../packem_shared/types.d-BVNv675q.js";
+import "../packem_shared/lru-cache.d-BsP6kbVJ.js";
 interface SplitOptions extends LocaleOptions {
-    handleAnsi?: boolean;
-    handleEmoji?: boolean;
-    knownAcronyms?: ReadonlyArray<string>;
-    normalize?: boolean;
-    separators?: ReadonlyArray<string> | RegExp;
-    stripAnsi?: boolean;
-    stripEmoji?: boolean;
+  handleAnsi?: boolean;
+  handleEmoji?: boolean;
+  knownAcronyms?: ReadonlyArray<string>;
+  normalize?: boolean;
+  separators?: ReadonlyArray<string> | RegExp;
+  stripAnsi?: boolean;
+  stripEmoji?: boolean;
 }
 declare const splitByCase: <T extends string = string>(input: T, options?: SplitOptions) => SplitByCase<T>;
-
-export { splitByCase };
-export type { SplitOptions };
+export { SplitOptions, splitByCase };

package/dist/case/split-by-case.js

@@ -20,16 +20,17 @@ const __cjs_getBuiltinModule = (module) => {
 const {
   stripVTControlCharacters
 } = __cjs_getBuiltinModule("node:util");
-import { j as RE_EMOJI, s as stripEmoji, k as RE_SEPARATORS, R as RE_FAST_ANSI, l as RE_CYRILLIC, m as RE_LATIN, n as RE_GREEK, o as RE_GREEK_LATIN_SPLIT, p as RE_UZBEK_LATIN_MODIFIER, q as RE_KATAKANA, r as RE_KANJI, t as RE_HIRAGANA, u as RE_HANGUL, v as RE_HEBREW, w as RE_ARABIC, x as RE_DEVANAGARI, y as RE_BENGALI, z as RE_GUJARATI, A as RE_GURMUKHI, B as RE_KANNADA, C as RE_TAMIL, D as RE_TELUGU, E as RE_MALAYALAM, F as RE_SINHALA, G as RE_THAI, H as RE_LAO, I as RE_TIBETAN, J as RE_MYANMAR, K as RE_ETHIOPIC, L as RE_KHMER, M as RE_ORIYA } from '../packem_shared/constants-CTzC6Gjg.js';
+import { i as RE_EMOJI, s as stripEmoji, R as RE_FAST_ANSI, l as RE_CYRILLIC, m as RE_LATIN, n as RE_GREEK, o as RE_GREEK_LATIN_SPLIT, p as RE_UZBEK_LATIN_MODIFIER, q as RE_KATAKANA, r as RE_KANJI, t as RE_HIRAGANA, u as RE_HANGUL, v as RE_HEBREW, w as RE_ARABIC, x as RE_SEPARATORS, y as RE_DEVANAGARI, z as RE_BENGALI, A as RE_GUJARATI, B as RE_GURMUKHI, C as RE_KANNADA, D as RE_TAMIL, E as RE_TELUGU, F as RE_MALAYALAM, G as RE_SINHALA, H as RE_THAI, I as RE_LAO, J as RE_TIBETAN, K as RE_MYANMAR, L as RE_ETHIOPIC, M as RE_KHMER, N as RE_ORIYA } from '../packem_shared/constants-BsZS5f0z.js';
 import LRUCache from '../packem_shared/LRUCache-3r3SovvR.js';
 
 const regexCache = new LRUCache(1e3);
+const RE_ESCAPE_SPECIAL = /[.*+?^${}()|[\]\\]/g;
 const getSeparatorsRegex = (separators) => {
   const key = separators.join("");
   if (regexCache.has(key)) {
     return regexCache.get(key);
   }
-  const pattern = separators.map((s) => s.replaceAll(/[.*+?^${}()|[\]\\]/g, String.raw`\$&`)).join("|");
+  const pattern = separators.map((s) => s.replaceAll(RE_ESCAPE_SPECIAL, String.raw`\$&`)).join("|");
   const regex = new RegExp(pattern, "g");
   regexCache.set(key, regex);
   return regex;
@@ -53,6 +54,7 @@ const splitByEmoji = (text) => {
   return segments.filter(Boolean);
 };
 
+const RE_SLOVENIAN_SPECIAL = /[ČŠŽĐ]/i;
 const isUpperCode = new Uint8Array(128);
 const isLowerCode = new Uint8Array(128);
 const isDigitCode = new Uint8Array(128);
@@ -69,8 +71,9 @@ const handleScriptTransitions = (s, scriptDetectors, caseSensitive, locale, cust
     return [];
   }
   let hasDetectedScript = false;
-  for (const detector of Object.values(scriptDetectors)) {
-    if (detector(s[0])) {
+  const detectorValues = Object.values(scriptDetectors);
+  for (const detectorValue of detectorValues) {
+    if (detectorValue(s[0])) {
       hasDetectedScript = true;
       break;
     }
@@ -82,7 +85,9 @@ const handleScriptTransitions = (s, scriptDetectors, caseSensitive, locale, cust
   const result = [];
   let currentSegment = chars[0];
   let previousType = "other";
-  for (const [type, detector] of Object.entries(scriptDetectors)) {
+  const scriptEntries = Object.entries(scriptDetectors);
+  for (const scriptEntry of scriptEntries) {
+    const [type, detector] = scriptEntry;
     if (detector(chars[0])) {
       previousType = type;
       break;
@@ -92,7 +97,8 @@ const handleScriptTransitions = (s, scriptDetectors, caseSensitive, locale, cust
   for (let index = 1; index < chars.length; index++) {
     const char = chars[index];
     let currentType = "other";
-    for (const [type, detector] of Object.entries(scriptDetectors)) {
+    for (const scriptEntry of scriptEntries) {
+      const [type, detector] = scriptEntry;
       if (detector(char)) {
         currentType = type;
         break;
@@ -126,6 +132,18 @@ const handleScriptTransitions = (s, scriptDetectors, caseSensitive, locale, cust
   }
   return result.length > 0 ? result : [s];
 };
+const detectAndProcessAcronym = (s, start, knownAcronyms, tokens) => {
+  if (knownAcronyms.size === 0) {
+    return start;
+  }
+  for (const acronym of knownAcronyms) {
+    if (s.startsWith(acronym, start)) {
+      tokens.push(acronym);
+      return start + acronym.length;
+    }
+  }
+  return start;
+};
 const splitCamelCaseFast = (s, knownAcronyms = /* @__PURE__ */ new Set()) => {
   if (s.length === 0) {
     return [];
@@ -137,21 +155,14 @@ const splitCamelCaseFast = (s, knownAcronyms = /* @__PURE__ */ new Set()) => {
   const tokens = [];
   const width = s.length;
   for (let index = 1; index < width; index++) {
+    const newStart = detectAndProcessAcronym(s, start, knownAcronyms, tokens);
+    if (newStart !== start) {
+      start = newStart;
+      index = start - 1;
+      continue;
+    }
     const previousCode = s.codePointAt(index - 1);
     const currentCode = s.codePointAt(index);
-    if (knownAcronyms.size > 0) {
-      for (const acronym of knownAcronyms) {
-        if (s.startsWith(acronym, start)) {
-          tokens.push(acronym);
-          start += acronym.length;
-          index = start - 1;
-          break;
-        }
-      }
-      if (index < start) {
-        continue;
-      }
-    }
     const previousIsUpper = previousCode && previousCode < 128 && isUpper(previousCode);
     const currentIsUpper = currentCode && currentCode < 128 && isUpper(currentCode);
     const previousIsLower = previousCode && previousCode < 128 && isLower(previousCode);
@@ -255,11 +266,26 @@ const splitCamelCaseLocale = (s, locale, knownAcronyms) => {
     const width_2 = chars2.length;
     const result2 = [];
     let currentSegment2 = chars2[0];
-    let previousType = RE_CYRILLIC.test(chars2[0]) ? 1 : RE_LATIN.test(chars2[0]) ? 2 : 0;
-    let previousIsUpper2 = chars2[0] === chars2[0].toLocaleUpperCase(locale);
+    const firstChar = chars2[0];
+    let previousType;
+    if (RE_CYRILLIC.test(firstChar)) {
+      previousType = 1;
+    } else if (RE_LATIN.test(firstChar)) {
+      previousType = 2;
+    } else {
+      previousType = 0;
+    }
+    let previousIsUpper2 = firstChar === firstChar.toLocaleUpperCase(locale);
     for (let index = 1; index < width_2; index++) {
       const char = chars2[index];
-      const currentType = RE_CYRILLIC.test(char) ? 1 : RE_LATIN.test(char) ? 2 : 0;
+      let currentType;
+      if (RE_CYRILLIC.test(char)) {
+        currentType = 1;
+      } else if (RE_LATIN.test(char)) {
+        currentType = 2;
+      } else {
+        currentType = 0;
+      }
       const isUpperCaseChar = char === char.toLocaleUpperCase(locale);
       if (previousType !== currentType && (previousType === 1 || previousType === 2) && (currentType === 1 || currentType === 2) || currentType === previousType && !previousIsUpper2 && isUpperCaseChar) {
         result2.push(currentSegment2);
@@ -288,28 +314,36 @@ const splitCamelCaseLocale = (s, locale, knownAcronyms) => {
     if (!RE_GREEK.test(s) && !RE_LATIN.test(s)) {
       return [s];
     }
-    const parts = s.match(RE_GREEK_LATIN_SPLIT) ?? [s];
+    const parts = [];
+    RE_GREEK_LATIN_SPLIT.lastIndex = 0;
+    let greekExecMatch;
+    while ((greekExecMatch = RE_GREEK_LATIN_SPLIT.exec(s)) !== null) {
+      parts.push(greekExecMatch[0]);
+    }
+    if (parts.length === 0) {
+      parts.push(s);
+    }
     const result2 = [];
     const width = parts.length;
     if (width === 1) {
       const part = parts[0];
       if (!part || !RE_GREEK.test(part[0]) || part.length === 1) {
-        return [part || s];
+        return [part ?? s];
       }
     }
-    for (const part of parts) {
-      if (!part) {
+    for (const greekPart of parts) {
+      if (!greekPart) {
         continue;
       }
-      if (!RE_GREEK.test(part[0]) || part.length === 1) {
-        result2.push(part);
+      if (!RE_GREEK.test(greekPart[0]) || greekPart.length === 1) {
+        result2.push(greekPart);
         continue;
       }
-      const partLength = part.length;
-      let word = part[0];
-      let previousIsUpper2 = part[0] === part[0].toLocaleUpperCase(locale);
+      const partLength = greekPart.length;
+      let word = greekPart[0];
+      let previousIsUpper2 = greekPart[0] === greekPart[0].toLocaleUpperCase(locale);
       for (let index = 1; index < partLength; index++) {
-        const char = part[index];
+        const char = greekPart[index];
         const isUpperCaseChar = char === char.toLocaleUpperCase(locale);
         if (!previousIsUpper2 && isUpperCaseChar) {
           result2.push(word);
@@ -347,9 +381,10 @@ const splitCamelCaseLocale = (s, locale, knownAcronyms) => {
         // latin -> japanese
       );
       const result2 = [];
-      for (const segment of baseSegments) {
+      for (const baseSegment of baseSegments) {
+        const segment = baseSegment;
         if (segment.length === 1 && particles.has(segment) && result2.length > 0) {
-          result2[result2.length - 1] += segment;
+          result2[result2.length - 1] = result2.at(-1) + segment;
         } else {
           result2.push(segment);
         }
@@ -374,7 +409,7 @@ const splitCamelCaseLocale = (s, locale, knownAcronyms) => {
     for (let index = 1; index < width_2; index++) {
       const char = chars2[index];
       const isUpperCaseChar = char === char.toLocaleUpperCase(locale);
-      const isSpecialChar = /[ČŠŽĐ]/i.test(char);
+      const isSpecialChar = RE_SLOVENIAN_SPECIAL.test(char);
       const nextIsUpper = index < width_2 - 1 && chars2[index + 1] === chars2[index + 1].toLocaleUpperCase(locale);
       if (!previousIsUpper2 && isUpperCaseChar || isSpecialChar && nextIsUpper) {
         result2.push(currentSegment2);
@@ -540,17 +575,21 @@ const splitCamelCaseLocale = (s, locale, knownAcronyms) => {
   for (let index = 1; index < width_; index++) {
     const char = chars[index];
     const isUpperCaseChar = char === char.toLocaleUpperCase(locale);
-    let isAcronym = false;
+    let acronymLength = 0;
     for (const acronym of knownAcronyms) {
       if (s.startsWith(acronym, index)) {
         result.push(currentSegment, acronym);
-        index += acronym.length - 1;
+        acronymLength = acronym.length;
         currentSegment = "";
-        isAcronym = true;
+        const lastAcronymChar = acronym.at(-1);
+        if (lastAcronymChar) {
+          previousIsUpper = lastAcronymChar === lastAcronymChar.toLocaleUpperCase(locale);
+        }
         break;
       }
     }
-    if (isAcronym) {
+    if (acronymLength > 0) {
+      index += acronymLength - 1;
       continue;
     }
     if (!previousIsUpper && isUpperCaseChar) {
@@ -569,20 +608,21 @@ const splitCamelCaseLocale = (s, locale, knownAcronyms) => {
 const processTextWithAnsiEmoji = (text, locale, knownAcronyms) => {
   const result = [];
   const segments = RE_FAST_ANSI.test(text) ? text.split(RE_FAST_ANSI).filter(Boolean) : [text];
-  for (const seg of segments) {
+  for (const segment of segments) {
+    const seg = segment;
     if (RE_FAST_ANSI.test(seg)) {
       result.push(seg);
     } else {
       const subs = RE_EMOJI.test(seg) ? splitByEmoji(seg).filter(Boolean) : [seg];
-      for (const sub of subs) {
-        if (RE_EMOJI.test(sub)) {
-          result.push(sub);
+      for (const emojiSub of subs) {
+        if (RE_EMOJI.test(emojiSub)) {
+          result.push(emojiSub);
         } else {
           if (locale) {
             const normalizedLocale = locale.toLowerCase().split("-")[0];
-            result.push(...splitCamelCaseLocale(sub, normalizedLocale, knownAcronyms));
+            result.push(...splitCamelCaseLocale(emojiSub, normalizedLocale, knownAcronyms));
           } else {
-            result.push(...splitCamelCaseFast(sub, knownAcronyms));
+            result.push(...splitCamelCaseFast(emojiSub, knownAcronyms));
           }
         }
       }
@@ -604,7 +644,7 @@ const splitByCase = (input, options = {}) => {
     stripAnsi: stripAnsiOption = false,
     stripEmoji: stripEmojiOption = false
   } = options;
-  const acronymSet = new Set([...knownAcronyms].sort((a, b) => b.length - a.length));
+  const acronymSet = new Set([...knownAcronyms].toSorted((a, b) => b.length - a.length));
   let cleanedInput = input;
   if (stripAnsiOption) {
     cleanedInput = stripVTControlCharacters(cleanedInput);
@@ -612,16 +652,95 @@ const splitByCase = (input, options = {}) => {
   if (stripEmojiOption) {
     cleanedInput = stripEmoji(cleanedInput);
   }
-  const separatorRegex = Array.isArray(separators) ? getSeparatorsRegex(separators) : separators instanceof RegExp ? separators : RE_SEPARATORS;
-  const parts = cleanedInput.split(separatorRegex).filter(Boolean);
+  let separatorRegex;
+  if (Array.isArray(separators)) {
+    separatorRegex = getSeparatorsRegex(separators);
+  } else if (separators instanceof RegExp) {
+    separatorRegex = separators;
+  } else {
+    separatorRegex = RE_SEPARATORS;
+  }
+  const parts = [];
+  let workingInput = cleanedInput;
+  const regex = separatorRegex.flags.includes("g") ? separatorRegex : new RegExp(separatorRegex.source, `${separatorRegex.flags}g`);
+  while (workingInput.length > 0) {
+    const match = regex.exec(workingInput);
+    if (!match) {
+      if (workingInput === "..") {
+        parts.push("..");
+      } else if (workingInput === ".") {
+        parts.push(".");
+      } else if (workingInput.length > 0) {
+        parts.push(workingInput);
+      }
+      break;
+    }
+    const matchIndex = match.index;
+    const matchText = match[0];
+    const matchLength = matchText.length;
+    const beforeMatch = workingInput.slice(0, matchIndex);
+    const afterMatch = workingInput.slice(matchIndex + matchLength);
+    if (matchText.startsWith("../")) {
+      parts.push("..");
+      workingInput = workingInput.slice(matchIndex + 3);
+    } else if (matchText.startsWith("./")) {
+      parts.push(".");
+      workingInput = workingInput.slice(matchIndex + 2);
+    } else if (matchIndex === 0 && matchText === "..") {
+      parts.push("..");
+      workingInput = workingInput.slice(2);
+    } else if (matchIndex === 0 && matchText === ".") {
+      parts.push(".");
+      workingInput = workingInput.slice(1);
+    } else {
+      if (beforeMatch.length > 0) {
+        parts.push(beforeMatch);
+      }
+      let pos = 0;
+      while ((pos = matchText.indexOf("../", pos)) !== -1) {
+        parts.push("..");
+        pos += 3;
+      }
+      pos = 0;
+      while ((pos = matchText.indexOf("./", pos)) !== -1) {
+        if (pos === 0 || matchText[pos - 1] !== ".") {
+          parts.push(".");
+        }
+        pos += 2;
+      }
+      let remainingAfterMatch = afterMatch;
+      while (remainingAfterMatch.startsWith("../")) {
+        parts.push("..");
+        remainingAfterMatch = remainingAfterMatch.slice(3);
+      }
+      while (remainingAfterMatch.startsWith("./")) {
+        parts.push(".");
+        remainingAfterMatch = remainingAfterMatch.slice(2);
+      }
+      if (remainingAfterMatch === "..") {
+        parts.push("..");
+        break;
+      } else if (remainingAfterMatch === ".") {
+        parts.push(".");
+        break;
+      } else {
+        workingInput = remainingAfterMatch;
+      }
+    }
+    regex.lastIndex = 0;
+  }
+  if (parts.length === 0) {
+    const standardParts = cleanedInput.split(separatorRegex).filter(Boolean);
+    parts.push(...standardParts);
+  }
   let tokens = [];
-  for (const part of parts) {
+  for (const splitPart of parts) {
     if (handleAnsi || handleEmoji) {
-      tokens.push(...processTextWithAnsiEmoji(part, locale, acronymSet));
+      tokens.push(...processTextWithAnsiEmoji(splitPart, locale, acronymSet));
     } else if (locale) {
-      tokens.push(...splitCamelCaseLocale(part, locale, acronymSet));
+      tokens.push(...splitCamelCaseLocale(splitPart, locale, acronymSet));
     } else {
-      tokens.push(...splitCamelCaseFast(part, acronymSet));
+      tokens.push(...splitCamelCaseFast(splitPart, acronymSet));
     }
   }
   if (normalize) {

package/dist/case/title-case.d.ts

@@ -1,7 +1,5 @@
-import { C as CaseOptions, T as TitleCase } from '../packem_shared/types-CfPsw9ix.js';
-import '../packem_shared/types-Daae0hGf.js';
-import '../packem_shared/lru-cache-B_t27XwI.js';
-
+import { C as CaseOptions, T as TitleCase } from "../packem_shared/types.d-DfgbcNKh.js";
+import "../packem_shared/types.d-BVNv675q.js";
+import "../packem_shared/lru-cache.d-BsP6kbVJ.js";
 declare function titleCase<T extends string = string>(value?: T, options?: CaseOptions): TitleCase<T>;
-
 export { titleCase as default };

package/dist/case/title-case.js

@@ -2,7 +2,7 @@ import LRUCache from '../packem_shared/LRUCache-3r3SovvR.js';
 import { splitByCase } from './split-by-case.js';
 import upperFirst from './upper-first.js';
 import { g as generateCacheKey } from '../packem_shared/generate-cache-key-DdayDfjV.js';
-import { n as normalizeGermanEszett } from '../packem_shared/normalize-german-eszett-DEB8-ZPT.js';
+import { n as normalizeGermanEszett } from '../packem_shared/normalize-german-eszett-4p3yKEzn.js';
 
 const defaultCacheStore = new LRUCache(1e3);
 function titleCase(value, options) {
@@ -28,10 +28,8 @@ function titleCase(value, options) {
     stripAnsi: options?.stripAnsi,
     stripEmoji: options?.stripEmoji
   }).map((word) => {
-    if (options?.locale?.startsWith("de")) {
-      word = normalizeGermanEszett(word);
-    }
-    return upperFirst(options?.locale ? word.toLocaleLowerCase(options.locale) : word.toLowerCase(), { locale: options?.locale });
+    const normalized = options?.locale?.startsWith("de") ? normalizeGermanEszett(word) : word;
+    return upperFirst(options?.locale ? normalized.toLocaleLowerCase(options.locale) : normalized.toLowerCase(), { locale: options?.locale });
   }).join(" ");
   if (shouldCache && cacheKey) {
     cacheStore.set(cacheKey, result);

package/dist/case/train-case.d.ts

@@ -1,7 +1,5 @@
-import { C as CaseOptions, j as TrainCase } from '../packem_shared/types-CfPsw9ix.js';
-import '../packem_shared/types-Daae0hGf.js';
-import '../packem_shared/lru-cache-B_t27XwI.js';
-
+import { C as CaseOptions, j as TrainCase } from "../packem_shared/types.d-DfgbcNKh.js";
+import "../packem_shared/types.d-BVNv675q.js";
+import "../packem_shared/lru-cache.d-BsP6kbVJ.js";
 declare const trainCase: <T extends string = string>(value?: T, options?: CaseOptions) => TrainCase<T>;
-
 export { trainCase as default };

package/dist/case/train-case.js

@@ -2,7 +2,7 @@ import LRUCache from '../packem_shared/LRUCache-3r3SovvR.js';
 import { splitByCase } from './split-by-case.js';
 import upperFirst from './upper-first.js';
 import { g as generateCacheKey } from '../packem_shared/generate-cache-key-DdayDfjV.js';
-import joinSegments from '../packem_shared/joinSegments-CuU8RGpP.js';
+import joinSegments from '../packem_shared/joinSegments-CvxSgKz0.js';
 
 const defaultCacheStore = new LRUCache(1e3);
 const trainCase = (value, options) => {

package/dist/case/upper-first.d.ts

@@ -1,7 +1,5 @@
-import { L as LocaleOptions, U as UpperFirst } from '../packem_shared/types-CfPsw9ix.js';
-import '../packem_shared/types-Daae0hGf.js';
-import '../packem_shared/lru-cache-B_t27XwI.js';
-
+import { L as LocaleOptions, U as UpperFirst } from "../packem_shared/types.d-DfgbcNKh.js";
+import "../packem_shared/types.d-BVNv675q.js";
+import "../packem_shared/lru-cache.d-BsP6kbVJ.js";
 declare const upperFirst: <T extends string = string>(value?: T, options?: LocaleOptions) => UpperFirst<T>;
-
 export { upperFirst as default };

package/dist/closest-string.d.ts

@@ -1,8 +1,6 @@
 interface ClosestStringOptions {
-    caseSensitive?: boolean;
-    compareFn?: (a: string, b: string) => number;
+  caseSensitive?: boolean;
+  compareFn?: (a: string, b: string) => number;
 }
 declare const closestString: (givenWord: string, possibleWords: ReadonlyArray<string>, options?: ClosestStringOptions) => string | undefined;
-
-export { closestString };
-export type { ClosestStringOptions };
+export { ClosestStringOptions, closestString };

package/dist/closest-string.js

@@ -2,18 +2,15 @@ import { distance } from './packem_shared/closest-IHuSvnSn.js';
 
 const closestString = (givenWord, possibleWords, options) => {
   if (possibleWords.length === 0) {
-    throw new TypeError(
-      "When using closestString(), the possibleWords array must contain at least one word"
-    );
+    throw new TypeError("When using closestString(), the possibleWords array must contain at least one word");
   }
   const { caseSensitive, compareFn: compareFunction = distance } = { ...options };
-  if (!caseSensitive) {
-    givenWord = givenWord.toLowerCase();
-  }
+  const normalizedGivenWord = caseSensitive ? givenWord : givenWord.toLowerCase();
   let nearestWord = possibleWords[0] ?? void 0;
   let closestStringDistance = Infinity;
-  for (const each of possibleWords) {
-    const distance = caseSensitive ? compareFunction(givenWord, each) : compareFunction(givenWord, each.toLowerCase());
+  for (const possibleWord of possibleWords) {
+    const each = possibleWord;
+    const distance = caseSensitive ? compareFunction(normalizedGivenWord, each) : compareFunction(normalizedGivenWord, each.toLowerCase());
     if (distance < closestStringDistance) {
       nearestWord = each;
       closestStringDistance = distance;

package/dist/compare-similarity.d.ts

@@ -1,8 +1,6 @@
 interface CompareSimilarityOptions {
-    caseSensitive?: boolean;
-    compareFn?: (a: string, b: string) => number;
+  caseSensitive?: boolean;
+  compareFn?: (a: string, b: string) => number;
 }
 declare const compareSimilarity: (givenWord: string, options?: CompareSimilarityOptions) => (a: string, b: string) => number;
-
-export { compareSimilarity };
-export type { CompareSimilarityOptions };
+export { CompareSimilarityOptions, compareSimilarity };

package/dist/compare-similarity.js

@@ -5,8 +5,8 @@ const compareSimilarity = (givenWord, options) => {
   if (options?.caseSensitive) {
     return (a, b) => compareFunction(givenWord, a) - compareFunction(givenWord, b);
   }
-  givenWord = givenWord.toLowerCase();
-  return (a, b) => compareFunction(givenWord, a.toLowerCase()) - compareFunction(givenWord, b.toLowerCase());
+  const normalizedGivenWord = givenWord.toLowerCase();
+  return (a, b) => compareFunction(normalizedGivenWord, a.toLowerCase()) - compareFunction(normalizedGivenWord, b.toLowerCase());
 };
 
 export { compareSimilarity };

package/dist/get-string-truncated-width.d.ts

@@ -1,25 +1,23 @@
 interface StringTruncatedWidthOptions {
-    ambiguousIsNarrow?: boolean;
-    ansiWidth?: number;
-    controlWidth?: number;
-    countAnsiEscapeCodes?: boolean;
-    ellipsis?: string;
-    ellipsisWidth?: number;
-    emojiWidth?: number;
-    fullWidth?: number;
-    halfWidth?: number;
-    limit?: number;
-    regularWidth?: number;
-    tabWidth?: number;
-    wideWidth?: number;
+  ambiguousIsNarrow?: boolean;
+  ansiWidth?: number;
+  controlWidth?: number;
+  countAnsiEscapeCodes?: boolean;
+  ellipsis?: string;
+  ellipsisWidth?: number;
+  emojiWidth?: number;
+  fullWidth?: number;
+  halfWidth?: number;
+  limit?: number;
+  regularWidth?: number;
+  tabWidth?: number;
+  wideWidth?: number;
 }
 interface StringTruncatedWidthResult {
-    ellipsed: boolean;
-    index: number;
-    truncated: boolean;
-    width: number;
+  ellipsed: boolean;
+  index: number;
+  truncated: boolean;
+  width: number;
 }
 declare const getStringTruncatedWidth: (input: string, options?: StringTruncatedWidthOptions) => StringTruncatedWidthResult;
-
-export { getStringTruncatedWidth };
-export type { StringTruncatedWidthOptions, StringTruncatedWidthResult };
+export { StringTruncatedWidthOptions, StringTruncatedWidthResult, getStringTruncatedWidth };