solid-js 1.9.11 → 2.0.0-beta.0

package/types/server/component.d.ts

@@ -0,0 +1,66 @@
+import type { JSX } from "../jsx.js";
+export declare function enableHydration(): void;
+/**
+ * A general `Component` has no implicit `children` prop.  If desired, you can
+ * specify one as in `Component<{name: String, children: JSX.Element}>`.
+ */
+export type Component<P extends Record<string, any> = {}> = (props: P) => JSX.Element;
+/**
+ * Extend props to forbid the `children` prop.
+ */
+export type VoidProps<P extends Record<string, any> = {}> = P & {
+    children?: never;
+};
+/**
+ * `VoidComponent` forbids the `children` prop.
+ */
+export type VoidComponent<P extends Record<string, any> = {}> = Component<VoidProps<P>>;
+/**
+ * Extend props to allow an optional `children` prop with the usual type in JSX.
+ */
+export type ParentProps<P extends Record<string, any> = {}> = P & {
+    children?: JSX.Element;
+};
+/**
+ * `ParentComponent` allows an optional `children` prop with the usual type in JSX.
+ */
+export type ParentComponent<P extends Record<string, any> = {}> = Component<ParentProps<P>>;
+/**
+ * Extend props to require a `children` prop with the specified type.
+ */
+export type FlowProps<P extends Record<string, any> = {}, C = JSX.Element> = P & {
+    children: C;
+};
+/**
+ * `FlowComponent` requires a `children` prop with the specified type.
+ */
+export type FlowComponent<P extends Record<string, any> = {}, C = JSX.Element> = Component<FlowProps<P, C>>;
+export type ValidComponent = keyof JSX.IntrinsicElements | Component<any> | (string & {});
+/**
+ * Takes the props of the passed component and returns its type
+ */
+export type ComponentProps<T extends ValidComponent> = T extends Component<infer P> ? P : T extends keyof JSX.IntrinsicElements ? JSX.IntrinsicElements[T] : Record<string, unknown>;
+/**
+ * Type of `props.ref`, for use in `Component` or `props` typing.
+ */
+export type Ref<T> = T | ((val: T) => void);
+/**
+ * Creates a component. On server, just calls the function directly (no untrack needed).
+ */
+export declare function createComponent<T extends Record<string, any>>(Comp: Component<T>, props: T): JSX.Element;
+/**
+ * Lazy load a function component asynchronously.
+ * On server, returns a createMemo that throws NotReadyError until the module resolves,
+ * allowing resolveSSRNode to capture it as a fine-grained hole. The memo naturally
+ * scopes the owner so hydration IDs align with the client's createMemo in lazy().
+ * Requires `moduleUrl` for SSR — the bundler plugin injects the module specifier
+ * so the server can look up client chunk URLs from the asset manifest.
+ */
+export declare function lazy<T extends Component<any>>(fn: () => Promise<{
+    default: T;
+}>, moduleUrl?: string): T & {
+    preload: () => Promise<{
+        default: T;
+    }>;
+};
+export declare function createUniqueId(): string;

package/types/server/core.d.ts

@@ -0,0 +1,44 @@
+import type { Accessor, EffectOptions } from "./signals.js";
+import type { JSX } from "../jsx.js";
+import type { FlowComponent } from "./component.js";
+export declare const $DEVCOMP: unique symbol;
+export type NoInfer<T extends any> = [T][T extends any ? 0 : never];
+export type ContextProviderComponent<T> = FlowComponent<{
+    value: T;
+}>;
+export interface Context<T> extends ContextProviderComponent<T> {
+    id: symbol;
+    defaultValue: T;
+}
+/**
+ * Creates a Context to handle a state scoped for the children of a component
+ * @param defaultValue optional default to inject into context
+ * @param options allows to set a name in dev mode for debugging purposes
+ * @returns The context that contains the Provider Component and that can be used with `useContext`
+ */
+export declare function createContext<T>(defaultValue?: undefined, options?: EffectOptions): Context<T | undefined>;
+export declare function createContext<T>(defaultValue: T, options?: EffectOptions): Context<T>;
+/**
+ * Uses a context to receive a scoped state from a parent's Context.Provider
+ * @param context Context object made by `createContext`
+ * @returns the current or `defaultValue`, if present
+ */
+export declare function useContext<T>(context: Context<T>): T;
+export type ResolvedJSXElement = Exclude<JSX.Element, JSX.ArrayElement>;
+export type ResolvedChildren = ResolvedJSXElement | ResolvedJSXElement[];
+export type ChildrenReturn = Accessor<ResolvedChildren> & {
+    toArray: () => ResolvedJSXElement[];
+};
+/**
+ * Resolves child elements to help interact with children
+ * @param fn an accessor for the children
+ * @returns a accessor of the same children, but resolved
+ */
+export declare function children(fn: Accessor<JSX.Element>): ChildrenReturn;
+/**
+ * Pass-through for SSR dynamic expressions.
+ * On the client, insert() render effects are transparent (0 owner slots),
+ * so the server doesn't need to create owners for these either.
+ */
+export declare function ssrRunInScope(fn: () => any): () => any;
+export declare function ssrRunInScope(array: (() => any)[]): (() => any)[];

