ccstatusline 2.0.1 → 2.0.3

package/dist/ccstatusline.js

@@ -31861,671 +31861,2118 @@ var require_jsx_dev_runtime = __commonJS((exports, module) => {
   }
 });
 
-// node_modules/chalk/source/vendor/ansi-styles/index.js
-var ANSI_BACKGROUND_OFFSET = 10;
-var wrapAnsi16 = (offset = 0) => (code) => `\x1B[${code + offset}m`;
-var wrapAnsi256 = (offset = 0) => (code) => `\x1B[${38 + offset};5;${code}m`;
-var wrapAnsi16m = (offset = 0) => (red, green, blue) => `\x1B[${38 + offset};2;${red};${green};${blue}m`;
-var styles = {
-  modifier: {
-    reset: [0, 0],
-    bold: [1, 22],
-    dim: [2, 22],
-    italic: [3, 23],
-    underline: [4, 24],
-    overline: [53, 55],
-    inverse: [7, 27],
-    hidden: [8, 28],
-    strikethrough: [9, 29]
-  },
-  color: {
-    black: [30, 39],
-    red: [31, 39],
-    green: [32, 39],
-    yellow: [33, 39],
-    blue: [34, 39],
-    magenta: [35, 39],
-    cyan: [36, 39],
-    white: [37, 39],
-    blackBright: [90, 39],
-    gray: [90, 39],
-    grey: [90, 39],
-    redBright: [91, 39],
-    greenBright: [92, 39],
-    yellowBright: [93, 39],
-    blueBright: [94, 39],
-    magentaBright: [95, 39],
-    cyanBright: [96, 39],
-    whiteBright: [97, 39]
-  },
-  bgColor: {
-    bgBlack: [40, 49],
-    bgRed: [41, 49],
-    bgGreen: [42, 49],
-    bgYellow: [43, 49],
-    bgBlue: [44, 49],
-    bgMagenta: [45, 49],
-    bgCyan: [46, 49],
-    bgWhite: [47, 49],
-    bgBlackBright: [100, 49],
-    bgGray: [100, 49],
-    bgGrey: [100, 49],
-    bgRedBright: [101, 49],
-    bgGreenBright: [102, 49],
-    bgYellowBright: [103, 49],
-    bgBlueBright: [104, 49],
-    bgMagentaBright: [105, 49],
-    bgCyanBright: [106, 49],
-    bgWhiteBright: [107, 49]
-  }
-};
-var modifierNames = Object.keys(styles.modifier);
-var foregroundColorNames = Object.keys(styles.color);
-var backgroundColorNames = Object.keys(styles.bgColor);
-var colorNames = [...foregroundColorNames, ...backgroundColorNames];
-function assembleStyles() {
-  const codes = new Map;
-  for (const [groupName, group] of Object.entries(styles)) {
-    for (const [styleName, style] of Object.entries(group)) {
-      styles[styleName] = {
-        open: `\x1B[${style[0]}m`,
-        close: `\x1B[${style[1]}m`
+// node_modules/picomatch/lib/constants.js
+var require_constants3 = __commonJS((exports, module) => {
+  var WIN_SLASH = "\\\\/";
+  var WIN_NO_SLASH = `[^${WIN_SLASH}]`;
+  var DOT_LITERAL = "\\.";
+  var PLUS_LITERAL = "\\+";
+  var QMARK_LITERAL = "\\?";
+  var SLASH_LITERAL = "\\/";
+  var ONE_CHAR = "(?=.)";
+  var QMARK = "[^/]";
+  var END_ANCHOR = `(?:${SLASH_LITERAL}|$)`;
+  var START_ANCHOR = `(?:^|${SLASH_LITERAL})`;
+  var DOTS_SLASH = `${DOT_LITERAL}{1,2}${END_ANCHOR}`;
+  var NO_DOT = `(?!${DOT_LITERAL})`;
+  var NO_DOTS = `(?!${START_ANCHOR}${DOTS_SLASH})`;
+  var NO_DOT_SLASH = `(?!${DOT_LITERAL}{0,1}${END_ANCHOR})`;
+  var NO_DOTS_SLASH = `(?!${DOTS_SLASH})`;
+  var QMARK_NO_DOT = `[^.${SLASH_LITERAL}]`;
+  var STAR = `${QMARK}*?`;
+  var SEP2 = "/";
+  var POSIX_CHARS = {
+    DOT_LITERAL,
+    PLUS_LITERAL,
+    QMARK_LITERAL,
+    SLASH_LITERAL,
+    ONE_CHAR,
+    QMARK,
+    END_ANCHOR,
+    DOTS_SLASH,
+    NO_DOT,
+    NO_DOTS,
+    NO_DOT_SLASH,
+    NO_DOTS_SLASH,
+    QMARK_NO_DOT,
+    STAR,
+    START_ANCHOR,
+    SEP: SEP2
+  };
+  var WINDOWS_CHARS = {
+    ...POSIX_CHARS,
+    SLASH_LITERAL: `[${WIN_SLASH}]`,
+    QMARK: WIN_NO_SLASH,
+    STAR: `${WIN_NO_SLASH}*?`,
+    DOTS_SLASH: `${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$)`,
+    NO_DOT: `(?!${DOT_LITERAL})`,
+    NO_DOTS: `(?!(?:^|[${WIN_SLASH}])${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
+    NO_DOT_SLASH: `(?!${DOT_LITERAL}{0,1}(?:[${WIN_SLASH}]|$))`,
+    NO_DOTS_SLASH: `(?!${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
+    QMARK_NO_DOT: `[^.${WIN_SLASH}]`,
+    START_ANCHOR: `(?:^|[${WIN_SLASH}])`,
+    END_ANCHOR: `(?:[${WIN_SLASH}]|$)`,
+    SEP: "\\"
+  };
+  var POSIX_REGEX_SOURCE = {
+    alnum: "a-zA-Z0-9",
+    alpha: "a-zA-Z",
+    ascii: "\\x00-\\x7F",
+    blank: " \\t",
+    cntrl: "\\x00-\\x1F\\x7F",
+    digit: "0-9",
+    graph: "\\x21-\\x7E",
+    lower: "a-z",
+    print: "\\x20-\\x7E ",
+    punct: "\\-!\"#$%&'()\\*+,./:;<=>?@[\\]^_`{|}~",
+    space: " \\t\\r\\n\\v\\f",
+    upper: "A-Z",
+    word: "A-Za-z0-9_",
+    xdigit: "A-Fa-f0-9"
+  };
+  module.exports = {
+    MAX_LENGTH: 1024 * 64,
+    POSIX_REGEX_SOURCE,
+    REGEX_BACKSLASH: /\\(?![*+?^${}(|)[\]])/g,
+    REGEX_NON_SPECIAL_CHARS: /^[^@![\].,$*+?^{}()|\\/]+/,
+    REGEX_SPECIAL_CHARS: /[-*+?.^${}(|)[\]]/,
+    REGEX_SPECIAL_CHARS_BACKREF: /(\\?)((\W)(\3*))/g,
+    REGEX_SPECIAL_CHARS_GLOBAL: /([-*+?.^${}(|)[\]])/g,
+    REGEX_REMOVE_BACKSLASH: /(?:\[.*?[^\\]\]|\\(?=.))/g,
+    REPLACEMENTS: {
+      __proto__: null,
+      "***": "*",
+      "**/**": "**",
+      "**/**/**": "**"
+    },
+    CHAR_0: 48,
+    CHAR_9: 57,
+    CHAR_UPPERCASE_A: 65,
+    CHAR_LOWERCASE_A: 97,
+    CHAR_UPPERCASE_Z: 90,
+    CHAR_LOWERCASE_Z: 122,
+    CHAR_LEFT_PARENTHESES: 40,
+    CHAR_RIGHT_PARENTHESES: 41,
+    CHAR_ASTERISK: 42,
+    CHAR_AMPERSAND: 38,
+    CHAR_AT: 64,
+    CHAR_BACKWARD_SLASH: 92,
+    CHAR_CARRIAGE_RETURN: 13,
+    CHAR_CIRCUMFLEX_ACCENT: 94,
+    CHAR_COLON: 58,
+    CHAR_COMMA: 44,
+    CHAR_DOT: 46,
+    CHAR_DOUBLE_QUOTE: 34,
+    CHAR_EQUAL: 61,
+    CHAR_EXCLAMATION_MARK: 33,
+    CHAR_FORM_FEED: 12,
+    CHAR_FORWARD_SLASH: 47,
+    CHAR_GRAVE_ACCENT: 96,
+    CHAR_HASH: 35,
+    CHAR_HYPHEN_MINUS: 45,
+    CHAR_LEFT_ANGLE_BRACKET: 60,
+    CHAR_LEFT_CURLY_BRACE: 123,
+    CHAR_LEFT_SQUARE_BRACKET: 91,
+    CHAR_LINE_FEED: 10,
+    CHAR_NO_BREAK_SPACE: 160,
+    CHAR_PERCENT: 37,
+    CHAR_PLUS: 43,
+    CHAR_QUESTION_MARK: 63,
+    CHAR_RIGHT_ANGLE_BRACKET: 62,
+    CHAR_RIGHT_CURLY_BRACE: 125,
+    CHAR_RIGHT_SQUARE_BRACKET: 93,
+    CHAR_SEMICOLON: 59,
+    CHAR_SINGLE_QUOTE: 39,
+    CHAR_SPACE: 32,
+    CHAR_TAB: 9,
+    CHAR_UNDERSCORE: 95,
+    CHAR_VERTICAL_LINE: 124,
+    CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279,
+    extglobChars(chars) {
+      return {
+        "!": { type: "negate", open: "(?:(?!(?:", close: `))${chars.STAR})` },
+        "?": { type: "qmark", open: "(?:", close: ")?" },
+        "+": { type: "plus", open: "(?:", close: ")+" },
+        "*": { type: "star", open: "(?:", close: ")*" },
+        "@": { type: "at", open: "(?:", close: ")" }
       };
-      group[styleName] = styles[styleName];
-      codes.set(style[0], style[1]);
+    },
+    globChars(win32) {
+      return win32 === true ? WINDOWS_CHARS : POSIX_CHARS;
     }
-    Object.defineProperty(styles, groupName, {
-      value: group,
-      enumerable: false
+  };
+});
+
+// node_modules/picomatch/lib/utils.js
+var require_utils = __commonJS((exports) => {
+  var {
+    REGEX_BACKSLASH,
+    REGEX_REMOVE_BACKSLASH,
+    REGEX_SPECIAL_CHARS,
+    REGEX_SPECIAL_CHARS_GLOBAL
+  } = require_constants3();
+  exports.isObject = (val) => val !== null && typeof val === "object" && !Array.isArray(val);
+  exports.hasRegexChars = (str) => REGEX_SPECIAL_CHARS.test(str);
+  exports.isRegexChar = (str) => str.length === 1 && exports.hasRegexChars(str);
+  exports.escapeRegex = (str) => str.replace(REGEX_SPECIAL_CHARS_GLOBAL, "\\$1");
+  exports.toPosixSlashes = (str) => str.replace(REGEX_BACKSLASH, "/");
+  exports.isWindows = () => {
+    if (typeof navigator !== "undefined" && navigator.platform) {
+      const platform4 = navigator.platform.toLowerCase();
+      return platform4 === "win32" || platform4 === "windows";
+    }
+    if (typeof process !== "undefined" && process.platform) {
+      return process.platform === "win32";
+    }
+    return false;
+  };
+  exports.removeBackslashes = (str) => {
+    return str.replace(REGEX_REMOVE_BACKSLASH, (match) => {
+      return match === "\\" ? "" : match;
     });
-  }
-  Object.defineProperty(styles, "codes", {
-    value: codes,
-    enumerable: false
-  });
-  styles.color.close = "\x1B[39m";
-  styles.bgColor.close = "\x1B[49m";
-  styles.color.ansi = wrapAnsi16();
-  styles.color.ansi256 = wrapAnsi256();
-  styles.color.ansi16m = wrapAnsi16m();
-  styles.bgColor.ansi = wrapAnsi16(ANSI_BACKGROUND_OFFSET);
-  styles.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET);
-  styles.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET);
-  Object.defineProperties(styles, {
-    rgbToAnsi256: {
-      value(red, green, blue) {
-        if (red === green && green === blue) {
-          if (red < 8) {
-            return 16;
+  };
+  exports.escapeLast = (input, char, lastIdx) => {
+    const idx = input.lastIndexOf(char, lastIdx);
+    if (idx === -1)
+      return input;
+    if (input[idx - 1] === "\\")
+      return exports.escapeLast(input, char, idx - 1);
+    return `${input.slice(0, idx)}\\${input.slice(idx)}`;
+  };
+  exports.removePrefix = (input, state = {}) => {
+    let output = input;
+    if (output.startsWith("./")) {
+      output = output.slice(2);
+      state.prefix = "./";
+    }
+    return output;
+  };
+  exports.wrapOutput = (input, state = {}, options = {}) => {
+    const prepend = options.contains ? "" : "^";
+    const append = options.contains ? "" : "$";
+    let output = `${prepend}(?:${input})${append}`;
+    if (state.negated === true) {
+      output = `(?:^(?!${output}).*$)`;
+    }
+    return output;
+  };
+  exports.basename = (path5, { windows } = {}) => {
+    const segs = path5.split(windows ? /[\\/]/ : "/");
+    const last = segs[segs.length - 1];
+    if (last === "") {
+      return segs[segs.length - 2];
+    }
+    return last;
+  };
+});
+
+// node_modules/picomatch/lib/scan.js
+var require_scan = __commonJS((exports, module) => {
+  var utils = require_utils();
+  var {
+    CHAR_ASTERISK,
+    CHAR_AT,
+    CHAR_BACKWARD_SLASH,
+    CHAR_COMMA,
+    CHAR_DOT,
+    CHAR_EXCLAMATION_MARK,
+    CHAR_FORWARD_SLASH,
+    CHAR_LEFT_CURLY_BRACE,
+    CHAR_LEFT_PARENTHESES,
+    CHAR_LEFT_SQUARE_BRACKET,
+    CHAR_PLUS,
+    CHAR_QUESTION_MARK,
+    CHAR_RIGHT_CURLY_BRACE,
+    CHAR_RIGHT_PARENTHESES,
+    CHAR_RIGHT_SQUARE_BRACKET
+  } = require_constants3();
+  var isPathSeparator = (code) => {
+    return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH;
+  };
+  var depth = (token) => {
+    if (token.isPrefix !== true) {
+      token.depth = token.isGlobstar ? Infinity : 1;
+    }
+  };
+  var scan = (input, options) => {
+    const opts = options || {};
+    const length = input.length - 1;
+    const scanToEnd = opts.parts === true || opts.scanToEnd === true;
+    const slashes = [];
+    const tokens = [];
+    const parts = [];
+    let str = input;
+    let index = -1;
+    let start = 0;
+    let lastIndex = 0;
+    let isBrace = false;
+    let isBracket = false;
+    let isGlob = false;
+    let isExtglob = false;
+    let isGlobstar = false;
+    let braceEscaped = false;
+    let backslashes = false;
+    let negated = false;
+    let negatedExtglob = false;
+    let finished = false;
+    let braces = 0;
+    let prev;
+    let code;
+    let token = { value: "", depth: 0, isGlob: false };
+    const eos = () => index >= length;
+    const peek = () => str.charCodeAt(index + 1);
+    const advance = () => {
+      prev = code;
+      return str.charCodeAt(++index);
+    };
+    while (index < length) {
+      code = advance();
+      let next;
+      if (code === CHAR_BACKWARD_SLASH) {
+        backslashes = token.backslashes = true;
+        code = advance();
+        if (code === CHAR_LEFT_CURLY_BRACE) {
+          braceEscaped = true;
+        }
+        continue;
+      }
+      if (braceEscaped === true || code === CHAR_LEFT_CURLY_BRACE) {
+        braces++;
+        while (eos() !== true && (code = advance())) {
+          if (code === CHAR_BACKWARD_SLASH) {
+            backslashes = token.backslashes = true;
+            advance();
+            continue;
           }
-          if (red > 248) {
-            return 231;
+          if (code === CHAR_LEFT_CURLY_BRACE) {
+            braces++;
+            continue;
+          }
+          if (braceEscaped !== true && code === CHAR_DOT && (code = advance()) === CHAR_DOT) {
+            isBrace = token.isBrace = true;
+            isGlob = token.isGlob = true;
+            finished = true;
+            if (scanToEnd === true) {
+              continue;
+            }
+            break;
+          }
+          if (braceEscaped !== true && code === CHAR_COMMA) {
+            isBrace = token.isBrace = true;
+            isGlob = token.isGlob = true;
+            finished = true;
+            if (scanToEnd === true) {
+              continue;
+            }
+            break;
+          }
+          if (code === CHAR_RIGHT_CURLY_BRACE) {
+            braces--;
+            if (braces === 0) {
+              braceEscaped = false;
+              isBrace = token.isBrace = true;
+              finished = true;
+              break;
+            }
           }
-          return Math.round((red - 8) / 247 * 24) + 232;
         }
-        return 16 + 36 * Math.round(red / 255 * 5) + 6 * Math.round(green / 255 * 5) + Math.round(blue / 255 * 5);
-      },
-      enumerable: false
-    },
-    hexToRgb: {
-      value(hex) {
-        const matches = /[a-f\d]{6}|[a-f\d]{3}/i.exec(hex.toString(16));
-        if (!matches) {
-          return [0, 0, 0];
+        if (scanToEnd === true) {
+          continue;
         }
-        let [colorString] = matches;
-        if (colorString.length === 3) {
-          colorString = [...colorString].map((character) => character + character).join("");
+        break;
+      }
+      if (code === CHAR_FORWARD_SLASH) {
+        slashes.push(index);
+        tokens.push(token);
+        token = { value: "", depth: 0, isGlob: false };
+        if (finished === true)
+          continue;
+        if (prev === CHAR_DOT && index === start + 1) {
+          start += 2;
+          continue;
         }
-        const integer = Number.parseInt(colorString, 16);
-        return [
-          integer >> 16 & 255,
-          integer >> 8 & 255,
-          integer & 255
-        ];
-      },
-      enumerable: false
-    },
-    hexToAnsi256: {
-      value: (hex) => styles.rgbToAnsi256(...styles.hexToRgb(hex)),
-      enumerable: false
-    },
-    ansi256ToAnsi: {
-      value(code) {
-        if (code < 8) {
-          return 30 + code;
+        lastIndex = index + 1;
+        continue;
+      }
+      if (opts.noext !== true) {
+        const isExtglobChar = code === CHAR_PLUS || code === CHAR_AT || code === CHAR_ASTERISK || code === CHAR_QUESTION_MARK || code === CHAR_EXCLAMATION_MARK;
+        if (isExtglobChar === true && peek() === CHAR_LEFT_PARENTHESES) {
+          isGlob = token.isGlob = true;
+          isExtglob = token.isExtglob = true;
+          finished = true;
+          if (code === CHAR_EXCLAMATION_MARK && index === start) {
+            negatedExtglob = true;
+          }
+          if (scanToEnd === true) {
+            while (eos() !== true && (code = advance())) {
+              if (code === CHAR_BACKWARD_SLASH) {
+                backslashes = token.backslashes = true;
+                code = advance();
+                continue;
+              }
+              if (code === CHAR_RIGHT_PARENTHESES) {
+                isGlob = token.isGlob = true;
+                finished = true;
+                break;
+              }
+            }
+            continue;
+          }
+          break;
         }
-        if (code < 16) {
-          return 90 + (code - 8);
+      }
+      if (code === CHAR_ASTERISK) {
+        if (prev === CHAR_ASTERISK)
+          isGlobstar = token.isGlobstar = true;
+        isGlob = token.isGlob = true;
+        finished = true;
+        if (scanToEnd === true) {
+          continue;
         }
-        let red;
-        let green;
-        let blue;
-        if (code >= 232) {
-          red = ((code - 232) * 10 + 8) / 255;
-          green = red;
-          blue = red;
-        } else {
-          code -= 16;
-          const remainder = code % 36;
-          red = Math.floor(code / 36) / 5;
-          green = Math.floor(remainder / 6) / 5;
-          blue = remainder % 6 / 5;
+        break;
+      }
+      if (code === CHAR_QUESTION_MARK) {
+        isGlob = token.isGlob = true;
+        finished = true;
+        if (scanToEnd === true) {
+          continue;
         }
-        const value = Math.max(red, green, blue) * 2;
-        if (value === 0) {
-          return 30;
+        break;
+      }
+      if (code === CHAR_LEFT_SQUARE_BRACKET) {
+        while (eos() !== true && (next = advance())) {
+          if (next === CHAR_BACKWARD_SLASH) {
+            backslashes = token.backslashes = true;
+            advance();
+            continue;
+          }
+          if (next === CHAR_RIGHT_SQUARE_BRACKET) {
+            isBracket = token.isBracket = true;
+            isGlob = token.isGlob = true;
+            finished = true;
+            break;
+          }
         }
-        let result = 30 + (Math.round(blue) << 2 | Math.round(green) << 1 | Math.round(red));
-        if (value === 2) {
-          result += 60;
+        if (scanToEnd === true) {
+          continue;
         }
-        return result;
-      },
-      enumerable: false
-    },
-    rgbToAnsi: {
-      value: (red, green, blue) => styles.ansi256ToAnsi(styles.rgbToAnsi256(red, green, blue)),
-      enumerable: false
-    },
-    hexToAnsi: {
-      value: (hex) => styles.ansi256ToAnsi(styles.hexToAnsi256(hex)),
-      enumerable: false
+        break;
+      }
+      if (opts.nonegate !== true && code === CHAR_EXCLAMATION_MARK && index === start) {
+        negated = token.negated = true;
+        start++;
+        continue;
+      }
+      if (opts.noparen !== true && code === CHAR_LEFT_PARENTHESES) {
+        isGlob = token.isGlob = true;
+        if (scanToEnd === true) {
+          while (eos() !== true && (code = advance())) {
+            if (code === CHAR_LEFT_PARENTHESES) {
+              backslashes = token.backslashes = true;
+              code = advance();
+              continue;
+            }
+            if (code === CHAR_RIGHT_PARENTHESES) {
+              finished = true;
+              break;
+            }
+          }
+          continue;
+        }
+        break;
+      }
+      if (isGlob === true) {
+        finished = true;
+        if (scanToEnd === true) {
+          continue;
+        }
+        break;
+      }
     }
-  });
-  return styles;
-}
-var ansiStyles = assembleStyles();
-var ansi_styles_default = ansiStyles;
-
-// node_modules/chalk/source/vendor/supports-color/index.js
-import process2 from "node:process";
-import os from "node:os";
-import tty from "node:tty";
-function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : process2.argv) {
-  const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
-  const position = argv.indexOf(prefix + flag);
-  const terminatorPosition = argv.indexOf("--");
-  return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
-}
-var { env } = process2;
-var flagForceColor;
-if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
-  flagForceColor = 0;
-} else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
-  flagForceColor = 1;
-}
-function envForceColor() {
-  if ("FORCE_COLOR" in env) {
-    if (env.FORCE_COLOR === "true") {
-      return 1;
-    }
-    if (env.FORCE_COLOR === "false") {
-      return 0;
-    }
-    return env.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
-  }
-}
-function translateLevel(level) {
-  if (level === 0) {
-    return false;
-  }
-  return {
-    level,
-    hasBasic: true,
-    has256: level >= 2,
-    has16m: level >= 3
-  };
-}
-function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
-  const noFlagForceColor = envForceColor();
-  if (noFlagForceColor !== undefined) {
-    flagForceColor = noFlagForceColor;
-  }
-  const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
-  if (forceColor === 0) {
-    return 0;
-  }
-  if (sniffFlags) {
-    if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
-      return 3;
-    }
-    if (hasFlag("color=256")) {
-      return 2;
-    }
-  }
-  if ("TF_BUILD" in env && "AGENT_NAME" in env) {
-    return 1;
-  }
-  if (haveStream && !streamIsTTY && forceColor === undefined) {
-    return 0;
-  }
-  const min = forceColor || 0;
-  if (env.TERM === "dumb") {
-    return min;
-  }
-  if (process2.platform === "win32") {
-    const osRelease = os.release().split(".");
-    if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
-      return Number(osRelease[2]) >= 14931 ? 3 : 2;
+    if (opts.noext === true) {
+      isExtglob = false;
+      isGlob = false;
+    }
+    let base2 = str;
+    let prefix = "";
+    let glob = "";
+    if (start > 0) {
+      prefix = str.slice(0, start);
+      str = str.slice(start);
+      lastIndex -= start;
+    }
+    if (base2 && isGlob === true && lastIndex > 0) {
+      base2 = str.slice(0, lastIndex);
+      glob = str.slice(lastIndex);
+    } else if (isGlob === true) {
+      base2 = "";
+      glob = str;
+    } else {
+      base2 = str;
     }
-    return 1;
-  }
-  if ("CI" in env) {
-    if (["GITHUB_ACTIONS", "GITEA_ACTIONS", "CIRCLECI"].some((key) => (key in env))) {
-      return 3;
+    if (base2 && base2 !== "" && base2 !== "/" && base2 !== str) {
+      if (isPathSeparator(base2.charCodeAt(base2.length - 1))) {
+        base2 = base2.slice(0, -1);
+      }
     }
-    if (["TRAVIS", "APPVEYOR", "GITLAB_CI", "BUILDKITE", "DRONE"].some((sign) => (sign in env)) || env.CI_NAME === "codeship") {
-      return 1;
+    if (opts.unescape === true) {
+      if (glob)
+        glob = utils.removeBackslashes(glob);
+      if (base2 && backslashes === true) {
+        base2 = utils.removeBackslashes(base2);
+      }
     }
-    return min;
-  }
-  if ("TEAMCITY_VERSION" in env) {
-    return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
-  }
-  if (env.COLORTERM === "truecolor") {
-    return 3;
-  }
-  if (env.TERM === "xterm-kitty") {
-    return 3;
-  }
-  if (env.TERM === "xterm-ghostty") {
-    return 3;
-  }
-  if ("TERM_PROGRAM" in env) {
-    const version = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
-    switch (env.TERM_PROGRAM) {
-      case "iTerm.app": {
-        return version >= 3 ? 3 : 2;
+    const state = {
+      prefix,
+      input,
+      start,
+      base: base2,
+      glob,
+      isBrace,
+      isBracket,
+      isGlob,
+      isExtglob,
+      isGlobstar,
+      negated,
+      negatedExtglob
+    };
+    if (opts.tokens === true) {
+      state.maxDepth = 0;
+      if (!isPathSeparator(code)) {
+        tokens.push(token);
+      }
+      state.tokens = tokens;
+    }
+    if (opts.parts === true || opts.tokens === true) {
+      let prevIndex;
+      for (let idx = 0;idx < slashes.length; idx++) {
+        const n = prevIndex ? prevIndex + 1 : start;
+        const i = slashes[idx];
+        const value = input.slice(n, i);
+        if (opts.tokens) {
+          if (idx === 0 && start !== 0) {
+            tokens[idx].isPrefix = true;
+            tokens[idx].value = prefix;
+          } else {
+            tokens[idx].value = value;
+          }
+          depth(tokens[idx]);
+          state.maxDepth += tokens[idx].depth;
+        }
+        if (idx !== 0 || value !== "") {
+          parts.push(value);
+        }
+        prevIndex = i;
       }
-      case "Apple_Terminal": {
-        return 2;
+      if (prevIndex && prevIndex + 1 < input.length) {
+        const value = input.slice(prevIndex + 1);
+        parts.push(value);
+        if (opts.tokens) {
+          tokens[tokens.length - 1].value = value;
+          depth(tokens[tokens.length - 1]);
+          state.maxDepth += tokens[tokens.length - 1].depth;
+        }
       }
+      state.slashes = slashes;
+      state.parts = parts;
     }
-  }
-  if (/-256(color)?$/i.test(env.TERM)) {
-    return 2;
-  }
-  if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
-    return 1;
-  }
-  if ("COLORTERM" in env) {
-    return 1;
-  }
-  return min;
-}
-function createSupportsColor(stream, options = {}) {
-  const level = _supportsColor(stream, {
-    streamIsTTY: stream && stream.isTTY,
-    ...options
-  });
-  return translateLevel(level);
-}
-var supportsColor = {
-  stdout: createSupportsColor({ isTTY: tty.isatty(1) }),
-  stderr: createSupportsColor({ isTTY: tty.isatty(2) })
-};
-var supports_color_default = supportsColor;
-
-// node_modules/chalk/source/utilities.js
-function stringReplaceAll(string, substring, replacer) {
-  let index = string.indexOf(substring);
-  if (index === -1) {
-    return string;
-  }
-  const substringLength = substring.length;
-  let endIndex = 0;
-  let returnValue = "";
-  do {
-    returnValue += string.slice(endIndex, index) + substring + replacer;
-    endIndex = index + substringLength;
-    index = string.indexOf(substring, endIndex);
-  } while (index !== -1);
-  returnValue += string.slice(endIndex);
-  return returnValue;
-}
-function stringEncaseCRLFWithFirstIndex(string, prefix, postfix, index) {
-  let endIndex = 0;
-  let returnValue = "";
-  do {
-    const gotCR = string[index - 1] === "\r";
-    returnValue += string.slice(endIndex, gotCR ? index - 1 : index) + prefix + (gotCR ? `\r
-` : `
-`) + postfix;
-    endIndex = index + 1;
-    index = string.indexOf(`
-`, endIndex);
-  } while (index !== -1);
-  returnValue += string.slice(endIndex);
-  return returnValue;
-}
+    return state;
+  };
+  module.exports = scan;
+});
 
-// node_modules/chalk/source/index.js
-var { stdout: stdoutColor, stderr: stderrColor } = supports_color_default;
-var GENERATOR = Symbol("GENERATOR");
-var STYLER = Symbol("STYLER");
-var IS_EMPTY = Symbol("IS_EMPTY");
-var levelMapping = [
-  "ansi",
-  "ansi",
-  "ansi256",
-  "ansi16m"
-];
-var styles2 = Object.create(null);
-var applyOptions = (object, options = {}) => {
-  if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) {
-    throw new Error("The `level` option should be an integer from 0 to 3");
-  }
-  const colorLevel = stdoutColor ? stdoutColor.level : 0;
-  object.level = options.level === undefined ? colorLevel : options.level;
-};
-var chalkFactory = (options) => {
-  const chalk = (...strings) => strings.join(" ");
-  applyOptions(chalk, options);
-  Object.setPrototypeOf(chalk, createChalk.prototype);
-  return chalk;
-};
-function createChalk(options) {
-  return chalkFactory(options);
-}
-Object.setPrototypeOf(createChalk.prototype, Function.prototype);
-for (const [styleName, style] of Object.entries(ansi_styles_default)) {
-  styles2[styleName] = {
-    get() {
-      const builder = createBuilder(this, createStyler(style.open, style.close, this[STYLER]), this[IS_EMPTY]);
-      Object.defineProperty(this, styleName, { value: builder });
-      return builder;
+// node_modules/picomatch/lib/parse.js
+var require_parse = __commonJS((exports, module) => {
+  var constants2 = require_constants3();
+  var utils = require_utils();
+  var {
+    MAX_LENGTH,
+    POSIX_REGEX_SOURCE,
+    REGEX_NON_SPECIAL_CHARS,
+    REGEX_SPECIAL_CHARS_BACKREF,
+    REPLACEMENTS
+  } = constants2;
+  var expandRange = (args, options) => {
+    if (typeof options.expandRange === "function") {
+      return options.expandRange(...args, options);
+    }
+    args.sort();
+    const value = `[${args.join("-")}]`;
+    try {
+      new RegExp(value);
+    } catch (ex) {
+      return args.map((v) => utils.escapeRegex(v)).join("..");
     }
+    return value;
   };
-}
-styles2.visible = {
-  get() {
-    const builder = createBuilder(this, this[STYLER], true);
-    Object.defineProperty(this, "visible", { value: builder });
-    return builder;
-  }
-};
-var getModelAnsi = (model, level, type, ...arguments_) => {
-  if (model === "rgb") {
-    if (level === "ansi16m") {
-      return ansi_styles_default[type].ansi16m(...arguments_);
-    }
-    if (level === "ansi256") {
-      return ansi_styles_default[type].ansi256(ansi_styles_default.rgbToAnsi256(...arguments_));
-    }
-    return ansi_styles_default[type].ansi(ansi_styles_default.rgbToAnsi(...arguments_));
-  }
-  if (model === "hex") {
-    return getModelAnsi("rgb", level, type, ...ansi_styles_default.hexToRgb(...arguments_));
-  }
-  return ansi_styles_default[type][model](...arguments_);
-};
-var usedModels = ["rgb", "hex", "ansi256"];
-for (const model of usedModels) {
-  styles2[model] = {
-    get() {
-      const { level } = this;
-      return function(...arguments_) {
-        const styler = createStyler(getModelAnsi(model, levelMapping[level], "color", ...arguments_), ansi_styles_default.color.close, this[STYLER]);
-        return createBuilder(this, styler, this[IS_EMPTY]);
-      };
-    }
+  var syntaxError = (type, char) => {
+    return `Missing ${type}: "${char}" - use "\\\\${char}" to match literal characters`;
   };
-  const bgModel = "bg" + model[0].toUpperCase() + model.slice(1);
-  styles2[bgModel] = {
-    get() {
-      const { level } = this;
-      return function(...arguments_) {
-        const styler = createStyler(getModelAnsi(model, levelMapping[level], "bgColor", ...arguments_), ansi_styles_default.bgColor.close, this[STYLER]);
-        return createBuilder(this, styler, this[IS_EMPTY]);
-      };
+  var parse5 = (input, options) => {
+    if (typeof input !== "string") {
+      throw new TypeError("Expected a string");
     }
-  };
-}
-var proto = Object.defineProperties(() => {}, {
-  ...styles2,
-  level: {
-    enumerable: true,
-    get() {
-      return this[GENERATOR].level;
-    },
-    set(level) {
-      this[GENERATOR].level = level;
+    input = REPLACEMENTS[input] || input;
+    const opts = { ...options };
+    const max = typeof opts.maxLength === "number" ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
+    let len = input.length;
+    if (len > max) {
+      throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
+    }
+    const bos = { type: "bos", value: "", output: opts.prepend || "" };
+    const tokens = [bos];
+    const capture = opts.capture ? "" : "?:";
+    const PLATFORM_CHARS = constants2.globChars(opts.windows);
+    const EXTGLOB_CHARS = constants2.extglobChars(PLATFORM_CHARS);
+    const {
+      DOT_LITERAL,
+      PLUS_LITERAL,
+      SLASH_LITERAL,
+      ONE_CHAR,
+      DOTS_SLASH,
+      NO_DOT,
+      NO_DOT_SLASH,
+      NO_DOTS_SLASH,
+      QMARK,
+      QMARK_NO_DOT,
+      STAR,
+      START_ANCHOR
+    } = PLATFORM_CHARS;
+    const globstar = (opts2) => {
+      return `(${capture}(?:(?!${START_ANCHOR}${opts2.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
+    };
+    const nodot = opts.dot ? "" : NO_DOT;
+    const qmarkNoDot = opts.dot ? QMARK : QMARK_NO_DOT;
+    let star = opts.bash === true ? globstar(opts) : STAR;
+    if (opts.capture) {
+      star = `(${star})`;
     }
-  }
-});
-var createStyler = (open, close, parent) => {
-  let openAll;
-  let closeAll;
-  if (parent === undefined) {
-    openAll = open;
-    closeAll = close;
-  } else {
-    openAll = parent.openAll + open;
-    closeAll = close + parent.closeAll;
-  }
-  return {
-    open,
-    close,
-    openAll,
-    closeAll,
-    parent
-  };
-};
-var createBuilder = (self2, _styler, _isEmpty) => {
-  const builder = (...arguments_) => applyStyle(builder, arguments_.length === 1 ? "" + arguments_[0] : arguments_.join(" "));
-  Object.setPrototypeOf(builder, proto);
-  builder[GENERATOR] = self2;
-  builder[STYLER] = _styler;
-  builder[IS_EMPTY] = _isEmpty;
-  return builder;
-};
-var applyStyle = (self2, string) => {
-  if (self2.level <= 0 || !string) {
-    return self2[IS_EMPTY] ? "" : string;
-  }
-  let styler = self2[STYLER];
-  if (styler === undefined) {
-    return string;
-  }
-  const { openAll, closeAll } = styler;
-  if (string.includes("\x1B")) {
-    while (styler !== undefined) {
-      string = stringReplaceAll(string, styler.close, styler.open);
-      styler = styler.parent;
-    }
-  }
-  const lfIndex = string.indexOf(`
-`);
-  if (lfIndex !== -1) {
-    string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex);
-  }
-  return openAll + string + closeAll;
-};
-Object.defineProperties(createChalk.prototype, styles2);
-var chalk = createChalk();
-var chalkStderr = createChalk({ level: stderrColor ? stderrColor.level : 0 });
-var source_default = chalk;
-
-// node_modules/ink/build/render.js
-import { Stream } from "node:stream";
-import process12 from "node:process";
-
-// node_modules/ink/build/ink.js
-var import_react13 = __toESM(require_react(), 1);
-import process11 from "node:process";
-
-// node_modules/es-toolkit/dist/function/debounce.mjs
-function debounce(func, debounceMs, { signal, edges } = {}) {
-  let pendingThis = undefined;
-  let pendingArgs = null;
-  const leading = edges != null && edges.includes("leading");
-  const trailing = edges == null || edges.includes("trailing");
-  const invoke = () => {
-    if (pendingArgs !== null) {
-      func.apply(pendingThis, pendingArgs);
-      pendingThis = undefined;
-      pendingArgs = null;
-    }
-  };
-  const onTimerEnd = () => {
-    if (trailing) {
-      invoke();
-    }
-    cancel();
-  };
-  let timeoutId = null;
-  const schedule = () => {
-    if (timeoutId != null) {
-      clearTimeout(timeoutId);
-    }
-    timeoutId = setTimeout(() => {
-      timeoutId = null;
-      onTimerEnd();
-    }, debounceMs);
-  };
-  const cancelTimer = () => {
-    if (timeoutId !== null) {
-      clearTimeout(timeoutId);
-      timeoutId = null;
-    }
-  };
-  const cancel = () => {
-    cancelTimer();
-    pendingThis = undefined;
-    pendingArgs = null;
-  };
-  const flush = () => {
-    invoke();
-  };
-  const debounced = function(...args) {
-    if (signal?.aborted) {
-      return;
-    }
-    pendingThis = this;
-    pendingArgs = args;
-    const isFirstCall = timeoutId == null;
-    schedule();
-    if (leading && isFirstCall) {
-      invoke();
+    if (typeof opts.noext === "boolean") {
+      opts.noextglob = opts.noext;
     }
-  };
-  debounced.schedule = schedule;
-  debounced.cancel = cancel;
-  debounced.flush = flush;
-  signal?.addEventListener("abort", cancel, { once: true });
-  return debounced;
-}
-
-// node_modules/es-toolkit/dist/compat/function/debounce.mjs
-function debounce2(func, debounceMs = 0, options = {}) {
-  if (typeof options !== "object") {
-    options = {};
-  }
-  const { leading = false, trailing = true, maxWait } = options;
-  const edges = Array(2);
-  if (leading) {
-    edges[0] = "leading";
-  }
-  if (trailing) {
-    edges[1] = "trailing";
-  }
-  let result = undefined;
-  let pendingAt = null;
-  const _debounced = debounce(function(...args) {
-    result = func.apply(this, args);
-    pendingAt = null;
-  }, debounceMs, { edges });
-  const debounced = function(...args) {
-    if (maxWait != null) {
-      if (pendingAt === null) {
-        pendingAt = Date.now();
+    const state = {
+      input,
+      index: -1,
+      start: 0,
+      dot: opts.dot === true,
+      consumed: "",
+      output: "",
+      prefix: "",
+      backtrack: false,
+      negated: false,
+      brackets: 0,
+      braces: 0,
+      parens: 0,
+      quotes: 0,
+      globstar: false,
+      tokens
+    };
+    input = utils.removePrefix(input, state);
+    len = input.length;
+    const extglobs = [];
+    const braces = [];
+    const stack = [];
+    let prev = bos;
+    let value;
+    const eos = () => state.index === len - 1;
+    const peek = state.peek = (n = 1) => input[state.index + n];
+    const advance = state.advance = () => input[++state.index] || "";
+    const remaining = () => input.slice(state.index + 1);
+    const consume = (value2 = "", num = 0) => {
+      state.consumed += value2;
+      state.index += num;
+    };
+    const append = (token) => {
+      state.output += token.output != null ? token.output : token.value;
+      consume(token.value);
+    };
+    const negate = () => {
+      let count = 1;
+      while (peek() === "!" && (peek(2) !== "(" || peek(3) === "?")) {
+        advance();
+        state.start++;
+        count++;
+      }
+      if (count % 2 === 0) {
+        return false;
       }
-      if (Date.now() - pendingAt >= maxWait) {
-        result = func.apply(this, args);
-        pendingAt = Date.now();
-        _debounced.cancel();
-        _debounced.schedule();
-        return result;
+      state.negated = true;
+      state.start++;
+      return true;
+    };
+    const increment = (type) => {
+      state[type]++;
+      stack.push(type);
+    };
+    const decrement = (type) => {
+      state[type]--;
+      stack.pop();
+    };
+    const push = (tok) => {
+      if (prev.type === "globstar") {
+        const isBrace = state.braces > 0 && (tok.type === "comma" || tok.type === "brace");
+        const isExtglob = tok.extglob === true || extglobs.length && (tok.type === "pipe" || tok.type === "paren");
+        if (tok.type !== "slash" && tok.type !== "paren" && !isBrace && !isExtglob) {
+          state.output = state.output.slice(0, -prev.output.length);
+          prev.type = "star";
+          prev.value = "*";
+          prev.output = star;
+          state.output += prev.output;
+        }
+      }
+      if (extglobs.length && tok.type !== "paren") {
+        extglobs[extglobs.length - 1].inner += tok.value;
+      }
+      if (tok.value || tok.output)
+        append(tok);
+      if (prev && prev.type === "text" && tok.type === "text") {
+        prev.output = (prev.output || prev.value) + tok.value;
+        prev.value += tok.value;
+        return;
+      }
+      tok.prev = prev;
+      tokens.push(tok);
+      prev = tok;
+    };
+    const extglobOpen = (type, value2) => {
+      const token = { ...EXTGLOB_CHARS[value2], conditions: 1, inner: "" };
+      token.prev = prev;
+      token.parens = state.parens;
+      token.output = state.output;
+      const output = (opts.capture ? "(" : "") + token.open;
+      increment("parens");
+      push({ type, value: value2, output: state.output ? "" : ONE_CHAR });
+      push({ type: "paren", extglob: true, value: advance(), output });
+      extglobs.push(token);
+    };
+    const extglobClose = (token) => {
+      let output = token.close + (opts.capture ? ")" : "");
+      let rest;
+      if (token.type === "negate") {
+        let extglobStar = star;
+        if (token.inner && token.inner.length > 1 && token.inner.includes("/")) {
+          extglobStar = globstar(opts);
+        }
+        if (extglobStar !== star || eos() || /^\)+$/.test(remaining())) {
+          output = token.close = `)$))${extglobStar}`;
+        }
+        if (token.inner.includes("*") && (rest = remaining()) && /^\.[^\\/.]+$/.test(rest)) {
+          const expression = parse5(rest, { ...options, fastpaths: false }).output;
+          output = token.close = `)${expression})${extglobStar})`;
+        }
+        if (token.prev.type === "bos") {
+          state.negatedExtglob = true;
+        }
+      }
+      push({ type: "paren", extglob: true, value, output });
+      decrement("parens");
+    };
+    if (opts.fastpaths !== false && !/(^[*!]|[/()[\]{}"])/.test(input)) {
+      let backslashes = false;
+      let output = input.replace(REGEX_SPECIAL_CHARS_BACKREF, (m, esc2, chars, first, rest, index) => {
+        if (first === "\\") {
+          backslashes = true;
+          return m;
+        }
+        if (first === "?") {
+          if (esc2) {
+            return esc2 + first + (rest ? QMARK.repeat(rest.length) : "");
+          }
+          if (index === 0) {
+            return qmarkNoDot + (rest ? QMARK.repeat(rest.length) : "");
+          }
+          return QMARK.repeat(chars.length);
+        }
+        if (first === ".") {
+          return DOT_LITERAL.repeat(chars.length);
+        }
+        if (first === "*") {
+          if (esc2) {
+            return esc2 + first + (rest ? star : "");
+          }
+          return star;
+        }
+        return esc2 ? m : `\\${m}`;
+      });
+      if (backslashes === true) {
+        if (opts.unescape === true) {
+          output = output.replace(/\\/g, "");
+        } else {
+          output = output.replace(/\\+/g, (m) => {
+            return m.length % 2 === 0 ? "\\\\" : m ? "\\" : "";
+          });
+        }
       }
+      if (output === input && opts.contains === true) {
+        state.output = input;
+        return state;
+      }
+      state.output = utils.wrapOutput(output, state, options);
+      return state;
     }
-    _debounced.apply(this, args);
-    return result;
-  };
-  const flush = () => {
-    _debounced.flush();
-    return result;
-  };
-  debounced.cancel = _debounced.cancel;
-  debounced.flush = flush;
-  return debounced;
-}
-
-// node_modules/es-toolkit/dist/compat/function/throttle.mjs
-function throttle(func, throttleMs = 0, options = {}) {
-  const { leading = true, trailing = true } = options;
-  return debounce2(func, throttleMs, {
-    leading,
-    maxWait: throttleMs,
-    trailing
-  });
-}
-// node_modules/ansi-escapes/base.js
-var exports_base = {};
-__export(exports_base, {
-  scrollUp: () => scrollUp,
-  scrollDown: () => scrollDown,
-  link: () => link,
-  image: () => image,
-  iTerm: () => iTerm,
-  exitAlternativeScreen: () => exitAlternativeScreen,
-  eraseUp: () => eraseUp,
-  eraseStartLine: () => eraseStartLine,
-  eraseScreen: () => eraseScreen,
-  eraseLines: () => eraseLines,
-  eraseLine: () => eraseLine,
-  eraseEndLine: () => eraseEndLine,
-  eraseDown: () => eraseDown,
-  enterAlternativeScreen: () => enterAlternativeScreen,
-  cursorUp: () => cursorUp,
-  cursorTo: () => cursorTo,
-  cursorShow: () => cursorShow,
-  cursorSavePosition: () => cursorSavePosition,
-  cursorRestorePosition: () => cursorRestorePosition,
-  cursorPrevLine: () => cursorPrevLine,
-  cursorNextLine: () => cursorNextLine,
-  cursorMove: () => cursorMove,
-  cursorLeft: () => cursorLeft,
-  cursorHide: () => cursorHide,
-  cursorGetPosition: () => cursorGetPosition,
-  cursorForward: () => cursorForward,
-  cursorDown: () => cursorDown,
-  cursorBackward: () => cursorBackward,
-  clearTerminal: () => clearTerminal,
-  clearScreen: () => clearScreen,
-  beep: () => beep
-});
-import process3 from "node:process";
-
-// node_modules/environment/index.js
-var isBrowser = globalThis.window?.document !== undefined;
-var isNode = globalThis.process?.versions?.node !== undefined;
-var isBun = globalThis.process?.versions?.bun !== undefined;
-var isDeno = globalThis.Deno?.version?.deno !== undefined;
-var isElectron = globalThis.process?.versions?.electron !== undefined;
-var isJsDom = globalThis.navigator?.userAgent?.includes("jsdom") === true;
-var isWebWorker = typeof WorkerGlobalScope !== "undefined" && globalThis instanceof WorkerGlobalScope;
-var isDedicatedWorker = typeof DedicatedWorkerGlobalScope !== "undefined" && globalThis instanceof DedicatedWorkerGlobalScope;
-var isSharedWorker = typeof SharedWorkerGlobalScope !== "undefined" && globalThis instanceof SharedWorkerGlobalScope;
-var isServiceWorker = typeof ServiceWorkerGlobalScope !== "undefined" && globalThis instanceof ServiceWorkerGlobalScope;
-var platform = globalThis.navigator?.userAgentData?.platform;
-var isMacOs = platform === "macOS" || globalThis.navigator?.platform === "MacIntel" || globalThis.navigator?.userAgent?.includes(" Mac ") === true || globalThis.process?.platform === "darwin";
-var isWindows = platform === "Windows" || globalThis.navigator?.platform === "Win32" || globalThis.process?.platform === "win32";
-var isLinux = platform === "Linux" || globalThis.navigator?.platform?.startsWith("Linux") === true || globalThis.navigator?.userAgent?.includes(" Linux ") === true || globalThis.process?.platform === "linux";
-var isIos = platform === "iOS" || globalThis.navigator?.platform === "MacIntel" && globalThis.navigator?.maxTouchPoints > 1 || /iPad|iPhone|iPod/.test(globalThis.navigator?.platform);
-var isAndroid = platform === "Android" || globalThis.navigator?.platform === "Android" || globalThis.navigator?.userAgent?.includes(" Android ") === true || globalThis.process?.platform === "android";
-
-// node_modules/ansi-escapes/base.js
+    while (!eos()) {
+      value = advance();
+      if (value === "\x00") {
+        continue;
+      }
+      if (value === "\\") {
+        const next = peek();
+        if (next === "/" && opts.bash !== true) {
+          continue;
+        }
+        if (next === "." || next === ";") {
+          continue;
+        }
+        if (!next) {
+          value += "\\";
+          push({ type: "text", value });
+          continue;
+        }
+        const match = /^\\+/.exec(remaining());
+        let slashes = 0;
+        if (match && match[0].length > 2) {
+          slashes = match[0].length;
+          state.index += slashes;
+          if (slashes % 2 !== 0) {
+            value += "\\";
+          }
+        }
+        if (opts.unescape === true) {
+          value = advance();
+        } else {
+          value += advance();
+        }
+        if (state.brackets === 0) {
+          push({ type: "text", value });
+          continue;
+        }
+      }
+      if (state.brackets > 0 && (value !== "]" || prev.value === "[" || prev.value === "[^")) {
+        if (opts.posix !== false && value === ":") {
+          const inner = prev.value.slice(1);
+          if (inner.includes("[")) {
+            prev.posix = true;
+            if (inner.includes(":")) {
+              const idx = prev.value.lastIndexOf("[");
+              const pre = prev.value.slice(0, idx);
+              const rest2 = prev.value.slice(idx + 2);
+              const posix = POSIX_REGEX_SOURCE[rest2];
+              if (posix) {
+                prev.value = pre + posix;
+                state.backtrack = true;
+                advance();
+                if (!bos.output && tokens.indexOf(prev) === 1) {
+                  bos.output = ONE_CHAR;
+                }
+                continue;
+              }
+            }
+          }
+        }
+        if (value === "[" && peek() !== ":" || value === "-" && peek() === "]") {
+          value = `\\${value}`;
+        }
+        if (value === "]" && (prev.value === "[" || prev.value === "[^")) {
+          value = `\\${value}`;
+        }
+        if (opts.posix === true && value === "!" && prev.value === "[") {
+          value = "^";
+        }
+        prev.value += value;
+        append({ value });
+        continue;
+      }
+      if (state.quotes === 1 && value !== '"') {
+        value = utils.escapeRegex(value);
+        prev.value += value;
+        append({ value });
+        continue;
+      }
+      if (value === '"') {
+        state.quotes = state.quotes === 1 ? 0 : 1;
+        if (opts.keepQuotes === true) {
+          push({ type: "text", value });
+        }
+        continue;
+      }
+      if (value === "(") {
+        increment("parens");
+        push({ type: "paren", value });
+        continue;
+      }
+      if (value === ")") {
+        if (state.parens === 0 && opts.strictBrackets === true) {
+          throw new SyntaxError(syntaxError("opening", "("));
+        }
+        const extglob = extglobs[extglobs.length - 1];
+        if (extglob && state.parens === extglob.parens + 1) {
+          extglobClose(extglobs.pop());
+          continue;
+        }
+        push({ type: "paren", value, output: state.parens ? ")" : "\\)" });
+        decrement("parens");
+        continue;
+      }
+      if (value === "[") {
+        if (opts.nobracket === true || !remaining().includes("]")) {
+          if (opts.nobracket !== true && opts.strictBrackets === true) {
+            throw new SyntaxError(syntaxError("closing", "]"));
+          }
+          value = `\\${value}`;
+        } else {
+          increment("brackets");
+        }
+        push({ type: "bracket", value });
+        continue;
+      }
+      if (value === "]") {
+        if (opts.nobracket === true || prev && prev.type === "bracket" && prev.value.length === 1) {
+          push({ type: "text", value, output: `\\${value}` });
+          continue;
+        }
+        if (state.brackets === 0) {
+          if (opts.strictBrackets === true) {
+            throw new SyntaxError(syntaxError("opening", "["));
+          }
+          push({ type: "text", value, output: `\\${value}` });
+          continue;
+        }
+        decrement("brackets");
+        const prevValue = prev.value.slice(1);
+        if (prev.posix !== true && prevValue[0] === "^" && !prevValue.includes("/")) {
+          value = `/${value}`;
+        }
+        prev.value += value;
+        append({ value });
+        if (opts.literalBrackets === false || utils.hasRegexChars(prevValue)) {
+          continue;
+        }
+        const escaped = utils.escapeRegex(prev.value);
+        state.output = state.output.slice(0, -prev.value.length);
+        if (opts.literalBrackets === true) {
+          state.output += escaped;
+          prev.value = escaped;
+          continue;
+        }
+        prev.value = `(${capture}${escaped}|${prev.value})`;
+        state.output += prev.value;
+        continue;
+      }
+      if (value === "{" && opts.nobrace !== true) {
+        increment("braces");
+        const open = {
+          type: "brace",
+          value,
+          output: "(",
+          outputIndex: state.output.length,
+          tokensIndex: state.tokens.length
+        };
+        braces.push(open);
+        push(open);
+        continue;
+      }
+      if (value === "}") {
+        const brace = braces[braces.length - 1];
+        if (opts.nobrace === true || !brace) {
+          push({ type: "text", value, output: value });
+          continue;
+        }
+        let output = ")";
+        if (brace.dots === true) {
+          const arr = tokens.slice();
+          const range = [];
+          for (let i = arr.length - 1;i >= 0; i--) {
+            tokens.pop();
+            if (arr[i].type === "brace") {
+              break;
+            }
+            if (arr[i].type !== "dots") {
+              range.unshift(arr[i].value);
+            }
+          }
+          output = expandRange(range, opts);
+          state.backtrack = true;
+        }
+        if (brace.comma !== true && brace.dots !== true) {
+          const out = state.output.slice(0, brace.outputIndex);
+          const toks = state.tokens.slice(brace.tokensIndex);
+          brace.value = brace.output = "\\{";
+          value = output = "\\}";
+          state.output = out;
+          for (const t of toks) {
+            state.output += t.output || t.value;
+          }
+        }
+        push({ type: "brace", value, output });
+        decrement("braces");
+        braces.pop();
+        continue;
+      }
+      if (value === "|") {
+        if (extglobs.length > 0) {
+          extglobs[extglobs.length - 1].conditions++;
+        }
+        push({ type: "text", value });
+        continue;
+      }
+      if (value === ",") {
+        let output = value;
+        const brace = braces[braces.length - 1];
+        if (brace && stack[stack.length - 1] === "braces") {
+          brace.comma = true;
+          output = "|";
+        }
+        push({ type: "comma", value, output });
+        continue;
+      }
+      if (value === "/") {
+        if (prev.type === "dot" && state.index === state.start + 1) {
+          state.start = state.index + 1;
+          state.consumed = "";
+          state.output = "";
+          tokens.pop();
+          prev = bos;
+          continue;
+        }
+        push({ type: "slash", value, output: SLASH_LITERAL });
+        continue;
+      }
+      if (value === ".") {
+        if (state.braces > 0 && prev.type === "dot") {
+          if (prev.value === ".")
+            prev.output = DOT_LITERAL;
+          const brace = braces[braces.length - 1];
+          prev.type = "dots";
+          prev.output += value;
+          prev.value += value;
+          brace.dots = true;
+          continue;
+        }
+        if (state.braces + state.parens === 0 && prev.type !== "bos" && prev.type !== "slash") {
+          push({ type: "text", value, output: DOT_LITERAL });
+          continue;
+        }
+        push({ type: "dot", value, output: DOT_LITERAL });
+        continue;
+      }
+      if (value === "?") {
+        const isGroup = prev && prev.value === "(";
+        if (!isGroup && opts.noextglob !== true && peek() === "(" && peek(2) !== "?") {
+          extglobOpen("qmark", value);
+          continue;
+        }
+        if (prev && prev.type === "paren") {
+          const next = peek();
+          let output = value;
+          if (prev.value === "(" && !/[!=<:]/.test(next) || next === "<" && !/<([!=]|\w+>)/.test(remaining())) {
+            output = `\\${value}`;
+          }
+          push({ type: "text", value, output });
+          continue;
+        }
+        if (opts.dot !== true && (prev.type === "slash" || prev.type === "bos")) {
+          push({ type: "qmark", value, output: QMARK_NO_DOT });
+          continue;
+        }
+        push({ type: "qmark", value, output: QMARK });
+        continue;
+      }
+      if (value === "!") {
+        if (opts.noextglob !== true && peek() === "(") {
+          if (peek(2) !== "?" || !/[!=<:]/.test(peek(3))) {
+            extglobOpen("negate", value);
+            continue;
+          }
+        }
+        if (opts.nonegate !== true && state.index === 0) {
+          negate();
+          continue;
+        }
+      }
+      if (value === "+") {
+        if (opts.noextglob !== true && peek() === "(" && peek(2) !== "?") {
+          extglobOpen("plus", value);
+          continue;
+        }
+        if (prev && prev.value === "(" || opts.regex === false) {
+          push({ type: "plus", value, output: PLUS_LITERAL });
+          continue;
+        }
+        if (prev && (prev.type === "bracket" || prev.type === "paren" || prev.type === "brace") || state.parens > 0) {
+          push({ type: "plus", value });
+          continue;
+        }
+        push({ type: "plus", value: PLUS_LITERAL });
+        continue;
+      }
+      if (value === "@") {
+        if (opts.noextglob !== true && peek() === "(" && peek(2) !== "?") {
+          push({ type: "at", extglob: true, value, output: "" });
+          continue;
+        }
+        push({ type: "text", value });
+        continue;
+      }
+      if (value !== "*") {
+        if (value === "$" || value === "^") {
+          value = `\\${value}`;
+        }
+        const match = REGEX_NON_SPECIAL_CHARS.exec(remaining());
+        if (match) {
+          value += match[0];
+          state.index += match[0].length;
+        }
+        push({ type: "text", value });
+        continue;
+      }
+      if (prev && (prev.type === "globstar" || prev.star === true)) {
+        prev.type = "star";
+        prev.star = true;
+        prev.value += value;
+        prev.output = star;
+        state.backtrack = true;
+        state.globstar = true;
+        consume(value);
+        continue;
+      }
+      let rest = remaining();
+      if (opts.noextglob !== true && /^\([^?]/.test(rest)) {
+        extglobOpen("star", value);
+        continue;
+      }
+      if (prev.type === "star") {
+        if (opts.noglobstar === true) {
+          consume(value);
+          continue;
+        }
+        const prior = prev.prev;
+        const before = prior.prev;
+        const isStart = prior.type === "slash" || prior.type === "bos";
+        const afterStar = before && (before.type === "star" || before.type === "globstar");
+        if (opts.bash === true && (!isStart || rest[0] && rest[0] !== "/")) {
+          push({ type: "star", value, output: "" });
+          continue;
+        }
+        const isBrace = state.braces > 0 && (prior.type === "comma" || prior.type === "brace");
+        const isExtglob = extglobs.length && (prior.type === "pipe" || prior.type === "paren");
+        if (!isStart && prior.type !== "paren" && !isBrace && !isExtglob) {
+          push({ type: "star", value, output: "" });
+          continue;
+        }
+        while (rest.slice(0, 3) === "/**") {
+          const after = input[state.index + 4];
+          if (after && after !== "/") {
+            break;
+          }
+          rest = rest.slice(3);
+          consume("/**", 3);
+        }
+        if (prior.type === "bos" && eos()) {
+          prev.type = "globstar";
+          prev.value += value;
+          prev.output = globstar(opts);
+          state.output = prev.output;
+          state.globstar = true;
+          consume(value);
+          continue;
+        }
+        if (prior.type === "slash" && prior.prev.type !== "bos" && !afterStar && eos()) {
+          state.output = state.output.slice(0, -(prior.output + prev.output).length);
+          prior.output = `(?:${prior.output}`;
+          prev.type = "globstar";
+          prev.output = globstar(opts) + (opts.strictSlashes ? ")" : "|$)");
+          prev.value += value;
+          state.globstar = true;
+          state.output += prior.output + prev.output;
+          consume(value);
+          continue;
+        }
+        if (prior.type === "slash" && prior.prev.type !== "bos" && rest[0] === "/") {
+          const end = rest[1] !== undefined ? "|$" : "";
+          state.output = state.output.slice(0, -(prior.output + prev.output).length);
+          prior.output = `(?:${prior.output}`;
+          prev.type = "globstar";
+          prev.output = `${globstar(opts)}${SLASH_LITERAL}|${SLASH_LITERAL}${end})`;
+          prev.value += value;
+          state.output += prior.output + prev.output;
+          state.globstar = true;
+          consume(value + advance());
+          push({ type: "slash", value: "/", output: "" });
+          continue;
+        }
+        if (prior.type === "bos" && rest[0] === "/") {
+          prev.type = "globstar";
+          prev.value += value;
+          prev.output = `(?:^|${SLASH_LITERAL}|${globstar(opts)}${SLASH_LITERAL})`;
+          state.output = prev.output;
+          state.globstar = true;
+          consume(value + advance());
+          push({ type: "slash", value: "/", output: "" });
+          continue;
+        }
+        state.output = state.output.slice(0, -prev.output.length);
+        prev.type = "globstar";
+        prev.output = globstar(opts);
+        prev.value += value;
+        state.output += prev.output;
+        state.globstar = true;
+        consume(value);
+        continue;
+      }
+      const token = { type: "star", value, output: star };
+      if (opts.bash === true) {
+        token.output = ".*?";
+        if (prev.type === "bos" || prev.type === "slash") {
+          token.output = nodot + token.output;
+        }
+        push(token);
+        continue;
+      }
+      if (prev && (prev.type === "bracket" || prev.type === "paren") && opts.regex === true) {
+        token.output = value;
+        push(token);
+        continue;
+      }
+      if (state.index === state.start || prev.type === "slash" || prev.type === "dot") {
+        if (prev.type === "dot") {
+          state.output += NO_DOT_SLASH;
+          prev.output += NO_DOT_SLASH;
+        } else if (opts.dot === true) {
+          state.output += NO_DOTS_SLASH;
+          prev.output += NO_DOTS_SLASH;
+        } else {
+          state.output += nodot;
+          prev.output += nodot;
+        }
+        if (peek() !== "*") {
+          state.output += ONE_CHAR;
+          prev.output += ONE_CHAR;
+        }
+      }
+      push(token);
+    }
+    while (state.brackets > 0) {
+      if (opts.strictBrackets === true)
+        throw new SyntaxError(syntaxError("closing", "]"));
+      state.output = utils.escapeLast(state.output, "[");
+      decrement("brackets");
+    }
+    while (state.parens > 0) {
+      if (opts.strictBrackets === true)
+        throw new SyntaxError(syntaxError("closing", ")"));
+      state.output = utils.escapeLast(state.output, "(");
+      decrement("parens");
+    }
+    while (state.braces > 0) {
+      if (opts.strictBrackets === true)
+        throw new SyntaxError(syntaxError("closing", "}"));
+      state.output = utils.escapeLast(state.output, "{");
+      decrement("braces");
+    }
+    if (opts.strictSlashes !== true && (prev.type === "star" || prev.type === "bracket")) {
+      push({ type: "maybe_slash", value: "", output: `${SLASH_LITERAL}?` });
+    }
+    if (state.backtrack === true) {
+      state.output = "";
+      for (const token of state.tokens) {
+        state.output += token.output != null ? token.output : token.value;
+        if (token.suffix) {
+          state.output += token.suffix;
+        }
+      }
+    }
+    return state;
+  };
+  parse5.fastpaths = (input, options) => {
+    const opts = { ...options };
+    const max = typeof opts.maxLength === "number" ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
+    const len = input.length;
+    if (len > max) {
+      throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
+    }
+    input = REPLACEMENTS[input] || input;
+    const {
+      DOT_LITERAL,
+      SLASH_LITERAL,
+      ONE_CHAR,
+      DOTS_SLASH,
+      NO_DOT,
+      NO_DOTS,
+      NO_DOTS_SLASH,
+      STAR,
+      START_ANCHOR
+    } = constants2.globChars(opts.windows);
+    const nodot = opts.dot ? NO_DOTS : NO_DOT;
+    const slashDot = opts.dot ? NO_DOTS_SLASH : NO_DOT;
+    const capture = opts.capture ? "" : "?:";
+    const state = { negated: false, prefix: "" };
+    let star = opts.bash === true ? ".*?" : STAR;
+    if (opts.capture) {
+      star = `(${star})`;
+    }
+    const globstar = (opts2) => {
+      if (opts2.noglobstar === true)
+        return star;
+      return `(${capture}(?:(?!${START_ANCHOR}${opts2.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
+    };
+    const create2 = (str) => {
+      switch (str) {
+        case "*":
+          return `${nodot}${ONE_CHAR}${star}`;
+        case ".*":
+          return `${DOT_LITERAL}${ONE_CHAR}${star}`;
+        case "*.*":
+          return `${nodot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;
+        case "*/*":
+          return `${nodot}${star}${SLASH_LITERAL}${ONE_CHAR}${slashDot}${star}`;
+        case "**":
+          return nodot + globstar(opts);
+        case "**/*":
+          return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${ONE_CHAR}${star}`;
+        case "**/*.*":
+          return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;
+        case "**/.*":
+          return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${DOT_LITERAL}${ONE_CHAR}${star}`;
+        default: {
+          const match = /^(.*?)\.(\w+)$/.exec(str);
+          if (!match)
+            return;
+          const source2 = create2(match[1]);
+          if (!source2)
+            return;
+          return source2 + DOT_LITERAL + match[2];
+        }
+      }
+    };
+    const output = utils.removePrefix(input, state);
+    let source = create2(output);
+    if (source && opts.strictSlashes !== true) {
+      source += `${SLASH_LITERAL}?`;
+    }
+    return source;
+  };
+  module.exports = parse5;
+});
+
+// node_modules/picomatch/lib/picomatch.js
+var require_picomatch = __commonJS((exports, module) => {
+  var scan = require_scan();
+  var parse5 = require_parse();
+  var utils = require_utils();
+  var constants2 = require_constants3();
+  var isObject2 = (val) => val && typeof val === "object" && !Array.isArray(val);
+  var picomatch = (glob, options, returnState = false) => {
+    if (Array.isArray(glob)) {
+      const fns = glob.map((input) => picomatch(input, options, returnState));
+      const arrayMatcher = (str) => {
+        for (const isMatch of fns) {
+          const state2 = isMatch(str);
+          if (state2)
+            return state2;
+        }
+        return false;
+      };
+      return arrayMatcher;
+    }
+    const isState = isObject2(glob) && glob.tokens && glob.input;
+    if (glob === "" || typeof glob !== "string" && !isState) {
+      throw new TypeError("Expected pattern to be a non-empty string");
+    }
+    const opts = options || {};
+    const posix = opts.windows;
+    const regex2 = isState ? picomatch.compileRe(glob, options) : picomatch.makeRe(glob, options, false, true);
+    const state = regex2.state;
+    delete regex2.state;
+    let isIgnored = () => false;
+    if (opts.ignore) {
+      const ignoreOpts = { ...options, ignore: null, onMatch: null, onResult: null };
+      isIgnored = picomatch(opts.ignore, ignoreOpts, returnState);
+    }
+    const matcher = (input, returnObject = false) => {
+      const { isMatch, match, output } = picomatch.test(input, regex2, options, { glob, posix });
+      const result = { glob, state, regex: regex2, posix, input, output, match, isMatch };
+      if (typeof opts.onResult === "function") {
+        opts.onResult(result);
+      }
+      if (isMatch === false) {
+        result.isMatch = false;
+        return returnObject ? result : false;
+      }
+      if (isIgnored(input)) {
+        if (typeof opts.onIgnore === "function") {
+          opts.onIgnore(result);
+        }
+        result.isMatch = false;
+        return returnObject ? result : false;
+      }
+      if (typeof opts.onMatch === "function") {
+        opts.onMatch(result);
+      }
+      return returnObject ? result : true;
+    };
+    if (returnState) {
+      matcher.state = state;
+    }
+    return matcher;
+  };
+  picomatch.test = (input, regex2, options, { glob, posix } = {}) => {
+    if (typeof input !== "string") {
+      throw new TypeError("Expected input to be a string");
+    }
+    if (input === "") {
+      return { isMatch: false, output: "" };
+    }
+    const opts = options || {};
+    const format = opts.format || (posix ? utils.toPosixSlashes : null);
+    let match = input === glob;
+    let output = match && format ? format(input) : input;
+    if (match === false) {
+      output = format ? format(input) : input;
+      match = output === glob;
+    }
+    if (match === false || opts.capture === true) {
+      if (opts.matchBase === true || opts.basename === true) {
+        match = picomatch.matchBase(input, regex2, options, posix);
+      } else {
+        match = regex2.exec(output);
+      }
+    }
+    return { isMatch: Boolean(match), match, output };
+  };
+  picomatch.matchBase = (input, glob, options) => {
+    const regex2 = glob instanceof RegExp ? glob : picomatch.makeRe(glob, options);
+    return regex2.test(utils.basename(input));
+  };
+  picomatch.isMatch = (str, patterns, options) => picomatch(patterns, options)(str);
+  picomatch.parse = (pattern, options) => {
+    if (Array.isArray(pattern))
+      return pattern.map((p) => picomatch.parse(p, options));
+    return parse5(pattern, { ...options, fastpaths: false });
+  };
+  picomatch.scan = (input, options) => scan(input, options);
+  picomatch.compileRe = (state, options, returnOutput = false, returnState = false) => {
+    if (returnOutput === true) {
+      return state.output;
+    }
+    const opts = options || {};
+    const prepend = opts.contains ? "" : "^";
+    const append = opts.contains ? "" : "$";
+    let source = `${prepend}(?:${state.output})${append}`;
+    if (state && state.negated === true) {
+      source = `^(?!${source}).*$`;
+    }
+    const regex2 = picomatch.toRegex(source, options);
+    if (returnState === true) {
+      regex2.state = state;
+    }
+    return regex2;
+  };
+  picomatch.makeRe = (input, options = {}, returnOutput = false, returnState = false) => {
+    if (!input || typeof input !== "string") {
+      throw new TypeError("Expected a non-empty string");
+    }
+    let parsed = { negated: false, fastpaths: true };
+    if (options.fastpaths !== false && (input[0] === "." || input[0] === "*")) {
+      parsed.output = parse5.fastpaths(input, options);
+    }
+    if (!parsed.output) {
+      parsed = parse5(input, options);
+    }
+    return picomatch.compileRe(parsed, options, returnOutput, returnState);
+  };
+  picomatch.toRegex = (source, options) => {
+    try {
+      const opts = options || {};
+      return new RegExp(source, opts.flags || (opts.nocase ? "i" : ""));
+    } catch (err) {
+      if (options && options.debug === true)
+        throw err;
+      return /$^/;
+    }
+  };
+  picomatch.constants = constants2;
+  module.exports = picomatch;
+});
+
+// node_modules/picomatch/index.js
+var require_picomatch2 = __commonJS((exports, module) => {
+  var pico = require_picomatch();
+  var utils = require_utils();
+  function picomatch(glob, options, returnState = false) {
+    if (options && (options.windows === null || options.windows === undefined)) {
+      options = { ...options, windows: utils.isWindows() };
+    }
+    return pico(glob, options, returnState);
+  }
+  Object.assign(picomatch, pico);
+  module.exports = picomatch;
+});
+
+// node_modules/chalk/source/vendor/ansi-styles/index.js
+var ANSI_BACKGROUND_OFFSET = 10;
+var wrapAnsi16 = (offset = 0) => (code) => `\x1B[${code + offset}m`;
+var wrapAnsi256 = (offset = 0) => (code) => `\x1B[${38 + offset};5;${code}m`;
+var wrapAnsi16m = (offset = 0) => (red, green, blue) => `\x1B[${38 + offset};2;${red};${green};${blue}m`;
+var styles = {
+  modifier: {
+    reset: [0, 0],
+    bold: [1, 22],
+    dim: [2, 22],
+    italic: [3, 23],
+    underline: [4, 24],
+    overline: [53, 55],
+    inverse: [7, 27],
+    hidden: [8, 28],
+    strikethrough: [9, 29]
+  },
+  color: {
+    black: [30, 39],
+    red: [31, 39],
+    green: [32, 39],
+    yellow: [33, 39],
+    blue: [34, 39],
+    magenta: [35, 39],
+    cyan: [36, 39],
+    white: [37, 39],
+    blackBright: [90, 39],
+    gray: [90, 39],
+    grey: [90, 39],
+    redBright: [91, 39],
+    greenBright: [92, 39],
+    yellowBright: [93, 39],
+    blueBright: [94, 39],
+    magentaBright: [95, 39],
+    cyanBright: [96, 39],
+    whiteBright: [97, 39]
+  },
+  bgColor: {
+    bgBlack: [40, 49],
+    bgRed: [41, 49],
+    bgGreen: [42, 49],
+    bgYellow: [43, 49],
+    bgBlue: [44, 49],
+    bgMagenta: [45, 49],
+    bgCyan: [46, 49],
+    bgWhite: [47, 49],
+    bgBlackBright: [100, 49],
+    bgGray: [100, 49],
+    bgGrey: [100, 49],
+    bgRedBright: [101, 49],
+    bgGreenBright: [102, 49],
+    bgYellowBright: [103, 49],
+    bgBlueBright: [104, 49],
+    bgMagentaBright: [105, 49],
+    bgCyanBright: [106, 49],
+    bgWhiteBright: [107, 49]
+  }
+};
+var modifierNames = Object.keys(styles.modifier);
+var foregroundColorNames = Object.keys(styles.color);
+var backgroundColorNames = Object.keys(styles.bgColor);
+var colorNames = [...foregroundColorNames, ...backgroundColorNames];
+function assembleStyles() {
+  const codes = new Map;
+  for (const [groupName, group] of Object.entries(styles)) {
+    for (const [styleName, style] of Object.entries(group)) {
+      styles[styleName] = {
+        open: `\x1B[${style[0]}m`,
+        close: `\x1B[${style[1]}m`
+      };
+      group[styleName] = styles[styleName];
+      codes.set(style[0], style[1]);
+    }
+    Object.defineProperty(styles, groupName, {
+      value: group,
+      enumerable: false
+    });
+  }
+  Object.defineProperty(styles, "codes", {
+    value: codes,
+    enumerable: false
+  });
+  styles.color.close = "\x1B[39m";
+  styles.bgColor.close = "\x1B[49m";
+  styles.color.ansi = wrapAnsi16();
+  styles.color.ansi256 = wrapAnsi256();
+  styles.color.ansi16m = wrapAnsi16m();
+  styles.bgColor.ansi = wrapAnsi16(ANSI_BACKGROUND_OFFSET);
+  styles.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET);
+  styles.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET);
+  Object.defineProperties(styles, {
+    rgbToAnsi256: {
+      value(red, green, blue) {
+        if (red === green && green === blue) {
+          if (red < 8) {
+            return 16;
+          }
+          if (red > 248) {
+            return 231;
+          }
+          return Math.round((red - 8) / 247 * 24) + 232;
+        }
+        return 16 + 36 * Math.round(red / 255 * 5) + 6 * Math.round(green / 255 * 5) + Math.round(blue / 255 * 5);
+      },
+      enumerable: false
+    },
+    hexToRgb: {
+      value(hex) {
+        const matches = /[a-f\d]{6}|[a-f\d]{3}/i.exec(hex.toString(16));
+        if (!matches) {
+          return [0, 0, 0];
+        }
+        let [colorString] = matches;
+        if (colorString.length === 3) {
+          colorString = [...colorString].map((character) => character + character).join("");
+        }
+        const integer = Number.parseInt(colorString, 16);
+        return [
+          integer >> 16 & 255,
+          integer >> 8 & 255,
+          integer & 255
+        ];
+      },
+      enumerable: false
+    },
+    hexToAnsi256: {
+      value: (hex) => styles.rgbToAnsi256(...styles.hexToRgb(hex)),
+      enumerable: false
+    },
+    ansi256ToAnsi: {
+      value(code) {
+        if (code < 8) {
+          return 30 + code;
+        }
+        if (code < 16) {
+          return 90 + (code - 8);
+        }
+        let red;
+        let green;
+        let blue;
+        if (code >= 232) {
+          red = ((code - 232) * 10 + 8) / 255;
+          green = red;
+          blue = red;
+        } else {
+          code -= 16;
+          const remainder = code % 36;
+          red = Math.floor(code / 36) / 5;
+          green = Math.floor(remainder / 6) / 5;
+          blue = remainder % 6 / 5;
+        }
+        const value = Math.max(red, green, blue) * 2;
+        if (value === 0) {
+          return 30;
+        }
+        let result = 30 + (Math.round(blue) << 2 | Math.round(green) << 1 | Math.round(red));
+        if (value === 2) {
+          result += 60;
+        }
+        return result;
+      },
+      enumerable: false
+    },
+    rgbToAnsi: {
+      value: (red, green, blue) => styles.ansi256ToAnsi(styles.rgbToAnsi256(red, green, blue)),
+      enumerable: false
+    },
+    hexToAnsi: {
+      value: (hex) => styles.ansi256ToAnsi(styles.hexToAnsi256(hex)),
+      enumerable: false
+    }
+  });
+  return styles;
+}
+var ansiStyles = assembleStyles();
+var ansi_styles_default = ansiStyles;
+
+// node_modules/chalk/source/vendor/supports-color/index.js
+import process2 from "node:process";
+import os from "node:os";
+import tty from "node:tty";
+function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : process2.argv) {
+  const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
+  const position = argv.indexOf(prefix + flag);
+  const terminatorPosition = argv.indexOf("--");
+  return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
+}
+var { env } = process2;
+var flagForceColor;
+if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
+  flagForceColor = 0;
+} else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
+  flagForceColor = 1;
+}
+function envForceColor() {
+  if ("FORCE_COLOR" in env) {
+    if (env.FORCE_COLOR === "true") {
+      return 1;
+    }
+    if (env.FORCE_COLOR === "false") {
+      return 0;
+    }
+    return env.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
+  }
+}
+function translateLevel(level) {
+  if (level === 0) {
+    return false;
+  }
+  return {
+    level,
+    hasBasic: true,
+    has256: level >= 2,
+    has16m: level >= 3
+  };
+}
+function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
+  const noFlagForceColor = envForceColor();
+  if (noFlagForceColor !== undefined) {
+    flagForceColor = noFlagForceColor;
+  }
+  const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
+  if (forceColor === 0) {
+    return 0;
+  }
+  if (sniffFlags) {
+    if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
+      return 3;
+    }
+    if (hasFlag("color=256")) {
+      return 2;
+    }
+  }
+  if ("TF_BUILD" in env && "AGENT_NAME" in env) {
+    return 1;
+  }
+  if (haveStream && !streamIsTTY && forceColor === undefined) {
+    return 0;
+  }
+  const min = forceColor || 0;
+  if (env.TERM === "dumb") {
+    return min;
+  }
+  if (process2.platform === "win32") {
+    const osRelease = os.release().split(".");
+    if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
+      return Number(osRelease[2]) >= 14931 ? 3 : 2;
+    }
+    return 1;
+  }
+  if ("CI" in env) {
+    if (["GITHUB_ACTIONS", "GITEA_ACTIONS", "CIRCLECI"].some((key) => (key in env))) {
+      return 3;
+    }
+    if (["TRAVIS", "APPVEYOR", "GITLAB_CI", "BUILDKITE", "DRONE"].some((sign) => (sign in env)) || env.CI_NAME === "codeship") {
+      return 1;
+    }
+    return min;
+  }
+  if ("TEAMCITY_VERSION" in env) {
+    return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+  }
+  if (env.COLORTERM === "truecolor") {
+    return 3;
+  }
+  if (env.TERM === "xterm-kitty") {
+    return 3;
+  }
+  if (env.TERM === "xterm-ghostty") {
+    return 3;
+  }
+  if ("TERM_PROGRAM" in env) {
+    const version = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+    switch (env.TERM_PROGRAM) {
+      case "iTerm.app": {
+        return version >= 3 ? 3 : 2;
+      }
+      case "Apple_Terminal": {
+        return 2;
+      }
+    }
+  }
+  if (/-256(color)?$/i.test(env.TERM)) {
+    return 2;
+  }
+  if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
+    return 1;
+  }
+  if ("COLORTERM" in env) {
+    return 1;
+  }
+  return min;
+}
+function createSupportsColor(stream, options = {}) {
+  const level = _supportsColor(stream, {
+    streamIsTTY: stream && stream.isTTY,
+    ...options
+  });
+  return translateLevel(level);
+}
+var supportsColor = {
+  stdout: createSupportsColor({ isTTY: tty.isatty(1) }),
+  stderr: createSupportsColor({ isTTY: tty.isatty(2) })
+};
+var supports_color_default = supportsColor;
+
+// node_modules/chalk/source/utilities.js
+function stringReplaceAll(string, substring, replacer) {
+  let index = string.indexOf(substring);
+  if (index === -1) {
+    return string;
+  }
+  const substringLength = substring.length;
+  let endIndex = 0;
+  let returnValue = "";
+  do {
+    returnValue += string.slice(endIndex, index) + substring + replacer;
+    endIndex = index + substringLength;
+    index = string.indexOf(substring, endIndex);
+  } while (index !== -1);
+  returnValue += string.slice(endIndex);
+  return returnValue;
+}
+function stringEncaseCRLFWithFirstIndex(string, prefix, postfix, index) {
+  let endIndex = 0;
+  let returnValue = "";
+  do {
+    const gotCR = string[index - 1] === "\r";
+    returnValue += string.slice(endIndex, gotCR ? index - 1 : index) + prefix + (gotCR ? `\r
+` : `
+`) + postfix;
+    endIndex = index + 1;
+    index = string.indexOf(`
+`, endIndex);
+  } while (index !== -1);
+  returnValue += string.slice(endIndex);
+  return returnValue;
+}
+
+// node_modules/chalk/source/index.js
+var { stdout: stdoutColor, stderr: stderrColor } = supports_color_default;
+var GENERATOR = Symbol("GENERATOR");
+var STYLER = Symbol("STYLER");
+var IS_EMPTY = Symbol("IS_EMPTY");
+var levelMapping = [
+  "ansi",
+  "ansi",
+  "ansi256",
+  "ansi16m"
+];
+var styles2 = Object.create(null);
+var applyOptions = (object, options = {}) => {
+  if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) {
+    throw new Error("The `level` option should be an integer from 0 to 3");
+  }
+  const colorLevel = stdoutColor ? stdoutColor.level : 0;
+  object.level = options.level === undefined ? colorLevel : options.level;
+};
+var chalkFactory = (options) => {
+  const chalk = (...strings) => strings.join(" ");
+  applyOptions(chalk, options);
+  Object.setPrototypeOf(chalk, createChalk.prototype);
+  return chalk;
+};
+function createChalk(options) {
+  return chalkFactory(options);
+}
+Object.setPrototypeOf(createChalk.prototype, Function.prototype);
+for (const [styleName, style] of Object.entries(ansi_styles_default)) {
+  styles2[styleName] = {
+    get() {
+      const builder = createBuilder(this, createStyler(style.open, style.close, this[STYLER]), this[IS_EMPTY]);
+      Object.defineProperty(this, styleName, { value: builder });
+      return builder;
+    }
+  };
+}
+styles2.visible = {
+  get() {
+    const builder = createBuilder(this, this[STYLER], true);
+    Object.defineProperty(this, "visible", { value: builder });
+    return builder;
+  }
+};
+var getModelAnsi = (model, level, type, ...arguments_) => {
+  if (model === "rgb") {
+    if (level === "ansi16m") {
+      return ansi_styles_default[type].ansi16m(...arguments_);
+    }
+    if (level === "ansi256") {
+      return ansi_styles_default[type].ansi256(ansi_styles_default.rgbToAnsi256(...arguments_));
+    }
+    return ansi_styles_default[type].ansi(ansi_styles_default.rgbToAnsi(...arguments_));
+  }
+  if (model === "hex") {
+    return getModelAnsi("rgb", level, type, ...ansi_styles_default.hexToRgb(...arguments_));
+  }
+  return ansi_styles_default[type][model](...arguments_);
+};
+var usedModels = ["rgb", "hex", "ansi256"];
+for (const model of usedModels) {
+  styles2[model] = {
+    get() {
+      const { level } = this;
+      return function(...arguments_) {
+        const styler = createStyler(getModelAnsi(model, levelMapping[level], "color", ...arguments_), ansi_styles_default.color.close, this[STYLER]);
+        return createBuilder(this, styler, this[IS_EMPTY]);
+      };
+    }
+  };
+  const bgModel = "bg" + model[0].toUpperCase() + model.slice(1);
+  styles2[bgModel] = {
+    get() {
+      const { level } = this;
+      return function(...arguments_) {
+        const styler = createStyler(getModelAnsi(model, levelMapping[level], "bgColor", ...arguments_), ansi_styles_default.bgColor.close, this[STYLER]);
+        return createBuilder(this, styler, this[IS_EMPTY]);
+      };
+    }
+  };
+}
+var proto = Object.defineProperties(() => {}, {
+  ...styles2,
+  level: {
+    enumerable: true,
+    get() {
+      return this[GENERATOR].level;
+    },
+    set(level) {
+      this[GENERATOR].level = level;
+    }
+  }
+});
+var createStyler = (open, close, parent) => {
+  let openAll;
+  let closeAll;
+  if (parent === undefined) {
+    openAll = open;
+    closeAll = close;
+  } else {
+    openAll = parent.openAll + open;
+    closeAll = close + parent.closeAll;
+  }
+  return {
+    open,
+    close,
+    openAll,
+    closeAll,
+    parent
+  };
+};
+var createBuilder = (self2, _styler, _isEmpty) => {
+  const builder = (...arguments_) => applyStyle(builder, arguments_.length === 1 ? "" + arguments_[0] : arguments_.join(" "));
+  Object.setPrototypeOf(builder, proto);
+  builder[GENERATOR] = self2;
+  builder[STYLER] = _styler;
+  builder[IS_EMPTY] = _isEmpty;
+  return builder;
+};
+var applyStyle = (self2, string) => {
+  if (self2.level <= 0 || !string) {
+    return self2[IS_EMPTY] ? "" : string;
+  }
+  let styler = self2[STYLER];
+  if (styler === undefined) {
+    return string;
+  }
+  const { openAll, closeAll } = styler;
+  if (string.includes("\x1B")) {
+    while (styler !== undefined) {
+      string = stringReplaceAll(string, styler.close, styler.open);
+      styler = styler.parent;
+    }
+  }
+  const lfIndex = string.indexOf(`
+`);
+  if (lfIndex !== -1) {
+    string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex);
+  }
+  return openAll + string + closeAll;
+};
+Object.defineProperties(createChalk.prototype, styles2);
+var chalk = createChalk();
+var chalkStderr = createChalk({ level: stderrColor ? stderrColor.level : 0 });
+var source_default = chalk;
+
+// node_modules/ink/build/render.js
+import { Stream } from "node:stream";
+import process12 from "node:process";
+
+// node_modules/ink/build/ink.js
+var import_react13 = __toESM(require_react(), 1);
+import process11 from "node:process";
+
+// node_modules/es-toolkit/dist/function/debounce.mjs
+function debounce(func, debounceMs, { signal, edges } = {}) {
+  let pendingThis = undefined;
+  let pendingArgs = null;
+  const leading = edges != null && edges.includes("leading");
+  const trailing = edges == null || edges.includes("trailing");
+  const invoke = () => {
+    if (pendingArgs !== null) {
+      func.apply(pendingThis, pendingArgs);
+      pendingThis = undefined;
+      pendingArgs = null;
+    }
+  };
+  const onTimerEnd = () => {
+    if (trailing) {
+      invoke();
+    }
+    cancel();
+  };
+  let timeoutId = null;
+  const schedule = () => {
+    if (timeoutId != null) {
+      clearTimeout(timeoutId);
+    }
+    timeoutId = setTimeout(() => {
+      timeoutId = null;
+      onTimerEnd();
+    }, debounceMs);
+  };
+  const cancelTimer = () => {
+    if (timeoutId !== null) {
+      clearTimeout(timeoutId);
+      timeoutId = null;
+    }
+  };
+  const cancel = () => {
+    cancelTimer();
+    pendingThis = undefined;
+    pendingArgs = null;
+  };
+  const flush = () => {
+    invoke();
+  };
+  const debounced = function(...args) {
+    if (signal?.aborted) {
+      return;
+    }
+    pendingThis = this;
+    pendingArgs = args;
+    const isFirstCall = timeoutId == null;
+    schedule();
+    if (leading && isFirstCall) {
+      invoke();
+    }
+  };
+  debounced.schedule = schedule;
+  debounced.cancel = cancel;
+  debounced.flush = flush;
+  signal?.addEventListener("abort", cancel, { once: true });
+  return debounced;
+}
+
+// node_modules/es-toolkit/dist/compat/function/debounce.mjs
+function debounce2(func, debounceMs = 0, options = {}) {
+  if (typeof options !== "object") {
+    options = {};
+  }
+  const { leading = false, trailing = true, maxWait } = options;
+  const edges = Array(2);
+  if (leading) {
+    edges[0] = "leading";
+  }
+  if (trailing) {
+    edges[1] = "trailing";
+  }
+  let result = undefined;
+  let pendingAt = null;
+  const _debounced = debounce(function(...args) {
+    result = func.apply(this, args);
+    pendingAt = null;
+  }, debounceMs, { edges });
+  const debounced = function(...args) {
+    if (maxWait != null) {
+      if (pendingAt === null) {
+        pendingAt = Date.now();
+      }
+      if (Date.now() - pendingAt >= maxWait) {
+        result = func.apply(this, args);
+        pendingAt = Date.now();
+        _debounced.cancel();
+        _debounced.schedule();
+        return result;
+      }
+    }
+    _debounced.apply(this, args);
+    return result;
+  };
+  const flush = () => {
+    _debounced.flush();
+    return result;
+  };
+  debounced.cancel = _debounced.cancel;
+  debounced.flush = flush;
+  return debounced;
+}
+
+// node_modules/es-toolkit/dist/compat/function/throttle.mjs
+function throttle(func, throttleMs = 0, options = {}) {
+  const { leading = true, trailing = true } = options;
+  return debounce2(func, throttleMs, {
+    leading,
+    maxWait: throttleMs,
+    trailing
+  });
+}
+// node_modules/ansi-escapes/base.js
+var exports_base = {};
+__export(exports_base, {
+  scrollUp: () => scrollUp,
+  scrollDown: () => scrollDown,
+  link: () => link,
+  image: () => image,
+  iTerm: () => iTerm,
+  exitAlternativeScreen: () => exitAlternativeScreen,
+  eraseUp: () => eraseUp,
+  eraseStartLine: () => eraseStartLine,
+  eraseScreen: () => eraseScreen,
+  eraseLines: () => eraseLines,
+  eraseLine: () => eraseLine,
+  eraseEndLine: () => eraseEndLine,
+  eraseDown: () => eraseDown,
+  enterAlternativeScreen: () => enterAlternativeScreen,
+  cursorUp: () => cursorUp,
+  cursorTo: () => cursorTo,
+  cursorShow: () => cursorShow,
+  cursorSavePosition: () => cursorSavePosition,
+  cursorRestorePosition: () => cursorRestorePosition,
+  cursorPrevLine: () => cursorPrevLine,
+  cursorNextLine: () => cursorNextLine,
+  cursorMove: () => cursorMove,
+  cursorLeft: () => cursorLeft,
+  cursorHide: () => cursorHide,
+  cursorGetPosition: () => cursorGetPosition,
+  cursorForward: () => cursorForward,
+  cursorDown: () => cursorDown,
+  cursorBackward: () => cursorBackward,
+  clearTerminal: () => clearTerminal,
+  clearScreen: () => clearScreen,
+  beep: () => beep
+});
+import process3 from "node:process";
+
+// node_modules/environment/index.js
+var isBrowser = globalThis.window?.document !== undefined;
+var isNode = globalThis.process?.versions?.node !== undefined;
+var isBun = globalThis.process?.versions?.bun !== undefined;
+var isDeno = globalThis.Deno?.version?.deno !== undefined;
+var isElectron = globalThis.process?.versions?.electron !== undefined;
+var isJsDom = globalThis.navigator?.userAgent?.includes("jsdom") === true;
+var isWebWorker = typeof WorkerGlobalScope !== "undefined" && globalThis instanceof WorkerGlobalScope;
+var isDedicatedWorker = typeof DedicatedWorkerGlobalScope !== "undefined" && globalThis instanceof DedicatedWorkerGlobalScope;
+var isSharedWorker = typeof SharedWorkerGlobalScope !== "undefined" && globalThis instanceof SharedWorkerGlobalScope;
+var isServiceWorker = typeof ServiceWorkerGlobalScope !== "undefined" && globalThis instanceof ServiceWorkerGlobalScope;
+var platform = globalThis.navigator?.userAgentData?.platform;
+var isMacOs = platform === "macOS" || globalThis.navigator?.platform === "MacIntel" || globalThis.navigator?.userAgent?.includes(" Mac ") === true || globalThis.process?.platform === "darwin";
+var isWindows = platform === "Windows" || globalThis.navigator?.platform === "Win32" || globalThis.process?.platform === "win32";
+var isLinux = platform === "Linux" || globalThis.navigator?.platform?.startsWith("Linux") === true || globalThis.navigator?.userAgent?.includes(" Linux ") === true || globalThis.process?.platform === "linux";
+var isIos = platform === "iOS" || globalThis.navigator?.platform === "MacIntel" && globalThis.navigator?.maxTouchPoints > 1 || /iPad|iPhone|iPod/.test(globalThis.navigator?.platform);
+var isAndroid = platform === "Android" || globalThis.navigator?.platform === "Android" || globalThis.navigator?.userAgent?.includes(" Android ") === true || globalThis.process?.platform === "android";
+
+// node_modules/ansi-escapes/base.js
 var ESC = "\x1B[";
 var OSC = "\x1B]";
 var BEL = "\x07";
@@ -49105,11 +50552,12 @@ var WidgetItemSchema = exports_external.object({
   maxWidth: exports_external.number().optional(),
   preserveColors: exports_external.boolean().optional(),
   timeout: exports_external.number().optional(),
-  merge: exports_external.union([exports_external.boolean(), exports_external.literal("no-padding")]).optional()
+  merge: exports_external.union([exports_external.boolean(), exports_external.literal("no-padding")]).optional(),
+  metadata: exports_external.record(exports_external.string(), exports_external.string()).optional()
 });
 
 // src/types/Settings.ts
-var CURRENT_VERSION = 2;
+var CURRENT_VERSION = 3;
 var SettingsSchema_v1 = exports_external.object({
   lines: exports_external.array(exports_external.array(WidgetItemSchema)).optional(),
   flexMode: FlexModeSchema.optional(),
@@ -49232,6 +50680,20 @@ var migrations = [
       };
       return migrated;
     }
+  },
+  {
+    fromVersion: 2,
+    toVersion: 3,
+    description: "Migrate from v2 to v3",
+    migrate: (data) => {
+      const migrated = { ...data };
+      migrated.version = 3;
+      migrated.updatemessage = {
+        message: "ccstatusline updated to v2.0.2, 5hr block timer widget added",
+        remaining: 12
+      };
+      return migrated;
+    }
   }
 ];
 function detectVersion(data) {
@@ -49573,7 +51035,7 @@ import { execSync as execSync3 } from "child_process";
 import * as fs5 from "fs";
 import * as path4 from "path";
 var __dirname = "/Users/sirmalloc/Projects/Personal/ccstatusline/src/utils";
-var PACKAGE_VERSION = "2.0.1";
+var PACKAGE_VERSION = "2.0.3";
 function getPackageVersion() {
   if (/^\d+\.\d+\.\d+/.test(PACKAGE_VERSION)) {
     return PACKAGE_VERSION;
@@ -50407,6 +51869,9 @@ class ModelWidget {
   getDefaultColor() {
     return "cyan";
   }
+  getDescription() {
+    return "Displays the Claude model name (e.g., Claude 3.5 Sonnet)";
+  }
   getDisplayName() {
     return "Model";
   }
@@ -50433,6 +51898,9 @@ class OutputStyleWidget {
   getDefaultColor() {
     return "cyan";
   }
+  getDescription() {
+    return "Shows the current Claude Code output style";
+  }
   getDisplayName() {
     return "Output Style";
   }
@@ -50461,6 +51929,9 @@ class GitBranchWidget {
   getDefaultColor() {
     return "magenta";
   }
+  getDescription() {
+    return "Shows the current git branch name";
+  }
   getDisplayName() {
     return "Git Branch";
   }
@@ -50501,6 +51972,9 @@ class GitChangesWidget {
   getDefaultColor() {
     return "yellow";
   }
+  getDescription() {
+    return "Shows git changes count (+insertions, -deletions)";
+  }
   getDisplayName() {
     return "Git Changes";
   }
@@ -50554,10 +52028,7 @@ class GitChangesWidget {
   }
 }
 // src/utils/renderer.ts
-import * as fs6 from "fs";
-import { promisify } from "util";
 var ANSI_REGEX = new RegExp(`\\x1b\\[[0-9;]*m`, "g");
-var readFile4 = promisify(fs6.readFile);
 function formatTokens(count) {
   if (count >= 1e6)
     return `${(count / 1e6).toFixed(1)}M`;
@@ -50565,100 +52036,6 @@ function formatTokens(count) {
     return `${(count / 1000).toFixed(1)}k`;
   return count.toString();
 }
-async function getSessionDuration(transcriptPath) {
-  try {
-    if (!fs6.existsSync(transcriptPath)) {
-      return null;
-    }
-    const content = await readFile4(transcriptPath, "utf-8");
-    const lines = content.trim().split(`
-`).filter((line) => line.trim());
-    if (lines.length === 0) {
-      return null;
-    }
-    let firstTimestamp = null;
-    let lastTimestamp = null;
-    for (const line of lines) {
-      try {
-        const data = JSON.parse(line);
-        if (data.timestamp) {
-          firstTimestamp = new Date(data.timestamp);
-          break;
-        }
-      } catch {}
-    }
-    for (let i = lines.length - 1;i >= 0; i--) {
-      try {
-        const data = JSON.parse(lines[i] ?? "");
-        if (data.timestamp) {
-          lastTimestamp = new Date(data.timestamp);
-          break;
-        }
-      } catch {}
-    }
-    if (!firstTimestamp || !lastTimestamp) {
-      return null;
-    }
-    const durationMs = lastTimestamp.getTime() - firstTimestamp.getTime();
-    const totalMinutes = Math.floor(durationMs / (1000 * 60));
-    if (totalMinutes < 1) {
-      return "<1m";
-    }
-    const hours = Math.floor(totalMinutes / 60);
-    const minutes = totalMinutes % 60;
-    if (hours === 0) {
-      return `${minutes}m`;
-    } else if (minutes === 0) {
-      return `${hours}hr`;
-    } else {
-      return `${hours}hr ${minutes}m`;
-    }
-  } catch {
-    return null;
-  }
-}
-async function getTokenMetrics(transcriptPath) {
-  try {
-    if (!fs6.existsSync(transcriptPath)) {
-      return { inputTokens: 0, outputTokens: 0, cachedTokens: 0, totalTokens: 0, contextLength: 0 };
-    }
-    const content = await readFile4(transcriptPath, "utf-8");
-    const lines = content.trim().split(`
-`);
-    let inputTokens = 0;
-    let outputTokens = 0;
-    let cachedTokens = 0;
-    let contextLength = 0;
-    let mostRecentMainChainEntry = null;
-    let mostRecentTimestamp = null;
-    for (const line of lines) {
-      try {
-        const data = JSON.parse(line);
-        if (data.message?.usage) {
-          inputTokens += data.message.usage.input_tokens || 0;
-          outputTokens += data.message.usage.output_tokens || 0;
-          cachedTokens += data.message.usage.cache_read_input_tokens ?? 0;
-          cachedTokens += data.message.usage.cache_creation_input_tokens ?? 0;
-          if (data.isSidechain !== true && data.timestamp) {
-            const entryTime = new Date(data.timestamp);
-            if (!mostRecentTimestamp || entryTime > mostRecentTimestamp) {
-              mostRecentTimestamp = entryTime;
-              mostRecentMainChainEntry = data;
-            }
-          }
-        }
-      } catch {}
-    }
-    if (mostRecentMainChainEntry?.message?.usage) {
-      const usage = mostRecentMainChainEntry.message.usage;
-      contextLength = (usage.input_tokens || 0) + (usage.cache_read_input_tokens ?? 0) + (usage.cache_creation_input_tokens ?? 0);
-    }
-    const totalTokens = inputTokens + outputTokens + cachedTokens;
-    return { inputTokens, outputTokens, cachedTokens, totalTokens, contextLength };
-  } catch {
-    return { inputTokens: 0, outputTokens: 0, cachedTokens: 0, totalTokens: 0, contextLength: 0 };
-  }
-}
 function renderPowerlineStatusLine(widgets, settings, context, lineIndex = 0, globalSeparatorOffset = 0) {
   const powerlineConfig = settings.powerline;
   const config2 = powerlineConfig ?? {};
@@ -51198,6 +52575,9 @@ class TokensInputWidget {
   getDefaultColor() {
     return "blue";
   }
+  getDescription() {
+    return "Shows input token count for the current session";
+  }
   getDisplayName() {
     return "Tokens Input";
   }
@@ -51224,6 +52604,9 @@ class TokensOutputWidget {
   getDefaultColor() {
     return "white";
   }
+  getDescription() {
+    return "Shows output token count for the current session";
+  }
   getDisplayName() {
     return "Tokens Output";
   }
@@ -51250,6 +52633,9 @@ class TokensCachedWidget {
   getDefaultColor() {
     return "cyan";
   }
+  getDescription() {
+    return "Shows cached token count for the current session";
+  }
   getDisplayName() {
     return "Tokens Cached";
   }
@@ -51276,6 +52662,9 @@ class TokensTotalWidget {
   getDefaultColor() {
     return "cyan";
   }
+  getDescription() {
+    return "Shows total token count (input + output + cache) for the current session";
+  }
   getDisplayName() {
     return "Tokens Total";
   }
@@ -51302,6 +52691,9 @@ class ContextLengthWidget {
   getDefaultColor() {
     return "brightBlack";
   }
+  getDescription() {
+    return "Shows the current context window size in tokens";
+  }
   getDisplayName() {
     return "Context Length";
   }
@@ -51328,6 +52720,9 @@ class ContextPercentageWidget {
   getDefaultColor() {
     return "blue";
   }
+  getDescription() {
+    return "Shows percentage of context window used (of 200k tokens)";
+  }
   getDisplayName() {
     return "Context %";
   }
@@ -51355,6 +52750,9 @@ class ContextPercentageUsableWidget {
   getDefaultColor() {
     return "green";
   }
+  getDescription() {
+    return "Shows percentage of usable context window used (of 160k tokens before auto-compact)";
+  }
   getDisplayName() {
     return "Context % (usable)";
   }
@@ -51382,6 +52780,9 @@ class SessionClockWidget {
   getDefaultColor() {
     return "yellow";
   }
+  getDescription() {
+    return "Shows elapsed time since current session started";
+  }
   getDisplayName() {
     return "Session Clock";
   }
@@ -51408,6 +52809,9 @@ class TerminalWidthWidget {
   getDefaultColor() {
     return "gray";
   }
+  getDescription() {
+    return "Shows current terminal width in columns";
+  }
   getDisplayName() {
     return "Terminal Width";
   }
@@ -51436,6 +52840,9 @@ class VersionWidget {
   getDefaultColor() {
     return "gray";
   }
+  getDescription() {
+    return "Shows Claude Code CLI version number";
+  }
   getDisplayName() {
     return "Version";
   }
@@ -51465,6 +52872,9 @@ class CustomTextWidget {
   getDefaultColor() {
     return "white";
   }
+  getDescription() {
+    return "Displays user-defined custom text";
+  }
   getDisplayName() {
     return "Custom Text";
   }
@@ -51553,10 +52963,12 @@ var import_react30 = __toESM(require_react(), 1);
 var jsx_dev_runtime2 = __toESM(require_jsx_dev_runtime(), 1);
 
 class CustomCommandWidget {
-  currentAction = "edit-command";
   getDefaultColor() {
     return "white";
   }
+  getDescription() {
+    return "Executes a custom shell command and displays output";
+  }
   getDisplayName() {
     return "Custom Command";
   }
@@ -51579,8 +52991,11 @@ class CustomCommandWidget {
       modifierText: modifiers.length > 0 ? `(${modifiers.join(", ")})` : undefined
     };
   }
-  setEditorAction(action) {
-    this.currentAction = action;
+  handleEditorAction(action, item) {
+    if (action === "toggle-preserve") {
+      return { ...item, preserveColors: !item.preserveColors };
+    }
+    return null;
   }
   render(item, context, settings) {
     if (context.isPreview) {
@@ -51633,8 +53048,7 @@ class CustomCommandWidget {
   }
   renderEditor(props) {
     return /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(CustomCommandEditor, {
-      ...props,
-      action: this.currentAction
+      ...props
     }, undefined, false, undefined, this);
   }
   supportsRawValue() {
@@ -51781,6 +53195,108 @@ var CustomCommandEditor = ({ widget, onComplete, onCancel, action }) => {
     children: "Unknown editor mode"
   }, undefined, false, undefined, this);
 };
+// src/widgets/BlockTimer.ts
+class BlockTimerWidget {
+  getDefaultColor() {
+    return "yellow";
+  }
+  getDescription() {
+    return "Shows elapsed time since beginning of current 5hr block";
+  }
+  getDisplayName() {
+    return "Block Timer";
+  }
+  getEditorDisplay(item) {
+    const mode = item.metadata?.display ?? "time";
+    const modifiers = [];
+    if (mode === "progress") {
+      modifiers.push("progress bar");
+    } else if (mode === "progress-short") {
+      modifiers.push("short bar");
+    }
+    return {
+      displayText: this.getDisplayName(),
+      modifierText: modifiers.length > 0 ? `(${modifiers.join(", ")})` : undefined
+    };
+  }
+  handleEditorAction(action, item) {
+    if (action === "toggle-progress") {
+      const currentMode = item.metadata?.display ?? "time";
+      let nextMode;
+      if (currentMode === "time") {
+        nextMode = "progress";
+      } else if (currentMode === "progress") {
+        nextMode = "progress-short";
+      } else {
+        nextMode = "time";
+      }
+      return {
+        ...item,
+        metadata: {
+          ...item.metadata,
+          display: nextMode
+        }
+      };
+    }
+    return null;
+  }
+  render(item, context, settings) {
+    const displayMode = item.metadata?.display ?? "time";
+    if (context.isPreview) {
+      if (displayMode === "progress") {
+        return "Block [██████████████████████░░░░░░░░] 73.9%";
+      } else if (displayMode === "progress-short") {
+        return "Block [███████░░░░░░░░] 73.9%";
+      }
+      return item.rawValue ? "3hr 45m" : "Block: 3hr 45m";
+    }
+    const blockInfo = context.blockMetrics;
+    if (!blockInfo) {
+      return null;
+    }
+    try {
+      const now = new Date;
+      const elapsedMs = now.getTime() - blockInfo.startTime.getTime();
+      const sessionDurationMs = 5 * 60 * 60 * 1000;
+      const progress = Math.min(elapsedMs / sessionDurationMs, 1);
+      const percentage = (progress * 100).toFixed(1);
+      if (displayMode === "progress" || displayMode === "progress-short") {
+        const barWidth = displayMode === "progress" ? 32 : 16;
+        const filledWidth = Math.floor(progress * barWidth);
+        const emptyWidth = barWidth - filledWidth;
+        const progressBar = "█".repeat(filledWidth) + "░".repeat(emptyWidth);
+        if (item.rawValue) {
+          return `[${progressBar}] ${percentage}%`;
+        } else {
+          return `Block [${progressBar}] ${percentage}%`;
+        }
+      } else {
+        const elapsedHours = Math.floor(elapsedMs / (1000 * 60 * 60));
+        const elapsedMinutes = Math.floor(elapsedMs % (1000 * 60 * 60) / (1000 * 60));
+        let timeString;
+        if (elapsedMinutes === 0) {
+          timeString = `${elapsedHours}hr`;
+        } else {
+          timeString = `${elapsedHours}hr ${elapsedMinutes}m`;
+        }
+        return item.rawValue ? timeString : `Block: ${timeString}`;
+      }
+    } catch {
+      return null;
+    }
+  }
+  getCustomKeybinds() {
+    return [
+      { key: "p", label: "(p)rogress toggle", action: "toggle-progress" }
+    ];
+  }
+  supportsRawValue() {
+    return true;
+  }
+  supportsColors(item) {
+    return true;
+  }
+}
 // src/utils/widgets.ts
 var widgetRegistry = new Map([
   ["model", new ModelWidget],
@@ -51795,6 +53311,7 @@ var widgetRegistry = new Map([
   ["context-percentage", new ContextPercentageWidget],
   ["context-percentage-usable", new ContextPercentageUsableWidget],
   ["session-clock", new SessionClockWidget],
+  ["block-timer", new BlockTimerWidget],
   ["terminal-width", new TerminalWidthWidget],
   ["version", new VersionWidget],
   ["custom-text", new CustomTextWidget],
@@ -53101,7 +54618,7 @@ var ItemsEditor = ({ widgets, onUpdate, onBack, lineNumber, settings }) => {
             nextMergeState = undefined;
           }
           if (nextMergeState === undefined) {
-            const { merge: _merge, ...rest } = currentWidget2;
+            const { merge: merge2, ...rest } = currentWidget2;
             newWidgets[selectedIndex] = rest;
           } else {
             newWidgets[selectedIndex] = { ...currentWidget2, merge: nextMergeState };
@@ -53119,15 +54636,17 @@ var ItemsEditor = ({ widgets, onUpdate, onBack, lineNumber, settings }) => {
               const customKeybinds2 = widgetImpl.getCustomKeybinds();
               const matchedKeybind = customKeybinds2.find((kb) => kb.key === input);
               if (matchedKeybind) {
-                if (matchedKeybind.action === "toggle-preserve") {
-                  const newWidgets = [...widgets];
-                  newWidgets[selectedIndex] = { ...currentWidget2, preserveColors: !currentWidget2.preserveColors };
-                  onUpdate(newWidgets);
-                } else if (widgetImpl.renderEditor) {
-                  if (widgetImpl.setEditorAction) {
-                    widgetImpl.setEditorAction(matchedKeybind.action);
+                if (widgetImpl.handleEditorAction) {
+                  const updatedWidget = widgetImpl.handleEditorAction(matchedKeybind.action, currentWidget2);
+                  if (updatedWidget) {
+                    const newWidgets = [...widgets];
+                    newWidgets[selectedIndex] = updatedWidget;
+                    onUpdate(newWidgets);
+                  } else if (widgetImpl.renderEditor) {
+                    setCustomEditorWidget({ widget: currentWidget2, impl: widgetImpl, action: matchedKeybind.action });
                   }
-                  setCustomEditorWidget({ widget: currentWidget2, impl: widgetImpl });
+                } else if (widgetImpl.renderEditor) {
+                  setCustomEditorWidget({ widget: currentWidget2, impl: widgetImpl, action: matchedKeybind.action });
                 }
               }
             }
@@ -53185,7 +54704,8 @@ var ItemsEditor = ({ widgets, onUpdate, onBack, lineNumber, settings }) => {
     return customEditorWidget.impl.renderEditor({
       widget: customEditorWidget.widget,
       onComplete: handleEditorComplete,
-      onCancel: handleEditorCancel
+      onCancel: handleEditorCancel,
+      action: customEditorWidget.action
     });
   }
   return /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(Box_default, {
@@ -53219,9 +54739,13 @@ var ItemsEditor = ({ widgets, onUpdate, onBack, lineNumber, settings }) => {
           }, undefined, false, undefined, this)
         ]
       }, undefined, true, undefined, this),
-      moveMode ? /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(Text, {
-        dimColor: true,
-        children: "↑↓ to move item, ESC or Enter to exit move mode"
+      moveMode ? /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(Box_default, {
+        flexDirection: "column",
+        marginBottom: 1,
+        children: /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(Text, {
+          dimColor: true,
+          children: "↑↓ to move item, ESC or Enter to exit move mode"
+        }, undefined, false, undefined, this)
       }, undefined, false, undefined, this) : /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(Box_default, {
         flexDirection: "column",
         children: [
@@ -53254,43 +54778,72 @@ var ItemsEditor = ({ widgets, onUpdate, onBack, lineNumber, settings }) => {
         children: widgets.length === 0 ? /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(Text, {
           dimColor: true,
           children: "No items. Press 'a' to add one."
-        }, undefined, false, undefined, this) : widgets.map((widget, index) => {
-          const isSelected = index === selectedIndex;
-          const widgetImpl = widget.type !== "separator" && widget.type !== "flex-separator" ? getWidget(widget.type) : null;
-          const { displayText, modifierText } = widgetImpl?.getEditorDisplay(widget) ?? { displayText: getWidgetDisplay(widget) };
-          return /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(Box_default, {
-            children: /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(Text, {
-              children: [
-                /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(Text, {
-                  color: isSelected ? moveMode ? "blue" : "green" : undefined,
-                  children: [
-                    isSelected ? moveMode ? "◆ " : "▶ " : "  ",
-                    ` ${index + 1}. ${displayText || getWidgetDisplay(widget)}`
-                  ]
-                }, undefined, true, undefined, this),
-                modifierText && /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(Text, {
-                  dimColor: true,
-                  children: [
-                    " ",
-                    modifierText
-                  ]
-                }, undefined, true, undefined, this),
-                widget.rawValue && /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(Text, {
-                  dimColor: true,
-                  children: " (raw value)"
-                }, undefined, false, undefined, this),
-                widget.merge === true && /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(Text, {
-                  dimColor: true,
-                  children: " (merged→)"
-                }, undefined, false, undefined, this),
-                widget.merge === "no-padding" && /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(Text, {
-                  dimColor: true,
-                  children: " (merged-no-pad→)"
-                }, undefined, false, undefined, this)
-              ]
-            }, undefined, true, undefined, this)
-          }, widget.id, false, undefined, this);
-        })
+        }, undefined, false, undefined, this) : /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(jsx_dev_runtime7.Fragment, {
+          children: [
+            widgets.map((widget, index) => {
+              const isSelected = index === selectedIndex;
+              const widgetImpl = widget.type !== "separator" && widget.type !== "flex-separator" ? getWidget(widget.type) : null;
+              const { displayText, modifierText } = widgetImpl?.getEditorDisplay(widget) ?? { displayText: getWidgetDisplay(widget) };
+              return /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(Box_default, {
+                flexDirection: "row",
+                flexWrap: "nowrap",
+                children: [
+                  /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(Box_default, {
+                    width: 3,
+                    children: /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(Text, {
+                      color: isSelected ? moveMode ? "blue" : "green" : undefined,
+                      children: isSelected ? moveMode ? "◆ " : "▶ " : "  "
+                    }, undefined, false, undefined, this)
+                  }, undefined, false, undefined, this),
+                  /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(Text, {
+                    color: isSelected ? moveMode ? "blue" : "green" : undefined,
+                    children: `${index + 1}. ${displayText || getWidgetDisplay(widget)}`
+                  }, undefined, false, undefined, this),
+                  modifierText && /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(Text, {
+                    dimColor: true,
+                    children: [
+                      " ",
+                      modifierText
+                    ]
+                  }, undefined, true, undefined, this),
+                  widget.rawValue && /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(Text, {
+                    dimColor: true,
+                    children: " (raw value)"
+                  }, undefined, false, undefined, this),
+                  widget.merge === true && /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(Text, {
+                    dimColor: true,
+                    children: " (merged→)"
+                  }, undefined, false, undefined, this),
+                  widget.merge === "no-padding" && /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(Text, {
+                    dimColor: true,
+                    children: " (merged-no-pad→)"
+                  }, undefined, false, undefined, this)
+                ]
+              }, widget.id, true, undefined, this);
+            }),
+            currentWidget && /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(Box_default, {
+              marginTop: 1,
+              paddingLeft: 2,
+              children: /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(Text, {
+                dimColor: true,
+                children: (() => {
+                  if (currentWidget.type === "separator") {
+                    return "A separator character between status line items";
+                  } else if (currentWidget.type === "flex-separator") {
+                    return "Expands to fill available terminal width";
+                  } else {
+                    try {
+                      const widgetImpl = getWidget(currentWidget.type);
+                      return widgetImpl.getDescription();
+                    } catch {
+                      return "Widget description not available";
+                    }
+                  }
+                })()
+              }, undefined, false, undefined, this)
+            }, undefined, false, undefined, this)
+          ]
+        }, undefined, true, undefined, this)
       }, undefined, false, undefined, this)
     ]
   }, undefined, true, undefined, this);
@@ -55355,83 +56908,1073 @@ Continue?`;
                 if (existing && !isAlreadyInstalled) {
                   message = `This will modify ~/.claude/settings.json
 
-A status line is already configured: "${existing}"
-Replace it with bunx -y ccstatusline@latest?`;
-                } else if (isAlreadyInstalled) {
-                  message = `ccstatusline is already installed in ~/.claude/settings.json
-Update it with bunx -y ccstatusline@latest?`;
-                } else {
-                  message = `This will modify ~/.claude/settings.json to add ccstatusline with bunx.
-Continue?`;
-                }
-                setConfirmDialog({
-                  message,
-                  action: async () => {
-                    await installStatusLine(true);
-                    setIsClaudeInstalled(true);
-                    setExistingStatusLine("bunx -y ccstatusline@latest");
-                    setScreen("main");
-                    setConfirmDialog(null);
-                  }
-                });
-                setScreen("confirm");
-              });
-            },
-            onCancel: () => {
-              setScreen("main");
-            }
-          }, undefined, false, undefined, this),
-          screen === "powerline" && /* @__PURE__ */ jsx_dev_runtime16.jsxDEV(PowerlineSetup, {
-            settings,
-            powerlineFontStatus,
-            onUpdate: (updatedSettings) => {
-              setSettings(updatedSettings);
-            },
-            onBack: () => {
-              setScreen("main");
-            },
-            onInstallFonts: () => {
-              setInstallingFonts(true);
-              installPowerlineFonts().then((result) => {
-                setInstallingFonts(false);
-                setFontInstallMessage(result.message);
-                checkPowerlineFontsAsync().then((asyncStatus) => {
-                  setPowerlineFontStatus(asyncStatus);
-                });
-              });
-            },
-            installingFonts,
-            fontInstallMessage,
-            onClearMessage: () => {
-              setFontInstallMessage(null);
+A status line is already configured: "${existing}"
+Replace it with bunx -y ccstatusline@latest?`;
+                } else if (isAlreadyInstalled) {
+                  message = `ccstatusline is already installed in ~/.claude/settings.json
+Update it with bunx -y ccstatusline@latest?`;
+                } else {
+                  message = `This will modify ~/.claude/settings.json to add ccstatusline with bunx.
+Continue?`;
+                }
+                setConfirmDialog({
+                  message,
+                  action: async () => {
+                    await installStatusLine(true);
+                    setIsClaudeInstalled(true);
+                    setExistingStatusLine("bunx -y ccstatusline@latest");
+                    setScreen("main");
+                    setConfirmDialog(null);
+                  }
+                });
+                setScreen("confirm");
+              });
+            },
+            onCancel: () => {
+              setScreen("main");
+            }
+          }, undefined, false, undefined, this),
+          screen === "powerline" && /* @__PURE__ */ jsx_dev_runtime16.jsxDEV(PowerlineSetup, {
+            settings,
+            powerlineFontStatus,
+            onUpdate: (updatedSettings) => {
+              setSettings(updatedSettings);
+            },
+            onBack: () => {
+              setScreen("main");
+            },
+            onInstallFonts: () => {
+              setInstallingFonts(true);
+              installPowerlineFonts().then((result) => {
+                setInstallingFonts(false);
+                setFontInstallMessage(result.message);
+                checkPowerlineFontsAsync().then((asyncStatus) => {
+                  setPowerlineFontStatus(asyncStatus);
+                });
+              });
+            },
+            installingFonts,
+            fontInstallMessage,
+            onClearMessage: () => {
+              setFontInstallMessage(null);
+            }
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+};
+function runTUI() {
+  process.stdout.write("\x1B[2J\x1B[H");
+  render_default(/* @__PURE__ */ jsx_dev_runtime16.jsxDEV(App2, {}, undefined, false, undefined, this));
+}
+// src/types/StatusJSON.ts
+var StatusJSONSchema = exports_external.looseObject({
+  hook_event_name: exports_external.string().optional(),
+  session_id: exports_external.string().optional(),
+  transcript_path: exports_external.string().optional(),
+  cwd: exports_external.string().optional(),
+  model: exports_external.object({
+    id: exports_external.string().optional(),
+    display_name: exports_external.string().optional()
+  }).optional(),
+  workspace: exports_external.object({
+    current_dir: exports_external.string().optional(),
+    project_dir: exports_external.string().optional()
+  }).optional(),
+  version: exports_external.string().optional(),
+  output_style: exports_external.object({ name: exports_external.string().optional() }).optional()
+});
+
+// src/utils/jsonl.ts
+import * as fs6 from "fs";
+import path6 from "node:path";
+
+// node_modules/tinyglobby/dist/index.mjs
+import path5, { posix } from "path";
+
+// node_modules/fdir/dist/index.mjs
+import { createRequire as createRequire2 } from "module";
+import { basename as basename2, dirname as dirname2, normalize, relative, resolve, sep } from "path";
+import * as nativeFs from "fs";
+var __require2 = /* @__PURE__ */ createRequire2(import.meta.url);
+function cleanPath(path5) {
+  let normalized = normalize(path5);
+  if (normalized.length > 1 && normalized[normalized.length - 1] === sep)
+    normalized = normalized.substring(0, normalized.length - 1);
+  return normalized;
+}
+var SLASHES_REGEX = /[\\/]/g;
+function convertSlashes(path5, separator) {
+  return path5.replace(SLASHES_REGEX, separator);
+}
+var WINDOWS_ROOT_DIR_REGEX = /^[a-z]:[\\/]$/i;
+function isRootDirectory(path5) {
+  return path5 === "/" || WINDOWS_ROOT_DIR_REGEX.test(path5);
+}
+function normalizePath(path5, options) {
+  const { resolvePaths, normalizePath: normalizePath$1, pathSeparator } = options;
+  const pathNeedsCleaning = process.platform === "win32" && path5.includes("/") || path5.startsWith(".");
+  if (resolvePaths)
+    path5 = resolve(path5);
+  if (normalizePath$1 || pathNeedsCleaning)
+    path5 = cleanPath(path5);
+  if (path5 === ".")
+    return "";
+  const needsSeperator = path5[path5.length - 1] !== pathSeparator;
+  return convertSlashes(needsSeperator ? path5 + pathSeparator : path5, pathSeparator);
+}
+function joinPathWithBasePath(filename, directoryPath) {
+  return directoryPath + filename;
+}
+function joinPathWithRelativePath(root, options) {
+  return function(filename, directoryPath) {
+    const sameRoot = directoryPath.startsWith(root);
+    if (sameRoot)
+      return directoryPath.slice(root.length) + filename;
+    else
+      return convertSlashes(relative(root, directoryPath), options.pathSeparator) + options.pathSeparator + filename;
+  };
+}
+function joinPath(filename) {
+  return filename;
+}
+function joinDirectoryPath(filename, directoryPath, separator) {
+  return directoryPath + filename + separator;
+}
+function build$7(root, options) {
+  const { relativePaths, includeBasePath } = options;
+  return relativePaths && root ? joinPathWithRelativePath(root, options) : includeBasePath ? joinPathWithBasePath : joinPath;
+}
+function pushDirectoryWithRelativePath(root) {
+  return function(directoryPath, paths) {
+    paths.push(directoryPath.substring(root.length) || ".");
+  };
+}
+function pushDirectoryFilterWithRelativePath(root) {
+  return function(directoryPath, paths, filters) {
+    const relativePath = directoryPath.substring(root.length) || ".";
+    if (filters.every((filter) => filter(relativePath, true)))
+      paths.push(relativePath);
+  };
+}
+var pushDirectory = (directoryPath, paths) => {
+  paths.push(directoryPath || ".");
+};
+var pushDirectoryFilter = (directoryPath, paths, filters) => {
+  const path5 = directoryPath || ".";
+  if (filters.every((filter) => filter(path5, true)))
+    paths.push(path5);
+};
+var empty$2 = () => {};
+function build$6(root, options) {
+  const { includeDirs, filters, relativePaths } = options;
+  if (!includeDirs)
+    return empty$2;
+  if (relativePaths)
+    return filters && filters.length ? pushDirectoryFilterWithRelativePath(root) : pushDirectoryWithRelativePath(root);
+  return filters && filters.length ? pushDirectoryFilter : pushDirectory;
+}
+var pushFileFilterAndCount = (filename, _paths, counts, filters) => {
+  if (filters.every((filter) => filter(filename, false)))
+    counts.files++;
+};
+var pushFileFilter = (filename, paths, _counts, filters) => {
+  if (filters.every((filter) => filter(filename, false)))
+    paths.push(filename);
+};
+var pushFileCount = (_filename, _paths, counts, _filters) => {
+  counts.files++;
+};
+var pushFile = (filename, paths) => {
+  paths.push(filename);
+};
+var empty$1 = () => {};
+function build$5(options) {
+  const { excludeFiles, filters, onlyCounts } = options;
+  if (excludeFiles)
+    return empty$1;
+  if (filters && filters.length)
+    return onlyCounts ? pushFileFilterAndCount : pushFileFilter;
+  else if (onlyCounts)
+    return pushFileCount;
+  else
+    return pushFile;
+}
+var getArray = (paths) => {
+  return paths;
+};
+var getArrayGroup = () => {
+  return [""].slice(0, 0);
+};
+function build$4(options) {
+  return options.group ? getArrayGroup : getArray;
+}
+var groupFiles = (groups, directory, files) => {
+  groups.push({
+    directory,
+    files,
+    dir: directory
+  });
+};
+var empty = () => {};
+function build$3(options) {
+  return options.group ? groupFiles : empty;
+}
+var resolveSymlinksAsync = function(path5, state, callback$1) {
+  const { queue, fs: fs6, options: { suppressErrors } } = state;
+  queue.enqueue();
+  fs6.realpath(path5, (error43, resolvedPath) => {
+    if (error43)
+      return queue.dequeue(suppressErrors ? null : error43, state);
+    fs6.stat(resolvedPath, (error$1, stat) => {
+      if (error$1)
+        return queue.dequeue(suppressErrors ? null : error$1, state);
+      if (stat.isDirectory() && isRecursive(path5, resolvedPath, state))
+        return queue.dequeue(null, state);
+      callback$1(stat, resolvedPath);
+      queue.dequeue(null, state);
+    });
+  });
+};
+var resolveSymlinks = function(path5, state, callback$1) {
+  const { queue, fs: fs6, options: { suppressErrors } } = state;
+  queue.enqueue();
+  try {
+    const resolvedPath = fs6.realpathSync(path5);
+    const stat = fs6.statSync(resolvedPath);
+    if (stat.isDirectory() && isRecursive(path5, resolvedPath, state))
+      return;
+    callback$1(stat, resolvedPath);
+  } catch (e) {
+    if (!suppressErrors)
+      throw e;
+  }
+};
+function build$2(options, isSynchronous) {
+  if (!options.resolveSymlinks || options.excludeSymlinks)
+    return null;
+  return isSynchronous ? resolveSymlinks : resolveSymlinksAsync;
+}
+function isRecursive(path5, resolved, state) {
+  if (state.options.useRealPaths)
+    return isRecursiveUsingRealPaths(resolved, state);
+  let parent = dirname2(path5);
+  let depth = 1;
+  while (parent !== state.root && depth < 2) {
+    const resolvedPath = state.symlinks.get(parent);
+    const isSameRoot = !!resolvedPath && (resolvedPath === resolved || resolvedPath.startsWith(resolved) || resolved.startsWith(resolvedPath));
+    if (isSameRoot)
+      depth++;
+    else
+      parent = dirname2(parent);
+  }
+  state.symlinks.set(path5, resolved);
+  return depth > 1;
+}
+function isRecursiveUsingRealPaths(resolved, state) {
+  return state.visited.includes(resolved + state.options.pathSeparator);
+}
+var onlyCountsSync = (state) => {
+  return state.counts;
+};
+var groupsSync = (state) => {
+  return state.groups;
+};
+var defaultSync = (state) => {
+  return state.paths;
+};
+var limitFilesSync = (state) => {
+  return state.paths.slice(0, state.options.maxFiles);
+};
+var onlyCountsAsync = (state, error43, callback$1) => {
+  report(error43, callback$1, state.counts, state.options.suppressErrors);
+  return null;
+};
+var defaultAsync = (state, error43, callback$1) => {
+  report(error43, callback$1, state.paths, state.options.suppressErrors);
+  return null;
+};
+var limitFilesAsync = (state, error43, callback$1) => {
+  report(error43, callback$1, state.paths.slice(0, state.options.maxFiles), state.options.suppressErrors);
+  return null;
+};
+var groupsAsync = (state, error43, callback$1) => {
+  report(error43, callback$1, state.groups, state.options.suppressErrors);
+  return null;
+};
+function report(error43, callback$1, output, suppressErrors) {
+  if (error43 && !suppressErrors)
+    callback$1(error43, output);
+  else
+    callback$1(null, output);
+}
+function build$1(options, isSynchronous) {
+  const { onlyCounts, group, maxFiles } = options;
+  if (onlyCounts)
+    return isSynchronous ? onlyCountsSync : onlyCountsAsync;
+  else if (group)
+    return isSynchronous ? groupsSync : groupsAsync;
+  else if (maxFiles)
+    return isSynchronous ? limitFilesSync : limitFilesAsync;
+  else
+    return isSynchronous ? defaultSync : defaultAsync;
+}
+var readdirOpts = { withFileTypes: true };
+var walkAsync = (state, crawlPath, directoryPath, currentDepth, callback$1) => {
+  state.queue.enqueue();
+  if (currentDepth < 0)
+    return state.queue.dequeue(null, state);
+  const { fs: fs6 } = state;
+  state.visited.push(crawlPath);
+  state.counts.directories++;
+  fs6.readdir(crawlPath || ".", readdirOpts, (error43, entries = []) => {
+    callback$1(entries, directoryPath, currentDepth);
+    state.queue.dequeue(state.options.suppressErrors ? null : error43, state);
+  });
+};
+var walkSync = (state, crawlPath, directoryPath, currentDepth, callback$1) => {
+  const { fs: fs6 } = state;
+  if (currentDepth < 0)
+    return;
+  state.visited.push(crawlPath);
+  state.counts.directories++;
+  let entries = [];
+  try {
+    entries = fs6.readdirSync(crawlPath || ".", readdirOpts);
+  } catch (e) {
+    if (!state.options.suppressErrors)
+      throw e;
+  }
+  callback$1(entries, directoryPath, currentDepth);
+};
+function build(isSynchronous) {
+  return isSynchronous ? walkSync : walkAsync;
+}
+var Queue = class {
+  count = 0;
+  constructor(onQueueEmpty) {
+    this.onQueueEmpty = onQueueEmpty;
+  }
+  enqueue() {
+    this.count++;
+    return this.count;
+  }
+  dequeue(error43, output) {
+    if (this.onQueueEmpty && (--this.count <= 0 || error43)) {
+      this.onQueueEmpty(error43, output);
+      if (error43) {
+        output.controller.abort();
+        this.onQueueEmpty = undefined;
+      }
+    }
+  }
+};
+var Counter = class {
+  _files = 0;
+  _directories = 0;
+  set files(num) {
+    this._files = num;
+  }
+  get files() {
+    return this._files;
+  }
+  set directories(num) {
+    this._directories = num;
+  }
+  get directories() {
+    return this._directories;
+  }
+  get dirs() {
+    return this._directories;
+  }
+};
+var Aborter = class {
+  aborted = false;
+  abort() {
+    this.aborted = true;
+  }
+};
+var Walker = class {
+  root;
+  isSynchronous;
+  state;
+  joinPath;
+  pushDirectory;
+  pushFile;
+  getArray;
+  groupFiles;
+  resolveSymlink;
+  walkDirectory;
+  callbackInvoker;
+  constructor(root, options, callback$1) {
+    this.isSynchronous = !callback$1;
+    this.callbackInvoker = build$1(options, this.isSynchronous);
+    this.root = normalizePath(root, options);
+    this.state = {
+      root: isRootDirectory(this.root) ? this.root : this.root.slice(0, -1),
+      paths: [""].slice(0, 0),
+      groups: [],
+      counts: new Counter,
+      options,
+      queue: new Queue((error43, state) => this.callbackInvoker(state, error43, callback$1)),
+      symlinks: /* @__PURE__ */ new Map,
+      visited: [""].slice(0, 0),
+      controller: new Aborter,
+      fs: options.fs || nativeFs
+    };
+    this.joinPath = build$7(this.root, options);
+    this.pushDirectory = build$6(this.root, options);
+    this.pushFile = build$5(options);
+    this.getArray = build$4(options);
+    this.groupFiles = build$3(options);
+    this.resolveSymlink = build$2(options, this.isSynchronous);
+    this.walkDirectory = build(this.isSynchronous);
+  }
+  start() {
+    this.pushDirectory(this.root, this.state.paths, this.state.options.filters);
+    this.walkDirectory(this.state, this.root, this.root, this.state.options.maxDepth, this.walk);
+    return this.isSynchronous ? this.callbackInvoker(this.state, null) : null;
+  }
+  walk = (entries, directoryPath, depth) => {
+    const { paths, options: { filters, resolveSymlinks: resolveSymlinks$1, excludeSymlinks, exclude, maxFiles, signal, useRealPaths, pathSeparator }, controller } = this.state;
+    if (controller.aborted || signal && signal.aborted || maxFiles && paths.length > maxFiles)
+      return;
+    const files = this.getArray(this.state.paths);
+    for (let i = 0;i < entries.length; ++i) {
+      const entry = entries[i];
+      if (entry.isFile() || entry.isSymbolicLink() && !resolveSymlinks$1 && !excludeSymlinks) {
+        const filename = this.joinPath(entry.name, directoryPath);
+        this.pushFile(filename, files, this.state.counts, filters);
+      } else if (entry.isDirectory()) {
+        let path5 = joinDirectoryPath(entry.name, directoryPath, this.state.options.pathSeparator);
+        if (exclude && exclude(entry.name, path5))
+          continue;
+        this.pushDirectory(path5, paths, filters);
+        this.walkDirectory(this.state, path5, path5, depth - 1, this.walk);
+      } else if (this.resolveSymlink && entry.isSymbolicLink()) {
+        let path5 = joinPathWithBasePath(entry.name, directoryPath);
+        this.resolveSymlink(path5, this.state, (stat, resolvedPath) => {
+          if (stat.isDirectory()) {
+            resolvedPath = normalizePath(resolvedPath, this.state.options);
+            if (exclude && exclude(entry.name, useRealPaths ? resolvedPath : path5 + pathSeparator))
+              return;
+            this.walkDirectory(this.state, resolvedPath, useRealPaths ? resolvedPath : path5 + pathSeparator, depth - 1, this.walk);
+          } else {
+            resolvedPath = useRealPaths ? resolvedPath : path5;
+            const filename = basename2(resolvedPath);
+            const directoryPath$1 = normalizePath(dirname2(resolvedPath), this.state.options);
+            resolvedPath = this.joinPath(filename, directoryPath$1);
+            this.pushFile(resolvedPath, files, this.state.counts, filters);
+          }
+        });
+      }
+    }
+    this.groupFiles(this.state.groups, directoryPath, files);
+  };
+};
+function promise2(root, options) {
+  return new Promise((resolve$1, reject) => {
+    callback(root, options, (err, output) => {
+      if (err)
+        return reject(err);
+      resolve$1(output);
+    });
+  });
+}
+function callback(root, options, callback$1) {
+  let walker = new Walker(root, options, callback$1);
+  walker.start();
+}
+function sync(root, options) {
+  const walker = new Walker(root, options);
+  return walker.start();
+}
+var APIBuilder = class {
+  constructor(root, options) {
+    this.root = root;
+    this.options = options;
+  }
+  withPromise() {
+    return promise2(this.root, this.options);
+  }
+  withCallback(cb) {
+    callback(this.root, this.options, cb);
+  }
+  sync() {
+    return sync(this.root, this.options);
+  }
+};
+var pm = null;
+try {
+  __require2.resolve("picomatch");
+  pm = __require2("picomatch");
+} catch {}
+var Builder = class {
+  globCache = {};
+  options = {
+    maxDepth: Infinity,
+    suppressErrors: true,
+    pathSeparator: sep,
+    filters: []
+  };
+  globFunction;
+  constructor(options) {
+    this.options = {
+      ...this.options,
+      ...options
+    };
+    this.globFunction = this.options.globFunction;
+  }
+  group() {
+    this.options.group = true;
+    return this;
+  }
+  withPathSeparator(separator) {
+    this.options.pathSeparator = separator;
+    return this;
+  }
+  withBasePath() {
+    this.options.includeBasePath = true;
+    return this;
+  }
+  withRelativePaths() {
+    this.options.relativePaths = true;
+    return this;
+  }
+  withDirs() {
+    this.options.includeDirs = true;
+    return this;
+  }
+  withMaxDepth(depth) {
+    this.options.maxDepth = depth;
+    return this;
+  }
+  withMaxFiles(limit) {
+    this.options.maxFiles = limit;
+    return this;
+  }
+  withFullPaths() {
+    this.options.resolvePaths = true;
+    this.options.includeBasePath = true;
+    return this;
+  }
+  withErrors() {
+    this.options.suppressErrors = false;
+    return this;
+  }
+  withSymlinks({ resolvePaths = true } = {}) {
+    this.options.resolveSymlinks = true;
+    this.options.useRealPaths = resolvePaths;
+    return this.withFullPaths();
+  }
+  withAbortSignal(signal) {
+    this.options.signal = signal;
+    return this;
+  }
+  normalize() {
+    this.options.normalizePath = true;
+    return this;
+  }
+  filter(predicate) {
+    this.options.filters.push(predicate);
+    return this;
+  }
+  onlyDirs() {
+    this.options.excludeFiles = true;
+    this.options.includeDirs = true;
+    return this;
+  }
+  exclude(predicate) {
+    this.options.exclude = predicate;
+    return this;
+  }
+  onlyCounts() {
+    this.options.onlyCounts = true;
+    return this;
+  }
+  crawl(root) {
+    return new APIBuilder(root || ".", this.options);
+  }
+  withGlobFunction(fn) {
+    this.globFunction = fn;
+    return this;
+  }
+  crawlWithOptions(root, options) {
+    this.options = {
+      ...this.options,
+      ...options
+    };
+    return new APIBuilder(root || ".", this.options);
+  }
+  glob(...patterns) {
+    if (this.globFunction)
+      return this.globWithOptions(patterns);
+    return this.globWithOptions(patterns, ...[{ dot: true }]);
+  }
+  globWithOptions(patterns, ...options) {
+    const globFn = this.globFunction || pm;
+    if (!globFn)
+      throw new Error("Please specify a glob function to use glob matching.");
+    var isMatch = this.globCache[patterns.join("\x00")];
+    if (!isMatch) {
+      isMatch = globFn(patterns, ...options);
+      this.globCache[patterns.join("\x00")] = isMatch;
+    }
+    this.options.filters.push((path5) => isMatch(path5));
+    return this;
+  }
+};
+
+// node_modules/tinyglobby/dist/index.mjs
+var import_picomatch = __toESM(require_picomatch2(), 1);
+var ONLY_PARENT_DIRECTORIES = /^(\/?\.\.)+$/;
+function getPartialMatcher(patterns, options) {
+  const patternsCount = patterns.length;
+  const patternsParts = Array(patternsCount);
+  const regexes = Array(patternsCount);
+  for (let i = 0;i < patternsCount; i++) {
+    const parts = splitPattern(patterns[i]);
+    patternsParts[i] = parts;
+    const partsCount = parts.length;
+    const partRegexes = Array(partsCount);
+    for (let j = 0;j < partsCount; j++)
+      partRegexes[j] = import_picomatch.default.makeRe(parts[j], options);
+    regexes[i] = partRegexes;
+  }
+  return (input) => {
+    const inputParts = input.split("/");
+    if (inputParts[0] === ".." && ONLY_PARENT_DIRECTORIES.test(input))
+      return true;
+    for (let i = 0;i < patterns.length; i++) {
+      const patternParts = patternsParts[i];
+      const regex2 = regexes[i];
+      const inputPatternCount = inputParts.length;
+      const minParts = Math.min(inputPatternCount, patternParts.length);
+      let j = 0;
+      while (j < minParts) {
+        const part = patternParts[j];
+        if (part.includes("/"))
+          return true;
+        const match = regex2[j].test(inputParts[j]);
+        if (!match)
+          break;
+        if (part === "**")
+          return true;
+        j++;
+      }
+      if (j === inputPatternCount)
+        return true;
+    }
+    return false;
+  };
+}
+var splitPatternOptions = { parts: true };
+function splitPattern(path$1) {
+  var _result$parts;
+  const result = import_picomatch.default.scan(path$1, splitPatternOptions);
+  return ((_result$parts = result.parts) === null || _result$parts === undefined ? undefined : _result$parts.length) ? result.parts : [path$1];
+}
+var isWin = process.platform === "win32";
+var POSIX_UNESCAPED_GLOB_SYMBOLS = /(?<!\\)([()[\]{}*?|]|^!|[!+@](?=\()|\\(?![()[\]{}!*+?@|]))/g;
+var WIN32_UNESCAPED_GLOB_SYMBOLS = /(?<!\\)([()[\]{}]|^!|[!+@](?=\())/g;
+var escapePosixPath = (path$1) => path$1.replace(POSIX_UNESCAPED_GLOB_SYMBOLS, "\\$&");
+var escapeWin32Path = (path$1) => path$1.replace(WIN32_UNESCAPED_GLOB_SYMBOLS, "\\$&");
+var escapePath = isWin ? escapeWin32Path : escapePosixPath;
+function isDynamicPattern(pattern, options) {
+  if ((options === null || options === undefined ? undefined : options.caseSensitiveMatch) === false)
+    return true;
+  const scan = import_picomatch.default.scan(pattern);
+  return scan.isGlob || scan.negated;
+}
+function log(...tasks) {
+  console.log(`[tinyglobby ${new Date().toLocaleTimeString("es")}]`, ...tasks);
+}
+var PARENT_DIRECTORY = /^(\/?\.\.)+/;
+var ESCAPING_BACKSLASHES = /\\(?=[()[\]{}!*+?@|])/g;
+var BACKSLASHES = /\\/g;
+function normalizePattern(pattern, expandDirectories, cwd2, props, isIgnore) {
+  let result = pattern;
+  if (pattern.endsWith("/"))
+    result = pattern.slice(0, -1);
+  if (!result.endsWith("*") && expandDirectories)
+    result += "/**";
+  const escapedCwd = escapePath(cwd2);
+  if (path5.isAbsolute(result.replace(ESCAPING_BACKSLASHES, "")))
+    result = posix.relative(escapedCwd, result);
+  else
+    result = posix.normalize(result);
+  const parentDirectoryMatch = PARENT_DIRECTORY.exec(result);
+  const parts = splitPattern(result);
+  if (parentDirectoryMatch === null || parentDirectoryMatch === undefined ? undefined : parentDirectoryMatch[0]) {
+    const n = (parentDirectoryMatch[0].length + 1) / 3;
+    let i = 0;
+    const cwdParts = escapedCwd.split("/");
+    while (i < n && parts[i + n] === cwdParts[cwdParts.length + i - n]) {
+      result = result.slice(0, (n - i - 1) * 3) + result.slice((n - i) * 3 + parts[i + n].length + 1) || ".";
+      i++;
+    }
+    const potentialRoot = posix.join(cwd2, parentDirectoryMatch[0].slice(i * 3));
+    if (!potentialRoot.startsWith(".") && props.root.length > potentialRoot.length) {
+      props.root = potentialRoot;
+      props.depthOffset = -n + i;
+    }
+  }
+  if (!isIgnore && props.depthOffset >= 0) {
+    var _props$commonPath;
+    (_props$commonPath = props.commonPath) !== null && _props$commonPath !== undefined || (props.commonPath = parts);
+    const newCommonPath = [];
+    const length = Math.min(props.commonPath.length, parts.length);
+    for (let i = 0;i < length; i++) {
+      const part = parts[i];
+      if (part === "**" && !parts[i + 1]) {
+        newCommonPath.pop();
+        break;
+      }
+      if (part !== props.commonPath[i] || isDynamicPattern(part) || i === parts.length - 1)
+        break;
+      newCommonPath.push(part);
+    }
+    props.depthOffset = newCommonPath.length;
+    props.commonPath = newCommonPath;
+    props.root = newCommonPath.length > 0 ? path5.posix.join(cwd2, ...newCommonPath) : cwd2;
+  }
+  return result;
+}
+function processPatterns({ patterns, ignore = [], expandDirectories = true }, cwd2, props) {
+  if (typeof patterns === "string")
+    patterns = [patterns];
+  else if (!patterns)
+    patterns = ["**/*"];
+  if (typeof ignore === "string")
+    ignore = [ignore];
+  const matchPatterns = [];
+  const ignorePatterns = [];
+  for (const pattern of ignore) {
+    if (!pattern)
+      continue;
+    if (pattern[0] !== "!" || pattern[1] === "(")
+      ignorePatterns.push(normalizePattern(pattern, expandDirectories, cwd2, props, true));
+  }
+  for (const pattern of patterns) {
+    if (!pattern)
+      continue;
+    if (pattern[0] !== "!" || pattern[1] === "(")
+      matchPatterns.push(normalizePattern(pattern, expandDirectories, cwd2, props, false));
+    else if (pattern[1] !== "!" || pattern[2] === "(")
+      ignorePatterns.push(normalizePattern(pattern.slice(1), expandDirectories, cwd2, props, true));
+  }
+  return {
+    match: matchPatterns,
+    ignore: ignorePatterns
+  };
+}
+function getRelativePath(path$1, cwd2, root) {
+  return posix.relative(cwd2, `${root}/${path$1}`) || ".";
+}
+function processPath(path$1, cwd2, root, isDirectory, absolute) {
+  const relativePath = absolute ? path$1.slice(root === "/" ? 1 : root.length + 1) || "." : path$1;
+  if (root === cwd2)
+    return isDirectory && relativePath !== "." ? relativePath.slice(0, -1) : relativePath;
+  return getRelativePath(relativePath, cwd2, root);
+}
+function formatPaths(paths, cwd2, root) {
+  for (let i = paths.length - 1;i >= 0; i--) {
+    const path$1 = paths[i];
+    paths[i] = getRelativePath(path$1, cwd2, root) + (!path$1 || path$1.endsWith("/") ? "/" : "");
+  }
+  return paths;
+}
+function crawl(options, cwd2, sync2) {
+  if (process.env.TINYGLOBBY_DEBUG)
+    options.debug = true;
+  if (options.debug)
+    log("globbing with options:", options, "cwd:", cwd2);
+  if (Array.isArray(options.patterns) && options.patterns.length === 0)
+    return sync2 ? [] : Promise.resolve([]);
+  const props = {
+    root: cwd2,
+    commonPath: null,
+    depthOffset: 0
+  };
+  const processed = processPatterns(options, cwd2, props);
+  const nocase = options.caseSensitiveMatch === false;
+  if (options.debug)
+    log("internal processing patterns:", processed);
+  const matcher = import_picomatch.default(processed.match, {
+    dot: options.dot,
+    nocase,
+    ignore: processed.ignore
+  });
+  const ignore = import_picomatch.default(processed.ignore, {
+    dot: options.dot,
+    nocase
+  });
+  const partialMatcher = getPartialMatcher(processed.match, {
+    dot: options.dot,
+    nocase
+  });
+  const fdirOptions = {
+    filters: [options.debug ? (p, isDirectory) => {
+      const path$1 = processPath(p, cwd2, props.root, isDirectory, options.absolute);
+      const matches = matcher(path$1);
+      if (matches)
+        log(`matched ${path$1}`);
+      return matches;
+    } : (p, isDirectory) => matcher(processPath(p, cwd2, props.root, isDirectory, options.absolute))],
+    exclude: options.debug ? (_, p) => {
+      const relativePath = processPath(p, cwd2, props.root, true, true);
+      const skipped = relativePath !== "." && !partialMatcher(relativePath) || ignore(relativePath);
+      if (skipped)
+        log(`skipped ${p}`);
+      else
+        log(`crawling ${p}`);
+      return skipped;
+    } : (_, p) => {
+      const relativePath = processPath(p, cwd2, props.root, true, true);
+      return relativePath !== "." && !partialMatcher(relativePath) || ignore(relativePath);
+    },
+    pathSeparator: "/",
+    relativePaths: true,
+    resolveSymlinks: true
+  };
+  if (options.deep !== undefined)
+    fdirOptions.maxDepth = Math.round(options.deep - props.depthOffset);
+  if (options.absolute) {
+    fdirOptions.relativePaths = false;
+    fdirOptions.resolvePaths = true;
+    fdirOptions.includeBasePath = true;
+  }
+  if (options.followSymbolicLinks === false) {
+    fdirOptions.resolveSymlinks = false;
+    fdirOptions.excludeSymlinks = true;
+  }
+  if (options.onlyDirectories) {
+    fdirOptions.excludeFiles = true;
+    fdirOptions.includeDirs = true;
+  } else if (options.onlyFiles === false)
+    fdirOptions.includeDirs = true;
+  props.root = props.root.replace(BACKSLASHES, "");
+  const root = props.root;
+  if (options.debug)
+    log("internal properties:", props);
+  const api2 = new Builder(fdirOptions).crawl(root);
+  if (cwd2 === root || options.absolute)
+    return sync2 ? api2.sync() : api2.withPromise();
+  return sync2 ? formatPaths(api2.sync(), cwd2, root) : api2.withPromise().then((paths) => formatPaths(paths, cwd2, root));
+}
+function globSync(patternsOrOptions, options) {
+  if (patternsOrOptions && (options === null || options === undefined ? undefined : options.patterns))
+    throw new Error("Cannot pass patterns as both an argument and an option");
+  const opts = Array.isArray(patternsOrOptions) || typeof patternsOrOptions === "string" ? {
+    ...options,
+    patterns: patternsOrOptions
+  } : patternsOrOptions;
+  const cwd2 = opts.cwd ? path5.resolve(opts.cwd).replace(BACKSLASHES, "/") : process.cwd().replace(BACKSLASHES, "/");
+  return crawl(opts, cwd2, true);
+}
+
+// src/utils/jsonl.ts
+import { promisify } from "util";
+var readFile4 = promisify(fs6.readFile);
+var readFileSync4 = fs6.readFileSync;
+var statSync3 = fs6.statSync;
+async function getSessionDuration(transcriptPath) {
+  try {
+    if (!fs6.existsSync(transcriptPath)) {
+      return null;
+    }
+    const content = await readFile4(transcriptPath, "utf-8");
+    const lines = content.trim().split(`
+`).filter((line) => line.trim());
+    if (lines.length === 0) {
+      return null;
+    }
+    let firstTimestamp = null;
+    let lastTimestamp = null;
+    for (const line of lines) {
+      try {
+        const data = JSON.parse(line);
+        if (data.timestamp) {
+          firstTimestamp = new Date(data.timestamp);
+          break;
+        }
+      } catch {}
+    }
+    for (let i = lines.length - 1;i >= 0; i--) {
+      try {
+        const data = JSON.parse(lines[i] ?? "");
+        if (data.timestamp) {
+          lastTimestamp = new Date(data.timestamp);
+          break;
+        }
+      } catch {}
+    }
+    if (!firstTimestamp || !lastTimestamp) {
+      return null;
+    }
+    const durationMs = lastTimestamp.getTime() - firstTimestamp.getTime();
+    const totalMinutes = Math.floor(durationMs / (1000 * 60));
+    if (totalMinutes < 1) {
+      return "<1m";
+    }
+    const hours = Math.floor(totalMinutes / 60);
+    const minutes = totalMinutes % 60;
+    if (hours === 0) {
+      return `${minutes}m`;
+    } else if (minutes === 0) {
+      return `${hours}hr`;
+    } else {
+      return `${hours}hr ${minutes}m`;
+    }
+  } catch {
+    return null;
+  }
+}
+async function getTokenMetrics(transcriptPath) {
+  try {
+    if (!fs6.existsSync(transcriptPath)) {
+      return { inputTokens: 0, outputTokens: 0, cachedTokens: 0, totalTokens: 0, contextLength: 0 };
+    }
+    const content = await readFile4(transcriptPath, "utf-8");
+    const lines = content.trim().split(`
+`);
+    let inputTokens = 0;
+    let outputTokens = 0;
+    let cachedTokens = 0;
+    let contextLength = 0;
+    let mostRecentMainChainEntry = null;
+    let mostRecentTimestamp = null;
+    for (const line of lines) {
+      try {
+        const data = JSON.parse(line);
+        if (data.message?.usage) {
+          inputTokens += data.message.usage.input_tokens || 0;
+          outputTokens += data.message.usage.output_tokens || 0;
+          cachedTokens += data.message.usage.cache_read_input_tokens ?? 0;
+          cachedTokens += data.message.usage.cache_creation_input_tokens ?? 0;
+          if (data.isSidechain !== true && data.timestamp) {
+            const entryTime = new Date(data.timestamp);
+            if (!mostRecentTimestamp || entryTime > mostRecentTimestamp) {
+              mostRecentTimestamp = entryTime;
+              mostRecentMainChainEntry = data;
             }
-          }, undefined, false, undefined, this)
-        ]
-      }, undefined, true, undefined, this)
-    ]
-  }, undefined, true, undefined, this);
-};
-function runTUI() {
-  process.stdout.write("\x1B[2J\x1B[H");
-  render_default(/* @__PURE__ */ jsx_dev_runtime16.jsxDEV(App2, {}, undefined, false, undefined, this));
+          }
+        }
+      } catch {}
+    }
+    if (mostRecentMainChainEntry?.message?.usage) {
+      const usage = mostRecentMainChainEntry.message.usage;
+      contextLength = (usage.input_tokens || 0) + (usage.cache_read_input_tokens ?? 0) + (usage.cache_creation_input_tokens ?? 0);
+    }
+    const totalTokens = inputTokens + outputTokens + cachedTokens;
+    return { inputTokens, outputTokens, cachedTokens, totalTokens, contextLength };
+  } catch {
+    return { inputTokens: 0, outputTokens: 0, cachedTokens: 0, totalTokens: 0, contextLength: 0 };
+  }
+}
+function getBlockMetrics(transcriptPath) {
+  if (!transcriptPath || typeof transcriptPath !== "string") {
+    return null;
+  }
+  let currentPath = path6.dirname(transcriptPath);
+  let claudePath = null;
+  while (currentPath && currentPath !== path6.dirname(currentPath)) {
+    const baseName = path6.basename(currentPath);
+    if (baseName === ".claude") {
+      claudePath = currentPath;
+      break;
+    }
+    currentPath = path6.dirname(currentPath);
+  }
+  if (!claudePath) {
+    return null;
+  }
+  try {
+    return findMostRecentBlockStartTime(claudePath);
+  } catch {
+    return null;
+  }
+}
+function findMostRecentBlockStartTime(rootDir, sessionDurationHours = 5) {
+  const sessionDurationMs = sessionDurationHours * 60 * 60 * 1000;
+  const now = new Date;
+  const pattern = path6.join(rootDir, "projects", "**", "*.jsonl").replace(/\\/g, "/");
+  const files = globSync([pattern]);
+  if (files.length === 0) {
+    return null;
+  }
+  const filesWithStats = files.map((file2) => {
+    const stats = statSync3(file2);
+    return { file: file2, mtime: stats.mtime };
+  });
+  filesWithStats.sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
+  const timestamps = [];
+  const cutoffTime = new Date(now.getTime() - 20 * 60 * 60 * 1000);
+  for (const { file: file2, mtime } of filesWithStats) {
+    if (mtime.getTime() < cutoffTime.getTime()) {
+      break;
+    }
+    const fileTimestamps = getAllTimestampsFromFile(file2);
+    timestamps.push(...fileTimestamps);
+  }
+  if (timestamps.length === 0) {
+    return null;
+  }
+  timestamps.sort((a, b) => b.getTime() - a.getTime());
+  const mostRecentTimestamp = timestamps[0];
+  if (!mostRecentTimestamp) {
+    return null;
+  }
+  let actualStartTimestamp = mostRecentTimestamp;
+  for (let i = 1;i < timestamps.length; i++) {
+    const currentTimestamp = timestamps[i];
+    const previousTimestamp = timestamps[i - 1];
+    if (!currentTimestamp || !previousTimestamp) {
+      continue;
+    }
+    const gap = previousTimestamp.getTime() - currentTimestamp.getTime();
+    if (gap > sessionDurationMs) {
+      break;
+    }
+    actualStartTimestamp = currentTimestamp;
+  }
+  const elapsedSinceStart = now.getTime() - actualStartTimestamp.getTime();
+  const timeInCurrentBlock = elapsedSinceStart % sessionDurationMs;
+  const blockStart = new Date(now.getTime() - timeInCurrentBlock);
+  const timeSinceActivity = now.getTime() - mostRecentTimestamp.getTime();
+  const blockEnd = new Date(blockStart.getTime() + sessionDurationMs);
+  const isActive = timeSinceActivity < sessionDurationMs && now < blockEnd;
+  return {
+    startTime: blockStart,
+    lastActivity: mostRecentTimestamp,
+    isActive
+  };
+}
+function getAllTimestampsFromFile(filePath) {
+  const timestamps = [];
+  try {
+    const content = readFileSync4(filePath, "utf-8");
+    const lines = content.trim().split(`
+`).filter((line) => line.length > 0);
+    for (const line of lines) {
+      try {
+        const json2 = JSON.parse(line);
+        if (json2.timestamp && typeof json2.timestamp === "string") {
+          const date5 = new Date(json2.timestamp);
+          if (!Number.isNaN(date5.getTime())) {
+            timestamps.push(date5);
+          }
+        }
+      } catch {
+        continue;
+      }
+    }
+    return timestamps;
+  } catch {
+    return [];
+  }
 }
-// src/types/StatusJSON.ts
-var StatusJSONSchema = exports_external.looseObject({
-  hook_event_name: exports_external.string().optional(),
-  session_id: exports_external.string().optional(),
-  transcript_path: exports_external.string().optional(),
-  cwd: exports_external.string().optional(),
-  model: exports_external.object({
-    id: exports_external.string().optional(),
-    display_name: exports_external.string().optional()
-  }).optional(),
-  workspace: exports_external.object({
-    current_dir: exports_external.string().optional(),
-    project_dir: exports_external.string().optional()
-  }).optional(),
-  version: exports_external.string().optional(),
-  output_style: exports_external.object({ name: exports_external.string().optional() }).optional()
-});
 
 // src/ccstatusline.ts
 async function readStdin() {
@@ -55463,16 +58006,21 @@ async function renderMultipleLines(data) {
   const lines = settings.lines;
   const hasTokenItems = lines.some((line) => line.some((item) => ["tokens-input", "tokens-output", "tokens-cached", "tokens-total", "context-length", "context-percentage", "context-percentage-usable"].includes(item.type)));
   const hasSessionClock = lines.some((line) => line.some((item) => item.type === "session-clock"));
+  const hasBlockTimer = lines.some((line) => line.some((item) => item.type === "block-timer"));
   let tokenMetrics = null;
   if (hasTokenItems && data.transcript_path)
     tokenMetrics = await getTokenMetrics(data.transcript_path);
   let sessionDuration = null;
   if (hasSessionClock && data.transcript_path)
     sessionDuration = await getSessionDuration(data.transcript_path);
+  let blockMetrics = null;
+  if (hasBlockTimer && data.transcript_path)
+    blockMetrics = getBlockMetrics(data.transcript_path);
   const context = {
     data,
     tokenMetrics,
     sessionDuration,
+    blockMetrics,
     isPreview: false
   };
   let globalSeparatorIndex = 0;