vite-plugin-vercel 9.0.6 → 10.0.0-beta.0

package/dist/index.cjs

@@ -1,829 +0,0 @@
-"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);
-
-// src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  default: () => allPlugins
-});
-module.exports = __toCommonJS(src_exports);
-var import_promises5 = __toESM(require("fs/promises"), 1);
-var import_node_path6 = __toESM(require("path"), 1);
-
-// src/build.ts
-var import_promises = __toESM(require("fs/promises"), 1);
-var import_node_module = require("module");
-var import_node_path2 = __toESM(require("path"), 1);
-var import_find_root = require("@manypkg/find-root");
-var import_build_utils = require("@vercel/build-utils");
-var import_nft = require("@vercel/nft");
-var import_esbuild = require("esbuild");
-var import_fast_glob = __toESM(require("fast-glob"), 1);
-var import_magicast = require("magicast");
-
-// src/assert.ts
-var import_libassert = require("@brillout/libassert");
-var libName = "vite-plugin-vercel";
-function assert(condition, errorMessage) {
-  if (condition) {
-    return;
-  }
-  const err = (0, import_libassert.newError)(`[${libName}][Wrong Usage] ${errorMessage}`, 2);
-  throw err;
-}
-
-// src/schemas/config/vc-config.ts
-var import_zod = require("zod");
-var vercelOutputEdgeVcConfigSchema = import_zod.z.object({
-  runtime: import_zod.z.literal("edge"),
-  entrypoint: import_zod.z.string(),
-  envVarsInUse: import_zod.z.array(import_zod.z.string()).optional()
-}).strict();
-var vercelOutputServerlessVcConfigSchema = import_zod.z.object({
-  runtime: import_zod.z.string(),
-  handler: import_zod.z.string(),
-  memory: import_zod.z.number().int().min(128).max(3008).optional(),
-  maxDuration: import_zod.z.number().int().positive().optional(),
-  environment: import_zod.z.record(import_zod.z.string()).optional(),
-  regions: import_zod.z.array(import_zod.z.string()).optional(),
-  supportsWrapper: import_zod.z.boolean().optional(),
-  supportsResponseStreaming: import_zod.z.boolean().optional()
-}).strict();
-var vercelOutputServerlessNodeVcConfigSchema = vercelOutputServerlessVcConfigSchema.extend({
-  launcherType: import_zod.z.literal("Nodejs"),
-  shouldAddHelpers: import_zod.z.boolean().optional(),
-  shouldAddSourcemapSupport: import_zod.z.boolean().optional(),
-  awsLambdaHandler: import_zod.z.string().optional()
-}).strict();
-var vercelOutputVcConfigSchema = import_zod.z.union([
-  vercelOutputEdgeVcConfigSchema,
-  vercelOutputServerlessVcConfigSchema,
-  vercelOutputServerlessNodeVcConfigSchema
-]);
-
-// src/schemas/exports.ts
-var import_zod2 = require("zod");
-var vercelEndpointExports = import_zod2.z.object({
-  edge: import_zod2.z.boolean().optional(),
-  headers: import_zod2.z.record(import_zod2.z.string()).optional(),
-  streaming: import_zod2.z.boolean().optional(),
-  isr: import_zod2.z.object({
-    expiration: import_zod2.z.number().or(import_zod2.z.literal(false))
-  }).optional()
-});
-
-// src/utils.ts
-var import_vite = require("vite");
-var import_node_path = __toESM(require("path"), 1);
-function getRoot(config) {
-  return (0, import_vite.normalizePath)(config.root || process.cwd());
-}
-function getOutput(config, suffix) {
-  return import_node_path.default.join(
-    config.vercel?.outDir ? "" : getRoot(config),
-    config.vercel?.outDir ?? ".vercel/output",
-    suffix ?? ""
-  );
-}
-function getPublic(config) {
-  return import_node_path.default.join(getRoot(config), config.publicDir || "public");
-}
-function pathRelativeTo(filePath, config, rel) {
-  const root = getRoot(config);
-  return (0, import_vite.normalizePath)(import_node_path.default.relative((0, import_vite.normalizePath)(import_node_path.default.join(root, rel)), filePath));
-}
-
-// src/build.ts
-async function getAdditionalEndpoints(resolvedConfig) {
-  const userEndpoints = [];
-  if (Array.isArray(resolvedConfig.vercel?.additionalEndpoints)) {
-    for (const endpoint of resolvedConfig.vercel.additionalEndpoints) {
-      if (typeof endpoint === "function") {
-        const res = await endpoint();
-        if (Array.isArray(res)) {
-          userEndpoints.push(...res);
-        } else {
-          userEndpoints.push(res);
-        }
-      } else {
-        userEndpoints.push(endpoint);
-      }
-    }
-  }
-  return userEndpoints.map((e) => ({
-    ...e,
-    route: e.route ?? true,
-    // path.resolve removes the trailing slash if any
-    destination: `${import_node_path2.default.posix.resolve("/", e.destination)}.func`
-  }));
-}
-async function getEntries(resolvedConfig) {
-  const apiEntries = import_fast_glob.default.sync(`${getRoot(resolvedConfig)}/api/**/*.*([a-zA-Z0-9])`).filter((filepath) => !import_node_path2.default.basename(filepath).startsWith("_"));
-  if (apiEntries.length > 0) {
-    console.warn(
-      "@vercel/build is currently force building /api files itself, with no way to disable it. In order to avoid double compilation, you should temporarily rename /api to /_api while using this plugin. /_api functions are compiled under .vercel/output/functions/api/*.func as if they were in /api."
-    );
-  }
-  const otherApiEntries = import_fast_glob.default.sync(`${getRoot(resolvedConfig)}/_api/**/*.*([a-zA-Z0-9])`).filter((filepath) => !import_node_path2.default.basename(filepath).startsWith("_"));
-  return [...apiEntries, ...otherApiEntries].reduce(
-    (entryPoints, filePath) => {
-      const outFilePath = pathRelativeTo(filePath, resolvedConfig, filePath.includes("/_api/") ? "_api" : "api");
-      const parsed = import_node_path2.default.posix.parse(outFilePath);
-      entryPoints.push({
-        source: filePath,
-        destination: `api/${import_node_path2.default.posix.join(parsed.dir, parsed.name)}.func`,
-        route: true
-      });
-      return entryPoints;
-    },
-    await getAdditionalEndpoints(resolvedConfig)
-  );
-}
-var edgeWasmPlugin = {
-  name: "edge-wasm-vercel",
-  setup(build2) {
-    build2.onResolve({ filter: /\.wasm/ }, (args) => {
-      return {
-        path: args.path.replace(/\.wasm\?module$/i, ".wasm"),
-        external: true
-      };
-    });
-  }
-};
-var vercelOgPlugin = (ctx) => {
-  return {
-    name: "vercel-og",
-    setup(build2) {
-      build2.onResolve({ filter: /@vercel\/og/ }, () => {
-        ctx.found = true;
-        return void 0;
-      });
-      build2.onLoad({ filter: /@vercel\/og/ }, (args) => {
-        ctx.index = args.path;
-        return void 0;
-      });
-    }
-  };
-};
-var standardBuildOptions = {
-  bundle: true,
-  target: "es2022",
-  format: "esm",
-  platform: "node",
-  logLevel: "info",
-  logOverride: {
-    "ignored-bare-import": "verbose",
-    "require-resolve-not-external": "verbose"
-  },
-  minify: false,
-  plugins: [],
-  define: {
-    "process.env.NODE_ENV": '"production"',
-    "import.meta.env.NODE_ENV": '"production"'
-  }
-};
-async function buildFn(resolvedConfig, entry, buildOptions) {
-  assert(
-    entry.destination.length > 0,
-    `Endpoint ${typeof entry.source === "string" ? entry.source : "-"} does not have build destination`
-  );
-  const options = Object.assign({}, standardBuildOptions);
-  if (buildOptions) {
-    Object.assign(options, buildOptions);
-  }
-  const filename = entry.edge || options.format === "cjs" ? "index.js" : "index.mjs";
-  const outfile = import_node_path2.default.join(getOutput(resolvedConfig, "functions"), entry.destination, filename);
-  Object.assign(options, { outfile });
-  if (!options.stdin) {
-    if (typeof entry.source === "string") {
-      options.entryPoints = [entry.source];
-    } else {
-      assert(typeof entry.source === "object", "`{ source }` must be a string or an object");
-      assert(typeof entry.source.contents === "string", "`{ contents }` must be a string");
-      options.stdin = entry.source;
-    }
-  }
-  if (entry.edge) {
-    options.platform = void 0;
-    options.external = [...import_node_module.builtinModules, ...import_node_module.builtinModules.map((m) => `node:${m}`)];
-    options.conditions = ["edge-light", "worker", "browser", "module", "import", "require"];
-    options.plugins?.push(edgeWasmPlugin);
-    options.format = "esm";
-  } else if (options.format === "esm") {
-    options.banner = {
-      js: `import { createRequire as VPV_createRequire } from "node:module";
-import { fileURLToPath as VPV_fileURLToPath } from "node:url";
-import { dirname as VPV_dirname } from "node:path";
-const require = VPV_createRequire(import.meta.url);
-const __filename = VPV_fileURLToPath(import.meta.url);
-const __dirname = VPV_dirname(__filename);
-`
-    };
-  }
-  const ctx = { found: false, index: "" };
-  options.plugins?.push(vercelOgPlugin(ctx));
-  const output = await (0, import_esbuild.build)(options);
-  if (typeof entry.source === "string") {
-    let base = resolvedConfig.root;
-    try {
-      const dir = await (0, import_find_root.findRoot)(resolvedConfig.root);
-      base = dir.rootDir;
-    } catch (e) {
-    }
-    const { fileList, reasons } = await (0, import_nft.nodeFileTrace)([entry.source], {
-      base,
-      processCwd: resolvedConfig.root,
-      mixedModules: true,
-      ignore: [
-        "**/node_modules/react{,-dom,-dom-server-turbopack}/**/*.development.js",
-        "**/*.d.ts",
-        "**/*.map",
-        "**/node_modules/webpack5/**/*"
-      ],
-      async readFile(filepath) {
-        if (filepath.endsWith(".ts") || filepath.endsWith(".tsx")) {
-          const result = await (0, import_esbuild.build)({
-            ...standardBuildOptions,
-            entryPoints: [entry.source],
-            bundle: false,
-            write: false
-          });
-          return result.outputFiles[0].text;
-        }
-        return import_promises.default.readFile(filepath, "utf-8");
-      }
-    });
-    for (const file of fileList) {
-      if (reasons.has(file) && reasons.get(file)?.type.includes("asset") && !file.endsWith(".js") && !file.endsWith(".cjs") && !file.endsWith(".mjs") && !file.endsWith("package.json")) {
-        await (0, import_promises.copyFile)(
-          import_node_path2.default.join(base, file),
-          import_node_path2.default.join(getOutput(resolvedConfig, "functions"), entry.destination, (0, import_node_path2.basename)(file))
-        );
-      }
-    }
-  }
-  await writeVcConfig(resolvedConfig, entry.destination, filename, {
-    edge: Boolean(entry.edge),
-    streaming: entry.streaming
-  });
-  return output;
-}
-async function writeVcConfig(resolvedConfig, destination, filename, options) {
-  const vcConfig = import_node_path2.default.join(getOutput(resolvedConfig, "functions"), destination, ".vc-config.json");
-  const nodeVersion = await (0, import_build_utils.getNodeVersion)(getOutput(resolvedConfig));
-  await import_promises.default.writeFile(
-    vcConfig,
-    JSON.stringify(
-      vercelOutputVcConfigSchema.parse(
-        options.edge ? {
-          runtime: "edge",
-          entrypoint: filename
-        } : {
-          runtime: nodeVersion.runtime,
-          handler: filename,
-          maxDuration: resolvedConfig.vercel?.defaultMaxDuration,
-          launcherType: "Nodejs",
-          shouldAddHelpers: true,
-          supportsResponseStreaming: options.streaming ?? resolvedConfig.vercel?.defaultSupportsResponseStreaming
-        }
-      ),
-      void 0,
-      2
-    ),
-    "utf-8"
-  );
-}
-function getSourceAndDestination(destination) {
-  if (destination.startsWith("api/")) {
-    return import_node_path2.default.posix.resolve("/", destination);
-  }
-  return import_node_path2.default.posix.resolve("/", destination, ":match*");
-}
-var RE_BRACKETS = /^\[([^/]+)\]$/gm;
-function replaceBrackets(source) {
-  return source.split("/").map((segment) => segment.replace(RE_BRACKETS, ":$1")).join("/");
-}
-function isPrimitive(test) {
-  return test !== Object(test);
-}
-function _eval(code) {
-  const func = new Function(`{ return function(){ return ${code} } };`);
-  return func.call(null).call(null);
-}
-function evalExport(exp) {
-  if (!exp) return;
-  const code = isPrimitive(exp) ? exp : (0, import_magicast.generateCode)(exp).code;
-  return _eval(code);
-}
-async function extractExports(filepath) {
-  try {
-    const mod = await (0, import_magicast.loadFile)(filepath);
-    const subject = {
-      edge: evalExport(mod.exports.edge),
-      headers: evalExport(mod.exports.headers),
-      streaming: evalExport(mod.exports.streaming),
-      isr: evalExport(mod.exports.isr)
-    };
-    return vercelEndpointExports.parse(subject);
-  } catch (e) {
-    console.warn(`Warning: failed to read exports of '${filepath}'`, e);
-  }
-}
-async function extractHeaders(resolvedConfig) {
-  let headers = [];
-  if (typeof resolvedConfig.vercel?.headers === "function") {
-    headers = await resolvedConfig.vercel.headers();
-  } else if (Array.isArray(resolvedConfig.vercel?.headers)) {
-    headers = resolvedConfig.vercel.headers;
-  }
-  return headers;
-}
-async function buildEndpoints(resolvedConfig) {
-  const entries = await getEntries(resolvedConfig);
-  const headers = await extractHeaders(resolvedConfig);
-  for (const entry of entries) {
-    if (typeof entry.source === "string") {
-      const exports2 = await extractExports(entry.source);
-      if (exports2) {
-        if (entry.headers || exports2.headers) {
-          entry.headers = {
-            ...exports2.headers,
-            ...entry.headers
-          };
-        }
-        if (entry.edge !== void 0 && exports2.edge !== void 0) {
-          throw new Error(
-            `edge configuration should be defined either in the endpoint itself or through Vite config, not both ('${entry.source}')`
-          );
-        }
-        if (exports2.edge !== void 0) {
-          entry.edge = exports2.edge;
-        }
-        if (entry.isr !== void 0 && exports2.isr !== void 0) {
-          throw new Error(
-            `isr configuration should be defined either in the endpoint itself or through Vite config, not both ('${entry.source}')`
-          );
-        }
-        if ((entry.isr !== void 0 || exports2.isr !== void 0) && (entry.edge !== void 0 || exports2.edge !== void 0)) {
-          throw new Error(`isr cannot be enabled for edge functions ('${entry.source}')`);
-        }
-        if (exports2.isr) {
-          entry.isr = exports2.isr;
-        }
-        if (typeof exports2.streaming === "boolean") {
-          entry.streaming = exports2.streaming;
-        }
-      }
-    }
-    await buildFn(resolvedConfig, entry, entry.buildOptions);
-  }
-  const isrEntries = entries.filter((e) => e.isr).map((e) => [e.destination.replace(/\.func$/, ""), { expiration: e.isr?.expiration }]);
-  return {
-    rewrites: entries.filter((e) => {
-      if (e.addRoute === void 0 && e.route !== void 0) {
-        return e.route !== false;
-      }
-      if (e.addRoute !== void 0 && e.route === void 0) {
-        return e.addRoute !== false;
-      }
-      if (e.addRoute !== void 0 && e.route !== void 0) {
-        throw new Error("Cannot use both `route` and `addRoute` in `additionalEndpoints`");
-      }
-      return true;
-    }).map((e) => {
-      const destination = e.destination.replace(/\.func$/, "");
-      if (typeof e.route === "string") {
-        return {
-          source: `(${e.route})`,
-          destination: `${destination}/?__original_path=$1`
-        };
-      }
-      return {
-        source: replaceBrackets(getSourceAndDestination(destination)),
-        destination: getSourceAndDestination(destination)
-      };
-    }),
-    isr: Object.fromEntries(isrEntries),
-    headers: [
-      ...entries.filter((e) => e.headers).map((e) => ({
-        source: `/${e.destination.replace(/\.func$/, "")}`,
-        headers: Object.entries(e.headers ?? {}).map(([key, value]) => ({
-          key,
-          value
-        }))
-      })),
-      ...headers
-    ]
-  };
-}
-
-// src/config.ts
-var import_node_path3 = __toESM(require("path"), 1);
-
-// src/schemas/config/config.ts
-var import_zod3 = require("zod");
-var HasOrMissing = import_zod3.z.array(
-  import_zod3.z.union([
-    import_zod3.z.object({
-      type: import_zod3.z.literal("host"),
-      value: import_zod3.z.string()
-    }).strict(),
-    import_zod3.z.object({
-      type: import_zod3.z.literal("header"),
-      key: import_zod3.z.string(),
-      value: import_zod3.z.string().optional()
-    }).strict(),
-    import_zod3.z.object({
-      type: import_zod3.z.literal("cookie"),
-      key: import_zod3.z.string(),
-      value: import_zod3.z.string().optional()
-    }).strict(),
-    import_zod3.z.object({
-      type: import_zod3.z.literal("query"),
-      key: import_zod3.z.string(),
-      value: import_zod3.z.string().optional()
-    }).strict()
-  ])
-).optional();
-var vercelOutputConfigSchema = import_zod3.z.object({
-  version: import_zod3.z.literal(3),
-  routes: import_zod3.z.array(
-    import_zod3.z.union([
-      import_zod3.z.object({
-        src: import_zod3.z.string(),
-        dest: import_zod3.z.string().optional(),
-        headers: import_zod3.z.record(import_zod3.z.string()).optional(),
-        methods: import_zod3.z.array(import_zod3.z.string()).optional(),
-        status: import_zod3.z.number().int().positive().optional(),
-        continue: import_zod3.z.boolean().optional(),
-        check: import_zod3.z.boolean().optional(),
-        missing: HasOrMissing,
-        has: HasOrMissing,
-        locale: import_zod3.z.object({
-          redirect: import_zod3.z.record(import_zod3.z.string()).optional(),
-          cookie: import_zod3.z.string().optional()
-        }).strict().optional(),
-        middlewarePath: import_zod3.z.string().optional()
-      }).strict(),
-      import_zod3.z.object({
-        handle: import_zod3.z.union([
-          import_zod3.z.literal("rewrite"),
-          import_zod3.z.literal("filesystem"),
-          import_zod3.z.literal("resource"),
-          import_zod3.z.literal("miss"),
-          import_zod3.z.literal("hit"),
-          import_zod3.z.literal("error")
-        ]),
-        src: import_zod3.z.string().optional(),
-        dest: import_zod3.z.string().optional(),
-        status: import_zod3.z.number().optional()
-      }).strict()
-    ])
-  ).optional(),
-  images: import_zod3.z.object({
-    sizes: import_zod3.z.tuple([import_zod3.z.number().int().positive(), import_zod3.z.number().int().positive()]),
-    domains: import_zod3.z.array(import_zod3.z.string()).nonempty().optional(),
-    minimumCacheTTL: import_zod3.z.number().int().positive().optional(),
-    formats: import_zod3.z.union([import_zod3.z.literal("image/avif"), import_zod3.z.literal("image/webp")]).array().nonempty().optional(),
-    dangerouslyAllowSVG: import_zod3.z.boolean().optional(),
-    contentSecurityPolicy: import_zod3.z.string().optional()
-  }).strict().optional(),
-  wildcard: import_zod3.z.array(
-    import_zod3.z.object({
-      domain: import_zod3.z.string(),
-      value: import_zod3.z.string()
-    }).strict()
-  ).optional(),
-  overrides: import_zod3.z.record(
-    import_zod3.z.object({
-      path: import_zod3.z.string().optional(),
-      contentType: import_zod3.z.string().optional()
-    }).strict()
-  ).optional(),
-  cache: import_zod3.z.array(import_zod3.z.string()).optional()
-}).strict();
-
-// src/config.ts
-var import_promises2 = __toESM(require("fs/promises"), 1);
-var import_routing_utils = require("@vercel/routing-utils");
-function reorderEnforce(arr) {
-  return [
-    ...arr.filter((r) => r.enforce === "pre"),
-    ...arr.filter((r) => !r.enforce),
-    ...arr.filter((r) => r.enforce === "post")
-  ];
-}
-function getConfig(resolvedConfig, rewrites, overrides, headers) {
-  const _rewrites = [
-    // User provided config always comes first
-    ...resolvedConfig.vercel?.rewrites ?? [],
-    ...rewrites ?? []
-  ];
-  const _enforcedRewrites = reorderEnforce(_rewrites).map((r) => {
-    r.source = r.source.replaceAll(/:\[(\.\.\.)(.*)\]/g, ":$2*");
-    r.source = r.source.replaceAll(/:(\.\.\.)(.*)/g, ":$2+");
-    return r;
-  });
-  const { routes, error } = (0, import_routing_utils.getTransformedRoutes)({
-    cleanUrls: resolvedConfig.vercel?.cleanUrls ?? true,
-    trailingSlash: resolvedConfig.vercel?.trailingSlash,
-    rewrites: _enforcedRewrites,
-    redirects: resolvedConfig.vercel?.redirects ? reorderEnforce(resolvedConfig.vercel?.redirects) : void 0,
-    headers
-  });
-  if (error) {
-    throw error;
-  }
-  if (resolvedConfig.vercel?.config?.routes && resolvedConfig.vercel.config.routes.length > 0 && !resolvedConfig.vercel.config.routes.every((r) => "continue" in r && r.continue)) {
-    console.warn(
-      'Did you forget to add `"continue": true` to your routes? See https://vercel.com/docs/build-output-api/v3/configuration#source-route\nIf not, it is discouraged to use `vercel.config.routes` to override routes. Prefer using `vercel.rewrites` and `vercel.redirects`.'
-    );
-  }
-  let userRoutes = [];
-  let buildRoutes = [];
-  if (resolvedConfig.vercel?.config?.routes) {
-    const norm = (0, import_routing_utils.normalizeRoutes)(resolvedConfig.vercel.config.routes);
-    if (norm.error) {
-      throw norm.error;
-    }
-    userRoutes = norm.routes ?? [];
-  }
-  if (routes) {
-    const norm = (0, import_routing_utils.normalizeRoutes)(routes);
-    if (norm.error) {
-      throw norm.error;
-    }
-    buildRoutes = norm.routes ?? [];
-  }
-  const cleanRoutes = (0, import_routing_utils.mergeRoutes)({
-    userRoutes,
-    builds: [
-      {
-        use: "@vercel/node",
-        entrypoint: "index.js",
-        routes: buildRoutes
-      }
-    ]
-  });
-  return vercelOutputConfigSchema.parse({
-    version: 3,
-    ...resolvedConfig.vercel?.config,
-    routes: cleanRoutes,
-    overrides: {
-      ...resolvedConfig.vercel?.config?.overrides,
-      ...overrides
-    }
-  });
-}
-function getConfigDestination(resolvedConfig) {
-  return import_node_path3.default.join(getOutput(resolvedConfig), "config.json");
-}
-async function writeConfig(resolvedConfig, rewrites, overrides, headers) {
-  await import_promises2.default.writeFile(
-    getConfigDestination(resolvedConfig),
-    JSON.stringify(getConfig(resolvedConfig, rewrites, overrides, headers), void 0, 2),
-    "utf-8"
-  );
-}
-
-// src/helpers.ts
-var import_promises3 = __toESM(require("fs/promises"), 1);
-var import_node_path4 = __toESM(require("path"), 1);
-async function copyDir(src, dest) {
-  await import_promises3.default.mkdir(dest, { recursive: true });
-  const entries = await import_promises3.default.readdir(src, { withFileTypes: true });
-  for (const entry of entries) {
-    const srcPath = import_node_path4.default.join(src, entry.name);
-    const destPath = import_node_path4.default.join(dest, entry.name);
-    entry.isDirectory() ? await copyDir(srcPath, destPath) : await import_promises3.default.copyFile(srcPath, destPath);
-  }
-}
-
-// src/prerender.ts
-var import_node_path5 = __toESM(require("path"), 1);
-
-// src/schemas/config/prerender-config.ts
-var import_zod4 = require("zod");
-var vercelOutputPrerenderConfigSchema = import_zod4.z.object({
-  expiration: import_zod4.z.union([import_zod4.z.number().int().positive(), import_zod4.z.literal(false)]),
-  group: import_zod4.z.number().int().optional(),
-  bypassToken: import_zod4.z.string().optional(),
-  fallback: import_zod4.z.string().optional(),
-  allowQuery: import_zod4.z.array(import_zod4.z.string()).optional()
-}).strict();
-
-// src/prerender.ts
-var import_promises4 = __toESM(require("fs/promises"), 1);
-function execPrerender(resolvedConfig) {
-  const prerender = resolvedConfig.vercel?.prerender;
-  if (prerender === false) {
-    return;
-  }
-  return prerender?.(resolvedConfig);
-}
-var group = 1;
-async function writePrerenderConfig(resolvedConfig, destination, isr) {
-  const parsed = import_node_path5.default.parse(destination);
-  const outfile = import_node_path5.default.join(getOutput(resolvedConfig, "functions"), parsed.dir, `${parsed.name}.prerender-config.json`);
-  await import_promises4.default.mkdir(import_node_path5.default.join(getOutput(resolvedConfig, "functions"), parsed.dir), { recursive: true });
-  await import_promises4.default.writeFile(
-    outfile,
-    JSON.stringify(
-      vercelOutputPrerenderConfigSchema.parse({
-        group: group++,
-        ...isr
-      }),
-      void 0,
-      2
-    ),
-    "utf-8"
-  );
-}
-function getPrerenderSymlinkInfo(resolvedConfig, destination, target) {
-  const parsed = import_node_path5.default.parse(destination);
-  const targetParsed = import_node_path5.default.parse(target);
-  return {
-    target: import_node_path5.default.join(getOutput(resolvedConfig, "functions"), targetParsed.dir, `${targetParsed.name}.func`),
-    link: import_node_path5.default.join(getOutput(resolvedConfig, "functions"), parsed.dir, `${parsed.name}.func`)
-  };
-}
-async function buildPrerenderConfigs(resolvedConfig, extractedIsr) {
-  const isr = Object.assign({}, extractedIsr, await getIsrConfig(resolvedConfig));
-  const entries = Object.entries(isr);
-  const rewrites = [];
-  for (const [destination, { symlink, route, ...isr2 }] of entries) {
-    await writePrerenderConfig(resolvedConfig, destination, isr2);
-    if (symlink) {
-      const info = getPrerenderSymlinkInfo(resolvedConfig, destination, symlink);
-      await copyDir(info.target, info.link);
-    }
-    if (route) {
-      rewrites.push({
-        source: `(${route})`,
-        destination: `${destination}/?__original_path=$1`
-      });
-    }
-  }
-  return rewrites;
-}
-async function getIsrConfig(resolvedConfig) {
-  const isr = resolvedConfig.vercel?.isr ?? {};
-  if (typeof isr === "function") {
-    return await isr();
-  }
-  return isr;
-}
-
-// src/index.ts
-function vercelPluginCleanup() {
-  let resolvedConfig;
-  return {
-    apply: "build",
-    name: "vite-plugin-vercel:cleanup",
-    enforce: "pre",
-    configResolved(config) {
-      resolvedConfig = config;
-    },
-    writeBundle: {
-      order: "pre",
-      sequential: true,
-      async handler() {
-        if (!resolvedConfig.build?.ssr) {
-          await cleanOutputDirectory(resolvedConfig);
-        }
-      }
-    }
-  };
-}
-function vercelPlugin() {
-  let resolvedConfig;
-  let vikeFound = false;
-  return {
-    apply: "build",
-    name: "vite-plugin-vercel",
-    enforce: "post",
-    configResolved(config) {
-      resolvedConfig = config;
-      vikeFound = resolvedConfig.plugins.some((p) => p.name.match("^vite-plugin-ssr:|^vike:"));
-      if (typeof resolvedConfig.vercel?.distContainsOnlyStatic === "undefined") {
-        resolvedConfig.vercel ??= {};
-        resolvedConfig.vercel.distContainsOnlyStatic = !vikeFound;
-      }
-    },
-    writeBundle: {
-      order: "post",
-      sequential: true,
-      async handler() {
-        if (!resolvedConfig.build?.ssr) {
-          if (vikeFound) {
-            return;
-          }
-        }
-        const overrides = await execPrerender(resolvedConfig);
-        const userOverrides = await computeStaticHtmlOverrides(resolvedConfig);
-        const { rewrites, isr, headers } = await buildEndpoints(resolvedConfig);
-        rewrites.push(...await buildPrerenderConfigs(resolvedConfig, isr));
-        await writeConfig(
-          resolvedConfig,
-          rewrites,
-          {
-            ...userOverrides,
-            ...overrides
-          },
-          headers
-        );
-        await copyDistToStatic(resolvedConfig);
-      }
-    }
-  };
-}
-async function cleanOutputDirectory(resolvedConfig) {
-  await import_promises5.default.rm(getOutput(resolvedConfig), {
-    recursive: true,
-    force: true
-  });
-  await import_promises5.default.mkdir(getOutput(resolvedConfig), { recursive: true });
-}
-async function copyDistToStatic(resolvedConfig) {
-  if (resolvedConfig.vercel?.distContainsOnlyStatic) {
-    await copyDir(resolvedConfig.build.outDir, getOutput(resolvedConfig, "static"));
-  }
-}
-async function computeStaticHtmlOverrides(resolvedConfig) {
-  const staticAbsolutePath = getOutput(resolvedConfig, "static");
-  const files = await getStaticHtmlFiles(staticAbsolutePath);
-  const publicDir = getPublic(resolvedConfig);
-  const publicFiles = await getStaticHtmlFiles(publicDir);
-  files.push(...publicFiles.map((f) => f.replace(publicDir, staticAbsolutePath)));
-  return files.reduce(
-    (acc, curr) => {
-      const relPath = import_node_path6.default.relative(staticAbsolutePath, curr);
-      const parsed = import_node_path6.default.parse(relPath);
-      const pathJoined = import_node_path6.default.join(parsed.dir, parsed.name);
-      acc[relPath] = {
-        path: pathJoined
-      };
-      return acc;
-    },
-    {}
-  );
-}
-async function getStaticHtmlFiles(src) {
-  try {
-    await import_promises5.default.stat(src);
-  } catch (e) {
-    return [];
-  }
-  const entries = await import_promises5.default.readdir(src, { withFileTypes: true });
-  const htmlFiles = [];
-  for (const entry of entries) {
-    const srcPath = import_node_path6.default.join(src, entry.name);
-    entry.isDirectory() ? htmlFiles.push(...await getStaticHtmlFiles(srcPath)) : srcPath.endsWith(".html") ? htmlFiles.push(srcPath) : void 0;
-  }
-  return htmlFiles;
-}
-async function tryImportVpvv(options) {
-  try {
-    await import("vike/plugin");
-    const vpvv = await import("@vite-plugin-vercel/vike");
-    return vpvv.default(options);
-  } catch (e) {
-    try {
-      await import("vite-plugin-ssr/plugin");
-      const vpvv = await import("@vite-plugin-vercel/vike");
-      return vpvv.default(options);
-    } catch (e2) {
-      return null;
-    }
-  }
-}
-function allPlugins(options = {}) {
-  const { smart, ...rest } = options;
-  return [vercelPluginCleanup(), vercelPlugin(), smart !== false ? tryImportVpvv(rest) : null];
-}