@vercel/python 16.0.0 → 17.0.1

package/dist/index.js

@@ -5,7 +5,6 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __commonJS = (cb, mod) => function __require() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
@@ -30,32 +29,6 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var __publicField = (obj, key, value) => {
-  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-  return value;
-};
-var __accessCheck = (obj, member, msg) => {
-  if (!member.has(obj))
-    throw TypeError("Cannot " + msg);
-};
-var __privateGet = (obj, member, getter) => {
-  __accessCheck(obj, member, "read from private field");
-  return getter ? getter.call(obj) : member.get(obj);
-};
-var __privateAdd = (obj, member, value) => {
-  if (member.has(obj))
-    throw TypeError("Cannot add the same private member more than once");
-  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-};
-var __privateSet = (obj, member, value, setter) => {
-  __accessCheck(obj, member, "write to private field");
-  setter ? setter.call(obj, value) : member.set(obj, value);
-  return value;
-};
-var __privateMethod = (obj, member, method) => {
-  __accessCheck(obj, member, "access private method");
-  return method;
-};
 
 // ../../node_modules/.pnpm/nice-try@1.0.5/node_modules/nice-try/src/index.js
 var require_src = __commonJS({
@@ -76,7 +49,7 @@ var require_windows = __commonJS({
     module2.exports = isexe;
     isexe.sync = sync;
     var fs19 = require("fs");
-    function checkPathExt(path2, options) {
+    function checkPathExt(path, options) {
       var pathext = options.pathExt !== void 0 ? options.pathExt : process.env.PATHEXT;
       if (!pathext) {
         return true;
@@ -87,25 +60,25 @@ var require_windows = __commonJS({
       }
       for (var i = 0; i < pathext.length; i++) {
         var p = pathext[i].toLowerCase();
-        if (p && path2.substr(-p.length).toLowerCase() === p) {
+        if (p && path.substr(-p.length).toLowerCase() === p) {
           return true;
         }
       }
       return false;
     }
-    function checkStat(stat, path2, options) {
+    function checkStat(stat, path, options) {
       if (!stat.isSymbolicLink() && !stat.isFile()) {
         return false;
       }
-      return checkPathExt(path2, options);
+      return checkPathExt(path, options);
     }
-    function isexe(path2, options, cb) {
-      fs19.stat(path2, function(er, stat) {
-        cb(er, er ? false : checkStat(stat, path2, options));
+    function isexe(path, options, cb) {
+      fs19.stat(path, function(er, stat) {
+        cb(er, er ? false : checkStat(stat, path, options));
       });
     }
-    function sync(path2, options) {
-      return checkStat(fs19.statSync(path2), path2, options);
+    function sync(path, options) {
+      return checkStat(fs19.statSync(path), path, options);
     }
   }
 });
@@ -116,13 +89,13 @@ var require_mode = __commonJS({
     module2.exports = isexe;
     isexe.sync = sync;
     var fs19 = require("fs");
-    function isexe(path2, options, cb) {
-      fs19.stat(path2, function(er, stat) {
+    function isexe(path, options, cb) {
+      fs19.stat(path, function(er, stat) {
         cb(er, er ? false : checkStat(stat, options));
       });
     }
-    function sync(path2, options) {
-      return checkStat(fs19.statSync(path2), options);
+    function sync(path, options) {
+      return checkStat(fs19.statSync(path), options);
     }
     function checkStat(stat, options) {
       return stat.isFile() && checkMode(stat, options);
@@ -155,7 +128,7 @@ var require_isexe = __commonJS({
     }
     module2.exports = isexe;
     isexe.sync = sync;
-    function isexe(path2, options, cb) {
+    function isexe(path, options, cb) {
       if (typeof options === "function") {
         cb = options;
         options = {};
@@ -165,7 +138,7 @@ var require_isexe = __commonJS({
           throw new TypeError("callback not provided");
         }
         return new Promise(function(resolve4, reject) {
-          isexe(path2, options || {}, function(er, is) {
+          isexe(path, options || {}, function(er, is) {
             if (er) {
               reject(er);
             } else {
@@ -174,7 +147,7 @@ var require_isexe = __commonJS({
           });
         });
       }
-      core(path2, options || {}, function(er, is) {
+      core(path, options || {}, function(er, is) {
         if (er) {
           if (er.code === "EACCES" || options && options.ignoreErrors) {
             er = null;
@@ -184,9 +157,9 @@ var require_isexe = __commonJS({
         cb(er, is);
       });
     }
-    function sync(path2, options) {
+    function sync(path, options) {
       try {
-        return core.sync(path2, options || {});
+        return core.sync(path, options || {});
       } catch (er) {
         if (options && options.ignoreErrors || er.code === "EACCES") {
           return false;
@@ -204,7 +177,7 @@ var require_which = __commonJS({
     module2.exports = which2;
     which2.sync = whichSync;
     var isWindows = process.platform === "win32" || process.env.OSTYPE === "cygwin" || process.env.OSTYPE === "msys";
-    var path2 = require("path");
+    var path = require("path");
     var COLON = isWindows ? ";" : ":";
     var isexe = require_isexe();
     function getNotFoundError(cmd) {
@@ -253,7 +226,7 @@ var require_which = __commonJS({
         var pathPart = pathEnv[i];
         if (pathPart.charAt(0) === '"' && pathPart.slice(-1) === '"')
           pathPart = pathPart.slice(1, -1);
-        var p = path2.join(pathPart, cmd);
+        var p = path.join(pathPart, cmd);
         if (!pathPart && /^\.[\\\/]/.test(cmd)) {
           p = cmd.slice(0, 2) + p;
         }
@@ -261,13 +234,13 @@ var require_which = __commonJS({
         (function E(ii, ll) {
           if (ii === ll)
             return F(i + 1, l);
-          var ext2 = pathExt[ii];
-          isexe(p + ext2, { pathExt: pathExtExe }, function(er, is) {
+          var ext = pathExt[ii];
+          isexe(p + ext, { pathExt: pathExtExe }, function(er, is) {
             if (!er && is) {
               if (opt.all)
-                found.push(p + ext2);
+                found.push(p + ext);
               else
-                return cb(null, p + ext2);
+                return cb(null, p + ext);
             }
             return E(ii + 1, ll);
           });
@@ -285,7 +258,7 @@ var require_which = __commonJS({
         var pathPart = pathEnv[i];
         if (pathPart.charAt(0) === '"' && pathPart.slice(-1) === '"')
           pathPart = pathPart.slice(1, -1);
-        var p = path2.join(pathPart, cmd);
+        var p = path.join(pathPart, cmd);
         if (!pathPart && /^\.[\\\/]/.test(cmd)) {
           p = cmd.slice(0, 2) + p;
         }
@@ -333,7 +306,7 @@ var require_path_key = __commonJS({
 var require_resolveCommand = __commonJS({
   "../../node_modules/.pnpm/cross-spawn@6.0.5/node_modules/cross-spawn/lib/util/resolveCommand.js"(exports, module2) {
     "use strict";
-    var path2 = require("path");
+    var path = require("path");
     var which2 = require_which();
     var pathKey = require_path_key()();
     function resolveCommandAttempt(parsed, withoutPathExt) {
@@ -349,14 +322,14 @@ var require_resolveCommand = __commonJS({
       try {
         resolved = which2.sync(parsed.command, {
           path: (parsed.options.env || process.env)[pathKey],
-          pathExt: withoutPathExt ? path2.delimiter : void 0
+          pathExt: withoutPathExt ? path.delimiter : void 0
         });
       } catch (e) {
       } finally {
         process.chdir(cwd);
       }
       if (resolved) {
-        resolved = path2.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
+        resolved = path.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
       }
       return resolved;
     }
@@ -406,11 +379,11 @@ var require_shebang_command = __commonJS({
     "use strict";
     var shebangRegex = require_shebang_regex();
     module2.exports = function(str) {
-      var match2 = str.match(shebangRegex);
-      if (!match2) {
+      var match = str.match(shebangRegex);
+      if (!match) {
         return null;
       }
-      var arr = match2[0].replace(/#! ?/, "").split(" ");
+      var arr = match[0].replace(/#! ?/, "").split(" ");
       var bin = arr[0].split("/").pop();
       var arg = arr[1];
       return bin === "env" ? arg : bin + (arg ? " " + arg : "");
@@ -836,10 +809,10 @@ var require_semver = __commonJS({
       }
     }
     exports.compareIdentifiers = compareIdentifiers;
-    var numeric2 = /^[0-9]+$/;
+    var numeric = /^[0-9]+$/;
     function compareIdentifiers(a, b) {
-      var anum = numeric2.test(a);
-      var bnum = numeric2.test(b);
+      var anum = numeric.test(a);
+      var bnum = numeric.test(b);
       if (anum && bnum) {
         a = +a;
         b = +b;
@@ -902,12 +875,12 @@ var require_semver = __commonJS({
     function neq(a, b, loose) {
       return compare(a, b, loose) !== 0;
     }
-    exports.gte = gte2;
-    function gte2(a, b, loose) {
+    exports.gte = gte;
+    function gte(a, b, loose) {
       return compare(a, b, loose) >= 0;
     }
-    exports.lte = lte2;
-    function lte2(a, b, loose) {
+    exports.lte = lte;
+    function lte(a, b, loose) {
       return compare(a, b, loose) <= 0;
     }
     exports.cmp = cmp;
@@ -934,11 +907,11 @@ var require_semver = __commonJS({
         case ">":
           return gt(a, b, loose);
         case ">=":
-          return gte2(a, b, loose);
+          return gte(a, b, loose);
         case "<":
           return lt(a, b, loose);
         case "<=":
-          return lte2(a, b, loose);
+          return lte(a, b, loose);
         default:
           throw new TypeError("Invalid operator: " + op);
       }
@@ -1030,32 +1003,32 @@ var require_semver = __commonJS({
       return sameDirectionIncreasing || sameDirectionDecreasing || sameSemVer && differentDirectionsInclusive || oppositeDirectionsLessThan || oppositeDirectionsGreaterThan;
     };
     exports.Range = Range;
-    function Range(range2, options) {
+    function Range(range, options) {
       if (!options || typeof options !== "object") {
         options = {
           loose: !!options,
           includePrerelease: false
         };
       }
-      if (range2 instanceof Range) {
-        if (range2.loose === !!options.loose && range2.includePrerelease === !!options.includePrerelease) {
-          return range2;
+      if (range instanceof Range) {
+        if (range.loose === !!options.loose && range.includePrerelease === !!options.includePrerelease) {
+          return range;
         } else {
-          return new Range(range2.raw, options);
+          return new Range(range.raw, options);
         }
       }
-      if (range2 instanceof Comparator) {
-        return new Range(range2.value, options);
+      if (range instanceof Comparator) {
+        return new Range(range.value, options);
       }
       if (!(this instanceof Range)) {
-        return new Range(range2, options);
+        return new Range(range, options);
       }
       this.options = options;
       this.loose = !!options.loose;
       this.includePrerelease = !!options.includePrerelease;
-      this.raw = range2.trim().split(/\s+/).join(" ");
-      this.set = this.raw.split("||").map(function(range3) {
-        return this.parseRange(range3.trim());
+      this.raw = range.trim().split(/\s+/).join(" ");
+      this.set = this.raw.split("||").map(function(range2) {
+        return this.parseRange(range2.trim());
       }, this).filter(function(c) {
         return c.length;
       });
@@ -1073,17 +1046,17 @@ var require_semver = __commonJS({
     Range.prototype.toString = function() {
       return this.range;
     };
-    Range.prototype.parseRange = function(range2) {
+    Range.prototype.parseRange = function(range) {
       var loose = this.options.loose;
       var hr = loose ? safeRe[HYPHENRANGELOOSE] : safeRe[HYPHENRANGE];
-      range2 = range2.replace(hr, hyphenReplace);
-      debug18("hyphen replace", range2);
-      range2 = range2.replace(safeRe[COMPARATORTRIM], comparatorTrimReplace);
-      debug18("comparator trim", range2, safeRe[COMPARATORTRIM]);
-      range2 = range2.replace(safeRe[TILDETRIM], tildeTrimReplace);
-      range2 = range2.replace(safeRe[CARETTRIM], caretTrimReplace);
+      range = range.replace(hr, hyphenReplace);
+      debug18("hyphen replace", range);
+      range = range.replace(safeRe[COMPARATORTRIM], comparatorTrimReplace);
+      debug18("comparator trim", range, safeRe[COMPARATORTRIM]);
+      range = range.replace(safeRe[TILDETRIM], tildeTrimReplace);
+      range = range.replace(safeRe[CARETTRIM], caretTrimReplace);
       var compRe = loose ? safeRe[COMPARATORLOOSE] : safeRe[COMPARATOR];
-      var set = range2.split(" ").map(function(comp) {
+      var set = range.split(" ").map(function(comp) {
         return parseComparator(comp, this.options);
       }, this).join(" ").split(/\s+/);
       if (this.options.loose) {
@@ -1096,13 +1069,13 @@ var require_semver = __commonJS({
       }, this);
       return set;
     };
-    Range.prototype.intersects = function(range2, options) {
-      if (!(range2 instanceof Range)) {
+    Range.prototype.intersects = function(range, options) {
+      if (!(range instanceof Range)) {
         throw new TypeError("a Range is required");
       }
       return this.set.some(function(thisComparators) {
         return thisComparators.every(function(thisComparator) {
-          return range2.set.some(function(rangeComparators) {
+          return range.set.some(function(rangeComparators) {
             return rangeComparators.every(function(rangeComparator) {
               return thisComparator.intersects(rangeComparator, options);
             });
@@ -1111,8 +1084,8 @@ var require_semver = __commonJS({
       });
     };
     exports.toComparators = toComparators;
-    function toComparators(range2, options) {
-      return new Range(range2, options).set.map(function(comp) {
+    function toComparators(range, options) {
+      return new Range(range, options).set.map(function(comp) {
         return comp.map(function(c) {
           return c.value;
         }).join(" ").trim().split(" ");
@@ -1329,20 +1302,20 @@ var require_semver = __commonJS({
       return true;
     }
     exports.satisfies = satisfies;
-    function satisfies(version2, range2, options) {
+    function satisfies(version2, range, options) {
       try {
-        range2 = new Range(range2, options);
+        range = new Range(range, options);
       } catch (er) {
         return false;
       }
-      return range2.test(version2);
+      return range.test(version2);
     }
     exports.maxSatisfying = maxSatisfying;
-    function maxSatisfying(versions, range2, options) {
+    function maxSatisfying(versions, range, options) {
       var max = null;
       var maxSV = null;
       try {
-        var rangeObj = new Range(range2, options);
+        var rangeObj = new Range(range, options);
       } catch (er) {
         return null;
       }
@@ -1357,11 +1330,11 @@ var require_semver = __commonJS({
       return max;
     }
     exports.minSatisfying = minSatisfying;
-    function minSatisfying(versions, range2, options) {
+    function minSatisfying(versions, range, options) {
       var min = null;
       var minSV = null;
       try {
-        var rangeObj = new Range(range2, options);
+        var rangeObj = new Range(range, options);
       } catch (er) {
         return null;
       }
@@ -1376,19 +1349,19 @@ var require_semver = __commonJS({
       return min;
     }
     exports.minVersion = minVersion;
-    function minVersion(range2, loose) {
-      range2 = new Range(range2, loose);
+    function minVersion(range, loose) {
+      range = new Range(range, loose);
       var minver = new SemVer("0.0.0");
-      if (range2.test(minver)) {
+      if (range.test(minver)) {
         return minver;
       }
       minver = new SemVer("0.0.0-0");
-      if (range2.test(minver)) {
+      if (range.test(minver)) {
         return minver;
       }
       minver = null;
-      for (var i2 = 0; i2 < range2.set.length; ++i2) {
-        var comparators = range2.set[i2];
+      for (var i2 = 0; i2 < range.set.length; ++i2) {
+        var comparators = range.set[i2];
         comparators.forEach(function(comparator) {
           var compver = new SemVer(comparator.semver.version);
           switch (comparator.operator) {
@@ -1413,43 +1386,43 @@ var require_semver = __commonJS({
           }
         });
       }
-      if (minver && range2.test(minver)) {
+      if (minver && range.test(minver)) {
         return minver;
       }
       return null;
     }
     exports.validRange = validRange;
-    function validRange(range2, options) {
+    function validRange(range, options) {
       try {
-        return new Range(range2, options).range || "*";
+        return new Range(range, options).range || "*";
       } catch (er) {
         return null;
       }
     }
     exports.ltr = ltr;
-    function ltr(version2, range2, options) {
-      return outside(version2, range2, "<", options);
+    function ltr(version2, range, options) {
+      return outside(version2, range, "<", options);
     }
     exports.gtr = gtr;
-    function gtr(version2, range2, options) {
-      return outside(version2, range2, ">", options);
+    function gtr(version2, range, options) {
+      return outside(version2, range, ">", options);
     }
     exports.outside = outside;
-    function outside(version2, range2, hilo, options) {
+    function outside(version2, range, hilo, options) {
       version2 = new SemVer(version2, options);
-      range2 = new Range(range2, options);
+      range = new Range(range, options);
       var gtfn, ltefn, ltfn, comp, ecomp;
       switch (hilo) {
         case ">":
           gtfn = gt;
-          ltefn = lte2;
+          ltefn = lte;
           ltfn = lt;
           comp = ">";
           ecomp = ">=";
           break;
         case "<":
           gtfn = lt;
-          ltefn = gte2;
+          ltefn = gte;
           ltfn = gt;
           comp = "<";
           ecomp = "<=";
@@ -1457,11 +1430,11 @@ var require_semver = __commonJS({
         default:
           throw new TypeError('Must provide a hilo val of "<" or ">"');
       }
-      if (satisfies(version2, range2, options)) {
+      if (satisfies(version2, range, options)) {
         return false;
       }
-      for (var i2 = 0; i2 < range2.set.length; ++i2) {
-        var comparators = range2.set[i2];
+      for (var i2 = 0; i2 < range.set.length; ++i2) {
+        var comparators = range.set[i2];
         var high = null;
         var low = null;
         comparators.forEach(function(comparator) {
@@ -1506,11 +1479,11 @@ var require_semver = __commonJS({
       if (typeof version2 !== "string") {
         return null;
       }
-      var match2 = version2.match(safeRe[COERCE]);
-      if (match2 == null) {
+      var match = version2.match(safeRe[COERCE]);
+      if (match == null) {
         return null;
       }
-      return parse2(match2[1] + "." + (match2[2] || "0") + "." + (match2[3] || "0"));
+      return parse2(match[1] + "." + (match[2] || "0") + "." + (match[3] || "0"));
     }
   }
 });
@@ -1519,10 +1492,10 @@ var require_semver = __commonJS({
 var require_parse = __commonJS({
   "../../node_modules/.pnpm/cross-spawn@6.0.5/node_modules/cross-spawn/lib/parse.js"(exports, module2) {
     "use strict";
-    var path2 = require("path");
+    var path = require("path");
     var niceTry = require_src();
     var resolveCommand = require_resolveCommand();
-    var escape2 = require_escape();
+    var escape = require_escape();
     var readShebang = require_readShebang();
     var semver2 = require_semver();
     var isWin3 = process.platform === "win32";
@@ -1547,9 +1520,9 @@ var require_parse = __commonJS({
       const needsShell = !isExecutableRegExp.test(commandFile);
       if (parsed.options.forceShell || needsShell) {
         const needsDoubleEscapeMetaChars = isCmdShimRegExp.test(commandFile);
-        parsed.command = path2.normalize(parsed.command);
-        parsed.command = escape2.command(parsed.command);
-        parsed.args = parsed.args.map((arg) => escape2.argument(arg, needsDoubleEscapeMetaChars));
+        parsed.command = path.normalize(parsed.command);
+        parsed.command = escape.command(parsed.command);
+        parsed.args = parsed.args.map((arg) => escape.argument(arg, needsDoubleEscapeMetaChars));
         const shellCommand = [parsed.command].concat(parsed.args).join(" ");
         parsed.args = ["/d", "/s", "/c", `"${shellCommand}"`];
         parsed.command = process.env.comspec || "cmd.exe";
@@ -1700,7 +1673,7 @@ var require_strip_eof = __commonJS({
 var require_npm_run_path = __commonJS({
   "../../node_modules/.pnpm/npm-run-path@2.0.2/node_modules/npm-run-path/index.js"(exports, module2) {
     "use strict";
-    var path2 = require("path");
+    var path = require("path");
     var pathKey = require_path_key();
     module2.exports = (opts) => {
       opts = Object.assign({
@@ -1708,24 +1681,24 @@ var require_npm_run_path = __commonJS({
         path: process.env[pathKey()]
       }, opts);
       let prev;
-      let pth = path2.resolve(opts.cwd);
+      let pth = path.resolve(opts.cwd);
       const ret = [];
       while (prev !== pth) {
-        ret.push(path2.join(pth, "node_modules/.bin"));
+        ret.push(path.join(pth, "node_modules/.bin"));
         prev = pth;
-        pth = path2.resolve(pth, "..");
+        pth = path.resolve(pth, "..");
       }
-      ret.push(path2.dirname(process.execPath));
-      return ret.concat(opts.path).join(path2.delimiter);
+      ret.push(path.dirname(process.execPath));
+      return ret.concat(opts.path).join(path.delimiter);
     };
     module2.exports.env = (opts) => {
       opts = Object.assign({
         env: process.env
       }, opts);
       const env = Object.assign({}, opts.env);
-      const path3 = pathKey({ env });
-      opts.path = env[path3];
-      env[path3] = module2.exports(opts);
+      const path2 = pathKey({ env });
+      opts.path = env[path2];
+      env[path2] = module2.exports(opts);
       return env;
     };
   }
@@ -2387,7 +2360,7 @@ var require_stdio = __commonJS({
 var require_execa = __commonJS({
   "../../node_modules/.pnpm/execa@1.0.0/node_modules/execa/index.js"(exports, module2) {
     "use strict";
-    var path2 = require("path");
+    var path = require("path");
     var childProcess = require("child_process");
     var crossSpawn = require_cross_spawn();
     var stripEof = require_strip_eof();
@@ -2440,7 +2413,7 @@ var require_execa = __commonJS({
       if (opts.detached) {
         opts.cleanup = false;
       }
-      if (process.platform === "win32" && path2.basename(parsed.command) === "cmd.exe") {
+      if (process.platform === "win32" && path.basename(parsed.command) === "cmd.exe") {
         parsed.args.unshift("/q");
       }
       return {
@@ -2991,7 +2964,7 @@ var require_specifier = __commonJS({
       RANGE_PATTERN,
       parse: parse2,
       satisfies,
-      filter: filter2,
+      filter,
       validRange,
       maxSatisfying,
       minSatisfying
@@ -3002,7 +2975,7 @@ var require_specifier = __commonJS({
       if (!ranges.trim()) {
         return [];
       }
-      const specifiers = ranges.split(",").map((range2) => rangeRegex.exec(range2.trim()) || {}).map(({ groups }) => {
+      const specifiers = ranges.split(",").map((range) => rangeRegex.exec(range.trim()) || {}).map(({ groups }) => {
         if (!groups) {
           return null;
         }
@@ -3034,19 +3007,19 @@ var require_specifier = __commonJS({
       }
       return specifiers;
     }
-    function filter2(versions, specifier, options = {}) {
+    function filter(versions, specifier, options = {}) {
       const filtered = pick(versions, specifier, options);
       if (filtered.length === 0 && options.prereleases === void 0) {
         return pick(versions, specifier, { prereleases: true });
       }
       return filtered;
     }
-    function maxSatisfying(versions, range2, options) {
-      const found = filter2(versions, range2, options).sort(Operator.compare);
+    function maxSatisfying(versions, range, options) {
+      const found = filter(versions, range, options).sort(Operator.compare);
       return found.length === 0 ? null : found[found.length - 1];
     }
-    function minSatisfying(versions, range2, options) {
-      const found = filter2(versions, range2, options).sort(Operator.compare);
+    function minSatisfying(versions, range, options) {
+      const found = filter(versions, range, options).sort(Operator.compare);
       return found.length === 0 ? null : found[0];
     }
     function pick(versions, specifier, options) {
@@ -3282,7 +3255,7 @@ var require_pep440 = __commonJS({
     var { valid: valid2, clean, explain, parse: parse2 } = require_version();
     var { lt, le, eq, ne, ge: ge2, gt, compare, rcompare } = require_operator();
     var {
-      filter: filter2,
+      filter,
       maxSatisfying,
       minSatisfying,
       RANGE_PATTERN,
@@ -3309,7 +3282,7 @@ var require_pep440 = __commonJS({
       compare,
       rcompare,
       // range
-      filter: filter2,
+      filter,
       maxSatisfying,
       minSatisfying,
       RANGE_PATTERN,
@@ -3328,9 +3301,9 @@ var require_pep440 = __commonJS({
 var require_lib = __commonJS({
   "../../node_modules/.pnpm/which@3.0.0/node_modules/which/lib/index.js"(exports, module2) {
     var isexe = require_isexe();
-    var { join: join21, delimiter: delimiter2, sep: sep6, posix: posix4 } = require("path");
+    var { join: join21, delimiter: delimiter2, sep: sep5, posix: posix4 } = require("path");
     var isWindows = process.platform === "win32";
-    var rSlash = new RegExp(`[${posix4.sep}${sep6 === posix4.sep ? "" : sep6}]`.replace(/(\\)/g, "\\$1"));
+    var rSlash = new RegExp(`[${posix4.sep}${sep5 === posix4.sep ? "" : sep5}]`.replace(/(\\)/g, "\\$1"));
     var rRel = new RegExp(`^\\.${rSlash.source}`);
     var getNotFoundError = (cmd) => Object.assign(new Error(`not found: ${cmd}`), { code: "ENOENT" });
     var getPathInfo = (cmd, {
@@ -3364,8 +3337,8 @@ var require_lib = __commonJS({
       const found = [];
       for (const envPart of pathEnv) {
         const p = getPathPart(envPart, cmd);
-        for (const ext2 of pathExt) {
-          const withExt = p + ext2;
+        for (const ext of pathExt) {
+          const withExt = p + ext;
           const is = await isexe(withExt, { pathExt: pathExtExe, ignoreErrors: true });
           if (is) {
             if (!opt.all) {
@@ -3388,8 +3361,8 @@ var require_lib = __commonJS({
       const found = [];
       for (const pathEnvPart of pathEnv) {
         const p = getPathPart(pathEnvPart, cmd);
-        for (const ext2 of pathExt) {
-          const withExt = p + ext2;
+        for (const ext of pathExt) {
+          const withExt = p + ext;
           const is = isexe.sync(withExt, { pathExt: pathExtExe, ignoreErrors: true });
           if (is) {
             if (!opt.all) {
@@ -3833,10 +3806,10 @@ var require_semver2 = __commonJS({
       }
     }
     exports.compareIdentifiers = compareIdentifiers;
-    var numeric2 = /^[0-9]+$/;
+    var numeric = /^[0-9]+$/;
     function compareIdentifiers(a, b) {
-      var anum = numeric2.test(a);
-      var bnum = numeric2.test(b);
+      var anum = numeric.test(a);
+      var bnum = numeric.test(b);
       if (anum && bnum) {
         a = +a;
         b = +b;
@@ -3905,12 +3878,12 @@ var require_semver2 = __commonJS({
     function neq(a, b, loose) {
       return compare(a, b, loose) !== 0;
     }
-    exports.gte = gte2;
-    function gte2(a, b, loose) {
+    exports.gte = gte;
+    function gte(a, b, loose) {
       return compare(a, b, loose) >= 0;
     }
-    exports.lte = lte2;
-    function lte2(a, b, loose) {
+    exports.lte = lte;
+    function lte(a, b, loose) {
       return compare(a, b, loose) <= 0;
     }
     exports.cmp = cmp;
@@ -3937,11 +3910,11 @@ var require_semver2 = __commonJS({
         case ">":
           return gt(a, b, loose);
         case ">=":
-          return gte2(a, b, loose);
+          return gte(a, b, loose);
         case "<":
           return lt(a, b, loose);
         case "<=":
-          return lte2(a, b, loose);
+          return lte(a, b, loose);
         default:
           throw new TypeError("Invalid operator: " + op);
       }
@@ -4043,32 +4016,32 @@ var require_semver2 = __commonJS({
       return sameDirectionIncreasing || sameDirectionDecreasing || sameSemVer && differentDirectionsInclusive || oppositeDirectionsLessThan || oppositeDirectionsGreaterThan;
     };
     exports.Range = Range;
-    function Range(range2, options) {
+    function Range(range, options) {
       if (!options || typeof options !== "object") {
         options = {
           loose: !!options,
           includePrerelease: false
         };
       }
-      if (range2 instanceof Range) {
-        if (range2.loose === !!options.loose && range2.includePrerelease === !!options.includePrerelease) {
-          return range2;
+      if (range instanceof Range) {
+        if (range.loose === !!options.loose && range.includePrerelease === !!options.includePrerelease) {
+          return range;
         } else {
-          return new Range(range2.raw, options);
+          return new Range(range.raw, options);
         }
       }
-      if (range2 instanceof Comparator) {
-        return new Range(range2.value, options);
+      if (range instanceof Comparator) {
+        return new Range(range.value, options);
       }
       if (!(this instanceof Range)) {
-        return new Range(range2, options);
+        return new Range(range, options);
       }
       this.options = options;
       this.loose = !!options.loose;
       this.includePrerelease = !!options.includePrerelease;
-      this.raw = range2.trim().split(/\s+/).join(" ");
-      this.set = this.raw.split("||").map(function(range3) {
-        return this.parseRange(range3.trim());
+      this.raw = range.trim().split(/\s+/).join(" ");
+      this.set = this.raw.split("||").map(function(range2) {
+        return this.parseRange(range2.trim());
       }, this).filter(function(c) {
         return c.length;
       });
@@ -4086,18 +4059,18 @@ var require_semver2 = __commonJS({
     Range.prototype.toString = function() {
       return this.range;
     };
-    Range.prototype.parseRange = function(range2) {
+    Range.prototype.parseRange = function(range) {
       var loose = this.options.loose;
       var hr = loose ? safeRe[t.HYPHENRANGELOOSE] : safeRe[t.HYPHENRANGE];
-      range2 = range2.replace(hr, hyphenReplace);
-      debug18("hyphen replace", range2);
-      range2 = range2.replace(safeRe[t.COMPARATORTRIM], comparatorTrimReplace);
-      debug18("comparator trim", range2, safeRe[t.COMPARATORTRIM]);
-      range2 = range2.replace(safeRe[t.TILDETRIM], tildeTrimReplace);
-      range2 = range2.replace(safeRe[t.CARETTRIM], caretTrimReplace);
-      range2 = range2.split(/\s+/).join(" ");
+      range = range.replace(hr, hyphenReplace);
+      debug18("hyphen replace", range);
+      range = range.replace(safeRe[t.COMPARATORTRIM], comparatorTrimReplace);
+      debug18("comparator trim", range, safeRe[t.COMPARATORTRIM]);
+      range = range.replace(safeRe[t.TILDETRIM], tildeTrimReplace);
+      range = range.replace(safeRe[t.CARETTRIM], caretTrimReplace);
+      range = range.split(/\s+/).join(" ");
       var compRe = loose ? safeRe[t.COMPARATORLOOSE] : safeRe[t.COMPARATOR];
-      var set = range2.split(" ").map(function(comp) {
+      var set = range.split(" ").map(function(comp) {
         return parseComparator(comp, this.options);
       }, this).join(" ").split(/\s+/);
       if (this.options.loose) {
@@ -4110,12 +4083,12 @@ var require_semver2 = __commonJS({
       }, this);
       return set;
     };
-    Range.prototype.intersects = function(range2, options) {
-      if (!(range2 instanceof Range)) {
+    Range.prototype.intersects = function(range, options) {
+      if (!(range instanceof Range)) {
         throw new TypeError("a Range is required");
       }
       return this.set.some(function(thisComparators) {
-        return isSatisfiable(thisComparators, options) && range2.set.some(function(rangeComparators) {
+        return isSatisfiable(thisComparators, options) && range.set.some(function(rangeComparators) {
           return isSatisfiable(rangeComparators, options) && thisComparators.every(function(thisComparator) {
             return rangeComparators.every(function(rangeComparator) {
               return thisComparator.intersects(rangeComparator, options);
@@ -4137,8 +4110,8 @@ var require_semver2 = __commonJS({
       return result;
     }
     exports.toComparators = toComparators;
-    function toComparators(range2, options) {
-      return new Range(range2, options).set.map(function(comp) {
+    function toComparators(range, options) {
+      return new Range(range, options).set.map(function(comp) {
         return comp.map(function(c) {
           return c.value;
         }).join(" ").trim().split(" ");
@@ -4360,20 +4333,20 @@ var require_semver2 = __commonJS({
       return true;
     }
     exports.satisfies = satisfies;
-    function satisfies(version2, range2, options) {
+    function satisfies(version2, range, options) {
       try {
-        range2 = new Range(range2, options);
+        range = new Range(range, options);
       } catch (er) {
         return false;
       }
-      return range2.test(version2);
+      return range.test(version2);
     }
     exports.maxSatisfying = maxSatisfying;
-    function maxSatisfying(versions, range2, options) {
+    function maxSatisfying(versions, range, options) {
       var max = null;
       var maxSV = null;
       try {
-        var rangeObj = new Range(range2, options);
+        var rangeObj = new Range(range, options);
       } catch (er) {
         return null;
       }
@@ -4388,11 +4361,11 @@ var require_semver2 = __commonJS({
       return max;
     }
     exports.minSatisfying = minSatisfying;
-    function minSatisfying(versions, range2, options) {
+    function minSatisfying(versions, range, options) {
       var min = null;
       var minSV = null;
       try {
-        var rangeObj = new Range(range2, options);
+        var rangeObj = new Range(range, options);
       } catch (er) {
         return null;
       }
@@ -4407,19 +4380,19 @@ var require_semver2 = __commonJS({
       return min;
     }
     exports.minVersion = minVersion;
-    function minVersion(range2, loose) {
-      range2 = new Range(range2, loose);
+    function minVersion(range, loose) {
+      range = new Range(range, loose);
       var minver = new SemVer("0.0.0");
-      if (range2.test(minver)) {
+      if (range.test(minver)) {
         return minver;
       }
       minver = new SemVer("0.0.0-0");
-      if (range2.test(minver)) {
+      if (range.test(minver)) {
         return minver;
       }
       minver = null;
-      for (var i2 = 0; i2 < range2.set.length; ++i2) {
-        var comparators = range2.set[i2];
+      for (var i2 = 0; i2 < range.set.length; ++i2) {
+        var comparators = range.set[i2];
         comparators.forEach(function(comparator) {
           var compver = new SemVer(comparator.semver.version);
           switch (comparator.operator) {
@@ -4444,43 +4417,43 @@ var require_semver2 = __commonJS({
           }
         });
       }
-      if (minver && range2.test(minver)) {
+      if (minver && range.test(minver)) {
         return minver;
       }
       return null;
     }
     exports.validRange = validRange;
-    function validRange(range2, options) {
+    function validRange(range, options) {
       try {
-        return new Range(range2, options).range || "*";
+        return new Range(range, options).range || "*";
       } catch (er) {
         return null;
       }
     }
     exports.ltr = ltr;
-    function ltr(version2, range2, options) {
-      return outside(version2, range2, "<", options);
+    function ltr(version2, range, options) {
+      return outside(version2, range, "<", options);
     }
     exports.gtr = gtr;
-    function gtr(version2, range2, options) {
-      return outside(version2, range2, ">", options);
+    function gtr(version2, range, options) {
+      return outside(version2, range, ">", options);
     }
     exports.outside = outside;
-    function outside(version2, range2, hilo, options) {
+    function outside(version2, range, hilo, options) {
       version2 = new SemVer(version2, options);
-      range2 = new Range(range2, options);
+      range = new Range(range, options);
       var gtfn, ltefn, ltfn, comp, ecomp;
       switch (hilo) {
         case ">":
           gtfn = gt;
-          ltefn = lte2;
+          ltefn = lte;
           ltfn = lt;
           comp = ">";
           ecomp = ">=";
           break;
         case "<":
           gtfn = lt;
-          ltefn = gte2;
+          ltefn = gte;
           ltfn = gt;
           comp = "<";
           ecomp = "<=";
@@ -4488,11 +4461,11 @@ var require_semver2 = __commonJS({
         default:
           throw new TypeError('Must provide a hilo val of "<" or ">"');
       }
-      if (satisfies(version2, range2, options)) {
+      if (satisfies(version2, range, options)) {
         return false;
       }
-      for (var i2 = 0; i2 < range2.set.length; ++i2) {
-        var comparators = range2.set[i2];
+      for (var i2 = 0; i2 < range.set.length; ++i2) {
+        var comparators = range.set[i2];
         var high = null;
         var low = null;
         comparators.forEach(function(comparator) {
@@ -4541,23 +4514,23 @@ var require_semver2 = __commonJS({
         return null;
       }
       options = options || {};
-      var match2 = null;
+      var match = null;
       if (!options.rtl) {
-        match2 = version2.match(safeRe[t.COERCE]);
+        match = version2.match(safeRe[t.COERCE]);
       } else {
         var next;
-        while ((next = safeRe[t.COERCERTL].exec(version2)) && (!match2 || match2.index + match2[0].length !== version2.length)) {
-          if (!match2 || next.index + next[0].length !== match2.index + match2[0].length) {
-            match2 = next;
+        while ((next = safeRe[t.COERCERTL].exec(version2)) && (!match || match.index + match[0].length !== version2.length)) {
+          if (!match || next.index + next[0].length !== match.index + match[0].length) {
+            match = next;
           }
           safeRe[t.COERCERTL].lastIndex = next.index + next[1].length + next[2].length;
         }
         safeRe[t.COERCERTL].lastIndex = -1;
       }
-      if (match2 === null) {
+      if (match === null) {
         return null;
       }
-      return parse2(match2[2] + "." + (match2[3] || "0") + "." + (match2[4] || "0"), options);
+      return parse2(match[2] + "." + (match[3] || "0") + "." + (match[4] || "0"), options);
     }
   }
 });
@@ -4593,16 +4566,16 @@ var require_filesystem = __commonJS({
     var LDD_PATH = "/usr/bin/ldd";
     var SELF_PATH = "/proc/self/exe";
     var MAX_LENGTH = 2048;
-    var readFileSync2 = (path2) => {
-      const fd = fs19.openSync(path2, "r");
+    var readFileSync2 = (path) => {
+      const fd = fs19.openSync(path, "r");
       const buffer = Buffer.alloc(MAX_LENGTH);
       const bytesRead = fs19.readSync(fd, buffer, 0, MAX_LENGTH, 0);
       fs19.close(fd, () => {
       });
       return buffer.subarray(0, bytesRead);
     };
-    var readFile2 = (path2) => new Promise((resolve4, reject) => {
-      fs19.open(path2, "r", (err, fd) => {
+    var readFile2 = (path) => new Promise((resolve4, reject) => {
+      fs19.open(path, "r", (err, fd) => {
         if (err) {
           reject(err);
         } else {
@@ -4721,11 +4694,11 @@ var require_detect_libc = __commonJS({
       }
       return null;
     };
-    var familyFromInterpreterPath = (path2) => {
-      if (path2) {
-        if (path2.includes("/ld-musl-")) {
+    var familyFromInterpreterPath = (path) => {
+      if (path) {
+        if (path.includes("/ld-musl-")) {
           return MUSL2;
-        } else if (path2.includes("/ld-linux-")) {
+        } else if (path.includes("/ld-linux-")) {
           return GLIBC;
         }
       }
@@ -4772,8 +4745,8 @@ var require_detect_libc = __commonJS({
       cachedFamilyInterpreter = null;
       try {
         const selfContent = await readFile2(SELF_PATH);
-        const path2 = interpreterPath(selfContent);
-        cachedFamilyInterpreter = familyFromInterpreterPath(path2);
+        const path = interpreterPath(selfContent);
+        cachedFamilyInterpreter = familyFromInterpreterPath(path);
       } catch (e) {
       }
       return cachedFamilyInterpreter;
@@ -4785,8 +4758,8 @@ var require_detect_libc = __commonJS({
       cachedFamilyInterpreter = null;
       try {
         const selfContent = readFileSync2(SELF_PATH);
-        const path2 = interpreterPath(selfContent);
-        cachedFamilyInterpreter = familyFromInterpreterPath(path2);
+        const path = interpreterPath(selfContent);
+        cachedFamilyInterpreter = familyFromInterpreterPath(path);
       } catch (e) {
       }
       return cachedFamilyInterpreter;
@@ -5056,1591 +5029,10 @@ __export(src_exports, {
 module.exports = __toCommonJS(src_exports);
 var import_assert = __toESM(require("assert"));
 var import_fs20 = __toESM(require("fs"));
-
-// ../../node_modules/.pnpm/@isaacs+balanced-match@4.0.1/node_modules/@isaacs/balanced-match/dist/esm/index.js
-var balanced = (a, b, str) => {
-  const ma = a instanceof RegExp ? maybeMatch(a, str) : a;
-  const mb = b instanceof RegExp ? maybeMatch(b, str) : b;
-  const r = ma !== null && mb != null && range(ma, mb, str);
-  return r && {
-    start: r[0],
-    end: r[1],
-    pre: str.slice(0, r[0]),
-    body: str.slice(r[0] + ma.length, r[1]),
-    post: str.slice(r[1] + mb.length)
-  };
-};
-var maybeMatch = (reg, str) => {
-  const m = str.match(reg);
-  return m ? m[0] : null;
-};
-var range = (a, b, str) => {
-  let begs, beg, left, right = void 0, result;
-  let ai = str.indexOf(a);
-  let bi = str.indexOf(b, ai + 1);
-  let i = ai;
-  if (ai >= 0 && bi > 0) {
-    if (a === b) {
-      return [ai, bi];
-    }
-    begs = [];
-    left = str.length;
-    while (i >= 0 && !result) {
-      if (i === ai) {
-        begs.push(i);
-        ai = str.indexOf(a, i + 1);
-      } else if (begs.length === 1) {
-        const r = begs.pop();
-        if (r !== void 0)
-          result = [r, bi];
-      } else {
-        beg = begs.pop();
-        if (beg !== void 0 && beg < left) {
-          left = beg;
-          right = bi;
-        }
-        bi = str.indexOf(b, i + 1);
-      }
-      i = ai < bi && ai >= 0 ? ai : bi;
-    }
-    if (begs.length && right !== void 0) {
-      result = [left, right];
-    }
-  }
-  return result;
-};
-
-// ../../node_modules/.pnpm/@isaacs+brace-expansion@5.0.1/node_modules/@isaacs/brace-expansion/dist/esm/index.js
-var escSlash = "\0SLASH" + Math.random() + "\0";
-var escOpen = "\0OPEN" + Math.random() + "\0";
-var escClose = "\0CLOSE" + Math.random() + "\0";
-var escComma = "\0COMMA" + Math.random() + "\0";
-var escPeriod = "\0PERIOD" + Math.random() + "\0";
-var escSlashPattern = new RegExp(escSlash, "g");
-var escOpenPattern = new RegExp(escOpen, "g");
-var escClosePattern = new RegExp(escClose, "g");
-var escCommaPattern = new RegExp(escComma, "g");
-var escPeriodPattern = new RegExp(escPeriod, "g");
-var slashPattern = /\\\\/g;
-var openPattern = /\\{/g;
-var closePattern = /\\}/g;
-var commaPattern = /\\,/g;
-var periodPattern = /\\./g;
-var EXPANSION_MAX = 1e5;
-function numeric(str) {
-  return !isNaN(str) ? parseInt(str, 10) : str.charCodeAt(0);
-}
-function escapeBraces(str) {
-  return str.replace(slashPattern, escSlash).replace(openPattern, escOpen).replace(closePattern, escClose).replace(commaPattern, escComma).replace(periodPattern, escPeriod);
-}
-function unescapeBraces(str) {
-  return str.replace(escSlashPattern, "\\").replace(escOpenPattern, "{").replace(escClosePattern, "}").replace(escCommaPattern, ",").replace(escPeriodPattern, ".");
-}
-function parseCommaParts(str) {
-  if (!str) {
-    return [""];
-  }
-  const parts = [];
-  const m = balanced("{", "}", str);
-  if (!m) {
-    return str.split(",");
-  }
-  const { pre, body, post } = m;
-  const p = pre.split(",");
-  p[p.length - 1] += "{" + body + "}";
-  const postParts = parseCommaParts(post);
-  if (post.length) {
-    ;
-    p[p.length - 1] += postParts.shift();
-    p.push.apply(p, postParts);
-  }
-  parts.push.apply(parts, p);
-  return parts;
-}
-function expand(str, options = {}) {
-  if (!str) {
-    return [];
-  }
-  const { max = EXPANSION_MAX } = options;
-  if (str.slice(0, 2) === "{}") {
-    str = "\\{\\}" + str.slice(2);
-  }
-  return expand_(escapeBraces(str), max, true).map(unescapeBraces);
-}
-function embrace(str) {
-  return "{" + str + "}";
-}
-function isPadded(el) {
-  return /^-?0\d/.test(el);
-}
-function lte(i, y) {
-  return i <= y;
-}
-function gte(i, y) {
-  return i >= y;
-}
-function expand_(str, max, isTop) {
-  const expansions = [];
-  const m = balanced("{", "}", str);
-  if (!m)
-    return [str];
-  const pre = m.pre;
-  const post = m.post.length ? expand_(m.post, max, false) : [""];
-  if (/\$$/.test(m.pre)) {
-    for (let k = 0; k < post.length && k < max; k++) {
-      const expansion = pre + "{" + m.body + "}" + post[k];
-      expansions.push(expansion);
-    }
-  } else {
-    const isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
-    const isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
-    const isSequence = isNumericSequence || isAlphaSequence;
-    const isOptions = m.body.indexOf(",") >= 0;
-    if (!isSequence && !isOptions) {
-      if (m.post.match(/,(?!,).*\}/)) {
-        str = m.pre + "{" + m.body + escClose + m.post;
-        return expand_(str, max, true);
-      }
-      return [str];
-    }
-    let n;
-    if (isSequence) {
-      n = m.body.split(/\.\./);
-    } else {
-      n = parseCommaParts(m.body);
-      if (n.length === 1 && n[0] !== void 0) {
-        n = expand_(n[0], max, false).map(embrace);
-        if (n.length === 1) {
-          return post.map((p) => m.pre + n[0] + p);
-        }
-      }
-    }
-    let N;
-    if (isSequence && n[0] !== void 0 && n[1] !== void 0) {
-      const x = numeric(n[0]);
-      const y = numeric(n[1]);
-      const width = Math.max(n[0].length, n[1].length);
-      let incr = n.length === 3 && n[2] !== void 0 ? Math.abs(numeric(n[2])) : 1;
-      let test = lte;
-      const reverse = y < x;
-      if (reverse) {
-        incr *= -1;
-        test = gte;
-      }
-      const pad = n.some(isPadded);
-      N = [];
-      for (let i = x; test(i, y); i += incr) {
-        let c;
-        if (isAlphaSequence) {
-          c = String.fromCharCode(i);
-          if (c === "\\") {
-            c = "";
-          }
-        } else {
-          c = String(i);
-          if (pad) {
-            const need = width - c.length;
-            if (need > 0) {
-              const z = new Array(need + 1).join("0");
-              if (i < 0) {
-                c = "-" + z + c.slice(1);
-              } else {
-                c = z + c;
-              }
-            }
-          }
-        }
-        N.push(c);
-      }
-    } else {
-      N = [];
-      for (let j = 0; j < n.length; j++) {
-        N.push.apply(N, expand_(n[j], max, false));
-      }
-    }
-    for (let j = 0; j < N.length; j++) {
-      for (let k = 0; k < post.length && expansions.length < max; k++) {
-        const expansion = pre + N[j] + post[k];
-        if (!isTop || isSequence || expansion) {
-          expansions.push(expansion);
-        }
-      }
-    }
-  }
-  return expansions;
-}
-
-// ../../node_modules/.pnpm/minimatch@10.1.1/node_modules/minimatch/dist/esm/assert-valid-pattern.js
-var MAX_PATTERN_LENGTH = 1024 * 64;
-var assertValidPattern = (pattern) => {
-  if (typeof pattern !== "string") {
-    throw new TypeError("invalid pattern");
-  }
-  if (pattern.length > MAX_PATTERN_LENGTH) {
-    throw new TypeError("pattern is too long");
-  }
-};
-
-// ../../node_modules/.pnpm/minimatch@10.1.1/node_modules/minimatch/dist/esm/brace-expressions.js
-var posixClasses = {
-  "[:alnum:]": ["\\p{L}\\p{Nl}\\p{Nd}", true],
-  "[:alpha:]": ["\\p{L}\\p{Nl}", true],
-  "[:ascii:]": ["\\x00-\\x7f", false],
-  "[:blank:]": ["\\p{Zs}\\t", true],
-  "[:cntrl:]": ["\\p{Cc}", true],
-  "[:digit:]": ["\\p{Nd}", true],
-  "[:graph:]": ["\\p{Z}\\p{C}", true, true],
-  "[:lower:]": ["\\p{Ll}", true],
-  "[:print:]": ["\\p{C}", true],
-  "[:punct:]": ["\\p{P}", true],
-  "[:space:]": ["\\p{Z}\\t\\r\\n\\v\\f", true],
-  "[:upper:]": ["\\p{Lu}", true],
-  "[:word:]": ["\\p{L}\\p{Nl}\\p{Nd}\\p{Pc}", true],
-  "[:xdigit:]": ["A-Fa-f0-9", false]
-};
-var braceEscape = (s) => s.replace(/[[\]\\-]/g, "\\$&");
-var regexpEscape = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
-var rangesToString = (ranges) => ranges.join("");
-var parseClass = (glob2, position) => {
-  const pos = position;
-  if (glob2.charAt(pos) !== "[") {
-    throw new Error("not in a brace expression");
-  }
-  const ranges = [];
-  const negs = [];
-  let i = pos + 1;
-  let sawStart = false;
-  let uflag = false;
-  let escaping = false;
-  let negate = false;
-  let endPos = pos;
-  let rangeStart = "";
-  WHILE:
-    while (i < glob2.length) {
-      const c = glob2.charAt(i);
-      if ((c === "!" || c === "^") && i === pos + 1) {
-        negate = true;
-        i++;
-        continue;
-      }
-      if (c === "]" && sawStart && !escaping) {
-        endPos = i + 1;
-        break;
-      }
-      sawStart = true;
-      if (c === "\\") {
-        if (!escaping) {
-          escaping = true;
-          i++;
-          continue;
-        }
-      }
-      if (c === "[" && !escaping) {
-        for (const [cls, [unip, u, neg]] of Object.entries(posixClasses)) {
-          if (glob2.startsWith(cls, i)) {
-            if (rangeStart) {
-              return ["$.", false, glob2.length - pos, true];
-            }
-            i += cls.length;
-            if (neg)
-              negs.push(unip);
-            else
-              ranges.push(unip);
-            uflag = uflag || u;
-            continue WHILE;
-          }
-        }
-      }
-      escaping = false;
-      if (rangeStart) {
-        if (c > rangeStart) {
-          ranges.push(braceEscape(rangeStart) + "-" + braceEscape(c));
-        } else if (c === rangeStart) {
-          ranges.push(braceEscape(c));
-        }
-        rangeStart = "";
-        i++;
-        continue;
-      }
-      if (glob2.startsWith("-]", i + 1)) {
-        ranges.push(braceEscape(c + "-"));
-        i += 2;
-        continue;
-      }
-      if (glob2.startsWith("-", i + 1)) {
-        rangeStart = c;
-        i += 2;
-        continue;
-      }
-      ranges.push(braceEscape(c));
-      i++;
-    }
-  if (endPos < i) {
-    return ["", false, 0, false];
-  }
-  if (!ranges.length && !negs.length) {
-    return ["$.", false, glob2.length - pos, true];
-  }
-  if (negs.length === 0 && ranges.length === 1 && /^\\?.$/.test(ranges[0]) && !negate) {
-    const r = ranges[0].length === 2 ? ranges[0].slice(-1) : ranges[0];
-    return [regexpEscape(r), false, endPos - pos, false];
-  }
-  const sranges = "[" + (negate ? "^" : "") + rangesToString(ranges) + "]";
-  const snegs = "[" + (negate ? "" : "^") + rangesToString(negs) + "]";
-  const comb = ranges.length && negs.length ? "(" + sranges + "|" + snegs + ")" : ranges.length ? sranges : snegs;
-  return [comb, uflag, endPos - pos, true];
-};
-
-// ../../node_modules/.pnpm/minimatch@10.1.1/node_modules/minimatch/dist/esm/unescape.js
-var unescape = (s, { windowsPathsNoEscape = false, magicalBraces = true } = {}) => {
-  if (magicalBraces) {
-    return windowsPathsNoEscape ? s.replace(/\[([^\/\\])\]/g, "$1") : s.replace(/((?!\\).|^)\[([^\/\\])\]/g, "$1$2").replace(/\\([^\/])/g, "$1");
-  }
-  return windowsPathsNoEscape ? s.replace(/\[([^\/\\{}])\]/g, "$1") : s.replace(/((?!\\).|^)\[([^\/\\{}])\]/g, "$1$2").replace(/\\([^\/{}])/g, "$1");
-};
-
-// ../../node_modules/.pnpm/minimatch@10.1.1/node_modules/minimatch/dist/esm/ast.js
-var types = /* @__PURE__ */ new Set(["!", "?", "+", "*", "@"]);
-var isExtglobType = (c) => types.has(c);
-var startNoTraversal = "(?!(?:^|/)\\.\\.?(?:$|/))";
-var startNoDot = "(?!\\.)";
-var addPatternStart = /* @__PURE__ */ new Set(["[", "."]);
-var justDots = /* @__PURE__ */ new Set(["..", "."]);
-var reSpecials = new Set("().*{}+?[]^$\\!");
-var regExpEscape = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
-var qmark = "[^/]";
-var star = qmark + "*?";
-var starNoEmpty = qmark + "+?";
-var _root, _hasMagic, _uflag, _parts, _parent, _parentIndex, _negs, _filledNegs, _options, _toString, _emptyExt, _fillNegs, fillNegs_fn, _parseAST, parseAST_fn, _partsToRegExp, partsToRegExp_fn, _parseGlob, parseGlob_fn;
-var _AST = class _AST {
-  constructor(type, parent, options = {}) {
-    __privateAdd(this, _fillNegs);
-    __privateAdd(this, _partsToRegExp);
-    __publicField(this, "type");
-    __privateAdd(this, _root, void 0);
-    __privateAdd(this, _hasMagic, void 0);
-    __privateAdd(this, _uflag, false);
-    __privateAdd(this, _parts, []);
-    __privateAdd(this, _parent, void 0);
-    __privateAdd(this, _parentIndex, void 0);
-    __privateAdd(this, _negs, void 0);
-    __privateAdd(this, _filledNegs, false);
-    __privateAdd(this, _options, void 0);
-    __privateAdd(this, _toString, void 0);
-    // set to true if it's an extglob with no children
-    // (which really means one child of '')
-    __privateAdd(this, _emptyExt, false);
-    this.type = type;
-    if (type)
-      __privateSet(this, _hasMagic, true);
-    __privateSet(this, _parent, parent);
-    __privateSet(this, _root, __privateGet(this, _parent) ? __privateGet(__privateGet(this, _parent), _root) : this);
-    __privateSet(this, _options, __privateGet(this, _root) === this ? options : __privateGet(__privateGet(this, _root), _options));
-    __privateSet(this, _negs, __privateGet(this, _root) === this ? [] : __privateGet(__privateGet(this, _root), _negs));
-    if (type === "!" && !__privateGet(__privateGet(this, _root), _filledNegs))
-      __privateGet(this, _negs).push(this);
-    __privateSet(this, _parentIndex, __privateGet(this, _parent) ? __privateGet(__privateGet(this, _parent), _parts).length : 0);
-  }
-  get hasMagic() {
-    if (__privateGet(this, _hasMagic) !== void 0)
-      return __privateGet(this, _hasMagic);
-    for (const p of __privateGet(this, _parts)) {
-      if (typeof p === "string")
-        continue;
-      if (p.type || p.hasMagic)
-        return __privateSet(this, _hasMagic, true);
-    }
-    return __privateGet(this, _hasMagic);
-  }
-  // reconstructs the pattern
-  toString() {
-    if (__privateGet(this, _toString) !== void 0)
-      return __privateGet(this, _toString);
-    if (!this.type) {
-      return __privateSet(this, _toString, __privateGet(this, _parts).map((p) => String(p)).join(""));
-    } else {
-      return __privateSet(this, _toString, this.type + "(" + __privateGet(this, _parts).map((p) => String(p)).join("|") + ")");
-    }
-  }
-  push(...parts) {
-    for (const p of parts) {
-      if (p === "")
-        continue;
-      if (typeof p !== "string" && !(p instanceof _AST && __privateGet(p, _parent) === this)) {
-        throw new Error("invalid part: " + p);
-      }
-      __privateGet(this, _parts).push(p);
-    }
-  }
-  toJSON() {
-    const ret = this.type === null ? __privateGet(this, _parts).slice().map((p) => typeof p === "string" ? p : p.toJSON()) : [this.type, ...__privateGet(this, _parts).map((p) => p.toJSON())];
-    if (this.isStart() && !this.type)
-      ret.unshift([]);
-    if (this.isEnd() && (this === __privateGet(this, _root) || __privateGet(__privateGet(this, _root), _filledNegs) && __privateGet(this, _parent)?.type === "!")) {
-      ret.push({});
-    }
-    return ret;
-  }
-  isStart() {
-    if (__privateGet(this, _root) === this)
-      return true;
-    if (!__privateGet(this, _parent)?.isStart())
-      return false;
-    if (__privateGet(this, _parentIndex) === 0)
-      return true;
-    const p = __privateGet(this, _parent);
-    for (let i = 0; i < __privateGet(this, _parentIndex); i++) {
-      const pp = __privateGet(p, _parts)[i];
-      if (!(pp instanceof _AST && pp.type === "!")) {
-        return false;
-      }
-    }
-    return true;
-  }
-  isEnd() {
-    if (__privateGet(this, _root) === this)
-      return true;
-    if (__privateGet(this, _parent)?.type === "!")
-      return true;
-    if (!__privateGet(this, _parent)?.isEnd())
-      return false;
-    if (!this.type)
-      return __privateGet(this, _parent)?.isEnd();
-    const pl = __privateGet(this, _parent) ? __privateGet(__privateGet(this, _parent), _parts).length : 0;
-    return __privateGet(this, _parentIndex) === pl - 1;
-  }
-  copyIn(part) {
-    if (typeof part === "string")
-      this.push(part);
-    else
-      this.push(part.clone(this));
-  }
-  clone(parent) {
-    const c = new _AST(this.type, parent);
-    for (const p of __privateGet(this, _parts)) {
-      c.copyIn(p);
-    }
-    return c;
-  }
-  static fromGlob(pattern, options = {}) {
-    var _a;
-    const ast = new _AST(null, void 0, options);
-    __privateMethod(_a = _AST, _parseAST, parseAST_fn).call(_a, pattern, ast, 0, options);
-    return ast;
-  }
-  // returns the regular expression if there's magic, or the unescaped
-  // string if not.
-  toMMPattern() {
-    if (this !== __privateGet(this, _root))
-      return __privateGet(this, _root).toMMPattern();
-    const glob2 = this.toString();
-    const [re, body, hasMagic, uflag] = this.toRegExpSource();
-    const anyMagic = hasMagic || __privateGet(this, _hasMagic) || __privateGet(this, _options).nocase && !__privateGet(this, _options).nocaseMagicOnly && glob2.toUpperCase() !== glob2.toLowerCase();
-    if (!anyMagic) {
-      return body;
-    }
-    const flags = (__privateGet(this, _options).nocase ? "i" : "") + (uflag ? "u" : "");
-    return Object.assign(new RegExp(`^${re}$`, flags), {
-      _src: re,
-      _glob: glob2
-    });
-  }
-  get options() {
-    return __privateGet(this, _options);
-  }
-  // returns the string match, the regexp source, whether there's magic
-  // in the regexp (so a regular expression is required) and whether or
-  // not the uflag is needed for the regular expression (for posix classes)
-  // TODO: instead of injecting the start/end at this point, just return
-  // the BODY of the regexp, along with the start/end portions suitable
-  // for binding the start/end in either a joined full-path makeRe context
-  // (where we bind to (^|/), or a standalone matchPart context (where
-  // we bind to ^, and not /).  Otherwise slashes get duped!
-  //
-  // In part-matching mode, the start is:
-  // - if not isStart: nothing
-  // - if traversal possible, but not allowed: ^(?!\.\.?$)
-  // - if dots allowed or not possible: ^
-  // - if dots possible and not allowed: ^(?!\.)
-  // end is:
-  // - if not isEnd(): nothing
-  // - else: $
-  //
-  // In full-path matching mode, we put the slash at the START of the
-  // pattern, so start is:
-  // - if first pattern: same as part-matching mode
-  // - if not isStart(): nothing
-  // - if traversal possible, but not allowed: /(?!\.\.?(?:$|/))
-  // - if dots allowed or not possible: /
-  // - if dots possible and not allowed: /(?!\.)
-  // end is:
-  // - if last pattern, same as part-matching mode
-  // - else nothing
-  //
-  // Always put the (?:$|/) on negated tails, though, because that has to be
-  // there to bind the end of the negated pattern portion, and it's easier to
-  // just stick it in now rather than try to inject it later in the middle of
-  // the pattern.
-  //
-  // We can just always return the same end, and leave it up to the caller
-  // to know whether it's going to be used joined or in parts.
-  // And, if the start is adjusted slightly, can do the same there:
-  // - if not isStart: nothing
-  // - if traversal possible, but not allowed: (?:/|^)(?!\.\.?$)
-  // - if dots allowed or not possible: (?:/|^)
-  // - if dots possible and not allowed: (?:/|^)(?!\.)
-  //
-  // But it's better to have a simpler binding without a conditional, for
-  // performance, so probably better to return both start options.
-  //
-  // Then the caller just ignores the end if it's not the first pattern,
-  // and the start always gets applied.
-  //
-  // But that's always going to be $ if it's the ending pattern, or nothing,
-  // so the caller can just attach $ at the end of the pattern when building.
-  //
-  // So the todo is:
-  // - better detect what kind of start is needed
-  // - return both flavors of starting pattern
-  // - attach $ at the end of the pattern when creating the actual RegExp
-  //
-  // Ah, but wait, no, that all only applies to the root when the first pattern
-  // is not an extglob. If the first pattern IS an extglob, then we need all
-  // that dot prevention biz to live in the extglob portions, because eg
-  // +(*|.x*) can match .xy but not .yx.
-  //
-  // So, return the two flavors if it's #root and the first child is not an
-  // AST, otherwise leave it to the child AST to handle it, and there,
-  // use the (?:^|/) style of start binding.
-  //
-  // Even simplified further:
-  // - Since the start for a join is eg /(?!\.) and the start for a part
-  // is ^(?!\.), we can just prepend (?!\.) to the pattern (either root
-  // or start or whatever) and prepend ^ or / at the Regexp construction.
-  toRegExpSource(allowDot) {
-    const dot = allowDot ?? !!__privateGet(this, _options).dot;
-    if (__privateGet(this, _root) === this)
-      __privateMethod(this, _fillNegs, fillNegs_fn).call(this);
-    if (!this.type) {
-      const noEmpty = this.isStart() && this.isEnd() && !__privateGet(this, _parts).some((s) => typeof s !== "string");
-      const src = __privateGet(this, _parts).map((p) => {
-        var _a;
-        const [re, _, hasMagic, uflag] = typeof p === "string" ? __privateMethod(_a = _AST, _parseGlob, parseGlob_fn).call(_a, p, __privateGet(this, _hasMagic), noEmpty) : p.toRegExpSource(allowDot);
-        __privateSet(this, _hasMagic, __privateGet(this, _hasMagic) || hasMagic);
-        __privateSet(this, _uflag, __privateGet(this, _uflag) || uflag);
-        return re;
-      }).join("");
-      let start2 = "";
-      if (this.isStart()) {
-        if (typeof __privateGet(this, _parts)[0] === "string") {
-          const dotTravAllowed = __privateGet(this, _parts).length === 1 && justDots.has(__privateGet(this, _parts)[0]);
-          if (!dotTravAllowed) {
-            const aps = addPatternStart;
-            const needNoTrav = (
-              // dots are allowed, and the pattern starts with [ or .
-              dot && aps.has(src.charAt(0)) || // the pattern starts with \., and then [ or .
-              src.startsWith("\\.") && aps.has(src.charAt(2)) || // the pattern starts with \.\., and then [ or .
-              src.startsWith("\\.\\.") && aps.has(src.charAt(4))
-            );
-            const needNoDot = !dot && !allowDot && aps.has(src.charAt(0));
-            start2 = needNoTrav ? startNoTraversal : needNoDot ? startNoDot : "";
-          }
-        }
-      }
-      let end = "";
-      if (this.isEnd() && __privateGet(__privateGet(this, _root), _filledNegs) && __privateGet(this, _parent)?.type === "!") {
-        end = "(?:$|\\/)";
-      }
-      const final2 = start2 + src + end;
-      return [
-        final2,
-        unescape(src),
-        __privateSet(this, _hasMagic, !!__privateGet(this, _hasMagic)),
-        __privateGet(this, _uflag)
-      ];
-    }
-    const repeated = this.type === "*" || this.type === "+";
-    const start = this.type === "!" ? "(?:(?!(?:" : "(?:";
-    let body = __privateMethod(this, _partsToRegExp, partsToRegExp_fn).call(this, dot);
-    if (this.isStart() && this.isEnd() && !body && this.type !== "!") {
-      const s = this.toString();
-      __privateSet(this, _parts, [s]);
-      this.type = null;
-      __privateSet(this, _hasMagic, void 0);
-      return [s, unescape(this.toString()), false, false];
-    }
-    let bodyDotAllowed = !repeated || allowDot || dot || !startNoDot ? "" : __privateMethod(this, _partsToRegExp, partsToRegExp_fn).call(this, true);
-    if (bodyDotAllowed === body) {
-      bodyDotAllowed = "";
-    }
-    if (bodyDotAllowed) {
-      body = `(?:${body})(?:${bodyDotAllowed})*?`;
-    }
-    let final = "";
-    if (this.type === "!" && __privateGet(this, _emptyExt)) {
-      final = (this.isStart() && !dot ? startNoDot : "") + starNoEmpty;
-    } else {
-      const close = this.type === "!" ? (
-        // !() must match something,but !(x) can match ''
-        "))" + (this.isStart() && !dot && !allowDot ? startNoDot : "") + star + ")"
-      ) : this.type === "@" ? ")" : this.type === "?" ? ")?" : this.type === "+" && bodyDotAllowed ? ")" : this.type === "*" && bodyDotAllowed ? `)?` : `)${this.type}`;
-      final = start + body + close;
-    }
-    return [
-      final,
-      unescape(body),
-      __privateSet(this, _hasMagic, !!__privateGet(this, _hasMagic)),
-      __privateGet(this, _uflag)
-    ];
-  }
-};
-_root = new WeakMap();
-_hasMagic = new WeakMap();
-_uflag = new WeakMap();
-_parts = new WeakMap();
-_parent = new WeakMap();
-_parentIndex = new WeakMap();
-_negs = new WeakMap();
-_filledNegs = new WeakMap();
-_options = new WeakMap();
-_toString = new WeakMap();
-_emptyExt = new WeakMap();
-_fillNegs = new WeakSet();
-fillNegs_fn = function() {
-  if (this !== __privateGet(this, _root))
-    throw new Error("should only call on root");
-  if (__privateGet(this, _filledNegs))
-    return this;
-  this.toString();
-  __privateSet(this, _filledNegs, true);
-  let n;
-  while (n = __privateGet(this, _negs).pop()) {
-    if (n.type !== "!")
-      continue;
-    let p = n;
-    let pp = __privateGet(p, _parent);
-    while (pp) {
-      for (let i = __privateGet(p, _parentIndex) + 1; !pp.type && i < __privateGet(pp, _parts).length; i++) {
-        for (const part of __privateGet(n, _parts)) {
-          if (typeof part === "string") {
-            throw new Error("string part in extglob AST??");
-          }
-          part.copyIn(__privateGet(pp, _parts)[i]);
-        }
-      }
-      p = pp;
-      pp = __privateGet(p, _parent);
-    }
-  }
-  return this;
-};
-_parseAST = new WeakSet();
-parseAST_fn = function(str, ast, pos, opt) {
-  var _a, _b;
-  let escaping = false;
-  let inBrace = false;
-  let braceStart = -1;
-  let braceNeg = false;
-  if (ast.type === null) {
-    let i2 = pos;
-    let acc2 = "";
-    while (i2 < str.length) {
-      const c = str.charAt(i2++);
-      if (escaping || c === "\\") {
-        escaping = !escaping;
-        acc2 += c;
-        continue;
-      }
-      if (inBrace) {
-        if (i2 === braceStart + 1) {
-          if (c === "^" || c === "!") {
-            braceNeg = true;
-          }
-        } else if (c === "]" && !(i2 === braceStart + 2 && braceNeg)) {
-          inBrace = false;
-        }
-        acc2 += c;
-        continue;
-      } else if (c === "[") {
-        inBrace = true;
-        braceStart = i2;
-        braceNeg = false;
-        acc2 += c;
-        continue;
-      }
-      if (!opt.noext && isExtglobType(c) && str.charAt(i2) === "(") {
-        ast.push(acc2);
-        acc2 = "";
-        const ext2 = new _AST(c, ast);
-        i2 = __privateMethod(_a = _AST, _parseAST, parseAST_fn).call(_a, str, ext2, i2, opt);
-        ast.push(ext2);
-        continue;
-      }
-      acc2 += c;
-    }
-    ast.push(acc2);
-    return i2;
-  }
-  let i = pos + 1;
-  let part = new _AST(null, ast);
-  const parts = [];
-  let acc = "";
-  while (i < str.length) {
-    const c = str.charAt(i++);
-    if (escaping || c === "\\") {
-      escaping = !escaping;
-      acc += c;
-      continue;
-    }
-    if (inBrace) {
-      if (i === braceStart + 1) {
-        if (c === "^" || c === "!") {
-          braceNeg = true;
-        }
-      } else if (c === "]" && !(i === braceStart + 2 && braceNeg)) {
-        inBrace = false;
-      }
-      acc += c;
-      continue;
-    } else if (c === "[") {
-      inBrace = true;
-      braceStart = i;
-      braceNeg = false;
-      acc += c;
-      continue;
-    }
-    if (isExtglobType(c) && str.charAt(i) === "(") {
-      part.push(acc);
-      acc = "";
-      const ext2 = new _AST(c, part);
-      part.push(ext2);
-      i = __privateMethod(_b = _AST, _parseAST, parseAST_fn).call(_b, str, ext2, i, opt);
-      continue;
-    }
-    if (c === "|") {
-      part.push(acc);
-      acc = "";
-      parts.push(part);
-      part = new _AST(null, ast);
-      continue;
-    }
-    if (c === ")") {
-      if (acc === "" && __privateGet(ast, _parts).length === 0) {
-        __privateSet(ast, _emptyExt, true);
-      }
-      part.push(acc);
-      acc = "";
-      ast.push(...parts, part);
-      return i;
-    }
-    acc += c;
-  }
-  ast.type = null;
-  __privateSet(ast, _hasMagic, void 0);
-  __privateSet(ast, _parts, [str.substring(pos - 1)]);
-  return i;
-};
-_partsToRegExp = new WeakSet();
-partsToRegExp_fn = function(dot) {
-  return __privateGet(this, _parts).map((p) => {
-    if (typeof p === "string") {
-      throw new Error("string type in extglob ast??");
-    }
-    const [re, _, _hasMagic2, uflag] = p.toRegExpSource(dot);
-    __privateSet(this, _uflag, __privateGet(this, _uflag) || uflag);
-    return re;
-  }).filter((p) => !(this.isStart() && this.isEnd()) || !!p).join("|");
-};
-_parseGlob = new WeakSet();
-parseGlob_fn = function(glob2, hasMagic, noEmpty = false) {
-  let escaping = false;
-  let re = "";
-  let uflag = false;
-  for (let i = 0; i < glob2.length; i++) {
-    const c = glob2.charAt(i);
-    if (escaping) {
-      escaping = false;
-      re += (reSpecials.has(c) ? "\\" : "") + c;
-      continue;
-    }
-    if (c === "\\") {
-      if (i === glob2.length - 1) {
-        re += "\\\\";
-      } else {
-        escaping = true;
-      }
-      continue;
-    }
-    if (c === "[") {
-      const [src, needUflag, consumed, magic] = parseClass(glob2, i);
-      if (consumed) {
-        re += src;
-        uflag = uflag || needUflag;
-        i += consumed - 1;
-        hasMagic = hasMagic || magic;
-        continue;
-      }
-    }
-    if (c === "*") {
-      re += noEmpty && glob2 === "*" ? starNoEmpty : star;
-      hasMagic = true;
-      continue;
-    }
-    if (c === "?") {
-      re += qmark;
-      hasMagic = true;
-      continue;
-    }
-    re += regExpEscape(c);
-  }
-  return [re, unescape(glob2), !!hasMagic, uflag];
-};
-__privateAdd(_AST, _parseAST);
-__privateAdd(_AST, _parseGlob);
-var AST = _AST;
-
-// ../../node_modules/.pnpm/minimatch@10.1.1/node_modules/minimatch/dist/esm/escape.js
-var escape = (s, { windowsPathsNoEscape = false, magicalBraces = false } = {}) => {
-  if (magicalBraces) {
-    return windowsPathsNoEscape ? s.replace(/[?*()[\]{}]/g, "[$&]") : s.replace(/[?*()[\]\\{}]/g, "\\$&");
-  }
-  return windowsPathsNoEscape ? s.replace(/[?*()[\]]/g, "[$&]") : s.replace(/[?*()[\]\\]/g, "\\$&");
-};
-
-// ../../node_modules/.pnpm/minimatch@10.1.1/node_modules/minimatch/dist/esm/index.js
-var minimatch = (p, pattern, options = {}) => {
-  assertValidPattern(pattern);
-  if (!options.nocomment && pattern.charAt(0) === "#") {
-    return false;
-  }
-  return new Minimatch(pattern, options).match(p);
-};
-var starDotExtRE = /^\*+([^+@!?\*\[\(]*)$/;
-var starDotExtTest = (ext2) => (f) => !f.startsWith(".") && f.endsWith(ext2);
-var starDotExtTestDot = (ext2) => (f) => f.endsWith(ext2);
-var starDotExtTestNocase = (ext2) => {
-  ext2 = ext2.toLowerCase();
-  return (f) => !f.startsWith(".") && f.toLowerCase().endsWith(ext2);
-};
-var starDotExtTestNocaseDot = (ext2) => {
-  ext2 = ext2.toLowerCase();
-  return (f) => f.toLowerCase().endsWith(ext2);
-};
-var starDotStarRE = /^\*+\.\*+$/;
-var starDotStarTest = (f) => !f.startsWith(".") && f.includes(".");
-var starDotStarTestDot = (f) => f !== "." && f !== ".." && f.includes(".");
-var dotStarRE = /^\.\*+$/;
-var dotStarTest = (f) => f !== "." && f !== ".." && f.startsWith(".");
-var starRE = /^\*+$/;
-var starTest = (f) => f.length !== 0 && !f.startsWith(".");
-var starTestDot = (f) => f.length !== 0 && f !== "." && f !== "..";
-var qmarksRE = /^\?+([^+@!?\*\[\(]*)?$/;
-var qmarksTestNocase = ([$0, ext2 = ""]) => {
-  const noext = qmarksTestNoExt([$0]);
-  if (!ext2)
-    return noext;
-  ext2 = ext2.toLowerCase();
-  return (f) => noext(f) && f.toLowerCase().endsWith(ext2);
-};
-var qmarksTestNocaseDot = ([$0, ext2 = ""]) => {
-  const noext = qmarksTestNoExtDot([$0]);
-  if (!ext2)
-    return noext;
-  ext2 = ext2.toLowerCase();
-  return (f) => noext(f) && f.toLowerCase().endsWith(ext2);
-};
-var qmarksTestDot = ([$0, ext2 = ""]) => {
-  const noext = qmarksTestNoExtDot([$0]);
-  return !ext2 ? noext : (f) => noext(f) && f.endsWith(ext2);
-};
-var qmarksTest = ([$0, ext2 = ""]) => {
-  const noext = qmarksTestNoExt([$0]);
-  return !ext2 ? noext : (f) => noext(f) && f.endsWith(ext2);
-};
-var qmarksTestNoExt = ([$0]) => {
-  const len = $0.length;
-  return (f) => f.length === len && !f.startsWith(".");
-};
-var qmarksTestNoExtDot = ([$0]) => {
-  const len = $0.length;
-  return (f) => f.length === len && f !== "." && f !== "..";
-};
-var defaultPlatform = typeof process === "object" && process ? typeof process.env === "object" && process.env && process.env.__MINIMATCH_TESTING_PLATFORM__ || process.platform : "posix";
-var path = {
-  win32: { sep: "\\" },
-  posix: { sep: "/" }
-};
-var sep = defaultPlatform === "win32" ? path.win32.sep : path.posix.sep;
-minimatch.sep = sep;
-var GLOBSTAR = Symbol("globstar **");
-minimatch.GLOBSTAR = GLOBSTAR;
-var qmark2 = "[^/]";
-var star2 = qmark2 + "*?";
-var twoStarDot = "(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?";
-var twoStarNoDot = "(?:(?!(?:\\/|^)\\.).)*?";
-var filter = (pattern, options = {}) => (p) => minimatch(p, pattern, options);
-minimatch.filter = filter;
-var ext = (a, b = {}) => Object.assign({}, a, b);
-var defaults = (def) => {
-  if (!def || typeof def !== "object" || !Object.keys(def).length) {
-    return minimatch;
-  }
-  const orig = minimatch;
-  const m = (p, pattern, options = {}) => orig(p, pattern, ext(def, options));
-  return Object.assign(m, {
-    Minimatch: class Minimatch extends orig.Minimatch {
-      constructor(pattern, options = {}) {
-        super(pattern, ext(def, options));
-      }
-      static defaults(options) {
-        return orig.defaults(ext(def, options)).Minimatch;
-      }
-    },
-    AST: class AST extends orig.AST {
-      /* c8 ignore start */
-      constructor(type, parent, options = {}) {
-        super(type, parent, ext(def, options));
-      }
-      /* c8 ignore stop */
-      static fromGlob(pattern, options = {}) {
-        return orig.AST.fromGlob(pattern, ext(def, options));
-      }
-    },
-    unescape: (s, options = {}) => orig.unescape(s, ext(def, options)),
-    escape: (s, options = {}) => orig.escape(s, ext(def, options)),
-    filter: (pattern, options = {}) => orig.filter(pattern, ext(def, options)),
-    defaults: (options) => orig.defaults(ext(def, options)),
-    makeRe: (pattern, options = {}) => orig.makeRe(pattern, ext(def, options)),
-    braceExpand: (pattern, options = {}) => orig.braceExpand(pattern, ext(def, options)),
-    match: (list, pattern, options = {}) => orig.match(list, pattern, ext(def, options)),
-    sep: orig.sep,
-    GLOBSTAR
-  });
-};
-minimatch.defaults = defaults;
-var braceExpand = (pattern, options = {}) => {
-  assertValidPattern(pattern);
-  if (options.nobrace || !/\{(?:(?!\{).)*\}/.test(pattern)) {
-    return [pattern];
-  }
-  return expand(pattern);
-};
-minimatch.braceExpand = braceExpand;
-var makeRe = (pattern, options = {}) => new Minimatch(pattern, options).makeRe();
-minimatch.makeRe = makeRe;
-var match = (list, pattern, options = {}) => {
-  const mm = new Minimatch(pattern, options);
-  list = list.filter((f) => mm.match(f));
-  if (mm.options.nonull && !list.length) {
-    list.push(pattern);
-  }
-  return list;
-};
-minimatch.match = match;
-var globMagic = /[?*]|[+@!]\(.*?\)|\[|\]/;
-var regExpEscape2 = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
-var Minimatch = class {
-  constructor(pattern, options = {}) {
-    __publicField(this, "options");
-    __publicField(this, "set");
-    __publicField(this, "pattern");
-    __publicField(this, "windowsPathsNoEscape");
-    __publicField(this, "nonegate");
-    __publicField(this, "negate");
-    __publicField(this, "comment");
-    __publicField(this, "empty");
-    __publicField(this, "preserveMultipleSlashes");
-    __publicField(this, "partial");
-    __publicField(this, "globSet");
-    __publicField(this, "globParts");
-    __publicField(this, "nocase");
-    __publicField(this, "isWindows");
-    __publicField(this, "platform");
-    __publicField(this, "windowsNoMagicRoot");
-    __publicField(this, "regexp");
-    assertValidPattern(pattern);
-    options = options || {};
-    this.options = options;
-    this.pattern = pattern;
-    this.platform = options.platform || defaultPlatform;
-    this.isWindows = this.platform === "win32";
-    this.windowsPathsNoEscape = !!options.windowsPathsNoEscape || options.allowWindowsEscape === false;
-    if (this.windowsPathsNoEscape) {
-      this.pattern = this.pattern.replace(/\\/g, "/");
-    }
-    this.preserveMultipleSlashes = !!options.preserveMultipleSlashes;
-    this.regexp = null;
-    this.negate = false;
-    this.nonegate = !!options.nonegate;
-    this.comment = false;
-    this.empty = false;
-    this.partial = !!options.partial;
-    this.nocase = !!this.options.nocase;
-    this.windowsNoMagicRoot = options.windowsNoMagicRoot !== void 0 ? options.windowsNoMagicRoot : !!(this.isWindows && this.nocase);
-    this.globSet = [];
-    this.globParts = [];
-    this.set = [];
-    this.make();
-  }
-  hasMagic() {
-    if (this.options.magicalBraces && this.set.length > 1) {
-      return true;
-    }
-    for (const pattern of this.set) {
-      for (const part of pattern) {
-        if (typeof part !== "string")
-          return true;
-      }
-    }
-    return false;
-  }
-  debug(..._) {
-  }
-  make() {
-    const pattern = this.pattern;
-    const options = this.options;
-    if (!options.nocomment && pattern.charAt(0) === "#") {
-      this.comment = true;
-      return;
-    }
-    if (!pattern) {
-      this.empty = true;
-      return;
-    }
-    this.parseNegate();
-    this.globSet = [...new Set(this.braceExpand())];
-    if (options.debug) {
-      this.debug = (...args) => console.error(...args);
-    }
-    this.debug(this.pattern, this.globSet);
-    const rawGlobParts = this.globSet.map((s) => this.slashSplit(s));
-    this.globParts = this.preprocess(rawGlobParts);
-    this.debug(this.pattern, this.globParts);
-    let set = this.globParts.map((s, _, __) => {
-      if (this.isWindows && this.windowsNoMagicRoot) {
-        const isUNC = s[0] === "" && s[1] === "" && (s[2] === "?" || !globMagic.test(s[2])) && !globMagic.test(s[3]);
-        const isDrive = /^[a-z]:/i.test(s[0]);
-        if (isUNC) {
-          return [...s.slice(0, 4), ...s.slice(4).map((ss) => this.parse(ss))];
-        } else if (isDrive) {
-          return [s[0], ...s.slice(1).map((ss) => this.parse(ss))];
-        }
-      }
-      return s.map((ss) => this.parse(ss));
-    });
-    this.debug(this.pattern, set);
-    this.set = set.filter((s) => s.indexOf(false) === -1);
-    if (this.isWindows) {
-      for (let i = 0; i < this.set.length; i++) {
-        const p = this.set[i];
-        if (p[0] === "" && p[1] === "" && this.globParts[i][2] === "?" && typeof p[3] === "string" && /^[a-z]:$/i.test(p[3])) {
-          p[2] = "?";
-        }
-      }
-    }
-    this.debug(this.pattern, this.set);
-  }
-  // various transforms to equivalent pattern sets that are
-  // faster to process in a filesystem walk.  The goal is to
-  // eliminate what we can, and push all ** patterns as far
-  // to the right as possible, even if it increases the number
-  // of patterns that we have to process.
-  preprocess(globParts) {
-    if (this.options.noglobstar) {
-      for (let i = 0; i < globParts.length; i++) {
-        for (let j = 0; j < globParts[i].length; j++) {
-          if (globParts[i][j] === "**") {
-            globParts[i][j] = "*";
-          }
-        }
-      }
-    }
-    const { optimizationLevel = 1 } = this.options;
-    if (optimizationLevel >= 2) {
-      globParts = this.firstPhasePreProcess(globParts);
-      globParts = this.secondPhasePreProcess(globParts);
-    } else if (optimizationLevel >= 1) {
-      globParts = this.levelOneOptimize(globParts);
-    } else {
-      globParts = this.adjascentGlobstarOptimize(globParts);
-    }
-    return globParts;
-  }
-  // just get rid of adjascent ** portions
-  adjascentGlobstarOptimize(globParts) {
-    return globParts.map((parts) => {
-      let gs = -1;
-      while (-1 !== (gs = parts.indexOf("**", gs + 1))) {
-        let i = gs;
-        while (parts[i + 1] === "**") {
-          i++;
-        }
-        if (i !== gs) {
-          parts.splice(gs, i - gs);
-        }
-      }
-      return parts;
-    });
-  }
-  // get rid of adjascent ** and resolve .. portions
-  levelOneOptimize(globParts) {
-    return globParts.map((parts) => {
-      parts = parts.reduce((set, part) => {
-        const prev = set[set.length - 1];
-        if (part === "**" && prev === "**") {
-          return set;
-        }
-        if (part === "..") {
-          if (prev && prev !== ".." && prev !== "." && prev !== "**") {
-            set.pop();
-            return set;
-          }
-        }
-        set.push(part);
-        return set;
-      }, []);
-      return parts.length === 0 ? [""] : parts;
-    });
-  }
-  levelTwoFileOptimize(parts) {
-    if (!Array.isArray(parts)) {
-      parts = this.slashSplit(parts);
-    }
-    let didSomething = false;
-    do {
-      didSomething = false;
-      if (!this.preserveMultipleSlashes) {
-        for (let i = 1; i < parts.length - 1; i++) {
-          const p = parts[i];
-          if (i === 1 && p === "" && parts[0] === "")
-            continue;
-          if (p === "." || p === "") {
-            didSomething = true;
-            parts.splice(i, 1);
-            i--;
-          }
-        }
-        if (parts[0] === "." && parts.length === 2 && (parts[1] === "." || parts[1] === "")) {
-          didSomething = true;
-          parts.pop();
-        }
-      }
-      let dd = 0;
-      while (-1 !== (dd = parts.indexOf("..", dd + 1))) {
-        const p = parts[dd - 1];
-        if (p && p !== "." && p !== ".." && p !== "**") {
-          didSomething = true;
-          parts.splice(dd - 1, 2);
-          dd -= 2;
-        }
-      }
-    } while (didSomething);
-    return parts.length === 0 ? [""] : parts;
-  }
-  // First phase: single-pattern processing
-  // <pre> is 1 or more portions
-  // <rest> is 1 or more portions
-  // <p> is any portion other than ., .., '', or **
-  // <e> is . or ''
-  //
-  // **/.. is *brutal* for filesystem walking performance, because
-  // it effectively resets the recursive walk each time it occurs,
-  // and ** cannot be reduced out by a .. pattern part like a regexp
-  // or most strings (other than .., ., and '') can be.
-  //
-  // <pre>/**/../<p>/<p>/<rest> -> {<pre>/../<p>/<p>/<rest>,<pre>/**/<p>/<p>/<rest>}
-  // <pre>/<e>/<rest> -> <pre>/<rest>
-  // <pre>/<p>/../<rest> -> <pre>/<rest>
-  // **/**/<rest> -> **/<rest>
-  //
-  // **/*/<rest> -> */**/<rest> <== not valid because ** doesn't follow
-  // this WOULD be allowed if ** did follow symlinks, or * didn't
-  firstPhasePreProcess(globParts) {
-    let didSomething = false;
-    do {
-      didSomething = false;
-      for (let parts of globParts) {
-        let gs = -1;
-        while (-1 !== (gs = parts.indexOf("**", gs + 1))) {
-          let gss = gs;
-          while (parts[gss + 1] === "**") {
-            gss++;
-          }
-          if (gss > gs) {
-            parts.splice(gs + 1, gss - gs);
-          }
-          let next = parts[gs + 1];
-          const p = parts[gs + 2];
-          const p2 = parts[gs + 3];
-          if (next !== "..")
-            continue;
-          if (!p || p === "." || p === ".." || !p2 || p2 === "." || p2 === "..") {
-            continue;
-          }
-          didSomething = true;
-          parts.splice(gs, 1);
-          const other = parts.slice(0);
-          other[gs] = "**";
-          globParts.push(other);
-          gs--;
-        }
-        if (!this.preserveMultipleSlashes) {
-          for (let i = 1; i < parts.length - 1; i++) {
-            const p = parts[i];
-            if (i === 1 && p === "" && parts[0] === "")
-              continue;
-            if (p === "." || p === "") {
-              didSomething = true;
-              parts.splice(i, 1);
-              i--;
-            }
-          }
-          if (parts[0] === "." && parts.length === 2 && (parts[1] === "." || parts[1] === "")) {
-            didSomething = true;
-            parts.pop();
-          }
-        }
-        let dd = 0;
-        while (-1 !== (dd = parts.indexOf("..", dd + 1))) {
-          const p = parts[dd - 1];
-          if (p && p !== "." && p !== ".." && p !== "**") {
-            didSomething = true;
-            const needDot = dd === 1 && parts[dd + 1] === "**";
-            const splin = needDot ? ["."] : [];
-            parts.splice(dd - 1, 2, ...splin);
-            if (parts.length === 0)
-              parts.push("");
-            dd -= 2;
-          }
-        }
-      }
-    } while (didSomething);
-    return globParts;
-  }
-  // second phase: multi-pattern dedupes
-  // {<pre>/*/<rest>,<pre>/<p>/<rest>} -> <pre>/*/<rest>
-  // {<pre>/<rest>,<pre>/<rest>} -> <pre>/<rest>
-  // {<pre>/**/<rest>,<pre>/<rest>} -> <pre>/**/<rest>
-  //
-  // {<pre>/**/<rest>,<pre>/**/<p>/<rest>} -> <pre>/**/<rest>
-  // ^-- not valid because ** doens't follow symlinks
-  secondPhasePreProcess(globParts) {
-    for (let i = 0; i < globParts.length - 1; i++) {
-      for (let j = i + 1; j < globParts.length; j++) {
-        const matched = this.partsMatch(globParts[i], globParts[j], !this.preserveMultipleSlashes);
-        if (matched) {
-          globParts[i] = [];
-          globParts[j] = matched;
-          break;
-        }
-      }
-    }
-    return globParts.filter((gs) => gs.length);
-  }
-  partsMatch(a, b, emptyGSMatch = false) {
-    let ai = 0;
-    let bi = 0;
-    let result = [];
-    let which2 = "";
-    while (ai < a.length && bi < b.length) {
-      if (a[ai] === b[bi]) {
-        result.push(which2 === "b" ? b[bi] : a[ai]);
-        ai++;
-        bi++;
-      } else if (emptyGSMatch && a[ai] === "**" && b[bi] === a[ai + 1]) {
-        result.push(a[ai]);
-        ai++;
-      } else if (emptyGSMatch && b[bi] === "**" && a[ai] === b[bi + 1]) {
-        result.push(b[bi]);
-        bi++;
-      } else if (a[ai] === "*" && b[bi] && (this.options.dot || !b[bi].startsWith(".")) && b[bi] !== "**") {
-        if (which2 === "b")
-          return false;
-        which2 = "a";
-        result.push(a[ai]);
-        ai++;
-        bi++;
-      } else if (b[bi] === "*" && a[ai] && (this.options.dot || !a[ai].startsWith(".")) && a[ai] !== "**") {
-        if (which2 === "a")
-          return false;
-        which2 = "b";
-        result.push(b[bi]);
-        ai++;
-        bi++;
-      } else {
-        return false;
-      }
-    }
-    return a.length === b.length && result;
-  }
-  parseNegate() {
-    if (this.nonegate)
-      return;
-    const pattern = this.pattern;
-    let negate = false;
-    let negateOffset = 0;
-    for (let i = 0; i < pattern.length && pattern.charAt(i) === "!"; i++) {
-      negate = !negate;
-      negateOffset++;
-    }
-    if (negateOffset)
-      this.pattern = pattern.slice(negateOffset);
-    this.negate = negate;
-  }
-  // set partial to true to test if, for example,
-  // "/a/b" matches the start of "/*/b/*/d"
-  // Partial means, if you run out of file before you run
-  // out of pattern, then that's fine, as long as all
-  // the parts match.
-  matchOne(file, pattern, partial = false) {
-    const options = this.options;
-    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]);
-      const patternDrive = typeof pattern[0] === "string" && /^[a-z]:$/i.test(pattern[0]);
-      const patternUNC = !patternDrive && pattern[0] === "" && pattern[1] === "" && pattern[2] === "?" && typeof pattern[3] === "string" && /^[a-z]:$/i.test(pattern[3]);
-      const fdi = fileUNC ? 3 : fileDrive ? 0 : void 0;
-      const pdi = patternUNC ? 3 : patternDrive ? 0 : void 0;
-      if (typeof fdi === "number" && typeof pdi === "number") {
-        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);
-          }
-        }
-      }
-    }
-    const { optimizationLevel = 1 } = this.options;
-    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) {
-        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;
-        }
-        while (fr < fl) {
-          var swallowee = file[fr];
-          this.debug("\nglobstar 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++;
-          }
-        }
-        if (partial) {
-          this.debug("\n>>> no match, partial?", file, fr, pattern, pr);
-          if (fr === fl) {
-            return true;
-          }
-        }
-        return false;
-      }
-      let hit;
-      if (typeof p === "string") {
-        hit = f === p;
-        this.debug("string match", p, f, hit);
-      } else {
-        hit = p.test(f);
-        this.debug("pattern match", p, f, hit);
-      }
-      if (!hit)
-        return false;
-    }
-    if (fi === fl && pi === pl) {
-      return true;
-    } else if (fi === fl) {
-      return partial;
-    } else if (pi === pl) {
-      return fi === fl - 1 && file[fi] === "";
-    } else {
-      throw new Error("wtf?");
-    }
-  }
-  braceExpand() {
-    return braceExpand(this.pattern, this.options);
-  }
-  parse(pattern) {
-    assertValidPattern(pattern);
-    const options = this.options;
-    if (pattern === "**")
-      return GLOBSTAR;
-    if (pattern === "")
-      return "";
-    let m;
-    let fastTest = null;
-    if (m = pattern.match(starRE)) {
-      fastTest = options.dot ? starTestDot : starTest;
-    } else if (m = pattern.match(starDotExtRE)) {
-      fastTest = (options.nocase ? options.dot ? starDotExtTestNocaseDot : starDotExtTestNocase : options.dot ? starDotExtTestDot : starDotExtTest)(m[1]);
-    } else if (m = pattern.match(qmarksRE)) {
-      fastTest = (options.nocase ? options.dot ? qmarksTestNocaseDot : qmarksTestNocase : options.dot ? qmarksTestDot : qmarksTest)(m);
-    } else if (m = pattern.match(starDotStarRE)) {
-      fastTest = options.dot ? starDotStarTestDot : starDotStarTest;
-    } else if (m = pattern.match(dotStarRE)) {
-      fastTest = dotStarTest;
-    }
-    const re = AST.fromGlob(pattern, this.options).toMMPattern();
-    if (fastTest && typeof re === "object") {
-      Reflect.defineProperty(re, "test", { value: fastTest });
-    }
-    return re;
-  }
-  makeRe() {
-    if (this.regexp || this.regexp === false)
-      return this.regexp;
-    const set = this.set;
-    if (!set.length) {
-      this.regexp = false;
-      return this.regexp;
-    }
-    const options = this.options;
-    const twoStar = options.noglobstar ? star2 : options.dot ? twoStarDot : twoStarNoDot;
-    const flags = new Set(options.nocase ? ["i"] : []);
-    let re = set.map((pattern) => {
-      const pp = pattern.map((p) => {
-        if (p instanceof RegExp) {
-          for (const f of p.flags.split(""))
-            flags.add(f);
-        }
-        return typeof p === "string" ? regExpEscape2(p) : p === GLOBSTAR ? GLOBSTAR : p._src;
-      });
-      pp.forEach((p, i) => {
-        const next = pp[i + 1];
-        const prev = pp[i - 1];
-        if (p !== GLOBSTAR || prev === GLOBSTAR) {
-          return;
-        }
-        if (prev === void 0) {
-          if (next !== void 0 && next !== GLOBSTAR) {
-            pp[i + 1] = "(?:\\/|" + twoStar + "\\/)?" + next;
-          } else {
-            pp[i] = twoStar;
-          }
-        } else if (next === void 0) {
-          pp[i - 1] = prev + "(?:\\/|\\/" + twoStar + ")?";
-        } else if (next !== GLOBSTAR) {
-          pp[i - 1] = prev + "(?:\\/|\\/" + twoStar + "\\/)" + next;
-          pp[i + 1] = GLOBSTAR;
-        }
-      });
-      const filtered = pp.filter((p) => p !== GLOBSTAR);
-      if (this.partial && filtered.length >= 1) {
-        const prefixes = [];
-        for (let i = 1; i <= filtered.length; i++) {
-          prefixes.push(filtered.slice(0, i).join("/"));
-        }
-        return "(?:" + prefixes.join("|") + ")";
-      }
-      return filtered.join("/");
-    }).join("|");
-    const [open, close] = set.length > 1 ? ["(?:", ")"] : ["", ""];
-    re = "^" + open + re + close + "$";
-    if (this.partial) {
-      re = "^(?:\\/|" + open + re.slice(1, -1) + close + ")$";
-    }
-    if (this.negate)
-      re = "^(?!" + re + ").+$";
-    try {
-      this.regexp = new RegExp(re, [...flags].join(""));
-    } catch (ex) {
-      this.regexp = false;
-    }
-    return this.regexp;
-  }
-  slashSplit(p) {
-    if (this.preserveMultipleSlashes) {
-      return p.split("/");
-    } else if (this.isWindows && /^\/\/[^\/]+/.test(p)) {
-      return ["", ...p.split(/\/+/)];
-    } else {
-      return p.split(/\/+/);
-    }
-  }
-  match(f, partial = this.partial) {
-    this.debug("match", f, this.pattern);
-    if (this.comment) {
-      return false;
-    }
-    if (this.empty) {
-      return f === "";
-    }
-    if (f === "/" && partial) {
-      return true;
-    }
-    const options = this.options;
-    if (this.isWindows) {
-      f = f.split("\\").join("/");
-    }
-    const ff = this.slashSplit(f);
-    this.debug(this.pattern, "split", ff);
-    const set = this.set;
-    this.debug(this.pattern, "set", set);
-    let filename = ff[ff.length - 1];
-    if (!filename) {
-      for (let i = ff.length - 2; !filename && i >= 0; i--) {
-        filename = ff[i];
-      }
-    }
-    for (let i = 0; i < set.length; i++) {
-      const pattern = set[i];
-      let file = ff;
-      if (options.matchBase && pattern.length === 1) {
-        file = [filename];
-      }
-      const hit = this.matchOne(file, pattern, partial);
-      if (hit) {
-        if (options.flipNegate) {
-          return true;
-        }
-        return !this.negate;
-      }
-    }
-    if (options.flipNegate) {
-      return false;
-    }
-    return this.negate;
-  }
-  static defaults(def) {
-    return minimatch.defaults(def).Minimatch;
-  }
-};
-minimatch.AST = AST;
-minimatch.Minimatch = Minimatch;
-minimatch.escape = escape;
-minimatch.unescape = unescape;
-
-// src/index.ts
 var import_path21 = require("path");
 
 // src/package-versions.ts
-var VERCEL_RUNTIME_VERSION = "0.23.0";
+var VERCEL_RUNTIME_VERSION = "0.23.1";
 var VERCEL_WORKERS_VERSION = "0.0.25";
 
 // src/conditional-vendoring.ts
@@ -7511,8 +5903,8 @@ function createVenvEnv(venvPath, baseEnv = process.env, uvCacheDir) {
 async function readVenvPythonVersion(pyvenvCfgPath) {
   try {
     const content = await import_fs3.default.promises.readFile(pyvenvCfgPath, "utf-8");
-    const match2 = content.match(/^version\s*=\s*(\d+)\.(\d+)/m);
-    return match2 ? `${match2[1]}.${match2[2]}` : null;
+    const match = content.match(/^version\s*=\s*(\d+)\.(\d+)/m);
+    return match ? `${match[1]}.${match[2]}` : null;
   } catch {
     return null;
   }
@@ -8814,11 +7206,11 @@ async function getPackagesReachableOnPlatform(lockFile, projectName, pythonMajor
   }
   return visited;
 }
-async function calculateBundleSize(files, filter2) {
+async function calculateBundleSize(files, filter) {
   let knownSize = 0;
   const statPromises = [];
   for (const filePath of Object.keys(files)) {
-    if (filter2 && !filter2(filePath))
+    if (filter && !filter(filePath))
       continue;
     const file = files[filePath];
     if ("fsPath" in file && file.fsPath) {
@@ -9258,11 +7650,11 @@ Add this to your pyproject.toml:
 entrypoint = "${moduleAttr}"`;
 }
 async function resolveModuleAttrEntrypoint(workPath, value) {
-  const match2 = value.match(/([A-Za-z_][\w.]*)\s*:\s*([A-Za-z_][\w]*)/);
-  if (!match2)
+  const match = value.match(/([A-Za-z_][\w.]*)\s*:\s*([A-Za-z_][\w]*)/);
+  if (!match)
     return null;
-  const modulePath = match2[1];
-  const variableName = match2[2];
+  const modulePath = match[1];
+  const variableName = match[2];
   const relPath = modulePath.replace(/\./g, "/");
   const candidates = [`${relPath}.py`, `${relPath}/__init__.py`];
   for (const candidate of candidates) {
@@ -9312,11 +7704,11 @@ async function getPyprojectEntrypointWithDiagnostics(workPath) {
   const appScript = scripts?.app;
   if (typeof appScript !== "string")
     return { entrypoint: null };
-  const match2 = appScript.match(/([A-Za-z_][\w.]*)\s*:\s*([A-Za-z_][\w]*)/);
-  if (!match2)
+  const match = appScript.match(/([A-Za-z_][\w.]*)\s*:\s*([A-Za-z_][\w]*)/);
+  if (!match)
     return { entrypoint: null, appScript };
-  const modulePath = match2[1];
-  const variableName = match2[2];
+  const modulePath = match[1];
+  const variableName = match[2];
   const relPath = modulePath.replace(/\./g, "/");
   const candidates = [`${relPath}.py`, `${relPath}/__init__.py`];
   for (const candidate of candidates) {
@@ -9696,6 +8088,28 @@ function moduleColonFuncToCronPath(serviceName, moduleFunction) {
   return (0, import_build_utils12.getInternalServiceCronPath)(serviceName, entrypointPath, funcPart);
 }
 
+// src/schedules.ts
+function getGeneratedScheduleHandlerPath(outputPath) {
+  return `_vc_schedule_handlers/${outputPath.replace(/[^A-Za-z0-9]+/g, "_")}.py`;
+}
+function createScheduleHandlerModule(sourceFilesByScheduleName) {
+  const entries = Array.from(
+    sourceFilesByScheduleName,
+    ([name, sourceFile]) => `    ${JSON.stringify(name)}: os.path.join(_root, ${JSON.stringify(sourceFile)}),`
+  );
+  return [
+    "import os.path",
+    "",
+    "from vercel_runtime.schedules import create_schedule_scripts_app",
+    "",
+    "_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))",
+    "app = create_schedule_scripts_app({",
+    ...entries,
+    "})",
+    ""
+  ].join("\n");
+}
+
 // src/start-dev-server.ts
 var import_child_process2 = require("child_process");
 var import_fs13 = require("fs");
@@ -9717,14 +8131,14 @@ var import_fs10 = __toESM(require("fs"));
 var MODULE_ATTR_RE = /^([A-Za-z_][\w]*(?:\.[A-Za-z_][\w]*)*):([A-Za-z_][\w]*)$/;
 var MODULE_RE = /^[A-Za-z_][\w]*(?:\.[A-Za-z_][\w]*)*$/;
 function parseModuleEntrypoint(value) {
-  const match2 = MODULE_ATTR_RE.exec(value);
-  if (!match2) {
+  const match = MODULE_ATTR_RE.exec(value);
+  if (!match) {
     return null;
   }
   return {
-    moduleName: match2[1],
-    variableName: match2[2],
-    filePath: `${match2[1].replace(/\./g, "/")}.py`
+    moduleName: match[1],
+    variableName: match[2],
+    filePath: `${match[1].replace(/\./g, "/")}.py`
   };
 }
 function parseBareModuleEntrypoint(value) {
@@ -10014,13 +8428,13 @@ async function getApschedulerPreviewConfig(workPath) {
       '"tool.vercel.apscheduler.previews.idle_timeout" must be a duration such as "30m"'
     );
   }
-  const match2 = /^([1-9]\d*)([smhd])$/.exec(rawPreviews.idle_timeout);
-  if (!match2) {
+  const match = /^([1-9]\d*)([smhd])$/.exec(rawPreviews.idle_timeout);
+  if (!match) {
     throw apschedulerError(
       '"tool.vercel.apscheduler.previews.idle_timeout" must be a positive duration using s, m, h, or d (for example "30m")'
     );
   }
-  const idleTimeoutSeconds = Number(match2[1]) * APSCHEDULER_DURATION_UNITS[match2[2]];
+  const idleTimeoutSeconds = Number(match[1]) * APSCHEDULER_DURATION_UNITS[match[2]];
   if (!Number.isSafeInteger(idleTimeoutSeconds)) {
     throw apschedulerError(
       '"tool.vercel.apscheduler.previews.idle_timeout" is too large'
@@ -10244,7 +8658,7 @@ function parseLegacyTopics(name, value) {
   return value;
 }
 function parseLegacyTriggerDefaults(subscriber, config) {
-  const defaults2 = {};
+  const defaults = {};
   for (const {
     field,
     output,
@@ -10260,9 +8674,9 @@ function parseLegacyTriggerDefaults(subscriber, config) {
         `subscriber "${subscriber}" field "${field}" must be ${expected}`
       );
     }
-    defaults2[output] = value;
+    defaults[output] = value;
   }
-  return defaults2;
+  return defaults;
 }
 function parseTopicPatterns(name, value) {
   if (value === void 0) {
@@ -10471,7 +8885,7 @@ function parseIntrospectedSubscription(kind, subscriberName, index, value) {
   };
 }
 function parseTriggerDefaults(label, subscription) {
-  const defaults2 = {};
+  const defaults = {};
   for (const { field, output, isValid, expected } of TRIGGER_NUMBER_FIELDS) {
     const value = subscription[field];
     if (value === void 0 || value === null) {
@@ -10480,9 +8894,9 @@ function parseTriggerDefaults(label, subscription) {
     if (typeof value !== "number" || !isValid(value)) {
       throw subscriberError(`${label} field "${field}" must be ${expected}`);
     }
-    defaults2[output] = value;
+    defaults[output] = value;
   }
-  return defaults2;
+  return defaults;
 }
 function getQueueWildcardPrefix(pattern) {
   if (pattern.endsWith("*")) {
@@ -13269,37 +11683,26 @@ function getTargetPlatform(isDev) {
   }
   return { uvPlatform: UV_LINUX_TARGET, architecture: "x86_64" };
 }
-function getMatchingFunction(config, entrypoint) {
-  if (!config?.functions || !entrypoint) {
+function getMatchingFunction(config, entrypoint, isScheduleEntrypoint = false) {
+  if (!entrypoint) {
     return;
   }
-  const sources = /* @__PURE__ */ new Set([entrypoint]);
-  if (entrypoint.endsWith(".py")) {
-    sources.add(entrypoint.slice(0, -".py".length));
-  }
-  for (const sourceFile of sources) {
-    for (const [pattern, functionConfig] of Object.entries(config.functions)) {
-      if (sourceFile === pattern || minimatch(sourceFile, pattern)) {
-        return { sourceFile, functionConfig };
-      }
-    }
-  }
-  return;
+  const candidates = entrypoint.endsWith(".py") && !isScheduleEntrypoint ? [entrypoint, entrypoint.slice(0, -".py".length)] : [entrypoint];
+  return (0, import_build_utils24.findMatchingFunction)(config?.functions, candidates);
 }
 function normalizeGlobs(value) {
   return Array.isArray(value) ? value.filter((item) => typeof item === "string") : typeof value === "string" ? [value] : [];
 }
 async function getPythonLambdaOptions({
   config,
-  entrypoint
+  entrypoint,
+  isScheduleEntrypoint = false
 }) {
-  const match2 = getMatchingFunction(config, entrypoint);
-  if (!match2) {
-    return {};
-  }
+  const match = getMatchingFunction(config, entrypoint, isScheduleEntrypoint);
   const lambdaOptions = await (0, import_build_utils24.getLambdaOptionsFromFunction)({
-    sourceFile: match2.sourceFile,
-    config
+    sourceFile: match?.sourceFile ?? entrypoint,
+    config,
+    isScheduleEntrypoint
   });
   delete lambdaOptions.architecture;
   return lambdaOptions;
@@ -14021,6 +12424,8 @@ var build = async ({
     throw err;
   }
   let detected;
+  const scheduleFunction = config?.scheduleFunction;
+  const scheduleEntrypoint = scheduleFunction?.entrypoints[0];
   const handlerFunction = typeof config?.handlerFunction === "string" ? config.handlerFunction : void 0;
   if (isPyprojectEntrypoint) {
     const declared = await getVercelToolsEntrypoint(workPath, repoRootPath);
@@ -14033,6 +12438,13 @@ var build = async ({
       });
     }
     entrypoint = void 0;
+  } else if (scheduleEntrypoint) {
+    detected = {
+      entrypoint: {
+        entrypoint: scheduleEntrypoint.sourceFile,
+        variableName: ""
+      }
+    };
   } else {
     detected = await detectPythonEntrypoint(
       config.framework,
@@ -14376,7 +12788,6 @@ var build = async ({
   let runtimeTrampoline;
   if (entrypoint) {
     (0, import_build_utils24.debug)("Entrypoint is", entrypoint);
-    const moduleName = entrypointToModule(entrypoint);
     if (handlerFunction) {
       const entrypointPath = (0, import_path21.join)(workPath, entrypoint);
       const source = await import_fs20.default.promises.readFile(entrypointPath, "utf-8");
@@ -14388,32 +12799,35 @@ var build = async ({
         });
       }
     }
-    const suffix = meta.isDev && !entrypoint.endsWith(".py") ? ".py" : "";
-    const entrypointWithSuffix = `${entrypoint}${suffix}`;
-    (0, import_build_utils24.debug)("Entrypoint with suffix is", entrypointWithSuffix);
-    crons = await getServiceCrons({
-      service,
-      entrypoint,
-      rawEntrypoint,
-      handlerFunction,
-      pythonBin: getVenvPythonBin(venvPath),
-      env: pythonEnv,
-      workPath
-    });
-    const extraTrampolineEnv = [];
-    if (crons?.length) {
-      const json = JSON.stringify(buildCronRouteTable(crons));
-      (0, import_assert.default)(!json.includes("\\"), `backslash in cron route table: ${json}`);
-      extraTrampolineEnv.push(`"__VC_CRON_ROUTES": '${json}'`);
+    if (!scheduleEntrypoint) {
+      const moduleName = entrypointToModule(entrypoint);
+      const suffix = meta.isDev && !entrypoint.endsWith(".py") ? ".py" : "";
+      const entrypointWithSuffix = `${entrypoint}${suffix}`;
+      (0, import_build_utils24.debug)("Entrypoint with suffix is", entrypointWithSuffix);
+      crons = await getServiceCrons({
+        service,
+        entrypoint,
+        rawEntrypoint,
+        handlerFunction,
+        pythonBin: getVenvPythonBin(venvPath),
+        env: pythonEnv,
+        workPath
+      });
+      const extraTrampolineEnv = [];
+      if (crons?.length) {
+        const json = JSON.stringify(buildCronRouteTable(crons));
+        (0, import_assert.default)(!json.includes("\\"), `backslash in cron route table: ${json}`);
+        extraTrampolineEnv.push(`"__VC_CRON_ROUTES": '${json}'`);
+      }
+      const variableName = resolved?.variableName ?? "";
+      runtimeTrampoline = createRuntimeTrampoline({
+        moduleName,
+        entrypoint: entrypointWithSuffix,
+        vendorDir,
+        variableName,
+        extraEnv: extraTrampolineEnv
+      });
     }
-    const variableName = resolved?.variableName ?? "";
-    runtimeTrampoline = createRuntimeTrampoline({
-      moduleName,
-      entrypoint: entrypointWithSuffix,
-      vendorDir,
-      variableName,
-      extraEnv: extraTrampolineEnv
-    });
   }
   const compileAllEnabled = shouldCompileAll({
     isDev: meta.isDev,
@@ -14448,7 +12862,8 @@ var build = async ({
   }
   const functionConfig = getMatchingFunction(
     config,
-    entrypoint
+    entrypoint,
+    scheduleEntrypoint !== void 0
   )?.functionConfig;
   const includeFilesPatterns = [
     ...normalizeGlobs(config?.includeFiles),
@@ -14694,6 +13109,48 @@ var build = async ({
       );
     }
   }
+  if (scheduleFunction && scheduleEntrypoint) {
+    const lambdaOptions = await getPythonLambdaOptions({
+      config,
+      entrypoint: scheduleEntrypoint.sourceFile,
+      isScheduleEntrypoint: true
+    });
+    const generatedPath = getGeneratedScheduleHandlerPath(
+      scheduleFunction.outputPath
+    );
+    const sourceFilesByScheduleName = /* @__PURE__ */ new Map();
+    for (const { sourceFile, scheduleNames } of scheduleFunction.entrypoints) {
+      for (const name of scheduleNames) {
+        sourceFilesByScheduleName.set(name, sourceFile);
+      }
+    }
+    const scheduleLambda = new import_build_utils24.Lambda({
+      files: {
+        ...files,
+        [generatedPath]: new import_build_utils24.FileBlob({
+          data: createScheduleHandlerModule(sourceFilesByScheduleName)
+        }),
+        [`${handlerPyFilename}.py`]: new import_build_utils24.FileBlob({
+          data: createRuntimeTrampoline({
+            moduleName: generatedPythonPathToModule(generatedPath),
+            entrypoint: generatedPath,
+            vendorDir,
+            variableName: "app"
+          })
+        })
+      },
+      handler: `${handlerPyFilename}.vc_handler`,
+      runtime: pythonVersion.runtime,
+      ...lambdaOptions,
+      architecture: target.architecture,
+      environment: { ...lambdaEnv },
+      supportsResponseStreaming: true
+    });
+    return {
+      resultVersion: 2,
+      result: { output: { [scheduleFunction.outputPath]: scheduleLambda } }
+    };
+  }
   if (!(0, import_build_utils24.isPythonFramework)(framework) && !service?.name && !isPyprojectEntrypoint) {
     (0, import_assert.default)(output, "web Lambda must exist for non-service builds");
     return { resultVersion: 3, result: { output } };