@nuxt/scripts 1.0.0-beta.20 → 1.0.0-beta.22

package/dist/runtime/components/ScriptXEmbed.vue.d.ts

@@ -7,12 +7,12 @@ type __VLS_Props = {
     tweetId: string;
     /**
      * Custom API endpoint for fetching tweet data
-     * @default '/api/_scripts/x-embed'
+     * @default '/_scripts/embed/x'
      */
     apiEndpoint?: string;
     /**
      * Custom image proxy endpoint
-     * @default '/_scripts/x-embed-image'
+     * @default '/_scripts/embed/x-image'
      */
     imageProxyEndpoint?: string;
     /**

package/dist/runtime/registry/bluesky-embed.d.ts

@@ -0,0 +1,116 @@
+import type { RegistryScriptInput } from '#nuxt-scripts/types';
+import { BlueskyEmbedOptions } from './schemas.js';
+export { BlueskyEmbedOptions };
+export interface BlueskyEmbedPostData {
+    uri: string;
+    cid: string;
+    author: {
+        did: string;
+        handle: string;
+        displayName: string;
+        avatar: string;
+        labels: Array<{
+            val: string;
+        }>;
+        verification?: {
+            verifiedStatus: string;
+        };
+    };
+    record: {
+        $type: string;
+        createdAt: string;
+        text: string;
+        langs?: string[];
+        facets?: Array<{
+            features: Array<{
+                $type: string;
+                uri?: string;
+                did?: string;
+                tag?: string;
+            }>;
+            index: {
+                byteStart: number;
+                byteEnd: number;
+            };
+        }>;
+        embed?: {
+            $type: string;
+            images?: Array<{
+                alt: string;
+                image: {
+                    ref: {
+                        $link: string;
+                    };
+                    mimeType: string;
+                    size: number;
+                };
+                aspectRatio?: {
+                    width: number;
+                    height: number;
+                };
+            }>;
+            external?: {
+                uri: string;
+                title: string;
+                description: string;
+                thumb?: {
+                    ref: {
+                        $link: string;
+                    };
+                    mimeType: string;
+                    size: number;
+                };
+            };
+        };
+    };
+    embed?: {
+        $type: string;
+        images?: Array<{
+            thumb: string;
+            fullsize: string;
+            alt: string;
+            aspectRatio?: {
+                width: number;
+                height: number;
+            };
+        }>;
+        external?: {
+            uri: string;
+            title: string;
+            description: string;
+            thumb?: string;
+        };
+    };
+    likeCount: number;
+    repostCount: number;
+    replyCount: number;
+    quoteCount: number;
+    indexedAt: string;
+    labels: Array<{
+        val: string;
+    }>;
+}
+export type BlueskyEmbedInput = RegistryScriptInput<typeof BlueskyEmbedOptions, false, false, false>;
+/**
+ * Extract the handle/DID and post rkey from a Bluesky post URL
+ */
+export declare function extractBlueskyPostId(url: string): {
+    actor: string;
+    rkey: string;
+} | undefined;
+/**
+ * Proxy a Bluesky image URL through the server
+ */
+export declare function proxyBlueskyImageUrl(url: string, proxyEndpoint?: string): string;
+/**
+ * Format a Bluesky post date for display
+ */
+export declare function formatBlueskyDate(dateString: string): string;
+/**
+ * Format a number for display (e.g., 1234 -> 1.2K)
+ */
+export declare function formatCount(count: number): string;
+/**
+ * Convert Bluesky facets (byte-range rich text annotations) to HTML
+ */
+export declare function facetsToHtml(text: string, facets?: BlueskyEmbedPostData['record']['facets']): string;

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

@@ -0,0 +1,72 @@
+import { BlueskyEmbedOptions } from "./schemas.js";
+export { BlueskyEmbedOptions };
+const BSKY_POST_URL_RE = /bsky\.app\/profile\/([^/]+)\/post\/([^/?]+)/;
+export function extractBlueskyPostId(url) {
+  const match = url.match(BSKY_POST_URL_RE);
+  if (!match)
+    return void 0;
+  return { actor: match[1], rkey: match[2] };
+}
+export function proxyBlueskyImageUrl(url, proxyEndpoint = "/_scripts/embed/bluesky-image") {
+  const separator = proxyEndpoint.includes("?") ? "&" : "?";
+  return `${proxyEndpoint}${separator}url=${encodeURIComponent(url)}`;
+}
+export function formatBlueskyDate(dateString) {
+  const date = new Date(dateString);
+  const time = date.toLocaleString("en-US", {
+    hour: "numeric",
+    minute: "numeric",
+    hour12: true,
+    timeZone: "UTC"
+  });
+  const month = date.toLocaleString("en-US", { month: "short", timeZone: "UTC" });
+  return `${time} \xB7 ${month} ${date.getUTCDate()}, ${date.getUTCFullYear()}`;
+}
+export function formatCount(count) {
+  if (count >= 1e6) {
+    return `${(count / 1e6).toFixed(1)}M`;
+  }
+  if (count >= 1e3) {
+    return `${(count / 1e3).toFixed(1)}K`;
+  }
+  return count.toString();
+}
+export function facetsToHtml(text, facets) {
+  if (!facets?.length)
+    return escapeHtml(text);
+  const encoder = new TextEncoder();
+  const decoder = new TextDecoder();
+  const bytes = encoder.encode(text);
+  const sorted = facets.toSorted((a, b) => a.index.byteStart - b.index.byteStart);
+  const parts = [];
+  let lastEnd = 0;
+  for (const facet of sorted) {
+    if (facet.index.byteStart > lastEnd) {
+      parts.push(escapeHtml(decoder.decode(bytes.slice(lastEnd, facet.index.byteStart))));
+    }
+    const facetText = escapeHtml(decoder.decode(bytes.slice(facet.index.byteStart, facet.index.byteEnd)));
+    for (const feature of facet.features) {
+      if (feature.$type === "app.bsky.richtext.facet#link" && feature.uri) {
+        parts.push(`<a href="${escapeHtml(feature.uri)}" target="_blank" rel="noopener noreferrer">${facetText}</a>`);
+      } else if (feature.$type === "app.bsky.richtext.facet#mention" && feature.did) {
+        parts.push(`<a href="https://bsky.app/profile/${escapeHtml(feature.did)}" target="_blank" rel="noopener noreferrer">${facetText}</a>`);
+      } else if (feature.$type === "app.bsky.richtext.facet#tag" && feature.tag) {
+        parts.push(`<a href="https://bsky.app/hashtag/${escapeHtml(feature.tag)}" target="_blank" rel="noopener noreferrer">${facetText}</a>`);
+      } else {
+        parts.push(facetText);
+      }
+    }
+    lastEnd = facet.index.byteEnd;
+  }
+  if (lastEnd < bytes.length) {
+    parts.push(escapeHtml(decoder.decode(bytes.slice(lastEnd))));
+  }
+  return parts.join("");
+}
+const AMP_RE = /&/g;
+const LT_RE = /</g;
+const GT_RE = />/g;
+const QUOT_RE = /"/g;
+function escapeHtml(str) {
+  return str.replace(AMP_RE, "&amp;").replace(LT_RE, "&lt;").replace(GT_RE, "&gt;").replace(QUOT_RE, "&quot;");
+}

package/dist/runtime/registry/gravatar.js

@@ -20,10 +20,10 @@ export function useScriptGravatar(_options) {
       scriptOptions: {
         use: () => ({
           getAvatarUrl: (hash, overrides) => {
-            return `/_scripts/gravatar-proxy?hash=${encodeURIComponent(hash)}&${buildQuery(overrides)}`;
+            return `/_scripts/proxy/gravatar?hash=${encodeURIComponent(hash)}&${buildQuery(overrides)}`;
           },
           getAvatarUrlFromEmail: (email, overrides) => {
-            return `/_scripts/gravatar-proxy?email=${encodeURIComponent(email)}&${buildQuery(overrides)}`;
+            return `/_scripts/proxy/gravatar?email=${encodeURIComponent(email)}&${buildQuery(overrides)}`;
           }
         })
       }

package/dist/runtime/registry/schemas.d.ts

@@ -1,3 +1,20 @@
+export declare const BlueskyEmbedOptions: import("valibot").ObjectSchema<{
+    /**
+     * The Bluesky post URL to embed.
+     * @example 'https://bsky.app/profile/bsky.app/post/3mgnwwvj3u22a'
+     */
+    readonly postUrl: import("valibot").StringSchema<undefined>;
+    /**
+     * Custom API endpoint for fetching post data.
+     * @default '/_scripts/embed/bluesky'
+     */
+    readonly apiEndpoint: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+    /**
+     * Custom image proxy endpoint.
+     * @default '/_scripts/embed/bluesky-image'
+     */
+    readonly imageProxyEndpoint: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+}, undefined>;
 export declare const ClarityOptions: import("valibot").ObjectSchema<{
     /**
      * The Clarity token.
@@ -433,7 +450,7 @@ export declare const InstagramEmbedOptions: import("valibot").ObjectSchema<{
     readonly captions: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
     /**
      * Custom API endpoint for fetching embed HTML.
-     * @default '/api/_scripts/instagram-embed'
+     * @default '/_scripts/embed/instagram'
      */
     readonly apiEndpoint: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
 }, undefined>;
@@ -871,12 +888,12 @@ export declare const XEmbedOptions: import("valibot").ObjectSchema<{
     readonly tweetId: import("valibot").StringSchema<undefined>;
     /**
      * Optional: Custom API endpoint for fetching tweet data.
-     * @default '/api/_scripts/x-embed'
+     * @default '/_scripts/embed/x'
      */
     readonly apiEndpoint: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
     /**
      * Optional: Custom image proxy endpoint.
-     * @default '/api/_scripts/x-embed-image'
+     * @default '/_scripts/embed/x-image'
      */
     readonly imageProxyEndpoint: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
 }, undefined>;

package/dist/runtime/registry/schemas.js

@@ -1,4 +1,21 @@
 import { any, array, boolean, custom, literal, minLength, number, object, optional, pipe, record, string, union } from "#nuxt-scripts-validator";
+export const BlueskyEmbedOptions = object({
+  /**
+   * The Bluesky post URL to embed.
+   * @example 'https://bsky.app/profile/bsky.app/post/3mgnwwvj3u22a'
+   */
+  postUrl: string(),
+  /**
+   * Custom API endpoint for fetching post data.
+   * @default '/_scripts/embed/bluesky'
+   */
+  apiEndpoint: optional(string()),
+  /**
+   * Custom image proxy endpoint.
+   * @default '/_scripts/embed/bluesky-image'
+   */
+  imageProxyEndpoint: optional(string())
+});
 export const ClarityOptions = object({
   /**
    * The Clarity token.
@@ -428,7 +445,7 @@ export const InstagramEmbedOptions = object({
   captions: optional(boolean()),
   /**
    * Custom API endpoint for fetching embed HTML.
-   * @default '/api/_scripts/instagram-embed'
+   * @default '/_scripts/embed/instagram'
    */
   apiEndpoint: optional(string())
 });
@@ -826,12 +843,12 @@ export const XEmbedOptions = object({
   tweetId: string(),
   /**
    * Optional: Custom API endpoint for fetching tweet data.
-   * @default '/api/_scripts/x-embed'
+   * @default '/_scripts/embed/x'
    */
   apiEndpoint: optional(string()),
   /**
    * Optional: Custom image proxy endpoint.
-   * @default '/api/_scripts/x-embed-image'
+   * @default '/_scripts/embed/x-image'
    */
   imageProxyEndpoint: optional(string())
 });

package/dist/runtime/registry/x-embed.js

@@ -1,6 +1,6 @@
 import { XEmbedOptions } from "./schemas.js";
 export { XEmbedOptions };
-export function proxyXImageUrl(url, proxyEndpoint = "/api/_scripts/x-embed-image") {
+export function proxyXImageUrl(url, proxyEndpoint = "/_scripts/embed/x-image") {
   const separator = proxyEndpoint.includes("?") ? "&" : "?";
   return `${proxyEndpoint}${separator}url=${encodeURIComponent(url)}`;
 }

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

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

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

@@ -0,0 +1,7 @@
+import { createImageProxyHandler } from "./utils/image-proxy.js";
+export default createImageProxyHandler({
+  allowedDomains: [
+    "cdn.bsky.app",
+    "av-cdn.bsky.app"
+  ]
+});

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

@@ -0,0 +1,16 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
+    uri: string;
+    cid: string;
+    author: Record<string, any>;
+    record: Record<string, any>;
+    embed?: Record<string, any>;
+    likeCount: number;
+    repostCount: number;
+    replyCount: number;
+    quoteCount: number;
+    indexedAt: string;
+    labels: Array<{
+        val: string;
+    }>;
+}>>;
+export default _default;

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

@@ -0,0 +1,59 @@
+import { createError, defineEventHandler, getQuery, setHeader } from "h3";
+import { $fetch } from "ofetch";
+const BSKY_POST_URL_RE = /^https:\/\/bsky\.app\/profile\/([^/]+)\/post\/([^/?]+)$/;
+export default 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 $fetch(
+      `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 $fetch(
+    `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 = 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"
+    });
+  }
+  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,34 @@
+import { useRuntimeConfig } from "#imports";
+import { createError, defineEventHandler, getQuery, setHeader } from "h3";
+import { $fetch } from "ofetch";
+import { withQuery } from "ufo";
+export default 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 $fetch(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.js

@@ -1,5 +1,5 @@
 import { useRuntimeConfig } from "#imports";
-import { createError, defineEventHandler, getHeader, getQuery, setHeader } from "h3";
+import { createError, defineEventHandler, getQuery, setHeader } from "h3";
 import { $fetch } from "ofetch";
 import { withQuery } from "ufo";
 export default defineEventHandler(async (event) => {
@@ -19,17 +19,6 @@ 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 googleMapsUrl = withQuery("https://maps.googleapis.com/maps/api/staticmap", {

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

@@ -1,25 +1,10 @@
 import { useRuntimeConfig } from "#imports";
-import { createError, defineEventHandler, getHeader, getQuery, setHeader } from "h3";
+import { createError, defineEventHandler, getQuery, setHeader } from "h3";
 import { $fetch } from "ofetch";
 import { withQuery } from "ufo";
 export default defineEventHandler(async (event) => {
   const runtimeConfig = useRuntimeConfig();
   const proxyConfig = runtimeConfig.public["nuxt-scripts"]?.gravatarProxy;
-  const referer = getHeader(event, "referer");
-  const host = getHeader(event, "host");
-  if (referer && host) {
-    let refererHost;
-    try {
-      refererHost = new URL(referer).host;
-    } catch {
-    }
-    if (refererHost && refererHost !== host) {
-      throw createError({
-        statusCode: 403,
-        statusMessage: "Invalid referer"
-      });
-    }
-  }
   const query = getQuery(event);
   let hash = query.hash;
   const email = query.email;

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

@@ -1,43 +1,9 @@
-import { createError, defineEventHandler, getQuery, setHeader } from "h3";
-import { $fetch } from "ofetch";
-const AMP_RE = /&/g;
-export default defineEventHandler(async (event) => {
-  const query = getQuery(event);
-  const url = query.url?.replace(AMP_RE, "&");
-  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.js

@@ -1,55 +1,7 @@
-import { createError, defineEventHandler, getQuery, setHeader } from "h3";
-import { $fetch } from "ofetch";
-const AMP_RE = /&/g;
-export default defineEventHandler(async (event) => {
-  const query = getQuery(event);
-  const url = query.url?.replace(AMP_RE, "&");
-  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,18 @@
+export declare const RSRC_RE: RegExp;
+export declare const AMP_RE: RegExp;
+export declare const SCONTENT_RE: RegExp;
+export declare const STATIC_CDN_RE: RegExp;
+export declare const LOOKASIDE_RE: RegExp;
+export declare const INSTAGRAM_IMAGE_HOSTS: string[];
+export declare const INSTAGRAM_ASSET_HOST = "static.cdninstagram.com";
+export declare function proxyImageUrl(url: string): string;
+export declare function proxyAssetUrl(url: string): string;
+export declare function rewriteUrl(url: string): string;
+export declare function rewriteUrlsInText(text: string): string;
+/**
+ * Scope CSS rules under a parent selector and strip global/page-level rules.
+ * Removes :root, html, body selectors and @charset/@import at-rules.
+ */
+export declare function scopeCss(css: string, scopeSelector: string): string;
 declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<string>>;
 export default _default;