@depup/vercel 50.32.5-depup.0

package/dist/chunks/chunk-IUGPWINM.js

@@ -0,0 +1,104 @@
+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_once
+} from "./chunk-AQLVWVEN.js";
+import {
+  __commonJS
+} from "./chunk-TZ2YI2VH.js";
+
+// ../../node_modules/.pnpm/end-of-stream@1.4.1/node_modules/end-of-stream/index.js
+var require_end_of_stream = __commonJS({
+  "../../node_modules/.pnpm/end-of-stream@1.4.1/node_modules/end-of-stream/index.js"(exports, module) {
+    var once = require_once();
+    var noop = function() {
+    };
+    var isRequest = function(stream) {
+      return stream.setHeader && typeof stream.abort === "function";
+    };
+    var isChildProcess = function(stream) {
+      return stream.stdio && Array.isArray(stream.stdio) && stream.stdio.length === 3;
+    };
+    var eos = function(stream, opts, callback) {
+      if (typeof opts === "function")
+        return eos(stream, null, opts);
+      if (!opts)
+        opts = {};
+      callback = once(callback || noop);
+      var ws = stream._writableState;
+      var rs = stream._readableState;
+      var readable = opts.readable || opts.readable !== false && stream.readable;
+      var writable = opts.writable || opts.writable !== false && stream.writable;
+      var onlegacyfinish = function() {
+        if (!stream.writable)
+          onfinish();
+      };
+      var onfinish = function() {
+        writable = false;
+        if (!readable)
+          callback.call(stream);
+      };
+      var onend = function() {
+        readable = false;
+        if (!writable)
+          callback.call(stream);
+      };
+      var onexit = function(exitCode) {
+        callback.call(stream, exitCode ? new Error("exited with error code: " + exitCode) : null);
+      };
+      var onerror = function(err) {
+        callback.call(stream, err);
+      };
+      var onclose = function() {
+        if (readable && !(rs && rs.ended))
+          return callback.call(stream, new Error("premature close"));
+        if (writable && !(ws && ws.ended))
+          return callback.call(stream, new Error("premature close"));
+      };
+      var onrequest = function() {
+        stream.req.on("finish", onfinish);
+      };
+      if (isRequest(stream)) {
+        stream.on("complete", onfinish);
+        stream.on("abort", onclose);
+        if (stream.req)
+          onrequest();
+        else
+          stream.on("request", onrequest);
+      } else if (writable && !ws) {
+        stream.on("end", onlegacyfinish);
+        stream.on("close", onlegacyfinish);
+      }
+      if (isChildProcess(stream))
+        stream.on("exit", onexit);
+      stream.on("end", onend);
+      stream.on("finish", onfinish);
+      if (opts.error !== false)
+        stream.on("error", onerror);
+      stream.on("close", onclose);
+      return function() {
+        stream.removeListener("complete", onfinish);
+        stream.removeListener("abort", onclose);
+        stream.removeListener("request", onrequest);
+        if (stream.req)
+          stream.req.removeListener("finish", onfinish);
+        stream.removeListener("end", onlegacyfinish);
+        stream.removeListener("close", onlegacyfinish);
+        stream.removeListener("finish", onfinish);
+        stream.removeListener("exit", onexit);
+        stream.removeListener("end", onend);
+        stream.removeListener("error", onerror);
+        stream.removeListener("close", onclose);
+      };
+    };
+    module.exports = eos;
+  }
+});
+
+export {
+  require_end_of_stream
+};

package/dist/chunks/chunk-J7HDA5GH.js

