vercel-cli 41.1.0__py3-none-any.whl

vercel_cli/vendor/node_modules/@vercel/build-utils/dist/file-fs-ref.js

@@ -0,0 +1,113 @@
+"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 __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);
+var file_fs_ref_exports = {};
+__export(file_fs_ref_exports, {
+  default: () => file_fs_ref_default
+});
+module.exports = __toCommonJS(file_fs_ref_exports);
+var import_assert = __toESM(require("assert"));
+var import_fs_extra = __toESM(require("fs-extra"));
+var import_multistream = __toESM(require("multistream"));
+var import_path = __toESM(require("path"));
+var import_async_sema = __toESM(require("async-sema"));
+const semaToPreventEMFILE = new import_async_sema.default(20);
+class FileFsRef {
+  constructor({
+    mode = 33188,
+    contentType,
+    fsPath,
+    size
+  }) {
+    (0, import_assert.default)(typeof mode === "number");
+    (0, import_assert.default)(typeof fsPath === "string");
+    this.type = "FileFsRef";
+    this.mode = mode;
+    this.contentType = contentType;
+    this.fsPath = fsPath;
+    this.size = size;
+  }
+  static async fromFsPath({
+    mode,
+    contentType,
+    fsPath,
+    size
+  }) {
+    let m = mode;
+    let s = size;
+    if (!m || typeof s === "undefined") {
+      const stat = await import_fs_extra.default.lstat(fsPath);
+      m = stat.mode;
+      s = stat.size;
+    }
+    return new FileFsRef({ mode: m, contentType, fsPath, size: s });
+  }
+  static async fromStream({
+    mode = 33188,
+    contentType,
+    stream,
+    fsPath
+  }) {
+    (0, import_assert.default)(typeof mode === "number");
+    (0, import_assert.default)(typeof stream.pipe === "function");
+    (0, import_assert.default)(typeof fsPath === "string");
+    await import_fs_extra.default.mkdirp(import_path.default.dirname(fsPath));
+    await new Promise((resolve, reject) => {
+      const dest = import_fs_extra.default.createWriteStream(fsPath, {
+        mode: mode & 511
+      });
+      stream.pipe(dest);
+      stream.on("error", reject);
+      dest.on("finish", resolve);
+      dest.on("error", reject);
+    });
+    return FileFsRef.fromFsPath({ mode, contentType, fsPath });
+  }
+  async toStreamAsync() {
+    await semaToPreventEMFILE.acquire();
+    const release = () => semaToPreventEMFILE.release();
+    const stream = import_fs_extra.default.createReadStream(this.fsPath);
+    stream.on("close", release);
+    stream.on("error", release);
+    return stream;
+  }
+  toStream() {
+    let flag = false;
+    return (0, import_multistream.default)((cb) => {
+      if (flag)
+        return cb(null, null);
+      flag = true;
+      this.toStreamAsync().then((stream) => {
+        cb(null, stream);
+      }).catch((error) => {
+        cb(error, null);
+      });
+    });
+  }
+}
+var file_fs_ref_default = FileFsRef;

vercel_cli/vendor/node_modules/@vercel/build-utils/dist/file-ref.d.ts

@@ -0,0 +1,38 @@
+/// <reference types="node" />
+import { FileBase } from './types';
+interface FileRefOptions {
+    mode?: number;
+    digest: string;
+    contentType?: string;
+    mutable?: boolean;
+}
+export default class FileRef implements FileBase {
+    type: 'FileRef';
+    mode: number;
+    digest: string;
+    contentType: string | undefined;
+    private mutable;
+    constructor({ mode, digest, contentType, mutable, }: FileRefOptions);
+    /**
+     * Retrieves the URL of the CloudFront distribution for the S3
+     * bucket represented by {@link getNowFilesS3Url}.
+     *
+     * @returns The URL of the CloudFront distribution
+     */
+    private getNowFilesCloudfrontUrl;
+    /**
+     * Retrieves the URL of the S3 bucket for storing ephemeral files.
+     *
+     * @returns The URL of the S3 bucket
+     */
+    private getNowEphemeralFilesS3Url;
+    /**
+     * Retrieves the URL of the S3 bucket for storing files.
+     *
+     * @returns The URL of the S3 bucket
+     */
+    private getNowFilesS3Url;
+    toStreamAsync(): Promise<NodeJS.ReadableStream>;
+    toStream(): NodeJS.ReadableStream;
+}
+export {};

