@cjser/wrap-ansi 10.0.0-cjser.2 → 10.0.2-cjser.2

package/dist-cjser/index.cjs

@@ -26,22 +26,17 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// packages/@cjser/wrap-ansi/index.js
+// packages/@cjser/wrap-ansi.tmp-26-1790096744839/index.js
 var index_exports = {};
 __export(index_exports, {
   default: () => wrapAnsi
 });
 module.exports = __toCommonJS(index_exports);
 var import_string_width = __toESM(require("@cjser/string-width"), 1);
-var import_strip_ansi = __toESM(require("@cjser/strip-ansi"), 1);
-var import_ansi_styles = __toESM(require("@cjser/ansi-styles"), 1);
+var import_ansi_styles_v6_2_3 = __toESM(require("@cjser/ansi-styles__v6_2_3"), 1);
 var ANSI_ESCAPE = "\x1B";
-var ANSI_ESCAPE_CSI = "\x9B";
-var ESCAPES = /* @__PURE__ */ new Set([
-  ANSI_ESCAPE,
-  ANSI_ESCAPE_CSI
-]);
 var ANSI_ESCAPE_BELL = "\x07";
+var C1_CSI = "\x9B";
 var ANSI_CSI = "[";
 var ANSI_OSC = "]";
 var ANSI_SGR_TERMINATOR = "m";
@@ -52,47 +47,168 @@ var ANSI_SGR_RESET_UNDERLINE_COLOR = 59;
 var ANSI_SGR_FOREGROUND_EXTENDED = 38;
 var ANSI_SGR_BACKGROUND_EXTENDED = 48;
 var ANSI_SGR_UNDERLINE_COLOR_EXTENDED = 58;
-var ANSI_SGR_COLOR_MODE_256 = 5;
 var ANSI_SGR_COLOR_MODE_RGB = 2;
-var ANSI_ESCAPE_LINK = `${ANSI_OSC}8;;`;
-var ANSI_ESCAPE_REGEX = new RegExp(`^\\u001B(?:\\${ANSI_CSI}(?<sgr>[0-9;]*)${ANSI_SGR_TERMINATOR}|${ANSI_ESCAPE_LINK}(?<uri>[^\\u0007\\u001B]*)(?:\\u0007|\\u001B\\\\))`);
-var ANSI_ESCAPE_CSI_REGEX = new RegExp(`^\\u009B(?<sgr>[0-9;]*)${ANSI_SGR_TERMINATOR}`);
-var ANSI_SGR_MODIFIER_CLOSE_CODES = new Set(import_ansi_styles.default.codes.values());
+var ANSI_SGR_COLOR_MODE_256 = 5;
+var ANSI_ESCAPE_LINK = `${ANSI_OSC}8;`;
+var ESCAPES = /* @__PURE__ */ new Set([
+  ANSI_ESCAPE,
+  C1_CSI
+]);
+var ESCAPE_CHARACTERS = [...ESCAPES].join("");
+var CSI_INTRODUCER = `(?:${ANSI_ESCAPE}\\${ANSI_CSI}|${C1_CSI})`;
+var CSI_PARAMETERS = "[0-?]*[ -/]*[@-~]";
+var SGR_PARAMETERS = `(?<sgr>[0-9;:]*)${ANSI_SGR_TERMINATOR}`;
+var OSC_STRING_TERMINATOR = `(?:${ANSI_ESCAPE_BELL}|${ANSI_ESCAPE}\\\\)`;
+var OSC_STRING_PAYLOAD = String.raw`[^\u0000-\u001F\u007F-\u009F]*`;
+var LINK_PARAMETERS = String.raw`8;(?<parameters>[^;\u0000-\u001F\u007F-\u009F]*);(?<uri>${OSC_STRING_PAYLOAD})${OSC_STRING_TERMINATOR}`;
+var OSC_STRING = `${OSC_STRING_PAYLOAD}${OSC_STRING_TERMINATOR}`;
+var ANSI_ESCAPE_REGEX = new RegExp(
+  `${CSI_INTRODUCER}(?:${SGR_PARAMETERS}|${CSI_PARAMETERS})|${ANSI_ESCAPE}\\${ANSI_OSC}(?:${LINK_PARAMETERS}|${OSC_STRING})`,
+  "y"
+);
+var ANSI_SGR_MODIFIER_CLOSE_CODES = new Set(import_ansi_styles_v6_2_3.default.codes.values());
 ANSI_SGR_MODIFIER_CLOSE_CODES.delete(ANSI_SGR_RESET);
 var segmenter = new Intl.Segmenter();
