nuxt-og-image 5.1.10 → 5.1.12

package/dist/runtime/server/util/eventHandlers.js

@@ -0,0 +1,156 @@
+import { createError, getQuery, H3Error, proxyRequest, sendRedirect, setHeader, setResponseHeader } from "h3";
+import { parseURL } from "ufo";
+import { normaliseFontInput } from "../../shared.js";
+import { resolveContext } from "../og-image/context.js";
+import { assets } from "../og-image/satori/font.js";
+import { html } from "../og-image/templates/html.js";
+import { useOgImageRuntimeConfig } from "../utils.js";
+import { useOgImageBufferCache } from "./cache.js";
+export async function fontEventHandler(e) {
+  const path = parseURL(e.path).pathname;
+  const { fonts } = useOgImageRuntimeConfig();
+  const key = path.split("/font/")[1];
+  if (key && key.includes(":")) {
+    const font2 = fonts.find((f) => f.key === key);
+    if (font2?.key && await assets.hasItem(font2.key)) {
+      let fontData = await assets.getItem(font2.key);
+      if (fontData instanceof Uint8Array) {
+        const decoder = new TextDecoder();
+        fontData = decoder.decode(fontData);
+      }
+      if (key.includes(".oft")) {
+        setResponseHeader(e, "Content-Type", "font/otf");
+      } else if (key.includes(".woff2")) {
+        setResponseHeader(e, "Content-Type", "font/woff2");
+      } else if (key.includes(".ttf")) {
+        setResponseHeader(e, "Content-Type", "font/ttf");
+      }
+      return Buffer.from(fontData, "base64");
+    }
+  }
+  const [_name, _weight] = String(key?.split(".")[0]).split("/");
+  if (!_name || !_weight)
+    return "Provide a font name and weight";
+  const name = String(_name[0]).toUpperCase() + _name.slice(1);
+  const weight = Math.round(Number.parseInt(_weight) / 100) * 100;
+  const config = useOgImageRuntimeConfig();
+  const normalisedFonts = normaliseFontInput(config.fonts);
+  let font;
+  if (typeof getQuery(e).font === "string")
+    font = JSON.parse(getQuery(e).font);
+  if (!font) {
+    font = normalisedFonts.find((font2) => {
+      return font2.name.toLowerCase() === name.toLowerCase() && weight === Number(font2.weight);
+    });
+  }
+  if (!font) {
+    return createError({
+      statusCode: 404,
+      statusMessage: `[Nuxt OG Image] Font ${name}:${weight} not found`
+    });
+  }
+  const css = await globalThis.$fetch(`https://fonts.googleapis.com/css2?family=${name}:wght@${weight}`, {
+    headers: {
+      // Make sure it returns TTF.
+      "User-Agent": "Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10_6_8; de-at) AppleWebKit/533.21.1 (KHTML, like Gecko) Version/5.0.5 Safari/533.21.1"
+    }
+  });
+  if (!css) {
+    return createError({
+      statusCode: 500,
+      statusMessage: `[Nuxt OG Image] Invalid Google Font ${name}:${weight}`
+    });
+  }
+  const ttfResource = css.match(/src: url\((.+)\) format\('(opentype|truetype)'\)/);
+  if (ttfResource?.[1])
+    return proxyRequest(e, ttfResource[1], {});
+  const woff2Resource = css.match(/src: url\((.+)\) format\('woff2'\)/);
+  if (woff2Resource?.[1])
+    return sendRedirect(e, woff2Resource[1]);
+  return createError({
+    statusCode: 500,
+    statusMessage: `[Nuxt OG Image] Malformed Google Font CSS ${css}`
+  });
+}
+export async function imageEventHandler(e) {
+  const ctx = await resolveContext(e);
+  if (ctx instanceof H3Error)
+    return ctx;
+  const { isDebugJsonPayload, extension, options, renderer } = ctx;
+  const { debug, baseCacheKey } = useOgImageRuntimeConfig();
+  const compatibilityHints = [];
+  if (isDebugJsonPayload) {
+    const queryExtension = getQuery(e).extension || ctx.options.extension;
+    if (["jpeg", "jpg"].includes(queryExtension) && options.renderer === "satori")
+      compatibilityHints.push("Converting PNGs to JPEGs requires Sharp which only runs on Node based systems.");
+    if (options.renderer === "chromium")
+      compatibilityHints.push("Using Chromium to generate images is only supported in Node based environments. It's recommended to only use this if you're prerendering");
+    setHeader(e, "Content-Type", "application/json");
+    return {
+      siteConfig: {
+        url: e.context.siteConfig.get().url
+      },
+      compatibilityHints,
+      cacheKey: ctx.key,
+      options: ctx.options,
+      ...options.renderer === "satori" ? await renderer.debug(ctx) : void 0
+    };
+  }
+  switch (extension) {
+    case "html":
+      setHeader(e, "Content-Type", `text/html`);
+      return html(ctx);
+    case "svg":
+      if (!debug && !import.meta.dev) {
+        return createError({
+          statusCode: 404
+        });
+      }
+      if (ctx.renderer.name !== "satori") {
+        return createError({
+          statusCode: 400,
+          statusMessage: `[Nuxt OG Image] Generating ${extension}'s with ${renderer.name} is not supported.`
+        });
+      }
+      setHeader(e, "Content-Type", `image/svg+xml`);
+      return (await ctx.renderer.debug(ctx)).svg;
+    case "png":
+    case "jpeg":
+    case "jpg":
+      if (!renderer.supportedFormats.includes(extension)) {
+        return createError({
+          statusCode: 400,
+          statusMessage: `[Nuxt OG Image] Generating ${extension}'s with ${renderer.name} is not supported.`
+        });
+      }
+      setHeader(e, "Content-Type", `image/${extension === "jpg" ? "jpeg" : extension}`);
+      break;
+    default:
+      return createError({
+        statusCode: 400,
+        statusMessage: `[Nuxt OG Image] Invalid request for og.${extension}.`
+      });
+  }
+  const cacheApi = await useOgImageBufferCache(ctx, {
+    cacheMaxAgeSeconds: ctx.options.cacheMaxAgeSeconds,
+    baseCacheKey
+  });
+  if (typeof cacheApi === "undefined")
+    return;
+  if (cacheApi instanceof H3Error)
+    return cacheApi;
+  let image = cacheApi.cachedItem;
+  if (!image) {
+    image = await renderer.createImage(ctx);
+    if (image instanceof H3Error)
+      return image;
+    if (!image) {
+      return createError({
+        statusCode: 500,
+        statusMessage: `Failed to generate og.${extension}.`
+      });
+    }
+    await cacheApi.update(image);
+  }
+  return image;
+}

