orcaq 1.0.20

package/.output/server/node_modules/@vercel/oidc/dist/get-vercel-oidc-token.js

@@ -0,0 +1,80 @@
+"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_vercel_oidc_token_exports = {};
+__export(get_vercel_oidc_token_exports, {
+  getVercelOidcToken: () => getVercelOidcToken,
+  getVercelOidcTokenSync: () => getVercelOidcTokenSync
+});
+module.exports = __toCommonJS(get_vercel_oidc_token_exports);
+var import_get_context = require("./get-context");
+var import_token_error = require("./token-error");
+async function getVercelOidcToken() {
+  let token = "";
+  let err;
+  try {
+    token = getVercelOidcTokenSync();
+  } catch (error) {
+    err = error;
+  }
+  try {
+    const [{ getTokenPayload, isExpired }, { refreshToken }] = await Promise.all([
+      await import("./token-util.js"),
+      await import("./token.js")
+    ]);
+    if (!token || isExpired(getTokenPayload(token))) {
+      await refreshToken();
+      token = getVercelOidcTokenSync();
+    }
+  } catch (error) {
+    let message = err instanceof Error ? err.message : "";
+    if (error instanceof Error) {
+      message = `${message}
+${error.message}`;
+    }
+    if (message) {
+      throw new import_token_error.VercelOidcTokenError(message);
+    }
+    throw error;
+  }
+  return token;
+}
+function getVercelOidcTokenSync() {
+  const token = (0, import_get_context.getContext)().headers?.["x-vercel-oidc-token"] ?? process.env.VERCEL_OIDC_TOKEN;
+  if (!token) {
+    throw new Error(
+      `The 'x-vercel-oidc-token' header is missing from the request. Do you have the OIDC option enabled in the Vercel project settings?`
+    );
+  }
+  return token;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getVercelOidcToken,
+  getVercelOidcTokenSync
+});

package/.output/server/node_modules/@vercel/oidc/dist/index.js

@@ -0,0 +1,33 @@
+"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 src_exports = {};
+__export(src_exports, {
+  getContext: () => import_get_context.getContext,
+  getVercelOidcToken: () => import_get_vercel_oidc_token.getVercelOidcToken,
+  getVercelOidcTokenSync: () => import_get_vercel_oidc_token.getVercelOidcTokenSync
+});
+module.exports = __toCommonJS(src_exports);
+var import_get_vercel_oidc_token = require("./get-vercel-oidc-token");
+var import_get_context = require("./get-context");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getContext,
+  getVercelOidcToken,
+  getVercelOidcTokenSync
+});

package/.output/server/node_modules/@vercel/oidc/dist/oauth.js

@@ -0,0 +1,88 @@
+"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 oauth_exports = {};
+__export(oauth_exports, {
+  processTokenResponse: () => processTokenResponse,
+  refreshTokenRequest: () => refreshTokenRequest
+});
+module.exports = __toCommonJS(oauth_exports);
+var import_os = require("os");
+const VERCEL_ISSUER = "https://vercel.com";
+const VERCEL_CLI_CLIENT_ID = "cl_HYyOPBNtFMfHhaUn9L4QPfTZz6TP47bp";
+const userAgent = `@vercel/oidc node-${process.version} ${(0, import_os.platform)()} (${(0, import_os.arch)()}) ${(0, import_os.hostname)()}`;
+let _tokenEndpoint = null;
+async function getTokenEndpoint() {
+  if (_tokenEndpoint) {
+    return _tokenEndpoint;
+  }
+  const discoveryUrl = `${VERCEL_ISSUER}/.well-known/openid-configuration`;
+  const response = await fetch(discoveryUrl, {
+    headers: { "user-agent": userAgent }
+  });
+  if (!response.ok) {
+    throw new Error("Failed to discover OAuth endpoints");
+  }
+  const metadata = await response.json();
+  if (!metadata || typeof metadata.token_endpoint !== "string") {
+    throw new Error("Invalid OAuth discovery response");
+  }
+  const endpoint = metadata.token_endpoint;
+  _tokenEndpoint = endpoint;
+  return endpoint;
+}
+async function refreshTokenRequest(options) {
+  const tokenEndpoint = await getTokenEndpoint();
+  return await fetch(tokenEndpoint, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded",
+      "user-agent": userAgent
+    },
+    body: new URLSearchParams({
+      client_id: VERCEL_CLI_CLIENT_ID,
+      grant_type: "refresh_token",
+      ...options
+    })
+  });
+}
+async function processTokenResponse(response) {
+  const json = await response.json();
+  if (!response.ok) {
+    const errorMsg = typeof json === "object" && json && "error" in json ? String(json.error) : "Token refresh failed";
+    return [new Error(errorMsg)];
+  }
+  if (typeof json !== "object" || json === null) {
+    return [new Error("Invalid token response")];
+  }
+  if (typeof json.access_token !== "string") {
+    return [new Error("Missing access_token in response")];
+  }
+  if (json.token_type !== "Bearer") {
+    return [new Error("Invalid token_type in response")];
+  }
+  if (typeof json.expires_in !== "number") {
+    return [new Error("Missing expires_in in response")];
+  }
+  return [null, json];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  processTokenResponse,
+  refreshTokenRequest
+});

