@nuxt/scripts 1.0.0-beta.7 → 1.0.0-rc.10

package/dist/runtime/server/bluesky-embed.js

@@ -0,0 +1,78 @@
+import { createError, defineEventHandler, getQuery, setHeader } from "h3";
+import { useRuntimeConfig } from "nitropack/runtime";
+import { createCachedJsonFetch } from "./utils/cached-upstream.js";
+import { rewriteBlueskyPostImages } from "./utils/embed-rewriters.js";
+import { withSigning } from "./utils/withSigning.js";
+const BSKY_POST_URL_RE = /^https:\/\/bsky\.app\/profile\/([^/]+)\/post\/([^/?]+)$/;
+const EMBED_BSKY_SUFFIX_RE = /\/embed\/bluesky$/;
+const cachedProfileFetch = createCachedJsonFetch(
+  "nuxt-scripts-bsky-profile",
+  86400,
+  (url) => url
+);
+const cachedPostFetch = createCachedJsonFetch(
+  "nuxt-scripts-bsky-post",
+  600,
+  (url) => url
+);
+export default withSigning(defineEventHandler(async (event) => {
+  const query = getQuery(event);
+  const postUrl = query.url;
+  if (!postUrl) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "Post URL is required"
+    });
+  }
+  const match = postUrl.match(BSKY_POST_URL_RE);
+  if (!match) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "Invalid Bluesky post URL"
+    });
+  }
+  const [, actor, rkey] = match;
+  let did = actor;
+  if (!actor.startsWith("did:")) {
+    const profile = await cachedProfileFetch(
+      `https://public.api.bsky.app/xrpc/app.bsky.actor.getProfile?actor=${encodeURIComponent(actor)}`
+    ).catch((error) => {
+      throw createError({
+        statusCode: error.statusCode || 500,
+        statusMessage: "Failed to resolve Bluesky handle"
+      });
+    });
+    did = profile.did;
+  }
+  const uri = `at://${did}/app.bsky.feed.post/${rkey}`;
+  const response = await cachedPostFetch(
+    `https://public.api.bsky.app/xrpc/app.bsky.feed.getPostThread?uri=${encodeURIComponent(uri)}&depth=0&parentHeight=0`
+  ).catch((error) => {
+    throw createError({
+      statusCode: error.statusCode || 500,
+      statusMessage: error.statusMessage || "Failed to fetch Bluesky post"
+    });
+  });
+  if (response.thread.$type !== "app.bsky.feed.defs#threadViewPost") {
+    throw createError({
+      statusCode: 404,
+      statusMessage: "Post not found"
+    });
+  }
+  const post = structuredClone(response.thread.post);
+  const hasOptOut = post.labels?.some((l) => l.val === "!no-unauthenticated") || post.author?.labels?.some((l) => l.val === "!no-unauthenticated");
+  if (hasOptOut) {
+    throw createError({
+      statusCode: 403,
+      statusMessage: "Author has opted out of external embedding"
+    });
+  }
+  const handlerPath = event.path?.split("?")[0] || "";
+  const prefix = handlerPath.replace(EMBED_BSKY_SUFFIX_RE, "") || "/_scripts";
+  const imagePath = `${prefix}/embed/bluesky-image`;
+  const secret = useRuntimeConfig(event)["nuxt-scripts"]?.proxySecret;
+  rewriteBlueskyPostImages(post, imagePath, secret);
+  setHeader(event, "Content-Type", "application/json");
+  setHeader(event, "Cache-Control", "public, max-age=600, s-maxage=600");
+  return post;
+}));

package/dist/runtime/server/google-maps-geocode-proxy.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<any>>;
+export default _default;

package/dist/runtime/server/google-maps-geocode-proxy.js

