vercel-cli 41.1.0__py3-none-any.whl

vercel_cli/vendor/node_modules/@vercel/python/dist/index.js

@@ -0,0 +1,3132 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// ../../node_modules/.pnpm/nice-try@1.0.5/node_modules/nice-try/src/index.js
+var require_src = __commonJS({
+  "../../node_modules/.pnpm/nice-try@1.0.5/node_modules/nice-try/src/index.js"(exports, module2) {
+    "use strict";
+    module2.exports = function(fn) {
+      try {
+        return fn();
+      } catch (e) {
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/windows.js
+var require_windows = __commonJS({
+  "../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/windows.js"(exports, module2) {
+    module2.exports = isexe;
+    isexe.sync = sync;
+    var fs2 = require("fs");
+    function checkPathExt(path, options) {
+      var pathext = options.pathExt !== void 0 ? options.pathExt : process.env.PATHEXT;
+      if (!pathext) {
+        return true;
+      }
+      pathext = pathext.split(";");
+      if (pathext.indexOf("") !== -1) {
+        return true;
+      }
+      for (var i = 0; i < pathext.length; i++) {
+        var p = pathext[i].toLowerCase();
+        if (p && path.substr(-p.length).toLowerCase() === p) {
+          return true;
+        }
+      }
+      return false;
+    }
+    function checkStat(stat, path, options) {
+      if (!stat.isSymbolicLink() && !stat.isFile()) {
+        return false;
+      }
+      return checkPathExt(path, options);
+    }
+    function isexe(path, options, cb) {
+      fs2.stat(path, function(er, stat) {
+        cb(er, er ? false : checkStat(stat, path, options));
+      });
+    }
+    function sync(path, options) {
+      return checkStat(fs2.statSync(path), path, options);
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/mode.js
+var require_mode = __commonJS({
+  "../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/mode.js"(exports, module2) {
+    module2.exports = isexe;
+    isexe.sync = sync;
+    var fs2 = require("fs");
+    function isexe(path, options, cb) {
+      fs2.stat(path, function(er, stat) {
+        cb(er, er ? false : checkStat(stat, options));
+      });
+    }
+    function sync(path, options) {
+      return checkStat(fs2.statSync(path), options);
+    }
+    function checkStat(stat, options) {
+      return stat.isFile() && checkMode(stat, options);
+    }
+    function checkMode(stat, options) {
+      var mod = stat.mode;
+      var uid = stat.uid;
+      var gid = stat.gid;
+      var myUid = options.uid !== void 0 ? options.uid : process.getuid && process.getuid();
+      var myGid = options.gid !== void 0 ? options.gid : process.getgid && process.getgid();
+      var u = parseInt("100", 8);
+      var g = parseInt("010", 8);
+      var o = parseInt("001", 8);
+      var ug = u | g;
+      var ret = mod & o || mod & g && gid === myGid || mod & u && uid === myUid || mod & ug && myUid === 0;
+      return ret;
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/index.js
+var require_isexe = __commonJS({
+  "../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/index.js"(exports, module2) {
+    var fs2 = require("fs");
+    var core;
+    if (process.platform === "win32" || global.TESTING_WINDOWS) {
+      core = require_windows();
+    } else {
+      core = require_mode();
+    }
+    module2.exports = isexe;
+    isexe.sync = sync;
+    function isexe(path, options, cb) {
+      if (typeof options === "function") {
+        cb = options;
+        options = {};
+      }
+      if (!cb) {
+        if (typeof Promise !== "function") {
+          throw new TypeError("callback not provided");
+        }
+        return new Promise(function(resolve, reject) {
+          isexe(path, options || {}, function(er, is) {
+            if (er) {
+              reject(er);
+            } else {
+              resolve(is);
+            }
+          });
+        });
+      }
+      core(path, options || {}, function(er, is) {
+        if (er) {
+          if (er.code === "EACCES" || options && options.ignoreErrors) {
+            er = null;
+            is = false;
+          }
+        }
+        cb(er, is);
+      });
+    }
+    function sync(path, options) {
+      try {
+        return core.sync(path, options || {});
+      } catch (er) {
+        if (options && options.ignoreErrors || er.code === "EACCES") {
+          return false;
+        } else {
+          throw er;
+        }
+      }
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/which@1.3.1/node_modules/which/which.js
+var require_which = __commonJS({
+  "../../node_modules/.pnpm/which@1.3.1/node_modules/which/which.js"(exports, module2) {
+    module2.exports = which2;
+    which2.sync = whichSync;
+    var isWindows = process.platform === "win32" || process.env.OSTYPE === "cygwin" || process.env.OSTYPE === "msys";
+    var path = require("path");
+    var COLON = isWindows ? ";" : ":";
+    var isexe = require_isexe();
+    function getNotFoundError(cmd) {
+      var er = new Error("not found: " + cmd);
+      er.code = "ENOENT";
+      return er;
+    }
+    function getPathInfo(cmd, opt) {
+      var colon = opt.colon || COLON;
+      var pathEnv = opt.path || process.env.PATH || "";
+      var pathExt = [""];
+      pathEnv = pathEnv.split(colon);
+      var pathExtExe = "";
+      if (isWindows) {
+        pathEnv.unshift(process.cwd());
+        pathExtExe = opt.pathExt || process.env.PATHEXT || ".EXE;.CMD;.BAT;.COM";
+        pathExt = pathExtExe.split(colon);
+        if (cmd.indexOf(".") !== -1 && pathExt[0] !== "")
+          pathExt.unshift("");
+      }
+      if (cmd.match(/\//) || isWindows && cmd.match(/\\/))
+        pathEnv = [""];
+      return {
+        env: pathEnv,
+        ext: pathExt,
+        extExe: pathExtExe
+      };
+    }
+    function which2(cmd, opt, cb) {
+      if (typeof opt === "function") {
+        cb = opt;
+        opt = {};
+      }
+      var info = getPathInfo(cmd, opt);
+      var pathEnv = info.env;
+      var pathExt = info.ext;
+      var pathExtExe = info.extExe;
+      var found = [];
+      (function F(i, l) {
+        if (i === l) {
+          if (opt.all && found.length)
+            return cb(null, found);
+          else
+            return cb(getNotFoundError(cmd));
+        }
+        var pathPart = pathEnv[i];
+        if (pathPart.charAt(0) === '"' && pathPart.slice(-1) === '"')
+          pathPart = pathPart.slice(1, -1);
+        var p = path.join(pathPart, cmd);
+        if (!pathPart && /^\.[\\\/]/.test(cmd)) {
+          p = cmd.slice(0, 2) + p;
+        }
+        ;
+        (function E(ii, ll) {
+          if (ii === ll)
+            return F(i + 1, l);
+          var ext = pathExt[ii];
+          isexe(p + ext, { pathExt: pathExtExe }, function(er, is) {
+            if (!er && is) {
+              if (opt.all)
+                found.push(p + ext);
+              else
+                return cb(null, p + ext);
+            }
+            return E(ii + 1, ll);
+          });
+        })(0, pathExt.length);
+      })(0, pathEnv.length);
+    }
+    function whichSync(cmd, opt) {
+      opt = opt || {};
+      var info = getPathInfo(cmd, opt);
+      var pathEnv = info.env;
+      var pathExt = info.ext;
+      var pathExtExe = info.extExe;
+      var found = [];
+      for (var i = 0, l = pathEnv.length; i < l; i++) {
+        var pathPart = pathEnv[i];
+        if (pathPart.charAt(0) === '"' && pathPart.slice(-1) === '"')
+          pathPart = pathPart.slice(1, -1);
+        var p = path.join(pathPart, cmd);
+        if (!pathPart && /^\.[\\\/]/.test(cmd)) {
+          p = cmd.slice(0, 2) + p;
+        }
+        for (var j = 0, ll = pathExt.length; j < ll; j++) {
+          var cur = p + pathExt[j];
+          var is;
+          try {
+            is = isexe.sync(cur, { pathExt: pathExtExe });
+            if (is) {
+              if (opt.all)
+                found.push(cur);
+              else
+                return cur;
+            }
+          } catch (ex) {
+          }
+        }
+      }
+      if (opt.all && found.length)
+        return found;
+      if (opt.nothrow)
+        return null;
+      throw getNotFoundError(cmd);
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/path-key@2.0.1/node_modules/path-key/index.js
+var require_path_key = __commonJS({
+  "../../node_modules/.pnpm/path-key@2.0.1/node_modules/path-key/index.js"(exports, module2) {
+    "use strict";
+    module2.exports = (opts) => {
+      opts = opts || {};
+      const env = opts.env || process.env;
+      const platform = opts.platform || process.platform;
+      if (platform !== "win32") {
+        return "PATH";
+      }
+      return Object.keys(env).find((x) => x.toUpperCase() === "PATH") || "Path";
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/cross-spawn@6.0.6/node_modules/cross-spawn/lib/util/resolveCommand.js
+var require_resolveCommand = __commonJS({
+  "../../node_modules/.pnpm/cross-spawn@6.0.6/node_modules/cross-spawn/lib/util/resolveCommand.js"(exports, module2) {
+    "use strict";
+    var path = require("path");
+    var which2 = require_which();
+    var pathKey = require_path_key()();
+    function resolveCommandAttempt(parsed, withoutPathExt) {
+      const cwd = process.cwd();
+      const hasCustomCwd = parsed.options.cwd != null;
+      const shouldSwitchCwd = hasCustomCwd && process.chdir !== void 0;
+      if (shouldSwitchCwd) {
+        try {
+          process.chdir(parsed.options.cwd);
+        } catch (err) {
+        }
+      }
+      let resolved;
+      try {
+        resolved = which2.sync(parsed.command, {
+          path: (parsed.options.env || process.env)[pathKey],
+          pathExt: withoutPathExt ? path.delimiter : void 0
+        });
+      } catch (e) {
+      } finally {
+        if (shouldSwitchCwd) {
+          process.chdir(cwd);
+        }
+      }
+      if (resolved) {
+        resolved = path.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
+      }
+      return resolved;
+    }
+    function resolveCommand(parsed) {
+      return resolveCommandAttempt(parsed) || resolveCommandAttempt(parsed, true);
+    }
+    module2.exports = resolveCommand;
+  }
+});
+
+// ../../node_modules/.pnpm/cross-spawn@6.0.6/node_modules/cross-spawn/lib/util/escape.js
+var require_escape = __commonJS({
+  "../../node_modules/.pnpm/cross-spawn@6.0.6/node_modules/cross-spawn/lib/util/escape.js"(exports, module2) {
+    "use strict";
+    var metaCharsRegExp = /([()\][%!^"`<>&|;, *?])/g;
+    function escapeCommand(arg) {
+      arg = arg.replace(metaCharsRegExp, "^$1");
+      return arg;
+    }
+    function escapeArgument(arg, doubleEscapeMetaChars) {
+      arg = `${arg}`;
+      arg = arg.replace(/(?=(\\+?)?)\1"/g, '$1$1\\"');
+      arg = arg.replace(/(?=(\\+?)?)\1$/, "$1$1");
+      arg = `"${arg}"`;
+      arg = arg.replace(metaCharsRegExp, "^$1");
+      if (doubleEscapeMetaChars) {
+        arg = arg.replace(metaCharsRegExp, "^$1");
+      }
+      return arg;
+    }
+    module2.exports.command = escapeCommand;
+    module2.exports.argument = escapeArgument;
+  }
+});
+
+// ../../node_modules/.pnpm/shebang-regex@1.0.0/node_modules/shebang-regex/index.js
+var require_shebang_regex = __commonJS({
+  "../../node_modules/.pnpm/shebang-regex@1.0.0/node_modules/shebang-regex/index.js"(exports, module2) {
+    "use strict";
+    module2.exports = /^#!.*/;
+  }
+});
+
+// ../../node_modules/.pnpm/shebang-command@1.2.0/node_modules/shebang-command/index.js
+var require_shebang_command = __commonJS({
+  "../../node_modules/.pnpm/shebang-command@1.2.0/node_modules/shebang-command/index.js"(exports, module2) {
+    "use strict";
+    var shebangRegex = require_shebang_regex();
+    module2.exports = function(str) {
+      var match = str.match(shebangRegex);
+      if (!match) {
+        return null;
+      }
+      var arr = match[0].replace(/#! ?/, "").split(" ");
+      var bin = arr[0].split("/").pop();
+      var arg = arr[1];
+      return bin === "env" ? arg : bin + (arg ? " " + arg : "");
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/cross-spawn@6.0.6/node_modules/cross-spawn/lib/util/readShebang.js
+var require_readShebang = __commonJS({
+  "../../node_modules/.pnpm/cross-spawn@6.0.6/node_modules/cross-spawn/lib/util/readShebang.js"(exports, module2) {
+    "use strict";
+    var fs2 = require("fs");
+    var shebangCommand = require_shebang_command();
+    function readShebang(command) {
+      const size = 150;
+      let buffer;
+      if (Buffer.alloc) {
+        buffer = Buffer.alloc(size);
+      } else {
+        buffer = new Buffer(size);
+        buffer.fill(0);
+      }
+      let fd;
+      try {
+        fd = fs2.openSync(command, "r");
+        fs2.readSync(fd, buffer, 0, size, 0);
+        fs2.closeSync(fd);
+      } catch (e) {
+      }
+      return shebangCommand(buffer.toString());
+    }
+    module2.exports = readShebang;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@5.7.2/node_modules/semver/semver.js
+var require_semver = __commonJS({
+  "../../node_modules/.pnpm/semver@5.7.2/node_modules/semver/semver.js"(exports, module2) {
+    exports = module2.exports = SemVer;
+    var debug3;
+    if (typeof process === "object" && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG)) {
+      debug3 = function() {
+        var args = Array.prototype.slice.call(arguments, 0);
+        args.unshift("SEMVER");
+        console.log.apply(console, args);
+      };
+    } else {
+      debug3 = function() {
+      };
+    }
+    exports.SEMVER_SPEC_VERSION = "2.0.0";
+    var MAX_LENGTH = 256;
+    var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || /* istanbul ignore next */
+    9007199254740991;
+    var MAX_SAFE_COMPONENT_LENGTH = 16;
+    var MAX_SAFE_BUILD_LENGTH = MAX_LENGTH - 6;
+    var re = exports.re = [];
+    var safeRe = exports.safeRe = [];
+    var src = exports.src = [];
+    var R = 0;
+    var LETTERDASHNUMBER = "[a-zA-Z0-9-]";
+    var safeRegexReplacements = [
+      ["\\s", 1],
+      ["\\d", MAX_LENGTH],
+      [LETTERDASHNUMBER, MAX_SAFE_BUILD_LENGTH]
+    ];
+    function makeSafeRe(value) {
+      for (var i2 = 0; i2 < safeRegexReplacements.length; i2++) {
+        var token = safeRegexReplacements[i2][0];
+        var max = safeRegexReplacements[i2][1];
+        value = value.split(token + "*").join(token + "{0," + max + "}").split(token + "+").join(token + "{1," + max + "}");
+      }
+      return value;
+    }
+    var NUMERICIDENTIFIER = R++;
+    src[NUMERICIDENTIFIER] = "0|[1-9]\\d*";
+    var NUMERICIDENTIFIERLOOSE = R++;
+    src[NUMERICIDENTIFIERLOOSE] = "\\d+";
+    var NONNUMERICIDENTIFIER = R++;
+    src[NONNUMERICIDENTIFIER] = "\\d*[a-zA-Z-]" + LETTERDASHNUMBER + "*";
+    var MAINVERSION = R++;
+    src[MAINVERSION] = "(" + src[NUMERICIDENTIFIER] + ")\\.(" + src[NUMERICIDENTIFIER] + ")\\.(" + src[NUMERICIDENTIFIER] + ")";
+    var MAINVERSIONLOOSE = R++;
+    src[MAINVERSIONLOOSE] = "(" + src[NUMERICIDENTIFIERLOOSE] + ")\\.(" + src[NUMERICIDENTIFIERLOOSE] + ")\\.(" + src[NUMERICIDENTIFIERLOOSE] + ")";
+    var PRERELEASEIDENTIFIER = R++;
+    src[PRERELEASEIDENTIFIER] = "(?:" + src[NUMERICIDENTIFIER] + "|" + src[NONNUMERICIDENTIFIER] + ")";
+    var PRERELEASEIDENTIFIERLOOSE = R++;
+    src[PRERELEASEIDENTIFIERLOOSE] = "(?:" + src[NUMERICIDENTIFIERLOOSE] + "|" + src[NONNUMERICIDENTIFIER] + ")";
+    var PRERELEASE = R++;
+    src[PRERELEASE] = "(?:-(" + src[PRERELEASEIDENTIFIER] + "(?:\\." + src[PRERELEASEIDENTIFIER] + ")*))";
+    var PRERELEASELOOSE = R++;
+    src[PRERELEASELOOSE] = "(?:-?(" + src[PRERELEASEIDENTIFIERLOOSE] + "(?:\\." + src[PRERELEASEIDENTIFIERLOOSE] + ")*))";
+    var BUILDIDENTIFIER = R++;
+    src[BUILDIDENTIFIER] = LETTERDASHNUMBER + "+";
+    var BUILD = R++;
+    src[BUILD] = "(?:\\+(" + src[BUILDIDENTIFIER] + "(?:\\." + src[BUILDIDENTIFIER] + ")*))";
+    var FULL = R++;
+    var FULLPLAIN = "v?" + src[MAINVERSION] + src[PRERELEASE] + "?" + src[BUILD] + "?";
+    src[FULL] = "^" + FULLPLAIN + "$";
+    var LOOSEPLAIN = "[v=\\s]*" + src[MAINVERSIONLOOSE] + src[PRERELEASELOOSE] + "?" + src[BUILD] + "?";
+    var LOOSE = R++;
+    src[LOOSE] = "^" + LOOSEPLAIN + "$";
+    var GTLT = R++;
+    src[GTLT] = "((?:<|>)?=?)";
+    var XRANGEIDENTIFIERLOOSE = R++;
+    src[XRANGEIDENTIFIERLOOSE] = src[NUMERICIDENTIFIERLOOSE] + "|x|X|\\*";
+    var XRANGEIDENTIFIER = R++;
+    src[XRANGEIDENTIFIER] = src[NUMERICIDENTIFIER] + "|x|X|\\*";
+    var XRANGEPLAIN = R++;
+    src[XRANGEPLAIN] = "[v=\\s]*(" + src[XRANGEIDENTIFIER] + ")(?:\\.(" + src[XRANGEIDENTIFIER] + ")(?:\\.(" + src[XRANGEIDENTIFIER] + ")(?:" + src[PRERELEASE] + ")?" + src[BUILD] + "?)?)?";
+    var XRANGEPLAINLOOSE = R++;
+    src[XRANGEPLAINLOOSE] = "[v=\\s]*(" + src[XRANGEIDENTIFIERLOOSE] + ")(?:\\.(" + src[XRANGEIDENTIFIERLOOSE] + ")(?:\\.(" + src[XRANGEIDENTIFIERLOOSE] + ")(?:" + src[PRERELEASELOOSE] + ")?" + src[BUILD] + "?)?)?";
+    var XRANGE = R++;
+    src[XRANGE] = "^" + src[GTLT] + "\\s*" + src[XRANGEPLAIN] + "$";
+    var XRANGELOOSE = R++;
+    src[XRANGELOOSE] = "^" + src[GTLT] + "\\s*" + src[XRANGEPLAINLOOSE] + "$";
+    var COERCE = R++;
+    src[COERCE] = "(?:^|[^\\d])(\\d{1," + MAX_SAFE_COMPONENT_LENGTH + "})(?:\\.(\\d{1," + MAX_SAFE_COMPONENT_LENGTH + "}))?(?:\\.(\\d{1," + MAX_SAFE_COMPONENT_LENGTH + "}))?(?:$|[^\\d])";
+    var LONETILDE = R++;
+    src[LONETILDE] = "(?:~>?)";
+    var TILDETRIM = R++;
+    src[TILDETRIM] = "(\\s*)" + src[LONETILDE] + "\\s+";
+    re[TILDETRIM] = new RegExp(src[TILDETRIM], "g");
+    safeRe[TILDETRIM] = new RegExp(makeSafeRe(src[TILDETRIM]), "g");
+    var tildeTrimReplace = "$1~";
+    var TILDE = R++;
+    src[TILDE] = "^" + src[LONETILDE] + src[XRANGEPLAIN] + "$";
+    var TILDELOOSE = R++;
+    src[TILDELOOSE] = "^" + src[LONETILDE] + src[XRANGEPLAINLOOSE] + "$";
+    var LONECARET = R++;
+    src[LONECARET] = "(?:\\^)";
+    var CARETTRIM = R++;
+    src[CARETTRIM] = "(\\s*)" + src[LONECARET] + "\\s+";
+    re[CARETTRIM] = new RegExp(src[CARETTRIM], "g");
+    safeRe[CARETTRIM] = new RegExp(makeSafeRe(src[CARETTRIM]), "g");
+    var caretTrimReplace = "$1^";
+    var CARET = R++;
+    src[CARET] = "^" + src[LONECARET] + src[XRANGEPLAIN] + "$";
+    var CARETLOOSE = R++;
+    src[CARETLOOSE] = "^" + src[LONECARET] + src[XRANGEPLAINLOOSE] + "$";
+    var COMPARATORLOOSE = R++;
+    src[COMPARATORLOOSE] = "^" + src[GTLT] + "\\s*(" + LOOSEPLAIN + ")$|^$";
+    var COMPARATOR = R++;
+    src[COMPARATOR] = "^" + src[GTLT] + "\\s*(" + FULLPLAIN + ")$|^$";
+    var COMPARATORTRIM = R++;
+    src[COMPARATORTRIM] = "(\\s*)" + src[GTLT] + "\\s*(" + LOOSEPLAIN + "|" + src[XRANGEPLAIN] + ")";
+    re[COMPARATORTRIM] = new RegExp(src[COMPARATORTRIM], "g");
+    safeRe[COMPARATORTRIM] = new RegExp(makeSafeRe(src[COMPARATORTRIM]), "g");
+    var comparatorTrimReplace = "$1$2$3";
+    var HYPHENRANGE = R++;
+    src[HYPHENRANGE] = "^\\s*(" + src[XRANGEPLAIN] + ")\\s+-\\s+(" + src[XRANGEPLAIN] + ")\\s*$";
+    var HYPHENRANGELOOSE = R++;
+    src[HYPHENRANGELOOSE] = "^\\s*(" + src[XRANGEPLAINLOOSE] + ")\\s+-\\s+(" + src[XRANGEPLAINLOOSE] + ")\\s*$";
+    var STAR = R++;
+    src[STAR] = "(<|>)?=?\\s*\\*";
+    for (i = 0; i < R; i++) {
+      debug3(i, src[i]);
+      if (!re[i]) {
+        re[i] = new RegExp(src[i]);
+        safeRe[i] = new RegExp(makeSafeRe(src[i]));
+      }
+    }
+    var i;
+    exports.parse = parse;
+    function parse(version2, options) {
+      if (!options || typeof options !== "object") {
+        options = {
+          loose: !!options,
+          includePrerelease: false
+        };
+      }
+      if (version2 instanceof SemVer) {
+        return version2;
+      }
+      if (typeof version2 !== "string") {
+        return null;
+      }
+      if (version2.length > MAX_LENGTH) {
+        return null;
+      }
+      var r = options.loose ? safeRe[LOOSE] : safeRe[FULL];
+      if (!r.test(version2)) {
+        return null;
+      }
+      try {
+        return new SemVer(version2, options);
+      } catch (er) {
+        return null;
+      }
+    }
+    exports.valid = valid;
+    function valid(version2, options) {
+      var v = parse(version2, options);
+      return v ? v.version : null;
+    }
+    exports.clean = clean;
+    function clean(version2, options) {
+      var s = parse(version2.trim().replace(/^[=v]+/, ""), options);
+      return s ? s.version : null;
+    }
+    exports.SemVer = SemVer;
+    function SemVer(version2, options) {
+      if (!options || typeof options !== "object") {
+        options = {
+          loose: !!options,
+          includePrerelease: false
+        };
+      }
+      if (version2 instanceof SemVer) {
+        if (version2.loose === options.loose) {
+          return version2;
+        } else {
+          version2 = version2.version;
+        }
+      } else if (typeof version2 !== "string") {
+        throw new TypeError("Invalid Version: " + version2);
+      }
+      if (version2.length > MAX_LENGTH) {
+        throw new TypeError("version is longer than " + MAX_LENGTH + " characters");
+      }
+      if (!(this instanceof SemVer)) {
+        return new SemVer(version2, options);
+      }
+      debug3("SemVer", version2, options);
+      this.options = options;
+      this.loose = !!options.loose;
+      var m = version2.trim().match(options.loose ? safeRe[LOOSE] : safeRe[FULL]);
+      if (!m) {
+        throw new TypeError("Invalid Version: " + version2);
+      }
+      this.raw = version2;
+      this.major = +m[1];
+      this.minor = +m[2];
+      this.patch = +m[3];
+      if (this.major > MAX_SAFE_INTEGER || this.major < 0) {
+        throw new TypeError("Invalid major version");
+      }
+      if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) {
+        throw new TypeError("Invalid minor version");
+      }
+      if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) {
+        throw new TypeError("Invalid patch version");
+      }
+      if (!m[4]) {
+        this.prerelease = [];
+      } else {
+        this.prerelease = m[4].split(".").map(function(id) {
+          if (/^[0-9]+$/.test(id)) {
+            var num = +id;
+            if (num >= 0 && num < MAX_SAFE_INTEGER) {
+              return num;
+            }
+          }
+          return id;
+        });
+      }
+      this.build = m[5] ? m[5].split(".") : [];
+      this.format();
+    }
+    SemVer.prototype.format = function() {
+      this.version = this.major + "." + this.minor + "." + this.patch;
+      if (this.prerelease.length) {
+        this.version += "-" + this.prerelease.join(".");
+      }
+      return this.version;
+    };
+    SemVer.prototype.toString = function() {
+      return this.version;
+    };
+    SemVer.prototype.compare = function(other) {
+      debug3("SemVer.compare", this.version, this.options, other);
+      if (!(other instanceof SemVer)) {
+        other = new SemVer(other, this.options);
+      }
+      return this.compareMain(other) || this.comparePre(other);
+    };
+    SemVer.prototype.compareMain = function(other) {
+      if (!(other instanceof SemVer)) {
+        other = new SemVer(other, this.options);
+      }
+      return compareIdentifiers(this.major, other.major) || compareIdentifiers(this.minor, other.minor) || compareIdentifiers(this.patch, other.patch);
+    };
+    SemVer.prototype.comparePre = function(other) {
+      if (!(other instanceof SemVer)) {
+        other = new SemVer(other, this.options);
+      }
+      if (this.prerelease.length && !other.prerelease.length) {
+        return -1;
+      } else if (!this.prerelease.length && other.prerelease.length) {
+        return 1;
+      } else if (!this.prerelease.length && !other.prerelease.length) {
+        return 0;
+      }
+      var i2 = 0;
+      do {
+        var a = this.prerelease[i2];
+        var b = other.prerelease[i2];
+        debug3("prerelease compare", i2, a, b);
+        if (a === void 0 && b === void 0) {
+          return 0;
+        } else if (b === void 0) {
+          return 1;
+        } else if (a === void 0) {
+          return -1;
+        } else if (a === b) {
+          continue;
+        } else {
+          return compareIdentifiers(a, b);
+        }
+      } while (++i2);
+    };
+    SemVer.prototype.inc = function(release, identifier) {
+      switch (release) {
+        case "premajor":
+          this.prerelease.length = 0;
+          this.patch = 0;
+          this.minor = 0;
+          this.major++;
+          this.inc("pre", identifier);
+          break;
+        case "preminor":
+          this.prerelease.length = 0;
+          this.patch = 0;
+          this.minor++;
+          this.inc("pre", identifier);
+          break;
+        case "prepatch":
+          this.prerelease.length = 0;
+          this.inc("patch", identifier);
+          this.inc("pre", identifier);
+          break;
+        case "prerelease":
+          if (this.prerelease.length === 0) {
+            this.inc("patch", identifier);
+          }
+          this.inc("pre", identifier);
+          break;
+        case "major":
+          if (this.minor !== 0 || this.patch !== 0 || this.prerelease.length === 0) {
+            this.major++;
+          }
+          this.minor = 0;
+          this.patch = 0;
+          this.prerelease = [];
+          break;
+        case "minor":
+          if (this.patch !== 0 || this.prerelease.length === 0) {
+            this.minor++;
+          }
+          this.patch = 0;
+          this.prerelease = [];
+          break;
+        case "patch":
+          if (this.prerelease.length === 0) {
+            this.patch++;
+          }
+          this.prerelease = [];
+          break;
+        case "pre":
+          if (this.prerelease.length === 0) {
+            this.prerelease = [0];
+          } else {
+            var i2 = this.prerelease.length;
+            while (--i2 >= 0) {
+              if (typeof this.prerelease[i2] === "number") {
+                this.prerelease[i2]++;
+                i2 = -2;
+              }
+            }
+            if (i2 === -1) {
+              this.prerelease.push(0);
+            }
+          }
+          if (identifier) {
+            if (this.prerelease[0] === identifier) {
+              if (isNaN(this.prerelease[1])) {
+                this.prerelease = [identifier, 0];
+              }
+            } else {
+              this.prerelease = [identifier, 0];
+            }
+          }
+          break;
+        default:
+          throw new Error("invalid increment argument: " + release);
+      }
+      this.format();
+      this.raw = this.version;
+      return this;
+    };
+    exports.inc = inc;
+    function inc(version2, release, loose, identifier) {
+      if (typeof loose === "string") {
+        identifier = loose;
+        loose = void 0;
+      }
+      try {
+        return new SemVer(version2, loose).inc(release, identifier).version;
+      } catch (er) {
+        return null;
+      }
+    }
+    exports.diff = diff;
+    function diff(version1, version2) {
+      if (eq(version1, version2)) {
+        return null;
+      } else {
+        var v1 = parse(version1);
+        var v2 = parse(version2);
+        var prefix = "";
+        if (v1.prerelease.length || v2.prerelease.length) {
+          prefix = "pre";
+          var defaultResult = "prerelease";
+        }
+        for (var key in v1) {
+          if (key === "major" || key === "minor" || key === "patch") {
+            if (v1[key] !== v2[key]) {
+              return prefix + key;
+            }
+          }
+        }
+        return defaultResult;
+      }
+    }
+    exports.compareIdentifiers = compareIdentifiers;
+    var numeric = /^[0-9]+$/;
+    function compareIdentifiers(a, b) {
+      var anum = numeric.test(a);
+      var bnum = numeric.test(b);
+      if (anum && bnum) {
+        a = +a;
+        b = +b;
+      }
+      return a === b ? 0 : anum && !bnum ? -1 : bnum && !anum ? 1 : a < b ? -1 : 1;
+    }
+    exports.rcompareIdentifiers = rcompareIdentifiers;
+    function rcompareIdentifiers(a, b) {
+      return compareIdentifiers(b, a);
+    }
+    exports.major = major;
+    function major(a, loose) {
+      return new SemVer(a, loose).major;
+    }
+    exports.minor = minor;
+    function minor(a, loose) {
+      return new SemVer(a, loose).minor;
+    }
+    exports.patch = patch;
+    function patch(a, loose) {
+      return new SemVer(a, loose).patch;
+    }
+    exports.compare = compare;
+    function compare(a, b, loose) {
+      return new SemVer(a, loose).compare(new SemVer(b, loose));
+    }
+    exports.compareLoose = compareLoose;
+    function compareLoose(a, b) {
+      return compare(a, b, true);
+    }
+    exports.rcompare = rcompare;
+    function rcompare(a, b, loose) {
+      return compare(b, a, loose);
+    }
+    exports.sort = sort;
+    function sort(list, loose) {
+      return list.sort(function(a, b) {
+        return exports.compare(a, b, loose);
+      });
+    }
+    exports.rsort = rsort;
+    function rsort(list, loose) {
+      return list.sort(function(a, b) {
+        return exports.rcompare(a, b, loose);
+      });
+    }
+    exports.gt = gt;
+    function gt(a, b, loose) {
+      return compare(a, b, loose) > 0;
+    }
+    exports.lt = lt;
+    function lt(a, b, loose) {
+      return compare(a, b, loose) < 0;
+    }
+    exports.eq = eq;
+    function eq(a, b, loose) {
+      return compare(a, b, loose) === 0;
+    }
+    exports.neq = neq;
+    function neq(a, b, loose) {
+      return compare(a, b, loose) !== 0;
+    }
+    exports.gte = gte;
+    function gte(a, b, loose) {
+      return compare(a, b, loose) >= 0;
+    }
+    exports.lte = lte;
+    function lte(a, b, loose) {
+      return compare(a, b, loose) <= 0;
+    }
+    exports.cmp = cmp;
+    function cmp(a, op, b, loose) {
+      switch (op) {
+        case "===":
+          if (typeof a === "object")
+            a = a.version;
+          if (typeof b === "object")
+            b = b.version;
+          return a === b;
+        case "!==":
+          if (typeof a === "object")
+            a = a.version;
+          if (typeof b === "object")
+            b = b.version;
+          return a !== b;
+        case "":
+        case "=":
+        case "==":
+          return eq(a, b, loose);
+        case "!=":
+          return neq(a, b, loose);
+        case ">":
+          return gt(a, b, loose);
+        case ">=":
+          return gte(a, b, loose);
+        case "<":
+          return lt(a, b, loose);
+        case "<=":
+          return lte(a, b, loose);
+        default:
+          throw new TypeError("Invalid operator: " + op);
+      }
+    }
+    exports.Comparator = Comparator;
+    function Comparator(comp, options) {
+      if (!options || typeof options !== "object") {
+        options = {
+          loose: !!options,
+          includePrerelease: false
+        };
+      }
+      if (comp instanceof Comparator) {
+        if (comp.loose === !!options.loose) {
+          return comp;
+        } else {
+          comp = comp.value;
+        }
+      }
+      if (!(this instanceof Comparator)) {
+        return new Comparator(comp, options);
+      }
+      comp = comp.trim().split(/\s+/).join(" ");
+      debug3("comparator", comp, options);
+      this.options = options;
+      this.loose = !!options.loose;
+      this.parse(comp);
+      if (this.semver === ANY) {
+        this.value = "";
+      } else {
+        this.value = this.operator + this.semver.version;
+      }
+      debug3("comp", this);
+    }
+    var ANY = {};
+    Comparator.prototype.parse = function(comp) {
+      var r = this.options.loose ? safeRe[COMPARATORLOOSE] : safeRe[COMPARATOR];
+      var m = comp.match(r);
+      if (!m) {
+        throw new TypeError("Invalid comparator: " + comp);
+      }
+      this.operator = m[1];
+      if (this.operator === "=") {
+        this.operator = "";
+      }
+      if (!m[2]) {
+        this.semver = ANY;
+      } else {
+        this.semver = new SemVer(m[2], this.options.loose);
+      }
+    };
+    Comparator.prototype.toString = function() {
+      return this.value;
+    };
+    Comparator.prototype.test = function(version2) {
+      debug3("Comparator.test", version2, this.options.loose);
+      if (this.semver === ANY) {
+        return true;
+      }
+      if (typeof version2 === "string") {
+        version2 = new SemVer(version2, this.options);
+      }
+      return cmp(version2, this.operator, this.semver, this.options);
+    };
+    Comparator.prototype.intersects = function(comp, options) {
+      if (!(comp instanceof Comparator)) {
+        throw new TypeError("a Comparator is required");
+      }
+      if (!options || typeof options !== "object") {
+        options = {
+          loose: !!options,
+          includePrerelease: false
+        };
+      }
+      var rangeTmp;
+      if (this.operator === "") {
+        rangeTmp = new Range(comp.value, options);
+        return satisfies(this.value, rangeTmp, options);
+      } else if (comp.operator === "") {
+        rangeTmp = new Range(this.value, options);
+        return satisfies(comp.semver, rangeTmp, options);
+      }
+      var sameDirectionIncreasing = (this.operator === ">=" || this.operator === ">") && (comp.operator === ">=" || comp.operator === ">");
+      var sameDirectionDecreasing = (this.operator === "<=" || this.operator === "<") && (comp.operator === "<=" || comp.operator === "<");
+      var sameSemVer = this.semver.version === comp.semver.version;
+      var differentDirectionsInclusive = (this.operator === ">=" || this.operator === "<=") && (comp.operator === ">=" || comp.operator === "<=");
+      var oppositeDirectionsLessThan = cmp(this.semver, "<", comp.semver, options) && ((this.operator === ">=" || this.operator === ">") && (comp.operator === "<=" || comp.operator === "<"));
+      var oppositeDirectionsGreaterThan = cmp(this.semver, ">", comp.semver, options) && ((this.operator === "<=" || this.operator === "<") && (comp.operator === ">=" || comp.operator === ">"));
+      return sameDirectionIncreasing || sameDirectionDecreasing || sameSemVer && differentDirectionsInclusive || oppositeDirectionsLessThan || oppositeDirectionsGreaterThan;
+    };
+    exports.Range = Range;
+    function Range(range, options) {
+      if (!options || typeof options !== "object") {
+        options = {
+          loose: !!options,
+          includePrerelease: false
+        };
+      }
+      if (range instanceof Range) {
+        if (range.loose === !!options.loose && range.includePrerelease === !!options.includePrerelease) {
+          return range;
+        } else {
+          return new Range(range.raw, options);
+        }
+      }
+      if (range instanceof Comparator) {
+        return new Range(range.value, options);
+      }
+      if (!(this instanceof Range)) {
+        return new Range(range, options);
+      }
+      this.options = options;
+      this.loose = !!options.loose;
+      this.includePrerelease = !!options.includePrerelease;
+      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;
+      });
+      if (!this.set.length) {
+        throw new TypeError("Invalid SemVer Range: " + this.raw);
+      }
+      this.format();
+    }
+    Range.prototype.format = function() {
+      this.range = this.set.map(function(comps) {
+        return comps.join(" ").trim();
+      }).join("||").trim();
+      return this.range;
+    };
+    Range.prototype.toString = function() {
+      return this.range;
+    };
+    Range.prototype.parseRange = function(range) {
+      var loose = this.options.loose;
+      var hr = loose ? safeRe[HYPHENRANGELOOSE] : safeRe[HYPHENRANGE];
+      range = range.replace(hr, hyphenReplace);
+      debug3("hyphen replace", range);
+      range = range.replace(safeRe[COMPARATORTRIM], comparatorTrimReplace);
+      debug3("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 = range.split(" ").map(function(comp) {
+        return parseComparator(comp, this.options);
+      }, this).join(" ").split(/\s+/);
+      if (this.options.loose) {
+        set = set.filter(function(comp) {
+          return !!comp.match(compRe);
+        });
+      }
+      set = set.map(function(comp) {
+        return new Comparator(comp, this.options);
+      }, this);
+      return set;
+    };
+    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 range.set.some(function(rangeComparators) {
+            return rangeComparators.every(function(rangeComparator) {
+              return thisComparator.intersects(rangeComparator, options);
+            });
+          });
+        });
+      });
+    };
+    exports.toComparators = toComparators;
+    function toComparators(range, options) {
+      return new Range(range, options).set.map(function(comp) {
+        return comp.map(function(c) {
+          return c.value;
+        }).join(" ").trim().split(" ");
+      });
+    }
+    function parseComparator(comp, options) {
+      debug3("comp", comp, options);
+      comp = replaceCarets(comp, options);
+      debug3("caret", comp);
+      comp = replaceTildes(comp, options);
+      debug3("tildes", comp);
+      comp = replaceXRanges(comp, options);
+      debug3("xrange", comp);
+      comp = replaceStars(comp, options);
+      debug3("stars", comp);
+      return comp;
+    }
+    function isX(id) {
+      return !id || id.toLowerCase() === "x" || id === "*";
+    }
+    function replaceTildes(comp, options) {
+      return comp.trim().split(/\s+/).map(function(comp2) {
+        return replaceTilde(comp2, options);
+      }).join(" ");
+    }
+    function replaceTilde(comp, options) {
+      var r = options.loose ? safeRe[TILDELOOSE] : safeRe[TILDE];
+      return comp.replace(r, function(_, M, m, p, pr) {
+        debug3("tilde", comp, _, M, m, p, pr);
+        var ret;
+        if (isX(M)) {
+          ret = "";
+        } else if (isX(m)) {
+          ret = ">=" + M + ".0.0 <" + (+M + 1) + ".0.0";
+        } else if (isX(p)) {
+          ret = ">=" + M + "." + m + ".0 <" + M + "." + (+m + 1) + ".0";
+        } else if (pr) {
+          debug3("replaceTilde pr", pr);
+          ret = ">=" + M + "." + m + "." + p + "-" + pr + " <" + M + "." + (+m + 1) + ".0";
+        } else {
+          ret = ">=" + M + "." + m + "." + p + " <" + M + "." + (+m + 1) + ".0";
+        }
+        debug3("tilde return", ret);
+        return ret;
+      });
+    }
+    function replaceCarets(comp, options) {
+      return comp.trim().split(/\s+/).map(function(comp2) {
+        return replaceCaret(comp2, options);
+      }).join(" ");
+    }
+    function replaceCaret(comp, options) {
+      debug3("caret", comp, options);
+      var r = options.loose ? safeRe[CARETLOOSE] : safeRe[CARET];
+      return comp.replace(r, function(_, M, m, p, pr) {
+        debug3("caret", comp, _, M, m, p, pr);
+        var ret;
+        if (isX(M)) {
+          ret = "";
+        } else if (isX(m)) {
+          ret = ">=" + M + ".0.0 <" + (+M + 1) + ".0.0";
+        } else if (isX(p)) {
+          if (M === "0") {
+            ret = ">=" + M + "." + m + ".0 <" + M + "." + (+m + 1) + ".0";
+          } else {
+            ret = ">=" + M + "." + m + ".0 <" + (+M + 1) + ".0.0";
+          }
+        } else if (pr) {
+          debug3("replaceCaret pr", pr);
+          if (M === "0") {
+            if (m === "0") {
+              ret = ">=" + M + "." + m + "." + p + "-" + pr + " <" + M + "." + m + "." + (+p + 1);
+            } else {
+              ret = ">=" + M + "." + m + "." + p + "-" + pr + " <" + M + "." + (+m + 1) + ".0";
+            }
+          } else {
+            ret = ">=" + M + "." + m + "." + p + "-" + pr + " <" + (+M + 1) + ".0.0";
+          }
+        } else {
+          debug3("no pr");
+          if (M === "0") {
+            if (m === "0") {
+              ret = ">=" + M + "." + m + "." + p + " <" + M + "." + m + "." + (+p + 1);
+            } else {
+              ret = ">=" + M + "." + m + "." + p + " <" + M + "." + (+m + 1) + ".0";
+            }
+          } else {
+            ret = ">=" + M + "." + m + "." + p + " <" + (+M + 1) + ".0.0";
+          }
+        }
+        debug3("caret return", ret);
+        return ret;
+      });
+    }
+    function replaceXRanges(comp, options) {
+      debug3("replaceXRanges", comp, options);
+      return comp.split(/\s+/).map(function(comp2) {
+        return replaceXRange(comp2, options);
+      }).join(" ");
+    }
+    function replaceXRange(comp, options) {
+      comp = comp.trim();
+      var r = options.loose ? safeRe[XRANGELOOSE] : safeRe[XRANGE];
+      return comp.replace(r, function(ret, gtlt, M, m, p, pr) {
+        debug3("xRange", comp, ret, gtlt, M, m, p, pr);
+        var xM = isX(M);
+        var xm = xM || isX(m);
+        var xp = xm || isX(p);
+        var anyX = xp;
+        if (gtlt === "=" && anyX) {
+          gtlt = "";
+        }
+        if (xM) {
+          if (gtlt === ">" || gtlt === "<") {
+            ret = "<0.0.0";
+          } else {
+            ret = "*";
+          }
+        } else if (gtlt && anyX) {
+          if (xm) {
+            m = 0;
+          }
+          p = 0;
+          if (gtlt === ">") {
+            gtlt = ">=";
+            if (xm) {
+              M = +M + 1;
+              m = 0;
+              p = 0;
+            } else {
+              m = +m + 1;
+              p = 0;
+            }
+          } else if (gtlt === "<=") {
+            gtlt = "<";
+            if (xm) {
+              M = +M + 1;
+            } else {
+              m = +m + 1;
+            }
+          }
+          ret = gtlt + M + "." + m + "." + p;
+        } else if (xm) {
+          ret = ">=" + M + ".0.0 <" + (+M + 1) + ".0.0";
+        } else if (xp) {
+          ret = ">=" + M + "." + m + ".0 <" + M + "." + (+m + 1) + ".0";
+        }
+        debug3("xRange return", ret);
+        return ret;
+      });
+    }
+    function replaceStars(comp, options) {
+      debug3("replaceStars", comp, options);
+      return comp.trim().replace(safeRe[STAR], "");
+    }
+    function hyphenReplace($0, from, fM, fm, fp, fpr, fb, to, tM, tm, tp, tpr, tb) {
+      if (isX(fM)) {
+        from = "";
+      } else if (isX(fm)) {
+        from = ">=" + fM + ".0.0";
+      } else if (isX(fp)) {
+        from = ">=" + fM + "." + fm + ".0";
+      } else {
+        from = ">=" + from;
+      }
+      if (isX(tM)) {
+        to = "";
+      } else if (isX(tm)) {
+        to = "<" + (+tM + 1) + ".0.0";
+      } else if (isX(tp)) {
+        to = "<" + tM + "." + (+tm + 1) + ".0";
+      } else if (tpr) {
+        to = "<=" + tM + "." + tm + "." + tp + "-" + tpr;
+      } else {
+        to = "<=" + to;
+      }
+      return (from + " " + to).trim();
+    }
+    Range.prototype.test = function(version2) {
+      if (!version2) {
+        return false;
+      }
+      if (typeof version2 === "string") {
+        version2 = new SemVer(version2, this.options);
+      }
+      for (var i2 = 0; i2 < this.set.length; i2++) {
+        if (testSet(this.set[i2], version2, this.options)) {
+          return true;
+        }
+      }
+      return false;
+    };
+    function testSet(set, version2, options) {
+      for (var i2 = 0; i2 < set.length; i2++) {
+        if (!set[i2].test(version2)) {
+          return false;
+        }
+      }
+      if (version2.prerelease.length && !options.includePrerelease) {
+        for (i2 = 0; i2 < set.length; i2++) {
+          debug3(set[i2].semver);
+          if (set[i2].semver === ANY) {
+            continue;
+          }
+          if (set[i2].semver.prerelease.length > 0) {
+            var allowed = set[i2].semver;
+            if (allowed.major === version2.major && allowed.minor === version2.minor && allowed.patch === version2.patch) {
+              return true;
+            }
+          }
+        }
+        return false;
+      }
+      return true;
+    }
+    exports.satisfies = satisfies;
+    function satisfies(version2, range, options) {
+      try {
+        range = new Range(range, options);
+      } catch (er) {
+        return false;
+      }
+      return range.test(version2);
+    }
+    exports.maxSatisfying = maxSatisfying;
+    function maxSatisfying(versions, range, options) {
+      var max = null;
+      var maxSV = null;
+      try {
+        var rangeObj = new Range(range, options);
+      } catch (er) {
+        return null;
+      }
+      versions.forEach(function(v) {
+        if (rangeObj.test(v)) {
+          if (!max || maxSV.compare(v) === -1) {
+            max = v;
+            maxSV = new SemVer(max, options);
+          }
+        }
+      });
+      return max;
+    }
+    exports.minSatisfying = minSatisfying;
+    function minSatisfying(versions, range, options) {
+      var min = null;
+      var minSV = null;
+      try {
+        var rangeObj = new Range(range, options);
+      } catch (er) {
+        return null;
+      }
+      versions.forEach(function(v) {
+        if (rangeObj.test(v)) {
+          if (!min || minSV.compare(v) === 1) {
+            min = v;
+            minSV = new SemVer(min, options);
+          }
+        }
+      });
+      return min;
+    }
+    exports.minVersion = minVersion;
+    function minVersion(range, loose) {
+      range = new Range(range, loose);
+      var minver = new SemVer("0.0.0");
+      if (range.test(minver)) {
+        return minver;
+      }
+      minver = new SemVer("0.0.0-0");
+      if (range.test(minver)) {
+        return minver;
+      }
+      minver = null;
+      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) {
+            case ">":
+              if (compver.prerelease.length === 0) {
+                compver.patch++;
+              } else {
+                compver.prerelease.push(0);
+              }
+              compver.raw = compver.format();
+            case "":
+            case ">=":
+              if (!minver || gt(minver, compver)) {
+                minver = compver;
+              }
+              break;
+            case "<":
+            case "<=":
+              break;
+            default:
+              throw new Error("Unexpected operation: " + comparator.operator);
+          }
+        });
+      }
+      if (minver && range.test(minver)) {
+        return minver;
+      }
+      return null;
+    }
+    exports.validRange = validRange;
+    function validRange(range, options) {
+      try {
+        return new Range(range, options).range || "*";
+      } catch (er) {
+        return null;
+      }
+    }
+    exports.ltr = ltr;
+    function ltr(version2, range, options) {
+      return outside(version2, range, "<", options);
+    }
+    exports.gtr = gtr;
+    function gtr(version2, range, options) {
+      return outside(version2, range, ">", options);
+    }
+    exports.outside = outside;
+    function outside(version2, range, hilo, options) {
+      version2 = new SemVer(version2, options);
+      range = new Range(range, options);
+      var gtfn, ltefn, ltfn, comp, ecomp;
+      switch (hilo) {
+        case ">":
+          gtfn = gt;
+          ltefn = lte;
+          ltfn = lt;
+          comp = ">";
+          ecomp = ">=";
+          break;
+        case "<":
+          gtfn = lt;
+          ltefn = gte;
+          ltfn = gt;
+          comp = "<";
+          ecomp = "<=";
+          break;
+        default:
+          throw new TypeError('Must provide a hilo val of "<" or ">"');
+      }
+      if (satisfies(version2, range, options)) {
+        return false;
+      }
+      for (var i2 = 0; i2 < range.set.length; ++i2) {
+        var comparators = range.set[i2];
+        var high = null;
+        var low = null;
+        comparators.forEach(function(comparator) {
+          if (comparator.semver === ANY) {
+            comparator = new Comparator(">=0.0.0");
+          }
+          high = high || comparator;
+          low = low || comparator;
+          if (gtfn(comparator.semver, high.semver, options)) {
+            high = comparator;
+          } else if (ltfn(comparator.semver, low.semver, options)) {
+            low = comparator;
+          }
+        });
+        if (high.operator === comp || high.operator === ecomp) {
+          return false;
+        }
+        if ((!low.operator || low.operator === comp) && ltefn(version2, low.semver)) {
+          return false;
+        } else if (low.operator === ecomp && ltfn(version2, low.semver)) {
+          return false;
+        }
+      }
+      return true;
+    }
+    exports.prerelease = prerelease;
+    function prerelease(version2, options) {
+      var parsed = parse(version2, options);
+      return parsed && parsed.prerelease.length ? parsed.prerelease : null;
+    }
+    exports.intersects = intersects;
+    function intersects(r1, r2, options) {
+      r1 = new Range(r1, options);
+      r2 = new Range(r2, options);
+      return r1.intersects(r2);
+    }
+    exports.coerce = coerce;
+    function coerce(version2) {
+      if (version2 instanceof SemVer) {
+        return version2;
+      }
+      if (typeof version2 !== "string") {
+        return null;
+      }
+      var match = version2.match(safeRe[COERCE]);
+      if (match == null) {
+        return null;
+      }
+      return parse(match[1] + "." + (match[2] || "0") + "." + (match[3] || "0"));
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/cross-spawn@6.0.6/node_modules/cross-spawn/lib/parse.js
+var require_parse = __commonJS({
+  "../../node_modules/.pnpm/cross-spawn@6.0.6/node_modules/cross-spawn/lib/parse.js"(exports, module2) {
+    "use strict";
+    var path = require("path");
+    var niceTry = require_src();
+    var resolveCommand = require_resolveCommand();
+    var escape = require_escape();
+    var readShebang = require_readShebang();
+    var semver = require_semver();
+    var isWin = process.platform === "win32";
+    var isExecutableRegExp = /\.(?:com|exe)$/i;
+    var isCmdShimRegExp = /node_modules[\\/].bin[\\/][^\\/]+\.cmd$/i;
+    var supportsShellOption = niceTry(() => semver.satisfies(process.version, "^4.8.0 || ^5.7.0 || >= 6.0.0", true)) || false;
+    function detectShebang(parsed) {
+      parsed.file = resolveCommand(parsed);
+      const shebang = parsed.file && readShebang(parsed.file);
+      if (shebang) {
+        parsed.args.unshift(parsed.file);
+        parsed.command = shebang;
+        return resolveCommand(parsed);
+      }
+      return parsed.file;
+    }
+    function parseNonShell(parsed) {
+      if (!isWin) {
+        return parsed;
+      }
+      const commandFile = detectShebang(parsed);
+      const needsShell = !isExecutableRegExp.test(commandFile);
+      if (parsed.options.forceShell || needsShell) {
+        const needsDoubleEscapeMetaChars = isCmdShimRegExp.test(commandFile);
+        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";
+        parsed.options.windowsVerbatimArguments = true;
+      }
+      return parsed;
+    }
+    function parseShell(parsed) {
+      if (supportsShellOption) {
+        return parsed;
+      }
+      const shellCommand = [parsed.command].concat(parsed.args).join(" ");
+      if (isWin) {
+        parsed.command = typeof parsed.options.shell === "string" ? parsed.options.shell : process.env.comspec || "cmd.exe";
+        parsed.args = ["/d", "/s", "/c", `"${shellCommand}"`];
+        parsed.options.windowsVerbatimArguments = true;
+      } else {
+        if (typeof parsed.options.shell === "string") {
+          parsed.command = parsed.options.shell;
+        } else if (process.platform === "android") {
+          parsed.command = "/system/bin/sh";
+        } else {
+          parsed.command = "/bin/sh";
+        }
+        parsed.args = ["-c", shellCommand];
+      }
+      return parsed;
+    }
+    function parse(command, args, options) {
+      if (args && !Array.isArray(args)) {
+        options = args;
+        args = null;
+      }
+      args = args ? args.slice(0) : [];
+      options = Object.assign({}, options);
+      const parsed = {
+        command,
+        args,
+        options,
+        file: void 0,
+        original: {
+          command,
+          args
+        }
+      };
+      return options.shell ? parseShell(parsed) : parseNonShell(parsed);
+    }
+    module2.exports = parse;
+  }
+});
+
+// ../../node_modules/.pnpm/cross-spawn@6.0.6/node_modules/cross-spawn/lib/enoent.js
+var require_enoent = __commonJS({
+  "../../node_modules/.pnpm/cross-spawn@6.0.6/node_modules/cross-spawn/lib/enoent.js"(exports, module2) {
+    "use strict";
+    var isWin = process.platform === "win32";
+    function notFoundError(original, syscall) {
+      return Object.assign(new Error(`${syscall} ${original.command} ENOENT`), {
+        code: "ENOENT",
+        errno: "ENOENT",
+        syscall: `${syscall} ${original.command}`,
+        path: original.command,
+        spawnargs: original.args
+      });
+    }
+    function hookChildProcess(cp, parsed) {
+      if (!isWin) {
+        return;
+      }
+      const originalEmit = cp.emit;
+      cp.emit = function(name, arg1) {
+        if (name === "exit") {
+          const err = verifyENOENT(arg1, parsed, "spawn");
+          if (err) {
+            return originalEmit.call(cp, "error", err);
+          }
+        }
+        return originalEmit.apply(cp, arguments);
+      };
+    }
+    function verifyENOENT(status, parsed) {
+      if (isWin && status === 1 && !parsed.file) {
+        return notFoundError(parsed.original, "spawn");
+      }
+      return null;
+    }
+    function verifyENOENTSync(status, parsed) {
+      if (isWin && status === 1 && !parsed.file) {
+        return notFoundError(parsed.original, "spawnSync");
+      }
+      return null;
+    }
+    module2.exports = {
+      hookChildProcess,
+      verifyENOENT,
+      verifyENOENTSync,
+      notFoundError
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/cross-spawn@6.0.6/node_modules/cross-spawn/index.js
+var require_cross_spawn = __commonJS({
+  "../../node_modules/.pnpm/cross-spawn@6.0.6/node_modules/cross-spawn/index.js"(exports, module2) {
+    "use strict";
+    var cp = require("child_process");
+    var parse = require_parse();
+    var enoent = require_enoent();
+    function spawn(command, args, options) {
+      const parsed = parse(command, args, options);
+      const spawned = cp.spawn(parsed.command, parsed.args, parsed.options);
+      enoent.hookChildProcess(spawned, parsed);
+      return spawned;
+    }
+    function spawnSync(command, args, options) {
+      const parsed = parse(command, args, options);
+      const result = cp.spawnSync(parsed.command, parsed.args, parsed.options);
+      result.error = result.error || enoent.verifyENOENTSync(result.status, parsed);
+      return result;
+    }
+    module2.exports = spawn;
+    module2.exports.spawn = spawn;
+    module2.exports.sync = spawnSync;
+    module2.exports._parse = parse;
+    module2.exports._enoent = enoent;
+  }
+});
+
+// ../../node_modules/.pnpm/strip-eof@1.0.0/node_modules/strip-eof/index.js
+var require_strip_eof = __commonJS({
+  "../../node_modules/.pnpm/strip-eof@1.0.0/node_modules/strip-eof/index.js"(exports, module2) {
+    "use strict";
+    module2.exports = function(x) {
+      var lf = typeof x === "string" ? "\n" : "\n".charCodeAt();
+      var cr = typeof x === "string" ? "\r" : "\r".charCodeAt();
+      if (x[x.length - 1] === lf) {
+        x = x.slice(0, x.length - 1);
+      }
+      if (x[x.length - 1] === cr) {
+        x = x.slice(0, x.length - 1);
+      }
+      return x;
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/npm-run-path@2.0.2/node_modules/npm-run-path/index.js
+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 path = require("path");
+    var pathKey = require_path_key();
+    module2.exports = (opts) => {
+      opts = Object.assign({
+        cwd: process.cwd(),
+        path: process.env[pathKey()]
+      }, opts);
+      let prev;
+      let pth = path.resolve(opts.cwd);
+      const ret = [];
+      while (prev !== pth) {
+        ret.push(path.join(pth, "node_modules/.bin"));
+        prev = pth;
+        pth = path.resolve(pth, "..");
+      }
+      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 path2 = pathKey({ env });
+      opts.path = env[path2];
+      env[path2] = module2.exports(opts);
+      return env;
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/is-stream@1.1.0/node_modules/is-stream/index.js
+var require_is_stream = __commonJS({
+  "../../node_modules/.pnpm/is-stream@1.1.0/node_modules/is-stream/index.js"(exports, module2) {
+    "use strict";
+    var isStream = module2.exports = function(stream) {
+      return stream !== null && typeof stream === "object" && typeof stream.pipe === "function";
+    };
+    isStream.writable = function(stream) {
+      return isStream(stream) && stream.writable !== false && typeof stream._write === "function" && typeof stream._writableState === "object";
+    };
+    isStream.readable = function(stream) {
+      return isStream(stream) && stream.readable !== false && typeof stream._read === "function" && typeof stream._readableState === "object";
+    };
+    isStream.duplex = function(stream) {
+      return isStream.writable(stream) && isStream.readable(stream);
+    };
+    isStream.transform = function(stream) {
+      return isStream.duplex(stream) && typeof stream._transform === "function" && typeof stream._transformState === "object";
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/wrappy@1.0.2/node_modules/wrappy/wrappy.js
+var require_wrappy = __commonJS({
+  "../../node_modules/.pnpm/wrappy@1.0.2/node_modules/wrappy/wrappy.js"(exports, module2) {
+    module2.exports = wrappy;
+    function wrappy(fn, cb) {
+      if (fn && cb)
+        return wrappy(fn)(cb);
+      if (typeof fn !== "function")
+        throw new TypeError("need wrapper function");
+      Object.keys(fn).forEach(function(k) {
+        wrapper[k] = fn[k];
+      });
+      return wrapper;
+      function wrapper() {
+        var args = new Array(arguments.length);
+        for (var i = 0; i < args.length; i++) {
+          args[i] = arguments[i];
+        }
+        var ret = fn.apply(this, args);
+        var cb2 = args[args.length - 1];
+        if (typeof ret === "function" && ret !== cb2) {
+          Object.keys(cb2).forEach(function(k) {
+            ret[k] = cb2[k];
+          });
+        }
+        return ret;
+      }
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/once@1.4.0/node_modules/once/once.js
+var require_once = __commonJS({
+  "../../node_modules/.pnpm/once@1.4.0/node_modules/once/once.js"(exports, module2) {
+    var wrappy = require_wrappy();
+    module2.exports = wrappy(once);
+    module2.exports.strict = wrappy(onceStrict);
+    once.proto = once(function() {
+      Object.defineProperty(Function.prototype, "once", {
+        value: function() {
+          return once(this);
+        },
+        configurable: true
+      });
+      Object.defineProperty(Function.prototype, "onceStrict", {
+        value: function() {
+          return onceStrict(this);
+        },
+        configurable: true
+      });
+    });
+    function once(fn) {
+      var f = function() {
+        if (f.called)
+          return f.value;
+        f.called = true;
+        return f.value = fn.apply(this, arguments);
+      };
+      f.called = false;
+      return f;
+    }
+    function onceStrict(fn) {
+      var f = function() {
+        if (f.called)
+          throw new Error(f.onceError);
+        f.called = true;
+        return f.value = fn.apply(this, arguments);
+      };
+      var name = fn.name || "Function wrapped with `once`";
+      f.onceError = name + " shouldn't be called more than once";
+      f.called = false;
+      return f;
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/end-of-stream@1.4.4/node_modules/end-of-stream/index.js
+var require_end_of_stream = __commonJS({
+  "../../node_modules/.pnpm/end-of-stream@1.4.4/node_modules/end-of-stream/index.js"(exports, module2) {
+    var once = require_once();
+    var noop = function() {
+    };
+    var isRequest = function(stream) {
+      return stream.setHeader && typeof stream.abort === "function";
+    };
+    var isChildProcess = function(stream) {
+      return stream.stdio && Array.isArray(stream.stdio) && stream.stdio.length === 3;
+    };
+    var eos = function(stream, opts, callback) {
+      if (typeof opts === "function")
+        return eos(stream, null, opts);
+      if (!opts)
+        opts = {};
+      callback = once(callback || noop);
+      var ws = stream._writableState;
+      var rs = stream._readableState;
+      var readable = opts.readable || opts.readable !== false && stream.readable;
+      var writable = opts.writable || opts.writable !== false && stream.writable;
+      var cancelled = false;
+      var onlegacyfinish = function() {
+        if (!stream.writable)
+          onfinish();
+      };
+      var onfinish = function() {
+        writable = false;
+        if (!readable)
+          callback.call(stream);
+      };
+      var onend = function() {
+        readable = false;
+        if (!writable)
+          callback.call(stream);
+      };
+      var onexit = function(exitCode) {
+        callback.call(stream, exitCode ? new Error("exited with error code: " + exitCode) : null);
+      };
+      var onerror = function(err) {
+        callback.call(stream, err);
+      };
+      var onclose = function() {
+        process.nextTick(onclosenexttick);
+      };
+      var onclosenexttick = function() {
+        if (cancelled)
+          return;
+        if (readable && !(rs && (rs.ended && !rs.destroyed)))
+          return callback.call(stream, new Error("premature close"));
+        if (writable && !(ws && (ws.ended && !ws.destroyed)))
+          return callback.call(stream, new Error("premature close"));
+      };
+      var onrequest = function() {
+        stream.req.on("finish", onfinish);
+      };
+      if (isRequest(stream)) {
+        stream.on("complete", onfinish);
+        stream.on("abort", onclose);
+        if (stream.req)
+          onrequest();
+        else
+          stream.on("request", onrequest);
+      } else if (writable && !ws) {
+        stream.on("end", onlegacyfinish);
+        stream.on("close", onlegacyfinish);
+      }
+      if (isChildProcess(stream))
+        stream.on("exit", onexit);
+      stream.on("end", onend);
+      stream.on("finish", onfinish);
+      if (opts.error !== false)
+        stream.on("error", onerror);
+      stream.on("close", onclose);
+      return function() {
+        cancelled = true;
+        stream.removeListener("complete", onfinish);
+        stream.removeListener("abort", onclose);
+        stream.removeListener("request", onrequest);
+        if (stream.req)
+          stream.req.removeListener("finish", onfinish);
+        stream.removeListener("end", onlegacyfinish);
+        stream.removeListener("close", onlegacyfinish);
+        stream.removeListener("finish", onfinish);
+        stream.removeListener("exit", onexit);
+        stream.removeListener("end", onend);
+        stream.removeListener("error", onerror);
+        stream.removeListener("close", onclose);
+      };
+    };
+    module2.exports = eos;
+  }
+});
+
+// ../../node_modules/.pnpm/pump@3.0.2/node_modules/pump/index.js
+var require_pump = __commonJS({
+  "../../node_modules/.pnpm/pump@3.0.2/node_modules/pump/index.js"(exports, module2) {
+    var once = require_once();
+    var eos = require_end_of_stream();
+    var fs2;
+    try {
+      fs2 = require("fs");
+    } catch (e) {
+    }
+    var noop = function() {
+    };
+    var ancient = /^v?\.0/.test(process.version);
+    var isFn = function(fn) {
+      return typeof fn === "function";
+    };
+    var isFS = function(stream) {
+      if (!ancient)
+        return false;
+      if (!fs2)
+        return false;
+      return (stream instanceof (fs2.ReadStream || noop) || stream instanceof (fs2.WriteStream || noop)) && isFn(stream.close);
+    };
+    var isRequest = function(stream) {
+      return stream.setHeader && isFn(stream.abort);
+    };
+    var destroyer = function(stream, reading, writing, callback) {
+      callback = once(callback);
+      var closed = false;
+      stream.on("close", function() {
+        closed = true;
+      });
+      eos(stream, { readable: reading, writable: writing }, function(err) {
+        if (err)
+          return callback(err);
+        closed = true;
+        callback();
+      });
+      var destroyed = false;
+      return function(err) {
+        if (closed)
+          return;
+        if (destroyed)
+          return;
+        destroyed = true;
+        if (isFS(stream))
+          return stream.close(noop);
+        if (isRequest(stream))
+          return stream.abort();
+        if (isFn(stream.destroy))
+          return stream.destroy();
+        callback(err || new Error("stream was destroyed"));
+      };
+    };
+    var call = function(fn) {
+      fn();
+    };
+    var pipe = function(from, to) {
+      return from.pipe(to);
+    };
+    var pump = function() {
+      var streams = Array.prototype.slice.call(arguments);
+      var callback = isFn(streams[streams.length - 1] || noop) && streams.pop() || noop;
+      if (Array.isArray(streams[0]))
+        streams = streams[0];
+      if (streams.length < 2)
+        throw new Error("pump requires two streams per minimum");
+      var error;
+      var destroys = streams.map(function(stream, i) {
+        var reading = i < streams.length - 1;
+        var writing = i > 0;
+        return destroyer(stream, reading, writing, function(err) {
+          if (!error)
+            error = err;
+          if (err)
+            destroys.forEach(call);
+          if (reading)
+            return;
+          destroys.forEach(call);
+          callback(error);
+        });
+      });
+      return streams.reduce(pipe);
+    };
+    module2.exports = pump;
+  }
+});
+
+// ../../node_modules/.pnpm/get-stream@4.1.0/node_modules/get-stream/buffer-stream.js
+var require_buffer_stream = __commonJS({
+  "../../node_modules/.pnpm/get-stream@4.1.0/node_modules/get-stream/buffer-stream.js"(exports, module2) {
+    "use strict";
+    var { PassThrough } = require("stream");
+    module2.exports = (options) => {
+      options = Object.assign({}, options);
+      const { array } = options;
+      let { encoding } = options;
+      const buffer = encoding === "buffer";
+      let objectMode = false;
+      if (array) {
+        objectMode = !(encoding || buffer);
+      } else {
+        encoding = encoding || "utf8";
+      }
+      if (buffer) {
+        encoding = null;
+      }
+      let len = 0;
+      const ret = [];
+      const stream = new PassThrough({ objectMode });
+      if (encoding) {
+        stream.setEncoding(encoding);
+      }
+      stream.on("data", (chunk) => {
+        ret.push(chunk);
+        if (objectMode) {
+          len = ret.length;
+        } else {
+          len += chunk.length;
+        }
+      });
+      stream.getBufferedValue = () => {
+        if (array) {
+          return ret;
+        }
+        return buffer ? Buffer.concat(ret, len) : ret.join("");
+      };
+      stream.getBufferedLength = () => len;
+      return stream;
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/get-stream@4.1.0/node_modules/get-stream/index.js
+var require_get_stream = __commonJS({
+  "../../node_modules/.pnpm/get-stream@4.1.0/node_modules/get-stream/index.js"(exports, module2) {
+    "use strict";
+    var pump = require_pump();
+    var bufferStream = require_buffer_stream();
+    var MaxBufferError = class extends Error {
+      constructor() {
+        super("maxBuffer exceeded");
+        this.name = "MaxBufferError";
+      }
+    };
+    function getStream(inputStream, options) {
+      if (!inputStream) {
+        return Promise.reject(new Error("Expected a stream"));
+      }
+      options = Object.assign({ maxBuffer: Infinity }, options);
+      const { maxBuffer } = options;
+      let stream;
+      return new Promise((resolve, reject) => {
+        const rejectPromise = (error) => {
+          if (error) {
+            error.bufferedData = stream.getBufferedValue();
+          }
+          reject(error);
+        };
+        stream = pump(inputStream, bufferStream(options), (error) => {
+          if (error) {
+            rejectPromise(error);
+            return;
+          }
+          resolve();
+        });
+        stream.on("data", () => {
+          if (stream.getBufferedLength() > maxBuffer) {
+            rejectPromise(new MaxBufferError());
+          }
+        });
+      }).then(() => stream.getBufferedValue());
+    }
+    module2.exports = getStream;
+    module2.exports.buffer = (stream, options) => getStream(stream, Object.assign({}, options, { encoding: "buffer" }));
+    module2.exports.array = (stream, options) => getStream(stream, Object.assign({}, options, { array: true }));
+    module2.exports.MaxBufferError = MaxBufferError;
+  }
+});
+
+// ../../node_modules/.pnpm/p-finally@1.0.0/node_modules/p-finally/index.js
+var require_p_finally = __commonJS({
+  "../../node_modules/.pnpm/p-finally@1.0.0/node_modules/p-finally/index.js"(exports, module2) {
+    "use strict";
+    module2.exports = (promise, onFinally) => {
+      onFinally = onFinally || (() => {
+      });
+      return promise.then(
+        (val) => new Promise((resolve) => {
+          resolve(onFinally());
+        }).then(() => val),
+        (err) => new Promise((resolve) => {
+          resolve(onFinally());
+        }).then(() => {
+          throw err;
+        })
+      );
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/signal-exit@3.0.7/node_modules/signal-exit/signals.js
+var require_signals = __commonJS({
+  "../../node_modules/.pnpm/signal-exit@3.0.7/node_modules/signal-exit/signals.js"(exports, module2) {
+    module2.exports = [
+      "SIGABRT",
+      "SIGALRM",
+      "SIGHUP",
+      "SIGINT",
+      "SIGTERM"
+    ];
+    if (process.platform !== "win32") {
+      module2.exports.push(
+        "SIGVTALRM",
+        "SIGXCPU",
+        "SIGXFSZ",
+        "SIGUSR2",
+        "SIGTRAP",
+        "SIGSYS",
+        "SIGQUIT",
+        "SIGIOT"
+        // should detect profiler and enable/disable accordingly.
+        // see #21
+        // 'SIGPROF'
+      );
+    }
+    if (process.platform === "linux") {
+      module2.exports.push(
+        "SIGIO",
+        "SIGPOLL",
+        "SIGPWR",
+        "SIGSTKFLT",
+        "SIGUNUSED"
+      );
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/signal-exit@3.0.7/node_modules/signal-exit/index.js
+var require_signal_exit = __commonJS({
+  "../../node_modules/.pnpm/signal-exit@3.0.7/node_modules/signal-exit/index.js"(exports, module2) {
+    var process2 = global.process;
+    var processOk = function(process3) {
+      return process3 && typeof process3 === "object" && typeof process3.removeListener === "function" && typeof process3.emit === "function" && typeof process3.reallyExit === "function" && typeof process3.listeners === "function" && typeof process3.kill === "function" && typeof process3.pid === "number" && typeof process3.on === "function";
+    };
+    if (!processOk(process2)) {
+      module2.exports = function() {
+        return function() {
+        };
+      };
+    } else {
+      assert = require("assert");
+      signals = require_signals();
+      isWin = /^win/i.test(process2.platform);
+      EE = require("events");
+      if (typeof EE !== "function") {
+        EE = EE.EventEmitter;
+      }
+      if (process2.__signal_exit_emitter__) {
+        emitter = process2.__signal_exit_emitter__;
+      } else {
+        emitter = process2.__signal_exit_emitter__ = new EE();
+        emitter.count = 0;
+        emitter.emitted = {};
+      }
+      if (!emitter.infinite) {
+        emitter.setMaxListeners(Infinity);
+        emitter.infinite = true;
+      }
+      module2.exports = function(cb, opts) {
+        if (!processOk(global.process)) {
+          return function() {
+          };
+        }
+        assert.equal(typeof cb, "function", "a callback must be provided for exit handler");
+        if (loaded === false) {
+          load();
+        }
+        var ev = "exit";
+        if (opts && opts.alwaysLast) {
+          ev = "afterexit";
+        }
+        var remove = function() {
+          emitter.removeListener(ev, cb);
+          if (emitter.listeners("exit").length === 0 && emitter.listeners("afterexit").length === 0) {
+            unload();
+          }
+        };
+        emitter.on(ev, cb);
+        return remove;
+      };
+      unload = function unload2() {
+        if (!loaded || !processOk(global.process)) {
+          return;
+        }
+        loaded = false;
+        signals.forEach(function(sig) {
+          try {
+            process2.removeListener(sig, sigListeners[sig]);
+          } catch (er) {
+          }
+        });
+        process2.emit = originalProcessEmit;
+        process2.reallyExit = originalProcessReallyExit;
+        emitter.count -= 1;
+      };
+      module2.exports.unload = unload;
+      emit = function emit2(event, code, signal) {
+        if (emitter.emitted[event]) {
+          return;
+        }
+        emitter.emitted[event] = true;
+        emitter.emit(event, code, signal);
+      };
+      sigListeners = {};
+      signals.forEach(function(sig) {
+        sigListeners[sig] = function listener() {
+          if (!processOk(global.process)) {
+            return;
+          }
+          var listeners = process2.listeners(sig);
+          if (listeners.length === emitter.count) {
+            unload();
+            emit("exit", null, sig);
+            emit("afterexit", null, sig);
+            if (isWin && sig === "SIGHUP") {
+              sig = "SIGINT";
+            }
+            process2.kill(process2.pid, sig);
+          }
+        };
+      });
+      module2.exports.signals = function() {
+        return signals;
+      };
+      loaded = false;
+      load = function load2() {
+        if (loaded || !processOk(global.process)) {
+          return;
+        }
+        loaded = true;
+        emitter.count += 1;
+        signals = signals.filter(function(sig) {
+          try {
+            process2.on(sig, sigListeners[sig]);
+            return true;
+          } catch (er) {
+            return false;
+          }
+        });
+        process2.emit = processEmit;
+        process2.reallyExit = processReallyExit;
+      };
+      module2.exports.load = load;
+      originalProcessReallyExit = process2.reallyExit;
+      processReallyExit = function processReallyExit2(code) {
+        if (!processOk(global.process)) {
+          return;
+        }
+        process2.exitCode = code || /* istanbul ignore next */
+        0;
+        emit("exit", process2.exitCode, null);
+        emit("afterexit", process2.exitCode, null);
+        originalProcessReallyExit.call(process2, process2.exitCode);
+      };
+      originalProcessEmit = process2.emit;
+      processEmit = function processEmit2(ev, arg) {
+        if (ev === "exit" && processOk(global.process)) {
+          if (arg !== void 0) {
+            process2.exitCode = arg;
+          }
+          var ret = originalProcessEmit.apply(this, arguments);
+          emit("exit", process2.exitCode, null);
+          emit("afterexit", process2.exitCode, null);
+          return ret;
+        } else {
+          return originalProcessEmit.apply(this, arguments);
+        }
+      };
+    }
+    var assert;
+    var signals;
+    var isWin;
+    var EE;
+    var emitter;
+    var unload;
+    var emit;
+    var sigListeners;
+    var loaded;
+    var load;
+    var originalProcessReallyExit;
+    var processReallyExit;
+    var originalProcessEmit;
+    var processEmit;
+  }
+});
+
+// ../../node_modules/.pnpm/execa@1.0.0/node_modules/execa/lib/errname.js
+var require_errname = __commonJS({
+  "../../node_modules/.pnpm/execa@1.0.0/node_modules/execa/lib/errname.js"(exports, module2) {
+    "use strict";
+    var util = require("util");
+    var uv;
+    if (typeof util.getSystemErrorName === "function") {
+      module2.exports = util.getSystemErrorName;
+    } else {
+      try {
+        uv = process.binding("uv");
+        if (typeof uv.errname !== "function") {
+          throw new TypeError("uv.errname is not a function");
+        }
+      } catch (err) {
+        console.error("execa/lib/errname: unable to establish process.binding('uv')", err);
+        uv = null;
+      }
+      module2.exports = (code) => errname(uv, code);
+    }
+    module2.exports.__test__ = errname;
+    function errname(uv2, code) {
+      if (uv2) {
+        return uv2.errname(code);
+      }
+      if (!(code < 0)) {
+        throw new Error("err >= 0");
+      }
+      return `Unknown system error ${code}`;
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/execa@1.0.0/node_modules/execa/lib/stdio.js
+var require_stdio = __commonJS({
+  "../../node_modules/.pnpm/execa@1.0.0/node_modules/execa/lib/stdio.js"(exports, module2) {
+    "use strict";
+    var alias = ["stdin", "stdout", "stderr"];
+    var hasAlias = (opts) => alias.some((x) => Boolean(opts[x]));
+    module2.exports = (opts) => {
+      if (!opts) {
+        return null;
+      }
+      if (opts.stdio && hasAlias(opts)) {
+        throw new Error(`It's not possible to provide \`stdio\` in combination with one of ${alias.map((x) => `\`${x}\``).join(", ")}`);
+      }
+      if (typeof opts.stdio === "string") {
+        return opts.stdio;
+      }
+      const stdio = opts.stdio || [];
+      if (!Array.isArray(stdio)) {
+        throw new TypeError(`Expected \`stdio\` to be of type \`string\` or \`Array\`, got \`${typeof stdio}\``);
+      }
+      const result = [];
+      const len = Math.max(stdio.length, alias.length);
+      for (let i = 0; i < len; i++) {
+        let value = null;
+        if (stdio[i] !== void 0) {
+          value = stdio[i];
+        } else if (opts[alias[i]] !== void 0) {
+          value = opts[alias[i]];
+        }
+        result[i] = value;
+      }
+      return result;
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/execa@1.0.0/node_modules/execa/index.js
+var require_execa = __commonJS({
+  "../../node_modules/.pnpm/execa@1.0.0/node_modules/execa/index.js"(exports, module2) {
+    "use strict";
+    var path = require("path");
+    var childProcess = require("child_process");
+    var crossSpawn = require_cross_spawn();
+    var stripEof = require_strip_eof();
+    var npmRunPath = require_npm_run_path();
+    var isStream = require_is_stream();
+    var _getStream = require_get_stream();
+    var pFinally = require_p_finally();
+    var onExit = require_signal_exit();
+    var errname = require_errname();
+    var stdio = require_stdio();
+    var TEN_MEGABYTES = 1e3 * 1e3 * 10;
+    function handleArgs(cmd, args, opts) {
+      let parsed;
+      opts = Object.assign({
+        extendEnv: true,
+        env: {}
+      }, opts);
+      if (opts.extendEnv) {
+        opts.env = Object.assign({}, process.env, opts.env);
+      }
+      if (opts.__winShell === true) {
+        delete opts.__winShell;
+        parsed = {
+          command: cmd,
+          args,
+          options: opts,
+          file: cmd,
+          original: {
+            cmd,
+            args
+          }
+        };
+      } else {
+        parsed = crossSpawn._parse(cmd, args, opts);
+      }
+      opts = Object.assign({
+        maxBuffer: TEN_MEGABYTES,
+        buffer: true,
+        stripEof: true,
+        preferLocal: true,
+        localDir: parsed.options.cwd || process.cwd(),
+        encoding: "utf8",
+        reject: true,
+        cleanup: true
+      }, parsed.options);
+      opts.stdio = stdio(opts);
+      if (opts.preferLocal) {
+        opts.env = npmRunPath.env(Object.assign({}, opts, { cwd: opts.localDir }));
+      }
+      if (opts.detached) {
+        opts.cleanup = false;
+      }
+      if (process.platform === "win32" && path.basename(parsed.command) === "cmd.exe") {
+        parsed.args.unshift("/q");
+      }
+      return {
+        cmd: parsed.command,
+        args: parsed.args,
+        opts,
+        parsed
+      };
+    }
+    function handleInput(spawned, input) {
+      if (input === null || input === void 0) {
+        return;
+      }
+      if (isStream(input)) {
+        input.pipe(spawned.stdin);
+      } else {
+        spawned.stdin.end(input);
+      }
+    }
+    function handleOutput(opts, val) {
+      if (val && opts.stripEof) {
+        val = stripEof(val);
+      }
+      return val;
+    }
+    function handleShell(fn, cmd, opts) {
+      let file = "/bin/sh";
+      let args = ["-c", cmd];
+      opts = Object.assign({}, opts);
+      if (process.platform === "win32") {
+        opts.__winShell = true;
+        file = process.env.comspec || "cmd.exe";
+        args = ["/s", "/c", `"${cmd}"`];
+        opts.windowsVerbatimArguments = true;
+      }
+      if (opts.shell) {
+        file = opts.shell;
+        delete opts.shell;
+      }
+      return fn(file, args, opts);
+    }
+    function getStream(process2, stream, { encoding, buffer, maxBuffer }) {
+      if (!process2[stream]) {
+        return null;
+      }
+      let ret;
+      if (!buffer) {
+        ret = new Promise((resolve, reject) => {
+          process2[stream].once("end", resolve).once("error", reject);
+        });
+      } else if (encoding) {
+        ret = _getStream(process2[stream], {
+          encoding,
+          maxBuffer
+        });
+      } else {
+        ret = _getStream.buffer(process2[stream], { maxBuffer });
+      }
+      return ret.catch((err) => {
+        err.stream = stream;
+        err.message = `${stream} ${err.message}`;
+        throw err;
+      });
+    }
+    function makeError(result, options) {
+      const { stdout, stderr } = result;
+      let err = result.error;
+      const { code, signal } = result;
+      const { parsed, joinedCmd } = options;
+      const timedOut = options.timedOut || false;
+      if (!err) {
+        let output = "";
+        if (Array.isArray(parsed.opts.stdio)) {
+          if (parsed.opts.stdio[2] !== "inherit") {
+            output += output.length > 0 ? stderr : `
+${stderr}`;
+          }
+          if (parsed.opts.stdio[1] !== "inherit") {
+            output += `
+${stdout}`;
+          }
+        } else if (parsed.opts.stdio !== "inherit") {
+          output = `
+${stderr}${stdout}`;
+        }
+        err = new Error(`Command failed: ${joinedCmd}${output}`);
+        err.code = code < 0 ? errname(code) : code;
+      }
+      err.stdout = stdout;
+      err.stderr = stderr;
+      err.failed = true;
+      err.signal = signal || null;
+      err.cmd = joinedCmd;
+      err.timedOut = timedOut;
+      return err;
+    }
+    function joinCmd(cmd, args) {
+      let joinedCmd = cmd;
+      if (Array.isArray(args) && args.length > 0) {
+        joinedCmd += " " + args.join(" ");
+      }
+      return joinedCmd;
+    }
+    module2.exports = (cmd, args, opts) => {
+      const parsed = handleArgs(cmd, args, opts);
+      const { encoding, buffer, maxBuffer } = parsed.opts;
+      const joinedCmd = joinCmd(cmd, args);
+      let spawned;
+      try {
+        spawned = childProcess.spawn(parsed.cmd, parsed.args, parsed.opts);
+      } catch (err) {
+        return Promise.reject(err);
+      }
+      let removeExitHandler;
+      if (parsed.opts.cleanup) {
+        removeExitHandler = onExit(() => {
+          spawned.kill();
+        });
+      }
+      let timeoutId = null;
+      let timedOut = false;
+      const cleanup = () => {
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+          timeoutId = null;
+        }
+        if (removeExitHandler) {
+          removeExitHandler();
+        }
+      };
+      if (parsed.opts.timeout > 0) {
+        timeoutId = setTimeout(() => {
+          timeoutId = null;
+          timedOut = true;
+          spawned.kill(parsed.opts.killSignal);
+        }, parsed.opts.timeout);
+      }
+      const processDone = new Promise((resolve) => {
+        spawned.on("exit", (code, signal) => {
+          cleanup();
+          resolve({ code, signal });
+        });
+        spawned.on("error", (err) => {
+          cleanup();
+          resolve({ error: err });
+        });
+        if (spawned.stdin) {
+          spawned.stdin.on("error", (err) => {
+            cleanup();
+            resolve({ error: err });
+          });
+        }
+      });
+      function destroy() {
+        if (spawned.stdout) {
+          spawned.stdout.destroy();
+        }
+        if (spawned.stderr) {
+          spawned.stderr.destroy();
+        }
+      }
+      const handlePromise = () => pFinally(Promise.all([
+        processDone,
+        getStream(spawned, "stdout", { encoding, buffer, maxBuffer }),
+        getStream(spawned, "stderr", { encoding, buffer, maxBuffer })
+      ]).then((arr) => {
+        const result = arr[0];
+        result.stdout = arr[1];
+        result.stderr = arr[2];
+        if (result.error || result.code !== 0 || result.signal !== null) {
+          const err = makeError(result, {
+            joinedCmd,
+            parsed,
+            timedOut
+          });
+          err.killed = err.killed || spawned.killed;
+          if (!parsed.opts.reject) {
+            return err;
+          }
+          throw err;
+        }
+        return {
+          stdout: handleOutput(parsed.opts, result.stdout),
+          stderr: handleOutput(parsed.opts, result.stderr),
+          code: 0,
+          failed: false,
+          killed: false,
+          signal: null,
+          cmd: joinedCmd,
+          timedOut: false
+        };
+      }), destroy);
+      crossSpawn._enoent.hookChildProcess(spawned, parsed.parsed);
+      handleInput(spawned, parsed.opts.input);
+      spawned.then = (onfulfilled, onrejected) => handlePromise().then(onfulfilled, onrejected);
+      spawned.catch = (onrejected) => handlePromise().catch(onrejected);
+      return spawned;
+    };
+    module2.exports.stdout = (...args) => module2.exports(...args).then((x) => x.stdout);
+    module2.exports.stderr = (...args) => module2.exports(...args).then((x) => x.stderr);
+    module2.exports.shell = (cmd, opts) => handleShell(module2.exports, cmd, opts);
+    module2.exports.sync = (cmd, args, opts) => {
+      const parsed = handleArgs(cmd, args, opts);
+      const joinedCmd = joinCmd(cmd, args);
+      if (isStream(parsed.opts.input)) {
+        throw new TypeError("The `input` option cannot be a stream in sync mode");
+      }
+      const result = childProcess.spawnSync(parsed.cmd, parsed.args, parsed.opts);
+      result.code = result.status;
+      if (result.error || result.status !== 0 || result.signal !== null) {
+        const err = makeError(result, {
+          joinedCmd,
+          parsed
+        });
+        if (!parsed.opts.reject) {
+          return err;
+        }
+        throw err;
+      }
+      return {
+        stdout: handleOutput(parsed.opts, result.stdout),
+        stderr: handleOutput(parsed.opts, result.stderr),
+        code: 0,
+        failed: false,
+        signal: null,
+        cmd: joinedCmd,
+        timedOut: false
+      };
+    };
+    module2.exports.shellSync = (cmd, opts) => handleShell(module2.exports.sync, cmd, opts);
+  }
+});
+
+// ../../node_modules/.pnpm/which@3.0.0/node_modules/which/lib/index.js
+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: join2, delimiter, sep, posix } = require("path");
+    var isWindows = process.platform === "win32";
+    var rSlash = new RegExp(`[${posix.sep}${sep === posix.sep ? "" : sep}]`.replace(/(\\)/g, "\\$1"));
+    var rRel = new RegExp(`^\\.${rSlash.source}`);
+    var getNotFoundError = (cmd) => Object.assign(new Error(`not found: ${cmd}`), { code: "ENOENT" });
+    var getPathInfo = (cmd, {
+      path: optPath = process.env.PATH,
+      pathExt: optPathExt = process.env.PATHEXT,
+      delimiter: optDelimiter = delimiter
+    }) => {
+      const pathEnv = cmd.match(rSlash) ? [""] : [
+        // windows always checks the cwd first
+        ...isWindows ? [process.cwd()] : [],
+        ...(optPath || /* istanbul ignore next: very unusual */
+        "").split(optDelimiter)
+      ];
+      if (isWindows) {
+        const pathExtExe = optPathExt || [".EXE", ".CMD", ".BAT", ".COM"].join(optDelimiter);
+        const pathExt = pathExtExe.split(optDelimiter);
+        if (cmd.includes(".") && pathExt[0] !== "") {
+          pathExt.unshift("");
+        }
+        return { pathEnv, pathExt, pathExtExe };
+      }
+      return { pathEnv, pathExt: [""] };
+    };
+    var getPathPart = (raw, cmd) => {
+      const pathPart = /^".*"$/.test(raw) ? raw.slice(1, -1) : raw;
+      const prefix = !pathPart && rRel.test(cmd) ? cmd.slice(0, 2) : "";
+      return prefix + join2(pathPart, cmd);
+    };
+    var which2 = async (cmd, opt = {}) => {
+      const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
+      const found = [];
+      for (const envPart of pathEnv) {
+        const p = getPathPart(envPart, cmd);
+        for (const ext of pathExt) {
+          const withExt = p + ext;
+          const is = await isexe(withExt, { pathExt: pathExtExe, ignoreErrors: true });
+          if (is) {
+            if (!opt.all) {
+              return withExt;
+            }
+            found.push(withExt);
+          }
+        }
+      }
+      if (opt.all && found.length) {
+        return found;
+      }
+      if (opt.nothrow) {
+        return null;
+      }
+      throw getNotFoundError(cmd);
+    };
+    var whichSync = (cmd, opt = {}) => {
+      const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
+      const found = [];
+      for (const pathEnvPart of pathEnv) {
+        const p = getPathPart(pathEnvPart, cmd);
+        for (const ext of pathExt) {
+          const withExt = p + ext;
+          const is = isexe.sync(withExt, { pathExt: pathExtExe, ignoreErrors: true });
+          if (is) {
+            if (!opt.all) {
+              return withExt;
+            }
+            found.push(withExt);
+          }
+        }
+      }
+      if (opt.all && found.length) {
+        return found;
+      }
+      if (opt.nothrow) {
+        return null;
+      }
+      throw getNotFoundError(cmd);
+    };
+    module2.exports = which2;
+    which2.sync = whichSync;
+  }
+});
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  build: () => build,
+  downloadFilesInWorkPath: () => downloadFilesInWorkPath,
+  installRequirement: () => installRequirement,
+  installRequirementsFile: () => installRequirementsFile,
+  shouldServe: () => import_build_utils3.shouldServe,
+  version: () => version
+});
+module.exports = __toCommonJS(src_exports);
+var import_fs = __toESM(require("fs"));
+var import_execa2 = __toESM(require_execa());
+var import_util = require("util");
+var import_path = require("path");
+var import_build_utils3 = require("@vercel/build-utils");
+
+// src/install.ts
+var import_execa = __toESM(require_execa());
+var import_build_utils = require("@vercel/build-utils");
+var makeDependencyCheckCode = (dependency) => `
+from importlib import util
+dep = '${dependency}'.replace('-', '_')
+spec = util.find_spec(dep)
+print(spec.origin)
+`;
+async function isInstalled(pythonPath, dependency, cwd) {
+  try {
+    const { stdout } = await (0, import_execa.default)(
+      pythonPath,
+      ["-c", makeDependencyCheckCode(dependency)],
+      {
+        stdio: "pipe",
+        cwd
+      }
+    );
+    return stdout.startsWith(cwd);
+  } catch (err) {
+    return false;
+  }
+}
+var makeRequirementsCheckCode = (requirementsPath) => `
+import distutils.text_file
+import pkg_resources
+from pkg_resources import DistributionNotFound, VersionConflict
+dependencies = distutils.text_file.TextFile(filename='${requirementsPath}').readlines()
+pkg_resources.require(dependencies)
+`;
+async function areRequirementsInstalled(pythonPath, requirementsPath, cwd) {
+  try {
+    await (0, import_execa.default)(
+      pythonPath,
+      ["-c", makeRequirementsCheckCode(requirementsPath)],
+      {
+        stdio: "pipe",
+        cwd
+      }
+    );
+    return true;
+  } catch (err) {
+    return false;
+  }
+}
+async function pipInstall(pipPath, workPath, args) {
+  const target = ".";
+  process.env.PIP_USER = "0";
+  const cmdArgs = [
+    "install",
+    "--disable-pip-version-check",
+    "--target",
+    target,
+    ...args
+  ];
+  const pretty = `${pipPath} ${cmdArgs.join(" ")}`;
+  (0, import_build_utils.debug)(`Running "${pretty}"...`);
+  try {
+    await (0, import_execa.default)(pipPath, cmdArgs, {
+      cwd: workPath
+    });
+  } catch (err) {
+    console.log(`Failed to run "${pretty}"`);
+    throw err;
+  }
+}
+async function installRequirement({
+  pythonPath,
+  pipPath,
+  dependency,
+  version: version2,
+  workPath,
+  meta,
+  args = []
+}) {
+  if (meta.isDev && await isInstalled(pythonPath, dependency, workPath)) {
+    (0, import_build_utils.debug)(
+      `Skipping ${dependency} dependency installation, already installed in ${workPath}`
+    );
+    return;
+  }
+  const exact = `${dependency}==${version2}`;
+  await pipInstall(pipPath, workPath, [exact, ...args]);
+}
+async function installRequirementsFile({
+  pythonPath,
+  pipPath,
+  filePath,
+  workPath,
+  meta,
+  args = []
+}) {
+  if (meta.isDev && await areRequirementsInstalled(pythonPath, filePath, workPath)) {
+    (0, import_build_utils.debug)(`Skipping requirements file installation, already installed`);
+    return;
+  }
+  await pipInstall(pipPath, workPath, ["--upgrade", "-r", filePath, ...args]);
+}
+
+// src/version.ts
+var import_build_utils2 = require("@vercel/build-utils");
+var import_which = __toESM(require_lib());
+var allOptions = [
+  {
+    version: "3.12",
+    pipPath: "pip3.12",
+    pythonPath: "python3.12",
+    runtime: "python3.12"
+  },
+  {
+    version: "3.11",
+    pipPath: "pip3.11",
+    pythonPath: "python3.11",
+    runtime: "python3.11"
+  },
+  {
+    version: "3.10",
+    pipPath: "pip3.10",
+    pythonPath: "python3.10",
+    runtime: "python3.10"
+  },
+  {
+    version: "3.9",
+    pipPath: "pip3.9",
+    pythonPath: "python3.9",
+    runtime: "python3.9"
+  },
+  {
+    version: "3.6",
+    pipPath: "pip3.6",
+    pythonPath: "python3.6",
+    runtime: "python3.6",
+    discontinueDate: /* @__PURE__ */ new Date("2022-07-18")
+  }
+];
+function getDevPythonVersion() {
+  return {
+    version: "3",
+    pipPath: "pip3",
+    pythonPath: "python3",
+    runtime: "python3"
+  };
+}
+function getLatestPythonVersion({
+  isDev
+}) {
+  if (isDev) {
+    return getDevPythonVersion();
+  }
+  const selection = allOptions.find(isInstalled2);
+  if (!selection) {
+    throw new import_build_utils2.NowBuildError({
+      code: "PYTHON_NOT_FOUND",
+      link: "http://vercel.link/python-version",
+      message: `Unable to find any supported Python versions.`
+    });
+  }
+  return selection;
+}
+function getSupportedPythonVersion({
+  isDev,
+  pipLockPythonVersion
+}) {
+  if (isDev) {
+    return getDevPythonVersion();
+  }
+  let selection = getLatestPythonVersion({ isDev: false });
+  if (typeof pipLockPythonVersion === "string") {
+    const found = allOptions.find(
+      (o) => o.version === pipLockPythonVersion && isInstalled2(o)
+    );
+    if (found) {
+      selection = found;
+    } else {
+      console.warn(
+        `Warning: Python version "${pipLockPythonVersion}" detected in Pipfile.lock is invalid and will be ignored. http://vercel.link/python-version`
+      );
+    }
+  }
+  if (isDiscontinued(selection)) {
+    throw new import_build_utils2.NowBuildError({
+      code: "BUILD_UTILS_PYTHON_VERSION_DISCONTINUED",
+      link: "http://vercel.link/python-version",
+      message: `Python version "${selection.version}" detected in Pipfile.lock is discontinued and must be upgraded.`
+    });
+  }
+  if (selection.discontinueDate) {
+    const d = selection.discontinueDate.toISOString().split("T")[0];
+    console.warn(
+      `Error: Python version "${selection.version}" detected in Pipfile.lock has reached End-of-Life. Deployments created on or after ${d} will fail to build. http://vercel.link/python-version`
+    );
+  }
+  return selection;
+}
+function isDiscontinued({ discontinueDate }) {
+  const today = Date.now();
+  return discontinueDate !== void 0 && discontinueDate.getTime() <= today;
+}
+function isInstalled2({ pipPath, pythonPath }) {
+  return Boolean(import_which.default.sync(pipPath, { nothrow: true })) && Boolean(import_which.default.sync(pythonPath, { nothrow: true }));
+}
+
+// src/index.ts
+var readFile = (0, import_util.promisify)(import_fs.default.readFile);
+var writeFile = (0, import_util.promisify)(import_fs.default.writeFile);
+async function pipenvConvert(cmd, srcDir) {
+  (0, import_build_utils3.debug)("Running pipfile2req...");
+  try {
+    const out = await import_execa2.default.stdout(cmd, [], {
+      cwd: srcDir
+    });
+    (0, import_build_utils3.debug)("Contents of requirements.txt is: " + out);
+    import_fs.default.writeFileSync((0, import_path.join)(srcDir, "requirements.txt"), out);
+  } catch (err) {
+    console.log('Failed to run "pipfile2req"');
+    throw err;
+  }
+}
+var version = 3;
+async function downloadFilesInWorkPath({
+  entrypoint,
+  workPath,
+  files,
+  meta = {}
+}) {
+  (0, import_build_utils3.debug)("Downloading user files...");
+  let downloadedFiles = await (0, import_build_utils3.download)(files, workPath, meta);
+  if (meta.isDev) {
+    const { devCacheDir = (0, import_path.join)(workPath, ".now", "cache") } = meta;
+    const destCache = (0, import_path.join)(devCacheDir, (0, import_path.basename)(entrypoint, ".py"));
+    await (0, import_build_utils3.download)(downloadedFiles, destCache);
+    downloadedFiles = await (0, import_build_utils3.glob)("**", destCache);
+    workPath = destCache;
+  }
+  return workPath;
+}
+var build = async ({
+  workPath,
+  files: originalFiles,
+  entrypoint,
+  meta = {},
+  config
+}) => {
+  let pythonVersion = getLatestPythonVersion(meta);
+  workPath = await downloadFilesInWorkPath({
+    workPath,
+    files: originalFiles,
+    entrypoint,
+    meta
+  });
+  try {
+    if (meta.isDev) {
+      const setupCfg = (0, import_path.join)(workPath, "setup.cfg");
+      await writeFile(setupCfg, "[install]\nprefix=\n");
+    }
+  } catch (err) {
+    console.log('Failed to create "setup.cfg" file');
+    throw err;
+  }
+  console.log("Installing required dependencies...");
+  await installRequirement({
+    pythonPath: pythonVersion.pythonPath,
+    pipPath: pythonVersion.pipPath,
+    dependency: "werkzeug",
+    version: "1.0.1",
+    workPath,
+    meta
+  });
+  let fsFiles = await (0, import_build_utils3.glob)("**", workPath);
+  const entryDirectory = (0, import_path.dirname)(entrypoint);
+  const pipfileLockDir = fsFiles[(0, import_path.join)(entryDirectory, "Pipfile.lock")] ? (0, import_path.join)(workPath, entryDirectory) : fsFiles["Pipfile.lock"] ? workPath : null;
+  if (pipfileLockDir) {
+    (0, import_build_utils3.debug)('Found "Pipfile.lock"');
+    let lock = {};
+    try {
+      const json = await readFile((0, import_path.join)(pipfileLockDir, "Pipfile.lock"), "utf8");
+      lock = JSON.parse(json);
+    } catch (err) {
+      throw new import_build_utils3.NowBuildError({
+        code: "INVALID_PIPFILE_LOCK",
+        message: "Unable to parse Pipfile.lock"
+      });
+    }
+    pythonVersion = getSupportedPythonVersion({
+      isDev: meta.isDev,
+      pipLockPythonVersion: lock?._meta?.requires?.python_version
+    });
+    const tempDir = await (0, import_build_utils3.getWriteableDirectory)();
+    await installRequirement({
+      pythonPath: pythonVersion.pythonPath,
+      pipPath: pythonVersion.pipPath,
+      dependency: "pipfile-requirements",
+      version: "0.3.0",
+      workPath: tempDir,
+      meta,
+      args: ["--no-warn-script-location"]
+    });
+    process.env.PYTHONPATH = tempDir;
+    const convertCmd = (0, import_path.join)(tempDir, "bin", "pipfile2req");
+    await pipenvConvert(convertCmd, pipfileLockDir);
+  }
+  fsFiles = await (0, import_build_utils3.glob)("**", workPath);
+  const requirementsTxt = (0, import_path.join)(entryDirectory, "requirements.txt");
+  if (fsFiles[requirementsTxt]) {
+    (0, import_build_utils3.debug)('Found local "requirements.txt"');
+    const requirementsTxtPath = fsFiles[requirementsTxt].fsPath;
+    await installRequirementsFile({
+      pythonPath: pythonVersion.pythonPath,
+      pipPath: pythonVersion.pipPath,
+      filePath: requirementsTxtPath,
+      workPath,
+      meta
+    });
+  } else if (fsFiles["requirements.txt"]) {
+    (0, import_build_utils3.debug)('Found global "requirements.txt"');
+    const requirementsTxtPath = fsFiles["requirements.txt"].fsPath;
+    await installRequirementsFile({
+      pythonPath: pythonVersion.pythonPath,
+      pipPath: pythonVersion.pipPath,
+      filePath: requirementsTxtPath,
+      workPath,
+      meta
+    });
+  }
+  const originalPyPath = (0, import_path.join)(__dirname, "..", "vc_init.py");
+  const originalHandlerPyContents = await readFile(originalPyPath, "utf8");
+  (0, import_build_utils3.debug)("Entrypoint is", entrypoint);
+  const moduleName = entrypoint.replace(/\//g, ".").replace(/\.py$/, "");
+  const suffix = meta.isDev && !entrypoint.endsWith(".py") ? ".py" : "";
+  const entrypointWithSuffix = `${entrypoint}${suffix}`;
+  (0, import_build_utils3.debug)("Entrypoint with suffix is", entrypointWithSuffix);
+  const handlerPyContents = originalHandlerPyContents.replace(/__VC_HANDLER_MODULE_NAME/g, moduleName).replace(/__VC_HANDLER_ENTRYPOINT/g, entrypointWithSuffix);
+  const globOptions = {
+    cwd: workPath,
+    ignore: config && typeof config.excludeFiles === "string" ? config.excludeFiles : [
+      ".git/**",
+      ".vercel/**",
+      "**/node_modules/**",
+      "**/.next/**",
+      "**/.nuxt/**"
+    ]
+  };
+  const files = await (0, import_build_utils3.glob)("**", globOptions);
+  const handlerPyFilename = "vc__handler__python";
+  files[`${handlerPyFilename}.py`] = new import_build_utils3.FileBlob({ data: handlerPyContents });
+  if (config.framework === "fasthtml") {
+    const { SESSKEY = "" } = process.env;
+    files[".sesskey"] = new import_build_utils3.FileBlob({ data: `"${SESSKEY}"` });
+  }
+  const output = new import_build_utils3.Lambda({
+    files,
+    handler: `${handlerPyFilename}.vc_handler`,
+    runtime: pythonVersion.runtime,
+    environment: {},
+    supportsResponseStreaming: true
+  });
+  return { output };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  build,
+  downloadFilesInWorkPath,
+  installRequirement,
+  installRequirementsFile,
+  shouldServe,
+  version
+});