@@ -0,0 +1,54 @@
+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 {
+  STANDARD_ENVIRONMENTS
+} from "./chunk-AQLVWVEN.js";
+import {
+  getCommandName,
+  require_lib
+} from "./chunk-ZLCMHY2G.js";
+import {
+  output_manager_default
+} from "./chunk-FDJURQMQ.js";
+import {
+  require_source
+} from "./chunk-S7KYDPEM.js";
+import {
+  __toESM
+} from "./chunk-TZ2YI2VH.js";
+
+// src/util/target/format-environment.ts
+var import_chalk = __toESM(require_source(), 1);
+var import_title = __toESM(require_lib(), 1);
+function formatEnvironment(orgSlug, projectSlug, environment) {
+  const projectUrl = `https://vercel.com/${orgSlug}/${projectSlug}`;
+  const boldName = import_chalk.default.bold(
+    STANDARD_ENVIRONMENTS.includes(environment.slug) ? (0, import_title.default)(environment.slug) : environment.slug
+  );
+  return output_manager_default.link(
+    boldName,
+    `${projectUrl}/settings/environments/${environment.slug}`,
+    { fallback: () => boldName, color: false }
+  );
+}
+
+// src/util/validate-ls-args.ts
+var import_chalk2 = __toESM(require_source(), 1);
+function validateLsArgs(options) {
+  const { commandName, args, maxArgs = 0, exitCode = 1, usageString } = options;
+  if (args.length > maxArgs) {
+    const usage = usageString || getCommandName(commandName);
+    output_manager_default.error(`Invalid number of arguments. Usage: ${import_chalk2.default.cyan(usage)}`);
+    return exitCode;
+  }
+  return 0;
+}
+
+export {
+  formatEnvironment,
+  validateLsArgs
+};

package/dist/chunks/chunk-JLYZNGYY.js

