nuxt-og-image 2.2.4 → 3.0.0-beta.1

package/dist/runtime/core/renderers/satori/instances.d.ts

@@ -0,0 +1,39 @@
+import type _satori from 'satori';
+export declare function useResvg(): Promise<new (svg: string | Uint8Array, options?: import("@resvg/resvg-wasm").ResvgRenderOptions | undefined) => {
+    free(): void;
+    render(): {
+        free(): void;
+        asPng(): Uint8Array;
+        readonly height: number;
+        readonly pixels: Uint8Array;
+        readonly width: number;
+    };
+    toString(): string;
+    innerBBox(): {
+        free(): void;
+        height: number;
+        width: number;
+        x: number;
+        y: number;
+    } | undefined;
+    getBBox(): {
+        free(): void;
+        height: number;
+        width: number;
+        x: number;
+        y: number;
+    } | undefined;
+    cropByBBox(bbox: {
+        free(): void;
+        height: number;
+        width: number;
+        x: number;
+        y: number;
+    }): void;
+    imagesToResolve(): any[];
+    resolveImage(href: string, buffer: Uint8Array): void;
+    readonly height: number;
+    readonly width: number;
+}>;
+export declare function useSatori(): Promise<typeof _satori>;
+export declare function useSharp(): Promise<any>;

package/dist/runtime/core/renderers/satori/instances.mjs

@@ -0,0 +1,17 @@
+const sharpInstance = { instance: void 0 };
+const resvgInstance = { instance: void 0 };
+const satoriInstance = { instance: void 0 };
+export async function useResvg() {
+  resvgInstance.instance = resvgInstance.instance || await import("#nuxt-og-image/bindings/resvg").then((m) => m.default);
+  await resvgInstance.instance.initWasmPromise;
+  return resvgInstance.instance.Resvg;
+}
+export async function useSatori() {
+  satoriInstance.instance = satoriInstance.instance || await import("#nuxt-og-image/bindings/satori").then((m) => m.default);
+  await satoriInstance.instance.initWasmPromise;
+  return satoriInstance.instance.satori;
+}
+export async function useSharp() {
+  sharpInstance.instance = sharpInstance.instance || await import("#nuxt-og-image/bindings/sharp").then((m) => m.default);
+  return sharpInstance.instance;
+}

package/dist/runtime/{nitro → core}/renderers/satori/plugins/encoding.mjs

@@ -1,5 +1,5 @@
 import { defineSatoriTransformer } from "../utils.mjs";
