vercel-cli 41.1.0__py3-none-any.whl

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

@@ -0,0 +1,81 @@
+/// <reference types="node" />
+import type { Config, Env, Files, FunctionFramework } from './types';
+export type LambdaOptions = LambdaOptionsWithFiles | LambdaOptionsWithZipBuffer;
+export type LambdaArchitecture = 'x86_64' | 'arm64';
+export interface LambdaOptionsBase {
+    handler: string;
+    runtime: string;
+    architecture?: LambdaArchitecture;
+    memory?: number;
+    maxDuration?: number;
+    environment?: Env;
+    allowQuery?: string[];
+    regions?: string[];
+    supportsMultiPayloads?: boolean;
+    supportsWrapper?: boolean;
+    supportsResponseStreaming?: boolean;
+    /**
+     * @deprecated Use the `supportsResponseStreaming` property instead.
+     */
+    experimentalResponseStreaming?: boolean;
+    operationType?: string;
+    framework?: FunctionFramework;
+}
+export interface LambdaOptionsWithFiles extends LambdaOptionsBase {
+    files: Files;
+    experimentalAllowBundling?: boolean;
+}
+/**
+ * @deprecated Use `LambdaOptionsWithFiles` instead.
+ */
+export interface LambdaOptionsWithZipBuffer extends LambdaOptionsBase {
+    /**
+     * @deprecated Use `files` property instead.
+     */
+    zipBuffer: Buffer;
+}
+interface GetLambdaOptionsFromFunctionOptions {
+    sourceFile: string;
+    config?: Pick<Config, 'functions'>;
+}
+export declare class Lambda {
+    type: 'Lambda';
+    /**
+     * This is a label for the type of Lambda a framework is producing.
+     * The value can be any string that makes sense for a given framework.
+     * Examples: "API", "ISR", "SSR", "SSG", "Render", "Resource"
+     */
+    operationType?: string;
+    files?: Files;
+    handler: string;
+    runtime: string;
+    architecture?: LambdaArchitecture;
+    memory?: number;
+    maxDuration?: number;
+    environment: Env;
+    allowQuery?: string[];
+    regions?: string[];
+    /**
+     * @deprecated Use `await lambda.createZip()` instead.
+     */
+    zipBuffer?: Buffer;
+    supportsMultiPayloads?: boolean;
+    supportsWrapper?: boolean;
+    supportsResponseStreaming?: boolean;
+    framework?: FunctionFramework;
+    experimentalAllowBundling?: boolean;
+    constructor(opts: LambdaOptions);
+    createZip(): Promise<Buffer>;
+    /**
+     * @deprecated Use the `supportsResponseStreaming` property instead.
+     */
+    get experimentalResponseStreaming(): boolean | undefined;
+    set experimentalResponseStreaming(v: boolean | undefined);
+}
+/**
+ * @deprecated Use `new Lambda()` instead.
+ */
+export declare function createLambda(opts: LambdaOptions): Promise<Lambda>;
+export declare function createZip(files: Files): Promise<Buffer>;
+export declare function getLambdaOptionsFromFunction({ sourceFile, config, }: GetLambdaOptionsFromFunctionOptions): Promise<Pick<LambdaOptions, 'memory' | 'maxDuration'>>;
+export {};

vercel_cli/vendor/node_modules/@vercel/build-utils/dist/lambda.js

