roast-my-codebase 1.3.0 → 1.3.2

package/dist/index.js

@@ -6,1758 +6,12 @@ import {
   LARGE_FILE_THRESHOLDS,
   SAFE_GLOB_OPTIONS,
   SOURCE_EXTENSIONS,
-  __commonJS,
-  __require,
-  __toESM,
   buildIgnorePatterns
-} from "./chunk-4KMMPANT.js";
-
-// node_modules/picomatch/lib/constants.js
-var require_constants = __commonJS({
-  "node_modules/picomatch/lib/constants.js"(exports, module) {
-    "use strict";
-    var path26 = __require("path");
-    var WIN_SLASH = "\\\\/";
-    var WIN_NO_SLASH = `[^${WIN_SLASH}]`;
-    var DEFAULT_MAX_EXTGLOB_RECURSION = 0;
-    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 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
-    };
-    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}]|$)`
-    };
-    var POSIX_REGEX_SOURCE = {
-      __proto__: null,
-      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 = {
-      DEFAULT_MAX_EXTGLOB_RECURSION,
-      MAX_LENGTH: 1024 * 64,
-      POSIX_REGEX_SOURCE,
-      // regular expressions
-      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,
-      // Replace globs with equivalent patterns to reduce parsing time.
-      REPLACEMENTS: {
-        __proto__: null,
-        "***": "*",
-        "**/**": "**",
-        "**/**/**": "**"
-      },
-      // Digits
-      CHAR_0: 48,
-      /* 0 */
-      CHAR_9: 57,
-      /* 9 */
-      // Alphabet chars.
-      CHAR_UPPERCASE_A: 65,
-      /* A */
-      CHAR_LOWERCASE_A: 97,
-      /* a */
-      CHAR_UPPERCASE_Z: 90,
-      /* Z */
-      CHAR_LOWERCASE_Z: 122,
-      /* z */
-      CHAR_LEFT_PARENTHESES: 40,
-      /* ( */
-      CHAR_RIGHT_PARENTHESES: 41,
-      /* ) */
-      CHAR_ASTERISK: 42,
-      /* * */
-      // Non-alphabetic chars.
-      CHAR_AMPERSAND: 38,
-      /* & */
-      CHAR_AT: 64,
-      /* @ */
-      CHAR_BACKWARD_SLASH: 92,
-      /* \ */
-      CHAR_CARRIAGE_RETURN: 13,
-      /* \r */
-      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,
-      /* \f */
-      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,
-      /* \n */
-      CHAR_NO_BREAK_SPACE: 160,
-      /* \u00A0 */
-      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,
-      /* \t */
-      CHAR_UNDERSCORE: 95,
-      /* _ */
-      CHAR_VERTICAL_LINE: 124,
-      /* | */
-      CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279,
-      /* \uFEFF */
-      SEP: path26.sep,
-      /**
-       * Create EXTGLOB_CHARS
-       */
-      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: ")" }
-        };
-      },
-      /**
-       * Create GLOB_CHARS
-       */
-      globChars(win32) {
-        return win32 === true ? WINDOWS_CHARS : POSIX_CHARS;
-      }
-    };
-  }
-});
-
-// node_modules/picomatch/lib/utils.js
-var require_utils = __commonJS({
-  "node_modules/picomatch/lib/utils.js"(exports) {
-    "use strict";
-    var path26 = __require("path");
-    var win32 = process.platform === "win32";
-    var {
-      REGEX_BACKSLASH,
-      REGEX_REMOVE_BACKSLASH,
-      REGEX_SPECIAL_CHARS,
-      REGEX_SPECIAL_CHARS_GLOBAL
-    } = require_constants();
-    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.removeBackslashes = (str) => {
-      return str.replace(REGEX_REMOVE_BACKSLASH, (match) => {
-        return match === "\\" ? "" : match;
-      });
-    };
-    exports.supportsLookbehinds = () => {
-      const segs = process.version.slice(1).split(".").map(Number);
-      if (segs.length === 3 && segs[0] >= 9 || segs[0] === 8 && segs[1] >= 10) {
-        return true;
-      }
-      return false;
-    };
-    exports.isWindows = (options) => {
-      if (options && typeof options.windows === "boolean") {
-        return options.windows;
-      }
-      return win32 === true || path26.sep === "\\";
-    };
-    exports.escapeLast = (input2, char, lastIdx) => {
-      const idx = input2.lastIndexOf(char, lastIdx);
-      if (idx === -1) return input2;
-      if (input2[idx - 1] === "\\") return exports.escapeLast(input2, char, idx - 1);
-      return `${input2.slice(0, idx)}\\${input2.slice(idx)}`;
-    };
-    exports.removePrefix = (input2, state = {}) => {
-      let output = input2;
-      if (output.startsWith("./")) {
-        output = output.slice(2);
-        state.prefix = "./";
-      }
-      return output;
-    };
-    exports.wrapOutput = (input2, state = {}, options = {}) => {
-      const prepend = options.contains ? "" : "^";
-      const append = options.contains ? "" : "$";
-      let output = `${prepend}(?:${input2})${append}`;
-      if (state.negated === true) {
-        output = `(?:^(?!${output}).*$)`;
-      }
-      return output;
-    };
-  }
-});
-
-// node_modules/picomatch/lib/scan.js
-var require_scan = __commonJS({
-  "node_modules/picomatch/lib/scan.js"(exports, module) {
-    "use strict";
-    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_constants();
-    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 = (input2, options) => {
-      const opts = options || {};
-      const length = input2.length - 1;
-      const scanToEnd = opts.parts === true || opts.scanToEnd === true;
-      const slashes = [];
-      const tokens = [];
-      const parts = [];
-      let str = input2;
-      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 (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;
-              }
-            }
-          }
-          if (scanToEnd === true) {
-            continue;
-          }
-          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;
-          }
-          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 === CHAR_ASTERISK) {
-          if (prev === CHAR_ASTERISK) isGlobstar = token.isGlobstar = true;
-          isGlob = token.isGlob = true;
-          finished = true;
-          if (scanToEnd === true) {
-            continue;
-          }
-          break;
-        }
-        if (code === CHAR_QUESTION_MARK) {
-          isGlob = token.isGlob = true;
-          finished = true;
-          if (scanToEnd === true) {
-            continue;
-          }
-          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;
-            }
-          }
-          if (scanToEnd === true) {
-            continue;
-          }
-          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;
-        }
-      }
-      if (opts.noext === true) {
-        isExtglob = false;
-        isGlob = false;
-      }
-      let base = str;
-      let prefix = "";
-      let glob = "";
-      if (start > 0) {
-        prefix = str.slice(0, start);
-        str = str.slice(start);
-        lastIndex -= start;
-      }
-      if (base && isGlob === true && lastIndex > 0) {
-        base = str.slice(0, lastIndex);
-        glob = str.slice(lastIndex);
-      } else if (isGlob === true) {
-        base = "";
-        glob = str;
-      } else {
-        base = str;
-      }
-      if (base && base !== "" && base !== "/" && base !== str) {
-        if (isPathSeparator(base.charCodeAt(base.length - 1))) {
-          base = base.slice(0, -1);
-        }
-      }
-      if (opts.unescape === true) {
-        if (glob) glob = utils.removeBackslashes(glob);
-        if (base && backslashes === true) {
-          base = utils.removeBackslashes(base);
-        }
-      }
-      const state = {
-        prefix,
-        input: input2,
-        start,
-        base,
-        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 = input2.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;
-        }
-        if (prevIndex && prevIndex + 1 < input2.length) {
-          const value = input2.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;
-      }
-      return state;
-    };
-    module.exports = scan;
-  }
-});
-
-// node_modules/picomatch/lib/parse.js
-var require_parse = __commonJS({
-  "node_modules/picomatch/lib/parse.js"(exports, module) {
-    "use strict";
-    var constants = require_constants();
-    var utils = require_utils();
-    var {
-      MAX_LENGTH,
-      POSIX_REGEX_SOURCE,
-      REGEX_NON_SPECIAL_CHARS,
-      REGEX_SPECIAL_CHARS_BACKREF,
-      REPLACEMENTS
-    } = constants;
-    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;
-    };
-    var syntaxError = (type, char) => {
-      return `Missing ${type}: "${char}" - use "\\\\${char}" to match literal characters`;
-    };
-    var splitTopLevel = (input2) => {
-      const parts = [];
-      let bracket = 0;
-      let paren = 0;
-      let quote = 0;
-      let value = "";
-      let escaped = false;
-      for (const ch of input2) {
-        if (escaped === true) {
-          value += ch;
-          escaped = false;
-          continue;
-        }
-        if (ch === "\\") {
-          value += ch;
-          escaped = true;
-          continue;
-        }
-        if (ch === '"') {
-          quote = quote === 1 ? 0 : 1;
-          value += ch;
-          continue;
-        }
-        if (quote === 0) {
-          if (ch === "[") {
-            bracket++;
-          } else if (ch === "]" && bracket > 0) {
-            bracket--;
-          } else if (bracket === 0) {
-            if (ch === "(") {
-              paren++;
-            } else if (ch === ")" && paren > 0) {
-              paren--;
-            } else if (ch === "|" && paren === 0) {
-              parts.push(value);
-              value = "";
-              continue;
-            }
-          }
-        }
-        value += ch;
-      }
-      parts.push(value);
-      return parts;
-    };
-    var isPlainBranch = (branch) => {
-      let escaped = false;
-      for (const ch of branch) {
-        if (escaped === true) {
-          escaped = false;
-          continue;
-        }
-        if (ch === "\\") {
-          escaped = true;
-          continue;
-        }
-        if (/[?*+@!()[\]{}]/.test(ch)) {
-          return false;
-        }
-      }
-      return true;
-    };
-    var normalizeSimpleBranch = (branch) => {
-      let value = branch.trim();
-      let changed = true;
-      while (changed === true) {
-        changed = false;
-        if (/^@\([^\\()[\]{}|]+\)$/.test(value)) {
-          value = value.slice(2, -1);
-          changed = true;
-        }
-      }
-      if (!isPlainBranch(value)) {
-        return;
-      }
-      return value.replace(/\\(.)/g, "$1");
-    };
-    var hasRepeatedCharPrefixOverlap = (branches) => {
-      const values = branches.map(normalizeSimpleBranch).filter(Boolean);
-      for (let i = 0; i < values.length; i++) {
-        for (let j = i + 1; j < values.length; j++) {
-          const a = values[i];
-          const b = values[j];
-          const char = a[0];
-          if (!char || a !== char.repeat(a.length) || b !== char.repeat(b.length)) {
-            continue;
-          }
-          if (a === b || a.startsWith(b) || b.startsWith(a)) {
-            return true;
-          }
-        }
-      }
-      return false;
-    };
-    var parseRepeatedExtglob = (pattern, requireEnd = true) => {
-      if (pattern[0] !== "+" && pattern[0] !== "*" || pattern[1] !== "(") {
-        return;
-      }
-      let bracket = 0;
-      let paren = 0;
-      let quote = 0;
-      let escaped = false;
-      for (let i = 1; i < pattern.length; i++) {
-        const ch = pattern[i];
-        if (escaped === true) {
-          escaped = false;
-          continue;
-        }
-        if (ch === "\\") {
-          escaped = true;
-          continue;
-        }
-        if (ch === '"') {
-          quote = quote === 1 ? 0 : 1;
-          continue;
-        }
-        if (quote === 1) {
-          continue;
-        }
-        if (ch === "[") {
-          bracket++;
-          continue;
-        }
-        if (ch === "]" && bracket > 0) {
-          bracket--;
-          continue;
-        }
-        if (bracket > 0) {
-          continue;
-        }
-        if (ch === "(") {
-          paren++;
-          continue;
-        }
-        if (ch === ")") {
-          paren--;
-          if (paren === 0) {
-            if (requireEnd === true && i !== pattern.length - 1) {
-              return;
-            }
-            return {
-              type: pattern[0],
-              body: pattern.slice(2, i),
-              end: i
-            };
-          }
-        }
-      }
-    };
-    var getStarExtglobSequenceOutput = (pattern) => {
-      let index = 0;
-      const chars = [];
-      while (index < pattern.length) {
-        const match = parseRepeatedExtglob(pattern.slice(index), false);
-        if (!match || match.type !== "*") {
-          return;
-        }
-        const branches = splitTopLevel(match.body).map((branch2) => branch2.trim());
-        if (branches.length !== 1) {
-          return;
-        }
-        const branch = normalizeSimpleBranch(branches[0]);
-        if (!branch || branch.length !== 1) {
-          return;
-        }
-        chars.push(branch);
-        index += match.end + 1;
-      }
-      if (chars.length < 1) {
-        return;
-      }
-      const source = chars.length === 1 ? utils.escapeRegex(chars[0]) : `[${chars.map((ch) => utils.escapeRegex(ch)).join("")}]`;
-      return `${source}*`;
-    };
-    var repeatedExtglobRecursion = (pattern) => {
-      let depth = 0;
-      let value = pattern.trim();
-      let match = parseRepeatedExtglob(value);
-      while (match) {
-        depth++;
-        value = match.body.trim();
-        match = parseRepeatedExtglob(value);
-      }
-      return depth;
-    };
-    var analyzeRepeatedExtglob = (body, options) => {
-      if (options.maxExtglobRecursion === false) {
-        return { risky: false };
-      }
-      const max = typeof options.maxExtglobRecursion === "number" ? options.maxExtglobRecursion : constants.DEFAULT_MAX_EXTGLOB_RECURSION;
-      const branches = splitTopLevel(body).map((branch) => branch.trim());
-      if (branches.length > 1) {
-        if (branches.some((branch) => branch === "") || branches.some((branch) => /^[*?]+$/.test(branch)) || hasRepeatedCharPrefixOverlap(branches)) {
-          return { risky: true };
-        }
-      }
-      for (const branch of branches) {
-        const safeOutput = getStarExtglobSequenceOutput(branch);
-        if (safeOutput) {
-          return { risky: true, safeOutput };
-        }
-        if (repeatedExtglobRecursion(branch) > max) {
-          return { risky: true };
-        }
-      }
-      return { risky: false };
-    };
-    var parse = (input2, options) => {
-      if (typeof input2 !== "string") {
-        throw new TypeError("Expected a string");
-      }
-      input2 = REPLACEMENTS[input2] || input2;
-      const opts = { ...options };
-      const max = typeof opts.maxLength === "number" ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
-      let len = input2.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 win32 = utils.isWindows(options);
-      const PLATFORM_CHARS = constants.globChars(win32);
-      const EXTGLOB_CHARS = constants.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})`;
-      }
-      if (typeof opts.noext === "boolean") {
-        opts.noextglob = opts.noext;
-      }
-      const state = {
-        input: input2,
-        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
-      };
-      input2 = utils.removePrefix(input2, state);
-      len = input2.length;
-      const extglobs = [];
-      const braces = [];
-      const stack = [];
-      let prev = bos;
-      let value;
-      const eos = () => state.index === len - 1;
-      const peek = state.peek = (n = 1) => input2[state.index + n];
-      const advance = state.advance = () => input2[++state.index] || "";
-      const remaining = () => input2.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;
-        }
-        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.value += tok.value;
-          prev.output = (prev.output || "") + 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;
-        token.startIndex = state.index;
-        token.tokensIndex = tokens.length;
-        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) => {
-        const literal = input2.slice(token.startIndex, state.index + 1);
-        const body = input2.slice(token.startIndex + 2, state.index);
-        const analysis = analyzeRepeatedExtglob(body, opts);
-        if ((token.type === "plus" || token.type === "star") && analysis.risky) {
-          const safeOutput = analysis.safeOutput ? (token.output ? "" : ONE_CHAR) + (opts.capture ? `(${analysis.safeOutput})` : analysis.safeOutput) : void 0;
-          const open = tokens[token.tokensIndex];
-          open.type = "text";
-          open.value = literal;
-          open.output = safeOutput || utils.escapeRegex(literal);
-          for (let i = token.tokensIndex + 1; i < tokens.length; i++) {
-            tokens[i].value = "";
-            tokens[i].output = "";
-            delete tokens[i].suffix;
-          }
-          state.output = token.output + open.output;
-          state.backtrack = true;
-          push({ type: "paren", extglob: true, value, output: "" });
-          decrement("parens");
-          return;
-        }
-        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 = parse(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(input2)) {
-        let backslashes = false;
-        let output = input2.replace(REGEX_SPECIAL_CHARS_BACKREF, (m, esc, chars, first, rest, index) => {
-          if (first === "\\") {
-            backslashes = true;
-            return m;
-          }
-          if (first === "?") {
-            if (esc) {
-              return esc + 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 (esc) {
-              return esc + first + (rest ? star : "");
-            }
-            return star;
-          }
-          return esc ? 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 === input2 && opts.contains === true) {
-          state.output = input2;
-          return state;
-        }
-        state.output = utils.wrapOutput(output, state, options);
-        return state;
-      }
-      while (!eos()) {
-        value = advance();
-        if (value === "\0") {
-          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 (next === "<" && !utils.supportsLookbehinds()) {
-              throw new Error("Node.js v10 or higher is required for regex lookbehinds");
-            }
-            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 = input2[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] !== void 0 ? "|$" : "";
-            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;
-    };
-    parse.fastpaths = (input2, options) => {
-      const opts = { ...options };
-      const max = typeof opts.maxLength === "number" ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
-      const len = input2.length;
-      if (len > max) {
-        throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
-      }
-      input2 = REPLACEMENTS[input2] || input2;
-      const win32 = utils.isWindows(options);
-      const {
-        DOT_LITERAL,
-        SLASH_LITERAL,
-        ONE_CHAR,
-        DOTS_SLASH,
-        NO_DOT,
-        NO_DOTS,
-        NO_DOTS_SLASH,
-        STAR,
-        START_ANCHOR
-      } = constants.globChars(win32);
-      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 create = (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 = create(match[1]);
-            if (!source2) return;
-            return source2 + DOT_LITERAL + match[2];
-          }
-        }
-      };
-      const output = utils.removePrefix(input2, state);
-      let source = create(output);
-      if (source && opts.strictSlashes !== true) {
-        source += `${SLASH_LITERAL}?`;
-      }
-      return source;
-    };
-    module.exports = parse;
-  }
-});
-
-// node_modules/picomatch/lib/picomatch.js
-var require_picomatch = __commonJS({
-  "node_modules/picomatch/lib/picomatch.js"(exports, module) {
-    "use strict";
-    var path26 = __require("path");
-    var scan = require_scan();
-    var parse = require_parse();
-    var utils = require_utils();
-    var constants = require_constants();
-    var isObject = (val) => val && typeof val === "object" && !Array.isArray(val);
-    var picomatch2 = (glob, options, returnState = false) => {
-      if (Array.isArray(glob)) {
-        const fns = glob.map((input2) => picomatch2(input2, options, returnState));
-        const arrayMatcher = (str) => {
-          for (const isMatch of fns) {
-            const state2 = isMatch(str);
-            if (state2) return state2;
-          }
-          return false;
-        };
-        return arrayMatcher;
-      }
-      const isState = isObject(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 = utils.isWindows(options);
-      const regex = isState ? picomatch2.compileRe(glob, options) : picomatch2.makeRe(glob, options, false, true);
-      const state = regex.state;
-      delete regex.state;
-      let isIgnored = () => false;
-      if (opts.ignore) {
-        const ignoreOpts = { ...options, ignore: null, onMatch: null, onResult: null };
-        isIgnored = picomatch2(opts.ignore, ignoreOpts, returnState);
-      }
-      const matcher = (input2, returnObject = false) => {
-        const { isMatch, match, output } = picomatch2.test(input2, regex, options, { glob, posix });
-        const result = { glob, state, regex, posix, input: input2, output, match, isMatch };
-        if (typeof opts.onResult === "function") {
-          opts.onResult(result);
-        }
-        if (isMatch === false) {
-          result.isMatch = false;
-          return returnObject ? result : false;
-        }
-        if (isIgnored(input2)) {
-          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;
-    };
-    picomatch2.test = (input2, regex, options, { glob, posix } = {}) => {
-      if (typeof input2 !== "string") {
-        throw new TypeError("Expected input to be a string");
-      }
-      if (input2 === "") {
-        return { isMatch: false, output: "" };
-      }
-      const opts = options || {};
-      const format = opts.format || (posix ? utils.toPosixSlashes : null);
-      let match = input2 === glob;
-      let output = match && format ? format(input2) : input2;
-      if (match === false) {
-        output = format ? format(input2) : input2;
-        match = output === glob;
-      }
-      if (match === false || opts.capture === true) {
-        if (opts.matchBase === true || opts.basename === true) {
-          match = picomatch2.matchBase(input2, regex, options, posix);
-        } else {
-          match = regex.exec(output);
-        }
-      }
-      return { isMatch: Boolean(match), match, output };
-    };
-    picomatch2.matchBase = (input2, glob, options, posix = utils.isWindows(options)) => {
-      const regex = glob instanceof RegExp ? glob : picomatch2.makeRe(glob, options);
-      return regex.test(path26.basename(input2));
-    };
-    picomatch2.isMatch = (str, patterns, options) => picomatch2(patterns, options)(str);
-    picomatch2.parse = (pattern, options) => {
-      if (Array.isArray(pattern)) return pattern.map((p) => picomatch2.parse(p, options));
-      return parse(pattern, { ...options, fastpaths: false });
-    };
-    picomatch2.scan = (input2, options) => scan(input2, options);
-    picomatch2.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 regex = picomatch2.toRegex(source, options);
-      if (returnState === true) {
-        regex.state = state;
-      }
-      return regex;
-    };
-    picomatch2.makeRe = (input2, options = {}, returnOutput = false, returnState = false) => {
-      if (!input2 || typeof input2 !== "string") {
-        throw new TypeError("Expected a non-empty string");
-      }
-      let parsed = { negated: false, fastpaths: true };
-      if (options.fastpaths !== false && (input2[0] === "." || input2[0] === "*")) {
-        parsed.output = parse.fastpaths(input2, options);
-      }
-      if (!parsed.output) {
-        parsed = parse(input2, options);
-      }
-      return picomatch2.compileRe(parsed, options, returnOutput, returnState);
-    };
-    picomatch2.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 /$^/;
-      }
-    };
-    picomatch2.constants = constants;
-    module.exports = picomatch2;
-  }
-});
-
-// node_modules/picomatch/index.js
-var require_picomatch2 = __commonJS({
-  "node_modules/picomatch/index.js"(exports, module) {
-    "use strict";
-    module.exports = require_picomatch();
-  }
-});
+} from "./chunk-32UIGL7K.js";
 
 // src/cli/index.ts
 import { Command } from "commander";
