@types/mithril

  • Version 2.2.6
  • Published
  • 34.2 kB
  • No dependencies
  • MIT license

Install

npm i @types/mithril
yarn add @types/mithril
pnpm add @types/mithril

Overview

TypeScript definitions for mithril

Index

Variables

variable Mithril

const Mithril: Mithril.Static;

    Functions

    function censor

    censor: <O extends Record<string, any>, E extends readonly string[]>(
    object: O,
    extra: E
    ) => Omit<Mithril._NoLifecycle<O>, E[number]>;
    • Returns a shallow-cloned object with lifecycle attributes and any given custom attributes omitted.

    function jsonp

    jsonp: {
    <T>(options: Mithril.JsonpOptions & { url: string }): Promise<T>;
    <T>(url: string, options?: Mithril.JsonpOptions): Promise<T>;
    };
    • Makes a JSON-P request and returns a promise.

    function mount

    mount: {
    (element: Element, component: Mithril.ComponentTypes<any, any>): void;
    (element: Element, component: null): void;
    };
    • Mounts a component to a DOM element, enabling it to autoredraw on user events.

    • Unmounts a component from a DOM element.

    function render

    render: (el: Element, vnodes: Mithril.Children) => void;
    • Renders a vnode structure into a DOM element.

    function request

    request: {
    <T>(options: Mithril.RequestOptions<T> & { url: string }): Promise<T>;
    <T>(url: string, options?: Mithril.RequestOptions<T>): Promise<T>;
    };
    • Makes an XHR request and returns a promise.

    Interfaces

    interface Attributes

    interface Attributes extends CommonAttributes<any, any> {}
    • This represents the attributes available for configuring virtual elements, beyond the applicable DOM attributes.

    property class

    class?: string | undefined;
    • The class name(s) for this virtual element, as a space-separated list.

    property className

    className?: string | undefined;
    • The class name(s) for this virtual element, as a space-separated list.

    index signature

    [property: string]: any;
    • Any other virtual element properties, including attributes and event handlers.

    interface ChildArray

    interface ChildArray extends Array<Children> {}

      interface ClassComponent

      interface ClassComponent<A = {}> {}
      • Components are a mechanism to encapsulate parts of a view to make code easier to organize and/or reuse. Any class that implements a view method can be used as a Mithril component. Components can be consumed via the m() utility.

      method onbeforeremove

      onbeforeremove: (vnode: VnodeDOM<A, this>) => Promise<any> | void;
      • The onbeforeremove hook is called before a DOM element is detached from the document. If a Promise is returned, Mithril only detaches the DOM element after the promise completes.

      method onbeforeupdate

      onbeforeupdate: (
      vnode: Vnode<A, this>,
      old: VnodeDOM<A, this>
      ) => boolean | void;
      • The onbeforeupdate hook is called before a vnode is diffed in a update.

      method oncreate

      oncreate: (vnode: VnodeDOM<A, this>) => any;
      • The oncreate hook is called after a DOM element is created and attached to the document.

      method oninit

      oninit: (vnode: Vnode<A, this>) => any;
      • The oninit hook is called before a vnode is touched by the virtual DOM engine.

      method onremove

      onremove: (vnode: VnodeDOM<A, this>) => any;
      • The onremove hook is called before a DOM element is removed from the document.

      method onupdate

      onupdate: (vnode: VnodeDOM<A, this>) => any;
      • The onupdate hook is called after a DOM element is updated, while attached to the document.

      method view

      view: (vnode: Vnode<A, this>) => Children | null | void;
      • Creates a view out of virtual elements.

      interface CommonAttributes

      interface CommonAttributes<Attrs, State> {}

        property key

        key?: string | number | undefined;
        • A key to optionally associate with this element.

        method onbeforeremove

        onbeforeremove: (
        this: State,
        vnode: VnodeDOM<Attrs, State>
        ) => Promise<any> | void;
        • The onbeforeremove hook is called before a DOM element is detached from the document. If a Promise is returned, Mithril only detaches the DOM element after the promise completes.

        method onbeforeupdate

        onbeforeupdate: (
        this: State,
        vnode: Vnode<Attrs, State>,
        old: VnodeDOM<Attrs, State>
        ) => boolean | void;
        • The onbeforeupdate hook is called before a vnode is diffed in a update.

        method oncreate

        oncreate: (this: State, vnode: VnodeDOM<Attrs, State>) => any;
        • The oncreate hook is called after a DOM element is created and attached to the document.

        method oninit

        oninit: (this: State, vnode: Vnode<Attrs, State>) => any;
        • The oninit hook is called before a vnode is touched by the virtual DOM engine.

        method onremove

        onremove: (this: State, vnode: VnodeDOM<Attrs, State>) => any;
        • The onremove hook is called before a DOM element is removed from the document.

        method onupdate

        onupdate: (this: State, vnode: VnodeDOM<Attrs, State>) => any;
        • The onupdate hook is called after a DOM element is updated, while attached to the document.

        interface Component

        interface Component<Attrs = {}, State = {}> {}
        • Components are a mechanism to encapsulate parts of a view to make code easier to organize and/or reuse. Any Javascript object that has a view method can be used as a Mithril component. Components can be consumed via the m() utility.

        method onbeforeremove

        onbeforeremove: (
        this: _NoLifecycle<this & State>,
        vnode: VnodeDOM<Attrs, _NoLifecycle<this & State>>
        ) => Promise<any> | void;
        • The onbeforeremove hook is called before a DOM element is detached from the document. If a Promise is returned, Mithril only detaches the DOM element after the promise completes.

        method onbeforeupdate

        onbeforeupdate: (
        this: _NoLifecycle<this & State>,
        vnode: Vnode<Attrs, _NoLifecycle<this & State>>,
        old: VnodeDOM<Attrs, _NoLifecycle<this & State>>
        ) => boolean | void;
        • The onbeforeupdate hook is called before a vnode is diffed in a update.

        method oncreate

        oncreate: (
        this: _NoLifecycle<this & State>,
        vnode: VnodeDOM<Attrs, _NoLifecycle<this & State>>
        ) => any;
        • The oncreate hook is called after a DOM element is created and attached to the document.

        method oninit

        oninit: (
        this: _NoLifecycle<this & State>,
        vnode: Vnode<Attrs, _NoLifecycle<this & State>>
        ) => any;
        • The oninit hook is called before a vnode is touched by the virtual DOM engine.

        method onremove

        onremove: (
        this: _NoLifecycle<this & State>,
        vnode: VnodeDOM<Attrs, _NoLifecycle<this & State>>
        ) => any;
        • The onremove hook is called before a DOM element is removed from the document.

        method onupdate

        onupdate: (
        this: _NoLifecycle<this & State>,
        vnode: VnodeDOM<Attrs, _NoLifecycle<this & State>>
        ) => any;
        • The onupdate hook is called after a DOM element is updated, while attached to the document.

        method view

        view: (
        this: _NoLifecycle<this & State>,
        vnode: Vnode<Attrs, _NoLifecycle<this & State>>
        ) => Children | null | void;
        • Creates a view out of virtual elements.

        interface CVnode

        interface CVnode<A = {}> extends Vnode<A, ClassComponent<A>> {}

          interface CVnodeDOM

          interface CVnodeDOM<A = {}> extends VnodeDOM<A, ClassComponent<A>> {}

            interface Hyperscript

            interface Hyperscript {}

              method fragment

              fragment: (
              attrs: CommonAttributes<any, any> & { [key: string]: any },
              children: ChildArrayOrPrimitive
              ) => Vnode<any, any>;
              • Creates a fragment virtual element (Vnode).

              method trust

              trust: (html: string) => Vnode<any, any>;
              • Turns an HTML string into a virtual element (Vnode). Do not use trust on unsanitized user input.

              call signature

              <Attrs, State>(
              component: ComponentTypes<Attrs, State>,
              attributes: Attrs & CommonAttributes<Attrs, State>,
              ...args: Children[]
              ): Vnode<Attrs, State>;
              • Creates a virtual element (Vnode).

              call signature

              (selector: string, attributes: Attributes, ...children: Children[]): Vnode<
              any,
              any
              >;
              • Creates a virtual element (Vnode).

              call signature

              <Attrs, State>(
              component: ComponentTypes<Attrs, State>,
              ...args: Children[]
              ): Vnode<Attrs, State>;
              • Creates a virtual element (Vnode).

              call signature

              (selector: string, ...children: Children[]): Vnode<any, any>;
              • Creates a virtual element (Vnode).

              interface JsonpOptions

              interface JsonpOptions {}

                property background

                background?: boolean | undefined;
                • If false, redraws mounted components upon completion of the request. If true, it does not.

                property body

                body?: any;
                • The data to be serialized into the request body.

                property callbackKey

                callbackKey?: string | undefined;
                • The name of the querystring parameter name that specifies the callback name.

                property callbackName

                callbackName?: string | undefined;
                • The name of the function that will be called as the callback.

                property params

                params?: { [id: string]: any } | undefined;
                • The data to be interpolated into the URL and serialized into the querystring.

                property type

                type?: new (o: any) => any;
                • A constructor to be applied to each object in the response.

                interface ParamsRec

                interface ParamsRec {}

                  index signature

                  [key: string]: string | number | boolean | null | undefined | Params;

                    interface Redraw

                    interface Redraw {}

                      method sync

                      sync: () => void;
                      • Manually triggers a synchronous redraw of mounted components.

                      call signature

                      (): void;
                      • Manually triggers an asynchronous redraw of mounted components.

                      interface RequestOptions

                      interface RequestOptions<T> {}

                        property async

                        async?: boolean | undefined;
                        • Whether the request should be asynchronous. Defaults to true.

                        property background

                        background?: boolean | undefined;
                        • If false, redraws mounted components upon completion of the request. If true, it does not.

                        property body

                        body?:
                        | (XMLHttpRequest['send'] extends (x: infer R) => any ? R : never)
                        | (object & { [id: string]: any })
                        | undefined;
                        • The data to be serialized into the request body.

                        property headers

                        headers?: { [key: string]: string } | undefined;
                        • Headers to append to the request before sending it.

                        property method

                        method?: string | undefined;
                        • The HTTP method to use.

                        property params

                        params?: { [key: string]: any } | undefined;
                        • The data to be interpolated into the URL and serialized into the querystring.

                        property password

                        password?: string | undefined;
                        • A password for HTTP authorization.

                        property responseType

                        responseType?:
                        | ''
                        | 'arraybuffer'
                        | 'blob'
                        | 'document'
                        | 'json'
                        | 'text'
                        | undefined;
                        • The expected type of the response, as a legal value of XMLHttpRequest.responseType.

                        property timeout

                        timeout?: number | undefined;
                        • Milliseconds a request can take before automatically being terminated.

                        property type

                        type?: new (o: any) => any;
                        • A constructor to be applied to each object in the response.

                        property useBody

                        useBody?: boolean | undefined;
                        • Force the use of the HTTP body section for data in GET requests when set to true, or the use of querystring for other HTTP methods when set to false. Defaults to false for GET requests and true for other methods.

                        property user

                        user?: string | undefined;
                        • A username for HTTP authorization.

                        property withCredentials

                        withCredentials?: boolean | undefined;
                        • Whether to send cookies to 3rd party domains.

                        method config

                        config: (xhr: XMLHttpRequest, options: this) => XMLHttpRequest | void;
                        • Exposes the underlying XMLHttpRequest object for low-level configuration.

                        method deserialize

                        deserialize: (data: string) => T;
                        • A deserialization method to be applied to the response. Defaults to a small wrapper around JSON.parse that returns null for empty responses.

                        method extract

                        extract: (xhr: XMLHttpRequest, options: this) => T;
                        • A hook to specify how the XMLHttpRequest response should be read. Useful for reading response headers and cookies. Defaults to a function that returns xhr.responseText

                        method serialize

                        serialize: (data: any) => any;
                        • A serialization method to be applied to data. Defaults to JSON.stringify, or if options.data is an instance of FormData, defaults to the identity function.

                        interface Route

                        interface Route {}
                          Link: Component<RouteLinkAttrs>;
                          • This Component renders a link <a href> that will use the current routing strategy

                          property prefix

                          prefix: string;
                          • Defines a router prefix which is a fragment of the URL that dictates the underlying strategy used by the router.

                          property SKIP

                          SKIP: any;
                          • Special value to SKIP current route

                          method get

                          get: () => string;
                          • Returns the last fully resolved routing path, without the prefix.

                          method param

                          param: { (name: string): string; (): any };
                          • Returns the named parameter value from the current route.

                          • Gets all route parameters.

                          method set

                          set: (route: string, data?: any, options?: RouteOptions) => void;
                          • Redirects to a matching route or to the default route if no matching routes can be found.

                          call signature

                          (element: Element, defaultRoute: string, routes: RouteDefs): void;
                          • Creates application routes and mounts Components and/or RouteResolvers to a DOM element.

                          interface RouteDefs

                          interface RouteDefs {}
                          • This represents a key-value mapping linking routes to components.

                          index signature

                          [url: string]: ComponentTypes<any, any> | RouteResolver<any, any>;
                          • The key represents the route. The value represents the corresponding component.

                          interface RouteLinkAttrs

                          interface RouteLinkAttrs extends Attributes {}

                            property href

                            href: string;

                              property options

                              options?: RouteOptions | undefined;

                                property selector

                                selector?: string | ComponentTypes<any> | undefined;

                                  interface RouteOptions

                                  interface RouteOptions {}

                                    property replace

                                    replace?: boolean | undefined;
                                    • Routing parameters. If path has routing parameter slots, the properties of this object are interpolated into the path string.

                                    property state

                                    state?: any;
                                    • The state object to pass to the underlying history.pushState / history.replaceState call.

                                    property title

                                    title?: string | undefined;
                                    • The title string to pass to the underlying history.pushState / history.replaceState call.

                                    interface RouteResolver

                                    interface RouteResolver<Attrs = {}, State = {}> {}

                                      method onmatch

                                      onmatch: (
                                      this: this,
                                      args: Attrs,
                                      requestedPath: string,
                                      route: string
                                      ) => ComponentTypes<any, any> | Promise<any> | void;
                                      • The onmatch hook is called when the router needs to find a component to render.

                                      method render

                                      render: (this: this, vnode: Vnode<Attrs, State>) => Children;
                                      • The render method is called on every redraw for a matching route.

                                      interface Static

                                      interface Static extends Hyperscript {}

                                        property censor

                                        censor: typeof censor;

                                          property jsonp

                                          jsonp: typeof jsonp;

                                            property mount

                                            mount: typeof mount;

                                              property redraw

                                              redraw: Redraw;

                                                property render

                                                render: typeof render;

                                                  property request

                                                  request: typeof request;

                                                    property route

                                                    route: Route;

                                                      method buildPathname

                                                      buildPathname: (template: string, params?: Params) => string;
                                                      • Build path name

                                                      method buildQueryString

                                                      buildQueryString: (values: Params) => string;
                                                      • Turns the key/value pairs of an object into a string of the form: a=1&b=2

                                                      method parsePathname

                                                      parsePathname: (url: string) => { path: string; params: Params };
                                                      • Parse path name

                                                      method parseQueryString

                                                      parseQueryString: (queryString: string) => Params;
                                                      • Returns an object with key/value pairs parsed from a string of the form: ?a=1&b=2

                                                      interface Vnode

                                                      interface Vnode<Attrs = {}, State = {}> {}
                                                      • Virtual DOM nodes, or vnodes, are Javascript objects that represent an element (or parts of the DOM).

                                                      property attrs

                                                      attrs: Attrs;
                                                      • A hashmap of DOM attributes, events, properties and lifecycle methods.

                                                      property children

                                                      children?: ChildArrayOrPrimitive | undefined;
                                                      • In most vnode types, the children property is an array of vnodes. For text and trusted HTML vnodes, The children property is either a string, a number or a boolean.

                                                      property key

                                                      key?: string | number | undefined;
                                                      • The value used to map a DOM element to its respective item in an array of data.

                                                      property state

                                                      state: State;
                                                      • An object that is persisted between redraws. In component vnodes, state is a shallow clone of the component object.

                                                      property tag

                                                      tag: string | ComponentTypes<Attrs, State>;
                                                      • The nodeName of a DOM element. It may also be the string [ if a vnode is a fragment, # if it's a text vnode, or < if it's a trusted HTML vnode. Additionally, it may be a component.

                                                      property text

                                                      text?: string | number | boolean | undefined;
                                                      • This is used instead of children if a vnode contains a text node as its only child. This is done for performance reasons. Component vnodes never use the text property even if they have a text node as their only child.

                                                      interface VnodeDOM

                                                      interface VnodeDOM<Attrs = {}, State = {}> extends Vnode<Attrs, State> {}

                                                        property dom

                                                        dom: Element;
                                                        • Points to the element that corresponds to the vnode.

                                                        property domSize

                                                        domSize?: number | undefined;
                                                        • This defines the number of DOM elements that the vnode represents (starting from the element referenced by the dom property).

                                                        Type Aliases

                                                        type Child

                                                        type Child = Vnode<any, any> | string | number | boolean | null | undefined;

                                                          type ChildArrayOrPrimitive

                                                          type ChildArrayOrPrimitive = ChildArray | string | number | boolean;

                                                            type Children

                                                            type Children = Child | ChildArray;

                                                              type ClosureComponent

                                                              type ClosureComponent<A = {}> = FactoryComponent<A>;
                                                              • Components are a mechanism to encapsulate parts of a view to make code easier to organize and/or reuse. Any function that returns an object with a view method can be used as a Mithril component. Components can be consumed via the m() utility.

                                                              type Comp

                                                              type Comp<Attrs = {}, State = {}> = _NoLifecycle<State> &
                                                              Component<Attrs, _NoLifecycle<State>>;
                                                              • Components are a mechanism to encapsulate parts of a view to make code easier to organize and/or reuse. Any Javascript object that has a view method is a Mithril component. Components can be consumed via the m() utility.

                                                              type ComponentTypes

                                                              type ComponentTypes<A = {}, S = {}> =
                                                              | Component<A, S>
                                                              | { new (vnode: CVnode<A>): ClassComponent<A> }
                                                              | FactoryComponent<A>;
                                                              • Components are a mechanism to encapsulate parts of a view to make code easier to organize and/or reuse. Components can be consumed via the m() utility.

                                                              type FactoryComponent

                                                              type FactoryComponent<A = {}> = (vnode: Vnode<A>) => Component<A>;
                                                              • Components are a mechanism to encapsulate parts of a view to make code easier to organize and/or reuse. Any function that returns an object with a view method can be used as a Mithril component. Components can be consumed via the m() utility.

                                                              type Params

                                                              type Params = object & ParamsRec;

                                                                Namespaces

                                                                namespace global

                                                                namespace global {}

                                                                  namespace global.JSX

                                                                  namespace global.JSX {}

                                                                    interface Element

                                                                    interface Element extends Mithril.Vnode {}

                                                                      interface IntrinsicAttributes

                                                                      interface IntrinsicAttributes extends Mithril.Attributes {}

                                                                        property children

                                                                        children?: Mithril.Children | HTMLCollection;

                                                                          interface IntrinsicClassAttributes

                                                                          interface IntrinsicClassAttributes extends Mithril.Attributes {}

                                                                            interface IntrinsicElements

                                                                            interface IntrinsicElements {}

                                                                              property "["

                                                                              '[': Mithril.Attributes;

                                                                                property a

                                                                                a: Mithril.Attributes;

                                                                                  property abbr

                                                                                  abbr: Mithril.Attributes;

                                                                                    property address

                                                                                    address: Mithril.Attributes;

                                                                                      property animate

                                                                                      animate: Mithril.Attributes;

                                                                                        property animateMotion

                                                                                        animateMotion: Mithril.Attributes;

                                                                                          property animateTransform

                                                                                          animateTransform: Mithril.Attributes;

                                                                                            property area

                                                                                            area: Mithril.Attributes;

                                                                                              property article

                                                                                              article: Mithril.Attributes;

                                                                                                property aside

                                                                                                aside: Mithril.Attributes;

                                                                                                  property audio

                                                                                                  audio: Mithril.Attributes;

                                                                                                    property b

                                                                                                    b: Mithril.Attributes;

                                                                                                      property base

                                                                                                      base: Mithril.Attributes;

                                                                                                        property bdi

                                                                                                        bdi: Mithril.Attributes;

                                                                                                          property bdo

                                                                                                          bdo: Mithril.Attributes;

                                                                                                            property big

                                                                                                            big: Mithril.Attributes;

                                                                                                              property blockquote

                                                                                                              blockquote: Mithril.Attributes;

                                                                                                                property body

                                                                                                                body: Mithril.Attributes;

                                                                                                                  property br

                                                                                                                  br: Mithril.Attributes;

                                                                                                                    property button

                                                                                                                    button: Mithril.Attributes;

                                                                                                                      property canvas

                                                                                                                      canvas: Mithril.Attributes;

                                                                                                                        property caption

                                                                                                                        caption: Mithril.Attributes;

                                                                                                                          property circle

                                                                                                                          circle: Mithril.Attributes;

                                                                                                                            property cite

                                                                                                                            cite: Mithril.Attributes;

                                                                                                                              property clipPath

                                                                                                                              clipPath: Mithril.Attributes;

                                                                                                                                property code

                                                                                                                                code: Mithril.Attributes;

                                                                                                                                  property col

                                                                                                                                  col: Mithril.Attributes;

                                                                                                                                    property colgroup

                                                                                                                                    colgroup: Mithril.Attributes;

                                                                                                                                      property data

                                                                                                                                      data: Mithril.Attributes;

                                                                                                                                        property datalist

                                                                                                                                        datalist: Mithril.Attributes;

                                                                                                                                          property dd

                                                                                                                                          dd: Mithril.Attributes;

                                                                                                                                            property defs

                                                                                                                                            defs: Mithril.Attributes;

                                                                                                                                              property del

                                                                                                                                              del: Mithril.Attributes;

                                                                                                                                                property desc

                                                                                                                                                desc: Mithril.Attributes;

                                                                                                                                                  property details

                                                                                                                                                  details: Mithril.Attributes;

                                                                                                                                                    property dfn

                                                                                                                                                    dfn: Mithril.Attributes;

                                                                                                                                                      property dialog

                                                                                                                                                      dialog: Mithril.Attributes;

                                                                                                                                                        property div

                                                                                                                                                        div: Mithril.Attributes;

                                                                                                                                                          property dl

                                                                                                                                                          dl: Mithril.Attributes;

                                                                                                                                                            property dt

                                                                                                                                                            dt: Mithril.Attributes;

                                                                                                                                                              property ellipse

                                                                                                                                                              ellipse: Mithril.Attributes;

                                                                                                                                                                property em

                                                                                                                                                                em: Mithril.Attributes;

                                                                                                                                                                  property embed

                                                                                                                                                                  embed: Mithril.Attributes;

                                                                                                                                                                    property feBlend

                                                                                                                                                                    feBlend: Mithril.Attributes;

                                                                                                                                                                      property feColorMatrix

                                                                                                                                                                      feColorMatrix: Mithril.Attributes;

                                                                                                                                                                        property feComponentTransfer

                                                                                                                                                                        feComponentTransfer: Mithril.Attributes;

                                                                                                                                                                          property feComposite

                                                                                                                                                                          feComposite: Mithril.Attributes;

                                                                                                                                                                            property feConvolveMatrix

                                                                                                                                                                            feConvolveMatrix: Mithril.Attributes;

                                                                                                                                                                              property feDiffuseLighting

                                                                                                                                                                              feDiffuseLighting: Mithril.Attributes;

                                                                                                                                                                                property feDisplacementMap

                                                                                                                                                                                feDisplacementMap: Mithril.Attributes;

                                                                                                                                                                                  property feDistantLight

                                                                                                                                                                                  feDistantLight: Mithril.Attributes;

                                                                                                                                                                                    property feDropShadow

                                                                                                                                                                                    feDropShadow: Mithril.Attributes;

                                                                                                                                                                                      property feFlood

                                                                                                                                                                                      feFlood: Mithril.Attributes;

                                                                                                                                                                                        property feFuncA

                                                                                                                                                                                        feFuncA: Mithril.Attributes;

                                                                                                                                                                                          property feFuncB

                                                                                                                                                                                          feFuncB: Mithril.Attributes;

                                                                                                                                                                                            property feFuncG

                                                                                                                                                                                            feFuncG: Mithril.Attributes;

                                                                                                                                                                                              property feFuncR

                                                                                                                                                                                              feFuncR: Mithril.Attributes;

                                                                                                                                                                                                property feGaussianBlur

                                                                                                                                                                                                feGaussianBlur: Mithril.Attributes;

                                                                                                                                                                                                  property feImage

                                                                                                                                                                                                  feImage: Mithril.Attributes;

                                                                                                                                                                                                    property feMerge

                                                                                                                                                                                                    feMerge: Mithril.Attributes;

                                                                                                                                                                                                      property feMergeNode

                                                                                                                                                                                                      feMergeNode: Mithril.Attributes;

                                                                                                                                                                                                        property feMorphology

                                                                                                                                                                                                        feMorphology: Mithril.Attributes;

                                                                                                                                                                                                          property feOffset

                                                                                                                                                                                                          feOffset: Mithril.Attributes;

                                                                                                                                                                                                            property fePointLight

                                                                                                                                                                                                            fePointLight: Mithril.Attributes;

                                                                                                                                                                                                              property feSpecularLighting

                                                                                                                                                                                                              feSpecularLighting: Mithril.Attributes;

                                                                                                                                                                                                                property feSpotLight

                                                                                                                                                                                                                feSpotLight: Mithril.Attributes;

                                                                                                                                                                                                                  property feTile

                                                                                                                                                                                                                  feTile: Mithril.Attributes;

                                                                                                                                                                                                                    property feTurbulence

                                                                                                                                                                                                                    feTurbulence: Mithril.Attributes;

                                                                                                                                                                                                                      property fieldset

                                                                                                                                                                                                                      fieldset: Mithril.Attributes;

                                                                                                                                                                                                                        property figcaption

                                                                                                                                                                                                                        figcaption: Mithril.Attributes;

                                                                                                                                                                                                                          property figure

                                                                                                                                                                                                                          figure: Mithril.Attributes;

                                                                                                                                                                                                                            property filter

                                                                                                                                                                                                                            filter: Mithril.Attributes;

                                                                                                                                                                                                                              property footer

                                                                                                                                                                                                                              footer: Mithril.Attributes;

                                                                                                                                                                                                                                property foreignObject

                                                                                                                                                                                                                                foreignObject: Mithril.Attributes;

                                                                                                                                                                                                                                  property form

                                                                                                                                                                                                                                  form: Mithril.Attributes;

                                                                                                                                                                                                                                    property g

                                                                                                                                                                                                                                    g: Mithril.Attributes;

                                                                                                                                                                                                                                      property h1

                                                                                                                                                                                                                                      h1: Mithril.Attributes;

                                                                                                                                                                                                                                        property h2

                                                                                                                                                                                                                                        h2: Mithril.Attributes;

                                                                                                                                                                                                                                          property h3

                                                                                                                                                                                                                                          h3: Mithril.Attributes;

                                                                                                                                                                                                                                            property h4

                                                                                                                                                                                                                                            h4: Mithril.Attributes;

                                                                                                                                                                                                                                              property h5

                                                                                                                                                                                                                                              h5: Mithril.Attributes;

                                                                                                                                                                                                                                                property h6

                                                                                                                                                                                                                                                h6: Mithril.Attributes;

                                                                                                                                                                                                                                                  property head

                                                                                                                                                                                                                                                  head: Mithril.Attributes;

                                                                                                                                                                                                                                                    property header

                                                                                                                                                                                                                                                    header: Mithril.Attributes;

                                                                                                                                                                                                                                                      property hgroup

                                                                                                                                                                                                                                                      hgroup: Mithril.Attributes;

                                                                                                                                                                                                                                                        property hr

                                                                                                                                                                                                                                                        hr: Mithril.Attributes;

                                                                                                                                                                                                                                                          property html

                                                                                                                                                                                                                                                          html: Mithril.Attributes;

                                                                                                                                                                                                                                                            property i

                                                                                                                                                                                                                                                            i: Mithril.Attributes;

                                                                                                                                                                                                                                                              property iframe

                                                                                                                                                                                                                                                              iframe: Mithril.Attributes;

                                                                                                                                                                                                                                                                property image

                                                                                                                                                                                                                                                                image: Mithril.Attributes;

                                                                                                                                                                                                                                                                  property img

                                                                                                                                                                                                                                                                  img: Mithril.Attributes;

                                                                                                                                                                                                                                                                    property input

                                                                                                                                                                                                                                                                    input: Mithril.Attributes;

                                                                                                                                                                                                                                                                      property ins

                                                                                                                                                                                                                                                                      ins: Mithril.Attributes;

                                                                                                                                                                                                                                                                        property kbd

                                                                                                                                                                                                                                                                        kbd: Mithril.Attributes;

                                                                                                                                                                                                                                                                          property keygen

                                                                                                                                                                                                                                                                          keygen: Mithril.Attributes;

                                                                                                                                                                                                                                                                            property label

                                                                                                                                                                                                                                                                            label: Mithril.Attributes;

                                                                                                                                                                                                                                                                              property legend

                                                                                                                                                                                                                                                                              legend: Mithril.Attributes;

                                                                                                                                                                                                                                                                                property li

                                                                                                                                                                                                                                                                                li: Mithril.Attributes;

                                                                                                                                                                                                                                                                                  property line

                                                                                                                                                                                                                                                                                  line: Mithril.Attributes;

                                                                                                                                                                                                                                                                                    property linearGradient

                                                                                                                                                                                                                                                                                    linearGradient: Mithril.Attributes;
                                                                                                                                                                                                                                                                                      link: Mithril.Attributes;

                                                                                                                                                                                                                                                                                        property main

                                                                                                                                                                                                                                                                                        main: Mithril.Attributes;

                                                                                                                                                                                                                                                                                          property map

                                                                                                                                                                                                                                                                                          map: Mithril.Attributes;

                                                                                                                                                                                                                                                                                            property mark

                                                                                                                                                                                                                                                                                            mark: Mithril.Attributes;

                                                                                                                                                                                                                                                                                              property marker

                                                                                                                                                                                                                                                                                              marker: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                property mask

                                                                                                                                                                                                                                                                                                mask: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                  property menu

                                                                                                                                                                                                                                                                                                  menu: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                    property menuitem

                                                                                                                                                                                                                                                                                                    menuitem: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                      property meta

                                                                                                                                                                                                                                                                                                      meta: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                        property metadata

                                                                                                                                                                                                                                                                                                        metadata: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                          property meter

                                                                                                                                                                                                                                                                                                          meter: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                            property mpath

                                                                                                                                                                                                                                                                                                            mpath: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                              property nav

                                                                                                                                                                                                                                                                                                              nav: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                property noindex

                                                                                                                                                                                                                                                                                                                noindex: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                  property noscript

                                                                                                                                                                                                                                                                                                                  noscript: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                    property object

                                                                                                                                                                                                                                                                                                                    object: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                      property ol

                                                                                                                                                                                                                                                                                                                      ol: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                        property optgroup

                                                                                                                                                                                                                                                                                                                        optgroup: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                          property option

                                                                                                                                                                                                                                                                                                                          option: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                            property output

                                                                                                                                                                                                                                                                                                                            output: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                              property p

                                                                                                                                                                                                                                                                                                                              p: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                property param

                                                                                                                                                                                                                                                                                                                                param: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                  property path

                                                                                                                                                                                                                                                                                                                                  path: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                    property pattern

                                                                                                                                                                                                                                                                                                                                    pattern: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                      property picture

                                                                                                                                                                                                                                                                                                                                      picture: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                        property polygon

                                                                                                                                                                                                                                                                                                                                        polygon: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                          property polyline

                                                                                                                                                                                                                                                                                                                                          polyline: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                            property pre

                                                                                                                                                                                                                                                                                                                                            pre: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                              property progress

                                                                                                                                                                                                                                                                                                                                              progress: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                property q

                                                                                                                                                                                                                                                                                                                                                q: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                  property radialGradient

                                                                                                                                                                                                                                                                                                                                                  radialGradient: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                    property rect

                                                                                                                                                                                                                                                                                                                                                    rect: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                      property rp

                                                                                                                                                                                                                                                                                                                                                      rp: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                        property rt

                                                                                                                                                                                                                                                                                                                                                        rt: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                          property ruby

                                                                                                                                                                                                                                                                                                                                                          ruby: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                            property s

                                                                                                                                                                                                                                                                                                                                                            s: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                              property samp

                                                                                                                                                                                                                                                                                                                                                              samp: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                                property script

                                                                                                                                                                                                                                                                                                                                                                script: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                                  property section

                                                                                                                                                                                                                                                                                                                                                                  section: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                                    property select

                                                                                                                                                                                                                                                                                                                                                                    select: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                                      property small

                                                                                                                                                                                                                                                                                                                                                                      small: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                                        property source

                                                                                                                                                                                                                                                                                                                                                                        source: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                                          property span

                                                                                                                                                                                                                                                                                                                                                                          span: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                                            property stop

                                                                                                                                                                                                                                                                                                                                                                            stop: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                                              property strong

                                                                                                                                                                                                                                                                                                                                                                              strong: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                                                property style

                                                                                                                                                                                                                                                                                                                                                                                style: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                                                  property sub

                                                                                                                                                                                                                                                                                                                                                                                  sub: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                                                    property summary

                                                                                                                                                                                                                                                                                                                                                                                    summary: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                                                      property sup

                                                                                                                                                                                                                                                                                                                                                                                      sup: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                                                        property svg

                                                                                                                                                                                                                                                                                                                                                                                        svg: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                                                          property switch

                                                                                                                                                                                                                                                                                                                                                                                          switch: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                                                            property symbol

                                                                                                                                                                                                                                                                                                                                                                                            symbol: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                                                              property table

                                                                                                                                                                                                                                                                                                                                                                                              table: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                                                                property tbody

                                                                                                                                                                                                                                                                                                                                                                                                tbody: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                                                                  property td

                                                                                                                                                                                                                                                                                                                                                                                                  td: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                                                                    property template

                                                                                                                                                                                                                                                                                                                                                                                                    template: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                                                                      property text

                                                                                                                                                                                                                                                                                                                                                                                                      text: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                                                                        property textarea

                                                                                                                                                                                                                                                                                                                                                                                                        textarea: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                                                                          property textPath

                                                                                                                                                                                                                                                                                                                                                                                                          textPath: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                                                                            property tfoot

                                                                                                                                                                                                                                                                                                                                                                                                            tfoot: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                                                                              property th

                                                                                                                                                                                                                                                                                                                                                                                                              th: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                                                                                property thead

                                                                                                                                                                                                                                                                                                                                                                                                                thead: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                                                                                  property time

                                                                                                                                                                                                                                                                                                                                                                                                                  time: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                                                                                    property title

                                                                                                                                                                                                                                                                                                                                                                                                                    title: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                                                                                      property tr

                                                                                                                                                                                                                                                                                                                                                                                                                      tr: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                                                                                        property track

                                                                                                                                                                                                                                                                                                                                                                                                                        track: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                                                                                          property tspan

                                                                                                                                                                                                                                                                                                                                                                                                                          tspan: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                                                                                            property u

                                                                                                                                                                                                                                                                                                                                                                                                                            u: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                                                                                              property ul

                                                                                                                                                                                                                                                                                                                                                                                                                              ul: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                                                                                                property use

                                                                                                                                                                                                                                                                                                                                                                                                                                use: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                                                                                                  property var

                                                                                                                                                                                                                                                                                                                                                                                                                                  var: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                                                                                                    property video

                                                                                                                                                                                                                                                                                                                                                                                                                                    video: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                                                                                                      property view

                                                                                                                                                                                                                                                                                                                                                                                                                                      view: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                                                                                                        property wbr

                                                                                                                                                                                                                                                                                                                                                                                                                                        wbr: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                                                                                                          property webview

                                                                                                                                                                                                                                                                                                                                                                                                                                          webview: Mithril.Attributes;

                                                                                                                                                                                                                                                                                                                                                                                                                                            Package Files (1)

                                                                                                                                                                                                                                                                                                                                                                                                                                            Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                            No dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                                            Dev Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                            No dev dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                                            Peer Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                            No peer dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                                            Badge

                                                                                                                                                                                                                                                                                                                                                                                                                                            To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                                                                                                                                                                                                                                                                                                                                            You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@types/mithril.

                                                                                                                                                                                                                                                                                                                                                                                                                                            • Markdown
                                                                                                                                                                                                                                                                                                                                                                                                                                              [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@types/mithril)
                                                                                                                                                                                                                                                                                                                                                                                                                                            • HTML
                                                                                                                                                                                                                                                                                                                                                                                                                                              <a href="https://www.jsdocs.io/package/@types/mithril"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>