vercel-cli 41.1.0__py3-none-any.whl

vercel_cli/vendor/node_modules/@vercel/build-utils/dist/fs/stream-to-buffer.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="node" />
+export default function streamToBuffer(stream: NodeJS.ReadableStream): Promise<Buffer>;
+export declare function streamToBufferChunks(stream: NodeJS.ReadableStream, chunkSize?: number): Promise<Buffer[]>;

vercel_cli/vendor/node_modules/@vercel/build-utils/dist/fs/stream-to-buffer.js

@@ -0,0 +1,87 @@
+"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 stream_to_buffer_exports = {};
+__export(stream_to_buffer_exports, {
+  default: () => streamToBuffer,
+  streamToBufferChunks: () => streamToBufferChunks
+});
+module.exports = __toCommonJS(stream_to_buffer_exports);
+var import_end_of_stream = __toESM(require("end-of-stream"));
+function streamToBuffer(stream) {
+  return new Promise((resolve, reject) => {
+    const buffers = [];
+    stream.on("data", buffers.push.bind(buffers));
+    (0, import_end_of_stream.default)(stream, (err) => {
+      if (err) {
+        reject(err);
+        return;
+      }
+      switch (buffers.length) {
+        case 0:
+          resolve(Buffer.allocUnsafe(0));
+          break;
+        case 1:
+          resolve(buffers[0]);
+          break;
+        default:
+          resolve(Buffer.concat(buffers));
+      }
+    });
+  });
+}
+const MB = 1024 * 1024;
+async function streamToBufferChunks(stream, chunkSize = 100 * MB) {
+  const chunks = [];
+  let currentChunk = [];
+  let currentSize = 0;
+  for await (const chunk of stream) {
+    const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    let offset = 0;
+    while (offset < buffer.length) {
+      const remainingSpace = chunkSize - currentSize;
+      const sliceSize = Math.min(remainingSpace, buffer.length - offset);
+      currentChunk.push(buffer.slice(offset, offset + sliceSize));
+      currentSize += sliceSize;
+      offset += sliceSize;
+      if (currentSize >= chunkSize) {
+        chunks.push(Buffer.concat(currentChunk));
+        currentChunk = [];
+        currentSize = 0;
+      }
+    }
+  }
+  if (currentChunk.length > 0) {
+    chunks.push(Buffer.concat(currentChunk));
+  }
+  return chunks;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  streamToBufferChunks
+});

vercel_cli/vendor/node_modules/@vercel/build-utils/dist/get-ignore-filter.d.ts

@@ -0,0 +1 @@
+export default function (downloadPath: string, rootDirectory?: string | undefined): Promise<(p: string) => any>;

vercel_cli/vendor/node_modules/@vercel/build-utils/dist/get-ignore-filter.js