package/types/server/flow.d.ts

@@ -0,0 +1,60 @@
+import type { Accessor } from "./signals.js";
+import type { JSX } from "../jsx.js";
+/**
+ * Creates a list of elements from a list
+ *
+ * @description https://docs.solidjs.com/reference/components/for
+ */
+export declare function For<T extends readonly any[], U extends JSX.Element>(props: {
+    each: T | undefined | null | false;
+    fallback?: JSX.Element;
+    keyed?: boolean | ((item: T[number]) => any);
+    children: (item: Accessor<T[number]>, index: Accessor<number>) => U;
+}): JSX.Element;
+/**
+ * Creates a list elements from a count
+ *
+ * @description https://docs.solidjs.com/reference/components/repeat
+ */
+export declare function Repeat<T extends JSX.Element>(props: {
+    count: number;
+    from?: number | undefined;
+    fallback?: JSX.Element;
+    children: ((index: number) => T) | T;
+}): JSX.Element;
+/**
+ * Conditionally render its children or an optional fallback component
+ * @description https://docs.solidjs.com/reference/components/show
+ */
+export declare function Show<T>(props: {
+    when: T | undefined | null | false;
+    keyed?: boolean;
+    fallback?: JSX.Element;
+    children: JSX.Element | ((item: Accessor<NonNullable<T>>) => JSX.Element);
+}): JSX.Element;
+/**
+ * Switches between content based on mutually exclusive conditions
+ * @description https://docs.solidjs.com/reference/components/switch-and-match
+ */
+export declare function Switch(props: {
+    fallback?: JSX.Element;
+    children: JSX.Element;
+}): JSX.Element;
+export type MatchProps<T> = {
+    when: T | undefined | null | false;
+    keyed?: boolean;
+    children: JSX.Element | ((item: Accessor<NonNullable<T>>) => JSX.Element);
+};
+/**
+ * Selects a content based on condition when inside a `<Switch>` control flow
+ * @description https://docs.solidjs.com/reference/components/switch-and-match
+ */
+export declare function Match<T>(props: MatchProps<T>): JSX.Element;
+/**
+ * Catches uncaught errors inside components and renders a fallback content
+ * @description https://docs.solidjs.com/reference/components/error-boundary
+ */
+export declare function Errored(props: {
+    fallback: JSX.Element | ((err: any, reset: () => void) => JSX.Element);
+    children: JSX.Element;
+}): JSX.Element;

package/types/server/hydration.d.ts

@@ -0,0 +1,21 @@
+import type { JSX } from "../jsx.js";
+export { sharedConfig } from "./shared.js";
+export type { HydrationContext } from "./shared.js";
+/**
+ * Handles errors during SSR rendering.
+ * Returns the promise source for NotReadyError (for async handling),
+ * or delegates to the ErrorContext handler.
+ */
+export declare function ssrHandleError(err: any): Promise<any> | undefined;
+/**
+ * Tracks all resources inside a component and renders a fallback until they are all resolved
+ *
+ * On the server, this is SSR-aware: it handles async mode (streaming) by registering
+ * fragments and resolving asynchronously, and sync mode by serializing fallback markers.
+ *
+ * @description https://docs.solidjs.com/reference/components/suspense
+ */
+export declare function Loading(props: {
+    fallback?: JSX.Element;
+    children: JSX.Element;
+}): JSX.Element;