-import path25 from "path";
+import path27 from "path";
 import fs41 from "fs";
 import { fileURLToPath } from "url";
 import { performance } from "perf_hooks";
@@ -1769,9 +23,9 @@ import fg from "fast-glob";
 import path2 from "path";
 
 // src/utils/files.ts
-var import_picomatch = __toESM(require_picomatch2(), 1);
 import fs from "fs";
 import path from "path";
+import picomatch from "picomatch";
 function readFileLines(filePath) {
   try {
     return fs.readFileSync(filePath, "utf-8").split("\n");
@@ -1839,7 +93,7 @@ function convertIgnorePattern(pattern) {
 }
 function filterIgnoredFindings(findings, ignorePatterns, _rootDir) {
   if (ignorePatterns.length === 0) return findings;
-  const matchers = ignorePatterns.map((p) => (0, import_picomatch.default)(p, { dot: true }));
+  const matchers = ignorePatterns.map((p) => picomatch(p, { dot: true }));
   return findings.filter((finding) => {
     if (!finding.file) return true;
     const normalized = finding.file.replace(/\\/g, "/");
@@ -1947,7 +201,7 @@ var TodoScanner = class {
     let totalHacks = 0;
     for (const file of files) {
       const lines = readFileLines(file);
-      const rel = relativePath(rootDir, file);
+      const _rel = relativePath(rootDir, file);
       for (let i = 0; i < lines.length; i++) {
         const line = lines[i];
         if (/\bTODO\b/.test(line)) totalTodos++;
@@ -2556,7 +810,7 @@ var DuplicateScanner = class {
       }
     }
     const duplicates = [];
-    for (const [hash, locations] of hashMap) {
+    for (const [_hash, locations] of hashMap) {
       if (locations.length < 2) continue;
       const uniqueLocations = this.filterUniqueLocations(locations);
       if (uniqueLocations.length < 2) continue;
@@ -2621,7 +875,7 @@ var DuplicateScanner = class {
     }
     return unique;
   }
-  calculateBlockSize(locations, files, rootDir) {
+  calculateBlockSize(_locations, _files, _rootDir) {
     return WINDOW_SIZE;
   }
   hashString(str) {
@@ -3430,7 +1684,7 @@ var FrameworkScanner = class {
         isAngular = !!(pkg.dependencies?.["@angular/core"] || pkg.devDependencies?.["@angular/core"]);
         isSvelte = !!(pkg.dependencies?.svelte || pkg.devDependencies?.svelte);
         isExpress = !!(pkg.dependencies?.express || pkg.devDependencies?.express);
-      } catch (error) {
+      } catch {
         return { findings: [], stats: { isNextJS: false, isReact: false } };
       }
     }
@@ -3443,7 +1697,7 @@ var FrameworkScanner = class {
         if (content.toLowerCase().includes("fastapi")) {
           isFastAPI = true;
         }
-      } catch (error) {
+      } catch {
       }
     }
     if (!isFastAPI && fs9.existsSync(pyprojectPath)) {
@@ -3452,7 +1706,7 @@ var FrameworkScanner = class {
         if (content.toLowerCase().includes("fastapi")) {
           isFastAPI = true;
         }
-      } catch (error) {
+      } catch {
       }
     }
     if (!isNextJS && !isReact && !isVue && !isAngular && !isSvelte && !isExpress && !isFastAPI) {
@@ -3479,7 +1733,7 @@ var FrameworkScanner = class {
               file: rel
             });
           }
-        } catch (error) {
+        } catch {
           continue;
         }
       }
@@ -3507,7 +1761,7 @@ var FrameworkScanner = class {
               });
             }
           }
-        } catch (error) {
+        } catch {
           continue;
         }
       }
