solid-js 1.2.3 → 1.3.0-beta.1

package/types/index.d.ts

@@ -7,7 +7,6 @@ export * from "./render";
 import type { JSX } from "./jsx";
 declare type JSXElement = JSX.Element;
 export type { JSXElement, JSX };
-export declare function awaitSuspense(): void;
 import { writeSignal, serializeGraph, registerGraph, hashValue } from "./reactive/signal";
 declare let DEV: {
     writeSignal: typeof writeSignal;

package/types/jsx.d.ts

@@ -92,6 +92,7 @@ export namespace JSX {
     onFocusIn?: EventHandlerUnion<T, FocusEvent>;
     onBlur?: EventHandlerUnion<T, FocusEvent>;
     onChange?: EventHandlerUnion<T, Event>;
+    onInvalid?: EventHandlerUnion<T, Event>;
     onInput?: EventHandlerUnion<T, InputEvent>;
     onBeforeInput?: EventHandlerUnion<T, InputEvent>;
     onReset?: EventHandlerUnion<T, Event>;
@@ -180,6 +181,7 @@ export namespace JSX {
     onfocusin?: EventHandlerUnion<T, FocusEvent>;
     onblur?: EventHandlerUnion<T, FocusEvent>;
     onchange?: EventHandlerUnion<T, Event>;
+    oninvalid?: EventHandlerUnion<T, Event>;
     oninput?: EventHandlerUnion<T, InputEvent>;
     onbeforeinput?: EventHandlerUnion<T, InputEvent>;
     onreset?: EventHandlerUnion<T, Event>;

package/types/reactive/signal.d.ts

@@ -1,16 +1,14 @@
 import { requestCallback } from "./scheduler";
 import type { JSX } from "../jsx";
-export declare type Accessor<T> = () => T;
-export declare type Setter<T> = undefined extends T ? <U extends T>(v?: (U extends Function ? never : U) | ((prev?: T) => U)) => U : <U extends T>(v: (U extends Function ? never : U) | ((prev: T) => U)) => U;
 export declare const equalFn: <T>(a: T, b: T) => boolean;
 export declare const $PROXY: unique symbol;
 export declare const NOTPENDING: {};
 export declare var Owner: Owner | null;
-export declare let Transition: Transition | null;
+export declare let Transition: TransitionState | null;
 declare global {
     var _$afterUpdate: () => void;
 }
-interface Signal<T> {
+export interface SignalState<T> {
     value?: T;
     observers: Computation<any>[] | null;
     observerSlots: number[] | null;
@@ -19,7 +17,7 @@ interface Signal<T> {
     comparator?: (prev: T, next: T) => boolean;
     name?: string;
 }
-interface Owner {
+export interface Owner {
     owned: Computation<any>[] | null;
     cleanups: (() => void)[] | null;
     owner: Owner | null;
@@ -30,23 +28,20 @@ interface Owner {
     name?: string;
     componentName?: string;
 }
-interface Computation<T> extends Owner {
-    fn: (v?: T) => T;
+export interface Computation<Init, Next extends Init = Init> extends Owner {
+    fn: EffectFunction<Init, Next>;
     state: number;
     tState?: number;
-    sources: Signal<T>[] | null;
+    sources: SignalState<Next>[] | null;
     sourceSlots: number[] | null;
-    value?: T;
+    value?: Init;
     updatedAt: number | null;
     pure: boolean;
     user?: boolean;
     suspense?: SuspenseContextType;
 }
-interface Memo<T> extends Signal<T>, Computation<T> {
-    tOwned?: Computation<any>[];
-}
-interface Transition {
-    sources: Set<Signal<any>>;
+export interface TransitionState {
+    sources: Set<SignalState<any>>;
     effects: Computation<any>[];
     promises: Set<Promise<any>>;
     disposed: Set<Computation<any>>;
@@ -55,6 +50,7 @@ interface Transition {
     running: boolean;
     cb: (() => void)[];
 }
+export declare type RootFunction<T> = (dispose: () => void) => T;
 /**
  * Creates a new non-tracked reactive context that doesn't auto-dispose
  *
@@ -64,11 +60,13 @@ interface Transition {
  *
  * @description https://www.solidjs.com/docs/latest/api#createroot
  */
-export declare function createRoot<T>(fn: (dispose: () => void) => T, detachedOwner?: Owner): T;
-export declare type SignalOptions<T> = {
-    name?: string;
-    equals?: false | ((prev: T, next: T) => boolean);
-};
+export declare function createRoot<T>(fn: RootFunction<T>, detachedOwner?: Owner): T;
+export declare type Accessor<T> = () => T;
+export declare type Setter<T> = undefined extends T ? <U extends T>(value?: (U extends Function ? never : U) | ((prev?: T) => U)) => U : <U extends T>(value: (U extends Function ? never : U) | ((prev: T) => U)) => U;
+export declare type Signal<T> = [get: Accessor<T>, set: Setter<T>];
+export interface SignalOptions<T> extends MemoOptions<T> {
+    internal?: boolean;
+}
 /**
  * Creates a simple reactive state with a getter and setter
  * ```typescript
@@ -92,18 +90,21 @@ export declare type SignalOptions<T> = {
  *
  * @description https://www.solidjs.com/docs/latest/api#createsignal
  */
-export declare function createSignal<T>(): [get: Accessor<T | undefined>, set: Setter<T | undefined>];
-export declare function createSignal<T>(value: T, options?: {
-    equals?: false | ((prev: T, next: T) => boolean);
+export declare function createSignal<T>(): Signal<T | undefined>;
+export declare function createSignal<T>(value: T, options?: SignalOptions<T>): Signal<T>;
+export interface BaseOptions {
     name?: string;
-    internal?: boolean;
-}): [get: Accessor<T>, set: Setter<T>];
+}
+export declare type NoInfer<T extends any> = [T][T extends any ? 0 : never];
+export interface EffectOptions extends BaseOptions {
+}
+export declare type EffectFunction<Prev, Next extends Prev = Prev> = (v: Prev) => Next;
 /**
  * Creates a reactive computation that runs immediately before render, mainly used to write to other reactive primitives
  * ```typescript
- * export function createComputed<T>(
- *   fn: (v: T) => T,
- *   value?: T,
+ * export function createComputed<Next, Init = Next>(
+ *   fn: (v: Init | Next) => Next,
+ *   value?: Init,
  *   options?: { name?: string }
  * ): void;
  * ```
@@ -113,10 +114,8 @@ export declare function createSignal<T>(value: T, options?: {
  *
  * @description https://www.solidjs.com/docs/latest/api#createcomputed
  */
-export declare function createComputed<T>(fn: (v?: T) => T | undefined): void;
-export declare function createComputed<T>(fn: (v: T) => T, value: T, options?: {
-    name?: string;
-}): void;
+export declare function createComputed<Next, Init = Next>(fn: EffectFunction<Init | Next, Next>, value: Init, options?: EffectOptions): void;
+export declare function createComputed<Next, Init = undefined>(..._: undefined extends Init ? [fn: EffectFunction<Init | Next, Next>, value?: Init, options?: EffectOptions] : [fn: EffectFunction<Init | Next, Next>, value: Init, options?: EffectOptions]): void;
 /**
  * Creates a reactive computation that runs during the render phase as DOM elements are created and updated but not necessarily connected
  * ```typescript
@@ -132,10 +131,8 @@ export declare function createComputed<T>(fn: (v: T) => T, value: T, options?: {
  *
  * @description https://www.solidjs.com/docs/latest/api#createrendereffect
  */
-export declare function createRenderEffect<T>(fn: (v?: T) => T | undefined): void;
-export declare function createRenderEffect<T>(fn: (v: T) => T, value: T, options?: {
-    name?: string;
-}): void;
+export declare function createRenderEffect<Next, Init = Next>(fn: EffectFunction<Init | Next, Next>, value: Init, options?: EffectOptions): void;
+export declare function createRenderEffect<Next, Init = undefined>(..._: undefined extends Init ? [fn: EffectFunction<Init | Next, Next>, value?: Init, options?: EffectOptions] : [fn: EffectFunction<Init | Next, Next>, value: Init, options?: EffectOptions]): void;
 /**
  * Creates a reactive computation that runs after the render phase
  * ```typescript
@@ -151,10 +148,14 @@ export declare function createRenderEffect<T>(fn: (v: T) => T, value: T, options
  *
  * @description https://www.solidjs.com/docs/latest/api#createeffect
  */
-export declare function createEffect<T>(fn: (v?: T) => T | undefined): void;
-export declare function createEffect<T>(fn: (v: T) => T, value: T, options?: {
-    name?: string;
-}): void;
+export declare function createEffect<Next, Init = Next>(fn: EffectFunction<Init | Next, Next>, value: Init, options?: EffectOptions): void;
+export declare function createEffect<Next, Init = undefined>(..._: undefined extends Init ? [fn: EffectFunction<Init | Next, Next>, value?: Init, options?: EffectOptions] : [fn: EffectFunction<Init | Next, Next>, value: Init, options?: EffectOptions]): void;
+interface Memo<Prev, Next = Prev> extends SignalState<Next>, Computation<Next> {
+    tOwned?: Computation<Prev | Next, Next>[];
+}
+export interface MemoOptions<T> extends EffectOptions {
+    equals?: false | ((prev: T, next: T) => boolean);
+}
 /**
  * Creates a readonly derived reactive memoized signal
  * ```typescript
@@ -170,14 +171,8 @@ export declare function createEffect<T>(fn: (v: T) => T, value: T, options?: {
  *
  * @description https://www.solidjs.com/docs/latest/api#creatememo
  */
-export declare function createMemo<T>(fn: (v?: T) => T, value?: undefined, options?: {
-    equals?: false | ((prev: T, next: T) => boolean);
-    name?: string;
-}): Accessor<T>;
-export declare function createMemo<T>(fn: (v: T) => T, value: T, options?: {
-    equals?: false | ((prev: T, next: T) => boolean);
-    name?: string;
-}): Accessor<T>;
+export declare function createMemo<Next extends _Next, Init = Next, _Next = Next>(fn: EffectFunction<Init | _Next, Next>, value: Init, options?: MemoOptions<Next>): Accessor<Next>;
+export declare function createMemo<Next extends _Next, Init = undefined, _Next = Next>(..._: undefined extends Init ? [fn: EffectFunction<Init | _Next, Next>, value?: Init, options?: MemoOptions<Next>] : [fn: EffectFunction<Init | _Next, Next>, value: Init, options?: MemoOptions<Next>]): Accessor<Next>;
 export interface Resource<T> extends Accessor<T> {
     loading: boolean;
     error: any;
@@ -221,30 +216,30 @@ export declare type ResourceOptions<T> = T extends undefined ? {
  *
  * @description https://www.solidjs.com/docs/latest/api#createresource
  */
-export declare function createResource<T extends any, S = true>(fetcher: ResourceFetcher<S, T>, options?: ResourceOptions<undefined>): [Resource<T | undefined>, ResourceActions<T | undefined>];
-export declare function createResource<T, S = true>(fetcher: ResourceFetcher<S, T>, options: ResourceOptions<T>): [Resource<T>, ResourceActions<T>];
-export declare function createResource<T, S>(source: ResourceSource<S>, fetcher: ResourceFetcher<S, T>, options?: ResourceOptions<undefined>): [Resource<T | undefined>, ResourceActions<T | undefined>];
-export declare function createResource<T, S>(source: ResourceSource<S>, fetcher: ResourceFetcher<S, T>, options: ResourceOptions<T>): [Resource<T>, ResourceActions<T>];
+export declare function createResource<T, S = true>(fetcher: ResourceFetcher<S, T>, options?: ResourceOptions<undefined>): ResourceReturn<T | undefined>;
+export declare function createResource<T, S = true>(fetcher: ResourceFetcher<S, T>, options: ResourceOptions<T>): ResourceReturn<T>;
+export declare function createResource<T, S>(source: ResourceSource<S>, fetcher: ResourceFetcher<S, T>, options?: ResourceOptions<undefined>): ResourceReturn<T | undefined>;
+export declare function createResource<T, S>(source: ResourceSource<S>, fetcher: ResourceFetcher<S, T>, options: ResourceOptions<T>): ResourceReturn<T>;
+export interface DeferredOptions<T> {
+    equals?: false | ((prev: T, next: T) => boolean);
+    name?: string;
+    timeoutMs?: number;
+}
 /**
  * Creates a reactive computation that only runs and notifies the reactive context when the browser is idle
  * ```typescript
  * export function createDeferred<T>(
  *   fn: (v: T) => T,
- *   value?: T,
  *   options?: { timeoutMs?: number, name?: string, equals?: false | ((prev: T, next: T) => boolean) }
  * ): () => T);
  * ```
  * @param fn a function that receives its previous or the initial value, if set, and returns a new value used to react on a computation
- * @param value an optional initial value for the computation; if set, fn will never receive undefined as first argument
  * @param options allows to set the timeout in milliseconds, use a custom comparison function and set a name in dev mode for debugging purposes
  *
  * @description https://www.solidjs.com/docs/latest/api#createdeferred
  */
-export declare function createDeferred<T>(source: Accessor<T>, options?: {
-    equals?: false | ((prev: T, next: T) => boolean);
-    name?: string;
-    timeoutMs?: number;
-}): Accessor<T>;
+export declare function createDeferred<T>(source: Accessor<T>, options?: DeferredOptions<T>): Accessor<T>;
+export declare type EqualityCheckerFunction<T, U> = (a: U, b: T) => boolean;
 /**
  * Creates a conditional signal that only notifies subscribers when entering or exiting their key matching the value
  * ```typescript
@@ -269,9 +264,7 @@ export declare function createDeferred<T>(source: Accessor<T>, options?: {
  *
  * @description https://www.solidjs.com/docs/latest/api#createselector
  */
-export declare function createSelector<T, U>(source: Accessor<T>, fn?: (a: U, b: T) => boolean, options?: {
-    name?: string;
-}): (key: U) => boolean;
+export declare function createSelector<T, U>(source: Accessor<T>, fn?: EqualityCheckerFunction<T, U>, options?: BaseOptions): (key: U) => boolean;
 /**
  * Holds changes inside the block before the reactive context is updated
  * @param fn wraps the reactive updates that should be batched
@@ -279,7 +272,7 @@ export declare function createSelector<T, U>(source: Accessor<T>, fn?: (a: U, b:
  *
  * @description https://www.solidjs.com/docs/latest/api#batch
  */
-export declare function batch<T>(fn: () => T): T;
+export declare function batch<T>(fn: Accessor<T>): T;
 /**
  * Ignores tracking context inside its scope
  * @param fn the scope that is out of the tracking context
@@ -291,6 +284,10 @@ export declare function untrack<T>(fn: Accessor<T>): T;
 export declare type ReturnTypes<T> = T extends (() => any)[] ? {
     [I in keyof T]: ReturnTypes<T[I]>;
 } : T extends () => any ? ReturnType<T> : never;
+export declare type OnEffectFunction<S, Prev, Next extends Prev = Prev> = (input: ReturnTypes<S>, prevInput: ReturnTypes<S>, v: Prev) => Next;
+export interface OnOptions {
+    defer?: boolean;
+}
 /**
  * on - make dependencies of a computation explicit
  * ```typescript
@@ -303,6 +300,8 @@ export declare type ReturnTypes<T> = T extends (() => any)[] ? {
  * @param deps list of reactive dependencies or a single reactive dependency
  * @param fn computation on input; the current previous content(s) of input and the previous value are given as arguments and it returns a new value
  * @param options optional, allows deferred computation until at the end of the next change
+ * @returns an effect function that is passed into createEffect. For example:
+ *
  * ```typescript
  * createEffect(on(a, (v) => console.log(v, b())));
  *
@@ -315,12 +314,7 @@ export declare type ReturnTypes<T> = T extends (() => any)[] ? {
  *
  * @description https://www.solidjs.com/docs/latest/api#on
  */
-export declare function on<T extends (() => any)[], U>(deps: [...T], fn: (input: ReturnTypes<T>, prevInput: ReturnTypes<T>, prevValue?: U) => U, options?: {
-    defer?: boolean;
-}): (prevValue?: U) => U;
-export declare function on<T extends () => any, U>(deps: T, fn: (input: ReturnType<T>, prevInput: ReturnType<T>, prevValue?: U) => U, options?: {
-    defer?: boolean;
-}): (prevValue?: U) => U;
+export declare function on<S extends Accessor<unknown> | Accessor<unknown>[] | [], Next, Init = unknown>(deps: S, fn: OnEffectFunction<S, Init | Next, Next>, options?: OnOptions): EffectFunction<NoInfer<Init> | NoInfer<Next>, NoInfer<Next>>;
 /**
  * onMount - run an effect only after initial render on mount
  * @param fn an effect that should run only once on mount
@@ -344,11 +338,12 @@ export declare function onCleanup(fn: () => void): () => void;
  * @description https://www.solidjs.com/docs/latest/api#onerror
  */
 export declare function onError(fn: (err: any) => void): void;
-export declare function getListener(): Computation<any> | null;
+export declare function getListener(): Computation<any, any> | null;
 export declare function getOwner(): Owner | null;
 export declare function runWithOwner(o: Owner, fn: () => any): any;
 export declare function enableScheduling(scheduler?: typeof requestCallback): void;
 export declare function startTransition(fn: () => void, cb?: () => void): void;
+export declare type Transition = [Accessor<boolean>, (fn: () => void, cb?: () => void) => void];
 /**
  * ```typescript
  * export function useTransition(): [
@@ -359,7 +354,7 @@ export declare function startTransition(fn: () => void, cb?: () => void): void;
  *
  * @description https://www.solidjs.com/docs/latest/api#usetransition
  */
-export declare function useTransition(): [Accessor<boolean>, (fn: () => void, cb?: () => void) => void];
+export declare function useTransition(): Transition;
 export declare function resumeEffects(e: Computation<any>[]): void;
 export declare function devComponent<T>(Comp: (props: T) => JSX.Element, props: T): JSX.Element;
 export declare function hashValue(v: any): string;
@@ -370,12 +365,13 @@ interface GraphRecord {
     [k: string]: GraphRecord | unknown;
 }
 export declare function serializeGraph(owner?: Owner | null): GraphRecord;
+export declare type ContextProviderComponent<T> = (props: {
+    value: T;
+    children: any;
+}) => any;
 export interface Context<T> {
     id: symbol;
-    Provider: (props: {
-        value: T;
-        children: any;
-    }) => any;
+    Provider: ContextProviderComponent<T>;
     defaultValue: T;
 }
 /**
@@ -413,18 +409,20 @@ export declare function useContext<T>(context: Context<T>): T;
  * @description https://www.solidjs.com/docs/latest/api#children
  */
 export declare function children(fn: Accessor<JSX.Element>): Accessor<JSX.Element>;
-declare type SuspenseContextType = {
+export declare type SuspenseContextType = {
     increment?: () => void;
     decrement?: () => void;
     inFallback?: () => boolean;
     effects?: Computation<any>[];
     resolved?: boolean;
 };
-export declare function getSuspenseContext(): Context<SuspenseContextType> & {
+declare type SuspenseContext = Context<SuspenseContextType> & {
     active?(): boolean;
     increment?(): void;
     decrement?(): void;
 };
-export declare function readSignal(this: Signal<any> | Memo<any>): any;
-export declare function writeSignal(node: Signal<any> | Memo<any>, value: any, isComp?: boolean): any;
+declare let SuspenseContext: SuspenseContext;
+export declare function getSuspenseContext(): SuspenseContext;
+export declare function readSignal(this: SignalState<any> | Memo<any>): any;
+export declare function writeSignal(node: SignalState<any> | Memo<any>, value: any, isComp?: boolean): any;
 export {};

package/types/render/hydration.d.ts

@@ -1,13 +1,14 @@
-declare type HydrationContext = {
+export declare type HydrationContext = {
     id: string;
     count: number;
-    loadResource?: (id: string) => Promise<any>;
 };
 declare type SharedConfig = {
     context?: HydrationContext;
     resources?: {
         [key: string]: any;
     };
+    load?: (id: string) => Promise<any> | undefined;
+    gather?: (key: string) => void;
     registry?: Map<string, Element>;
 };
 export declare const sharedConfig: SharedConfig;

package/types/server/index.d.ts

@@ -1,3 +1,3 @@
 export { createRoot, createSignal, createComputed, createRenderEffect, createEffect, createDeferred, createSelector, createMemo, getListener, onMount, onCleanup, onError, untrack, batch, on, children, createContext, useContext, getOwner, runWithOwner, equalFn, requestCallback, mapArray, observable, from, $PROXY, DEV } from "./reactive";
-export { awaitSuspense, mergeProps, splitProps, createComponent, For, Index, Show, Switch, Match, ErrorBoundary, Suspense, SuspenseList, createResource, enableScheduling, startTransition, useTransition, createUniqueId, lazy, sharedConfig } from "./rendering";
+export { mergeProps, splitProps, createComponent, For, Index, Show, Switch, Match, ErrorBoundary, Suspense, SuspenseList, createResource, enableScheduling, startTransition, useTransition, createUniqueId, lazy, sharedConfig } from "./rendering";
 export type { Component, Resource } from "./rendering";

package/types/server/reactive.d.ts

@@ -1,9 +1,8 @@
+import type { Accessor, Setter } from "../reactive/signal";
 export declare const equalFn: <T>(a: T, b: T) => boolean;
 export declare const $PROXY: unique symbol;
 export declare const DEV: {};
 export declare let Owner: Owner | null;
-export declare type Accessor<T> = () => T;
-export declare type Setter<T> = undefined extends T ? <U extends T>(v?: (U extends Function ? never : U) | ((prev?: U) => U)) => U : <U extends T>(v: (U extends Function ? never : U) | ((prev: U) => U)) => U;
 interface Owner {
     owner: Owner | null;
     context: any | null;

package/types/server/rendering.d.ts

@@ -94,8 +94,10 @@ declare type HydrationContext = {
     writeResource?: (id: string, v: Promise<any>) => void;
     resources: Record<string, any>;
     suspense: Record<string, SuspenseContextType>;
+    registerFragment: (v: string) => (v?: string) => void;
     async?: boolean;
     streaming?: boolean;
+    noHydrate: boolean;
 };
 export declare function SuspenseList(props: {
     children: string;
@@ -106,5 +108,4 @@ export declare function Suspense(props: {
     fallback: string;
     children: string;
 }): any;
-export declare function awaitSuspense(fn: () => any): Promise<unknown>;
 export {};

package/web/dist/dev.cjs

@@ -203,60 +203,41 @@ function insert(parent, accessor, marker, initial) {
   solidJs.createRenderEffect(current => insertExpression(parent, accessor(), current, marker), initial);
 }
 function assign(node, props, isSVG, skipChildren, prevProps = {}) {
-  let isCE, isProp, isChildProp;
+  for (const prop in prevProps) {
+    if (!(prop in props)) {
+      if (prop === "children") continue;
+      assignProp(node, prop, null, prevProps[prop], isSVG);
+    }
+  }
   for (const prop in props) {
     if (prop === "children") {
       if (!skipChildren) insertExpression(node, props.children);
       continue;
     }
     const value = props[prop];
-    if (value === prevProps[prop]) continue;
-    if (prop === "style") {
-      style(node, value, prevProps[prop]);
-    } else if (prop === "classList") {
-      classList(node, value, prevProps[prop]);
-    } else if (prop === "ref") {
-      value(node);
-    } else if (prop.slice(0, 3) === "on:") {
-      node.addEventListener(prop.slice(3), value);
-    } else if (prop.slice(0, 10) === "oncapture:") {
-      node.addEventListener(prop.slice(10), value, true);
-    } else if (prop.slice(0, 2) === "on") {
-      const name = prop.slice(2).toLowerCase();
-      const delegate = DelegatedEvents.has(name);
-      addEventListener(node, name, value, delegate);
-      delegate && delegateEvents([name]);
-    } else if ((isChildProp = ChildProperties.has(prop)) || !isSVG && (PropAliases[prop] || (isProp = Properties.has(prop))) || (isCE = node.nodeName.includes("-"))) {
-      if (isCE && !isProp && !isChildProp) node[toPropertyName(prop)] = value;else node[PropAliases[prop] || prop] = value;
-    } else {
-      const ns = isSVG && prop.indexOf(":") > -1 && SVGNamespace[prop.split(":")[0]];
-      if (ns) setAttributeNS(node, ns, prop, value);else setAttribute(node, Aliases[prop] || prop, value);
-    }
-    prevProps[prop] = value;
+    prevProps[prop] = assignProp(node, prop, value, prevProps[prop], isSVG);
   }
 }
 function hydrate(code, element) {
-  solidJs.sharedConfig.resources = globalThis._$HYDRATION.resources;
-  solidJs.sharedConfig.completed = globalThis._$HYDRATION.completed;
-  solidJs.sharedConfig.events = globalThis._$HYDRATION.events;
+  if (!globalThis._$HY.sync) {
+    let dispose;
+    globalThis._$HY.queue.push(() => dispose = hydrate(code, element));
+    return () => dispose();
+  }
+  solidJs.sharedConfig.completed = globalThis._$HY.completed;
+  solidJs.sharedConfig.events = globalThis._$HY.events;
+  solidJs.sharedConfig.load = globalThis._$HY.load;
+  solidJs.sharedConfig.gather = root => gatherHydratable(element, root);
+  solidJs.sharedConfig.registry = new Map();
   solidJs.sharedConfig.context = {
     id: "",
-    count: 0,
-    loadResource: globalThis._$HYDRATION.loadResource
+    count: 0
   };
-  solidJs.sharedConfig.registry = new Map();
   gatherHydratable(element);
   const dispose = render(code, element, [...element.childNodes]);
   solidJs.sharedConfig.context = null;
   return dispose;
 }
-function gatherHydratable(element) {
-  const templates = element.querySelectorAll(`*[data-hk]`);
-  for (let i = 0; i < templates.length; i++) {
-    const node = templates[i];
-    solidJs.sharedConfig.registry.set(node.getAttribute("data-hk"), node);
-  }
-}
 function getNextElement(template) {
   let node, key;
   if (!solidJs.sharedConfig.context || !(node = solidJs.sharedConfig.registry.get(key = getHydrationKey()))) {
@@ -314,6 +295,30 @@ function toggleClassKey(node, key, value) {
   const classNames = key.trim().split(/\s+/);
   for (let i = 0, nameLen = classNames.length; i < nameLen; i++) node.classList.toggle(classNames[i], value);
 }
+function assignProp(node, prop, value, prev, isSVG) {
+  let isCE, isProp, isChildProp;
+  if (prop === "style") return style(node, value, prev);
+  if (prop === "classList") return classList(node, value, prev);
+  if (value === prev) return prev;
+  if (prop === "ref") {
+    value(node);
+  } else if (prop.slice(0, 3) === "on:") {
+    node.addEventListener(prop.slice(3), value);
+  } else if (prop.slice(0, 10) === "oncapture:") {
+    node.addEventListener(prop.slice(10), value, true);
+  } else if (prop.slice(0, 2) === "on") {
+    const name = prop.slice(2).toLowerCase();
+    const delegate = DelegatedEvents.has(name);
+    addEventListener(node, name, value, delegate);
+    delegate && delegateEvents([name]);
+  } else if ((isChildProp = ChildProperties.has(prop)) || !isSVG && (PropAliases[prop] || (isProp = Properties.has(prop))) || (isCE = node.nodeName.includes("-"))) {
+    if (isCE && !isProp && !isChildProp) node[toPropertyName(prop)] = value;else node[PropAliases[prop] || prop] = value;
+  } else {
+    const ns = isSVG && prop.indexOf(":") > -1 && SVGNamespace[prop.split(":")[0]];
+    if (ns) setAttributeNS(node, ns, prop, value);else setAttribute(node, Aliases[prop] || prop, value);
+  }
+  return value;
+}
 function eventHandler(e) {
   const key = `$$${e.type}`;
   let node = e.composedPath && e.composedPath()[0] || e.target;
@@ -326,7 +331,7 @@ function eventHandler(e) {
   Object.defineProperty(e, "currentTarget", {
     configurable: true,
     get() {
-      return node;
+      return node || document;
     }
   });
   while (node !== null) {
@@ -381,7 +386,12 @@ function insertExpression(parent, value, current, marker, unwrapArray) {
       solidJs.createRenderEffect(() => current = insertExpression(parent, array, current, marker, true));
       return () => current;
     }
-    if (solidJs.sharedConfig.context && current && current.length) return current;
+    if (solidJs.sharedConfig.context && current && current.length) {
+      for (let i; i < array.length; i++) {
+        if (array[i].parentNode) return array;
+      }
+      return current;
+    }
     if (array.length === 0) {
       current = cleanChildren(parent, current, marker);
       if (multi) return current;
@@ -449,6 +459,14 @@ function cleanChildren(parent, current, marker, replacement) {
   } else parent.insertBefore(node, marker);
   return [node];
 }
+function gatherHydratable(element, root) {
+  const templates = element.querySelectorAll(`*[data-hk]`);
+  for (let i = 0; i < templates.length; i++) {
+    const node = templates[i];
+    const key = node.getAttribute("data-hk");
+    if (!root || key.startsWith(root)) solidJs.sharedConfig.registry.set(key, node);
+  }
+}
 function getHydrationKey() {
   const hydrate = solidJs.sharedConfig.context;
   return `${hydrate.id}${hydrate.count++}`;
@@ -623,7 +641,6 @@ exports.clearDelegatedEvents = clearDelegatedEvents;
 exports.delegateEvents = delegateEvents;
 exports.dynamicProperty = dynamicProperty;
 exports.escape = escape;
-exports.gatherHydratable = gatherHydratable;
 exports.generateHydrationScript = generateHydrationScript;
 exports.getHydrationKey = getHydrationKey;
 exports.getNextElement = getNextElement;