@@ -0,0 +1,231 @@
+"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 lambda_exports = {};
+__export(lambda_exports, {
+  Lambda: () => Lambda,
+  createLambda: () => createLambda,
+  createZip: () => createZip,
+  getLambdaOptionsFromFunction: () => getLambdaOptionsFromFunction
+});
+module.exports = __toCommonJS(lambda_exports);
+var import_assert = __toESM(require("assert"));
+var import_async_sema = __toESM(require("async-sema"));
+var import_yazl = require("yazl");
+var import_minimatch = __toESM(require("minimatch"));
+var import_fs_extra = require("fs-extra");
+var import_download = require("./fs/download");
+var import_stream_to_buffer = __toESM(require("./fs/stream-to-buffer"));
+class Lambda {
+  constructor(opts) {
+    const {
+      handler,
+      runtime,
+      maxDuration,
+      architecture,
+      memory,
+      environment = {},
+      allowQuery,
+      regions,
+      supportsMultiPayloads,
+      supportsWrapper,
+      supportsResponseStreaming,
+      experimentalResponseStreaming,
+      operationType,
+      framework
+    } = opts;
+    if ("files" in opts) {
+      (0, import_assert.default)(typeof opts.files === "object", '"files" must be an object');
+    }
+    if ("zipBuffer" in opts) {
+      (0, import_assert.default)(Buffer.isBuffer(opts.zipBuffer), '"zipBuffer" must be a Buffer');
+    }
+    (0, import_assert.default)(typeof handler === "string", '"handler" is not a string');
+    (0, import_assert.default)(typeof runtime === "string", '"runtime" is not a string');
+    (0, import_assert.default)(typeof environment === "object", '"environment" is not an object');
+    if (architecture !== void 0) {
+      (0, import_assert.default)(
+        architecture === "x86_64" || architecture === "arm64",
+        '"architecture" must be either "x86_64" or "arm64"'
+      );
+    }
+    if ("experimentalAllowBundling" in opts && opts.experimentalAllowBundling !== void 0) {
+      (0, import_assert.default)(
+        typeof opts.experimentalAllowBundling === "boolean",
+        '"experimentalAllowBundling" is not a boolean'
+      );
+    }
+    if (memory !== void 0) {
+      (0, import_assert.default)(typeof memory === "number", '"memory" is not a number');
+    }
+    if (maxDuration !== void 0) {
+      (0, import_assert.default)(typeof maxDuration === "number", '"maxDuration" is not a number');
+    }
+    if (allowQuery !== void 0) {
+      (0, import_assert.default)(Array.isArray(allowQuery), '"allowQuery" is not an Array');
+      (0, import_assert.default)(
+        allowQuery.every((q) => typeof q === "string"),
+        '"allowQuery" is not a string Array'
+      );
+    }
+    if (supportsMultiPayloads !== void 0) {
+      (0, import_assert.default)(
+        typeof supportsMultiPayloads === "boolean",
+        '"supportsMultiPayloads" is not a boolean'
+      );
+    }
+    if (supportsWrapper !== void 0) {
+      (0, import_assert.default)(
+        typeof supportsWrapper === "boolean",
+        '"supportsWrapper" is not a boolean'
+      );
+    }
+    if (regions !== void 0) {
+      (0, import_assert.default)(Array.isArray(regions), '"regions" is not an Array');
+      (0, import_assert.default)(
+        regions.every((r) => typeof r === "string"),
+        '"regions" is not a string Array'
+      );
+    }
+    if (framework !== void 0) {
+      (0, import_assert.default)(typeof framework === "object", '"framework" is not an object');
+      (0, import_assert.default)(
+        typeof framework.slug === "string",
+        '"framework.slug" is not a string'
+      );
+      if (framework.version !== void 0) {
+        (0, import_assert.default)(
+          typeof framework.version === "string",
+          '"framework.version" is not a string'
+        );
+      }
+    }
+    this.type = "Lambda";
+    this.operationType = operationType;
+    this.files = "files" in opts ? opts.files : void 0;
+    this.handler = handler;
+    this.runtime = runtime;
+    this.architecture = architecture;
+    this.memory = memory;
+    this.maxDuration = maxDuration;
+    this.environment = environment;
+    this.allowQuery = allowQuery;
+    this.regions = regions;
+    this.zipBuffer = "zipBuffer" in opts ? opts.zipBuffer : void 0;
+    this.supportsMultiPayloads = supportsMultiPayloads;
+    this.supportsWrapper = supportsWrapper;
+    this.supportsResponseStreaming = supportsResponseStreaming ?? experimentalResponseStreaming;
+    this.framework = framework;
+    this.experimentalAllowBundling = "experimentalAllowBundling" in opts ? opts.experimentalAllowBundling : void 0;
+  }
+  async createZip() {
+    let { zipBuffer } = this;
+    if (!zipBuffer) {
+      if (!this.files) {
+        throw new Error("`files` is not defined");
+      }
+      await sema.acquire();
+      try {
+        zipBuffer = await createZip(this.files);
+      } finally {
+        sema.release();
+      }
+    }
+    return zipBuffer;
+  }
+  /**
+   * @deprecated Use the `supportsResponseStreaming` property instead.
+   */
+  get experimentalResponseStreaming() {
+    return this.supportsResponseStreaming;
+  }
+  set experimentalResponseStreaming(v) {
+    this.supportsResponseStreaming = v;
+  }
+}
+const sema = new import_async_sema.default(10);
+const mtime = /* @__PURE__ */ new Date(154e10);
+async function createLambda(opts) {
+  const lambda = new Lambda(opts);
+  lambda.zipBuffer = await lambda.createZip();
+  return lambda;
+}
+async function createZip(files) {
+  const names = Object.keys(files).sort();
+  const symlinkTargets = /* @__PURE__ */ new Map();
+  for (const name of names) {
+    const file = files[name];
+    if (file.mode && (0, import_download.isSymbolicLink)(file.mode) && file.type === "FileFsRef") {
+      const symlinkTarget = await (0, import_fs_extra.readlink)(file.fsPath);
+      symlinkTargets.set(name, symlinkTarget);
+    }
+  }
+  const zipFile = new import_yazl.ZipFile();
+  const zipBuffer = await new Promise((resolve, reject) => {
+    for (const name of names) {
+      const file = files[name];
+      const opts = { mode: file.mode, mtime };
+      const symlinkTarget = symlinkTargets.get(name);
+      if (typeof symlinkTarget === "string") {
+        zipFile.addBuffer(Buffer.from(symlinkTarget, "utf8"), name, opts);
+      } else if (file.mode && (0, import_download.isDirectory)(file.mode)) {
+        zipFile.addEmptyDirectory(name, opts);
+      } else {
+        const stream = file.toStream();
+        stream.on("error", reject);
+        zipFile.addReadStream(stream, name, opts);
+      }
+    }
+    zipFile.end();
+    (0, import_stream_to_buffer.default)(zipFile.outputStream).then(resolve).catch(reject);
+  });
+  return zipBuffer;
+}
+async function getLambdaOptionsFromFunction({
+  sourceFile,
+  config
+}) {
+  if (config?.functions) {
+    for (const [pattern, fn] of Object.entries(config.functions)) {
+      if (sourceFile === pattern || (0, import_minimatch.default)(sourceFile, pattern)) {
+        return {
+          memory: fn.memory,
+          maxDuration: fn.maxDuration
+        };
+      }
+    }
+  }
+  return {};
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Lambda,
+  createLambda,
+  createZip,
+  getLambdaOptionsFromFunction
+});

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