-var getGraphemes = (string) => Array.from(segmenter.segment(string), ({ segment }) => segment);
+var getStringWidth = (string) => (0, import_string_width.default)(string, { countAnsiEscapeCodes: true });
 var TAB_SIZE = 8;
+var ESCAPE_INTRODUCER_REGEX = new RegExp(`[${ESCAPE_CHARACTERS}]`, "g");
+var ROW_BOUNDARY_REGEX = new RegExp(`[\\n${ESCAPE_CHARACTERS}]`, "g");
+var ASCII_PRINTABLE_REGEX = /^[ -~]*$/;
 var wrapAnsiCode = (code) => `${ANSI_ESCAPE}${ANSI_CSI}${code}${ANSI_SGR_TERMINATOR}`;
-var wrapAnsiHyperlink = (url) => `${ANSI_ESCAPE}${ANSI_ESCAPE_LINK}${url}${ANSI_ESCAPE_BELL}`;
+var wrapAnsiHyperlink = (url, parameters = "") => `${ANSI_ESCAPE}${ANSI_ESCAPE_LINK}${parameters};${url}${ANSI_ESCAPE_BELL}`;
+var matchAnsiEscape = (string, index) => {
+  if (!ESCAPES.has(string[index])) {
+    return;
+  }
+  ANSI_ESCAPE_REGEX.lastIndex = index;
+  return ANSI_ESCAPE_REGEX.exec(string) ?? void 0;
+};
+var forEachSegment = (string, onPlainText, onEscape = () => {
+}) => {
+  let plainStart = 0;
+  let index = 0;
+  while (index < string.length) {
+    ESCAPE_INTRODUCER_REGEX.lastIndex = index;
+    const introducer = ESCAPE_INTRODUCER_REGEX.exec(string);
+    if (!introducer) {
+      break;
+    }
+    const escape = matchAnsiEscape(string, introducer.index);
+    if (!escape) {
+      index = introducer.index + 1;
+      continue;
+    }
+    if (introducer.index > plainStart) {
+      onPlainText(string.slice(plainStart, introducer.index));
+    }
+    onEscape(escape[0]);
+    index = introducer.index + escape[0].length;
+    plainStart = index;
+  }
+  if (plainStart < string.length) {
+    onPlainText(string.slice(plainStart));
+  }
+};
+var getWidth = (string) => {
+  let plainText = "";
+  forEachSegment(string, (part) => {
+    plainText += part;
+  });
+  return getStringWidth(plainText);
+};
+var getTokens = (string) => {
+  const tokens = [];
+  forEachSegment(string, (plainText) => {
+    if (ASCII_PRINTABLE_REGEX.test(plainText)) {
+      for (const character of plainText) {
+        tokens.push({ value: character, width: 1 });
+      }
+      return;
+    }
+    for (const { segment } of segmenter.segment(plainText)) {
+      tokens.push({ value: segment, width: getStringWidth(segment) });
+    }
+  }, (escape) => {
+    tokens.push({ value: escape, width: 0 });
+  });
+  return tokens;
+};
+var splitWords = (string) => {
+  let currentWord = { value: "", plainText: "" };
+  const words = [currentWord];
+  forEachSegment(string, (plainText) => {
+    const parts = plainText.split(" ");
+    currentWord.value += parts[0];
+    currentWord.plainText += parts[0];
+    for (let index = 1; index < parts.length; index++) {
+      currentWord = { value: parts[index], plainText: parts[index] };
+      words.push(currentWord);
+    }
+  }, (escape) => {
+    currentWord.value += escape;
+  });
+  for (const word of words) {
+    word.width = getStringWidth(word.plainText);
+  }
+  return words;
+};
+var getColonColorToken = (parameter) => {
+  const parts = parameter.split(":");
+  const code = Number.parseInt(parts[0], 10);
+  const mode = Number.parseInt(parts[1], 10);
+  if (![ANSI_SGR_FOREGROUND_EXTENDED, ANSI_SGR_BACKGROUND_EXTENDED, ANSI_SGR_UNDERLINE_COLOR_EXTENDED].includes(code)) {
+    return;
+  }
+  if (mode === ANSI_SGR_COLOR_MODE_256 && parts.length === 3 && /^\d+$/.test(parts[2])) {
+    return { code, open: parameter, hasArguments: true };
+  }
+  if (mode !== ANSI_SGR_COLOR_MODE_RGB) {
+    return;
+  }
+  const components = parts.length === 6 ? parts.slice(3) : parts.slice(2);
+  const colorSpace = parts.length === 6 ? parts[2] : void 0;
+  if (components.length === 3 && components.every((component) => /^\d+$/.test(component)) && (colorSpace === void 0 || /^\d*$/.test(colorSpace))) {
+    return { code, open: parameter, hasArguments: true };
+  }
+};
 var getSgrTokens = (sgrParameters) => {
-  const codes = sgrParameters.split(";").map((sgrParameter) => sgrParameter === "" ? ANSI_SGR_RESET : Number.parseInt(sgrParameter, 10));
+  const parameters = sgrParameters.split(";");
   const sgrTokens = [];
-  for (let index = 0; index < codes.length; index++) {
-    const code = codes[index];
+  for (let index = 0; index < parameters.length; index++) {
+    const parameter = parameters[index];
+    if (parameter.includes(":")) {
+      const colonColorToken = getColonColorToken(parameter);
+      if (colonColorToken) {
+        sgrTokens.push(colonColorToken);
+      }
+      continue;
+    }
+    const code = parameter === "" ? ANSI_SGR_RESET : Number.parseInt(parameter, 10);
     if (!Number.isFinite(code)) {
       continue;
     }
     if (code === ANSI_SGR_FOREGROUND_EXTENDED || code === ANSI_SGR_BACKGROUND_EXTENDED || code === ANSI_SGR_UNDERLINE_COLOR_EXTENDED) {
-      if (index + 1 >= codes.length) {
+      if (index + 1 >= parameters.length) {
         break;
       }
-      const mode = codes[index + 1];
-      if (mode === ANSI_SGR_COLOR_MODE_256 && Number.isFinite(codes[index + 2])) {
-        sgrTokens.push([code, mode, codes[index + 2]]);
+      const mode = Number.parseInt(parameters[index + 1], 10);
+      const colorIndex = Number.parseInt(parameters[index + 2], 10);
+      if (mode === ANSI_SGR_COLOR_MODE_256 && Number.isFinite(colorIndex)) {
+        sgrTokens.push({ code, open: [code, mode, colorIndex].join(";"), hasArguments: true });
         index += 2;
         continue;
       }
-      const red = codes[index + 2];
-      const green = codes[index + 3];
-      const blue = codes[index + 4];
+      const red = Number.parseInt(parameters[index + 2], 10);
+      const green = Number.parseInt(parameters[index + 3], 10);
+      const blue = Number.parseInt(parameters[index + 4], 10);
       if (mode === ANSI_SGR_COLOR_MODE_RGB && Number.isFinite(red) && Number.isFinite(green) && Number.isFinite(blue)) {
-        sgrTokens.push([code, mode, red, green, blue]);
+        sgrTokens.push({ code, open: [code, mode, red, green, blue].join(";"), hasArguments: true });
         index += 4;
         continue;
       }
       break;
     }
-    sgrTokens.push([code]);
+    sgrTokens.push({ code, open: String(code), hasArguments: false });
   }
   return sgrTokens;
 };
@@ -114,25 +230,26 @@ var removeModifierStylesByClose = (activeStyles, closeCode) => {
     }
   }
 };
-var getColorStyle = (code, sgrToken) => {
-  if (code >= 30 && code <= 37 || code >= 90 && code <= 97 || code === ANSI_SGR_FOREGROUND_EXTENDED && sgrToken.length > 1) {
+var getColorStyle = (sgrToken) => {
+  const { code, open, hasArguments } = sgrToken;
+  if (code >= 30 && code <= 37 || code >= 90 && code <= 97 || code === ANSI_SGR_FOREGROUND_EXTENDED && hasArguments) {
     return {
       family: "foreground",
-      open: sgrToken.join(";"),
+      open,
       close: ANSI_SGR_RESET_FOREGROUND
     };
   }
-  if (code >= 40 && code <= 47 || code >= 100 && code <= 107 || code === ANSI_SGR_BACKGROUND_EXTENDED && sgrToken.length > 1) {
+  if (code >= 40 && code <= 47 || code >= 100 && code <= 107 || code === ANSI_SGR_BACKGROUND_EXTENDED && hasArguments) {
     return {
       family: "background",
-      open: sgrToken.join(";"),
+      open,
       close: ANSI_SGR_RESET_BACKGROUND
     };
   }
-  if (code === ANSI_SGR_UNDERLINE_COLOR_EXTENDED && sgrToken.length > 1) {
+  if (code === ANSI_SGR_UNDERLINE_COLOR_EXTENDED && hasArguments) {
     return {
       family: "underlineColor",
-      open: sgrToken.join(";"),
+      open,
       close: ANSI_SGR_RESET_UNDERLINE_COLOR
     };
   }
@@ -161,20 +278,20 @@ var applySgrResetCode = (code, activeStyles) => {
   return false;
 };
 var applySgrToken = (sgrToken, activeStyles) => {
-  const [code] = sgrToken;
+  const { code } = sgrToken;
   if (applySgrResetCode(code, activeStyles)) {
     return;
   }
-  const colorStyle = getColorStyle(code, sgrToken);
+  const colorStyle = getColorStyle(sgrToken);
   if (colorStyle) {
     upsertActiveStyle(activeStyles, colorStyle);
     return;
   }
-  const close = import_ansi_styles.default.codes.get(code);
+  const close = import_ansi_styles_v6_2_3.default.codes.get(code);
   if (close !== void 0 && close !== ANSI_SGR_RESET) {
     upsertActiveStyle(activeStyles, {
       family: `modifier-${code}`,
-      open: sgrToken.join(";"),
+      open: sgrToken.open,
       close
     });
   }
@@ -185,71 +302,37 @@ var applySgrParameters = (sgrParameters, activeStyles) => {
   }
 };
 var applySgrResets = (sgrParameters, activeStyles) => {
-  for (const sgrToken of getSgrTokens(sgrParameters)) {
-    const [code] = sgrToken;
+  for (const { code } of getSgrTokens(sgrParameters)) {
     applySgrResetCode(code, activeStyles);
   }
 };
-var applyLeadingSgrResets = (string, activeStyles) => {
-  let remainder = string;
-  while (remainder.length > 0) {
-    if (remainder.startsWith(ANSI_ESCAPE) && remainder[1] !== "\\") {
-      const match = ANSI_ESCAPE_REGEX.exec(remainder);
-      if (!match) {
-        break;
-      }
-      if (match.groups.sgr !== void 0) {
-        applySgrResets(match.groups.sgr, activeStyles);
-      }
-      remainder = remainder.slice(match[0].length);
-      continue;
+var applyLeadingSgrResets = (string, startIndex, activeStyles) => {
+  let index = startIndex;
+  while (index < string.length) {
+    const match = matchAnsiEscape(string, index);
+    if (!match) {
+      break;
     }
-    if (remainder.startsWith(ANSI_ESCAPE_CSI)) {
-      const match = ANSI_ESCAPE_CSI_REGEX.exec(remainder);
-      if (!match || match.groups.sgr === void 0) {
-        break;
-      }
+    if (match.groups.sgr !== void 0) {
       applySgrResets(match.groups.sgr, activeStyles);
-      remainder = remainder.slice(match[0].length);
-      continue;
     }
-    break;
+    index += match[0].length;
   }
 };
 var getClosingSgrSequence = (activeStyles) => [...activeStyles].reverse().map((activeStyle) => wrapAnsiCode(activeStyle.close)).join("");
 var getOpeningSgrSequence = (activeStyles) => activeStyles.map((activeStyle) => wrapAnsiCode(activeStyle.open)).join("");
-var wordLengths = (string) => string.split(" ").map((word) => (0, import_string_width.default)(word));
-var wrapWord = (rows, word, columns) => {
-  const characters = getGraphemes(word);
-  let isInsideEscape = false;
-  let isInsideLinkEscape = false;
-  let visible = (0, import_string_width.default)((0, import_strip_ansi.default)(rows.at(-1)));
-  for (const [index, character] of characters.entries()) {
-    const characterLength = (0, import_string_width.default)(character);
-    if (visible + characterLength <= columns) {
-      rows[rows.length - 1] += character;
-    } else {
-      rows.push(character);
+var wrapWord = (rows, word, columns, rowWidth) => {
+  const tokens = getTokens(word);
+  let visible = rowWidth;
+  for (let index = 0; index < tokens.length; index++) {
+    const token = tokens[index];
+    if (token.width > 0 && visible > 0 && visible + token.width > columns) {
+      rows.push("");
       visible = 0;
     }
-    if (ESCAPES.has(character) && !(isInsideLinkEscape && character === ANSI_ESCAPE && characters[index + 1] === "\\")) {
-      isInsideEscape = true;
-      const ansiEscapeLinkCandidate = characters.slice(index + 1, index + 1 + ANSI_ESCAPE_LINK.length).join("");
-      isInsideLinkEscape = ansiEscapeLinkCandidate === ANSI_ESCAPE_LINK;
-    }
-    if (isInsideEscape) {
-      if (isInsideLinkEscape) {
-        if (character === ANSI_ESCAPE_BELL || character === "\\" && index > 0 && characters[index - 1] === ANSI_ESCAPE) {
-          isInsideEscape = false;
-          isInsideLinkEscape = false;
-        }
-      } else if (character === ANSI_SGR_TERMINATOR) {
-        isInsideEscape = false;
-      }
-      continue;
-    }
-    visible += characterLength;
-    if (visible === columns && index < characters.length - 1) {
+    rows[rows.length - 1] += token.value;
+    visible += token.width;
+    if (visible === columns && index < tokens.length - 1) {
       rows.push("");
       visible = 0;
     }
@@ -257,54 +340,134 @@ var wrapWord = (rows, word, columns) => {
   if (!visible && rows.at(-1).length > 0 && rows.length > 1) {
     rows[rows.length - 2] += rows.pop();
   }
+  return getWidth(rows.at(-1));
 };
 var stringVisibleTrimSpacesRight = (string) => {
-  const words = string.split(" ");
-  let last = words.length;
-  while (last > 0) {
-    if ((0, import_string_width.default)(words[last - 1]) > 0) {
+  if (!string.includes(" ")) {
+    return string;
+  }
+  const segments = [];
+  forEachSegment(string, (plainText) => {
+    segments.push({ value: plainText, isEscape: false });
+  }, (escape) => {
+    segments.push({ value: escape, isEscape: true });
+  });
+  for (let index = segments.length - 1; index >= 0; index--) {
+    const segment = segments[index];
+    if (segment.isEscape) {
+      continue;
+    }
+    let end = segment.value.length;
+    while (end > 0 && segment.value[end - 1] === " ") {
+      end--;
+    }
+    segment.value = segment.value.slice(0, end);
+    if (getStringWidth(segment.value) > 0) {
       break;
     }
-    last--;
   }
-  if (last === words.length) {
-    return string;
-  }
-  return words.slice(0, last).join(" ") + words.slice(last).join("");
+  return segments.map((segment) => segment.value).join("");
 };
 var expandTabs = (line) => {
   if (!line.includes("	")) {
     return line;
   }
-  const segments = line.split("	");
   let visible = 0;
   let expandedLine = "";
-  for (const [index, segment] of segments.entries()) {
-    expandedLine += segment;
-    visible += (0, import_string_width.default)(segment);
-    if (index < segments.length - 1) {
-      const spaces = TAB_SIZE - visible % TAB_SIZE;
-      expandedLine += " ".repeat(spaces);
-      visible += spaces;
+  let plainTextSinceTab = "";
+  const expandPlainText = (plainText) => {
+    const segments = plainText.split("	");
+    for (const [index, segment] of segments.entries()) {
+      expandedLine += segment;
+      plainTextSinceTab += segment;
+      if (index < segments.length - 1) {
+        visible += getStringWidth(plainTextSinceTab);
+        plainTextSinceTab = "";
+        const spaces = TAB_SIZE - visible % TAB_SIZE;
+        expandedLine += " ".repeat(spaces);
+        visible += spaces;
+      }
     }
-  }
+  };
+  forEachSegment(line, expandPlainText, (escape) => {
+    expandedLine += escape;
+  });
   return expandedLine;
 };
+var restoreStylesAcrossRows = (preString) => {
+  let returnValue = "";
+  let activeHyperlink;
+  const activeStyles = [];
+  let index = 0;
+  let copiedIndex = 0;
+  while (index < preString.length) {
+    ROW_BOUNDARY_REGEX.lastIndex = index;
+    const boundary = ROW_BOUNDARY_REGEX.exec(preString);
+    if (!boundary) {
+      break;
+    }
+    index = boundary.index;
+    if (boundary[0] !== "\n") {
+      const escape = matchAnsiEscape(preString, index);
+      if (!escape) {
+        index++;
+        continue;
+      }
+      const { groups } = escape;
+      if (groups.sgr !== void 0) {
+        applySgrParameters(groups.sgr, activeStyles);
+      } else if (groups.uri !== void 0) {
+        activeHyperlink = groups.uri.length === 0 ? void 0 : { parameters: groups.parameters, uri: groups.uri };
+      }
+      index += escape[0].length;
+      continue;
+    }
+    returnValue += preString.slice(copiedIndex, index);
+    if (index > copiedIndex) {
+      if (activeHyperlink) {
+        returnValue += wrapAnsiHyperlink("");
+      }
+      returnValue += getClosingSgrSequence(activeStyles);
+    }
+    returnValue += "\n";
+    index++;
+    copiedIndex = index;
+    if (index < preString.length && preString[index] !== "\n") {
+      const openingStyles = [...activeStyles];
+      applyLeadingSgrResets(preString, index, openingStyles);
+      returnValue += getOpeningSgrSequence(openingStyles);
+      if (activeHyperlink) {
+        returnValue += wrapAnsiHyperlink(activeHyperlink.uri, activeHyperlink.parameters);
+      }
+    }
+  }
+  return returnValue + preString.slice(copiedIndex);
+};
 var exec = (string, columns, options = {}) => {
   if (options.trim !== false && string.trim() === "") {
     return "";
   }
-  let returnValue = "";
-  let escapeUrl;
-  const activeStyles = [];
-  const lengths = wordLengths(string);
+  const words = splitWords(string);
   let rows = [""];
-  for (const [index, word] of string.split(" ").entries()) {
-    if (options.trim !== false) {
-      rows[rows.length - 1] = rows.at(-1).trimStart();
+  let rowLength = 0;
+  let trimmedRowIndex = -1;
+  let isFirstWord = true;
+  for (const word of words) {
+    const rowIndex = rows.length - 1;
+    if (options.trim !== false && trimmedRowIndex !== rowIndex) {
+      const row = rows[rowIndex];
+      const trimmedRow = row.trimStart();
+      if (trimmedRow.length !== row.length) {
+        rows[rowIndex] = trimmedRow;
+        rowLength = getWidth(trimmedRow);
+      }
+      if (trimmedRow.length > 0) {
+        trimmedRowIndex = rowIndex;
+      }
     }
-    let rowLength = (0, import_string_width.default)(rows.at(-1));
-    if (index !== 0) {
+    if (isFirstWord) {
+      isFirstWord = false;
+    } else {
       if (rowLength >= columns && (options.wordWrap === false || options.trim === false)) {
         rows.push("");
         rowLength = 0;
@@ -314,67 +477,46 @@ var exec = (string, columns, options = {}) => {
         rowLength++;
       }
     }
-    if (options.hard && options.wordWrap !== false && lengths[index] > columns) {
+    if (options.hard && options.wordWrap !== false && word.width > columns) {
       const remainingColumns = columns - rowLength;
-      const breaksStartingThisLine = 1 + Math.floor((lengths[index] - remainingColumns - 1) / columns);
-      const breaksStartingNextLine = Math.floor((lengths[index] - 1) / columns);
+      const breaksStartingThisLine = 1 + Math.floor((word.width - remainingColumns - 1) / columns);
+      const breaksStartingNextLine = Math.floor((word.width - 1) / columns);
       if (breaksStartingNextLine < breaksStartingThisLine) {
         rows.push("");
+        rowLength = 0;
       }
-      wrapWord(rows, word, columns);
+      rowLength = wrapWord(rows, word.value, columns, rowLength);
       continue;
     }
-    if (rowLength + lengths[index] > columns && rowLength > 0 && lengths[index] > 0) {
+    if (rowLength + word.width > columns && rowLength > 0 && word.width > 0) {
       if (options.wordWrap === false && rowLength < columns) {
-        wrapWord(rows, word, columns);
+        rowLength = wrapWord(rows, word.value, columns, rowLength);
         continue;
       }
       rows.push("");
+      rowLength = 0;
     }
-    if (rowLength + lengths[index] > columns && options.wordWrap === false) {
-      wrapWord(rows, word, columns);
+    if (rowLength + word.width > columns && options.wordWrap === false) {
+      rowLength = wrapWord(rows, word.value, columns, rowLength);
       continue;
     }
-    rows[rows.length - 1] += word;
+    rows[rows.length - 1] += word.value;
+    rowLength += word.width;
   }
   if (options.trim !== false) {
     rows = rows.map((row) => stringVisibleTrimSpacesRight(row));
   }
-  const preString = rows.join("\n");
-  const pre = getGraphemes(preString);
-  let preStringIndex = 0;
-  for (const [index, character] of pre.entries()) {
-    returnValue += character;
-    if (character === ANSI_ESCAPE && pre[index + 1] !== "\\") {
-      const { groups } = ANSI_ESCAPE_REGEX.exec(preString.slice(preStringIndex)) || { groups: {} };
-      if (groups.sgr !== void 0) {
-        applySgrParameters(groups.sgr, activeStyles);
-      } else if (groups.uri !== void 0) {
-        escapeUrl = groups.uri.length === 0 ? void 0 : groups.uri;
-      }
-    } else if (character === ANSI_ESCAPE_CSI) {
-      const { groups } = ANSI_ESCAPE_CSI_REGEX.exec(preString.slice(preStringIndex)) || { groups: {} };
-      if (groups.sgr !== void 0) {
-        applySgrParameters(groups.sgr, activeStyles);
-      }
-    }
-    if (pre[index + 1] === "\n") {
-      if (escapeUrl) {
-        returnValue += wrapAnsiHyperlink("");
-      }
-      returnValue += getClosingSgrSequence(activeStyles);
-    } else if (character === "\n") {
-      const openingStyles = [...activeStyles];
-      applyLeadingSgrResets(preString.slice(preStringIndex + 1), openingStyles);
-      returnValue += getOpeningSgrSequence(openingStyles);
-      if (escapeUrl) {
-        returnValue += wrapAnsiHyperlink(escapeUrl);
-      }
-    }
-    preStringIndex += character.length;
-  }
-  return returnValue;
+  return restoreStylesAcrossRows(rows.join("\n"));
+};
+var normalizeText = (string) => {
+  let normalizedString = "";
+  forEachSegment(string, (plainText) => {
+    normalizedString += plainText.normalize();
+  }, (escape) => {
+    normalizedString += escape;
+  });
+  return normalizedString;
 };
 function wrapAnsi(string, columns, options) {
-  return String(string).normalize().replaceAll("\r\n", "\n").split("\n").map((line) => exec(expandTabs(line), columns, options)).join("\n");
+  return normalizeText(String(string)).replaceAll("\r\n", "\n").split("\n").map((line) => exec(expandTabs(line), columns, options)).join("\n");
 }