vercel_cli/vendor/node_modules/@vercel/build-utils/dist/file-ref.js

@@ -0,0 +1,147 @@
+"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 __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);
+var file_ref_exports = {};
+__export(file_ref_exports, {
+  default: () => FileRef
+});
+module.exports = __toCommonJS(file_ref_exports);
+var import_assert = __toESM(require("assert"));
+var import_node_fetch = __toESM(require("node-fetch"));
+var import_multistream = __toESM(require("multistream"));
+var import_async_retry = __toESM(require("async-retry"));
+var import_async_sema = __toESM(require("async-sema"));
+const semaToDownloadFromS3 = new import_async_sema.default(5);
+class BailableError extends Error {
+  constructor(...args) {
+    super(...args);
+    this.bail = false;
+  }
+}
+class FileRef {
+  constructor({
+    mode = 33188,
+    digest,
+    contentType,
+    mutable = false
+  }) {
+    (0, import_assert.default)(typeof mode === "number");
+    (0, import_assert.default)(typeof digest === "string");
+    this.type = "FileRef";
+    this.mode = mode;
+    this.digest = digest;
+    this.contentType = contentType;
+    this.mutable = mutable;
+  }
+  /**
+   * Retrieves the URL of the CloudFront distribution for the S3
+   * bucket represented by {@link getNowFilesS3Url}.
+   *
+   * @returns The URL of the CloudFront distribution
+   */
+  getNowFilesCloudfrontUrl() {
+    return getEnvAsUrlOrThrow("NOW_FILES_CLOUDFRONT_URL") || "https://dmmcy0pwk6bqi.cloudfront.net";
+  }
+  /**
+   * Retrieves the URL of the S3 bucket for storing ephemeral files.
+   *
+   * @returns The URL of the S3 bucket
+   */
+  getNowEphemeralFilesS3Url() {
+    return getEnvAsUrlOrThrow("NOW_EPHEMERAL_FILES_S3_URL") || "https://now-ephemeral-files.s3.amazonaws.com";
+  }
+  /**
+   * Retrieves the URL of the S3 bucket for storing files.
+   *
+   * @returns The URL of the S3 bucket
+   */
+  getNowFilesS3Url() {
+    return getEnvAsUrlOrThrow("NOW_FILES_S3_URL") || "https://now-files.s3.amazonaws.com";
+  }
+  async toStreamAsync() {
+    let url = "";
+    const [digestType, digestHash] = this.digest.split(":");
+    if (digestType === "sha") {
+      url = this.mutable ? `${this.getNowFilesS3Url()}/${digestHash}` : `${this.getNowFilesCloudfrontUrl()}/${digestHash}`;
+    } else if (digestType === "sha+ephemeral") {
+      url = `${this.getNowEphemeralFilesS3Url()}/${digestHash}`;
+    } else {
+      throw new Error("Expected digest to be sha");
+    }
+    await semaToDownloadFromS3.acquire();
+    try {
+      return await (0, import_async_retry.default)(
+        async () => {
+          const resp = await (0, import_node_fetch.default)(url);
+          if (!resp.ok) {
+            const error = new BailableError(
+              `download: ${resp.status} ${resp.statusText} for ${url}`
+            );
+            if (resp.status === 403)
+              error.bail = true;
+            throw error;
+          }
+          return resp.body;
+        },
+        { factor: 1, retries: 3 }
+      );
+    } finally {
+      semaToDownloadFromS3.release();
+    }
+  }
+  toStream() {
+    let flag = false;
+    return (0, import_multistream.default)((cb) => {
+      if (flag)
+        return cb(null, null);
+      flag = true;
+      this.toStreamAsync().then((stream) => {
+        cb(null, stream);
+      }).catch((error) => {
+        cb(error, null);
+      });
+    });
+  }
+}
+function getEnvAsUrlOrThrow(key) {
+  const value = process.env[key];
+  if (value === void 0)
+    return void 0;
+  try {
+    new URL(value);
+    return value;
+  } catch (e) {
+    if (e instanceof TypeError && "code" in e && e.code === "ERR_INVALID_URL") {
+      throw new Error(
+        `A non-URL value was supplied to the ${key} environment variable`
+      );
+    } else {
+      throw e;
+    }
+  }
+}

