@uniweb/runtime 0.6.13 → 0.6.15

package/dist/ssr.js

@@ -1,5 +1,7 @@
-import React, { useState, useEffect } from "react";
-import { jsxs, jsx, Fragment } from "react/jsx-runtime";
+import React from "react";
+import { renderToString } from "react-dom/server";
+import { createUniweb } from "@uniweb/core";
+import { buildSectionOverrides } from "@uniweb/theming";
 function guaranteeItemStructure(item) {
   return {
     title: item.title || "",
@@ -124,85 +126,31 @@ function getComponentMeta(componentName) {
 function getComponentDefaults(componentName) {
   return globalThis.uniweb?.getComponentDefaults?.(componentName) || {};
 }
-const MODES = {
-  COLOR: "color",
-  GRADIENT: "gradient",
-  IMAGE: "image",
-  VIDEO: "video"
-};
-function resolveUrl(url) {
-  if (!url || !url.startsWith("/")) return url;
-  const basePath = globalThis.uniweb?.activeWebsite?.basePath || "";
-  if (!basePath) return url;
-  if (url.startsWith(basePath + "/") || url === basePath) return url;
-  return basePath + url;
-}
-function GradientOverlay({ gradient, opacity = 0.5 }) {
-  const {
-    start = "rgba(0,0,0,0.7)",
-    end = "rgba(0,0,0,0)",
-    angle = 180,
-    startPosition = 0,
-    endPosition = 100
-  } = gradient;
-  const style = {
-    position: "absolute",
-    inset: 0,
-    background: `linear-gradient(${angle}deg, ${start} ${startPosition}%, ${end} ${endPosition}%)`,
-    opacity,
-    pointerEvents: "none"
-  };
-  return /* @__PURE__ */ jsx("div", { className: "background-overlay background-overlay--gradient", style, "aria-hidden": "true" });
-}
-function SolidOverlay({ type = "dark", opacity = 0.5 }) {
-  const baseColor = type === "light" ? "255, 255, 255" : "0, 0, 0";
-  const style = {
-    position: "absolute",
-    inset: 0,
-    backgroundColor: `rgba(${baseColor}, ${opacity})`,
-    pointerEvents: "none"
-  };
-  return /* @__PURE__ */ jsx("div", { className: "background-overlay background-overlay--solid", style, "aria-hidden": "true" });
-}
-function Overlay({ overlay }) {
-  if (!overlay?.enabled) return null;
-  if (overlay.gradient) {
-    return /* @__PURE__ */ jsx(GradientOverlay, { gradient: overlay.gradient, opacity: overlay.opacity });
+const VALID_CONTEXTS = ["light", "medium", "dark"];
+function getWrapperProps(block) {
+  const theme = block.themeName;
+  const blockClassName = block.state?.className || "";
+  let contextClass = "";
+  if (theme && VALID_CONTEXTS.includes(theme)) {
+    contextClass = `context-${theme}`;
   }
-  return /* @__PURE__ */ jsx(SolidOverlay, { type: overlay.type, opacity: overlay.opacity });
-}
-function ColorBackground({ color }) {
-  if (!color) return null;
-  const style = {
-    position: "absolute",
-    inset: 0,
-    backgroundColor: color
-  };
-  return /* @__PURE__ */ jsx("div", { className: "background-color", style, "aria-hidden": "true" });
-}
-function GradientBackground({ gradient }) {
-  if (!gradient) return null;
-  if (typeof gradient === "string") {
-    const style2 = { position: "absolute", inset: 0, background: gradient };
-    return /* @__PURE__ */ jsx("div", { className: "background-gradient", style: style2, "aria-hidden": "true" });
-  }
-  const {
-    start = "transparent",
-    end = "transparent",
-    angle = 0,
-    startPosition = 0,
-    endPosition = 100,
-    startOpacity = 1,
-    endOpacity = 1
-  } = gradient;
-  const startColor = startOpacity < 1 ? withOpacity(start, startOpacity) : start;
-  const endColor = endOpacity < 1 ? withOpacity(end, endOpacity) : end;
-  const style = {
-    position: "absolute",
-    inset: 0,
-    background: `linear-gradient(${angle}deg, ${startColor} ${startPosition}%, ${endColor} ${endPosition}%)`
-  };
-  return /* @__PURE__ */ jsx("div", { className: "background-gradient", style, "aria-hidden": "true" });
+  let className = contextClass;
+  if (blockClassName) {
+    className = className ? `${className} ${blockClassName}` : blockClassName;
+  }
+  const { background = {} } = block.standardOptions;
+  const style = {};
+  if (background.mode) {
+    style.position = "relative";
+    style.isolation = "isolate";
+  }
+  if (block.contextOverrides) {
+    for (const [key, value] of Object.entries(block.contextOverrides)) {
+      style[`--${key}`] = value;
+    }
+  }
+  const sectionId = block.stableId || block.id;
+  return { id: `section-${sectionId}`, style, className, background };
 }
 function withOpacity(color, opacity) {
   if (color.startsWith("#")) {
@@ -219,192 +167,143 @@ function withOpacity(color, opacity) {
   }
   return color;
 }
-function ImageBackground({ image }) {
-  if (!image?.src) return null;
-  const {
-    src,
-    position = "center",
-    size = "cover",
-    lazy = true
-  } = image;
-  const style = {
-    position: "absolute",
-    inset: 0,
-    backgroundImage: `url(${resolveUrl(src)})`,
-    backgroundPosition: position,
-    backgroundSize: size,
-    backgroundRepeat: "no-repeat"
-  };
-  return /* @__PURE__ */ jsx("div", { className: "background-image", style, "aria-hidden": "true" });
-}
-function prefersReducedMotion() {
-  if (typeof window === "undefined") return false;
-  return window.matchMedia("(prefers-reduced-motion: reduce)").matches;
-}
-function VideoBackground({ video }) {
-  if (!video?.src) return null;
-  const {
-    src,
-    sources,
-    // Array of { src, type } for multiple formats
-    poster,
-    loop = true,
-    muted = true
-  } = video;
-  if (prefersReducedMotion() && poster) {
-    return /* @__PURE__ */ jsx(ImageBackground, { image: { src: poster, size: "cover", position: "center" } });
-  }
-  const style = {
-    position: "absolute",
-    inset: 0,
-    width: "100%",
-    height: "100%",
-    objectFit: "cover"
-  };
-  const sourceList = (sources || inferSources(src)).map((s) => ({
-    ...s,
-    src: resolveUrl(s.src)
-  }));
-  return /* @__PURE__ */ jsx(
-    "video",
-    {
-      className: "background-video",
-      style,
-      autoPlay: true,
-      loop,
-      muted,
-      playsInline: true,
-      poster: resolveUrl(poster),
-      "aria-hidden": "true",
-      children: sourceList.map(({ src: sourceSrc, type }, index) => /* @__PURE__ */ jsx("source", { src: sourceSrc, type }, index))
-    }
-  );
-}
-function inferSources(src) {
-  const sources = [];
-  const ext = src.split(".").pop()?.toLowerCase();
-  const basePath = src.slice(0, src.lastIndexOf("."));
-  if (ext === "mp4") {
-    sources.push({ src: `${basePath}.webm`, type: "video/webm" });
-    sources.push({ src, type: "video/mp4" });
-  } else if (ext === "webm") {
-    sources.push({ src, type: "video/webm" });
-    sources.push({ src: `${basePath}.mp4`, type: "video/mp4" });
-  } else {
-    sources.push({ src, type: getVideoMimeType(src) });
-  }
-  return sources;
-}
-function getVideoMimeType(src) {
-  if (src.endsWith(".webm")) return "video/webm";
-  if (src.endsWith(".ogg") || src.endsWith(".ogv")) return "video/ogg";
-  return "video/mp4";
+function resolveUrl(url) {
+  if (!url || !url.startsWith("/")) return url;
+  const basePath = globalThis.uniweb?.activeWebsite?.basePath || "";
+  if (!basePath) return url;
+  if (url.startsWith(basePath + "/") || url === basePath) return url;
+  return basePath + url;
 }
-function Background({
-  mode,
-  color,
-  gradient,
-  image,
-  video,
-  overlay,
-  className = ""
-}) {
-  if (!mode) return null;
+function renderBackground(background) {
+  if (!background?.mode) return null;
   const containerStyle = {
     position: "absolute",
-    inset: 0,
+    inset: "0",
     overflow: "hidden",
     zIndex: 0
   };
-  return /* @__PURE__ */ jsxs(
-    "div",
-    {
-      className: `background background--${mode} ${className}`.trim(),
-      style: containerStyle,
-      "aria-hidden": "true",
-      children: [
-        mode === MODES.COLOR && /* @__PURE__ */ jsx(ColorBackground, { color }),
-        mode === MODES.GRADIENT && /* @__PURE__ */ jsx(GradientBackground, { gradient }),
-        mode === MODES.IMAGE && /* @__PURE__ */ jsx(ImageBackground, { image }),
-        mode === MODES.VIDEO && /* @__PURE__ */ jsx(VideoBackground, { video }),
-        /* @__PURE__ */ jsx(Overlay, { overlay })
-      ]
-    }
-  );
-}
-const VALID_CONTEXTS = ["light", "medium", "dark"];
-const getWrapperProps = (block) => {
-  const theme = block.themeName;
-  const blockClassName = block.state?.className || "";
-  let contextClass = "";
-  if (theme && VALID_CONTEXTS.includes(theme)) {
-    contextClass = `context-${theme}`;
+  const children = [];
+  if (background.mode === "color" && background.color) {
+    children.push(
+      React.createElement("div", {
+        key: "bg-color",
+        className: "background-color",
+        style: { position: "absolute", inset: "0", backgroundColor: background.color },
+        "aria-hidden": "true"
+      })
+    );
   }
-  let className = contextClass;
-  if (blockClassName) {
-    className = className ? `${className} ${blockClassName}` : blockClassName;
+  if (background.mode === "gradient" && background.gradient) {
+    const g = background.gradient;
+    let bgValue;
+    if (typeof g === "string") {
+      bgValue = g;
+    } else {
+      const {
+        start = "transparent",
+        end = "transparent",
+        angle = 0,
+        startPosition = 0,
+        endPosition = 100,
+        startOpacity = 1,
+        endOpacity = 1
+      } = g;
+      const startColor = startOpacity < 1 ? withOpacity(start, startOpacity) : start;
+      const endColor = endOpacity < 1 ? withOpacity(end, endOpacity) : end;
+      bgValue = `linear-gradient(${angle}deg, ${startColor} ${startPosition}%, ${endColor} ${endPosition}%)`;
+    }
+    children.push(
+      React.createElement("div", {
+        key: "bg-gradient",
+        className: "background-gradient",
+        style: { position: "absolute", inset: "0", background: bgValue },
+        "aria-hidden": "true"
+      })
+    );
   }
-  const { background = {} } = block.standardOptions;
-  const style = {};
-  if (background.mode) {
-    style.position = "relative";
-    style.isolation = "isolate";
+  if (background.mode === "image" && background.image?.src) {
+    const img = background.image;
+    children.push(
+      React.createElement("div", {
+        key: "bg-image",
+        className: "background-image",
+        style: {
+          position: "absolute",
+          inset: "0",
+          backgroundImage: `url(${resolveUrl(img.src)})`,
+          backgroundPosition: img.position || "center",
+          backgroundSize: img.size || "cover",
+          backgroundRepeat: "no-repeat"
+        },
+        "aria-hidden": "true"
+      })
+    );
   }
-  if (block.contextOverrides) {
-    for (const [key, value] of Object.entries(block.contextOverrides)) {
-      style[`--${key}`] = value;
+  if (background.overlay?.enabled) {
+    const ov = background.overlay;
+    let overlayStyle;
+    if (ov.gradient) {
+      const g = ov.gradient;
+      overlayStyle = {
+        position: "absolute",
+        inset: "0",
+        pointerEvents: "none",
+        background: `linear-gradient(${g.angle || 180}deg, ${g.start || "rgba(0,0,0,0.7)"} ${g.startPosition || 0}%, ${g.end || "rgba(0,0,0,0)"} ${g.endPosition || 100}%)`,
+        opacity: ov.opacity ?? 0.5
+      };
+    } else {
+      const baseColor = ov.type === "light" ? "255, 255, 255" : "0, 0, 0";
+      overlayStyle = {
+        position: "absolute",
+        inset: "0",
+        pointerEvents: "none",
+        backgroundColor: `rgba(${baseColor}, ${ov.opacity ?? 0.5})`
+      };
     }
+    children.push(
+      React.createElement("div", {
+        key: "bg-overlay",
+        className: ov.gradient ? "background-overlay background-overlay--gradient" : "background-overlay background-overlay--solid",
+        style: overlayStyle,
+        "aria-hidden": "true"
+      })
+    );
   }
-  const sectionId = block.stableId || block.id;
-  return {
-    id: `section-${sectionId}`,
-    style,
-    className,
-    background
-  };
-};
-function BlockRenderer({ block, pure = false, as = "section", extra = {} }) {
+  if (children.length === 0) return null;
+  return React.createElement("div", {
+    className: `background background--${background.mode}`,
+    style: containerStyle,
+    "aria-hidden": "true"
+  }, ...children);
+}
+function renderBlock(block, { pure = false, as = void 0 } = {}) {
   const Component = block.initComponent();
-  const entityStore = block.website.entityStore;
-  const meta = getComponentMeta(block.type);
-  const resolved = entityStore.resolve(block, meta);
-  const [asyncData, setAsyncData] = useState(null);
-  useEffect(() => {
-    setAsyncData(null);
-  }, [block]);
-  useEffect(() => {
-    if (resolved.status !== "pending") return;
-    let cancelled = false;
-    entityStore.fetch(block, meta).then((result) => {
-      if (!cancelled && result.data) setAsyncData(result.data);
-    });
-    return () => {
-      cancelled = true;
-    };
-  }, [block]);
-  const entityData = resolved.status === "ready" ? resolved.data : asyncData;
-  block.dataLoading = resolved.status === "pending" && !entityData;
   if (!Component) {
-    return /* @__PURE__ */ jsxs("div", { className: "block-error", style: { padding: "1rem", background: "#fef2f2", color: "#dc2626" }, children: [
-      "Component not found: ",
-      block.type
-    ] });
+    return React.createElement("div", {
+      className: "block-error",
+      style: { padding: "1rem", background: "#fef2f2", color: "#dc2626" }
+    }, `Component not found: ${block.type}`);
   }
+  const meta = getComponentMeta(block.type);
   const prepared = prepareProps(block, meta);
-  let params = prepared.params;
-  let content = {
-    ...prepared.content,
-    ...block.properties
-    // Frontmatter params overlay (legacy support)
-  };
-  if (entityData) {
-    const merged = { ...content.data };
-    for (const key of Object.keys(entityData)) {
-      if (merged[key] === void 0) {
-        merged[key] = entityData[key];
+  const params = prepared.params;
+  const content = { ...prepared.content, ...block.properties };
+  const entityStore = block.website?.entityStore;
+  if (entityStore) {
+    const resolved = entityStore.resolve(block, meta);
+    if (resolved.status === "ready" && resolved.data) {
+      const merged = { ...content.data };
+      for (const key of Object.keys(resolved.data)) {
+        if (merged[key] === void 0) {
+          merged[key] = resolved.data[key];
+        }
       }
+      content.data = merged;
     }
-    content.data = merged;
+  }
+  const componentProps = { content, params, block };
+  if (pure) {
+    return React.createElement(Component, componentProps);
   }
   const { background, ...wrapperProps } = getWrapperProps(block);
   const componentClassName = Component.className;
@@ -413,109 +312,202 @@ function BlockRenderer({ block, pure = false, as = "section", extra = {} }) {
   }
   const hasBackground = background?.mode && meta?.background !== "self";
   block.hasBackground = hasBackground;
-  const componentProps = {
-    content,
-    params,
-    block
-  };
-  if (pure) {
-    return /* @__PURE__ */ jsx(Component, { ...componentProps, extra });
-  }
-  const componentAs = Component.as;
-  const Wrapper = as === false ? React.Fragment : as !== "section" ? as : componentAs || "section";
-  const wrapperElementProps = as === false ? {} : wrapperProps;
+  const wrapperTag = as !== void 0 && as !== "section" ? as : Component.as || "section";
   if (hasBackground) {
-    return /* @__PURE__ */ jsxs(Wrapper, { ...wrapperElementProps, children: [
-      /* @__PURE__ */ jsx(
-        Background,
-        {
-          mode: background.mode,
-          color: background.color,
-          gradient: background.gradient,
-          image: background.image,
-          video: background.video,
-          overlay: background.overlay
-        }
-      ),
-      /* @__PURE__ */ jsx("div", { style: { position: "relative", zIndex: 10 }, children: /* @__PURE__ */ jsx(Component, { ...componentProps }) })
-    ] });
+    return React.createElement(
+      wrapperTag,
+      wrapperProps,
+      renderBackground(background),
+      React.createElement(
+        "div",
+        { style: { position: "relative", zIndex: 10 } },
+        React.createElement(Component, componentProps)
+      )
+    );
   }
-  return /* @__PURE__ */ jsx(Wrapper, { ...wrapperElementProps, children: /* @__PURE__ */ jsx(Component, { ...componentProps }) });
+  return React.createElement(
+    wrapperTag,
+    wrapperProps,
+    React.createElement(Component, componentProps)
+  );
 }
-function Blocks({ blocks, extra = {} }) {
+function renderBlocks(blocks) {
   if (!blocks || blocks.length === 0) return null;
-  return blocks.map((block, index) => /* @__PURE__ */ jsx(React.Fragment, { children: /* @__PURE__ */ jsx(BlockRenderer, { block, extra }) }, block.id || index));
-}
-function DefaultLayout({ header, body, footer }) {
-  return /* @__PURE__ */ jsxs(Fragment, { children: [
-    header && /* @__PURE__ */ jsx("header", { children: header }),
-    body && /* @__PURE__ */ jsx("main", { children: body }),
-    footer && /* @__PURE__ */ jsx("footer", { children: footer })
-  ] });
-}
-function initializeAllBlocks(...blockGroups) {
-  for (const blocks of blockGroups) {
-    if (!blocks) continue;
-    for (const block of blocks) {
-      block.initComponent();
-    }
-  }
-}
-function mergeParams(pageParams = {}, defaults = {}) {
-  return { ...defaults, ...pageParams };
+  return blocks.map(
+    (block, index) => React.createElement(
+      React.Fragment,
+      { key: block.id || index },
+      renderBlock(block)
+    )
+  );
 }
-function Layout({ page, website }) {
+function renderLayout(page, website) {
   const layoutName = page.getLayoutName();
   const RemoteLayout = website.getRemoteLayout(layoutName);
   const layoutMeta = website.getLayoutMeta(layoutName);
   const bodyBlocks = page.getBodyBlocks();
   const areas = page.getLayoutAreas();
-  const allBlockGroups = [bodyBlocks, ...Object.values(areas)];
-  initializeAllBlocks(...allBlockGroups);
-  const bodyElement = bodyBlocks ? /* @__PURE__ */ jsx(Blocks, { blocks: bodyBlocks }) : null;
+  const bodyElement = bodyBlocks ? renderBlocks(bodyBlocks) : null;
   const areaElements = {};
   for (const [name, blocks] of Object.entries(areas)) {
-    areaElements[name] = /* @__PURE__ */ jsx(Blocks, { blocks });
+    areaElements[name] = renderBlocks(blocks);
   }
   if (RemoteLayout) {
-    const params = mergeParams(page.getLayoutParams(), layoutMeta?.defaults);
-    return /* @__PURE__ */ jsx(
-      RemoteLayout,
-      {
-        page,
-        website,
-        params,
-        body: bodyElement,
-        ...areaElements
-      },
-      layoutName
-    );
-  }
-  return /* @__PURE__ */ jsx(
-    DefaultLayout,
-    {
+    const params = { ...layoutMeta?.defaults || {}, ...page.getLayoutParams() || {} };
+    return React.createElement(RemoteLayout, {
+      page,
+      website,
+      params,
       body: bodyElement,
       ...areaElements
-    }
-  );
-}
-function PageElement({ page, website }) {
+    });
+  }
   return React.createElement(
-    "main",
+    React.Fragment,
     null,
-    React.createElement(Layout, { page, website })
+    areaElements.header && React.createElement("header", null, areaElements.header),
+    bodyElement && React.createElement("main", null, bodyElement),
+    areaElements.footer && React.createElement("footer", null, areaElements.footer)
+  );
+}
+function initPrerender(content, foundation, options = {}) {
+  const { onProgress = () => {
+  } } = options;
+  onProgress("Initializing runtime...");
+  const uniweb = createUniweb(content);
+  uniweb.setFoundation(foundation);
+  if (foundation.default?.capabilities) {
+    uniweb.setFoundationConfig(foundation.default.capabilities);
+  }
+  if (foundation.default?.layoutMeta && uniweb.foundationConfig) {
+    uniweb.foundationConfig.layoutMeta = foundation.default.layoutMeta;
+  }
+  if (content.config?.base && uniweb.activeWebsite?.setBasePath) {
+    uniweb.activeWebsite.setBasePath(content.config.base);
+  }
+  uniweb.childBlockRenderer = function InlineChildBlocks({ blocks, from, pure = false, as = "div" }) {
+    const blockList = blocks || from?.childBlocks || [];
+    return blockList.map(
+      (childBlock, index) => React.createElement(
+        React.Fragment,
+        { key: childBlock.id || index },
+        renderBlock(childBlock, { pure, as })
+      )
+    );
+  };
+  return uniweb;
+}
+async function prefetchIcons(siteContent, uniweb, onProgress = () => {
+}) {
+  const icons = siteContent.icons?.used || [];
+  if (icons.length === 0) return;
+  const cdnBase = siteContent.config?.icons?.cdnUrl || "https://uniweb.github.io/icons";
+  onProgress(`Fetching ${icons.length} icons for SSR...`);
+  const results = await Promise.allSettled(
+    icons.map(async (iconRef) => {
+      const [family, name] = iconRef.split(":");
+      const url = `${cdnBase}/${family}/${family}-${name}.svg`;
+      const response = await fetch(url);
+      if (!response.ok) throw new Error(`HTTP ${response.status}`);
+      const svg = await response.text();
+      uniweb.iconCache.set(`${family}:${name}`, svg);
+    })
+  );
+  const succeeded = results.filter((r) => r.status === "fulfilled").length;
+  const failed = results.filter((r) => r.status === "rejected").length;
+  if (failed > 0) {
+    const msg = `Fetched ${succeeded}/${icons.length} icons (${failed} failed)`;
+    console.warn(`[prerender] ${msg}`);
+    onProgress(`  ${msg}`);
+  }
+  if (uniweb.iconCache.size > 0) {
+    siteContent._iconCache = Object.fromEntries(uniweb.iconCache);
+  }
+}
+function classifyRenderError(err) {
+  const msg = err.message || "";
+  if (msg.includes("Invalid hook call") || msg.includes("useState") || msg.includes("useEffect")) {
+    return {
+      type: "hooks",
+      message: "contains components with React hooks (renders client-side)"
+    };
+  }
+  if (msg.includes("Element type is invalid") && msg.includes("null")) {
+    return {
+      type: "null-component",
+      message: "a component resolved to null (often hook-related, renders client-side)"
+    };
+  }
+  return {
+    type: "unknown",
+    message: msg
+  };
+}
+function renderPage(page, website) {
+  website.setActivePage(page.route);
+  const element = renderLayout(page, website);
+  let renderedContent;
+  try {
+    renderedContent = renderToString(element);
+  } catch (err) {
+    return { error: classifyRenderError(err) };
+  }
+  const appearance = website.themeData?.appearance;
+  const sectionOverrideCSS = buildSectionOverrides(page.getPageBlocks(), appearance);
+  return { renderedContent, sectionOverrideCSS };
+}
+function escapeHtml(str) {
+  if (!str) return "";
+  return String(str).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function injectPageContent(html, renderedContent, page, options = {}) {
+  let result = html;
+  if (options.sectionOverrideCSS) {
+    const overrideStyle = `<style id="uniweb-page-overrides">
+${options.sectionOverrideCSS}
+</style>`;
+    result = result.replace("</head>", `${overrideStyle}
+</head>`);
+  }
+  result = result.replace(
+    /<div id="root">[\s\S]*?<\/div>/,
+    `<div id="root">${renderedContent}</div>`
   );
+  const pageTitle = page.getTitle?.() || page.title;
+  if (pageTitle) {
+    result = result.replace(
+      /<title>.*?<\/title>/,
+      `<title>${escapeHtml(pageTitle)}</title>`
+    );
+  }
+  if (page.description) {
+    const metaDesc = `<meta name="description" content="${escapeHtml(page.description)}">`;
+    if (result.includes('<meta name="description"')) {
+      result = result.replace(/<meta name="description"[^>]*>/, metaDesc);
+    } else {
+      result = result.replace("</head>", `${metaDesc}
+</head>`);
+    }
+  }
+  return result;
 }
 export {
-  BlockRenderer,
-  Blocks,
-  Layout,
-  PageElement,
   applyDefaults,
   applySchemas,
+  classifyRenderError,
+  escapeHtml,
   getComponentDefaults,
   getComponentMeta,
+  getWrapperProps,
   guaranteeContentStructure,
-  prepareProps
+  initPrerender,
+  injectPageContent,
+  prefetchIcons,
+  prepareProps,
+  renderBackground,
+  renderBlock,
+  renderBlocks,
+  renderLayout,
+  renderPage
 };
 //# sourceMappingURL=ssr.js.map