@@ -0,0 +1,38 @@
+import { createError, defineEventHandler, getQuery, setHeader } from "h3";
+import { useRuntimeConfig } from "nitropack/runtime";
+import { withQuery } from "ufo";
+import { createCachedJsonFetch } from "./utils/cached-upstream.js";
+import { withSigning } from "./utils/withSigning.js";
+const cachedGeocodeFetch = createCachedJsonFetch(
+  "nuxt-scripts-geocode",
+  2592e3,
+  (url) => url
+);
+export default withSigning(defineEventHandler(async (event) => {
+  const runtimeConfig = useRuntimeConfig();
+  const privateConfig = runtimeConfig["nuxt-scripts"]?.googleMapsGeocodeProxy;
+  const apiKey = privateConfig?.apiKey;
+  if (!apiKey) {
+    throw createError({
+      statusCode: 500,
+      statusMessage: "Google Maps API key not configured for geocode proxy"
+    });
+  }
+  const query = getQuery(event);
+  const { key: _clientKey, ...safeQuery } = query;
+  const geocodeUrl = withQuery("https://maps.googleapis.com/maps/api/geocode/json", {
+    ...safeQuery,
+    key: apiKey
+  });
+  const data = await cachedGeocodeFetch(geocodeUrl, {
+    headers: { "User-Agent": "Nuxt Scripts Google Geocode Proxy" }
+  }).catch((error) => {
+    throw createError({
+      statusCode: error.statusCode || 500,
+      statusMessage: error.statusMessage || "Failed to geocode"
+    });
+  });
+  setHeader(event, "Content-Type", "application/json");
+  setHeader(event, "Cache-Control", "public, max-age=86400, s-maxage=86400");
+  return data;
+}));

package/dist/runtime/server/google-static-maps-proxy.d.ts

@@ -1,2 +1,2 @@
-declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<any>>;
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<Buffer<ArrayBufferLike>>>;
 export default _default;

package/dist/runtime/server/google-static-maps-proxy.js

@@ -1,8 +1,12 @@
-import { createError, defineEventHandler, getHeader, getQuery, setHeader } from "h3";
-import { $fetch } from "ofetch";
+import { createError, defineEventHandler, getQuery, setHeader } from "h3";
+import { useRuntimeConfig } from "nitropack/runtime";
 import { withQuery } from "ufo";
