nolo-cli 0.213.0 → 0.222.0-alpha.2

package/{chunk-RPQXPZZF.js → chunk-F3GRJO4Z.js}

@@ -11,26 +11,902 @@ import {
   getAntigravityUserAgent,
   normalizeAntigravityTokenPayload,
   refreshAntigravityToken
-} from "./chunk-KIM6CLW5.js";
+} from "./chunk-SY3C4SQ7.js";
+import {
+  buildEnvFromProfile,
+  loadProfileConfig
+} from "./chunk-R5GO3YZP.js";
+import {
+  getCliLocale
+} from "./chunk-OB6DVWPF.js";
 import {
   toErrorMessage
 } from "./chunk-HNMXYYJR.js";
+import {
+  asTrimmedString
+} from "./chunk-3EUW3WEO.js";
 import {
   isRecord
 } from "./chunk-KUG52IAP.js";
-import {
-  buildEnvFromProfile,
-  loadProfileConfig
-} from "./chunk-R5GO3YZP.js";
-import {
-  writeOAuthCredential
-} from "./chunk-G7Y4GXTY.js";
 import {
   asOptionalFiniteNumber
 } from "./chunk-WWC7I6TA.js";
 import {
-  asTrimmedString
-} from "./chunk-3EUW3WEO.js";
+  writeOAuthCredential
+} from "./chunk-G7Y4GXTY.js";
+
+// packages/cli/tui/wtAmbiguousWidth.ts
+import fs from "node:fs";
+import path from "node:path";
+var WT_PACKAGE_NAMES = [
+  "Microsoft.WindowsTerminal_8wekyb3d8bbwe",
+  "Microsoft.WindowsTerminalPreview_8wekyb3d8bbwe"
+];
+function wtSettingsCandidates(env = process.env) {
+  const localAppData = env.LOCALAPPDATA;
+  if (typeof localAppData !== "string" || localAppData.trim() === "") return [];
+  return WT_PACKAGE_NAMES.map(
+    (name) => path.join(localAppData, "Packages", name, "LocalState", "settings.json")
+  );
+}
+function stripJsonComments(text) {
+  let out = "";
+  let inString = false;
+  let inLineComment = false;
+  let inBlockComment = false;
+  for (let i = 0; i < text.length; i += 1) {
+    const ch = text[i];
+    const next = text[i + 1];
+    if (inLineComment) {
+      if (ch === "\n") {
+        inLineComment = false;
+        out += ch;
+      }
+      continue;
+    }
+    if (inBlockComment) {
+      if (ch === "*" && next === "/") {
+        inBlockComment = false;
+        i += 1;
+      }
+      continue;
+    }
+    if (inString) {
+      out += ch;
+      if (ch === "\\") {
+        out += next ?? "";
+        i += 1;
+        continue;
+      }
+      if (ch === '"') inString = false;
+      continue;
+    }
+    if (ch === '"') {
+      inString = true;
+      out += ch;
+      continue;
+    }
+    if (ch === "/" && next === "/") {
+      inLineComment = true;
+      i += 1;
+      continue;
+    }
+    if (ch === "/" && next === "*") {
+      inBlockComment = true;
+      i += 1;
+      continue;
+    }
+    out += ch;
+  }
+  return out;
+}
+function parseAmbiguousWidthSetting(text) {
+  const active = stripJsonComments(text);
+  const match = active.match(/"(?:[A-Za-z0-9_]+\.)?ambiguousWidth"\s*:\s*"([A-Za-z]+)"/);
+  if (!match) return null;
+  const value = match[1].toLowerCase();
+  if (value === "wide") return "wide";
+  if (value === "narrow") return "narrow";
+  return null;
+}
+function detectWindowsTerminalAmbiguousWidth(deps = {}) {
+  const platform = deps.platform ?? process.platform;
+  if (platform !== "win32") return null;
+  const env = deps.env ?? process.env;
+  const readFile = deps.readFile ?? ((filePath) => {
+    try {
+      return fs.readFileSync(filePath, "utf8");
+    } catch {
+      return null;
+    }
+  });
+  for (const candidate of wtSettingsCandidates(env)) {
+    const text = readFile(candidate);
+    if (text === null) continue;
+    const parsed = parseAmbiguousWidthSetting(text);
+    return parsed ?? "narrow";
+  }
+  return null;
+}
+
+// node_modules/ansi-regex/index.js
+function ansiRegex({ onlyFirst = false } = {}) {
+  const ST = "(?:\\u0007|\\u001B\\u005C|\\u009C)";
+  const osc = `(?:\\u001B\\][^\\u0007\\u001B\\u009C]*${ST})`;
+  const csi = "[\\u001B\\u009B][[\\]()#;?]*(?:\\d{1,4}(?:[;:]\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]";
+  const pattern = `${osc}|${csi}`;
+  return new RegExp(pattern, onlyFirst ? void 0 : "g");
+}
+
+// node_modules/strip-ansi/index.js
+var regex = ansiRegex();
+function stripAnsi(string) {
+  if (typeof string !== "string") {
+    throw new TypeError(`Expected a \`string\`, got \`${typeof string}\``);
+  }
+  if (!string.includes("\x1B") && !string.includes("\x9B")) {
+    return string;
+  }
+  return string.replace(regex, "");
+}
+
+// node_modules/get-east-asian-width/lookup-data.js
+var ambiguousMinimalCodePoint = 161;
+var ambiguousMaximumCodePoint = 1114109;
+var ambiguousRanges = [161, 161, 164, 164, 167, 168, 170, 170, 173, 174, 176, 180, 182, 186, 188, 191, 198, 198, 208, 208, 215, 216, 222, 225, 230, 230, 232, 234, 236, 237, 240, 240, 242, 243, 247, 250, 252, 252, 254, 254, 257, 257, 273, 273, 275, 275, 283, 283, 294, 295, 299, 299, 305, 307, 312, 312, 319, 322, 324, 324, 328, 331, 333, 333, 338, 339, 358, 359, 363, 363, 462, 462, 464, 464, 466, 466, 468, 468, 470, 470, 472, 472, 474, 474, 476, 476, 593, 593, 609, 609, 708, 708, 711, 711, 713, 715, 717, 717, 720, 720, 728, 731, 733, 733, 735, 735, 768, 879, 913, 929, 931, 937, 945, 961, 963, 969, 1025, 1025, 1040, 1103, 1105, 1105, 8208, 8208, 8211, 8214, 8216, 8217, 8220, 8221, 8224, 8226, 8228, 8231, 8240, 8240, 8242, 8243, 8245, 8245, 8251, 8251, 8254, 8254, 8308, 8308, 8319, 8319, 8321, 8324, 8364, 8364, 8451, 8451, 8453, 8453, 8457, 8457, 8467, 8467, 8470, 8470, 8481, 8482, 8486, 8486, 8491, 8491, 8531, 8532, 8539, 8542, 8544, 8555, 8560, 8569, 8585, 8585, 8592, 8601, 8632, 8633, 8658, 8658, 8660, 8660, 8679, 8679, 8704, 8704, 8706, 8707, 8711, 8712, 8715, 8715, 8719, 8719, 8721, 8721, 8725, 8725, 8730, 8730, 8733, 8736, 8739, 8739, 8741, 8741, 8743, 8748, 8750, 8750, 8756, 8759, 8764, 8765, 8776, 8776, 8780, 8780, 8786, 8786, 8800, 8801, 8804, 8807, 8810, 8811, 8814, 8815, 8834, 8835, 8838, 8839, 8853, 8853, 8857, 8857, 8869, 8869, 8895, 8895, 8978, 8978, 9312, 9449, 9451, 9547, 9552, 9587, 9600, 9615, 9618, 9621, 9632, 9633, 9635, 9641, 9650, 9651, 9654, 9655, 9660, 9661, 9664, 9665, 9670, 9672, 9675, 9675, 9678, 9681, 9698, 9701, 9711, 9711, 9733, 9734, 9737, 9737, 9742, 9743, 9756, 9756, 9758, 9758, 9792, 9792, 9794, 9794, 9824, 9825, 9827, 9829, 9831, 9834, 9836, 9837, 9839, 9839, 9886, 9887, 9919, 9919, 9926, 9933, 9935, 9939, 9941, 9953, 9955, 9955, 9960, 9961, 9963, 9969, 9972, 9972, 9974, 9977, 9979, 9980, 9982, 9983, 10045, 10045, 10102, 10111, 11094, 11097, 12872, 12879, 57344, 63743, 65024, 65039, 65533, 65533, 127232, 127242, 127248, 127277, 127280, 127337, 127344, 127373, 127375, 127376, 127387, 127404, 917760, 917999, 983040, 1048573, 1048576, 1114109];
+var fullwidthMinimalCodePoint = 12288;
+var fullwidthMaximumCodePoint = 65510;
+var fullwidthRanges = [12288, 12288, 65281, 65376, 65504, 65510];
+var wideMinimalCodePoint = 4352;
+var wideMaximumCodePoint = 262141;
+var wideRanges = [4352, 4447, 8986, 8987, 9001, 9002, 9193, 9196, 9200, 9200, 9203, 9203, 9725, 9726, 9748, 9749, 9776, 9783, 9800, 9811, 9855, 9855, 9866, 9871, 9875, 9875, 9889, 9889, 9898, 9899, 9917, 9918, 9924, 9925, 9934, 9934, 9940, 9940, 9962, 9962, 9970, 9971, 9973, 9973, 9978, 9978, 9981, 9981, 9989, 9989, 9994, 9995, 10024, 10024, 10060, 10060, 10062, 10062, 10067, 10069, 10071, 10071, 10133, 10135, 10160, 10160, 10175, 10175, 11035, 11036, 11088, 11088, 11093, 11093, 11904, 11929, 11931, 12019, 12032, 12245, 12272, 12287, 12289, 12350, 12353, 12438, 12441, 12543, 12549, 12591, 12593, 12686, 12688, 12773, 12783, 12830, 12832, 12871, 12880, 42124, 42128, 42182, 43360, 43388, 44032, 55203, 63744, 64255, 65040, 65049, 65072, 65106, 65108, 65126, 65128, 65131, 94176, 94180, 94192, 94198, 94208, 101594, 101631, 101664, 101760, 101874, 101888, 102801, 102816, 102866, 110576, 110579, 110581, 110587, 110589, 110590, 110592, 110888, 110898, 110898, 110928, 110930, 110933, 110933, 110948, 110952, 110960, 111355, 119552, 119638, 119648, 119670, 126980, 126980, 127183, 127183, 127374, 127374, 127377, 127386, 127406, 127406, 127488, 127490, 127504, 127547, 127552, 127560, 127568, 127569, 127584, 127589, 127744, 127776, 127789, 127797, 127799, 127868, 127870, 127891, 127904, 127946, 127951, 127955, 127968, 127984, 127988, 127988, 127992, 128062, 128064, 128064, 128066, 128252, 128255, 128317, 128331, 128334, 128336, 128359, 128378, 128378, 128405, 128406, 128420, 128420, 128507, 128591, 128640, 128709, 128716, 128716, 128720, 128722, 128725, 128729, 128732, 128735, 128747, 128748, 128756, 128764, 128986, 128986, 128992, 129003, 129008, 129008, 129292, 129338, 129340, 129349, 129351, 129535, 129648, 129660, 129664, 129734, 129736, 129736, 129740, 129757, 129759, 129771, 129775, 129786, 131072, 196605, 196608, 262141];
+
+// node_modules/get-east-asian-width/utilities.js
+var isInRange = (ranges, codePoint) => {
+  let low = 0;
+  let high = Math.floor(ranges.length / 2) - 1;
+  while (low <= high) {
+    const mid = Math.floor((low + high) / 2);
+    const i = mid * 2;
+    if (codePoint < ranges[i]) {
+      high = mid - 1;
+    } else if (codePoint > ranges[i + 1]) {
+      low = mid + 1;
+    } else {
+      return true;
+    }
+  }
+  return false;
+};
+
+// node_modules/get-east-asian-width/lookup.js
+var commonCjkCodePoint = 19968;
+var [wideFastPathStart, wideFastPathEnd] = /* @__PURE__ */ findWideFastPathRange(wideRanges);
+function findWideFastPathRange(ranges) {
+  let fastPathStart = ranges[0];
+  let fastPathEnd = ranges[1];
+  for (let index = 0; index < ranges.length; index += 2) {
+    const start = ranges[index];
+    const end = ranges[index + 1];
+    if (commonCjkCodePoint >= start && commonCjkCodePoint <= end) {
+      return [start, end];
+    }
+    if (end - start > fastPathEnd - fastPathStart) {
+      fastPathStart = start;
+      fastPathEnd = end;
+    }
+  }
+  return [fastPathStart, fastPathEnd];
+}
+var isAmbiguous = (codePoint) => {
+  if (codePoint < ambiguousMinimalCodePoint || codePoint > ambiguousMaximumCodePoint) {
+    return false;
+  }
+  return isInRange(ambiguousRanges, codePoint);
+};
+var isFullwidth = (codePoint) => {
+  if (codePoint < fullwidthMinimalCodePoint || codePoint > fullwidthMaximumCodePoint) {
+    return false;
+  }
+  return isInRange(fullwidthRanges, codePoint);
+};
+var isWide = (codePoint) => {
+  if (codePoint >= wideFastPathStart && codePoint <= wideFastPathEnd) {
+    return true;
+  }
+  if (codePoint < wideMinimalCodePoint || codePoint > wideMaximumCodePoint) {
+    return false;
+  }
+  return isInRange(wideRanges, codePoint);
+};
+
+// node_modules/get-east-asian-width/index.js
+function validate(codePoint) {
+  if (!Number.isSafeInteger(codePoint)) {
+    throw new TypeError(`Expected a code point, got \`${typeof codePoint}\`.`);
+  }
+}
+function eastAsianWidth(codePoint, { ambiguousAsWide = false } = {}) {
+  validate(codePoint);
+  if (isFullwidth(codePoint) || isWide(codePoint) || ambiguousAsWide && isAmbiguous(codePoint)) {
+    return 2;
+  }
+  return 1;
+}
+
+// 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{Nonspacing_Mark}|\\p{Enclosing_Mark}|\\p{Surrogate})+$", "v");
+var leadingNonPrintingRegex = 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");
+function isDoubleWidthNonRgiEmojiSequence(segment) {
+  if (segment.length > 50) {
+    return false;
+  }
+  if (unqualifiedKeycapRegex.test(segment)) {
+    return true;
+  }
+  if (segment.includes("\u200D")) {
+    const pictographics = segment.match(extendedPictographicRegex);
+    return pictographics !== null && pictographics.length >= 2;
+  }
+  return false;
+}
+function baseVisible(segment) {
+  return segment.replace(leadingNonPrintingRegex, "");
+}
+function isZeroWidthCluster(segment) {
+  return zeroWidthClusterRegex.test(segment);
+}
+function isHangulLeadingJamo(codePoint) {
+  return codePoint >= 4352 && codePoint <= 4447 || codePoint >= 43360 && codePoint <= 43388;
+}
+function isHangulVowelJamo(codePoint) {
+  return codePoint >= 4448 && codePoint <= 4519 || codePoint >= 55216 && codePoint <= 55238;
+}
+function isHangulTrailingJamo(codePoint) {
+  return codePoint >= 4520 && codePoint <= 4607 || codePoint >= 55243 && codePoint <= 55291;
+}
+function isHangulJamo(codePoint) {
+  return isHangulLeadingJamo(codePoint) || isHangulVowelJamo(codePoint) || isHangulTrailingJamo(codePoint);
+}
+function hangulClusterWidth(visibleSegment, eastAsianWidthOptions) {
+  const codePoints = [];
+  for (const character of visibleSegment) {
+    if (zeroWidthClusterRegex.test(character)) {
+      continue;
+    }
+    codePoints.push(character.codePointAt(0));
+  }
+  if (codePoints.length === 0) {
+    return void 0;
+  }
+  let width = 0;
+  for (let index = 0; index < codePoints.length; index++) {
+    const codePoint = codePoints[index];
+    if (!isHangulJamo(codePoint)) {
+      if (width === 0) {
+        return void 0;
+      }
+      for (let remaining = index; remaining < codePoints.length; remaining++) {
+        width += eastAsianWidth(codePoints[remaining], eastAsianWidthOptions);
+      }
+      return width;
+    }
+    if (isHangulLeadingJamo(codePoint) && isHangulVowelJamo(codePoints[index + 1])) {
+      width += 2;
+      index += isHangulTrailingJamo(codePoints[index + 2]) ? 2 : 1;
+      continue;
+    }
+    width += eastAsianWidth(codePoint, eastAsianWidthOptions);
+  }
+  return width;
+}
+function trailingWidth(visibleSegment, eastAsianWidthOptions) {
+  let extra = 0;
+  let first = true;
+  for (const character of visibleSegment) {
+    if (first) {
+      first = false;
+      continue;
+    }
+    if (spacingMarkRegex.test(character) || character >= "\uFF00" && character <= "\uFFEF") {
+      extra += eastAsianWidth(character.codePointAt(0), eastAsianWidthOptions);
+    }
+  }
+  return extra;
+}
+function stringWidth(input, options = {}) {
+  if (typeof input !== "string" || input.length === 0) {
+    return 0;
+  }
+  const {
+    ambiguousIsNarrow = true,
+    countAnsiEscapeCodes = false
+  } = options;
+  let string = input;
+  if (!countAnsiEscapeCodes && (string.includes("\x1B") || string.includes("\x9B"))) {
+    string = stripAnsi(string);
+  }
+  if (string.length === 0) {
+    return 0;
+  }
+  if (/^[\u0020-\u007E]*$/.test(string)) {
+    return string.length;
+  }
+  let width = 0;
+  const eastAsianWidthOptions = { ambiguousAsWide: !ambiguousIsNarrow };
+  for (const { segment } of segmenter.segment(string)) {
+    if (isZeroWidthCluster(segment)) {
+      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;
+      continue;
+    }
+    const codePoint = visibleSegment.codePointAt(0);
+    width += eastAsianWidth(codePoint, eastAsianWidthOptions);
+    width += trailingWidth(visibleSegment, eastAsianWidthOptions);
+  }
+  return width;
+}
+
+// packages/cli/tui/tuiAnsi.ts
+var ANSI_ESCAPE_REGEX = /\x1b\[[\x30-\x3f]*[\x20-\x2f]*[\x40-\x7e]/g;
+var OSC8_HYPERLINK_REGEX = /\x1b\]8;;[^\x1b]*\x1b\\/g;
+var ALL_ANSI_ESCAPE_REGEX = ansiRegex();
+var FIRST_ANSI_ESCAPE_REGEX = ansiRegex({ onlyFirst: true });
+function stripOsc8Hyperlinks(text) {
+  return text.replace(OSC8_HYPERLINK_REGEX, "");
+}
+function stripAnsi2(text) {
+  return text.replace(ANSI_ESCAPE_REGEX, "").replace(ALL_ANSI_ESCAPE_REGEX, "");
+}
+var SGR_SEQUENCE_REGEX = /^\x1b\[[0-9;]*m/;
+var TRAILING_SGR_REGEX = /(?:\x1b\[[0-9;]*m)+$/;
+function applyTerminalOutputToText(existing, chunk) {
+  if (!chunk) return existing;
+  let text = existing;
+  let index = 0;
+  while (index < chunk.length) {
+    if (chunk[index] === "\x1B") {
+      const sgr = SGR_SEQUENCE_REGEX.exec(chunk.slice(index));
+      if (sgr) {
+        text += sgr[0];
+        index += sgr[0].length;
+        continue;
+      }
+      const osc = chunk.slice(index).match(/^\x1b\]8;;[^\x07\x1b]*(?:\x07|\x1b\\)/);
+      if (osc) {
+        index += osc[0].length;
+        continue;
+      }
+      const csi = chunk.slice(index).match(/^\x1b\[[\x30-\x3f]*[\x20-\x2f]*[\x40-\x7e]/);
+      if (csi) {
+        index += csi[0].length;
+        continue;
+      }
+      index += 1;
+      continue;
+    }
+    const ch = chunk[index];
+    if (ch === "\r") {
+      const lastNl = text.lastIndexOf("\n");
+      text = lastNl === -1 ? "" : text.slice(0, lastNl + 1);
+      index += 1;
+      continue;
+    }
+    if (ch === "\n") {
+      text += "\n";
+      index += 1;
+      continue;
+    }
+    if (ch === "\b") {
+      const trailing = TRAILING_SGR_REGEX.exec(text);
+      const sgrTail = trailing ? trailing[0] : "";
+      const head = sgrTail ? text.slice(0, -sgrTail.length) : text;
+      if (head.length > 0 && head[head.length - 1] !== "\n") {
+        text = head.slice(0, -1) + sgrTail;
+      }
+      index += 1;
+      continue;
+    }
+    const code = ch.charCodeAt(0);
+    if (code < 32 && ch !== "	" || code === 127) {
+      index += 1;
+      continue;
+    }
+    text += ch;
+    index += 1;
+  }
+  return text;
+}
+function resolveAmbiguousWidth(explicit, env = process.env) {
+  if (explicit === "wide" || explicit === "narrow") return explicit;
+  const raw = env.NOLO_TUI_AMBIGUOUS_WIDTH;
+  if (typeof raw === "string") {
+    const trimmed = raw.trim().toLowerCase();
+    if (trimmed === "wide") return "wide";
+    if (trimmed === "narrow") return "narrow";
+  }
+  return detectedWindowsTerminalAmbiguousWidth() ?? "narrow";
+}
+var wtAmbiguousWidthCache;
+function detectedWindowsTerminalAmbiguousWidth() {
+  if (wtAmbiguousWidthCache === void 0) {
+    wtAmbiguousWidthCache = detectWindowsTerminalAmbiguousWidth();
+  }
+  return wtAmbiguousWidthCache;
+}
+function isCjkFontWideSymbolCode(code) {
+  return code >= 9728 && code <= 10175 && !(code >= 10088 && code <= 10101) || code >= 11008 && code <= 11263 || code >= 127744 && code <= 129791 || code >= 8986 && code <= 8987 || // ⌚ ⌛
+  code >= 9193 && code <= 9210;
+}
+function isCjkQuoteCode(code) {
+  return code === 8220 || code === 8221 || code === 8216 || code === 8217;
+}
+var UNICODE_BOX_GLYPHS = {
+  h: "\u2500",
+  v: "\u2502",
+  tl: "\u250C",
+  tm: "\u252C",
+  tr: "\u2510",
+  ml: "\u251C",
+  mm: "\u253C",
+  mr: "\u2524",
+  bl: "\u2514",
+  bm: "\u2534",
+  br: "\u2518"
+};
+var ASCII_BOX_GLYPHS = {
+  h: "-",
+  v: "|",
+  tl: "+",
+  tm: "+",
+  tr: "+",
+  ml: "+",
+  mm: "+",
+  mr: "+",
+  bl: "+",
+  bm: "+",
+  br: "+"
+};
+function resolveBoxCharset(ambiguousWidth = resolveAmbiguousWidth(), env = process.env) {
+  const raw = env.NOLO_TUI_BOX;
+  if (typeof raw === "string") {
+    const trimmed = raw.trim().toLowerCase();
+    if (trimmed === "ascii") return "ascii";
+    if (trimmed === "unicode") return "unicode";
+  }
+  return ambiguousWidth === "wide" ? "ascii" : "unicode";
+}
+function boxGlyphs(charset) {
+  return charset === "ascii" ? ASCII_BOX_GLYPHS : UNICODE_BOX_GLYPHS;
+}
+function scanWidthNeeds(plain, locale, ambiguousWidth) {
+  let hasNonAscii = false;
+  const isWideMode = ambiguousWidth === "wide";
+  for (let i = 0; i < plain.length; i++) {
+    const cc = plain.charCodeAt(i);
+    if (cc < 8192) {
+      if (cc >= 128) hasNonAscii = true;
+      continue;
+    }
+    hasNonAscii = true;
+    let code = cc;
+    if (cc >= 55296 && cc <= 56319 && i + 1 < plain.length) {
+      const lo = plain.charCodeAt(i + 1);
+      if (lo >= 56320 && lo <= 57343) {
+        code = (cc - 55296) * 1024 + (lo - 56320) + 65536;
+        i += 1;
+      }
+    }
+    const isSymbolCandidate = isWideMode && isCjkFontWideSymbolCode(code);
+    const isQuoteCandidate = locale === "zh" && isCjkQuoteCode(code);
+    if (isSymbolCandidate || isQuoteCandidate) {
+      return { hasNonAscii: true, hasCandidate: true };
+    }
+  }
+  return { hasNonAscii, hasCandidate: false };
+}
+var displayWidthCache = /* @__PURE__ */ new Map();
+var DISPLAY_WIDTH_CACHE_MAX = 4096;
+function displayWidth(str, ambiguousWidth = resolveAmbiguousWidth()) {
+  const plain = stripAnsi2(str);
+  const locale = getCliLocale();
+  const widthOptions = { ambiguousIsNarrow: ambiguousWidth !== "wide" };
+  const needs = scanWidthNeeds(plain, locale, ambiguousWidth);
+  if (!needs.hasNonAscii) {
+    return stringWidth(plain, widthOptions);
+  }
+  const key = locale + "\0" + ambiguousWidth + "\0" + plain;
+  const cached = displayWidthCache.get(key);
+  if (cached !== void 0) return cached;
+  const remember = (width2) => {
+    if (displayWidthCache.size >= DISPLAY_WIDTH_CACHE_MAX) {
+      const eldest = displayWidthCache.keys().next().value;
+      if (eldest !== void 0) displayWidthCache.delete(eldest);
+    }
+    displayWidthCache.set(key, width2);
+    return width2;
+  };
+  const base = stringWidth(plain, widthOptions);
+  if (!needs.hasCandidate) {
+    return remember(base);
+  }
+  let width = base;
+  const isWideMode = ambiguousWidth === "wide";
+  for (const { segment } of graphemeSegmenter.segment(plain)) {
+    const code = segment.codePointAt(0) ?? 0;
+    const isSymbol = isWideMode && isCjkFontWideSymbolCode(code);
+    const isQuote = locale === "zh" && isCjkQuoteCode(code);
+    if (isSymbol || isQuote) {
+      if (stringWidth(segment, widthOptions) === 1) width += 1;
+    }
+  }
+  return remember(width);
+}
+function visibleWidth(str) {
+  return displayWidth(stripAnsi2(str));
+}
+function truncateAnsi(text, maxWidth) {
+  if (maxWidth <= 0) return "";
+  text = stripOsc8Hyperlinks(text);
+  if (visibleWidth(text) <= maxWidth) return text;
+  let width = 0;
+  let out = "";
+  let i = 0;
+  let sawAnsi = false;
+  while (i < text.length) {
+    if (text[i] === "\x1B" && text[i + 1] === "[") {
+      sawAnsi = true;
+      let j = i + 2;
+      while (j < text.length) {
+        const code = text.charCodeAt(j);
+        j += 1;
+        if (code >= 64 && code <= 126) break;
+      }
+      out += text.slice(i, j);
+      i = j;
+      continue;
+    }
+    const codePoint = text.codePointAt(i) ?? 0;
+    const char = String.fromCodePoint(codePoint);
+    const charWidth = displayWidth(char);
+    if (width + charWidth > maxWidth) break;
+    out += char;
+    width += charWidth;
+    i += char.length;
+  }
+  return sawAnsi ? `${out}\x1B[0m` : out;
+}
+function fitAnsiLine(text, width, ellipsis = "\u2026") {
+  if (width <= 0) return "";
+  if (visibleWidth(text) <= width) return text;
+  const ellipsisWidth = displayWidth(ellipsis);
+  if (width < ellipsisWidth) return truncateAnsi(text, width);
+  if (width === ellipsisWidth) return truncateAnsi(ellipsis, width) || truncateAnsi(text, width);
+  return `${truncateAnsi(text, width - ellipsisWidth)}${ellipsis}`;
+}
+function countPhysicalLines(text, columns) {
+  const lines = text.split("\n");
+  let total = 0;
+  for (const line of lines) {
+    const width = visibleWidth(stripOsc8Hyperlinks(line));
+    total += Math.max(1, Math.ceil(width / columns));
+  }
+  return Math.max(total, 1);
+}
+function takeDisplayWidth(text, width) {
+  let used = 0;
+  let index = 0;
+  for (const char of text) {
+    const charWidth = displayWidth(char);
+    if (used + charWidth > width && used > 0) break;
+    used += charWidth;
+    index += char.length;
+  }
+  return { prefix: text.slice(0, index), rest: text.slice(index) };
+}
+function padOrTruncateToWidth(text, width) {
+  const textWidth = visibleWidth(text);
+  if (textWidth > width) {
+    return truncateAnsi(text, width);
+  }
+  return `${text}${" ".repeat(width - textWidth)}`;
+}
+var SGR_RESET_REGEX = /^\x1b\[0?m$/;
+var graphemeSegmenter = new Intl.Segmenter(void 0, { granularity: "grapheme" });
+function tokenizeAnsiLine(line) {
+  const tokens = [];
+  let index = 0;
+  while (index < line.length) {
+    if (line[index] === "\x1B") {
+      const osc = line.slice(index).match(/^\x1b\]8;;[^\x07\x1b]*(?:\x07|\x1b\\)/);
+      if (osc) {
+        tokens.push({ kind: "sgr", value: osc[0], width: 0, charIndex: index });
+        index += osc[0].length;
+        continue;
+      }
+      const sgr = SGR_SEQUENCE_REGEX.exec(line.slice(index));
+      if (sgr) {
+        tokens.push({ kind: "sgr", value: sgr[0], width: 0, charIndex: index });
+        index += sgr[0].length;
+        continue;
+      }
+      const csi = line.slice(index).match(/^\x1b\[[\x30-\x3f]*[\x20-\x2f]*[\x40-\x7e]/);
+      if (csi) {
+        index += csi[0].length;
+        continue;
+      }
+      const escape = FIRST_ANSI_ESCAPE_REGEX.exec(line.slice(index));
+      if (escape?.index === 0) {
+        index += escape[0].length;
+        continue;
+      }
+      index += 1;
+      continue;
+    }
+    let nextEsc = line.indexOf("\x1B", index);
+    if (nextEsc === -1) nextEsc = line.length;
+    const chunk = line.slice(index, nextEsc);
+    for (const item of graphemeSegmenter.segment(chunk)) {
+      tokens.push({
+        kind: "char",
+        value: item.segment,
+        width: displayWidth(item.segment),
+        charIndex: index + item.index
+      });
+    }
+    index = nextEsc;
+  }
+  return tokens;
+}
+function buildSourceMapping(rawLine, styledLine, prefixCharCount) {
+  let contentStart = 0;
+  const headingMatch = rawLine.match(/^(#{1,3})\s+(.+)$/);
+  let lineToParse = rawLine;
+  if (headingMatch) {
+    contentStart = headingMatch[1].length + 1;
+    while (contentStart < rawLine.length && rawLine[contentStart] === " ") contentStart++;
+    lineToParse = rawLine.slice(contentStart);
+  }
+  const INLINE_RE = /(\[([^\]]+)\]\(([^)\s]+)\)|`([^`]+)`|\*\*(.+?)\*\*|(?<!\*)\*([^*]+?)\*(?!\*)|~~([^~]+?)~~)/g;
+  const mapping = [];
+  let lastIdx = 0;
+  let match;
+  while ((match = INLINE_RE.exec(lineToParse)) !== null) {
+    const plainBefore = lineToParse.slice(lastIdx, match.index);
+    for (let c = 0; c < plainBefore.length; c++) {
+      mapping.push(contentStart + lastIdx + c);
+    }
+    const fullMatch = match[0];
+    if (match[2] !== void 0 && match[3] !== void 0) {
+      const linkText = match[2];
+      const linkUrl = match[3];
+      const textOffset = contentStart + match.index + 1;
+      for (let c = 0; c < linkText.length; c++) {
+        mapping.push(textOffset + c);
+      }
+      const parenOffset = textOffset + linkText.length;
+      mapping.push(parenOffset);
+      mapping.push(parenOffset + 1);
+      const urlOffset = parenOffset + 2;
+      for (let c = 0; c < linkUrl.length; c++) {
+        mapping.push(urlOffset + c);
+      }
+      mapping.push(urlOffset + linkUrl.length);
+    } else if (match[4] !== void 0) {
+      const codeText = match[4];
+      const codeOffset = contentStart + match.index + 1;
+      for (let c = 0; c < codeText.length; c++) {
+        mapping.push(codeOffset + c);
+      }
+    } else if (match[5] !== void 0) {
+      const boldText = match[5];
+      const boldOffset = contentStart + match.index + 2;
+      for (let c = 0; c < boldText.length; c++) {
+        mapping.push(boldOffset + c);
+      }
+    } else if (match[6] !== void 0) {
+      const italicText = match[6];
+      const italicOffset = contentStart + match.index + 1;
+      for (let c = 0; c < italicText.length; c++) {
+        mapping.push(italicOffset + c);
+      }
+    } else if (match[7] !== void 0) {
+      const strikeText = match[7];
+      const strikeOffset = contentStart + match.index + 2;
+      for (let c = 0; c < strikeText.length; c++) {
+        mapping.push(strikeOffset + c);
+      }
+    }
+    lastIdx = match.index + fullMatch.length;
+  }
+  const plainRest = lineToParse.slice(lastIdx);
+  for (let c = 0; c < plainRest.length; c++) {
+    mapping.push(contentStart + lastIdx + c);
+  }
+  return mapping;
+}
+function wrapTranscriptLineWithLayout(line, columns, hangingIndent = "", lineSourceStart = 0, prefixWidth = 0, prefixCharCount = 0, sourceMapping, rawLineLength) {
+  if (line === "") {
+    const rawLen = rawLineLength ?? 0;
+    return [
+      {
+        rendered: "",
+        sourceStart: lineSourceStart,
+        sourceEnd: lineSourceStart + rawLen,
+        prefixWidth
+      }
+    ];
+  }
+  const tokens = tokenizeAnsiLine(line);
+  const rows = [];
+  let activeStyles = [];
+  const applyStyleToken = (value) => {
+    if (SGR_RESET_REGEX.test(value)) {
+      activeStyles = [];
+    } else {
+      activeStyles.push(value);
+    }
+  };
+  let lastContentTokenIndex = -1;
+  for (let i = tokens.length - 1; i >= 0; i -= 1) {
+    if (tokens[i].kind !== "sgr") {
+      lastContentTokenIndex = i;
+      break;
+    }
+  }
+  let plainCharIndexAtStart = 0;
+  let start = 0;
+  while (start < tokens.length) {
+    if (start > lastContentTokenIndex && rows.length > 0) break;
+    const openingStyles = [...activeStyles];
+    const isContinuation = rows.length > 0;
+    const currentPrefixWidth = isContinuation ? visibleWidth(hangingIndent) : prefixWidth;
+    const indentWidth = isContinuation ? visibleWidth(hangingIndent) : 0;
+    const maxSegmentWidth = Math.max(1, columns - indentWidth);
+    let width = 0;
+    let end = start;
+    let lastBreak = -1;
+    while (end < tokens.length) {
+      const token = tokens[end];
+      if (token.kind === "sgr") {
+        end += 1;
+        continue;
+      }
+      if (width + token.width > maxSegmentWidth && width > 0) break;
+      width += token.width;
+      end += 1;
+      if ((token.value === " " || token.value === "	") && token.charIndex >= prefixCharCount) {
+        lastBreak = end;
+      }
+    }
+    let segmentEnd = end;
+    if (end < tokens.length && lastBreak > start) {
+      const overflowToken = tokens[end];
+      if (overflowToken.kind === "char" && overflowToken.value !== " " && overflowToken.width === 1) {
+        segmentEnd = lastBreak;
+      }
+    }
+    if (segmentEnd === start) segmentEnd = start + 1;
+    let segment = "";
+    let sawStyle = openingStyles.length > 0;
+    for (let i = start; i < segmentEnd; i += 1) {
+      const token = tokens[i];
+      segment += token.value;
+      if (token.kind === "sgr") {
+        sawStyle = true;
+        applyStyleToken(token.value);
+      }
+    }
+    const prefix = openingStyles.join("");
+    const needsReset = (sawStyle || activeStyles.length > 0) && !segment.endsWith("\x1B[0m");
+    const lineContent = `${prefix}${segment}${needsReset ? "\x1B[0m" : ""}`;
+    const rowRendered = isContinuation && hangingIndent.length > 0 ? `${hangingIndent}${lineContent}` : lineContent;
+    let segSourceStart = lineSourceStart;
+    let segSourceEnd = lineSourceStart;
+    let foundFirst = false;
+    const rowMapping = [];
+    let plainCharIndex = plainCharIndexAtStart;
+    for (let i = start; i < segmentEnd; i++) {
+      const tok = tokens[i];
+      if (tok.kind === "char" && tok.charIndex >= prefixCharCount) {
+        const mappedOffset = sourceMapping && sourceMapping[plainCharIndex] !== void 0 ? sourceMapping[plainCharIndex] : plainCharIndex;
+        if (!foundFirst) {
+          segSourceStart = lineSourceStart + mappedOffset;
+          foundFirst = true;
+        }
+        for (let c = 0; c < tok.value.length; c++) {
+          const idx = plainCharIndex + c;
+          const mapped = sourceMapping && sourceMapping[idx] !== void 0 ? sourceMapping[idx] : idx;
+          rowMapping.push(lineSourceStart + mapped);
+        }
+        const lastCharIdx = plainCharIndex + tok.value.length - 1;
+        const mappedEndOffset = sourceMapping && sourceMapping[lastCharIdx] !== void 0 ? sourceMapping[lastCharIdx] + 1 : plainCharIndex + tok.value.length;
+        segSourceEnd = lineSourceStart + mappedEndOffset;
+        plainCharIndex += tok.value.length;
+      }
+    }
+    start = segmentEnd;
+    let softWrapJoiner = "";
+    while (start < tokens.length) {
+      const token = tokens[start];
+      if (token.kind === "char" && token.value === " " && token.charIndex >= prefixCharCount) {
+        softWrapJoiner += token.value;
+        const mappedOffset = sourceMapping && sourceMapping[plainCharIndex] !== void 0 ? sourceMapping[plainCharIndex] + 1 : plainCharIndex + 1;
+        segSourceEnd = lineSourceStart + mappedOffset;
+        plainCharIndex += token.value.length;
+        start += 1;
+        continue;
+      }
+      break;
+    }
+    if (start >= tokens.length && rawLineLength !== void 0) {
+      segSourceEnd = lineSourceStart + rawLineLength;
+    }
+    plainCharIndexAtStart = plainCharIndex;
+    rows.push({
+      rendered: rowRendered,
+      sourceStart: segSourceStart,
+      sourceEnd: segSourceEnd,
+      prefixWidth: currentPrefixWidth,
+      sourceMapping: rowMapping.length > 0 ? rowMapping : void 0,
+      softWrapped: start < tokens.length,
+      softWrapJoiner
+    });
+  }
+  return rows.length > 0 ? rows : [
+    {
+      rendered: "",
+      sourceStart: lineSourceStart,
+      sourceEnd: lineSourceStart + (rawLineLength ?? 0),
+      prefixWidth
+    }
+  ];
+}
+function wrapTranscriptLine(line, columns, hangingIndent = "") {
+  return wrapTranscriptLineWithLayout(line, columns, hangingIndent).map((r) => r.rendered);
+}
+function buildWindowTitle(title) {
+  const plain = stripAnsi2(title).replace(/[\x00-\x1f\x7f]+/g, " ");
+  let truncated = "";
+  let width = 0;
+  const maxCols = 80;
+  for (const char of plain) {
+    const charWidth = displayWidth(char);
+    if (width + charWidth > maxCols) break;
+    truncated += char;
+    width += charWidth;
+  }
+  return `\x1B]0;${truncated}\x07\x1B]2;${truncated}\x07`;
+}
+function wrapTextToLines(text, columns) {
+  const result = [];
+  for (const logicalLine of text.split("\n")) {
+    if (logicalLine === "") {
+      result.push("");
+      continue;
+    }
+    let remaining = logicalLine;
+    while (remaining.length > 0) {
+      const { prefix, rest } = takeDisplayWidth(remaining, columns);
+      result.push(prefix);
+      remaining = rest;
+    }
+  }
+  return result;
+}
 
 // packages/cli/oauth/callback-server.ts
 import { createServer } from "node:http";
@@ -575,13 +1451,14 @@ function renderDeviceCodeDisplay(args) {
     plain: `  Code: ${userCode}  `
   });
   const innerWidth = Math.max(...rows.map((row) => row.plain.length));
-  const top = `\u250C${"\u2500".repeat(innerWidth)}\u2510`;
-  const bottom = `\u2514${"\u2500".repeat(innerWidth)}\u2518`;
+  const g = boxGlyphs(resolveBoxCharset());
+  const top = `${g.tl}${g.h.repeat(innerWidth)}${g.tr}`;
+  const bottom = `${g.bl}${g.h.repeat(innerWidth)}${g.br}`;
   return [
     `Authorize nolo-cli for ${provider} (device code / headless):`,
     top,
     ...rows.map(
-      (row) => `\u2502${row.rendered}${" ".repeat(innerWidth - row.plain.length)}\u2502`
+      (row) => `${g.v}${row.rendered}${" ".repeat(innerWidth - row.plain.length)}${g.v}`
     ),
     bottom,
     ...notes
@@ -1468,6 +2345,24 @@ async function refreshCursorToken(credential, deps = {}) {
 var cursorRefresh = refreshCursorToken;
 
 export {
+  ANSI_ESCAPE_REGEX,
+  stripAnsi2 as stripAnsi,
+  applyTerminalOutputToText,
+  resolveBoxCharset,
+  boxGlyphs,
+  displayWidth,
+  visibleWidth,
+  truncateAnsi,
+  fitAnsiLine,
+  countPhysicalLines,
+  takeDisplayWidth,
+  padOrTruncateToWidth,
+  tokenizeAnsiLine,
+  buildSourceMapping,
+  wrapTranscriptLineWithLayout,
+  wrapTranscriptLine,
+  buildWindowTitle,
+  wrapTextToLines,
   resolveClaudeCodeVersion,
   getClaudeCodeUserAgent,
   adoptRequiredClaudeCodeVersion,