@@ -3543,7 +1797,7 @@ var FrameworkScanner = class {
                 file: rel
               });
             }
-          } catch (error) {
+          } catch {
             continue;
           }
         }
@@ -3590,7 +1844,7 @@ var FrameworkScanner = class {
               file: rel
             });
           }
-        } catch (error) {
+        } catch {
           continue;
         }
       }
@@ -3633,7 +1887,7 @@ var FrameworkScanner = class {
               file: rel
             });
           }
-        } catch (error) {
+        } catch {
           continue;
         }
       }
@@ -3670,7 +1924,7 @@ var FrameworkScanner = class {
               });
             }
           }
-        } catch (error) {
+        } catch {
           continue;
         }
       }
@@ -3694,7 +1948,7 @@ var FrameworkScanner = class {
           if (/app\.(get|post|put|delete|patch)\s*\(/.test(content)) {
             routeFiles.push(filePath);
           }
-        } catch (error) {
+        } catch {
           continue;
         }
       }
@@ -3714,7 +1968,7 @@ var FrameworkScanner = class {
             hasRateLimit = true;
             break;
           }
-        } catch (error) {
+        } catch {
           continue;
         }
       }
@@ -3739,7 +1993,7 @@ var FrameworkScanner = class {
               file: rel
             });
           }