-import { useRuntimeConfig } from "#imports";
-export default defineEventHandler(async (event) => {
+import { createCachedBinaryFetch } from "./utils/cached-upstream.js";
+import { PAGE_TOKEN_PARAM, PAGE_TOKEN_TS_PARAM, SIG_PARAM } from "./utils/sign-constants.js";
+import { withSigning } from "./utils/withSigning.js";
+const cachedMapFetch = createCachedBinaryFetch("nuxt-scripts-static-map", 604800);
+const STRIP_PARAMS = /* @__PURE__ */ new Set([SIG_PARAM, PAGE_TOKEN_PARAM, PAGE_TOKEN_TS_PARAM, "key"]);
+export default withSigning(defineEventHandler(async (event) => {
   const runtimeConfig = useRuntimeConfig();
   const publicConfig = runtimeConfig.public["nuxt-scripts"]?.googleStaticMapsProxy;
   const privateConfig = runtimeConfig["nuxt-scripts"]?.googleStaticMapsProxy;
@@ -19,27 +23,18 @@ export default defineEventHandler(async (event) => {
       statusMessage: "Google Maps API key not configured for proxy"
     });
   }
-  const referer = getHeader(event, "referer");
-  const host = getHeader(event, "host");
-  if (referer && host) {
-    const refererUrl = new URL(referer).host;
-    if (refererUrl !== host) {
-      throw createError({
-        statusCode: 403,
-        statusMessage: "Invalid referer"
-      });
-    }
-  }
   const query = getQuery(event);
-  const { key: _clientKey, ...safeQuery } = query;
+  const safeQuery = {};
+  for (const [k, v] of Object.entries(query)) {
+    if (!STRIP_PARAMS.has(k))
+      safeQuery[k] = v;
+  }
   const googleMapsUrl = withQuery("https://maps.googleapis.com/maps/api/staticmap", {
     ...safeQuery,
     key: apiKey
   });
-  const response = await $fetch.raw(googleMapsUrl, {
-    headers: {
-      "User-Agent": "Nuxt Scripts Google Static Maps Proxy"
-    }
+  const result = await cachedMapFetch(googleMapsUrl, {
+    headers: { "User-Agent": "Nuxt Scripts Google Static Maps Proxy" }
   }).catch((error) => {
     throw createError({
       statusCode: error.statusCode || 500,
@@ -47,8 +42,8 @@ export default defineEventHandler(async (event) => {
     });
   });
   const cacheMaxAge = publicConfig.cacheMaxAge || 3600;
-  setHeader(event, "Content-Type", response.headers.get("content-type") || "image/png");
+  setHeader(event, "Content-Type", result.contentType || "image/png");
   setHeader(event, "Cache-Control", `public, max-age=${cacheMaxAge}, s-maxage=${cacheMaxAge}`);
   setHeader(event, "Vary", "Accept-Encoding");
-  return response._data;
-});
+  return result.body;
+}));

package/dist/runtime/server/gravatar-proxy.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<Buffer<ArrayBufferLike>>>;
+export default _default;

package/dist/runtime/server/gravatar-proxy.js

@@ -0,0 +1,46 @@
+import { createError, defineEventHandler, getQuery, setHeader } from "h3";
+import { useRuntimeConfig } from "nitropack/runtime";
+import { withQuery } from "ufo";
+import { createCachedBinaryFetch } from "./utils/cached-upstream.js";
+import { withSigning } from "./utils/withSigning.js";
+const cachedGravatarFetch = createCachedBinaryFetch("nuxt-scripts-gravatar", 3600);
+export default withSigning(defineEventHandler(async (event) => {
+  const runtimeConfig = useRuntimeConfig();
+  const proxyConfig = runtimeConfig.public["nuxt-scripts"]?.gravatarProxy;
+  const query = getQuery(event);
+  let hash = query.hash;
+  const email = query.email;
+  if (!hash && email) {
+    const encoder = new TextEncoder();
+    const data = encoder.encode(email.trim().toLowerCase());
+    const hashBuffer = await crypto.subtle.digest("SHA-256", data);
+    hash = Array.from(new Uint8Array(hashBuffer), (b) => b.toString(16).padStart(2, "0")).join("");
+  }
+  if (!hash) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "Either hash or email parameter is required"
+    });
+  }
+  const size = query.s || "80";
+  const defaultImg = query.d || "mp";
+  const rating = query.r || "g";
+  const gravatarUrl = withQuery(`https://www.gravatar.com/avatar/${hash}`, {
+    s: size,
+    d: defaultImg,
+    r: rating
+  });
+  const result = await cachedGravatarFetch(gravatarUrl, {
+    headers: { "User-Agent": "Nuxt Scripts Gravatar Proxy" }
+  }).catch((error) => {
+    throw createError({
+      statusCode: error.statusCode || 500,
+      statusMessage: error.statusMessage || "Failed to fetch Gravatar avatar"
+    });
+  });
+  const cacheMaxAge = proxyConfig?.cacheMaxAge ?? 3600;
+  setHeader(event, "Content-Type", result.contentType || "image/jpeg");
+  setHeader(event, "Cache-Control", `public, max-age=${cacheMaxAge}, s-maxage=${cacheMaxAge}`);
+  setHeader(event, "Vary", "Accept-Encoding");
+  return result.body;
+}));

package/dist/runtime/server/instagram-embed-asset.d.ts

@@ -1,2 +1,2 @@
-declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<any>>;
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<Buffer<ArrayBufferLike>>>;
 export default _default;

package/dist/runtime/server/instagram-embed-asset.js