package/.output/server/node_modules/@vercel/oidc/dist/token-error.js

@@ -0,0 +1,40 @@
+"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 token_error_exports = {};
+__export(token_error_exports, {
+  VercelOidcTokenError: () => VercelOidcTokenError
+});
+module.exports = __toCommonJS(token_error_exports);
+class VercelOidcTokenError extends Error {
+  constructor(message, cause) {
+    super(message);
+    this.name = "VercelOidcTokenError";
+    this.cause = cause;
+  }
+  toString() {
+    if (this.cause) {
+      return `${this.name}: ${this.message}: ${this.cause}`;
+    }
+    return `${this.name}: ${this.message}`;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  VercelOidcTokenError
+});

package/.output/server/node_modules/@vercel/oidc/dist/token-io.js

@@ -0,0 +1,78 @@
+"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 token_io_exports = {};
+__export(token_io_exports, {
+  findRootDir: () => findRootDir,
+  getUserDataDir: () => getUserDataDir
+});
+module.exports = __toCommonJS(token_io_exports);
+var import_path = __toESM(require("path"));
+var import_fs = __toESM(require("fs"));
+var import_os = __toESM(require("os"));
+var import_token_error = require("./token-error");
+function findRootDir() {
+  try {
+    let dir = process.cwd();
+    while (dir !== import_path.default.dirname(dir)) {
+      const pkgPath = import_path.default.join(dir, ".vercel");
+      if (import_fs.default.existsSync(pkgPath)) {
+        return dir;
+      }
+      dir = import_path.default.dirname(dir);
+    }
+  } catch (e) {
+    throw new import_token_error.VercelOidcTokenError(
+      "Token refresh only supported in node server environments"
+    );
+  }
+  return null;
+}
+function getUserDataDir() {
+  if (process.env.XDG_DATA_HOME) {
+    return process.env.XDG_DATA_HOME;
+  }
+  switch (import_os.default.platform()) {
+    case "darwin":
+      return import_path.default.join(import_os.default.homedir(), "Library/Application Support");
+    case "linux":
+      return import_path.default.join(import_os.default.homedir(), ".local/share");
+    case "win32":
+      if (process.env.LOCALAPPDATA) {
+        return process.env.LOCALAPPDATA;
+      }
+      return null;
+    default:
+      return null;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  findRootDir,
+  getUserDataDir
+});

package/.output/server/node_modules/@vercel/oidc/dist/token-util.js

