@vercel/python-analysis 0.15.0 → 0.15.1

package/dist/index.js

@@ -1,3 +1,679 @@
+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 __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
+));
+
+// ../../node_modules/.pnpm/@renovatebot+pep440@4.2.1/node_modules/@renovatebot/pep440/lib/version.js
+var require_version = __commonJS({
+  "../../node_modules/.pnpm/@renovatebot+pep440@4.2.1/node_modules/@renovatebot/pep440/lib/version.js"(exports, module) {
+    var VERSION_PATTERN = [
+      "v?",
+      "(?:",
+      /* */
+      "(?:(?<epoch>[0-9]+)!)?",
+      // epoch
+      /* */
+      "(?<release>[0-9]+(?:\\.[0-9]+)*)",
+      // release segment
+      /* */
+      "(?<pre>",
+      // pre-release
+      /*    */
+      "[-_\\.]?",
+      /*    */
+      "(?<pre_l>(a|b|c|rc|alpha|beta|pre|preview))",
+      /*    */
+      "[-_\\.]?",
+      /*    */
+      "(?<pre_n>[0-9]+)?",
+      /* */
+      ")?",
+      /* */
+      "(?<post>",
+      // post release
+      /*    */
+      "(?:-(?<post_n1>[0-9]+))",
+      /*    */
+      "|",
+      /*    */
+      "(?:",
+      /*        */
+      "[-_\\.]?",
+      /*        */
+      "(?<post_l>post|rev|r)",
+      /*        */
+      "[-_\\.]?",
+      /*        */
+      "(?<post_n2>[0-9]+)?",
+      /*    */
+      ")",
+      /* */
+      ")?",
+      /* */
+      "(?<dev>",
+      // dev release
+      /*    */
+      "[-_\\.]?",
+      /*    */
+      "(?<dev_l>dev)",
+      /*    */
+      "[-_\\.]?",
+      /*    */
+      "(?<dev_n>[0-9]+)?",
+      /* */
+      ")?",
+      ")",
+      "(?:\\+(?<local>[a-z0-9]+(?:[-_\\.][a-z0-9]+)*))?"
+      // local version
+    ].join("");
+    module.exports = {
+      VERSION_PATTERN,
+      valid,
+      clean,
+      explain,
+      parse,
+      stringify
+    };
+    var validRegex = new RegExp("^" + VERSION_PATTERN + "$", "i");
+    function valid(version) {
+      return validRegex.test(version) ? version : null;
+    }
+    var cleanRegex = new RegExp("^\\s*" + VERSION_PATTERN + "\\s*$", "i");
+    function clean(version) {
+      return stringify(parse(version, cleanRegex));
+    }
+    function parse(version, regex) {
+      const { groups } = (regex || validRegex).exec(version) || {};
+      if (!groups) {
+        return null;
+      }
+      const parsed = {
+        epoch: Number(groups.epoch ? groups.epoch : 0),
+        release: groups.release.split(".").map(Number),
+        pre: normalize_letter_version(groups.pre_l, groups.pre_n),
+        post: normalize_letter_version(
+          groups.post_l,
+          groups.post_n1 || groups.post_n2
+        ),
+        dev: normalize_letter_version(groups.dev_l, groups.dev_n),
+        local: parse_local_version(groups.local)
+      };
+      return parsed;
+    }
+    function stringify(parsed) {
+      if (!parsed) {
+        return null;
+      }
+      const { epoch, release, pre, post, dev, local } = parsed;
+      const parts = [];
+      if (epoch !== 0) {
+        parts.push(`${epoch}!`);
+      }
+      parts.push(release.join("."));
+      if (pre) {
+        parts.push(pre.join(""));
+      }
+      if (post) {
+        parts.push("." + post.join(""));
+      }
+      if (dev) {
+        parts.push("." + dev.join(""));
+      }
+      if (local) {
+        parts.push(`+${local}`);
+      }
+      return parts.join("");
+    }
+    function normalize_letter_version(letterIn, numberIn) {
+      let letter = letterIn;
+      let number = numberIn;
+      if (letter) {
+        if (!number) {
+          number = 0;
+        }
+        letter = letter.toLowerCase();
+        if (letter === "alpha") {
+          letter = "a";
+        } else if (letter === "beta") {
+          letter = "b";
+        } else if (["c", "pre", "preview"].includes(letter)) {
+          letter = "rc";
+        } else if (["rev", "r"].includes(letter)) {
+          letter = "post";
+        }
+        return [letter, Number(number)];
+      }
+      if (!letter && number) {
+        letter = "post";
+        return [letter, Number(number)];
+      }
+      return null;
+    }
+    function parse_local_version(local) {
+      if (local) {
+        return local.split(/[._-]/).map(
+          (part) => Number.isNaN(Number(part)) ? part.toLowerCase() : Number(part)
+        );
+      }
+      return null;
+    }
+    function explain(version) {
+      const parsed = parse(version);
+      if (!parsed) {
+        return parsed;
+      }
+      const { epoch, release, pre, post, dev, local } = parsed;
+      let base_version = "";
+      if (epoch !== 0) {
+        base_version += epoch + "!";
+      }
+      base_version += release.join(".");
+      const is_prerelease = Boolean(dev || pre);
+      const is_devrelease = Boolean(dev);
+      const is_postrelease = Boolean(post);
+      return {
+        epoch,
+        release,
+        pre,
+        post: post ? post[1] : post,
+        dev: dev ? dev[1] : dev,
+        local: local ? local.join(".") : local,
+        public: stringify(parsed).split("+", 1)[0],
+        base_version,
+        is_prerelease,
+        is_devrelease,
+        is_postrelease
+      };
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/@renovatebot+pep440@4.2.1/node_modules/@renovatebot/pep440/lib/operator.js
+var require_operator = __commonJS({
+  "../../node_modules/.pnpm/@renovatebot+pep440@4.2.1/node_modules/@renovatebot/pep440/lib/operator.js"(exports, module) {
+    var { parse } = require_version();
+    module.exports = {
+      compare,
+      rcompare,
+      lt,
+      le,
+      eq,
+      ne,
+      ge,
+      gt,
+      "<": lt,
+      "<=": le,
+      "==": eq,
+      "!=": ne,
+      ">=": ge,
+      ">": gt,
+      "===": arbitrary
+    };
+    function lt(version, other) {
+      return compare(version, other) < 0;
+    }
+    function le(version, other) {
+      return compare(version, other) <= 0;
+    }
+    function eq(version, other) {
+      return compare(version, other) === 0;
+    }
+    function ne(version, other) {
+      return compare(version, other) !== 0;
+    }
+    function ge(version, other) {
+      return compare(version, other) >= 0;
+    }
+    function gt(version, other) {
+      return compare(version, other) > 0;
+    }
+    function arbitrary(version, other) {
+      return version.toLowerCase() === other.toLowerCase();
+    }
+    function compare(version, other) {
+      const parsedVersion = parse(version);
+      const parsedOther = parse(other);
+      const keyVersion = calculateKey(parsedVersion);
+      const keyOther = calculateKey(parsedOther);
+      return pyCompare(keyVersion, keyOther);
+    }
+    function rcompare(version, other) {
+      return -compare(version, other);
+    }
+    function pyCompare(elemIn, otherIn) {
+      let elem = elemIn;
+      let other = otherIn;
+      if (elem === other) {
+        return 0;
+      }
+      if (Array.isArray(elem) !== Array.isArray(other)) {
+        elem = Array.isArray(elem) ? elem : [elem];
+        other = Array.isArray(other) ? other : [other];
+      }
+      if (Array.isArray(elem)) {
+        const len = Math.min(elem.length, other.length);
+        for (let i = 0; i < len; i += 1) {
+          const res = pyCompare(elem[i], other[i]);
+          if (res !== 0) {
+            return res;
+          }
+        }
+        return elem.length - other.length;
+      }
+      if (elem === -Infinity || other === Infinity) {
+        return -1;
+      }
+      if (elem === Infinity || other === -Infinity) {
+        return 1;
+      }
+      return elem < other ? -1 : 1;
+    }
+    function calculateKey(input) {
+      const { epoch } = input;
+      let { release, pre, post, local, dev } = input;
+      release = release.concat();
+      release.reverse();
+      while (release.length && release[0] === 0) {
+        release.shift();
+      }
+      release.reverse();
+      if (!pre && !post && dev)
+        pre = -Infinity;
+      else if (!pre)
+        pre = Infinity;
+      if (!post)
+        post = -Infinity;
+      if (!dev)
+        dev = Infinity;
+      if (!local) {
+        local = -Infinity;
+      } else {
+        local = local.map(
+          (i) => Number.isNaN(Number(i)) ? [-Infinity, i] : [Number(i), ""]
+        );
+      }
+      return [epoch, release, pre, post, dev, local];
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/@renovatebot+pep440@4.2.1/node_modules/@renovatebot/pep440/lib/specifier.js
+var require_specifier = __commonJS({
+  "../../node_modules/.pnpm/@renovatebot+pep440@4.2.1/node_modules/@renovatebot/pep440/lib/specifier.js"(exports, module) {
+    var { VERSION_PATTERN, explain: explainVersion } = require_version();
+    var Operator = require_operator();
+    var RANGE_PATTERN = [
+      "(?<operator>(===|~=|==|!=|<=|>=|<|>))",
+      "\\s*",
+      "(",
+      /*  */
+      "(?<version>(?:" + VERSION_PATTERN.replace(/\?<\w+>/g, "?:") + "))",
+      /*  */
+      "(?<prefix>\\.\\*)?",
+      /*  */
+      "|",
+      /*  */
+      "(?<legacy>[^,;\\s)]+)",
+      ")"
+    ].join("");
+    module.exports = {
+      RANGE_PATTERN,
+      parse,
+      satisfies: satisfies2,
+      filter,
+      validRange,
+      maxSatisfying,
+      minSatisfying
+    };
+    var isEqualityOperator = (op) => ["==", "!=", "==="].includes(op);
+    var rangeRegex = new RegExp("^" + RANGE_PATTERN + "$", "i");
+    function parse(ranges) {
+      if (!ranges.trim()) {
+        return [];
+      }
+      const specifiers = ranges.split(",").map((range) => rangeRegex.exec(range.trim()) || {}).map(({ groups }) => {
+        if (!groups) {
+          return null;
+        }
+        let { ...spec } = groups;
+        const { operator, version, prefix, legacy } = groups;
+        if (version) {
+          spec = { ...spec, ...explainVersion(version) };
+          if (operator === "~=") {
+            if (spec.release.length < 2) {
+              return null;
+            }
+          }
+          if (!isEqualityOperator(operator) && spec.local) {
+            return null;
+          }
+          if (prefix) {
+            if (!isEqualityOperator(operator) || spec.dev || spec.local) {
+              return null;
+            }
+          }
+        }
+        if (legacy && operator !== "===") {
+          return null;
+        }
+        return spec;
+      });
+      if (specifiers.filter(Boolean).length !== specifiers.length) {
+        return null;
+      }
+      return specifiers;
+    }
+    function filter(versions, specifier, options = {}) {
+      const filtered = pick(versions, specifier, options);
+      if (filtered.length === 0 && options.prereleases === void 0) {
+        return pick(versions, specifier, { prereleases: true });
+      }
+      return filtered;
+    }
+    function maxSatisfying(versions, range, options) {
+      const found = filter(versions, range, options).sort(Operator.compare);
+      return found.length === 0 ? null : found[found.length - 1];
+    }
+    function minSatisfying(versions, range, options) {
+      const found = filter(versions, range, options).sort(Operator.compare);
+      return found.length === 0 ? null : found[0];
+    }
+    function pick(versions, specifier, options) {
+      const parsed = parse(specifier);
+      if (!parsed) {
+        return [];
+      }
+      return versions.filter((version) => {
+        const explained = explainVersion(version);
+        if (!parsed.length) {
+          return explained && !(explained.is_prerelease && !options.prereleases);
+        }
+        return parsed.reduce((pass, spec) => {
+          if (!pass) {
+            return false;
+          }
+          return contains({ ...spec, ...options }, { version, explained });
+        }, true);
+      });
+    }
+    function satisfies2(version, specifier, options = {}) {
+      const filtered = pick([version], specifier, options);
+      return filtered.length === 1;
+    }
+    function arrayStartsWith(array, prefix) {
+      if (prefix.length > array.length) {
+        return false;
+      }
+      for (let i = 0; i < prefix.length; i += 1) {
+        if (prefix[i] !== array[i]) {
+          return false;
+        }
+      }
+      return true;
+    }
+    function contains(specifier, input) {
+      const { explained } = input;
+      let { version } = input;
+      const { ...spec } = specifier;
+      if (spec.prereleases === void 0) {
+        spec.prereleases = spec.is_prerelease;
+      }
+      if (explained && explained.is_prerelease && !spec.prereleases) {
+        return false;
+      }
+      if (spec.operator === "~=") {
+        let compatiblePrefix = spec.release.slice(0, -1).concat("*").join(".");
+        if (spec.epoch) {
+          compatiblePrefix = spec.epoch + "!" + compatiblePrefix;
+        }
+        return satisfies2(version, `>=${spec.version}, ==${compatiblePrefix}`);
+      }
+      if (spec.prefix) {
+        const isMatching = explained.epoch === spec.epoch && arrayStartsWith(explained.release, spec.release);
+        const isEquality = spec.operator !== "!=";
+        return isEquality ? isMatching : !isMatching;
+      }
+      if (explained) {
+        if (explained.local && spec.version) {
+          version = explained.public;
+          spec.version = explainVersion(spec.version).public;
+        }
+      }
+      if (spec.operator === "<" || spec.operator === ">") {
+        if (Operator.eq(spec.release.join("."), explained.release.join("."))) {
+          return false;
+        }
+      }
+      const op = Operator[spec.operator];
+      return op(version, spec.version || spec.legacy);
+    }
+    function validRange(specifier) {
+      return Boolean(parse(specifier));
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/@renovatebot+pep440@4.2.1/node_modules/@renovatebot/pep440/lib/semantic.js
+var require_semantic = __commonJS({
+  "../../node_modules/.pnpm/@renovatebot+pep440@4.2.1/node_modules/@renovatebot/pep440/lib/semantic.js"(exports, module) {
+    var { explain, parse, stringify } = require_version();
+    module.exports = {
+      major,
+      minor,
+      patch,
+      inc
+    };
+    function major(input) {
+      const version = explain(input);
+      if (!version) {
+        throw new TypeError("Invalid Version: " + input);
+      }
+      return version.release[0];
+    }
+    function minor(input) {
+      const version = explain(input);
+      if (!version) {
+        throw new TypeError("Invalid Version: " + input);
+      }
+      if (version.release.length < 2) {
+        return 0;
+      }
+      return version.release[1];
+    }
+    function patch(input) {
+      const version = explain(input);
+      if (!version) {
+        throw new TypeError("Invalid Version: " + input);
+      }
+      if (version.release.length < 3) {
+        return 0;
+      }
+      return version.release[2];
+    }
+    function inc(input, release, preReleaseIdentifier) {
+      let identifier = preReleaseIdentifier || `a`;
+      const version = parse(input);
+      if (!version) {
+        return null;
+      }
+      if (!["a", "b", "c", "rc", "alpha", "beta", "pre", "preview"].includes(
+        identifier
+      )) {
+        return null;
+      }
+      switch (release) {
+        case "premajor":
+          {
+            const [majorVersion] = version.release;
+            version.release.fill(0);
+            version.release[0] = majorVersion + 1;
+          }
+          version.pre = [identifier, 0];
+          delete version.post;
+          delete version.dev;
+          delete version.local;
+          break;
+        case "preminor":
+          {
+            const [majorVersion, minorVersion = 0] = version.release;
+            version.release.fill(0);
+            version.release[0] = majorVersion;
+            version.release[1] = minorVersion + 1;
+          }
+          version.pre = [identifier, 0];
+          delete version.post;
+          delete version.dev;
+          delete version.local;
+          break;
+        case "prepatch":
+          {
+            const [majorVersion, minorVersion = 0, patchVersion = 0] = version.release;
+            version.release.fill(0);
+            version.release[0] = majorVersion;
+            version.release[1] = minorVersion;
+            version.release[2] = patchVersion + 1;
+          }
+          version.pre = [identifier, 0];
+          delete version.post;
+          delete version.dev;
+          delete version.local;
+          break;
+        case "prerelease":
+          if (version.pre === null) {
+            const [majorVersion, minorVersion = 0, patchVersion = 0] = version.release;
+            version.release.fill(0);
+            version.release[0] = majorVersion;
+            version.release[1] = minorVersion;
+            version.release[2] = patchVersion + 1;
+            version.pre = [identifier, 0];
+          } else {
+            if (preReleaseIdentifier === void 0 && version.pre !== null) {
+              [identifier] = version.pre;
+            }
+            const [letter, number] = version.pre;
+            if (letter === identifier) {
+              version.pre = [letter, number + 1];
+            } else {
+              version.pre = [identifier, 0];
+            }
+          }
+          delete version.post;
+          delete version.dev;
+          delete version.local;
+          break;
+        case "major":
+          if (version.release.slice(1).some((value) => value !== 0) || version.pre === null) {
+            const [majorVersion] = version.release;
+            version.release.fill(0);
+            version.release[0] = majorVersion + 1;
+          }
+          delete version.pre;
+          delete version.post;
+          delete version.dev;
+          delete version.local;
+          break;
+        case "minor":
+          if (version.release.slice(2).some((value) => value !== 0) || version.pre === null) {
+            const [majorVersion, minorVersion = 0] = version.release;
+            version.release.fill(0);
+            version.release[0] = majorVersion;
+            version.release[1] = minorVersion + 1;
+          }
+          delete version.pre;
+          delete version.post;
+          delete version.dev;
+          delete version.local;
+          break;
+        case "patch":
+          if (version.release.slice(3).some((value) => value !== 0) || version.pre === null) {
+            const [majorVersion, minorVersion = 0, patchVersion = 0] = version.release;
+            version.release.fill(0);
+            version.release[0] = majorVersion;
+            version.release[1] = minorVersion;
+            version.release[2] = patchVersion + 1;
+          }
+          delete version.pre;
+          delete version.post;
+          delete version.dev;
+          delete version.local;
+          break;
+        default:
+          return null;
+      }
+      return stringify(version);
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/@renovatebot+pep440@4.2.1/node_modules/@renovatebot/pep440/index.js
+var require_pep440 = __commonJS({
+  "../../node_modules/.pnpm/@renovatebot+pep440@4.2.1/node_modules/@renovatebot/pep440/index.js"(exports, module) {
+    var { valid, clean, explain, parse } = require_version();
+    var { lt, le, eq, ne, ge, gt, compare, rcompare } = require_operator();
+    var {
+      filter,
+      maxSatisfying,
+      minSatisfying,
+      RANGE_PATTERN,
+      satisfies: satisfies2,
+      validRange
+    } = require_specifier();
+    var { major, minor, patch, inc } = require_semantic();
+    module.exports = {
+      // version
+      valid,
+      clean,
+      explain,
+      parse,
+      // operator
+      lt,
+      le,
+      lte: le,
+      eq,
+      ne,
+      neq: ne,
+      ge,
+      gte: ge,
+      gt,
+      compare,
+      rcompare,
+      // range
+      filter,
+      maxSatisfying,
+      minSatisfying,
+      RANGE_PATTERN,
+      satisfies: satisfies2,
+      validRange,
+      // semantic
+      major,
+      minor,
+      patch,
+      inc
+    };
+  }
+});
+
 // src/wasm/load.ts
 import { readFile } from "fs/promises";
 import { createRequire } from "module";
@@ -711,13 +1387,19 @@ async function readConfigIfExists(filename, schema, filetype = void 0) {
 }
 
 // src/manifest/pep440.ts
+var import_pep440 = __toESM(require_pep440(), 1);
+var import_specifier = __toESM(require_specifier(), 1);
+var import_version = __toESM(require_version(), 1);
 import assert from "assert";
-import { stringify as stringifyVersion } from "@renovatebot/pep440/lib/version";
-import { parse } from "@renovatebot/pep440";
-import {
-  parse as parse2,
-  satisfies
-} from "@renovatebot/pep440/lib/specifier";
+function parsePep440Version(version) {
+  return (0, import_pep440.parse)(version);
+}
+function parsePep440Constraint(ranges) {
+  return (0, import_specifier.parse)(ranges);
+}
+function pep440Satisfies(version, specifier) {
+  return (0, import_specifier.satisfies)(version, specifier);
+}
 function pep440ConstraintFromVersion(v) {
   return [
     {
@@ -728,7 +1410,7 @@ function pep440ConstraintFromVersion(v) {
   ];
 }
 function unparsePep440Version(v) {
-  const verstr = stringifyVersion(v);
+  const verstr = (0, import_version.stringify)(v);
   assert(verstr != null, "pep440/lib/version:stringify returned null");
   return verstr;
 }
@@ -1558,12 +2240,12 @@ function parseUvPythonRequest(input) {
 }
 function parseVersionRequest(input) {
   const [version, variant] = parseVariantSuffix(input);
-  let parsedVer = parse(version);
+  let parsedVer = parsePep440Version(version);
   if (parsedVer != null) {
     if (parsedVer.release.length === 1) {
       const converted = splitWheelTagVersion(version);
       if (converted != null) {
-        const convertedVer = parse(converted);
+        const convertedVer = parsePep440Version(converted);
         if (convertedVer != null) {
           parsedVer = convertedVer;
         }
@@ -1574,7 +2256,7 @@ function parseVersionRequest(input) {
       variant
     };
   }
-  const parsedConstr = parse2(version);
+  const parsedConstr = parsePep440Constraint(version);
   if (parsedConstr?.length) {
     return {
       constraint: parsedConstr,
@@ -1833,7 +2515,7 @@ function computeRequiresPython(manifest, workspaceManifest, configs) {
   if (!hasPythonVersionFile) {
     const manifestRequiresPython = manifest?.data.project?.["requires-python"];
     if (manifestRequiresPython) {
-      const parsed = parse2(manifestRequiresPython);
+      const parsed = parsePep440Constraint(manifestRequiresPython);
       if (parsed?.length) {
         const request = pythonRequestFromConstraint(parsed);
         constraints.push({
@@ -1846,7 +2528,7 @@ function computeRequiresPython(manifest, workspaceManifest, configs) {
     } else {
       const workspaceRequiresPython = workspaceManifest?.data.project?.["requires-python"];
       if (workspaceRequiresPython) {
-        const parsed = parse2(workspaceRequiresPython);
+        const parsed = parsePep440Constraint(workspaceRequiresPython);
         if (parsed?.length) {
           const request = pythonRequestFromConstraint(parsed);
           constraints.push({
@@ -2514,7 +3196,7 @@ function buildMatchesRequest(build, request) {
     if (versionConstraints.length > 0) {
       const buildVersionStr = pythonVersionToString(build.version);
       const specifier = pep440ConstraintsToString(versionConstraints);
-      if (!satisfies(buildVersionStr, specifier)) {
+      if (!pep440Satisfies(buildVersionStr, specifier)) {
         return false;
       }
     }