package/types/server/index.d.ts

@@ -1,3 +1,12 @@
-export { catchError, createRoot, createSignal, createComputed, createRenderEffect, createEffect, createReaction, createDeferred, createSelector, createMemo, getListener, onMount, onCleanup, onError, untrack, batch, on, children, createContext, useContext, getOwner, runWithOwner, equalFn, requestCallback, mapArray, indexArray, observable, from, $PROXY, $DEVCOMP, $TRACK, DEV, enableExternalSource } from "./reactive.js";
-export { mergeProps, splitProps, createComponent, For, Index, Show, Switch, Match, ErrorBoundary, Suspense, SuspenseList, createResource, resetErrorBoundaries, enableScheduling, enableHydration, startTransition, useTransition, createUniqueId, lazy, sharedConfig } from "./rendering.js";
-export type { Component, Resource } from "./rendering.js";
+export { $PROXY, $TRACK, action, createEffect, createMemo, createOptimistic, createOptimisticStore, createOwner, createProjection, createReaction, createRenderEffect, createRoot, createSignal, createStore, createTrackedEffect, deep, flatten, flush, getNextChildId, getObserver, getOwner, isEqual, isRefreshing, isPending, isWrappable, mapArray, merge, omit, onCleanup, onSettled, latest, reconcile, refresh, repeat, resolve, NotReadyError, runWithOwner, snapshot, storePath, createDeepProxy, untrack } from "./signals.js";
+export type { Accessor, ComputeFunction, EffectFunction, EffectOptions, Merge, NoInfer, NotWrappable, Omit, Owner, Signal, SignalOptions, Setter, Store, SolidStore, StoreNode, StoreSetter, StorePathRange, ArrayFilterFn, CustomPartial, Part, PathSetter, PatchOp } from "./signals.js";
+export { $DEVCOMP, children, createContext, useContext, ssrRunInScope } from "./core.js";
+export type { ChildrenReturn, Context, ContextProviderComponent, ResolvedChildren, ResolvedJSXElement } from "./core.js";
+export * from "./component.js";
+export * from "./flow.js";
+export { sharedConfig, Loading, ssrHandleError } from "./hydration.js";
+export type { HydrationContext } from "./hydration.js";
+import type { JSX } from "../jsx.js";
+type JSXElement = JSX.Element;
+export type { JSXElement, JSX };
+export declare const DEV: undefined;

package/types/server/shared.d.ts

@@ -0,0 +1,45 @@
+type SSRTemplateObject = {
+    t: string[];
+    h: Function[];
+    p: Promise<any>[];
+};
+export type HydrationContext = {
+    id: string;
+    count: number;
+    /**
+     * Serialize a value for client hydration.
+     * In renderToStream (async: true), accepts promises and async iterables.
+     * In renderToString (async: false), only synchronous values are allowed —
+     * passing async values will throw.
+     */
+    serialize: (id: string, v: any, deferStream?: boolean) => void;
+    resolve(value: any): SSRTemplateObject;
+    ssr(template: string[], ...values: any[]): SSRTemplateObject;
+    escape(value: any): string;
+    replace: (id: string, replacement: () => any) => void;
+    block: (p: Promise<any>) => void;
+    registerFragment: (v: string) => (v?: string, err?: any) => boolean;
+    /** Register a client-side asset URL discovered during SSR (e.g. from lazy()). */
+    registerAsset?: (type: "module" | "style", url: string) => void;
+    /** Register a moduleUrl-to-entryUrl mapping for the current boundary. */
+    registerModule?: (moduleUrl: string, entryUrl: string) => void;
+    /** Resolve a module's JS and CSS assets from the asset manifest. Set by dom-expressions. */
+    resolveAssets?: (moduleUrl: string) => {
+        js: string[];
+        css: string[];
+    } | null;
+    /** Retrieve the moduleUrl-to-entryUrl map for a boundary. */
+    getBoundaryModules?: (id: string) => Record<string, string> | null;
+    /** @internal Tracks which Loading boundary is currently rendering. Set by dom-expressions via applyAssetTracking(). */
+    _currentBoundaryId?: string | null;
+    assets: any[];
+    /** True only in renderToStream — enables async data serialization and streaming. */
+    async?: boolean;
+    noHydrate: boolean;
+};
+type SharedConfig = {
+    context?: HydrationContext;
+    getNextContextId(): string;
+};
+export declare const sharedConfig: SharedConfig;
+export {};