package/dist/runtime/server/util/kit.d.ts

@@ -0,0 +1,6 @@
+import type { H3Event } from 'h3';
+import type { NitroRouteRules } from 'nitropack';
+import type { NuxtIslandResponse } from 'nuxt/app';
+export declare function fetchIsland(e: H3Event, component: string, props: Record<string, any>): Promise<NuxtIslandResponse>;
+export declare function withoutQuery(path: string): string | undefined;
+export declare function createNitroRouteRuleMatcher(): ((path: string) => NitroRouteRules);

package/dist/runtime/server/util/kit.js

@@ -0,0 +1,32 @@
+import { defu } from "defu";
+import { useRuntimeConfig } from "nitropack/runtime";
+import { hash } from "ohash";
+import { createRouter as createRadixRouter, toRouteMatcher } from "radix3";
+import { withoutBase, withoutTrailingSlash } from "ufo";
+export function fetchIsland(e, component, props) {
+  const hashId = hash([component, props]).replaceAll("_", "-");
+  return e.$fetch(`/__nuxt_island/${component}_${hashId}.json`, {
+    params: {
+      props: JSON.stringify(props)
+    }
+  });
+}
+export function withoutQuery(path) {
+  return path.split("?")[0];
+}
+export function createNitroRouteRuleMatcher() {
+  const { nitro, app } = useRuntimeConfig();
+  const _routeRulesMatcher = toRouteMatcher(
+    createRadixRouter({
+      routes: Object.fromEntries(
+        Object.entries(nitro?.routeRules || {}).map(([path, rules]) => [withoutTrailingSlash(path), rules])
+      )
+    })
+  );
+  return (path) => {
+    return defu({}, ..._routeRulesMatcher.matchAll(
+      // radix3 does not support trailing slashes
+      withoutBase(withoutTrailingSlash(withoutQuery(path)), app.baseURL)
+    ).reverse());
+  };
+}