@@ -0,0 +1,90 @@
+"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 get_ignore_filter_exports = {};
+__export(get_ignore_filter_exports, {
+  default: () => get_ignore_filter_default
+});
+module.exports = __toCommonJS(get_ignore_filter_exports);
+var import_path = __toESM(require("path"));
+var import_fs_extra = __toESM(require("fs-extra"));
+var import_ignore = __toESM(require("ignore"));
+function isCodedError(error) {
+  return error !== null && error !== void 0 && error.code !== void 0;
+}
+function clearRelative(s) {
+  return s.replace(/(\n|^)\.\//g, "$1");
+}
+async function get_ignore_filter_default(downloadPath, rootDirectory) {
+  const readFile = async (p) => {
+    try {
+      return await import_fs_extra.default.readFile(p, "utf8");
+    } catch (error) {
+      if (error.code === "ENOENT" || error instanceof Error && error.message.includes("ENOENT")) {
+        return void 0;
+      }
+      throw error;
+    }
+  };
+  const vercelIgnorePath = import_path.default.join(
+    downloadPath,
+    rootDirectory || "",
+    ".vercelignore"
+  );
+  const nowIgnorePath = import_path.default.join(
+    downloadPath,
+    rootDirectory || "",
+    ".nowignore"
+  );
+  const ignoreContents = [];
+  try {
+    ignoreContents.push(
+      ...(await Promise.all([readFile(vercelIgnorePath), readFile(nowIgnorePath)])).filter(Boolean)
+    );
+  } catch (error) {
+    if (isCodedError(error) && error.code === "ENOTDIR") {
+      console.log(`Warning: Cannot read ignore file from ${vercelIgnorePath}`);
+    } else {
+      throw error;
+    }
+  }
+  if (ignoreContents.length === 2) {
+    throw new Error(
+      "Cannot use both a `.vercelignore` and `.nowignore` file. Please delete the `.nowignore` file."
+    );
+  }
+  if (ignoreContents.length === 0) {
+    return () => false;
+  }
+  const ignoreFilter = (0, import_ignore.default)().add(clearRelative(ignoreContents[0]));
+  return function(p) {
+    if (p === "now.json" || p === "vercel.json")
+      return false;
+    return ignoreFilter.test(p).ignored;
+  };
+}

vercel_cli/vendor/node_modules/@vercel/build-utils/dist/get-installed-package-version.d.ts

@@ -0,0 +1 @@
+export declare function getInstalledPackageVersion(packageName: string, path?: string | string[]): Promise<string | undefined>;

vercel_cli/vendor/node_modules/@vercel/build-utils/dist/get-installed-package-version.js

@@ -0,0 +1,53 @@
+"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 get_installed_package_version_exports = {};
+__export(get_installed_package_version_exports, {
+  getInstalledPackageVersion: () => getInstalledPackageVersion
+});
+module.exports = __toCommonJS(get_installed_package_version_exports);
+var import_debug = __toESM(require("./debug"));
+async function getInstalledPackageVersion(packageName, path) {
+  try {
+    const resolved = require.resolve(`${packageName}/package.json`, {
+      paths: path ? Array.isArray(path) ? path : [path] : [process.cwd()]
+    });
+    const version = require(resolved).version;
+    return version;
+  } catch (err) {
+    (0, import_debug.default)(
+      `Could not resolve package "${packageName}". Package is not installed.`,
+      err
+    );
+    return void 0;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getInstalledPackageVersion
+});

vercel_cli/vendor/node_modules/@vercel/build-utils/dist/get-platform-env.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Helper function to support both `VERCEL_` and legacy `NOW_` env vars.
+ * Throws an error if *both* env vars are defined.
+ */
+export declare const getPlatformEnv: (name: string) => string | undefined;

vercel_cli/vendor/node_modules/@vercel/build-utils/dist/get-platform-env.js

@@ -0,0 +1,45 @@
+"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_platform_env_exports = {};
+__export(get_platform_env_exports, {
+  getPlatformEnv: () => getPlatformEnv
+});
+module.exports = __toCommonJS(get_platform_env_exports);
+var import_errors = require("./errors");
+const getPlatformEnv = (name) => {
+  const vName = `VERCEL_${name}`;
+  const nName = `NOW_${name}`;
+  const v = process.env[vName];
+  const n = process.env[nName];
+  if (typeof v === "string") {
+    if (typeof n === "string") {
+      throw new import_errors.NowBuildError({
+        code: "CONFLICTING_ENV_VAR_NAMES",
+        message: `Both "${vName}" and "${nName}" env vars are defined. Please only define the "${vName}" env var.`,
+        link: "https://vercel.link/combining-old-and-new-config"
+      });
+    }
+    return v;
+  }
+  return n;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getPlatformEnv
+});

vercel_cli/vendor/node_modules/@vercel/build-utils/dist/get-prefixed-env-vars.d.ts