vercel_cli/vendor/node_modules/@vercel/build-utils/dist/fs/download.d.ts

@@ -0,0 +1,9 @@
+import FileFsRef from '../file-fs-ref';
+import { File, Files, Meta } from '../types';
+export interface DownloadedFiles {
+    [filePath: string]: FileFsRef;
+}
+export declare function isDirectory(mode: number): boolean;
+export declare function isSymbolicLink(mode: number): boolean;
+export declare function downloadFile(file: File, fsPath: string): Promise<FileFsRef>;
+export default function download(files: Files, basePath: string, meta?: Meta): Promise<DownloadedFiles>;

vercel_cli/vendor/node_modules/@vercel/build-utils/dist/fs/download.js

@@ -0,0 +1,136 @@
+"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 __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);
+var download_exports = {};
+__export(download_exports, {
+  default: () => download,
+  downloadFile: () => downloadFile,
+  isDirectory: () => isDirectory,
+  isSymbolicLink: () => isSymbolicLink
+});
+module.exports = __toCommonJS(download_exports);
+var import_path = __toESM(require("path"));
+var import_debug = __toESM(require("../debug"));
+var import_file_fs_ref = __toESM(require("../file-fs-ref"));
+var import_fs_extra = require("fs-extra");
+var import_stream_to_buffer = __toESM(require("./stream-to-buffer"));
+const S_IFDIR = 16384;
+const S_IFLNK = 40960;
+const S_IFMT = 61440;
+function isDirectory(mode) {
+  return (mode & S_IFMT) === S_IFDIR;
+}
+function isSymbolicLink(mode) {
+  return (mode & S_IFMT) === S_IFLNK;
+}
+async function prepareSymlinkTarget(file, fsPath) {
+  const mkdirPromise = (0, import_fs_extra.mkdirp)(import_path.default.dirname(fsPath));
+  if (file.type === "FileFsRef") {
+    const [target] = await Promise.all([(0, import_fs_extra.readlink)(file.fsPath), mkdirPromise]);
+    return target;
+  }
+  if (file.type === "FileRef" || file.type === "FileBlob") {
+    const targetPathBufferPromise = (0, import_stream_to_buffer.default)(await file.toStreamAsync());
+    const [targetPathBuffer] = await Promise.all([
+      targetPathBufferPromise,
+      mkdirPromise
+    ]);
+    return targetPathBuffer.toString("utf8");
+  }
+  throw new Error(
+    `file.type "${file.type}" not supported for symlink`
+  );
+}
+async function downloadFile(file, fsPath) {
+  const { mode } = file;
+  if (isDirectory(mode)) {
+    await (0, import_fs_extra.mkdirp)(fsPath);
+    await (0, import_fs_extra.chmod)(fsPath, mode);
+    return import_file_fs_ref.default.fromFsPath({ mode, fsPath });
+  }
+  if (isSymbolicLink(mode)) {
+    const target = await prepareSymlinkTarget(file, fsPath);
+    await (0, import_fs_extra.symlink)(target, fsPath);
+    return import_file_fs_ref.default.fromFsPath({ mode, fsPath });
+  }
+  const stream = file.toStream();
+  return import_file_fs_ref.default.fromStream({ mode, stream, fsPath });
+}
+async function removeFile(basePath, fileMatched) {
+  const file = import_path.default.join(basePath, fileMatched);
+  await (0, import_fs_extra.remove)(file);
+}
+async function download(files, basePath, meta) {
+  const {
+    isDev = false,
+    skipDownload = false,
+    filesChanged = null,
+    filesRemoved = null
+  } = meta || {};
+  if (isDev || skipDownload) {
+    return files;
+  }
+  (0, import_debug.default)("Downloading deployment source files...");
+  const start = Date.now();
+  const files2 = {};
+  const filenames = Object.keys(files);
+  await Promise.all(
+    filenames.map(async (name) => {
+      if (Array.isArray(filesRemoved) && filesRemoved.includes(name)) {
+        await removeFile(basePath, name);
+        return;
+      }
+      if (Array.isArray(filesChanged) && !filesChanged.includes(name)) {
+        return;
+      }
+      const parts = name.split("/");
+      for (let i = 1; i < parts.length; i++) {
+        const dir = parts.slice(0, i).join("/");
+        const parent = files[dir];
+        if (parent && isSymbolicLink(parent.mode)) {
+          console.warn(
+            `Warning: file "${name}" is within a symlinked directory "${dir}" and will be ignored`
+          );
+          return;
+        }
+      }
+      const file = files[name];
+      const fsPath = import_path.default.join(basePath, name);
+      files2[name] = await downloadFile(file, fsPath);
+    })
+  );
+  const duration = Date.now() - start;
+  (0, import_debug.default)(`Downloaded ${filenames.length} source files: ${duration}ms`);
+  return files2;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  downloadFile,
+  isDirectory,
+  isSymbolicLink
+});