@@ -0,0 +1,16 @@
+import { Lambda, LambdaOptionsWithFiles } from './lambda';
+interface NodejsLambdaOptions extends LambdaOptionsWithFiles {
+    shouldAddHelpers: boolean;
+    shouldAddSourcemapSupport: boolean;
+    awsLambdaHandler?: string;
+    useWebApi?: boolean;
+}
+export declare class NodejsLambda extends Lambda {
+    launcherType: 'Nodejs';
+    shouldAddHelpers: boolean;
+    shouldAddSourcemapSupport: boolean;
+    awsLambdaHandler?: string;
+    useWebApi?: boolean;
+    constructor({ shouldAddHelpers, shouldAddSourcemapSupport, awsLambdaHandler, useWebApi, ...opts }: NodejsLambdaOptions);
+}
+export {};

vercel_cli/vendor/node_modules/@vercel/build-utils/dist/nodejs-lambda.js

@@ -0,0 +1,44 @@
+"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 nodejs_lambda_exports = {};
+__export(nodejs_lambda_exports, {
+  NodejsLambda: () => NodejsLambda
+});
+module.exports = __toCommonJS(nodejs_lambda_exports);
+var import_lambda = require("./lambda");
+class NodejsLambda extends import_lambda.Lambda {
+  constructor({
+    shouldAddHelpers,
+    shouldAddSourcemapSupport,
+    awsLambdaHandler,
+    useWebApi,
+    ...opts
+  }) {
+    super(opts);
+    this.launcherType = "Nodejs";
+    this.shouldAddHelpers = shouldAddHelpers;
+    this.shouldAddSourcemapSupport = shouldAddSourcemapSupport;
+    this.awsLambdaHandler = awsLambdaHandler;
+    this.useWebApi = useWebApi;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NodejsLambda
+});

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

