Showing preview only (2,673K chars total). Download the full file or copy to clipboard to get everything.
Repository: rundis/elm-light
Branch: master
Commit: 5e1c0983b089
Files: 69
Total size: 2.5 MB
Directory structure:
gitextract_2btuyzk6/
├── .gitignore
├── DocPreview/
│ ├── DocPreview.elm
│ ├── DocPreview.html
│ ├── LICENSE
│ ├── docPreview.js
│ ├── elm-package.json
│ ├── highlight.pack.js
│ └── src/
│ ├── Docs/
│ │ ├── Entry.elm
│ │ ├── Name.elm
│ │ ├── Package.elm
│ │ ├── Summary.elm
│ │ ├── Type.elm
│ │ └── Version.elm
│ ├── Native/
│ │ ├── Jump.js
│ │ └── Parse.js
│ ├── Parse/
│ │ ├── Combinators.elm
│ │ └── Type.elm
│ └── Utils/
│ ├── Code.elm
│ ├── FluidList.elm
│ ├── Markdown.elm
│ └── Path.elm
├── LICENSE.md
├── README.adoc
├── css/
│ ├── docpreview.css
│ ├── elm.css
│ ├── graph.css
│ ├── hinter.css
│ ├── inlinedoc.css
│ └── test.css
├── elm/
│ └── ModuleBrowser/
│ ├── ModuleBrowser.elm
│ ├── ModuleBrowser.html
│ ├── elm-package.json
│ └── moduleBrowser.js
├── elm-light.behaviors
├── elm-light_compiled.js
├── elm.keymap
├── js/
│ ├── highlight.pack.js
│ ├── show-hint.js
│ └── show-hint2.js
├── mode/
│ └── elm.js
├── node/
│ ├── elm-client.js
│ └── elmparser.js
├── package.json
├── plugin.edn
├── project.clj
├── src/
│ └── lt/
│ └── plugins/
│ ├── elm_light/
│ │ ├── autocompleter/
│ │ │ └── core.cljs
│ │ ├── autocompleter.cljs
│ │ ├── clients.cljs
│ │ ├── docpreview.cljs
│ │ ├── elm_ast.cljs
│ │ ├── format.cljs
│ │ ├── graph.cljs
│ │ ├── gutter.cljs
│ │ ├── hinter.cljs
│ │ ├── inline-doc.cljs
│ │ ├── linter.cljs
│ │ ├── make.cljs
│ │ ├── module_graph.cljs
│ │ ├── modulebrowser.cljs
│ │ ├── packages.cljs
│ │ ├── repl.cljs
│ │ ├── selection.cljs
│ │ ├── test.cljs
│ │ ├── usages.cljs
│ │ ├── utils.cljs
│ │ └── widgets/
│ │ └── selector.cljs
│ └── elm_light.cljs
└── templates/
└── test/
├── Main.elm
└── Tests.elm
================================================
FILE CONTENTS
================================================
================================================
FILE: .gitignore
================================================
.nrepl-port
target
elm/ModuleBrowser/elm-stuff
elm/ModuleBrowser/elm.js
DocPreview/elm-stuff
DocPreview/elm.js
================================================
FILE: DocPreview/DocPreview.elm
================================================
module DocPreview (..) where
import Html exposing (Html, text, div, span, h1)
import Html.Attributes exposing (class)
import StartApp
import Effects exposing (Effects, Never)
import Docs.Package
import Docs.Entry
import String
import Regex
import Dict
import Json.Decode as Dec
import Utils.Markdown as Markdown
import Parse.Type
import Docs.Type
import Docs.Name
import Set
type alias Model =
{ selModule : Maybe Docs.Package.Module
, package : Docs.Package.Package }
init : (Model, Effects Action)
init =
(Model Nothing Dict.empty, Effects.none)
type Action
= NoOp
| RefreshModules String
| SelectModule String
update : Action -> Model -> ( Model, Effects Action )
update action model =
case action of
NoOp ->
( model, Effects.none )
RefreshModules rawModules ->
let
res =
Dec.decodeString Docs.Package.decodePackage rawModules
in
case res of
Result.Err v ->
Debug.crash "Error decoding package docs"
Result.Ok r ->
( { model | package = r
, selModule = Dict.values r |> List.head
}
, Effects.none
)
SelectModule name ->
( { model | selModule = Dict.get name model.package }
, Effects.none
)
-- View module docs
view : Signal.Address Action -> Model -> Html
view address model =
case model.selModule of
Nothing ->
div [] [text "NO SELECTED MODULE - Maybe you forgot to add your module to the `exposed-modules` entry in elm-package.json ?"]
Just mod ->
let
chunks = toChunks mod
--nameDict = toNameDict model.package
--newChunks = List.map (chunkMap stringToType) chunks
in
div [ class "entry-list" ] <|
h1 [class "entry-list-title"] [text mod.name]
:: List.map (viewChunk Docs.Entry.stringView) chunks
--:: List.map (viewChunk (Docs.Entry.typeView nameDict)) newChunks
viewChunk : (Docs.Entry.Model tipe -> Html) -> Chunk tipe -> Html
viewChunk entryView chunk =
case chunk of
Markdown md ->
span [class "markdown-entry"] [ Markdown.block md ]
Entry entry ->
entryView entry
type Chunk tipe
= Markdown String
| Entry (Docs.Entry.Model tipe)
toNameDict : Docs.Package.Package -> Docs.Name.Dictionary
toNameDict pkg =
Dict.map (\_ modul -> Set.fromList (Dict.keys modul.entries)) pkg
chunkMap : (a -> b) -> Chunk a -> Chunk b
chunkMap func chunk =
case chunk of
Markdown md ->
Markdown md
Entry entry ->
Entry (Docs.Entry.map func entry)
-- parsing fails for some reason when in LT (native issue ?)
stringToType : String -> Docs.Type.Type
stringToType str =
let
_ = Debug.log "String to type for:" str
in
case Parse.Type.parse str of
Ok tipe ->
let
_ = Debug.log "type after parse: " tipe
in
tipe
Err err ->
let
_ = Debug.log "Shit while parsing" err
in
Docs.Type.Var str
toChunks : Docs.Package.Module -> List (Chunk String)
toChunks moduleDocs =
case String.split "\n@docs " moduleDocs.comment of
[] ->
Debug.crash "Expecting some documented functions in this module!"
firstChunk :: rest ->
Markdown firstChunk
:: List.concatMap (subChunks moduleDocs) rest
subChunks : Docs.Package.Module -> String -> List (Chunk String)
subChunks moduleDocs postDocs =
subChunksHelp moduleDocs (String.split "," postDocs)
subChunksHelp : Docs.Package.Module -> List String -> List (Chunk String)
subChunksHelp moduleDocs parts =
case parts of
[] ->
[]
rawPart :: remainingParts ->
let
part =
String.trim rawPart
in
case isValue part of
Just valueName ->
toEntry moduleDocs valueName
:: subChunksHelp moduleDocs remainingParts
Nothing ->
let
trimmedPart =
String.trimLeft rawPart
in
case String.words trimmedPart of
[] ->
[ Markdown (String.join "," parts) ]
token :: _ ->
case isValue token of
Just valueName ->
[ toEntry moduleDocs valueName
, Markdown (String.dropLeft (String.length token) trimmedPart)
]
Nothing ->
[ Markdown (String.join "," parts) ]
var : Regex.Regex
var =
Regex.regex "^[a-zA-Z0-9_']+$"
operator : Regex.Regex
operator =
Regex.regex "^\\([^a-zA-Z0-9]+\\)$"
isValue : String -> Maybe String
isValue str =
if Regex.contains var str then
Just str
else if Regex.contains operator str then
Just (String.dropLeft 1 (String.dropRight 1 str))
else
Nothing
toEntry : Docs.Package.Module -> String -> Chunk String
toEntry moduleDocs name =
case Dict.get name moduleDocs.entries of
Nothing ->
Debug.crash ("docs have been corrupted, could not find " ++ name)
Just entry ->
Entry entry
-- START-APP WIRING
app : StartApp.App Model
app =
StartApp.start
{ init = init
, update = update
, view = view
, inputs = [ modulesSignal, selectModuleSignal ]
}
main : Signal Html
main =
app.html
-- Inbound
modulesSignal : Signal Action
modulesSignal =
Signal.map RefreshModules modules
port modules : Signal String
selectModuleSignal : Signal Action
selectModuleSignal =
Signal.map SelectModule selectModule
port selectModule : Signal String
================================================
FILE: DocPreview/DocPreview.html
================================================
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta content="IE=edge,chrome=1" http-equiv="X-UA-Compatible">
<meta http-equiv="cache-control" content="max-age=0" />
<meta http-equiv="cache-control" content="no-cache" />
<meta http-equiv="expires" content="0" />
<meta http-equiv="expires" content="Tue, 01 Jan 1980 1:00:00 GMT" />
<meta http-equiv="pragma" content="no-cache" />
<style>
#elm-doc-preview {
font-family: 'Source Sans Pro', 'Trebuchet MS', 'Lucida Grande', 'Bitstream Vera Sans', 'Helvetica Neue', sans-serif;
color: #293c4b;
}
#elm-doc-preview h1, #elm-doc-preview h2, #elm-doc-preview h3, #elm-doc-preview h4 {
font-weight: normal;
}
#elm-doc-preview .entry-list {
width: 600px;
display: inline-block;
vertical-align: top;
}
#elm-doc-preview .entry-list-title {
font-size: 3em;
}
#elm-doc-preview .markdown-entry h1 {
margin-top: 2em;
margin-bottom: 0.5px
}
#elm-doc-preview .docs-entry {
border-top: 1px solid #eeeeee;
margin-top: 1em;
margin-bottom: 2em;
}
#elm-doc-preview .docs-annotation {
white-space: pre;
font-family: 'Source Code Pro', consolas, inconsolata, monospace;
padding-top: 10px;
padding-bottom: 10px;
}
#elm-doc-preview .docs-comment {
overflow: hidden;
padding-left: 1em;
}
.hljs {
display: block;
overflow-x: auto;
padding: 0.5em;
background: #f0f0f0;
-webkit-text-size-adjust: none;
}
.hljs,
.hljs-subst,
.hljs-tag .hljs-title,
.nginx .hljs-title {
color: black;
}
.hljs-string,
.hljs-title,
.hljs-constant,
.hljs-parent,
.hljs-tag .hljs-value,
.hljs-rules .hljs-value,
.hljs-preprocessor,
.hljs-pragma,
.haml .hljs-symbol,
.ruby .hljs-symbol,
.ruby .hljs-symbol .hljs-string,
.hljs-template_tag,
.django .hljs-variable,
.smalltalk .hljs-class,
.hljs-addition,
.hljs-flow,
.hljs-stream,
.bash .hljs-variable,
.apache .hljs-tag,
.apache .hljs-cbracket,
.tex .hljs-command,
.tex .hljs-special,
.erlang_repl .hljs-function_or_atom,
.asciidoc .hljs-header,
.markdown .hljs-header,
.coffeescript .hljs-attribute {
color: #800;
}
.smartquote,
.hljs-comment,
.hljs-annotation,
.diff .hljs-header,
.hljs-chunk,
.asciidoc .hljs-blockquote,
.markdown .hljs-blockquote {
color: #888;
}
.hljs-number,
.hljs-date,
.hljs-regexp,
.hljs-literal,
.hljs-hexcolor,
.smalltalk .hljs-symbol,
.smalltalk .hljs-char,
.go .hljs-constant,
.hljs-change,
.lasso .hljs-variable,
.makefile .hljs-variable,
.asciidoc .hljs-bullet,
.markdown .hljs-bullet,
.asciidoc .hljs-link_url,
.markdown .hljs-link_url {
color: #080;
}
.hljs-label,
.hljs-javadoc,
.ruby .hljs-string,
.hljs-decorator,
.hljs-filter .hljs-argument,
.hljs-localvars,
.hljs-array,
.hljs-attr_selector,
.hljs-important,
.hljs-pseudo,
.hljs-pi,
.haml .hljs-bullet,
.hljs-doctype,
.hljs-deletion,
.hljs-envvar,
.hljs-shebang,
.apache .hljs-sqbracket,
.nginx .hljs-built_in,
.tex .hljs-formula,
.erlang_repl .hljs-reserved,
.hljs-prompt,
.asciidoc .hljs-link_label,
.markdown .hljs-link_label,
.vhdl .hljs-attribute,
.clojure .hljs-attribute,
.asciidoc .hljs-attribute,
.lasso .hljs-attribute,
.coffeescript .hljs-property,
.hljs-phony {
color: #88f;
}
.hljs-keyword,
.hljs-id,
.hljs-title,
.hljs-built_in,
.css .hljs-tag,
.hljs-javadoctag,
.hljs-phpdoc,
.hljs-dartdoc,
.hljs-yardoctag,
.smalltalk .hljs-class,
.hljs-winutils,
.bash .hljs-variable,
.apache .hljs-tag,
.hljs-type,
.hljs-typename,
.tex .hljs-command,
.asciidoc .hljs-strong,
.markdown .hljs-strong,
.hljs-request,
.hljs-status {
font-weight: bold;
}
.asciidoc .hljs-emphasis,
.markdown .hljs-emphasis {
font-style: italic;
}
.nginx .hljs-built_in {
font-weight: normal;
}
.coffeescript .javascript,
.javascript .xml,
.lasso .markup,
.tex .hljs-formula,
.xml .javascript,
.xml .vbscript,
.xml .css,
.xml .hljs-cdata {
opacity: 0.5;
}
</style>
</head>
<body>
<div id="elm-doc-preview">
Here we go docpreview
</div>
<script type="text/javascript" src="/highlight.pack.js"></script>
<script type="text/javascript" src="/docPreview.js"></script>
<script type="text/javascript">
var preview = Elm.embed(Elm.DocPreview,
document.getElementById("elm-doc-preview"),
{modules: '[]', selectModule: ''});
var modules = '[{"name": "Dull", "comment": " The awesome dull module\\n\\n## Awesome math\\n@docs dill, Model\\n", "aliases": [{"name": "Model", "comment": " This is the model you know", "args": [ "a"], "type": "{ a | id : Maybe.Maybe Int, name : String }"}], "types": [], "values": [{"name": "dill", "comment": " Add in a disguised nice manner\\n\\n \\"hello\\" ++ \\"world\\" == \\"helloworld\\"\\n [1,1,2] ++ [3,5,8] == [1,1,2,3,5,8]","type": "number -> number -> number"}],"generated-with-elm-version": "0.16.0"}]';
//preview.ports.modules.send(modules);
//preview.ports.selectModule.send("Dull");
</script>
</body>
</html>
================================================
FILE: DocPreview/LICENSE
================================================
Copyright (c) 2014, Evan Czaplicki
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the following
disclaimer in the documentation and/or other materials provided
with the distribution.
* Neither the name of Evan Czaplicki nor the names of other
contributors may be used to endorse or promote products derived
from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
================================================
FILE: DocPreview/docPreview.js
================================================
var Elm = Elm || { Native: {} };
Elm.Native.Array = {};
Elm.Native.Array.make = function(localRuntime) {
localRuntime.Native = localRuntime.Native || {};
localRuntime.Native.Array = localRuntime.Native.Array || {};
if (localRuntime.Native.Array.values)
{
return localRuntime.Native.Array.values;
}
if ('values' in Elm.Native.Array)
{
return localRuntime.Native.Array.values = Elm.Native.Array.values;
}
var List = Elm.Native.List.make(localRuntime);
// A RRB-Tree has two distinct data types.
// Leaf -> "height" is always 0
// "table" is an array of elements
// Node -> "height" is always greater than 0
// "table" is an array of child nodes
// "lengths" is an array of accumulated lengths of the child nodes
// M is the maximal table size. 32 seems fast. E is the allowed increase
// of search steps when concatting to find an index. Lower values will
// decrease balancing, but will increase search steps.
var M = 32;
var E = 2;
// An empty array.
var empty = {
ctor: '_Array',
height: 0,
table: []
};
function get(i, array)
{
if (i < 0 || i >= length(array))
{
throw new Error(
'Index ' + i + ' is out of range. Check the length of ' +
'your array first or use getMaybe or getWithDefault.');
}
return unsafeGet(i, array);
}
function unsafeGet(i, array)
{
for (var x = array.height; x > 0; x--)
{
var slot = i >> (x * 5);
while (array.lengths[slot] <= i)
{
slot++;
}
if (slot > 0)
{
i -= array.lengths[slot - 1];
}
array = array.table[slot];
}
return array.table[i];
}
// Sets the value at the index i. Only the nodes leading to i will get
// copied and updated.
function set(i, item, array)
{
if (i < 0 || length(array) <= i)
{
return array;
}
return unsafeSet(i, item, array);
}
function unsafeSet(i, item, array)
{
array = nodeCopy(array);
if (array.height === 0)
{
array.table[i] = item;
}
else
{
var slot = getSlot(i, array);
if (slot > 0)
{
i -= array.lengths[slot - 1];
}
array.table[slot] = unsafeSet(i, item, array.table[slot]);
}
return array;
}
function initialize(len, f)
{
if (len <= 0)
{
return empty;
}
var h = Math.floor( Math.log(len) / Math.log(M) );
return initialize_(f, h, 0, len);
}
function initialize_(f, h, from, to)
{
if (h === 0)
{
var table = new Array((to - from) % (M + 1));
for (var i = 0; i < table.length; i++)
{
table[i] = f(from + i);
}
return {
ctor: '_Array',
height: 0,
table: table
};
}
var step = Math.pow(M, h);
var table = new Array(Math.ceil((to - from) / step));
var lengths = new Array(table.length);
for (var i = 0; i < table.length; i++)
{
table[i] = initialize_(f, h - 1, from + (i * step), Math.min(from + ((i + 1) * step), to));
lengths[i] = length(table[i]) + (i > 0 ? lengths[i-1] : 0);
}
return {
ctor: '_Array',
height: h,
table: table,
lengths: lengths
};
}
function fromList(list)
{
if (list === List.Nil)
{
return empty;
}
// Allocate M sized blocks (table) and write list elements to it.
var table = new Array(M);
var nodes = [];
var i = 0;
while (list.ctor !== '[]')
{
table[i] = list._0;
list = list._1;
i++;
// table is full, so we can push a leaf containing it into the
// next node.
if (i === M)
{
var leaf = {
ctor: '_Array',
height: 0,
table: table
};
fromListPush(leaf, nodes);
table = new Array(M);
i = 0;
}
}
// Maybe there is something left on the table.
if (i > 0)
{
var leaf = {
ctor: '_Array',
height: 0,
table: table.splice(0, i)
};
fromListPush(leaf, nodes);
}
// Go through all of the nodes and eventually push them into higher nodes.
for (var h = 0; h < nodes.length - 1; h++)
{
if (nodes[h].table.length > 0)
{
fromListPush(nodes[h], nodes);
}
}
var head = nodes[nodes.length - 1];
if (head.height > 0 && head.table.length === 1)
{
return head.table[0];
}
else
{
return head;
}
}
// Push a node into a higher node as a child.
function fromListPush(toPush, nodes)
{
var h = toPush.height;
// Maybe the node on this height does not exist.
if (nodes.length === h)
{
var node = {
ctor: '_Array',
height: h + 1,
table: [],
lengths: []
};
nodes.push(node);
}
nodes[h].table.push(toPush);
var len = length(toPush);
if (nodes[h].lengths.length > 0)
{
len += nodes[h].lengths[nodes[h].lengths.length - 1];
}
nodes[h].lengths.push(len);
if (nodes[h].table.length === M)
{
fromListPush(nodes[h], nodes);
nodes[h] = {
ctor: '_Array',
height: h + 1,
table: [],
lengths: []
};
}
}
// Pushes an item via push_ to the bottom right of a tree.
function push(item, a)
{
var pushed = push_(item, a);
if (pushed !== null)
{
return pushed;
}
var newTree = create(item, a.height);
return siblise(a, newTree);
}
// Recursively tries to push an item to the bottom-right most
// tree possible. If there is no space left for the item,
// null will be returned.
function push_(item, a)
{
// Handle resursion stop at leaf level.
if (a.height === 0)
{
if (a.table.length < M)
{
var newA = {
ctor: '_Array',
height: 0,
table: a.table.slice()
};
newA.table.push(item);
return newA;
}
else
{
return null;
}
}
// Recursively push
var pushed = push_(item, botRight(a));
// There was space in the bottom right tree, so the slot will
// be updated.
if (pushed !== null)
{
var newA = nodeCopy(a);
newA.table[newA.table.length - 1] = pushed;
newA.lengths[newA.lengths.length - 1]++;
return newA;
}
// When there was no space left, check if there is space left
// for a new slot with a tree which contains only the item
// at the bottom.
if (a.table.length < M)
{
var newSlot = create(item, a.height - 1);
var newA = nodeCopy(a);
newA.table.push(newSlot);
newA.lengths.push(newA.lengths[newA.lengths.length - 1] + length(newSlot));
return newA;
}
else
{
return null;
}
}
// Converts an array into a list of elements.
function toList(a)
{
return toList_(List.Nil, a);
}
function toList_(list, a)
{
for (var i = a.table.length - 1; i >= 0; i--)
{
list =
a.height === 0
? List.Cons(a.table[i], list)
: toList_(list, a.table[i]);
}
return list;
}
// Maps a function over the elements of an array.
function map(f, a)
{
var newA = {
ctor: '_Array',
height: a.height,
table: new Array(a.table.length)
};
if (a.height > 0)
{
newA.lengths = a.lengths;
}
for (var i = 0; i < a.table.length; i++)
{
newA.table[i] =
a.height === 0
? f(a.table[i])
: map(f, a.table[i]);
}
return newA;
}
// Maps a function over the elements with their index as first argument.
function indexedMap(f, a)
{
return indexedMap_(f, a, 0);
}
function indexedMap_(f, a, from)
{
var newA = {
ctor: '_Array',
height: a.height,
table: new Array(a.table.length)
};
if (a.height > 0)
{
newA.lengths = a.lengths;
}
for (var i = 0; i < a.table.length; i++)
{
newA.table[i] =
a.height === 0
? A2(f, from + i, a.table[i])
: indexedMap_(f, a.table[i], i == 0 ? from : from + a.lengths[i - 1]);
}
return newA;
}
function foldl(f, b, a)
{
if (a.height === 0)
{
for (var i = 0; i < a.table.length; i++)
{
b = A2(f, a.table[i], b);
}
}
else
{
for (var i = 0; i < a.table.length; i++)
{
b = foldl(f, b, a.table[i]);
}
}
return b;
}
function foldr(f, b, a)
{
if (a.height === 0)
{
for (var i = a.table.length; i--; )
{
b = A2(f, a.table[i], b);
}
}
else
{
for (var i = a.table.length; i--; )
{
b = foldr(f, b, a.table[i]);
}
}
return b;
}
// TODO: currently, it slices the right, then the left. This can be
// optimized.
function slice(from, to, a)
{
if (from < 0)
{
from += length(a);
}
if (to < 0)
{
to += length(a);
}
return sliceLeft(from, sliceRight(to, a));
}
function sliceRight(to, a)
{
if (to === length(a))
{
return a;
}
// Handle leaf level.
if (a.height === 0)
{
var newA = { ctor:'_Array', height:0 };
newA.table = a.table.slice(0, to);
return newA;
}
// Slice the right recursively.
var right = getSlot(to, a);
var sliced = sliceRight(to - (right > 0 ? a.lengths[right - 1] : 0), a.table[right]);
// Maybe the a node is not even needed, as sliced contains the whole slice.
if (right === 0)
{
return sliced;
}
// Create new node.
var newA = {
ctor: '_Array',
height: a.height,
table: a.table.slice(0, right),
lengths: a.lengths.slice(0, right)
};
if (sliced.table.length > 0)
{
newA.table[right] = sliced;
newA.lengths[right] = length(sliced) + (right > 0 ? newA.lengths[right - 1] : 0);
}
return newA;
}
function sliceLeft(from, a)
{
if (from === 0)
{
return a;
}
// Handle leaf level.
if (a.height === 0)
{
var newA = { ctor:'_Array', height:0 };
newA.table = a.table.slice(from, a.table.length + 1);
return newA;
}
// Slice the left recursively.
var left = getSlot(from, a);
var sliced = sliceLeft(from - (left > 0 ? a.lengths[left - 1] : 0), a.table[left]);
// Maybe the a node is not even needed, as sliced contains the whole slice.
if (left === a.table.length - 1)
{
return sliced;
}
// Create new node.
var newA = {
ctor: '_Array',
height: a.height,
table: a.table.slice(left, a.table.length + 1),
lengths: new Array(a.table.length - left)
};
newA.table[0] = sliced;
var len = 0;
for (var i = 0; i < newA.table.length; i++)
{
len += length(newA.table[i]);
newA.lengths[i] = len;
}
return newA;
}
// Appends two trees.
function append(a,b)
{
if (a.table.length === 0)
{
return b;
}
if (b.table.length === 0)
{
return a;
}
var c = append_(a, b);
// Check if both nodes can be crunshed together.
if (c[0].table.length + c[1].table.length <= M)
{
if (c[0].table.length === 0)
{
return c[1];
}
if (c[1].table.length === 0)
{
return c[0];
}
// Adjust .table and .lengths
c[0].table = c[0].table.concat(c[1].table);
if (c[0].height > 0)
{
var len = length(c[0]);
for (var i = 0; i < c[1].lengths.length; i++)
{
c[1].lengths[i] += len;
}
c[0].lengths = c[0].lengths.concat(c[1].lengths);
}
return c[0];
}
if (c[0].height > 0)
{
var toRemove = calcToRemove(a, b);
if (toRemove > E)
{
c = shuffle(c[0], c[1], toRemove);
}
}
return siblise(c[0], c[1]);
}
// Returns an array of two nodes; right and left. One node _may_ be empty.
function append_(a, b)
{
if (a.height === 0 && b.height === 0)
{
return [a, b];
}
if (a.height !== 1 || b.height !== 1)
{
if (a.height === b.height)
{
a = nodeCopy(a);
b = nodeCopy(b);
var appended = append_(botRight(a), botLeft(b));
insertRight(a, appended[1]);
insertLeft(b, appended[0]);
}
else if (a.height > b.height)
{
a = nodeCopy(a);
var appended = append_(botRight(a), b);
insertRight(a, appended[0]);
b = parentise(appended[1], appended[1].height + 1);
}
else
{
b = nodeCopy(b);
var appended = append_(a, botLeft(b));
var left = appended[0].table.length === 0 ? 0 : 1;
var right = left === 0 ? 1 : 0;
insertLeft(b, appended[left]);
a = parentise(appended[right], appended[right].height + 1);
}
}
// Check if balancing is needed and return based on that.
if (a.table.length === 0 || b.table.length === 0)
{
return [a, b];
}
var toRemove = calcToRemove(a, b);
if (toRemove <= E)
{
return [a, b];
}
return shuffle(a, b, toRemove);
}
// Helperfunctions for append_. Replaces a child node at the side of the parent.
function insertRight(parent, node)
{
var index = parent.table.length - 1;
parent.table[index] = node;
parent.lengths[index] = length(node);
parent.lengths[index] += index > 0 ? parent.lengths[index - 1] : 0;
}
function insertLeft(parent, node)
{
if (node.table.length > 0)
{
parent.table[0] = node;
parent.lengths[0] = length(node);
var len = length(parent.table[0]);
for (var i = 1; i < parent.lengths.length; i++)
{
len += length(parent.table[i]);
parent.lengths[i] = len;
}
}
else
{
parent.table.shift();
for (var i = 1; i < parent.lengths.length; i++)
{
parent.lengths[i] = parent.lengths[i] - parent.lengths[0];
}
parent.lengths.shift();
}
}
// Returns the extra search steps for E. Refer to the paper.
function calcToRemove(a, b)
{
var subLengths = 0;
for (var i = 0; i < a.table.length; i++)
{
subLengths += a.table[i].table.length;
}
for (var i = 0; i < b.table.length; i++)
{
subLengths += b.table[i].table.length;
}
var toRemove = a.table.length + b.table.length;
return toRemove - (Math.floor((subLengths - 1) / M) + 1);
}
// get2, set2 and saveSlot are helpers for accessing elements over two arrays.
function get2(a, b, index)
{
return index < a.length
? a[index]
: b[index - a.length];
}
function set2(a, b, index, value)
{
if (index < a.length)
{
a[index] = value;
}
else
{
b[index - a.length] = value;
}
}
function saveSlot(a, b, index, slot)
{
set2(a.table, b.table, index, slot);
var l = (index === 0 || index === a.lengths.length)
? 0
: get2(a.lengths, a.lengths, index - 1);
set2(a.lengths, b.lengths, index, l + length(slot));
}
// Creates a node or leaf with a given length at their arrays for perfomance.
// Is only used by shuffle.
function createNode(h, length)
{
if (length < 0)
{
length = 0;
}
var a = {
ctor: '_Array',
height: h,
table: new Array(length)
};
if (h > 0)
{
a.lengths = new Array(length);
}
return a;
}
// Returns an array of two balanced nodes.
function shuffle(a, b, toRemove)
{
var newA = createNode(a.height, Math.min(M, a.table.length + b.table.length - toRemove));
var newB = createNode(a.height, newA.table.length - (a.table.length + b.table.length - toRemove));
// Skip the slots with size M. More precise: copy the slot references
// to the new node
var read = 0;
while (get2(a.table, b.table, read).table.length % M === 0)
{
set2(newA.table, newB.table, read, get2(a.table, b.table, read));
set2(newA.lengths, newB.lengths, read, get2(a.lengths, b.lengths, read));
read++;
}
// Pulling items from left to right, caching in a slot before writing
// it into the new nodes.
var write = read;
var slot = new createNode(a.height - 1, 0);
var from = 0;
// If the current slot is still containing data, then there will be at
// least one more write, so we do not break this loop yet.
while (read - write - (slot.table.length > 0 ? 1 : 0) < toRemove)
{
// Find out the max possible items for copying.
var source = get2(a.table, b.table, read);
var to = Math.min(M - slot.table.length, source.table.length);
// Copy and adjust size table.
slot.table = slot.table.concat(source.table.slice(from, to));
if (slot.height > 0)
{
var len = slot.lengths.length;
for (var i = len; i < len + to - from; i++)
{
slot.lengths[i] = length(slot.table[i]);
slot.lengths[i] += (i > 0 ? slot.lengths[i - 1] : 0);
}
}
from += to;
// Only proceed to next slots[i] if the current one was
// fully copied.
if (source.table.length <= to)
{
read++; from = 0;
}
// Only create a new slot if the current one is filled up.
if (slot.table.length === M)
{
saveSlot(newA, newB, write, slot);
slot = createNode(a.height - 1, 0);
write++;
}
}
// Cleanup after the loop. Copy the last slot into the new nodes.
if (slot.table.length > 0)
{
saveSlot(newA, newB, write, slot);
write++;
}
// Shift the untouched slots to the left
while (read < a.table.length + b.table.length )
{
saveSlot(newA, newB, write, get2(a.table, b.table, read));
read++;
write++;
}
return [newA, newB];
}
// Navigation functions
function botRight(a)
{
return a.table[a.table.length - 1];
}
function botLeft(a)
{
return a.table[0];
}
// Copies a node for updating. Note that you should not use this if
// only updating only one of "table" or "lengths" for performance reasons.
function nodeCopy(a)
{
var newA = {
ctor: '_Array',
height: a.height,
table: a.table.slice()
};
if (a.height > 0)
{
newA.lengths = a.lengths.slice();
}
return newA;
}
// Returns how many items are in the tree.
function length(array)
{
if (array.height === 0)
{
return array.table.length;
}
else
{
return array.lengths[array.lengths.length - 1];
}
}
// Calculates in which slot of "table" the item probably is, then
// find the exact slot via forward searching in "lengths". Returns the index.
function getSlot(i, a)
{
var slot = i >> (5 * a.height);
while (a.lengths[slot] <= i)
{
slot++;
}
return slot;
}
// Recursively creates a tree with a given height containing
// only the given item.
function create(item, h)
{
if (h === 0)
{
return {
ctor: '_Array',
height: 0,
table: [item]
};
}
return {
ctor: '_Array',
height: h,
table: [create(item, h - 1)],
lengths: [1]
};
}
// Recursively creates a tree that contains the given tree.
function parentise(tree, h)
{
if (h === tree.height)
{
return tree;
}
return {
ctor: '_Array',
height: h,
table: [parentise(tree, h - 1)],
lengths: [length(tree)]
};
}
// Emphasizes blood brotherhood beneath two trees.
function siblise(a, b)
{
return {
ctor: '_Array',
height: a.height + 1,
table: [a, b],
lengths: [length(a), length(a) + length(b)]
};
}
function toJSArray(a)
{
var jsArray = new Array(length(a));
toJSArray_(jsArray, 0, a);
return jsArray;
}
function toJSArray_(jsArray, i, a)
{
for (var t = 0; t < a.table.length; t++)
{
if (a.height === 0)
{
jsArray[i + t] = a.table[t];
}
else
{
var inc = t === 0 ? 0 : a.lengths[t - 1];
toJSArray_(jsArray, i + inc, a.table[t]);
}
}
}
function fromJSArray(jsArray)
{
if (jsArray.length === 0)
{
return empty;
}
var h = Math.floor(Math.log(jsArray.length) / Math.log(M));
return fromJSArray_(jsArray, h, 0, jsArray.length);
}
function fromJSArray_(jsArray, h, from, to)
{
if (h === 0)
{
return {
ctor: '_Array',
height: 0,
table: jsArray.slice(from, to)
};
}
var step = Math.pow(M, h);
var table = new Array(Math.ceil((to - from) / step));
var lengths = new Array(table.length);
for (var i = 0; i < table.length; i++)
{
table[i] = fromJSArray_(jsArray, h - 1, from + (i * step), Math.min(from + ((i + 1) * step), to));
lengths[i] = length(table[i]) + (i > 0 ? lengths[i - 1] : 0);
}
return {
ctor: '_Array',
height: h,
table: table,
lengths: lengths
};
}
Elm.Native.Array.values = {
empty: empty,
fromList: fromList,
toList: toList,
initialize: F2(initialize),
append: F2(append),
push: F2(push),
slice: F3(slice),
get: F2(get),
set: F3(set),
map: F2(map),
indexedMap: F2(indexedMap),
foldl: F3(foldl),
foldr: F3(foldr),
length: length,
toJSArray: toJSArray,
fromJSArray: fromJSArray
};
return localRuntime.Native.Array.values = Elm.Native.Array.values;
};
Elm.Native.Basics = {};
Elm.Native.Basics.make = function(localRuntime) {
localRuntime.Native = localRuntime.Native || {};
localRuntime.Native.Basics = localRuntime.Native.Basics || {};
if (localRuntime.Native.Basics.values)
{
return localRuntime.Native.Basics.values;
}
var Utils = Elm.Native.Utils.make(localRuntime);
function div(a, b)
{
return (a / b) | 0;
}
function rem(a, b)
{
return a % b;
}
function mod(a, b)
{
if (b === 0)
{
throw new Error('Cannot perform mod 0. Division by zero error.');
}
var r = a % b;
var m = a === 0 ? 0 : (b > 0 ? (a >= 0 ? r : r + b) : -mod(-a, -b));
return m === b ? 0 : m;
}
function logBase(base, n)
{
return Math.log(n) / Math.log(base);
}
function negate(n)
{
return -n;
}
function abs(n)
{
return n < 0 ? -n : n;
}
function min(a, b)
{
return Utils.cmp(a, b) < 0 ? a : b;
}
function max(a, b)
{
return Utils.cmp(a, b) > 0 ? a : b;
}
function clamp(lo, hi, n)
{
return Utils.cmp(n, lo) < 0 ? lo : Utils.cmp(n, hi) > 0 ? hi : n;
}
function xor(a, b)
{
return a !== b;
}
function not(b)
{
return !b;
}
function isInfinite(n)
{
return n === Infinity || n === -Infinity;
}
function truncate(n)
{
return n | 0;
}
function degrees(d)
{
return d * Math.PI / 180;
}
function turns(t)
{
return 2 * Math.PI * t;
}
function fromPolar(point)
{
var r = point._0;
var t = point._1;
return Utils.Tuple2(r * Math.cos(t), r * Math.sin(t));
}
function toPolar(point)
{
var x = point._0;
var y = point._1;
return Utils.Tuple2(Math.sqrt(x * x + y * y), Math.atan2(y, x));
}
return localRuntime.Native.Basics.values = {
div: F2(div),
rem: F2(rem),
mod: F2(mod),
pi: Math.PI,
e: Math.E,
cos: Math.cos,
sin: Math.sin,
tan: Math.tan,
acos: Math.acos,
asin: Math.asin,
atan: Math.atan,
atan2: F2(Math.atan2),
degrees: degrees,
turns: turns,
fromPolar: fromPolar,
toPolar: toPolar,
sqrt: Math.sqrt,
logBase: F2(logBase),
negate: negate,
abs: abs,
min: F2(min),
max: F2(max),
clamp: F3(clamp),
compare: Utils.compare,
xor: F2(xor),
not: not,
truncate: truncate,
ceiling: Math.ceil,
floor: Math.floor,
round: Math.round,
toFloat: function(x) { return x; },
isNaN: isNaN,
isInfinite: isInfinite
};
};
Elm.Native.Port = {};
Elm.Native.Port.make = function(localRuntime) {
localRuntime.Native = localRuntime.Native || {};
localRuntime.Native.Port = localRuntime.Native.Port || {};
if (localRuntime.Native.Port.values)
{
return localRuntime.Native.Port.values;
}
var NS;
// INBOUND
function inbound(name, type, converter)
{
if (!localRuntime.argsTracker[name])
{
throw new Error(
'Port Error:\n' +
'No argument was given for the port named \'' + name + '\' with type:\n\n' +
' ' + type.split('\n').join('\n ') + '\n\n' +
'You need to provide an initial value!\n\n' +
'Find out more about ports here <http://elm-lang.org/learn/Ports.elm>'
);
}
var arg = localRuntime.argsTracker[name];
arg.used = true;
return jsToElm(name, type, converter, arg.value);
}
function inboundSignal(name, type, converter)
{
var initialValue = inbound(name, type, converter);
if (!NS)
{
NS = Elm.Native.Signal.make(localRuntime);
}
var signal = NS.input('inbound-port-' + name, initialValue);
function send(jsValue)
{
var elmValue = jsToElm(name, type, converter, jsValue);
setTimeout(function() {
localRuntime.notify(signal.id, elmValue);
}, 0);
}
localRuntime.ports[name] = { send: send };
return signal;
}
function jsToElm(name, type, converter, value)
{
try
{
return converter(value);
}
catch(e)
{
throw new Error(
'Port Error:\n' +
'Regarding the port named \'' + name + '\' with type:\n\n' +
' ' + type.split('\n').join('\n ') + '\n\n' +
'You just sent the value:\n\n' +
' ' + JSON.stringify(value) + '\n\n' +
'but it cannot be converted to the necessary type.\n' +
e.message
);
}
}
// OUTBOUND
function outbound(name, converter, elmValue)
{
localRuntime.ports[name] = converter(elmValue);
}
function outboundSignal(name, converter, signal)
{
var subscribers = [];
function subscribe(handler)
{
subscribers.push(handler);
}
function unsubscribe(handler)
{
subscribers.pop(subscribers.indexOf(handler));
}
function notify(elmValue)
{
var jsValue = converter(elmValue);
var len = subscribers.length;
for (var i = 0; i < len; ++i)
{
subscribers[i](jsValue);
}
}
if (!NS)
{
NS = Elm.Native.Signal.make(localRuntime);
}
NS.output('outbound-port-' + name, notify, signal);
localRuntime.ports[name] = {
subscribe: subscribe,
unsubscribe: unsubscribe
};
return signal;
}
return localRuntime.Native.Port.values = {
inbound: inbound,
outbound: outbound,
inboundSignal: inboundSignal,
outboundSignal: outboundSignal
};
};
if (!Elm.fullscreen) {
(function() {
'use strict';
var Display = {
FULLSCREEN: 0,
COMPONENT: 1,
NONE: 2
};
Elm.fullscreen = function(module, args)
{
var container = document.createElement('div');
document.body.appendChild(container);
return init(Display.FULLSCREEN, container, module, args || {});
};
Elm.embed = function(module, container, args)
{
var tag = container.tagName;
if (tag !== 'DIV')
{
throw new Error('Elm.node must be given a DIV, not a ' + tag + '.');
}
return init(Display.COMPONENT, container, module, args || {});
};
Elm.worker = function(module, args)
{
return init(Display.NONE, {}, module, args || {});
};
function init(display, container, module, args, moduleToReplace)
{
// defining state needed for an instance of the Elm RTS
var inputs = [];
/* OFFSET
* Elm's time traveling debugger lets you pause time. This means
* "now" may be shifted a bit into the past. By wrapping Date.now()
* we can manage this.
*/
var timer = {
programStart: Date.now(),
now: function()
{
return Date.now();
}
};
var updateInProgress = false;
function notify(id, v)
{
if (updateInProgress)
{
throw new Error(
'The notify function has been called synchronously!\n' +
'This can lead to frames being dropped.\n' +
'Definitely report this to <https://github.com/elm-lang/Elm/issues>\n');
}
updateInProgress = true;
var timestep = timer.now();
for (var i = inputs.length; i--; )
{
inputs[i].notify(timestep, id, v);
}
updateInProgress = false;
}
function setTimeout(func, delay)
{
return window.setTimeout(func, delay);
}
var listeners = [];
function addListener(relevantInputs, domNode, eventName, func)
{
domNode.addEventListener(eventName, func);
var listener = {
relevantInputs: relevantInputs,
domNode: domNode,
eventName: eventName,
func: func
};
listeners.push(listener);
}
var argsTracker = {};
for (var name in args)
{
argsTracker[name] = {
value: args[name],
used: false
};
}
// create the actual RTS. Any impure modules will attach themselves to this
// object. This permits many Elm programs to be embedded per document.
var elm = {
notify: notify,
setTimeout: setTimeout,
node: container,
addListener: addListener,
inputs: inputs,
timer: timer,
argsTracker: argsTracker,
ports: {},
isFullscreen: function() { return display === Display.FULLSCREEN; },
isEmbed: function() { return display === Display.COMPONENT; },
isWorker: function() { return display === Display.NONE; }
};
function swap(newModule)
{
removeListeners(listeners);
var div = document.createElement('div');
var newElm = init(display, div, newModule, args, elm);
inputs = [];
return newElm;
}
function dispose()
{
removeListeners(listeners);
inputs = [];
}
var Module = {};
try
{
Module = module.make(elm);
checkInputs(elm);
}
catch (error)
{
if (typeof container.appendChild === "function")
{
container.appendChild(errorNode(error.message));
}
else
{
console.error(error.message);
}
throw error;
}
if (display !== Display.NONE)
{
var graphicsNode = initGraphics(elm, Module);
}
var rootNode = { kids: inputs };
trimDeadNodes(rootNode);
inputs = rootNode.kids;
filterListeners(inputs, listeners);
addReceivers(elm.ports);
if (typeof moduleToReplace !== 'undefined')
{
hotSwap(moduleToReplace, elm);
// rerender scene if graphics are enabled.
if (typeof graphicsNode !== 'undefined')
{
graphicsNode.notify(0, true, 0);
}
}
return {
swap: swap,
ports: elm.ports,
dispose: dispose
};
}
function checkInputs(elm)
{
var argsTracker = elm.argsTracker;
for (var name in argsTracker)
{
if (!argsTracker[name].used)
{
throw new Error(
"Port Error:\nYou provided an argument named '" + name +
"' but there is no corresponding port!\n\n" +
"Maybe add a port '" + name + "' to your Elm module?\n" +
"Maybe remove the '" + name + "' argument from your initialization code in JS?"
);
}
}
}
function errorNode(message)
{
var code = document.createElement('code');
var lines = message.split('\n');
code.appendChild(document.createTextNode(lines[0]));
code.appendChild(document.createElement('br'));
code.appendChild(document.createElement('br'));
for (var i = 1; i < lines.length; ++i)
{
code.appendChild(document.createTextNode('\u00A0 \u00A0 ' + lines[i].replace(/ /g, '\u00A0 ')));
code.appendChild(document.createElement('br'));
}
code.appendChild(document.createElement('br'));
code.appendChild(document.createTextNode('Open the developer console for more details.'));
return code;
}
//// FILTER SIGNALS ////
// TODO: move this code into the signal module and create a function
// Signal.initializeGraph that actually instantiates everything.
function filterListeners(inputs, listeners)
{
loop:
for (var i = listeners.length; i--; )
{
var listener = listeners[i];
for (var j = inputs.length; j--; )
{
if (listener.relevantInputs.indexOf(inputs[j].id) >= 0)
{
continue loop;
}
}
listener.domNode.removeEventListener(listener.eventName, listener.func);
}
}
function removeListeners(listeners)
{
for (var i = listeners.length; i--; )
{
var listener = listeners[i];
listener.domNode.removeEventListener(listener.eventName, listener.func);
}
}
// add receivers for built-in ports if they are defined
function addReceivers(ports)
{
if ('title' in ports)
{
if (typeof ports.title === 'string')
{
document.title = ports.title;
}
else
{
ports.title.subscribe(function(v) { document.title = v; });
}
}
if ('redirect' in ports)
{
ports.redirect.subscribe(function(v) {
if (v.length > 0)
{
window.location = v;
}
});
}
}
// returns a boolean representing whether the node is alive or not.
function trimDeadNodes(node)
{
if (node.isOutput)
{
return true;
}
var liveKids = [];
for (var i = node.kids.length; i--; )
{
var kid = node.kids[i];
if (trimDeadNodes(kid))
{
liveKids.push(kid);
}
}
node.kids = liveKids;
return liveKids.length > 0;
}
//// RENDERING ////
function initGraphics(elm, Module)
{
if (!('main' in Module))
{
throw new Error("'main' is missing! What do I display?!");
}
var signalGraph = Module.main;
// make sure the signal graph is actually a signal & extract the visual model
if (!('notify' in signalGraph))
{
signalGraph = Elm.Signal.make(elm).constant(signalGraph);
}
var initialScene = signalGraph.value;
// Figure out what the render functions should be
var render;
var update;
if (initialScene.ctor === 'Element_elm_builtin')
{
var Element = Elm.Native.Graphics.Element.make(elm);
render = Element.render;
update = Element.updateAndReplace;
}
else
{
var VirtualDom = Elm.Native.VirtualDom.make(elm);
render = VirtualDom.render;
update = VirtualDom.updateAndReplace;
}
// Add the initialScene to the DOM
var container = elm.node;
var node = render(initialScene);
while (container.firstChild)
{
container.removeChild(container.firstChild);
}
container.appendChild(node);
var _requestAnimationFrame =
typeof requestAnimationFrame !== 'undefined'
? requestAnimationFrame
: function(cb) { setTimeout(cb, 1000 / 60); }
;
// domUpdate is called whenever the main Signal changes.
//
// domUpdate and drawCallback implement a small state machine in order
// to schedule only 1 draw per animation frame. This enforces that
// once draw has been called, it will not be called again until the
// next frame.
//
// drawCallback is scheduled whenever
// 1. The state transitions from PENDING_REQUEST to EXTRA_REQUEST, or
// 2. The state transitions from NO_REQUEST to PENDING_REQUEST
//
// Invariants:
// 1. In the NO_REQUEST state, there is never a scheduled drawCallback.
// 2. In the PENDING_REQUEST and EXTRA_REQUEST states, there is always exactly 1
// scheduled drawCallback.
var NO_REQUEST = 0;
var PENDING_REQUEST = 1;
var EXTRA_REQUEST = 2;
var state = NO_REQUEST;
var savedScene = initialScene;
var scheduledScene = initialScene;
function domUpdate(newScene)
{
scheduledScene = newScene;
switch (state)
{
case NO_REQUEST:
_requestAnimationFrame(drawCallback);
state = PENDING_REQUEST;
return;
case PENDING_REQUEST:
state = PENDING_REQUEST;
return;
case EXTRA_REQUEST:
state = PENDING_REQUEST;
return;
}
}
function drawCallback()
{
switch (state)
{
case NO_REQUEST:
// This state should not be possible. How can there be no
// request, yet somehow we are actively fulfilling a
// request?
throw new Error(
'Unexpected draw callback.\n' +
'Please report this to <https://github.com/elm-lang/core/issues>.'
);
case PENDING_REQUEST:
// At this point, we do not *know* that another frame is
// needed, but we make an extra request to rAF just in
// case. It's possible to drop a frame if rAF is called
// too late, so we just do it preemptively.
_requestAnimationFrame(drawCallback);
state = EXTRA_REQUEST;
// There's also stuff we definitely need to draw.
draw();
return;
case EXTRA_REQUEST:
// Turns out the extra request was not needed, so we will
// stop calling rAF. No reason to call it all the time if
// no one needs it.
state = NO_REQUEST;
return;
}
}
function draw()
{
update(elm.node.firstChild, savedScene, scheduledScene);
if (elm.Native.Window)
{
elm.Native.Window.values.resizeIfNeeded();
}
savedScene = scheduledScene;
}
var renderer = Elm.Native.Signal.make(elm).output('main', domUpdate, signalGraph);
// must check for resize after 'renderer' is created so
// that changes show up.
if (elm.Native.Window)
{
elm.Native.Window.values.resizeIfNeeded();
}
return renderer;
}
//// HOT SWAPPING ////
// Returns boolean indicating if the swap was successful.
// Requires that the two signal graphs have exactly the same
// structure.
function hotSwap(from, to)
{
function similar(nodeOld, nodeNew)
{
if (nodeOld.id !== nodeNew.id)
{
return false;
}
if (nodeOld.isOutput)
{
return nodeNew.isOutput;
}
return nodeOld.kids.length === nodeNew.kids.length;
}
function swap(nodeOld, nodeNew)
{
nodeNew.value = nodeOld.value;
return true;
}
var canSwap = depthFirstTraversals(similar, from.inputs, to.inputs);
if (canSwap)
{
depthFirstTraversals(swap, from.inputs, to.inputs);
}
from.node.parentNode.replaceChild(to.node, from.node);
return canSwap;
}
// Returns false if the node operation f ever fails.
function depthFirstTraversals(f, queueOld, queueNew)
{
if (queueOld.length !== queueNew.length)
{
return false;
}
queueOld = queueOld.slice(0);
queueNew = queueNew.slice(0);
var seen = [];
while (queueOld.length > 0 && queueNew.length > 0)
{
var nodeOld = queueOld.pop();
var nodeNew = queueNew.pop();
if (seen.indexOf(nodeOld.id) < 0)
{
if (!f(nodeOld, nodeNew))
{
return false;
}
queueOld = queueOld.concat(nodeOld.kids || []);
queueNew = queueNew.concat(nodeNew.kids || []);
seen.push(nodeOld.id);
}
}
return true;
}
}());
function F2(fun)
{
function wrapper(a) { return function(b) { return fun(a,b); }; }
wrapper.arity = 2;
wrapper.func = fun;
return wrapper;
}
function F3(fun)
{
function wrapper(a) {
return function(b) { return function(c) { return fun(a, b, c); }; };
}
wrapper.arity = 3;
wrapper.func = fun;
return wrapper;
}
function F4(fun)
{
function wrapper(a) { return function(b) { return function(c) {
return function(d) { return fun(a, b, c, d); }; }; };
}
wrapper.arity = 4;
wrapper.func = fun;
return wrapper;
}
function F5(fun)
{
function wrapper(a) { return function(b) { return function(c) {
return function(d) { return function(e) { return fun(a, b, c, d, e); }; }; }; };
}
wrapper.arity = 5;
wrapper.func = fun;
return wrapper;
}
function F6(fun)
{
function wrapper(a) { return function(b) { return function(c) {
return function(d) { return function(e) { return function(f) {
return fun(a, b, c, d, e, f); }; }; }; }; };
}
wrapper.arity = 6;
wrapper.func = fun;
return wrapper;
}
function F7(fun)
{
function wrapper(a) { return function(b) { return function(c) {
return function(d) { return function(e) { return function(f) {
return function(g) { return fun(a, b, c, d, e, f, g); }; }; }; }; }; };
}
wrapper.arity = 7;
wrapper.func = fun;
return wrapper;
}
function F8(fun)
{
function wrapper(a) { return function(b) { return function(c) {
return function(d) { return function(e) { return function(f) {
return function(g) { return function(h) {
return fun(a, b, c, d, e, f, g, h); }; }; }; }; }; }; };
}
wrapper.arity = 8;
wrapper.func = fun;
return wrapper;
}
function F9(fun)
{
function wrapper(a) { return function(b) { return function(c) {
return function(d) { return function(e) { return function(f) {
return function(g) { return function(h) { return function(i) {
return fun(a, b, c, d, e, f, g, h, i); }; }; }; }; }; }; }; };
}
wrapper.arity = 9;
wrapper.func = fun;
return wrapper;
}
function A2(fun, a, b)
{
return fun.arity === 2
? fun.func(a, b)
: fun(a)(b);
}
function A3(fun, a, b, c)
{
return fun.arity === 3
? fun.func(a, b, c)
: fun(a)(b)(c);
}
function A4(fun, a, b, c, d)
{
return fun.arity === 4
? fun.func(a, b, c, d)
: fun(a)(b)(c)(d);
}
function A5(fun, a, b, c, d, e)
{
return fun.arity === 5
? fun.func(a, b, c, d, e)
: fun(a)(b)(c)(d)(e);
}
function A6(fun, a, b, c, d, e, f)
{
return fun.arity === 6
? fun.func(a, b, c, d, e, f)
: fun(a)(b)(c)(d)(e)(f);
}
function A7(fun, a, b, c, d, e, f, g)
{
return fun.arity === 7
? fun.func(a, b, c, d, e, f, g)
: fun(a)(b)(c)(d)(e)(f)(g);
}
function A8(fun, a, b, c, d, e, f, g, h)
{
return fun.arity === 8
? fun.func(a, b, c, d, e, f, g, h)
: fun(a)(b)(c)(d)(e)(f)(g)(h);
}
function A9(fun, a, b, c, d, e, f, g, h, i)
{
return fun.arity === 9
? fun.func(a, b, c, d, e, f, g, h, i)
: fun(a)(b)(c)(d)(e)(f)(g)(h)(i);
}
}
Elm.Native = Elm.Native || {};
Elm.Native.Utils = {};
Elm.Native.Utils.make = function(localRuntime) {
localRuntime.Native = localRuntime.Native || {};
localRuntime.Native.Utils = localRuntime.Native.Utils || {};
if (localRuntime.Native.Utils.values)
{
return localRuntime.Native.Utils.values;
}
// COMPARISONS
function eq(l, r)
{
var stack = [{'x': l, 'y': r}];
while (stack.length > 0)
{
var front = stack.pop();
var x = front.x;
var y = front.y;
if (x === y)
{
continue;
}
if (typeof x === 'object')
{
var c = 0;
for (var i in x)
{
++c;
if (i in y)
{
if (i !== 'ctor')
{
stack.push({ 'x': x[i], 'y': y[i] });
}
}
else
{
return false;
}
}
if ('ctor' in x)
{
stack.push({'x': x.ctor, 'y': y.ctor});
}
if (c !== Object.keys(y).length)
{
return false;
}
}
else if (typeof x === 'function')
{
throw new Error('Equality error: general function equality is ' +
'undecidable, and therefore, unsupported');
}
else
{
return false;
}
}
return true;
}
// code in Generate/JavaScript.hs depends on the particular
// integer values assigned to LT, EQ, and GT
var LT = -1, EQ = 0, GT = 1, ord = ['LT', 'EQ', 'GT'];
function compare(x, y)
{
return {
ctor: ord[cmp(x, y) + 1]
};
}
function cmp(x, y) {
var ord;
if (typeof x !== 'object')
{
return x === y ? EQ : x < y ? LT : GT;
}
else if (x.isChar)
{
var a = x.toString();
var b = y.toString();
return a === b
? EQ
: a < b
? LT
: GT;
}
else if (x.ctor === '::' || x.ctor === '[]')
{
while (true)
{
if (x.ctor === '[]' && y.ctor === '[]')
{
return EQ;
}
if (x.ctor !== y.ctor)
{
return x.ctor === '[]' ? LT : GT;
}
ord = cmp(x._0, y._0);
if (ord !== EQ)
{
return ord;
}
x = x._1;
y = y._1;
}
}
else if (x.ctor.slice(0, 6) === '_Tuple')
{
var n = x.ctor.slice(6) - 0;
var err = 'cannot compare tuples with more than 6 elements.';
if (n === 0) return EQ;
if (n >= 1) { ord = cmp(x._0, y._0); if (ord !== EQ) return ord;
if (n >= 2) { ord = cmp(x._1, y._1); if (ord !== EQ) return ord;
if (n >= 3) { ord = cmp(x._2, y._2); if (ord !== EQ) return ord;
if (n >= 4) { ord = cmp(x._3, y._3); if (ord !== EQ) return ord;
if (n >= 5) { ord = cmp(x._4, y._4); if (ord !== EQ) return ord;
if (n >= 6) { ord = cmp(x._5, y._5); if (ord !== EQ) return ord;
if (n >= 7) throw new Error('Comparison error: ' + err); } } } } } }
return EQ;
}
else
{
throw new Error('Comparison error: comparison is only defined on ints, ' +
'floats, times, chars, strings, lists of comparable values, ' +
'and tuples of comparable values.');
}
}
// TUPLES
var Tuple0 = {
ctor: '_Tuple0'
};
function Tuple2(x, y)
{
return {
ctor: '_Tuple2',
_0: x,
_1: y
};
}
// LITERALS
function chr(c)
{
var x = new String(c);
x.isChar = true;
return x;
}
function txt(str)
{
var t = new String(str);
t.text = true;
return t;
}
// GUID
var count = 0;
function guid(_)
{
return count++;
}
// RECORDS
function update(oldRecord, updatedFields)
{
var newRecord = {};
for (var key in oldRecord)
{
var value = (key in updatedFields) ? updatedFields[key] : oldRecord[key];
newRecord[key] = value;
}
return newRecord;
}
// MOUSE COORDINATES
function getXY(e)
{
var posx = 0;
var posy = 0;
if (e.pageX || e.pageY)
{
posx = e.pageX;
posy = e.pageY;
}
else if (e.clientX || e.clientY)
{
posx = e.clientX + document.body.scrollLeft + document.documentElement.scrollLeft;
posy = e.clientY + document.body.scrollTop + document.documentElement.scrollTop;
}
if (localRuntime.isEmbed())
{
var rect = localRuntime.node.getBoundingClientRect();
var relx = rect.left + document.body.scrollLeft + document.documentElement.scrollLeft;
var rely = rect.top + document.body.scrollTop + document.documentElement.scrollTop;
// TODO: figure out if there is a way to avoid rounding here
posx = posx - Math.round(relx) - localRuntime.node.clientLeft;
posy = posy - Math.round(rely) - localRuntime.node.clientTop;
}
return Tuple2(posx, posy);
}
//// LIST STUFF ////
var Nil = { ctor: '[]' };
function Cons(hd, tl)
{
return {
ctor: '::',
_0: hd,
_1: tl
};
}
function list(arr)
{
var out = Nil;
for (var i = arr.length; i--; )
{
out = Cons(arr[i], out);
}
return out;
}
function range(lo, hi)
{
var list = Nil;
if (lo <= hi)
{
do
{
list = Cons(hi, list);
}
while (hi-- > lo);
}
return list;
}
function append(xs, ys)
{
// append Strings
if (typeof xs === 'string')
{
return xs + ys;
}
// append Text
if (xs.ctor.slice(0, 5) === 'Text:')
{
return {
ctor: 'Text:Append',
_0: xs,
_1: ys
};
}
// append Lists
if (xs.ctor === '[]')
{
return ys;
}
var root = Cons(xs._0, Nil);
var curr = root;
xs = xs._1;
while (xs.ctor !== '[]')
{
curr._1 = Cons(xs._0, Nil);
xs = xs._1;
curr = curr._1;
}
curr._1 = ys;
return root;
}
// CRASHES
function crash(moduleName, region)
{
return function(message) {
throw new Error(
'Ran into a `Debug.crash` in module `' + moduleName + '` ' + regionToString(region) + '\n'
+ 'The message provided by the code author is:\n\n '
+ message
);
};
}
function crashCase(moduleName, region, value)
{
return function(message) {
throw new Error(
'Ran into a `Debug.crash` in module `' + moduleName + '`\n\n'
+ 'This was caused by the `case` expression ' + regionToString(region) + '.\n'
+ 'One of the branches ended with a crash and the following value got through:\n\n ' + toString(value) + '\n\n'
+ 'The message provided by the code author is:\n\n '
+ message
);
};
}
function regionToString(region)
{
if (region.start.line == region.end.line)
{
return 'on line ' + region.start.line;
}
return 'between lines ' + region.start.line + ' and ' + region.end.line;
}
// BAD PORTS
function badPort(expected, received)
{
throw new Error(
'Runtime error when sending values through a port.\n\n'
+ 'Expecting ' + expected + ' but was given ' + formatValue(received)
);
}
function formatValue(value)
{
// Explicity format undefined values as "undefined"
// because JSON.stringify(undefined) unhelpfully returns ""
return (value === undefined) ? "undefined" : JSON.stringify(value);
}
// TO STRING
var _Array;
var Dict;
var List;
var toString = function(v)
{
var type = typeof v;
if (type === 'function')
{
var name = v.func ? v.func.name : v.name;
return '<function' + (name === '' ? '' : ': ') + name + '>';
}
else if (type === 'boolean')
{
return v ? 'True' : 'False';
}
else if (type === 'number')
{
return v + '';
}
else if ((v instanceof String) && v.isChar)
{
return '\'' + addSlashes(v, true) + '\'';
}
else if (type === 'string')
{
return '"' + addSlashes(v, false) + '"';
}
else if (type === 'object' && 'ctor' in v)
{
if (v.ctor.substring(0, 6) === '_Tuple')
{
var output = [];
for (var k in v)
{
if (k === 'ctor') continue;
output.push(toString(v[k]));
}
return '(' + output.join(',') + ')';
}
else if (v.ctor === '_Array')
{
if (!_Array)
{
_Array = Elm.Array.make(localRuntime);
}
var list = _Array.toList(v);
return 'Array.fromList ' + toString(list);
}
else if (v.ctor === '::')
{
var output = '[' + toString(v._0);
v = v._1;
while (v.ctor === '::')
{
output += ',' + toString(v._0);
v = v._1;
}
return output + ']';
}
else if (v.ctor === '[]')
{
return '[]';
}
else if (v.ctor === 'RBNode_elm_builtin' || v.ctor === 'RBEmpty_elm_builtin' || v.ctor === 'Set_elm_builtin')
{
if (!Dict)
{
Dict = Elm.Dict.make(localRuntime);
}
var list;
var name;
if (v.ctor === 'Set_elm_builtin')
{
if (!List)
{
List = Elm.List.make(localRuntime);
}
name = 'Set';
list = A2(List.map, function(x) {return x._0; }, Dict.toList(v._0));
}
else
{
name = 'Dict';
list = Dict.toList(v);
}
return name + '.fromList ' + toString(list);
}
else if (v.ctor.slice(0, 5) === 'Text:')
{
return '<text>';
}
else if (v.ctor === 'Element_elm_builtin')
{
return '<element>'
}
else if (v.ctor === 'Form_elm_builtin')
{
return '<form>'
}
else
{
var output = '';
for (var i in v)
{
if (i === 'ctor') continue;
var str = toString(v[i]);
var parenless = str[0] === '{' || str[0] === '<' || str.indexOf(' ') < 0;
output += ' ' + (parenless ? str : '(' + str + ')');
}
return v.ctor + output;
}
}
else if (type === 'object' && 'notify' in v && 'id' in v)
{
return '<signal>';
}
else if (type === 'object')
{
var output = [];
for (var k in v)
{
output.push(k + ' = ' + toString(v[k]));
}
if (output.length === 0)
{
return '{}';
}
return '{ ' + output.join(', ') + ' }';
}
return '<internal structure>';
};
function addSlashes(str, isChar)
{
var s = str.replace(/\\/g, '\\\\')
.replace(/\n/g, '\\n')
.replace(/\t/g, '\\t')
.replace(/\r/g, '\\r')
.replace(/\v/g, '\\v')
.replace(/\0/g, '\\0');
if (isChar)
{
return s.replace(/\'/g, '\\\'');
}
else
{
return s.replace(/\"/g, '\\"');
}
}
return localRuntime.Native.Utils.values = {
eq: eq,
cmp: cmp,
compare: F2(compare),
Tuple0: Tuple0,
Tuple2: Tuple2,
chr: chr,
txt: txt,
update: update,
guid: guid,
getXY: getXY,
Nil: Nil,
Cons: Cons,
list: list,
range: range,
append: F2(append),
crash: crash,
crashCase: crashCase,
badPort: badPort,
toString: toString
};
};
Elm.Basics = Elm.Basics || {};
Elm.Basics.make = function (_elm) {
"use strict";
_elm.Basics = _elm.Basics || {};
if (_elm.Basics.values) return _elm.Basics.values;
var _U = Elm.Native.Utils.make(_elm),$Native$Basics = Elm.Native.Basics.make(_elm),$Native$Utils = Elm.Native.Utils.make(_elm);
var _op = {};
var uncurry = F2(function (f,_p0) { var _p1 = _p0;return A2(f,_p1._0,_p1._1);});
var curry = F3(function (f,a,b) { return f({ctor: "_Tuple2",_0: a,_1: b});});
var flip = F3(function (f,b,a) { return A2(f,a,b);});
var snd = function (_p2) { var _p3 = _p2;return _p3._1;};
var fst = function (_p4) { var _p5 = _p4;return _p5._0;};
var always = F2(function (a,_p6) { return a;});
var identity = function (x) { return x;};
_op["<|"] = F2(function (f,x) { return f(x);});
_op["|>"] = F2(function (x,f) { return f(x);});
_op[">>"] = F3(function (f,g,x) { return g(f(x));});
_op["<<"] = F3(function (g,f,x) { return g(f(x));});
_op["++"] = $Native$Utils.append;
var toString = $Native$Utils.toString;
var isInfinite = $Native$Basics.isInfinite;
var isNaN = $Native$Basics.isNaN;
var toFloat = $Native$Basics.toFloat;
var ceiling = $Native$Basics.ceiling;
var floor = $Native$Basics.floor;
var truncate = $Native$Basics.truncate;
var round = $Native$Basics.round;
var not = $Native$Basics.not;
var xor = $Native$Basics.xor;
_op["||"] = $Native$Basics.or;
_op["&&"] = $Native$Basics.and;
var max = $Native$Basics.max;
var min = $Native$Basics.min;
var GT = {ctor: "GT"};
var EQ = {ctor: "EQ"};
var LT = {ctor: "LT"};
var compare = $Native$Basics.compare;
_op[">="] = $Native$Basics.ge;
_op["<="] = $Native$Basics.le;
_op[">"] = $Native$Basics.gt;
_op["<"] = $Native$Basics.lt;
_op["/="] = $Native$Basics.neq;
_op["=="] = $Native$Basics.eq;
var e = $Native$Basics.e;
var pi = $Native$Basics.pi;
var clamp = $Native$Basics.clamp;
var logBase = $Native$Basics.logBase;
var abs = $Native$Basics.abs;
var negate = $Native$Basics.negate;
var sqrt = $Native$Basics.sqrt;
var atan2 = $Native$Basics.atan2;
var atan = $Native$Basics.atan;
var asin = $Native$Basics.asin;
var acos = $Native$Basics.acos;
var tan = $Native$Basics.tan;
var sin = $Native$Basics.sin;
var cos = $Native$Basics.cos;
_op["^"] = $Native$Basics.exp;
_op["%"] = $Native$Basics.mod;
var rem = $Native$Basics.rem;
_op["//"] = $Native$Basics.div;
_op["/"] = $Native$Basics.floatDiv;
_op["*"] = $Native$Basics.mul;
_op["-"] = $Native$Basics.sub;
_op["+"] = $Native$Basics.add;
var toPolar = $Native$Basics.toPolar;
var fromPolar = $Native$Basics.fromPolar;
var turns = $Native$Basics.turns;
var degrees = $Native$Basics.degrees;
var radians = function (t) { return t;};
return _elm.Basics.values = {_op: _op
,max: max
,min: min
,compare: compare
,not: not
,xor: xor
,rem: rem
,negate: negate
,abs: abs
,sqrt: sqrt
,clamp: clamp
,logBase: logBase
,e: e
,pi: pi
,cos: cos
,sin: sin
,tan: tan
,acos: acos
,asin: asin
,atan: atan
,atan2: atan2
,round: round
,floor: floor
,ceiling: ceiling
,truncate: truncate
,toFloat: toFloat
,degrees: degrees
,radians: radians
,turns: turns
,toPolar: toPolar
,fromPolar: fromPolar
,isNaN: isNaN
,isInfinite: isInfinite
,toString: toString
,fst: fst
,snd: snd
,identity: identity
,always: always
,flip: flip
,curry: curry
,uncurry: uncurry
,LT: LT
,EQ: EQ
,GT: GT};
};
Elm.Maybe = Elm.Maybe || {};
Elm.Maybe.make = function (_elm) {
"use strict";
_elm.Maybe = _elm.Maybe || {};
if (_elm.Maybe.values) return _elm.Maybe.values;
var _U = Elm.Native.Utils.make(_elm);
var _op = {};
var withDefault = F2(function ($default,maybe) { var _p0 = maybe;if (_p0.ctor === "Just") { return _p0._0;} else { return $default;}});
var Nothing = {ctor: "Nothing"};
var oneOf = function (maybes) {
oneOf: while (true) {
var _p1 = maybes;
if (_p1.ctor === "[]") {
return Nothing;
} else {
var _p3 = _p1._0;
var _p2 = _p3;
if (_p2.ctor === "Nothing") {
var _v3 = _p1._1;
maybes = _v3;
continue oneOf;
} else {
return _p3;
}
}
}
};
var andThen = F2(function (maybeValue,callback) {
var _p4 = maybeValue;
if (_p4.ctor === "Just") {
return callback(_p4._0);
} else {
return Nothing;
}
});
var Just = function (a) { return {ctor: "Just",_0: a};};
var map = F2(function (f,maybe) { var _p5 = maybe;if (_p5.ctor === "Just") { return Just(f(_p5._0));} else { return Nothing;}});
var map2 = F3(function (func,ma,mb) {
var _p6 = {ctor: "_Tuple2",_0: ma,_1: mb};
if (_p6.ctor === "_Tuple2" && _p6._0.ctor === "Just" && _p6._1.ctor === "Just") {
return Just(A2(func,_p6._0._0,_p6._1._0));
} else {
return Nothing;
}
});
var map3 = F4(function (func,ma,mb,mc) {
var _p7 = {ctor: "_Tuple3",_0: ma,_1: mb,_2: mc};
if (_p7.ctor === "_Tuple3" && _p7._0.ctor === "Just" && _p7._1.ctor === "Just" && _p7._2.ctor === "Just") {
return Just(A3(func,_p7._0._0,_p7._1._0,_p7._2._0));
} else {
return Nothing;
}
});
var map4 = F5(function (func,ma,mb,mc,md) {
var _p8 = {ctor: "_Tuple4",_0: ma,_1: mb,_2: mc,_3: md};
if (_p8.ctor === "_Tuple4" && _p8._0.ctor === "Just" && _p8._1.ctor === "Just" && _p8._2.ctor === "Just" && _p8._3.ctor === "Just") {
return Just(A4(func,_p8._0._0,_p8._1._0,_p8._2._0,_p8._3._0));
} else {
return Nothing;
}
});
var map5 = F6(function (func,ma,mb,mc,md,me) {
var _p9 = {ctor: "_Tuple5",_0: ma,_1: mb,_2: mc,_3: md,_4: me};
if (_p9.ctor === "_Tuple5" && _p9._0.ctor === "Just" && _p9._1.ctor === "Just" && _p9._2.ctor === "Just" && _p9._3.ctor === "Just" && _p9._4.ctor === "Just")
{
return Just(A5(func,_p9._0._0,_p9._1._0,_p9._2._0,_p9._3._0,_p9._4._0));
} else {
return Nothing;
}
});
return _elm.Maybe.values = {_op: _op
,andThen: andThen
,map: map
,map2: map2
,map3: map3
,map4: map4
,map5: map5
,withDefault: withDefault
,oneOf: oneOf
,Just: Just
,Nothing: Nothing};
};
Elm.Native.List = {};
Elm.Native.List.make = function(localRuntime) {
localRuntime.Native = localRuntime.Native || {};
localRuntime.Native.List = localRuntime.Native.List || {};
if (localRuntime.Native.List.values)
{
return localRuntime.Native.List.values;
}
if ('values' in Elm.Native.List)
{
return localRuntime.Native.List.values = Elm.Native.List.values;
}
var Utils = Elm.Native.Utils.make(localRuntime);
var Nil = Utils.Nil;
var Cons = Utils.Cons;
var fromArray = Utils.list;
function toArray(xs)
{
var out = [];
while (xs.ctor !== '[]')
{
out.push(xs._0);
xs = xs._1;
}
return out;
}
// f defined similarly for both foldl and foldr (NB: different from Haskell)
// ie, foldl : (a -> b -> b) -> b -> [a] -> b
function foldl(f, b, xs)
{
var acc = b;
while (xs.ctor !== '[]')
{
acc = A2(f, xs._0, acc);
xs = xs._1;
}
return acc;
}
function foldr(f, b, xs)
{
var arr = toArray(xs);
var acc = b;
for (var i = arr.length; i--; )
{
acc = A2(f, arr[i], acc);
}
return acc;
}
function map2(f, xs, ys)
{
var arr = [];
while (xs.ctor !== '[]' && ys.ctor !== '[]')
{
arr.push(A2(f, xs._0, ys._0));
xs = xs._1;
ys = ys._1;
}
return fromArray(arr);
}
function map3(f, xs, ys, zs)
{
var arr = [];
while (xs.ctor !== '[]' && ys.ctor !== '[]' && zs.ctor !== '[]')
{
arr.push(A3(f, xs._0, ys._0, zs._0));
xs = xs._1;
ys = ys._1;
zs = zs._1;
}
return fromArray(arr);
}
function map4(f, ws, xs, ys, zs)
{
var arr = [];
while ( ws.ctor !== '[]'
&& xs.ctor !== '[]'
&& ys.ctor !== '[]'
&& zs.ctor !== '[]')
{
arr.push(A4(f, ws._0, xs._0, ys._0, zs._0));
ws = ws._1;
xs = xs._1;
ys = ys._1;
zs = zs._1;
}
return fromArray(arr);
}
function map5(f, vs, ws, xs, ys, zs)
{
var arr = [];
while ( vs.ctor !== '[]'
&& ws.ctor !== '[]'
&& xs.ctor !== '[]'
&& ys.ctor !== '[]'
&& zs.ctor !== '[]')
{
arr.push(A5(f, vs._0, ws._0, xs._0, ys._0, zs._0));
vs = vs._1;
ws = ws._1;
xs = xs._1;
ys = ys._1;
zs = zs._1;
}
return fromArray(arr);
}
function sortBy(f, xs)
{
return fromArray(toArray(xs).sort(function(a, b) {
return Utils.cmp(f(a), f(b));
}));
}
function sortWith(f, xs)
{
return fromArray(toArray(xs).sort(function(a, b) {
var ord = f(a)(b).ctor;
return ord === 'EQ' ? 0 : ord === 'LT' ? -1 : 1;
}));
}
function take(n, xs)
{
var arr = [];
while (xs.ctor !== '[]' && n > 0)
{
arr.push(xs._0);
xs = xs._1;
--n;
}
return fromArray(arr);
}
Elm.Native.List.values = {
Nil: Nil,
Cons: Cons,
cons: F2(Cons),
toArray: toArray,
fromArray: fromArray,
foldl: F3(foldl),
foldr: F3(foldr),
map2: F3(map2),
map3: F4(map3),
map4: F5(map4),
map5: F6(map5),
sortBy: F2(sortBy),
sortWith: F2(sortWith),
take: F2(take)
};
return localRuntime.Native.List.values = Elm.Native.List.values;
};
Elm.List = Elm.List || {};
Elm.List.make = function (_elm) {
"use strict";
_elm.List = _elm.List || {};
if (_elm.List.values) return _elm.List.values;
var _U = Elm.Native.Utils.make(_elm),$Basics = Elm.Basics.make(_elm),$Maybe = Elm.Maybe.make(_elm),$Native$List = Elm.Native.List.make(_elm);
var _op = {};
var sortWith = $Native$List.sortWith;
var sortBy = $Native$List.sortBy;
var sort = function (xs) { return A2(sortBy,$Basics.identity,xs);};
var drop = F2(function (n,list) {
drop: while (true) if (_U.cmp(n,0) < 1) return list; else {
var _p0 = list;
if (_p0.ctor === "[]") {
return list;
} else {
var _v1 = n - 1,_v2 = _p0._1;
n = _v1;
list = _v2;
continue drop;
}
}
});
var take = $Native$List.take;
var map5 = $Native$List.map5;
var map4 = $Native$List.map4;
var map3 = $Native$List.map3;
var map2 = $Native$List.map2;
var any = F2(function (isOkay,list) {
any: while (true) {
var _p1 = list;
if (_p1.ctor === "[]") {
return false;
} else {
if (isOkay(_p1._0)) return true; else {
var _v4 = isOkay,_v5 = _p1._1;
isOkay = _v4;
list = _v5;
continue any;
}
}
}
});
var all = F2(function (isOkay,list) { return $Basics.not(A2(any,function (_p2) { return $Basics.not(isOkay(_p2));},list));});
var foldr = $Native$List.foldr;
var foldl = $Native$List.foldl;
var length = function (xs) { return A3(foldl,F2(function (_p3,i) { return i + 1;}),0,xs);};
var sum = function (numbers) { return A3(foldl,F2(function (x,y) { return x + y;}),0,numbers);};
var product = function (numbers) { return A3(foldl,F2(function (x,y) { return x * y;}),1,numbers);};
var maximum = function (list) {
var _p4 = list;
if (_p4.ctor === "::") {
return $Maybe.Just(A3(foldl,$Basics.max,_p4._0,_p4._1));
} else {
return $Maybe.Nothing;
}
};
var minimum = function (list) {
var _p5 = list;
if (_p5.ctor === "::") {
return $Maybe.Just(A3(foldl,$Basics.min,_p5._0,_p5._1));
} else {
return $Maybe.Nothing;
}
};
var indexedMap = F2(function (f,xs) { return A3(map2,f,_U.range(0,length(xs) - 1),xs);});
var member = F2(function (x,xs) { return A2(any,function (a) { return _U.eq(a,x);},xs);});
var isEmpty = function (xs) { var _p6 = xs;if (_p6.ctor === "[]") { return true;} else { return false;}};
var tail = function (list) { var _p7 = list;if (_p7.ctor === "::") { return $Maybe.Just(_p7._1);} else { return $Maybe.Nothing;}};
var head = function (list) { var _p8 = list;if (_p8.ctor === "::") { return $Maybe.Just(_p8._0);} else { return $Maybe.Nothing;}};
_op["::"] = $Native$List.cons;
var map = F2(function (f,xs) { return A3(foldr,F2(function (x,acc) { return A2(_op["::"],f(x),acc);}),_U.list([]),xs);});
var filter = F2(function (pred,xs) {
var conditionalCons = F2(function (x,xs$) { return pred(x) ? A2(_op["::"],x,xs$) : xs$;});
return A3(foldr,conditionalCons,_U.list([]),xs);
});
var maybeCons = F3(function (f,mx,xs) { var _p9 = f(mx);if (_p9.ctor === "Just") { return A2(_op["::"],_p9._0,xs);} else { return xs;}});
var filterMap = F2(function (f,xs) { return A3(foldr,maybeCons(f),_U.list([]),xs);});
var reverse = function (list) { return A3(foldl,F2(function (x,y) { return A2(_op["::"],x,y);}),_U.list([]),list);};
var scanl = F3(function (f,b,xs) {
var scan1 = F2(function (x,accAcc) {
var _p10 = accAcc;
if (_p10.ctor === "::") {
return A2(_op["::"],A2(f,x,_p10._0),accAcc);
} else {
return _U.list([]);
}
});
return reverse(A3(foldl,scan1,_U.list([b]),xs));
});
var append = F2(function (xs,ys) {
var _p11 = ys;
if (_p11.ctor === "[]") {
return xs;
} else {
return A3(foldr,F2(function (x,y) { return A2(_op["::"],x,y);}),ys,xs);
}
});
var concat = function (lists) { return A3(foldr,append,_U.list([]),lists);};
var concatMap = F2(function (f,list) { return concat(A2(map,f,list));});
var partition = F2(function (pred,list) {
var step = F2(function (x,_p12) {
var _p13 = _p12;
var _p15 = _p13._0;
var _p14 = _p13._1;
return pred(x) ? {ctor: "_Tuple2",_0: A2(_op["::"],x,_p15),_1: _p14} : {ctor: "_Tuple2",_0: _p15,_1: A2(_op["::"],x,_p14)};
});
return A3(foldr,step,{ctor: "_Tuple2",_0: _U.list([]),_1: _U.list([])},list);
});
var unzip = function (pairs) {
var step = F2(function (_p17,_p16) {
var _p18 = _p17;
var _p19 = _p16;
return {ctor: "_Tuple2",_0: A2(_op["::"],_p18._0,_p19._0),_1: A2(_op["::"],_p18._1,_p19._1)};
});
return A3(foldr,step,{ctor: "_Tuple2",_0: _U.list([]),_1: _U.list([])},pairs);
};
var intersperse = F2(function (sep,xs) {
var _p20 = xs;
if (_p20.ctor === "[]") {
return _U.list([]);
} else {
var step = F2(function (x,rest) { return A2(_op["::"],sep,A2(_op["::"],x,rest));});
var spersed = A3(foldr,step,_U.list([]),_p20._1);
return A2(_op["::"],_p20._0,spersed);
}
});
var repeatHelp = F3(function (result,n,value) {
repeatHelp: while (true) if (_U.cmp(n,0) < 1) return result; else {
var _v18 = A2(_op["::"],value,result),_v19 = n - 1,_v20 = value;
result = _v18;
n = _v19;
value = _v20;
continue repeatHelp;
}
});
var repeat = F2(function (n,value) { return A3(repeatHelp,_U.list([]),n,value);});
return _elm.List.values = {_op: _op
,isEmpty: isEmpty
,length: length
,reverse: reverse
,member: member
,head: head
,tail: tail
,filter: filter
,take: take
,drop: drop
,repeat: repeat
,append: append
,concat: concat
,intersperse: intersperse
,partition: partition
,unzip: unzip
,map: map
,map2: map2
,map3: map3
,map4: map4
,map5: map5
,filterMap: filterMap
,concatMap: concatMap
,indexedMap: indexedMap
,foldr: foldr
,foldl: foldl
,sum: sum
,product: product
,maximum: maximum
,minimum: minimum
,all: all
,any: any
,scanl: scanl
,sort: sort
,sortBy: sortBy
,sortWith: sortWith};
};
Elm.Array = Elm.Array || {};
Elm.Array.make = function (_elm) {
"use strict";
_elm.Array = _elm.Array || {};
if (_elm.Array.values) return _elm.Array.values;
var _U = Elm.Native.Utils.make(_elm),
$Basics = Elm.Basics.make(_elm),
$List = Elm.List.make(_elm),
$Maybe = Elm.Maybe.make(_elm),
$Native$Array = Elm.Native.Array.make(_elm);
var _op = {};
var append = $Native$Array.append;
var length = $Native$Array.length;
var isEmpty = function (array) { return _U.eq(length(array),0);};
var slice = $Native$Array.slice;
var set = $Native$Array.set;
var get = F2(function (i,array) {
return _U.cmp(0,i) < 1 && _U.cmp(i,$Native$Array.length(array)) < 0 ? $Maybe.Just(A2($Native$Array.get,i,array)) : $Maybe.Nothing;
});
var push = $Native$Array.push;
var empty = $Native$Array.empty;
var filter = F2(function (isOkay,arr) {
var update = F2(function (x,xs) { return isOkay(x) ? A2($Native$Array.push,x,xs) : xs;});
return A3($Native$Array.foldl,update,$Native$Array.empty,arr);
});
var foldr = $Native$Array.foldr;
var foldl = $Native$Array.foldl;
var indexedMap = $Native$Array.indexedMap;
var map = $Native$Array.map;
var toIndexedList = function (array) {
return A3($List.map2,
F2(function (v0,v1) { return {ctor: "_Tuple2",_0: v0,_1: v1};}),
_U.range(0,$Native$Array.length(array) - 1),
$Native$Array.toList(array));
};
var toList = $Native$Array.toList;
var fromList = $Native$Array.fromList;
var initialize = $Native$Array.initialize;
var repeat = F2(function (n,e) { return A2(initialize,n,$Basics.always(e));});
var Array = {ctor: "Array"};
return _elm.Array.values = {_op: _op
,empty: empty
,repeat: repeat
,initialize: initialize
,fromList: fromList
,isEmpty: isEmpty
,length: length
,push: push
,append: append
,get: get
,set: set
,slice: slice
,toList: toList
,toIndexedList: toIndexedList
,map: map
,indexedMap: indexedMap
,filter: filter
,foldl: foldl
,foldr: foldr};
};
Elm.Native.Char = {};
Elm.Native.Char.make = function(localRuntime) {
localRuntime.Native = localRuntime.Native || {};
localRuntime.Native.Char = localRuntime.Native.Char || {};
if (localRuntime.Native.Char.values)
{
return localRuntime.Native.Char.values;
}
var Utils = Elm.Native.Utils.make(localRuntime);
return localRuntime.Native.Char.values = {
fromCode: function(c) { return Utils.chr(String.fromCharCode(c)); },
toCode: function(c) { return c.charCodeAt(0); },
toUpper: function(c) { return Utils.chr(c.toUpperCase()); },
toLower: function(c) { return Utils.chr(c.toLowerCase()); },
toLocaleUpper: function(c) { return Utils.chr(c.toLocaleUpperCase()); },
toLocaleLower: function(c) { return Utils.chr(c.toLocaleLowerCase()); }
};
};
Elm.Char = Elm.Char || {};
Elm.Char.make = function (_elm) {
"use strict";
_elm.Char = _elm.Char || {};
if (_elm.Char.values) return _elm.Char.values;
var _U = Elm.Native.Utils.make(_elm),$Basics = Elm.Basics.make(_elm),$Native$Char = Elm.Native.Char.make(_elm);
var _op = {};
var fromCode = $Native$Char.fromCode;
var toCode = $Native$Char.toCode;
var toLocaleLower = $Native$Char.toLocaleLower;
var toLocaleUpper = $Native$Char.toLocaleUpper;
var toLower = $Native$Char.toLower;
var toUpper = $Native$Char.toUpper;
var isBetween = F3(function (low,high,$char) { var code = toCode($char);return _U.cmp(code,toCode(low)) > -1 && _U.cmp(code,toCode(high)) < 1;});
var isUpper = A2(isBetween,_U.chr("A"),_U.chr("Z"));
var isLower = A2(isBetween,_U.chr("a"),_U.chr("z"));
var isDigit = A2(isBetween,_U.chr("0"),_U.chr("9"));
var isOctDigit = A2(isBetween,_U.chr("0"),_U.chr("7"));
var isHexDigit = function ($char) {
return isDigit($char) || (A3(isBetween,_U.chr("a"),_U.chr("f"),$char) || A3(isBetween,_U.chr("A"),_U.chr("F"),$char));
};
return _elm.Char.values = {_op: _op
,isUpper: isUpper
,isLower: isLower
,isDigit: isDigit
,isOctDigit: isOctDigit
,isHexDigit: isHexDigit
,toUpper: toUpper
,toLower: toLower
,toLocaleUpper: toLocaleUpper
,toLocaleLower: toLocaleLower
,toCode: toCode
,fromCode: fromCode};
};
Elm.Native.Color = {};
Elm.Native.Color.make = function(localRuntime) {
localRuntime.Native = localRuntime.Native || {};
localRuntime.Native.Color = localRuntime.Native.Color || {};
if (localRuntime.Native.Color.values)
{
return localRuntime.Native.Color.values;
}
function toCss(c)
{
var format = '';
var colors = '';
if (c.ctor === 'RGBA')
{
format = 'rgb';
colors = c._0 + ', ' + c._1 + ', ' + c._2;
}
else
{
format = 'hsl';
colors = (c._0 * 180 / Math.PI) + ', ' +
(c._1 * 100) + '%, ' +
(c._2 * 100) + '%';
}
if (c._3 === 1)
{
return format + '(' + colors + ')';
}
else
{
return format + 'a(' + colors + ', ' + c._3 + ')';
}
}
return localRuntime.Native.Color.values = {
toCss: toCss
};
};
Elm.Color = Elm.Color || {};
Elm.Color.make = function (_elm) {
"use strict";
_elm.Color = _elm.Color || {};
if (_elm.Color.values) return _elm.Color.values;
var _U = Elm.Native.Utils.make(_elm),$Basics = Elm.Basics.make(_elm);
var _op = {};
var Radial = F5(function (a,b,c,d,e) { return {ctor: "Radial",_0: a,_1: b,_2: c,_3: d,_4: e};});
var radial = Radial;
var Linear = F3(function (a,b,c) { return {ctor: "Linear",_0: a,_1: b,_2: c};});
var linear = Linear;
var fmod = F2(function (f,n) { var integer = $Basics.floor(f);return $Basics.toFloat(A2($Basics._op["%"],integer,n)) + f - $Basics.toFloat(integer);});
var rgbToHsl = F3(function (red,green,blue) {
var b = $Basics.toFloat(blue) / 255;
var g = $Basics.toFloat(green) / 255;
var r = $Basics.toFloat(red) / 255;
var cMax = A2($Basics.max,A2($Basics.max,r,g),b);
var cMin = A2($Basics.min,A2($Basics.min,r,g),b);
var c = cMax - cMin;
var lightness = (cMax + cMin) / 2;
var saturation = _U.eq(lightness,0) ? 0 : c / (1 - $Basics.abs(2 * lightness - 1));
var hue = $Basics.degrees(60) * (_U.eq(cMax,r) ? A2(fmod,(g - b) / c,6) : _U.eq(cMax,g) ? (b - r) / c + 2 : (r - g) / c + 4);
return {ctor: "_Tuple3",_0: hue,_1: saturation,_2: lightness};
});
var hslToRgb = F3(function (hue,saturation,lightness) {
var hue$ = hue / $Basics.degrees(60);
var chroma = (1 - $Basics.abs(2 * lightness - 1)) * saturation;
var x = chroma * (1 - $Basics.abs(A2(fmod,hue$,2) - 1));
var _p0 = _U.cmp(hue$,0) < 0 ? {ctor: "_Tuple3",_0: 0,_1: 0,_2: 0} : _U.cmp(hue$,1) < 0 ? {ctor: "_Tuple3",_0: chroma,_1: x,_2: 0} : _U.cmp(hue$,
2) < 0 ? {ctor: "_Tuple3",_0: x,_1: chroma,_2: 0} : _U.cmp(hue$,3) < 0 ? {ctor: "_Tuple3",_0: 0,_1: chroma,_2: x} : _U.cmp(hue$,4) < 0 ? {ctor: "_Tuple3"
,_0: 0
,_1: x
,_2: chroma} : _U.cmp(hue$,
5) < 0 ? {ctor: "_Tuple3",_0: x,_1: 0,_2: chroma} : _U.cmp(hue$,6) < 0 ? {ctor: "_Tuple3",_0: chroma,_1: 0,_2: x} : {ctor: "_Tuple3",_0: 0,_1: 0,_2: 0};
var r = _p0._0;
var g = _p0._1;
var b = _p0._2;
var m = lightness - chroma / 2;
return {ctor: "_Tuple3",_0: r + m,_1: g + m,_2: b + m};
});
var toRgb = function (color) {
var _p1 = color;
if (_p1.ctor === "RGBA") {
return {red: _p1._0,green: _p1._1,blue: _p1._2,alpha: _p1._3};
} else {
var _p2 = A3(hslToRgb,_p1._0,_p1._1,_p1._2);
var r = _p2._0;
var g = _p2._1;
var b = _p2._2;
return {red: $Basics.round(255 * r),green: $Basics.round(255 * g),blue: $Basics.round(255 * b),alpha: _p1._3};
}
};
var toHsl = function (color) {
var _p3 = color;
if (_p3.ctor === "HSLA") {
return {hue: _p3._0,saturation: _p3._1,lightness: _p3._2,alpha: _p3._3};
} else {
var _p4 = A3(rgbToHsl,_p3._0,_p3._1,_p3._2);
var h = _p4._0;
var s = _p4._1;
var l = _p4._2;
return {hue: h,saturation: s,lightness: l,alpha: _p3._3};
}
};
var HSLA = F4(function (a,b,c,d) { return {ctor: "HSLA",_0: a,_1: b,_2: c,_3: d};});
var hsla = F4(function (hue,saturation,lightness,alpha) {
return A4(HSLA,hue - $Basics.turns($Basics.toFloat($Basics.floor(hue / (2 * $Basics.pi)))),saturation,lightness,alpha);
});
var hsl = F3(function (hue,saturation,lightness) { return A4(hsla,hue,saturation,lightness,1);});
var complement = function (color) {
var _p5 = color;
if (_p5.ctor === "HSLA") {
return A4(hsla,_p5._0 + $Basics.degrees(180),_p5._1,_p5._2,_p5._3);
} else {
var _p6 = A3(rgbToHsl,_p5._0,_p5._1,_p5._2);
var h = _p6._0;
var s = _p6._1;
var l = _p6._2;
return A4(hsla,h + $Basics.degrees(180),s,l,_p5._3);
}
};
var grayscale = function (p) { return A4(HSLA,0,0,1 - p,1);};
var greyscale = function (p) { return A4(HSLA,0,0,1 - p,1);};
var RGBA = F4(function (a,b,c,d) { return {ctor: "RGBA",_0: a,_1: b,_2: c,_3: d};});
var rgba = RGBA;
var rgb = F3(function (r,g,b) { return A4(RGBA,r,g,b,1);});
var lightRed = A4(RGBA,239,41,41,1);
var red = A4(RGBA,204,0,0,1);
var darkRed = A4(RGBA,164,0,0,1);
var lightOrange = A4(RGBA,252,175,62,1);
var orange = A4(RGBA,245,121,0,1);
var darkOrange = A4(RGBA,206,92,0,1);
var lightYellow = A4(RGBA,255,233,79,1);
var yellow = A4(RGBA,237,212,0,1);
var darkYellow = A4(RGBA,196,160,0,1);
var lightGreen = A4(RGBA,138,226,52,1);
var green = A4(RGBA,115,210,22,1);
var darkGreen = A4(RGBA,78,154,6,1);
var lightBlue = A4(RGBA,114,159,207,1);
var blue = A4(RGBA,52,101,164,1);
var darkBlue = A4(RGBA,32,74,135,1);
var lightPurple = A4(RGBA,173,127,168,1);
var purple = A4(RGBA,117,80,123,1);
var darkPurple = A4(RGBA,92,53,102,1);
var lightBrown = A4(RGBA,233,185,110,1);
var brown = A4(RGBA,193,125,17,1);
var darkBrown = A4(RGBA,143,89,2,1);
var black = A4(RGBA,0,0,0,1);
var white = A4(RGBA,255,255,255,1);
var lightGrey = A4(RGBA,238,238,236,1);
var grey = A4(RGBA,211,215,207,1);
var darkGrey = A4(RGBA,186,189,182,1);
var lightGray = A4(RGBA,238,238,236,1);
var gray = A4(RGBA,211,215,207,1);
var darkGray = A4(RGBA,186,189,182,1);
var lightCharcoal = A4(RGBA,136,138,133,1);
var charcoal = A4(RGBA,85,87,83,1);
var darkCharcoal = A4(RGBA,46,52,54,1);
return _elm.Color.values = {_op: _op
,rgb: rgb
,rgba: rgba
,hsl: hsl
,hsla: hsla
,greyscale: greyscale
,grayscale: grayscale
,complement: complement
,linear: linear
,radial: radial
,toRgb: toRgb
,toHsl: toHsl
,red: red
,orange: orange
,yellow: yellow
,green: green
,blue: blue
,purple: purple
,brown: brown
,lightRed: lightRed
,lightOrange: lightOrange
,lightYellow: lightYellow
,lightGreen: lightGreen
,lightBlue: lightBlue
,lightPurple: lightPurple
,lightBrown: lightBrown
,darkRed: darkRed
,darkOrange: darkOrange
,darkYellow: darkYellow
,darkGreen: darkGreen
,darkBlue: darkBlue
,darkPurple: darkPurple
,darkBrown: darkBrown
,white: white
,lightGrey: lightGrey
,grey: grey
,darkGrey: darkGrey
,lightCharcoal: lightCharcoal
,charcoal: charcoal
,darkCharcoal: darkCharcoal
,black: black
,lightGray: lightGray
,gray: gray
,darkGray: darkGray};
};
Elm.Native.Signal = {};
Elm.Native.Signal.make = function(localRuntime) {
localRuntime.Native = localRuntime.Native || {};
localRuntime.Native.Signal = localRuntime.Native.Signal || {};
if (localRuntime.Native.Signal.values)
{
return localRuntime.Native.Signal.values;
}
var Task = Elm.Native.Task.make(localRuntime);
var Utils = Elm.Native.Utils.make(localRuntime);
function broadcastToKids(node, timestamp, update)
{
var kids = node.kids;
for (var i = kids.length; i--; )
{
kids[i].notify(timestamp, update, node.id);
}
}
// INPUT
function input(name, base)
{
var node = {
id: Utils.guid(),
name: 'input-' + name,
value: base,
parents: [],
kids: []
};
node.notify = function(timestamp, targetId, value) {
var update = targetId === node.id;
if (update)
{
node.value = value;
}
broadcastToKids(node, timestamp, update);
return update;
};
localRuntime.inputs.push(node);
return node;
}
function constant(value)
{
return input('constant', value);
}
// MAILBOX
function mailbox(base)
{
var signal = input('mailbox', base);
function send(value) {
return Task.asyncFunction(function(callback) {
localRuntime.setTimeout(function() {
localRuntime.notify(signal.id, value);
}, 0);
callback(Task.succeed(Utils.Tuple0));
});
}
return {
signal: signal,
address: {
ctor: 'Address',
_0: send
}
};
}
function sendMessage(message)
{
Task.perform(message._0);
}
// OUTPUT
function output(name, handler, parent)
{
var node = {
id: Utils.guid(),
name: 'output-' + name,
parents: [parent],
isOutput: true
};
node.notify = function(timestamp, parentUpdate, parentID)
{
if (parentUpdate)
{
handler(parent.value);
}
};
parent.kids.push(node);
return node;
}
// MAP
function mapMany(refreshValue, args)
{
var node = {
id: Utils.guid(),
name: 'map' + args.length,
value: refreshValue(),
parents: args,
kids: []
};
var numberOfParents = args.length;
var count = 0;
var update = false;
node.notify = function(timestamp, parentUpdate, parentID)
{
++count;
update = update || parentUpdate;
if (count === numberOfParents)
{
if (update)
{
node.value = refreshValue();
}
broadcastToKids(node, timestamp, update);
update = false;
count = 0;
}
};
for (var i = numberOfParents; i--; )
{
args[i].kids.push(node);
}
return node;
}
function map(func, a)
{
function refreshValue()
{
return func(a.value);
}
return mapMany(refreshValue, [a]);
}
function map2(func, a, b)
{
function refreshValue()
{
return A2( func, a.value, b.value );
}
return mapMany(refreshValue, [a, b]);
}
function map3(func, a, b, c)
{
function refreshValue()
{
return A3( func, a.value, b.value, c.value );
}
return mapMany(refreshValue, [a, b, c]);
}
function map4(func, a, b, c, d)
{
function refreshValue()
{
return A4( func, a.value, b.value, c.value, d.value );
}
return mapMany(refreshValue, [a, b, c, d]);
}
function map5(func, a, b, c, d, e)
{
function refreshValue()
{
return A5( func, a.value, b.value, c.value, d.value, e.value );
}
return mapMany(refreshValue, [a, b, c, d, e]);
}
// FOLD
function foldp(update, state, signal)
{
var node = {
id: Utils.guid(),
name: 'foldp',
parents: [signal],
kids: [],
value: state
};
node.notify = function(timestamp, parentUpdate, parentID)
{
if (parentUpdate)
{
node.value = A2( update, signal.value, node.value );
}
broadcastToKids(node, timestamp, parentUpdate);
};
signal.kids.push(node);
return node;
}
// TIME
function timestamp(signal)
{
var node = {
id: Utils.guid(),
name: 'timestamp',
value: Utils.Tuple2(localRuntime.timer.programStart, signal.value),
parents: [signal],
kids: []
};
node.notify = function(timestamp, parentUpdate, parentID)
{
if (parentUpdate)
{
node.value = Utils.Tuple2(timestamp, signal.value);
}
broadcastToKids(node, timestamp, parentUpdate);
};
signal.kids.push(node);
return node;
}
function delay(time, signal)
{
var delayed = input('delay-input-' + time, signal.value);
function handler(value)
{
setTimeout(function() {
localRuntime.notify(delayed.id, value);
}, time);
}
output('delay-output-' + time, handler, signal);
return delayed;
}
// MERGING
function genericMerge(tieBreaker, leftStream, rightStream)
{
var node = {
id: Utils.guid(),
name: 'merge',
value: A2(tieBreaker, leftStream.value, rightStream.value),
parents: [leftStream, rightStream],
kids: []
};
var left = { touched: false, update: false, value: null };
var right = { touched: false, update: false, value: null };
node.notify = function(timestamp, parentUpdate, parentID)
{
if (parentID === leftStream.id)
{
left.touched = true;
left.update = parentUpdate;
left.value = leftStream.value;
}
if (parentID === rightStream.id)
{
right.touched = true;
right.update = parentUpdate;
right.value = rightStream.value;
}
if (left.touched && right.touched)
{
var update = false;
if (left.update && right.update)
{
node.value = A2(tieBreaker, left.value, right.value);
update = true;
}
else if (left.update)
{
node.value = left.value;
update = true;
}
else if (right.update)
{
node.value = right.value;
update = true;
}
left.touched = false;
right.touched = false;
broadcastToKids(node, timestamp, update);
}
};
leftStream.kids.push(node);
rightStream.kids.push(node);
return node;
}
// FILTERING
function filterMap(toMaybe, base, signal)
{
var maybe = toMaybe(signal.value);
var node = {
id: Utils.guid(),
name: 'filterMap',
value: maybe.ctor === 'Nothing' ? base : maybe._0,
parents: [signal],
kids: []
};
node.notify = function(timestamp, parentUpdate, parentID)
{
var update = false;
if (parentUpdate)
{
var maybe = toMaybe(signal.value);
if (maybe.ctor === 'Just')
{
update = true;
node.value = maybe._0;
}
}
broadcastToKids(node, timestamp, update);
};
signal.kids.push(node);
return node;
}
// SAMPLING
function sampleOn(ticker, signal)
{
var node = {
id: Utils.guid(),
name: 'sampleOn',
value: signal.value,
parents: [ticker, signal],
kids: []
};
var signalTouch = false;
var tickerTouch = false;
var tickerUpdate = false;
node.notify = function(timestamp, parentUpdate, parentID)
{
if (parentID === ticker.id)
{
tickerTouch = true;
tickerUpdate = parentUpdate;
}
if (parentID === signal.id)
{
signalTouch = true;
}
if (tickerTouch && signalTouch)
{
if (tickerUpdate)
{
node.value = signal.value;
}
tickerTouch = false;
signalTouch = false;
broadcastToKids(node, timestamp, tickerUpdate);
}
};
ticker.kids.push(node);
signal.kids.push(node);
return node;
}
// DROP REPEATS
function dropRepeats(signal)
{
var node = {
id: Utils.guid(),
name: 'dropRepeats',
value: signal.value,
parents: [signal],
kids: []
};
node.notify = function(timestamp, parentUpdate, parentID)
{
var update = false;
if (parentUpdate && !Utils.eq(node.value, signal.value))
{
node.value = signal.value;
update = true;
}
broadcastToKids(node, timestamp, update);
};
signal.kids.push(node);
return node;
}
return localRuntime.Native.Signal.values = {
input: input,
constant: constant,
mailbox: mailbox,
sendMessage: sendMessage,
output: output,
map: F2(map),
map2: F3(map2),
map3: F4(map3),
map4: F5(map4),
map5: F6(map5),
foldp: F3(foldp),
genericMerge: F3(genericMerge),
filterMap: F3(filterMap),
sampleOn: F2(sampleOn),
dropRepeats: dropRepeats,
timestamp: timestamp,
delay: F2(delay)
};
};
Elm.Native.Time = {};
Elm.Native.Time.make = function(localRuntime)
{
localRuntime.Native = localRuntime.Native || {};
localRuntime.Native.Time = localRuntime.Native.Time || {};
if (localRuntime.Native.Time.values)
{
return localRuntime.Native.Time.values;
}
var NS = Elm.Native.Signal.make(localRuntime);
var Maybe = Elm.Maybe.make(localRuntime);
// FRAMES PER SECOND
function fpsWhen(desiredFPS, isOn)
{
var msPerFrame = 1000 / desiredFPS;
var ticker = NS.input('fps-' + desiredFPS, null);
function notifyTicker()
{
localRuntime.notify(ticker.id, null);
}
function firstArg(x, y)
{
return x;
}
// input fires either when isOn changes, or when ticker fires.
// Its value is a tuple with the current timestamp, and the state of isOn
var input = NS.timestamp(A3(NS.map2, F2(firstArg), NS.dropRepeats(isOn), ticker));
var initialState = {
isOn: false,
time: localRuntime.timer.programStart,
delta: 0
};
var timeoutId;
function update(input, state)
{
var currentTime = input._0;
var isOn = input._1;
var wasOn = state.isOn;
var previousTime = state.time;
if (isOn)
{
timeoutId = localRuntime.setTimeout(notifyTicker, msPerFrame);
}
else if (wasOn)
{
clearTimeout(timeoutId);
}
return {
isOn: isOn,
time: currentTime,
delta: (isOn && !wasOn) ? 0 : currentTime - previousTime
};
}
return A2(
NS.map,
function(state) { return state.delta; },
A3(NS.foldp, F2(update), update(input.value, initialState), input)
);
}
// EVERY
function every(t)
{
var ticker = NS.input('every-' + t, null);
function tellTime()
{
localRuntime.notify(ticker.id, null);
}
var clock = A2(NS.map, fst, NS.timestamp(ticker));
setInterval(tellTime, t);
return clock;
}
function fst(pair)
{
return pair._0;
}
function read(s)
{
var t = Date.parse(s);
return isNaN(t) ? Maybe.Nothing : Maybe.Just(t);
}
return localRuntime.Native.Time.values = {
fpsWhen: F2(fpsWhen),
every: every,
toDate: function(t) { return new Date(t); },
read: read
};
};
Elm.Native.Transform2D = {};
Elm.Native.Transform2D.make = function(localRuntime) {
localRuntime.Native = localRuntime.Native || {};
localRuntime.Native.Transform2D = localRuntime.Native.Transform2D || {};
if (localRuntime.Native.Transform2D.values)
{
return localRuntime.Native.Transform2D.values;
}
var A;
if (typeof Float32Array === 'undefined')
{
A = function(arr)
{
this.length = arr.length;
this[0] = arr[0];
this[1] = arr[1];
this[2] = arr[2];
this[3] = arr[3];
this[4] = arr[4];
this[5] = arr[5];
};
}
else
{
A = Float32Array;
}
// layout of matrix in an array is
//
// | m11 m12 dx |
// | m21 m22 dy |
// | 0 0 1 |
//
// new A([ m11, m12, dx, m21, m22, dy ])
var identity = new A([1, 0, 0, 0, 1, 0]);
function matrix(m11, m12, m21, m22, dx, dy)
{
return new A([m11, m12, dx, m21, m22, dy]);
}
function rotation(t)
{
var c = Math.cos(t);
var s = Math.sin(t);
return new A([c, -s, 0, s, c, 0]);
}
function rotate(t, m)
{
var c = Math.cos(t);
var s = Math.sin(t);
var m11 = m[0], m12 = m[1], m21 = m[3], m22 = m[4];
return new A([m11 * c + m12 * s, -m11 * s + m12 * c, m[2],
m21 * c + m22 * s, -m21 * s + m22 * c, m[5]]);
}
/*
function move(xy,m) {
var x = xy._0;
var y = xy._1;
var m11 = m[0], m12 = m[1], m21 = m[3], m22 = m[4];
return new A([m11, m12, m11*x + m12*y + m[2],
m21, m22, m21*x + m22*y + m[5]]);
}
function scale(s,m) { return new A([m[0]*s, m[1]*s, m[2], m[3]*s, m[4]*s, m[5]]); }
function scaleX(x,m) { return new A([m[0]*x, m[1], m[2], m[3]*x, m[4], m[5]]); }
function scaleY(y,m) { return new A([m[0], m[1]*y, m[2], m[3], m[4]*y, m[5]]); }
function reflectX(m) { return new A([-m[0], m[1], m[2], -m[3], m[4], m[5]]); }
function reflectY(m) { return new A([m[0], -m[1], m[2], m[3], -m[4], m[5]]); }
function transform(m11, m21, m12, m22, mdx, mdy, n) {
var n11 = n[0], n12 = n[1], n21 = n[3], n22 = n[4], ndx = n[2], ndy = n[5];
return new A([m11*n11 + m12*n21,
m11*n12 + m12*n22,
m11*ndx + m12*ndy + mdx,
m21*n11 + m22*n21,
m21*n12 + m22*n22,
m21*ndx + m22*ndy + mdy]);
}
*/
function multiply(m, n)
{
var m11 = m[0], m12 = m[1], m21 = m[3], m22 = m[4], mdx = m[2], mdy = m[5];
var n11 = n[0], n12 = n[1], n21 = n[3], n22 = n[4], ndx = n[2], ndy = n[5];
return new A([m11 * n11 + m12 * n21,
m11 * n12 + m12 * n22,
m11 * ndx + m12 * ndy + mdx,
m21 * n11 + m22 * n21,
m21 * n12 + m22 * n22,
m21 * ndx + m22 * ndy + mdy]);
}
return localRuntime.Native.Transform2D.values = {
identity: identity,
matrix: F6(matrix),
rotation: rotation,
multiply: F2(multiply)
/*
transform: F7(transform),
rotate: F2(rotate),
move: F2(move),
scale: F2(scale),
scaleX: F2(scaleX),
scaleY: F2(scaleY),
reflectX: reflectX,
reflectY: reflectY
*/
};
};
Elm.Transform2D = Elm.Transform2D || {};
Elm.Transform2D.make = function (_elm) {
"use strict";
_elm.Transform2D = _elm.Transform2D || {};
if (_elm.Transform2D.values) return _elm.Transform2D.values;
var _U = Elm.Native.Utils.make(_elm),$Native$Transform2D = Elm.Native.Transform2D.make(_elm);
var _op = {};
var multiply = $Native$Transform2D.multiply;
var rotation = $Native$Transform2D.rotation;
var matrix = $Native$Transform2D.matrix;
var translation = F2(function (x,y) { return A6(matrix,1,0,0,1,x,y);});
var scale = function (s) { return A6(matrix,s,0,0,s,0,0);};
var scaleX = function (x) { return A6(matrix,x,0,0,1,0,0);};
var scaleY = function (y) { return A6(matrix,1,0,0,y,0,0);};
var identity = $Native$Transform2D.identity;
var Transform2D = {ctor: "Transform2D"};
return _elm.Transform2D.values = {_op: _op
,identity: identity
,matrix: matrix
,multiply: multiply
,rotation: rotation
,translation: translation
,scale: scale
,scaleX: scaleX
,scaleY: scaleY};
};
// setup
Elm.Native = Elm.Native || {};
Elm.Native.Graphics = Elm.Native.Graphics || {};
Elm.Native.Graphics.Collage = Elm.Native.Graphics.Collage || {};
// definition
Elm.Native.Graphics.Collage.make = function(localRuntime) {
'use strict';
// attempt to short-circuit
localRuntime.Native = localRuntime.Native || {};
localRuntime.Native.Graphics = localRuntime.Native.Graphics || {};
localRuntime.Native.Graphics.Collage = localRuntime.Native.Graphics.Collage || {};
if ('values' in localRuntime.Native.Graphics.Collage)
{
return localRuntime.Native.Graphics.Collage.values;
}
// okay, we cannot short-ciruit, so now we define everything
var Color = Elm.Native.Color.make(localRuntime);
var List = Elm.Native.List.make(localRuntime);
var NativeElement = Elm.Native.Graphics.Element.make(localRuntime);
var Transform = Elm.Transform2D.make(localRuntime);
var Utils = Elm.Native.Utils.make(localRuntime);
function setStrokeStyle(ctx, style)
{
ctx.lineWidth = style.width;
var cap = style.cap.ctor;
ctx.lineCap = cap === 'Flat'
? 'butt'
: cap === 'Round'
? 'round'
: 'square';
var join = style.join.ctor;
ctx.lineJoin = join === 'Smooth'
? 'round'
: join === 'Sharp'
? 'miter'
: 'bevel';
ctx.miterLimit = style.join._0 || 10;
ctx.strokeStyle = Color.toCss(style.color);
}
function setFillStyle(redo, ctx, style)
{
var sty = style.ctor;
ctx.fillStyle = sty === 'Solid'
? Color.toCss(style._0)
: sty === 'Texture'
? texture(redo, ctx, style._0)
: gradient(ctx, style._0);
}
function trace(ctx, path)
{
var points = List.toArray(path);
var i = points.length - 1;
if (i <= 0)
{
return;
}
ctx.moveTo(points[i]._0, points[i]._1);
while (i--)
{
ctx.lineTo(points[i]._0, points[i]._1);
}
if (path.closed)
{
i = points.length - 1;
ctx.lineTo(points[i]._0, points[i]._1);
}
}
function line(ctx, style, path)
{
if (style.dashing.ctor === '[]')
{
trace(ctx, path);
}
else
{
customLineHelp(ctx, style, path);
}
ctx.scale(1, -1);
ctx.stroke();
}
function customLineHelp(ctx, style, path)
{
var points = List.toArray(path);
if (path.closed)
{
points.push(points[0]);
}
var pattern = List.toArray(style.dashing);
var i = points.length - 1;
if (i <= 0)
{
return;
}
var x0 = points[i]._0, y0 = points[i]._1;
var x1 = 0, y1 = 0, dx = 0, dy = 0, remaining = 0;
var pindex = 0, plen = pattern.length;
var draw = true, segmentLength = pattern[0];
ctx.moveTo(x0, y0);
while (i--)
{
x1 = points[i]._0;
y1 = points[i]._1;
dx = x1 - x0;
dy = y1 - y0;
remaining = Math.sqrt(dx * dx + dy * dy);
while (segmentLength <= remaining)
{
x0 += dx * segmentLength / remaining;
y0 += dy * segmentLength / remaining;
ctx[draw ? 'lineTo' : 'moveTo'](x0, y0);
// update starting position
dx = x1 - x0;
dy = y1 - y0;
remaining = Math.sqrt(dx * dx + dy * dy);
// update pattern
draw = !draw;
pindex = (pindex + 1) % plen;
segmentLength = pattern[pindex];
}
if (remaining > 0)
{
ctx[draw ? 'lineTo' : 'moveTo'](x1, y1);
segmentLength -= remaining;
}
x0 = x1;
y0 = y1;
}
}
function drawLine(ctx, style, path)
{
setStrokeStyle(ctx, style);
return line(ctx, style, path);
}
function texture(redo, ctx, src)
{
var img = new Image();
img.src = src;
img.onload = redo;
return ctx.createPattern(img, 'repeat');
}
function gradient(ctx, grad)
{
var g;
var stops = [];
if (grad.ctor === 'Linear')
{
var p0 = grad._0, p1 = grad._1;
g = ctx.createLinearGradient(p0._0, -p0._1, p1._0, -p1._1);
stops = List.toArray(grad._2);
}
else
{
var p0 = grad._0, p2 = grad._2;
g = ctx.createRadialGradient(p0._0, -p0._1, grad._1, p2._0, -p2._1, grad._3);
stops = List.toArray(grad._4);
}
var len = stops.length;
for (var i = 0; i < len; ++i)
{
var stop = stops[i];
g.addColorStop(stop._0, Color.toCss(stop._1));
}
return g;
}
function drawShape(redo, ctx, style, path)
{
trace(ctx, path);
setFillStyle(redo, ctx, style);
ctx.scale(1, -1);
ctx.fill();
}
// TEXT RENDERING
function fillText(redo, ctx, text)
{
drawText(ctx, text, ctx.fillText);
}
function strokeText(redo, ctx, style, text)
{
setStrokeStyle(ctx, style);
// Use native canvas API for dashes only for text for now
// Degrades to non-dashed on IE 9 + 10
if (style.dashing.ctor !== '[]' && ctx.setLineDash)
{
var pattern = List.toArray(style.dashing);
ctx.setLineDash(pattern);
}
drawText(ctx, text, ctx.strokeText);
}
function drawText(ctx, text, canvasDrawFn)
{
var textChunks = chunkText(defaultContext, text);
var totalWidth = 0;
var maxHeight = 0;
var numChunks = textChunks.length;
ctx.scale(1,-1);
for (var i = numChunks; i--; )
{
var chunk = textChunks[i];
ctx.font = chunk.font;
var metrics = ctx.measureText(chunk.text);
chunk.width = metrics.width;
totalWidth += chunk.width;
if (chunk.height > maxHeight)
{
maxHeight = chunk.height;
}
}
var x = -totalWidth / 2.0;
for (var i = 0; i < numChunks; ++i)
{
var chunk = textChunks[i];
ctx.font = chunk.font;
ctx.fillStyle = chunk.color;
canvasDrawFn.call(ctx, chunk.text, x, maxHeight / 2);
x += chunk.width;
}
}
function toFont(props)
{
return [
props['font-style'],
props['font-variant'],
props['font-weight'],
props['font-size'],
props['font-family']
].join(' ');
}
// Convert the object returned by the text module
// into something we can use for styling canvas text
function chunkText(context, text)
{
var tag = text.ctor;
if (tag === 'Text:Append')
{
var leftChunks = chunkText(context, text._0);
var rightChunks = chunkText(context, text._1);
return leftChunks.concat(rightChunks);
}
if (tag === 'Text:Text')
{
return [{
text: text._0,
color: context.color,
height: context['font-size'].slice(0, -2) | 0,
font: toFont(context)
}];
}
if (tag === 'Text:Meta')
{
var newContext = freshContext(text._0, context);
return chunkText(newContext, text._1);
}
}
function freshContext(props, ctx)
{
return {
'font-style': props['font-style'] || ctx['font-style'],
'font-variant': props['font-variant'] || ctx['font-variant'],
'font-weight': props['font-weight'] || ctx['font-weight'],
'font-size': props['font-size'] || ctx['font-size'],
'font-family': props['font-family'] || ctx['font-family'],
'color': props['color'] || ctx['color']
};
}
var defaultContext = {
'font-style': 'normal',
'font-variant': 'normal',
'font-weight': 'normal',
'font-size': '12px',
'font-family': 'sans-serif',
'color': 'black'
};
// IMAGES
function drawImage(redo, ctx, form)
{
var img = new Image();
img.onload = redo;
img.src = form._3;
var w = form._0,
h = form._1,
pos = form._2,
srcX = pos._0,
srcY = pos._1,
srcW = w,
srcH = h,
destX = -w / 2,
destY = -h / 2,
destW = w,
destH = h;
ctx.scale(1, -1);
ctx.drawImage(img, srcX, srcY, srcW, srcH, destX, destY, destW, destH);
}
function renderForm(redo, ctx, form)
{
ctx.save();
var x = form.x,
y = form.y,
theta = form.theta,
scale = form.scale;
if (x !== 0 || y !== 0)
{
ctx.translate(x, y);
}
if (theta !== 0)
{
ctx.rotate(theta % (Math.PI * 2));
}
if (scale !== 1)
{
ctx.scale(scale, scale);
}
if (form.alpha !== 1)
{
ctx.globalAlpha = ctx.globalAlpha * form.alpha;
}
ctx.beginPath();
var f = form.form;
switch (f.ctor)
{
case 'FPath':
drawLine(ctx, f._0, f._1);
break;
case 'FImage':
drawImage(redo, ctx, f);
break;
case 'FShape':
if (f._0.ctor === 'Line')
{
f._1.closed = true;
drawLine(ctx, f._0._0, f._1);
}
else
{
drawShape(redo, ctx, f._0._0, f._1);
}
break;
case 'FText':
fillText(redo, ctx, f._0);
break;
case 'FOutlinedText':
strokeText(redo, ctx, f._0, f._1);
break;
}
ctx.restore();
}
function formToMatrix(form)
{
var scale = form.scale;
var matrix = A6( Transform.matrix, scale, 0, 0, scale, form.x, form.y );
var theta = form.theta;
if (theta !== 0)
{
matrix = A2( Transform.multiply, matrix, Transform.rotation(theta) );
}
return matrix;
}
function str(n)
{
if (n < 0.00001 && n > -0.00001)
{
return 0;
}
return n;
}
function makeTransform(w, h, form, matrices)
{
var props = form.form._0._0.props;
var m = A6( Transform.matrix, 1, 0, 0, -1,
(w - props.width ) / 2,
(h - props.height) / 2 );
var len = matrices.length;
for (var i = 0; i < len; ++i)
{
m = A2( Transform.multiply, m, matrices[i] );
}
m = A2( Transform.multiply, m, formToMatrix(form) );
return 'matrix(' +
str( m[0]) + ', ' + str( m[3]) + ', ' +
str(-m[1]) + ', ' + str(-m[4]) + ', ' +
str( m[2]) + ', ' + str( m[5]) + ')';
}
function stepperHelp(list)
{
var arr = List.toArray(list);
var i = 0;
function peekNext()
{
return i < arr.length ? arr[i]._0.form.ctor : '';
}
// assumes that there is a next element
function next()
{
var out = arr[i]._0;
++i;
return out;
}
return {
peekNext: peekNext,
next: next
};
}
function formStepper(forms)
{
var ps = [stepperHelp(forms)];
var matrices = [];
var alphas = [];
function peekNext()
{
var len = ps.length;
var formType = '';
for (var i = 0; i < len; ++i )
{
if (formType = ps[i].peekNext()) return formType;
}
return '';
}
// assumes that there is a next element
function next(ctx)
{
while (!ps[0].peekNext())
{
ps.shift();
matrices.pop();
alphas.shift();
if (ctx)
{
ctx.restore();
}
}
var out = ps[0].next();
var f = out.form;
if (f.ctor === 'FGroup')
{
ps.unshift(stepperHelp(f._1));
var m = A2(Transform.multiply, f._0, formToMatrix(out));
ctx.save();
ctx.transform(m[0], m[3], m[1], m[4], m[2], m[5]);
matrices.push(m);
var alpha = (alphas[0] || 1) * out.alpha;
alphas.unshift(alpha);
ctx.globalAlpha = alpha;
}
return out;
}
function transforms()
{
return matrices;
}
function alpha()
{
return alphas[0] || 1;
}
return {
peekNext: peekNext,
next: next,
transforms: transforms,
alpha: alpha
};
}
function makeCanvas(w, h)
{
var canvas = NativeElement.createNode('canvas');
canvas.style.width = w + 'px';
canvas.style.height = h + 'px';
canvas.style.display = 'block';
canvas.style.position = 'absolute';
var ratio = window.devicePixelRatio || 1;
canvas.width = w * ratio;
canvas.height = h * ratio;
return canvas;
}
function render(model)
{
var div = NativeElement.createNode('div');
div.style.overflow = 'hidden';
div.style.position = 'relative';
update(div, model, model);
return div;
}
function nodeStepper(w, h, div)
{
var kids = div.childNodes;
var i = 0;
var ratio = window.devicePixelRatio || 1;
function transform(transforms, ctx)
{
ctx.translate( w / 2 * ratio, h / 2 * ratio );
ctx.scale( ratio, -ratio );
var len = transforms.length;
for (var i = 0; i < len; ++i)
{
var m = transforms[i];
ctx.save();
ctx.transform(m[0], m[3], m[1], m[4], m[2], m[5]);
}
return ctx;
}
function nextContext(transforms)
{
while (i < kids.length)
{
var node = kids[i];
if (node.getContext)
{
node.width = w * ratio;
node.height = h * ratio;
node.style.width = w + 'px';
node.style.height = h + 'px';
++i;
return transform(transforms, node.getContext('2d'));
}
div.removeChild(node);
}
var canvas = makeCanvas(w, h);
div.appendChild(canvas);
// we have added a new node, so we must step our position
++i;
return transform(transforms, canvas.getContext('2d'));
}
function addElement(matrices, alpha, form)
{
var kid = kids[i];
var elem = form.form._0;
var node = (!kid || kid.getContext)
? NativeElement.render(elem)
: NativeElement.update(kid, kid.oldElement, elem);
node.style.position = 'absolute';
node.style.opacity = alpha * form.alpha * elem._0.props.opacity;
NativeElement.addTransform(node.style, makeTransform(w, h, form, matrices));
node.oldElement = elem;
++i;
if (!kid)
{
div.appendChild(node);
}
else
{
div.insertBefore(node, kid);
}
}
function clearRest()
{
while (i < kids.length)
{
div.removeChild(kids[i]);
}
}
return {
nextContext: nextContext,
addElement: addElement,
clearRest: clearRest
};
}
function update(div, _, model)
{
var w = model.w;
var h = model.h;
var forms = formStepper(model.forms);
var nodes = nodeStepper(w, h, div);
var ctx = null;
var formType = '';
while (formType = forms.peekNext())
{
// make sure we have context if we need it
if (ctx === null && formType !== 'FElement')
{
ctx = nodes.nextContext(forms.transforms());
ctx.globalAlpha = forms.alpha();
}
var form = forms.next(ctx);
// if it is FGroup, all updates are made within formStepper when next is called.
if (formType === 'FElement')
{
// update or insert an element, get a new context
nodes.addElement(forms.transforms(), forms.alpha(), form);
ctx = null;
}
else if (formType !== 'FGroup')
{
renderForm(function() { update(div, model, model); }, ctx, form);
}
}
nodes.clearRest();
return div;
}
function collage(w, h, forms)
{
return A3(NativeElement.newElement, w, h, {
ctor: 'Custom',
type: 'Collage',
render: render,
update: update,
model: {w: w, h: h, forms: forms}
});
}
return localRuntime.Native.Graphics.Collage.values = {
collage: F3(collage)
};
};
// setup
Elm.Native = Elm.Native || {};
Elm.Native.Graphics = Elm.Native.Graphics || {};
Elm.Native.Graphics.Element = Elm.Native.Graphics.Element || {};
// definition
Elm.Native.Graphics.Element.make = function(localRuntime) {
'use strict';
// attempt to short-circuit
localRuntime.Native = localRuntime.Native || {};
localRuntime.Native.Graphics = localRuntime.Native.Graphics || {};
localRuntime.Native.Graphics.Element = localRuntime.Native.Graphics.Element || {};
if ('values' in localRuntime.Native.Graphics.Element)
{
return localRuntime.Native.Graphics.Element.values;
}
var Color = Elm.Native.Color.make(localRuntime);
var List = Elm.Native.List.make(localRuntime);
var Maybe = Elm.Maybe.make(localRuntime);
var Text = Elm.Native.Text.make(localRuntime);
var Utils = Elm.Native.Utils.make(localRuntime);
// CREATION
var createNode =
typeof document === 'undefined'
?
function(_)
{
return {
style: {},
appendChild: function() {}
};
}
:
function(elementType)
{
var node = document.createElement(elementType);
node.style.padding = '0';
node.style.margin = '0';
return node;
}
;
function newElement(width, height, elementPrim)
{
return {
ctor: 'Element_elm_builtin',
_0: {
element: elementPrim,
props: {
id: Utils.guid(),
width: width,
height: height,
opacity: 1,
color: Maybe.Nothing,
href: '',
tag: '',
hover: Utils.Tuple0,
click: Utils.Tuple0
}
}
};
}
// PROPERTIES
function setProps(elem, node)
{
var props = elem.props;
var element = elem.element;
var width = props.width - (element.adjustWidth || 0);
var height = props.height - (element.adjustHeight || 0);
node.style.width = (width | 0) + 'px';
node.style.height = (height | 0) + 'px';
if (props.opacity !== 1)
{
node.style.opacity = props.opacity;
}
if (props.color.ctor === 'Just')
{
node.style.backgroundColor = Color.toCss(props.color._0);
}
if (props.tag !== '')
{
node.id = props.tag;
}
if (props.hover.ctor !== '_Tuple0')
{
addHover(node, props.hover);
}
if (props.click.ctor !== '_Tuple0')
{
addClick(node, props.click);
}
if (props.href !== '')
{
var anchor = createNode('a');
anchor.href = props.href;
anchor.style.display = 'block';
anchor.style.pointerEvents = 'auto';
anchor.appendChild(node);
node = anchor;
}
return node;
}
function addClick(e, handler)
{
e.style.pointerEvents = 'auto';
e.elm_click_handler = handler;
function trigger(ev)
{
e.elm_click_handler(Utils.Tuple0);
ev.stopPropagation();
}
e.elm_click_trigger = trigger;
e.addEventListener('click', trigger);
}
function removeClick(e, handler)
{
if (e.elm_click_trigger)
{
e.removeEventListener('click', e.elm_click_trigger);
e.elm_click_trigger = null;
e.elm_click_handler = null;
}
}
function addHover(e, handler)
{
e.style.pointerEvents = 'auto';
e.elm_hover_handler = handler;
e.elm_hover_count = 0;
function over(evt)
{
if (e.elm_hover_count++ > 0) return;
e.elm_hover_handler(true);
evt.stopPropagation();
}
function out(evt)
{
if (e.contains(evt.toElement || evt.relatedTarget)) return;
e.elm_hover_count = 0;
e.elm_hover_handler(false);
evt.stopPropagation();
}
e.elm_hover_over = over;
e.elm_hover_out = out;
e.addEventListener('mouseover', over);
e.addEventListener('mouseout', out);
}
function removeHover(e)
{
e.elm_hover_handler = null;
if (e.elm_hover_over)
{
e.removeEventListener('mouseover', e.elm_hover_over);
e.elm_hover_over = null;
}
if (e.elm_hover_out)
{
e.removeEventListener('mouseout', e.elm_hover_out);
e.elm_hover_out = null;
}
}
// IMAGES
function image(props, img)
{
switch (img._0.ctor)
{
case 'Plain':
return plainImage(img._3);
case 'Fitted':
return fittedImage(props.width, props.height, img._3);
case 'Cropped':
return croppedImage(img, props.width, props.height, img._3);
case 'Tiled':
return tiledImage(img._3);
}
}
function plainImage(src)
{
var img = createNode('img');
img.src = src;
img.name = src;
img.style.display = 'block';
return img;
}
function tiledImage(src)
{
var div = createNode('div');
div.style.backgroundImage = 'url(' + src + ')';
return div;
}
function fittedImage(w, h, src)
{
var div = createNode('div');
div.style.background = 'url(' + src + ') no-repeat center';
div.style.webkitBackgroundSize = 'cover';
div.style.MozBackgroundSize = 'cover';
div.style.OBackgroundSize = 'cover';
div.style.backgroundSize = 'cover';
return div;
}
function croppedImage(elem, w, h, src)
{
var pos = elem._0._0;
var e = createNode('div');
e.style.overflow = 'hidden';
var img = createNode('img');
img.onload = function() {
var sw = w / elem._1, sh = h / elem._2;
img.style.width = ((this.width * sw) | 0) + 'px';
img.style.height = ((this.height * sh) | 0) + 'px';
img.style.marginLeft = ((- pos._0 * sw) | 0) + 'px';
img.style.marginTop = ((- pos._1 * sh) | 0) + 'px';
};
img.src = src;
img.name = src;
e.appendChild(img);
return e;
}
// FLOW
function goOut(node)
{
node.style.position = 'absolute';
return node;
}
function goDown(node)
{
return node;
}
function goRight(node)
{
node.style.styleFloat = 'left';
node.style.cssFloat = 'left';
return node;
}
var directionTable = {
DUp: goDown,
DDown: goDown,
DLeft: goRight,
DRight: goRight,
DIn: goOut,
DOut: goOut
};
function needsReversal(dir)
{
return dir === 'DUp' || dir === 'DLeft' || dir === 'DIn';
}
function flow(dir, elist)
{
var array = List.toArray(elist);
var container = createNode('div');
var goDir = directionTable[dir];
if (goDir === goOut)
{
container.style.pointerEvents = 'none';
}
if (needsReversal(dir))
{
array.reverse();
}
var len = array.length;
for (var i = 0; i < len; ++i)
{
container.appendChild(goDir(render(array[i])));
}
return container;
}
// CONTAINER
function toPos(pos)
{
return pos.ctor === 'Absolute'
? pos._0 + 'px'
: (pos._0 * 100) + '%';
}
// must clear right, left, top, bottom, and transform
// before calling this function
function setPos(pos, wrappedElement, e)
{
var elem = wrappedElement._0;
var element = elem.element;
var props = elem.props;
var w = props.width + (element.adjustWidth ? element.adjustWidth : 0);
var h = props.height + (element.adjustHeight ? element.adjustHeight : 0);
e.style.position = 'absolute';
e.style.margin = 'auto';
var transform = '';
switch (pos.horizontal.ctor)
{
case 'P':
e.style.right = toPos(pos.x);
e.style.removeProperty('left');
break;
case 'Z':
transform = 'translateX(' + ((-w / 2) | 0) + 'px) ';
case 'N':
e.style.left = toPos(pos.x);
e.style.removeProperty('right');
break;
}
switch (pos.vertical.ctor)
{
case 'N':
e.style.bottom = toPos(pos.y);
e.style.removeProperty('top');
break;
case 'Z':
transform += 'translateY(' + ((-h / 2) | 0) + 'px)';
case 'P':
e.style.top = toPos(pos.y);
e.style.removeProperty('bottom');
break;
}
if (transform !== '')
{
addTransform(e.style, transform);
}
return e;
}
function addTransform(style, transform)
{
style.transform = transform;
style.msTransform = transform;
style.MozTransform = transform;
style.webkitTransform = transform;
style.OTransform = transform;
}
function container(pos, elem)
{
var e = render(elem);
setPos(pos, elem, e);
var div = createNode('div');
div.style.position = 'relative';
div.style.overflow = 'hidden';
div.appendChild(e);
return div;
}
function rawHtml(elem)
{
var html = elem.html;
var align = elem.align;
var div = createNode('div');
div.innerHTML = html;
div.style.visibility = 'hidden';
if (align)
{
div.style.textAlign = align;
}
div.style.visibility = 'visible';
div.style.pointerEvents = 'auto';
return div;
}
// RENDER
function render(wrappedElement)
{
var elem = wrappedElement._0;
return setProps(elem, makeElement(elem));
}
function makeElement(e)
{
var elem = e.element;
switch (elem.ctor)
{
case 'Image':
return image(e.props, elem);
case 'Flow':
return flow(elem._0.ctor, elem._1);
case 'Container':
return container(elem._0, elem._1);
case 'Spacer':
return createNode('div');
case 'RawHtml':
return rawHtml(elem);
case 'Custom':
return elem.render(elem.model);
}
}
function updateAndReplace(node, curr, next)
{
var newNode = update(node, curr, next);
if (newNode !== node)
{
node.parentNode.replaceChild(newNode, node);
}
return newNode;
}
// UPDATE
function update(node, wrappedCurrent, wrappedNext)
{
var curr = wrappedCurrent._0;
var next = wrappedNext._0;
var rootNode = node;
if (node.tagName === 'A')
{
node = node.firstChild;
}
if (curr.props.id === next.props.id)
{
updateProps(node, curr, next);
return rootNode;
}
if (curr.element.ctor !== next.element.ctor)
{
return render(wrappedNext);
}
var nextE = next.element;
var currE = curr.element;
switch (nextE.ctor)
{
case 'Spacer':
updateProps(node, curr, next);
return rootNode;
case 'RawHtml':
if(currE.html.valueOf() !== nextE.html.valueOf())
{
node.innerHTML = nextE.html;
}
updateProps(node, curr, next);
return rootNode;
case 'Image':
if (nextE._0.ctor === 'Plain')
{
if (nextE._3 !== currE._3)
{
node.src = nextE._3;
}
}
else if (!Utils.eq(nextE, currE)
|| next.props.width !== curr.props.width
|| next.props.height !== curr.props.height)
{
return render(wrappedNext);
}
updateProps(node, curr, next);
return rootNode;
case 'Flow':
var arr = List.toArray(nextE._1);
for (var i = arr.length; i--; )
{
arr[i] = arr[i]._0.element.ctor;
}
if (nextE._0.ctor !== currE._0.ctor)
{
return render(wrappedNext);
}
var nexts = List.toArray(nextE._1);
var kids = node.childNodes;
if (nexts.length !== kids.length)
{
return render(wrappedNext);
}
var currs = List.toArray(currE._1);
var dir = nextE._0.ctor;
var goDir = directionTable[dir];
var toReverse = needsReversal(dir);
var len = kids.length;
for (var i = len; i--; )
{
var subNode = kids[toReverse ? len - i - 1 : i];
goDir(updateAndReplace(subNode, currs[i], nexts[i]));
}
updateProps(node, curr, next);
return rootNode;
case 'Container':
var subNode = node.firstChild;
var newSubNode = updateAndReplace(subNode, currE._1, nextE._1);
setPos(nextE._0, nextE._1, newSubNode);
updateProps(node, curr, next);
return rootNode;
case 'Custom':
if (currE.type === nextE.type)
{
var updatedNode = nextE.update(node, currE.model, nextE.model);
updateProps(updatedNode, curr, next);
return updatedNode;
}
return render(wrappedNext);
}
}
function updateProps(node, curr, next)
{
var nextProps = next.props;
var currProps = curr.props;
var element = next.element;
var width = nextProps.width - (element.adjustWidth || 0);
var height = nextProps.height - (element.adjustHeight || 0);
if (width !== currProps.width)
{
node.style.width = (width | 0) + 'px';
}
if (height !== currProps.height)
{
node.style.height = (height | 0) + 'px';
}
if (nextProps.opacity !== currProps.opacity)
{
node.style.opacity = nextProps.opacity;
}
var nextColor = nextProps.color.ctor === 'Just'
? Color.toCss(nextProps.color._0)
: '';
if (node.style.backgroundColor !== nextColor)
{
node.style.backgroundColor = nextColor;
}
if (nextProps.tag !== currProps.tag)
{
node.id = nextProps.tag;
}
if (nextProps.href !== currProps.href)
{
if (currProps.href === '')
{
// add a surrounding href
var anchor = createNode('a');
anchor.href = nextProps.href;
anchor.style.display = 'block';
anchor.style.pointerEvents = 'auto';
node.parentNode.replaceChild(anchor, node);
anchor.appendChild(node);
}
else if (nextProps.href === '')
{
// remove the surrounding href
var anchor = node.parentNode;
anchor.parentNode.replaceChild(node, anchor);
}
else
{
// just update the link
node.parentNode.href = nextProps.href;
}
}
// update click and hover handlers
var removed = false;
// update hover handlers
if (currProps.hover.ctor === '_Tuple0')
{
if (nextProps.hover.ctor !== '_Tuple0')
{
addHover(node, nextProps.hover);
}
}
else
{
if (nextProps.hover.ctor === '_Tuple0')
{
removed = true;
removeHover(node);
}
else
{
node.elm_hover_handler = nextProps.hover;
}
}
// update click handlers
if (currProps.click.ctor === '_Tuple0')
{
if (nextProps.click.ctor !== '_Tuple0')
{
addClick(node, nextProps.click);
}
}
else
{
if (nextProps.click.ctor === '_Tuple0')
{
removed = true;
removeClick(node);
}
else
{
node.elm_click_handler = nextProps.click;
}
}
// stop capturing clicks if
if (removed
&& nextProps.hover.ctor === '_Tuple0'
&& nextProps.click.ctor === '_Tuple0')
{
node.style.pointerEvents = 'none';
}
}
// TEXT
function block(align)
{
return function(text)
{
var raw = {
ctor: 'RawHtml',
html: Text.renderHtml(text),
align: align
};
var pos = htmlHeight(0, raw);
return newElement(pos._0, pos._1, raw);
};
}
function markdown(text)
{
var raw = {
ctor: 'RawHtml',
html: text,
align: null
};
var pos = htmlHeight(0, raw);
return newElement(pos._0, pos._1, raw);
}
var htmlHeight =
typeof document !== 'undefined'
? realHtmlHeight
: function(a, b) { return Utils.Tuple2(0, 0); };
function realHtmlHeight(width, rawHtml)
{
// create dummy node
var temp = document.createElement('div');
temp.innerHTML = rawHtml.html;
if (width > 0)
{
temp.style.width = width + 'px';
}
temp.style.visibility = 'hidden';
temp.style.styleFloat = 'left';
temp.style.cssFloat = 'left';
document.body.appendChild(temp);
// get dimensions
var style = window.getComputedStyle(temp, null);
var w = Math.ceil(style.getPropertyValue('width').slice(0, -2) - 0);
var h = Math.ceil(style.getPropertyValue('height').slice(0, -2) - 0);
document.body.removeChild(temp);
return Utils.Tuple2(w, h);
}
return localRuntime.Native.Graphics.Element.values = {
render: render,
update: update,
updateAndReplace: updateAndReplace,
createNode: createNode,
newElement: F3(newElement),
addTransform: addTransform,
htmlHeight: F2(htmlHeight),
guid: Utils.guid,
block: block,
markdown: markdown
};
};
Elm.Native.Text = {};
Elm.Native.Text.make = function(localRuntime) {
localRuntime.Native = localRuntime.Native || {};
localRuntime.Native.Text = localRuntime.Native.Text || {};
if (localRuntime.Native.Text.values)
{
return localRuntime.Native.Text.values;
}
var toCss = Elm.Native.Color.make(localRuntime).toCss;
var List = Elm.Native.List.make(localRuntime);
// CONSTRUCTORS
function fromString(str)
{
return {
ctor: 'Text:Text',
_0: str
};
}
function append(a, b)
{
return {
ctor: 'Text:Append',
_0: a,
_1: b
};
}
function addMeta(field, value, text)
{
var newProps = {};
var newText = {
ctor: 'Text:Meta',
_0: newProps,
_1: text
};
if (text.ctor === 'Text:Meta')
{
newText._1 = text._1;
var props = text._0;
for (var i = metaKeys.length; i--; )
{
var key = metaKeys[i];
var val = props[key];
if (val)
{
newProps[key] = val;
}
}
}
newProps[field] = value;
return newText;
}
var metaKeys = [
'font-size',
'font-family',
'font-style',
'font-weight',
'href',
'text-decoration',
'color'
];
// conversions from Elm values to CSS
function toTypefaces(list)
{
var typefaces = List.toArray(list);
for (var i = typefaces.length; i--; )
{
var typeface = typefaces[i];
if (typeface.indexOf(' ') > -1)
{
typefaces[i] = "'" + typeface + "'";
}
}
return typefaces.join(',');
}
function toLine(line)
{
var ctor = line.ctor;
return ctor === 'Under'
? 'underline'
: ctor === 'Over'
? 'overline'
: 'line-through';
}
// setting styles of Text
function style(style, text)
{
var newText = addMeta('color', toCss(style.color), text);
var props = newText._0;
if (style.typeface.ctor !== '[]')
{
props['font-family'] = toTypefaces(style.typeface);
}
if (style.height.ctor !== 'Nothing')
{
props['font-size'] = style.height._0 + 'px';
}
if (style.bold)
{
props['font-weight'] = 'bold';
}
if (style.italic)
{
props['font-style'] = 'italic';
}
if (style.line.ctor !== 'Nothing')
{
props['text-decoration'] = toLine(style.line._0);
}
return newText;
}
function height(px, text)
{
return addMeta('font-size', px + 'px', text);
}
function typeface(names, text)
{
return addMeta('font-family', toTypefaces(names), text);
}
function monospace(text)
{
return addMeta('font-family', 'monospace', text);
}
function italic(text)
{
return addMeta('font-style', 'italic', text);
}
function bold(text)
{
return addMeta('font-weight', 'bold', text);
}
function link(href, text)
{
return addMeta('href', href, text);
}
function line(line, text)
{
return addMeta('text-decoration', toLine(line), text);
}
function color(color, text)
{
return addMeta('color', toCss(color), text);
}
// RENDER
function renderHtml(text)
{
var tag = text.ctor;
if (tag === 'Text:Append')
{
return renderHtml(text._0) + renderHtml(text._1);
}
if (tag === 'Text:Text')
{
return properEscape(text._0);
}
if (tag === 'Text:Meta')
{
return renderMeta(text._0, renderHtml(text._1));
}
}
function renderMeta(metas, string)
{
var href = metas.href;
if (href)
{
string = '<a href="' + href + '">' + string + '</a>';
}
var styles = '';
for (var key in metas)
{
if (key === 'href')
{
continue;
}
styles += key + ':' + metas[key] + ';';
}
if (styles)
{
string = '<span style="' + styles + '">' + string + '</span>';
}
return string;
}
function properEscape(str)
{
if (str.length === 0)
{
return str;
}
str = str //.replace(/&/g, '&')
.replace(/"/g, '"')
.replace(/'/g, ''')
.replace(/</g, '<')
.replace(/>/g, '>');
var arr = str.split('\n');
for (var i = arr.length; i--; )
{
arr[i] = makeSpaces(arr[i]);
}
return arr.join('<br/>');
}
function makeSpaces(s)
{
if (s.length === 0)
{
return s;
}
var arr = s.split('');
if (arr[0] === ' ')
{
arr[0] = ' ';
}
for (var i = arr.length; --i; )
{
if (arr[i][0] === ' ' && arr[i - 1] === ' ')
{
arr[i - 1] = arr[i - 1] + arr[i];
arr[i] = '';
}
}
for (var i = arr.length; i--; )
{
if (arr[i].length > 1 && arr[i][0] === ' ')
{
var spaces = arr[i].split('');
for (var j = spaces.length - 2; j >= 0; j -= 2)
{
spaces[j] = ' ';
}
arr[i] = spaces.join('');
}
}
arr = arr.join('');
if (arr[arr.length - 1] === ' ')
{
return arr.slice(0, -1) + ' ';
}
return arr;
}
return localRuntime.Native.Text.values = {
fromString: fromString,
append: F2(append),
height: F2(height),
italic: italic,
bold: bold,
line: F2(line),
monospace: monospace,
typeface: F2(typeface),
color: F2(color),
link: F2(link),
style: F2(style),
toTypefaces: toTypefaces,
toLine: toLine,
renderHtml: renderHtml
};
};
Elm.Text = Elm.Text || {};
Elm.Text.make = function (_elm) {
"use strict";
_elm.Text = _elm.Text || {};
if (_elm.Text.values) return _elm.Text.values;
var _U = Elm.Native.Utils.make(_elm),
$Color = Elm.Color.make(_elm),
$List = Elm.List.make(_elm),
$Maybe = Elm.Maybe.make(_elm),
$Native$Text = Elm.Native.Text.make(_elm);
var _op = {};
var line = $Native$Text.line;
var italic = $Native$Text.italic;
var bold = $Native$Text.bold;
var color = $Native$Text.color;
var height = $Native$Text.height;
var link = $Native$Text.link;
var monospace = $Native$Text.monospace;
var typeface = $Native$Text.typeface;
var style = $Native$Text.style;
var append = $Native$Text.append;
var fromString = $Native$Text.fromString;
var empty = fromString("");
var concat = function (texts) { return A3($List.foldr,append,empty,texts);};
var join = F2(function (seperator,texts) { return concat(A2($List.intersperse,seperator,texts));});
var defaultStyle = {typeface: _U.list([]),height: $Maybe.Nothing,color: $Color.black,bold: false,italic: false,line: $Maybe.Nothing};
var Style = F6(function (a,b,c,d,e,f) { return {typeface: a,height: b,color: c,bold: d,italic: e,line: f};});
var Through = {ctor: "Through"};
var Over = {ctor: "Over"};
var Under = {ctor: "Under"};
var Text = {ctor: "Text"};
return _elm.Text.values = {_op: _op
,fromString: fromString
,empty: empty
,append: append
,concat: concat
,join: join
,link: link
,style: style
,defaultStyle: defaultStyle
,typeface: typeface
,monospace: monospace
,height: height
,color: color
,bold: bold
,italic: italic
,line: line
,Style: Style
,Under: Under
,Over: Over
,Through: Through};
};
Elm.Graphics = Elm.Graphics || {};
Elm.Graphics.Element = Elm.Graphics.Element || {};
Elm.Graphics.Element.make = function (_elm) {
"use strict";
_elm.Graphics = _elm.Graphics || {};
_elm.Graphics.Element = _elm.Graphics.Element || {};
if (_elm.Graphics.Element.values) return _elm.Graphics.Element.values;
var _U = Elm.Native.Utils.make(_elm),
$Basics = Elm.Basics.make(_elm),
$Color = Elm.Color.make(_elm),
$List = Elm.List.make(_elm),
$Maybe = Elm.Maybe.make(_elm),
$Native$Graphics$Element = Elm.Native.Graphics.Element.make(_elm),
$Text = Elm.Text.make(_elm);
var _op = {};
var DOut = {ctor: "DOut"};
var outward = DOut;
var DIn = {ctor: "DIn"};
var inward = DIn;
var DRight = {ctor: "DRight"};
var right = DRight;
var DLeft = {ctor: "DLeft"};
var left = DLeft;
var DDown = {ctor: "DDown"};
var down = DDown;
var DUp = {ctor: "DUp"};
var up = DUp;
var RawPosition = F4(function (a,b,c,d) { return {horizontal: a,vertical: b,x: c,y: d};});
var Position = function (a) { return {ctor: "Position",_0: a};};
var Relative = function (a) { return {ctor: "Relative",_0: a};};
var relative = Relative;
var Absolute = function (a) { return {ctor: "Absolute",_0: a};};
var absolute = Absolute;
var N = {ctor: "N"};
var bottomLeft = Position({horizontal: N,vertical: N,x: Absolute(0),y: Absolute(0)});
var bottomLeftAt = F2(function (x,y) { return Position({horizontal: N,vertical: N,x: x,y: y});});
var Z = {ctor: "Z"};
var middle = Position({horizontal: Z,vertical: Z,x: Relative(0.5),y: Relative(0.5)});
var midLeft = Position({horizontal: N,vertical: Z,x: Absolute(0),y: Relative(0.5)});
var midBottom = Position({horizontal: Z,vertical: N,x: Relative(0.5),y: Absolute(0)});
var middleAt = F2(function (x,y) { return Position({horizontal: Z,vertical: Z,x: x,y: y});});
var midLeftAt = F2(function (x,y) { return Position({horizontal: N,vertical: Z,x: x,y: y});});
var midBottomAt = F2(function (x,y) { return Position({horizontal: Z,vertical: N,x: x,y: y});});
var P = {ctor: "P"};
var topLeft = Position({horizontal: N,vertical: P,x: Absolute(0),y: Absolute(0)});
var topRight = Position({horizontal: P,vertical: P,x: Absolute(0),y: Absolute(0)});
var bottomRight = Position({horizontal: P,vertical: N,x: Absolute(0),y: Absolute(0)});
var midRight = Position({horizontal: P,vertical: Z,x: Absolute(0),y: Relative(0.5)});
var midTop = Position({horizontal: Z,vertical: P,x: Relative(0.5),y: Absolute(0)});
var topLeftAt = F2(function (x,y) { return Position({horizontal: N,vertical: P,x: x,y: y});});
var topRightAt = F2(function (x,y) { return Position({horizontal: P,vertical: P,x: x,y: y});});
var bottomRightAt = F2(function (x,y) { return Position({horizontal: P,vertical: N,x: x,y: y});});
var midRightAt = F2(function (x,y) { return Position({horizontal: P,vertical: Z,x: x,y: y});});
var midTopAt = F2(function (x,y) { return Position({horizontal: Z,vertical: P,x: x,y: y});});
var justified = $Native$Graphics$Element.block("justify");
var centered = $Native$Graphics$Element.block("center");
var rightAligned = $Native$Graphics$Element.block("right");
var leftAligned = $Native$Graphics$Element.block("left");
var show = function (value) { return leftAligned($Text.monospace($Text.fromString($Basics.toString(value))));};
var Tiled = {ctor: "Tiled"};
var Cropped = function (a) { return {ctor: "Cropped",_0: a};};
var Fitted = {ctor: "Fitted"};
var Plain = {ctor: "Plain"};
var Custom = {ctor: "Custom"};
var RawHtml = {ctor: "RawHtml"};
var Spacer = {ctor: "Spacer"};
var Flow = F2(function (a,b) { return {ctor: "Flow",_0: a,_1: b};});
var Container = F2(function (a,b) { return {ctor: "Container",_0: a,_1: b};});
var Image = F4(function (a,b,c,d) { return {ctor: "Image",_0: a,_1: b,_2: c,_3: d};});
var newElement = $Native$Graphics$Element.newElement;
var image = F3(function (w,h,src) { return A3(newElement,w,h,A4(Image,Plain,w,h,src));});
var fittedImage = F3(function (w,h,src) { return A3(newElement,w,h,A4(Image,Fitted,w,h,src));});
var croppedImage = F4(function (pos,w,h,src) { return A3(newElement,w,h,A4(Image,Cropped(pos),w,h,src));});
var tiledImage = F3(function (w,h,src) { return A3(newElement,w,h,A4(Image,Tiled,w,h,src));});
var container = F4(function (w,h,_p0,e) { var _p1 = _p0;return A3(newElement,w,h,A2(Container,_p1._0,e));});
var spacer = F2(function (w,h) { return A3(newElement,w,h,Spacer);});
var sizeOf = function (_p2) { var _p3 = _p2;var _p4 = _p3._0;return {ctor: "_Tuple2",_0: _p4.props.width,_1: _p4.props.height};};
var heightOf = function (_p5) { var _p6 = _p5;return _p6._0.props.height;};
var widthOf = function (_p7) { var _p8 = _p7;return _p8._0.props.width;};
var above = F2(function (hi,lo) {
return A3(newElement,A2($Basics.max,widthOf(hi),widthOf(lo)),heightOf(hi) + heightOf(lo),A2(Flow,DDown,_U.list([hi,lo])));
});
var below = F2(function (lo,hi) {
return A3(newElement,A2($Basics.max,widthOf(hi),widthOf(lo)),heightOf(hi) + heightOf(lo),A2(Flow,DDown,_U.list([hi,lo])));
});
var beside = F2(function (lft,rht) {
return A3(newElement,widthOf(lft) + widthOf(rht),A2($Basics.max,heightOf(lft),heightOf(rht)),A2(Flow,right,_U.list([lft,rht])));
});
var layers = function (es) {
var hs = A2($List.map,heightOf,es);
var ws = A2($List.map,widthOf,es);
return A3(newElement,A2($Maybe.withDefault,0,$List.maximum(ws)),A2($Maybe.withDefault,0,$List.maximum(hs)),A2(Flow,DOut,es));
};
var empty = A2(spacer,0,0);
var flow = F2(function (dir,es) {
var newFlow = F2(function (w,h) { return A3(newElement,w,h,A2(Flow,dir,es));});
var maxOrZero = function (list) { return A2($Maybe.withDefault,0,$List.maximum(list));};
var hs = A2($List.map,heightOf,es);
var ws = A2($List.map,widthOf,es);
if (_U.eq(es,_U.list([]))) return empty; else {
var _p9 = dir;
switch (_p9.ctor)
{case "DUp": return A2(newFlow,maxOrZero(ws),$List.sum(hs));
case "DDown": return A2(newFlow,maxOrZero(ws),$List.sum(hs));
case "DLeft": return A2(newFlow,$List.sum(ws),maxOrZero(hs));
case "DRight": return A2(newFlow,$List.sum(ws),maxOrZero(hs));
case "DIn": return A2(newFlow,maxOrZero(ws),maxOrZero(hs));
default: return A2(newFlow,maxOrZero(ws),maxOrZero(hs));}
}
});
var Properties = F9(function (a,b,c,d,e,f,g,h,i) { return {id: a,width: b,height: c,opacity: d,color: e,href: f,tag: g,hover: h,click: i};});
var Element_elm_builtin = function (a) { return {ctor: "Element_elm_builtin",_0: a};};
var width = F2(function (newWidth,_p10) {
var _p11 = _p10;
var _p14 = _p11._0.props;
var _p13 = _p11._0.element;
var newHeight = function () {
var _p12 = _p13;
switch (_p12.ctor)
{case "Image": return $Basics.round($Basics.toFloat(_p12._2) / $Basics.toFloat(_p12._1) * $Basics.toFloat(newWidth));
case "RawHtml": return $Basics.snd(A2($Native$Graphics$Element.htmlHeight,newWidth,_p13));
default: return _p14.height;}
}();
return Element_elm_builtin({element: _p13,props: _U.update(_p14,{width: newWidth,height: newHeight})});
});
var height = F2(function (newHeight,_p15) {
var _p16 = _p15;
return Element_elm_builtin({element: _p16._0.element,props: _U.update(_p16._0.props,{height: newHeight})});
});
var size = F3(function (w,h,e) { return A2(height,h,A2(width,w,e));});
var opacity = F2(function (givenOpacity,_p17) {
var _p18 = _p17;
return Element_elm_builtin({element: _p18._0.element,props: _U.update(_p18._0.props,{opacity: givenOpacity})});
});
var color = F2(function (clr,_p19) {
var _p20 = _p19;
return Element_elm_builtin({element: _p20._0.element,props: _U.update(_p20._0.props,{color: $Maybe.Just(clr)})});
});
var tag = F2(function (name,_p21) { var _p22 = _p21;return Element_elm_builtin({element: _p22._0.element,props: _U.update(_p22._0.props,{tag: name})});});
var link = F2(function (href,_p23) {
var _p24 = _p23;
return Element_elm_builtin({element: _p24._0.element,props: _U.update(_p24._0.props,{href: href})});
});
return _elm.Graphics.Element.values = {_op: _op
,image: image
,fittedImage: fittedImage
,croppedImage: croppedImage
,tiledImage: tiledImage
,leftAligned: leftAligned
,rightAligned: rightAligned
,centered: centered
,justified: justified
,show: show
,width: width
,height: height
,size: size
,color: color
,opacity: opacity
,link: link
,tag: tag
,widthOf: widthOf
,heightOf: heightOf
,sizeOf: sizeOf
,flow: flow
,up: up
,down: down
,left: left
,right: right
,inward: inward
,outward: outward
,layers: layers
,above: above
,below: below
,beside: beside
,empty: empty
,spacer: spacer
,container: container
,middle: middle
,midTop: midTop
,midBottom: midBottom
,midLeft: midLeft
,midRight: midRight
,topLeft: topLeft
,topRight: topRight
,bottomLeft: bottomLeft
,bottomRight: bottomRight
,absolute: absolute
,relative: relative
,middleAt: middleAt
,midTopAt: midTopAt
,midBottomAt: midBottomAt
,midLeftAt: midLeftAt
,midRightAt: midRightAt
,topLeftAt: topLeftAt
,topRightAt: topRightAt
,bottomLeftAt: bottomLeftAt
,bottomRightAt: bottomRightAt};
};
Elm.Graphics = Elm.Graphics || {};
Elm.Graphics.Collage = Elm.Graphics.Collage || {};
Elm.Graphics.Collage.make = function (_elm) {
"use strict";
_elm.Graphics = _elm.Graphics || {};
_elm.Graphics.Collage = _elm.Graphics.Collage || {};
if (_elm.Graphics.Collage.values) return _elm.Graphics.Collage.values;
var _U = Elm.Native.Utils.make(_elm),
$Basics = Elm.Basics.make(_elm),
$Color = Elm.Color.make(_elm),
$Graphics$Element = Elm.Graphics.Element.make(_elm),
$List = Elm.List.make(_elm),
$Native$Graphics$Collage = Elm.Native.Graphics.Collage.make(_elm),
$Text = Elm.Text.make(_elm),
$Transform2D = Elm.Transform2D.make(_elm);
var _op = {};
var Shape = function (a) { return {ctor: "Shape",_0: a};};
var polygon = function (points) { return Shape(points);};
var rect = F2(function (w,h) {
var hh = h / 2;
var hw = w / 2;
return Shape(_U.list([{ctor: "_Tuple2",_0: 0 - hw,_1: 0 - hh}
,{ctor: "_Tuple2",_0: 0 - hw,_1: hh}
,{ctor: "_Tuple2",_0: hw,_1: hh}
,{ctor: "_Tuple2",_0: hw,_1: 0 - hh}]));
});
var square = function (n) { return A2(rect,n,n);};
var oval = F2(function (w,h) {
var hh = h / 2;
var hw = w / 2;
var n = 50;
var t = 2 * $Basics.pi / n;
var f = function (i) { return {ctor: "_Tuple2",_0: hw * $Basics.cos(t * i),_1: hh * $Basics.sin(t * i)};};
return Shape(A2($List.map,f,_U.range(0,n - 1)));
});
var circle = function (r) { return A2(oval,2 * r,2 * r);};
var ngon = F2(function (n,r) {
var m = $Basics.toFloat(n);
var t = 2 * $Basics.pi / m;
var f = function (i) { return {ctor: "_Tuple2",_0: r * $Basics.cos(t * i),_1: r * $Basics.sin(t * i)};};
return Shape(A2($List.map,f,_U.range(0,m - 1)));
});
var Path = function (a) { return {ctor: "Path",_0: a};};
var path = function (ps) { return Path(ps);};
var segment = F2(function (p1,p2) { return Path(_U.list([p1,p2]));});
var collage = $Native$Graphics$Collage.collage;
var Fill = function (a) { return {ctor: "Fill",_0: a};};
var Line = function (a) { return {ctor: "Line",_0: a};};
var FGroup = F2(function (a,b) { return {ctor: "FGroup",_0: a,_1: b};});
var FElement = function (a) { return {ctor: "FElement",_0: a};};
var FImage = F4(function (a,b,c,d) { return {ctor: "FImage",_0: a,_1: b,_2: c,_3: d};});
var FText = function (a) { return {ctor: "FText",_0: a};};
var FOutlinedText = F2(function (a,b) { return {ctor: "FOutlinedText",_0: a,_1: b};});
var FShape = F2(function (a,b) { return {ctor: "FShape",_0: a,_1: b};});
var FPath = F2(function (a,b) { return {ctor: "FPath",_0: a,_1: b};});
var LineStyle = F6(function (a,b,c,d,e,f) { return {color: a,width: b,cap: c,join: d,dashing: e,dashOffset: f};});
var Clipped = {ctor: "Clipped"};
var Sharp = function (a) { return {ctor: "Sharp",_0: a};};
var Smooth = {ctor: "Smooth"};
var Padded = {ctor: "Padded"};
var Round = {ctor: "Round"};
var Flat = {ctor: "Flat"};
var defaultLine = {color: $Color.black,width: 1,cap: Flat,join: Sharp(10),dashing: _U.list([]),dashOffset: 0};
var solid = function (clr) { return _U.update(defaultLine,{color: clr});};
var dashed = function (clr) { return _U.update(defaultLine,{color: clr,dashing: _U.list([8,4])});};
var dotted = function (clr) { return _U.update(defaultLine,{color: clr,dashing: _U.list([3,3])});};
var Grad = function (a) { return {ctor: "Grad",_0: a};};
var Texture = function (a) { return {ctor: "Texture",_0: a};};
var Solid = function (a) { return {ctor: "Solid",_0: a};};
var Form_elm_builtin = function (a) { return {ctor: "Form_elm_builtin",_0: a};};
var form = function (f) { return Form_elm_builtin({theta: 0,scale: 1,x: 0,y: 0,alpha: 1,form: f});};
var fill = F2(function (style,_p0) { var _p1 = _p0;return form(A2(FShape,Fill(style),_p1._0));});
var filled = F2(function (color,shape) { return A2(fill,Solid(color),shape);});
var textured = F2(function (src,shape) { return A2(fill,Texture(src),shape);});
var gradient = F2(function (grad,shape) { return A2(fill,Grad(grad),shape);});
var outlined = F2(function (style,_p2) { var _p3 = _p2;return form(A2(FShape,Line(style),_p3._0));});
var traced = F2(function (style,_p4) { var _p5 = _p4;return form(A2(FPath,style,_p5._0));});
var sprite = F4(function (w,h,pos,src) { return form(A4(FImage,w,h,pos,src));});
var toForm = function (e) { return form(FElement(e));};
var group = function (fs) { return form(A2(FGroup,$Transform2D.identity,fs));};
var groupTransform = F2(function (matrix,fs) { return form(A2(FGroup,matrix,fs));});
var text = function (t) { return form(FText(t));};
var outlinedText = F2(function (ls,t) { return form(A2(FOutlinedText,ls,t));});
var move = F2(function (_p7,_p6) {
var _p8 = _p7;
var _p9 = _p6;
var _p10 = _p9._0;
return Form_elm_builtin(_U.update(_p10,{x: _p10.x + _p8._0,y: _p10.y + _p8._1}));
});
var moveX = F2(function (x,_p11) { var _p12 = _p11;var _p13 = _p12._0;return Form_elm_builtin(_U.update(_p13,{x: _p13.x + x}));});
var moveY = F2(function (y,_p14) { var _p15 = _p14;var _p16 = _p15._0;return Form_elm_builtin(_U.update(_p16,{y: _p16.y + y}));});
var scale = F2(function (s,_p17) { var _p18 = _p17;var _p19 = _p18._0;return Form_elm_builtin(_U.update(_p19,{scale: _p19.scale * s}));});
var rotate = F2(function (t,_p20) { var _p21 = _p20;var _p22 = _p21._0;return Form_elm_builtin(_U.update(_p22,{theta: _p22.theta + t}));});
var alpha = F2(function (a,_p23) { var _p24 = _p23;return Form_elm_builtin(_U.update(_p24._0,{alpha: a}));});
return _elm.Graphics.Collage.values = {_op: _op
,collage: collage
,toForm: toForm
,filled: filled
,textured: textured
,gradient: gradient
,outlined: outlined
,traced: traced
,text: text
,outlinedText: outlinedText
,move: move
,moveX: moveX
,moveY: moveY
,scale: scale
,rotate: rotate
,alpha: alpha
,group: group
,groupTransform: groupTransform
,rect: rect
,oval: oval
,square: square
,circle: circle
,ngon: ngon
,polygon: polygon
,segment: segment
,path: path
,solid: solid
,dashed: dashed
,dotted: dotted
,defaultLine: defaultLine
,LineStyle: LineStyle
,Flat: Flat
,Round: Round
,Padded: Padded
,Smooth: Smooth
,Sharp: Sharp
,Clipped: Clipped};
};
Elm.Native.Debug = {};
Elm.Native.Debug.make = function(localRuntime) {
localRuntime.Native = localRuntime.Native || {};
localRuntime.Native.Debug = localRuntime.Native.Debug || {};
if (localRuntime.Native.Debug.values)
{
return localRuntime.Native.Debug.values;
}
var toString = Elm.Native.Utils.make(localRuntime).toString;
function log(tag, value)
{
var msg = tag + ': ' + toString(value);
var process = process || {};
if (process.stdout)
{
process.stdout.write(msg);
}
else
{
console.log(msg);
}
return value;
}
function crash(message)
{
throw new Error(message);
}
function tracePath(tag, form)
{
if (localRuntime.debug)
{
return localRuntime.debug.trace(tag, form);
}
return form;
}
function watch(tag, value)
{
if (localRuntime.debug)
{
localRuntime.debug.watch(tag, value);
}
return value;
}
function watchSummary(tag, summarize, value)
{
if (localRuntime.debug)
{
localRuntime.debug.watch(tag, summarize(value));
}
return value;
}
return localRuntime.Native.Debug.values = {
crash: crash,
tracePath: F2(tracePath),
log: F2(log),
watch: F2(watch),
watchSummary: F3(watchSummary)
};
};
Elm.Debug = Elm.Debug || {};
Elm.Debug.make = function (_elm) {
"use strict";
_elm.Debug = _elm.Debug || {};
if (_elm.Debug.values) return _elm.Debug.values;
var _U = Elm.Native.Utils.make(_elm),$Graphics$Collage = Elm.Graphics.Collage.make(_elm),$Native$Debug = Elm.Native.Debug.make(_elm);
var _op = {};
var trace = $Native$Debug.tracePath;
var watchSummary = $Native$Debug.watchSummary;
var watch = $Native$Debug.watch;
var crash = $Native$Debug.crash;
var log = $Native$Debug.log;
return _elm.Debug.values = {_op: _op,log: log,crash: crash,watch: watch,watchSummary: watchSummary,trace: trace};
};
Elm.Native.Task = {};
Elm.Native.Task.make = function(localRuntime) {
localRuntime.Native = localRuntime.Native || {};
localRuntime.Native.Task = localRuntime.Native.Task || {};
if (localRuntime.Native.Task.values)
{
return localRuntime.Native.Task.values;
}
var Result = Elm.Result.make(localRuntime);
var Signal;
var Utils = Elm.Native.Utils.make(localRuntime);
// CONSTRUCTORS
function succeed(value)
{
return {
tag: 'Succeed',
value: value
};
}
function fail(error)
{
return {
tag: 'Fail',
value: error
};
}
function asyncFunction(func)
{
return {
tag: 'Async',
asyncFunction: func
};
}
function andThen(task, callback)
{
return {
tag: 'AndThen',
task: task,
callback: callback
};
}
function catch_(task, callback)
{
return {
tag: 'Catch',
task: task,
callback: callback
};
}
// RUNNER
function perform(task) {
runTask({ task: task }, function() {});
}
function performSignal(name, signal)
{
var workQueue = [];
function onComplete()
{
workQueue.shift();
if (workQueue.length > 0)
{
var task = workQueue[0];
setTimeout(function() {
runTask(task, onComplete);
}, 0);
}
}
function register(task)
{
var root = { task: task };
workQueue.push(root);
if (workQueue.length === 1)
{
runTask(root, onComplete);
}
}
if (!Signal)
{
Signal = Elm.Native.Signal.make(localRuntime);
}
Signal.output('perform-tasks-' + name, register, signal);
register(signal.value);
return signal;
}
function mark(status, task)
{
return { status: status, task: task };
}
function runTask(root, onComplete)
{
var result = mark('runnable', root.task);
while (result.status === 'runnable')
{
result = stepTask(onComplete, root, result.task);
}
if (result.status === 'done')
{
root.task = result.task;
onComplete();
}
if (result.status === 'blocked')
{
root.task = result.task;
}
}
function stepTask(onComplete, root, task)
{
var tag = task.tag;
if (tag === 'Succeed' || tag === 'Fail')
{
return mark('done', task);
}
if (tag === 'Async')
{
var placeHolder = {};
var couldBeSync = true;
var wasSync = false;
task.asyncFunction(function(result) {
placeHolder.tag = result.tag;
placeHolder.value = result.value;
if (couldBeSync)
{
wasSync = true;
}
else
{
runTask(root, onComplete);
}
});
couldBeSync = false;
return mark(wasSync ? 'done' : 'blocked', placeHolder);
}
if (tag === 'AndThen' || tag === 'Catch')
{
var result = mark('runnable', task.task);
while (result.status === 'runnable')
{
result = stepTask(onComplete, root, result.task);
}
if (result.status === 'done')
{
var activeTask = result.task;
var activeTag = activeTask.tag;
var succeedChain = activeTag === 'Succeed' && tag === 'AndThen';
var failChain = activeTag === 'Fail' && tag === 'Catch';
return (succeedChain || failChain)
? mark('runnable', task.callback(activeTask.value))
: mark('runnable', activeTask);
}
if (result.status === 'blocked')
{
return mark('blocked', {
tag: tag,
task: result.task,
callback: task.callback
});
}
}
}
// THREADS
function sleep(time) {
return asyncFunction(function(callback) {
setTimeout(function() {
callback(succeed(Utils.Tuple0));
}, time);
});
}
function spawn(task) {
return asyncFunction(function(callback) {
var id = setTimeout(function() {
perform(task);
}, 0);
callback(succeed(id));
});
}
return localRuntime.Native.Task.values = {
succeed: succeed,
fail: fail,
asyncFunction: asyncFunction,
andThen: F2(andThen),
catch_: F2(catch_),
perform: perform,
performSignal: performSignal,
spawn: spawn,
sleep: sleep
};
};
Elm.Result = Elm.Result || {};
Elm.Result.make = function (_elm) {
"use strict";
_elm.Result = _elm.Result || {};
if (_elm.Result.values) return _elm.Result.values;
var _U = Elm.Native.Utils.make(_elm),$Maybe = Elm.Maybe.make(_elm);
var _op = {};
var toMaybe = function (result) { var _p0 = result;if (_p0.ctor === "Ok") { return $Maybe.Just(_p0._0);} else { return $Maybe.Nothing;}};
var withDefault = F2(function (def,result) { var _p1 = result;if (_p1.ctor === "Ok") { return _p1._0;} else { return def;}});
var Err = function (a) { return {ctor: "Err",_0: a};};
var andThen = F2(function (result,callback) { var _p2 = result;if (_p2.ctor === "Ok") { return callback(_p2._0);} else { return Err(_p2._0);}});
var Ok = function (a) { return {ctor: "Ok",_0: a};};
var map = F2(function (func,ra) { var _p3 = ra;if (_p3.ctor === "Ok") { return Ok(func(_p3._0));} else { return Err(_p3._0);}});
var map2 = F3(function (func,ra,rb) {
var _p4 = {ctor: "_Tuple2",_0: ra,_1: rb};
if (_p4._0.ctor === "Ok") {
if (_p4._1.ctor === "Ok") {
return Ok(A2(func,_p4._0._0,_p4._1._0));
} else {
return Err(_p4._1._0);
}
} else {
return Err(_p4._0._0);
}
});
var map3 = F4(function (func,ra,rb,rc) {
var _p5 = {ctor: "_Tuple3",_0: ra,_1: rb,_2: rc};
if (_p5._0.ctor === "Ok") {
if (_p5._1.ctor === "Ok") {
if (_p5._2.ctor === "Ok") {
return Ok(A3(func,_p5._0._0,_p5._1._0,_p5._2._0));
} else {
return Err(_p5._2._0);
}
} else {
return Err(_p5._1._0);
}
} else {
return Err(_p5._0._0);
}
});
var map4 = F5(function (func,ra,rb,rc,rd) {
var _p6 = {ctor: "_Tuple4",_0: ra,_1: rb,_2: rc,_3: rd};
if (_p6._0.ctor === "Ok") {
if (_p6._1.ctor === "Ok") {
if (_p6._2.ctor === "Ok") {
if (_p6._3.ctor === "Ok") {
return Ok(A4(func,_p6._0._0,_p6._1._0,_p6._2._0,_p6._3._0));
} else {
return Err(_p6._3._0);
}
} else {
return Err(_p6._2._0);
}
} else {
return Err(_p6._1._0);
}
} else {
return Err(_p6._0._0);
}
});
var map5 = F6(function (func,ra,rb,rc,rd,re) {
var _p7 = {ctor: "_Tuple5",_0: ra,_1: rb,_2: rc,_3: rd,_4: re};
if (_p7._0.ctor === "Ok") {
if (_p7._1.ctor === "Ok") {
if (_p7._2.ctor === "Ok") {
if (_p7._3.ctor === "Ok") {
if (_p7._4.ctor === "Ok") {
return Ok(A5(func,_p7._0._0,_p7._1._0,_p7._2._0,_p7._3._0,_p7._4._0));
} else {
return Err(_p7._4._0);
}
} else {
return Err(_p7._3._0);
}
} else {
return Err(_p7._2._0);
}
} else {
return Err(_p7._1._0);
}
} else {
return Err(_p7._0._0);
}
});
var formatError = F2(function (f,result) { var _p8 = result;if (_p8.ctor === "Ok") { return Ok(_p8._0);} else { return Err(f(_p8._0));}});
var fromMaybe = F2(function (err,maybe) { var _p9 = maybe;if (_p9.ctor === "Just") { return Ok(_p9._0);} else { return Err(err);}});
return _elm.Result.values = {_op: _op
,withDefault: withDefault
,map: map
,map2: map2
,map3: map3
,map4: map4
,map5: map5
,andThen: andThen
,toMaybe: toMaybe
,fromMaybe: fromMaybe
,formatError: formatError
,Ok: Ok
,Err: Err};
};
Elm.Task = Elm.Task || {};
Elm.Task.make = function (_elm) {
"use strict";
_elm.Task = _elm.Task || {};
if (_elm.Task.values) return _elm.Task.values;
var _U = Elm.Native.Utils.make(_elm),
$List = Elm.List.make(_elm),
$Maybe = Elm.Maybe.make(_elm),
$Native$Task = Elm.Native.Task.make(_elm),
$Result = Elm.Result.make(_elm);
var _op = {};
var sleep = $Native$Task.sleep;
var spawn = $Native$Task.spawn;
var ThreadID = function (a) { return {ctor: "ThreadID",_0: a};};
var onError = $Native$Task.catch_;
var andThen = $Native$Task.andThen;
var fail = $Native$Task.fail;
var mapError = F2(function (f,task) { return A2(onError,task,function (err) { return fail(f(err));});});
var succeed = $Native$Task.succeed;
var map = F2(function (func,taskA) { return A2(andThen,taskA,function (a) { return succeed(func(a));});});
var map2 = F3(function (func,taskA,taskB) {
return A2(andThen,taskA,function (a) { return A2(andThen,taskB,function (b) { return succeed(A2(func,a,b));});});
});
var map3 = F4(function (func,taskA,taskB,taskC) {
return A2(andThen,
taskA,
function (a) {
return A2(andThen,taskB,function (b) { return A2(andThen,taskC,function (c) { return succeed(A3(func,a,b,c));});});
});
});
var map4 = F5(function (func,taskA,taskB,taskC,taskD) {
return A2(andThen,
taskA,
function (a) {
return A2(andThen,
taskB,
function (b) {
return A2(andThen,taskC,function (c) { return A2(andThen,taskD,function (d) { return succeed(A4(func,a,b,c,d));});});
});
});
});
var map5 = F6(function (func,taskA,taskB,taskC,taskD,taskE) {
return A2(andThen,
taskA,
function (a) {
return A2(andThen,
taskB,
function (b) {
return A2(andThen,
taskC,
function (c) {
return A2(andThen,taskD,function (d) { return A2(andThen,taskE,function (e) { return succeed(A5(func,a,b,c,d,e));});});
});
});
});
});
var andMap = F2(function (taskFunc,taskValue) {
return A2(andThen,taskFunc,function (func) { return A2(andThen,taskValue,function (value) { return succeed(func(value));});});
});
var sequence = function (tasks) {
var _p0 = tasks;
if (_p0.ctor === "[]") {
return succeed(_U.list([]));
} else {
return A3(map2,F2(function (x,y) { return A2($List._op["::"],x,y);}),_p0._0,sequence(_p0._1));
}
};
var toMaybe = function (task) { return A2(onError,A2(map,$Maybe.Just,task),function (_p1) { return succeed($Maybe.Nothing);});};
var fromMaybe = F2(function ($default,maybe) { var _p2 = maybe;if (_p2.ctor === "Just") { return succeed(_p2._0);} else { return fail($default);}});
var toResult = function (task) { return A2(onError,A2(map,$Result.Ok,task),function (msg) { return succeed($Result.Err(msg));});};
var fromResult = function (result) { var _p3 = result;if (_p3.ctor === "Ok") { return succeed(_p3._0);} else { return fail(_p3._0);}};
var Task = {ctor: "Task"};
return _elm.Task.values = {_op: _op
,succeed: succeed
,fail: fail
,map: map
,map2: map2
,map3: map3
,map4: map4
,map5: map5
,andMap: andMap
,sequence: sequence
,andThen: andThen
,onError: onError
,mapError: mapError
,toMaybe: toMaybe
,fromMaybe: fromMaybe
,toResult: toResult
,fromResult: fromResult
,spawn: spawn
,sleep: sleep};
};
Elm.Signal = Elm.Signal || {};
Elm.Signal.make = function (_elm) {
"use strict";
_elm.Signal = _elm.Signal || {};
if (_elm.Signal.values) return _elm.Signal.values;
var _U = Elm.Native.Utils.make(_elm),
$Basics = Elm.Basics.make(_elm),
$Debug = Elm.Debug.make(_elm),
$List = Elm.List.make(_elm),
$Maybe = Elm.Maybe.make(_elm),
$Native$Signal = Elm.Native.Signal.make(_elm),
$Task = Elm.Task.make(_elm);
var _op = {};
var send = F2(function (_p0,value) {
var _p1 = _p0;
return A2($Task.onError,_p1._0(value),function (_p2) { return $Task.succeed({ctor: "_Tuple0"});});
});
var Message = function (a) { return {ctor: "Message",_0: a};};
var message = F2(function (_p3,value) { var _p4 = _p3;return Message(_p4._0(value));});
var mailbox = $Native$Signal.mailbox;
var Address = function (a) { return {ctor: "Address",_0: a};};
var forwardTo = F2(function (_p5,f) { var _p6 = _p5;return Address(function (x) { return _p6._0(f(x));});});
var Mailbox = F2(function (a,b) { return {address: a,signal: b};});
var sampleOn = $Native$Signal.sampleOn;
var dropRepeats = $Native$Signal.dropRepeats;
var filterMap = $Native$Signal.filterMap;
var filter = F3(function (isOk,base,signal) {
return A3(filterMap,function (value) { return isOk(value) ? $Maybe.Just(value) : $Maybe.Nothing;},base,signal);
});
var merge = F2(function (left,right) { return A3($Native$Signal.genericMerge,$Basics.always,left,right);});
var mergeMany = function (signalList) {
var _p7 = $List.reverse(signalList);
if (_p7.ctor === "[]") {
return _U.crashCase("Signal",{start: {line: 184,column: 3},end: {line: 189,column: 40}},_p7)("mergeMany was given an empty list!");
} else {
return A3($List.foldl,merge,_p7._0,_p7._1);
}
};
var foldp = $Native$Signal.foldp;
var map5 = $Native$Signal.map5;
var map4 = $Native$Signal.map4;
var map3 = $Native$Signal.map3;
var map2 = $Native$Signal.map2;
var map = $Native$Signal.map;
var constant = $Native$Signal.constant;
var Signal = {ctor: "Signal"};
return _elm.Signal.values = {_op: _op
,merge: merge
,mergeMany: mergeMany
,map: map
,map2: map2
,map3: map3
,map4: map4
,map5: map5
,constant: constant
,dropRepeats: dropRepeats
,filter: filter
,filterMap: filterMap
,sampleOn: sampleOn
,foldp: foldp
,mailbox: mailbox
,send: send
,message: message
,forwardTo: forwardTo
,Mailbox: Mailbox};
};
Elm.Time = Elm.Time || {};
Elm.Time.make = function (_elm) {
"use strict";
_elm.Time = _elm.Time || {};
if (_elm.Time.values) return _elm.Time.values;
var _U = Elm.Native.Utils.make(_elm),
$Basics = Elm.Basics.make(_elm),
$Native$Signal = Elm.Native.Signal.make(_elm),
$Native$Time = Elm.Native.Time.make(_elm),
$Signal = Elm.Signal.make(_elm);
var _op = {};
var delay = $Native$Signal.delay;
var since = F2(function (time,signal) {
var stop = A2($Signal.map,$Basics.always(-1),A2(delay,time,signal));
var start = A2($Signal.map,$Basics.always(1),signal);
var delaydiff = A3($Signal.foldp,F2(function (x,y) { return x + y;}),0,A2($Signal.merge,start,stop));
return A2($Signal.map,F2(function (x,y) { return !_U.eq(x,y);})(0),delaydiff);
});
var timestamp = $Native$Signal.timestamp;
var every = $Native$Time.every;
var fpsWhen = $Native$Time.fpsWhen;
var fps = function (targetFrames) { return A2(fpsWhen,targetFrames,$Signal.constant(true));};
var inMilliseconds = function (t) { return t;};
var millisecond = 1;
var second = 1000 * millisecond;
var minute = 60 * second;
var hour = 60 * minute;
var inHours = function (t) { return t / hour;};
var inMinutes = function (t) { return t / minute;};
var inSeconds = function (t) { return t / second;};
return _elm.Time.values = {_op: _op
,millisecond: millisecond
,second: second
,minute: minute
,hour: hour
,inMilliseconds: inMilliseconds
,inSeconds: inSeconds
,inMinutes: inMinutes
,inHours: inHours
,fps: fps
,fpsWhen: fpsWhen
,every: every
,timestamp: timestamp
,delay: delay
,since: since};
};
Elm.Native.String = {};
Elm.Native.String.make = function(localRuntime) {
localRuntime.Native = localRuntime.Native || {};
localRuntime.Native.String = localRuntime.Native.String || {};
if (localRuntime.Native.String.values)
{
return localRuntime.Native.String.values;
}
if ('values' in Elm.Native.String)
{
return localRuntime.Native.String.values = Elm.Native.String.values;
}
var Char = Elm.Char.make(localRuntime);
var List = Elm.Native.List.make(localRuntime);
var Maybe = Elm.Maybe.make(localRuntime);
var Result = Elm.Result.make(localRuntime);
var Utils = Elm.Native.Utils.make(localRuntime);
function isEmpty(str)
{
return str.length === 0;
}
function cons(chr, str)
{
return chr + str;
}
function uncons(str)
{
var hd = str[0];
if (hd)
{
return Maybe.Just(Utils.Tuple2(Utils.chr(hd), str.slice(1)));
}
return Maybe.Nothing;
}
function append(a, b)
{
return a + b;
}
function concat(strs)
{
return List.toArray(strs).join('');
}
function length(str)
{
return str.length;
}
function map(f, str)
{
var out = str.split('');
for (var i = out.length; i--; )
{
out[i] = f(Utils.chr(out[i]));
}
return out.join('');
}
function filter(pred, str)
{
return str.split('').map(Utils.chr).filter(pred).join('');
}
function reverse(str)
{
return str.split('').reverse().join('');
}
function foldl(f, b, str)
{
var len = str.length;
for (var i = 0; i < len; ++i)
{
b = A2(f, Utils.chr(str[i]), b);
}
return b;
}
function foldr(f, b, str)
{
for (var i = str.length; i--; )
{
b = A2(f, Utils.chr(str[i]), b);
}
return b;
}
function split(sep, str)
{
return List.fromArray(str.split(sep));
}
function join(sep, strs)
{
return List.toArray(strs).join(sep);
}
function repeat(n, str)
{
var result = '';
while (n > 0)
{
if (n & 1)
{
result += str;
}
n >>= 1, str += str;
}
return result;
}
function slice(start, end, str)
{
return str.slice(start, end);
}
function left(n, str)
{
return n < 1 ? '' : str.slice(0, n);
}
function right(n, str)
{
return n < 1 ? '' : str.slice(-n);
}
function dropLeft(n, str)
{
return n < 1 ? str : str.slice(n);
}
function dropRight(n, str)
{
return n < 1 ? str : str.slice(0, -n);
}
function pad(n, chr, str)
{
var half = (n - str.length) / 2;
return repeat(Math.ceil(half), chr) + str + repeat(half | 0, chr);
}
function padRight(n, chr, str)
{
return str + repeat(n - str.length, chr);
}
function padLeft(n, chr, str)
{
return repeat(n - str.length, chr) + str;
}
function trim(str)
{
return str.trim();
}
function trimLeft(str)
{
return str.replace(/^\s+/, '');
}
function trimRight(str)
{
return str.replace(/\s+$/, '');
}
function words(str)
{
return List.fromArray(str.trim().split(/\s+/g));
}
function lines(str)
{
return List.fromArray(str.split(/\r\n|\r|\n/g));
}
function toUpper(str)
{
return str.toUpperCase();
}
function toLower(str)
{
return str.toLowerCase();
}
function any(pred, str)
{
for (var i = str.length; i--; )
{
if (pred(Utils.chr(str[i])))
{
return true;
}
}
return false;
}
function all(pred, str)
{
for (var i = str.length; i--; )
{
if (!pred(Utils.chr(str[i])))
{
return false;
}
}
return true;
}
function contains(sub, str)
{
return str.indexOf(sub) > -1;
}
function startsWith(sub, str)
{
return str.indexOf(sub) === 0;
}
function endsWith(sub, str)
{
return str.length >= sub.length &&
str.lastIndexOf(sub) === str.length - sub.length;
}
function indexes(sub, str)
{
var subLen = sub.length;
var i = 0;
var is = [];
while ((i = str.indexOf(sub, i)) > -1)
{
is.push(i);
i = i + subLen;
}
return List.fromArray(is);
}
function toInt(s)
{
var len = s.length;
if (len === 0)
{
return Result.Err("could not convert string '" + s + "' to an Int" );
}
var start = 0;
if (s[0] === '-')
{
if (len === 1)
{
return Result.Err("could not convert string '" + s + "' to an Int" );
}
start = 1;
}
for (var i = start; i < len; ++i)
{
if (!Char.isDigit(s[i]))
{
return Result.Err("could not convert string '" + s + "' to an Int" );
}
}
return Result.Ok(parseInt(s, 10));
}
function toFloat(s)
{
var len = s.length;
if (len === 0)
{
return Result.Err("could not convert string '" + s + "' to a Float" );
}
var start = 0;
if (s[0] === '-')
{
if (len === 1)
{
return Result.Err("could not convert string '" + s + "' to a Float" );
}
start = 1;
}
var dotCount = 0;
for (var i = start; i < len; ++i)
{
if (Char.isDigit(s[i]))
{
continue;
}
if (s[i] === '.')
{
dotCount += 1;
if (dotCount <= 1)
{
continue;
}
}
return Result.Err("could not convert string '" + s + "' to a Float" );
}
return Result.Ok(parseFloat(s));
}
function toList(str)
{
return List.fromArray(str.split('').map(Utils.chr));
}
function fromList(chars)
{
return List.toArray(chars).join('');
}
return Elm.Native.String.values = {
isEmpty: isEmpty,
cons: F2(cons),
uncons: uncons,
append: F2(append),
concat: concat,
length: length,
map: F2(map),
filter: F2(filter),
reverse: reverse,
foldl: F3(foldl),
foldr: F3(foldr),
split: F2(split),
join: F2(join),
repeat: F2(repeat),
slice: F3(slice),
left: F2(left),
right: F2(right),
dropLeft: F2(dropLeft),
dropRight: F2(dropRight),
pad: F3(pad),
padLeft: F3(padLeft),
padRight: F3(padRight),
trim: trim,
trimLeft: trimLeft,
trimRight: trimRight,
words: words,
lines: lines,
toUpper: toUpper,
toLower: toLower,
any: F2(any),
all: F2(all),
contains: F2(contains),
startsWith: F2(startsWith),
endsWith: F2(endsWith),
indexes: F2(indexes),
toInt: toInt,
toFloat: toFloat,
toList: toList,
fromList: fromList
};
};
Elm.String = Elm.String || {};
Elm.String.make = function (_elm) {
"use strict";
_elm.String = _elm.String || {};
if (_elm.String.values) return _elm.String.values;
var _U = Elm.Native.Utils.make(_elm),$Maybe = Elm.Maybe.make(_elm),$Native$String = Elm.Native.String.make(_elm),$Result = Elm.Result.make(_elm);
var _op = {};
var fromList = $Native$String.fromList;
var toList = $Native$String.toList;
var toFloat = $Native$String.toFloat;
var toInt = $Native$String.toInt;
var indices = $Native$String.indexes;
var indexes = $Native$String.indexes;
var endsWith = $Native$String.endsWith;
var startsWith = $Native$String.startsWith;
var contains = $Native$String.contains;
var all = $Native$String.all;
var any = $Native$String.any;
var toLower = $Native$String.toLower;
var toUpper = $Native$String.toUpper;
var lines = $Native$String.lines;
var words = $Native$String.words;
var trimRight = $Native$String.trimRight;
var trimLeft = $Native$String.trimLeft;
var trim = $Native$String.trim;
var padRight = $Native$String.padRight;
var padLeft = $Native$String.padLeft;
var pad = $Native$String.pad;
var dropRight = $Native$String.dropRight;
var dropLeft = $Native$String.dropLeft;
var right = $Native$String.right;
var left = $Native$String.left;
var slice = $Native$String.slice;
var repeat = $Native$String.repeat;
var join = $Native$String.join;
var split = $Native$String.split;
var foldr = $Native$String.foldr;
var foldl = $Native$String.foldl;
var reverse = $Native$String.reverse;
var filter = $Native$String.filter;
var map = $Native$String.map;
var length = $Native$String.length;
var concat = $Native$String.concat;
var append = $Native$String.append;
var uncons = $Native$String.uncons;
var cons = $Native$String.cons;
var fromChar = function ($char) { return A2(cons,$char,"");};
var isEmpty = $Native$String.isEmpty;
return _elm.String.values = {_op: _op
,isEmpty: isEmpty
,length: length
,reverse: reverse
,repeat: repeat
,cons: cons
,uncons: uncons
,fromChar: fromChar
,append: append
,concat: concat
,split: split
,join: join
,words: words
,lines: lines
,slice: slice
,left: left
,right: right
,dropLeft: dropLeft
,dropRight: dropRight
,contains: contains
,startsWith: startsWith
,endsWith: endsWith
,indexes: indexes
,indices: indices
,toInt: toInt
,toFloat: toFloat
,toList: toList
,fromList: fromList
,toUpper: toUpper
,toLower: toLower
,pad: pad
,padLeft: padLeft
,padRight: padRight
,trim: trim
,trimLeft: trimLeft
,trimRight: trimRight
,map: map
,filter: filter
,foldl: foldl
,foldr: foldr
,any: any
,all: all};
};
Elm.Dict = Elm.Dict || {};
Elm.Dict.make = function (_elm) {
"use strict";
_elm.Dict = _elm.Dict || {};
if (_elm.Dict.values) return _elm.Dict.values;
var _U = Elm.Native.Utils.make(_elm),
$Basics = Elm.Basics.make(_elm),
$List = Elm.List.make(_elm),
$Maybe = Elm.Maybe.make(_elm),
$Native$Debug = Elm.Native.Debug.make(_elm),
$String = Elm.String.make(_elm);
var _op = {};
var foldr = F3(function (f,acc,t) {
foldr: while (true) {
var _p0 = t;
if (_p0.ctor === "RBEmpty_elm_builtin") {
return acc;
} else {
var _v1 = f,_v2 = A3(f,_p0._1,_p0._2,A3(foldr,f,acc,_p0._4)),_v3 = _p0._3;
f = _v1;
acc = _v2;
t = _v3;
continue foldr;
}
}
});
var keys = function (dict) { return A3(foldr,F3(function (key,value,keyList) { return A2($List._op["::"],key,keyList);}),_U.list([]),dict);};
var values = function (dict) { return A3(foldr,F3(function (key,value,valueList) { return A2($List._op["::"],value,valueList);}),_U.list([]),dict);};
var toList = function (dict) {
return A3(foldr,F3(function (key,value,list) { return A2($List._op["::"],{ctor: "_Tuple2",_0: key,_1: value},list);}),_U.list([]),dict);
};
var foldl = F3(function (f,acc,dict) {
foldl: while (true) {
var _p1 = dict;
if (_p1.ctor === "RBEmpty_elm_builtin") {
return acc;
} else {
var _v5 = f,_v6 = A3(f,_p1._1,_p1._2,A3(foldl,f,acc,_p1._3)),_v7 = _p1._4;
f = _v5;
acc = _v6;
dict = _v7;
continue foldl;
}
}
});
var reportRemBug = F4(function (msg,c,lgot,rgot) {
return $Native$Debug.crash($String.concat(_U.list(["Internal red-black tree invariant violated, expected "
,msg
," and got "
,$Basics.toString(c)
,"/"
,lgot
,"/"
,rgot
,"\nPlease report this bug to <https://github.com/elm-lang/core/issues>"])));
});
var isBBlack = function (dict) {
var _p2 = dict;
_v8_2: do {
if (_p2.ctor === "RBNode_elm_builtin") {
if (_p2._0.ctor === "BBlack") {
return true;
} else {
break _v8_2;
}
} else {
if (_p2._0.ctor === "LBBlack") {
return true;
} else {
break _v8_2;
}
}
} while (false);
return false;
};
var Same = {ctor: "Same"};
var Remove = {ctor: "Remove"};
var Insert = {ctor: "Insert"};
var sizeHelp = F2(function (n,dict) {
sizeHelp: while (true) {
var _p3 = dict;
if (_p3.ctor === "RBEmpty_elm_builtin") {
return n;
} else {
var _v10 = A2(sizeHelp,n + 1,_p3._4),_v11 = _p3._3;
n = _v10;
dict = _v11;
continue sizeHelp;
}
}
});
var size = function (dict) { return A2(sizeHelp,0,dict);};
var get = F2(function (targetKey,dict) {
get: while (true) {
var _p4 = dict;
if (_p4.ctor === "RBEmpty_elm_builtin") {
return $Maybe.Nothing;
} else {
var _p5 = A2($Basics.compare,targetKey,_p4._1);
switch (_p5.ctor)
{case "LT": var _v14 = targetKey,_v15 = _p4._3;
targetKey = _v14;
dict = _v15;
continue get;
case "EQ": return $Maybe.Just(_p4._2);
default: var _v16 = targetKey,_v17 = _p4._4;
targetKey = _v16;
dict = _v17;
continue get;}
}
}
});
var member = F2(function (key,dict) { var _p6 = A2(get,key,dict);if (_p6.ctor === "Just") { return true;} else { return false;}});
var maxWithDefault = F3(function (k,v,r) {
maxWithDefault: while (true) {
var _p7 = r;
if (_p7.ctor === "RBEmpty_elm_builtin") {
return {ctor: "_Tuple2",_0: k,_1: v};
} else {
var _v20 = _p7._1,_v21 = _p7._2,_v22 = _p7._4;
k = _v20;
v = _v21;
r = _v22;
continue maxWithDefault;
}
}
});
var RBEmpty_elm_builtin = function (a) {
gitextract_2btuyzk6/
├── .gitignore
├── DocPreview/
│ ├── DocPreview.elm
│ ├── DocPreview.html
│ ├── LICENSE
│ ├── docPreview.js
│ ├── elm-package.json
│ ├── highlight.pack.js
│ └── src/
│ ├── Docs/
│ │ ├── Entry.elm
│ │ ├── Name.elm
│ │ ├── Package.elm
│ │ ├── Summary.elm
│ │ ├── Type.elm
│ │ └── Version.elm
│ ├── Native/
│ │ ├── Jump.js
│ │ └── Parse.js
│ ├── Parse/
│ │ ├── Combinators.elm
│ │ └── Type.elm
│ └── Utils/
│ ├── Code.elm
│ ├── FluidList.elm
│ ├── Markdown.elm
│ └── Path.elm
├── LICENSE.md
├── README.adoc
├── css/
│ ├── docpreview.css
│ ├── elm.css
│ ├── graph.css
│ ├── hinter.css
│ ├── inlinedoc.css
│ └── test.css
├── elm/
│ └── ModuleBrowser/
│ ├── ModuleBrowser.elm
│ ├── ModuleBrowser.html
│ ├── elm-package.json
│ └── moduleBrowser.js
├── elm-light.behaviors
├── elm-light_compiled.js
├── elm.keymap
├── js/
│ ├── highlight.pack.js
│ ├── show-hint.js
│ └── show-hint2.js
├── mode/
│ └── elm.js
├── node/
│ ├── elm-client.js
│ └── elmparser.js
├── package.json
├── plugin.edn
├── project.clj
├── src/
│ └── lt/
│ └── plugins/
│ ├── elm_light/
│ │ ├── autocompleter/
│ │ │ └── core.cljs
│ │ ├── autocompleter.cljs
│ │ ├── clients.cljs
│ │ ├── docpreview.cljs
│ │ ├── elm_ast.cljs
│ │ ├── format.cljs
│ │ ├── graph.cljs
│ │ ├── gutter.cljs
│ │ ├── hinter.cljs
│ │ ├── inline-doc.cljs
│ │ ├── linter.cljs
│ │ ├── make.cljs
│ │ ├── module_graph.cljs
│ │ ├── modulebrowser.cljs
│ │ ├── packages.cljs
│ │ ├── repl.cljs
│ │ ├── selection.cljs
│ │ ├── test.cljs
│ │ ├── usages.cljs
│ │ ├── utils.cljs
│ │ └── widgets/
│ │ └── selector.cljs
│ └── elm_light.cljs
└── templates/
└── test/
├── Main.elm
└── Tests.elm
SYMBOL INDEX (928 symbols across 10 files)
FILE: DocPreview/docPreview.js
function get (line 39) | function get(i, array)
function unsafeGet (line 51) | function unsafeGet(i, array)
function set (line 72) | function set(i, item, array)
function unsafeSet (line 82) | function unsafeSet(i, item, array)
function initialize (line 103) | function initialize(len, f)
function initialize_ (line 113) | function initialize_(f, h, from, to)
function fromList (line 145) | function fromList(list)
function fromListPush (line 210) | function fromListPush(toPush, nodes)
function push (line 247) | function push(item, a)
function push_ (line 262) | function push_(item, a)
function toList (line 314) | function toList(a)
function toList_ (line 319) | function toList_(list, a)
function map (line 332) | function map(f, a)
function indexedMap (line 354) | function indexedMap(f, a)
function indexedMap_ (line 359) | function indexedMap_(f, a, from)
function foldl (line 380) | function foldl(f, b, a)
function foldr (line 399) | function foldr(f, b, a)
function slice (line 420) | function slice(from, to, a)
function sliceRight (line 433) | function sliceRight(to, a)
function sliceLeft (line 473) | function sliceLeft(from, a)
function append (line 517) | function append(a,b)
function append_ (line 570) | function append_(a, b)
function insertRight (line 623) | function insertRight(parent, node)
function insertLeft (line 631) | function insertLeft(parent, node)
function calcToRemove (line 657) | function calcToRemove(a, b)
function get2 (line 674) | function get2(a, b, index)
function set2 (line 681) | function set2(a, b, index, value)
function saveSlot (line 693) | function saveSlot(a, b, index, slot)
function createNode (line 706) | function createNode(h, length)
function shuffle (line 725) | function shuffle(a, b, toRemove)
function botRight (line 803) | function botRight(a)
function botLeft (line 807) | function botLeft(a)
function nodeCopy (line 814) | function nodeCopy(a)
function length (line 829) | function length(array)
function getSlot (line 843) | function getSlot(i, a)
function create (line 855) | function create(item, h)
function parentise (line 874) | function parentise(tree, h)
function siblise (line 890) | function siblise(a, b)
function toJSArray (line 900) | function toJSArray(a)
function toJSArray_ (line 907) | function toJSArray_(jsArray, i, a)
function fromJSArray (line 923) | function fromJSArray(jsArray)
function fromJSArray_ (line 933) | function fromJSArray_(jsArray, h, from, to)
function div (line 994) | function div(a, b)
function rem (line 998) | function rem(a, b)
function mod (line 1002) | function mod(a, b)
function logBase (line 1013) | function logBase(base, n)
function negate (line 1017) | function negate(n)
function abs (line 1021) | function abs(n)
function min (line 1026) | function min(a, b)
function max (line 1030) | function max(a, b)
function clamp (line 1034) | function clamp(lo, hi, n)
function xor (line 1039) | function xor(a, b)
function not (line 1043) | function not(b)
function isInfinite (line 1047) | function isInfinite(n)
function truncate (line 1052) | function truncate(n)
function degrees (line 1057) | function degrees(d)
function turns (line 1061) | function turns(t)
function fromPolar (line 1065) | function fromPolar(point)
function toPolar (line 1071) | function toPolar(point)
function inbound (line 1134) | function inbound(name, type, converter)
function inboundSignal (line 1153) | function inboundSignal(name, type, converter)
function jsToElm (line 1177) | function jsToElm(name, type, converter, value)
function outbound (line 1200) | function outbound(name, converter, elmValue)
function outboundSignal (line 1206) | function outboundSignal(name, converter, signal)
function init (line 1284) | function init(display, container, module, args, moduleToReplace)
function checkInputs (line 1429) | function checkInputs(elm)
function errorNode (line 1446) | function errorNode(message)
function filterListeners (line 1470) | function filterListeners(inputs, listeners)
function removeListeners (line 1487) | function removeListeners(listeners)
function addReceivers (line 1497) | function addReceivers(ports)
function trimDeadNodes (line 1523) | function trimDeadNodes(node)
function initGraphics (line 1547) | function initGraphics(elm, Module)
function hotSwap (line 1696) | function hotSwap(from, to)
function depthFirstTraversals (line 1726) | function depthFirstTraversals(f, queueOld, queueNew)
function F2 (line 1755) | function F2(fun)
function F3 (line 1763) | function F3(fun)
function F4 (line 1773) | function F4(fun)
function F5 (line 1783) | function F5(fun)
function F6 (line 1793) | function F6(fun)
function F7 (line 1804) | function F7(fun)
function F8 (line 1815) | function F8(fun)
function F9 (line 1827) | function F9(fun)
function A2 (line 1839) | function A2(fun, a, b)
function A3 (line 1845) | function A3(fun, a, b, c)
function A4 (line 1851) | function A4(fun, a, b, c, d)
function A5 (line 1857) | function A5(fun, a, b, c, d, e)
function A6 (line 1863) | function A6(fun, a, b, c, d, e, f)
function A7 (line 1869) | function A7(fun, a, b, c, d, e, f, g)
function A8 (line 1875) | function A8(fun, a, b, c, d, e, f, g, h)
function A9 (line 1881) | function A9(fun, a, b, c, d, e, f, g, h, i)
function eq (line 1902) | function eq(l, r)
function compare (line 1958) | function compare(x, y)
function cmp (line 1965) | function cmp(x, y) {
function Tuple2 (line 2031) | function Tuple2(x, y)
function chr (line 2043) | function chr(c)
function txt (line 2050) | function txt(str)
function guid (line 2061) | function guid(_)
function update (line 2069) | function update(oldRecord, updatedFields)
function getXY (line 2083) | function getXY(e)
function Cons (line 2115) | function Cons(hd, tl)
function list (line 2124) | function list(arr)
function range (line 2134) | function range(lo, hi)
function append (line 2148) | function append(xs, ys)
function crash (line 2188) | function crash(moduleName, region)
function crashCase (line 2199) | function crashCase(moduleName, region, value)
function regionToString (line 2212) | function regionToString(region)
function badPort (line 2224) | function badPort(expected, received)
function formatValue (line 2232) | function formatValue(value)
function addSlashes (line 2375) | function addSlashes(str, isChar)
function toArray (line 2637) | function toArray(xs)
function foldl (line 2650) | function foldl(f, b, xs)
function foldr (line 2661) | function foldr(f, b, xs)
function map2 (line 2672) | function map2(f, xs, ys)
function map3 (line 2684) | function map3(f, xs, ys, zs)
function map4 (line 2697) | function map4(f, ws, xs, ys, zs)
function map5 (line 2714) | function map5(f, vs, ws, xs, ys, zs)
function sortBy (line 2733) | function sortBy(f, xs)
function sortWith (line 2740) | function sortWith(f, xs)
function take (line 2748) | function take(n, xs)
function toCss (line 3080) | function toCss(c)
function broadcastToKids (line 3289) | function broadcastToKids(node, timestamp, update)
function input (line 3301) | function input(name, base)
function constant (line 3326) | function constant(value)
function mailbox (line 3334) | function mailbox(base)
function sendMessage (line 3356) | function sendMessage(message)
function output (line 3364) | function output(name, handler, parent)
function mapMany (line 3389) | function mapMany(refreshValue, args)
function map (line 3430) | function map(func, a)
function map2 (line 3440) | function map2(func, a, b)
function map3 (line 3450) | function map3(func, a, b, c)
function map4 (line 3460) | function map4(func, a, b, c, d)
function map5 (line 3470) | function map5(func, a, b, c, d, e)
function foldp (line 3482) | function foldp(update, state, signal)
function timestamp (line 3509) | function timestamp(signal)
function delay (line 3534) | function delay(time, signal)
function genericMerge (line 3553) | function genericMerge(tieBreaker, leftStream, rightStream)
function filterMap (line 3615) | function filterMap(toMaybe, base, signal)
function sampleOn (line 3649) | function sampleOn(ticker, signal)
function dropRepeats (line 3697) | function dropRepeats(signal)
function fpsWhen (line 3762) | function fpsWhen(desiredFPS, isOn)
function every (line 3822) | function every(t)
function fst (line 3835) | function fst(pair)
function read (line 3841) | function read(s)
function matrix (line 3892) | function matrix(m11, m12, m21, m22, dx, dy)
function rotation (line 3897) | function rotation(t)
function rotate (line 3904) | function rotate(t, m)
function multiply (line 3936) | function multiply(m, n)
function setStrokeStyle (line 4018) | function setStrokeStyle(ctx, style)
function setFillStyle (line 4040) | function setFillStyle(redo, ctx, style)
function trace (line 4050) | function trace(ctx, path)
function line (line 4070) | function line(ctx, style, path)
function customLineHelp (line 4084) | function customLineHelp(ctx, style, path)
function drawLine (line 4133) | function drawLine(ctx, style, path)
function texture (line 4139) | function texture(redo, ctx, src)
function gradient (line 4147) | function gradient(ctx, grad)
function drawShape (line 4172) | function drawShape(redo, ctx, style, path)
function fillText (line 4183) | function fillText(redo, ctx, text)
function strokeText (line 4188) | function strokeText(redo, ctx, style, text)
function drawText (line 4201) | function drawText(ctx, text, canvasDrawFn)
function toFont (line 4235) | function toFont(props)
function chunkText (line 4249) | function chunkText(context, text)
function freshContext (line 4274) | function freshContext(props, ctx)
function drawImage (line 4298) | function drawImage(redo, ctx, form)
function renderForm (line 4319) | function renderForm(redo, ctx, form)
function formToMatrix (line 4380) | function formToMatrix(form)
function str (line 4394) | function str(n)
function makeTransform (line 4403) | function makeTransform(w, h, form, matrices)
function stepperHelp (line 4422) | function stepperHelp(list)
function formStepper (line 4443) | function formStepper(forms)
function makeCanvas (line 4503) | function makeCanvas(w, h)
function render (line 4516) | function render(model)
function nodeStepper (line 4525) | function nodeStepper(w, h, div)
function update (line 4604) | function update(div, _, model)
function collage (line 4641) | function collage(w, h, forms)
function newElement (line 4706) | function newElement(width, height, elementPrim)
function setProps (line 4730) | function setProps(elem, node)
function addClick (line 4778) | function addClick(e, handler)
function removeClick (line 4791) | function removeClick(e, handler)
function addHover (line 4801) | function addHover(e, handler)
function removeHover (line 4826) | function removeHover(e)
function image (line 4844) | function image(props, img)
function plainImage (line 4862) | function plainImage(src)
function tiledImage (line 4871) | function tiledImage(src)
function fittedImage (line 4878) | function fittedImage(w, h, src)
function croppedImage (line 4889) | function croppedImage(elem, w, h, src)
function goOut (line 4912) | function goOut(node)
function goDown (line 4917) | function goDown(node)
function goRight (line 4921) | function goRight(node)
function needsReversal (line 4936) | function needsReversal(dir)
function flow (line 4941) | function flow(dir, elist)
function toPos (line 4965) | function toPos(pos)
function setPos (line 4974) | function setPos(pos, wrappedElement, e)
function addTransform (line 5023) | function addTransform(style, transform)
function container (line 5032) | function container(pos, elem)
function rawHtml (line 5044) | function rawHtml(elem)
function render (line 5064) | function render(wrappedElement)
function makeElement (line 5070) | function makeElement(e)
function updateAndReplace (line 5095) | function updateAndReplace(node, curr, next)
function update (line 5108) | function update(node, wrappedCurrent, wrappedNext)
function updateProps (line 5206) | function updateProps(node, curr, next)
function block (line 5324) | function block(align)
function markdown (line 5338) | function markdown(text)
function realHtmlHeight (line 5354) | function realHtmlHeight(width, rawHtml)
function fromString (line 5409) | function fromString(str)
function append (line 5417) | function append(a, b)
function addMeta (line 5426) | function addMeta(field, value, text)
function toTypefaces (line 5466) | function toTypefaces(list)
function toLine (line 5480) | function toLine(line)
function style (line 5492) | function style(style, text)
function height (line 5520) | function height(px, text)
function typeface (line 5525) | function typeface(names, text)
function monospace (line 5530) | function monospace(text)
function italic (line 5535) | function italic(text)
function bold (line 5540) | function bold(text)
function link (line 5545) | function link(href, text)
function line (line 5550) | function line(line, text)
function color (line 5555) | function color(color, text)
function renderHtml (line 5563) | function renderHtml(text)
function renderMeta (line 5580) | function renderMeta(metas, string)
function properEscape (line 5603) | function properEscape(str)
function makeSpaces (line 5622) | function makeSpaces(s)
function log (line 6075) | function log(tag, value)
function crash (line 6090) | function crash(message)
function tracePath (line 6095) | function tracePath(tag, form)
function watch (line 6104) | function watch(tag, value)
function watchSummary (line 6113) | function watchSummary(tag, summarize, value)
function succeed (line 6162) | function succeed(value)
function fail (line 6170) | function fail(error)
function asyncFunction (line 6178) | function asyncFunction(func)
function andThen (line 6186) | function andThen(task, callback)
function catch_ (line 6195) | function catch_(task, callback)
function perform (line 6207) | function perform(task) {
function performSignal (line 6211) | function performSignal(name, signal)
function mark (line 6250) | function mark(status, task)
function runTask (line 6255) | function runTask(root, onComplete)
function stepTask (line 6275) | function stepTask(onComplete, root, task)
function sleep (line 6340) | function sleep(time) {
function spawn (line 6348) | function spawn(task) {
function isEmpty (line 6697) | function isEmpty(str)
function cons (line 6701) | function cons(chr, str)
function uncons (line 6705) | function uncons(str)
function append (line 6714) | function append(a, b)
function concat (line 6718) | function concat(strs)
function length (line 6722) | function length(str)
function map (line 6726) | function map(f, str)
function filter (line 6735) | function filter(pred, str)
function reverse (line 6739) | function reverse(str)
function foldl (line 6743) | function foldl(f, b, str)
function foldr (line 6752) | function foldr(f, b, str)
function split (line 6760) | function split(sep, str)
function join (line 6764) | function join(sep, strs)
function repeat (line 6768) | function repeat(n, str)
function slice (line 6781) | function slice(start, end, str)
function left (line 6785) | function left(n, str)
function right (line 6789) | function right(n, str)
function dropLeft (line 6793) | function dropLeft(n, str)
function dropRight (line 6797) | function dropRight(n, str)
function pad (line 6801) | function pad(n, chr, str)
function padRight (line 6806) | function padRight(n, chr, str)
function padLeft (line 6810) | function padLeft(n, chr, str)
function trim (line 6815) | function trim(str)
function trimLeft (line 6819) | function trimLeft(str)
function trimRight (line 6823) | function trimRight(str)
function words (line 6828) | function words(str)
function lines (line 6832) | function lines(str)
function toUpper (line 6837) | function toUpper(str)
function toLower (line 6841) | function toLower(str)
function any (line 6846) | function any(pred, str)
function all (line 6857) | function all(pred, str)
function contains (line 6869) | function contains(sub, str)
function startsWith (line 6873) | function startsWith(sub, str)
function endsWith (line 6877) | function endsWith(sub, str)
function indexes (line 6882) | function indexes(sub, str)
function toInt (line 6895) | function toInt(s)
function toFloat (line 6921) | function toFloat(s)
function toList (line 6957) | function toList(str)
function fromList (line 6961) | function fromList(chars)
function crash (line 7686) | function crash(expected, actual) {
function decodeNull (line 7695) | function decodeNull(successValue) {
function decodeString (line 7705) | function decodeString(value) {
function decodeFloat (line 7713) | function decodeFloat(value) {
function decodeInt (line 7721) | function decodeInt(value) {
function decodeBool (line 7738) | function decodeBool(value) {
function decodeArray (line 7748) | function decodeArray(decoder) {
function decodeList (line 7765) | function decodeList(decoder) {
function decodeMaybe (line 7782) | function decodeMaybe(decoder) {
function decodeField (line 7795) | function decodeField(field, decoder) {
function decodeKeyValuePairs (line 7808) | function decodeKeyValuePairs(decoder) {
function decodeObject1 (line 7830) | function decodeObject1(f, d1) {
function decodeObject2 (line 7836) | function decodeObject2(f, d1, d2) {
function decodeObject3 (line 7842) | function decodeObject3(f, d1, d2, d3) {
function decodeObject4 (line 7848) | function decodeObject4(f, d1, d2, d3, d4) {
function decodeObject5 (line 7854) | function decodeObject5(f, d1, d2, d3, d4, d5) {
function decodeObject6 (line 7860) | function decodeObject6(f, d1, d2, d3, d4, d5, d6) {
function decodeObject7 (line 7873) | function decodeObject7(f, d1, d2, d3, d4, d5, d6, d7) {
function decodeObject8 (line 7887) | function decodeObject8(f, d1, d2, d3, d4, d5, d6, d7, d8) {
function decodeTuple1 (line 7905) | function decodeTuple1(f, d1) {
function decodeTuple2 (line 7914) | function decodeTuple2(f, d1, d2) {
function decodeTuple3 (line 7923) | function decodeTuple3(f, d1, d2, d3) {
function decodeTuple4 (line 7933) | function decodeTuple4(f, d1, d2, d3, d4) {
function decodeTuple5 (line 7943) | function decodeTuple5(f, d1, d2, d3, d4, d5) {
function decodeTuple6 (line 7959) | function decodeTuple6(f, d1, d2, d3, d4, d5, d6) {
function decodeTuple7 (line 7975) | function decodeTuple7(f, d1, d2, d3, d4, d5, d6, d7) {
function decodeTuple8 (line 7993) | function decodeTuple8(f, d1, d2, d3, d4, d5, d6, d7, d8) {
function decodeValue (line 8014) | function decodeValue(value) {
function runDecoderValue (line 8018) | function runDecoderValue(decoder, value) {
function customDecoder (line 8026) | function customDecoder(decoder, callback) {
function andThen (line 8036) | function andThen(decode, callback) {
function fail (line 8043) | function fail(msg) {
function succeed (line 8049) | function succeed(successValue) {
function oneOf (line 8058) | function oneOf(decoders) {
function get (line 8074) | function get(decoder, value) {
function runDecoderString (line 8085) | function runDecoderString(decoder, string) {
function encode (line 8093) | function encode(indentLevel, value) {
function identity (line 8097) | function identity(value) {
function encodeObject (line 8101) | function encodeObject(keyValuePairs) {
function escape (line 8354) | function escape(str)
function caseInsensitive (line 8358) | function caseInsensitive(re)
function regex (line 8362) | function regex(raw)
function contains (line 8367) | function contains(re, string)
function find (line 8372) | function find(n, re, str)
function replace (line 8405) | function replace(n, re, replacer, string)
function split (line 8434) | function split(n, re, str)
function s (line 8497) | function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&re...
function isArray (line 8531) | function isArray(obj) {
function applyProperties (line 8541) | function applyProperties(node, props, previous) {
function removeProperty (line 8564) | function removeProperty(node, propName, propValue, previous) {
function patchObject (line 8588) | function patchObject(node, props, previous, propName, propValue) {
function getPrototype (line 8624) | function getPrototype(value) {
function createElement (line 8646) | function createElement(vnode, opts) {
function domIndex (line 8693) | function domIndex(rootNode, tree, indices, nodes) {
function recurse (line 8702) | function recurse(rootNode, tree, indices, nodes, rootIndex) {
function indexInRange (line 8737) | function indexInRange(indices, left, right) {
function ascending (line 8765) | function ascending(a, b) {
function applyPatch (line 8780) | function applyPatch(vpatch, domNode, renderOptions) {
function removeNode (line 8810) | function removeNode(domNode, vNode) {
function insertNode (line 8822) | function insertNode(parentNode, vNode, renderOptions) {
function stringPatch (line 8832) | function stringPatch(domNode, leftVNode, vText, renderOptions) {
function widgetPatch (line 8850) | function widgetPatch(domNode, leftVNode, widget, renderOptions) {
function vNodePatch (line 8873) | function vNodePatch(domNode, leftVNode, vNode, renderOptions) {
function destroyWidget (line 8884) | function destroyWidget(domNode, w) {
function reorderChildren (line 8890) | function reorderChildren(domNode, moves) {
function replaceRoot (line 8915) | function replaceRoot(oldRoot, newRoot) {
function patch (line 8931) | function patch(rootNode, patches) {
function patchRecursive (line 8935) | function patchRecursive(rootNode, patches, renderOptions) {
function applyPatch (line 8963) | function applyPatch(rootNode, domNode, patchList, renderOptions) {
function patchIndices (line 8989) | function patchIndices(patches) {
function updateWidget (line 9006) | function updateWidget(a, b) {
function handleThunk (line 9026) | function handleThunk(a, b) {
function renderThunk (line 9044) | function renderThunk(thunk, previous) {
function isThunk (line 9063) | function isThunk(t) {
function isHook (line 9070) | function isHook(hook) {
function isVirtualNode (line 9081) | function isVirtualNode(x) {
function isVirtualText (line 9090) | function isVirtualText(x) {
function isWidget (line 9097) | function isWidget(w) {
function VirtualNode (line 9116) | function VirtualNode(tagName, properties, children, key, namespace) {
function VirtualPatch (line 9193) | function VirtualPatch(type, vNode, patch) {
function VirtualText (line 9207) | function VirtualText(text) {
function diffProps (line 9220) | function diffProps(a, b) {
function getPrototype (line 9264) | function getPrototype(value) {
function diff (line 9288) | function diff(a, b) {
function walk (line 9294) | function walk(a, b, patch, index) {
function diffChildren (line 9358) | function diffChildren(a, b, patch, apply, index) {
function clearState (line 9399) | function clearState(vNode, patch, index) {
function destroyWidgets (line 9407) | function destroyWidgets(vNode, patch, index) {
function thunks (line 9434) | function thunks(a, b, patch, index) {
function hasPatches (line 9442) | function hasPatches(patch) {
function unhook (line 9453) | function unhook(vNode, patch, index) {
function undefinedKeys (line 9485) | function undefinedKeys(obj) {
function reorder (line 9496) | function reorder(aChildren, bChildren) {
function remove (line 9659) | function remove(arr, index, key) {
function keyIndex (line 9668) | function keyIndex(children) {
function appendPatch (line 9689) | function appendPatch(apply, patch) {
function text (line 9735) | function text(string)
function node (line 9740) | function node(name)
function makeNode (line 9751) | function makeNode(name, propertyList, contents)
function listToProperties (line 9784) | function listToProperties(list)
function property (line 9809) | function property(key, value)
function attribute (line 9817) | function attribute(key, value)
function attributeNS (line 9833) | function attributeNS(namespace, key, value)
function AttributeHook (line 9841) | function AttributeHook(namespace, key, value)
function on (line 9885) | function on(name, options, decoder, createMessage)
function SoftSetHook (line 9906) | function SoftSetHook(value)
function ElementWidget (line 9929) | function ElementWidget(element)
function fromElement (line 9946) | function fromElement(element)
function toElement (line 9951) | function toElement(width, height, html)
function render (line 9967) | function render(model)
function update (line 9974) | function update(node, oldModel, newModel)
function updateAndReplace (line 9980) | function updateAndReplace(node, oldModel, newModel)
function lazyRef (line 9992) | function lazyRef(fn, a)
function lazyRef2 (line 10001) | function lazyRef2(fn, a, b)
function lazyRef3 (line 10010) | function lazyRef3(fn, a, b, c)
function Thunk (line 10019) | function Thunk(fn, args, thunk)
function shouldUpdate (line 10034) | function shouldUpdate(current, previous)
function renderThunk (line 10056) | function renderThunk(previous)
function batchedSending (line 10626) | function batchedSending(address, tickMessages)
function sendCallback (line 10663) | function sendCallback(time)
function send (line 10698) | function send(time)
function requestTickSending (line 10714) | function requestTickSending(address, tickMessages)
function Lexer (line 11034) | function Lexer(options){this.tokens=[];this.tokens.links={};this.options...
function InlineLexer (line 11034) | function InlineLexer(links,options){this.options=options||marked.default...
function Renderer (line 11034) | function Renderer(options){this.options=options||{}}
function Parser (line 11034) | function Parser(options){this.tokens=[];this.token=null;this.options=opt...
function escape (line 11034) | function escape(html,encode){return html.replace(!encode?/&(?!#?\w+;)/g:...
function unescape (line 11034) | function unescape(html){return html.replace(/&([#\w]+);/g,function(_,n){...
function replace (line 11034) | function replace(regex,opt){regex=regex.source;opt=opt||"";return functi...
function noop (line 11034) | function noop(){}
function merge (line 11034) | function merge(obj){var i=1,target,key;for(;i<arguments.length;i++){targ...
function marked (line 11034) | function marked(src,opt,callback){if(callback||typeof opt==="function"){...
function formatOptions (line 11039) | function formatOptions(options) {
function toHtmlWith (line 11078) | function toHtmlWith(options, rawMarkdown)
function MarkdownWidget (line 11083) | function MarkdownWidget(options, rawMarkdown)
function toElementWith (line 11110) | function toElementWith(options, rawMarkdown)
function ok (line 11427) | function ok(index, value) {
function err (line 11431) | function err(msg) {
function succeed (line 11438) | function succeed(value)
function fail (line 11445) | function fail(msg)
function satisfy (line 11455) | function satisfy(isOk)
function string (line 11469) | function string(expected)
function oneOf (line 11483) | function oneOf(parserList)
function andThen (line 11504) | function andThen(parser, callback)
function run (line 11523) | function run(parser, input)
FILE: DocPreview/highlight.pack.js
function n (line 2) | function n(e){return e.replace(/&/gm,"&").replace(/</gm,"<").repl...
function t (line 2) | function t(e){return e.nodeName.toLowerCase()}
function r (line 2) | function r(e,n){var t=e&&e.exec(n);return t&&0==t.index}
function a (line 2) | function a(e){return/^(no-?highlight|plain|text)$/i.test(e)}
function i (line 2) | function i(e){var n,t,r,i=e.className+" ";if(i+=e.parentNode?e.parentNod...
function o (line 2) | function o(e,n){var t,r={};for(t in e)r[t]=e[t];if(n)for(t in n)r[t]=n[t...
function u (line 2) | function u(e){var n=[];return function r(e,a){for(var i=e.firstChild;i;i...
function c (line 2) | function c(e,r,a){function i(){return e.length&&r.length?e[0].offset!=r[...
function s (line 2) | function s(e){function n(e){return e&&e.source||e}function t(t,r){return...
function f (line 2) | function f(e,t,a,i){function o(e,n){for(var t=0;t<n.c.length;t++)if(r(n....
function l (line 2) | function l(e,t){t=t||E.languages||Object.keys(R);var r={r:0,value:n(e)},...
function g (line 2) | function g(e){return E.tabReplace&&(e=e.replace(/^((<[^>]+>|\t)+)/gm,fun...
function p (line 2) | function p(e,n,t){var r=n?x[n]:t,a=[e.trim()];return e.match(/\bhljs\b/)...
function h (line 2) | function h(e){var n=i(e);if(!a(n)){var t;E.useBR?(t=document.createEleme...
function d (line 2) | function d(e){E=o(E,e)}
function b (line 2) | function b(){if(!b.called){b.called=!0;var e=document.querySelectorAll("...
function v (line 2) | function v(){addEventListener("DOMContentLoaded",b,!1),addEventListener(...
function m (line 2) | function m(n,t){var r=R[n]=t(e);r.aliases&&r.aliases.forEach(function(e)...
function N (line 2) | function N(){return Object.keys(R)}
function w (line 2) | function w(e){return e=(e||"").toLowerCase(),R[e]||R[x[e]]}
FILE: DocPreview/src/Native/Parse.js
function ok (line 18) | function ok(index, value) {
function err (line 22) | function err(msg) {
function succeed (line 29) | function succeed(value)
function fail (line 36) | function fail(msg)
function satisfy (line 46) | function satisfy(isOk)
function string (line 60) | function string(expected)
function oneOf (line 74) | function oneOf(parserList)
function andThen (line 95) | function andThen(parser, callback)
function run (line 114) | function run(parser, input)
FILE: elm/ModuleBrowser/moduleBrowser.js
function div (line 13) | function div(a, b)
function rem (line 17) | function rem(a, b)
function mod (line 21) | function mod(a, b)
function logBase (line 32) | function logBase(base, n)
function negate (line 36) | function negate(n)
function abs (line 40) | function abs(n)
function min (line 45) | function min(a, b)
function max (line 49) | function max(a, b)
function clamp (line 53) | function clamp(lo, hi, n)
function xor (line 58) | function xor(a, b)
function not (line 62) | function not(b)
function isInfinite (line 66) | function isInfinite(n)
function truncate (line 71) | function truncate(n)
function degrees (line 76) | function degrees(d)
function turns (line 80) | function turns(t)
function fromPolar (line 84) | function fromPolar(point)
function toPolar (line 90) | function toPolar(point)
function inbound (line 153) | function inbound(name, type, converter)
function inboundSignal (line 172) | function inboundSignal(name, type, converter)
function jsToElm (line 196) | function jsToElm(name, type, converter, value)
function outbound (line 219) | function outbound(name, converter, elmValue)
function outboundSignal (line 225) | function outboundSignal(name, converter, signal)
function init (line 303) | function init(display, container, module, args, moduleToReplace)
function checkInputs (line 448) | function checkInputs(elm)
function errorNode (line 465) | function errorNode(message)
function filterListeners (line 489) | function filterListeners(inputs, listeners)
function removeListeners (line 506) | function removeListeners(listeners)
function addReceivers (line 516) | function addReceivers(ports)
function trimDeadNodes (line 542) | function trimDeadNodes(node)
function initGraphics (line 566) | function initGraphics(elm, Module)
function hotSwap (line 715) | function hotSwap(from, to)
function depthFirstTraversals (line 745) | function depthFirstTraversals(f, queueOld, queueNew)
function F2 (line 774) | function F2(fun)
function F3 (line 782) | function F3(fun)
function F4 (line 792) | function F4(fun)
function F5 (line 802) | function F5(fun)
function F6 (line 812) | function F6(fun)
function F7 (line 823) | function F7(fun)
function F8 (line 834) | function F8(fun)
function F9 (line 846) | function F9(fun)
function A2 (line 858) | function A2(fun, a, b)
function A3 (line 864) | function A3(fun, a, b, c)
function A4 (line 870) | function A4(fun, a, b, c, d)
function A5 (line 876) | function A5(fun, a, b, c, d, e)
function A6 (line 882) | function A6(fun, a, b, c, d, e, f)
function A7 (line 888) | function A7(fun, a, b, c, d, e, f, g)
function A8 (line 894) | function A8(fun, a, b, c, d, e, f, g, h)
function A9 (line 900) | function A9(fun, a, b, c, d, e, f, g, h, i)
function eq (line 921) | function eq(l, r)
function compare (line 977) | function compare(x, y)
function cmp (line 984) | function cmp(x, y) {
function Tuple2 (line 1050) | function Tuple2(x, y)
function chr (line 1062) | function chr(c)
function txt (line 1069) | function txt(str)
function guid (line 1080) | function guid(_)
function update (line 1088) | function update(oldRecord, updatedFields)
function getXY (line 1102) | function getXY(e)
function Cons (line 1134) | function Cons(hd, tl)
function list (line 1143) | function list(arr)
function range (line 1153) | function range(lo, hi)
function append (line 1167) | function append(xs, ys)
function crash (line 1207) | function crash(moduleName, region)
function crashCase (line 1218) | function crashCase(moduleName, region, value)
function regionToString (line 1231) | function regionToString(region)
function badPort (line 1243) | function badPort(expected, received)
function formatValue (line 1251) | function formatValue(value)
function addSlashes (line 1394) | function addSlashes(str, isChar)
function toArray (line 1656) | function toArray(xs)
function foldl (line 1669) | function foldl(f, b, xs)
function foldr (line 1680) | function foldr(f, b, xs)
function map2 (line 1691) | function map2(f, xs, ys)
function map3 (line 1703) | function map3(f, xs, ys, zs)
function map4 (line 1716) | function map4(f, ws, xs, ys, zs)
function map5 (line 1733) | function map5(f, vs, ws, xs, ys, zs)
function sortBy (line 1752) | function sortBy(f, xs)
function sortWith (line 1759) | function sortWith(f, xs)
function take (line 1767) | function take(n, xs)
function matrix (line 2012) | function matrix(m11, m12, m21, m22, dx, dy)
function rotation (line 2017) | function rotation(t)
function rotate (line 2024) | function rotate(t, m)
function multiply (line 2056) | function multiply(m, n)
function setStrokeStyle (line 2138) | function setStrokeStyle(ctx, style)
function setFillStyle (line 2160) | function setFillStyle(redo, ctx, style)
function trace (line 2170) | function trace(ctx, path)
function line (line 2190) | function line(ctx, style, path)
function customLineHelp (line 2204) | function customLineHelp(ctx, style, path)
function drawLine (line 2253) | function drawLine(ctx, style, path)
function texture (line 2259) | function texture(redo, ctx, src)
function gradient (line 2267) | function gradient(ctx, grad)
function drawShape (line 2292) | function drawShape(redo, ctx, style, path)
function fillText (line 2303) | function fillText(redo, ctx, text)
function strokeText (line 2308) | function strokeText(redo, ctx, style, text)
function drawText (line 2321) | function drawText(ctx, text, canvasDrawFn)
function toFont (line 2355) | function toFont(props)
function chunkText (line 2369) | function chunkText(context, text)
function freshContext (line 2394) | function freshContext(props, ctx)
function drawImage (line 2418) | function drawImage(redo, ctx, form)
function renderForm (line 2439) | function renderForm(redo, ctx, form)
function formToMatrix (line 2500) | function formToMatrix(form)
function str (line 2514) | function str(n)
function makeTransform (line 2523) | function makeTransform(w, h, form, matrices)
function stepperHelp (line 2542) | function stepperHelp(list)
function formStepper (line 2563) | function formStepper(forms)
function makeCanvas (line 2623) | function makeCanvas(w, h)
function render (line 2636) | function render(model)
function nodeStepper (line 2645) | function nodeStepper(w, h, div)
function update (line 2724) | function update(div, _, model)
function collage (line 2761) | function collage(w, h, forms)
function toCss (line 2786) | function toCss(c)
function newElement (line 3029) | function newElement(width, height, elementPrim)
function setProps (line 3053) | function setProps(elem, node)
function addClick (line 3101) | function addClick(e, handler)
function removeClick (line 3114) | function removeClick(e, handler)
function addHover (line 3124) | function addHover(e, handler)
function removeHover (line 3149) | function removeHover(e)
function image (line 3167) | function image(props, img)
function plainImage (line 3185) | function plainImage(src)
function tiledImage (line 3194) | function tiledImage(src)
function fittedImage (line 3201) | function fittedImage(w, h, src)
function croppedImage (line 3212) | function croppedImage(elem, w, h, src)
function goOut (line 3235) | function goOut(node)
function goDown (line 3240) | function goDown(node)
function goRight (line 3244) | function goRight(node)
function needsReversal (line 3259) | function needsReversal(dir)
function flow (line 3264) | function flow(dir, elist)
function toPos (line 3288) | function toPos(pos)
function setPos (line 3297) | function setPos(pos, wrappedElement, e)
function addTransform (line 3346) | function addTransform(style, transform)
function container (line 3355) | function container(pos, elem)
function rawHtml (line 3367) | function rawHtml(elem)
function render (line 3387) | function render(wrappedElement)
function makeElement (line 3393) | function makeElement(e)
function updateAndReplace (line 3418) | function updateAndReplace(node, curr, next)
function update (line 3431) | function update(node, wrappedCurrent, wrappedNext)
function updateProps (line 3529) | function updateProps(node, curr, next)
function block (line 3647) | function block(align)
function markdown (line 3661) | function markdown(text)
function realHtmlHeight (line 3677) | function realHtmlHeight(width, rawHtml)
function fromString (line 3732) | function fromString(str)
function append (line 3740) | function append(a, b)
function addMeta (line 3749) | function addMeta(field, value, text)
function toTypefaces (line 3789) | function toTypefaces(list)
function toLine (line 3803) | function toLine(line)
function style (line 3815) | function style(style, text)
function height (line 3843) | function height(px, text)
function typeface (line 3848) | function typeface(names, text)
function monospace (line 3853) | function monospace(text)
function italic (line 3858) | function italic(text)
function bold (line 3863) | function bold(text)
function link (line 3868) | function link(href, text)
function line (line 3873) | function line(line, text)
function color (line 3878) | function color(color, text)
function renderHtml (line 3886) | function renderHtml(text)
function renderMeta (line 3903) | function renderMeta(metas, string)
function properEscape (line 3926) | function properEscape(str)
function makeSpaces (line 3945) | function makeSpaces(s)
function log (line 4398) | function log(tag, value)
function crash (line 4413) | function crash(message)
function tracePath (line 4418) | function tracePath(tag, form)
function watch (line 4427) | function watch(tag, value)
function watchSummary (line 4436) | function watchSummary(tag, summarize, value)
function broadcastToKids (line 4584) | function broadcastToKids(node, timestamp, update)
function input (line 4596) | function input(name, base)
function constant (line 4621) | function constant(value)
function mailbox (line 4629) | function mailbox(base)
function sendMessage (line 4651) | function sendMessage(message)
function output (line 4659) | function output(name, handler, parent)
function mapMany (line 4684) | function mapMany(refreshValue, args)
function map (line 4725) | function map(func, a)
function map2 (line 4735) | function map2(func, a, b)
function map3 (line 4745) | function map3(func, a, b, c)
function map4 (line 4755) | function map4(func, a, b, c, d)
function map5 (line 4765) | function map5(func, a, b, c, d, e)
function foldp (line 4777) | function foldp(update, state, signal)
function timestamp (line 4804) | function timestamp(signal)
function delay (line 4829) | function delay(time, signal)
function genericMerge (line 4848) | function genericMerge(tieBreaker, leftStream, rightStream)
function filterMap (line 4910) | function filterMap(toMaybe, base, signal)
function sampleOn (line 4944) | function sampleOn(ticker, signal)
function dropRepeats (line 4992) | function dropRepeats(signal)
function succeed (line 5057) | function succeed(value)
function fail (line 5065) | function fail(error)
function asyncFunction (line 5073) | function asyncFunction(func)
function andThen (line 5081) | function andThen(task, callback)
function catch_ (line 5090) | function catch_(task, callback)
function perform (line 5102) | function perform(task) {
function performSignal (line 5106) | function performSignal(name, signal)
function mark (line 5145) | function mark(status, task)
function runTask (line 5150) | function runTask(root, onComplete)
function stepTask (line 5170) | function stepTask(onComplete, root, task)
function sleep (line 5235) | function sleep(time) {
function spawn (line 5243) | function spawn(task) {
function isEmpty (line 5445) | function isEmpty(str)
function cons (line 5449) | function cons(chr, str)
function uncons (line 5453) | function uncons(str)
function append (line 5462) | function append(a, b)
function concat (line 5466) | function concat(strs)
function length (line 5470) | function length(str)
function map (line 5474) | function map(f, str)
function filter (line 5483) | function filter(pred, str)
function reverse (line 5487) | function reverse(str)
function foldl (line 5491) | function foldl(f, b, str)
function foldr (line 5500) | function foldr(f, b, str)
function split (line 5508) | function split(sep, str)
function join (line 5512) | function join(sep, strs)
function repeat (line 5516) | function repeat(n, str)
function slice (line 5529) | function slice(start, end, str)
function left (line 5533) | function left(n, str)
function right (line 5537) | function right(n, str)
function dropLeft (line 5541) | function dropLeft(n, str)
function dropRight (line 5545) | function dropRight(n, str)
function pad (line 5549) | function pad(n, chr, str)
function padRight (line 5554) | function padRight(n, chr, str)
function padLeft (line 5558) | function padLeft(n, chr, str)
function trim (line 5563) | function trim(str)
function trimLeft (line 5567) | function trimLeft(str)
function trimRight (line 5571) | function trimRight(str)
function words (line 5576) | function words(str)
function lines (line 5580) | function lines(str)
function toUpper (line 5585) | function toUpper(str)
function toLower (line 5589) | function toLower(str)
function any (line 5594) | function any(pred, str)
function all (line 5605) | function all(pred, str)
function contains (line 5617) | function contains(sub, str)
function startsWith (line 5621) | function startsWith(sub, str)
function endsWith (line 5625) | function endsWith(sub, str)
function indexes (line 5630) | function indexes(sub, str)
function toInt (line 5643) | function toInt(s)
function toFloat (line 5669) | function toFloat(s)
function toList (line 5705) | function toList(str)
function fromList (line 5709) | function fromList(chars)
function get (line 7060) | function get(i, array)
function unsafeGet (line 7072) | function unsafeGet(i, array)
function set (line 7093) | function set(i, item, array)
function unsafeSet (line 7103) | function unsafeSet(i, item, array)
function initialize (line 7124) | function initialize(len, f)
function initialize_ (line 7134) | function initialize_(f, h, from, to)
function fromList (line 7166) | function fromList(list)
function fromListPush (line 7231) | function fromListPush(toPush, nodes)
function push (line 7268) | function push(item, a)
function push_ (line 7283) | function push_(item, a)
function toList (line 7335) | function toList(a)
function toList_ (line 7340) | function toList_(list, a)
function map (line 7353) | function map(f, a)
function indexedMap (line 7375) | function indexedMap(f, a)
function indexedMap_ (line 7380) | function indexedMap_(f, a, from)
function foldl (line 7401) | function foldl(f, b, a)
function foldr (line 7420) | function foldr(f, b, a)
function slice (line 7441) | function slice(from, to, a)
function sliceRight (line 7454) | function sliceRight(to, a)
function sliceLeft (line 7494) | function sliceLeft(from, a)
function append (line 7538) | function append(a,b)
function append_ (line 7591) | function append_(a, b)
function insertRight (line 7644) | function insertRight(parent, node)
function insertLeft (line 7652) | function insertLeft(parent, node)
function calcToRemove (line 7678) | function calcToRemove(a, b)
function get2 (line 7695) | function get2(a, b, index)
function set2 (line 7702) | function set2(a, b, index, value)
function saveSlot (line 7714) | function saveSlot(a, b, index, slot)
function createNode (line 7727) | function createNode(h, length)
function shuffle (line 7746) | function shuffle(a, b, toRemove)
function botRight (line 7824) | function botRight(a)
function botLeft (line 7828) | function botLeft(a)
function nodeCopy (line 7835) | function nodeCopy(a)
function length (line 7850) | function length(array)
function getSlot (line 7864) | function getSlot(i, a)
function create (line 7876) | function create(item, h)
function parentise (line 7895) | function parentise(tree, h)
function siblise (line 7911) | function siblise(a, b)
function toJSArray (line 7921) | function toJSArray(a)
function toJSArray_ (line 7928) | function toJSArray_(jsArray, i, a)
function fromJSArray (line 7944) | function fromJSArray(jsArray)
function fromJSArray_ (line 7954) | function fromJSArray_(jsArray, h, from, to)
function fpsWhen (line 8081) | function fpsWhen(desiredFPS, isOn)
function every (line 8141) | function every(t)
function fst (line 8154) | function fst(pair)
function read (line 8160) | function read(s)
function crash (line 8236) | function crash(expected, actual) {
function decodeNull (line 8245) | function decodeNull(successValue) {
function decodeString (line 8255) | function decodeString(value) {
function decodeFloat (line 8263) | function decodeFloat(value) {
function decodeInt (line 8271) | function decodeInt(value) {
function decodeBool (line 8288) | function decodeBool(value) {
function decodeArray (line 8298) | function decodeArray(decoder) {
function decodeList (line 8315) | function decodeList(decoder) {
function decodeMaybe (line 8332) | function decodeMaybe(decoder) {
function decodeField (line 8345) | function decodeField(field, decoder) {
function decodeKeyValuePairs (line 8358) | function decodeKeyValuePairs(decoder) {
function decodeObject1 (line 8380) | function decodeObject1(f, d1) {
function decodeObject2 (line 8386) | function decodeObject2(f, d1, d2) {
function decodeObject3 (line 8392) | function decodeObject3(f, d1, d2, d3) {
function decodeObject4 (line 8398) | function decodeObject4(f, d1, d2, d3, d4) {
function decodeObject5 (line 8404) | function decodeObject5(f, d1, d2, d3, d4, d5) {
function decodeObject6 (line 8410) | function decodeObject6(f, d1, d2, d3, d4, d5, d6) {
function decodeObject7 (line 8423) | function decodeObject7(f, d1, d2, d3, d4, d5, d6, d7) {
function decodeObject8 (line 8437) | function decodeObject8(f, d1, d2, d3, d4, d5, d6, d7, d8) {
function decodeTuple1 (line 8455) | function decodeTuple1(f, d1) {
function decodeTuple2 (line 8464) | function decodeTuple2(f, d1, d2) {
function decodeTuple3 (line 8473) | function decodeTuple3(f, d1, d2, d3) {
function decodeTuple4 (line 8483) | function decodeTuple4(f, d1, d2, d3, d4) {
function decodeTuple5 (line 8493) | function decodeTuple5(f, d1, d2, d3, d4, d5) {
function decodeTuple6 (line 8509) | function decodeTuple6(f, d1, d2, d3, d4, d5, d6) {
function decodeTuple7 (line 8525) | function decodeTuple7(f, d1, d2, d3, d4, d5, d6, d7) {
function decodeTuple8 (line 8543) | function decodeTuple8(f, d1, d2, d3, d4, d5, d6, d7, d8) {
function decodeValue (line 8564) | function decodeValue(value) {
function runDecoderValue (line 8568) | function runDecoderValue(decoder, value) {
function customDecoder (line 8576) | function customDecoder(decoder, callback) {
function andThen (line 8586) | function andThen(decode, callback) {
function fail (line 8593) | function fail(msg) {
function succeed (line 8599) | function succeed(successValue) {
function oneOf (line 8608) | function oneOf(decoders) {
function get (line 8624) | function get(decoder, value) {
function runDecoderString (line 8635) | function runDecoderString(decoder, string) {
function encode (line 8643) | function encode(indentLevel, value) {
function identity (line 8647) | function identity(value) {
function encodeObject (line 8651) | function encodeObject(keyValuePairs) {
function batchedSending (line 8876) | function batchedSending(address, tickMessages)
function sendCallback (line 8913) | function sendCallback(time)
function send (line 8948) | function send(time)
function requestTickSending (line 8964) | function requestTickSending(address, tickMessages)
function s (line 9035) | function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&re...
function isArray (line 9069) | function isArray(obj) {
function applyProperties (line 9079) | function applyProperties(node, props, previous) {
function removeProperty (line 9102) | function removeProperty(node, propName, propValue, previous) {
function patchObject (line 9126) | function patchObject(node, props, previous, propName, propValue) {
function getPrototype (line 9162) | function getPrototype(value) {
function createElement (line 9184) | function createElement(vnode, opts) {
function domIndex (line 9231) | function domIndex(rootNode, tree, indices, nodes) {
function recurse (line 9240) | function recurse(rootNode, tree, indices, nodes, rootIndex) {
function indexInRange (line 9275) | function indexInRange(indices, left, right) {
function ascending (line 9303) | function ascending(a, b) {
function applyPatch (line 9318) | function applyPatch(vpatch, domNode, renderOptions) {
function removeNode (line 9348) | function removeNode(domNode, vNode) {
function insertNode (line 9360) | function insertNode(parentNode, vNode, renderOptions) {
function stringPatch (line 9370) | function stringPatch(domNode, leftVNode, vText, renderOptions) {
function widgetPatch (line 9388) | function widgetPatch(domNode, leftVNode, widget, renderOptions) {
function vNodePatch (line 9411) | function vNodePatch(domNode, leftVNode, vNode, renderOptions) {
function destroyWidget (line 9422) | function destroyWidget(domNode, w) {
function reorderChildren (line 9428) | function reorderChildren(domNode, moves) {
function replaceRoot (line 9453) | function replaceRoot(oldRoot, newRoot) {
function patch (line 9469) | function patch(rootNode, patches) {
function patchRecursive (line 9473) | function patchRecursive(rootNode, patches, renderOptions) {
function applyPatch (line 9501) | function applyPatch(rootNode, domNode, patchList, renderOptions) {
function patchIndices (line 9527) | function patchIndices(patches) {
function updateWidget (line 9544) | function updateWidget(a, b) {
function handleThunk (line 9564) | function handleThunk(a, b) {
function renderThunk (line 9582) | function renderThunk(thunk, previous) {
function isThunk (line 9601) | function isThunk(t) {
function isHook (line 9608) | function isHook(hook) {
function isVirtualNode (line 9619) | function isVirtualNode(x) {
function isVirtualText (line 9628) | function isVirtualText(x) {
function isWidget (line 9635) | function isWidget(w) {
function VirtualNode (line 9654) | function VirtualNode(tagName, properties, children, key, namespace) {
function VirtualPatch (line 9731) | function VirtualPatch(type, vNode, patch) {
function VirtualText (line 9745) | function VirtualText(text) {
function diffProps (line 9758) | function diffProps(a, b) {
function getPrototype (line 9802) | function getPrototype(value) {
function diff (line 9826) | function diff(a, b) {
function walk (line 9832) | function walk(a, b, patch, index) {
function diffChildren (line 9896) | function diffChildren(a, b, patch, apply, index) {
function clearState (line 9937) | function clearState(vNode, patch, index) {
function destroyWidgets (line 9945) | function destroyWidgets(vNode, patch, index) {
function thunks (line 9972) | function thunks(a, b, patch, index) {
function hasPatches (line 9980) | function hasPatches(patch) {
function unhook (line 9991) | function unhook(vNode, patch, index) {
function undefinedKeys (line 10023) | function undefinedKeys(obj) {
function reorder (line 10034) | function reorder(aChildren, bChildren) {
function remove (line 10197) | function remove(arr, index, key) {
function keyIndex (line 10206) | function keyIndex(children) {
function appendPatch (line 10227) | function appendPatch(apply, patch) {
function text (line 10273) | function text(string)
function node (line 10278) | function node(name)
function makeNode (line 10289) | function makeNode(name, propertyList, contents)
function listToProperties (line 10322) | function listToProperties(list)
function property (line 10347) | function property(key, value)
function attribute (line 10355) | function attribute(key, value)
function attributeNS (line 10371) | function attributeNS(namespace, key, value)
function AttributeHook (line 10379) | function AttributeHook(namespace, key, value)
function on (line 10423) | function on(name, options, decoder, createMessage)
function SoftSetHook (line 10444) | function SoftSetHook(value)
function ElementWidget (line 10467) | function ElementWidget(element)
function fromElement (line 10484) | function fromElement(element)
function toElement (line 10489) | function toElement(width, height, html)
function render (line 10505) | function render(model)
function update (line 10512) | function update(node, oldModel, newModel)
function updateAndReplace (line 10518) | function updateAndReplace(node, oldModel, newModel)
function lazyRef (line 10530) | function lazyRef(fn, a)
function lazyRef2 (line 10539) | function lazyRef2(fn, a, b)
function lazyRef3 (line 10548) | function lazyRef3(fn, a, b, c)
function Thunk (line 10557) | function Thunk(fn, args, thunk)
function shouldUpdate (line 10572) | function shouldUpdate(current, previous)
function renderThunk (line 10594) | function renderThunk(previous)
FILE: js/highlight.pack.js
function n (line 1) | function n(e){return e.replace(/&/gm,"&").replace(/</gm,"<").repl...
function t (line 1) | function t(e){return e.nodeName.toLowerCase()}
function r (line 1) | function r(e,n){var t=e&&e.exec(n);return t&&0==t.index}
function a (line 1) | function a(e){return/^(no-?highlight|plain|text)$/i.test(e)}
function i (line 1) | function i(e){var n,t,r,i=e.className+" ";if(i+=e.parentNode?e.parentNod...
function o (line 1) | function o(e,n){var t,r={};for(t in e)r[t]=e[t];if(n)for(t in n)r[t]=n[t...
function u (line 1) | function u(e){var n=[];return function r(e,a){for(var i=e.firstChild;i;i...
function c (line 1) | function c(e,r,a){function i(){return e.length&&r.length?e[0].offset!=r[...
function s (line 1) | function s(e){function n(e){return e&&e.source||e}function t(t,r){return...
function f (line 1) | function f(e,t,a,i){function o(e,n){for(var t=0;t<n.c.length;t++)if(r(n....
function l (line 1) | function l(e,t){t=t||E.languages||Object.keys(x);var r={r:0,value:n(e)},...
function g (line 1) | function g(e){return E.tabReplace&&(e=e.replace(/^((<[^>]+>|\t)+)/gm,fun...
function h (line 1) | function h(e,n,t){var r=n?R[n]:t,a=[e.trim()];return e.match(/\bhljs\b/)...
function p (line 1) | function p(e){var n=i(e);if(!a(n)){var t;E.useBR?(t=document.createEleme...
function d (line 1) | function d(e){E=o(E,e)}
function b (line 1) | function b(){if(!b.called){b.called=!0;var e=document.querySelectorAll("...
function v (line 1) | function v(){addEventListener("DOMContentLoaded",b,!1),addEventListener(...
function m (line 1) | function m(n,t){var r=x[n]=t(e);r.aliases&&r.aliases.forEach(function(e)...
function N (line 1) | function N(){return Object.keys(x)}
function w (line 1) | function w(e){return e=e.toLowerCase(),x[e]||x[R[e]]}
FILE: js/show-hint.js
function Completion (line 49) | function Completion(cm, options) {
function isNewCompletion (line 139) | function isNewCompletion(old, nw) {
function parseOptions (line 144) | function parseOptions(cm, pos, options) {
function getText (line 156) | function getText(completion) {
function buildKeyMap (line 161) | function buildKeyMap(completion, handle) {
function getHintElement (line 196) | function getHintElement(hintsElement, el) {
function Widget (line 203) | function Widget(completion, data) {
function applicableHelpers (line 354) | function applicableHelpers(cm, helpers) {
function fetchHints (line 362) | function fetchHints(hint, cm, options, callback) {
function resolveAutoHints (line 372) | function resolveAutoHints(cm, pos) {
FILE: js/show-hint2.js
function Completion (line 51) | function Completion(cm, options) {
function isNewCompletion (line 142) | function isNewCompletion(old, nw) {
function parseOptions (line 147) | function parseOptions(cm, pos, options) {
function getText (line 159) | function getText(completion) {
function buildKeyMap (line 164) | function buildKeyMap(completion, handle) {
function getHintElement (line 199) | function getHintElement(hintsElement, el) {
function Widget (line 206) | function Widget(completion, data) {
function applicableHelpers (line 367) | function applicableHelpers(cm, helpers) {
function fetchHints (line 375) | function fetchHints(hint, cm, options, callback) {
function resolveAutoHints (line 387) | function resolveAutoHints(cm, pos) {
FILE: mode/elm.js
function switchState (line 18) | function switchState(source, setState, f) {
function normal (line 34) | function normal() {
function ncomment (line 123) | function ncomment(type, nest) {
function nstring (line 146) | function nstring(nest) {
function stringLiteral (line 169) | function stringLiteral(source, setState) {
function stringGap (line 188) | function stringGap(source, setState) {
FILE: node/elm-client.js
function doPackageInstall (line 86) | function doPackageInstall() {
function startRepl (line 96) | function startRepl(error, success, projectPath) {
function startReactor (line 117) | function startReactor(error, success, projectPath, port) {
function startMessageListener (line 140) | function startMessageListener() {
function startWatcher (line 198) | function startWatcher() {
function parseSourceFiles (line 271) | function parseSourceFiles() {
function parseAllPackageSources (line 288) | function parseAllPackageSources() {
function parsePackageSources (line 300) | function parsePackageSources(package) {
function getProjectDeps (line 314) | function getProjectDeps(projectDir) {
function parseAndSend (line 343) | function parseAndSend(file) {
function parseAndSendPackageSource (line 369) | function parseAndSendPackageSource(package, file) {
function sendAstMsg (line 398) | function sendAstMsg(msg) {
function getSourceDirs (line 403) | function getSourceDirs (projectDir) {
function getExposedModules (line 417) | function getExposedModules (projectDir) {
function fileExists (line 434) | function fileExists(file) {
function isSourceFile (line 443) | function isSourceFile(sourceDirs, file) {
function handleAstPassThrough (line 465) | function handleAstPassThrough(clientId, msg) {
function handleReloadAst (line 469) | function handleReloadAst(clientId) {
function handleParseEditorText (line 476) | function handleParseEditorText(clientId, msg) {
function handleReplRestart (line 490) | function handleReplRestart(clientId) {
function idxReplTerminator (line 508) | function idxReplTerminator(x) {
function maybeRemoveLastLine (line 512) | function maybeRemoveLastLine (x) {
function stripReplNewLines (line 524) | function stripReplNewLines(x) {
function handleEval (line 532) | function handleEval(clientId, msg) {
function parseMakeResults (line 577) | function parseMakeResults(data) {
function send (line 588) | function send(msg) { process.send(msg); }
function handleLint (line 590) | function handleLint(clientId, msg) {
function lowerFirstLetter (line 605) | function lowerFirstLetter(str) {
function inferOutputFile (line 611) | function inferOutputFile(filePath) {
function handleMake (line 620) | function handleMake(clientId, msg) {
function handleGendoc (line 645) | function handleGendoc(clientId, msg) {
function handleDocsSearch (line 664) | function handleDocsSearch(clientId, msg) {
function handleTest (line 671) | function handleTest(clientId, msg) {
function handleTestSuite (line 706) | function handleTestSuite(clientId, msg) {
function killExternalChildren (line 772) | function killExternalChildren(pid, cb) {
function handleClose (line 791) | function handleClose() {
FILE: node/elmparser.js
function peg$subclass (line 10) | function peg$subclass(child, parent) {
function peg$SyntaxError (line 16) | function peg$SyntaxError(message, expected, found, location) {
function peg$parse (line 30) | function peg$parse(input) {
Condensed preview — 69 files, each showing path, character count, and a content snippet. Download the .json file or copy for the full structured content (2,788K chars).
[
{
"path": ".gitignore",
"chars": 111,
"preview": ".nrepl-port\ntarget\nelm/ModuleBrowser/elm-stuff\nelm/ModuleBrowser/elm.js\nDocPreview/elm-stuff\nDocPreview/elm.js\n"
},
{
"path": "DocPreview/DocPreview.elm",
"chars": 5683,
"preview": "module DocPreview (..) where\n\n\nimport Html exposing (Html, text, div, span, h1)\nimport Html.Attributes exposing (class)\n"
},
{
"path": "DocPreview/DocPreview.html",
"chars": 5151,
"preview": "<!DOCTYPE html>\n<html lang=\"en\">\n <head>\n <meta charset=\"utf-8\">\n <meta content=\"IE=edge,chrome=1\" http-equiv=\"X-"
},
{
"path": "DocPreview/LICENSE",
"chars": 1526,
"preview": "Copyright (c) 2014, Evan Czaplicki\n\nAll rights reserved.\n\nRedistribution and use in source and binary forms, with or wit"
},
{
"path": "DocPreview/docPreview.js",
"chars": 378004,
"preview": "var Elm = Elm || { Native: {} };\nElm.Native.Array = {};\nElm.Native.Array.make = function(localRuntime) {\n\n\tlocalRuntime."
},
{
"path": "DocPreview/elm-package.json",
"chars": 685,
"preview": "{\n \"version\": \"1.0.0\",\n \"summary\": \"website for browsing packages and exploring documentation\",\n \"repository\": "
},
{
"path": "DocPreview/highlight.pack.js",
"chars": 65884,
"preview": "/*! highlight.js v9.2.0 | BSD3 License | git.io/hljslicense */\n!function(e){var n=\"object\"==typeof window&&window||\"obje"
},
{
"path": "DocPreview/src/Docs/Entry.elm",
"chars": 5912,
"preview": "module Docs.Entry where\n\nimport Effects as Fx exposing (Effects)\nimport Html exposing (..)\nimport Html.Attributes exposi"
},
{
"path": "DocPreview/src/Docs/Name.elm",
"chars": 591,
"preview": "module Docs.Name where\n\nimport Dict\nimport Html exposing (..)\nimport Html.Attributes exposing (..)\nimport Set\nimport Str"
},
{
"path": "DocPreview/src/Docs/Package.elm",
"chars": 2074,
"preview": "module Docs.Package\n ( Package\n , Module\n , decodePackage\n , decodeModule\n )\n where\n\nimport Dict\nimport Json.Decod"
},
{
"path": "DocPreview/src/Docs/Summary.elm",
"chars": 438,
"preview": "module Docs.Summary (Summary, decoder) where\n\nimport Docs.Version as Vsn\nimport Json.Decode exposing (..)\n\n\n\ntype alias "
},
{
"path": "DocPreview/src/Docs/Type.elm",
"chars": 3495,
"preview": "module Docs.Type where\n\nimport Html exposing (..)\nimport String\nimport Docs.Name as Name\nimport Utils.Code as Code expos"
},
{
"path": "DocPreview/src/Docs/Version.elm",
"chars": 2665,
"preview": "module Docs.Version\n ( Version\n , Dictionary\n , MinorPatch\n , decoder\n , filterInteresting\n , realMax\n"
},
{
"path": "DocPreview/src/Native/Jump.js",
"chars": 745,
"preview": "Elm.Native.Jump = {};\n\nElm.Native.Jump.make = function(localRuntime)\n{\n\tlocalRuntime.Native = localRuntime.Native || {};"
},
{
"path": "DocPreview/src/Native/Parse.js",
"chars": 2427,
"preview": "Elm.Native.Parse = {};\n\nElm.Native.Parse.make = function(localRuntime)\n{\n\tlocalRuntime.Native = localRuntime.Native || {"
},
{
"path": "DocPreview/src/Parse/Combinators.elm",
"chars": 2604,
"preview": "module Parse.Combinators where\n\nimport Char\nimport Native.Parse\n\n\n\n-- PARSERS\n\n\ntype Parser a = P\n\n\nrun : Parser a -> St"
},
{
"path": "DocPreview/src/Parse/Type.elm",
"chars": 3196,
"preview": "module Parse.Type (parse) where\n\nimport Char\nimport String\n\nimport Parse.Combinators exposing (..)\nimport Docs.Name as N"
},
{
"path": "DocPreview/src/Utils/Code.elm",
"chars": 495,
"preview": "module Utils.Code where\n\nimport Html exposing (..)\nimport Html.Attributes exposing (..)\n\n\n\nkeyword : String -> Html\nkeyw"
},
{
"path": "DocPreview/src/Utils/FluidList.elm",
"chars": 794,
"preview": "module Utils.FluidList where\n\nimport Html exposing (..)\nimport Html.Attributes exposing (..)\n\n\n(=>) : a -> b -> ( a, b )"
},
{
"path": "DocPreview/src/Utils/Markdown.elm",
"chars": 292,
"preview": "module Utils.Markdown (block) where\n\nimport Html\nimport Markdown\n\n\nblock : String -> Html.Html\nblock raw =\n Markdown.to"
},
{
"path": "DocPreview/src/Utils/Path.elm",
"chars": 216,
"preview": "module Utils.Path where\n\nimport String\n\n\nhyphenate : String -> String\nhyphenate string =\n String.map (\\c -> if c == '.'"
},
{
"path": "LICENSE.md",
"chars": 1106,
"preview": "The MIT License (MIT)\n=====================\n\nCopyright (c) 2015 Magnus Rundberget\n\nPermission is hereby granted, free of"
},
{
"path": "README.adoc",
"chars": 6253,
"preview": "= Elm LightTable plugin\n\n\nifdef::env-github[]\n:tip-caption: :bulb:\n:note-caption: :information_source:\n:important-captio"
},
{
"path": "css/docpreview.css",
"chars": 9406,
"preview": "/*.hljs {\n display: block;\n overflow-x: auto;\n padding: 0.5em;\n background: #f0f0f0;\n -webkit-text-size-adjust: non"
},
{
"path": "css/elm.css",
"chars": 6026,
"preview": "/* linting */\n\n\n\n\n.package-table {\n padding-bottom: 10px;\n}\n\n.package-table > tbody > tr:first-child {\n line-height: 2"
},
{
"path": "css/graph.css",
"chars": 1221,
"preview": "div.graph {\n width: 100%;\n height: 100%;\n\n}\n\n.graph .filters {\n border-bottom: 1px solid;\n padding-bottom: 10px;\n m"
},
{
"path": "css/hinter.css",
"chars": 133,
"preview": ".CodeMirror-hint-active {\n background: #616161;\n color: #f4f4f4;\n}\n\n.CodeMirror-hint em {\n font-weight: bold;\n color"
},
{
"path": "css/inlinedoc.css",
"chars": 5983,
"preview": ".hljs {\n display: block;\n overflow-x: auto;\n padding: 0.5em;\n background: inherit;\n -webkit-text-size-adjust: none;"
},
{
"path": "css/test.css",
"chars": 1744,
"preview": ".elmtest-dashboard {\n padding: 10px;\n}\n\n\n.elmtest-dashboard h2 {\n font-size: 125%;\n}\n\n.elmtest-dashboard .curr-test {\n"
},
{
"path": "elm/ModuleBrowser/ModuleBrowser.elm",
"chars": 5849,
"preview": "module ModuleBrowser (..) where\n\nimport Html exposing (Html, text, ul, li, div, input, p)\nimport Html.Attributes exposin"
},
{
"path": "elm/ModuleBrowser/ModuleBrowser.html",
"chars": 18616,
"preview": "<!DOCTYPE html>\n<html lang=\"en\">\n <head>\n <meta charset=\"utf-8\">\n <meta content=\"IE=edge,chrome=1\" http-equiv=\"X-"
},
{
"path": "elm/ModuleBrowser/elm-package.json",
"chars": 571,
"preview": "{\n \"version\": \"1.0.0\",\n \"summary\": \"Elm project module browser for elm-light\",\n \"repository\": \"https://github.c"
},
{
"path": "elm/ModuleBrowser/moduleBrowser.js",
"chars": 340824,
"preview": "var Elm = Elm || { Native: {} };\nElm.Native.Basics = {};\nElm.Native.Basics.make = function(localRuntime) {\n\tlocalRuntime"
},
{
"path": "elm-light.behaviors",
"chars": 7265,
"preview": "[[:app :lt.objs.plugins/load-js [\"mode/elm.js\"\n \"js/show-hint2.js\"\n "
},
{
"path": "elm-light_compiled.js",
"chars": 1294397,
"preview": "if(!lt.util.load.provided_QMARK_('lt.plugins.elm-light.widgets.selector')) {\ngoog.provide('lt.plugins.elm_light.widgets."
},
{
"path": "elm.keymap",
"chars": 53,
"preview": "[\n [:editor.keys.normal.elm \"tab\" :passthrough]\n\n ]\n"
},
{
"path": "js/highlight.pack.js",
"chars": 13129,
"preview": "!function(e){\"undefined\"!=typeof exports?e(exports):(window.hljs=e({}),\"function\"==typeof define&&define.amd&&define(\"hl"
},
{
"path": "js/show-hint.js",
"chars": 15907,
"preview": "// CodeMirror, copyright (c) by Marijn Haverbeke and others\n// Distributed under an MIT license: http://codemirror.net/L"
},
{
"path": "js/show-hint2.js",
"chars": 16288,
"preview": "// CodeMirror, copyright (c) by Marijn Haverbeke and others\n// Distributed under an MIT license: http://codemirror.net/L"
},
{
"path": "mode/elm.js",
"chars": 6323,
"preview": "// CodeMirror, copyright (c) by Marijn Haverbeke and others\n// Distributed under an MIT license: http://codemirror.net/L"
},
{
"path": "node/elm-client.js",
"chars": 20757,
"preview": "var path = require(\"path\");\nvar fs = require(\"fs\");\nvar net = require(\"net\");\nvar psTree = require(\"ps-tree\");\nvar cp = "
},
{
"path": "node/elmparser.js",
"chars": 195950,
"preview": "module.exports = (function() {\n \"use strict\";\n\n /*\n * Generated by PEG.js 0.9.0.\n *\n * http://pegjs.org/\n */\n\n"
},
{
"path": "package.json",
"chars": 599,
"preview": "{\n \"name\": \"elm-light\",\n \"preferGlobal\": true,\n \"version\": \"0.0.1\",\n \"author\": \"Magnus Rundberge <mrundberge"
},
{
"path": "plugin.edn",
"chars": 193,
"preview": "{:name \"elm-light\"\n :version \"0.5.1\"\n :author \"Magnus Rundberget\"\n :source \"https://github.com/rundis/elm-light\"\n :desc "
},
{
"path": "project.clj",
"chars": 183,
"preview": "(defproject elm-light \"0.5.1\"\n :dependencies [[org.clojure/clojure \"1.5.1\"]\n [quiescent \"0.1.4\"]\n "
},
{
"path": "src/lt/plugins/elm_light/autocompleter/core.cljs",
"chars": 4693,
"preview": "(ns lt.plugins.elm-light.autocompleter.core\n \"Basis for generic autocompleter for LT\"\n (:require [lt.objs.editor :as e"
},
{
"path": "src/lt/plugins/elm_light/autocompleter.cljs",
"chars": 2545,
"preview": "(ns lt.plugins.elm-light.autocompleter\n (:require [quiescent :as q :include-macros true]\n [quiescent.dom :as"
},
{
"path": "src/lt/plugins/elm_light/clients.cljs",
"chars": 10853,
"preview": "(ns lt.plugins.elm-light.clients\n (:require [lt.plugins.elm-light.utils :as u]\n [lt.plugins.elm-light.elm-as"
},
{
"path": "src/lt/plugins/elm_light/docpreview.cljs",
"chars": 5080,
"preview": "(ns lt.plugins.elm-light.docpreview\n (:require [lt.plugins.elm-light.clients :refer [try-connect]]\n [lt.plug"
},
{
"path": "src/lt/plugins/elm_light/elm_ast.cljs",
"chars": 51788,
"preview": "(ns lt.plugins.elm-light.elm-ast\n (:require [lt.plugins.elm-light.utils :as util]\n [lt.objs.console :as cons"
},
{
"path": "src/lt/plugins/elm_light/format.cljs",
"chars": 5290,
"preview": "(ns lt.plugins.elm-light.format\n (:require [lt.plugins.elm-light.utils :as u]\n [lt.plugins.elm-light.selecti"
},
{
"path": "src/lt/plugins/elm_light/graph.cljs",
"chars": 7924,
"preview": "(ns lt.plugins.elm-light.graph\n (:require [lt.plugins.elm-light.utils :as u]\n [lt.objs.files :as files]\n "
},
{
"path": "src/lt/plugins/elm_light/gutter.cljs",
"chars": 2869,
"preview": "(ns lt.plugins.elm-light.gutter\n (:require [lt.plugins.elm-light.elm-ast :as ast]\n [lt.plugins.elm-light.uti"
},
{
"path": "src/lt/plugins/elm_light/hinter.cljs",
"chars": 6184,
"preview": "(ns lt.plugins.elm-light.hinter\n \"Hinter implementation for Elm\"\n (:require [lt.plugins.elm-light.utils :as utils]\n "
},
{
"path": "src/lt/plugins/elm_light/inline-doc.cljs",
"chars": 2550,
"preview": "(ns lt.plugins.elm-light.inline-doc\n (:require [lt.plugins.elm-light.utils :as u]\n [lt.util.dom :as dom]\n "
},
{
"path": "src/lt/plugins/elm_light/linter.cljs",
"chars": 8126,
"preview": "(ns lt.plugins.elm-light.linter\n \"Generic linter for highlighting errors/warnings and providing context sensitive actio"
},
{
"path": "src/lt/plugins/elm_light/make.cljs",
"chars": 0,
"preview": ""
},
{
"path": "src/lt/plugins/elm_light/module_graph.cljs",
"chars": 11043,
"preview": "(ns lt.plugins.elm-light.module-graph\n (:require [lt.plugins.elm-light.utils :as u]\n [lt.plugins.elm-light.e"
},
{
"path": "src/lt/plugins/elm_light/modulebrowser.cljs",
"chars": 5812,
"preview": "(ns lt.plugins.elm-light.modulebrowser\n (:require [lt.plugins.elm-light.utils :as u]\n [lt.objs.files :as fil"
},
{
"path": "src/lt/plugins/elm_light/packages.cljs",
"chars": 10821,
"preview": "(ns lt.plugins.elm-light.packages\n (:require [lt.plugins.elm-light.utils :as u]\n [lt.plugins.elm-light.graph"
},
{
"path": "src/lt/plugins/elm_light/repl.cljs",
"chars": 2488,
"preview": "(ns lt.plugins.elm-light.repl\n \"Implementation of anyonymous Elm Repl Tab\"\n (:require [lt.object :as object]\n "
},
{
"path": "src/lt/plugins/elm_light/selection.cljs",
"chars": 1648,
"preview": "(ns lt.plugins.elm-light.selection\n (:require [lt.objs.editor :as editor]))\n\n\n(defn indented? [s]\n (> (count (re-find "
},
{
"path": "src/lt/plugins/elm_light/test.cljs",
"chars": 19506,
"preview": "(ns lt.plugins.elm-light.test\n (:require [lt.plugins.elm-light.utils :as util]\n [lt.plugins.elm-light.client"
},
{
"path": "src/lt/plugins/elm_light/usages.cljs",
"chars": 5984,
"preview": "(ns lt.plugins.elm-light.usages\n (:require [lt.plugins.elm-light.elm-ast :as ast]\n [lt.plugins.elm-light.uti"
},
{
"path": "src/lt/plugins/elm_light/utils.cljs",
"chars": 6924,
"preview": "(ns lt.plugins.elm-light.utils\n (:require [lt.objs.files :as files]\n [lt.objs.editor :as editor]\n "
},
{
"path": "src/lt/plugins/elm_light/widgets/selector.cljs",
"chars": 3056,
"preview": "(ns lt.plugins.elm-light.widgets.selector\n \"Drop down select widget positioned absolutely in editor at given line/ch\"\n "
},
{
"path": "src/lt/plugins/elm_light.cljs",
"chars": 31491,
"preview": "(ns lt.plugins.elm-light\n (:require [lt.plugins.elm-light.selection :as elm-sel]\n [lt.plugins.elm-light.util"
},
{
"path": "templates/test/Main.elm",
"chars": 227,
"preview": "port module Main exposing (..)\n\nimport Tests\nimport Test.Runner.Node exposing (run, TestProgram)\nimport Json.Encode expo"
},
{
"path": "templates/test/Tests.elm",
"chars": 1501,
"preview": "module Tests exposing (..)\n\nimport Test exposing (..)\nimport Expect\nimport Fuzz exposing (list, int, tuple, string)\nimpo"
}
]
About this extraction
This page contains the full source code of the rundis/elm-light GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 69 files (2.5 MB), approximately 668.2k tokens, and a symbol index with 928 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.