@vertz/ui-server 0.2.0 → 0.2.4

package/dist/shared/chunk-2qsqp9xj.js

@@ -0,0 +1,150 @@
+// @bun
+// src/bun-plugin/fast-refresh-dom-state.ts
+function captureDOMState(element) {
+  return {
+    formFields: captureFormFields(element),
+    focus: captureFocus(element),
+    scrollPositions: captureScrollPositions(element)
+  };
+}
+function captureFormFields(element) {
+  const fields = new Map;
+  const inputs = element.querySelectorAll("input, textarea, select");
+  for (const el of inputs) {
+    const name = el.getAttribute("name");
+    if (!name)
+      continue;
+    const type = el.type ?? "";
+    if (type === "file")
+      continue;
+    fields.set(name, {
+      value: el.value ?? "",
+      checked: el.checked ?? false,
+      selectedIndex: el.selectedIndex ?? -1,
+      type
+    });
+  }
+  return fields;
+}
+function captureFocus(element) {
+  const active = element.ownerDocument?.activeElement;
+  if (!active)
+    return null;
+  if (!element.contains(active))
+    return null;
+  const name = active.getAttribute("name");
+  const id = active.getAttribute("id");
+  const matchKey = name ?? id;
+  if (!matchKey)
+    return null;
+  let selectionStart = -1;
+  let selectionEnd = -1;
+  const inputLike = active;
+  if ("selectionStart" in active && inputLike.selectionStart != null) {
+    selectionStart = inputLike.selectionStart;
+    selectionEnd = inputLike.selectionEnd ?? selectionStart;
+  }
+  return {
+    matchKey,
+    matchBy: name ? "name" : "id",
+    selectionStart,
+    selectionEnd
+  };
+}
+function captureScrollPositions(element) {
+  const positions = [];
+  walkElements(element, (el) => {
+    if (el.scrollTop === 0 && el.scrollLeft === 0)
+      return;
+    const id = el.getAttribute("id");
+    if (id) {
+      positions.push({
+        matchKey: id,
+        matchBy: "id",
+        scrollTop: el.scrollTop,
+        scrollLeft: el.scrollLeft
+      });
+      return;
+    }
+    const selector = `${el.tagName.toLowerCase()}.${el.className}`;
+    if (el.className) {
+      positions.push({
+        matchKey: selector,
+        matchBy: "selector",
+        scrollTop: el.scrollTop,
+        scrollLeft: el.scrollLeft
+      });
+    }
+  });
+  return positions;
+}
+function restoreDOMState(newElement, snapshot) {
+  restoreFormFields(newElement, snapshot.formFields);
+  restoreFocus(newElement, snapshot.focus);
+  restoreScrollPositions(newElement, snapshot.scrollPositions);
+}
+function restoreFormFields(element, fields) {
+  if (fields.size === 0)
+    return;
+  const inputs = element.querySelectorAll("input, textarea, select");
+  for (const el of inputs) {
+    const name = el.getAttribute("name");
+    if (!name)
+      continue;
+    const saved = fields.get(name);
+    if (!saved)
+      continue;
+    if (saved.type === "file")
+      continue;
+    const input = el;
+    if (el.tagName === "SELECT") {
+      el.selectedIndex = saved.selectedIndex;
+    } else if (saved.type === "checkbox" || saved.type === "radio") {
+      input.checked = saved.checked;
+    } else {
+      input.value = saved.value;
+    }
+  }
+}
+function restoreFocus(element, focus) {
+  if (!focus)
+    return;
+  const target = focus.matchBy === "name" ? element.querySelector(`[name="${focus.matchKey}"]`) : element.querySelector(`#${focus.matchKey}`);
+  if (!target)
+    return;
+  if (target.disabled)
+    return;
+  if (typeof target.focus === "function") {
+    target.focus();
+  }
+  if (focus.selectionStart >= 0 && "setSelectionRange" in target && typeof target.setSelectionRange === "function") {
+    try {
+      target.setSelectionRange(focus.selectionStart, focus.selectionEnd);
+    } catch (_) {}
+  }
+}
+function restoreScrollPositions(element, positions) {
+  for (const pos of positions) {
+    let target = null;
+    if (pos.matchBy === "id") {
+      target = element.querySelector(`#${pos.matchKey}`);
+    } else {
+      target = element.querySelector(pos.matchKey);
+    }
+    if (!target)
+      continue;
+    target.scrollTop = pos.scrollTop;
+    target.scrollLeft = pos.scrollLeft;
+  }
+}
+function walkElements(root, callback) {
+  callback(root);
+  const children = root.children;
+  for (let i = 0;i < children.length; i++) {
+    const child = children[i];
+    if (child)
+      walkElements(child, callback);
+  }
+}
+
+export { captureDOMState, restoreDOMState };

