defuss 2.1.11 → 3.2.0

package/dist/index-Bu2vwaJ2.d.ts

@@ -0,0 +1,1352 @@
+import * as CSS from 'csstype';
+
+type MemoryProviderOptions = {};
+interface MemoryStorage<T> extends PersistenceProviderImpl<T> {
+    backendApi: Omit<Omit<Storage, "key">, "length">;
+}
+interface WebStorage<T> extends PersistenceProviderImpl<T> {
+    backendApi: Storage;
+}
+
+type MiddlewareFn<T> = (key: string, value: T) => T;
+/** a simple key/value persistence interface */
+interface PersistenceProviderImpl<T> {
+    get: (key: string, defaultValue: T, middlewareFn?: MiddlewareFn<T>) => T;
+    set: (key: string, value: T, middlewareFn?: MiddlewareFn<T>) => void;
+    remove: (key: string) => void;
+    removeAll: () => void;
+    backendApi: any;
+}
+type PersistenceProviderType = "session" | "local" | "memory";
+type PersistenceProviderOptions = MemoryProviderOptions;
+
+type TransitionType = "fade" | "slide-left" | "slide-right" | "shake" | "none";
+interface TransitionStyles {
+    enter: Record<string, string>;
+    enterActive: Record<string, string>;
+    exit: Record<string, string>;
+    exitActive: Record<string, string>;
+}
+type TransitionsEasing = "linear" | "ease" | "ease-in" | "ease-out" | "ease-in-out" | "step-start" | "step-end";
+interface TransitionConfig {
+    type?: TransitionType;
+    styles?: TransitionStyles;
+    duration?: number;
+    easing?: TransitionsEasing | string;
+    delay?: number;
+    target?: "parent" | "self";
+}
+declare const getTransitionStyles: (type: TransitionType, duration: number, easing?: string) => TransitionStyles;
+declare const applyStyles: (el: HTMLElement, styles: Record<string, string | number>) => void;
+declare const DEFAULT_TRANSITION_CONFIG: TransitionConfig;
+declare const performTransition: (element: HTMLElement, updateCallback: () => Promise<void>, config?: TransitionConfig) => Promise<void>;
+
+type FormFieldValue = string | boolean;
+interface FormKeyValues {
+    [keyOrPath: string]: FormFieldValue | FormFieldValue[];
+}
+type AnyEventHandler = (ev: Event) => any;
+type TargetOf<NT> = Extract<NT, EventTarget>;
+type UnionToIntersection<U> = (U extends any ? (x: U) => void : never) extends (x: infer I) => void ? I : never;
+type EventMapFor<T> = T extends Window ? WindowEventMap : T extends Document ? DocumentEventMap : T extends SVGElement ? SVGElementEventMap : T extends HTMLElement ? HTMLElementEventMap : T extends Element ? ElementEventMap : Record<string, Event>;
+type EventMapForAny<T> = UnionToIntersection<EventMapFor<T>>;
+interface Dimensions {
+    width: number;
+    height: number;
+    outerWidth?: number;
+    outerHeight?: number;
+}
+interface Position {
+    top: number;
+    left: number;
+}
+type DOMPropValue = string | number | boolean | null;
+declare global {
+    interface HTMLElement {
+        _dequeryEvents?: Map<string, Set<EventListener>>;
+    }
+}
+interface DequeryOptions<NT = DequerySyncMethodReturnType> {
+    timeout?: number;
+    autoStart?: boolean;
+    autoStartDelay?: number;
+    resultStack?: NT[];
+    globals?: Partial<Globals>;
+}
+type ElementCreationOptions = JSX.HTMLAttributesLowerCase & JSX.HTMLAttributesLowerCase & {
+    html?: string;
+    text?: string;
+};
+type DequerySyncMethodReturnType = NodeType;
+
+declare class Call<R = unknown> {
+    name: string;
+    fn: (...args: any[]) => Promise<R>;
+    args: any[];
+    constructor(name: string, fn: (...args: any[]) => Promise<R>, ...args: any[]);
+}
+declare function addNonChainedReturnCallNames(callNames: string[]): void;
+declare function getNonChainedReturnCallNames(): string[];
+declare function isNonChainedReturnCall(callName: string): boolean;
+declare const emptyImpl: <T>(nodes: Array<T>) => T[];
+declare class CallChainImpl<NT = DequerySyncMethodReturnType, ET extends Dequery<NT> = Dequery<NT>> {
+    [index: number]: NT;
+    isResolved: boolean;
+    options: DequeryOptions<NT>;
+    elementCreationOptions: ElementCreationOptions;
+    callStack: Call<any>[];
+    resultStack: NT[][];
+    stackPointer: number;
+    lastResolvedStackPointer: number;
+    stoppedWithError: Error | null;
+    lastResult: unknown;
+    length: number;
+    chainStartTime: number;
+    chainAsyncStartTime: number;
+    chainAsyncFinishTime: number;
+    document: Document;
+    window: Window;
+    performance: Performance;
+    Parser: typeof DOMParser;
+    constructor(options?: DequeryOptions<NT>);
+    get globals(): Globals;
+    get nodes(): NodeType[];
+    [Symbol.iterator](): IterableIterator<NT>;
+    getFirstElement(): PromiseLike<NT>;
+    debug(cb: (chain: CallChainImpl<NT, ET>) => void): ET;
+    ref<T extends NodeType, ST = any>(ref: Ref<T, ST>): any;
+    query(selector: string): CallChainImpl<NT, ET> | CallChainImplThenable<NT, ET>;
+    next(): Dequery<NT>;
+    prev(): Dequery<NT>;
+    find(selector: string): CallChainImplThenable<NT, ET> | CallChainImpl<NT, ET>;
+    parent(): Dequery<NT>;
+    children(): Dequery<NT>;
+    closest(selector: string): Dequery<NT>;
+    first(): CallChainImpl<NT, ET> | CallChainImplThenable<NT, ET>;
+    last(): CallChainImpl<NT, ET> | CallChainImplThenable<NT, ET>;
+    attr(name: string, value: string): PromiseLike<ET>;
+    attr(name: string): PromiseLike<string | null>;
+    prop<K extends keyof AllHTMLElements>(name: K, value: DOMPropValue): PromiseLike<ET>;
+    prop<K extends keyof AllHTMLElements>(name: K): PromiseLike<string>;
+    private static resultCache;
+    css(prop: CSSProperties): PromiseLike<ET>;
+    css(prop: string, value: string): PromiseLike<ET>;
+    css(prop: string): PromiseLike<string>;
+    addClass(name: string | Array<string>): ET;
+    removeClass(name: string | Array<string>): ET;
+    hasClass(name: string): PromiseLike<boolean>;
+    toggleClass(name: string): ET;
+    animateClass(name: string, duration: number): ET;
+    empty(): ET;
+    html(): PromiseLike<string>;
+    html(html: string): PromiseLike<ET>;
+    jsx(vdom: RenderInput): ET;
+    /**
+     * Alias for .jsx() - renders new JSX into the selected element(s).
+     * Explicitly named to make clear that JSX is being rendered.
+     */
+    render(vdom: RenderInput): ET;
+    text(text?: string): PromiseLike<string>;
+    remove(): ET;
+    replaceWith(content: string | RenderInput | NodeType | Ref<NodeType, any> | CallChainImpl<NT, ET> | CallChainImplThenable<NT, ET>): ET;
+    append<T = NT>(content: string | RenderInput | NodeType | Ref<NodeType, any> | CallChainImpl<T> | CallChainImplThenable<T>): ET;
+    appendTo<T = NT>(target: string | NodeType | Ref<any, NodeType> | CallChainImpl<T> | CallChainImplThenable<T>): ET;
+    /**
+     * @deprecated Use .jsx() or .render() for rendering JSX content. This method will be removed in v4.
+     * Note: .update() with props object for component re-rendering is still supported.
+     */
+    update(input?: string | RenderInput | Ref<NodeType, any> | NodeType | CallChainImpl<NT> | CallChainImplThenable<NT> | Record<string, unknown>, // pass a props object for implicit update
+    transitionConfig?: TransitionConfig): ET;
+    on<K extends keyof EventMapForAny<TargetOf<NT>>>(event: K, handler: (ev: EventMapForAny<TargetOf<NT>>[K]) => any, options?: boolean | AddEventListenerOptions): ET;
+    on(event: string, handler: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): ET;
+    off<K extends keyof EventMapFor<TargetOf<NT>>>(event: K, handler?: (ev: EventMapFor<TargetOf<NT>>[K]) => any, options?: boolean | AddEventListenerOptions): ET;
+    off(event: string, handler?: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): ET;
+    clearEvents(): ET;
+    trigger(eventType: string): ET;
+    position(): PromiseLike<Position>;
+    offset(): PromiseLike<Position>;
+    data(name: string, value?: string): PromiseLike<string | undefined>;
+    val(val?: string | boolean): PromiseLike<string | boolean>;
+    serialize(format?: "querystring" | "json"): PromiseLike<string>;
+    form<T = FormKeyValues>(formData?: Record<string, string | boolean>): PromiseLike<T>;
+    dimension(includeMarginOrPadding?: boolean, includePaddingIfMarginTrue?: boolean): PromiseLike<Dimensions>;
+    isVisible(): PromiseLike<boolean>;
+    isHidden(): PromiseLike<boolean>;
+    scrollTo(xOrOptions: number | ScrollToOptions, y?: number): ET;
+    scrollBy(xOrOptions: number | ScrollToOptions, y?: number): ET;
+    scrollIntoView(options?: boolean | ScrollIntoViewOptions): ET;
+    map<T>(cb: (el: NT, idx: number) => T): PromiseLike<T[]>;
+    toArray(): PromiseLike<NT[]>;
+    filter(selector: string): ET;
+    /** memory cleanup (chain becomes useless after calling this method) */
+    dispose(): PromiseLike<void>;
+    ready(callback?: () => void): ET;
+}
+declare class CallChainImplThenable<NT = DequerySyncMethodReturnType, ET extends Dequery<NT> = Dequery<NT>> extends CallChainImpl<NT, ET> {
+    constructor(options?: DequeryOptions<NT>, isResolved?: boolean);
+    then(onfulfilled?: (value: CallChainImpl<NT, ET>) => CallChainImpl<NT, ET>, onrejected?: (reason: any) => any | PromiseLike<any>): Promise<any>;
+    catch<TResult = never>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>): Promise<any | TResult>;
+    finally(onfinally?: () => void): Promise<any>;
+}
+declare function scrollHelper<T = NodeType>(methodName: "scrollTo" | "scrollBy", elements: T[], xOrOptions: number | ScrollToOptions, y?: number): T[];
+declare function getAllFormValues(chain: CallChainImpl<any, any>): FormKeyValues;
+declare function delayedAutoStart<NT = DequerySyncMethodReturnType, ET extends Dequery<NT> = Dequery<NT>>(chain: CallChainImplThenable<NT, ET> | CallChainImpl<NT, ET>): CallChainImplThenable<NT, ET> | CallChainImpl<NT, ET>;
+interface Dequery<NT> extends CallChainImplThenable<NT>, CallChainImpl<NT> {
+}
+declare function dequery<T extends EventTarget>(selectorRefOrEl: T, options?: DequeryOptions<T> & ElementCreationOptions): Dequery<T>;
+declare function dequery<NT = DequerySyncMethodReturnType, ET extends Dequery<NT> = Dequery<NT>>(selectorRefOrEl: string | NodeType | Ref<NodeType, any> | RenderInput | Function, options?: DequeryOptions<NT> & ElementCreationOptions): ET;
+declare function dequery<T extends NodeType, ST = any>(selectorRefOrEl: Ref<T, ST>, options?: DequeryOptions<T> & ElementCreationOptions): Dequery<T>;
+declare namespace dequery {
+    var extend: <TExtendedClass extends new (...args: any[]) => any>(ExtensionClass: TExtendedClass, nonChainedReturnCalls?: string[]) => <NT = DequerySyncMethodReturnType>(selectorRefOrEl: string | NodeType | Ref<NodeType, any> | RenderInput | Function, options?: DequeryOptions<NT> & ElementCreationOptions) => InstanceType<TExtendedClass>;
+}
+declare const $: typeof dequery & {
+    extend: <TExtendedClass extends new (...args: any[]) => any>(ExtensionClass: TExtendedClass) => <NT = DequerySyncMethodReturnType>(selectorRefOrEl: string | NodeType | Ref<NodeType, any> | RenderInput | Function, options?: DequeryOptions<NT> & ElementCreationOptions) => InstanceType<TExtendedClass>;
+};
+declare function isDequery(obj: unknown): obj is CallChainImplThenable | CallChainImpl;
+declare function isDequeryOptionsObject(o: object): boolean;
+declare function getDefaultDequeryOptions<NT>(): DequeryOptions<NT>;
+declare function mapArrayIndexAccess<NT = DequerySyncMethodReturnType, ET extends Dequery<NT> = Dequery<NT>>(source: CallChainImpl<NT, ET>, target: CallChainImpl<NT, ET>): void;
+declare function createCall<NT, ET extends Dequery<NT>>(chain: CallChainImpl<NT, ET>, methodName: string, handler: () => Promise<NT>, ...callArgs: any[]): CallChainImpl<NT, ET> | CallChainImplThenable<NT, ET>;
+/**
+ * Creates a sync-safe call that executes immediately if no operations are pending.
+ * Use this for methods that don't need async waiting (e.g., .on(), .addClass()).
+ *
+ * Safety rule: Only executes immediately when callStack.length === 0,
+ * ensuring correct ordering when async ops like .find() are queued.
+ */
+declare function createSyncCall<NT, ET extends Dequery<NT>>(chain: CallChainImpl<NT, ET>, methodName: string, handler: () => NT, ...callArgs: any[]): CallChainImplThenable<NT, ET> | CallChainImpl<NT, ET>;
+declare function createGetterSetterCall<NT, ET extends Dequery<NT>, T, V>(chain: CallChainImpl<NT, ET>, methodName: string, value: V | undefined, getter: () => T, setter: (value: V) => void): CallChainImplThenable<NT, ET> | CallChainImpl<NT, ET>;
+declare function createSubChain<NT = DequerySyncMethodReturnType, ET extends Dequery<NT> = Dequery<NT>>(source: CallChainImpl<NT, ET>, Constructor?: typeof CallChainImpl | typeof CallChainImplThenable, isResolved?: boolean): CallChainImpl<NT, ET> | CallChainImplThenable<NT, ET>;
+declare function subChainForNextAwait<NT, ET extends Dequery<NT>>(source: CallChainImpl<NT, ET>): CallChainImplThenable<NT, ET> | CallChainImpl<NT, ET>;
+declare function runWithTimeGuard<NT>(timeout: number, fn: Function, args: any[], onError: (ms: number, call: Call<NT>) => void): Promise<any>;
+declare function renderNode<T = DequerySyncMethodReturnType>(input: string | RenderInput | NodeType | Dequery<T> | Ref<NodeType, any> | CallChainImpl<T> | CallChainImplThenable<T> | null | undefined, chain: CallChainImpl<any> | CallChainImplThenable<any>): Promise<NodeType | null>;
+declare function resolveNodes<T = DequerySyncMethodReturnType>(input: string | NodeType | Ref<NodeType, any> | CallChainImpl<T> | CallChainImplThenable<T>, timeout: number, document?: Document): Promise<NodeType[]>;
+declare function traverse<NT, R = NT, ET extends Dequery<R> = Dequery<R>>(chain: CallChainImpl<NT, any>, methodName: string, selector: (el: Element) => Element | Element[] | null | undefined): ET;
+
+type Listener<T> = (newValue: T, oldValue?: T, changedKey?: string) => void;
+type EqualsFn<T> = (a: T, b: T) => boolean;
+interface StoreOptions<T> {
+    /** Custom equality function. Default: Object.is (shallow identity) */
+    equals?: EqualsFn<T>;
+}
+interface Store<T> {
+    value: T;
+    /** Get value at path, or entire store if no path */
+    get: <D = T>(path?: string) => D;
+    /** Set value at path, or replace entire store if no path */
+    set: <D = T>(pathOrValue: string | D, value?: D) => void;
+    /** Get entire store value (clearer API than get()) */
+    getRaw: () => T;
+    /** Replace entire store value (clearer API than set(value)) */
+    setRaw: (value: T) => void;
+    /** Reset store to initial value or provided value */
+    reset: (value?: T) => void;
+    subscribe: (listener: Listener<T>) => () => void;
+    persist: (key: string, provider?: PersistenceProviderType) => void;
+    restore: (key: string, provider?: PersistenceProviderType) => void;
+}
+/** Shallow identity comparison (opt-in for performance) */
+declare const shallowEquals: <T>(a: T, b: T) => boolean;
+/** Deep equality via JSON (default - backward compatible) */
+declare const deepEquals: <T>(a: T, b: T) => boolean;
+declare const createStore: <T>(initialValue: T, options?: StoreOptions<T>) => Store<T>;
+
+declare global {
+    var __defuss_document: Document;
+    var __defuss_window: Window;
+    interface HTMLElement {
+        _defussRef?: Ref<Element>;
+    }
+}
+type Globals = Performance & Window & typeof globalThis;
+type Maybe<T> = T | null | undefined;
+type OneOrMany<T> = T | readonly T[];
+type NodeType = Node | Text | Element | Document | DocumentFragment | HTMLElement | SVGElement | null;
+type DOMElement = Element | SVGElement;
+type SyncRenderInput = VNode | undefined | string | Array<VNode | undefined | string>;
+type ParentElementInput = Element | Document | Dequery<NodeType> | undefined;
+type SyncRenderResult = Array<Element | Text | undefined> | Element | Text | undefined;
+type ParentElementInputAsync = ParentElementInput | Dequery<NodeType> | Promise<ParentElementInput | Dequery<NodeType>>;
+type JsxRuntimeHookFn = (type: VNodeType | Function | any, attributes: (JSX.HTMLAttributes & JSX.SVGAttributes & Record<string, any>) | null, key?: string, sourceInfo?: JsxSourceInfo) => void;
+interface CSSProperties extends CSS.Properties<string | number> {
+}
+interface FontFaceProperties {
+    MozFontFeatureSettings?: CSS.Property.FontFeatureSettings;
+    fontDisplay?: "auto" | "block" | "fallback" | "optional" | "swap" | (string & {});
+    fontFamily?: CSS.Property.FontFamily;
+    fontFeatureSettings?: CSS.Property.FontFeatureSettings;
+    fontStretch?: CSS.Property.FontStretch;
+    fontStyle?: CSS.Property.FontStyle;
+    fontVariant?: CSS.Property.FontVariant;
+    fontVariationSettings?: CSS.Property.FontVariationSettings;
+    fontWeight?: CSS.Property.FontWeight;
+    src?: string;
+    unicodeRange?: string;
+}
+interface KeyFrameProperties {
+    from?: Partial<CSSProperties>;
+    to?: Partial<CSSProperties>;
+    [k: Percent]: Partial<CSSProperties> | undefined;
+}
+type MountHandler<T extends DOMElement = DOMElement> = (element: T) => void;
+type UnmountHandler<T extends DOMElement = DOMElement> = (element: T) => void;
+type RefUpdateRenderFnInput = string | RenderInput | NodeType | Dequery<NodeType>;
+type RefUpdateFn<ST> = (state: ST) => void;
+type RefUpdateRenderFn = (input: RefUpdateRenderFnInput) => Promise<CallChainImpl<NodeType>>;
+interface Ref<NT = null | Node | Element | Text, ST = any> {
+    orphan?: boolean;
+    current: NT;
+    store?: Store<ST>;
+    state?: ST;
+    /** @deprecated use render() instead */
+    update: RefUpdateRenderFn;
+    render: RefUpdateRenderFn;
+    updateState: RefUpdateFn<ST>;
+    subscribe: (refUpdateFn: RefUpdateFn<ST>) => () => void;
+    persist: (key: string, provider?: PersistenceProviderType) => void;
+    restore: (key: string, provider?: PersistenceProviderType) => void;
+}
+type DefussKey = string | number;
+interface VAttributes<T extends DOMElement = DOMElement, ST = any> {
+    ref?: Ref<T, ST>;
+    key?: DefussKey;
+    onMount?: MountHandler<T>;
+    onUnmount?: UnmountHandler<T>;
+}
+interface VNodeAttributes extends VAttributes {
+    [attributeName: string]: any;
+    key?: DefussKey;
+}
+interface JsxSourceInfo {
+    fileName: string;
+    lineNumber: number;
+    columnNumber: number;
+    exportName?: string;
+    allChildrenAreStatic?: boolean;
+    selfReference?: boolean;
+}
+interface VNode<A = VNodeAttributes> {
+    type?: VNodeType;
+    attributes?: A;
+    children?: DefussChildren;
+    sourceInfo?: JsxSourceInfo;
+}
+type VNodeType = string | Function | any;
+type VNodeKey = string | number | any;
+type VNodeRefObject<T> = {
+    current?: T | null;
+};
+type VNodeRefCallback<T> = (instance: T | null) => void;
+type VNodeRef<T> = VNodeRefObject<T> | VNodeRefCallback<T>;
+type VNodeChild = VNode<any> | object | string | number | boolean | null | undefined;
+type VNodeChildren = VNodeChild[];
+type Children = VNodeChildren;
+interface DomAbstractionImpl {
+    hasElNamespace(domElement: Element): boolean;
+    hasSvgNamespace(parentElement: Element, type: string): boolean;
+    createElementOrElements(virtualNode: VNode | undefined | Array<VNode | undefined | string>, parentDomElement?: Element | Document): Array<Element | Text | undefined> | Element | Text | undefined;
+    createElement(virtualNode: VNode | undefined, parentDomElement?: Element | Document): Element | undefined;
+    createTextNode(text: string, parentDomElement?: Element | Document): Text;
+    createChildElements(virtualChildren: VNodeChildren, parentDomElement?: Element): Array<Element | Text | undefined>;
+    setAttribute(name: string, value: any, parentDomElement: Element, attributes: VNodeAttributes): void;
+    setAttributes(attributes: VNode<VNodeAttributes>, parentDomElement: Element): void;
+}
+declare global {
+    namespace JSX {
+        interface ElementAttributesProperty {
+            attrs: {};
+        }
+        interface SVGAttributes<T extends DOMElement = DOMElement> extends HTMLAttributes<T> {
+            accentHeight?: number | string;
+            accumulate?: "none" | "sum";
+            additive?: "replace" | "sum";
+            alignmentBaseline?: "auto" | "baseline" | "before-edge" | "text-before-edge" | "middle" | "central" | "after-edge" | "text-after-edge" | "ideographic" | "alphabetic" | "hanging" | "mathematical" | "inherit";
+            allowReorder?: "no" | "yes";
+            alphabetic?: number | string;
+            amplitude?: number | string;
+            arabicForm?: "initial" | "medial" | "terminal" | "isolated";
+            ascent?: number | string;
+            attributeName?: string;
+            attributeType?: string;
+            autoReverse?: number | string;
+            azimuth?: number | string;
+            baseFrequency?: number | string;
+            baselineShift?: number | string;
+            baseProfile?: number | string;
+            bbox?: number | string;
+            begin?: number | string;
+            bias?: number | string;
+            by?: number | string;
+            calcMode?: number | string;
+            capHeight?: number | string;
+            clip?: number | string;
+            clipPath?: string;
+            clipPathUnits?: number | string;
+            clipRule?: number | string;
+            colorInterpolation?: number | string;
+            colorInterpolationFilters?: "auto" | "sRGB" | "linearRGB" | "inherit";
+            colorProfile?: number | string;
+            colorRendering?: number | string;
+            contentScriptType?: number | string;
+            contentStyleType?: number | string;
+            cursor?: number | string;
+            cx?: number | string;
+            cy?: number | string;
+            d?: string;
+            decelerate?: number | string;
+            descent?: number | string;
+            diffuseConstant?: number | string;
+            direction?: number | string;
+            display?: number | string;
+            divisor?: number | string;
+            dominantBaseline?: number | string;
+            dur?: number | string;
+            dx?: number | string;
+            dy?: number | string;
+            edgeMode?: number | string;
+            elevation?: number | string;
+            enableBackground?: number | string;
+            end?: number | string;
+            exponent?: number | string;
+            externalResourcesRequired?: number | string;
+            fill?: string;
+            fillOpacity?: number | string;
+            fillRule?: "nonzero" | "evenodd" | "inherit";
+            filter?: string;
+            filterRes?: number | string;
+            filterUnits?: number | string;
+            floodColor?: number | string;
+            floodOpacity?: number | string;
+            focusable?: number | string;
+            fontFamily?: string;
+            fontSize?: number | string;
+            fontSizeAdjust?: number | string;
+            fontStretch?: number | string;
+            fontStyle?: number | string;
+            fontVariant?: number | string;
+            fontWeight?: number | string;
+            format?: number | string;
+            from?: number | string;
+            fx?: number | string;
+            fy?: number | string;
+            g1?: number | string;
+            g2?: number | string;
+            glyphName?: number | string;
+            glyphOrientationHorizontal?: number | string;
+            glyphOrientationVertical?: number | string;
+            glyphRef?: number | string;
+            gradientTransform?: string;
+            gradientUnits?: string;
+            hanging?: number | string;
+            horizAdvX?: number | string;
+            horizOriginX?: number | string;
+            ideographic?: number | string;
+            imageRendering?: number | string;
+            in2?: number | string;
+            in?: string;
+            intercept?: number | string;
+            k1?: number | string;
+            k2?: number | string;
+            k3?: number | string;
+            k4?: number | string;
+            k?: number | string;
+            kernelMatrix?: number | string;
+            kernelUnitLength?: number | string;
+            kerning?: number | string;
+            keyPoints?: number | string;
+            keySplines?: number | string;
+            keyTimes?: number | string;
+            lengthAdjust?: number | string;
+            letterSpacing?: number | string;
+            lightingColor?: number | string;
+            limitingConeAngle?: number | string;
+            local?: number | string;
+            markerEnd?: string;
+            markerHeight?: number | string;
+            markerMid?: string;
+            markerStart?: string;
+            markerUnits?: number | string;
+            markerWidth?: number | string;
+            mask?: string;
+            maskContentUnits?: number | string;
+            maskUnits?: number | string;
+            mathematical?: number | string;
+            mode?: number | string;
+            numOctaves?: number | string;
+            offset?: number | string;
+            opacity?: number | string;
+            operator?: number | string;
+            order?: number | string;
+            orient?: number | string;
+            orientation?: number | string;
+            origin?: number | string;
+            overflow?: number | string;
+            overlinePosition?: number | string;
+            overlineThickness?: number | string;
+            paintOrder?: number | string;
+            panose1?: number | string;
+            pathLength?: number | string;
+            patternContentUnits?: string;
+            patternTransform?: number | string;
+            patternUnits?: string;
+            pointerEvents?: number | string;
+            points?: string;
+            pointsAtX?: number | string;
+            pointsAtY?: number | string;
+            pointsAtZ?: number | string;
+            preserveAlpha?: number | string;
+            preserveAspectRatio?: string;
+            primitiveUnits?: number | string;
+            r?: number | string;
+            radius?: number | string;
+            refX?: number | string;
+            refY?: number | string;
+            renderingIntent?: number | string;
+            repeatCount?: number | string;
+            repeatDur?: number | string;
+            requiredExtensions?: number | string;
+            requiredFeatures?: number | string;
+            restart?: number | string;
+            result?: string;
+            rotate?: number | string;
+            rx?: number | string;
+            ry?: number | string;
+            scale?: number | string;
+            seed?: number | string;
+            shapeRendering?: number | string;
+            slope?: number | string;
+            spacing?: number | string;
+            specularConstant?: number | string;
+            specularExponent?: number | string;
+            speed?: number | string;
+            spreadMethod?: string;
+            startOffset?: number | string;
+            stdDeviation?: number | string;
+            stemh?: number | string;
+            stemv?: number | string;
+            stitchTiles?: number | string;
+            stopColor?: string;
+            stopOpacity?: number | string;
+            strikethroughPosition?: number | string;
+            strikethroughThickness?: number | string;
+            string?: number | string;
+            stroke?: string;
+            strokeDasharray?: string | number;
+            strokeDashoffset?: string | number;
+            strokeLinecap?: "butt" | "round" | "square" | "inherit";
+            strokeLinejoin?: "miter" | "round" | "bevel" | "inherit";
+            strokeMiterlimit?: string;
+            strokeOpacity?: number | string;
+            strokeWidth?: number | string;
+            surfaceScale?: number | string;
+            systemLanguage?: number | string;
+            tableValues?: number | string;
+            targetX?: number | string;
+            targetY?: number | string;
+            textAnchor?: string;
+            textDecoration?: number | string;
+            textLength?: number | string;
+            textRendering?: number | string;
+            to?: number | string;
+            transform?: string;
+            u1?: number | string;
+            u2?: number | string;
+            underlinePosition?: number | string;
+            underlineThickness?: number | string;
+            unicode?: number | string;
+            unicodeBidi?: number | string;
+            unicodeRange?: number | string;
+            unitsPerEm?: number | string;
+            vAlphabetic?: number | string;
+            values?: string;
+            vectorEffect?: number | string;
+            version?: string;
+            vertAdvY?: number | string;
+            vertOriginX?: number | string;
+            vertOriginY?: number | string;
+            vHanging?: number | string;
+            vIdeographic?: number | string;
+            viewBox?: string;
+            viewTarget?: number | string;
+            visibility?: number | string;
+            vMathematical?: number | string;
+            widths?: number | string;
+            wordSpacing?: number | string;
+            writingMode?: number | string;
+            x1?: number | string;
+            x2?: number | string;
+            x?: number | string;
+            xChannelSelector?: string;
+            xHeight?: number | string;
+            xlinkActuate?: string;
+            xlinkArcrole?: string;
+            xlinkHref?: string;
+            xlinkRole?: string;
+            xlinkShow?: string;
+            xlinkTitle?: string;
+            xlinkType?: string;
+            xmlBase?: string;
+            xmlLang?: string;
+            xmlns?: string;
+            xmlnsXlink?: string;
+            xmlSpace?: string;
+            y1?: number | string;
+            y2?: number | string;
+            y?: number | string;
+            yChannelSelector?: string;
+            z?: number | string;
+            zoomAndPan?: string;
+        }
+        interface PathAttributes {
+            d: string;
+        }
+        type EventHandler<E extends Event> = (event: E) => void;
+        type ClipboardEventHandler = EventHandler<ClipboardEvent>;
+        type CompositionEventHandler = EventHandler<CompositionEvent>;
+        type DragEventHandler = EventHandler<DragEvent>;
+        type FocusEventHandler = EventHandler<FocusEvent>;
+        type KeyboardEventHandler = EventHandler<KeyboardEvent>;
+        type MouseEventHandler = EventHandler<MouseEvent>;
+        type TouchEventHandler = EventHandler<TouchEvent>;
+        type UIEventHandler = EventHandler<UIEvent>;
+        type WheelEventHandler = EventHandler<WheelEvent>;
+        type AnimationEventHandler = EventHandler<AnimationEvent>;
+        type TransitionEventHandler = EventHandler<TransitionEvent>;
+        type ProgressEventHandler = EventHandler<ProgressEvent>;
+        type GenericEventHandler = EventHandler<Event>;
+        type PointerEventHandler = EventHandler<PointerEvent>;
+        interface DOMAttributeEventHandlersLowerCase<T extends DOMElement = DOMElement> {
+            onload?: GenericEventHandler;
+            onloadcapture?: GenericEventHandler;
+            onerror?: GenericEventHandler;
+            onerrorcapture?: GenericEventHandler;
+            oncopy?: ClipboardEventHandler;
+            oncopycapture?: ClipboardEventHandler;
+            oncut?: ClipboardEventHandler;
+            oncutcapture?: ClipboardEventHandler;
+            onpaste?: ClipboardEventHandler;
+            onpastecapture?: ClipboardEventHandler;
+            oncompositionend?: CompositionEventHandler;
+            oncompositionendcapture?: CompositionEventHandler;
+            oncompositionstart?: CompositionEventHandler;
+            oncompositionstartcapture?: CompositionEventHandler;
+            oncompositionupdate?: CompositionEventHandler;
+            oncompositionupdatecapture?: CompositionEventHandler;
+            onfocus?: FocusEventHandler;
+            onfocuscapture?: FocusEventHandler;
+            onblur?: FocusEventHandler;
+            onblurcapture?: FocusEventHandler;
+            onchange?: GenericEventHandler;
+            onchangecapture?: GenericEventHandler;
+            oninput?: GenericEventHandler;
+            oninputcapture?: GenericEventHandler;
+            onsearch?: GenericEventHandler;
+            onsearchcapture?: GenericEventHandler;
+            onsubmit?: GenericEventHandler;
+            onsubmitcapture?: GenericEventHandler;
+            oninvalid?: GenericEventHandler;
+            oninvalidcapture?: GenericEventHandler;
+            onkeydown?: KeyboardEventHandler;
+            onkeydowncapture?: KeyboardEventHandler;
+            onkeypress?: KeyboardEventHandler;
+            onkeypresscapture?: KeyboardEventHandler;
+            onkeyup?: KeyboardEventHandler;
+            onkeyupcapture?: KeyboardEventHandler;
+            onabort?: GenericEventHandler;
+            onabortcapture?: GenericEventHandler;
+            oncanplay?: GenericEventHandler;
+            oncanplaycapture?: GenericEventHandler;
+            oncanplaythrough?: GenericEventHandler;
+            oncanplaythroughcapture?: GenericEventHandler;
+            ondurationchange?: GenericEventHandler;
+            ondurationchangecapture?: GenericEventHandler;
+            onemptied?: GenericEventHandler;
+            onemptiedcapture?: GenericEventHandler;
+            onencrypted?: GenericEventHandler;
+            onencryptedcapture?: GenericEventHandler;
+            onended?: GenericEventHandler;
+            onendedcapture?: GenericEventHandler;
+            onloadeddata?: GenericEventHandler;
+            onloadeddatacapture?: GenericEventHandler;
+            onloadedmetadata?: GenericEventHandler;
+            onloadedmetadatacapture?: GenericEventHandler;
+            onloadstart?: GenericEventHandler;
+            onloadstartcapture?: GenericEventHandler;
+            onpause?: GenericEventHandler;
+            onpausecapture?: GenericEventHandler;
+            onplay?: GenericEventHandler;
+            onplaycapture?: GenericEventHandler;
+            onplaying?: GenericEventHandler;
+            onplayingcapture?: GenericEventHandler;
+            onprogress?: ProgressEventHandler;
+            onprogresscapture?: ProgressEventHandler;
+            onratechange?: GenericEventHandler;
+            onratechangecapture?: GenericEventHandler;
+            onseeked?: GenericEventHandler;
+            onseekedcapture?: GenericEventHandler;
+            onseeking?: GenericEventHandler;
+            onseekingcapture?: GenericEventHandler;
+            onstalled?: GenericEventHandler;
+            onstalledcapture?: GenericEventHandler;
+            onsuspend?: GenericEventHandler;
+            onsuspendcapture?: GenericEventHandler;
+            ontimeupdate?: GenericEventHandler;
+            ontimeupdatecapture?: GenericEventHandler;
+            onvolumechange?: GenericEventHandler;
+            onvolumechangecapture?: GenericEventHandler;
+            onwaiting?: GenericEventHandler;
+            onwaitingcapture?: GenericEventHandler;
+            onclick?: MouseEventHandler;
+            onclickcapture?: MouseEventHandler;
+            oncontextmenu?: MouseEventHandler;
+            oncontextmenucapture?: MouseEventHandler;
+            ondblclick?: MouseEventHandler;
+            ondblclickcapture?: MouseEventHandler;
+            ondrag?: DragEventHandler;
+            ondragcapture?: DragEventHandler;
+            ondragend?: DragEventHandler;
+            ondragendcapture?: DragEventHandler;
+            ondragenter?: DragEventHandler;
+            ondragentercapture?: DragEventHandler;
+            ondragexit?: DragEventHandler;
+            ondragexitcapture?: DragEventHandler;
+            ondragleave?: DragEventHandler;
+            ondragleavecapture?: DragEventHandler;
+            ondragover?: DragEventHandler;
+            ondragovercapture?: DragEventHandler;
+            ondragstart?: DragEventHandler;
+            ondragstartcapture?: DragEventHandler;
+            ondrop?: DragEventHandler;
+            ondropcapture?: DragEventHandler;
+            onmousedown?: MouseEventHandler;
+            onmousedowncapture?: MouseEventHandler;
+            onmouseenter?: MouseEventHandler;
+            onmouseentercapture?: MouseEventHandler;
+            onmouseleave?: MouseEventHandler;
+            onmouseleavecapture?: MouseEventHandler;
+            onmousemove?: MouseEventHandler;
+            onmousemovecapture?: MouseEventHandler;
+            onmouseout?: MouseEventHandler;
+            onmouseoutcapture?: MouseEventHandler;
+            onmouseover?: MouseEventHandler;
+            onmouseovercapture?: MouseEventHandler;
+            onmouseup?: MouseEventHandler;
+            onmouseupcapture?: MouseEventHandler;
+            onselect?: GenericEventHandler;
+            onselectcapture?: GenericEventHandler;
+            ontouchcancel?: TouchEventHandler;
+            ontouchcancelcapture?: TouchEventHandler;
+            ontouchend?: TouchEventHandler;
+            ontouchendcapture?: TouchEventHandler;
+            ontouchmove?: TouchEventHandler;
+            ontouchmovecapture?: TouchEventHandler;
+            ontouchstart?: TouchEventHandler;
+            ontouchstartcapture?: TouchEventHandler;
+            onpointerover?: PointerEventHandler;
+            onpointerovercapture?: PointerEventHandler;
+            onpointerenter?: PointerEventHandler;
+            onpointerentercapture?: PointerEventHandler;
+            onpointerdown?: PointerEventHandler;
+            onpointerdowncapture?: PointerEventHandler;
+            onpointermove?: PointerEventHandler;
+            onpointermovecapture?: PointerEventHandler;
+            onpointerup?: PointerEventHandler;
+            onpointerupcapture?: PointerEventHandler;
+            onpointercancel?: PointerEventHandler;
+            onpointercancelcapture?: PointerEventHandler;
+            onpointerout?: PointerEventHandler;
+            onpointeroutcapture?: PointerEventHandler;
+            onpointerleave?: PointerEventHandler;
+            onpointerleavecapture?: PointerEventHandler;
+            ongotpointercapture?: PointerEventHandler;
+            ongotpointercapturecapture?: PointerEventHandler;
+            onlostpointercapture?: PointerEventHandler;
+            onlostpointercapturecapture?: PointerEventHandler;
+            onscroll?: UIEventHandler;
+            onscrollcapture?: UIEventHandler;
+            onwheel?: WheelEventHandler;
+            onwheelcapture?: WheelEventHandler;
+            onanimationstart?: AnimationEventHandler;
+            onanimationstartcapture?: AnimationEventHandler;
+            onanimationend?: AnimationEventHandler;
+            onanimationendcapture?: AnimationEventHandler;
+            onanimationiteration?: AnimationEventHandler;
+            onanimationiterationcapture?: AnimationEventHandler;
+            ontransitionend?: TransitionEventHandler;
+            ontransitionendcapture?: TransitionEventHandler;
+        }
+        interface DOMAttributes<T extends DOMElement = DOMElement> extends VAttributes<T>, DOMAttributeEventHandlersLowerCase<T> {
+            onMount?: MountHandler<T>;
+            onUnmount?: UnmountHandler<T>;
+            onLoad?: GenericEventHandler;
+            onLoadCapture?: GenericEventHandler;
+            onError?: GenericEventHandler;
+            onErrorCapture?: GenericEventHandler;
+            onCopy?: ClipboardEventHandler;
+            onCopyCapture?: ClipboardEventHandler;
+            onCut?: ClipboardEventHandler;
+            onCutCapture?: ClipboardEventHandler;
+            onPaste?: ClipboardEventHandler;
+            onPasteCapture?: ClipboardEventHandler;
+            onCompositionEnd?: CompositionEventHandler;
+            onCompositionEndCapture?: CompositionEventHandler;
+            onCompositionStart?: CompositionEventHandler;
+            onCompositionStartCapture?: CompositionEventHandler;
+            onCompositionUpdate?: CompositionEventHandler;
+            onCompositionUpdateCapture?: CompositionEventHandler;
+            onFocus?: FocusEventHandler;
+            onFocusCapture?: FocusEventHandler;
+            onBlur?: FocusEventHandler;
+            onBlurCapture?: FocusEventHandler;
+            onChange?: GenericEventHandler;
+            onChangeCapture?: GenericEventHandler;
+            onInput?: GenericEventHandler;
+            onInputCapture?: GenericEventHandler;
+            onSearch?: GenericEventHandler;
+            onSearchCapture?: GenericEventHandler;
+            onSubmit?: GenericEventHandler;
+            onSubmitCapture?: GenericEventHandler;
+            onInvalid?: GenericEventHandler;
+            onInvalidCapture?: GenericEventHandler;
+            onKeyDown?: KeyboardEventHandler;
+            onKeyDownCapture?: KeyboardEventHandler;
+            onKeyPress?: KeyboardEventHandler;
+            onKeyPressCapture?: KeyboardEventHandler;
+            onKeyUp?: KeyboardEventHandler;
+            onKeyUpCapture?: KeyboardEventHandler;
+            onAbort?: GenericEventHandler;
+            onAbortCapture?: GenericEventHandler;
+            onCanPlay?: GenericEventHandler;
+            onCanPlayCapture?: GenericEventHandler;
+            onCanPlayThrough?: GenericEventHandler;
+            onCanPlayThroughCapture?: GenericEventHandler;
+            onDurationChange?: GenericEventHandler;
+            onDurationChangeCapture?: GenericEventHandler;
+            onEmptied?: GenericEventHandler;
+            onEmptiedCapture?: GenericEventHandler;
+            onEncrypted?: GenericEventHandler;
+            onEncryptedCapture?: GenericEventHandler;
+            onEnded?: GenericEventHandler;
+            onEndedCapture?: GenericEventHandler;
+            onLoadedData?: GenericEventHandler;
+            onLoadedDataCapture?: GenericEventHandler;
+            onLoadedMetadata?: GenericEventHandler;
+            onLoadedMetadataCapture?: GenericEventHandler;
+            onLoadStart?: GenericEventHandler;
+            onLoadStartCapture?: GenericEventHandler;
+            onPause?: GenericEventHandler;
+            onPauseCapture?: GenericEventHandler;
+            onPlay?: GenericEventHandler;
+            onPlayCapture?: GenericEventHandler;
+            onPlaying?: GenericEventHandler;
+            onPlayingCapture?: GenericEventHandler;
+            onProgress?: GenericEventHandler;
+            onProgressCapture?: GenericEventHandler;
+            onRateChange?: GenericEventHandler;
+            onRateChangeCapture?: GenericEventHandler;
+            onSeeked?: GenericEventHandler;
+            onSeekedCapture?: GenericEventHandler;
+            onSeeking?: GenericEventHandler;
+            onSeekingCapture?: GenericEventHandler;
+            onStalled?: GenericEventHandler;
+            onStalledCapture?: GenericEventHandler;
+            onSuspend?: GenericEventHandler;
+            onSuspendCapture?: GenericEventHandler;
+            onTimeUpdate?: GenericEventHandler;
+            onTimeUpdateCapture?: GenericEventHandler;
+            onVolumeChange?: GenericEventHandler;
+            onVolumeChangeCapture?: GenericEventHandler;
+            onWaiting?: GenericEventHandler;
+            onWaitingCapture?: GenericEventHandler;
+            onClick?: MouseEventHandler;
+            onClickCapture?: MouseEventHandler;
+            onContextMenu?: MouseEventHandler;
+            onContextMenuCapture?: MouseEventHandler;
+            onDblClick?: MouseEventHandler;
+            onDblClickCapture?: MouseEventHandler;
+            onDrag?: DragEventHandler;
+            onDragCapture?: DragEventHandler;
+            onDragEnd?: DragEventHandler;
+            onDragEndCapture?: DragEventHandler;
+            onDragEnter?: DragEventHandler;
+            onDragEnterCapture?: DragEventHandler;
+            onDragExit?: DragEventHandler;
+            onDragExitCapture?: DragEventHandler;
+            onDragLeave?: DragEventHandler;
+            onDragLeaveCapture?: DragEventHandler;
+            onDragOver?: DragEventHandler;
+            onDragOverCapture?: DragEventHandler;
+            onDragStart?: DragEventHandler;
+            onDragStartCapture?: DragEventHandler;
+            onDrop?: DragEventHandler;
+            onDropCapture?: DragEventHandler;
+            onMouseDown?: MouseEventHandler;
+            onMouseDownCapture?: MouseEventHandler;
+            onMouseEnter?: MouseEventHandler;
+            onMouseEnterCapture?: MouseEventHandler;
+            onMouseLeave?: MouseEventHandler;
+            onMouseLeaveCapture?: MouseEventHandler;
+            onMouseMove?: MouseEventHandler;
+            onMouseMoveCapture?: MouseEventHandler;
+            onMouseOut?: MouseEventHandler;
+            onMouseOutCapture?: MouseEventHandler;
+            onMouseOver?: MouseEventHandler;
+            onMouseOverCapture?: MouseEventHandler;
+            onMouseUp?: MouseEventHandler;
+            onMouseUpCapture?: MouseEventHandler;
+            onSelect?: GenericEventHandler;
+            onSelectCapture?: GenericEventHandler;
+            onTouchCancel?: TouchEventHandler;
+            onTouchCancelCapture?: TouchEventHandler;
+            onTouchEnd?: TouchEventHandler;
+            onTouchEndCapture?: TouchEventHandler;
+            onTouchMove?: TouchEventHandler;
+            onTouchMoveCapture?: TouchEventHandler;
+            onTouchStart?: TouchEventHandler;
+            onTouchStartCapture?: TouchEventHandler;
+            onPointerOver?: PointerEventHandler;
+            onPointerOverCapture?: PointerEventHandler;
+            onPointerEnter?: PointerEventHandler;
+            onPointerEnterCapture?: PointerEventHandler;
+            onPointerDown?: PointerEventHandler;
+            onPointerDownCapture?: PointerEventHandler;
+            onPointerMove?: PointerEventHandler;
+            onPointerMoveCapture?: PointerEventHandler;
+            onPointerUp?: PointerEventHandler;
+            onPointerUpCapture?: PointerEventHandler;
+            onPointerCancel?: PointerEventHandler;
+            onPointerCancelCapture?: PointerEventHandler;
+            onPointerOut?: PointerEventHandler;
+            onPointerOutCapture?: PointerEventHandler;
+            onPointerLeave?: PointerEventHandler;
+            onPointerLeaveCapture?: PointerEventHandler;
+            onGotPointerCapture?: PointerEventHandler;
+            onGotPointerCaptureCapture?: PointerEventHandler;
+            onLostPointerCapture?: PointerEventHandler;
+            onLostPointerCaptureCapture?: PointerEventHandler;
+            onScroll?: UIEventHandler;
+            onScrollCapture?: UIEventHandler;
+            onWheel?: WheelEventHandler;
+            onWheelCapture?: WheelEventHandler;
+            onAnimationStart?: AnimationEventHandler;
+            onAnimationStartCapture?: AnimationEventHandler;
+            onAnimationEnd?: AnimationEventHandler;
+            onAnimationEndCapture?: AnimationEventHandler;
+            onAnimationIteration?: AnimationEventHandler;
+            onAnimationIterationCapture?: AnimationEventHandler;
+            onTransitionEnd?: TransitionEventHandler;
+            onTransitionEndCapture?: TransitionEventHandler;
+        }
+        interface HTMLAttributesLowerCase<T extends DOMElement = DOMElement> extends VAttributes<T> {
+            dangerouslysetinnerhtml?: {
+                __html: string;
+            };
+            accept?: string;
+            acceptcharset?: string;
+            accesskey?: string;
+            action?: string;
+            allowfullscreen?: boolean;
+            allowtransparency?: boolean;
+            alt?: string;
+            async?: boolean;
+            autocomplete?: string;
+            autocorrect?: string;
+            autofocus?: boolean | string;
+            autoplay?: boolean;
+            capture?: boolean;
+            cellpadding?: number | string;
+            cellspacing?: number | string;
+            charset?: string;
+            challenge?: string;
+            checked?: boolean | string;
+            class?: DefussClassValue;
+            classname?: DefussClassValue;
+            cols?: number;
+            children?: DefussChildren;
+            colspan?: number;
+            content?: string;
+            contenteditable?: boolean;
+            contextmenu?: string;
+            controls?: boolean;
+            controlslist?: string;
+            coords?: string;
+            crossorigin?: string;
+            data?: string;
+            datetime?: string;
+            default?: boolean;
+            defer?: boolean;
+            dir?: string;
+            disabled?: boolean;
+            download?: any;
+            draggable?: boolean;
+            enctype?: string;
+            form?: string;
+            formaction?: string;
+            formenctype?: string;
+            formmethod?: string;
+            novalidate?: boolean | string;
+            formnovalidate?: boolean;
+            formtarget?: string;
+            frameborder?: number | string;
+            headers?: string;
+            height?: number | string;
+            hidden?: boolean;
+            high?: number;
+            href?: string;
+            hreflang?: string;
+            for?: string;
+            htmlfor?: string;
+            httpequiv?: string;
+            icon?: string;
+            id?: string;
+            inputmode?: string;
+            integrity?: string;
+            is?: string;
+            keyparams?: string;
+            keytype?: string;
+            kind?: string;
+            label?: string;
+            lang?: string;
+            list?: string;
+            loop?: boolean;
+            low?: number;
+            manifest?: string;
+            marginheight?: number;
+            marginwidth?: number;
+            max?: number | string;
+            maxlength?: number;
+            media?: string;
+            mediagroup?: string;
+            method?: string;
+            min?: number | string;
+            minlength?: number;
+            multiple?: boolean;
+            muted?: boolean;
+            name?: string;
+            open?: boolean;
+            optimum?: number;
+            pattern?: string;
+            placeholder?: string;
+            playsinline?: boolean;
+            poster?: string;
+            preload?: string;
+            radiogroup?: string;
+            readonly?: boolean;
+            rel?: string;
+            required?: boolean | string;
+            role?: string;
+            rows?: number;
+            rowspan?: number;
+            sandbox?: string;
+            scope?: string;
+            scoped?: boolean;
+            scrolling?: string;
+            seamless?: boolean;
+            selected?: boolean;
+            shape?: string;
+            size?: number;
+            sizes?: string;
+            slot?: string;
+            span?: number;
+            spellcheck?: boolean;
+            src?: string;
+            srcset?: string;
+            srcdoc?: string;
+            srclang?: string;
+            start?: number;
+            step?: number | string;
+            style?: string | Partial<CSSProperties>;
+            summary?: string;
+            tabindex?: number | string;
+            target?: string;
+            title?: string;
+            type?: string;
+            usemap?: string;
+            value?: string | string[] | number;
+            width?: number | string;
+            wmode?: string;
+            wrap?: string;
+            about?: string;
+            datatype?: string;
+            inlist?: any;
+            prefix?: string;
+            property?: string;
+            resource?: string;
+            typeof?: string;
+            vocab?: string;
+            itemprop?: string;
+            itemscope?: boolean;
+            itemtype?: string;
+            itemid?: string;
+            itemref?: string;
+        }
+        interface HTMLAttributes<T extends DOMElement = DOMElement> extends HTMLAttributesLowerCase<T>, DOMAttributes<T> {
+            dangerouslySetInnerHTML?: {
+                __html: string;
+            };
+            onMount?: MountHandler<T>;
+            onUnmount?: UnmountHandler<T>;
+            accept?: string;
+            acceptCharset?: string;
+            accessKey?: string;
+            action?: string;
+            allowFullScreen?: boolean;
+            allowTransparency?: boolean;
+            alt?: string;
+            async?: boolean;
+            autoComplete?: string;
+            autoCorrect?: string;
+            autofocus?: boolean | string;
+            autoFocus?: boolean;
+            autoPlay?: boolean;
+            capture?: boolean;
+            cellPadding?: number | string;
+            cellSpacing?: number | string;
+            charSet?: string;
+            challenge?: string;
+            checked?: boolean | string;
+            class?: DefussClassValue;
+            className?: DefussClassValue;
+            cols?: number;
+            children?: DefussChildren;
+            colSpan?: number;
+            content?: string;
+            contentEditable?: boolean;
+            contextMenu?: string;
+            controls?: boolean;
+            controlsList?: string;
+            coords?: string;
+            crossOrigin?: string;
+            data?: string;
+            dateTime?: string;
+            default?: boolean;
+            defer?: boolean;
+            dir?: string;
+            disabled?: boolean;
+            download?: any;
+            draggable?: boolean;
+            encType?: string;
+            form?: string;
+            formAction?: string;
+            formEncType?: string;
+            formMethod?: string;
+            formNoValidate?: boolean;
+            formTarget?: string;
+            frameBorder?: number | string;
+            headers?: string;
+            height?: number | string;
+            hidden?: boolean;
+            high?: number;
+            href?: string;
+            hrefLang?: string;
+            for?: string;
+            htmlFor?: string;
+            httpEquiv?: string;
+            icon?: string;
+            id?: string;
+            inputMode?: string;
+            integrity?: string;
+            is?: string;
+            keyParams?: string;
+            keyType?: string;
+            kind?: string;
+            label?: string;
+            lang?: string;
+            list?: string;
+            loop?: boolean;
+            low?: number;
+            manifest?: string;
+            marginHeight?: number;
+            marginWidth?: number;
+            max?: number | string;
+            maxLength?: number;
+            media?: string;
+            mediaGroup?: string;
+            method?: string;
+            min?: number | string;
+            minLength?: number;
+            multiple?: boolean;
+            muted?: boolean;
+            name?: string;
+            open?: boolean;
+            optimum?: number;
+            pattern?: string;
+            placeholder?: string;
+            playsInline?: boolean;
+            poster?: string;
+            preload?: string;
+            radioGroup?: string;
+            readOnly?: boolean;
+            rel?: string;
+            required?: boolean | string;
+            role?: string;
+            rows?: number;
+            rowSpan?: number;
+            sandbox?: string;
+            scope?: string;
+            scoped?: boolean;
+            scrolling?: string;
+            seamless?: boolean;
+            selected?: boolean;
+            shape?: string;
+            size?: number;
+            sizes?: string;
+            slot?: string;
+            span?: number;
+            spellcheck?: boolean;
+            src?: string;
+            srcDoc?: string;
+            srcLang?: string;
+            srcSet?: string;
+            start?: number;
+            step?: number | string;
+            style?: string | Partial<CSSProperties>;
+            summary?: string;
+            tabIndex?: number | string;
+            target?: string;
+            title?: string;
+            type?: string;
+            useMap?: string;
+            value?: string | string[] | number;
+            width?: number | string;
+            wmode?: string;
+            wrap?: string;
+            about?: string;
+            datatype?: string;
+            inlist?: any;
+            prefix?: string;
+            property?: string;
+            resource?: string;
+            typeof?: string;
+            vocab?: string;
+            itemProp?: string;
+            itemScope?: boolean;
+            itemType?: string;
+            itemID?: string;
+            itemRef?: string;
+        }
+        interface IVirtualIntrinsicElements {
+        }
+        type HtmlIntrinsic = {
+            [K in keyof HTMLElementTagNameMap]: HTMLAttributes<HTMLElementTagNameMap[K]>;
+        };
+        type SvgIntrinsic = {
+            [K in keyof SVGElementTagNameMap]: SVGAttributes<SVGElementTagNameMap[K]>;
+        };
+        type SvgOnly = Omit<SvgIntrinsic, keyof HtmlIntrinsic>;
+        interface IntrinsicElements extends HtmlIntrinsic, SvgOnly, IVirtualIntrinsicElements {
+            fragment: {};
+        }
+        type Element = VNode;
+    }
+}
+type RenderNodeInput = VNode | string | undefined;
+type RenderResultNode = Element | Text | undefined;
+/**
+ * DefussChild represents any valid child element in defuss.
+ */
+type DefussChild = VNode | VNodeChild | string | number | boolean | null | undefined | DefussChild[];
+/**
+ * AsyncChild extends DefussChild to also accept async components (Promise-returning).
+ * Use this for children of the <Async> wrapper component.
+ */
+type AsyncChild = Promise<DefussChild> | DefussChild;
+type DefussChildren = DefussChild;
+type RenderInput = DefussChild;
+type DefussClassValue = string | false | DefussClassValue[];
+interface Props<NT extends DOMElement = DOMElement, ST = any> {
+    children?: DefussChildren;
+    ref?: Ref<NT, ST>;
+    key?: DefussKey;
+    /** if implemented, maps 1:1 to class attribute of the root element of the functional component */
+    className?: DefussClassValue;
+    onError?: JSX.GenericEventHandler;
+}
+type ElementProps<T extends DOMElement> = Props<T> & JSX.HTMLAttributes<T>;
+type RenderResult<T = RenderInput> = T extends Array<RenderNodeInput> ? Array<RenderResultNode> : RenderResultNode;
+type AllHTMLElements = HTMLElementTagNameMap[keyof HTMLElementTagNameMap] | SVGElementTagNameMap[keyof SVGElementTagNameMap];
+/**
+ * Functional Component type that accepts a generic Props type.
+ * Defaults to the base Props interface if no generic is provided.
+ * Supports both synchronous and asynchronous rendering.
+ *
+ * @example
+ *
+ * export interface MyComponentProps extends Props {
+ *    name: string;
+ *    age: number;
+ * }
+ *
+ * // With custom props
+ * export const MyComponent: FC<MyComponentProps> = (props) => { ... }
+ *
+ * // With default Props
+ * export const SimpleComponent: FC = (props) => { ... }
+ *
+ * // Async component
+ * export const AsyncComponent: FC = async (props) => { ... }
+ */
+type FC<P = Props> = (props: P) => JSX.Element | null;
+type AsyncFC<P = Props> = (props: P) => Promise<JSX.Element | null>;
+/**
+ * Alias for FunctionComponent
+ */
+type FunctionComponent<P = Props> = FC<P>;
+type AsyncFunctionComponent<P = Props> = AsyncFC<P>;
+
+declare const CLASS_ATTRIBUTE_NAME = "class";
+declare const XLINK_ATTRIBUTE_NAME = "xlink";
+declare const XMLNS_ATTRIBUTE_NAME = "xmlns";
+declare const REF_ATTRIBUTE_NAME = "ref";
+declare const DANGEROUSLY_SET_INNER_HTML_ATTRIBUTE = "dangerouslySetInnerHTML";
+declare const nsMap: {
+    xmlns: string;
+    xlink: string;
+    svg: string;
+};
+declare const createInPlaceErrorMessageVNode: (error: unknown) => {
+    type: string;
+    attributes: {};
+    children: string[];
+};
+declare const jsx: (type: VNodeType | Function | any, attributes: (JSX.HTMLAttributes & JSX.SVGAttributes & Record<string, any>) | null, key?: string, sourceInfo?: JsxSourceInfo) => Array<VNode> | VNode;
+declare const observeUnmount: (domNode: Node, onUnmount: () => void) => void;
+/** lifecycle event attachment has been implemented separately, because it is also required to run when partially updating the DOM */
+declare const handleLifecycleEventsForOnMount: (newEl: HTMLElement) => void;
+declare const getRenderer: (document: Document) => DomAbstractionImpl;
+declare const renderIsomorphicSync: (virtualNode: SyncRenderInput, parentDomElement: ParentElementInput, globals: Globals) => SyncRenderResult;
+declare const renderIsomorphicAsync: (virtualNode: SyncRenderInput | Promise<SyncRenderInput>, parentDomElement: ParentElementInputAsync, globals: Globals) => Promise<SyncRenderResult>;
+declare const globalScopeDomApis: (window: Window, document: Document) => void;
+/**
+ * React-compatible render function.
+ * Renders JSX content into a container element using defuss' DOM morphing engine.
+ *
+ * @example
+ * ```tsx
+ * import { render, $ } from "defuss";
+ *
+ * const App = () => <div>Hello World</div>;
+ *
+ * // Using with $ selector
+ * render(<App />, $("#app").current);
+ *
+ * // Using with direct element
+ * render(<App />, document.getElementById("app"));
+ * ```
+ */
+declare const render: (jsx: SyncRenderInput, container: Element | null | undefined) => void;
+/**
+ * @deprecated Use render instead. Will be removed in v4.
+ */
+declare const renderInto: (jsx: SyncRenderInput, container: Element | null | undefined) => void;
+declare const isJSX: (o: any) => boolean;
+declare const Fragment: (props: VNode) => DefussChild;
+declare const jsxs: (type: VNodeType | Function | any, attributes: (JSX.HTMLAttributes & JSX.SVGAttributes & Record<string, any>) | null, key?: string, sourceInfo?: JsxSourceInfo) => Array<VNode> | VNode;
+declare const jsxDEV: (type: VNodeType | Function | any, attributes: (JSX.HTMLAttributes & JSX.SVGAttributes & Record<string, any>) | null, key?: string, allChildrenAreStatic?: boolean, sourceInfo?: JsxSourceInfo, selfReference?: any) => Array<VNode> | VNode;
+declare function updateDom<NT>(input: string | RenderInput | Ref<NodeType> | NodeType | CallChainImpl<NT> | CallChainImplThenable<NT>, nodes: readonly NodeType[], timeout: number, Parser: typeof globalThis.DOMParser, transitionConfig?: TransitionConfig): Promise<readonly NodeType[]>;
+
+declare const isRef: <NT extends Node | Element | Text | null = HTMLElement, ST = any>(obj: any) => obj is Ref<NT, ST>;
+declare function createRef<NT extends DOMElement = DOMElement, ST = any>(refUpdateFn?: RefUpdateFn<ST>, defaultState?: ST): Ref<NT, ST>;
+
+export { nsMap as $, CLASS_ATTRIBUTE_NAME as W, XLINK_ATTRIBUTE_NAME as X, XMLNS_ATTRIBUTE_NAME as Y, REF_ATTRIBUTE_NAME as Z, DANGEROUSLY_SET_INNER_HTML_ATTRIBUTE as _, createInPlaceErrorMessageVNode as a0, jsx as a1, observeUnmount as a2, handleLifecycleEventsForOnMount as a3, getRenderer as a4, renderIsomorphicSync as a5, renderIsomorphicAsync as a6, globalScopeDomApis as a7, renderInto as a8, isJSX as a9, getAllFormValues as aA, delayedAutoStart as aB, dequery as aD, $ as aE, isDequery as aF, isDequeryOptionsObject as aG, getDefaultDequeryOptions as aH, mapArrayIndexAccess as aI, createCall as aJ, createSyncCall as aK, createGetterSetterCall as aL, createSubChain as aM, subChainForNextAwait as aN, runWithTimeGuard as aO, renderNode as aP, resolveNodes as aQ, traverse as aR, Fragment as aa, jsxs as ab, jsxDEV as ac, updateDom as ad, isRef as ae, createRef as af, getTransitionStyles as ak, applyStyles as al, DEFAULT_TRANSITION_CONFIG as am, performTransition as an, render as ar, Call as as, addNonChainedReturnCallNames as at, getNonChainedReturnCallNames as au, isNonChainedReturnCall as av, emptyImpl as aw, CallChainImpl as ax, CallChainImplThenable as ay, scrollHelper as az, shallowEquals as ba, deepEquals as bb, createStore as bc };
+export type { AsyncChild as A, Props as B, CSSProperties as C, DOMElement as D, ElementProps as E, FontFaceProperties as F, Globals as G, AllHTMLElements as H, FC as I, JsxRuntimeHookFn as J, KeyFrameProperties as K, AsyncFC as L, Maybe as M, NodeType as N, OneOrMany as O, ParentElementInput as P, FunctionComponent as Q, RenderInput as R, SyncRenderInput as S, AsyncFunctionComponent as T, UnmountHandler as U, VAttributes as V, RenderResult as a, DOMPropValue as a$, Dequery as aC, FormFieldValue as aS, FormKeyValues as aT, AnyEventHandler as aU, TargetOf as aV, UnionToIntersection as aW, EventMapFor as aX, EventMapForAny as aY, Dimensions as aZ, Position as a_, TransitionType as ag, TransitionStyles as ah, TransitionsEasing as ai, TransitionConfig as aj, PersistenceProviderType as ao, PersistenceProviderOptions as ap, PersistenceProviderImpl as aq, ParentElementInputAsync as b, DequeryOptions as b0, ElementCreationOptions as b1, DequerySyncMethodReturnType as b2, MiddlewareFn as b3, MemoryStorage as b4, WebStorage as b5, Listener as b6, EqualsFn as b7, StoreOptions as b8, Store as b9, SyncRenderResult as c, MountHandler as d, RefUpdateRenderFnInput as e, RefUpdateFn as f, RefUpdateRenderFn as g, Ref as h, DefussKey as i, VNodeAttributes as j, JsxSourceInfo as k, VNode as l, VNodeType as m, VNodeKey as n, VNodeRefObject as o, VNodeRefCallback as p, VNodeRef as q, VNodeChild as r, VNodeChildren as s, Children as t, DomAbstractionImpl as u, RenderNodeInput as v, RenderResultNode as w, DefussChild as x, DefussChildren as y, DefussClassValue as z };