@solidjs/web 2.0.0-beta.22 → 2.0.0-beta.23

package/frames/dist/server.js

@@ -0,0 +1,1694 @@
+import { toCrossJSONStream, Feature, Serializer, getCrossReferenceHeader, createPlugin } from 'seroval';
+import { runWithOwner, createOwner, sharedConfig, createRoot, ssrHandleError, getOwner, NoHydration, Hydration } from 'solid-js';
+import { AbortSignalPlugin, CustomEventPlugin, DOMExceptionPlugin, EventPlugin, FormDataPlugin, HeadersPlugin, ReadableStreamPlugin, RequestPlugin, ResponsePlugin, URLSearchParamsPlugin, URLPlugin } from 'seroval-plugins/web';
+
+const runWithHydrationScope = (id, fn) => runWithOwner(createOwner({
+  id
+}), fn);
+
+const DEFAULT_DISABLED_FEATURES = Feature.AggregateError | Feature.BigIntTypedArray;
+const HYDRATION_GLOBAL = "_$HY.r";
+const DEFAULT_WEB_PLUGINS = Object.freeze([AbortSignalPlugin,
+CustomEventPlugin, DOMExceptionPlugin, EventPlugin,
+FormDataPlugin, HeadersPlugin, ReadableStreamPlugin, RequestPlugin, ResponsePlugin, URLSearchParamsPlugin, URLPlugin]);
+function resolveSerializerPlugins(customPlugins) {
+  return customPlugins ? [...customPlugins, ...DEFAULT_WEB_PLUGINS] : [...DEFAULT_WEB_PLUGINS];
+}
+function createSerializer(options) {
+  return new Serializer({
+    ...options,
+    plugins: resolveSerializerPlugins(options.plugins),
+    disabledFeatures: options.disabledFeatures === undefined ? DEFAULT_DISABLED_FEATURES : options.disabledFeatures
+  });
+}
+function createHydrationSerializer({
+  onData,
+  onDone,
+  scopeId,
+  onError,
+  plugins
+}) {
+  return createSerializer({
+    scopeId,
+    plugins,
+    globalIdentifier: HYDRATION_GLOBAL,
+    onData,
+    onDone,
+    onError
+  });
+}
+function getLocalHeaderScript(id) {
+  return getCrossReferenceHeader(id) + ";";
+}
+const JSON_CODEC_DISABLED_FEATURES = Feature.RegExp;
+const JSON_CODEC_DEPTH_LIMIT = 64;
+function resolveCodecOptions({
+  plugins,
+  disabledFeatures,
+  depthLimit
+} = {}) {
+  return {
+    plugins: resolveSerializerPlugins(plugins),
+    disabledFeatures: disabledFeatures === undefined ? JSON_CODEC_DISABLED_FEATURES : disabledFeatures,
+    depthLimit: depthLimit === undefined ? JSON_CODEC_DEPTH_LIMIT : depthLimit
+  };
+}
+function createJSONSerializer({
+  onData,
+  onDone,
+  onError,
+  plugins,
+  disabledFeatures,
+  depthLimit
+}) {
+  const resolved = resolveCodecOptions({
+    plugins,
+    disabledFeatures,
+    depthLimit
+  });
+  const refs = new Map();
+  const cancels = new Set();
+  let pendingWrites = 0;
+  let flushed = false;
+  let done = false;
+  const maybeDone = () => {
+    if (flushed && pendingWrites === 0 && !done) {
+      done = true;
+      onDone && onDone();
+    }
+  };
+  return {
+    write(key, value) {
+      if (flushed) return;
+      pendingWrites++;
+      let settled = false;
+      let cancel = null;
+      const stream = toCrossJSONStream(value, {
+        refs,
+        plugins: resolved.plugins,
+        disabledFeatures: resolved.disabledFeatures,
+        onParse(node, initial) {
+          onData({
+            key,
+            node,
+            initial
+          });
+        },
+        onError,
+        onDone() {
+          settled = true;
+          if (cancel) cancels.delete(cancel);
+          pendingWrites--;
+          maybeDone();
+        }
+      });
+      if (!settled) {
+        cancel = stream;
+        cancels.add(cancel);
+      }
+    },
+    flush() {
+      flushed = true;
+      maybeDone();
+    },
+    close() {
+      flushed = true;
+      for (const cancel of cancels) cancel();
+      cancels.clear();
+    }
+  };
+}
+
+function joinAssetPath(base, file) {
+  if (/^(?:[a-z][a-z0-9+.-]*:)?\/\//i.test(file)) return file;
+  if (typeof base !== "string" || !base) base = "/";
+  if (base[base.length - 1] !== "/") base += "/";
+  return base + (file[0] === "/" ? file.slice(1) : file);
+}
+function resolveAssets(moduleUrl, manifest) {
+  if (!manifest) return null;
+  const base = manifest._base;
+  const entry = manifest[moduleUrl];
+  if (!entry) return null;
+  const css = [];
+  const js = [];
+  const visited = new Set();
+  const walk = key => {
+    if (visited.has(key)) return;
+    visited.add(key);
+    const e = manifest[key];
+    if (!e) return;
+    js.push(joinAssetPath(base, e.file));
+    if (e.css) for (let i = 0; i < e.css.length; i++) css.push(joinAssetPath(base, e.css[i]));
+    if (e.imports) for (let i = 0; i < e.imports.length; i++) walk(e.imports[i]);
+  };
+  walk(moduleUrl);
+  return {
+    js,
+    css
+  };
+}
+function registerEntryAssets(manifest) {
+  if (!manifest || typeof manifest === "function" || typeof manifest.resolve === "function") return;
+  const ctx = sharedConfig.context;
+  if (!ctx?.registerAsset) return;
+  for (const key in manifest) {
+    if (manifest[key].isEntry) {
+      const assets = resolveAssets(key, manifest);
+      if (assets) {
+        for (let i = 0; i < assets.css.length; i++) ctx.registerAsset("style", assets.css[i]);
+      }
+      return;
+    }
+  }
+}
+function createAssetTracking() {
+  const boundaryModules = new Map();
+  const boundaryStyles = new Map();
+  const emittedAssets = new Set();
+  const inlineStyles = new Map();
+  let currentBoundaryId = null;
+  return {
+    boundaryModules,
+    boundaryStyles,
+    emittedAssets,
+    inlineStyles,
+    registerInlineStyle(desc) {
+      let entry = inlineStyles.get(desc.id);
+      if (!entry) {
+        entry = {
+          id: desc.id,
+          content: desc.content || "",
+          attrs: desc.attrs,
+          emitted: false
+        };
+        inlineStyles.set(desc.id, entry);
+      }
+      if (currentBoundaryId) {
+        let styles = boundaryStyles.get(currentBoundaryId);
+        if (!styles) {
+          styles = new Set();
+          boundaryStyles.set(currentBoundaryId, styles);
+        }
+        styles.add(entry);
+      }
+      return entry;
+    },
+    get currentBoundaryId() {
+      return currentBoundaryId;
+    },
+    set currentBoundaryId(v) {
+      currentBoundaryId = v;
+    },
+    registerModule(key, entryUrl) {
+      const id = currentBoundaryId || "";
+      let map = boundaryModules.get(id);
+      if (!map) {
+        map = {};
+        boundaryModules.set(id, map);
+      }
+      map[key] = entryUrl;
+    },
+    getBoundaryModules(id) {
+      return boundaryModules.get(id) || null;
+    },
+    getBoundaryStyles(id) {
+      return boundaryStyles.get(id) || null;
+    }
+  };
+}
+function applyAssetTracking(context, tracking, manifest) {
+  Object.defineProperty(context, "_currentBoundaryId", {
+    get() {
+      return tracking.currentBoundaryId;
+    },
+    set(v) {
+      tracking.currentBoundaryId = v;
+    },
+    configurable: true,
+    enumerable: true
+  });
+  context.registerModule = tracking.registerModule;
+  context.getBoundaryModules = tracking.getBoundaryModules;
+  if (typeof manifest === "function") {
+    context.resolveAssets = manifest;
+  } else if (manifest && typeof manifest.resolve === "function") {
+    context.resolveAssets = key => manifest.resolve(key);
+    if (typeof manifest.resolveSync === "function") {
+      context.resolveAssetsSync = key => manifest.resolveSync(key);
+    }
+  } else if (manifest) {
+    const resolve = moduleUrl => resolveAssets(moduleUrl, manifest);
+    context.resolveAssets = resolve;
+    context.resolveAssetsSync = resolve;
+  }
+}
+const REPLACE_SCRIPT = `function $df(e,n,o,t){if(!(n=document.getElementById(e)))return 0;if(!(o=document.getElementById("pl-"+e)))return(_$HY.dq=_$HY.dq||{})[e]=1,0;for(;o&&(8!==o.nodeType||o.nodeValue!=="pl-"+e);)t=o.nextSibling,o.remove(),o=t;_$HY.done?o.remove():o.replaceWith(n.content),n.remove(),_$HY.fe(e),$dfd();return 1}function $dfl(e,o,n){if(!(o=document.getElementById("pl-"+e)))return(_$HY.dlq=_$HY.dlq||{})[e]=1,0;if(o._$fl)return 1;for(n=o.nextSibling;n;){if(8===n.nodeType&&n.nodeValue==="pl-"+e){o.parentNode&&o.parentNode.insertBefore(o.content.cloneNode(!0),n),o._$fl=1,$dfd();return 1}n=n.nextSibling}return 0}function $dflj(e,i){for(i=0;i<e.length;i++)$dfl(e[i])}function $dfd(e,i){if(e=_$HY.dq){_$HY.dq=0;for(i in e)$df(i)}if(e=_$HY.dlq){_$HY.dlq=0;for(i in e)$dfl(i)}}function $dfs(e,c,d){(_$HY.sc=_$HY.sc||{})[e]=c,d&&((_$HY.sd=_$HY.sd||{})[e]=1)}function $dfg(e,g,i,k){if(!(g=_$HY.sg&&_$HY.sg[e]))return;for(i=0;i<g.length;i++)if(_$HY.sc&&_$HY.sc[g[i]]>0)return;for(i=0;i<g.length;i++)k=g[i],delete _$HY.sg[k],$df(k)}function $dfc(e){if(--_$HY.sc[e]<=0){delete _$HY.sc[e],_$HY.sg&&_$HY.sg[e]?$dfg(e):!(_$HY.sd&&_$HY.sd[e])&&$df(e);_$HY.sd&&delete _$HY.sd[e]}}function $dfj(e,i,n){for(i=0;i<e.length;i++)if(_$HY.sc&&_$HY.sc[e[i]]>0){for(n=0;n<e.length;n++)(_$HY.sg=_$HY.sg||{})[e[n]]=e;return}for(i=0;i<e.length;i++)$df(e[i])}`;
+function renderToStream(code, options = {}) {
+  let {
+    nonce,
+    onCompleteShell,
+    onCompleteAll,
+    renderId = "",
+    noScripts,
+    manifest
+  } = options;
+  let dispose;
+  const blockingPromises = new Set();
+  let headerEmitted = false;
+  const pushTask = task => {
+    if (noScripts) return;
+    if (!headerEmitted) {
+      headerEmitted = true;
+      tasks += getLocalHeaderScript(renderId);
+    }
+    tasks += task + ";";
+    if (!timer && firstFlushed) {
+      timer = setTimeout(writeTasks);
+    }
+  };
+  const onDone = () => {
+    writeTasks();
+    doShell();
+    onCompleteAll && onCompleteAll({
+      write(v) {
+        !completed && buffer.write(v);
+      }
+    });
+    writable && writable.end();
+    completed = true;
+    if (firstFlushed) dispose();
+  };
+  const sink = {
+    data(payload) {
+      pushTask(payload);
+    },
+    fragment(key, value, meta) {
+      const deferActivation = !!meta.revealGroup;
+      const styles = meta.styles;
+      for (let i = 0; i < styles.inline.length; i++) {
+        buffer.write(renderInlineStyle(styles.inline[i], nonce));
+      }
+      if (styles.links.length) {
+        emitTask(`$dfs("${key}",${styles.links.length},${deferActivation ? 1 : 0})`);
+        writeTasks();
+        for (const url of styles.links) {
+          buffer.write(`<link rel="stylesheet" href="${url}" onload="$dfc('${key}')" onerror="$dfc('${key}')">`);
+        }
+        buffer.write(`<template id="${key}">${value}</template>`);
+      } else {
+        buffer.write(`<template id="${key}">${value}</template>`);
+        if (!deferActivation) {
+          emitTask(`$df("${key}")`);
+        }
+      }
+    },
+    reveal(keys, meta) {
+      emitTask(`${meta.fallback ? "$dflj" : "$dfj"}(${JSON.stringify(keys)})`);
+    },
+    asset(type, value) {
+      if (type === "module") {
+        buffer.write(`<link rel="modulepreload" href="${value}">`);
+      } else if (type === "inline-style") {
+        buffer.write(renderInlineStyle(value, nonce));
+      }
+    },
+    shell(shellHtml, meta) {
+      shellHtml = injectBeforeHead(shellHtml, meta.assets);
+      shellHtml = injectPreloadLinks(meta.preloads, shellHtml);
+      shellHtml = injectInlineStyles(meta.inlineStyles, shellHtml, nonce);
+      if (meta.tasks.length) shellHtml = injectScripts(shellHtml, meta.tasks, nonce);
+      buffer.write(shellHtml);
+    },
+    ...options.sink
+  };
+  const serializer = (options.serializer || createHydrationSerializer)({
+    scopeId: options.renderId,
+    plugins: options.plugins,
+    onData: payload => sink.data(payload),
+    onDone,
+    onError: options.onError
+  });
+  let rootAssetsSerialized = false;
+  const serializeRootAssets = () => {
+    if (rootAssetsSerialized) return;
+    rootAssetsSerialized = true;
+    serializeFragmentAssets("", tracking.boundaryModules, context);
+  };
+  const flushEnd = () => {
+    if (!registry.size) {
+      serializeRootAssets();
+      queue(() => queue(() => serializer.flush()));
+    }
+  };
+  const registry = new Map();
+  const writeTasks = () => {
+    if (tasks.length && !completed && firstFlushed) {
+      buffer.write(`<script${nonce ? ` nonce="${nonce}"` : ""}>${tasks}</script>`);
+      tasks = "";
+    }
+    timer && clearTimeout(timer);
+    timer = null;
+  };
+  let context;
+  let writable;
+  let tmp = "";
+  let tasks = "";
+  let firstFlushed = false;
+  let completed = false;
+  let shellCompleted = false;
+  let scriptFlushed = false;
+  let headStyles;
+  const revealGroups = new Map();
+  let timer = null;
+  const emitTask = task => {
+    pushTask(`${task}${!scriptFlushed ? ";" + REPLACE_SCRIPT : ""}`);
+    scriptFlushed = true;
+  };
+  function resolveRevealKeys(groupOrKeys, release, consume) {
+    if (Array.isArray(groupOrKeys)) return groupOrKeys.slice();
+    let group = revealGroups.get(groupOrKeys);
+    if (!group) {
+      if (!release) return;
+      group = {
+        order: [],
+        keys: new Set(),
+        released: true
+      };
+      revealGroups.set(groupOrKeys, group);
+    } else if (release) group.released = true;
+    if (!group.order.length) return;
+    const keys = group.order.slice();
+    if (consume) revealGroups.delete(groupOrKeys);
+    return keys;
+  }
+  let rootHoles = null;
+  let nextHoleId = 0;
+  let buffer = {
+    write(payload) {
+      tmp += payload;
+    }
+  };
+  const tracking = createAssetTracking();
+  sharedConfig.context = context = {
+    async: true,
+    assets: [],
+    nonce,
+    registerAsset(type, value) {
+      if (type === "inline-style") {
+        const entry = tracking.registerInlineStyle(value);
+        if (firstFlushed && !tracking.currentBoundaryId && !entry.emitted) {
+          entry.emitted = true;
+          sink.asset("inline-style", entry);
+        }
+        return;
+      }
+      if (tracking.currentBoundaryId && type === "style") {
+        let styles = tracking.boundaryStyles.get(tracking.currentBoundaryId);
+        if (!styles) {
+          styles = new Set();
+          tracking.boundaryStyles.set(tracking.currentBoundaryId, styles);
+        }
+        styles.add(value);
+      }
+      if (!tracking.emittedAssets.has(value)) {
+        tracking.emittedAssets.add(value);
+        if (firstFlushed) sink.asset(type, value);
+      }
+    },
+    block(p) {
+      if (!firstFlushed) blockingPromises.add(p);
+    },
+    replace(id, payloadFn) {
+      if (firstFlushed) return;
+      const placeholder = `<!--!$${id}-->`;
+      const first = html.indexOf(placeholder);
+      if (first === -1) return;
+      const last = html.indexOf(`<!--!$/${id}-->`, first + placeholder.length);
+      html = html.slice(0, first) + resolveSSRSync(escape(payloadFn())) + html.slice(last + placeholder.length + 1);
+    },
+    serialize(id, p, deferStream) {
+      if (sharedConfig.context.noHydrate) return;
+      if (!firstFlushed && deferStream && typeof p === "object" && "then" in p) {
+        blockingPromises.add(p);
+        p.then(d => serializer.write(id, d)).catch(e => serializer.write(id, e));
+      } else serializer.write(id, p);
+    },
+    escape: escape,
+    resolve: resolveSSRNode,
+    ssr: ssr,
+    registerFragment(key, options) {
+      const revealGroup = options && options.revealGroup;
+      if (revealGroup) {
+        let group = revealGroups.get(revealGroup);
+        if (!group) {
+          group = {
+            order: [],
+            keys: new Set(),
+            released: false
+          };
+          revealGroups.set(revealGroup, group);
+        }
+        if (!group.keys.has(key)) {
+          group.keys.add(key);
+          group.order.push(key);
+        }
+        if (group.released) {
+          throw new Error("registerFragment() for reveal group '" + revealGroup + "' was called after revealFragments(). Ensure template payload is emitted before grouped reveal.");
+        }
+      }
+      if (!registry.has(key)) {
+        let resolve, reject;
+        const p = new Promise((r, rej) => (resolve = r, reject = rej));
+        registry.set(key, {
+          resolve: err => queue(() => queue(() => {
+            err ? reject(err) : resolve(true);
+            queue(flushEnd);
+          }))
+        });
+        serializer.write(key + "_fr", p);
+      }
+      return (value, error) => {
+        if (registry.has(key)) {
+          const item = registry.get(key);
+          registry.delete(key);
+          if (item.children) {
+            for (const k in item.children) {
+              value = replacePlaceholder(value, k, item.children[k]);
+            }
+          }
+          const parentKey = waitForFragments(registry, key);
+          if (parentKey) {
+            const parent = registry.get(parentKey);
+            parent.children ||= {};
+            parent.children[key] = value !== undefined ? value : "";
+            serializeFragmentAssets(key, tracking.boundaryModules, context);
+            propagateBoundaryStyles(key, parentKey, tracking);
+            item.resolve();
+            return;
+          }
+          if (!completed) {
+            if (!firstFlushed) {
+              queue(() => html = replacePlaceholder(html, key, value !== undefined ? value : ""));
+              serializeFragmentAssets(key, tracking.boundaryModules, context);
+              item.resolve(error);
+            } else {
+              serializeFragmentAssets(key, tracking.boundaryModules, context);
+              const styles = collectStreamStyles(key, tracking, headStyles);
+              sink.fragment(key, value !== undefined ? value : " ", {
+                styles,
+                revealGroup,
+                error
+              });
+              item.resolve(error);
+            }
+          }
+        }
+        return firstFlushed;
+      };
+    },
+    revealFragments(groupOrKeys) {
+      const keys = resolveRevealKeys(groupOrKeys, true, true);
+      if (!keys) return;
+      sink.reveal(keys, {
+        fallback: false
+      });
+    },
+    revealFallbacks(groupOrKeys) {
+      const keys = resolveRevealKeys(groupOrKeys, false, false);
+      if (!keys) return;
+      sink.reveal(keys, {
+        fallback: true
+      });
+    }
+  };
+  applyAssetTracking(context, tracking, manifest);
+  registerEntryAssets(manifest);
+  let html = createRoot(d => {
+    dispose = d;
+    const res = resolveSSRNode(escape(code()));
+    if (!res.h.length) return res.t[0];
+    rootHoles = [];
+    let out = res.t[0];
+    for (let i = 0; i < res.h.length; i++) {
+      const id = nextHoleId++;
+      rootHoles.push({
+        id,
+        fn: res.h[i]
+      });
+      out += `<!--rh${id}-->` + res.t[i + 1];
+    }
+    for (const p of res.p) blockingPromises.add(p);
+    return out;
+  }, {
+    id: renderId
+  });
+  function resolveRootHoles() {
+    if (!rootHoles) return true;
+    const pending = [];
+    for (const {
+      id,
+      fn
+    } of rootHoles) {
+      const marker = `<!--rh${id}-->`;
+      const res = resolveSSRNode(fn);
+      if (!res.h.length) {
+        html = html.replace(marker, res.t[0]);
+      } else {
+        let out = res.t[0];
+        for (let j = 0; j < res.h.length; j++) {
+          const newId = nextHoleId++;
+          pending.push({
+            id: newId,
+            fn: res.h[j]
+          });
+          out += `<!--rh${newId}-->` + res.t[j + 1];
+        }
+        html = html.replace(marker, out);
+        for (const p of res.p) blockingPromises.add(p);
+      }
+    }
+    if (pending.length) {
+      rootHoles = pending;
+      return false;
+    }
+    rootHoles = null;
+    return true;
+  }
+  function doShell() {
+    if (shellCompleted) return;
+    if (!resolveRootHoles()) return;
+    sharedConfig.context = context;
+    const assetsHtml = resolveAssetsHtml(context.assets);
+    headStyles = new Set();
+    for (const url of tracking.emittedAssets) {
+      if (url.endsWith(".css")) headStyles.add(url);
+    }
+    serializeRootAssets();
+    sink.shell(html, {
+      assets: assetsHtml,
+      preloads: tracking.emittedAssets,
+      inlineStyles: tracking.inlineStyles,
+      tasks
+    });
+    tasks = "";
+    onCompleteShell && onCompleteShell({
+      write(v) {
+        !completed && buffer.write(v);
+      }
+    });
+    shellCompleted = true;
+  }
+  return {
+    then(fn) {
+      function complete() {
+        dispose();
+        fn(tmp);
+      }
+      if (onCompleteAll) {
+        let ogComplete = onCompleteAll;
+        onCompleteAll = options => {
+          ogComplete(options);
+          complete();
+        };
+      } else onCompleteAll = complete;
+      function flush() {
+        allSettled(blockingPromises).then(() => {
+          setTimeout(() => {
+            if (!resolveRootHoles()) return flush();
+            queue(flushEnd);
+          });
+        });
+      }
+      flush();
+    },
+    pipe(w) {
+      function flush() {
+        allSettled(blockingPromises).then(() => {
+          setTimeout(() => {
+            doShell();
+            if (!shellCompleted) return flush();
+            buffer = writable = w;
+            buffer.write(tmp);
+            firstFlushed = true;
+            if (completed) {
+              dispose();
+              writable.end();
+            } else flushEnd();
+          });
+        });
+      }
+      flush();
+    },
+    pipeTo(w) {
+      let resolve;
+      const p = new Promise(r => resolve = r);
+      function flush() {
+        allSettled(blockingPromises).then(() => {
+          setTimeout(() => {
+            doShell();
+            if (!shellCompleted) return flush();
+            const encoder = new TextEncoder();
+            const writer = w.getWriter();
+            writable = {
+              end() {
+                writer.releaseLock();
+                w.close().catch(() => {});
+                resolve();
+              }
+            };
+            buffer = {
+              write(payload) {
+                writer.write(encoder.encode(payload)).catch(() => {});
+              }
+            };
+            buffer.write(tmp);
+            firstFlushed = true;
+            if (completed) {
+              dispose();
+              writable.end();
+            } else flushEnd();
+          });
+        });
+      }
+      flush();
+      return p;
+    }
+  };
+}
+function buildAsyncWrap(err, node) {
+  const p = ssrHandleError(err);
+  if (!p) return null;
+  const owner = getOwner();
+  return {
+    fn: owner ? () => runWithOwner(owner, node) : node,
+    p
+  };
+}
+function ssrFirstGroupHit(hole) {
+  try {
+    return hole();
+  } catch (err) {
+    return buildAsyncWrap(err, hole);
+  }
+}
+function tryResolveFunctionHole(hole) {
+  let value;
+  try {
+    value = hole();
+  } catch (err) {
+    return buildAsyncWrap(err, hole) || "";
+  }
+  const t = typeof value;
+  if (t === "string") return value;
+  if (t === "number") return "" + value;
+  if (value == null || t === "boolean") return "";
+  return tryResolveString(value);
+}
+function mergeTemplateInto(result, node) {
+  result.t[result.t.length - 1] += node.t[0];
+  if (node.t.length > 1) {
+    result.t.push(...node.t.slice(1));
+    result.h.push(...node.h);
+    result.p.push(...node.p);
+  }
+}
+function appendResolvedNode(result, node) {
+  if (node.fn !== undefined) {
+    result.h.push(node.fn);
+    result.p.push(node.p);
+    result.t.push("");
+  } else if (node.merge !== undefined) mergeTemplateInto(result, node.merge);else resolveSSRNode(node.bail, result);
+}
+let _lastGroupFn = null;
+let _lastGroupArr = null;
+let _lastGroupErr = null;
+function ssrGroupSlot(fn, idx) {
+  return () => {
+    if (idx > 0 && _lastGroupFn === fn) {
+      if (_lastGroupArr !== null) return _lastGroupArr[idx];
+      throw _lastGroupErr;
+    }
+    _lastGroupFn = fn;
+    _lastGroupArr = null;
+    _lastGroupErr = null;
+    try {
+      _lastGroupArr = fn();
+      return _lastGroupArr[idx];
+    } catch (err) {
+      _lastGroupErr = err;
+      throw err;
+    }
+  };
+}
+function ssr(t) {
+  const len = arguments.length;
+  if (len === 1) return {
+    t
+  };
+  let s = t[0];
+  let result = null;
+  let lastGroup = null;
+  let lastGroupVal = null;
+  let lastGroupIdx = 0;
+  for (let i = 1; i < len; i++) {
+    const hole = arguments[i];
+    const ht = typeof hole;
+    if (ht === "string") {
+      if (result === null) s += hole;else result.t[result.t.length - 1] += hole;
+    } else if (ht === "number") {
+      if (result === null) s += hole;else result.t[result.t.length - 1] += hole;
+    } else if (hole == null || ht === "boolean") ; else if (ht === "function" && hole.$g) {
+      let value;
+      let hasValue = false;
+      if (lastGroup !== hole) {
+        const r = ssrFirstGroupHit(hole);
+        if (r !== null) {
+          lastGroup = hole;
+          lastGroupVal = r;
+          lastGroupIdx = 0;
+          if (!Array.isArray(r) && result === null) {
+            result = {
+              t: [s],
+              h: [],
+              p: []
+            };
+            s = "";
+          }
+        }
+      }
+      if (lastGroup === hole) {
+        if (Array.isArray(lastGroupVal)) {
+          value = lastGroupVal[lastGroupIdx++];
+          hasValue = true;
+        } else {
+          result.h.push(ssrGroupSlot(lastGroupVal.fn, lastGroupIdx++));
+          result.p.push(lastGroupVal.p);
+          result.t.push("");
+        }
+      }
+      if (hasValue) {
+        const vt = typeof value;
+        if (vt === "string" || vt === "number") {
+          if (result === null) s += value;else result.t[result.t.length - 1] += value;
+        } else if (value == null || vt === "boolean") ; else if (result !== null) {
+          resolveSSRNode(value, result);
+        } else {
+          const rs = tryResolveString(value);
+          if (typeof rs === "string") {
+            s += rs;
+          } else {
+            result = {
+              t: [s],
+              h: [],
+              p: []
+            };
+            s = "";
+            if (rs.merge !== undefined) mergeTemplateInto(result, rs.merge);else resolveSSRNode(rs.bail, result);
+          }
+        }
+      }
+    } else if (result !== null) {
+      resolveSSRNode(hole, result);
+    } else if (ht === "function") {
+      const r = tryResolveFunctionHole(hole);
+      if (typeof r === "string") s += r;else {
+        result = {
+          t: [s],
+          h: [],
+          p: []
+        };
+        s = "";
+        appendResolvedNode(result, r);
+      }
+    } else {
+      const r = tryResolveString(hole);
+      if (typeof r === "string") {
+        s += r;
+      } else {
+        result = {
+          t: [s],
+          h: [],
+          p: []
+        };
+        s = "";
+        appendResolvedNode(result, r);
+      }
+    }
+    const next = t[i];
+    if (result === null) s += next;else result.t[result.t.length - 1] += next;
+  }
+  if (result === null) return {
+    t: s
+  };
+  return result;
+}
+function escape(s, attr) {
+  const t = typeof s;
+  if (t !== "string") {
+    if (!attr && Array.isArray(s)) {
+      const joined = tryJoinPlainSSRArray(s);
+      if (joined !== undefined) return joined;
+      s = s.slice();
+      for (let i = 0; i < s.length; i++) s[i] = escape(s[i]);
+      return s;
+    }
+    if (attr) {
+      if (s == null || t === "boolean" || t === "number") return s;
+      return escape(String(s), attr);
+    }
+    return s;
+  }
+  const delimCode = attr ? 34 : 60;
+  const len = s.length;
+  for (let i = 0; i < len; i++) {
+    const c = s.charCodeAt(i);
+    if (c === 38 || c === delimCode) return escapeSlow(s, attr, i);
+  }
+  return s;
+}
+function escapeSlow(s, attr, start) {
+  const delim = attr ? '"' : "<";
+  const delimCode = attr ? 34 : 60;
+  const escDelim = attr ? "&quot;" : "&lt;";
+  const c0 = s.charCodeAt(start);
+  let iDelim = c0 === delimCode ? start : s.indexOf(delim, start);
+  let iAmp = c0 === 38 ? start : s.indexOf("&", start);
+  let left = 0,
+    out = "";
+  while (iDelim >= 0 && iAmp >= 0) {
+    if (iDelim < iAmp) {
+      if (left < iDelim) out += s.substring(left, iDelim);
+      out += escDelim;
+      left = iDelim + 1;
+      iDelim = s.indexOf(delim, left);
+    } else {
+      if (left < iAmp) out += s.substring(left, iAmp);
+      out += "&amp;";
+      left = iAmp + 1;
+      iAmp = s.indexOf("&", left);
+    }
+  }
+  if (iDelim >= 0) {
+    do {
+      if (left < iDelim) out += s.substring(left, iDelim);
+      out += escDelim;
+      left = iDelim + 1;
+      iDelim = s.indexOf(delim, left);
+    } while (iDelim >= 0);
+  } else while (iAmp >= 0) {
+    if (left < iAmp) out += s.substring(left, iAmp);
+    out += "&amp;";
+    left = iAmp + 1;
+    iAmp = s.indexOf("&", left);
+  }
+  return left < s.length ? out + s.substring(left) : out;
+}
+function tryJoinPlainSSRArray(nodes) {
+  if (nodes.length === 0) return undefined;
+  let out = "";
+  for (let i = 0, len = nodes.length; i < len; i++) {
+    const node = nodes[i];
+    if (node == null || typeof node !== "object" || node.h || typeof node.t !== "string") {
+      return undefined;
+    }
+    out += node.t;
+  }
+  return out;
+}
+function queue(fn) {
+  return Promise.resolve().then(fn);
+}
+function allSettled(promises) {
+  let size = promises.size;
+  return Promise.allSettled(promises).then(() => {
+    if (promises.size !== size) return allSettled(promises);
+    return;
+  });
+}
+function resolveAssetsHtml(assets) {
+  if (!assets || !assets.length) return "";
+  let out = "";
+  for (let i = 0, len = assets.length; i < len; i++) out += assets[i]();
+  return out;
+}
+function injectBeforeHead(html, content) {
+  if (!content) return html;
+  const index = html.indexOf("</head>");
+  if (index === -1) return html;
+  return html.slice(0, index) + content + html.slice(index);
+}
+function injectPreloadLinks(emittedAssets, html, nonce) {
+  if (!emittedAssets.size) return html;
+  let links = "";
+  for (const url of emittedAssets) {
+    if (url.endsWith(".css")) {
+      links += `<link rel="stylesheet" href="${url}">`;
+    } else {
+      links += `<link rel="modulepreload" href="${url}">`;
+    }
+  }
+  const index = html.indexOf("</head>");
+  if (index === -1) return html;
+  return html.slice(0, index) + links + html.slice(index);
+}
+function serializeFragmentAssets(key, boundaryModules, context) {
+  const map = boundaryModules.get(key);
+  if (!map || !Object.keys(map).length) return;
+  context.serialize(key + "_assets", map);
+}
+function propagateBoundaryStyles(childKey, parentKey, tracking) {
+  const childStyles = tracking.getBoundaryStyles(childKey);
+  if (!childStyles) return;
+  let parentStyles = tracking.boundaryStyles.get(parentKey);
+  if (!parentStyles) {
+    parentStyles = new Set();
+    tracking.boundaryStyles.set(parentKey, parentStyles);
+  }
+  for (const url of childStyles) {
+    parentStyles.add(url);
+  }
+}
+function collectStreamStyles(key, tracking, headStyles) {
+  const styles = tracking.getBoundaryStyles(key);
+  const links = [];
+  const inline = [];
+  if (!styles) return {
+    links,
+    inline
+  };
+  for (const entry of styles) {
+    if (typeof entry === "string") {
+      if (!headStyles || !headStyles.has(entry)) links.push(entry);
+    } else if (!entry.emitted) {
+      entry.emitted = true;
+      inline.push(entry);
+    }
+  }
+  return {
+    links,
+    inline
+  };
+}
+function escapeStyleContent(content) {
+  return content.replace(/<\/(style)/gi, "<\\/$1");
+}
+function renderInlineStyle(entry, nonce) {
+  let attrs = "";
+  if (entry.attrs) {
+    for (const name in entry.attrs) {
+      attrs += ` ${name}="${escape(String(entry.attrs[name]), true)}"`;
+    }
+  }
+  return `<style${nonce ? ` nonce="${nonce}"` : ""} data-asset="${escape(entry.id, true)}"${attrs}>${escapeStyleContent(entry.content)}</style>`;
+}
+function injectInlineStyles(inlineStyles, html, nonce) {
+  if (!inlineStyles.size) return html;
+  const index = html.indexOf("</head>");
+  if (index === -1) return html;
+  let out = "";
+  for (const entry of inlineStyles.values()) {
+    if (entry.emitted) continue;
+    entry.emitted = true;
+    out += renderInlineStyle(entry, nonce);
+  }
+  return out ? html.slice(0, index) + out + html.slice(index) : html;
+}
+function injectScripts(html, scripts, nonce) {
+  const tag = `<script${nonce ? ` nonce="${nonce}"` : ""}>${scripts}</script>`;
+  const index = html.indexOf("<!--xs-->");
+  if (index > -1) {
+    return html.slice(0, index) + tag + html.slice(index);
+  }
+  return html + tag;
+}
+function waitForFragments(registry, key) {
+  for (const k of [...registry.keys()].reverse()) {
+    if (key.startsWith(k)) return k;
+  }
+  return false;
+}
+function replacePlaceholder(html, key, value) {
+  const marker = `<template id="pl-${key}">`;
+  const close = `<!--pl-${key}-->`;
+  const first = html.indexOf(marker);
+  if (first === -1) return html;
+  const last = html.indexOf(close, first + marker.length);
+  return html.slice(0, first) + value + html.slice(last + close.length);
+}
+function tryResolveString(node) {
+  const t = typeof node;
+  if (t === "string") return node;
+  if (t === "number") return "" + node;
+  if (node == null || t === "boolean") return "";
+  if (t === "object") {
+    if (Array.isArray(node)) {
+      const joined = tryJoinPlainSSRArray(node);
+      if (joined !== undefined) return joined;
+      let s = "";
+      let prevNonObj = false;
+      for (let i = 0, len = node.length; i < len; i++) {
+        const item = node[i];
+        const itemNonObj = item !== null && typeof item !== "object";
+        if (prevNonObj && itemNonObj) s += "<!--!$-->";
+        prevNonObj = itemNonObj;
+        const r = tryResolveString(item);
+        if (typeof r !== "string") return {
+          bail: node
+        };
+        s += r;
+      }
+      return s;
+    }
+    if (node.h && node.h.length > 0) return {
+      merge: node
+    };
+    if (node.t === undefined) {
+      console.warn(`Unrecognized value. Skipped inserting`, node);
+      return "";
+    }
+    return Array.isArray(node.t) ? node.t[0] : node.t;
+  }
+  if (t === "function") {
+    let v;
+    try {
+      v = node();
+    } catch (err) {
+      return buildAsyncWrap(err, node) || "";
+    }
+    return tryResolveString(v);
+  }
+  return "";
+}
+function resolveSSRNode(node, result = {
+  t: [""],
+  h: [],
+  p: []
+}, top) {
+  const t = typeof node;
+  if (t === "string" || t === "number") {
+    result.t[result.t.length - 1] += node;
+  } else if (node == null || t === "boolean") ; else if (Array.isArray(node)) {
+    let prevNonObj = false;
+    for (let i = 0, len = node.length; i < len; i++) {
+      const item = node[i];
+      const itemNonObj = item !== null && typeof item !== "object";
+      if (!top && prevNonObj && itemNonObj) result.t[result.t.length - 1] += `<!--!$-->`;
+      prevNonObj = itemNonObj;
+      resolveSSRNode(item, result);
+    }
+  } else if (t === "object") {
+    if (node.h) {
+      result.t[result.t.length - 1] += node.t[0];
+      if (node.t.length > 1) {
+        result.t.push(...node.t.slice(1));
+        result.h.push(...node.h);
+        result.p.push(...node.p);
+      }
+    } else if (node.t !== undefined) {
+      result.t[result.t.length - 1] += node.t;
+    } else console.warn(`Unrecognized value. Skipped inserting`, node);
+  } else if (t === "function") {
+    try {
+      resolveSSRNode(node(), result);
+    } catch (err) {
+      const wrap = buildAsyncWrap(err, node);
+      if (wrap) {
+        result.h.push(wrap.fn);
+        result.p.push(wrap.p);
+        result.t.push("");
+      }
+    }
+  }
+  return result;
+}
+function resolveSSRSync(node) {
+  const res = resolveSSRNode(node);
+  if (!res.h.length) return res.t[0];
+  throw new Error("This value cannot be rendered synchronously. Are you missing a boundary?");
+}
+
+function createChunk(data) {
+  const encodeData = new TextEncoder().encode(data);
+  const bytes = encodeData.length;
+  const baseHex = bytes.toString(16);
+  const totalHex = "00000000".substring(0, 8 - baseHex.length) + baseHex;
+  const head = new TextEncoder().encode(`;0x${totalHex};`);
+  const chunk = new Uint8Array(12 + bytes);
+  chunk.set(head);
+  chunk.set(encodeData, 12);
+  return chunk;
+}
+
+const ENVELOPE = Symbol.for("solid.ResponseEnvelope");
+function isResponseEnvelope(value) {
+  return !!(value && typeof value === "object" && value[ENVELOPE]);
+}
+
+const FRAME_STREAM_HEADER = "X-Frame-Stream";
+function isFrameStreamResponse(response) {
+  return response.headers.has(FRAME_STREAM_HEADER);
+}
+
+function serverOwned(render) {
+  return NoHydration ? NoHydration({
+    get children() {
+      return render();
+    }
+  }) : render();
+}
+function createFrameSink(emit, frame) {
+  const {
+    id,
+    version
+  } = frame;
+  const styledKeys = new Set();
+  return {
+    shell(html, meta = {}) {
+      if (meta.preloads && meta.preloads.size) {
+        const styles = [];
+        const modules = [];
+        for (const url of meta.preloads) {
+          (url.endsWith(".css") ? styles : modules).push(url);
+        }
+        const chunk = {
+          type: "assets",
+          id,
+          version,
+          key: ""
+        };
+        if (styles.length) chunk.styles = styles;
+        if (modules.length) chunk.modules = modules;
+        emit(chunk);
+      }
+      emit({
+        type: "html",
+        id,
+        version,
+        html
+      });
+    },
+    data(record) {
+      if (record && typeof record.key === "string" && (record.key.endsWith("_fr") || /^\d+$/.test(record.key))) {
+        return;
+      }
+      if (typeof record === "string") {
+        emit({
+          type: "data",
+          id,
+          version,
+          payload: record
+        });
+      } else {
+        emit({
+          type: "data",
+          id,
+          version,
+          key: record.key,
+          node: record.node,
+          initial: record.initial
+        });
+      }
+    },
+    fragment(key, value, meta = {}) {
+      const links = meta.styles && meta.styles.links || [];
+      const inline = meta.styles && meta.styles.inline || [];
+      if (links.length || inline.length) {
+        if (links.length) styledKeys.add(key);
+        const chunk = {
+          type: "assets",
+          id,
+          version,
+          key
+        };
+        if (links.length) chunk.styles = links;
+        if (inline.length) {
+          chunk.inlineStyles = inline.map(e => ({
+            id: e.id,
+            content: e.content,
+            attrs: e.attrs
+          }));
+        }
+        emit(chunk);
+      }
+      emit({
+        type: "fragment",
+        id,
+        version,
+        key,
+        html: value
+      });
+      if (meta.error) {
+        emit({
+          type: "error",
+          id,
+          version,
+          key,
+          error: {
+            message: String(meta.error && meta.error.message || meta.error)
+          }
+        });
+      }
+      if (!meta.revealGroup) {
+        emit({
+          type: "reveal",
+          id,
+          version,
+          keys: [key],
+          waitForStyles: !!links.length
+        });
+      }
+    },
+    reveal(keys, meta = {}) {
+      let waitForStyles = false;
+      for (const key of keys) if (styledKeys.has(key)) waitForStyles = true;
+      const chunk = {
+        type: "reveal",
+        id,
+        version,
+        keys,
+        waitForStyles
+      };
+      if (meta.fallback) chunk.fallback = true;
+      emit(chunk);
+    },
+    asset(type, url) {
+      if (type !== "module") return;
+      emit({
+        type: "assets",
+        id,
+        version,
+        key: "",
+        modules: [url]
+      });
+    },
+    end() {
+      emit({
+        type: "complete",
+        id,
+        version
+      });
+    },
+    error(errorId, error) {
+      emit({
+        type: "error",
+        id,
+        version,
+        key: errorId,
+        error
+      });
+    },
+    slot(key, args) {
+      emit({
+        type: "slot",
+        id,
+        version,
+        key,
+        args
+      });
+    },
+    region(childId, html) {
+      emit({
+        type: "html",
+        id: childId,
+        version,
+        html
+      });
+    }
+  };
+}
+function renderToFrameStream(code, options = {}) {
+  return frameStream(() => code, options);
+}
+function renderServerComponent(component, options = {}) {
+  return frameStream((sink, frame) => {
+    const props = createSlotProps(sink, frame);
+    return () => component(props);
+  }, options);
+}
+function frameStream(makeCode, options) {
+  const {
+    id = "",
+    version = 1
+  } = options.frame || {};
+  const frame = {
+    id,
+    version
+  };
+  function stream(w) {
+    const emit = chunk => w.write(chunk);
+    const sink = createFrameSink(emit, frame);
+    emit({
+      type: "start",
+      id,
+      version
+    });
+    const code = makeCode(sink, frame);
+    try {
+      renderToStream(() => serverOwned(code), {
+        serializer: createJSONSerializer,
+        ...options,
+        sink
+      }).pipe({
+        write() {},
+        end() {
+          sink.end();
+          w.end && w.end();
+        }
+      });
+    } catch (err) {
+      sink.error("", err instanceof Error ? err.message : String(err));
+      sink.end();
+      w.end && w.end();
+    }
+  }
+  return {
+    pipe: stream,
+    then(onFulfilled, onRejected) {
+      return new Promise((resolve, reject) => {
+        const chunks = [];
+        try {
+          stream({
+            write: chunk => chunks.push(chunk),
+            end: () => resolve(chunks)
+          });
+        } catch (err) {
+          reject(err);
+        }
+      }).then(onFulfilled, onRejected);
+    }
+  };
+}
+function slotRange(occurrence) {
+  return {
+    t: `<!--slot:${occurrence}:start--><!--slot:${occurrence}:end-->`
+  };
+}
+function createDocumentSlotProps(clientProps, frameId) {
+  const counts = Object.create(null);
+  const getters = new Map();
+  const range = (occurrence, content) => [{
+    t: `<!--slot:${occurrence}:start-->`
+  }, content, {
+    t: `<!--slot:${occurrence}:end-->`
+  }];
+  const zoneOwner = getOwner ? getOwner() : null;
+  const scoped = (occurrence, render) => {
+    const id = `sc-${frameId}-${occurrence}-`;
+    const run = () => Hydration ? Hydration({
+      id,
+      get children() {
+        return render();
+      }
+    }) : runWithHydrationScope(id, render);
+    return zoneOwner ? runWithOwner(zoneOwner, run) : run();
+  };
+  return new Proxy(Object.create(null), {
+    has() {
+      return true;
+    },
+    get(_, prop) {
+      if (typeof prop !== "string") return undefined;
+      if (prop === "then") return undefined;
+      let fn = getters.get(prop);
+      if (!fn) {
+        fn = (...callArgs) => {
+          if (callArgs.length === 0 || callArgs[0] === undefined) {
+            return scoped(prop, () => {
+              const value = clientProps[prop];
+              return range(prop, typeof value === "function" ? value() : value);
+            });
+          }
+          const raw = callArgs[0];
+          let occurrence;
+          const k = raw.$key;
+          if (typeof k === "string" || typeof k === "number") {
+            occurrence = `${prop}#${k}`;
+          } else {
+            const n = counts[prop] || 0;
+            counts[prop] = n + 1;
+            occurrence = `${prop}#${n}`;
+          }
+          const slot = clientProps[prop];
+          if (typeof slot !== "function") return range(occurrence, undefined);
+          const resolved = {};
+          const regions = [];
+          for (const key of Object.keys(raw)) {
+            const value = raw[key];
+            if (key !== "$key" && isServerContent(value)) {
+              const childId = `${frameId}.${occurrence}.${key}`;
+              const region = {
+                key,
+                childId,
+                value,
+                used: false
+              };
+              regions.push(region);
+              resolved[key] = () => {
+                region.used = true;
+                return [{
+                  t: `<!--frame:${childId}:start-->`
+                }, value, {
+                  t: `<!--frame:${childId}:end-->`
+                }];
+              };
+            } else {
+              resolved[key] = value;
+            }
+          }
+          const out = scoped(occurrence, () => range(occurrence, slot(resolved)));
+          const unused = regions.filter(r => !r.used);
+          if (sharedConfig.context) {
+            const rendered = renderedHtmlOf(out);
+            const args = {};
+            let any = false;
+            for (const key of Object.keys(raw)) {
+              const value = raw[key];
+              if (key === "$key") continue;
+              const region = regions.find(r => r.key === key);
+              if (region) {
+                if (!region.used) {
+                  args[key] = {
+                    $frame: region.childId
+                  };
+                  any = true;
+                }
+                continue;
+              }
+              if (isServerContent(value)) continue;
+              const t = typeof value;
+              if ((t === "string" || t === "number") && rendered !== null) {
+                const needle = t === "string" ? sharedConfig.context.escape(String(value)) : String(value);
+                if (needle !== "" && rendered.includes(needle)) continue;
+              }
+              args[key] = value;
+              any = true;
+            }
+            if (any) sharedConfig.context.serialize(`sc:slot:${frameId}:${occurrence}`, args);
+            for (const region of unused) {
+              sharedConfig.context.serialize(`sc:region:${region.childId}`, resolveRegionHtml(sharedConfig.context, region.value));
+            }
+          }
+          return out;
+        };
+        getters.set(prop, fn);
+      }
+      return fn;
+    }
+  });
+}
+function frameTransformDirectResult(value, {
+  id
+}) {
+  if (typeof value !== "function") return value;
+  const component = value;
+  const wrapped = props => [{
+    t: `<!--frame:${id}:start-->`
+  }, serverOwned(() => component(createDocumentSlotProps(props, id))), {
+    t: `<!--frame:${id}:end-->`
+  }];
+  wrapped[SERVER_COMPONENT] = id;
+  return wrapped;
+}
+function renderedHtmlOf(out) {
+  try {
+    const res = sharedConfig.context.resolve(out);
+    if (res && res.t && (!res.h || !res.h.length)) {
+      return res.t[0].replace(/<!--[^>]*-->/g, "");
+    }
+  } catch (e) {}
+  return null;
+}
+function resolveRegionHtml(ctx, node) {
+  const res = ctx.resolve(node);
+  if (!res || !res.t) return String(res ?? "");
+  if (!res.h || !res.h.length) return res.t[0];
+  return Promise.all(res.p).then(() => {
+    let out = Promise.resolve(res.t[0]);
+    for (let i = 0; i < res.h.length; i++) {
+      const hole = res.h[i];
+      const tail = res.t[i + 1];
+      out = out.then(acc => Promise.resolve(resolveRegionHtml(ctx, hole)).then(part => acc + part + tail));
+    }
+    return out;
+  });
+}
+const SERVER_COMPONENT = /*#__PURE__*/Symbol.for("dom-expressions.server-component");
+const ServerComponentPlugin = /*#__PURE__*/createPlugin({
+  tag: "dom-expressions/server-component",
+  test(value) {
+    return typeof value === "function" && SERVER_COMPONENT in value;
+  },
+  parse: {
+    sync(value, ctx) {
+      return {
+        id: ctx.parse(value[SERVER_COMPONENT])
+      };
+    },
+    async async(value, ctx) {
+      return {
+        id: await ctx.parse(value[SERVER_COMPONENT])
+      };
+    },
+    stream(value, ctx) {
+      return {
+        id: ctx.parse(value[SERVER_COMPONENT])
+      };
+    }
+  },
+  serialize(node, ctx) {
+    return "self._$SC.r(" + ctx.serialize(node.id) + ")";
+  },
+  deserialize(node, ctx) {
+    return globalThis._$SC.r(ctx.deserialize(node.id));
+  }
+});
+const SERVER_COMPONENT_BOOTSTRAP = "self._$SC={c:{},r(i){return this.c[i]||(this.c[i]=(p)=>self._$SC.impl(i,p))}};";
+function isServerContent(value) {
+  if (value && typeof value === "object") {
+    if ("t" in value) return true;
+    if (Array.isArray(value) && value.length > 0) {
+      for (const item of value) {
+        if (!(item && typeof item === "object" && "t" in item)) return false;
+      }
+      return true;
+    }
+  }
+  return false;
+}
+function createSlotProps(sink, frame) {
+  const counts = Object.create(null);
+  const getters = new Map();
+  return new Proxy(Object.create(null), {
+    has() {
+      return true;
+    },
+    get(_, prop) {
+      if (typeof prop !== "string") return undefined;
+      if (prop === "then") return undefined;
+      let fn = getters.get(prop);
+      if (!fn) {
+        fn = (...callArgs) => {
+          if (callArgs.length === 0 || callArgs[0] === undefined) {
+            return slotRange(prop);
+          }
+          const raw = callArgs[0];
+          let occurrence;
+          const k = raw.$key;
+          if (typeof k === "string" || typeof k === "number") {
+            occurrence = `${prop}#${k}`;
+          } else {
+            const n = counts[prop] || 0;
+            counts[prop] = n + 1;
+            occurrence = `${prop}#${n}`;
+          }
+          const args = {};
+          for (const key of Object.keys(raw)) {
+            const value = raw[key];
+            const t = typeof value;
+            if (value == null || t === "string" || t === "number" || t === "boolean") {
+              args[key] = value;
+            } else if (isServerContent(value)) {
+              const resolved = sharedConfig.context.resolve(value);
+              if (resolved.h.length) {
+                throw new Error("Async server content in slot args is not supported yet (arg '" + key + "' of " + occurrence + "). Move the async read above the slot or into a fragment.");
+              }
+              const childId = `${frame.id}.${occurrence}.${key}`;
+              sink.region(childId, resolved.t[0]);
+              args[key] = {
+                $frame: childId
+              };
+            } else {
+              const ref = `arg:${occurrence}:${key}`;
+              sharedConfig.context.serialize(ref, value);
+              args[key] = {
+                $ref: ref
+              };
+            }
+          }
+          sink.slot(occurrence, args);
+          return slotRange(occurrence);
+        };
+        getters.set(prop, fn);
+      }
+      return fn;
+    }
+  });
+}
+function serverComponentResponse(component, options = {}, init = {}) {
+  const {
+    id = "",
+    version = 1
+  } = options.frame || {};
+  const headers = new Headers(init.headers);
+  headers.set("Content-Type", "application/x-frame-stream");
+  headers.set(FRAME_STREAM_HEADER, id);
+  headers.set("X-Content-Raw", "1");
+  const stream = renderServerComponent(component, {
+    ...options,
+    frame: {
+      id,
+      version
+    }
+  });
+  const body = new ReadableStream({
+    start(controller) {
+      stream.pipe({
+        write(chunk) {
+          controller.enqueue(createChunk(JSON.stringify(chunk)));
+        },
+        end() {
+          controller.close();
+        }
+      });
+    }
+  });
+  return new Response(body, {
+    status: init.status || 200,
+    headers
+  });
+}
+function frameTransformResult(event, result) {
+  let init;
+  if (isResponseEnvelope(result)) {
+    const {
+      response,
+      value
+    } = result;
+    if (typeof value !== "function") return result;
+    init = response ? {
+      headers: response.headers,
+      status: response.status
+    } : undefined;
+    result = value;
+  }
+  if (typeof result !== "function") return result;
+  const meta = event && event.locals && event.locals.serverFunctionMeta;
+  return serverComponentResponse(result, {
+    frame: {
+      id: meta && meta.id || ""
+    }
+  }, init);
+}
+
+export { FRAME_STREAM_HEADER, SERVER_COMPONENT_BOOTSTRAP, ServerComponentPlugin, createFrameSink, frameTransformDirectResult, frameTransformResult, isFrameStreamResponse, renderServerComponent, renderToFrameStream, serverComponentResponse };