mates 0.0.18 → 0.0.21

package/dist/index.d.ts

@@ -1,28 +1,1176 @@
-export { atom, action, asyncAtom, iAtom, globalVersion, incrGlobalVersion, df, } from "./atom";
-export { bubble } from "./bubbles";
-export { location, isPathMatching } from "./pathResolver";
-export { _, useStore, setter, useContext, useSubscribe, withHost, getCurrentHost, subscribe, useMutable, useOnMount, useOnUnmount, type SetterReturnType, useState, useUpdate, setBubbleInProgress, setBubblesSetter, getbubbleInProgress, getbubblesSetter, safetyCheck, useUpdate as useForceUpdate, } from "./useStore";
-export { getter } from "./compute";
-export { molecule } from "./molecule";
-export { useRefEffect } from "./useRefEffect";
-export { unit, getProps as getStoreProps } from "./units";
-import "./x-view";
-export { type Props, type Setter, getTemplateIsRunning, globalScheduler, } from "./x-view";
-import "./xProvider";
-export { view, renderView } from "./view";
-export { html, render } from "./lit-html";
-export { repeat } from "./lit-html/directives/repeat";
-export { guard } from "./lit-html/directives/guard";
-export { styleMap } from "./lit-html/directives/style-map";
-export { classMap } from "./lit-html/directives/class-map";
-export { when } from "./lit-html/directives/when";
-export { ifDefined } from "./lit-html/directives/if-defined";
-export { live } from "./lit-html/directives/live";
-export { until } from "./lit-html/directives/until";
-export { keyed } from "./lit-html/directives/keyed";
-export { cache } from "./lit-html/directives/cache";
-export { asyncReplace } from "./lit-html/directives/async-replace";
-export { join } from "./lit-html/directives/join";
-export { range } from "./lit-html/directives/range";
-export { asyncAppend } from "./lit-html/directives/async-append";
-//# sourceMappingURL=index.d.ts.map
+import { TrustedHTML } from 'trusted-types/lib/index.js';
+
+declare let globalVersion: number;
+declare const incrGlobalVersion: () => void;
+type Subscriber = () => void;
+type Updater<T> = (prev: T) => T;
+type UpdateFn<T> = (draft: T) => void;
+type AtomType<T> = {
+    (): T;
+    get(): T;
+    set(value: T | Updater<T>): void;
+    update(fn: UpdateFn<T>): void;
+    subscribe(fn: Subscriber): () => void;
+    lock(): void;
+    unlock(): void;
+    readonly val: T;
+    readonly toJSON: () => string;
+    readonly __version__: number;
+    readonly __id__: string;
+    readonly __isAtom___: boolean;
+    select: <S>(selector: (state: T) => S) => () => S;
+};
+declare function atom<T>(initial: T, deepFreeze?: boolean): AtomType<T>;
+declare function iAtom<T>(initial: T): AtomType<T>;
+declare function df(obj: any): void;
+declare function asyncAtom<T, E = Error>(fn: (abortController: AbortController) => Promise<T>, context: any): {
+    getData(): T | null;
+    getError(): E | null;
+    getStatus(): "init" | "loading" | "success" | "error";
+    isLoading(): boolean;
+    set(fn: (...args: any[]) => Promise<T>): void;
+    cancel: () => void;
+    run: (...args: any[]) => Promise<void>;
+    subscribe: (fn: () => void) => (() => void);
+};
+declare function action(fn: (...args: any[]) => void, options?: {
+    debounce?: number;
+    throttle?: number;
+}): {
+    (...args: any[]): any;
+    subscribe(fn: (result?: any) => void): () => boolean;
+    set(fn: (...args: any[]) => void): void;
+    intercept(interceptor: (next: (...args: any[]) => any, ...args: any[]) => any): void;
+    cancel(): void;
+};
+
+declare const bubble: <T>(storeFn: (setter: <F extends (...args: any[]) => any>(updatorFn: F) => F) => () => T) => (() => T);
+
+declare const location: {
+    readonly path: string;
+    pathAtom: AtomType<string>;
+    navigateTo(path: string, replace?: boolean): void;
+    matchPath(path: string): boolean;
+};
+declare const isPathMatching: (path: string) => boolean;
+
+declare class Context<T> {
+    id: string;
+    context: T;
+}
+
+declare function withHost(host: HTMLElement, renderFn: () => any): any;
+declare function getCurrentHost(throwError?: boolean): HTMLElement | null;
+declare function subscribe(store: any, throwError?: boolean, subscribeFn?: (fn: () => void) => () => void): void;
+declare function useStore(store: any): any;
+declare function useMutable<T extends Record<string, any>>(initialState: T): [T, (updatorFn: (state: T) => void) => void];
+type CleanupFn = () => void;
+declare function useSubscribe(effectFn: () => any, deps: SetterReturnType<any>[]): any;
+declare function useOnMount(fn: () => CleanupFn | void): void;
+declare function useContext<T>(context: Context<T>): T;
+declare const useOnUnmount: (fn: () => void) => void;
+type SetterReturnType<T extends Function> = T & {
+    subscribe: (listener: () => void) => Function;
+    [key: string]: any;
+};
+declare const _: (fn: (...args: any[]) => any) => Function;
+declare const setter: (fn: (...args: any[]) => any) => Function;
+declare const useState: <T extends Record<string, any>>(initialState: T) => [T, (updatorFn?: () => any) => any];
+declare const useUpdate: () => (updatorFn?: () => any) => any;
+declare const setBubbleInProgress: (value: boolean) => void;
+declare const setBubblesSetter: (setter: ((fn: () => void) => void) | null) => void;
+declare const getbubbleInProgress: () => boolean;
+declare const getbubblesSetter: () => any;
+declare const safetyCheck: () => void;
+
+declare function getter<T extends () => any>(computeFn: T): T & {
+    val: ReturnType<T>;
+    version: number;
+    areVersionsChanged: (callerVersion?: number) => boolean;
+};
+
+type ActionFunction<T extends (...args: any[]) => any> = T & {
+    subscribe: (fn: (result?: ReturnType<T>) => void) => () => void;
+    set: (fn: T) => void;
+    intercept: (interceptor: (next: T, ...args: Parameters<T>) => any) => void;
+    cancel: () => void;
+};
+type TMolecule<T> = {
+    [K in keyof T]: T[K] extends (...args: any[]) => any ? ActionFunction<T[K]> : T[K];
+} & {
+    __isMolecule___: true;
+};
+declare function _molecule<T extends Record<string, any>>(molecule: new () => T): () => TMolecule<T>;
+declare const molecule: typeof _molecule;
+
+declare const useRefEffect: (effect: () => void, deps: () => any[]) => void;
+
+declare function getProps(obj: Record<string, any>): unknown[];
+type TMutableStore<T> = () => T & {
+    subscribe: (fn: () => void) => () => void;
+    __isUnit___: true;
+    __version__: number;
+    isLoading: (fn: MethodOfT<T>) => boolean;
+};
+type MethodOfT<T> = T[keyof T] extends (...args: any[]) => any ? T[keyof T] : never;
+declare function createMutableStore<T extends Record<string, any>>(mutableState: T): TMutableStore<T>;
+declare const unit: typeof createMutableStore;
+
+type PropsType<T> = () => T;
+type Setter = (fn: (...args: any[]) => any) => any;
+declare const getTemplateIsRunning: () => boolean;
+declare class RenderScheduler {
+    private pendingComponents;
+    isScheduled: boolean;
+    schedule(component: XView): void;
+}
+declare const globalScheduler: RenderScheduler;
+declare class XView extends HTMLElement {
+    private _props;
+    private _propsFn;
+    private _view;
+    private _componentFn;
+    private _hasMounted;
+    private _renderScheduled;
+    _xviewRender: () => void;
+    componentId: number;
+    cleanups: Map<string, Function>;
+    scopes: Map<new () => any, () => any>;
+    addScope(scopeClass: new () => any, scope: any): void;
+    lastVersion: number;
+    onEachUpdateCallbacks: (() => void)[];
+    onEachUpdate(callback: () => void): void;
+    constructor();
+    setter<T extends (...args: any[]) => any>(fn: T): T;
+    set props(val: Record<string, any>);
+    get props(): Record<string, any>;
+    oldView: any;
+    private _isViewLoading;
+    set view(val: any);
+    get view(): any;
+    callOnEachUpdate(): void;
+    disconnectedCallback(): void;
+    addToCleanUps(key: string, cleanup: Function): void;
+    _render(): void;
+}
+
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+interface DirectiveClass {
+    new (part: PartInfo): Directive;
+}
+/**
+ * This utility type extracts the signature of a directive class's render()
+ * method so we can use it for the type of the generated directive function.
+ */
+type DirectiveParameters<C extends Directive> = Parameters<C['render']>;
+/**
+ * A generated directive function doesn't evaluate the directive, but just
+ * returns a DirectiveResult object that captures the arguments.
+ */
+interface DirectiveResult<C extends DirectiveClass = DirectiveClass> {
+}
+declare const PartType: {
+    readonly ATTRIBUTE: 1;
+    readonly CHILD: 2;
+    readonly PROPERTY: 3;
+    readonly BOOLEAN_ATTRIBUTE: 4;
+    readonly EVENT: 5;
+    readonly ELEMENT: 6;
+};
+type PartType = (typeof PartType)[keyof typeof PartType];
+interface ChildPartInfo {
+    readonly type: typeof PartType.CHILD;
+}
+interface AttributePartInfo {
+    readonly type: typeof PartType.ATTRIBUTE | typeof PartType.PROPERTY | typeof PartType.BOOLEAN_ATTRIBUTE | typeof PartType.EVENT;
+    readonly strings?: ReadonlyArray<string>;
+    readonly name: string;
+    readonly tagName: string;
+}
+interface ElementPartInfo {
+    readonly type: typeof PartType.ELEMENT;
+}
+/**
+ * Information about the part a directive is bound to.
+ *
+ * This is useful for checking that a directive is attached to a valid part,
+ * such as with directive that can only be used on attribute bindings.
+ */
+type PartInfo = ChildPartInfo | AttributePartInfo | ElementPartInfo;
+/**
+ * Base class for creating custom directives. Users should extend this class,
+ * implement `render` and/or `update`, and then pass their subclass to
+ * `directive`.
+ */
+declare abstract class Directive implements Disconnectable {
+    constructor(_partInfo: PartInfo);
+    get _$isConnected(): boolean;
+    abstract render(...props: Array<unknown>): unknown;
+    update(_part: Part, props: Array<unknown>): unknown;
+}
+
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+/**
+ * Used to sanitize any value before it is written into the DOM. This can be
+ * used to implement a security policy of allowed and disallowed values in
+ * order to prevent XSS attacks.
+ *
+ * One way of using this callback would be to check attributes and properties
+ * against a list of high risk fields, and require that values written to such
+ * fields be instances of a class which is safe by construction. Closure's Safe
+ * HTML Types is one implementation of this technique (
+ * https://github.com/google/safe-html-types/blob/master/doc/safehtml-types.md).
+ * The TrustedTypes polyfill in API-only mode could also be used as a basis
+ * for this technique (https://github.com/WICG/trusted-types).
+ *
+ * @param node The HTML node (usually either a #text node or an Element) that
+ *     is being written to. Note that this is just an exemplar node, the write
+ *     may take place against another instance of the same class of node.
+ * @param name The name of an attribute or property (for example, 'href').
+ * @param type Indicates whether the write that's about to be performed will
+ *     be to a property or a node.
+ * @return A function that will sanitize this class of writes.
+ */
+type SanitizerFactory = (node: Node, name: string, type: 'property' | 'attribute') => ValueSanitizer;
+/**
+ * A function which can sanitize values that will be written to a specific kind
+ * of DOM sink.
+ *
+ * See SanitizerFactory.
+ *
+ * @param value The value to sanitize. Will be the actual value passed into
+ *     the lit-html template literal, so this could be of any type.
+ * @return The value to write to the DOM. Usually the same as the input value,
+ *     unless sanitization is needed.
+ */
+type ValueSanitizer = (value: unknown) => unknown;
+/** TemplateResult types */
+declare const HTML_RESULT = 1;
+declare const SVG_RESULT = 2;
+declare const MATHML_RESULT = 3;
+type ResultType = typeof HTML_RESULT | typeof SVG_RESULT | typeof MATHML_RESULT;
+declare const ATTRIBUTE_PART = 1;
+declare const CHILD_PART = 2;
+declare const PROPERTY_PART = 3;
+declare const BOOLEAN_ATTRIBUTE_PART = 4;
+declare const EVENT_PART = 5;
+declare const ELEMENT_PART = 6;
+declare const COMMENT_PART = 7;
+/**
+ * The return type of the template tag functions, {@linkcode html} and
+ * {@linkcode svg} when it hasn't been compiled by @lit-labs/compiler.
+ *
+ * A `TemplateResult` object holds all the information about a template
+ * expression required to render it: the template strings, expression values,
+ * and type of template (html or svg).
+ *
+ * `TemplateResult` objects do not create any DOM on their own. To create or
+ * update DOM you need to render the `TemplateResult`. See
+ * [Rendering](https://lit.dev/docs/components/rendering) for more information.
+ *
+ */
+type UncompiledTemplateResult<T extends ResultType = ResultType> = {
+    ['_$litType$']: T;
+    strings: TemplateStringsArray;
+    values: unknown[];
+};
+/**
+ * The return type of the template tag functions, {@linkcode html} and
+ * {@linkcode svg}.
+ *
+ * A `TemplateResult` object holds all the information about a template
+ * expression required to render it: the template strings, expression values,
+ * and type of template (html or svg).
+ *
+ * `TemplateResult` objects do not create any DOM on their own. To create or
+ * update DOM you need to render the `TemplateResult`. See
+ * [Rendering](https://lit.dev/docs/components/rendering) for more information.
+ *
+ * In Lit 4, this type will be an alias of
+ * MaybeCompiledTemplateResult, so that code will get type errors if it assumes
+ * that Lit templates are not compiled. When deliberately working with only
+ * one, use either {@linkcode CompiledTemplateResult} or
+ * {@linkcode UncompiledTemplateResult} explicitly.
+ */
+type TemplateResult<T extends ResultType = ResultType> = UncompiledTemplateResult<T>;
+/**
+ * Interprets a template literal as an HTML template that can efficiently
+ * render to and update a container.
+ *
+ * ```ts
+ * const header = (title: string) => html`<h1>${title}</h1>`;
+ * ```
+ *
+ * The `html` tag returns a description of the DOM to render as a value. It is
+ * lazy, meaning no work is done until the template is rendered. When rendering,
+ * if a template comes from the same expression as a previously rendered result,
+ * it's efficiently updated instead of replaced.
+ */
+declare const html: (strings: TemplateStringsArray, ...values: unknown[]) => TemplateResult<1>;
+/**
+ * A sentinel value that signals that a value was handled by a directive and
+ * should not be written to the DOM.
+ */
+declare const noChange: unique symbol;
+/**
+ * A sentinel value that signals a ChildPart to fully clear its content.
+ *
+ * ```ts
+ * const button = html`${
+ *  user.isAdmin
+ *    ? html`<button>DELETE</button>`
+ *    : nothing
+ * }`;
+ * ```
+ *
+ * Prefer using `nothing` over other falsy values as it provides a consistent
+ * behavior between various expression binding contexts.
+ *
+ * In child expressions, `undefined`, `null`, `''`, and `nothing` all behave the
+ * same and render no nodes. In attribute expressions, `nothing` _removes_ the
+ * attribute, while `undefined` and `null` will render an empty string. In
+ * property expressions `nothing` becomes `undefined`.
+ */
+declare const nothing: unique symbol;
+/**
+ * Object specifying options for controlling lit-html rendering. Note that
+ * while `render` may be called multiple times on the same `container` (and
+ * `renderBefore` reference node) to efficiently update the rendered content,
+ * only the options passed in during the first render are respected during
+ * the lifetime of renders to that unique `container` + `renderBefore`
+ * combination.
+ */
+interface RenderOptions {
+    /**
+     * An object to use as the `this` value for event listeners. It's often
+     * useful to set this to the host component rendering a template.
+     */
+    host?: object;
+    /**
+     * A DOM node before which to render content in the container.
+     */
+    renderBefore?: ChildNode | null;
+    /**
+     * Node used for cloning the template (`importNode` will be called on this
+     * node). This controls the `ownerDocument` of the rendered DOM, along with
+     * any inherited context. Defaults to the global `document`.
+     */
+    creationScope?: {
+        importNode(node: Node, deep?: boolean): Node;
+    };
+    /**
+     * The initial connected state for the top-level part being rendered. If no
+     * `isConnected` option is set, `AsyncDirective`s will be connected by
+     * default. Set to `false` if the initial render occurs in a disconnected tree
+     * and `AsyncDirective`s should see `isConnected === false` for their initial
+     * render. The `part.setConnected()` method must be used subsequent to initial
+     * render to change the connected state of the part.
+     */
+    isConnected?: boolean;
+}
+interface DirectiveParent {
+    _$parent?: DirectiveParent;
+    _$isConnected: boolean;
+    __directive?: Directive;
+    __directives?: Array<Directive | undefined>;
+}
+declare class Template {
+    parts: Array<TemplatePart>;
+    constructor({ strings, ['_$litType$']: type }: UncompiledTemplateResult, options?: RenderOptions);
+    /** @nocollapse */
+    static createElement(html: TrustedHTML, _options?: RenderOptions): HTMLTemplateElement;
+}
+interface Disconnectable {
+    _$parent?: Disconnectable;
+    _$disconnectableChildren?: Set<Disconnectable>;
+    _$isConnected: boolean;
+}
+/**
+ * An updateable instance of a Template. Holds references to the Parts used to
+ * update the template instance.
+ */
+declare class TemplateInstance implements Disconnectable {
+    _$template: Template;
+    _$parts: Array<Part | undefined>;
+    constructor(template: Template, parent: ChildPart);
+    get parentNode(): Node;
+    get _$isConnected(): boolean;
+    _clone(options: RenderOptions | undefined): Node;
+    _update(values: Array<unknown>): void;
+}
+type AttributeTemplatePart = {
+    readonly type: typeof ATTRIBUTE_PART;
+    readonly index: number;
+    readonly name: string;
+    readonly ctor: typeof AttributePart;
+    readonly strings: ReadonlyArray<string>;
+};
+type ChildTemplatePart = {
+    readonly type: typeof CHILD_PART;
+    readonly index: number;
+};
+type ElementTemplatePart = {
+    readonly type: typeof ELEMENT_PART;
+    readonly index: number;
+};
+type CommentTemplatePart = {
+    readonly type: typeof COMMENT_PART;
+    readonly index: number;
+};
+/**
+ * A TemplatePart represents a dynamic part in a template, before the template
+ * is instantiated. When a template is instantiated Parts are created from
+ * TemplateParts.
+ */
+type TemplatePart = ChildTemplatePart | AttributeTemplatePart | ElementTemplatePart | CommentTemplatePart;
+type Part = ChildPart | AttributePart | PropertyPart | BooleanAttributePart | ElementPart | EventPart;
+
+declare class ChildPart implements Disconnectable {
+    readonly type = 2;
+    readonly options: RenderOptions | undefined;
+    _$committedValue: unknown;
+    private _textSanitizer;
+    get _$isConnected(): boolean;
+    constructor(startNode: ChildNode, endNode: ChildNode | null, parent: TemplateInstance | ChildPart | undefined, options: RenderOptions | undefined);
+    /**
+     * The parent node into which the part renders its content.
+     *
+     * A ChildPart's content consists of a range of adjacent child nodes of
+     * `.parentNode`, possibly bordered by 'marker nodes' (`.startNode` and
+     * `.endNode`).
+     *
+     * - If both `.startNode` and `.endNode` are non-null, then the part's content
+     * consists of all siblings between `.startNode` and `.endNode`, exclusively.
+     *
+     * - If `.startNode` is non-null but `.endNode` is null, then the part's
+     * content consists of all siblings following `.startNode`, up to and
+     * including the last child of `.parentNode`. If `.endNode` is non-null, then
+     * `.startNode` will always be non-null.
+     *
+     * - If both `.endNode` and `.startNode` are null, then the part's content
+     * consists of all child nodes of `.parentNode`.
+     */
+    get parentNode(): Node;
+    /**
+     * The part's leading marker node, if any. See `.parentNode` for more
+     * information.
+     */
+    get startNode(): Node | null;
+    /**
+     * The part's trailing marker node, if any. See `.parentNode` for more
+     * information.
+     */
+    get endNode(): Node | null;
+    _$setValue(value: unknown, directiveParent?: DirectiveParent): void;
+    private _insert;
+    private _commitNode;
+    private _commitText;
+    private _commitTemplateResult;
+    private _commitIterable;
+}
+/**
+ * A top-level `ChildPart` returned from `render` that manages the connected
+ * state of `AsyncDirective`s created throughout the tree below it.
+ */
+interface RootPart extends ChildPart {
+    /**
+     * Sets the connection state for `AsyncDirective`s contained within this root
+     * ChildPart.
+     *
+     * lit-html does not automatically monitor the connectedness of DOM rendered;
+     * as such, it is the responsibility of the caller to `render` to ensure that
+     * `part.setConnected(false)` is called before the part object is potentially
+     * discarded, to ensure that `AsyncDirective`s have a chance to dispose of
+     * any resources being held. If a `RootPart` that was previously
+     * disconnected is subsequently re-connected (and its `AsyncDirective`s should
+     * re-connect), `setConnected(true)` should be called.
+     *
+     * @param isConnected Whether directives within this tree should be connected
+     * or not
+     */
+    setConnected(isConnected: boolean): void;
+}
+
+declare class AttributePart implements Disconnectable {
+    readonly type: typeof ATTRIBUTE_PART | typeof PROPERTY_PART | typeof BOOLEAN_ATTRIBUTE_PART | typeof EVENT_PART;
+    readonly element: HTMLElement;
+    readonly name: string;
+    readonly options: RenderOptions | undefined;
+    /**
+     * If this attribute part represents an interpolation, this contains the
+     * static strings of the interpolation. For single-value, complete bindings,
+     * this is undefined.
+     */
+    readonly strings?: ReadonlyArray<string>;
+    protected _sanitizer: ValueSanitizer | undefined;
+    get tagName(): string;
+    get _$isConnected(): boolean;
+    constructor(element: HTMLElement, name: string, strings: ReadonlyArray<string>, parent: Disconnectable, options: RenderOptions | undefined);
+}
+
+declare class PropertyPart extends AttributePart {
+    readonly type = 3;
+}
+
+declare class BooleanAttributePart extends AttributePart {
+    readonly type = 4;
+}
+
+declare class EventPart extends AttributePart {
+    readonly type = 5;
+    constructor(element: HTMLElement, name: string, strings: ReadonlyArray<string>, parent: Disconnectable, options: RenderOptions | undefined);
+    handleEvent(event: Event): void;
+}
+
+declare class ElementPart implements Disconnectable {
+    element: Element;
+    readonly type = 6;
+    _$committedValue: undefined;
+    options: RenderOptions | undefined;
+    constructor(element: Element, parent: Disconnectable, options: RenderOptions | undefined);
+    get _$isConnected(): boolean;
+    _$setValue(value: unknown): void;
+}
+/**
+ * Renders a value, usually a lit-html TemplateResult, to the container.
+ *
+ * This example renders the text "Hello, Zoe!" inside a paragraph tag, appending
+ * it to the container `document.body`.
+ *
+ * ```js
+ * import {html, render} from 'lit';
+ *
+ * const name = "Zoe";
+ * render(html`<p>Hello, ${name}!</p>`, document.body);
+ * ```
+ *
+ * @param value Any [renderable
+ *   value](https://lit.dev/docs/templates/expressions/#child-expressions),
+ *   typically a {@linkcode TemplateResult} created by evaluating a template tag
+ *   like {@linkcode html} or {@linkcode svg}.
+ * @param container A DOM container to render to. The first render will append
+ *   the rendered value to the container, and subsequent renders will
+ *   efficiently update the rendered value if the same result type was
+ *   previously rendered there.
+ * @param options See {@linkcode RenderOptions} for options documentation.
+ * @see
+ * {@link https://lit.dev/docs/libraries/standalone-templates/#rendering-lit-html-templates| Rendering Lit HTML Templates}
+ */
+declare const render: {
+    (value: unknown, container: HTMLElement | DocumentFragment, options?: RenderOptions): RootPart;
+    setSanitizer: (newSanitizer: SanitizerFactory) => void;
+    createSanitizer: SanitizerFactory;
+    _testOnlyClearSanitizerFactoryDoNotCallOrElse: () => void;
+};
+
+type InnerFactory<T> = () => T;
+type ViewType<T> = (factory: InnerFactory<T>) => () => TemplateResult;
+type OuterFn<T> = (factory: InnerFactory<T>) => () => TemplateResult;
+declare const view: <T extends Record<string, any> = {}>(viewFn: OuterFn<T>, props?: T) => TemplateResult<1>;
+declare const renderView: <T extends Record<string, any> = {}>(viewFn: OuterFn<T>, element: HTMLElement) => RootPart;
+
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+type KeyFn<T> = (item: T, index: number) => unknown;
+type ItemTemplate<T> = (item: T, index: number) => unknown;
+interface RepeatDirectiveFn {
+    <T>(items: Iterable<T>, keyFnOrTemplate: KeyFn<T> | ItemTemplate<T>, template?: ItemTemplate<T>): unknown;
+    <T>(items: Iterable<T>, template: ItemTemplate<T>): unknown;
+    <T>(items: Iterable<T>, keyFn: KeyFn<T> | ItemTemplate<T>, template: ItemTemplate<T>): unknown;
+}
+/**
+ * A directive that repeats a series of values (usually `TemplateResults`)
+ * generated from an iterable, and updates those items efficiently when the
+ * iterable changes based on user-provided `keys` associated with each item.
+ *
+ * Note that if a `keyFn` is provided, strict key-to-DOM mapping is maintained,
+ * meaning previous DOM for a given key is moved into the new position if
+ * needed, and DOM will never be reused with values for different keys (new DOM
+ * will always be created for new keys). This is generally the most efficient
+ * way to use `repeat` since it performs minimum unnecessary work for insertions
+ * and removals.
+ *
+ * The `keyFn` takes two parameters, the item and its index, and returns a unique key value.
+ *
+ * ```js
+ * html`
+ *   <ol>
+ *     ${repeat(this.items, (item) => item.id, (item, index) => {
+ *       return html`<li>${index}: ${item.name}</li>`;
+ *     })}
+ *   </ol>
+ * `
+ * ```
+ *
+ * **Important**: If providing a `keyFn`, keys *must* be unique for all items in a
+ * given call to `repeat`. The behavior when two or more items have the same key
+ * is undefined.
+ *
+ * If no `keyFn` is provided, this directive will perform similar to mapping
+ * items to values, and DOM will be reused against potentially different items.
+ */
+declare const repeat: RepeatDirectiveFn;
+
+declare class GuardDirective extends Directive {
+    private _previousValue;
+    render(_value: unknown, f: () => unknown): unknown;
+    update(_part: Part, [value, f]: DirectiveParameters<this>): unknown;
+}
+/**
+ * Prevents re-render of a template function until a single value or an array of
+ * values changes.
+ *
+ * Values are checked against previous values with strict equality (`===`), and
+ * so the check won't detect nested property changes inside objects or arrays.
+ * Arrays values have each item checked against the previous value at the same
+ * index with strict equality. Nested arrays are also checked only by strict
+ * equality.
+ *
+ * Example:
+ *
+ * ```js
+ * html`
+ *   <div>
+ *     ${guard([user.id, company.id], () => html`...`)}
+ *   </div>
+ * `
+ * ```
+ *
+ * In this case, the template only rerenders if either `user.id` or `company.id`
+ * changes.
+ *
+ * guard() is useful with immutable data patterns, by preventing expensive work
+ * until data updates.
+ *
+ * Example:
+ *
+ * ```js
+ * html`
+ *   <div>
+ *     ${guard([immutableItems], () => immutableItems.map(i => html`${i}`))}
+ *   </div>
+ * `
+ * ```
+ *
+ * In this case, items are mapped over only when the array reference changes.
+ *
+ * @param value the value to check before re-rendering
+ * @param f the template function
+ */
+declare const guard: (_value: unknown, f: () => unknown) => DirectiveResult<typeof GuardDirective>;
+
+/**
+ * A key-value set of CSS properties and values.
+ *
+ * The key should be either a valid CSS property name string, like
+ * `'background-color'`, or a valid JavaScript camel case property name
+ * for CSSStyleDeclaration like `backgroundColor`.
+ */
+interface StyleInfo {
+    [name: string]: string | number | undefined | null;
+}
+declare class StyleMapDirective extends Directive {
+    private _previousStyleProperties?;
+    constructor(partInfo: PartInfo);
+    render(styleInfo: Readonly<StyleInfo>): string;
+    update(part: AttributePart, [styleInfo]: DirectiveParameters<this>): string | typeof noChange;
+}
+/**
+ * A directive that applies CSS properties to an element.
+ *
+ * `styleMap` can only be used in the `style` attribute and must be the only
+ * expression in the attribute. It takes the property names in the
+ * {@link StyleInfo styleInfo} object and adds the properties to the inline
+ * style of the element.
+ *
+ * Property names with dashes (`-`) are assumed to be valid CSS
+ * property names and set on the element's style object using `setProperty()`.
+ * Names without dashes are assumed to be camelCased JavaScript property names
+ * and set on the element's style object using property assignment, allowing the
+ * style object to translate JavaScript-style names to CSS property names.
+ *
+ * For example `styleMap({backgroundColor: 'red', 'border-top': '5px', '--size':
+ * '0'})` sets the `background-color`, `border-top` and `--size` properties.
+ *
+ * @param styleInfo
+ * @see {@link https://lit.dev/docs/templates/directives/#stylemap styleMap code samples on Lit.dev}
+ */
+declare const styleMap: (styleInfo: Readonly<StyleInfo>) => DirectiveResult<typeof StyleMapDirective>;
+
+/**
+ * A key-value set of class names to truthy values.
+ */
+interface ClassInfo {
+    readonly [name: string]: string | boolean | number;
+}
+declare class ClassMapDirective extends Directive {
+    /**
+     * Stores the ClassInfo object applied to a given AttributePart.
+     * Used to unset existing values when a new ClassInfo object is applied.
+     */
+    private _previousClasses?;
+    private _staticClasses?;
+    constructor(partInfo: PartInfo);
+    render(classInfo: ClassInfo): string;
+    update(part: AttributePart, [classInfo]: DirectiveParameters<this>): string | typeof noChange;
+}
+/**
+ * A directive that applies dynamic CSS classes.
+ *
+ * This must be used in the `class` attribute and must be the only part used in
+ * the attribute. It takes each property in the `classInfo` argument and adds
+ * the property name to the element's `classList` if the property value is
+ * truthy; if the property value is falsy, the property name is removed from
+ * the element's `class`.
+ *
+ * For example `{foo: bar}` applies the class `foo` if the value of `bar` is
+ * truthy.
+ *
+ * @param classInfo
+ */
+declare const classMap: (classInfo: ClassInfo) => DirectiveResult<typeof ClassMapDirective>;
+
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+type Falsy = null | undefined | false | 0 | -0 | 0n | '';
+/**
+ * When `condition` is true, returns the result of calling `trueCase()`, else
+ * returns the result of calling `falseCase()` if `falseCase` is defined.
+ *
+ * This is a convenience wrapper around a ternary expression that makes it a
+ * little nicer to write an inline conditional without an else.
+ *
+ * @example
+ *
+ * ```ts
+ * render() {
+ *   return html`
+ *     ${when(this.user, () => html`User: ${this.user.username}`, () => html`Sign In...`)}
+ *   `;
+ * }
+ * ```
+ */
+declare function when<C extends Falsy, T, F = undefined>(condition: C, trueCase: (c: C) => T, falseCase?: (c: C) => F): F;
+declare function when<C, T, F>(condition: C extends Falsy ? never : C, trueCase: (c: C) => T, falseCase?: (c: C) => F): T;
+declare function when<C, T, F = undefined>(condition: C, trueCase: (c: Exclude<C, Falsy>) => T, falseCase?: (c: Extract<C, Falsy>) => F): C extends Falsy ? F : T;
+
+/**
+ * @license
+ * Copyright 2018 Google LLC
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+/**
+ * For AttributeParts, sets the attribute if the value is defined and removes
+ * the attribute if the value is undefined.
+ *
+ * For other part types, this directive is a no-op.
+ */
+declare const ifDefined: <T>(value: T) => typeof nothing | NonNullable<T>;
+
+declare class LiveDirective extends Directive {
+    constructor(partInfo: PartInfo);
+    render(value: unknown): unknown;
+    update(part: AttributePart, [value]: DirectiveParameters<this>): unknown;
+}
+/**
+ * Checks binding values against live DOM values, instead of previously bound
+ * values, when determining whether to update the value.
+ *
+ * This is useful for cases where the DOM value may change from outside of
+ * lit-html, such as with a binding to an `<input>` element's `value` property,
+ * a content editable elements text, or to a custom element that changes it's
+ * own properties or attributes.
+ *
+ * In these cases if the DOM value changes, but the value set through lit-html
+ * bindings hasn't, lit-html won't know to update the DOM value and will leave
+ * it alone. If this is not what you want--if you want to overwrite the DOM
+ * value with the bound value no matter what--use the `live()` directive:
+ *
+ * ```js
+ * html`<input .value=${live(x)}>`
+ * ```
+ *
+ * `live()` performs a strict equality check against the live DOM value, and if
+ * the new value is equal to the live value, does nothing. This means that
+ * `live()` should not be used when the binding will cause a type conversion. If
+ * you use `live()` with an attribute binding, make sure that only strings are
+ * passed in, or the binding will update every render.
+ */
+declare const live: (value: unknown) => DirectiveResult<typeof LiveDirective>;
+
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+/**
+ * Overview:
+ *
+ * This module is designed to add support for an async `setValue` API and
+ * `disconnected` callback to directives with the least impact on the core
+ * runtime or payload when that feature is not used.
+ *
+ * The strategy is to introduce a `AsyncDirective` subclass of
+ * `Directive` that climbs the "parent" tree in its constructor to note which
+ * branches of lit-html's "logical tree" of data structures contain such
+ * directives and thus need to be crawled when a subtree is being cleared (or
+ * manually disconnected) in order to run the `disconnected` callback.
+ *
+ * The "nodes" of the logical tree include Parts, TemplateInstances (for when a
+ * TemplateResult is committed to a value of a ChildPart), and Directives; these
+ * all implement a common interface called `DisconnectableChild`. Each has a
+ * `_$parent` reference which is set during construction in the core code, and a
+ * `_$disconnectableChildren` field which is initially undefined.
+ *
+ * The sparse tree created by means of the `AsyncDirective` constructor
+ * crawling up the `_$parent` tree and placing a `_$disconnectableChildren` Set
+ * on each parent that includes each child that contains a
+ * `AsyncDirective` directly or transitively via its children. In order to
+ * notify connection state changes and disconnect (or reconnect) a tree, the
+ * `_$notifyConnectionChanged` API is patched onto ChildParts as a directive
+ * climbs the parent tree, which is called by the core when clearing a part if
+ * it exists. When called, that method iterates over the sparse tree of
+ * Set<DisconnectableChildren> built up by AsyncDirectives, and calls
+ * `_$notifyDirectiveConnectionChanged` on any directives that are encountered
+ * in that tree, running the required callbacks.
+ *
+ * A given "logical tree" of lit-html data-structures might look like this:
+ *
+ *  ChildPart(N1) _$dC=[D2,T3]
+ *   ._directive
+ *     AsyncDirective(D2)
+ *   ._value // user value was TemplateResult
+ *     TemplateInstance(T3) _$dC=[A4,A6,N10,N12]
+ *      ._$parts[]
+ *        AttributePart(A4) _$dC=[D5]
+ *         ._directives[]
+ *           AsyncDirective(D5)
+ *        AttributePart(A6) _$dC=[D7,D8]
+ *         ._directives[]
+ *           AsyncDirective(D7)
+ *           Directive(D8) _$dC=[D9]
+ *            ._directive
+ *              AsyncDirective(D9)
+ *        ChildPart(N10) _$dC=[D11]
+ *         ._directive
+ *           AsyncDirective(D11)
+ *         ._value
+ *           string
+ *        ChildPart(N12) _$dC=[D13,N14,N16]
+ *         ._directive
+ *           AsyncDirective(D13)
+ *         ._value // user value was iterable
+ *           Array<ChildPart>
+ *             ChildPart(N14) _$dC=[D15]
+ *              ._value
+ *                string
+ *             ChildPart(N16) _$dC=[D17,T18]
+ *              ._directive
+ *                AsyncDirective(D17)
+ *              ._value // user value was TemplateResult
+ *                TemplateInstance(T18) _$dC=[A19,A21,N25]
+ *                 ._$parts[]
+ *                   AttributePart(A19) _$dC=[D20]
+ *                    ._directives[]
+ *                      AsyncDirective(D20)
+ *                   AttributePart(A21) _$dC=[22,23]
+ *                    ._directives[]
+ *                      AsyncDirective(D22)
+ *                      Directive(D23) _$dC=[D24]
+ *                       ._directive
+ *                         AsyncDirective(D24)
+ *                   ChildPart(N25) _$dC=[D26]
+ *                    ._directive
+ *                      AsyncDirective(D26)
+ *                    ._value
+ *                      string
+ *
+ * Example 1: The directive in ChildPart(N12) updates and returns `nothing`. The
+ * ChildPart will _clear() itself, and so we need to disconnect the "value" of
+ * the ChildPart (but not its directive). In this case, when `_clear()` calls
+ * `_$notifyConnectionChanged()`, we don't iterate all of the
+ * _$disconnectableChildren, rather we do a value-specific disconnection: i.e.
+ * since the _value was an Array<ChildPart> (because an iterable had been
+ * committed), we iterate the array of ChildParts (N14, N16) and run
+ * `setConnected` on them (which does recurse down the full tree of
+ * `_$disconnectableChildren` below it, and also removes N14 and N16 from N12's
+ * `_$disconnectableChildren`). Once the values have been disconnected, we then
+ * check whether the ChildPart(N12)'s list of `_$disconnectableChildren` is empty
+ * (and would remove it from its parent TemplateInstance(T3) if so), but since
+ * it would still contain its directive D13, it stays in the disconnectable
+ * tree.
+ *
+ * Example 2: In the course of Example 1, `setConnected` will reach
+ * ChildPart(N16); in this case the entire part is being disconnected, so we
+ * simply iterate all of N16's `_$disconnectableChildren` (D17,T18) and
+ * recursively run `setConnected` on them. Note that we only remove children
+ * from `_$disconnectableChildren` for the top-level values being disconnected
+ * on a clear; doing this bookkeeping lower in the tree is wasteful since it's
+ * all being thrown away.
+ *
+ * Example 3: If the LitElement containing the entire tree above becomes
+ * disconnected, it will run `childPart.setConnected()` (which calls
+ * `childPart._$notifyConnectionChanged()` if it exists); in this case, we
+ * recursively run `setConnected()` over the entire tree, without removing any
+ * children from `_$disconnectableChildren`, since this tree is required to
+ * re-connect the tree, which does the same operation, simply passing
+ * `isConnected: true` down the tree, signaling which callback to run.
+ */
+
+/**
+ * An abstract `Directive` base class whose `disconnected` method will be
+ * called when the part containing the directive is cleared as a result of
+ * re-rendering, or when the user calls `part.setConnected(false)` on
+ * a part that was previously rendered containing the directive (as happens
+ * when e.g. a LitElement disconnects from the DOM).
+ *
+ * If `part.setConnected(true)` is subsequently called on a
+ * containing part, the directive's `reconnected` method will be called prior
+ * to its next `update`/`render` callbacks. When implementing `disconnected`,
+ * `reconnected` should also be implemented to be compatible with reconnection.
+ *
+ * Note that updates may occur while the directive is disconnected. As such,
+ * directives should generally check the `this.isConnected` flag during
+ * render/update to determine whether it is safe to subscribe to resources
+ * that may prevent garbage collection.
+ */
+declare abstract class AsyncDirective extends Directive {
+    /**
+     * The connection state for this Directive.
+     */
+    isConnected: boolean;
+    /**
+     * Initialize the part with internal fields
+     * @param part
+     * @param parent
+     * @param attributeIndex
+     */
+    _$initialize(part: Part, parent: Disconnectable, attributeIndex: number | undefined): void;
+    /**
+     * Sets the value of the directive's Part outside the normal `update`/`render`
+     * lifecycle of a directive.
+     *
+     * This method should not be called synchronously from a directive's `update`
+     * or `render`.
+     *
+     * @param directive The directive to update
+     * @param value The value to set
+     */
+    setValue(value: unknown): void;
+    /**
+     * User callbacks for implementing logic to release any resources/subscriptions
+     * that may have been retained by this directive. Since directives may also be
+     * re-connected, `reconnected` should also be implemented to restore the
+     * working state of the directive prior to the next render.
+     */
+    protected disconnected(): void;
+    protected reconnected(): void;
+}
+
+declare class UntilDirective extends AsyncDirective {
+    private __lastRenderedIndex;
+    private __values;
+    private __weakThis;
+    private __pauser;
+    render(...args: Array<unknown>): unknown;
+    update(_part: Part, args: Array<unknown>): unknown;
+    disconnected(): void;
+    reconnected(): void;
+}
+/**
+ * Renders one of a series of values, including Promises, to a Part.
+ *
+ * Values are rendered in priority order, with the first argument having the
+ * highest priority and the last argument having the lowest priority. If a
+ * value is a Promise, low-priority values will be rendered until it resolves.
+ *
+ * The priority of values can be used to create placeholder content for async
+ * data. For example, a Promise with pending content can be the first,
+ * highest-priority, argument, and a non_promise loading indicator template can
+ * be used as the second, lower-priority, argument. The loading indicator will
+ * render immediately, and the primary content will render when the Promise
+ * resolves.
+ *
+ * Example:
+ *
+ * ```js
+ * const content = fetch('./content.txt').then(r => r.text());
+ * html`${until(content, html`<span>Loading...</span>`)}`
+ * ```
+ */
+declare const until: (...values: unknown[]) => DirectiveResult<typeof UntilDirective>;
+
+declare class Keyed extends Directive {
+    key: unknown;
+    render(k: unknown, v: unknown): unknown;
+    update(part: ChildPart, [k, v]: DirectiveParameters<this>): unknown;
+}
+/**
+ * Associates a renderable value with a unique key. When the key changes, the
+ * previous DOM is removed and disposed before rendering the next value, even
+ * if the value - such as a template - is the same.
+ *
+ * This is useful for forcing re-renders of stateful components, or working
+ * with code that expects new data to generate new HTML elements, such as some
+ * animation techniques.
+ */
+declare const keyed: (k: unknown, v: unknown) => DirectiveResult<typeof Keyed>;
+
+declare class CacheDirective extends Directive {
+    private _templateCache;
+    private _value?;
+    constructor(partInfo: PartInfo);
+    render(v: unknown): unknown[];
+    update(containerPart: ChildPart, [v]: DirectiveParameters<this>): unknown[];
+}
+/**
+ * Enables fast switching between multiple templates by caching the DOM nodes
+ * and TemplateInstances produced by the templates.
+ *
+ * Example:
+ *
+ * ```js
+ * let checked = false;
+ *
+ * html`
+ *   ${cache(checked ? html`input is checked` : html`input is not checked`)}
+ * `
+ * ```
+ */
+declare const cache: (v: unknown) => DirectiveResult<typeof CacheDirective>;
+
+type Mapper<T> = (v: T, index?: number) => unknown;
+declare class AsyncReplaceDirective extends AsyncDirective {
+    private __value?;
+    private __weakThis;
+    private __pauser;
+    render<T>(value: AsyncIterable<T>, _mapper?: Mapper<T>): symbol;
+    update(_part: ChildPart, [value, mapper]: DirectiveParameters<this>): symbol;
+    protected commitValue(value: unknown, _index: number): void;
+    disconnected(): void;
+    reconnected(): void;
+}
+/**
+ * A directive that renders the items of an async iterable[1], replacing
+ * previous values with new values, so that only one value is ever rendered
+ * at a time. This directive may be used in any expression type.
+ *
+ * Async iterables are objects with a `[Symbol.asyncIterator]` method, which
+ * returns an iterator who's `next()` method returns a Promise. When a new
+ * value is available, the Promise resolves and the value is rendered to the
+ * Part controlled by the directive. If another value other than this
+ * directive has been set on the Part, the iterable will no longer be listened
+ * to and new values won't be written to the Part.
+ *
+ * [1]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for-await...of
+ *
+ * @param value An async iterable
+ * @param mapper An optional function that maps from (value, index) to another
+ *     value. Useful for generating templates for each item in the iterable.
+ */
+declare const asyncReplace: (value: AsyncIterable<unknown>, _mapper?: Mapper<unknown> | undefined) => DirectiveResult<typeof AsyncReplaceDirective>;
+
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+/**
+ * Returns an iterable containing the values in `items` interleaved with the
+ * `joiner` value.
+ *
+ * @example
+ *
+ * ```ts
+ * render() {
+ *   return html`
+ *     ${join(items, html`<span class="separator">|</span>`)}
+ *   `;
+ * }
+ */
+declare function join<I, J>(items: Iterable<I> | undefined, joiner: (index: number) => J): Iterable<I | J>;
+declare function join<I, J>(items: Iterable<I> | undefined, joiner: J): Iterable<I | J>;
+
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+/**
+ * Returns an iterable of integers from `start` to `end` (exclusive)
+ * incrementing by `step`.
+ *
+ * If `start` is omitted, the range starts at `0`. `step` defaults to `1`.
+ *
+ * @example
+ *
+ * ```ts
+ * render() {
+ *   return html`
+ *     ${map(range(8), () => html`<div class="cell"></div>`)}
+ *   `;
+ * }
+ * ```
+ */
+declare function range(end: number): Iterable<number>;
+declare function range(start: number, end: number, step?: number): Iterable<number>;
+
+declare class AsyncAppendDirective extends AsyncReplaceDirective {
+    private __childPart;
+    constructor(partInfo: PartInfo);
+    update(part: ChildPart, params: DirectiveParameters<this>): symbol;
+    protected commitValue(value: unknown, index: number): void;
+}
+/**
+ * A directive that renders the items of an async iterable[1], appending new
+ * values after previous values, similar to the built-in support for iterables.
+ * This directive is usable only in child expressions.
+ *
+ * Async iterables are objects with a [Symbol.asyncIterator] method, which
+ * returns an iterator who's `next()` method returns a Promise. When a new
+ * value is available, the Promise resolves and the value is appended to the
+ * Part controlled by the directive. If another value other than this
+ * directive has been set on the Part, the iterable will no longer be listened
+ * to and new values won't be written to the Part.
+ *
+ * [1]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for-await...of
+ *
+ * @param value An async iterable
+ * @param mapper An optional function that maps from (value, index) to another
+ *     value. Useful for generating templates for each item in the iterable.
+ */
+declare const asyncAppend: (value: AsyncIterable<unknown>, _mapper?: ((v: unknown, index?: number) => unknown) | undefined) => DirectiveResult<typeof AsyncAppendDirective>;
+
+type AsyncMethodKeys<T> = {
+    [K in keyof T]: T[K] extends (...args: infer _A) => Promise<unknown> ? K : never;
+}[keyof T];
+type ForbidAsyncMethods<T> = AsyncMethodKeys<T> extends never ? {} : never;
+interface ScopeGetter<T> {
+    (): T;
+    reset: () => T;
+    __isScope___: boolean;
+    readonly __version__: number;
+}
+declare const useScope: <T extends object>(ScopeClass: (new () => T & ForbidAsyncMethods<T>)) => [ScopeGetter<T>, () => T];
+declare const getParentScope: <T>(ScopeClass: (new () => T)) => never;
+
+export { Context, _, action, asyncAppend, asyncAtom, asyncReplace, atom, bubble, cache, classMap, df, getCurrentHost, getParentScope, getProps as getStoreProps, getTemplateIsRunning, getbubbleInProgress, getbubblesSetter, getter, globalScheduler, globalVersion, guard, html, iAtom, ifDefined, incrGlobalVersion, isPathMatching, join, keyed, live, location, molecule, range, render, renderView, repeat, safetyCheck, setBubbleInProgress, setBubblesSetter, setter, styleMap, subscribe, unit, until, useContext, useUpdate as useForceUpdate, useMutable, useOnMount, useOnUnmount, useRefEffect, useScope, useState, useStore, useSubscribe, useUpdate, view, when, withHost };
+export type { PropsType as Props, Setter, SetterReturnType, ViewType };