solid-js 1.9.11 → 2.0.0-beta.0

package/types/render/flow.d.ts

@@ -1,118 +0,0 @@
-import { Accessor } from "../reactive/signal.js";
-import type { JSX } from "../jsx.js";
-/**
- * Creates a list elements from a list
- *
- * it receives a map function as its child that receives a list element and an accessor with the index and returns a JSX-Element; if the list is empty, an optional fallback is returned:
- * ```typescript
- * <For each={items} fallback={<div>No items</div>}>
- *   {(item, index) => <div data-index={index()}>{item}</div>}
- * </For>
- * ```
- * If you have a list with fixed indices and changing values, consider using `<Index>` instead.
- *
- * @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;
-    children: (item: T[number], index: Accessor<number>) => U;
-}): JSX.Element;
-/**
- * Non-keyed iteration over a list creating elements from its items
- *
- * To be used if you have a list with fixed indices, but changing values.
- * ```typescript
- * <Index each={items} fallback={<div>No items</div>}>
- *   {(item, index) => <div data-index={index}>{item()}</div>}
- * </Index>
- * ```
- * If you have a list with changing indices, better use `<For>`.
- *
- * @description https://docs.solidjs.com/reference/components/index-component
- */
-export declare function Index<T extends readonly any[], U extends JSX.Element>(props: {
-    each: T | undefined | null | false;
-    fallback?: JSX.Element;
-    children: (item: Accessor<T[number]>, index: number) => U;
-}): JSX.Element;
-type RequiredParameter<T> = T extends () => unknown ? never : T;
-/**
- * Conditionally render its children or an optional fallback component
- * @description https://docs.solidjs.com/reference/components/show
- */
-export declare function Show<T, TRenderFunction extends (item: Accessor<NonNullable<T>>) => JSX.Element>(props: {
-    when: T | undefined | null | false;
-    keyed?: false;
-    fallback?: JSX.Element;
-    children: JSX.Element | RequiredParameter<TRenderFunction>;
-}): JSX.Element;
-export declare function Show<T, TRenderFunction extends (item: NonNullable<T>) => JSX.Element>(props: {
-    when: T | undefined | null | false;
-    keyed: true;
-    fallback?: JSX.Element;
-    children: JSX.Element | RequiredParameter<TRenderFunction>;
-}): JSX.Element;
-/**
- * Switches between content based on mutually exclusive conditions
- * ```typescript
- * <Switch fallback={<FourOhFour />}>
- *   <Match when={state.route === 'home'}>
- *     <Home />
- *   </Match>
- *   <Match when={state.route === 'settings'}>
- *     <Settings />
- *   </Match>
- * </Switch>
- * ```
- * @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: NonNullable<T> | Accessor<NonNullable<T>>) => JSX.Element);
-};
-/**
- * Selects a content based on condition when inside a `<Switch>` control flow
- * ```typescript
- * <Match when={condition()}>
- *   <Content/>
- * </Match>
- * ```
- * @description https://docs.solidjs.com/reference/components/switch-and-match
- */
-export declare function Match<T, TRenderFunction extends (item: Accessor<NonNullable<T>>) => JSX.Element>(props: {
-    when: T | undefined | null | false;
-    keyed?: false;
-    children: JSX.Element | RequiredParameter<TRenderFunction>;
-}): JSX.Element;
-export declare function Match<T, TRenderFunction extends (item: NonNullable<T>) => JSX.Element>(props: {
-    when: T | undefined | null | false;
-    keyed: true;
-    children: JSX.Element | RequiredParameter<TRenderFunction>;
-}): JSX.Element;
-export declare function resetErrorBoundaries(): void;
-/**
- * Catches uncaught errors inside components and renders a fallback content
- *
- * Also supports a callback form that passes the error and a reset function:
- * ```typescript
- * <ErrorBoundary fallback={
- *   (err, reset) => <div onClick={reset}>Error: {err.toString()}</div>
- * }>
- *   <MyComp />
- * </ErrorBoundary>
- * ```
- * Errors thrown from the fallback can be caught by a parent ErrorBoundary
- *
- * @description https://docs.solidjs.com/reference/components/error-boundary
- */
-export declare function ErrorBoundary(props: {
-    fallback: JSX.Element | ((err: any, reset: () => void) => JSX.Element);
-    children: JSX.Element;
-}): JSX.Element;
-export {};

package/types/render/hydration.d.ts

