@arcote.tech/arc-cli 0.4.2 → 0.4.6

package/dist/index.js

@@ -29,7 +29,7 @@ var __export = (target, all) => {
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = import.meta.require;
 
-// ../../node_modules/commander/lib/error.js
+// node_modules/commander/lib/error.js
 var require_error = __commonJS((exports) => {
   class CommanderError extends Error {
     constructor(exitCode, code, message) {
@@ -53,7 +53,7 @@ var require_error = __commonJS((exports) => {
   exports.InvalidArgumentError = InvalidArgumentError;
 });
 
-// ../../node_modules/commander/lib/argument.js
+// node_modules/commander/lib/argument.js
 var require_argument = __commonJS((exports) => {
   var { InvalidArgumentError } = require_error();
 
@@ -132,7 +132,7 @@ var require_argument = __commonJS((exports) => {
   exports.humanReadableArgName = humanReadableArgName;
 });
 
-// ../../node_modules/commander/lib/help.js
+// node_modules/commander/lib/help.js
 var require_help = __commonJS((exports) => {
   var { humanReadableArgName } = require_argument();
 
@@ -379,7 +379,7 @@ var require_help = __commonJS((exports) => {
   exports.Help = Help;
 });
 
-// ../../node_modules/commander/lib/option.js
+// node_modules/commander/lib/option.js
 var require_option = __commonJS((exports) => {
   var { InvalidArgumentError } = require_error();
 
@@ -531,7 +531,7 @@ var require_option = __commonJS((exports) => {
   exports.DualOptions = DualOptions;
 });
 
-// ../../node_modules/commander/lib/suggestSimilar.js
+// node_modules/commander/lib/suggestSimilar.js
 var require_suggestSimilar = __commonJS((exports) => {
   var maxDistance = 3;
   function editDistance(a, b) {
@@ -604,7 +604,7 @@ var require_suggestSimilar = __commonJS((exports) => {
   exports.suggestSimilar = suggestSimilar;
 });
 
-// ../../node_modules/commander/lib/command.js
+// node_modules/commander/lib/command.js
 var require_command = __commonJS((exports) => {
   var EventEmitter = __require("node:events").EventEmitter;
   var childProcess = __require("node:child_process");
@@ -1787,7 +1787,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
   exports.Command = Command;
 });
 
-// ../../node_modules/commander/index.js
+// node_modules/commander/index.js
 var require_commander = __commonJS((exports, module) => {
   var { Argument } = require_argument();
   var { Command } = require_command();
@@ -4153,11 +4153,12 @@ var require_brace_expansion = __commonJS((exports, module) => {
   }
 });
 
-// ../../node_modules/picomatch/lib/constants.js
+// node_modules/chokidar/node_modules/readdirp/node_modules/picomatch/lib/constants.js
 var require_constants = __commonJS((exports, module) => {
   var path4 = __require("node: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 = "\\?";
@@ -4205,6 +4206,7 @@ var require_constants = __commonJS((exports, module) => {
     END_ANCHOR: `(?:[${WIN_SLASH}]|$)`
   };
   var POSIX_REGEX_SOURCE = {
+    __proto__: null,
     alnum: "a-zA-Z0-9",
     alpha: "a-zA-Z",
     ascii: "\\x00-\\x7F",
@@ -4221,6 +4223,7 @@ var require_constants = __commonJS((exports, module) => {
     xdigit: "A-Fa-f0-9"
   };
   module.exports = {
+    DEFAULT_MAX_EXTGLOB_RECURSION,
     MAX_LENGTH: 1024 * 64,
     POSIX_REGEX_SOURCE,
     REGEX_BACKSLASH: /\\(?![*+?^${}(|)[\]])/g,
@@ -4230,6 +4233,7 @@ var require_constants = __commonJS((exports, module) => {
     REGEX_SPECIAL_CHARS_GLOBAL: /([-*+?.^${}(|)[\]])/g,
     REGEX_REMOVE_BACKSLASH: /(?:\[.*?[^\\]\]|\\(?=.))/g,
     REPLACEMENTS: {
+      __proto__: null,
       "***": "*",
       "**/**": "**",
       "**/**/**": "**"
@@ -4293,7 +4297,7 @@ var require_constants = __commonJS((exports, module) => {
   };
 });
 
-// ../../node_modules/picomatch/lib/utils.js
+// node_modules/chokidar/node_modules/readdirp/node_modules/picomatch/lib/utils.js
 var require_utils = __commonJS((exports) => {
   var path4 = __require("node:path");
   var win322 = process.platform === "win32";
@@ -4353,7 +4357,7 @@ var require_utils = __commonJS((exports) => {
   };
 });
 
-// ../../node_modules/picomatch/lib/scan.js
+// node_modules/chokidar/node_modules/readdirp/node_modules/picomatch/lib/scan.js
 var require_scan = __commonJS((exports, module) => {
   var utils = require_utils();
   var {
@@ -4668,7 +4672,7 @@ var require_scan = __commonJS((exports, module) => {
   module.exports = scan;
 });
 
-// ../../node_modules/picomatch/lib/parse.js
+// node_modules/chokidar/node_modules/readdirp/node_modules/picomatch/lib/parse.js
 var require_parse = __commonJS((exports, module) => {
   var constants = require_constants();
   var utils = require_utils();
@@ -4695,6 +4699,213 @@ var require_parse = __commonJS((exports, module) => {
   var syntaxError = (type, char) => {
     return `Missing ${type}: "${char}" - use "\\\\${char}" to match literal characters`;
   };
+  var splitTopLevel = (input) => {
+    const parts = [];
+    let bracket = 0;
+    let paren = 0;
+    let quote = 0;
+    let value = "";
+    let escaped = false;
+    for (const ch of input) {
+      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 match2 = parseRepeatedExtglob(pattern.slice(index), false);
+      if (!match2 || match2.type !== "*") {
+        return;
+      }
+      const branches = splitTopLevel(match2.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 += match2.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 match2 = parseRepeatedExtglob(value);
+    while (match2) {
+      depth++;
+      value = match2.body.trim();
+      match2 = 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 = (input, options) => {
     if (typeof input !== "string") {
       throw new TypeError("Expected a string");
@@ -4827,6 +5038,8 @@ var require_parse = __commonJS((exports, module) => {
       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 });
@@ -4834,6 +5047,26 @@ var require_parse = __commonJS((exports, module) => {
       extglobs.push(token);
     };
     const extglobClose = (token) => {
+      const literal = input.slice(token.startIndex, state.index + 1);
+      const body = input.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) : undefined;
+        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") {
@@ -5446,7 +5679,7 @@ var require_parse = __commonJS((exports, module) => {
   module.exports = parse;
 });
 
-// ../../node_modules/picomatch/lib/picomatch.js
+// node_modules/chokidar/node_modules/readdirp/node_modules/picomatch/lib/picomatch.js
 var require_picomatch = __commonJS((exports, module) => {
   var path4 = __require("node:path");
   var scan = require_scan();
@@ -5587,7 +5820,7 @@ var require_picomatch = __commonJS((exports, module) => {
   module.exports = picomatch;
 });
 
-// ../../node_modules/readdirp/index.js
+// node_modules/chokidar/node_modules/readdirp/index.js
 var require_readdirp = __commonJS((exports, module) => {
   var fs2 = __require("node:fs");
   var { Readable } = __require("node:stream");
@@ -5724,98 +5957,1532 @@ var require_readdirp = __commonJS((exports, module) => {
         this.reading = false;
       }
     }
-    async _exploreDir(path4, depth) {
-      let files;
-      try {
-        files = await readdir2(path4, this._rdOptions);
-      } catch (error) {
-        this._onError(error);
-      }
-      return { files, depth, path: path4 };
+    async _exploreDir(path4, depth) {
+      let files;
+      try {
+        files = await readdir2(path4, this._rdOptions);
+      } catch (error) {
+        this._onError(error);
+      }
+      return { files, depth, path: path4 };
+    }
+    async _formatEntry(dirent, path4) {
+      let entry;
+      try {
+        const basename2 = this._isDirent ? dirent.name : dirent;
+        const fullPath = sysPath.resolve(sysPath.join(path4, basename2));
+        entry = { path: sysPath.relative(this._root, fullPath), fullPath, basename: basename2 };
+        entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
+      } catch (err) {
+        this._onError(err);
+      }
+      return entry;
+    }
+    _onError(err) {
+      if (isNormalFlowError(err) && !this.destroyed) {
+        this.emit("warn", err);
+      } else {
+        this.destroy(err);
+      }
+    }
+    async _getEntryType(entry) {
+      const stats = entry && entry[this._statsProp];
+      if (!stats) {
+        return;
+      }
+      if (stats.isFile()) {
+        return "file";
+      }
+      if (stats.isDirectory()) {
+        return "directory";
+      }
+      if (stats && stats.isSymbolicLink()) {
+        const full = entry.fullPath;
+        try {
+          const entryRealPath = await realpath2(full);
+          const entryRealPathStats = await lstat2(entryRealPath);
+          if (entryRealPathStats.isFile()) {
+            return "file";
+          }
+          if (entryRealPathStats.isDirectory()) {
+            const len = entryRealPath.length;
+            if (full.startsWith(entryRealPath) && full.substr(len, 1) === sysPath.sep) {
+              const recursiveError = new Error(`Circular symlink detected: "${full}" points to "${entryRealPath}"`);
+              recursiveError.code = RECURSIVE_ERROR_CODE;
+              return this._onError(recursiveError);
+            }
+            return "directory";
+          }
+        } catch (error) {
+          this._onError(error);
+        }
+      }
+    }
+    _includeAsFile(entry) {
+      const stats = entry && entry[this._statsProp];
+      return stats && this._wantsEverything && !stats.isDirectory();
+    }
+  }
+  var readdirp = (root, options = {}) => {
+    let type = options.entryType || options.type;
+    if (type === "both")
+      type = FILE_DIR_TYPE;
+    if (type)
+      options.type = type;
+    if (!root) {
+      throw new Error("readdirp: root argument is required. Usage: readdirp(root, options)");
+    } else if (typeof root !== "string") {
+      throw new TypeError("readdirp: root argument must be a string. Usage: readdirp(root, options)");
+    } else if (type && !ALL_TYPES.includes(type)) {
+      throw new Error(`readdirp: Invalid type passed. Use one of ${ALL_TYPES.join(", ")}`);
+    }
+    options.root = root;
+    return new ReaddirpStream(options);
+  };
+  var readdirpPromise = (root, options = {}) => {
+    return new Promise((resolve, reject) => {
+      const files = [];
+      readdirp(root, options).on("data", (entry) => files.push(entry)).on("end", () => resolve(files)).on("error", (error) => reject(error));
+    });
+  };
+  readdirp.promise = readdirpPromise;
+  readdirp.ReaddirpStream = ReaddirpStream;
+  readdirp.default = readdirp;
+  module.exports = readdirp;
+});
+
+// ../../node_modules/picomatch/lib/constants.js
+var require_constants2 = __commonJS((exports, module) => {
+  var path4 = __require("node:path");
+  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 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 = {
+    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: {
+      "***": "*",
+      "**/**": "**",
+      "**/**/**": "**"
+    },
+    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,
+    SEP: path4.sep,
+    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(win322) {
+      return win322 === true ? WINDOWS_CHARS : POSIX_CHARS;
+    }
+  };
+});
+
+// ../../node_modules/picomatch/lib/utils.js
+var require_utils2 = __commonJS((exports) => {
+  var path4 = __require("node:path");
+  var win322 = process.platform === "win32";
+  var {
+    REGEX_BACKSLASH,
+    REGEX_REMOVE_BACKSLASH,
+    REGEX_SPECIAL_CHARS,
+    REGEX_SPECIAL_CHARS_GLOBAL
+  } = require_constants2();
+  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, (match2) => {
+      return match2 === "\\" ? "" : match2;
+    });
+  };
+  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 win322 === true || path4.sep === "\\";
+  };
+  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;
+  };
+});
+
+// ../../node_modules/picomatch/lib/scan.js
+var require_scan2 = __commonJS((exports, module) => {
+  var utils = require_utils2();
+  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_constants2();
+  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 base2 = str;
+    let prefix = "";
+    let glob2 = "";
+    if (start > 0) {
+      prefix = str.slice(0, start);
+      str = str.slice(start);
+      lastIndex -= start;
+    }
+    if (base2 && isGlob === true && lastIndex > 0) {
+      base2 = str.slice(0, lastIndex);
+      glob2 = str.slice(lastIndex);
+    } else if (isGlob === true) {
+      base2 = "";
+      glob2 = str;
+    } else {
+      base2 = str;
+    }
+    if (base2 && base2 !== "" && base2 !== "/" && base2 !== str) {
+      if (isPathSeparator(base2.charCodeAt(base2.length - 1))) {
+        base2 = base2.slice(0, -1);
+      }
+    }
+    if (opts.unescape === true) {
+      if (glob2)
+        glob2 = utils.removeBackslashes(glob2);
+      if (base2 && backslashes === true) {
+        base2 = utils.removeBackslashes(base2);
+      }
+    }
+    const state = {
+      prefix,
+      input,
+      start,
+      base: base2,
+      glob: glob2,
+      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/picomatch/lib/parse.js
+var require_parse2 = __commonJS((exports, module) => {
+  var constants = require_constants2();
+  var utils = require_utils2();
+  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 parse = (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 win322 = utils.isWindows(options);
+    const PLATFORM_CHARS = constants.globChars(win322);
+    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 star3 = opts.bash === true ? globstar(opts) : STAR;
+    if (opts.capture) {
+      star3 = `(${star3})`;
+    }
+    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 = star3;
+          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;
+      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 = star3;
+        if (token.inner && token.inner.length > 1 && token.inner.includes("/")) {
+          extglobStar = globstar(opts);
+        }
+        if (extglobStar !== star3 || 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(input)) {
+      let backslashes = false;
+      let output = input.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 ? star3 : "");
+          }
+          return star3;
+        }
+        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 === 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 match2 = /^\\+/.exec(remaining());
+        let slashes = 0;
+        if (match2 && match2[0].length > 2) {
+          slashes = match2[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 posix2 = POSIX_REGEX_SOURCE[rest2];
+              if (posix2) {
+                prev.value = pre + posix2;
+                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 match2 = REGEX_NON_SPECIAL_CHARS.exec(remaining());
+        if (match2) {
+          value += match2[0];
+          state.index += match2[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 = star3;
+        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: star3 };
+      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 = (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 win322 = utils.isWindows(options);
+    const {
+      DOT_LITERAL,
+      SLASH_LITERAL,
+      ONE_CHAR,
+      DOTS_SLASH,
+      NO_DOT,
+      NO_DOTS,
+      NO_DOTS_SLASH,
+      STAR,
+      START_ANCHOR
+    } = constants.globChars(win322);
+    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 star3 = opts.bash === true ? ".*?" : STAR;
+    if (opts.capture) {
+      star3 = `(${star3})`;
+    }
+    const globstar = (opts2) => {
+      if (opts2.noglobstar === true)
+        return star3;
+      return `(${capture}(?:(?!${START_ANCHOR}${opts2.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
+    };
+    const create = (str) => {
+      switch (str) {
+        case "*":
+          return `${nodot}${ONE_CHAR}${star3}`;
+        case ".*":
+          return `${DOT_LITERAL}${ONE_CHAR}${star3}`;
+        case "*.*":
+          return `${nodot}${star3}${DOT_LITERAL}${ONE_CHAR}${star3}`;
+        case "*/*":
+          return `${nodot}${star3}${SLASH_LITERAL}${ONE_CHAR}${slashDot}${star3}`;
+        case "**":
+          return nodot + globstar(opts);
+        case "**/*":
+          return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${ONE_CHAR}${star3}`;
+        case "**/*.*":
+          return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${star3}${DOT_LITERAL}${ONE_CHAR}${star3}`;
+        case "**/.*":
+          return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${DOT_LITERAL}${ONE_CHAR}${star3}`;
+        default: {
+          const match2 = /^(.*?)\.(\w+)$/.exec(str);
+          if (!match2)
+            return;
+          const source2 = create(match2[1]);
+          if (!source2)
+            return;
+          return source2 + DOT_LITERAL + match2[2];
+        }
+      }
+    };
+    const output = utils.removePrefix(input, 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_picomatch2 = __commonJS((exports, module) => {
+  var path4 = __require("node:path");
+  var scan = require_scan2();
+  var parse = require_parse2();
+  var utils = require_utils2();
+  var constants = require_constants2();
+  var isObject = (val) => val && typeof val === "object" && !Array.isArray(val);
+  var picomatch = (glob2, options, returnState = false) => {
+    if (Array.isArray(glob2)) {
+      const fns = glob2.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 = isObject(glob2) && glob2.tokens && glob2.input;
+    if (glob2 === "" || typeof glob2 !== "string" && !isState) {
+      throw new TypeError("Expected pattern to be a non-empty string");
+    }
+    const opts = options || {};
+    const posix2 = utils.isWindows(options);
+    const regex2 = isState ? picomatch.compileRe(glob2, options) : picomatch.makeRe(glob2, options, false, true);
+    const state = regex2.state;
+    delete regex2.state;
+    let isIgnored = () => false;
+    if (opts.ignore) {
+      const ignoreOpts = { ...options, ignore: null, onMatch: null, onResult: null };
+      isIgnored = picomatch(opts.ignore, ignoreOpts, returnState);
+    }
+    const matcher = (input, returnObject = false) => {
+      const { isMatch, match: match2, output } = picomatch.test(input, regex2, options, { glob: glob2, posix: posix2 });
+      const result = { glob: glob2, state, regex: regex2, posix: posix2, input, output, match: match2, isMatch };
+      if (typeof opts.onResult === "function") {
+        opts.onResult(result);
+      }
+      if (isMatch === false) {
+        result.isMatch = false;
+        return returnObject ? result : false;
+      }
+      if (isIgnored(input)) {
+        if (typeof opts.onIgnore === "function") {
+          opts.onIgnore(result);
+        }
+        result.isMatch = false;
+        return returnObject ? result : false;
+      }
+      if (typeof opts.onMatch === "function") {
+        opts.onMatch(result);
+      }
+      return returnObject ? result : true;
+    };
+    if (returnState) {
+      matcher.state = state;
+    }
+    return matcher;
+  };
+  picomatch.test = (input, regex2, options, { glob: glob2, posix: posix2 } = {}) => {
+    if (typeof input !== "string") {
+      throw new TypeError("Expected input to be a string");
+    }
+    if (input === "") {
+      return { isMatch: false, output: "" };
     }
-    async _formatEntry(dirent, path4) {
-      let entry;
-      try {
-        const basename2 = this._isDirent ? dirent.name : dirent;
-        const fullPath = sysPath.resolve(sysPath.join(path4, basename2));
-        entry = { path: sysPath.relative(this._root, fullPath), fullPath, basename: basename2 };
-        entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
-      } catch (err) {
-        this._onError(err);
-      }
-      return entry;
+    const opts = options || {};
+    const format2 = opts.format || (posix2 ? utils.toPosixSlashes : null);
+    let match2 = input === glob2;
+    let output = match2 && format2 ? format2(input) : input;
+    if (match2 === false) {
+      output = format2 ? format2(input) : input;
+      match2 = output === glob2;
     }
-    _onError(err) {
-      if (isNormalFlowError(err) && !this.destroyed) {
-        this.emit("warn", err);
+    if (match2 === false || opts.capture === true) {
+      if (opts.matchBase === true || opts.basename === true) {
+        match2 = picomatch.matchBase(input, regex2, options, posix2);
       } else {
-        this.destroy(err);
+        match2 = regex2.exec(output);
       }
     }
-    async _getEntryType(entry) {
-      const stats = entry && entry[this._statsProp];
-      if (!stats) {
-        return;
-      }
-      if (stats.isFile()) {
-        return "file";
-      }
-      if (stats.isDirectory()) {
-        return "directory";
-      }
-      if (stats && stats.isSymbolicLink()) {
-        const full = entry.fullPath;
-        try {
-          const entryRealPath = await realpath2(full);
-          const entryRealPathStats = await lstat2(entryRealPath);
-          if (entryRealPathStats.isFile()) {
-            return "file";
-          }
-          if (entryRealPathStats.isDirectory()) {
-            const len = entryRealPath.length;
-            if (full.startsWith(entryRealPath) && full.substr(len, 1) === sysPath.sep) {
-              const recursiveError = new Error(`Circular symlink detected: "${full}" points to "${entryRealPath}"`);
-              recursiveError.code = RECURSIVE_ERROR_CODE;
-              return this._onError(recursiveError);
-            }
-            return "directory";
-          }
-        } catch (error) {
-          this._onError(error);
-        }
-      }
+    return { isMatch: Boolean(match2), match: match2, output };
+  };
+  picomatch.matchBase = (input, glob2, options, posix2 = utils.isWindows(options)) => {
+    const regex2 = glob2 instanceof RegExp ? glob2 : picomatch.makeRe(glob2, options);
+    return regex2.test(path4.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 parse(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;
     }
-    _includeAsFile(entry) {
-      const stats = entry && entry[this._statsProp];
-      return stats && this._wantsEverything && !stats.isDirectory();
+    const opts = options || {};
+    const prepend = opts.contains ? "" : "^";
+    const append = opts.contains ? "" : "$";
+    let source = `${prepend}(?:${state.output})${append}`;
+    if (state && state.negated === true) {
+      source = `^(?!${source}).*$`;
     }
-  }
-  var readdirp = (root, options = {}) => {
-    let type = options.entryType || options.type;
-    if (type === "both")
-      type = FILE_DIR_TYPE;
-    if (type)
-      options.type = type;
-    if (!root) {
-      throw new Error("readdirp: root argument is required. Usage: readdirp(root, options)");
-    } else if (typeof root !== "string") {
-      throw new TypeError("readdirp: root argument must be a string. Usage: readdirp(root, options)");
-    } else if (type && !ALL_TYPES.includes(type)) {
-      throw new Error(`readdirp: Invalid type passed. Use one of ${ALL_TYPES.join(", ")}`);
+    const regex2 = picomatch.toRegex(source, options);
+    if (returnState === true) {
+      regex2.state = state;
     }
-    options.root = root;
-    return new ReaddirpStream(options);
+    return regex2;
   };
-  var readdirpPromise = (root, options = {}) => {
-    return new Promise((resolve, reject) => {
-      const files = [];
-      readdirp(root, options).on("data", (entry) => files.push(entry)).on("end", () => resolve(files)).on("error", (error) => reject(error));
-    });
+  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 = parse.fastpaths(input, options);
+    }
+    if (!parsed.output) {
+      parsed = parse(input, options);
+    }
+    return picomatch.compileRe(parsed, options, returnOutput, returnState);
   };
-  readdirp.promise = readdirpPromise;
-  readdirp.ReaddirpStream = ReaddirpStream;
-  readdirp.default = readdirp;
-  module.exports = readdirp;
+  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/normalize-path/index.js
@@ -5854,7 +7521,7 @@ var require_normalize_path = __commonJS((exports, module) => {
 // ../../node_modules/anymatch/index.js
 var require_anymatch = __commonJS((exports, module) => {
   Object.defineProperty(exports, "__esModule", { value: true });
-  var picomatch = require_picomatch();
+  var picomatch = require_picomatch2();
   var normalizePath = require_normalize_path();
   var BANG = "!";
   var DEFAULT_OPTIONS = { returnIndex: false };
@@ -6072,7 +7739,7 @@ var require_is_glob = __commonJS((exports, module) => {
   };
 });
 
-// ../../node_modules/glob-parent/index.js
+// node_modules/chokidar/node_modules/glob-parent/index.js
 var require_glob_parent = __commonJS((exports, module) => {
   var isGlob = require_is_glob();
   var pathPosixDirname = __require("node:path").posix.dirname;
@@ -6099,7 +7766,7 @@ var require_glob_parent = __commonJS((exports, module) => {
 });
 
 // ../../node_modules/braces/lib/utils.js
-var require_utils2 = __commonJS((exports) => {
+var require_utils3 = __commonJS((exports) => {
   exports.isInteger = (num) => {
     if (typeof num === "number") {
       return Number.isInteger(num);
@@ -6187,7 +7854,7 @@ var require_utils2 = __commonJS((exports) => {
 
 // ../../node_modules/braces/lib/stringify.js
 var require_stringify = __commonJS((exports, module) => {
-  var utils = require_utils2();
+  var utils = require_utils3();
   module.exports = (ast, options = {}) => {
     const stringify = (node, parent = {}) => {
       const invalidBlock = options.escapeInvalid && utils.isInvalidBrace(parent);
@@ -6659,7 +8326,7 @@ var require_fill_range = __commonJS((exports, module) => {
 // ../../node_modules/braces/lib/compile.js
 var require_compile = __commonJS((exports, module) => {
   var fill = require_fill_range();
-  var utils = require_utils2();
+  var utils = require_utils3();
   var compile = (ast, options = {}) => {
     const walk = (node, parent = {}) => {
       const invalidBlock = utils.isInvalidBrace(parent);
@@ -6709,7 +8376,7 @@ var require_compile = __commonJS((exports, module) => {
 var require_expand = __commonJS((exports, module) => {
   var fill = require_fill_range();
   var stringify = require_stringify();
-  var utils = require_utils2();
+  var utils = require_utils3();
   var append = (queue = "", stash = "", enclose = false) => {
     const result = [];
     queue = [].concat(queue);
@@ -6800,7 +8467,7 @@ var require_expand = __commonJS((exports, module) => {
 });
 
 // ../../node_modules/braces/lib/constants.js
-var require_constants2 = __commonJS((exports, module) => {
+var require_constants3 = __commonJS((exports, module) => {
   module.exports = {
     MAX_LENGTH: 1e4,
     CHAR_0: "0",
@@ -6852,7 +8519,7 @@ var require_constants2 = __commonJS((exports, module) => {
 });
 
 // ../../node_modules/braces/lib/parse.js
-var require_parse2 = __commonJS((exports, module) => {
+var require_parse3 = __commonJS((exports, module) => {
   var stringify = require_stringify();
   var {
     MAX_LENGTH,
@@ -6870,7 +8537,7 @@ var require_parse2 = __commonJS((exports, module) => {
     CHAR_SINGLE_QUOTE,
     CHAR_NO_BREAK_SPACE,
     CHAR_ZERO_WIDTH_NOBREAK_SPACE
-  } = require_constants2();
+  } = require_constants3();
   var parse = (input, options = {}) => {
     if (typeof input !== "string") {
       throw new TypeError("Expected a string");
@@ -7083,7 +8750,7 @@ var require_braces = __commonJS((exports, module) => {
   var stringify = require_stringify();
   var compile = require_compile();
   var expand2 = require_expand();
-  var parse = require_parse2();
+  var parse = require_parse3();
   var braces = (input, options = {}) => {
     let output = [];
     if (Array.isArray(input)) {
@@ -7413,8 +9080,8 @@ var require_is_binary_path = __commonJS((exports, module) => {
   module.exports = (filePath) => extensions.has(path4.extname(filePath).slice(1).toLowerCase());
 });
 
-// ../../node_modules/chokidar/lib/constants.js
-var require_constants3 = __commonJS((exports) => {
+// node_modules/chokidar/lib/constants.js
+var require_constants4 = __commonJS((exports) => {
   var { sep: sep2 } = __require("node:path");
   var { platform: platform3 } = process;
   var os2 = __require("node:os");
@@ -7473,7 +9140,7 @@ var require_constants3 = __commonJS((exports) => {
   exports.isIBMi = os2.type() === "OS400";
 });
 
-// ../../node_modules/chokidar/lib/nodefs-handler.js
+// node_modules/chokidar/lib/nodefs-handler.js
 var require_nodefs_handler = __commonJS((exports, module) => {
   var fs2 = __require("node:fs");
   var sysPath = __require("node:path");
@@ -7496,7 +9163,7 @@ var require_nodefs_handler = __commonJS((exports, module) => {
     STR_END,
     BRACE_START,
     STAR
-  } = require_constants3();
+  } = require_constants4();
   var THROTTLE_MODE_WATCH = "watch";
   var open = promisify(fs2.open);
   var stat = promisify(fs2.stat);
@@ -8003,7 +9670,7 @@ var require_fsevents2 = __commonJS((exports) => {
   exports.constants = events;
 });
 
-// ../../node_modules/chokidar/lib/fsevents-handler.js
+// node_modules/chokidar/lib/fsevents-handler.js
 var require_fsevents_handler = __commonJS((exports, module) => {
   var fs2 = __require("node:fs");
   var sysPath = __require("node:path");
@@ -8048,7 +9715,7 @@ var require_fsevents_handler = __commonJS((exports, module) => {
     FUNCTION_TYPE,
     EMPTY_FN,
     IDENTITY_FN
-  } = require_constants3();
+  } = require_constants4();
   var Depth = (value) => isNaN(value) ? {} : { depth: value };
   var stat = promisify(fs2.stat);
   var lstat2 = promisify(fs2.lstat);
@@ -8373,7 +10040,7 @@ var require_fsevents_handler = __commonJS((exports, module) => {
   module.exports.canUse = canUse;
 });
 
-// ../../node_modules/chokidar/index.js
+// node_modules/chokidar/index.js
 var require_chokidar = __commonJS((exports) => {
   var { EventEmitter: EventEmitter3 } = __require("node:events");
   var fs2 = __require("node:fs");
@@ -8420,7 +10087,7 @@ var require_chokidar = __commonJS((exports) => {
     isWindows: isWindows4,
     isMacos,
     isIBMi
-  } = require_constants3();
+  } = require_constants4();
   var stat = promisify(fs2.stat);
   var readdir2 = promisify(fs2.readdir);
   var arrify = (value = []) => Array.isArray(value) ? value : [value];
@@ -10005,7 +11672,7 @@ var require_timespan = __commonJS((exports, module) => {
 });
 
 // ../../node_modules/semver/internal/constants.js
-var require_constants4 = __commonJS((exports, module) => {
+var require_constants5 = __commonJS((exports, module) => {
   var SEMVER_SPEC_VERSION = "2.0.0";
   var MAX_LENGTH = 256;
   var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || 9007199254740991;
@@ -10044,7 +11711,7 @@ var require_re = __commonJS((exports, module) => {
     MAX_SAFE_COMPONENT_LENGTH,
     MAX_SAFE_BUILD_LENGTH,
     MAX_LENGTH
-  } = require_constants4();
+  } = require_constants5();
   var debug = require_debug();
   exports = module.exports = {};
   var re = exports.re = [];
@@ -10164,7 +11831,7 @@ var require_identifiers = __commonJS((exports, module) => {
 // ../../node_modules/semver/classes/semver.js
 var require_semver = __commonJS((exports, module) => {
   var debug = require_debug();
-  var { MAX_LENGTH, MAX_SAFE_INTEGER } = require_constants4();
+  var { MAX_LENGTH, MAX_SAFE_INTEGER } = require_constants5();
   var { safeRe: re, t } = require_re();
   var parseOptions = require_parse_options();
   var { compareIdentifiers } = require_identifiers();
@@ -10431,7 +12098,7 @@ var require_semver = __commonJS((exports, module) => {
 });
 
 // ../../node_modules/semver/functions/parse.js
-var require_parse3 = __commonJS((exports, module) => {
+var require_parse4 = __commonJS((exports, module) => {
   var SemVer = require_semver();
   var parse = (version, options, throwErrors = false) => {
     if (version instanceof SemVer) {
@@ -10451,7 +12118,7 @@ var require_parse3 = __commonJS((exports, module) => {
 
 // ../../node_modules/semver/functions/valid.js
 var require_valid = __commonJS((exports, module) => {
-  var parse = require_parse3();
+  var parse = require_parse4();
   var valid = (version, options) => {
     const v = parse(version, options);
     return v ? v.version : null;
@@ -10461,7 +12128,7 @@ var require_valid = __commonJS((exports, module) => {
 
 // ../../node_modules/semver/functions/clean.js
 var require_clean = __commonJS((exports, module) => {
-  var parse = require_parse3();
+  var parse = require_parse4();
   var clean = (version, options) => {
     const s = parse(version.trim().replace(/^[=v]+/, ""), options);
     return s ? s.version : null;
@@ -10489,7 +12156,7 @@ var require_inc = __commonJS((exports, module) => {
 
 // ../../node_modules/semver/functions/diff.js
 var require_diff = __commonJS((exports, module) => {
-  var parse = require_parse3();
+  var parse = require_parse4();
   var diff = (version1, version2) => {
     const v1 = parse(version1, null, true);
     const v2 = parse(version2, null, true);
@@ -10551,7 +12218,7 @@ var require_patch = __commonJS((exports, module) => {
 
 // ../../node_modules/semver/functions/prerelease.js
 var require_prerelease = __commonJS((exports, module) => {
-  var parse = require_parse3();
+  var parse = require_parse4();
   var prerelease = (version, options) => {
     const parsed = parse(version, options);
     return parsed && parsed.prerelease.length ? parsed.prerelease : null;
@@ -10697,7 +12364,7 @@ var require_cmp = __commonJS((exports, module) => {
 // ../../node_modules/semver/functions/coerce.js
 var require_coerce = __commonJS((exports, module) => {
   var SemVer = require_semver();
-  var parse = require_parse3();
+  var parse = require_parse4();
   var { safeRe: re, t } = require_re();
   var coerce = (version, options) => {
     if (version instanceof SemVer) {
@@ -10927,7 +12594,7 @@ var require_range = __commonJS((exports, module) => {
     tildeTrimReplace,
     caretTrimReplace
   } = require_re();
-  var { FLAG_INCLUDE_PRERELEASE, FLAG_LOOSE } = require_constants4();
+  var { FLAG_INCLUDE_PRERELEASE, FLAG_LOOSE } = require_constants5();
   var isNullSet = (c) => c.value === "<0.0.0-0";
   var isAny = (c) => c.value === "";
   var isSatisfiable = (comparators, options) => {
@@ -11698,10 +13365,10 @@ var require_subset = __commonJS((exports, module) => {
 // ../../node_modules/semver/index.js
 var require_semver2 = __commonJS((exports, module) => {
   var internalRe = require_re();
-  var constants = require_constants4();
+  var constants = require_constants5();
   var SemVer = require_semver();
   var identifiers = require_identifiers();
-  var parse = require_parse3();
+  var parse = require_parse4();
   var valid = require_valid();
   var clean = require_clean();
   var inc = require_inc();
@@ -12744,8 +14411,8 @@ function isBaseMapInstance(obj) {
   return Object.getPrototypeOf(obj) === Map.prototype;
 }
 function latest(proxyDraft) {
-  var _a;
-  return (_a = proxyDraft.copy) !== null && _a !== undefined ? _a : proxyDraft.original;
+  var _a2;
+  return (_a2 = proxyDraft.copy) !== null && _a2 !== undefined ? _a2 : proxyDraft.original;
 }
 function isDraft(target) {
   return !!getProxyDraft(target);
@@ -12756,9 +14423,9 @@ function getProxyDraft(value) {
   return value === null || value === undefined ? undefined : value[PROXY_DRAFT];
 }
 function getValue(value) {
-  var _a;
+  var _a2;
   const proxyDraft = getProxyDraft(value);
-  return proxyDraft ? (_a = proxyDraft.copy) !== null && _a !== undefined ? _a : proxyDraft.original : value;
+  return proxyDraft ? (_a2 = proxyDraft.copy) !== null && _a2 !== undefined ? _a2 : proxyDraft.original : value;
 }
 function isDraftable(value, options) {
   if (!value || typeof value !== "object")
@@ -12955,8 +14622,8 @@ function cloneIfNeeded(target) {
   return isDraft(target) ? deepClone(target) : target;
 }
 function markChanged(proxyDraft) {
-  var _a;
-  proxyDraft.assignedMap = (_a = proxyDraft.assignedMap) !== null && _a !== undefined ? _a : new Map;
+  var _a2;
+  proxyDraft.assignedMap = (_a2 = proxyDraft.assignedMap) !== null && _a2 !== undefined ? _a2 : new Map;
   if (!proxyDraft.operated) {
     proxyDraft.operated = true;
     if (proxyDraft.parent) {
@@ -13059,11 +14726,11 @@ function handleValue(target, handledSet, options) {
   const setMap = isSet ? new Map : undefined;
   handledSet.add(target);
   forEach(target, (key, value) => {
-    var _a;
+    var _a2;
     if (isDraft(value)) {
       const proxyDraft = getProxyDraft(value);
       ensureShallowCopy(proxyDraft);
-      const updatedValue = ((_a = proxyDraft.assignedMap) === null || _a === undefined ? undefined : _a.size) || proxyDraft.operated ? proxyDraft.copy : proxyDraft.original;
+      const updatedValue = ((_a2 = proxyDraft.assignedMap) === null || _a2 === undefined ? undefined : _a2.size) || proxyDraft.operated ? proxyDraft.copy : proxyDraft.original;
       set(isSet ? setMap : target, key, updatedValue);
     } else {
       handleValue(value, handledSet, options);
@@ -13111,7 +14778,7 @@ function markFinalization(target, key, value, generatePatches) {
       proxyDraft.callbacks = [];
     }
     proxyDraft.callbacks.push((patches, inversePatches) => {
-      var _a;
+      var _a2;
       const copy = target.type === 3 ? target.setMap : target.copy;
       if (isEqual(get(copy, key), value)) {
         let updatedValue = proxyDraft.original;
@@ -13121,7 +14788,7 @@ function markFinalization(target, key, value, generatePatches) {
         finalizeSetValue(target);
         finalizePatches(target, generatePatches, patches, inversePatches);
         if (target.options.enableAutoFreeze) {
-          target.options.updatedValues = (_a = target.options.updatedValues) !== null && _a !== undefined ? _a : new WeakMap;
+          target.options.updatedValues = (_a2 = target.options.updatedValues) !== null && _a2 !== undefined ? _a2 : new WeakMap;
           target.options.updatedValues.set(updatedValue, proxyDraft.original);
         }
         set(copy, key, updatedValue);
@@ -13282,7 +14949,7 @@ function createDraft(createDraftOptions) {
   if (parentDraft) {
     const target = parentDraft;
     target.finalities.draft.push((patches, inversePatches) => {
-      var _a, _b;
+      var _a2, _b;
       const oldProxyDraft = getProxyDraft(proxy);
       let copy = target.type === 3 ? target.setMap : target.copy;
       const draft = get(copy, key);
@@ -13295,7 +14962,7 @@ function createDraft(createDraftOptions) {
         finalizeSetValue(proxyDraft2);
         finalizePatches(proxyDraft2, generatePatches, patches, inversePatches);
         if (target.options.enableAutoFreeze) {
-          target.options.updatedValues = (_a = target.options.updatedValues) !== null && _a !== undefined ? _a : new WeakMap;
+          target.options.updatedValues = (_a2 = target.options.updatedValues) !== null && _a2 !== undefined ? _a2 : new WeakMap;
           target.options.updatedValues.set(updatedValue, proxyDraft2.original);
         }
         set(copy, key, updatedValue);
@@ -13314,9 +14981,9 @@ function createDraft(createDraftOptions) {
   return proxy;
 }
 function finalizeDraft(result, returnedValue, patches, inversePatches, enableAutoFreeze) {
-  var _a;
+  var _a2;
   const proxyDraft = getProxyDraft(result);
-  const original = (_a = proxyDraft === null || proxyDraft === undefined ? undefined : proxyDraft.original) !== null && _a !== undefined ? _a : result;
+  const original = (_a2 = proxyDraft === null || proxyDraft === undefined ? undefined : proxyDraft.original) !== null && _a2 !== undefined ? _a2 : result;
   const hasReturnedValue = !!returnedValue.length;
   if (proxyDraft === null || proxyDraft === undefined ? undefined : proxyDraft.operated) {
     while (proxyDraft.finalities.draft.length > 0) {
@@ -13337,7 +15004,7 @@ function finalizeDraft(result, returnedValue, patches, inversePatches, enableAut
   ];
 }
 function draftify(baseState, options) {
-  var _a;
+  var _a2;
   const finalities = {
     draft: [],
     revoke: [],
@@ -13350,7 +15017,7 @@ function draftify(baseState, options) {
     patches = [];
     inversePatches = [];
   }
-  const isMutable = ((_a = options.mark) === null || _a === undefined ? undefined : _a.call(options, baseState, dataTypes)) === dataTypes.mutable || !isDraftable(baseState, options);
+  const isMutable = ((_a2 = options.mark) === null || _a2 === undefined ? undefined : _a2.call(options, baseState, dataTypes)) === dataTypes.mutable || !isDraftable(baseState, options);
   const draft = isMutable ? baseState : createDraft({
     original: baseState,
     parentDraft: null,
@@ -13394,7 +15061,7 @@ function handleReturnValue(options) {
   }
 }
 function getCurrent(target) {
-  var _a;
+  var _a2;
   const proxyDraft = getProxyDraft(target);
   if (!isDraftable(target, proxyDraft === null || proxyDraft === undefined ? undefined : proxyDraft.options))
     return target;
@@ -13426,7 +15093,7 @@ function getCurrent(target) {
     }
   });
   if (type === 3) {
-    const value = (_a = proxyDraft === null || proxyDraft === undefined ? undefined : proxyDraft.original) !== null && _a !== undefined ? _a : currentValue;
+    const value = (_a2 = proxyDraft === null || proxyDraft === undefined ? undefined : proxyDraft.original) !== null && _a2 !== undefined ? _a2 : currentValue;
     return !isBaseSetInstance(value) ? new (Object.getPrototypeOf(value)).constructor(currentValue) : new Set(currentValue);
   }
   return currentValue;
@@ -15824,14 +17491,14 @@ var Operation, PROXY_DRAFT, RAW_RETURN_SYMBOL, iteratorSymbol, dataTypes, intern
     throw new Error(`Strict mode: Mutable data cannot be accessed directly, please use 'unsafe(callback)' wrap.`);
   }
 }, mapHandler, mapHandlerKeys, getNextIterator = (target, iterator, { isValuesIterator }) => () => {
-  var _a, _b;
+  var _a2, _b;
   const result = iterator.next();
   if (result.done)
     return result;
   const key = result.value;
   let value = target.setMap.get(key);
   const currentDraft = getProxyDraft(value);
-  const mutable = ((_b = (_a = target.options).mark) === null || _b === undefined ? undefined : _b.call(_a, value, dataTypes)) === dataTypes.mutable;
+  const mutable = ((_b = (_a2 = target.options).mark) === null || _b === undefined ? undefined : _b.call(_a2, value, dataTypes)) === dataTypes.mutable;
   if (target.options.strict) {
     checkReadable(key, target.options, mutable);
   }
@@ -15857,7 +17524,7 @@ var Operation, PROXY_DRAFT, RAW_RETURN_SYMBOL, iteratorSymbol, dataTypes, intern
     throw new Error(`Invalid options: ${String(arg)}, 'options' should be an object.`);
   }
   return function create(arg0, arg1, arg2) {
-    var _a, _b, _c;
+    var _a2, _b, _c;
     if (typeof arg0 === "function" && typeof arg1 !== "function") {
       return function(base22, ...args) {
         return create(base22, (draft2) => arg0.call(this, draft2, ...args), arg1);
@@ -15886,7 +17553,7 @@ var Operation, PROXY_DRAFT, RAW_RETURN_SYMBOL, iteratorSymbol, dataTypes, intern
       }
       return;
     } : options.mark;
-    const enablePatches = (_a = options.enablePatches) !== null && _a !== undefined ? _a : false;
+    const enablePatches = (_a2 = options.enablePatches) !== null && _a2 !== undefined ? _a2 : false;
     const strict = (_b = options.strict) !== null && _b !== undefined ? _b : false;
     const enableAutoFreeze = (_c = options.enableAutoFreeze) !== null && _c !== undefined ? _c : false;
     const _options = {
@@ -16038,10 +17705,10 @@ var init_dist = __esm(() => {
       });
     },
     get(key) {
-      var _a, _b;
+      var _a2, _b;
       const target = getProxyDraft(this);
       const value = latest(target).get(key);
-      const mutable = ((_b = (_a = target.options).mark) === null || _b === undefined ? undefined : _b.call(_a, value, dataTypes)) === dataTypes.mutable;
+      const mutable = ((_b = (_a2 = target.options).mark) === null || _b === undefined ? undefined : _b.call(_a2, value, dataTypes)) === dataTypes.mutable;
       if (target.options.strict) {
         checkReadable(value, target.options, mutable);
       }
@@ -16224,8 +17891,8 @@ var init_dist = __esm(() => {
   setHandlerKeys = Reflect.ownKeys(setHandler);
   proxyHandler = {
     get(target, key, receiver) {
-      var _a, _b;
-      const copy = (_a = target.copy) === null || _a === undefined ? undefined : _a[key];
+      var _a2, _b;
+      const copy = (_a2 = target.copy) === null || _a2 === undefined ? undefined : _a2[key];
       if (copy && target.finalities.draftsCache.has(copy)) {
         return copy;
       }
@@ -16291,7 +17958,7 @@ var init_dist = __esm(() => {
       return value;
     },
     set(target, key, value) {
-      var _a;
+      var _a2;
       if (target.type === 3 || target.type === 2) {
         throw new Error(`Map/Set draft does not support any property assignment.`);
       }
@@ -16308,7 +17975,7 @@ var init_dist = __esm(() => {
       const currentProxyDraft = getProxyDraft(current);
       if (currentProxyDraft && isEqual(currentProxyDraft.original, value)) {
         target.copy[key] = value;
-        target.assignedMap = (_a = target.assignedMap) !== null && _a !== undefined ? _a : new Map;
+        target.assignedMap = (_a2 = target.assignedMap) !== null && _a2 !== undefined ? _a2 : new Map;
         target.assignedMap.set(key, false);
         return true;
       }
@@ -16353,7 +18020,7 @@ var init_dist = __esm(() => {
       throw new Error(`Cannot call 'defineProperty()' on drafts`);
     },
     deleteProperty(target, key) {
-      var _a;
+      var _a2;
       if (target.type === 1) {
         return proxyHandler.set.call(this, target, key, undefined, target.proxy);
       }
@@ -16362,7 +18029,7 @@ var init_dist = __esm(() => {
         markChanged(target);
         target.assignedMap.set(key, false);
       } else {
-        target.assignedMap = (_a = target.assignedMap) !== null && _a !== undefined ? _a : new Map;
+        target.assignedMap = (_a2 = target.assignedMap) !== null && _a2 !== undefined ? _a2 : new Map;
         target.assignedMap.delete(key);
       }
       if (target.copy)
@@ -17481,7 +19148,7 @@ var init_dist = __esm(() => {
   };
 });
 
-// ../../node_modules/commander/esm.mjs
+// node_modules/commander/esm.mjs
 var import__ = __toESM(require_commander(), 1);
 var {
   program,
@@ -17497,10 +19164,10 @@ var {
   Help
 } = import__.default;
 
-// ../../node_modules/find-up/index.js
+// node_modules/find-up/index.js
 import path2 from "node:path";
 
-// ../../node_modules/locate-path/index.js
+// node_modules/find-up/node_modules/locate-path/index.js
 import process2 from "node:process";
 import path from "node:path";
 import fs, { promises as fsPromises } from "node:fs";
@@ -17546,7 +19213,7 @@ function toPath2(urlOrPath) {
   return urlOrPath instanceof URL ? fileURLToPath2(urlOrPath) : urlOrPath;
 }
 
-// ../../node_modules/find-up/index.js
+// node_modules/find-up/index.js
 var findUpStop = Symbol("findUpStop");
 function findUpMultipleSync(name, options = {}) {
   let directory = path2.resolve(toPath2(options.cwd) ?? "");
@@ -19755,8 +21422,35 @@ var unescape = (s, { windowsPathsNoEscape = false } = {}) => {
 };
 
 // node_modules/glob/node_modules/minimatch/dist/esm/ast.js
+var _a;
 var types = new Set(["!", "?", "+", "*", "@"]);
 var isExtglobType = (c) => types.has(c);
+var isExtglobAST = (c) => isExtglobType(c.type);
+var adoptionMap = new Map([
+  ["!", ["@"]],
+  ["?", ["?", "@"]],
+  ["@", ["@"]],
+  ["*", ["*", "+", "?", "@"]],
+  ["+", ["+", "@"]]
+]);
+var adoptionWithSpaceMap = new Map([
+  ["!", ["?"]],
+  ["@", ["?"]],
+  ["+", ["?", "*"]]
+]);
+var adoptionAnyMap = new Map([
+  ["!", ["?", "@"]],
+  ["?", ["?", "@"]],
+  ["@", ["?", "@"]],
+  ["*", ["*", "+", "?", "@"]],
+  ["+", ["+", "@", "?", "*"]]
+]);
+var usurpMap = new Map([
+  ["!", new Map([["!", "@"]])],
+  ["?", new Map([["*", "*"], ["+", "*"]])],
+  ["@", new Map([["!", "!"], ["?", "?"], ["@", "@"], ["*", "*"], ["+", "+"]])],
+  ["+", new Map([["?", "*"], ["*", "*"]])]
+]);
 var startNoTraversal = "(?!(?:^|/)\\.\\.?(?:$|/))";
 var startNoDot = "(?!\\.)";
 var addPatternStart = new Set(["[", "."]);
@@ -19844,7 +21538,7 @@ class AST {
     for (const p of parts) {
       if (p === "")
         continue;
-      if (typeof p !== "string" && !(p instanceof AST && p.#parent === this)) {
+      if (typeof p !== "string" && !(p instanceof _a && p.#parent === this)) {
         throw new Error("invalid part: " + p);
       }
       this.#parts.push(p);
@@ -19869,7 +21563,7 @@ class AST {
     const p = this.#parent;
     for (let i = 0;i < this.#parentIndex; i++) {
       const pp = p.#parts[i];
-      if (!(pp instanceof AST && pp.type === "!")) {
+      if (!(pp instanceof _a && pp.type === "!")) {
         return false;
       }
     }
@@ -19894,13 +21588,14 @@ class AST {
       this.push(part.clone(this));
   }
   clone(parent) {
-    const c = new AST(this.type, parent);
+    const c = new _a(this.type, parent);
     for (const p of this.#parts) {
       c.copyIn(p);
     }
     return c;
   }
-  static #parseAST(str, ast, pos, opt) {
+  static #parseAST(str, ast, pos, opt, extDepth) {
+    const maxDepth = opt.maxExtglobRecursion ?? 2;
     let escaping = false;
     let inBrace = false;
     let braceStart = -1;
@@ -19932,11 +21627,12 @@ class AST {
           acc2 += c;
           continue;
         }
-        if (!opt.noext && isExtglobType(c) && str.charAt(i2) === "(") {
+        const doRecurse = !opt.noext && isExtglobType(c) && str.charAt(i2) === "(" && extDepth <= maxDepth;
+        if (doRecurse) {
           ast.push(acc2);
           acc2 = "";
-          const ext = new AST(c, ast);
-          i2 = AST.#parseAST(str, ext, i2, opt);
+          const ext = new _a(c, ast);
+          i2 = _a.#parseAST(str, ext, i2, opt, extDepth + 1);
           ast.push(ext);
           continue;
         }
@@ -19946,7 +21642,7 @@ class AST {
       return i2;
     }
     let i = pos + 1;
-    let part = new AST(null, ast);
+    let part = new _a(null, ast);
     const parts = [];
     let acc = "";
     while (i < str.length) {
@@ -19973,19 +21669,21 @@ class AST {
         acc += c;
         continue;
       }
-      if (isExtglobType(c) && str.charAt(i) === "(") {
+      const doRecurse = isExtglobType(c) && str.charAt(i) === "(" && (extDepth <= maxDepth || ast && ast.#canAdoptType(c));
+      if (doRecurse) {
+        const depthAdd = ast && ast.#canAdoptType(c) ? 0 : 1;
         part.push(acc);
         acc = "";
-        const ext = new AST(c, part);
+        const ext = new _a(c, part);
         part.push(ext);
-        i = AST.#parseAST(str, ext, i, opt);
+        i = _a.#parseAST(str, ext, i, opt, extDepth + depthAdd);
         continue;
       }
       if (c === "|") {
         part.push(acc);
         acc = "";
         parts.push(part);
-        part = new AST(null, ast);
+        part = new _a(null, ast);
         continue;
       }
       if (c === ")") {
@@ -20004,9 +21702,101 @@ class AST {
     ast.#parts = [str.substring(pos - 1)];
     return i;
   }
+  #canAdoptWithSpace(child) {
+    return this.#canAdopt(child, adoptionWithSpaceMap);
+  }
+  #canAdopt(child, map = adoptionMap) {
+    if (!child || typeof child !== "object" || child.type !== null || child.#parts.length !== 1 || this.type === null) {
+      return false;
+    }
+    const gc = child.#parts[0];
+    if (!gc || typeof gc !== "object" || gc.type === null) {
+      return false;
+    }
+    return this.#canAdoptType(gc.type, map);
+  }
+  #canAdoptType(c, map = adoptionAnyMap) {
+    return !!map.get(this.type)?.includes(c);
+  }
+  #adoptWithSpace(child, index) {
+    const gc = child.#parts[0];
+    const blank = new _a(null, gc, this.options);
+    blank.#parts.push("");
+    gc.push(blank);
+    this.#adopt(child, index);
+  }
+  #adopt(child, index) {
+    const gc = child.#parts[0];
+    this.#parts.splice(index, 1, ...gc.#parts);
+    for (const p of gc.#parts) {
+      if (typeof p === "object")
+        p.#parent = this;
+    }
+    this.#toString = undefined;
+  }
+  #canUsurpType(c) {
+    const m = usurpMap.get(this.type);
+    return !!m?.has(c);
+  }
+  #canUsurp(child) {
+    if (!child || typeof child !== "object" || child.type !== null || child.#parts.length !== 1 || this.type === null || this.#parts.length !== 1) {
+      return false;
+    }
+    const gc = child.#parts[0];
+    if (!gc || typeof gc !== "object" || gc.type === null) {
+      return false;
+    }
+    return this.#canUsurpType(gc.type);
+  }
+  #usurp(child) {
+    const m = usurpMap.get(this.type);
+    const gc = child.#parts[0];
+    const nt = m?.get(gc.type);
+    if (!nt)
+      return false;
+    this.#parts = gc.#parts;
+    for (const p of this.#parts) {
+      if (typeof p === "object")
+        p.#parent = this;
+    }
+    this.type = nt;
+    this.#toString = undefined;
+    this.#emptyExt = false;
+  }
+  #flatten() {
+    if (!isExtglobAST(this)) {
+      for (const p of this.#parts) {
+        if (typeof p === "object")
+          p.#flatten();
+      }
+    } else {
+      let iterations = 0;
+      let done = false;
+      do {
+        done = true;
+        for (let i = 0;i < this.#parts.length; i++) {
+          const c = this.#parts[i];
+          if (typeof c === "object") {
+            c.#flatten();
+            if (this.#canAdopt(c)) {
+              done = false;
+              this.#adopt(c, i);
+            } else if (this.#canAdoptWithSpace(c)) {
+              done = false;
+              this.#adoptWithSpace(c, i);
+            } else if (this.#canUsurp(c)) {
+              done = false;
+              this.#usurp(c);
+            }
+          }
+        }
+      } while (!done && ++iterations < 10);
+    }
+    this.#toString = undefined;
+  }
   static fromGlob(pattern, options = {}) {
-    const ast = new AST(null, undefined, options);
-    AST.#parseAST(pattern, ast, 0, options);
+    const ast = new _a(null, undefined, options);
+    _a.#parseAST(pattern, ast, 0, options, 0);
     return ast;
   }
   toMMPattern() {
@@ -20029,12 +21819,14 @@ class AST {
   }
   toRegExpSource(allowDot) {
     const dot = allowDot ?? !!this.#options.dot;
-    if (this.#root === this)
+    if (this.#root === this) {
+      this.#flatten();
       this.#fillNegs();
-    if (!this.type) {
+    }
+    if (!isExtglobAST(this)) {
       const noEmpty = this.isStart() && this.isEnd();
       const src = this.#parts.map((p) => {
-        const [re, _, hasMagic, uflag] = typeof p === "string" ? AST.#parseGlob(p, this.#hasMagic, noEmpty) : p.toRegExpSource(allowDot);
+        const [re, _, hasMagic, uflag] = typeof p === "string" ? _a.#parseGlob(p, this.#hasMagic, noEmpty) : p.toRegExpSource(allowDot);
         this.#hasMagic = this.#hasMagic || hasMagic;
         this.#uflag = this.#uflag || uflag;
         return re;
@@ -20068,9 +21860,10 @@ class AST {
     let body = this.#partsToRegExp(dot);
     if (this.isStart() && this.isEnd() && !body && this.type !== "!") {
       const s = this.toString();
-      this.#parts = [s];
-      this.type = null;
-      this.#hasMagic = undefined;
+      const me = this;
+      me.#parts = [s];
+      me.type = null;
+      me.#hasMagic = undefined;
       return [s, unescape(this.toString()), false, false];
     }
     let bodyDotAllowed = !repeated || allowDot || dot || !startNoDot ? "" : this.#partsToRegExp(true);
@@ -20108,11 +21901,13 @@ class AST {
     let escaping = false;
     let re = "";
     let uflag = false;
+    let inStar = false;
     for (let i = 0;i < glob.length; i++) {
       const c = glob.charAt(i);
       if (escaping) {
         escaping = false;
         re += (reSpecials.has(c) ? "\\" : "") + c;
+        inStar = false;
         continue;
       }
       if (c === "\\") {
@@ -20130,16 +21925,19 @@ class AST {
           uflag = uflag || needUflag;
           i += consumed - 1;
           hasMagic = hasMagic || magic;
+          inStar = false;
           continue;
         }
       }
       if (c === "*") {
-        if (noEmpty && glob === "*")
-          re += starNoEmpty;
-        else
-          re += star;
+        if (inStar)
+          continue;
+        inStar = true;
+        re += noEmpty && /^[*]+$/.test(glob) ? starNoEmpty : star;
         hasMagic = true;
         continue;
+      } else {
+        inStar = false;
       }
       if (c === "?") {
         re += qmark;
@@ -20151,6 +21949,7 @@ class AST {
     return [re, unescape(glob), !!hasMagic, uflag];
   }
 }
+_a = AST;
 
 // node_modules/glob/node_modules/minimatch/dist/esm/escape.js
 var escape = (s, { windowsPathsNoEscape = false } = {}) => {
@@ -20305,11 +22104,13 @@ class Minimatch {
   isWindows;
   platform;
   windowsNoMagicRoot;
+  maxGlobstarRecursion;
   regexp;
   constructor(pattern, options = {}) {
     assertValidPattern(pattern);
     options = options || {};
     this.options = options;
+    this.maxGlobstarRecursion = options.maxGlobstarRecursion ?? 200;
     this.pattern = pattern;
     this.platform = options.platform || defaultPlatform;
     this.isWindows = this.platform === "win32";
@@ -20604,7 +22405,8 @@ class Minimatch {
     this.negate = negate;
   }
   matchOne(file, pattern, partial = false) {
-    const options = this.options;
+    let fileStartIndex = 0;
+    let patternStartIndex = 0;
     if (this.isWindows) {
       const fileDrive = typeof file[0] === "string" && /^[a-z]:$/i.test(file[0]);
       const fileUNC = !fileDrive && file[0] === "" && file[1] === "" && file[2] === "?" && /^[a-z]:$/i.test(file[3]);
@@ -20613,14 +22415,14 @@ class Minimatch {
       const fdi = fileUNC ? 3 : fileDrive ? 0 : undefined;
       const pdi = patternUNC ? 3 : patternDrive ? 0 : undefined;
       if (typeof fdi === "number" && typeof pdi === "number") {
-        const [fd, pd] = [file[fdi], pattern[pdi]];
+        const [fd, pd] = [
+          file[fdi],
+          pattern[pdi]
+        ];
         if (fd.toLowerCase() === pd.toLowerCase()) {
           pattern[pdi] = fd;
-          if (pdi > fdi) {
-            pattern = pattern.slice(pdi);
-          } else if (fdi > pdi) {
-            file = file.slice(fdi);
-          }
+          patternStartIndex = pdi;
+          fileStartIndex = fdi;
         }
       }
     }
@@ -20628,53 +22430,118 @@ class Minimatch {
     if (optimizationLevel >= 2) {
       file = this.levelTwoFileOptimize(file);
     }
-    this.debug("matchOne", this, { file, pattern });
-    this.debug("matchOne", file.length, pattern.length);
-    for (var fi = 0, pi = 0, fl = file.length, pl = pattern.length;fi < fl && pi < pl; fi++, pi++) {
-      this.debug("matchOne loop");
-      var p = pattern[pi];
-      var f = file[fi];
-      this.debug(pattern, p, f);
-      if (p === false) {
+    if (pattern.includes(GLOBSTAR)) {
+      return this.#matchGlobstar(file, pattern, partial, fileStartIndex, patternStartIndex);
+    }
+    return this.#matchOne(file, pattern, partial, fileStartIndex, patternStartIndex);
+  }
+  #matchGlobstar(file, pattern, partial, fileIndex, patternIndex) {
+    const firstgs = pattern.indexOf(GLOBSTAR, patternIndex);
+    const lastgs = pattern.lastIndexOf(GLOBSTAR);
+    const [head, body, tail] = partial ? [
+      pattern.slice(patternIndex, firstgs),
+      pattern.slice(firstgs + 1),
+      []
+    ] : [
+      pattern.slice(patternIndex, firstgs),
+      pattern.slice(firstgs + 1, lastgs),
+      pattern.slice(lastgs + 1)
+    ];
+    if (head.length) {
+      const fileHead = file.slice(fileIndex, fileIndex + head.length);
+      if (!this.#matchOne(fileHead, head, partial, 0, 0))
         return false;
-      }
-      if (p === GLOBSTAR) {
-        this.debug("GLOBSTAR", [pattern, p, f]);
-        var fr = fi;
-        var pr = pi + 1;
-        if (pr === pl) {
-          this.debug("** at the end");
-          for (;fi < fl; fi++) {
-            if (file[fi] === "." || file[fi] === ".." || !options.dot && file[fi].charAt(0) === ".")
-              return false;
-          }
-          return true;
+      fileIndex += head.length;
+    }
+    let fileTailMatch = 0;
+    if (tail.length) {
+      if (tail.length + fileIndex > file.length)
+        return false;
+      let tailStart = file.length - tail.length;
+      if (this.#matchOne(file, tail, partial, tailStart, 0)) {
+        fileTailMatch = tail.length;
+      } else {
+        if (file[file.length - 1] !== "" || fileIndex + tail.length === file.length) {
+          return false;
         }
-        while (fr < fl) {
-          var swallowee = file[fr];
-          this.debug(`
-globstar while`, file, fr, pattern, pr, swallowee);
-          if (this.matchOne(file.slice(fr), pattern.slice(pr), partial)) {
-            this.debug("globstar found match!", fr, fl, swallowee);
-            return true;
-          } else {
-            if (swallowee === "." || swallowee === ".." || !options.dot && swallowee.charAt(0) === ".") {
-              this.debug("dot detected!", file, fr, pattern, pr);
-              break;
-            }
-            this.debug("globstar swallow a segment, and continue");
-            fr++;
-          }
+        tailStart--;
+        if (!this.#matchOne(file, tail, partial, tailStart, 0))
+          return false;
+        fileTailMatch = tail.length + 1;
+      }
+    }
+    if (!body.length) {
+      let sawSome = !!fileTailMatch;
+      for (let i2 = fileIndex;i2 < file.length - fileTailMatch; i2++) {
+        const f = String(file[i2]);
+        sawSome = true;
+        if (f === "." || f === ".." || !this.options.dot && f.startsWith(".")) {
+          return false;
         }
-        if (partial) {
-          this.debug(`
->>> no match, partial?`, file, fr, pattern, pr);
-          if (fr === fl) {
-            return true;
-          }
+      }
+      return partial || sawSome;
+    }
+    const bodySegments = [[[], 0]];
+    let currentBody = bodySegments[0];
+    let nonGsParts = 0;
+    const nonGsPartsSums = [0];
+    for (const b of body) {
+      if (b === GLOBSTAR) {
+        nonGsPartsSums.push(nonGsParts);
+        currentBody = [[], 0];
+        bodySegments.push(currentBody);
+      } else {
+        currentBody[0].push(b);
+        nonGsParts++;
+      }
+    }
+    let i = bodySegments.length - 1;
+    const fileLength = file.length - fileTailMatch;
+    for (const b of bodySegments) {
+      b[1] = fileLength - (nonGsPartsSums[i--] + b[0].length);
+    }
+    return !!this.#matchGlobStarBodySections(file, bodySegments, fileIndex, 0, partial, 0, !!fileTailMatch);
+  }
+  #matchGlobStarBodySections(file, bodySegments, fileIndex, bodyIndex, partial, globStarDepth, sawTail) {
+    const bs = bodySegments[bodyIndex];
+    if (!bs) {
+      for (let i = fileIndex;i < file.length; i++) {
+        sawTail = true;
+        const f = file[i];
+        if (f === "." || f === ".." || !this.options.dot && f.startsWith(".")) {
+          return false;
         }
+      }
+      return sawTail;
+    }
+    const [body, after] = bs;
+    while (fileIndex <= after) {
+      const m = this.#matchOne(file.slice(0, fileIndex + body.length), body, partial, fileIndex, 0);
+      if (m && globStarDepth < this.maxGlobstarRecursion) {
+        const sub = this.#matchGlobStarBodySections(file, bodySegments, fileIndex + body.length, bodyIndex + 1, partial, globStarDepth + 1, sawTail);
+        if (sub !== false)
+          return sub;
+      }
+      const f = file[fileIndex];
+      if (f === "." || f === ".." || !this.options.dot && f.startsWith(".")) {
         return false;
       }
+      fileIndex++;
+    }
+    return partial || null;
+  }
+  #matchOne(file, pattern, partial, fileIndex, patternIndex) {
+    let fi;
+    let pi;
+    let pl;
+    let fl;
+    for (fi = fileIndex, pi = patternIndex, fl = file.length, pl = pattern.length;fi < fl && pi < pl; fi++, pi++) {
+      this.debug("matchOne loop");
+      let p = pattern[pi];
+      let f = file[fi];
+      this.debug(pattern, p, f);
+      if (p === false || p === GLOBSTAR)
+        return false;
       let hit;
       if (typeof p === "string") {
         hit = f === p;
@@ -25806,6 +27673,9 @@ var SHELL_EXTERNALS = [
   "@arcote.tech/arc",
   "@arcote.tech/arc-ds",
   "@arcote.tech/arc-react",
+  "@arcote.tech/arc-auth",
+  "@arcote.tech/arc-utils",
+  "@arcote.tech/arc-workspace",
   "@arcote.tech/platform"
 ];
 function discoverPackages(rootDir) {
@@ -25890,6 +27760,14 @@ async function buildPackages(rootDir, outDir, packages) {
   }
   console.log(`  Bundling ${entrypoints.length} package(s)...`);
   const i18nCollector = new Map;
+  const arcExternalPlugin = {
+    name: "arc-external",
+    setup(build2) {
+      build2.onResolve({ filter: /^@arcote\.tech\// }, (args) => {
+        return { path: args.path, external: true };
+      });
+    }
+  };
   const result = await Bun.build({
     entrypoints,
     outdir: outDir,
@@ -25897,7 +27775,7 @@ async function buildPackages(rootDir, outDir, packages) {
     format: "esm",
     target: "browser",
     external: SHELL_EXTERNALS,
-    plugins: [i18nExtractPlugin(i18nCollector, rootDir)],
+    plugins: [arcExternalPlugin, i18nExtractPlugin(i18nCollector, rootDir)],
     naming: "[name].[ext]",
     define: {
       ONLY_SERVER: "false",
@@ -26128,6 +28006,9 @@ export const { createPortal, flushSync } = ReactDOM;`
     ["arc", "@arcote.tech/arc"],
     ["arc-ds", "@arcote.tech/arc-ds"],
     ["arc-react", "@arcote.tech/arc-react"],
+    ["arc-auth", "@arcote.tech/arc-auth"],
+    ["arc-utils", "@arcote.tech/arc-utils"],
+    ["arc-workspace", "@arcote.tech/arc-workspace"],
     ["platform", "@arcote.tech/platform"]
   ];
   const arcEps = [];
@@ -26150,7 +28031,12 @@ export const { createPortal, flushSync } = ReactDOM;`
       "react/jsx-runtime",
       "react/jsx-dev-runtime",
       "react-dom/client"
-    ]
+    ],
+    define: {
+      ONLY_SERVER: "false",
+      ONLY_BROWSER: "true",
+      ONLY_CLIENT: "true"
+    }
   });
   if (!r2.success) {
     for (const l of r2.logs)
@@ -26167,6 +28053,10 @@ async function loadServerContext(packages) {
   globalThis.ONLY_SERVER = true;
   globalThis.ONLY_BROWSER = false;
   globalThis.ONLY_CLIENT = false;
+  const platformDir = join7(process.cwd(), "node_modules", "@arcote.tech", "platform");
+  const platformPkg = JSON.parse(readFileSync6(join7(platformDir, "package.json"), "utf-8"));
+  const platformEntry = join7(platformDir, platformPkg.main ?? "src/index.ts");
+  await import(platformEntry);
   for (const ctx of ctxPackages) {
     const serverDist = join7(ctx.path, "dist", "server", "main", "index.js");
     if (!existsSync6(serverDist)) {
@@ -26179,7 +28069,7 @@ async function loadServerContext(packages) {
       err(`Failed to load server context from ${ctx.name}: ${e}`);
     }
   }
-  const { getContext } = await import("@arcote.tech/platform");
+  const { getContext } = await import(platformEntry);
   return getContext() ?? null;
 }
 
@@ -27608,6 +29498,9 @@ function generateShellHtml(appName, manifest) {
       "@arcote.tech/arc": "/shell/arc.js",
       "@arcote.tech/arc-ds": "/shell/arc-ds.js",
       "@arcote.tech/arc-react": "/shell/arc-react.js",
+      "@arcote.tech/arc-auth": "/shell/arc-auth.js",
+      "@arcote.tech/arc-utils": "/shell/arc-utils.js",
+      "@arcote.tech/arc-workspace": "/shell/arc-workspace.js",
       "@arcote.tech/platform": "/shell/platform.js"
     }
   };