@@ -0,0 +1,293 @@
+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_dist
+} from "./chunk-FDJURQMQ.js";
+import {
+  __commonJS,
+  __require,
+  __toESM
+} from "./chunk-TZ2YI2VH.js";
+
+// ../../node_modules/.pnpm/@next+env@11.1.2/node_modules/@next/env/dist/index.js
+var require_dist2 = __commonJS({
+  "../../node_modules/.pnpm/@next+env@11.1.2/node_modules/@next/env/dist/index.js"(exports, module) {
+    module.exports = function(n, r) {
+      "use strict";
+      var e = {};
+      function __webpack_require__(r2) {
+        if (e[r2]) {
+          return e[r2].exports;
+        }
+        var t = e[r2] = { i: r2, l: false, exports: {} };
+        n[r2].call(t.exports, t, t.exports, __webpack_require__);
+        t.l = true;
+        return t.exports;
+      }
+      __webpack_require__.ab = __dirname + "/";
+      function startup() {
+        return __webpack_require__(903);
+      }
+      r(__webpack_require__);
+      return startup();
+    }({ 148: function(n) {
+      "use strict";
+      var r = function(n2) {
+        var r2 = n2.ignoreProcessEnv ? {} : process.env;
+        var e = function(t2) {
+          var o2 = t2.match(/(.?\${?(?:[a-zA-Z0-9_]+)?}?)/g) || [];
+          return o2.reduce(function(t3, o3) {
+            var c2 = /(.?)\${?([a-zA-Z0-9_]+)?}?/g.exec(o3);
+            var s = c2[1];
+            var i, f;
+            if (s === "\\") {
+              f = c2[0];
+              i = f.replace("\\$", "$");
+            } else {
+              var p = c2[2];
+              f = c2[0].substring(s.length);
+              i = r2.hasOwnProperty(p) ? r2[p] : n2.parsed[p] || "";
+              i = e(i);
+            }
+            return t3.replace(f, i);
+          }, t2);
+        };
+        for (var t in n2.parsed) {
+          var o = r2.hasOwnProperty(t) ? r2[t] : n2.parsed[t];
+          n2.parsed[t] = e(o);
+        }
+        for (var c in n2.parsed) {
+          r2[c] = n2.parsed[c];
+        }
+        return n2;
+      };
+      n.exports = r;
+    }, 548: function(n, r, e) {
+      const t = e(747);
+      const o = e(622);
+      function log(n2) {
+        console.log(`[dotenv][DEBUG] ${n2}`);
+      }
+      const c = "\n";
+      const s = /^\s*([\w.-]+)\s*=\s*(.*)?\s*$/;
+      const i = /\\n/g;
+      const f = /\n|\r|\r\n/;
+      function parse(n2, r2) {
+        const e2 = Boolean(r2 && r2.debug);
+        const t2 = {};
+        n2.toString().split(f).forEach(function(n3, r3) {
+          const o2 = n3.match(s);
+          if (o2 != null) {
+            const n4 = o2[1];
+            let r4 = o2[2] || "";
+            const e3 = r4.length - 1;
+            const s2 = r4[0] === '"' && r4[e3] === '"';
+            const f2 = r4[0] === "'" && r4[e3] === "'";
+            if (f2 || s2) {
+              r4 = r4.substring(1, e3);
+              if (s2) {
+                r4 = r4.replace(i, c);
+              }
+            } else {
+              r4 = r4.trim();
+            }
+            t2[n4] = r4;
+          } else if (e2) {
+            log(`did not match key and value when parsing line ${r3 + 1}: ${n3}`);
+          }
+        });
+        return t2;
+      }
+      function config(n2) {
+        let r2 = o.resolve(process.cwd(), ".env");
+        let e2 = "utf8";
+        let c2 = false;
+        if (n2) {
+          if (n2.path != null) {
+            r2 = n2.path;
+          }
+          if (n2.encoding != null) {
+            e2 = n2.encoding;
+          }
+          if (n2.debug != null) {
+            c2 = true;
+          }
+        }
+        try {
+          const n3 = parse(t.readFileSync(r2, { encoding: e2 }), { debug: c2 });
+          Object.keys(n3).forEach(function(r3) {
+            if (!Object.prototype.hasOwnProperty.call(process.env, r3)) {
+              process.env[r3] = n3[r3];
+            } else if (c2) {
+              log(`"${r3}" is already defined in \`process.env\` and will not be overwritten`);
+            }
+          });
+          return { parsed: n3 };
+        } catch (n3) {
+          return { error: n3 };
+        }
+      }
+      n.exports.config = config;
+      n.exports.parse = parse;
+    }, 622: function(n) {
+      n.exports = __require("path");
+    }, 747: function(n) {
+      n.exports = __require("fs");
+    }, 903: function(n, r, e) {
+      "use strict";
+      e.r(r);
+      e.d(r, "processEnv", function() {
+        return processEnv;
+      });
+      e.d(r, "loadEnvConfig", function() {
+        return loadEnvConfig;
+      });
+      var t = e(747);
+      var o = e.n(t);
+      var c = e(622);
+      var s = e.n(c);
+      var i = e(548);
+      var f = e.n(i);
+      var p = e(148);
+      var u = e.n(p);
+      let a = void 0;
+      let d = [];
+      function processEnv(n2, r2, e2 = console) {
+        var t2;
+        if (process.env.__NEXT_PROCESSED_ENV || n2.length === 0) {
+          return process.env;
+        }
+        process.env.__NEXT_PROCESSED_ENV = "true";
+        const o2 = Object.assign({}, process.env);
+        const s2 = {};
+        for (const f2 of n2) {
+          try {
+            let n3 = {};
+            n3.parsed = i.parse(f2.contents);
+            n3 = u()(n3);
+            if (n3.parsed) {
+              e2.info(`Loaded env from ${c.join(r2 || "", f2.path)}`);
+            }
+            for (const r3 of Object.keys(n3.parsed || {})) {
+              if (typeof s2[r3] === "undefined" && typeof o2[r3] === "undefined") {
+                s2[r3] = (t2 = n3.parsed) === null || t2 === void 0 ? void 0 : t2[r3];
+              }
+            }
+          } catch (n3) {
+            e2.error(`Failed to load env from ${c.join(r2 || "", f2.path)}`, n3);
+          }
+        }
+        return Object.assign(process.env, s2);
+      }
+      function loadEnvConfig(n2, r2, e2 = console) {
+        if (a)
+          return { combinedEnv: a, loadedEnvFiles: d };
+        const o2 = process.env.NODE_ENV === "test";
+        const s2 = o2 ? "test" : r2 ? "development" : "production";
+        const i2 = [`.env.${s2}.local`, s2 !== "test" && `.env.local`, `.env.${s2}`, ".env"].filter(Boolean);
+        for (const r3 of i2) {
+          const o3 = c.join(n2, r3);
+          try {
+            const n3 = t.statSync(o3);
+            if (!n3.isFile()) {
+              continue;
+            }
+            const c2 = t.readFileSync(o3, "utf8");
+            d.push({ path: r3, contents: c2 });
+          } catch (n3) {
+            if (n3.code !== "ENOENT") {
+              e2.error(`Failed to load env from ${r3}`, n3);
+            }
+          }
+        }
+        a = processEnv(d, n2, e2);
+        return { combinedEnv: a, loadedEnvFiles: d };
+      }
+    } }, function(n) {
+      "use strict";
+      !function() {
+        n.r = function(n2) {
+          if (typeof Symbol !== "undefined" && Symbol.toStringTag) {
+            Object.defineProperty(n2, Symbol.toStringTag, { value: "Module" });
+          }
+          Object.defineProperty(n2, "__esModule", { value: true });
+        };
+      }();
+      !function() {
+        n.n = function(r) {
+          var e = r && r.__esModule ? function getDefault() {
+            return r["default"];
+          } : function getModuleExports() {
+            return r;
+          };
+          n.d(e, "a", e);
+          return e;
+        };
+      }();
+      !function() {
+        var r = Object.prototype.hasOwnProperty;
+        n.d = function(n2, e, t) {
+          if (!r.call(n2, e)) {
+            Object.defineProperty(n2, e, { enumerable: true, get: t });
+          }
+        };
+      }();
+    });
+  }
+});
+
+// src/util/get-invalid-subcommand.ts
+function getInvalidSubcommand(config) {
+  return `Please specify a valid subcommand: ${Object.keys(config).join(
+    " | "
+  )}`;
+}
+
+// src/util/input/read-standard-input.ts
+async function readStandardInput(stdin) {
+  return new Promise((resolve) => {
+    setTimeout(() => resolve(""), 500);
+    if (stdin.isTTY) {
+      resolve("");
+    } else {
+      stdin.setEncoding("utf8");
+      stdin.once("data", resolve);
+    }
+  });
+}
+
+// src/util/target/get-custom-environments.ts
+var import_error_utils = __toESM(require_dist(), 1);
+async function getCustomEnvironments(client, projectId) {
+  try {
+    const res = await client.fetch(
+      `/projects/${encodeURIComponent(projectId)}/custom-environments`,
+      { method: "GET" }
+    );
+    return res.environments;
+  } catch (error) {
+    if ((0, import_error_utils.isObject)(error) && error.status === 404) {
+      return [];
+    }
+    throw error;
+  }
+}
+function pickCustomEnvironment(customEnvironments, customEnvironmentSlugOrId) {
+  if (!customEnvironmentSlugOrId)
+    return void 0;
+  return customEnvironments.find(
+    ({ slug, id }) => slug === customEnvironmentSlugOrId || id === customEnvironmentSlugOrId
+  );
+}
+
+export {
+  getInvalidSubcommand,
+  readStandardInput,
+  getCustomEnvironments,
+  pickCustomEnvironment,
+  require_dist2 as require_dist
+};