package/dist/runtime/server/util/logger.d.ts

@@ -0,0 +1 @@
+export declare const logger: import("consola").ConsolaInstance;

package/dist/runtime/server/util/logger.js

@@ -0,0 +1,6 @@
+import { createConsola } from "consola";
+export const logger = createConsola({
+  defaults: {
+    tag: "Nuxt OG Image"
+  }
+});

package/dist/runtime/server/util/options.d.ts

@@ -0,0 +1,2 @@
+import type { DefineOgImageInput, OgImageOptions, OgImagePrebuilt } from '../../types.js';
+export declare function normaliseOptions(_options: DefineOgImageInput): OgImageOptions | OgImagePrebuilt;

package/dist/runtime/server/util/options.js

@@ -0,0 +1,18 @@
+import { componentNames } from "#og-image-virtual/component-names.mjs";
+export function normaliseOptions(_options) {
+  const options = { ..._options };
+  if (!options)
+    return options;
+  if (options.component && componentNames) {
+    const originalName = options.component;
+    for (const component of componentNames) {
+      if (component.pascalName.endsWith(originalName) || component.kebabName.endsWith(originalName)) {
+        options.component = component.pascalName;
+        break;
+      }
+    }
+  } else if (!options.component) {
+    options.component = componentNames[0]?.pascalName;
+  }
+  return options;
+}

package/dist/runtime/server/util/plugins.d.ts

@@ -0,0 +1,2 @@
+import type { NitroApp } from 'nitropack/runtime/app';
+export declare function nuxtContentPlugin(nitroApp: NitroApp): void;

package/dist/runtime/server/util/plugins.js

@@ -0,0 +1,56 @@
+import { defu } from "defu";
+import { stringify } from "devalue";
+import { withQuery } from "ufo";
+import { generateMeta } from "../../shared.js";
+import { getOgImagePath, useOgImageRuntimeConfig } from "../utils.js";
+import { normaliseOptions } from "./options.js";
+export function nuxtContentPlugin(nitroApp) {
+  const { isNuxtContentDocumentDriven, strictNuxtContentPaths, defaults } = useOgImageRuntimeConfig();
+  nitroApp.hooks.hook("content:file:afterParse", async (content) => {
+    if (content._draft || content._extension !== "md" || content._partial || content.indexable === false || content.index === false)
+      return;
+    let path = content.path;
+    if (isNuxtContentDocumentDriven && !path)
+      path = content._path;
+    let shouldRenderOgImage = !!content.ogImage;
+    if (typeof content.ogImage === "undefined" && (strictNuxtContentPaths || typeof content.path !== "undefined")) {
+      shouldRenderOgImage = true;
+    }
+    if (path && shouldRenderOgImage) {
+      const ogImageConfig = (typeof content.ogImage === "object" ? content.ogImage : {}) || {};
+      const optionsWithDefault = defu(ogImageConfig, defaults);
+      let src = optionsWithDefault.url || getOgImagePath(path, optionsWithDefault);
+      if (optionsWithDefault._query && Object.keys(optionsWithDefault._query).length)
+        src = withQuery(src, { _query: optionsWithDefault._query });
+      const meta = generateMeta(src, ogImageConfig);
+      if (optionsWithDefault.url) {
+        content.head = defu({ meta }, content.head);
+        return content;
+      }
+      const payload = {
+        title: content.title,
+        excerpt: content.description || content.excerpt,
+        ...content.ogImage
+      };
+      Object.entries(ogImageConfig).forEach(([key, val]) => {
+        payload[key.replace(/-([a-z])/g, (g) => String(g[1]).toUpperCase())] = val;
+      });
+      content.head = defu({
+        script: [
+          {
+            id: "nuxt-og-image-overrides",
+            type: "application/json",
+            processTemplateParams: true,
+            innerHTML: stringify(normaliseOptions(payload)),
+            // we want this to be last in our head
+            tagPosition: "bodyClose",
+            tagPriority: 30
+            // slighty higher priority
+          }
+        ],
+        meta: generateMeta(src, optionsWithDefault)
+      }, content.head);
+    }
+    return content;
+  });
+}