-import { decodeHtml } from "../../../utils-pure.mjs";
+import { decodeHtml } from "../../../options/extract.mjs";
 export default defineSatoriTransformer({
   filter: (node) => typeof node.props?.children === "string",
   transform: async (node) => {

package/dist/runtime/{nitro → core}/renderers/satori/plugins/imageSrc.mjs

@@ -2,31 +2,26 @@ import { Buffer } from "node:buffer";
 import { withBase } from "ufo";
 import sizeOf from "image-size";
 import { defineSatoriTransformer } from "../utils.mjs";
-import { readPublicAssetBase64, toBase64Image } from "../../../utils.mjs";
+import { toBase64Image } from "../../../env/assets.mjs";
+import { useNitroOrigin } from "#imports";
 export default defineSatoriTransformer({
   filter: (node) => node.type === "img",
-  transform: async (node, options) => {
+  transform: async (node, e) => {
     const src = node.props?.src;
-    if (src && src.startsWith("/")) {
+    if (src) {
       let updated = false;
-      const file = await readPublicAssetBase64(src);
       let dimensions;
-      if (file) {
-        node.props.src = file.src;
-        dimensions = { width: file.width, height: file.height };
-        updated = true;
-      }
       if (!updated) {
         let valid = true;
-        const response = await globalThis.$fetch(src, {
-          responseType: "arrayBuffer",
-          baseURL: options.requestOrigin
+        const response = await e.$fetch(src, {
+          baseURL: useNitroOrigin(e),
+          responseType: "arrayBuffer"
         }).catch(() => {
           valid = false;
         });
         if (valid) {
           node.props.src = toBase64Image(src, response);
-          const imageSize = await sizeOf(Buffer.from(response));
+          const imageSize = sizeOf(Buffer.from(response));
           dimensions = { width: imageSize.width, height: imageSize.height };
           updated = true;
         }
@@ -43,7 +38,7 @@ export default defineSatoriTransformer({
         }
       }
       if (!updated) {
-        node.props.src = `${withBase(src, `${options.requestOrigin}`)}?${Date.now()}`;
+        node.props.src = `${withBase(src, `${useNitroOrigin(e)}`)}?${Date.now()}`;
       }
     }
   }

package/dist/runtime/{nitro → core}/renderers/satori/plugins/twClasses.mjs

@@ -3,5 +3,6 @@ export default defineSatoriTransformer({
   filter: (node) => !!node.props?.class && !node.props?.tw,
   transform: async (node) => {
     node.props.tw = node.props.class;
+    node.props.tw = node.props.tw.replace(/icon|inline-style/g, "");
   }
 });

package/dist/runtime/core/renderers/satori/utils.d.ts

@@ -0,0 +1,4 @@
+import type { H3Event } from 'h3';
+import type { SatoriTransformer, VNode } from '../../../types';
+export declare function walkSatoriTree(e: H3Event, node: VNode, plugins: (SatoriTransformer | SatoriTransformer[])[]): Promise<void>;
+export declare function defineSatoriTransformer(transformer: SatoriTransformer | SatoriTransformer[]): SatoriTransformer | SatoriTransformer[];

package/dist/runtime/core/renderers/satori/utils.mjs

@@ -0,0 +1,20 @@
+export async function walkSatoriTree(e, node, plugins) {
+  if (!node.props?.children || !Array.isArray(node.props.children))
+    return;
+  if (node.props.children.length === 0) {
+    delete node.props.children;
+    return;
+  }
+  for (const child of node.props.children || []) {
+    if (child) {
+      for (const plugin of plugins.flat()) {
+        if (plugin.filter(child))
+          await plugin.transform(child, e);
+      }
+      await walkSatoriTree(e, child, plugins);
+    }
+  }
+}
+export function defineSatoriTransformer(transformer) {
+  return transformer;
+}

package/dist/runtime/core/renderers/satori/vnodes.d.ts

@@ -0,0 +1,3 @@
+import type { H3Event } from 'h3';
+import type { RendererOptions, VNode } from '../../../types';
+export declare function createVNodes(e: H3Event, options: RendererOptions): Promise<VNode>;

package/dist/runtime/core/renderers/satori/vnodes.mjs

@@ -0,0 +1,21 @@
+import { html as convertHtmlToSatori } from "satori-html";
+import { fetchHTML } from "../../html/fetch.mjs";
+import { walkSatoriTree } from "./utils.mjs";
+import emojis from "./plugins/emojis.mjs";
+import twClasses from "./plugins/twClasses.mjs";
+import imageSrc from "./plugins/imageSrc.mjs";
+import flex from "./plugins/flex.mjs";
+import encoding from "./plugins/encoding.mjs";
+export async function createVNodes(e, options) {
+  const html = options.html || await fetchHTML(e, options);
+  const body = html.match(/<body[^>]*>([\s\S]*)<\/body>/)?.[1] || html;
+  const satoriTree = convertHtmlToSatori(body);
+  await walkSatoriTree(e, satoriTree, [
+    emojis,
+    twClasses,
+    imageSrc,
+    flex,
+    encoding
+  ]);
+  return satoriTree;
+}

package/dist/runtime/core/utils/resolveRendererContext.d.ts

@@ -0,0 +1,7 @@
+import type { H3Error, H3Event } from 'h3';
+import type { Renderer, RuntimeOgImageOptions } from '../../types';
+export declare function resolveRendererContext(e: H3Event): Promise<H3Error | {
+    extension: RuntimeOgImageOptions['extension'];
+    renderer: Renderer;
+    options: RuntimeOgImageOptions;
+}>;

package/dist/runtime/core/utils/resolveRendererContext.mjs

@@ -0,0 +1,76 @@
+import { parseURL, withoutBase, withoutLeadingSlash, withoutTrailingSlash } from "ufo";
+import { createError, getQuery } from "h3";
+import { defu } from "defu";
+import { createRouter as createRadixRouter, toRouteMatcher } from "radix3";
+import { fetchPathHtmlAndExtractOptions } from "../options/fetch.mjs";
+import { prerenderCache } from "../cache/prerender.mjs";
+import { useRuntimeConfig } from "#imports";
+const satoriRendererInstance = { instance: void 0 };
+const chromiumRendererInstance = { instance: void 0 };
+export async function resolveRendererContext(e) {
+  const runtimeConfig = useRuntimeConfig()["nuxt-og-image"];
+  const path = parseURL(e.path).pathname;
+  const extension = path.split(".").pop();
+  if (!extension) {
+    return createError({
+      statusCode: 400,
+      statusMessage: `Missing OG Image type.`
+    });
+  }
+  const basePath = withoutTrailingSlash(
+    path.replace("/__og-image__/image", "").replace(`/og.${extension}`, "")
+  );
+  const queryParams = { ...getQuery(e) };
+  let options = queryParams.options;
+  if (!options) {
+    if (import.meta.prerender) {
+      const key = [
+        withoutLeadingSlash(basePath === "/" || !basePath ? "index" : basePath).replaceAll("/", "-")
+      ].join(":");
+      options = await prerenderCache?.getItem(key);
+    } else {
+      const payloadOptions = await fetchPathHtmlAndExtractOptions(e, basePath);
+      if (payloadOptions instanceof Error)
+        return payloadOptions;
+      options = payloadOptions;
+    }
+  }
+  delete queryParams.options;
+  const _routeRulesMatcher = toRouteMatcher(
+    createRadixRouter({ routes: useRuntimeConfig().nitro?.routeRules })
+  );
+  const routeRules = defu({}, ..._routeRulesMatcher.matchAll(
+    withoutBase(basePath.split("?")[0], useRuntimeConfig().app.baseURL)
+  ).reverse()).ogImage;
+  options = defu(queryParams, routeRules, options, runtimeConfig.defaults);
+  if (!options) {
+    return createError({
+      statusCode: 404,
+      statusMessage: "OG Image not found."
+    });
+  }
+  let renderer;
+  switch (options.renderer) {
+    case "satori":
+      renderer = satoriRendererInstance.instance = satoriRendererInstance.instance || await import("#nuxt-og-image/renderers/satori").then((m) => Object.keys(m.default).length ? m.default : false);
+      break;
+    case "chromium":
+      renderer = chromiumRendererInstance.instance = chromiumRendererInstance.instance || await import("#nuxt-og-image/renderers/chromium").then((m) => Object.keys(m.default).length ? m.default : false);
+      break;
+  }
+  if (!renderer) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: `Renderer ${options.renderer} is missing.`
+    });
+  }
+  return {
+    renderer,
+    extension,
+    options: {
+      ...options,
+      extension: extension === "json" ? options.extension : extension,
+      path: basePath
+    }
+  };
+}

package/dist/runtime/nitro/plugins/nuxt-content.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("nitropack/dist/runtime/plugin").NitroAppPlugin;
+export default _default;

package/dist/runtime/nitro/plugins/nuxt-content.mjs

@@ -0,0 +1,50 @@
+import { defineNitroPlugin } from "nitropack/dist/runtime/plugin";
+import { defu } from "defu";
+import { getOgImagePath } from "../../utilts.mjs";
+import { useRuntimeConfig } from "#imports";
+export default defineNitroPlugin((nitroApp) => {
+  nitroApp.hooks.hook("content:file:afterParse", async (content) => {
+    if (content._draft || content._extension !== "md" || content._partial || content.indexable === false || content.index === false)
+      return;
+    if (content.path && content.ogImage) {
+      const ogImageConfig = typeof content.ogImage === "object" ? content.ogImage : {};
+      const { defaults } = useRuntimeConfig()["nuxt-og-image"];
+      const optionsWithDefault = defu(ogImageConfig, defaults);
+      const src = getOgImagePath(content.path, optionsWithDefault.extension);
+      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) => g[1].toUpperCase())] = val;
+      });
+      content.head = defu({
+        script: [
+          {
+            id: "nuxt-og-image-options",
+            type: "application/json",
+            processTemplateParams: true,
+            innerHTML: payload,
+            // we want this to be last in our head
+            tagPosition: "bodyClose"
+          }
+        ],
+        meta: [
+          { property: "og:image", content: src },
+          { property: "og:image:width", content: optionsWithDefault.width },
+          { property: "og:image:height", content: optionsWithDefault.height },
+          { property: "og:image:type", content: `image/${optionsWithDefault.extension}` },
+          { property: "og:image:alt", content: optionsWithDefault.alt },
+          // twitter
+          { name: "twitter:card", content: "summary_large_image" },
+          { name: "twitter:image:src", content: src },
+          { name: "twitter:image:width", content: optionsWithDefault.width },
+          { name: "twitter:image:height", content: optionsWithDefault.height },
+          { name: "twitter:image:alt", content: optionsWithDefault.alt }
+        ]
+      });
+    }
+    return content;
+  });
+});

package/dist/runtime/nitro/plugins/prerender.d.ts

@@ -1,3 +1,2 @@
-import type { NitroAppPlugin } from 'nitropack';
-declare const OgImagePrenderNitroPlugin: NitroAppPlugin;
-export default OgImagePrenderNitroPlugin;
+declare const _default: import("nitropack/dist/runtime/plugin").NitroAppPlugin;
+export default _default;

package/dist/runtime/nitro/plugins/prerender.mjs

@@ -1,42 +1,34 @@
-import { appendHeader } from "h3";
-import { joinURL, parseURL, withoutLeadingSlash } from "ufo";
-import { extractAndNormaliseOgImageOptions } from "../utils-pure.mjs";
-import { useNitroCache } from "../../cache.mjs";
-import { getRouteRules } from "#internal/nitro";
-import { useRuntimeConfig } from "#imports";
-const OgImagePrenderNitroPlugin = async (nitroApp) => {
-  if (!process.env.prerender)
+import { parseURL, withoutLeadingSlash } from "ufo";
+import { getRouteRules } from "nitropack/dist/runtime/route-rules";
+import { extractAndNormaliseOgImageOptions } from "../../core/options/extract.mjs";
+import { prerenderCache, prerenderChromiumContext } from "../../core/cache/prerender.mjs";
+import { isInternalRoute } from "../../utilts.mjs";
+import { defineNitroPlugin } from "nitropack/dist/runtime/plugin";
+export default defineNitroPlugin(async (nitro) => {
+  if (!import.meta.prerender)
     return;
-  const { defaults } = useRuntimeConfig()["nuxt-og-image"];
-  nitroApp.hooks.hook("render:html", async (ctx, { event }) => {
-    const path = parseURL(event.path).pathname;
-    if (path.includes(".") || path.startsWith("/__nuxt_island/"))
+  nitro.hooks.hook("render:html", async ({ head, bodyAppend }, e) => {
+    const path = parseURL(e.event.path).pathname;
+    if (isInternalRoute(path))
       return;
-    const routeRules = getRouteRules(event)?.ogImage || {};
+    const routeRules = getRouteRules(e)?.ogImage || {};
     if (routeRules === false)
       return;
-    const options = extractAndNormaliseOgImageOptions(path, [
-      // payload may move
-      ctx.head.join("\n"),
-      ctx.bodyAppend.join("\n")
-    ].join("\n"), routeRules, defaults);
+    const options = extractAndNormaliseOgImageOptions([
+      head.join("\n"),
+      bodyAppend.join("\n")
+    ].join("\n"));
     if (!options)
       return;
     const key = [
-      withoutLeadingSlash(path === "/" || !path ? "index" : path).replaceAll("/", "-"),
-      "options"
+      withoutLeadingSlash(path === "/" || !path ? "index" : path).replaceAll("/", "-")
     ].join(":");
-    const { update } = await useNitroCache(event, "nuxt-og-image", {
-      key,
-      // shouldn't change for the prerender, 5 min cache
-      cacheTtl: 5 * 60 * 1e3,
-      cache: true,
-      headers: false,
-      skipRestore: true
-    });
-    await update(options);
-    if (options.provider === "satori")
-      appendHeader(event, "x-nitro-prerender", joinURL(path, "/__og_image__/og.png"));
+    await prerenderCache.setItem(key, options);
   });
-};
-export default OgImagePrenderNitroPlugin;
+  nitro.hooks.hook("close", () => {
+    if (prerenderChromiumContext.browser) {
+      prerenderChromiumContext.browser.close();
+      prerenderChromiumContext.browser = void 0;
+    }
+  });
+});

package/dist/runtime/nuxt/plugins/nuxt-content-canonical-urls.mjs

@@ -0,0 +1,29 @@
+import { parseURL } from "ufo";
+import { toValue } from "vue";
+import { isInternalRoute } from "../../utilts.mjs";
+import { useRequestEvent, withSiteUrl } from "#imports";
+export default defineNuxtPlugin((nuxtApp) => {
+  nuxtApp.hooks.hook("app:rendered", async (ctx) => {
+    const { ssrContext } = ctx;
+    const e = useRequestEvent();
+    const path = parseURL(e.path).pathname;
+    if (isInternalRoute(path))
+      return;
+    ssrContext?.head.use({
+      key: "nuxt-og-image:canonical-urls",
+      hooks: {
+        "tags:resolve": async ({ tags }) => {
+          for (const tag of tags) {
+            if (tag.tag === "meta" && (tag.props.property === "og:image" || tag.props.name === "twitter:image:src")) {
+              if (!tag.props.content.startsWith("https")) {
+                await nuxtApp.runWithContext(() => {
+                  tag.props.content = toValue(withSiteUrl(tag.props.content));
+                });
+              }
+            }
+          }
+        }
+      }
+    });
+  });
+});

package/dist/runtime/nuxt/plugins/route-rule-og-image.server.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/nuxt/plugins/route-rule-og-image.server.mjs

@@ -0,0 +1,72 @@
+import { defu } from "defu";
+import { parseURL, withoutBase } from "ufo";
+import { createRouter as createRadixRouter, toRouteMatcher } from "radix3";
+import { normaliseOptions } from "../../core/options/normalise.mjs";
+import { getOgImagePath, isInternalRoute } from "../../utilts.mjs";
+import { defineNuxtPlugin, useRequestEvent, useRuntimeConfig } from "#imports";
+export default defineNuxtPlugin((nuxtApp) => {
+  nuxtApp.hooks.hook("app:rendered", async (ctx) => {
+    const { ssrContext } = ctx;
+    const e = useRequestEvent();
+    const path = parseURL(e.path).pathname;
+    if (isInternalRoute(path))
+      return;
+    const _routeRulesMatcher = toRouteMatcher(
+      createRadixRouter({ routes: ssrContext?.runtimeConfig?.nitro?.routeRules })
+    );
+    const routeRules = defu({}, ..._routeRulesMatcher.matchAll(
+      withoutBase(path.split("?")[0], ssrContext?.runtimeConfig?.app.baseURL)
+    ).reverse()).ogImage;
+    if (typeof routeRules === "undefined")
+      return;
+    const payloadIndex = ssrContext.head.headEntries().findIndex((entry) => {
+      return entry.input?.script?.[0]?.id === "nuxt-og-image-options";
+    });
+    if (payloadIndex >= 0 && routeRules === false) {
+      ssrContext.head.headEntries().splice(payloadIndex, 1);
+      return;
+    }
+    if (payloadIndex >= 0)
+      return;
+    const options = normaliseOptions(routeRules);
+    const { defaults } = useRuntimeConfig()["nuxt-og-image"];
+    const optionsWithDefault = normaliseOptions(defu(options, defaults));
+    const src = getOgImagePath(ssrContext.url, optionsWithDefault.extension);
+    ssrContext?.head.push({
+      script: [
+        {
+          id: "nuxt-og-image-options",
+          type: "application/json",
+          processTemplateParams: true,
+          innerHTML: () => {
+            const payload = {
+              title: "%s"
+            };
+            Object.entries(options).forEach(([key, val]) => {
+              payload[key.replace(/-([a-z])/g, (g) => g[1].toUpperCase())] = val;
+            });
+            return payload;
+          },
+          // we want this to be last in our head
+          tagPosition: "bodyClose"
+        }
+      ],
+      meta: [
+        { property: "og:image", content: src },
+        { property: "og:image:width", content: optionsWithDefault.width },
+        { property: "og:image:height", content: optionsWithDefault.height },
+        { property: "og:image:type", content: `image/${optionsWithDefault.extension}` },
+        { property: "og:image:alt", content: optionsWithDefault.alt },
+        // twitter
+        { name: "twitter:card", content: "summary_large_image" },
+        { name: "twitter:image:src", content: src },
+        { name: "twitter:image:width", content: optionsWithDefault.width },
+        { name: "twitter:image:height", content: optionsWithDefault.height },
+        { name: "twitter:image:alt", content: optionsWithDefault.alt }
+      ]
+    }, {
+      mode: "server",
+      tagPriority: 35
+    });
+  });
+});

package/dist/runtime/{nitro/routes/debug.d.ts → server/routes/__og-image__/debug.json.d.ts}

@@ -3,7 +3,7 @@ declare const _default: import("h3").EventHandler<import("h3").EventHandlerReque
         value: any;
         source: any;
     };
-    dev: boolean | undefined;
+    componentNames: any;
     runtimeConfig: any;
     baseCacheKey: string;
     cachedKeys: string[];

package/dist/runtime/{nitro/routes/debug.mjs → server/routes/__og-image__/debug.json.mjs}

@@ -1,10 +1,11 @@
 import { defineEventHandler, setHeader } from "h3";
 import { prefixStorage } from "unstorage";
 import { useRuntimeConfig, useSiteConfig, useStorage } from "#imports";
+import { componentNames } from "#nuxt-og-image/component-names.mjs";
 export default defineEventHandler(async (e) => {
   setHeader(e, "Content-Type", "application/json");
   const runtimeConfig = useRuntimeConfig()["nuxt-og-image"];
-  const siteConfig = await useSiteConfig(e);
+  const siteConfig = await useSiteConfig(e, { debug: true });
   const baseCacheKey = runtimeConfig.runtimeCacheStorage === "default" ? `/cache/nuxt-og-image@${runtimeConfig.version}` : `/nuxt-og-image@${runtimeConfig.version}`;
   const cache = prefixStorage(useStorage(), `${baseCacheKey}/`);
   return {
@@ -12,7 +13,7 @@ export default defineEventHandler(async (e) => {
       value: siteConfig.url,
       source: siteConfig._context.url || "unknown"
     },
-    dev: process.dev,
+    componentNames,
     runtimeConfig,
     baseCacheKey,
     cachedKeys: await cache.getKeys()

package/dist/runtime/server/routes/__og-image__/font-[name]-[weight].[extension].mjs

@@ -0,0 +1,30 @@
+import { createError, defineEventHandler, proxyRequest, sendRedirect } from "h3";
+import { parseURL } from "ufo";
+export default defineEventHandler(async (e) => {
+  const path = parseURL(e.path).pathname;
+  const [name, weight] = path.split("/font/")[1].split(".")[0].split("/");
+  if (!name || !weight)
+    return "Provide a font name and weight";
+  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: `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: `Malformed Google Font CSS ${css}`
+  });
+});

package/dist/runtime/server/routes/__og-image__/image-[path]-og.[extension].mjs

@@ -0,0 +1,44 @@
+import { H3Error, createError, defineEventHandler, setHeader } from "h3";
+import { resolveRendererContext } from "../../../core/utils/resolveRendererContext.mjs";
+import { fetchHTML } from "../../../core/html/fetch.mjs";
+export default defineEventHandler(async (e) => {
+  const ctx = await resolveRendererContext(e);
+  if (ctx instanceof H3Error)
+    return ctx;
+  const { extension, options, renderer } = ctx;
+  if (!options.cacheTtl || import.meta.dev) {
+    setHeader(e, "Cache-Control", "no-cache, no-store, must-revalidate");
+    setHeader(e, "Pragma", "no-cache");
+    setHeader(e, "Expires", "0");
+  }
+  switch (extension) {
+    case "html":
+      setHeader(e, "Content-Type", `text/html`);
+      return fetchHTML(e, options);
+    case "json":
+      setHeader(e, "Content-Type", "application/json");
+      return {
+        ...ctx,
+        siteConfig: useSiteConfig(e),
+        vnodes: options.renderer === "satori" ? await renderer.createImage(e, { ...options, extension: "json" }) : void 0
+      };
+    case "svg":
+    case "png":
+    case "jpeg":
+    case "jpg":
+      if (!renderer.supportedFormats.includes(options.extension)) {
+        return createError({
+          statusCode: 400,
+          statusMessage: `Generating ${options.extension}'s with ${renderer.name} is not supported.`
+        });
+      }
+      setHeader(e, "Content-Type", `image/${options.extension === "svg" ? "svg+xml" : options.extension}`);
+      break;
+    default:
+      return createError({
+        statusCode: 400,
+        statusMessage: `Invalid request for og.${options.extension}.`
+      });
+  }
+  return renderer.createImage(e, options);
+});