package/dist/chunks/chunk-JQ4NA5MX.js

@@ -0,0 +1,250 @@
+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_dist
+} from "./chunk-P4I4DMEU.js";
+import {
+  noBorderChars,
+  require_cli_table3
+} from "./chunk-LWBSOTJP.js";
+import {
+  globalCommandOptions
+} from "./chunk-ZLCMHY2G.js";
+import {
+  require_source
+} from "./chunk-S7KYDPEM.js";
+import {
+  __toESM
+} from "./chunk-TZ2YI2VH.js";
+
+// src/commands/help.ts
+var import_chalk = __toESM(require_source(), 1);
+var import_constants = __toESM(require_dist(), 1);
+var import_cli_table3 = __toESM(require_cli_table3(), 1);
+var INDENT = " ".repeat(2);
+var NEWLINE = "\n";
+var tableOptions = {
+  chars: noBorderChars,
+  style: {
+    "padding-left": 0,
+    "padding-right": 0
+  }
+};
+function wordWrap(text, maxWidth) {
+  const _tableOptions = Object.assign({}, tableOptions, {
+    colWidths: [maxWidth],
+    style: {
+      "padding-left": INDENT.length
+    }
+  });
+  const table = new import_cli_table3.default(_tableOptions);
+  table.push([
+    {
+      content: text,
+      wordWrap: true
+    }
+  ]);
+  return table.toString();
+}
+function lineToString(line) {
+  let string = "";
+  for (let i = 0; i < line.length; i++) {
+    if (i === line.length - 1) {
+      string += line[i];
+    } else {
+      const curr = line[i];
+      const next = line[i + 1];
+      string += curr;
+      if (curr.trim() !== "" && next.trim() !== "") {
+        string += " ";
+      }
+    }
+  }
+  return string;
+}
+function outputArrayToString(outputArray) {
+  return outputArray.filter((line) => line !== null).join(NEWLINE);
+}
+function buildCommandSynopsisLine(command, parent) {
+  const line = [INDENT, import_constants.LOGO, import_chalk.default.bold(import_constants.NAME)];
+  if (parent) {
+    line.push(import_chalk.default.bold(parent.name));
+  }
+  line.push(import_chalk.default.bold(command.name));
+  const args = command.arguments.slice(0);
+  if (args.length === 0 && command.subcommands && command.subcommands.length > 0) {
+    args.push({
+      name: "command",
+      required: !command.subcommands.some((subcommand) => subcommand.default)
+    });
+  }
+  if (args.length > 0) {
+    for (const argument of args) {
+      let { name } = argument;
+      if (argument.multiple) {
+        name += " ...";
+      }
+      line.push(argument.required ? name : `[${name}]`);
+    }
+  }
+  if (command.options.length > 0) {
+    line.push("[options]");
+  }
+  line.push(NEWLINE);
+  return lineToString(line);
+}
+function buildCommandOptionLines(commandOptions, options, sectionTitle) {
+  const filteredCommandOptions = commandOptions.filter(
+    (option) => !option.deprecated && option.description !== void 0
+  );
+  if (filteredCommandOptions.length === 0) {
+    return null;
+  }
+  filteredCommandOptions.sort(
+    (a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0
+  );
+  let maxWidthOfUnwrappedColumns = 0;
+  const rows = [];
+  for (const option of filteredCommandOptions) {
+    const shorthandCell = option.shorthand ? `${INDENT}-${option.shorthand},` : "";
+    let longhandCell = `${INDENT}--${option.name}`;
+    if (option.argument) {
+      longhandCell += ` <${option.argument}>`;
+    }
+    longhandCell += INDENT;
+    const widthOfUnwrappedColumns = shorthandCell.length + longhandCell.length;
+    maxWidthOfUnwrappedColumns = Math.max(
+      widthOfUnwrappedColumns,
+      maxWidthOfUnwrappedColumns
+    );
+    rows.push([
+      shorthandCell,
+      longhandCell,
+      {
+        content: option.description,
+        wordWrap: true
+      }
+    ]);
+  }
+  const finalColumnWidth = options.columns - maxWidthOfUnwrappedColumns;
+  const table = new import_cli_table3.default(
+    Object.assign({}, tableOptions, {
+      colWidths: [null, null, finalColumnWidth]
+    })
+  );
+  table.push(...rows);
+  return [
+    `${INDENT}${import_chalk.default.dim(sectionTitle)}:`,
+    NEWLINE,
+    NEWLINE,
+    table.toString(),
+    NEWLINE,
+    NEWLINE
+  ].join("");
+}
+function buildSubcommandLines(subcommands, options) {
+  if (!subcommands) {
+    return null;
+  }
+  let maxWidthOfUnwrappedColumns = 0;
+  const rows = [];
+  for (const command of subcommands) {
+    if (command.hidden) {
+      continue;
+    }
+    const nameCell = `${INDENT}${command.name}`;
+    let argsCell = INDENT;
+    argsCell += command.arguments.map((arg) => {
+      return arg.required ? arg.name : `[${arg.name}]`;
+    }).join(" ");
+    argsCell += INDENT;
+    const widthOfUnwrappedColumns = nameCell.length + argsCell.length;
+    maxWidthOfUnwrappedColumns = Math.max(
+      widthOfUnwrappedColumns,
+      maxWidthOfUnwrappedColumns
+    );
+    rows.push([
+      nameCell,
+      argsCell,
+      {
+        content: command.default ? `${command.description} ${import_chalk.default.bold("(default)")}` : command.description,
+        wordWrap: true
+      }
+    ]);
+  }
+  const rightMargin = INDENT.repeat(4).length;
+  const finalColumnWidth = options.columns - maxWidthOfUnwrappedColumns - rightMargin;
+  const table = new import_cli_table3.default(
+    Object.assign({}, tableOptions, {
+      colWidths: [null, null, finalColumnWidth]
+    })
+  );
+  if (rows.length === 0) {
+    return null;
+  }
+  table.push(...rows);
+  return [
+    `${INDENT}${import_chalk.default.dim("Commands")}:`,
+    NEWLINE,
+    NEWLINE,
+    table.toString(),
+    NEWLINE,
+    NEWLINE
+  ].join("");
+}
+function buildCommandExampleLines(command) {
+  if (!command.examples?.length) {
+    return null;
+  }
+  const outputArray = [`${INDENT}${import_chalk.default.dim("Examples:")}`, ""];
+  for (const example of command.examples) {
+    const nameLine = [INDENT];
+    nameLine.push(import_chalk.default.gray("-"));
+    nameLine.push(example.name);
+    outputArray.push(lineToString(nameLine));
+    outputArray.push("");
+    const buildValueLine = (value) => {
+      return lineToString([INDENT, INDENT, import_chalk.default.cyan(`$ ${value}`)]);
+    };
+    if (Array.isArray(example.value)) {
+      for (const line of example.value) {
+        outputArray.push(buildValueLine(line));
+      }
+    } else {
+      outputArray.push(buildValueLine(example.value));
+    }
+    outputArray.push("");
+  }
+  return outputArrayToString(outputArray);
+}
+function buildDescriptionLine(command, options) {
+  const wrappingText = wordWrap(command.description, options.columns);
+  return `${wrappingText}${NEWLINE}`;
+}
+function buildHelpOutput(command, options) {
+  const outputArray = [
+    "",
+    buildCommandSynopsisLine(command, options.parent),
+    buildDescriptionLine(command, options),
+    buildSubcommandLines(command.subcommands, options),
+    buildCommandOptionLines(command.options, options, "Options"),
+    buildCommandOptionLines(globalCommandOptions, options, "Global Options"),
+    buildCommandExampleLines(command),
+    ""
+  ];
+  return outputArrayToString(outputArray);
+}
+function help(command, options) {
+  return buildHelpOutput(command, {
+    ...options,
+    columns: options.columns ?? 80
+  });
+}
+
+export {
+  help
+};