@simon_he/vue-tui 1.0.1 → 1.1.0

package/dist/core.cjs

@@ -5,17 +5,14 @@ var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
     for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
   return to;
 };
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
 
 // src/core.ts
 var core_exports = {};
@@ -65,15 +62,12 @@ var ANSI_PALETTE_HEX = Object.freeze({
   whiteBright: "#ffffff"
 });
 function ansiHexToRgb(hex) {
-  const h = hex.startsWith("#") ? hex.slice(1) : hex;
+  let h = hex.startsWith("#") ? hex.slice(1) : hex;
   if (h.length !== 6)
-    return void 0;
-  const r = Number.parseInt(h.slice(0, 2), 16);
-  const g = Number.parseInt(h.slice(2, 4), 16);
-  const b = Number.parseInt(h.slice(4, 6), 16);
-  if (!Number.isFinite(r) || !Number.isFinite(g) || !Number.isFinite(b))
-    return void 0;
-  return { r, g, b };
+    return;
+  let r = Number.parseInt(h.slice(0, 2), 16), g = Number.parseInt(h.slice(2, 4), 16), b = Number.parseInt(h.slice(4, 6), 16);
+  if (!(!Number.isFinite(r) || !Number.isFinite(g) || !Number.isFinite(b)))
+    return { r, g, b };
 }
 var ANSI_PALETTE_RGB = Object.freeze(
   Object.fromEntries(
@@ -81,15 +75,13 @@ var ANSI_PALETTE_RGB = Object.freeze(
   )
 );
 function isAnsiColorName(name) {
-  return typeof name === "string" && Object.prototype.hasOwnProperty.call(ANSI_PALETTE_HEX, name);
+  return typeof name == "string" && Object.prototype.hasOwnProperty.call(ANSI_PALETTE_HEX, name);
 }
 function ansiColorRgb(name, palette) {
   if (!isAnsiColorName(name))
-    return void 0;
-  const custom = palette?.[name];
-  if (custom)
-    return ansiHexToRgb(custom) ?? ANSI_PALETTE_RGB[name];
-  return ANSI_PALETTE_RGB[name];
+    return;
+  let custom = palette?.[name];
+  return custom ? ansiHexToRgb(custom) ?? ANSI_PALETTE_RGB[name] : ANSI_PALETTE_RGB[name];
 }
 
 // src/core/ansi/colors.ts
@@ -102,8 +94,7 @@ var ANSI8_COLOR_NAMES = Object.freeze([
   "magenta",
   "cyan",
   "white"
-]);
-var ANSI16_COLOR_NAMES = Object.freeze([
+]), ANSI16_COLOR_NAMES = Object.freeze([
   "black",
   "red",
   "green",
@@ -120,14 +111,7 @@ var ANSI16_COLOR_NAMES = Object.freeze([
   "magentaBright",
   "cyanBright",
   "whiteBright"
-]);
-var ESC = "\x1B[";
-var SGR_RESET = `${ESC}0m`;
-var SGR_BOLD = `${ESC}1m`;
-var SGR_DIM = `${ESC}2m`;
-var SGR_ITALIC = `${ESC}3m`;
-var SGR_UNDERLINE = `${ESC}4m`;
-var SGR_INVERSE = `${ESC}7m`;
+]), ESC = "\x1B[", SGR_RESET = `${ESC}0m`, SGR_BOLD = `${ESC}1m`, SGR_DIM = `${ESC}2m`, SGR_ITALIC = `${ESC}3m`, SGR_UNDERLINE = `${ESC}4m`, SGR_INVERSE = `${ESC}7m`;
 function toAnsi8ColorName(name) {
   switch (name) {
     case "black":
@@ -174,8 +158,7 @@ var ANSI16_FG_CODE = Object.freeze({
   magentaBright: 95,
   cyanBright: 96,
   whiteBright: 97
-});
-var ANSI16_BG_CODE = Object.freeze({
+}), ANSI16_BG_CODE = Object.freeze({
   black: 40,
   red: 41,
   green: 42,
@@ -194,13 +177,11 @@ var ANSI16_BG_CODE = Object.freeze({
   whiteBright: 107
 });
 function ansi8FgOpen(name) {
-  const base = toAnsi8ColorName(name);
-  const idx = ANSI8_COLOR_NAMES.indexOf(base);
+  let base = toAnsi8ColorName(name), idx = ANSI8_COLOR_NAMES.indexOf(base);
   return `${ESC}${30 + (idx < 0 ? 7 : idx)}m`;
 }
 function ansi8BgOpen(name) {
-  const base = toAnsi8ColorName(name);
-  const idx = ANSI8_COLOR_NAMES.indexOf(base);
+  let base = toAnsi8ColorName(name), idx = ANSI8_COLOR_NAMES.indexOf(base);
   return `${ESC}${40 + (idx < 0 ? 0 : idx)}m`;
 }
 function ansi16FgOpen(name) {
@@ -210,11 +191,11 @@ function ansi16BgOpen(name) {
   return `${ESC}${ANSI16_BG_CODE[name]}m`;
 }
 function ansi256FgOpen(index) {
-  const n = clampAnsiIndex(index);
+  let n = clampAnsiIndex(index);
   return `${ESC}38;5;${n}m`;
 }
 function ansi256BgOpen(index) {
-  const n = clampAnsiIndex(index);
+  let n = clampAnsiIndex(index);
   return `${ESC}48;5;${n}m`;
 }
 function truecolorFgOpen(rgb) {
@@ -224,54 +205,32 @@ function truecolorBgOpen(rgb) {
   return `${ESC}48;2;${clampByte(rgb.r)};${clampByte(rgb.g)};${clampByte(rgb.b)}m`;
 }
 function ansi256ToRgb(index) {
-  const n = clampAnsiIndex(index);
+  let n = clampAnsiIndex(index);
   if (n < 16) {
-    const name = ANSI16_COLOR_NAMES[n] ?? "white";
+    let name = ANSI16_COLOR_NAMES[n] ?? "white";
     return ansiColorRgb(name) ?? { r: 255, g: 255, b: 255 };
   }
   if (n >= 232) {
-    const c = 8 + (n - 232) * 10;
+    let c = 8 + (n - 232) * 10;
     return { r: c, g: c, b: c };
   }
-  const i = n - 16;
-  const rr = Math.floor(i / 36);
-  const gg = Math.floor(i % 36 / 6);
-  const bb = i % 6;
-  const levels = [0, 95, 135, 175, 215, 255];
+  let i = n - 16, rr = Math.floor(i / 36), gg = Math.floor(i % 36 / 6), bb = i % 6, levels = [0, 95, 135, 175, 215, 255];
   return { r: levels[rr], g: levels[gg], b: levels[bb] };
 }
 function rgbToAnsi256(rgb) {
-  const r = clampByte(rgb.r);
-  const g = clampByte(rgb.g);
-  const b = clampByte(rgb.b);
-  const levels = [0, 95, 135, 175, 215, 255];
-  const nearestLevelIndex = (v) => {
-    let best = 0;
-    let bestDist = Number.POSITIVE_INFINITY;
+  let r = clampByte(rgb.r), g = clampByte(rgb.g), b = clampByte(rgb.b), levels = [0, 95, 135, 175, 215, 255], nearestLevelIndex = (v) => {
+    let best = 0, bestDist = Number.POSITIVE_INFINITY;
     for (let i = 0; i < levels.length; i++) {
-      const d = (v - levels[i]) ** 2;
-      if (d < bestDist) {
-        bestDist = d;
-        best = i;
-      }
+      let d = (v - levels[i]) ** 2;
+      d < bestDist && (bestDist = d, best = i);
     }
     return best;
-  };
-  const ri = nearestLevelIndex(r);
-  const gi = nearestLevelIndex(g);
-  const bi = nearestLevelIndex(b);
-  const cubeIndex = 16 + 36 * ri + 6 * gi + bi;
-  const cube = ansi256ToRgb(cubeIndex);
-  const cubeDist = (r - cube.r) ** 2 + (g - cube.g) ** 2 + (b - cube.b) ** 2;
-  const gray = Math.round((r + g + b) / 3);
-  const grayIndex = gray < 8 ? 16 : gray > 248 ? 231 : 232 + Math.round((gray - 8) / 10);
-  const grayRgb = ansi256ToRgb(grayIndex);
-  const grayDist = (r - grayRgb.r) ** 2 + (g - grayRgb.g) ** 2 + (b - grayRgb.b) ** 2;
-  return grayDist < cubeDist ? grayIndex : cubeIndex;
+  }, ri = nearestLevelIndex(r), gi = nearestLevelIndex(g), bi = nearestLevelIndex(b), cubeIndex = 16 + 36 * ri + 6 * gi + bi, cube = ansi256ToRgb(cubeIndex), cubeDist = (r - cube.r) ** 2 + (g - cube.g) ** 2 + (b - cube.b) ** 2, gray = Math.round((r + g + b) / 3), grayIndex = gray < 8 ? 16 : gray > 248 ? 231 : 232 + Math.round((gray - 8) / 10), grayRgb = ansi256ToRgb(grayIndex);
+  return (r - grayRgb.r) ** 2 + (g - grayRgb.g) ** 2 + (b - grayRgb.b) ** 2 < cubeDist ? grayIndex : cubeIndex;
 }
 function ansi8Palette() {
   return ANSI8_COLOR_NAMES.map((name, index) => {
-    const rgb = ansiColorRgb(name) ?? { r: 255, g: 255, b: 255 };
+    let rgb = ansiColorRgb(name) ?? { r: 255, g: 255, b: 255 };
     return Object.freeze({
       level: 8,
       index,
@@ -284,7 +243,7 @@ function ansi8Palette() {
 }
 function ansi16Palette() {
   return ANSI16_COLOR_NAMES.map((name, index) => {
-    const rgb = ansiColorRgb(name) ?? { r: 255, g: 255, b: 255 };
+    let rgb = ansiColorRgb(name) ?? { r: 255, g: 255, b: 255 };
     return Object.freeze({
       level: 16,
       index,
@@ -296,8 +255,8 @@ function ansi16Palette() {
   });
 }
 function ansi256Palette() {
-  const out = [];
-  for (let index = 0; index < 256; index++) {
+  let out = [];
+  for (let index = 0; index < 256; index++)
     out.push(
       Object.freeze({
         level: 256,
@@ -307,18 +266,13 @@ function ansi256Palette() {
         bgOpen: ansi256BgOpen(index)
       })
     );
-  }
   return Object.freeze(out);
 }
 function clampAnsiIndex(n) {
-  if (!Number.isFinite(n))
-    return 0;
-  return Math.max(0, Math.min(255, Math.trunc(n)));
+  return Number.isFinite(n) ? Math.max(0, Math.min(255, Math.trunc(n))) : 0;
 }
 function clampByte(n) {
-  if (!Number.isFinite(n))
-    return 0;
-  return Math.max(0, Math.min(255, Math.round(n)));
+  return Number.isFinite(n) ? Math.max(0, Math.min(255, Math.round(n))) : 0;
 }
 
 // src/ansi-styles.ts
@@ -374,93 +328,53 @@ var ansiStyles = Object.freeze({
     ansi256: (idx) => ansi256BgOpen(idx),
     ansi16m: (r, g, b) => truecolorBgOpen({ r, g, b })
   })
-});
-var ANSI8_COLORS = ansi8Palette();
-var ANSI16_COLORS = ansi16Palette();
-var ANSI256_COLORS = ansi256Palette();
+}), ANSI8_COLORS = ansi8Palette(), ANSI16_COLORS = ansi16Palette(), ANSI256_COLORS = ansi256Palette();
 function ansiColors(level) {
-  if (level === 8)
-    return ANSI8_COLORS;
-  if (level === 16)
-    return ANSI16_COLORS;
-  return ANSI256_COLORS;
+  return level === 8 ? ANSI8_COLORS : level === 16 ? ANSI16_COLORS : ANSI256_COLORS;
 }
 
 // src/utils/env.ts
 function firstNonEmptyEnv(env, primary, legacy) {
-  const primaryValue = env?.[primary];
+  let primaryValue = env?.[primary];
   if (String(primaryValue ?? "").trim() !== "")
     return primaryValue;
   if (!legacy)
-    return void 0;
-  const legacyValue = env?.[legacy];
+    return;
+  let legacyValue = env?.[legacy];
   if (String(legacyValue ?? "").trim() !== "")
     return legacyValue;
-  return void 0;
 }
 
 // src/core/ansi/capability.ts
 function parseColorMode(raw) {
-  const v = String(raw ?? "").trim().toLowerCase();
-  if (!v)
-    return null;
-  if (v === "truecolor" || v === "24bit" || v === "rgb")
-    return "truecolor";
-  if (v === "ansi256" || v === "256" || v === "xterm256" || v === "xterm-256color") {
-    return "ansi256";
-  }
-  if (v === "ansi16" || v === "16")
-    return "ansi16";
-  if (v === "ansi8" || v === "8")
-    return "ansi8";
-  return null;
+  let v = String(raw ?? "").trim().toLowerCase();
+  return v ? v === "truecolor" || v === "24bit" || v === "rgb" ? "truecolor" : v === "ansi256" || v === "256" || v === "xterm256" || v === "xterm-256color" ? "ansi256" : v === "ansi16" || v === "16" ? "ansi16" : v === "ansi8" || v === "8" ? "ansi8" : null : null;
 }
 function levelForMode(mode) {
-  if (mode === "ansi8")
-    return 8;
-  if (mode === "ansi16")
-    return 16;
-  return 256;
+  return mode === "ansi8" ? 8 : mode === "ansi16" ? 16 : 256;
 }
 function detectTerminalColorCapability(opts) {
-  const env = opts?.env ?? {};
-  const isTTY = opts?.isTTY ?? false;
-  const platform = String(opts?.platform ?? "").trim().toLowerCase();
-  const isWindows = platform === "win32" || String(env.OS ?? "").trim().toLowerCase() === "windows_nt";
-  const forced = parseColorMode(firstNonEmptyEnv(env, "VUE_TUI_COLOR_MODE", "DIMCODE_COLOR_MODE"));
+  let env = opts?.env ?? {}, isTTY = opts?.isTTY ?? !1, isWindows = String(opts?.platform ?? "").trim().toLowerCase() === "win32" || String(env.OS ?? "").trim().toLowerCase() === "windows_nt", forced = parseColorMode(firstNonEmptyEnv(env, "VUE_TUI_COLOR_MODE", "DIMCODE_COLOR_MODE"));
   if (forced)
     return { mode: forced, level: levelForMode(forced) };
   if (!isTTY)
     return { mode: "truecolor", level: 256 };
-  const termProgram = String(env.TERM_PROGRAM ?? "").toLowerCase();
-  const isAppleTerminal = termProgram.includes("apple_terminal");
-  const colorterm = String(env.COLORTERM ?? "").toLowerCase();
-  if (!isAppleTerminal && (colorterm.includes("truecolor") || colorterm.includes("24bit"))) {
+  let termProgram = String(env.TERM_PROGRAM ?? "").toLowerCase(), isAppleTerminal = termProgram.includes("apple_terminal"), colorterm = String(env.COLORTERM ?? "").toLowerCase();
+  if (!isAppleTerminal && (colorterm.includes("truecolor") || colorterm.includes("24bit")))
     return { mode: "truecolor", level: 256 };
-  }
   if (termProgram.includes("vscode"))
     return { mode: "truecolor", level: 256 };
-  if (termProgram.includes("wezterm") || termProgram.includes("alacritty") || termProgram.includes("ghostty") || termProgram.includes("kitty") || termProgram.includes("iterm") || termProgram.includes("windows terminal") || termProgram.includes("windowsterminal") || termProgram.includes("tabby") || termProgram.includes("hyper") || termProgram.includes("rio") || termProgram.includes("contour")) {
+  if (termProgram.includes("wezterm") || termProgram.includes("alacritty") || termProgram.includes("ghostty") || termProgram.includes("kitty") || termProgram.includes("iterm") || termProgram.includes("windows terminal") || termProgram.includes("windowsterminal") || termProgram.includes("tabby") || termProgram.includes("hyper") || termProgram.includes("rio") || termProgram.includes("contour"))
     return { mode: "truecolor", level: 256 };
-  }
-  const term = String(env.TERM ?? "").toLowerCase();
+  let term = String(env.TERM ?? "").toLowerCase();
   if (isWindows) {
-    const hasWindowsTerminal = "WT_SESSION" in env || "WT_PROFILE_ID" in env || "WT_ID" in env;
-    const hasWezterm = "WEZTERM_EXECUTABLE" in env || "WEZTERM_PANE" in env;
-    const hasAlacritty = "ALACRITTY_LOG" in env || "ALACRITTY_WINDOW_ID" in env;
-    const hasTabby = "TABBY_CONFIG_DIRECTORY" in env;
+    let hasWindowsTerminal = "WT_SESSION" in env || "WT_PROFILE_ID" in env || "WT_ID" in env, hasWezterm = "WEZTERM_EXECUTABLE" in env || "WEZTERM_PANE" in env, hasAlacritty = "ALACRITTY_LOG" in env || "ALACRITTY_WINDOW_ID" in env, hasTabby = "TABBY_CONFIG_DIRECTORY" in env;
     if (hasWindowsTerminal || hasWezterm || hasAlacritty || hasTabby)
       return { mode: "truecolor", level: 256 };
     if (term.includes("xterm") && term.includes("256color"))
       return { mode: "truecolor", level: 256 };
   }
-  if (term.includes("256color"))
-    return { mode: "ansi256", level: 256 };
-  if (term.includes("color"))
-    return { mode: "ansi16", level: 16 };
-  if (term.includes("dumb"))
-    return { mode: "ansi8", level: 8 };
-  return { mode: "ansi16", level: 16 };
+  return term.includes("256color") ? { mode: "ansi256", level: 256 } : term.includes("color") ? { mode: "ansi16", level: 16 } : term.includes("dumb") ? { mode: "ansi8", level: 8 } : { mode: "ansi16", level: 16 };
 }
 
 // src/core/ansi/sgr.ts
@@ -500,14 +414,13 @@ function ansi16ToColorName(code) {
     case 97:
       return "whiteBright";
     default:
-      return void 0;
+      return;
   }
 }
 function ansi16BgToColorName(code) {
-  const fgCode = code >= 40 && code <= 47 ? code - 10 : code >= 100 && code <= 107 ? code - 10 : null;
-  if (fgCode == null)
-    return void 0;
-  return ansi16ToColorName(fgCode);
+  let fgCode = code >= 40 && code <= 47 || code >= 100 && code <= 107 ? code - 10 : null;
+  if (fgCode != null)
+    return ansi16ToColorName(fgCode);
 }
 var ANSI16_RGB = {
   black: { r: 0, g: 0, b: 0 },
@@ -528,24 +441,17 @@ var ANSI16_RGB = {
   whiteBright: { r: 255, g: 255, b: 255 }
 };
 function nearestAnsi16(r, g, b) {
-  let best = "white";
-  let bestDist = Number.POSITIVE_INFINITY;
-  for (const [name, rgb] of Object.entries(ANSI16_RGB)) {
-    const dr = r - rgb.r;
-    const dg = g - rgb.g;
-    const db = b - rgb.b;
-    const d = dr * dr + dg * dg + db * db;
-    if (d < bestDist) {
-      bestDist = d;
-      best = name;
-    }
+  let best = "white", bestDist = Number.POSITIVE_INFINITY;
+  for (let [name, rgb] of Object.entries(ANSI16_RGB)) {
+    let dr = r - rgb.r, dg = g - rgb.g, db = b - rgb.b, d = dr * dr + dg * dg + db * db;
+    d < bestDist && (bestDist = d, best = name);
   }
   return best;
 }
 function ansi256ToRgb2(index) {
-  const n = Math.max(0, Math.min(255, Math.trunc(index)));
+  let n = Math.max(0, Math.min(255, Math.trunc(index)));
   if (n < 16) {
-    const map = [
+    let name = [
       "black",
       "red",
       "green",
@@ -562,73 +468,65 @@ function ansi256ToRgb2(index) {
       "magentaBright",
       "cyanBright",
       "whiteBright"
-    ];
-    const name = map[n] ?? "white";
+    ][n] ?? "white";
     return ANSI16_RGB[name];
   }
   if (n >= 232) {
-    const c = 8 + (n - 232) * 10;
+    let c = 8 + (n - 232) * 10;
     return { r: c, g: c, b: c };
   }
-  const i = n - 16;
-  const rr = Math.floor(i / 36);
-  const gg = Math.floor(i % 36 / 6);
-  const bb = i % 6;
-  const toComponent = (v) => v === 0 ? 0 : 55 + v * 40;
+  let i = n - 16, rr = Math.floor(i / 36), gg = Math.floor(i % 36 / 6), bb = i % 6, toComponent = (v) => v === 0 ? 0 : 55 + v * 40;
   return { r: toComponent(rr), g: toComponent(gg), b: toComponent(bb) };
 }
 function applyAnsiSgrStyle(current, codes) {
   let next = { ...current };
   for (let i = 0; i < codes.length; i++) {
-    const code = codes[i];
+    let code = codes[i];
     if (code === 0) {
       next = {};
       continue;
     }
-    if (code === 1) {
-      next = { ...next, bold: true };
-    } else if (code === 2) {
-      next = { ...next, dim: true };
-    } else if (code === 3) {
-      next = { ...next, italic: true };
-    } else if (code === 4) {
-      next = { ...next, underline: true };
-    } else if (code === 7) {
-      next = { ...next, inverse: true };
-    } else if (code === 22) {
-      next = { ...next, bold: false, dim: false };
-    } else if (code === 23) {
-      next = { ...next, italic: false };
-    } else if (code === 24) {
-      next = { ...next, underline: false };
-    } else if (code === 27) {
-      next = { ...next, inverse: false };
-    } else if (code === 39) {
+    if (code === 1)
+      next = { ...next, bold: !0 };
+    else if (code === 2)
+      next = { ...next, dim: !0 };
+    else if (code === 3)
+      next = { ...next, italic: !0 };
+    else if (code === 4)
+      next = { ...next, underline: !0 };
+    else if (code === 7)
+      next = { ...next, inverse: !0 };
+    else if (code === 22)
+      next = { ...next, bold: !1, dim: !1 };
+    else if (code === 23)
+      next = { ...next, italic: !1 };
+    else if (code === 24)
+      next = { ...next, underline: !1 };
+    else if (code === 27)
+      next = { ...next, inverse: !1 };
+    else if (code === 39)
       next = { ...next, fg: void 0 };
-    } else if (code === 49) {
+    else if (code === 49)
       next = { ...next, bg: void 0 };
-    } else if (code >= 30 && code <= 37 || code >= 90 && code <= 97) {
-      const fg = ansi16ToColorName(code);
+    else if (code >= 30 && code <= 37 || code >= 90 && code <= 97) {
+      let fg = ansi16ToColorName(code);
       next = { ...next, fg: fg ?? next.fg };
     } else if (code >= 40 && code <= 47 || code >= 100 && code <= 107) {
-      const bg = ansi16BgToColorName(code);
+      let bg = ansi16BgToColorName(code);
       next = { ...next, bg: bg ?? next.bg };
     } else if (code === 38 || code === 48) {
-      const mode = codes[i + 1];
+      let mode = codes[i + 1];
       if (mode === 5) {
-        const idx = codes[i + 2];
+        let idx = codes[i + 2];
         if (idx != null) {
-          const { r, g, b } = ansi256ToRgb2(idx);
-          const name = nearestAnsi16(r, g, b);
+          let { r, g, b } = ansi256ToRgb2(idx), name = nearestAnsi16(r, g, b);
           next = code === 38 ? { ...next, fg: name } : { ...next, bg: name };
         }
         i += 2;
       } else if (mode === 2) {
-        const r = codes[i + 2];
-        const g = codes[i + 3];
-        const b = codes[i + 4];
+        let r = codes[i + 2], g = codes[i + 3], b = codes[i + 4];
         if (r != null && g != null && b != null) {
-          const name = nearestAnsi16(r, g, b);
+          let name = nearestAnsi16(r, g, b);
           next = code === 38 ? { ...next, fg: name } : { ...next, bg: name };
         }
         i += 4;
@@ -638,15 +536,13 @@ function applyAnsiSgrStyle(current, codes) {
   return next;
 }
 function parseAnsiSgr(input, baseStyle = {}) {
-  const segments = [];
-  let style = { ...baseStyle };
-  let lastIndex = 0;
+  let segments = [], style = { ...baseStyle }, lastIndex = 0;
   for (let i = 0; i < input.length; i++) {
     if (input[i] !== ESC3 || input[i + 1] !== "[")
       continue;
     let j = i + 2;
-    while (j < input.length) {
-      const c = input.charCodeAt(j);
+    for (; j < input.length; ) {
+      let c = input.charCodeAt(j);
       if (c >= 48 && c <= 57 || c === 59) {
         j++;
         continue;
@@ -655,32 +551,139 @@ function parseAnsiSgr(input, baseStyle = {}) {
     }
     if (j >= input.length || input[j] !== "m")
       continue;
-    if (i > lastIndex)
-      segments.push({ text: input.slice(lastIndex, i), style });
-    const body = input.slice(i + 2, j);
-    const codes = body.split(";").filter(Boolean).map((n) => Number.parseInt(n, 10)).filter((n) => Number.isFinite(n));
-    style = applyAnsiSgrStyle(style, codes.length ? codes : [0]);
-    lastIndex = j + 1;
-    i = j;
-  }
-  if (lastIndex < input.length)
-    segments.push({ text: input.slice(lastIndex), style });
-  return segments;
+    i > lastIndex && segments.push({ text: input.slice(lastIndex, i), style });
+    let codes = input.slice(i + 2, j).split(";").filter(Boolean).map((n) => Number.parseInt(n, 10)).filter((n) => Number.isFinite(n));
+    style = applyAnsiSgrStyle(style, codes.length ? codes : [0]), lastIndex = j + 1, i = j;
+  }
+  return lastIndex < input.length && segments.push({ text: input.slice(lastIndex), style }), segments;
 }
 
-// src/core/buffer/width.ts
+// src/core/buffer/eaw-ranges-unicode-17.ts
 var fullWidthRanges = [
   [4352, 4447],
+  [8986, 8987],
   [9001, 9002],
-  [11904, 42191],
+  [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, 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, 65135],
-  [65280, 65376],
-  [65504, 65510]
-];
-var ambiguousWidthRanges = [
+  [65072, 65106],
+  [65108, 65126],
+  [65128, 65131],
+  [65281, 65376],
+  [65504, 65510],
+  [94176, 94180],
+  [94192, 94198],
+  [94208, 101589],
+  [101631, 101662],
+  [101760, 101874],
+  [110576, 110579],
+  [110581, 110587],
+  [110589, 110590],
+  [110592, 110882],
+  [110898, 110898],
+  [110928, 110930],
+  [110933, 110933],
+  [110948, 110951],
+  [110960, 111355],
+  [119552, 119638],
+  [119648, 119670],
+  [126980, 126980],
+  [127183, 127183],
+  [127374, 127374],
+  [127377, 127386],
+  [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, 128728],
+  [128732, 128735],
+  [128747, 128748],
+  [128756, 128764],
+  [128992, 129003],
+  [129008, 129008],
+  [129292, 129338],
+  [129340, 129349],
+  [129351, 129535],
+  [129648, 129660],
+  [129664, 129674],
+  [129678, 129734],
+  [129736, 129736],
+  [129741, 129756],
+  [129759, 129770],
+  [129775, 129784],
+  [131072, 196605],
+  [196608, 262141]
+], ambiguousWidthRanges = [
   [161, 161],
   [164, 164],
   [167, 168],
@@ -734,6 +737,7 @@ var ambiguousWidthRanges = [
   [728, 731],
   [733, 733],
   [735, 735],
+  [768, 879],
   [913, 929],
   [931, 937],
   [945, 961],
@@ -741,7 +745,8 @@ var ambiguousWidthRanges = [
   [1025, 1025],
   [1040, 1103],
   [1105, 1105],
-  [8208, 8213],
+  [8208, 8208],
+  [8211, 8214],
   [8216, 8217],
   [8220, 8221],
   [8224, 8226],
@@ -803,7 +808,8 @@ var ambiguousWidthRanges = [
   [8895, 8895],
   [8978, 8978],
   [9312, 9449],
-  [9451, 9471],
+  [9451, 9547],
+  [9552, 9587],
   [9600, 9615],
   [9618, 9621],
   [9632, 9633],
@@ -829,33 +835,72 @@ var ambiguousWidthRanges = [
   [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, 11094],
+  [11094, 11097],
+  [12872, 12879],
   [57344, 63743],
-  [65533, 65533]
+  [65024, 65039],
+  [65533, 65533],
+  [127232, 127242],
+  [127248, 127277],
+  [127280, 127337],
+  [127344, 127373],
+  [127375, 127376],
+  [127387, 127404],
+  [917760, 917999],
+  [983040, 1048573],
+  [1048576, 1114109]
 ];
+
+// src/core/buffer/width.ts
 function isFullWidthCodePoint(codePoint) {
-  if (codePoint < 4352 || codePoint > 65510)
-    return false;
-  for (const [start, end] of fullWidthRanges) {
+  if (codePoint < 4352)
+    return !1;
+  for (let [start, end] of fullWidthRanges) {
     if (codePoint < start)
-      return false;
+      return !1;
     if (codePoint <= end)
-      return true;
+      return !0;
   }
-  return false;
+  return !1;
 }
 function isAmbiguousWidthCodePoint(codePoint) {
-  if (codePoint < 161 || codePoint > 65533)
-    return false;
-  for (const [start, end] of ambiguousWidthRanges) {
+  let first = ambiguousWidthRanges[0], last = ambiguousWidthRanges[ambiguousWidthRanges.length - 1];
+  if (!first || !last || codePoint < first[0] || codePoint > last[1])
+    return !1;
+  for (let [start, end] of ambiguousWidthRanges) {
     if (codePoint < start)
-      return false;
+      return !1;
     if (codePoint <= end)
-      return true;
+      return !0;
   }
-  return false;
+  return !1;
+}
+function isVariationSelectorCodePoint(codePoint) {
+  return codePoint >= 65024 && codePoint <= 65039 || codePoint >= 917760 && codePoint <= 917999;
+}
+function isCombiningMarkCodePoint(codePoint) {
+  return codePoint >= 768 && codePoint <= 879 || // Combining Diacritical Marks
+  codePoint >= 6832 && codePoint <= 6911 || // Combining Diacritical Marks Extended
+  codePoint >= 7616 && codePoint <= 7679 || // Combining Diacritical Marks Supplement
+  codePoint >= 8400 && codePoint <= 8447 || // Combining Diacritical Marks for Symbols
+  codePoint >= 65056 && codePoint <= 65071 || // Combining Half Marks
+  codePoint >= 12330 && codePoint <= 12335 || // EAW=W: Ideographic level tone marks
+  codePoint >= 12441 && codePoint <= 12442 || // EAW=W: Combining Katakana-Hiragana marks
+  codePoint === 94180;
 }
 function isEmojiLike(codePoint) {
   return codePoint >= 127744 && codePoint <= 129791 || codePoint >= 127462 && codePoint <= 127487;
@@ -884,93 +929,61 @@ function normalizeCustomWidth(width) {
 function charCellWidth(text, provider = "default") {
   if (!text)
     return 1;
-  if (typeof provider === "function")
+  if (typeof provider == "function")
     return normalizeCustomWidth(provider(text));
-  if (provider !== "cjk" && text.length === 1) {
-    const code = text.charCodeAt(0);
-    if (code < 4352)
-      return 1;
-  }
-  const codePoint = text.codePointAt(0);
+  if (provider !== "cjk" && text.length === 1 && text.charCodeAt(0) < 4352)
+    return 1;
+  let codePoint = text.codePointAt(0);
   if (codePoint == null)
     return 1;
-  const hasVs16 = text.includes("\uFE0F");
-  if (isFullWidthCodePoint(codePoint))
-    return 2;
-  if (provider === "cjk" && isAmbiguousWidthCodePoint(codePoint))
-    return 2;
-  if (isEmojiLike(codePoint))
-    return 2;
-  if (emojiPresentationRe?.test(text))
-    return 2;
-  if (text.includes("\u20E3"))
-    return 2;
-  if (hasVs16 && emojiRe?.test(text))
-    return 2;
-  if (extendedPictographicRe?.test(text)) {
-    if (codePoint <= 65535)
-      return hasVs16 ? 2 : 1;
-    return 2;
-  }
-  return 1;
+  let hasVs16 = text.includes("\uFE0F");
+  return isVariationSelectorCodePoint(codePoint) || isCombiningMarkCodePoint(codePoint) || codePoint >= 9472 && codePoint <= 9599 ? 1 : isFullWidthCodePoint(codePoint) || provider === "cjk" && isAmbiguousWidthCodePoint(codePoint) || isEmojiLike(codePoint) || emojiPresentationRe?.test(text) || text.includes("\u20E3") || hasVs16 && emojiRe?.test(text) ? 2 : extendedPictographicRe?.test(text) ? codePoint <= 65535 ? hasVs16 ? 2 : 1 : 2 : 1;
 }
 
 // src/utils/url-safety.ts
 var ENCODED_ASCII_CONTROL_RE = /%(?:0[0-9a-f]|1[0-9a-f]|7f)/i;
 function hasControlCodePoint(value) {
   for (let i = 0; i < value.length; i++) {
-    const code = value.charCodeAt(i);
+    let code = value.charCodeAt(i);
     if (code <= 31 || code >= 127 && code <= 159)
-      return true;
+      return !0;
   }
-  return false;
+  return !1;
 }
 function hasEncodedControl(value) {
   let current = String(value ?? "");
   for (let depth = 0; depth < 3; depth++) {
     if (ENCODED_ASCII_CONTROL_RE.test(current))
-      return true;
+      return !0;
     let decoded;
     try {
       decoded = decodeURIComponent(current);
     } catch {
-      return true;
+      return !0;
     }
     if (hasControlCodePoint(decoded))
-      return true;
+      return !0;
     if (decoded === current)
-      return false;
+      return !1;
     current = decoded;
   }
   return ENCODED_ASCII_CONTROL_RE.test(current) || hasControlCodePoint(current);
 }
 
 // src/core/hyperlink.ts
-var SCHEME_RE = /^[a-z][a-z0-9+.-]*:/i;
-var BLOCKED_SCHEME_RE = /^(?:javascript|data|vbscript):/i;
-var SAFE_RELATIVE_HREF_RE = /^(?:[A-Za-z0-9._~!$&()*+,;=:@/?#-]|%[0-9A-Fa-f]{2})+$/u;
+var SCHEME_RE = /^[a-z][a-z0-9+.-]*:/i, BLOCKED_SCHEME_RE = /^(?:javascript|data|vbscript):/i, SAFE_RELATIVE_HREF_RE = /^(?:[A-Za-z0-9._~!$&()*+,;=:@/?#-]|%[0-9A-Fa-f]{2})+$/u;
 function normalizeRawHref(value) {
-  if (typeof value !== "string")
+  if (typeof value != "string")
     return null;
-  const raw = value.trim();
-  if (!raw)
-    return null;
-  if (raw !== value)
+  let raw = value.trim();
+  if (!raw || raw !== value)
     return null;
   for (let i = 0; i < value.length; i++) {
-    const code = value.charCodeAt(i);
+    let code = value.charCodeAt(i);
     if (code <= 31 || code >= 127 && code <= 159)
       return null;
   }
-  if (/\s/u.test(raw))
-    return null;
-  if (raw.startsWith("//"))
-    return null;
-  if (BLOCKED_SCHEME_RE.test(raw))
-    return null;
-  if (hasEncodedControl(raw))
-    return null;
-  return raw;
+  return /\s/u.test(raw) || raw.startsWith("//") || BLOCKED_SCHEME_RE.test(raw) || hasEncodedControl(raw) ? null : raw;
 }
 function hrefScheme(raw) {
   return raw.match(SCHEME_RE)?.[0].toLowerCase() ?? null;
@@ -985,58 +998,33 @@ function parseSafeAbsoluteUrl(raw) {
   }
 }
 function sanitizeAbsoluteHref(raw, options = {}) {
-  const url = parseSafeAbsoluteUrl(raw);
-  if (!url)
-    return null;
-  if (url.protocol === "http:" || url.protocol === "https:") {
-    if (!/^https?:\/\//i.test(raw))
-      return null;
-    return options.preserveHttpHref ? raw : url.toString();
-  }
-  if (url.protocol === "mailto:")
-    return raw;
-  return null;
+  let url = parseSafeAbsoluteUrl(raw);
+  return url ? url.protocol === "http:" || url.protocol === "https:" ? /^https?:\/\//i.test(raw) ? options.preserveHttpHref ? raw : url.toString() : null : url.protocol === "mailto:" ? raw : null : null;
 }
 function isSafeNormalizedRelativeHref(raw) {
-  if (raw.includes("\\"))
-    return false;
-  if (raw.startsWith("//"))
-    return false;
-  if (SCHEME_RE.test(raw))
-    return false;
-  if (hasEncodedControl(raw))
-    return false;
-  if (!SAFE_RELATIVE_HREF_RE.test(raw))
-    return false;
-  return raw.startsWith("#") || raw.startsWith("?") || raw.startsWith("/") || raw.startsWith("./") || raw.startsWith("../") || /^[A-Za-z0-9._~-]/u.test(raw);
+  return raw.includes("\\") || raw.startsWith("//") || SCHEME_RE.test(raw) || hasEncodedControl(raw) || !SAFE_RELATIVE_HREF_RE.test(raw) ? !1 : raw.startsWith("#") || raw.startsWith("?") || raw.startsWith("/") || raw.startsWith("./") || raw.startsWith("../") || /^[A-Za-z0-9._~-]/u.test(raw);
 }
 function isSafeRelativeHref(value) {
-  const raw = normalizeRawHref(value);
+  let raw = normalizeRawHref(value);
   return raw != null && isSafeNormalizedRelativeHref(raw);
 }
 function sanitizeTerminalHref(value, options = {}) {
-  const raw = normalizeRawHref(value);
+  let raw = normalizeRawHref(value);
   if (!raw)
     return null;
-  const sanitized = sanitizeAbsoluteHref(raw, { preserveHttpHref: true });
+  let sanitized = sanitizeAbsoluteHref(raw, { preserveHttpHref: !0 });
   if (sanitized)
     return sanitized;
   if (options.allowFileUrls) {
-    const url = parseSafeAbsoluteUrl(raw);
+    let url = parseSafeAbsoluteUrl(raw);
     if (url?.protocol === "file:")
       return url.toString();
   }
   return null;
 }
 function sanitizeDomHref(value, options = {}) {
-  const raw = normalizeRawHref(value);
-  if (!raw)
-    return null;
-  const scheme = hrefScheme(raw);
-  if (!scheme) {
-    return options.allowRelative !== false && isSafeNormalizedRelativeHref(raw) ? raw : null;
-  }
-  return sanitizeAbsoluteHref(raw);
+  let raw = normalizeRawHref(value);
+  return raw ? hrefScheme(raw) ? sanitizeAbsoluteHref(raw) : options.allowRelative !== !1 && isSafeNormalizedRelativeHref(raw) ? raw : null : null;
 }
 
 // src/core/render-plane.ts
@@ -1045,7 +1033,7 @@ var TERMINAL_RENDER_PLANES = ["default", "transcript", "chrome", "overlay"];
 // src/utils/grapheme.ts
 var graphemeSegmenter = null;
 try {
-  const Segmenter = typeof Intl !== "undefined" ? Intl.Segmenter : void 0;
+  let Segmenter = typeof Intl < "u" ? Intl.Segmenter : void 0;
   graphemeSegmenter = Segmenter ? new Segmenter(void 0, { granularity: "grapheme" }) : null;
 } catch {
   graphemeSegmenter = null;
@@ -1057,28 +1045,18 @@ try {
   unicodeMarkRe = null;
 }
 function needsGraphemeSegmentation(text) {
-  for (const ch of text) {
-    const cp = ch.codePointAt(0);
-    if (cp === 8205)
-      return true;
-    if (cp >= 65024 && cp <= 65039 || cp >= 917760 && cp <= 917999)
-      return true;
-    if (isCombiningMark(cp))
-      return true;
-    if (cp >= 127995 && cp <= 127999)
-      return true;
-    if (cp >= 127462 && cp <= 127487)
-      return true;
-    if (cp >= 917504 && cp <= 917631)
-      return true;
-  }
-  return false;
+  for (let ch of text) {
+    let cp = ch.codePointAt(0);
+    if (cp === 8205 || cp >= 65024 && cp <= 65039 || cp >= 917760 && cp <= 917999 || isCombiningMark(cp) || cp >= 127995 && cp <= 127999 || cp >= 127462 && cp <= 127487 || cp >= 917504 && cp <= 917631)
+      return !0;
+  }
+  return !1;
 }
 function isVariationSelector(codePoint) {
   return codePoint >= 65024 && codePoint <= 65039 || codePoint >= 917760 && codePoint <= 917999;
 }
 function isCombiningMark(codePoint) {
-  return codePoint >= 768 && codePoint <= 879 || codePoint >= 6832 && codePoint <= 6911 || codePoint >= 7616 && codePoint <= 7679 || codePoint >= 8400 && codePoint <= 8447 || codePoint >= 65056 && codePoint <= 65071 || isDevanagariMark(codePoint) || unicodeMarkRe?.test(String.fromCodePoint(codePoint)) === true;
+  return codePoint >= 768 && codePoint <= 879 || codePoint >= 6832 && codePoint <= 6911 || codePoint >= 7616 && codePoint <= 7679 || codePoint >= 8400 && codePoint <= 8447 || codePoint >= 65056 && codePoint <= 65071 || isDevanagariMark(codePoint) || unicodeMarkRe?.test(String.fromCodePoint(codePoint)) === !0;
 }
 function isDevanagariMark(codePoint) {
   return codePoint >= 2304 && codePoint <= 2307 || codePoint >= 2362 && codePoint <= 2364 || codePoint >= 2366 && codePoint <= 2383 || codePoint >= 2385 && codePoint <= 2391 || codePoint >= 2402 && codePoint <= 2403;
@@ -1096,125 +1074,73 @@ function isEmojiTag(codePoint) {
   return codePoint >= 917504 && codePoint <= 917631;
 }
 function fallbackGraphemeSegments(text) {
-  const out = [];
-  let segment = "";
-  let segmentStart = 0;
-  let pos = 0;
-  let regionalIndicators = 0;
-  let joinNext = false;
-  const pushSegment = () => {
-    if (segment)
-      out.push({ segment, index: segmentStart });
+  let out = [], segment = "", segmentStart = 0, pos = 0, regionalIndicators = 0, joinNext = !1, pushSegment = () => {
+    segment && out.push({ segment, index: segmentStart });
   };
-  for (const ch of text) {
-    const codePoint = ch.codePointAt(0);
-    const chStart = pos;
-    pos += ch.length;
-    const attach = segment !== "" && (joinNext || codePoint === 8205 || isVariationSelector(codePoint) || isCombiningMark(codePoint) || isEmojiModifier(codePoint) || isEmojiTag(codePoint) || isRegionalIndicator(codePoint) && regionalIndicators === 1);
-    if (!attach) {
-      pushSegment();
-      segment = ch;
-      segmentStart = chStart;
-      regionalIndicators = isRegionalIndicator(codePoint) ? 1 : 0;
-    } else {
-      segment += ch;
-      if (isRegionalIndicator(codePoint))
-        regionalIndicators++;
-      else if (!isVariationSelector(codePoint) && !isCombiningMark(codePoint))
-        regionalIndicators = 0;
-    }
-    if (codePoint === 8205 || isVirama(codePoint))
-      joinNext = true;
-    else if (joinNext && !isVariationSelector(codePoint) && !isCombiningMark(codePoint)) {
-      joinNext = false;
-    }
+  for (let ch of text) {
+    let codePoint = ch.codePointAt(0), chStart = pos;
+    pos += ch.length, segment !== "" && (joinNext || codePoint === 8205 || isVariationSelector(codePoint) || isCombiningMark(codePoint) || isEmojiModifier(codePoint) || isEmojiTag(codePoint) || isRegionalIndicator(codePoint) && regionalIndicators === 1) ? (segment += ch, isRegionalIndicator(codePoint) ? regionalIndicators++ : !isVariationSelector(codePoint) && !isCombiningMark(codePoint) && (regionalIndicators = 0)) : (pushSegment(), segment = ch, segmentStart = chStart, regionalIndicators = isRegionalIndicator(codePoint) ? 1 : 0), codePoint === 8205 || isVirama(codePoint) ? joinNext = !0 : joinNext && !isVariationSelector(codePoint) && !isCombiningMark(codePoint) && (joinNext = !1);
   }
-  pushSegment();
-  return out;
+  return pushSegment(), out;
 }
 function segmentedGraphemes(text) {
-  if (!needsGraphemeSegmentation(text))
-    return null;
-  if (graphemeSegmenter)
-    return graphemeSegmenter.segment(text);
-  return fallbackGraphemeSegments(text);
+  return needsGraphemeSegmentation(text) ? graphemeSegmenter ? graphemeSegmenter.segment(text) : fallbackGraphemeSegments(text) : null;
 }
 
 // src/core/buffer/buffer.ts
-var DEFAULT_STYLE = Object.freeze({});
-var styleCache = /* @__PURE__ */ new WeakMap();
-var blankCellCache = /* @__PURE__ */ new WeakMap();
-var continuationCellCache = /* @__PURE__ */ new WeakMap();
-var cellCacheWidth1 = /* @__PURE__ */ new WeakMap();
-var cellCacheWidth2 = /* @__PURE__ */ new WeakMap();
-var MAX_CACHED_CELLS_PER_STYLE = 128;
+var DEFAULT_STYLE = Object.freeze({}), styleCache = /* @__PURE__ */ new WeakMap(), blankCellCache = /* @__PURE__ */ new WeakMap(), continuationCellCache = /* @__PURE__ */ new WeakMap(), cellCacheWidth1 = /* @__PURE__ */ new WeakMap(), cellCacheWidth2 = /* @__PURE__ */ new WeakMap(), MAX_CACHED_CELLS_PER_STYLE = 128;
 function normalizeStyle(style) {
   if (!style)
     return DEFAULT_STYLE;
   if (Object.isFrozen(style))
     return style;
-  const cached = styleCache.get(style);
+  let cached = styleCache.get(style);
   if (cached)
     return cached;
-  const frozen = Object.freeze({ ...style });
-  styleCache.set(style, frozen);
-  return frozen;
+  let frozen = Object.freeze({ ...style });
+  return styleCache.set(style, frozen), frozen;
 }
 function getOrCreateCellCache(map, style) {
-  const cached = map.get(style);
+  let cached = map.get(style);
   if (cached)
     return cached;
-  const next = /* @__PURE__ */ new Map();
-  map.set(style, next);
-  return next;
+  let next = /* @__PURE__ */ new Map();
+  return map.set(style, next), next;
 }
 function createCell(ch, style, widthProvider) {
   if (ch === " ")
     return createBlankCell(style);
-  const normalizedStyle = normalizeStyle(style);
-  const width = charCellWidth(ch, widthProvider);
-  const map = width === 2 ? getOrCreateCellCache(cellCacheWidth2, normalizedStyle) : getOrCreateCellCache(cellCacheWidth1, normalizedStyle);
-  const cached = map.get(ch);
+  let normalizedStyle = normalizeStyle(style), width = charCellWidth(ch, widthProvider), map = getOrCreateCellCache(width === 2 ? cellCacheWidth2 : cellCacheWidth1, normalizedStyle), cached = map.get(ch);
   if (cached)
     return cached;
-  const cell = { ch, width, style: normalizedStyle };
-  map.set(ch, cell);
-  if (map.size > MAX_CACHED_CELLS_PER_STYLE)
-    map.clear();
-  return cell;
+  let cell = { ch, width, style: normalizedStyle };
+  return map.set(ch, cell), map.size > MAX_CACHED_CELLS_PER_STYLE && map.clear(), cell;
 }
 function createBlankCell(style) {
-  const normalizedStyle = normalizeStyle(style);
-  const cached = blankCellCache.get(normalizedStyle);
+  let normalizedStyle = normalizeStyle(style), cached = blankCellCache.get(normalizedStyle);
   if (cached)
     return cached;
-  const cell = Object.freeze({
+  let cell = Object.freeze({
     ch: " ",
     width: 1,
     style: normalizedStyle
   });
-  blankCellCache.set(normalizedStyle, cell);
-  return cell;
+  return blankCellCache.set(normalizedStyle, cell), cell;
 }
 function createContinuationCell(style) {
-  const normalizedStyle = normalizeStyle(style);
-  const cached = continuationCellCache.get(normalizedStyle);
+  let normalizedStyle = normalizeStyle(style), cached = continuationCellCache.get(normalizedStyle);
   if (cached)
     return cached;
-  const cell = Object.freeze({
+  let cell = Object.freeze({
     ch: "",
     width: 1,
-    continuation: true,
+    continuation: !0,
     style: normalizedStyle
   });
-  continuationCellCache.set(normalizedStyle, cell);
-  return cell;
+  return continuationCellCache.set(normalizedStyle, cell), cell;
 }
 function createGridBuffer(cols, rows, options = {}) {
-  const safeCols = Math.max(0, Math.floor(cols));
-  const safeRows = Math.max(0, Math.floor(rows));
-  const blank = createBlankCell();
-  const grid = Array.from(
+  let safeCols = Math.max(0, Math.floor(cols)), safeRows = Math.max(0, Math.floor(rows)), blank = createBlankCell(), grid = Array.from(
     { length: safeRows },
     () => Array.from({ length: safeCols }, () => blank)
   );
@@ -1230,7 +1156,7 @@ function createGridBuffer(cols, rows, options = {}) {
     dirtyAll: safeRows > 0,
     cursorX: 0,
     cursorY: 0,
-    cursorVisible: true,
+    cursorVisible: !0,
     cursorStyle: DEFAULT_STYLE,
     scrollback: [],
     scrollbackLimit: 1e3,
@@ -1245,42 +1171,38 @@ function clamp(n, min, max) {
 }
 function setFingerprintFn(buffer, fn) {
   buffer.fingerprintFn = fn;
-  const len = buffer.rows * buffer.cols;
-  if (!len) {
+  let len = buffer.rows * buffer.cols;
+  if (!fn || !len) {
     buffer.soaFingerprints = null;
     return;
   }
   buffer.soaFingerprints = new Uint32Array(len);
   for (let y = 0; y < buffer.rows; y++) {
-    const row = getBufferRow(buffer, y);
-    const physY = physicalRowIndex(buffer, y);
-    const base = physY * buffer.cols;
+    let row = getBufferRow(buffer, y), base = physicalRowIndex(buffer, y) * buffer.cols;
     for (let x = 0; x < buffer.cols; x++) {
-      const cell = row[x];
+      let cell = row[x];
       buffer.soaFingerprints[base + x] = fn(cell.ch, cell.style);
     }
   }
 }
 function getRowFingerprints(buffer, y) {
-  if (!buffer.soaFingerprints)
+  if (!buffer.soaFingerprints || buffer.rows <= 0 || buffer.cols <= 0)
+    return null;
+  let yy = Math.floor(y);
+  if (!Number.isFinite(yy) || yy < 0 || yy >= buffer.rows)
     return null;
-  const physY = physicalRowIndex(buffer, y);
-  const base = physY * buffer.cols;
+  let base = physicalRowIndex(buffer, yy) * buffer.cols;
   return buffer.soaFingerprints.subarray(base, base + buffer.cols);
 }
 function updateCellFingerprint(buffer, physY, x, ch, style) {
-  if (!buffer.soaFingerprints || !buffer.fingerprintFn)
-    return;
-  buffer.soaFingerprints[physY * buffer.cols + x] = buffer.fingerprintFn(ch, style);
+  !buffer.soaFingerprints || !buffer.fingerprintFn || (buffer.soaFingerprints[physY * buffer.cols + x] = buffer.fingerprintFn(ch, style));
 }
 function updateRangeFingerprint(buffer, physY, x0, x1, ch, style) {
   if (!buffer.soaFingerprints || !buffer.fingerprintFn)
     return;
-  const fp = buffer.fingerprintFn(ch, style);
-  const base = physY * buffer.cols;
-  for (let x = x0; x < x1; x++) {
+  let fp = buffer.fingerprintFn(ch, style), base = physY * buffer.cols;
+  for (let x = x0; x < x1; x++)
     buffer.soaFingerprints[base + x] = fp;
-  }
 }
 function physicalRowIndex(buffer, y) {
   return (buffer.gridStart + y) % buffer.rows;
@@ -1292,400 +1214,264 @@ function getBufferCell(buffer, x, y) {
   return getBufferRow(buffer, y)[x];
 }
 function markAllDirty(buffer) {
-  if (buffer.rows <= 0)
-    return;
-  buffer.dirtyAll = true;
-  buffer.dirtyCount = buffer.rows;
-  buffer.dirtyMin = 0;
-  buffer.dirtyMax = buffer.rows - 1;
+  buffer.rows <= 0 || (buffer.dirtyAll = !0, buffer.dirtyCount = buffer.rows, buffer.dirtyMin = 0, buffer.dirtyMax = buffer.rows - 1);
 }
 function markDirty(buffer, y) {
-  if (buffer.dirtyAll)
-    return;
-  if (y < 0 || y >= buffer.rows)
-    return;
-  if (buffer.dirtyBits[y]) {
-    return;
-  }
-  buffer.dirtyBits[y] = 1;
-  buffer.dirtyCount++;
-  if (y < buffer.dirtyMin)
-    buffer.dirtyMin = y;
-  if (y > buffer.dirtyMax)
-    buffer.dirtyMax = y;
+  buffer.dirtyAll || y < 0 || y >= buffer.rows || buffer.dirtyBits[y] || (buffer.dirtyBits[y] = 1, buffer.dirtyCount++, y < buffer.dirtyMin && (buffer.dirtyMin = y), y > buffer.dirtyMax && (buffer.dirtyMax = y));
 }
 function clearCellRange(row, startX, endXExclusive) {
-  const blank = createBlankCell();
+  let blank = createBlankCell();
   for (let x = startX; x < endXExclusive; x++)
     row[x] = blank;
 }
 function clearWideIfOverwriting(row, x) {
-  const cell = row[x];
-  if (!cell)
-    return;
-  if (cell.continuation) {
-    if (x - 1 >= 0)
-      row[x - 1] = createBlankCell();
-    row[x] = createBlankCell();
-    return;
-  }
-  if (cell.width === 2) {
-    row[x] = createBlankCell();
-    if (x + 1 < row.length)
-      row[x + 1] = createBlankCell();
+  let cell = row[x];
+  if (cell) {
+    if (cell.continuation) {
+      x - 1 >= 0 && (row[x - 1] = createBlankCell()), row[x] = createBlankCell();
+      return;
+    }
+    cell.width === 2 && (row[x] = createBlankCell(), x + 1 < row.length && (row[x + 1] = createBlankCell()));
   }
 }
 function putCell(buffer, x, y, ch, style) {
-  if (y < 0 || y >= buffer.rows)
+  if (y < 0 || y >= buffer.rows || x < 0 || x >= buffer.cols)
     return;
-  if (x < 0 || x >= buffer.cols)
-    return;
-  const row = getBufferRow(buffer, y);
-  const width = charCellWidth(ch, buffer.widthProvider);
-  const previous = row[x];
-  const next = width === 2 && x + 1 < buffer.cols ? row[x + 1] : void 0;
-  const previousWideOverlap = Boolean(
-    previous?.continuation || previous?.width === 2 || next?.continuation || next?.width === 2
-  );
-  clearWideIfOverwriting(row, x);
-  if (width === 2 && x + 1 < buffer.cols)
-    clearWideIfOverwriting(row, x + 1);
-  if (width === 2 && x + 1 >= buffer.cols) {
-    const blank = createBlankCell();
-    row[x] = blank;
-    if (buffer.soaFingerprints) {
-      if (previousWideOverlap) {
+  let row = getBufferRow(buffer, y), width = charCellWidth(ch, buffer.widthProvider), previous = row[x], next = width === 2 && x + 1 < buffer.cols ? row[x + 1] : void 0, previousWideOverlap = !!(previous?.continuation || previous?.width === 2 || next?.continuation || next?.width === 2);
+  if (clearWideIfOverwriting(row, x), width === 2 && x + 1 < buffer.cols && clearWideIfOverwriting(row, x + 1), width === 2 && x + 1 >= buffer.cols) {
+    let blank = createBlankCell();
+    if (row[x] = blank, buffer.soaFingerprints)
+      if (previousWideOverlap)
         recomputeFingerprintsForRows(buffer, y, y + 1);
-      } else {
-        const physY = physicalRowIndex(buffer, y);
+      else {
+        let physY = physicalRowIndex(buffer, y);
         updateCellFingerprint(buffer, physY, x, blank.ch, blank.style);
       }
-    }
     markDirty(buffer, y);
     return;
   }
-  const cell = createCell(ch, style, buffer.widthProvider);
-  row[x] = cell;
-  if (width === 2 && x + 1 < buffer.cols)
-    row[x + 1] = createContinuationCell(style);
-  if (buffer.soaFingerprints) {
-    if (previousWideOverlap) {
+  let cell = createCell(ch, style, buffer.widthProvider);
+  if (row[x] = cell, width === 2 && x + 1 < buffer.cols && (row[x + 1] = createContinuationCell(style)), buffer.soaFingerprints)
+    if (previousWideOverlap)
       recomputeFingerprintsForRows(buffer, y, y + 1);
-    } else {
-      const physY = physicalRowIndex(buffer, y);
-      updateCellFingerprint(buffer, physY, x, cell.ch, cell.style);
-      if (width === 2 && x + 1 < buffer.cols) {
-        updateCellFingerprint(buffer, physY, x + 1, "", cell.style);
-      }
+    else {
+      let physY = physicalRowIndex(buffer, y);
+      updateCellFingerprint(buffer, physY, x, cell.ch, cell.style), width === 2 && x + 1 < buffer.cols && updateCellFingerprint(buffer, physY, x + 1, "", cell.style);
     }
-  }
   markDirty(buffer, y);
 }
 function fillRect(buffer, x, y, w, h, ch = " ", style) {
   if (w <= 0 || h <= 0 || buffer.cols === 0 || buffer.rows === 0)
     return;
-  const x0 = clamp(Math.floor(x), 0, buffer.cols);
-  const y0 = clamp(Math.floor(y), 0, buffer.rows);
-  const x1 = clamp(Math.floor(x + w), 0, buffer.cols);
-  const y1 = clamp(Math.floor(y + h), 0, buffer.rows);
+  let x0 = clamp(Math.floor(x), 0, buffer.cols), y0 = clamp(Math.floor(y), 0, buffer.rows), x1 = clamp(Math.floor(x + w), 0, buffer.cols), y1 = clamp(Math.floor(y + h), 0, buffer.rows);
   if (x1 <= x0 || y1 <= y0)
     return;
-  const width = charCellWidth(ch, buffer.widthProvider);
-  if (width === 1) {
-    const fillCell2 = createCell(ch, style, buffer.widthProvider);
-    const blank2 = createBlankCell();
+  if (charCellWidth(ch, buffer.widthProvider) === 1) {
+    let fillCell2 = createCell(ch, style, buffer.widthProvider), blank2 = createBlankCell();
     for (let yy = y0; yy < y1; yy++) {
-      const row = getBufferRow(buffer, yy);
-      const clearsLeftWideBase = Boolean(row[x0]?.continuation);
-      const clearsRightContinuation = Boolean(x1 < buffer.cols && row[x1]?.continuation);
-      if (clearsLeftWideBase)
-        clearWideIfOverwriting(row, x0);
-      row.fill(fillCell2, x0, x1);
-      if (clearsRightContinuation)
-        row[x1] = blank2;
-      if (buffer.soaFingerprints) {
-        if (clearsLeftWideBase || clearsRightContinuation) {
+      let row = getBufferRow(buffer, yy), clearsLeftWideBase = !!row[x0]?.continuation, clearsRightContinuation = !!(x1 < buffer.cols && row[x1]?.continuation);
+      if (clearsLeftWideBase && clearWideIfOverwriting(row, x0), row.fill(fillCell2, x0, x1), clearsRightContinuation && (row[x1] = blank2), buffer.soaFingerprints)
+        if (clearsLeftWideBase || clearsRightContinuation)
           recomputeFingerprintsForRows(buffer, yy, yy + 1);
-        } else {
-          const physY = physicalRowIndex(buffer, yy);
+        else {
+          let physY = physicalRowIndex(buffer, yy);
           updateRangeFingerprint(buffer, physY, x0, x1, fillCell2.ch, fillCell2.style);
         }
-      }
       markDirty(buffer, yy);
     }
     return;
   }
-  const fillCell = createCell(ch, style, buffer.widthProvider);
-  const continuationCell = createContinuationCell(style);
-  const blank = createBlankCell();
+  let fillCell = createCell(ch, style, buffer.widthProvider), continuationCell = createContinuationCell(style), blank = createBlankCell();
   for (let yy = y0; yy < y1; yy++) {
-    const row = getBufferRow(buffer, yy);
+    let row = getBufferRow(buffer, yy);
     for (let xx = x0; xx < x1; ) {
-      clearWideIfOverwriting(row, xx);
-      if (xx + 1 >= x1 || xx + 1 >= buffer.cols) {
-        row[xx] = blank;
-        xx += 1;
+      if (clearWideIfOverwriting(row, xx), xx + 1 >= x1 || xx + 1 >= buffer.cols) {
+        row[xx] = blank, xx += 1;
         continue;
       }
-      clearWideIfOverwriting(row, xx + 1);
-      row[xx] = fillCell;
-      row[xx + 1] = continuationCell;
-      xx += 2;
+      clearWideIfOverwriting(row, xx + 1), row[xx] = fillCell, row[xx + 1] = continuationCell, xx += 2;
     }
-    recomputeFingerprintsForRows(buffer, yy, yy + 1);
-    markDirty(buffer, yy);
+    recomputeFingerprintsForRows(buffer, yy, yy + 1), markDirty(buffer, yy);
   }
 }
 function clearRect(buffer, x, y, w, h) {
   if (buffer.cols === 0 || buffer.rows === 0)
     return;
   if (x == null || y == null || w == null || h == null) {
-    const blank = createBlankCell();
+    let blank = createBlankCell();
     for (let yy = 0; yy < buffer.rows; yy++) {
-      const row = getBufferRow(buffer, yy);
+      let row = getBufferRow(buffer, yy);
       row.length = buffer.cols;
       for (let xx = 0; xx < buffer.cols; xx++)
         row[xx] = blank;
     }
-    recomputeFingerprintsForRows(buffer, 0, buffer.rows);
-    markAllDirty(buffer);
-    buffer.cursorX = 0;
-    buffer.cursorY = 0;
+    recomputeFingerprintsForRows(buffer, 0, buffer.rows), markAllDirty(buffer), buffer.cursorX = 0, buffer.cursorY = 0;
     return;
   }
   if (w <= 0 || h <= 0)
     return;
-  const x0 = clamp(Math.floor(x), 0, buffer.cols);
-  const y0 = clamp(Math.floor(y), 0, buffer.rows);
-  const x1 = clamp(Math.floor(x + w), 0, buffer.cols);
-  const y1 = clamp(Math.floor(y + h), 0, buffer.rows);
-  if (x1 <= x0 || y1 <= y0)
-    return;
-  for (let yy = y0; yy < y1; yy++) {
-    const row = getBufferRow(buffer, yy);
-    if (row[x0]?.continuation)
-      clearWideIfOverwriting(row, x0);
-    clearCellRange(row, x0, x1);
-    if (x1 < buffer.cols && row[x1]?.continuation)
-      row[x1] = createBlankCell();
-    recomputeFingerprintsForRows(buffer, yy, yy + 1);
-    markDirty(buffer, yy);
-  }
+  let x0 = clamp(Math.floor(x), 0, buffer.cols), y0 = clamp(Math.floor(y), 0, buffer.rows), x1 = clamp(Math.floor(x + w), 0, buffer.cols), y1 = clamp(Math.floor(y + h), 0, buffer.rows);
+  if (!(x1 <= x0 || y1 <= y0))
+    for (let yy = y0; yy < y1; yy++) {
+      let row = getBufferRow(buffer, yy);
+      row[x0]?.continuation && clearWideIfOverwriting(row, x0), clearCellRange(row, x0, x1), x1 < buffer.cols && row[x1]?.continuation && (row[x1] = createBlankCell()), recomputeFingerprintsForRows(buffer, yy, yy + 1), markDirty(buffer, yy);
+    }
 }
 function takePooledRow(buffer) {
-  const row = buffer.rowPool.pop();
-  return row ?? null;
+  return buffer.rowPool.pop() ?? null;
 }
 function blankRow(buffer) {
-  const pooled = takePooledRow(buffer);
+  let pooled = takePooledRow(buffer);
   if (!pooled)
     return Array.from({ length: buffer.cols }, () => createBlankCell());
   pooled.length = buffer.cols;
-  const blank = createBlankCell();
+  let blank = createBlankCell();
   for (let x = 0; x < buffer.cols; x++)
     pooled[x] = blank;
   return pooled;
 }
 function recomputeFingerprintsForRows(buffer, startY, endY) {
-  if (!buffer.soaFingerprints || !buffer.fingerprintFn)
-    return;
-  for (let y = startY; y < endY; y++) {
-    const row = getBufferRow(buffer, y);
-    const physY = physicalRowIndex(buffer, y);
-    const base = physY * buffer.cols;
-    for (let x = 0; x < buffer.cols; x++) {
-      const cell = row[x];
-      buffer.soaFingerprints[base + x] = buffer.fingerprintFn(cell.ch, cell.style);
+  if (!(!buffer.soaFingerprints || !buffer.fingerprintFn))
+    for (let y = startY; y < endY; y++) {
+      let row = getBufferRow(buffer, y), base = physicalRowIndex(buffer, y) * buffer.cols;
+      for (let x = 0; x < buffer.cols; x++) {
+        let cell = row[x];
+        buffer.soaFingerprints[base + x] = buffer.fingerprintFn(cell.ch, cell.style);
+      }
     }
-  }
 }
 function recomputeAllVisibleFingerprints(buffer) {
   recomputeFingerprintsForRows(buffer, 0, buffer.rows);
 }
 function scrollBuffer(buffer, lines) {
-  const raw = Math.trunc(lines);
+  let raw = Math.trunc(lines);
   if (raw === 0 || buffer.rows === 0)
     return;
-  const abs = Math.min(Math.abs(raw), buffer.rows);
-  const n = raw > 0 ? abs : -abs;
-  if (n > 0) {
+  let abs = Math.min(Math.abs(raw), buffer.rows), n = raw > 0 ? abs : -abs;
+  if (n > 0)
     for (let i = 0; i < n; i++) {
-      const removedIdx = buffer.gridStart;
-      const removed = buffer.grid[removedIdx];
+      let removedIdx = buffer.gridStart, removed = buffer.grid[removedIdx];
       if (buffer.scrollbackLimit > 0) {
-        buffer.scrollback.push(removed);
-        if (buffer.scrollback.length > buffer.scrollbackLimit) {
-          const excess = buffer.scrollback.length - buffer.scrollbackLimit;
-          const dropped = buffer.scrollback.splice(0, excess);
+        if (buffer.scrollback.push(removed), buffer.scrollback.length > buffer.scrollbackLimit) {
+          let excess = buffer.scrollback.length - buffer.scrollbackLimit, dropped = buffer.scrollback.splice(0, excess);
           buffer.rowPool.push(...dropped);
         }
-      } else {
+      } else
         buffer.rowPool.push(removed);
-      }
       buffer.gridStart = (buffer.gridStart + 1) % buffer.rows;
-      const bottomIdx = (buffer.gridStart + buffer.rows - 1) % buffer.rows;
+      let bottomIdx = (buffer.gridStart + buffer.rows - 1) % buffer.rows;
       buffer.grid[bottomIdx] = blankRow(buffer);
     }
-  } else {
+  else
     for (let i = 0; i < -n; i++) {
-      const bottomIdx = (buffer.gridStart + buffer.rows - 1) % buffer.rows;
-      const removed = buffer.grid[bottomIdx];
-      buffer.rowPool.push(removed);
-      buffer.gridStart = (buffer.gridStart - 1 + buffer.rows) % buffer.rows;
-      buffer.grid[buffer.gridStart] = blankRow(buffer);
+      let bottomIdx = (buffer.gridStart + buffer.rows - 1) % buffer.rows, removed = buffer.grid[bottomIdx];
+      buffer.rowPool.push(removed), buffer.gridStart = (buffer.gridStart - 1 + buffer.rows) % buffer.rows, buffer.grid[buffer.gridStart] = blankRow(buffer);
     }
-  }
-  const inserted = Math.abs(n);
-  if (inserted >= buffer.rows) {
-    recomputeAllVisibleFingerprints(buffer);
-  } else if (n > 0) {
-    recomputeFingerprintsForRows(buffer, buffer.rows - inserted, buffer.rows);
-  } else {
-    recomputeFingerprintsForRows(buffer, 0, inserted);
-  }
-  markAllDirty(buffer);
-  buffer.cursorY = clamp(buffer.cursorY - n, 0, Math.max(0, buffer.rows - 1));
+  let inserted = Math.abs(n);
+  inserted >= buffer.rows ? recomputeAllVisibleFingerprints(buffer) : n > 0 ? recomputeFingerprintsForRows(buffer, buffer.rows - inserted, buffer.rows) : recomputeFingerprintsForRows(buffer, 0, inserted), markAllDirty(buffer), buffer.cursorY = clamp(buffer.cursorY - n, 0, Math.max(0, buffer.rows - 1));
 }
 function scrollBufferRegion(buffer, startY, endY, lines) {
-  const n = Math.trunc(lines);
+  let n = Math.trunc(lines);
   if (n === 0 || buffer.rows === 0)
     return [];
-  const start = clamp(Math.floor(startY), 0, buffer.rows);
-  const end = clamp(Math.floor(endY), 0, buffer.rows);
-  const height = end - start;
+  let start = clamp(Math.floor(startY), 0, buffer.rows), end = clamp(Math.floor(endY), 0, buffer.rows), height = end - start;
   if (height <= 0)
     return [];
-  const absDelta = Math.abs(n);
-  const insertedRows = [];
-  const replaceRegionWithBlankRows = () => {
+  let absDelta = Math.abs(n), insertedRows = [], replaceRegionWithBlankRows = () => {
     for (let y = start; y < end; y++) {
-      const physY = physicalRowIndex(buffer, y);
-      buffer.rowPool.push(buffer.grid[physY]);
-      buffer.grid[physY] = blankRow(buffer);
-      markDirty(buffer, y);
-      insertedRows.push(y);
+      let physY = physicalRowIndex(buffer, y);
+      buffer.rowPool.push(buffer.grid[physY]), buffer.grid[physY] = blankRow(buffer), markDirty(buffer, y), insertedRows.push(y);
     }
   };
-  if (absDelta >= height) {
-    replaceRegionWithBlankRows();
-    recomputeFingerprintsForRows(buffer, start, end);
-    if (buffer.cursorY >= start && buffer.cursorY < end)
-      buffer.cursorY = clamp(buffer.cursorY - n, start, Math.max(start, end - 1));
-    return insertedRows;
-  }
-  const regionRows = [];
+  if (absDelta >= height)
+    return replaceRegionWithBlankRows(), recomputeFingerprintsForRows(buffer, start, end), buffer.cursorY >= start && buffer.cursorY < end && (buffer.cursorY = clamp(buffer.cursorY - n, start, Math.max(start, end - 1))), insertedRows;
+  let regionRows = [];
   for (let y = start; y < end; y++)
     regionRows.push(getBufferRow(buffer, y));
-  const nextRows = Array.from({ length: height }, () => []);
+  let nextRows = Array.from({ length: height }, () => []);
   if (n > 0) {
-    const movedCount = height - n;
+    let movedCount = height - n;
     for (let i = 0; i < movedCount; i++)
       nextRows[i] = regionRows[i + n];
     for (let i = 0; i < n; i++) {
       buffer.rowPool.push(regionRows[i]);
-      const y = end - n + i;
-      nextRows[movedCount + i] = blankRow(buffer);
-      markDirty(buffer, y);
-      insertedRows.push(y);
+      let y = end - n + i;
+      nextRows[movedCount + i] = blankRow(buffer), markDirty(buffer, y), insertedRows.push(y);
     }
   } else {
-    const insertedCount = -n;
-    const movedCount = height - insertedCount;
+    let insertedCount = -n, movedCount = height - insertedCount;
     for (let i = 0; i < insertedCount; i++) {
       buffer.rowPool.push(regionRows[height - insertedCount + i]);
-      const y = start + i;
-      nextRows[i] = blankRow(buffer);
-      markDirty(buffer, y);
-      insertedRows.push(y);
+      let y = start + i;
+      nextRows[i] = blankRow(buffer), markDirty(buffer, y), insertedRows.push(y);
     }
     for (let i = 0; i < movedCount; i++)
       nextRows[insertedCount + i] = regionRows[i];
   }
   for (let i = 0; i < height; i++) {
-    const physY = physicalRowIndex(buffer, start + i);
+    let physY = physicalRowIndex(buffer, start + i);
     buffer.grid[physY] = nextRows[i];
   }
-  recomputeFingerprintsForRows(buffer, start, end);
-  if (buffer.cursorY >= start && buffer.cursorY < end)
-    buffer.cursorY = clamp(buffer.cursorY - n, start, Math.max(start, end - 1));
-  return insertedRows;
+  return recomputeFingerprintsForRows(buffer, start, end), buffer.cursorY >= start && buffer.cursorY < end && (buffer.cursorY = clamp(buffer.cursorY - n, start, Math.max(start, end - 1))), insertedRows;
 }
 function resizeBuffer(buffer, cols, rows) {
-  const nextCols = Math.max(0, Math.floor(cols));
-  const nextRows = Math.max(0, Math.floor(rows));
+  let nextCols = Math.max(0, Math.floor(cols)), nextRows = Math.max(0, Math.floor(rows));
   if (nextCols === buffer.cols && nextRows === buffer.rows)
     return;
-  const blank = createBlankCell();
-  const nextGrid = Array.from(
+  let prevRows = buffer.rows, prevDirtyAll = buffer.dirtyAll, prevDirtyBits = buffer.dirtyBits, blank = createBlankCell(), nextGrid = Array.from(
     { length: nextRows },
     () => Array.from({ length: nextCols }, () => blank)
-  );
-  const copyRows = Math.min(buffer.rows, nextRows);
-  const copyCols = Math.min(buffer.cols, nextCols);
+  ), copyRows = Math.min(prevRows, nextRows), copyCols = Math.min(buffer.cols, nextCols);
   for (let y = 0; y < copyRows; y++) {
-    const src = getBufferRow(buffer, y);
-    const dst = nextGrid[y];
+    let src = getBufferRow(buffer, y), dst = nextGrid[y];
     for (let x = 0; x < copyCols; x++)
       dst[x] = src[x];
   }
-  if (nextCols > 0) {
+  if (nextCols > 0)
     for (let y = 0; y < nextGrid.length; y++) {
-      const row = nextGrid[y];
+      let row = nextGrid[y];
       for (let x = 0; x < nextCols; x++) {
-        const cell = row[x];
+        let cell = row[x];
         if (cell.continuation) {
-          if (x === 0 || row[x - 1]?.width !== 2 || row[x - 1]?.continuation)
-            row[x] = blank;
+          (x === 0 || row[x - 1]?.width !== 2 || row[x - 1]?.continuation) && (row[x] = blank);
           continue;
         }
-        if (cell.width === 2 && (x + 1 >= nextCols || !row[x + 1]?.continuation)) {
-          row[x] = blank;
-        }
+        cell.width === 2 && (x + 1 >= nextCols || !row[x + 1]?.continuation) && (row[x] = blank);
       }
     }
-  }
   for (let y = 0; y < buffer.rows; y++)
     buffer.rowPool.push(getBufferRow(buffer, y));
-  buffer.grid = nextGrid;
-  buffer.gridStart = 0;
-  buffer.cols = nextCols;
-  buffer.rows = nextRows;
-  buffer.dirtyBits = new Uint8Array(nextRows);
-  buffer.dirtyCount = nextRows || 0;
-  buffer.dirtyMin = nextRows ? 0 : Number.POSITIVE_INFINITY;
-  buffer.dirtyMax = nextRows ? nextRows - 1 : -1;
-  buffer.dirtyAll = nextRows > 0;
-  buffer.cursorX = clamp(buffer.cursorX, 0, Math.max(0, nextCols));
-  buffer.cursorY = clamp(buffer.cursorY, 0, Math.max(0, nextRows - 1));
-  if (buffer.fingerprintFn) {
-    const len = nextRows * nextCols;
+  if (buffer.grid = nextGrid, buffer.gridStart = 0, buffer.cols = nextCols, buffer.rows = nextRows, buffer.dirtyBits = new Uint8Array(nextRows), buffer.dirtyCount = 0, buffer.dirtyMin = Number.POSITIVE_INFINITY, buffer.dirtyMax = -1, buffer.dirtyAll = prevDirtyAll && nextRows > 0, buffer.dirtyAll)
+    buffer.dirtyCount = nextRows, buffer.dirtyMin = 0, buffer.dirtyMax = nextRows - 1;
+  else
+    for (let y = 0; y < copyRows; y++)
+      prevDirtyBits[y] === 1 && (buffer.dirtyBits[y] = 1, buffer.dirtyCount++, y < buffer.dirtyMin && (buffer.dirtyMin = y), y > buffer.dirtyMax && (buffer.dirtyMax = y));
+  if (buffer.cursorX = clamp(buffer.cursorX, 0, Math.max(0, nextCols)), buffer.cursorY = clamp(buffer.cursorY, 0, Math.max(0, nextRows - 1)), buffer.fingerprintFn) {
+    let len = nextRows * nextCols;
     if (len > 0) {
       buffer.soaFingerprints = new Uint32Array(len);
       for (let y = 0; y < nextRows; y++) {
-        const row = nextGrid[y];
-        const base = y * nextCols;
+        let row = nextGrid[y], base = y * nextCols;
         for (let x = 0; x < nextCols; x++) {
-          const cell = row[x];
+          let cell = row[x];
           buffer.soaFingerprints[base + x] = buffer.fingerprintFn(cell.ch, cell.style);
         }
       }
-    } else {
+    } else
       buffer.soaFingerprints = null;
-    }
   }
 }
 function snapshotText(buffer) {
-  const out = [];
+  let out = [];
   for (let y = 0; y < buffer.rows; y++) {
-    const row = getBufferRow(buffer, y);
+    let row = getBufferRow(buffer, y);
     out.push(row.map((cell) => cell.continuation ? " " : cell.ch || " ").join(""));
   }
   return out;
 }
 
 // src/core/terminal/emitter.ts
-var emitterListeners = /* @__PURE__ */ new WeakMap();
-var Emitter = class {
+var emitterListeners = /* @__PURE__ */ new WeakMap(), Emitter = class {
   constructor() {
     emitterListeners.set(this, /* @__PURE__ */ new Map());
   }
@@ -1693,25 +1479,16 @@ var Emitter = class {
     return emitterListeners.get(this);
   }
   on(event, cb) {
-    const listeners = this.getListeners();
-    let set = listeners.get(event);
-    if (!set) {
-      set = /* @__PURE__ */ new Set();
-      listeners.set(event, set);
-    }
-    set.add(cb);
-    return () => {
-      set.delete(cb);
-      if (set.size === 0)
-        listeners.delete(event);
+    let listeners = this.getListeners(), set = listeners.get(event);
+    return set || (set = /* @__PURE__ */ new Set(), listeners.set(event, set)), set.add(cb), () => {
+      set.delete(cb), set.size === 0 && listeners.delete(event);
     };
   }
   emit(event, payload) {
-    const set = this.getListeners().get(event);
-    if (!set)
-      return;
-    for (const cb of set)
-      cb(payload);
+    let set = this.getListeners().get(event);
+    if (set)
+      for (let cb of set)
+        cb(payload);
   }
   clear() {
     this.getListeners().clear();
@@ -1720,44 +1497,37 @@ var Emitter = class {
 
 // src/core/terminal/create-terminal.ts
 function isControlChar(ch) {
-  return ch === "\n" || ch === "\r" || ch === "	";
+  return ch === `
+` || ch === "\r" || ch === "	";
 }
 function mergePlanes(prev, next) {
   if (!prev?.length)
     return next?.length ? [...next] : null;
   if (!next?.length)
     return prev;
-  const merged = new Set(prev);
-  for (const plane of next)
+  let merged = new Set(prev);
+  for (let plane of next)
     merged.add(plane);
   return Array.from(merged);
 }
-var TERMINAL_PLANE_INTERNALS = Symbol.for("@simon_he/vue-tui:v1:terminal-plane-internals");
+var TERMINAL_PLANE_INTERNALS = Symbol.for("@simon_he/vue-tui:v1:terminal-plane-internals"), TERMINAL_ROOT = Symbol.for("@simon_he/vue-tui:v1:terminal-root");
 function createCoverage(cols, rows) {
   return Array.from({ length: rows }, () => new Uint8Array(cols));
 }
 function resizeCoverage(prev, cols, rows) {
-  const next = createCoverage(cols, rows);
-  const copyRows = Math.min(prev.length, rows);
+  let next = createCoverage(cols, rows), copyRows = Math.min(prev.length, rows);
   for (let y = 0; y < copyRows; y++) {
-    const src = prev[y];
-    const dst = next[y];
-    dst.set(src.subarray(0, Math.min(src.length, cols)));
+    let src = prev[y];
+    next[y].set(src.subarray(0, Math.min(src.length, cols)));
   }
   return next;
 }
 function setBufferClean(buffer) {
-  buffer.dirtyBits.fill(0);
-  buffer.dirtyCount = 0;
-  buffer.dirtyMin = Number.POSITIVE_INFINITY;
-  buffer.dirtyMax = -1;
-  buffer.dirtyAll = false;
+  buffer.dirtyBits.fill(0), buffer.dirtyCount = 0, buffer.dirtyMin = Number.POSITIVE_INFINITY, buffer.dirtyMax = -1, buffer.dirtyAll = !1;
 }
 function createPlaneState(cols, rows, widthProvider) {
-  const buffer = createGridBuffer(cols, rows, { widthProvider });
-  setBufferClean(buffer);
-  buffer.cursorVisible = false;
-  return {
+  let buffer = createGridBuffer(cols, rows, { widthProvider });
+  return setBufferClean(buffer), buffer.cursorVisible = !1, {
     buffer,
     coverage: createCoverage(cols, rows)
   };
@@ -1765,31 +1535,14 @@ function createPlaneState(cols, rows, widthProvider) {
 function collectAndClearDirtyRows(buffer) {
   if (buffer.rows === 0)
     return [];
-  if (buffer.dirtyAll) {
-    buffer.dirtyAll = false;
-    buffer.dirtyBits.fill(0);
-    buffer.dirtyCount = 0;
-    buffer.dirtyMin = Number.POSITIVE_INFINITY;
-    buffer.dirtyMax = -1;
-    return null;
-  }
+  if (buffer.dirtyAll)
+    return buffer.dirtyAll = !1, buffer.dirtyBits.fill(0), buffer.dirtyCount = 0, buffer.dirtyMin = Number.POSITIVE_INFINITY, buffer.dirtyMax = -1, null;
   if (buffer.dirtyCount === 0)
     return [];
-  const out = [];
-  const start = Math.max(0, buffer.dirtyMin);
-  const end = Math.min(buffer.rows - 1, buffer.dirtyMax);
-  for (let y = start; y <= end; y++) {
-    if (buffer.dirtyBits[y]) {
-      buffer.dirtyBits[y] = 0;
-      out.push(y);
-      if (out.length === buffer.dirtyCount)
-        break;
-    }
-  }
-  buffer.dirtyCount = 0;
-  buffer.dirtyMin = Number.POSITIVE_INFINITY;
-  buffer.dirtyMax = -1;
-  return out;
+  let out = [], start = Math.max(0, buffer.dirtyMin), end = Math.min(buffer.rows - 1, buffer.dirtyMax);
+  for (let y = start; y <= end && !(buffer.dirtyBits[y] && (buffer.dirtyBits[y] = 0, out.push(y), out.length === buffer.dirtyCount)); y++)
+    ;
+  return buffer.dirtyCount = 0, buffer.dirtyMin = Number.POSITIVE_INFINITY, buffer.dirtyMax = -1, out;
 }
 function peekDirtyRows(buffer) {
   if (buffer.rows === 0)
@@ -1798,60 +1551,39 @@ function peekDirtyRows(buffer) {
     return null;
   if (buffer.dirtyCount === 0)
     return [];
-  const out = [];
-  const start = Math.max(0, buffer.dirtyMin);
-  const end = Math.min(buffer.rows - 1, buffer.dirtyMax);
-  for (let y = start; y <= end; y++) {
-    if (buffer.dirtyBits[y]) {
-      out.push(y);
-      if (out.length === buffer.dirtyCount)
-        break;
-    }
-  }
+  let out = [], start = Math.max(0, buffer.dirtyMin), end = Math.min(buffer.rows - 1, buffer.dirtyMax);
+  for (let y = start; y <= end && !(buffer.dirtyBits[y] && (out.push(y), out.length === buffer.dirtyCount)); y++)
+    ;
   return out;
 }
 function clearPlaneCoverageRow(state, y) {
   if (y < 0 || y >= state.buffer.rows)
     return;
-  const row = getBufferRow(state.buffer, y);
-  const blank = createBlankCell();
+  let row = getBufferRow(state.buffer, y), blank = createBlankCell();
   row.length = state.buffer.cols;
   for (let x = 0; x < state.buffer.cols; x++)
     row[x] = blank;
-  state.coverage[y]?.fill(0);
-  markDirty(state.buffer, y);
+  state.coverage[y]?.fill(0), markDirty(state.buffer, y);
 }
 function markPlaneCoverageRange(state, x0, y0, x1, y1, value) {
   for (let y = y0; y < y1; y++) {
-    const row = state.coverage[y];
-    if (!row)
-      continue;
-    row.fill(value, x0, x1);
+    let row = state.coverage[y];
+    row && row.fill(value, x0, x1);
   }
 }
 function markPlaneCoverageForPut(state, x, y, ch, prevCell) {
-  const row = state.coverage[y];
-  if (!row)
+  if (!Number.isSafeInteger(x) || !Number.isSafeInteger(y) || x < 0 || x >= state.buffer.cols || y < 0 || y >= state.buffer.rows)
     return;
-  if (prevCell?.continuation && x > 0)
-    row[x - 1] = 1;
-  if (prevCell?.width === 2 && x + 1 < row.length)
-    row[x + 1] = 1;
-  row[x] = 1;
-  if (ch !== " " && x + 1 < row.length) {
-    const next = getBufferCell(state.buffer, x, y);
-    if (next.width === 2)
-      row[x + 1] = 1;
-  }
+  let row = state.coverage[y];
+  row && (prevCell?.continuation && x > 0 && (row[x - 1] = 1), prevCell?.width === 2 && x + 1 < row.length && (row[x + 1] = 1), row[x] = 1, ch !== " " && x + 1 < row.length && getBufferCell(state.buffer, x, y).width === 2 && (row[x + 1] = 1));
 }
 function scrollPlaneCoverage(state, lines) {
-  const n = Math.trunc(lines);
+  let n = Math.trunc(lines);
   if (n === 0 || state.coverage.length === 0)
     return;
-  const rows = state.coverage.length;
-  const cols = state.buffer.cols;
+  let rows = state.coverage.length, cols = state.buffer.cols;
   if (Math.abs(n) >= rows) {
-    for (const row of state.coverage)
+    for (let row of state.coverage)
       row.fill(0);
     return;
   }
@@ -1866,31 +1598,27 @@ function scrollPlaneCoverage(state, lines) {
     state.coverage.unshift(new Uint8Array(cols));
 }
 function scrollPlaneCoverageRegion(state, startY, endY, lines) {
-  const n = Math.trunc(lines);
+  let n = Math.trunc(lines);
   if (n === 0 || state.coverage.length === 0)
     return;
-  const start = Math.max(0, Math.min(state.coverage.length, Math.floor(startY)));
-  const end = Math.max(0, Math.min(state.coverage.length, Math.floor(endY)));
-  const height = end - start;
+  let start = Math.max(0, Math.min(state.coverage.length, Math.floor(startY))), end = Math.max(0, Math.min(state.coverage.length, Math.floor(endY))), height = end - start;
   if (height <= 0)
     return;
-  const cols = state.buffer.cols;
+  let cols = state.buffer.cols;
   if (Math.abs(n) >= height) {
     for (let y = start; y < end; y++)
       state.coverage[y] = new Uint8Array(cols);
     return;
   }
-  const region = state.coverage.slice(start, end);
-  const next = Array.from({ length: height }, () => new Uint8Array(0));
+  let region = state.coverage.slice(start, end), next = Array.from({ length: height }, () => new Uint8Array(0));
   if (n > 0) {
-    const movedCount = height - n;
+    let movedCount = height - n;
     for (let i = 0; i < movedCount; i++)
       next[i] = region[i + n];
     for (let i = 0; i < n; i++)
       next[movedCount + i] = new Uint8Array(cols);
   } else {
-    const insertedCount = -n;
-    const movedCount = height - insertedCount;
+    let insertedCount = -n, movedCount = height - insertedCount;
     for (let i = 0; i < insertedCount; i++)
       next[i] = new Uint8Array(cols);
     for (let i = 0; i < movedCount; i++)
@@ -1900,303 +1628,211 @@ function scrollPlaneCoverageRegion(state, startY, endY, lines) {
     state.coverage[start + i] = next[i];
 }
 function resizePlaneState(state, cols, rows) {
-  resizeBuffer(state.buffer, cols, rows);
-  state.coverage = resizeCoverage(state.coverage, state.buffer.cols, state.buffer.rows);
+  resizeBuffer(state.buffer, cols, rows), state.coverage = resizeCoverage(state.coverage, state.buffer.cols, state.buffer.rows);
 }
 function normalizeDirtyRows(rows, totalRows) {
   if (rows === null)
     return null;
   if (rows.length === 0)
     return rows;
-  const out = [];
-  for (const y of rows) {
-    const yy = Math.floor(y);
-    if (yy < 0 || yy >= totalRows)
-      continue;
-    if (out[out.length - 1] === yy)
-      continue;
-    out.push(yy);
+  let out = [];
+  for (let y of rows) {
+    let yy = Math.floor(y);
+    yy < 0 || yy >= totalRows || out[out.length - 1] !== yy && out.push(yy);
   }
   return out;
 }
 function createTerminal(opts) {
-  const widthProvider = opts.widthProvider ?? "default";
-  const emitter = new Emitter();
-  const compositeBuffer = createGridBuffer(opts.cols, opts.rows, {
+  let widthProvider = opts.widthProvider ?? "default", emitter = new Emitter(), compositeBuffer = createGridBuffer(opts.cols, opts.rows, {
     widthProvider
-  });
-  const planeStates = /* @__PURE__ */ new Map();
-  let disposed = false;
-  let batchingDepth = 0;
-  let pendingCommit = false;
-  let pendingCommitAllPlanes = false;
-  let pendingCommitPlanes = null;
-  const pendingPlaneScrollOps = /* @__PURE__ */ new Map();
-  const planeTerminals = /* @__PURE__ */ new Map();
-  let base;
-  compositeBuffer.cursorVisible = false;
+  }), planeStates = /* @__PURE__ */ new Map(), disposed = !1, batchingDepth = 0, pendingCommit = !1, pendingCommitAllPlanes = !1, pendingCommitPlanes = null, pendingPlaneScrollOps = /* @__PURE__ */ new Map(), planeTerminals = /* @__PURE__ */ new Map(), base;
+  compositeBuffer.cursorVisible = !1;
   function assertNotDisposed() {
     if (disposed)
       throw new Error("Terminal is disposed");
   }
   function getPlaneState(plane) {
     let state = planeStates.get(plane);
-    if (!state) {
-      state = createPlaneState(compositeBuffer.cols, compositeBuffer.rows, widthProvider);
-      planeStates.set(plane, state);
-    }
-    return state;
+    return state || (state = createPlaneState(compositeBuffer.cols, compositeBuffer.rows, widthProvider), planeStates.set(plane, state)), state;
   }
-  function setCursorForPlane(plane, x, y, visible = true) {
-    const state = getPlaneState(plane);
-    state.buffer.cursorX = Math.max(0, Math.min(state.buffer.cols, Math.floor(x)));
-    state.buffer.cursorY = Math.max(
+  function setCursorForPlane(plane, x, y, visible = !0) {
+    let state = getPlaneState(plane);
+    state.buffer.cursorX = Math.max(0, Math.min(state.buffer.cols, Math.floor(x))), state.buffer.cursorY = Math.max(
       0,
       Math.min(state.buffer.rows ? state.buffer.rows - 1 : 0, Math.floor(y))
-    );
-    state.buffer.cursorVisible = visible;
-    markDirty(state.buffer, state.buffer.cursorY);
+    ), state.buffer.cursorVisible = visible, markDirty(state.buffer, state.buffer.cursorY);
   }
   function putForPlane(plane, x, y, ch, style) {
-    const state = getPlaneState(plane);
-    if (y < 0 || y >= state.buffer.rows || x < 0 || x >= state.buffer.cols)
+    let state = getPlaneState(plane);
+    if (typeof x != "number" || typeof y != "number")
+      return;
+    let cellX = Math.floor(x), cellY = Math.floor(y);
+    if (!Number.isFinite(cellX) || !Number.isFinite(cellY) || cellY < 0 || cellY >= state.buffer.rows || cellX < 0 || cellX >= state.buffer.cols)
       return;
-    const prevCell = getBufferCell(state.buffer, x, y);
-    putCell(state.buffer, x, y, ch, style);
-    markPlaneCoverageForPut(state, x, y, ch, prevCell);
+    let prevCell = getBufferCell(state.buffer, cellX, cellY);
+    putCell(state.buffer, cellX, cellY, ch, style), markPlaneCoverageForPut(state, cellX, cellY, ch, prevCell);
   }
   function writeAtForPlane(plane, text, x, y, style) {
-    const state = getPlaneState(plane);
-    let cx = x;
-    let cy = y;
+    let state = getPlaneState(plane), cx = x, cy = y;
     if (state.buffer.cols === 0 || state.buffer.rows === 0)
       return { x: cx, y: cy };
-    const writeChar = (ch) => {
+    let writeChar = (ch) => {
       if (isControlChar(ch)) {
-        if (ch === "\n") {
+        if (ch === `
+`)
+          cx = 0, cy += 1, cy >= state.buffer.rows && (scrollBuffer(state.buffer, 1), scrollPlaneCoverage(state, 1), cy = state.buffer.rows - 1);
+        else if (ch === "\r")
           cx = 0;
-          cy += 1;
-          if (cy >= state.buffer.rows) {
-            scrollBuffer(state.buffer, 1);
-            scrollPlaneCoverage(state, 1);
-            cy = state.buffer.rows - 1;
-          }
-        } else if (ch === "\r") {
-          cx = 0;
-        } else if (ch === "	") {
-          const tabSize = 4;
-          const next = Math.min(state.buffer.cols, cx + (tabSize - cx % tabSize));
+        else if (ch === "	") {
+          let next = Math.min(state.buffer.cols, cx + (4 - cx % 4));
           for (; cx < next; cx++)
             putForPlane(plane, cx, cy, " ", style);
         }
-        return true;
+        return !0;
       }
       if (cy < 0 || cy >= state.buffer.rows)
-        return false;
-      if (cx >= state.buffer.cols) {
-        cx = 0;
-        cy += 1;
-      }
-      if (cy >= state.buffer.rows) {
-        scrollBuffer(state.buffer, 1);
-        scrollPlaneCoverage(state, 1);
-        cy = state.buffer.rows - 1;
-      }
-      putForPlane(plane, cx, cy, ch, style);
-      const width = ch === " " ? 1 : getBufferCell(state.buffer, cx, cy).width || 1;
-      cx += width;
-      return true;
-    };
-    const segments = segmentedGraphemes(text);
+        return !1;
+      cx >= state.buffer.cols && (cx = 0, cy += 1), cy >= state.buffer.rows && (scrollBuffer(state.buffer, 1), scrollPlaneCoverage(state, 1), cy = state.buffer.rows - 1), putForPlane(plane, cx, cy, ch, style);
+      let width = ch === " " ? 1 : getBufferCell(state.buffer, cx, cy).width || 1;
+      return cx += width, !0;
+    }, segments = segmentedGraphemes(text);
     if (segments) {
-      for (const seg of segments) {
+      for (let seg of segments)
         if (!writeChar(seg.segment))
           break;
-      }
       return { x: cx, y: cy };
     }
     let i = 0;
-    for (; i < text.length; i++) {
-      const code = text.charCodeAt(i);
-      if (code > 127)
-        break;
+    for (; i < text.length && !(text.charCodeAt(i) > 127); i++)
       if (!writeChar(text[i]))
         return { x: cx, y: cy };
-    }
     if (i < text.length) {
-      const rest = text.slice(i);
-      const restSegments = segmentedGraphemes(rest);
+      let rest = text.slice(i), restSegments = segmentedGraphemes(rest);
       if (restSegments) {
-        for (const seg of restSegments) {
+        for (let seg of restSegments)
           if (!writeChar(seg.segment))
             break;
-        }
-      } else {
-        for (const ch of rest) {
+      } else
+        for (let ch of rest)
           if (!writeChar(ch))
             break;
-        }
-      }
     }
     return { x: cx, y: cy };
   }
   function clearForPlane(plane, x, y, w, h) {
-    const state = getPlaneState(plane);
-    clearRect(state.buffer, x, y, w, h);
-    if (x == null || y == null || w == null || h == null) {
-      for (const row of state.coverage)
+    let state = getPlaneState(plane);
+    if (clearRect(state.buffer, x, y, w, h), x == null || y == null || w == null || h == null) {
+      for (let row of state.coverage)
         row.fill(1);
       return;
     }
     if (w <= 0 || h <= 0)
       return;
-    const x0 = Math.max(0, Math.min(state.buffer.cols, Math.floor(x)));
-    const y0 = Math.max(0, Math.min(state.buffer.rows, Math.floor(y)));
-    const x1 = Math.max(0, Math.min(state.buffer.cols, Math.floor(x + w)));
-    const y1 = Math.max(0, Math.min(state.buffer.rows, Math.floor(y + h)));
-    if (x1 <= x0 || y1 <= y0)
-      return;
-    markPlaneCoverageRange(state, x0, y0, x1, y1, 1);
+    let x0 = Math.max(0, Math.min(state.buffer.cols, Math.floor(x))), y0 = Math.max(0, Math.min(state.buffer.rows, Math.floor(y))), x1 = Math.max(0, Math.min(state.buffer.cols, Math.floor(x + w))), y1 = Math.max(0, Math.min(state.buffer.rows, Math.floor(y + h)));
+    x1 <= x0 || y1 <= y0 || markPlaneCoverageRange(state, x0, y0, x1, y1, 1);
   }
   function fillForPlane(plane, x, y, w, h, ch, style) {
-    const state = getPlaneState(plane);
-    fillRect(state.buffer, x, y, w, h, ch ?? " ", style);
-    if (w <= 0 || h <= 0 || state.buffer.cols === 0 || state.buffer.rows === 0)
+    let state = getPlaneState(plane);
+    if (fillRect(state.buffer, x, y, w, h, ch ?? " ", style), w <= 0 || h <= 0 || state.buffer.cols === 0 || state.buffer.rows === 0)
       return;
-    const x0 = Math.max(0, Math.min(state.buffer.cols, Math.floor(x)));
-    const y0 = Math.max(0, Math.min(state.buffer.rows, Math.floor(y)));
-    const x1 = Math.max(0, Math.min(state.buffer.cols, Math.floor(x + w)));
-    const y1 = Math.max(0, Math.min(state.buffer.rows, Math.floor(y + h)));
-    if (x1 <= x0 || y1 <= y0)
-      return;
-    markPlaneCoverageRange(state, x0, y0, x1, y1, 1);
+    let x0 = Math.max(0, Math.min(state.buffer.cols, Math.floor(x))), y0 = Math.max(0, Math.min(state.buffer.rows, Math.floor(y))), x1 = Math.max(0, Math.min(state.buffer.cols, Math.floor(x + w))), y1 = Math.max(0, Math.min(state.buffer.rows, Math.floor(y + h)));
+    x1 <= x0 || y1 <= y0 || markPlaneCoverageRange(state, x0, y0, x1, y1, 1);
   }
   function scrollForPlane(plane, lines) {
-    const state = getPlaneState(plane);
-    scrollBuffer(state.buffer, lines);
-    scrollPlaneCoverage(state, lines);
+    let state = getPlaneState(plane);
+    scrollBuffer(state.buffer, lines), scrollPlaneCoverage(state, lines);
   }
   function normalizeScrollOperation(startY, endY, delta, totalRows) {
-    const start = Math.max(0, Math.min(totalRows, Math.floor(startY)));
-    const end = Math.max(0, Math.min(totalRows, Math.floor(endY)));
-    const height = end - start;
-    const lines = Math.trunc(delta);
-    if (height <= 0 || lines === 0 || Math.abs(lines) >= height)
-      return null;
-    return { startY: start, endY: end, delta: lines };
+    let start = Math.max(0, Math.min(totalRows, Math.floor(startY))), end = Math.max(0, Math.min(totalRows, Math.floor(endY))), height = end - start, lines = Math.trunc(delta);
+    return height <= 0 || lines === 0 || Math.abs(lines) >= height ? null : { startY: start, endY: end, delta: lines };
   }
   function recordPendingScrollOp(plane, op) {
-    const list = pendingPlaneScrollOps.get(plane) ?? [];
-    const last = list[list.length - 1];
+    let list = pendingPlaneScrollOps.get(plane) ?? [], last = list[list.length - 1];
     if (last && last.startY === op.startY && last.endY === op.endY && Math.sign(last.delta) === Math.sign(op.delta)) {
-      const next = normalizeScrollOperation(
+      let next = normalizeScrollOperation(
         op.startY,
         op.endY,
         last.delta + op.delta,
         compositeBuffer.rows
       );
-      if (next)
-        list[list.length - 1] = next;
-      else
-        list.push(op);
-    } else {
+      next ? list[list.length - 1] = next : list.push(op);
+    } else
       list.push(op);
-    }
     pendingPlaneScrollOps.set(plane, list);
   }
   function takePendingScrollOps(planes) {
-    const planesToTake = planes?.length ? planes : TERMINAL_RENDER_PLANES;
-    const out = [];
-    for (const plane of planesToTake) {
-      const ops = pendingPlaneScrollOps.get(plane);
-      if (!ops?.length)
-        continue;
-      pendingPlaneScrollOps.delete(plane);
-      for (const op of ops)
-        out.push({ plane, ...op });
+    let planesToTake = planes?.length ? planes : TERMINAL_RENDER_PLANES, out = [];
+    for (let plane of planesToTake) {
+      let ops = pendingPlaneScrollOps.get(plane);
+      if (ops?.length) {
+        pendingPlaneScrollOps.delete(plane);
+        for (let op of ops)
+          out.push({ plane, ...op });
+      }
     }
     return out.length ? out : null;
   }
   function higherPlanesFor(plane) {
-    const planeIndex = TERMINAL_RENDER_PLANES.indexOf(plane);
-    if (planeIndex < 0)
-      return [];
-    return TERMINAL_RENDER_PLANES.slice(planeIndex + 1);
+    let planeIndex = TERMINAL_RENDER_PLANES.indexOf(plane);
+    return planeIndex < 0 ? [] : TERMINAL_RENDER_PLANES.slice(planeIndex + 1);
   }
   function higherPlaneCoverageKind(plane, y) {
-    const higherPlanes = higherPlanesFor(plane);
+    let higherPlanes = higherPlanesFor(plane);
     if (!higherPlanes.length || y < 0 || y >= compositeBuffer.rows)
       return 0;
     let covered = 0;
     for (let x = 0; x < compositeBuffer.cols; x++) {
-      let cellCovered = false;
-      for (const higherPlane of higherPlanes) {
-        const state = planeStates.get(higherPlane);
-        if (state?.coverage[y]?.[x]) {
-          cellCovered = true;
+      let cellCovered = !1;
+      for (let higherPlane of higherPlanes)
+        if (planeStates.get(higherPlane)?.coverage[y]?.[x]) {
+          cellCovered = !0;
           break;
         }
-      }
-      if (cellCovered)
-        covered++;
+      cellCovered && covered++;
     }
-    if (covered === 0)
-      return 0;
-    if (covered >= compositeBuffer.cols)
-      return 2;
-    return 1;
+    return covered === 0 ? 0 : covered >= compositeBuffer.cols ? 2 : 1;
   }
   function addAffectedRows(out, op) {
     for (let y = op.startY; y < op.endY; y++)
       out.add(y);
   }
   function areDisjointSorted(ops) {
-    for (let i = 1; i < ops.length; i++) {
+    for (let i = 1; i < ops.length; i++)
       if (ops[i - 1].endY > ops[i].startY)
-        return false;
-    }
-    return true;
+        return !1;
+    return !0;
   }
   function groupedPendingScrollOps(pendingOps) {
-    const grouped = /* @__PURE__ */ new Map();
-    for (const pending of pendingOps) {
-      const list = grouped.get(pending.plane) ?? [];
+    let grouped = /* @__PURE__ */ new Map();
+    for (let pending of pendingOps) {
+      let list = grouped.get(pending.plane) ?? [];
       list.push({
         startY: pending.startY,
         endY: pending.endY,
         delta: pending.delta
-      });
-      grouped.set(pending.plane, list);
+      }), grouped.set(pending.plane, list);
     }
     return grouped;
   }
   function prepareCompositeScrollOps(pendingOps) {
-    if (!pendingOps?.length) {
+    if (!pendingOps?.length)
       return {
         scrollOperations: null,
         extraDirtyRows: []
       };
-    }
-    const scrollOperations = [];
-    const extraDirtyRows = /* @__PURE__ */ new Set();
-    const grouped = groupedPendingScrollOps(pendingOps);
-    for (const [plane, ops] of grouped) {
-      const sorted = [...ops].sort((a, b) => a.startY - b.startY || a.endY - b.endY);
+    let scrollOperations = [], extraDirtyRows = /* @__PURE__ */ new Set(), grouped = groupedPendingScrollOps(pendingOps);
+    for (let [plane, ops] of grouped) {
+      let sorted = [...ops].sort((a, b) => a.startY - b.startY || a.endY - b.endY);
       if (!areDisjointSorted(sorted)) {
-        for (const op of ops)
+        for (let op of ops)
           addAffectedRows(extraDirtyRows, op);
         continue;
       }
-      for (const op of sorted) {
-        const blockedRows = /* @__PURE__ */ new Set();
-        const partiallyBlockedRows = /* @__PURE__ */ new Set();
+      for (let op of sorted) {
+        let blockedRows = /* @__PURE__ */ new Set(), partiallyBlockedRows = /* @__PURE__ */ new Set();
         for (let y = op.startY; y < op.endY; y++) {
-          const coverageKind = higherPlaneCoverageKind(plane, y);
-          if (coverageKind === 0)
-            continue;
-          blockedRows.add(y);
-          if (coverageKind === 1)
-            partiallyBlockedRows.add(y);
+          let coverageKind = higherPlaneCoverageKind(plane, y);
+          coverageKind !== 0 && (blockedRows.add(y), coverageKind === 1 && partiallyBlockedRows.add(y));
         }
         if (!blockedRows.size) {
           scrollOperations.push({
@@ -2206,34 +1842,29 @@ function createTerminal(opts) {
           });
           continue;
         }
-        const absDelta = Math.abs(op.delta);
-        for (let y = op.startY; y < op.endY; y++) {
-          if (partiallyBlockedRows.has(y))
-            extraDirtyRows.add(y);
-        }
-        let bandStart = -1;
-        const flushBand = (bandEnd) => {
+        let absDelta = Math.abs(op.delta);
+        for (let y = op.startY; y < op.endY; y++)
+          partiallyBlockedRows.has(y) && extraDirtyRows.add(y);
+        let bandStart = -1, flushBand = (bandEnd) => {
           if (bandStart < 0 || bandEnd <= bandStart)
             return;
-          const bandHeight = bandEnd - bandStart;
+          let bandHeight = bandEnd - bandStart;
           if (absDelta >= bandHeight) {
             for (let y = bandStart; y < bandEnd; y++)
               extraDirtyRows.add(y);
             bandStart = -1;
             return;
           }
-          scrollOperations.push({
+          if (scrollOperations.push({
             startY: bandStart,
             endY: bandEnd,
             delta: op.delta
-          });
-          if (op.delta > 0) {
+          }), op.delta > 0)
             for (let y = bandEnd - absDelta; y < bandEnd; y++)
               extraDirtyRows.add(y);
-          } else {
+          else
             for (let y = bandStart; y < bandStart + absDelta; y++)
               extraDirtyRows.add(y);
-          }
           bandStart = -1;
         };
         for (let y = op.startY; y < op.endY; y++) {
@@ -2241,8 +1872,7 @@ function createTerminal(opts) {
             flushBand(y);
             continue;
           }
-          if (bandStart < 0)
-            bandStart = y;
+          bandStart < 0 && (bandStart = y);
         }
         flushBand(op.endY);
       }
@@ -2254,77 +1884,56 @@ function createTerminal(opts) {
   }
   function dirtyRowsCoverRange(rows, startY, endY) {
     if (rows === null)
-      return true;
+      return !0;
     if (!rows.length)
-      return false;
+      return !1;
     let idx = 0;
-    while (idx < rows.length && (rows[idx] ?? -1) < startY)
+    for (; idx < rows.length && (rows[idx] ?? -1) < startY; )
       idx++;
     for (let y = startY; y < endY; y++) {
       if (rows[idx] !== y)
-        return false;
+        return !1;
       idx++;
     }
-    return true;
+    return !0;
   }
   function dropScrollOpsCoveredByDirtyRows(ops, dirtyRows) {
     if (!ops?.length)
       return null;
-    const next = ops.filter((op) => !dirtyRowsCoverRange(dirtyRows, op.startY, op.endY));
+    let next = ops.filter((op) => !dirtyRowsCoverRange(dirtyRows, op.startY, op.endY));
     return next.length ? next : null;
   }
   function scrollRowsForPlane(plane, startY, endY, lines) {
-    const state = getPlaneState(plane);
-    const op = normalizeScrollOperation(startY, endY, lines, state.buffer.rows);
-    if (!op)
-      return;
-    scrollBufferRegion(state.buffer, op.startY, op.endY, op.delta);
-    scrollPlaneCoverageRegion(state, op.startY, op.endY, op.delta);
-    recordPendingScrollOp(plane, op);
+    let state = getPlaneState(plane), op = normalizeScrollOperation(startY, endY, lines, state.buffer.rows);
+    op && (scrollBufferRegion(state.buffer, op.startY, op.endY, op.delta), scrollPlaneCoverageRegion(state, op.startY, op.endY, op.delta), recordPendingScrollOp(plane, op));
   }
   function composeRows(rows, planes = TERMINAL_RENDER_PLANES) {
-    const blank = createBlankCell();
-    const fpFn = compositeBuffer.fingerprintFn;
-    const fpArr = compositeBuffer.soaFingerprints;
-    const rowList = rows ?? Array.from({ length: compositeBuffer.rows }, (_, index) => index);
-    for (const y of rowList) {
+    let blank = createBlankCell(), fpFn = compositeBuffer.fingerprintFn, fpArr = compositeBuffer.soaFingerprints, rowList = rows ?? Array.from({ length: compositeBuffer.rows }, (_, index) => index);
+    for (let y of rowList) {
       if (y < 0 || y >= compositeBuffer.rows)
         continue;
-      const dst = getBufferRow(compositeBuffer, y);
+      let dst = getBufferRow(compositeBuffer, y);
       dst.length = compositeBuffer.cols;
       for (let x = 0; x < compositeBuffer.cols; x++)
         dst[x] = blank;
-      for (const plane of planes) {
-        const state = planeStates.get(plane);
+      for (let plane of planes) {
+        let state = planeStates.get(plane);
         if (!state)
           continue;
-        const src = getBufferRow(state.buffer, y);
-        const coverage = state.coverage[y];
-        if (!coverage)
-          continue;
-        for (let x = 0; x < compositeBuffer.cols; x++) {
-          if (coverage[x])
-            dst[x] = src[x];
-        }
+        let src = getBufferRow(state.buffer, y), coverage = state.coverage[y];
+        if (coverage)
+          for (let x = 0; x < compositeBuffer.cols; x++)
+            coverage[x] && (dst[x] = src[x]);
       }
-      const cols = compositeBuffer.cols;
+      let cols = compositeBuffer.cols;
       for (let x = 0; x < cols; x++) {
-        const cell = dst[x];
-        if (cell.width === 2 && !cell.continuation) {
-          if (x + 1 >= cols || !dst[x + 1].continuation) {
-            dst[x] = blank;
-          }
-        } else if (cell.continuation) {
-          if (x === 0 || dst[x - 1].width !== 2 || dst[x - 1].continuation) {
-            dst[x] = blank;
-          }
-        }
+        let cell = dst[x];
+        cell.width === 2 && !cell.continuation ? (x + 1 >= cols || !dst[x + 1].continuation) && (dst[x] = blank) : cell.continuation && (x === 0 || dst[x - 1].width !== 2 || dst[x - 1].continuation) && (dst[x] = blank);
       }
       if (fpFn && fpArr) {
-        const physY = (compositeBuffer.gridStart + y) % compositeBuffer.rows;
-        const base2 = physY * cols;
+        let base2 = (compositeBuffer.gridStart + y) % compositeBuffer.rows * cols;
         for (let x = 0; x < cols; x++) {
-          const cell = dst[x];
+          let cell = dst[x];
           fpArr[base2 + x] = fpFn(cell.ch, cell.style);
         }
       }
@@ -2332,166 +1941,121 @@ function createTerminal(opts) {
     }
   }
   function syncCompositeCursor() {
-    const prevVisible = compositeBuffer.cursorVisible;
-    const prevY = compositeBuffer.cursorY;
-    let nextPlane = null;
-    for (const plane of ["overlay", "chrome", "transcript", "default"]) {
-      const state = planeStates.get(plane);
+    let prevVisible = compositeBuffer.cursorVisible, prevY = compositeBuffer.cursorY, nextPlane = null;
+    for (let plane of ["overlay", "chrome", "transcript", "default"]) {
+      let state = planeStates.get(plane);
       if (state?.buffer.cursorVisible) {
         nextPlane = state;
         break;
       }
     }
-    compositeBuffer.cursorVisible = Boolean(nextPlane);
-    compositeBuffer.cursorX = nextPlane?.buffer.cursorX ?? 0;
-    compositeBuffer.cursorY = nextPlane?.buffer.cursorY ?? 0;
-    if (prevVisible)
-      markDirty(compositeBuffer, prevY);
-    if (compositeBuffer.cursorVisible)
-      markDirty(compositeBuffer, compositeBuffer.cursorY);
+    compositeBuffer.cursorVisible = !!nextPlane, compositeBuffer.cursorX = nextPlane?.buffer.cursorX ?? 0, compositeBuffer.cursorY = nextPlane?.buffer.cursorY ?? 0, prevVisible && markDirty(compositeBuffer, prevY), compositeBuffer.cursorVisible && markDirty(compositeBuffer, compositeBuffer.cursorY);
   }
   function syncCompositeForRead(planes) {
-    const planesToCompose = planes?.length ? planes : TERMINAL_RENDER_PLANES;
-    let composeAllRows = false;
-    const dirtyRows = /* @__PURE__ */ new Set();
-    for (const plane of planesToCompose) {
-      const state = planeStates.get(plane);
+    let planesToCompose = planes?.length ? planes : TERMINAL_RENDER_PLANES, composeAllRows = !1, dirtyRows = /* @__PURE__ */ new Set();
+    for (let plane of planesToCompose) {
+      let state = planeStates.get(plane);
       if (!state)
         continue;
-      const rows = peekDirtyRows(state.buffer);
+      let rows = peekDirtyRows(state.buffer);
       if (rows === null) {
-        composeAllRows = true;
+        composeAllRows = !0;
         break;
       }
-      for (const y of rows)
+      for (let y of rows)
         dirtyRows.add(y);
     }
-    if (composeAllRows || dirtyRows.size > 0)
-      composeRows(
-        composeAllRows ? null : Array.from(dirtyRows).sort((a, b) => a - b),
-        planesToCompose
-      );
-    syncCompositeCursor();
+    (composeAllRows || dirtyRows.size > 0) && composeRows(
+      composeAllRows ? null : Array.from(dirtyRows).sort((a, b) => a - b),
+      planesToCompose
+    ), syncCompositeCursor();
   }
   function readRowForPlanes(y, planes) {
-    assertNotDisposed();
-    if (y < 0 || y >= compositeBuffer.rows)
+    if (assertNotDisposed(), y < 0 || y >= compositeBuffer.rows)
       throw new RangeError("Row out of bounds");
-    composeRows([y], planes?.length ? planes : TERMINAL_RENDER_PLANES);
-    return getBufferRow(compositeBuffer, y);
+    return composeRows([y], planes?.length ? planes : TERMINAL_RENDER_PLANES), getBufferRow(compositeBuffer, y);
   }
   function pendingDirtyRowsForPlanes(planes) {
-    const planesToCheck = planes?.length ? planes : TERMINAL_RENDER_PLANES;
-    let full = false;
-    const rows = /* @__PURE__ */ new Set();
-    for (const plane of planesToCheck) {
-      const state = planeStates.get(plane);
+    let planesToCheck = planes?.length ? planes : TERMINAL_RENDER_PLANES, full = !1, rows = /* @__PURE__ */ new Set();
+    for (let plane of planesToCheck) {
+      let state = planeStates.get(plane);
       if (!state)
         continue;
-      const dirty = peekDirtyRows(state.buffer);
+      let dirty = peekDirtyRows(state.buffer);
       if (dirty === null) {
-        full = true;
+        full = !0;
         break;
       }
-      for (const y of dirty)
+      for (let y of dirty)
         rows.add(y);
     }
-    if (full)
-      return null;
-    return Array.from(rows).sort((a, b) => a - b);
+    return full ? null : Array.from(rows).sort((a, b) => a - b);
   }
   function createPlaneTerminalApi(plane) {
-    const existing = planeTerminals.get(plane);
+    let existing = planeTerminals.get(plane);
     if (existing)
       return existing;
-    const api = {
+    let api = {
       resize(cols, rows) {
-        assertNotDisposed();
-        base.resize(cols, rows);
+        assertNotDisposed(), base.resize(cols, rows);
       },
       clear(x, y, w, h) {
-        assertNotDisposed();
-        clearForPlane(plane, x, y, w, h);
+        assertNotDisposed(), clearForPlane(plane, x, y, w, h);
       },
       write(text, opts2) {
         assertNotDisposed();
-        const state = getPlaneState(plane);
-        const x = opts2?.x;
-        const y = opts2?.y;
-        const style = opts2?.style;
+        let state = getPlaneState(plane), x = opts2?.x, y = opts2?.y, style = opts2?.style;
         if (x == null || y == null) {
-          const next = writeAtForPlane(
+          let next = writeAtForPlane(
             plane,
             text,
             state.buffer.cursorX,
             state.buffer.cursorY,
             style ?? state.buffer.cursorStyle
           );
-          state.buffer.cursorX = next.x;
-          state.buffer.cursorY = next.y;
-        } else {
+          state.buffer.cursorX = next.x, state.buffer.cursorY = next.y;
+        } else
           writeAtForPlane(plane, text, x, y, style);
-        }
       },
       writeAnsi(text, opts2) {
         assertNotDisposed();
-        const state = getPlaneState(plane);
-        const x = opts2?.x;
-        const y = opts2?.y;
-        const positionedWrite = x != null && y != null;
-        let cx = positionedWrite ? x : state.buffer.cursorX;
-        let cy = positionedWrite ? y : state.buffer.cursorY;
-        let style = positionedWrite ? {} : state.buffer.cursorStyle;
-        for (const seg of parseAnsiSgr(text, style)) {
-          const next = writeAtForPlane(plane, seg.text, cx, cy, seg.style);
-          cx = next.x;
-          cy = next.y;
-          style = seg.style;
-        }
-        if (!positionedWrite) {
-          state.buffer.cursorX = cx;
-          state.buffer.cursorY = cy;
-          state.buffer.cursorStyle = style;
+        let state = getPlaneState(plane), x = opts2?.x, y = opts2?.y, positionedWrite = x != null && y != null, cx = positionedWrite ? x : state.buffer.cursorX, cy = positionedWrite ? y : state.buffer.cursorY, style = positionedWrite ? {} : state.buffer.cursorStyle;
+        for (let seg of parseAnsiSgr(text, style)) {
+          let next = writeAtForPlane(plane, seg.text, cx, cy, seg.style);
+          cx = next.x, cy = next.y, style = seg.style;
         }
+        positionedWrite || (state.buffer.cursorX = cx, state.buffer.cursorY = cy, state.buffer.cursorStyle = style);
       },
       put(x, y, ch, style) {
-        assertNotDisposed();
-        putForPlane(plane, x, y, ch, style);
+        assertNotDisposed(), putForPlane(plane, x, y, ch, style);
       },
       fill(x, y, w, h, ch, style) {
-        assertNotDisposed();
-        fillForPlane(plane, x, y, w, h, ch, style);
+        assertNotDisposed(), fillForPlane(plane, x, y, w, h, ch, style);
       },
       scroll(lines) {
-        assertNotDisposed();
-        scrollForPlane(plane, lines);
+        assertNotDisposed(), scrollForPlane(plane, lines);
       },
       setCursor(x, y, visible) {
-        assertNotDisposed();
-        setCursorForPlane(plane, x, y, visible);
+        assertNotDisposed(), setCursorForPlane(plane, x, y, visible);
       },
       batch(fn) {
-        assertNotDisposed();
-        return base.batch(fn);
+        return assertNotDisposed(), base.batch(fn);
       },
       commit(meta) {
-        assertNotDisposed();
-        return base.commit({ planes: meta?.planes ?? [plane], sync: meta?.sync });
+        return assertNotDisposed(), base.commit({ planes: meta?.planes ?? [plane], sync: meta?.sync });
       },
       on(event, cb) {
-        assertNotDisposed();
-        return base.on(event, cb);
+        return assertNotDisposed(), base.on(event, cb);
       },
       dispose() {
         base.dispose();
       },
       size() {
-        assertNotDisposed();
-        return base.size();
+        return assertNotDisposed(), base.size();
       },
       snapshot() {
         assertNotDisposed();
-        const state = getPlaneState(plane);
+        let state = getPlaneState(plane);
         return {
           cols: state.buffer.cols,
           rows: state.buffer.rows,
@@ -2500,188 +2064,142 @@ function createTerminal(opts) {
       },
       getCell(x, y) {
         assertNotDisposed();
-        const state = getPlaneState(plane);
+        let state = getPlaneState(plane);
         if (y < 0 || y >= state.buffer.rows || x < 0 || x >= state.buffer.cols)
           throw new RangeError("Cell out of bounds");
         return getBufferCell(state.buffer, x, y);
       },
       getRow(y) {
         assertNotDisposed();
-        const state = getPlaneState(plane);
+        let state = getPlaneState(plane);
         if (y < 0 || y >= state.buffer.rows)
           throw new RangeError("Row out of bounds");
         return getBufferRow(state.buffer, y);
       },
       setScrollbackLimit(limit) {
         assertNotDisposed();
-        const state = getPlaneState(plane);
-        state.buffer.scrollbackLimit = Math.max(0, Math.floor(limit));
-        if (state.buffer.scrollback.length > state.buffer.scrollbackLimit) {
-          state.buffer.scrollback.splice(
-            0,
-            state.buffer.scrollback.length - state.buffer.scrollbackLimit
-          );
-        }
+        let state = getPlaneState(plane);
+        state.buffer.scrollbackLimit = Math.max(0, Math.floor(limit)), state.buffer.scrollback.length > state.buffer.scrollbackLimit && state.buffer.scrollback.splice(
+          0,
+          state.buffer.scrollback.length - state.buffer.scrollbackLimit
+        );
       },
       getScrollbackLines(count) {
         assertNotDisposed();
-        const state = getPlaneState(plane);
-        const all = state.buffer.scrollback.map(
+        let all = getPlaneState(plane).buffer.scrollback.map(
           (row) => row.map((cell) => cell.continuation ? " " : cell.ch || " ").join("")
         );
-        if (count == null)
-          return all;
-        return all.slice(Math.max(0, all.length - Math.max(0, Math.floor(count))));
+        return count == null ? all : all.slice(Math.max(0, all.length - Math.max(0, Math.floor(count))));
       },
       setFingerprintFn(fn) {
         assertNotDisposed();
-        base.setFingerprintFn(fn);
+        let state = getPlaneState(plane);
+        setFingerprintFn(state.buffer, fn);
       },
       getRowFingerprints(y) {
         assertNotDisposed();
-        return base.getRowFingerprints(y);
+        let yy = Math.floor(y), state = getPlaneState(plane);
+        if (!Number.isFinite(yy) || yy < 0 || yy >= state.buffer.rows)
+          throw new RangeError("Row out of bounds");
+        return getRowFingerprints(state.buffer, yy);
       }
     };
-    planeTerminals.set(plane, api);
-    return api;
+    return api[TERMINAL_ROOT] = base, planeTerminals.set(plane, api), api;
   }
-  base = {
+  return base = {
     resize(cols, rows) {
       assertNotDisposed();
-      const prevCols = compositeBuffer.cols;
-      const prevRows = compositeBuffer.rows;
+      let prevCols = compositeBuffer.cols, prevRows = compositeBuffer.rows;
       resizeBuffer(compositeBuffer, cols, rows);
-      for (const state of planeStates.values())
+      for (let state of planeStates.values())
         resizePlaneState(state, cols, rows);
-      if (compositeBuffer.cols !== prevCols || compositeBuffer.rows !== prevRows)
-        emitter.emit("resize", { cols: compositeBuffer.cols, rows: compositeBuffer.rows });
+      (compositeBuffer.cols !== prevCols || compositeBuffer.rows !== prevRows) && emitter.emit("resize", { cols: compositeBuffer.cols, rows: compositeBuffer.rows });
     },
     clear(x, y, w, h) {
-      assertNotDisposed();
-      clearForPlane("default", x, y, w, h);
+      assertNotDisposed(), clearForPlane("default", x, y, w, h);
     },
     write(text, opts2) {
-      assertNotDisposed();
-      createPlaneTerminalApi("default").write(text, opts2);
+      assertNotDisposed(), createPlaneTerminalApi("default").write(text, opts2);
     },
     writeAnsi(text, opts2) {
-      assertNotDisposed();
-      createPlaneTerminalApi("default").writeAnsi(text, opts2);
+      assertNotDisposed(), createPlaneTerminalApi("default").writeAnsi(text, opts2);
     },
     put(x, y, ch, style) {
-      assertNotDisposed();
-      putForPlane("default", x, y, ch, style);
+      assertNotDisposed(), putForPlane("default", x, y, ch, style);
     },
     fill(x, y, w, h, ch, style) {
-      assertNotDisposed();
-      fillForPlane("default", x, y, w, h, ch, style);
+      assertNotDisposed(), fillForPlane("default", x, y, w, h, ch, style);
     },
     scroll(lines) {
-      assertNotDisposed();
-      scrollForPlane("default", lines);
+      assertNotDisposed(), scrollForPlane("default", lines);
     },
-    setCursor(x, y, visible = true) {
-      assertNotDisposed();
-      setCursorForPlane("default", x, y, visible);
+    setCursor(x, y, visible = !0) {
+      assertNotDisposed(), setCursorForPlane("default", x, y, visible);
     },
     batch(fn) {
-      assertNotDisposed();
-      batchingDepth++;
+      assertNotDisposed(), batchingDepth++;
       try {
         return fn();
       } finally {
-        batchingDepth--;
-        if (batchingDepth === 0 && pendingCommit) {
-          pendingCommit = false;
-          const planes = pendingCommitAllPlanes ? null : pendingCommitPlanes;
-          pendingCommitAllPlanes = false;
-          pendingCommitPlanes = null;
-          base.commit({ planes });
+        if (batchingDepth--, batchingDepth === 0 && pendingCommit) {
+          pendingCommit = !1;
+          let planes = pendingCommitAllPlanes ? null : pendingCommitPlanes;
+          pendingCommitAllPlanes = !1, pendingCommitPlanes = null, base.commit({ planes });
         }
       }
     },
     commit(meta) {
-      assertNotDisposed();
-      if (batchingDepth > 0) {
-        pendingCommit = true;
-        if (!meta?.planes?.length) {
-          pendingCommitAllPlanes = true;
-          pendingCommitPlanes = null;
-        } else if (!pendingCommitAllPlanes) {
-          pendingCommitPlanes = mergePlanes(pendingCommitPlanes, meta.planes);
-        }
-        return pendingDirtyRowsForPlanes(meta?.planes ?? null);
-      }
-      const planesToCompose = meta?.planes?.length ? meta.planes : TERMINAL_RENDER_PLANES;
-      const pendingScrollOps = takePendingScrollOps(planesToCompose);
-      const preparedScroll = prepareCompositeScrollOps(pendingScrollOps);
-      let scrollOperations = preparedScroll.scrollOperations;
-      let composeAllRows = false;
-      const dirtyRows = /* @__PURE__ */ new Set();
-      for (const plane of planesToCompose) {
-        const state = planeStates.get(plane);
+      if (assertNotDisposed(), batchingDepth > 0)
+        return pendingCommit = !0, meta?.planes?.length ? pendingCommitAllPlanes || (pendingCommitPlanes = mergePlanes(pendingCommitPlanes, meta.planes)) : (pendingCommitAllPlanes = !0, pendingCommitPlanes = null), pendingDirtyRowsForPlanes(meta?.planes ?? null);
+      let planesToCompose = meta?.planes?.length ? meta.planes : TERMINAL_RENDER_PLANES, pendingScrollOps = takePendingScrollOps(planesToCompose), preparedScroll = prepareCompositeScrollOps(pendingScrollOps), scrollOperations = preparedScroll.scrollOperations, composeAllRows = !1, dirtyRows = /* @__PURE__ */ new Set();
+      for (let plane of planesToCompose) {
+        let state = planeStates.get(plane);
         if (!state)
           continue;
-        const rows = collectAndClearDirtyRows(state.buffer);
+        let rows = collectAndClearDirtyRows(state.buffer);
         if (rows === null) {
-          composeAllRows = true;
-          break;
+          composeAllRows = !0;
+          continue;
         }
-        for (const y of rows)
+        for (let y of rows)
           dirtyRows.add(y);
       }
-      for (const y of preparedScroll.extraDirtyRows)
+      for (let y of preparedScroll.extraDirtyRows)
         dirtyRows.add(y);
-      const normalizedDirtyRows = composeAllRows ? null : Array.from(dirtyRows).sort((a, b) => a - b);
-      scrollOperations = dropScrollOpsCoveredByDirtyRows(scrollOperations, normalizedDirtyRows);
-      if (scrollOperations) {
-        for (const op of scrollOperations)
+      let normalizedDirtyRows = composeAllRows ? null : Array.from(dirtyRows).sort((a, b) => a - b);
+      if (scrollOperations = dropScrollOpsCoveredByDirtyRows(scrollOperations, normalizedDirtyRows), scrollOperations)
+        for (let op of scrollOperations)
           scrollBufferRegion(compositeBuffer, op.startY, op.endY, op.delta);
-      }
       if (normalizedDirtyRows !== null && normalizedDirtyRows.length === 0) {
-        const pendingCompositeRows = collectAndClearDirtyRows(compositeBuffer);
-        if (pendingCompositeRows !== null && pendingCompositeRows.length === 0)
-          return pendingCompositeRows;
-        emitter.emit("commit", {
+        let pendingCompositeRows = collectAndClearDirtyRows(compositeBuffer);
+        return pendingCompositeRows !== null && pendingCompositeRows.length === 0 || emitter.emit("commit", {
           dirtyRows: pendingCompositeRows,
           planes: meta?.planes ?? null,
           sync: meta?.sync,
           scrollOperations
-        });
-        return pendingCompositeRows;
+        }), pendingCompositeRows;
       }
-      composeRows(normalizedDirtyRows);
-      if (normalizedDirtyRows === null)
-        markAllDirty(compositeBuffer);
-      syncCompositeCursor();
-      const committedRows = collectAndClearDirtyRows(compositeBuffer);
-      if (committedRows !== null && committedRows.length === 0)
-        return committedRows;
-      emitter.emit("commit", {
+      composeRows(normalizedDirtyRows), normalizedDirtyRows === null && markAllDirty(compositeBuffer), syncCompositeCursor();
+      let committedRows = collectAndClearDirtyRows(compositeBuffer);
+      return committedRows !== null && committedRows.length === 0 || emitter.emit("commit", {
         dirtyRows: committedRows,
         planes: meta?.planes ?? null,
         sync: meta?.sync,
         scrollOperations
-      });
-      return committedRows;
+      }), committedRows;
     },
     on(event, cb) {
-      assertNotDisposed();
-      return emitter.on(event, cb);
+      return assertNotDisposed(), emitter.on(event, cb);
     },
     dispose() {
-      disposed = true;
-      emitter.clear();
+      disposed = !0, emitter.clear();
     },
     size() {
-      assertNotDisposed();
-      return { cols: compositeBuffer.cols, rows: compositeBuffer.rows };
+      return assertNotDisposed(), { cols: compositeBuffer.cols, rows: compositeBuffer.rows };
     },
     snapshot() {
-      assertNotDisposed();
-      if (batchingDepth === 0)
-        syncCompositeForRead();
-      const source = batchingDepth > 0 ? getPlaneState("default").buffer : compositeBuffer;
+      assertNotDisposed(), batchingDepth === 0 && syncCompositeForRead();
+      let source = batchingDepth > 0 ? getPlaneState("default").buffer : compositeBuffer;
       return {
         cols: source.cols,
         rows: source.rows,
@@ -2689,176 +2207,131 @@ function createTerminal(opts) {
       };
     },
     getCell(x, y) {
-      assertNotDisposed();
-      if (batchingDepth === 0)
-        syncCompositeForRead();
-      const source = batchingDepth > 0 ? getPlaneState("default").buffer : compositeBuffer;
+      assertNotDisposed(), batchingDepth === 0 && syncCompositeForRead();
+      let source = batchingDepth > 0 ? getPlaneState("default").buffer : compositeBuffer;
       if (y < 0 || y >= source.rows || x < 0 || x >= source.cols)
         throw new RangeError("Cell out of bounds");
       return getBufferCell(source, x, y);
     },
     getRow(y) {
-      assertNotDisposed();
-      if (batchingDepth === 0)
-        syncCompositeForRead();
-      const source = batchingDepth > 0 ? getPlaneState("default").buffer : compositeBuffer;
+      assertNotDisposed(), batchingDepth === 0 && syncCompositeForRead();
+      let source = batchingDepth > 0 ? getPlaneState("default").buffer : compositeBuffer;
       if (y < 0 || y >= source.rows)
         throw new RangeError("Row out of bounds");
       return getBufferRow(source, y);
     },
     setScrollbackLimit(limit) {
       assertNotDisposed();
-      const state = getPlaneState("default");
-      state.buffer.scrollbackLimit = Math.max(0, Math.floor(limit));
-      if (state.buffer.scrollback.length > state.buffer.scrollbackLimit) {
-        state.buffer.scrollback.splice(
-          0,
-          state.buffer.scrollback.length - state.buffer.scrollbackLimit
-        );
-      }
+      let state = getPlaneState("default");
+      state.buffer.scrollbackLimit = Math.max(0, Math.floor(limit)), state.buffer.scrollback.length > state.buffer.scrollbackLimit && state.buffer.scrollback.splice(
+        0,
+        state.buffer.scrollback.length - state.buffer.scrollbackLimit
+      );
     },
     getScrollbackLines(count) {
       assertNotDisposed();
-      const state = getPlaneState("default");
-      const all = state.buffer.scrollback.map(
+      let all = getPlaneState("default").buffer.scrollback.map(
         (row) => row.map((cell) => cell.continuation ? " " : cell.ch || " ").join("")
       );
-      if (count == null)
-        return all;
-      return all.slice(Math.max(0, all.length - Math.max(0, Math.floor(count))));
+      return count == null ? all : all.slice(Math.max(0, all.length - Math.max(0, Math.floor(count))));
     },
     setFingerprintFn(fn) {
-      assertNotDisposed();
-      setFingerprintFn(compositeBuffer, fn);
+      assertNotDisposed(), setFingerprintFn(compositeBuffer, fn);
     },
     getRowFingerprints(y) {
       assertNotDisposed();
-      return getRowFingerprints(compositeBuffer, y);
+      let yy = Math.floor(y);
+      if (!Number.isFinite(yy) || yy < 0 || yy >= compositeBuffer.rows)
+        throw new RangeError("Row out of bounds");
+      return getRowFingerprints(compositeBuffer, yy);
     }
-  };
-  base[TERMINAL_PLANE_INTERNALS] = {
+  }, base[TERMINAL_PLANE_INTERNALS] = {
     getPlaneTerminal: createPlaneTerminalApi,
     readRowForPlanes,
     resetRowsForRender(plane, dirtyRows) {
-      const state = getPlaneState(plane);
-      const rows = normalizeDirtyRows(dirtyRows, state.buffer.rows);
+      let state = getPlaneState(plane), rows = normalizeDirtyRows(dirtyRows, state.buffer.rows);
       if (rows === null) {
         for (let y = 0; y < state.buffer.rows; y++)
           clearPlaneCoverageRow(state, y);
         return;
       }
-      for (const y of rows)
+      for (let y of rows)
         clearPlaneCoverageRow(state, y);
     },
     getRowCoverageKind(plane, y) {
-      const state = getPlaneState(plane);
+      let state = getPlaneState(plane);
       if (y < 0 || y >= state.coverage.length)
         return 0;
-      const row = state.coverage[y];
+      let row = state.coverage[y];
       if (!row?.length)
         return 0;
       let covered = 0;
-      for (let x = 0; x < row.length; x++) {
-        if (row[x])
-          covered++;
-      }
-      if (covered === 0)
-        return 0;
-      if (covered >= row.length)
-        return 2;
-      return 1;
+      for (let x = 0; x < row.length; x++)
+        row[x] && covered++;
+      return covered === 0 ? 0 : covered >= row.length ? 2 : 1;
     },
     scrollRows(plane, startY, endY, lines) {
       scrollRowsForPlane(plane, startY, endY, lines);
     }
-  };
-  return base;
+  }, base[TERMINAL_ROOT] = base, base;
 }
 
 // src/utils/path.ts
 function normalizeSeparators(input) {
   let out = "";
   for (let i = 0; i < input.length; i++) {
-    const ch = input[i];
+    let ch = input[i];
     out += ch === "\\" ? "/" : ch;
   }
   return out;
 }
 function isAbsolutePath(path) {
-  const p = normalizeSeparators(path);
-  if (p.startsWith("/"))
-    return true;
-  return /^[A-Z]:\//i.test(p);
+  let p = normalizeSeparators(path);
+  return p.startsWith("/") ? !0 : /^[A-Z]:\//i.test(p);
 }
 function stripTrailingSlash(path) {
-  const p = normalizeSeparators(path);
+  let p = normalizeSeparators(path);
   if (p === "/")
     return p;
   let end = p.length;
-  while (end > 0 && p.charCodeAt(end - 1) === 47)
+  for (; end > 0 && p.charCodeAt(end - 1) === 47; )
     end--;
   return end === p.length ? p : p.slice(0, end);
 }
 function joinPath(base, next) {
-  const a = normalizeSeparators(base);
-  const b = normalizeSeparators(next);
-  if (!a)
-    return b;
-  if (!b)
-    return a;
-  if (a.endsWith("/"))
-    return `${a}${b.startsWith("/") ? b.slice(1) : b}`;
-  return `${a}/${b.startsWith("/") ? b.slice(1) : b}`;
+  let a = normalizeSeparators(base), b = normalizeSeparators(next);
+  return a ? b ? a.endsWith("/") ? `${a}${b.startsWith("/") ? b.slice(1) : b}` : `${a}/${b.startsWith("/") ? b.slice(1) : b}` : a : b;
 }
 function dirname(path) {
-  const p = stripTrailingSlash(path);
-  const normalized = normalizeSeparators(p);
+  let p = stripTrailingSlash(path), normalized = normalizeSeparators(p);
   if (normalized === "/")
     return "/";
-  const drive = normalized.match(/^([A-Z]:)\//i)?.[1] ?? null;
-  const start = drive ? drive.length + 1 : 0;
-  const idx = normalized.lastIndexOf("/");
-  if (idx < start)
-    return drive ? `${drive}/` : "";
-  const out = normalized.slice(0, idx) || (drive ? `${drive}/` : "/");
-  return out;
+  let drive = normalized.match(/^([A-Z]:)\//i)?.[1] ?? null, start = drive ? drive.length + 1 : 0, idx = normalized.lastIndexOf("/");
+  return idx < start ? drive ? `${drive}/` : "" : normalized.slice(0, idx) || (drive ? `${drive}/` : "/");
 }
 function normalizePath(path) {
-  const raw = normalizeSeparators(path);
+  let raw = normalizeSeparators(path);
   if (!raw)
     return "";
-  const drive = raw.match(/^([A-Z]:)(\/|$)/i)?.[1] ?? null;
-  const rest = drive ? raw.slice(drive.length) : raw;
-  const absolute = rest.startsWith("/");
-  const parts = rest.split("/").filter(Boolean);
-  const stack = [];
-  for (const part of parts) {
-    if (part === ".")
-      continue;
-    if (part === "..") {
-      if (stack.length > 0 && stack[stack.length - 1] !== "..") {
-        stack.pop();
+  let drive = raw.match(/^([A-Z]:)(\/|$)/i)?.[1] ?? null, rest = drive ? raw.slice(drive.length) : raw, absolute = rest.startsWith("/"), parts = rest.split("/").filter(Boolean), stack = [];
+  for (let part of parts)
+    if (part !== ".") {
+      if (part === "..") {
+        if (stack.length > 0 && stack[stack.length - 1] !== "..") {
+          stack.pop();
+          continue;
+        }
+        absolute || stack.push("..");
         continue;
       }
-      if (!absolute)
-        stack.push("..");
-      continue;
+      stack.push(part);
     }
-    stack.push(part);
-  }
-  const prefix = drive ? `${drive}${absolute ? "/" : ""}` : absolute ? "/" : "";
-  const joined = stack.join("/");
-  const out = `${prefix}${joined}`;
-  return out || (absolute ? drive ? `${drive}/` : "/" : "");
+  let prefix = drive ? `${drive}${absolute ? "/" : ""}` : absolute ? "/" : "", joined = stack.join("/");
+  return `${prefix}${joined}` || (absolute ? drive ? `${drive}/` : "/" : "");
 }
 function resolvePath(baseAbs, input) {
-  const b = normalizePath(baseAbs);
-  const i = normalizePath(input);
-  if (!b)
-    return i;
-  if (isAbsolutePath(i))
-    return i;
-  return normalizePath(joinPath(b, i));
+  let b = normalizePath(baseAbs), i = normalizePath(input);
+  return !b || isAbsolutePath(i) ? i : normalizePath(joinPath(b, i));
 }
 
 // src/core/path-suggest.ts
@@ -2868,55 +2341,46 @@ function lower(s) {
 function normalizePathInputSeparators(input) {
   let out = "";
   for (let i = 0; i < input.length; i++) {
-    const ch = input[i];
-    if (ch === "\r")
-      continue;
-    out += ch === "\\" ? "/" : ch;
+    let ch = input[i];
+    ch !== "\r" && (out += ch === "\\" ? "/" : ch);
   }
   return out;
 }
 function stripCarriageReturns(input) {
   let out = "";
   for (let i = 0; i < input.length; i++) {
-    const ch = input[i];
-    if (ch !== "\r")
-      out += ch;
+    let ch = input[i];
+    ch !== "\r" && (out += ch);
   }
   return out;
 }
 function stripLeadingDotSlash(input) {
   let i = 0;
-  while (i + 1 < input.length && input.charCodeAt(i) === 46 && input.charCodeAt(i + 1) === 47) {
+  for (; i + 1 < input.length && input.charCodeAt(i) === 46 && input.charCodeAt(i + 1) === 47; )
     i += 2;
-  }
   return i === 0 ? input : input.slice(i);
 }
 function stripLeadingSlashes(input) {
   let i = 0;
-  while (i < input.length && input.charCodeAt(i) === 47)
+  for (; i < input.length && input.charCodeAt(i) === 47; )
     i++;
   return i === 0 ? input : input.slice(i);
 }
 function stripTrailingSlashes(input) {
   let end = input.length;
-  while (end > 0 && input.charCodeAt(end - 1) === 47)
+  for (; end > 0 && input.charCodeAt(end - 1) === 47; )
     end--;
   return end === input.length ? input : input.slice(0, end);
 }
 function collapseSlashes(input) {
-  let out = "";
-  let previousWasSlash = false;
+  let out = "", previousWasSlash = !1;
   for (let i = 0; i < input.length; i++) {
-    const ch = input[i];
-    const isSlash = ch === "/";
-    if (isSlash) {
-      if (!previousWasSlash)
-        out += "/";
-      previousWasSlash = true;
+    let ch = input[i];
+    if (ch === "/") {
+      previousWasSlash || (out += "/"), previousWasSlash = !0;
       continue;
     }
-    out += ch;
-    previousWasSlash = false;
+    out += ch, previousWasSlash = !1;
   }
   return out;
 }
@@ -2926,52 +2390,35 @@ function normalizeRelativePathForIgnore(input) {
   );
 }
 function fuzzyScore(name, query) {
-  const n = lower(name);
-  const q = lower(query);
+  let n = lower(name), q = lower(query);
   if (!q)
     return 0;
   if (n === q)
     return 2e3;
   if (n.startsWith(q))
     return 1500 - (n.length - q.length);
-  const idx = n.indexOf(q);
+  let idx = n.indexOf(q);
   if (idx >= 0)
     return 1200 - idx;
-  let ni = 0;
-  let qi = 0;
-  let gaps = 0;
-  let lastMatch = -1;
-  while (ni < n.length && qi < q.length) {
-    if (n[ni] === q[qi]) {
-      if (lastMatch >= 0)
-        gaps += ni - lastMatch - 1;
-      lastMatch = ni;
-      qi++;
-    }
-    ni++;
-  }
+  let ni = 0, qi = 0, gaps = 0, lastMatch = -1;
+  for (; ni < n.length && qi < q.length; )
+    n[ni] === q[qi] && (lastMatch >= 0 && (gaps += ni - lastMatch - 1), lastMatch = ni, qi++), ni++;
   if (qi !== q.length)
     return null;
-  const maxGaps = Math.max(4, q.length * 2);
-  if (gaps > maxGaps)
-    return null;
-  return 800 - gaps;
+  let maxGaps = Math.max(4, q.length * 2);
+  return gaps > maxGaps ? null : 800 - gaps;
 }
 function parsePathQuery(rawInput) {
-  const input = normalizePathInputSeparators(rawInput);
-  const lastSlash = input.lastIndexOf("/");
-  if (lastSlash < 0)
-    return { dirPrefix: "", query: input };
-  return {
+  let input = normalizePathInputSeparators(rawInput), lastSlash = input.lastIndexOf("/");
+  return lastSlash < 0 ? { dirPrefix: "", query: input } : {
     dirPrefix: input.slice(0, lastSlash + 1),
     query: input.slice(lastSlash + 1)
   };
 }
 async function suggestPaths(options) {
-  const rawWorkspace = String(options.workspaceAbs ?? "");
-  const rawInput = String(options.input ?? "");
+  let rawWorkspace = String(options.workspaceAbs ?? ""), rawInput = String(options.input ?? "");
   if (!rawWorkspace || rawWorkspace.includes("\0") || rawInput.includes("\0")) {
-    const safeWorkspaceAbs = normalizePath(rawWorkspace || ".");
+    let safeWorkspaceAbs = normalizePath(rawWorkspace || ".");
     return {
       baseDirAbs: resolvePath(safeWorkspaceAbs, "."),
       dirPrefix: "",
@@ -2979,64 +2426,31 @@ async function suggestPaths(options) {
       suggestions: []
     };
   }
-  const workspaceAbs = normalizePath(rawWorkspace);
-  const input = normalizePathInputSeparators(rawInput);
-  const parsed = parsePathQuery(input);
-  let dirPrefix = parsed.dirPrefix;
-  let query = parsed.query;
-  let baseDirAbs = resolvePath(workspaceAbs, dirPrefix || ".");
-  let maxDepth = options.maxDepth ?? 0;
-  if (!query)
-    maxDepth = 0;
-  const allowHidden = Boolean(options.showHidden);
-  const allowDir = options.mode === "directory" || options.mode === "any" || options.mode === "file";
-  const allowFile = options.mode === "file" || options.mode === "any";
-  const max = Math.max(0, Math.floor(options.max));
-  if (max <= 0) {
+  let workspaceAbs = normalizePath(rawWorkspace), input = normalizePathInputSeparators(rawInput), parsed = parsePathQuery(input), dirPrefix = parsed.dirPrefix, query = parsed.query, baseDirAbs = resolvePath(workspaceAbs, dirPrefix || "."), maxDepth = options.maxDepth ?? 0;
+  query || (maxDepth = 0);
+  let allowHidden = !!options.showHidden, allowDir = options.mode === "directory" || options.mode === "any" || options.mode === "file", allowFile = options.mode === "file" || options.mode === "any", max = Math.max(0, Math.floor(options.max));
+  if (max <= 0)
     return { baseDirAbs, dirPrefix, query, suggestions: [] };
-  }
-  const maxDepthClamped = Math.max(0, Math.floor(maxDepth || 0));
-  const keepCapacity = Math.max(500, Math.min(8e3, max * 40));
-  const maxScannedDirs = Math.max(200, Math.min(6e3, 800 + maxDepthClamped * 600));
-  const maxScannedEntries = Math.max(2e3, Math.min(8e4, max * 2e3));
-  const scored = [];
-  let scannedDirs = 0;
-  let scannedEntries = 0;
-  let scanAborted = false;
+  let maxDepthClamped = Math.max(0, Math.floor(maxDepth || 0)), keepCapacity = Math.max(500, Math.min(8e3, max * 40)), maxScannedDirs = Math.max(200, Math.min(6e3, 800 + maxDepthClamped * 600)), maxScannedEntries = Math.max(2e3, Math.min(8e4, max * 2e3)), scored = [], scannedDirs = 0, scannedEntries = 0, scanAborted = !1;
   function cmpScored(a, b) {
-    if (a.score !== b.score)
-      return b.score - a.score;
-    if (a.depth !== b.depth)
-      return a.depth - b.depth;
-    return a.name.localeCompare(b.name);
+    return a.score !== b.score ? b.score - a.score : a.depth !== b.depth ? a.depth - b.depth : a.name.localeCompare(b.name);
   }
   function pruneScored() {
-    if (scored.length <= keepCapacity)
-      return;
-    scored.sort(cmpScored);
-    scored.length = keepCapacity;
+    scored.length <= keepCapacity || (scored.sort(cmpScored), scored.length = keepCapacity);
   }
   function scoreItem(name, relPath, q) {
-    const byName = fuzzyScore(name, q);
-    const byPath = fuzzyScore(relPath, q);
-    if (byName == null && byPath == null)
-      return null;
-    if (byName != null && byPath != null)
-      return Math.max(byName + 50, byPath);
-    return byName ?? byPath;
+    let byName = fuzzyScore(name, q), byPath = fuzzyScore(relPath, q);
+    return byName == null && byPath == null ? null : byName != null && byPath != null ? Math.max(byName + 50, byPath) : byName ?? byPath;
   }
   async function searchDir(dirAbs, currentDepth, currentRelPath, preloadedEntries) {
-    if (scanAborted)
-      return;
-    if (currentDepth > maxDepth)
+    if (scanAborted || currentDepth > maxDepth)
       return;
     if (dirAbs.includes("\0")) {
-      scanAborted = true;
+      scanAborted = !0;
       return;
     }
-    scannedDirs++;
-    if (scannedDirs > maxScannedDirs) {
-      scanAborted = true;
+    if (scannedDirs++, scannedDirs > maxScannedDirs) {
+      scanAborted = !0;
       return;
     }
     let entries = [];
@@ -3045,109 +2459,84 @@ async function suggestPaths(options) {
     } catch {
       return;
     }
-    for (const e of entries) {
+    for (let e of entries) {
       if (scanAborted)
         return;
-      scannedEntries++;
-      if (scannedEntries > maxScannedEntries) {
-        scanAborted = true;
+      if (scannedEntries++, scannedEntries > maxScannedEntries) {
+        scanAborted = !0;
         return;
       }
       if (!allowHidden && !query && e.name.startsWith("."))
         continue;
-      const itemRelPath = currentRelPath ? `${currentRelPath}/${e.name}` : e.name;
-      const normalizedRelPath = normalizeRelativePathForIgnore(`${dirPrefix}${itemRelPath}`);
-      const isDir = e.kind === "directory";
-      if (options.shouldIgnore?.({ normalizedRelPath, isDir }))
-        continue;
-      if (e.kind === "directory") {
-        if (!allowDir)
-          continue;
-        const score = scoreItem(e.name, itemRelPath, query);
-        if (score != null) {
-          scored.push({
+      let itemRelPath = currentRelPath ? `${currentRelPath}/${e.name}` : e.name, normalizedRelPath = normalizeRelativePathForIgnore(`${dirPrefix}${itemRelPath}`), isDir = e.kind === "directory";
+      if (!options.shouldIgnore?.({ normalizedRelPath, isDir })) {
+        if (e.kind === "directory") {
+          if (!allowDir)
+            continue;
+          let score = scoreItem(e.name, itemRelPath, query);
+          score != null && (scored.push({
             score,
             name: e.name,
             kind: "directory",
             depth: currentDepth,
             relPath: itemRelPath
-          });
-          if (scored.length > keepCapacity * 2)
-            pruneScored();
-        }
-        await searchDir(`${dirAbs}/${e.name}`, currentDepth + 1, itemRelPath);
-        continue;
-      }
-      if (e.kind === "file") {
-        if (!allowFile)
+          }), scored.length > keepCapacity * 2 && pruneScored()), await searchDir(`${dirAbs}/${e.name}`, currentDepth + 1, itemRelPath);
           continue;
-        const score = scoreItem(e.name, itemRelPath, query);
-        if (score != null) {
-          scored.push({
+        }
+        if (e.kind === "file") {
+          if (!allowFile)
+            continue;
+          let score = scoreItem(e.name, itemRelPath, query);
+          score != null && (scored.push({
             score,
             name: e.name,
             kind: "file",
             depth: currentDepth,
             relPath: itemRelPath
-          });
-          if (scored.length > keepCapacity * 2)
-            pruneScored();
+          }), scored.length > keepCapacity * 2 && pruneScored());
         }
       }
     }
   }
-  let ok = true;
-  let baseEntries = null;
+  let ok = !0, baseEntries = null;
   try {
     baseEntries = await options.listDir(baseDirAbs);
   } catch {
-    ok = false;
+    ok = !1;
   }
   if (!ok && dirPrefix) {
-    const fallbackQuery = stripTrailingSlashes(input);
-    dirPrefix = "";
-    query = fallbackQuery;
-    baseDirAbs = workspaceAbs;
-    maxDepth = options.maxDepth ?? 0;
-    if (!query)
-      maxDepth = 0;
-    baseEntries = null;
-  }
-  await searchDir(baseDirAbs, 0, "", baseEntries ?? void 0);
-  pruneScored();
-  scored.sort(cmpScored);
-  const list = max ? scored.slice(0, max) : [];
-  const suggestions = list.map((s) => {
-    const suffix = s.kind === "directory" ? "/" : "";
-    const completion = `${dirPrefix}${s.relPath}${suffix}`;
-    const absPath = resolvePath(workspaceAbs, `${dirPrefix}${s.relPath}`);
+    let fallbackQuery = stripTrailingSlashes(input);
+    dirPrefix = "", query = fallbackQuery, baseDirAbs = workspaceAbs, maxDepth = options.maxDepth ?? 0, query || (maxDepth = 0), baseEntries = null;
+  }
+  await searchDir(baseDirAbs, 0, "", baseEntries ?? void 0), pruneScored(), scored.sort(cmpScored);
+  let suggestions = (max ? scored.slice(0, max) : []).map((s) => {
+    let suffix = s.kind === "directory" ? "/" : "", completion = `${dirPrefix}${s.relPath}${suffix}`, absPath = resolvePath(workspaceAbs, `${dirPrefix}${s.relPath}`);
     return { kind: s.kind, display: completion, completion, absPath };
   });
   return { baseDirAbs, dirPrefix, query, suggestions };
 }
 function resolveUserPath(workspaceAbs, input, options) {
-  const raw = stripCarriageReturns(input ?? "").trim();
+  let raw = stripCarriageReturns(input ?? "").trim();
   if (!raw)
     return resolvePath(normalizePath(workspaceAbs), ".");
   if (raw === "~" || raw.startsWith("~/")) {
-    const home = String(options?.homeDir ?? "").trim();
+    let home = String(options?.homeDir ?? "").trim();
     if (home) {
-      const rest = raw === "~" ? "" : raw.slice(2);
+      let rest = raw === "~" ? "" : raw.slice(2);
       return resolvePath(normalizePath(home), rest);
     }
   }
-  const normalized = normalizePathInputSeparators(raw);
-  if (isAbsolutePath(normalized))
-    return normalizePath(normalized);
-  return resolvePath(normalizePath(workspaceAbs), normalized);
+  let normalized = normalizePathInputSeparators(raw);
+  return isAbsolutePath(normalized) ? normalizePath(normalized) : resolvePath(normalizePath(workspaceAbs), normalized);
 }
 function suggestParentHint(path) {
-  const p = normalizePath(path);
-  const d = dirname(p);
+  let p = normalizePath(path), d = dirname(p);
   return d ? joinPath(d, "..") : "..";
 }
 
 // src/utils/newlines.ts
 function normalizeNewlines(text) {
-  return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+  return text.replace(/\r\n/g, `
+`).replace(/\r/g, `
+`);
 }