@@ -0,0 +1,198 @@
+"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 token_util_exports = {};
+__export(token_util_exports, {
+  assertVercelOidcTokenResponse: () => assertVercelOidcTokenResponse,
+  findProjectInfo: () => findProjectInfo,
+  getTokenPayload: () => getTokenPayload,
+  getVercelCliToken: () => getVercelCliToken,
+  getVercelDataDir: () => getVercelDataDir,
+  getVercelOidcToken: () => getVercelOidcToken,
+  isExpired: () => isExpired,
+  loadToken: () => loadToken,
+  saveToken: () => saveToken
+});
+module.exports = __toCommonJS(token_util_exports);
+var path = __toESM(require("path"));
+var fs = __toESM(require("fs"));
+var import_token_error = require("./token-error");
+var import_token_io = require("./token-io");
+var import_auth_config = require("./auth-config");
+var import_oauth = require("./oauth");
+function getVercelDataDir() {
+  const vercelFolder = "com.vercel.cli";
+  const dataDir = (0, import_token_io.getUserDataDir)();
+  if (!dataDir) {
+    return null;
+  }
+  return path.join(dataDir, vercelFolder);
+}
+async function getVercelCliToken() {
+  const authConfig = (0, import_auth_config.readAuthConfig)();
+  if (!authConfig) {
+    return null;
+  }
+  if ((0, import_auth_config.isValidAccessToken)(authConfig)) {
+    return authConfig.token || null;
+  }
+  if (!authConfig.refreshToken) {
+    (0, import_auth_config.writeAuthConfig)({});
+    return null;
+  }
+  try {
+    const tokenResponse = await (0, import_oauth.refreshTokenRequest)({
+      refresh_token: authConfig.refreshToken
+    });
+    const [tokensError, tokens] = await (0, import_oauth.processTokenResponse)(tokenResponse);
+    if (tokensError || !tokens) {
+      (0, import_auth_config.writeAuthConfig)({});
+      return null;
+    }
+    const updatedConfig = {
+      token: tokens.access_token,
+      expiresAt: Math.floor(Date.now() / 1e3) + tokens.expires_in
+    };
+    if (tokens.refresh_token) {
+      updatedConfig.refreshToken = tokens.refresh_token;
+    }
+    (0, import_auth_config.writeAuthConfig)(updatedConfig);
+    return updatedConfig.token ?? null;
+  } catch (error) {
+    (0, import_auth_config.writeAuthConfig)({});
+    return null;
+  }
+}
+async function getVercelOidcToken(authToken, projectId, teamId) {
+  const url = `https://api.vercel.com/v1/projects/${projectId}/token?source=vercel-oidc-refresh${teamId ? `&teamId=${teamId}` : ""}`;
+  const res = await fetch(url, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${authToken}`
+    }
+  });
+  if (!res.ok) {
+    throw new import_token_error.VercelOidcTokenError(
+      `Failed to refresh OIDC token: ${res.statusText}`
+    );
+  }
+  const tokenRes = await res.json();
+  assertVercelOidcTokenResponse(tokenRes);
+  return tokenRes;
+}
+function assertVercelOidcTokenResponse(res) {
+  if (!res || typeof res !== "object") {
+    throw new TypeError(
+      "Vercel OIDC token is malformed. Expected an object. Please run `vc env pull` and try again"
+    );
+  }
+  if (!("token" in res) || typeof res.token !== "string") {
+    throw new TypeError(
+      "Vercel OIDC token is malformed. Expected a string-valued token property. Please run `vc env pull` and try again"
+    );
+  }
+}
+function findProjectInfo() {
+  const dir = (0, import_token_io.findRootDir)();
+  if (!dir) {
+    throw new import_token_error.VercelOidcTokenError(
+      "Unable to find project root directory. Have you linked your project with `vc link?`"
+    );
+  }
+  const prjPath = path.join(dir, ".vercel", "project.json");
+  if (!fs.existsSync(prjPath)) {
+    throw new import_token_error.VercelOidcTokenError(
+      "project.json not found, have you linked your project with `vc link?`"
+    );
+  }
+  const prj = JSON.parse(fs.readFileSync(prjPath, "utf8"));
+  if (typeof prj.projectId !== "string" && typeof prj.orgId !== "string") {
+    throw new TypeError(
+      "Expected a string-valued projectId property. Try running `vc link` to re-link your project."
+    );
+  }
+  return { projectId: prj.projectId, teamId: prj.orgId };
+}
+function saveToken(token, projectId) {
+  const dir = (0, import_token_io.getUserDataDir)();
+  if (!dir) {
+    throw new import_token_error.VercelOidcTokenError(
+      "Unable to find user data directory. Please reach out to Vercel support."
+    );
+  }
+  const tokenPath = path.join(dir, "com.vercel.token", `${projectId}.json`);
+  const tokenJson = JSON.stringify(token);
+  fs.mkdirSync(path.dirname(tokenPath), { mode: 504, recursive: true });
+  fs.writeFileSync(tokenPath, tokenJson);
+  fs.chmodSync(tokenPath, 432);
+  return;
+}
+function loadToken(projectId) {
+  const dir = (0, import_token_io.getUserDataDir)();
+  if (!dir) {
+    throw new import_token_error.VercelOidcTokenError(
+      "Unable to find user data directory. Please reach out to Vercel support."
+    );
+  }
+  const tokenPath = path.join(dir, "com.vercel.token", `${projectId}.json`);
+  if (!fs.existsSync(tokenPath)) {
+    return null;
+  }
+  const token = JSON.parse(fs.readFileSync(tokenPath, "utf8"));
+  assertVercelOidcTokenResponse(token);
+  return token;
+}
+function getTokenPayload(token) {
+  const tokenParts = token.split(".");
+  if (tokenParts.length !== 3) {
+    throw new import_token_error.VercelOidcTokenError(
+      "Invalid token. Please run `vc env pull` and try again"
+    );
+  }
+  const base64 = tokenParts[1].replace(/-/g, "+").replace(/_/g, "/");
+  const padded = base64.padEnd(
+    base64.length + (4 - base64.length % 4) % 4,
+    "="
+  );
+  return JSON.parse(Buffer.from(padded, "base64").toString("utf8"));
+}
+function isExpired(token) {
+  return token.exp * 1e3 < Date.now();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  assertVercelOidcTokenResponse,
+  findProjectInfo,
+  getTokenPayload,
+  getVercelCliToken,
+  getVercelDataDir,
+  getVercelOidcToken,
+  isExpired,
+  loadToken,
+  saveToken
+});

package/.output/server/node_modules/@vercel/oidc/dist/token.js

@@ -0,0 +1,53 @@
+"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 token_exports = {};
+__export(token_exports, {
+  refreshToken: () => refreshToken
+});
+module.exports = __toCommonJS(token_exports);
+var import_token_error = require("./token-error");
+var import_token_util = require("./token-util");
+async function refreshToken() {
+  const { projectId, teamId } = (0, import_token_util.findProjectInfo)();
+  let maybeToken = (0, import_token_util.loadToken)(projectId);
+  if (!maybeToken || (0, import_token_util.isExpired)((0, import_token_util.getTokenPayload)(maybeToken.token))) {
+    const authToken = await (0, import_token_util.getVercelCliToken)();
+    if (!authToken) {
+      throw new import_token_error.VercelOidcTokenError(
+        "Failed to refresh OIDC token: Log in to Vercel CLI and link your project with `vc link`"
+      );
+    }
+    if (!projectId) {
+      throw new import_token_error.VercelOidcTokenError(
+        "Failed to refresh OIDC token: Try re-linking your project with `vc link`"
+      );
+    }
+    maybeToken = await (0, import_token_util.getVercelOidcToken)(authToken, projectId, teamId);
+    if (!maybeToken) {
+      throw new import_token_error.VercelOidcTokenError("Failed to refresh OIDC token");
+    }
+    (0, import_token_util.saveToken)(maybeToken, projectId);
+  }
+  process.env.VERCEL_OIDC_TOKEN = maybeToken.token;
+  return;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  refreshToken
+});

package/.output/server/node_modules/@vercel/oidc/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@vercel/oidc",
+  "description": "Runtime OIDC helpers intended for use with Vercel Functions",
+  "homepage": "https://vercel.com",
+  "files": [
+    "**/*.js",
+    "**/*.d.ts",
+    "**/*.md"
+  ],
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "browser": "./dist/index-browser.js",
+      "react-native": "./dist/index-browser.js",
+      "workflow": "./dist/index-browser.js",
+      "import": "./dist/index.js",
+      "require": "./dist/index.js"
+    }
+  },
+  "version": "3.1.0",
+  "repository": {
+    "directory": "packages/oidc",
+    "type": "git",
+    "url": "git+https://github.com/vercel/vercel.git"
+  },
+  "bugs": {
+    "url": "https://github.com/vercel/vercel/issues"
+  },
+  "devDependencies": {
+    "tinyspawn": "1.3.1",
+    "typedoc": "0.24.6",
+    "typedoc-plugin-markdown": "4.1.2",
+    "typedoc-plugin-mdn-links": "3.2.3",
+    "typescript": "4.9.5",
+    "vitest": "2.0.1"
+  },
+  "peerDependenciesMeta": {},
+  "engines": {
+    "node": ">= 20"
+  },
+  "license": "Apache-2.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "pretest": "pnpm run build:code",
+    "test": "vitest",
+    "build": "pnpm run build:code && pnpm run build:docs",
+    "build:code": "node ../../utils/build.mjs",
+    "build:docs": "typedoc && prettier --write docs/**/*.md docs/*.md"
+  }
+}