[
    {
        "name": "VirtualDom",
        "comment": " API to the core diffing algorithm. Can serve as a foundation for libraries\nthat expose more helper functions for HTML or SVG.\n\n# Create\n@docs Node, text, node\n\n# Declare Properties and Attributes\n@docs Property, property, attribute, attributeNS\n\n# Styles\n@docs style\n\n# Events\n@docs on, onWithOptions, Options, defaultOptions\n\n# Routing Messages\n@docs map\n\n# Optimizations\n@docs lazy, lazy2, lazy3\n\n# Programs\n@docs programWithFlags\n\n",
        "unions": [
            {
                "name": "Node",
                "comment": " An immutable chunk of data representing a DOM node. This can be HTML or SVG.\n",
                "args": [
                    "msg"
                ],
                "cases": []
            },
            {
                "name": "Property",
                "comment": " When using HTML and JS, there are two ways to specify parts of a DOM node.\n\n  1. Attributes &mdash; You can set things in HTML itself. So the `class`\n     in `<div class=\"greeting\"></div>` is called an *attribute*.\n\n  2. Properties &mdash; You can also set things in JS. So the `className`\n     in `div.className = 'greeting'` is called a *property*.\n\nSo the `class` attribute corresponds to the `className` property. At first\nglance, perhaps this distinction is defensible, but it gets much crazier.\n*There is not always a one-to-one mapping between attributes and properties!*\nYes, that is a true fact. Sometimes an attribute exists, but there is no\ncorresponding property. Sometimes changing an attribute does not change the\nunderlying property. For example, as of this writing, the `webkit-playsinline`\nattribute can be used in HTML, but there is no corresponding property!\n",
                "args": [
                    "msg"
                ],
                "cases": []
            }
        ],
        "aliases": [
            {
                "name": "Options",
                "comment": " Options for an event listener. If `stopPropagation` is true, it means the\nevent stops traveling through the DOM so it will not trigger any other event\nlisteners. If `preventDefault` is true, any built-in browser behavior related\nto the event is prevented. For example, this is used with touch events when you\nwant to treat them as gestures of your own, not as scrolls.\n",
                "args": [],
                "type": "{ stopPropagation : Bool, preventDefault : Bool }"
            }
        ],
        "values": [
            {
                "name": "attribute",
                "comment": " Create arbitrary HTML *attributes*. Maps onto JavaScript’s `setAttribute`\nfunction under the hood.\n\n    greeting : Html\n    greeting =\n        node \"div\" [ attribute \"class\" \"greeting\" ] [\n          text \"Hello!\"\n        ]\n\nNotice that you must give the *attribute* name, so we use `class` as it would\nbe in HTML, not `className` as it would appear in JS.\n",
                "type": "String -> String -> Property msg"
            },
            {
                "name": "attributeNS",
                "comment": " Would you believe that there is another way to do this?! This corresponds\nto JavaScript's `setAttributeNS` function under the hood. It is doing pretty\nmuch the same thing as `attribute` but you are able to have \"namespaced\"\nattributes. This is used in some SVG stuff at least.\n",
                "type": "String -> String -> String -> Property msg"
            },
            {
                "name": "defaultOptions",
                "comment": " Everything is `False` by default.\n\n    defaultOptions =\n        { stopPropagation = False\n        , preventDefault = False\n        }\n",
                "type": "Options"
            },
            {
                "name": "lazy",
                "comment": " A performance optimization that delays the building of virtual DOM nodes.\n\nCalling `(view model)` will definitely build some virtual DOM, perhaps a lot of\nit. Calling `(lazy view model)` delays the call until later. During diffing, we\ncan check to see if `model` is referentially equal to the previous value used,\nand if so, we just stop. No need to build up the tree structure and diff it,\nwe know if the input to `view` is the same, the output must be the same!\n",
                "type": "(a -> Node msg) -> a -> Node msg"
            },
            {
                "name": "lazy2",
                "comment": " Same as `lazy` but checks on two arguments.\n",
                "type": "(a -> b -> Node msg) -> a -> b -> Node msg"
            },
            {
                "name": "lazy3",
                "comment": " Same as `lazy` but checks on three arguments.\n",
                "type": "(a -> b -> c -> Node msg) -> a -> b -> c -> Node msg"
            },
            {
                "name": "map",
                "comment": " This function is useful when nesting components with [the Elm\nArchitecture](https://github.com/evancz/elm-architecture-tutorial/). It lets\nyou transform the messages produced by a subtree.\n\nSay you have a node named `button` that produces `()` values when it is\nclicked. To get your model updating properly, you will probably want to tag\nthis `()` value like this:\n\n    type Msg = Click | ...\n\n    update msg model =\n      case msg of\n        Click ->\n          ...\n\n    view model =\n      map (\\_ -> Click) button\n\nSo now all the events produced by `button` will be transformed to be of type\n`Msg` so they can be handled by your update function!\n",
                "type": "(a -> msg) -> Node a -> Node msg"
            },
            {
                "name": "node",
                "comment": " Create a DOM node with a tag name, a list of HTML properties that can\ninclude styles and event listeners, a list of CSS properties like `color`, and\na list of child nodes.\n\n    import Json.Encode as Json\n\n    hello : Node msg\n    hello =\n      node \"div\" [] [ text \"Hello!\" ]\n\n    greeting : Node msg\n    greeting =\n      node \"div\"\n        [ property \"id\" (Json.string \"greeting\") ]\n        [ text \"Hello!\" ]\n",
                "type": "String -> List (Property msg) -> List (Node msg) -> Node msg"
            },
            {
                "name": "on",
                "comment": " Create a custom event listener.\n\n    import Json.Decode as Json\n\n    onClick : msg -> Property msg\n    onClick msg =\n      on \"click\" (Json.succeed msg)\n\nYou first specify the name of the event in the same format as with JavaScript’s\n`addEventListener`. Next you give a JSON decoder, which lets you pull\ninformation out of the event object. If the decoder succeeds, it will produce\na message and route it to your `update` function.\n",
                "type": "String -> Decoder msg -> Property msg"
            },
            {
                "name": "onWithOptions",
                "comment": " Same as `on` but you can set a few options.\n",
                "type": "String -> Options -> Decoder msg -> Property msg"
            },
            {
                "name": "programWithFlags",
                "comment": " The most generic way to create a [`Program`][program]. It is the primitive\nbehind things like `beginnerProgram` and `program` in [the `Html.App` module][app].\nRead about it there if you'd like to learn more about this.\n\n[program]: http://package.elm-lang.org/packages/elm-lang/core/latest/Platform#Program\n[app]: http://package.elm-lang.org/packages/elm-lang/html/latest/Html-App\n",
                "type": "{ init : flags -> ( model, Cmd msg ), update : msg -> model -> ( model, Cmd msg ), subscriptions : model -> Sub msg, view : model -> Node msg } -> Program flags"
            },
            {
                "name": "property",
                "comment": " Create arbitrary *properties*.\n\n    import JavaScript.Encode as Json\n\n    greeting : Html\n    greeting =\n        node \"div\" [ property \"className\" (Json.string \"greeting\") ] [\n          text \"Hello!\"\n        ]\n\nNotice that you must give the *property* name, so we use `className` as it\nwould be in JavaScript, not `class` as it would appear in HTML.\n",
                "type": "String -> Value -> Property msg"
            },
            {
                "name": "style",
                "comment": " Specify a list of styles.\n\n    myStyle : Property msg\n    myStyle =\n      style\n        [ (\"backgroundColor\", \"red\")\n        , (\"height\", \"90px\")\n        , (\"width\", \"100%\")\n        ]\n\n    greeting : Node msg\n    greeting =\n      node \"div\" [ myStyle ] [ text \"Hello!\" ]\n\n",
                "type": "List ( String, String ) -> Property msg"
            },
            {
                "name": "text",
                "comment": " Just put plain text in the DOM. It will escape the string so that it appears\nexactly as you specify.\n\n    text \"Hello World!\"\n",
                "type": "String -> Node msg"
            }
        ],
        "binops": []
    }
]