@visulima/string 2.0.6 → 3.0.0-alpha.2

package/dist/packem_shared/{joinSegments-CuU8RGpP.js → joinSegments-B4H6oZ9b.js}

@@ -1,4 +1,4 @@
-import { R as RE_FAST_ANSI } from './constants-CTzC6Gjg.js';
+import { R as RE_FAST_ANSI } from './constants-CnXdp6qx.js';
 
 const joinSegments = (segments, joiner) => {
   const { length } = segments;

package/dist/packem_shared/{replaceString-vYvRBMfC.js → replaceString-BVlxk27d.js}

@@ -99,17 +99,17 @@ const replaceString = (source, searches, ignoreRanges) => {
     }
     return b.end - a.end;
   });
-  const sortedIgnores = [...ignoreRanges].sort((a, b) => a[0] - b[0]);
+  const sortedIgnores = ignoreRanges.toSorted((a, b) => a[0] - b[0]);
   const mergedIgnores = mergeIntervals(sortedIgnores);
   const processedChars = source.split("").map((char, index) => {
     return {
-      appliedMatchId: null,
+      appliedMatchId: void 0,
       char,
       index,
-      insertBeforeReplacement: null,
+      insertBeforeReplacement: void 0,
       isIgnored: false,
       isMatchStart: false,
-      matchReplacement: null
+      matchReplacement: void 0
     };
   });
   for (const range of mergedIgnores) {
@@ -139,7 +139,7 @@ const replaceString = (source, searches, ignoreRanges) => {
     }
     let canApply = true;
     for (let index = match.start; index <= match.end; index++) {
-      if (!processedChars[index] || processedChars[index].isIgnored || processedChars[index].appliedMatchId !== null) {
+      if (!processedChars[index] || processedChars[index].isIgnored || processedChars[index].appliedMatchId !== void 0) {
         canApply = false;
         break;
       }
@@ -160,10 +160,10 @@ const replaceString = (source, searches, ignoreRanges) => {
   let currentIndex = 0;
   while (currentIndex < processedChars.length) {
     const pChar = processedChars[currentIndex];
-    if (pChar.insertBeforeReplacement !== null) {
+    if (pChar.insertBeforeReplacement !== void 0) {
       result += pChar.insertBeforeReplacement;
     }
-    if (pChar.isMatchStart && pChar.appliedMatchId !== null) {
+    if (pChar.isMatchStart && pChar.appliedMatchId !== void 0) {
       result += pChar.matchReplacement ?? "";
       let matchEndIndex = currentIndex;
       for (let index = currentIndex + 1; index < processedChars.length; index++) {
@@ -174,7 +174,7 @@ const replaceString = (source, searches, ignoreRanges) => {
         }
       }
       currentIndex = matchEndIndex + 1;
-    } else if (pChar.appliedMatchId === null) {
+    } else if (pChar.appliedMatchId === void 0) {
       result += pChar.char;
       currentIndex += 1;
     } else {

package/dist/packem_shared/{transliterate-CYnKKT8f.js → transliterate-a6LLM_Ei.js}

@@ -1,5 +1,5 @@
-import { G as RE_THAI } from './constants-CTzC6Gjg.js';
-import replaceString from './replaceString-vYvRBMfC.js';
+import { F as RE_THAI } from './constants-CnXdp6qx.js';
+import replaceString from './replaceString-BVlxk27d.js';
 import { findStringOccurrences, hasPunctuationOrSpace, hasChinese } from '../utilities.js';
 
 const UNICODE_BLOCK_0000_00FF = [
@@ -47618,7 +47618,7 @@ const formatReplaceOption = (option) => {
     return structuredClone(option);
   }
   const replaceArray = [];
-  for (const key in option) {
+  for (const key of Object.keys(option)) {
     if (Object.prototype.hasOwnProperty.call(option, key)) {
       const value = option[key];
       if (typeof value === "string") {
@@ -47687,8 +47687,6 @@ const transliterate = (source, options) => {
     const codePoint = input.codePointAt(index);
     if (codePoint === void 0) {
       char = input[index];
-      charLength = 1;
-      s = opt.unknown;
     } else {
       char = String.fromCodePoint(codePoint);
       charLength = char.length;

package/dist/packem_shared/{types-CfPsw9ix.d.ts → types-CHpmpy8C.d.ts}

@@ -1,4 +1,4 @@
-import { N as NodeLocale, k as IsStringLiteral } from './types-Daae0hGf.js';
+import { N as NodeLocale, k as IsStringLiteral } from './types-D2ydhHCv.js';
 import { L as LRUCache } from './lru-cache-B_t27XwI.js';
 
 type SplitterCharacter = " " | "_" | "-" | "." | "/";

package/dist/packem_shared/{types-Daae0hGf.d.ts → types-D2ydhHCv.d.ts}

@@ -14,7 +14,7 @@ type IsNumberLiteral<T extends number> = [T] extends [number] ? ([number] extend
 type IsBooleanLiteral<T extends boolean> = [T] extends [boolean] ? ([boolean] extends [T] ? false : true) : false;
 type Reverse<T extends string, Accumulator extends string = ""> = T extends `${infer Head}${infer Tail}` ? Reverse<Tail, `${Head}${Accumulator}`> : Accumulator extends "" ? T : `${T}${Accumulator}`;
 type Any<BoolArray extends boolean[]> = BoolArray extends [infer Head extends boolean, ...infer Rest extends boolean[]] ? IsBooleanLiteral<Head> extends true ? Head extends true ? true : Any<Rest> : Any<Rest> : false;
-type All<BoolArray extends boolean[]> = IsBooleanLiteral<BoolArray[number]> extends true ? BoolArray extends [infer Head extends boolean, ...infer Rest extends boolean[]] ? Head extends true ? Any<Rest> : false : true : false;
+type All<BoolArray extends boolean[]> = IsBooleanLiteral<BoolArray[number]> extends true ? BoolArray extends [infer Head extends boolean, ...infer Rest extends boolean[]] ? Head extends true ? All<Rest> : false : true : false;
 type IsStringLiteral<T extends string> = [T] extends [string] ? [string] extends [T] ? false : Uppercase<T> extends Uppercase<Lowercase<T>> ? Lowercase<T> extends Lowercase<Uppercase<T>> ? true : false : false : false;
 type IsStringLiteralArray<StringArray extends ReadonlyArray<string>> = IsStringLiteral<StringArray[number]> extends true ? true : false;
 type CharAt<T extends string, Index extends number> = All<[IsStringLiteral<T>, IsNumberLiteral<Index>]> extends true ? Split<T>[Index] : string;

package/dist/slice.js

@@ -1,4 +1,4 @@
-import { a as RE_VALID_ANSI_PAIRS, b as RE_VALID_HYPERLINKS, c as RE_ANSI } from './packem_shared/constants-CTzC6Gjg.js';
+import { g as RE_VALID_ANSI_PAIRS, h as RE_VALID_HYPERLINKS, i as RE_ANSI } from './packem_shared/constants-CnXdp6qx.js';
 import { getStringWidth } from './get-string-width.js';
 import LRUCache from './packem_shared/LRUCache-3r3SovvR.js';
 

package/dist/slugify.d.ts

@@ -1,4 +1,4 @@
-import { j as SlugifyOptions } from './packem_shared/types-Daae0hGf.js';
+import { j as SlugifyOptions } from './packem_shared/types-D2ydhHCv.js';
 
 declare const slugify: (input: string, options?: SlugifyOptions) => string;
 

package/dist/slugify.js

@@ -1,4 +1,4 @@
-import transliterate from './packem_shared/transliterate-CYnKKT8f.js';
+import transliterate from './packem_shared/transliterate-a6LLM_Ei.js';
 import { escapeRegExp } from './utilities.js';
 
 const removeDisallowedChars = (input, allowedChars, separator) => {

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}`);
@@ -49,8 +60,11 @@ const truncate = (input, limit, options = {}) => {
   switch (position) {
     case "end": {
       if (preferTruncationOnSpace) {
-        const nearestSpace = findNearestSpace(input, limit - 1);
-        return slice(input, 0, nearestSpace, {
+        const targetWidth = limit - ellipsisWidth;
+        const stringIndex = widthToIndex(input, targetWidth, options.width);
+        const nearestSpace = findNearestSpace(input, stringIndex);
+        const nearestSpaceWidth = indexToWidth(input, nearestSpace, options.width);
+        return slice(input, 0, nearestSpaceWidth, {
           width: options.width
         }) + ellipsis;
       }
@@ -60,21 +74,32 @@ const truncate = (input, limit, options = {}) => {
     }
     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(input, leftWidth, options.width);
+        const firstBreak = findNearestSpace(input, firstBreakIndex);
+        const firstBreakWidth = indexToWidth(input, firstBreak, options.width);
+        const secondBreakWidthTarget = width - rightWidth;
+        const secondBreakIndex = widthToIndex(input, secondBreakWidthTarget, options.width);
+        const secondBreak = findNearestSpace(input, secondBreakIndex, true);
+        const secondBreakWidthActual = indexToWidth(input, secondBreak, options.width);
+        return slice(input, 0, firstBreakWidth, { width: options.width }) + ellipsis + slice(input, secondBreakWidthActual, width, { width: options.width }).trim();
       }
-      return slice(input, 0, half, {
+      return slice(input, 0, leftWidth, {
         width: options.width
-      }) + ellipsis + slice(input, width - (limit - half) + ellipsisWidth, width, {
+      }) + ellipsis + slice(input, 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(input, targetWidth, options.width);
+        const nearestSpace = findNearestSpace(input, stringIndex, true);
+        const nearestSpaceWidth = indexToWidth(input, nearestSpace, options.width);
+        return ellipsis + slice(input, nearestSpaceWidth, width, { width: options.width }).trim();
       }
       return ellipsis + slice(input, width - limit + ellipsisWidth, width, {
         width: options.width

package/dist/utilities.d.ts

@@ -1,4 +1,4 @@
-import { l as IntervalArray } from './packem_shared/types-Daae0hGf.js';
+import { l as IntervalArray } from './packem_shared/types-D2ydhHCv.js';
 export { L as LRUCache } from './packem_shared/lru-cache-B_t27XwI.js';
 
 declare const escapeRegExp: (char: string) => string;

package/dist/word-wrap.js

@@ -1,9 +1,9 @@
-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-CnXdp6qx.js';
 import { getStringWidth } from './get-string-width.js';
 
 class AnsiStateTracker {
-  activeForeground = null;
-  activeBackground = null;
+  activeForeground = void 0;
+  activeBackground = void 0;
   // Track other formatting (bold, italic, etc.)
   activeFormatting = [];
   /**
@@ -18,17 +18,17 @@ class AnsiStateTracker {
     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: {
@@ -92,7 +92,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);
@@ -356,7 +356,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 +365,7 @@ const wrapWithBreakAtWidth = (string, width, trim) => {
       currentLine += char;
       const escapeInfo = checkEscapeSequence([...string], index);
       isInsideLinkEscape = escapeInfo.isInsideLinkEscape;
+      index += 1;
       continue;
     }
     if (isInsideEscape) {
@@ -377,12 +379,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 +398,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 +413,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,6 +436,7 @@ 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) => {
       if (segment.isEscapeSequence) {
         currentLine += segment.text;
@@ -550,8 +550,8 @@ 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];
         currentWidth = getStringWidth(currentLine);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@visulima/string",
-  "version": "2.0.6",
+  "version": "3.0.0-alpha.2",
   "description": "Functions for manipulating strings.",
   "keywords": [
     "visulima",
@@ -57,7 +57,7 @@
   "repository": {
     "type": "git",
     "url": "git+https://github.com/visulima/visulima.git",
-    "directory": "packages/string"
+    "directory": "packages/data-manipulation/string"
   },
   "funding": [
     {
@@ -228,7 +228,7 @@
     "CHANGELOG.md"
   ],
   "engines": {
-    "node": ">=20.19 <=25.x"
+    "node": ">=22.13 <=25.x"
   },
   "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 };