-        } catch (error) {
+        } catch {
           continue;
         }
       }
@@ -3794,7 +2048,7 @@ var FrameworkScanner = class {
               break;
             }
           }
-        } catch (error) {
+        } catch {
           continue;
         }
       }
@@ -3918,7 +2172,7 @@ var PythonTypeHintsScanner = class {
     for (const file of files) {
       try {
         const content = fs10.readFileSync(file, "utf-8");
-        const rel = relativePath(rootDir, file);
+        const _rel = relativePath(rootDir, file);
         const funcPattern = /def\s+(\w+)\s*\([^)]{0,500}\)(?:\s*->\s*\w+)?:/g;
         const functions = Array.from(content.matchAll(funcPattern));
         for (const match of functions) {
@@ -7285,6 +5539,7 @@ var DatabaseScanner = class {
 };
 
 // src/languages/index.ts
+import path14 from "path";
 var LANGUAGE_CONFIGS = {
   javascript: {
     name: "JavaScript",
@@ -7374,7 +5629,7 @@ function detectProjectLanguage(rootDir, fs42) {
   const detectedLanguages = [];
   for (const [lang, config] of Object.entries(LANGUAGE_CONFIGS)) {
     for (const packageFile of config.packageFiles) {
-      const fullPath = __require("path").join(rootDir, packageFile);
+      const fullPath = path14.join(rootDir, packageFile);
       if (fs42.existsSync(fullPath)) {
         detectedLanguages.push(lang);
         break;
@@ -7557,7 +5812,7 @@ function getLabel(score) {
 // src/ai/index.ts
 import Anthropic from "@anthropic-ai/sdk";
 import fs25 from "fs";
-import path14 from "path";
+import path15 from "path";
 import crypto from "crypto";
 var DEFAULT_MODEL = "claude-3-5-sonnet-20241022";
 var DEFAULT_MAX_TOKENS = 150;
@@ -7661,7 +5916,7 @@ function getFindingHash(finding) {
   return crypto.createHash("md5").update(key).digest("hex");
 }
 function getCachedRoast(finding, rootDir, cachePath) {
-  const cacheFile = path14.join(rootDir, cachePath || CACHE_FILE);
+  const cacheFile = path15.join(rootDir, cachePath || CACHE_FILE);
   if (!fs25.existsSync(cacheFile)) {
     return null;
   }
@@ -7679,7 +5934,7 @@ function getCachedRoast(finding, rootDir, cachePath) {
   }
 }
 function cacheRoast(finding, roast, rootDir, cachePath) {
-  const cacheFile = path14.join(rootDir, cachePath || CACHE_FILE);
+  const cacheFile = path15.join(rootDir, cachePath || CACHE_FILE);
   try {
     let cache = [];
     if (fs25.existsSync(cacheFile)) {
@@ -7699,7 +5954,7 @@ function cacheRoast(finding, roast, rootDir, cachePath) {
       cache = cache.slice(-100);
     }
     fs25.writeFileSync(cacheFile, JSON.stringify(cache, null, 2), "utf-8");
-  } catch (error) {
+  } catch {
   }
 }
 
@@ -8289,7 +6544,7 @@ async function generateRoasts(findings, aiConfig, rootDir) {
         aiConfig,
         rootDir
       );
-    } catch (error) {
+    } catch {
       console.warn("Warning: AI roast generation failed, using predefined roasts");
     }
   }
@@ -8863,7 +7118,7 @@ function renderMarkdownReport(report) {
 
 // src/report/html.ts
 import fs27 from "fs";
-import path15 from "path";
+import path16 from "path";
 function escapeHtml(text) {
   return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
 }
@@ -9587,7 +7842,7 @@ function renderHtmlReport(report) {
 </html>`;
 }
 function saveHtmlReport(html, rootDir) {
-  const outputPath = path15.join(rootDir, ".roast-report.html");
+  const outputPath = path16.join(rootDir, ".roast-report.html");
   fs27.writeFileSync(outputPath, html, "utf-8");
 }
 
@@ -9694,13 +7949,13 @@ function formatPRComment(report) {
   }
   return comment;
 }
-function githubRequest(method, path26, token, body) {
+function githubRequest(method, path28, token, body) {
   return new Promise((resolve, reject) => {
     const data = body ? JSON.stringify(body) : void 0;
     const req = https.request(
       {
         hostname: "api.github.com",
-        path: path26,
+        path: path28,
         method,
         headers: {
           Authorization: `Bearer ${token}`,
@@ -10016,7 +8271,180 @@ function saveJUnitReport(xml, rootDir) {
 }
 
 // src/report/hotmap.ts
+import path17 from "path";
 import chalk3 from "chalk";
+function normalizePath(filePath) {
+  return filePath.replace(/\\/g, "/");
+}
+function emptyNode(name, nodePath) {
+  return {
+    name,
+    path: nodePath,
+    criticalCount: 0,
+    warningCount: 0,
+    infoCount: 0,
+    totalCount: 0,
+    score: 100,
+    children: [],
+    fileCount: 0
+  };
+}
+function calculateScore(criticalCount, warningCount, infoCount) {
+  const raw = 100 - (criticalCount * 5 + warningCount * 2 + infoCount * 0.5);
+  return Math.max(0, Math.min(100, raw));
+}
+function buildFolderTree(findings, rootDir) {
+  const rootName = path17.basename(rootDir);
+  const root = emptyNode(rootName, "");
+  const fileFindings = findings.filter((f) => f.file !== void 0 && f.file !== "");
+  const nodeMap = /* @__PURE__ */ new Map();
+  nodeMap.set("", root);
+  const filesPerNode = /* @__PURE__ */ new Map();
+  filesPerNode.set("", /* @__PURE__ */ new Set());
+  for (const finding of fileFindings) {
+    const rawFile = finding.file;
+    let relFile = normalizePath(rawFile);
+    const normalizedRoot = normalizePath(rootDir);
+    if (relFile.startsWith(normalizedRoot + "/")) {
+      relFile = relFile.slice(normalizedRoot.length + 1);
+    }
+    const dirPart = relFile.includes("/") ? relFile.substring(0, relFile.lastIndexOf("/")) : "";
+    const segments = dirPart === "" ? [] : dirPart.split("/");
+    let currentPath = "";
+    for (let i = 0; i < segments.length; i++) {
+      const seg = segments[i];
+      const parentPath = currentPath;
+      currentPath = currentPath === "" ? seg : `${currentPath}/${seg}`;
+      if (!nodeMap.has(currentPath)) {
+        const newNode = emptyNode(seg, currentPath);
+        nodeMap.set(currentPath, newNode);
+        filesPerNode.set(currentPath, /* @__PURE__ */ new Set());
+        const parent = nodeMap.get(parentPath);
+        parent.children.push(newNode);
+      }
+    }
+    const leafNode = nodeMap.get(currentPath);
+    if (finding.severity === "critical") leafNode.criticalCount++;
+    else if (finding.severity === "warning") leafNode.warningCount++;
+    else if (finding.severity === "info") leafNode.infoCount++;
+    leafNode.totalCount++;
+    let trackPath = currentPath;
+    while (true) {
+      const set = filesPerNode.get(trackPath);
+      if (set) set.add(relFile);
+      if (trackPath === "") break;
+      trackPath = trackPath.includes("/") ? trackPath.substring(0, trackPath.lastIndexOf("/")) : "";
+    }
+  }
+  function aggregate(node) {
+    for (const child of node.children) {
+      aggregate(child);
+      node.criticalCount += child.criticalCount;
+      node.warningCount += child.warningCount;
+      node.infoCount += child.infoCount;
+      node.totalCount += child.totalCount;
+    }
+    node.score = calculateScore(node.criticalCount, node.warningCount, node.infoCount);
+    node.fileCount = filesPerNode.get(node.path)?.size ?? 0;
+  }
+  aggregate(root);
+  return root;
+}
+function renderHealthBar(score) {
+  const width = 10;
+  const filled = Math.round(score / 100 * width);
+  const empty = width - filled;
+  return "[" + "\u2588".repeat(filled) + "\u2591".repeat(empty) + "]";
+}
+function colorScore(score) {
+  const bar = renderHealthBar(score);
+  const scoreStr = String(Math.round(score));
+  if (score >= 80) {
+    return chalk3.green(bar) + " " + chalk3.green(scoreStr);
+  } else if (score >= 60) {
+    return chalk3.yellow(bar) + " " + chalk3.yellow(scoreStr);
+  } else {
+    return chalk3.red(bar) + " " + chalk3.red(scoreStr);
+  }
+}
+function folderIcon(node) {
+  if (node.criticalCount > 0) return "\u{1F534}";
+  if (node.warningCount > 0) return "\u26A0\uFE0F ";
+  return "\u2713 ";
+}
+function renderFolderSuffix(node) {
+  if (node.totalCount === 0) {
+    return chalk3.dim("\u2713  0 issues");
+  }
+  const icon = folderIcon(node);
+  const countStr = ` ${node.totalCount} issue${node.totalCount !== 1 ? "s" : ""}`;
+  const bar = " " + colorScore(node.score);
+  let issuesPart;
+  if (node.criticalCount > 0) {
+    issuesPart = chalk3.red(icon) + chalk3.red(countStr);
+  } else if (node.warningCount > 0) {
+    issuesPart = chalk3.yellow(icon) + chalk3.yellow(countStr);
+  } else {
+    issuesPart = chalk3.dim(icon) + chalk3.dim(countStr);
+  }
+  return issuesPart + bar;
+}
+function renderHotmap(root, maxDepth = 4) {
+  const lines = [];
+  const totalIssues = root.totalCount;
+  const folderCount = countFoldersWithIssues(root);
+  lines.push(
+    chalk3.bold("  Complexity Hotmap") + chalk3.dim(` \u2014 ${totalIssues} total issue${totalIssues !== 1 ? "s" : ""} across ${folderCount} folder${folderCount !== 1 ? "s" : ""}`)
+  );
+  const hotFolders = getHottestFolders(root, 3);
+  if (hotFolders.length > 0) {
+    const hottestStr = hotFolders.map((n) => chalk3.yellow(`${n.path || root.name} (${n.totalCount} issues)`)).join(", ");
+    lines.push(chalk3.dim("  Hottest folders: ") + hottestStr);
+  }
+  lines.push("");
+  lines.push(chalk3.bold(root.name + "/") + "  " + renderFolderSuffix(root));
+  function renderChildren(node, prefix, depth) {
+    if (depth > maxDepth) return;
+    const visibleChildren = node.children.filter((c) => c.totalCount > 0);
+    const childrenToRender = visibleChildren.length > 0 ? visibleChildren : node.children;
+    for (let i = 0; i < childrenToRender.length; i++) {
+      const child = childrenToRender[i];
+      const isLast = i === childrenToRender.length - 1;
+      const connector = isLast ? "\u2514\u2500\u2500" : "\u251C\u2500\u2500";
+      const childPrefix = prefix + (isLast ? "    " : "\u2502   ");
+      lines.push(
+        prefix + connector + " " + chalk3.bold(child.name + "/") + "  " + renderFolderSuffix(child)
+      );
+      if (depth < maxDepth) {
+        renderChildren(child, childPrefix, depth + 1);
+      }
+    }
+  }
+  renderChildren(root, "", 1);
+  lines.push("");
+  lines.push(
+    chalk3.dim("  \u{1F534} critical  \u26A0\uFE0F  warning  \u2713 clean   ") + chalk3.green("[\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588]") + chalk3.dim(" health bar")
+  );
+  return lines.join("\n");
+}
+function countFoldersWithIssues(root) {
+  let count = 0;
+  function walk(node) {
+    if (node.totalCount > 0) count++;
+    for (const child of node.children) walk(child);
+  }
+  walk(root);
+  return count;
+}
+function getHottestFolders(root, topN) {
+  const all = [];
+  function collect(node) {
+    if (node.path !== "" && node.totalCount > 0) all.push(node);
+    for (const child of node.children) collect(child);
+  }
+  collect(root);
+  return all.sort((a, b) => b.totalCount - a.totalCount).slice(0, topN);
+}
 
 // src/report/github-summary.ts
 import fs31 from "fs";
@@ -10227,7 +8655,7 @@ function calculateScoreBreakdown(findings, finalScore) {
 
 // src/report/output-dir.ts
 import fs32 from "fs";
-import path16 from "path";
+import path18 from "path";
 async function saveAllReports(report, outputDir, rootDir) {
   const result = { dir: outputDir, files: [], errors: [] };
   try {
@@ -10244,7 +8672,7 @@ async function saveAllReports(report, outputDir, rootDir) {
     { name: "roast-results", content: renderJUnitReport(report, rootDir), ext: ".xml" }
   ];
   for (const { name, content, ext } of reports) {
-    const filePath = path16.join(outputDir, name + ext);
+    const filePath = path18.join(outputDir, name + ext);
     try {
       fs32.writeFileSync(filePath, content, "utf-8");
       result.files.push(filePath);
@@ -10280,7 +8708,7 @@ function renderReport(report, options) {
     )
   );
   sections.push("");
-  sections.push(renderHealthBar(report.health.score));
+  sections.push(renderHealthBar2(report.health.score));
   sections.push("");
   const openingLine = generateOpeningLine(report.health.score, report.findings.length);
   if (openingLine) {
@@ -10305,6 +8733,34 @@ function renderReport(report, options) {
     `  ${chalk4.cyan("Dev Dependencies")}   ${report.stats.devDependencies}`
   );
   sections.push("");
+  const FINDING_TO_ROAST_CATEGORY = {
+    "unused-deps": "dependencies",
+    "nextjs-metadata": "framework",
+    "nextjs-client-server": "framework",
+    "react-error-boundary": "framework",
+    "secrets": "security",
+    "env-in-git": "security",
+    "eval-usage": "security",
+    "npm-audit": "npm-audit",
+    "dep-outdated": "dep-outdated",
+    "ruby-style": "ruby-issues",
+    "php-smell": "php-issues",
+    "swift-async": "swift-issues",
+    "kotlin-coroutine": "kotlin-issues",
+    "db-n-plus-one": "database",
+    "db-sql-injection": "database",
+    "db-over-fetch": "database",
+    "db-destructive": "database"
+  };
+  const roastByFile = /* @__PURE__ */ new Map();
+  const roastByCategory = /* @__PURE__ */ new Map();
+  for (const roast of report.roasts) {
+    if (roast.target === "codebase") continue;
+    roastByCategory.set(roast.category, roast.message);
+    if (roast.target.includes("/") || roast.target.includes(".") && !roast.target.includes(" ")) {
+      roastByFile.set(roast.target, roast.message);
+    }
+  }
   const warnings = report.findings.filter((f) => f.severity === "warning");
   const criticals = report.findings.filter((f) => f.severity === "critical");
   const infos = report.findings.filter((f) => f.severity === "info");
@@ -10325,27 +8781,37 @@ function renderReport(report, options) {
       sections.push(`  ${chalk4.blue("\u25CF")} ${chalk4.blue(`${infos.length} info`)}`);
     }
     sections.push("");
+    const shownRoastKeys = /* @__PURE__ */ new Set();
     const keyFindings = [...criticals, ...warnings].slice(0, 8);
     for (const finding of keyFindings) {
       const icon = finding.severity === "critical" ? chalk4.red("\u2717") : chalk4.yellow("\u26A0");
       sections.push(`  ${icon} ${chalk4.white(finding.message)}`);
+      let roastMsg;
+      let roastKey;
+      if (finding.file && roastByFile.has(finding.file)) {
+        roastKey = `file:${finding.file}`;
+        if (!shownRoastKeys.has(roastKey)) {
+          roastMsg = roastByFile.get(finding.file);
+        }
+      }
+      if (!roastMsg) {
+        const resolvedCategory = FINDING_TO_ROAST_CATEGORY[finding.category] ?? finding.category;
+        roastKey = `cat:${resolvedCategory}`;
+        if (!shownRoastKeys.has(roastKey)) {
+          roastMsg = roastByCategory.get(resolvedCategory);
+        }
+      }
+      if (roastMsg && roastKey) {
+        sections.push(`     ${chalk4.italic.dim(roastMsg)}`);
+        shownRoastKeys.add(roastKey);
+      }
     }
     sections.push("");
   }
-  if (report.roasts.length > 0) {
-    sections.push(
-      boxen(chalk4.bold.yellow(" Roast Time ") + " " + flame(), {
-        padding: { top: 0, bottom: 0, left: 1, right: 1 },
-        borderStyle: "round",
-        borderColor: "yellow"
-      })
-    );
+  const comboRoast = report.roasts.find((r) => r.target === "codebase");
+  if (comboRoast) {
+    sections.push(chalk4.italic.yellow(`  ${comboRoast.message}`));
     sections.push("");
-    for (const roast of report.roasts) {
-      sections.push(`  ${chalk4.bold.white(roast.target)}`);
-      sections.push(`  ${chalk4.yellow(roast.message)}`);
-      sections.push("");
-    }
   }
   if (report.fixes && report.fixes.length > 0) {
     sections.push(
@@ -10388,7 +8854,7 @@ function getScoreColor3(score) {
   if (score >= 60) return chalk4.rgb(255, 165, 0);
   return chalk4.red;
 }
-function renderHealthBar(score) {
+function renderHealthBar2(score) {
   const width = 30;
   const filled = Math.round(score / 100 * width);
   const empty = width - filled;
@@ -10533,7 +8999,7 @@ function renderWatchSummary(health, delta, findingCounts2) {
 }
 
 // src/compare/index.ts
-import path17 from "path";
+import path19 from "path";
 import fs33 from "fs";
 import { spawnSync as spawnSync4 } from "child_process";
 import { randomBytes } from "crypto";
@@ -10562,7 +9028,7 @@ async function compareWithBranch(rootDir, branchName, scanFunc) {
   console.log(chalk6.dim(`Scanning current working directory...`));
   const currentResult = await scanFunc(rootDir);
   const randomId = randomBytes(8).toString("hex");
-  const worktreePath = path17.join(tmpdir(), `.roast-worktree-${randomId}`);
+  const worktreePath = path19.join(tmpdir(), `.roast-worktree-${randomId}`);
   console.log(chalk6.dim(`Checking out ${branchName} to temporary worktree...`));
   let cleanupAttempted = false;
   const cleanupWorktree = async (retries = 3) => {
@@ -10655,7 +9121,7 @@ function renderComparison(comparison, branchName) {
 
 // src/config/index.ts
 import fs34 from "fs";
-import path18 from "path";
+import path20 from "path";
 
 // src/config/validation.ts
 function validateConfig(userConfig) {
@@ -10801,7 +9267,7 @@ function safeJsonParse(content) {
       return cleaned;
     }
     return parsed;
-  } catch (_error) {
+  } catch {
     return null;
   }
 }
@@ -10826,7 +9292,7 @@ var DEFAULT_CONFIG = {
   notify: void 0
 };
 function loadConfig(rootDir) {
-  const configPath = path18.join(rootDir, ".roastrc.json");
+  const configPath = path20.join(rootDir, ".roastrc.json");
   if (!fs34.existsSync(configPath)) {
     return DEFAULT_CONFIG;
   }
@@ -10898,7 +9364,7 @@ import chalk7 from "chalk";
 
 // src/interactive/fixes.ts
 import fs35 from "fs";
-import path19 from "path";
+import path21 from "path";
 import { spawnSync as spawnSync5 } from "child_process";
 async function applyAutoFix(finding, fix, rootDir, dryRun = false) {
   switch (finding.category) {
@@ -10979,7 +9445,7 @@ function fixTodoComment(finding, rootDir, dryRun) {
       message: "No file specified for TODO fix"
     };
   }
-  const filePath = path19.join(rootDir, finding.file);
+  const filePath = path21.join(rootDir, finding.file);
   try {
     const content = fs35.readFileSync(filePath, "utf-8");
     const lines = content.split("\n");
@@ -11036,7 +9502,7 @@ function fixDeadExport(finding, rootDir, dryRun) {
     };
   }
   const exportName = match[1];
-  const filePath = path19.join(rootDir, finding.file);
+  const filePath = path21.join(rootDir, finding.file);
   try {
     const content = fs35.readFileSync(filePath, "utf-8");
     const lines = content.split("\n");
@@ -11080,7 +9546,7 @@ function fixNextjsClientServer(finding, rootDir, dryRun) {
   if (!finding.file) {
     return { success: false, message: "No file specified for nextjs-client-server fix" };
   }
-  const filePath = path19.join(rootDir, finding.file);
+  const filePath = path21.join(rootDir, finding.file);
   try {
     const content = fs35.readFileSync(filePath, "utf-8");
     if (content.includes("'use client'") || content.includes('"use client"')) {
@@ -11104,7 +9570,7 @@ function fixNextjsMetadata(finding, rootDir, dryRun) {
   if (!finding.file) {
     return { success: false, message: "No file specified for nextjs-metadata fix" };
   }
-  const filePath = path19.join(rootDir, finding.file);
+  const filePath = path21.join(rootDir, finding.file);
   try {
     const content = fs35.readFileSync(filePath, "utf-8");
     if (/export.*metadata/.test(content)) {
@@ -11124,7 +9590,7 @@ function fixNextjsMetadata(finding, rootDir, dryRun) {
   }
 }
 function fixGitignoreEntry(rootDir, filename, dryRun) {
-  const gitignorePath = path19.join(rootDir, ".gitignore");
+  const gitignorePath = path21.join(rootDir, ".gitignore");
   try {
     let existing = "";
     if (fs35.existsSync(gitignorePath)) {
@@ -11151,7 +9617,7 @@ function fixEnvInGit(finding, rootDir, dryRun) {
   if (!finding.file) {
     return { success: false, message: "No file specified for env-in-git fix" };
   }
-  const filename = path19.basename(finding.file);
+  const filename = path21.basename(finding.file);
   const result = fixGitignoreEntry(rootDir, filename, dryRun);
   if (result.success) {
     return {
@@ -11168,7 +9634,7 @@ function fixTypeSafety(finding, rootDir, dryRun) {
   if (!finding.file) {
     return { success: false, message: "No file specified for type-safety fix" };
   }
-  const filePath = path19.join(rootDir, finding.file);
+  const filePath = path21.join(rootDir, finding.file);
   try {
     const content = fs35.readFileSync(filePath, "utf-8");
     const lines = content.split("\n");
@@ -11207,11 +9673,11 @@ function fixTestCoverage(finding, rootDir, dryRun) {
   }
   const srcRelative = finding.file.replace(/^src\//, "");
   const testRelative = `tests/${srcRelative.replace(/\.tsx?$/, ".test.ts")}`;
-  const testPath = path19.join(rootDir, testRelative);
+  const testPath = path21.join(rootDir, testRelative);
   if (fs35.existsSync(testPath)) {
     return { success: false, message: `Test file already exists: ${testRelative}` };
   }
-  const baseName = path19.basename(finding.file, path19.extname(finding.file));
+  const baseName = path21.basename(finding.file, path21.extname(finding.file));
   const skeleton = `import { describe, it, expect } from 'vitest';
 
 describe('${baseName}', () => {
@@ -11225,7 +9691,7 @@ describe('${baseName}', () => {
     return { success: true, message: `Would create test file: ${testRelative}` };
   }
   try {
-    fs35.mkdirSync(path19.dirname(testPath), { recursive: true });
+    fs35.mkdirSync(path21.dirname(testPath), { recursive: true });
     fs35.writeFileSync(testPath, skeleton, "utf-8");
     return { success: true, message: `Created test file: ${testRelative}` };
   } catch (error) {
@@ -11239,7 +9705,7 @@ function fixSecrets(finding, rootDir, dryRun) {
   if (!finding.file) {
     return { success: false, message: "No file specified for secrets fix" };
   }
-  const filename = path19.basename(finding.file);
+  const filename = path21.basename(finding.file);
   const result = fixGitignoreEntry(rootDir, filename, dryRun);
   const warning = " WARNING: The secret may already be in git history \u2014 consider rotating it and running: git filter-branch or git-filter-repo";
   if (result.success) {
@@ -11525,11 +9991,11 @@ function getSeverityBadge(severity) {
 
 // src/history/index.ts
 import fs36 from "fs";
-import path20 from "path";
+import path22 from "path";
 import { spawnSync as spawnSync6 } from "child_process";
 var HISTORY_FILE = ".roast-history.json";
 function loadHistory(rootDir) {
-  const historyPath = path20.join(rootDir, HISTORY_FILE);
+  const historyPath = path22.join(rootDir, HISTORY_FILE);
   if (!fs36.existsSync(historyPath)) {
     return null;
   }
@@ -11542,7 +10008,7 @@ function loadHistory(rootDir) {
   }
 }
 function saveHistory(rootDir, history) {
-  const historyPath = path20.join(rootDir, HISTORY_FILE);
+  const historyPath = path22.join(rootDir, HISTORY_FILE);
   try {
     fs36.writeFileSync(historyPath, JSON.stringify(history, null, 2), "utf-8");
   } catch (error) {
@@ -11860,7 +10326,7 @@ function getTrendColor(trend) {
 // src/incremental/index.ts
 import { spawnSync as spawnSync7 } from "child_process";
 import fs37 from "fs";
-import path21 from "path";
+import path23 from "path";
 function getChangedFiles(rootDir, baseRef) {
   const gitCheck = spawnSync7("git", ["rev-parse", "--git-dir"], {
     cwd: rootDir,
@@ -11878,7 +10344,7 @@ function getChangedFiles(rootDir, baseRef) {
     if (diffResult.status !== 0) {
       return { changedFiles: [], isIncremental: true, baseRef };
     }
-    const files = parseGitOutput(diffResult.stdout).map((f) => path21.join(rootDir, f)).filter((f) => fs37.existsSync(f));
+    const files = parseGitOutput(diffResult.stdout).map((f) => path23.join(rootDir, f)).filter((f) => fs37.existsSync(f));
     return { changedFiles: files, isIncremental: true, baseRef };
   }
   const unstagedResult = spawnSync7(
@@ -11894,7 +10360,7 @@ function getChangedFiles(rootDir, baseRef) {
   const unstagedFiles = unstagedResult.status === 0 ? parseGitOutput(unstagedResult.stdout) : [];
   const stagedFiles = stagedResult.status === 0 ? parseGitOutput(stagedResult.stdout) : [];
   const merged = Array.from(/* @__PURE__ */ new Set([...unstagedFiles, ...stagedFiles]));
-  const changedFiles = merged.map((f) => path21.join(rootDir, f)).filter((f) => fs37.existsSync(f));
+  const changedFiles = merged.map((f) => path23.join(rootDir, f)).filter((f) => fs37.existsSync(f));
   return { changedFiles, isIncremental: true, baseRef: "HEAD" };
 }
 function parseGitOutput(stdout) {
@@ -11905,13 +10371,13 @@ function filterFindingsByFiles(findings, changedFiles, rootDir) {
     return findings.filter((f) => !f.file);
   }
   const normalizedChanged = new Set(
-    changedFiles.map((f) => path21.normalize(f))
+    changedFiles.map((f) => path23.normalize(f))
   );
   return findings.filter((finding) => {
     if (!finding.file) {
       return true;
     }
-    const findingAbsolute = path21.isAbsolute(finding.file) ? path21.normalize(finding.file) : path21.normalize(path21.join(rootDir, finding.file));
+    const findingAbsolute = path23.isAbsolute(finding.file) ? path23.normalize(finding.file) : path23.normalize(path23.join(rootDir, finding.file));
     const findingForward = findingAbsolute.replace(/\\/g, "/");
     const findingBackward = findingAbsolute.replace(/\//g, "\\");
     if (normalizedChanged.has(findingAbsolute)) {
@@ -11987,10 +10453,10 @@ function filterFindingsByChangedLines(findings, changedRanges) {
 
 // src/ci/index.ts
 import fs38 from "fs";
-import path22 from "path";
+import path24 from "path";
 function detectPackageManager(rootDir) {
-  if (fs38.existsSync(path22.join(rootDir, "yarn.lock"))) return "yarn";
-  if (fs38.existsSync(path22.join(rootDir, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs38.existsSync(path24.join(rootDir, "yarn.lock"))) return "yarn";
+  if (fs38.existsSync(path24.join(rootDir, "pnpm-lock.yaml"))) return "pnpm";
   return "npm";
 }
 function generateCIWorkflow(config) {
@@ -12046,9 +10512,9 @@ ${permissionsBlock}
 `;
 }
 function writeCIWorkflow(rootDir, config) {
-  const workflowsDir = path22.join(rootDir, ".github", "workflows");
-  const filePath = path22.join(workflowsDir, "roast.yml");
-  const displayPath = filePath.split(path22.sep).join("/");
+  const workflowsDir = path24.join(rootDir, ".github", "workflows");
+  const filePath = path24.join(workflowsDir, "roast.yml");
+  const displayPath = filePath.split(path24.sep).join("/");
   if (fs38.existsSync(filePath)) {
     return { path: displayPath, alreadyExists: true };
   }
@@ -12185,13 +10651,13 @@ function formatTrendResult(result) {
 
 // src/hooks/index.ts
 import fs39 from "fs";
-import path23 from "path";
+import path25 from "path";
 function detectHuskySetup(rootDir) {
-  const huskyDir = path23.join(rootDir, ".husky");
+  const huskyDir = path25.join(rootDir, ".husky");
   if (fs39.existsSync(huskyDir) && fs39.statSync(huskyDir).isDirectory()) {
     return true;
   }
-  const pkgPath = path23.join(rootDir, "package.json");
+  const pkgPath = path25.join(rootDir, "package.json");
   if (fs39.existsSync(pkgPath)) {
     try {
       const pkg = JSON.parse(fs39.readFileSync(pkgPath, "utf-8"));
@@ -12212,8 +10678,8 @@ function installPreCommitHook(rootDir, threshold) {
   }
 }
 function _installHuskyHook(rootDir, threshold) {
-  const huskyDir = path23.join(rootDir, ".husky");
-  const hookPath = path23.join(huskyDir, "pre-commit");
+  const huskyDir = path25.join(rootDir, ".husky");
+  const hookPath = path25.join(huskyDir, "pre-commit");
   try {
     if (!fs39.existsSync(huskyDir)) {
       fs39.mkdirSync(huskyDir, { recursive: true });
@@ -12260,9 +10726,9 @@ function _installHuskyHook(rootDir, threshold) {
   }
 }
 function _installGitHook(rootDir, threshold) {
-  const gitDir = path23.join(rootDir, ".git");
-  const hooksDir = path23.join(gitDir, "hooks");
-  const hookPath = path23.join(hooksDir, "pre-commit");
+  const gitDir = path25.join(rootDir, ".git");
+  const hooksDir = path25.join(gitDir, "hooks");
+  const hookPath = path25.join(hooksDir, "pre-commit");
   if (!fs39.existsSync(gitDir) || !fs39.statSync(gitDir).isDirectory()) {
     return {
       success: false,
@@ -12325,8 +10791,8 @@ function _installGitHook(rootDir, threshold) {
   }
 }
 function uninstallPreCommitHook(rootDir) {
-  const huskyHook = path23.join(rootDir, ".husky", "pre-commit");
-  const gitHook = path23.join(rootDir, ".git", "hooks", "pre-commit");
+  const huskyHook = path25.join(rootDir, ".husky", "pre-commit");
+  const gitHook = path25.join(rootDir, ".git", "hooks", "pre-commit");
   let targetPath = null;
   if (fs39.existsSync(huskyHook)) {
     const content = fs39.readFileSync(huskyHook, "utf-8");
@@ -13236,9 +11702,9 @@ function generateDashboardHtml(report) {
 </html>`;
 }
 function startDashboard(report, port = 7777, options) {
-  let currentReport = report;
+  let _currentReport = report;
   let currentHtml = generateDashboardHtml(report);
-  let currentReportJson = JSON.stringify(report);
+  let _currentReportJson = JSON.stringify(report);
   const sseClients = /* @__PURE__ */ new Set();
   let isRescanning = false;
   function broadcast(data) {
@@ -13274,9 +11740,9 @@ function startDashboard(report, port = 7777, options) {
         isRescanning = true;
         broadcast({ type: "scanning", file: "manual" });
         options.rescan().then((newReport) => {
-          currentReport = newReport;
+          _currentReport = newReport;
           currentHtml = generateDashboardHtml(newReport);
-          currentReportJson = JSON.stringify(newReport);
+          _currentReportJson = JSON.stringify(newReport);
           broadcast({ type: "update", report: newReport });
           isRescanning = false;
         }).catch(() => {
@@ -13291,7 +11757,7 @@ function startDashboard(report, port = 7777, options) {
       res.end(currentHtml);
     } else if (req.method === "GET" && url === "/api/report") {
       res.writeHead(200, { "Content-Type": "application/json; charset=utf-8" });
-      res.end(currentReportJson);
+      res.end(_currentReportJson);
     } else if (req.method === "GET" && url === "/health") {
       res.writeHead(200, { "Content-Type": "application/json; charset=utf-8" });
       res.end('{"ok":true}');
@@ -13338,12 +11804,12 @@ function startDashboard(report, port = 7777, options) {
             broadcast({ type: "scanning", file: changedPath });
             try {
               const newReport = await options.rescan();
-              currentReport = newReport;
+              _currentReport = newReport;
               currentHtml = generateDashboardHtml(newReport);
-              currentReportJson = JSON.stringify(newReport);
+              _currentReportJson = JSON.stringify(newReport);
               broadcast({ type: "update", report: newReport });
               console.log(`  \u21BB Dashboard updated (${changedPath})`);
-            } catch (err) {
+            } catch {
               broadcast({ type: "error", message: "Rescan failed" });
             } finally {
               isRescanning = false;
@@ -13379,11 +11845,11 @@ function startDashboard(report, port = 7777, options) {
 
 // src/readme/index.ts
 import fs40 from "fs";
-import path24 from "path";
+import path26 from "path";
 function findReadmePath(rootDir) {
   const candidates = ["README.md", "readme.md", "README.MD", "Readme.md"];
   for (const name of candidates) {
-    const fullPath = path24.join(rootDir, name);
+    const fullPath = path26.join(rootDir, name);
     if (fs40.existsSync(fullPath)) {
       return fullPath;
     }
@@ -13403,7 +11869,7 @@ function updateReadmeBadge(rootDir, health) {
 ${badgeLine}
 <!-- roast-score-end -->`;
     const newContent2 = previousContent.replace(blockPattern, replacement);
-    validateOutputPath(rootDir, path24.relative(rootDir, readmePath));
+    validateOutputPath(rootDir, path26.relative(rootDir, readmePath));
     fs40.writeFileSync(readmePath, newContent2, "utf-8");
     return { updated: true, method: "html-comment", previousContent };
   }
@@ -13414,7 +11880,7 @@ ${badgeLine}
   if (badgeLineIndex !== -1) {
     lines[badgeLineIndex] = badgeLine;
     const newContent2 = lines.join("\n");
-    validateOutputPath(rootDir, path24.relative(rootDir, readmePath));
+    validateOutputPath(rootDir, path26.relative(rootDir, readmePath));
     fs40.writeFileSync(readmePath, newContent2, "utf-8");
     return { updated: true, method: "badge-line", previousContent };
   }
@@ -13427,7 +11893,7 @@ ${badgeLine}
 Generated by [roast-my-codebase](https://github.com/rahuldk1105/roast-my-codebase)
 <!-- roast-score-end -->`;
   const newContent = previousContent + appendBlock;
-  validateOutputPath(rootDir, path24.relative(rootDir, readmePath));
+  validateOutputPath(rootDir, path26.relative(rootDir, readmePath));
   fs40.writeFileSync(readmePath, newContent, "utf-8");
   return { updated: true, method: "appended", previousContent };
 }
@@ -14309,14 +12775,14 @@ var EXIT_CODES = {
 // src/cli/index.ts
 function loadPackageVersion() {
   const __filename = fileURLToPath(import.meta.url);
-  let dir = path25.dirname(__filename);
-  while (dir !== path25.dirname(dir)) {
-    const pkgPath = path25.join(dir, "package.json");
+  let dir = path27.dirname(__filename);
+  while (dir !== path27.dirname(dir)) {
+    const pkgPath = path27.join(dir, "package.json");
     if (fs41.existsSync(pkgPath)) {
       const pkg = JSON.parse(fs41.readFileSync(pkgPath, "utf-8"));
       if (pkg.name === "roast-my-codebase") return pkg.version;
     }
-    dir = path25.dirname(dir);
+    dir = path27.dirname(dir);
   }
   return "1.0.0";
 }
@@ -14327,7 +12793,7 @@ function createCli() {
     "Exit with code 1 if health score is below threshold (use with --json)",
     parseInt
   ).action(async (targetPath, options) => {
-    const rootDir = path25.resolve(targetPath);
+    const rootDir = path27.resolve(targetPath);
     if (options.explain !== void 0) {
       if (options.explain === true || options.explain === "") {
         console.log(chalk12.bold("\n  Available categories:\n"));
@@ -14441,7 +12907,7 @@ function createCli() {
         process.exit(1);
       }
       try {
-        fs41.mkdirSync(path25.join(pluginDir, "src"), { recursive: false });
+        fs41.mkdirSync(path27.join(pluginDir, "src"), { recursive: false });
       } catch (e) {
         if (e.code === "EEXIST") {
           console.log(chalk12.yellow(`
@@ -14449,9 +12915,9 @@ function createCli() {
 `));
           process.exit(1);
         }
-        fs41.mkdirSync(path25.join(pluginDir, "src"), { recursive: true });
+        fs41.mkdirSync(path27.join(pluginDir, "src"), { recursive: true });
       }
-      fs41.writeFileSync(path25.join(pluginDir, "package.json"), JSON.stringify({
+      fs41.writeFileSync(path27.join(pluginDir, "package.json"), JSON.stringify({
         name: fullName,
         version: "0.1.0",
         description: "A roast-my-codebase plugin",
@@ -14462,7 +12928,7 @@ function createCli() {
         devDependencies: { typescript: "^5.0.0" }
       }, null, 2));
       fs41.writeFileSync(
-        path25.join(pluginDir, "src", "index.ts"),
+        path27.join(pluginDir, "src", "index.ts"),
         `import type { Scanner, ScanResult, Finding } from 'roast-my-codebase/types';
 
 export default {
@@ -14479,7 +12945,7 @@ export default {
 };
 `
       );
-      fs41.writeFileSync(path25.join(pluginDir, "tsconfig.json"), JSON.stringify({
+      fs41.writeFileSync(path27.join(pluginDir, "tsconfig.json"), JSON.stringify({
         compilerOptions: {
           target: "ES2022",
           module: "NodeNext",
@@ -14506,7 +12972,7 @@ export default {
         console.error(`Error: "${rootDir}" does not exist.`);
         process.exit(1);
       }
-      const { BundleSizeScanner: BundleSizeScannerDynamic } = await import("./bundle-OG535XKC.js");
+      const { BundleSizeScanner: BundleSizeScannerDynamic } = await import("./bundle-U2Y5OE4Z.js");
       const scanner = new BundleSizeScannerDynamic();
       const result = await scanner.scan(rootDir);
       const stats = result.stats;
@@ -14544,9 +13010,9 @@ export default {
       process.exit(1);
     }
     if (options.file) {
-      const targetFile = path25.resolve(rootDir, options.file);
-      const normalizedRootForFile = path25.resolve(rootDir);
-      if (!targetFile.startsWith(normalizedRootForFile + path25.sep) && targetFile !== normalizedRootForFile) {
+      const targetFile = path27.resolve(rootDir, options.file);
+      const normalizedRootForFile = path27.resolve(rootDir);
+      if (!targetFile.startsWith(normalizedRootForFile + path27.sep) && targetFile !== normalizedRootForFile) {
         console.error(chalk12.red(`
 Security: --file path must be within the project directory.
 `));
@@ -14596,7 +13062,7 @@ ${options.file} is a directory. Use --file with a specific file.
         ...fileDuplicateResult.findings,
         ...fileDeadExportResult.findings
       );
-      const fileExt = path25.extname(targetFile).toLowerCase();
+      const fileExt = path27.extname(targetFile).toLowerCase();
       if (fileExt === ".py") {
         const pyResults = await Promise.all([
           new PythonComplexityScanner().scan(rootDir),
@@ -14625,7 +13091,7 @@ ${options.file} is a directory. Use --file with a specific file.
         fileAllFindings.push(...rsResults.flatMap((r) => r.findings));
       }
       fileSpinner.stop();
-      const relFilePath = path25.relative(rootDir, targetFile).replace(/\\/g, "/");
+      const relFilePath = path27.relative(rootDir, targetFile).replace(/\\/g, "/");
       const fileFindings = fileAllFindings.filter(
         (f) => f.file && (f.file === relFilePath || f.file.replace(/\\/g, "/") === relFilePath)
       );
@@ -15217,9 +13683,9 @@ Warning: Custom rules scanner failed: ${error instanceof Error ? error.message :
         return;
       }
       if (options.outputDir) {
-        const resolvedOutputDir = path25.resolve(rootDir, options.outputDir);
-        const normalizedRoot = path25.resolve(rootDir);
-        if (!resolvedOutputDir.startsWith(normalizedRoot + path25.sep) && resolvedOutputDir !== normalizedRoot) {
+        const resolvedOutputDir = path27.resolve(rootDir, options.outputDir);
+        const normalizedRoot = path27.resolve(rootDir);
+        if (!resolvedOutputDir.startsWith(normalizedRoot + path27.sep) && resolvedOutputDir !== normalizedRoot) {
           console.error(chalk12.red(`
 Error: --output-dir path "${options.outputDir}" escapes the project directory.
 `));
@@ -15231,7 +13697,7 @@ Error: --output-dir path "${options.outputDir}" escapes the project directory.
 \u2713 Reports saved to ${options.outputDir}/
 `));
           for (const file of outputResult.files) {
-            console.log(chalk12.dim(`  ${path25.basename(file)}`));
+            console.log(chalk12.dim(`  ${path27.basename(file)}`));
           }
           console.log();
         } else {
@@ -15391,7 +13857,7 @@ Error: --output-dir path "${options.outputDir}" escapes the project directory.
       console.error("Analysis failed:", sanitizeError(error));
       if (process.env.DEBUG) {
         try {
-          const debugPath = path25.join(rootDir, ".roast-debug.log");
+          const debugPath = path27.join(rootDir, ".roast-debug.log");
           const timestamp = (/* @__PURE__ */ new Date()).toISOString();
           const errorStr = error instanceof Error ? error.stack : String(error);
           fs41.appendFileSync(debugPath, `${timestamp}: ${errorStr}
@@ -15406,12 +13872,12 @@ Error: --output-dir path "${options.outputDir}" escapes the project directory.
   return program2;
 }
 function getProjectName(rootDir) {
-  const pkgPath = path25.join(rootDir, "package.json");
+  const pkgPath = path27.join(rootDir, "package.json");
   try {
     const pkg = JSON.parse(fs41.readFileSync(pkgPath, "utf-8"));
-    return pkg.name || path25.basename(rootDir);
+    return pkg.name || path27.basename(rootDir);
   } catch {
-    return path25.basename(rootDir);
+    return path27.basename(rootDir);
   }
 }