package/dist/runtime/server/util/wasm.d.ts

@@ -0,0 +1,2 @@
+export declare function importWasm(input: any): Promise<any>;
+export declare function readWasmFile(input: string): Promise<Buffer<ArrayBufferLike>>;

package/dist/runtime/server/util/wasm.js

@@ -0,0 +1,16 @@
+import { readFile } from "node:fs/promises";
+import { resolvePath } from "mlly";
+export async function importWasm(input) {
+  const _input = await input;
+  const _module = _input.default || _input;
+  if (typeof _module === "function") {
+    const fnRes = await _module();
+    const _instance = fnRes.instance || fnRes;
+    return _instance.exports || _instance || _module;
+  }
+  return _module;
+}
+export async function readWasmFile(input) {
+  const path = await resolvePath(input);
+  return readFile(path);
+}

package/dist/runtime/server/utils.d.ts

@@ -0,0 +1,4 @@
+import type { OgImageOptions, OgImageRuntimeConfig } from '#og-image/types';
+import type { H3Event } from 'h3';
+export declare function getOgImagePath(pagePath: string, _options?: Partial<OgImageOptions>): string;
+export declare function useOgImageRuntimeConfig(e?: H3Event): OgImageRuntimeConfig;

package/dist/runtime/server/utils.js

@@ -0,0 +1,20 @@
+import { useRuntimeConfig } from "nitropack/runtime";
+import { joinURL, withQuery } from "ufo";
+export function getOgImagePath(pagePath, _options) {
+  const baseURL = useRuntimeConfig().app.baseURL;
+  const extension = _options?.extension || useOgImageRuntimeConfig().defaults.extension;
+  const path = joinURL("/", baseURL, `__og-image__/${import.meta.prerender ? "static" : "image"}`, pagePath, `og.${extension}`);
+  if (Object.keys(_options?._query || {}).length) {
+    return withQuery(path, _options._query);
+  }
+  return path;
+}
+export function useOgImageRuntimeConfig(e) {
+  const c = useRuntimeConfig(e);
+  return {
+    ...c["nuxt-og-image"],
+    app: {
+      baseURL: c.app.baseURL
+    }
+  };
+}

package/dist/runtime/shared.d.ts

@@ -0,0 +1,15 @@
+import type { ResolvableMeta } from '@unhead/vue';
+import type { InputFontConfig, OgImageOptions, OgImagePrebuilt, ResolvedFontConfig } from './types.js';
+export declare function generateMeta(url: OgImagePrebuilt['url'] | string, resolvedOptions: OgImageOptions | OgImagePrebuilt): ResolvableMeta[];
+export declare function toBase64Image(data: string | ArrayBuffer): string;
+export declare function isInternalRoute(path: string): boolean;
+export declare function separateProps(options: OgImageOptions | undefined, ignoreKeys?: string[]): {
+    props: Record<string, any>;
+};
+export declare function normaliseFontInput(fonts: InputFontConfig[]): ResolvedFontConfig[];
+export declare function withoutQuery(path: string): string | undefined;
+export declare function getExtension(path: string): string;
+/**
+ * @deprecated Please use `#og-image/app/utils` instead.
+ */
+export declare function useOgImageRuntimeConfig(): {};

