@absolutejs/absolute 0.20.0-beta.174 → 0.20.0-beta.176

package/dist/react/components/server/index.js

@@ -0,0 +1,728 @@
+// @bun
+// src/utils/cspNonceRef.ts
+var GETTER_KEY = Symbol.for("absolutejs.cspNonceGetter");
+var readCspNonce = () => {
+  const getter = Reflect.get(globalThis, GETTER_KEY);
+  if (typeof getter !== "function")
+    return;
+  const nonce = getter();
+  return typeof nonce === "string" ? nonce : undefined;
+};
+
+// src/utils/fontAssets.ts
+var MIME_BY_EXTENSION = {
+  otf: "font/otf",
+  ttf: "font/ttf",
+  woff: "font/woff",
+  woff2: "font/woff2"
+};
+var fontMimeType = (href) => {
+  const extension = /\.([a-z0-9]+)(?:[?#].*)?$/i.exec(href)?.[1]?.toLowerCase();
+  return (extension && MIME_BY_EXTENSION[extension]) ?? "font/woff2";
+};
+var isRemote = (href) => /^https?:\/\//i.test(href);
+var fontPreconnectOrigins = (fonts) => fonts.stylesheets.some(isRemote) ? ["https://fonts.googleapis.com", "https://fonts.gstatic.com"] : [];
+
+// src/utils/iconVersion.ts
+var iconMimeType = (icon) => {
+  if (icon.endsWith(".svg"))
+    return "image/svg+xml";
+  if (icon.endsWith(".png"))
+    return "image/png";
+  return "image/x-icon";
+};
+var resolver;
+var applyIconVersion = (href) => resolver ? resolver(href) : href;
+
+// src/utils/escapeScriptContent.ts
+var ESCAPE_LOOKUP = {
+  "\u2028": "\\u2028",
+  "\u2029": "\\u2029",
+  "<": "\\u003C"
+};
+var ESCAPE_REGEX = /[<\u2028\u2029]/g;
+var escapeScriptContent = (content) => content.replace(ESCAPE_REGEX, (char) => {
+  const escaped = ESCAPE_LOOKUP[char];
+  return escaped !== undefined ? escaped : char;
+});
+
+// src/utils/jsonLd.ts
+var serializeJsonLd = (schema) => {
+  const schemaOrgContext = "https://schema.org";
+  const data = Array.isArray(schema) ? { "@context": schemaOrgContext, "@graph": schema } : { "@context": schemaOrgContext, ...schema };
+  return escapeScriptContent(JSON.stringify(data));
+};
+
+// src/utils/generateHeadElement.ts
+var serializeSpeculationRules = (rules) => {
+  const body = {};
+  if (rules.prerender && rules.prerender.length > 0) {
+    body.prerender = [{ urls: rules.prerender }];
+  }
+  if (rules.prefetch && rules.prefetch.length > 0) {
+    body.prefetch = [{ urls: rules.prefetch }];
+  }
+  if (Object.keys(body).length === 0)
+    return;
+  return JSON.stringify(body).replace(/</g, "\\u003c");
+};
+
+// src/react/components/Head.tsx
+import { jsx, jsxs, Fragment } from "react/jsx-runtime";
+var RobotsContent = ({ robots }) => {
+  const directives = [];
+  if (robots.index === false)
+    directives.push("noindex");
+  if (robots.index === true)
+    directives.push("index");
+  if (robots.follow === false)
+    directives.push("nofollow");
+  if (robots.follow === true)
+    directives.push("follow");
+  if (robots.noarchive)
+    directives.push("noarchive");
+  if (robots.nosnippet)
+    directives.push("nosnippet");
+  if (robots.noimageindex)
+    directives.push("noimageindex");
+  if (robots.maxSnippet !== undefined)
+    directives.push(`max-snippet:${robots.maxSnippet}`);
+  if (robots.maxImagePreview)
+    directives.push(`max-image-preview:${robots.maxImagePreview}`);
+  if (robots.maxVideoPreview !== undefined)
+    directives.push(`max-video-preview:${robots.maxVideoPreview}`);
+  const content = directives.join(", ");
+  return content ? /* @__PURE__ */ jsx("meta", {
+    content,
+    name: "robots"
+  }) : null;
+};
+var OpenGraphTags = ({
+  openGraph,
+  title,
+  description
+}) => /* @__PURE__ */ jsxs(Fragment, {
+  children: [
+    /* @__PURE__ */ jsx("meta", {
+      content: openGraph.title ?? title,
+      property: "og:title"
+    }),
+    /* @__PURE__ */ jsx("meta", {
+      content: openGraph.description ?? description,
+      property: "og:description"
+    }),
+    openGraph.url && /* @__PURE__ */ jsx("meta", {
+      content: openGraph.url,
+      property: "og:url"
+    }),
+    openGraph.image && /* @__PURE__ */ jsx("meta", {
+      content: openGraph.image,
+      property: "og:image"
+    }),
+    openGraph.imageAlt && /* @__PURE__ */ jsx("meta", {
+      content: openGraph.imageAlt,
+      property: "og:image:alt"
+    }),
+    openGraph.imageWidth && /* @__PURE__ */ jsx("meta", {
+      content: String(openGraph.imageWidth),
+      property: "og:image:width"
+    }),
+    openGraph.imageHeight && /* @__PURE__ */ jsx("meta", {
+      content: String(openGraph.imageHeight),
+      property: "og:image:height"
+    }),
+    openGraph.type && /* @__PURE__ */ jsx("meta", {
+      content: openGraph.type,
+      property: "og:type"
+    }),
+    openGraph.siteName && /* @__PURE__ */ jsx("meta", {
+      content: openGraph.siteName,
+      property: "og:site_name"
+    }),
+    openGraph.locale && /* @__PURE__ */ jsx("meta", {
+      content: openGraph.locale,
+      property: "og:locale"
+    })
+  ]
+});
+var TwitterTags = ({
+  twitter,
+  title,
+  description
+}) => /* @__PURE__ */ jsxs(Fragment, {
+  children: [
+    twitter.card && /* @__PURE__ */ jsx("meta", {
+      content: twitter.card,
+      name: "twitter:card"
+    }),
+    /* @__PURE__ */ jsx("meta", {
+      content: twitter.title ?? title,
+      name: "twitter:title"
+    }),
+    /* @__PURE__ */ jsx("meta", {
+      content: twitter.description ?? description,
+      name: "twitter:description"
+    }),
+    twitter.image && /* @__PURE__ */ jsx("meta", {
+      content: twitter.image,
+      name: "twitter:image"
+    }),
+    twitter.imageAlt && /* @__PURE__ */ jsx("meta", {
+      content: twitter.imageAlt,
+      name: "twitter:image:alt"
+    }),
+    twitter.site && /* @__PURE__ */ jsx("meta", {
+      content: twitter.site,
+      name: "twitter:site"
+    }),
+    twitter.creator && /* @__PURE__ */ jsx("meta", {
+      content: twitter.creator,
+      name: "twitter:creator"
+    })
+  ]
+});
+var CustomMetaTag = ({ tag }) => {
+  if (tag.property)
+    return /* @__PURE__ */ jsx("meta", {
+      content: tag.content,
+      property: tag.property
+    });
+  if (tag.httpEquiv)
+    return /* @__PURE__ */ jsx("meta", {
+      content: tag.content,
+      httpEquiv: tag.httpEquiv
+    });
+  return /* @__PURE__ */ jsx("meta", {
+    content: tag.content,
+    name: tag.name
+  });
+};
+var toCrossOrigin = (value) => {
+  if (value === undefined)
+    return;
+  if (value === "" || value === "use-credentials")
+    return value;
+  return "anonymous";
+};
+var FontLinks = ({ fonts }) => /* @__PURE__ */ jsxs(Fragment, {
+  children: [
+    fontPreconnectOrigins(fonts).map((origin) => /* @__PURE__ */ jsx("link", {
+      crossOrigin: origin.includes("gstatic") ? "anonymous" : undefined,
+      href: origin,
+      rel: "preconnect"
+    }, `preconnect:${origin}`)),
+    fonts.preload.map((href) => /* @__PURE__ */ jsx("link", {
+      as: "font",
+      crossOrigin: "anonymous",
+      href,
+      rel: "preload",
+      suppressHydrationWarning: true,
+      type: fontMimeType(href)
+    }, `preload:${href}`)),
+    fonts.stylesheets.map((href) => /* @__PURE__ */ jsx("link", {
+      "data-absolute-fonts": "",
+      href,
+      rel: "stylesheet",
+      suppressHydrationWarning: true
+    }, `stylesheet:${href}`))
+  ]
+});
+var SpeculationRulesScript = ({
+  rules
+}) => {
+  const body = serializeSpeculationRules(rules);
+  if (!body)
+    return null;
+  return /* @__PURE__ */ jsx("script", {
+    dangerouslySetInnerHTML: { __html: body },
+    nonce: readCspNonce(),
+    suppressHydrationWarning: true,
+    type: "speculationrules"
+  });
+};
+var Head = ({
+  title = "AbsoluteJS",
+  description = "A page created using AbsoluteJS",
+  icon = "/assets/ico/favicon.ico",
+  font,
+  fonts,
+  cssPath,
+  canonical,
+  alternates,
+  openGraph,
+  twitter,
+  robots,
+  meta,
+  jsonLd,
+  preload,
+  speculationRules
+} = {}) => /* @__PURE__ */ jsxs("head", {
+  suppressHydrationWarning: true,
+  children: [
+    /* @__PURE__ */ jsx("meta", {
+      charSet: "utf-8"
+    }),
+    /* @__PURE__ */ jsx("title", {
+      children: title
+    }),
+    /* @__PURE__ */ jsx("meta", {
+      content: description,
+      name: "description"
+    }),
+    /* @__PURE__ */ jsx("meta", {
+      content: "width=device-width, initial-scale=1",
+      name: "viewport"
+    }),
+    /* @__PURE__ */ jsx("link", {
+      href: applyIconVersion(icon),
+      rel: "icon",
+      type: iconMimeType(icon)
+    }),
+    canonical && /* @__PURE__ */ jsx("link", {
+      href: canonical,
+      rel: "canonical"
+    }),
+    alternates?.map(({ href, hreflang }) => /* @__PURE__ */ jsx("link", {
+      href,
+      hrefLang: hreflang,
+      rel: "alternate"
+    }, `alternate:${hreflang}`)),
+    openGraph && /* @__PURE__ */ jsx(OpenGraphTags, {
+      description,
+      openGraph,
+      title
+    }),
+    twitter && /* @__PURE__ */ jsx(TwitterTags, {
+      description,
+      title,
+      twitter
+    }),
+    robots && /* @__PURE__ */ jsx(RobotsContent, {
+      robots
+    }),
+    meta?.map((tag, i) => /* @__PURE__ */ jsx(CustomMetaTag, {
+      tag
+    }, i)),
+    font && /* @__PURE__ */ jsxs(Fragment, {
+      children: [
+        /* @__PURE__ */ jsx("link", {
+          href: "https://fonts.googleapis.com",
+          rel: "preconnect"
+        }),
+        /* @__PURE__ */ jsx("link", {
+          crossOrigin: "anonymous",
+          href: "https://fonts.gstatic.com",
+          rel: "preconnect",
+          suppressHydrationWarning: true
+        }),
+        /* @__PURE__ */ jsx("link", {
+          href: `https://fonts.googleapis.com/css2?family=${font}:wght@100..900&display=swap`,
+          rel: "stylesheet",
+          suppressHydrationWarning: true
+        })
+      ]
+    }),
+    fonts && /* @__PURE__ */ jsx(FontLinks, {
+      fonts
+    }),
+    preload?.map((link) => /* @__PURE__ */ jsx("link", {
+      as: link.module ? undefined : link.as,
+      crossOrigin: toCrossOrigin(link.crossorigin),
+      href: link.href,
+      rel: link.module ? "modulepreload" : "preload"
+    }, `${link.module ? "modulepreload" : "preload"}:${link.href}`)),
+    speculationRules && /* @__PURE__ */ jsx(SpeculationRulesScript, {
+      rules: speculationRules
+    }),
+    cssPath && [cssPath].flat().map((path) => /* @__PURE__ */ jsx("link", {
+      href: path,
+      rel: "stylesheet",
+      suppressHydrationWarning: true,
+      type: "text/css"
+    }, path)),
+    jsonLd && /* @__PURE__ */ jsx("script", {
+      dangerouslySetInnerHTML: { __html: serializeJsonLd(jsonLd) },
+      nonce: readCspNonce(),
+      suppressHydrationWarning: true,
+      type: "application/ld+json"
+    })
+  ]
+});
+// src/constants.ts
+var HOURS_IN_DAY = 24;
+var IMAGE_DEFAULT_DEVICE_SIZES = [
+  640,
+  750,
+  828,
+  1080,
+  1200,
+  1920,
+  2048,
+  3840
+];
+var IMAGE_DEFAULT_IMAGE_SIZES = [16, 32, 48, 64, 96, 128, 256, 384];
+var IMAGE_DEFAULT_QUALITY = 75;
+var MILLISECONDS_IN_A_SECOND = 1000;
+var MINUTES_IN_AN_HOUR = 60;
+var SECONDS_IN_A_MINUTE = 60;
+var MILLISECONDS_IN_A_MINUTE = MILLISECONDS_IN_A_SECOND * SECONDS_IN_A_MINUTE;
+var MILLISECONDS_IN_A_DAY = MILLISECONDS_IN_A_SECOND * SECONDS_IN_A_MINUTE * MINUTES_IN_AN_HOUR * HOURS_IN_DAY;
+var TWO_THIRDS = 2 / 3;
+
+// src/utils/imageClient.ts
+var DEFAULT_DEVICE_SIZES = IMAGE_DEFAULT_DEVICE_SIZES;
+var DEFAULT_IMAGE_SIZES = IMAGE_DEFAULT_IMAGE_SIZES;
+var DEFAULT_QUALITY = IMAGE_DEFAULT_QUALITY;
+var OPTIMIZATION_ENDPOINT = "/_absolute/image";
+var buildOptimizedUrl = (src, width, quality, basePath = OPTIMIZATION_ENDPOINT) => `${basePath}?url=${encodeURIComponent(src)}&w=${width}&q=${quality}`;
+var getAllSizes = (deviceSizes, imageSizes) => {
+  const device = deviceSizes ?? DEFAULT_DEVICE_SIZES;
+  const image = imageSizes ?? DEFAULT_IMAGE_SIZES;
+  return [...device, ...image].sort((left, right) => left - right);
+};
+var snapToSize = (target, sizes) => {
+  for (const size of sizes) {
+    if (size >= target)
+      return size;
+  }
+  return sizes[sizes.length - 1] ?? target;
+};
+var generateBlurSvg = (base64Thumbnail) => {
+  const svg = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 320 320"><filter id="b" color-interpolation-filters="sRGB"><feGaussianBlur stdDeviation="20"/><feColorMatrix values="1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 100 -1"/></filter><image filter="url(#b)" x="0" y="0" width="100%" height="100%" href="${base64Thumbnail}"/></svg>`;
+  const encoded = encodeURIComponent(svg);
+  return `url("data:image/svg+xml,${encoded}")`;
+};
+var generateSrcSet = (src, width, sizes, deviceSizes, imageSizes) => {
+  const quality = DEFAULT_QUALITY;
+  if (sizes) {
+    const allSizes = getAllSizes(deviceSizes, imageSizes);
+    return allSizes.map((sizeWidth) => `${buildOptimizedUrl(src, sizeWidth, quality)} ${sizeWidth}w`).join(", ");
+  }
+  if (width) {
+    const allSizes = getAllSizes(deviceSizes, imageSizes);
+    const w1x = snapToSize(width, allSizes);
+    const w2x = snapToSize(width * 2, allSizes);
+    return `${buildOptimizedUrl(src, w1x, quality)} 1x, ${buildOptimizedUrl(src, w2x, quality)} 2x`;
+  }
+  const devSizes = deviceSizes ?? DEFAULT_DEVICE_SIZES;
+  return devSizes.map((sizeWidth) => `${buildOptimizedUrl(src, sizeWidth, quality)} ${sizeWidth}w`).join(", ");
+};
+
+// src/react/components/Image.tsx
+import { jsx as jsx2, jsxs as jsxs2, Fragment as Fragment2 } from "react/jsx-runtime";
+var resolveSource = (src, overrideSrc, unoptimized, loader, width, quality) => {
+  if (overrideSrc)
+    return overrideSrc;
+  if (unoptimized)
+    return src;
+  if (loader)
+    return loader({ quality, src, width: width ?? 0 });
+  if (!width)
+    return buildOptimizedUrl(src, 0, quality);
+  return buildOptimizedUrl(src, width, quality);
+};
+var resolveBlurBackground = (hasBlur, placeholder, blurDataURL) => {
+  if (!hasBlur)
+    return;
+  if (typeof placeholder === "string" && placeholder !== "blur" && placeholder.startsWith("data:")) {
+    return generateBlurSvg(placeholder);
+  }
+  if (blurDataURL)
+    return generateBlurSvg(blurDataURL);
+  return;
+};
+var Image = ({
+  alt,
+  blurDataURL,
+  className,
+  crossOrigin,
+  fetchPriority,
+  fill,
+  height,
+  loader,
+  loading,
+  onError,
+  onLoad,
+  overrideSrc,
+  placeholder,
+  priority,
+  quality = DEFAULT_QUALITY,
+  referrerPolicy,
+  sizes,
+  src,
+  style,
+  unoptimized,
+  width
+}) => {
+  const resolvedSrc = resolveSource(src, overrideSrc, unoptimized, loader, width, quality);
+  const srcSet = unoptimized ? undefined : generateSrcSet(src, width, sizes);
+  const resolvedSizes = sizes ?? (fill ? "100vw" : undefined);
+  const resolvedLoading = priority ? "eager" : loading ?? "lazy";
+  const resolvedFetchPriority = priority ? "high" : fetchPriority;
+  const hasBlur = placeholder === "blur" || typeof placeholder === "string" && placeholder !== "empty" && placeholder.startsWith("data:");
+  const blurBackground = resolveBlurBackground(hasBlur, placeholder, blurDataURL);
+  const imgStyle = {
+    ...style ?? {},
+    ...blurBackground ? {
+      backgroundImage: blurBackground,
+      backgroundPosition: "center",
+      backgroundRepeat: "no-repeat",
+      backgroundSize: "cover"
+    } : {},
+    ...fill ? {
+      color: "transparent",
+      height: "100%",
+      inset: 0,
+      objectFit: "cover",
+      position: "absolute",
+      width: "100%"
+    } : { color: "transparent" }
+  };
+  const fillWrapperStyle = {
+    display: "block",
+    height: "100%",
+    overflow: "hidden",
+    position: "relative",
+    width: "100%"
+  };
+  const preloadLink = priority ? /* @__PURE__ */ jsx2("link", {
+    as: "image",
+    crossOrigin,
+    href: resolvedSrc,
+    imageSizes: resolvedSizes,
+    imageSrcSet: srcSet,
+    rel: "preload"
+  }) : null;
+  const imgElement = /* @__PURE__ */ jsx2("img", {
+    alt,
+    className,
+    crossOrigin,
+    decoding: "async",
+    fetchPriority: resolvedFetchPriority,
+    height: fill ? undefined : height,
+    loading: resolvedLoading,
+    onError: onError ? (event) => onError(event.nativeEvent) : undefined,
+    onLoad: (event) => {
+      const { target } = event;
+      if (blurBackground && target instanceof HTMLImageElement) {
+        target.style.backgroundImage = "none";
+      }
+      if (onLoad)
+        onLoad(event.nativeEvent);
+    },
+    referrerPolicy,
+    sizes: resolvedSizes,
+    src: resolvedSrc,
+    srcSet,
+    style: imgStyle,
+    width: fill ? undefined : width
+  });
+  if (fill) {
+    return /* @__PURE__ */ jsxs2(Fragment2, {
+      children: [
+        preloadLink,
+        /* @__PURE__ */ jsx2("span", {
+          style: fillWrapperStyle,
+          children: imgElement
+        })
+      ]
+    });
+  }
+  return /* @__PURE__ */ jsxs2(Fragment2, {
+    children: [
+      preloadLink,
+      imgElement
+    ]
+  });
+};
+// src/react/components/JsonLd.tsx
+import { jsx as jsx3 } from "react/jsx-runtime";
+var JsonLd = ({
+  schema
+}) => {
+  const schemaOrgContext = "https://schema.org";
+  const data = Array.isArray(schema) ? schema.map((s) => ({
+    "@context": schemaOrgContext,
+    ...s
+  })) : { "@context": schemaOrgContext, ...schema };
+  return /* @__PURE__ */ jsx3("script", {
+    dangerouslySetInnerHTML: { __html: JSON.stringify(data) },
+    type: "application/ld+json"
+  });
+};
+// src/core/streamingSlotRegistrar.ts
+var STREAMING_SLOT_REGISTRAR_KEY = Symbol.for("absolutejs.streamingSlotRegistrar");
+var STREAMING_SLOT_WARNING_STORAGE_KEY = Symbol.for("absolutejs.streamingSlotWarningController");
+var STREAMING_SLOT_COLLECTION_STORAGE_KEY = Symbol.for("absolutejs.streamingSlotCollectionController");
+var getRegisteredStreamingSlotRegistrar = () => {
+  const value = Reflect.get(globalThis, STREAMING_SLOT_REGISTRAR_KEY);
+  if (typeof value === "function" || value === null) {
+    return value;
+  }
+  return;
+};
+var isObjectRecord = (value) => Boolean(value) && typeof value === "object";
+var isStreamingSlotWarningController = (value) => isObjectRecord(value) && ("maybeWarn" in value) && typeof value.maybeWarn === "function";
+var isStreamingSlotCollectionController = (value) => isObjectRecord(value) && ("isCollecting" in value) && typeof value.isCollecting === "function";
+var getWarningController = () => {
+  const value = Reflect.get(globalThis, STREAMING_SLOT_WARNING_STORAGE_KEY);
+  if (value === null || typeof value === "undefined")
+    return;
+  return isStreamingSlotWarningController(value) ? value : undefined;
+};
+var getCollectionController = () => {
+  const value = Reflect.get(globalThis, STREAMING_SLOT_COLLECTION_STORAGE_KEY);
+  if (value === null || typeof value === "undefined")
+    return;
+  return isStreamingSlotCollectionController(value) ? value : undefined;
+};
+var isStreamingSlotCollectionActive = () => getCollectionController()?.isCollecting() === true;
+var registerStreamingSlot = (slot) => {
+  getRegisteredStreamingSlotRegistrar()?.(slot);
+};
+var warnMissingStreamingSlotCollector = (primitiveName) => {
+  if (isStreamingSlotCollectionActive()) {
+    return;
+  }
+  getWarningController()?.maybeWarn(primitiveName);
+};
+
+// src/react/components/SuspenseSlot.tsx
+import { jsx as jsx4 } from "react/jsx-runtime";
+var isLegacyProps = (props) => ("fallbackHtml" in props) || ("errorHtml" in props);
+var renderReactNodeToHtml = async (node) => {
+  const { Fragment } = await import("react");
+  const { renderToReadableStream } = await import("react-dom/server");
+  const stream = await renderToReadableStream(/* @__PURE__ */ jsx4(Fragment, {
+    children: node
+  }));
+  await stream.allReady;
+  return new Response(stream).text();
+};
+var hasRenderChildren = (props) => typeof props.children === "function";
+async function resolveRenderSuspenseValue(props) {
+  if ("resolve" in props && props.resolve !== undefined) {
+    return props.resolve();
+  }
+  if ("promise" in props && props.promise !== undefined) {
+    return props.promise;
+  }
+  return;
+}
+async function resolveNodeSuspenseValue(props) {
+  if (props.resolve !== undefined) {
+    return props.resolve();
+  }
+  if (props.promise !== undefined) {
+    return props.promise;
+  }
+  return;
+}
+var renderErrorFallback = async (props, error) => {
+  if (typeof props.errorFallback === "function") {
+    return renderReactNodeToHtml(props.errorFallback(error));
+  }
+  if (props.errorFallback !== undefined) {
+    return renderReactNodeToHtml(props.errorFallback);
+  }
+  throw error;
+};
+var registerLegacySuspenseSlot = (props) => {
+  registerStreamingSlot({
+    dynamic: props.dynamic,
+    errorHtml: props.errorHtml,
+    fallbackHtml: props.fallbackHtml,
+    id: props.id,
+    resolve: props.resolve,
+    timeoutMs: props.timeoutMs
+  });
+};
+var registerFrameworkSuspenseSlot = (props) => {
+  registerStreamingSlot({
+    dynamic: props.dynamic,
+    id: props.id,
+    timeoutMs: props.timeoutMs,
+    resolve: async () => {
+      try {
+        const content = hasRenderChildren(props) ? props.children(await resolveRenderSuspenseValue(props)) : props.children ?? await resolveNodeSuspenseValue(props) ?? null;
+        return renderReactNodeToHtml(content);
+      } catch (error) {
+        return renderErrorFallback(props, error);
+      }
+    }
+  });
+};
+var renderLegacySuspenseSlot = (props) => /* @__PURE__ */ jsx4("div", {
+  className: props.className,
+  dangerouslySetInnerHTML: { __html: props.fallbackHtml ?? "" },
+  "data-absolute-slot": "true",
+  id: props.id,
+  suppressHydrationWarning: true
+});
+var renderFrameworkSuspenseSlot = (props) => /* @__PURE__ */ jsx4("div", {
+  className: props.className,
+  "data-absolute-slot": "true",
+  id: props.id,
+  suppressHydrationWarning: true,
+  children: props.fallback ?? null
+});
+var renderServerSuspenseSlot = (props) => {
+  if (isLegacyProps(props)) {
+    registerLegacySuspenseSlot(props);
+    return renderLegacySuspenseSlot(props);
+  }
+  registerFrameworkSuspenseSlot(props);
+  return renderFrameworkSuspenseSlot(props);
+};
+var SuspenseSlot = (props) => {
+  if (isStreamingSlotCollectionActive()) {
+    return renderServerSuspenseSlot(props);
+  }
+  warnMissingStreamingSlotCollector("SuspenseSlot");
+  if (isLegacyProps(props))
+    return renderLegacySuspenseSlot(props);
+  return renderFrameworkSuspenseSlot(props);
+};
+// src/react/components/StreamSlot.tsx
+import { jsx as jsx5 } from "react/jsx-runtime";
+var StreamSlot = ({
+  className,
+  dynamic,
+  errorHtml,
+  fallbackHtml = "",
+  id,
+  resolve,
+  timeoutMs
+}) => {
+  if (isStreamingSlotCollectionActive()) {
+    registerStreamingSlot({
+      dynamic,
+      errorHtml,
+      fallbackHtml,
+      id,
+      resolve,
+      timeoutMs
+    });
+  } else {
+    warnMissingStreamingSlotCollector("StreamSlot");
+  }
+  return /* @__PURE__ */ jsx5("div", {
+    className,
+    dangerouslySetInnerHTML: { __html: fallbackHtml },
+    "data-absolute-slot": "true",
+    id,
+    suppressHydrationWarning: true
+  });
+};
+
+// src/react/components/server/index.ts
+import { Link, usePrefetch } from "../client.js";
+export {
+  Head,
+  Image,
+  JsonLd,
+  Link,
+  StreamSlot,
+  SuspenseSlot,
+  usePrefetch
+};