@visulima/string 3.0.0-alpha.1 → 3.0.0-alpha.11

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 };

package/dist/get-string-truncated-width.js

@@ -1,36 +1,5 @@
-import { c as RE_ANSI, N as RE_CONTROL, j as RE_EMOJI } from './packem_shared/constants-CTzC6Gjg.js';
-
-function isAmbiguous(x) {
-  return x === 161 || x === 164 || x === 167 || x === 168 || x === 170 || x === 173 || x === 174 || x >= 176 && x <= 180 || x >= 182 && x <= 186 || x >= 188 && x <= 191 || x === 198 || x === 208 || x === 215 || x === 216 || x >= 222 && x <= 225 || x === 230 || x >= 232 && x <= 234 || x === 236 || x === 237 || x === 240 || x === 242 || x === 243 || x >= 247 && x <= 250 || x === 252 || x === 254 || x === 257 || x === 273 || x === 275 || x === 283 || x === 294 || x === 295 || x === 299 || x >= 305 && x <= 307 || x === 312 || x >= 319 && x <= 322 || x === 324 || x >= 328 && x <= 331 || x === 333 || x === 338 || x === 339 || x === 358 || x === 359 || x === 363 || x === 462 || x === 464 || x === 466 || x === 468 || x === 470 || x === 472 || x === 474 || x === 476 || x === 593 || x === 609 || x === 708 || x === 711 || x >= 713 && x <= 715 || x === 717 || x === 720 || x >= 728 && x <= 731 || x === 733 || x === 735 || x >= 768 && x <= 879 || x >= 913 && x <= 929 || x >= 931 && x <= 937 || x >= 945 && x <= 961 || x >= 963 && x <= 969 || x === 1025 || x >= 1040 && x <= 1103 || x === 1105 || x === 8208 || x >= 8211 && x <= 8214 || x === 8216 || x === 8217 || x === 8220 || x === 8221 || x >= 8224 && x <= 8226 || x >= 8228 && x <= 8231 || x === 8240 || x === 8242 || x === 8243 || x === 8245 || x === 8251 || x === 8254 || x === 8308 || x === 8319 || x >= 8321 && x <= 8324 || x === 8364 || x === 8451 || x === 8453 || x === 8457 || x === 8467 || x === 8470 || x === 8481 || x === 8482 || x === 8486 || x === 8491 || x === 8531 || x === 8532 || x >= 8539 && x <= 8542 || x >= 8544 && x <= 8555 || x >= 8560 && x <= 8569 || x === 8585 || x >= 8592 && x <= 8601 || x === 8632 || x === 8633 || x === 8658 || x === 8660 || x === 8679 || x === 8704 || x === 8706 || x === 8707 || x === 8711 || x === 8712 || x === 8715 || x === 8719 || x === 8721 || x === 8725 || x === 8730 || x >= 8733 && x <= 8736 || x === 8739 || x === 8741 || x >= 8743 && x <= 8748 || x === 8750 || x >= 8756 && x <= 8759 || x === 8764 || x === 8765 || x === 8776 || x === 8780 || x === 8786 || x === 8800 || x === 8801 || x >= 8804 && x <= 8807 || x === 8810 || x === 8811 || x === 8814 || x === 8815 || x === 8834 || x === 8835 || x === 8838 || x === 8839 || x === 8853 || x === 8857 || x === 8869 || x === 8895 || x === 8978 || x >= 9312 && x <= 9449 || x >= 9451 && x <= 9547 || x >= 9552 && x <= 9587 || x >= 9600 && x <= 9615 || x >= 9618 && x <= 9621 || x === 9632 || x === 9633 || x >= 9635 && x <= 9641 || x === 9650 || x === 9651 || x === 9654 || x === 9655 || x === 9660 || x === 9661 || x === 9664 || x === 9665 || x >= 9670 && x <= 9672 || x === 9675 || x >= 9678 && x <= 9681 || x >= 9698 && x <= 9701 || x === 9711 || x === 9733 || x === 9734 || x === 9737 || x === 9742 || x === 9743 || x === 9756 || x === 9758 || x === 9792 || x === 9794 || x === 9824 || x === 9825 || x >= 9827 && x <= 9829 || x >= 9831 && x <= 9834 || x === 9836 || x === 9837 || x === 9839 || x === 9886 || x === 9887 || x === 9919 || x >= 9926 && x <= 9933 || x >= 9935 && x <= 9939 || x >= 9941 && x <= 9953 || x === 9955 || x === 9960 || x === 9961 || x >= 9963 && x <= 9969 || x === 9972 || x >= 9974 && x <= 9977 || x === 9979 || x === 9980 || x === 9982 || x === 9983 || x === 10045 || x >= 10102 && x <= 10111 || x >= 11094 && x <= 11097 || x >= 12872 && x <= 12879 || x >= 57344 && x <= 63743 || x >= 65024 && x <= 65039 || x === 65533 || x >= 127232 && x <= 127242 || x >= 127248 && x <= 127277 || x >= 127280 && x <= 127337 || x >= 127344 && x <= 127373 || x === 127375 || x === 127376 || x >= 127387 && x <= 127404 || x >= 917760 && x <= 917999 || x >= 983040 && x <= 1048573 || x >= 1048576 && x <= 1114109;
-}
-function isFullWidth(x) {
-  return x === 12288 || x >= 65281 && x <= 65376 || x >= 65504 && x <= 65510;
-}
-function isWide(x) {
-  return x >= 4352 && x <= 4447 || x === 8986 || x === 8987 || x === 9001 || x === 9002 || x >= 9193 && x <= 9196 || x === 9200 || x === 9203 || x === 9725 || x === 9726 || x === 9748 || x === 9749 || x >= 9776 && x <= 9783 || x >= 9800 && x <= 9811 || x === 9855 || x >= 9866 && x <= 9871 || x === 9875 || x === 9889 || x === 9898 || x === 9899 || x === 9917 || x === 9918 || x === 9924 || x === 9925 || x === 9934 || x === 9940 || x === 9962 || x === 9970 || x === 9971 || x === 9973 || x === 9978 || x === 9981 || x === 9989 || x === 9994 || x === 9995 || x === 10024 || x === 10060 || x === 10062 || x >= 10067 && x <= 10069 || x === 10071 || x >= 10133 && x <= 10135 || x === 10160 || x === 10175 || x === 11035 || x === 11036 || x === 11088 || x === 11093 || x >= 11904 && x <= 11929 || x >= 11931 && x <= 12019 || x >= 12032 && x <= 12245 || x >= 12272 && x <= 12287 || x >= 12289 && x <= 12350 || x >= 12353 && x <= 12438 || x >= 12441 && x <= 12543 || x >= 12549 && x <= 12591 || x >= 12593 && x <= 12686 || x >= 12688 && x <= 12773 || x >= 12783 && x <= 12830 || x >= 12832 && x <= 12871 || x >= 12880 && x <= 42124 || x >= 42128 && x <= 42182 || x >= 43360 && x <= 43388 || x >= 44032 && x <= 55203 || x >= 63744 && x <= 64255 || x >= 65040 && x <= 65049 || x >= 65072 && x <= 65106 || x >= 65108 && x <= 65126 || x >= 65128 && x <= 65131 || x >= 94176 && x <= 94180 || x >= 94192 && x <= 94198 || x >= 94208 && x <= 101589 || x >= 101631 && x <= 101662 || x >= 101760 && x <= 101874 || x >= 110576 && x <= 110579 || x >= 110581 && x <= 110587 || x === 110589 || x === 110590 || x >= 110592 && x <= 110882 || x === 110898 || x >= 110928 && x <= 110930 || x === 110933 || x >= 110948 && x <= 110951 || x >= 110960 && x <= 111355 || x >= 119552 && x <= 119638 || x >= 119648 && x <= 119670 || x === 126980 || x === 127183 || x === 127374 || x >= 127377 && x <= 127386 || x >= 127488 && x <= 127490 || x >= 127504 && x <= 127547 || x >= 127552 && x <= 127560 || x === 127568 || x === 127569 || x >= 127584 && x <= 127589 || x >= 127744 && x <= 127776 || x >= 127789 && x <= 127797 || x >= 127799 && x <= 127868 || x >= 127870 && x <= 127891 || x >= 127904 && x <= 127946 || x >= 127951 && x <= 127955 || x >= 127968 && x <= 127984 || x === 127988 || x >= 127992 && x <= 128062 || x === 128064 || x >= 128066 && x <= 128252 || x >= 128255 && x <= 128317 || x >= 128331 && x <= 128334 || x >= 128336 && x <= 128359 || x === 128378 || x === 128405 || x === 128406 || x === 128420 || x >= 128507 && x <= 128591 || x >= 128640 && x <= 128709 || x === 128716 || x >= 128720 && x <= 128722 || x >= 128725 && x <= 128728 || x >= 128732 && x <= 128735 || x === 128747 || x === 128748 || x >= 128756 && x <= 128764 || x >= 128992 && x <= 129003 || x === 129008 || x >= 129292 && x <= 129338 || x >= 129340 && x <= 129349 || x >= 129351 && x <= 129535 || x >= 129648 && x <= 129660 || x >= 129664 && x <= 129674 || x >= 129678 && x <= 129734 || x === 129736 || x >= 129741 && x <= 129756 || x >= 129759 && x <= 129770 || x >= 129775 && x <= 129784 || x >= 131072 && x <= 196605 || x >= 196608 && x <= 262141;
-}
-function getCategory(x) {
-  if (isAmbiguous(x)) return "ambiguous";
-  if (isFullWidth(x)) return "fullwidth";
-  if (x === 8361 || x >= 65377 && x <= 65470 || x >= 65474 && x <= 65479 || x >= 65482 && x <= 65487 || x >= 65490 && x <= 65495 || x >= 65498 && x <= 65500 || x >= 65512 && x <= 65518) {
-    return "halfwidth";
-  }
-  if (x >= 32 && x <= 126 || x === 162 || x === 163 || x === 165 || x === 166 || x === 172 || x === 175 || x >= 10214 && x <= 10221 || x === 10629 || x === 10630) {
-    return "narrow";
-  }
-  if (isWide(x)) return "wide";
-  return "neutral";
-}
-
-function validate(codePoint) {
-  if (!Number.isSafeInteger(codePoint)) {
-    throw new TypeError(`Expected a code point, got \`${typeof codePoint}\`.`);
-  }
-}
-function eastAsianWidthType(codePoint) {
-  validate(codePoint);
-  return getCategory(codePoint);
-}
+import { eastAsianWidthType } from './packem_shared/eastAsianWidthType-SD3YniiT.js';
+import { g as RE_ANSI, h as RE_CONTROL, i as RE_EMOJI } from './packem_shared/constants-BsZS5f0z.js';
 
 const charWidthCache = /* @__PURE__ */ new Map();
 const RE_LATIN_CHARS = /(?:[\u0020-\u007E\u00A0-\u00FF](?!\uFE0F)){1,1000}/y;

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

@@ -1,7 +1,4 @@
-import { StringTruncatedWidthOptions } from './get-string-truncated-width.js';
-
+import { StringTruncatedWidthOptions } from "./get-string-truncated-width.js";
 type StringWidthOptions = Omit<StringTruncatedWidthOptions, "ellipsis" | "ellipsisWidth" | "limit">;
 declare const getStringWidth: (input: string, options?: StringWidthOptions) => number;
-
-export { getStringWidth };
-export type { StringWidthOptions };
+export { StringWidthOptions, getStringWidth };