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

package/frames/dist/client.dev.cjs

@@ -0,0 +1,1759 @@
+'use strict';
+
+var solidJs = require('solid-js');
+var web$1 = require('@solidjs/web');
+var seroval = require('seroval');
+var client = require('@solidjs/web/server-functions/client');
+var web = require('seroval-plugins/web');
+
+const ELEMENT_NODE = 1;
+const TEXT_NODE = 3;
+const COMMENT_NODE = 8;
+const CLAIM_SEAM = Symbol.for("dom-expressions.element-claims");
+const CLAIMED_ELEMENTS = "a[href], form[action]";
+function claimHandlers() {
+  const handlers = globalThis[CLAIM_SEAM];
+  return handlers !== undefined && handlers.length !== 0 ? handlers : undefined;
+}
+function claimNode(handlers, el) {
+  for (let i = 0; i < handlers.length; i++) handlers[i](el);
+}
+const claimedAttr = name => name === "href" || name === "action";
+function claimTree(handlers, root) {
+  const isElement = root.nodeType === ELEMENT_NODE;
+  if (!isElement && root.nodeType !== 11 ) return;
+  if (isElement && root.matches(CLAIMED_ELEMENTS)) claimNode(handlers, root);
+  const found = root.querySelectorAll(CLAIMED_ELEMENTS);
+  for (let i = 0; i < found.length; i++) claimNode(handlers, found[i]);
+}
+const placeholderId = name => `pl-${name}`;
+const SLOT_START = /^slot:(.+):start$/;
+const SLOT_END = /^slot:(.+):end$/;
+const slotEnd = id => `slot:${id}:end`;
+function chunkToRecords(chunk) {
+  switch (chunk.type) {
+    case "start":
+    case "data":
+      return {};
+    case "html":
+      return {
+        "": {
+          kind: "html",
+          value: chunk.html
+        }
+      };
+    case "fragment":
+      return {
+        [`seg:${chunk.key}`]: {
+          kind: "html",
+          value: chunk.html
+        }
+      };
+    case "reveal":
+      {
+        const records = {};
+        const gate = chunk.fallback ? "fallback" : "reveal";
+        for (const key of chunk.keys) records[`seg:${key}:${gate}`] = true;
+        return records;
+      }
+    case "assets":
+      return {
+        [`seg:${chunk.key}:assets`]: chunk
+      };
+    case "slot":
+      return {
+        [`slot:${chunk.key}`]: {
+          kind: "slot",
+          args: chunk.args
+        }
+      };
+    case "complete":
+      return {
+        ":complete": true
+      };
+    case "error":
+      return chunk.key ? {
+        [`seg:${chunk.key}:error`]: chunk.error
+      } : {
+        ":error": chunk.error
+      };
+    default:
+      return {};
+  }
+}
+function createFrameHost(options = {}) {
+  const frames = new Map();
+  const pending = new Map();
+  const retained = new Map();
+  const deliver = (frame, chunk) => {
+    if (chunk.type === "data") {
+      options.applyData && options.applyData(chunk);
+      return;
+    }
+    frame.apply({
+      version: chunk.version,
+      r: chunkToRecords(chunk)
+    });
+  };
+  return {
+    register(id, frame) {
+      let set = frames.get(id);
+      if (!set) frames.set(id, set = new Set());
+      const sibling = set.size ? set.values().next().value : undefined;
+      set.add(frame);
+      if (sibling) {
+        frame.apply({
+          version: sibling.version ?? 0,
+          r: sibling.store
+        });
+        if (sibling.version === undefined) frame.rebase && frame.rebase();
+        return;
+      }
+      const kept = retained.get(id);
+      if (kept) {
+        retained.delete(id);
+        frame.apply({
+          version: kept.version,
+          r: kept.records
+        });
+        frame.rebase && frame.rebase();
+      }
+      const buffered = pending.get(id);
+      if (buffered) {
+        pending.delete(id);
+        const records = {};
+        let version;
+        for (const chunk of buffered.chunks) {
+          if (chunk.type === "data") {
+            options.applyData && options.applyData(chunk);
+            continue;
+          }
+          version = chunk.version;
+          Object.assign(records, chunkToRecords(chunk));
+        }
+        if (version !== undefined) frame.apply({
+          version,
+          r: records
+        });
+      }
+    },
+    unregister(id, frame) {
+      const set = frames.get(id);
+      if (set && frame) set.delete(frame);
+      if (!set || !frame || !set.size) {
+        if (frame) {
+          const kept = frame.snapshot && frame.snapshot();
+          if (kept) retained.set(id, kept);
+        } else {
+          retained.delete(id);
+        }
+        frames.delete(id);
+        pending.delete(id);
+      }
+    },
+    apply(chunk) {
+      if (chunk.type === "data") {
+        options.applyData && options.applyData(chunk);
+        return;
+      }
+      const set = frames.get(chunk.id);
+      if (set && set.size) {
+        for (const frame of set) deliver(frame, chunk);
+        return;
+      }
+      const buffered = pending.get(chunk.id);
+      if (!buffered) {
+        pending.set(chunk.id, {
+          version: chunk.version,
+          chunks: [chunk]
+        });
+        return;
+      }
+      if (chunk.version < buffered.version) return;
+      if (chunk.version > buffered.version) {
+        buffered.version = chunk.version;
+        buffered.chunks.length = 0;
+      }
+      buffered.chunks.push(chunk);
+    },
+    get(id) {
+      const set = frames.get(id);
+      return set && set.values().next().value;
+    },
+    serialize(value) {
+      if (!options.serialize) throw new Error("host has no serializer");
+      return options.serialize(value);
+    },
+    resolve(ref, frameId) {
+      return options.resolve ? options.resolve(ref, frameId) : undefined;
+    }
+  };
+}
+const FRAME_APPLIED_EVENT = "frame:applied";
+class FrameImpl {
+  #element;
+  #start;
+  #end;
+  #options;
+  #version;
+  #store = Object.create(null);
+  #appliedRootValue;
+  #hasContent = false;
+  #revealed = new Set();
+  #fallbackShown = new Set();
+  #slots;
+  #mountedSlots = new Set();
+  #slotCleanups = new Map();
+  #slotArgs = new Map();
+  #slotUpdaters = new Map();
+  #slotRegions = new Map();
+  #slotResolvedRefs = new Map();
+  #slotNodes = new Map();
+  #processedAssets = new Set();
+  #disposed = false;
+  #styleFlush = () => {
+    if (!this.#disposed) this.#flush();
+  };
+  #claimTree = (node, direct) => {
+    const handlers = claimHandlers();
+    if (!handlers) return;
+    const run = () => direct ? claimNode(handlers, node) : claimTree(handlers, node);
+    const scope = this.#options.ownerScope;
+    scope ? scope(run) : run();
+  };
+  constructor(element, start, end, options = {}) {
+    this.#element = element;
+    this.#start = start;
+    this.#end = end;
+    this.#options = options;
+    this.#slots = options.slots;
+    if (options.adopt) {
+      this.#hasContent = true;
+      this.#claimContent();
+    }
+    if (options.host && options.id !== undefined) {
+      options.host.register(options.id, this);
+    }
+    if (options.adopt && this.#version === undefined) this.#syncSlots();
+  }
+  #parent() {
+    return this.#element ?? this.#start.parentNode;
+  }
+  #applied(version, reason) {
+    this.#options.onApply?.({
+      version,
+      reason
+    });
+    const parent = this.#parent();
+    const Ev = parent && (parent.ownerDocument || parent).defaultView?.CustomEvent;
+    if (Ev) {
+      parent.dispatchEvent(new Ev(FRAME_APPLIED_EVENT, {
+        bubbles: true,
+        detail: {
+          id: this.#options.id,
+          version,
+          reason
+        }
+      }));
+    }
+  }
+  #firstContent() {
+    return this.#start ? this.#start.nextSibling : this.#parent().firstChild;
+  }
+  get version() {
+    return this.#version;
+  }
+  get store() {
+    return this.#store;
+  }
+  isRevealed(segment) {
+    return this.#revealed.has(segment);
+  }
+  get error() {
+    return this.#store[":error"];
+  }
+  apply(write) {
+    if (this.#disposed) return;
+    const v = write.version;
+    if (this.#version === undefined) {
+      this.#version = v;
+    } else if (v < this.#version) {
+      return;
+    } else if (v > this.#version) {
+      this.#version = v;
+      this.#revealed.clear();
+      this.#fallbackShown.clear();
+      for (const key of Object.keys(this.#store)) {
+        if (key.startsWith("seg:") || key === ":error") {
+          delete this.#store[key];
+        }
+      }
+    }
+    for (const key of Object.keys(write.r)) {
+      const incoming = write.r[key];
+      if (incoming && incoming.kind === "slot" && key.charCodeAt(0) === 115  && key.startsWith("slot:")) {
+        const existing = this.#store[key];
+        if (existing && existing.kind === "slot" && argsEquivalent(existing.args, incoming.args)) {
+          continue;
+        }
+      }
+      this.#store[key] = incoming;
+    }
+    this.#flush();
+  }
+  #flush() {
+    if (this.#disposed) return;
+    const version = this.#version;
+    const root = this.#store[""];
+    if (root && root.kind === "html" && root.value !== this.#appliedRootValue) {
+      const reason = this.#hasContent ? "morph" : "materialize";
+      this.#applyRoot(root.value);
+      this.#appliedRootValue = root.value;
+      this.#applied(version, reason);
+    }
+    let progressed = true;
+    while (progressed) {
+      progressed = false;
+      for (const key of Object.keys(this.#store)) {
+        const name = segmentName(key);
+        if (name === null || this.#revealed.has(name)) continue;
+        if (this.#segmentReady(name)) {
+          this.#revealSegment(name);
+          this.#applied(version, "reveal");
+          progressed = true;
+        }
+      }
+      for (const key of Object.keys(this.#store)) {
+        const m = /^seg:([^:]+):fallback$/.exec(key);
+        if (!m) continue;
+        const name = m[1];
+        if (this.#revealed.has(name) || this.#fallbackShown.has(name)) continue;
+        if (this.#showFallback(name)) {
+          this.#fallbackShown.add(name);
+          this.#applied(version, "reveal");
+          progressed = true;
+        }
+      }
+    }
+    for (const key of Object.keys(this.#store)) {
+      if (this.#processedAssets.has(key) || !key.endsWith(":assets")) continue;
+      this.#processedAssets.add(key);
+      const record = this.#store[key];
+      if (record && record.modules) {
+        for (const href of record.modules) ensureModulePreload(href);
+      }
+    }
+    this.#syncSlots();
+  }
+  #resolveSlot(prop) {
+    return this.#slots?.[prop] ?? this.#options.resolveSlot?.(prop);
+  }
+  #resolveSlotRecord(occurrence) {
+    const record = this.#store[`slot:${occurrence}`];
+    if (record !== undefined) return record;
+    return this.#options.resolveSlotRecord?.(occurrence);
+  }
+  #removeSlotRecord(occurrence) {
+    const key = `slot:${occurrence}`;
+    if (key in this.#store) delete this.#store[key];else this.#options.removeSlotRecord?.(occurrence);
+  }
+  #syncSlots(root) {
+    if (!this.#slots && !this.#options.resolveSlot) return;
+    const found = new Map();
+    if (root) collectSlots(root.firstChild, null, found);else this.#collectSlots(found);
+    for (const [occurrence, start] of found) {
+      const callback = this.#resolveSlot(propOf(occurrence));
+      if (!callback) continue;
+      const record = this.#resolveSlotRecord(occurrence);
+      const prev = this.#slotNodes.get(occurrence);
+      const prevFirst = Array.isArray(prev) ? prev[0] : prev;
+      const zombie = this.#mountedSlots.has(occurrence) && prevFirst && !prevFirst.parentNode;
+      if (zombie) {
+        this.#mountedSlots.delete(occurrence);
+        this.#runSlotCleanups(occurrence);
+      }
+      if (!this.#mountedSlots.has(occurrence)) {
+        if (this.#options.adopt) this.#discoverRegions(occurrence, start);
+        const nodes = this.#invokeSlot(occurrence, callback, record, start, this.#options.adopt);
+        if (nodes) this.#replaceRange(occurrence, start, nodes);
+        this.#slotNodes.set(occurrence, nodes);
+        this.#mountedSlots.add(occurrence);
+        if (!this.#options.adopt || nodes) this.#discoverRegions(occurrence, start);
+        this.#bindRegions(occurrence);
+      } else if (record !== this.#slotArgs.get(occurrence)) {
+        if (this.#refArgsUnchanged(occurrence, record)) {
+          this.#slotArgs.set(occurrence, record);
+          this.#reconcileRegions(occurrence, record);
+          continue;
+        }
+        const update = this.#slotUpdaters.get(occurrence);
+        if (update) {
+          const props = this.#resolveArgs(occurrence, record.args);
+          const regions = this.#slotRegions.get(occurrence);
+          if (regions) {
+            for (const [argKey, entry] of regions) {
+              if (!(argKey in props)) props[argKey] = entry.element;
+            }
+          }
+          this.#slotArgs.set(occurrence, record);
+          update(props);
+          this.#bindRegions(occurrence);
+          continue;
+        }
+        const nodes = this.#invokeSlot(occurrence, callback, record, start);
+        if (nodes) this.#replaceRange(occurrence, start, nodes);
+        this.#slotNodes.set(occurrence, nodes);
+        this.#bindRegions(occurrence);
+      }
+    }
+    if (!root) {
+      for (const occurrence of [...this.#mountedSlots]) {
+        if (!found.has(occurrence)) this.#unmountSlot(occurrence);
+      }
+    }
+  }
+  #invokeSlot(occurrence, callback, record, start, adopted) {
+    this.#slotUpdaters.delete(occurrence);
+    const cleanups = this.#slotCleanups.get(occurrence) ?? [];
+    let existing = [];
+    let end = null;
+    if (start) {
+      const endData = slotEnd(occurrence);
+      let n = start.nextSibling;
+      while (n && !(n.nodeType === COMMENT_NODE && n.data === endData)) {
+        existing.push(n);
+        n = n.nextSibling;
+      }
+      end = n;
+    }
+    const ctx = {
+      frame: this.#options.claimScope ?? this.#options.id,
+      key: occurrence,
+      adopted: !!adopted,
+      invoked: !!(record && record.kind === "slot"),
+      onCleanup: fn => cleanups.push(fn),
+      onUpdate: fn => this.#slotUpdaters.set(occurrence, fn),
+      existing,
+      range: end ? {
+        start,
+        end
+      } : undefined
+    };
+    const props = record && record.kind === "slot" ? this.#resolveArgs(occurrence, record.args) : {};
+    const regions = this.#slotRegions.get(occurrence);
+    if (regions) {
+      for (const [argKey, entry] of regions) {
+        if (!(argKey in props)) props[argKey] = entry.element;
+      }
+    }
+    const scope = this.#options.ownerScope;
+    const content = scope ? scope(() => callback(props, ctx)) : callback(props, ctx);
+    this.#slotArgs.set(occurrence, record);
+    if (cleanups.length) this.#slotCleanups.set(occurrence, cleanups);
+    if (content == null) return null;
+    return Array.isArray(content) ? content : [content];
+  }
+  #replaceRange(key, start, nodes) {
+    const end = slotEnd(key);
+    const parent = start.parentNode;
+    let n = start.nextSibling;
+    while (n && !(n.nodeType === COMMENT_NODE && n.data === end)) {
+      const next = n.nextSibling;
+      parent.removeChild(n);
+      n = next;
+    }
+    for (const node of nodes) parent.insertBefore(node, n);
+  }
+  #unmountSlot(key) {
+    this.#mountedSlots.delete(key);
+    this.#slotNodes.delete(key);
+    this.#slotArgs.delete(key);
+    this.#slotUpdaters.delete(key);
+    this.#slotResolvedRefs.delete(key);
+    this.#removeSlotRecord(key);
+    this.#runSlotCleanups(key);
+    const regions = this.#slotRegions.get(key);
+    if (regions) {
+      for (const {
+        frame
+      } of regions.values()) frame?.dispose();
+      this.#slotRegions.delete(key);
+    }
+  }
+  #runSlotCleanups(key) {
+    const cleanups = this.#slotCleanups.get(key);
+    if (!cleanups) return;
+    this.#slotCleanups.delete(key);
+    for (const fn of cleanups) fn();
+  }
+  #resolveArgs(slotKey, args) {
+    const host = this.#options.host;
+    let regions = this.#slotRegions.get(slotKey);
+    if (!regions) {
+      regions = new Map();
+      this.#slotRegions.set(slotKey, regions);
+    }
+    const props = {};
+    for (const key of Object.keys(args)) {
+      const value = args[key];
+      if (isDataRef(value)) {
+        const resolved = host ? host.resolve(value, this.#options.id) : undefined;
+        let cache = this.#slotResolvedRefs.get(slotKey);
+        if (!cache) this.#slotResolvedRefs.set(slotKey, cache = {});
+        cache[key] = resolved;
+        props[key] = resolved;
+      } else if (isFrameRef(value)) {
+        let entry = regions.get(key);
+        if (!entry) {
+          const element = makeFrameElement(value.$frame);
+          entry = {
+            childId: value.$frame,
+            element,
+            frame: undefined
+          };
+          regions.set(key, entry);
+        } else if (entry.childId !== value.$frame) {
+          renameRegion(entry, value.$frame);
+        }
+        props[key] = entry.element;
+      } else {
+        props[key] = value;
+      }
+    }
+    return props;
+  }
+  #discoverRegions(slotKey, start) {
+    if (!start) return;
+    let regions = this.#slotRegions.get(slotKey);
+    if (!regions) {
+      regions = new Map();
+      this.#slotRegions.set(slotKey, regions);
+    }
+    const endData = slotEnd(slotKey);
+    const prefix = `${this.#options.id}.`;
+    let n = start.nextSibling;
+    while (n && !(n.nodeType === COMMENT_NODE && n.data === endData)) {
+      collectRegionElements(n, regions, prefix);
+      n = n.nextSibling;
+    }
+  }
+  #refArgsUnchanged(occurrence, record) {
+    const old = this.#slotArgs.get(occurrence);
+    if (!record || record.kind !== "slot") return false;
+    if (old && old.kind !== "slot") return false;
+    const a = old && old.args || {};
+    const b = record.args || {};
+    const ka = Object.keys(a);
+    const kb = Object.keys(b);
+    if (kb.length < ka.length) return false;
+    if (kb.length !== ka.length) {
+      const regions = this.#slotRegions.get(occurrence);
+      for (const key of kb) {
+        if (key in a) continue;
+        const vb = b[key];
+        if (!vb || typeof vb !== "object" || typeof vb.$frame !== "string") return false;
+        if (!regions || !regions.has(key)) return false;
+      }
+    }
+    const cache = this.#slotResolvedRefs.get(occurrence);
+    for (const key of ka) {
+      const va = a[key];
+      const vb = b[key];
+      if (va === vb) continue;
+      if (!va || !vb || typeof va !== "object" || typeof vb !== "object") return false;
+      if (typeof va.$frame === "string" && typeof vb.$frame === "string") continue;
+      if (typeof va.$ref === "string" && typeof vb.$ref === "string" && cache && key in cache) {
+        const host = this.#options.host;
+        const next = host ? host.resolve(vb, this.#options.id) : undefined;
+        try {
+          if (JSON.stringify(next) === JSON.stringify(cache[key])) continue;
+        } catch (e) {
+          return false;
+        }
+      }
+      return false;
+    }
+    return true;
+  }
+  #reconcileRegions(occurrence, record) {
+    const args = record && record.args;
+    if (!args) return;
+    const regions = this.#slotRegions.get(occurrence);
+    if (!regions) return;
+    for (const key of Object.keys(args)) {
+      const value = args[key];
+      if (!isFrameRef(value)) continue;
+      const entry = regions.get(key);
+      if (entry && entry.childId !== value.$frame) renameRegion(entry, value.$frame);
+    }
+  }
+  #bindRegions(slotKey) {
+    const regions = this.#slotRegions.get(slotKey);
+    if (!regions) return;
+    for (const entry of regions.values()) {
+      if (!entry.frame) {
+        entry.frame = new FrameImpl(entry.element, null, null, {
+          id: entry.childId,
+          host: this.#options.host,
+          adopt: entry.adopt,
+          claimScope: this.#options.claimScope ?? this.#options.id,
+          ownerScope: this.#options.ownerScope,
+          resolveSlot: prop => this.#resolveSlot(prop),
+          resolveSlotRecord: occurrence => this.#resolveSlotRecord(occurrence),
+          removeSlotRecord: occurrence => this.#removeSlotRecord(occurrence)
+        });
+      }
+    }
+  }
+  #collectSlots(found) {
+    collectSlots(this.#firstContent(), this.#end, found);
+  }
+  #findPlaceholder(name) {
+    return findPlaceholder(this.#firstContent(), this.#end, placeholderId(name));
+  }
+  snapshot() {
+    if (this.#disposed) return null;
+    const records = {
+      ...this.#store
+    };
+    if (!records[""] && this.#element && this.#hasContent) {
+      records[""] = {
+        kind: "html",
+        value: this.#element.innerHTML
+      };
+    }
+    if (!records[""] && this.#version === undefined) return null;
+    return {
+      version: this.#version ?? 0,
+      records
+    };
+  }
+  rebind(id) {
+    if (this.#disposed || id === this.#options.id) return;
+    const {
+      host,
+      id: oldId
+    } = this.#options;
+    if (host && oldId !== undefined) host.unregister(oldId, this);
+    this.#options = {
+      ...this.#options,
+      id
+    };
+    if (this.#element && this.#element.nodeType === ELEMENT_NODE) {
+      this.#element.setAttribute(FRAME_ID_ATTR, id);
+    }
+    this.#version = undefined;
+    this.#revealed.clear();
+    this.#fallbackShown.clear();
+    for (const key of Object.keys(this.#store)) {
+      if (key.startsWith("seg:") || key === ":error") delete this.#store[key];
+    }
+    if (host) host.register(id, this);
+  }
+  rebase() {
+    this.#version = undefined;
+  }
+  dispose() {
+    if (this.#disposed) return;
+    const {
+      host,
+      id
+    } = this.#options;
+    if (host && id !== undefined) host.unregister(id, this);
+    this.#disposed = true;
+    for (const key of [...this.#slotCleanups.keys()]) this.#runSlotCleanups(key);
+    for (const key of this.#mountedSlots) this.#removeSlotRecord(key);
+    for (const regions of this.#slotRegions.values()) {
+      for (const {
+        frame
+      } of regions.values()) frame?.dispose();
+    }
+    this.#slotRegions.clear();
+    this.#mountedSlots.clear();
+  }
+  #applyRoot(html) {
+    const fragment = parseFragment(html);
+    const parent = this.#parent();
+    if (!this.#hasContent) {
+      this.#clearContent();
+      this.#claimTree(fragment);
+      parent.insertBefore(fragment, this.#end);
+      this.#hasContent = true;
+    } else {
+      const claim = claimHandlers() ? this.#claimTree : null;
+      const ranges = new Map();
+      this.#collectSlots(ranges);
+      reconcileChildren(parent, fragment, this.#start, this.#end, claim, ranges);
+      if (ranges.size) restoreDisplacedRanges(this.#firstContent(), this.#end, ranges);
+    }
+  }
+  #clearContent() {
+    const parent = this.#parent();
+    let n = this.#firstContent();
+    while (n && n !== this.#end) {
+      const next = n.nextSibling;
+      parent.removeChild(n);
+      n = next;
+    }
+  }
+  #claimContent() {
+    if (!claimHandlers()) return;
+    let n = this.#firstContent();
+    while (n && n !== this.#end) {
+      this.#claimTree(n);
+      n = n.nextSibling;
+    }
+  }
+  #segmentReady(name) {
+    const content = this.#store[`seg:${name}`];
+    if (!content || content.kind !== "html") return false;
+    if (!this.#store[`seg:${name}:reveal`]) return false;
+    const assets = this.#store[`seg:${name}:assets`];
+    if (assets && assets.styles) {
+      let ready = true;
+      for (const entry of assets.styles) {
+        if (!ensureStylesheet(entry, this.#styleFlush)) ready = false;
+      }
+      if (!ready) return false;
+    }
+    if (!this.#findPlaceholder(name)) return false;
+    return true;
+  }
+  #revealSegment(name) {
+    const tpl = this.#findPlaceholder(name);
+    if (!tpl) return;
+    const assets = this.#store[`seg:${name}:assets`];
+    if (assets && assets.inlineStyles) applyInlineStyles(assets.inlineStyles);
+    const content = this.#store[`seg:${name}`];
+    const closing = rangeClose(tpl, placeholderId(name));
+    if (!closing) {
+      console.error(`Frame fragment placeholder "${name}" is missing its closing comment ` + `(<!--${placeholderId(name)}-->); revealed content will be appended at the end of ` + `its parent instead of in place. Likely an HTML-rewriting layer stripped the ` + `comment, or invalid nesting split the placeholder range.`, tpl);
+    }
+    const parent = tpl.parentNode;
+    let n = tpl.nextSibling;
+    while (n && n !== closing) {
+      const next = n.nextSibling;
+      parent.removeChild(n);
+      n = next;
+    }
+    if (this.#options.reveal) {
+      const fallbackFrag = tpl.content.cloneNode(true);
+      this.#claimTree(fallbackFrag);
+      this.#options.reveal({
+        before: closing,
+        fallback: [...fallbackFrag.childNodes],
+        content: () => {
+          const materialized = this.#materialize(content);
+          this.#syncSlots(materialized);
+          this.#claimTree(materialized);
+          return materialized;
+        }
+      });
+      tpl.remove();
+      this.#revealed.add(name);
+      return;
+    }
+    const materialized = this.#materialize(content);
+    this.#claimTree(materialized);
+    parent.insertBefore(materialized, closing);
+    tpl.remove();
+    closing && closing.remove();
+    this.#revealed.add(name);
+  }
+  #showFallback(name) {
+    const tpl = this.#findPlaceholder(name);
+    if (!tpl) return false;
+    const closing = rangeClose(tpl, placeholderId(name));
+    if (!closing) return false;
+    const fallback = tpl.content.cloneNode(true);
+    this.#claimTree(fallback);
+    closing.parentNode.insertBefore(fallback, closing);
+    return true;
+  }
+  #materialize(record) {
+    return record.kind === "html" ? parseFragment(record.value) : parseFragment("");
+  }
+}
+function createFrame(boundary, options) {
+  return new FrameImpl(boundary, null, null, options);
+}
+const FRAME_TAG = "dx-frame";
+const FRAME_ID_ATTR = "data-fid";
+function createFrameElement(options) {
+  const el = makeFrameElement(options.id);
+  const frame = new FrameImpl(el, null, null, options);
+  return {
+    element: el,
+    get frame() {
+      return frame;
+    },
+    dispose() {
+      frame.dispose();
+      el.remove();
+    }
+  };
+}
+function makeFrameElement(id) {
+  const el = document.createElement(FRAME_TAG);
+  el.style.display = "contents";
+  if (id !== undefined) el.setAttribute(FRAME_ID_ATTR, id);
+  return el;
+}
+function isFrameElement(node) {
+  return node.nodeType === ELEMENT_NODE && node.hasAttribute(FRAME_ID_ATTR);
+}
+function segmentName(key) {
+  const m = /^seg:([^:]+)$/.exec(key);
+  return m ? m[1] : null;
+}
+function propOf(occurrence) {
+  const hash = occurrence.indexOf("#");
+  return hash === -1 ? occurrence : occurrence.slice(0, hash);
+}
+function isDataRef(value) {
+  return typeof value === "object" && value !== null && typeof value.$ref === "string";
+}
+function isFrameRef(value) {
+  return typeof value === "object" && value !== null && typeof value.$frame === "string";
+}
+function parseFragment(html) {
+  const template = document.createElement("template");
+  template.innerHTML = html;
+  return template.content;
+}
+function findHeadElement(selector, attr, value) {
+  const nodes = document.head.querySelectorAll(selector);
+  for (let i = 0; i < nodes.length; i++) {
+    if (nodes[i].getAttribute(attr) === value) return nodes[i];
+  }
+  return null;
+}
+function ensureStylesheet(entry, onSettle) {
+  const href = typeof entry === "string" ? entry : entry.href;
+  let link = findHeadElement('link[rel="stylesheet"]', "href", href);
+  if (!link) {
+    link = document.createElement("link");
+    link.rel = "stylesheet";
+    if (typeof entry !== "string" && entry.attrs) {
+      for (const name in entry.attrs) link.setAttribute(name, entry.attrs[name]);
+    }
+    link.href = href;
+    const waiters = new Set();
+    link._$frWaiters = waiters;
+    const settle = () => {
+      link._$frWaiters = null;
+      for (const fn of waiters) fn();
+    };
+    link.addEventListener("load", settle);
+    link.addEventListener("error", settle);
+    document.head.appendChild(link);
+  }
+  const waiters = link._$frWaiters;
+  if (waiters == null) return true;
+  waiters.add(onSettle);
+  return false;
+}
+function ensureModulePreload(href) {
+  if (findHeadElement('link[rel="modulepreload"]', "href", href)) return;
+  const link = document.createElement("link");
+  link.rel = "modulepreload";
+  link.href = href;
+  document.head.appendChild(link);
+}
+function applyInlineStyles(inlineStyles) {
+  for (const entry of inlineStyles) {
+    if (findHeadElement("style[data-asset]", "data-asset", entry.id)) continue;
+    const el = document.createElement("style");
+    el.setAttribute("data-asset", entry.id);
+    if (entry.attrs) {
+      for (const name in entry.attrs) el.setAttribute(name, entry.attrs[name]);
+    }
+    el.textContent = entry.content || "";
+    document.head.appendChild(el);
+  }
+}
+function isPlaceholderStart(node, id) {
+  return node.nodeType === ELEMENT_NODE && node.tagName === "TEMPLATE" && node.getAttribute("id") === id;
+}
+function rangeClose(start, id) {
+  let n = start.nextSibling;
+  while (n) {
+    if (n.nodeType === COMMENT_NODE && n.data === id) return n;
+    n = n.nextSibling;
+  }
+  return null;
+}
+function findPlaceholder(n, end, id) {
+  while (n && n !== end) {
+    if (isPlaceholderStart(n, id)) return n;
+    if (n.nodeType === ELEMENT_NODE) {
+      const found = findPlaceholder(n.firstChild, null, id);
+      if (found) return found;
+    }
+    n = n.nextSibling;
+  }
+  return null;
+}
+function collectSlots(n, end, out) {
+  while (n && n !== end) {
+    const id = slotStartId(n);
+    if (id !== null) {
+      devCheckRange(n, id);
+      if (!out.has(id)) out.set(id, n);
+      n = afterRange(n, id);
+      continue;
+    }
+    if (n.nodeType === ELEMENT_NODE && !isFrameElement(n)) collectSlots(n.firstChild, null, out);
+    n = n.nextSibling;
+  }
+}
+function collectRegionElements(node, regions, prefix) {
+  if (node.nodeType !== ELEMENT_NODE) return;
+  if (isFrameElement(node)) {
+    const childId = node.getAttribute(FRAME_ID_ATTR);
+    if (childId && childId.startsWith(prefix)) {
+      const argKey = childId.slice(childId.lastIndexOf(".") + 1);
+      if (!regions.has(argKey)) {
+        regions.set(argKey, {
+          childId,
+          element: node,
+          frame: undefined,
+          adopt: true
+        });
+      }
+    }
+    return;
+  }
+  for (let c = node.firstChild; c; c = c.nextSibling) collectRegionElements(c, regions, prefix);
+}
+function renameRegion(entry, childId) {
+  entry.childId = childId;
+  if (entry.frame) entry.frame.rebind(childId);else entry.element.setAttribute(FRAME_ID_ATTR, childId);
+}
+function argsEquivalent(a, b) {
+  if (a === b) return true;
+  if (!a || !b) return false;
+  const ka = Object.keys(a);
+  const kb = Object.keys(b);
+  if (ka.length !== kb.length) return false;
+  for (const key of ka) {
+    const va = a[key];
+    const vb = b[key];
+    if (va === vb) continue;
+    if (va && vb && typeof va === "object" && typeof vb === "object" && typeof va.$frame === "string" && va.$frame === vb.$frame) {
+      continue;
+    }
+    return false;
+  }
+  return true;
+}
+function slotStartId(node) {
+  if (node.nodeType !== COMMENT_NODE) return null;
+  const m = SLOT_START.exec(node.data);
+  return m ? m[1] : null;
+}
+function isSlotMarker(node) {
+  if (node.nodeType !== COMMENT_NODE) return false;
+  const data = node.data;
+  return SLOT_START.test(data) || SLOT_END.test(data);
+}
+function compatible(a, b) {
+  if (a.nodeType !== b.nodeType) return false;
+  if (a.nodeType === ELEMENT_NODE) return a.nodeName === b.nodeName;
+  return a.nodeType === TEXT_NODE || a.nodeType === COMMENT_NODE;
+}
+function preservesOpen(el) {
+  const t = el.tagName;
+  return t === "DETAILS" || t === "DIALOG";
+}
+function morphAttributes(oldEl, newEl, claim) {
+  let reclaim = false;
+  let changed = false;
+  const keepOpen = preservesOpen(oldEl);
+  const oldAttrs = oldEl.attributes;
+  for (let i = oldAttrs.length - 1; i >= 0; i--) {
+    const name = oldAttrs[i].name;
+    if (keepOpen && name === "open") continue;
+    if (!newEl.hasAttribute(name)) {
+      oldEl.removeAttribute(name);
+      changed = true;
+      reclaim ||= claimedAttr(name);
+    }
+  }
+  const newAttrs = newEl.attributes;
+  for (let i = 0; i < newAttrs.length; i++) {
+    const attr = newAttrs[i];
+    if (keepOpen && attr.name === "open") continue;
+    if (oldEl.getAttribute(attr.name) !== attr.value) {
+      oldEl.setAttribute(attr.name, attr.value);
+      changed = true;
+      reclaim ||= claimedAttr(attr.name);
+    }
+  }
+  if (claim && (reclaim || changed && oldEl.matches(CLAIMED_ELEMENTS))) claim(oldEl, true);
+}
+function morphNode(oldNode, newNode, claim, ranges) {
+  if (oldNode.nodeType === ELEMENT_NODE) {
+    if (oldNode.hasAttribute("data-preserve")) return;
+    morphAttributes(oldNode, newNode, claim);
+    reconcileChildren(oldNode, newNode, null, null, claim, ranges);
+  } else if (oldNode.data !== newNode.data) {
+    oldNode.data = newNode.data;
+  }
+}
+function afterRange(start, id) {
+  const end = slotEnd(id);
+  let n = start.nextSibling;
+  while (n) {
+    if (n.nodeType === COMMENT_NODE && n.data === end) return n.nextSibling;
+    n = n.nextSibling;
+  }
+  return null;
+}
+function devCheckRange(start, id) {
+  const end = slotEnd(id);
+  let n = start.nextSibling;
+  while (n) {
+    if (n.nodeType === COMMENT_NODE && n.data === end) return;
+    n = n.nextSibling;
+  }
+  console.error(`Frame slot range "${id}" is missing its end marker (<!--${end}-->) among its start ` + `marker's siblings. Slots after it in this content cannot be discovered. Likely causes: ` + `invalid HTML nesting split the range during parsing (e.g. a block element inside <p>), ` + `or an HTML-rewriting layer (CDN/minifier/translator) removed or moved the comment — ` + `serve frame documents with Cache-Control: no-transform.`, start);
+}
+function findRangeStart(from, id, bound) {
+  const target = `slot:${id}:start`;
+  let n = from;
+  while (n && n !== bound) {
+    if (n.nodeType === COMMENT_NODE && n.data === target) return n;
+    n = n.nextSibling;
+  }
+  return null;
+}
+function moveRangeBefore(parent, start, id, ref) {
+  const end = slotEnd(id);
+  let n = start;
+  while (n) {
+    const next = n.nextSibling;
+    const isEnd = n.nodeType === COMMENT_NODE && n.data === end;
+    parent.insertBefore(n, ref);
+    if (isEnd) break;
+    n = next;
+  }
+}
+function adoptRange(parent, start, id, ref, claim) {
+  const end = slotEnd(id);
+  let n = start;
+  let after = null;
+  while (n) {
+    const next = n.nextSibling;
+    const isEnd = n.nodeType === COMMENT_NODE && n.data === end;
+    parent.insertBefore(n, ref);
+    if (claim) claim(n);
+    if (isEnd) {
+      after = next;
+      break;
+    }
+    n = next;
+  }
+  return after;
+}
+function reconcileChildren(parent, source, boundStart = null, boundEnd = null, claim = null, ranges = null) {
+  let oldChild = boundStart ? boundStart.nextSibling : parent.firstChild;
+  let newChild = source.firstChild;
+  while (newChild) {
+    const nextNew = newChild.nextSibling;
+    const pid = slotStartId(newChild);
+    const old = oldChild === boundEnd ? null : oldChild;
+    if (pid !== null) {
+      if (old && slotStartId(old) === pid) {
+        oldChild = afterRange(old, pid);
+        newChild = afterRange(newChild, pid);
+      } else {
+        const displaced = ranges && ranges.get(pid);
+        const existing = displaced || findRangeStart(old, pid, boundEnd);
+        if (existing) {
+          if (ranges) ranges.delete(pid);
+          if (existing.nodeType === 11 ) {
+            parent.insertBefore(existing, old ?? boundEnd);
+          } else {
+            moveRangeBefore(parent, existing, pid, old ?? boundEnd);
+          }
+          newChild = afterRange(newChild, pid);
+        } else {
+          newChild = adoptRange(parent, newChild, pid, old ?? boundEnd, claim);
+        }
+      }
+      continue;
+    }
+    if (!old) {
+      parent.insertBefore(newChild, boundEnd);
+      if (claim) claim(newChild);
+      newChild = nextNew;
+      continue;
+    }
+    if (isSlotMarker(old)) {
+      parent.insertBefore(newChild, old);
+      if (claim) claim(newChild);
+      newChild = nextNew;
+      continue;
+    }
+    if (compatible(old, newChild)) {
+      morphNode(old, newChild, claim, ranges);
+      oldChild = old.nextSibling;
+      newChild = nextNew;
+      continue;
+    }
+    if (newChild.nodeType === 1) {
+      let ahead = old.nextSibling;
+      while (ahead && ahead !== boundEnd && !compatible(ahead, newChild)) {
+        const aheadPid = slotStartId(ahead);
+        ahead = aheadPid !== null ? afterRange(ahead, aheadPid) : ahead.nextSibling;
+      }
+      if (ahead && ahead !== boundEnd) {
+        parent.insertBefore(ahead, old);
+        morphNode(ahead, newChild, claim, ranges);
+        newChild = nextNew;
+        continue;
+      }
+    }
+    parent.insertBefore(newChild, old);
+    if (claim) claim(newChild);
+    newChild = nextNew;
+  }
+  while (oldChild && oldChild !== boundEnd) {
+    const next = oldChild.nextSibling;
+    const pid = ranges ? slotStartId(oldChild) : null;
+    if (pid !== null && ranges.get(pid) === oldChild) {
+      const frag = document.createDocumentFragment();
+      const after = stashRange(frag, oldChild, pid);
+      ranges.set(pid, frag);
+      oldChild = after;
+      continue;
+    }
+    parent.removeChild(oldChild);
+    oldChild = next;
+  }
+}
+function restoreDisplacedRanges(first, end, ranges) {
+  const found = new Map();
+  collectSlots(first, end, found);
+  for (const [id, start] of found) {
+    const displaced = ranges.get(id);
+    if (!displaced || displaced === start) continue;
+    ranges.delete(id);
+    const parent = start.parentNode;
+    if (displaced.nodeType === 11 ) {
+      parent.insertBefore(displaced, start);
+    } else {
+      moveRangeBefore(parent, displaced, id, start);
+    }
+    stashRange(document.createDocumentFragment(), start, id);
+  }
+}
+function stashRange(frag, start, id) {
+  const end = slotEnd(id);
+  let n = start;
+  while (n) {
+    const next = n.nextSibling;
+    const isEnd = n.nodeType === COMMENT_NODE && n.data === end;
+    frag.appendChild(n);
+    if (isEnd) return next;
+    n = next;
+  }
+  return null;
+}
+
+const FRAME_STREAM_HEADER = "X-Frame-Stream";
+function isFrameStreamResponse(response) {
+  return response.headers.has(FRAME_STREAM_HEADER);
+}
+async function applyFrameResponse(response, host, options = {}) {
+  const rootId = response.headers.get(FRAME_STREAM_HEADER) ?? "";
+  const as = options.as;
+  const version = options.version;
+  const perFrame = typeof version === "function" ? new Map() : null;
+  const reader = new client.ChunkReader(response.body);
+  let result = await reader.next();
+  while (!result.done) {
+    const chunk = JSON.parse(result.value);
+    if (chunk.type === "outcome") {
+      if (options.onOutcome) options.onOutcome(chunk.payload);
+    } else {
+      if (as !== undefined && chunk.id === rootId) chunk.id = as;else if (options.route) chunk.id = options.route(chunk.id);
+      if (perFrame) {
+        let v = perFrame.get(chunk.id);
+        if (v === undefined) perFrame.set(chunk.id, v = version(chunk.id));
+        chunk.version = v;
+      } else if (version !== undefined) chunk.version = version;
+      host.apply(chunk);
+    }
+    result = await reader.next();
+  }
+  return as !== undefined ? as : rootId;
+}
+const SERVER_COMPONENT = /*#__PURE__*/Symbol.for("dom-expressions.server-component");
+const SERVER_COMPONENT_ADDRESS = /*#__PURE__*/Symbol.for("dom-expressions.server-component-address");
+const COMPONENT_HANDOFF = /*#__PURE__*/Symbol.for("dom-expressions.component-handoff");
+let resolveServerComponent;
+function parseServerComponent(value, ctx) {
+  return {
+    id: ctx.parse(value[SERVER_COMPONENT]),
+    address: ctx.parse(value[SERVER_COMPONENT_ADDRESS])
+  };
+}
+const ServerComponentPlugin = /*#__PURE__*/seroval.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) {
+    return "self._$SC.r(" + ctx.serialize(node.id) + "," + ctx.serialize(node.address) + ")";
+  },
+  deserialize(node, ctx) {
+    const id = ctx.deserialize(node.id);
+    const address = ctx.deserialize(node.address);
+    if (address !== undefined && resolveServerComponent) {
+      return resolveServerComponent(id, 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 createServerComponentHandler({
+  host,
+  component,
+  onStream,
+  documentComponent,
+  intercept,
+  consumer = client.getFlightDataConsumer,
+  codec = client.getServerFunctionsCodec
+}) {
+  const byAddress = new Map();
+  const forwards = new Map();
+  const brand = (comp, fnId, frameId) => {
+    const brandable = typeof comp === "function" || typeof comp === "object" && comp !== null;
+    if (brandable && !comp[COMPONENT_HANDOFF]) {
+      comp[COMPONENT_HANDOFF] = {
+        fnId,
+        frameId,
+        take(prev) {
+          const meta = prev !== null && (typeof prev === "function" || typeof prev === "object") && prev[COMPONENT_HANDOFF];
+          if (!meta || meta.fnId !== fnId) return false;
+          const root = meta.frameId;
+          let cur = forwards.get(root) ?? root;
+          if (cur !== root && !host.get(cur)) {
+            forwards.delete(root);
+            cur = root;
+          }
+          if (cur === frameId) return true;
+          let frame = host.get(cur);
+          if (!frame) return false;
+          while (frame) {
+            frame.rebind(frameId);
+            frame = host.get(cur);
+          }
+          if (frameId === root) forwards.delete(root);else forwards.set(root, frameId);
+          return true;
+        }
+      };
+    }
+    return comp;
+  };
+  const boundaryFor = (address, fnId) => {
+    let entry = byAddress.get(address);
+    if (!entry) {
+      entry = {
+        frameId: address,
+        component: brand(component(address), fnId, address)
+      };
+      byAddress.set(address, entry);
+    }
+    return entry;
+  };
+  const resolveAddress = (id, address) => boundaryFor(address, id).component;
+  resolveServerComponent = resolveAddress;
+  const versions = new Map();
+  const bump = frameId => {
+    const version = (versions.get(frameId) || 0) + 1;
+    versions.set(frameId, version);
+    return version;
+  };
+  return {
+    intercept: intercept && (info => {
+      const hit = intercept(info);
+      if (hit !== undefined) {
+        const address = client.frameAddress(info.id, info.args);
+        byAddress.set(address, {
+          frameId: info.id,
+          component: brand(hit, info.id, info.id)
+        });
+      }
+      return hit;
+    }),
+    handle(response, ctx) {
+      if (!isFrameStreamResponse(response)) return undefined;
+      const address = client.frameAddress(ctx.id, ctx.args);
+      let entry = byAddress.get(address);
+      if (!entry) {
+        const adopted = documentComponent && documentComponent(ctx.id);
+        if (adopted) {
+          entry = {
+            frameId: ctx.id,
+            component: brand(adopted, ctx.id, ctx.id)
+          };
+          byAddress.set(address, entry);
+        } else {
+          entry = boundaryFor(address, ctx.id);
+        }
+      }
+      if (response.headers.has(client.SINGLE_FLIGHT_HEADER)) {
+        return applyFlightResponse(response, entry);
+      }
+      const version = bump(entry.frameId);
+      if (onStream) onStream(entry.frameId, version, response);
+      applyFrameResponse(response, host, {
+        as: entry.frameId,
+        version
+      }).catch(err => host.apply({
+        type: "error",
+        id: entry.frameId,
+        version,
+        error: {
+          message: String(err && err.message)
+        }
+      }));
+      return entry.component;
+    },
+    showing(address, functionId, component) {
+      if (!byAddress.has(address)) {
+        byAddress.set(address, {
+          frameId: functionId,
+          component: brand(component, functionId, functionId),
+          address
+        });
+      }
+    }
+  };
+  async function applyFlightResponse(response, entry) {
+    const rootId = response.headers.get(FRAME_STREAM_HEADER) ?? "";
+    const as = rootId ? entry.frameId : undefined;
+    let feed;
+    const source = new ReadableStream({
+      start(controller) {
+        feed = controller;
+      }
+    });
+    const payload = client.deserializeStream(new Response(source), flightCodec(codec()));
+    let carried = false;
+    await applyFrameResponse(response, host, {
+      as,
+      route: id => {
+        const local = byAddress.get(id);
+        return local ? local.frameId : id;
+      },
+      version: frameId => {
+        const version = bump(frameId);
+        if (onStream) onStream(frameId, version, response);
+        return version;
+      },
+      onOutcome: text => {
+        carried = true;
+        feed.enqueue(client.createChunk(text));
+      }
+    });
+    feed.close();
+    if (!carried) throw new Error("Single-flight frame response carried no outcome");
+    const envelope = await payload;
+    const deliver = consumer();
+    if (deliver) await deliver(envelope.data, {
+      response
+    });
+    if (response.headers.has(client.ERROR_HEADER) && !response.headers.has("Location") && !response.headers.has(client.REVALIDATE_HEADER)) {
+      throw envelope.value;
+    }
+    return rootId ? entry.component : envelope.value;
+  }
+}
+
+seroval.Feature.AggregateError | seroval.Feature.BigIntTypedArray;
+const DEFAULT_WEB_PLUGINS = Object.freeze([web.AbortSignalPlugin,
+web.CustomEventPlugin, web.DOMExceptionPlugin, web.EventPlugin,
+web.FormDataPlugin, web.HeadersPlugin, web.ReadableStreamPlugin, web.RequestPlugin, web.ResponsePlugin, web.URLSearchParamsPlugin, web.URLPlugin]);
+function resolveSerializerPlugins(customPlugins) {
+  return customPlugins ? [...customPlugins, ...DEFAULT_WEB_PLUGINS] : [...DEFAULT_WEB_PLUGINS];
+}
+const JSON_CODEC_DISABLED_FEATURES = seroval.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 createJSONDeserializer(options) {
+  const refs = new Map();
+  const resolved = resolveCodecOptions(options);
+  return function deserializeJSONChunk(node) {
+    return seroval.fromCrossJSON(node, {
+      refs,
+      ...resolved
+    });
+  };
+}
+function createJSONDataTable(options) {
+  const deserialize = createJSONDeserializer(options);
+  const table = new Map();
+  return {
+    apply(record) {
+      const value = deserialize(record.node);
+      if (record.initial) table.set(record.key, value);
+    },
+    get(key) {
+      return table.get(key);
+    },
+    resolve(ref) {
+      return table.get(ref.$ref);
+    }
+  };
+}
+
+let sharedHost;
+const tables = new Map();
+function tableFor(id) {
+  const table = tables.get(id);
+  if (table) return table;
+  for (const [root, t] of tables) if (id.startsWith(root + ".")) return t;
+  return undefined;
+}
+function beginStream(frameId) {
+  tables.set(frameId, createJSONDataTable());
+}
+function getFrameHost() {
+  if (!sharedHost) {
+    sharedHost = createFrameHost({
+      applyData: c => tableFor(c.id)?.apply(c),
+      resolve: (ref, id) => tableFor(id)?.resolve(ref)
+    });
+  }
+  return sharedHost;
+}
+function normalizeSlotContent(value) {
+  while (typeof value === "function") value = value();
+  if (Array.isArray(value)) {
+    const out = [];
+    for (const v of value) {
+      const n = normalizeSlotContent(v);
+      Array.isArray(n) ? out.push(...n) : out.push(n);
+    }
+    return out;
+  }
+  if (value == null || typeof value === "boolean") return document.createTextNode("");
+  return value instanceof Node ? value : document.createTextNode(String(value));
+}
+function gatherClaims(el, registry) {
+  if (el.hasAttribute("_hk")) registry.set(el.getAttribute("_hk"), el);
+  if (el.hasAttribute(FRAME_ID_ATTR)) return;
+  for (let c = el.firstElementChild; c; c = c.nextElementSibling) gatherClaims(c, registry);
+}
+function hasPendingFragment(existing) {
+  for (const n of existing) {
+    if (n.nodeType !== 1) continue;
+    const el = n;
+    if (el.tagName === "TEMPLATE" && el.id.startsWith("pl-")) return true;
+    if (el.querySelector?.('template[id^="pl-"]')) return true;
+  }
+  return false;
+}
+function claimRender(prefix, existing, render) {
+  const sc = solidJs.sharedConfig;
+  if (!sc.getNextContextId) return render();
+  const registry = new Map();
+  for (const n of existing) {
+    if (n.nodeType !== 1) continue;
+    gatherClaims(n, registry);
+  }
+  if (!registry.size && !hasPendingFragment(existing)) return render();
+  const prevRegistry = sc.registry;
+  const prevHydrating = sc.hydrating;
+  const prevClaimRoots = sc.claimRoots;
+  if (prevRegistry) for (const key of registry.keys()) prevRegistry.delete(key);
+  sc.registry = registry;
+  sc.hydrating = true;
+  sc.claimRoots = existing;
+  try {
+    return solidJs.runWithOwner(solidJs.createOwner({
+      id: prefix
+    }), render);
+  } finally {
+    sc.registry = prevRegistry;
+    sc.hydrating = prevHydrating;
+    sc.claimRoots = prevClaimRoots;
+  }
+}
+function liveSlotProps(initial, ctx) {
+  const [args, setArgs] = solidJs.createSignal(initial);
+  ctx.onUpdate(next => setArgs(() => next));
+  return new Proxy({}, {
+    get: (_, key) => args()[key],
+    has: (_, key) => key in args(),
+    ownKeys: () => Reflect.ownKeys(args()),
+    getOwnPropertyDescriptor: (_, key) => key in args() ? {
+      enumerable: true,
+      configurable: true
+    } : undefined
+  });
+}
+function isReactiveContent(value) {
+  if (typeof value === "function") return true;
+  if (Array.isArray(value)) {
+    for (const v of value) if (isReactiveContent(v)) return true;
+  }
+  return false;
+}
+function slotsFor(props) {
+  const bindings = new Map();
+  return new Proxy({}, {
+    get(_, prop) {
+      if (typeof prop !== "string" || !(prop in props)) return undefined;
+      return (slotProps, ctx) => {
+        const key = ctx && ctx.key;
+        const prev = key !== undefined && bindings.get(key);
+        if (prev) {
+          bindings.delete(key);
+          prev.dispose();
+        }
+        const settle = out => {
+          const existing = ctx && ctx.existing || [];
+          if (existing.length) {
+            const list = Array.isArray(out) ? out : [out];
+            const inPlace = list.every(n => existing.some(e => e === n || e.nodeType === 1 && e.contains(n)));
+            if (inPlace) return undefined;
+          }
+          return out;
+        };
+        const evaluate = () => {
+          const v = props[prop];
+          if (typeof v === "function" && ctx && ctx.invoked) {
+            return v(ctx.onUpdate ? liveSlotProps(slotProps, ctx) : slotProps);
+          }
+          return v;
+        };
+        const adopted = !!(ctx && ctx.frame && ctx.adopted && ctx.existing && ctx.existing.length);
+        const prefix = ctx && ctx.frame ? `sc-${ctx.frame}-${ctx.key}-` : "";
+        const value = adopted ? claimRender(prefix, ctx.existing, evaluate) : evaluate();
+        if (!isReactiveContent(value)) {
+          return settle(normalizeSlotContent(value));
+        }
+        if (ctx && ctx.range) {
+          let claim = adopted;
+          const source = value;
+          const accessor = () => {
+            if (claim) {
+              claim = false;
+              return claimRender(prefix, ctx.existing, () => typeof source === "function" ? source() : source);
+            }
+            return typeof source === "function" ? source() : source;
+          };
+          const owner = solidJs.createOwner();
+          bindings.set(key, owner);
+          ctx.onCleanup(() => {
+            if (bindings.get(key) === owner) bindings.delete(key);
+            owner.dispose();
+          });
+          const end = ctx.range.end;
+          solidJs.runWithOwner(owner, () => web$1.insert(end.parentNode, accessor, end, [...ctx.existing]));
+          return undefined;
+        }
+        return settle(normalizeSlotContent(value));
+      };
+    }
+  });
+}
+function revealSeam(owner) {
+  return seam => solidJs.runWithOwner(owner, () => web$1.insert(seam.before.parentNode, solidJs.createLoadingBoundary(() => seam.content(), () => seam.fallback), seam.before));
+}
+function boundaryScope(owner) {
+  return fn => solidJs.getOwner() ? fn() : solidJs.runWithOwner(owner, fn);
+}
+function boundaryComponent(host, id) {
+  return props => {
+    const owner = solidJs.getOwner();
+    const {
+      element,
+      dispose
+    } = createFrameElement({
+      host,
+      id,
+      slots: slotsFor(props),
+      ownerScope: boundaryScope(owner),
+      reveal: revealSeam(owner)
+    });
+    solidJs.onCleanup(dispose);
+    return element;
+  };
+}
+const claimedBoundaries = new Set();
+let boundaryIndex = null;
+const isBoundaryId = id => !id.includes(".");
+function indexBoundaries(root) {
+  root.querySelectorAll(`[${FRAME_ID_ATTR}]`).forEach(el => {
+    const key = el.getAttribute(FRAME_ID_ATTR);
+    if (key && isBoundaryId(key) && !boundaryIndex.has(key)) boundaryIndex.set(key, el);
+  });
+}
+function findBoundaryElement(id) {
+  if (!boundaryIndex) {
+    boundaryIndex = new Map();
+    if (typeof document !== "undefined" && document.body) indexBoundaries(document.body);
+  }
+  return boundaryIndex.get(id);
+}
+const boundaryWaiters = new Map();
+function documentStreaming() {
+  const hy = globalThis._$HY;
+  return !!hy && !hy.done;
+}
+function installRevealHook() {
+  const hy = globalThis._$HY;
+  if (!hy || hy.$sc) return;
+  hy.$sc = true;
+  const prev = hy.fe;
+  hy.fe = (fragmentId, parent) => {
+    if (prev) prev(fragmentId, parent);
+    if (!boundaryIndex) return;
+    const root = parent || (typeof document !== "undefined" ? document.body : null);
+    if (!root) return;
+    indexBoundaries(root);
+    for (const [id, notify] of boundaryWaiters) {
+      const el = boundaryIndex.get(id);
+      if (!el) continue;
+      boundaryWaiters.delete(id);
+      notify(el);
+    }
+  };
+}
+function documentBoundary(host, id, props) {
+  const claimed = claimedBoundaries.has(id);
+  const el = !claimed ? findBoundaryElement(id) : undefined;
+  if (el) return adoptBoundary(host, id, el, props);
+  if (!claimed && !boundaryWaiters.has(id) && documentStreaming()) {
+    const owner = solidJs.getOwner();
+    const arrival = new Promise(resolve => boundaryWaiters.set(id, resolve));
+    solidJs.onCleanup(() => boundaryWaiters.delete(id));
+    return solidJs.createMemo(() => arrival.then(node => solidJs.runWithOwner(owner, () => adoptBoundary(host, id, node, props))));
+  }
+  return boundaryComponent(host, id)(props);
+}
+function adoptBoundary(host, id, el, props) {
+  claimedBoundaries.add(id);
+  const hy = globalThis._$HY;
+  if (hy && hy.r) {
+    const slotPrefix = `sc:slot:${id}:`;
+    for (const key of Object.keys(hy.r)) {
+      if (key.startsWith(slotPrefix)) {
+        host.apply({
+          type: "slot",
+          id,
+          version: 0,
+          key: key.slice(slotPrefix.length),
+          args: hy.r[key]
+        });
+      } else if (key.startsWith("sc:region:")) {
+        const childId = key.slice("sc:region:".length);
+        if (childId.startsWith(id + ".")) {
+          const val = hy.r[key];
+          const apply = html => host.apply({
+            type: "html",
+            id: childId,
+            version: 0,
+            html
+          });
+          val && typeof val.then === "function" ? val.then(apply) : apply(val);
+        }
+      }
+    }
+  }
+  const owner = solidJs.getOwner();
+  const frame = createFrame(el, {
+    adopt: true,
+    host,
+    id,
+    slots: slotsFor(props),
+    ownerScope: boundaryScope(owner),
+    reveal: revealSeam(owner)
+  });
+  solidJs.onCleanup(() => frame.dispose());
+  return el;
+}
+function installServerComponents(host = getFrameHost()) {
+  const g = globalThis;
+  if (!g._$SC) {
+    g._$SC = {
+      c: {},
+      a: {},
+      r(i, a) {
+        if (a) {
+          g._$SC.a[a] = i;
+          g._$SC.reg && g._$SC.reg(a, i);
+        }
+        return g._$SC.c[i] || (g._$SC.c[i] = p => g._$SC.impl(i, p));
+      }
+    };
+  }
+  g._$SC.impl = (id, props) => documentBoundary(host, id, props);
+  installRevealHook();
+  const handler = createServerComponentHandler({
+    host,
+    component: frameId => boundaryComponent(host, frameId),
+    onStream: frameId => beginStream(frameId),
+    documentComponent: functionId => claimedBoundaries.has(functionId) ? undefined : g._$SC.c[functionId],
+    intercept: ({
+      id
+    }) => {
+      if (claimedBoundaries.has(id) || !findBoundaryElement(id)) return undefined;
+      return g._$SC.r(id);
+    }
+  });
+  const showing = (address, id) => handler.showing(address, id, g._$SC.r(id));
+  const records = g._$SC.a || (g._$SC.a = {});
+  for (const address in records) showing(address, records[address]);
+  g._$SC.reg = showing;
+  client.configureServerFunctionsClient({
+    responseHandler: handler
+  });
+}
+
+exports.FRAME_APPLIED_EVENT = FRAME_APPLIED_EVENT;
+exports.FRAME_STREAM_HEADER = FRAME_STREAM_HEADER;
+exports.applyFrameResponse = applyFrameResponse;
+exports.createFrame = createFrame;
+exports.createFrameElement = createFrameElement;
+exports.createFrameHost = createFrameHost;
+exports.createJSONDataTable = createJSONDataTable;
+exports.createServerComponentHandler = createServerComponentHandler;
+exports.getFrameHost = getFrameHost;
+exports.installServerComponents = installServerComponents;
+exports.isFrameStreamResponse = isFrameStreamResponse;