nuxt-og-image 6.6.0 → 6.7.1

package/dist/shared/nuxt-og-image.DQkJQHaN.cjs

@@ -0,0 +1,689 @@
+'use strict';
+
+const fs = require('node:fs');
+const magicast = require('magicast');
+const helpers = require('magicast/helpers');
+const pathe = require('pathe');
+const logger_js = require('../../dist/runtime/logger.js');
+const nypm = require('nypm');
+const stdEnv = require('std-env');
+const kit = require('@nuxt/kit');
+const defu = require('defu');
+const kit$1 = require('nuxtseo-shared/kit');
+const chromeLauncher = require('chrome-launcher');
+
+function parseFontString(font) {
+  const parts = font.split(":");
+  if (parts.length === 3) {
+    return {
+      name: parts[0] || font,
+      style: parts[1] === "ital" ? "italic" : "normal",
+      weight: Number.parseInt(parts[2] || "") || 400
+    };
+  }
+  return {
+    name: parts[0] || font,
+    weight: Number.parseInt(parts[1] || "") || 400,
+    style: "normal"
+  };
+}
+function groupFontsByFamily(fonts) {
+  const families = /* @__PURE__ */ new Map();
+  for (const font of fonts) {
+    const parsed = parseFontString(font);
+    const existing = families.get(parsed.name);
+    if (existing) {
+      existing.weights.add(parsed.weight);
+      existing.styles.add(parsed.style);
+    } else {
+      families.set(parsed.name, {
+        weights: /* @__PURE__ */ new Set([parsed.weight]),
+        styles: /* @__PURE__ */ new Set([parsed.style])
+      });
+    }
+  }
+  return Array.from(families.entries(), ([name, { weights, styles }]) => ({
+    name,
+    weights: [...weights].toSorted((a, b) => a - b),
+    styles: [...styles]
+  }));
+}
+async function migrateFontsConfig(rootDir) {
+  const configPaths = [
+    "nuxt.config.ts",
+    "nuxt.config.js",
+    "nuxt.config.mjs"
+  ];
+  let configPath;
+  for (const p of configPaths) {
+    const fullPath = pathe.join(rootDir, p);
+    if (fs.existsSync(fullPath)) {
+      configPath = fullPath;
+      break;
+    }
+  }
+  if (!configPath) {
+    return { migrated: false, message: "No nuxt.config found" };
+  }
+  const mod = await magicast.loadFile(configPath);
+  const config = mod.exports.default;
+  if (!config?.ogImage?.fonts) {
+    return { migrated: false, message: "No ogImage.fonts config found" };
+  }
+  const oldFonts = config.ogImage.fonts;
+  if (!Array.isArray(oldFonts) || oldFonts.length === 0) {
+    return { migrated: false, message: "ogImage.fonts is empty or invalid" };
+  }
+  const groupedFonts = groupFontsByFamily(oldFonts);
+  if (!config.fonts) {
+    config.fonts = {};
+  }
+  if (!config.fonts.families) {
+    config.fonts.families = [];
+  }
+  const existingFamilies = config.fonts.families;
+  for (const font of groupedFonts) {
+    const existing = existingFamilies.find((f) => f.name === font.name);
+    if (existing) {
+      const existingWeights = new Set(existing.weights || []);
+      for (const w of font.weights) {
+        existingWeights.add(w);
+      }
+      existing.weights = [...existingWeights].toSorted((a, b) => a - b);
+      if (font.styles.includes("italic")) {
+        const existingStyles = new Set(existing.styles || ["normal"]);
+        existingStyles.add("italic");
+        existing.styles = [...existingStyles];
+      }
+      existing.global = true;
+    } else {
+      const family = {
+        name: font.name,
+        weights: font.weights,
+        global: true
+      };
+      if (font.styles.includes("italic")) {
+        family.styles = font.styles;
+      }
+      existingFamilies.push(family);
+    }
+  }
+  helpers.addNuxtModule(mod, "@nuxt/fonts");
+  delete config.ogImage.fonts;
+  if (Object.keys(config.ogImage).length === 0) {
+    delete config.ogImage;
+  }
+  await magicast.writeFile(mod, configPath);
+  const familyNames = groupedFonts.map((f) => f.name).join(", ");
+  return {
+    migrated: true,
+    message: `Migrated fonts (${familyNames}) from ogImage.fonts to @nuxt/fonts`
+  };
+}
+async function migrateDefaultsComponent(rootDir) {
+  const configPaths = [
+    "nuxt.config.ts",
+    "nuxt.config.js",
+    "nuxt.config.mjs"
+  ];
+  let configPath;
+  for (const cp of configPaths) {
+    const fullPath = pathe.join(rootDir, cp);
+    if (fs.existsSync(fullPath)) {
+      configPath = fullPath;
+      break;
+    }
+  }
+  if (!configPath)
+    return { migrated: false, componentName: null, message: "No nuxt.config found" };
+  const mod = await magicast.loadFile(configPath);
+  const config = mod.exports.default;
+  if (!config?.ogImage?.defaults?.component)
+    return { migrated: false, componentName: null, message: "No defaults.component found" };
+  const componentName = String(config.ogImage.defaults.component);
+  delete config.ogImage.defaults.component;
+  if (config.ogImage.defaults && Object.keys(config.ogImage.defaults).length === 0)
+    delete config.ogImage.defaults;
+  if (config.ogImage && Object.keys(config.ogImage).length === 0)
+    delete config.ogImage;
+  await magicast.writeFile(mod, configPath);
+  return { migrated: true, componentName, message: `Removed defaults.component: '${componentName}'` };
+}
+async function promptFontsMigration(rootDir) {
+  logger_js.logger.info("");
+  logger_js.logger.info("Detected deprecated ogImage.fonts configuration.");
+  logger_js.logger.info("");
+  logger_js.logger.info("Inter fonts now work out of the box without any configuration.");
+  logger_js.logger.info("For custom fonts, use @nuxt/fonts:");
+  logger_js.logger.info("");
+  logger_js.logger.info("Before:");
+  logger_js.logger.info("  ogImage: {");
+  logger_js.logger.info("    fonts: ['Inter:400', 'Inter:700']");
+  logger_js.logger.info("  }");
+  logger_js.logger.info("");
+  logger_js.logger.info("After (Inter only): Remove the config entirely \u2014 it works by default.");
+  logger_js.logger.info("");
+  logger_js.logger.info("After (custom fonts):");
+  logger_js.logger.info("  modules: ['@nuxt/fonts', 'nuxt-og-image'],");
+  logger_js.logger.info("  fonts: {");
+  logger_js.logger.info("    families: [");
+  logger_js.logger.info("      { name: 'Roboto', weights: [400, 700], global: true }");
+  logger_js.logger.info("    ]");
+  logger_js.logger.info("  }");
+  logger_js.logger.info("");
+  const migrate = await logger_js.logger.prompt("Automatically migrate nuxt.config?", {
+    type: "confirm",
+    initial: true
+  });
+  if (migrate) {
+    const result = await migrateFontsConfig(rootDir).catch((err) => {
+      logger_js.logger.error(`Migration failed: ${err.message}`);
+      return { migrated: false, message: err.message };
+    });
+    if (result.migrated) {
+      logger_js.logger.success(result.message);
+      logger_js.logger.info("");
+      logger_js.logger.info("Please install @nuxt/fonts:");
+      logger_js.logger.info("  npm add @nuxt/fonts");
+    } else {
+      logger_js.logger.warn(`Could not migrate: ${result.message}`);
+      logger_js.logger.info("Please migrate manually.");
+    }
+  } else {
+    logger_js.logger.info("Skipping automatic migration. Please migrate manually.");
+  }
+}
+
+const isUndefinedOrTruthy = (v) => typeof v === "undefined" || v !== false;
+function checkLocalChrome() {
+  if (stdEnv.isCI)
+    return false;
+  let hasChromeLocally = false;
+  try {
+    hasChromeLocally = !!chromeLauncher.Launcher.getFirstInstallation();
+  } catch {
+  }
+  return hasChromeLocally;
+}
+async function hasResolvableDependency(dep) {
+  return await kit.resolvePath(dep, { fallbackToOriginal: true }).catch(() => null).then((r) => r && r !== dep);
+}
+const VALID_RENDERER_SUFFIXES = ["satori", "browser", "takumi"];
+const RE_RENDERER_SUFFIX_CI = /\.?(satori|browser|takumi)$/i;
+const RE_RENDERER_SUFFIX = /(Satori|Browser|Takumi)$/;
+const RE_LEGACY_SUFFIX = /-legacy$/;
+const RE_WHITESPACE = /\s+/;
+function getRendererFromFilename(filepath) {
+  const filename = pathe.basename(filepath).replace(".vue", "");
+  for (const suffix of VALID_RENDERER_SUFFIXES) {
+    if (filename.endsWith(`.${suffix}`))
+      return suffix;
+  }
+  return null;
+}
+const OGIMAGE_PREFIXES = [
+  { prefix: "OgImageCommunity", overlapWord: "Community" },
+  { prefix: "OgImageTemplate", overlapWord: "Template" },
+  { prefix: "OgImage", overlapWord: "Image" }
+];
+function getRegisteredBaseNames(registeredPascalName) {
+  const stripped = registeredPascalName.replace(RE_RENDERER_SUFFIX_CI, "").replace(RE_RENDERER_SUFFIX, "");
+  const names = [];
+  for (const { prefix, overlapWord } of OGIMAGE_PREFIXES) {
+    if (!stripped.startsWith(prefix))
+      continue;
+    const withoutPrefix = stripped.slice(prefix.length);
+    if (withoutPrefix) {
+      names.push(withoutPrefix);
+      if (withoutPrefix !== overlapWord)
+        names.push(overlapWord + withoutPrefix);
+    } else {
+      names.push(overlapWord);
+    }
+    break;
+  }
+  if (names.length === 0)
+    names.push(stripped);
+  return names;
+}
+
+const NodeRuntime = {
+  // node-server runtime
+  browser: "on-demand",
+  // this gets changed build start
+  resvg: "node",
+  satori: "node",
+  takumi: "node",
+  sharp: "node",
+  // will be disabled if they're missing the dependency
+  emoji: "local"
+  // can bundle icons, no size constraints
+};
+const NodeDevRuntime = {
+  ...NodeRuntime,
+  resvg: "node-dev",
+  // use worker to prevent crashes from killing process
+  takumi: "node-dev"
+  // use worker to prevent crashes from killing process
+};
+const NodePrerenderRuntime = {
+  ...NodeRuntime,
+  resvg: "node-dev",
+  // use worker to prevent crashes from killing prerender process
+  takumi: "node-dev"
+  // use worker to prevent crashes from killing prerender process
+};
+const cloudflare = {
+  browser: "cloudflare",
+  resvg: "wasm",
+  satori: "wasm",
+  takumi: "wasm",
+  sharp: false,
+  emoji: "fetch",
+  // edge size limits - use API instead of bundling 24MB icons
+  wasm: {
+    esmImport: true
+    // Do NOT set lazy here — Nitro's cloudflare preset uses lazy: false because
+    // CF Workers require WASM modules to be imported eagerly via top-level await
+  }
+};
+const awsLambda = {
+  browser: false,
+  resvg: "node",
+  satori: "node",
+  takumi: "node",
+  sharp: false,
+  // 0.33.x has issues
+  emoji: "local"
+  // serverless has larger size limits
+};
+const WebContainer = {
+  browser: false,
+  resvg: "wasm-fs",
+  satori: "wasm-fs",
+  takumi: "wasm",
+  sharp: false,
+  emoji: "fetch"
+  // webcontainer has size constraints
+};
+const RuntimeCompatibility = {
+  "nitro-dev": NodeDevRuntime,
+  "nitro-prerender": NodePrerenderRuntime,
+  "node-server": NodeRuntime,
+  "node-cluster": NodeRuntime,
+  "node-listener": NodeRuntime,
+  "bun": NodeRuntime,
+  "deno-server": NodeRuntime,
+  "deno-deploy": NodeRuntime,
+  // node-server extending presets
+  "alwaysdata": NodeRuntime,
+  "cleavr": NodeRuntime,
+  "digital-ocean": NodeRuntime,
+  "edgio": NodeRuntime,
+  "flight-control": NodeRuntime,
+  "heroku": NodeRuntime,
+  "iis-handler": NodeRuntime,
+  "iis-node": NodeRuntime,
+  "koyeb": NodeRuntime,
+  "platform-sh": NodeRuntime,
+  "render-com": NodeRuntime,
+  "zeabur": NodeRuntime,
+  "zerops": NodeRuntime,
+  "stackblitz": WebContainer,
+  "codesandbox": WebContainer,
+  "aws-amplify": awsLambda,
+  "aws-lambda": awsLambda,
+  "azure": awsLambda,
+  "azure-functions": awsLambda,
+  "azure-swa": awsLambda,
+  "netlify": awsLambda,
+  "netlify-edge": {
+    browser: false,
+    resvg: "wasm",
+    satori: "node",
+    takumi: "wasm",
+    sharp: false,
+    emoji: "fetch",
+    // edge size limits
+    wasm: {
+      rollup: {
+        targetEnv: "auto-inline",
+        sync: ["@resvg/resvg-wasm/index_bg.wasm"]
+      }
+    }
+  },
+  "firebase": awsLambda,
+  "firebase-app-hosting": awsLambda,
+  "genezio": awsLambda,
+  "stormkit": awsLambda,
+  "vercel": awsLambda,
+  "vercel-edge": {
+    browser: false,
+    resvg: "wasm",
+    satori: "wasm",
+    takumi: "wasm",
+    sharp: false,
+    emoji: "fetch",
+    // edge size limits - bundling 24MB icons not viable
+    wasm: {
+      // lowers workers kb size
+      esmImport: true,
+      lazy: true
+    }
+  },
+  "cloudflare-pages": cloudflare,
+  "cloudflare-pages-static": cloudflare,
+  "cloudflare": cloudflare,
+  "cloudflare-module": cloudflare,
+  "cloudflare-durable": cloudflare
+};
+function resolveOgImagePreset(nitroConfig) {
+  const nuxt = kit.useNuxt();
+  if (nuxt.options.dev)
+    return "nitro-dev";
+  if (nuxt.options.nitro.static)
+    return "nitro-prerender";
+  return kit$1.resolveNitroPreset(nitroConfig);
+}
+function getPresetNitroPresetCompatibility(target) {
+  const normalizedTarget = target.replace(RE_LEGACY_SUFFIX, "");
+  let compatibility = RuntimeCompatibility[normalizedTarget];
+  if (!compatibility) {
+    logger_js.logger.warn(`Unknown Nitro preset "${target}" \u2014 falling back to node-server compatibility. Set ogImage.compatibility.runtime to override.`);
+    compatibility = NodeRuntime;
+  }
+  return compatibility;
+}
+async function applyNitroPresetCompatibility(nitroConfig, options) {
+  const target = resolveOgImagePreset(nitroConfig);
+  const compatibility = getPresetNitroPresetCompatibility(target);
+  const { resolve, detectedRenderers } = options;
+  const satoriEnabled = detectedRenderers.has("satori");
+  const browserEnabled = detectedRenderers.has("browser");
+  const takumiEnabled = detectedRenderers.has("takumi");
+  for (const renderer of detectedRenderers) {
+    if (!compatibility[renderer]) {
+      logger_js.logger.warn(`Renderer "${renderer}" detected but not supported on "${target}" preset. OG images using .${renderer}.vue components may fail.`);
+    }
+  }
+  const emptyMock = await resolve.resolvePath("./runtime/mock/empty");
+  nitroConfig.alias["#og-image/renderers/satori"] = satoriEnabled ? await resolve.resolvePath("./runtime/server/og-image/satori/renderer") : emptyMock;
+  nitroConfig.alias["#og-image/renderers/browser"] = browserEnabled ? await resolve.resolvePath("./runtime/server/og-image/browser/renderer") : emptyMock;
+  nitroConfig.alias["#og-image/renderers/takumi"] = takumiEnabled ? await resolve.resolvePath("./runtime/server/og-image/takumi/renderer") : emptyMock;
+  const resolvedCompatibility = { ...options.metadata || {} };
+  async function applyBinding(key) {
+    let binding = options.compatibility?.[key];
+    if (typeof binding === "undefined")
+      binding = compatibility[key];
+    const isRendererBinding = key === "browser" || key === "satori" || key === "takumi";
+    if (isRendererBinding && !detectedRenderers.has(key)) {
+      binding = false;
+    }
+    resolvedCompatibility[key] = binding;
+    if (!binding && isRendererBinding) {
+      nitroConfig.alias[`#og-image/renderers/${key}`] = emptyMock;
+    }
+    return {
+      [`#og-image/bindings/${key}`]: !binding ? emptyMock : await resolve.resolvePath(`./runtime/server/og-image/bindings/${key}/${binding}`)
+    };
+  }
+  const satoriPkgDir = await resolve.resolvePath("satori/package.json").then((p) => p.replace("/package.json", ""));
+  const yogaWasmPath = `${satoriPkgDir}/yoga.wasm`;
+  nitroConfig.alias = defu.defu(
+    { "#og-image/yoga-wasm": `${yogaWasmPath}?module` },
+    await applyBinding("browser"),
+    await applyBinding("satori"),
+    await applyBinding("takumi"),
+    await applyBinding("resvg"),
+    await applyBinding("sharp"),
+    nitroConfig.alias || {}
+  );
+  if (Object.values(resolvedCompatibility).includes("wasm")) {
+    nitroConfig.experimental = nitroConfig.experimental || {};
+    nitroConfig.experimental.wasm = true;
+  }
+  nitroConfig.rollupConfig = nitroConfig.rollupConfig || {};
+  nitroConfig.wasm = defu.defu(compatibility.wasm, nitroConfig.wasm);
+  nitroConfig.virtual["#og-image/compatibility"] = () => `export default ${JSON.stringify(resolvedCompatibility)}`;
+  kit.addTemplate({
+    filename: "nuxt-og-image/compatibility.mjs",
+    getContents() {
+      return `export default ${JSON.stringify(resolvedCompatibility)}`;
+    },
+    options: { mode: "server" }
+  });
+  return resolvedCompatibility;
+}
+async function ensureDependencies(dep, nuxt = kit.useNuxt()) {
+  const { ensureDependencyInstalled } = await import('nypm');
+  return Promise.all(dep.map((d) => {
+    return ensureDependencyInstalled(d, {
+      cwd: nuxt.options.rootDir,
+      dev: true
+    });
+  }));
+}
+
+const TAKUMI_INSTALL_TAG = "rc";
+const TAKUMI_CORE_PACKAGE = "@takumi-rs/core";
+const TAKUMI_WASM_PACKAGE = "@takumi-rs/wasm";
+const TAKUMI_CORE_INSTALL_SPEC = `${TAKUMI_CORE_PACKAGE}@${TAKUMI_INSTALL_TAG}`;
+const TAKUMI_WASM_INSTALL_SPEC = `${TAKUMI_WASM_PACKAGE}@${TAKUMI_INSTALL_TAG}`;
+const PROVIDER_DEPENDENCIES = [
+  {
+    name: "satori",
+    description: "SVG-based renderer using Satori",
+    bindings: {
+      "node": [
+        { name: "satori", description: "HTML to SVG renderer" },
+        { name: "@resvg/resvg-js", description: "SVG to PNG converter (native)" }
+      ],
+      "wasm": [
+        { name: "satori", description: "HTML to SVG renderer" },
+        { name: "@resvg/resvg-wasm", description: "SVG to PNG converter (WASM)" }
+      ],
+      "wasm-fs": [
+        { name: "satori", description: "HTML to SVG renderer" },
+        { name: "@resvg/resvg-wasm", description: "SVG to PNG converter (WASM)" }
+      ]
+    }
+  },
+  {
+    name: "takumi",
+    description: "Rust-based high-performance renderer (recommended)",
+    bindings: {
+      "node": [
+        { name: TAKUMI_CORE_PACKAGE, installSpec: TAKUMI_CORE_INSTALL_SPEC, description: "Native Takumi renderer" }
+      ],
+      "wasm": [
+        { name: TAKUMI_WASM_PACKAGE, installSpec: TAKUMI_WASM_INSTALL_SPEC, description: "WASM Takumi renderer" }
+      ],
+      "wasm-fs": [
+        { name: TAKUMI_WASM_PACKAGE, installSpec: TAKUMI_WASM_INSTALL_SPEC, description: "WASM Takumi renderer" }
+      ]
+    }
+  },
+  {
+    name: "browser",
+    description: "Browser-based screenshot renderer",
+    bindings: {
+      node: [
+        { name: "playwright-core", description: "Headless browser automation" }
+      ]
+    }
+  }
+];
+async function getInstalledProviders() {
+  const installed = [];
+  for (const provider of PROVIDER_DEPENDENCIES) {
+    if (provider.bindings.node) {
+      const allNodeInstalled = await Promise.all(
+        provider.bindings.node.map((dep) => hasResolvableDependency(dep.name))
+      );
+      if (allNodeInstalled.every(Boolean)) {
+        installed.push({ provider: provider.name, binding: "node" });
+        continue;
+      }
+    }
+    if (provider.bindings.wasm) {
+      const allWasmInstalled = await Promise.all(
+        provider.bindings.wasm.map((dep) => hasResolvableDependency(dep.name))
+      );
+      if (allWasmInstalled.every(Boolean)) {
+        installed.push({ provider: provider.name, binding: "wasm" });
+      }
+    }
+  }
+  return installed;
+}
+async function getMissingDependencies(provider, binding = "node") {
+  const missing = await getMissingProviderDependencyDefinitions(provider, binding);
+  return missing.map((d) => d.name);
+}
+async function getMissingProviderDependencyDefinitions(provider, binding = "node") {
+  const providerDef = PROVIDER_DEPENDENCIES.find((p) => p.name === provider);
+  if (!providerDef)
+    return [];
+  const deps = providerDef.bindings[binding] || providerDef.bindings.node || [];
+  const missing = [];
+  for (const dep of deps) {
+    if (!await hasResolvableDependency(dep.name))
+      missing.push(dep);
+  }
+  return missing;
+}
+function getDependencyDefinitions(provider, binding = "node") {
+  const providerDef = PROVIDER_DEPENDENCIES.find((p) => p.name === provider);
+  if (!providerDef)
+    return [];
+  return providerDef.bindings[binding] || providerDef.bindings.node || [];
+}
+function getDependencyInstallSpec(dep) {
+  return dep.installSpec || dep.name;
+}
+async function getMissingDependencyInstallSpecs(provider, binding = "node") {
+  const missing = await getMissingProviderDependencyDefinitions(provider, binding);
+  return missing.map(getDependencyInstallSpec);
+}
+function getProviderDependencyInstallSpecs(provider, binding = "node") {
+  return getDependencyDefinitions(provider, binding).map(getDependencyInstallSpec);
+}
+function getRecommendedBindingFromPreset(provider) {
+  const preset = resolveOgImagePreset();
+  const compatibility = getPresetNitroPresetCompatibility(preset);
+  return getRecommendedBinding(provider, compatibility);
+}
+function getRecommendedBinding(provider, compatibility) {
+  if (provider === "satori") {
+    const resvgBinding = compatibility.resvg;
+    if (resvgBinding === "wasm-fs")
+      return "wasm-fs";
+    if (resvgBinding === "wasm")
+      return "wasm";
+    return "node";
+  }
+  if (provider === "takumi") {
+    const takumiBinding = compatibility.takumi;
+    if (takumiBinding === "wasm")
+      return "wasm";
+    return "node";
+  }
+  if (provider === "browser") {
+    return "node";
+  }
+  return "node";
+}
+async function ensureProviderDependencies(provider, binding, nuxt) {
+  const missingDeps = await getMissingProviderDependencyDefinitions(provider, binding);
+  if (missingDeps.length === 0)
+    return { success: true, installed: [] };
+  const missingInstallSpecs = missingDeps.map(getDependencyInstallSpec);
+  const pm = await nypm.detectPackageManager(nuxt.options.rootDir);
+  const pmName = pm?.name || "npm";
+  logger_js.logger.info(`Installing ${provider} dependencies: ${missingInstallSpecs.join(", ")}`);
+  const installed = [];
+  for (const dep of missingDeps) {
+    const installSpec = getDependencyInstallSpec(dep);
+    const success = await nypm.addDependency(installSpec, {
+      cwd: nuxt.options.rootDir,
+      dev: false
+    }).then(() => {
+      installed.push(installSpec);
+      return true;
+    }).catch(() => {
+      logger_js.logger.error(`Failed to install ${installSpec}. Run manually: ${pmName} add ${installSpec}`);
+      return false;
+    });
+    if (!success)
+      return { success: false, installed };
+  }
+  return { success: true, installed };
+}
+function canPromptInteractively(env = {
+  hasTTY: stdEnv.hasTTY,
+  hasStdinTTY: Boolean(process.stdin?.isTTY),
+  isAgent: stdEnv.isAgent,
+  isCI: stdEnv.isCI
+}) {
+  return env.hasTTY && env.hasStdinTTY && !env.isAgent && !env.isCI;
+}
+async function promptForRendererSelection() {
+  logger_js.logger.info("Welcome to Nuxt OG Image! No renderer dependencies detected.");
+  const renderer = await logger_js.logger.prompt("Which renderer would you like to use?", {
+    type: "select",
+    options: PROVIDER_DEPENDENCIES.map((p) => p.name),
+    initial: "takumi"
+  });
+  return renderer || "takumi";
+}
+async function validateProviderSetup(renderer, compatibility) {
+  const issues = [];
+  const binding = getRecommendedBinding(renderer, compatibility);
+  const missing = await getMissingDependencyInstallSpecs(renderer, binding);
+  if (missing.length > 0) {
+    issues.push(`Missing ${renderer} dependencies: ${missing.join(", ")}`);
+  }
+  if (renderer === "satori") {
+    const hasResvgNode = await hasResolvableDependency("@resvg/resvg-js");
+    const hasResvgWasm = await hasResolvableDependency("@resvg/resvg-wasm");
+    if (!hasResvgNode && !hasResvgWasm) {
+      issues.push("Satori requires either @resvg/resvg-js (node) or @resvg/resvg-wasm to render PNGs");
+    }
+  }
+  if (renderer === "browser") {
+    const hasPlaywright = await hasResolvableDependency("playwright-core");
+    if (!hasPlaywright && binding === "node") {
+      issues.push("Browser renderer requires playwright-core");
+    }
+  }
+  return { valid: issues.length === 0, issues };
+}
+
+exports.PROVIDER_DEPENDENCIES = PROVIDER_DEPENDENCIES;
+exports.RE_LEGACY_SUFFIX = RE_LEGACY_SUFFIX;
+exports.RE_RENDERER_SUFFIX = RE_RENDERER_SUFFIX;
+exports.RE_WHITESPACE = RE_WHITESPACE;
+exports.TAKUMI_CORE_INSTALL_SPEC = TAKUMI_CORE_INSTALL_SPEC;
+exports.TAKUMI_WASM_INSTALL_SPEC = TAKUMI_WASM_INSTALL_SPEC;
+exports.applyNitroPresetCompatibility = applyNitroPresetCompatibility;
+exports.canPromptInteractively = canPromptInteractively;
+exports.checkLocalChrome = checkLocalChrome;
+exports.ensureDependencies = ensureDependencies;
+exports.ensureProviderDependencies = ensureProviderDependencies;
+exports.getInstalledProviders = getInstalledProviders;
+exports.getMissingDependencies = getMissingDependencies;
+exports.getMissingDependencyInstallSpecs = getMissingDependencyInstallSpecs;
+exports.getPresetNitroPresetCompatibility = getPresetNitroPresetCompatibility;
+exports.getProviderDependencyInstallSpecs = getProviderDependencyInstallSpecs;
+exports.getRecommendedBinding = getRecommendedBinding;
+exports.getRecommendedBindingFromPreset = getRecommendedBindingFromPreset;
+exports.getRegisteredBaseNames = getRegisteredBaseNames;
+exports.getRendererFromFilename = getRendererFromFilename;
+exports.hasResolvableDependency = hasResolvableDependency;
+exports.isUndefinedOrTruthy = isUndefinedOrTruthy;
+exports.migrateDefaultsComponent = migrateDefaultsComponent;
+exports.migrateFontsConfig = migrateFontsConfig;
+exports.promptFontsMigration = promptFontsMigration;
+exports.promptForRendererSelection = promptForRendererSelection;
+exports.resolveOgImagePreset = resolveOgImagePreset;
+exports.validateProviderSetup = validateProviderSetup;