@depup/vercel 50.32.5-depup.0

package/dist/chunks/chunk-MBGJBHYD.js

@@ -0,0 +1,388 @@
+import { createRequire as __createRequire } from 'node:module';
+import { fileURLToPath as __fileURLToPath } from 'node:url';
+import { dirname as __dirname_ } from 'node:path';
+const require = __createRequire(import.meta.url);
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __dirname_(__filename);
+import {
+  VERCEL_DIR
+} from "./chunk-AQLVWVEN.js";
+import {
+  ConflictingConfigFiles
+} from "./chunk-ZLCMHY2G.js";
+import {
+  output_manager_default
+} from "./chunk-FDJURQMQ.js";
+import {
+  __commonJS,
+  __require,
+  __toESM
+} from "./chunk-TZ2YI2VH.js";
+
+// ../../node_modules/.pnpm/dotenv@4.0.0/node_modules/dotenv/lib/main.js
+var require_main = __commonJS({
+  "../../node_modules/.pnpm/dotenv@4.0.0/node_modules/dotenv/lib/main.js"(exports, module) {
+    "use strict";
+    var fs = __require("fs");
+    function parse(src) {
+      var obj = {};
+      src.toString().split("\n").forEach(function(line) {
+        var keyValueArr = line.match(/^\s*([\w\.\-]+)\s*=\s*(.*)?\s*$/);
+        if (keyValueArr != null) {
+          var key = keyValueArr[1];
+          var value = keyValueArr[2] ? keyValueArr[2] : "";
+          var len = value ? value.length : 0;
+          if (len > 0 && value.charAt(0) === '"' && value.charAt(len - 1) === '"') {
+            value = value.replace(/\\n/gm, "\n");
+          }
+          value = value.replace(/(^['"]|['"]$)/g, "").trim();
+          obj[key] = value;
+        }
+      });
+      return obj;
+    }
+    function config(options) {
+      var path = ".env";
+      var encoding = "utf8";
+      if (options) {
+        if (options.path) {
+          path = options.path;
+        }
+        if (options.encoding) {
+          encoding = options.encoding;
+        }
+      }
+      try {
+        var parsedObj = parse(fs.readFileSync(path, { encoding }));
+        Object.keys(parsedObj).forEach(function(key) {
+          process.env[key] = process.env[key] || parsedObj[key];
+        });
+        return { parsed: parsedObj };
+      } catch (e) {
+        return { error: e };
+      }
+    }
+    module.exports.config = config;
+    module.exports.load = config;
+    module.exports.parse = parse;
+  }
+});
+
+// src/util/compile-vercel-config.ts
+var import_dotenv = __toESM(require_main(), 1);
+import { mkdir, writeFile, unlink, access } from "fs/promises";
+import { join, basename } from "path";
+import { fork } from "child_process";
+import { NowBuildError } from "@vercel/build-utils";
+function toRouteFormat(item) {
+  if ("src" in item)
+    return item;
+  const { source, destination, headers, statusCode, permanent, ...rest } = item;
+  const route = {
+    src: source,
+    ...rest
+  };
+  if (destination)
+    route.dest = destination;
+  if (headers)
+    route.headers = Object.fromEntries(headers.map((h) => [h.key, h.value]));
+  if (statusCode !== void 0) {
+    route.status = statusCode;
+  } else if (permanent !== void 0) {
+    route.status = permanent ? 308 : 307;
+  }
+  return route;
+}
+function normalizeConfig(config) {
+  const normalized = { ...config };
+  const { rewrites, redirects, headers } = normalized;
+  let allRoutes = normalized.routes || [];
+  const hasRoutes = allRoutes.length > 0;
+  const hasRewrites = (rewrites?.length ?? 0) > 0;
+  const hasRedirects = (redirects?.length ?? 0) > 0;
+  const hasHeaders = (headers?.length ?? 0) > 0;
+  function hasRouteFormat(items) {
+    return items?.some((item) => "src" in item) ?? false;
+  }
+  if (hasRoutes && (hasRewrites || hasRedirects || hasHeaders)) {
+    return normalized;
+  }
+  const shouldConvertRewrites = hasRewrites && hasRouteFormat(rewrites);
+  const shouldConvertRedirects = hasRedirects && hasRouteFormat(redirects);
+  const shouldConvertHeaders = hasHeaders && hasRouteFormat(headers);
+  const someWillConvert = shouldConvertRewrites || shouldConvertRedirects || shouldConvertHeaders;
+  const someWontConvert = hasRewrites && !shouldConvertRewrites || hasRedirects && !shouldConvertRedirects || hasHeaders && !shouldConvertHeaders;
+  if (someWillConvert && someWontConvert) {
+    throw new NowBuildError({
+      code: "INVALID_VERCEL_CONFIG",
+      message: "Transforms (e.g., requestHeaders) require the `routes` format, which cannot be used alongside `rewrites`, `redirects`, or `headers`. Move everything into the `routes` array instead.",
+      link: "https://vercel.com/docs/projects/project-configuration#routes"
+    });
+  }
+  if (rewrites && shouldConvertRewrites) {
+    allRoutes = [...allRoutes, ...rewrites.map(toRouteFormat)];
+    delete normalized.rewrites;
+  }
+  if (redirects && shouldConvertRedirects) {
+    allRoutes = [...allRoutes, ...redirects.map(toRouteFormat)];
+    delete normalized.redirects;
+  }
+  if (headers && shouldConvertHeaders) {
+    allRoutes = [...allRoutes, ...headers.map(toRouteFormat)];
+    delete normalized.headers;
+  }
+  if (allRoutes.length > 0) {
+    normalized.routes = allRoutes.map(toRouteFormat);
+  }
+  return normalized;
+}
+var VERCEL_CONFIG_EXTENSIONS = [
+  "ts",
+  "mts",
+  "js",
+  "mjs",
+  "cjs"
+];
+var DEFAULT_VERCEL_CONFIG_FILENAME = "Vercel config";
+async function fileExists(filePath) {
+  try {
+    await access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function findAllVercelConfigFiles(workPath) {
+  const foundFiles = [];
+  for (const ext of VERCEL_CONFIG_EXTENSIONS) {
+    const configPath = join(workPath, `vercel.${ext}`);
+    if (await fileExists(configPath)) {
+      foundFiles.push(configPath);
+    }
+  }
+  return foundFiles;
+}
+async function findSourceVercelConfigFile(workPath) {
+  for (const ext of VERCEL_CONFIG_EXTENSIONS) {
+    const configPath = join(workPath, `vercel.${ext}`);
+    if (await fileExists(configPath)) {
+      return basename(configPath);
+    }
+  }
+  return null;
+}
+async function findVercelConfigFile(workPath) {
+  const foundFiles = await findAllVercelConfigFiles(workPath);
+  if (foundFiles.length > 1) {
+    throw new ConflictingConfigFiles(
+      foundFiles,
+      "Multiple vercel config files found. Please use only one configuration file.",
+      "https://vercel.com/docs/projects/project-configuration"
+    );
+  }
+  return foundFiles[0] || null;
+}
+function parseConfigLoaderError(stderr) {
+  if (!stderr.trim()) {
+    return "";
+  }
+  const moduleNotFoundMatch = stderr.match(
+    /Error \[ERR_MODULE_NOT_FOUND\]: Cannot find package '([^']+)'/
+  );
+  if (moduleNotFoundMatch) {
+    const packageName = moduleNotFoundMatch[1];
+    return `Cannot find package '${packageName}'. Make sure it's installed in your project dependencies.`;
+  }
+  const syntaxErrorMatch = stderr.match(/SyntaxError: (.+?)(?:\n|$)/);
+  if (syntaxErrorMatch) {
+    return `Syntax error: ${syntaxErrorMatch[1]}`;
+  }
+  const errorMatch = stderr.match(
+    /^(?:Error|TypeError|ReferenceError): (.+?)(?:\n|$)/m
+  );
+  if (errorMatch) {
+    return errorMatch[1];
+  }
+  return stderr.trim();
+}
+async function compileVercelConfig(workPath) {
+  const vercelJsonPath = join(workPath, "vercel.json");
+  const nowJsonPath = join(workPath, "now.json");
+  const hasVercelJson = await fileExists(vercelJsonPath);
+  const hasNowJson = await fileExists(nowJsonPath);
+  if (hasVercelJson && hasNowJson) {
+    throw new ConflictingConfigFiles([vercelJsonPath, nowJsonPath]);
+  }
+  const vercelConfigPath = await findVercelConfigFile(workPath);
+  const vercelDir = join(workPath, VERCEL_DIR);
+  const compiledConfigPath = join(vercelDir, "vercel.json");
+  if (vercelConfigPath && hasNowJson) {
+    throw new ConflictingConfigFiles(
+      [vercelConfigPath, nowJsonPath],
+      `Both ${basename(vercelConfigPath)} and now.json exist in your project. Please use only one configuration method.`,
+      "https://vercel.com/docs/projects/project-configuration"
+    );
+  }
+  if (vercelConfigPath && hasVercelJson) {
+    throw new ConflictingConfigFiles(
+      [vercelConfigPath, vercelJsonPath],
+      `Both ${basename(vercelConfigPath)} and vercel.json exist in your project. Please use only one configuration method.`,
+      "https://vercel.com/docs/projects/project-configuration"
+    );
+  }
+  if (!vercelConfigPath) {
+    if (hasVercelJson) {
+      return {
+        configPath: vercelJsonPath,
+        wasCompiled: false
+      };
+    }
+    if (hasNowJson) {
+      return {
+        configPath: nowJsonPath,
+        wasCompiled: false
+      };
+    }
+    if (await fileExists(compiledConfigPath)) {
+      return {
+        configPath: compiledConfigPath,
+        wasCompiled: true,
+        sourceFile: await findSourceVercelConfigFile(workPath) ?? void 0
+      };
+    }
+    return {
+      configPath: null,
+      wasCompiled: false
+    };
+  }
+  (0, import_dotenv.config)({ path: join(workPath, ".env") });
+  (0, import_dotenv.config)({ path: join(workPath, ".env.local") });
+  const tempOutPath = join(vercelDir, "vercel-temp.mjs");
+  const loaderPath = join(vercelDir, "vercel-loader.mjs");
+  try {
+    const { build } = await import("esbuild");
+    await mkdir(vercelDir, { recursive: true });
+    await build({
+      entryPoints: [vercelConfigPath],
+      bundle: true,
+      platform: "node",
+      format: "esm",
+      outfile: tempOutPath,
+      packages: "external",
+      target: "node20",
+      sourcemap: "inline"
+    });
+    const loaderScript = `
+      import { pathToFileURL } from 'url';
+      const configModule = await import(pathToFileURL(process.argv[2]).href);
+      const config = ('default' in configModule) ? configModule.default : ('config' in configModule) ? configModule.config : configModule;
+      process.send(config);
+    `;
+    await writeFile(loaderPath, loaderScript, "utf-8");
+    const config = await new Promise((resolve, reject) => {
+      const child = fork(loaderPath, [tempOutPath], {
+        stdio: ["pipe", "pipe", "pipe", "ipc"]
+      });
+      let stderrOutput = "";
+      let stdoutOutput = "";
+      if (child.stderr) {
+        child.stderr.on("data", (data) => {
+          stderrOutput += data.toString();
+        });
+      }
+      if (child.stdout) {
+        child.stdout.on("data", (data) => {
+          stdoutOutput += data.toString();
+        });
+      }
+      const timeout = setTimeout(() => {
+        child.kill();
+        reject(new Error("Config loader timed out after 10 seconds"));
+      }, 1e4);
+      child.on("message", (message) => {
+        clearTimeout(timeout);
+        child.kill();
+        resolve(message);
+      });
+      child.on("error", (err) => {
+        clearTimeout(timeout);
+        reject(err);
+      });
+      child.on("exit", (code) => {
+        clearTimeout(timeout);
+        if (code !== 0) {
+          if (stderrOutput.trim()) {
+            output_manager_default.log(stderrOutput);
+          }
+          if (stdoutOutput.trim()) {
+            output_manager_default.log(stdoutOutput);
+          }
+          const parsedError = parseConfigLoaderError(stderrOutput);
+          if (parsedError) {
+            reject(new Error(parsedError));
+          } else if (stdoutOutput.trim()) {
+            reject(new Error(stdoutOutput.trim()));
+          } else {
+            reject(new Error(`Config loader exited with code ${code}`));
+          }
+        }
+      });
+    });
+    const normalizedConfig = normalizeConfig(config);
+    await writeFile(
+      compiledConfigPath,
+      JSON.stringify(normalizedConfig, null, 2),
+      "utf-8"
+    );
+    output_manager_default.debug(`Compiled ${vercelConfigPath} -> ${compiledConfigPath}`);
+    return {
+      configPath: compiledConfigPath,
+      wasCompiled: true,
+      sourceFile: await findSourceVercelConfigFile(workPath) ?? void 0
+    };
+  } catch (error) {
+    throw new NowBuildError({
+      code: error.code ?? "vercel_ts_compilation_failed",
+      message: `Failed to compile ${basename(vercelConfigPath)}: ${error.message}`,
+      link: error.link ?? "https://vercel.com/docs/projects/project-configuration"
+    });
+  } finally {
+    await Promise.all([
+      unlink(tempOutPath).catch((err) => {
+        if (err.code !== "ENOENT") {
+          output_manager_default.debug(`Failed to cleanup temp file: ${err}`);
+        }
+      }),
+      unlink(loaderPath).catch((err) => {
+        if (err.code !== "ENOENT") {
+          output_manager_default.debug(`Failed to cleanup loader file: ${err}`);
+        }
+      })
+    ]);
+  }
+}
+async function getVercelConfigPath(workPath) {
+  const vercelJsonPath = join(workPath, "vercel.json");
+  const nowJsonPath = join(workPath, "now.json");
+  const compiledConfigPath = join(workPath, VERCEL_DIR, "vercel.json");
+  if (await fileExists(vercelJsonPath)) {
+    return vercelJsonPath;
+  }
+  if (await fileExists(nowJsonPath)) {
+    return nowJsonPath;
+  }
+  if (await fileExists(compiledConfigPath)) {
+    return compiledConfigPath;
+  }
+  return nowJsonPath;
+}
+
+export {
+  require_main,
+  normalizeConfig,
+  VERCEL_CONFIG_EXTENSIONS,
+  DEFAULT_VERCEL_CONFIG_FILENAME,
+  findSourceVercelConfigFile,
+  compileVercelConfig,
+  getVercelConfigPath
+};

package/dist/chunks/chunk-NUKAG3YM.js

@@ -0,0 +1,168 @@
+import { createRequire as __createRequire } from 'node:module';
+import { fileURLToPath as __fileURLToPath } from 'node:url';
+import { dirname as __dirname_ } from 'node:path';
+const require = __createRequire(import.meta.url);
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __dirname_(__filename);
+import {
+  require_lib
+} from "./chunk-QXRJ52T4.js";
+import {
+  init_pkg,
+  pkg_default
+} from "./chunk-3XFFP2BA.js";
+import {
+  output_manager_default
+} from "./chunk-FDJURQMQ.js";
+import {
+  __toESM
+} from "./chunk-TZ2YI2VH.js";
+
+// src/commands/build/emit-flags-datafiles.ts
+var import_node_fetch = __toESM(require_lib(), 1);
+import { createHash } from "crypto";
+import { NowBuildError } from "@vercel/build-utils";
+import { mkdir, writeFile } from "fs/promises";
+import { join } from "path";
+init_pkg();
+var FLAGS_HOST = "https://flags.vercel.com";
+var FLAGS_DEFINITIONS_VERSION = "1.0.1";
+function obfuscate(sdkKey, prefixLength = 18) {
+  if (prefixLength >= sdkKey.length)
+    return sdkKey;
+  return sdkKey.slice(0, prefixLength) + "*".repeat(sdkKey.length - prefixLength);
+}
+function hashSdkKey(sdkKey) {
+  return createHash("sha256").update(sdkKey).digest("hex");
+}
+function generateDefinitionsModule(sdkKeys, values) {
+  const stringified = sdkKeys.map((_, i) => JSON.stringify(values[i]));
+  const uniqueStrings = [];
+  const stringToIndex = /* @__PURE__ */ new Map();
+  for (const s of stringified) {
+    if (!stringToIndex.has(s)) {
+      stringToIndex.set(s, uniqueStrings.length);
+      uniqueStrings.push(s);
+    }
+  }
+  const keyToIndex = sdkKeys.map((_, i) => stringToIndex.get(stringified[i]));
+  const hashedKeys = sdkKeys.map(hashSdkKey);
+  const lines = [
+    "const memo = (fn) => { let cached; return () => (cached ??= fn()); };",
+    ""
+  ];
+  for (let i = 0; i < uniqueStrings.length; i++) {
+    lines.push(
+      `const _d${i} = memo(() => JSON.parse(${JSON.stringify(uniqueStrings[i])}));`
+    );
+  }
+  lines.push("");
+  lines.push("const map = {");
+  for (let i = 0; i < sdkKeys.length; i++) {
+    lines.push(`  ${JSON.stringify(hashedKeys[i])}: _d${keyToIndex[i]},`);
+  }
+  lines.push("};");
+  lines.push("");
+  lines.push("export function get(hashedSdkKey) {");
+  lines.push("  return map[hashedSdkKey]?.() ?? null;");
+  lines.push("}");
+  lines.push("");
+  lines.push(
+    `export const version = ${JSON.stringify(FLAGS_DEFINITIONS_VERSION)};`
+  );
+  return lines.join("\n");
+}
+async function emitFlagsDatafiles(cwd, env) {
+  output_manager_default.debug("vercel-flags: checking env vars for SDK Keys");
+  const sdkKeys = Array.from(
+    Object.values(env).reduce((acc, value) => {
+      if (typeof value === "string") {
+        if (value.startsWith("vf_")) {
+          acc.add(value);
+        } else if (value.startsWith("flags:")) {
+          const params = new URLSearchParams(value.slice("flags:".length));
+          const sdkKey = params.get("sdkKey");
+          if (sdkKey?.startsWith("vf_")) {
+            acc.add(sdkKey);
+          }
+        }
+      }
+      return acc;
+    }, /* @__PURE__ */ new Set())
+  );
+  output_manager_default.debug(`vercel-flags: found ${sdkKeys.length} SDK keys`);
+  const fetchPromise = Promise.all(
+    sdkKeys.map(async (sdkKey) => {
+      const headers = {
+        authorization: `Bearer ${sdkKey}`,
+        "user-agent": `VercelCLI/${pkg_default.version}`
+      };
+      if (env.VERCEL_PROJECT_ID) {
+        headers["x-vercel-project-id"] = env.VERCEL_PROJECT_ID;
+      }
+      if (env.VERCEL_ENV) {
+        headers["x-vercel-env"] = env.VERCEL_ENV;
+      }
+      if (env.VERCEL_DEPLOYMENT_ID) {
+        headers["x-vercel-deployment-id"] = env.VERCEL_DEPLOYMENT_ID;
+      }
+      if (env.VERCEL_REGION) {
+        headers["x-vercel-region"] = env.VERCEL_REGION;
+      }
+      const res = await (0, import_node_fetch.default)(`${FLAGS_HOST}/v1/datafile`, { headers });
+      if (!res.ok) {
+        throw new NowBuildError({
+          code: "VERCEL_FLAGS_DEFINITIONS_FETCH_FAILED",
+          message: `Failed to fetch flag definitions for ${obfuscate(sdkKey)}: ${res.status} ${res.statusText}`,
+          link: "https://vercel.com/docs/flags"
+          // TODO replace with better link once we have a docs page
+        });
+      }
+      return res.json();
+    })
+  );
+  const values = await output_manager_default.time(
+    "vercel-flags: load datafiles",
+    fetchPromise
+  );
+  const definitionsJs = generateDefinitionsModule(sdkKeys, values);
+  const storageDir = join(cwd, "node_modules", "@vercel", "flags-definitions");
+  const indexPath = join(storageDir, "index.js");
+  const dtsPath = join(storageDir, "index.d.ts");
+  const packageJsonPath = join(storageDir, "package.json");
+  const dts = [
+    "export function get(hashedSdkKey: string): Record<string, unknown> | null;",
+    "export const version: string;",
+    ""
+  ].join("\n");
+  const packageJson = {
+    name: "@vercel/flags-definitions",
+    version: FLAGS_DEFINITIONS_VERSION,
+    type: "module",
+    main: "./index.js",
+    types: "./index.d.ts",
+    exports: {
+      ".": {
+        types: "./index.d.ts",
+        import: "./index.js"
+      }
+    }
+  };
+  await mkdir(storageDir, { recursive: true });
+  await Promise.all([
+    writeFile(indexPath, definitionsJs),
+    writeFile(dtsPath, dts),
+    writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2))
+  ]);
+  output_manager_default.debug("vercel-flags: created module");
+  output_manager_default.debug(`  \u2192 ${indexPath}`);
+  output_manager_default.debug(`  \u2192 ${dtsPath}`);
+  output_manager_default.debug(`  \u2192 ${packageJsonPath}`);
+  output_manager_default.debug(
+    `  \u2192 included definitions for keys "${sdkKeys.map((key) => obfuscate(key)).join(", ")}"`
+  );
+}
+
+export {
+  emitFlagsDatafiles
+};

package/dist/chunks/chunk-O7I4ZOCC.js

@@ -0,0 +1,58 @@
+import { createRequire as __createRequire } from 'node:module';
+import { fileURLToPath as __fileURLToPath } from 'node:url';
+import { dirname as __dirname_ } from 'node:path';
+const require = __createRequire(import.meta.url);
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __dirname_(__filename);
+import {
+  confirmOption,
+  packageName,
+  yesOption
+} from "./chunk-ZLCMHY2G.js";
+
+// src/commands/dev/command.ts
+var devCommand = {
+  name: "dev",
+  aliases: ["develop"],
+  description: `Starts the \`${packageName} dev\` server.`,
+  arguments: [
+    {
+      name: "dir",
+      required: false
+    }
+  ],
+  options: [
+    {
+      name: "listen",
+      description: "Specify a URI endpoint on which to listen [0.0.0.0:3000]",
+      argument: "URI",
+      shorthand: "l",
+      type: String,
+      deprecated: false
+    },
+    {
+      name: "local",
+      shorthand: "L",
+      type: Boolean,
+      deprecated: false,
+      description: "Start the dev server without linking to a Vercel project"
+    },
+    yesOption,
+    { name: "port", shorthand: "p", type: String, deprecated: true },
+    confirmOption
+  ],
+  examples: [
+    {
+      name: `Start the \`${packageName} dev\` server on port 8080`,
+      value: `${packageName} dev --listen 8080`
+    },
+    {
+      name: "Make the `vercel dev` server bind to localhost on port 5000",
+      value: `${packageName} dev --listen 127.0.0.1:5000 `
+    }
+  ]
+};
+
+export {
+  devCommand
+};

package/dist/chunks/chunk-OWR3XNE3.js

@@ -0,0 +1,48 @@
+import { createRequire as __createRequire } from 'node:module';
+import { fileURLToPath as __fileURLToPath } from 'node:url';
+import { dirname as __dirname_ } from 'node:path';
+const require = __createRequire(import.meta.url);
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __dirname_(__filename);
+import {
+  VERCEL_DIR
+} from "./chunk-AQLVWVEN.js";
+import {
+  ConflictingConfigFiles,
+  InvalidLocalConfig,
+  getArgs
+} from "./chunk-ZLCMHY2G.js";
+
+// src/util/config/local-path.ts
+import path from "path";
+import { existsSync } from "fs";
+function getLocalPathConfig(prefix) {
+  const argv = getArgs(process.argv.slice(2), {}, { permissive: true });
+  const customPath = argv["--local-config"];
+  if (customPath) {
+    if (typeof customPath !== "string") {
+      throw new InvalidLocalConfig(customPath);
+    }
+    return path.resolve(prefix, customPath);
+  }
+  const vercelConfigPath = path.join(prefix, "vercel.json");
+  const nowConfigPath = path.join(prefix, "now.json");
+  const vercelConfigExists = existsSync(vercelConfigPath);
+  const nowConfigExists = existsSync(nowConfigPath);
+  if (nowConfigExists && vercelConfigExists) {
+    throw new ConflictingConfigFiles([vercelConfigPath, nowConfigPath]);
+  }
+  const compiledConfigPath = path.join(prefix, VERCEL_DIR, "vercel.json");
+  const compiledConfigExists = existsSync(compiledConfigPath);
+  if (compiledConfigExists) {
+    return compiledConfigPath;
+  }
+  if (nowConfigExists) {
+    return nowConfigPath;
+  }
+  return vercelConfigPath;
+}
+
+export {
+  getLocalPathConfig
+};

package/dist/chunks/chunk-P3SKP5WM.js

@@ -0,0 +1,27 @@
+import { createRequire as __createRequire } from 'node:module';
+import { fileURLToPath as __fileURLToPath } from 'node:url';
+import { dirname as __dirname_ } from 'node:path';
+const require = __createRequire(import.meta.url);
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __dirname_(__filename);
+
+// src/util/routes/edit-route.ts
+async function editRoute(client, projectId, routeId, input, options = {}) {
+  const { teamId } = options;
+  const query = new URLSearchParams();
+  if (teamId)
+    query.set("teamId", teamId);
+  const queryString = query.toString();
+  const url = `/v1/projects/${projectId}/routes/${routeId}${queryString ? `?${queryString}` : ""}`;
+  return await client.fetch(url, {
+    method: "PATCH",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(input)
+  });
+}
+
+export {
+  editRoute
+};