@kevisual/project-search 0.0.3 → 0.0.5

package/dist/remote.js

@@ -5312,1841 +5312,6 @@ var require_out4 = __commonJS((exports, module) => {
   module.exports = FastGlob;
 });
 
-// ../../node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/lib/constants.js
-var require_constants5 = __commonJS((exports, module) => {
-  var WIN_SLASH = "\\\\/";
-  var WIN_NO_SLASH = `[^${WIN_SLASH}]`;
-  var DOT_LITERAL = "\\.";
-  var PLUS_LITERAL = "\\+";
-  var QMARK_LITERAL = "\\?";
-  var SLASH_LITERAL = "\\/";
-  var ONE_CHAR = "(?=.)";
-  var QMARK = "[^/]";
-  var END_ANCHOR = `(?:${SLASH_LITERAL}|$)`;
-  var START_ANCHOR = `(?:^|${SLASH_LITERAL})`;
-  var DOTS_SLASH = `${DOT_LITERAL}{1,2}${END_ANCHOR}`;
-  var NO_DOT = `(?!${DOT_LITERAL})`;
-  var NO_DOTS = `(?!${START_ANCHOR}${DOTS_SLASH})`;
-  var NO_DOT_SLASH = `(?!${DOT_LITERAL}{0,1}${END_ANCHOR})`;
-  var NO_DOTS_SLASH = `(?!${DOTS_SLASH})`;
-  var QMARK_NO_DOT = `[^.${SLASH_LITERAL}]`;
-  var STAR = `${QMARK}*?`;
-  var SEP = "/";
-  var POSIX_CHARS = {
-    DOT_LITERAL,
-    PLUS_LITERAL,
-    QMARK_LITERAL,
-    SLASH_LITERAL,
-    ONE_CHAR,
-    QMARK,
-    END_ANCHOR,
-    DOTS_SLASH,
-    NO_DOT,
-    NO_DOTS,
-    NO_DOT_SLASH,
-    NO_DOTS_SLASH,
-    QMARK_NO_DOT,
-    STAR,
-    START_ANCHOR,
-    SEP
-  };
-  var WINDOWS_CHARS = {
-    ...POSIX_CHARS,
-    SLASH_LITERAL: `[${WIN_SLASH}]`,
-    QMARK: WIN_NO_SLASH,
-    STAR: `${WIN_NO_SLASH}*?`,
-    DOTS_SLASH: `${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$)`,
-    NO_DOT: `(?!${DOT_LITERAL})`,
-    NO_DOTS: `(?!(?:^|[${WIN_SLASH}])${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
-    NO_DOT_SLASH: `(?!${DOT_LITERAL}{0,1}(?:[${WIN_SLASH}]|$))`,
-    NO_DOTS_SLASH: `(?!${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
-    QMARK_NO_DOT: `[^.${WIN_SLASH}]`,
-    START_ANCHOR: `(?:^|[${WIN_SLASH}])`,
-    END_ANCHOR: `(?:[${WIN_SLASH}]|$)`,
-    SEP: "\\"
-  };
-  var POSIX_REGEX_SOURCE = {
-    alnum: "a-zA-Z0-9",
-    alpha: "a-zA-Z",
-    ascii: "\\x00-\\x7F",
-    blank: " \\t",
-    cntrl: "\\x00-\\x1F\\x7F",
-    digit: "0-9",
-    graph: "\\x21-\\x7E",
-    lower: "a-z",
-    print: "\\x20-\\x7E ",
-    punct: "\\-!\"#$%&'()\\*+,./:;<=>?@[\\]^_`{|}~",
-    space: " \\t\\r\\n\\v\\f",
-    upper: "A-Z",
-    word: "A-Za-z0-9_",
-    xdigit: "A-Fa-f0-9"
-  };
-  module.exports = {
-    MAX_LENGTH: 1024 * 64,
-    POSIX_REGEX_SOURCE,
-    REGEX_BACKSLASH: /\\(?![*+?^${}(|)[\]])/g,
-    REGEX_NON_SPECIAL_CHARS: /^[^@![\].,$*+?^{}()|\\/]+/,
-    REGEX_SPECIAL_CHARS: /[-*+?.^${}(|)[\]]/,
-    REGEX_SPECIAL_CHARS_BACKREF: /(\\?)((\W)(\3*))/g,
-    REGEX_SPECIAL_CHARS_GLOBAL: /([-*+?.^${}(|)[\]])/g,
-    REGEX_REMOVE_BACKSLASH: /(?:\[.*?[^\\]\]|\\(?=.))/g,
-    REPLACEMENTS: {
-      __proto__: null,
-      "***": "*",
-      "**/**": "**",
-      "**/**/**": "**"
-    },
-    CHAR_0: 48,
-    CHAR_9: 57,
-    CHAR_UPPERCASE_A: 65,
-    CHAR_LOWERCASE_A: 97,
-    CHAR_UPPERCASE_Z: 90,
-    CHAR_LOWERCASE_Z: 122,
-    CHAR_LEFT_PARENTHESES: 40,
-    CHAR_RIGHT_PARENTHESES: 41,
-    CHAR_ASTERISK: 42,
-    CHAR_AMPERSAND: 38,
-    CHAR_AT: 64,
-    CHAR_BACKWARD_SLASH: 92,
-    CHAR_CARRIAGE_RETURN: 13,
-    CHAR_CIRCUMFLEX_ACCENT: 94,
-    CHAR_COLON: 58,
-    CHAR_COMMA: 44,
-    CHAR_DOT: 46,
-    CHAR_DOUBLE_QUOTE: 34,
-    CHAR_EQUAL: 61,
-    CHAR_EXCLAMATION_MARK: 33,
-    CHAR_FORM_FEED: 12,
-    CHAR_FORWARD_SLASH: 47,
-    CHAR_GRAVE_ACCENT: 96,
-    CHAR_HASH: 35,
-    CHAR_HYPHEN_MINUS: 45,
-    CHAR_LEFT_ANGLE_BRACKET: 60,
-    CHAR_LEFT_CURLY_BRACE: 123,
-    CHAR_LEFT_SQUARE_BRACKET: 91,
-    CHAR_LINE_FEED: 10,
-    CHAR_NO_BREAK_SPACE: 160,
-    CHAR_PERCENT: 37,
-    CHAR_PLUS: 43,
-    CHAR_QUESTION_MARK: 63,
-    CHAR_RIGHT_ANGLE_BRACKET: 62,
-    CHAR_RIGHT_CURLY_BRACE: 125,
-    CHAR_RIGHT_SQUARE_BRACKET: 93,
-    CHAR_SEMICOLON: 59,
-    CHAR_SINGLE_QUOTE: 39,
-    CHAR_SPACE: 32,
-    CHAR_TAB: 9,
-    CHAR_UNDERSCORE: 95,
-    CHAR_VERTICAL_LINE: 124,
-    CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279,
-    extglobChars(chars) {
-      return {
-        "!": { type: "negate", open: "(?:(?!(?:", close: `))${chars.STAR})` },
-        "?": { type: "qmark", open: "(?:", close: ")?" },
-        "+": { type: "plus", open: "(?:", close: ")+" },
-        "*": { type: "star", open: "(?:", close: ")*" },
-        "@": { type: "at", open: "(?:", close: ")" }
-      };
-    },
-    globChars(win32) {
-      return win32 === true ? WINDOWS_CHARS : POSIX_CHARS;
-    }
-  };
-});
-
-// ../../node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/lib/utils.js
-var require_utils5 = __commonJS((exports) => {
-  var {
-    REGEX_BACKSLASH,
-    REGEX_REMOVE_BACKSLASH,
-    REGEX_SPECIAL_CHARS,
-    REGEX_SPECIAL_CHARS_GLOBAL
-  } = require_constants5();
-  exports.isObject = (val) => val !== null && typeof val === "object" && !Array.isArray(val);
-  exports.hasRegexChars = (str) => REGEX_SPECIAL_CHARS.test(str);
-  exports.isRegexChar = (str) => str.length === 1 && exports.hasRegexChars(str);
-  exports.escapeRegex = (str) => str.replace(REGEX_SPECIAL_CHARS_GLOBAL, "\\$1");
-  exports.toPosixSlashes = (str) => str.replace(REGEX_BACKSLASH, "/");
-  exports.isWindows = () => {
-    if (typeof navigator !== "undefined" && navigator.platform) {
-      const platform = navigator.platform.toLowerCase();
-      return platform === "win32" || platform === "windows";
-    }
-    if (typeof process !== "undefined" && process.platform) {
-      return process.platform === "win32";
-    }
-    return false;
-  };
-  exports.removeBackslashes = (str) => {
-    return str.replace(REGEX_REMOVE_BACKSLASH, (match) => {
-      return match === "\\" ? "" : match;
-    });
-  };
-  exports.escapeLast = (input, char, lastIdx) => {
-    const idx = input.lastIndexOf(char, lastIdx);
-    if (idx === -1)
-      return input;
-    if (input[idx - 1] === "\\")
-      return exports.escapeLast(input, char, idx - 1);
-    return `${input.slice(0, idx)}\\${input.slice(idx)}`;
-  };
-  exports.removePrefix = (input, state = {}) => {
-    let output = input;
-    if (output.startsWith("./")) {
-      output = output.slice(2);
-      state.prefix = "./";
-    }
-    return output;
-  };
-  exports.wrapOutput = (input, state = {}, options = {}) => {
-    const prepend = options.contains ? "" : "^";
-    const append = options.contains ? "" : "$";
-    let output = `${prepend}(?:${input})${append}`;
-    if (state.negated === true) {
-      output = `(?:^(?!${output}).*$)`;
-    }
-    return output;
-  };
-  exports.basename = (path3, { windows } = {}) => {
-    const segs = path3.split(windows ? /[\\/]/ : "/");
-    const last = segs[segs.length - 1];
-    if (last === "") {
-      return segs[segs.length - 2];
-    }
-    return last;
-  };
-});
-
-// ../../node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/lib/scan.js
-var require_scan2 = __commonJS((exports, module) => {
-  var utils = require_utils5();
-  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_constants5();
-  var isPathSeparator = (code) => {
-    return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH;
-  };
-  var depth = (token) => {
-    if (token.isPrefix !== true) {
-      token.depth = token.isGlobstar ? Infinity : 1;
-    }
-  };
-  var scan = (input, options) => {
-    const opts = options || {};
-    const length = input.length - 1;
-    const scanToEnd = opts.parts === true || opts.scanToEnd === true;
-    const slashes = [];
-    const tokens = [];
-    const parts = [];
-    let str = input;
-    let index = -1;
-    let start = 0;
-    let lastIndex = 0;
-    let isBrace = false;
-    let isBracket = false;
-    let isGlob = false;
-    let isExtglob = false;
-    let isGlobstar = false;
-    let braceEscaped = false;
-    let backslashes = false;
-    let negated = false;
-    let negatedExtglob = false;
-    let finished = false;
-    let braces = 0;
-    let prev;
-    let code;
-    let token = { value: "", depth: 0, isGlob: false };
-    const eos = () => index >= length;
-    const peek = () => str.charCodeAt(index + 1);
-    const advance = () => {
-      prev = code;
-      return str.charCodeAt(++index);
-    };
-    while (index < length) {
-      code = advance();
-      let next;
-      if (code === CHAR_BACKWARD_SLASH) {
-        backslashes = token.backslashes = true;
-        code = advance();
-        if (code === CHAR_LEFT_CURLY_BRACE) {
-          braceEscaped = true;
-        }
-        continue;
-      }
-      if (braceEscaped === true || code === CHAR_LEFT_CURLY_BRACE) {
-        braces++;
-        while (eos() !== true && (code = advance())) {
-          if (code === CHAR_BACKWARD_SLASH) {
-            backslashes = token.backslashes = true;
-            advance();
-            continue;
-          }
-          if (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,
-      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 = input.slice(n, i);
-        if (opts.tokens) {
-          if (idx === 0 && start !== 0) {
-            tokens[idx].isPrefix = true;
-            tokens[idx].value = prefix;
-          } else {
-            tokens[idx].value = value;
-          }
-          depth(tokens[idx]);
-          state.maxDepth += tokens[idx].depth;
-        }
-        if (idx !== 0 || value !== "") {
-          parts.push(value);
-        }
-        prevIndex = i;
-      }
-      if (prevIndex && prevIndex + 1 < input.length) {
-        const value = input.slice(prevIndex + 1);
-        parts.push(value);
-        if (opts.tokens) {
-          tokens[tokens.length - 1].value = value;
-          depth(tokens[tokens.length - 1]);
-          state.maxDepth += tokens[tokens.length - 1].depth;
-        }
-      }
-      state.slashes = slashes;
-      state.parts = parts;
-    }
-    return state;
-  };
-  module.exports = scan;
-});
-
-// ../../node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/lib/parse.js
-var require_parse3 = __commonJS((exports, module) => {
-  var constants = require_constants5();
-  var utils = require_utils5();
-  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 parse2 = (input, options) => {
-    if (typeof input !== "string") {
-      throw new TypeError("Expected a string");
-    }
-    input = REPLACEMENTS[input] || input;
-    const opts = { ...options };
-    const max = typeof opts.maxLength === "number" ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
-    let len = input.length;
-    if (len > max) {
-      throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
-    }
-    const bos = { type: "bos", value: "", output: opts.prepend || "" };
-    const tokens = [bos];
-    const capture = opts.capture ? "" : "?:";
-    const PLATFORM_CHARS = constants.globChars(opts.windows);
-    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,
-      index: -1,
-      start: 0,
-      dot: opts.dot === true,
-      consumed: "",
-      output: "",
-      prefix: "",
-      backtrack: false,
-      negated: false,
-      brackets: 0,
-      braces: 0,
-      parens: 0,
-      quotes: 0,
-      globstar: false,
-      tokens
-    };
-    input = utils.removePrefix(input, state);
-    len = input.length;
-    const extglobs = [];
-    const braces = [];
-    const stack = [];
-    let prev = bos;
-    let value;
-    const eos = () => state.index === len - 1;
-    const peek = state.peek = (n = 1) => input[state.index + n];
-    const advance = state.advance = () => input[++state.index] || "";
-    const remaining = () => input.slice(state.index + 1);
-    const consume = (value2 = "", num = 0) => {
-      state.consumed += value2;
-      state.index += num;
-    };
-    const append = (token) => {
-      state.output += token.output != null ? token.output : token.value;
-      consume(token.value);
-    };
-    const negate = () => {
-      let count = 1;
-      while (peek() === "!" && (peek(2) !== "(" || peek(3) === "?")) {
-        advance();
-        state.start++;
-        count++;
-      }
-      if (count % 2 === 0) {
-        return false;
-      }
-      state.negated = true;
-      state.start++;
-      return true;
-    };
-    const increment = (type) => {
-      state[type]++;
-      stack.push(type);
-    };
-    const decrement = (type) => {
-      state[type]--;
-      stack.pop();
-    };
-    const push = (tok) => {
-      if (prev.type === "globstar") {
-        const isBrace = state.braces > 0 && (tok.type === "comma" || tok.type === "brace");
-        const isExtglob = tok.extglob === true || extglobs.length && (tok.type === "pipe" || tok.type === "paren");
-        if (tok.type !== "slash" && tok.type !== "paren" && !isBrace && !isExtglob) {
-          state.output = state.output.slice(0, -prev.output.length);
-          prev.type = "star";
-          prev.value = "*";
-          prev.output = star;
-          state.output += prev.output;
-        }
-      }
-      if (extglobs.length && tok.type !== "paren") {
-        extglobs[extglobs.length - 1].inner += tok.value;
-      }
-      if (tok.value || tok.output)
-        append(tok);
-      if (prev && prev.type === "text" && tok.type === "text") {
-        prev.output = (prev.output || prev.value) + tok.value;
-        prev.value += tok.value;
-        return;
-      }
-      tok.prev = prev;
-      tokens.push(tok);
-      prev = tok;
-    };
-    const extglobOpen = (type, value2) => {
-      const token = { ...EXTGLOB_CHARS[value2], conditions: 1, inner: "" };
-      token.prev = prev;
-      token.parens = state.parens;
-      token.output = state.output;
-      const output = (opts.capture ? "(" : "") + token.open;
-      increment("parens");
-      push({ type, value: value2, output: state.output ? "" : ONE_CHAR });
-      push({ type: "paren", extglob: true, value: advance(), output });
-      extglobs.push(token);
-    };
-    const extglobClose = (token) => {
-      let output = token.close + (opts.capture ? ")" : "");
-      let rest;
-      if (token.type === "negate") {
-        let extglobStar = star;
-        if (token.inner && token.inner.length > 1 && token.inner.includes("/")) {
-          extglobStar = globstar(opts);
-        }
-        if (extglobStar !== star || eos() || /^\)+$/.test(remaining())) {
-          output = token.close = `)$))${extglobStar}`;
-        }
-        if (token.inner.includes("*") && (rest = remaining()) && /^\.[^\\/.]+$/.test(rest)) {
-          const expression = parse2(rest, { ...options, fastpaths: false }).output;
-          output = token.close = `)${expression})${extglobStar})`;
-        }
-        if (token.prev.type === "bos") {
-          state.negatedExtglob = true;
-        }
-      }
-      push({ type: "paren", extglob: true, value, output });
-      decrement("parens");
-    };
-    if (opts.fastpaths !== false && !/(^[*!]|[/()[\]{}"])/.test(input)) {
-      let backslashes = false;
-      let output = input.replace(REGEX_SPECIAL_CHARS_BACKREF, (m, esc2, chars, first, rest, index) => {
-        if (first === "\\") {
-          backslashes = true;
-          return m;
-        }
-        if (first === "?") {
-          if (esc2) {
-            return esc2 + first + (rest ? QMARK.repeat(rest.length) : "");
-          }
-          if (index === 0) {
-            return qmarkNoDot + (rest ? QMARK.repeat(rest.length) : "");
-          }
-          return QMARK.repeat(chars.length);
-        }
-        if (first === ".") {
-          return DOT_LITERAL.repeat(chars.length);
-        }
-        if (first === "*") {
-          if (esc2) {
-            return esc2 + first + (rest ? star : "");
-          }
-          return star;
-        }
-        return esc2 ? m : `\\${m}`;
-      });
-      if (backslashes === true) {
-        if (opts.unescape === true) {
-          output = output.replace(/\\/g, "");
-        } else {
-          output = output.replace(/\\+/g, (m) => {
-            return m.length % 2 === 0 ? "\\\\" : m ? "\\" : "";
-          });
-        }
-      }
-      if (output === input && opts.contains === true) {
-        state.output = input;
-        return state;
-      }
-      state.output = utils.wrapOutput(output, state, options);
-      return state;
-    }
-    while (!eos()) {
-      value = advance();
-      if (value === "\x00") {
-        continue;
-      }
-      if (value === "\\") {
-        const next = peek();
-        if (next === "/" && opts.bash !== true) {
-          continue;
-        }
-        if (next === "." || next === ";") {
-          continue;
-        }
-        if (!next) {
-          value += "\\";
-          push({ type: "text", value });
-          continue;
-        }
-        const match = /^\\+/.exec(remaining());
-        let slashes = 0;
-        if (match && match[0].length > 2) {
-          slashes = match[0].length;
-          state.index += slashes;
-          if (slashes % 2 !== 0) {
-            value += "\\";
-          }
-        }
-        if (opts.unescape === true) {
-          value = advance();
-        } else {
-          value += advance();
-        }
-        if (state.brackets === 0) {
-          push({ type: "text", value });
-          continue;
-        }
-      }
-      if (state.brackets > 0 && (value !== "]" || prev.value === "[" || prev.value === "[^")) {
-        if (opts.posix !== false && value === ":") {
-          const inner = prev.value.slice(1);
-          if (inner.includes("[")) {
-            prev.posix = true;
-            if (inner.includes(":")) {
-              const idx = prev.value.lastIndexOf("[");
-              const pre = prev.value.slice(0, idx);
-              const rest2 = prev.value.slice(idx + 2);
-              const posix = POSIX_REGEX_SOURCE[rest2];
-              if (posix) {
-                prev.value = pre + posix;
-                state.backtrack = true;
-                advance();
-                if (!bos.output && tokens.indexOf(prev) === 1) {
-                  bos.output = ONE_CHAR;
-                }
-                continue;
-              }
-            }
-          }
-        }
-        if (value === "[" && peek() !== ":" || value === "-" && peek() === "]") {
-          value = `\\${value}`;
-        }
-        if (value === "]" && (prev.value === "[" || prev.value === "[^")) {
-          value = `\\${value}`;
-        }
-        if (opts.posix === true && value === "!" && prev.value === "[") {
-          value = "^";
-        }
-        prev.value += value;
-        append({ value });
-        continue;
-      }
-      if (state.quotes === 1 && value !== '"') {
-        value = utils.escapeRegex(value);
-        prev.value += value;
-        append({ value });
-        continue;
-      }
-      if (value === '"') {
-        state.quotes = state.quotes === 1 ? 0 : 1;
-        if (opts.keepQuotes === true) {
-          push({ type: "text", value });
-        }
-        continue;
-      }
-      if (value === "(") {
-        increment("parens");
-        push({ type: "paren", value });
-        continue;
-      }
-      if (value === ")") {
-        if (state.parens === 0 && opts.strictBrackets === true) {
-          throw new SyntaxError(syntaxError("opening", "("));
-        }
-        const extglob = extglobs[extglobs.length - 1];
-        if (extglob && state.parens === extglob.parens + 1) {
-          extglobClose(extglobs.pop());
-          continue;
-        }
-        push({ type: "paren", value, output: state.parens ? ")" : "\\)" });
-        decrement("parens");
-        continue;
-      }
-      if (value === "[") {
-        if (opts.nobracket === true || !remaining().includes("]")) {
-          if (opts.nobracket !== true && opts.strictBrackets === true) {
-            throw new SyntaxError(syntaxError("closing", "]"));
-          }
-          value = `\\${value}`;
-        } else {
-          increment("brackets");
-        }
-        push({ type: "bracket", value });
-        continue;
-      }
-      if (value === "]") {
-        if (opts.nobracket === true || prev && prev.type === "bracket" && prev.value.length === 1) {
-          push({ type: "text", value, output: `\\${value}` });
-          continue;
-        }
-        if (state.brackets === 0) {
-          if (opts.strictBrackets === true) {
-            throw new SyntaxError(syntaxError("opening", "["));
-          }
-          push({ type: "text", value, output: `\\${value}` });
-          continue;
-        }
-        decrement("brackets");
-        const prevValue = prev.value.slice(1);
-        if (prev.posix !== true && prevValue[0] === "^" && !prevValue.includes("/")) {
-          value = `/${value}`;
-        }
-        prev.value += value;
-        append({ value });
-        if (opts.literalBrackets === false || utils.hasRegexChars(prevValue)) {
-          continue;
-        }
-        const escaped = utils.escapeRegex(prev.value);
-        state.output = state.output.slice(0, -prev.value.length);
-        if (opts.literalBrackets === true) {
-          state.output += escaped;
-          prev.value = escaped;
-          continue;
-        }
-        prev.value = `(${capture}${escaped}|${prev.value})`;
-        state.output += prev.value;
-        continue;
-      }
-      if (value === "{" && opts.nobrace !== true) {
-        increment("braces");
-        const open = {
-          type: "brace",
-          value,
-          output: "(",
-          outputIndex: state.output.length,
-          tokensIndex: state.tokens.length
-        };
-        braces.push(open);
-        push(open);
-        continue;
-      }
-      if (value === "}") {
-        const brace = braces[braces.length - 1];
-        if (opts.nobrace === true || !brace) {
-          push({ type: "text", value, output: value });
-          continue;
-        }
-        let output = ")";
-        if (brace.dots === true) {
-          const arr = tokens.slice();
-          const range = [];
-          for (let i = arr.length - 1;i >= 0; i--) {
-            tokens.pop();
-            if (arr[i].type === "brace") {
-              break;
-            }
-            if (arr[i].type !== "dots") {
-              range.unshift(arr[i].value);
-            }
-          }
-          output = expandRange(range, opts);
-          state.backtrack = true;
-        }
-        if (brace.comma !== true && brace.dots !== true) {
-          const out = state.output.slice(0, brace.outputIndex);
-          const toks = state.tokens.slice(brace.tokensIndex);
-          brace.value = brace.output = "\\{";
-          value = output = "\\}";
-          state.output = out;
-          for (const t of toks) {
-            state.output += t.output || t.value;
-          }
-        }
-        push({ type: "brace", value, output });
-        decrement("braces");
-        braces.pop();
-        continue;
-      }
-      if (value === "|") {
-        if (extglobs.length > 0) {
-          extglobs[extglobs.length - 1].conditions++;
-        }
-        push({ type: "text", value });
-        continue;
-      }
-      if (value === ",") {
-        let output = value;
-        const brace = braces[braces.length - 1];
-        if (brace && stack[stack.length - 1] === "braces") {
-          brace.comma = true;
-          output = "|";
-        }
-        push({ type: "comma", value, output });
-        continue;
-      }
-      if (value === "/") {
-        if (prev.type === "dot" && state.index === state.start + 1) {
-          state.start = state.index + 1;
-          state.consumed = "";
-          state.output = "";
-          tokens.pop();
-          prev = bos;
-          continue;
-        }
-        push({ type: "slash", value, output: SLASH_LITERAL });
-        continue;
-      }
-      if (value === ".") {
-        if (state.braces > 0 && prev.type === "dot") {
-          if (prev.value === ".")
-            prev.output = DOT_LITERAL;
-          const brace = braces[braces.length - 1];
-          prev.type = "dots";
-          prev.output += value;
-          prev.value += value;
-          brace.dots = true;
-          continue;
-        }
-        if (state.braces + state.parens === 0 && prev.type !== "bos" && prev.type !== "slash") {
-          push({ type: "text", value, output: DOT_LITERAL });
-          continue;
-        }
-        push({ type: "dot", value, output: DOT_LITERAL });
-        continue;
-      }
-      if (value === "?") {
-        const isGroup = prev && prev.value === "(";
-        if (!isGroup && opts.noextglob !== true && peek() === "(" && peek(2) !== "?") {
-          extglobOpen("qmark", value);
-          continue;
-        }
-        if (prev && prev.type === "paren") {
-          const next = peek();
-          let output = value;
-          if (prev.value === "(" && !/[!=<:]/.test(next) || next === "<" && !/<([!=]|\w+>)/.test(remaining())) {
-            output = `\\${value}`;
-          }
-          push({ type: "text", value, output });
-          continue;
-        }
-        if (opts.dot !== true && (prev.type === "slash" || prev.type === "bos")) {
-          push({ type: "qmark", value, output: QMARK_NO_DOT });
-          continue;
-        }
-        push({ type: "qmark", value, output: QMARK });
-        continue;
-      }
-      if (value === "!") {
-        if (opts.noextglob !== true && peek() === "(") {
-          if (peek(2) !== "?" || !/[!=<:]/.test(peek(3))) {
-            extglobOpen("negate", value);
-            continue;
-          }
-        }
-        if (opts.nonegate !== true && state.index === 0) {
-          negate();
-          continue;
-        }
-      }
-      if (value === "+") {
-        if (opts.noextglob !== true && peek() === "(" && peek(2) !== "?") {
-          extglobOpen("plus", value);
-          continue;
-        }
-        if (prev && prev.value === "(" || opts.regex === false) {
-          push({ type: "plus", value, output: PLUS_LITERAL });
-          continue;
-        }
-        if (prev && (prev.type === "bracket" || prev.type === "paren" || prev.type === "brace") || state.parens > 0) {
-          push({ type: "plus", value });
-          continue;
-        }
-        push({ type: "plus", value: PLUS_LITERAL });
-        continue;
-      }
-      if (value === "@") {
-        if (opts.noextglob !== true && peek() === "(" && peek(2) !== "?") {
-          push({ type: "at", extglob: true, value, output: "" });
-          continue;
-        }
-        push({ type: "text", value });
-        continue;
-      }
-      if (value !== "*") {
-        if (value === "$" || value === "^") {
-          value = `\\${value}`;
-        }
-        const match = REGEX_NON_SPECIAL_CHARS.exec(remaining());
-        if (match) {
-          value += match[0];
-          state.index += match[0].length;
-        }
-        push({ type: "text", value });
-        continue;
-      }
-      if (prev && (prev.type === "globstar" || prev.star === true)) {
-        prev.type = "star";
-        prev.star = true;
-        prev.value += value;
-        prev.output = star;
-        state.backtrack = true;
-        state.globstar = true;
-        consume(value);
-        continue;
-      }
-      let rest = remaining();
-      if (opts.noextglob !== true && /^\([^?]/.test(rest)) {
-        extglobOpen("star", value);
-        continue;
-      }
-      if (prev.type === "star") {
-        if (opts.noglobstar === true) {
-          consume(value);
-          continue;
-        }
-        const prior = prev.prev;
-        const before = prior.prev;
-        const isStart = prior.type === "slash" || prior.type === "bos";
-        const afterStar = before && (before.type === "star" || before.type === "globstar");
-        if (opts.bash === true && (!isStart || rest[0] && rest[0] !== "/")) {
-          push({ type: "star", value, output: "" });
-          continue;
-        }
-        const isBrace = state.braces > 0 && (prior.type === "comma" || prior.type === "brace");
-        const isExtglob = extglobs.length && (prior.type === "pipe" || prior.type === "paren");
-        if (!isStart && prior.type !== "paren" && !isBrace && !isExtglob) {
-          push({ type: "star", value, output: "" });
-          continue;
-        }
-        while (rest.slice(0, 3) === "/**") {
-          const after = input[state.index + 4];
-          if (after && after !== "/") {
-            break;
-          }
-          rest = rest.slice(3);
-          consume("/**", 3);
-        }
-        if (prior.type === "bos" && eos()) {
-          prev.type = "globstar";
-          prev.value += value;
-          prev.output = globstar(opts);
-          state.output = prev.output;
-          state.globstar = true;
-          consume(value);
-          continue;
-        }
-        if (prior.type === "slash" && prior.prev.type !== "bos" && !afterStar && eos()) {
-          state.output = state.output.slice(0, -(prior.output + prev.output).length);
-          prior.output = `(?:${prior.output}`;
-          prev.type = "globstar";
-          prev.output = globstar(opts) + (opts.strictSlashes ? ")" : "|$)");
-          prev.value += value;
-          state.globstar = true;
-          state.output += prior.output + prev.output;
-          consume(value);
-          continue;
-        }
-        if (prior.type === "slash" && prior.prev.type !== "bos" && rest[0] === "/") {
-          const end = rest[1] !== undefined ? "|$" : "";
-          state.output = state.output.slice(0, -(prior.output + prev.output).length);
-          prior.output = `(?:${prior.output}`;
-          prev.type = "globstar";
-          prev.output = `${globstar(opts)}${SLASH_LITERAL}|${SLASH_LITERAL}${end})`;
-          prev.value += value;
-          state.output += prior.output + prev.output;
-          state.globstar = true;
-          consume(value + advance());
-          push({ type: "slash", value: "/", output: "" });
-          continue;
-        }
-        if (prior.type === "bos" && rest[0] === "/") {
-          prev.type = "globstar";
-          prev.value += value;
-          prev.output = `(?:^|${SLASH_LITERAL}|${globstar(opts)}${SLASH_LITERAL})`;
-          state.output = prev.output;
-          state.globstar = true;
-          consume(value + advance());
-          push({ type: "slash", value: "/", output: "" });
-          continue;
-        }
-        state.output = state.output.slice(0, -prev.output.length);
-        prev.type = "globstar";
-        prev.output = globstar(opts);
-        prev.value += value;
-        state.output += prev.output;
-        state.globstar = true;
-        consume(value);
-        continue;
-      }
-      const token = { type: "star", value, output: star };
-      if (opts.bash === true) {
-        token.output = ".*?";
-        if (prev.type === "bos" || prev.type === "slash") {
-          token.output = nodot + token.output;
-        }
-        push(token);
-        continue;
-      }
-      if (prev && (prev.type === "bracket" || prev.type === "paren") && opts.regex === true) {
-        token.output = value;
-        push(token);
-        continue;
-      }
-      if (state.index === state.start || prev.type === "slash" || prev.type === "dot") {
-        if (prev.type === "dot") {
-          state.output += NO_DOT_SLASH;
-          prev.output += NO_DOT_SLASH;
-        } else if (opts.dot === true) {
-          state.output += NO_DOTS_SLASH;
-          prev.output += NO_DOTS_SLASH;
-        } else {
-          state.output += nodot;
-          prev.output += nodot;
-        }
-        if (peek() !== "*") {
-          state.output += ONE_CHAR;
-          prev.output += ONE_CHAR;
-        }
-      }
-      push(token);
-    }
-    while (state.brackets > 0) {
-      if (opts.strictBrackets === true)
-        throw new SyntaxError(syntaxError("closing", "]"));
-      state.output = utils.escapeLast(state.output, "[");
-      decrement("brackets");
-    }
-    while (state.parens > 0) {
-      if (opts.strictBrackets === true)
-        throw new SyntaxError(syntaxError("closing", ")"));
-      state.output = utils.escapeLast(state.output, "(");
-      decrement("parens");
-    }
-    while (state.braces > 0) {
-      if (opts.strictBrackets === true)
-        throw new SyntaxError(syntaxError("closing", "}"));
-      state.output = utils.escapeLast(state.output, "{");
-      decrement("braces");
-    }
-    if (opts.strictSlashes !== true && (prev.type === "star" || prev.type === "bracket")) {
-      push({ type: "maybe_slash", value: "", output: `${SLASH_LITERAL}?` });
-    }
-    if (state.backtrack === true) {
-      state.output = "";
-      for (const token of state.tokens) {
-        state.output += token.output != null ? token.output : token.value;
-        if (token.suffix) {
-          state.output += token.suffix;
-        }
-      }
-    }
-    return state;
-  };
-  parse2.fastpaths = (input, options) => {
-    const opts = { ...options };
-    const max = typeof opts.maxLength === "number" ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
-    const len = input.length;
-    if (len > max) {
-      throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
-    }
-    input = REPLACEMENTS[input] || input;
-    const {
-      DOT_LITERAL,
-      SLASH_LITERAL,
-      ONE_CHAR,
-      DOTS_SLASH,
-      NO_DOT,
-      NO_DOTS,
-      NO_DOTS_SLASH,
-      STAR,
-      START_ANCHOR
-    } = constants.globChars(opts.windows);
-    const nodot = opts.dot ? NO_DOTS : NO_DOT;
-    const slashDot = opts.dot ? NO_DOTS_SLASH : NO_DOT;
-    const capture = opts.capture ? "" : "?:";
-    const state = { negated: false, prefix: "" };
-    let star = opts.bash === true ? ".*?" : STAR;
-    if (opts.capture) {
-      star = `(${star})`;
-    }
-    const globstar = (opts2) => {
-      if (opts2.noglobstar === true)
-        return star;
-      return `(${capture}(?:(?!${START_ANCHOR}${opts2.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
-    };
-    const 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(input, state);
-    let source = create(output);
-    if (source && opts.strictSlashes !== true) {
-      source += `${SLASH_LITERAL}?`;
-    }
-    return source;
-  };
-  module.exports = parse2;
-});
-
-// ../../node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/lib/picomatch.js
-var require_picomatch2 = __commonJS((exports, module) => {
-  var scan = require_scan2();
-  var parse2 = require_parse3();
-  var utils = require_utils5();
-  var constants = require_constants5();
-  var isObject2 = (val) => val && typeof val === "object" && !Array.isArray(val);
-  var picomatch = (glob, options, returnState = false) => {
-    if (Array.isArray(glob)) {
-      const fns = glob.map((input) => picomatch(input, options, returnState));
-      const arrayMatcher = (str) => {
-        for (const isMatch of fns) {
-          const state2 = isMatch(str);
-          if (state2)
-            return state2;
-        }
-        return false;
-      };
-      return arrayMatcher;
-    }
-    const isState = isObject2(glob) && glob.tokens && glob.input;
-    if (glob === "" || typeof glob !== "string" && !isState) {
-      throw new TypeError("Expected pattern to be a non-empty string");
-    }
-    const opts = options || {};
-    const posix = opts.windows;
-    const regex = isState ? picomatch.compileRe(glob, options) : picomatch.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 = picomatch(opts.ignore, ignoreOpts, returnState);
-    }
-    const matcher = (input, returnObject = false) => {
-      const { isMatch, match, output } = picomatch.test(input, regex, options, { glob, posix });
-      const result = { glob, state, regex, posix, input, output, match, isMatch };
-      if (typeof opts.onResult === "function") {
-        opts.onResult(result);
-      }
-      if (isMatch === false) {
-        result.isMatch = false;
-        return returnObject ? result : false;
-      }
-      if (isIgnored(input)) {
-        if (typeof opts.onIgnore === "function") {
-          opts.onIgnore(result);
-        }
-        result.isMatch = false;
-        return returnObject ? result : false;
-      }
-      if (typeof opts.onMatch === "function") {
-        opts.onMatch(result);
-      }
-      return returnObject ? result : true;
-    };
-    if (returnState) {
-      matcher.state = state;
-    }
-    return matcher;
-  };
-  picomatch.test = (input, regex, options, { glob, posix } = {}) => {
-    if (typeof input !== "string") {
-      throw new TypeError("Expected input to be a string");
-    }
-    if (input === "") {
-      return { isMatch: false, output: "" };
-    }
-    const opts = options || {};
-    const format = opts.format || (posix ? utils.toPosixSlashes : null);
-    let match = input === glob;
-    let output = match && format ? format(input) : input;
-    if (match === false) {
-      output = format ? format(input) : input;
-      match = output === glob;
-    }
-    if (match === false || opts.capture === true) {
-      if (opts.matchBase === true || opts.basename === true) {
-        match = picomatch.matchBase(input, regex, options, posix);
-      } else {
-        match = regex.exec(output);
-      }
-    }
-    return { isMatch: Boolean(match), match, output };
-  };
-  picomatch.matchBase = (input, glob, options) => {
-    const regex = glob instanceof RegExp ? glob : picomatch.makeRe(glob, options);
-    return regex.test(utils.basename(input));
-  };
-  picomatch.isMatch = (str, patterns, options) => picomatch(patterns, options)(str);
-  picomatch.parse = (pattern, options) => {
-    if (Array.isArray(pattern))
-      return pattern.map((p) => picomatch.parse(p, options));
-    return parse2(pattern, { ...options, fastpaths: false });
-  };
-  picomatch.scan = (input, options) => scan(input, options);
-  picomatch.compileRe = (state, options, returnOutput = false, returnState = false) => {
-    if (returnOutput === true) {
-      return state.output;
-    }
-    const opts = options || {};
-    const prepend = opts.contains ? "" : "^";
-    const append = opts.contains ? "" : "$";
-    let source = `${prepend}(?:${state.output})${append}`;
-    if (state && state.negated === true) {
-      source = `^(?!${source}).*$`;
-    }
-    const regex = picomatch.toRegex(source, options);
-    if (returnState === true) {
-      regex.state = state;
-    }
-    return regex;
-  };
-  picomatch.makeRe = (input, options = {}, returnOutput = false, returnState = false) => {
-    if (!input || typeof input !== "string") {
-      throw new TypeError("Expected a non-empty string");
-    }
-    let parsed = { negated: false, fastpaths: true };
-    if (options.fastpaths !== false && (input[0] === "." || input[0] === "*")) {
-      parsed.output = parse2.fastpaths(input, options);
-    }
-    if (!parsed.output) {
-      parsed = parse2(input, options);
-    }
-    return picomatch.compileRe(parsed, options, returnOutput, returnState);
-  };
-  picomatch.toRegex = (source, options) => {
-    try {
-      const opts = options || {};
-      return new RegExp(source, opts.flags || (opts.nocase ? "i" : ""));
-    } catch (err) {
-      if (options && options.debug === true)
-        throw err;
-      return /$^/;
-    }
-  };
-  picomatch.constants = constants;
-  module.exports = picomatch;
-});
-
-// ../../node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/index.js
-var require_picomatch3 = __commonJS((exports, module) => {
-  var pico = require_picomatch2();
-  var utils = require_utils5();
-  function picomatch(glob, options, returnState = false) {
-    if (options && (options.windows === null || options.windows === undefined)) {
-      options = { ...options, windows: utils.isWindows() };
-    }
-    return pico(glob, options, returnState);
-  }
-  Object.assign(picomatch, pico);
-  module.exports = picomatch;
-});
-
-// ../../node_modules/.pnpm/@parcel+watcher@2.5.6/node_modules/@parcel/watcher/wrapper.js
-var require_wrapper = __commonJS((exports) => {
-  var path3 = __require("path");
-  var picomatch = require_picomatch3();
-  var isGlob = require_is_glob();
-  function normalizeOptions(dir, opts = {}) {
-    const { ignore, ...rest } = opts;
-    if (Array.isArray(ignore)) {
-      opts = { ...rest };
-      for (const value of ignore) {
-        if (isGlob(value)) {
-          if (!opts.ignoreGlobs) {
-            opts.ignoreGlobs = [];
-          }
-          const regex = picomatch.makeRe(value, {
-            dot: true,
-            windows: process.platform === "win32"
-          });
-          opts.ignoreGlobs.push(regex.source);
-        } else {
-          if (!opts.ignorePaths) {
-            opts.ignorePaths = [];
-          }
-          opts.ignorePaths.push(path3.resolve(dir, value));
-        }
-      }
-    }
-    return opts;
-  }
-  exports.createWrapper = (binding) => {
-    return {
-      writeSnapshot(dir, snapshot, opts) {
-        return binding.writeSnapshot(path3.resolve(dir), path3.resolve(snapshot), normalizeOptions(dir, opts));
-      },
-      getEventsSince(dir, snapshot, opts) {
-        return binding.getEventsSince(path3.resolve(dir), path3.resolve(snapshot), normalizeOptions(dir, opts));
-      },
-      async subscribe(dir, fn, opts) {
-        dir = path3.resolve(dir);
-        opts = normalizeOptions(dir, opts);
-        await binding.subscribe(dir, fn, opts);
-        return {
-          unsubscribe() {
-            return binding.unsubscribe(dir, fn, opts);
-          }
-        };
-      },
-      unsubscribe(dir, fn, opts) {
-        return binding.unsubscribe(path3.resolve(dir), fn, normalizeOptions(dir, opts));
-      }
-    };
-  };
-});
-
-// ../../node_modules/.pnpm/detect-libc@2.1.2/node_modules/detect-libc/lib/process.js
-var require_process = __commonJS((exports, module) => {
-  var isLinux = () => process.platform === "linux";
-  var report = null;
-  var getReport = () => {
-    if (!report) {
-      if (isLinux() && process.report) {
-        const orig = process.report.excludeNetwork;
-        process.report.excludeNetwork = true;
-        report = process.report.getReport();
-        process.report.excludeNetwork = orig;
-      } else {
-        report = {};
-      }
-    }
-    return report;
-  };
-  module.exports = { isLinux, getReport };
-});
-
-// ../../node_modules/.pnpm/detect-libc@2.1.2/node_modules/detect-libc/lib/filesystem.js
-var require_filesystem = __commonJS((exports, module) => {
-  var fs2 = __require("fs");
-  var LDD_PATH = "/usr/bin/ldd";
-  var SELF_PATH = "/proc/self/exe";
-  var MAX_LENGTH = 2048;
-  var readFileSync = (path3) => {
-    const fd = fs2.openSync(path3, "r");
-    const buffer = Buffer.alloc(MAX_LENGTH);
-    const bytesRead = fs2.readSync(fd, buffer, 0, MAX_LENGTH, 0);
-    fs2.close(fd, () => {});
-    return buffer.subarray(0, bytesRead);
-  };
-  var readFile = (path3) => new Promise((resolve, reject) => {
-    fs2.open(path3, "r", (err, fd) => {
-      if (err) {
-        reject(err);
-      } else {
-        const buffer = Buffer.alloc(MAX_LENGTH);
-        fs2.read(fd, buffer, 0, MAX_LENGTH, 0, (_, bytesRead) => {
-          resolve(buffer.subarray(0, bytesRead));
-          fs2.close(fd, () => {});
-        });
-      }
-    });
-  });
-  module.exports = {
-    LDD_PATH,
-    SELF_PATH,
-    readFileSync,
-    readFile
-  };
-});
-
-// ../../node_modules/.pnpm/detect-libc@2.1.2/node_modules/detect-libc/lib/elf.js
-var require_elf = __commonJS((exports, module) => {
-  var interpreterPath = (elf) => {
-    if (elf.length < 64) {
-      return null;
-    }
-    if (elf.readUInt32BE(0) !== 2135247942) {
-      return null;
-    }
-    if (elf.readUInt8(4) !== 2) {
-      return null;
-    }
-    if (elf.readUInt8(5) !== 1) {
-      return null;
-    }
-    const offset = elf.readUInt32LE(32);
-    const size = elf.readUInt16LE(54);
-    const count = elf.readUInt16LE(56);
-    for (let i = 0;i < count; i++) {
-      const headerOffset = offset + i * size;
-      const type = elf.readUInt32LE(headerOffset);
-      if (type === 3) {
-        const fileOffset = elf.readUInt32LE(headerOffset + 8);
-        const fileSize = elf.readUInt32LE(headerOffset + 32);
-        return elf.subarray(fileOffset, fileOffset + fileSize).toString().replace(/\0.*$/g, "");
-      }
-    }
-    return null;
-  };
-  module.exports = {
-    interpreterPath
-  };
-});
-
-// ../../node_modules/.pnpm/detect-libc@2.1.2/node_modules/detect-libc/lib/detect-libc.js
-var require_detect_libc = __commonJS((exports, module) => {
-  var childProcess = __require("child_process");
-  var { isLinux, getReport } = require_process();
-  var { LDD_PATH, SELF_PATH, readFile, readFileSync } = require_filesystem();
-  var { interpreterPath } = require_elf();
-  var cachedFamilyInterpreter;
-  var cachedFamilyFilesystem;
-  var cachedVersionFilesystem;
-  var command = "getconf GNU_LIBC_VERSION 2>&1 || true; ldd --version 2>&1 || true";
-  var commandOut = "";
-  var safeCommand = () => {
-    if (!commandOut) {
-      return new Promise((resolve) => {
-        childProcess.exec(command, (err, out) => {
-          commandOut = err ? " " : out;
-          resolve(commandOut);
-        });
-      });
-    }
-    return commandOut;
-  };
-  var safeCommandSync = () => {
-    if (!commandOut) {
-      try {
-        commandOut = childProcess.execSync(command, { encoding: "utf8" });
-      } catch (_err) {
-        commandOut = " ";
-      }
-    }
-    return commandOut;
-  };
-  var GLIBC = "glibc";
-  var RE_GLIBC_VERSION = /LIBC[a-z0-9 \-).]*?(\d+\.\d+)/i;
-  var MUSL = "musl";
-  var isFileMusl = (f) => f.includes("libc.musl-") || f.includes("ld-musl-");
-  var familyFromReport = () => {
-    const report = getReport();
-    if (report.header && report.header.glibcVersionRuntime) {
-      return GLIBC;
-    }
-    if (Array.isArray(report.sharedObjects)) {
-      if (report.sharedObjects.some(isFileMusl)) {
-        return MUSL;
-      }
-    }
-    return null;
-  };
-  var familyFromCommand = (out) => {
-    const [getconf, ldd1] = out.split(/[\r\n]+/);
-    if (getconf && getconf.includes(GLIBC)) {
-      return GLIBC;
-    }
-    if (ldd1 && ldd1.includes(MUSL)) {
-      return MUSL;
-    }
-    return null;
-  };
-  var familyFromInterpreterPath = (path3) => {
-    if (path3) {
-      if (path3.includes("/ld-musl-")) {
-        return MUSL;
-      } else if (path3.includes("/ld-linux-")) {
-        return GLIBC;
-      }
-    }
-    return null;
-  };
-  var getFamilyFromLddContent = (content) => {
-    content = content.toString();
-    if (content.includes("musl")) {
-      return MUSL;
-    }
-    if (content.includes("GNU C Library")) {
-      return GLIBC;
-    }
-    return null;
-  };
-  var familyFromFilesystem = async () => {
-    if (cachedFamilyFilesystem !== undefined) {
-      return cachedFamilyFilesystem;
-    }
-    cachedFamilyFilesystem = null;
-    try {
-      const lddContent = await readFile(LDD_PATH);
-      cachedFamilyFilesystem = getFamilyFromLddContent(lddContent);
-    } catch (e) {}
-    return cachedFamilyFilesystem;
-  };
-  var familyFromFilesystemSync = () => {
-    if (cachedFamilyFilesystem !== undefined) {
-      return cachedFamilyFilesystem;
-    }
-    cachedFamilyFilesystem = null;
-    try {
-      const lddContent = readFileSync(LDD_PATH);
-      cachedFamilyFilesystem = getFamilyFromLddContent(lddContent);
-    } catch (e) {}
-    return cachedFamilyFilesystem;
-  };
-  var familyFromInterpreter = async () => {
-    if (cachedFamilyInterpreter !== undefined) {
-      return cachedFamilyInterpreter;
-    }
-    cachedFamilyInterpreter = null;
-    try {
-      const selfContent = await readFile(SELF_PATH);
-      const path3 = interpreterPath(selfContent);
-      cachedFamilyInterpreter = familyFromInterpreterPath(path3);
-    } catch (e) {}
-    return cachedFamilyInterpreter;
-  };
-  var familyFromInterpreterSync = () => {
-    if (cachedFamilyInterpreter !== undefined) {
-      return cachedFamilyInterpreter;
-    }
-    cachedFamilyInterpreter = null;
-    try {
-      const selfContent = readFileSync(SELF_PATH);
-      const path3 = interpreterPath(selfContent);
-      cachedFamilyInterpreter = familyFromInterpreterPath(path3);
-    } catch (e) {}
-    return cachedFamilyInterpreter;
-  };
-  var family = async () => {
-    let family2 = null;
-    if (isLinux()) {
-      family2 = await familyFromInterpreter();
-      if (!family2) {
-        family2 = await familyFromFilesystem();
-        if (!family2) {
-          family2 = familyFromReport();
-        }
-        if (!family2) {
-          const out = await safeCommand();
-          family2 = familyFromCommand(out);
-        }
-      }
-    }
-    return family2;
-  };
-  var familySync = () => {
-    let family2 = null;
-    if (isLinux()) {
-      family2 = familyFromInterpreterSync();
-      if (!family2) {
-        family2 = familyFromFilesystemSync();
-        if (!family2) {
-          family2 = familyFromReport();
-        }
-        if (!family2) {
-          const out = safeCommandSync();
-          family2 = familyFromCommand(out);
-        }
-      }
-    }
-    return family2;
-  };
-  var isNonGlibcLinux = async () => isLinux() && await family() !== GLIBC;
-  var isNonGlibcLinuxSync = () => isLinux() && familySync() !== GLIBC;
-  var versionFromFilesystem = async () => {
-    if (cachedVersionFilesystem !== undefined) {
-      return cachedVersionFilesystem;
-    }
-    cachedVersionFilesystem = null;
-    try {
-      const lddContent = await readFile(LDD_PATH);
-      const versionMatch = lddContent.match(RE_GLIBC_VERSION);
-      if (versionMatch) {
-        cachedVersionFilesystem = versionMatch[1];
-      }
-    } catch (e) {}
-    return cachedVersionFilesystem;
-  };
-  var versionFromFilesystemSync = () => {
-    if (cachedVersionFilesystem !== undefined) {
-      return cachedVersionFilesystem;
-    }
-    cachedVersionFilesystem = null;
-    try {
-      const lddContent = readFileSync(LDD_PATH);
-      const versionMatch = lddContent.match(RE_GLIBC_VERSION);
-      if (versionMatch) {
-        cachedVersionFilesystem = versionMatch[1];
-      }
-    } catch (e) {}
-    return cachedVersionFilesystem;
-  };
-  var versionFromReport = () => {
-    const report = getReport();
-    if (report.header && report.header.glibcVersionRuntime) {
-      return report.header.glibcVersionRuntime;
-    }
-    return null;
-  };
-  var versionSuffix = (s) => s.trim().split(/\s+/)[1];
-  var versionFromCommand = (out) => {
-    const [getconf, ldd1, ldd2] = out.split(/[\r\n]+/);
-    if (getconf && getconf.includes(GLIBC)) {
-      return versionSuffix(getconf);
-    }
-    if (ldd1 && ldd2 && ldd1.includes(MUSL)) {
-      return versionSuffix(ldd2);
-    }
-    return null;
-  };
-  var version3 = async () => {
-    let version4 = null;
-    if (isLinux()) {
-      version4 = await versionFromFilesystem();
-      if (!version4) {
-        version4 = versionFromReport();
-      }
-      if (!version4) {
-        const out = await safeCommand();
-        version4 = versionFromCommand(out);
-      }
-    }
-    return version4;
-  };
-  var versionSync = () => {
-    let version4 = null;
-    if (isLinux()) {
-      version4 = versionFromFilesystemSync();
-      if (!version4) {
-        version4 = versionFromReport();
-      }
-      if (!version4) {
-        const out = safeCommandSync();
-        version4 = versionFromCommand(out);
-      }
-    }
-    return version4;
-  };
-  module.exports = {
-    GLIBC,
-    MUSL,
-    family,
-    familySync,
-    isNonGlibcLinux,
-    isNonGlibcLinuxSync,
-    version: version3,
-    versionSync
-  };
-});
-
 // ../../node_modules/.pnpm/eventemitter3@5.0.4/node_modules/eventemitter3/index.js
 var require_eventemitter32 = __commonJS((exports, module) => {
   var has = Object.prototype.hasOwnProperty;
@@ -7186,12 +5351,12 @@ var require_eventemitter32 = __commonJS((exports, module) => {
     this._eventsCount = 0;
   }
   EventEmitter.prototype.eventNames = function eventNames() {
-    var names = [], events, name2;
+    var names = [], events, name;
     if (this._eventsCount === 0)
       return names;
-    for (name2 in events = this._events) {
-      if (has.call(events, name2))
-        names.push(prefix ? name2.slice(1) : name2);
+    for (name in events = this._events) {
+      if (has.call(events, name))
+        names.push(prefix ? name.slice(1) : name);
     }
     if (Object.getOwnPropertySymbols) {
       return names.concat(Object.getOwnPropertySymbols(events));
@@ -26926,6 +25091,31 @@ class Scheduler {
   }
 }
 
+// src/project/utils.ts
+function normalizeIgnorePattern(pattern) {
+  if (pattern.includes("*") || pattern.includes("?")) {
+    return pattern;
+  }
+  if (pattern.endsWith("/")) {
+    return `**/${pattern.replace(/\/$/, "")}/**`;
+  }
+  return `**/${pattern}/**`;
+}
+var defaultIgnorePatterns = [
+  "node_modules",
+  "dist",
+  "pack-dist",
+  "build",
+  "out",
+  "coverage",
+  ".git",
+  ".svn",
+  ".hg",
+  ".next",
+  ".astro",
+  ".swc"
+];
+
 // src/project/project-search/index.ts
 var MANUAL_FIELDS = ["title", "tags", "summary", "description", "link"];
 var INDEX_NAME = "project-files";
@@ -27096,8 +25286,7 @@ class ProjectSearch {
     const ignoreFile = path2.join(projectPath, ".gitignore");
     const gitIgnore = fs.existsSync(ignoreFile) ? fs.readFileSync(ignoreFile, "utf-8").split(`
 `).map((l) => l.trim()).filter((l) => l && !l.startsWith("#")) : [];
-    const defaultIgnore = ["node_modules", "dist", "pack-dist", "build", "out", "coverage", ".git", ".svn", ".hg", ".next", ".astro", ".swc"];
-    const allIgnore = [...defaultIgnore, ...gitIgnore];
+    const allIgnore = [...defaultIgnorePatterns, ...gitIgnore].map(normalizeIgnorePattern);
     const files = await import_fast_glob.default("**", {
       cwd: projectPath,
       ignore: allIgnore,
@@ -27224,64 +25413,10 @@ class ProjectStore {
   }
 }
 
-// ../../node_modules/.pnpm/@parcel+watcher@2.5.6/node_modules/@parcel/watcher/index.js
-var { createWrapper } = require_wrapper();
-var name = `@parcel/watcher-${process.platform}-${process.arch}`;
-if (process.platform === "linux") {
-  const { MUSL, familySync } = require_detect_libc();
-  const family = familySync();
-  if (family === MUSL) {
-    name += "-musl";
-  } else {
-    name += "-glibc";
-  }
-}
-var binding;
-try {
-  binding = __require(name);
-} catch (err) {
-  handleError(err);
-  try {
-    binding = (()=>{throw new Error("Cannot require module "+"./build/Release/watcher.node");})();
-  } catch (err2) {
-    handleError(err2);
-    try {
-      binding = (()=>{throw new Error("Cannot require module "+"./build/Debug/watcher.node");})();
-    } catch (err3) {
-      handleError(err3);
-      throw new Error(`No prebuild or local build of @parcel/watcher found. Tried ${name}. Please ensure it is installed (don't use --no-optional when installing with npm). Otherwise it is possible we don't support your platform yet. If this is the case, please report an issue to https://github.com/parcel-bundler/watcher.`);
-    }
-  }
-}
-function handleError(err) {
-  if (err?.code !== "MODULE_NOT_FOUND") {
-    throw err;
-  }
-}
-var wrapper = createWrapper(binding);
-var $writeSnapshot = wrapper.writeSnapshot;
-var $getEventsSince = wrapper.getEventsSince;
-var $subscribe = wrapper.subscribe;
-var $unsubscribe = wrapper.unsubscribe;
-
 // src/project/project-listener/listener.ts
+import { subscribe } from "@parcel/watcher";
 import path3 from "node:path";
 import fs2 from "node:fs";
-var defaultIgnore = [
-  "node_modules",
-  "dist",
-  "pack-dist",
-  "build",
-  "out",
-  "coverage",
-  ".git",
-  ".svn",
-  ".hg",
-  ".next",
-  ".astro",
-  ".swc"
-];
-
 class ProjectListener {
   projectPath;
   subscribe = null;
@@ -27302,8 +25437,8 @@ class ProjectListener {
       ignorePatterns = fs2.readFileSync(ignoreFile, "utf-8").split(`
 `).map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
     }
-    const allIgnore = [...defaultIgnore, ...ignorePatterns];
-    const sub = await $subscribe(this.projectPath, async (err, events) => {
+    const allIgnore = [...defaultIgnorePatterns, ...ignorePatterns];
+    const sub = await subscribe(this.projectPath, async (err, events) => {
       if (err)
         throw err;
       for (const event of events) {
@@ -27337,7 +25472,7 @@ class ProjectListener {
         }
       }
     }, {
-      ignore: allIgnore.map((pattern) => `**/${pattern}/**`),
+      ignore: allIgnore.map(normalizeIgnorePattern),
       backend: "watchman"
     });
     this.subscribe = sub;
@@ -27537,12 +25672,12 @@ function requireEventemitter3() {
       this._eventsCount = 0;
     }
     EventEmitter2.prototype.eventNames = function eventNames() {
-      var names = [], events, name2;
+      var names = [], events, name;
       if (this._eventsCount === 0)
         return names;
-      for (name2 in events = this._events) {
-        if (has.call(events, name2))
-          names.push(prefix ? name2.slice(1) : name2);
+      for (name in events = this._events) {
+        if (has.call(events, name))
+          names.push(prefix ? name.slice(1) : name);
       }
       if (Object.getOwnPropertySymbols) {
         return names.concat(Object.getOwnPropertySymbols(events));
@@ -28617,7 +26752,7 @@ __export(exports_core3, {
 var NEVER2 = Object.freeze({
   status: "aborted"
 });
-function $constructor2(name2, initializer3, params) {
+function $constructor2(name, initializer3, params) {
   function init(inst, def) {
     if (!inst._zod) {
       Object.defineProperty(inst, "_zod", {
@@ -28629,10 +26764,10 @@ function $constructor2(name2, initializer3, params) {
         enumerable: false
       });
     }
-    if (inst._zod.traits.has(name2)) {
+    if (inst._zod.traits.has(name)) {
       return;
     }
-    inst._zod.traits.add(name2);
+    inst._zod.traits.add(name);
     initializer3(inst, def);
     const proto = _.prototype;
     const keys = Object.keys(proto);
@@ -28647,7 +26782,7 @@ function $constructor2(name2, initializer3, params) {
 
   class Definition extends Parent {
   }
-  Object.defineProperty(Definition, "name", { value: name2 });
+  Object.defineProperty(Definition, "name", { value: name });
   function _(def) {
     var _a2;
     const inst = params?.Parent ? new Definition : this;
@@ -28663,10 +26798,10 @@ function $constructor2(name2, initializer3, params) {
     value: (inst) => {
       if (params?.Parent && inst instanceof params.Parent)
         return true;
-      return inst?._zod?.traits?.has(name2);
+      return inst?._zod?.traits?.has(name);
     }
   });
-  Object.defineProperty(_, "name", { value: name2 });
+  Object.defineProperty(_, "name", { value: name });
   return _;
 }
 var $brand2 = Symbol("zod_brand");
@@ -28678,8 +26813,8 @@ class $ZodAsyncError2 extends Error {
 }
 
 class $ZodEncodeError2 extends Error {
-  constructor(name2) {
-    super(`Encountered unidirectional transform during encode: ${name2}`);
+  constructor(name) {
+    super(`Encountered unidirectional transform during encode: ${name}`);
     this.name = "ZodEncodeError";
   }
 }
@@ -41638,7 +39773,7 @@ var getGitPathname = (repoPath) => {
     }
     return null;
   } catch (err) {
-    console.error(`Failed to get remote URL for repo at ${repoPath}:`, err);
+    console.warn(`[getGitPathname] Failed to get git remote url for ${repoPath}:`);
     return null;
   }
 };
@@ -41657,7 +39792,7 @@ app.route({
     }
   }
 }).define(async (ctx) => {
-  let { filepath, repo, name: name2 } = ctx.query;
+  let { filepath, repo, name } = ctx.query;
   if (!filepath)
     ctx.throw(400, "filepath 不能为空");
   if (!repo) {
@@ -41669,7 +39804,7 @@ app.route({
       repo = pathParts[pathParts.length - 1];
     }
   }
-  const info = await manager.addProject({ path: filepath, repo, name: name2 });
+  const info = await manager.addProject({ path: filepath, repo, name });
   ctx.body = { success: true, data: info };
 }).addTo(app);
 app.route({
@@ -41752,10 +39887,10 @@ app.route({
     }
   }
 }).define(async (ctx) => {
-  const { filepath, name: name2, title, tags, summary, description, link } = ctx.query;
+  const { filepath, name, title, tags, summary, description, link } = ctx.query;
   if (!filepath)
     ctx.throw(400, "filepath 不能为空");
-  await manager.projectStore.updateProject(filepath, { name: name2, title, tags, summary, description, link });
+  await manager.projectStore.updateProject(filepath, { name, title, tags, summary, description, link });
   ctx.body = { success: true };
 }).addTo(app);
 
@@ -41920,12 +40055,12 @@ var require_eventemitter33 = __commonJS3((exports, module) => {
     this._eventsCount = 0;
   }
   EventEmitter3.prototype.eventNames = function eventNames() {
-    var names = [], events, name2;
+    var names = [], events, name;
     if (this._eventsCount === 0)
       return names;
-    for (name2 in events = this._events) {
-      if (has.call(events, name2))
-        names.push(prefix ? name2.slice(1) : name2);
+    for (name in events = this._events) {
+      if (has.call(events, name))
+        names.push(prefix ? name.slice(1) : name);
     }
     if (Object.getOwnPropertySymbols) {
       return names.concat(Object.getOwnPropertySymbols(events));