@@ -1,24 +0,0 @@
-import { Computation } from "../reactive/signal.js";
-export type HydrationContext = {
-    id: string;
-    count: number;
-};
-type SharedConfig = {
-    context?: HydrationContext;
-    resources?: {
-        [key: string]: any;
-    };
-    load?: (id: string) => Promise<any> | any;
-    has?: (id: string) => boolean;
-    gather?: (key: string) => void;
-    registry?: Map<string, Element>;
-    done?: boolean;
-    count?: number;
-    effects?: Computation<any, any>[];
-    getContextId(): string;
-    getNextContextId(): string;
-};
-export declare const sharedConfig: SharedConfig;
-export declare function setHydrateContext(context?: HydrationContext): void;
-export declare function nextHydrateContext(): HydrationContext | undefined;
-export {};

package/types/render/index.d.ts

@@ -1,4 +0,0 @@
-export * from "./component.js";
-export * from "./flow.js";
-export * from "./Suspense.js";
-export { sharedConfig } from "./hydration.js";

package/types/server/reactive.d.ts

@@ -1,98 +0,0 @@
-export declare const equalFn: <T>(a: T, b: T) => boolean;
-export declare const $PROXY: unique symbol;
-export declare const $TRACK: unique symbol;
-export declare const $DEVCOMP: unique symbol;
-export declare const DEV: undefined;
-export type Accessor<T> = () => T;
-export 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 type Signal<T> = [get: Accessor<T>, set: Setter<T>];
-export declare function castError(err: unknown): Error;
-export declare let Owner: Owner | null;
-interface Owner {
-    owner: Owner | null;
-    context: any | null;
-    owned: Owner[] | null;
-    cleanups: (() => void)[] | null;
-}
-export declare function createOwner(): Owner;
-export declare function createRoot<T>(fn: (dispose: () => void) => T, detachedOwner?: typeof Owner): T;
-export declare function createSignal<T>(value: T, options?: {
-    equals?: false | ((prev: T, next: T) => boolean);
-    name?: string;
-}): [get: () => T, set: (v: (T extends Function ? never : T) | ((prev: T) => T)) => T];
-export declare function createComputed<T>(fn: (v?: T) => T, value?: T): void;
-export declare const createRenderEffect: typeof createComputed;
-export declare function createEffect<T>(fn: (v?: T) => T, value?: T): void;
-export declare function createReaction(fn: () => void): (fn: () => void) => void;
-export declare function createMemo<T>(fn: (v?: T) => T, value?: T): () => T;
-export declare function createDeferred<T>(source: () => T): () => T;
-export declare function createSelector<T>(source: () => T, fn?: (k: T, value: T) => boolean): (k: T) => boolean;
-export declare function batch<T>(fn: () => T): T;
-export declare const untrack: typeof batch;
-export declare function on<T, U>(deps: Array<() => T> | (() => T), fn: (value: Array<T> | T, prev?: Array<T> | T, prevResults?: U) => U, options?: {
-    defer?: boolean;
-}): (prev?: U) => U | undefined;
-export declare function onMount(fn: () => void): void;
-export declare function onCleanup(fn: () => void): () => void;
-export declare function cleanNode(node: Owner): void;
-export declare function catchError<T>(fn: () => T, handler: (err: Error) => void): T | undefined;
-export declare function getListener(): null;
-export interface Context<T> {
-    id: symbol;
-    Provider: (props: {
-        value: T;
-        children: any;
-    }) => any;
-    defaultValue?: T;
-}
-export declare function createContext<T>(defaultValue?: T): Context<T>;
-export declare function useContext<T>(context: Context<T>): T;
-export declare function getOwner(): Owner | null;
-type ChildrenReturn = Accessor<any> & {
-    toArray: () => any[];
-};
-export declare function children(fn: () => any): ChildrenReturn;
-export declare function runWithOwner<T>(o: typeof Owner, fn: () => T): T | undefined;
-export interface Task {
-    id: number;
-    fn: ((didTimeout: boolean) => void) | null;
-    startTime: number;
-    expirationTime: number;
-}
-export declare function requestCallback(fn: () => void, options?: {
-    timeout: number;
-}): Task;
-export declare function cancelCallback(task: Task): void;
-export declare function mapArray<T, U>(list: Accessor<readonly T[] | undefined | null | false>, mapFn: (v: T, i: Accessor<number>) => U, options?: {
-    fallback?: Accessor<any>;
-}): () => U[];
-export declare function indexArray<T, U>(list: Accessor<readonly T[] | undefined | null | false>, mapFn: (v: Accessor<T>, i: number) => U, options?: {
-    fallback?: Accessor<any>;
-}): () => U[];
-export type ObservableObserver<T> = ((v: T) => void) | {
-    next: (v: T) => void;
-    error?: (v: any) => void;
-    complete?: (v: boolean) => void;
-};
-export declare function observable<T>(input: Accessor<T>): {
-    subscribe(observer: ObservableObserver<T>): {
-        unsubscribe(): void;
-    };
-    [Symbol.observable](): {
-        subscribe(observer: ObservableObserver<T>): {
-            unsubscribe(): void;
-        };
-        [Symbol.observable](): /*elided*/ any;
-    };
-};
-export declare function from<T>(producer: ((setter: Setter<T>) => () => void) | {
-    subscribe: (fn: (v: T) => void) => (() => void) | {
-        unsubscribe: () => void;
-    };
-}): Accessor<T>;
-export declare function enableExternalSource(factory: any): void;
-/**
- * @deprecated since version 1.7.0 and will be removed in next major - use catchError instead
- */
-export declare function onError(fn: (err: Error) => void): void;
-export {};