package/dist/runtime/shared.js

@@ -0,0 +1,132 @@
+import { defu } from "defu";
+import { toValue } from "vue";
+export function generateMeta(url, resolvedOptions) {
+  const meta = [
+    { property: "og:image", content: url },
+    { property: "og:image:type", content: () => `image/${getExtension(toValue(url)) || resolvedOptions.extension}` },
+    { name: "twitter:card", content: "summary_large_image" },
+    // we don't need this but avoids issue when using useSeoMeta({ twitterImage })
+    { name: "twitter:image", content: url },
+    { name: "twitter:image:src", content: url }
+  ];
+  if (resolvedOptions.width) {
+    meta.push({ property: "og:image:width", content: resolvedOptions.width });
+    meta.push({ name: "twitter:image:width", content: resolvedOptions.width });
+  }
+  if (resolvedOptions.height) {
+    meta.push({ property: "og:image:height", content: resolvedOptions.height });
+    meta.push({ name: "twitter:image:height", content: resolvedOptions.height });
+  }
+  if (resolvedOptions.alt) {
+    meta.push({ property: "og:image:alt", content: resolvedOptions.alt });
+    meta.push({ name: "twitter:image:alt", content: resolvedOptions.alt });
+  }
+  return meta;
+}
+function detectBase64MimeType(data) {
+  const signatures = {
+    "R0lGODdh": "image/gif",
+    "R0lGODlh": "image/gif",
+    "iVBORw0KGgo": "image/png",
+    "/9j/": "image/jpeg",
+    "UklGR": "image/webp",
+    "AAABAA": "image/x-icon"
+  };
+  for (const s in signatures) {
+    if (data.startsWith(s)) {
+      return signatures[s];
+    }
+  }
+  return "image/svg+xml";
+}
+export function toBase64Image(data) {
+  const base64 = typeof data === "string" ? data : Buffer.from(data).toString("base64");
+  const type = detectBase64MimeType(base64);
+  return `data:${type};base64,${base64}`;
+}
+export function isInternalRoute(path) {
+  return path.startsWith("/_") || path.startsWith("@");
+}
+function filterIsOgImageOption(key) {
+  const keys = [
+    "url",
+    "extension",
+    "width",
+    "height",
+    "fonts",
+    "alt",
+    "props",
+    "renderer",
+    "html",
+    "component",
+    "renderer",
+    "emojis",
+    "_query",
+    "satori",
+    "resvg",
+    "sharp",
+    "screenshot",
+    "cacheMaxAgeSeconds"
+  ];
+  return keys.includes(key);
+}
+export function separateProps(options, ignoreKeys = []) {
+  options = options || {};
+  const _props = defu(options.props, Object.fromEntries(
+    Object.entries({ ...options }).filter(([k]) => !filterIsOgImageOption(k) && !ignoreKeys.includes(k))
+  ));
+  const props = {};
+  Object.entries(_props).forEach(([key, val]) => {
+    props[key.replace(/-([a-z])/g, (g) => String(g[1]).toUpperCase())] = val;
+  });
+  return {
+    ...Object.fromEntries(
+      Object.entries({ ...options }).filter(([k]) => filterIsOgImageOption(k) || ignoreKeys.includes(k))
+    ),
+    props
+  };
+}
+export function normaliseFontInput(fonts) {
+  return fonts.map((f) => {
+    if (typeof f === "string") {
+      const vals = f.split(":");
+      const includesStyle = vals.length === 3;
+      let name, weight, style;
+      if (includesStyle) {
+        name = vals[0];
+        style = vals[1];
+        weight = vals[2];
+      } else {
+        name = vals[0];
+        weight = vals[1];
+      }
+      return {
+        cacheKey: f,
+        name,
+        weight: weight || 400,
+        style: style || "normal",
+        path: void 0
+      };
+    }
+    return {
+      cacheKey: f.key || `${f.name}:${f.style}:${f.weight}`,
+      style: "normal",
+      weight: 400,
+      ...f
+    };
+  });
+}
+export function withoutQuery(path) {
+  return path.split("?")[0];
+}
+export function getExtension(path) {
+  path = withoutQuery(path);
+  const lastSegment = path.split("/").pop() || path;
+  const extension = lastSegment.split(".").pop() || lastSegment;
+  if (extension === "jpg")
+    return "jpeg";
+  return extension;
+}
+export function useOgImageRuntimeConfig() {
+  return {};
+}