@@ -0,0 +1,14 @@
+type Envs = {
+    [key: string]: string | undefined;
+};
+/**
+ * Get the framework-specific prefixed System Environment Variables.
+ * See https://vercel.com/docs/concepts/projects/environment-variables#system-environment-variables
+ * @param envPrefix - Prefix, typically from `@vercel/frameworks`
+ * @param envs - Environment Variables, typically from `process.env`
+ */
+export declare function getPrefixedEnvVars({ envPrefix, envs, }: {
+    envPrefix: string | undefined;
+    envs: Envs;
+}): Envs;
+export {};

vercel_cli/vendor/node_modules/@vercel/build-utils/dist/get-prefixed-env-vars.js

@@ -0,0 +1,51 @@
+"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_prefixed_env_vars_exports = {};
+__export(get_prefixed_env_vars_exports, {
+  getPrefixedEnvVars: () => getPrefixedEnvVars
+});
+module.exports = __toCommonJS(get_prefixed_env_vars_exports);
+function getPrefixedEnvVars({
+  envPrefix,
+  envs
+}) {
+  const vercelSystemEnvPrefix = "VERCEL_";
+  const allowed = [
+    "VERCEL_URL",
+    "VERCEL_ENV",
+    "VERCEL_REGION",
+    "VERCEL_BRANCH_URL",
+    "VERCEL_PROJECT_PRODUCTION_URL"
+  ];
+  const newEnvs = {};
+  if (envPrefix && envs.VERCEL_URL) {
+    Object.keys(envs).filter((key) => allowed.includes(key) || key.startsWith("VERCEL_GIT_")).forEach((key) => {
+      const newKey = `${envPrefix}${key}`;
+      if (!(newKey in envs)) {
+        newEnvs[newKey] = envs[key];
+      }
+    });
+    newEnvs.TURBO_CI_VENDOR_ENV_KEY = `${envPrefix}${vercelSystemEnvPrefix}`;
+  }
+  return newEnvs;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getPrefixedEnvVars
+});

vercel_cli/vendor/node_modules/@vercel/build-utils/dist/hard-link-dir.d.ts

@@ -0,0 +1 @@
+export declare function hardLinkDir(src: string, destDirs: string[]): Promise<void>;

vercel_cli/vendor/node_modules/@vercel/build-utils/dist/hard-link-dir.js

@@ -0,0 +1,104 @@
+"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 hard_link_dir_exports = {};
+__export(hard_link_dir_exports, {
+  hardLinkDir: () => hardLinkDir
+});
+module.exports = __toCommonJS(hard_link_dir_exports);
+var import_path = __toESM(require("path"));
+var import_fs = require("fs");
+async function hardLinkDir(src, destDirs) {
+  if (destDirs.length === 0)
+    return;
+  destDirs = destDirs.filter((destDir) => import_path.default.relative(destDir, src) !== "");
+  const files = await import_fs.promises.readdir(src);
+  await Promise.all(
+    files.map(async (file) => {
+      if (file === "node_modules")
+        return;
+      const srcFile = import_path.default.join(src, file);
+      if ((await import_fs.promises.lstat(srcFile)).isDirectory()) {
+        const destSubdirs = await Promise.all(
+          destDirs.map(async (destDir) => {
+            const destSubdir = import_path.default.join(destDir, file);
+            try {
+              await import_fs.promises.mkdir(destSubdir, { recursive: true });
+            } catch (err) {
+              if (err.code !== "EEXIST")
+                throw err;
+            }
+            return destSubdir;
+          })
+        );
+        await hardLinkDir(srcFile, destSubdirs);
+        return;
+      }
+      await Promise.all(
+        destDirs.map(async (destDir) => {
+          const destFile = import_path.default.join(destDir, file);
+          try {
+            await linkOrCopyFile(srcFile, destFile);
+          } catch (err) {
+            if (err.code === "ENOENT") {
+              return;
+            }
+            throw err;
+          }
+        })
+      );
+    })
+  );
+}
+async function linkOrCopyFile(srcFile, destFile) {
+  try {
+    await linkOrCopy(srcFile, destFile);
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      await import_fs.promises.mkdir(import_path.default.dirname(destFile), { recursive: true });
+      await linkOrCopy(srcFile, destFile);
+      return;
+    }
+    if (err.code !== "EEXIST") {
+      throw err;
+    }
+  }
+}
+async function linkOrCopy(srcFile, destFile) {
+  try {
+    await import_fs.promises.link(srcFile, destFile);
+  } catch (err) {
+    if (err.code !== "EXDEV")
+      throw err;
+    await import_fs.promises.copyFile(srcFile, destFile);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  hardLinkDir
+});

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