@@ -1,42 +1,9 @@
-import { createError, defineEventHandler, getQuery, setHeader } from "h3";
-import { $fetch } from "ofetch";
-export default defineEventHandler(async (event) => {
-  const query = getQuery(event);
-  const url = query.url?.replace(/&/g, "&");
-  if (!url) {
-    throw createError({
-      statusCode: 400,
-      statusMessage: "Asset URL is required"
-    });
-  }
-  let parsedUrl;
-  try {
-    parsedUrl = new URL(url);
-  } catch {
-    throw createError({
-      statusCode: 400,
-      statusMessage: "Invalid asset URL"
-    });
-  }
-  if (parsedUrl.hostname !== "static.cdninstagram.com") {
-    throw createError({
-      statusCode: 403,
-      statusMessage: "Domain not allowed"
-    });
-  }
-  const response = await $fetch.raw(url, {
-    headers: {
-      "Accept": "*/*",
-      "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36"
-    }
-  }).catch((error) => {
-    throw createError({
-      statusCode: error.statusCode || 500,
-      statusMessage: error.statusMessage || "Failed to fetch asset"
-    });
-  });
-  const contentType = response.headers.get("content-type") || "application/octet-stream";
-  setHeader(event, "Content-Type", contentType);
-  setHeader(event, "Cache-Control", "public, max-age=86400, s-maxage=86400");
-  return response._data;
+import { createImageProxyHandler } from "./utils/image-proxy.js";
+export default createImageProxyHandler({
+  allowedDomains: ["static.cdninstagram.com"],
+  accept: "*/*",
+  userAgent: "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36",
+  cacheMaxAge: 86400,
+  contentType: "application/octet-stream",
+  decodeAmpersands: true
 });

package/dist/runtime/server/instagram-embed-image.d.ts

@@ -1,2 +1,2 @@
-declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<any>>;
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<Buffer<ArrayBufferLike>>>;
 export default _default;

package/dist/runtime/server/instagram-embed-image.js

@@ -1,54 +1,7 @@
-import { createError, defineEventHandler, getQuery, setHeader } from "h3";
-import { $fetch } from "ofetch";
-export default defineEventHandler(async (event) => {
-  const query = getQuery(event);
-  const url = query.url?.replace(/&/g, "&");
-  if (!url) {
-    throw createError({
-      statusCode: 400,
-      statusMessage: "Image URL is required"
-    });
-  }
-  let parsedUrl;
-  try {
-    parsedUrl = new URL(url);
-  } catch {
-    throw createError({
-      statusCode: 400,
-      statusMessage: "Invalid image URL"
-    });
-  }
-  if (parsedUrl.protocol !== "http:" && parsedUrl.protocol !== "https:") {
-    throw createError({
-      statusCode: 400,
-      statusMessage: "Invalid URL scheme"
-    });
-  }
-  if (!parsedUrl.hostname.endsWith(".cdninstagram.com") && parsedUrl.hostname !== "scontent.cdninstagram.com") {
-    throw createError({
-      statusCode: 403,
-      statusMessage: "Domain not allowed"
-    });
-  }
-  const response = await $fetch.raw(url, {
-    redirect: "manual",
-    headers: {
-      "Accept": "image/webp,image/jpeg,image/png,image/*,*/*;q=0.8",
-      "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36"
-    }
-  }).catch((error) => {
-    throw createError({
-      statusCode: error.statusCode || 500,
-      statusMessage: error.statusMessage || "Failed to fetch image"
-    });
-  });
-  if (response.status >= 300 && response.status < 400) {
-    throw createError({
-      statusCode: 403,
-      statusMessage: "Redirects not allowed"
-    });
-  }
-  setHeader(event, "Content-Type", response.headers.get("content-type") || "image/jpeg");
-  setHeader(event, "Cache-Control", "public, max-age=3600, s-maxage=3600");
-  return response._data;
+import { createImageProxyHandler } from "./utils/image-proxy.js";
+export default createImageProxyHandler({
+  allowedDomains: (hostname) => hostname.endsWith(".cdninstagram.com") || hostname === "scontent.cdninstagram.com",
+  userAgent: "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36",
+  followRedirects: false,
+  decodeAmpersands: true
 });

package/dist/runtime/server/instagram-embed.d.ts

@@ -1,2 +1,3 @@
+export { proxyAssetUrl, proxyImageUrl, rewriteUrl, rewriteUrlsInText, scopeCss } from './utils/instagram-embed.js';
 declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<string>>;
 export default _default;

package/dist/runtime/server/instagram-embed.js

@@ -1,6 +1,33 @@
 import { createError, defineEventHandler, getQuery, setHeader } from "h3";
-import { $fetch } from "ofetch";
-export default defineEventHandler(async (event) => {
+import { useRuntimeConfig } from "nitropack/runtime";
+import { ELEMENT_NODE, parse, renderSync, TEXT_NODE, walkSync } from "ultrahtml";
+import { createCachedJsonFetch } from "./utils/cached-upstream.js";
+import { proxyAssetUrl, rewriteUrl, rewriteUrlsInText, RSRC_RE, scopeCss } from "./utils/instagram-embed.js";
+import { withSigning } from "./utils/withSigning.js";
+export { proxyAssetUrl, proxyImageUrl, rewriteUrl, rewriteUrlsInText, scopeCss } from "./utils/instagram-embed.js";
+const EMBED_INSTAGRAM_SUFFIX_RE = /\/embed\/instagram$/;
+const SRCSET_SPLIT_RE = /\s+/;
+const cachedEmbedFetch = createCachedJsonFetch(
+  "nuxt-scripts-instagram-embed",
+  600,
+  (url) => url
+);
+const cachedCssFetch = createCachedJsonFetch(
+  "nuxt-scripts-instagram-css",
+  86400,
+  (url) => url
+);
+function removeNode(node) {
+  node.type = TEXT_NODE;
+  node.value = "";
+  node.name = void 0;
+  node.attributes = {};
+  node.children = [];
+}
+export default withSigning(defineEventHandler(async (event) => {
+  const handlerPath = event.path?.split("?")[0] || "";
+  const prefix = handlerPath.replace(EMBED_INSTAGRAM_SUFFIX_RE, "") || "/_scripts";
+  const secret = useRuntimeConfig(event)["nuxt-scripts"]?.proxySecret;
   const query = getQuery(event);
   const postUrl = query.url;
   const captions = query.captions === "true";
@@ -27,11 +54,10 @@ export default defineEventHandler(async (event) => {
   }
   const pathname = parsedUrl.pathname.endsWith("/") ? parsedUrl.pathname : `${parsedUrl.pathname}/`;
   const cleanUrl = parsedUrl.origin + pathname;
-  const embedUrl = cleanUrl + "embed/" + (captions ? "captioned/" : "");
-  const html = await $fetch(embedUrl, {
+  const embedUrl = `${cleanUrl}embed/${captions ? "captioned/" : ""}`;
+  const html = await cachedEmbedFetch(embedUrl, {
     headers: {
       "Accept": "text/html",
-      // Use simple UA - full Chrome UA triggers JS-heavy version without static content
       "User-Agent": "Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)"
     }
   }).catch((error) => {
@@ -40,52 +66,68 @@ export default defineEventHandler(async (event) => {
       statusMessage: error.statusMessage || "Failed to fetch Instagram embed"
     });
   });
+  const ast = parse(html);
   const cssUrls = [];
-  const linkRegex = /<link[^>]+rel=["']stylesheet["'][^>]+href=["']([^"']+)["'][^>]*>/gi;
-  let match;
-  while ((match = linkRegex.exec(html)) !== null) {
-    if (match[1])
-      cssUrls.push(match[1]);
-  }
-  const linkRegex2 = /<link[^>]+href=["']([^"']+)["'][^>]+rel=["']stylesheet["'][^>]*>/gi;
-  while ((match = linkRegex2.exec(html)) !== null) {
-    if (match[1])
-      cssUrls.push(match[1]);
-  }
+  walkSync(ast, (node) => {
+    if (node.type !== ELEMENT_NODE)
+      return;
+    if (node.name === "link" && node.attributes.rel === "stylesheet" && node.attributes.href) {
+      cssUrls.push(node.attributes.href);
+      removeNode(node);
+      return;
+    }
+    if (node.name === "script" || node.name === "noscript" || node.name === "style") {
+      removeNode(node);
+      return;
+    }
+    for (const attr of ["src", "poster"]) {
+      if (node.attributes[attr])
+        node.attributes[attr] = rewriteUrl(node.attributes[attr], prefix, secret);
+    }
+    if (node.attributes.srcset) {
+      node.attributes.srcset = node.attributes.srcset.split(",").map((entry) => {
+        const parts = entry.trim().split(SRCSET_SPLIT_RE);
+        const url = parts[0];
+        const descriptor = parts.slice(1).join(" ");
+        return url ? `${rewriteUrl(url, prefix, secret)}${descriptor ? ` ${descriptor}` : ""}` : entry;
+      }).join(", ");
+    }
+    if (node.attributes.style)
+      node.attributes.style = rewriteUrlsInText(node.attributes.style, prefix, secret);
+  });
+  walkSync(ast, (node) => {
+    if (node.type === TEXT_NODE && node.value)
+      node.value = rewriteUrlsInText(node.value, prefix, secret);
+  });
+  let bodyNode = null;
+  walkSync(ast, (node) => {
+    if (node.type === ELEMENT_NODE && node.name === "body")
+      bodyNode = node;
+  });
+  const bodyHtml = bodyNode ? bodyNode.children.map((child) => renderSync(child)).join("") : renderSync(ast);
   const cssContents = await Promise.all(
     cssUrls.map(
-      (url) => $fetch(url, {
+      (url) => cachedCssFetch(url, {
         headers: { Accept: "text/css" }
       }).catch(() => "")
     )
   );
   let combinedCss = cssContents.join("\n");
   combinedCss = combinedCss.replace(
-    /url\(\/rsrc\.php([^)]+)\)/g,
-    (_m, path) => `url(/api/_scripts/instagram-embed-asset?url=${encodeURIComponent(`https://static.cdninstagram.com/rsrc.php${path}`)})`
+    RSRC_RE,
+    (_m, path) => `url(${proxyAssetUrl(`https://static.cdninstagram.com/rsrc.php${path}`, prefix, secret)})`
   );
+  combinedCss = rewriteUrlsInText(combinedCss, prefix, secret);
+  combinedCss = scopeCss(combinedCss, ".instagram-embed-root");
   const baseStyles = `
-    html { background: white; max-width: 540px; width: calc(100% - 2px); border-radius: 3px; border: 1px solid rgb(219, 219, 219); display: block; margin: 0px 0px 12px; min-width: 326px; padding: 0px; }
-    #splash-screen { display: none !important; }
-    .Embed { opacity: 1 !important; visibility: visible !important; }
-    .EmbeddedMedia, .EmbeddedMediaImage { display: block !important; visibility: visible !important; }
+    .instagram-embed-root { background: white; max-width: 540px; width: calc(100% - 2px); border-radius: 3px; border: 1px solid rgb(219, 219, 219); display: block; margin: 0px 0px 12px; min-width: 326px; padding: 0px; }
+    .instagram-embed-root #splash-screen { display: none !important; }
+    .instagram-embed-root .Embed { opacity: 1 !important; visibility: visible !important; }
+    .instagram-embed-root .EmbeddedMedia, .instagram-embed-root .EmbeddedMediaImage { display: block !important; visibility: visible !important; }
   `;
-  let rewrittenHtml = html.replace(/<script[\s\S]*?<\/script>/gi, "").replace(/<link[^>]+rel=["']stylesheet["'][^>]*>/gi, "").replace(/<link[^>]+href=["'][^"']+\.css[^"']*["'][^>]*>/gi, "").replace(/<noscript>[\s\S]*?<\/noscript>/gi, "").replace(
-    /https:\/\/scontent[^"'\s),]+\.cdninstagram\.com[^"'\s),]+/g,
-    (m) => `/api/_scripts/instagram-embed-image?url=${encodeURIComponent(m.replace(/&amp;/g, "&"))}`
-  ).replace(
-    /https:\/\/static\.cdninstagram\.com[^"'\s),]+/g,
-    (m) => `/api/_scripts/instagram-embed-asset?url=${encodeURIComponent(m.replace(/&amp;/g, "&"))}`
-  ).replace(
-    /https:\/\/lookaside\.instagram\.com[^"'\s),]+/g,
-    (m) => `/api/_scripts/instagram-embed-image?url=${encodeURIComponent(m.replace(/&amp;/g, "&"))}`
-  );
-  rewrittenHtml = rewrittenHtml.replace(
-    "</head>",
-    `<style>${baseStyles}
-${combinedCss}</style></head>`
-  );
+  const result = `<div class="instagram-embed-root"><style>${baseStyles}
+${combinedCss}</style>${bodyHtml}</div>`;
   setHeader(event, "Content-Type", "text/html");
   setHeader(event, "Cache-Control", "public, max-age=600, s-maxage=600");
-  return rewrittenHtml;
-});
+  return result;
+}));