mixdog 1.3.3 → 1.3.5

package/src/tui/dist/index.mjs

@@ -27484,8 +27484,8 @@ function eastAsianWidth(codePoint, { ambiguousAsWide = false } = {}) {
 
 // node_modules/string-width/index.js
 var segmenter = new Intl.Segmenter();
-var zeroWidthClusterRegex = new RegExp("^(?:\\p{Default_Ignorable_Code_Point}|\\p{Control}|\\p{Format}|\\p{Mark}|\\p{Surrogate})+$", "v");
-var leadingNonPrintingRegex = new RegExp("^[\\p{Default_Ignorable_Code_Point}\\p{Control}\\p{Format}\\p{Mark}\\p{Surrogate}]+", "v");
+var visibleCharacterRegex = new RegExp("[^\\p{Default_Ignorable_Code_Point}\\p{Control}\\p{Format}\\p{Nonspacing_Mark}\\p{Enclosing_Mark}\\p{Surrogate}]", "v");
+var spacingMarkRegex = new RegExp("\\p{Spacing_Mark}", "v");
 var rgiEmojiRegex = new RegExp("^\\p{RGI_Emoji}$", "v");
 var unqualifiedKeycapRegex = /^[\d#*]\u20E3$/;
 var extendedPictographicRegex = new RegExp("\\p{Extended_Pictographic}", "gu");
@@ -27503,10 +27503,8 @@ function isDoubleWidthNonRgiEmojiSequence(segment) {
   return false;
 }
 function baseVisible(segment) {
-  return segment.replace(leadingNonPrintingRegex, "");
-}
-function isZeroWidthCluster(segment) {
-  return zeroWidthClusterRegex.test(segment);
+  const index = segment.search(visibleCharacterRegex);
+  return index === -1 ? void 0 : segment.slice(index);
 }
 function isHangulLeadingJamo(codePoint) {
   return codePoint >= 4352 && codePoint <= 4447 || codePoint >= 43360 && codePoint <= 43388;
@@ -27523,7 +27521,7 @@ function isHangulJamo(codePoint) {
 function hangulClusterWidth(visibleSegment, eastAsianWidthOptions) {
   const codePoints = [];
   for (const character of visibleSegment) {
-    if (zeroWidthClusterRegex.test(character)) {
+    if (!visibleCharacterRegex.test(character)) {
       continue;
     }
     codePoints.push(character.codePointAt(0));
@@ -27552,7 +27550,7 @@ function hangulClusterWidth(visibleSegment, eastAsianWidthOptions) {
   }
   return width;
 }
-function trailingHalfwidthWidth(visibleSegment, eastAsianWidthOptions) {
+function trailingWidth(visibleSegment, eastAsianWidthOptions) {
   let extra = 0;
   let first = true;
   for (const character of visibleSegment) {
@@ -27560,7 +27558,7 @@ function trailingHalfwidthWidth(visibleSegment, eastAsianWidthOptions) {
       first = false;
       continue;
     }
-    if (character >= "\uFF00" && character <= "\uFFEF") {
+    if (spacingMarkRegex.test(character) || character >= "\uFF00" && character <= "\uFFEF") {
       extra += eastAsianWidth(character.codePointAt(0), eastAsianWidthOptions);
     }
   }
@@ -27587,14 +27585,14 @@ function stringWidth(input, options = {}) {
   let width = 0;
   const eastAsianWidthOptions = { ambiguousAsWide: !ambiguousIsNarrow };
   for (const { segment } of segmenter.segment(string)) {
-    if (isZeroWidthCluster(segment)) {
+    const visibleSegment = baseVisible(segment);
+    if (visibleSegment === void 0) {
       continue;
     }
     if (rgiEmojiRegex.test(segment) || isDoubleWidthNonRgiEmojiSequence(segment)) {
       width += 2;
       continue;
     }
-    const visibleSegment = baseVisible(segment);
     const hangulWidth = hangulClusterWidth(visibleSegment, eastAsianWidthOptions);
     if (hangulWidth !== void 0) {
       width += hangulWidth;
@@ -27602,7 +27600,7 @@ function stringWidth(input, options = {}) {
     }
     const codePoint = visibleSegment.codePointAt(0);
     width += eastAsianWidth(codePoint, eastAsianWidthOptions);
-    width += trailingHalfwidthWidth(visibleSegment, eastAsianWidthOptions);
+    width += trailingWidth(visibleSegment, eastAsianWidthOptions);
   }
   return width;
 }
@@ -27795,12 +27793,8 @@ var ansi_styles_default = ansiStyles;
 
 // node_modules/wrap-ansi/index.js
 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";
@@ -27811,47 +27805,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_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(ansi_styles_default.codes.values());
 ANSI_SGR_MODIFIER_CLOSE_CODES.delete(ANSI_SGR_RESET);
 var segmenter2 = new Intl.Segmenter();
-var getGraphemes = (string) => Array.from(segmenter2.segment(string), ({ segment }) => segment);
+var getStringWidth = (string) => stringWidth(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 escape3 = matchAnsiEscape(string, introducer.index);
+    if (!escape3) {
+      index = introducer.index + 1;
+      continue;
+    }
+    if (introducer.index > plainStart) {
+      onPlainText(string.slice(plainStart, introducer.index));
+    }
+    onEscape(escape3[0]);
+    index = introducer.index + escape3[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 segmenter2.segment(plainText)) {
+      tokens.push({ value: segment, width: getStringWidth(segment) });
+    }
+  }, (escape3) => {
+    tokens.push({ value: escape3, 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);
+    }
+  }, (escape3) => {
+    currentWord.value += escape3;
+  });
+  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 red2 = codes[index + 2];
-      const green2 = codes[index + 3];
-      const blue2 = codes[index + 4];
+      const red2 = Number.parseInt(parameters[index + 2], 10);
+      const green2 = Number.parseInt(parameters[index + 3], 10);
+      const blue2 = Number.parseInt(parameters[index + 4], 10);
       if (mode === ANSI_SGR_COLOR_MODE_RGB && Number.isFinite(red2) && Number.isFinite(green2) && Number.isFinite(blue2)) {
-        sgrTokens.push([code, mode, red2, green2, blue2]);
+        sgrTokens.push({ code, open: [code, mode, red2, green2, blue2].join(";"), hasArguments: true });
         index += 4;
         continue;
       }
       break;
     }
-    sgrTokens.push([code]);
+    sgrTokens.push({ code, open: String(code), hasArguments: false });
   }
   return sgrTokens;
 };
@@ -27873,25 +27988,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
     };
   }
@@ -27920,11 +28036,11 @@ 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;
@@ -27933,7 +28049,7 @@ var applySgrToken = (sgrToken, activeStyles) => {
   if (close !== void 0 && close !== ANSI_SGR_RESET) {
     upsertActiveStyle(activeStyles, {
       family: `modifier-${code}`,
-      open: sgrToken.join(";"),
+      open: sgrToken.open,
       close
     });
   }
@@ -27944,71 +28060,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) => stringWidth(word));
-var wrapWord = (rows2, word, columns) => {
-  const characters = getGraphemes(word);
-  let isInsideEscape = false;
-  let isInsideLinkEscape = false;
-  let visible = stringWidth(stripAnsi(rows2.at(-1)));
-  for (const [index, character] of characters.entries()) {
-    const characterLength = stringWidth(character);
-    if (visible + characterLength <= columns) {
-      rows2[rows2.length - 1] += character;
-    } else {
-      rows2.push(character);
+var wrapWord = (rows2, 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) {
+      rows2.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) {
+    rows2[rows2.length - 1] += token.value;
+    visible += token.width;
+    if (visible === columns && index < tokens.length - 1) {
       rows2.push("");
       visible = 0;
     }
@@ -28016,54 +28098,134 @@ var wrapWord = (rows2, word, columns) => {
   if (!visible && rows2.at(-1).length > 0 && rows2.length > 1) {
     rows2[rows2.length - 2] += rows2.pop();
   }
+  return getWidth(rows2.at(-1));
 };
 var stringVisibleTrimSpacesRight = (string) => {
-  const words = string.split(" ");
-  let last = words.length;
-  while (last > 0) {
-    if (stringWidth(words[last - 1]) > 0) {
+  if (!string.includes(" ")) {
+    return string;
+  }
+  const segments = [];
+  forEachSegment(string, (plainText) => {
+    segments.push({ value: plainText, isEscape: false });
+  }, (escape3) => {
+    segments.push({ value: escape3, 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 += stringWidth(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, (escape3) => {
+    expandedLine += escape3;
+  });
   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 escape3 = matchAnsiEscape(preString, index);
+      if (!escape3) {
+        index++;
+        continue;
+      }
+      const { groups } = escape3;
+      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 += escape3[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 rows2 = [""];
-  for (const [index, word] of string.split(" ").entries()) {
-    if (options.trim !== false) {
-      rows2[rows2.length - 1] = rows2.at(-1).trimStart();
-    }
-    let rowLength = stringWidth(rows2.at(-1));
-    if (index !== 0) {
+  let rowLength = 0;
+  let trimmedRowIndex = -1;
+  let isFirstWord = true;
+  for (const word of words) {
+    const rowIndex = rows2.length - 1;
+    if (options.trim !== false && trimmedRowIndex !== rowIndex) {
+      const row = rows2[rowIndex];
+      const trimmedRow = row.trimStart();
+      if (trimmedRow.length !== row.length) {
+        rows2[rowIndex] = trimmedRow;
+        rowLength = getWidth(trimmedRow);
+      }
+      if (trimmedRow.length > 0) {
+        trimmedRowIndex = rowIndex;
+      }
+    }
+    if (isFirstWord) {
+      isFirstWord = false;
+    } else {
       if (rowLength >= columns && (options.wordWrap === false || options.trim === false)) {
         rows2.push("");
         rowLength = 0;
@@ -28073,69 +28235,48 @@ 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) {
         rows2.push("");
+        rowLength = 0;
       }
-      wrapWord(rows2, word, columns);
+      rowLength = wrapWord(rows2, 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(rows2, word, columns);
+        rowLength = wrapWord(rows2, word.value, columns, rowLength);
         continue;
       }
       rows2.push("");
+      rowLength = 0;
     }
-    if (rowLength + lengths[index] > columns && options.wordWrap === false) {
-      wrapWord(rows2, word, columns);
+    if (rowLength + word.width > columns && options.wordWrap === false) {
+      rowLength = wrapWord(rows2, word.value, columns, rowLength);
       continue;
     }
-    rows2[rows2.length - 1] += word;
+    rows2[rows2.length - 1] += word.value;
+    rowLength += word.width;
   }
   if (options.trim !== false) {
     rows2 = rows2.map((row) => stringVisibleTrimSpacesRight(row));
   }
-  const preString = rows2.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(rows2.join("\n"));
+};
+var normalizeText = (string) => {
+  let normalizedString = "";
+  forEachSegment(string, (plainText) => {
+    normalizedString += plainText.normalize();
+  }, (escape3) => {
+    normalizedString += escape3;
+  });
+  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");
 }
 
 // node_modules/terminal-size/index.js
@@ -51206,6 +51347,7 @@ var PROVIDER_CATALOGS = Object.freeze({
     rosterLimitsAuthoritative: true
   },
   "cursor-oauth": { relay: true },
+  "devin-oauth": { relay: true },
   "cursor-api": { relay: true },
   // The models.dev listing id of the Go gateway: a relay catalog, not a
   // selectable provider (the model lookup needs it flagged as a relay).
@@ -59529,6 +59671,7 @@ var PROVIDER_DISPLAY_NAMES = /* @__PURE__ */ new Map([
   ["command-code-oauth", "Command Code"],
   ["mimo-oauth", "MiMo"],
   ["cursor-oauth", "Cursor OAuth"],
+  ["devin-oauth", "Devin"],
   ["antigravity-oauth", "Antigravity OAuth"],
   ["openai", "OpenAI API"],
   ["openai-api", "OpenAI API"],
@@ -59613,6 +59756,7 @@ var PROVIDER_DISPLAY_RANKS = {
   "mimo-oauth": 34,
   "antigravity-oauth": 31,
   "cursor-oauth": 32,
+  "devin-oauth": 32.5,
   "opencode-go-oauth": 34.5,
   openai: 40,
   "openai-api": 40,
@@ -61990,12 +62134,30 @@ function markUserDataInitialized(dataDir2) {
 }
 var ensuredDataDirs = /* @__PURE__ */ new Set();
 function ensureUserDataInitialized(dataDir2) {
-  if (!dataDir2) return;
+  if (!dataDir2 || skipBackups()) return;
   const key = normalizeDataDir(dataDir2);
   if (ensuredDataDirs.has(key)) return;
-  if (!hasUserDataInitMarker(dataDir2)) backupUserData(dataDir2, "initial-snapshot");
+  if (!hasPublishedBackup(dataDir2)) {
+    backupUserData(dataDir2, "initial-snapshot");
+    if (!hasPublishedBackup(dataDir2)) return;
+  }
   ensuredDataDirs.add(key);
 }
+function hasPublishedBackup(dataDir2) {
+  const instanceId = readInitInstanceId(dataDir2);
+  if (!instanceId) return false;
+  const key = normalizeDataDir(dataDir2);
+  const scopeDir = scopeDirFor(dataDir2);
+  return listBackupDirsNewestFirst(scopeDir).some((name) => {
+    try {
+      const manifest = JSON.parse(readFileSync10(manifestPath(scopeDir, name), "utf8"));
+      return typeof manifest?.dataDir === "string" && normalizeDataDir(manifest.dataDir) === key && manifest.instanceId === instanceId;
+    } catch (error) {
+      if (isAbsentBackupError(error)) return false;
+      throw error;
+    }
+  });
+}
 function skipBackups() {
   return process.env.MIXDOG_SKIP_USER_DATA_BACKUP === "1" || process.env.MIXDOG_SKIP_USER_DATA_BACKUP === "true";
 }
@@ -62129,6 +62291,7 @@ var {
   setSecret: _setSecret,
   deleteSecret: _deleteSecret,
   hasSecret: _hasSecret,
+  hasFallbackSecret: _hasFallbackSecret,
   setSecretAsync: _setSecretAsyncImpl,
   deleteSecretAsync: _deleteSecretAsyncImpl,
   keychainStatus: _keychainStatus,