diff --git a/.travis.yml b/.travis.yml index a4d7835..9a58d6a 100644 --- a/.travis.yml +++ b/.travis.yml @@ -1,44 +1,9 @@ -sudo: false - -language: node_js -node_js: node - -cache: - directories: - - elm-stuff/build-artifacts - - elm-stuff/packages - - sysconfcpus -os: - - linux - -env: ELM_VERSION=0.18.0 - -before_install: - - echo -e "Host github.com\n\tStrictHostKeyChecking no\n" >> ~/.ssh/config +language: elm install: - - node --version - - npm --version - - npm install -g elm@$ELM_VERSION elm-test@0.18.7 - - npm install -g elm-github-install - - git clone https://github.com/NoRedInk/elm-ops-tooling - - elm-ops-tooling/with_retry.rb elm package install --yes - # Faster compile on Travis. - - | - if [ ! -d sysconfcpus/bin ]; - then - git clone https://github.com/obmarg/libsysconfcpus.git; - cd libsysconfcpus; - ./configure --prefix=$TRAVIS_BUILD_DIR/sysconfcpus; - make && make install; - cd ..; - fi - -before_script: - - cd tests && elm-github-install && $TRAVIS_BUILD_DIR/sysconfcpus/bin/sysconfcpus -n 2 elm-make --yes && cd .. - -script: - - $TRAVIS_BUILD_DIR/sysconfcpus/bin/sysconfcpus -n 2 elm-test + - npm install -g elm@0.19.1-3 + - npm install -g elm-test@0.19.1 + - npm install -g elm-format@0.8.2 notifications: email: false diff --git a/elm-package.json b/elm-package.json deleted file mode 100644 index ebaed64..0000000 --- a/elm-package.json +++ /dev/null @@ -1,27 +0,0 @@ -{ - "version": "10.0.1", - "summary": "A parser for Elm code", - "repository": "https://github.com/Bogdanp/elm-ast.git", - "license": "BSD3", - "source-directories": [ - "src", - "test" - ], - "exposed-modules": [ - "Ast", - "Ast.BinOp", - "Ast.Expression", - "Ast.Statement", - "Ast.Common" - ], - "dependencies": { - "elm-community/list-extra": "7.0.0 <= v < 8.0.0", - "elm-community/parser-combinators": "3.1.0 <= v < 4.0.0", - "elm-lang/core": "5.0.0 <= v < 6.0.0", - "rtfeldman/hex": "1.0.0 <= v < 2.0.0" - }, - "dependency-sources": { - "elm-community/parser-combinators": "https://github.com/MajronMan/elm-combine.git" - }, - "elm-version": "0.18.0 <= v < 0.19.0" -} diff --git a/elm.json b/elm.json new file mode 100644 index 0000000..f5e2483 --- /dev/null +++ b/elm.json @@ -0,0 +1,25 @@ +{ + "type": "package", + "name": "sgdan/elm-ast", + "summary": "Port of Bogdanp/elm-ast to Elm 0.19", + "license": "BSD-3-Clause", + "version": "0.1.0", + "exposed-modules": [ + "Ast", + "Ast.BinOp", + "Ast.Expression", + "Ast.Statement", + "Ast.Common" + ], + "elm-version": "0.19.1 <= v < 0.20.0", + "dependencies": { + "andre-dietrich/parser-combinators": "3.2.0 <= v < 4.0.0", + "elm/core": "1.0.0 <= v < 2.0.0", + "elm-community/list-extra": "8.2.2 <= v < 9.0.0", + "pilatch/flip": "1.0.0 <= v < 2.0.0", + "rtfeldman/elm-hex": "1.0.0 <= v < 2.0.0" + }, + "test-dependencies": { + "elm-explorations/test": "1.2.2 <= v < 2.0.0" + } +} diff --git a/example/Main.elm b/example/Main.elm index 268ccc5..9c5a7e6 100644 --- a/example/Main.elm +++ b/example/Main.elm @@ -3,6 +3,7 @@ module Main exposing (main) import Ast import Ast.Expression exposing (..) import Ast.Statement exposing (..) +import Browser import Html exposing (..) import Html.Events exposing (..) import Json.Decode as JD @@ -36,7 +37,7 @@ update action model = withChild : a -> List (Html Msg) -> Html Msg withChild title children = li [] - [ pre [] [ text <| toString title ] + [ pre [] [ text <| Debug.toString title ] , ul [] children ] @@ -53,18 +54,18 @@ expression e = , expression e2 ] - e -> - li [] [ pre [] [ text <| toString e ] ] + e_ -> + li [] [ pre [] [ text <| Debug.toString e ] ] statement : Statement -> Html Msg -statement (s, _) = +statement ( s, _ ) = case s of FunctionDeclaration _ e -> withChild s [ expression e ] - s -> - li [] [ pre [] [ text <| toString s ] ] + s_ -> + li [] [ pre [] [ text <| Debug.toString s ] ] tree : String -> Html Msg @@ -74,7 +75,7 @@ tree m = ul [] (List.map statement statements) err -> - div [] [ text <| toString err ] + div [] [ text <| Debug.toString err ] view : String -> Html Msg @@ -85,10 +86,10 @@ view model = ] -main : Program Never String Msg +main : Program () String Msg main = - Html.beginnerProgram - { model = init + Browser.sandbox + { init = init , update = update , view = view } diff --git a/example/elm-package.json b/example/elm-package.json deleted file mode 100644 index 3427f17..0000000 --- a/example/elm-package.json +++ /dev/null @@ -1,22 +0,0 @@ -{ - "version": "2.0.0", - "summary": "example for elm-ast", - "repository": "https://github.com/Bogdanp/elm-ast.git", - "license": "BSD3", - "source-directories": [ - ".", - "../src" - ], - "exposed-modules": [], - "dependencies": { - "elm-lang/core": "5.0.0 <= v < 6.0.0", - "elm-lang/html": "2.0.0 <= v < 3.0.0", - "elm-community/parser-combinators": "3.1.0 <= v < 4.0.0", - "rtfeldman/hex": "1.0.0 <= v < 2.0.0", - "elm-community/list-extra": "5.0.0 <= v < 6.0.0" - }, - "dependency-sources": { - "elm-community/parser-combinators": "https://github.com/MajronMan/elm-combine.git" - }, - "elm-version": "0.18.0 <= v < 0.19.0" -} diff --git a/example/elm.js b/example/elm.js index 71c58da..63b788b 100644 --- a/example/elm.js +++ b/example/elm.js @@ -1,12622 +1,9835 @@ +try { + (function(scope) { + "use strict"; + + function F(arity, fun, wrapper) { + wrapper.a = arity; + wrapper.f = fun; + return wrapper; + } + + function F2(fun) { + return F(2, fun, function(a) { + return function(b) { + return fun(a, b); + }; + }); + } + function F3(fun) { + return F(3, fun, function(a) { + return function(b) { + return function(c) { + return fun(a, b, c); + }; + }; + }); + } + function F4(fun) { + return F(4, fun, function(a) { + return function(b) { + return function(c) { + return function(d) { + return fun(a, b, c, d); + }; + }; + }; + }); + } + function F5(fun) { + return F(5, fun, function(a) { + return function(b) { + return function(c) { + return function(d) { + return function(e) { + return fun(a, b, c, d, e); + }; + }; + }; + }; + }); + } + function F6(fun) { + return F(6, fun, function(a) { + return function(b) { + return function(c) { + return function(d) { + return function(e) { + return function(f) { + return fun(a, b, c, d, e, f); + }; + }; + }; + }; + }; + }); + } + function F7(fun) { + return F(7, fun, function(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); + }; + }; + }; + }; + }; + }; + }); + } + function F8(fun) { + return F(8, fun, function(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); + }; + }; + }; + }; + }; + }; + }; + }); + } + function F9(fun) { + return F(9, fun, function(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); + }; + }; + }; + }; + }; + }; + }; + }; + }); + } + + function A2(fun, a, b) { + return fun.a === 2 ? fun.f(a, b) : fun(a)(b); + } + function A3(fun, a, b, c) { + return fun.a === 3 ? fun.f(a, b, c) : fun(a)(b)(c); + } + function A4(fun, a, b, c, d) { + return fun.a === 4 ? fun.f(a, b, c, d) : fun(a)(b)(c)(d); + } + function A5(fun, a, b, c, d, e) { + return fun.a === 5 ? fun.f(a, b, c, d, e) : fun(a)(b)(c)(d)(e); + } + function A6(fun, a, b, c, d, e, f) { + return fun.a === 6 + ? fun.f(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.a === 7 + ? fun.f(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.a === 8 + ? fun.f(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.a === 9 + ? fun.f(a, b, c, d, e, f, g, h, i) + : fun(a)(b)(c)(d)(e)(f)(g)(h)(i); + } + + console.warn( + "Compiled in DEV mode. Follow the advice at https://elm-lang.org/0.19.1/optimize for better performance and smaller assets." + ); + + // EQUALITY + + function _Utils_eq(x, y) { + for ( + var pair, stack = [], isEqual = _Utils_eqHelp(x, y, 0, stack); + isEqual && (pair = stack.pop()); + isEqual = _Utils_eqHelp(pair.a, pair.b, 0, stack) + ) {} + + return isEqual; + } + + function _Utils_eqHelp(x, y, depth, stack) { + if (depth > 100) { + stack.push(_Utils_Tuple2(x, y)); + return true; + } + + if (x === y) { + return true; + } + + if (typeof x !== "object" || x === null || y === null) { + typeof x === "function" && _Debug_crash(5); + return false; + } + + /**/ + if (x.$ === "Set_elm_builtin") { + x = $elm$core$Set$toList(x); + y = $elm$core$Set$toList(y); + } + if (x.$ === "RBNode_elm_builtin" || x.$ === "RBEmpty_elm_builtin") { + x = $elm$core$Dict$toList(x); + y = $elm$core$Dict$toList(y); + } + //*/ + + /**_UNUSED/ +if (x.$ < 0) +{ + x = $elm$core$Dict$toList(x); + y = $elm$core$Dict$toList(y); +} +//*/ + + for (var key in x) { + if (!_Utils_eqHelp(x[key], y[key], depth + 1, stack)) { + return false; + } + } + return true; + } + + var _Utils_equal = F2(_Utils_eq); + var _Utils_notEqual = F2(function(a, b) { + return !_Utils_eq(a, b); + }); + + // COMPARISONS + + // Code in Generate/JavaScript.hs, Basics.js, and List.js depends on + // the particular integer values assigned to LT, EQ, and GT. + + function _Utils_cmp(x, y, ord) { + if (typeof x !== "object") { + return x === y ? /*EQ*/ 0 : x < y ? /*LT*/ -1 : /*GT*/ 1; + } + + /**/ + if (x instanceof String) { + var a = x.valueOf(); + var b = y.valueOf(); + return a === b ? 0 : a < b ? -1 : 1; + } + //*/ + + /**_UNUSED/ +if (typeof x.$ === 'undefined') +//*/ + /**/ + if (x.$[0] === "#") { + //*/ + return (ord = _Utils_cmp(x.a, y.a)) + ? ord + : (ord = _Utils_cmp(x.b, y.b)) + ? ord + : _Utils_cmp(x.c, y.c); + } + + // traverse conses until end of a list or a mismatch + for ( + ; + x.b && y.b && !(ord = _Utils_cmp(x.a, y.a)); + x = x.b, y = y.b + ) {} // WHILE_CONSES + return ord || (x.b ? /*GT*/ 1 : y.b ? /*LT*/ -1 : /*EQ*/ 0); + } + + var _Utils_lt = F2(function(a, b) { + return _Utils_cmp(a, b) < 0; + }); + var _Utils_le = F2(function(a, b) { + return _Utils_cmp(a, b) < 1; + }); + var _Utils_gt = F2(function(a, b) { + return _Utils_cmp(a, b) > 0; + }); + var _Utils_ge = F2(function(a, b) { + return _Utils_cmp(a, b) >= 0; + }); + + var _Utils_compare = F2(function(x, y) { + var n = _Utils_cmp(x, y); + return n < 0 + ? $elm$core$Basics$LT + : n + ? $elm$core$Basics$GT + : $elm$core$Basics$EQ; + }); + + // COMMON VALUES + + var _Utils_Tuple0_UNUSED = 0; + var _Utils_Tuple0 = { $: "#0" }; + + function _Utils_Tuple2_UNUSED(a, b) { + return { a: a, b: b }; + } + function _Utils_Tuple2(a, b) { + return { $: "#2", a: a, b: b }; + } + + function _Utils_Tuple3_UNUSED(a, b, c) { + return { a: a, b: b, c: c }; + } + function _Utils_Tuple3(a, b, c) { + return { $: "#3", a: a, b: b, c: c }; + } + + function _Utils_chr_UNUSED(c) { + return c; + } + function _Utils_chr(c) { + return new String(c); + } + + // RECORDS + + function _Utils_update(oldRecord, updatedFields) { + var newRecord = {}; + + for (var key in oldRecord) { + newRecord[key] = oldRecord[key]; + } + + for (var key in updatedFields) { + newRecord[key] = updatedFields[key]; + } + + return newRecord; + } + + // APPEND + + var _Utils_append = F2(_Utils_ap); + + function _Utils_ap(xs, ys) { + // append Strings + if (typeof xs === "string") { + return xs + ys; + } + + // append Lists + if (!xs.b) { + return ys; + } + var root = _List_Cons(xs.a, ys); + xs = xs.b; + for ( + var curr = root; + xs.b; + xs = xs.b // WHILE_CONS + ) { + curr = curr.b = _List_Cons(xs.a, ys); + } + return root; + } + + var _List_Nil_UNUSED = { $: 0 }; + var _List_Nil = { $: "[]" }; + + function _List_Cons_UNUSED(hd, tl) { + return { $: 1, a: hd, b: tl }; + } + function _List_Cons(hd, tl) { + return { $: "::", a: hd, b: tl }; + } + + var _List_cons = F2(_List_Cons); + + function _List_fromArray(arr) { + var out = _List_Nil; + for (var i = arr.length; i--; ) { + out = _List_Cons(arr[i], out); + } + return out; + } + + function _List_toArray(xs) { + for ( + var out = []; + xs.b; + xs = xs.b // WHILE_CONS + ) { + out.push(xs.a); + } + return out; + } + + var _List_map2 = F3(function(f, xs, ys) { + for ( + var arr = []; + xs.b && ys.b; + xs = xs.b, ys = ys.b // WHILE_CONSES + ) { + arr.push(A2(f, xs.a, ys.a)); + } + return _List_fromArray(arr); + }); + + var _List_map3 = F4(function(f, xs, ys, zs) { + for ( + var arr = []; + xs.b && ys.b && zs.b; + xs = xs.b, ys = ys.b, zs = zs.b // WHILE_CONSES + ) { + arr.push(A3(f, xs.a, ys.a, zs.a)); + } + return _List_fromArray(arr); + }); + + var _List_map4 = F5(function(f, ws, xs, ys, zs) { + for ( + var arr = []; + ws.b && xs.b && ys.b && zs.b; + ws = ws.b, xs = xs.b, ys = ys.b, zs = zs.b // WHILE_CONSES + ) { + arr.push(A4(f, ws.a, xs.a, ys.a, zs.a)); + } + return _List_fromArray(arr); + }); + + var _List_map5 = F6(function(f, vs, ws, xs, ys, zs) { + for ( + var arr = []; + vs.b && ws.b && xs.b && ys.b && zs.b; + vs = vs.b, ws = ws.b, xs = xs.b, ys = ys.b, zs = zs.b // WHILE_CONSES + ) { + arr.push(A5(f, vs.a, ws.a, xs.a, ys.a, zs.a)); + } + return _List_fromArray(arr); + }); + + var _List_sortBy = F2(function(f, xs) { + return _List_fromArray( + _List_toArray(xs).sort(function(a, b) { + return _Utils_cmp(f(a), f(b)); + }) + ); + }); + + var _List_sortWith = F2(function(f, xs) { + return _List_fromArray( + _List_toArray(xs).sort(function(a, b) { + var ord = A2(f, a, b); + return ord === $elm$core$Basics$EQ + ? 0 + : ord === $elm$core$Basics$LT + ? -1 + : 1; + }) + ); + }); -(function() { -'use strict'; + var _JsArray_empty = []; -function F2(fun) -{ - function wrapper(a) { return function(b) { return fun(a,b); }; } - wrapper.arity = 2; - wrapper.func = fun; - return wrapper; -} + function _JsArray_singleton(value) { + return [value]; + } -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 _JsArray_length(array) { + return array.length; + } -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; -} + var _JsArray_initialize = F3(function(size, offset, func) { + var result = new Array(size); -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; -} + for (var i = 0; i < size; i++) { + result[i] = func(offset + i); + } -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; -} + return result; + }); -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; -} + var _JsArray_initializeFromList = F2(function(max, ls) { + var result = new Array(max); -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; -} + for (var i = 0; i < max && ls.b; i++) { + result[i] = ls.a; + ls = ls.b; + } -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; -} + result.length = i; + return _Utils_Tuple2(result, ls); + }); -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); -} + var _JsArray_unsafeGet = F2(function(index, array) { + return array[index]; + }); -var _elm_lang$lazy$Native_Lazy = function() { + var _JsArray_unsafeSet = F3(function(index, value, array) { + var length = array.length; + var result = new Array(length); -function memoize(thunk) -{ - var value; - var isForced = false; - return function(tuple0) { - if (!isForced) { - value = thunk(tuple0); - isForced = true; - } - return value; - }; -} + for (var i = 0; i < length; i++) { + result[i] = array[i]; + } -return { - memoize: memoize -}; + result[index] = value; + return result; + }); -}(); + var _JsArray_push = F2(function(value, array) { + var length = array.length; + var result = new Array(length + 1); -//import Native.Utils // + for (var i = 0; i < length; i++) { + result[i] = array[i]; + } -var _elm_lang$core$Native_Basics = function() { + result[length] = value; + return result; + }); -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; -} + var _JsArray_foldl = F3(function(func, acc, array) { + var length = array.length; -function min(a, b) -{ - return _elm_lang$core$Native_Utils.cmp(a, b) < 0 ? a : b; -} -function max(a, b) -{ - return _elm_lang$core$Native_Utils.cmp(a, b) > 0 ? a : b; -} -function clamp(lo, hi, n) -{ - return _elm_lang$core$Native_Utils.cmp(n, lo) < 0 - ? lo - : _elm_lang$core$Native_Utils.cmp(n, hi) > 0 - ? hi - : n; -} + for (var i = 0; i < length; i++) { + acc = A2(func, array[i], acc); + } -var ord = ['LT', 'EQ', 'GT']; + return acc; + }); -function compare(x, y) -{ - return { ctor: ord[_elm_lang$core$Native_Utils.cmp(x, y) + 1] }; -} + var _JsArray_foldr = F3(function(func, acc, array) { + for (var i = array.length - 1; i >= 0; i--) { + acc = A2(func, array[i], acc); + } -function xor(a, b) -{ - return a !== b; -} -function not(b) -{ - return !b; -} -function isInfinite(n) -{ - return n === Infinity || n === -Infinity; -} + return acc; + }); -function truncate(n) -{ - return n | 0; -} + var _JsArray_map = F2(function(func, array) { + var length = array.length; + var result = new Array(length); -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 _elm_lang$core$Native_Utils.Tuple2(r * Math.cos(t), r * Math.sin(t)); -} -function toPolar(point) -{ - var x = point._0; - var y = point._1; - return _elm_lang$core$Native_Utils.Tuple2(Math.sqrt(x * x + y * y), Math.atan2(y, x)); -} + for (var i = 0; i < length; i++) { + result[i] = func(array[i]); + } -return { - 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: F2(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 -}; - -}(); -//import // - -var _elm_lang$core$Native_Utils = function() { - -// COMPARISONS - -function eq(x, y) -{ - var stack = []; - var isEqual = eqHelp(x, y, 0, stack); - var pair; - while (isEqual && (pair = stack.pop())) - { - isEqual = eqHelp(pair.x, pair.y, 0, stack); - } - return isEqual; -} + return result; + }); + var _JsArray_indexedMap = F3(function(func, offset, array) { + var length = array.length; + var result = new Array(length); -function eqHelp(x, y, depth, stack) -{ - if (depth > 100) - { - stack.push({ x: x, y: y }); - return true; - } + for (var i = 0; i < length; i++) { + result[i] = A2(func, offset + i, array[i]); + } - if (x === y) - { - return true; - } + return result; + }); - if (typeof x !== 'object') - { - if (typeof x === 'function') - { - throw new Error( - 'Trying to use `(==)` on functions. There is no way to know if functions are "the same" in the Elm sense.' - + ' Read more about this at http://package.elm-lang.org/packages/elm-lang/core/latest/Basics#==' - + ' which describes why it is this way and what the better version will look like.' - ); - } - return false; - } - - if (x === null || y === null) - { - return false - } - - if (x instanceof Date) - { - return x.getTime() === y.getTime(); - } - - if (!('ctor' in x)) - { - for (var key in x) - { - if (!eqHelp(x[key], y[key], depth + 1, stack)) - { - return false; - } + var _JsArray_slice = F3(function(from, to, array) { + return array.slice(from, to); + }); + + var _JsArray_appendN = F3(function(n, dest, source) { + var destLen = dest.length; + var itemsToCopy = n - destLen; + + if (itemsToCopy > source.length) { + itemsToCopy = source.length; } - return true; - } - - // convert Dicts and Sets to lists - if (x.ctor === 'RBNode_elm_builtin' || x.ctor === 'RBEmpty_elm_builtin') - { - x = _elm_lang$core$Dict$toList(x); - y = _elm_lang$core$Dict$toList(y); - } - if (x.ctor === 'Set_elm_builtin') - { - x = _elm_lang$core$Set$toList(x); - y = _elm_lang$core$Set$toList(y); - } - - // check if lists are equal without recursion - if (x.ctor === '::') - { - var a = x; - var b = y; - while (a.ctor === '::' && b.ctor === '::') - { - if (!eqHelp(a._0, b._0, depth + 1, stack)) - { - return false; - } - a = a._1; - b = b._1; - } - return a.ctor === b.ctor; - } - - // check if Arrays are equal - if (x.ctor === '_Array') - { - var xs = _elm_lang$core$Native_Array.toJSArray(x); - var ys = _elm_lang$core$Native_Array.toJSArray(y); - if (xs.length !== ys.length) - { - return false; + + var size = destLen + itemsToCopy; + var result = new Array(size); + + for (var i = 0; i < destLen; i++) { + result[i] = dest[i]; } - for (var i = 0; i < xs.length; i++) - { - if (!eqHelp(xs[i], ys[i], depth + 1, stack)) - { - return false; - } + + for (var i = 0; i < itemsToCopy; i++) { + result[i + destLen] = source[i]; } - return true; - } - if (!eqHelp(x.ctor, y.ctor, depth + 1, stack)) - { - return false; - } + return result; + }); - for (var key in x) - { - if (!eqHelp(x[key], y[key], depth + 1, stack)) - { - return false; - } - } - return true; -} + // LOG -// Code in Generate/JavaScript.hs, Basics.js, and List.js depends on -// the particular integer values assigned to LT, EQ, and GT. + var _Debug_log_UNUSED = F2(function(tag, value) { + return value; + }); -var LT = -1, EQ = 0, GT = 1; + var _Debug_log = F2(function(tag, value) { + console.log(tag + ": " + _Debug_toString(value)); + return value; + }); -function cmp(x, y) -{ - if (typeof x !== 'object') - { - return x === y ? EQ : x < y ? LT : GT; - } - - if (x instanceof String) - { - var a = x.valueOf(); - var b = y.valueOf(); - return a === b ? EQ : a < b ? LT : GT; - } - - if (x.ctor === '::' || x.ctor === '[]') - { - while (x.ctor === '::' && y.ctor === '::') - { - var ord = cmp(x._0, y._0); - if (ord !== EQ) - { - return ord; - } - x = x._1; - y = y._1; - } - return x.ctor === y.ctor ? EQ : x.ctor === '[]' ? LT : GT; - } - - if (x.ctor.slice(0, 6) === '_Tuple') - { - var ord; - 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; - } - - throw new Error( - 'Comparison error: comparison is only defined on ints, ' - + 'floats, times, chars, strings, lists of comparable values, ' - + 'and tuples of comparable values.' - ); -} + // TODOS + function _Debug_todo(moduleName, region) { + return function(message) { + _Debug_crash(8, moduleName, region, message); + }; + } -// COMMON VALUES + function _Debug_todoCase(moduleName, region, value) { + return function(message) { + _Debug_crash(9, moduleName, region, value, message); + }; + } -var Tuple0 = { - ctor: '_Tuple0' -}; + // TO STRING -function Tuple2(x, y) -{ - return { - ctor: '_Tuple2', - _0: x, - _1: y - }; -} + function _Debug_toString_UNUSED(value) { + return ""; + } -function chr(c) -{ - return new String(c); -} + function _Debug_toString(value) { + return _Debug_toAnsiString(false, value); + } + function _Debug_toAnsiString(ansi, value) { + if (typeof value === "function") { + return _Debug_internalColor(ansi, ""); + } -// GUID + if (typeof value === "boolean") { + return _Debug_ctorColor(ansi, value ? "True" : "False"); + } -var count = 0; -function guid(_) -{ - return count++; -} + if (typeof value === "number") { + return _Debug_numberColor(ansi, value + ""); + } + if (value instanceof String) { + return _Debug_charColor( + ansi, + "'" + _Debug_addSlashes(value, true) + "'" + ); + } + + if (typeof value === "string") { + return _Debug_stringColor( + ansi, + '"' + _Debug_addSlashes(value, false) + '"' + ); + } -// RECORDS + if (typeof value === "object" && "$" in value) { + var tag = value.$; -function update(oldRecord, updatedFields) -{ - var newRecord = {}; + if (typeof tag === "number") { + return _Debug_internalColor(ansi, ""); + } + + if (tag[0] === "#") { + var output = []; + for (var k in value) { + if (k === "$") continue; + output.push(_Debug_toAnsiString(ansi, value[k])); + } + return "(" + output.join(",") + ")"; + } + + if (tag === "Set_elm_builtin") { + return ( + _Debug_ctorColor(ansi, "Set") + + _Debug_fadeColor(ansi, ".fromList") + + " " + + _Debug_toAnsiString(ansi, $elm$core$Set$toList(value)) + ); + } + + if ( + tag === "RBNode_elm_builtin" || + tag === "RBEmpty_elm_builtin" + ) { + return ( + _Debug_ctorColor(ansi, "Dict") + + _Debug_fadeColor(ansi, ".fromList") + + " " + + _Debug_toAnsiString(ansi, $elm$core$Dict$toList(value)) + ); + } + + if (tag === "Array_elm_builtin") { + return ( + _Debug_ctorColor(ansi, "Array") + + _Debug_fadeColor(ansi, ".fromList") + + " " + + _Debug_toAnsiString(ansi, $elm$core$Array$toList(value)) + ); + } - for (var key in oldRecord) - { - newRecord[key] = oldRecord[key]; - } + if (tag === "::" || tag === "[]") { + var output = "["; - for (var key in updatedFields) - { - newRecord[key] = updatedFields[key]; - } + value.b && + ((output += _Debug_toAnsiString(ansi, value.a)), + (value = value.b)); - return newRecord; -} + for ( + ; + value.b; + value = value.b // WHILE_CONS + ) { + output += "," + _Debug_toAnsiString(ansi, value.a); + } + return output + "]"; + } + var output = ""; + for (var i in value) { + if (i === "$") continue; + var str = _Debug_toAnsiString(ansi, value[i]); + var c0 = str[0]; + var parenless = + c0 === "{" || + c0 === "(" || + c0 === "[" || + c0 === "<" || + c0 === '"' || + str.indexOf(" ") < 0; + output += " " + (parenless ? str : "(" + str + ")"); + } + return _Debug_ctorColor(ansi, tag) + output; + } + + if (typeof DataView === "function" && value instanceof DataView) { + return _Debug_stringColor( + ansi, + "<" + value.byteLength + " bytes>" + ); + } + + if (typeof File === "function" && value instanceof File) { + return _Debug_internalColor(ansi, "<" + value.name + ">"); + } + + if (typeof value === "object") { + var output = []; + for (var key in value) { + var field = key[0] === "_" ? key.slice(1) : key; + output.push( + _Debug_fadeColor(ansi, field) + + " = " + + _Debug_toAnsiString(ansi, value[key]) + ); + } + if (output.length === 0) { + return "{}"; + } + return "{ " + output.join(", ") + " }"; + } + + return _Debug_internalColor(ansi, ""); + } + + function _Debug_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, '\\"'); + } + } -//// LIST STUFF //// + function _Debug_ctorColor(ansi, string) { + return ansi ? "\x1b[96m" + string + "\x1b[0m" : string; + } -var Nil = { ctor: '[]' }; + function _Debug_numberColor(ansi, string) { + return ansi ? "\x1b[95m" + string + "\x1b[0m" : string; + } -function Cons(hd, tl) -{ - return { - ctor: '::', - _0: hd, - _1: tl - }; -} + function _Debug_stringColor(ansi, string) { + return ansi ? "\x1b[93m" + string + "\x1b[0m" : string; + } -function append(xs, ys) -{ - // append Strings - if (typeof xs === 'string') - { - return xs + 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; -} + function _Debug_charColor(ansi, string) { + return ansi ? "\x1b[92m" + string + "\x1b[0m" : string; + } + function _Debug_fadeColor(ansi, string) { + return ansi ? "\x1b[37m" + string + "\x1b[0m" : string; + } -// CRASHES + function _Debug_internalColor(ansi, string) { + return ansi ? "\x1b[94m" + string + "\x1b[0m" : string; + } -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 _Debug_toHexDigit(n) { + return String.fromCharCode(n < 10 ? 48 + n : 55 + n); + } -function crashCase(moduleName, region, value) -{ - return function(message) { + // CRASH + + function _Debug_crash_UNUSED(identifier) { 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 + "https://github.com/elm/core/blob/1.0.0/hints/" + + identifier + + ".md" ); - }; -} + } -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; -} + function _Debug_crash(identifier, fact1, fact2, fact3, fact4) { + switch (identifier) { + case 0: + throw new Error( + 'What node should I take over? In JavaScript I need something like:\n\n Elm.Main.init({\n node: document.getElementById("elm-node")\n })\n\nYou need to do this with any Browser.sandbox or Browser.element program.' + ); + case 1: + throw new Error( + "Browser.application programs cannot handle URLs like this:\n\n " + + document.location.href + + "\n\nWhat is the root? The root of your file system? Try looking at this program with `elm reactor` or some other server." + ); -// TO STRING + case 2: + var jsonErrorString = fact1; + throw new Error( + "Problem with the flags given to your Elm program on initialization.\n\n" + + jsonErrorString + ); -function toString(v) -{ - var type = typeof v; - if (type === 'function') - { - return ''; - } - - if (type === 'boolean') - { - return v ? 'True' : 'False'; - } - - if (type === 'number') - { - return v + ''; - } - - if (v instanceof String) - { - return '\'' + addSlashes(v, true) + '\''; - } - - if (type === 'string') - { - return '"' + addSlashes(v, false) + '"'; - } - - if (v === null) - { - return 'null'; - } - - if (type === 'object' && 'ctor' in v) - { - var ctorStarter = v.ctor.substring(0, 5); - - if (ctorStarter === '_Tupl') - { - var output = []; - for (var k in v) - { - if (k === 'ctor') continue; - output.push(toString(v[k])); - } - return '(' + output.join(',') + ')'; - } + case 3: + var portName = fact1; + throw new Error( + "There can only be one port named `" + + portName + + "`, but your program has multiple." + ); - if (ctorStarter === '_Task') - { - return '' - } + case 4: + var portName = fact1; + var problem = fact2; + throw new Error( + "Trying to send an unexpected type of value through port `" + + portName + + "`:\n" + + problem + ); - if (v.ctor === '_Array') - { - var list = _elm_lang$core$Array$toList(v); - return 'Array.fromList ' + toString(list); - } + case 5: + throw new Error( + 'Trying to use `(==)` on functions.\nThere is no way to know if functions are "the same" in the Elm sense.\nRead more about this at https://package.elm-lang.org/packages/elm/core/latest/Basics#== which describes why it is this way and what the better version will look like.' + ); - if (v.ctor === '') - { - return ''; - } + case 6: + var moduleName = fact1; + throw new Error( + "Your page is loading multiple Elm scripts with a module named " + + moduleName + + ". Maybe a duplicate script is getting loaded accidentally? If not, rename one of them so I know which is which!" + ); - if (v.ctor === '_Process') - { - return ''; - } + case 8: + var moduleName = fact1; + var region = fact2; + var message = fact3; + throw new Error( + "TODO in module `" + + moduleName + + "` " + + _Debug_regionToString(region) + + "\n\n" + + message + ); - if (v.ctor === '::') - { - var output = '[' + toString(v._0); - v = v._1; - while (v.ctor === '::') - { - output += ',' + toString(v._0); - v = v._1; - } - return output + ']'; - } + case 9: + var moduleName = fact1; + var region = fact2; + var value = fact3; + var message = fact4; + throw new Error( + "TODO in module `" + + moduleName + + "` from the `case` expression " + + _Debug_regionToString(region) + + "\n\nIt received the following value:\n\n " + + _Debug_toString(value).replace("\n", "\n ") + + "\n\nBut the branch that handles it says:\n\n " + + message.replace("\n", "\n ") + ); - if (v.ctor === '[]') - { - return '[]'; - } + case 10: + throw new Error( + "Bug in https://github.com/elm/virtual-dom/issues" + ); - if (v.ctor === 'Set_elm_builtin') - { - return 'Set.fromList ' + toString(_elm_lang$core$Set$toList(v)); + case 11: + throw new Error( + "Cannot perform mod 0. Division by zero error." + ); } + } - if (v.ctor === 'RBNode_elm_builtin' || v.ctor === 'RBEmpty_elm_builtin') - { - return 'Dict.fromList ' + toString(_elm_lang$core$Dict$toList(v)); + function _Debug_regionToString(region) { + if (region.start.line === region.end.line) { + return "on line " + region.start.line; } - - var output = ''; - for (var i in v) - { - if (i === 'ctor') continue; - var str = toString(v[i]); - var c0 = str[0]; - var parenless = c0 === '{' || c0 === '(' || c0 === '<' || c0 === '"' || str.indexOf(' ') < 0; - output += ' ' + (parenless ? str : '(' + str + ')'); + return ( + "on lines " + region.start.line + " through " + region.end.line + ); + } + + // MATH + + var _Basics_add = F2(function(a, b) { + return a + b; + }); + var _Basics_sub = F2(function(a, b) { + return a - b; + }); + var _Basics_mul = F2(function(a, b) { + return a * b; + }); + var _Basics_fdiv = F2(function(a, b) { + return a / b; + }); + var _Basics_idiv = F2(function(a, b) { + return (a / b) | 0; + }); + var _Basics_pow = F2(Math.pow); + + var _Basics_remainderBy = F2(function(b, a) { + return a % b; + }); + + // https://www.microsoft.com/en-us/research/wp-content/uploads/2016/02/divmodnote-letter.pdf + var _Basics_modBy = F2(function(modulus, x) { + var answer = x % modulus; + return modulus === 0 + ? _Debug_crash(11) + : (answer > 0 && modulus < 0) || (answer < 0 && modulus > 0) + ? answer + modulus + : answer; + }); + + // TRIGONOMETRY + + var _Basics_pi = Math.PI; + var _Basics_e = Math.E; + var _Basics_cos = Math.cos; + var _Basics_sin = Math.sin; + var _Basics_tan = Math.tan; + var _Basics_acos = Math.acos; + var _Basics_asin = Math.asin; + var _Basics_atan = Math.atan; + var _Basics_atan2 = F2(Math.atan2); + + // MORE MATH + + function _Basics_toFloat(x) { + return x; + } + function _Basics_truncate(n) { + return n | 0; + } + function _Basics_isInfinite(n) { + return n === Infinity || n === -Infinity; + } + + var _Basics_ceiling = Math.ceil; + var _Basics_floor = Math.floor; + var _Basics_round = Math.round; + var _Basics_sqrt = Math.sqrt; + var _Basics_log = Math.log; + var _Basics_isNaN = isNaN; + + // BOOLEANS + + function _Basics_not(bool) { + return !bool; + } + var _Basics_and = F2(function(a, b) { + return a && b; + }); + var _Basics_or = F2(function(a, b) { + return a || b; + }); + var _Basics_xor = F2(function(a, b) { + return a !== b; + }); + + var _String_cons = F2(function(chr, str) { + return chr + str; + }); + + function _String_uncons(string) { + var word = string.charCodeAt(0); + return word + ? $elm$core$Maybe$Just( + 0xd800 <= word && word <= 0xdbff + ? _Utils_Tuple2( + _Utils_chr(string[0] + string[1]), + string.slice(2) + ) + : _Utils_Tuple2(_Utils_chr(string[0]), string.slice(1)) + ) + : $elm$core$Maybe$Nothing; + } + + var _String_append = F2(function(a, b) { + return a + b; + }); + + function _String_length(str) { + return str.length; + } + + var _String_map = F2(function(func, string) { + var len = string.length; + var array = new Array(len); + var i = 0; + while (i < len) { + var word = string.charCodeAt(i); + if (0xd800 <= word && word <= 0xdbff) { + array[i] = func(_Utils_chr(string[i] + string[i + 1])); + i += 2; + continue; + } + array[i] = func(_Utils_chr(string[i])); + i++; + } + return array.join(""); + }); + + var _String_filter = F2(function(isGood, str) { + var arr = []; + var len = str.length; + var i = 0; + while (i < len) { + var char = str[i]; + var word = str.charCodeAt(i); + i++; + if (0xd800 <= word && word <= 0xdbff) { + char += str[i]; + i++; + } + + if (isGood(_Utils_chr(char))) { + arr.push(char); + } + } + return arr.join(""); + }); + + function _String_reverse(str) { + var len = str.length; + var arr = new Array(len); + var i = 0; + while (i < len) { + var word = str.charCodeAt(i); + if (0xd800 <= word && word <= 0xdbff) { + arr[len - i] = str[i + 1]; + i++; + arr[len - i] = str[i - 1]; + i++; + } else { + arr[len - i] = str[i]; + i++; + } + } + return arr.join(""); + } + + var _String_foldl = F3(function(func, state, string) { + var len = string.length; + var i = 0; + while (i < len) { + var char = string[i]; + var word = string.charCodeAt(i); + i++; + if (0xd800 <= word && word <= 0xdbff) { + char += string[i]; + i++; + } + state = A2(func, _Utils_chr(char), state); + } + return state; + }); + + var _String_foldr = F3(function(func, state, string) { + var i = string.length; + while (i--) { + var char = string[i]; + var word = string.charCodeAt(i); + if (0xdc00 <= word && word <= 0xdfff) { + i--; + char = string[i] + char; + } + state = A2(func, _Utils_chr(char), state); + } + return state; + }); + + var _String_split = F2(function(sep, str) { + return str.split(sep); + }); + + var _String_join = F2(function(sep, strs) { + return strs.join(sep); + }); + + var _String_slice = F3(function(start, end, str) { + return str.slice(start, end); + }); + + function _String_trim(str) { + return str.trim(); + } + + function _String_trimLeft(str) { + return str.replace(/^\s+/, ""); + } + + function _String_trimRight(str) { + return str.replace(/\s+$/, ""); + } + + function _String_words(str) { + return _List_fromArray(str.trim().split(/\s+/g)); + } + + function _String_lines(str) { + return _List_fromArray(str.split(/\r\n|\r|\n/g)); + } + + function _String_toUpper(str) { + return str.toUpperCase(); + } + + function _String_toLower(str) { + return str.toLowerCase(); + } + + var _String_any = F2(function(isGood, string) { + var i = string.length; + while (i--) { + var char = string[i]; + var word = string.charCodeAt(i); + if (0xdc00 <= word && word <= 0xdfff) { + i--; + char = string[i] + char; + } + if (isGood(_Utils_chr(char))) { + return true; + } } - return v.ctor + output; - } - - if (type === 'object') - { - if (v instanceof Date) - { - return '<' + v.toString() + '>'; + return false; + }); + + var _String_all = F2(function(isGood, string) { + var i = string.length; + while (i--) { + var char = string[i]; + var word = string.charCodeAt(i); + if (0xdc00 <= word && word <= 0xdfff) { + i--; + char = string[i] + char; + } + if (!isGood(_Utils_chr(char))) { + return false; + } } + return true; + }); - if (v.elm_web_socket) - { - return ''; - } + var _String_contains = F2(function(sub, str) { + return str.indexOf(sub) > -1; + }); + + var _String_startsWith = F2(function(sub, str) { + return str.indexOf(sub) === 0; + }); + + var _String_endsWith = F2(function(sub, str) { + return ( + str.length >= sub.length && + str.lastIndexOf(sub) === str.length - sub.length + ); + }); - var output = []; - for (var k in v) - { - output.push(k + ' = ' + toString(v[k])); + var _String_indexes = F2(function(sub, str) { + var subLen = sub.length; + + if (subLen < 1) { + return _List_Nil; } - if (output.length === 0) - { - return '{}'; + + var i = 0; + var is = []; + + while ((i = str.indexOf(sub, i)) > -1) { + is.push(i); + i = i + subLen; } - return '{ ' + output.join(', ') + ' }'; - } - return ''; -} + return _List_fromArray(is); + }); -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, '\\"'); - } -} + // TO STRING + function _String_fromNumber(number) { + return number + ""; + } -return { - eq: eq, - cmp: cmp, - Tuple0: Tuple0, - Tuple2: Tuple2, - chr: chr, - update: update, - guid: guid, - - append: F2(append), - - crash: crash, - crashCase: crashCase, - - toString: toString -}; - -}(); -var _elm_lang$core$Basics$never = function (_p0) { - never: - while (true) { - var _p1 = _p0; - var _v1 = _p1._0; - _p0 = _v1; - continue never; - } -}; -var _elm_lang$core$Basics$uncurry = F2( - function (f, _p2) { - var _p3 = _p2; - return A2(f, _p3._0, _p3._1); - }); -var _elm_lang$core$Basics$curry = F3( - function (f, a, b) { - return f( - {ctor: '_Tuple2', _0: a, _1: b}); - }); -var _elm_lang$core$Basics$flip = F3( - function (f, b, a) { - return A2(f, a, b); - }); -var _elm_lang$core$Basics$always = F2( - function (a, _p4) { - return a; - }); -var _elm_lang$core$Basics$identity = function (x) { - return x; -}; -var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {}; -_elm_lang$core$Basics_ops['<|'] = F2( - function (f, x) { - return f(x); - }); -var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {}; -_elm_lang$core$Basics_ops['|>'] = F2( - function (x, f) { - return f(x); - }); -var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {}; -_elm_lang$core$Basics_ops['>>'] = F3( - function (f, g, x) { - return g( - f(x)); - }); -var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {}; -_elm_lang$core$Basics_ops['<<'] = F3( - function (g, f, x) { - return g( - f(x)); - }); -var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {}; -_elm_lang$core$Basics_ops['++'] = _elm_lang$core$Native_Utils.append; -var _elm_lang$core$Basics$toString = _elm_lang$core$Native_Utils.toString; -var _elm_lang$core$Basics$isInfinite = _elm_lang$core$Native_Basics.isInfinite; -var _elm_lang$core$Basics$isNaN = _elm_lang$core$Native_Basics.isNaN; -var _elm_lang$core$Basics$toFloat = _elm_lang$core$Native_Basics.toFloat; -var _elm_lang$core$Basics$ceiling = _elm_lang$core$Native_Basics.ceiling; -var _elm_lang$core$Basics$floor = _elm_lang$core$Native_Basics.floor; -var _elm_lang$core$Basics$truncate = _elm_lang$core$Native_Basics.truncate; -var _elm_lang$core$Basics$round = _elm_lang$core$Native_Basics.round; -var _elm_lang$core$Basics$not = _elm_lang$core$Native_Basics.not; -var _elm_lang$core$Basics$xor = _elm_lang$core$Native_Basics.xor; -var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {}; -_elm_lang$core$Basics_ops['||'] = _elm_lang$core$Native_Basics.or; -var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {}; -_elm_lang$core$Basics_ops['&&'] = _elm_lang$core$Native_Basics.and; -var _elm_lang$core$Basics$max = _elm_lang$core$Native_Basics.max; -var _elm_lang$core$Basics$min = _elm_lang$core$Native_Basics.min; -var _elm_lang$core$Basics$compare = _elm_lang$core$Native_Basics.compare; -var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {}; -_elm_lang$core$Basics_ops['>='] = _elm_lang$core$Native_Basics.ge; -var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {}; -_elm_lang$core$Basics_ops['<='] = _elm_lang$core$Native_Basics.le; -var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {}; -_elm_lang$core$Basics_ops['>'] = _elm_lang$core$Native_Basics.gt; -var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {}; -_elm_lang$core$Basics_ops['<'] = _elm_lang$core$Native_Basics.lt; -var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {}; -_elm_lang$core$Basics_ops['/='] = _elm_lang$core$Native_Basics.neq; -var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {}; -_elm_lang$core$Basics_ops['=='] = _elm_lang$core$Native_Basics.eq; -var _elm_lang$core$Basics$e = _elm_lang$core$Native_Basics.e; -var _elm_lang$core$Basics$pi = _elm_lang$core$Native_Basics.pi; -var _elm_lang$core$Basics$clamp = _elm_lang$core$Native_Basics.clamp; -var _elm_lang$core$Basics$logBase = _elm_lang$core$Native_Basics.logBase; -var _elm_lang$core$Basics$abs = _elm_lang$core$Native_Basics.abs; -var _elm_lang$core$Basics$negate = _elm_lang$core$Native_Basics.negate; -var _elm_lang$core$Basics$sqrt = _elm_lang$core$Native_Basics.sqrt; -var _elm_lang$core$Basics$atan2 = _elm_lang$core$Native_Basics.atan2; -var _elm_lang$core$Basics$atan = _elm_lang$core$Native_Basics.atan; -var _elm_lang$core$Basics$asin = _elm_lang$core$Native_Basics.asin; -var _elm_lang$core$Basics$acos = _elm_lang$core$Native_Basics.acos; -var _elm_lang$core$Basics$tan = _elm_lang$core$Native_Basics.tan; -var _elm_lang$core$Basics$sin = _elm_lang$core$Native_Basics.sin; -var _elm_lang$core$Basics$cos = _elm_lang$core$Native_Basics.cos; -var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {}; -_elm_lang$core$Basics_ops['^'] = _elm_lang$core$Native_Basics.exp; -var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {}; -_elm_lang$core$Basics_ops['%'] = _elm_lang$core$Native_Basics.mod; -var _elm_lang$core$Basics$rem = _elm_lang$core$Native_Basics.rem; -var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {}; -_elm_lang$core$Basics_ops['//'] = _elm_lang$core$Native_Basics.div; -var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {}; -_elm_lang$core$Basics_ops['/'] = _elm_lang$core$Native_Basics.floatDiv; -var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {}; -_elm_lang$core$Basics_ops['*'] = _elm_lang$core$Native_Basics.mul; -var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {}; -_elm_lang$core$Basics_ops['-'] = _elm_lang$core$Native_Basics.sub; -var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {}; -_elm_lang$core$Basics_ops['+'] = _elm_lang$core$Native_Basics.add; -var _elm_lang$core$Basics$toPolar = _elm_lang$core$Native_Basics.toPolar; -var _elm_lang$core$Basics$fromPolar = _elm_lang$core$Native_Basics.fromPolar; -var _elm_lang$core$Basics$turns = _elm_lang$core$Native_Basics.turns; -var _elm_lang$core$Basics$degrees = _elm_lang$core$Native_Basics.degrees; -var _elm_lang$core$Basics$radians = function (t) { - return t; -}; -var _elm_lang$core$Basics$GT = {ctor: 'GT'}; -var _elm_lang$core$Basics$EQ = {ctor: 'EQ'}; -var _elm_lang$core$Basics$LT = {ctor: 'LT'}; -var _elm_lang$core$Basics$JustOneMore = function (a) { - return {ctor: 'JustOneMore', _0: a}; -}; - -//import Native.Utils // - -var _elm_lang$core$Native_Debug = function() { - -function log(tag, value) -{ - var msg = tag + ': ' + _elm_lang$core$Native_Utils.toString(value); - var process = process || {}; - if (process.stdout) - { - process.stdout.write(msg); - } - else - { - console.log(msg); - } - return value; -} + // INT CONVERSIONS -function crash(message) -{ - throw new Error(message); -} + function _String_toInt(str) { + var total = 0; + var code0 = str.charCodeAt(0); + var start = code0 == 0x2b /* + */ || code0 == 0x2d /* - */ ? 1 : 0; -return { - crash: crash, - log: F2(log) -}; + for (var i = start; i < str.length; ++i) { + var code = str.charCodeAt(i); + if (code < 0x30 || 0x39 < code) { + return $elm$core$Maybe$Nothing; + } + total = 10 * total + code - 0x30; + } -}(); -var _elm_lang$core$Debug$crash = _elm_lang$core$Native_Debug.crash; -var _elm_lang$core$Debug$log = _elm_lang$core$Native_Debug.log; + return i == start + ? $elm$core$Maybe$Nothing + : $elm$core$Maybe$Just(code0 == 0x2d ? -total : total); + } -var _elm_lang$core$Maybe$withDefault = F2( - function ($default, maybe) { - var _p0 = maybe; - if (_p0.ctor === 'Just') { - return _p0._0; - } else { - return $default; - } - }); -var _elm_lang$core$Maybe$Nothing = {ctor: 'Nothing'}; -var _elm_lang$core$Maybe$andThen = F2( - function (callback, maybeValue) { - var _p1 = maybeValue; - if (_p1.ctor === 'Just') { - return callback(_p1._0); - } else { - return _elm_lang$core$Maybe$Nothing; - } - }); -var _elm_lang$core$Maybe$Just = function (a) { - return {ctor: 'Just', _0: a}; -}; -var _elm_lang$core$Maybe$map = F2( - function (f, maybe) { - var _p2 = maybe; - if (_p2.ctor === 'Just') { - return _elm_lang$core$Maybe$Just( - f(_p2._0)); - } else { - return _elm_lang$core$Maybe$Nothing; - } - }); -var _elm_lang$core$Maybe$map2 = F3( - function (func, ma, mb) { - var _p3 = {ctor: '_Tuple2', _0: ma, _1: mb}; - if (((_p3.ctor === '_Tuple2') && (_p3._0.ctor === 'Just')) && (_p3._1.ctor === 'Just')) { - return _elm_lang$core$Maybe$Just( - A2(func, _p3._0._0, _p3._1._0)); - } else { - return _elm_lang$core$Maybe$Nothing; - } - }); -var _elm_lang$core$Maybe$map3 = F4( - function (func, ma, mb, mc) { - var _p4 = {ctor: '_Tuple3', _0: ma, _1: mb, _2: mc}; - if ((((_p4.ctor === '_Tuple3') && (_p4._0.ctor === 'Just')) && (_p4._1.ctor === 'Just')) && (_p4._2.ctor === 'Just')) { - return _elm_lang$core$Maybe$Just( - A3(func, _p4._0._0, _p4._1._0, _p4._2._0)); - } else { - return _elm_lang$core$Maybe$Nothing; - } - }); -var _elm_lang$core$Maybe$map4 = F5( - function (func, ma, mb, mc, md) { - var _p5 = {ctor: '_Tuple4', _0: ma, _1: mb, _2: mc, _3: md}; - if (((((_p5.ctor === '_Tuple4') && (_p5._0.ctor === 'Just')) && (_p5._1.ctor === 'Just')) && (_p5._2.ctor === 'Just')) && (_p5._3.ctor === 'Just')) { - return _elm_lang$core$Maybe$Just( - A4(func, _p5._0._0, _p5._1._0, _p5._2._0, _p5._3._0)); - } else { - return _elm_lang$core$Maybe$Nothing; - } - }); -var _elm_lang$core$Maybe$map5 = F6( - function (func, ma, mb, mc, md, me) { - var _p6 = {ctor: '_Tuple5', _0: ma, _1: mb, _2: mc, _3: md, _4: me}; - if ((((((_p6.ctor === '_Tuple5') && (_p6._0.ctor === 'Just')) && (_p6._1.ctor === 'Just')) && (_p6._2.ctor === 'Just')) && (_p6._3.ctor === 'Just')) && (_p6._4.ctor === 'Just')) { - return _elm_lang$core$Maybe$Just( - A5(func, _p6._0._0, _p6._1._0, _p6._2._0, _p6._3._0, _p6._4._0)); - } else { - return _elm_lang$core$Maybe$Nothing; + // FLOAT CONVERSIONS + + function _String_toFloat(s) { + // check if it is a hex, octal, or binary number + if (s.length === 0 || /[\sxbo]/.test(s)) { + return $elm$core$Maybe$Nothing; } - }); + var n = +s; + // faster isNaN check + return n === n ? $elm$core$Maybe$Just(n) : $elm$core$Maybe$Nothing; + } -//import Native.Utils // + function _String_fromList(chars) { + return _List_toArray(chars).join(""); + } -var _elm_lang$core$Native_List = function() { + function _Char_toCode(char) { + var code = char.charCodeAt(0); + if (0xd800 <= code && code <= 0xdbff) { + return ( + (code - 0xd800) * 0x400 + char.charCodeAt(1) - 0xdc00 + 0x10000 + ); + } + return code; + } -var Nil = { ctor: '[]' }; + function _Char_fromCode(code) { + return _Utils_chr( + code < 0 || 0x10ffff < code + ? "\uFFFD" + : code <= 0xffff + ? String.fromCharCode(code) + : ((code -= 0x10000), + String.fromCharCode( + Math.floor(code / 0x400) + 0xd800, + (code % 0x400) + 0xdc00 + )) + ); + } -function Cons(hd, tl) -{ - return { ctor: '::', _0: hd, _1: tl }; -} + function _Char_toUpper(char) { + return _Utils_chr(char.toUpperCase()); + } -function fromArray(arr) -{ - var out = Nil; - for (var i = arr.length; i--; ) - { - out = Cons(arr[i], out); - } - return out; -} + function _Char_toLower(char) { + return _Utils_chr(char.toLowerCase()); + } -function toArray(xs) -{ - var out = []; - while (xs.ctor !== '[]') - { - out.push(xs._0); - xs = xs._1; - } - return out; -} + function _Char_toLocaleUpper(char) { + return _Utils_chr(char.toLocaleUpperCase()); + } -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 _Char_toLocaleLower(char) { + return _Utils_chr(char.toLocaleLowerCase()); + } -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 _Json_errorToString(error) { + return $elm$json$Json$Decode$errorToString(error); + } + //*/ -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); -} + // CORE DECODERS -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 _Json_succeed(msg) { + return { + $: 0, + a: msg + }; + } -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 _Json_fail(msg) { + return { + $: 1, + a: msg + }; + } + + function _Json_decodePrim(decoder) { + return { $: 2, b: decoder }; + } + + var _Json_decodeInt = _Json_decodePrim(function(value) { + return typeof value !== "number" + ? _Json_expecting("an INT", value) + : -2147483647 < value && + value < 2147483647 && + (value | 0) === value + ? $elm$core$Result$Ok(value) + : isFinite(value) && !(value % 1) + ? $elm$core$Result$Ok(value) + : _Json_expecting("an INT", value); + }); + + var _Json_decodeBool = _Json_decodePrim(function(value) { + return typeof value === "boolean" + ? $elm$core$Result$Ok(value) + : _Json_expecting("a BOOL", value); + }); + + var _Json_decodeFloat = _Json_decodePrim(function(value) { + return typeof value === "number" + ? $elm$core$Result$Ok(value) + : _Json_expecting("a FLOAT", value); + }); + + var _Json_decodeValue = _Json_decodePrim(function(value) { + return $elm$core$Result$Ok(_Json_wrap(value)); + }); + + var _Json_decodeString = _Json_decodePrim(function(value) { + return typeof value === "string" + ? $elm$core$Result$Ok(value) + : value instanceof String + ? $elm$core$Result$Ok(value + "") + : _Json_expecting("a STRING", value); + }); + + function _Json_decodeList(decoder) { + return { $: 3, b: decoder }; + } + function _Json_decodeArray(decoder) { + return { $: 4, b: decoder }; + } + + function _Json_decodeNull(value) { + return { $: 5, c: value }; + } + + var _Json_decodeField = F2(function(field, decoder) { + return { + $: 6, + d: field, + b: decoder + }; + }); -function sortBy(f, xs) -{ - return fromArray(toArray(xs).sort(function(a, b) { - return _elm_lang$core$Native_Utils.cmp(f(a), f(b)); - })); -} + var _Json_decodeIndex = F2(function(index, decoder) { + return { + $: 7, + e: index, + b: decoder + }; + }); -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 _Json_decodeKeyValuePairs(decoder) { + return { + $: 8, + b: decoder + }; + } -return { - Nil: Nil, - Cons: Cons, - cons: F2(Cons), - toArray: toArray, - fromArray: fromArray, - - foldr: F3(foldr), - - map2: F3(map2), - map3: F4(map3), - map4: F5(map4), - map5: F6(map5), - sortBy: F2(sortBy), - sortWith: F2(sortWith) -}; - -}(); -var _elm_lang$core$List$sortWith = _elm_lang$core$Native_List.sortWith; -var _elm_lang$core$List$sortBy = _elm_lang$core$Native_List.sortBy; -var _elm_lang$core$List$sort = function (xs) { - return A2(_elm_lang$core$List$sortBy, _elm_lang$core$Basics$identity, xs); -}; -var _elm_lang$core$List$singleton = function (value) { - return { - ctor: '::', - _0: value, - _1: {ctor: '[]'} - }; -}; -var _elm_lang$core$List$drop = F2( - function (n, list) { - drop: - while (true) { - if (_elm_lang$core$Native_Utils.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 _elm_lang$core$List$map5 = _elm_lang$core$Native_List.map5; -var _elm_lang$core$List$map4 = _elm_lang$core$Native_List.map4; -var _elm_lang$core$List$map3 = _elm_lang$core$Native_List.map3; -var _elm_lang$core$List$map2 = _elm_lang$core$Native_List.map2; -var _elm_lang$core$List$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; - } + function _Json_mapMany(f, decoders) { + return { + $: 9, + f: f, + g: decoders + }; + } + + var _Json_andThen = F2(function(callback, decoder) { + return { + $: 10, + b: decoder, + h: callback + }; + }); + + function _Json_oneOf(decoders) { + return { + $: 11, + g: decoders + }; + } + + // DECODING OBJECTS + + var _Json_map1 = F2(function(f, d1) { + return _Json_mapMany(f, [d1]); + }); + + var _Json_map2 = F3(function(f, d1, d2) { + return _Json_mapMany(f, [d1, d2]); + }); + + var _Json_map3 = F4(function(f, d1, d2, d3) { + return _Json_mapMany(f, [d1, d2, d3]); + }); + + var _Json_map4 = F5(function(f, d1, d2, d3, d4) { + return _Json_mapMany(f, [d1, d2, d3, d4]); + }); + + var _Json_map5 = F6(function(f, d1, d2, d3, d4, d5) { + return _Json_mapMany(f, [d1, d2, d3, d4, d5]); + }); + + var _Json_map6 = F7(function(f, d1, d2, d3, d4, d5, d6) { + return _Json_mapMany(f, [d1, d2, d3, d4, d5, d6]); + }); + + var _Json_map7 = F8(function(f, d1, d2, d3, d4, d5, d6, d7) { + return _Json_mapMany(f, [d1, d2, d3, d4, d5, d6, d7]); + }); + + var _Json_map8 = F9(function(f, d1, d2, d3, d4, d5, d6, d7, d8) { + return _Json_mapMany(f, [d1, d2, d3, d4, d5, d6, d7, d8]); + }); + + // DECODE + + var _Json_runOnString = F2(function(decoder, string) { + try { + var value = JSON.parse(string); + return _Json_runHelp(decoder, value); + } catch (e) { + return $elm$core$Result$Err( + A2( + $elm$json$Json$Decode$Failure, + "This is not valid JSON! " + e.message, + _Json_wrap(string) + ) + ); + } + }); + + var _Json_run = F2(function(decoder, value) { + return _Json_runHelp(decoder, _Json_unwrap(value)); + }); + + function _Json_runHelp(decoder, value) { + switch (decoder.$) { + case 2: + return decoder.b(value); + + case 5: + return value === null + ? $elm$core$Result$Ok(decoder.c) + : _Json_expecting("null", value); + + case 3: + if (!_Json_isArray(value)) { + return _Json_expecting("a LIST", value); } - } - }); -var _elm_lang$core$List$all = F2( - function (isOkay, list) { - return !A2( - _elm_lang$core$List$any, - function (_p2) { - return !isOkay(_p2); - }, - list); - }); -var _elm_lang$core$List$foldr = _elm_lang$core$Native_List.foldr; -var _elm_lang$core$List$foldl = F3( - function (func, acc, list) { - foldl: - while (true) { - var _p3 = list; - if (_p3.ctor === '[]') { - return acc; - } else { - var _v7 = func, - _v8 = A2(func, _p3._0, acc), - _v9 = _p3._1; - func = _v7; - acc = _v8; - list = _v9; - continue foldl; + return _Json_runArrayDecoder(decoder.b, value, _List_fromArray); + + case 4: + if (!_Json_isArray(value)) { + return _Json_expecting("an ARRAY", value); } - } - }); -var _elm_lang$core$List$length = function (xs) { - return A3( - _elm_lang$core$List$foldl, - F2( - function (_p4, i) { - return i + 1; - }), - 0, - xs); -}; -var _elm_lang$core$List$sum = function (numbers) { - return A3( - _elm_lang$core$List$foldl, - F2( - function (x, y) { - return x + y; - }), - 0, - numbers); -}; -var _elm_lang$core$List$product = function (numbers) { - return A3( - _elm_lang$core$List$foldl, - F2( - function (x, y) { - return x * y; - }), - 1, - numbers); -}; -var _elm_lang$core$List$maximum = function (list) { - var _p5 = list; - if (_p5.ctor === '::') { - return _elm_lang$core$Maybe$Just( - A3(_elm_lang$core$List$foldl, _elm_lang$core$Basics$max, _p5._0, _p5._1)); - } else { - return _elm_lang$core$Maybe$Nothing; - } -}; -var _elm_lang$core$List$minimum = function (list) { - var _p6 = list; - if (_p6.ctor === '::') { - return _elm_lang$core$Maybe$Just( - A3(_elm_lang$core$List$foldl, _elm_lang$core$Basics$min, _p6._0, _p6._1)); - } else { - return _elm_lang$core$Maybe$Nothing; - } -}; -var _elm_lang$core$List$member = F2( - function (x, xs) { - return A2( - _elm_lang$core$List$any, - function (a) { - return _elm_lang$core$Native_Utils.eq(a, x); - }, - xs); - }); -var _elm_lang$core$List$isEmpty = function (xs) { - var _p7 = xs; - if (_p7.ctor === '[]') { - return true; - } else { - return false; - } -}; -var _elm_lang$core$List$tail = function (list) { - var _p8 = list; - if (_p8.ctor === '::') { - return _elm_lang$core$Maybe$Just(_p8._1); - } else { - return _elm_lang$core$Maybe$Nothing; - } -}; -var _elm_lang$core$List$head = function (list) { - var _p9 = list; - if (_p9.ctor === '::') { - return _elm_lang$core$Maybe$Just(_p9._0); - } else { - return _elm_lang$core$Maybe$Nothing; - } -}; -var _elm_lang$core$List_ops = _elm_lang$core$List_ops || {}; -_elm_lang$core$List_ops['::'] = _elm_lang$core$Native_List.cons; -var _elm_lang$core$List$map = F2( - function (f, xs) { - return A3( - _elm_lang$core$List$foldr, - F2( - function (x, acc) { - return { - ctor: '::', - _0: f(x), - _1: acc - }; - }), - {ctor: '[]'}, - xs); - }); -var _elm_lang$core$List$filter = F2( - function (pred, xs) { - var conditionalCons = F2( - function (front, back) { - return pred(front) ? {ctor: '::', _0: front, _1: back} : back; - }); - return A3( - _elm_lang$core$List$foldr, - conditionalCons, - {ctor: '[]'}, - xs); - }); -var _elm_lang$core$List$maybeCons = F3( - function (f, mx, xs) { - var _p10 = f(mx); - if (_p10.ctor === 'Just') { - return {ctor: '::', _0: _p10._0, _1: xs}; - } else { - return xs; - } - }); -var _elm_lang$core$List$filterMap = F2( - function (f, xs) { - return A3( - _elm_lang$core$List$foldr, - _elm_lang$core$List$maybeCons(f), - {ctor: '[]'}, - xs); - }); -var _elm_lang$core$List$reverse = function (list) { - return A3( - _elm_lang$core$List$foldl, - F2( - function (x, y) { - return {ctor: '::', _0: x, _1: y}; - }), - {ctor: '[]'}, - list); -}; -var _elm_lang$core$List$scanl = F3( - function (f, b, xs) { - var scan1 = F2( - function (x, accAcc) { - var _p11 = accAcc; - if (_p11.ctor === '::') { - return { - ctor: '::', - _0: A2(f, x, _p11._0), - _1: accAcc - }; - } else { - return {ctor: '[]'}; - } - }); - return _elm_lang$core$List$reverse( - A3( - _elm_lang$core$List$foldl, - scan1, - { - ctor: '::', - _0: b, - _1: {ctor: '[]'} - }, - xs)); - }); -var _elm_lang$core$List$append = F2( - function (xs, ys) { - var _p12 = ys; - if (_p12.ctor === '[]') { - return xs; - } else { - return A3( - _elm_lang$core$List$foldr, - F2( - function (x, y) { - return {ctor: '::', _0: x, _1: y}; - }), - ys, - xs); - } - }); -var _elm_lang$core$List$concat = function (lists) { - return A3( - _elm_lang$core$List$foldr, - _elm_lang$core$List$append, - {ctor: '[]'}, - lists); -}; -var _elm_lang$core$List$concatMap = F2( - function (f, list) { - return _elm_lang$core$List$concat( - A2(_elm_lang$core$List$map, f, list)); - }); -var _elm_lang$core$List$partition = F2( - function (pred, list) { - var step = F2( - function (x, _p13) { - var _p14 = _p13; - var _p16 = _p14._0; - var _p15 = _p14._1; - return pred(x) ? { - ctor: '_Tuple2', - _0: {ctor: '::', _0: x, _1: _p16}, - _1: _p15 - } : { - ctor: '_Tuple2', - _0: _p16, - _1: {ctor: '::', _0: x, _1: _p15} - }; - }); - return A3( - _elm_lang$core$List$foldr, - step, - { - ctor: '_Tuple2', - _0: {ctor: '[]'}, - _1: {ctor: '[]'} - }, - list); - }); -var _elm_lang$core$List$unzip = function (pairs) { - var step = F2( - function (_p18, _p17) { - var _p19 = _p18; - var _p20 = _p17; - return { - ctor: '_Tuple2', - _0: {ctor: '::', _0: _p19._0, _1: _p20._0}, - _1: {ctor: '::', _0: _p19._1, _1: _p20._1} - }; - }); - return A3( - _elm_lang$core$List$foldr, - step, - { - ctor: '_Tuple2', - _0: {ctor: '[]'}, - _1: {ctor: '[]'} - }, - pairs); -}; -var _elm_lang$core$List$intersperse = F2( - function (sep, xs) { - var _p21 = xs; - if (_p21.ctor === '[]') { - return {ctor: '[]'}; - } else { - var step = F2( - function (x, rest) { - return { - ctor: '::', - _0: sep, - _1: {ctor: '::', _0: x, _1: rest} - }; - }); - var spersed = A3( - _elm_lang$core$List$foldr, - step, - {ctor: '[]'}, - _p21._1); - return {ctor: '::', _0: _p21._0, _1: spersed}; - } - }); -var _elm_lang$core$List$takeReverse = F3( - function (n, list, taken) { - takeReverse: - while (true) { - if (_elm_lang$core$Native_Utils.cmp(n, 0) < 1) { - return taken; - } else { - var _p22 = list; - if (_p22.ctor === '[]') { - return taken; - } else { - var _v23 = n - 1, - _v24 = _p22._1, - _v25 = {ctor: '::', _0: _p22._0, _1: taken}; - n = _v23; - list = _v24; - taken = _v25; - continue takeReverse; - } + return _Json_runArrayDecoder( + decoder.b, + value, + _Json_toElmArray + ); + + case 6: + var field = decoder.d; + if ( + typeof value !== "object" || + value === null || + !(field in value) + ) { + return _Json_expecting( + "an OBJECT with a field named `" + field + "`", + value + ); } - } - }); -var _elm_lang$core$List$takeTailRec = F2( - function (n, list) { - return _elm_lang$core$List$reverse( - A3( - _elm_lang$core$List$takeReverse, - n, - list, - {ctor: '[]'})); - }); -var _elm_lang$core$List$takeFast = F3( - function (ctr, n, list) { - if (_elm_lang$core$Native_Utils.cmp(n, 0) < 1) { - return {ctor: '[]'}; - } else { - var _p23 = {ctor: '_Tuple2', _0: n, _1: list}; - _v26_5: - do { - _v26_1: - do { - if (_p23.ctor === '_Tuple2') { - if (_p23._1.ctor === '[]') { - return list; - } else { - if (_p23._1._1.ctor === '::') { - switch (_p23._0) { - case 1: - break _v26_1; - case 2: - return { - ctor: '::', - _0: _p23._1._0, - _1: { - ctor: '::', - _0: _p23._1._1._0, - _1: {ctor: '[]'} - } - }; - case 3: - if (_p23._1._1._1.ctor === '::') { - return { - ctor: '::', - _0: _p23._1._0, - _1: { - ctor: '::', - _0: _p23._1._1._0, - _1: { - ctor: '::', - _0: _p23._1._1._1._0, - _1: {ctor: '[]'} - } - } - }; - } else { - break _v26_5; - } - default: - if ((_p23._1._1._1.ctor === '::') && (_p23._1._1._1._1.ctor === '::')) { - var _p28 = _p23._1._1._1._0; - var _p27 = _p23._1._1._0; - var _p26 = _p23._1._0; - var _p25 = _p23._1._1._1._1._0; - var _p24 = _p23._1._1._1._1._1; - return (_elm_lang$core$Native_Utils.cmp(ctr, 1000) > 0) ? { - ctor: '::', - _0: _p26, - _1: { - ctor: '::', - _0: _p27, - _1: { - ctor: '::', - _0: _p28, - _1: { - ctor: '::', - _0: _p25, - _1: A2(_elm_lang$core$List$takeTailRec, n - 4, _p24) - } - } - } - } : { - ctor: '::', - _0: _p26, - _1: { - ctor: '::', - _0: _p27, - _1: { - ctor: '::', - _0: _p28, - _1: { - ctor: '::', - _0: _p25, - _1: A3(_elm_lang$core$List$takeFast, ctr + 1, n - 4, _p24) - } - } - } - }; - } else { - break _v26_5; - } - } - } else { - if (_p23._0 === 1) { - break _v26_1; - } else { - break _v26_5; - } - } - } - } else { - break _v26_5; - } - } while(false); - return { - ctor: '::', - _0: _p23._1._0, - _1: {ctor: '[]'} - }; - } while(false); - return list; - } - }); -var _elm_lang$core$List$take = F2( - function (n, list) { - return A3(_elm_lang$core$List$takeFast, 0, n, list); - }); -var _elm_lang$core$List$repeatHelp = F3( - function (result, n, value) { - repeatHelp: - while (true) { - if (_elm_lang$core$Native_Utils.cmp(n, 0) < 1) { - return result; - } else { - var _v27 = {ctor: '::', _0: value, _1: result}, - _v28 = n - 1, - _v29 = value; - result = _v27; - n = _v28; - value = _v29; - continue repeatHelp; + var result = _Json_runHelp(decoder.b, value[field]); + return $elm$core$Result$isOk(result) + ? result + : $elm$core$Result$Err( + A2($elm$json$Json$Decode$Field, field, result.a) + ); + + case 7: + var index = decoder.e; + if (!_Json_isArray(value)) { + return _Json_expecting("an ARRAY", value); } - } - }); -var _elm_lang$core$List$repeat = F2( - function (n, value) { - return A3( - _elm_lang$core$List$repeatHelp, - {ctor: '[]'}, - n, - value); - }); -var _elm_lang$core$List$rangeHelp = F3( - function (lo, hi, list) { - rangeHelp: - while (true) { - if (_elm_lang$core$Native_Utils.cmp(lo, hi) < 1) { - var _v30 = lo, - _v31 = hi - 1, - _v32 = {ctor: '::', _0: hi, _1: list}; - lo = _v30; - hi = _v31; - list = _v32; - continue rangeHelp; - } else { - return list; + if (index >= value.length) { + return _Json_expecting( + "a LONGER array. Need index " + + index + + " but only see " + + value.length + + " entries", + value + ); } - } - }); -var _elm_lang$core$List$range = F2( - function (lo, hi) { - return A3( - _elm_lang$core$List$rangeHelp, - lo, - hi, - {ctor: '[]'}); - }); -var _elm_lang$core$List$indexedMap = F2( - function (f, xs) { - return A3( - _elm_lang$core$List$map2, - f, - A2( - _elm_lang$core$List$range, - 0, - _elm_lang$core$List$length(xs) - 1), - xs); - }); - -var _elm_lang$core$Result$toMaybe = function (result) { - var _p0 = result; - if (_p0.ctor === 'Ok') { - return _elm_lang$core$Maybe$Just(_p0._0); - } else { - return _elm_lang$core$Maybe$Nothing; - } -}; -var _elm_lang$core$Result$withDefault = F2( - function (def, result) { - var _p1 = result; - if (_p1.ctor === 'Ok') { - return _p1._0; - } else { - return def; - } - }); -var _elm_lang$core$Result$Err = function (a) { - return {ctor: 'Err', _0: a}; -}; -var _elm_lang$core$Result$andThen = F2( - function (callback, result) { - var _p2 = result; - if (_p2.ctor === 'Ok') { - return callback(_p2._0); - } else { - return _elm_lang$core$Result$Err(_p2._0); - } - }); -var _elm_lang$core$Result$Ok = function (a) { - return {ctor: 'Ok', _0: a}; -}; -var _elm_lang$core$Result$map = F2( - function (func, ra) { - var _p3 = ra; - if (_p3.ctor === 'Ok') { - return _elm_lang$core$Result$Ok( - func(_p3._0)); - } else { - return _elm_lang$core$Result$Err(_p3._0); - } - }); -var _elm_lang$core$Result$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 _elm_lang$core$Result$Ok( - A2(func, _p4._0._0, _p4._1._0)); - } else { - return _elm_lang$core$Result$Err(_p4._1._0); + var result = _Json_runHelp(decoder.b, value[index]); + return $elm$core$Result$isOk(result) + ? result + : $elm$core$Result$Err( + A2($elm$json$Json$Decode$Index, index, result.a) + ); + + case 8: + if ( + typeof value !== "object" || + value === null || + _Json_isArray(value) + ) { + return _Json_expecting("an OBJECT", value); } - } else { - return _elm_lang$core$Result$Err(_p4._0._0); - } - }); -var _elm_lang$core$Result$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 _elm_lang$core$Result$Ok( - A3(func, _p5._0._0, _p5._1._0, _p5._2._0)); - } else { - return _elm_lang$core$Result$Err(_p5._2._0); + + var keyValuePairs = _List_Nil; + // TODO test perf of Object.keys and switch when support is good enough + for (var key in value) { + if (value.hasOwnProperty(key)) { + var result = _Json_runHelp(decoder.b, value[key]); + if (!$elm$core$Result$isOk(result)) { + return $elm$core$Result$Err( + A2($elm$json$Json$Decode$Field, key, result.a) + ); } - } else { - return _elm_lang$core$Result$Err(_p5._1._0); + keyValuePairs = _List_Cons( + _Utils_Tuple2(key, result.a), + keyValuePairs + ); + } } - } else { - return _elm_lang$core$Result$Err(_p5._0._0); - } - }); -var _elm_lang$core$Result$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 _elm_lang$core$Result$Ok( - A4(func, _p6._0._0, _p6._1._0, _p6._2._0, _p6._3._0)); - } else { - return _elm_lang$core$Result$Err(_p6._3._0); - } - } else { - return _elm_lang$core$Result$Err(_p6._2._0); - } - } else { - return _elm_lang$core$Result$Err(_p6._1._0); + return $elm$core$Result$Ok( + $elm$core$List$reverse(keyValuePairs) + ); + + case 9: + var answer = decoder.f; + var decoders = decoder.g; + for (var i = 0; i < decoders.length; i++) { + var result = _Json_runHelp(decoders[i], value); + if (!$elm$core$Result$isOk(result)) { + return result; + } + answer = answer(result.a); } - } else { - return _elm_lang$core$Result$Err(_p6._0._0); - } - }); -var _elm_lang$core$Result$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 _elm_lang$core$Result$Ok( - A5(func, _p7._0._0, _p7._1._0, _p7._2._0, _p7._3._0, _p7._4._0)); - } else { - return _elm_lang$core$Result$Err(_p7._4._0); - } - } else { - return _elm_lang$core$Result$Err(_p7._3._0); - } - } else { - return _elm_lang$core$Result$Err(_p7._2._0); - } - } else { - return _elm_lang$core$Result$Err(_p7._1._0); + return $elm$core$Result$Ok(answer); + + case 10: + var result = _Json_runHelp(decoder.b, value); + return !$elm$core$Result$isOk(result) + ? result + : _Json_runHelp(decoder.h(result.a), value); + + case 11: + var errors = _List_Nil; + for ( + var temp = decoder.g; + temp.b; + temp = temp.b // WHILE_CONS + ) { + var result = _Json_runHelp(temp.a, value); + if ($elm$core$Result$isOk(result)) { + return result; + } + errors = _List_Cons(result.a, errors); } - } else { - return _elm_lang$core$Result$Err(_p7._0._0); - } - }); -var _elm_lang$core$Result$mapError = F2( - function (f, result) { - var _p8 = result; - if (_p8.ctor === 'Ok') { - return _elm_lang$core$Result$Ok(_p8._0); - } else { - return _elm_lang$core$Result$Err( - f(_p8._0)); - } - }); -var _elm_lang$core$Result$fromMaybe = F2( - function (err, maybe) { - var _p9 = maybe; - if (_p9.ctor === 'Just') { - return _elm_lang$core$Result$Ok(_p9._0); - } else { - return _elm_lang$core$Result$Err(err); - } - }); + return $elm$core$Result$Err( + $elm$json$Json$Decode$OneOf($elm$core$List$reverse(errors)) + ); -//import Maybe, Native.List, Native.Utils, Result // + case 1: + return $elm$core$Result$Err( + A2( + $elm$json$Json$Decode$Failure, + decoder.a, + _Json_wrap(value) + ) + ); -var _elm_lang$core$Native_String = function() { + case 0: + return $elm$core$Result$Ok(decoder.a); + } + } -function isEmpty(str) -{ - return str.length === 0; -} -function cons(chr, str) -{ - return chr + str; -} -function uncons(str) -{ - var hd = str[0]; - if (hd) - { - return _elm_lang$core$Maybe$Just(_elm_lang$core$Native_Utils.Tuple2(_elm_lang$core$Native_Utils.chr(hd), str.slice(1))); - } - return _elm_lang$core$Maybe$Nothing; -} -function append(a, b) -{ - return a + b; -} -function concat(strs) -{ - return _elm_lang$core$Native_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(_elm_lang$core$Native_Utils.chr(out[i])); - } - return out.join(''); -} -function filter(pred, str) -{ - return str.split('').map(_elm_lang$core$Native_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, _elm_lang$core$Native_Utils.chr(str[i]), b); - } - return b; -} -function foldr(f, b, str) -{ - for (var i = str.length; i--; ) - { - b = A2(f, _elm_lang$core$Native_Utils.chr(str[i]), b); - } - return b; -} -function split(sep, str) -{ - return _elm_lang$core$Native_List.fromArray(str.split(sep)); -} -function join(sep, strs) -{ - return _elm_lang$core$Native_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 _Json_runArrayDecoder(decoder, value, toElmValue) { + var len = value.length; + var array = new Array(len); + for (var i = 0; i < len; i++) { + var result = _Json_runHelp(decoder, value[i]); + if (!$elm$core$Result$isOk(result)) { + return $elm$core$Result$Err( + A2($elm$json$Json$Decode$Index, i, result.a) + ); + } + array[i] = result.a; + } + return $elm$core$Result$Ok(toElmValue(array)); + } -function trim(str) -{ - return str.trim(); -} -function trimLeft(str) -{ - return str.replace(/^\s+/, ''); -} -function trimRight(str) -{ - return str.replace(/\s+$/, ''); -} + function _Json_isArray(value) { + return ( + Array.isArray(value) || + (typeof FileList !== "undefined" && value instanceof FileList) + ); + } -function words(str) -{ - return _elm_lang$core$Native_List.fromArray(str.trim().split(/\s+/g)); -} -function lines(str) -{ - return _elm_lang$core$Native_List.fromArray(str.split(/\r\n|\r|\n/g)); -} + function _Json_toElmArray(array) { + return A2($elm$core$Array$initialize, array.length, function(i) { + return array[i]; + }); + } + + function _Json_expecting(type, value) { + return $elm$core$Result$Err( + A2( + $elm$json$Json$Decode$Failure, + "Expecting " + type, + _Json_wrap(value) + ) + ); + } -function toUpper(str) -{ - return str.toUpperCase(); -} -function toLower(str) -{ - return str.toLowerCase(); -} + // EQUALITY -function any(pred, str) -{ - for (var i = str.length; i--; ) - { - if (pred(_elm_lang$core$Native_Utils.chr(str[i]))) - { - return true; + function _Json_equality(x, y) { + if (x === y) { + return true; } - } - return false; -} -function all(pred, str) -{ - for (var i = str.length; i--; ) - { - if (!pred(_elm_lang$core$Native_Utils.chr(str[i]))) - { - return false; + + if (x.$ !== y.$) { + 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; + switch (x.$) { + case 0: + case 1: + return x.a === y.a; - if (subLen < 1) - { - return _elm_lang$core$Native_List.Nil; - } + case 2: + return x.b === y.b; - var i = 0; - var is = []; + case 5: + return x.c === y.c; - while ((i = str.indexOf(sub, i)) > -1) - { - is.push(i); - i = i + subLen; - } + case 3: + case 4: + case 8: + return _Json_equality(x.b, y.b); - return _elm_lang$core$Native_List.fromArray(is); -} + case 6: + return x.d === y.d && _Json_equality(x.b, y.b); + case 7: + return x.e === y.e && _Json_equality(x.b, y.b); -function toInt(s) -{ - var len = s.length; - - // if empty - if (len === 0) - { - return intErr(s); - } - - // if hex - var c = s[0]; - if (c === '0' && s[1] === 'x') - { - for (var i = 2; i < len; ++i) - { - var c = s[i]; - if (('0' <= c && c <= '9') || ('A' <= c && c <= 'F') || ('a' <= c && c <= 'f')) - { - continue; - } - return intErr(s); - } - return _elm_lang$core$Result$Ok(parseInt(s, 16)); - } - - // is decimal - if (c > '9' || (c < '0' && c !== '-' && c !== '+')) - { - return intErr(s); - } - for (var i = 1; i < len; ++i) - { - var c = s[i]; - if (c < '0' || '9' < c) - { - return intErr(s); - } - } - - return _elm_lang$core$Result$Ok(parseInt(s, 10)); -} + case 9: + return x.f === y.f && _Json_listEquality(x.g, y.g); -function intErr(s) -{ - return _elm_lang$core$Result$Err("could not convert string '" + s + "' to an Int"); -} + case 10: + return x.h === y.h && _Json_equality(x.b, y.b); + case 11: + return _Json_listEquality(x.g, y.g); + } + } -function toFloat(s) -{ - // check if it is a hex, octal, or binary number - if (s.length === 0 || /[\sxbo]/.test(s)) - { - return floatErr(s); - } - var n = +s; - // faster isNaN check - return n === n ? _elm_lang$core$Result$Ok(n) : floatErr(s); -} + function _Json_listEquality(aDecoders, bDecoders) { + var len = aDecoders.length; + if (len !== bDecoders.length) { + return false; + } + for (var i = 0; i < len; i++) { + if (!_Json_equality(aDecoders[i], bDecoders[i])) { + return false; + } + } + return true; + } + + // ENCODE + + var _Json_encode = F2(function(indentLevel, value) { + return JSON.stringify(_Json_unwrap(value), null, indentLevel) + ""; + }); + + function _Json_wrap(value) { + return { $: 0, a: value }; + } + function _Json_unwrap(value) { + return value.a; + } + + function _Json_wrap_UNUSED(value) { + return value; + } + function _Json_unwrap_UNUSED(value) { + return value; + } + + function _Json_emptyArray() { + return []; + } + function _Json_emptyObject() { + return {}; + } + + var _Json_addField = F3(function(key, value, object) { + object[key] = _Json_unwrap(value); + return object; + }); + + function _Json_addEntry(func) { + return F2(function(entry, array) { + array.push(_Json_unwrap(func(entry))); + return array; + }); + } -function floatErr(s) -{ - return _elm_lang$core$Result$Err("could not convert string '" + s + "' to a Float"); -} + var _Json_encodeNull = _Json_wrap(null); + // TASKS -function toList(str) -{ - return _elm_lang$core$Native_List.fromArray(str.split('').map(_elm_lang$core$Native_Utils.chr)); -} -function fromList(chars) -{ - return _elm_lang$core$Native_List.toArray(chars).join(''); -} + function _Scheduler_succeed(value) { + return { + $: 0, + a: value + }; + } -return { - 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 -}; - -}(); - -//import Native.Utils // - -var _elm_lang$core$Native_Char = function() { - -return { - fromCode: function(c) { return _elm_lang$core$Native_Utils.chr(String.fromCharCode(c)); }, - toCode: function(c) { return c.charCodeAt(0); }, - toUpper: function(c) { return _elm_lang$core$Native_Utils.chr(c.toUpperCase()); }, - toLower: function(c) { return _elm_lang$core$Native_Utils.chr(c.toLowerCase()); }, - toLocaleUpper: function(c) { return _elm_lang$core$Native_Utils.chr(c.toLocaleUpperCase()); }, - toLocaleLower: function(c) { return _elm_lang$core$Native_Utils.chr(c.toLocaleLowerCase()); } -}; - -}(); -var _elm_lang$core$Char$fromCode = _elm_lang$core$Native_Char.fromCode; -var _elm_lang$core$Char$toCode = _elm_lang$core$Native_Char.toCode; -var _elm_lang$core$Char$toLocaleLower = _elm_lang$core$Native_Char.toLocaleLower; -var _elm_lang$core$Char$toLocaleUpper = _elm_lang$core$Native_Char.toLocaleUpper; -var _elm_lang$core$Char$toLower = _elm_lang$core$Native_Char.toLower; -var _elm_lang$core$Char$toUpper = _elm_lang$core$Native_Char.toUpper; -var _elm_lang$core$Char$isBetween = F3( - function (low, high, $char) { - var code = _elm_lang$core$Char$toCode($char); - return (_elm_lang$core$Native_Utils.cmp( - code, - _elm_lang$core$Char$toCode(low)) > -1) && (_elm_lang$core$Native_Utils.cmp( - code, - _elm_lang$core$Char$toCode(high)) < 1); - }); -var _elm_lang$core$Char$isUpper = A2( - _elm_lang$core$Char$isBetween, - _elm_lang$core$Native_Utils.chr('A'), - _elm_lang$core$Native_Utils.chr('Z')); -var _elm_lang$core$Char$isLower = A2( - _elm_lang$core$Char$isBetween, - _elm_lang$core$Native_Utils.chr('a'), - _elm_lang$core$Native_Utils.chr('z')); -var _elm_lang$core$Char$isDigit = A2( - _elm_lang$core$Char$isBetween, - _elm_lang$core$Native_Utils.chr('0'), - _elm_lang$core$Native_Utils.chr('9')); -var _elm_lang$core$Char$isOctDigit = A2( - _elm_lang$core$Char$isBetween, - _elm_lang$core$Native_Utils.chr('0'), - _elm_lang$core$Native_Utils.chr('7')); -var _elm_lang$core$Char$isHexDigit = function ($char) { - return _elm_lang$core$Char$isDigit($char) || (A3( - _elm_lang$core$Char$isBetween, - _elm_lang$core$Native_Utils.chr('a'), - _elm_lang$core$Native_Utils.chr('f'), - $char) || A3( - _elm_lang$core$Char$isBetween, - _elm_lang$core$Native_Utils.chr('A'), - _elm_lang$core$Native_Utils.chr('F'), - $char)); -}; - -var _elm_lang$core$String$fromList = _elm_lang$core$Native_String.fromList; -var _elm_lang$core$String$toList = _elm_lang$core$Native_String.toList; -var _elm_lang$core$String$toFloat = _elm_lang$core$Native_String.toFloat; -var _elm_lang$core$String$toInt = _elm_lang$core$Native_String.toInt; -var _elm_lang$core$String$indices = _elm_lang$core$Native_String.indexes; -var _elm_lang$core$String$indexes = _elm_lang$core$Native_String.indexes; -var _elm_lang$core$String$endsWith = _elm_lang$core$Native_String.endsWith; -var _elm_lang$core$String$startsWith = _elm_lang$core$Native_String.startsWith; -var _elm_lang$core$String$contains = _elm_lang$core$Native_String.contains; -var _elm_lang$core$String$all = _elm_lang$core$Native_String.all; -var _elm_lang$core$String$any = _elm_lang$core$Native_String.any; -var _elm_lang$core$String$toLower = _elm_lang$core$Native_String.toLower; -var _elm_lang$core$String$toUpper = _elm_lang$core$Native_String.toUpper; -var _elm_lang$core$String$lines = _elm_lang$core$Native_String.lines; -var _elm_lang$core$String$words = _elm_lang$core$Native_String.words; -var _elm_lang$core$String$trimRight = _elm_lang$core$Native_String.trimRight; -var _elm_lang$core$String$trimLeft = _elm_lang$core$Native_String.trimLeft; -var _elm_lang$core$String$trim = _elm_lang$core$Native_String.trim; -var _elm_lang$core$String$padRight = _elm_lang$core$Native_String.padRight; -var _elm_lang$core$String$padLeft = _elm_lang$core$Native_String.padLeft; -var _elm_lang$core$String$pad = _elm_lang$core$Native_String.pad; -var _elm_lang$core$String$dropRight = _elm_lang$core$Native_String.dropRight; -var _elm_lang$core$String$dropLeft = _elm_lang$core$Native_String.dropLeft; -var _elm_lang$core$String$right = _elm_lang$core$Native_String.right; -var _elm_lang$core$String$left = _elm_lang$core$Native_String.left; -var _elm_lang$core$String$slice = _elm_lang$core$Native_String.slice; -var _elm_lang$core$String$repeat = _elm_lang$core$Native_String.repeat; -var _elm_lang$core$String$join = _elm_lang$core$Native_String.join; -var _elm_lang$core$String$split = _elm_lang$core$Native_String.split; -var _elm_lang$core$String$foldr = _elm_lang$core$Native_String.foldr; -var _elm_lang$core$String$foldl = _elm_lang$core$Native_String.foldl; -var _elm_lang$core$String$reverse = _elm_lang$core$Native_String.reverse; -var _elm_lang$core$String$filter = _elm_lang$core$Native_String.filter; -var _elm_lang$core$String$map = _elm_lang$core$Native_String.map; -var _elm_lang$core$String$length = _elm_lang$core$Native_String.length; -var _elm_lang$core$String$concat = _elm_lang$core$Native_String.concat; -var _elm_lang$core$String$append = _elm_lang$core$Native_String.append; -var _elm_lang$core$String$uncons = _elm_lang$core$Native_String.uncons; -var _elm_lang$core$String$cons = _elm_lang$core$Native_String.cons; -var _elm_lang$core$String$fromChar = function ($char) { - return A2(_elm_lang$core$String$cons, $char, ''); -}; -var _elm_lang$core$String$isEmpty = _elm_lang$core$Native_String.isEmpty; - -var _elm_lang$core$Tuple$mapSecond = F2( - function (func, _p0) { - var _p1 = _p0; + function _Scheduler_fail(error) { return { - ctor: '_Tuple2', - _0: _p1._0, - _1: func(_p1._1) + $: 1, + a: error }; - }); -var _elm_lang$core$Tuple$mapFirst = F2( - function (func, _p2) { - var _p3 = _p2; + } + + function _Scheduler_binding(callback) { return { - ctor: '_Tuple2', - _0: func(_p3._0), - _1: _p3._1 + $: 2, + b: callback, + c: null }; - }); -var _elm_lang$core$Tuple$second = function (_p4) { - var _p5 = _p4; - return _p5._1; -}; -var _elm_lang$core$Tuple$first = function (_p6) { - var _p7 = _p6; - return _p7._0; -}; + } -//import // + var _Scheduler_andThen = F2(function(callback, task) { + return { + $: 3, + b: callback, + d: task + }; + }); -var _elm_lang$core$Native_Platform = function() { + var _Scheduler_onError = F2(function(callback, task) { + return { + $: 4, + b: callback, + d: task + }; + }); - -// PROGRAMS - -function program(impl) -{ - return function(flagDecoder) - { - return function(object, moduleName) - { - object['worker'] = function worker(flags) - { - if (typeof flags !== 'undefined') - { - throw new Error( - 'The `' + moduleName + '` module does not need flags.\n' - + 'Call ' + moduleName + '.worker() with no arguments and you should be all set!' - ); - } - - return initialize( - impl.init, - impl.update, - impl.subscriptions, - renderer - ); - }; + function _Scheduler_receive(callback) { + return { + $: 5, + b: callback }; - }; -} + } -function programWithFlags(impl) -{ - return function(flagDecoder) - { - return function(object, moduleName) - { - object['worker'] = function worker(flags) - { - if (typeof flagDecoder === 'undefined') - { - throw new Error( - 'Are you trying to sneak a Never value into Elm? Trickster!\n' - + 'It looks like ' + moduleName + '.main is defined with `programWithFlags` but has type `Program Never`.\n' - + 'Use `program` instead if you do not want flags.' - ); - } + // PROCESSES - var result = A2(_elm_lang$core$Native_Json.run, flagDecoder, flags); - if (result.ctor === 'Err') - { - throw new Error( - moduleName + '.worker(...) was called with an unexpected argument.\n' - + 'I tried to convert it to an Elm value, but ran into this problem:\n\n' - + result._0 - ); - } + var _Scheduler_guid = 0; - return initialize( - impl.init(result._0), - impl.update, - impl.subscriptions, - renderer - ); - }; + function _Scheduler_rawSpawn(task) { + var proc = { + $: 0, + e: _Scheduler_guid++, + f: task, + g: null, + h: [] }; - }; -} - -function renderer(enqueue, _) -{ - return function(_) {}; -} - -// HTML TO PROGRAM + _Scheduler_enqueue(proc); -function htmlToProgram(vnode) -{ - var emptyBag = batch(_elm_lang$core$Native_List.Nil); - var noChange = _elm_lang$core$Native_Utils.Tuple2( - _elm_lang$core$Native_Utils.Tuple0, - emptyBag - ); - - return _elm_lang$virtual_dom$VirtualDom$program({ - init: noChange, - view: function(model) { return main; }, - update: F2(function(msg, model) { return noChange; }), - subscriptions: function (model) { return emptyBag; } - }); -} + return proc; + } + function _Scheduler_spawn(task) { + return _Scheduler_binding(function(callback) { + callback(_Scheduler_succeed(_Scheduler_rawSpawn(task))); + }); + } -// INITIALIZE A PROGRAM + function _Scheduler_rawSend(proc, msg) { + proc.h.push(msg); + _Scheduler_enqueue(proc); + } -function initialize(init, update, subscriptions, renderer) -{ - // ambient state - var managers = {}; - var updateView; - - // init and update state in main process - var initApp = _elm_lang$core$Native_Scheduler.nativeBinding(function(callback) { - var model = init._0; - updateView = renderer(enqueue, model); - var cmds = init._1; - var subs = subscriptions(model); - dispatchEffects(managers, cmds, subs); - callback(_elm_lang$core$Native_Scheduler.succeed(model)); - }); - - function onMessage(msg, model) - { - return _elm_lang$core$Native_Scheduler.nativeBinding(function(callback) { - var results = A2(update, msg, model); - model = results._0; - updateView(model); - var cmds = results._1; - var subs = subscriptions(model); - dispatchEffects(managers, cmds, subs); - callback(_elm_lang$core$Native_Scheduler.succeed(model)); + var _Scheduler_send = F2(function(proc, msg) { + return _Scheduler_binding(function(callback) { + _Scheduler_rawSend(proc, msg); + callback(_Scheduler_succeed(_Utils_Tuple0)); }); - } + }); - var mainProcess = spawnLoop(initApp, onMessage); + function _Scheduler_kill(proc) { + return _Scheduler_binding(function(callback) { + var task = proc.f; + if (task.$ === 2 && task.c) { + task.c(); + } - function enqueue(msg) - { - _elm_lang$core$Native_Scheduler.rawSend(mainProcess, msg); - } + proc.f = null; + + callback(_Scheduler_succeed(_Utils_Tuple0)); + }); + } - var ports = setupEffects(managers, enqueue); + /* STEP PROCESSES - return ports ? { ports: ports } : {}; +type alias Process = +{ $ : tag +, id : unique_id +, root : Task +, stack : null | { $: SUCCEED | FAIL, a: callback, b: stack } +, mailbox : [msg] } +*/ -// EFFECT MANAGERS + var _Scheduler_working = false; + var _Scheduler_queue = []; -var effectManagers = {}; + function _Scheduler_enqueue(proc) { + _Scheduler_queue.push(proc); + if (_Scheduler_working) { + return; + } + _Scheduler_working = true; + while ((proc = _Scheduler_queue.shift())) { + _Scheduler_step(proc); + } + _Scheduler_working = false; + } -function setupEffects(managers, callback) -{ - var ports; + function _Scheduler_step(proc) { + while (proc.f) { + var rootTag = proc.f.$; + if (rootTag === 0 || rootTag === 1) { + while (proc.g && proc.g.$ !== rootTag) { + proc.g = proc.g.i; + } + if (!proc.g) { + return; + } + proc.f = proc.g.b(proc.f.a); + proc.g = proc.g.i; + } else if (rootTag === 2) { + proc.f.c = proc.f.b(function(newRoot) { + proc.f = newRoot; + _Scheduler_enqueue(proc); + }); + return; + } else if (rootTag === 5) { + if (proc.h.length === 0) { + return; + } + proc.f = proc.f.b(proc.h.shift()); + } // if (rootTag === 3 || rootTag === 4) + else { + proc.g = { + $: rootTag === 3 ? 0 : 1, + b: proc.f.b, + i: proc.g + }; + proc.f = proc.f.d; + } + } + } - // setup all necessary effect managers - for (var key in effectManagers) - { - var manager = effectManagers[key]; + function _Process_sleep(time) { + return _Scheduler_binding(function(callback) { + var id = setTimeout(function() { + callback(_Scheduler_succeed(_Utils_Tuple0)); + }, time); - if (manager.isForeign) - { - ports = ports || {}; - ports[key] = manager.tag === 'cmd' - ? setupOutgoingPort(key) - : setupIncomingPort(key, callback); - } + return function() { + clearTimeout(id); + }; + }); + } + + // PROGRAMS + + var _Platform_worker = F4(function( + impl, + flagDecoder, + debugMetadata, + args + ) { + return _Platform_initialize( + flagDecoder, + args, + impl.init, + impl.update, + impl.subscriptions, + function() { + return function() {}; + } + ); + }); + + // INITIALIZE A PROGRAM + + function _Platform_initialize( + flagDecoder, + args, + init, + update, + subscriptions, + stepperBuilder + ) { + var result = A2( + _Json_run, + flagDecoder, + _Json_wrap(args ? args["flags"] : undefined) + ); + $elm$core$Result$isOk(result) || + _Debug_crash(2 /**/, _Json_errorToString(result.a) /**/); + var managers = {}; + result = init(result.a); + var model = result.a; + var stepper = stepperBuilder(sendToApp, model); + var ports = _Platform_setupEffects(managers, sendToApp); - managers[key] = makeManager(manager, callback); - } + function sendToApp(msg, viewMetadata) { + result = A2(update, msg, model); + stepper((model = result.a), viewMetadata); + _Platform_dispatchEffects( + managers, + result.b, + subscriptions(model) + ); + } - return ports; -} + _Platform_dispatchEffects(managers, result.b, subscriptions(model)); -function makeManager(info, callback) -{ - var router = { - main: callback, - self: undefined - }; + return ports ? { ports: ports } : {}; + } - var tag = info.tag; - var onEffects = info.onEffects; - var onSelfMsg = info.onSelfMsg; + // TRACK PRELOADS + // + // This is used by code in elm/browser and elm/http + // to register any HTTP requests that are triggered by init. + // - function onMessage(msg, state) - { - if (msg.ctor === 'self') - { - return A3(onSelfMsg, router, msg._0, state); - } + var _Platform_preload; - var fx = msg._0; - switch (tag) - { - case 'cmd': - return A3(onEffects, router, fx.cmds, state); + function _Platform_registerPreload(url) { + _Platform_preload.add(url); + } - case 'sub': - return A3(onEffects, router, fx.subs, state); + // EFFECT MANAGERS - case 'fx': - return A4(onEffects, router, fx.cmds, fx.subs, state); - } - } + var _Platform_effectManagers = {}; - var process = spawnLoop(info.init, onMessage); - router.self = process; - return process; -} + function _Platform_setupEffects(managers, sendToApp) { + var ports; -function sendToApp(router, msg) -{ - return _elm_lang$core$Native_Scheduler.nativeBinding(function(callback) - { - router.main(msg); - callback(_elm_lang$core$Native_Scheduler.succeed(_elm_lang$core$Native_Utils.Tuple0)); - }); -} + // setup all necessary effect managers + for (var key in _Platform_effectManagers) { + var manager = _Platform_effectManagers[key]; -function sendToSelf(router, msg) -{ - return A2(_elm_lang$core$Native_Scheduler.send, router.self, { - ctor: 'self', - _0: msg - }); -} + if (manager.a) { + ports = ports || {}; + ports[key] = manager.a(key, sendToApp); + } + managers[key] = _Platform_instantiateManager(manager, sendToApp); + } -// HELPER for STATEFUL LOOPS + return ports; + } -function spawnLoop(init, onMessage) -{ - var andThen = _elm_lang$core$Native_Scheduler.andThen; + function _Platform_createManager( + init, + onEffects, + onSelfMsg, + cmdMap, + subMap + ) { + return { + b: init, + c: onEffects, + d: onSelfMsg, + e: cmdMap, + f: subMap + }; + } - function loop(state) - { - var handleMsg = _elm_lang$core$Native_Scheduler.receive(function(msg) { - return onMessage(msg, state); - }); - return A2(andThen, loop, handleMsg); - } + function _Platform_instantiateManager(info, sendToApp) { + var router = { + g: sendToApp, + h: undefined + }; - var task = A2(andThen, loop, init); + var onEffects = info.c; + var onSelfMsg = info.d; + var cmdMap = info.e; + var subMap = info.f; - return _elm_lang$core$Native_Scheduler.rawSpawn(task); -} + function loop(state) { + return A2( + _Scheduler_andThen, + loop, + _Scheduler_receive(function(msg) { + var value = msg.a; + if (msg.$ === 0) { + return A3(onSelfMsg, router, value, state); + } -// BAGS + return cmdMap && subMap + ? A4(onEffects, router, value.i, value.j, state) + : A3(onEffects, router, cmdMap ? value.i : value.j, state); + }) + ); + } -function leaf(home) -{ - return function(value) - { - return { - type: 'leaf', - home: home, - value: value - }; - }; -} + return (router.h = _Scheduler_rawSpawn( + A2(_Scheduler_andThen, loop, info.b) + )); + } -function batch(list) -{ - return { - type: 'node', - branches: list - }; -} + // ROUTING -function map(tagger, bag) -{ - return { - type: 'map', - tagger: tagger, - tree: bag - } -} + var _Platform_sendToApp = F2(function(router, msg) { + return _Scheduler_binding(function(callback) { + router.g(msg); + callback(_Scheduler_succeed(_Utils_Tuple0)); + }); + }); + var _Platform_sendToSelf = F2(function(router, msg) { + return A2(_Scheduler_send, router.h, { + $: 0, + a: msg + }); + }); -// PIPE BAGS INTO EFFECT MANAGERS + // BAGS -function dispatchEffects(managers, cmdBag, subBag) -{ - var effectsDict = {}; - gatherEffects(true, cmdBag, effectsDict, null); - gatherEffects(false, subBag, effectsDict, null); - - for (var home in managers) - { - var fx = home in effectsDict - ? effectsDict[home] - : { - cmds: _elm_lang$core$Native_List.Nil, - subs: _elm_lang$core$Native_List.Nil - }; + function _Platform_leaf(home) { + return function(value) { + return { + $: 1, + k: home, + l: value + }; + }; + } - _elm_lang$core$Native_Scheduler.rawSend(managers[home], { ctor: 'fx', _0: fx }); - } -} + function _Platform_batch(list) { + return { + $: 2, + m: list + }; + } -function gatherEffects(isCmd, bag, effectsDict, taggers) -{ - switch (bag.type) - { - case 'leaf': - var home = bag.home; - var effect = toEffect(isCmd, home, taggers, bag.value); - effectsDict[home] = insert(isCmd, effect, effectsDict[home]); + var _Platform_map = F2(function(tagger, bag) { + return { + $: 3, + n: tagger, + o: bag + }; + }); + + // PIPE BAGS INTO EFFECT MANAGERS + + function _Platform_dispatchEffects(managers, cmdBag, subBag) { + var effectsDict = {}; + _Platform_gatherEffects(true, cmdBag, effectsDict, null); + _Platform_gatherEffects(false, subBag, effectsDict, null); + + for (var home in managers) { + _Scheduler_rawSend(managers[home], { + $: "fx", + a: effectsDict[home] || { i: _List_Nil, j: _List_Nil } + }); + } + } + + function _Platform_gatherEffects(isCmd, bag, effectsDict, taggers) { + switch (bag.$) { + case 1: + var home = bag.k; + var effect = _Platform_toEffect(isCmd, home, taggers, bag.l); + effectsDict[home] = _Platform_insert( + isCmd, + effect, + effectsDict[home] + ); return; - case 'node': - var list = bag.branches; - while (list.ctor !== '[]') - { - gatherEffects(isCmd, list._0, effectsDict, taggers); - list = list._1; + case 2: + for ( + var list = bag.m; + list.b; + list = list.b // WHILE_CONS + ) { + _Platform_gatherEffects(isCmd, list.a, effectsDict, taggers); } return; - case 'map': - gatherEffects(isCmd, bag.tree, effectsDict, { - tagger: bag.tagger, - rest: taggers + case 3: + _Platform_gatherEffects(isCmd, bag.o, effectsDict, { + p: bag.n, + q: taggers }); return; - } -} - -function toEffect(isCmd, home, taggers, value) -{ - function applyTaggers(x) - { - var temp = taggers; - while (temp) - { - x = temp.tagger(x); - temp = temp.rest; } - return x; - } - - var map = isCmd - ? effectManagers[home].cmdMap - : effectManagers[home].subMap; - - return A2(map, applyTaggers, value) -} - -function insert(isCmd, newEffect, effects) -{ - effects = effects || { - cmds: _elm_lang$core$Native_List.Nil, - subs: _elm_lang$core$Native_List.Nil - }; - if (isCmd) - { - effects.cmds = _elm_lang$core$Native_List.Cons(newEffect, effects.cmds); - return effects; - } - effects.subs = _elm_lang$core$Native_List.Cons(newEffect, effects.subs); - return effects; -} - + } -// PORTS + function _Platform_toEffect(isCmd, home, taggers, value) { + function applyTaggers(x) { + for (var temp = taggers; temp; temp = temp.q) { + x = temp.p(x); + } + return x; + } -function checkPortName(name) -{ - if (name in effectManagers) - { - throw new Error('There can only be one port named `' + name + '`, but your program has multiple.'); - } -} + var map = isCmd + ? _Platform_effectManagers[home].e + : _Platform_effectManagers[home].f; + return A2(map, applyTaggers, value); + } -// OUTGOING PORTS + function _Platform_insert(isCmd, newEffect, effects) { + effects = effects || { i: _List_Nil, j: _List_Nil }; -function outgoingPort(name, converter) -{ - checkPortName(name); - effectManagers[name] = { - tag: 'cmd', - cmdMap: outgoingPortMap, - converter: converter, - isForeign: true - }; - return leaf(name); -} + isCmd + ? (effects.i = _List_Cons(newEffect, effects.i)) + : (effects.j = _List_Cons(newEffect, effects.j)); -var outgoingPortMap = F2(function cmdMap(tagger, value) { - return value; -}); + return effects; + } -function setupOutgoingPort(name) -{ - var subs = []; - var converter = effectManagers[name].converter; + // PORTS - // CREATE MANAGER + function _Platform_checkPortName(name) { + if (_Platform_effectManagers[name]) { + _Debug_crash(3, name); + } + } - var init = _elm_lang$core$Native_Scheduler.succeed(null); + // OUTGOING PORTS - function onEffects(router, cmdList, state) - { - while (cmdList.ctor !== '[]') - { + function _Platform_outgoingPort(name, converter) { + _Platform_checkPortName(name); + _Platform_effectManagers[name] = { + e: _Platform_outgoingPortMap, + r: converter, + a: _Platform_setupOutgoingPort + }; + return _Platform_leaf(name); + } + + var _Platform_outgoingPortMap = F2(function(tagger, value) { + return value; + }); + + function _Platform_setupOutgoingPort(name) { + var subs = []; + var converter = _Platform_effectManagers[name].r; + + // CREATE MANAGER + + var init = _Process_sleep(0); + + _Platform_effectManagers[name].b = init; + _Platform_effectManagers[name].c = F3(function( + router, + cmdList, + state + ) { + for ( + ; + cmdList.b; + cmdList = cmdList.b // WHILE_CONS + ) { // grab a separate reference to subs in case unsubscribe is called var currentSubs = subs; - var value = converter(cmdList._0); - for (var i = 0; i < currentSubs.length; i++) - { - currentSubs[i](value); + var value = _Json_unwrap(converter(cmdList.a)); + for (var i = 0; i < currentSubs.length; i++) { + currentSubs[i](value); } - cmdList = cmdList._1; - } - return init; - } - - effectManagers[name].init = init; - effectManagers[name].onEffects = F3(onEffects); + } + return init; + }); - // PUBLIC API + // PUBLIC API - function subscribe(callback) - { - subs.push(callback); - } + function subscribe(callback) { + subs.push(callback); + } - function unsubscribe(callback) - { - // copy subs into a new array in case unsubscribe is called within a - // subscribed callback - subs = subs.slice(); - var index = subs.indexOf(callback); - if (index >= 0) - { + function unsubscribe(callback) { + // copy subs into a new array in case unsubscribe is called within a + // subscribed callback + subs = subs.slice(); + var index = subs.indexOf(callback); + if (index >= 0) { subs.splice(index, 1); + } } - } - - return { - subscribe: subscribe, - unsubscribe: unsubscribe - }; -} - -// INCOMING PORTS + return { + subscribe: subscribe, + unsubscribe: unsubscribe + }; + } -function incomingPort(name, converter) -{ - checkPortName(name); - effectManagers[name] = { - tag: 'sub', - subMap: incomingPortMap, - converter: converter, - isForeign: true - }; - return leaf(name); -} + // INCOMING PORTS -var incomingPortMap = F2(function subMap(tagger, finalTagger) -{ - return function(value) - { - return tagger(finalTagger(value)); - }; -}); + function _Platform_incomingPort(name, converter) { + _Platform_checkPortName(name); + _Platform_effectManagers[name] = { + f: _Platform_incomingPortMap, + r: converter, + a: _Platform_setupIncomingPort + }; + return _Platform_leaf(name); + } -function setupIncomingPort(name, callback) -{ - var sentBeforeInit = []; - var subs = _elm_lang$core$Native_List.Nil; - var converter = effectManagers[name].converter; - var currentOnEffects = preInitOnEffects; - var currentSend = preInitSend; + var _Platform_incomingPortMap = F2(function(tagger, finalTagger) { + return function(value) { + return tagger(finalTagger(value)); + }; + }); - // CREATE MANAGER + function _Platform_setupIncomingPort(name, sendToApp) { + var subs = _List_Nil; + var converter = _Platform_effectManagers[name].r; - var init = _elm_lang$core$Native_Scheduler.succeed(null); + // CREATE MANAGER - function preInitOnEffects(router, subList, state) - { - var postInitResult = postInitOnEffects(router, subList, state); + var init = _Scheduler_succeed(null); - for(var i = 0; i < sentBeforeInit.length; i++) - { - postInitSend(sentBeforeInit[i]); - } + _Platform_effectManagers[name].b = init; + _Platform_effectManagers[name].c = F3(function( + router, + subList, + state + ) { + subs = subList; + return init; + }); - sentBeforeInit = null; // to release objects held in queue - currentSend = postInitSend; - currentOnEffects = postInitOnEffects; - return postInitResult; - } + // PUBLIC API + + function send(incomingValue) { + var result = A2(_Json_run, converter, _Json_wrap(incomingValue)); + + $elm$core$Result$isOk(result) || _Debug_crash(4, name, result.a); + + var value = result.a; + for ( + var temp = subs; + temp.b; + temp = temp.b // WHILE_CONS + ) { + sendToApp(temp.a(value)); + } + } + + return { send: send }; + } + + // EXPORT ELM MODULES + // + // Have DEBUG and PROD versions so that we can (1) give nicer errors in + // debug mode and (2) not pay for the bits needed for that in prod mode. + // + + function _Platform_export_UNUSED(exports) { + scope["Elm"] + ? _Platform_mergeExportsProd(scope["Elm"], exports) + : (scope["Elm"] = exports); + } + + function _Platform_mergeExportsProd(obj, exports) { + for (var name in exports) { + name in obj + ? name == "init" + ? _Debug_crash(6) + : _Platform_mergeExportsProd(obj[name], exports[name]) + : (obj[name] = exports[name]); + } + } + + function _Platform_export(exports) { + scope["Elm"] + ? _Platform_mergeExportsDebug("Elm", scope["Elm"], exports) + : (scope["Elm"] = exports); + } + + function _Platform_mergeExportsDebug(moduleName, obj, exports) { + for (var name in exports) { + name in obj + ? name == "init" + ? _Debug_crash(6, moduleName) + : _Platform_mergeExportsDebug( + moduleName + "." + name, + obj[name], + exports[name] + ) + : (obj[name] = exports[name]); + } + } + + // HELPERS + + var _VirtualDom_divertHrefToApp; + + var _VirtualDom_doc = typeof document !== "undefined" ? document : {}; + + function _VirtualDom_appendChild(parent, child) { + parent.appendChild(child); + } + + var _VirtualDom_init = F4(function( + virtualNode, + flagDecoder, + debugMetadata, + args + ) { + // NOTE: this function needs _Platform_export available to work + + /**_UNUSED/ +var node = args['node']; +//*/ + /**/ + var node = args && args["node"] ? args["node"] : _Debug_crash(0); + //*/ + + node.parentNode.replaceChild( + _VirtualDom_render(virtualNode, function() {}), + node + ); - function postInitOnEffects(router, subList, state) - { - subs = subList; - return init; - } + return {}; + }); - function onEffects(router, subList, state) - { - return currentOnEffects(router, subList, state); - } + // TEXT - effectManagers[name].init = init; - effectManagers[name].onEffects = F3(onEffects); + function _VirtualDom_text(string) { + return { + $: 0, + a: string + }; + } + + // NODE + + var _VirtualDom_nodeNS = F2(function(namespace, tag) { + return F2(function(factList, kidList) { + for ( + var kids = [], descendantsCount = 0; + kidList.b; + kidList = kidList.b // WHILE_CONS + ) { + var kid = kidList.a; + descendantsCount += kid.b || 0; + kids.push(kid); + } + descendantsCount += kids.length; + + return { + $: 1, + c: tag, + d: _VirtualDom_organizeFacts(factList), + e: kids, + f: namespace, + b: descendantsCount + }; + }); + }); + + var _VirtualDom_node = _VirtualDom_nodeNS(undefined); + + // KEYED NODE + + var _VirtualDom_keyedNodeNS = F2(function(namespace, tag) { + return F2(function(factList, kidList) { + for ( + var kids = [], descendantsCount = 0; + kidList.b; + kidList = kidList.b // WHILE_CONS + ) { + var kid = kidList.a; + descendantsCount += kid.b.b || 0; + kids.push(kid); + } + descendantsCount += kids.length; + + return { + $: 2, + c: tag, + d: _VirtualDom_organizeFacts(factList), + e: kids, + f: namespace, + b: descendantsCount + }; + }); + }); - // PUBLIC API + var _VirtualDom_keyedNode = _VirtualDom_keyedNodeNS(undefined); - function preInitSend(value) - { - sentBeforeInit.push(value); - } + // CUSTOM - function postInitSend(value) - { - var temp = subs; - while (temp.ctor !== '[]') - { - callback(temp._0(value)); - temp = temp._1; - } - } + function _VirtualDom_custom(factList, model, render, diff) { + return { + $: 3, + d: _VirtualDom_organizeFacts(factList), + g: model, + h: render, + i: diff + }; + } - function send(incomingValue) - { - var result = A2(_elm_lang$core$Json_Decode$decodeValue, converter, incomingValue); - if (result.ctor === 'Err') - { - throw new Error('Trying to send an unexpected type of value through port `' + name + '`:\n' + result._0); - } + // MAP - currentSend(result._0); - } + var _VirtualDom_map = F2(function(tagger, node) { + return { + $: 4, + j: tagger, + k: node, + b: 1 + (node.b || 0) + }; + }); - return { send: send }; -} + // LAZY -return { - // routers - sendToApp: F2(sendToApp), - sendToSelf: F2(sendToSelf), + function _VirtualDom_thunk(refs, thunk) { + return { + $: 5, + l: refs, + m: thunk, + k: undefined + }; + } - // global setup - effectManagers: effectManagers, - outgoingPort: outgoingPort, - incomingPort: incomingPort, + var _VirtualDom_lazy = F2(function(func, a) { + return _VirtualDom_thunk([func, a], function() { + return func(a); + }); + }); - htmlToProgram: htmlToProgram, - program: program, - programWithFlags: programWithFlags, - initialize: initialize, + var _VirtualDom_lazy2 = F3(function(func, a, b) { + return _VirtualDom_thunk([func, a, b], function() { + return A2(func, a, b); + }); + }); - // effect bags - leaf: leaf, - batch: batch, - map: F2(map) -}; + var _VirtualDom_lazy3 = F4(function(func, a, b, c) { + return _VirtualDom_thunk([func, a, b, c], function() { + return A3(func, a, b, c); + }); + }); -}(); + var _VirtualDom_lazy4 = F5(function(func, a, b, c, d) { + return _VirtualDom_thunk([func, a, b, c, d], function() { + return A4(func, a, b, c, d); + }); + }); -//import Native.Utils // + var _VirtualDom_lazy5 = F6(function(func, a, b, c, d, e) { + return _VirtualDom_thunk([func, a, b, c, d, e], function() { + return A5(func, a, b, c, d, e); + }); + }); -var _elm_lang$core$Native_Scheduler = function() { + var _VirtualDom_lazy6 = F7(function(func, a, b, c, d, e, f) { + return _VirtualDom_thunk([func, a, b, c, d, e, f], function() { + return A6(func, a, b, c, d, e, f); + }); + }); -var MAX_STEPS = 10000; + var _VirtualDom_lazy7 = F8(function(func, a, b, c, d, e, f, g) { + return _VirtualDom_thunk([func, a, b, c, d, e, f, g], function() { + return A7(func, a, b, c, d, e, f, g); + }); + }); + + var _VirtualDom_lazy8 = F9(function(func, a, b, c, d, e, f, g, h) { + return _VirtualDom_thunk( + [func, a, b, c, d, e, f, g, h], + function() { + return A8(func, a, b, c, d, e, f, g, h); + } + ); + }); + // FACTS -// TASKS + var _VirtualDom_on = F2(function(key, handler) { + return { + $: "a0", + n: key, + o: handler + }; + }); + var _VirtualDom_style = F2(function(key, value) { + return { + $: "a1", + n: key, + o: value + }; + }); + var _VirtualDom_property = F2(function(key, value) { + return { + $: "a2", + n: key, + o: value + }; + }); + var _VirtualDom_attribute = F2(function(key, value) { + return { + $: "a3", + n: key, + o: value + }; + }); + var _VirtualDom_attributeNS = F3(function(namespace, key, value) { + return { + $: "a4", + n: key, + o: { f: namespace, o: value } + }; + }); + + // XSS ATTACK VECTOR CHECKS + + function _VirtualDom_noScript(tag) { + return tag == "script" ? "p" : tag; + } + + function _VirtualDom_noOnOrFormAction(key) { + return /^(on|formAction$)/i.test(key) ? "data-" + key : key; + } + + function _VirtualDom_noInnerHtmlOrFormAction(key) { + return key == "innerHTML" || key == "formAction" + ? "data-" + key + : key; + } + + function _VirtualDom_noJavaScriptUri_UNUSED(value) { + return /^javascript:/i.test(value.replace(/\s/g, "")) ? "" : value; + } + + function _VirtualDom_noJavaScriptUri(value) { + return /^javascript:/i.test(value.replace(/\s/g, "")) + ? 'javascript:alert("This is an XSS vector. Please use ports or web components instead.")' + : value; + } + + function _VirtualDom_noJavaScriptOrHtmlUri_UNUSED(value) { + return /^\s*(javascript:|data:text\/html)/i.test(value) + ? "" + : value; + } + + function _VirtualDom_noJavaScriptOrHtmlUri(value) { + return /^\s*(javascript:|data:text\/html)/i.test(value) + ? 'javascript:alert("This is an XSS vector. Please use ports or web components instead.")' + : value; + } + + // MAP FACTS + + var _VirtualDom_mapAttribute = F2(function(func, attr) { + return attr.$ === "a0" + ? A2(_VirtualDom_on, attr.n, _VirtualDom_mapHandler(func, attr.o)) + : attr; + }); + + function _VirtualDom_mapHandler(func, handler) { + var tag = $elm$virtual_dom$VirtualDom$toHandlerInt(handler); + + // 0 = Normal + // 1 = MayStopPropagation + // 2 = MayPreventDefault + // 3 = Custom -function succeed(value) -{ - return { - ctor: '_Task_succeed', - value: value - }; -} + return { + $: handler.$, + a: !tag + ? A2($elm$json$Json$Decode$map, func, handler.a) + : A3( + $elm$json$Json$Decode$map2, + tag < 3 + ? _VirtualDom_mapEventTuple + : _VirtualDom_mapEventRecord, + $elm$json$Json$Decode$succeed(func), + handler.a + ) + }; + } -function fail(error) -{ - return { - ctor: '_Task_fail', - value: error - }; -} + var _VirtualDom_mapEventTuple = F2(function(func, tuple) { + return _Utils_Tuple2(func(tuple.a), tuple.b); + }); -function nativeBinding(callback) -{ - return { - ctor: '_Task_nativeBinding', - callback: callback, - cancel: null - }; -} + var _VirtualDom_mapEventRecord = F2(function(func, record) { + return { + message: func(record.message), + stopPropagation: record.stopPropagation, + preventDefault: record.preventDefault + }; + }); -function andThen(callback, task) -{ - return { - ctor: '_Task_andThen', - callback: callback, - task: task - }; -} + // ORGANIZE FACTS -function onError(callback, task) -{ - return { - ctor: '_Task_onError', - callback: callback, - task: task - }; -} + function _VirtualDom_organizeFacts(factList) { + for ( + var facts = {}; + factList.b; + factList = factList.b // WHILE_CONS + ) { + var entry = factList.a; -function receive(callback) -{ - return { - ctor: '_Task_receive', - callback: callback - }; -} + var tag = entry.$; + var key = entry.n; + var value = entry.o; + if (tag === "a2") { + key === "className" + ? _VirtualDom_addClass(facts, key, _Json_unwrap(value)) + : (facts[key] = _Json_unwrap(value)); -// PROCESSES + continue; + } -function rawSpawn(task) -{ - var process = { - ctor: '_Process', - id: _elm_lang$core$Native_Utils.guid(), - root: task, - stack: null, - mailbox: [] - }; + var subFacts = facts[tag] || (facts[tag] = {}); + tag === "a3" && key === "class" + ? _VirtualDom_addClass(subFacts, key, value) + : (subFacts[key] = value); + } - enqueue(process); + return facts; + } - return process; -} + function _VirtualDom_addClass(object, key, newClass) { + var classes = object[key]; + object[key] = classes ? classes + " " + newClass : newClass; + } -function spawn(task) -{ - return nativeBinding(function(callback) { - var process = rawSpawn(task); - callback(succeed(process)); - }); -} + // RENDER -function rawSend(process, msg) -{ - process.mailbox.push(msg); - enqueue(process); -} + function _VirtualDom_render(vNode, eventNode) { + var tag = vNode.$; -function send(process, msg) -{ - return nativeBinding(function(callback) { - rawSend(process, msg); - callback(succeed(_elm_lang$core$Native_Utils.Tuple0)); - }); -} + if (tag === 5) { + return _VirtualDom_render( + vNode.k || (vNode.k = vNode.m()), + eventNode + ); + } -function kill(process) -{ - return nativeBinding(function(callback) { - var root = process.root; - if (root.ctor === '_Task_nativeBinding' && root.cancel) - { - root.cancel(); + if (tag === 0) { + return _VirtualDom_doc.createTextNode(vNode.a); } - process.root = null; + if (tag === 4) { + var subNode = vNode.k; + var tagger = vNode.j; - callback(succeed(_elm_lang$core$Native_Utils.Tuple0)); - }); -} + while (subNode.$ === 4) { + typeof tagger !== "object" + ? (tagger = [tagger, subNode.j]) + : tagger.push(subNode.j); -function sleep(time) -{ - return nativeBinding(function(callback) { - var id = setTimeout(function() { - callback(succeed(_elm_lang$core$Native_Utils.Tuple0)); - }, time); + subNode = subNode.k; + } - return function() { clearTimeout(id); }; - }); -} + var subEventRoot = { j: tagger, p: eventNode }; + var domNode = _VirtualDom_render(subNode, subEventRoot); + domNode.elm_event_node_ref = subEventRoot; + return domNode; + } + if (tag === 3) { + var domNode = vNode.h(vNode.g); + _VirtualDom_applyFacts(domNode, eventNode, vNode.d); + return domNode; + } -// STEP PROCESSES + // at this point `tag` must be 1 or 2 -function step(numSteps, process) -{ - while (numSteps < MAX_STEPS) - { - var ctor = process.root.ctor; - - if (ctor === '_Task_succeed') - { - while (process.stack && process.stack.ctor === '_Task_onError') - { - process.stack = process.stack.rest; - } - if (process.stack === null) - { - break; - } - process.root = process.stack.callback(process.root.value); - process.stack = process.stack.rest; - ++numSteps; - continue; + var domNode = vNode.f + ? _VirtualDom_doc.createElementNS(vNode.f, vNode.c) + : _VirtualDom_doc.createElement(vNode.c); + + if (_VirtualDom_divertHrefToApp && vNode.c == "a") { + domNode.addEventListener( + "click", + _VirtualDom_divertHrefToApp(domNode) + ); } - if (ctor === '_Task_fail') - { - while (process.stack && process.stack.ctor === '_Task_andThen') - { - process.stack = process.stack.rest; - } - if (process.stack === null) - { - break; - } - process.root = process.stack.callback(process.root.value); - process.stack = process.stack.rest; - ++numSteps; - continue; + _VirtualDom_applyFacts(domNode, eventNode, vNode.d); + + for (var kids = vNode.e, i = 0; i < kids.length; i++) { + _VirtualDom_appendChild( + domNode, + _VirtualDom_render(tag === 1 ? kids[i] : kids[i].b, eventNode) + ); } - if (ctor === '_Task_andThen') - { - process.stack = { - ctor: '_Task_andThen', - callback: process.root.callback, - rest: process.stack - }; - process.root = process.root.task; - ++numSteps; - continue; + return domNode; + } + + // APPLY FACTS + + function _VirtualDom_applyFacts(domNode, eventNode, facts) { + for (var key in facts) { + var value = facts[key]; + + key === "a1" + ? _VirtualDom_applyStyles(domNode, value) + : key === "a0" + ? _VirtualDom_applyEvents(domNode, eventNode, value) + : key === "a3" + ? _VirtualDom_applyAttrs(domNode, value) + : key === "a4" + ? _VirtualDom_applyAttrsNS(domNode, value) + : ((key !== "value" && key !== "checked") || + domNode[key] !== value) && + (domNode[key] = value); } + } - if (ctor === '_Task_onError') - { - process.stack = { - ctor: '_Task_onError', - callback: process.root.callback, - rest: process.stack - }; - process.root = process.root.task; - ++numSteps; - continue; + // APPLY STYLES + + function _VirtualDom_applyStyles(domNode, styles) { + var domNodeStyle = domNode.style; + + for (var key in styles) { + domNodeStyle[key] = styles[key]; } + } - if (ctor === '_Task_nativeBinding') - { - process.root.cancel = process.root.callback(function(newRoot) { - process.root = newRoot; - enqueue(process); - }); + // APPLY ATTRS - break; + function _VirtualDom_applyAttrs(domNode, attrs) { + for (var key in attrs) { + var value = attrs[key]; + typeof value !== "undefined" + ? domNode.setAttribute(key, value) + : domNode.removeAttribute(key); } + } - if (ctor === '_Task_receive') - { - var mailbox = process.mailbox; - if (mailbox.length === 0) - { - break; - } + // APPLY NAMESPACED ATTRS - process.root = process.root.callback(mailbox.shift()); - ++numSteps; - continue; + function _VirtualDom_applyAttrsNS(domNode, nsAttrs) { + for (var key in nsAttrs) { + var pair = nsAttrs[key]; + var namespace = pair.f; + var value = pair.o; + + typeof value !== "undefined" + ? domNode.setAttributeNS(namespace, key, value) + : domNode.removeAttributeNS(namespace, key); } + } - throw new Error(ctor); - } + // APPLY EVENTS - if (numSteps < MAX_STEPS) - { - return numSteps + 1; - } - enqueue(process); + function _VirtualDom_applyEvents(domNode, eventNode, events) { + var allCallbacks = domNode.elmFs || (domNode.elmFs = {}); - return numSteps; -} + for (var key in events) { + var newHandler = events[key]; + var oldCallback = allCallbacks[key]; + if (!newHandler) { + domNode.removeEventListener(key, oldCallback); + allCallbacks[key] = undefined; + continue; + } -// WORK QUEUE + if (oldCallback) { + var oldHandler = oldCallback.q; + if (oldHandler.$ === newHandler.$) { + oldCallback.q = newHandler; + continue; + } + domNode.removeEventListener(key, oldCallback); + } -var working = false; -var workQueue = []; + oldCallback = _VirtualDom_makeCallback(eventNode, newHandler); + domNode.addEventListener( + key, + oldCallback, + _VirtualDom_passiveSupported && { + passive: + $elm$virtual_dom$VirtualDom$toHandlerInt(newHandler) < 2 + } + ); + allCallbacks[key] = oldCallback; + } + } -function enqueue(process) -{ - workQueue.push(process); + // PASSIVE EVENTS - if (!working) - { - setTimeout(work, 0); - working = true; - } -} + var _VirtualDom_passiveSupported; -function work() -{ - var numSteps = 0; - var process; - while (numSteps < MAX_STEPS && (process = workQueue.shift())) - { - if (process.root) - { - numSteps = step(numSteps, process); - } - } - if (!process) - { - working = false; - return; - } - setTimeout(work, 0); -} + try { + window.addEventListener( + "t", + null, + Object.defineProperty({}, "passive", { + get: function() { + _VirtualDom_passiveSupported = true; + } + }) + ); + } catch (e) {} + // EVENT HANDLERS -return { - succeed: succeed, - fail: fail, - nativeBinding: nativeBinding, - andThen: F2(andThen), - onError: F2(onError), - receive: receive, - - spawn: spawn, - kill: kill, - sleep: sleep, - send: F2(send), - - rawSpawn: rawSpawn, - rawSend: rawSend -}; - -}(); -var _elm_lang$core$Platform_Cmd$batch = _elm_lang$core$Native_Platform.batch; -var _elm_lang$core$Platform_Cmd$none = _elm_lang$core$Platform_Cmd$batch( - {ctor: '[]'}); -var _elm_lang$core$Platform_Cmd_ops = _elm_lang$core$Platform_Cmd_ops || {}; -_elm_lang$core$Platform_Cmd_ops['!'] = F2( - function (model, commands) { - return { - ctor: '_Tuple2', - _0: model, - _1: _elm_lang$core$Platform_Cmd$batch(commands) + function _VirtualDom_makeCallback(eventNode, initialHandler) { + function callback(event) { + var handler = callback.q; + var result = _Json_runHelp(handler.a, event); + + if (!$elm$core$Result$isOk(result)) { + return; + } + + var tag = $elm$virtual_dom$VirtualDom$toHandlerInt(handler); + + // 0 = Normal + // 1 = MayStopPropagation + // 2 = MayPreventDefault + // 3 = Custom + + var value = result.a; + var message = !tag ? value : tag < 3 ? value.a : value.message; + var stopPropagation = + tag == 1 ? value.b : tag == 3 && value.stopPropagation; + var currentEventNode = + (stopPropagation && event.stopPropagation(), + (tag == 2 ? value.b : tag == 3 && value.preventDefault) && + event.preventDefault(), + eventNode); + var tagger; + var i; + while ((tagger = currentEventNode.j)) { + if (typeof tagger == "function") { + message = tagger(message); + } else { + for (var i = tagger.length; i--; ) { + message = tagger[i](message); + } + } + currentEventNode = currentEventNode.p; + } + currentEventNode(message, stopPropagation); // stopPropagation implies isSync + } + + callback.q = initialHandler; + + return callback; + } + + function _VirtualDom_equalEvents(x, y) { + return x.$ == y.$ && _Json_equality(x.a, y.a); + } + + // DIFF + + // TODO: Should we do patches like in iOS? + // + // type Patch + // = At Int Patch + // | Batch (List Patch) + // | Change ... + // + // How could it not be better? + // + function _VirtualDom_diff(x, y) { + var patches = []; + _VirtualDom_diffHelp(x, y, patches, 0); + return patches; + } + + function _VirtualDom_pushPatch(patches, type, index, data) { + var patch = { + $: type, + r: index, + s: data, + t: undefined, + u: undefined }; - }); -var _elm_lang$core$Platform_Cmd$map = _elm_lang$core$Native_Platform.map; -var _elm_lang$core$Platform_Cmd$Cmd = {ctor: 'Cmd'}; - -var _elm_lang$core$Platform_Sub$batch = _elm_lang$core$Native_Platform.batch; -var _elm_lang$core$Platform_Sub$none = _elm_lang$core$Platform_Sub$batch( - {ctor: '[]'}); -var _elm_lang$core$Platform_Sub$map = _elm_lang$core$Native_Platform.map; -var _elm_lang$core$Platform_Sub$Sub = {ctor: 'Sub'}; - -var _elm_lang$core$Platform$hack = _elm_lang$core$Native_Scheduler.succeed; -var _elm_lang$core$Platform$sendToSelf = _elm_lang$core$Native_Platform.sendToSelf; -var _elm_lang$core$Platform$sendToApp = _elm_lang$core$Native_Platform.sendToApp; -var _elm_lang$core$Platform$programWithFlags = _elm_lang$core$Native_Platform.programWithFlags; -var _elm_lang$core$Platform$program = _elm_lang$core$Native_Platform.program; -var _elm_lang$core$Platform$Program = {ctor: 'Program'}; -var _elm_lang$core$Platform$Task = {ctor: 'Task'}; -var _elm_lang$core$Platform$ProcessId = {ctor: 'ProcessId'}; -var _elm_lang$core$Platform$Router = {ctor: 'Router'}; - -var _elm_lang$lazy$Lazy$force = function (_p0) { - var _p1 = _p0; - return _p1._0( - {ctor: '_Tuple0'}); -}; -var _elm_lang$lazy$Lazy$Lazy = function (a) { - return {ctor: 'Lazy', _0: a}; -}; -var _elm_lang$lazy$Lazy$lazy = function (thunk) { - return _elm_lang$lazy$Lazy$Lazy( - _elm_lang$lazy$Native_Lazy.memoize(thunk)); -}; -var _elm_lang$lazy$Lazy$map = F2( - function (f, a) { - return _elm_lang$lazy$Lazy$lazy( - function (_p2) { - var _p3 = _p2; - return f( - _elm_lang$lazy$Lazy$force(a)); - }); - }); -var _elm_lang$lazy$Lazy$map2 = F3( - function (f, a, b) { - return _elm_lang$lazy$Lazy$lazy( - function (_p4) { - var _p5 = _p4; - return A2( - f, - _elm_lang$lazy$Lazy$force(a), - _elm_lang$lazy$Lazy$force(b)); - }); - }); -var _elm_lang$lazy$Lazy$map3 = F4( - function (f, a, b, c) { - return _elm_lang$lazy$Lazy$lazy( - function (_p6) { - var _p7 = _p6; - return A3( - f, - _elm_lang$lazy$Lazy$force(a), - _elm_lang$lazy$Lazy$force(b), - _elm_lang$lazy$Lazy$force(c)); - }); - }); -var _elm_lang$lazy$Lazy$map4 = F5( - function (f, a, b, c, d) { - return _elm_lang$lazy$Lazy$lazy( - function (_p8) { - var _p9 = _p8; - return A4( - f, - _elm_lang$lazy$Lazy$force(a), - _elm_lang$lazy$Lazy$force(b), - _elm_lang$lazy$Lazy$force(c), - _elm_lang$lazy$Lazy$force(d)); - }); - }); -var _elm_lang$lazy$Lazy$map5 = F6( - function (f, a, b, c, d, e) { - return _elm_lang$lazy$Lazy$lazy( - function (_p10) { - var _p11 = _p10; - return A5( - f, - _elm_lang$lazy$Lazy$force(a), - _elm_lang$lazy$Lazy$force(b), - _elm_lang$lazy$Lazy$force(c), - _elm_lang$lazy$Lazy$force(d), - _elm_lang$lazy$Lazy$force(e)); - }); - }); -var _elm_lang$lazy$Lazy$apply = F2( - function (f, x) { - return _elm_lang$lazy$Lazy$lazy( - function (_p12) { - var _p13 = _p12; - return A2( - _elm_lang$lazy$Lazy$force, - f, - _elm_lang$lazy$Lazy$force(x)); - }); - }); -var _elm_lang$lazy$Lazy$andThen = F2( - function (callback, a) { - return _elm_lang$lazy$Lazy$lazy( - function (_p14) { - var _p15 = _p14; - return _elm_lang$lazy$Lazy$force( - callback( - _elm_lang$lazy$Lazy$force(a))); - }); - }); + patches.push(patch); + return patch; + } + + function _VirtualDom_diffHelp(x, y, patches, index) { + if (x === y) { + return; + } + + var xType = x.$; + var yType = y.$; + + // Bail if you run into different types of nodes. Implies that the + // structure has changed significantly and it's not worth a diff. + if (xType !== yType) { + if (xType === 1 && yType === 2) { + y = _VirtualDom_dekey(y); + yType = 1; + } else { + _VirtualDom_pushPatch(patches, 0, index, y); + return; + } + } + + // Now we know that both nodes are the same $. + switch (yType) { + case 5: + var xRefs = x.l; + var yRefs = y.l; + var i = xRefs.length; + var same = i === yRefs.length; + while (same && i--) { + same = xRefs[i] === yRefs[i]; + } + if (same) { + y.k = x.k; + return; + } + y.k = y.m(); + var subPatches = []; + _VirtualDom_diffHelp(x.k, y.k, subPatches, 0); + subPatches.length > 0 && + _VirtualDom_pushPatch(patches, 1, index, subPatches); + return; -//import Maybe, Native.List // + case 4: + // gather nested taggers + var xTaggers = x.j; + var yTaggers = y.j; + var nesting = false; -var _elm_lang$core$Native_Regex = function() { + var xSubNode = x.k; + while (xSubNode.$ === 4) { + nesting = true; -function escape(str) -{ - return str.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&'); -} -function caseInsensitive(re) -{ - return new RegExp(re.source, 'gi'); -} -function regex(raw) -{ - return new RegExp(raw, 'g'); -} + typeof xTaggers !== "object" + ? (xTaggers = [xTaggers, xSubNode.j]) + : xTaggers.push(xSubNode.j); -function contains(re, string) -{ - return string.match(re) !== null; -} - -function find(n, re, str) -{ - n = n.ctor === 'All' ? Infinity : n._0; - var out = []; - var number = 0; - var string = str; - var lastIndex = re.lastIndex; - var prevLastIndex = -1; - var result; - while (number++ < n && (result = re.exec(string))) - { - if (prevLastIndex === re.lastIndex) break; - var i = result.length - 1; - var subs = new Array(i); - while (i > 0) - { - var submatch = result[i]; - subs[--i] = submatch === undefined - ? _elm_lang$core$Maybe$Nothing - : _elm_lang$core$Maybe$Just(submatch); - } - out.push({ - match: result[0], - submatches: _elm_lang$core$Native_List.fromArray(subs), - index: result.index, - number: number - }); - prevLastIndex = re.lastIndex; - } - re.lastIndex = lastIndex; - return _elm_lang$core$Native_List.fromArray(out); -} - -function replace(n, re, replacer, string) -{ - n = n.ctor === 'All' ? Infinity : n._0; - var count = 0; - function jsReplacer(match) - { - if (count++ >= n) - { - return match; - } - var i = arguments.length - 3; - var submatches = new Array(i); - while (i > 0) - { - var submatch = arguments[i]; - submatches[--i] = submatch === undefined - ? _elm_lang$core$Maybe$Nothing - : _elm_lang$core$Maybe$Just(submatch); - } - return replacer({ - match: match, - submatches: _elm_lang$core$Native_List.fromArray(submatches), - index: arguments[arguments.length - 2], - number: count - }); - } - return string.replace(re, jsReplacer); -} - -function split(n, re, str) -{ - n = n.ctor === 'All' ? Infinity : n._0; - if (n === Infinity) - { - return _elm_lang$core$Native_List.fromArray(str.split(re)); - } - var string = str; - var result; - var out = []; - var start = re.lastIndex; - var restoreLastIndex = re.lastIndex; - while (n--) - { - if (!(result = re.exec(string))) break; - out.push(string.slice(start, result.index)); - start = re.lastIndex; - } - out.push(string.slice(start)); - re.lastIndex = restoreLastIndex; - return _elm_lang$core$Native_List.fromArray(out); -} - -return { - regex: regex, - caseInsensitive: caseInsensitive, - escape: escape, - - contains: F2(contains), - find: F3(find), - replace: F4(replace), - split: F3(split) -}; - -}(); - -var _elm_lang$core$Regex$split = _elm_lang$core$Native_Regex.split; -var _elm_lang$core$Regex$replace = _elm_lang$core$Native_Regex.replace; -var _elm_lang$core$Regex$find = _elm_lang$core$Native_Regex.find; -var _elm_lang$core$Regex$contains = _elm_lang$core$Native_Regex.contains; -var _elm_lang$core$Regex$caseInsensitive = _elm_lang$core$Native_Regex.caseInsensitive; -var _elm_lang$core$Regex$regex = _elm_lang$core$Native_Regex.regex; -var _elm_lang$core$Regex$escape = _elm_lang$core$Native_Regex.escape; -var _elm_lang$core$Regex$Match = F4( - function (a, b, c, d) { - return {match: a, submatches: b, index: c, number: d}; - }); -var _elm_lang$core$Regex$Regex = {ctor: 'Regex'}; -var _elm_lang$core$Regex$AtMost = function (a) { - return {ctor: 'AtMost', _0: a}; -}; -var _elm_lang$core$Regex$All = {ctor: 'All'}; - -var _elm_community$parser_combinators$Combine$app = function (p) { - var _p0 = p; - if (_p0.ctor === 'Parser') { - return _p0._0; - } else { - return _elm_lang$lazy$Lazy$force(_p0._0); - } -}; -var _elm_community$parser_combinators$Combine$InputStream = F3( - function (a, b, c) { - return {data: a, input: b, position: c}; - }); -var _elm_community$parser_combinators$Combine$initStream = function (s) { - return A3(_elm_community$parser_combinators$Combine$InputStream, s, s, 0); -}; -var _elm_community$parser_combinators$Combine$runParser = F3( - function (p, st, s) { - var _p1 = A3( - _elm_community$parser_combinators$Combine$app, - p, - st, - _elm_community$parser_combinators$Combine$initStream(s)); - if (_p1._2.ctor === 'Ok') { - return _elm_lang$core$Result$Ok( - {ctor: '_Tuple3', _0: _p1._0, _1: _p1._1, _2: _p1._2._0}); - } else { - return _elm_lang$core$Result$Err( - {ctor: '_Tuple3', _0: _p1._0, _1: _p1._1, _2: _p1._2._0}); - } - }); -var _elm_community$parser_combinators$Combine$parse = function (p) { - return A2( - _elm_community$parser_combinators$Combine$runParser, - p, - {ctor: '_Tuple0'}); -}; -var _elm_community$parser_combinators$Combine$ParseLocation = F3( - function (a, b, c) { - return {source: a, line: b, column: c}; - }); -var _elm_community$parser_combinators$Combine$currentLocation = function (stream) { - var find = F3( - function (position, currentLine, lines) { - find: - while (true) { - var _p2 = lines; - if (_p2.ctor === '[]') { - return A3(_elm_community$parser_combinators$Combine$ParseLocation, '', 1, position); - } else { - if (_p2._1.ctor === '[]') { - return A3(_elm_community$parser_combinators$Combine$ParseLocation, _p2._0, currentLine + 1, position); - } else { - var _p3 = _p2._0; - var length = _elm_lang$core$String$length(_p3); - if (_elm_lang$core$Native_Utils.cmp(position, length) > -1) { - var _v3 = (position - length) - 1, - _v4 = currentLine + 1, - _v5 = _p2._1; - position = _v3; - currentLine = _v4; - lines = _v5; - continue find; - } else { - if (_elm_lang$core$Native_Utils.eq(currentLine, 0)) { - return A3(_elm_community$parser_combinators$Combine$ParseLocation, _p3, 1, position); - } else { - return A3(_elm_community$parser_combinators$Combine$ParseLocation, _p3, currentLine, position - 1); - } - } - } - } - } - }); - return A3( - find, - stream.position, - 0, - A2(_elm_lang$core$String$split, '\n', stream.data)); -}; -var _elm_community$parser_combinators$Combine$currentSourceLine = function (_p4) { - return function (_) { - return _.source; - }( - _elm_community$parser_combinators$Combine$currentLocation(_p4)); -}; -var _elm_community$parser_combinators$Combine$currentLine = function (_p5) { - return function (_) { - return _.line; - }( - _elm_community$parser_combinators$Combine$currentLocation(_p5)); -}; -var _elm_community$parser_combinators$Combine$currentColumn = function (_p6) { - return function (_) { - return _.column; - }( - _elm_community$parser_combinators$Combine$currentLocation(_p6)); -}; -var _elm_community$parser_combinators$Combine$RecursiveParser = function (a) { - return {ctor: 'RecursiveParser', _0: a}; -}; -var _elm_community$parser_combinators$Combine$lazy = function (t) { - return _elm_community$parser_combinators$Combine$RecursiveParser( - _elm_lang$lazy$Lazy$lazy( - function (_p7) { - var _p8 = _p7; - return _elm_community$parser_combinators$Combine$app( - t( - {ctor: '_Tuple0'})); - })); -}; -var _elm_community$parser_combinators$Combine$Parser = function (a) { - return {ctor: 'Parser', _0: a}; -}; -var _elm_community$parser_combinators$Combine$primitive = _elm_community$parser_combinators$Combine$Parser; -var _elm_community$parser_combinators$Combine$bimap = F3( - function (fok, ferr, p) { - return _elm_community$parser_combinators$Combine$Parser( - F2( - function (state, stream) { - var _p9 = A3(_elm_community$parser_combinators$Combine$app, p, state, stream); - if (_p9._2.ctor === 'Ok') { - return { - ctor: '_Tuple3', - _0: _p9._0, - _1: _p9._1, - _2: _elm_lang$core$Result$Ok( - fok(_p9._2._0)) - }; - } else { - return { - ctor: '_Tuple3', - _0: _p9._0, - _1: _p9._1, - _2: _elm_lang$core$Result$Err( - ferr(_p9._2._0)) - }; - } - })); - }); -var _elm_community$parser_combinators$Combine$map = F2( - function (f, p) { - return A3(_elm_community$parser_combinators$Combine$bimap, f, _elm_lang$core$Basics$identity, p); - }); -var _elm_community$parser_combinators$Combine_ops = _elm_community$parser_combinators$Combine_ops || {}; -_elm_community$parser_combinators$Combine_ops['<$>'] = _elm_community$parser_combinators$Combine$map; -var _elm_community$parser_combinators$Combine_ops = _elm_community$parser_combinators$Combine_ops || {}; -_elm_community$parser_combinators$Combine_ops['<$'] = function (res) { - return _elm_community$parser_combinators$Combine$map( - _elm_lang$core$Basics$always(res)); -}; -var _elm_community$parser_combinators$Combine$skip = function (p) { - return A2( - _elm_community$parser_combinators$Combine_ops['<$'], - {ctor: '_Tuple0'}, - p); -}; -var _elm_community$parser_combinators$Combine_ops = _elm_community$parser_combinators$Combine_ops || {}; -_elm_community$parser_combinators$Combine_ops['$>'] = _elm_lang$core$Basics$flip( - F2( - function (x, y) { - return A2(_elm_community$parser_combinators$Combine_ops['<$'], x, y); - })); -var _elm_community$parser_combinators$Combine$mapError = _elm_community$parser_combinators$Combine$bimap(_elm_lang$core$Basics$identity); -var _elm_community$parser_combinators$Combine_ops = _elm_community$parser_combinators$Combine_ops || {}; -_elm_community$parser_combinators$Combine_ops[''] = F2( - function (p, m) { - return A2( - _elm_community$parser_combinators$Combine$mapError, - _elm_lang$core$Basics$always( - { - ctor: '::', - _0: m, - _1: {ctor: '[]'} - }), - p); - }); -var _elm_community$parser_combinators$Combine$withState = function (f) { - return _elm_community$parser_combinators$Combine$Parser( - F2( - function (state, stream) { - return A3( - _elm_community$parser_combinators$Combine$app, - f(state), - state, - stream); - })); -}; -var _elm_community$parser_combinators$Combine$withLocation = function (f) { - return _elm_community$parser_combinators$Combine$Parser( - F2( - function (state, stream) { - return A3( - _elm_community$parser_combinators$Combine$app, - f( - _elm_community$parser_combinators$Combine$currentLocation(stream)), - state, - stream); - })); -}; -var _elm_community$parser_combinators$Combine$withLine = function (f) { - return _elm_community$parser_combinators$Combine$Parser( - F2( - function (state, stream) { - return A3( - _elm_community$parser_combinators$Combine$app, - f( - _elm_community$parser_combinators$Combine$currentLine(stream)), - state, - stream); - })); -}; -var _elm_community$parser_combinators$Combine$withColumn = function (f) { - return _elm_community$parser_combinators$Combine$Parser( - F2( - function (state, stream) { - return A3( - _elm_community$parser_combinators$Combine$app, - f( - _elm_community$parser_combinators$Combine$currentColumn(stream)), - state, - stream); - })); -}; -var _elm_community$parser_combinators$Combine$andThen = F2( - function (f, p) { - return _elm_community$parser_combinators$Combine$Parser( - F2( - function (state, stream) { - var _p10 = A3(_elm_community$parser_combinators$Combine$app, p, state, stream); - if (_p10._2.ctor === 'Ok') { - return A3( - _elm_community$parser_combinators$Combine$app, - f(_p10._2._0), - _p10._0, - _p10._1); - } else { - return { - ctor: '_Tuple3', - _0: _p10._0, - _1: _p10._1, - _2: _elm_lang$core$Result$Err(_p10._2._0) - }; - } - })); - }); -var _elm_community$parser_combinators$Combine_ops = _elm_community$parser_combinators$Combine_ops || {}; -_elm_community$parser_combinators$Combine_ops['>>='] = _elm_lang$core$Basics$flip(_elm_community$parser_combinators$Combine$andThen); -var _elm_community$parser_combinators$Combine$andMap = F2( - function (rp, lp) { - return A2( - _elm_community$parser_combinators$Combine_ops['>>='], - lp, - A2(_elm_lang$core$Basics$flip, _elm_community$parser_combinators$Combine$map, rp)); - }); -var _elm_community$parser_combinators$Combine_ops = _elm_community$parser_combinators$Combine_ops || {}; -_elm_community$parser_combinators$Combine_ops['<*>'] = _elm_lang$core$Basics$flip(_elm_community$parser_combinators$Combine$andMap); -var _elm_community$parser_combinators$Combine_ops = _elm_community$parser_combinators$Combine_ops || {}; -_elm_community$parser_combinators$Combine_ops['<*'] = F2( - function (lp, rp) { - return A2( - _elm_community$parser_combinators$Combine$andMap, - rp, - A2(_elm_community$parser_combinators$Combine$map, _elm_lang$core$Basics$always, lp)); - }); -var _elm_community$parser_combinators$Combine_ops = _elm_community$parser_combinators$Combine_ops || {}; -_elm_community$parser_combinators$Combine_ops['*>'] = F2( - function (lp, rp) { - return A2( - _elm_community$parser_combinators$Combine$andMap, - rp, - A2( - _elm_community$parser_combinators$Combine$map, - _elm_lang$core$Basics$flip(_elm_lang$core$Basics$always), - lp)); - }); -var _elm_community$parser_combinators$Combine$between = F3( - function (lp, rp, p) { - return A2( - _elm_community$parser_combinators$Combine_ops['<*'], - A2(_elm_community$parser_combinators$Combine_ops['*>'], lp, p), - rp); - }); -var _elm_community$parser_combinators$Combine$sequence = function (parsers) { - var accumulate = F4( - function (acc, ps, state, stream) { - accumulate: - while (true) { - var _p11 = ps; - if (_p11.ctor === '[]') { - return { - ctor: '_Tuple3', - _0: state, - _1: stream, - _2: _elm_lang$core$Result$Ok( - _elm_lang$core$List$reverse(acc)) - }; - } else { - var _p12 = A3(_elm_community$parser_combinators$Combine$app, _p11._0, state, stream); - if (_p12._2.ctor === 'Ok') { - var _v11 = {ctor: '::', _0: _p12._2._0, _1: acc}, - _v12 = _p11._1, - _v13 = _p12._0, - _v14 = _p12._1; - acc = _v11; - ps = _v12; - state = _v13; - stream = _v14; - continue accumulate; - } else { - return { - ctor: '_Tuple3', - _0: _p12._0, - _1: _p12._1, - _2: _elm_lang$core$Result$Err(_p12._2._0) - }; - } - } - } - }); - return _elm_community$parser_combinators$Combine$Parser( - F2( - function (state, stream) { - return A4( - accumulate, - {ctor: '[]'}, - parsers, - state, - stream); - })); -}; -var _elm_community$parser_combinators$Combine$fail = function (m) { - return _elm_community$parser_combinators$Combine$Parser( - F2( - function (state, stream) { - return { - ctor: '_Tuple3', - _0: state, - _1: stream, - _2: _elm_lang$core$Result$Err( - { - ctor: '::', - _0: m, - _1: {ctor: '[]'} - }) - }; - })); -}; -var _elm_community$parser_combinators$Combine$emptyErr = _elm_community$parser_combinators$Combine$Parser( - F2( - function (state, stream) { - return { - ctor: '_Tuple3', - _0: state, - _1: stream, - _2: _elm_lang$core$Result$Err( - {ctor: '[]'}) - }; - })); -var _elm_community$parser_combinators$Combine$succeed = function (res) { - return _elm_community$parser_combinators$Combine$Parser( - F2( - function (state, stream) { - return { - ctor: '_Tuple3', - _0: state, - _1: stream, - _2: _elm_lang$core$Result$Ok(res) - }; - })); -}; -var _elm_community$parser_combinators$Combine$putState = function (state) { - return _elm_community$parser_combinators$Combine$Parser( - F2( - function (_p13, stream) { - return A3( - _elm_community$parser_combinators$Combine$app, - _elm_community$parser_combinators$Combine$succeed( - {ctor: '_Tuple0'}), - state, - stream); - })); -}; -var _elm_community$parser_combinators$Combine$modifyState = function (f) { - return _elm_community$parser_combinators$Combine$Parser( - F2( - function (state, stream) { - return A3( - _elm_community$parser_combinators$Combine$app, - _elm_community$parser_combinators$Combine$succeed( - {ctor: '_Tuple0'}), - f(state), - stream); - })); -}; -var _elm_community$parser_combinators$Combine$count = F2( - function (n, p) { - var accumulate = F2( - function (x, acc) { - return (_elm_lang$core$Native_Utils.cmp(x, 0) < 1) ? _elm_community$parser_combinators$Combine$succeed( - _elm_lang$core$List$reverse(acc)) : A2( - _elm_community$parser_combinators$Combine$andThen, - function (res) { - return A2( - accumulate, - x - 1, - {ctor: '::', _0: res, _1: acc}); - }, - p); - }); - return A2( - accumulate, - n, - {ctor: '[]'}); - }); -var _elm_community$parser_combinators$Combine$string = function (s) { - return _elm_community$parser_combinators$Combine$Parser( - F2( - function (state, stream) { - if (A2(_elm_lang$core$String$startsWith, s, stream.input)) { - var len = _elm_lang$core$String$length(s); - var rem = A2(_elm_lang$core$String$dropLeft, len, stream.input); - var pos = stream.position + len; - return { - ctor: '_Tuple3', - _0: state, - _1: _elm_lang$core$Native_Utils.update( - stream, - {input: rem, position: pos}), - _2: _elm_lang$core$Result$Ok(s) - }; - } else { - return { - ctor: '_Tuple3', - _0: state, - _1: stream, - _2: _elm_lang$core$Result$Err( - { - ctor: '::', - _0: A2( - _elm_lang$core$Basics_ops['++'], - 'expected ', - _elm_lang$core$Basics$toString(s)), - _1: {ctor: '[]'} - }) - }; - } - })); -}; -var _elm_community$parser_combinators$Combine$parens = A2( - _elm_community$parser_combinators$Combine$between, - _elm_community$parser_combinators$Combine$string('('), - _elm_community$parser_combinators$Combine$string(')')); -var _elm_community$parser_combinators$Combine$braces = A2( - _elm_community$parser_combinators$Combine$between, - _elm_community$parser_combinators$Combine$string('{'), - _elm_community$parser_combinators$Combine$string('}')); -var _elm_community$parser_combinators$Combine$brackets = A2( - _elm_community$parser_combinators$Combine$between, - _elm_community$parser_combinators$Combine$string('['), - _elm_community$parser_combinators$Combine$string(']')); -var _elm_community$parser_combinators$Combine$regex = function (pat) { - var pattern = A2(_elm_lang$core$String$startsWith, '^', pat) ? pat : A2(_elm_lang$core$Basics_ops['++'], '^', pat); - return _elm_community$parser_combinators$Combine$Parser( - F2( - function (state, stream) { - var _p14 = A3( - _elm_lang$core$Regex$find, - _elm_lang$core$Regex$AtMost(1), - _elm_lang$core$Regex$regex(pattern), - stream.input); - if ((_p14.ctor === '::') && (_p14._1.ctor === '[]')) { - var _p15 = _p14._0; - var len = _elm_lang$core$String$length(_p15.match); - var rem = A2(_elm_lang$core$String$dropLeft, len, stream.input); - var pos = stream.position + len; - return { - ctor: '_Tuple3', - _0: state, - _1: _elm_lang$core$Native_Utils.update( - stream, - {input: rem, position: pos}), - _2: _elm_lang$core$Result$Ok(_p15.match) - }; - } else { - return { - ctor: '_Tuple3', - _0: state, - _1: stream, - _2: _elm_lang$core$Result$Err( - { - ctor: '::', - _0: A2( - _elm_lang$core$Basics_ops['++'], - 'expected input matching Regexp /', - A2(_elm_lang$core$Basics_ops['++'], pattern, '/')), - _1: {ctor: '[]'} - }) - }; - } - })); -}; -var _elm_community$parser_combinators$Combine$whitespace = A2( - _elm_community$parser_combinators$Combine_ops[''], - _elm_community$parser_combinators$Combine$regex('[ \t\r\n]*'), - 'whitespace'); -var _elm_community$parser_combinators$Combine$whitespace1 = A2( - _elm_community$parser_combinators$Combine_ops[''], - _elm_community$parser_combinators$Combine$regex('[ \t\r\n]+'), - 'whitespace'); -var _elm_community$parser_combinators$Combine$while = function (pred) { - var accumulate = F3( - function (acc, state, stream) { - accumulate: - while (true) { - var _p16 = _elm_lang$core$String$uncons(stream.input); - if (_p16.ctor === 'Just') { - var _p17 = _p16._0._0; - if (pred(_p17)) { - var pos = stream.position + 1; - var c = A2(_elm_lang$core$String$cons, _p17, ''); - var _v17 = A2(_elm_lang$core$Basics_ops['++'], acc, c), - _v18 = state, - _v19 = _elm_lang$core$Native_Utils.update( - stream, - {input: _p16._0._1, position: pos}); - acc = _v17; - state = _v18; - stream = _v19; - continue accumulate; - } else { - return {ctor: '_Tuple3', _0: state, _1: stream, _2: acc}; - } - } else { - return {ctor: '_Tuple3', _0: state, _1: stream, _2: acc}; - } - } - }); - return _elm_community$parser_combinators$Combine$Parser( - F2( - function (state, stream) { - var _p18 = A3(accumulate, '', state, stream); - var rstate = _p18._0; - var rstream = _p18._1; - var res = _p18._2; - return { - ctor: '_Tuple3', - _0: rstate, - _1: rstream, - _2: _elm_lang$core$Result$Ok(res) - }; - })); -}; -var _elm_community$parser_combinators$Combine$end = _elm_community$parser_combinators$Combine$Parser( - F2( - function (state, stream) { - return _elm_lang$core$Native_Utils.eq(stream.input, '') ? { - ctor: '_Tuple3', - _0: state, - _1: stream, - _2: _elm_lang$core$Result$Ok( - {ctor: '_Tuple0'}) - } : { - ctor: '_Tuple3', - _0: state, - _1: stream, - _2: _elm_lang$core$Result$Err( - { - ctor: '::', - _0: 'expected end of input', - _1: {ctor: '[]'} - }) - }; - })); -var _elm_community$parser_combinators$Combine$lookAhead = function (p) { - return _elm_community$parser_combinators$Combine$Parser( - F2( - function (state, stream) { - var _p19 = A3(_elm_community$parser_combinators$Combine$app, p, state, stream); - if ((_p19.ctor === '_Tuple3') && (_p19._2.ctor === 'Ok')) { - return { - ctor: '_Tuple3', - _0: _p19._0, - _1: stream, - _2: _elm_lang$core$Result$Ok(_p19._2._0) - }; - } else { - return _p19; - } - })); -}; -var _elm_community$parser_combinators$Combine$or = F2( - function (lp, rp) { - return _elm_community$parser_combinators$Combine$Parser( - F2( - function (state, stream) { - var _p20 = A3(_elm_community$parser_combinators$Combine$app, lp, state, stream); - if (_p20._2.ctor === 'Ok') { - return _p20; - } else { - var _p21 = A3(_elm_community$parser_combinators$Combine$app, rp, state, stream); - if (_p21._2.ctor === 'Ok') { - return _p21; - } else { - return { - ctor: '_Tuple3', - _0: state, - _1: stream, - _2: _elm_lang$core$Result$Err( - A2(_elm_lang$core$Basics_ops['++'], _p20._2._0, _p21._2._0)) - }; - } - } - })); - }); -var _elm_community$parser_combinators$Combine$choice = function (xs) { - return A3(_elm_lang$core$List$foldr, _elm_community$parser_combinators$Combine$or, _elm_community$parser_combinators$Combine$emptyErr, xs); -}; -var _elm_community$parser_combinators$Combine_ops = _elm_community$parser_combinators$Combine_ops || {}; -_elm_community$parser_combinators$Combine_ops['<|>'] = _elm_community$parser_combinators$Combine$or; -var _elm_community$parser_combinators$Combine$optional = F2( - function (res, p) { - return A2( - _elm_community$parser_combinators$Combine_ops['<|>'], - p, - _elm_community$parser_combinators$Combine$succeed(res)); - }); -var _elm_community$parser_combinators$Combine$chainl = F2( - function (op, p) { - var accumulate = function (x) { - return A2( - _elm_community$parser_combinators$Combine_ops['<|>'], - A2( - _elm_community$parser_combinators$Combine$andThen, - function (f) { - return A2( - _elm_community$parser_combinators$Combine$andThen, - function (y) { - return accumulate( - A2(f, x, y)); - }, - p); - }, - op), - _elm_community$parser_combinators$Combine$succeed(x)); - }; - return A2(_elm_community$parser_combinators$Combine$andThen, accumulate, p); - }); -var _elm_community$parser_combinators$Combine$chainr = F2( - function (op, p) { - var accumulate = function (x) { - return A2( - _elm_community$parser_combinators$Combine_ops['<|>'], - A2( - _elm_community$parser_combinators$Combine$andThen, - function (f) { - return A2( - _elm_community$parser_combinators$Combine$andThen, - function (y) { - return _elm_community$parser_combinators$Combine$succeed( - A2(f, x, y)); - }, - A2(_elm_community$parser_combinators$Combine$andThen, accumulate, p)); - }, - op), - _elm_community$parser_combinators$Combine$succeed(x)); - }; - return A2(_elm_community$parser_combinators$Combine$andThen, accumulate, p); - }); -var _elm_community$parser_combinators$Combine$maybe = function (p) { - return _elm_community$parser_combinators$Combine$Parser( - F2( - function (state, stream) { - var _p22 = A3(_elm_community$parser_combinators$Combine$app, p, state, stream); - if ((_p22.ctor === '_Tuple3') && (_p22._2.ctor === 'Ok')) { - return { - ctor: '_Tuple3', - _0: _p22._0, - _1: _p22._1, - _2: _elm_lang$core$Result$Ok( - _elm_lang$core$Maybe$Just(_p22._2._0)) - }; - } else { - return { - ctor: '_Tuple3', - _0: state, - _1: stream, - _2: _elm_lang$core$Result$Ok(_elm_lang$core$Maybe$Nothing) - }; - } - })); -}; -var _elm_community$parser_combinators$Combine$many = function (p) { - var accumulate = F3( - function (acc, state, stream) { - accumulate: - while (true) { - var _p23 = A3(_elm_community$parser_combinators$Combine$app, p, state, stream); - if ((_p23.ctor === '_Tuple3') && (_p23._2.ctor === 'Ok')) { - var _p25 = _p23._1; - var _p24 = _p23._0; - if (_elm_lang$core$Native_Utils.eq(stream, _p25)) { - return { - ctor: '_Tuple3', - _0: _p24, - _1: _p25, - _2: _elm_lang$core$List$reverse(acc) - }; - } else { - var _v25 = {ctor: '::', _0: _p23._2._0, _1: acc}, - _v26 = _p24, - _v27 = _p25; - acc = _v25; - state = _v26; - stream = _v27; - continue accumulate; - } - } else { - return { - ctor: '_Tuple3', - _0: state, - _1: stream, - _2: _elm_lang$core$List$reverse(acc) - }; - } - } - }); - return _elm_community$parser_combinators$Combine$Parser( - F2( - function (state, stream) { - var _p26 = A3( - accumulate, - {ctor: '[]'}, - state, - stream); - var rstate = _p26._0; - var rstream = _p26._1; - var res = _p26._2; - return { - ctor: '_Tuple3', - _0: rstate, - _1: rstream, - _2: _elm_lang$core$Result$Ok(res) - }; - })); -}; -var _elm_community$parser_combinators$Combine$many1 = function (p) { - return A2( - _elm_community$parser_combinators$Combine_ops['<*>'], - A2( - _elm_community$parser_combinators$Combine_ops['<$>'], - F2( - function (x, y) { - return {ctor: '::', _0: x, _1: y}; - }), - p), - _elm_community$parser_combinators$Combine$many(p)); -}; -var _elm_community$parser_combinators$Combine$skipMany1 = function (p) { - return A2( - _elm_community$parser_combinators$Combine_ops['<$'], - {ctor: '_Tuple0'}, - _elm_community$parser_combinators$Combine$many1( - _elm_community$parser_combinators$Combine$skip(p))); -}; -var _elm_community$parser_combinators$Combine$sepBy1 = F2( - function (sep, p) { - return A2( - _elm_community$parser_combinators$Combine_ops['<*>'], - A2( - _elm_community$parser_combinators$Combine_ops['<$>'], - F2( - function (x, y) { - return {ctor: '::', _0: x, _1: y}; - }), - p), - _elm_community$parser_combinators$Combine$many( - A2(_elm_community$parser_combinators$Combine_ops['*>'], sep, p))); - }); -var _elm_community$parser_combinators$Combine$sepBy = F2( - function (sep, p) { - return A2( - _elm_community$parser_combinators$Combine_ops['<|>'], - A2(_elm_community$parser_combinators$Combine$sepBy1, sep, p), - _elm_community$parser_combinators$Combine$succeed( - {ctor: '[]'})); - }); -var _elm_community$parser_combinators$Combine$sepEndBy1 = F2( - function (sep, p) { - return A2( - _elm_community$parser_combinators$Combine_ops['<*'], - A2(_elm_community$parser_combinators$Combine$sepBy1, sep, p), - _elm_community$parser_combinators$Combine$maybe(sep)); - }); -var _elm_community$parser_combinators$Combine$sepEndBy = F2( - function (sep, p) { - return A2( - _elm_community$parser_combinators$Combine_ops['<|>'], - A2(_elm_community$parser_combinators$Combine$sepEndBy1, sep, p), - _elm_community$parser_combinators$Combine$succeed( - {ctor: '[]'})); - }); -var _elm_community$parser_combinators$Combine$skipMany = function (p) { - return A2( - _elm_community$parser_combinators$Combine_ops['<$'], - {ctor: '_Tuple0'}, - _elm_community$parser_combinators$Combine$many( - _elm_community$parser_combinators$Combine$skip(p))); -}; -var _elm_community$parser_combinators$Combine$manyTill = F2( - function (p, end) { - var accumulate = F3( - function (acc, state, stream) { - accumulate: - while (true) { - var _p27 = A3(_elm_community$parser_combinators$Combine$app, end, state, stream); - if (_p27._2.ctor === 'Ok') { - return { - ctor: '_Tuple3', - _0: _p27._0, - _1: _p27._1, - _2: _elm_lang$core$Result$Ok( - _elm_lang$core$List$reverse(acc)) - }; - } else { - var _p28 = A3(_elm_community$parser_combinators$Combine$app, p, state, stream); - if ((_p28.ctor === '_Tuple3') && (_p28._2.ctor === 'Ok')) { - var _v30 = {ctor: '::', _0: _p28._2._0, _1: acc}, - _v31 = _p28._0, - _v32 = _p28._1; - acc = _v30; - state = _v31; - stream = _v32; - continue accumulate; - } else { - return { - ctor: '_Tuple3', - _0: _p27._0, - _1: _p27._1, - _2: _elm_lang$core$Result$Err(_p27._2._0) - }; - } - } - } - }); - return _elm_community$parser_combinators$Combine$Parser( - accumulate( - {ctor: '[]'})); - }); - -var _elm_lang$core$Dict$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(_elm_lang$core$Dict$foldr, f, acc, _p0._4)), - _v3 = _p0._3; - f = _v1; - acc = _v2; - t = _v3; - continue foldr; - } - } - }); -var _elm_lang$core$Dict$keys = function (dict) { - return A3( - _elm_lang$core$Dict$foldr, - F3( - function (key, value, keyList) { - return {ctor: '::', _0: key, _1: keyList}; - }), - {ctor: '[]'}, - dict); -}; -var _elm_lang$core$Dict$values = function (dict) { - return A3( - _elm_lang$core$Dict$foldr, - F3( - function (key, value, valueList) { - return {ctor: '::', _0: value, _1: valueList}; - }), - {ctor: '[]'}, - dict); -}; -var _elm_lang$core$Dict$toList = function (dict) { - return A3( - _elm_lang$core$Dict$foldr, - F3( - function (key, value, list) { - return { - ctor: '::', - _0: {ctor: '_Tuple2', _0: key, _1: value}, - _1: list - }; - }), - {ctor: '[]'}, - dict); -}; -var _elm_lang$core$Dict$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(_elm_lang$core$Dict$foldl, f, acc, _p1._3)), - _v7 = _p1._4; - f = _v5; - acc = _v6; - dict = _v7; - continue foldl; - } - } - }); -var _elm_lang$core$Dict$merge = F6( - function (leftStep, bothStep, rightStep, leftDict, rightDict, initialResult) { - var stepState = F3( - function (rKey, rValue, _p2) { - stepState: - while (true) { - var _p3 = _p2; - var _p9 = _p3._1; - var _p8 = _p3._0; - var _p4 = _p8; - if (_p4.ctor === '[]') { - return { - ctor: '_Tuple2', - _0: _p8, - _1: A3(rightStep, rKey, rValue, _p9) - }; - } else { - var _p7 = _p4._1; - var _p6 = _p4._0._1; - var _p5 = _p4._0._0; - if (_elm_lang$core$Native_Utils.cmp(_p5, rKey) < 0) { - var _v10 = rKey, - _v11 = rValue, - _v12 = { - ctor: '_Tuple2', - _0: _p7, - _1: A3(leftStep, _p5, _p6, _p9) - }; - rKey = _v10; - rValue = _v11; - _p2 = _v12; - continue stepState; - } else { - if (_elm_lang$core$Native_Utils.cmp(_p5, rKey) > 0) { - return { - ctor: '_Tuple2', - _0: _p8, - _1: A3(rightStep, rKey, rValue, _p9) - }; - } else { - return { - ctor: '_Tuple2', - _0: _p7, - _1: A4(bothStep, _p5, _p6, rValue, _p9) - }; - } - } - } - } - }); - var _p10 = A3( - _elm_lang$core$Dict$foldl, - stepState, - { - ctor: '_Tuple2', - _0: _elm_lang$core$Dict$toList(leftDict), - _1: initialResult - }, - rightDict); - var leftovers = _p10._0; - var intermediateResult = _p10._1; - return A3( - _elm_lang$core$List$foldl, - F2( - function (_p11, result) { - var _p12 = _p11; - return A3(leftStep, _p12._0, _p12._1, result); - }), - intermediateResult, - leftovers); - }); -var _elm_lang$core$Dict$reportRemBug = F4( - function (msg, c, lgot, rgot) { - return _elm_lang$core$Native_Debug.crash( - _elm_lang$core$String$concat( - { - ctor: '::', - _0: 'Internal red-black tree invariant violated, expected ', - _1: { - ctor: '::', - _0: msg, - _1: { - ctor: '::', - _0: ' and got ', - _1: { - ctor: '::', - _0: _elm_lang$core$Basics$toString(c), - _1: { - ctor: '::', - _0: '/', - _1: { - ctor: '::', - _0: lgot, - _1: { - ctor: '::', - _0: '/', - _1: { - ctor: '::', - _0: rgot, - _1: { - ctor: '::', - _0: '\nPlease report this bug to ', - _1: {ctor: '[]'} - } - } - } - } - } - } - } - } - })); - }); -var _elm_lang$core$Dict$isBBlack = function (dict) { - var _p13 = dict; - _v14_2: - do { - if (_p13.ctor === 'RBNode_elm_builtin') { - if (_p13._0.ctor === 'BBlack') { - return true; - } else { - break _v14_2; - } - } else { - if (_p13._0.ctor === 'LBBlack') { - return true; - } else { - break _v14_2; - } - } - } while(false); - return false; -}; -var _elm_lang$core$Dict$sizeHelp = F2( - function (n, dict) { - sizeHelp: - while (true) { - var _p14 = dict; - if (_p14.ctor === 'RBEmpty_elm_builtin') { - return n; - } else { - var _v16 = A2(_elm_lang$core$Dict$sizeHelp, n + 1, _p14._4), - _v17 = _p14._3; - n = _v16; - dict = _v17; - continue sizeHelp; - } - } - }); -var _elm_lang$core$Dict$size = function (dict) { - return A2(_elm_lang$core$Dict$sizeHelp, 0, dict); -}; -var _elm_lang$core$Dict$get = F2( - function (targetKey, dict) { - get: - while (true) { - var _p15 = dict; - if (_p15.ctor === 'RBEmpty_elm_builtin') { - return _elm_lang$core$Maybe$Nothing; - } else { - var _p16 = A2(_elm_lang$core$Basics$compare, targetKey, _p15._1); - switch (_p16.ctor) { - case 'LT': - var _v20 = targetKey, - _v21 = _p15._3; - targetKey = _v20; - dict = _v21; - continue get; - case 'EQ': - return _elm_lang$core$Maybe$Just(_p15._2); - default: - var _v22 = targetKey, - _v23 = _p15._4; - targetKey = _v22; - dict = _v23; - continue get; - } - } - } - }); -var _elm_lang$core$Dict$member = F2( - function (key, dict) { - var _p17 = A2(_elm_lang$core$Dict$get, key, dict); - if (_p17.ctor === 'Just') { - return true; - } else { - return false; - } - }); -var _elm_lang$core$Dict$maxWithDefault = F3( - function (k, v, r) { - maxWithDefault: - while (true) { - var _p18 = r; - if (_p18.ctor === 'RBEmpty_elm_builtin') { - return {ctor: '_Tuple2', _0: k, _1: v}; - } else { - var _v26 = _p18._1, - _v27 = _p18._2, - _v28 = _p18._4; - k = _v26; - v = _v27; - r = _v28; - continue maxWithDefault; - } - } - }); -var _elm_lang$core$Dict$NBlack = {ctor: 'NBlack'}; -var _elm_lang$core$Dict$BBlack = {ctor: 'BBlack'}; -var _elm_lang$core$Dict$Black = {ctor: 'Black'}; -var _elm_lang$core$Dict$blackish = function (t) { - var _p19 = t; - if (_p19.ctor === 'RBNode_elm_builtin') { - var _p20 = _p19._0; - return _elm_lang$core$Native_Utils.eq(_p20, _elm_lang$core$Dict$Black) || _elm_lang$core$Native_Utils.eq(_p20, _elm_lang$core$Dict$BBlack); - } else { - return true; - } -}; -var _elm_lang$core$Dict$Red = {ctor: 'Red'}; -var _elm_lang$core$Dict$moreBlack = function (color) { - var _p21 = color; - switch (_p21.ctor) { - case 'Black': - return _elm_lang$core$Dict$BBlack; - case 'Red': - return _elm_lang$core$Dict$Black; - case 'NBlack': - return _elm_lang$core$Dict$Red; - default: - return _elm_lang$core$Native_Debug.crash('Can\'t make a double black node more black!'); - } -}; -var _elm_lang$core$Dict$lessBlack = function (color) { - var _p22 = color; - switch (_p22.ctor) { - case 'BBlack': - return _elm_lang$core$Dict$Black; - case 'Black': - return _elm_lang$core$Dict$Red; - case 'Red': - return _elm_lang$core$Dict$NBlack; - default: - return _elm_lang$core$Native_Debug.crash('Can\'t make a negative black node less black!'); - } -}; -var _elm_lang$core$Dict$LBBlack = {ctor: 'LBBlack'}; -var _elm_lang$core$Dict$LBlack = {ctor: 'LBlack'}; -var _elm_lang$core$Dict$RBEmpty_elm_builtin = function (a) { - return {ctor: 'RBEmpty_elm_builtin', _0: a}; -}; -var _elm_lang$core$Dict$empty = _elm_lang$core$Dict$RBEmpty_elm_builtin(_elm_lang$core$Dict$LBlack); -var _elm_lang$core$Dict$isEmpty = function (dict) { - return _elm_lang$core$Native_Utils.eq(dict, _elm_lang$core$Dict$empty); -}; -var _elm_lang$core$Dict$RBNode_elm_builtin = F5( - function (a, b, c, d, e) { - return {ctor: 'RBNode_elm_builtin', _0: a, _1: b, _2: c, _3: d, _4: e}; - }); -var _elm_lang$core$Dict$ensureBlackRoot = function (dict) { - var _p23 = dict; - if ((_p23.ctor === 'RBNode_elm_builtin') && (_p23._0.ctor === 'Red')) { - return A5(_elm_lang$core$Dict$RBNode_elm_builtin, _elm_lang$core$Dict$Black, _p23._1, _p23._2, _p23._3, _p23._4); - } else { - return dict; - } -}; -var _elm_lang$core$Dict$lessBlackTree = function (dict) { - var _p24 = dict; - if (_p24.ctor === 'RBNode_elm_builtin') { - return A5( - _elm_lang$core$Dict$RBNode_elm_builtin, - _elm_lang$core$Dict$lessBlack(_p24._0), - _p24._1, - _p24._2, - _p24._3, - _p24._4); - } else { - return _elm_lang$core$Dict$RBEmpty_elm_builtin(_elm_lang$core$Dict$LBlack); - } -}; -var _elm_lang$core$Dict$balancedTree = function (col) { - return function (xk) { - return function (xv) { - return function (yk) { - return function (yv) { - return function (zk) { - return function (zv) { - return function (a) { - return function (b) { - return function (c) { - return function (d) { - return A5( - _elm_lang$core$Dict$RBNode_elm_builtin, - _elm_lang$core$Dict$lessBlack(col), - yk, - yv, - A5(_elm_lang$core$Dict$RBNode_elm_builtin, _elm_lang$core$Dict$Black, xk, xv, a, b), - A5(_elm_lang$core$Dict$RBNode_elm_builtin, _elm_lang$core$Dict$Black, zk, zv, c, d)); - }; - }; - }; - }; - }; - }; - }; - }; - }; - }; -}; -var _elm_lang$core$Dict$blacken = function (t) { - var _p25 = t; - if (_p25.ctor === 'RBEmpty_elm_builtin') { - return _elm_lang$core$Dict$RBEmpty_elm_builtin(_elm_lang$core$Dict$LBlack); - } else { - return A5(_elm_lang$core$Dict$RBNode_elm_builtin, _elm_lang$core$Dict$Black, _p25._1, _p25._2, _p25._3, _p25._4); - } -}; -var _elm_lang$core$Dict$redden = function (t) { - var _p26 = t; - if (_p26.ctor === 'RBEmpty_elm_builtin') { - return _elm_lang$core$Native_Debug.crash('can\'t make a Leaf red'); - } else { - return A5(_elm_lang$core$Dict$RBNode_elm_builtin, _elm_lang$core$Dict$Red, _p26._1, _p26._2, _p26._3, _p26._4); - } -}; -var _elm_lang$core$Dict$balanceHelp = function (tree) { - var _p27 = tree; - _v36_6: - do { - _v36_5: - do { - _v36_4: - do { - _v36_3: - do { - _v36_2: - do { - _v36_1: - do { - _v36_0: - do { - if (_p27.ctor === 'RBNode_elm_builtin') { - if (_p27._3.ctor === 'RBNode_elm_builtin') { - if (_p27._4.ctor === 'RBNode_elm_builtin') { - switch (_p27._3._0.ctor) { - case 'Red': - switch (_p27._4._0.ctor) { - case 'Red': - if ((_p27._3._3.ctor === 'RBNode_elm_builtin') && (_p27._3._3._0.ctor === 'Red')) { - break _v36_0; - } else { - if ((_p27._3._4.ctor === 'RBNode_elm_builtin') && (_p27._3._4._0.ctor === 'Red')) { - break _v36_1; - } else { - if ((_p27._4._3.ctor === 'RBNode_elm_builtin') && (_p27._4._3._0.ctor === 'Red')) { - break _v36_2; - } else { - if ((_p27._4._4.ctor === 'RBNode_elm_builtin') && (_p27._4._4._0.ctor === 'Red')) { - break _v36_3; - } else { - break _v36_6; - } - } - } - } - case 'NBlack': - if ((_p27._3._3.ctor === 'RBNode_elm_builtin') && (_p27._3._3._0.ctor === 'Red')) { - break _v36_0; - } else { - if ((_p27._3._4.ctor === 'RBNode_elm_builtin') && (_p27._3._4._0.ctor === 'Red')) { - break _v36_1; - } else { - if (((((_p27._0.ctor === 'BBlack') && (_p27._4._3.ctor === 'RBNode_elm_builtin')) && (_p27._4._3._0.ctor === 'Black')) && (_p27._4._4.ctor === 'RBNode_elm_builtin')) && (_p27._4._4._0.ctor === 'Black')) { - break _v36_4; - } else { - break _v36_6; - } - } - } - default: - if ((_p27._3._3.ctor === 'RBNode_elm_builtin') && (_p27._3._3._0.ctor === 'Red')) { - break _v36_0; - } else { - if ((_p27._3._4.ctor === 'RBNode_elm_builtin') && (_p27._3._4._0.ctor === 'Red')) { - break _v36_1; - } else { - break _v36_6; - } - } - } - case 'NBlack': - switch (_p27._4._0.ctor) { - case 'Red': - if ((_p27._4._3.ctor === 'RBNode_elm_builtin') && (_p27._4._3._0.ctor === 'Red')) { - break _v36_2; - } else { - if ((_p27._4._4.ctor === 'RBNode_elm_builtin') && (_p27._4._4._0.ctor === 'Red')) { - break _v36_3; - } else { - if (((((_p27._0.ctor === 'BBlack') && (_p27._3._3.ctor === 'RBNode_elm_builtin')) && (_p27._3._3._0.ctor === 'Black')) && (_p27._3._4.ctor === 'RBNode_elm_builtin')) && (_p27._3._4._0.ctor === 'Black')) { - break _v36_5; - } else { - break _v36_6; - } - } - } - case 'NBlack': - if (_p27._0.ctor === 'BBlack') { - if ((((_p27._4._3.ctor === 'RBNode_elm_builtin') && (_p27._4._3._0.ctor === 'Black')) && (_p27._4._4.ctor === 'RBNode_elm_builtin')) && (_p27._4._4._0.ctor === 'Black')) { - break _v36_4; - } else { - if ((((_p27._3._3.ctor === 'RBNode_elm_builtin') && (_p27._3._3._0.ctor === 'Black')) && (_p27._3._4.ctor === 'RBNode_elm_builtin')) && (_p27._3._4._0.ctor === 'Black')) { - break _v36_5; - } else { - break _v36_6; - } - } - } else { - break _v36_6; - } - default: - if (((((_p27._0.ctor === 'BBlack') && (_p27._3._3.ctor === 'RBNode_elm_builtin')) && (_p27._3._3._0.ctor === 'Black')) && (_p27._3._4.ctor === 'RBNode_elm_builtin')) && (_p27._3._4._0.ctor === 'Black')) { - break _v36_5; - } else { - break _v36_6; - } - } - default: - switch (_p27._4._0.ctor) { - case 'Red': - if ((_p27._4._3.ctor === 'RBNode_elm_builtin') && (_p27._4._3._0.ctor === 'Red')) { - break _v36_2; - } else { - if ((_p27._4._4.ctor === 'RBNode_elm_builtin') && (_p27._4._4._0.ctor === 'Red')) { - break _v36_3; - } else { - break _v36_6; - } - } - case 'NBlack': - if (((((_p27._0.ctor === 'BBlack') && (_p27._4._3.ctor === 'RBNode_elm_builtin')) && (_p27._4._3._0.ctor === 'Black')) && (_p27._4._4.ctor === 'RBNode_elm_builtin')) && (_p27._4._4._0.ctor === 'Black')) { - break _v36_4; - } else { - break _v36_6; - } - default: - break _v36_6; - } - } - } else { - switch (_p27._3._0.ctor) { - case 'Red': - if ((_p27._3._3.ctor === 'RBNode_elm_builtin') && (_p27._3._3._0.ctor === 'Red')) { - break _v36_0; - } else { - if ((_p27._3._4.ctor === 'RBNode_elm_builtin') && (_p27._3._4._0.ctor === 'Red')) { - break _v36_1; - } else { - break _v36_6; - } - } - case 'NBlack': - if (((((_p27._0.ctor === 'BBlack') && (_p27._3._3.ctor === 'RBNode_elm_builtin')) && (_p27._3._3._0.ctor === 'Black')) && (_p27._3._4.ctor === 'RBNode_elm_builtin')) && (_p27._3._4._0.ctor === 'Black')) { - break _v36_5; - } else { - break _v36_6; - } - default: - break _v36_6; - } - } - } else { - if (_p27._4.ctor === 'RBNode_elm_builtin') { - switch (_p27._4._0.ctor) { - case 'Red': - if ((_p27._4._3.ctor === 'RBNode_elm_builtin') && (_p27._4._3._0.ctor === 'Red')) { - break _v36_2; - } else { - if ((_p27._4._4.ctor === 'RBNode_elm_builtin') && (_p27._4._4._0.ctor === 'Red')) { - break _v36_3; - } else { - break _v36_6; - } - } - case 'NBlack': - if (((((_p27._0.ctor === 'BBlack') && (_p27._4._3.ctor === 'RBNode_elm_builtin')) && (_p27._4._3._0.ctor === 'Black')) && (_p27._4._4.ctor === 'RBNode_elm_builtin')) && (_p27._4._4._0.ctor === 'Black')) { - break _v36_4; - } else { - break _v36_6; - } - default: - break _v36_6; - } - } else { - break _v36_6; - } - } - } else { - break _v36_6; - } - } while(false); - return _elm_lang$core$Dict$balancedTree(_p27._0)(_p27._3._3._1)(_p27._3._3._2)(_p27._3._1)(_p27._3._2)(_p27._1)(_p27._2)(_p27._3._3._3)(_p27._3._3._4)(_p27._3._4)(_p27._4); - } while(false); - return _elm_lang$core$Dict$balancedTree(_p27._0)(_p27._3._1)(_p27._3._2)(_p27._3._4._1)(_p27._3._4._2)(_p27._1)(_p27._2)(_p27._3._3)(_p27._3._4._3)(_p27._3._4._4)(_p27._4); - } while(false); - return _elm_lang$core$Dict$balancedTree(_p27._0)(_p27._1)(_p27._2)(_p27._4._3._1)(_p27._4._3._2)(_p27._4._1)(_p27._4._2)(_p27._3)(_p27._4._3._3)(_p27._4._3._4)(_p27._4._4); - } while(false); - return _elm_lang$core$Dict$balancedTree(_p27._0)(_p27._1)(_p27._2)(_p27._4._1)(_p27._4._2)(_p27._4._4._1)(_p27._4._4._2)(_p27._3)(_p27._4._3)(_p27._4._4._3)(_p27._4._4._4); - } while(false); - return A5( - _elm_lang$core$Dict$RBNode_elm_builtin, - _elm_lang$core$Dict$Black, - _p27._4._3._1, - _p27._4._3._2, - A5(_elm_lang$core$Dict$RBNode_elm_builtin, _elm_lang$core$Dict$Black, _p27._1, _p27._2, _p27._3, _p27._4._3._3), - A5( - _elm_lang$core$Dict$balance, - _elm_lang$core$Dict$Black, - _p27._4._1, - _p27._4._2, - _p27._4._3._4, - _elm_lang$core$Dict$redden(_p27._4._4))); - } while(false); - return A5( - _elm_lang$core$Dict$RBNode_elm_builtin, - _elm_lang$core$Dict$Black, - _p27._3._4._1, - _p27._3._4._2, - A5( - _elm_lang$core$Dict$balance, - _elm_lang$core$Dict$Black, - _p27._3._1, - _p27._3._2, - _elm_lang$core$Dict$redden(_p27._3._3), - _p27._3._4._3), - A5(_elm_lang$core$Dict$RBNode_elm_builtin, _elm_lang$core$Dict$Black, _p27._1, _p27._2, _p27._3._4._4, _p27._4)); - } while(false); - return tree; -}; -var _elm_lang$core$Dict$balance = F5( - function (c, k, v, l, r) { - var tree = A5(_elm_lang$core$Dict$RBNode_elm_builtin, c, k, v, l, r); - return _elm_lang$core$Dict$blackish(tree) ? _elm_lang$core$Dict$balanceHelp(tree) : tree; - }); -var _elm_lang$core$Dict$bubble = F5( - function (c, k, v, l, r) { - return (_elm_lang$core$Dict$isBBlack(l) || _elm_lang$core$Dict$isBBlack(r)) ? A5( - _elm_lang$core$Dict$balance, - _elm_lang$core$Dict$moreBlack(c), - k, - v, - _elm_lang$core$Dict$lessBlackTree(l), - _elm_lang$core$Dict$lessBlackTree(r)) : A5(_elm_lang$core$Dict$RBNode_elm_builtin, c, k, v, l, r); - }); -var _elm_lang$core$Dict$removeMax = F5( - function (c, k, v, l, r) { - var _p28 = r; - if (_p28.ctor === 'RBEmpty_elm_builtin') { - return A3(_elm_lang$core$Dict$rem, c, l, r); - } else { - return A5( - _elm_lang$core$Dict$bubble, - c, - k, - v, - l, - A5(_elm_lang$core$Dict$removeMax, _p28._0, _p28._1, _p28._2, _p28._3, _p28._4)); - } - }); -var _elm_lang$core$Dict$rem = F3( - function (color, left, right) { - var _p29 = {ctor: '_Tuple2', _0: left, _1: right}; - if (_p29._0.ctor === 'RBEmpty_elm_builtin') { - if (_p29._1.ctor === 'RBEmpty_elm_builtin') { - var _p30 = color; - switch (_p30.ctor) { - case 'Red': - return _elm_lang$core$Dict$RBEmpty_elm_builtin(_elm_lang$core$Dict$LBlack); - case 'Black': - return _elm_lang$core$Dict$RBEmpty_elm_builtin(_elm_lang$core$Dict$LBBlack); - default: - return _elm_lang$core$Native_Debug.crash('cannot have bblack or nblack nodes at this point'); - } - } else { - var _p33 = _p29._1._0; - var _p32 = _p29._0._0; - var _p31 = {ctor: '_Tuple3', _0: color, _1: _p32, _2: _p33}; - if ((((_p31.ctor === '_Tuple3') && (_p31._0.ctor === 'Black')) && (_p31._1.ctor === 'LBlack')) && (_p31._2.ctor === 'Red')) { - return A5(_elm_lang$core$Dict$RBNode_elm_builtin, _elm_lang$core$Dict$Black, _p29._1._1, _p29._1._2, _p29._1._3, _p29._1._4); - } else { - return A4( - _elm_lang$core$Dict$reportRemBug, - 'Black/LBlack/Red', - color, - _elm_lang$core$Basics$toString(_p32), - _elm_lang$core$Basics$toString(_p33)); - } - } - } else { - if (_p29._1.ctor === 'RBEmpty_elm_builtin') { - var _p36 = _p29._1._0; - var _p35 = _p29._0._0; - var _p34 = {ctor: '_Tuple3', _0: color, _1: _p35, _2: _p36}; - if ((((_p34.ctor === '_Tuple3') && (_p34._0.ctor === 'Black')) && (_p34._1.ctor === 'Red')) && (_p34._2.ctor === 'LBlack')) { - return A5(_elm_lang$core$Dict$RBNode_elm_builtin, _elm_lang$core$Dict$Black, _p29._0._1, _p29._0._2, _p29._0._3, _p29._0._4); - } else { - return A4( - _elm_lang$core$Dict$reportRemBug, - 'Black/Red/LBlack', - color, - _elm_lang$core$Basics$toString(_p35), - _elm_lang$core$Basics$toString(_p36)); - } - } else { - var _p40 = _p29._0._2; - var _p39 = _p29._0._4; - var _p38 = _p29._0._1; - var newLeft = A5(_elm_lang$core$Dict$removeMax, _p29._0._0, _p38, _p40, _p29._0._3, _p39); - var _p37 = A3(_elm_lang$core$Dict$maxWithDefault, _p38, _p40, _p39); - var k = _p37._0; - var v = _p37._1; - return A5(_elm_lang$core$Dict$bubble, color, k, v, newLeft, right); - } - } - }); -var _elm_lang$core$Dict$map = F2( - function (f, dict) { - var _p41 = dict; - if (_p41.ctor === 'RBEmpty_elm_builtin') { - return _elm_lang$core$Dict$RBEmpty_elm_builtin(_elm_lang$core$Dict$LBlack); - } else { - var _p42 = _p41._1; - return A5( - _elm_lang$core$Dict$RBNode_elm_builtin, - _p41._0, - _p42, - A2(f, _p42, _p41._2), - A2(_elm_lang$core$Dict$map, f, _p41._3), - A2(_elm_lang$core$Dict$map, f, _p41._4)); - } - }); -var _elm_lang$core$Dict$Same = {ctor: 'Same'}; -var _elm_lang$core$Dict$Remove = {ctor: 'Remove'}; -var _elm_lang$core$Dict$Insert = {ctor: 'Insert'}; -var _elm_lang$core$Dict$update = F3( - function (k, alter, dict) { - var up = function (dict) { - var _p43 = dict; - if (_p43.ctor === 'RBEmpty_elm_builtin') { - var _p44 = alter(_elm_lang$core$Maybe$Nothing); - if (_p44.ctor === 'Nothing') { - return {ctor: '_Tuple2', _0: _elm_lang$core$Dict$Same, _1: _elm_lang$core$Dict$empty}; - } else { - return { - ctor: '_Tuple2', - _0: _elm_lang$core$Dict$Insert, - _1: A5(_elm_lang$core$Dict$RBNode_elm_builtin, _elm_lang$core$Dict$Red, k, _p44._0, _elm_lang$core$Dict$empty, _elm_lang$core$Dict$empty) - }; - } - } else { - var _p55 = _p43._2; - var _p54 = _p43._4; - var _p53 = _p43._3; - var _p52 = _p43._1; - var _p51 = _p43._0; - var _p45 = A2(_elm_lang$core$Basics$compare, k, _p52); - switch (_p45.ctor) { - case 'EQ': - var _p46 = alter( - _elm_lang$core$Maybe$Just(_p55)); - if (_p46.ctor === 'Nothing') { - return { - ctor: '_Tuple2', - _0: _elm_lang$core$Dict$Remove, - _1: A3(_elm_lang$core$Dict$rem, _p51, _p53, _p54) - }; - } else { - return { - ctor: '_Tuple2', - _0: _elm_lang$core$Dict$Same, - _1: A5(_elm_lang$core$Dict$RBNode_elm_builtin, _p51, _p52, _p46._0, _p53, _p54) - }; - } - case 'LT': - var _p47 = up(_p53); - var flag = _p47._0; - var newLeft = _p47._1; - var _p48 = flag; - switch (_p48.ctor) { - case 'Same': - return { - ctor: '_Tuple2', - _0: _elm_lang$core$Dict$Same, - _1: A5(_elm_lang$core$Dict$RBNode_elm_builtin, _p51, _p52, _p55, newLeft, _p54) - }; - case 'Insert': - return { - ctor: '_Tuple2', - _0: _elm_lang$core$Dict$Insert, - _1: A5(_elm_lang$core$Dict$balance, _p51, _p52, _p55, newLeft, _p54) - }; - default: - return { - ctor: '_Tuple2', - _0: _elm_lang$core$Dict$Remove, - _1: A5(_elm_lang$core$Dict$bubble, _p51, _p52, _p55, newLeft, _p54) - }; - } - default: - var _p49 = up(_p54); - var flag = _p49._0; - var newRight = _p49._1; - var _p50 = flag; - switch (_p50.ctor) { - case 'Same': - return { - ctor: '_Tuple2', - _0: _elm_lang$core$Dict$Same, - _1: A5(_elm_lang$core$Dict$RBNode_elm_builtin, _p51, _p52, _p55, _p53, newRight) - }; - case 'Insert': - return { - ctor: '_Tuple2', - _0: _elm_lang$core$Dict$Insert, - _1: A5(_elm_lang$core$Dict$balance, _p51, _p52, _p55, _p53, newRight) - }; - default: - return { - ctor: '_Tuple2', - _0: _elm_lang$core$Dict$Remove, - _1: A5(_elm_lang$core$Dict$bubble, _p51, _p52, _p55, _p53, newRight) - }; - } - } - } - }; - var _p56 = up(dict); - var flag = _p56._0; - var updatedDict = _p56._1; - var _p57 = flag; - switch (_p57.ctor) { - case 'Same': - return updatedDict; - case 'Insert': - return _elm_lang$core$Dict$ensureBlackRoot(updatedDict); - default: - return _elm_lang$core$Dict$blacken(updatedDict); - } - }); -var _elm_lang$core$Dict$insert = F3( - function (key, value, dict) { - return A3( - _elm_lang$core$Dict$update, - key, - _elm_lang$core$Basics$always( - _elm_lang$core$Maybe$Just(value)), - dict); - }); -var _elm_lang$core$Dict$singleton = F2( - function (key, value) { - return A3(_elm_lang$core$Dict$insert, key, value, _elm_lang$core$Dict$empty); - }); -var _elm_lang$core$Dict$union = F2( - function (t1, t2) { - return A3(_elm_lang$core$Dict$foldl, _elm_lang$core$Dict$insert, t2, t1); - }); -var _elm_lang$core$Dict$filter = F2( - function (predicate, dictionary) { - var add = F3( - function (key, value, dict) { - return A2(predicate, key, value) ? A3(_elm_lang$core$Dict$insert, key, value, dict) : dict; - }); - return A3(_elm_lang$core$Dict$foldl, add, _elm_lang$core$Dict$empty, dictionary); - }); -var _elm_lang$core$Dict$intersect = F2( - function (t1, t2) { - return A2( - _elm_lang$core$Dict$filter, - F2( - function (k, _p58) { - return A2(_elm_lang$core$Dict$member, k, t2); - }), - t1); - }); -var _elm_lang$core$Dict$partition = F2( - function (predicate, dict) { - var add = F3( - function (key, value, _p59) { - var _p60 = _p59; - var _p62 = _p60._1; - var _p61 = _p60._0; - return A2(predicate, key, value) ? { - ctor: '_Tuple2', - _0: A3(_elm_lang$core$Dict$insert, key, value, _p61), - _1: _p62 - } : { - ctor: '_Tuple2', - _0: _p61, - _1: A3(_elm_lang$core$Dict$insert, key, value, _p62) - }; - }); - return A3( - _elm_lang$core$Dict$foldl, - add, - {ctor: '_Tuple2', _0: _elm_lang$core$Dict$empty, _1: _elm_lang$core$Dict$empty}, - dict); - }); -var _elm_lang$core$Dict$fromList = function (assocs) { - return A3( - _elm_lang$core$List$foldl, - F2( - function (_p63, dict) { - var _p64 = _p63; - return A3(_elm_lang$core$Dict$insert, _p64._0, _p64._1, dict); - }), - _elm_lang$core$Dict$empty, - assocs); -}; -var _elm_lang$core$Dict$remove = F2( - function (key, dict) { - return A3( - _elm_lang$core$Dict$update, - key, - _elm_lang$core$Basics$always(_elm_lang$core$Maybe$Nothing), - dict); - }); -var _elm_lang$core$Dict$diff = F2( - function (t1, t2) { - return A3( - _elm_lang$core$Dict$foldl, - F3( - function (k, v, t) { - return A2(_elm_lang$core$Dict$remove, k, t); - }), - t1, - t2); - }); - -var _elm_community$parser_combinators$Combine_Char$crlf = A2( - _elm_community$parser_combinators$Combine_ops['<$'], - _elm_lang$core$Native_Utils.chr('\n'), - A2( - _elm_community$parser_combinators$Combine_ops[''], - _elm_community$parser_combinators$Combine$regex('\r\n'), - 'expected crlf')); -var _elm_community$parser_combinators$Combine_Char$satisfy = function (pred) { - return _elm_community$parser_combinators$Combine$primitive( - F2( - function (state, stream) { - var message = 'could not satisfy predicate'; - var _p0 = _elm_lang$core$String$uncons(stream.input); - if (_p0.ctor === 'Just') { - var _p1 = _p0._0._0; - return pred(_p1) ? { - ctor: '_Tuple3', - _0: state, - _1: _elm_lang$core$Native_Utils.update( - stream, - {input: _p0._0._1, position: stream.position + 1}), - _2: _elm_lang$core$Result$Ok(_p1) - } : { - ctor: '_Tuple3', - _0: state, - _1: stream, - _2: _elm_lang$core$Result$Err( - { - ctor: '::', - _0: message, - _1: {ctor: '[]'} - }) - }; - } else { - return { - ctor: '_Tuple3', - _0: state, - _1: stream, - _2: _elm_lang$core$Result$Err( - { - ctor: '::', - _0: message, - _1: {ctor: '[]'} - }) - }; - } - })); -}; -var _elm_community$parser_combinators$Combine_Char$char = function (c) { - return A2( - _elm_community$parser_combinators$Combine_ops[''], - _elm_community$parser_combinators$Combine_Char$satisfy( - F2( - function (x, y) { - return _elm_lang$core$Native_Utils.eq(x, y); - })(c)), - A2( - _elm_lang$core$Basics_ops['++'], - 'expected ', - _elm_lang$core$Basics$toString(c))); -}; -var _elm_community$parser_combinators$Combine_Char$anyChar = A2( - _elm_community$parser_combinators$Combine_ops[''], - _elm_community$parser_combinators$Combine_Char$satisfy( - _elm_lang$core$Basics$always(true)), - 'expected any character'); -var _elm_community$parser_combinators$Combine_Char$oneOf = function (cs) { - return A2( - _elm_community$parser_combinators$Combine_ops[''], - _elm_community$parser_combinators$Combine_Char$satisfy( - A2(_elm_lang$core$Basics$flip, _elm_lang$core$List$member, cs)), - A2( - _elm_lang$core$Basics_ops['++'], - 'expected one of ', - _elm_lang$core$Basics$toString(cs))); -}; -var _elm_community$parser_combinators$Combine_Char$noneOf = function (cs) { - return A2( - _elm_community$parser_combinators$Combine_ops[''], - _elm_community$parser_combinators$Combine_Char$satisfy( - function (_p2) { - return !A3(_elm_lang$core$Basics$flip, _elm_lang$core$List$member, cs, _p2); - }), - A2( - _elm_lang$core$Basics_ops['++'], - 'expected none of ', - _elm_lang$core$Basics$toString(cs))); -}; -var _elm_community$parser_combinators$Combine_Char$space = A2( - _elm_community$parser_combinators$Combine_ops[''], - _elm_community$parser_combinators$Combine_Char$satisfy( - F2( - function (x, y) { - return _elm_lang$core$Native_Utils.eq(x, y); - })( - _elm_lang$core$Native_Utils.chr(' '))), - 'expected space'); -var _elm_community$parser_combinators$Combine_Char$tab = A2( - _elm_community$parser_combinators$Combine_ops[''], - _elm_community$parser_combinators$Combine_Char$satisfy( - F2( - function (x, y) { - return _elm_lang$core$Native_Utils.eq(x, y); - })( - _elm_lang$core$Native_Utils.chr('\t'))), - 'expected tab'); -var _elm_community$parser_combinators$Combine_Char$newline = A2( - _elm_community$parser_combinators$Combine_ops[''], - _elm_community$parser_combinators$Combine_Char$satisfy( - F2( - function (x, y) { - return _elm_lang$core$Native_Utils.eq(x, y); - })( - _elm_lang$core$Native_Utils.chr('\n'))), - 'expected newline'); -var _elm_community$parser_combinators$Combine_Char$eol = A2(_elm_community$parser_combinators$Combine_ops['<|>'], _elm_community$parser_combinators$Combine_Char$newline, _elm_community$parser_combinators$Combine_Char$crlf); -var _elm_community$parser_combinators$Combine_Char$lower = A2( - _elm_community$parser_combinators$Combine_ops[''], - _elm_community$parser_combinators$Combine_Char$satisfy(_elm_lang$core$Char$isLower), - 'expected a lowercase character'); -var _elm_community$parser_combinators$Combine_Char$upper = A2( - _elm_community$parser_combinators$Combine_ops[''], - _elm_community$parser_combinators$Combine_Char$satisfy(_elm_lang$core$Char$isUpper), - 'expected an uppercase character'); -var _elm_community$parser_combinators$Combine_Char$digit = A2( - _elm_community$parser_combinators$Combine_ops[''], - _elm_community$parser_combinators$Combine_Char$satisfy(_elm_lang$core$Char$isDigit), - 'expected a digit'); -var _elm_community$parser_combinators$Combine_Char$octDigit = A2( - _elm_community$parser_combinators$Combine_ops[''], - _elm_community$parser_combinators$Combine_Char$satisfy(_elm_lang$core$Char$isOctDigit), - 'expected an octal digit'); -var _elm_community$parser_combinators$Combine_Char$hexDigit = A2( - _elm_community$parser_combinators$Combine_ops[''], - _elm_community$parser_combinators$Combine_Char$satisfy(_elm_lang$core$Char$isHexDigit), - 'expected a hexadecimal digit'); - -var _Bogdanp$elm_ast$Ast_Helpers$emptyTuple = _elm_community$parser_combinators$Combine$string('()'); -var _Bogdanp$elm_ast$Ast_Helpers$name = function (p) { - return A2( - _elm_community$parser_combinators$Combine_ops['<*>'], - A2(_elm_community$parser_combinators$Combine_ops['<$>'], _elm_lang$core$String$cons, p), - _elm_community$parser_combinators$Combine$regex('[a-zA-Z0-9-_]*')); -}; -var _Bogdanp$elm_ast$Ast_Helpers$upName = _Bogdanp$elm_ast$Ast_Helpers$name(_elm_community$parser_combinators$Combine_Char$upper); -var _Bogdanp$elm_ast$Ast_Helpers$spaces_ = _elm_community$parser_combinators$Combine$regex('[ \\t]+'); -var _Bogdanp$elm_ast$Ast_Helpers$initialSymbol = function (k) { - return A2( - _elm_community$parser_combinators$Combine_ops['<*'], - _elm_community$parser_combinators$Combine$string(k), - _Bogdanp$elm_ast$Ast_Helpers$spaces_); -}; -var _Bogdanp$elm_ast$Ast_Helpers$spaces = _elm_community$parser_combinators$Combine$regex('[ \\t]*'); -var _Bogdanp$elm_ast$Ast_Helpers$between_ = function (p) { - return A2(_elm_community$parser_combinators$Combine$between, p, p); -}; -var _Bogdanp$elm_ast$Ast_Helpers$symbol_ = function (k) { - return A2( - _Bogdanp$elm_ast$Ast_Helpers$between_, - _elm_community$parser_combinators$Combine$whitespace, - A2( - _elm_community$parser_combinators$Combine_ops['<*'], - _elm_community$parser_combinators$Combine$string(k), - _elm_community$parser_combinators$Combine$regex('( |\\n)+'))); -}; -var _Bogdanp$elm_ast$Ast_Helpers$symbol = function (k) { - return A2( - _Bogdanp$elm_ast$Ast_Helpers$between_, - _elm_community$parser_combinators$Combine$whitespace, - _elm_community$parser_combinators$Combine$string(k)); -}; -var _Bogdanp$elm_ast$Ast_Helpers$commaSeparated = function (p) { - return A2( - _elm_community$parser_combinators$Combine$sepBy1, - _elm_community$parser_combinators$Combine$string(','), - A2(_Bogdanp$elm_ast$Ast_Helpers$between_, _elm_community$parser_combinators$Combine$whitespace, p)); -}; -var _Bogdanp$elm_ast$Ast_Helpers$commaSeparated_ = function (p) { - return A2( - _elm_community$parser_combinators$Combine$sepBy, - _elm_community$parser_combinators$Combine$string(','), - A2(_Bogdanp$elm_ast$Ast_Helpers$between_, _elm_community$parser_combinators$Combine$whitespace, p)); -}; -var _Bogdanp$elm_ast$Ast_Helpers$moduleName = A2( - _Bogdanp$elm_ast$Ast_Helpers$between_, - _Bogdanp$elm_ast$Ast_Helpers$spaces, - A2( - _elm_community$parser_combinators$Combine$sepBy1, - _elm_community$parser_combinators$Combine$string('.'), - _Bogdanp$elm_ast$Ast_Helpers$upName)); -var _Bogdanp$elm_ast$Ast_Helpers$reservedOperators = { - ctor: '::', - _0: '=', - _1: { - ctor: '::', - _0: '.', - _1: { - ctor: '::', - _0: '..', - _1: { - ctor: '::', - _0: '->', - _1: { - ctor: '::', - _0: '--', - _1: { - ctor: '::', - _0: '|', - _1: { - ctor: '::', - _0: ':', - _1: {ctor: '[]'} - } - } - } - } - } - } -}; -var _Bogdanp$elm_ast$Ast_Helpers$operator = A2( - _elm_community$parser_combinators$Combine$andThen, - function (n) { - return A2(_elm_lang$core$List$member, n, _Bogdanp$elm_ast$Ast_Helpers$reservedOperators) ? _elm_community$parser_combinators$Combine$fail( - A2( - _elm_lang$core$Basics_ops['++'], - 'operator \'', - A2(_elm_lang$core$Basics_ops['++'], n, '\' is reserved'))) : _elm_community$parser_combinators$Combine$succeed(n); - }, - _elm_community$parser_combinators$Combine$regex('[+\\-\\/*=.$<>:&|^?%#@~!]+|Šs\b')); -var _Bogdanp$elm_ast$Ast_Helpers$reserved = { - ctor: '::', - _0: 'module', - _1: { - ctor: '::', - _0: 'where', - _1: { - ctor: '::', - _0: 'import', - _1: { - ctor: '::', - _0: 'as', - _1: { - ctor: '::', - _0: 'exposing', - _1: { - ctor: '::', - _0: 'type', - _1: { - ctor: '::', - _0: 'alias', - _1: { - ctor: '::', - _0: 'port', - _1: { - ctor: '::', - _0: 'if', - _1: { - ctor: '::', - _0: 'then', - _1: { - ctor: '::', - _0: 'else', - _1: { - ctor: '::', - _0: 'let', - _1: { - ctor: '::', - _0: 'in', - _1: { - ctor: '::', - _0: 'case', - _1: { - ctor: '::', - _0: 'of', - _1: {ctor: '[]'} - } - } - } - } - } - } - } - } - } - } - } - } - } - } -}; -var _Bogdanp$elm_ast$Ast_Helpers$loName = function () { - var loName_ = A2( - _elm_community$parser_combinators$Combine$andThen, - function (n) { - return A2(_elm_lang$core$List$member, n, _Bogdanp$elm_ast$Ast_Helpers$reserved) ? _elm_community$parser_combinators$Combine$fail( - A2( - _elm_lang$core$Basics_ops['++'], - 'name \'', - A2(_elm_lang$core$Basics_ops['++'], n, '\' is reserved'))) : _elm_community$parser_combinators$Combine$succeed(n); - }, - _Bogdanp$elm_ast$Ast_Helpers$name(_elm_community$parser_combinators$Combine_Char$lower)); - return A2( - _elm_community$parser_combinators$Combine_ops['<|>'], - _elm_community$parser_combinators$Combine$string('_'), - loName_); -}(); -var _Bogdanp$elm_ast$Ast_Helpers$functionName = _Bogdanp$elm_ast$Ast_Helpers$loName; - -var _Bogdanp$elm_ast$Ast_BinOp$R = {ctor: 'R'}; -var _Bogdanp$elm_ast$Ast_BinOp$L = {ctor: 'L'}; -var _Bogdanp$elm_ast$Ast_BinOp$operators = A3( - _elm_lang$core$Dict$insert, - '=', - {ctor: '_Tuple2', _0: _Bogdanp$elm_ast$Ast_BinOp$R, _1: 0}, - A3( - _elm_lang$core$Dict$insert, - '|>', - {ctor: '_Tuple2', _0: _Bogdanp$elm_ast$Ast_BinOp$R, _1: 1}, - A3( - _elm_lang$core$Dict$insert, - '<|', - {ctor: '_Tuple2', _0: _Bogdanp$elm_ast$Ast_BinOp$R, _1: 1}, - A3( - _elm_lang$core$Dict$insert, - '>>', - {ctor: '_Tuple2', _0: _Bogdanp$elm_ast$Ast_BinOp$L, _1: 9}, - A3( - _elm_lang$core$Dict$insert, - '<<', - {ctor: '_Tuple2', _0: _Bogdanp$elm_ast$Ast_BinOp$L, _1: 9}, - A3( - _elm_lang$core$Dict$insert, - '^', - {ctor: '_Tuple2', _0: _Bogdanp$elm_ast$Ast_BinOp$L, _1: 8}, - A3( - _elm_lang$core$Dict$insert, - 'rem', - {ctor: '_Tuple2', _0: _Bogdanp$elm_ast$Ast_BinOp$L, _1: 7}, - A3( - _elm_lang$core$Dict$insert, - '//', - {ctor: '_Tuple2', _0: _Bogdanp$elm_ast$Ast_BinOp$L, _1: 7}, - A3( - _elm_lang$core$Dict$insert, - '%', - {ctor: '_Tuple2', _0: _Bogdanp$elm_ast$Ast_BinOp$L, _1: 7}, - A3( - _elm_lang$core$Dict$insert, - '/', - {ctor: '_Tuple2', _0: _Bogdanp$elm_ast$Ast_BinOp$L, _1: 7}, - A3( - _elm_lang$core$Dict$insert, - '*', - {ctor: '_Tuple2', _0: _Bogdanp$elm_ast$Ast_BinOp$L, _1: 7}, - A3( - _elm_lang$core$Dict$insert, - '-', - {ctor: '_Tuple2', _0: _Bogdanp$elm_ast$Ast_BinOp$L, _1: 6}, - A3( - _elm_lang$core$Dict$insert, - '+', - {ctor: '_Tuple2', _0: _Bogdanp$elm_ast$Ast_BinOp$L, _1: 6}, - A3( - _elm_lang$core$Dict$insert, - '::', - {ctor: '_Tuple2', _0: _Bogdanp$elm_ast$Ast_BinOp$R, _1: 5}, - A3( - _elm_lang$core$Dict$insert, - '++', - {ctor: '_Tuple2', _0: _Bogdanp$elm_ast$Ast_BinOp$L, _1: 5}, - A3( - _elm_lang$core$Dict$insert, - '<=', - {ctor: '_Tuple2', _0: _Bogdanp$elm_ast$Ast_BinOp$L, _1: 4}, - A3( - _elm_lang$core$Dict$insert, - '>=', - {ctor: '_Tuple2', _0: _Bogdanp$elm_ast$Ast_BinOp$L, _1: 4}, - A3( - _elm_lang$core$Dict$insert, - '>', - {ctor: '_Tuple2', _0: _Bogdanp$elm_ast$Ast_BinOp$L, _1: 4}, - A3( - _elm_lang$core$Dict$insert, - '<', - {ctor: '_Tuple2', _0: _Bogdanp$elm_ast$Ast_BinOp$L, _1: 4}, - A3( - _elm_lang$core$Dict$insert, - '/=', - {ctor: '_Tuple2', _0: _Bogdanp$elm_ast$Ast_BinOp$L, _1: 4}, - A3( - _elm_lang$core$Dict$insert, - '==', - {ctor: '_Tuple2', _0: _Bogdanp$elm_ast$Ast_BinOp$L, _1: 4}, - A3( - _elm_lang$core$Dict$insert, - '&&', - {ctor: '_Tuple2', _0: _Bogdanp$elm_ast$Ast_BinOp$L, _1: 3}, - A3( - _elm_lang$core$Dict$insert, - '||', - {ctor: '_Tuple2', _0: _Bogdanp$elm_ast$Ast_BinOp$L, _1: 2}, - _elm_lang$core$Dict$empty))))))))))))))))))))))); -var _Bogdanp$elm_ast$Ast_BinOp$N = {ctor: 'N'}; - -var _elm_community$parser_combinators$Combine_Num$digit = function () { - var toDigit = function (c) { - return _elm_lang$core$Char$toCode(c) - _elm_lang$core$Char$toCode( - _elm_lang$core$Native_Utils.chr('0')); - }; - return A2( - _elm_community$parser_combinators$Combine_ops['<$>'], - toDigit, - A2(_elm_community$parser_combinators$Combine_ops[''], _elm_community$parser_combinators$Combine_Char$digit, 'expected a digit')); -}(); -var _elm_community$parser_combinators$Combine_Num$sign = A2( - _elm_community$parser_combinators$Combine$optional, - 1, - _elm_community$parser_combinators$Combine$choice( - { - ctor: '::', - _0: A2( - _elm_community$parser_combinators$Combine_ops['<$'], - 1, - _elm_community$parser_combinators$Combine$string('+')), - _1: { - ctor: '::', - _0: A2( - _elm_community$parser_combinators$Combine_ops['<$'], - -1, - _elm_community$parser_combinators$Combine$string('-')), - _1: {ctor: '[]'} - } - })); -var _elm_community$parser_combinators$Combine_Num$unwrap = F2( - function (f, s) { - var _p0 = f(s); - if (_p0.ctor === 'Ok') { - return _p0._0; - } else { - return _elm_lang$core$Native_Utils.crashCase( - 'Combine.Num', - { - start: {line: 23, column: 5}, - end: {line: 28, column: 83} - }, - _p0)( - A2( - _elm_lang$core$Basics_ops['++'], - 'impossible state in Combine.Num.unwrap: ', - _elm_lang$core$Basics$toString(_p0._0))); - } - }); -var _elm_community$parser_combinators$Combine_Num$toInt = _elm_community$parser_combinators$Combine_Num$unwrap(_elm_lang$core$String$toInt); -var _elm_community$parser_combinators$Combine_Num$int = A2( - _elm_community$parser_combinators$Combine_ops['<*>'], - A2( - _elm_community$parser_combinators$Combine_ops['<$>'], - F2( - function (x, y) { - return x * y; - }), - _elm_community$parser_combinators$Combine_Num$sign), - A2( - _elm_community$parser_combinators$Combine_ops[''], - A2( - _elm_community$parser_combinators$Combine_ops['<$>'], - _elm_community$parser_combinators$Combine_Num$toInt, - _elm_community$parser_combinators$Combine$regex('(0|[1-9][0-9]*)')), - 'expected an integer')); -var _elm_community$parser_combinators$Combine_Num$toFloat = _elm_community$parser_combinators$Combine_Num$unwrap(_elm_lang$core$String$toFloat); -var _elm_community$parser_combinators$Combine_Num$float = A2( - _elm_community$parser_combinators$Combine_ops['<*>'], - A2( - _elm_community$parser_combinators$Combine_ops['<$>'], - function (_p2) { - return F2( - function (x, y) { - return x * y; - })( - _elm_lang$core$Basics$toFloat(_p2)); - }, - _elm_community$parser_combinators$Combine_Num$sign), - A2( - _elm_community$parser_combinators$Combine_ops[''], - A2( - _elm_community$parser_combinators$Combine_ops['<$>'], - _elm_community$parser_combinators$Combine_Num$toFloat, - _elm_community$parser_combinators$Combine$regex('(0|[1-9][0-9]*)(\\.[0-9]+)')), - 'expected a float')); - -var _elm_lang$core$Set$foldr = F3( - function (f, b, _p0) { - var _p1 = _p0; - return A3( - _elm_lang$core$Dict$foldr, - F3( - function (k, _p2, b) { - return A2(f, k, b); - }), - b, - _p1._0); - }); -var _elm_lang$core$Set$foldl = F3( - function (f, b, _p3) { - var _p4 = _p3; - return A3( - _elm_lang$core$Dict$foldl, - F3( - function (k, _p5, b) { - return A2(f, k, b); - }), - b, - _p4._0); - }); -var _elm_lang$core$Set$toList = function (_p6) { - var _p7 = _p6; - return _elm_lang$core$Dict$keys(_p7._0); -}; -var _elm_lang$core$Set$size = function (_p8) { - var _p9 = _p8; - return _elm_lang$core$Dict$size(_p9._0); -}; -var _elm_lang$core$Set$member = F2( - function (k, _p10) { - var _p11 = _p10; - return A2(_elm_lang$core$Dict$member, k, _p11._0); - }); -var _elm_lang$core$Set$isEmpty = function (_p12) { - var _p13 = _p12; - return _elm_lang$core$Dict$isEmpty(_p13._0); -}; -var _elm_lang$core$Set$Set_elm_builtin = function (a) { - return {ctor: 'Set_elm_builtin', _0: a}; -}; -var _elm_lang$core$Set$empty = _elm_lang$core$Set$Set_elm_builtin(_elm_lang$core$Dict$empty); -var _elm_lang$core$Set$singleton = function (k) { - return _elm_lang$core$Set$Set_elm_builtin( - A2( - _elm_lang$core$Dict$singleton, - k, - {ctor: '_Tuple0'})); -}; -var _elm_lang$core$Set$insert = F2( - function (k, _p14) { - var _p15 = _p14; - return _elm_lang$core$Set$Set_elm_builtin( - A3( - _elm_lang$core$Dict$insert, - k, - {ctor: '_Tuple0'}, - _p15._0)); - }); -var _elm_lang$core$Set$fromList = function (xs) { - return A3(_elm_lang$core$List$foldl, _elm_lang$core$Set$insert, _elm_lang$core$Set$empty, xs); -}; -var _elm_lang$core$Set$map = F2( - function (f, s) { - return _elm_lang$core$Set$fromList( - A2( - _elm_lang$core$List$map, - f, - _elm_lang$core$Set$toList(s))); - }); -var _elm_lang$core$Set$remove = F2( - function (k, _p16) { - var _p17 = _p16; - return _elm_lang$core$Set$Set_elm_builtin( - A2(_elm_lang$core$Dict$remove, k, _p17._0)); - }); -var _elm_lang$core$Set$union = F2( - function (_p19, _p18) { - var _p20 = _p19; - var _p21 = _p18; - return _elm_lang$core$Set$Set_elm_builtin( - A2(_elm_lang$core$Dict$union, _p20._0, _p21._0)); - }); -var _elm_lang$core$Set$intersect = F2( - function (_p23, _p22) { - var _p24 = _p23; - var _p25 = _p22; - return _elm_lang$core$Set$Set_elm_builtin( - A2(_elm_lang$core$Dict$intersect, _p24._0, _p25._0)); - }); -var _elm_lang$core$Set$diff = F2( - function (_p27, _p26) { - var _p28 = _p27; - var _p29 = _p26; - return _elm_lang$core$Set$Set_elm_builtin( - A2(_elm_lang$core$Dict$diff, _p28._0, _p29._0)); - }); -var _elm_lang$core$Set$filter = F2( - function (p, _p30) { - var _p31 = _p30; - return _elm_lang$core$Set$Set_elm_builtin( - A2( - _elm_lang$core$Dict$filter, - F2( - function (k, _p32) { - return p(k); - }), - _p31._0)); - }); -var _elm_lang$core$Set$partition = F2( - function (p, _p33) { - var _p34 = _p33; - var _p35 = A2( - _elm_lang$core$Dict$partition, - F2( - function (k, _p36) { - return p(k); - }), - _p34._0); - var p1 = _p35._0; - var p2 = _p35._1; - return { - ctor: '_Tuple2', - _0: _elm_lang$core$Set$Set_elm_builtin(p1), - _1: _elm_lang$core$Set$Set_elm_builtin(p2) - }; - }); - -var _elm_community$list_extra$List_Extra$greedyGroupsOfWithStep = F3( - function (size, step, xs) { - var okayXs = _elm_lang$core$Native_Utils.cmp( - _elm_lang$core$List$length(xs), - 0) > 0; - var okayArgs = (_elm_lang$core$Native_Utils.cmp(size, 0) > 0) && (_elm_lang$core$Native_Utils.cmp(step, 0) > 0); - var xs_ = A2(_elm_lang$core$List$drop, step, xs); - var group = A2(_elm_lang$core$List$take, size, xs); - return (okayArgs && okayXs) ? { - ctor: '::', - _0: group, - _1: A3(_elm_community$list_extra$List_Extra$greedyGroupsOfWithStep, size, step, xs_) - } : {ctor: '[]'}; - }); -var _elm_community$list_extra$List_Extra$greedyGroupsOf = F2( - function (size, xs) { - return A3(_elm_community$list_extra$List_Extra$greedyGroupsOfWithStep, size, size, xs); - }); -var _elm_community$list_extra$List_Extra$groupsOfWithStep = F3( - function (size, step, xs) { - var okayArgs = (_elm_lang$core$Native_Utils.cmp(size, 0) > 0) && (_elm_lang$core$Native_Utils.cmp(step, 0) > 0); - var xs_ = A2(_elm_lang$core$List$drop, step, xs); - var group = A2(_elm_lang$core$List$take, size, xs); - var okayLength = _elm_lang$core$Native_Utils.eq( - size, - _elm_lang$core$List$length(group)); - return (okayArgs && okayLength) ? { - ctor: '::', - _0: group, - _1: A3(_elm_community$list_extra$List_Extra$groupsOfWithStep, size, step, xs_) - } : {ctor: '[]'}; - }); -var _elm_community$list_extra$List_Extra$groupsOf = F2( - function (size, xs) { - return A3(_elm_community$list_extra$List_Extra$groupsOfWithStep, size, size, xs); - }); -var _elm_community$list_extra$List_Extra$zip5 = _elm_lang$core$List$map5( - F5( - function (v0, v1, v2, v3, v4) { - return {ctor: '_Tuple5', _0: v0, _1: v1, _2: v2, _3: v3, _4: v4}; - })); -var _elm_community$list_extra$List_Extra$zip4 = _elm_lang$core$List$map4( - F4( - function (v0, v1, v2, v3) { - return {ctor: '_Tuple4', _0: v0, _1: v1, _2: v2, _3: v3}; - })); -var _elm_community$list_extra$List_Extra$zip3 = _elm_lang$core$List$map3( - F3( - function (v0, v1, v2) { - return {ctor: '_Tuple3', _0: v0, _1: v1, _2: v2}; - })); -var _elm_community$list_extra$List_Extra$zip = _elm_lang$core$List$map2( - F2( - function (v0, v1) { - return {ctor: '_Tuple2', _0: v0, _1: v1}; - })); -var _elm_community$list_extra$List_Extra$isPrefixOf = F2( - function (prefix, xs) { - var _p0 = {ctor: '_Tuple2', _0: prefix, _1: xs}; - if (_p0._0.ctor === '[]') { - return true; - } else { - if (_p0._1.ctor === '[]') { - return false; - } else { - return _elm_lang$core$Native_Utils.eq(_p0._0._0, _p0._1._0) && A2(_elm_community$list_extra$List_Extra$isPrefixOf, _p0._0._1, _p0._1._1); - } - } - }); -var _elm_community$list_extra$List_Extra$isSuffixOf = F2( - function (suffix, xs) { - return A2( - _elm_community$list_extra$List_Extra$isPrefixOf, - _elm_lang$core$List$reverse(suffix), - _elm_lang$core$List$reverse(xs)); - }); -var _elm_community$list_extra$List_Extra$selectSplit = function (xs) { - var _p1 = xs; - if (_p1.ctor === '[]') { - return {ctor: '[]'}; - } else { - var _p5 = _p1._1; - var _p4 = _p1._0; - return { - ctor: '::', - _0: { - ctor: '_Tuple3', - _0: {ctor: '[]'}, - _1: _p4, - _2: _p5 - }, - _1: A2( - _elm_lang$core$List$map, - function (_p2) { - var _p3 = _p2; - return { - ctor: '_Tuple3', - _0: {ctor: '::', _0: _p4, _1: _p3._0}, - _1: _p3._1, - _2: _p3._2 - }; - }, - _elm_community$list_extra$List_Extra$selectSplit(_p5)) - }; - } -}; -var _elm_community$list_extra$List_Extra$select = function (xs) { - var _p6 = xs; - if (_p6.ctor === '[]') { - return {ctor: '[]'}; - } else { - var _p10 = _p6._1; - var _p9 = _p6._0; - return { - ctor: '::', - _0: {ctor: '_Tuple2', _0: _p9, _1: _p10}, - _1: A2( - _elm_lang$core$List$map, - function (_p7) { - var _p8 = _p7; - return { - ctor: '_Tuple2', - _0: _p8._0, - _1: {ctor: '::', _0: _p9, _1: _p8._1} - }; - }, - _elm_community$list_extra$List_Extra$select(_p10)) - }; - } -}; -var _elm_community$list_extra$List_Extra$tailsHelp = F2( - function (e, list) { - var _p11 = list; - if (_p11.ctor === '::') { - var _p12 = _p11._0; - return { - ctor: '::', - _0: {ctor: '::', _0: e, _1: _p12}, - _1: {ctor: '::', _0: _p12, _1: _p11._1} - }; - } else { - return {ctor: '[]'}; - } - }); -var _elm_community$list_extra$List_Extra$tails = A2( - _elm_lang$core$List$foldr, - _elm_community$list_extra$List_Extra$tailsHelp, - { - ctor: '::', - _0: {ctor: '[]'}, - _1: {ctor: '[]'} - }); -var _elm_community$list_extra$List_Extra$isInfixOf = F2( - function (infix, xs) { - return A2( - _elm_lang$core$List$any, - _elm_community$list_extra$List_Extra$isPrefixOf(infix), - _elm_community$list_extra$List_Extra$tails(xs)); - }); -var _elm_community$list_extra$List_Extra$inits = A2( - _elm_lang$core$List$foldr, - F2( - function (e, acc) { - return { - ctor: '::', - _0: {ctor: '[]'}, - _1: A2( - _elm_lang$core$List$map, - F2( - function (x, y) { - return {ctor: '::', _0: x, _1: y}; - })(e), - acc) - }; - }), - { - ctor: '::', - _0: {ctor: '[]'}, - _1: {ctor: '[]'} - }); -var _elm_community$list_extra$List_Extra$groupWhileTransitively = F2( - function (cmp, xs_) { - var _p13 = xs_; - if (_p13.ctor === '[]') { - return {ctor: '[]'}; - } else { - if (_p13._1.ctor === '[]') { - return { - ctor: '::', - _0: { - ctor: '::', - _0: _p13._0, - _1: {ctor: '[]'} - }, - _1: {ctor: '[]'} - }; - } else { - var _p15 = _p13._0; - var _p14 = A2(_elm_community$list_extra$List_Extra$groupWhileTransitively, cmp, _p13._1); - if (_p14.ctor === '::') { - return A2(cmp, _p15, _p13._1._0) ? { - ctor: '::', - _0: {ctor: '::', _0: _p15, _1: _p14._0}, - _1: _p14._1 - } : { - ctor: '::', - _0: { - ctor: '::', - _0: _p15, - _1: {ctor: '[]'} - }, - _1: _p14 - }; - } else { - return {ctor: '[]'}; - } - } - } - }); -var _elm_community$list_extra$List_Extra$stripPrefix = F2( - function (prefix, xs) { - var step = F2( - function (e, m) { - var _p16 = m; - if (_p16.ctor === 'Nothing') { - return _elm_lang$core$Maybe$Nothing; - } else { - if (_p16._0.ctor === '[]') { - return _elm_lang$core$Maybe$Nothing; - } else { - return _elm_lang$core$Native_Utils.eq(e, _p16._0._0) ? _elm_lang$core$Maybe$Just(_p16._0._1) : _elm_lang$core$Maybe$Nothing; - } - } - }); - return A3( - _elm_lang$core$List$foldl, - step, - _elm_lang$core$Maybe$Just(xs), - prefix); - }); -var _elm_community$list_extra$List_Extra$dropWhileRight = function (p) { - return A2( - _elm_lang$core$List$foldr, - F2( - function (x, xs) { - return (p(x) && _elm_lang$core$List$isEmpty(xs)) ? {ctor: '[]'} : {ctor: '::', _0: x, _1: xs}; - }), - {ctor: '[]'}); -}; -var _elm_community$list_extra$List_Extra$takeWhileRight = function (p) { - var step = F2( - function (x, _p17) { - var _p18 = _p17; - var _p19 = _p18._0; - return (p(x) && _p18._1) ? { - ctor: '_Tuple2', - _0: {ctor: '::', _0: x, _1: _p19}, - _1: true - } : {ctor: '_Tuple2', _0: _p19, _1: false}; - }); - return function (_p20) { - return _elm_lang$core$Tuple$first( - A3( - _elm_lang$core$List$foldr, - step, - { - ctor: '_Tuple2', - _0: {ctor: '[]'}, - _1: true - }, - _p20)); - }; -}; -var _elm_community$list_extra$List_Extra$splitAt = F2( - function (n, xs) { - return { - ctor: '_Tuple2', - _0: A2(_elm_lang$core$List$take, n, xs), - _1: A2(_elm_lang$core$List$drop, n, xs) - }; - }); -var _elm_community$list_extra$List_Extra$groupsOfVarying_ = F3( - function (listOflengths, list, accu) { - groupsOfVarying_: - while (true) { - var _p21 = {ctor: '_Tuple2', _0: listOflengths, _1: list}; - if (((_p21.ctor === '_Tuple2') && (_p21._0.ctor === '::')) && (_p21._1.ctor === '::')) { - var _p22 = A2(_elm_community$list_extra$List_Extra$splitAt, _p21._0._0, list); - var head = _p22._0; - var tail = _p22._1; - var _v11 = _p21._0._1, - _v12 = tail, - _v13 = {ctor: '::', _0: head, _1: accu}; - listOflengths = _v11; - list = _v12; - accu = _v13; - continue groupsOfVarying_; - } else { - return _elm_lang$core$List$reverse(accu); - } - } - }); -var _elm_community$list_extra$List_Extra$groupsOfVarying = F2( - function (listOflengths, list) { - return A3( - _elm_community$list_extra$List_Extra$groupsOfVarying_, - listOflengths, - list, - {ctor: '[]'}); - }); -var _elm_community$list_extra$List_Extra$unfoldr = F2( - function (f, seed) { - var _p23 = f(seed); - if (_p23.ctor === 'Nothing') { - return {ctor: '[]'}; - } else { - return { - ctor: '::', - _0: _p23._0._0, - _1: A2(_elm_community$list_extra$List_Extra$unfoldr, f, _p23._0._1) - }; - } - }); -var _elm_community$list_extra$List_Extra$scanr1 = F2( - function (f, xs_) { - var _p24 = xs_; - if (_p24.ctor === '[]') { - return {ctor: '[]'}; - } else { - if (_p24._1.ctor === '[]') { - return { - ctor: '::', - _0: _p24._0, - _1: {ctor: '[]'} - }; - } else { - var _p25 = A2(_elm_community$list_extra$List_Extra$scanr1, f, _p24._1); - if (_p25.ctor === '::') { - return { - ctor: '::', - _0: A2(f, _p24._0, _p25._0), - _1: _p25 - }; - } else { - return {ctor: '[]'}; - } - } - } - }); -var _elm_community$list_extra$List_Extra$scanr = F3( - function (f, acc, xs_) { - var _p26 = xs_; - if (_p26.ctor === '[]') { - return { - ctor: '::', - _0: acc, - _1: {ctor: '[]'} - }; - } else { - var _p27 = A3(_elm_community$list_extra$List_Extra$scanr, f, acc, _p26._1); - if (_p27.ctor === '::') { - return { - ctor: '::', - _0: A2(f, _p26._0, _p27._0), - _1: _p27 - }; - } else { - return {ctor: '[]'}; - } - } - }); -var _elm_community$list_extra$List_Extra$scanl1 = F2( - function (f, xs_) { - var _p28 = xs_; - if (_p28.ctor === '[]') { - return {ctor: '[]'}; - } else { - return A3(_elm_lang$core$List$scanl, f, _p28._0, _p28._1); - } - }); -var _elm_community$list_extra$List_Extra$indexedFoldr = F3( - function (func, acc, list) { - var step = F2( - function (x, _p29) { - var _p30 = _p29; - var _p31 = _p30._0; - return { - ctor: '_Tuple2', - _0: _p31 - 1, - _1: A3(func, _p31, x, _p30._1) - }; - }); - return _elm_lang$core$Tuple$second( - A3( - _elm_lang$core$List$foldr, - step, - { - ctor: '_Tuple2', - _0: _elm_lang$core$List$length(list) - 1, - _1: acc - }, - list)); - }); -var _elm_community$list_extra$List_Extra$indexedFoldl = F3( - function (func, acc, list) { - var step = F2( - function (x, _p32) { - var _p33 = _p32; - var _p34 = _p33._0; - return { - ctor: '_Tuple2', - _0: _p34 + 1, - _1: A3(func, _p34, x, _p33._1) - }; - }); - return _elm_lang$core$Tuple$second( - A3( - _elm_lang$core$List$foldl, - step, - {ctor: '_Tuple2', _0: 0, _1: acc}, - list)); - }); -var _elm_community$list_extra$List_Extra$foldr1 = F2( - function (f, xs) { - var mf = F2( - function (x, m) { - return _elm_lang$core$Maybe$Just( - function () { - var _p35 = m; - if (_p35.ctor === 'Nothing') { - return x; - } else { - return A2(f, x, _p35._0); - } - }()); - }); - return A3(_elm_lang$core$List$foldr, mf, _elm_lang$core$Maybe$Nothing, xs); - }); -var _elm_community$list_extra$List_Extra$foldl1 = F2( - function (f, xs) { - var mf = F2( - function (x, m) { - return _elm_lang$core$Maybe$Just( - function () { - var _p36 = m; - if (_p36.ctor === 'Nothing') { - return x; - } else { - return A2(f, _p36._0, x); - } - }()); - }); - return A3(_elm_lang$core$List$foldl, mf, _elm_lang$core$Maybe$Nothing, xs); - }); -var _elm_community$list_extra$List_Extra$interweaveHelp = F3( - function (l1, l2, acc) { - interweaveHelp: - while (true) { - var _p37 = {ctor: '_Tuple2', _0: l1, _1: l2}; - _v24_1: - do { - if (_p37._0.ctor === '::') { - if (_p37._1.ctor === '::') { - var _v25 = _p37._0._1, - _v26 = _p37._1._1, - _v27 = A2( - _elm_lang$core$Basics_ops['++'], - acc, - { - ctor: '::', - _0: _p37._0._0, - _1: { - ctor: '::', - _0: _p37._1._0, - _1: {ctor: '[]'} - } - }); - l1 = _v25; - l2 = _v26; - acc = _v27; - continue interweaveHelp; - } else { - break _v24_1; - } - } else { - if (_p37._1.ctor === '[]') { - break _v24_1; - } else { - return A2(_elm_lang$core$Basics_ops['++'], acc, _p37._1); - } - } - } while(false); - return A2(_elm_lang$core$Basics_ops['++'], acc, _p37._0); - } - }); -var _elm_community$list_extra$List_Extra$interweave = F2( - function (l1, l2) { - return A3( - _elm_community$list_extra$List_Extra$interweaveHelp, - l1, - l2, - {ctor: '[]'}); - }); -var _elm_community$list_extra$List_Extra$permutations = function (xs_) { - var _p38 = xs_; - if (_p38.ctor === '[]') { - return { - ctor: '::', - _0: {ctor: '[]'}, - _1: {ctor: '[]'} - }; - } else { - var f = function (_p39) { - var _p40 = _p39; - return A2( - _elm_lang$core$List$map, - F2( - function (x, y) { - return {ctor: '::', _0: x, _1: y}; - })(_p40._0), - _elm_community$list_extra$List_Extra$permutations(_p40._1)); - }; - return A2( - _elm_lang$core$List$concatMap, - f, - _elm_community$list_extra$List_Extra$select(_p38)); - } -}; -var _elm_community$list_extra$List_Extra$isPermutationOf = F2( - function (permut, xs) { - return A2( - _elm_lang$core$List$member, - permut, - _elm_community$list_extra$List_Extra$permutations(xs)); - }); -var _elm_community$list_extra$List_Extra$subsequencesNonEmpty = function (xs) { - var _p41 = xs; - if (_p41.ctor === '[]') { - return {ctor: '[]'}; - } else { - var _p42 = _p41._0; - var f = F2( - function (ys, r) { - return { - ctor: '::', - _0: ys, - _1: { - ctor: '::', - _0: {ctor: '::', _0: _p42, _1: ys}, - _1: r - } - }; - }); - return { - ctor: '::', - _0: { - ctor: '::', - _0: _p42, - _1: {ctor: '[]'} - }, - _1: A3( - _elm_lang$core$List$foldr, - f, - {ctor: '[]'}, - _elm_community$list_extra$List_Extra$subsequencesNonEmpty(_p41._1)) - }; - } -}; -var _elm_community$list_extra$List_Extra$subsequences = function (xs) { - return { - ctor: '::', - _0: {ctor: '[]'}, - _1: _elm_community$list_extra$List_Extra$subsequencesNonEmpty(xs) - }; -}; -var _elm_community$list_extra$List_Extra$isSubsequenceOf = F2( - function (subseq, xs) { - return A2( - _elm_lang$core$List$member, - subseq, - _elm_community$list_extra$List_Extra$subsequences(xs)); - }); -var _elm_community$list_extra$List_Extra$transpose = function (ll) { - transpose: - while (true) { - var _p43 = ll; - if (_p43.ctor === '[]') { - return {ctor: '[]'}; - } else { - if (_p43._0.ctor === '[]') { - var _v32 = _p43._1; - ll = _v32; - continue transpose; - } else { - var _p44 = _p43._1; - var tails = A2(_elm_lang$core$List$filterMap, _elm_lang$core$List$tail, _p44); - var heads = A2(_elm_lang$core$List$filterMap, _elm_lang$core$List$head, _p44); - return { - ctor: '::', - _0: {ctor: '::', _0: _p43._0._0, _1: heads}, - _1: _elm_community$list_extra$List_Extra$transpose( - {ctor: '::', _0: _p43._0._1, _1: tails}) - }; - } - } - } -}; -var _elm_community$list_extra$List_Extra$intercalate = function (xs) { - return function (_p45) { - return _elm_lang$core$List$concat( - A2(_elm_lang$core$List$intersperse, xs, _p45)); - }; -}; -var _elm_community$list_extra$List_Extra$filterNot = F2( - function (pred, list) { - return A2( - _elm_lang$core$List$filter, - function (_p46) { - return !pred(_p46); - }, - list); - }); -var _elm_community$list_extra$List_Extra$removeAt = F2( - function (index, l) { - if (_elm_lang$core$Native_Utils.cmp(index, 0) < 0) { - return l; - } else { - var tail = _elm_lang$core$List$tail( - A2(_elm_lang$core$List$drop, index, l)); - var head = A2(_elm_lang$core$List$take, index, l); - var _p47 = tail; - if (_p47.ctor === 'Nothing') { - return l; - } else { - return A2(_elm_lang$core$List$append, head, _p47._0); - } - } - }); -var _elm_community$list_extra$List_Extra$singleton = function (x) { - return { - ctor: '::', - _0: x, - _1: {ctor: '[]'} - }; -}; -var _elm_community$list_extra$List_Extra$stableSortWith = F2( - function (pred, list) { - var predWithIndex = F2( - function (_p49, _p48) { - var _p50 = _p49; - var _p51 = _p48; - var result = A2(pred, _p50._0, _p51._0); - var _p52 = result; - if (_p52.ctor === 'EQ') { - return A2(_elm_lang$core$Basics$compare, _p50._1, _p51._1); - } else { - return result; - } - }); - var listWithIndex = A2( - _elm_lang$core$List$indexedMap, - F2( - function (i, a) { - return {ctor: '_Tuple2', _0: a, _1: i}; - }), - list); - return A2( - _elm_lang$core$List$map, - _elm_lang$core$Tuple$first, - A2(_elm_lang$core$List$sortWith, predWithIndex, listWithIndex)); - }); -var _elm_community$list_extra$List_Extra$setAt = F3( - function (index, value, l) { - if (_elm_lang$core$Native_Utils.cmp(index, 0) < 0) { - return _elm_lang$core$Maybe$Nothing; - } else { - var tail = _elm_lang$core$List$tail( - A2(_elm_lang$core$List$drop, index, l)); - var head = A2(_elm_lang$core$List$take, index, l); - var _p53 = tail; - if (_p53.ctor === 'Nothing') { - return _elm_lang$core$Maybe$Nothing; - } else { - return _elm_lang$core$Maybe$Just( - A2( - _elm_lang$core$List$append, - head, - {ctor: '::', _0: value, _1: _p53._0})); - } - } - }); -var _elm_community$list_extra$List_Extra$remove = F2( - function (x, xs) { - var _p54 = xs; - if (_p54.ctor === '[]') { - return {ctor: '[]'}; - } else { - var _p56 = _p54._1; - var _p55 = _p54._0; - return _elm_lang$core$Native_Utils.eq(x, _p55) ? _p56 : { - ctor: '::', - _0: _p55, - _1: A2(_elm_community$list_extra$List_Extra$remove, x, _p56) - }; - } - }); -var _elm_community$list_extra$List_Extra$updateIfIndex = F3( - function (predicate, update, list) { - return A2( - _elm_lang$core$List$indexedMap, - F2( - function (i, x) { - return predicate(i) ? update(x) : x; - }), - list); - }); -var _elm_community$list_extra$List_Extra$updateAt = F3( - function (index, update, list) { - return ((_elm_lang$core$Native_Utils.cmp(index, 0) < 0) || (_elm_lang$core$Native_Utils.cmp( - index, - _elm_lang$core$List$length(list)) > -1)) ? _elm_lang$core$Maybe$Nothing : _elm_lang$core$Maybe$Just( - A3( - _elm_community$list_extra$List_Extra$updateIfIndex, - F2( - function (x, y) { - return _elm_lang$core$Native_Utils.eq(x, y); - })(index), - update, - list)); - }); -var _elm_community$list_extra$List_Extra$updateIf = F3( - function (predicate, update, list) { - return A2( - _elm_lang$core$List$map, - function (item) { - return predicate(item) ? update(item) : item; - }, - list); - }); -var _elm_community$list_extra$List_Extra$replaceIf = F3( - function (predicate, replacement, list) { - return A3( - _elm_community$list_extra$List_Extra$updateIf, - predicate, - _elm_lang$core$Basics$always(replacement), - list); - }); -var _elm_community$list_extra$List_Extra$findIndices = function (p) { - return function (_p57) { - return A2( - _elm_lang$core$List$map, - _elm_lang$core$Tuple$first, - A2( - _elm_lang$core$List$filter, - function (_p58) { - var _p59 = _p58; - return p(_p59._1); - }, - A2( - _elm_lang$core$List$indexedMap, - F2( - function (v0, v1) { - return {ctor: '_Tuple2', _0: v0, _1: v1}; - }), - _p57))); - }; -}; -var _elm_community$list_extra$List_Extra$findIndex = function (p) { - return function (_p60) { - return _elm_lang$core$List$head( - A2(_elm_community$list_extra$List_Extra$findIndices, p, _p60)); - }; -}; -var _elm_community$list_extra$List_Extra$elemIndices = function (x) { - return _elm_community$list_extra$List_Extra$findIndices( - F2( - function (x, y) { - return _elm_lang$core$Native_Utils.eq(x, y); - })(x)); -}; -var _elm_community$list_extra$List_Extra$elemIndex = function (x) { - return _elm_community$list_extra$List_Extra$findIndex( - F2( - function (x, y) { - return _elm_lang$core$Native_Utils.eq(x, y); - })(x)); -}; -var _elm_community$list_extra$List_Extra$find = F2( - function (predicate, list) { - find: - while (true) { - var _p61 = list; - if (_p61.ctor === '[]') { - return _elm_lang$core$Maybe$Nothing; - } else { - var _p62 = _p61._0; - if (predicate(_p62)) { - return _elm_lang$core$Maybe$Just(_p62); - } else { - var _v41 = predicate, - _v42 = _p61._1; - predicate = _v41; - list = _v42; - continue find; - } - } - } - }); -var _elm_community$list_extra$List_Extra$notMember = function (x) { - return function (_p63) { - return !A2(_elm_lang$core$List$member, x, _p63); - }; -}; -var _elm_community$list_extra$List_Extra$andThen = _elm_lang$core$List$concatMap; -var _elm_community$list_extra$List_Extra$lift2 = F3( - function (f, la, lb) { - return A2( - _elm_community$list_extra$List_Extra$andThen, - function (a) { - return A2( - _elm_community$list_extra$List_Extra$andThen, - function (b) { - return { - ctor: '::', - _0: A2(f, a, b), - _1: {ctor: '[]'} - }; - }, - lb); - }, - la); - }); -var _elm_community$list_extra$List_Extra$lift3 = F4( - function (f, la, lb, lc) { - return A2( - _elm_community$list_extra$List_Extra$andThen, - function (a) { - return A2( - _elm_community$list_extra$List_Extra$andThen, - function (b) { - return A2( - _elm_community$list_extra$List_Extra$andThen, - function (c) { - return { - ctor: '::', - _0: A3(f, a, b, c), - _1: {ctor: '[]'} - }; - }, - lc); - }, - lb); - }, - la); - }); -var _elm_community$list_extra$List_Extra$lift4 = F5( - function (f, la, lb, lc, ld) { - return A2( - _elm_community$list_extra$List_Extra$andThen, - function (a) { - return A2( - _elm_community$list_extra$List_Extra$andThen, - function (b) { - return A2( - _elm_community$list_extra$List_Extra$andThen, - function (c) { - return A2( - _elm_community$list_extra$List_Extra$andThen, - function (d) { - return { - ctor: '::', - _0: A4(f, a, b, c, d), - _1: {ctor: '[]'} - }; - }, - ld); - }, - lc); - }, - lb); - }, - la); - }); -var _elm_community$list_extra$List_Extra$andMap = F2( - function (l, fl) { - return A3( - _elm_lang$core$List$map2, - F2( - function (x, y) { - return x(y); - }), - fl, - l); - }); -var _elm_community$list_extra$List_Extra$uniqueHelp = F3( - function (f, existing, remaining) { - uniqueHelp: - while (true) { - var _p64 = remaining; - if (_p64.ctor === '[]') { - return {ctor: '[]'}; - } else { - var _p66 = _p64._1; - var _p65 = _p64._0; - var computedFirst = f(_p65); - if (A2(_elm_lang$core$Set$member, computedFirst, existing)) { - var _v44 = f, - _v45 = existing, - _v46 = _p66; - f = _v44; - existing = _v45; - remaining = _v46; - continue uniqueHelp; - } else { - return { - ctor: '::', - _0: _p65, - _1: A3( - _elm_community$list_extra$List_Extra$uniqueHelp, - f, - A2(_elm_lang$core$Set$insert, computedFirst, existing), - _p66) - }; - } - } - } - }); -var _elm_community$list_extra$List_Extra$uniqueBy = F2( - function (f, list) { - return A3(_elm_community$list_extra$List_Extra$uniqueHelp, f, _elm_lang$core$Set$empty, list); - }); -var _elm_community$list_extra$List_Extra$allDifferentBy = F2( - function (f, list) { - return _elm_lang$core$Native_Utils.eq( - _elm_lang$core$List$length(list), - _elm_lang$core$List$length( - A2(_elm_community$list_extra$List_Extra$uniqueBy, f, list))); - }); -var _elm_community$list_extra$List_Extra$allDifferent = function (list) { - return A2(_elm_community$list_extra$List_Extra$allDifferentBy, _elm_lang$core$Basics$identity, list); -}; -var _elm_community$list_extra$List_Extra$unique = function (list) { - return A3(_elm_community$list_extra$List_Extra$uniqueHelp, _elm_lang$core$Basics$identity, _elm_lang$core$Set$empty, list); -}; -var _elm_community$list_extra$List_Extra$dropWhile = F2( - function (predicate, list) { - dropWhile: - while (true) { - var _p67 = list; - if (_p67.ctor === '[]') { - return {ctor: '[]'}; - } else { - if (predicate(_p67._0)) { - var _v48 = predicate, - _v49 = _p67._1; - predicate = _v48; - list = _v49; - continue dropWhile; - } else { - return list; - } - } - } - }); -var _elm_community$list_extra$List_Extra$takeWhile = function (predicate) { - var takeWhileMemo = F2( - function (memo, list) { - takeWhileMemo: - while (true) { - var _p68 = list; - if (_p68.ctor === '[]') { - return _elm_lang$core$List$reverse(memo); - } else { - var _p69 = _p68._0; - if (predicate(_p69)) { - var _v51 = {ctor: '::', _0: _p69, _1: memo}, - _v52 = _p68._1; - memo = _v51; - list = _v52; - continue takeWhileMemo; - } else { - return _elm_lang$core$List$reverse(memo); - } - } - } - }); - return takeWhileMemo( - {ctor: '[]'}); -}; -var _elm_community$list_extra$List_Extra$span = F2( - function (p, xs) { - return { - ctor: '_Tuple2', - _0: A2(_elm_community$list_extra$List_Extra$takeWhile, p, xs), - _1: A2(_elm_community$list_extra$List_Extra$dropWhile, p, xs) - }; - }); -var _elm_community$list_extra$List_Extra$break = function (p) { - return _elm_community$list_extra$List_Extra$span( - function (_p70) { - return !p(_p70); - }); -}; -var _elm_community$list_extra$List_Extra$groupWhile = F2( - function (eq, xs_) { - var _p71 = xs_; - if (_p71.ctor === '[]') { - return {ctor: '[]'}; - } else { - var _p73 = _p71._0; - var _p72 = A2( - _elm_community$list_extra$List_Extra$span, - eq(_p73), - _p71._1); - var ys = _p72._0; - var zs = _p72._1; - return { - ctor: '::', - _0: {ctor: '::', _0: _p73, _1: ys}, - _1: A2(_elm_community$list_extra$List_Extra$groupWhile, eq, zs) - }; - } - }); -var _elm_community$list_extra$List_Extra$group = _elm_community$list_extra$List_Extra$groupWhile( - F2( - function (x, y) { - return _elm_lang$core$Native_Utils.eq(x, y); - })); -var _elm_community$list_extra$List_Extra$minimumBy = F2( - function (f, ls) { - var minBy = F2( - function (x, _p74) { - var _p75 = _p74; - var _p76 = _p75._1; - var fx = f(x); - return (_elm_lang$core$Native_Utils.cmp(fx, _p76) < 0) ? {ctor: '_Tuple2', _0: x, _1: fx} : {ctor: '_Tuple2', _0: _p75._0, _1: _p76}; - }); - var _p77 = ls; - if (_p77.ctor === '::') { - if (_p77._1.ctor === '[]') { - return _elm_lang$core$Maybe$Just(_p77._0); - } else { - var _p78 = _p77._0; - return _elm_lang$core$Maybe$Just( - _elm_lang$core$Tuple$first( - A3( - _elm_lang$core$List$foldl, - minBy, - { - ctor: '_Tuple2', - _0: _p78, - _1: f(_p78) - }, - _p77._1))); - } - } else { - return _elm_lang$core$Maybe$Nothing; - } - }); -var _elm_community$list_extra$List_Extra$maximumBy = F2( - function (f, ls) { - var maxBy = F2( - function (x, _p79) { - var _p80 = _p79; - var _p81 = _p80._1; - var fx = f(x); - return (_elm_lang$core$Native_Utils.cmp(fx, _p81) > 0) ? {ctor: '_Tuple2', _0: x, _1: fx} : {ctor: '_Tuple2', _0: _p80._0, _1: _p81}; - }); - var _p82 = ls; - if (_p82.ctor === '::') { - if (_p82._1.ctor === '[]') { - return _elm_lang$core$Maybe$Just(_p82._0); - } else { - var _p83 = _p82._0; - return _elm_lang$core$Maybe$Just( - _elm_lang$core$Tuple$first( - A3( - _elm_lang$core$List$foldl, - maxBy, - { - ctor: '_Tuple2', - _0: _p83, - _1: f(_p83) - }, - _p82._1))); - } - } else { - return _elm_lang$core$Maybe$Nothing; - } - }); -var _elm_community$list_extra$List_Extra$uncons = function (xs) { - var _p84 = xs; - if (_p84.ctor === '[]') { - return _elm_lang$core$Maybe$Nothing; - } else { - return _elm_lang$core$Maybe$Just( - {ctor: '_Tuple2', _0: _p84._0, _1: _p84._1}); - } -}; -var _elm_community$list_extra$List_Extra$swapAt = F3( - function (index1, index2, l) { - swapAt: - while (true) { - if (_elm_lang$core$Native_Utils.eq(index1, index2)) { - return _elm_lang$core$Maybe$Just(l); - } else { - if (_elm_lang$core$Native_Utils.cmp(index1, index2) > 0) { - var _v59 = index2, - _v60 = index1, - _v61 = l; - index1 = _v59; - index2 = _v60; - l = _v61; - continue swapAt; - } else { - if (_elm_lang$core$Native_Utils.cmp(index1, 0) < 0) { - return _elm_lang$core$Maybe$Nothing; - } else { - var _p85 = A2(_elm_community$list_extra$List_Extra$splitAt, index1, l); - var part1 = _p85._0; - var tail1 = _p85._1; - var _p86 = A2(_elm_community$list_extra$List_Extra$splitAt, index2 - index1, tail1); - var head2 = _p86._0; - var tail2 = _p86._1; - return A3( - _elm_lang$core$Maybe$map2, - F2( - function (_p88, _p87) { - var _p89 = _p88; - var _p90 = _p87; - return _elm_lang$core$List$concat( - { - ctor: '::', - _0: part1, - _1: { - ctor: '::', - _0: {ctor: '::', _0: _p90._0, _1: _p89._1}, - _1: { - ctor: '::', - _0: {ctor: '::', _0: _p89._0, _1: _p90._1}, - _1: {ctor: '[]'} - } - } - }); - }), - _elm_community$list_extra$List_Extra$uncons(head2), - _elm_community$list_extra$List_Extra$uncons(tail2)); - } - } - } - } - }); -var _elm_community$list_extra$List_Extra$iterate = F2( - function (f, x) { - var _p91 = f(x); - if (_p91.ctor === 'Just') { - return { - ctor: '::', - _0: x, - _1: A2(_elm_community$list_extra$List_Extra$iterate, f, _p91._0) - }; - } else { - return { - ctor: '::', - _0: x, - _1: {ctor: '[]'} - }; - } - }); -var _elm_community$list_extra$List_Extra$getAt = F2( - function (idx, xs) { - return (_elm_lang$core$Native_Utils.cmp(idx, 0) < 0) ? _elm_lang$core$Maybe$Nothing : _elm_lang$core$List$head( - A2(_elm_lang$core$List$drop, idx, xs)); - }); -var _elm_community$list_extra$List_Extra_ops = _elm_community$list_extra$List_Extra_ops || {}; -_elm_community$list_extra$List_Extra_ops['!!'] = _elm_lang$core$Basics$flip(_elm_community$list_extra$List_Extra$getAt); -var _elm_community$list_extra$List_Extra$init = function () { - var maybe = F2( - function (d, f) { - return function (_p92) { - return A2( - _elm_lang$core$Maybe$withDefault, - d, - A2(_elm_lang$core$Maybe$map, f, _p92)); - }; - }); - return A2( - _elm_lang$core$List$foldr, - function (x) { - return function (_p93) { - return _elm_lang$core$Maybe$Just( - A3( - maybe, - {ctor: '[]'}, - F2( - function (x, y) { - return {ctor: '::', _0: x, _1: y}; - })(x), - _p93)); - }; - }, - _elm_lang$core$Maybe$Nothing); -}(); -var _elm_community$list_extra$List_Extra$last = _elm_community$list_extra$List_Extra$foldl1( - _elm_lang$core$Basics$flip(_elm_lang$core$Basics$always)); - -var _Bogdanp$elm_ast$Ast_Expression$op = F2( - function (ops, n) { - return A2( - _elm_lang$core$Maybe$withDefault, - {ctor: '_Tuple2', _0: _Bogdanp$elm_ast$Ast_BinOp$L, _1: 9}, - A2(_elm_lang$core$Dict$get, n, ops)); - }); -var _Bogdanp$elm_ast$Ast_Expression$assoc = F2( - function (ops, n) { - return _elm_lang$core$Tuple$first( - A2(_Bogdanp$elm_ast$Ast_Expression$op, ops, n)); - }); -var _Bogdanp$elm_ast$Ast_Expression$level = F2( - function (ops, n) { - return _elm_lang$core$Tuple$second( - A2(_Bogdanp$elm_ast$Ast_Expression$op, ops, n)); - }); -var _Bogdanp$elm_ast$Ast_Expression$hasLevel = F3( - function (ops, l, _p0) { - var _p1 = _p0; - return _elm_lang$core$Native_Utils.eq( - A2(_Bogdanp$elm_ast$Ast_Expression$level, ops, _p1._0), - l); - }); -var _Bogdanp$elm_ast$Ast_Expression$findAssoc = F3( - function (ops, l, eops) { - var lops = A2( - _elm_lang$core$List$filter, - A2(_Bogdanp$elm_ast$Ast_Expression$hasLevel, ops, l), - eops); - var assocs = A2( - _elm_lang$core$List$map, - function (_p2) { - return A2( - _Bogdanp$elm_ast$Ast_Expression$assoc, - ops, - _elm_lang$core$Tuple$first(_p2)); - }, - lops); - var error = function (issue) { - var operators = A2( - _elm_lang$core$String$join, - ' and ', - A2(_elm_lang$core$List$map, _elm_lang$core$Tuple$first, lops)); - return A2( - _elm_lang$core$Basics_ops['++'], - 'conflicting ', - A2( - _elm_lang$core$Basics_ops['++'], - issue, - A2(_elm_lang$core$Basics_ops['++'], ' for operators ', operators))); - }; - if (A2( - _elm_lang$core$List$all, - F2( - function (x, y) { - return _elm_lang$core$Native_Utils.eq(x, y); - })(_Bogdanp$elm_ast$Ast_BinOp$L), - assocs)) { - return _elm_community$parser_combinators$Combine$succeed(_Bogdanp$elm_ast$Ast_BinOp$L); - } else { - if (A2( - _elm_lang$core$List$all, - F2( - function (x, y) { - return _elm_lang$core$Native_Utils.eq(x, y); - })(_Bogdanp$elm_ast$Ast_BinOp$R), - assocs)) { - return _elm_community$parser_combinators$Combine$succeed(_Bogdanp$elm_ast$Ast_BinOp$R); - } else { - if (A2( - _elm_lang$core$List$all, - F2( - function (x, y) { - return _elm_lang$core$Native_Utils.eq(x, y); - })(_Bogdanp$elm_ast$Ast_BinOp$N), - assocs)) { - var _p3 = assocs; - if ((_p3.ctor === '::') && (_p3._1.ctor === '[]')) { - return _elm_community$parser_combinators$Combine$succeed(_Bogdanp$elm_ast$Ast_BinOp$N); - } else { - return _elm_community$parser_combinators$Combine$fail( - error('precedence')); - } - } else { - return _elm_community$parser_combinators$Combine$fail( - error('associativity')); - } - } - } - }); -var _Bogdanp$elm_ast$Ast_Expression$Stop = function (a) { - return {ctor: 'Stop', _0: a}; -}; -var _Bogdanp$elm_ast$Ast_Expression$Cont = function (a) { - return {ctor: 'Cont', _0: a}; -}; -var _Bogdanp$elm_ast$Ast_Expression$BinOp = F3( - function (a, b, c) { - return {ctor: 'BinOp', _0: a, _1: b, _2: c}; - }); -var _Bogdanp$elm_ast$Ast_Expression$Application = F2( - function (a, b) { - return {ctor: 'Application', _0: a, _1: b}; - }); -var _Bogdanp$elm_ast$Ast_Expression$Lambda = F2( - function (a, b) { - return {ctor: 'Lambda', _0: a, _1: b}; - }); -var _Bogdanp$elm_ast$Ast_Expression$Case = F2( - function (a, b) { - return {ctor: 'Case', _0: a, _1: b}; - }); -var _Bogdanp$elm_ast$Ast_Expression$Let = F2( - function (a, b) { - return {ctor: 'Let', _0: a, _1: b}; - }); -var _Bogdanp$elm_ast$Ast_Expression$If = F3( - function (a, b, c) { - return {ctor: 'If', _0: a, _1: b, _2: c}; - }); -var _Bogdanp$elm_ast$Ast_Expression$RecordUpdate = F2( - function (a, b) { - return {ctor: 'RecordUpdate', _0: a, _1: b}; - }); -var _Bogdanp$elm_ast$Ast_Expression$Record = function (a) { - return {ctor: 'Record', _0: a}; -}; -var _Bogdanp$elm_ast$Ast_Expression$AccessFunction = function (a) { - return {ctor: 'AccessFunction', _0: a}; -}; -var _Bogdanp$elm_ast$Ast_Expression$accessFunction = A2( - _elm_community$parser_combinators$Combine_ops['<$>'], - _Bogdanp$elm_ast$Ast_Expression$AccessFunction, - A2( - _elm_community$parser_combinators$Combine_ops['*>'], - _elm_community$parser_combinators$Combine$string('.'), - _Bogdanp$elm_ast$Ast_Helpers$loName)); -var _Bogdanp$elm_ast$Ast_Expression$Access = F2( - function (a, b) { - return {ctor: 'Access', _0: a, _1: b}; - }); -var _Bogdanp$elm_ast$Ast_Expression$Tuple = function (a) { - return {ctor: 'Tuple', _0: a}; -}; -var _Bogdanp$elm_ast$Ast_Expression$List = function (a) { - return {ctor: 'List', _0: a}; -}; -var _Bogdanp$elm_ast$Ast_Expression$Variable = function (a) { - return {ctor: 'Variable', _0: a}; -}; -var _Bogdanp$elm_ast$Ast_Expression$variable = A2( - _elm_community$parser_combinators$Combine_ops['<$>'], - _Bogdanp$elm_ast$Ast_Expression$Variable, - _elm_community$parser_combinators$Combine$choice( - { - ctor: '::', - _0: A2(_elm_community$parser_combinators$Combine_ops['<$>'], _elm_community$list_extra$List_Extra$singleton, _Bogdanp$elm_ast$Ast_Helpers$emptyTuple), - _1: { - ctor: '::', - _0: A2(_elm_community$parser_combinators$Combine_ops['<$>'], _elm_community$list_extra$List_Extra$singleton, _Bogdanp$elm_ast$Ast_Helpers$loName), - _1: { - ctor: '::', - _0: A2( - _elm_community$parser_combinators$Combine$sepBy1, - _elm_community$parser_combinators$Combine$string('.'), - _Bogdanp$elm_ast$Ast_Helpers$upName), - _1: { - ctor: '::', - _0: A2( - _elm_community$parser_combinators$Combine_ops['<$>'], - _elm_community$list_extra$List_Extra$singleton, - _elm_community$parser_combinators$Combine$parens(_Bogdanp$elm_ast$Ast_Helpers$operator)), - _1: { - ctor: '::', - _0: A2( - _elm_community$parser_combinators$Combine_ops['<$>'], - _elm_community$list_extra$List_Extra$singleton, - _elm_community$parser_combinators$Combine$parens( - _elm_community$parser_combinators$Combine$regex(',+'))), - _1: {ctor: '[]'} - } - } - } - } - })); -var _Bogdanp$elm_ast$Ast_Expression$access = A2( - _elm_community$parser_combinators$Combine_ops['<*>'], - A2(_elm_community$parser_combinators$Combine_ops['<$>'], _Bogdanp$elm_ast$Ast_Expression$Access, _Bogdanp$elm_ast$Ast_Expression$variable), - _elm_community$parser_combinators$Combine$many1( - A2( - _elm_community$parser_combinators$Combine_ops['*>'], - _elm_community$parser_combinators$Combine$string('.'), - _Bogdanp$elm_ast$Ast_Helpers$loName))); -var _Bogdanp$elm_ast$Ast_Expression$simplifiedRecord = _elm_community$parser_combinators$Combine$lazy( - function (_p4) { - var _p5 = _p4; - return A2( - _elm_community$parser_combinators$Combine_ops['<$>'], - _Bogdanp$elm_ast$Ast_Expression$Record, - _elm_community$parser_combinators$Combine$braces( - _Bogdanp$elm_ast$Ast_Helpers$commaSeparated( - A2( - _elm_community$parser_combinators$Combine_ops['<$>'], - function (a) { - return { - ctor: '_Tuple2', - _0: a, - _1: _Bogdanp$elm_ast$Ast_Expression$Variable( - { - ctor: '::', - _0: a, - _1: {ctor: '[]'} - }) - }; - }, - _Bogdanp$elm_ast$Ast_Helpers$loName)))); - }); -var _Bogdanp$elm_ast$Ast_Expression$joinL = F2( - function (es, ops) { - joinL: - while (true) { - var _p6 = {ctor: '_Tuple2', _0: es, _1: ops}; - _v3_2: - do { - if ((_p6.ctor === '_Tuple2') && (_p6._0.ctor === '::')) { - if (_p6._0._1.ctor === '[]') { - if (_p6._1.ctor === '[]') { - return _elm_community$parser_combinators$Combine$succeed(_p6._0._0); - } else { - break _v3_2; - } - } else { - if (_p6._1.ctor === '::') { - var _v4 = { - ctor: '::', - _0: A3( - _Bogdanp$elm_ast$Ast_Expression$BinOp, - _Bogdanp$elm_ast$Ast_Expression$Variable( - { - ctor: '::', - _0: _p6._1._0, - _1: {ctor: '[]'} - }), - _p6._0._0, - _p6._0._1._0), - _1: _p6._0._1._1 - }, - _v5 = _p6._1._1; - es = _v4; - ops = _v5; - continue joinL; - } else { - break _v3_2; - } - } - } else { - break _v3_2; - } - } while(false); - return _elm_community$parser_combinators$Combine$fail(''); - } - }); -var _Bogdanp$elm_ast$Ast_Expression$joinR = F2( - function (es, ops) { - var _p7 = {ctor: '_Tuple2', _0: es, _1: ops}; - _v6_2: - do { - if ((_p7.ctor === '_Tuple2') && (_p7._0.ctor === '::')) { - if (_p7._0._1.ctor === '[]') { - if (_p7._1.ctor === '[]') { - return _elm_community$parser_combinators$Combine$succeed(_p7._0._0); - } else { - break _v6_2; - } - } else { - if (_p7._1.ctor === '::') { - return A2( - _elm_community$parser_combinators$Combine$andThen, - function (e) { - return _elm_community$parser_combinators$Combine$succeed( - A3( - _Bogdanp$elm_ast$Ast_Expression$BinOp, - _Bogdanp$elm_ast$Ast_Expression$Variable( - { - ctor: '::', - _0: _p7._1._0, - _1: {ctor: '[]'} - }), - _p7._0._0, - e)); - }, - A2( - _Bogdanp$elm_ast$Ast_Expression$joinR, - {ctor: '::', _0: _p7._0._1._0, _1: _p7._0._1._1}, - _p7._1._1)); - } else { - break _v6_2; - } - } - } else { - break _v6_2; - } - } while(false); - return _elm_community$parser_combinators$Combine$fail(''); - }); -var _Bogdanp$elm_ast$Ast_Expression$split = F4( - function (ops, l, e, eops) { - var _p8 = eops; - if (_p8.ctor === '[]') { - return _elm_community$parser_combinators$Combine$succeed(e); - } else { - return A2( - _elm_community$parser_combinators$Combine$andThen, - function (assoc) { - return A2( - _elm_community$parser_combinators$Combine$andThen, - function (es) { - var ops_ = A2( - _elm_lang$core$List$filterMap, - function (x) { - return A3(_Bogdanp$elm_ast$Ast_Expression$hasLevel, ops, l, x) ? _elm_lang$core$Maybe$Just( - _elm_lang$core$Tuple$first(x)) : _elm_lang$core$Maybe$Nothing; - }, - eops); - var _p9 = assoc; - if (_p9.ctor === 'R') { - return A2(_Bogdanp$elm_ast$Ast_Expression$joinR, es, ops_); - } else { - return A2(_Bogdanp$elm_ast$Ast_Expression$joinL, es, ops_); - } - }, - _elm_community$parser_combinators$Combine$sequence( - A4(_Bogdanp$elm_ast$Ast_Expression$splitLevel, ops, l, e, eops))); - }, - A3(_Bogdanp$elm_ast$Ast_Expression$findAssoc, ops, l, eops)); - } - }); -var _Bogdanp$elm_ast$Ast_Expression$splitLevel = F4( - function (ops, l, e, eops) { - var _p10 = A2( - _elm_community$list_extra$List_Extra$break, - A2(_Bogdanp$elm_ast$Ast_Expression$hasLevel, ops, l), - eops); - if (_p10._1.ctor === '::') { - return { - ctor: '::', - _0: A4(_Bogdanp$elm_ast$Ast_Expression$split, ops, l + 1, e, _p10._0), - _1: A4(_Bogdanp$elm_ast$Ast_Expression$splitLevel, ops, l, _p10._1._0._1, _p10._1._1) - }; - } else { - return { - ctor: '::', - _0: A4(_Bogdanp$elm_ast$Ast_Expression$split, ops, l + 1, e, _p10._0), - _1: {ctor: '[]'} - }; - } - }); -var _Bogdanp$elm_ast$Ast_Expression$Float = function (a) { - return {ctor: 'Float', _0: a}; -}; -var _Bogdanp$elm_ast$Ast_Expression$float = A2(_elm_community$parser_combinators$Combine_ops['<$>'], _Bogdanp$elm_ast$Ast_Expression$Float, _elm_community$parser_combinators$Combine_Num$float); -var _Bogdanp$elm_ast$Ast_Expression$Integer = function (a) { - return {ctor: 'Integer', _0: a}; -}; -var _Bogdanp$elm_ast$Ast_Expression$integer = A2(_elm_community$parser_combinators$Combine_ops['<$>'], _Bogdanp$elm_ast$Ast_Expression$Integer, _elm_community$parser_combinators$Combine_Num$int); -var _Bogdanp$elm_ast$Ast_Expression$String = function (a) { - return {ctor: 'String', _0: a}; -}; -var _Bogdanp$elm_ast$Ast_Expression$string = function () { - var multiString = A2( - _elm_community$parser_combinators$Combine_ops['<$>'], - function (_p11) { - return _Bogdanp$elm_ast$Ast_Expression$String( - _elm_lang$core$String$concat(_p11)); - }, - A2( - _elm_community$parser_combinators$Combine_ops['<*'], - A2( - _elm_community$parser_combinators$Combine_ops['*>'], - _elm_community$parser_combinators$Combine$string('\"\"\"'), - _elm_community$parser_combinators$Combine$many( - _elm_community$parser_combinators$Combine$regex('[^\"]*'))), - _elm_community$parser_combinators$Combine$string('\"\"\"'))); - var singleString = A2( - _elm_community$parser_combinators$Combine_ops['<$>'], - _Bogdanp$elm_ast$Ast_Expression$String, - A2( - _elm_community$parser_combinators$Combine_ops['<*'], - A2( - _elm_community$parser_combinators$Combine_ops['*>'], - _elm_community$parser_combinators$Combine$string('\"'), - _elm_community$parser_combinators$Combine$regex('(\\\\\\\\|\\\\\"|[^\"\n])*')), - _elm_community$parser_combinators$Combine$string('\"'))); - return A2(_elm_community$parser_combinators$Combine_ops['<|>'], multiString, singleString); -}(); -var _Bogdanp$elm_ast$Ast_Expression$Character = function (a) { - return {ctor: 'Character', _0: a}; -}; -var _Bogdanp$elm_ast$Ast_Expression$character = A2( - _elm_community$parser_combinators$Combine_ops['<$>'], - _Bogdanp$elm_ast$Ast_Expression$Character, - A2( - _Bogdanp$elm_ast$Ast_Helpers$between_, - _elm_community$parser_combinators$Combine$string('\''), - A2( - _elm_community$parser_combinators$Combine_ops['<|>'], - A2( - _elm_community$parser_combinators$Combine_ops['>>='], - A2( - _elm_community$parser_combinators$Combine_ops['*>'], - _elm_community$parser_combinators$Combine$string('\\'), - _elm_community$parser_combinators$Combine$regex('(n|t|r|\\\\|x..)')), - function (a) { - var _p12 = a; - switch (_p12) { - case 'n': - return _elm_community$parser_combinators$Combine$succeed( - _elm_lang$core$Native_Utils.chr('\n')); - case 't': - return _elm_community$parser_combinators$Combine$succeed( - _elm_lang$core$Native_Utils.chr('\t')); - case 'r': - return _elm_community$parser_combinators$Combine$succeed( - _elm_lang$core$Native_Utils.chr('\r')); - case '\\': - return _elm_community$parser_combinators$Combine$succeed( - _elm_lang$core$Native_Utils.chr('\\')); - case '0': - return _elm_community$parser_combinators$Combine$succeed( - _elm_lang$core$Native_Utils.chr('')); - case 'x00': - return _elm_community$parser_combinators$Combine$succeed( - _elm_lang$core$Native_Utils.chr('')); - default: - return _elm_community$parser_combinators$Combine$fail( - A2(_elm_lang$core$Basics_ops['++'], 'No such character as \\', _p12)); - } - }), - _elm_community$parser_combinators$Combine_Char$anyChar))); -var _Bogdanp$elm_ast$Ast_Expression$term = function (ops) { - return _elm_community$parser_combinators$Combine$lazy( - function (_p13) { - var _p14 = _p13; - return _elm_community$parser_combinators$Combine$choice( - { - ctor: '::', - _0: _Bogdanp$elm_ast$Ast_Expression$character, - _1: { - ctor: '::', - _0: _Bogdanp$elm_ast$Ast_Expression$string, - _1: { - ctor: '::', - _0: _Bogdanp$elm_ast$Ast_Expression$float, - _1: { - ctor: '::', - _0: _Bogdanp$elm_ast$Ast_Expression$integer, - _1: { - ctor: '::', - _0: _Bogdanp$elm_ast$Ast_Expression$access, - _1: { - ctor: '::', - _0: _Bogdanp$elm_ast$Ast_Expression$accessFunction, - _1: { - ctor: '::', - _0: _Bogdanp$elm_ast$Ast_Expression$variable, - _1: { - ctor: '::', - _0: _Bogdanp$elm_ast$Ast_Expression$list(ops), - _1: { - ctor: '::', - _0: _Bogdanp$elm_ast$Ast_Expression$tuple(ops), - _1: { - ctor: '::', - _0: _Bogdanp$elm_ast$Ast_Expression$recordUpdate(ops), - _1: { - ctor: '::', - _0: _Bogdanp$elm_ast$Ast_Expression$record(ops), - _1: { - ctor: '::', - _0: _Bogdanp$elm_ast$Ast_Expression$simplifiedRecord, - _1: { - ctor: '::', - _0: _elm_community$parser_combinators$Combine$parens( - A2( - _Bogdanp$elm_ast$Ast_Helpers$between_, - _elm_community$parser_combinators$Combine$whitespace, - _Bogdanp$elm_ast$Ast_Expression$expression(ops))), - _1: {ctor: '[]'} - } - } - } - } - } - } - } - } - } - } - } - } - }); - }); -}; -var _Bogdanp$elm_ast$Ast_Expression$expression = function (ops) { - return _elm_community$parser_combinators$Combine$lazy( - function (_p15) { - var _p16 = _p15; - return _elm_community$parser_combinators$Combine$choice( - { - ctor: '::', - _0: _Bogdanp$elm_ast$Ast_Expression$letExpression(ops), - _1: { - ctor: '::', - _0: _Bogdanp$elm_ast$Ast_Expression$caseExpression(ops), - _1: { - ctor: '::', - _0: _Bogdanp$elm_ast$Ast_Expression$ifExpression(ops), - _1: { - ctor: '::', - _0: _Bogdanp$elm_ast$Ast_Expression$lambda(ops), - _1: { - ctor: '::', - _0: _Bogdanp$elm_ast$Ast_Expression$binary(ops), - _1: {ctor: '[]'} - } - } - } - } - }); - }); -}; -var _Bogdanp$elm_ast$Ast_Expression$binary = function (ops) { - return _elm_community$parser_combinators$Combine$lazy( - function (_p17) { - var _p18 = _p17; - var next = A2( - _elm_community$parser_combinators$Combine$andThen, - function (op) { - return A2( - _elm_community$parser_combinators$Combine$andThen, - function (e) { - var _p19 = e; - if (_p19.ctor === 'Cont') { - return A2( - _elm_community$parser_combinators$Combine_ops['<$>'], - F2( - function (x, y) { - return {ctor: '::', _0: x, _1: y}; - })( - {ctor: '_Tuple2', _0: op, _1: _p19._0}), - collect); - } else { - return _elm_community$parser_combinators$Combine$succeed( - { - ctor: '::', - _0: {ctor: '_Tuple2', _0: op, _1: _p19._0}, - _1: {ctor: '[]'} - }); - } - }, - _elm_community$parser_combinators$Combine$choice( - { - ctor: '::', - _0: A2( - _elm_community$parser_combinators$Combine_ops['<$>'], - _Bogdanp$elm_ast$Ast_Expression$Cont, - _Bogdanp$elm_ast$Ast_Expression$application(ops)), - _1: { - ctor: '::', - _0: A2( - _elm_community$parser_combinators$Combine_ops['<$>'], - _Bogdanp$elm_ast$Ast_Expression$Stop, - _Bogdanp$elm_ast$Ast_Expression$expression(ops)), - _1: {ctor: '[]'} - } - })); - }, - A2( - _Bogdanp$elm_ast$Ast_Helpers$between_, - _elm_community$parser_combinators$Combine$whitespace, - _elm_community$parser_combinators$Combine$choice( - { - ctor: '::', - _0: _Bogdanp$elm_ast$Ast_Helpers$operator, - _1: { - ctor: '::', - _0: _Bogdanp$elm_ast$Ast_Helpers$symbol_('as'), - _1: {ctor: '[]'} - } - }))); - var collect = A2( - _elm_community$parser_combinators$Combine_ops['<|>'], - next, - _elm_community$parser_combinators$Combine$succeed( - {ctor: '[]'})); - return A2( - _elm_community$parser_combinators$Combine$andThen, - function (e) { - return A2( - _elm_community$parser_combinators$Combine$andThen, - function (eops) { - return A4(_Bogdanp$elm_ast$Ast_Expression$split, ops, 0, e, eops); - }, - collect); - }, - _Bogdanp$elm_ast$Ast_Expression$application(ops)); - }); -}; -var _Bogdanp$elm_ast$Ast_Expression$application = function (ops) { - return _elm_community$parser_combinators$Combine$lazy( - function (_p20) { - var _p21 = _p20; - return A2( - _elm_community$parser_combinators$Combine$chainl, - A2( - _elm_community$parser_combinators$Combine_ops['<$'], - _Bogdanp$elm_ast$Ast_Expression$Application, - _Bogdanp$elm_ast$Ast_Expression$spacesOrIndentedNewline(ops)), - _Bogdanp$elm_ast$Ast_Expression$term(ops)); - }); -}; -var _Bogdanp$elm_ast$Ast_Expression$spacesOrIndentedNewline = function (ops) { - var startsBinding = A2( - _elm_community$parser_combinators$Combine$or, - _Bogdanp$elm_ast$Ast_Expression$letBinding(ops), - _Bogdanp$elm_ast$Ast_Expression$caseBinding(ops)); - var failAtBinding = A2( - _elm_community$parser_combinators$Combine$andThen, - function (x) { - var _p22 = x; - if (_p22.ctor === 'Just') { - return _elm_community$parser_combinators$Combine$fail('next line starts a new case or let binding'); - } else { - return _elm_community$parser_combinators$Combine$succeed(''); - } - }, - _elm_community$parser_combinators$Combine$maybe(startsBinding)); - return A2( - _elm_community$parser_combinators$Combine$or, - A2( - _elm_community$parser_combinators$Combine_ops['*>'], - A2( - _elm_community$parser_combinators$Combine_ops['*>'], - A2(_elm_community$parser_combinators$Combine_ops['*>'], _Bogdanp$elm_ast$Ast_Helpers$spaces, _elm_community$parser_combinators$Combine_Char$newline), - _Bogdanp$elm_ast$Ast_Helpers$spaces_), - _elm_community$parser_combinators$Combine$lookAhead(failAtBinding)), - _Bogdanp$elm_ast$Ast_Helpers$spaces_); -}; -var _Bogdanp$elm_ast$Ast_Expression$caseBinding = function (ops) { - return _elm_community$parser_combinators$Combine$lazy( - function (_p23) { - var _p24 = _p23; - return A2( - _elm_community$parser_combinators$Combine_ops['<*>'], - A2( - _elm_community$parser_combinators$Combine_ops['<$>'], - F2( - function (v0, v1) { - return {ctor: '_Tuple2', _0: v0, _1: v1}; - }), - A2( - _elm_community$parser_combinators$Combine_ops['*>'], - _elm_community$parser_combinators$Combine$whitespace, - _Bogdanp$elm_ast$Ast_Expression$expression(ops))), - A2( - _elm_community$parser_combinators$Combine_ops['*>'], - _Bogdanp$elm_ast$Ast_Helpers$symbol('->'), - _Bogdanp$elm_ast$Ast_Expression$expression(ops))); - }); -}; -var _Bogdanp$elm_ast$Ast_Expression$letBinding = function (ops) { - return _elm_community$parser_combinators$Combine$lazy( - function (_p25) { - var _p26 = _p25; - return A2( - _elm_community$parser_combinators$Combine_ops['<*>'], - A2( - _elm_community$parser_combinators$Combine_ops['<$>'], - F2( - function (v0, v1) { - return {ctor: '_Tuple2', _0: v0, _1: v1}; - }), - A2( - _Bogdanp$elm_ast$Ast_Helpers$between_, - _elm_community$parser_combinators$Combine$whitespace, - _Bogdanp$elm_ast$Ast_Expression$expression(ops))), - A2( - _elm_community$parser_combinators$Combine_ops['*>'], - _Bogdanp$elm_ast$Ast_Helpers$symbol('='), - _Bogdanp$elm_ast$Ast_Expression$expression(ops))); - }); -}; -var _Bogdanp$elm_ast$Ast_Expression$caseExpression = function (ops) { - return _elm_community$parser_combinators$Combine$lazy( - function (_p27) { - var _p28 = _p27; - return A2( - _elm_community$parser_combinators$Combine_ops['<*>'], - A2( - _elm_community$parser_combinators$Combine_ops['<$>'], - _Bogdanp$elm_ast$Ast_Expression$Case, - A2( - _elm_community$parser_combinators$Combine_ops['*>'], - _Bogdanp$elm_ast$Ast_Helpers$symbol('case'), - _Bogdanp$elm_ast$Ast_Expression$expression(ops))), - A2( - _elm_community$parser_combinators$Combine_ops['*>'], - _Bogdanp$elm_ast$Ast_Helpers$symbol('of'), - _elm_community$parser_combinators$Combine$many1( - _Bogdanp$elm_ast$Ast_Expression$caseBinding(ops)))); - }); -}; -var _Bogdanp$elm_ast$Ast_Expression$ifExpression = function (ops) { - return _elm_community$parser_combinators$Combine$lazy( - function (_p29) { - var _p30 = _p29; - return A2( - _elm_community$parser_combinators$Combine_ops['<*>'], - A2( - _elm_community$parser_combinators$Combine_ops['<*>'], - A2( - _elm_community$parser_combinators$Combine_ops['<$>'], - _Bogdanp$elm_ast$Ast_Expression$If, - A2( - _elm_community$parser_combinators$Combine_ops['*>'], - _Bogdanp$elm_ast$Ast_Helpers$symbol('if'), - _Bogdanp$elm_ast$Ast_Expression$expression(ops))), - A2( - _elm_community$parser_combinators$Combine_ops['*>'], - _Bogdanp$elm_ast$Ast_Helpers$symbol('then'), - _Bogdanp$elm_ast$Ast_Expression$expression(ops))), - A2( - _elm_community$parser_combinators$Combine_ops['*>'], - _Bogdanp$elm_ast$Ast_Helpers$symbol('else'), - _Bogdanp$elm_ast$Ast_Expression$expression(ops))); - }); -}; -var _Bogdanp$elm_ast$Ast_Expression$lambda = function (ops) { - return _elm_community$parser_combinators$Combine$lazy( - function (_p31) { - var _p32 = _p31; - return A2( - _elm_community$parser_combinators$Combine_ops['<*>'], - A2( - _elm_community$parser_combinators$Combine_ops['<$>'], - _Bogdanp$elm_ast$Ast_Expression$Lambda, - A2( - _elm_community$parser_combinators$Combine_ops['*>'], - _Bogdanp$elm_ast$Ast_Helpers$symbol('\\'), - _elm_community$parser_combinators$Combine$many( - A2( - _Bogdanp$elm_ast$Ast_Helpers$between_, - _Bogdanp$elm_ast$Ast_Helpers$spaces, - _Bogdanp$elm_ast$Ast_Expression$term(ops))))), - A2( - _elm_community$parser_combinators$Combine_ops['*>'], - _Bogdanp$elm_ast$Ast_Helpers$symbol('->'), - _Bogdanp$elm_ast$Ast_Expression$expression(ops))); - }); -}; -var _Bogdanp$elm_ast$Ast_Expression$letExpression = function (ops) { - return _elm_community$parser_combinators$Combine$lazy( - function (_p33) { - var _p34 = _p33; - return A2( - _elm_community$parser_combinators$Combine_ops['<*>'], - A2( - _elm_community$parser_combinators$Combine_ops['<$>'], - _Bogdanp$elm_ast$Ast_Expression$Let, - A2( - _elm_community$parser_combinators$Combine_ops['*>'], - _Bogdanp$elm_ast$Ast_Helpers$symbol_('let'), - _elm_community$parser_combinators$Combine$many1( - _Bogdanp$elm_ast$Ast_Expression$letBinding(ops)))), - A2( - _elm_community$parser_combinators$Combine_ops['*>'], - _Bogdanp$elm_ast$Ast_Helpers$symbol('in'), - _Bogdanp$elm_ast$Ast_Expression$expression(ops))); - }); -}; -var _Bogdanp$elm_ast$Ast_Expression$list = function (ops) { - return _elm_community$parser_combinators$Combine$lazy( - function (_p35) { - var _p36 = _p35; - return A2( - _elm_community$parser_combinators$Combine_ops['<$>'], - _Bogdanp$elm_ast$Ast_Expression$List, - _elm_community$parser_combinators$Combine$brackets( - _Bogdanp$elm_ast$Ast_Helpers$commaSeparated_( - _Bogdanp$elm_ast$Ast_Expression$expression(ops)))); - }); -}; -var _Bogdanp$elm_ast$Ast_Expression$record = function (ops) { - return _elm_community$parser_combinators$Combine$lazy( - function (_p37) { - var _p38 = _p37; - return A2( - _elm_community$parser_combinators$Combine_ops['<$>'], - _Bogdanp$elm_ast$Ast_Expression$Record, - _elm_community$parser_combinators$Combine$braces( - _Bogdanp$elm_ast$Ast_Helpers$commaSeparated( - A2( - _elm_community$parser_combinators$Combine_ops['<*>'], - A2( - _elm_community$parser_combinators$Combine_ops['<$>'], - F2( - function (v0, v1) { - return {ctor: '_Tuple2', _0: v0, _1: v1}; - }), - _Bogdanp$elm_ast$Ast_Helpers$loName), - A2( - _elm_community$parser_combinators$Combine_ops['*>'], - _Bogdanp$elm_ast$Ast_Helpers$symbol('='), - _Bogdanp$elm_ast$Ast_Expression$expression(ops)))))); - }); -}; -var _Bogdanp$elm_ast$Ast_Expression$recordUpdate = function (ops) { - return _elm_community$parser_combinators$Combine$lazy( - function (_p39) { - var _p40 = _p39; - return A2( - _elm_community$parser_combinators$Combine_ops['<*>'], - A2( - _elm_community$parser_combinators$Combine_ops['<$>'], - _Bogdanp$elm_ast$Ast_Expression$RecordUpdate, - A2( - _elm_community$parser_combinators$Combine_ops['*>'], - _Bogdanp$elm_ast$Ast_Helpers$symbol('{'), - _Bogdanp$elm_ast$Ast_Helpers$loName)), - A2( - _elm_community$parser_combinators$Combine_ops['<*'], - A2( - _elm_community$parser_combinators$Combine_ops['*>'], - _Bogdanp$elm_ast$Ast_Helpers$symbol('|'), - _Bogdanp$elm_ast$Ast_Helpers$commaSeparated( - A2( - _elm_community$parser_combinators$Combine_ops['<*>'], - A2( - _elm_community$parser_combinators$Combine_ops['<$>'], - F2( - function (v0, v1) { - return {ctor: '_Tuple2', _0: v0, _1: v1}; - }), - _Bogdanp$elm_ast$Ast_Helpers$loName), - A2( - _elm_community$parser_combinators$Combine_ops['*>'], - _Bogdanp$elm_ast$Ast_Helpers$symbol('='), - _Bogdanp$elm_ast$Ast_Expression$expression(ops))))), - _Bogdanp$elm_ast$Ast_Helpers$symbol('}'))); - }); -}; -var _Bogdanp$elm_ast$Ast_Expression$tuple = function (ops) { - return _elm_community$parser_combinators$Combine$lazy( - function (_p41) { - var _p42 = _p41; - return A2( - _elm_community$parser_combinators$Combine_ops['<$>'], - _Bogdanp$elm_ast$Ast_Expression$Tuple, - A2( - _elm_community$parser_combinators$Combine_ops['>>='], - _elm_community$parser_combinators$Combine$parens( - _Bogdanp$elm_ast$Ast_Helpers$commaSeparated_( - _Bogdanp$elm_ast$Ast_Expression$expression(ops))), - function (a) { - var _p43 = a; - if ((_p43.ctor === '::') && (_p43._1.ctor === '[]')) { - return _elm_community$parser_combinators$Combine$fail('No single tuples'); - } else { - return _elm_community$parser_combinators$Combine$succeed(_p43); - } - })); - }); -}; - -var _Bogdanp$elm_ast$Ast_Statement$TypeExport = F2( - function (a, b) { - return {ctor: 'TypeExport', _0: a, _1: b}; - }); -var _Bogdanp$elm_ast$Ast_Statement$FunctionExport = function (a) { - return {ctor: 'FunctionExport', _0: a}; -}; -var _Bogdanp$elm_ast$Ast_Statement$functionExport = A2( - _elm_community$parser_combinators$Combine_ops['<$>'], - _Bogdanp$elm_ast$Ast_Statement$FunctionExport, - _elm_community$parser_combinators$Combine$choice( - { - ctor: '::', - _0: _Bogdanp$elm_ast$Ast_Helpers$functionName, - _1: { - ctor: '::', - _0: _elm_community$parser_combinators$Combine$parens(_Bogdanp$elm_ast$Ast_Helpers$operator), - _1: {ctor: '[]'} - } - })); -var _Bogdanp$elm_ast$Ast_Statement$SubsetExport = function (a) { - return {ctor: 'SubsetExport', _0: a}; -}; -var _Bogdanp$elm_ast$Ast_Statement$constructorSubsetExports = A2( - _elm_community$parser_combinators$Combine_ops['<$>'], - _Bogdanp$elm_ast$Ast_Statement$SubsetExport, - _Bogdanp$elm_ast$Ast_Helpers$commaSeparated( - A2(_elm_community$parser_combinators$Combine_ops['<$>'], _Bogdanp$elm_ast$Ast_Statement$FunctionExport, _Bogdanp$elm_ast$Ast_Helpers$upName))); -var _Bogdanp$elm_ast$Ast_Statement$AllExport = {ctor: 'AllExport'}; -var _Bogdanp$elm_ast$Ast_Statement$allExport = A2( - _elm_community$parser_combinators$Combine_ops['<$'], - _Bogdanp$elm_ast$Ast_Statement$AllExport, - _Bogdanp$elm_ast$Ast_Helpers$symbol('..')); -var _Bogdanp$elm_ast$Ast_Statement$constructorExports = _elm_community$parser_combinators$Combine$maybe( - _elm_community$parser_combinators$Combine$parens( - _elm_community$parser_combinators$Combine$choice( - { - ctor: '::', - _0: _Bogdanp$elm_ast$Ast_Statement$allExport, - _1: { - ctor: '::', - _0: _Bogdanp$elm_ast$Ast_Statement$constructorSubsetExports, - _1: {ctor: '[]'} - } - }))); -var _Bogdanp$elm_ast$Ast_Statement$typeExport = A2( - _elm_community$parser_combinators$Combine_ops['<*>'], - A2( - _elm_community$parser_combinators$Combine_ops['<$>'], - _Bogdanp$elm_ast$Ast_Statement$TypeExport, - A2(_elm_community$parser_combinators$Combine_ops['<*'], _Bogdanp$elm_ast$Ast_Helpers$upName, _Bogdanp$elm_ast$Ast_Helpers$spaces)), - _Bogdanp$elm_ast$Ast_Statement$constructorExports); -var _Bogdanp$elm_ast$Ast_Statement$subsetExport = A2( - _elm_community$parser_combinators$Combine_ops['<$>'], - _Bogdanp$elm_ast$Ast_Statement$SubsetExport, - _Bogdanp$elm_ast$Ast_Helpers$commaSeparated( - A2(_elm_community$parser_combinators$Combine$or, _Bogdanp$elm_ast$Ast_Statement$typeExport, _Bogdanp$elm_ast$Ast_Statement$functionExport))); -var _Bogdanp$elm_ast$Ast_Statement$exports = _elm_community$parser_combinators$Combine$parens( - _elm_community$parser_combinators$Combine$choice( - { - ctor: '::', - _0: _Bogdanp$elm_ast$Ast_Statement$allExport, - _1: { - ctor: '::', - _0: _Bogdanp$elm_ast$Ast_Statement$subsetExport, - _1: {ctor: '[]'} - } - })); -var _Bogdanp$elm_ast$Ast_Statement$TypeApplication = F2( - function (a, b) { - return {ctor: 'TypeApplication', _0: a, _1: b}; - }); -var _Bogdanp$elm_ast$Ast_Statement$typeApplication = A2( - _elm_community$parser_combinators$Combine_ops['<$'], - _Bogdanp$elm_ast$Ast_Statement$TypeApplication, - _Bogdanp$elm_ast$Ast_Helpers$symbol('->')); -var _Bogdanp$elm_ast$Ast_Statement$TypeTuple = function (a) { - return {ctor: 'TypeTuple', _0: a}; -}; -var _Bogdanp$elm_ast$Ast_Statement$TypeRecord = function (a) { - return {ctor: 'TypeRecord', _0: a}; -}; -var _Bogdanp$elm_ast$Ast_Statement$TypeRecordConstructor = F2( - function (a, b) { - return {ctor: 'TypeRecordConstructor', _0: a, _1: b}; - }); -var _Bogdanp$elm_ast$Ast_Statement$TypeVariable = function (a) { - return {ctor: 'TypeVariable', _0: a}; -}; -var _Bogdanp$elm_ast$Ast_Statement$typeVariable = A2( - _elm_community$parser_combinators$Combine_ops['<$>'], - _Bogdanp$elm_ast$Ast_Statement$TypeVariable, - _elm_community$parser_combinators$Combine$regex('[a-z]+(\\w|_)*')); -var _Bogdanp$elm_ast$Ast_Statement$TypeConstructor = F2( - function (a, b) { - return {ctor: 'TypeConstructor', _0: a, _1: b}; - }); -var _Bogdanp$elm_ast$Ast_Statement$typeConstant = A2( - _elm_community$parser_combinators$Combine_ops['<*>'], - A2( - _elm_community$parser_combinators$Combine_ops['<$>'], - _Bogdanp$elm_ast$Ast_Statement$TypeConstructor, - A2( - _elm_community$parser_combinators$Combine$sepBy1, - _elm_community$parser_combinators$Combine$string('.'), - _Bogdanp$elm_ast$Ast_Helpers$upName)), - _elm_community$parser_combinators$Combine$succeed( - {ctor: '[]'})); -var _Bogdanp$elm_ast$Ast_Statement$typeConstructor = _elm_community$parser_combinators$Combine$lazy( - function (_p0) { - var _p1 = _p0; - return A2( - _elm_community$parser_combinators$Combine_ops['<*>'], - A2( - _elm_community$parser_combinators$Combine_ops['<$>'], - _Bogdanp$elm_ast$Ast_Statement$TypeConstructor, - A2( - _elm_community$parser_combinators$Combine$sepBy1, - _elm_community$parser_combinators$Combine$string('.'), - _Bogdanp$elm_ast$Ast_Helpers$upName)), - _elm_community$parser_combinators$Combine$many(_Bogdanp$elm_ast$Ast_Statement$typeParameter)); - }); -var _Bogdanp$elm_ast$Ast_Statement$typeParameter = _elm_community$parser_combinators$Combine$lazy( - function (_p2) { - var _p3 = _p2; - return A2( - _Bogdanp$elm_ast$Ast_Helpers$between_, - A2( - _elm_community$parser_combinators$Combine$or, - A2( - _elm_community$parser_combinators$Combine_ops['*>'], - A2(_elm_community$parser_combinators$Combine_ops['*>'], _Bogdanp$elm_ast$Ast_Helpers$spaces, _elm_community$parser_combinators$Combine_Char$newline), - _Bogdanp$elm_ast$Ast_Helpers$spaces_), - _Bogdanp$elm_ast$Ast_Helpers$spaces), - _elm_community$parser_combinators$Combine$choice( - { - ctor: '::', - _0: _Bogdanp$elm_ast$Ast_Statement$typeVariable, - _1: { - ctor: '::', - _0: _Bogdanp$elm_ast$Ast_Statement$typeConstant, - _1: { - ctor: '::', - _0: _Bogdanp$elm_ast$Ast_Statement$typeRecordConstructor, - _1: { - ctor: '::', - _0: _Bogdanp$elm_ast$Ast_Statement$typeRecord, - _1: { - ctor: '::', - _0: _Bogdanp$elm_ast$Ast_Statement$typeTuple, - _1: { - ctor: '::', - _0: _elm_community$parser_combinators$Combine$parens(_Bogdanp$elm_ast$Ast_Statement$typeAnnotation), - _1: {ctor: '[]'} - } - } - } - } - } - })); - }); -var _Bogdanp$elm_ast$Ast_Statement$typeAnnotation = _elm_community$parser_combinators$Combine$lazy( - function (_p4) { - var _p5 = _p4; - return A2(_elm_community$parser_combinators$Combine$chainr, _Bogdanp$elm_ast$Ast_Statement$typeApplication, _Bogdanp$elm_ast$Ast_Statement$type_); - }); -var _Bogdanp$elm_ast$Ast_Statement$type_ = _elm_community$parser_combinators$Combine$lazy( - function (_p6) { - var _p7 = _p6; - return A2( - _Bogdanp$elm_ast$Ast_Helpers$between_, - _Bogdanp$elm_ast$Ast_Helpers$spaces, - _elm_community$parser_combinators$Combine$choice( - { - ctor: '::', - _0: _Bogdanp$elm_ast$Ast_Statement$typeConstructor, - _1: { - ctor: '::', - _0: _Bogdanp$elm_ast$Ast_Statement$typeVariable, - _1: { - ctor: '::', - _0: _Bogdanp$elm_ast$Ast_Statement$typeRecordConstructor, - _1: { - ctor: '::', - _0: _Bogdanp$elm_ast$Ast_Statement$typeRecord, - _1: { - ctor: '::', - _0: _Bogdanp$elm_ast$Ast_Statement$typeTuple, - _1: { - ctor: '::', - _0: _elm_community$parser_combinators$Combine$parens(_Bogdanp$elm_ast$Ast_Statement$typeAnnotation), - _1: {ctor: '[]'} - } - } - } - } - } - })); - }); -var _Bogdanp$elm_ast$Ast_Statement$typeRecord = _elm_community$parser_combinators$Combine$lazy( - function (_p8) { - var _p9 = _p8; - return _elm_community$parser_combinators$Combine$braces( - A2(_elm_community$parser_combinators$Combine_ops['<$>'], _Bogdanp$elm_ast$Ast_Statement$TypeRecord, _Bogdanp$elm_ast$Ast_Statement$typeRecordPairs)); - }); -var _Bogdanp$elm_ast$Ast_Statement$typeRecordPairs = _elm_community$parser_combinators$Combine$lazy( - function (_p10) { - var _p11 = _p10; - return _Bogdanp$elm_ast$Ast_Helpers$commaSeparated_(_Bogdanp$elm_ast$Ast_Statement$typeRecordPair); - }); -var _Bogdanp$elm_ast$Ast_Statement$typeRecordPair = _elm_community$parser_combinators$Combine$lazy( - function (_p12) { - var _p13 = _p12; - return A2( - _elm_community$parser_combinators$Combine_ops['<*>'], - A2( - _elm_community$parser_combinators$Combine_ops['<$>'], - F2( - function (v0, v1) { - return {ctor: '_Tuple2', _0: v0, _1: v1}; - }), - A2( - _elm_community$parser_combinators$Combine_ops['<*'], - _Bogdanp$elm_ast$Ast_Helpers$loName, - _Bogdanp$elm_ast$Ast_Helpers$symbol(':'))), - _Bogdanp$elm_ast$Ast_Statement$typeAnnotation); - }); -var _Bogdanp$elm_ast$Ast_Statement$typeRecordConstructor = _elm_community$parser_combinators$Combine$lazy( - function (_p14) { - var _p15 = _p14; - return _elm_community$parser_combinators$Combine$braces( - A2( - _elm_community$parser_combinators$Combine_ops['<*>'], - A2( - _elm_community$parser_combinators$Combine_ops['<$>'], - _Bogdanp$elm_ast$Ast_Statement$TypeRecordConstructor, - A2(_Bogdanp$elm_ast$Ast_Helpers$between_, _Bogdanp$elm_ast$Ast_Helpers$spaces, _Bogdanp$elm_ast$Ast_Statement$typeVariable)), - A2( - _elm_community$parser_combinators$Combine_ops['*>'], - _Bogdanp$elm_ast$Ast_Helpers$symbol('|'), - _Bogdanp$elm_ast$Ast_Statement$typeRecordPairs))); - }); -var _Bogdanp$elm_ast$Ast_Statement$typeTuple = _elm_community$parser_combinators$Combine$lazy( - function (_p16) { - var _p17 = _p16; - return A2( - _elm_community$parser_combinators$Combine_ops['<$>'], - _Bogdanp$elm_ast$Ast_Statement$TypeTuple, - _elm_community$parser_combinators$Combine$parens( - _Bogdanp$elm_ast$Ast_Helpers$commaSeparated_(_Bogdanp$elm_ast$Ast_Statement$type_))); - }); -var _Bogdanp$elm_ast$Ast_Statement$Comment = function (a) { - return {ctor: 'Comment', _0: a}; -}; -var _Bogdanp$elm_ast$Ast_Statement$singleLineComment = A2( - _elm_community$parser_combinators$Combine_ops['<$>'], - _Bogdanp$elm_ast$Ast_Statement$Comment, - A2( - _elm_community$parser_combinators$Combine_ops['<*'], - A2( - _elm_community$parser_combinators$Combine_ops['*>'], - _elm_community$parser_combinators$Combine$string('--'), - _elm_community$parser_combinators$Combine$regex('.*')), - _elm_community$parser_combinators$Combine$whitespace)); -var _Bogdanp$elm_ast$Ast_Statement$multiLineComment = A2( - _elm_community$parser_combinators$Combine_ops['<$>'], - function (_p18) { - return _Bogdanp$elm_ast$Ast_Statement$Comment( - _elm_lang$core$String$fromList(_p18)); - }, - A2( - _elm_community$parser_combinators$Combine_ops['*>'], - _elm_community$parser_combinators$Combine$string('{-'), - A2( - _elm_community$parser_combinators$Combine$manyTill, - _elm_community$parser_combinators$Combine_Char$anyChar, - _elm_community$parser_combinators$Combine$string('-}')))); -var _Bogdanp$elm_ast$Ast_Statement$comment = A2(_elm_community$parser_combinators$Combine_ops['<|>'], _Bogdanp$elm_ast$Ast_Statement$singleLineComment, _Bogdanp$elm_ast$Ast_Statement$multiLineComment); -var _Bogdanp$elm_ast$Ast_Statement$InfixDeclaration = F3( - function (a, b, c) { - return {ctor: 'InfixDeclaration', _0: a, _1: b, _2: c}; - }); -var _Bogdanp$elm_ast$Ast_Statement$infixDeclaration = A2( - _elm_community$parser_combinators$Combine_ops['<*>'], - A2( - _elm_community$parser_combinators$Combine_ops['<*>'], - A2( - _elm_community$parser_combinators$Combine_ops['<$>'], - _Bogdanp$elm_ast$Ast_Statement$InfixDeclaration, - _elm_community$parser_combinators$Combine$choice( - { - ctor: '::', - _0: A2( - _elm_community$parser_combinators$Combine_ops['<$'], - _Bogdanp$elm_ast$Ast_BinOp$L, - _Bogdanp$elm_ast$Ast_Helpers$initialSymbol('infixl')), - _1: { - ctor: '::', - _0: A2( - _elm_community$parser_combinators$Combine_ops['<$'], - _Bogdanp$elm_ast$Ast_BinOp$R, - _Bogdanp$elm_ast$Ast_Helpers$initialSymbol('infixr')), - _1: { - ctor: '::', - _0: A2( - _elm_community$parser_combinators$Combine_ops['<$'], - _Bogdanp$elm_ast$Ast_BinOp$N, - _Bogdanp$elm_ast$Ast_Helpers$initialSymbol('infix')), - _1: {ctor: '[]'} - } - } - })), - A2(_elm_community$parser_combinators$Combine_ops['*>'], _Bogdanp$elm_ast$Ast_Helpers$spaces, _elm_community$parser_combinators$Combine_Num$int)), - A2( - _elm_community$parser_combinators$Combine_ops['*>'], - _Bogdanp$elm_ast$Ast_Helpers$spaces, - A2(_elm_community$parser_combinators$Combine_ops['<|>'], _Bogdanp$elm_ast$Ast_Helpers$loName, _Bogdanp$elm_ast$Ast_Helpers$operator))); -var _Bogdanp$elm_ast$Ast_Statement$infixStatements = function () { - var statements = A2( - _elm_community$parser_combinators$Combine_ops['<*'], - _elm_community$parser_combinators$Combine$many( - A2( - _elm_community$parser_combinators$Combine_ops['<*'], - _elm_community$parser_combinators$Combine$choice( - { - ctor: '::', - _0: A2(_elm_community$parser_combinators$Combine_ops['<$>'], _elm_lang$core$Maybe$Just, _Bogdanp$elm_ast$Ast_Statement$infixDeclaration), - _1: { - ctor: '::', - _0: A2( - _elm_community$parser_combinators$Combine_ops['<$'], - _elm_lang$core$Maybe$Nothing, - _elm_community$parser_combinators$Combine$regex('.*')), - _1: {ctor: '[]'} - } - }), - _elm_community$parser_combinators$Combine$whitespace)), - _elm_community$parser_combinators$Combine$end); - return A2( - _elm_community$parser_combinators$Combine$andThen, - function (xs) { - return _elm_community$parser_combinators$Combine$succeed( - A2(_elm_lang$core$List$filterMap, _elm_lang$core$Basics$identity, xs)); - }, - statements); -}(); -var _Bogdanp$elm_ast$Ast_Statement$opTable = function (ops) { - var collect = F2( - function (s, d) { - var _p19 = s; - if (_p19.ctor === 'InfixDeclaration') { - return A3( - _elm_lang$core$Dict$insert, - _p19._2, - {ctor: '_Tuple2', _0: _p19._0, _1: _p19._1}, - d); - } else { - return _elm_lang$core$Native_Utils.crashCase( - 'Ast.Statement', - { - start: {line: 414, column: 13}, - end: {line: 419, column: 45} - }, - _p19)('impossible'); - } - }); - return A2( - _elm_community$parser_combinators$Combine$andThen, - function (xs) { - return _elm_community$parser_combinators$Combine$succeed( - A3(_elm_lang$core$List$foldr, collect, ops, xs)); - }, - _Bogdanp$elm_ast$Ast_Statement$infixStatements); -}; -var _Bogdanp$elm_ast$Ast_Statement$FunctionDeclaration = F3( - function (a, b, c) { - return {ctor: 'FunctionDeclaration', _0: a, _1: b, _2: c}; - }); -var _Bogdanp$elm_ast$Ast_Statement$functionDeclaration = function (ops) { - return A2( - _elm_community$parser_combinators$Combine_ops['<*>'], - A2( - _elm_community$parser_combinators$Combine_ops['<*>'], - A2( - _elm_community$parser_combinators$Combine_ops['<$>'], - _Bogdanp$elm_ast$Ast_Statement$FunctionDeclaration, - _elm_community$parser_combinators$Combine$choice( - { - ctor: '::', - _0: _Bogdanp$elm_ast$Ast_Helpers$loName, - _1: { - ctor: '::', - _0: _elm_community$parser_combinators$Combine$parens(_Bogdanp$elm_ast$Ast_Helpers$operator), - _1: {ctor: '[]'} - } - })), - _elm_community$parser_combinators$Combine$many( - A2( - _Bogdanp$elm_ast$Ast_Helpers$between_, - _elm_community$parser_combinators$Combine$whitespace, - _Bogdanp$elm_ast$Ast_Expression$term(ops)))), - A2( - _elm_community$parser_combinators$Combine_ops['*>'], - A2( - _elm_community$parser_combinators$Combine_ops['*>'], - _Bogdanp$elm_ast$Ast_Helpers$symbol('='), - _elm_community$parser_combinators$Combine$whitespace), - _Bogdanp$elm_ast$Ast_Expression$expression(ops))); -}; -var _Bogdanp$elm_ast$Ast_Statement$FunctionTypeDeclaration = F2( - function (a, b) { - return {ctor: 'FunctionTypeDeclaration', _0: a, _1: b}; - }); -var _Bogdanp$elm_ast$Ast_Statement$functionTypeDeclaration = A2( - _elm_community$parser_combinators$Combine_ops['<*>'], - A2( - _elm_community$parser_combinators$Combine_ops['<$>'], - _Bogdanp$elm_ast$Ast_Statement$FunctionTypeDeclaration, - A2( - _elm_community$parser_combinators$Combine_ops['<*'], - _elm_community$parser_combinators$Combine$choice( - { - ctor: '::', - _0: _Bogdanp$elm_ast$Ast_Helpers$loName, - _1: { - ctor: '::', - _0: _elm_community$parser_combinators$Combine$parens(_Bogdanp$elm_ast$Ast_Helpers$operator), - _1: {ctor: '[]'} - } - }), - _Bogdanp$elm_ast$Ast_Helpers$symbol(':'))), - _Bogdanp$elm_ast$Ast_Statement$typeAnnotation); -var _Bogdanp$elm_ast$Ast_Statement$PortDeclaration = F3( - function (a, b, c) { - return {ctor: 'PortDeclaration', _0: a, _1: b, _2: c}; - }); -var _Bogdanp$elm_ast$Ast_Statement$portDeclaration = function (ops) { - return A2( - _elm_community$parser_combinators$Combine_ops['<*>'], - A2( - _elm_community$parser_combinators$Combine_ops['<*>'], - A2( - _elm_community$parser_combinators$Combine_ops['<$>'], - _Bogdanp$elm_ast$Ast_Statement$PortDeclaration, - A2( - _elm_community$parser_combinators$Combine_ops['*>'], - _Bogdanp$elm_ast$Ast_Helpers$initialSymbol('port'), - _Bogdanp$elm_ast$Ast_Helpers$loName)), - _elm_community$parser_combinators$Combine$many( - A2(_Bogdanp$elm_ast$Ast_Helpers$between_, _Bogdanp$elm_ast$Ast_Helpers$spaces, _Bogdanp$elm_ast$Ast_Helpers$loName))), - A2( - _elm_community$parser_combinators$Combine_ops['*>'], - _Bogdanp$elm_ast$Ast_Helpers$symbol('='), - _Bogdanp$elm_ast$Ast_Expression$expression(ops))); -}; -var _Bogdanp$elm_ast$Ast_Statement$PortTypeDeclaration = F2( - function (a, b) { - return {ctor: 'PortTypeDeclaration', _0: a, _1: b}; - }); -var _Bogdanp$elm_ast$Ast_Statement$portTypeDeclaration = A2( - _elm_community$parser_combinators$Combine_ops['<*>'], - A2( - _elm_community$parser_combinators$Combine_ops['<$>'], - _Bogdanp$elm_ast$Ast_Statement$PortTypeDeclaration, - A2( - _elm_community$parser_combinators$Combine_ops['*>'], - _Bogdanp$elm_ast$Ast_Helpers$initialSymbol('port'), - _Bogdanp$elm_ast$Ast_Helpers$loName)), - A2( - _elm_community$parser_combinators$Combine_ops['*>'], - _Bogdanp$elm_ast$Ast_Helpers$symbol(':'), - _Bogdanp$elm_ast$Ast_Statement$typeAnnotation)); -var _Bogdanp$elm_ast$Ast_Statement$TypeDeclaration = F2( - function (a, b) { - return {ctor: 'TypeDeclaration', _0: a, _1: b}; - }); -var _Bogdanp$elm_ast$Ast_Statement$typeDeclaration = A2( - _elm_community$parser_combinators$Combine_ops['<*>'], - A2( - _elm_community$parser_combinators$Combine_ops['<$>'], - _Bogdanp$elm_ast$Ast_Statement$TypeDeclaration, - A2( - _elm_community$parser_combinators$Combine_ops['*>'], - _Bogdanp$elm_ast$Ast_Helpers$initialSymbol('type'), - _Bogdanp$elm_ast$Ast_Statement$type_)), - A2( - _elm_community$parser_combinators$Combine_ops['*>'], - A2( - _elm_community$parser_combinators$Combine_ops['*>'], - _elm_community$parser_combinators$Combine$whitespace, - _Bogdanp$elm_ast$Ast_Helpers$symbol('=')), - A2( - _elm_community$parser_combinators$Combine$sepBy1, - _Bogdanp$elm_ast$Ast_Helpers$symbol('|'), - A2(_Bogdanp$elm_ast$Ast_Helpers$between_, _elm_community$parser_combinators$Combine$whitespace, _Bogdanp$elm_ast$Ast_Statement$typeConstructor)))); -var _Bogdanp$elm_ast$Ast_Statement$TypeAliasDeclaration = F2( - function (a, b) { - return {ctor: 'TypeAliasDeclaration', _0: a, _1: b}; - }); -var _Bogdanp$elm_ast$Ast_Statement$typeAliasDeclaration = A2( - _elm_community$parser_combinators$Combine_ops['<*>'], - A2( - _elm_community$parser_combinators$Combine_ops['<$>'], - _Bogdanp$elm_ast$Ast_Statement$TypeAliasDeclaration, - A2( - _elm_community$parser_combinators$Combine_ops['*>'], - A2( - _elm_community$parser_combinators$Combine_ops['*>'], - _Bogdanp$elm_ast$Ast_Helpers$initialSymbol('type'), - _Bogdanp$elm_ast$Ast_Helpers$symbol('alias')), - _Bogdanp$elm_ast$Ast_Statement$type_)), - A2( - _elm_community$parser_combinators$Combine_ops['*>'], - A2( - _elm_community$parser_combinators$Combine_ops['*>'], - _elm_community$parser_combinators$Combine$whitespace, - _Bogdanp$elm_ast$Ast_Helpers$symbol('=')), - _Bogdanp$elm_ast$Ast_Statement$typeAnnotation)); -var _Bogdanp$elm_ast$Ast_Statement$ImportStatement = F3( - function (a, b, c) { - return {ctor: 'ImportStatement', _0: a, _1: b, _2: c}; - }); -var _Bogdanp$elm_ast$Ast_Statement$importStatement = A2( - _elm_community$parser_combinators$Combine_ops['<*>'], - A2( - _elm_community$parser_combinators$Combine_ops['<*>'], - A2( - _elm_community$parser_combinators$Combine_ops['<$>'], - _Bogdanp$elm_ast$Ast_Statement$ImportStatement, - A2( - _elm_community$parser_combinators$Combine_ops['*>'], - _Bogdanp$elm_ast$Ast_Helpers$initialSymbol('import'), - _Bogdanp$elm_ast$Ast_Helpers$moduleName)), - _elm_community$parser_combinators$Combine$maybe( - A2( - _elm_community$parser_combinators$Combine_ops['*>'], - _Bogdanp$elm_ast$Ast_Helpers$symbol('as'), - _Bogdanp$elm_ast$Ast_Helpers$upName))), - _elm_community$parser_combinators$Combine$maybe( - A2( - _elm_community$parser_combinators$Combine_ops['*>'], - _Bogdanp$elm_ast$Ast_Helpers$symbol('exposing'), - _Bogdanp$elm_ast$Ast_Statement$exports))); -var _Bogdanp$elm_ast$Ast_Statement$EffectModuleDeclaration = F3( - function (a, b, c) { - return {ctor: 'EffectModuleDeclaration', _0: a, _1: b, _2: c}; - }); -var _Bogdanp$elm_ast$Ast_Statement$effectModuleDeclaration = A2( - _elm_community$parser_combinators$Combine_ops['<*>'], - A2( - _elm_community$parser_combinators$Combine_ops['<*>'], - A2( - _elm_community$parser_combinators$Combine_ops['<$>'], - _Bogdanp$elm_ast$Ast_Statement$EffectModuleDeclaration, - A2( - _elm_community$parser_combinators$Combine_ops['*>'], - A2( - _elm_community$parser_combinators$Combine_ops['*>'], - _Bogdanp$elm_ast$Ast_Helpers$initialSymbol('effect'), - _Bogdanp$elm_ast$Ast_Helpers$symbol('module')), - _Bogdanp$elm_ast$Ast_Helpers$moduleName)), - A2( - _elm_community$parser_combinators$Combine_ops['*>'], - _Bogdanp$elm_ast$Ast_Helpers$symbol('where'), - _elm_community$parser_combinators$Combine$braces( - _Bogdanp$elm_ast$Ast_Helpers$commaSeparated( - A2( - _elm_community$parser_combinators$Combine_ops['<*>'], - A2( - _elm_community$parser_combinators$Combine_ops['<$>'], - F2( - function (v0, v1) { - return {ctor: '_Tuple2', _0: v0, _1: v1}; - }), - _Bogdanp$elm_ast$Ast_Helpers$loName), - A2( - _elm_community$parser_combinators$Combine_ops['*>'], - _Bogdanp$elm_ast$Ast_Helpers$symbol('='), - _Bogdanp$elm_ast$Ast_Helpers$upName)))))), - A2( - _elm_community$parser_combinators$Combine_ops['*>'], - _Bogdanp$elm_ast$Ast_Helpers$symbol('exposing'), - _Bogdanp$elm_ast$Ast_Statement$exports)); -var _Bogdanp$elm_ast$Ast_Statement$PortModuleDeclaration = F2( - function (a, b) { - return {ctor: 'PortModuleDeclaration', _0: a, _1: b}; - }); -var _Bogdanp$elm_ast$Ast_Statement$portModuleDeclaration = A2( - _elm_community$parser_combinators$Combine_ops['<*>'], - A2( - _elm_community$parser_combinators$Combine_ops['<$>'], - _Bogdanp$elm_ast$Ast_Statement$PortModuleDeclaration, - A2( - _elm_community$parser_combinators$Combine_ops['*>'], - A2( - _elm_community$parser_combinators$Combine_ops['*>'], - _Bogdanp$elm_ast$Ast_Helpers$initialSymbol('port'), - _Bogdanp$elm_ast$Ast_Helpers$symbol('module')), - _Bogdanp$elm_ast$Ast_Helpers$moduleName)), - A2( - _elm_community$parser_combinators$Combine_ops['*>'], - _Bogdanp$elm_ast$Ast_Helpers$symbol('exposing'), - _Bogdanp$elm_ast$Ast_Statement$exports)); -var _Bogdanp$elm_ast$Ast_Statement$ModuleDeclaration = F2( - function (a, b) { - return {ctor: 'ModuleDeclaration', _0: a, _1: b}; - }); -var _Bogdanp$elm_ast$Ast_Statement$moduleDeclaration = A2( - _elm_community$parser_combinators$Combine_ops['<*>'], - A2( - _elm_community$parser_combinators$Combine_ops['<$>'], - _Bogdanp$elm_ast$Ast_Statement$ModuleDeclaration, - A2( - _elm_community$parser_combinators$Combine_ops['*>'], - _Bogdanp$elm_ast$Ast_Helpers$initialSymbol('module'), - _Bogdanp$elm_ast$Ast_Helpers$moduleName)), - A2( - _elm_community$parser_combinators$Combine_ops['*>'], - _Bogdanp$elm_ast$Ast_Helpers$symbol('exposing'), - _Bogdanp$elm_ast$Ast_Statement$exports)); -var _Bogdanp$elm_ast$Ast_Statement$statement = function (ops) { - return _elm_community$parser_combinators$Combine$choice( - { - ctor: '::', - _0: _Bogdanp$elm_ast$Ast_Statement$portModuleDeclaration, - _1: { - ctor: '::', - _0: _Bogdanp$elm_ast$Ast_Statement$effectModuleDeclaration, - _1: { - ctor: '::', - _0: _Bogdanp$elm_ast$Ast_Statement$moduleDeclaration, - _1: { - ctor: '::', - _0: _Bogdanp$elm_ast$Ast_Statement$importStatement, - _1: { - ctor: '::', - _0: _Bogdanp$elm_ast$Ast_Statement$typeAliasDeclaration, - _1: { - ctor: '::', - _0: _Bogdanp$elm_ast$Ast_Statement$typeDeclaration, - _1: { - ctor: '::', - _0: _Bogdanp$elm_ast$Ast_Statement$portTypeDeclaration, - _1: { - ctor: '::', - _0: _Bogdanp$elm_ast$Ast_Statement$portDeclaration(ops), - _1: { - ctor: '::', - _0: _Bogdanp$elm_ast$Ast_Statement$functionTypeDeclaration, - _1: { - ctor: '::', - _0: _Bogdanp$elm_ast$Ast_Statement$functionDeclaration(ops), - _1: { - ctor: '::', - _0: _Bogdanp$elm_ast$Ast_Statement$infixDeclaration, - _1: { - ctor: '::', - _0: _Bogdanp$elm_ast$Ast_Statement$comment, - _1: {ctor: '[]'} - } - } - } - } - } - } - } - } - } - } - } - }); -}; -var _Bogdanp$elm_ast$Ast_Statement$statements = function (ops) { - return A2( - _elm_community$parser_combinators$Combine$manyTill, - A2( - _elm_community$parser_combinators$Combine_ops['<*'], - A2( - _elm_community$parser_combinators$Combine_ops['*>'], - _elm_community$parser_combinators$Combine$whitespace, - _Bogdanp$elm_ast$Ast_Statement$statement(ops)), - _elm_community$parser_combinators$Combine$whitespace), - _elm_community$parser_combinators$Combine$end); -}; - -var _Bogdanp$elm_ast$Ast$parseModule = function (ops) { - return _elm_community$parser_combinators$Combine$parse( - _Bogdanp$elm_ast$Ast_Statement$statements(ops)); -}; -var _Bogdanp$elm_ast$Ast$parseOpTable = function (ops) { - return _elm_community$parser_combinators$Combine$parse( - _Bogdanp$elm_ast$Ast_Statement$opTable(ops)); -}; -var _Bogdanp$elm_ast$Ast$parse = function (input) { - var _p0 = A2(_Bogdanp$elm_ast$Ast$parseOpTable, _Bogdanp$elm_ast$Ast_BinOp$operators, input); - if (_p0.ctor === 'Ok') { - return A2(_Bogdanp$elm_ast$Ast$parseModule, _p0._0._2, input); - } else { - return _elm_lang$core$Result$Err(_p0._0); - } -}; -var _Bogdanp$elm_ast$Ast$parseStatement = function (ops) { - return _elm_community$parser_combinators$Combine$parse( - A2( - _elm_community$parser_combinators$Combine_ops['<*'], - _Bogdanp$elm_ast$Ast_Statement$statement(ops), - _elm_community$parser_combinators$Combine$end)); -}; -var _Bogdanp$elm_ast$Ast$parseExpression = function (ops) { - return _elm_community$parser_combinators$Combine$parse( - A2( - _elm_community$parser_combinators$Combine_ops['<*'], - _Bogdanp$elm_ast$Ast_Expression$expression(ops), - _elm_community$parser_combinators$Combine$end)); -}; - -//import Native.List // - -var _elm_lang$core$Native_Array = function() { - -// 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.ctor === '[]') - { - 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_(_elm_lang$core$Native_List.Nil, a); -} - -function toList_(list, a) -{ - for (var i = a.table.length - 1; i >= 0; i--) - { - list = - a.height === 0 - ? _elm_lang$core$Native_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 - }; -} - -return { - 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 -}; - -}(); -var _elm_lang$core$Array$append = _elm_lang$core$Native_Array.append; -var _elm_lang$core$Array$length = _elm_lang$core$Native_Array.length; -var _elm_lang$core$Array$isEmpty = function (array) { - return _elm_lang$core$Native_Utils.eq( - _elm_lang$core$Array$length(array), - 0); -}; -var _elm_lang$core$Array$slice = _elm_lang$core$Native_Array.slice; -var _elm_lang$core$Array$set = _elm_lang$core$Native_Array.set; -var _elm_lang$core$Array$get = F2( - function (i, array) { - return ((_elm_lang$core$Native_Utils.cmp(0, i) < 1) && (_elm_lang$core$Native_Utils.cmp( - i, - _elm_lang$core$Native_Array.length(array)) < 0)) ? _elm_lang$core$Maybe$Just( - A2(_elm_lang$core$Native_Array.get, i, array)) : _elm_lang$core$Maybe$Nothing; - }); -var _elm_lang$core$Array$push = _elm_lang$core$Native_Array.push; -var _elm_lang$core$Array$empty = _elm_lang$core$Native_Array.empty; -var _elm_lang$core$Array$filter = F2( - function (isOkay, arr) { - var update = F2( - function (x, xs) { - return isOkay(x) ? A2(_elm_lang$core$Native_Array.push, x, xs) : xs; - }); - return A3(_elm_lang$core$Native_Array.foldl, update, _elm_lang$core$Native_Array.empty, arr); - }); -var _elm_lang$core$Array$foldr = _elm_lang$core$Native_Array.foldr; -var _elm_lang$core$Array$foldl = _elm_lang$core$Native_Array.foldl; -var _elm_lang$core$Array$indexedMap = _elm_lang$core$Native_Array.indexedMap; -var _elm_lang$core$Array$map = _elm_lang$core$Native_Array.map; -var _elm_lang$core$Array$toIndexedList = function (array) { - return A3( - _elm_lang$core$List$map2, - F2( - function (v0, v1) { - return {ctor: '_Tuple2', _0: v0, _1: v1}; - }), - A2( - _elm_lang$core$List$range, - 0, - _elm_lang$core$Native_Array.length(array) - 1), - _elm_lang$core$Native_Array.toList(array)); -}; -var _elm_lang$core$Array$toList = _elm_lang$core$Native_Array.toList; -var _elm_lang$core$Array$fromList = _elm_lang$core$Native_Array.fromList; -var _elm_lang$core$Array$initialize = _elm_lang$core$Native_Array.initialize; -var _elm_lang$core$Array$repeat = F2( - function (n, e) { - return A2( - _elm_lang$core$Array$initialize, - n, - _elm_lang$core$Basics$always(e)); - }); -var _elm_lang$core$Array$Array = {ctor: 'Array'}; - -//import Maybe, Native.Array, Native.List, Native.Utils, Result // - -var _elm_lang$core$Native_Json = function() { - - -// CORE DECODERS - -function succeed(msg) -{ - return { - ctor: '', - tag: 'succeed', - msg: msg - }; -} - -function fail(msg) -{ - return { - ctor: '', - tag: 'fail', - msg: msg - }; -} - -function decodePrimitive(tag) -{ - return { - ctor: '', - tag: tag - }; -} - -function decodeContainer(tag, decoder) -{ - return { - ctor: '', - tag: tag, - decoder: decoder - }; -} - -function decodeNull(value) -{ - return { - ctor: '', - tag: 'null', - value: value - }; -} - -function decodeField(field, decoder) -{ - return { - ctor: '', - tag: 'field', - field: field, - decoder: decoder - }; -} - -function decodeIndex(index, decoder) -{ - return { - ctor: '', - tag: 'index', - index: index, - decoder: decoder - }; -} - -function decodeKeyValuePairs(decoder) -{ - return { - ctor: '', - tag: 'key-value', - decoder: decoder - }; -} - -function mapMany(f, decoders) -{ - return { - ctor: '', - tag: 'map-many', - func: f, - decoders: decoders - }; -} - -function andThen(callback, decoder) -{ - return { - ctor: '', - tag: 'andThen', - decoder: decoder, - callback: callback - }; -} - -function oneOf(decoders) -{ - return { - ctor: '', - tag: 'oneOf', - decoders: decoders - }; -} - - -// DECODING OBJECTS - -function map1(f, d1) -{ - return mapMany(f, [d1]); -} - -function map2(f, d1, d2) -{ - return mapMany(f, [d1, d2]); -} - -function map3(f, d1, d2, d3) -{ - return mapMany(f, [d1, d2, d3]); -} - -function map4(f, d1, d2, d3, d4) -{ - return mapMany(f, [d1, d2, d3, d4]); -} - -function map5(f, d1, d2, d3, d4, d5) -{ - return mapMany(f, [d1, d2, d3, d4, d5]); -} - -function map6(f, d1, d2, d3, d4, d5, d6) -{ - return mapMany(f, [d1, d2, d3, d4, d5, d6]); -} - -function map7(f, d1, d2, d3, d4, d5, d6, d7) -{ - return mapMany(f, [d1, d2, d3, d4, d5, d6, d7]); -} - -function map8(f, d1, d2, d3, d4, d5, d6, d7, d8) -{ - return mapMany(f, [d1, d2, d3, d4, d5, d6, d7, d8]); -} - - -// DECODE HELPERS - -function ok(value) -{ - return { tag: 'ok', value: value }; -} - -function badPrimitive(type, value) -{ - return { tag: 'primitive', type: type, value: value }; -} - -function badIndex(index, nestedProblems) -{ - return { tag: 'index', index: index, rest: nestedProblems }; -} - -function badField(field, nestedProblems) -{ - return { tag: 'field', field: field, rest: nestedProblems }; -} - -function badIndex(index, nestedProblems) -{ - return { tag: 'index', index: index, rest: nestedProblems }; -} - -function badOneOf(problems) -{ - return { tag: 'oneOf', problems: problems }; -} - -function bad(msg) -{ - return { tag: 'fail', msg: msg }; -} - -function badToString(problem) -{ - var context = '_'; - while (problem) - { - switch (problem.tag) - { - case 'primitive': - return 'Expecting ' + problem.type - + (context === '_' ? '' : ' at ' + context) - + ' but instead got: ' + jsToString(problem.value); - - case 'index': - context += '[' + problem.index + ']'; - problem = problem.rest; - break; - - case 'field': - context += '.' + problem.field; - problem = problem.rest; - break; - - case 'oneOf': - var problems = problem.problems; - for (var i = 0; i < problems.length; i++) - { - problems[i] = badToString(problems[i]); - } - return 'I ran into the following problems' - + (context === '_' ? '' : ' at ' + context) - + ':\n\n' + problems.join('\n'); - - case 'fail': - return 'I ran into a `fail` decoder' - + (context === '_' ? '' : ' at ' + context) - + ': ' + problem.msg; - } - } -} - -function jsToString(value) -{ - return value === undefined - ? 'undefined' - : JSON.stringify(value); -} - - -// DECODE - -function runOnString(decoder, string) -{ - var json; - try - { - json = JSON.parse(string); - } - catch (e) - { - return _elm_lang$core$Result$Err('Given an invalid JSON: ' + e.message); - } - return run(decoder, json); -} - -function run(decoder, value) -{ - var result = runHelp(decoder, value); - return (result.tag === 'ok') - ? _elm_lang$core$Result$Ok(result.value) - : _elm_lang$core$Result$Err(badToString(result)); -} - -function runHelp(decoder, value) -{ - switch (decoder.tag) - { - case 'bool': - return (typeof value === 'boolean') - ? ok(value) - : badPrimitive('a Bool', value); - - case 'int': - if (typeof value !== 'number') { - return badPrimitive('an Int', value); - } - - if (-2147483647 < value && value < 2147483647 && (value | 0) === value) { - return ok(value); - } - - if (isFinite(value) && !(value % 1)) { - return ok(value); - } - - return badPrimitive('an Int', value); - - case 'float': - return (typeof value === 'number') - ? ok(value) - : badPrimitive('a Float', value); - - case 'string': - return (typeof value === 'string') - ? ok(value) - : (value instanceof String) - ? ok(value + '') - : badPrimitive('a String', value); - - case 'null': - return (value === null) - ? ok(decoder.value) - : badPrimitive('null', value); - - case 'value': - return ok(value); - - case 'list': - if (!(value instanceof Array)) - { - return badPrimitive('a List', value); - } - - var list = _elm_lang$core$Native_List.Nil; - for (var i = value.length; i--; ) - { - var result = runHelp(decoder.decoder, value[i]); - if (result.tag !== 'ok') - { - return badIndex(i, result) - } - list = _elm_lang$core$Native_List.Cons(result.value, list); - } - return ok(list); - - case 'array': - if (!(value instanceof Array)) - { - return badPrimitive('an Array', value); - } - - var len = value.length; - var array = new Array(len); - for (var i = len; i--; ) - { - var result = runHelp(decoder.decoder, value[i]); - if (result.tag !== 'ok') - { - return badIndex(i, result); - } - array[i] = result.value; - } - return ok(_elm_lang$core$Native_Array.fromJSArray(array)); - - case 'maybe': - var result = runHelp(decoder.decoder, value); - return (result.tag === 'ok') - ? ok(_elm_lang$core$Maybe$Just(result.value)) - : ok(_elm_lang$core$Maybe$Nothing); - - case 'field': - var field = decoder.field; - if (typeof value !== 'object' || value === null || !(field in value)) - { - return badPrimitive('an object with a field named `' + field + '`', value); - } - - var result = runHelp(decoder.decoder, value[field]); - return (result.tag === 'ok') ? result : badField(field, result); - - case 'index': - var index = decoder.index; - if (!(value instanceof Array)) - { - return badPrimitive('an array', value); - } - if (index >= value.length) - { - return badPrimitive('a longer array. Need index ' + index + ' but there are only ' + value.length + ' entries', value); - } - - var result = runHelp(decoder.decoder, value[index]); - return (result.tag === 'ok') ? result : badIndex(index, result); - - case 'key-value': - if (typeof value !== 'object' || value === null || value instanceof Array) - { - return badPrimitive('an object', value); - } - - var keyValuePairs = _elm_lang$core$Native_List.Nil; - for (var key in value) - { - var result = runHelp(decoder.decoder, value[key]); - if (result.tag !== 'ok') - { - return badField(key, result); - } - var pair = _elm_lang$core$Native_Utils.Tuple2(key, result.value); - keyValuePairs = _elm_lang$core$Native_List.Cons(pair, keyValuePairs); - } - return ok(keyValuePairs); - - case 'map-many': - var answer = decoder.func; - var decoders = decoder.decoders; - for (var i = 0; i < decoders.length; i++) - { - var result = runHelp(decoders[i], value); - if (result.tag !== 'ok') - { - return result; - } - answer = answer(result.value); - } - return ok(answer); - - case 'andThen': - var result = runHelp(decoder.decoder, value); - return (result.tag !== 'ok') - ? result - : runHelp(decoder.callback(result.value), value); - - case 'oneOf': - var errors = []; - var temp = decoder.decoders; - while (temp.ctor !== '[]') - { - var result = runHelp(temp._0, value); - - if (result.tag === 'ok') - { - return result; - } - - errors.push(result); - - temp = temp._1; - } - return badOneOf(errors); - - case 'fail': - return bad(decoder.msg); - - case 'succeed': - return ok(decoder.msg); - } -} - - -// EQUALITY - -function equality(a, b) -{ - if (a === b) - { - return true; - } - - if (a.tag !== b.tag) - { - return false; - } - - switch (a.tag) - { - case 'succeed': - case 'fail': - return a.msg === b.msg; - - case 'bool': - case 'int': - case 'float': - case 'string': - case 'value': - return true; - - case 'null': - return a.value === b.value; - - case 'list': - case 'array': - case 'maybe': - case 'key-value': - return equality(a.decoder, b.decoder); - - case 'field': - return a.field === b.field && equality(a.decoder, b.decoder); - - case 'index': - return a.index === b.index && equality(a.decoder, b.decoder); - - case 'map-many': - if (a.func !== b.func) - { - return false; - } - return listEquality(a.decoders, b.decoders); - - case 'andThen': - return a.callback === b.callback && equality(a.decoder, b.decoder); - - case 'oneOf': - return listEquality(a.decoders, b.decoders); - } -} - -function listEquality(aDecoders, bDecoders) -{ - var len = aDecoders.length; - if (len !== bDecoders.length) - { - return false; - } - for (var i = 0; i < len; i++) - { - if (!equality(aDecoders[i], bDecoders[i])) - { - return false; - } - } - return true; -} - - -// ENCODE - -function encode(indentLevel, value) -{ - return JSON.stringify(value, null, indentLevel); -} - -function identity(value) -{ - return value; -} - -function encodeObject(keyValuePairs) -{ - var obj = {}; - while (keyValuePairs.ctor !== '[]') - { - var pair = keyValuePairs._0; - obj[pair._0] = pair._1; - keyValuePairs = keyValuePairs._1; - } - return obj; -} - -return { - encode: F2(encode), - runOnString: F2(runOnString), - run: F2(run), - - decodeNull: decodeNull, - decodePrimitive: decodePrimitive, - decodeContainer: F2(decodeContainer), - - decodeField: F2(decodeField), - decodeIndex: F2(decodeIndex), - - map1: F2(map1), - map2: F3(map2), - map3: F4(map3), - map4: F5(map4), - map5: F6(map5), - map6: F7(map6), - map7: F8(map7), - map8: F9(map8), - decodeKeyValuePairs: decodeKeyValuePairs, - - andThen: F2(andThen), - fail: fail, - succeed: succeed, - oneOf: oneOf, - - identity: identity, - encodeNull: null, - encodeArray: _elm_lang$core$Native_Array.toJSArray, - encodeList: _elm_lang$core$Native_List.toArray, - encodeObject: encodeObject, - - equality: equality -}; - -}(); - -var _elm_lang$core$Json_Encode$list = _elm_lang$core$Native_Json.encodeList; -var _elm_lang$core$Json_Encode$array = _elm_lang$core$Native_Json.encodeArray; -var _elm_lang$core$Json_Encode$object = _elm_lang$core$Native_Json.encodeObject; -var _elm_lang$core$Json_Encode$null = _elm_lang$core$Native_Json.encodeNull; -var _elm_lang$core$Json_Encode$bool = _elm_lang$core$Native_Json.identity; -var _elm_lang$core$Json_Encode$float = _elm_lang$core$Native_Json.identity; -var _elm_lang$core$Json_Encode$int = _elm_lang$core$Native_Json.identity; -var _elm_lang$core$Json_Encode$string = _elm_lang$core$Native_Json.identity; -var _elm_lang$core$Json_Encode$encode = _elm_lang$core$Native_Json.encode; -var _elm_lang$core$Json_Encode$Value = {ctor: 'Value'}; - -var _elm_lang$core$Json_Decode$null = _elm_lang$core$Native_Json.decodeNull; -var _elm_lang$core$Json_Decode$value = _elm_lang$core$Native_Json.decodePrimitive('value'); -var _elm_lang$core$Json_Decode$andThen = _elm_lang$core$Native_Json.andThen; -var _elm_lang$core$Json_Decode$fail = _elm_lang$core$Native_Json.fail; -var _elm_lang$core$Json_Decode$succeed = _elm_lang$core$Native_Json.succeed; -var _elm_lang$core$Json_Decode$lazy = function (thunk) { - return A2( - _elm_lang$core$Json_Decode$andThen, - thunk, - _elm_lang$core$Json_Decode$succeed( - {ctor: '_Tuple0'})); -}; -var _elm_lang$core$Json_Decode$decodeValue = _elm_lang$core$Native_Json.run; -var _elm_lang$core$Json_Decode$decodeString = _elm_lang$core$Native_Json.runOnString; -var _elm_lang$core$Json_Decode$map8 = _elm_lang$core$Native_Json.map8; -var _elm_lang$core$Json_Decode$map7 = _elm_lang$core$Native_Json.map7; -var _elm_lang$core$Json_Decode$map6 = _elm_lang$core$Native_Json.map6; -var _elm_lang$core$Json_Decode$map5 = _elm_lang$core$Native_Json.map5; -var _elm_lang$core$Json_Decode$map4 = _elm_lang$core$Native_Json.map4; -var _elm_lang$core$Json_Decode$map3 = _elm_lang$core$Native_Json.map3; -var _elm_lang$core$Json_Decode$map2 = _elm_lang$core$Native_Json.map2; -var _elm_lang$core$Json_Decode$map = _elm_lang$core$Native_Json.map1; -var _elm_lang$core$Json_Decode$oneOf = _elm_lang$core$Native_Json.oneOf; -var _elm_lang$core$Json_Decode$maybe = function (decoder) { - return A2(_elm_lang$core$Native_Json.decodeContainer, 'maybe', decoder); -}; -var _elm_lang$core$Json_Decode$index = _elm_lang$core$Native_Json.decodeIndex; -var _elm_lang$core$Json_Decode$field = _elm_lang$core$Native_Json.decodeField; -var _elm_lang$core$Json_Decode$at = F2( - function (fields, decoder) { - return A3(_elm_lang$core$List$foldr, _elm_lang$core$Json_Decode$field, decoder, fields); - }); -var _elm_lang$core$Json_Decode$keyValuePairs = _elm_lang$core$Native_Json.decodeKeyValuePairs; -var _elm_lang$core$Json_Decode$dict = function (decoder) { - return A2( - _elm_lang$core$Json_Decode$map, - _elm_lang$core$Dict$fromList, - _elm_lang$core$Json_Decode$keyValuePairs(decoder)); -}; -var _elm_lang$core$Json_Decode$array = function (decoder) { - return A2(_elm_lang$core$Native_Json.decodeContainer, 'array', decoder); -}; -var _elm_lang$core$Json_Decode$list = function (decoder) { - return A2(_elm_lang$core$Native_Json.decodeContainer, 'list', decoder); -}; -var _elm_lang$core$Json_Decode$nullable = function (decoder) { - return _elm_lang$core$Json_Decode$oneOf( - { - ctor: '::', - _0: _elm_lang$core$Json_Decode$null(_elm_lang$core$Maybe$Nothing), - _1: { - ctor: '::', - _0: A2(_elm_lang$core$Json_Decode$map, _elm_lang$core$Maybe$Just, decoder), - _1: {ctor: '[]'} - } - }); -}; -var _elm_lang$core$Json_Decode$float = _elm_lang$core$Native_Json.decodePrimitive('float'); -var _elm_lang$core$Json_Decode$int = _elm_lang$core$Native_Json.decodePrimitive('int'); -var _elm_lang$core$Json_Decode$bool = _elm_lang$core$Native_Json.decodePrimitive('bool'); -var _elm_lang$core$Json_Decode$string = _elm_lang$core$Native_Json.decodePrimitive('string'); -var _elm_lang$core$Json_Decode$Decoder = {ctor: 'Decoder'}; - -var _elm_lang$virtual_dom$VirtualDom_Debug$wrap; -var _elm_lang$virtual_dom$VirtualDom_Debug$wrapWithFlags; - -var _elm_lang$virtual_dom$Native_VirtualDom = function() { - -var STYLE_KEY = 'STYLE'; -var EVENT_KEY = 'EVENT'; -var ATTR_KEY = 'ATTR'; -var ATTR_NS_KEY = 'ATTR_NS'; - -var localDoc = typeof document !== 'undefined' ? document : {}; - - -//////////// VIRTUAL DOM NODES //////////// - - -function text(string) -{ - return { - type: 'text', - text: string - }; -} - - -function node(tag) -{ - return F2(function(factList, kidList) { - return nodeHelp(tag, factList, kidList); - }); -} - - -function nodeHelp(tag, factList, kidList) -{ - var organized = organizeFacts(factList); - var namespace = organized.namespace; - var facts = organized.facts; - - var children = []; - var descendantsCount = 0; - while (kidList.ctor !== '[]') - { - var kid = kidList._0; - descendantsCount += (kid.descendantsCount || 0); - children.push(kid); - kidList = kidList._1; - } - descendantsCount += children.length; - - return { - type: 'node', - tag: tag, - facts: facts, - children: children, - namespace: namespace, - descendantsCount: descendantsCount - }; -} - - -function keyedNode(tag, factList, kidList) -{ - var organized = organizeFacts(factList); - var namespace = organized.namespace; - var facts = organized.facts; - - var children = []; - var descendantsCount = 0; - while (kidList.ctor !== '[]') - { - var kid = kidList._0; - descendantsCount += (kid._1.descendantsCount || 0); - children.push(kid); - kidList = kidList._1; - } - descendantsCount += children.length; - - return { - type: 'keyed-node', - tag: tag, - facts: facts, - children: children, - namespace: namespace, - descendantsCount: descendantsCount - }; -} - - -function custom(factList, model, impl) -{ - var facts = organizeFacts(factList).facts; - - return { - type: 'custom', - facts: facts, - model: model, - impl: impl - }; -} - - -function map(tagger, node) -{ - return { - type: 'tagger', - tagger: tagger, - node: node, - descendantsCount: 1 + (node.descendantsCount || 0) - }; -} - - -function thunk(func, args, thunk) -{ - return { - type: 'thunk', - func: func, - args: args, - thunk: thunk, - node: undefined - }; -} - -function lazy(fn, a) -{ - return thunk(fn, [a], function() { - return fn(a); - }); -} - -function lazy2(fn, a, b) -{ - return thunk(fn, [a,b], function() { - return A2(fn, a, b); - }); -} - -function lazy3(fn, a, b, c) -{ - return thunk(fn, [a,b,c], function() { - return A3(fn, a, b, c); - }); -} + xSubNode = xSubNode.k; + } + var ySubNode = y.k; + while (ySubNode.$ === 4) { + nesting = true; + typeof yTaggers !== "object" + ? (yTaggers = [yTaggers, ySubNode.j]) + : yTaggers.push(ySubNode.j); -// FACTS + ySubNode = ySubNode.k; + } + // Just bail if different numbers of taggers. This implies the + // structure of the virtual DOM has changed. + if (nesting && xTaggers.length !== yTaggers.length) { + _VirtualDom_pushPatch(patches, 0, index, y); + return; + } -function organizeFacts(factList) -{ - var namespace, facts = {}; - - while (factList.ctor !== '[]') - { - var entry = factList._0; - var key = entry.key; - - if (key === ATTR_KEY || key === ATTR_NS_KEY || key === EVENT_KEY) - { - var subFacts = facts[key] || {}; - subFacts[entry.realKey] = entry.value; - facts[key] = subFacts; - } - else if (key === STYLE_KEY) - { - var styles = facts[key] || {}; - var styleList = entry.value; - while (styleList.ctor !== '[]') - { - var style = styleList._0; - styles[style._0] = style._1; - styleList = styleList._1; + // check if taggers are "the same" + if ( + nesting + ? !_VirtualDom_pairwiseRefEqual(xTaggers, yTaggers) + : xTaggers !== yTaggers + ) { + _VirtualDom_pushPatch(patches, 2, index, yTaggers); } - facts[key] = styles; - } - else if (key === 'namespace') - { - namespace = entry.value; - } - else if (key === 'className') - { - var classes = facts[key]; - facts[key] = typeof classes === 'undefined' - ? entry.value - : classes + ' ' + entry.value; - } - else - { - facts[key] = entry.value; - } - factList = factList._1; - } - - return { - facts: facts, - namespace: namespace - }; -} + // diff everything below the taggers + _VirtualDom_diffHelp(xSubNode, ySubNode, patches, index + 1); + return; + case 0: + if (x.a !== y.a) { + _VirtualDom_pushPatch(patches, 3, index, y.a); + } + return; -//////////// PROPERTIES AND ATTRIBUTES //////////// + case 1: + _VirtualDom_diffNodes( + x, + y, + patches, + index, + _VirtualDom_diffKids + ); + return; + case 2: + _VirtualDom_diffNodes( + x, + y, + patches, + index, + _VirtualDom_diffKeyedKids + ); + return; -function style(value) -{ - return { - key: STYLE_KEY, - value: value - }; -} + case 3: + if (x.h !== y.h) { + _VirtualDom_pushPatch(patches, 0, index, y); + return; + } + var factsDiff = _VirtualDom_diffFacts(x.d, y.d); + factsDiff && + _VirtualDom_pushPatch(patches, 4, index, factsDiff); -function property(key, value) -{ - return { - key: key, - value: value - }; -} + var patch = y.i(x.g, y.g); + patch && _VirtualDom_pushPatch(patches, 5, index, patch); + return; + } + } -function attribute(key, value) -{ - return { - key: ATTR_KEY, - realKey: key, - value: value - }; -} + // assumes the incoming arrays are the same length + function _VirtualDom_pairwiseRefEqual(as, bs) { + for (var i = 0; i < as.length; i++) { + if (as[i] !== bs[i]) { + return false; + } + } + return true; + } + + function _VirtualDom_diffNodes(x, y, patches, index, diffKids) { + // Bail if obvious indicators have changed. Implies more serious + // structural changes such that it's not worth it to diff. + if (x.c !== y.c || x.f !== y.f) { + _VirtualDom_pushPatch(patches, 0, index, y); + return; + } + + var factsDiff = _VirtualDom_diffFacts(x.d, y.d); + factsDiff && _VirtualDom_pushPatch(patches, 4, index, factsDiff); + + diffKids(x, y, patches, index); + } + + // DIFF FACTS + + // TODO Instead of creating a new diff object, it's possible to just test if + // there *is* a diff. During the actual patch, do the diff again and make the + // modifications directly. This way, there's no new allocations. Worth it? + function _VirtualDom_diffFacts(x, y, category) { + var diff; + + // look for changes and removals + for (var xKey in x) { + if ( + xKey === "a1" || + xKey === "a0" || + xKey === "a3" || + xKey === "a4" + ) { + var subDiff = _VirtualDom_diffFacts( + x[xKey], + y[xKey] || {}, + xKey + ); + if (subDiff) { + diff = diff || {}; + diff[xKey] = subDiff; + } + continue; + } -function attributeNS(namespace, key, value) -{ - return { - key: ATTR_NS_KEY, - realKey: key, - value: { - value: value, - namespace: namespace - } - }; -} + // remove if not in the new facts + if (!(xKey in y)) { + diff = diff || {}; + diff[xKey] = !category + ? typeof x[xKey] === "string" + ? "" + : null + : category === "a1" + ? "" + : category === "a0" || category === "a3" + ? undefined + : { f: x[xKey].f, o: undefined }; + continue; + } -function on(name, options, decoder) -{ - return { - key: EVENT_KEY, - realKey: name, - value: { - options: options, - decoder: decoder - } - }; -} + var xValue = x[xKey]; + var yValue = y[xKey]; + // reference equal, so don't worry about it + if ( + (xValue === yValue && xKey !== "value" && xKey !== "checked") || + (category === "a0" && _VirtualDom_equalEvents(xValue, yValue)) + ) { + continue; + } -function equalEvents(a, b) -{ - if (a.options !== b.options) - { - if (a.options.stopPropagation !== b.options.stopPropagation || a.options.preventDefault !== b.options.preventDefault) - { - return false; + diff = diff || {}; + diff[xKey] = yValue; } - } - return _elm_lang$core$Native_Json.equality(a.decoder, b.decoder); -} + // add new stuff + for (var yKey in y) { + if (!(yKey in x)) { + diff = diff || {}; + diff[yKey] = y[yKey]; + } + } -function mapProperty(func, property) -{ - if (property.key !== EVENT_KEY) - { - return property; - } - return on( - property.realKey, - property.value.options, - A2(_elm_lang$core$Json_Decode$map, func, property.value.decoder) - ); -} + return diff; + } + // DIFF KIDS -//////////// RENDER //////////// + function _VirtualDom_diffKids(xParent, yParent, patches, index) { + var xKids = xParent.e; + var yKids = yParent.e; + var xLen = xKids.length; + var yLen = yKids.length; -function render(vNode, eventNode) -{ - switch (vNode.type) - { - case 'thunk': - if (!vNode.node) - { - vNode.node = vNode.thunk(); - } - return render(vNode.node, eventNode); + // FIGURE OUT IF THERE ARE INSERTS OR REMOVALS - case 'tagger': - var subNode = vNode.node; - var tagger = vNode.tagger; + if (xLen > yLen) { + _VirtualDom_pushPatch(patches, 6, index, { + v: yLen, + i: xLen - yLen + }); + } else if (xLen < yLen) { + _VirtualDom_pushPatch(patches, 7, index, { + v: xLen, + e: yKids + }); + } - while (subNode.type === 'tagger') - { - typeof tagger !== 'object' - ? tagger = [tagger, subNode.tagger] - : tagger.push(subNode.tagger); + // PAIRWISE DIFF EVERYTHING ELSE - subNode = subNode.node; - } + for ( + var minLen = xLen < yLen ? xLen : yLen, i = 0; + i < minLen; + i++ + ) { + var xKid = xKids[i]; + _VirtualDom_diffHelp(xKid, yKids[i], patches, ++index); + index += xKid.b || 0; + } + } - var subEventRoot = { tagger: tagger, parent: eventNode }; - var domNode = render(subNode, subEventRoot); - domNode.elm_event_node_ref = subEventRoot; - return domNode; + // KEYED DIFF - case 'text': - return localDoc.createTextNode(vNode.text); + function _VirtualDom_diffKeyedKids( + xParent, + yParent, + patches, + rootIndex + ) { + var localPatches = []; - case 'node': - var domNode = vNode.namespace - ? localDoc.createElementNS(vNode.namespace, vNode.tag) - : localDoc.createElement(vNode.tag); + var changes = {}; // Dict String Entry + var inserts = []; // Array { index : Int, entry : Entry } + // type Entry = { tag : String, vnode : VNode, index : Int, data : _ } - applyFacts(domNode, eventNode, vNode.facts); + var xKids = xParent.e; + var yKids = yParent.e; + var xLen = xKids.length; + var yLen = yKids.length; + var xIndex = 0; + var yIndex = 0; - var children = vNode.children; + var index = rootIndex; - for (var i = 0; i < children.length; i++) - { - domNode.appendChild(render(children[i], eventNode)); - } + while (xIndex < xLen && yIndex < yLen) { + var x = xKids[xIndex]; + var y = yKids[yIndex]; - return domNode; + var xKey = x.a; + var yKey = y.a; + var xNode = x.b; + var yNode = y.b; - case 'keyed-node': - var domNode = vNode.namespace - ? localDoc.createElementNS(vNode.namespace, vNode.tag) - : localDoc.createElement(vNode.tag); + var newMatch = undefined; + var oldMatch = undefined; - applyFacts(domNode, eventNode, vNode.facts); + // check if keys match - var children = vNode.children; + if (xKey === yKey) { + index++; + _VirtualDom_diffHelp(xNode, yNode, localPatches, index); + index += xNode.b || 0; - for (var i = 0; i < children.length; i++) - { - domNode.appendChild(render(children[i]._1, eventNode)); - } + xIndex++; + yIndex++; + continue; + } - return domNode; + // look ahead 1 to detect insertions and removals. - case 'custom': - var domNode = vNode.impl.render(vNode.model); - applyFacts(domNode, eventNode, vNode.facts); - return domNode; - } -} + var xNext = xKids[xIndex + 1]; + var yNext = yKids[yIndex + 1]; + if (xNext) { + var xNextKey = xNext.a; + var xNextNode = xNext.b; + oldMatch = yKey === xNextKey; + } + if (yNext) { + var yNextKey = yNext.a; + var yNextNode = yNext.b; + newMatch = xKey === yNextKey; + } -//////////// APPLY FACTS //////////// + // swap x and y + if (newMatch && oldMatch) { + index++; + _VirtualDom_diffHelp(xNode, yNextNode, localPatches, index); + _VirtualDom_insertNode( + changes, + localPatches, + xKey, + yNode, + yIndex, + inserts + ); + index += xNode.b || 0; + index++; + _VirtualDom_removeNode( + changes, + localPatches, + xKey, + xNextNode, + index + ); + index += xNextNode.b || 0; -function applyFacts(domNode, eventNode, facts) -{ - for (var key in facts) - { - var value = facts[key]; - - switch (key) - { - case STYLE_KEY: - applyStyles(domNode, value); - break; - - case EVENT_KEY: - applyEvents(domNode, eventNode, value); - break; - - case ATTR_KEY: - applyAttrs(domNode, value); - break; - - case ATTR_NS_KEY: - applyAttrsNS(domNode, value); - break; - - case 'value': - if (domNode[key] !== value) - { - domNode[key] = value; - } - break; + xIndex += 2; + yIndex += 2; + continue; + } - default: - domNode[key] = value; - break; - } - } -} + // insert y + if (newMatch) { + index++; + _VirtualDom_insertNode( + changes, + localPatches, + yKey, + yNode, + yIndex, + inserts + ); + _VirtualDom_diffHelp(xNode, yNextNode, localPatches, index); + index += xNode.b || 0; -function applyStyles(domNode, styles) -{ - var domNodeStyle = domNode.style; + xIndex += 1; + yIndex += 2; + continue; + } - for (var key in styles) - { - domNodeStyle[key] = styles[key]; - } -} + // remove x + if (oldMatch) { + index++; + _VirtualDom_removeNode( + changes, + localPatches, + xKey, + xNode, + index + ); + index += xNode.b || 0; -function applyEvents(domNode, eventNode, events) -{ - var allHandlers = domNode.elm_handlers || {}; + index++; + _VirtualDom_diffHelp(xNextNode, yNode, localPatches, index); + index += xNextNode.b || 0; - for (var key in events) - { - var handler = allHandlers[key]; - var value = events[key]; + xIndex += 2; + yIndex += 1; + continue; + } - if (typeof value === 'undefined') - { - domNode.removeEventListener(key, handler); - allHandlers[key] = undefined; - } - else if (typeof handler === 'undefined') - { - var handler = makeEventHandler(eventNode, value); - domNode.addEventListener(key, handler); - allHandlers[key] = handler; - } - else - { - handler.info = value; - } - } + // remove x, insert y + if (xNext && xNextKey === yNextKey) { + index++; + _VirtualDom_removeNode( + changes, + localPatches, + xKey, + xNode, + index + ); + _VirtualDom_insertNode( + changes, + localPatches, + yKey, + yNode, + yIndex, + inserts + ); + index += xNode.b || 0; - domNode.elm_handlers = allHandlers; -} + index++; + _VirtualDom_diffHelp(xNextNode, yNextNode, localPatches, index); + index += xNextNode.b || 0; -function makeEventHandler(eventNode, info) -{ - function eventHandler(event) - { - var info = eventHandler.info; - - var value = A2(_elm_lang$core$Native_Json.run, info.decoder, event); - - if (value.ctor === 'Ok') - { - var options = info.options; - if (options.stopPropagation) - { - event.stopPropagation(); - } - if (options.preventDefault) - { - event.preventDefault(); - } + xIndex += 2; + yIndex += 2; + continue; + } + + break; + } + + // eat up any remaining nodes with removeNode and insertNode + + while (xIndex < xLen) { + index++; + var x = xKids[xIndex]; + var xNode = x.b; + _VirtualDom_removeNode(changes, localPatches, x.a, xNode, index); + index += xNode.b || 0; + xIndex++; + } + + while (yIndex < yLen) { + var endInserts = endInserts || []; + var y = yKids[yIndex]; + _VirtualDom_insertNode( + changes, + localPatches, + y.a, + y.b, + undefined, + endInserts + ); + yIndex++; + } + + if (localPatches.length > 0 || inserts.length > 0 || endInserts) { + _VirtualDom_pushPatch(patches, 8, rootIndex, { + w: localPatches, + x: inserts, + y: endInserts + }); + } + } + + // CHANGES FROM KEYED DIFF + + var _VirtualDom_POSTFIX = "_elmW6BL"; + + function _VirtualDom_insertNode( + changes, + localPatches, + key, + vnode, + yIndex, + inserts + ) { + var entry = changes[key]; + + // never seen this key before + if (!entry) { + entry = { + c: 0, + z: vnode, + r: yIndex, + s: undefined + }; + + inserts.push({ r: yIndex, A: entry }); + changes[key] = entry; + + return; + } + + // this key was removed earlier, a match! + if (entry.c === 1) { + inserts.push({ r: yIndex, A: entry }); + + entry.c = 2; + var subPatches = []; + _VirtualDom_diffHelp(entry.z, vnode, subPatches, entry.r); + entry.r = yIndex; + entry.s.s = { + w: subPatches, + A: entry + }; + + return; + } + + // this key has already been inserted or moved, a duplicate! + _VirtualDom_insertNode( + changes, + localPatches, + key + _VirtualDom_POSTFIX, + vnode, + yIndex, + inserts + ); + } + + function _VirtualDom_removeNode( + changes, + localPatches, + key, + vnode, + index + ) { + var entry = changes[key]; + + // never seen this key before + if (!entry) { + var patch = _VirtualDom_pushPatch( + localPatches, + 9, + index, + undefined + ); - var message = value._0; + changes[key] = { + c: 1, + z: vnode, + r: index, + s: patch + }; - var currentEventNode = eventNode; - while (currentEventNode) - { - var tagger = currentEventNode.tagger; - if (typeof tagger === 'function') - { - message = tagger(message); - } - else - { - for (var i = tagger.length; i--; ) - { - message = tagger[i](message); - } - } - currentEventNode = currentEventNode.parent; - } + return; } - }; - - eventHandler.info = info; - - return eventHandler; -} -function applyAttrs(domNode, attrs) -{ - for (var key in attrs) - { - var value = attrs[key]; - if (typeof value === 'undefined') - { - domNode.removeAttribute(key); - } - else - { - domNode.setAttribute(key, value); - } - } -} + // this key was inserted earlier, a match! + if (entry.c === 0) { + entry.c = 2; + var subPatches = []; + _VirtualDom_diffHelp(vnode, entry.z, subPatches, index); -function applyAttrsNS(domNode, nsAttrs) -{ - for (var key in nsAttrs) - { - var pair = nsAttrs[key]; - var namespace = pair.namespace; - var value = pair.value; + _VirtualDom_pushPatch(localPatches, 9, index, { + w: subPatches, + A: entry + }); - if (typeof value === 'undefined') - { - domNode.removeAttributeNS(namespace, key); - } - else - { - domNode.setAttributeNS(namespace, key, value); + return; } - } -} - - - -//////////// DIFF //////////// - -function diff(a, b) -{ - var patches = []; - diffHelp(a, b, patches, 0); - return patches; -} - - -function makePatch(type, index, data) -{ - return { - index: index, - type: type, - data: data, - domNode: undefined, - eventNode: undefined - }; -} - - -function diffHelp(a, b, patches, index) -{ - if (a === b) - { - return; - } - - var aType = a.type; - var bType = b.type; - - // Bail if you run into different types of nodes. Implies that the - // structure has changed significantly and it's not worth a diff. - if (aType !== bType) - { - patches.push(makePatch('p-redraw', index, b)); - return; - } - - // Now we know that both nodes are the same type. - switch (bType) - { - case 'thunk': - var aArgs = a.args; - var bArgs = b.args; - var i = aArgs.length; - var same = a.func === b.func && i === bArgs.length; - while (same && i--) - { - same = aArgs[i] === bArgs[i]; - } - if (same) - { - b.node = a.node; - return; + // this key has already been removed or moved, a duplicate! + _VirtualDom_removeNode( + changes, + localPatches, + key + _VirtualDom_POSTFIX, + vnode, + index + ); + } + + // ADD DOM NODES + // + // Each DOM node has an "index" assigned in order of traversal. It is important + // to minimize our crawl over the actual DOM, so these indexes (along with the + // descendantsCount of virtual nodes) let us skip touching entire subtrees of + // the DOM if we know there are no patches there. + + function _VirtualDom_addDomNodes(domNode, vNode, patches, eventNode) { + _VirtualDom_addDomNodesHelp( + domNode, + vNode, + patches, + 0, + 0, + vNode.b, + eventNode + ); + } + + // assumes `patches` is non-empty and indexes increase monotonically. + function _VirtualDom_addDomNodesHelp( + domNode, + vNode, + patches, + i, + low, + high, + eventNode + ) { + var patch = patches[i]; + var index = patch.r; + + while (index === low) { + var patchType = patch.$; + + if (patchType === 1) { + _VirtualDom_addDomNodes(domNode, vNode.k, patch.s, eventNode); + } else if (patchType === 8) { + patch.t = domNode; + patch.u = eventNode; + + var subPatches = patch.s.w; + if (subPatches.length > 0) { + _VirtualDom_addDomNodesHelp( + domNode, + vNode, + subPatches, + 0, + low, + high, + eventNode + ); } - b.node = b.thunk(); - var subPatches = []; - diffHelp(a.node, b.node, subPatches, 0); - if (subPatches.length > 0) - { - patches.push(makePatch('p-thunk', index, subPatches)); + } else if (patchType === 9) { + patch.t = domNode; + patch.u = eventNode; + + var data = patch.s; + if (data) { + data.A.s = domNode; + var subPatches = data.w; + if (subPatches.length > 0) { + _VirtualDom_addDomNodesHelp( + domNode, + vNode, + subPatches, + 0, + low, + high, + eventNode + ); + } } - return; - - case 'tagger': - // gather nested taggers - var aTaggers = a.tagger; - var bTaggers = b.tagger; - var nesting = false; - - var aSubNode = a.node; - while (aSubNode.type === 'tagger') - { - nesting = true; + } else { + patch.t = domNode; + patch.u = eventNode; + } - typeof aTaggers !== 'object' - ? aTaggers = [aTaggers, aSubNode.tagger] - : aTaggers.push(aSubNode.tagger); - - aSubNode = aSubNode.node; - } + i++; - var bSubNode = b.node; - while (bSubNode.type === 'tagger') - { - nesting = true; + if (!(patch = patches[i]) || (index = patch.r) > high) { + return i; + } + } - typeof bTaggers !== 'object' - ? bTaggers = [bTaggers, bSubNode.tagger] - : bTaggers.push(bSubNode.tagger); + var tag = vNode.$; - bSubNode = bSubNode.node; - } + if (tag === 4) { + var subNode = vNode.k; - // Just bail if different numbers of taggers. This implies the - // structure of the virtual DOM has changed. - if (nesting && aTaggers.length !== bTaggers.length) - { - patches.push(makePatch('p-redraw', index, b)); - return; - } + while (subNode.$ === 4) { + subNode = subNode.k; + } - // check if taggers are "the same" - if (nesting ? !pairwiseRefEqual(aTaggers, bTaggers) : aTaggers !== bTaggers) - { - patches.push(makePatch('p-tagger', index, bTaggers)); + return _VirtualDom_addDomNodesHelp( + domNode, + subNode, + patches, + i, + low + 1, + high, + domNode.elm_event_node_ref + ); + } + + // tag must be 1 or 2 at this point + + var vKids = vNode.e; + var childNodes = domNode.childNodes; + for (var j = 0; j < vKids.length; j++) { + low++; + var vKid = tag === 1 ? vKids[j] : vKids[j].b; + var nextLow = low + (vKid.b || 0); + if (low <= index && index <= nextLow) { + i = _VirtualDom_addDomNodesHelp( + childNodes[j], + vKid, + patches, + i, + low, + nextLow, + eventNode + ); + if (!(patch = patches[i]) || (index = patch.r) > high) { + return i; } + } + low = nextLow; + } + return i; + } - // diff everything below the taggers - diffHelp(aSubNode, bSubNode, patches, index + 1); - return; + // APPLY PATCHES - case 'text': - if (a.text !== b.text) - { - patches.push(makePatch('p-text', index, b.text)); - return; - } + function _VirtualDom_applyPatches( + rootDomNode, + oldVirtualNode, + patches, + eventNode + ) { + if (patches.length === 0) { + return rootDomNode; + } - return; + _VirtualDom_addDomNodes( + rootDomNode, + oldVirtualNode, + patches, + eventNode + ); + return _VirtualDom_applyPatchesHelp(rootDomNode, patches); + } + + function _VirtualDom_applyPatchesHelp(rootDomNode, patches) { + for (var i = 0; i < patches.length; i++) { + var patch = patches[i]; + var localDomNode = patch.t; + var newNode = _VirtualDom_applyPatch(localDomNode, patch); + if (localDomNode === rootDomNode) { + rootDomNode = newNode; + } + } + return rootDomNode; + } - case 'node': - // Bail if obvious indicators have changed. Implies more serious - // structural changes such that it's not worth it to diff. - if (a.tag !== b.tag || a.namespace !== b.namespace) - { - patches.push(makePatch('p-redraw', index, b)); - return; - } + function _VirtualDom_applyPatch(domNode, patch) { + switch (patch.$) { + case 0: + return _VirtualDom_applyPatchRedraw(domNode, patch.s, patch.u); - var factsDiff = diffFacts(a.facts, b.facts); + case 4: + _VirtualDom_applyFacts(domNode, patch.u, patch.s); + return domNode; - if (typeof factsDiff !== 'undefined') - { - patches.push(makePatch('p-facts', index, factsDiff)); - } + case 3: + domNode.replaceData(0, domNode.length, patch.s); + return domNode; - diffChildren(a, b, patches, index); - return; + case 1: + return _VirtualDom_applyPatchesHelp(domNode, patch.s); - case 'keyed-node': - // Bail if obvious indicators have changed. Implies more serious - // structural changes such that it's not worth it to diff. - if (a.tag !== b.tag || a.namespace !== b.namespace) - { - patches.push(makePatch('p-redraw', index, b)); - return; + case 2: + if (domNode.elm_event_node_ref) { + domNode.elm_event_node_ref.j = patch.s; + } else { + domNode.elm_event_node_ref = { j: patch.s, p: patch.u }; } + return domNode; - var factsDiff = diffFacts(a.facts, b.facts); - - if (typeof factsDiff !== 'undefined') - { - patches.push(makePatch('p-facts', index, factsDiff)); + case 6: + var data = patch.s; + for (var i = 0; i < data.i; i++) { + domNode.removeChild(domNode.childNodes[data.v]); } + return domNode; - diffKeyedChildren(a, b, patches, index); - return; - - case 'custom': - if (a.impl !== b.impl) - { - patches.push(makePatch('p-redraw', index, b)); - return; + case 7: + var data = patch.s; + var kids = data.e; + var i = data.v; + var theEnd = domNode.childNodes[i]; + for (; i < kids.length; i++) { + domNode.insertBefore( + _VirtualDom_render(kids[i], patch.u), + theEnd + ); } + return domNode; - var factsDiff = diffFacts(a.facts, b.facts); - if (typeof factsDiff !== 'undefined') - { - patches.push(makePatch('p-facts', index, factsDiff)); + case 9: + var data = patch.s; + if (!data) { + domNode.parentNode.removeChild(domNode); + return domNode; } - - var patch = b.impl.diff(a,b); - if (patch) - { - patches.push(makePatch('p-custom', index, patch)); - return; + var entry = data.A; + if (typeof entry.r !== "undefined") { + domNode.parentNode.removeChild(domNode); } + entry.s = _VirtualDom_applyPatchesHelp(domNode, data.w); + return domNode; - return; - } -} + case 8: + return _VirtualDom_applyPatchReorder(domNode, patch); + case 5: + return patch.s(domNode); -// assumes the incoming arrays are the same length -function pairwiseRefEqual(as, bs) -{ - for (var i = 0; i < as.length; i++) - { - if (as[i] !== bs[i]) - { - return false; + default: + _Debug_crash(10); // 'Ran into an unknown patch!' } - } - - return true; -} + } + function _VirtualDom_applyPatchRedraw(domNode, vNode, eventNode) { + var parentNode = domNode.parentNode; + var newNode = _VirtualDom_render(vNode, eventNode); -// TODO Instead of creating a new diff object, it's possible to just test if -// there *is* a diff. During the actual patch, do the diff again and make the -// modifications directly. This way, there's no new allocations. Worth it? -function diffFacts(a, b, category) -{ - var diff; - - // look for changes and removals - for (var aKey in a) - { - if (aKey === STYLE_KEY || aKey === EVENT_KEY || aKey === ATTR_KEY || aKey === ATTR_NS_KEY) - { - var subDiff = diffFacts(a[aKey], b[aKey] || {}, aKey); - if (subDiff) - { - diff = diff || {}; - diff[aKey] = subDiff; - } - continue; + if (!newNode.elm_event_node_ref) { + newNode.elm_event_node_ref = domNode.elm_event_node_ref; } - // remove if not in the new facts - if (!(aKey in b)) - { - diff = diff || {}; - diff[aKey] = - (typeof category === 'undefined') - ? (typeof a[aKey] === 'string' ? '' : null) - : - (category === STYLE_KEY) - ? '' - : - (category === EVENT_KEY || category === ATTR_KEY) - ? undefined - : - { namespace: a[aKey].namespace, value: undefined }; - - continue; + if (parentNode && newNode !== domNode) { + parentNode.replaceChild(newNode, domNode); } + return newNode; + } - var aValue = a[aKey]; - var bValue = b[aKey]; + function _VirtualDom_applyPatchReorder(domNode, patch) { + var data = patch.s; - // reference equal, so don't worry about it - if (aValue === bValue && aKey !== 'value' - || category === EVENT_KEY && equalEvents(aValue, bValue)) - { - continue; - } + // remove end inserts + var frag = _VirtualDom_applyPatchReorderEndInsertsHelp( + data.y, + patch + ); - diff = diff || {}; - diff[aKey] = bValue; - } + // removals + domNode = _VirtualDom_applyPatchesHelp(domNode, data.w); - // add new stuff - for (var bKey in b) - { - if (!(bKey in a)) - { - diff = diff || {}; - diff[bKey] = b[bKey]; + // inserts + var inserts = data.x; + for (var i = 0; i < inserts.length; i++) { + var insert = inserts[i]; + var entry = insert.A; + var node = + entry.c === 2 ? entry.s : _VirtualDom_render(entry.z, patch.u); + domNode.insertBefore(node, domNode.childNodes[insert.r]); } - } - - return diff; -} - - -function diffChildren(aParent, bParent, patches, rootIndex) -{ - var aChildren = aParent.children; - var bChildren = bParent.children; - - var aLen = aChildren.length; - var bLen = bChildren.length; - - // FIGURE OUT IF THERE ARE INSERTS OR REMOVALS - - if (aLen > bLen) - { - patches.push(makePatch('p-remove-last', rootIndex, aLen - bLen)); - } - else if (aLen < bLen) - { - patches.push(makePatch('p-append', rootIndex, bChildren.slice(aLen))); - } - - // PAIRWISE DIFF EVERYTHING ELSE - - var index = rootIndex; - var minLen = aLen < bLen ? aLen : bLen; - for (var i = 0; i < minLen; i++) - { - index++; - var aChild = aChildren[i]; - diffHelp(aChild, bChildren[i], patches, index); - index += aChild.descendantsCount || 0; - } -} - - - -//////////// KEYED DIFF //////////// + // add end inserts + if (frag) { + _VirtualDom_appendChild(domNode, frag); + } -function diffKeyedChildren(aParent, bParent, patches, rootIndex) -{ - var localPatches = []; + return domNode; + } - var changes = {}; // Dict String Entry - var inserts = []; // Array { index : Int, entry : Entry } - // type Entry = { tag : String, vnode : VNode, index : Int, data : _ } + function _VirtualDom_applyPatchReorderEndInsertsHelp( + endInserts, + patch + ) { + if (!endInserts) { + return; + } - var aChildren = aParent.children; - var bChildren = bParent.children; - var aLen = aChildren.length; - var bLen = bChildren.length; - var aIndex = 0; - var bIndex = 0; + var frag = _VirtualDom_doc.createDocumentFragment(); + for (var i = 0; i < endInserts.length; i++) { + var insert = endInserts[i]; + var entry = insert.A; + _VirtualDom_appendChild( + frag, + entry.c === 2 ? entry.s : _VirtualDom_render(entry.z, patch.u) + ); + } + return frag; + } - var index = rootIndex; + function _VirtualDom_virtualize(node) { + // TEXT NODES - while (aIndex < aLen && bIndex < bLen) - { - var a = aChildren[aIndex]; - var b = bChildren[bIndex]; + if (node.nodeType === 3) { + return _VirtualDom_text(node.textContent); + } - var aKey = a._0; - var bKey = b._0; - var aNode = a._1; - var bNode = b._1; + // WEIRD NODES - // check if keys match + if (node.nodeType !== 1) { + return _VirtualDom_text(""); + } - if (aKey === bKey) - { - index++; - diffHelp(aNode, bNode, localPatches, index); - index += aNode.descendantsCount || 0; + // ELEMENT NODES - aIndex++; - bIndex++; - continue; + var attrList = _List_Nil; + var attrs = node.attributes; + for (var i = attrs.length; i--; ) { + var attr = attrs[i]; + var name = attr.name; + var value = attr.value; + attrList = _List_Cons( + A2(_VirtualDom_attribute, name, value), + attrList + ); } - // look ahead 1 to detect insertions and removals. + var tag = node.tagName.toLowerCase(); + var kidList = _List_Nil; + var kids = node.childNodes; - var aLookAhead = aIndex + 1 < aLen; - var bLookAhead = bIndex + 1 < bLen; - - if (aLookAhead) - { - var aNext = aChildren[aIndex + 1]; - var aNextKey = aNext._0; - var aNextNode = aNext._1; - var oldMatch = bKey === aNextKey; + for (var i = kids.length; i--; ) { + kidList = _List_Cons(_VirtualDom_virtualize(kids[i]), kidList); } + return A3(_VirtualDom_node, tag, attrList, kidList); + } - if (bLookAhead) - { - var bNext = bChildren[bIndex + 1]; - var bNextKey = bNext._0; - var bNextNode = bNext._1; - var newMatch = aKey === bNextKey; + function _VirtualDom_dekey(keyedNode) { + var keyedKids = keyedNode.e; + var len = keyedKids.length; + var kids = new Array(len); + for (var i = 0; i < len; i++) { + kids[i] = keyedKids[i].b; } + return { + $: 1, + c: keyedNode.c, + d: keyedNode.d, + e: kids, + f: keyedNode.f, + b: keyedNode.b + }; + } - // swap a and b - if (aLookAhead && bLookAhead && newMatch && oldMatch) - { - index++; - diffHelp(aNode, bNextNode, localPatches, index); - insertNode(changes, localPatches, aKey, bNode, bIndex, inserts); - index += aNode.descendantsCount || 0; + // ELEMENT - index++; - removeNode(changes, localPatches, aKey, aNextNode, index); - index += aNextNode.descendantsCount || 0; + var _Debugger_element; - aIndex += 2; - bIndex += 2; - continue; - } + var _Browser_element = + _Debugger_element || + F4(function(impl, flagDecoder, debugMetadata, args) { + return _Platform_initialize( + flagDecoder, + args, + impl.init, + impl.update, + impl.subscriptions, + function(sendToApp, initialModel) { + var view = impl.view; + /**_UNUSED/ + var domNode = args['node']; + //*/ + /**/ + var domNode = + args && args["node"] ? args["node"] : _Debug_crash(0); + //*/ + var currNode = _VirtualDom_virtualize(domNode); + + return _Browser_makeAnimator(initialModel, function(model) { + var nextNode = view(model); + var patches = _VirtualDom_diff(currNode, nextNode); + domNode = _VirtualDom_applyPatches( + domNode, + currNode, + patches, + sendToApp + ); + currNode = nextNode; + }); + } + ); + }); - // insert b - if (bLookAhead && newMatch) - { - index++; - insertNode(changes, localPatches, bKey, bNode, bIndex, inserts); - diffHelp(aNode, bNextNode, localPatches, index); - index += aNode.descendantsCount || 0; + // DOCUMENT - aIndex += 1; - bIndex += 2; - continue; - } + var _Debugger_document; - // remove a - if (aLookAhead && oldMatch) - { - index++; - removeNode(changes, localPatches, aKey, aNode, index); - index += aNode.descendantsCount || 0; + var _Browser_document = + _Debugger_document || + F4(function(impl, flagDecoder, debugMetadata, args) { + return _Platform_initialize( + flagDecoder, + args, + impl.init, + impl.update, + impl.subscriptions, + function(sendToApp, initialModel) { + var divertHrefToApp = impl.setup && impl.setup(sendToApp); + var view = impl.view; + var title = _VirtualDom_doc.title; + var bodyNode = _VirtualDom_doc.body; + var currNode = _VirtualDom_virtualize(bodyNode); + return _Browser_makeAnimator(initialModel, function(model) { + _VirtualDom_divertHrefToApp = divertHrefToApp; + var doc = view(model); + var nextNode = _VirtualDom_node("body")(_List_Nil)( + doc.body + ); + var patches = _VirtualDom_diff(currNode, nextNode); + bodyNode = _VirtualDom_applyPatches( + bodyNode, + currNode, + patches, + sendToApp + ); + currNode = nextNode; + _VirtualDom_divertHrefToApp = 0; + title !== doc.title && + (_VirtualDom_doc.title = title = doc.title); + }); + } + ); + }); - index++; - diffHelp(aNextNode, bNode, localPatches, index); - index += aNextNode.descendantsCount || 0; + // ANIMATION - aIndex += 2; - bIndex += 1; - continue; - } + var _Browser_cancelAnimationFrame = + typeof cancelAnimationFrame !== "undefined" + ? cancelAnimationFrame + : function(id) { + clearTimeout(id); + }; - // remove a, insert b - if (aLookAhead && bLookAhead && aNextKey === bNextKey) - { - index++; - removeNode(changes, localPatches, aKey, aNode, index); - insertNode(changes, localPatches, bKey, bNode, bIndex, inserts); - index += aNode.descendantsCount || 0; + var _Browser_requestAnimationFrame = + typeof requestAnimationFrame !== "undefined" + ? requestAnimationFrame + : function(callback) { + return setTimeout(callback, 1000 / 60); + }; - index++; - diffHelp(aNextNode, bNextNode, localPatches, index); - index += aNextNode.descendantsCount || 0; + function _Browser_makeAnimator(model, draw) { + draw(model); - aIndex += 2; - bIndex += 2; - continue; - } + var state = 0; - break; - } - - // eat up any remaining nodes with removeNode and insertNode - - while (aIndex < aLen) - { - index++; - var a = aChildren[aIndex]; - var aNode = a._1; - removeNode(changes, localPatches, a._0, aNode, index); - index += aNode.descendantsCount || 0; - aIndex++; - } - - var endInserts; - while (bIndex < bLen) - { - endInserts = endInserts || []; - var b = bChildren[bIndex]; - insertNode(changes, localPatches, b._0, b._1, undefined, endInserts); - bIndex++; - } - - if (localPatches.length > 0 || inserts.length > 0 || typeof endInserts !== 'undefined') - { - patches.push(makePatch('p-reorder', rootIndex, { - patches: localPatches, - inserts: inserts, - endInserts: endInserts - })); - } -} + function updateIfNeeded() { + state = + state === 1 + ? 0 + : (_Browser_requestAnimationFrame(updateIfNeeded), + draw(model), + 1); + } + return function(nextModel, isSync) { + model = nextModel; + isSync + ? (draw(model), state === 2 && (state = 1)) + : (state === 0 && + _Browser_requestAnimationFrame(updateIfNeeded), + (state = 2)); + }; + } -//////////// CHANGES FROM KEYED DIFF //////////// + // APPLICATION + function _Browser_application(impl) { + var onUrlChange = impl.onUrlChange; + var onUrlRequest = impl.onUrlRequest; + var key = function() { + key.a(onUrlChange(_Browser_getUrl())); + }; -var POSTFIX = '_elmW6BL'; + return _Browser_document({ + setup: function(sendToApp) { + key.a = sendToApp; + _Browser_window.addEventListener("popstate", key); + _Browser_window.navigator.userAgent.indexOf("Trident") < 0 || + _Browser_window.addEventListener("hashchange", key); + + return F2(function(domNode, event) { + if ( + !event.ctrlKey && + !event.metaKey && + !event.shiftKey && + event.button < 1 && + !domNode.target && + !domNode.hasAttribute("download") + ) { + event.preventDefault(); + var href = domNode.href; + var curr = _Browser_getUrl(); + var next = $elm$url$Url$fromString(href).a; + sendToApp( + onUrlRequest( + next && + curr.protocol === next.protocol && + curr.host === next.host && + curr.port_.a === next.port_.a + ? $elm$browser$Browser$Internal(next) + : $elm$browser$Browser$External(href) + ) + ); + } + }); + }, + init: function(flags) { + return A3(impl.init, flags, _Browser_getUrl(), key); + }, + view: impl.view, + update: impl.update, + subscriptions: impl.subscriptions + }); + } + function _Browser_getUrl() { + return ( + $elm$url$Url$fromString(_VirtualDom_doc.location.href).a || + _Debug_crash(1) + ); + } -function insertNode(changes, localPatches, key, vnode, bIndex, inserts) -{ - var entry = changes[key]; - - // never seen this key before - if (typeof entry === 'undefined') - { - entry = { - tag: 'insert', - vnode: vnode, - index: bIndex, - data: undefined - }; + var _Browser_go = F2(function(key, n) { + return A2( + $elm$core$Task$perform, + $elm$core$Basics$never, + _Scheduler_binding(function() { + n && history.go(n); + key(); + }) + ); + }); - inserts.push({ index: bIndex, entry: entry }); - changes[key] = entry; + var _Browser_pushUrl = F2(function(key, url) { + return A2( + $elm$core$Task$perform, + $elm$core$Basics$never, + _Scheduler_binding(function() { + history.pushState({}, "", url); + key(); + }) + ); + }); - return; - } + var _Browser_replaceUrl = F2(function(key, url) { + return A2( + $elm$core$Task$perform, + $elm$core$Basics$never, + _Scheduler_binding(function() { + history.replaceState({}, "", url); + key(); + }) + ); + }); + + // GLOBAL EVENTS + + var _Browser_fakeNode = { + addEventListener: function() {}, + removeEventListener: function() {} + }; + var _Browser_doc = + typeof document !== "undefined" ? document : _Browser_fakeNode; + var _Browser_window = + typeof window !== "undefined" ? window : _Browser_fakeNode; + + var _Browser_on = F3(function(node, eventName, sendToSelf) { + return _Scheduler_spawn( + _Scheduler_binding(function(callback) { + function handler(event) { + _Scheduler_rawSpawn(sendToSelf(event)); + } + node.addEventListener( + eventName, + handler, + _VirtualDom_passiveSupported && { passive: true } + ); + return function() { + node.removeEventListener(eventName, handler); + }; + }) + ); + }); + + var _Browser_decodeEvent = F2(function(decoder, event) { + var result = _Json_runHelp(decoder, event); + return $elm$core$Result$isOk(result) + ? $elm$core$Maybe$Just(result.a) + : $elm$core$Maybe$Nothing; + }); + + // PAGE VISIBILITY + + function _Browser_visibilityInfo() { + return typeof _VirtualDom_doc.hidden !== "undefined" + ? { hidden: "hidden", change: "visibilitychange" } + : typeof _VirtualDom_doc.mozHidden !== "undefined" + ? { hidden: "mozHidden", change: "mozvisibilitychange" } + : typeof _VirtualDom_doc.msHidden !== "undefined" + ? { hidden: "msHidden", change: "msvisibilitychange" } + : typeof _VirtualDom_doc.webkitHidden !== "undefined" + ? { hidden: "webkitHidden", change: "webkitvisibilitychange" } + : { hidden: "hidden", change: "visibilitychange" }; + } + + // ANIMATION FRAMES + + function _Browser_rAF() { + return _Scheduler_binding(function(callback) { + var id = _Browser_requestAnimationFrame(function() { + callback(_Scheduler_succeed(Date.now())); + }); + + return function() { + _Browser_cancelAnimationFrame(id); + }; + }); + } - // this key was removed earlier, a match! - if (entry.tag === 'remove') - { - inserts.push({ index: bIndex, entry: entry }); + function _Browser_now() { + return _Scheduler_binding(function(callback) { + callback(_Scheduler_succeed(Date.now())); + }); + } + + // DOM STUFF + + function _Browser_withNode(id, doStuff) { + return _Scheduler_binding(function(callback) { + _Browser_requestAnimationFrame(function() { + var node = document.getElementById(id); + callback( + node + ? _Scheduler_succeed(doStuff(node)) + : _Scheduler_fail($elm$browser$Browser$Dom$NotFound(id)) + ); + }); + }); + } - entry.tag = 'move'; - var subPatches = []; - diffHelp(entry.vnode, vnode, subPatches, entry.index); - entry.index = bIndex; - entry.data.data = { - patches: subPatches, - entry: entry - }; + function _Browser_withWindow(doStuff) { + return _Scheduler_binding(function(callback) { + _Browser_requestAnimationFrame(function() { + callback(_Scheduler_succeed(doStuff())); + }); + }); + } - return; - } + // FOCUS and BLUR - // this key has already been inserted or moved, a duplicate! - insertNode(changes, localPatches, key + POSTFIX, vnode, bIndex, inserts); -} + var _Browser_call = F2(function(functionName, id) { + return _Browser_withNode(id, function(node) { + node[functionName](); + return _Utils_Tuple0; + }); + }); + // WINDOW VIEWPORT -function removeNode(changes, localPatches, key, vnode, index) -{ - var entry = changes[key]; - - // never seen this key before - if (typeof entry === 'undefined') - { - var patch = makePatch('p-remove', index, undefined); - localPatches.push(patch); - - changes[key] = { - tag: 'remove', - vnode: vnode, - index: index, - data: patch + function _Browser_getViewport() { + return { + scene: _Browser_getScene(), + viewport: { + x: _Browser_window.pageXOffset, + y: _Browser_window.pageYOffset, + width: _Browser_doc.documentElement.clientWidth, + height: _Browser_doc.documentElement.clientHeight + } }; + } - return; - } - - // this key was inserted earlier, a match! - if (entry.tag === 'insert') - { - entry.tag = 'move'; - var subPatches = []; - diffHelp(vnode, entry.vnode, subPatches, index); + function _Browser_getScene() { + var body = _Browser_doc.body; + var elem = _Browser_doc.documentElement; + return { + width: Math.max( + body.scrollWidth, + body.offsetWidth, + elem.scrollWidth, + elem.offsetWidth, + elem.clientWidth + ), + height: Math.max( + body.scrollHeight, + body.offsetHeight, + elem.scrollHeight, + elem.offsetHeight, + elem.clientHeight + ) + }; + } - var patch = makePatch('p-remove', index, { - patches: subPatches, - entry: entry + var _Browser_setViewport = F2(function(x, y) { + return _Browser_withWindow(function() { + _Browser_window.scroll(x, y); + return _Utils_Tuple0; }); - localPatches.push(patch); + }); - return; - } + // ELEMENT VIEWPORT - // this key has already been removed or moved, a duplicate! - removeNode(changes, localPatches, key + POSTFIX, vnode, index); -} + function _Browser_getViewportOf(id) { + return _Browser_withNode(id, function(node) { + return { + scene: { + width: node.scrollWidth, + height: node.scrollHeight + }, + viewport: { + x: node.scrollLeft, + y: node.scrollTop, + width: node.clientWidth, + height: node.clientHeight + } + }; + }); + } + var _Browser_setViewportOf = F3(function(id, x, y) { + return _Browser_withNode(id, function(node) { + node.scrollLeft = x; + node.scrollTop = y; + return _Utils_Tuple0; + }); + }); + + // ELEMENT + + function _Browser_getElement(id) { + return _Browser_withNode(id, function(node) { + var rect = node.getBoundingClientRect(); + var x = _Browser_window.pageXOffset; + var y = _Browser_window.pageYOffset; + return { + scene: _Browser_getScene(), + viewport: { + x: x, + y: y, + width: _Browser_doc.documentElement.clientWidth, + height: _Browser_doc.documentElement.clientHeight + }, + element: { + x: x + rect.left, + y: y + rect.top, + width: rect.width, + height: rect.height + } + }; + }); + } + // LOAD and RELOAD -//////////// ADD DOM NODES //////////// -// -// Each DOM node has an "index" assigned in order of traversal. It is important -// to minimize our crawl over the actual DOM, so these indexes (along with the -// descendantsCount of virtual nodes) let us skip touching entire subtrees of -// the DOM if we know there are no patches there. + function _Browser_reload(skipCache) { + return A2( + $elm$core$Task$perform, + $elm$core$Basics$never, + _Scheduler_binding(function(callback) { + _VirtualDom_doc.location.reload(skipCache); + }) + ); + } + function _Browser_load(url) { + return A2( + $elm$core$Task$perform, + $elm$core$Basics$never, + _Scheduler_binding(function(callback) { + try { + _Browser_window.location = url; + } catch (err) { + // Only Firefox can throw a NS_ERROR_MALFORMED_URI exception here. + // Other browsers reload the page, so let's be consistent about that. + _VirtualDom_doc.location.reload(false); + } + }) + ); + } -function addDomNodes(domNode, vNode, patches, eventNode) -{ - addDomNodesHelp(domNode, vNode, patches, 0, 0, vNode.descendantsCount, eventNode); -} + // CREATE + var _Regex_never = /.^/; -// assumes `patches` is non-empty and indexes increase monotonically. -function addDomNodesHelp(domNode, vNode, patches, i, low, high, eventNode) -{ - var patch = patches[i]; - var index = patch.index; - - while (index === low) - { - var patchType = patch.type; - - if (patchType === 'p-thunk') - { - addDomNodes(domNode, vNode.node, patch.data, eventNode); - } - else if (patchType === 'p-reorder') - { - patch.domNode = domNode; - patch.eventNode = eventNode; - - var subPatches = patch.data.patches; - if (subPatches.length > 0) - { - addDomNodesHelp(domNode, vNode, subPatches, 0, low, high, eventNode); - } - } - else if (patchType === 'p-remove') - { - patch.domNode = domNode; - patch.eventNode = eventNode; - - var data = patch.data; - if (typeof data !== 'undefined') - { - data.entry.data = domNode; - var subPatches = data.patches; - if (subPatches.length > 0) - { - addDomNodesHelp(domNode, vNode, subPatches, 0, low, high, eventNode); - } - } + var _Regex_fromStringWith = F2(function(options, string) { + var flags = "g"; + if (options.multiline) { + flags += "m"; } - else - { - patch.domNode = domNode; - patch.eventNode = eventNode; + if (options.caseInsensitive) { + flags += "i"; } - i++; - - if (!(patch = patches[i]) || (index = patch.index) > high) - { - return i; + try { + return $elm$core$Maybe$Just(new RegExp(string, flags)); + } catch (error) { + return $elm$core$Maybe$Nothing; } - } + }); - switch (vNode.type) - { - case 'tagger': - var subNode = vNode.node; + // USE - while (subNode.type === "tagger") - { - subNode = subNode.node; - } + var _Regex_contains = F2(function(re, string) { + return string.match(re) !== null; + }); - return addDomNodesHelp(domNode, subNode, patches, i, low + 1, high, domNode.elm_event_node_ref); - - case 'node': - var vChildren = vNode.children; - var childNodes = domNode.childNodes; - for (var j = 0; j < vChildren.length; j++) - { - low++; - var vChild = vChildren[j]; - var nextLow = low + (vChild.descendantsCount || 0); - if (low <= index && index <= nextLow) - { - i = addDomNodesHelp(childNodes[j], vChild, patches, i, low, nextLow, eventNode); - if (!(patch = patches[i]) || (index = patch.index) > high) - { - return i; - } + var _Regex_findAtMost = F3(function(n, re, str) { + var out = []; + var number = 0; + var string = str; + var lastIndex = re.lastIndex; + var prevLastIndex = -1; + var result; + while (number++ < n && (result = re.exec(string))) { + if (prevLastIndex == re.lastIndex) break; + var i = result.length - 1; + var subs = new Array(i); + while (i > 0) { + var submatch = result[i]; + subs[--i] = submatch + ? $elm$core$Maybe$Just(submatch) + : $elm$core$Maybe$Nothing; + } + out.push( + A4( + $elm$regex$Regex$Match, + result[0], + result.index, + number, + _List_fromArray(subs) + ) + ); + prevLastIndex = re.lastIndex; + } + re.lastIndex = lastIndex; + return _List_fromArray(out); + }); + + var _Regex_replaceAtMost = F4(function(n, re, replacer, string) { + var count = 0; + function jsReplacer(match) { + if (count++ >= n) { + return match; + } + var i = arguments.length - 3; + var submatches = new Array(i); + while (i > 0) { + var submatch = arguments[i]; + submatches[--i] = submatch + ? $elm$core$Maybe$Just(submatch) + : $elm$core$Maybe$Nothing; + } + return replacer( + A4( + $elm$regex$Regex$Match, + match, + arguments[arguments.length - 2], + count, + _List_fromArray(submatches) + ) + ); + } + return string.replace(re, jsReplacer); + }); + + var _Regex_splitAtMost = F3(function(n, re, str) { + var string = str; + var out = []; + var start = re.lastIndex; + var restoreLastIndex = re.lastIndex; + while (n--) { + var result = re.exec(string); + if (!result) break; + out.push(string.slice(start, result.index)); + start = re.lastIndex; + } + out.push(string.slice(start)); + re.lastIndex = restoreLastIndex; + return _List_fromArray(out); + }); + + var _Regex_infinity = Infinity; + var $author$project$Main$init = + "\nmodule Main exposing (..)\n\nf : Int -> Int\nf x = x + 1\n\ng : Int -> Int\ng x = x * 2\n\nh = f << g\n"; + var $elm$core$Basics$EQ = { $: "EQ" }; + var $elm$core$Basics$GT = { $: "GT" }; + var $elm$core$Basics$LT = { $: "LT" }; + var $elm$core$List$cons = _List_cons; + var $elm$core$Dict$foldr = F3(function(func, acc, t) { + foldr: while (true) { + if (t.$ === "RBEmpty_elm_builtin") { + return acc; + } else { + var key = t.b; + var value = t.c; + var left = t.d; + var right = t.e; + var $temp$func = func, + $temp$acc = A3( + func, + key, + value, + A3($elm$core$Dict$foldr, func, acc, right) + ), + $temp$t = left; + func = $temp$func; + acc = $temp$acc; + t = $temp$t; + continue foldr; + } + } + }); + var $elm$core$Dict$toList = function(dict) { + return A3( + $elm$core$Dict$foldr, + F3(function(key, value, list) { + return A2($elm$core$List$cons, _Utils_Tuple2(key, value), list); + }), + _List_Nil, + dict + ); + }; + var $elm$core$Dict$keys = function(dict) { + return A3( + $elm$core$Dict$foldr, + F3(function(key, value, keyList) { + return A2($elm$core$List$cons, key, keyList); + }), + _List_Nil, + dict + ); + }; + var $elm$core$Set$toList = function(_v0) { + var dict = _v0.a; + return $elm$core$Dict$keys(dict); + }; + var $elm$core$Elm$JsArray$foldr = _JsArray_foldr; + var $elm$core$Array$foldr = F3(function(func, baseCase, _v0) { + var tree = _v0.c; + var tail = _v0.d; + var helper = F2(function(node, acc) { + if (node.$ === "SubTree") { + var subTree = node.a; + return A3($elm$core$Elm$JsArray$foldr, helper, acc, subTree); + } else { + var values = node.a; + return A3($elm$core$Elm$JsArray$foldr, func, acc, values); + } + }); + return A3( + $elm$core$Elm$JsArray$foldr, + helper, + A3($elm$core$Elm$JsArray$foldr, func, baseCase, tail), + tree + ); + }); + var $elm$core$Array$toList = function(array) { + return A3( + $elm$core$Array$foldr, + $elm$core$List$cons, + _List_Nil, + array + ); + }; + var $elm$core$Result$Err = function(a) { + return { $: "Err", a: a }; + }; + var $elm$json$Json$Decode$Failure = F2(function(a, b) { + return { $: "Failure", a: a, b: b }; + }); + var $elm$json$Json$Decode$Field = F2(function(a, b) { + return { $: "Field", a: a, b: b }; + }); + var $elm$json$Json$Decode$Index = F2(function(a, b) { + return { $: "Index", a: a, b: b }; + }); + var $elm$core$Result$Ok = function(a) { + return { $: "Ok", a: a }; + }; + var $elm$json$Json$Decode$OneOf = function(a) { + return { $: "OneOf", a: a }; + }; + var $elm$core$Basics$False = { $: "False" }; + var $elm$core$Basics$add = _Basics_add; + var $elm$core$Maybe$Just = function(a) { + return { $: "Just", a: a }; + }; + var $elm$core$Maybe$Nothing = { $: "Nothing" }; + var $elm$core$String$all = _String_all; + var $elm$core$Basics$and = _Basics_and; + var $elm$core$Basics$append = _Utils_append; + var $elm$json$Json$Encode$encode = _Json_encode; + var $elm$core$String$fromInt = _String_fromNumber; + var $elm$core$String$join = F2(function(sep, chunks) { + return A2(_String_join, sep, _List_toArray(chunks)); + }); + var $elm$core$String$split = F2(function(sep, string) { + return _List_fromArray(A2(_String_split, sep, string)); + }); + var $elm$json$Json$Decode$indent = function(str) { + return A2( + $elm$core$String$join, + "\n ", + A2($elm$core$String$split, "\n", str) + ); + }; + var $elm$core$List$foldl = F3(function(func, acc, list) { + foldl: while (true) { + if (!list.b) { + return acc; + } else { + var x = list.a; + var xs = list.b; + var $temp$func = func, + $temp$acc = A2(func, x, acc), + $temp$list = xs; + func = $temp$func; + acc = $temp$acc; + list = $temp$list; + continue foldl; + } + } + }); + var $elm$core$List$length = function(xs) { + return A3( + $elm$core$List$foldl, + F2(function(_v0, i) { + return i + 1; + }), + 0, + xs + ); + }; + var $elm$core$List$map2 = _List_map2; + var $elm$core$Basics$le = _Utils_le; + var $elm$core$Basics$sub = _Basics_sub; + var $elm$core$List$rangeHelp = F3(function(lo, hi, list) { + rangeHelp: while (true) { + if (_Utils_cmp(lo, hi) < 1) { + var $temp$lo = lo, + $temp$hi = hi - 1, + $temp$list = A2($elm$core$List$cons, hi, list); + lo = $temp$lo; + hi = $temp$hi; + list = $temp$list; + continue rangeHelp; + } else { + return list; + } + } + }); + var $elm$core$List$range = F2(function(lo, hi) { + return A3($elm$core$List$rangeHelp, lo, hi, _List_Nil); + }); + var $elm$core$List$indexedMap = F2(function(f, xs) { + return A3( + $elm$core$List$map2, + f, + A2($elm$core$List$range, 0, $elm$core$List$length(xs) - 1), + xs + ); + }); + var $elm$core$Char$toCode = _Char_toCode; + var $elm$core$Char$isLower = function(_char) { + var code = $elm$core$Char$toCode(_char); + return 97 <= code && code <= 122; + }; + var $elm$core$Char$isUpper = function(_char) { + var code = $elm$core$Char$toCode(_char); + return code <= 90 && 65 <= code; + }; + var $elm$core$Basics$or = _Basics_or; + var $elm$core$Char$isAlpha = function(_char) { + return ( + $elm$core$Char$isLower(_char) || $elm$core$Char$isUpper(_char) + ); + }; + var $elm$core$Char$isDigit = function(_char) { + var code = $elm$core$Char$toCode(_char); + return code <= 57 && 48 <= code; + }; + var $elm$core$Char$isAlphaNum = function(_char) { + return ( + $elm$core$Char$isLower(_char) || + $elm$core$Char$isUpper(_char) || $elm$core$Char$isDigit(_char) + ); + }; + var $elm$core$List$reverse = function(list) { + return A3( + $elm$core$List$foldl, + $elm$core$List$cons, + _List_Nil, + list + ); + }; + var $elm$core$String$uncons = _String_uncons; + var $elm$json$Json$Decode$errorOneOf = F2(function(i, error) { + return ( + "\n\n(" + + ($elm$core$String$fromInt(i + 1) + + (") " + + $elm$json$Json$Decode$indent( + $elm$json$Json$Decode$errorToString(error) + ))) + ); + }); + var $elm$json$Json$Decode$errorToString = function(error) { + return A2( + $elm$json$Json$Decode$errorToStringHelp, + error, + _List_Nil + ); + }; + var $elm$json$Json$Decode$errorToStringHelp = F2(function( + error, + context + ) { + errorToStringHelp: while (true) { + switch (error.$) { + case "Field": + var f = error.a; + var err = error.b; + var isSimple = (function() { + var _v1 = $elm$core$String$uncons(f); + if (_v1.$ === "Nothing") { + return false; + } else { + var _v2 = _v1.a; + var _char = _v2.a; + var rest = _v2.b; + return ( + $elm$core$Char$isAlpha(_char) && + A2( + $elm$core$String$all, + $elm$core$Char$isAlphaNum, + rest + ) + ); } - low = nextLow; - } - return i; - - case 'keyed-node': - var vChildren = vNode.children; - var childNodes = domNode.childNodes; - for (var j = 0; j < vChildren.length; j++) - { - low++; - var vChild = vChildren[j]._1; - var nextLow = low + (vChild.descendantsCount || 0); - if (low <= index && index <= nextLow) - { - i = addDomNodesHelp(childNodes[j], vChild, patches, i, low, nextLow, eventNode); - if (!(patch = patches[i]) || (index = patch.index) > high) - { - return i; + })(); + var fieldName = isSimple ? "." + f : "['" + (f + "']"); + var $temp$error = err, + $temp$context = A2($elm$core$List$cons, fieldName, context); + error = $temp$error; + context = $temp$context; + continue errorToStringHelp; + case "Index": + var i = error.a; + var err = error.b; + var indexName = "[" + ($elm$core$String$fromInt(i) + "]"); + var $temp$error = err, + $temp$context = A2($elm$core$List$cons, indexName, context); + error = $temp$error; + context = $temp$context; + continue errorToStringHelp; + case "OneOf": + var errors = error.a; + if (!errors.b) { + return ( + "Ran into a Json.Decode.oneOf with no possibilities" + + (function() { + if (!context.b) { + return "!"; + } else { + return ( + " at json" + + A2( + $elm$core$String$join, + "", + $elm$core$List$reverse(context) + ) + ); + } + })() + ); + } else { + if (!errors.b.b) { + var err = errors.a; + var $temp$error = err, + $temp$context = context; + error = $temp$error; + context = $temp$context; + continue errorToStringHelp; + } else { + var starter = (function() { + if (!context.b) { + return "Json.Decode.oneOf"; + } else { + return ( + "The Json.Decode.oneOf at json" + + A2( + $elm$core$String$join, + "", + $elm$core$List$reverse(context) + ) + ); } + })(); + var introduction = + starter + + (" failed in the following " + + ($elm$core$String$fromInt( + $elm$core$List$length(errors) + ) + + " ways:")); + return A2( + $elm$core$String$join, + "\n\n", + A2( + $elm$core$List$cons, + introduction, + A2( + $elm$core$List$indexedMap, + $elm$json$Json$Decode$errorOneOf, + errors + ) + ) + ); + } + } + default: + var msg = error.a; + var json = error.b; + var introduction = (function() { + if (!context.b) { + return "Problem with the given value:\n\n"; + } else { + return ( + "Problem with the value at json" + + (A2( + $elm$core$String$join, + "", + $elm$core$List$reverse(context) + ) + + ":\n\n ") + ); } - low = nextLow; + })(); + return ( + introduction + + ($elm$json$Json$Decode$indent( + A2($elm$json$Json$Encode$encode, 4, json) + ) + + ("\n\n" + msg)) + ); + } + } + }); + var $elm$core$Array$branchFactor = 32; + var $elm$core$Array$Array_elm_builtin = F4(function(a, b, c, d) { + return { $: "Array_elm_builtin", a: a, b: b, c: c, d: d }; + }); + var $elm$core$Elm$JsArray$empty = _JsArray_empty; + var $elm$core$Basics$ceiling = _Basics_ceiling; + var $elm$core$Basics$fdiv = _Basics_fdiv; + var $elm$core$Basics$logBase = F2(function(base, number) { + return _Basics_log(number) / _Basics_log(base); + }); + var $elm$core$Basics$toFloat = _Basics_toFloat; + var $elm$core$Array$shiftStep = $elm$core$Basics$ceiling( + A2($elm$core$Basics$logBase, 2, $elm$core$Array$branchFactor) + ); + var $elm$core$Array$empty = A4( + $elm$core$Array$Array_elm_builtin, + 0, + $elm$core$Array$shiftStep, + $elm$core$Elm$JsArray$empty, + $elm$core$Elm$JsArray$empty + ); + var $elm$core$Elm$JsArray$initialize = _JsArray_initialize; + var $elm$core$Array$Leaf = function(a) { + return { $: "Leaf", a: a }; + }; + var $elm$core$Basics$apL = F2(function(f, x) { + return f(x); + }); + var $elm$core$Basics$apR = F2(function(x, f) { + return f(x); + }); + var $elm$core$Basics$eq = _Utils_equal; + var $elm$core$Basics$floor = _Basics_floor; + var $elm$core$Elm$JsArray$length = _JsArray_length; + var $elm$core$Basics$gt = _Utils_gt; + var $elm$core$Basics$max = F2(function(x, y) { + return _Utils_cmp(x, y) > 0 ? x : y; + }); + var $elm$core$Basics$mul = _Basics_mul; + var $elm$core$Array$SubTree = function(a) { + return { $: "SubTree", a: a }; + }; + var $elm$core$Elm$JsArray$initializeFromList = _JsArray_initializeFromList; + var $elm$core$Array$compressNodes = F2(function(nodes, acc) { + compressNodes: while (true) { + var _v0 = A2( + $elm$core$Elm$JsArray$initializeFromList, + $elm$core$Array$branchFactor, + nodes + ); + var node = _v0.a; + var remainingNodes = _v0.b; + var newAcc = A2( + $elm$core$List$cons, + $elm$core$Array$SubTree(node), + acc + ); + if (!remainingNodes.b) { + return $elm$core$List$reverse(newAcc); + } else { + var $temp$nodes = remainingNodes, + $temp$acc = newAcc; + nodes = $temp$nodes; + acc = $temp$acc; + continue compressNodes; + } + } + }); + var $elm$core$Tuple$first = function(_v0) { + var x = _v0.a; + return x; + }; + var $elm$core$Array$treeFromBuilder = F2(function( + nodeList, + nodeListSize + ) { + treeFromBuilder: while (true) { + var newNodeSize = $elm$core$Basics$ceiling( + nodeListSize / $elm$core$Array$branchFactor + ); + if (newNodeSize === 1) { + return A2( + $elm$core$Elm$JsArray$initializeFromList, + $elm$core$Array$branchFactor, + nodeList + ).a; + } else { + var $temp$nodeList = A2( + $elm$core$Array$compressNodes, + nodeList, + _List_Nil + ), + $temp$nodeListSize = newNodeSize; + nodeList = $temp$nodeList; + nodeListSize = $temp$nodeListSize; + continue treeFromBuilder; + } + } + }); + var $elm$core$Array$builderToArray = F2(function( + reverseNodeList, + builder + ) { + if (!builder.nodeListSize) { + return A4( + $elm$core$Array$Array_elm_builtin, + $elm$core$Elm$JsArray$length(builder.tail), + $elm$core$Array$shiftStep, + $elm$core$Elm$JsArray$empty, + builder.tail + ); + } else { + var treeLen = builder.nodeListSize * $elm$core$Array$branchFactor; + var depth = $elm$core$Basics$floor( + A2( + $elm$core$Basics$logBase, + $elm$core$Array$branchFactor, + treeLen - 1 + ) + ); + var correctNodeList = reverseNodeList + ? $elm$core$List$reverse(builder.nodeList) + : builder.nodeList; + var tree = A2( + $elm$core$Array$treeFromBuilder, + correctNodeList, + builder.nodeListSize + ); + return A4( + $elm$core$Array$Array_elm_builtin, + $elm$core$Elm$JsArray$length(builder.tail) + treeLen, + A2($elm$core$Basics$max, 5, depth * $elm$core$Array$shiftStep), + tree, + builder.tail + ); + } + }); + var $elm$core$Basics$idiv = _Basics_idiv; + var $elm$core$Basics$lt = _Utils_lt; + var $elm$core$Array$initializeHelp = F5(function( + fn, + fromIndex, + len, + nodeList, + tail + ) { + initializeHelp: while (true) { + if (fromIndex < 0) { + return A2($elm$core$Array$builderToArray, false, { + nodeList: nodeList, + nodeListSize: (len / $elm$core$Array$branchFactor) | 0, + tail: tail + }); + } else { + var leaf = $elm$core$Array$Leaf( + A3( + $elm$core$Elm$JsArray$initialize, + $elm$core$Array$branchFactor, + fromIndex, + fn + ) + ); + var $temp$fn = fn, + $temp$fromIndex = fromIndex - $elm$core$Array$branchFactor, + $temp$len = len, + $temp$nodeList = A2($elm$core$List$cons, leaf, nodeList), + $temp$tail = tail; + fn = $temp$fn; + fromIndex = $temp$fromIndex; + len = $temp$len; + nodeList = $temp$nodeList; + tail = $temp$tail; + continue initializeHelp; + } + } + }); + var $elm$core$Basics$remainderBy = _Basics_remainderBy; + var $elm$core$Array$initialize = F2(function(len, fn) { + if (len <= 0) { + return $elm$core$Array$empty; + } else { + var tailLen = len % $elm$core$Array$branchFactor; + var tail = A3( + $elm$core$Elm$JsArray$initialize, + tailLen, + len - tailLen, + fn + ); + var initialFromIndex = + len - tailLen - $elm$core$Array$branchFactor; + return A5( + $elm$core$Array$initializeHelp, + fn, + initialFromIndex, + len, + _List_Nil, + tail + ); + } + }); + var $elm$core$Basics$True = { $: "True" }; + var $elm$core$Result$isOk = function(result) { + if (result.$ === "Ok") { + return true; + } else { + return false; + } + }; + var $elm$json$Json$Decode$map = _Json_map1; + var $elm$json$Json$Decode$map2 = _Json_map2; + var $elm$json$Json$Decode$succeed = _Json_succeed; + var $elm$virtual_dom$VirtualDom$toHandlerInt = function(handler) { + switch (handler.$) { + case "Normal": + return 0; + case "MayStopPropagation": + return 1; + case "MayPreventDefault": + return 2; + default: + return 3; + } + }; + var $elm$browser$Browser$External = function(a) { + return { $: "External", a: a }; + }; + var $elm$browser$Browser$Internal = function(a) { + return { $: "Internal", a: a }; + }; + var $elm$core$Basics$identity = function(x) { + return x; + }; + var $elm$browser$Browser$Dom$NotFound = function(a) { + return { $: "NotFound", a: a }; + }; + var $elm$url$Url$Http = { $: "Http" }; + var $elm$url$Url$Https = { $: "Https" }; + var $elm$url$Url$Url = F6(function( + protocol, + host, + port_, + path, + query, + fragment + ) { + return { + fragment: fragment, + host: host, + path: path, + port_: port_, + protocol: protocol, + query: query + }; + }); + var $elm$core$String$contains = _String_contains; + var $elm$core$String$length = _String_length; + var $elm$core$String$slice = _String_slice; + var $elm$core$String$dropLeft = F2(function(n, string) { + return n < 1 + ? string + : A3( + $elm$core$String$slice, + n, + $elm$core$String$length(string), + string + ); + }); + var $elm$core$String$indexes = _String_indexes; + var $elm$core$String$isEmpty = function(string) { + return string === ""; + }; + var $elm$core$String$left = F2(function(n, string) { + return n < 1 ? "" : A3($elm$core$String$slice, 0, n, string); + }); + var $elm$core$String$toInt = _String_toInt; + var $elm$url$Url$chompBeforePath = F5(function( + protocol, + path, + params, + frag, + str + ) { + if ( + $elm$core$String$isEmpty(str) || + A2($elm$core$String$contains, "@", str) + ) { + return $elm$core$Maybe$Nothing; + } else { + var _v0 = A2($elm$core$String$indexes, ":", str); + if (!_v0.b) { + return $elm$core$Maybe$Just( + A6( + $elm$url$Url$Url, + protocol, + str, + $elm$core$Maybe$Nothing, + path, + params, + frag + ) + ); + } else { + if (!_v0.b.b) { + var i = _v0.a; + var _v1 = $elm$core$String$toInt( + A2($elm$core$String$dropLeft, i + 1, str) + ); + if (_v1.$ === "Nothing") { + return $elm$core$Maybe$Nothing; + } else { + var port_ = _v1; + return $elm$core$Maybe$Just( + A6( + $elm$url$Url$Url, + protocol, + A2($elm$core$String$left, i, str), + port_, + path, + params, + frag + ) + ); + } + } else { + return $elm$core$Maybe$Nothing; } - return i; - - case 'text': - case 'thunk': - throw new Error('should never traverse `text` or `thunk` nodes like this'); - } -} - - - -//////////// APPLY PATCHES //////////// - - -function applyPatches(rootDomNode, oldVirtualNode, patches, eventNode) -{ - if (patches.length === 0) - { - return rootDomNode; - } - - addDomNodes(rootDomNode, oldVirtualNode, patches, eventNode); - return applyPatchesHelp(rootDomNode, patches); -} - -function applyPatchesHelp(rootDomNode, patches) -{ - for (var i = 0; i < patches.length; i++) - { - var patch = patches[i]; - var localDomNode = patch.domNode - var newNode = applyPatch(localDomNode, patch); - if (localDomNode === rootDomNode) - { - rootDomNode = newNode; + } + } + }); + var $elm$url$Url$chompBeforeQuery = F4(function( + protocol, + params, + frag, + str + ) { + if ($elm$core$String$isEmpty(str)) { + return $elm$core$Maybe$Nothing; + } else { + var _v0 = A2($elm$core$String$indexes, "/", str); + if (!_v0.b) { + return A5( + $elm$url$Url$chompBeforePath, + protocol, + "/", + params, + frag, + str + ); + } else { + var i = _v0.a; + return A5( + $elm$url$Url$chompBeforePath, + protocol, + A2($elm$core$String$dropLeft, i, str), + params, + frag, + A2($elm$core$String$left, i, str) + ); + } + } + }); + var $elm$url$Url$chompBeforeFragment = F3(function( + protocol, + frag, + str + ) { + if ($elm$core$String$isEmpty(str)) { + return $elm$core$Maybe$Nothing; + } else { + var _v0 = A2($elm$core$String$indexes, "?", str); + if (!_v0.b) { + return A4( + $elm$url$Url$chompBeforeQuery, + protocol, + $elm$core$Maybe$Nothing, + frag, + str + ); + } else { + var i = _v0.a; + return A4( + $elm$url$Url$chompBeforeQuery, + protocol, + $elm$core$Maybe$Just( + A2($elm$core$String$dropLeft, i + 1, str) + ), + frag, + A2($elm$core$String$left, i, str) + ); + } } - } - return rootDomNode; -} - -function applyPatch(domNode, patch) -{ - switch (patch.type) - { - case 'p-redraw': - return applyPatchRedraw(domNode, patch.data, patch.eventNode); - - case 'p-facts': - applyFacts(domNode, patch.eventNode, patch.data); - return domNode; - - case 'p-text': - domNode.replaceData(0, domNode.length, patch.data); - return domNode; - - case 'p-thunk': - return applyPatchesHelp(domNode, patch.data); - - case 'p-tagger': - if (typeof domNode.elm_event_node_ref !== 'undefined') - { - domNode.elm_event_node_ref.tagger = patch.data; + }); + var $elm$url$Url$chompAfterProtocol = F2(function(protocol, str) { + if ($elm$core$String$isEmpty(str)) { + return $elm$core$Maybe$Nothing; + } else { + var _v0 = A2($elm$core$String$indexes, "#", str); + if (!_v0.b) { + return A3( + $elm$url$Url$chompBeforeFragment, + protocol, + $elm$core$Maybe$Nothing, + str + ); + } else { + var i = _v0.a; + return A3( + $elm$url$Url$chompBeforeFragment, + protocol, + $elm$core$Maybe$Just( + A2($elm$core$String$dropLeft, i + 1, str) + ), + A2($elm$core$String$left, i, str) + ); + } + } + }); + var $elm$core$String$startsWith = _String_startsWith; + var $elm$url$Url$fromString = function(str) { + return A2($elm$core$String$startsWith, "http://", str) + ? A2( + $elm$url$Url$chompAfterProtocol, + $elm$url$Url$Http, + A2($elm$core$String$dropLeft, 7, str) + ) + : A2($elm$core$String$startsWith, "https://", str) + ? A2( + $elm$url$Url$chompAfterProtocol, + $elm$url$Url$Https, + A2($elm$core$String$dropLeft, 8, str) + ) + : $elm$core$Maybe$Nothing; + }; + var $elm$core$Basics$never = function(_v0) { + never: while (true) { + var nvr = _v0.a; + var $temp$_v0 = nvr; + _v0 = $temp$_v0; + continue never; + } + }; + var $elm$core$Task$Perform = function(a) { + return { $: "Perform", a: a }; + }; + var $elm$core$Task$succeed = _Scheduler_succeed; + var $elm$core$Task$init = $elm$core$Task$succeed(_Utils_Tuple0); + var $elm$core$List$foldrHelper = F4(function(fn, acc, ctr, ls) { + if (!ls.b) { + return acc; + } else { + var a = ls.a; + var r1 = ls.b; + if (!r1.b) { + return A2(fn, a, acc); + } else { + var b = r1.a; + var r2 = r1.b; + if (!r2.b) { + return A2(fn, a, A2(fn, b, acc)); + } else { + var c = r2.a; + var r3 = r2.b; + if (!r3.b) { + return A2(fn, a, A2(fn, b, A2(fn, c, acc))); + } else { + var d = r3.a; + var r4 = r3.b; + var res = + ctr > 500 + ? A3( + $elm$core$List$foldl, + fn, + acc, + $elm$core$List$reverse(r4) + ) + : A4($elm$core$List$foldrHelper, fn, acc, ctr + 1, r4); + return A2(fn, a, A2(fn, b, A2(fn, c, A2(fn, d, res)))); + } + } + } + } + }); + var $elm$core$List$foldr = F3(function(fn, acc, ls) { + return A4($elm$core$List$foldrHelper, fn, acc, 0, ls); + }); + var $elm$core$List$map = F2(function(f, xs) { + return A3( + $elm$core$List$foldr, + F2(function(x, acc) { + return A2($elm$core$List$cons, f(x), acc); + }), + _List_Nil, + xs + ); + }); + var $elm$core$Task$andThen = _Scheduler_andThen; + var $elm$core$Task$map = F2(function(func, taskA) { + return A2( + $elm$core$Task$andThen, + function(a) { + return $elm$core$Task$succeed(func(a)); + }, + taskA + ); + }); + var $elm$core$Task$map2 = F3(function(func, taskA, taskB) { + return A2( + $elm$core$Task$andThen, + function(a) { + return A2( + $elm$core$Task$andThen, + function(b) { + return $elm$core$Task$succeed(A2(func, a, b)); + }, + taskB + ); + }, + taskA + ); + }); + var $elm$core$Task$sequence = function(tasks) { + return A3( + $elm$core$List$foldr, + $elm$core$Task$map2($elm$core$List$cons), + $elm$core$Task$succeed(_List_Nil), + tasks + ); + }; + var $elm$core$Platform$sendToApp = _Platform_sendToApp; + var $elm$core$Task$spawnCmd = F2(function(router, _v0) { + var task = _v0.a; + return _Scheduler_spawn( + A2( + $elm$core$Task$andThen, + $elm$core$Platform$sendToApp(router), + task + ) + ); + }); + var $elm$core$Task$onEffects = F3(function(router, commands, state) { + return A2( + $elm$core$Task$map, + function(_v0) { + return _Utils_Tuple0; + }, + $elm$core$Task$sequence( + A2( + $elm$core$List$map, + $elm$core$Task$spawnCmd(router), + commands + ) + ) + ); + }); + var $elm$core$Task$onSelfMsg = F3(function(_v0, _v1, _v2) { + return $elm$core$Task$succeed(_Utils_Tuple0); + }); + var $elm$core$Task$cmdMap = F2(function(tagger, _v0) { + var task = _v0.a; + return $elm$core$Task$Perform(A2($elm$core$Task$map, tagger, task)); + }); + _Platform_effectManagers["Task"] = _Platform_createManager( + $elm$core$Task$init, + $elm$core$Task$onEffects, + $elm$core$Task$onSelfMsg, + $elm$core$Task$cmdMap + ); + var $elm$core$Task$command = _Platform_leaf("Task"); + var $elm$core$Task$perform = F2(function(toMessage, task) { + return $elm$core$Task$command( + $elm$core$Task$Perform(A2($elm$core$Task$map, toMessage, task)) + ); + }); + var $elm$core$Platform$Cmd$batch = _Platform_batch; + var $elm$core$Platform$Cmd$none = $elm$core$Platform$Cmd$batch( + _List_Nil + ); + var $elm$core$Platform$Sub$batch = _Platform_batch; + var $elm$core$Platform$Sub$none = $elm$core$Platform$Sub$batch( + _List_Nil + ); + var $elm$browser$Browser$sandbox = function(impl) { + return _Browser_element({ + init: function(_v0) { + return _Utils_Tuple2(impl.init, $elm$core$Platform$Cmd$none); + }, + subscriptions: function(_v1) { + return $elm$core$Platform$Sub$none; + }, + update: F2(function(msg, model) { + return _Utils_Tuple2( + A2(impl.update, msg, model), + $elm$core$Platform$Cmd$none + ); + }), + view: impl.view + }); + }; + var $author$project$Main$update = F2(function(action, model) { + var m = action.a; + return m; + }); + var $author$project$Main$Replace = function(a) { + return { $: "Replace", a: a }; + }; + var $elm$html$Html$div = _VirtualDom_node("div"); + var $elm$virtual_dom$VirtualDom$Normal = function(a) { + return { $: "Normal", a: a }; + }; + var $elm$virtual_dom$VirtualDom$on = _VirtualDom_on; + var $elm$html$Html$Events$on = F2(function(event, decoder) { + return A2( + $elm$virtual_dom$VirtualDom$on, + event, + $elm$virtual_dom$VirtualDom$Normal(decoder) + ); + }); + var $elm$json$Json$Decode$field = _Json_decodeField; + var $elm$json$Json$Decode$at = F2(function(fields, decoder) { + return A3( + $elm$core$List$foldr, + $elm$json$Json$Decode$field, + decoder, + fields + ); + }); + var $elm$json$Json$Decode$string = _Json_decodeString; + var $elm$html$Html$Events$targetValue = A2( + $elm$json$Json$Decode$at, + _List_fromArray(["target", "value"]), + $elm$json$Json$Decode$string + ); + var $elm$virtual_dom$VirtualDom$text = _VirtualDom_text; + var $elm$html$Html$text = $elm$virtual_dom$VirtualDom$text; + var $elm$html$Html$textarea = _VirtualDom_node("textarea"); + var $author$project$Ast$BinOp$L = { $: "L" }; + var $author$project$Ast$BinOp$R = { $: "R" }; + var $elm$core$Dict$RBEmpty_elm_builtin = { $: "RBEmpty_elm_builtin" }; + var $elm$core$Dict$empty = $elm$core$Dict$RBEmpty_elm_builtin; + var $elm$core$Dict$Black = { $: "Black" }; + var $elm$core$Dict$RBNode_elm_builtin = F5(function(a, b, c, d, e) { + return { $: "RBNode_elm_builtin", a: a, b: b, c: c, d: d, e: e }; + }); + var $elm$core$Dict$Red = { $: "Red" }; + var $elm$core$Dict$balance = F5(function( + color, + key, + value, + left, + right + ) { + if (right.$ === "RBNode_elm_builtin" && right.a.$ === "Red") { + var _v1 = right.a; + var rK = right.b; + var rV = right.c; + var rLeft = right.d; + var rRight = right.e; + if (left.$ === "RBNode_elm_builtin" && left.a.$ === "Red") { + var _v3 = left.a; + var lK = left.b; + var lV = left.c; + var lLeft = left.d; + var lRight = left.e; + return A5( + $elm$core$Dict$RBNode_elm_builtin, + $elm$core$Dict$Red, + key, + value, + A5( + $elm$core$Dict$RBNode_elm_builtin, + $elm$core$Dict$Black, + lK, + lV, + lLeft, + lRight + ), + A5( + $elm$core$Dict$RBNode_elm_builtin, + $elm$core$Dict$Black, + rK, + rV, + rLeft, + rRight + ) + ); + } else { + return A5( + $elm$core$Dict$RBNode_elm_builtin, + color, + rK, + rV, + A5( + $elm$core$Dict$RBNode_elm_builtin, + $elm$core$Dict$Red, + key, + value, + left, + rLeft + ), + rRight + ); + } + } else { + if ( + left.$ === "RBNode_elm_builtin" && + left.a.$ === "Red" && + left.d.$ === "RBNode_elm_builtin" && + left.d.a.$ === "Red" + ) { + var _v5 = left.a; + var lK = left.b; + var lV = left.c; + var _v6 = left.d; + var _v7 = _v6.a; + var llK = _v6.b; + var llV = _v6.c; + var llLeft = _v6.d; + var llRight = _v6.e; + var lRight = left.e; + return A5( + $elm$core$Dict$RBNode_elm_builtin, + $elm$core$Dict$Red, + lK, + lV, + A5( + $elm$core$Dict$RBNode_elm_builtin, + $elm$core$Dict$Black, + llK, + llV, + llLeft, + llRight + ), + A5( + $elm$core$Dict$RBNode_elm_builtin, + $elm$core$Dict$Black, + key, + value, + lRight, + right + ) + ); + } else { + return A5( + $elm$core$Dict$RBNode_elm_builtin, + color, + key, + value, + left, + right + ); + } + } + }); + var $elm$core$Basics$compare = _Utils_compare; + var $elm$core$Dict$insertHelp = F3(function(key, value, dict) { + if (dict.$ === "RBEmpty_elm_builtin") { + return A5( + $elm$core$Dict$RBNode_elm_builtin, + $elm$core$Dict$Red, + key, + value, + $elm$core$Dict$RBEmpty_elm_builtin, + $elm$core$Dict$RBEmpty_elm_builtin + ); + } else { + var nColor = dict.a; + var nKey = dict.b; + var nValue = dict.c; + var nLeft = dict.d; + var nRight = dict.e; + var _v1 = A2($elm$core$Basics$compare, key, nKey); + switch (_v1.$) { + case "LT": + return A5( + $elm$core$Dict$balance, + nColor, + nKey, + nValue, + A3($elm$core$Dict$insertHelp, key, value, nLeft), + nRight + ); + case "EQ": + return A5( + $elm$core$Dict$RBNode_elm_builtin, + nColor, + nKey, + value, + nLeft, + nRight + ); + default: + return A5( + $elm$core$Dict$balance, + nColor, + nKey, + nValue, + nLeft, + A3($elm$core$Dict$insertHelp, key, value, nRight) + ); + } + } + }); + var $elm$core$Dict$insert = F3(function(key, value, dict) { + var _v0 = A3($elm$core$Dict$insertHelp, key, value, dict); + if (_v0.$ === "RBNode_elm_builtin" && _v0.a.$ === "Red") { + var _v1 = _v0.a; + var k = _v0.b; + var v = _v0.c; + var l = _v0.d; + var r = _v0.e; + return A5( + $elm$core$Dict$RBNode_elm_builtin, + $elm$core$Dict$Black, + k, + v, + l, + r + ); + } else { + var x = _v0; + return x; + } + }); + var $author$project$Ast$BinOp$operators = A3( + $elm$core$Dict$insert, + "=", + _Utils_Tuple2($author$project$Ast$BinOp$R, 0), + A3( + $elm$core$Dict$insert, + "|>", + _Utils_Tuple2($author$project$Ast$BinOp$R, 1), + A3( + $elm$core$Dict$insert, + "<|", + _Utils_Tuple2($author$project$Ast$BinOp$R, 1), + A3( + $elm$core$Dict$insert, + ">>", + _Utils_Tuple2($author$project$Ast$BinOp$L, 9), + A3( + $elm$core$Dict$insert, + "<<", + _Utils_Tuple2($author$project$Ast$BinOp$L, 9), + A3( + $elm$core$Dict$insert, + "^", + _Utils_Tuple2($author$project$Ast$BinOp$L, 8), + A3( + $elm$core$Dict$insert, + "rem", + _Utils_Tuple2($author$project$Ast$BinOp$L, 7), + A3( + $elm$core$Dict$insert, + "//", + _Utils_Tuple2($author$project$Ast$BinOp$L, 7), + A3( + $elm$core$Dict$insert, + "%", + _Utils_Tuple2($author$project$Ast$BinOp$L, 7), + A3( + $elm$core$Dict$insert, + "/", + _Utils_Tuple2($author$project$Ast$BinOp$L, 7), + A3( + $elm$core$Dict$insert, + "*", + _Utils_Tuple2($author$project$Ast$BinOp$L, 7), + A3( + $elm$core$Dict$insert, + "-", + _Utils_Tuple2($author$project$Ast$BinOp$L, 6), + A3( + $elm$core$Dict$insert, + "+", + _Utils_Tuple2( + $author$project$Ast$BinOp$L, + 6 + ), + A3( + $elm$core$Dict$insert, + "::", + _Utils_Tuple2( + $author$project$Ast$BinOp$R, + 5 + ), + A3( + $elm$core$Dict$insert, + "++", + _Utils_Tuple2( + $author$project$Ast$BinOp$R, + 5 + ), + A3( + $elm$core$Dict$insert, + "<=", + _Utils_Tuple2( + $author$project$Ast$BinOp$L, + 4 + ), + A3( + $elm$core$Dict$insert, + ">=", + _Utils_Tuple2( + $author$project$Ast$BinOp$L, + 4 + ), + A3( + $elm$core$Dict$insert, + ">", + _Utils_Tuple2( + $author$project$Ast$BinOp$L, + 4 + ), + A3( + $elm$core$Dict$insert, + "<", + _Utils_Tuple2( + $author$project$Ast$BinOp$L, + 4 + ), + A3( + $elm$core$Dict$insert, + "/=", + _Utils_Tuple2( + $author$project$Ast$BinOp$L, + 4 + ), + A3( + $elm$core$Dict$insert, + "==", + _Utils_Tuple2( + $author$project$Ast$BinOp$L, + 4 + ), + A3( + $elm$core$Dict$insert, + "&&", + _Utils_Tuple2( + $author$project$Ast$BinOp$L, + 3 + ), + A3( + $elm$core$Dict$insert, + "||", + _Utils_Tuple2( + $author$project$Ast$BinOp$L, + 2 + ), + $elm$core$Dict$empty + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ); + var $andre_dietrich$parser_combinators$Combine$app = function(_v0) { + var inner = _v0.a; + return inner; + }; + var $andre_dietrich$parser_combinators$Combine$InputStream = F3( + function(data, input, position) { + return { data: data, input: input, position: position }; + } + ); + var $andre_dietrich$parser_combinators$Combine$initStream = function( + s + ) { + return A3( + $andre_dietrich$parser_combinators$Combine$InputStream, + s, + s, + 0 + ); + }; + var $andre_dietrich$parser_combinators$Combine$runParser = F3( + function(p, st, s) { + var _v0 = A3( + $andre_dietrich$parser_combinators$Combine$app, + p, + st, + $andre_dietrich$parser_combinators$Combine$initStream(s) + ); + if (_v0.c.$ === "Ok") { + var state = _v0.a; + var stream = _v0.b; + var res = _v0.c.a; + return $elm$core$Result$Ok(_Utils_Tuple3(state, stream, res)); + } else { + var state = _v0.a; + var stream = _v0.b; + var ms = _v0.c.a; + return $elm$core$Result$Err(_Utils_Tuple3(state, stream, ms)); + } + } + ); + var $andre_dietrich$parser_combinators$Combine$parse = function(p) { + return A2( + $andre_dietrich$parser_combinators$Combine$runParser, + p, + _Utils_Tuple0 + ); + }; + var $andre_dietrich$parser_combinators$Combine$Parser = function(a) { + return { $: "Parser", a: a }; + }; + var $andre_dietrich$parser_combinators$Combine$end = $andre_dietrich$parser_combinators$Combine$Parser( + F2(function(state, stream) { + return stream.input === "" + ? _Utils_Tuple3( + state, + stream, + $elm$core$Result$Ok(_Utils_Tuple0) + ) + : _Utils_Tuple3( + state, + stream, + $elm$core$Result$Err( + _List_fromArray(["expected end of input"]) + ) + ); + }) + ); + var $elm$core$Basics$always = F2(function(a, _v0) { + return a; + }); + var $andre_dietrich$parser_combinators$Combine$andThen = F2(function( + f, + p + ) { + return $andre_dietrich$parser_combinators$Combine$Parser( + F2(function(state, stream) { + var _v0 = A3( + $andre_dietrich$parser_combinators$Combine$app, + p, + state, + stream + ); + if (_v0.c.$ === "Ok") { + var rstate = _v0.a; + var rstream = _v0.b; + var res = _v0.c.a; + return A3( + $andre_dietrich$parser_combinators$Combine$app, + f(res), + rstate, + rstream + ); + } else { + var estate = _v0.a; + var estream = _v0.b; + var ms = _v0.c.a; + return _Utils_Tuple3( + estate, + estream, + $elm$core$Result$Err(ms) + ); } - else - { - domNode.elm_event_node_ref = { tagger: patch.data, parent: patch.eventNode }; + }) + ); + }); + var $pilatch$flip$Flip$flip = F3(function(_function, argB, argA) { + return A2(_function, argA, argB); + }); + var $andre_dietrich$parser_combinators$Combine$bimap = F3(function( + fok, + ferr, + p + ) { + return $andre_dietrich$parser_combinators$Combine$Parser( + F2(function(state, stream) { + var _v0 = A3( + $andre_dietrich$parser_combinators$Combine$app, + p, + state, + stream + ); + if (_v0.c.$ === "Ok") { + var rstate = _v0.a; + var rstream = _v0.b; + var res = _v0.c.a; + return _Utils_Tuple3( + rstate, + rstream, + $elm$core$Result$Ok(fok(res)) + ); + } else { + var estate = _v0.a; + var estream = _v0.b; + var ms = _v0.c.a; + return _Utils_Tuple3( + estate, + estream, + $elm$core$Result$Err(ferr(ms)) + ); } - return domNode; - - case 'p-remove-last': - var i = patch.data; - while (i--) - { - domNode.removeChild(domNode.lastChild); + }) + ); + }); + var $andre_dietrich$parser_combinators$Combine$map = F2(function( + f, + p + ) { + return A3( + $andre_dietrich$parser_combinators$Combine$bimap, + f, + $elm$core$Basics$identity, + p + ); + }); + var $andre_dietrich$parser_combinators$Combine$andMap = F2(function( + rp, + lp + ) { + return A2( + $andre_dietrich$parser_combinators$Combine$andThen, + A2( + $pilatch$flip$Flip$flip, + $andre_dietrich$parser_combinators$Combine$map, + rp + ), + lp + ); + }); + var $andre_dietrich$parser_combinators$Combine$ignore = F2(function( + p1, + p2 + ) { + return A2( + $andre_dietrich$parser_combinators$Combine$andMap, + p1, + A2( + $andre_dietrich$parser_combinators$Combine$map, + $elm$core$Basics$always, + p2 + ) + ); + }); + var $andre_dietrich$parser_combinators$Combine$keep = F2(function( + p1, + p2 + ) { + return A2( + $andre_dietrich$parser_combinators$Combine$andMap, + p1, + A2( + $andre_dietrich$parser_combinators$Combine$map, + $pilatch$flip$Flip$flip($elm$core$Basics$always), + p2 + ) + ); + }); + var $andre_dietrich$parser_combinators$Combine$manyTill = F2(function( + p, + end_ + ) { + var accumulate = F3(function(acc, state, stream) { + accumulate: while (true) { + var _v0 = A3( + $andre_dietrich$parser_combinators$Combine$app, + end_, + state, + stream + ); + if (_v0.c.$ === "Ok") { + var rstate = _v0.a; + var rstream = _v0.b; + return _Utils_Tuple3( + rstate, + rstream, + $elm$core$Result$Ok($elm$core$List$reverse(acc)) + ); + } else { + var estate = _v0.a; + var estream = _v0.b; + var ms = _v0.c.a; + var _v1 = A3( + $andre_dietrich$parser_combinators$Combine$app, + p, + state, + stream + ); + if (_v1.c.$ === "Ok") { + var rstate = _v1.a; + var rstream = _v1.b; + var res = _v1.c.a; + var $temp$acc = A2($elm$core$List$cons, res, acc), + $temp$state = rstate, + $temp$stream = rstream; + acc = $temp$acc; + state = $temp$state; + stream = $temp$stream; + continue accumulate; + } else { + return _Utils_Tuple3( + estate, + estream, + $elm$core$Result$Err(ms) + ); + } } - return domNode; - - case 'p-append': - var newNodes = patch.data; - for (var i = 0; i < newNodes.length; i++) - { - domNode.appendChild(render(newNodes[i], patch.eventNode)); + } + }); + return $andre_dietrich$parser_combinators$Combine$Parser( + accumulate(_List_Nil) + ); + }); + var $andre_dietrich$parser_combinators$Combine$or = F2(function( + lp, + rp + ) { + return $andre_dietrich$parser_combinators$Combine$Parser( + F2(function(state, stream) { + var _v0 = A3( + $andre_dietrich$parser_combinators$Combine$app, + lp, + state, + stream + ); + if (_v0.c.$ === "Ok") { + var res = _v0; + return res; + } else { + var lms = _v0.c.a; + var _v1 = A3( + $andre_dietrich$parser_combinators$Combine$app, + rp, + state, + stream + ); + if (_v1.c.$ === "Ok") { + var res = _v1; + return res; + } else { + var rms = _v1.c.a; + return _Utils_Tuple3( + state, + stream, + $elm$core$Result$Err(_Utils_ap(lms, rms)) + ); + } + } + }) + ); + }); + var $elm$core$Basics$composeR = F3(function(f, g, x) { + return g(f(x)); + }); + var $elm$regex$Regex$Match = F4(function( + match, + index, + number, + submatches + ) { + return { + index: index, + match: match, + number: number, + submatches: submatches + }; + }); + var $elm$regex$Regex$fromStringWith = _Regex_fromStringWith; + var $elm$regex$Regex$fromString = function(string) { + return A2( + $elm$regex$Regex$fromStringWith, + { caseInsensitive: false, multiline: false }, + string + ); + }; + var $elm$regex$Regex$findAtMost = _Regex_findAtMost; + var $elm$regex$Regex$never = _Regex_never; + var $elm$core$Maybe$withDefault = F2(function(_default, maybe) { + if (maybe.$ === "Just") { + var value = maybe.a; + return value; + } else { + return _default; + } + }); + var $andre_dietrich$parser_combinators$Combine$regexer = F5(function( + input, + output, + pat, + state, + stream + ) { + var pattern = A2($elm$core$String$startsWith, "^", pat) + ? pat + : "^" + pat; + var _v0 = A3( + $elm$regex$Regex$findAtMost, + 1, + A2( + $elm$core$Maybe$withDefault, + $elm$regex$Regex$never, + input(pattern) + ), + stream.input + ); + if (_v0.b && !_v0.b.b) { + var match = _v0.a; + var len = $elm$core$String$length(match.match); + var pos = stream.position + len; + var rem = A2($elm$core$String$dropLeft, len, stream.input); + return _Utils_Tuple3( + state, + _Utils_update(stream, { input: rem, position: pos }), + $elm$core$Result$Ok(output(match)) + ); + } else { + return _Utils_Tuple3( + state, + stream, + $elm$core$Result$Err( + _List_fromArray([ + "expected input matching Regexp /" + (pattern + "/") + ]) + ) + ); + } + }); + var $andre_dietrich$parser_combinators$Combine$regex = A2( + $elm$core$Basics$composeR, + A2( + $andre_dietrich$parser_combinators$Combine$regexer, + $elm$regex$Regex$fromString, + function($) { + return $.match; + } + ), + $andre_dietrich$parser_combinators$Combine$Parser + ); + var $author$project$Ast$Helpers$spaces = $andre_dietrich$parser_combinators$Combine$regex( + "[ \\t]*" + ); + var $andre_dietrich$parser_combinators$Combine$emptyErr = $andre_dietrich$parser_combinators$Combine$Parser( + F2(function(state, stream) { + return _Utils_Tuple3( + state, + stream, + $elm$core$Result$Err(_List_Nil) + ); + }) + ); + var $andre_dietrich$parser_combinators$Combine$choice = function(xs) { + return A3( + $elm$core$List$foldr, + $andre_dietrich$parser_combinators$Combine$or, + $andre_dietrich$parser_combinators$Combine$emptyErr, + xs + ); + }; + var $author$project$Ast$Statement$Comment = function(a) { + return { $: "Comment", a: a }; + }; + var $andre_dietrich$parser_combinators$Combine$mapError = $andre_dietrich$parser_combinators$Combine$bimap( + $elm$core$Basics$identity + ); + var $andre_dietrich$parser_combinators$Combine$onerror = F2(function( + m, + p + ) { + return A2( + $andre_dietrich$parser_combinators$Combine$mapError, + $elm$core$Basics$always(_List_fromArray([m])), + p + ); + }); + var $andre_dietrich$parser_combinators$Combine$primitive = $andre_dietrich$parser_combinators$Combine$Parser; + var $andre_dietrich$parser_combinators$Combine$Char$satisfy = function( + pred + ) { + return $andre_dietrich$parser_combinators$Combine$primitive( + F2(function(state, stream) { + var message = "could not satisfy predicate"; + var _v0 = $elm$core$String$uncons(stream.input); + if (_v0.$ === "Just") { + var _v1 = _v0.a; + var h = _v1.a; + var rest = _v1.b; + return pred(h) + ? _Utils_Tuple3( + state, + _Utils_update(stream, { + input: rest, + position: stream.position + 1 + }), + $elm$core$Result$Ok(h) + ) + : _Utils_Tuple3( + state, + stream, + $elm$core$Result$Err(_List_fromArray([message])) + ); + } else { + return _Utils_Tuple3( + state, + stream, + $elm$core$Result$Err(_List_fromArray([message])) + ); + } + }) + ); + }; + var $andre_dietrich$parser_combinators$Combine$Char$anyChar = A2( + $andre_dietrich$parser_combinators$Combine$onerror, + "expected any character", + $andre_dietrich$parser_combinators$Combine$Char$satisfy( + $elm$core$Basics$always(true) + ) + ); + var $elm$core$Basics$composeL = F3(function(g, f, x) { + return g(f(x)); + }); + var $elm$core$String$fromList = _String_fromList; + var $andre_dietrich$parser_combinators$Combine$string = function(s) { + return $andre_dietrich$parser_combinators$Combine$Parser( + F2(function(state, stream) { + if (A2($elm$core$String$startsWith, s, stream.input)) { + var len = $elm$core$String$length(s); + var pos = stream.position + len; + var rem = A2($elm$core$String$dropLeft, len, stream.input); + return _Utils_Tuple3( + state, + _Utils_update(stream, { input: rem, position: pos }), + $elm$core$Result$Ok(s) + ); + } else { + return _Utils_Tuple3( + state, + stream, + $elm$core$Result$Err( + _List_fromArray(['expected "' + (s + '"')]) + ) + ); + } + }) + ); + }; + var $author$project$Ast$Common$addMeta = F3(function(l, c, e) { + return _Utils_Tuple2(e, { column: c, line: l }); + }); + var $andre_dietrich$parser_combinators$Combine$ParseLocation = F3( + function(source, line, column) { + return { column: column, line: line, source: source }; + } + ); + var $andre_dietrich$parser_combinators$Combine$currentLocation = function( + stream + ) { + var find = F3(function(position, currentLine_, lines) { + find: while (true) { + if (!lines.b) { + return A3( + $andre_dietrich$parser_combinators$Combine$ParseLocation, + "", + currentLine_, + position + ); + } else { + var line = lines.a; + var rest = lines.b; + var length = $elm$core$String$length(line); + var lengthPlusNL = length + 1; + if (_Utils_eq(position, length)) { + return A3( + $andre_dietrich$parser_combinators$Combine$ParseLocation, + line, + currentLine_, + position + ); + } else { + if (_Utils_cmp(position, length) > 0) { + var $temp$position = position - lengthPlusNL, + $temp$currentLine_ = currentLine_ + 1, + $temp$lines = rest; + position = $temp$position; + currentLine_ = $temp$currentLine_; + lines = $temp$lines; + continue find; + } else { + return A3( + $andre_dietrich$parser_combinators$Combine$ParseLocation, + line, + currentLine_, + position + ); + } + } + } + } + }); + return A3( + find, + stream.position, + 0, + A2($elm$core$String$split, "\n", stream.data) + ); + }; + var $andre_dietrich$parser_combinators$Combine$withLocation = function( + f + ) { + return $andre_dietrich$parser_combinators$Combine$Parser( + F2(function(state, stream) { + return A3( + $andre_dietrich$parser_combinators$Combine$app, + f( + $andre_dietrich$parser_combinators$Combine$currentLocation( + stream + ) + ), + state, + stream + ); + }) + ); + }; + var $author$project$Ast$Common$withMeta = function(p) { + return $andre_dietrich$parser_combinators$Combine$withLocation( + function(a) { + return A2( + $andre_dietrich$parser_combinators$Combine$map, + function(x) { + return A3( + $author$project$Ast$Common$addMeta, + a.line, + a.column, + x + ); + }, + p + ); + } + ); + }; + var $author$project$Ast$Statement$multiLineComment = $author$project$Ast$Common$withMeta( + A2( + $andre_dietrich$parser_combinators$Combine$map, + A2( + $elm$core$Basics$composeL, + $author$project$Ast$Statement$Comment, + $elm$core$String$fromList + ), + A2( + $andre_dietrich$parser_combinators$Combine$keep, + A2( + $andre_dietrich$parser_combinators$Combine$manyTill, + $andre_dietrich$parser_combinators$Combine$Char$anyChar, + $andre_dietrich$parser_combinators$Combine$string("-}") + ), + $andre_dietrich$parser_combinators$Combine$string("{-") + ) + ) + ); + var $andre_dietrich$parser_combinators$Combine$whitespace = A2( + $andre_dietrich$parser_combinators$Combine$onerror, + "optional whitespace", + $andre_dietrich$parser_combinators$Combine$regex("\\s*") + ); + var $author$project$Ast$Statement$singleLineComment = $author$project$Ast$Common$withMeta( + A2( + $andre_dietrich$parser_combinators$Combine$map, + $author$project$Ast$Statement$Comment, + A2( + $andre_dietrich$parser_combinators$Combine$ignore, + $andre_dietrich$parser_combinators$Combine$whitespace, + A2( + $andre_dietrich$parser_combinators$Combine$keep, + $andre_dietrich$parser_combinators$Combine$regex(".*"), + $andre_dietrich$parser_combinators$Combine$string("--") + ) + ) + ) + ); + var $author$project$Ast$Statement$comment = A2( + $andre_dietrich$parser_combinators$Combine$or, + $author$project$Ast$Statement$singleLineComment, + $author$project$Ast$Statement$multiLineComment + ); + var $author$project$Ast$Statement$EffectModuleDeclaration = F3( + function(a, b, c) { + return { $: "EffectModuleDeclaration", a: a, b: b, c: c }; + } + ); + var $andre_dietrich$parser_combinators$Combine$between = F3(function( + lp, + rp, + p + ) { + return A2( + $andre_dietrich$parser_combinators$Combine$ignore, + rp, + A2($andre_dietrich$parser_combinators$Combine$keep, p, lp) + ); + }); + var $andre_dietrich$parser_combinators$Combine$braces = A2( + $andre_dietrich$parser_combinators$Combine$between, + $andre_dietrich$parser_combinators$Combine$string("{"), + $andre_dietrich$parser_combinators$Combine$string("}") + ); + var $author$project$Ast$Helpers$between_ = function(p) { + return A2($andre_dietrich$parser_combinators$Combine$between, p, p); + }; + var $andre_dietrich$parser_combinators$Combine$many = function(p) { + var accumulate = F3(function(acc, state, stream) { + accumulate: while (true) { + var _v0 = A3( + $andre_dietrich$parser_combinators$Combine$app, + p, + state, + stream + ); + if (_v0.c.$ === "Ok") { + var rstate = _v0.a; + var rstream = _v0.b; + var res = _v0.c.a; + if (_Utils_eq(stream, rstream)) { + return _Utils_Tuple3( + rstate, + rstream, + $elm$core$List$reverse(acc) + ); + } else { + var $temp$acc = A2($elm$core$List$cons, res, acc), + $temp$state = rstate, + $temp$stream = rstream; + acc = $temp$acc; + state = $temp$state; + stream = $temp$stream; + continue accumulate; + } + } else { + return _Utils_Tuple3( + state, + stream, + $elm$core$List$reverse(acc) + ); } - return domNode; - - case 'p-remove': - var data = patch.data; - if (typeof data === 'undefined') - { - domNode.parentNode.removeChild(domNode); - return domNode; + } + }); + return $andre_dietrich$parser_combinators$Combine$Parser( + F2(function(state, stream) { + var _v1 = A3(accumulate, _List_Nil, state, stream); + var rstate = _v1.a; + var rstream = _v1.b; + var res = _v1.c; + return _Utils_Tuple3(rstate, rstream, $elm$core$Result$Ok(res)); + }) + ); + }; + var $andre_dietrich$parser_combinators$Combine$sepBy1 = F2(function( + sep, + p + ) { + return A2( + $andre_dietrich$parser_combinators$Combine$andMap, + $andre_dietrich$parser_combinators$Combine$many( + A2($andre_dietrich$parser_combinators$Combine$keep, p, sep) + ), + A2( + $andre_dietrich$parser_combinators$Combine$map, + $elm$core$List$cons, + p + ) + ); + }); + var $author$project$Ast$Helpers$commaSeparated = function(p) { + return A2( + $andre_dietrich$parser_combinators$Combine$sepBy1, + $andre_dietrich$parser_combinators$Combine$string(","), + A2( + $author$project$Ast$Helpers$between_, + $andre_dietrich$parser_combinators$Combine$whitespace, + p + ) + ); + }; + var $author$project$Ast$Statement$AllExport = { $: "AllExport" }; + var $andre_dietrich$parser_combinators$Combine$onsuccess = function( + res + ) { + return $andre_dietrich$parser_combinators$Combine$map( + $elm$core$Basics$always(res) + ); + }; + var $author$project$Ast$Helpers$symbol = function(k) { + return A2( + $author$project$Ast$Helpers$between_, + $andre_dietrich$parser_combinators$Combine$whitespace, + $andre_dietrich$parser_combinators$Combine$string(k) + ); + }; + var $author$project$Ast$Statement$allExport = A2( + $andre_dietrich$parser_combinators$Combine$onsuccess, + $author$project$Ast$Statement$AllExport, + $author$project$Ast$Helpers$symbol("..") + ); + var $andre_dietrich$parser_combinators$Combine$parens = A2( + $andre_dietrich$parser_combinators$Combine$between, + $andre_dietrich$parser_combinators$Combine$string("("), + $andre_dietrich$parser_combinators$Combine$string(")") + ); + var $author$project$Ast$Statement$SubsetExport = function(a) { + return { $: "SubsetExport", a: a }; + }; + var $author$project$Ast$Statement$FunctionExport = function(a) { + return { $: "FunctionExport", a: a }; + }; + var $andre_dietrich$parser_combinators$Combine$fail = function(m) { + return $andre_dietrich$parser_combinators$Combine$Parser( + F2(function(state, stream) { + return _Utils_Tuple3( + state, + stream, + $elm$core$Result$Err(_List_fromArray([m])) + ); + }) + ); + }; + var $andre_dietrich$parser_combinators$Combine$Char$lower = A2( + $andre_dietrich$parser_combinators$Combine$onerror, + "expected a lowercase character", + $andre_dietrich$parser_combinators$Combine$Char$satisfy( + $elm$core$Char$isLower + ) + ); + var $elm$core$List$any = F2(function(isOkay, list) { + any: while (true) { + if (!list.b) { + return false; + } else { + var x = list.a; + var xs = list.b; + if (isOkay(x)) { + return true; + } else { + var $temp$isOkay = isOkay, + $temp$list = xs; + isOkay = $temp$isOkay; + list = $temp$list; + continue any; } - var entry = data.entry; - if (typeof entry.index !== 'undefined') - { - domNode.parentNode.removeChild(domNode); + } + } + }); + var $elm$core$List$member = F2(function(x, xs) { + return A2( + $elm$core$List$any, + function(a) { + return _Utils_eq(a, x); + }, + xs + ); + }); + var $elm$core$String$cons = _String_cons; + var $author$project$Ast$Helpers$name = function(p) { + return A2( + $andre_dietrich$parser_combinators$Combine$andMap, + $andre_dietrich$parser_combinators$Combine$regex( + "[a-zA-Z0-9-_]*" + ), + A2( + $andre_dietrich$parser_combinators$Combine$map, + $elm$core$String$cons, + p + ) + ); + }; + var $author$project$Ast$Helpers$reserved = _List_fromArray([ + "module", + "where", + "import", + "as", + "exposing", + "type", + "alias", + "port", + "if", + "then", + "else", + "let", + "in", + "case", + "of" + ]); + var $andre_dietrich$parser_combinators$Combine$succeed = function( + res + ) { + return $andre_dietrich$parser_combinators$Combine$Parser( + F2(function(state, stream) { + return _Utils_Tuple3(state, stream, $elm$core$Result$Ok(res)); + }) + ); + }; + var $author$project$Ast$Helpers$varName = A2( + $andre_dietrich$parser_combinators$Combine$andThen, + function(n) { + return A2( + $elm$core$List$member, + n, + $author$project$Ast$Helpers$reserved + ) + ? $andre_dietrich$parser_combinators$Combine$fail( + "name '" + (n + "' is reserved") + ) + : $andre_dietrich$parser_combinators$Combine$succeed(n); + }, + $author$project$Ast$Helpers$name( + $andre_dietrich$parser_combinators$Combine$Char$lower + ) + ); + var $author$project$Ast$Helpers$wild = $andre_dietrich$parser_combinators$Combine$string( + "_" + ); + var $author$project$Ast$Helpers$loName = A2( + $andre_dietrich$parser_combinators$Combine$or, + $author$project$Ast$Helpers$wild, + $author$project$Ast$Helpers$varName + ); + var $author$project$Ast$Helpers$functionName = $author$project$Ast$Helpers$loName; + var $andre_dietrich$parser_combinators$Combine$lazy = function(t) { + return A2( + $andre_dietrich$parser_combinators$Combine$andThen, + t, + $andre_dietrich$parser_combinators$Combine$succeed(_Utils_Tuple0) + ); + }; + var $author$project$Ast$Helpers$reservedOperators = _List_fromArray([ + "=", + ".", + "..", + "->", + "--", + "|", + ":" + ]); + var $author$project$Ast$Helpers$operator = $andre_dietrich$parser_combinators$Combine$lazy( + function(_v0) { + return A2( + $andre_dietrich$parser_combinators$Combine$andThen, + function(n) { + return A2( + $elm$core$List$member, + n, + $author$project$Ast$Helpers$reservedOperators + ) + ? $andre_dietrich$parser_combinators$Combine$fail( + "operator '" + (n + "' is reserved") + ) + : $andre_dietrich$parser_combinators$Combine$succeed(n); + }, + $andre_dietrich$parser_combinators$Combine$regex( + "[+\\-\\/*=.$<>:&|^?%#@~!]+|\u008As\u0008" + ) + ); + } + ); + var $author$project$Ast$Statement$functionExport = A2( + $andre_dietrich$parser_combinators$Combine$map, + $author$project$Ast$Statement$FunctionExport, + $andre_dietrich$parser_combinators$Combine$choice( + _List_fromArray([ + $author$project$Ast$Helpers$functionName, + $andre_dietrich$parser_combinators$Combine$parens( + $author$project$Ast$Helpers$operator + ) + ]) + ) + ); + var $author$project$Ast$Statement$TypeExport = F2(function(a, b) { + return { $: "TypeExport", a: a, b: b }; + }); + var $andre_dietrich$parser_combinators$Combine$Char$upper = A2( + $andre_dietrich$parser_combinators$Combine$onerror, + "expected an uppercase character", + $andre_dietrich$parser_combinators$Combine$Char$satisfy( + $elm$core$Char$isUpper + ) + ); + var $author$project$Ast$Helpers$upName = $author$project$Ast$Helpers$name( + $andre_dietrich$parser_combinators$Combine$Char$upper + ); + var $author$project$Ast$Statement$constructorSubsetExports = A2( + $andre_dietrich$parser_combinators$Combine$map, + $author$project$Ast$Statement$SubsetExport, + $author$project$Ast$Helpers$commaSeparated( + A2( + $andre_dietrich$parser_combinators$Combine$map, + $author$project$Ast$Statement$FunctionExport, + $author$project$Ast$Helpers$upName + ) + ) + ); + var $andre_dietrich$parser_combinators$Combine$maybe = function(p) { + return $andre_dietrich$parser_combinators$Combine$Parser( + F2(function(state, stream) { + var _v0 = A3( + $andre_dietrich$parser_combinators$Combine$app, + p, + state, + stream + ); + if (_v0.c.$ === "Ok") { + var rstate = _v0.a; + var rstream = _v0.b; + var res = _v0.c.a; + return _Utils_Tuple3( + rstate, + rstream, + $elm$core$Result$Ok($elm$core$Maybe$Just(res)) + ); + } else { + return _Utils_Tuple3( + state, + stream, + $elm$core$Result$Ok($elm$core$Maybe$Nothing) + ); } - entry.data = applyPatchesHelp(domNode, data.patches); - return domNode; - - case 'p-reorder': - return applyPatchReorder(domNode, patch); - - case 'p-custom': - var impl = patch.data; - return impl.applyPatch(domNode, impl.data); - - default: - throw new Error('Ran into an unknown patch!'); - } -} - - -function applyPatchRedraw(domNode, vNode, eventNode) -{ - var parentNode = domNode.parentNode; - var newNode = render(vNode, eventNode); - - if (typeof newNode.elm_event_node_ref === 'undefined') - { - newNode.elm_event_node_ref = domNode.elm_event_node_ref; - } - - if (parentNode && newNode !== domNode) - { - parentNode.replaceChild(newNode, domNode); - } - return newNode; -} - - -function applyPatchReorder(domNode, patch) -{ - var data = patch.data; - - // remove end inserts - var frag = applyPatchReorderEndInsertsHelp(data.endInserts, patch); - - // removals - domNode = applyPatchesHelp(domNode, data.patches); - - // inserts - var inserts = data.inserts; - for (var i = 0; i < inserts.length; i++) - { - var insert = inserts[i]; - var entry = insert.entry; - var node = entry.tag === 'move' - ? entry.data - : render(entry.vnode, patch.eventNode); - domNode.insertBefore(node, domNode.childNodes[insert.index]); - } - - // add end inserts - if (typeof frag !== 'undefined') - { - domNode.appendChild(frag); - } - - return domNode; -} - - -function applyPatchReorderEndInsertsHelp(endInserts, patch) -{ - if (typeof endInserts === 'undefined') - { - return; - } - - var frag = localDoc.createDocumentFragment(); - for (var i = 0; i < endInserts.length; i++) - { - var insert = endInserts[i]; - var entry = insert.entry; - frag.appendChild(entry.tag === 'move' - ? entry.data - : render(entry.vnode, patch.eventNode) + }) ); - } - return frag; -} - - -// PROGRAMS - -var program = makeProgram(checkNoFlags); -var programWithFlags = makeProgram(checkYesFlags); - -function makeProgram(flagChecker) -{ - return F2(function(debugWrap, impl) - { - return function(flagDecoder) - { - return function(object, moduleName, debugMetadata) - { - var checker = flagChecker(flagDecoder, moduleName); - if (typeof debugMetadata === 'undefined') - { - normalSetup(impl, object, moduleName, checker); - } - else - { - debugSetup(A2(debugWrap, debugMetadata, impl), object, moduleName, checker); - } - }; + }; + var $author$project$Ast$Statement$constructorExports = $andre_dietrich$parser_combinators$Combine$maybe( + $andre_dietrich$parser_combinators$Combine$parens( + $andre_dietrich$parser_combinators$Combine$choice( + _List_fromArray([ + $author$project$Ast$Statement$allExport, + $author$project$Ast$Statement$constructorSubsetExports + ]) + ) + ) + ); + var $author$project$Ast$Statement$typeExport = A2( + $andre_dietrich$parser_combinators$Combine$andMap, + $author$project$Ast$Statement$constructorExports, + A2( + $andre_dietrich$parser_combinators$Combine$map, + $author$project$Ast$Statement$TypeExport, + A2( + $andre_dietrich$parser_combinators$Combine$ignore, + $author$project$Ast$Helpers$spaces, + $author$project$Ast$Helpers$upName + ) + ) + ); + var $author$project$Ast$Statement$subsetExport = A2( + $andre_dietrich$parser_combinators$Combine$map, + $author$project$Ast$Statement$SubsetExport, + $author$project$Ast$Helpers$commaSeparated( + A2( + $andre_dietrich$parser_combinators$Combine$or, + $author$project$Ast$Statement$typeExport, + $author$project$Ast$Statement$functionExport + ) + ) + ); + var $author$project$Ast$Statement$exports = $andre_dietrich$parser_combinators$Combine$parens( + $andre_dietrich$parser_combinators$Combine$choice( + _List_fromArray([ + $author$project$Ast$Statement$allExport, + $author$project$Ast$Statement$subsetExport + ]) + ) + ); + var $author$project$Ast$Helpers$spaces_ = $andre_dietrich$parser_combinators$Combine$regex( + "[ \\t]+" + ); + var $author$project$Ast$Helpers$initialSymbol = function(k) { + return A2( + $andre_dietrich$parser_combinators$Combine$ignore, + $author$project$Ast$Helpers$spaces_, + $andre_dietrich$parser_combinators$Combine$string(k) + ); + }; + var $author$project$Ast$Helpers$moduleName = A2( + $author$project$Ast$Helpers$between_, + $author$project$Ast$Helpers$spaces, + A2( + $andre_dietrich$parser_combinators$Combine$sepBy1, + $andre_dietrich$parser_combinators$Combine$string("."), + $author$project$Ast$Helpers$upName + ) + ); + var $elm$core$Tuple$pair = F2(function(a, b) { + return _Utils_Tuple2(a, b); + }); + var $author$project$Ast$Statement$effectModuleDeclaration = $author$project$Ast$Common$withMeta( + A2( + $andre_dietrich$parser_combinators$Combine$andMap, + A2( + $andre_dietrich$parser_combinators$Combine$keep, + $author$project$Ast$Statement$exports, + $author$project$Ast$Helpers$symbol("exposing") + ), + A2( + $andre_dietrich$parser_combinators$Combine$andMap, + A2( + $andre_dietrich$parser_combinators$Combine$keep, + $andre_dietrich$parser_combinators$Combine$braces( + $author$project$Ast$Helpers$commaSeparated( + A2( + $andre_dietrich$parser_combinators$Combine$andMap, + A2( + $andre_dietrich$parser_combinators$Combine$keep, + $author$project$Ast$Helpers$upName, + $author$project$Ast$Helpers$symbol("=") + ), + A2( + $andre_dietrich$parser_combinators$Combine$map, + $elm$core$Tuple$pair, + $author$project$Ast$Helpers$loName + ) + ) + ) + ), + $author$project$Ast$Helpers$symbol("where") + ), + A2( + $andre_dietrich$parser_combinators$Combine$map, + $author$project$Ast$Statement$EffectModuleDeclaration, + A2( + $andre_dietrich$parser_combinators$Combine$keep, + $author$project$Ast$Helpers$moduleName, + A2( + $andre_dietrich$parser_combinators$Combine$keep, + $author$project$Ast$Helpers$symbol("module"), + $author$project$Ast$Helpers$initialSymbol("effect") + ) + ) + ) + ) + ) + ); + var $author$project$Ast$Statement$FunctionDeclaration = F2(function( + a, + b + ) { + return { $: "FunctionDeclaration", a: a, b: b }; + }); + var $author$project$Ast$Expression$Application = F2(function(a, b) { + return { $: "Application", a: a, b: b }; + }); + var $author$project$Ast$Expression$Case = F2(function(a, b) { + return { $: "Case", a: a, b: b }; + }); + var $author$project$Ast$Expression$Cont = function(a) { + return { $: "Cont", a: a }; + }; + var $author$project$Ast$Expression$If = F3(function(a, b, c) { + return { $: "If", a: a, b: b, c: c }; + }); + var $author$project$Ast$Expression$Lambda = F2(function(a, b) { + return { $: "Lambda", a: a, b: b }; + }); + var $author$project$Ast$Expression$Let = F2(function(a, b) { + return { $: "Let", a: a, b: b }; + }); + var $author$project$Ast$Expression$List = function(a) { + return { $: "List", a: a }; + }; + var $author$project$Ast$Expression$Record = function(a) { + return { $: "Record", a: a }; + }; + var $author$project$Ast$Expression$RecordUpdate = F2(function(a, b) { + return { $: "RecordUpdate", a: a, b: b }; + }); + var $author$project$Ast$Expression$Stop = function(a) { + return { $: "Stop", a: a }; + }; + var $author$project$Ast$Expression$Tuple = function(a) { + return { $: "Tuple", a: a }; + }; + var $author$project$Ast$Expression$Access = F2(function(a, b) { + return { $: "Access", a: a, b: b }; + }); + var $andre_dietrich$parser_combinators$Combine$many1 = function(p) { + return A2( + $andre_dietrich$parser_combinators$Combine$andMap, + $andre_dietrich$parser_combinators$Combine$many(p), + A2( + $andre_dietrich$parser_combinators$Combine$map, + $elm$core$List$cons, + p + ) + ); + }; + var $author$project$Ast$Expression$Variable = function(a) { + return { $: "Variable", a: a }; + }; + var $author$project$Ast$Helpers$emptyTuple = $andre_dietrich$parser_combinators$Combine$string( + "()" + ); + var $author$project$Ast$Expression$variable = $author$project$Ast$Common$withMeta( + A2( + $andre_dietrich$parser_combinators$Combine$map, + $author$project$Ast$Expression$Variable, + $andre_dietrich$parser_combinators$Combine$choice( + _List_fromArray([ + $author$project$Ast$Helpers$loName, + $andre_dietrich$parser_combinators$Combine$parens( + $author$project$Ast$Helpers$operator + ), + $andre_dietrich$parser_combinators$Combine$parens( + $andre_dietrich$parser_combinators$Combine$regex(",+") + ), + $author$project$Ast$Helpers$emptyTuple + ]) + ) + ) + ); + var $author$project$Ast$Expression$access = $author$project$Ast$Common$withMeta( + A2( + $andre_dietrich$parser_combinators$Combine$andMap, + $andre_dietrich$parser_combinators$Combine$many1( + A2( + $andre_dietrich$parser_combinators$Combine$keep, + $author$project$Ast$Common$withMeta( + $author$project$Ast$Helpers$varName + ), + $andre_dietrich$parser_combinators$Combine$string(".") + ) + ), + A2( + $andre_dietrich$parser_combinators$Combine$map, + $author$project$Ast$Expression$Access, + $author$project$Ast$Expression$variable + ) + ) + ); + var $author$project$Ast$Expression$AccessFunction = function(a) { + return { $: "AccessFunction", a: a }; + }; + var $author$project$Ast$Expression$accessFunction = $author$project$Ast$Common$withMeta( + A2( + $andre_dietrich$parser_combinators$Combine$map, + $author$project$Ast$Expression$AccessFunction, + A2( + $andre_dietrich$parser_combinators$Combine$keep, + $author$project$Ast$Helpers$loName, + $andre_dietrich$parser_combinators$Combine$string(".") + ) + ) + ); + var $author$project$Ast$Pattern$applicationToList = function( + application + ) { + if (application.a.$ === "PApplication") { + var _v1 = application.a; + var left = _v1.a; + var right = _v1.b; + return _Utils_ap( + $author$project$Ast$Pattern$applicationToList(left), + _List_fromArray([right]) + ); + } else { + var other = application; + return _List_fromArray([other]); + } + }; + var $andre_dietrich$parser_combinators$Combine$chainl = F2(function( + op, + p + ) { + var accumulate = function(x) { + return A2( + $andre_dietrich$parser_combinators$Combine$or, + A2( + $andre_dietrich$parser_combinators$Combine$andThen, + function(f) { + return A2( + $andre_dietrich$parser_combinators$Combine$andThen, + function(y) { + return accumulate(A2(f, x, y)); + }, + p + ); + }, + op + ), + $andre_dietrich$parser_combinators$Combine$succeed(x) + ); }; - }); -} - -function staticProgram(vNode) -{ - var nothing = _elm_lang$core$Native_Utils.Tuple2( - _elm_lang$core$Native_Utils.Tuple0, - _elm_lang$core$Platform_Cmd$none - ); - return A2(program, _elm_lang$virtual_dom$VirtualDom_Debug$wrap, { - init: nothing, - view: function() { return vNode; }, - update: F2(function() { return nothing; }), - subscriptions: function() { return _elm_lang$core$Platform_Sub$none; } - })(); -} - - -// FLAG CHECKERS - -function checkNoFlags(flagDecoder, moduleName) -{ - return function(init, flags, domNode) - { - if (typeof flags === 'undefined') - { - return init; - } - - var errorMessage = - 'The `' + moduleName + '` module does not need flags.\n' - + 'Initialize it with no arguments and you should be all set!'; - - crash(errorMessage, domNode); - }; -} - -function checkYesFlags(flagDecoder, moduleName) -{ - return function(init, flags, domNode) - { - if (typeof flagDecoder === 'undefined') - { - var errorMessage = - 'Are you trying to sneak a Never value into Elm? Trickster!\n' - + 'It looks like ' + moduleName + '.main is defined with `programWithFlags` but has type `Program Never`.\n' - + 'Use `program` instead if you do not want flags.' - - crash(errorMessage, domNode); + return A2( + $andre_dietrich$parser_combinators$Combine$andThen, + accumulate, + p + ); + }); + var $author$project$Ast$Common$Character = function(a) { + return { $: "Character", a: a }; + }; + var $author$project$Ast$Expression$Literal = function(a) { + return { $: "Literal", a: a }; + }; + var $elm$core$String$fromChar = function(_char) { + return A2($elm$core$String$cons, _char, ""); + }; + var $elm$core$Char$fromCode = _Char_fromCode; + var $elm$core$Basics$pow = _Basics_pow; + var $rtfeldman$elm_hex$Hex$fromStringHelp = F3(function( + position, + chars, + accumulated + ) { + fromStringHelp: while (true) { + if (!chars.b) { + return $elm$core$Result$Ok(accumulated); + } else { + var _char = chars.a; + var rest = chars.b; + switch (_char.valueOf()) { + case "0": + var $temp$position = position - 1, + $temp$chars = rest, + $temp$accumulated = accumulated; + position = $temp$position; + chars = $temp$chars; + accumulated = $temp$accumulated; + continue fromStringHelp; + case "1": + var $temp$position = position - 1, + $temp$chars = rest, + $temp$accumulated = + accumulated + A2($elm$core$Basics$pow, 16, position); + position = $temp$position; + chars = $temp$chars; + accumulated = $temp$accumulated; + continue fromStringHelp; + case "2": + var $temp$position = position - 1, + $temp$chars = rest, + $temp$accumulated = + accumulated + + 2 * A2($elm$core$Basics$pow, 16, position); + position = $temp$position; + chars = $temp$chars; + accumulated = $temp$accumulated; + continue fromStringHelp; + case "3": + var $temp$position = position - 1, + $temp$chars = rest, + $temp$accumulated = + accumulated + + 3 * A2($elm$core$Basics$pow, 16, position); + position = $temp$position; + chars = $temp$chars; + accumulated = $temp$accumulated; + continue fromStringHelp; + case "4": + var $temp$position = position - 1, + $temp$chars = rest, + $temp$accumulated = + accumulated + + 4 * A2($elm$core$Basics$pow, 16, position); + position = $temp$position; + chars = $temp$chars; + accumulated = $temp$accumulated; + continue fromStringHelp; + case "5": + var $temp$position = position - 1, + $temp$chars = rest, + $temp$accumulated = + accumulated + + 5 * A2($elm$core$Basics$pow, 16, position); + position = $temp$position; + chars = $temp$chars; + accumulated = $temp$accumulated; + continue fromStringHelp; + case "6": + var $temp$position = position - 1, + $temp$chars = rest, + $temp$accumulated = + accumulated + + 6 * A2($elm$core$Basics$pow, 16, position); + position = $temp$position; + chars = $temp$chars; + accumulated = $temp$accumulated; + continue fromStringHelp; + case "7": + var $temp$position = position - 1, + $temp$chars = rest, + $temp$accumulated = + accumulated + + 7 * A2($elm$core$Basics$pow, 16, position); + position = $temp$position; + chars = $temp$chars; + accumulated = $temp$accumulated; + continue fromStringHelp; + case "8": + var $temp$position = position - 1, + $temp$chars = rest, + $temp$accumulated = + accumulated + + 8 * A2($elm$core$Basics$pow, 16, position); + position = $temp$position; + chars = $temp$chars; + accumulated = $temp$accumulated; + continue fromStringHelp; + case "9": + var $temp$position = position - 1, + $temp$chars = rest, + $temp$accumulated = + accumulated + + 9 * A2($elm$core$Basics$pow, 16, position); + position = $temp$position; + chars = $temp$chars; + accumulated = $temp$accumulated; + continue fromStringHelp; + case "a": + var $temp$position = position - 1, + $temp$chars = rest, + $temp$accumulated = + accumulated + + 10 * A2($elm$core$Basics$pow, 16, position); + position = $temp$position; + chars = $temp$chars; + accumulated = $temp$accumulated; + continue fromStringHelp; + case "b": + var $temp$position = position - 1, + $temp$chars = rest, + $temp$accumulated = + accumulated + + 11 * A2($elm$core$Basics$pow, 16, position); + position = $temp$position; + chars = $temp$chars; + accumulated = $temp$accumulated; + continue fromStringHelp; + case "c": + var $temp$position = position - 1, + $temp$chars = rest, + $temp$accumulated = + accumulated + + 12 * A2($elm$core$Basics$pow, 16, position); + position = $temp$position; + chars = $temp$chars; + accumulated = $temp$accumulated; + continue fromStringHelp; + case "d": + var $temp$position = position - 1, + $temp$chars = rest, + $temp$accumulated = + accumulated + + 13 * A2($elm$core$Basics$pow, 16, position); + position = $temp$position; + chars = $temp$chars; + accumulated = $temp$accumulated; + continue fromStringHelp; + case "e": + var $temp$position = position - 1, + $temp$chars = rest, + $temp$accumulated = + accumulated + + 14 * A2($elm$core$Basics$pow, 16, position); + position = $temp$position; + chars = $temp$chars; + accumulated = $temp$accumulated; + continue fromStringHelp; + case "f": + var $temp$position = position - 1, + $temp$chars = rest, + $temp$accumulated = + accumulated + + 15 * A2($elm$core$Basics$pow, 16, position); + position = $temp$position; + chars = $temp$chars; + accumulated = $temp$accumulated; + continue fromStringHelp; + default: + var nonHex = _char; + return $elm$core$Result$Err( + $elm$core$String$fromChar(nonHex) + + " is not a valid hexadecimal character." + ); + } + } } - - var result = A2(_elm_lang$core$Native_Json.run, flagDecoder, flags); - if (result.ctor === 'Ok') - { - return init(result._0); + }); + var $elm$core$Result$map = F2(function(func, ra) { + if (ra.$ === "Ok") { + var a = ra.a; + return $elm$core$Result$Ok(func(a)); + } else { + var e = ra.a; + return $elm$core$Result$Err(e); + } + }); + var $elm$core$Result$mapError = F2(function(f, result) { + if (result.$ === "Ok") { + var v = result.a; + return $elm$core$Result$Ok(v); + } else { + var e = result.a; + return $elm$core$Result$Err(f(e)); + } + }); + var $elm$core$Basics$negate = function(n) { + return -n; + }; + var $elm$core$List$tail = function(list) { + if (list.b) { + var x = list.a; + var xs = list.b; + return $elm$core$Maybe$Just(xs); + } else { + return $elm$core$Maybe$Nothing; } - - var errorMessage = - 'Trying to initialize the `' + moduleName + '` module with an unexpected flag.\n' - + 'I tried to convert it to an Elm value, but ran into this problem:\n\n' - + result._0; - - crash(errorMessage, domNode); - }; -} - -function crash(errorMessage, domNode) -{ - if (domNode) - { - domNode.innerHTML = - '
' - + '

Oops! Something went wrong when starting your Elm program.

' - + '
' + errorMessage + '
' - + '
'; - } - - throw new Error(errorMessage); -} - - -// NORMAL SETUP - -function normalSetup(impl, object, moduleName, flagChecker) -{ - object['embed'] = function embed(node, flags) - { - while (node.lastChild) - { - node.removeChild(node.lastChild); + }; + var $elm$core$String$foldr = _String_foldr; + var $elm$core$String$toList = function(string) { + return A3( + $elm$core$String$foldr, + $elm$core$List$cons, + _List_Nil, + string + ); + }; + var $rtfeldman$elm_hex$Hex$fromString = function(str) { + if ($elm$core$String$isEmpty(str)) { + return $elm$core$Result$Err( + "Empty strings are not valid hexadecimal strings." + ); + } else { + var result = (function() { + if (A2($elm$core$String$startsWith, "-", str)) { + var list = A2( + $elm$core$Maybe$withDefault, + _List_Nil, + $elm$core$List$tail($elm$core$String$toList(str)) + ); + return A2( + $elm$core$Result$map, + $elm$core$Basics$negate, + A3( + $rtfeldman$elm_hex$Hex$fromStringHelp, + $elm$core$List$length(list) - 1, + list, + 0 + ) + ); + } else { + return A3( + $rtfeldman$elm_hex$Hex$fromStringHelp, + $elm$core$String$length(str) - 1, + $elm$core$String$toList(str), + 0 + ); + } + })(); + var formatError = function(err) { + return A2( + $elm$core$String$join, + " ", + _List_fromArray([ + '"' + (str + '"'), + "is not a valid hexadecimal string because", + err + ]) + ); + }; + return A2($elm$core$Result$mapError, formatError, result); + } + }; + var $elm$core$String$toLower = _String_toLower; + var $elm$core$Result$withDefault = F2(function(def, result) { + if (result.$ === "Ok") { + var a = result.a; + return a; + } else { + return def; } - - return _elm_lang$core$Native_Platform.initialize( - flagChecker(impl.init, flags, node), - impl.update, - impl.subscriptions, - normalRenderer(node, impl.view) + }); + var $author$project$Ast$Literal$characterParser = A2( + $author$project$Ast$Helpers$between_, + $andre_dietrich$parser_combinators$Combine$string("'"), + A2( + $andre_dietrich$parser_combinators$Combine$or, + A2( + $andre_dietrich$parser_combinators$Combine$andThen, + function(a) { + var _v0 = $elm$core$String$uncons(a); + _v0$6: while (true) { + if (_v0.$ === "Just") { + switch (_v0.a.a.valueOf()) { + case "n": + if (_v0.a.b === "") { + var _v1 = _v0.a; + return $andre_dietrich$parser_combinators$Combine$succeed( + _Utils_chr("\n") + ); + } else { + break _v0$6; + } + case "t": + if (_v0.a.b === "") { + var _v2 = _v0.a; + return $andre_dietrich$parser_combinators$Combine$succeed( + _Utils_chr("\t") + ); + } else { + break _v0$6; + } + case "r": + if (_v0.a.b === "") { + var _v3 = _v0.a; + return $andre_dietrich$parser_combinators$Combine$succeed( + _Utils_chr("\u000D") + ); + } else { + break _v0$6; + } + case "\\": + if (_v0.a.b === "") { + var _v4 = _v0.a; + return $andre_dietrich$parser_combinators$Combine$succeed( + _Utils_chr("\\") + ); + } else { + break _v0$6; + } + case "0": + if (_v0.a.b === "") { + var _v5 = _v0.a; + return $andre_dietrich$parser_combinators$Combine$succeed( + _Utils_chr("\u0000") + ); + } else { + break _v0$6; + } + case "x": + var _v6 = _v0.a; + var hex = _v6.b; + return A2( + $elm$core$Result$withDefault, + $andre_dietrich$parser_combinators$Combine$fail( + "Invalid charcode" + ), + A2( + $elm$core$Result$map, + $andre_dietrich$parser_combinators$Combine$succeed, + A2( + $elm$core$Result$map, + $elm$core$Char$fromCode, + $rtfeldman$elm_hex$Hex$fromString( + $elm$core$String$toLower(hex) + ) + ) + ) + ); + default: + break _v0$6; + } + } else { + return $andre_dietrich$parser_combinators$Combine$fail( + "No character" + ); + } + } + var other = _v0.a; + return $andre_dietrich$parser_combinators$Combine$fail( + "No such character as \\" + + $elm$core$String$fromChar(other.a) + ); + }, + A2( + $andre_dietrich$parser_combinators$Combine$keep, + $andre_dietrich$parser_combinators$Combine$regex( + "(n|t|r|\\\\|x..)" + ), + $andre_dietrich$parser_combinators$Combine$string("\\") + ) + ), + $andre_dietrich$parser_combinators$Combine$Char$anyChar + ) + ); + var $author$project$Ast$Expression$character = $author$project$Ast$Common$withMeta( + A2( + $andre_dietrich$parser_combinators$Combine$map, + A2( + $elm$core$Basics$composeL, + $author$project$Ast$Expression$Literal, + $author$project$Ast$Common$Character + ), + $author$project$Ast$Literal$characterParser + ) + ); + var $author$project$Ast$Expression$Constructor = function(a) { + return { $: "Constructor", a: a }; + }; + var $author$project$Ast$Expression$constructor = $author$project$Ast$Common$withMeta( + A2( + $andre_dietrich$parser_combinators$Combine$map, + $author$project$Ast$Expression$Constructor, + $author$project$Ast$Helpers$upName + ) + ); + var $elm$core$String$filter = _String_filter; + var $andre_dietrich$parser_combinators$Combine$Char$newline = A2( + $andre_dietrich$parser_combinators$Combine$onerror, + "expected a newline", + $andre_dietrich$parser_combinators$Combine$Char$satisfy( + $elm$core$Basics$eq(_Utils_chr("\n")) + ) + ); + var $author$project$Ast$Helpers$countIndent = A2( + $andre_dietrich$parser_combinators$Combine$andThen, + A2( + $elm$core$Basics$composeR, + $elm$core$String$filter(function(_char) { + return _Utils_eq(_char, _Utils_chr(" ")); + }), + A2( + $elm$core$Basics$composeR, + $elm$core$String$length, + $andre_dietrich$parser_combinators$Combine$succeed + ) + ), + A2( + $andre_dietrich$parser_combinators$Combine$keep, + $author$project$Ast$Helpers$spaces, + $andre_dietrich$parser_combinators$Combine$Char$newline + ) + ); + var $author$project$Ast$Helpers$exactIndentation = function(_int) { + return $andre_dietrich$parser_combinators$Combine$regex( + "\n*[ \\t]{" + ($elm$core$String$fromInt(_int) + "}\n*") ); - }; - - object['fullscreen'] = function fullscreen(flags) - { - return _elm_lang$core$Native_Platform.initialize( - flagChecker(impl.init, flags, document.body), - impl.update, - impl.subscriptions, - normalRenderer(document.body, impl.view) + }; + var $author$project$Ast$Expression$External = F2(function(a, b) { + return { $: "External", a: a, b: b }; + }); + var $author$project$Ast$Expression$external = $author$project$Ast$Common$withMeta( + A2( + $andre_dietrich$parser_combinators$Combine$andMap, + A2( + $andre_dietrich$parser_combinators$Combine$or, + $author$project$Ast$Expression$variable, + $author$project$Ast$Expression$constructor + ), + A2( + $andre_dietrich$parser_combinators$Combine$map, + $author$project$Ast$Expression$External, + $andre_dietrich$parser_combinators$Combine$many1( + A2( + $andre_dietrich$parser_combinators$Combine$ignore, + $andre_dietrich$parser_combinators$Combine$string("."), + $author$project$Ast$Helpers$upName + ) + ) + ) + ) + ); + var $author$project$Ast$Common$Float = function(a) { + return { $: "Float", a: a }; + }; + var $elm$core$String$toFloat = _String_toFloat; + var $andre_dietrich$parser_combinators$Combine$Num$unwrap = function( + value + ) { + if (value.$ === "Just") { + var v = value.a; + return $andre_dietrich$parser_combinators$Combine$succeed(v); + } else { + return $andre_dietrich$parser_combinators$Combine$fail( + "impossible state in Combine.Num.unwrap" + ); + } + }; + var $andre_dietrich$parser_combinators$Combine$Num$float = A2( + $andre_dietrich$parser_combinators$Combine$onerror, + "expected a float", + A2( + $andre_dietrich$parser_combinators$Combine$andThen, + $andre_dietrich$parser_combinators$Combine$Num$unwrap, + A2( + $andre_dietrich$parser_combinators$Combine$map, + $elm$core$String$toFloat, + $andre_dietrich$parser_combinators$Combine$regex( + "-?(?:0|[1-9]\\d*)\\.\\d+" + ) + ) + ) + ); + var $author$project$Ast$Literal$floatParser = $andre_dietrich$parser_combinators$Combine$Num$float; + var $author$project$Ast$Expression$float = $author$project$Ast$Common$withMeta( + A2( + $andre_dietrich$parser_combinators$Combine$map, + A2( + $elm$core$Basics$composeL, + $author$project$Ast$Expression$Literal, + $author$project$Ast$Common$Float + ), + $author$project$Ast$Literal$floatParser + ) + ); + var $author$project$Ast$Common$Integer = function(a) { + return { $: "Integer", a: a }; + }; + var $andre_dietrich$parser_combinators$Combine$Num$int = A2( + $andre_dietrich$parser_combinators$Combine$onerror, + "expected an int", + A2( + $andre_dietrich$parser_combinators$Combine$andThen, + $andre_dietrich$parser_combinators$Combine$Num$unwrap, + A2( + $andre_dietrich$parser_combinators$Combine$map, + $elm$core$String$toInt, + $andre_dietrich$parser_combinators$Combine$regex( + "-?(?:0|[1-9]\\d*)" + ) + ) + ) + ); + var $author$project$Ast$Literal$intParser = $andre_dietrich$parser_combinators$Combine$Num$int; + var $author$project$Ast$Expression$integer = $author$project$Ast$Common$withMeta( + A2( + $andre_dietrich$parser_combinators$Combine$map, + A2( + $elm$core$Basics$composeL, + $author$project$Ast$Expression$Literal, + $author$project$Ast$Common$Integer + ), + $author$project$Ast$Literal$intParser + ) + ); + var $andre_dietrich$parser_combinators$Combine$brackets = A2( + $andre_dietrich$parser_combinators$Combine$between, + $andre_dietrich$parser_combinators$Combine$string("["), + $andre_dietrich$parser_combinators$Combine$string("]") + ); + var $andre_dietrich$parser_combinators$Combine$sepBy = F2(function( + sep, + p + ) { + return A2( + $andre_dietrich$parser_combinators$Combine$or, + A2($andre_dietrich$parser_combinators$Combine$sepBy1, sep, p), + $andre_dietrich$parser_combinators$Combine$succeed(_List_Nil) ); - }; -} - -function normalRenderer(parentNode, view) -{ - return function(tagger, initialModel) - { - var eventNode = { tagger: tagger, parent: undefined }; - var initialVirtualNode = view(initialModel); - var domNode = render(initialVirtualNode, eventNode); - parentNode.appendChild(domNode); - return makeStepper(domNode, view, initialVirtualNode, eventNode); - }; -} - - -// STEPPER - -var rAF = - typeof requestAnimationFrame !== 'undefined' - ? requestAnimationFrame - : function(callback) { setTimeout(callback, 1000 / 60); }; - -function makeStepper(domNode, view, initialVirtualNode, eventNode) -{ - var state = 'NO_REQUEST'; - var currNode = initialVirtualNode; - var nextModel; - - function updateIfNeeded() - { - switch (state) - { - case 'NO_REQUEST': - throw new Error( - 'Unexpected draw callback.\n' + - 'Please report this to .' + }); + var $author$project$Ast$Helpers$commaSeparated_ = function(p) { + return A2( + $andre_dietrich$parser_combinators$Combine$sepBy, + $andre_dietrich$parser_combinators$Combine$string(","), + A2( + $author$project$Ast$Helpers$between_, + $andre_dietrich$parser_combinators$Combine$whitespace, + p + ) + ); + }; + var $author$project$Ast$Helpers$listParser = function(el) { + return $andre_dietrich$parser_combinators$Combine$brackets( + $author$project$Ast$Helpers$commaSeparated_(el) + ); + }; + var $andre_dietrich$parser_combinators$Combine$lookAhead = function( + p + ) { + return $andre_dietrich$parser_combinators$Combine$Parser( + F2(function(state, stream) { + var _v0 = A3( + $andre_dietrich$parser_combinators$Combine$app, + p, + state, + stream + ); + if (_v0.c.$ === "Ok") { + var rstate = _v0.a; + var res = _v0.c.a; + return _Utils_Tuple3( + rstate, + stream, + $elm$core$Result$Ok(res) + ); + } else { + var err = _v0; + return err; + } + }) + ); + }; + var $author$project$Ast$Common$PApplication = F2(function(a, b) { + return { $: "PApplication", a: a, b: b }; + }); + var $author$project$Ast$Helpers$spacesOrIndentedNewline = function( + indentation + ) { + return $andre_dietrich$parser_combinators$Combine$lazy(function( + _v0 + ) { + return A2( + $andre_dietrich$parser_combinators$Combine$or, + A2( + $andre_dietrich$parser_combinators$Combine$keep, + $andre_dietrich$parser_combinators$Combine$succeed( + _Utils_Tuple0 + ), + $author$project$Ast$Helpers$spaces_ + ), + A2( + $andre_dietrich$parser_combinators$Combine$andThen, + function(column) { + return _Utils_cmp(column, indentation) < 0 + ? $andre_dietrich$parser_combinators$Combine$fail( + "Arguments have to be at least the same indentation as the function" + ) + : $andre_dietrich$parser_combinators$Combine$succeed( + _Utils_Tuple0 + ); + }, + $author$project$Ast$Helpers$countIndent + ) + ); + }); + }; + var $author$project$Ast$Pattern$appParser = function(next) { + return $andre_dietrich$parser_combinators$Combine$lazy(function( + _v0 + ) { + return A2( + $andre_dietrich$parser_combinators$Combine$or, + $andre_dietrich$parser_combinators$Combine$withLocation( + function(l) { + return A2( + $andre_dietrich$parser_combinators$Combine$chainl, + A2( + $andre_dietrich$parser_combinators$Combine$onsuccess, + F2(function(a, b) { + return A3( + $author$project$Ast$Common$addMeta, + l.line, + l.column, + A2($author$project$Ast$Common$PApplication, a, b) + ); + }), + $author$project$Ast$Helpers$spacesOrIndentedNewline( + l.column + 1 + ) + ), + next ); - - case 'PENDING_REQUEST': - rAF(updateIfNeeded); - state = 'EXTRA_REQUEST'; - - var nextNode = view(nextModel); - var patches = diff(currNode, nextNode); - domNode = applyPatches(domNode, currNode, patches, eventNode); - currNode = nextNode; - - return; - - case 'EXTRA_REQUEST': - state = 'NO_REQUEST'; - return; - } - } - - return function stepper(model) - { - if (state === 'NO_REQUEST') - { - rAF(updateIfNeeded); - } - state = 'PENDING_REQUEST'; - nextModel = model; - }; -} - - -// DEBUG SETUP - -function debugSetup(impl, object, moduleName, flagChecker) -{ - object['fullscreen'] = function fullscreen(flags) - { - var popoutRef = { doc: undefined }; - return _elm_lang$core$Native_Platform.initialize( - flagChecker(impl.init, flags, document.body), - impl.update(scrollTask(popoutRef)), - impl.subscriptions, - debugRenderer(moduleName, document.body, popoutRef, impl.view, impl.viewIn, impl.viewOut) + } + ), + next + ); + }); + }; + var $author$project$Ast$Common$PAs = F2(function(a, b) { + return { $: "PAs", a: a, b: b }; + }); + var $author$project$Ast$Pattern$asParser_ = function(a) { + return $andre_dietrich$parser_combinators$Combine$lazy(function( + _v0 + ) { + return A2( + $andre_dietrich$parser_combinators$Combine$or, + A2( + $andre_dietrich$parser_combinators$Combine$andThen, + $author$project$Ast$Pattern$asParser_, + $author$project$Ast$Common$withMeta( + A2( + $andre_dietrich$parser_combinators$Combine$map, + $author$project$Ast$Common$PAs(a), + A2( + $andre_dietrich$parser_combinators$Combine$keep, + $author$project$Ast$Helpers$varName, + $author$project$Ast$Helpers$symbol("as") + ) + ) + ) + ), + $andre_dietrich$parser_combinators$Combine$succeed(a) + ); + }); + }; + var $author$project$Ast$Pattern$asParser = function(next) { + return $andre_dietrich$parser_combinators$Combine$lazy(function( + _v0 + ) { + return A2( + $andre_dietrich$parser_combinators$Combine$andThen, + $author$project$Ast$Pattern$asParser_, + next + ); + }); + }; + var $author$project$Ast$Common$PCons = F2(function(a, b) { + return { $: "PCons", a: a, b: b }; + }); + var $author$project$Ast$Pattern$consParser = function(next) { + return $andre_dietrich$parser_combinators$Combine$lazy(function( + _v0 + ) { + return A2( + $andre_dietrich$parser_combinators$Combine$or, + $author$project$Ast$Common$withMeta( + A2( + $andre_dietrich$parser_combinators$Combine$andMap, + $author$project$Ast$Pattern$consParser(next), + A2( + $andre_dietrich$parser_combinators$Combine$ignore, + $author$project$Ast$Common$withMeta( + $author$project$Ast$Helpers$symbol("::") + ), + A2( + $andre_dietrich$parser_combinators$Combine$map, + $author$project$Ast$Common$PCons, + next + ) + ) + ) + ), + next + ); + }); + }; + var $author$project$Ast$Common$PList = function(a) { + return { $: "PList", a: a }; + }; + var $author$project$Ast$Common$PLiteral = function(a) { + return { $: "PLiteral", a: a }; + }; + var $author$project$Ast$Common$PRecord = function(a) { + return { $: "PRecord", a: a }; + }; + var $author$project$Ast$Common$PTuple = function(a) { + return { $: "PTuple", a: a }; + }; + var $author$project$Ast$Common$PConstructor = function(a) { + return { $: "PConstructor", a: a }; + }; + var $author$project$Ast$Pattern$constructorParser = $author$project$Ast$Common$withMeta( + A2( + $andre_dietrich$parser_combinators$Combine$map, + $author$project$Ast$Common$PConstructor, + $author$project$Ast$Helpers$upName + ) + ); + var $author$project$Ast$Common$String = function(a) { + return { $: "String", a: a }; + }; + var $elm$core$String$concat = function(strings) { + return A2($elm$core$String$join, "", strings); + }; + var $author$project$Ast$Literal$stringParser = (function() { + var singleString = A2( + $andre_dietrich$parser_combinators$Combine$ignore, + $andre_dietrich$parser_combinators$Combine$string('"'), + A2( + $andre_dietrich$parser_combinators$Combine$keep, + $andre_dietrich$parser_combinators$Combine$regex( + '(\\\\\\\\|\\\\"|[^"\n])*' + ), + $andre_dietrich$parser_combinators$Combine$string('"') + ) ); - }; - - object['embed'] = function fullscreen(node, flags) - { - var popoutRef = { doc: undefined }; - return _elm_lang$core$Native_Platform.initialize( - flagChecker(impl.init, flags, node), - impl.update(scrollTask(popoutRef)), - impl.subscriptions, - debugRenderer(moduleName, node, popoutRef, impl.view, impl.viewIn, impl.viewOut) + var multiString = A2( + $andre_dietrich$parser_combinators$Combine$map, + $elm$core$String$concat, + A2( + $andre_dietrich$parser_combinators$Combine$ignore, + $andre_dietrich$parser_combinators$Combine$string('"""'), + A2( + $andre_dietrich$parser_combinators$Combine$keep, + $andre_dietrich$parser_combinators$Combine$many( + $andre_dietrich$parser_combinators$Combine$regex('[^"]*') + ), + $andre_dietrich$parser_combinators$Combine$string('"""') + ) + ) ); - }; -} - -function scrollTask(popoutRef) -{ - return _elm_lang$core$Native_Scheduler.nativeBinding(function(callback) - { - var doc = popoutRef.doc; - if (doc) - { - var msgs = doc.getElementsByClassName('debugger-sidebar-messages')[0]; - if (msgs) - { - msgs.scrollTop = msgs.scrollHeight; + return A2( + $andre_dietrich$parser_combinators$Combine$or, + multiString, + singleString + ); + })(); + var $author$project$Ast$Literal$literalParser = $andre_dietrich$parser_combinators$Combine$choice( + _List_fromArray([ + A2( + $andre_dietrich$parser_combinators$Combine$map, + $author$project$Ast$Common$Float, + $author$project$Ast$Literal$floatParser + ), + A2( + $andre_dietrich$parser_combinators$Combine$map, + $author$project$Ast$Common$Integer, + $author$project$Ast$Literal$intParser + ), + A2( + $andre_dietrich$parser_combinators$Combine$map, + $author$project$Ast$Common$Character, + $author$project$Ast$Literal$characterParser + ), + A2( + $andre_dietrich$parser_combinators$Combine$map, + $author$project$Ast$Common$String, + $author$project$Ast$Literal$stringParser + ) + ]) + ); + var $author$project$Ast$Helpers$tupleParser = function(el) { + return A2( + $andre_dietrich$parser_combinators$Combine$andThen, + function(a) { + if (a.b && !a.b.b) { + return $andre_dietrich$parser_combinators$Combine$fail( + "No single tuples" + ); + } else { + var anyOther = a; + return $andre_dietrich$parser_combinators$Combine$succeed( + anyOther + ); } - } - callback(_elm_lang$core$Native_Scheduler.succeed(_elm_lang$core$Native_Utils.Tuple0)); - }); -} - - -function debugRenderer(moduleName, parentNode, popoutRef, view, viewIn, viewOut) -{ - return function(tagger, initialModel) - { - var appEventNode = { tagger: tagger, parent: undefined }; - var eventNode = { tagger: tagger, parent: undefined }; - - // make normal stepper - var appVirtualNode = view(initialModel); - var appNode = render(appVirtualNode, appEventNode); - parentNode.appendChild(appNode); - var appStepper = makeStepper(appNode, view, appVirtualNode, appEventNode); - - // make overlay stepper - var overVirtualNode = viewIn(initialModel)._1; - var overNode = render(overVirtualNode, eventNode); - parentNode.appendChild(overNode); - var wrappedViewIn = wrapViewIn(appEventNode, overNode, viewIn); - var overStepper = makeStepper(overNode, wrappedViewIn, overVirtualNode, eventNode); - - // make debugger stepper - var debugStepper = makeDebugStepper(initialModel, viewOut, eventNode, parentNode, moduleName, popoutRef); - - return function stepper(model) - { - appStepper(model); - overStepper(model); - debugStepper(model); - } - }; -} - -function makeDebugStepper(initialModel, view, eventNode, parentNode, moduleName, popoutRef) -{ - var curr; - var domNode; - - return function stepper(model) - { - if (!model.isDebuggerOpen) - { - return; - } - - if (!popoutRef.doc) - { - curr = view(model); - domNode = openDebugWindow(moduleName, popoutRef, curr, eventNode); - return; - } - - // switch to document of popout - localDoc = popoutRef.doc; - - var next = view(model); - var patches = diff(curr, next); - domNode = applyPatches(domNode, curr, patches, eventNode); - curr = next; - - // switch back to normal document - localDoc = document; - }; -} - -function openDebugWindow(moduleName, popoutRef, virtualNode, eventNode) -{ - var w = 900; - var h = 360; - var x = screen.width - w; - var y = screen.height - h; - var debugWindow = window.open('', '', 'width=' + w + ',height=' + h + ',left=' + x + ',top=' + y); - - // switch to window document - localDoc = debugWindow.document; - - popoutRef.doc = localDoc; - localDoc.title = 'Debugger - ' + moduleName; - localDoc.body.style.margin = '0'; - localDoc.body.style.padding = '0'; - var domNode = render(virtualNode, eventNode); - localDoc.body.appendChild(domNode); - - localDoc.addEventListener('keydown', function(event) { - if (event.metaKey && event.which === 82) - { - window.location.reload(); - } - if (event.which === 38) - { - eventNode.tagger({ ctor: 'Up' }); - event.preventDefault(); - } - if (event.which === 40) - { - eventNode.tagger({ ctor: 'Down' }); - event.preventDefault(); - } - }); - - function close() - { - popoutRef.doc = undefined; - debugWindow.close(); - } - window.addEventListener('unload', close); - debugWindow.addEventListener('unload', function() { - popoutRef.doc = undefined; - window.removeEventListener('unload', close); - eventNode.tagger({ ctor: 'Close' }); - }); - - // switch back to the normal document - localDoc = document; - - return domNode; -} - - -// BLOCK EVENTS - -function wrapViewIn(appEventNode, overlayNode, viewIn) -{ - var ignorer = makeIgnorer(overlayNode); - var blocking = 'Normal'; - var overflow; - - var normalTagger = appEventNode.tagger; - var blockTagger = function() {}; - - return function(model) - { - var tuple = viewIn(model); - var newBlocking = tuple._0.ctor; - appEventNode.tagger = newBlocking === 'Normal' ? normalTagger : blockTagger; - if (blocking !== newBlocking) - { - traverse('removeEventListener', ignorer, blocking); - traverse('addEventListener', ignorer, newBlocking); - - if (blocking === 'Normal') - { - overflow = document.body.style.overflow; - document.body.style.overflow = 'hidden'; + }, + $andre_dietrich$parser_combinators$Combine$parens( + $author$project$Ast$Helpers$commaSeparated_(el) + ) + ); + }; + var $author$project$Ast$Common$PVariable = function(a) { + return { $: "PVariable", a: a }; + }; + var $author$project$Ast$Helpers$funName = $andre_dietrich$parser_combinators$Combine$choice( + _List_fromArray([ + $author$project$Ast$Helpers$varName, + $andre_dietrich$parser_combinators$Combine$parens( + $author$project$Ast$Helpers$operator + ) + ]) + ); + var $author$project$Ast$Pattern$varParser = $author$project$Ast$Common$withMeta( + A2( + $andre_dietrich$parser_combinators$Combine$map, + $author$project$Ast$Common$PVariable, + $author$project$Ast$Helpers$funName + ) + ); + var $author$project$Ast$Common$PWild = { $: "PWild" }; + var $author$project$Ast$Pattern$wildParser = $author$project$Ast$Common$withMeta( + A2( + $andre_dietrich$parser_combinators$Combine$map, + $elm$core$Basics$always($author$project$Ast$Common$PWild), + $author$project$Ast$Helpers$wild + ) + ); + var $author$project$Ast$Pattern$terminalParser = function(next) { + return $andre_dietrich$parser_combinators$Combine$lazy(function( + _v0 + ) { + return $andre_dietrich$parser_combinators$Combine$choice( + _List_fromArray([ + $author$project$Ast$Pattern$wildParser, + $author$project$Ast$Pattern$varParser, + $author$project$Ast$Pattern$constructorParser, + $author$project$Ast$Common$withMeta( + A2( + $andre_dietrich$parser_combinators$Combine$map, + $author$project$Ast$Common$PLiteral, + $author$project$Ast$Literal$literalParser + ) + ), + $author$project$Ast$Common$withMeta( + A2( + $andre_dietrich$parser_combinators$Combine$map, + $author$project$Ast$Common$PRecord, + $andre_dietrich$parser_combinators$Combine$braces( + $author$project$Ast$Helpers$commaSeparated_( + $author$project$Ast$Common$withMeta( + $author$project$Ast$Helpers$loName + ) + ) + ) + ) + ), + $author$project$Ast$Common$withMeta( + A2( + $andre_dietrich$parser_combinators$Combine$map, + $author$project$Ast$Common$PTuple, + $author$project$Ast$Helpers$tupleParser(next) + ) + ), + $author$project$Ast$Common$withMeta( + A2( + $andre_dietrich$parser_combinators$Combine$map, + $author$project$Ast$Common$PList, + $author$project$Ast$Helpers$listParser(next) + ) + ), + $andre_dietrich$parser_combinators$Combine$parens(next) + ]) + ); + }); + }; + var $author$project$Ast$Pattern$precedence = _List_fromArray([ + $author$project$Ast$Pattern$asParser, + $author$project$Ast$Pattern$consParser, + $author$project$Ast$Pattern$appParser, + $author$project$Ast$Pattern$terminalParser + ]); + function $author$project$Ast$Pattern$cyclic$pattern() { + return $andre_dietrich$parser_combinators$Combine$lazy(function( + _v0 + ) { + return A3( + $elm$core$List$foldr, + $elm$core$Basics$identity, + $author$project$Ast$Pattern$cyclic$pattern(), + $author$project$Ast$Pattern$precedence + ); + }); + } + try { + var $author$project$Ast$Pattern$pattern = $author$project$Ast$Pattern$cyclic$pattern(); + $author$project$Ast$Pattern$cyclic$pattern = function() { + return $author$project$Ast$Pattern$pattern; + }; + } catch ($) { + throw "Some top-level definitions from `Ast.Pattern` are causing infinite recursion:\n\n ┌─────┐\n │ pattern\n └─────┘\n\nThese errors are very tricky, so read https://elm-lang.org/0.19.1/bad-recursion to learn how to fix it!"; + } + var $author$project$Ast$Expression$simplifiedRecord = (function() { + var branch = function(_v1) { + var line = _v1.line; + var column = _v1.column; + return A2( + $andre_dietrich$parser_combinators$Combine$map, + function(a) { + return _Utils_Tuple2( + A3($author$project$Ast$Common$addMeta, line, column, a), + A3( + $author$project$Ast$Common$addMeta, + line, + column, + $author$project$Ast$Expression$Variable(a) + ) + ); + }, + $author$project$Ast$Helpers$loName + ); + }; + return $andre_dietrich$parser_combinators$Combine$lazy(function( + _v0 + ) { + return $author$project$Ast$Common$withMeta( + A2( + $andre_dietrich$parser_combinators$Combine$map, + $author$project$Ast$Expression$Record, + $andre_dietrich$parser_combinators$Combine$braces( + $author$project$Ast$Helpers$commaSeparated( + $andre_dietrich$parser_combinators$Combine$withLocation( + branch + ) + ) + ) + ) + ); + }); + })(); + var $elm$core$Basics$not = _Basics_not; + var $elm_community$list_extra$List$Extra$dropWhile = F2(function( + predicate, + list + ) { + dropWhile: while (true) { + if (!list.b) { + return _List_Nil; + } else { + var x = list.a; + var xs = list.b; + if (predicate(x)) { + var $temp$predicate = predicate, + $temp$list = xs; + predicate = $temp$predicate; + list = $temp$list; + continue dropWhile; + } else { + return list; } - - if (newBlocking === 'Normal') - { - document.body.style.overflow = overflow; + } + } + }); + var $elm_community$list_extra$List$Extra$takeWhile = function( + predicate + ) { + var takeWhileMemo = F2(function(memo, list) { + takeWhileMemo: while (true) { + if (!list.b) { + return $elm$core$List$reverse(memo); + } else { + var x = list.a; + var xs = list.b; + if (predicate(x)) { + var $temp$memo = A2($elm$core$List$cons, x, memo), + $temp$list = xs; + memo = $temp$memo; + list = $temp$list; + continue takeWhileMemo; + } else { + return $elm$core$List$reverse(memo); + } } - - blocking = newBlocking; + } + }); + return takeWhileMemo(_List_Nil); + }; + var $elm_community$list_extra$List$Extra$span = F2(function(p, xs) { + return _Utils_Tuple2( + A2($elm_community$list_extra$List$Extra$takeWhile, p, xs), + A2($elm_community$list_extra$List$Extra$dropWhile, p, xs) + ); + }); + var $elm_community$list_extra$List$Extra$break = function(p) { + return $elm_community$list_extra$List$Extra$span( + A2($elm$core$Basics$composeL, $elm$core$Basics$not, p) + ); + }; + var $elm$core$List$maybeCons = F3(function(f, mx, xs) { + var _v0 = f(mx); + if (_v0.$ === "Just") { + var x = _v0.a; + return A2($elm$core$List$cons, x, xs); + } else { + return xs; } - return tuple._1; - } -} - -function traverse(verbEventListener, ignorer, blocking) -{ - switch(blocking) - { - case 'Normal': - return; - - case 'Pause': - return traverseHelp(verbEventListener, ignorer, mostEvents); - - case 'Message': - return traverseHelp(verbEventListener, ignorer, allEvents); - } -} - -function traverseHelp(verbEventListener, handler, eventNames) -{ - for (var i = 0; i < eventNames.length; i++) - { - document.body[verbEventListener](eventNames[i], handler, true); - } -} - -function makeIgnorer(overlayNode) -{ - return function(event) - { - if (event.type === 'keydown' && event.metaKey && event.which === 82) - { - return; + }); + var $elm$core$List$filterMap = F2(function(f, xs) { + return A3( + $elm$core$List$foldr, + $elm$core$List$maybeCons(f), + _List_Nil, + xs + ); + }); + var $author$project$Ast$BinOp$N = { $: "N" }; + var $elm$core$List$all = F2(function(isOkay, list) { + return !A2( + $elm$core$List$any, + A2($elm$core$Basics$composeL, $elm$core$Basics$not, isOkay), + list + ); + }); + var $elm$core$Dict$get = F2(function(targetKey, dict) { + get: while (true) { + if (dict.$ === "RBEmpty_elm_builtin") { + return $elm$core$Maybe$Nothing; + } else { + var key = dict.b; + var value = dict.c; + var left = dict.d; + var right = dict.e; + var _v1 = A2($elm$core$Basics$compare, targetKey, key); + switch (_v1.$) { + case "LT": + var $temp$targetKey = targetKey, + $temp$dict = left; + targetKey = $temp$targetKey; + dict = $temp$dict; + continue get; + case "EQ": + return $elm$core$Maybe$Just(value); + default: + var $temp$targetKey = targetKey, + $temp$dict = right; + targetKey = $temp$targetKey; + dict = $temp$dict; + continue get; + } + } } - - var isScroll = event.type === 'scroll' || event.type === 'wheel'; - - var node = event.target; - while (node !== null) - { - if (node.className === 'elm-overlay-message-details' && isScroll) - { - return; + }); + var $author$project$Ast$Expression$op = F2(function(ops, n) { + return A2( + $elm$core$Maybe$withDefault, + _Utils_Tuple2($author$project$Ast$BinOp$L, 9), + A2($elm$core$Dict$get, n, ops) + ); + }); + var $author$project$Ast$Expression$assoc = F2(function(ops, n) { + return A2($author$project$Ast$Expression$op, ops, n).a; + }); + var $author$project$Ast$Common$dropMeta = function(_v0) { + var e = _v0.a; + return e; + }; + var $elm$core$List$filter = F2(function(isGood, list) { + return A3( + $elm$core$List$foldr, + F2(function(x, xs) { + return isGood(x) ? A2($elm$core$List$cons, x, xs) : xs; + }), + _List_Nil, + list + ); + }); + var $elm$core$Tuple$second = function(_v0) { + var y = _v0.b; + return y; + }; + var $author$project$Ast$Expression$level = F2(function(ops, n) { + return A2($author$project$Ast$Expression$op, ops, n).b; + }); + var $author$project$Ast$Expression$hasLevel = F3(function( + ops, + l, + _v0 + ) { + var n = _v0.a; + return _Utils_eq( + A2( + $author$project$Ast$Expression$level, + ops, + $author$project$Ast$Common$dropMeta(n) + ), + l + ); + }); + var $author$project$Ast$Expression$findAssoc = F3(function( + ops, + l, + eops + ) { + var lops = A2( + $elm$core$List$filter, + A2($author$project$Ast$Expression$hasLevel, ops, l), + eops + ); + var error = function(issue) { + var operators = A2( + $elm$core$String$join, + " and ", + A2( + $elm$core$List$map, + A2( + $elm$core$Basics$composeR, + $elm$core$Tuple$first, + $author$project$Ast$Common$dropMeta + ), + lops + ) + ); + return "conflicting " + (issue + (" for operators " + operators)); + }; + var assocs = A2( + $elm$core$List$map, + A2( + $elm$core$Basics$composeL, + A2( + $elm$core$Basics$composeL, + $author$project$Ast$Expression$assoc(ops), + $author$project$Ast$Common$dropMeta + ), + $elm$core$Tuple$first + ), + lops + ); + if ( + A2( + $elm$core$List$all, + $elm$core$Basics$eq($author$project$Ast$BinOp$L), + assocs + ) + ) { + return $andre_dietrich$parser_combinators$Combine$succeed( + $author$project$Ast$BinOp$L + ); + } else { + if ( + A2( + $elm$core$List$all, + $elm$core$Basics$eq($author$project$Ast$BinOp$R), + assocs + ) + ) { + return $andre_dietrich$parser_combinators$Combine$succeed( + $author$project$Ast$BinOp$R + ); + } else { + if ( + A2( + $elm$core$List$all, + $elm$core$Basics$eq($author$project$Ast$BinOp$N), + assocs + ) + ) { + if (assocs.b && !assocs.b.b) { + return $andre_dietrich$parser_combinators$Combine$succeed( + $author$project$Ast$BinOp$N + ); + } else { + return $andre_dietrich$parser_combinators$Combine$fail( + error("precedence") + ); + } + } else { + return $andre_dietrich$parser_combinators$Combine$fail( + error("associativity") + ); } - - if (node === overlayNode && !isScroll) - { - return; + } + } + }); + var $author$project$Ast$Expression$BinOp = F3(function(a, b, c) { + return { $: "BinOp", a: a, b: b, c: c }; + }); + var $author$project$Ast$Expression$joinL = F2(function(es, ops) { + joinL: while (true) { + var _v0 = _Utils_Tuple2(es, ops); + _v0$2: while (true) { + if (_v0.a.b) { + if (!_v0.a.b.b) { + if (!_v0.b.b) { + var _v1 = _v0.a; + var e = _v1.a; + return $andre_dietrich$parser_combinators$Combine$succeed( + e + ); + } else { + break _v0$2; + } + } else { + if (_v0.b.b) { + var _v2 = _v0.a; + var a = _v2.a; + var _v3 = _v2.b; + var b = _v3.a; + var remE = _v3.b; + var _v4 = _v0.b; + var _v5 = _v4.a; + var e = _v5.a; + var line = _v5.b.line; + var column = _v5.b.column; + var remO = _v4.b; + var $temp$es = A2( + $elm$core$List$cons, + A3( + $author$project$Ast$Common$addMeta, + line, + column, + A3( + $author$project$Ast$Expression$BinOp, + A3( + $author$project$Ast$Common$addMeta, + line, + column, + $author$project$Ast$Expression$Variable(e) + ), + a, + b + ) + ), + remE + ), + $temp$ops = remO; + es = $temp$es; + ops = $temp$ops; + continue joinL; + } else { + break _v0$2; + } + } + } else { + break _v0$2; } - node = node.parentNode; - } - - event.stopPropagation(); - event.preventDefault(); - } -} - -var mostEvents = [ - 'click', 'dblclick', 'mousemove', - 'mouseup', 'mousedown', 'mouseenter', 'mouseleave', - 'touchstart', 'touchend', 'touchcancel', 'touchmove', - 'pointerdown', 'pointerup', 'pointerover', 'pointerout', - 'pointerenter', 'pointerleave', 'pointermove', 'pointercancel', - 'dragstart', 'drag', 'dragend', 'dragenter', 'dragover', 'dragleave', 'drop', - 'keyup', 'keydown', 'keypress', - 'input', 'change', - 'focus', 'blur' -]; - -var allEvents = mostEvents.concat('wheel', 'scroll'); - - -return { - node: node, - text: text, - custom: custom, - map: F2(map), - - on: F3(on), - style: style, - property: F2(property), - attribute: F2(attribute), - attributeNS: F3(attributeNS), - mapProperty: F2(mapProperty), - - lazy: F2(lazy), - lazy2: F3(lazy2), - lazy3: F4(lazy3), - keyedNode: F3(keyedNode), - - program: program, - programWithFlags: programWithFlags, - staticProgram: staticProgram -}; - -}(); - -var _elm_lang$virtual_dom$VirtualDom$programWithFlags = function (impl) { - return A2(_elm_lang$virtual_dom$Native_VirtualDom.programWithFlags, _elm_lang$virtual_dom$VirtualDom_Debug$wrapWithFlags, impl); -}; -var _elm_lang$virtual_dom$VirtualDom$program = function (impl) { - return A2(_elm_lang$virtual_dom$Native_VirtualDom.program, _elm_lang$virtual_dom$VirtualDom_Debug$wrap, impl); -}; -var _elm_lang$virtual_dom$VirtualDom$keyedNode = _elm_lang$virtual_dom$Native_VirtualDom.keyedNode; -var _elm_lang$virtual_dom$VirtualDom$lazy3 = _elm_lang$virtual_dom$Native_VirtualDom.lazy3; -var _elm_lang$virtual_dom$VirtualDom$lazy2 = _elm_lang$virtual_dom$Native_VirtualDom.lazy2; -var _elm_lang$virtual_dom$VirtualDom$lazy = _elm_lang$virtual_dom$Native_VirtualDom.lazy; -var _elm_lang$virtual_dom$VirtualDom$defaultOptions = {stopPropagation: false, preventDefault: false}; -var _elm_lang$virtual_dom$VirtualDom$onWithOptions = _elm_lang$virtual_dom$Native_VirtualDom.on; -var _elm_lang$virtual_dom$VirtualDom$on = F2( - function (eventName, decoder) { - return A3(_elm_lang$virtual_dom$VirtualDom$onWithOptions, eventName, _elm_lang$virtual_dom$VirtualDom$defaultOptions, decoder); - }); -var _elm_lang$virtual_dom$VirtualDom$style = _elm_lang$virtual_dom$Native_VirtualDom.style; -var _elm_lang$virtual_dom$VirtualDom$mapProperty = _elm_lang$virtual_dom$Native_VirtualDom.mapProperty; -var _elm_lang$virtual_dom$VirtualDom$attributeNS = _elm_lang$virtual_dom$Native_VirtualDom.attributeNS; -var _elm_lang$virtual_dom$VirtualDom$attribute = _elm_lang$virtual_dom$Native_VirtualDom.attribute; -var _elm_lang$virtual_dom$VirtualDom$property = _elm_lang$virtual_dom$Native_VirtualDom.property; -var _elm_lang$virtual_dom$VirtualDom$map = _elm_lang$virtual_dom$Native_VirtualDom.map; -var _elm_lang$virtual_dom$VirtualDom$text = _elm_lang$virtual_dom$Native_VirtualDom.text; -var _elm_lang$virtual_dom$VirtualDom$node = _elm_lang$virtual_dom$Native_VirtualDom.node; -var _elm_lang$virtual_dom$VirtualDom$Options = F2( - function (a, b) { - return {stopPropagation: a, preventDefault: b}; - }); -var _elm_lang$virtual_dom$VirtualDom$Node = {ctor: 'Node'}; -var _elm_lang$virtual_dom$VirtualDom$Property = {ctor: 'Property'}; - -var _elm_lang$html$Html$programWithFlags = _elm_lang$virtual_dom$VirtualDom$programWithFlags; -var _elm_lang$html$Html$program = _elm_lang$virtual_dom$VirtualDom$program; -var _elm_lang$html$Html$beginnerProgram = function (_p0) { - var _p1 = _p0; - return _elm_lang$html$Html$program( - { - init: A2( - _elm_lang$core$Platform_Cmd_ops['!'], - _p1.model, - {ctor: '[]'}), - update: F2( - function (msg, model) { + } + return $andre_dietrich$parser_combinators$Combine$fail(""); + } + }); + var $author$project$Ast$Expression$joinR = F2(function(es, ops) { + var _v0 = _Utils_Tuple2(es, ops); + _v0$2: while (true) { + if (_v0.a.b) { + if (!_v0.a.b.b) { + if (!_v0.b.b) { + var _v1 = _v0.a; + var e = _v1.a; + return $andre_dietrich$parser_combinators$Combine$succeed( + e + ); + } else { + break _v0$2; + } + } else { + if (_v0.b.b) { + var _v2 = _v0.a; + var a = _v2.a; + var _v3 = _v2.b; + var b = _v3.a; + var remE = _v3.b; + var _v4 = _v0.b; + var _v5 = _v4.a; + var e = _v5.a; + var line = _v5.b.line; + var column = _v5.b.column; + var remO = _v4.b; + return A2( + $andre_dietrich$parser_combinators$Combine$andThen, + function(exp) { + return $andre_dietrich$parser_combinators$Combine$succeed( + A3( + $author$project$Ast$Common$addMeta, + line, + column, + A3( + $author$project$Ast$Expression$BinOp, + A3( + $author$project$Ast$Common$addMeta, + line, + column, + $author$project$Ast$Expression$Variable(e) + ), + a, + exp + ) + ) + ); + }, + A2( + $author$project$Ast$Expression$joinR, + A2($elm$core$List$cons, b, remE), + remO + ) + ); + } else { + break _v0$2; + } + } + } else { + break _v0$2; + } + } + return $andre_dietrich$parser_combinators$Combine$fail(""); + }); + var $andre_dietrich$parser_combinators$Combine$sequence = function( + parsers + ) { + var accumulate = F4(function(acc, ps, state, stream) { + accumulate: while (true) { + if (!ps.b) { + return _Utils_Tuple3( + state, + stream, + $elm$core$Result$Ok($elm$core$List$reverse(acc)) + ); + } else { + var x = ps.a; + var xs = ps.b; + var _v1 = A3( + $andre_dietrich$parser_combinators$Combine$app, + x, + state, + stream + ); + if (_v1.c.$ === "Ok") { + var rstate = _v1.a; + var rstream = _v1.b; + var res = _v1.c.a; + var $temp$acc = A2($elm$core$List$cons, res, acc), + $temp$ps = xs, + $temp$state = rstate, + $temp$stream = rstream; + acc = $temp$acc; + ps = $temp$ps; + state = $temp$state; + stream = $temp$stream; + continue accumulate; + } else { + var estate = _v1.a; + var estream = _v1.b; + var ms = _v1.c.a; + return _Utils_Tuple3( + estate, + estream, + $elm$core$Result$Err(ms) + ); + } + } + } + }); + return $andre_dietrich$parser_combinators$Combine$Parser( + F2(function(state, stream) { + return A4(accumulate, _List_Nil, parsers, state, stream); + }) + ); + }; + var $author$project$Ast$Expression$split = F4(function( + ops, + l, + e, + eops + ) { + if (!eops.b) { + return $andre_dietrich$parser_combinators$Combine$succeed(e); + } else { + return A2( + $andre_dietrich$parser_combinators$Combine$andThen, + function(association) { + return A2( + $andre_dietrich$parser_combinators$Combine$andThen, + function(es) { + var ops_ = A2( + $elm$core$List$filterMap, + function(x) { + return A3( + $author$project$Ast$Expression$hasLevel, + ops, + l, + x + ) + ? $elm$core$Maybe$Just(x.a) + : $elm$core$Maybe$Nothing; + }, + eops + ); + if (association.$ === "R") { + return A2( + $author$project$Ast$Expression$joinR, + es, + ops_ + ); + } else { return A2( - _elm_lang$core$Platform_Cmd_ops['!'], - A2(_p1.update, msg, model), - {ctor: '[]'}); - }), - view: _p1.view, - subscriptions: function (_p2) { - return _elm_lang$core$Platform_Sub$none; + $author$project$Ast$Expression$joinL, + es, + ops_ + ); + } + }, + $andre_dietrich$parser_combinators$Combine$sequence( + A4( + $author$project$Ast$Expression$splitLevel, + ops, + l, + e, + eops + ) + ) + ); + }, + A3($author$project$Ast$Expression$findAssoc, ops, l, eops) + ); + } + }); + var $author$project$Ast$Expression$splitLevel = F4(function( + ops, + l, + e, + eops + ) { + var _v0 = A2( + $elm_community$list_extra$List$Extra$break, + A2($author$project$Ast$Expression$hasLevel, ops, l), + eops + ); + if (_v0.b.b) { + var lops = _v0.a; + var _v1 = _v0.b; + var _v2 = _v1.a; + var e_ = _v2.b; + var rops = _v1.b; + return A2( + $elm$core$List$cons, + A4($author$project$Ast$Expression$split, ops, l + 1, e, lops), + A4($author$project$Ast$Expression$splitLevel, ops, l, e_, rops) + ); + } else { + var lops = _v0.a; + return _List_fromArray([ + A4($author$project$Ast$Expression$split, ops, l + 1, e, lops) + ]); + } + }); + var $author$project$Ast$Expression$string = $author$project$Ast$Common$withMeta( + A2( + $andre_dietrich$parser_combinators$Combine$map, + A2( + $elm$core$Basics$composeL, + $author$project$Ast$Expression$Literal, + $author$project$Ast$Common$String + ), + $author$project$Ast$Literal$stringParser + ) + ); + var $author$project$Ast$Expression$successOrEmptyList = function(p) { + return $andre_dietrich$parser_combinators$Combine$lazy(function( + _v0 + ) { + return $andre_dietrich$parser_combinators$Combine$choice( + _List_fromArray([ + p, + $andre_dietrich$parser_combinators$Combine$succeed(_List_Nil) + ]) + ); + }); + }; + var $author$project$Ast$Helpers$symbol_ = function(k) { + return A2( + $author$project$Ast$Helpers$between_, + $andre_dietrich$parser_combinators$Combine$whitespace, + A2( + $andre_dietrich$parser_combinators$Combine$ignore, + $andre_dietrich$parser_combinators$Combine$regex("( |\\n)+"), + $andre_dietrich$parser_combinators$Combine$string(k) + ) + ); + }; + var $author$project$Ast$Expression$application = function(ops) { + return $andre_dietrich$parser_combinators$Combine$lazy(function( + _v13 + ) { + return $andre_dietrich$parser_combinators$Combine$withLocation( + function(l) { + return A2( + $andre_dietrich$parser_combinators$Combine$chainl, + A2( + $andre_dietrich$parser_combinators$Combine$onsuccess, + F2(function(a, b) { + return A3( + $author$project$Ast$Common$addMeta, + l.line, + l.column, + A2($author$project$Ast$Expression$Application, a, b) + ); + }), + $author$project$Ast$Helpers$spacesOrIndentedNewline( + l.column + 1 + ) + ), + $author$project$Ast$Expression$term(ops) + ); } + ); }); -}; -var _elm_lang$html$Html$map = _elm_lang$virtual_dom$VirtualDom$map; -var _elm_lang$html$Html$text = _elm_lang$virtual_dom$VirtualDom$text; -var _elm_lang$html$Html$node = _elm_lang$virtual_dom$VirtualDom$node; -var _elm_lang$html$Html$body = _elm_lang$html$Html$node('body'); -var _elm_lang$html$Html$section = _elm_lang$html$Html$node('section'); -var _elm_lang$html$Html$nav = _elm_lang$html$Html$node('nav'); -var _elm_lang$html$Html$article = _elm_lang$html$Html$node('article'); -var _elm_lang$html$Html$aside = _elm_lang$html$Html$node('aside'); -var _elm_lang$html$Html$h1 = _elm_lang$html$Html$node('h1'); -var _elm_lang$html$Html$h2 = _elm_lang$html$Html$node('h2'); -var _elm_lang$html$Html$h3 = _elm_lang$html$Html$node('h3'); -var _elm_lang$html$Html$h4 = _elm_lang$html$Html$node('h4'); -var _elm_lang$html$Html$h5 = _elm_lang$html$Html$node('h5'); -var _elm_lang$html$Html$h6 = _elm_lang$html$Html$node('h6'); -var _elm_lang$html$Html$header = _elm_lang$html$Html$node('header'); -var _elm_lang$html$Html$footer = _elm_lang$html$Html$node('footer'); -var _elm_lang$html$Html$address = _elm_lang$html$Html$node('address'); -var _elm_lang$html$Html$main_ = _elm_lang$html$Html$node('main'); -var _elm_lang$html$Html$p = _elm_lang$html$Html$node('p'); -var _elm_lang$html$Html$hr = _elm_lang$html$Html$node('hr'); -var _elm_lang$html$Html$pre = _elm_lang$html$Html$node('pre'); -var _elm_lang$html$Html$blockquote = _elm_lang$html$Html$node('blockquote'); -var _elm_lang$html$Html$ol = _elm_lang$html$Html$node('ol'); -var _elm_lang$html$Html$ul = _elm_lang$html$Html$node('ul'); -var _elm_lang$html$Html$li = _elm_lang$html$Html$node('li'); -var _elm_lang$html$Html$dl = _elm_lang$html$Html$node('dl'); -var _elm_lang$html$Html$dt = _elm_lang$html$Html$node('dt'); -var _elm_lang$html$Html$dd = _elm_lang$html$Html$node('dd'); -var _elm_lang$html$Html$figure = _elm_lang$html$Html$node('figure'); -var _elm_lang$html$Html$figcaption = _elm_lang$html$Html$node('figcaption'); -var _elm_lang$html$Html$div = _elm_lang$html$Html$node('div'); -var _elm_lang$html$Html$a = _elm_lang$html$Html$node('a'); -var _elm_lang$html$Html$em = _elm_lang$html$Html$node('em'); -var _elm_lang$html$Html$strong = _elm_lang$html$Html$node('strong'); -var _elm_lang$html$Html$small = _elm_lang$html$Html$node('small'); -var _elm_lang$html$Html$s = _elm_lang$html$Html$node('s'); -var _elm_lang$html$Html$cite = _elm_lang$html$Html$node('cite'); -var _elm_lang$html$Html$q = _elm_lang$html$Html$node('q'); -var _elm_lang$html$Html$dfn = _elm_lang$html$Html$node('dfn'); -var _elm_lang$html$Html$abbr = _elm_lang$html$Html$node('abbr'); -var _elm_lang$html$Html$time = _elm_lang$html$Html$node('time'); -var _elm_lang$html$Html$code = _elm_lang$html$Html$node('code'); -var _elm_lang$html$Html$var = _elm_lang$html$Html$node('var'); -var _elm_lang$html$Html$samp = _elm_lang$html$Html$node('samp'); -var _elm_lang$html$Html$kbd = _elm_lang$html$Html$node('kbd'); -var _elm_lang$html$Html$sub = _elm_lang$html$Html$node('sub'); -var _elm_lang$html$Html$sup = _elm_lang$html$Html$node('sup'); -var _elm_lang$html$Html$i = _elm_lang$html$Html$node('i'); -var _elm_lang$html$Html$b = _elm_lang$html$Html$node('b'); -var _elm_lang$html$Html$u = _elm_lang$html$Html$node('u'); -var _elm_lang$html$Html$mark = _elm_lang$html$Html$node('mark'); -var _elm_lang$html$Html$ruby = _elm_lang$html$Html$node('ruby'); -var _elm_lang$html$Html$rt = _elm_lang$html$Html$node('rt'); -var _elm_lang$html$Html$rp = _elm_lang$html$Html$node('rp'); -var _elm_lang$html$Html$bdi = _elm_lang$html$Html$node('bdi'); -var _elm_lang$html$Html$bdo = _elm_lang$html$Html$node('bdo'); -var _elm_lang$html$Html$span = _elm_lang$html$Html$node('span'); -var _elm_lang$html$Html$br = _elm_lang$html$Html$node('br'); -var _elm_lang$html$Html$wbr = _elm_lang$html$Html$node('wbr'); -var _elm_lang$html$Html$ins = _elm_lang$html$Html$node('ins'); -var _elm_lang$html$Html$del = _elm_lang$html$Html$node('del'); -var _elm_lang$html$Html$img = _elm_lang$html$Html$node('img'); -var _elm_lang$html$Html$iframe = _elm_lang$html$Html$node('iframe'); -var _elm_lang$html$Html$embed = _elm_lang$html$Html$node('embed'); -var _elm_lang$html$Html$object = _elm_lang$html$Html$node('object'); -var _elm_lang$html$Html$param = _elm_lang$html$Html$node('param'); -var _elm_lang$html$Html$video = _elm_lang$html$Html$node('video'); -var _elm_lang$html$Html$audio = _elm_lang$html$Html$node('audio'); -var _elm_lang$html$Html$source = _elm_lang$html$Html$node('source'); -var _elm_lang$html$Html$track = _elm_lang$html$Html$node('track'); -var _elm_lang$html$Html$canvas = _elm_lang$html$Html$node('canvas'); -var _elm_lang$html$Html$math = _elm_lang$html$Html$node('math'); -var _elm_lang$html$Html$table = _elm_lang$html$Html$node('table'); -var _elm_lang$html$Html$caption = _elm_lang$html$Html$node('caption'); -var _elm_lang$html$Html$colgroup = _elm_lang$html$Html$node('colgroup'); -var _elm_lang$html$Html$col = _elm_lang$html$Html$node('col'); -var _elm_lang$html$Html$tbody = _elm_lang$html$Html$node('tbody'); -var _elm_lang$html$Html$thead = _elm_lang$html$Html$node('thead'); -var _elm_lang$html$Html$tfoot = _elm_lang$html$Html$node('tfoot'); -var _elm_lang$html$Html$tr = _elm_lang$html$Html$node('tr'); -var _elm_lang$html$Html$td = _elm_lang$html$Html$node('td'); -var _elm_lang$html$Html$th = _elm_lang$html$Html$node('th'); -var _elm_lang$html$Html$form = _elm_lang$html$Html$node('form'); -var _elm_lang$html$Html$fieldset = _elm_lang$html$Html$node('fieldset'); -var _elm_lang$html$Html$legend = _elm_lang$html$Html$node('legend'); -var _elm_lang$html$Html$label = _elm_lang$html$Html$node('label'); -var _elm_lang$html$Html$input = _elm_lang$html$Html$node('input'); -var _elm_lang$html$Html$button = _elm_lang$html$Html$node('button'); -var _elm_lang$html$Html$select = _elm_lang$html$Html$node('select'); -var _elm_lang$html$Html$datalist = _elm_lang$html$Html$node('datalist'); -var _elm_lang$html$Html$optgroup = _elm_lang$html$Html$node('optgroup'); -var _elm_lang$html$Html$option = _elm_lang$html$Html$node('option'); -var _elm_lang$html$Html$textarea = _elm_lang$html$Html$node('textarea'); -var _elm_lang$html$Html$keygen = _elm_lang$html$Html$node('keygen'); -var _elm_lang$html$Html$output = _elm_lang$html$Html$node('output'); -var _elm_lang$html$Html$progress = _elm_lang$html$Html$node('progress'); -var _elm_lang$html$Html$meter = _elm_lang$html$Html$node('meter'); -var _elm_lang$html$Html$details = _elm_lang$html$Html$node('details'); -var _elm_lang$html$Html$summary = _elm_lang$html$Html$node('summary'); -var _elm_lang$html$Html$menuitem = _elm_lang$html$Html$node('menuitem'); -var _elm_lang$html$Html$menu = _elm_lang$html$Html$node('menu'); - -var _elm_lang$html$Html_Events$keyCode = A2(_elm_lang$core$Json_Decode$field, 'keyCode', _elm_lang$core$Json_Decode$int); -var _elm_lang$html$Html_Events$targetChecked = A2( - _elm_lang$core$Json_Decode$at, - { - ctor: '::', - _0: 'target', - _1: { - ctor: '::', - _0: 'checked', - _1: {ctor: '[]'} - } - }, - _elm_lang$core$Json_Decode$bool); -var _elm_lang$html$Html_Events$targetValue = A2( - _elm_lang$core$Json_Decode$at, - { - ctor: '::', - _0: 'target', - _1: { - ctor: '::', - _0: 'value', - _1: {ctor: '[]'} - } - }, - _elm_lang$core$Json_Decode$string); -var _elm_lang$html$Html_Events$defaultOptions = _elm_lang$virtual_dom$VirtualDom$defaultOptions; -var _elm_lang$html$Html_Events$onWithOptions = _elm_lang$virtual_dom$VirtualDom$onWithOptions; -var _elm_lang$html$Html_Events$on = _elm_lang$virtual_dom$VirtualDom$on; -var _elm_lang$html$Html_Events$onFocus = function (msg) { - return A2( - _elm_lang$html$Html_Events$on, - 'focus', - _elm_lang$core$Json_Decode$succeed(msg)); -}; -var _elm_lang$html$Html_Events$onBlur = function (msg) { - return A2( - _elm_lang$html$Html_Events$on, - 'blur', - _elm_lang$core$Json_Decode$succeed(msg)); -}; -var _elm_lang$html$Html_Events$onSubmitOptions = _elm_lang$core$Native_Utils.update( - _elm_lang$html$Html_Events$defaultOptions, - {preventDefault: true}); -var _elm_lang$html$Html_Events$onSubmit = function (msg) { - return A3( - _elm_lang$html$Html_Events$onWithOptions, - 'submit', - _elm_lang$html$Html_Events$onSubmitOptions, - _elm_lang$core$Json_Decode$succeed(msg)); -}; -var _elm_lang$html$Html_Events$onCheck = function (tagger) { - return A2( - _elm_lang$html$Html_Events$on, - 'change', - A2(_elm_lang$core$Json_Decode$map, tagger, _elm_lang$html$Html_Events$targetChecked)); -}; -var _elm_lang$html$Html_Events$onInput = function (tagger) { - return A2( - _elm_lang$html$Html_Events$on, - 'input', - A2(_elm_lang$core$Json_Decode$map, tagger, _elm_lang$html$Html_Events$targetValue)); -}; -var _elm_lang$html$Html_Events$onMouseOut = function (msg) { - return A2( - _elm_lang$html$Html_Events$on, - 'mouseout', - _elm_lang$core$Json_Decode$succeed(msg)); -}; -var _elm_lang$html$Html_Events$onMouseOver = function (msg) { - return A2( - _elm_lang$html$Html_Events$on, - 'mouseover', - _elm_lang$core$Json_Decode$succeed(msg)); -}; -var _elm_lang$html$Html_Events$onMouseLeave = function (msg) { - return A2( - _elm_lang$html$Html_Events$on, - 'mouseleave', - _elm_lang$core$Json_Decode$succeed(msg)); -}; -var _elm_lang$html$Html_Events$onMouseEnter = function (msg) { - return A2( - _elm_lang$html$Html_Events$on, - 'mouseenter', - _elm_lang$core$Json_Decode$succeed(msg)); -}; -var _elm_lang$html$Html_Events$onMouseUp = function (msg) { - return A2( - _elm_lang$html$Html_Events$on, - 'mouseup', - _elm_lang$core$Json_Decode$succeed(msg)); -}; -var _elm_lang$html$Html_Events$onMouseDown = function (msg) { - return A2( - _elm_lang$html$Html_Events$on, - 'mousedown', - _elm_lang$core$Json_Decode$succeed(msg)); -}; -var _elm_lang$html$Html_Events$onDoubleClick = function (msg) { - return A2( - _elm_lang$html$Html_Events$on, - 'dblclick', - _elm_lang$core$Json_Decode$succeed(msg)); -}; -var _elm_lang$html$Html_Events$onClick = function (msg) { - return A2( - _elm_lang$html$Html_Events$on, - 'click', - _elm_lang$core$Json_Decode$succeed(msg)); -}; -var _elm_lang$html$Html_Events$Options = F2( - function (a, b) { - return {stopPropagation: a, preventDefault: b}; - }); - -var _Bogdanp$elm_ast$Main$withChild = F2( - function (title, children) { + }; + var $author$project$Ast$Expression$binary = function(ops) { return A2( - _elm_lang$html$Html$li, - {ctor: '[]'}, - { - ctor: '::', - _0: A2( - _elm_lang$html$Html$pre, - {ctor: '[]'}, - { - ctor: '::', - _0: _elm_lang$html$Html$text( - _elm_lang$core$Basics$toString(title)), - _1: {ctor: '[]'} - }), - _1: { - ctor: '::', - _0: A2( - _elm_lang$html$Html$ul, - {ctor: '[]'}, - children), - _1: {ctor: '[]'} - } - }); - }); -var _Bogdanp$elm_ast$Main$expression = function (e) { - var _p0 = e; - switch (_p0.ctor) { - case 'List': + $andre_dietrich$parser_combinators$Combine$andThen, + function(e) { return A2( - _Bogdanp$elm_ast$Main$withChild, - e, - A2(_elm_lang$core$List$map, _Bogdanp$elm_ast$Main$expression, _p0._0)); - case 'Application': + $andre_dietrich$parser_combinators$Combine$andThen, + function(eops) { + return A4( + $author$project$Ast$Expression$split, + ops, + 0, + e, + eops + ); + }, + $author$project$Ast$Expression$successOrEmptyList( + $author$project$Ast$Expression$next_(ops) + ) + ); + }, + $author$project$Ast$Expression$application(ops) + ); + }; + var $author$project$Ast$Expression$caseExpression = function(ops) { + var binding = function(indent) { + return $andre_dietrich$parser_combinators$Combine$lazy(function( + _v12 + ) { return A2( - _Bogdanp$elm_ast$Main$withChild, - e, - { - ctor: '::', - _0: _Bogdanp$elm_ast$Main$expression(_p0._0), - _1: { - ctor: '::', - _0: _Bogdanp$elm_ast$Main$expression(_p0._1), - _1: {ctor: '[]'} - } - }); - default: + $andre_dietrich$parser_combinators$Combine$andMap, + A2( + $andre_dietrich$parser_combinators$Combine$keep, + $author$project$Ast$Expression$expression(ops), + $author$project$Ast$Helpers$symbol("->") + ), + A2( + $andre_dietrich$parser_combinators$Combine$map, + $elm$core$Tuple$pair, + A2( + $andre_dietrich$parser_combinators$Combine$keep, + $author$project$Ast$Pattern$pattern, + $author$project$Ast$Helpers$exactIndentation(indent) + ) + ) + ); + }); + }; + return $andre_dietrich$parser_combinators$Combine$lazy(function( + _v11 + ) { + return $author$project$Ast$Common$withMeta( + A2( + $andre_dietrich$parser_combinators$Combine$andMap, + A2( + $andre_dietrich$parser_combinators$Combine$andThen, + function(indent) { + return $andre_dietrich$parser_combinators$Combine$many1( + binding(indent) + ); + }, + A2( + $andre_dietrich$parser_combinators$Combine$keep, + $andre_dietrich$parser_combinators$Combine$lookAhead( + $author$project$Ast$Helpers$countIndent + ), + A2( + $andre_dietrich$parser_combinators$Combine$keep, + $andre_dietrich$parser_combinators$Combine$string("of"), + $andre_dietrich$parser_combinators$Combine$whitespace + ) + ) + ), + A2( + $andre_dietrich$parser_combinators$Combine$map, + $author$project$Ast$Expression$Case, + A2( + $andre_dietrich$parser_combinators$Combine$keep, + $author$project$Ast$Expression$expression(ops), + $author$project$Ast$Helpers$symbol("case") + ) + ) + ) + ); + }); + }; + var $author$project$Ast$Expression$expression = function(ops) { + return $andre_dietrich$parser_combinators$Combine$lazy(function( + _v10 + ) { + return $andre_dietrich$parser_combinators$Combine$choice( + _List_fromArray([ + $author$project$Ast$Expression$binary(ops), + $author$project$Ast$Expression$letExpression(ops), + $author$project$Ast$Expression$caseExpression(ops), + $author$project$Ast$Expression$ifExpression(ops), + $author$project$Ast$Expression$lambda(ops) + ]) + ); + }); + }; + var $author$project$Ast$Expression$ifExpression = function(ops) { + return $andre_dietrich$parser_combinators$Combine$lazy(function( + _v9 + ) { + return $author$project$Ast$Common$withMeta( + A2( + $andre_dietrich$parser_combinators$Combine$andMap, + A2( + $andre_dietrich$parser_combinators$Combine$keep, + $author$project$Ast$Expression$expression(ops), + $author$project$Ast$Helpers$symbol("else") + ), + A2( + $andre_dietrich$parser_combinators$Combine$andMap, + A2( + $andre_dietrich$parser_combinators$Combine$keep, + $author$project$Ast$Expression$expression(ops), + $author$project$Ast$Helpers$symbol("then") + ), + A2( + $andre_dietrich$parser_combinators$Combine$map, + $author$project$Ast$Expression$If, + A2( + $andre_dietrich$parser_combinators$Combine$keep, + $author$project$Ast$Expression$expression(ops), + $author$project$Ast$Helpers$symbol("if") + ) + ) + ) + ) + ); + }); + }; + var $author$project$Ast$Expression$lambda = function(ops) { + return $andre_dietrich$parser_combinators$Combine$lazy(function( + _v8 + ) { + return $author$project$Ast$Common$withMeta( + A2( + $andre_dietrich$parser_combinators$Combine$andMap, + A2( + $andre_dietrich$parser_combinators$Combine$keep, + $author$project$Ast$Expression$expression(ops), + $author$project$Ast$Helpers$symbol("->") + ), + A2( + $andre_dietrich$parser_combinators$Combine$map, + $author$project$Ast$Expression$Lambda, + A2( + $andre_dietrich$parser_combinators$Combine$keep, + A2( + $andre_dietrich$parser_combinators$Combine$andThen, + A2( + $elm$core$Basics$composeL, + $andre_dietrich$parser_combinators$Combine$succeed, + $author$project$Ast$Pattern$applicationToList + ), + $author$project$Ast$Pattern$pattern + ), + $author$project$Ast$Helpers$symbol("\\") + ) + ) + ) + ); + }); + }; + var $author$project$Ast$Expression$letBinding = function(ops) { + return $andre_dietrich$parser_combinators$Combine$lazy(function( + _v7 + ) { + return A2( + $andre_dietrich$parser_combinators$Combine$andMap, + A2( + $andre_dietrich$parser_combinators$Combine$keep, + $author$project$Ast$Expression$expression(ops), + $author$project$Ast$Helpers$symbol("=") + ), + A2( + $andre_dietrich$parser_combinators$Combine$map, + $elm$core$Tuple$pair, + A2( + $author$project$Ast$Helpers$between_, + $andre_dietrich$parser_combinators$Combine$whitespace, + $author$project$Ast$Pattern$pattern + ) + ) + ); + }); + }; + var $author$project$Ast$Expression$letExpression = function(ops) { + return $andre_dietrich$parser_combinators$Combine$lazy(function( + _v6 + ) { + return $author$project$Ast$Common$withMeta( + A2( + $andre_dietrich$parser_combinators$Combine$andMap, + A2( + $andre_dietrich$parser_combinators$Combine$keep, + $author$project$Ast$Expression$expression(ops), + $author$project$Ast$Helpers$symbol("in") + ), + A2( + $andre_dietrich$parser_combinators$Combine$map, + $author$project$Ast$Expression$Let, + A2( + $andre_dietrich$parser_combinators$Combine$keep, + $andre_dietrich$parser_combinators$Combine$many1( + $author$project$Ast$Expression$letBinding(ops) + ), + $author$project$Ast$Helpers$symbol_("let") + ) + ) + ) + ); + }); + }; + var $author$project$Ast$Expression$list = function(ops) { + return $andre_dietrich$parser_combinators$Combine$lazy(function( + _v5 + ) { + return $author$project$Ast$Common$withMeta( + A2( + $andre_dietrich$parser_combinators$Combine$map, + $author$project$Ast$Expression$List, + $author$project$Ast$Helpers$listParser( + $author$project$Ast$Expression$expression(ops) + ) + ) + ); + }); + }; + var $author$project$Ast$Expression$next_ = function(ops) { + return A2( + $andre_dietrich$parser_combinators$Combine$andThen, + function(o) { return A2( - _elm_lang$html$Html$li, - {ctor: '[]'}, - { - ctor: '::', - _0: A2( - _elm_lang$html$Html$pre, - {ctor: '[]'}, - { - ctor: '::', - _0: _elm_lang$html$Html$text( - _elm_lang$core$Basics$toString(_p0)), - _1: {ctor: '[]'} - }), - _1: {ctor: '[]'} - }); - } -}; -var _Bogdanp$elm_ast$Main$statement = function (s) { - var _p1 = s; - if (_p1.ctor === 'FunctionDeclaration') { + $andre_dietrich$parser_combinators$Combine$andThen, + function(e) { + if (e.$ === "Cont") { + var t = e.a; + return A2( + $andre_dietrich$parser_combinators$Combine$map, + $elm$core$List$cons(_Utils_Tuple2(o, t)), + $author$project$Ast$Expression$successOrEmptyList( + $author$project$Ast$Expression$next_(ops) + ) + ); + } else { + var ex = e.a; + return $andre_dietrich$parser_combinators$Combine$succeed( + _List_fromArray([_Utils_Tuple2(o, ex)]) + ); + } + }, + A2( + $andre_dietrich$parser_combinators$Combine$or, + A2( + $andre_dietrich$parser_combinators$Combine$map, + $author$project$Ast$Expression$Cont, + $author$project$Ast$Expression$application(ops) + ), + A2( + $andre_dietrich$parser_combinators$Combine$map, + $author$project$Ast$Expression$Stop, + $author$project$Ast$Expression$expression(ops) + ) + ) + ); + }, + $author$project$Ast$Common$withMeta( + A2( + $author$project$Ast$Helpers$between_, + $andre_dietrich$parser_combinators$Combine$whitespace, + $author$project$Ast$Helpers$operator + ) + ) + ); + }; + var $author$project$Ast$Expression$record = function(ops) { + return $andre_dietrich$parser_combinators$Combine$lazy(function( + _v3 + ) { + return $author$project$Ast$Common$withMeta( + A2( + $andre_dietrich$parser_combinators$Combine$map, + $author$project$Ast$Expression$Record, + $andre_dietrich$parser_combinators$Combine$braces( + $author$project$Ast$Helpers$commaSeparated( + A2( + $andre_dietrich$parser_combinators$Combine$andMap, + A2( + $andre_dietrich$parser_combinators$Combine$keep, + $author$project$Ast$Expression$expression(ops), + $author$project$Ast$Helpers$symbol("=") + ), + A2( + $andre_dietrich$parser_combinators$Combine$map, + $elm$core$Tuple$pair, + $author$project$Ast$Common$withMeta( + $author$project$Ast$Helpers$loName + ) + ) + ) + ) + ) + ) + ); + }); + }; + var $author$project$Ast$Expression$recordUpdate = function(ops) { + return $andre_dietrich$parser_combinators$Combine$lazy(function( + _v2 + ) { + return $author$project$Ast$Common$withMeta( + A2( + $andre_dietrich$parser_combinators$Combine$andMap, + A2( + $andre_dietrich$parser_combinators$Combine$ignore, + $andre_dietrich$parser_combinators$Combine$string("}"), + A2( + $andre_dietrich$parser_combinators$Combine$keep, + $author$project$Ast$Helpers$commaSeparated( + A2( + $andre_dietrich$parser_combinators$Combine$andMap, + A2( + $andre_dietrich$parser_combinators$Combine$keep, + $author$project$Ast$Expression$expression(ops), + $author$project$Ast$Helpers$symbol("=") + ), + A2( + $andre_dietrich$parser_combinators$Combine$map, + $elm$core$Tuple$pair, + $author$project$Ast$Common$withMeta( + $author$project$Ast$Helpers$loName + ) + ) + ) + ), + $author$project$Ast$Helpers$symbol("|") + ) + ), + A2( + $andre_dietrich$parser_combinators$Combine$map, + $author$project$Ast$Expression$RecordUpdate, + A2( + $andre_dietrich$parser_combinators$Combine$keep, + $author$project$Ast$Common$withMeta( + $author$project$Ast$Helpers$loName + ), + $author$project$Ast$Helpers$symbol("{") + ) + ) + ) + ); + }); + }; + var $author$project$Ast$Expression$term = function(ops) { + return $andre_dietrich$parser_combinators$Combine$lazy(function( + _v1 + ) { + return $andre_dietrich$parser_combinators$Combine$choice( + _List_fromArray([ + $author$project$Ast$Expression$external, + $author$project$Ast$Expression$access, + $author$project$Ast$Expression$variable, + $author$project$Ast$Expression$constructor, + $author$project$Ast$Expression$accessFunction, + $author$project$Ast$Expression$string, + $author$project$Ast$Expression$float, + $author$project$Ast$Expression$integer, + $author$project$Ast$Expression$character, + $andre_dietrich$parser_combinators$Combine$parens( + A2( + $author$project$Ast$Helpers$between_, + $andre_dietrich$parser_combinators$Combine$whitespace, + $author$project$Ast$Expression$expression(ops) + ) + ), + $author$project$Ast$Expression$list(ops), + $author$project$Ast$Expression$tuple(ops), + $author$project$Ast$Expression$recordUpdate(ops), + $author$project$Ast$Expression$record(ops), + $author$project$Ast$Expression$simplifiedRecord + ]) + ); + }); + }; + var $author$project$Ast$Expression$tuple = function(ops) { + return $andre_dietrich$parser_combinators$Combine$lazy(function( + _v0 + ) { + return $author$project$Ast$Common$withMeta( + A2( + $andre_dietrich$parser_combinators$Combine$map, + $author$project$Ast$Expression$Tuple, + $author$project$Ast$Helpers$tupleParser( + $author$project$Ast$Expression$expression(ops) + ) + ) + ); + }); + }; + var $author$project$Ast$Statement$functionDeclaration = function( + ops + ) { return A2( - _Bogdanp$elm_ast$Main$withChild, - s, - { - ctor: '::', - _0: _Bogdanp$elm_ast$Main$expression(_p1._2), - _1: {ctor: '[]'} - }); - } else { + $andre_dietrich$parser_combinators$Combine$andThen, + function(full) { + var decl = full.a; + _v0$2: while (true) { + if (decl.$ === "FunctionDeclaration") { + switch (decl.a.a.$) { + case "PVariable": + var _v1 = decl.a; + return $andre_dietrich$parser_combinators$Combine$succeed( + full + ); + case "PApplication": + var _v2 = decl.a; + var _v3 = _v2.a; + return $andre_dietrich$parser_combinators$Combine$succeed( + full + ); + default: + break _v0$2; + } + } else { + break _v0$2; + } + } + return $andre_dietrich$parser_combinators$Combine$fail( + "wrong pattern in function declaration" + ); + }, + $author$project$Ast$Common$withMeta( + A2( + $andre_dietrich$parser_combinators$Combine$andMap, + A2( + $andre_dietrich$parser_combinators$Combine$keep, + $author$project$Ast$Expression$expression(ops), + A2( + $andre_dietrich$parser_combinators$Combine$keep, + $andre_dietrich$parser_combinators$Combine$whitespace, + $author$project$Ast$Helpers$symbol("=") + ) + ), + A2( + $andre_dietrich$parser_combinators$Combine$map, + $author$project$Ast$Statement$FunctionDeclaration, + $author$project$Ast$Pattern$pattern + ) + ) + ) + ); + }; + var $author$project$Ast$Statement$FunctionTypeDeclaration = F2( + function(a, b) { + return { $: "FunctionTypeDeclaration", a: a, b: b }; + } + ); + var $author$project$Ast$Statement$TypeConstructor = F2(function( + a, + b + ) { + return { $: "TypeConstructor", a: a, b: b }; + }); + var $author$project$Ast$Statement$TypeRecord = function(a) { + return { $: "TypeRecord", a: a }; + }; + var $author$project$Ast$Statement$TypeRecordConstructor = F2(function( + a, + b + ) { + return { $: "TypeRecordConstructor", a: a, b: b }; + }); + var $author$project$Ast$Statement$TypeTuple = function(a) { + return { $: "TypeTuple", a: a }; + }; + var $andre_dietrich$parser_combinators$Combine$chainr = F2(function( + op, + p + ) { + var accumulate = function(x) { + return A2( + $andre_dietrich$parser_combinators$Combine$or, + A2( + $andre_dietrich$parser_combinators$Combine$andThen, + function(f) { + return A2( + $andre_dietrich$parser_combinators$Combine$andThen, + function(y) { + return $andre_dietrich$parser_combinators$Combine$succeed( + A2(f, x, y) + ); + }, + A2( + $andre_dietrich$parser_combinators$Combine$andThen, + accumulate, + p + ) + ); + }, + op + ), + $andre_dietrich$parser_combinators$Combine$succeed(x) + ); + }; return A2( - _elm_lang$html$Html$li, - {ctor: '[]'}, - { - ctor: '::', - _0: A2( - _elm_lang$html$Html$pre, - {ctor: '[]'}, - { - ctor: '::', - _0: _elm_lang$html$Html$text( - _elm_lang$core$Basics$toString(_p1)), - _1: {ctor: '[]'} - }), - _1: {ctor: '[]'} - }); - } -}; -var _Bogdanp$elm_ast$Main$tree = function (m) { - var _p2 = _Bogdanp$elm_ast$Ast$parse(m); - if ((_p2.ctor === 'Ok') && (_p2._0.ctor === '_Tuple3')) { + $andre_dietrich$parser_combinators$Combine$andThen, + accumulate, + p + ); + }); + var $author$project$Ast$Statement$TypeApplication = F2(function( + a, + b + ) { + return { $: "TypeApplication", a: a, b: b }; + }); + var $author$project$Ast$Statement$typeApplication = A2( + $andre_dietrich$parser_combinators$Combine$onsuccess, + $author$project$Ast$Statement$TypeApplication, + $author$project$Ast$Helpers$symbol("->") + ); + var $author$project$Ast$Statement$typeConstant = A2( + $andre_dietrich$parser_combinators$Combine$andMap, + $andre_dietrich$parser_combinators$Combine$succeed(_List_Nil), + A2( + $andre_dietrich$parser_combinators$Combine$map, + $author$project$Ast$Statement$TypeConstructor, + A2( + $andre_dietrich$parser_combinators$Combine$sepBy1, + $andre_dietrich$parser_combinators$Combine$string("."), + $author$project$Ast$Helpers$upName + ) + ) + ); + var $author$project$Ast$Statement$TypeVariable = function(a) { + return { $: "TypeVariable", a: a }; + }; + var $author$project$Ast$Statement$typeVariable = A2( + $andre_dietrich$parser_combinators$Combine$map, + $author$project$Ast$Statement$TypeVariable, + $andre_dietrich$parser_combinators$Combine$regex("[a-z]+(\\w|_)*") + ); + function $author$project$Ast$Statement$cyclic$typeAnnotation() { + return $andre_dietrich$parser_combinators$Combine$lazy(function( + _v8 + ) { + return A2( + $andre_dietrich$parser_combinators$Combine$chainr, + $author$project$Ast$Statement$typeApplication, + $author$project$Ast$Statement$cyclic$type_() + ); + }); + } + function $author$project$Ast$Statement$cyclic$typeConstructor() { + return $andre_dietrich$parser_combinators$Combine$lazy(function( + _v7 + ) { + return A2( + $andre_dietrich$parser_combinators$Combine$andMap, + $andre_dietrich$parser_combinators$Combine$many( + $author$project$Ast$Statement$cyclic$typeParameter() + ), + A2( + $andre_dietrich$parser_combinators$Combine$map, + $author$project$Ast$Statement$TypeConstructor, + A2( + $andre_dietrich$parser_combinators$Combine$sepBy1, + $andre_dietrich$parser_combinators$Combine$string("."), + $author$project$Ast$Helpers$upName + ) + ) + ); + }); + } + function $author$project$Ast$Statement$cyclic$typeParameter() { + return $andre_dietrich$parser_combinators$Combine$lazy(function( + _v6 + ) { + return A2( + $author$project$Ast$Helpers$between_, + A2( + $andre_dietrich$parser_combinators$Combine$or, + A2( + $andre_dietrich$parser_combinators$Combine$keep, + $author$project$Ast$Helpers$spaces_, + A2( + $andre_dietrich$parser_combinators$Combine$keep, + $andre_dietrich$parser_combinators$Combine$Char$newline, + $author$project$Ast$Helpers$spaces + ) + ), + $author$project$Ast$Helpers$spaces + ), + $andre_dietrich$parser_combinators$Combine$choice( + _List_fromArray([ + $author$project$Ast$Statement$typeVariable, + $author$project$Ast$Statement$typeConstant, + $author$project$Ast$Statement$cyclic$typeRecordConstructor(), + $author$project$Ast$Statement$cyclic$typeRecord(), + $author$project$Ast$Statement$cyclic$typeTuple(), + $andre_dietrich$parser_combinators$Combine$parens( + $author$project$Ast$Statement$cyclic$typeAnnotation() + ) + ]) + ) + ); + }); + } + function $author$project$Ast$Statement$cyclic$typeRecord() { + return $andre_dietrich$parser_combinators$Combine$lazy(function( + _v5 + ) { + return $andre_dietrich$parser_combinators$Combine$braces( + A2( + $andre_dietrich$parser_combinators$Combine$map, + $author$project$Ast$Statement$TypeRecord, + $author$project$Ast$Statement$cyclic$typeRecordPairs() + ) + ); + }); + } + function $author$project$Ast$Statement$cyclic$typeRecordConstructor() { + return $andre_dietrich$parser_combinators$Combine$lazy(function( + _v4 + ) { + return $andre_dietrich$parser_combinators$Combine$braces( + A2( + $andre_dietrich$parser_combinators$Combine$andMap, + A2( + $andre_dietrich$parser_combinators$Combine$ignore, + $author$project$Ast$Helpers$symbol("|"), + $author$project$Ast$Statement$cyclic$typeRecordPairs() + ), + A2( + $andre_dietrich$parser_combinators$Combine$map, + $author$project$Ast$Statement$TypeRecordConstructor, + A2( + $author$project$Ast$Helpers$between_, + $author$project$Ast$Helpers$spaces, + $author$project$Ast$Statement$typeVariable + ) + ) + ) + ); + }); + } + function $author$project$Ast$Statement$cyclic$typeRecordPair() { + return $andre_dietrich$parser_combinators$Combine$lazy(function( + _v3 + ) { + return A2( + $andre_dietrich$parser_combinators$Combine$andMap, + $author$project$Ast$Statement$cyclic$typeAnnotation(), + A2( + $andre_dietrich$parser_combinators$Combine$map, + $elm$core$Tuple$pair, + A2( + $andre_dietrich$parser_combinators$Combine$ignore, + $author$project$Ast$Helpers$symbol(":"), + $author$project$Ast$Helpers$loName + ) + ) + ); + }); + } + function $author$project$Ast$Statement$cyclic$typeRecordPairs() { + return $andre_dietrich$parser_combinators$Combine$lazy(function( + _v2 + ) { + return $author$project$Ast$Helpers$commaSeparated_( + $author$project$Ast$Statement$cyclic$typeRecordPair() + ); + }); + } + function $author$project$Ast$Statement$cyclic$typeTuple() { + return $andre_dietrich$parser_combinators$Combine$lazy(function( + _v1 + ) { + return A2( + $andre_dietrich$parser_combinators$Combine$map, + $author$project$Ast$Statement$TypeTuple, + $andre_dietrich$parser_combinators$Combine$parens( + $author$project$Ast$Helpers$commaSeparated_( + $author$project$Ast$Statement$cyclic$type_() + ) + ) + ); + }); + } + function $author$project$Ast$Statement$cyclic$type_() { + return $andre_dietrich$parser_combinators$Combine$lazy(function( + _v0 + ) { + return A2( + $author$project$Ast$Helpers$between_, + $author$project$Ast$Helpers$spaces, + $andre_dietrich$parser_combinators$Combine$choice( + _List_fromArray([ + $author$project$Ast$Statement$cyclic$typeConstructor(), + $author$project$Ast$Statement$typeVariable, + $author$project$Ast$Statement$cyclic$typeRecordConstructor(), + $author$project$Ast$Statement$cyclic$typeRecord(), + $author$project$Ast$Statement$cyclic$typeTuple(), + $andre_dietrich$parser_combinators$Combine$parens( + $author$project$Ast$Statement$cyclic$typeAnnotation() + ) + ]) + ) + ); + }); + } + try { + var $author$project$Ast$Statement$typeAnnotation = $author$project$Ast$Statement$cyclic$typeAnnotation(); + $author$project$Ast$Statement$cyclic$typeAnnotation = function() { + return $author$project$Ast$Statement$typeAnnotation; + }; + var $author$project$Ast$Statement$typeConstructor = $author$project$Ast$Statement$cyclic$typeConstructor(); + $author$project$Ast$Statement$cyclic$typeConstructor = function() { + return $author$project$Ast$Statement$typeConstructor; + }; + var $author$project$Ast$Statement$typeParameter = $author$project$Ast$Statement$cyclic$typeParameter(); + $author$project$Ast$Statement$cyclic$typeParameter = function() { + return $author$project$Ast$Statement$typeParameter; + }; + var $author$project$Ast$Statement$typeRecord = $author$project$Ast$Statement$cyclic$typeRecord(); + $author$project$Ast$Statement$cyclic$typeRecord = function() { + return $author$project$Ast$Statement$typeRecord; + }; + var $author$project$Ast$Statement$typeRecordConstructor = $author$project$Ast$Statement$cyclic$typeRecordConstructor(); + $author$project$Ast$Statement$cyclic$typeRecordConstructor = function() { + return $author$project$Ast$Statement$typeRecordConstructor; + }; + var $author$project$Ast$Statement$typeRecordPair = $author$project$Ast$Statement$cyclic$typeRecordPair(); + $author$project$Ast$Statement$cyclic$typeRecordPair = function() { + return $author$project$Ast$Statement$typeRecordPair; + }; + var $author$project$Ast$Statement$typeRecordPairs = $author$project$Ast$Statement$cyclic$typeRecordPairs(); + $author$project$Ast$Statement$cyclic$typeRecordPairs = function() { + return $author$project$Ast$Statement$typeRecordPairs; + }; + var $author$project$Ast$Statement$typeTuple = $author$project$Ast$Statement$cyclic$typeTuple(); + $author$project$Ast$Statement$cyclic$typeTuple = function() { + return $author$project$Ast$Statement$typeTuple; + }; + var $author$project$Ast$Statement$type_ = $author$project$Ast$Statement$cyclic$type_(); + $author$project$Ast$Statement$cyclic$type_ = function() { + return $author$project$Ast$Statement$type_; + }; + } catch ($) { + throw "Some top-level definitions from `Ast.Statement` are causing infinite recursion:\n\n ┌─────┐\n │ typeAnnotation\n │ ↓\n │ typeConstructor\n │ ↓\n │ typeParameter\n │ ↓\n │ typeRecord\n │ ↓\n │ typeRecordConstructor\n │ ↓\n │ typeRecordPair\n │ ↓\n │ typeRecordPairs\n │ ↓\n │ typeTuple\n │ ↓\n │ type_\n └─────┘\n\nThese errors are very tricky, so read https://elm-lang.org/0.19.1/bad-recursion to learn how to fix it!"; + } + var $author$project$Ast$Statement$functionTypeDeclaration = $author$project$Ast$Common$withMeta( + A2( + $andre_dietrich$parser_combinators$Combine$andMap, + $author$project$Ast$Statement$typeAnnotation, + A2( + $andre_dietrich$parser_combinators$Combine$map, + $author$project$Ast$Statement$FunctionTypeDeclaration, + A2( + $andre_dietrich$parser_combinators$Combine$ignore, + $author$project$Ast$Helpers$symbol(":"), + $author$project$Ast$Helpers$funName + ) + ) + ) + ); + var $author$project$Ast$Statement$ImportStatement = F3(function( + a, + b, + c + ) { + return { $: "ImportStatement", a: a, b: b, c: c }; + }); + var $author$project$Ast$Statement$importStatement = $author$project$Ast$Common$withMeta( + A2( + $andre_dietrich$parser_combinators$Combine$andMap, + $andre_dietrich$parser_combinators$Combine$maybe( + A2( + $andre_dietrich$parser_combinators$Combine$keep, + $author$project$Ast$Statement$exports, + $author$project$Ast$Helpers$symbol("exposing") + ) + ), + A2( + $andre_dietrich$parser_combinators$Combine$andMap, + $andre_dietrich$parser_combinators$Combine$maybe( + A2( + $andre_dietrich$parser_combinators$Combine$keep, + $author$project$Ast$Helpers$upName, + $author$project$Ast$Helpers$symbol("as") + ) + ), + A2( + $andre_dietrich$parser_combinators$Combine$map, + $author$project$Ast$Statement$ImportStatement, + A2( + $andre_dietrich$parser_combinators$Combine$keep, + $author$project$Ast$Helpers$moduleName, + $author$project$Ast$Helpers$initialSymbol("import") + ) + ) + ) + ) + ); + var $author$project$Ast$Statement$InfixDeclaration = F3(function( + a, + b, + c + ) { + return { $: "InfixDeclaration", a: a, b: b, c: c }; + }); + var $author$project$Ast$Statement$infixDeclaration = $author$project$Ast$Common$withMeta( + A2( + $andre_dietrich$parser_combinators$Combine$andMap, + A2( + $andre_dietrich$parser_combinators$Combine$keep, + A2( + $andre_dietrich$parser_combinators$Combine$or, + $author$project$Ast$Helpers$loName, + $author$project$Ast$Helpers$operator + ), + $author$project$Ast$Helpers$spaces + ), + A2( + $andre_dietrich$parser_combinators$Combine$andMap, + A2( + $andre_dietrich$parser_combinators$Combine$keep, + $andre_dietrich$parser_combinators$Combine$Num$int, + $author$project$Ast$Helpers$spaces + ), + A2( + $andre_dietrich$parser_combinators$Combine$map, + $author$project$Ast$Statement$InfixDeclaration, + $andre_dietrich$parser_combinators$Combine$choice( + _List_fromArray([ + A2( + $andre_dietrich$parser_combinators$Combine$onsuccess, + $author$project$Ast$BinOp$L, + $author$project$Ast$Helpers$initialSymbol("infixl") + ), + A2( + $andre_dietrich$parser_combinators$Combine$onsuccess, + $author$project$Ast$BinOp$R, + $author$project$Ast$Helpers$initialSymbol("infixr") + ), + A2( + $andre_dietrich$parser_combinators$Combine$onsuccess, + $author$project$Ast$BinOp$N, + $author$project$Ast$Helpers$initialSymbol("infix") + ) + ]) + ) + ) + ) + ) + ); + var $author$project$Ast$Statement$ModuleDeclaration = F2(function( + a, + b + ) { + return { $: "ModuleDeclaration", a: a, b: b }; + }); + var $author$project$Ast$Statement$moduleDeclaration = $author$project$Ast$Common$withMeta( + A2( + $andre_dietrich$parser_combinators$Combine$andMap, + A2( + $andre_dietrich$parser_combinators$Combine$keep, + $author$project$Ast$Statement$exports, + $author$project$Ast$Helpers$symbol("exposing") + ), + A2( + $andre_dietrich$parser_combinators$Combine$map, + $author$project$Ast$Statement$ModuleDeclaration, + A2( + $andre_dietrich$parser_combinators$Combine$keep, + $author$project$Ast$Helpers$moduleName, + $author$project$Ast$Helpers$initialSymbol("module") + ) + ) + ) + ); + var $author$project$Ast$Statement$PortDeclaration = F3(function( + a, + b, + c + ) { + return { $: "PortDeclaration", a: a, b: b, c: c }; + }); + var $author$project$Ast$Statement$portDeclaration = function(ops) { + return $author$project$Ast$Common$withMeta( + A2( + $andre_dietrich$parser_combinators$Combine$andMap, + A2( + $andre_dietrich$parser_combinators$Combine$keep, + $author$project$Ast$Expression$expression(ops), + $author$project$Ast$Helpers$symbol("=") + ), + A2( + $andre_dietrich$parser_combinators$Combine$andMap, + $andre_dietrich$parser_combinators$Combine$many( + A2( + $author$project$Ast$Helpers$between_, + $author$project$Ast$Helpers$spaces, + $author$project$Ast$Helpers$loName + ) + ), + A2( + $andre_dietrich$parser_combinators$Combine$map, + $author$project$Ast$Statement$PortDeclaration, + A2( + $andre_dietrich$parser_combinators$Combine$keep, + $author$project$Ast$Helpers$loName, + $author$project$Ast$Helpers$initialSymbol("port") + ) + ) + ) + ) + ); + }; + var $author$project$Ast$Statement$PortModuleDeclaration = F2(function( + a, + b + ) { + return { $: "PortModuleDeclaration", a: a, b: b }; + }); + var $author$project$Ast$Statement$portModuleDeclaration = $author$project$Ast$Common$withMeta( + A2( + $andre_dietrich$parser_combinators$Combine$andMap, + A2( + $andre_dietrich$parser_combinators$Combine$keep, + $author$project$Ast$Statement$exports, + $author$project$Ast$Helpers$symbol("exposing") + ), + A2( + $andre_dietrich$parser_combinators$Combine$map, + $author$project$Ast$Statement$PortModuleDeclaration, + A2( + $andre_dietrich$parser_combinators$Combine$keep, + $author$project$Ast$Helpers$moduleName, + A2( + $andre_dietrich$parser_combinators$Combine$keep, + $author$project$Ast$Helpers$symbol("module"), + $author$project$Ast$Helpers$initialSymbol("port") + ) + ) + ) + ) + ); + var $author$project$Ast$Statement$PortTypeDeclaration = F2(function( + a, + b + ) { + return { $: "PortTypeDeclaration", a: a, b: b }; + }); + var $author$project$Ast$Statement$portTypeDeclaration = $author$project$Ast$Common$withMeta( + A2( + $andre_dietrich$parser_combinators$Combine$andMap, + A2( + $andre_dietrich$parser_combinators$Combine$keep, + $author$project$Ast$Statement$typeAnnotation, + $author$project$Ast$Helpers$symbol(":") + ), + A2( + $andre_dietrich$parser_combinators$Combine$map, + $author$project$Ast$Statement$PortTypeDeclaration, + A2( + $andre_dietrich$parser_combinators$Combine$keep, + $author$project$Ast$Helpers$loName, + $author$project$Ast$Helpers$initialSymbol("port") + ) + ) + ) + ); + var $author$project$Ast$Statement$TypeAliasDeclaration = F2(function( + a, + b + ) { + return { $: "TypeAliasDeclaration", a: a, b: b }; + }); + var $author$project$Ast$Statement$typeAliasDeclaration = $author$project$Ast$Common$withMeta( + A2( + $andre_dietrich$parser_combinators$Combine$andMap, + A2( + $andre_dietrich$parser_combinators$Combine$keep, + $author$project$Ast$Statement$typeAnnotation, + A2( + $andre_dietrich$parser_combinators$Combine$keep, + $author$project$Ast$Helpers$symbol("="), + $andre_dietrich$parser_combinators$Combine$whitespace + ) + ), + A2( + $andre_dietrich$parser_combinators$Combine$map, + $author$project$Ast$Statement$TypeAliasDeclaration, + A2( + $andre_dietrich$parser_combinators$Combine$keep, + $author$project$Ast$Statement$type_, + A2( + $andre_dietrich$parser_combinators$Combine$keep, + $author$project$Ast$Helpers$symbol("alias"), + $author$project$Ast$Helpers$initialSymbol("type") + ) + ) + ) + ) + ); + var $author$project$Ast$Statement$TypeDeclaration = F2(function( + a, + b + ) { + return { $: "TypeDeclaration", a: a, b: b }; + }); + var $author$project$Ast$Statement$typeDeclaration = $author$project$Ast$Common$withMeta( + A2( + $andre_dietrich$parser_combinators$Combine$andMap, + A2( + $andre_dietrich$parser_combinators$Combine$keep, + A2( + $andre_dietrich$parser_combinators$Combine$sepBy1, + $author$project$Ast$Helpers$symbol("|"), + A2( + $author$project$Ast$Helpers$between_, + $andre_dietrich$parser_combinators$Combine$whitespace, + $author$project$Ast$Statement$typeConstructor + ) + ), + A2( + $andre_dietrich$parser_combinators$Combine$keep, + $author$project$Ast$Helpers$symbol("="), + $andre_dietrich$parser_combinators$Combine$whitespace + ) + ), + A2( + $andre_dietrich$parser_combinators$Combine$map, + $author$project$Ast$Statement$TypeDeclaration, + A2( + $andre_dietrich$parser_combinators$Combine$keep, + $author$project$Ast$Statement$type_, + $author$project$Ast$Helpers$initialSymbol("type") + ) + ) + ) + ); + var $author$project$Ast$Statement$statement = function(ops) { + return $andre_dietrich$parser_combinators$Combine$lazy(function( + _v0 + ) { + return $andre_dietrich$parser_combinators$Combine$choice( + _List_fromArray([ + $author$project$Ast$Statement$portModuleDeclaration, + $author$project$Ast$Statement$effectModuleDeclaration, + $author$project$Ast$Statement$moduleDeclaration, + $author$project$Ast$Statement$importStatement, + $author$project$Ast$Statement$typeAliasDeclaration, + $author$project$Ast$Statement$typeDeclaration, + $author$project$Ast$Statement$portTypeDeclaration, + $author$project$Ast$Statement$portDeclaration(ops), + $author$project$Ast$Statement$functionTypeDeclaration, + $author$project$Ast$Statement$functionDeclaration(ops), + $author$project$Ast$Statement$infixDeclaration, + $author$project$Ast$Statement$comment + ]) + ); + }); + }; + var $author$project$Ast$Statement$statements = function(ops) { return A2( - _elm_lang$html$Html$ul, - {ctor: '[]'}, - A2(_elm_lang$core$List$map, _Bogdanp$elm_ast$Main$statement, _p2._0._2)); - } else { + $andre_dietrich$parser_combinators$Combine$manyTill, + A2( + $andre_dietrich$parser_combinators$Combine$ignore, + A2( + $andre_dietrich$parser_combinators$Combine$or, + $andre_dietrich$parser_combinators$Combine$whitespace, + $author$project$Ast$Helpers$spaces + ), + A2( + $andre_dietrich$parser_combinators$Combine$keep, + $author$project$Ast$Statement$statement(ops), + A2( + $andre_dietrich$parser_combinators$Combine$or, + $andre_dietrich$parser_combinators$Combine$whitespace, + $author$project$Ast$Helpers$spaces + ) + ) + ), + $andre_dietrich$parser_combinators$Combine$end + ); + }; + var $author$project$Ast$parseModule = function(ops) { + return $andre_dietrich$parser_combinators$Combine$parse( + $author$project$Ast$Statement$statements(ops) + ); + }; + var $author$project$Ast$Statement$infixStatements = (function() { + var statements_ = A2( + $andre_dietrich$parser_combinators$Combine$ignore, + $andre_dietrich$parser_combinators$Combine$end, + $andre_dietrich$parser_combinators$Combine$many( + A2( + $andre_dietrich$parser_combinators$Combine$ignore, + $andre_dietrich$parser_combinators$Combine$whitespace, + $andre_dietrich$parser_combinators$Combine$choice( + _List_fromArray([ + A2( + $andre_dietrich$parser_combinators$Combine$map, + $elm$core$Maybe$Just, + $author$project$Ast$Statement$infixDeclaration + ), + A2( + $andre_dietrich$parser_combinators$Combine$onsuccess, + $elm$core$Maybe$Nothing, + $andre_dietrich$parser_combinators$Combine$regex(".*") + ) + ]) + ) + ) + ) + ); return A2( - _elm_lang$html$Html$div, - {ctor: '[]'}, - { - ctor: '::', - _0: _elm_lang$html$Html$text( - _elm_lang$core$Basics$toString(_p2)), - _1: {ctor: '[]'} - }); - } -}; -var _Bogdanp$elm_ast$Main$update = F2( - function (action, model) { - var _p3 = action; - return _p3._0; - }); -var _Bogdanp$elm_ast$Main$init = 'module Main exposing (..)\n\nf : Int -> Int\nf x = x + 1\n\ng : Int -> Int\ng x = x * 2\n\nh = f << g\n'; -var _Bogdanp$elm_ast$Main$Replace = function (a) { - return {ctor: 'Replace', _0: a}; -}; -var _Bogdanp$elm_ast$Main$view = function (model) { - return A2( - _elm_lang$html$Html$div, - {ctor: '[]'}, - { - ctor: '::', - _0: A2( - _elm_lang$html$Html$textarea, - { - ctor: '::', - _0: A2( - _elm_lang$html$Html_Events$on, - 'input', - A2(_elm_lang$core$Json_Decode$map, _Bogdanp$elm_ast$Main$Replace, _elm_lang$html$Html_Events$targetValue)), - _1: {ctor: '[]'} - }, - { - ctor: '::', - _0: _elm_lang$html$Html$text(model), - _1: {ctor: '[]'} - }), - _1: { - ctor: '::', - _0: _Bogdanp$elm_ast$Main$tree(model), - _1: {ctor: '[]'} - } + $andre_dietrich$parser_combinators$Combine$andThen, + function(xs) { + return $andre_dietrich$parser_combinators$Combine$succeed( + A2($elm$core$List$filterMap, $elm$core$Basics$identity, xs) + ); + }, + statements_ + ); + })(); + var $elm$core$Debug$todo = _Debug_todo; + var $author$project$Ast$Statement$opTable = function(ops) { + var collect = F2(function(_v1, d) { + var s = _v1.a; + if (s.$ === "InfixDeclaration") { + var a = s.a; + var l = s.b; + var n = s.c; + return A3($elm$core$Dict$insert, n, _Utils_Tuple2(a, l), d); + } else { + return _Debug_todo("Ast.Statement", { + start: { line: 449, column: 21 }, + end: { line: 449, column: 31 } + })("impossible"); + } }); -}; -var _Bogdanp$elm_ast$Main$main = _elm_lang$html$Html$beginnerProgram( - {model: _Bogdanp$elm_ast$Main$init, update: _Bogdanp$elm_ast$Main$update, view: _Bogdanp$elm_ast$Main$view})(); - -var Elm = {}; -Elm['Main'] = Elm['Main'] || {}; -if (typeof _Bogdanp$elm_ast$Main$main !== 'undefined') { - _Bogdanp$elm_ast$Main$main(Elm['Main'], 'Main', undefined); -} - -if (typeof define === "function" && define['amd']) -{ - define([], function() { return Elm; }); - return; -} - -if (typeof module === "object") -{ - module['exports'] = Elm; - return; -} - -var globalElm = this['Elm']; -if (typeof globalElm === "undefined") -{ - this['Elm'] = Elm; - return; -} - -for (var publicModule in Elm) -{ - if (publicModule in globalElm) - { - throw new Error('There are two Elm modules called `' + publicModule + '` on this page! Rename one of them.'); + return A2( + $andre_dietrich$parser_combinators$Combine$andThen, + function(xs) { + return $andre_dietrich$parser_combinators$Combine$succeed( + A3($elm$core$List$foldr, collect, ops, xs) + ); + }, + $author$project$Ast$Statement$infixStatements + ); + }; + var $author$project$Ast$parseOpTable = function(ops) { + return $andre_dietrich$parser_combinators$Combine$parse( + $author$project$Ast$Statement$opTable(ops) + ); + }; + var $author$project$Ast$parse = function(input) { + var _v0 = A2( + $author$project$Ast$parseOpTable, + $author$project$Ast$BinOp$operators, + input + ); + if (_v0.$ === "Ok") { + var _v1 = _v0.a; + var state = _v1.a; + var stream = _v1.b; + var ops = _v1.c; + return A2($author$project$Ast$parseModule, ops, input); + } else { + var e = _v0.a; + return $elm$core$Result$Err(e); + } + }; + var $elm$html$Html$li = _VirtualDom_node("li"); + var $elm$html$Html$pre = _VirtualDom_node("pre"); + var $elm$core$Debug$toString = _Debug_toString; + var $elm$html$Html$ul = _VirtualDom_node("ul"); + var $author$project$Main$withChild = F2(function(title, children) { + return A2( + $elm$html$Html$li, + _List_Nil, + _List_fromArray([ + A2( + $elm$html$Html$pre, + _List_Nil, + _List_fromArray([ + $elm$html$Html$text($elm$core$Debug$toString(title)) + ]) + ), + A2($elm$html$Html$ul, _List_Nil, children) + ]) + ); + }); + var $author$project$Main$expression = function(e) { + var _v0 = e.a; + switch (_v0.$) { + case "List": + var es = _v0.a; + return A2( + $author$project$Main$withChild, + e, + A2($elm$core$List$map, $author$project$Main$expression, es) + ); + case "Application": + var e1 = _v0.a; + var e2 = _v0.b; + return A2( + $author$project$Main$withChild, + e, + _List_fromArray([ + $author$project$Main$expression(e1), + $author$project$Main$expression(e2) + ]) + ); + default: + var e_ = _v0; + return A2( + $elm$html$Html$li, + _List_Nil, + _List_fromArray([ + A2( + $elm$html$Html$pre, + _List_Nil, + _List_fromArray([ + $elm$html$Html$text($elm$core$Debug$toString(e)) + ]) + ) + ]) + ); + } + }; + var $author$project$Main$statement = function(_v0) { + var s = _v0.a; + if (s.$ === "FunctionDeclaration") { + var e = s.b; + return A2( + $author$project$Main$withChild, + s, + _List_fromArray([$author$project$Main$expression(e)]) + ); + } else { + var s_ = s; + return A2( + $elm$html$Html$li, + _List_Nil, + _List_fromArray([ + A2( + $elm$html$Html$pre, + _List_Nil, + _List_fromArray([ + $elm$html$Html$text($elm$core$Debug$toString(s)) + ]) + ) + ]) + ); + } + }; + var $author$project$Main$tree = function(m) { + var _v0 = $author$project$Ast$parse(m); + if (_v0.$ === "Ok") { + var _v1 = _v0.a; + var statements = _v1.c; + return A2( + $elm$html$Html$ul, + _List_Nil, + A2( + $elm$core$List$map, + $author$project$Main$statement, + statements + ) + ); + } else { + var err = _v0; + return A2( + $elm$html$Html$div, + _List_Nil, + _List_fromArray([ + $elm$html$Html$text($elm$core$Debug$toString(err)) + ]) + ); + } + }; + var $author$project$Main$view = function(model) { + return A2( + $elm$html$Html$div, + _List_Nil, + _List_fromArray([ + A2( + $elm$html$Html$textarea, + _List_fromArray([ + A2( + $elm$html$Html$Events$on, + "input", + A2( + $elm$json$Json$Decode$map, + $author$project$Main$Replace, + $elm$html$Html$Events$targetValue + ) + ) + ]), + _List_fromArray([$elm$html$Html$text(model)]) + ), + $author$project$Main$tree(model) + ]) + ); + }; + var $author$project$Main$main = $elm$browser$Browser$sandbox({ + init: $author$project$Main$init, + update: $author$project$Main$update, + view: $author$project$Main$view + }); + _Platform_export({ + Main: { + init: $author$project$Main$main( + $elm$json$Json$Decode$succeed(_Utils_Tuple0) + )(0) + } + }); + })(this); + + var app = Elm.Main.init({ node: document.getElementById("elm") }); + } catch (e) { + // display initialization errors (e.g. bad flags, infinite recursion) + var header = document.createElement("h1"); + header.style.fontFamily = "monospace"; + header.innerText = "Initialization Error"; + var pre = document.getElementById("elm"); + document.body.insertBefore(header, pre); + pre.innerText = e; + throw e; } - globalElm[publicModule] = Elm[publicModule]; -} - -}).call(this); - diff --git a/example/elm.json b/example/elm.json new file mode 100644 index 0000000..8722010 --- /dev/null +++ b/example/elm.json @@ -0,0 +1,30 @@ +{ + "type": "application", + "source-directories": [ + ".", + "../src" + ], + "elm-version": "0.19.1", + "dependencies": { + "direct": { + "andre-dietrich/parser-combinators": "3.2.0", + "elm/browser": "1.0.2", + "elm/core": "1.0.2", + "elm/html": "1.0.0", + "elm/json": "1.1.3", + "elm-community/list-extra": "8.2.2", + "pilatch/flip": "1.0.0", + "rtfeldman/elm-hex": "1.0.0" + }, + "indirect": { + "elm/regex": "1.0.0", + "elm/time": "1.0.0", + "elm/url": "1.0.0", + "elm/virtual-dom": "1.0.2" + } + }, + "test-dependencies": { + "direct": {}, + "indirect": {} + } +} diff --git a/example/index.html b/example/index.html index 5cea5ff..6e269f1 100644 --- a/example/index.html +++ b/example/index.html @@ -1,21 +1,24 @@ + + + Main + + 

+
     
-    
   
 
diff --git a/src/Ast.elm b/src/Ast.elm
index 80a8b71..a136c70 100644
--- a/src/Ast.elm
+++ b/src/Ast.elm
@@ -14,47 +14,47 @@ import Ast.Common exposing (MPattern, Pattern(..))
 import Ast.Expression exposing (MExp, expression)
 import Ast.Pattern exposing (pattern)
 import Ast.Statement exposing (Statement, opTable, statement, statements)
-import Combine exposing ((<*), end)
+import Combine exposing (ParseError, ParseOk, end, ignore)
 
 
 {-| Parse an Elm pattern
 -}
-parsePattern : String -> Result (Combine.ParseErr ()) (Combine.ParseOk () MPattern)
+parsePattern : String -> Result (ParseError ()) (ParseOk () MPattern)
 parsePattern =
-    Combine.parse (pattern <* end)
+    Combine.parse (pattern |> ignore end)
 
 
 {-| Parse an Elm expression.
 -}
-parseExpression : OpTable -> String -> Result (Combine.ParseErr ()) (Combine.ParseOk () MExp)
+parseExpression : OpTable -> String -> Result (ParseError ()) (ParseOk () MExp)
 parseExpression ops =
-    Combine.parse (expression ops <* end)
+    Combine.parse (expression ops |> ignore end)
 
 
 {-| Parse an Elm statement.
 -}
-parseStatement : OpTable -> String -> Result (Combine.ParseErr ()) (Combine.ParseOk () Statement)
+parseStatement : OpTable -> String -> Result (ParseError ()) (ParseOk () Statement)
 parseStatement ops =
-    Combine.parse (statement ops <* end)
+    Combine.parse (statement ops |> ignore end)
 
 
 {-| Parse an OpTable from a module.
 -}
-parseOpTable : OpTable -> String -> Result (Combine.ParseErr ()) (Combine.ParseOk () OpTable)
+parseOpTable : OpTable -> String -> Result (ParseError ()) (ParseOk () OpTable)
 parseOpTable ops =
     Combine.parse (opTable ops)
 
 
 {-| Parse an Elm module.
 -}
-parseModule : OpTable -> String -> Result (Combine.ParseErr ()) (Combine.ParseOk () (List Statement))
+parseModule : OpTable -> String -> Result (ParseError ()) (ParseOk () (List Statement))
 parseModule ops =
     Combine.parse (statements ops)
 
 
 {-| Parse an Elm module, scanning for infix declarations first.
 -}
-parse : String -> Result (Combine.ParseErr ()) (Combine.ParseOk () (List Statement))
+parse : String -> Result (ParseError ()) (ParseOk () (List Statement))
 parse input =
     case parseOpTable operators input of
         Ok ( state, stream, ops ) ->
diff --git a/src/Ast/Common.elm b/src/Ast/Common.elm
index 1ee3f20..d5084fe 100644
--- a/src/Ast/Common.elm
+++ b/src/Ast/Common.elm
@@ -115,7 +115,7 @@ addMeta l c e =
 -}
 withMeta : Parser s x -> Parser s (WithMeta x {})
 withMeta p =
-    withLocation (\a -> (\x -> addMeta a.line a.column x) <$> p)
+    withLocation <| \a -> map (\x -> addMeta a.line a.column x) p
 
 
 {-| Extract only an entity dropping its metadata
diff --git a/src/Ast/Expression.elm b/src/Ast/Expression.elm
index b819088..0b11542 100644
--- a/src/Ast/Expression.elm
+++ b/src/Ast/Expression.elm
@@ -73,81 +73,89 @@ type Expression
 
 character : Parser s MExp
 character =
-    withMeta <|
-        Literal
-            << Character
-            <$> characterParser
+    withMeta <| map (Literal << Character) characterParser
 
 
 string : Parser s MExp
 string =
-    withMeta <|
-        (Literal << String <$> stringParser)
+    withMeta <| map (Literal << String) stringParser
 
 
 integer : Parser s MExp
 integer =
-    withMeta <| Literal << Integer <$> intParser
+    withMeta <| map (Literal << Integer) intParser
 
 
 float : Parser s MExp
 float =
-    withMeta <| Literal << Float <$> floatParser
+    withMeta <| map (Literal << Float) floatParser
 
 
 access : Parser s MExp
 access =
-    withMeta <| Access <$> variable <*> many1 (Combine.string "." *> withMeta varName)
+    map Access variable
+        |> andMap (many1 (Combine.string "." |> keep (withMeta varName)))
+        |> withMeta
 
 
 accessFunction : Parser s MExp
 accessFunction =
-    withMeta <| AccessFunction <$> (Combine.string "." *> loName)
+    map AccessFunction (Combine.string "." |> keep loName)
+        |> withMeta
 
 
 external : Parser s MExp
 external =
-    withMeta <| External <$> many1 (upName <* Combine.string ".") <*> (variable <|> constructor)
+    map External (many1 (upName |> ignore (Combine.string ".")))
+        |> andMap (or variable constructor)
+        |> withMeta
 
 
 variable : Parser s MExp
 variable =
-    withMeta <|
-        Variable
-            <$> choice
-                    [ loName
-                    , parens operator
-                    , parens (Combine.regex ",+")
-                    , emptyTuple
-                    ]
+    map Variable
+        (choice
+            [ loName
+            , parens operator
+            , parens (Combine.regex ",+")
+            , emptyTuple
+            ]
+        )
+        |> withMeta
 
 
 constructor : Parser s MExp
 constructor =
-    withMeta <| Constructor <$> upName
+    withMeta <| map Constructor upName
 
 
 list : OpTable -> Parser s MExp
 list ops =
     lazy <|
         \() ->
-            withMeta <| List <$> (listParser <| expression ops)
+            map List (listParser <| expression ops)
+                |> withMeta
 
 
 tuple : OpTable -> Parser s MExp
 tuple ops =
     lazy <|
         \() ->
-            withMeta <|
-                Tuple
-                    <$> tupleParser (expression ops)
+            map Tuple (tupleParser (expression ops))
+                |> withMeta
 
 
 record : OpTable -> Parser s MExp
 record ops =
     lazy <|
         \() ->
-            withMeta <| Record <$> braces (commaSeparated ((,) <$> withMeta loName <*> (symbol "=" *> expression ops)))
+            withMeta <|
+                map Record <|
+                    braces <|
+                        commaSeparated <|
+                            (map Tuple.pair (withMeta loName)
+                                |> andMap (symbol "=" |> keep (expression ops))
+                            )
 
 
 simplifiedRecord : Parser s MExp
@@ -164,52 +172,52 @@ simplifiedRecord =
     in
     lazy <|
         \() ->
-            withMeta <|
-                Record
-                    <$> braces (commaSeparated (withLocation branch))
+            withMeta <| map Record <| braces (commaSeparated (withLocation branch))
 
 
 recordUpdate : OpTable -> Parser s MExp
 recordUpdate ops =
     lazy <|
         \() ->
-            withMeta <|
-                RecordUpdate
-                    <$> (symbol "{" *> withMeta loName)
-                    <*> (symbol "|"
-                            *> commaSeparated ((,) <$> withMeta loName <*> (symbol "=" *> expression ops))
-                            <* Combine.string "}"
-                        )
+            map RecordUpdate (symbol "{" |> keep (withMeta loName))
+                |> andMap
+                    (symbol "|"
+                        |> keep
+                            (commaSeparated
+                                (map Tuple.pair (withMeta loName)
+                                    |> andMap (symbol "=" |> keep (expression ops))
+                                )
+                            )
+                        |> ignore (Combine.string "}")
+                    )
+                |> withMeta
 
 
 letExpression : OpTable -> Parser s MExp
 letExpression ops =
     lazy <|
         \() ->
-            withMeta <|
-                Let
-                    <$> (symbol_ "let" *> many1 (letBinding ops))
-                    <*> (symbol "in" *> expression ops)
+            map Let (symbol_ "let" |> keep (many1 (letBinding ops)))
+                |> andMap (symbol "in" |> keep (expression ops))
+                |> withMeta
 
 
 letBinding : OpTable -> Parser s ( MPattern, MExp )
 letBinding ops =
     lazy <|
         \() ->
-            (,)
-                <$> between_ whitespace pattern
-                <*> (symbol "=" *> expression ops)
+            map Tuple.pair (between_ whitespace pattern)
+                |> andMap (symbol "=" |> keep (expression ops))
 
 
 ifExpression : OpTable -> Parser s MExp
 ifExpression ops =
     lazy <|
         \() ->
-            withMeta <|
-                If
-                    <$> (symbol "if" *> expression ops)
-                    <*> (symbol "then" *> expression ops)
-                    <*> (symbol "else" *> expression ops)
+            map If (symbol "if" |> keep (expression ops))
+                |> andMap (symbol "then" |> keep (expression ops))
+                |> andMap (symbol "else" |> keep (expression ops))
+                |> withMeta
 
 
 caseExpression : OpTable -> Parser s MExp
@@ -218,32 +226,31 @@ caseExpression ops =
         binding indent =
             lazy <|
                 \() ->
-                    (,)
-                        <$> (exactIndentation indent *> pattern)
-                        <*> (symbol "->" *> expression ops)
+                    map Tuple.pair (exactIndentation indent |> keep pattern)
+                        |> andMap (symbol "->" |> keep (expression ops))
     in
     lazy <|
         \() ->
-            withMeta <|
-                Case
-                    <$> (symbol "case" *> expression ops)
-                    <*> (whitespace
-                            *> Combine.string "of"
-                            *> lookAhead countIndent
-                            >>= (\indent ->
-                                    many1 (binding indent)
-                                )
-                        )
+            map Case (symbol "case" |> keep (expression ops))
+                |> andMap
+                    (whitespace
+                        |> keep (Combine.string "of")
+                        |> keep (lookAhead countIndent)
+                        |> andThen
+                            (\indent ->
+                                many1 (binding indent)
+                            )
+                    )
+                |> withMeta
 
 
 lambda : OpTable -> Parser s MExp
 lambda ops =
     lazy <|
         \() ->
-            withMeta <|
-                Lambda
-                    <$> (symbol "\\" *> (pattern >>= succeed << applicationToList))
-                    <*> (symbol "->" *> expression ops)
+            map Lambda (symbol "\\" |> keep (pattern |> andThen (succeed << applicationToList)))
+                |> andMap (symbol "->" |> keep (expression ops))
+                |> withMeta
 
 
 application : OpTable -> Parser s MExp
@@ -253,42 +260,50 @@ application ops =
             withLocation
                 (\l ->
                     chainl
-                        ((\a b -> addMeta l.line l.column (Application a b)) <$ spacesOrIndentedNewline (l.column + 1))
+                        (onsuccess
+                            (\a b -> addMeta l.line l.column (Application a b))
+                            (spacesOrIndentedNewline (l.column + 1))
+                        )
                         (term ops)
                 )
 
 
 successOrEmptyList : Parser s (List a) -> Parser s (List a)
 successOrEmptyList p =
-    lazy <| \() -> choice [ p, succeed [] ]
+    lazy <|
+        \() ->
+            choice [ p, succeed [] ]
+
+
+next_ : OpTable -> Parser s (List ( WithMeta String {}, MExp ))
+next_ ops =
+    (withMeta <| between_ whitespace <| operator)
+        |> andThen
+            (\o ->
+                or (map Cont (application ops)) (map Stop (expression ops))
+                    |> andThen
+                        (\e ->
+                            case e of
+                                Cont t ->
+                                    map ((::) ( o, t )) (successOrEmptyList (next_ ops))
+
+                                Stop ex ->
+                                    succeed [ ( o, ex ) ]
+                        )
+            )
 
 
 binary : OpTable -> Parser s MExp
 binary ops =
-    lazy <|
-        \() ->
-            let
-                next =
-                    (withMeta <| between_ whitespace <| operator)
-                        >>= (\op ->
-                                lazy <|
-                                    \() ->
-                                        or (Cont <$> application ops) (Stop <$> expression ops)
-                                            >>= (\e ->
-                                                    case e of
-                                                        Cont t ->
-                                                            (::) ( op, t ) <$> successOrEmptyList next
-
-                                                        Stop ex ->
-                                                            succeed [ ( op, ex ) ]
-                                                )
-                            )
-            in
-            application ops
-                >>= (\e -> successOrEmptyList next >>= (\eops -> split ops 0 e eops))
+    application ops
+        |> andThen
+            (\e ->
+                successOrEmptyList (next_ ops)
+                    |> andThen (\eops -> split ops 0 e eops)
+            )
 
 
-{-| A parses for term
+{-| A parser for term
 -}
 term : OpTable -> Parser s MExp
 term ops =
@@ -357,9 +372,11 @@ split ops l e eops =
 
         _ ->
             findAssoc ops l eops
-                >>= (\assoc ->
+                |> andThen
+                    (\association ->
                         sequence (splitLevel ops l e eops)
-                            >>= (\es ->
+                            |> andThen
+                                (\es ->
                                     let
                                         ops_ =
                                             List.filterMap
@@ -372,7 +389,7 @@ split ops l e eops =
                                                 )
                                                 eops
                                     in
-                                    case assoc of
+                                    case association of
                                         R ->
                                             joinR es ops_
 
diff --git a/src/Ast/Helpers.elm b/src/Ast/Helpers.elm
index 2c3744f..a393dee 100644
--- a/src/Ast/Helpers.elm
+++ b/src/Ast/Helpers.elm
@@ -31,6 +31,7 @@ module Ast.Helpers exposing
 import Ast.Common exposing (..)
 import Combine exposing (..)
 import Combine.Char exposing (..)
+import Flip exposing (flip)
 import String
 
 
@@ -61,7 +62,7 @@ reservedOperators =
 
 optionalParens : Parser s a -> Parser s a
 optionalParens p =
-    lazy <| \() -> p <|> (parens <| optionalParens p)
+    lazy <| \() -> or p (parens <| optionalParens p)
 
 
 between_ : Parser s a -> Parser s res -> Parser s res
@@ -81,17 +82,17 @@ spaces_ =
 
 notWhitespace_ : Parser s String
 notWhitespace_ =
-    regex "[^ \t\x0D\n]*"  "whitespace"
+    regex "[^ \t\u{000D}\n]*" |> onerror "whitespace"
 
 
 exactIndentation : Int -> Parser s String
 exactIndentation int =
-    regex ("\n*[ \\t]{" ++ toString int ++ "}\n*")
+    regex ("\n*[ \\t]{" ++ String.fromInt int ++ "}\n*")
 
 
 symbol_ : String -> Parser s String
 symbol_ k =
-    between_ whitespace (string k <* regex "( |\\n)+")
+    between_ whitespace (string k |> ignore (regex "( |\\n)+"))
 
 
 symbol : String -> Parser s String
@@ -101,7 +102,7 @@ symbol k =
 
 initialSymbol : String -> Parser s String
 initialSymbol k =
-    string k <* spaces_
+    string k |> ignore spaces_
 
 
 commaSeparated : Parser s res -> Parser s (List res)
@@ -116,12 +117,13 @@ commaSeparated_ p =
 
 name : Parser s Char -> Parser s String
 name p =
-    String.cons <$> p <*> regex "[a-zA-Z0-9-_]*"
+    map String.cons p
+        |> andMap (regex "[a-zA-Z0-9-_]*")
 
 
 loName : Parser s String
 loName =
-    wild <|> varName
+    or wild varName
 
 
 funName : Parser s String
@@ -137,7 +139,8 @@ wild =
 varName : Parser s String
 varName =
     name lower
-        >>= (\n ->
+        |> andThen
+            (\n ->
                 if List.member n reserved then
                     fail <| "name '" ++ n ++ "' is reserved"
 
@@ -160,8 +163,9 @@ operator : Parser s String
 operator =
     lazy <|
         \() ->
-            regex "[+\\-\\/*=.$<>:&|^?%#@~!]+|\x8As\x08"
-                >>= (\n ->
+            regex "[+\\-\\/*=.$<>:&|^?%#@~!]+|\u{008A}s\u{0008}"
+                |> andThen
+                    (\n ->
                         if List.member n reservedOperators then
                             fail <| "operator '" ++ n ++ "' is reserved"
 
@@ -182,7 +186,7 @@ moduleName =
 
 logContent : String -> Parser s x -> Parser s x
 logContent label xsParser =
-    xsParser >>= (Debug.log label >> succeed)
+    xsParser |> andThen (Debug.log label >> succeed)
 
 
 listParser : Parser s a -> Parser s (List a)
@@ -193,7 +197,8 @@ listParser el =
 tupleParser : Parser s a -> Parser s (List a)
 tupleParser el =
     parens (commaSeparated_ <| el)
-        >>= (\a ->
+        |> andThen
+            (\a ->
                 case a of
                     [ _ ] ->
                         fail "No single tuples"
@@ -207,9 +212,10 @@ spacesOrIndentedNewline : Int -> Parser s ()
 spacesOrIndentedNewline indentation =
     lazy <|
         \() ->
-            or (spaces_ *> succeed ())
+            or (spaces_ |> keep (succeed ()))
                 (countIndent
-                    >>= (\column ->
+                    |> andThen
+                        (\column ->
                             if column < indentation then
                                 fail "Arguments have to be at least the same indentation as the function"
 
@@ -221,4 +227,4 @@ spacesOrIndentedNewline indentation =
 
 countIndent : Parser s Int
 countIndent =
-    newline *> spaces >>= (String.filter (\char -> char == ' ') >> String.length >> succeed)
+    newline |> keep spaces |> andThen (String.filter (\char -> char == ' ') >> String.length >> succeed)
diff --git a/src/Ast/Literal.elm b/src/Ast/Literal.elm
index 226856e..caa94c6 100644
--- a/src/Ast/Literal.elm
+++ b/src/Ast/Literal.elm
@@ -1,7 +1,7 @@
 module Ast.Literal exposing (characterParser, floatParser, intParser, literalParser, stringParser)
 
-import Ast.Helpers exposing (..)
 import Ast.Common exposing (Literal(..))
+import Ast.Helpers exposing (..)
 import Char
 import Combine exposing (..)
 import Combine.Char exposing (..)
@@ -12,50 +12,52 @@ import Hex
 literalParser : Parser s Literal
 literalParser =
     choice
-        [ Float <$> floatParser
-        , Integer <$> intParser
-        , Character <$> characterParser
-        , String <$> stringParser
+        [ map Float floatParser
+        , map Integer intParser
+        , map Character characterParser
+        , map String stringParser
         ]
 
 
 characterParser : Parser s Char
 characterParser =
     between_ (Combine.string "'")
-        (((Combine.string "\\" *> regex "(n|t|r|\\\\|x..)")
-            >>= (\a ->
-                    case String.uncons a of
-                        Just ( 'n', "" ) ->
-                            succeed '\n'
-
-                        Just ( 't', "" ) ->
-                            succeed '\t'
-
-                        Just ( 'r', "" ) ->
-                            succeed '\x0D'
-
-                        Just ( '\\', "" ) ->
-                            succeed '\\'
-
-                        Just ( '0', "" ) ->
-                            succeed '\x00'
-
-                        Just ( 'x', hex ) ->
-                            hex
-                                |> String.toLower
-                                |> Hex.fromString
-                                |> Result.map Char.fromCode
-                                |> Result.map succeed
-                                |> Result.withDefault (fail "Invalid charcode")
-
-                        Just other ->
-                            fail ("No such character as \\" ++ toString other)
-
-                        Nothing ->
-                            fail "No character"
-                )
-         )
-            <|> anyChar
+        (or
+            ((Combine.string "\\" |> keep (regex "(n|t|r|\\\\|x..)"))
+                |> andThen
+                    (\a ->
+                        case String.uncons a of
+                            Just ( 'n', "" ) ->
+                                succeed '\n'
+
+                            Just ( 't', "" ) ->
+                                succeed '\t'
+
+                            Just ( 'r', "" ) ->
+                                succeed '\u{000D}'
+
+                            Just ( '\\', "" ) ->
+                                succeed '\\'
+
+                            Just ( '0', "" ) ->
+                                succeed '\u{0000}'
+
+                            Just ( 'x', hex ) ->
+                                hex
+                                    |> String.toLower
+                                    |> Hex.fromString
+                                    |> Result.map Char.fromCode
+                                    |> Result.map succeed
+                                    |> Result.withDefault (fail "Invalid charcode")
+
+                            Just other ->
+                                fail ("No such character as \\" ++ String.fromChar (Tuple.first other))
+
+                            Nothing ->
+                                fail "No character"
+                    )
+            )
+            anyChar
         )
 
 
@@ -63,12 +65,17 @@ stringParser : Parser s String
 stringParser =
     let
         singleString =
-            Combine.string "\"" *> regex "(\\\\\\\\|\\\\\"|[^\"\n])*" <* Combine.string "\""
+            Combine.string "\""
+                |> keep (regex "(\\\\\\\\|\\\\\"|[^\"\n])*")
+                |> ignore (Combine.string "\"")
 
         multiString =
-            String.concat <$> (Combine.string "\"\"\"" *> many (regex "[^\"]*") <* Combine.string "\"\"\"")
+            Combine.string "\"\"\""
+                |> keep (many (regex "[^\"]*"))
+                |> ignore (Combine.string "\"\"\"")
+                |> map String.concat
     in
-    multiString <|> singleString
+    or multiString singleString
 
 
 intParser : Parser s Int
diff --git a/src/Ast/Pattern.elm b/src/Ast/Pattern.elm
index 1d06870..1ca51d9 100644
--- a/src/Ast/Pattern.elm
+++ b/src/Ast/Pattern.elm
@@ -8,17 +8,17 @@ import Combine exposing (..)
 
 wildParser : Parser s MPattern
 wildParser =
-    withMeta <| always PWild <$> wild
+    withMeta <| map (always PWild) wild
 
 
 varParser : Parser s MPattern
 varParser =
-    withMeta <| PVariable <$> funName
+    withMeta <| map PVariable funName
 
 
 constructorParser : Parser s MPattern
 constructorParser =
-    withMeta <| PConstructor <$> upName
+    withMeta <| map PConstructor upName
 
 
 
@@ -56,46 +56,50 @@ precedence =
 
 asParser : Parser s MPattern -> Parser s MPattern
 asParser next =
-    lazy <| \() -> next >>= asParser_
+    lazy <| \() -> andThen asParser_ next
 
 
 asParser_ : MPattern -> Parser s MPattern
 asParser_ a =
     lazy <|
         \() ->
-            ((withMeta <| PAs a <$> (symbol "as" *> varName)) >>= asParser_)
-                <|> succeed a
+            or
+                ((withMeta <| map (PAs a) (symbol "as" |> keep varName)) |> andThen asParser_)
+                (succeed a)
 
 
 consParser : Parser s MPattern -> Parser s MPattern
 consParser next =
     lazy <|
         \() ->
-            (withMeta <|
-                PCons
-                    <$> next
-                    <* withMeta (symbol "::")
-                    <*> consParser next
-            )
-                <|> next
+            or
+                (map PCons next
+                    |> ignore (withMeta (symbol "::"))
+                    |> andMap (consParser next)
+                    |> withMeta
+                )
+                next
 
 
 appParser : Parser s MPattern -> Parser s MPattern
 appParser next =
     lazy <|
         \() ->
-            withLocation
-                (\l ->
-                    chainl
-                        ((\a b ->
-                            addMeta l.line l.column <|
-                                PApplication a b
-                         )
-                            <$ spacesOrIndentedNewline (l.column + 1)
-                        )
-                        next
+            or
+                (withLocation
+                    (\l ->
+                        chainl
+                            (onsuccess
+                                (\a b ->
+                                    addMeta l.line l.column <|
+                                        PApplication a b
+                                )
+                                (spacesOrIndentedNewline (l.column + 1))
+                            )
+                            next
+                    )
                 )
-                <|> next
+                next
 
 
 terminalParser : Parser s MPattern -> Parser s MPattern
@@ -106,10 +110,10 @@ terminalParser next =
                 [ wildParser
                 , varParser
                 , constructorParser
-                , withMeta <| PLiteral <$> literalParser
-                , withMeta <| PRecord <$> (braces <| commaSeparated_ <| withMeta loName)
-                , withMeta <| PTuple <$> tupleParser next
-                , withMeta <| PList <$> listParser next
+                , withMeta <| map PLiteral literalParser
+                , withMeta <| map PRecord (braces <| commaSeparated_ <| withMeta loName)
+                , withMeta <| map PTuple <| tupleParser next
+                , withMeta <| map PList <| listParser next
                 , parens next
                 ]
 
diff --git a/src/Ast/Statement.elm b/src/Ast/Statement.elm
index 703802d..2bccea2 100644
--- a/src/Ast/Statement.elm
+++ b/src/Ast/Statement.elm
@@ -79,17 +79,17 @@ type alias Statement =
 
 allExport : Parser s ExportSet
 allExport =
-    AllExport <$ symbol ".."
+    onsuccess AllExport <| symbol ".."
 
 
 functionExport : Parser s ExportSet
 functionExport =
-    FunctionExport <$> choice [ functionName, parens operator ]
+    map FunctionExport <| choice [ functionName, parens operator ]
 
 
 constructorSubsetExports : Parser s ExportSet
 constructorSubsetExports =
-    SubsetExport <$> commaSeparated (FunctionExport <$> upName)
+    map SubsetExport <| commaSeparated <| map FunctionExport upName
 
 
 constructorExports : Parser s (Maybe ExportSet)
@@ -104,13 +104,12 @@ constructorExports =
 
 typeExport : Parser s ExportSet
 typeExport =
-    TypeExport <$> (upName <* spaces) <*> constructorExports
+    map TypeExport (upName |> ignore spaces) |> andMap constructorExports
 
 
 subsetExport : Parser s ExportSet
 subsetExport =
-    SubsetExport
-        <$> commaSeparated (functionExport |> or typeExport)
+    map SubsetExport <| commaSeparated (functionExport |> or typeExport)
 
 
 exports : Parser s ExportSet
@@ -125,31 +124,33 @@ exports =
 
 typeVariable : Parser s Type
 typeVariable =
-    TypeVariable <$> regex "[a-z]+(\\w|_)*"
+    map TypeVariable (regex "[a-z]+(\\w|_)*")
 
 
 typeConstant : Parser s Type
 typeConstant =
-    TypeConstructor <$> sepBy1 (string ".") upName <*> succeed []
+    map TypeConstructor (sepBy1 (string ".") upName)
+        |> andMap (succeed [])
 
 
 typeApplication : Parser s (Type -> Type -> Type)
 typeApplication =
-    TypeApplication <$ symbol "->"
+    onsuccess TypeApplication <| symbol "->"
 
 
 typeTuple : Parser s Type
 typeTuple =
     lazy <|
         \() ->
-            TypeTuple <$> parens (commaSeparated_ type_)
+            map TypeTuple <| parens (commaSeparated_ type_)
 
 
 typeRecordPair : Parser s ( Name, Type )
 typeRecordPair =
     lazy <|
         \() ->
-            (,) <$> (loName <* symbol ":") <*> typeAnnotation
+            map Tuple.pair (loName |> ignore (symbol ":"))
+                |> andMap typeAnnotation
 
 
 typeRecordPairs : Parser s (List ( Name, Type ))
@@ -163,26 +164,23 @@ typeRecordConstructor : Parser s Type
 typeRecordConstructor =
     lazy <|
         \() ->
-            braces <|
-                TypeRecordConstructor
-                    <$> between_ spaces typeVariable
-                    <*> (symbol "|" *> typeRecordPairs)
+            map TypeRecordConstructor (between_ spaces typeVariable)
+                |> andMap (typeRecordPairs |> ignore (symbol "|"))
+                |> braces
 
 
 typeRecord : Parser s Type
 typeRecord =
     lazy <|
         \() ->
-            braces <|
-                TypeRecord
-                    <$> typeRecordPairs
+            braces <| map TypeRecord typeRecordPairs
 
 
 typeParameter : Parser s Type
 typeParameter =
     lazy <|
         \() ->
-            between_ (or (spaces *> newline *> spaces_) spaces) <|
+            between_ (or (spaces |> keep newline |> keep spaces_) spaces) <|
                 choice
                     [ typeVariable
                     , typeConstant
@@ -197,7 +195,8 @@ typeConstructor : Parser s Type
 typeConstructor =
     lazy <|
         \() ->
-            TypeConstructor <$> sepBy1 (string ".") upName <*> many typeParameter
+            map TypeConstructor (sepBy1 (string ".") upName)
+                |> andMap (many typeParameter)
 
 
 type_ : Parser s Type
@@ -229,27 +228,30 @@ typeAnnotation =
 
 portModuleDeclaration : Parser s Statement
 portModuleDeclaration =
-    withMeta <|
-        PortModuleDeclaration
-            <$> (initialSymbol "port" *> symbol "module" *> moduleName)
-            <*> (symbol "exposing" *> exports)
+    map PortModuleDeclaration (initialSymbol "port" |> keep (symbol "module") |> keep moduleName)
+        |> andMap (symbol "exposing" |> keep exports)
+        |> withMeta
 
 
 effectModuleDeclaration : Parser s Statement
 effectModuleDeclaration =
-    withMeta <|
-        EffectModuleDeclaration
-            <$> (initialSymbol "effect" *> symbol "module" *> moduleName)
-            <*> (symbol "where" *> braces (commaSeparated ((,) <$> loName <*> (symbol "=" *> upName))))
-            <*> (symbol "exposing" *> exports)
+    map EffectModuleDeclaration (initialSymbol "effect" |> keep (symbol "module") |> keep moduleName)
+        |> andMap
+            (symbol "where"
+                |> keep
+                    (braces
+                        (commaSeparated (map Tuple.pair loName |> andMap (symbol "=" |> keep upName)))
+                    )
+            )
+        |> andMap (symbol "exposing" |> keep exports)
+        |> withMeta
 
 
 moduleDeclaration : Parser s Statement
 moduleDeclaration =
-    withMeta <|
-        ModuleDeclaration
-            <$> (initialSymbol "module" *> moduleName)
-            <*> (symbol "exposing" *> exports)
+    map ModuleDeclaration (initialSymbol "module" |> keep moduleName)
+        |> andMap (symbol "exposing" |> keep exports)
+        |> withMeta
 
 
 
@@ -259,11 +261,10 @@ moduleDeclaration =
 
 importStatement : Parser s Statement
 importStatement =
-    withMeta <|
-        ImportStatement
-            <$> (initialSymbol "import" *> moduleName)
-            <*> maybe (symbol "as" *> upName)
-            <*> maybe (symbol "exposing" *> exports)
+    map ImportStatement (initialSymbol "import" |> keep moduleName)
+        |> andMap (maybe (symbol "as" |> keep upName))
+        |> andMap (maybe (symbol "exposing" |> keep exports))
+        |> withMeta
 
 
 
@@ -273,18 +274,16 @@ importStatement =
 
 typeAliasDeclaration : Parser s Statement
 typeAliasDeclaration =
-    withMeta <|
-        TypeAliasDeclaration
-            <$> (initialSymbol "type" *> symbol "alias" *> type_)
-            <*> (whitespace *> symbol "=" *> typeAnnotation)
+    map TypeAliasDeclaration (initialSymbol "type" |> keep (symbol "alias") |> keep type_)
+        |> andMap (whitespace |> keep (symbol "=") |> keep typeAnnotation)
+        |> withMeta
 
 
 typeDeclaration : Parser s Statement
 typeDeclaration =
-    withMeta <|
-        TypeDeclaration
-            <$> (initialSymbol "type" *> type_)
-            <*> (whitespace *> symbol "=" *> sepBy1 (symbol "|") (between_ whitespace typeConstructor))
+    map TypeDeclaration (initialSymbol "type" |> keep type_)
+        |> andMap (whitespace |> keep (symbol "=") |> keep (sepBy1 (symbol "|") (between_ whitespace typeConstructor)))
+        |> withMeta
 
 
 
@@ -294,19 +293,17 @@ typeDeclaration =
 
 portTypeDeclaration : Parser s Statement
 portTypeDeclaration =
-    withMeta <|
-        PortTypeDeclaration
-            <$> (initialSymbol "port" *> loName)
-            <*> (symbol ":" *> typeAnnotation)
+    map PortTypeDeclaration (initialSymbol "port" |> keep loName)
+        |> andMap (symbol ":" |> keep typeAnnotation)
+        |> withMeta
 
 
 portDeclaration : OpTable -> Parser s Statement
 portDeclaration ops =
-    withMeta <|
-        PortDeclaration
-            <$> (initialSymbol "port" *> loName)
-            <*> (many <| between_ spaces loName)
-            <*> (symbol "=" *> expression ops)
+    map PortDeclaration (initialSymbol "port" |> keep loName)
+        |> andMap (many <| between_ spaces loName)
+        |> andMap (symbol "=" |> keep (expression ops))
+        |> withMeta
 
 
 
@@ -316,25 +313,24 @@ portDeclaration ops =
 
 functionTypeDeclaration : Parser s Statement
 functionTypeDeclaration =
-    withMeta <|
-        FunctionTypeDeclaration
-            <$> (funName <* symbol ":")
-            <*> typeAnnotation
+    map FunctionTypeDeclaration (funName |> ignore (symbol ":"))
+        |> andMap typeAnnotation
+        |> withMeta
 
 
 functionDeclaration : OpTable -> Parser s Statement
 functionDeclaration ops =
-    (withMeta <|
-        FunctionDeclaration
-            <$> pattern
-            <*> (symbol "=" *> whitespace *> expression ops)
+    (map FunctionDeclaration pattern
+        |> andMap (symbol "=" |> keep whitespace |> keep (expression ops))
+        |> withMeta
     )
-        >>= (\(( decl, _ ) as full) ->
+        |> andThen
+            (\(( decl, _ ) as full) ->
                 case decl of
-                    FunctionDeclaration (PVariable _, _) _ ->
+                    FunctionDeclaration ( PVariable _, _ ) _ ->
                         succeed full
 
-                    FunctionDeclaration (PApplication _ _, _) _ ->
+                    FunctionDeclaration ( PApplication _ _, _ ) _ ->
                         succeed full
 
                     _ ->
@@ -349,15 +345,16 @@ functionDeclaration ops =
 
 infixDeclaration : Parser s Statement
 infixDeclaration =
-    withMeta <|
-        InfixDeclaration
-            <$> choice
-                    [ L <$ initialSymbol "infixl"
-                    , R <$ initialSymbol "infixr"
-                    , N <$ initialSymbol "infix"
-                    ]
-            <*> (spaces *> Combine.Num.int)
-            <*> (spaces *> (loName <|> operator))
+    map InfixDeclaration
+        (choice
+            [ onsuccess L (initialSymbol "infixl")
+            , onsuccess R (initialSymbol "infixr")
+            , onsuccess N (initialSymbol "infix")
+            ]
+        )
+        |> andMap (spaces |> keep Combine.Num.int)
+        |> andMap (spaces |> keep (or loName operator))
+        |> withMeta
 
 
 
@@ -367,21 +364,20 @@ infixDeclaration =
 
 singleLineComment : Parser s Statement
 singleLineComment =
-    withMeta <|
-        Comment
-            <$> (string "--" *> regex ".*" <* whitespace)
+    map Comment (string "--" |> keep (regex ".*") |> ignore whitespace)
+        |> withMeta
 
 
 multiLineComment : Parser s Statement
 multiLineComment =
-    withMeta <|
-        (Comment << String.fromList)
-            <$> (string "{-" *> manyTill anyChar (string "-}"))
+    map (Comment << String.fromList)
+        (string "{-" |> keep (manyTill anyChar (string "-}")))
+        |> withMeta
 
 
 comment : Parser s Statement
 comment =
-    singleLineComment <|> multiLineComment
+    or singleLineComment multiLineComment
 
 
 {-| A parser for stand-alone Elm statements.
@@ -410,7 +406,9 @@ statement ops =
 -}
 statements : OpTable -> Parser s (List Statement)
 statements ops =
-    manyTill (or whitespace spaces *> statement ops <* or whitespace spaces) end
+    manyTill
+        (or whitespace spaces |> keep (statement ops) |> ignore (or whitespace spaces))
+        end
 
 
 {-| A scanner for infix statements. This is useful for performing a
@@ -419,18 +417,19 @@ first pass over a module to find all of the infix declarations in it.
 infixStatements : Parser s (List Statement)
 infixStatements =
     let
-        statements =
+        statements_ =
             many
                 (choice
-                    [ Just <$> infixDeclaration
-                    , Nothing <$ regex ".*"
+                    [ map Just infixDeclaration
+                    , onsuccess Nothing (regex ".*")
                     ]
-                    <* whitespace
+                    |> ignore whitespace
                 )
-                <* end
+                |> ignore end
     in
-    statements
-        >>= (\xs ->
+    statements_
+        |> andThen
+            (\xs ->
                 succeed <| List.filterMap identity xs
             )
 
@@ -447,9 +446,10 @@ opTable ops =
                     Dict.insert n ( a, l ) d
 
                 _ ->
-                    Debug.crash "impossible"
+                    Debug.todo "impossible"
     in
     infixStatements
-        >>= (\xs ->
+        |> andThen
+            (\xs ->
                 succeed <| List.foldr collect ops xs
             )
diff --git a/tests/Expression.elm b/tests/Expression.elm
index f91757c..3a20ca7 100644
--- a/tests/Expression.elm
+++ b/tests/Expression.elm
@@ -14,7 +14,7 @@ module Expression exposing
     )
 
 import Helpers exposing (..)
-import Test exposing (Test, describe, test)
+import Test exposing (Test, describe, only, test)
 
 
 characterLiterals : Test
@@ -37,7 +37,7 @@ intLiterals =
         [ test "integer literal" <|
             \() -> "0" |> isExpressionSansMeta (integer 0)
         , test "positive literal" <|
-            \() -> "+12" |> isExpressionSansMeta (integer 12)
+            \() -> "12" |> isExpressionSansMeta (integer 12)
         , test "negative literal" <|
             \() -> "-12" |> isExpressionSansMeta (integer -12)
         ]
@@ -49,7 +49,7 @@ floatLiterals =
         [ test "float literal" <|
             \() -> "0.5" |> isExpressionSansMeta (float 0.5)
         , test "positive literal" <|
-            \() -> "+12.5" |> isExpressionSansMeta (float 12.5)
+            \() -> "12.5" |> isExpressionSansMeta (float 12.5)
         , test "negative literal" <|
             \() -> "-12.5" |> isExpressionSansMeta (float -12.5)
         ]
diff --git a/tests/Helpers.elm b/tests/Helpers.elm
index 2e67c6b..d1b05c4 100644
--- a/tests/Helpers.elm
+++ b/tests/Helpers.elm
@@ -6,6 +6,7 @@ import Ast.Common exposing (..)
 import Ast.Expression exposing (Expression(..), MExp)
 import Ast.Statement exposing (ExportSet(..), Statement, StatementBase(..), Type(..))
 import Expect exposing (..)
+import Flip exposing (flip)
 
 
 
@@ -95,8 +96,8 @@ dropStatementMeta ( s, _ ) =
         InfixDeclaration a i n ->
             InfixDeclarationSM a i n
 
-        Comment s ->
-            CommentSM s
+        Comment s_ ->
+            CommentSM s_
 
 
 dropMExpMeta : MExp -> ExpressionSansMeta
@@ -126,7 +127,7 @@ dropPatternMatches l =
         patternsSM =
             List.map dropPatternMeta patterns
     in
-    List.map2 (,) patternsSM expsSM
+    List.map2 Tuple.pair patternsSM expsSM
 
 
 dropExpressionMeta : Expression -> ExpressionSansMeta
@@ -141,8 +142,8 @@ dropExpressionMeta e =
         Constructor n ->
             ConstructorSM n
 
-        External l e ->
-            ExternalSM l (dropMExpMeta e)
+        External l e_ ->
+            ExternalSM l (dropMExpMeta e_)
 
         List l ->
             ListSM (List.map dropMExpMeta l)
@@ -165,14 +166,14 @@ dropExpressionMeta e =
         If e1 e2 e3 ->
             IfSM (dropMExpMeta e1) (dropMExpMeta e2) (dropMExpMeta e3)
 
-        Let l e ->
-            LetSM (dropPatternMatches l) (dropMExpMeta e)
+        Let l e_ ->
+            LetSM (dropPatternMatches l) (dropMExpMeta e_)
 
-        Case e l ->
-            CaseSM (dropMExpMeta e) (dropPatternMatches l)
+        Case e_ l ->
+            CaseSM (dropMExpMeta e_) (dropPatternMatches l)
 
-        Lambda l e ->
-            LambdaSM (List.map dropPatternMeta l) (dropMExpMeta e)
+        Lambda l e_ ->
+            LambdaSM (List.map dropPatternMeta l) (dropMExpMeta e_)
 
         Application e1 e2 ->
             ApplicationSM (dropMExpMeta e1) (dropMExpMeta e2)
@@ -500,13 +501,13 @@ isExpressionSansMeta e i =
 isApplicationSansMeta : ExpressionSansMeta -> List ExpressionSansMeta -> String -> Expectation
 isApplicationSansMeta fn args i =
     case parseExpression operators (String.trim i) of
-        Ok ( _, _, app ) ->
+        Ok ( _, _, app_ ) ->
             let
                 l =
                     List.foldl (flip ApplicationSM) fn args
 
                 r =
-                    dropMExpMeta app
+                    dropMExpMeta app_
             in
             Expect.equal l r
 
@@ -576,4 +577,4 @@ isPatternSansMeta p i =
 
 failure : String -> Int -> List String -> String
 failure i position es =
-    "failed to parse: " ++ i ++ " at position " ++ toString position ++ " (" ++ String.slice position (position + 1) i ++ ") with errors: " ++ toString es
+    "failed to parse: " ++ i ++ " at position " ++ Debug.toString position ++ " (" ++ String.slice position (position + 1) i ++ ") with errors: " ++ Debug.toString es
diff --git a/tests/Meta.elm b/tests/Meta.elm
index 360688d..b24fee0 100644
--- a/tests/Meta.elm
+++ b/tests/Meta.elm
@@ -88,7 +88,7 @@ let
         { a | b = x }
 in
     f 12
-""" |> String.trim
+"""
 
         expectation =
             addMeta 0 0 <|
@@ -124,7 +124,7 @@ in
     in
     describe "Multiline location"
         [ test "Multiple lines" <|
-            \() -> isExpression expectation input
+            \() -> isExpression expectation (input |> String.trim)
         ]
 
 
@@ -139,7 +139,7 @@ import Html exposing (text)
 
 f : String -> Html msg
 f s = text <| s ++ s
-""" |> String.trim
+"""
 
         expectations =
             [ addMeta 0 0 <|
@@ -171,4 +171,4 @@ f s = text <| s ++ s
             ]
     in
     describe "Statements location"
-        [ test "full module" <| \() -> areStatements expectations input ]
+        [ test "full module" <| \() -> areStatements expectations (input |> String.trim) ]
diff --git a/tests/Multiline.elm b/tests/Multiline.elm
index 05e5c05..248f710 100644
--- a/tests/Multiline.elm
+++ b/tests/Multiline.elm
@@ -1,7 +1,7 @@
 module Multiline exposing (application)
 
-import Test exposing (describe, test, Test)
 import Helpers exposing (isApplicationSansMeta, var)
+import Test exposing (Test, describe, test)
 
 
 application : Test
diff --git a/tests/Parsing.elm b/tests/Parsing.elm
index c733bee..e22314e 100644
--- a/tests/Parsing.elm
+++ b/tests/Parsing.elm
@@ -7,13 +7,13 @@ import Test exposing (Test, describe, test)
 wrongWhitespaceInput : String
 wrongWhitespaceInput =
     """
--- Empty line with spaces at the end here
-b =
-  2
-""" ++ "  " ++ """
-a =
-  1
-"""
+    -- Empty line with spaces at the end here
+    b =
+    2
+    """ ++ "  " ++ """
+    a =
+    1
+    """
 
 
 wrongWhitespace : Test
diff --git a/tests/Pattern.elm b/tests/Pattern.elm
index fc50915..b2066d1 100644
--- a/tests/Pattern.elm
+++ b/tests/Pattern.elm
@@ -22,7 +22,7 @@ intLiterals =
         [ test "integer literal" <|
             \() -> "0" |> isPatternSansMeta (integerPattern 0)
         , test "positive literal" <|
-            \() -> "+12" |> isPatternSansMeta (integerPattern 12)
+            \() -> "12" |> isPatternSansMeta (integerPattern 12)
         , test "negative literal" <|
             \() -> "-12" |> isPatternSansMeta (integerPattern -12)
         ]
@@ -34,7 +34,7 @@ floatLiterals =
         [ test "float literal" <|
             \() -> "0.5" |> isPatternSansMeta (floatPattern 0.5)
         , test "positive literal" <|
-            \() -> "+12.5" |> isPatternSansMeta (floatPattern 12.5)
+            \() -> "12.5" |> isPatternSansMeta (floatPattern 12.5)
         , test "negative literal" <|
             \() -> "-12.5" |> isPatternSansMeta (floatPattern -12.5)
         ]
diff --git a/tests/elm-package.json b/tests/elm-package.json
deleted file mode 100644
index 3aaa83d..0000000
--- a/tests/elm-package.json
+++ /dev/null
@@ -1,23 +0,0 @@
-{
-    "version": "1.0.0",
-    "summary": "Test Suites",
-    "repository": "https://github.com/Bogdanp/elm-ast.git",
-    "license": "BSD3",
-    "source-directories": [
-        "../src",
-        "../test",
-        "."
-    ],
-    "exposed-modules": [],
-    "dependencies": {
-        "elm-lang/core": "5.0.0 <= v < 6.0.0",
-        "elm-community/elm-test": "4.0.0 <= v < 5.0.0",
-        "elm-community/list-extra": "7.0.0 <= v < 8.0.0",
-        "elm-community/parser-combinators": "3.1.0 <= v < 4.0.0",
-        "rtfeldman/hex": "1.0.0 <= v < 2.0.0"
-    },
-    "dependency-sources": {
-        "elm-community/parser-combinators": "https://github.com/MajronMan/elm-combine.git"
-    },
-    "elm-version": "0.18.0 <= v < 0.19.0"
-}