[
    {
        "name": "Exts.Html",
        "comment": " Extensions to the `Html` library.\n\n@docs matchText, nbsp\n\n",
        "unions": [],
        "aliases": [],
        "values": [
            {
                "name": "matchText",
                "comment": " Highlight regex matches in a given piece of text. This is most easily explained with an example:\n\n    import Regex exposing (regex)\n    import Html.Attributes exposing (class)\n\n    matchText\n      [class \"match\"]\n      (regex \"the\")\n      \"the quick brown fox jumped over the lazy dog\"\n\n    =>\n\n    [span [class \"match\"] [text \"the\"]\n    ,text \" quick brown fox jumped over \"\n    ,span [class \"match\"] [text \"the\"]\n    ,text \" lazy dog\"]\n\n    Now you can add a CSS rule like `.match {background-color: yellow;}` to highlight matches\n    for the user.\n\n    (Note that you can supply any attributes you like for the matched sections, or an empty list.)\n\n",
                "type": "List (Attribute msg) -> Regex -> String -> List (Html msg)"
            },
            {
                "name": "nbsp",
                "comment": " A non-breaking space. elm-html doesn't support escape sequences\nlike `text \"&nbsp\"`, so use this string instead.\n",
                "type": "String"
            }
        ],
        "binops": []
    },
    {
        "name": "Exts.Array",
        "comment": " Extensions to the core `Array` library.\n\n@docs update\n",
        "unions": [],
        "aliases": [],
        "values": [
            {
                "name": "update",
                "comment": " 'Update' the entry at position `n`, by applying `f` to it. If the\nindex is out of range, the array is unaltered.\n",
                "type": "Int -> (a -> a) -> Array a -> Array a"
            }
        ],
        "binops": []
    },
    {
        "name": "Exts.String",
        "comment": " Extensions to the core `String` library.\n\n@docs removePrefix\n\n",
        "unions": [],
        "aliases": [],
        "values": [
            {
                "name": "removePrefix",
                "comment": " Strip a leading string from a `String`.\n",
                "type": "String -> String -> String"
            }
        ],
        "binops": []
    },
    {
        "name": "Exts.Validation",
        "comment": " Simple tools for validation. See also [Richard Feldman's elm-validate](http://package.elm-lang.org/packages/rtfeldman/elm-validate/latest).\n\n@docs Validator, apply, (|:), required, notBlank, matches, email, emailRegex\n",
        "unions": [],
        "aliases": [
            {
                "name": "Validator",
                "comment": " A validator is a function that takes a possibly-invalid form, and\neither returns an error message, or a form that is definitely valid. For example:\n\n    type alias Form =\n      { message : Maybe String\n      , email : Maybe String\n      , firstName : Maybe String\n      , age : Maybe Int\n      }\n\n    type alias ValidForm =\n      { message : String\n      , email : String\n      , firstName : String\n      , age : Int\n      }\n\n    validateForm : Form -> Result String ValidForm\n    validateForm form =\n      Ok ValidForm\n        |: notBlank \"Message is required and may not be blank.\" form.message\n        |: email \"Email is required and may not be blank.\" form.email\n        |: matches (caseInsensitive (regex \"^[a-z]+$\")) \"First name may only contain letters.\" form.firstName\n        |: required \"Age is required\" form.age\n\nAn error message is typically a `String`, but may be any type you choose.\n",
                "args": [
                    "e",
                    "a",
                    "b"
                ],
                "type": "Maybe a -> Result e b"
            }
        ],
        "values": [
            {
                "name": "apply",
                "comment": " Chain validators together.\n\n(Hat tip to CircuitHub, who inspired the syntax and guided the code with their [elm-json-extra](http://package.elm-lang.org/packages/circuithub/elm-json-extra/latest) library.)\n",
                "type": "Result e (a -> b) -> Result e a -> Result e b"
            },
            {
                "name": "email",
                "comment": " A basic email regex. This is incredibly simplistic, but is\nincluded for convenience.\n\nRemember that the only real way to validate an email address is to\nsend something to it and get a reply.\n",
                "type": "e -> Validator e String String"
            },
            {
                "name": "emailRegex",
                "comment": " ",
                "type": "Regex"
            },
            {
                "name": "matches",
                "comment": " A field that must match the given regex.\n",
                "type": "Regex -> e -> Validator e String String"
            },
            {
                "name": "notBlank",
                "comment": " A field that might be `Nothing`, but is only valid if it is a non-empty `String`.\n",
                "type": "e -> Validator e String String"
            },
            {
                "name": "required",
                "comment": " A field that might be `Nothing`, but is only valid if it is `Just a`.\n",
                "type": "e -> Validator e a a"
            }
        ],
        "binops": [
            {
                "name": "|:",
                "comment": " Convenient synonym for `apply`.\n",
                "type": "Result e (a -> b) -> Result e a -> Result e b",
                "associativity": "left",
                "precedence": 9
            }
        ]
    },
    {
        "name": "Exts.Task",
        "comment": " Extensions to the core `Process` library.\n\n@docs delay, asCmd\n",
        "unions": [],
        "aliases": [],
        "values": [
            {
                "name": "asCmd",
                "comment": " Turn a `Task` into a `Cmd` which returns a `Result`.\n",
                "type": "Task e a -> Cmd (Result e a)"
            },
            {
                "name": "delay",
                "comment": " Delay running the `Task` for a given `Time`.\n\nThis is just the example given in `Task.sleep` wrapped up, because it's o useful.\n",
                "type": "Time -> Task e a -> Task e a"
            }
        ],
        "binops": []
    },
    {
        "name": "Exts.Delta",
        "comment": " A system for tracking players that enter and leave a stage, a-la D3.\n\nImplementation detail: This code is hampered by the lack of Elm's type classes. Note the following:\n1. Performance may degrade badly as the number of elements increases.\n2. It is up to you to ensure (a) implments Eq correctly.\n\n@docs Delta, empty, generation\n",
        "unions": [],
        "aliases": [
            {
                "name": "Delta",
                "comment": " A data-structure that maintains the difference list of entering, continuing and leaving players.\n",
                "args": [
                    "a"
                ],
                "type": "{ entering : List a, continuing : List a, leaving : List a }"
            }
        ],
        "values": [
            {
                "name": "empty",
                "comment": " A default starting state for Deltas.\n",
                "type": "Delta a"
            },
            {
                "name": "generation",
                "comment": " Update the delta by inspecting a list of players.\n",
                "type": "List a -> Delta a -> Delta a"
            }
        ],
        "binops": []
    },
    {
        "name": "Exts.Tuple",
        "comment": " Extensions for tuples.\n\n@docs indexedPair\n@docs first\n@docs second\n@docs both\n@docs pair\n@docs fork\n@docs onFirst\n@docs onSecond\n\n",
        "unions": [],
        "aliases": [],
        "values": [
            {
                "name": "both",
                "comment": " Update both components of a pair with a single function.\n",
                "type": "(a -> b) -> ( a, a ) -> ( b, b )"
            },
            {
                "name": "first",
                "comment": " Update the first component of a pair.\n",
                "type": "(a -> a_) -> ( a, b ) -> ( a_, b )"
            },
            {
                "name": "fork",
                "comment": " Generate a pair from a single value and a left & right function.\n",
                "type": "(a -> b) -> (a -> c) -> a -> ( b, c )"
            },
            {
                "name": "indexedPair",
                "comment": " Turn a items into a key-value pair.\n\n  See also `Exts.Dict.indexBy` and `Exts.Dict.groupBy`.\n",
                "type": "(a -> b) -> a -> ( b, a )"
            },
            {
                "name": "onFirst",
                "comment": " Apply a function that considers both elements of a pair and changes the first.\n",
                "type": "(a -> b -> c) -> ( a, b ) -> ( c, b )"
            },
            {
                "name": "onSecond",
                "comment": " Apply a function that considers both elements of a pair and changes the second.\n",
                "type": "(a -> b -> c) -> ( a, b ) -> ( a, c )"
            },
            {
                "name": "pair",
                "comment": " Update both components of a pair with two functions.\n",
                "type": "(a -> a_) -> (b -> b_) -> ( a, b ) -> ( a_, b_ )"
            },
            {
                "name": "second",
                "comment": " Update the second component of a pair.\n",
                "type": "(b -> b_) -> ( a, b ) -> ( a, b_ )"
            }
        ],
        "binops": []
    },
    {
        "name": "Exts.Maybe",
        "comment": " Extensions to the core `Maybe` library.\n\n@docs isJust, isNothing, maybe, mappend, catMaybes, join, maybeDefault, matches, validate, when\n",
        "unions": [],
        "aliases": [],
        "values": [
            {
                "name": "catMaybes",
                "comment": " Extract all the `Just` values from a List of Maybes.\n",
                "type": "List (Maybe a) -> List a"
            },
            {
                "name": "isJust",
                "comment": " Boolean checks.\n",
                "type": "Maybe a -> Bool"
            },
            {
                "name": "isNothing",
                "comment": " ",
                "type": "Maybe a -> Bool"
            },
            {
                "name": "join",
                "comment": " Join together two `Maybe` values using the supplied function. If\neither value is `Nothing`, the result is `Nothing`.\n",
                "type": "(a -> b -> c) -> Maybe a -> Maybe b -> Maybe c"
            },
            {
                "name": "mappend",
                "comment": " Join two `Maybe`s together as though they were one.\n",
                "type": "Maybe a -> Maybe b -> Maybe ( a, b )"
            },
            {
                "name": "matches",
                "comment": " Check the if value in the `Maybe` matches a predicate. If it does, pass it through, if not, return nothing.\n\n    matches isEven (Just 2) => Just 2\n    matches isEven (Just 3) => Nothing\n    matches isEven Nothing => Nothing\n",
                "type": "(a -> Bool) -> Maybe a -> Maybe a"
            },
            {
                "name": "maybe",
                "comment": " Apply a function to a value, returning the default if the value is `Nothing`.\n",
                "type": "b -> (a -> b) -> Maybe a -> b"
            },
            {
                "name": "maybeDefault",
                "comment": " If `x` is a `Just _` value, return it, otherwise return `Just default`.\n",
                "type": "a -> Maybe a -> Maybe a"
            },
            {
                "name": "validate",
                "comment": " Validate a value against a predicate, returning a `Maybe`.\n\n    validate isEven 2 => Just 2\n    validate isEven 3 => Nothing\n",
                "type": "(a -> Bool) -> a -> Maybe a"
            },
            {
                "name": "when",
                "comment": " When `test` returns true, return `Just value`, otherwise return `Nothing`.\n",
                "type": "Bool -> a -> Maybe a"
            }
        ],
        "binops": []
    },
    {
        "name": "Exts.Set",
        "comment": " Extensions to the core `Set` library.\n\n@docs select, uniqueItems, toggle\n\n",
        "unions": [],
        "aliases": [],
        "values": [
            {
                "name": "select",
                "comment": " Pull any items from a list where (f x) is in the given set.\n",
                "type": "(a -> comparable) -> Set comparable -> List a -> List a"
            },
            {
                "name": "toggle",
                "comment": " If x is a member of the set, remove it. Otherwise, add it.\n",
                "type": "comparable -> Set comparable -> Set comparable"
            },
            {
                "name": "uniqueItems",
                "comment": " Dive into a `List` to get a set of values.\n\n  For example, pulling a `Set` of countries from a `List` of users.\n",
                "type": "(a -> Maybe comparable) -> List a -> Set comparable"
            }
        ],
        "binops": []
    },
    {
        "name": "Exts.RemoteData",
        "comment": " **NOTE:** This file has been promoted to its own project. Please see\nthe [RemoteData for Elm package](http://package.elm-lang.org/packages/krisajenkins/remotedata/latest).\nThis file will be remove from elm-exts in a future release.\n\n\n\nA datatype representing fetched data.\n\nIf you find yourself continually using `Maybe (Result Error a)` to\nrepresent loaded data, or you have a habit of shuffling errors away to\nwhere they can be quietly ignored, consider using this. It makes it\neasier to represent the real state of a remote data fetch and handle\nit properly.\n\n\nFor more on the motivation, take a look at the blog post [How Elm Slays A UI Antipattern](http://blog.jenkster.com/2016/06/how-elm-slays-a-ui-antipattern.html).\n\n\nTo use the datatype, let's look at an example that loads `News` from a feed.\n\nFirst you add to your model, wrapping the data you want in `WebData`:\n\n\n    type alias Model =\n        { news : WebData News }\n\n\nThen add in a message that will deliver the response:\n\n\n    type alias Msg\n        = NewsResponse (WebData News)\n\n\nNow we can create an HTTP get:\n\n\n    getNews : Cmd Msg\n    getNews =\n        Http.get decodeNews \"/news\"\n            |> RemoteData.asCmd\n            |> Cmd.map NewsResponse\n\n\nWe trigger it in our `init` function:\n\n\n    init : ( Model, Cmd Msg)\n    init =\n        ( { news = Loading }\n        , getNews\n        )\n\n\nWe handle it in our `update` function:\n\n\n    update msg model =\n        case msg of\n            NewsResponse response ->\n                ( { model | news = response }\n                , Cmd.none\n                )\n\n\n\nMost of this you'd already have in your app, and the changes are just\nwrapping the datatype in `Webdata`, and updating the `Http.get` call\nto add in `RemoteData.asCmd`.\n\nNow we get to where we really want to be, rendering the data and\nhandling the different states in the UI gracefully:\n\n\n    view : Model -> Html msg\n    view model =\n      case model.news of\n        NotAsked -> text \"Initialising.\"\n\n        Loading -> text \"Loading.\"\n\n        Failure err -> text (\"Error: \" ++ toString err)\n\n        Success news -> viewNews news\n\n\n    viewNews : News -> Html msg\n    viewNews news =\n        div []\n            [h1 [] [text \"Here is the news.\"]\n            , ...]\n\n@docs RemoteData, WebData, map, mapFailure, mapBoth, andThen, withDefault, fromResult, asCmd, fromTask, append, mappend, isSuccess, update\n\n",
        "unions": [
            {
                "name": "RemoteData",
                "comment": " Frequently when you're fetching data from an API, you want to represent four different states:\n  * `NotAsked` - We haven't asked for the data yet.\n  * `Loading` - We've asked, but haven't got an answer yet.\n  * `Failure` - We asked, but something went wrong. Here's the error.\n  * `Success` - Everything worked, and here's the data.\n",
                "args": [
                    "e",
                    "a"
                ],
                "cases": [
                    [
                        "NotAsked",
                        []
                    ],
                    [
                        "Loading",
                        []
                    ],
                    [
                        "Failure",
                        [
                            "e"
                        ]
                    ],
                    [
                        "Success",
                        [
                            "a"
                        ]
                    ]
                ]
            }
        ],
        "aliases": [
            {
                "name": "WebData",
                "comment": " While `RemoteData` can model any type of error, the most common\none you'll actually encounter is when you fetch data from a REST\ninterface, and get back `RemoteData Http.Error a`. Because that case\nis so common, `WebData` is provided as a useful alias.\n",
                "args": [
                    "a"
                ],
                "type": "RemoteData Error a"
            }
        ],
        "values": [
            {
                "name": "andThen",
                "comment": " Chain together RemoteData function calls.\n",
                "type": "RemoteData e a -> (a -> RemoteData e b) -> RemoteData e b"
            },
            {
                "name": "append",
                "comment": " Append - join two `RemoteData` values together as though\nthey were one.\n\nIf their value is `NotAsked`, the result is `NotAsked`.\nIf their value is `Loading`, the result is `Loading`.\nIf both values are `Failure`, the left one wins.\n",
                "type": "RemoteData e a -> RemoteData e b -> RemoteData e ( a, b )"
            },
            {
                "name": "asCmd",
                "comment": " Convert a web `Task`, probably produced from elm-http, to a `Cmd (RemoteData e a)`.\n",
                "type": "Task e a -> Cmd (RemoteData e a)"
            },
            {
                "name": "fromResult",
                "comment": " Convert a `Result Error`, probably produced from elm-http, to a RemoteData value.\n",
                "type": "Result e a -> RemoteData e a"
            },
            {
                "name": "fromTask",
                "comment": " Convert from a `Task` that may succeed or fail, to one that always\nsucceeds with the `RemoteData` that captures any errors.\n",
                "type": "Task e a -> Task Never (RemoteData e a)"
            },
            {
                "name": "isSuccess",
                "comment": " State-checking predicate. Returns true if we've successfully loaded some data.\n",
                "type": "RemoteData e a -> Bool"
            },
            {
                "name": "map",
                "comment": " Map a function into the `Success` value.\n",
                "type": "(a -> b) -> RemoteData e a -> RemoteData e b"
            },
            {
                "name": "mapBoth",
                "comment": " Map function into both the `Success` and `Failure` value.\n",
                "type": "(a -> b) -> (e -> f) -> RemoteData e a -> RemoteData f b"
            },
            {
                "name": "mapFailure",
                "comment": " Map a function into the `Failure` value.\n",
                "type": "(e -> f) -> RemoteData e a -> RemoteData f a"
            },
            {
                "name": "mappend",
                "comment": " DEPRECATED: Old, incorrect name for `append`.\n",
                "type": "RemoteData e a -> RemoteData e b -> RemoteData e ( a, b )"
            },
            {
                "name": "update",
                "comment": " Apply an Elm update function - `Model -> (Model, Cmd Msg)` - to any `Successful`-ly loaded data.\n\nIt's quite common in Elm to want to run a model-update function, over\nsome remote data, but only once it's actually been loaded.\n\nFor example, we might want to handle UI messages changing the users\nsettings, but that only makes sense once those settings have been\nreturned from the server.\n\nThis function makes it more convenient to reach inside a\n`RemoteData.Success` value and apply an update. If the data in not\n`Success a`, it is return unchanged with a `Cmd.none`.\n\n",
                "type": "(a -> ( a, Cmd b )) -> RemoteData e a -> ( RemoteData e a, Cmd b )"
            },
            {
                "name": "withDefault",
                "comment": " Return the `Success` value, or the default.\n",
                "type": "a -> RemoteData e a -> a"
            }
        ],
        "binops": []
    },
    {
        "name": "Exts.Result",
        "comment": " Extensions to the core `Result` library.\n\n@docs mapBoth, isOk, isErr, fromOk, fromErr, mappend\n",
        "unions": [],
        "aliases": [],
        "values": [
            {
                "name": "fromErr",
                "comment": " ",
                "type": "Result e a -> Maybe e"
            },
            {
                "name": "fromOk",
                "comment": " Convert a `Result` to a `Maybe`.\n",
                "type": "Result e a -> Maybe a"
            },
            {
                "name": "isErr",
                "comment": " ",
                "type": "Result e a -> Bool"
            },
            {
                "name": "isOk",
                "comment": " Boolean checks for success/failure.\n",
                "type": "Result e a -> Bool"
            },
            {
                "name": "mapBoth",
                "comment": " Apply functions to both sides of a `Result`, transforming the error and ok types.\n",
                "type": "(e -> f) -> (a -> b) -> Result e a -> Result f b"
            },
            {
                "name": "mappend",
                "comment": " Monoidal append - join two Results together as though they were one.\n",
                "type": "Result e a -> Result e b -> Result e ( a, b )"
            }
        ],
        "binops": []
    },
    {
        "name": "Exts.Json.Decode",
        "comment": " Extensions to the core `Json.Decode` library.\n\n@docs stringIgnoringBlanks\n",
        "unions": [],
        "aliases": [],
        "values": [
            {
                "name": "stringIgnoringBlanks",
                "comment": " A decoder like `(maybe string)`, except an empty or whitespace string is treated as `Nothing`.\n\nUseful for dirty data-models.\n",
                "type": "Decoder (Maybe String)"
            }
        ],
        "binops": []
    },
    {
        "name": "Exts.List",
        "comment": " Extensions to the core `List` library.\n\n@docs chunk, mergeBy, singleton, maybeSingleton, firstMatch, rest, unique\n",
        "unions": [],
        "aliases": [],
        "values": [
            {
                "name": "chunk",
                "comment": " Split a list into chunks of length `n`.\n\n  Be aware that the last sub-list may be smaller than `n`-items long.\n\n  For example `chunk 3 [1..10] => [[1,2,3], [4,5,6], [7,8,9], [10]]`\n",
                "type": "Int -> List a -> List (List a)"
            },
            {
                "name": "firstMatch",
                "comment": " Find the first element in the `List` that matches the given predicate.\n",
                "type": "(a -> Bool) -> List a -> Maybe a"
            },
            {
                "name": "maybeSingleton",
                "comment": " Wrap a maybe item into a `List`. If the item is `Nothing`, the `List` is empty.\n",
                "type": "Maybe a -> List a"
            },
            {
                "name": "mergeBy",
                "comment": " Merge two lists. The first argument is a function which returns\nthe unique ID of each element. Where an element appears more than\nonce, the last won wins.\n",
                "type": "(a -> comparable) -> List a -> List a -> List a"
            },
            {
                "name": "rest",
                "comment": " Like List.tail, but if the list is empty it returns an empty list rather than `Nothing`.\n",
                "type": "List a -> List a"
            },
            {
                "name": "singleton",
                "comment": " Wrap a single item into a `List`.\n",
                "type": "a -> List a"
            },
            {
                "name": "unique",
                "comment": " Return a new list with duplicates removed. Order is preserved.\n",
                "type": "List comparable -> List comparable"
            }
        ],
        "binops": []
    },
    {
        "name": "Exts.Json.Encode",
        "comment": " Extensions to the core `Json.Encode` library.\n\n@docs set, dict, tuple2\n",
        "unions": [],
        "aliases": [],
        "values": [
            {
                "name": "dict",
                "comment": " Encode a `Dict` to a JSON array .\n",
                "type": "(comparable -> Value) -> (v -> Value) -> Dict comparable v -> Value"
            },
            {
                "name": "set",
                "comment": " Encode a `Set` to a JSON array .\n",
                "type": "(comparable -> Value) -> Set comparable -> Value"
            },
            {
                "name": "tuple2",
                "comment": " Encode a pair to a JSON array .\n",
                "type": "(a -> Value) -> (b -> Value) -> ( a, b ) -> Value"
            }
        ],
        "binops": []
    },
    {
        "name": "Exts.LatLng",
        "comment": " Calculations between points on the earth.\n\n@docs distanceBetween, bearingTo\n",
        "unions": [],
        "aliases": [],
        "values": [
            {
                "name": "bearingTo",
                "comment": " Calculate the heading you'd need to travel on to get from point a to point b.\n",
                "type": "{ a | latitude : Float, longitude : Float } -> { b | latitude : Float, longitude : Float } -> Float"
            },
            {
                "name": "distanceBetween",
                "comment": " Calculate the distance in kilometers between two points.\n\n  Note that this assumes the earth is spherical, which is not true, but may be true enough for your purposes.\n",
                "type": "{ a | latitude : Float, longitude : Float } -> { b | latitude : Float, longitude : Float } -> Float"
            }
        ],
        "binops": []
    },
    {
        "name": "Exts.Html.Events",
        "comment": " Extensions to the `Html.Events` library.\n\n@docs onEnter, onSelect\n",
        "unions": [],
        "aliases": [],
        "values": [
            {
                "name": "onEnter",
                "comment": " Send a message when the user hits enter.\n",
                "type": "msg -> Attribute msg"
            },
            {
                "name": "onSelect",
                "comment": " An event handler for `<select>` tags. Set the child `<option>` tag's value to \"\" to get a `Nothing`.\n",
                "type": "(Maybe String -> msg) -> Attribute msg"
            }
        ],
        "binops": []
    },
    {
        "name": "Exts.Int",
        "comment": " Extensions to the core `Int` library.\n\n@docs floorBy\n",
        "unions": [],
        "aliases": [],
        "values": [
            {
                "name": "floorBy",
                "comment": " Round an int down to the nearest multiple of a factor.\n\n    floorBy  2 143 => Just 142\n    floorBy 50 143 => Just 100\n    floorBy  0 143 => Nothing\n",
                "type": "Int -> Int -> Maybe Int"
            }
        ],
        "binops": []
    },
    {
        "name": "Exts.Html.Table",
        "comment": " Helpers for simple data tables. Define how a list of items can be\nrendered as a table. The definition is a `List` of `(column-title,\ncolumn-value-accessor)` pairs.\n\n  I find this approach works well for simple tables, but breaks down\n  as soon as you need much customisation. Use it to get you started\n  quickly, but be ready to rewrite when this 80% case no longer suits.\n\n@docs CellDef, TableDef, simpleTable, simpleTableRow, titleGroup, valueGroup\n",
        "unions": [],
        "aliases": [
            {
                "name": "CellDef",
                "comment": " A table definition looks something like:\n\n    [(text \"Name\", .name >> text)\n    ,(text \"Name\", .age >> toString >> text)]\n\n",
                "args": [
                    "a",
                    "msg"
                ],
                "type": "( Html msg, a -> Html msg )"
            },
            {
                "name": "TableDef",
                "comment": " ",
                "args": [
                    "a",
                    "msg"
                ],
                "type": "List (CellDef a msg)"
            }
        ],
        "values": [
            {
                "name": "simpleTable",
                "comment": " Given a table definition, render a list of elements as HTML.\n",
                "type": "TableDef a msg -> List a -> Html msg"
            },
            {
                "name": "simpleTableRow",
                "comment": " Given a table definition, render an element to a <tr> tag. This is\nlower-level. Usually you will want `simpleTable` instead.\n",
                "type": "TableDef a msg -> a -> Html msg"
            },
            {
                "name": "titleGroup",
                "comment": " titleGroup and valueGroup are used to create columns that stack multiple pairs. For example:\n\n    [(titleGroup [\"Latitude\", \"Longitude\"]\n     ,valueGroup [.location >> .lat >> toString >> text\n                 ,.location >> .lng >> toString >> text])\n\n",
                "type": "List String -> Html msg"
            },
            {
                "name": "valueGroup",
                "comment": " ",
                "type": "List (a -> Html msg) -> a -> Html msg"
            }
        ],
        "binops": []
    },
    {
        "name": "Exts.Http",
        "comment": " Extensions to the `Http` library.\n\n@docs handleError, put, postContent, postForm, postJson, cgiParameters\n",
        "unions": [],
        "aliases": [],
        "values": [
            {
                "name": "cgiParameters",
                "comment": " Encode a CGI parameter list.\n",
                "type": "List ( String, String ) -> String"
            },
            {
                "name": "handleError",
                "comment": " Lift a raw Http response into a `Task Error Response`, using the same rules `Http` uses internally.\n",
                "type": "Task RawError Response -> Task Error Response"
            },
            {
                "name": "postContent",
                "comment": " Send a `POST` request with the given content-type.\n",
                "type": "String -> Decoder value -> String -> Body -> Task Error value"
            },
            {
                "name": "postForm",
                "comment": " Send a `POST` request with appropriate headers for form payloads.\n",
                "type": "Decoder value -> String -> Body -> Task Error value"
            },
            {
                "name": "postJson",
                "comment": " Send a `POST` request with appropriate headers JSON payloads.\n",
                "type": "Decoder value -> String -> Body -> Task Error value"
            },
            {
                "name": "put",
                "comment": " Send a simple `PUT` request.\n",
                "type": "Decoder value -> String -> Body -> Task Error value"
            }
        ],
        "binops": []
    },
    {
        "name": "Exts.Float",
        "comment": " Extensions to the core `Float` library.\n\n@docs roundTo\n",
        "unions": [],
        "aliases": [],
        "values": [
            {
                "name": "roundTo",
                "comment": " Round a `Float` to a given number of decimal places.\n",
                "type": "Int -> Float -> Float"
            }
        ],
        "binops": []
    },
    {
        "name": "Exts.Html.Bootstrap.Glyphicons",
        "comment": " Type-safe glyphicons for Twitter Bootstrap 3 users.\n\n@docs glyphicon, Glyphicon\n",
        "unions": [
            {
                "name": "Glyphicon",
                "comment": " A type-safe list of all available glyphicons in Bootstrap. To fit\nElm's syntax we convert from kebab-case to CamelCase, so\n`\"glyphicon-star-empty\"` becomes the type constructor `StarEmpty`.\n",
                "args": [],
                "cases": [
                    [
                        "Asterisk",
                        []
                    ],
                    [
                        "Plus",
                        []
                    ],
                    [
                        "Euro",
                        []
                    ],
                    [
                        "Eur",
                        []
                    ],
                    [
                        "Minus",
                        []
                    ],
                    [
                        "Cloud",
                        []
                    ],
                    [
                        "Envelope",
                        []
                    ],
                    [
                        "Pencil",
                        []
                    ],
                    [
                        "Glass",
                        []
                    ],
                    [
                        "Music",
                        []
                    ],
                    [
                        "Search",
                        []
                    ],
                    [
                        "Heart",
                        []
                    ],
                    [
                        "Star",
                        []
                    ],
                    [
                        "StarEmpty",
                        []
                    ],
                    [
                        "User",
                        []
                    ],
                    [
                        "Film",
                        []
                    ],
                    [
                        "ThLarge",
                        []
                    ],
                    [
                        "Th",
                        []
                    ],
                    [
                        "ThList",
                        []
                    ],
                    [
                        "Ok",
                        []
                    ],
                    [
                        "Remove",
                        []
                    ],
                    [
                        "ZoomIn",
                        []
                    ],
                    [
                        "ZoomOut",
                        []
                    ],
                    [
                        "Off",
                        []
                    ],
                    [
                        "Signal",
                        []
                    ],
                    [
                        "Cog",
                        []
                    ],
                    [
                        "Trash",
                        []
                    ],
                    [
                        "Home",
                        []
                    ],
                    [
                        "File",
                        []
                    ],
                    [
                        "Time",
                        []
                    ],
                    [
                        "Road",
                        []
                    ],
                    [
                        "DownloadAlt",
                        []
                    ],
                    [
                        "Download",
                        []
                    ],
                    [
                        "Upload",
                        []
                    ],
                    [
                        "Inbox",
                        []
                    ],
                    [
                        "PlayCircle",
                        []
                    ],
                    [
                        "Repeat",
                        []
                    ],
                    [
                        "Refresh",
                        []
                    ],
                    [
                        "ListAlt",
                        []
                    ],
                    [
                        "Lock",
                        []
                    ],
                    [
                        "Flag",
                        []
                    ],
                    [
                        "Headphones",
                        []
                    ],
                    [
                        "VolumeOff",
                        []
                    ],
                    [
                        "VolumeDown",
                        []
                    ],
                    [
                        "VolumeUp",
                        []
                    ],
                    [
                        "Qrcode",
                        []
                    ],
                    [
                        "Barcode",
                        []
                    ],
                    [
                        "Tag",
                        []
                    ],
                    [
                        "Tags",
                        []
                    ],
                    [
                        "Book",
                        []
                    ],
                    [
                        "Bookmark",
                        []
                    ],
                    [
                        "Print",
                        []
                    ],
                    [
                        "Camera",
                        []
                    ],
                    [
                        "Font",
                        []
                    ],
                    [
                        "Bold",
                        []
                    ],
                    [
                        "Italic",
                        []
                    ],
                    [
                        "TextHeight",
                        []
                    ],
                    [
                        "TextWidth",
                        []
                    ],
                    [
                        "AlignLeft",
                        []
                    ],
                    [
                        "AlignCenter",
                        []
                    ],
                    [
                        "AlignRight",
                        []
                    ],
                    [
                        "AlignJustify",
                        []
                    ],
                    [
                        "List",
                        []
                    ],
                    [
                        "IndentLeft",
                        []
                    ],
                    [
                        "IndentRight",
                        []
                    ],
                    [
                        "FacetimeVideo",
                        []
                    ],
                    [
                        "Picture",
                        []
                    ],
                    [
                        "MapMarker",
                        []
                    ],
                    [
                        "Adjust",
                        []
                    ],
                    [
                        "Tint",
                        []
                    ],
                    [
                        "Edit",
                        []
                    ],
                    [
                        "Share",
                        []
                    ],
                    [
                        "Check",
                        []
                    ],
                    [
                        "Move",
                        []
                    ],
                    [
                        "StepBackward",
                        []
                    ],
                    [
                        "FastBackward",
                        []
                    ],
                    [
                        "Backward",
                        []
                    ],
                    [
                        "Play",
                        []
                    ],
                    [
                        "Pause",
                        []
                    ],
                    [
                        "Stop",
                        []
                    ],
                    [
                        "Forward",
                        []
                    ],
                    [
                        "FastForward",
                        []
                    ],
                    [
                        "StepForward",
                        []
                    ],
                    [
                        "Eject",
                        []
                    ],
                    [
                        "ChevronLeft",
                        []
                    ],
                    [
                        "ChevronRight",
                        []
                    ],
                    [
                        "PlusSign",
                        []
                    ],
                    [
                        "MinusSign",
                        []
                    ],
                    [
                        "RemoveSign",
                        []
                    ],
                    [
                        "OkSign",
                        []
                    ],
                    [
                        "QuestionSign",
                        []
                    ],
                    [
                        "InfoSign",
                        []
                    ],
                    [
                        "Screenshot",
                        []
                    ],
                    [
                        "RemoveCircle",
                        []
                    ],
                    [
                        "OkCircle",
                        []
                    ],
                    [
                        "BanCircle",
                        []
                    ],
                    [
                        "ArrowLeft",
                        []
                    ],
                    [
                        "ArrowRight",
                        []
                    ],
                    [
                        "ArrowUp",
                        []
                    ],
                    [
                        "ArrowDown",
                        []
                    ],
                    [
                        "ShareAlt",
                        []
                    ],
                    [
                        "ResizeFull",
                        []
                    ],
                    [
                        "ResizeSmall",
                        []
                    ],
                    [
                        "ExclamationSign",
                        []
                    ],
                    [
                        "Gift",
                        []
                    ],
                    [
                        "Leaf",
                        []
                    ],
                    [
                        "Fire",
                        []
                    ],
                    [
                        "EyeOpen",
                        []
                    ],
                    [
                        "EyeClose",
                        []
                    ],
                    [
                        "WarningSign",
                        []
                    ],
                    [
                        "Plane",
                        []
                    ],
                    [
                        "Calendar",
                        []
                    ],
                    [
                        "Random",
                        []
                    ],
                    [
                        "Comment",
                        []
                    ],
                    [
                        "Magnet",
                        []
                    ],
                    [
                        "ChevronUp",
                        []
                    ],
                    [
                        "ChevronDown",
                        []
                    ],
                    [
                        "Retweet",
                        []
                    ],
                    [
                        "ShoppingCart",
                        []
                    ],
                    [
                        "FolderClose",
                        []
                    ],
                    [
                        "FolderOpen",
                        []
                    ],
                    [
                        "ResizeVertical",
                        []
                    ],
                    [
                        "ResizeHorizontal",
                        []
                    ],
                    [
                        "Hdd",
                        []
                    ],
                    [
                        "Bullhorn",
                        []
                    ],
                    [
                        "Bell",
                        []
                    ],
                    [
                        "Certificate",
                        []
                    ],
                    [
                        "ThumbsUp",
                        []
                    ],
                    [
                        "ThumbsDown",
                        []
                    ],
                    [
                        "HandRight",
                        []
                    ],
                    [
                        "HandLeft",
                        []
                    ],
                    [
                        "HandUp",
                        []
                    ],
                    [
                        "HandDown",
                        []
                    ],
                    [
                        "CircleArrowRight",
                        []
                    ],
                    [
                        "CircleArrowLeft",
                        []
                    ],
                    [
                        "CircleArrowUp",
                        []
                    ],
                    [
                        "CircleArrowDown",
                        []
                    ],
                    [
                        "Globe",
                        []
                    ],
                    [
                        "Wrench",
                        []
                    ],
                    [
                        "Tasks",
                        []
                    ],
                    [
                        "Filter",
                        []
                    ],
                    [
                        "Briefcase",
                        []
                    ],
                    [
                        "Fullscreen",
                        []
                    ],
                    [
                        "Dashboard",
                        []
                    ],
                    [
                        "Paperclip",
                        []
                    ],
                    [
                        "HeartEmpty",
                        []
                    ],
                    [
                        "Link",
                        []
                    ],
                    [
                        "Phone",
                        []
                    ],
                    [
                        "Pushpin",
                        []
                    ],
                    [
                        "Usd",
                        []
                    ],
                    [
                        "Gbp",
                        []
                    ],
                    [
                        "Sort",
                        []
                    ],
                    [
                        "SortByAlphabet",
                        []
                    ],
                    [
                        "SortByAlphabetAlt",
                        []
                    ],
                    [
                        "SortByOrder",
                        []
                    ],
                    [
                        "SortByOrderAlt",
                        []
                    ],
                    [
                        "SortByAttributes",
                        []
                    ],
                    [
                        "SortByAttributesAlt",
                        []
                    ],
                    [
                        "Unchecked",
                        []
                    ],
                    [
                        "Expand",
                        []
                    ],
                    [
                        "CollapseDown",
                        []
                    ],
                    [
                        "CollapseUp",
                        []
                    ],
                    [
                        "LogIn",
                        []
                    ],
                    [
                        "Flash",
                        []
                    ],
                    [
                        "LogOut",
                        []
                    ],
                    [
                        "NewWindow",
                        []
                    ],
                    [
                        "Record",
                        []
                    ],
                    [
                        "Save",
                        []
                    ],
                    [
                        "Open",
                        []
                    ],
                    [
                        "Saved",
                        []
                    ],
                    [
                        "Import",
                        []
                    ],
                    [
                        "Export",
                        []
                    ],
                    [
                        "Send",
                        []
                    ],
                    [
                        "FloppyDisk",
                        []
                    ],
                    [
                        "FloppySaved",
                        []
                    ],
                    [
                        "FloppyRemove",
                        []
                    ],
                    [
                        "FloppySave",
                        []
                    ],
                    [
                        "FloppyOpen",
                        []
                    ],
                    [
                        "CreditCard",
                        []
                    ],
                    [
                        "Transfer",
                        []
                    ],
                    [
                        "Cutlery",
                        []
                    ],
                    [
                        "Header",
                        []
                    ],
                    [
                        "Compressed",
                        []
                    ],
                    [
                        "Earphone",
                        []
                    ],
                    [
                        "PhoneAlt",
                        []
                    ],
                    [
                        "Tower",
                        []
                    ],
                    [
                        "Stats",
                        []
                    ],
                    [
                        "SdVideo",
                        []
                    ],
                    [
                        "HdVideo",
                        []
                    ],
                    [
                        "Subtitles",
                        []
                    ],
                    [
                        "SoundStereo",
                        []
                    ],
                    [
                        "SoundDolby",
                        []
                    ],
                    [
                        "Sound51",
                        []
                    ],
                    [
                        "Sound61",
                        []
                    ],
                    [
                        "Sound71",
                        []
                    ],
                    [
                        "CopyrightMark",
                        []
                    ],
                    [
                        "RegistrationMark",
                        []
                    ],
                    [
                        "CloudDownload",
                        []
                    ],
                    [
                        "CloudUpload",
                        []
                    ],
                    [
                        "TreeConifer",
                        []
                    ],
                    [
                        "TreeDeciduous",
                        []
                    ],
                    [
                        "Cd",
                        []
                    ],
                    [
                        "SaveFile",
                        []
                    ],
                    [
                        "OpenFile",
                        []
                    ],
                    [
                        "LevelUp",
                        []
                    ],
                    [
                        "Copy",
                        []
                    ],
                    [
                        "Paste",
                        []
                    ],
                    [
                        "Alert",
                        []
                    ],
                    [
                        "Equalizer",
                        []
                    ],
                    [
                        "King",
                        []
                    ],
                    [
                        "Queen",
                        []
                    ],
                    [
                        "Pawn",
                        []
                    ],
                    [
                        "Bishop",
                        []
                    ],
                    [
                        "Knight",
                        []
                    ],
                    [
                        "BabyFormula",
                        []
                    ],
                    [
                        "Tent",
                        []
                    ],
                    [
                        "Blackboard",
                        []
                    ],
                    [
                        "Bed",
                        []
                    ],
                    [
                        "Apple",
                        []
                    ],
                    [
                        "Erase",
                        []
                    ],
                    [
                        "Hourglass",
                        []
                    ],
                    [
                        "Lamp",
                        []
                    ],
                    [
                        "Duplicate",
                        []
                    ],
                    [
                        "PiggyBank",
                        []
                    ],
                    [
                        "Scissors",
                        []
                    ],
                    [
                        "Bitcoin",
                        []
                    ],
                    [
                        "Btc",
                        []
                    ],
                    [
                        "Xbt",
                        []
                    ],
                    [
                        "Yen",
                        []
                    ],
                    [
                        "Jpy",
                        []
                    ],
                    [
                        "Ruble",
                        []
                    ],
                    [
                        "Rub",
                        []
                    ],
                    [
                        "Scale",
                        []
                    ],
                    [
                        "IceLolly",
                        []
                    ],
                    [
                        "IceLollyTasted",
                        []
                    ],
                    [
                        "Education",
                        []
                    ],
                    [
                        "OptionHorizontal",
                        []
                    ],
                    [
                        "OptionVertical",
                        []
                    ],
                    [
                        "MenuHamburger",
                        []
                    ],
                    [
                        "ModalWindow",
                        []
                    ],
                    [
                        "Oil",
                        []
                    ],
                    [
                        "Grain",
                        []
                    ],
                    [
                        "Sunglasses",
                        []
                    ],
                    [
                        "TextSize",
                        []
                    ],
                    [
                        "TextColor",
                        []
                    ],
                    [
                        "TextBackground",
                        []
                    ],
                    [
                        "ObjectAlignTop",
                        []
                    ],
                    [
                        "ObjectAlignBottom",
                        []
                    ],
                    [
                        "ObjectAlignHorizontal",
                        []
                    ],
                    [
                        "ObjectAlignLeft",
                        []
                    ],
                    [
                        "ObjectAlignVertical",
                        []
                    ],
                    [
                        "ObjectAlignRight",
                        []
                    ],
                    [
                        "TriangleRight",
                        []
                    ],
                    [
                        "TriangleLeft",
                        []
                    ],
                    [
                        "TriangleBottom",
                        []
                    ],
                    [
                        "TriangleTop",
                        []
                    ],
                    [
                        "Console",
                        []
                    ],
                    [
                        "Superscript",
                        []
                    ],
                    [
                        "Subscript",
                        []
                    ],
                    [
                        "MenuLeft",
                        []
                    ],
                    [
                        "MenuRight",
                        []
                    ],
                    [
                        "MenuDown",
                        []
                    ],
                    [
                        "MenuUp",
                        []
                    ]
                ]
            }
        ],
        "aliases": [],
        "values": [
            {
                "name": "glyphicon",
                "comment": " Type-checked Glyphicons.\n",
                "type": "Glyphicon -> Html msg"
            }
        ],
        "binops": []
    },
    {
        "name": "Exts.Html.Attributes",
        "comment": " Extensions to the `Html.Attributes` library.\n\n@docs defaultValue, defaultString, defaultInt, defaultFloat, styleList\n",
        "unions": [],
        "aliases": [],
        "values": [
            {
                "name": "defaultFloat",
                "comment": " Convenience version of `defaultValue`, for `Float`s.\n",
                "type": "Float -> Attribute msg"
            },
            {
                "name": "defaultInt",
                "comment": " Convenience version of `defaultValue`, for `Int`s.\n",
                "type": "Int -> Attribute msg"
            },
            {
                "name": "defaultString",
                "comment": " Convenience version of `defaultValue`, for `String`s.\n",
                "type": "String -> Attribute msg"
            },
            {
                "name": "defaultValue",
                "comment": " Set a default value for an input field.\n",
                "type": "Value -> Attribute msg"
            },
            {
                "name": "styleList",
                "comment": " This function makes it easier to specify a conditional set of styles.\n   This the style-equivalent of elm-html's classList.\n",
                "type": "List ( String, String, Bool ) -> Attribute msg"
            }
        ],
        "binops": []
    },
    {
        "name": "Exts.Html.Bootstrap",
        "comment": " Base classes for Twitter Bootstrap 3 users.\n\n@docs stylesheet, container, containerFluid, row, formGroup, empty, twoColumns, Ratio, video, popover, PopoverDirection, clearfix, well, jumbotron, badge\n",
        "unions": [
            {
                "name": "PopoverDirection",
                "comment": " ",
                "args": [],
                "cases": [
                    [
                        "Top",
                        []
                    ],
                    [
                        "Right",
                        []
                    ],
                    [
                        "Bottom",
                        []
                    ],
                    [
                        "Left",
                        []
                    ]
                ]
            },
            {
                "name": "Ratio",
                "comment": " Aspect ratios for responsive video embedding.\n",
                "args": [],
                "cases": [
                    [
                        "SixteenByNine",
                        []
                    ],
                    [
                        "FourByThree",
                        []
                    ]
                ]
            }
        ],
        "aliases": [],
        "values": [
            {
                "name": "badge",
                "comment": " Bootstrap badge component.\n",
                "type": "List (Html msg) -> Html msg"
            },
            {
                "name": "clearfix",
                "comment": " Bootstrap clearfix.\n",
                "type": "Html msg"
            },
            {
                "name": "container",
                "comment": " Bootstrap grid container.\n",
                "type": "List (Html msg) -> Html msg"
            },
            {
                "name": "containerFluid",
                "comment": " Bootstrap grid fluid container.\n",
                "type": "List (Html msg) -> Html msg"
            },
            {
                "name": "empty",
                "comment": " The minimum markup - an empty span.\n",
                "type": "Html msg"
            },
            {
                "name": "formGroup",
                "comment": " Bootstrap form group.\n",
                "type": "List (Html msg) -> Html msg"
            },
            {
                "name": "jumbotron",
                "comment": " Bootstrap jumbotron component.\n",
                "type": "List (Html msg) -> Html msg"
            },
            {
                "name": "popover",
                "comment": " Interface to the bootstrap popover that does not require bootstrap.js.\n",
                "type": "PopoverDirection -> Bool -> List ( String, String ) -> Maybe String -> Html msg -> Html msg"
            },
            {
                "name": "row",
                "comment": " Bootstrap grid row.\n",
                "type": "List (Html msg) -> Html msg"
            },
            {
                "name": "stylesheet",
                "comment": " A tag that loads Bootstrap from a CDN.\n\nYou'll probably only want to use this to get you started. By the time you go\ninto production, you should probably be loading this file in the `<head>` tag\nof your page.\n",
                "type": "Html msg"
            },
            {
                "name": "twoColumns",
                "comment": " Two evenly-sized columns. Must be used within a row.\n",
                "type": "List (Html msg) -> List (Html msg) -> Html msg"
            },
            {
                "name": "video",
                "comment": " Embed a responsive video.\n",
                "type": "Ratio -> String -> Html msg"
            },
            {
                "name": "well",
                "comment": " Bootstrap well component.\n",
                "type": "List (Html msg) -> Html msg"
            }
        ],
        "binops": []
    },
    {
        "name": "Exts.Basics",
        "comment": " Extensions to the core `Basics` library.\n\n@docs compareBy\n\n",
        "unions": [],
        "aliases": [],
        "values": [
            {
                "name": "compareBy",
                "comment": " Compare two things by running the supplied function of both, and comparing the results.\n\n",
                "type": "(a -> comparable) -> a -> a -> Order"
            }
        ],
        "binops": []
    },
    {
        "name": "Exts.Dict",
        "comment": " Extensions to the core `Dict` library.\n\n@docs indexBy\n@docs groupBy\n@docs frequency\n@docs getWithDefault\n@docs foldToList\n@docs updateDict\n\n",
        "unions": [],
        "aliases": [],
        "values": [
            {
                "name": "foldToList",
                "comment": " Run a function over the dictionary entries, resulting in a list of the final results.\n",
                "type": "(comparable -> v -> b) -> Dict comparable v -> List b"
            },
            {
                "name": "frequency",
                "comment": " Create a frequency-map from the given list.\n",
                "type": "List comparable -> Dict comparable Int"
            },
            {
                "name": "getWithDefault",
                "comment": " Attempt to find a key, if it's not there, return a default value.\n",
                "type": "a -> comparable -> Dict comparable a -> a"
            },
            {
                "name": "groupBy",
                "comment": " Group a list of items by a key.\n\n  Supply an indexing function (eg. `.id`) and a list of\n  items. `groupBy` returns a dictionary of group-key/list-of-items.\n\n  If the indexing function returns a unique key for every item, consider `indexBy` instead.\n",
                "type": "(v -> comparable) -> List v -> Dict comparable (List v)"
            },
            {
                "name": "indexBy",
                "comment": " Turn a list of items into an indexed dictionary.\n\n  Supply an indexing function (eg. `.id`) and a list of\n  items. `indexBy` returns a dictionary with each item stored under\n  its index.\n\n  This code assumes each index is unique. If that is not the case, you\n  should use `groupBy` instead.\n",
                "type": "(v -> comparable) -> List v -> Dict comparable v"
            },
            {
                "name": "updateDict",
                "comment": " Apply an Elm update function - `Model -> (Model, Cmd Msg)` - to a `Dict` entry, if present.\n\nIt's quite common in Elm to want to run a model-update function, over\nsome dictionary of models, but only if that model is available.\n\nThis function makes it more convenient to reach inside a `Dict` and\napply an update. If the data is not there, the `Dict` is returned\nunchanged with a `Cmd.none`.\n\n",
                "type": "(a -> ( a, Cmd cmd )) -> comparable -> Dict comparable a -> ( Dict comparable a, Cmd cmd )"
            }
        ],
        "binops": []
    },
    {
        "name": "Exts.Date",
        "comment": " Extensions to the core `Date` library.\n\n@docs toISOString\n@docs toRFC3339\n@docs monthNumber\n",
        "unions": [],
        "aliases": [],
        "values": [
            {
                "name": "monthNumber",
                "comment": " Extract the month of a given date as an `Int`. January is 1.\n",
                "type": "Date -> Int"
            },
            {
                "name": "toISOString",
                "comment": " Format a `Date` as an ISO-standard string.\n",
                "type": "Date -> String"
            },
            {
                "name": "toRFC3339",
                "comment": " Format a `Date` as an RFC-3339 standard string\n\n  This is useful for passing a `Date` as a value to an HTML input. (See [the W3 spec](https://www.w3.org/TR/html-markup/input.date.html#input.date.attrs.value) for details.)\n",
                "type": "Date -> String"
            }
        ],
        "binops": []
    }
]