@@ -0,0 +1,3 @@
+export declare function getOsRelease(): Promise<Record<string, string> | null>;
+export declare function parseOsRelease(data: string): Promise<Record<string, string>>;
+export declare function getProvidedRuntime(): Promise<"provided.al2023" | "provided.al2">;

vercel_cli/vendor/node_modules/@vercel/build-utils/dist/os.js

@@ -0,0 +1,62 @@
+"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 os_exports = {};
+__export(os_exports, {
+  getOsRelease: () => getOsRelease,
+  getProvidedRuntime: () => getProvidedRuntime,
+  parseOsRelease: () => parseOsRelease
+});
+module.exports = __toCommonJS(os_exports);
+var import_fs_extra = require("fs-extra");
+var import_error_utils = require("@vercel/error-utils");
+async function getOsRelease() {
+  try {
+    const data = await (0, import_fs_extra.readFile)("/etc/os-release", "utf8");
+    return await parseOsRelease(data);
+  } catch (err) {
+    if ((0, import_error_utils.isErrnoException)(err) && err.code === "ENOENT") {
+      return null;
+    }
+    throw err;
+  }
+}
+async function parseOsRelease(data) {
+  const obj = {};
+  for (const line of data.trim().split("\n")) {
+    const m = /(?<key>.*)="(?<value>.*)"/.exec(line);
+    if (!m?.groups) {
+      continue;
+    }
+    obj[m.groups.key] = m.groups.value;
+  }
+  return obj;
+}
+async function getProvidedRuntime() {
+  const os = await getOsRelease();
+  if (!os) {
+    return "provided.al2023";
+  }
+  return os.PRETTY_NAME === "Amazon Linux 2" ? "provided.al2" : "provided.al2023";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getOsRelease,
+  getProvidedRuntime,
+  parseOsRelease
+});

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

@@ -0,0 +1,37 @@
+import type { File, HasField, Chain } from './types';
+import { Lambda } from './lambda';
+interface PrerenderOptions {
+    expiration: number | false;
+    lambda?: Lambda;
+    fallback: File | null;
+    group?: number;
+    bypassToken?: string | null;
+    allowQuery?: string[];
+    allowHeader?: string[];
+    initialHeaders?: Record<string, string>;
+    initialStatus?: number;
+    passQuery?: boolean;
+    sourcePath?: string;
+    experimentalBypassFor?: HasField;
+    experimentalStreamingLambdaPath?: string;
+    chain?: Chain;
+}
+export declare class Prerender {
+    type: 'Prerender';
+    expiration: number | false;
+    lambda?: Lambda;
+    fallback: File | null;
+    group?: number;
+    bypassToken: string | null;
+    allowQuery?: string[];
+    allowHeader?: string[];
+    initialHeaders?: Record<string, string>;
+    initialStatus?: number;
+    passQuery?: boolean;
+    sourcePath?: string;
+    experimentalBypassFor?: HasField;
+    experimentalStreamingLambdaPath?: string;
+    chain?: Chain;
+    constructor({ expiration, lambda, fallback, group, bypassToken, allowQuery, allowHeader, initialHeaders, initialStatus, passQuery, sourcePath, experimentalBypassFor, experimentalStreamingLambdaPath, chain, }: PrerenderOptions);
+}
+export {};

vercel_cli/vendor/node_modules/@vercel/build-utils/dist/prerender.js

