@solidjs/web 2.0.0-beta.3 → 2.0.0-beta.31

package/frames/dist/server.js

@@ -0,0 +1,2508 @@
+import { runWithOwner, createOwner, sharedConfig, createRoot, ssrHandleError, getOwner, NoHydration, runInServerComponentScope, Hydration } from 'solid-js';
+import { toCrossJSONStream, Feature, Serializer, getCrossReferenceHeader, createPlugin } from 'seroval';
+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 serializeOnlyDisabledFeatures = () => process.env.NODE_ENV === "development" ? 0 : Feature.ErrorPrototypeStack;
+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) | serializeOnlyDisabledFeatures()
+  });
+}
+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 serializeJSON(value, {
+  onParse,
+  onDone,
+  onError,
+  ...codecOptions
+}) {
+  const resolved = resolveCodecOptions(codecOptions);
+  return toCrossJSONStream(value, {
+    onParse,
+    onDone,
+    onError,
+    ...resolved,
+    disabledFeatures: resolved.disabledFeatures | serializeOnlyDisabledFeatures()
+  });
+}
+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 | serializeOnlyDisabledFeatures(),
+        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();
+    }
+  };
+}
+
+const HEAD_ELIGIBLE_TAGS = new Set(["title", "meta", "link", "style", "script", "base"]);
+const HEAD_ATTR_NAME = /^[a-zA-Z_][a-zA-Z0-9_:.-]*$/;
+const RESOURCE_LINK_RELS = new Set(["preload", "modulepreload", "prefetch", "preconnect", "dns-prefetch", "stylesheet"]);
+const RESOURCE_QUALIFIERS = ["as", "crossorigin", "type", "media", "imagesrcset", "imagesizes"];
+const STYLESHEET_FETCH_META = new Set(["crossorigin", "integrity", "referrerpolicy", "fetchpriority"]);
+function evalHeadValue(v) {
+  return typeof v === "function" ? v() : v;
+}
+function evalHeadProps(props, presets) {
+  const out = {};
+  for (const name in props) out[name] = presets && name in presets ? presets[name] : evalHeadValue(props[name]);
+  return out;
+}
+function classifyHeadTag(desc) {
+  const tag = desc.tag;
+  if (tag === "link") {
+    const rel = evalHeadValue(desc.props && desc.props.rel);
+    return {
+      resource: RESOURCE_LINK_RELS.has(rel),
+      rel
+    };
+  }
+  if (tag === "style") return {
+    resource: !!(desc.props && "href" in desc.props)
+  };
+  if (tag === "script") return {
+    resource: !!(desc.props && "src" in desc.props)
+  };
+  return {
+    resource: false
+  };
+}
+function resourceIdentity(tag, props) {
+  let id = "res:" + tag + ":" + (props.rel || "") + ":" + (props.href || props.src || "");
+  for (let i = 0; i < RESOURCE_QUALIFIERS.length; i++) {
+    const q = RESOURCE_QUALIFIERS[i];
+    if (props[q] != null) id += ":" + q + "=" + props[q];
+  }
+  return id;
+}
+function replaceableIdentity(tag, props, key, unique) {
+  if (tag === "title") return "title";
+  if (tag === "base") return "base";
+  if (tag === "meta" && props.charset != null) return "charset";
+  if (key != null) return tag + ":key:" + key;
+  if (tag === "meta") {
+    for (const ns of ["name", "property", "http-equiv"]) if (props[ns] != null) return "meta:" + ns + ":" + props[ns] + (props.media != null ? ":media=" + props.media : "");
+    return unique;
+  }
+  if (tag === "link") {
+    const rel = props.rel || "";
+    if (rel === "icon" || rel === "apple-touch-icon") return "link:" + rel + (props.sizes != null ? ":sizes=" + props.sizes : "") + (props.type != null ? ":type=" + props.type : "");
+    return "link:" + rel + ":" + (props.href || "");
+  }
+  return unique;
+}
+function resolveHead(groups) {
+  const winners = new Map();
+  const sorted = groups.slice().sort((a, b) => a.seq - b.seq);
+  for (let i = 0; i < sorted.length; i++) {
+    const group = sorted[i];
+    const byIdentity = new Map();
+    for (let j = 0; j < group.tags.length; j++) {
+      const t = group.tags[j];
+      let list = byIdentity.get(t.identity);
+      if (!list) byIdentity.set(t.identity, list = []);
+      list.push(t);
+    }
+    for (const [identity, tags] of byIdentity) {
+      if (identity === "title") {
+        if (tags.length > 1) console.warn("Multiple <title> tags in one head group; the last one wins.");
+        winners.set(identity, {
+          seq: group.seq,
+          tags: [tags[tags.length - 1]]
+        });
+      } else {
+        winners.set(identity, {
+          seq: group.seq,
+          tags
+        });
+      }
+    }
+  }
+  return winners;
+}
+
+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 warnUnresolvedModuleAssets(moduleUrl, warned) {
+  if (warned.has(moduleUrl)) return;
+  warned.add(moduleUrl);
+  console.error(`Asset manifest returned no client assets for module "${moduleUrl}". ` + "If this module is a server-rendered lazy() component, its entry will be missing from " + "the serialized hydration asset map, the client will be unable to preload it, and " + "hydration will fail with 'lazy() module \"…\" was not preloaded before hydration'. " + "This means the integration's asset resolver (dev manifest bridge or build client " + "manifest) failed to answer for this module — check the integration's server logs, " + "restart the dev server, or verify the module is included in the client build.");
+}
+function guardResolvedAssets(moduleUrl, result, warned) {
+  if (result && typeof result.then === "function") {
+    return result.then(assets => {
+      if (!assets || !assets.js || !assets.js.length) warnUnresolvedModuleAssets(moduleUrl, warned);
+      return assets;
+    });
+  }
+  if (!result || !result.js || !result.js.length) warnUnresolvedModuleAssets(moduleUrl, warned);
+  return result;
+}
+function applyAssetTracking(context, tracking, manifest, noScripts) {
+  const warned = new Set();
+  const guard = noScripts ? resolve => resolve : resolve => moduleUrl => guardResolvedAssets(moduleUrl, resolve(moduleUrl), warned);
+  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 = guard(manifest);
+  } else if (manifest && typeof manifest.resolve === "function") {
+    context.resolveAssets = guard(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 = guard(resolve);
+    context.resolveAssetsSync = resolve;
+  }
+}
+function isCssUrl(url) {
+  const q = url.search(/[?#]/);
+  return (q === -1 ? url : url.slice(0, q)).endsWith(".css");
+}
+function createHeadRegistry() {
+  return {
+    pending: [],
+    committed: [],
+    seq: 0,
+    uniq: 0,
+    resources: new Set(),
+    eagerHtml: "",
+    flushed: null,
+    shellFlushed: false
+  };
+}
+function registerHeadTags(registry, context, tracking, emitResource, nonce, tags) {
+  const boundary = context._currentBoundaryId || "";
+  if (typeof tags === "function") {
+    registry.pending.push({
+      boundary,
+      list: tags,
+      resource: (desc, rel) => emitHeadResource(registry, context, tracking, emitResource, nonce, desc, rel)
+    });
+    return;
+  }
+  if (!Array.isArray(tags)) tags = [tags];
+  let replaceable = null;
+  for (let i = 0; i < tags.length; i++) {
+    const desc = tags[i];
+    if (!desc || !HEAD_ELIGIBLE_TAGS.has(desc.tag)) {
+      console.warn(`useHead: ignoring non-head tag`, desc);
+      continue;
+    }
+    const cls = classifyHeadTag(desc);
+    if (cls.resource) {
+      emitHeadResource(registry, context, tracking, emitResource, nonce, desc, cls.rel);
+    } else {
+      (replaceable || (replaceable = [])).push(cls.rel !== undefined ? {
+        tag: desc.tag,
+        props: desc.props,
+        key: desc.key,
+        rel: cls.rel
+      } : desc);
+    }
+  }
+  if (replaceable) registry.pending.push({
+    boundary,
+    tags: replaceable
+  });
+}
+function emitHeadResource(registry, context, tracking, emitResource, nonce, desc, rel) {
+  let props;
+  try {
+    props = evalHeadProps(desc.props || {}, rel !== undefined ? {
+      rel
+    } : undefined);
+  } catch (err) {
+    console.warn(`useHead: error evaluating resource tag props`, err);
+    return;
+  }
+  const identity = resourceIdentity(desc.tag, props);
+  if (registry.resources.has(identity)) return;
+  registry.resources.add(identity);
+  if (desc.tag === "link" && (rel === "stylesheet" || rel === "modulepreload")) {
+    let plain = true;
+    let gateable = rel === "stylesheet";
+    for (const name in props) {
+      if (name === "rel" || name === "href") continue;
+      plain = false;
+      if (!STYLESHEET_FETCH_META.has(name)) gateable = false;
+    }
+    if (plain && props.href != null) {
+      const isCss = isCssUrl(props.href);
+      if (rel === "stylesheet" ? isCss : !isCss) {
+        context.registerAsset(rel === "stylesheet" ? "style" : "module", props.href);
+        return;
+      }
+    }
+    if (gateable && props.href != null) {
+      const attrHtml = renderHeadAttrHtml(props);
+      const entry = {
+        href: props.href,
+        attrHtml,
+        attrs: headAttrRecord(props)
+      };
+      if (tracking.currentBoundaryId) {
+        let styles = tracking.boundaryStyles.get(tracking.currentBoundaryId);
+        if (!styles) tracking.boundaryStyles.set(tracking.currentBoundaryId, styles = new Set());
+        styles.add(entry);
+      }
+      const markup = `<link${attrHtml}>`;
+      if (emitResource) emitResource(markup, entry);else {
+        registry.eagerHtml += markup;
+        entry.emitted = true;
+      }
+      return;
+    }
+  }
+  const url = props.href || props.src;
+  if (url != null && tracking.emittedAssets.has(url)) return;
+  const markup = renderHeadTagMarkup(desc.tag, props, null, nonce);
+  if (emitResource) emitResource(markup);else registry.eagerHtml += markup;
+}
+function commitHeadBoundary(registry, boundary, isPendingFragment) {
+  const keep = [];
+  const groups = [];
+  for (let i = 0; i < registry.pending.length; i++) {
+    const reg = registry.pending[i];
+    const mine = boundary === "" ? !(isPendingFragment && reg.boundary !== "" && isPendingFragment(reg.boundary)) : reg.boundary === boundary;
+    if (!mine) {
+      keep.push(reg);
+      continue;
+    }
+    let descs = reg.tags;
+    if (reg.list) {
+      let resolved;
+      try {
+        resolved = reg.list();
+      } catch (err) {
+        console.warn(`useHead: error evaluating head group membership`, err);
+        continue;
+      }
+      if (!Array.isArray(resolved)) resolved = [resolved];
+      descs = [];
+      for (let j = 0; j < resolved.length; j++) {
+        const desc = resolved[j];
+        if (!desc || !HEAD_ELIGIBLE_TAGS.has(desc.tag)) {
+          console.warn(`useHead: ignoring non-head tag`, desc);
+          continue;
+        }
+        const cls = classifyHeadTag(desc);
+        if (cls.resource) {
+          reg.resource(desc, cls.rel);
+        } else {
+          descs.push(cls.rel !== undefined ? {
+            tag: desc.tag,
+            props: desc.props,
+            key: desc.key,
+            rel: cls.rel
+          } : desc);
+        }
+      }
+    }
+    const tags = [];
+    for (let j = 0; j < descs.length; j++) {
+      const desc = descs[j];
+      let props, key;
+      try {
+        props = evalHeadProps(desc.props || {}, desc.rel !== undefined ? {
+          rel: desc.rel
+        } : undefined);
+        key = evalHeadValue(desc.key);
+      } catch (err) {
+        console.warn(`useHead: error evaluating tag props`, err);
+        continue;
+      }
+      const identity = replaceableIdentity(desc.tag, props, key, "u:" + registry.uniq++);
+      if ((identity === "base" || identity === "charset") && registry.shellFlushed) {
+        console.warn(`useHead: <${desc.tag}> (${identity}) registered after shell flush is ignored`);
+        continue;
+      }
+      tags.push({
+        tag: desc.tag,
+        props,
+        identity
+      });
+    }
+    if (tags.length) groups.push({
+      seq: registry.seq++,
+      tags
+    });
+  }
+  registry.pending = keep;
+  for (let i = 0; i < groups.length; i++) registry.committed.push(groups[i]);
+  return groups;
+}
+function adoptHeadBoundary(registry, childKey, parentKey) {
+  for (let i = 0; i < registry.pending.length; i++) {
+    if (registry.pending[i].boundary === childKey) registry.pending[i].boundary = parentKey;
+  }
+}
+function dropHeadBoundary(registry, boundary) {
+  registry.pending = registry.pending.filter(reg => reg.boundary !== boundary);
+}
+function headGroupSignature(winner) {
+  let sig = "" + winner.seq;
+  for (let i = 0; i < winner.tags.length; i++) {
+    const t = winner.tags[i];
+    sig += "|" + t.tag + JSON.stringify(t.props);
+  }
+  return sig;
+}
+function renderShellHead(registry, nonce, isPendingFragment) {
+  commitHeadBoundary(registry, "", isPendingFragment);
+  registry.shellFlushed = true;
+  const winners = resolveHead(registry.committed);
+  registry.flushed = new Map();
+  let prelude = "";
+  let links = "";
+  let metas = "";
+  let others = "";
+  let scripts = "";
+  for (const [identity, winner] of winners) {
+    registry.flushed.set(identity, headGroupSignature(winner));
+    for (let i = 0; i < winner.tags.length; i++) {
+      const t = winner.tags[i];
+      const markup = renderHeadTagMarkup(t.tag, t.props, identity, nonce);
+      if (identity === "charset" || identity === "base") prelude += markup;else if (t.tag === "link" || t.tag === "style") links += markup;else if (t.tag === "meta") metas += markup;else if (t.tag === "script") scripts += markup;else others += markup;
+    }
+  }
+  return {
+    prelude,
+    html: registry.eagerHtml + links + metas + others + scripts
+  };
+}
+function flushHeadFragment(registry, boundary) {
+  const groups = commitHeadBoundary(registry, boundary);
+  if (!groups.length) return null;
+  const winners = resolveHead(registry.committed);
+  const affected = new Set();
+  for (let i = 0; i < groups.length; i++) for (let j = 0; j < groups[i].tags.length; j++) affected.add(groups[i].tags[j].identity);
+  const ops = [];
+  for (const identity of affected) {
+    const winner = winners.get(identity);
+    const sig = headGroupSignature(winner);
+    if (registry.flushed.get(identity) === sig) continue;
+    const existed = registry.flushed.has(identity);
+    registry.flushed.set(identity, sig);
+    if (identity === "title") {
+      const children = winner.tags[0].props.children;
+      ops.push(["t", children == null ? "" : String(children)]);
+      continue;
+    }
+    if (existed) ops.push(["r", identity]);
+    for (let i = 0; i < winner.tags.length; i++) {
+      const t = winner.tags[i];
+      const attrs = {};
+      for (const name in t.props) {
+        if (name === "children" || name === "ref" || name.slice(0, 2) === "on") continue;
+        if (!HEAD_ATTR_NAME.test(name)) {
+          console.warn(`useHead: ignoring invalid attribute name "${name}"`);
+          continue;
+        }
+        const v = t.props[name];
+        if (v == null || v === false) continue;
+        attrs[name] = v === true ? "" : String(v);
+      }
+      const children = t.props.children;
+      ops.push(["a", identity, t.tag, attrs, children == null ? null : String(children)]);
+    }
+  }
+  return ops.length ? ops : null;
+}
+function renderHeadAttrHtml(props) {
+  let attrs = "";
+  for (const name in props) {
+    if (name === "children" || name === "ref" || name.slice(0, 2) === "on") continue;
+    if (!HEAD_ATTR_NAME.test(name)) {
+      console.warn(`useHead: ignoring invalid attribute name "${name}"`);
+      continue;
+    }
+    const v = props[name];
+    if (v == null || v === false) continue;
+    attrs += v === true ? ` ${name}` : ` ${name}="${escape(String(v), true)}"`;
+  }
+  return attrs;
+}
+function headAttrRecord(props, skipRelHref) {
+  let attrs = null;
+  for (const name in props) {
+    if (name === "children" || name === "ref" || name.slice(0, 2) === "on") continue;
+    if ((name === "rel" || name === "href")) continue;
+    if (!HEAD_ATTR_NAME.test(name)) continue;
+    const v = props[name];
+    if (v == null || v === false) continue;
+    (attrs || (attrs = {}))[name] = v === true ? "" : String(v);
+  }
+  return attrs;
+}
+function renderHeadTagMarkup(tag, props, identity, nonce) {
+  let attrs = renderHeadAttrHtml(props);
+  if (identity != null) attrs += ` data-dh="${escape(identity, true)}"`;
+  if (nonce && (tag === "script" || tag === "style")) attrs += ` nonce="${nonce}"`;
+  if (tag === "meta" || tag === "link" || tag === "base") return `<${tag}${attrs}>`;
+  let body = props.children == null ? "" : String(props.children);
+  if (tag === "script") body = body.replace(/<\/(script)/gi, "<\\/$1");else if (tag === "style") body = escapeStyleContent(body);else body = escape(body);
+  return `<${tag}${attrs}>${body}</${tag}>`;
+}
+const REPLACE_SCRIPT = `function $df(e){return _$HY.f?_$HY.f(e):$dfr(e)}function $dfr(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;t=o.parentNode,o.replaceWith(n.content),n.remove(),(_$HY.v=_$HY.v||{})[e]=1,_$HY.fe(e,t),_$HY.hp&&_$HY.hp[e]&&($dh(_$HY.hp[e]),delete _$HY.hp[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])}`;
+const HEAD_SCRIPT = `function $dha(o,i,e,n){for(i=0;i<o.length;i++)e=o[i],"t"==e[0]?((n=document.querySelector("title"))||(n=document.createElement("title"),document.head.appendChild(n)),n.textContent=e[1],n.setAttribute("data-dh","title")):"r"==e[0]?$dhr(e[1]):(n=document.createElement(e[2]),Object.keys(e[3]).forEach(function(a){n.setAttribute(a,e[3][a])}),null!=e[4]&&(n.textContent=e[4]),n.setAttribute("data-dh",e[1]),document.head.appendChild(n))}function $dhr(v,l,i){for(l=document.head.querySelectorAll("[data-dh]"),i=0;i<l.length;i++)l[i].getAttribute("data-dh")==v&&l[i].remove()}function $dh(o){_$HY.h?_$HY.h(o):$dha(o)}`;
+function renderToStream(code, options = {}) {
+  let {
+    nonce,
+    onCompleteShell,
+    onCompleteAll,
+    renderId = "",
+    noScripts,
+    manifest,
+    onHead
+  } = options;
+  let dispose;
+  let dead = false;
+  const abandon = () => {
+    if (dead) return;
+    dead = true;
+    completed = true;
+    buffer = {
+      write() {}
+    };
+    writable = {
+      end() {}
+    };
+    if (dispose) {
+      const d = dispose;
+      dispose = () => {};
+      d();
+    }
+  };
+  const guardSink = w => ({
+    write(payload) {
+      if (dead) return;
+      try {
+        w.write(payload);
+      } catch (_) {
+        abandon();
+      }
+    },
+    end() {
+      if (dead) return;
+      try {
+        w.end();
+      } catch (_) {
+        abandon();
+      }
+    }
+  });
+  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 = true;
+      queue(() => queue(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 entry of styles.links) {
+          buffer.write(typeof entry === "string" ? `<link rel="stylesheet" href="${entry}" onload="$dfc('${key}')" onerror="$dfc('${key}')">` : `<link${entry.attrHtml} 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));
+      } else if (type === "head-tag") {
+        buffer.write(value);
+      }
+    },
+    shell(shellHtml, meta) {
+      buffer.write(assembleDocument(shellHtml, meta.assets, meta.preloads, meta.inlineStyles, meta.tasks.length ? meta.tasks : "", nonce, meta.head, onHead));
+    },
+    ...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 = 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();
+  const headRegistry = createHeadRegistry();
+  let headScriptFlushed = false;
+  const emitHeadOps = (key, ops) => {
+    const payload = JSON.stringify(ops).replace(/</g, "\\u003C");
+    emitTask(`${!headScriptFlushed ? HEAD_SCRIPT : ""}(_$HY.hp=_$HY.hp||{})[${JSON.stringify(key)}]=${payload}`);
+    headScriptFlushed = true;
+  };
+  sharedConfig.context = context = {
+    async: true,
+    assets: [],
+    nonce,
+    registerHeadTags(tags) {
+      registerHeadTags(headRegistry, context, tracking,
+      (markup, gateEntry) => {
+        if (!firstFlushed) {
+          headRegistry.eagerHtml += markup;
+          if (gateEntry) gateEntry.emitted = true;
+        } else if (!gateEntry || !tracking.currentBoundaryId) {
+          sink.asset("head-tag", markup);
+        }
+      }, nonce, tags);
+    },
+    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);
+            adoptHeadBoundary(headRegistry, key, parentKey);
+            item.resolve();
+            return;
+          }
+          if (!completed) {
+            if (error) dropHeadBoundary(headRegistry, key);
+            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);
+              const headOps = error ? null : flushHeadFragment(headRegistry, key);
+              if (headOps) emitHeadOps(key, headOps);
+              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, noScripts);
+  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;
+    sharedConfig.context = context;
+    if (!resolveRootHoles()) return;
+    const assetsHtml = resolveAssetsHtml(context.assets);
+    headStyles = new Set();
+    for (const url of tracking.emittedAssets) {
+      if (isCssUrl(url)) headStyles.add(url);
+    }
+    serializeRootAssets();
+    const head = renderShellHead(headRegistry, nonce, k => registry.has(k));
+    sink.shell(html, {
+      assets: assetsHtml,
+      preloads: tracking.emittedAssets,
+      inlineStyles: tracking.inlineStyles,
+      tasks,
+      head
+    });
+    tasks = "";
+    onCompleteShell && onCompleteShell({
+      write(v) {
+        !completed && buffer.write(v);
+      }
+    });
+    shellCompleted = true;
+  }
+  const MIN_DRAIN_TURNS = 8;
+  let lastBlockingSize = -1;
+  let lastRegistrySize = -1;
+  let drainTurn = 0;
+  const scheduleFlush = fn => {
+    const attempt = () => {
+      if (registry.size !== lastRegistrySize || drainTurn++ < MIN_DRAIN_TURNS) {
+        if (registry.size !== lastRegistrySize) drainTurn = 0;
+        lastRegistrySize = registry.size;
+        queue(attempt);
+        return;
+      }
+      fn();
+    };
+    const progressed = blockingPromises.size !== lastBlockingSize;
+    lastBlockingSize = blockingPromises.size;
+    lastRegistrySize = -1;
+    drainTurn = 0;
+    progressed ? queue(attempt) : setTimeout(attempt);
+  };
+  let cachedReadable;
+  let consumer;
+  const claimConsumer = name => {
+    if (consumer && consumer !== name) {
+      throw new Error(`renderToStream result was already consumed via \`${consumer}\`; cannot also consume it via \`${name}\`. Use exactly one of \`pipe\`, \`pipeTo\`, or \`readable\`.`);
+    }
+    consumer = name;
+  };
+  const pipeToImpl = w => {
+    let resolve;
+    const p = new Promise(r => resolve = r);
+    function flush() {
+      allSettled(blockingPromises).then(() => {
+        scheduleFlush(() => {
+          if (dead) return resolve();
+          doShell();
+          if (!shellCompleted) return flush();
+          const encoder = new TextEncoder();
+          const writer = w.getWriter();
+          let pendingWrites = Promise.resolve();
+          let ended = false;
+          const failed = () => {
+            if (!ended) {
+              abandon();
+              resolve();
+            }
+          };
+          writer.closed && writer.closed.catch(failed);
+          writable = {
+            end() {
+              pendingWrites.then(() => {
+                ended = true;
+                writer.releaseLock();
+                w.close().catch(() => {});
+                resolve();
+              });
+            }
+          };
+          buffer = {
+            write(payload) {
+              pendingWrites = pendingWrites.then(() => writer.write(encoder.encode(payload))).catch(failed);
+            }
+          };
+          buffer.write(tmp);
+          firstFlushed = true;
+          if (completed) {
+            dispose();
+            writable.end();
+          } else flushEnd();
+        });
+      });
+    }
+    flush();
+    return p;
+  };
+  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(() => {
+          scheduleFlush(() => {
+            if (!resolveRootHoles()) return flush();
+            queue(flushEnd);
+          });
+        });
+      }
+      flush();
+    },
+    pipe(w) {
+      claimConsumer("pipe");
+      function flush() {
+        allSettled(blockingPromises).then(() => {
+          scheduleFlush(() => {
+            if (dead) return;
+            doShell();
+            if (!shellCompleted) return flush();
+            buffer = writable = guardSink(w);
+            buffer.write(tmp);
+            firstFlushed = true;
+            if (completed) {
+              dispose();
+              writable.end();
+            } else flushEnd();
+          });
+        });
+      }
+      flush();
+    },
+    pipeTo(w) {
+      claimConsumer("pipeTo");
+      return pipeToImpl(w);
+    },
+    get readable() {
+      claimConsumer("readable");
+      if (!cachedReadable) {
+        const t = new TransformStream();
+        pipeToImpl(t.writable);
+        cachedReadable = t.readable;
+      }
+      return cachedReadable;
+    }
+  };
+}
+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 i = s.search(attr ? ESCAPE_ATTR : ESCAPE_CONTENT);
+  if (i < 0) return s;
+  return escapeSlow(s, attr, i);
+}
+const ESCAPE_CONTENT = /[&<]/;
+const ESCAPE_ATTR = /[&"]/;
+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 assembleDocument(html, assetsHtml, emittedAssets, inlineStyles, scripts, nonce, headTags, onHead) {
+  const scriptTag = scripts ? `<script${nonce ? ` nonce="${nonce}"` : ""}>${scripts}</script>` : "";
+  const headTagsHtml = headTags ? headTags.html : "";
+  const headPrelude = headTags ? headTags.prelude : "";
+  if (!onHead && !assetsHtml && !headTagsHtml && !headPrelude && !(emittedAssets && emittedAssets.size) && !(inlineStyles && inlineStyles.size)) {
+    if (!scriptTag) return html;
+    const xs = html.indexOf("<!--xs-->");
+    return xs === -1 ? html + scriptTag : html.slice(0, xs) + scriptTag + html.slice(xs);
+  }
+  if (headPrelude) {
+    const open = html.match(/<head(?:\s[^>]*)?>/);
+    if (open) {
+      const at = open.index + open[0].length;
+      html = html.slice(0, at) + headPrelude + html.slice(at);
+    }
+  }
+  const headIdx = html.indexOf("</head>");
+  if (headIdx === -1) {
+    if (onHead) {
+      onHead(headPrelude + headTagsHtml + (assetsHtml || "") + renderHeadAssets(emittedAssets, inlineStyles, nonce));
+    }
+    if (!scriptTag) return html;
+    const xs = html.indexOf("<!--xs-->");
+    return xs === -1 ? html + scriptTag : html.slice(0, xs) + scriptTag + html.slice(xs);
+  }
+  const head = headTagsHtml + (assetsHtml || "") + renderHeadAssets(emittedAssets, inlineStyles, nonce);
+  if (!scriptTag) return html.slice(0, headIdx) + head + html.slice(headIdx);
+  const xsIdx = html.indexOf("<!--xs-->");
+  if (xsIdx === -1) return html.slice(0, headIdx) + head + html.slice(headIdx) + scriptTag;
+  return xsIdx < headIdx ? html.slice(0, xsIdx) + scriptTag + html.slice(xsIdx, headIdx) + head + html.slice(headIdx) : html.slice(0, headIdx) + head + html.slice(headIdx, xsIdx) + scriptTag + html.slice(xsIdx);
+}
+function renderHeadAssets(emittedAssets, inlineStyles, nonce) {
+  let head = "";
+  if (emittedAssets && emittedAssets.size) {
+    for (const url of emittedAssets) {
+      head += isCssUrl(url) ? `<link rel="stylesheet" href="${url}">` : `<link rel="modulepreload" href="${url}">`;
+    }
+  }
+  if (inlineStyles && inlineStyles.size) {
+    for (const entry of inlineStyles.values()) {
+      if (entry.emitted) continue;
+      entry.emitted = true;
+      head += renderInlineStyle(entry, nonce);
+    }
+  }
+  return head;
+}
+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) {
+      continue;
+    } else if (entry.attrHtml !== undefined) {
+      entry.emitted = true;
+      links.push(entry);
+    } else {
+      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 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 frameAddress(id, args) {
+  return args && args.length ? id + ":" + hashArguments(args) : id;
+}
+function hashArguments(args) {
+  let hash = 0;
+  const text = stableString(args);
+  for (let i = 0; i < text.length; i++) {
+    hash = (hash << 5) - hash + text.charCodeAt(i);
+    hash |= 0;
+  }
+  return (hash >>> 0).toString(36);
+}
+function stableString(value, seen) {
+  if (value === null || typeof value !== "object") {
+    return typeof value === "bigint" ? value + "n" : String(value);
+  }
+  if (value instanceof Date) return "Date:" + value.getTime();
+  seen || (seen = new Set());
+  if (seen.has(value)) return "~";
+  seen.add(value);
+  if (value instanceof Map) {
+    const entries = [];
+    for (const [k, v] of value) {
+      entries.push(stableString(k, seen) + "=>" + stableString(v, seen));
+    }
+    return "Map{" + entries.sort().join(",") + "}";
+  }
+  if (value instanceof Set) {
+    const members = [];
+    for (const v of value) members.push(stableString(v, seen));
+    return "Set{" + members.sort().join(",") + "}";
+  }
+  if (Array.isArray(value)) {
+    let out = "[";
+    for (let i = 0; i < value.length; i++) out += (i ? "," : "") + stableString(value[i], seen);
+    return out + "]";
+  }
+  const keys = Object.keys(value).sort();
+  let out = "{";
+  for (let i = 0; i < keys.length; i++) {
+    out += (i ? "," : "") + keys[i] + ":" + stableString(value[keys[i]], seen);
+  }
+  return out + "}";
+}
+const SINGLE_FLIGHT_HEADER = "X-Single-Flight";
+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;
+}
+class ChunkReader {
+  constructor(stream) {
+    this.reader = stream.getReader();
+    this.buffer = new Uint8Array(0);
+    this.done = false;
+  }
+  async readChunk() {
+    const chunk = await this.reader.read();
+    if (!chunk.done) {
+      const newBuffer = new Uint8Array(this.buffer.length + chunk.value.length);
+      newBuffer.set(this.buffer);
+      newBuffer.set(chunk.value, this.buffer.length);
+      this.buffer = newBuffer;
+    } else {
+      this.done = true;
+    }
+  }
+  async next() {
+    while (this.buffer.length < 12) {
+      if (this.done) {
+        if (this.buffer.length === 0) return {
+          done: true,
+          value: undefined
+        };
+        throw new Error("Malformed server function stream.");
+      }
+      await this.readChunk();
+    }
+    const head = new TextDecoder().decode(this.buffer.subarray(1, 11));
+    const bytes = Number.parseInt(head, 16);
+    if (Number.isNaN(bytes)) {
+      throw new Error("Malformed server function stream.");
+    }
+    while (bytes > this.buffer.length - 12) {
+      if (this.done) {
+        throw new Error("Malformed server function stream.");
+      }
+      await this.readChunk();
+    }
+    const partial = new TextDecoder().decode(this.buffer.subarray(12, 12 + bytes));
+    this.buffer = this.buffer.subarray(12 + bytes);
+    return {
+      done: false,
+      value: partial
+    };
+  }
+  async drain(interpret) {
+    while (true) {
+      const result = await this.next();
+      if (result.done) {
+        break;
+      }
+      interpret(result.value);
+    }
+  }
+}
+function serializeStream(value, codecOptions) {
+  return new ReadableStream({
+    start(controller) {
+      serializeJSON(value, {
+        ...codecOptions,
+        onParse(node) {
+          controller.enqueue(createChunk(JSON.stringify(node)));
+        },
+        onDone() {
+          controller.close();
+        },
+        onError(error) {
+          controller.error(error);
+        }
+      });
+    }
+  });
+}
+
+const ENVELOPE = Symbol.for("solid.ResponseEnvelope");
+function isResponseEnvelope(value) {
+  return !!(value && typeof value === "object" && value[ENVELOPE]);
+}
+
+const INVOCATIONS = new WeakMap();
+function getEventServerFunctionInvocation(event) {
+  return event && INVOCATIONS.get(event);
+}
+
+const FRAME_STREAM_HEADER = "X-Frame-Stream";
+function isFrameStreamResponse(response) {
+  return response.headers.has(FRAME_STREAM_HEADER);
+}
+const SERVER_COMPONENT = /*#__PURE__*/Symbol.for("dom-expressions.server-component");
+const SERVER_COMPONENT_SOURCE = /*#__PURE__*/Symbol.for("dom-expressions.server-component-source");
+const SERVER_COMPONENT_ADDRESS = /*#__PURE__*/Symbol.for("dom-expressions.server-component-address");
+let serverComponentRegistryExpr;
+function setServerComponentBootstrap(resolve) {
+  serverComponentRegistryExpr = resolve;
+}
+function parseServerComponent(value, ctx) {
+  return {
+    id: ctx.parse(value[SERVER_COMPONENT]),
+    address: ctx.parse(value[SERVER_COMPONENT_ADDRESS])
+  };
+}
+const ServerComponentPlugin = /*#__PURE__*/createPlugin({
+  tag: "dom-expressions/server-component",
+  test(value) {
+    return typeof value === "function" && SERVER_COMPONENT in value;
+  },
+  parse: {
+    sync: parseServerComponent,
+    async async(value, ctx) {
+      return {
+        id: await ctx.parse(value[SERVER_COMPONENT]),
+        address: await ctx.parse(value[SERVER_COMPONENT_ADDRESS])
+      };
+    },
+    stream: parseServerComponent
+  },
+  serialize(node, ctx) {
+    const registry = serverComponentRegistryExpr ? serverComponentRegistryExpr(ctx) : "self._$SC";
+    return registry + ".r(" + ctx.serialize(node.id) + "," + ctx.serialize(node.address) + ")";
+  },
+  deserialize(node, ctx) {
+    const id = ctx.deserialize(node.id);
+    ctx.deserialize(node.address);
+    return globalThis._$SC.r(id);
+  }
+});
+function flightCodec(codec) {
+  const plugins = codec && codec.plugins || [];
+  for (const plugin of plugins) {
+    if (plugin && plugin.tag === "dom-expressions/server-component") return codec;
+  }
+  return {
+    ...codec,
+    plugins: [...plugins, ServerComponentPlugin]
+  };
+}
+
+function serverOwned(render) {
+  return NoHydration ? NoHydration({
+    get children() {
+      return render();
+    }
+  }) : render();
+}
+function serverComponentScope(render) {
+  return runInServerComponentScope ? runInServerComponentScope(render) : render();
+}
+const SERVER_COMPONENT_BOOTSTRAP_EXPR = "(self._$SC||(self._$SC={c:{},a:{},r(i,a){a&&(this.a[a]=i,this.reg&&this.reg(a,i));return this.c[i]||(this.c[i]=(p,b)=>self._$SC.impl(i,p,b))}}))";
+const bootstrappedScripts = new WeakSet();
+setServerComponentBootstrap(ctx => {
+  if (bootstrappedScripts.has(ctx)) return "self._$SC";
+  bootstrappedScripts.add(ctx);
+  return SERVER_COMPONENT_BOOTSTRAP_EXPR;
+});
+const SERVER_COMPONENT_BOOTSTRAP = SERVER_COMPONENT_BOOTSTRAP_EXPR + ";";
+function createFrameSink(emit, frame) {
+  const {
+    id,
+    version
+  } = frame;
+  const styledKeys = new Set();
+  const regionKeys = new Map();
+  const frameOf = key => regionKeys.get(key) || id;
+  return {
+    tagRegion(key, childId) {
+      if (!regionKeys.has(key)) regionKeys.set(key, childId);
+    },
+    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 fid = frameOf(key);
+      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: fid,
+          version,
+          key
+        };
+        if (links.length) {
+          chunk.styles = links.map(e => typeof e === "string" ? e : e.attrs ? {
+            href: e.href,
+            attrs: e.attrs
+          } : e.href);
+        }
+        if (inline.length) {
+          chunk.inlineStyles = inline.map(e => ({
+            id: e.id,
+            content: e.content,
+            attrs: e.attrs
+          }));
+        }
+        emit(chunk);
+      }
+      emit({
+        type: "fragment",
+        id: fid,
+        version,
+        key,
+        html: value
+      });
+      if (meta.error) {
+        emit({
+          type: "error",
+          id: fid,
+          version,
+          key,
+          error: {
+            message: String(meta.error && meta.error.message || meta.error)
+          }
+        });
+      }
+      if (!meta.revealGroup) {
+        emit({
+          type: "reveal",
+          id: fid,
+          version,
+          keys: [key],
+          waitForStyles: !!links.length
+        });
+      }
+    },
+    reveal(keys, meta = {}) {
+      const byFrame = new Map();
+      for (const key of keys) {
+        const fid = frameOf(key);
+        let group = byFrame.get(fid);
+        if (!group) byFrame.set(fid, group = []);
+        group.push(key);
+      }
+      for (const [fid, groupKeys] of byFrame) {
+        let waitForStyles = false;
+        for (const key of groupKeys) if (styledKeys.has(key)) waitForStyles = true;
+        const chunk = {
+          type: "reveal",
+          id: fid,
+          version,
+          keys: groupKeys,
+          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 () => serverComponentScope(() => 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-->`
+  };
+}
+const OCCURRENCE_UNSAFE = /[^A-Za-z0-9_.-]/g;
+function encodeOccurrenceKey(key) {
+  return String(key).replace(OCCURRENCE_UNSAFE, c => {
+    const code = c.codePointAt(0);
+    return "%" + (code < 16 ? "0" : "") + code.toString(16);
+  });
+}
+function occurrenceId(prop, raw, counts) {
+  const k = raw.$key;
+  if (typeof k === "string" || typeof k === "number") {
+    return `${prop}#${encodeOccurrenceKey(k)}`;
+  }
+  const n = counts[prop] || 0;
+  counts[prop] = n + 1;
+  return `${prop}#${n}`;
+}
+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];
+          const occurrence = occurrenceId(prop, raw, counts);
+          const slot = clientProps[prop];
+          if (typeof slot !== "function") return range(occurrence, undefined);
+          const resolved = {};
+          const vals = {};
+          for (const key of Object.keys(raw)) {
+            if (key === "$key") continue;
+            let value = raw[key];
+            for (let d = 0; typeof value === "function" && d < 16; d++) value = value();
+            vals[key] = value;
+          }
+          const regions = [];
+          for (const key of Object.keys(vals)) {
+            const value = vals[key];
+            if (isServerContent(value)) {
+              const childId = `${frameId}.${occurrence}.${key}`;
+              const region = {
+                key,
+                childId,
+                value,
+                used: false,
+                locked: false
+              };
+              regions.push(region);
+              resolved[key] = () => {
+                if (region.locked) return [];
+                region.used = true;
+                return [{
+                  t: frameElementOpen(childId)
+                }, value, {
+                  t: FRAME_ELEMENT_CLOSE
+                }];
+              };
+            } else {
+              resolved[key] = value;
+            }
+          }
+          const out = scoped(occurrence, () => range(occurrence, slot(resolved)));
+          const unused = regions.filter(r => !r.used);
+          if (sharedConfig.context) {
+            const args = {};
+            for (const key of Object.keys(vals)) {
+              const value = vals[key];
+              const region = regions.find(r => r.key === key);
+              if (region) {
+                args[key] = {
+                  $frame: region.childId
+                };
+                continue;
+              }
+              if (isServerContent(value)) continue;
+              args[key] = value;
+            }
+            sharedConfig.context.serialize(`sc:slot:${frameId}:${occurrence}`, args);
+            for (const region of unused) {
+              region.locked = true;
+              sharedConfig.context.serialize(`sc:region:${region.childId}`, resolveRegionHtml(sharedConfig.context, region.value));
+            }
+          }
+          return out;
+        };
+        getters.set(prop, fn);
+      }
+      return fn;
+    }
+  });
+}
+const FRAME_TAG = "dx-frame";
+const FRAME_ID_ATTR = "data-fid";
+function frameElementOpen(id) {
+  const escaped = sharedConfig.context ? sharedConfig.context.escape(String(id), true) : String(id);
+  return `<${FRAME_TAG} ${FRAME_ID_ATTR}="${escaped}" style="display:contents">`;
+}
+const FRAME_ELEMENT_CLOSE = `</${FRAME_TAG}>`;
+function frameTransformDirectResult(value, {
+  id,
+  args
+}) {
+  if (typeof value !== "function") return value;
+  const component = value;
+  const wrapped = props => [{
+    t: frameElementOpen(id)
+  },
+  serverOwned(() => {
+    const slotProps = createDocumentSlotProps(props, id);
+    return serverComponentScope(() => component(slotProps));
+  }), {
+    t: FRAME_ELEMENT_CLOSE
+  }];
+  wrapped[SERVER_COMPONENT] = id;
+  wrapped[SERVER_COMPONENT_SOURCE] = component;
+  wrapped[SERVER_COMPONENT_ADDRESS] = frameAddress(id, args);
+  return wrapped;
+}
+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;
+  });
+}
+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];
+          const occurrence = occurrenceId(prop, raw, counts);
+          const args = {};
+          for (const key of Object.keys(raw)) {
+            if (key === "$key") continue;
+            const childId = `${frame.id}.${occurrence}.${key}`;
+            const ctx = sharedConfig.context;
+            const origRegister = ctx.registerFragment;
+            ctx.registerFragment = (fragKey, fragOptions) => {
+              sink.tagRegion(fragKey, childId);
+              return origRegister.call(ctx, fragKey, fragOptions);
+            };
+            try {
+              let value = raw[key];
+              for (let d = 0; typeof value === "function" && d < 16; d++) value = value();
+              const t = typeof value;
+              if (value == null || t === "string" || t === "number" || t === "boolean") {
+                args[key] = value;
+              } else if (isServerContent(value)) {
+                const resolved = ctx.resolve(value);
+                if (resolved.h.length) {
+                  throw new Error("Async server content in a slot arg needs a boundary (arg '" + key + "' of " + occurrence + "). Wrap the async read in a <Suspense>, or move it above the slot.");
+                }
+                sink.region(childId, resolved.t[0]);
+                args[key] = {
+                  $frame: childId
+                };
+              } else {
+                const ref = `arg:${occurrence}:${key}`;
+                ctx.serialize(ref, value);
+                args[key] = {
+                  $ref: ref
+                };
+              }
+            } finally {
+              ctx.registerFragment = origRegister;
+            }
+          }
+          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, context) {
+  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;
+  if (context && context.collectsFlight) return init ? {
+    response: init,
+    value: result
+  } : result;
+  const invocation = getEventServerFunctionInvocation(event);
+  return serverComponentResponse(result, {
+    frame: {
+      id: invocation && invocation.id || ""
+    }
+  }, init);
+}
+async function frameTransformFlightResult(event, outcome, context) {
+  const {
+    value,
+    data
+  } = outcome;
+  const regions = [];
+  let serialized = data;
+  if (data && typeof data === "object") {
+    serialized = {};
+    const keys = Object.keys(data);
+    const values = await Promise.all(keys.map(key => data[key]));
+    for (let i = 0; i < keys.length; i++) {
+      const entry = values[i];
+      serialized[keys[i]] = entry;
+      if (typeof entry === "function") {
+        regions.push({
+          id: entry[SERVER_COMPONENT_ADDRESS] || keys[i],
+          component: entry[SERVER_COMPONENT_SOURCE] || entry
+        });
+      }
+    }
+  }
+  const invocation = getEventServerFunctionInvocation(event);
+  const primary = typeof value === "function" ? {
+    id: invocation && invocation.id || "",
+    component: value
+  } : undefined;
+  if (!primary && !regions.length) return undefined;
+  return frameFlightResponse({
+    primary,
+    regions,
+    outcome: {
+      value: primary ? undefined : value,
+      data: serialized
+    },
+    codec: context && context.codec
+  });
+}
+function frameFlightResponse({
+  primary,
+  regions = [],
+  outcome,
+  codec
+}, init = {}) {
+  const frames = primary ? [primary, ...regions] : regions;
+  const headers = new Headers(init.headers);
+  headers.set("Content-Type", "application/x-frame-stream");
+  headers.set(FRAME_STREAM_HEADER, primary ? primary.id : "");
+  headers.set("X-Content-Raw", "1");
+  headers.set(SINGLE_FLIGHT_HEADER, "true");
+  const body = new ReadableStream({
+    async start(controller) {
+      const write = chunk => controller.enqueue(createChunk(JSON.stringify(chunk)));
+      try {
+        for (const {
+          id,
+          component
+        } of frames) {
+          await new Promise(resolve => {
+            renderServerComponent(component, {
+              frame: {
+                id,
+                version: 1
+              }
+            }).pipe({
+              write,
+              end: resolve
+            });
+          });
+        }
+        if (outcome) {
+          const reader = new ChunkReader(serializeStream(outcome, flightCodec(codec)));
+          for (let node = await reader.next(); !node.done; node = await reader.next()) {
+            write({
+              type: "outcome",
+              payload: node.value
+            });
+          }
+        }
+        controller.close();
+      } catch (err) {
+        controller.error(err);
+      }
+    }
+  });
+  return new Response(body, {
+    status: init.status || 200,
+    headers
+  });
+}
+
+export { FRAME_STREAM_HEADER, SERVER_COMPONENT_BOOTSTRAP, ServerComponentPlugin, createFrameSink, frameTransformDirectResult, frameTransformFlightResult, frameTransformResult, isFrameStreamResponse, renderServerComponent, renderToFrameStream, serverComponentResponse };