package/dist/shared/chunk-32688jav.js

@@ -0,0 +1,564 @@
+import {
+  SSRElement,
+  installDomShim,
+  removeDomShim,
+  toVNode
+} from "./chunk-4t0ekdyv.js";
+
+// src/html-serializer.ts
+var VOID_ELEMENTS = new Set([
+  "area",
+  "base",
+  "br",
+  "col",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "link",
+  "meta",
+  "param",
+  "source",
+  "track",
+  "wbr"
+]);
+var RAW_TEXT_ELEMENTS = new Set(["script", "style"]);
+function escapeHtml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function escapeAttr(value) {
+  const str = typeof value === "string" ? value : String(value);
+  return str.replace(/&/g, "&amp;").replace(/"/g, "&quot;");
+}
+function serializeAttrs(attrs) {
+  const parts = [];
+  for (const [key, value] of Object.entries(attrs)) {
+    parts.push(` ${key}="${escapeAttr(value)}"`);
+  }
+  return parts.join("");
+}
+function isRawHtml(value) {
+  return typeof value === "object" && "__raw" in value && value.__raw === true;
+}
+function serializeToHtml(node) {
+  if (typeof node === "string") {
+    return escapeHtml(node);
+  }
+  if (isRawHtml(node)) {
+    return node.html;
+  }
+  const { tag, attrs, children } = node;
+  const attrStr = serializeAttrs(attrs);
+  if (VOID_ELEMENTS.has(tag)) {
+    return `<${tag}${attrStr}>`;
+  }
+  const isRawText = RAW_TEXT_ELEMENTS.has(tag);
+  const childrenHtml = children.map((child) => {
+    if (typeof child === "string" && isRawText) {
+      return child;
+    }
+    return serializeToHtml(child);
+  }).join("");
+  return `<${tag}${attrStr}>${childrenHtml}</${tag}>`;
+}
+
+// src/slot-placeholder.ts
+var slotCounter = 0;
+function resetSlotCounter() {
+  slotCounter = 0;
+}
+function createSlotPlaceholder(fallback) {
+  const id = slotCounter++;
+  const placeholder = {
+    tag: "div",
+    attrs: { id: `v-slot-${id}` },
+    children: typeof fallback === "string" ? [fallback] : [fallback],
+    _slotId: id
+  };
+  return placeholder;
+}
+
+// src/streaming.ts
+var encoder = new TextEncoder;
+var decoder = new TextDecoder;
+function encodeChunk(html) {
+  return encoder.encode(html);
+}
+async function streamToString(stream) {
+  const reader = stream.getReader();
+  const parts = [];
+  for (;; ) {
+    const { done, value } = await reader.read();
+    if (done)
+      break;
+    parts.push(decoder.decode(value, { stream: true }));
+  }
+  parts.push(decoder.decode());
+  return parts.join("");
+}
+async function collectStreamChunks(stream) {
+  const reader = stream.getReader();
+  const chunks = [];
+  for (;; ) {
+    const { done, value } = await reader.read();
+    if (done)
+      break;
+    chunks.push(decoder.decode(value, { stream: true }));
+  }
+  return chunks;
+}
+
+// src/template-chunk.ts
+function createTemplateChunk(slotId, resolvedHtml, nonce) {
+  const tmplId = `v-tmpl-${slotId}`;
+  const slotRef = `v-slot-${slotId}`;
+  const nonceAttr = nonce != null ? ` nonce="${escapeAttr(nonce)}"` : "";
+  return `<template id="${tmplId}">${resolvedHtml}</template>` + `<script${nonceAttr}>` + `(function(){` + `var s=document.getElementById("${slotRef}");` + `var t=document.getElementById("${tmplId}");` + `if(s&&t){s.replaceWith(t.content.cloneNode(true));t.remove()}` + `})()` + "</script>";
+}
+
+// src/render-to-stream.ts
+function isSuspenseNode(node) {
+  return typeof node === "object" && "tag" in node && node.tag === "__suspense" && "_resolve" in node;
+}
+function renderToStream(tree, options) {
+  const pendingBoundaries = [];
+  function walkAndSerialize(node) {
+    if (typeof node === "string") {
+      return escapeHtml(node);
+    }
+    if (isRawHtml(node)) {
+      return node.html;
+    }
+    if (isSuspenseNode(node)) {
+      const placeholder = createSlotPlaceholder(node._fallback);
+      pendingBoundaries.push({
+        slotId: placeholder._slotId,
+        resolve: node._resolve
+      });
+      return serializeToHtml(placeholder);
+    }
+    const { tag, attrs, children } = node;
+    const isRawText = RAW_TEXT_ELEMENTS.has(tag);
+    const attrStr = Object.entries(attrs).map(([k, v]) => ` ${k}="${escapeAttr(v)}"`).join("");
+    if (VOID_ELEMENTS.has(tag)) {
+      return `<${tag}${attrStr}>`;
+    }
+    const childrenHtml = children.map((child) => {
+      if (typeof child === "string" && isRawText) {
+        return child;
+      }
+      return walkAndSerialize(child);
+    }).join("");
+    return `<${tag}${attrStr}>${childrenHtml}</${tag}>`;
+  }
+  return new ReadableStream({
+    async start(controller) {
+      const mainHtml = walkAndSerialize(tree);
+      controller.enqueue(encodeChunk(mainHtml));
+      if (pendingBoundaries.length > 0) {
+        const nonce = options?.nonce;
+        const resolutions = pendingBoundaries.map(async (boundary) => {
+          try {
+            const resolved = await boundary.resolve;
+            const resolvedHtml = serializeToHtml(resolved);
+            return createTemplateChunk(boundary.slotId, resolvedHtml, nonce);
+          } catch (_err) {
+            const errorHtml = `<div data-v-ssr-error="true" id="v-ssr-error-${boundary.slotId}">` + "<!--SSR error--></div>";
+            return createTemplateChunk(boundary.slotId, errorHtml, nonce);
+          }
+        });
+        const chunks = await Promise.all(resolutions);
+        for (const chunk of chunks) {
+          controller.enqueue(encodeChunk(chunk));
+        }
+      }
+      controller.close();
+    }
+  });
+}
+
+// src/ssr-context.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+var ssrStorage = new AsyncLocalStorage;
+function isInSSR() {
+  return ssrStorage.getStore() !== undefined;
+}
+function getSSRUrl() {
+  return ssrStorage.getStore()?.url;
+}
+function registerSSRQuery(entry) {
+  ssrStorage.getStore()?.queries.push(entry);
+}
+function getSSRQueries() {
+  return ssrStorage.getStore()?.queries ?? [];
+}
+function setGlobalSSRTimeout(timeout) {
+  const store = ssrStorage.getStore();
+  if (store)
+    store.globalSSRTimeout = timeout;
+}
+function clearGlobalSSRTimeout() {
+  const store = ssrStorage.getStore();
+  if (store)
+    store.globalSSRTimeout = undefined;
+}
+function getGlobalSSRTimeout() {
+  return ssrStorage.getStore()?.globalSSRTimeout;
+}
+globalThis.__VERTZ_IS_SSR__ = isInSSR;
+globalThis.__VERTZ_SSR_REGISTER_QUERY__ = registerSSRQuery;
+globalThis.__VERTZ_GET_GLOBAL_SSR_TIMEOUT__ = getGlobalSSRTimeout;
+
+// src/ssr-streaming-runtime.ts
+function safeSerialize(data) {
+  return JSON.stringify(data).replace(/</g, "\\u003c");
+}
+function getStreamingRuntimeScript(nonce) {
+  const nonceAttr = nonce != null ? ` nonce="${escapeAttr(nonce)}"` : "";
+  return `<script${nonceAttr}>` + "window.__VERTZ_SSR_DATA__=[];" + "window.__VERTZ_SSR_PUSH__=function(k,d){" + "window.__VERTZ_SSR_DATA__.push({key:k,data:d});" + 'document.dispatchEvent(new CustomEvent("vertz:ssr-data",{detail:{key:k,data:d}}))' + "};" + "</script>";
+}
+function createSSRDataChunk(key, data, nonce) {
+  const nonceAttr = nonce != null ? ` nonce="${escapeAttr(nonce)}"` : "";
+  const serialized = safeSerialize(data);
+  return `<script${nonceAttr}>window.__VERTZ_SSR_PUSH__(${safeSerialize(key)},${serialized})</script>`;
+}
+
+// src/ssr-render.ts
+import { compileTheme } from "@vertz/ui";
+var renderLock = Promise.resolve();
+function withRenderLock(fn) {
+  const prev = renderLock;
+  let release;
+  renderLock = new Promise((r) => {
+    release = r;
+  });
+  return prev.then(fn).finally(() => release());
+}
+function resolveAppFactory(module) {
+  const createApp = module.default || module.App;
+  if (typeof createApp !== "function") {
+    throw new Error("App entry must export a default function or named App function");
+  }
+  return createApp;
+}
+function collectCSS(themeCss, module) {
+  const themeTag = themeCss ? `<style data-vertz-css>${themeCss}</style>` : "";
+  const globalTags = module.styles ? module.styles.map((s) => `<style data-vertz-css>${s}</style>`).join(`
+`) : "";
+  const alreadyIncluded = new Set;
+  if (themeCss)
+    alreadyIncluded.add(themeCss);
+  if (module.styles) {
+    for (const s of module.styles)
+      alreadyIncluded.add(s);
+  }
+  let componentCss;
+  if (module.getInjectedCSS) {
+    componentCss = module.getInjectedCSS().filter((s) => !alreadyIncluded.has(s));
+  } else {
+    componentCss = [];
+    const head = globalThis.document?.head;
+    if (head instanceof SSRElement) {
+      for (const child of head.children) {
+        if (child instanceof SSRElement && child.tag === "style" && "data-vertz-css" in child.attrs && child.textContent && !alreadyIncluded.has(child.textContent)) {
+          componentCss.push(child.textContent);
+        }
+      }
+    }
+  }
+  const componentStyles = componentCss.map((s) => `<style data-vertz-css>${s}</style>`).join(`
+`);
+  return [themeTag, globalTags, componentStyles].filter(Boolean).join(`
+`);
+}
+async function ssrRenderToString(module, url, options) {
+  return withRenderLock(() => ssrRenderToStringUnsafe(module, url, options));
+}
+async function ssrRenderToStringUnsafe(module, url, options) {
+  const normalizedUrl = url.endsWith("/index.html") ? url.slice(0, -"/index.html".length) || "/" : url;
+  const ssrTimeout = options?.ssrTimeout ?? 300;
+  return ssrStorage.run({ url: normalizedUrl, errors: [], queries: [] }, async () => {
+    globalThis.__SSR_URL__ = normalizedUrl;
+    installDomShim();
+    globalThis.__VERTZ_CLEAR_QUERY_CACHE__?.();
+    try {
+      setGlobalSSRTimeout(ssrTimeout);
+      const createApp = resolveAppFactory(module);
+      let themeCss = "";
+      if (module.theme) {
+        try {
+          themeCss = compileTheme(module.theme).css;
+        } catch (e) {
+          console.error("[vertz] Failed to compile theme export. Ensure your theme is created with defineTheme().", e);
+        }
+      }
+      globalThis.__VERTZ_SSR_SYNC_ROUTER__?.(normalizedUrl);
+      createApp();
+      const queries = getSSRQueries();
+      const resolvedQueries = [];
+      if (queries.length > 0) {
+        await Promise.allSettled(queries.map(({ promise, timeout, resolve, key }) => Promise.race([
+          promise.then((data) => {
+            resolve(data);
+            resolvedQueries.push({ key, data });
+            return "resolved";
+          }),
+          new Promise((r) => setTimeout(r, timeout || ssrTimeout)).then(() => "timeout")
+        ])));
+        const store = ssrStorage.getStore();
+        if (store)
+          store.queries = [];
+      }
+      const app = createApp();
+      const vnode = toVNode(app);
+      const stream = renderToStream(vnode);
+      const html = await streamToString(stream);
+      const css = collectCSS(themeCss, module);
+      const ssrData = resolvedQueries.length > 0 ? resolvedQueries.map(({ key, data }) => ({
+        key,
+        data: JSON.parse(JSON.stringify(data))
+      })) : [];
+      return { html, css, ssrData };
+    } finally {
+      clearGlobalSSRTimeout();
+      removeDomShim();
+      delete globalThis.__SSR_URL__;
+    }
+  });
+}
+async function ssrDiscoverQueries(module, url, options) {
+  return withRenderLock(() => ssrDiscoverQueriesUnsafe(module, url, options));
+}
+async function ssrDiscoverQueriesUnsafe(module, url, options) {
+  const normalizedUrl = url.endsWith("/index.html") ? url.slice(0, -"/index.html".length) || "/" : url;
+  const ssrTimeout = options?.ssrTimeout ?? 300;
+  return ssrStorage.run({ url: normalizedUrl, errors: [], queries: [] }, async () => {
+    globalThis.__SSR_URL__ = normalizedUrl;
+    installDomShim();
+    globalThis.__VERTZ_CLEAR_QUERY_CACHE__?.();
+    try {
+      setGlobalSSRTimeout(ssrTimeout);
+      const createApp = resolveAppFactory(module);
+      globalThis.__VERTZ_SSR_SYNC_ROUTER__?.(normalizedUrl);
+      createApp();
+      const queries = getSSRQueries();
+      const resolvedQueries = [];
+      const pendingKeys = [];
+      if (queries.length > 0) {
+        await Promise.allSettled(queries.map(({ promise, timeout, resolve, key }) => {
+          let settled = false;
+          return Promise.race([
+            promise.then((data) => {
+              if (settled)
+                return "late";
+              settled = true;
+              resolve(data);
+              resolvedQueries.push({ key, data });
+              return "resolved";
+            }),
+            new Promise((r) => setTimeout(r, timeout || ssrTimeout)).then(() => {
+              if (settled)
+                return "already-resolved";
+              settled = true;
+              pendingKeys.push(key);
+              return "timeout";
+            })
+          ]);
+        }));
+      }
+      return {
+        resolved: resolvedQueries.map(({ key, data }) => ({
+          key,
+          data: JSON.parse(JSON.stringify(data))
+        })),
+        pending: pendingKeys
+      };
+    } finally {
+      clearGlobalSSRTimeout();
+      removeDomShim();
+      delete globalThis.__SSR_URL__;
+    }
+  });
+}
+async function ssrStreamNavQueries(module, url, options) {
+  const normalizedUrl = url.endsWith("/index.html") ? url.slice(0, -"/index.html".length) || "/" : url;
+  const ssrTimeout = options?.ssrTimeout ?? 300;
+  const navTimeout = options?.navSsrTimeout ?? 5000;
+  const queries = await withRenderLock(() => ssrStorage.run({ url: normalizedUrl, errors: [], queries: [] }, async () => {
+    globalThis.__SSR_URL__ = normalizedUrl;
+    installDomShim();
+    globalThis.__VERTZ_CLEAR_QUERY_CACHE__?.();
+    try {
+      setGlobalSSRTimeout(ssrTimeout);
+      const createApp = resolveAppFactory(module);
+      globalThis.__VERTZ_SSR_SYNC_ROUTER__?.(normalizedUrl);
+      createApp();
+      const discovered = getSSRQueries();
+      return discovered.map((q) => ({
+        promise: q.promise,
+        timeout: q.timeout || ssrTimeout,
+        resolve: q.resolve,
+        key: q.key
+      }));
+    } finally {
+      clearGlobalSSRTimeout();
+      removeDomShim();
+      delete globalThis.__SSR_URL__;
+    }
+  }));
+  if (queries.length === 0) {
+    const encoder3 = new TextEncoder;
+    return new ReadableStream({
+      start(controller) {
+        controller.enqueue(encoder3.encode(`event: done
+data: {}
+
+`));
+        controller.close();
+      }
+    });
+  }
+  const encoder2 = new TextEncoder;
+  let remaining = queries.length;
+  return new ReadableStream({
+    start(controller) {
+      let closed = false;
+      function safeEnqueue(chunk) {
+        if (closed)
+          return;
+        try {
+          controller.enqueue(chunk);
+        } catch {
+          closed = true;
+        }
+      }
+      function safeClose() {
+        if (closed)
+          return;
+        closed = true;
+        try {
+          controller.close();
+        } catch {}
+      }
+      function checkDone() {
+        if (remaining === 0) {
+          safeEnqueue(encoder2.encode(`event: done
+data: {}
+
+`));
+          safeClose();
+        }
+      }
+      for (const { promise, resolve, key } of queries) {
+        let settled = false;
+        promise.then((data) => {
+          if (settled)
+            return;
+          settled = true;
+          resolve(data);
+          const entry = { key, data: JSON.parse(JSON.stringify(data)) };
+          safeEnqueue(encoder2.encode(`event: data
+data: ${safeSerialize(entry)}
+
+`));
+          remaining--;
+          checkDone();
+        }, () => {
+          if (settled)
+            return;
+          settled = true;
+          remaining--;
+          checkDone();
+        });
+        setTimeout(() => {
+          if (settled)
+            return;
+          settled = true;
+          remaining--;
+          checkDone();
+        }, navTimeout);
+      }
+    }
+  });
+}
+
+// src/ssr-handler.ts
+function injectIntoTemplate(template, appHtml, appCss, ssrData, nonce) {
+  let html;
+  if (template.includes("<!--ssr-outlet-->")) {
+    html = template.replace("<!--ssr-outlet-->", appHtml);
+  } else {
+    html = template.replace(/(<div[^>]*id="app"[^>]*>)([\s\S]*?)(<\/div>)/, `$1${appHtml}$3`);
+  }
+  if (appCss) {
+    html = html.replace("</head>", `${appCss}
+</head>`);
+  }
+  if (ssrData.length > 0) {
+    const nonceAttr = nonce != null ? ` nonce="${nonce}"` : "";
+    const ssrDataScript = `<script${nonceAttr}>window.__VERTZ_SSR_DATA__=${safeSerialize(ssrData)};</script>`;
+    html = html.replace("</body>", `${ssrDataScript}
+</body>`);
+  }
+  return html;
+}
+function createSSRHandler(options) {
+  const { module, ssrTimeout, inlineCSS, nonce } = options;
+  let template = options.template;
+  if (inlineCSS) {
+    for (const [href, css] of Object.entries(inlineCSS)) {
+      const escapedHref = href.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      const linkPattern = new RegExp(`<link[^>]*href=["']${escapedHref}["'][^>]*>`);
+      const safeCss = css.replace(/<\//g, "<\\/");
+      template = template.replace(linkPattern, `<style data-vertz-css>${safeCss}</style>`);
+    }
+  }
+  return async (request) => {
+    const url = new URL(request.url);
+    const pathname = url.pathname;
+    if (request.headers.get("x-vertz-nav") === "1") {
+      return handleNavRequest(module, pathname, ssrTimeout);
+    }
+    return handleHTMLRequest(module, template, pathname, ssrTimeout, nonce);
+  };
+}
+async function handleNavRequest(module, url, ssrTimeout) {
+  try {
+    const stream = await ssrStreamNavQueries(module, url, { ssrTimeout });
+    return new Response(stream, {
+      status: 200,
+      headers: {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache"
+      }
+    });
+  } catch {
+    return new Response(`event: done
+data: {}
+
+`, {
+      status: 200,
+      headers: {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache"
+      }
+    });
+  }
+}
+async function handleHTMLRequest(module, template, url, ssrTimeout, nonce) {
+  try {
+    const result = await ssrRenderToString(module, url, { ssrTimeout });
+    const html = injectIntoTemplate(template, result.html, result.css, result.ssrData, nonce);
+    return new Response(html, {
+      status: 200,
+      headers: { "Content-Type": "text/html; charset=utf-8" }
+    });
+  } catch {
+    return new Response("Internal Server Error", {
+      status: 500,
+      headers: { "Content-Type": "text/plain" }
+    });
+  }
+}
+
+export { escapeHtml, escapeAttr, serializeToHtml, resetSlotCounter, createSlotPlaceholder, encodeChunk, streamToString, collectStreamChunks, createTemplateChunk, renderToStream, ssrStorage, isInSSR, getSSRUrl, registerSSRQuery, getSSRQueries, setGlobalSSRTimeout, clearGlobalSSRTimeout, getGlobalSSRTimeout, safeSerialize, getStreamingRuntimeScript, createSSRDataChunk, ssrRenderToString, ssrDiscoverQueries, createSSRHandler };