sinho 0.1.0

package/web/static/dist/bundle.d.ts

@@ -0,0 +1,1126 @@
+/**
+ * Represents a signal-based computation.
+ */
+interface SignalLike<out T> {
+    /**
+     * Gets the current value of the signal with tracking by default.
+     */
+    (): T;
+}
+/**
+ * Represents a value that tracks changes over time.
+ */
+interface Signal<out T> extends SignalLike<T> {
+    /** @ignore */
+    _effects: Set<Effect>;
+    /**
+     * Accesses the current value of the signal without tracking.
+     */
+    peek(): T;
+}
+interface SetSignalOptions {
+    /**
+     * Whether to force the update of the signal even if the new value has the
+     * same reference.
+     */
+    force?: boolean;
+    /**
+     * Whether to suppress the update of the signal's effects.
+     */
+    silent?: boolean;
+}
+/**
+ * Can be used to update a signal with a new value.
+ */
+interface SignalSetter<in T, out U = T> {
+    (update: (value: U) => T, opts?: SetSignalOptions): void;
+    (value: T extends Function ? never : T, opts?: SetSignalOptions): void;
+}
+interface SubscopeOptions {
+    details?: object;
+}
+interface Effect {
+    _clean?: Cleanup;
+    _deps: Set<Signal<unknown>>;
+    _scope: Scope;
+    _run(): void;
+}
+/**
+ * Represents the cleanup function of an effect.
+ */
+type Cleanup = (() => void) | void | undefined | null;
+interface Scope<out T = {}> {
+    readonly _parent?: Scope;
+    _effects: Effect[];
+    _subscopes: Scope[];
+    _details: T;
+    _run<T>(fn: () => T): T;
+    _cleanup(): void;
+}
+/** @ignore */
+declare const useScope: <T = {}>() => Scope<T>;
+/**
+ * Creates a new signal with the given value.
+ * @returns A tuple with the signal and its setter.
+ */
+declare const useSignal: (<T>(value: T, opts?: SetSignalOptions) => readonly [Signal<T>, SignalSetter<T>]) & (<T>(value?: T, opts?: SetSignalOptions) => readonly [Signal<T | undefined>, SignalSetter<T | undefined>]);
+/**
+ * Runs the given function in a batch.
+ *
+ * @param fn Any calls to signal setters inside the function will be batched
+ * and updated at the same time.
+ */
+declare const useBatch: <T>(fn: () => T) => T;
+/**
+ * Creates a memoized signal.
+ *
+ * @param fn The computation function.
+ */
+declare const useMemo: <T>(fn: () => T, opts?: SetSignalOptions) => Signal<T>;
+/**
+ * Provide write capabilities to a signal.
+ */
+interface RefSignal<in out T> extends Signal<T>, RefSignalSetter<T> {
+    /**
+     * Sets the value of the signal.
+     */
+    set: SignalSetter<T>;
+}
+/**
+ * A contravariant variant of {@link RefSignal}.
+ */
+interface RefSignalSetter<in T> {
+    /**
+     * Sets the value of the signal.
+     */
+    set: SignalSetter<T, unknown>;
+}
+/**
+ * Creates a new signal with write capabilities.
+ */
+declare const useRef: (<T>(value: T, opts?: SetSignalOptions) => RefSignal<T>) & (<T>(value?: T, opts?: SetSignalOptions) => RefSignal<T | undefined>);
+/**
+ * Represents a value that can be a signal or a constant value.
+ *
+ * Note that functions are not allowed as constant values.
+ */
+type MaybeSignal<T> = SignalLike<T> | (T extends Function ? never : T);
+/**
+ * @namespace
+ */
+declare const MaybeSignal: {
+    /**
+     * Transforms the given {@link MaybeSignal} into a {@link Signal}.
+     */
+    upgrade: <T>(signal: MaybeSignal<T>) => SignalLike<T>;
+    /**
+     * Gets the value of the given {@link MaybeSignal}.
+     */
+    get: <T_1>(signal: MaybeSignal<T_1>) => T_1;
+    /**
+     * Accesses the value of the given {@link MaybeSignal} without tracking.
+     */
+    peek<T_2>(signal: MaybeSignal<T_2>): T_2;
+};
+
+interface DomIntrinsicElements {
+    a: HtmlProps<HTMLAnchorElement> & DomEventProps<HTMLAnchorElement>;
+    abbr: HtmlProps<HTMLElement> & DomEventProps<HTMLElement>;
+    address: HtmlProps<HTMLElement> & DomEventProps<HTMLElement>;
+    area: HtmlProps<HTMLAreaElement> & DomEventProps<HTMLAreaElement>;
+    article: HtmlProps<HTMLElement> & DomEventProps<HTMLElement>;
+    aside: HtmlProps<HTMLElement> & DomEventProps<HTMLElement>;
+    audio: HtmlProps<HTMLAudioElement> & DomEventProps<HTMLAudioElement>;
+    b: HtmlProps<HTMLElement> & DomEventProps<HTMLElement>;
+    base: HtmlProps<HTMLBaseElement> & DomEventProps<HTMLBaseElement>;
+    bdi: HtmlProps<HTMLElement> & DomEventProps<HTMLElement>;
+    bdo: HtmlProps<HTMLElement> & DomEventProps<HTMLElement>;
+    big: HtmlProps<HTMLElement> & DomEventProps<HTMLElement>;
+    blockquote: HtmlProps<HTMLQuoteElement> & DomEventProps<HTMLQuoteElement>;
+    body: HtmlProps<HTMLBodyElement> & DomEventProps<HTMLBodyElement>;
+    br: HtmlProps<HTMLBRElement> & DomEventProps<HTMLBRElement>;
+    button: HtmlProps<HTMLButtonElement> & DomEventProps<HTMLButtonElement>;
+    canvas: HtmlProps<HTMLCanvasElement> & DomEventProps<HTMLCanvasElement>;
+    caption: HtmlProps<HTMLTableCaptionElement> & DomEventProps<HTMLTableCaptionElement>;
+    cite: HtmlProps<HTMLElement> & DomEventProps<HTMLElement>;
+    code: HtmlProps<HTMLElement> & DomEventProps<HTMLElement>;
+    col: HtmlProps<HTMLTableColElement> & DomEventProps<HTMLTableColElement>;
+    colgroup: HtmlProps<HTMLTableColElement> & DomEventProps<HTMLTableColElement>;
+    data: HtmlProps<HTMLDataElement> & DomEventProps<HTMLDataElement>;
+    datalist: HtmlProps<HTMLDataListElement> & DomEventProps<HTMLDataListElement>;
+    dd: HtmlProps<HTMLElement> & DomEventProps<HTMLElement>;
+    del: HtmlProps<HTMLModElement> & DomEventProps<HTMLModElement>;
+    details: HtmlProps<HTMLDetailsElement> & DomEventProps<HTMLDetailsElement>;
+    dfn: HtmlProps<HTMLElement> & DomEventProps<HTMLElement>;
+    dialog: HtmlProps<HTMLDialogElement> & DomEventProps<HTMLDialogElement>;
+    div: HtmlProps<HTMLDivElement> & DomEventProps<HTMLDivElement>;
+    dl: HtmlProps<HTMLDListElement> & DomEventProps<HTMLDListElement>;
+    dt: HtmlProps<HTMLElement> & DomEventProps<HTMLElement>;
+    em: HtmlProps<HTMLElement> & DomEventProps<HTMLElement>;
+    embed: HtmlProps<HTMLEmbedElement> & DomEventProps<HTMLEmbedElement>;
+    fieldset: HtmlProps<HTMLFieldSetElement> & DomEventProps<HTMLFieldSetElement>;
+    figcaption: HtmlProps<HTMLElement> & DomEventProps<HTMLElement>;
+    figure: HtmlProps<HTMLElement> & DomEventProps<HTMLElement>;
+    footer: HtmlProps<HTMLElement> & DomEventProps<HTMLElement>;
+    form: HtmlProps<HTMLFormElement> & DomEventProps<HTMLFormElement>;
+    h1: HtmlProps<HTMLHeadingElement> & DomEventProps<HTMLHeadingElement>;
+    h2: HtmlProps<HTMLHeadingElement> & DomEventProps<HTMLHeadingElement>;
+    h3: HtmlProps<HTMLHeadingElement> & DomEventProps<HTMLHeadingElement>;
+    h4: HtmlProps<HTMLHeadingElement> & DomEventProps<HTMLHeadingElement>;
+    h5: HtmlProps<HTMLHeadingElement> & DomEventProps<HTMLHeadingElement>;
+    h6: HtmlProps<HTMLHeadingElement> & DomEventProps<HTMLHeadingElement>;
+    head: HtmlProps<HTMLHeadElement> & DomEventProps<HTMLHeadElement>;
+    header: HtmlProps<HTMLElement> & DomEventProps<HTMLElement>;
+    hgroup: HtmlProps<HTMLElement> & DomEventProps<HTMLElement>;
+    hr: HtmlProps<HTMLHRElement> & DomEventProps<HTMLHRElement>;
+    html: HtmlProps<HTMLHtmlElement> & DomEventProps<HTMLHtmlElement>;
+    i: HtmlProps<HTMLElement> & DomEventProps<HTMLElement>;
+    iframe: HtmlProps<HTMLIFrameElement> & DomEventProps<HTMLIFrameElement>;
+    img: HtmlProps<HTMLImageElement> & DomEventProps<HTMLImageElement>;
+    input: HtmlProps<HTMLInputElement> & DomEventProps<HTMLInputElement>;
+    ins: HtmlProps<HTMLModElement> & DomEventProps<HTMLModElement>;
+    kbd: HtmlProps<HTMLElement> & DomEventProps<HTMLElement>;
+    keygen: HtmlProps<HTMLUnknownElement> & DomEventProps<HTMLUnknownElement>;
+    label: HtmlProps<HTMLLabelElement> & DomEventProps<HTMLLabelElement>;
+    legend: HtmlProps<HTMLLegendElement> & DomEventProps<HTMLLegendElement>;
+    li: HtmlProps<HTMLLIElement> & DomEventProps<HTMLLIElement>;
+    link: HtmlProps<HTMLLinkElement> & DomEventProps<HTMLLinkElement>;
+    main: HtmlProps<HTMLElement> & DomEventProps<HTMLElement>;
+    map: HtmlProps<HTMLMapElement> & DomEventProps<HTMLMapElement>;
+    mark: HtmlProps<HTMLElement> & DomEventProps<HTMLElement>;
+    marquee: HtmlProps<HTMLMarqueeElement> & DomEventProps<HTMLMarqueeElement>;
+    menu: HtmlProps<HTMLMenuElement> & DomEventProps<HTMLMenuElement>;
+    menuitem: HtmlProps<HTMLUnknownElement> & DomEventProps<HTMLUnknownElement>;
+    meta: HtmlProps<HTMLMetaElement> & DomEventProps<HTMLMetaElement>;
+    meter: HtmlProps<HTMLMeterElement> & DomEventProps<HTMLMeterElement>;
+    nav: HtmlProps<HTMLElement> & DomEventProps<HTMLElement>;
+    noscript: HtmlProps<HTMLElement> & DomEventProps<HTMLElement>;
+    object: HtmlProps<HTMLObjectElement> & DomEventProps<HTMLObjectElement>;
+    ol: HtmlProps<HTMLOListElement> & DomEventProps<HTMLOListElement>;
+    optgroup: HtmlProps<HTMLOptGroupElement> & DomEventProps<HTMLOptGroupElement>;
+    option: HtmlProps<HTMLOptionElement> & DomEventProps<HTMLOptionElement>;
+    output: HtmlProps<HTMLOutputElement> & DomEventProps<HTMLOutputElement>;
+    p: HtmlProps<HTMLParagraphElement> & DomEventProps<HTMLParagraphElement>;
+    param: HtmlProps<HTMLParamElement> & DomEventProps<HTMLParamElement>;
+    picture: HtmlProps<HTMLPictureElement> & DomEventProps<HTMLPictureElement>;
+    pre: HtmlProps<HTMLPreElement> & DomEventProps<HTMLPreElement>;
+    progress: HtmlProps<HTMLProgressElement> & DomEventProps<HTMLProgressElement>;
+    q: HtmlProps<HTMLQuoteElement> & DomEventProps<HTMLQuoteElement>;
+    rp: HtmlProps<HTMLElement> & DomEventProps<HTMLElement>;
+    rt: HtmlProps<HTMLElement> & DomEventProps<HTMLElement>;
+    ruby: HtmlProps<HTMLElement> & DomEventProps<HTMLElement>;
+    s: HtmlProps<HTMLElement> & DomEventProps<HTMLElement>;
+    samp: HtmlProps<HTMLElement> & DomEventProps<HTMLElement>;
+    script: HtmlProps<HTMLScriptElement> & DomEventProps<HTMLScriptElement>;
+    section: HtmlProps<HTMLElement> & DomEventProps<HTMLElement>;
+    select: HtmlProps<HTMLSelectElement> & DomEventProps<HTMLSelectElement>;
+    slot: HtmlProps<HTMLSlotElement> & DomEventProps<HTMLSlotElement>;
+    small: HtmlProps<HTMLElement> & DomEventProps<HTMLElement>;
+    source: HtmlProps<HTMLSourceElement> & DomEventProps<HTMLSourceElement>;
+    span: HtmlProps<HTMLSpanElement> & DomEventProps<HTMLSpanElement>;
+    strong: HtmlProps<HTMLElement> & DomEventProps<HTMLElement>;
+    style: HtmlProps<HTMLStyleElement> & DomEventProps<HTMLStyleElement>;
+    sub: HtmlProps<HTMLElement> & DomEventProps<HTMLElement>;
+    summary: HtmlProps<HTMLElement> & DomEventProps<HTMLElement>;
+    sup: HtmlProps<HTMLElement> & DomEventProps<HTMLElement>;
+    table: HtmlProps<HTMLTableElement> & DomEventProps<HTMLTableElement>;
+    tbody: HtmlProps<HTMLTableSectionElement> & DomEventProps<HTMLTableSectionElement>;
+    td: HtmlProps<HTMLTableCellElement> & DomEventProps<HTMLTableCellElement>;
+    textarea: HtmlProps<HTMLTextAreaElement> & DomEventProps<HTMLTextAreaElement>;
+    tfoot: HtmlProps<HTMLTableSectionElement> & DomEventProps<HTMLTableSectionElement>;
+    th: HtmlProps<HTMLTableCellElement> & DomEventProps<HTMLTableCellElement>;
+    thead: HtmlProps<HTMLTableSectionElement> & DomEventProps<HTMLTableSectionElement>;
+    time: HtmlProps<HTMLTimeElement> & DomEventProps<HTMLTimeElement>;
+    title: HtmlProps<HTMLTitleElement> & DomEventProps<HTMLTitleElement>;
+    tr: HtmlProps<HTMLTableRowElement> & DomEventProps<HTMLTableRowElement>;
+    track: HtmlProps<HTMLTrackElement> & DomEventProps<HTMLTrackElement>;
+    u: HtmlProps<HTMLElement> & DomEventProps<HTMLElement>;
+    ul: HtmlProps<HTMLUListElement> & DomEventProps<HTMLUListElement>;
+    var: HtmlProps<HTMLElement> & DomEventProps<HTMLElement>;
+    video: HtmlProps<HTMLVideoElement> & DomEventProps<HTMLVideoElement>;
+    wbr: HtmlProps<HTMLElement> & DomEventProps<HTMLElement>;
+    svg: SvgProps<SVGSVGElement> & DomEventProps<SVGSVGElement>;
+    animate: SvgProps<SVGAnimateElement> & DomEventProps<SVGAnimateElement>;
+    circle: SvgProps<SVGCircleElement> & DomEventProps<SVGCircleElement>;
+    animateTransform: SvgProps<SVGAnimateElement> & DomEventProps<SVGAnimateElement>;
+    clipPath: SvgProps<SVGClipPathElement> & DomEventProps<SVGClipPathElement>;
+    defs: SvgProps<SVGDefsElement> & DomEventProps<SVGDefsElement>;
+    desc: SvgProps<SVGDescElement> & DomEventProps<SVGDescElement>;
+    ellipse: SvgProps<SVGEllipseElement> & DomEventProps<SVGEllipseElement>;
+    feBlend: SvgProps<SVGFEBlendElement> & DomEventProps<SVGFEBlendElement>;
+    feColorMatrix: SvgProps<SVGFEColorMatrixElement> & DomEventProps<SVGFEColorMatrixElement>;
+    feComponentTransfer: SvgProps<SVGFEComponentTransferElement> & DomEventProps<SVGFEComponentTransferElement>;
+    feComposite: SvgProps<SVGFECompositeElement> & DomEventProps<SVGFECompositeElement>;
+    feConvolveMatrix: SvgProps<SVGFEConvolveMatrixElement> & DomEventProps<SVGFEConvolveMatrixElement>;
+    feDiffuseLighting: SvgProps<SVGFEDiffuseLightingElement> & DomEventProps<SVGFEDiffuseLightingElement>;
+    feDisplacementMap: SvgProps<SVGFEDisplacementMapElement> & DomEventProps<SVGFEDisplacementMapElement>;
+    feDropShadow: SvgProps<SVGFEDropShadowElement> & DomEventProps<SVGFEDropShadowElement>;
+    feFlood: SvgProps<SVGFEFloodElement> & DomEventProps<SVGFEFloodElement>;
+    feFuncA: SvgProps<SVGFEFuncAElement> & DomEventProps<SVGFEFuncAElement>;
+    feFuncB: SvgProps<SVGFEFuncBElement> & DomEventProps<SVGFEFuncBElement>;
+    feFuncG: SvgProps<SVGFEFuncGElement> & DomEventProps<SVGFEFuncGElement>;
+    feFuncR: SvgProps<SVGFEFuncRElement> & DomEventProps<SVGFEFuncRElement>;
+    feGaussianBlur: SvgProps<SVGFEGaussianBlurElement> & DomEventProps<SVGFEGaussianBlurElement>;
+    feImage: SvgProps<SVGFEImageElement> & DomEventProps<SVGFEImageElement>;
+    feMerge: SvgProps<SVGFEMergeElement> & DomEventProps<SVGFEMergeElement>;
+    feMergeNode: SvgProps<SVGFEMergeNodeElement> & DomEventProps<SVGFEMergeNodeElement>;
+    feMorphology: SvgProps<SVGFEMorphologyElement> & DomEventProps<SVGFEMorphologyElement>;
+    feOffset: SvgProps<SVGFEOffsetElement> & DomEventProps<SVGFEOffsetElement>;
+    feSpecularLighting: SvgProps<SVGFESpecularLightingElement> & DomEventProps<SVGFESpecularLightingElement>;
+    feTile: SvgProps<SVGFETileElement> & DomEventProps<SVGFETileElement>;
+    feTurbulence: SvgProps<SVGFETurbulenceElement> & DomEventProps<SVGFETurbulenceElement>;
+    filter: SvgProps<SVGFilterElement> & DomEventProps<SVGFilterElement>;
+    foreignObject: SvgProps<SVGForeignObjectElement> & DomEventProps<SVGForeignObjectElement>;
+    g: SvgProps<SVGGElement> & DomEventProps<SVGGElement>;
+    image: SvgProps<SVGImageElement> & DomEventProps<SVGImageElement>;
+    line: SvgProps<SVGLineElement> & DomEventProps<SVGLineElement>;
+    linearGradient: SvgProps<SVGLinearGradientElement> & DomEventProps<SVGLinearGradientElement>;
+    marker: SvgProps<SVGMarkerElement> & DomEventProps<SVGMarkerElement>;
+    mask: SvgProps<SVGMaskElement> & DomEventProps<SVGMaskElement>;
+    path: SvgProps<SVGPathElement> & DomEventProps<SVGPathElement>;
+    pattern: SvgProps<SVGPatternElement> & DomEventProps<SVGPatternElement>;
+    polygon: SvgProps<SVGPolygonElement> & DomEventProps<SVGPolygonElement>;
+    polyline: SvgProps<SVGPolylineElement> & DomEventProps<SVGPolylineElement>;
+    radialGradient: SvgProps<SVGRadialGradientElement> & DomEventProps<SVGRadialGradientElement>;
+    rect: SvgProps<SVGRectElement> & DomEventProps<SVGRectElement>;
+    stop: SvgProps<SVGStopElement> & DomEventProps<SVGStopElement>;
+    symbol: SvgProps<SVGSymbolElement> & DomEventProps<SVGSymbolElement>;
+    text: SvgProps<SVGTextElement> & DomEventProps<SVGTextElement>;
+    textPath: SvgProps<SVGTextPathElement> & DomEventProps<SVGTextPathElement>;
+    tspan: SvgProps<SVGTSpanElement> & DomEventProps<SVGTSpanElement>;
+    use: SvgProps<SVGUseElement> & DomEventProps<SVGUseElement>;
+    [tagName: string]: DomProps<any> & Record<string, any>;
+}
+type Styles = {
+    [K in Exclude<keyof CSSStyleDeclaration, "item" | "setProperty" | "removeProperty" | "getPropertyValue" | "getPropertyPriority" | typeof Symbol.iterator | number>]?: MaybeSignal<string | number | null | undefined>;
+} & {
+    [key: string]: MaybeSignal<string | number | null | undefined>;
+};
+type ExcludeNeverValues<T> = T[Exclude<keyof T, {
+    [K in keyof T]: T[K] extends never ? K : never;
+}[keyof T]>];
+type EventMap = Pick<ElementEventMap & DocumentEventMap & GlobalEventHandlersEventMap, ExcludeNeverValues<{
+    [K in keyof (ElementEventMap & DocumentEventMap & GlobalEventHandlersEventMap)]: K extends Lowercase<K> ? K : never;
+}>>;
+type EventHandler<K extends keyof EventMap, E> = (this: E, evt: Omit<EventMap[K], "currentTarget"> & {
+    currentTarget: E;
+}) => void;
+type DomEventProps<E> = {
+    [K in keyof EventMap as `on${K}`]?: EventHandler<K, E>;
+};
+interface DangerousHtml {
+    __html: string;
+}
+interface DomProps<in E> {
+    ref?: RefSignalSetter<E | undefined>;
+    class?: MaybeSignal<string | undefined>;
+    style?: Styles;
+    dangerouslySetInnerHTML?: MaybeSignal<DangerousHtml>;
+    children?: Children;
+}
+interface HtmlProps<in E> extends DomProps<E> {
+    accept?: MaybeSignal<string | undefined>;
+    acceptCharset?: MaybeSignal<string | undefined>;
+    accessKey?: MaybeSignal<string | undefined>;
+    action?: MaybeSignal<string | undefined>;
+    allow?: MaybeSignal<string | undefined>;
+    allowFullScreen?: MaybeSignal<boolean | undefined>;
+    allowTransparency?: MaybeSignal<boolean | undefined>;
+    alt?: MaybeSignal<string | undefined>;
+    as?: MaybeSignal<string | undefined>;
+    async?: MaybeSignal<boolean | undefined>;
+    autocomplete?: MaybeSignal<string | undefined>;
+    autoComplete?: MaybeSignal<string | undefined>;
+    autocorrect?: MaybeSignal<string | undefined>;
+    autoCorrect?: MaybeSignal<string | undefined>;
+    autofocus?: MaybeSignal<boolean | undefined>;
+    autoFocus?: MaybeSignal<boolean | undefined>;
+    autoPlay?: MaybeSignal<boolean | undefined>;
+    capture?: MaybeSignal<string | undefined>;
+    cellPadding?: MaybeSignal<string | undefined>;
+    cellSpacing?: MaybeSignal<string | undefined>;
+    charSet?: MaybeSignal<string | undefined>;
+    challenge?: MaybeSignal<string | undefined>;
+    checked?: MaybeSignal<boolean | undefined>;
+    cite?: MaybeSignal<string | undefined>;
+    cols?: MaybeSignal<number | undefined>;
+    colSpan?: MaybeSignal<number | undefined>;
+    content?: MaybeSignal<string | undefined>;
+    contentEditable?: MaybeSignal<boolean | undefined>;
+    contextMenu?: MaybeSignal<string | undefined>;
+    controls?: MaybeSignal<boolean | undefined>;
+    controlsList?: MaybeSignal<string | undefined>;
+    coords?: MaybeSignal<string | undefined>;
+    crossOrigin?: MaybeSignal<string | undefined>;
+    data?: MaybeSignal<string | undefined>;
+    dateTime?: MaybeSignal<string | undefined>;
+    default?: MaybeSignal<boolean | undefined>;
+    defaultChecked?: MaybeSignal<boolean | undefined>;
+    defaultValue?: MaybeSignal<string | string[] | number | undefined>;
+    defer?: MaybeSignal<boolean | undefined>;
+    dir?: MaybeSignal<"auto" | "rtl" | "ltr" | undefined>;
+    disabled?: MaybeSignal<boolean | undefined>;
+    disableRemotePlayback?: MaybeSignal<boolean | undefined>;
+    download?: MaybeSignal<any | undefined>;
+    decoding?: MaybeSignal<"sync" | "async" | "auto" | undefined>;
+    draggable?: MaybeSignal<boolean | undefined>;
+    encType?: MaybeSignal<string | undefined>;
+    enterkeyhint?: MaybeSignal<"enter" | "done" | "go" | "next" | "previous" | "search" | "send" | undefined>;
+    for?: MaybeSignal<string | undefined>;
+    form?: MaybeSignal<string | undefined>;
+    formAction?: MaybeSignal<string | undefined>;
+    formEncType?: MaybeSignal<string | undefined>;
+    formMethod?: MaybeSignal<string | undefined>;
+    formNoValidate?: MaybeSignal<boolean | undefined>;
+    formTarget?: MaybeSignal<string | undefined>;
+    frameBorder?: MaybeSignal<number | string | undefined>;
+    headers?: MaybeSignal<string | undefined>;
+    height?: MaybeSignal<number | string | undefined>;
+    hidden?: MaybeSignal<boolean | undefined>;
+    high?: MaybeSignal<number | undefined>;
+    href?: MaybeSignal<string | undefined>;
+    hrefLang?: MaybeSignal<string | undefined>;
+    httpEquiv?: MaybeSignal<string | undefined>;
+    icon?: MaybeSignal<string | undefined>;
+    inputMode?: MaybeSignal<string | undefined>;
+    integrity?: MaybeSignal<string | undefined>;
+    is?: MaybeSignal<string | undefined>;
+    keyParams?: MaybeSignal<string | undefined>;
+    keyType?: MaybeSignal<string | undefined>;
+    kind?: MaybeSignal<string | undefined>;
+    label?: MaybeSignal<string | undefined>;
+    lang?: MaybeSignal<string | undefined>;
+    list?: MaybeSignal<string | undefined>;
+    loading?: MaybeSignal<"eager" | "lazy" | undefined>;
+    loop?: MaybeSignal<boolean | undefined>;
+    low?: MaybeSignal<number | undefined>;
+    manifest?: MaybeSignal<string | undefined>;
+    marginHeight?: MaybeSignal<number | undefined>;
+    marginWidth?: MaybeSignal<number | undefined>;
+    max?: MaybeSignal<string | undefined>;
+    maxLength?: MaybeSignal<number | undefined>;
+    media?: MaybeSignal<string | undefined>;
+    mediaGroup?: MaybeSignal<string | undefined>;
+    method?: MaybeSignal<string | undefined>;
+    min?: MaybeSignal<string | undefined>;
+    minLength?: MaybeSignal<number | undefined>;
+    multiple?: MaybeSignal<boolean | undefined>;
+    muted?: MaybeSignal<boolean | undefined>;
+    name?: MaybeSignal<string | undefined>;
+    nomodule?: MaybeSignal<boolean | undefined>;
+    nonce?: MaybeSignal<string | undefined>;
+    noValidate?: MaybeSignal<boolean | undefined>;
+    open?: MaybeSignal<boolean | undefined>;
+    optimum?: MaybeSignal<number | undefined>;
+    part?: MaybeSignal<string | undefined>;
+    pattern?: MaybeSignal<string | undefined>;
+    ping?: MaybeSignal<string | undefined>;
+    placeholder?: MaybeSignal<string | undefined>;
+    playsInline?: MaybeSignal<boolean | undefined>;
+    poster?: MaybeSignal<string | undefined>;
+    preload?: MaybeSignal<string | undefined>;
+    radioGroup?: MaybeSignal<string | undefined>;
+    readonly?: MaybeSignal<boolean | undefined>;
+    readOnly?: MaybeSignal<boolean | undefined>;
+    referrerpolicy?: MaybeSignal<"no-referrer" | "no-referrer-when-downgrade" | "origin" | "origin-when-cross-origin" | "same-origin" | "strict-origin" | "strict-origin-when-cross-origin" | "unsafe-url" | undefined>;
+    rel?: MaybeSignal<string | undefined>;
+    required?: MaybeSignal<boolean | undefined>;
+    reversed?: MaybeSignal<boolean | undefined>;
+    role?: MaybeSignal<string | undefined>;
+    rows?: MaybeSignal<number | undefined>;
+    rowSpan?: MaybeSignal<number | undefined>;
+    sandbox?: MaybeSignal<string | undefined>;
+    scope?: MaybeSignal<string | undefined>;
+    scoped?: MaybeSignal<boolean | undefined>;
+    scrolling?: MaybeSignal<string | undefined>;
+    seamless?: MaybeSignal<boolean | undefined>;
+    selected?: MaybeSignal<boolean | undefined>;
+    shape?: MaybeSignal<string | undefined>;
+    size?: MaybeSignal<number | undefined>;
+    sizes?: MaybeSignal<string | undefined>;
+    slot?: MaybeSignal<string | undefined>;
+    span?: MaybeSignal<number | undefined>;
+    spellcheck?: MaybeSignal<boolean | undefined>;
+    spellCheck?: MaybeSignal<boolean | undefined>;
+    src?: MaybeSignal<string | undefined>;
+    srcset?: MaybeSignal<string | undefined>;
+    srcDoc?: MaybeSignal<string | undefined>;
+    srcLang?: MaybeSignal<string | undefined>;
+    srcSet?: MaybeSignal<string | undefined>;
+    start?: MaybeSignal<number | undefined>;
+    step?: MaybeSignal<number | string | undefined>;
+    summary?: MaybeSignal<string | undefined>;
+    tabIndex?: MaybeSignal<number | undefined>;
+    target?: MaybeSignal<string | undefined>;
+    title?: MaybeSignal<string | undefined>;
+    type?: MaybeSignal<string | undefined>;
+    useMap?: MaybeSignal<string | undefined>;
+    value?: MaybeSignal<string | string[] | number | undefined>;
+    volume?: MaybeSignal<string | number | undefined>;
+    width?: MaybeSignal<number | string | undefined>;
+    wmode?: MaybeSignal<string | undefined>;
+    wrap?: MaybeSignal<string | undefined>;
+    autocapitalize?: MaybeSignal<"off" | "none" | "on" | "sentences" | "words" | "characters" | undefined>;
+    autoCapitalize?: MaybeSignal<"off" | "none" | "on" | "sentences" | "words" | "characters" | undefined>;
+    disablePictureInPicture?: MaybeSignal<boolean | undefined>;
+    results?: MaybeSignal<number | undefined>;
+    translate?: MaybeSignal<"yes" | "no" | undefined>;
+    about?: MaybeSignal<string | undefined>;
+    datatype?: MaybeSignal<string | undefined>;
+    inlist?: MaybeSignal<any | undefined>;
+    prefix?: MaybeSignal<string | undefined>;
+    property?: MaybeSignal<string | undefined>;
+    resource?: MaybeSignal<string | undefined>;
+    typeof?: MaybeSignal<string | undefined>;
+    vocab?: MaybeSignal<string | undefined>;
+    itemProp?: MaybeSignal<string | undefined>;
+    itemScope?: MaybeSignal<boolean | undefined>;
+    itemType?: MaybeSignal<string | undefined>;
+    itemID?: MaybeSignal<string | undefined>;
+    itemRef?: MaybeSignal<string | undefined>;
+    [name: string]: any;
+}
+interface SvgProps<in E> extends HtmlProps<E> {
+    accentHeight?: MaybeSignal<number | string | undefined>;
+    accumulate?: MaybeSignal<"none" | "sum" | undefined>;
+    additive?: MaybeSignal<"replace" | "sum" | undefined>;
+    alignmentBaseline?: MaybeSignal<"auto" | "baseline" | "before-edge" | "text-before-edge" | "middle" | "central" | "after-edge" | "text-after-edge" | "ideographic" | "alphabetic" | "hanging" | "mathematical" | "inherit" | undefined>;
+    allowReorder?: MaybeSignal<"no" | "yes" | undefined>;
+    alphabetic?: MaybeSignal<number | string | undefined>;
+    amplitude?: MaybeSignal<number | string | undefined>;
+    arabicForm?: MaybeSignal<"initial" | "medial" | "terminal" | "isolated" | undefined>;
+    ascent?: MaybeSignal<number | string | undefined>;
+    attributeName?: MaybeSignal<string | undefined>;
+    attributeType?: MaybeSignal<string | undefined>;
+    autoReverse?: MaybeSignal<number | string | undefined>;
+    azimuth?: MaybeSignal<number | string | undefined>;
+    baseFrequency?: MaybeSignal<number | string | undefined>;
+    baselineShift?: MaybeSignal<number | string | undefined>;
+    baseProfile?: MaybeSignal<number | string | undefined>;
+    bbox?: MaybeSignal<number | string | undefined>;
+    begin?: MaybeSignal<number | string | undefined>;
+    bias?: MaybeSignal<number | string | undefined>;
+    by?: MaybeSignal<number | string | undefined>;
+    calcMode?: MaybeSignal<number | string | undefined>;
+    capHeight?: MaybeSignal<number | string | undefined>;
+    clip?: MaybeSignal<number | string | undefined>;
+    clipPath?: MaybeSignal<string | undefined>;
+    clipPathUnits?: MaybeSignal<number | string | undefined>;
+    clipRule?: MaybeSignal<number | string | undefined>;
+    colorInterpolation?: MaybeSignal<number | string | undefined>;
+    colorInterpolationFilters?: MaybeSignal<"auto" | "sRGB" | "linearRGB" | "inherit" | undefined>;
+    colorProfile?: MaybeSignal<number | string | undefined>;
+    colorRendering?: MaybeSignal<number | string | undefined>;
+    contentScriptType?: MaybeSignal<number | string | undefined>;
+    contentStyleType?: MaybeSignal<number | string | undefined>;
+    cursor?: MaybeSignal<number | string | undefined>;
+    cx?: MaybeSignal<number | string | undefined>;
+    cy?: MaybeSignal<number | string | undefined>;
+    d?: MaybeSignal<string | undefined>;
+    decelerate?: MaybeSignal<number | string | undefined>;
+    descent?: MaybeSignal<number | string | undefined>;
+    diffuseConstant?: MaybeSignal<number | string | undefined>;
+    direction?: MaybeSignal<number | string | undefined>;
+    display?: MaybeSignal<number | string | undefined>;
+    divisor?: MaybeSignal<number | string | undefined>;
+    dominantBaseline?: MaybeSignal<number | string | undefined>;
+    dur?: MaybeSignal<number | string | undefined>;
+    dx?: MaybeSignal<number | string | undefined>;
+    dy?: MaybeSignal<number | string | undefined>;
+    edgeMode?: MaybeSignal<number | string | undefined>;
+    elevation?: MaybeSignal<number | string | undefined>;
+    enableBackground?: MaybeSignal<number | string | undefined>;
+    end?: MaybeSignal<number | string | undefined>;
+    exponent?: MaybeSignal<number | string | undefined>;
+    externalResourcesRequired?: MaybeSignal<number | string | undefined>;
+    fill?: MaybeSignal<string | undefined>;
+    fillOpacity?: MaybeSignal<number | string | undefined>;
+    fillRule?: MaybeSignal<"nonzero" | "evenodd" | "inherit" | undefined>;
+    filter?: MaybeSignal<string | undefined>;
+    filterRes?: MaybeSignal<number | string | undefined>;
+    filterUnits?: MaybeSignal<number | string | undefined>;
+    floodColor?: MaybeSignal<number | string | undefined>;
+    floodOpacity?: MaybeSignal<number | string | undefined>;
+    focusable?: MaybeSignal<number | string | undefined>;
+    fontFamily?: MaybeSignal<string | undefined>;
+    fontSize?: MaybeSignal<number | string | undefined>;
+    fontSizeAdjust?: MaybeSignal<number | string | undefined>;
+    fontStretch?: MaybeSignal<number | string | undefined>;
+    fontStyle?: MaybeSignal<number | string | undefined>;
+    fontVariant?: MaybeSignal<number | string | undefined>;
+    fontWeight?: MaybeSignal<number | string | undefined>;
+    format?: MaybeSignal<number | string | undefined>;
+    from?: MaybeSignal<number | string | undefined>;
+    fx?: MaybeSignal<number | string | undefined>;
+    fy?: MaybeSignal<number | string | undefined>;
+    g1?: MaybeSignal<number | string | undefined>;
+    g2?: MaybeSignal<number | string | undefined>;
+    glyphName?: MaybeSignal<number | string | undefined>;
+    glyphOrientationHorizontal?: MaybeSignal<number | string | undefined>;
+    glyphOrientationVertical?: MaybeSignal<number | string | undefined>;
+    glyphRef?: MaybeSignal<number | string | undefined>;
+    gradientTransform?: MaybeSignal<string | undefined>;
+    gradientUnits?: MaybeSignal<string | undefined>;
+    hanging?: MaybeSignal<number | string | undefined>;
+    horizAdvX?: MaybeSignal<number | string | undefined>;
+    horizOriginX?: MaybeSignal<number | string | undefined>;
+    ideographic?: MaybeSignal<number | string | undefined>;
+    imageRendering?: MaybeSignal<number | string | undefined>;
+    in2?: MaybeSignal<number | string | undefined>;
+    in?: MaybeSignal<string | undefined>;
+    intercept?: MaybeSignal<number | string | undefined>;
+    k1?: MaybeSignal<number | string | undefined>;
+    k2?: MaybeSignal<number | string | undefined>;
+    k3?: MaybeSignal<number | string | undefined>;
+    k4?: MaybeSignal<number | string | undefined>;
+    k?: MaybeSignal<number | string | undefined>;
+    kernelMatrix?: MaybeSignal<number | string | undefined>;
+    kernelUnitLength?: MaybeSignal<number | string | undefined>;
+    kerning?: MaybeSignal<number | string | undefined>;
+    keyPoints?: MaybeSignal<number | string | undefined>;
+    keySplines?: MaybeSignal<number | string | undefined>;
+    keyTimes?: MaybeSignal<number | string | undefined>;
+    lengthAdjust?: MaybeSignal<number | string | undefined>;
+    letterSpacing?: MaybeSignal<number | string | undefined>;
+    lightingColor?: MaybeSignal<number | string | undefined>;
+    limitingConeAngle?: MaybeSignal<number | string | undefined>;
+    local?: MaybeSignal<number | string | undefined>;
+    markerEnd?: MaybeSignal<string | undefined>;
+    markerHeight?: MaybeSignal<number | string | undefined>;
+    markerMid?: MaybeSignal<string | undefined>;
+    markerStart?: MaybeSignal<string | undefined>;
+    markerUnits?: MaybeSignal<number | string | undefined>;
+    markerWidth?: MaybeSignal<number | string | undefined>;
+    mask?: MaybeSignal<string | undefined>;
+    maskContentUnits?: MaybeSignal<number | string | undefined>;
+    maskUnits?: MaybeSignal<number | string | undefined>;
+    mathematical?: MaybeSignal<number | string | undefined>;
+    mode?: MaybeSignal<number | string | undefined>;
+    numOctaves?: MaybeSignal<number | string | undefined>;
+    offset?: MaybeSignal<number | string | undefined>;
+    opacity?: MaybeSignal<number | string | undefined>;
+    operator?: MaybeSignal<number | string | undefined>;
+    order?: MaybeSignal<number | string | undefined>;
+    orient?: MaybeSignal<number | string | undefined>;
+    orientation?: MaybeSignal<number | string | undefined>;
+    origin?: MaybeSignal<number | string | undefined>;
+    overflow?: MaybeSignal<number | string | undefined>;
+    overlinePosition?: MaybeSignal<number | string | undefined>;
+    overlineThickness?: MaybeSignal<number | string | undefined>;
+    paintOrder?: MaybeSignal<number | string | undefined>;
+    panose1?: MaybeSignal<number | string | undefined>;
+    pathLength?: MaybeSignal<number | string | undefined>;
+    patternContentUnits?: MaybeSignal<string | undefined>;
+    patternTransform?: MaybeSignal<number | string | undefined>;
+    patternUnits?: MaybeSignal<string | undefined>;
+    pointerEvents?: MaybeSignal<number | string | undefined>;
+    points?: MaybeSignal<string | undefined>;
+    pointsAtX?: MaybeSignal<number | string | undefined>;
+    pointsAtY?: MaybeSignal<number | string | undefined>;
+    pointsAtZ?: MaybeSignal<number | string | undefined>;
+    preserveAlpha?: MaybeSignal<number | string | undefined>;
+    preserveAspectRatio?: MaybeSignal<string | undefined>;
+    primitiveUnits?: MaybeSignal<number | string | undefined>;
+    r?: MaybeSignal<number | string | undefined>;
+    radius?: MaybeSignal<number | string | undefined>;
+    refX?: MaybeSignal<number | string | undefined>;
+    refY?: MaybeSignal<number | string | undefined>;
+    renderingIntent?: MaybeSignal<number | string | undefined>;
+    repeatCount?: MaybeSignal<number | string | undefined>;
+    repeatDur?: MaybeSignal<number | string | undefined>;
+    requiredExtensions?: MaybeSignal<number | string | undefined>;
+    requiredFeatures?: MaybeSignal<number | string | undefined>;
+    restart?: MaybeSignal<number | string | undefined>;
+    result?: MaybeSignal<string | undefined>;
+    rotate?: MaybeSignal<number | string | undefined>;
+    rx?: MaybeSignal<number | string | undefined>;
+    ry?: MaybeSignal<number | string | undefined>;
+    scale?: MaybeSignal<number | string | undefined>;
+    seed?: MaybeSignal<number | string | undefined>;
+    shapeRendering?: MaybeSignal<number | string | undefined>;
+    slope?: MaybeSignal<number | string | undefined>;
+    spacing?: MaybeSignal<number | string | undefined>;
+    specularConstant?: MaybeSignal<number | string | undefined>;
+    specularExponent?: MaybeSignal<number | string | undefined>;
+    speed?: MaybeSignal<number | string | undefined>;
+    spreadMethod?: MaybeSignal<string | undefined>;
+    startOffset?: MaybeSignal<number | string | undefined>;
+    stdDeviation?: MaybeSignal<number | string | undefined>;
+    stemh?: MaybeSignal<number | string | undefined>;
+    stemv?: MaybeSignal<number | string | undefined>;
+    stitchTiles?: MaybeSignal<number | string | undefined>;
+    stopColor?: MaybeSignal<string | undefined>;
+    stopOpacity?: MaybeSignal<number | string | undefined>;
+    strikethroughPosition?: MaybeSignal<number | string | undefined>;
+    strikethroughThickness?: MaybeSignal<number | string | undefined>;
+    string?: MaybeSignal<number | string | undefined>;
+    stroke?: MaybeSignal<string | undefined>;
+    strokeDasharray?: MaybeSignal<number | string | undefined>;
+    strokeDashoffset?: MaybeSignal<number | string | undefined>;
+    strokeLinecap?: MaybeSignal<"butt" | "round" | "square" | "inherit" | undefined>;
+    strokeLinejoin?: MaybeSignal<"miter" | "round" | "bevel" | "inherit" | undefined>;
+    strokeMiterlimit?: MaybeSignal<number | string | undefined>;
+    strokeOpacity?: MaybeSignal<number | string | undefined>;
+    strokeWidth?: MaybeSignal<number | string | undefined>;
+    surfaceScale?: MaybeSignal<number | string | undefined>;
+    systemLanguage?: MaybeSignal<number | string | undefined>;
+    tableValues?: MaybeSignal<number | string | undefined>;
+    targetX?: MaybeSignal<number | string | undefined>;
+    targetY?: MaybeSignal<number | string | undefined>;
+    textAnchor?: MaybeSignal<string | undefined>;
+    textDecoration?: MaybeSignal<number | string | undefined>;
+    textLength?: MaybeSignal<number | string | undefined>;
+    textRendering?: MaybeSignal<number | string | undefined>;
+    to?: MaybeSignal<number | string | undefined>;
+    transform?: MaybeSignal<string | undefined>;
+    u1?: MaybeSignal<number | string | undefined>;
+    u2?: MaybeSignal<number | string | undefined>;
+    underlinePosition?: MaybeSignal<number | string | undefined>;
+    underlineThickness?: MaybeSignal<number | string | undefined>;
+    unicode?: MaybeSignal<number | string | undefined>;
+    unicodeBidi?: MaybeSignal<number | string | undefined>;
+    unicodeRange?: MaybeSignal<number | string | undefined>;
+    unitsPerEm?: MaybeSignal<number | string | undefined>;
+    vAlphabetic?: MaybeSignal<number | string | undefined>;
+    values?: MaybeSignal<string | undefined>;
+    vectorEffect?: MaybeSignal<number | string | undefined>;
+    version?: MaybeSignal<string | undefined>;
+    vertAdvY?: MaybeSignal<number | string | undefined>;
+    vertOriginX?: MaybeSignal<number | string | undefined>;
+    vertOriginY?: MaybeSignal<number | string | undefined>;
+    vHanging?: MaybeSignal<number | string | undefined>;
+    vIdeographic?: MaybeSignal<number | string | undefined>;
+    viewBox?: MaybeSignal<string | undefined>;
+    viewTarget?: MaybeSignal<number | string | undefined>;
+    visibility?: MaybeSignal<number | string | undefined>;
+    vMathematical?: MaybeSignal<number | string | undefined>;
+    widths?: MaybeSignal<number | string | undefined>;
+    wordSpacing?: MaybeSignal<number | string | undefined>;
+    writingMode?: MaybeSignal<number | string | undefined>;
+    x1?: MaybeSignal<number | string | undefined>;
+    x2?: MaybeSignal<number | string | undefined>;
+    x?: MaybeSignal<number | string | undefined>;
+    xChannelSelector?: MaybeSignal<string | undefined>;
+    xHeight?: MaybeSignal<number | string | undefined>;
+    xlinkActuate?: MaybeSignal<string | undefined>;
+    xlinkArcrole?: MaybeSignal<string | undefined>;
+    xlinkHref?: MaybeSignal<string | undefined>;
+    xlinkRole?: MaybeSignal<string | undefined>;
+    xlinkShow?: MaybeSignal<string | undefined>;
+    xlinkTitle?: MaybeSignal<string | undefined>;
+    xlinkType?: MaybeSignal<string | undefined>;
+    xmlBase?: MaybeSignal<string | undefined>;
+    xmlLang?: MaybeSignal<string | undefined>;
+    xmlns?: MaybeSignal<string | undefined>;
+    xmlnsXlink?: MaybeSignal<string | undefined>;
+    xmlSpace?: MaybeSignal<string | undefined>;
+    y1?: MaybeSignal<number | string | undefined>;
+    y2?: MaybeSignal<number | string | undefined>;
+    y?: MaybeSignal<number | string | undefined>;
+    yChannelSelector?: MaybeSignal<string | undefined>;
+    z?: MaybeSignal<number | string | undefined>;
+    zoomAndPan?: MaybeSignal<string | undefined>;
+}
+
+type RemoveOn<S extends string> = S extends `on${infer R}` ? Uncapitalize<R> : never;
+type CamelCaseToKebabCase<S extends string> = S extends `${infer F}${infer R}` ? F extends Lowercase<F> ? `${F}${CamelCaseToKebabCase<R>}` : `-${Lowercase<F>}${CamelCaseToKebabCase<R>}` : Lowercase<S>;
+type JsxPropNameToEventName<S extends string> = CamelCaseToKebabCase<RemoveOn<S>>;
+
+declare const contextSym: unique symbol;
+/**
+ * A value that can be passed through the component tree without having to be
+ * explicitly passed as a prop.
+ */
+interface Context<in out T> {
+    readonly [contextSym]: string;
+    /** @ignore */
+    readonly _init: T;
+    /** @ignore */
+    readonly _opts?: SetSignalOptions;
+}
+/**
+ * Creates a new context with the given value.
+ */
+declare const createContext: (<T>(value: T, opts?: SetSignalOptions) => Context<T>) & (<T>(value?: T, opts?: SetSignalOptions) => Context<T | undefined>);
+declare const useContext: <T>(context: Context<T>) => Signal<T>;
+
+/**
+ * Represents a render result of a component.
+ */
+interface Template {
+    /**
+     * Build the DOM elements represented by this template.
+     */
+    build(): Node[];
+}
+
+interface Tagged<in out T> {
+    _tag: T;
+}
+type OmitNever<T> = Omit<T, {
+    [K in keyof T]: T[K] extends never ? K : never;
+}[keyof T]>;
+type PartialRequire<T, K extends keyof T> = Omit<T, K> & Required<Pick<T, K>>;
+/** @ignore */
+interface PropMeta<T> extends PropOptions<T>, Tagged<"p"> {
+    _type?: [T];
+    _defaultOrContext: T;
+}
+interface AttributeOptions<T> {
+    /**
+     * The name of the attribute to observe.
+     *
+     * Defaults to the kebab-case version of the prop.
+     */
+    name?: string;
+    /**
+     * A function to transform the attribute value to the prop value.
+     */
+    transform: (value: string) => T;
+    /**
+     * Set to `true` to not observe the attribute for changes.
+     *
+     * @default false
+     */
+    static?: boolean;
+}
+type PartialPartial<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+interface PropOptions<T> {
+    attribute?: ((value: string) => T) | (string extends T ? PartialPartial<AttributeOptions<T>, "transform"> : AttributeOptions<T>);
+}
+type Props<M> = OmitNever<{
+    readonly [K in keyof M]: M[K] extends PropMeta<infer T> ? Signal<T> : never;
+}>;
+type EventConstructor<T = any, E = Event> = new (name: string, arg: T) => E;
+/** @ignore */
+interface EventMeta<out E extends EventConstructor> extends Tagged<"e"> {
+    _event: E;
+}
+type Events<M> = OmitNever<Omit<{
+    readonly [K in keyof M]: K extends `on${string}` ? M[K] extends EventMeta<infer E> ? E : never : never;
+}, `on${Lowercase<keyof HTMLElementEventMap>}`>>;
+type GeneralJsxProps<T> = Partial<OmitNever<{
+    [K in keyof T]: K extends typeof jsxPropsSym | keyof DomProps<any> | `on${string}` | `${Uppercase<infer _>}${string}` | "accessKeyLabel" | "offsetHeight" | "offsetLeft" | "offsetParent" | "offsetTop" | "offsetWidth" | "attributes" | "classList" | "clientHeight" | "clientLeft" | "clientTop" | "clientWidth" | "localName" | "namespaceURI" | "ownerDocument" | "part" | "prefix" | "scrollHeight" | "scrollWidth" | "shadowRoot" | "tagName" | "baseURI" | "childNodes" | "firstChild" | "isConnected" | "lastChild" | "nextSibling" | "nodeName" | "nodeType" | "parentElement" | "parentNode" | "previousSibling" | "nextElementSibling" | "previousElementSibling" | "childElementCount" | "firstElementChild" | "lastElementChild" | "assignedSlot" | "attributeStyleMap" | "isContentEditable" | "dataset" ? never : T[K] extends Function ? never : MaybeSignal<T[K]>;
+}>> & DomProps<any> & DomEventProps<never> & Record<string, any>;
+type JsxProps<T extends HTMLElement> = typeof jsxPropsSym extends keyof T ? NonNullable<T[typeof jsxPropsSym]> : any;
+type ComponentJsxProps<M> = Partial<OmitNever<{
+    [K in keyof Props<M>]: Props<M>[K] extends Signal<infer T> ? MaybeSignal<T> : never;
+}> & {
+    [K in keyof Events<M>]: (evt: InstanceType<Events<M>[K]>) => void;
+}> & GeneralJsxProps<HTMLElement>;
+type EventEmitters<M> = OmitNever<Omit<{
+    [K in keyof Events<M>]: Events<M>[K] extends EventConstructor<infer E> ? undefined extends E ? (arg?: E) => boolean : (arg: E) => boolean : never;
+}, `on${Lowercase<keyof HTMLElementEventMap>}`>>;
+/**
+ * Defines a property in your component metadata that can be set from outside
+ * of the component.
+ *
+ * Make sure to avoid conflicts with native `HTMLElement` properties.
+ *
+ * You can get properties by accessing the {@link Signal} in `this.props`.
+ * It's also possible to set the properties directly on the component instance.
+ *
+ * It's also possible to define an attribute for the property by setting the
+ * `attribute` option. By default, the attribute name is the kebab-case version
+ * of the property name. The attribute will be observed and the signal updated
+ * on changes. You can also provide a custom name and a transform function to
+ * convert the attribute value to the property value.
+ *
+ * @example
+ * ```tsx
+ * class App extends Component("x-app", {
+ *   greetingMessage: prop<string>("Hello, world!", {
+ *     attribute: {
+ *       name: "greeting",
+ *     }
+ *   }),
+ * }) {
+ *   render() {
+ *     return <h1>{this.props.greetingMessage}</h1>;
+ *   }
+ * }
+ *
+ * defineComponents(App);
+ *
+ * const app = new App();
+ * app.greetingMessage = "Hello, universe!";
+ * ```
+ */
+declare const prop: (<T>(context: Context<T>, opts?: PropOptions<T>) => PropMeta<T | undefined>) & (<T>(defaultValue: T, opts?: PropOptions<T>) => PropMeta<T>) & (<T>(defaultValue?: T, opts?: PropOptions<T | undefined>) => PropMeta<T | undefined>);
+type _CustomEventContructor<T> = undefined extends T ? typeof CustomEvent<T> : EventConstructor<PartialRequire<CustomEventInit<T>, "detail">, CustomEvent<T>>;
+/**
+ * Defines an event in your component metadata that can be dispatched by
+ * the component.
+ *
+ * Make sure your event name starts with `on` and to avoid conflicts with
+ * native `HTMLElement` events. The event name will be converted to kebab-case.
+ *
+ * You can dispatch events either using `HTMLElement.dispatchEvent` or by
+ * calling the event emitter function in `this.events` inside the `render`
+ * function of a component.
+ *
+ * @example
+ * ```tsx
+ * class App extends Component("x-app", {
+ *   onSomethingHappen: event<string>(),
+ *   // Event name will be `something-happen`
+ * }) {
+ *   render() {
+ *     // …
+ *     this.events.onSomethingHappen({ detail: "Something happened! "});
+ *   }
+ * }
+ *
+ * const app = new App();
+ * app.addEventListener("something-happen", (evt) => {
+ *   // `evt` is `CustomEvent<string>`
+ *   console.log(evt.detail);
+ * });
+ * ```
+ *
+ * You can also provide a custom event constructor:
+ *
+ * @example
+ * ```tsx
+ * class App extends Component("x-app", {
+ *   onSomethingClick: event(() => MouseEvent),
+ * }) {
+ *   render() {
+ *     return (
+ *       <button onclick={evt => this.events.onSomethingClick(evt)}>
+ *         Click me!
+ *       </button>
+ *     );
+ *   }
+ * }
+ * ```
+ */
+declare const event: (() => EventMeta<_CustomEventContructor<undefined>>) & (<T>() => EventMeta<_CustomEventContructor<T>>) & (<E extends EventConstructor>(eventConstructor: E) => EventMeta<E>);
+type Metadata = {
+    [K in keyof ComponentInner<any> | "props" | "events"]?: never;
+} & {
+    [K in keyof DomProps<any>]?: never;
+} & {
+    [K in keyof HTMLElement]?: never;
+} & {
+    [name: string]: PropMeta<any> | EventMeta<any>;
+};
+declare const componentSym: unique symbol;
+declare const jsxPropsSym: unique symbol;
+declare abstract class ComponentInner<M extends Metadata> {
+    protected props: Props<M>;
+    protected events: EventEmitters<M>;
+    readonly [jsxPropsSym]?: ComponentJsxProps<M>;
+    readonly [componentSym]: {
+        _scope?: ReturnType<typeof useScope>;
+        _destroy?: (() => void) | void;
+    };
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name: string, oldValue: string | null, value: string | null): void;
+    addEventListener<K extends keyof Events<M> & string>(type: JsxPropNameToEventName<K>, listener: (event: InstanceType<Events<M>[K]>) => void, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof Events<M> & string>(type: JsxPropNameToEventName<K>, listener: (event: InstanceType<Events<M>[K]>) => void, options?: boolean | EventListenerOptions): void;
+    abstract render(): Template;
+}
+interface ComponentConstructor<M extends Metadata = {}> {
+    /** @ignore */
+    readonly [componentSym]: {
+        readonly _tagName: string;
+    };
+    readonly observedAttributes: readonly string[];
+    new (): Component<M>;
+}
+interface ComponentOptions {
+    /**
+     * Shadow DOM options. Set to `false` to disable shadow DOM.
+     *
+     * @default { mode: "open" }
+     */
+    shadow?: ShadowRootInit | false;
+}
+/**
+ * Creates an effect which will rerun when any accessed signal changes.
+ *
+ * If used inside of a component and the component is not yet mounted, the
+ * effect will run only after the component is mounted. Otherwise, the effect
+ * will run immediately.
+ *
+ * @param fn The function to run; it may return a cleanup function.
+ */
+declare const useMountEffect: (fn: () => Cleanup, deps?: Signal<unknown>[]) => void;
+type Component<M extends Metadata = {}> = {
+    -readonly [K in keyof Props<M>]: Props<M>[K] extends Signal<infer T> ? T : never;
+} & ComponentInner<M> & HTMLElement;
+/**
+ * Creates a new web component class.
+ *
+ * Specify props and events using the `metadata` parameter.
+ *
+ * @example
+ * ```tsx
+ * class MyComponent extends Component("my-component", {
+ *   myProp: prop<string>("Hello, world!"),
+ *   onMyEvent: event(),
+ * }) {
+ *   render() {
+ *     return (
+ *       <>
+ *         <h1>{this.props.myProp}</h1>
+ *         <button onclick={() => this.events.onMyEvent()}>Click me</button>
+ *       </>
+ *     );
+ *   },
+ * }
+ *
+ * customElements.define("my-component", MyComponent);
+ * ```
+ */
+declare const Component: ((tagName: string) => ComponentConstructor<{}>) & (<const M extends Metadata>(tagName: string, metadata: M, opts?: ComponentOptions) => ComponentConstructor<M>);
+/**
+ * Determines whether the given value is a component created by
+ * extending {@link ComponentConstructor}.
+ */
+declare const isComponent: (value: any) => value is ComponentConstructor<{}> | Component<{}>;
+/**
+ * Represents a functional component.
+ *
+ * @example
+ * ```tsx
+ * const MyComponent: FunctionalComponent<{
+ *   name: MaybeSignal<string>;
+ * }> = ({ name }) => {
+ *   return <h1>Hello, {name}!</h1>;
+ * };
+ * ```
+ */
+interface FunctionalComponent<in P extends object = {}> {
+    (props: P): Template;
+}
+/**
+ * Defines a set of components with the given prefix.
+ */
+declare const defineComponents: ((...components: ComponentConstructor[]) => void) & ((prefix: string, ...components: ComponentConstructor[]) => void);
+
+type Children = Template | MaybeSignal<string | number | null | undefined> | Children[];
+/**
+ * Fragment is a component that can be used to wrap multiple children without
+ * introducing an extra DOM element.
+ *
+ * @example
+ * ```tsx
+ * render() {
+ *   return (
+ *     <>
+ *       <h1>Hello World</h1>
+ *       <p>This is a paragraph.</p>
+ *     </>
+ *   );
+ * }
+ * ```
+ */
+declare const Fragment: FunctionalComponent<{
+    children?: Children;
+}>;
+
+/**
+ * Creates a template based on the given component type.
+ *
+ * @example
+ * ```tsx
+ * render() {
+ *   return createElement("div", { id: "app" }, [
+ *     createElement("h1", {}, "Hello, World!"),
+ *   ]);
+ * }
+ * ```
+ */
+declare const createElement: (<K extends keyof DomIntrinsicElements & string>(type: K, props?: DomIntrinsicElements[K], children?: Children) => Template) & (<T extends HTMLElement>(...args: [
+    type: new () => T,
+    ...({} extends JsxProps<T> ? [props?: JsxProps<T>] : [props: JsxProps<T>]),
+    children?: DomProps<T>["children"]
+]) => Template) & (<P extends object>(...args: [
+    type: FunctionalComponent<P>,
+    ...({} extends P ? [props?: P] : [props: P]),
+    ...(P extends {
+        children?: unknown;
+    } ? undefined extends P["children"] ? [children?: P["children"]] : [children: P["children"]] : [])
+]) => Template);
+/**
+ * Shorthand for {@link createElement} with convenience methods for intrinsic
+ * elements.
+ *
+ * @example
+ * ```tsx
+ * render() {
+ *   return h.div({ id: "app" }, [
+ *     h.h1({}, "Hello, World!"),
+ *   ]);
+ * }
+ * ```
+ */
+declare const h: typeof createElement & {
+    [K in keyof DomIntrinsicElements]: (props?: DomIntrinsicElements[K], children?: Children) => Template;
+};
+
+/**
+ * `For` is a component that can be used to render a list of items.
+ */
+declare const For: <T>(props: {
+    each?: MaybeSignal<readonly T[]> | undefined;
+    key?: ((item: T, index: number) => string | number) | undefined;
+    children?: ((item: Signal<T>, index: Signal<number>, arr: SignalLike<readonly T[]>) => Template) | undefined;
+}) => Template;
+
+/**
+ * `If` is a component that can be used to render conditionally.
+ */
+declare const If: FunctionalComponent<{
+    condition?: MaybeSignal<boolean>;
+    children?: Children;
+}>;
+/**
+ * `ElseIf` serves as an `else if` block for {@link If}. It can also be chained
+ * multiple times.
+ */
+declare const ElseIf: FunctionalComponent<{
+    condition?: MaybeSignal<boolean>;
+    children?: Children;
+}>;
+/**
+ * `Else` indicates the `else` block for {@link If} and {@link ElseIf}.
+ */
+declare const Else: FunctionalComponent<{
+    children?: Children;
+}>;
+
+declare const Portal: FunctionalComponent<{
+    mount: Node;
+    children?: Children;
+}>;
+
+declare const Style: FunctionalComponent<{
+    light?: boolean;
+    children?: MaybeSignal<string>;
+}>;
+declare const css: (strings: TemplateStringsArray, ...values: MaybeSignal<string | number>[]) => MaybeSignal<string>;
+
+/** @ignore */
+declare const jsx: (type: any, props?: (object & {
+    key?: unknown;
+}) | undefined, key?: unknown) => Template;
+/** @ignore */
+declare namespace JSX {
+    type Element = Template;
+    type ElementClass = Omit<HTMLElement, typeof jsxPropsSym>;
+    interface ElementAttributesProperty {
+        [jsxPropsSym]: {};
+    }
+    interface ElementChildrenAttribute {
+        children: {};
+    }
+    type IntrinsicElements = DomIntrinsicElements;
+    interface IntrinsicClassAttributes<T> extends DomProps<T>, DomEventProps<T> {
+    }
+}
+
+export { type AttributeOptions, type Children, type Cleanup, Component, type ComponentConstructor, type ComponentOptions, type Context, type DangerousHtml, Else, ElseIf, type EventConstructor, For, Fragment, type FunctionalComponent, If, JSX, MaybeSignal, type Metadata, Portal, type PropOptions, type RefSignal, type RefSignalSetter, type SetSignalOptions, type Signal, type SignalLike, type SignalSetter, Style, type Styles, type SubscopeOptions, type Template, createContext, createElement, css, defineComponents, event, h, isComponent, jsx, jsx as jsxDEV, jsx as jsxs, prop, useBatch, useContext, useMountEffect as useEffect, useMemo, useRef, useSignal };