@oakoliver/lipgloss 1.0.0

package/dist/index.cjs

@@ -0,0 +1,2408 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+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") {
+    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 });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Black: () => Black,
+  Blue: () => Blue,
+  Bottom: () => Bottom,
+  BrightBlack: () => BrightBlack,
+  BrightBlue: () => BrightBlue,
+  BrightCyan: () => BrightCyan,
+  BrightGreen: () => BrightGreen,
+  BrightMagenta: () => BrightMagenta,
+  BrightRed: () => BrightRed,
+  BrightWhite: () => BrightWhite,
+  BrightYellow: () => BrightYellow,
+  Center: () => Center,
+  Cyan: () => Cyan,
+  Green: () => Green,
+  Left: () => Left,
+  Magenta: () => Magenta,
+  NO_COLOR: () => NO_COLOR,
+  Red: () => Red,
+  Right: () => Right,
+  SGR: () => SGR,
+  Style: () => Style,
+  Top: () => Top,
+  White: () => White,
+  Yellow: () => Yellow,
+  alpha: () => alpha,
+  ansi256ToRGB: () => ansi256ToRGB,
+  asciiBorder: () => asciiBorder,
+  bgAnsi256: () => bgAnsi256,
+  bgBasic: () => bgBasic,
+  bgColor: () => bgColor,
+  blockBorder: () => blockBorder,
+  colorToRGB: () => colorToRGB,
+  complementary: () => complementary,
+  darken: () => darken,
+  doubleBorder: () => doubleBorder,
+  fgAnsi256: () => fgAnsi256,
+  fgBasic: () => fgBasic,
+  fgColor: () => fgColor,
+  getBottomSize: () => getBottomSize,
+  getFirstRune: () => getFirstRune,
+  getLeftSize: () => getLeftSize,
+  getLines: () => getLines,
+  getRightSize: () => getRightSize,
+  getTopSize: () => getTopSize,
+  hiddenBorder: () => hiddenBorder,
+  innerHalfBlockBorder: () => innerHalfBlockBorder,
+  isDarkColor: () => isDarkColor,
+  isNoBorder: () => isNoBorder,
+  joinHorizontal: () => joinHorizontal,
+  joinVertical: () => joinVertical,
+  lightDark: () => lightDark,
+  lighten: () => lighten,
+  markdownBorder: () => markdownBorder,
+  maxRuneWidth: () => maxRuneWidth,
+  newStyle: () => newStyle,
+  noBorder: () => noBorder,
+  normalBorder: () => normalBorder,
+  outerHalfBlockBorder: () => outerHalfBlockBorder,
+  parseColor: () => parseColor,
+  parseHex: () => parseHex,
+  place: () => place,
+  placeHorizontal: () => placeHorizontal,
+  placeVertical: () => placeVertical,
+  resetHyperlink: () => resetHyperlink,
+  roundedBorder: () => roundedBorder,
+  setHyperlink: () => setHyperlink,
+  stringWidth: () => stringWidth,
+  stripAnsi: () => stripAnsi,
+  styled: () => styled,
+  thickBorder: () => thickBorder,
+  truncate: () => truncate,
+  ulAnsi256: () => ulAnsi256,
+  ulColor: () => ulColor
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/ansi.ts
+var ESC = "\x1B";
+var CSI = `${ESC}[`;
+var SGR = {
+  reset: `${CSI}0m`,
+  bold: `${CSI}1m`,
+  faint: `${CSI}2m`,
+  italic: `${CSI}3m`,
+  underline: `${CSI}4m`,
+  blink: `${CSI}5m`,
+  reverse: `${CSI}7m`,
+  strikethrough: `${CSI}9m`,
+  // Underline styles (not universally supported)
+  underlineNone: `${CSI}24m`,
+  underlineSingle: `${CSI}4m`,
+  underlineDouble: `${CSI}4:2m`,
+  underlineCurly: `${CSI}4:3m`,
+  underlineDotted: `${CSI}4:4m`,
+  underlineDashed: `${CSI}4:5m`,
+  // Reset specific attributes
+  resetBold: `${CSI}22m`,
+  resetItalic: `${CSI}23m`,
+  resetUnderline: `${CSI}24m`,
+  resetBlink: `${CSI}25m`,
+  resetReverse: `${CSI}27m`,
+  resetStrikethrough: `${CSI}29m`
+};
+function fgColor(r, g, b) {
+  return `${CSI}38;2;${r};${g};${b}m`;
+}
+function fgAnsi256(n) {
+  return `${CSI}38;5;${n}m`;
+}
+function fgBasic(n) {
+  if (n < 8) return `${CSI}${30 + n}m`;
+  return `${CSI}${90 + (n - 8)}m`;
+}
+function bgColor(r, g, b) {
+  return `${CSI}48;2;${r};${g};${b}m`;
+}
+function bgAnsi256(n) {
+  return `${CSI}48;5;${n}m`;
+}
+function bgBasic(n) {
+  if (n < 8) return `${CSI}${40 + n}m`;
+  return `${CSI}${100 + (n - 8)}m`;
+}
+function ulColor(r, g, b) {
+  return `${CSI}58;2;${r};${g};${b}m`;
+}
+function ulAnsi256(n) {
+  return `${CSI}58;5;${n}m`;
+}
+function setHyperlink(url, params) {
+  const p = params ? params : "";
+  return `${ESC}]8;${p};${url}${ESC}\\`;
+}
+function resetHyperlink() {
+  return `${ESC}]8;;${ESC}\\`;
+}
+var ANSI_REGEX = /[\x1b\x9b][[()#;?]*(?:[0-9]{1,4}(?:[;:][0-9]{0,4})*)?[0-9A-ORZcf-nqry=><~]|\x1b\]8;[^\x1b]*\x1b\\/g;
+function stripAnsi(str) {
+  return str.replace(ANSI_REGEX, "");
+}
+function stringWidth(str) {
+  const stripped = stripAnsi(str);
+  let width = 0;
+  for (let i = 0; i < stripped.length; i++) {
+    const code = stripped.charCodeAt(i);
+    if (code >= 768 && code <= 879) continue;
+    if (code >= 6832 && code <= 6911) continue;
+    if (code >= 7616 && code <= 7679) continue;
+    if (code >= 8400 && code <= 8447) continue;
+    if (code >= 65056 && code <= 65071) continue;
+    if (code >= 55296 && code <= 56319) {
+      const next = stripped.charCodeAt(i + 1);
+      if (next >= 56320 && next <= 57343) {
+        const cp = (code - 55296) * 1024 + (next - 56320) + 65536;
+        if (cp >= 131072 && cp <= 262143) {
+          width += 2;
+        } else {
+          width += 1;
+        }
+        i++;
+        continue;
+      }
+    }
+    if (isFullWidth(code)) {
+      width += 2;
+    } else if (code === 9) {
+      width += 4;
+    } else {
+      width += 1;
+    }
+  }
+  return width;
+}
+function isFullWidth(code) {
+  return code >= 4352 && code <= 4447 || // Hangul Jamo
+  code >= 11904 && code <= 12350 || // CJK Radicals, Kangxi, Ideographic Description
+  code >= 12352 && code <= 13247 || // Hiragana, Katakana, Bopomofo, etc.
+  code >= 13312 && code <= 19903 || // CJK Unified Ideographs Extension A
+  code >= 19968 && code <= 42191 || // CJK Unified Ideographs, Yi
+  code >= 44032 && code <= 55203 || // Hangul Syllables
+  code >= 63744 && code <= 64255 || // CJK Compatibility Ideographs
+  code >= 65072 && code <= 65135 || // CJK Compatibility Forms, Small Form Variants
+  code >= 65281 && code <= 65376 || // Fullwidth Forms
+  code >= 65504 && code <= 65510;
+}
+function truncate(str, maxWidth) {
+  if (maxWidth <= 0) return "";
+  if (stringWidth(str) <= maxWidth) return str;
+  let width = 0;
+  let result = "";
+  let inEscape = false;
+  let escapeSeq = "";
+  for (let i = 0; i < str.length; i++) {
+    const ch = str[i];
+    if (inEscape) {
+      escapeSeq += ch;
+      if (/[A-Za-z~]/.test(ch) || escapeSeq.startsWith("\x1B]") && ch === "\\" && escapeSeq[escapeSeq.length - 2] === "\x1B") {
+        result += escapeSeq;
+        inEscape = false;
+        escapeSeq = "";
+      }
+      continue;
+    }
+    if (ch === "\x1B" || ch === "\x9B") {
+      inEscape = true;
+      escapeSeq = ch;
+      continue;
+    }
+    const code = ch.charCodeAt(0);
+    const charWidth = isFullWidth(code) ? 2 : 1;
+    if (width + charWidth > maxWidth) break;
+    width += charWidth;
+    result += ch;
+  }
+  return result;
+}
+function styled(str, opts) {
+  let prefix = "";
+  let suffix = "";
+  if (opts.bold) {
+    prefix += SGR.bold;
+  }
+  if (opts.faint) {
+    prefix += SGR.faint;
+  }
+  if (opts.italic) {
+    prefix += SGR.italic;
+  }
+  if (opts.underline || opts.underlineStyle && opts.underlineStyle !== "none") {
+    const style = opts.underlineStyle || "single";
+    switch (style) {
+      case "single":
+        prefix += SGR.underlineSingle;
+        break;
+      case "double":
+        prefix += SGR.underlineDouble;
+        break;
+      case "curly":
+        prefix += SGR.underlineCurly;
+        break;
+      case "dotted":
+        prefix += SGR.underlineDotted;
+        break;
+      case "dashed":
+        prefix += SGR.underlineDashed;
+        break;
+    }
+  }
+  if (opts.blink) {
+    prefix += SGR.blink;
+  }
+  if (opts.reverse) {
+    prefix += SGR.reverse;
+  }
+  if (opts.strikethrough) {
+    prefix += SGR.strikethrough;
+  }
+  if (opts.fg) {
+    prefix += colorToFg(opts.fg);
+  }
+  if (opts.bg) {
+    prefix += colorToBg(opts.bg);
+  }
+  if (opts.ul) {
+    prefix += colorToUl(opts.ul);
+  }
+  if (prefix) {
+    suffix = SGR.reset;
+  }
+  return prefix + str + suffix;
+}
+function colorToFg(c) {
+  switch (c.type) {
+    case "basic":
+      return fgBasic(c.value);
+    case "ansi256":
+      return fgAnsi256(c.value);
+    case "rgb":
+      return fgColor(c.r, c.g, c.b);
+  }
+}
+function colorToBg(c) {
+  switch (c.type) {
+    case "basic":
+      return bgBasic(c.value);
+    case "ansi256":
+      return bgAnsi256(c.value);
+    case "rgb":
+      return bgColor(c.r, c.g, c.b);
+  }
+}
+function colorToUl(c) {
+  switch (c.type) {
+    case "basic":
+      return ulAnsi256(c.value);
+    // underline color uses 256 encoding for basic too
+    case "ansi256":
+      return ulAnsi256(c.value);
+    case "rgb":
+      return ulColor(c.r, c.g, c.b);
+  }
+}
+
+// src/color.ts
+var NO_COLOR = /* @__PURE__ */ Symbol("NoColor");
+var Black = 0;
+var Red = 1;
+var Green = 2;
+var Yellow = 3;
+var Blue = 4;
+var Magenta = 5;
+var Cyan = 6;
+var White = 7;
+var BrightBlack = 8;
+var BrightRed = 9;
+var BrightGreen = 10;
+var BrightYellow = 11;
+var BrightBlue = 12;
+var BrightMagenta = 13;
+var BrightCyan = 14;
+var BrightWhite = 15;
+function parseColor(c) {
+  if (c === null || c === void 0 || c === NO_COLOR) return null;
+  if (typeof c === "number") {
+    if (c < 0) c = -c;
+    if (c < 16) return { type: "basic", value: c };
+    if (c < 256) return { type: "ansi256", value: c };
+    return {
+      type: "rgb",
+      value: 0,
+      r: c >> 16 & 255,
+      g: c >> 8 & 255,
+      b: c & 255
+    };
+  }
+  if (typeof c === "string") {
+    if (c.startsWith("#")) {
+      const rgb = parseHex(c);
+      if (!rgb) return null;
+      return { type: "rgb", value: 0, ...rgb };
+    }
+    const n = parseInt(c, 10);
+    if (!isNaN(n)) {
+      return parseColor(n);
+    }
+    return null;
+  }
+  if (typeof c === "object" && "r" in c && "g" in c && "b" in c) {
+    return { type: "rgb", value: 0, r: c.r, g: c.g, b: c.b };
+  }
+  return null;
+}
+function parseHex(hex) {
+  if (!hex.startsWith("#")) return null;
+  if (hex.length === 7) {
+    const r = parseInt(hex.slice(1, 3), 16);
+    const g = parseInt(hex.slice(3, 5), 16);
+    const b = parseInt(hex.slice(5, 7), 16);
+    if (isNaN(r) || isNaN(g) || isNaN(b)) return null;
+    return { r, g, b };
+  }
+  if (hex.length === 4) {
+    const r = parseInt(hex[1], 16) * 17;
+    const g = parseInt(hex[2], 16) * 17;
+    const b = parseInt(hex[3], 16) * 17;
+    if (isNaN(r) || isNaN(g) || isNaN(b)) return null;
+    return { r, g, b };
+  }
+  return null;
+}
+function colorToRGB(c) {
+  const cv = parseColor(c);
+  if (!cv) return null;
+  if (cv.type === "rgb") return { r: cv.r, g: cv.g, b: cv.b };
+  if (cv.type === "ansi256") return ansi256ToRGB(cv.value);
+  if (cv.type === "basic") return ansi256ToRGB(cv.value);
+  return null;
+}
+var ANSI_16_COLORS = [
+  { r: 0, g: 0, b: 0 },
+  // Black
+  { r: 170, g: 0, b: 0 },
+  // Red
+  { r: 0, g: 170, b: 0 },
+  // Green
+  { r: 170, g: 85, b: 0 },
+  // Yellow
+  { r: 0, g: 0, b: 170 },
+  // Blue
+  { r: 170, g: 0, b: 170 },
+  // Magenta
+  { r: 0, g: 170, b: 170 },
+  // Cyan
+  { r: 170, g: 170, b: 170 },
+  // White
+  { r: 85, g: 85, b: 85 },
+  // Bright Black
+  { r: 255, g: 85, b: 85 },
+  // Bright Red
+  { r: 85, g: 255, b: 85 },
+  // Bright Green
+  { r: 255, g: 255, b: 85 },
+  // Bright Yellow
+  { r: 85, g: 85, b: 255 },
+  // Bright Blue
+  { r: 255, g: 85, b: 255 },
+  // Bright Magenta
+  { r: 85, g: 255, b: 255 },
+  // Bright Cyan
+  { r: 255, g: 255, b: 255 }
+  // Bright White
+];
+function ansi256ToRGB(index) {
+  if (index < 16) return ANSI_16_COLORS[index];
+  if (index < 232) {
+    const i = index - 16;
+    const r = Math.floor(i / 36);
+    const g = Math.floor(i % 36 / 6);
+    const b = i % 6;
+    return {
+      r: r ? r * 40 + 55 : 0,
+      g: g ? g * 40 + 55 : 0,
+      b: b ? b * 40 + 55 : 0
+    };
+  }
+  const v = (index - 232) * 10 + 8;
+  return { r: v, g: v, b: v };
+}
+function isDarkColor(c) {
+  const rgb = colorToRGB(c);
+  if (!rgb) return true;
+  const max = Math.max(rgb.r, rgb.g, rgb.b) / 255;
+  const min = Math.min(rgb.r, rgb.g, rgb.b) / 255;
+  const l = (max + min) / 2;
+  return l < 0.5;
+}
+function lightDark(isDark) {
+  return (light, dark) => isDark ? dark : light;
+}
+function complementary(c) {
+  const rgb = colorToRGB(c);
+  if (!rgb) return null;
+  const { h, s, v } = rgbToHsv(rgb.r, rgb.g, rgb.b);
+  const newH = (h + 180) % 360;
+  const result = hsvToRgb(newH, s, v);
+  return result;
+}
+function darken(c, percent) {
+  const rgb = colorToRGB(c);
+  if (!rgb) return null;
+  const mult = 1 - clamp(percent, 0, 1);
+  return {
+    r: Math.round(rgb.r * mult),
+    g: Math.round(rgb.g * mult),
+    b: Math.round(rgb.b * mult)
+  };
+}
+function lighten(c, percent) {
+  const rgb = colorToRGB(c);
+  if (!rgb) return null;
+  const add = 255 * clamp(percent, 0, 1);
+  return {
+    r: Math.min(255, Math.round(rgb.r + add)),
+    g: Math.min(255, Math.round(rgb.g + add)),
+    b: Math.min(255, Math.round(rgb.b + add))
+  };
+}
+function alpha(c, a) {
+  const rgb = colorToRGB(c);
+  if (!rgb) return null;
+  const al = clamp(a, 0, 1);
+  return {
+    r: Math.round(rgb.r * al),
+    g: Math.round(rgb.g * al),
+    b: Math.round(rgb.b * al)
+  };
+}
+function clamp(v, lo, hi) {
+  return Math.min(hi, Math.max(lo, v));
+}
+function rgbToHsv(r, g, b) {
+  r /= 255;
+  g /= 255;
+  b /= 255;
+  const max = Math.max(r, g, b);
+  const min = Math.min(r, g, b);
+  const d = max - min;
+  let h = 0;
+  const s = max === 0 ? 0 : d / max;
+  const v = max;
+  if (d !== 0) {
+    if (max === r) h = ((g - b) / d + (g < b ? 6 : 0)) / 6;
+    else if (max === g) h = ((b - r) / d + 2) / 6;
+    else h = ((r - g) / d + 4) / 6;
+  }
+  return { h: h * 360, s, v };
+}
+function hsvToRgb(h, s, v) {
+  h = (h % 360 + 360) % 360;
+  const c = v * s;
+  const x = c * (1 - Math.abs(h / 60 % 2 - 1));
+  const m = v - c;
+  let r = 0, g = 0, b = 0;
+  if (h < 60) {
+    r = c;
+    g = x;
+  } else if (h < 120) {
+    r = x;
+    g = c;
+  } else if (h < 180) {
+    g = c;
+    b = x;
+  } else if (h < 240) {
+    g = x;
+    b = c;
+  } else if (h < 300) {
+    r = x;
+    b = c;
+  } else {
+    r = c;
+    b = x;
+  }
+  return {
+    r: Math.round((r + m) * 255),
+    g: Math.round((g + m) * 255),
+    b: Math.round((b + m) * 255)
+  };
+}
+
+// src/border.ts
+function border(b) {
+  return {
+    top: "",
+    bottom: "",
+    left: "",
+    right: "",
+    topLeft: "",
+    topRight: "",
+    bottomLeft: "",
+    bottomRight: "",
+    middleLeft: "",
+    middleRight: "",
+    middle: "",
+    middleTop: "",
+    middleBottom: "",
+    ...b
+  };
+}
+var noBorder = border({});
+function normalBorder() {
+  return border({
+    top: "\u2500",
+    bottom: "\u2500",
+    left: "\u2502",
+    right: "\u2502",
+    topLeft: "\u250C",
+    topRight: "\u2510",
+    bottomLeft: "\u2514",
+    bottomRight: "\u2518",
+    middleLeft: "\u251C",
+    middleRight: "\u2524",
+    middle: "\u253C",
+    middleTop: "\u252C",
+    middleBottom: "\u2534"
+  });
+}
+function roundedBorder() {
+  return border({
+    top: "\u2500",
+    bottom: "\u2500",
+    left: "\u2502",
+    right: "\u2502",
+    topLeft: "\u256D",
+    topRight: "\u256E",
+    bottomLeft: "\u2570",
+    bottomRight: "\u256F",
+    middleLeft: "\u251C",
+    middleRight: "\u2524",
+    middle: "\u253C",
+    middleTop: "\u252C",
+    middleBottom: "\u2534"
+  });
+}
+function blockBorder() {
+  return border({
+    top: "\u2588",
+    bottom: "\u2588",
+    left: "\u2588",
+    right: "\u2588",
+    topLeft: "\u2588",
+    topRight: "\u2588",
+    bottomLeft: "\u2588",
+    bottomRight: "\u2588",
+    middleLeft: "\u2588",
+    middleRight: "\u2588",
+    middle: "\u2588",
+    middleTop: "\u2588",
+    middleBottom: "\u2588"
+  });
+}
+function outerHalfBlockBorder() {
+  return border({
+    top: "\u2580",
+    bottom: "\u2584",
+    left: "\u258C",
+    right: "\u2590",
+    topLeft: "\u259B",
+    topRight: "\u259C",
+    bottomLeft: "\u2599",
+    bottomRight: "\u259F"
+  });
+}
+function innerHalfBlockBorder() {
+  return border({
+    top: "\u2584",
+    bottom: "\u2580",
+    left: "\u2590",
+    right: "\u258C",
+    topLeft: "\u2597",
+    topRight: "\u2596",
+    bottomLeft: "\u259D",
+    bottomRight: "\u2598"
+  });
+}
+function thickBorder() {
+  return border({
+    top: "\u2501",
+    bottom: "\u2501",
+    left: "\u2503",
+    right: "\u2503",
+    topLeft: "\u250F",
+    topRight: "\u2513",
+    bottomLeft: "\u2517",
+    bottomRight: "\u251B",
+    middleLeft: "\u2523",
+    middleRight: "\u252B",
+    middle: "\u254B",
+    middleTop: "\u2533",
+    middleBottom: "\u253B"
+  });
+}
+function doubleBorder() {
+  return border({
+    top: "\u2550",
+    bottom: "\u2550",
+    left: "\u2551",
+    right: "\u2551",
+    topLeft: "\u2554",
+    topRight: "\u2557",
+    bottomLeft: "\u255A",
+    bottomRight: "\u255D",
+    middleLeft: "\u2560",
+    middleRight: "\u2563",
+    middle: "\u256C",
+    middleTop: "\u2566",
+    middleBottom: "\u2569"
+  });
+}
+function hiddenBorder() {
+  return border({
+    top: " ",
+    bottom: " ",
+    left: " ",
+    right: " ",
+    topLeft: " ",
+    topRight: " ",
+    bottomLeft: " ",
+    bottomRight: " ",
+    middleLeft: " ",
+    middleRight: " ",
+    middle: " ",
+    middleTop: " ",
+    middleBottom: " "
+  });
+}
+function markdownBorder() {
+  return border({
+    top: "-",
+    bottom: "-",
+    left: "|",
+    right: "|",
+    topLeft: "|",
+    topRight: "|",
+    bottomLeft: "|",
+    bottomRight: "|",
+    middleLeft: "|",
+    middleRight: "|",
+    middle: "|",
+    middleTop: "|",
+    middleBottom: "|"
+  });
+}
+function asciiBorder() {
+  return border({
+    top: "-",
+    bottom: "-",
+    left: "|",
+    right: "|",
+    topLeft: "+",
+    topRight: "+",
+    bottomLeft: "+",
+    bottomRight: "+",
+    middleLeft: "+",
+    middleRight: "+",
+    middle: "+",
+    middleTop: "+",
+    middleBottom: "+"
+  });
+}
+function maxRuneWidth(str) {
+  if (!str) return 0;
+  if (str.length === 1) return stringWidth(str);
+  let width = 0;
+  for (const ch of str) {
+    width = Math.max(width, stringWidth(ch));
+  }
+  return width;
+}
+function getBorderEdgeWidth(...parts) {
+  let max = 0;
+  for (const part of parts) {
+    max = Math.max(max, maxRuneWidth(part));
+  }
+  return max;
+}
+function getTopSize(b) {
+  return getBorderEdgeWidth(b.topLeft, b.top, b.topRight);
+}
+function getRightSize(b) {
+  return getBorderEdgeWidth(b.topRight, b.right, b.bottomRight);
+}
+function getBottomSize(b) {
+  return getBorderEdgeWidth(b.bottomLeft, b.bottom, b.bottomRight);
+}
+function getLeftSize(b) {
+  return getBorderEdgeWidth(b.topLeft, b.left, b.bottomLeft);
+}
+function isNoBorder(b) {
+  return !b.top && !b.bottom && !b.left && !b.right && !b.topLeft && !b.topRight && !b.bottomLeft && !b.bottomRight;
+}
+
+// src/style.ts
+var Top = 0;
+var Bottom = 1;
+var Center = 0.5;
+var Left = 0;
+var Right = 1;
+function clampPos(p) {
+  return Math.min(1, Math.max(0, p));
+}
+function whichSidesInt(...args) {
+  switch (args.length) {
+    case 1:
+      return { top: args[0], right: args[0], bottom: args[0], left: args[0] };
+    case 2:
+      return { top: args[0], right: args[1], bottom: args[0], left: args[1] };
+    case 3:
+      return { top: args[0], right: args[1], bottom: args[2], left: args[1] };
+    case 4:
+      return { top: args[0], right: args[1], bottom: args[2], left: args[3] };
+    default:
+      return null;
+  }
+}
+function whichSidesBool(...args) {
+  switch (args.length) {
+    case 1:
+      return { top: args[0], right: args[0], bottom: args[0], left: args[0] };
+    case 2:
+      return { top: args[0], right: args[1], bottom: args[0], left: args[1] };
+    case 3:
+      return { top: args[0], right: args[1], bottom: args[2], left: args[1] };
+    case 4:
+      return { top: args[0], right: args[1], bottom: args[2], left: args[3] };
+    default:
+      return null;
+  }
+}
+function whichSidesColor(...args) {
+  switch (args.length) {
+    case 1:
+      return { top: args[0], right: args[0], bottom: args[0], left: args[0] };
+    case 2:
+      return { top: args[0], right: args[1], bottom: args[0], left: args[1] };
+    case 3:
+      return { top: args[0], right: args[1], bottom: args[2], left: args[1] };
+    case 4:
+      return { top: args[0], right: args[1], bottom: args[2], left: args[3] };
+    default:
+      return null;
+  }
+}
+function getLines(s) {
+  s = s.replace(/\t/g, "    ").replace(/\r\n/g, "\n");
+  const lines = s.split("\n");
+  let widest = 0;
+  for (const l of lines) {
+    const w = stringWidth(l);
+    if (w > widest) widest = w;
+  }
+  return { lines, widest };
+}
+function alignTextHorizontal(str, pos, width, wsStyle) {
+  const { lines, widest } = getLines(str);
+  const parts = [];
+  for (const l of lines) {
+    const lineWidth = stringWidth(l);
+    const shortAmount = Math.max(0, widest - lineWidth) + Math.max(0, width - Math.max(widest, lineWidth));
+    if (shortAmount > 0) {
+      const p = clampPos(pos);
+      if (p <= 0) {
+        parts.push(l + styledSpaces(shortAmount, wsStyle));
+      } else if (p >= 1) {
+        parts.push(styledSpaces(shortAmount, wsStyle) + l);
+      } else {
+        const leftPad = Math.floor(shortAmount * p);
+        const rightPad = shortAmount - leftPad;
+        parts.push(styledSpaces(leftPad, wsStyle) + l + styledSpaces(rightPad, wsStyle));
+      }
+    } else {
+      parts.push(l);
+    }
+  }
+  return parts.join("\n");
+}
+function alignTextVertical(str, pos, height) {
+  const strHeight = str.split("\n").length;
+  if (height <= strHeight) return str;
+  const gap = height - strHeight;
+  const p = clampPos(pos);
+  if (p <= 0) {
+    return str + "\n".repeat(gap);
+  } else if (p >= 1) {
+    return "\n".repeat(gap) + str;
+  } else {
+    const topPad = Math.round(gap * (1 - p));
+    const bottomPad = gap - topPad;
+    return "\n".repeat(topPad) + str + "\n".repeat(bottomPad);
+  }
+}
+function styledSpaces(n, wsStyle, ch = " ") {
+  if (n <= 0) return "";
+  const sp = ch.repeat(n);
+  if (wsStyle) return styled(sp, wsStyle);
+  return sp;
+}
+function padLeft(str, n, wsStyle, ch = " ") {
+  if (n <= 0) return str;
+  const sp = styledSpaces(n, wsStyle, ch);
+  return str.split("\n").map((line) => sp + line).join("\n");
+}
+function padRight(str, n, wsStyle, ch = " ") {
+  if (n <= 0) return str;
+  const sp = styledSpaces(n, wsStyle, ch);
+  return str.split("\n").map((line) => line + sp).join("\n");
+}
+function wordWrap(str, width) {
+  if (width <= 0) return str;
+  const inputLines = str.split("\n");
+  const out = [];
+  for (const line of inputLines) {
+    if (stringWidth(line) <= width) {
+      out.push(line);
+      continue;
+    }
+    const words = line.split(/(\s+)/);
+    let current = "";
+    for (const word of words) {
+      const combined = current + word;
+      if (stringWidth(combined) <= width) {
+        current = combined;
+      } else {
+        if (current) out.push(current);
+        if (stringWidth(word) > width) {
+          let rem = word;
+          while (stringWidth(rem) > width) {
+            let cut = "";
+            for (const ch of rem) {
+              if (stringWidth(cut + ch) > width) break;
+              cut += ch;
+            }
+            if (!cut) {
+              cut = rem[0];
+              rem = rem.slice(1);
+            } else {
+              rem = rem.slice(cut.length);
+            }
+            out.push(cut);
+          }
+          current = rem;
+        } else {
+          current = word;
+        }
+      }
+    }
+    if (current) out.push(current);
+  }
+  return out.join("\n");
+}
+function renderHorizontalEdge(left, middle, right, width) {
+  if (!middle) middle = " ";
+  const leftW = stringWidth(left);
+  const rightW = stringWidth(right);
+  const runes = [...middle];
+  let j = 0;
+  let result = left;
+  let i = 0;
+  const target = width - leftW - rightW;
+  while (i < target) {
+    const r = runes[j % runes.length];
+    result += r;
+    i += stringWidth(r);
+    j++;
+  }
+  result += right;
+  return result;
+}
+function getFirstRune(s) {
+  if (!s) return s;
+  return [...s][0];
+}
+var TAB_WIDTH_DEFAULT = 4;
+var Style = class _Style {
+  // Track which properties have been explicitly set
+  _set = /* @__PURE__ */ new Set();
+  // Internal string value (for SetString / toString)
+  _value = "";
+  // Boolean attrs
+  _bold = false;
+  _italic = false;
+  _strikethrough = false;
+  _reverse = false;
+  _blink = false;
+  _faint = false;
+  _underlineSpaces = false;
+  _strikethroughSpaces = false;
+  _colorWhitespace = false;
+  // Underline
+  _underlineStyle = "none";
+  // Colors
+  _fg = null;
+  _bg = null;
+  _ulColor = null;
+  // Dimensions
+  _width = 0;
+  _height = 0;
+  _maxWidth = 0;
+  _maxHeight = 0;
+  // Alignment
+  _alignH = 0;
+  _alignV = 0;
+  // Padding
+  _paddingTop = 0;
+  _paddingRight = 0;
+  _paddingBottom = 0;
+  _paddingLeft = 0;
+  // Margin
+  _marginTop = 0;
+  _marginRight = 0;
+  _marginBottom = 0;
+  _marginLeft = 0;
+  _marginBg = null;
+  // Border
+  _borderStyle = noBorder;
+  _borderTop = false;
+  _borderRight = false;
+  _borderBottom = false;
+  _borderLeft = false;
+  _borderTopFg = null;
+  _borderRightFg = null;
+  _borderBottomFg = null;
+  _borderLeftFg = null;
+  _borderTopBg = null;
+  _borderRightBg = null;
+  _borderBottomBg = null;
+  _borderLeftBg = null;
+  // Other
+  _inline = false;
+  _tabWidth = TAB_WIDTH_DEFAULT;
+  _transform = null;
+  _link = "";
+  _linkParams = "";
+  _paddingChar = " ";
+  /** Clone this style into a new instance. */
+  _clone() {
+    const s = new _Style();
+    s._set = new Set(this._set);
+    s._value = this._value;
+    s._bold = this._bold;
+    s._italic = this._italic;
+    s._strikethrough = this._strikethrough;
+    s._reverse = this._reverse;
+    s._blink = this._blink;
+    s._faint = this._faint;
+    s._underlineSpaces = this._underlineSpaces;
+    s._strikethroughSpaces = this._strikethroughSpaces;
+    s._colorWhitespace = this._colorWhitespace;
+    s._underlineStyle = this._underlineStyle;
+    s._fg = this._fg;
+    s._bg = this._bg;
+    s._ulColor = this._ulColor;
+    s._width = this._width;
+    s._height = this._height;
+    s._maxWidth = this._maxWidth;
+    s._maxHeight = this._maxHeight;
+    s._alignH = this._alignH;
+    s._alignV = this._alignV;
+    s._paddingTop = this._paddingTop;
+    s._paddingRight = this._paddingRight;
+    s._paddingBottom = this._paddingBottom;
+    s._paddingLeft = this._paddingLeft;
+    s._marginTop = this._marginTop;
+    s._marginRight = this._marginRight;
+    s._marginBottom = this._marginBottom;
+    s._marginLeft = this._marginLeft;
+    s._marginBg = this._marginBg;
+    s._borderStyle = this._borderStyle;
+    s._borderTop = this._borderTop;
+    s._borderRight = this._borderRight;
+    s._borderBottom = this._borderBottom;
+    s._borderLeft = this._borderLeft;
+    s._borderTopFg = this._borderTopFg;
+    s._borderRightFg = this._borderRightFg;
+    s._borderBottomFg = this._borderBottomFg;
+    s._borderLeftFg = this._borderLeftFg;
+    s._borderTopBg = this._borderTopBg;
+    s._borderRightBg = this._borderRightBg;
+    s._borderBottomBg = this._borderBottomBg;
+    s._borderLeftBg = this._borderLeftBg;
+    s._inline = this._inline;
+    s._tabWidth = this._tabWidth;
+    s._transform = this._transform;
+    s._link = this._link;
+    s._linkParams = this._linkParams;
+    s._paddingChar = this._paddingChar;
+    return s;
+  }
+  // -----------------------------------------------------------------------
+  // Setters (all return new Style)
+  // -----------------------------------------------------------------------
+  setString(...strs) {
+    const s = this._clone();
+    s._value = strs.join(" ");
+    return s;
+  }
+  bold(v) {
+    const s = this._clone();
+    s._bold = v;
+    s._set.add("bold");
+    return s;
+  }
+  italic(v) {
+    const s = this._clone();
+    s._italic = v;
+    s._set.add("italic");
+    return s;
+  }
+  strikethrough(v) {
+    const s = this._clone();
+    s._strikethrough = v;
+    s._set.add("strikethrough");
+    return s;
+  }
+  reverse(v) {
+    const s = this._clone();
+    s._reverse = v;
+    s._set.add("reverse");
+    return s;
+  }
+  blink(v) {
+    const s = this._clone();
+    s._blink = v;
+    s._set.add("blink");
+    return s;
+  }
+  faint(v) {
+    const s = this._clone();
+    s._faint = v;
+    s._set.add("faint");
+    return s;
+  }
+  underline(v) {
+    return v ? this.underlineStyle("single") : this.underlineStyle("none");
+  }
+  underlineStyle(u) {
+    const s = this._clone();
+    s._underlineStyle = u;
+    s._set.add("underline");
+    return s;
+  }
+  foreground(c) {
+    const s = this._clone();
+    s._fg = c;
+    s._set.add("fg");
+    return s;
+  }
+  background(c) {
+    const s = this._clone();
+    s._bg = c;
+    s._set.add("bg");
+    return s;
+  }
+  underlineColor(c) {
+    const s = this._clone();
+    s._ulColor = c;
+    s._set.add("ulColor");
+    return s;
+  }
+  width(n) {
+    const s = this._clone();
+    s._width = Math.max(0, n);
+    s._set.add("width");
+    return s;
+  }
+  height(n) {
+    const s = this._clone();
+    s._height = Math.max(0, n);
+    s._set.add("height");
+    return s;
+  }
+  maxWidth(n) {
+    const s = this._clone();
+    s._maxWidth = Math.max(0, n);
+    s._set.add("maxWidth");
+    return s;
+  }
+  maxHeight(n) {
+    const s = this._clone();
+    s._maxHeight = Math.max(0, n);
+    s._set.add("maxHeight");
+    return s;
+  }
+  align(...pos) {
+    let s = this._clone();
+    if (pos.length > 0) {
+      s._alignH = pos[0];
+      s._set.add("alignH");
+    }
+    if (pos.length > 1) {
+      s._alignV = pos[1];
+      s._set.add("alignV");
+    }
+    return s;
+  }
+  alignHorizontal(p) {
+    const s = this._clone();
+    s._alignH = p;
+    s._set.add("alignH");
+    return s;
+  }
+  alignVertical(p) {
+    const s = this._clone();
+    s._alignV = p;
+    s._set.add("alignV");
+    return s;
+  }
+  padding(...args) {
+    const sides = whichSidesInt(...args);
+    if (!sides) return this;
+    const s = this._clone();
+    s._paddingTop = Math.max(0, sides.top);
+    s._set.add("paddingTop");
+    s._paddingRight = Math.max(0, sides.right);
+    s._set.add("paddingRight");
+    s._paddingBottom = Math.max(0, sides.bottom);
+    s._set.add("paddingBottom");
+    s._paddingLeft = Math.max(0, sides.left);
+    s._set.add("paddingLeft");
+    return s;
+  }
+  paddingTop(n) {
+    const s = this._clone();
+    s._paddingTop = Math.max(0, n);
+    s._set.add("paddingTop");
+    return s;
+  }
+  paddingRight(n) {
+    const s = this._clone();
+    s._paddingRight = Math.max(0, n);
+    s._set.add("paddingRight");
+    return s;
+  }
+  paddingBottom(n) {
+    const s = this._clone();
+    s._paddingBottom = Math.max(0, n);
+    s._set.add("paddingBottom");
+    return s;
+  }
+  paddingLeft(n) {
+    const s = this._clone();
+    s._paddingLeft = Math.max(0, n);
+    s._set.add("paddingLeft");
+    return s;
+  }
+  margin(...args) {
+    const sides = whichSidesInt(...args);
+    if (!sides) return this;
+    const s = this._clone();
+    s._marginTop = Math.max(0, sides.top);
+    s._set.add("marginTop");
+    s._marginRight = Math.max(0, sides.right);
+    s._set.add("marginRight");
+    s._marginBottom = Math.max(0, sides.bottom);
+    s._set.add("marginBottom");
+    s._marginLeft = Math.max(0, sides.left);
+    s._set.add("marginLeft");
+    return s;
+  }
+  marginTop(n) {
+    const s = this._clone();
+    s._marginTop = Math.max(0, n);
+    s._set.add("marginTop");
+    return s;
+  }
+  marginRight(n) {
+    const s = this._clone();
+    s._marginRight = Math.max(0, n);
+    s._set.add("marginRight");
+    return s;
+  }
+  marginBottom(n) {
+    const s = this._clone();
+    s._marginBottom = Math.max(0, n);
+    s._set.add("marginBottom");
+    return s;
+  }
+  marginLeft(n) {
+    const s = this._clone();
+    s._marginLeft = Math.max(0, n);
+    s._set.add("marginLeft");
+    return s;
+  }
+  marginBackground(c) {
+    const s = this._clone();
+    s._marginBg = c;
+    s._set.add("marginBg");
+    return s;
+  }
+  border(b, ...sides) {
+    const s = this._clone();
+    s._borderStyle = b;
+    s._set.add("borderStyle");
+    const bs = whichSidesBool(...sides);
+    if (bs) {
+      s._borderTop = bs.top;
+      s._set.add("borderTop");
+      s._borderRight = bs.right;
+      s._set.add("borderRight");
+      s._borderBottom = bs.bottom;
+      s._set.add("borderBottom");
+      s._borderLeft = bs.left;
+      s._set.add("borderLeft");
+    } else {
+      s._borderTop = true;
+      s._set.add("borderTop");
+      s._borderRight = true;
+      s._set.add("borderRight");
+      s._borderBottom = true;
+      s._set.add("borderBottom");
+      s._borderLeft = true;
+      s._set.add("borderLeft");
+    }
+    return s;
+  }
+  borderStyle(b) {
+    const s = this._clone();
+    s._borderStyle = b;
+    s._set.add("borderStyle");
+    return s;
+  }
+  borderTop(v) {
+    const s = this._clone();
+    s._borderTop = v;
+    s._set.add("borderTop");
+    return s;
+  }
+  borderRight(v) {
+    const s = this._clone();
+    s._borderRight = v;
+    s._set.add("borderRight");
+    return s;
+  }
+  borderBottom(v) {
+    const s = this._clone();
+    s._borderBottom = v;
+    s._set.add("borderBottom");
+    return s;
+  }
+  borderLeft(v) {
+    const s = this._clone();
+    s._borderLeft = v;
+    s._set.add("borderLeft");
+    return s;
+  }
+  borderForeground(...colors) {
+    if (colors.length === 0) return this;
+    const sides = whichSidesColor(...colors);
+    if (!sides) return this;
+    const s = this._clone();
+    s._borderTopFg = sides.top;
+    s._set.add("borderTopFg");
+    s._borderRightFg = sides.right;
+    s._set.add("borderRightFg");
+    s._borderBottomFg = sides.bottom;
+    s._set.add("borderBottomFg");
+    s._borderLeftFg = sides.left;
+    s._set.add("borderLeftFg");
+    return s;
+  }
+  borderTopForeground(c) {
+    const s = this._clone();
+    s._borderTopFg = c;
+    s._set.add("borderTopFg");
+    return s;
+  }
+  borderRightForeground(c) {
+    const s = this._clone();
+    s._borderRightFg = c;
+    s._set.add("borderRightFg");
+    return s;
+  }
+  borderBottomForeground(c) {
+    const s = this._clone();
+    s._borderBottomFg = c;
+    s._set.add("borderBottomFg");
+    return s;
+  }
+  borderLeftForeground(c) {
+    const s = this._clone();
+    s._borderLeftFg = c;
+    s._set.add("borderLeftFg");
+    return s;
+  }
+  borderBackground(...colors) {
+    if (colors.length === 0) return this;
+    const sides = whichSidesColor(...colors);
+    if (!sides) return this;
+    const s = this._clone();
+    s._borderTopBg = sides.top;
+    s._set.add("borderTopBg");
+    s._borderRightBg = sides.right;
+    s._set.add("borderRightBg");
+    s._borderBottomBg = sides.bottom;
+    s._set.add("borderBottomBg");
+    s._borderLeftBg = sides.left;
+    s._set.add("borderLeftBg");
+    return s;
+  }
+  borderTopBackground(c) {
+    const s = this._clone();
+    s._borderTopBg = c;
+    s._set.add("borderTopBg");
+    return s;
+  }
+  borderRightBackground(c) {
+    const s = this._clone();
+    s._borderRightBg = c;
+    s._set.add("borderRightBg");
+    return s;
+  }
+  borderBottomBackground(c) {
+    const s = this._clone();
+    s._borderBottomBg = c;
+    s._set.add("borderBottomBg");
+    return s;
+  }
+  borderLeftBackground(c) {
+    const s = this._clone();
+    s._borderLeftBg = c;
+    s._set.add("borderLeftBg");
+    return s;
+  }
+  inline(v) {
+    const s = this._clone();
+    s._inline = v;
+    s._set.add("inline");
+    return s;
+  }
+  tabWidth(n) {
+    const s = this._clone();
+    s._tabWidth = n <= -1 ? -1 : n;
+    s._set.add("tabWidth");
+    return s;
+  }
+  transform(fn) {
+    const s = this._clone();
+    s._transform = fn;
+    s._set.add("transform");
+    return s;
+  }
+  hyperlink(url, params) {
+    const s = this._clone();
+    s._link = url;
+    s._set.add("link");
+    if (params !== void 0) {
+      s._linkParams = params;
+      s._set.add("linkParams");
+    }
+    return s;
+  }
+  underlineSpaces(v) {
+    const s = this._clone();
+    s._underlineSpaces = v;
+    s._set.add("underlineSpaces");
+    return s;
+  }
+  strikethroughSpaces(v) {
+    const s = this._clone();
+    s._strikethroughSpaces = v;
+    s._set.add("strikethroughSpaces");
+    return s;
+  }
+  colorWhitespace(v) {
+    const s = this._clone();
+    s._colorWhitespace = v;
+    s._set.add("colorWhitespace");
+    return s;
+  }
+  paddingChar(ch) {
+    const s = this._clone();
+    s._paddingChar = ch || " ";
+    s._set.add("paddingChar");
+    return s;
+  }
+  // -----------------------------------------------------------------------
+  // Copy — returns a full copy preserving ALL properties
+  // -----------------------------------------------------------------------
+  copy() {
+    return this._clone();
+  }
+  // -----------------------------------------------------------------------
+  // Unset methods — remove a property from the set so it reverts to default
+  // -----------------------------------------------------------------------
+  unsetBold() {
+    const s = this._clone();
+    s._set.delete("bold");
+    s._bold = false;
+    return s;
+  }
+  unsetItalic() {
+    const s = this._clone();
+    s._set.delete("italic");
+    s._italic = false;
+    return s;
+  }
+  unsetUnderline() {
+    const s = this._clone();
+    s._set.delete("underline");
+    s._underlineStyle = "none";
+    return s;
+  }
+  unsetUnderlineSpaces() {
+    const s = this._clone();
+    s._set.delete("underlineSpaces");
+    s._underlineSpaces = false;
+    return s;
+  }
+  unsetStrikethrough() {
+    const s = this._clone();
+    s._set.delete("strikethrough");
+    s._strikethrough = false;
+    return s;
+  }
+  unsetStrikethroughSpaces() {
+    const s = this._clone();
+    s._set.delete("strikethroughSpaces");
+    s._strikethroughSpaces = false;
+    return s;
+  }
+  unsetReverse() {
+    const s = this._clone();
+    s._set.delete("reverse");
+    s._reverse = false;
+    return s;
+  }
+  unsetBlink() {
+    const s = this._clone();
+    s._set.delete("blink");
+    s._blink = false;
+    return s;
+  }
+  unsetFaint() {
+    const s = this._clone();
+    s._set.delete("faint");
+    s._faint = false;
+    return s;
+  }
+  unsetInline() {
+    const s = this._clone();
+    s._set.delete("inline");
+    s._inline = false;
+    return s;
+  }
+  unsetForeground() {
+    const s = this._clone();
+    s._set.delete("fg");
+    s._fg = null;
+    return s;
+  }
+  unsetBackground() {
+    const s = this._clone();
+    s._set.delete("bg");
+    s._bg = null;
+    return s;
+  }
+  unsetUnderlineColor() {
+    const s = this._clone();
+    s._set.delete("ulColor");
+    s._ulColor = null;
+    return s;
+  }
+  unsetWidth() {
+    const s = this._clone();
+    s._set.delete("width");
+    s._width = 0;
+    return s;
+  }
+  unsetHeight() {
+    const s = this._clone();
+    s._set.delete("height");
+    s._height = 0;
+    return s;
+  }
+  unsetMaxWidth() {
+    const s = this._clone();
+    s._set.delete("maxWidth");
+    s._maxWidth = 0;
+    return s;
+  }
+  unsetMaxHeight() {
+    const s = this._clone();
+    s._set.delete("maxHeight");
+    s._maxHeight = 0;
+    return s;
+  }
+  unsetPaddingTop() {
+    const s = this._clone();
+    s._set.delete("paddingTop");
+    s._paddingTop = 0;
+    return s;
+  }
+  unsetPaddingRight() {
+    const s = this._clone();
+    s._set.delete("paddingRight");
+    s._paddingRight = 0;
+    return s;
+  }
+  unsetPaddingBottom() {
+    const s = this._clone();
+    s._set.delete("paddingBottom");
+    s._paddingBottom = 0;
+    return s;
+  }
+  unsetPaddingLeft() {
+    const s = this._clone();
+    s._set.delete("paddingLeft");
+    s._paddingLeft = 0;
+    return s;
+  }
+  unsetPaddingChar() {
+    const s = this._clone();
+    s._set.delete("paddingChar");
+    s._paddingChar = " ";
+    return s;
+  }
+  unsetMarginTop() {
+    const s = this._clone();
+    s._set.delete("marginTop");
+    s._marginTop = 0;
+    return s;
+  }
+  unsetMarginRight() {
+    const s = this._clone();
+    s._set.delete("marginRight");
+    s._marginRight = 0;
+    return s;
+  }
+  unsetMarginBottom() {
+    const s = this._clone();
+    s._set.delete("marginBottom");
+    s._marginBottom = 0;
+    return s;
+  }
+  unsetMarginLeft() {
+    const s = this._clone();
+    s._set.delete("marginLeft");
+    s._marginLeft = 0;
+    return s;
+  }
+  unsetBorderTop() {
+    const s = this._clone();
+    s._set.delete("borderTop");
+    s._borderTop = false;
+    return s;
+  }
+  unsetBorderRight() {
+    const s = this._clone();
+    s._set.delete("borderRight");
+    s._borderRight = false;
+    return s;
+  }
+  unsetBorderBottom() {
+    const s = this._clone();
+    s._set.delete("borderBottom");
+    s._borderBottom = false;
+    return s;
+  }
+  unsetBorderLeft() {
+    const s = this._clone();
+    s._set.delete("borderLeft");
+    s._borderLeft = false;
+    return s;
+  }
+  unsetBorderStyle() {
+    const s = this._clone();
+    s._set.delete("borderStyle");
+    s._borderStyle = noBorder;
+    return s;
+  }
+  unsetTabWidth() {
+    const s = this._clone();
+    s._set.delete("tabWidth");
+    s._tabWidth = TAB_WIDTH_DEFAULT;
+    return s;
+  }
+  unsetTransform() {
+    const s = this._clone();
+    s._set.delete("transform");
+    s._transform = null;
+    return s;
+  }
+  unsetHyperlink() {
+    const s = this._clone();
+    s._set.delete("link");
+    s._link = "";
+    s._set.delete("linkParams");
+    s._linkParams = "";
+    return s;
+  }
+  unsetColorWhitespace() {
+    const s = this._clone();
+    s._set.delete("colorWhitespace");
+    s._colorWhitespace = false;
+    return s;
+  }
+  // -----------------------------------------------------------------------
+  // Getters
+  // -----------------------------------------------------------------------
+  getBold() {
+    return this._set.has("bold") ? this._bold : false;
+  }
+  getItalic() {
+    return this._set.has("italic") ? this._italic : false;
+  }
+  getUnderline() {
+    return this._underlineStyle !== "none";
+  }
+  getUnderlineStyle() {
+    return this._underlineStyle;
+  }
+  getStrikethrough() {
+    return this._set.has("strikethrough") ? this._strikethrough : false;
+  }
+  getReverse() {
+    return this._set.has("reverse") ? this._reverse : false;
+  }
+  getBlink() {
+    return this._set.has("blink") ? this._blink : false;
+  }
+  getFaint() {
+    return this._set.has("faint") ? this._faint : false;
+  }
+  getForeground() {
+    return this._set.has("fg") ? this._fg : null;
+  }
+  getBackground() {
+    return this._set.has("bg") ? this._bg : null;
+  }
+  getUnderlineColor() {
+    return this._set.has("ulColor") ? this._ulColor : null;
+  }
+  getWidth() {
+    return this._set.has("width") ? this._width : 0;
+  }
+  getHeight() {
+    return this._set.has("height") ? this._height : 0;
+  }
+  getMaxWidth() {
+    return this._set.has("maxWidth") ? this._maxWidth : 0;
+  }
+  getMaxHeight() {
+    return this._set.has("maxHeight") ? this._maxHeight : 0;
+  }
+  getAlignHorizontal() {
+    return this._set.has("alignH") ? this._alignH : Left;
+  }
+  getAlignVertical() {
+    return this._set.has("alignV") ? this._alignV : Top;
+  }
+  getInline() {
+    return this._set.has("inline") ? this._inline : false;
+  }
+  getTabWidth() {
+    return this._set.has("tabWidth") ? this._tabWidth : TAB_WIDTH_DEFAULT;
+  }
+  getUnderlineSpaces() {
+    return this._set.has("underlineSpaces") ? this._underlineSpaces : false;
+  }
+  getStrikethroughSpaces() {
+    return this._set.has("strikethroughSpaces") ? this._strikethroughSpaces : false;
+  }
+  getColorWhitespace() {
+    return this._set.has("colorWhitespace") ? this._colorWhitespace : false;
+  }
+  getTransform() {
+    return this._set.has("transform") ? this._transform : null;
+  }
+  getPaddingChar() {
+    return this._set.has("paddingChar") ? this._paddingChar : " ";
+  }
+  getHyperlink() {
+    return { link: this._set.has("link") ? this._link : "", params: this._set.has("linkParams") ? this._linkParams : "" };
+  }
+  getPadding() {
+    return {
+      top: this._set.has("paddingTop") ? this._paddingTop : 0,
+      right: this._set.has("paddingRight") ? this._paddingRight : 0,
+      bottom: this._set.has("paddingBottom") ? this._paddingBottom : 0,
+      left: this._set.has("paddingLeft") ? this._paddingLeft : 0
+    };
+  }
+  getPaddingTop() {
+    return this._set.has("paddingTop") ? this._paddingTop : 0;
+  }
+  getPaddingRight() {
+    return this._set.has("paddingRight") ? this._paddingRight : 0;
+  }
+  getPaddingBottom() {
+    return this._set.has("paddingBottom") ? this._paddingBottom : 0;
+  }
+  getPaddingLeft() {
+    return this._set.has("paddingLeft") ? this._paddingLeft : 0;
+  }
+  getHorizontalPadding() {
+    return this.getPaddingLeft() + this.getPaddingRight();
+  }
+  getVerticalPadding() {
+    return this.getPaddingTop() + this.getPaddingBottom();
+  }
+  getMargin() {
+    return {
+      top: this._set.has("marginTop") ? this._marginTop : 0,
+      right: this._set.has("marginRight") ? this._marginRight : 0,
+      bottom: this._set.has("marginBottom") ? this._marginBottom : 0,
+      left: this._set.has("marginLeft") ? this._marginLeft : 0
+    };
+  }
+  getMarginTop() {
+    return this._set.has("marginTop") ? this._marginTop : 0;
+  }
+  getMarginRight() {
+    return this._set.has("marginRight") ? this._marginRight : 0;
+  }
+  getMarginBottom() {
+    return this._set.has("marginBottom") ? this._marginBottom : 0;
+  }
+  getMarginLeft() {
+    return this._set.has("marginLeft") ? this._marginLeft : 0;
+  }
+  getHorizontalMargins() {
+    return this.getMarginLeft() + this.getMarginRight();
+  }
+  getVerticalMargins() {
+    return this.getMarginTop() + this.getMarginBottom();
+  }
+  getBorderStyle() {
+    return this._set.has("borderStyle") ? this._borderStyle : noBorder;
+  }
+  getBorderTop() {
+    return this._set.has("borderTop") ? this._borderTop : false;
+  }
+  getBorderRight() {
+    return this._set.has("borderRight") ? this._borderRight : false;
+  }
+  getBorderBottom() {
+    return this._set.has("borderBottom") ? this._borderBottom : false;
+  }
+  getBorderLeft() {
+    return this._set.has("borderLeft") ? this._borderLeft : false;
+  }
+  /** True when border style is set but no individual side bools are set. */
+  _isBorderStyleSetWithoutSides() {
+    const b = this.getBorderStyle();
+    const anySideSet = this._set.has("borderTop") || this._set.has("borderRight") || this._set.has("borderBottom") || this._set.has("borderLeft");
+    return !isNoBorder(b) && !anySideSet;
+  }
+  getBorderTopSize() {
+    if (this._isBorderStyleSetWithoutSides()) return 1;
+    if (!this.getBorderTop()) return 0;
+    return getTopSize(this.getBorderStyle());
+  }
+  getBorderRightSize() {
+    if (this._isBorderStyleSetWithoutSides()) return 1;
+    if (!this.getBorderRight()) return 0;
+    return getRightSize(this.getBorderStyle());
+  }
+  getBorderBottomSize() {
+    if (this._isBorderStyleSetWithoutSides()) return 1;
+    if (!this.getBorderBottom()) return 0;
+    return getBottomSize(this.getBorderStyle());
+  }
+  getBorderLeftSize() {
+    if (this._isBorderStyleSetWithoutSides()) return 1;
+    if (!this.getBorderLeft()) return 0;
+    return getLeftSize(this.getBorderStyle());
+  }
+  getHorizontalBorderSize() {
+    return this.getBorderLeftSize() + this.getBorderRightSize();
+  }
+  getVerticalBorderSize() {
+    return this.getBorderTopSize() + this.getBorderBottomSize();
+  }
+  getHorizontalFrameSize() {
+    return this.getHorizontalMargins() + this.getHorizontalPadding() + this.getHorizontalBorderSize();
+  }
+  getVerticalFrameSize() {
+    return this.getVerticalMargins() + this.getVerticalPadding() + this.getVerticalBorderSize();
+  }
+  getFrameSize() {
+    return { x: this.getHorizontalFrameSize(), y: this.getVerticalFrameSize() };
+  }
+  // -----------------------------------------------------------------------
+  // Inherit
+  // -----------------------------------------------------------------------
+  /** Copy explicitly-set values from `other` that are NOT set on this style. Margins/padding are not inherited. */
+  inherit(other) {
+    const s = this._clone();
+    const skip = /* @__PURE__ */ new Set(["paddingTop", "paddingRight", "paddingBottom", "paddingLeft", "marginTop", "marginRight", "marginBottom", "marginLeft"]);
+    for (const key of other._set) {
+      if (skip.has(key)) continue;
+      if (key === "bg" && !s._set.has("marginBg") && !other._set.has("marginBg")) {
+        s._marginBg = other._bg;
+        s._set.add("marginBg");
+      }
+      if (s._set.has(key)) continue;
+      s["_" + this._keyToField(key)] = other["_" + this._keyToField(key)];
+      s._set.add(key);
+    }
+    return s;
+  }
+  _keyToField(key) {
+    const map = {
+      bold: "bold",
+      italic: "italic",
+      strikethrough: "strikethrough",
+      reverse: "reverse",
+      blink: "blink",
+      faint: "faint",
+      underlineSpaces: "underlineSpaces",
+      strikethroughSpaces: "strikethroughSpaces",
+      colorWhitespace: "colorWhitespace",
+      underline: "underlineStyle",
+      fg: "fg",
+      bg: "bg",
+      ulColor: "ulColor",
+      width: "width",
+      height: "height",
+      maxWidth: "maxWidth",
+      maxHeight: "maxHeight",
+      alignH: "alignH",
+      alignV: "alignV",
+      paddingTop: "paddingTop",
+      paddingRight: "paddingRight",
+      paddingBottom: "paddingBottom",
+      paddingLeft: "paddingLeft",
+      marginTop: "marginTop",
+      marginRight: "marginRight",
+      marginBottom: "marginBottom",
+      marginLeft: "marginLeft",
+      marginBg: "marginBg",
+      borderStyle: "borderStyle",
+      borderTop: "borderTop",
+      borderRight: "borderRight",
+      borderBottom: "borderBottom",
+      borderLeft: "borderLeft",
+      borderTopFg: "borderTopFg",
+      borderRightFg: "borderRightFg",
+      borderBottomFg: "borderBottomFg",
+      borderLeftFg: "borderLeftFg",
+      borderTopBg: "borderTopBg",
+      borderRightBg: "borderRightBg",
+      borderBottomBg: "borderBottomBg",
+      borderLeftBg: "borderLeftBg",
+      inline: "inline",
+      tabWidth: "tabWidth",
+      transform: "transform",
+      link: "link",
+      linkParams: "linkParams",
+      paddingChar: "paddingChar"
+    };
+    return map[key] || key;
+  }
+  // -----------------------------------------------------------------------
+  // Render
+  // -----------------------------------------------------------------------
+  /** Render the style applied to the given strings (joined with space). */
+  render(...strs) {
+    if (this._value) strs = [this._value, ...strs];
+    let str = strs.join(" ");
+    const hasUnderline = this._underlineStyle !== "none";
+    const isBold = this._set.has("bold") && this._bold;
+    const isItalic = this._set.has("italic") && this._italic;
+    const isStrikethrough = this._set.has("strikethrough") && this._strikethrough;
+    const isReverse = this._set.has("reverse") && this._reverse;
+    const isBlink = this._set.has("blink") && this._blink;
+    const isFaint = this._set.has("faint") && this._faint;
+    const fg = this._set.has("fg") ? parseColor(this._fg) : null;
+    const bg = this._set.has("bg") ? parseColor(this._bg) : null;
+    const ul = this._set.has("ulColor") ? parseColor(this._ulColor) : null;
+    const w = this._set.has("width") ? this._width : 0;
+    const h = this._set.has("height") ? this._height : 0;
+    const hAlign = this._set.has("alignH") ? this._alignH : Left;
+    const vAlign = this._set.has("alignV") ? this._alignV : Top;
+    const topPad = this._set.has("paddingTop") ? this._paddingTop : 0;
+    const rightPad = this._set.has("paddingRight") ? this._paddingRight : 0;
+    const bottomPad = this._set.has("paddingBottom") ? this._paddingBottom : 0;
+    const leftPad = this._set.has("paddingLeft") ? this._paddingLeft : 0;
+    const hBorderSize = this.getHorizontalBorderSize();
+    const vBorderSize = this.getVerticalBorderSize();
+    const colorWS = this._set.has("colorWhitespace") ? this._colorWhitespace : true;
+    const isInline = this._set.has("inline") ? this._inline : false;
+    const mw = this._set.has("maxWidth") ? this._maxWidth : 0;
+    const mh = this._set.has("maxHeight") ? this._maxHeight : 0;
+    const ulSpaces = this._set.has("underlineSpaces") && this._underlineSpaces || hasUnderline && (!this._set.has("underlineSpaces") || this._underlineSpaces);
+    const stSpaces = this._set.has("strikethroughSpaces") && this._strikethroughSpaces || isStrikethrough && (!this._set.has("strikethroughSpaces") || this._strikethroughSpaces);
+    const styleWhitespace = isReverse;
+    const useSpaceStyler = hasUnderline && !ulSpaces || isStrikethrough && !stSpaces || ulSpaces || stSpaces;
+    const transform = this._set.has("transform") ? this._transform : null;
+    const link = this._set.has("link") ? this._link : "";
+    const linkParams = this._set.has("linkParams") ? this._linkParams : "";
+    if (transform) str = transform(str);
+    if (this._set.size === 0) return this._maybeConvertTabs(str);
+    const teOpts = {};
+    const teSpaceOpts = {};
+    const teWSOpts = {};
+    if (isBold) teOpts.bold = true;
+    if (isItalic) teOpts.italic = true;
+    if (hasUnderline) {
+      teOpts.underline = true;
+      teOpts.underlineStyle = this._underlineStyle;
+    }
+    if (isReverse) {
+      teOpts.reverse = true;
+      teWSOpts.reverse = true;
+    }
+    if (isBlink) teOpts.blink = true;
+    if (isFaint) teOpts.faint = true;
+    if (isStrikethrough) teOpts.strikethrough = true;
+    if (fg) {
+      teOpts.fg = fg;
+      if (styleWhitespace) teWSOpts.fg = fg;
+      if (useSpaceStyler) teSpaceOpts.fg = fg;
+    }
+    if (bg) {
+      teOpts.bg = bg;
+      if (colorWS) teWSOpts.bg = bg;
+      if (useSpaceStyler) teSpaceOpts.bg = bg;
+    }
+    if (ul) {
+      teOpts.ul = ul;
+      if (colorWS) teWSOpts.ul = ul;
+      if (useSpaceStyler) teSpaceOpts.ul = ul;
+    }
+    if (ulSpaces) teSpaceOpts.underline = true;
+    if (stSpaces) teSpaceOpts.strikethrough = true;
+    str = this._maybeConvertTabs(str);
+    str = str.replace(/\r\n/g, "\n");
+    if (isInline) str = str.replace(/\n/g, "");
+    let width = w - hBorderSize;
+    let height = h - vBorderSize;
+    if (!isInline && width > 0) {
+      const wrapAt = width - leftPad - rightPad;
+      str = wordWrap(str, wrapAt);
+    }
+    {
+      const lines = str.split("\n");
+      const rendered = [];
+      for (const line of lines) {
+        if (useSpaceStyler) {
+          let buf = "";
+          for (const ch of line) {
+            if (ch === " " || ch === "	") {
+              buf += styled(ch, teSpaceOpts);
+            } else {
+              buf += styled(ch, teOpts);
+            }
+          }
+          rendered.push(buf);
+        } else {
+          rendered.push(line ? styled(line, teOpts) : line);
+        }
+      }
+      str = rendered.join("\n");
+      if (link) {
+        str = setHyperlink(link, linkParams || void 0) + str + resetHyperlink();
+      }
+    }
+    if (!isInline) {
+      const wsStyle = colorWS || styleWhitespace ? teWSOpts : null;
+      const padCh = this._set.has("paddingChar") ? this._paddingChar : " ";
+      if (leftPad > 0) str = padLeft(str, leftPad, wsStyle, padCh);
+      if (rightPad > 0) str = padRight(str, rightPad, wsStyle, padCh);
+      if (topPad > 0) str = "\n".repeat(topPad) + str;
+      if (bottomPad > 0) str = str + "\n".repeat(bottomPad);
+    }
+    if (height > 0) str = alignTextVertical(str, vAlign, height);
+    {
+      const numLines = str.split("\n").length - 1;
+      if (numLines > 0 || width > 0) {
+        const wsStyle = colorWS || styleWhitespace ? teWSOpts : null;
+        str = alignTextHorizontal(str, hAlign, width, wsStyle);
+      }
+    }
+    if (!isInline) {
+      str = this._applyBorder(str);
+      str = this._applyMargins(str, isInline);
+    }
+    if (mw > 0) {
+      str = str.split("\n").map((line) => truncate(line, mw)).join("\n");
+    }
+    if (mh > 0) {
+      const lines = str.split("\n");
+      if (lines.length > mh) str = lines.slice(0, mh).join("\n");
+    }
+    return str;
+  }
+  // -----------------------------------------------------------------------
+  // Internal: tab conversion
+  // -----------------------------------------------------------------------
+  _maybeConvertTabs(str) {
+    const tw = this._set.has("tabWidth") ? this._tabWidth : TAB_WIDTH_DEFAULT;
+    if (tw === -1) return str;
+    if (tw === 0) return str.replace(/\t/g, "");
+    return str.replace(/\t/g, " ".repeat(tw));
+  }
+  // -----------------------------------------------------------------------
+  // Internal: border rendering
+  // -----------------------------------------------------------------------
+  _applyBorder(str) {
+    let borderDef = this.getBorderStyle();
+    let hasT = this.getBorderTop();
+    let hasR = this.getBorderRight();
+    let hasB = this.getBorderBottom();
+    let hasL = this.getBorderLeft();
+    if (this._isBorderStyleSetWithoutSides()) {
+      hasT = true;
+      hasR = true;
+      hasB = true;
+      hasL = true;
+    }
+    if (isNoBorder(borderDef) || !hasT && !hasR && !hasB && !hasL) return str;
+    borderDef = { ...borderDef };
+    const { lines, widest } = getLines(str);
+    let width = widest;
+    if (hasL) {
+      if (!borderDef.left) borderDef.left = " ";
+      width += maxRuneWidth(borderDef.left);
+    }
+    if (hasR) {
+      if (!borderDef.right) borderDef.right = " ";
+      width += maxRuneWidth(borderDef.right);
+    }
+    if (hasT && hasL && !borderDef.topLeft) borderDef.topLeft = " ";
+    if (hasT && hasR && !borderDef.topRight) borderDef.topRight = " ";
+    if (hasB && hasL && !borderDef.bottomLeft) borderDef.bottomLeft = " ";
+    if (hasB && hasR && !borderDef.bottomRight) borderDef.bottomRight = " ";
+    if (hasT) {
+      if (!hasL && !hasR) {
+        borderDef.topLeft = "";
+        borderDef.topRight = "";
+      } else if (!hasL) {
+        borderDef.topLeft = "";
+      } else if (!hasR) {
+        borderDef.topRight = "";
+      }
+    }
+    if (hasB) {
+      if (!hasL && !hasR) {
+        borderDef.bottomLeft = "";
+        borderDef.bottomRight = "";
+      } else if (!hasL) {
+        borderDef.bottomLeft = "";
+      } else if (!hasR) {
+        borderDef.bottomRight = "";
+      }
+    }
+    borderDef.topLeft = getFirstRune(borderDef.topLeft);
+    borderDef.topRight = getFirstRune(borderDef.topRight);
+    borderDef.bottomLeft = getFirstRune(borderDef.bottomLeft);
+    borderDef.bottomRight = getFirstRune(borderDef.bottomRight);
+    const topFg = this._set.has("borderTopFg") ? parseColor(this._borderTopFg) : null;
+    const rightFg = this._set.has("borderRightFg") ? parseColor(this._borderRightFg) : null;
+    const bottomFg = this._set.has("borderBottomFg") ? parseColor(this._borderBottomFg) : null;
+    const leftFg = this._set.has("borderLeftFg") ? parseColor(this._borderLeftFg) : null;
+    const topBg = this._set.has("borderTopBg") ? parseColor(this._borderTopBg) : null;
+    const rightBg = this._set.has("borderRightBg") ? parseColor(this._borderRightBg) : null;
+    const bottomBg = this._set.has("borderBottomBg") ? parseColor(this._borderBottomBg) : null;
+    const leftBg = this._set.has("borderLeftBg") ? parseColor(this._borderLeftBg) : null;
+    let out = "";
+    if (hasT) {
+      const top = renderHorizontalEdge(borderDef.topLeft, borderDef.top, borderDef.topRight, width);
+      out += styleBorderStr(top, topFg, topBg) + "\n";
+    }
+    const leftRunes = [...borderDef.left];
+    const rightRunes = [...borderDef.right];
+    let li = 0, ri = 0;
+    for (let i = 0; i < lines.length; i++) {
+      if (hasL) {
+        const r = leftRunes[li % leftRunes.length];
+        li++;
+        out += styleBorderStr(r, leftFg, leftBg);
+      }
+      out += lines[i];
+      if (hasR) {
+        const r = rightRunes[ri % rightRunes.length];
+        ri++;
+        out += styleBorderStr(r, rightFg, rightBg);
+      }
+      if (i < lines.length - 1) out += "\n";
+    }
+    if (hasB) {
+      const bottom = renderHorizontalEdge(borderDef.bottomLeft, borderDef.bottom, borderDef.bottomRight, width);
+      out += "\n" + styleBorderStr(bottom, bottomFg, bottomBg);
+    }
+    return out;
+  }
+  // -----------------------------------------------------------------------
+  // Internal: margin rendering
+  // -----------------------------------------------------------------------
+  _applyMargins(str, isInline) {
+    const topM = this._set.has("marginTop") ? this._marginTop : 0;
+    const rightM = this._set.has("marginRight") ? this._marginRight : 0;
+    const bottomM = this._set.has("marginBottom") ? this._marginBottom : 0;
+    const leftM = this._set.has("marginLeft") ? this._marginLeft : 0;
+    const marginBg = this._set.has("marginBg") ? parseColor(this._marginBg) : null;
+    const marginStyle = marginBg ? { bg: marginBg } : null;
+    if (leftM > 0) str = padLeft(str, leftM, marginStyle);
+    if (rightM > 0) str = padRight(str, rightM, marginStyle);
+    if (!isInline) {
+      const { widest: totalWidth } = getLines(str);
+      const blankLine = marginStyle ? styled(" ".repeat(totalWidth), marginStyle) : " ".repeat(totalWidth);
+      if (topM > 0) {
+        str = (blankLine + "\n").repeat(topM) + str;
+      }
+      if (bottomM > 0) {
+        str = str + ("\n" + blankLine).repeat(bottomM);
+      }
+    }
+    return str;
+  }
+  // -----------------------------------------------------------------------
+  // toString
+  // -----------------------------------------------------------------------
+  toString() {
+    return this.render();
+  }
+};
+function styleBorderStr(border2, fg, bg) {
+  if (!fg && !bg) return border2;
+  return styled(border2, { fg, bg });
+}
+function newStyle() {
+  return new Style();
+}
+
+// src/layout.ts
+function joinHorizontal(pos, ...strs) {
+  if (strs.length === 0) return "";
+  if (strs.length === 1) return strs[0];
+  const blocks = [];
+  const maxWidths = [];
+  let maxHeight = 0;
+  for (let i = 0; i < strs.length; i++) {
+    const { lines, widest } = getLines(strs[i]);
+    blocks.push(lines);
+    maxWidths.push(widest);
+    if (lines.length > maxHeight) maxHeight = lines.length;
+  }
+  for (let i = 0; i < blocks.length; i++) {
+    if (blocks[i].length >= maxHeight) continue;
+    const extra = maxHeight - blocks[i].length;
+    const empties = new Array(extra).fill("");
+    const p = Math.min(1, Math.max(0, pos));
+    if (p <= 0) {
+      blocks[i] = [...blocks[i], ...empties];
+    } else if (p >= 1) {
+      blocks[i] = [...empties, ...blocks[i]];
+    } else {
+      const split = Math.round(extra * p);
+      const top = extra - split;
+      const bottom = extra - top;
+      blocks[i] = [
+        ...new Array(top).fill(""),
+        ...blocks[i],
+        ...new Array(bottom).fill("")
+      ];
+    }
+  }
+  const result = [];
+  for (let row = 0; row < maxHeight; row++) {
+    let line = "";
+    for (let col = 0; col < blocks.length; col++) {
+      const cell = blocks[col][row] || "";
+      line += cell;
+      const pad = maxWidths[col] - stringWidth(cell);
+      if (pad > 0) line += " ".repeat(pad);
+    }
+    result.push(line);
+  }
+  return result.join("\n");
+}
+function joinVertical(pos, ...strs) {
+  if (strs.length === 0) return "";
+  if (strs.length === 1) return strs[0];
+  const blocks = [];
+  let maxWidth = 0;
+  for (const str of strs) {
+    const { lines, widest } = getLines(str);
+    blocks.push(lines);
+    if (widest > maxWidth) maxWidth = widest;
+  }
+  const result = [];
+  for (let i = 0; i < blocks.length; i++) {
+    for (let j = 0; j < blocks[i].length; j++) {
+      const line = blocks[i][j];
+      const gap = maxWidth - stringWidth(line);
+      if (gap <= 0) {
+        result.push(line);
+      } else {
+        const p = Math.min(1, Math.max(0, pos));
+        if (p <= 0) {
+          result.push(line + " ".repeat(gap));
+        } else if (p >= 1) {
+          result.push(" ".repeat(gap) + line);
+        } else {
+          const split = Math.round(gap * p);
+          const left = gap - split;
+          const right = gap - left;
+          result.push(" ".repeat(left) + line + " ".repeat(right));
+        }
+      }
+    }
+  }
+  return result.join("\n");
+}
+function place(width, height, hPos, vPos, str) {
+  return placeVertical(height, vPos, placeHorizontal(width, hPos, str));
+}
+function placeHorizontal(width, pos, str) {
+  const { lines, widest: contentWidth } = getLines(str);
+  const gap = width - contentWidth;
+  if (gap <= 0) return str;
+  const result = [];
+  for (const line of lines) {
+    const short = Math.max(0, contentWidth - stringWidth(line));
+    const totalGap = gap + short;
+    const p = Math.min(1, Math.max(0, pos));
+    if (p <= 0) {
+      result.push(line + " ".repeat(totalGap));
+    } else if (p >= 1) {
+      result.push(" ".repeat(totalGap) + line);
+    } else {
+      const split = Math.round(totalGap * p);
+      const left = totalGap - split;
+      const right = totalGap - left;
+      result.push(" ".repeat(left) + line + " ".repeat(right));
+    }
+  }
+  return result.join("\n");
+}
+function placeVertical(height, pos, str) {
+  const contentHeight = str.split("\n").length;
+  const gap = height - contentHeight;
+  if (gap <= 0) return str;
+  const { widest: width } = getLines(str);
+  const emptyLine = " ".repeat(width);
+  const p = Math.min(1, Math.max(0, pos));
+  if (p <= 0) {
+    const bottom = [];
+    for (let i = 0; i < gap; i++) bottom.push(emptyLine);
+    return str + "\n" + bottom.join("\n");
+  } else if (p >= 1) {
+    const top = [];
+    for (let i = 0; i < gap; i++) top.push(emptyLine);
+    return top.join("\n") + "\n" + str;
+  } else {
+    const split = Math.round(gap * p);
+    const topCount = gap - split;
+    const bottomCount = gap - topCount;
+    const topLines = [];
+    for (let i = 0; i < topCount; i++) topLines.push(emptyLine);
+    const bottomLines = [];
+    for (let i = 0; i < bottomCount; i++) bottomLines.push(emptyLine);
+    let result = "";
+    if (topLines.length > 0) result += topLines.join("\n") + "\n";
+    result += str;
+    if (bottomLines.length > 0) result += "\n" + bottomLines.join("\n");
+    return result;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Black,
+  Blue,
+  Bottom,
+  BrightBlack,
+  BrightBlue,
+  BrightCyan,
+  BrightGreen,
+  BrightMagenta,
+  BrightRed,
+  BrightWhite,
+  BrightYellow,
+  Center,
+  Cyan,
+  Green,
+  Left,
+  Magenta,
+  NO_COLOR,
+  Red,
+  Right,
+  SGR,
+  Style,
+  Top,
+  White,
+  Yellow,
+  alpha,
+  ansi256ToRGB,
+  asciiBorder,
+  bgAnsi256,
+  bgBasic,
+  bgColor,
+  blockBorder,
+  colorToRGB,
+  complementary,
+  darken,
+  doubleBorder,
+  fgAnsi256,
+  fgBasic,
+  fgColor,
+  getBottomSize,
+  getFirstRune,
+  getLeftSize,
+  getLines,
+  getRightSize,
+  getTopSize,
+  hiddenBorder,
+  innerHalfBlockBorder,
+  isDarkColor,
+  isNoBorder,
+  joinHorizontal,
+  joinVertical,
+  lightDark,
+  lighten,
+  markdownBorder,
+  maxRuneWidth,
+  newStyle,
+  noBorder,
+  normalBorder,
+  outerHalfBlockBorder,
+  parseColor,
+  parseHex,
+  place,
+  placeHorizontal,
+  placeVertical,
+  resetHyperlink,
+  roundedBorder,
+  setHyperlink,
+  stringWidth,
+  stripAnsi,
+  styled,
+  thickBorder,
+  truncate,
+  ulAnsi256,
+  ulColor
+});