@@ -0,0 +1,169 @@
+"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 prerender_exports = {};
+__export(prerender_exports, {
+  Prerender: () => Prerender
+});
+module.exports = __toCommonJS(prerender_exports);
+class Prerender {
+  constructor({
+    expiration,
+    lambda,
+    fallback,
+    group,
+    bypassToken,
+    allowQuery,
+    allowHeader,
+    initialHeaders,
+    initialStatus,
+    passQuery,
+    sourcePath,
+    experimentalBypassFor,
+    experimentalStreamingLambdaPath,
+    chain
+  }) {
+    this.type = "Prerender";
+    this.expiration = expiration;
+    this.sourcePath = sourcePath;
+    this.lambda = lambda;
+    if (this.lambda) {
+      this.lambda.operationType = this.lambda.operationType || "ISR";
+    }
+    if (typeof group !== "undefined" && (group <= 0 || !Number.isInteger(group))) {
+      throw new Error(
+        "The `group` argument for `Prerender` needs to be a natural number."
+      );
+    }
+    this.group = group;
+    if (passQuery === true) {
+      this.passQuery = true;
+    } else if (typeof passQuery !== "boolean" && typeof passQuery !== "undefined") {
+      throw new Error(
+        `The \`passQuery\` argument for \`Prerender\` must be a boolean.`
+      );
+    }
+    if (bypassToken == null) {
+      this.bypassToken = null;
+    } else if (typeof bypassToken === "string") {
+      if (bypassToken.length < 32) {
+        throw new Error(
+          "The `bypassToken` argument for `Prerender` must be 32 characters or more."
+        );
+      }
+      this.bypassToken = bypassToken;
+    } else {
+      throw new Error(
+        "The `bypassToken` argument for `Prerender` must be a `string`."
+      );
+    }
+    if (experimentalBypassFor !== void 0) {
+      if (!Array.isArray(experimentalBypassFor) || experimentalBypassFor.some(
+        (field) => typeof field !== "object" || // host doesn't need a key
+        field.type !== "host" && typeof field.key !== "string" || typeof field.type !== "string" || field.value !== void 0 && typeof field.value !== "string"
+      )) {
+        throw new Error(
+          "The `experimentalBypassFor` argument for `Prerender` must be Array of objects with fields `type`, `key` and optionally `value`."
+        );
+      }
+      this.experimentalBypassFor = experimentalBypassFor;
+    }
+    if (typeof fallback === "undefined") {
+      throw new Error(
+        "The `fallback` argument for `Prerender` needs to be a `FileBlob`, `FileFsRef`, `FileRef`, or null."
+      );
+    }
+    this.fallback = fallback;
+    if (initialHeaders !== void 0) {
+      if (!initialHeaders || typeof initialHeaders !== "object" || Object.entries(initialHeaders).some(
+        ([key, value]) => typeof key !== "string" || typeof value !== "string"
+      )) {
+        throw new Error(
+          `The \`initialHeaders\` argument for \`Prerender\` must be an object with string key/values`
+        );
+      }
+      this.initialHeaders = initialHeaders;
+    }
+    if (initialStatus !== void 0) {
+      if (initialStatus <= 0 || !Number.isInteger(initialStatus)) {
+        throw new Error(
+          `The \`initialStatus\` argument for \`Prerender\` must be a natural number.`
+        );
+      }
+      this.initialStatus = initialStatus;
+    }
+    if (allowQuery !== void 0) {
+      if (!Array.isArray(allowQuery)) {
+        throw new Error(
+          "The `allowQuery` argument for `Prerender` must be Array."
+        );
+      }
+      if (!allowQuery.every((q) => typeof q === "string")) {
+        throw new Error(
+          "The `allowQuery` argument for `Prerender` must be Array of strings."
+        );
+      }
+      this.allowQuery = allowQuery;
+    }
+    if (allowHeader !== void 0) {
+      if (!Array.isArray(allowHeader)) {
+        throw new Error(
+          "The `allowHeader` argument for `Prerender` must be Array."
+        );
+      }
+      if (!allowHeader.every((q) => typeof q === "string")) {
+        throw new Error(
+          "The `allowHeader` argument for `Prerender` must be Array of strings."
+        );
+      }
+      this.allowHeader = allowHeader;
+    }
+    if (experimentalStreamingLambdaPath !== void 0) {
+      if (typeof experimentalStreamingLambdaPath !== "string") {
+        throw new Error(
+          "The `experimentalStreamingLambdaPath` argument for `Prerender` must be a string."
+        );
+      }
+      this.experimentalStreamingLambdaPath = experimentalStreamingLambdaPath;
+    }
+    if (chain !== void 0) {
+      if (typeof chain !== "object") {
+        throw new Error(
+          "The `chain` argument for `Prerender` must be an object."
+        );
+      }
+      if (!chain.headers || typeof chain.headers !== "object" || Object.entries(chain.headers).some(
+        ([key, value]) => typeof key !== "string" || typeof value !== "string"
+      )) {
+        throw new Error(
+          `The \`chain.headers\` argument for \`Prerender\` must be an object with string key/values`
+        );
+      }
+      if (!chain.outputPath || typeof chain.outputPath !== "string") {
+        throw new Error(
+          "The `chain.outputPath` argument for `Prerender` must be a string."
+        );
+      }
+      this.chain = chain;
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Prerender
+});