package/dist/runtime/types.d.ts

@@ -0,0 +1,187 @@
+import type { OgImageComponents } from '#og-image/components';
+import type { ResvgRenderOptions } from '@resvg/resvg-js';
+import type { UnoGenerator } from '@unocss/core';
+import type { AllowedComponentProps, Component, ComponentCustomProps, VNodeProps } from '@vue/runtime-core';
+import type { H3Error, H3Event } from 'h3';
+import type { NitroOptions } from 'nitropack';
+import type { NitroApp } from 'nitropack/types';
+import type { SatoriOptions } from 'satori';
+import type { html } from 'satori-html';
+import type { JpegOptions, SharpOptions } from 'sharp';
+import type { Ref } from 'vue';
+export interface OgImageRenderEventContext {
+    unocss: UnoGenerator;
+    e: H3Event;
+    extension: 'png' | 'jpeg' | 'jpg' | 'svg' | 'html' | 'json';
+    key: string;
+    basePath: string;
+    renderer: Renderer;
+    options: OgImageOptions;
+    isDebugJsonPayload: boolean;
+    publicStoragePath: string;
+    runtimeConfig: OgImageRuntimeConfig;
+    _nitro: NitroApp;
+}
+export type IconifyEmojiIconSets = 'twemoji' | 'noto' | 'fluent-emoji' | 'fluent-emoji-flat' | 'fluent-emoji-high-contrast' | 'noto-v1' | 'emojione' | 'emojione-monotone' | 'emojione-v1' | 'streamline-emojis' | 'openmoji';
+export interface OgImageRuntimeConfig {
+    version: string;
+    satoriOptions: SatoriOptions;
+    resvgOptions: ResvgRenderOptions;
+    sharpOptions: SharpOptions;
+    publicStoragePath: string;
+    defaults: OgImageOptions;
+    debug: boolean;
+    baseCacheKey: string;
+    fonts: FontConfig[];
+    hasNuxtIcon: boolean;
+    colorPreference: 'light' | 'dark';
+    isNuxtContentDocumentDriven: boolean;
+    strictNuxtContentPaths: boolean;
+    zeroRuntime: boolean;
+    componentDirs?: string[];
+    app: {
+        baseURL: string;
+    };
+}
+export interface OgImageComponent {
+    path?: string;
+    pascalName: string;
+    kebabName: string;
+    hash: string;
+    category: 'app' | 'community' | 'pro';
+    credits?: string;
+}
+export interface ScreenshotOptions {
+    colorScheme?: 'dark' | 'light';
+    selector?: string;
+    mask?: string;
+    /**
+     * The width of the screenshot.
+     *
+     * @default 1200
+     */
+    width: number;
+    /**
+     * The height of the screenshot.
+     *
+     * @default 630
+     */
+    height: number;
+    /**
+     * How long to wait before taking the screenshot. Useful for waiting for animations.
+     */
+    delay?: number;
+}
+export interface OgImagePrebuilt extends OgImageOptions {
+}
+export type DefineOgImageInput = OgImageOptions | OgImagePrebuilt | false;
+export interface OgImageOptions<T extends keyof OgImageComponents = 'NuxtSeo'> {
+    /**
+     * The width of the screenshot.
+     *
+     * @default 1200
+     */
+    width?: number | (() => number) | Ref<number>;
+    /**
+     * The height of the screenshot.
+     *
+     * @default 630
+     */
+    height?: number | (() => number) | Ref<number>;
+    /**
+     * The alt text for the image.
+     */
+    alt?: string | (() => string) | Ref<string>;
+    /**
+     * Use a prebuilt image instead of generating one.
+     *
+     * Should be an absolute URL.
+     */
+    url?: string | (() => string) | Ref<string>;
+    /**
+     * The name of the component to render.
+     */
+    component?: T | string;
+    /**
+     * Props to pass to the component.
+     */
+    props?: OgImageComponents[T] | Record<string, any>;
+    renderer?: 'chromium' | 'satori';
+    extension?: 'png' | 'jpeg' | 'jpg';
+    emojis?: IconifyEmojiIconSets;
+    /**
+     * Provide a static HTML template to render the OG Image instead of a component.
+     */
+    html?: string;
+    resvg?: ResvgRenderOptions;
+    satori?: SatoriOptions;
+    screenshot?: Partial<ScreenshotOptions>;
+    sharp?: SharpOptions & JpegOptions;
+    fonts?: InputFontConfig[];
+    cacheMaxAgeSeconds?: number;
+    /**
+     * Social preview metadata
+     * @internal
+     */
+    socialPreview?: SocialPreviewMetaData;
+    /**
+     * @internal
+     */
+    _query?: Record<string, any>;
+}
+export interface FontConfig {
+    name: string;
+    style?: 'normal' | 'ital';
+    weight?: string | number;
+    path?: string;
+    key?: string;
+    absolutePath?: boolean;
+}
+export interface ResolvedFontConfig extends FontConfig {
+    cacheKey: string;
+    data?: BufferSource;
+}
+export type InputFontConfig = (`${string}:${number}` | `${string}:${'normal' | 'ital'}:${number}` | string | FontConfig);
+export interface RuntimeCompatibilitySchema {
+    chromium: 'chrome-launcher' | 'on-demand' | 'playwright' | false;
+    ['css-inline']: 'node' | 'wasm' | 'wasm-fs' | false;
+    resvg: 'node' | 'wasm' | 'wasm-fs' | false;
+    satori: 'node' | 'wasm' | 'wasm-fs' | false;
+    sharp: 'node' | false;
+    wasm?: NitroOptions['wasm'];
+}
+export type CompatibilityFlags = Partial<Omit<RuntimeCompatibilitySchema, 'wasm'>>;
+export interface CompatibilityFlagEnvOverrides {
+    dev?: CompatibilityFlags;
+    runtime?: CompatibilityFlags;
+    prerender?: CompatibilityFlags;
+}
+export type RendererOptions = Omit<OgImageOptions, 'extension'> & {
+    extension: Omit<OgImageOptions['extension'], 'html'>;
+};
+export interface Renderer {
+    name: 'chromium' | 'satori';
+    supportedFormats: Partial<RendererOptions['extension']>[];
+    createImage: (e: OgImageRenderEventContext) => Promise<H3Error | BufferSource | Buffer | Uint8Array | void | undefined>;
+    debug: (e: OgImageRenderEventContext) => Promise<Record<string, any>>;
+}
+export type ExtractComponentProps<T extends Component> = T extends new (...args: any) => any ? Omit<InstanceType<T>['$props'], keyof ComponentCustomProps | keyof VNodeProps | keyof AllowedComponentProps> : never;
+export type OgImagePageScreenshotOptions = Omit<OgImageOptions, 'html' | 'renderer' | 'component' | 'satori' | 'resvg' | 'sharp'>;
+export type VNode = ReturnType<typeof html>;
+export interface SatoriTransformer {
+    filter: (node: VNode) => boolean;
+    transform: (node: VNode, e: OgImageRenderEventContext) => Promise<void> | void;
+}
+export interface SocialPreviewMetaData {
+    twitter?: Record<string, string>;
+    og?: Record<string, string> & {
+        image?: string | {
+            'image:width'?: string | number;
+            'image:height'?: string | number;
+            [key: string]: any;
+        };
+    };
+}
+export interface RouteRulesOgImage extends Partial<OgImageOptions> {
+    [key: string]: any;
+}