vercel_cli/vendor/node_modules/@vercel/build-utils/dist/fs/get-writable-directory.d.ts

@@ -0,0 +1 @@
+export default function getWritableDirectory(): Promise<string>;

vercel_cli/vendor/node_modules/@vercel/build-utils/dist/fs/get-writable-directory.js

@@ -0,0 +1,32 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var get_writable_directory_exports = {};
+__export(get_writable_directory_exports, {
+  default: () => getWritableDirectory
+});
+module.exports = __toCommonJS(get_writable_directory_exports);
+var import_path = require("path");
+var import_os = require("os");
+var import_fs_extra = require("fs-extra");
+async function getWritableDirectory() {
+  const name = Math.floor(Math.random() * 2147483647).toString(16);
+  const directory = (0, import_path.join)((0, import_os.tmpdir)(), name);
+  await (0, import_fs_extra.mkdirp)(directory);
+  return directory;
+}

vercel_cli/vendor/node_modules/@vercel/build-utils/dist/fs/glob.d.ts

@@ -0,0 +1,10 @@
+import FileFsRef from '../file-fs-ref';
+export interface GlobOptions {
+    cwd?: string;
+    dot?: boolean;
+    follow?: boolean;
+    ignore?: string | ReadonlyArray<string>;
+    includeDirectories?: boolean;
+    nodir?: boolean;
+}
+export default function glob(pattern: string, opts: GlobOptions | string, mountpoint?: string): Promise<Record<string, FileFsRef>>;

vercel_cli/vendor/node_modules/@vercel/build-utils/dist/fs/glob.js

