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

package/dist/test/utils.d.ts

@@ -1,31 +1,29 @@
 declare const formatAnsiString: (ansiString: string) => {
-    ansi: string;
-    json: string;
-    lengthDifference: number;
-    stripped: string;
-    visible: string;
+  ansi: string;
+  json: string;
+  lengthDifference: number;
+  stripped: string;
+  visible: string;
 };
 interface ExpectationResult {
-    actual?: unknown;
-    expected?: unknown;
-    message: () => string;
-    pass: boolean;
+  actual?: unknown;
+  expected?: unknown;
+  message: () => string;
+  pass: boolean;
 }
 declare const expectAnsiStrings: (actual: string, expected: string) => ExpectationResult;
 declare const compareAnsiStrings: (actual: string, expected: string) => {
-    actual: ReturnType<typeof formatAnsiString>;
+  actual: ReturnType<typeof formatAnsiString>;
+  ansiEqual: boolean;
+  expected: ReturnType<typeof formatAnsiString>;
+  strippedEqual: boolean;
+  summary: {
+    actualLength: number;
+    actualStrippedLength: number;
     ansiEqual: boolean;
-    expected: ReturnType<typeof formatAnsiString>;
+    expectedLength: number;
+    expectedStrippedLength: number;
     strippedEqual: boolean;
-    summary: {
-        actualLength: number;
-        actualStrippedLength: number;
-        ansiEqual: boolean;
-        expectedLength: number;
-        expectedStrippedLength: number;
-        strippedEqual: boolean;
-    };
+  };
 };
-
-export { compareAnsiStrings, expectAnsiStrings, formatAnsiString };
-export type { ExpectationResult };
+export { ExpectationResult, compareAnsiStrings, expectAnsiStrings, formatAnsiString };

package/dist/test/utils.js

@@ -18,8 +18,8 @@ const __cjs_getBuiltinModule = (module) => {
 };
 
 const {
-  stripVTControlCharacters,
-  format
+  format,
+  stripVTControlCharacters
 } = __cjs_getBuiltinModule("node:util");
 import { getStringWidth } from '../get-string-width.js';
 

package/dist/test/vitest.d.ts

@@ -1,9 +1,6 @@
-import { ExpectationResult } from './utils.js';
-
+import { ExpectationResult } from "./utils.js";
 interface CustomMatchers {
-    toEqualAnsi: (expected: string) => ExpectationResult;
+  toEqualAnsi: (expected: string) => ExpectationResult;
 }
 declare const toEqualAnsi: (actual: string, expected: string) => ExpectationResult;
-
-export { toEqualAnsi };
-export type { CustomMatchers };
+export { CustomMatchers, toEqualAnsi };

package/dist/truncate.d.ts

@@ -1,13 +1,10 @@
-import { StringTruncatedWidthOptions } from './get-string-truncated-width.js';
-
+import { StringTruncatedWidthOptions } from "./get-string-truncated-width.js";
 type TruncateOptions = {
-    ellipsis?: string;
-    ellipsisWidth?: number;
-    position?: "end" | "middle" | "start";
-    preferTruncationOnSpace?: boolean;
-    width?: Omit<StringTruncatedWidthOptions, "ellipsis" | "ellipsisWidth" | "limit">;
+  ellipsis?: string;
+  ellipsisWidth?: number;
+  position?: "end" | "middle" | "start";
+  preferTruncationOnSpace?: boolean;
+  width?: Omit<StringTruncatedWidthOptions, "ellipsis" | "ellipsisWidth" | "limit">;
 };
 declare const truncate: (input: string, limit: number, options?: TruncateOptions) => string;
-
-export { truncate };
-export type { TruncateOptions };
+export { TruncateOptions, truncate };

package/dist/truncate.js

@@ -1,22 +1,33 @@
 import { getStringTruncatedWidth } from './get-string-truncated-width.js';
+import { getStringWidth } from './get-string-width.js';
 import { slice } from './slice.js';
 
 const DEFAULT_ELLIPSIS = "…";
 const MAX_SPACE_SEARCH_DISTANCE = 3;
