@solidjs/web 2.0.0-rc.2 → 2.0.0-rc.4

package/dist/web.cjs

@@ -57,23 +57,16 @@ const transparentOptions = {
 const syncOptions = {
   sync: true
 };
-const effect = (fn, effectFn, options) => solidJs.createRenderEffect(fn, effectFn, options ? {
-  sync: true,
-  ...options,
-  transparent: !options.scope
-} : transparentOptions);
-const memo = fn => solidJs.createMemo(() => fn(), syncOptions);
-const assetGates = new WeakMap();
-const waitAsset = promise => {
-  let gate = assetGates.get(promise);
-  if (!gate) {
-    solidJs.runWithOwner(null, () => {
-      gate = solidJs.createMemo(() => promise);
-    });
-    assetGates.set(promise, gate);
-  }
-  gate();
-};
+function effect(fn, effectFn, options) {
+  solidJs.createRenderEffect(fn, effectFn, options ? {
+    sync: true,
+    ...options,
+    transparent: !options.scope
+  } : transparentOptions);
+}
+function memo(fn) {
+  return solidJs.createMemo(() => fn(), syncOptions);
+}
 
 function reconcileArrays(parentNode, a, b, marker) {
   let bLength = b.length,
@@ -329,11 +322,34 @@ function getServerFunctionRPC() {
   return globalThis[SERVER_FUNCTION_RPC];
 }
 
-const $$EVENT_OWNER = "_$DX_EVENT_OWNER";
+const assetGates = new WeakMap();
+const waitAsset = promise => {
+  let gate = assetGates.get(promise);
+  if (!gate) {
+    solidJs.runWithOwner(null, () => {
+      gate = solidJs.createMemo(() => promise);
+    });
+    assetGates.set(promise, gate);
+  }
+  gate();
+};
+exports.listDriver = void 0;
+function installListDriver(driver) {
+  exports.listDriver = driver;
+}
+const $$EVENT_OWNER = "_$SOLID_EVENT_OWNER";
 const INNER_OWNED = {};
 const delegatedEvents = new Set();
 const delegatedContainers = new Map();
-function render$1(code, element, init, options = {}) {
+function voidFn() {}
+function generateHydrationScript(_options) {
+  return "";
+}
+function HydrationScript(_props) {
+  return null;
+}
+const getRequestEvent = voidFn;
+function render(code, element, init, options = {}) {
   let disposer;
   registerDelegatedRoot(element);
   try {
@@ -344,15 +360,20 @@ function render$1(code, element, init, options = {}) {
         effect(() => solidJs.flatten(tree), () => {});
       } else {
         const tree = code();
-        insert(element, () => tree, element.firstChild ? null : undefined, init, options.insertOptions);
+        insert(element, () => tree, element.firstChild ? null : undefined, init, {
+          ...options.insertOptions,
+          schedule: true
+        });
       }
     }, {
       id: options.renderId
     });
+    solidJs.flush();
   } catch (err) {
     if (disposer) disposer();
     unregisterDelegatedRoot(element);
     throw err;
+  } finally {
   }
   return () => {
     disposer();
@@ -437,7 +458,7 @@ function setProperty(node, name, value) {
   node[name] = value;
 }
 let claimHandlers = null;
-const CLAIM_SEAM = Symbol.for("dom-expressions.element-claims");
+const CLAIM_SEAM = Symbol.for("solid.element-claims");
 function registerElementClaim(handler) {
   (claimHandlers || (claimHandlers = globalThis[CLAIM_SEAM] = [])).push(handler);
   return () => {
@@ -591,11 +612,6 @@ function ref(fn, element) {
   const resolved = solidJs.untrack(fn);
   solidJs.runWithOwner(null, () => applyRef(resolved, element));
 }
-const PURE_ROW = Symbol.for("solid.pure-row");
-function rowProof(fn) {
-  fn[PURE_ROW] = true;
-  return fn;
-}
 function scope(fn) {
   fn.$s = true;
   return fn;
@@ -659,16 +675,16 @@ function stripTextSeparators(nodes) {
   nodes.length = j;
   return nodes;
 }
-function patchDriver(subject, body) {
-  {
-    effect(() => body(subject, subject, false), () => body(subject, undefined, true));
-  }
-}
 function insert(parent, accessor, marker, initial, options) {
   const multi = marker !== undefined;
   const host = options && options.host;
   if (multi && !initial) initial = [];
   if (hydrationRt !== null) initial = hydrationRt.claimInitial(parent, multi, initial);
+  if (exports.listDriver !== undefined && typeof accessor === "function" && accessor.$ll !== undefined) {
+    const listAccessor = accessor;
+    const owner = solidJs.getOwner();
+    if (exports.listDriver(parent, accessor, marker, () => solidJs.runWithOwner(owner, () => insert(parent, () => listAccessor(), marker, marker !== undefined ? [] : undefined, options)))) return;
+  }
   if (typeof accessor !== "function") {
     accessor = normalize(accessor, initial, multi, true);
     if (typeof accessor !== "function") {
@@ -1140,9 +1156,19 @@ function loadModuleAssets(mapping) {
   }
   return pending.length ? Promise.all(pending).then(() => {}) : undefined;
 }
-function hydrate$1(code, element, options = {}) {
+function hydrate(code, element, options = {}) {
+  solidJs.enableHydration();
   installHydrationRuntime();
-  if (globalThis._$HY.done) return render$1(code, element, [...element.childNodes], options);
+  if (globalThis._$HY.done) return render(code, element, [...element.childNodes], options);
+  const head = (element.nodeType === 9 ? element : element.ownerDocument).head;
+  if (head && element.contains(head)) {
+    let n = head.firstChild;
+    while (n && n.nodeType === 1 && n.hasAttribute("data-dh") && !n.hasAttribute("data-dhf")) {
+      const next = n.nextSibling;
+      head.appendChild(n);
+      n = next;
+    }
+  }
   options.renderId ||= "";
   if (!globalThis._$HY.modules) globalThis._$HY.modules = {};
   if (!globalThis._$HY.loading) globalThis._$HY.loading = {};
@@ -1191,7 +1217,7 @@ function hydrate$1(code, element, options = {}) {
         solidJs.sharedConfig.gather = gather;
         solidJs.sharedConfig.hydrating = true;
         try {
-          disposer = render$1(code, element, [...element.childNodes], options);
+          disposer = render(code, element, [...element.childNodes], options);
         } finally {
           solidJs.sharedConfig.hydrating = false;
         }
@@ -1199,14 +1225,14 @@ function hydrate$1(code, element, options = {}) {
         console.error("Hydration module preload failed, falling back to client render:", err);
         solidJs.sharedConfig.hydrating = false;
         solidJs.sharedConfig.registry = undefined;
-        disposer = render$1(code, element, [...element.childNodes], options);
+        disposer = render(code, element, [...element.childNodes], options);
       });
       return () => disposer && disposer();
     }
   }
   try {
     gatherHydratable(element, options.renderId);
-    return render$1(code, element, [...element.childNodes], options);
+    return render(code, element, [...element.childNodes], options);
   } finally {
     solidJs.sharedConfig.hydrating = false;
   }
@@ -1393,7 +1419,7 @@ function eventHandler(e, container, state) {
   const handleNode = () => {
     let handler = node[key];
     if (handler === undefined && node.hasAttribute && node.hasAttribute("_bnd")) {
-      const seam = globalThis[Symbol.for("dx.bnd")];
+      const seam = globalThis[Symbol.for("solid.bnd")];
       if (seam) handler = seam.resolve(node, e.type);
     }
     if (handler && !node.disabled) {
@@ -1442,7 +1468,16 @@ function eventHandler(e, container, state) {
 }
 function insertExpression(parent, value, current, marker) {
   if (hydrationRt !== null && isHydrating(parent)) {
-    if (value && value !== current) for (const n of Array.isArray(value) ? value : [value]) if (n && n.nodeType && !isHydrating(n)) return current;
+    if (value && value !== current) {
+      const arr = Array.isArray(value);
+      for (const n of arr ? value : [value]) {
+        if (n && n.nodeType) {
+          if (!isHydrating(n)) return current;
+        } else if (arr && (typeof n === "string" || typeof n === "number")) {
+          return current;
+        }
+      }
+    }
     return value;
   }
   if (value === current) return value;
@@ -1473,6 +1508,17 @@ function insertExpression(parent, value, current, marker) {
     if (marker) value[$$SLOT] = marker;
   } else if (Array.isArray(value)) {
     const currentArray = current && Array.isArray(current);
+    for (let i = 0, len = value.length; i < len; i++) {
+      const item = value[i],
+        t = typeof item;
+      if (t === "string" || t === "number") {
+        const prev = currentArray ? current[i] : undefined;
+        if (prev && prev.nodeType === 3) {
+          if (prev.data !== "" + item) prev.data = item;
+          value[i] = prev;
+        } else value[i] = document.createTextNode(item);
+      }
+    }
     if (value.length === 0) {
       cleanChildren(parent, current, marker);
     } else if (currentArray) {
@@ -1493,12 +1539,12 @@ function normalize(value, current, multi, doNotUnwrap) {
   });
   if (doNotUnwrap && typeof value === "function") return value;
   if (multi && !Array.isArray(value)) value = [value != null ? value : ""];
-  if (Array.isArray(value)) {
+  if (solidJs.sharedConfig.hydrating && Array.isArray(value)) {
     for (let i = 0, len = value.length; i < len; i++) {
       const item = value[i],
         prev = current && current[i],
         t = typeof item;
-      if (t === "string" || t === "number") value[i] = prev && prev.nodeType === 3 && (solidJs.sharedConfig.hydrating || prev.data === "" + item) ? prev : document.createTextNode(item);
+      if ((t === "string" || t === "number") && prev && prev.nodeType === 3) value[i] = prev;
     }
   }
   return value;
@@ -1579,9 +1625,324 @@ function gatherHydratable(element, root) {
 function getHydrationKey() {
   return solidJs.sharedConfig.getNextContextId();
 }
-const voidFn = () => undefined;
 const RequestContext = Symbol();
 
+const PURE_ROW = Symbol.for("solid.pure-row");
+const arm = () => {
+  installListDriver(driveList);
+};
+function rowProof(fn) {
+  arm();
+  fn[PURE_ROW] = true;
+  return fn;
+}
+let rowCollector = null;
+const lisPositions = sources => {
+  const n = sources.length;
+  const tails = [];
+  const tailsIdx = [];
+  const prev = new Array(n).fill(-1);
+  for (let j = 0; j < n; j++) {
+    const v = sources[j];
+    if (v === -1) continue;
+    let lo = 0,
+      hi = tails.length;
+    while (lo < hi) {
+      const mid = lo + hi >> 1;
+      if (tails[mid] < v) lo = mid + 1;else hi = mid;
+    }
+    if (lo > 0) prev[j] = tailsIdx[lo - 1];
+    tails[lo] = v;
+    tailsIdx[lo] = j;
+  }
+  const stable = new Set();
+  let k = tailsIdx.length ? tailsIdx[tails.length - 1] : -1;
+  while (k >= 0) {
+    stable.add(k);
+    k = prev[k];
+  }
+  return stable;
+};
+const driveList = (parent, listFn, marker, lateClassic) => {
+  const meta = listFn.$ll;
+  if (meta.row?.[PURE_ROW] !== true) return false;
+  if (typeof meta.keyed === "function") return false;
+  const evalOwner = solidJs.createOwner({
+    id: "&each"
+  });
+  let subject = solidJs.runWithOwner(evalOwner, () => solidJs.untrack(meta.each));
+  evalOwner.dispose();
+  let raw = subject != null ? solidJs.patchableRaw(subject) : undefined;
+  if (raw === undefined || !Array.isArray(raw)) return false;
+  const optimistic = solidJs.storeHasOptimisticFamily(subject);
+  if (optimistic) raw = solidJs.untrack(() => Array.from(subject));
+  const hydrating = !!solidJs.sharedConfig.hydrating;
+  if (hydrating && raw.length === 0) return false;
+  let domRows;
+  let rowIds;
+  if (hydrating) {
+    if (marker !== undefined) return false;
+    domRows = Array.from(parent.children);
+    if (domRows.length !== raw.length) return false;
+    rowIds = new Array(raw.length);
+    for (let i = 0; i < domRows.length; i++) {
+      const key = domRows[i].getAttribute("_hk");
+      if (key === null || !key.endsWith("0") || key.length < 2) return false;
+      rowIds[i] = key.slice(0, -1);
+    }
+  }
+  const rowFn = meta.row;
+  const endAnchor = marker ?? null;
+  const shallow = solidJs.storeIsShallow(subject);
+  let lastBodies = null;
+  let lastUnbinds = null;
+  const collectBind = (abs, build) => {
+    const prevC = rowCollector;
+    rowCollector = {
+      row: shallow ? subject[abs] : undefined,
+      bodies: [],
+      unbinds: []
+    };
+    try {
+      return build();
+    } finally {
+      lastBodies = rowCollector.bodies;
+      lastUnbinds = rowCollector.unbinds;
+      rowCollector = prevC;
+    }
+  };
+  const listOwner = solidJs.createOwner();
+  let declined = false;
+  const bindRow = (abs, claimId) => {
+    return collectBind(abs, () => solidJs.runWithOwner(listOwner, () => claimId !== undefined ? solidJs.runWithOwner(solidJs.createOwner({
+      id: claimId
+    }), () => solidJs.untrack(() => rowFn(subject[abs]))) : solidJs.untrack(() => rowFn(subject[abs]))));
+  };
+  let entries = new Array(raw.length);
+  let rowBodies = shallow ? new Array(raw.length) : null;
+  let rowUnbinds = new Array(raw.length);
+  const runUnbinds = list => {
+    if (list !== undefined) for (let u = 0; u < list.length; u++) list[u]();
+  };
+  const unbindAllRows = () => {
+    for (let j = 0; j < rowUnbinds.length; j++) runUnbinds(rowUnbinds[j]);
+    rowUnbinds = [];
+  };
+  let prevRaws = raw.slice();
+  try {
+    if (hydrating) {
+      for (let i = 0; i < raw.length; i++) {
+        entries[i] = bindRow(i, rowIds[i]);
+        if (rowBodies !== null) rowBodies[i] = lastBodies;
+        rowUnbinds[i] = lastUnbinds;
+      }
+    } else {
+      for (let i = 0; i < raw.length; i++) {
+        const node = bindRow(i);
+        entries[i] = node;
+        if (rowBodies !== null) rowBodies[i] = lastBodies;
+        rowUnbinds[i] = lastUnbinds;
+        parent.insertBefore(node, endAnchor);
+      }
+    }
+  } catch (err) {
+    unbindAllRows();
+    runUnbinds(lastUnbinds ?? undefined);
+    for (let j = 0; j < entries.length; j++) {
+      const n = entries[j];
+      if (n !== undefined && n.parentNode === parent) n.remove();
+    }
+    listOwner.dispose();
+    throw err;
+  }
+  const identityOps = nextArr => {
+    const keyOf = r => {
+      const w = r != null ? solidJs.patchableRaw(r) : undefined;
+      return w !== undefined ? w : r;
+    };
+    const oldIndex = new Map();
+    for (let j = 0; j < prevRaws.length; j++) {
+      const k = keyOf(prevRaws[j]);
+      const existing = oldIndex.get(k);
+      if (existing === undefined) oldIndex.set(k, j);else if (Array.isArray(existing)) existing.push(j);else oldIndex.set(k, [existing, j]);
+    }
+    const sources = new Array(nextArr.length);
+    for (let k = 0; k < nextArr.length; k++) {
+      const m = oldIndex.get(keyOf(nextArr[k]));
+      if (m === undefined) sources[k] = -1;else if (Array.isArray(m)) {
+        sources[k] = m.shift();
+        if (m.length === 1) oldIndex.set(keyOf(nextArr[k]), m[0]);
+      } else {
+        sources[k] = m;
+        oldIndex.delete(keyOf(nextArr[k]));
+      }
+    }
+    return {
+      prefix: 0,
+      sources
+    };
+  };
+  let resyncNeeded = false;
+  const applyOps = (next, ops) => {
+    if (declined) return;
+    if (resyncNeeded) ops = null;
+    if (ops === null) ops = identityOps(next);
+    const {
+      prefix,
+      sources
+    } = ops;
+    const built = new Array(sources.length);
+    const builtBodies = rowBodies !== null ? new Array(sources.length) : null;
+    const builtUnbinds = new Array(sources.length);
+    let j = 0;
+    try {
+      for (; j < sources.length; j++) {
+        const abs = prefix + j;
+        const src = sources[j];
+        if (src === -1 || refRebuild && src >= 0 && next[abs] !== prevRaws[src]) {
+          built[j] = bindRow(abs);
+          if (builtBodies !== null) builtBodies[j] = lastBodies;
+          builtUnbinds[j] = lastUnbinds;
+        }
+      }
+    } catch (err) {
+      for (let k = 0; k < j; k++) runUnbinds(builtUnbinds[k]);
+      runUnbinds(lastUnbinds ?? undefined);
+      resyncNeeded = true;
+      throw err;
+    }
+    const retained = new Set();
+    for (let k = 0; k < sources.length; k++) {
+      if (sources[k] >= 0 && built[k] === undefined) retained.add(sources[k]);
+    }
+    for (let k = prefix; k < entries.length; k++) {
+      if (!retained.has(k)) {
+        entries[k].remove();
+        runUnbinds(rowUnbinds[k]);
+      }
+    }
+    const newEntries = new Array(prefix + sources.length);
+    const newBodies = rowBodies !== null ? new Array(prefix + sources.length) : null;
+    const newUnbinds = new Array(prefix + sources.length);
+    for (let i = 0; i < prefix; i++) {
+      newEntries[i] = entries[i];
+      if (newBodies !== null) newBodies[i] = rowBodies[i];
+      newUnbinds[i] = rowUnbinds[i];
+    }
+    const stable = lisPositions(sources);
+    let anchor = endAnchor;
+    for (let k = sources.length - 1; k >= 0; k--) {
+      const abs = prefix + k;
+      const src = sources[k];
+      let node;
+      if (built[k] !== undefined) {
+        node = built[k];
+        if (newBodies !== null) newBodies[abs] = builtBodies[k];
+        newUnbinds[abs] = builtUnbinds[k];
+        parent.insertBefore(node, anchor);
+      } else {
+        node = entries[src];
+        if (newBodies !== null) newBodies[abs] = rowBodies[src];
+        newUnbinds[abs] = rowUnbinds[src];
+        if (!stable.has(k)) parent.insertBefore(node, anchor);
+      }
+      newEntries[abs] = node;
+      anchor = node;
+    }
+    entries = newEntries;
+    if (newBodies !== null) rowBodies = newBodies;
+    rowUnbinds = newUnbinds;
+    prevRaws = next.slice();
+    resyncNeeded = false;
+  };
+  let unbindOps = solidJs.runWithOwner(listOwner, () => solidJs.registerRowOps(subject, applyOps));
+  const refRebuild = shallow && typeof meta.keyed !== "function";
+  const rebuildSlot = i => {
+    runUnbinds(rowUnbinds[i]);
+    const old = entries[i];
+    const node = bindRow(i);
+    rowBodies[i] = lastBodies;
+    rowUnbinds[i] = lastUnbinds;
+    parent.insertBefore(node, old);
+    old.remove();
+    entries[i] = node;
+  };
+  const applySlot = (i, next, prev) => {
+    if (declined) return;
+    if (resyncNeeded) {
+      const live = subject != null ? solidJs.patchableRaw(subject) : undefined;
+      if (live !== undefined && Array.isArray(live)) applyOps(live, null);
+      return;
+    }
+    if (refRebuild) {
+      rebuildSlot(i);
+      prevRaws[i] = next;
+      return;
+    }
+    const bodies = rowBodies[i];
+    if (bodies !== undefined) {
+      for (let b = 0; b < bodies.length; b++) bodies[b](next, prev, false);
+    }
+    prevRaws[i] = next;
+  };
+  let unbindSlots = shallow ? solidJs.runWithOwner(listOwner, () => solidJs.registerSlotPatch(subject, applySlot)) : null;
+  solidJs.runWithOwner(listOwner, () => effect(() => meta.each(), value => {
+    if (declined || value === subject) return;
+    const nextRaw = value != null ? solidJs.patchableRaw(value) : undefined;
+    unbindOps();
+    unbindSlots?.();
+    if (nextRaw !== undefined && Array.isArray(nextRaw) && solidJs.storeIsShallow(value) !== shallow) {
+      for (let j = 0; j < entries.length; j++) entries[j].remove();
+      entries = [];
+      prevRaws = [];
+      unbindAllRows();
+      subject = value;
+      declined = true;
+      listOwner.dispose();
+      lateClassic?.();
+      return;
+    }
+    if (nextRaw === undefined || !Array.isArray(nextRaw)) {
+      for (let j = 0; j < entries.length; j++) entries[j].remove();
+      entries = [];
+      prevRaws = [];
+      unbindAllRows();
+      subject = value;
+      declined = true;
+      listOwner.dispose();
+      lateClassic?.();
+      return;
+    }
+    const swapOps = identityOps(nextRaw);
+    subject = value;
+    unbindOps = solidJs.runWithOwner(listOwner, () => solidJs.registerRowOps(subject, applyOps));
+    if (shallow) unbindSlots = solidJs.runWithOwner(listOwner, () => solidJs.registerSlotPatch(subject, applySlot));
+    applyOps(nextRaw, swapOps);
+  }));
+  solidJs.onCleanup(() => {
+    unbindOps();
+    unbindSlots?.();
+    unbindAllRows();
+    listOwner.dispose();
+  });
+  return true;
+};
+const patchDriver = (subject, body) => {
+  const raw = solidJs.patchableRaw(subject);
+  if (raw !== undefined) {
+    if (!solidJs.sharedConfig.hydrating) body(raw, undefined, true);
+    const unbind = solidJs.registerPatch(subject, body);
+    if (rowCollector !== null) rowCollector.unbinds.push(unbind);
+    else solidJs.onCleanup(unbind);
+  } else if (rowCollector !== null && subject === rowCollector.row) {
+    rowCollector.bodies.push(body);
+    if (!solidJs.sharedConfig.hydrating) body(subject, undefined, true);
+  } else {
+    effect(() => body(subject, subject, false),
+    () => solidJs.untrack(() => body(subject, undefined, true)));
+  }
+};
+
 function throwInBrowser(func) {
   const err = new Error(`${func.name} is not supported in the browser, returning undefined`);
   console.error(err);
@@ -1655,11 +2016,14 @@ function isSafeError(value) {
   return !!(value && (typeof value === "object" || typeof value === "function") && value[SAFE_ERROR]);
 }
 const REVALIDATE_HEADER = "X-Revalidate";
-function initWithRevalidate(init) {
+function initWithRevalidate(init = {}) {
+  const resolved = typeof init === "number" ? {
+    status: init
+  } : init;
   const {
     revalidate,
     ...responseInit
-  } = init;
+  } = resolved;
   let headers;
   if (responseInit.headers && responseInit.headers.getSetCookie) {
     headers = new Headers();
@@ -1685,13 +2049,12 @@ function redirect(url, init = 302) {
   const {
     responseInit,
     headers
-  } = initWithRevalidate(typeof init === "number" ? {
-    status: init
-  } : init);
+  } = initWithRevalidate(init);
   if (responseInit.status === undefined) {
     responseInit.status = 302;
   }
-  headers.set("Location", String(url));
+  const target = typeof url === "string" ? url : url[HREF];
+  headers.set("Location", typeof target === "string" ? target : String(url));
   return new Response(null, {
     ...responseInit,
     headers
@@ -1719,26 +2082,8 @@ function respond(value, init = {}) {
   }), value);
 }
 
-const mergeProps = solidJs.merge;
 const isServer = false;
 const isDev = false;
-function render(code, element, init, options = {}) {
-  try {
-    const dispose = render$1(code, element, init, {
-      ...options,
-      insertOptions: {
-        schedule: true
-      }
-    });
-    solidJs.flush();
-    return dispose;
-  } finally {
-  }
-}
-const hydrate = (...args) => {
-  solidJs.enableHydration();
-  return hydrate$1(...args);
-};
 function Portal(props) {
   return solidJs.runWithOwner(solidJs.createOwner(), () => portalImpl(props));
 }
@@ -1791,7 +2136,7 @@ function portalImpl(props) {
   });
   return treeMarker;
 }
-const COMPONENT_BINDING = Symbol.for("dom-expressions.component-binding");
+const COMPONENT_BINDING = Symbol.for("solid.component-binding");
 function bindingOf(value) {
   return value !== null && (typeof value === "function" || typeof value === "object") && value[COMPONENT_BINDING] || undefined;
 }
@@ -1928,6 +2273,10 @@ Object.defineProperty(exports, "getOwner", {
   enumerable: true,
   get: function () { return solidJs.getOwner; }
 });
+Object.defineProperty(exports, "mergeProps", {
+  enumerable: true,
+  get: function () { return solidJs.merge; }
+});
 Object.defineProperty(exports, "untrack", {
   enumerable: true,
   get: function () { return solidJs.untrack; }
@@ -1938,7 +2287,7 @@ exports.DOMWithState = DOMWithState;
 exports.DelegatedEvents = DelegatedEvents;
 exports.Dynamic = Dynamic;
 exports.HREF = HREF;
-exports.HydrationScript = voidFn;
+exports.HydrationScript = HydrationScript;
 exports.MathMLElements = MathMLElements;
 exports.Namespaces = Namespaces;
 exports.Portal = Portal;
@@ -1964,11 +2313,12 @@ exports.createRequestEvent = createRequestEvent;
 exports.createResponseStub = createResponseStub;
 exports.createSSRResponse = createSSRResponse;
 exports.delegateEvents = delegateEvents;
+exports.driveList = driveList;
 exports.dynamic = dynamic;
 exports.dynamicProperty = dynamicProperty;
 exports.effect = effect;
 exports.escape = escape;
-exports.generateHydrationScript = voidFn;
+exports.generateHydrationScript = generateHydrationScript;
 exports.getDelegatedRoot = getDelegatedRoot;
 exports.getExpectedRedirectStatus = getExpectedRedirectStatus;
 exports.getFirstChild = getFirstChild;
@@ -1977,7 +2327,7 @@ exports.getNextElement = getNextElement;
 exports.getNextMarker = getNextMarker;
 exports.getNextMatch = getNextMatch;
 exports.getNextSibling = getNextSibling;
-exports.getRequestEvent = voidFn;
+exports.getRequestEvent = getRequestEvent;
 exports.getServerFunctionMetadata = getServerFunctionMetadata;
 exports.getServerFunctionRPC = getServerFunctionRPC;
 exports.hasFlashCookie = hasFlashCookie;
@@ -1986,6 +2336,7 @@ exports.httpStatus = httpStatus;
 exports.hydrate = hydrate;
 exports.insert = insert;
 exports.installHydrationRuntime = installHydrationRuntime;
+exports.installListDriver = installListDriver;
 exports.isDev = isDev;
 exports.isHref = isHref;
 exports.isResponseEnvelope = isResponseEnvelope;
@@ -1994,7 +2345,6 @@ exports.isServer = isServer;
 exports.isServerFunction = isServerFunction;
 exports.markSafeError = markSafeError;
 exports.memo = memo;
-exports.mergeProps = mergeProps;
 exports.parseCookieHeader = parseCookieHeader;
 exports.patchDriver = patchDriver;
 exports.redirect = redirect;
@@ -2030,4 +2380,5 @@ exports.template = template;
 exports.unregisterDelegatedContainer = unregisterDelegatedContainer;
 exports.unregisterDelegatedRoot = unregisterDelegatedRoot;
 exports.useHead = useHead;
+exports.waitAsset = waitAsset;
 exports.warmAsset = warmAsset;