@@ -0,0 +1,111 @@
+"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 __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);
+var glob_exports = {};
+__export(glob_exports, {
+  default: () => glob
+});
+module.exports = __toCommonJS(glob_exports);
+var import_path = __toESM(require("path"));
+var import_assert = __toESM(require("assert"));
+var import_glob = __toESM(require("glob"));
+var import_util = require("util");
+var import_fs_extra = require("fs-extra");
+var import_normalize_path = require("./normalize-path");
+var import_file_fs_ref = __toESM(require("../file-fs-ref"));
+const vanillaGlob = (0, import_util.promisify)(import_glob.default);
+async function glob(pattern, opts, mountpoint) {
+  const options = typeof opts === "string" ? { cwd: opts } : opts;
+  if (!options.cwd) {
+    throw new Error(
+      "Second argument (basePath) must be specified for names of resulting files"
+    );
+  }
+  if (!import_path.default.isAbsolute(options.cwd)) {
+    throw new Error(`basePath/cwd must be an absolute path (${options.cwd})`);
+  }
+  const results = {};
+  const statCache = {};
+  const symlinks = {};
+  const files = await vanillaGlob(pattern, {
+    ...options,
+    symlinks,
+    statCache,
+    stat: true,
+    dot: true
+  });
+  const dirs = /* @__PURE__ */ new Set();
+  const dirsWithEntries = /* @__PURE__ */ new Set();
+  for (const relativePath of files) {
+    const absPath = import_path.default.join(options.cwd, relativePath);
+    const fsPath = (0, import_normalize_path.normalizePath)(absPath);
+    let stat = statCache[fsPath];
+    (0, import_assert.default)(
+      stat,
+      `statCache does not contain value for ${relativePath} (resolved to ${fsPath})`
+    );
+    const isSymlink = symlinks[fsPath];
+    if (options.follow && (isSymlink || (await (0, import_fs_extra.lstat)(fsPath)).isSymbolicLink())) {
+      const target = await (0, import_fs_extra.readlink)(absPath);
+      const absTarget = import_path.default.resolve(import_path.default.dirname(absPath), target);
+      if (import_path.default.relative(options.cwd, absTarget).startsWith(`..${import_path.default.sep}`)) {
+        continue;
+      }
+    }
+    if (isSymlink || stat.isFile() || stat.isDirectory()) {
+      if (isSymlink) {
+        stat = await (0, import_fs_extra.lstat)(absPath);
+      }
+      const dirname = import_path.default.dirname(relativePath);
+      dirsWithEntries.add(dirname);
+      if (stat.isDirectory()) {
+        dirs.add(relativePath);
+        continue;
+      }
+      let finalPath = relativePath;
+      if (mountpoint) {
+        finalPath = import_path.default.join(mountpoint, finalPath);
+      }
+      results[finalPath] = new import_file_fs_ref.default({ mode: stat.mode, fsPath });
+    }
+  }
+  if (options.includeDirectories) {
+    for (const relativePath of dirs) {
+      if (dirsWithEntries.has(relativePath))
+        continue;
+      let finalPath = relativePath;
+      if (mountpoint) {
+        finalPath = import_path.default.join(mountpoint, finalPath);
+      }
+      const fsPath = (0, import_normalize_path.normalizePath)(import_path.default.join(options.cwd, relativePath));
+      const stat = statCache[fsPath];
+      results[finalPath] = new import_file_fs_ref.default({ mode: stat.mode, fsPath });
+    }
+  }
+  return results;
+}

vercel_cli/vendor/node_modules/@vercel/build-utils/dist/fs/node-version.d.ts

@@ -0,0 +1,9 @@
+import { NodeVersion } from '../types';
+export type NodeVersionMajor = ReturnType<typeof getOptions>[number]['major'];
+export declare const NODE_VERSIONS: NodeVersion[];
+declare function getOptions(): NodeVersion[];
+export declare function getAvailableNodeVersions(): NodeVersionMajor[];
+export declare function getLatestNodeVersion(availableVersions?: NodeVersionMajor[]): NodeVersion;
+export declare function getDiscontinuedNodeVersions(): NodeVersion[];
+export declare function getSupportedNodeVersion(engineRange: string | undefined, isAuto?: boolean, availableVersions?: NodeVersionMajor[]): Promise<NodeVersion>;
+export {};