package/types/server/signals.d.ts

@@ -0,0 +1,60 @@
+export { createRoot, createOwner, runWithOwner, getOwner, onCleanup, getNextChildId, createContext, setContext, getContext, NotReadyError, NoOwnerError, ContextNotFoundError, isEqual, isWrappable, SUPPORTS_PROXY } from "@solidjs/signals";
+export { flatten } from "@solidjs/signals";
+export { snapshot, merge, omit, storePath, $PROXY, $TRACK } from "@solidjs/signals";
+export type { Accessor, ComputeFunction, EffectFunction, EffectBundle, EffectOptions, MemoOptions, NoInfer, SignalOptions, Setter, Signal, Owner, Maybe, Store, StoreSetter, StoreNode, NotWrappable, SolidStore, Merge, Omit, Context, ContextRecord, IQueue, StorePathRange, ArrayFilterFn, CustomPartial, Part, PathSetter } from "@solidjs/signals";
+import type { Accessor, ComputeFunction, EffectFunction, EffectBundle, EffectOptions, MemoOptions, SignalOptions, Signal, Owner, Store, StoreSetter, Context } from "@solidjs/signals";
+interface ServerComputation<T = any> {
+    owner: Owner;
+    value: T;
+    compute: ComputeFunction<any, T>;
+    error: unknown;
+    computed: boolean;
+    disposed: boolean;
+}
+export declare function getObserver(): ServerComputation<any> | null;
+export declare function createSignal<T>(): Signal<T | undefined>;
+export declare function createSignal<T>(value: Exclude<T, Function>, options?: SignalOptions<T>): Signal<T>;
+export declare function createSignal<T>(fn: ComputeFunction<T>, initialValue?: T, options?: SignalOptions<T>): Signal<T>;
+export declare function createMemo<Next extends Prev, Prev = Next>(compute: ComputeFunction<undefined | NoInfer<Prev>, Next>): Accessor<Next>;
+export declare function createMemo<Next extends Prev, Init = Next, Prev = Next>(compute: ComputeFunction<Init | Prev, Next>, value: Init, options?: MemoOptions<Next>): Accessor<Next>;
+export type PatchOp = [path: PropertyKey[]] | [path: PropertyKey[], value: any] | [path: PropertyKey[], value: any, insert: 1];
+export declare function createDeepProxy<T extends object>(target: T, patches: PatchOp[], basePath?: PropertyKey[]): T;
+export declare function createEffect<Next>(compute: ComputeFunction<undefined | NoInfer<Next>, Next>, effectFn: EffectFunction<NoInfer<Next>, Next> | EffectBundle<NoInfer<Next>, Next>): void;
+export declare function createEffect<Next, Init = Next>(compute: ComputeFunction<Init | Next, Next>, effect: EffectFunction<Next, Next> | EffectBundle<Next, Next>, value: Init, options?: EffectOptions): void;
+export declare function createRenderEffect<Next>(compute: ComputeFunction<undefined | NoInfer<Next>, Next>, effectFn: EffectFunction<NoInfer<Next>, Next>): void;
+export declare function createRenderEffect<Next, Init = Next>(compute: ComputeFunction<Init | Next, Next>, effectFn: EffectFunction<Next, Next>, value: Init, options?: EffectOptions): void;
+export declare function createTrackedEffect(compute: () => void | (() => void), options?: EffectOptions): void;
+export declare function createReaction(effectFn: EffectFunction<undefined> | EffectBundle<undefined>, options?: EffectOptions): (tracking: () => void) => void;
+export declare function createOptimistic<T>(): Signal<T | undefined>;
+export declare function createOptimistic<T>(value: Exclude<T, Function>, options?: SignalOptions<T>): Signal<T>;
+export declare function createOptimistic<T>(fn: ComputeFunction<T>, initialValue?: T, options?: SignalOptions<T>): Signal<T>;
+export declare function createStore<T extends object>(first: T | Store<T> | ((store: T) => void | T | Promise<void | T>), second?: T | Store<T>): [get: Store<T>, set: StoreSetter<T>];
+export declare const createOptimisticStore: typeof createStore;
+export declare function createProjection<T extends object>(fn: (draft: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, initialValue?: T, options?: {
+    deferStream?: boolean;
+    ssrSource?: string;
+}): Store<T>;
+export declare function reconcile<T extends U, U extends object>(value: T): (state: U) => T;
+export declare function deep<T extends object>(store: Store<T>): Store<T>;
+export declare function mapArray<T, U>(list: Accessor<readonly T[] | undefined | null | false>, mapFn: (v: Accessor<T>, i: Accessor<number>) => U, options?: {
+    keyed?: boolean | ((item: T) => any);
+    fallback?: Accessor<any>;
+}): () => U[];
+export declare function repeat<T>(count: Accessor<number>, mapFn: (i: number) => T, options?: {
+    fallback?: Accessor<any>;
+    from?: Accessor<number | undefined>;
+}): () => T[];
+declare const ErrorContext: Context<((err: any) => void) | null>;
+export { ErrorContext };
+export declare function createErrorBoundary<U>(fn: () => any, fallback: (error: unknown, reset: () => void) => U): () => unknown;
+export declare function createLoadBoundary(fn: () => any, fallback: () => any): () => unknown;
+export declare function untrack<T>(fn: () => T): T;
+export declare function flush(): void;
+export declare function resolve<T>(fn: () => T): Promise<T>;
+export declare function isPending(fn: () => any, fallback?: boolean): boolean;
+export declare function latest<T>(fn: () => T): T;
+export declare function isRefreshing(): boolean;
+export declare function refresh<T>(fn: () => T): T;
+export declare function action<T extends (...args: any[]) => any>(fn: T): T;
+export declare function onSettled(callback: () => void | (() => void)): void;
+type NoInfer<T extends any> = [T][T extends any ? 0 : never];

package/h/dist/h.cjs

@@ -1,115 +0,0 @@
-'use strict';
-
-var web = require('solid-js/web');
-
-const $ELEMENT = Symbol("hyper-element");
-function createHyperScript(r) {
-  function h() {
-    let args = [].slice.call(arguments),
-      e,
-      classes = [],
-      multiExpression = false;
-    while (Array.isArray(args[0])) args = args[0];
-    if (args[0][$ELEMENT]) args.unshift(h.Fragment);
-    typeof args[0] === "string" && detectMultiExpression(args);
-    const ret = () => {
-      while (args.length) item(args.shift());
-      if (e instanceof Element && classes.length) e.classList.add(...classes);
-      return e;
-    };
-    ret[$ELEMENT] = true;
-    return ret;
-    function item(l) {
-      const type = typeof l;
-      if (l == null) ;else if ("string" === type) {
-        if (!e) parseClass(l);else e.appendChild(document.createTextNode(l));
-      } else if ("number" === type || "boolean" === type || "bigint" === type || "symbol" === type || l instanceof Date || l instanceof RegExp) {
-        e.appendChild(document.createTextNode(l.toString()));
-      } else if (Array.isArray(l)) {
-        for (let i = 0; i < l.length; i++) item(l[i]);
-      } else if (l instanceof Element) {
-        r.insert(e, l, multiExpression ? null : undefined);
-      } else if ("object" === type) {
-        let dynamic = false;
-        const d = Object.getOwnPropertyDescriptors(l);
-        for (const k in d) {
-          if (k === "class" && classes.length !== 0) {
-            const fixedClasses = classes.join(" "),
-              value = typeof d["class"].value === "function" ? () => fixedClasses + " " + d["class"].value() : fixedClasses + " " + l["class"];
-            Object.defineProperty(l, "class", {
-              ...d[k],
-              value
-            });
-            classes = [];
-          }
-          if (k !== "ref" && k.slice(0, 2) !== "on" && typeof d[k].value === "function") {
-            r.dynamicProperty(l, k);
-            dynamic = true;
-          } else if (d[k].get) dynamic = true;
-        }
-        dynamic ? r.spread(e, l, e instanceof SVGElement, !!args.length) : r.assign(e, l, e instanceof SVGElement, !!args.length);
-      } else if ("function" === type) {
-        if (!e) {
-          let props,
-            next = args[0];
-          if (next == null || typeof next === "object" && !Array.isArray(next) && !(next instanceof Element)) props = args.shift();
-          props || (props = {});
-          if (args.length) {
-            props.children = args.length > 1 ? args : args[0];
-          }
-          const d = Object.getOwnPropertyDescriptors(props);
-          for (const k in d) {
-            if (Array.isArray(d[k].value)) {
-              const list = d[k].value;
-              props[k] = () => {
-                for (let i = 0; i < list.length; i++) {
-                  while (list[i][$ELEMENT]) list[i] = list[i]();
-                }
-                return list;
-              };
-              r.dynamicProperty(props, k);
-            } else if (typeof d[k].value === "function" && !d[k].value.length) r.dynamicProperty(props, k);
-          }
-          e = r.createComponent(l, props);
-          args = [];
-        } else {
-          while (l[$ELEMENT]) l = l();
-          r.insert(e, l, multiExpression ? null : undefined);
-        }
-      }
-    }
-    function parseClass(string) {
-      const m = string.split(/([\.#]?[^\s#.]+)/);
-      if (/^\.|#/.test(m[1])) e = document.createElement("div");
-      for (let i = 0; i < m.length; i++) {
-        const v = m[i],
-          s = v.substring(1, v.length);
-        if (!v) continue;
-        if (!e) e = r.SVGElements.has(v) ? document.createElementNS("http://www.w3.org/2000/svg", v) : document.createElement(v);else if (v[0] === ".") classes.push(s);else if (v[0] === "#") e.setAttribute("id", s);
-      }
-    }
-    function detectMultiExpression(list) {
-      for (let i = 1; i < list.length; i++) {
-        if (typeof list[i] === "function") {
-          multiExpression = true;
-          return;
-        } else if (Array.isArray(list[i])) {
-          detectMultiExpression(list[i]);
-        }
-      }
-    }
-  }
-  h.Fragment = props => props.children;
-  return h;
-}
-
-const h = createHyperScript({
-  spread: web.spread,
-  assign: web.assign,
-  insert: web.insert,
-  createComponent: web.createComponent,
-  dynamicProperty: web.dynamicProperty,
-  SVGElements: web.SVGElements
-});
-
-module.exports = h;

package/h/dist/h.js

@@ -1,113 +0,0 @@
-import { spread, assign, insert, createComponent, dynamicProperty, SVGElements } from 'solid-js/web';
-
-const $ELEMENT = Symbol("hyper-element");
-function createHyperScript(r) {
-  function h() {
-    let args = [].slice.call(arguments),
-      e,
-      classes = [],
-      multiExpression = false;
-    while (Array.isArray(args[0])) args = args[0];
-    if (args[0][$ELEMENT]) args.unshift(h.Fragment);
-    typeof args[0] === "string" && detectMultiExpression(args);
-    const ret = () => {
-      while (args.length) item(args.shift());
-      if (e instanceof Element && classes.length) e.classList.add(...classes);
-      return e;
-    };
-    ret[$ELEMENT] = true;
-    return ret;
-    function item(l) {
-      const type = typeof l;
-      if (l == null) ;else if ("string" === type) {
-        if (!e) parseClass(l);else e.appendChild(document.createTextNode(l));
-      } else if ("number" === type || "boolean" === type || "bigint" === type || "symbol" === type || l instanceof Date || l instanceof RegExp) {
-        e.appendChild(document.createTextNode(l.toString()));
-      } else if (Array.isArray(l)) {
-        for (let i = 0; i < l.length; i++) item(l[i]);
-      } else if (l instanceof Element) {
-        r.insert(e, l, multiExpression ? null : undefined);
-      } else if ("object" === type) {
-        let dynamic = false;
-        const d = Object.getOwnPropertyDescriptors(l);
-        for (const k in d) {
-          if (k === "class" && classes.length !== 0) {
-            const fixedClasses = classes.join(" "),
-              value = typeof d["class"].value === "function" ? () => fixedClasses + " " + d["class"].value() : fixedClasses + " " + l["class"];
-            Object.defineProperty(l, "class", {
-              ...d[k],
-              value
-            });
-            classes = [];
-          }
-          if (k !== "ref" && k.slice(0, 2) !== "on" && typeof d[k].value === "function") {
-            r.dynamicProperty(l, k);
-            dynamic = true;
-          } else if (d[k].get) dynamic = true;
-        }
-        dynamic ? r.spread(e, l, e instanceof SVGElement, !!args.length) : r.assign(e, l, e instanceof SVGElement, !!args.length);
-      } else if ("function" === type) {
-        if (!e) {
-          let props,
-            next = args[0];
-          if (next == null || typeof next === "object" && !Array.isArray(next) && !(next instanceof Element)) props = args.shift();
-          props || (props = {});
-          if (args.length) {
-            props.children = args.length > 1 ? args : args[0];
-          }
-          const d = Object.getOwnPropertyDescriptors(props);
-          for (const k in d) {
-            if (Array.isArray(d[k].value)) {
-              const list = d[k].value;
-              props[k] = () => {
-                for (let i = 0; i < list.length; i++) {
-                  while (list[i][$ELEMENT]) list[i] = list[i]();
-                }
-                return list;
-              };
-              r.dynamicProperty(props, k);
-            } else if (typeof d[k].value === "function" && !d[k].value.length) r.dynamicProperty(props, k);
-          }
-          e = r.createComponent(l, props);
-          args = [];
-        } else {
-          while (l[$ELEMENT]) l = l();
-          r.insert(e, l, multiExpression ? null : undefined);
-        }
-      }
-    }
-    function parseClass(string) {
-      const m = string.split(/([\.#]?[^\s#.]+)/);
-      if (/^\.|#/.test(m[1])) e = document.createElement("div");
-      for (let i = 0; i < m.length; i++) {
-        const v = m[i],
-          s = v.substring(1, v.length);
-        if (!v) continue;
-        if (!e) e = r.SVGElements.has(v) ? document.createElementNS("http://www.w3.org/2000/svg", v) : document.createElement(v);else if (v[0] === ".") classes.push(s);else if (v[0] === "#") e.setAttribute("id", s);
-      }
-    }
-    function detectMultiExpression(list) {
-      for (let i = 1; i < list.length; i++) {
-        if (typeof list[i] === "function") {
-          multiExpression = true;
-          return;
-        } else if (Array.isArray(list[i])) {
-          detectMultiExpression(list[i]);
-        }
-      }
-    }
-  }
-  h.Fragment = props => props.children;
-  return h;
-}
-
-const h = createHyperScript({
-  spread,
-  assign,
-  insert,
-  createComponent,
-  dynamicProperty,
-  SVGElements
-});
-
-export { h as default };

package/h/jsx-dev-runtime/package.json

@@ -1,8 +0,0 @@
-{
-  "name": "solid-js/h/jsx-dev-runtime",
-  "main": "../jsx-runtime/dist/jsx.cjs",
-  "module": "../jsx-runtime/dist/jsx.js",
-  "types": "../jsx-runtime/types/index.d.ts",
-  "type": "module",
-  "sideEffects": false
-}

package/h/jsx-runtime/dist/jsx.cjs

@@ -1,15 +0,0 @@
-'use strict';
-
-var h = require('solid-js/h');
-
-function Fragment(props) {
-  return props.children;
-}
-function jsx(type, props) {
-  return h(type, props);
-}
-
-exports.Fragment = Fragment;
-exports.jsx = jsx;
-exports.jsxDEV = jsx;
-exports.jsxs = jsx;

package/h/jsx-runtime/dist/jsx.js

@@ -1,10 +0,0 @@
-import h from 'solid-js/h';
-
-function Fragment(props) {
-  return props.children;
-}
-function jsx(type, props) {
-  return h(type, props);
-}
-
-export { Fragment, jsx, jsx as jsxDEV, jsx as jsxs };

package/h/jsx-runtime/package.json

@@ -1,8 +0,0 @@
-{
-  "name": "solid-js/h/jsx-runtime",
-  "main": "./dist/jsx.cjs",
-  "module": "./dist/jsx.js",
-  "types": "./types/index.d.ts",
-  "type": "module",
-  "sideEffects": false
-}

package/h/jsx-runtime/types/index.d.ts

@@ -1,11 +0,0 @@
-export type { JSX } from "./jsx.d.ts";
-import type { JSX } from "./jsx.d.ts";
-declare function Fragment(props: {
-    children: JSX.Element;
-}): JSX.Element;
-declare function jsx(type: any, props: any): () => (Node & {
-    [key: string]: any;
-}) | (Node & {
-    [key: string]: any;
-})[];
-export { jsx, jsx as jsxs, jsx as jsxDEV, Fragment };