-const findNearestSpace = (string_, startIndex, searchRight = false) => {
-  if (string_.charAt(startIndex) === " ") {
+const findNearestSpace = (value, startIndex, searchRight = false) => {
+  if (value.charAt(startIndex) === " ") {
     return startIndex;
   }
   const direction = searchRight ? 1 : -1;
-  const limit = Math.min(MAX_SPACE_SEARCH_DISTANCE, searchRight ? string_.length - startIndex : startIndex);
+  const limit = Math.min(MAX_SPACE_SEARCH_DISTANCE, searchRight ? value.length - startIndex : startIndex);
   for (let offset = 1; offset <= limit; offset++) {
     const index = startIndex + offset * direction;
-    if (string_.charAt(index) === " ") {
+    if (value.charAt(index) === " ") {
       return index;
     }
   }
   return startIndex;
 };
+const widthToIndex = (input, targetWidth, widthOptions) => {
+  const result = getStringTruncatedWidth(input, {
+    ...widthOptions,
+    ellipsis: "",
+    ellipsisWidth: 0,
+    limit: targetWidth
+  });
+  return result.index;
+};
+const indexToWidth = (input, stringIndex, widthOptions) => getStringWidth(input.slice(0, stringIndex), widthOptions);
 const truncate = (input, limit, options = {}) => {
   if (typeof input !== "string") {
     throw new TypeError(`Expected \`input\` to be a string, got ${typeof input}`);
@@ -27,56 +38,68 @@ const truncate = (input, limit, options = {}) => {
   if (input === "" || limit <= 0) {
     return "";
   }
-  input = input.normalize("NFC");
+  const normalizedInput = input.normalize("NFC");
   const { ellipsis = DEFAULT_ELLIPSIS, position = "end", preferTruncationOnSpace = false } = options;
   let ellipsisWidth = options.ellipsisWidth ?? ellipsis === DEFAULT_ELLIPSIS ? 1 : void 0;
-  if (ellipsisWidth === void 0) {
-    ellipsisWidth = getStringTruncatedWidth(ellipsis, {
-      ...options.width,
-      ellipsis: "",
-      ellipsisWidth: 0,
-      limit: Number.POSITIVE_INFINITY
-    }).width;
-  }
-  const { width } = getStringTruncatedWidth(input, {
+  ellipsisWidth ??= getStringTruncatedWidth(ellipsis, {
+    ...options.width,
+    ellipsis: "",
+    ellipsisWidth: 0,
+    limit: Number.POSITIVE_INFINITY
+  }).width;
+  const { width } = getStringTruncatedWidth(normalizedInput, {
     ...options.width,
     ellipsis,
     ellipsisWidth
   });
   if (width <= limit) {
-    return input;
+    return normalizedInput;
   }
   switch (position) {
     case "end": {
       if (preferTruncationOnSpace) {
-        const nearestSpace = findNearestSpace(input, limit - 1);
-        return slice(input, 0, nearestSpace, {
+        const targetWidth = limit - ellipsisWidth;
+        const stringIndex = widthToIndex(normalizedInput, targetWidth, options.width);
+        const nearestSpace = findNearestSpace(normalizedInput, stringIndex);
+        const nearestSpaceWidth = indexToWidth(normalizedInput, nearestSpace, options.width);
+        return slice(normalizedInput, 0, nearestSpaceWidth, {
           width: options.width
         }) + ellipsis;
       }
-      return slice(input, 0, limit - ellipsisWidth, {
+      return slice(normalizedInput, 0, limit - ellipsisWidth, {
         width: options.width
       }) + ellipsis;
     }
     case "middle": {
       const half = Math.floor(limit / 2);
+      const totalTextWidth = Math.max(0, limit - ellipsisWidth);
+      const leftWidth = Math.min(half, totalTextWidth);
+      const rightWidth = Math.max(0, totalTextWidth - leftWidth);
       if (preferTruncationOnSpace) {
-        const firstBreak = findNearestSpace(input, half);
-        const secondBreak = findNearestSpace(input, width - (limit - half) + 1, true);
-        return slice(input, 0, firstBreak) + ellipsis + slice(input, secondBreak, width).trim();
+        const firstBreakIndex = widthToIndex(normalizedInput, leftWidth, options.width);
+        const firstBreak = findNearestSpace(normalizedInput, firstBreakIndex);
+        const firstBreakWidth = indexToWidth(normalizedInput, firstBreak, options.width);
+        const secondBreakWidthTarget = width - rightWidth;
+        const secondBreakIndex = widthToIndex(normalizedInput, secondBreakWidthTarget, options.width);
+        const secondBreak = findNearestSpace(normalizedInput, secondBreakIndex, true);
+        const secondBreakWidthActual = indexToWidth(normalizedInput, secondBreak, options.width);
+        return slice(normalizedInput, 0, firstBreakWidth, { width: options.width }) + ellipsis + slice(normalizedInput, secondBreakWidthActual, width, { width: options.width }).trim();
       }
-      return slice(input, 0, half, {
+      return slice(normalizedInput, 0, leftWidth, {
         width: options.width
-      }) + ellipsis + slice(input, width - (limit - half) + ellipsisWidth, width, {
+      }) + ellipsis + slice(normalizedInput, width - rightWidth, width, {
         width: options.width
       });
     }
     case "start": {
       if (preferTruncationOnSpace) {
-        const nearestSpace = findNearestSpace(input, width - limit + 1, true);
-        return ellipsis + slice(input, nearestSpace, width).trim();
+        const targetWidth = width - limit + ellipsisWidth;
+        const stringIndex = widthToIndex(normalizedInput, targetWidth, options.width);
+        const nearestSpace = findNearestSpace(normalizedInput, stringIndex, true);
+        const nearestSpaceWidth = indexToWidth(normalizedInput, nearestSpace, options.width);
+        return ellipsis + slice(normalizedInput, nearestSpaceWidth, width, { width: options.width }).trim();
       }
-      return ellipsis + slice(input, width - limit + ellipsisWidth, width, {
+      return ellipsis + slice(normalizedInput, width - limit + ellipsisWidth, width, {
         width: options.width
       });
     }

package/dist/utilities.d.ts

@@ -1,10 +1,8 @@
-import { l as IntervalArray } from './packem_shared/types-Daae0hGf.js';
-export { L as LRUCache } from './packem_shared/lru-cache-B_t27XwI.js';
-
+import { a as IntervalArray } from "./packem_shared/types.d-BVNv675q.js";
+export { L as LRUCache } from "./packem_shared/lru-cache.d-BsP6kbVJ.js";
 declare const escapeRegExp: (char: string) => string;
 declare const inRange: (number_: number, ranges: IntervalArray) => boolean;
 declare const hasChinese: (char: string) => boolean;
 declare const hasPunctuationOrSpace: (char: string) => boolean;
 declare const findStringOccurrences: (source: string, needles: string[]) => IntervalArray;
-
 export { escapeRegExp, findStringOccurrences, hasChinese, hasPunctuationOrSpace, inRange };

package/dist/utilities.js

@@ -1,17 +1,15 @@
 export { default as LRUCache } from './packem_shared/LRUCache-3r3SovvR.js';
 
+const RE_REGEXP_SPECIAL = /[.*+?^${}()|[\]\\]/g;
+const RE_CHINESE = /[\u2E80-\u2E99\u2E9B-\u2EF3\u2F00-\u2FD5\u3005\u3007\u3021-\u3029\u3038-\u303B\u3400-\u4DBF\u4E00-\u9FFC\uF900-\uFA6D\uFA70-\uFAD9]|\uD81B[\uDFF0\uDFF1]|[\uD840-\uD868\uD86A-\uD86C\uD86F-\uD872\uD874-\uD879\uD880-\uD883][\uDC00-\uDFFF]|\uD869[\uDC00-\uDEDD\uDF00-\uDFFF]|\uD86D[\uDC00-\uDF34\uDF40-\uDFFF]|\uD86E[\uDC00-\uDC1D\uDC20-\uDFFF]|\uD873[\uDC00-\uDEA1\uDEB0-\uDFFF]|\uD87A[\uDC00-\uDFE0]|\uD87E[\uDC00-\uDE1D]|\uD884[\uDC00-\uDF4A]/;
+const RE_PUNCTUATION_OR_SPACE = /[\p{P}\p{Z}]/u;
 const escapeRegExp = (char) => (
   // $& means the whole matched string
-  char.replaceAll(/[.*+?^${}()|[\]\\]/g, String.raw`\$&`)
+  char.replaceAll(RE_REGEXP_SPECIAL, String.raw`\$&`)
 );
 const inRange = (number_, ranges) => ranges.some((range) => number_ >= range[0] && number_ <= range[1]);
-const hasChinese = (char) => /[\u2E80-\u2E99\u2E9B-\u2EF3\u2F00-\u2FD5\u3005\u3007\u3021-\u3029\u3038-\u303B\u3400-\u4DBF\u4E00-\u9FFC\uF900-\uFA6D\uFA70-\uFAD9]|\uD81B[\uDFF0\uDFF1]|[\uD840-\uD868\uD86A-\uD86C\uD86F-\uD872\uD874-\uD879\uD880-\uD883][\uDC00-\uDFFF]|\uD869[\uDC00-\uDEDD\uDF00-\uDFFF]|\uD86D[\uDC00-\uDF34\uDF40-\uDFFF]|\uD86E[\uDC00-\uDC1D\uDC20-\uDFFF]|\uD873[\uDC00-\uDEA1\uDEB0-\uDFFF]|\uD87A[\uDC00-\uDFE0]|\uD87E[\uDC00-\uDE1D]|\uD884[\uDC00-\uDF4A]/.test(
-  char
-);
-const hasPunctuationOrSpace = (char) => (
-  // Uses Unicode property escapes for Punctuation and general category for Space
-  /[\p{P}\p{Z}]/u.test(char)
-);
+const hasChinese = (char) => RE_CHINESE.test(char);
+const hasPunctuationOrSpace = (char) => RE_PUNCTUATION_OR_SPACE.test(char);
 const findStringOccurrences = (source, needles) => {
   const ranges = [];
   if (!Array.isArray(needles)) {

package/dist/word-similarity-sort.d.ts

@@ -1,8 +1,6 @@
 interface WordSimilaritySortOptions {
-    caseSensitive?: boolean;
-    compareFunction?: (a: string, b: string) => number;
+  caseSensitive?: boolean;
+  compareFunction?: (a: string, b: string) => number;
 }
 declare const wordSimilaritySort: (givenWord: string, possibleWords: ReadonlyArray<string>, options?: WordSimilaritySortOptions) => string[];
-
-export { wordSimilaritySort };
-export type { WordSimilaritySortOptions };
+export { WordSimilaritySortOptions, wordSimilaritySort };

package/dist/word-wrap.d.ts

@@ -1,16 +1,14 @@
 declare const WrapMode: {
-    readonly BREAK_AT_CHARACTERS: "BREAK_AT_CHARACTERS";
-    readonly BREAK_WORDS: "BREAK_WORDS";
-    readonly PRESERVE_WORDS: "PRESERVE_WORDS";
-    readonly STRICT_WIDTH: "STRICT_WIDTH";
+  readonly BREAK_AT_CHARACTERS: "BREAK_AT_CHARACTERS";
+  readonly BREAK_WORDS: "BREAK_WORDS";
+  readonly PRESERVE_WORDS: "PRESERVE_WORDS";
+  readonly STRICT_WIDTH: "STRICT_WIDTH";
 };
 interface WordWrapOptions {
-    removeZeroWidthCharacters?: boolean;
-    trim?: boolean;
-    width?: number;
-    wrapMode?: keyof typeof WrapMode;
+  removeZeroWidthCharacters?: boolean;
+  trim?: boolean;
+  width?: number;
+  wrapMode?: keyof typeof WrapMode;
 }
 declare const wordWrap: (string: string, options?: WordWrapOptions) => string;
-
-export { WrapMode, wordWrap };
-export type { WordWrapOptions };
+export { WordWrapOptions, WrapMode, wordWrap };

package/dist/word-wrap.js

@@ -1,9 +1,10 @@
-import { O as ESCAPES, P as ANSI_ESCAPE_LINK, Q as ANSI_SGR_TERMINATOR, S as ANSI_ESCAPE_BELL, T as ANSI_CSI, U as RE_ESCAPE_PATTERN, V as ANSI_RESET_CODES, W as END_CODE, X as RE_ZERO_WIDTH } from './packem_shared/constants-CTzC6Gjg.js';
+import { O as ESCAPES, P as ANSI_ESCAPE_LINK, Q as ANSI_SGR_TERMINATOR, S as ANSI_ESCAPE_BELL, T as ANSI_CSI, U as RE_ESCAPE_PATTERN, V as ANSI_RESET_CODES, W as END_CODE, X as RE_ZERO_WIDTH } from './packem_shared/constants-BsZS5f0z.js';
 import { getStringWidth } from './get-string-width.js';
 
+const RE_ANSI_CODE = /\x1B\[(\d+)m/;
 class AnsiStateTracker {
-  activeForeground = null;
-  activeBackground = null;
+  activeForeground = void 0;
+  activeBackground = void 0;
   // Track other formatting (bold, italic, etc.)
   activeFormatting = [];
   /**
@@ -11,24 +12,24 @@ class AnsiStateTracker {
    * @param sequence The escape sequence to process
    */
   processEscape(sequence) {
-    const match = /\x1B\[(\d+)m/.exec(sequence);
+    const match = RE_ANSI_CODE.exec(sequence);
     if (!match) {
       return;
     }
     const code = Number.parseInt(match[1], 10);
     switch (code) {
       case 0: {
-        this.activeForeground = null;
-        this.activeBackground = null;
+        this.activeForeground = void 0;
+        this.activeBackground = void 0;
         this.activeFormatting = [];
         break;
       }
       case 39: {
-        this.activeForeground = null;
+        this.activeForeground = void 0;
         break;
       }
       case 49: {
-        this.activeBackground = null;
+        this.activeBackground = void 0;
         break;
       }
       default: {
@@ -62,7 +63,7 @@ class AnsiStateTracker {
     }
   }
   /**
-   * Gets all active escape sequences to apply
+   * Gets all active escape sequences to apply.
    * @returns String with all active escapes
    */
   getStartEscapesForAllActiveAttributes() {
@@ -92,7 +93,7 @@ class AnsiStateTracker {
         "\x1B[9m": "\x1B[29m"
         // Strikethrough
       };
-      [...this.activeFormatting].reverse().forEach((formatCode) => {
+      [...this.activeFormatting].toReversed().forEach((formatCode) => {
         const resetCode = formatResetMap[formatCode];
         if (resetCode) {
           closingEscapes.push(resetCode);
@@ -122,7 +123,6 @@ const processAnsiString = (string, options = {}) => {
   const stateTracker = new AnsiStateTracker();
   let currentText = "";
   let isInsideEscape = false;
-  let isInsideLinkEscape = false;
   let escapeBuffer = "";
   let currentUrl = "";
   let isInHyperlink = false;
@@ -150,7 +150,7 @@ const processAnsiString = (string, options = {}) => {
       isInsideEscape = true;
       escapeBuffer = character;
       const escapeInfo = checkEscapeSequence(chars, index);
-      isInsideLinkEscape = escapeInfo.isInsideLinkEscape;
+      const { isInsideLinkEscape } = escapeInfo;
       if (isInsideLinkEscape) {
         let urlEnd = index + 1;
         currentUrl = "";
@@ -177,7 +177,6 @@ const processAnsiString = (string, options = {}) => {
         index = urlEnd;
         isInHyperlink = true;
         isInsideEscape = false;
-        isInsideLinkEscape = false;
         escapeBuffer = "";
         continue;
       }
@@ -264,7 +263,7 @@ const processAnsiString = (string, options = {}) => {
 
 const wrapAnsiCode = (code) => {
   const escapeChar = ESCAPES.values().next().value;
-  return `${escapeChar}${ANSI_CSI}${code}${ANSI_SGR_TERMINATOR}`;
+  return `${escapeChar}${ANSI_CSI}${String(code)}${ANSI_SGR_TERMINATOR}`;
 };
 
 const wrapAnsiHyperlink = (url) => {
@@ -318,6 +317,8 @@ const preserveAnsi = (rawLines) => {
   return returnValue;
 };
 
+const RE_SPLIT_WHITESPACE = /(?=\s)|(?<=\s)/;
+const RE_WHITESPACE_ONLY = /^\s+$/;
 const resetAnsiAtLineBreak = (currentLine) => {
   if (!currentLine.includes("\x1B")) {
     return currentLine;
@@ -356,7 +357,8 @@ const wrapWithBreakAtWidth = (string, width, trim) => {
   let isInsideEscape = false;
   let isInsideLinkEscape = false;
   let escapeBuffer = "";
-  for (let index = 0; index < string.length; index++) {
+  let index = 0;
+  while (index < string.length) {
     const char = string[index];
     if (ESCAPES.has(char)) {
       isInsideEscape = true;
@@ -364,6 +366,7 @@ const wrapWithBreakAtWidth = (string, width, trim) => {
       currentLine += char;
       const escapeInfo = checkEscapeSequence([...string], index);
       isInsideLinkEscape = escapeInfo.isInsideLinkEscape;
+      index += 1;
       continue;
     }
     if (isInsideEscape) {
@@ -377,12 +380,14 @@ const wrapWithBreakAtWidth = (string, width, trim) => {
         isInsideEscape = false;
         ansiTracker.processEscape(escapeBuffer);
       }
+      index += 1;
       continue;
     }
     const charWidth = getStringWidth(char);
     const isSpace = char === " ";
     if (charWidth === 0) {
       currentLine += char;
+      index += 1;
       continue;
     }
     if (currentWidth + charWidth > width) {
@@ -394,12 +399,6 @@ const wrapWithBreakAtWidth = (string, width, trim) => {
       if (isSpace && trim) {
         while (index < string.length && string[index] === " ") {
           index += 1;
-          if (index >= string.length) {
-            break;
-          }
-        }
-        if (index < string.length) {
-          index--;
         }
         continue;
       }
@@ -415,9 +414,10 @@ const wrapWithBreakAtWidth = (string, width, trim) => {
         while (index < string.length && string[index] === " ") {
           index += 1;
         }
-        index--;
+        continue;
       }
     }
+    index += 1;
   }
   if (currentLine) {
     rows.push(currentLine + ansiTracker.getEndEscapesForAllActiveAttributes());
@@ -437,13 +437,15 @@ const wrapCharByChar = (string, width, trim) => {
   let currentWidth = 0;
   processAnsiString(inputToProcess, {
     getWidth: getStringWidth,
+    // eslint-disable-next-line sonarjs/cognitive-complexity,sonarjs/no-invariant-returns
     onSegment: (segment, stateTracker) => {
+      const segText = segment.text ?? "";
       if (segment.isEscapeSequence) {
-        currentLine += segment.text;
+        currentLine += segText;
       } else {
-        const isSpace = segment.text === " ";
+        const isSpace = segText === " ";
         if (segment.width === 0) {
-          currentLine += segment.text;
+          currentLine += segText;
           return true;
         }
         if (currentWidth + segment.width > width) {
@@ -456,11 +458,11 @@ const wrapCharByChar = (string, width, trim) => {
             if (trim) {
               return true;
             }
-            rows.push(stateTracker.getStartEscapesForAllActiveAttributes() + segment.text);
+            rows.push(stateTracker.getStartEscapesForAllActiveAttributes() + segText);
             return true;
           }
         }
-        currentLine += segment.text;
+        currentLine += segText;
         currentWidth += segment.width;
       }
       return true;
@@ -479,14 +481,14 @@ const wrapWithWordBoundaries = (string, width, trim) => {
   if (inputToProcess.length === 0) {
     return [];
   }
-  const tokens = inputToProcess.split(/(?=\s)|(?<=\s)/);
+  const tokens = inputToProcess.split(RE_SPLIT_WHITESPACE);
   const rows = [];
   let currentLine = "";
   let currentWidth = 0;
   let index = 0;
   while (index < tokens.length) {
     const token = tokens[index];
-    const isSpace = /^\s+$/.test(token);
+    const isSpace = RE_WHITESPACE_ONLY.test(token);
     const tokenVisibleWidth = getStringWidth(token);
     if (token.length === 0) {
       index += 1;
@@ -527,14 +529,14 @@ const wrapAndBreakWords = (string, width, trim) => {
   if (inputToProcess.length === 0) {
     return [];
   }
-  const tokens = inputToProcess.split(/(?=\s)|(?<=\s)/);
+  const tokens = inputToProcess.split(RE_SPLIT_WHITESPACE);
   const rows = [];
   let currentLine = "";
   let currentWidth = 0;
   let index = 0;
   while (index < tokens.length) {
     const token = tokens[index];
-    const isSpace = /^\s+$/.test(token);
+    const isSpace = RE_WHITESPACE_ONLY.test(token);
     const tokenVisibleWidth = getStringWidth(token);
     if (token.length === 0) {
       index += 1;
@@ -550,10 +552,10 @@ const wrapAndBreakWords = (string, width, trim) => {
       }
       const brokenLines = wrapWithBreakAtWidth(token, width, trim);
       if (brokenLines.length > 0) {
-        for (let index_ = 0; index_ < brokenLines.length - 1; index_++) {
-          rows.push(brokenLines[index_]);
+        for (let brokenLineIndex = 0; brokenLineIndex < brokenLines.length - 1; brokenLineIndex += 1) {
+          rows.push(brokenLines[brokenLineIndex]);
         }
-        currentLine = brokenLines[brokenLines.length - 1];
+        currentLine = brokenLines.at(-1);
         currentWidth = getStringWidth(currentLine);
       } else {
         currentLine = "";
@@ -603,7 +605,7 @@ const wordWrap = (string, options = {}) => {
   if (trim && string.trim() === "") {
     return "";
   }
-  let normalizedString = String(string).normalize("NFC").replaceAll("\r\n", "\n");
+  let normalizedString = string.normalize("NFC").replaceAll("\r\n", "\n");
   if (removeZeroWidthCharacters) {
     normalizedString = normalizedString.replaceAll(RE_ZERO_WIDTH, "");
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@visulima/string",
-  "version": "3.0.0-alpha.1",
+  "version": "3.0.0-alpha.10",
   "description": "Functions for manipulating strings.",
   "keywords": [
     "visulima",
@@ -228,7 +228,7 @@
     "CHANGELOG.md"
   ],
   "engines": {
-    "node": ">=22.13 <=25.x"
+    "node": "^22.14.0 || >=24.10.0"
   },
   "publishConfig": {
     "access": "public",

package/dist/packem_shared/closestN-BREy4E7C.js

@@ -1,19 +0,0 @@
-import { distance } from './closest-IHuSvnSn.js';
-export { closest } from './closest-IHuSvnSn.js';
-
-const closestN = (string_, array, n) => {
-  const distances = new Array(n).fill(Infinity);
-  const values = new Array(n).fill(null);
-  for (let value of array) {
-    let distribution = distance(string_, value);
-    for (let index = 0; index < n; index++) {
-      if (distribution < distances[index]) {
-        [distribution, distances[index]] = [distances[index], distribution];
-        [value, values[index]] = [values[index], value];
-      }
-    }
-  }
-  return values;
-};
-
-export { closestN, distance };

package/dist/packem_shared/lru-cache-B_t27XwI.d.ts

@@ -1,14 +0,0 @@
-declare class LRUCache<K, V> {
-    private readonly capacity;
-    private readonly cache;
-    private keyOrder;
-    constructor(capacity: number);
-    get(key: K): V | undefined;
-    has(key: K): boolean;
-    set(key: K, value: V): void;
-    delete(key: K): void;
-    clear(): void;
-    size(): number;
-}
-
-export { LRUCache as L };