package/types/server/rendering.d.ts

@@ -1,159 +0,0 @@
-import { Accessor, Setter, Signal } from "./reactive.js";
-import type { JSX } from "../jsx.js";
-export type Component<P = {}> = (props: P) => JSX.Element;
-export type VoidProps<P = {}> = P & {
-    children?: never;
-};
-export type VoidComponent<P = {}> = Component<VoidProps<P>>;
-export type ParentProps<P = {}> = P & {
-    children?: JSX.Element;
-};
-export type ParentComponent<P = {}> = Component<ParentProps<P>>;
-export type FlowProps<P = {}, C = JSX.Element> = P & {
-    children: C;
-};
-export type FlowComponent<P = {}, C = JSX.Element> = Component<FlowProps<P, C>>;
-export type Ref<T> = T | ((val: T) => void);
-export type ValidComponent = keyof JSX.IntrinsicElements | Component<any> | (string & {});
-export type ComponentProps<T extends ValidComponent> = T extends Component<infer P> ? P : T extends keyof JSX.IntrinsicElements ? JSX.IntrinsicElements[T] : Record<string, unknown>;
-type SharedConfig = {
-    context?: HydrationContext;
-    getContextId(): string;
-    getNextContextId(): string;
-};
-export declare const sharedConfig: SharedConfig;
-export declare function createUniqueId(): string;
-export declare function createComponent<T>(Comp: (props: T) => JSX.Element, props: T): JSX.Element;
-export declare function mergeProps<T, U>(source: T, source1: U): T & U;
-export declare function mergeProps<T, U, V>(source: T, source1: U, source2: V): T & U & V;
-export declare function mergeProps<T, U, V, W>(source: T, source1: U, source2: V, source3: W): T & U & V & W;
-export declare function splitProps<T extends object, K1 extends keyof T>(props: T, ...keys: [K1[]]): [Pick<T, K1>, Omit<T, K1>];
-export declare function splitProps<T extends object, K1 extends keyof T, K2 extends keyof T>(props: T, ...keys: [K1[], K2[]]): [Pick<T, K1>, Pick<T, K2>, Omit<T, K1 | K2>];
-export declare function splitProps<T extends object, K1 extends keyof T, K2 extends keyof T, K3 extends keyof T>(props: T, ...keys: [K1[], K2[], K3[]]): [Pick<T, K1>, Pick<T, K2>, Pick<T, K3>, Omit<T, K1 | K2 | K3>];
-export declare function splitProps<T extends object, K1 extends keyof T, K2 extends keyof T, K3 extends keyof T, K4 extends keyof T>(props: T, ...keys: [K1[], K2[], K3[], K4[]]): [Pick<T, K1>, Pick<T, K2>, Pick<T, K3>, Pick<T, K4>, Omit<T, K1 | K2 | K3 | K4>];
-export declare function splitProps<T extends object, K1 extends keyof T, K2 extends keyof T, K3 extends keyof T, K4 extends keyof T, K5 extends keyof T>(props: T, ...keys: [K1[], K2[], K3[], K4[], K5[]]): [
-    Pick<T, K1>,
-    Pick<T, K2>,
-    Pick<T, K3>,
-    Pick<T, K4>,
-    Pick<T, K5>,
-    Omit<T, K1 | K2 | K3 | K4 | K5>
-];
-export declare function For<T>(props: {
-    each: T[];
-    fallback?: string;
-    children: (item: T, index: () => number) => string;
-}): string | any[] | undefined;
-export declare function Index<T>(props: {
-    each: T[];
-    fallback?: string;
-    children: (item: () => T, index: number) => string;
-}): string | any[] | undefined;
-/**
- * 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?: string;
-    children: string | ((item: NonNullable<T> | Accessor<NonNullable<T>>) => string);
-}): string;
-export declare function Switch(props: {
-    fallback?: string;
-    children: MatchProps<unknown> | MatchProps<unknown>[];
-}): string;
-type MatchProps<T> = {
-    when: T | false;
-    keyed?: boolean;
-    children: string | ((item: NonNullable<T> | Accessor<NonNullable<T>>) => string);
-};
-export declare function Match<T>(props: MatchProps<T>): MatchProps<T>;
-export declare function resetErrorBoundaries(): void;
-export declare function ErrorBoundary(props: {
-    fallback: string | ((err: any, reset: () => void) => string);
-    children: string;
-}): string | ((err: any, reset: () => void) => string) | {
-    t: string;
-};
-export interface Resource<T> {
-    (): T | undefined;
-    state: "unresolved" | "pending" | "ready" | "refreshing" | "errored";
-    loading: boolean;
-    error: any;
-    latest: T | undefined;
-}
-type SuspenseContextType = {
-    resources: Map<string, {
-        _loading: boolean;
-        error: any;
-    }>;
-    completed: () => void;
-};
-export type ResourceActions<T> = {
-    mutate: Setter<T>;
-    refetch: (info?: unknown) => void;
-};
-export type ResourceReturn<T> = [Resource<T>, ResourceActions<T>];
-export type ResourceSource<S> = S | false | null | undefined | (() => S | false | null | undefined);
-export type ResourceFetcher<S, T> = (k: S, info: ResourceFetcherInfo<T>) => T | Promise<T>;
-export type ResourceFetcherInfo<T> = {
-    value: T | undefined;
-    refetching?: unknown;
-};
-export type ResourceOptions<T> = undefined extends T ? {
-    initialValue?: T;
-    name?: string;
-    deferStream?: boolean;
-    ssrLoadFrom?: "initial" | "server";
-    storage?: () => Signal<T | undefined>;
-    onHydrated?: <S, T>(k: S, info: ResourceFetcherInfo<T>) => void;
-} : {
-    initialValue: T;
-    name?: string;
-    deferStream?: boolean;
-    ssrLoadFrom?: "initial" | "server";
-    storage?: (v?: T) => Signal<T | undefined>;
-    onHydrated?: <S, T>(k: S, info: ResourceFetcherInfo<T>) => void;
-};
-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 declare function lazy<T extends Component<any>>(fn: () => Promise<{
-    default: T;
-}>): T & {
-    preload: () => Promise<{
-        default: T;
-    }>;
-};
-export declare function enableScheduling(): void;
-export declare function enableHydration(): void;
-export declare function startTransition(fn: () => any): void;
-export declare function useTransition(): [() => boolean, (fn: () => any) => void];
-type HydrationContext = {
-    id: string;
-    count: number;
-    serialize: (id: string, v: Promise<any> | any, deferStream?: boolean) => void;
-    nextRoot: (v: any) => string;
-    replace: (id: string, replacement: () => any) => void;
-    block: (p: Promise<any>) => void;
-    resources: Record<string, any>;
-    suspense: Record<string, SuspenseContextType>;
-    registerFragment: (v: string) => (v?: string, err?: any) => boolean;
-    lazy: Record<string, Promise<any>>;
-    async?: boolean;
-    noHydrate: boolean;
-};
-export declare function SuspenseList(props: {
-    children: string;
-    revealOrder: "forwards" | "backwards" | "together";
-    tail?: "collapsed" | "hidden";
-}): string;
-export declare function Suspense(props: {
-    fallback?: string;
-    children: string;
-}): string | number | boolean | Node | JSX.ArrayElement | {
-    t: string;
-} | null | undefined;
-export {};

package/universal/dist/dev.cjs

@@ -1,245 +0,0 @@
-'use strict';
-
-var solidJs = require('solid-js');
-
-const memo = fn => solidJs.createMemo(() => fn());
-
-function createRenderer$1({
-  createElement,
-  createTextNode,
-  isTextNode,
-  replaceText,
-  insertNode,
-  removeNode,
-  setProperty,
-  getParentNode,
-  getFirstChild,
-  getNextSibling
-}) {
-  function insert(parent, accessor, marker, initial) {
-    if (marker !== undefined && !initial) initial = [];
-    if (typeof accessor !== "function") return insertExpression(parent, accessor, initial, marker);
-    solidJs.createRenderEffect(current => insertExpression(parent, accessor(), current, marker), initial);
-  }
-  function insertExpression(parent, value, current, marker, unwrapArray) {
-    while (typeof current === "function") current = current();
-    if (value === current) return current;
-    const t = typeof value,
-      multi = marker !== undefined;
-    if (t === "string" || t === "number") {
-      if (t === "number") value = value.toString();
-      if (multi) {
-        let node = current[0];
-        if (node && isTextNode(node)) {
-          replaceText(node, value);
-        } else node = createTextNode(value);
-        current = cleanChildren(parent, current, marker, node);
-      } else {
-        if (current !== "" && typeof current === "string") {
-          replaceText(getFirstChild(parent), current = value);
-        } else {
-          cleanChildren(parent, current, marker, createTextNode(value));
-          current = value;
-        }
-      }
-    } else if (value == null || t === "boolean") {
-      current = cleanChildren(parent, current, marker);
-    } else if (t === "function") {
-      solidJs.createRenderEffect(() => {
-        let v = value();
-        while (typeof v === "function") v = v();
-        current = insertExpression(parent, v, current, marker);
-      });
-      return () => current;
-    } else if (Array.isArray(value)) {
-      const array = [];
-      if (normalizeIncomingArray(array, value, unwrapArray)) {
-        solidJs.createRenderEffect(() => current = insertExpression(parent, array, current, marker, true));
-        return () => current;
-      }
-      if (array.length === 0) {
-        const replacement = cleanChildren(parent, current, marker);
-        if (multi) return current = replacement;
-      } else {
-        if (Array.isArray(current)) {
-          if (current.length === 0) {
-            appendNodes(parent, array, marker);
-          } else reconcileArrays(parent, current, array);
-        } else if (current == null || current === "") {
-          appendNodes(parent, array);
-        } else {
-          reconcileArrays(parent, multi && current || [getFirstChild(parent)], array);
-        }
-      }
-      current = array;
-    } else {
-      if (Array.isArray(current)) {
-        if (multi) return current = cleanChildren(parent, current, marker, value);
-        cleanChildren(parent, current, null, value);
-      } else if (current == null || current === "" || !getFirstChild(parent)) {
-        insertNode(parent, value);
-      } else replaceNode(parent, value, getFirstChild(parent));
-      current = value;
-    }
-    return current;
-  }
-  function normalizeIncomingArray(normalized, array, unwrap) {
-    let dynamic = false;
-    for (let i = 0, len = array.length; i < len; i++) {
-      let item = array[i],
-        t;
-      if (item == null || item === true || item === false) ; else if (Array.isArray(item)) {
-        dynamic = normalizeIncomingArray(normalized, item) || dynamic;
-      } else if ((t = typeof item) === "string" || t === "number") {
-        normalized.push(createTextNode(item));
-      } else if (t === "function") {
-        if (unwrap) {
-          while (typeof item === "function") item = item();
-          dynamic = normalizeIncomingArray(normalized, Array.isArray(item) ? item : [item]) || dynamic;
-        } else {
-          normalized.push(item);
-          dynamic = true;
-        }
-      } else normalized.push(item);
-    }
-    return dynamic;
-  }
-  function reconcileArrays(parentNode, a, b) {
-    let bLength = b.length,
-      aEnd = a.length,
-      bEnd = bLength,
-      aStart = 0,
-      bStart = 0,
-      after = getNextSibling(a[aEnd - 1]),
-      map = null;
-    while (aStart < aEnd || bStart < bEnd) {
-      if (a[aStart] === b[bStart]) {
-        aStart++;
-        bStart++;
-        continue;
-      }
-      while (a[aEnd - 1] === b[bEnd - 1]) {
-        aEnd--;
-        bEnd--;
-      }
-      if (aEnd === aStart) {
-        const node = bEnd < bLength ? bStart ? getNextSibling(b[bStart - 1]) : b[bEnd - bStart] : after;
-        while (bStart < bEnd) insertNode(parentNode, b[bStart++], node);
-      } else if (bEnd === bStart) {
-        while (aStart < aEnd) {
-          if (!map || !map.has(a[aStart])) removeNode(parentNode, a[aStart]);
-          aStart++;
-        }
-      } else if (a[aStart] === b[bEnd - 1] && b[bStart] === a[aEnd - 1]) {
-        const node = getNextSibling(a[--aEnd]);
-        insertNode(parentNode, b[bStart++], getNextSibling(a[aStart++]));
-        insertNode(parentNode, b[--bEnd], node);
-        a[aEnd] = b[bEnd];
-      } else {
-        if (!map) {
-          map = new Map();
-          let i = bStart;
-          while (i < bEnd) map.set(b[i], i++);
-        }
-        const index = map.get(a[aStart]);
-        if (index != null) {
-          if (bStart < index && index < bEnd) {
-            let i = aStart,
-              sequence = 1,
-              t;
-            while (++i < aEnd && i < bEnd) {
-              if ((t = map.get(a[i])) == null || t !== index + sequence) break;
-              sequence++;
-            }
-            if (sequence > index - bStart) {
-              const node = a[aStart];
-              while (bStart < index) insertNode(parentNode, b[bStart++], node);
-            } else replaceNode(parentNode, b[bStart++], a[aStart++]);
-          } else aStart++;
-        } else removeNode(parentNode, a[aStart++]);
-      }
-    }
-  }
-  function cleanChildren(parent, current, marker, replacement) {
-    if (marker === undefined) {
-      let removed;
-      while (removed = getFirstChild(parent)) removeNode(parent, removed);
-      replacement && insertNode(parent, replacement);
-      return "";
-    }
-    const node = replacement || createTextNode("");
-    if (current.length) {
-      let inserted = false;
-      for (let i = current.length - 1; i >= 0; i--) {
-        const el = current[i];
-        if (node !== el) {
-          const isParent = getParentNode(el) === parent;
-          if (!inserted && !i) isParent ? replaceNode(parent, node, el) : insertNode(parent, node, marker);else isParent && removeNode(parent, el);
-        } else inserted = true;
-      }
-    } else insertNode(parent, node, marker);
-    return [node];
-  }
-  function appendNodes(parent, array, marker) {
-    for (let i = 0, len = array.length; i < len; i++) insertNode(parent, array[i], marker);
-  }
-  function replaceNode(parent, newNode, oldNode) {
-    insertNode(parent, newNode, oldNode);
-    removeNode(parent, oldNode);
-  }
-  function spreadExpression(node, props, prevProps = {}, skipChildren) {
-    props || (props = {});
-    if (!skipChildren) {
-      solidJs.createRenderEffect(() => prevProps.children = insertExpression(node, props.children, prevProps.children));
-    }
-    solidJs.createRenderEffect(() => props.ref && props.ref(node));
-    solidJs.createRenderEffect(() => {
-      for (const prop in props) {
-        if (prop === "children" || prop === "ref") continue;
-        const value = props[prop];
-        if (value === prevProps[prop]) continue;
-        setProperty(node, prop, value, prevProps[prop]);
-        prevProps[prop] = value;
-      }
-    });
-    return prevProps;
-  }
-  return {
-    render(code, element) {
-      let disposer;
-      solidJs.createRoot(dispose => {
-        disposer = dispose;
-        insert(element, code());
-      });
-      return disposer;
-    },
-    insert,
-    spread(node, accessor, skipChildren) {
-      if (typeof accessor === "function") {
-        solidJs.createRenderEffect(current => spreadExpression(node, accessor(), current, skipChildren));
-      } else spreadExpression(node, accessor, undefined, skipChildren);
-    },
-    createElement,
-    createTextNode,
-    insertNode,
-    setProp(node, name, value, prev) {
-      setProperty(node, name, value, prev);
-      return value;
-    },
-    mergeProps: solidJs.mergeProps,
-    effect: solidJs.createRenderEffect,
-    memo,
-    createComponent: solidJs.createComponent,
-    use(fn, element, arg) {
-      return solidJs.untrack(() => fn(element, arg));
-    }
-  };
-}
-
-function createRenderer(options) {
-  const renderer = createRenderer$1(options);
-  renderer.mergeProps = solidJs.mergeProps;
-  return renderer;
-}
-
-exports.createRenderer = createRenderer;