@@ -0,0 +1,33 @@
+import FileBlob from './file-blob';
+import FileFsRef from './file-fs-ref';
+import FileRef from './file-ref';
+import { Lambda, createLambda, getLambdaOptionsFromFunction } from './lambda';
+import { NodejsLambda } from './nodejs-lambda';
+import { Prerender } from './prerender';
+import download, { downloadFile, DownloadedFiles, isSymbolicLink, isDirectory } from './fs/download';
+import getWriteableDirectory from './fs/get-writable-directory';
+import glob, { GlobOptions } from './fs/glob';
+import rename from './fs/rename';
+import { spawnAsync, execCommand, spawnCommand, walkParentDirs, getScriptName, installDependencies, runPackageJsonScript, runNpmInstall, runBundleInstall, runPipInstall, runShellScript, runCustomInstallCommand, getEnvForPackageManager, getNodeVersion, getPathForPackageManager, detectPackageManager, getSpawnOptions, getNodeBinPath, getNodeBinPaths, scanParentDirs, traverseUpDirectories } from './fs/run-user-scripts';
+import { getLatestNodeVersion, getDiscontinuedNodeVersions, getSupportedNodeVersion } from './fs/node-version';
+import streamToBuffer, { streamToBufferChunks } from './fs/stream-to-buffer';
+import debug from './debug';
+import getIgnoreFilter from './get-ignore-filter';
+import { getPlatformEnv } from './get-platform-env';
+import { getPrefixedEnvVars } from './get-prefixed-env-vars';
+import { cloneEnv } from './clone-env';
+import { hardLinkDir } from './hard-link-dir';
+import { validateNpmrc } from './validate-npmrc';
+export { FileBlob, FileFsRef, FileRef, Lambda, NodejsLambda, createLambda, Prerender, download, downloadFile, DownloadedFiles, getWriteableDirectory, glob, GlobOptions, rename, spawnAsync, getScriptName, installDependencies, runPackageJsonScript, execCommand, spawnCommand, walkParentDirs, getNodeBinPath, getNodeBinPaths, getSupportedNodeVersion, detectPackageManager, runNpmInstall, runBundleInstall, runPipInstall, runShellScript, runCustomInstallCommand, getEnvForPackageManager, getNodeVersion, getPathForPackageManager, getLatestNodeVersion, getDiscontinuedNodeVersions, getSpawnOptions, getPlatformEnv, getPrefixedEnvVars, streamToBuffer, streamToBufferChunks, debug, isSymbolicLink, isDirectory, getLambdaOptionsFromFunction, scanParentDirs, getIgnoreFilter, cloneEnv, hardLinkDir, traverseUpDirectories, validateNpmrc, };
+export { EdgeFunction } from './edge-function';
+export { readConfigFile } from './fs/read-config-file';
+export { normalizePath } from './fs/normalize-path';
+export { getOsRelease, getProvidedRuntime } from './os';
+export * from './should-serve';
+export * from './schemas';
+export * from './types';
+export * from './errors';
+export * from './trace';
+export { NODE_VERSIONS } from './fs/node-version';
+export { getInstalledPackageVersion } from './get-installed-package-version';
+export { defaultCachePathGlob } from './default-cache-path-glob';