├── .gitignore ├── LICENSE ├── README.md ├── elm-package.json ├── elm-stuff ├── build-artifacts │ └── 0.16.0 │ │ ├── elm-lang │ │ └── core │ │ │ └── 3.0.0 │ │ │ ├── Array.elmi │ │ │ ├── Array.elmo │ │ │ ├── Basics.elmi │ │ │ ├── Basics.elmo │ │ │ ├── Bitwise.elmi │ │ │ ├── Bitwise.elmo │ │ │ ├── Char.elmi │ │ │ ├── Char.elmo │ │ │ ├── Color.elmi │ │ │ ├── Color.elmo │ │ │ ├── Date.elmi │ │ │ ├── Date.elmo │ │ │ ├── Debug.elmi │ │ │ ├── Debug.elmo │ │ │ ├── Dict.elmi │ │ │ ├── Dict.elmo │ │ │ ├── Graphics-Collage.elmi │ │ │ ├── Graphics-Collage.elmo │ │ │ ├── Graphics-Element.elmi │ │ │ ├── Graphics-Element.elmo │ │ │ ├── Graphics-Input-Field.elmi │ │ │ ├── Graphics-Input-Field.elmo │ │ │ ├── Graphics-Input.elmi │ │ │ ├── Graphics-Input.elmo │ │ │ ├── Json-Decode.elmi │ │ │ ├── Json-Decode.elmo │ │ │ ├── Json-Encode.elmi │ │ │ ├── Json-Encode.elmo │ │ │ ├── Keyboard.elmi │ │ │ ├── Keyboard.elmo │ │ │ ├── List.elmi │ │ │ ├── List.elmo │ │ │ ├── Maybe.elmi │ │ │ ├── Maybe.elmo │ │ │ ├── Mouse.elmi │ │ │ ├── Mouse.elmo │ │ │ ├── Random.elmi │ │ │ ├── Random.elmo │ │ │ ├── Regex.elmi │ │ │ ├── Regex.elmo │ │ │ ├── Result.elmi │ │ │ ├── Result.elmo │ │ │ ├── Set.elmi │ │ │ ├── Set.elmo │ │ │ ├── Signal.elmi │ │ │ ├── Signal.elmo │ │ │ ├── String.elmi │ │ │ ├── String.elmo │ │ │ ├── Task.elmi │ │ │ ├── Task.elmo │ │ │ ├── Text.elmi │ │ │ ├── Text.elmo │ │ │ ├── Time.elmi │ │ │ ├── Time.elmo │ │ │ ├── Touch.elmi │ │ │ ├── Touch.elmo │ │ │ ├── Trampoline.elmi │ │ │ ├── Trampoline.elmo │ │ │ ├── Transform2D.elmi │ │ │ ├── Transform2D.elmo │ │ │ ├── Window.elmi │ │ │ ├── Window.elmo │ │ │ └── graph.dat │ │ └── user │ │ └── project │ │ └── 1.0.0 │ │ ├── MissileCommand.elmi │ │ └── MissileCommand.elmo └── exact-dependencies.json ├── main.elm ├── main.html └── run_server.cmd /.gitignore: -------------------------------------------------------------------------------- 1 | cache 2 | build 3 | Public 4 | elm_dependencies -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | The MIT License (MIT) 2 | 3 | Copyright (c) 2014 Yan Cui 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | Missile Command [Play It](https://s3.amazonaws.com/missile-command/main.html) 2 | =================== 3 | 4 | Missile command implemented in Elm 5 | -------------------------------------------------------------------------------- /elm-package.json: -------------------------------------------------------------------------------- 1 | { 2 | "version": "1.0.0", 3 | "summary": "helpful summary of your project, less than 80 characters", 4 | "repository": "https://github.com/user/project.git", 5 | "license": "BSD3", 6 | "source-directories": [ 7 | "." 8 | ], 9 | "exposed-modules": [], 10 | "dependencies": { 11 | "elm-lang/core": "3.0.0 <= v < 4.0.0" 12 | }, 13 | "elm-version": "0.16.0 <= v < 0.17.0" 14 | } -------------------------------------------------------------------------------- /elm-stuff/build-artifacts/0.16.0/elm-lang/core/3.0.0/Array.elmi: -------------------------------------------------------------------------------- 1 | elm-langcoreemptyrepeat 2 | initializefromListisEmptylengthpushappendgetsetslicetoList toIndexedListmap 3 | indexedMapfilterfoldlfoldrArray::aListaListaArrayelm-langcoreArrayArrayaappendelm-langcoreArrayArrayaelm-langcoreArrayArrayaelm-langcoreArrayArrayaemptyelm-langcoreArrayArrayafilteraBoolelm-langcoreArrayArrayaelm-langcoreArrayArrayafoldlabbbelm-langcoreArrayArrayabfoldrabbbelm-langcoreArrayArrayabfromListListaelm-langcoreArrayArrayagetIntelm-langcoreArrayArrayaelm-langcoreMaybeMaybea 4 | indexedMapIntabelm-langcoreArrayArrayaelm-langcoreArrayArrayb 5 | initializeIntIntaelm-langcoreArrayArrayaisEmptyelm-langcoreArrayArrayaBoollengthelm-langcoreArrayArrayaIntmapabelm-langcoreArrayArrayaelm-langcoreArrayArraybpushaelm-langcoreArrayArrayaelm-langcoreArrayArrayarepeatIntaelm-langcoreArrayArrayasetIntaelm-langcoreArrayArrayaelm-langcoreArrayArrayasliceIntIntelm-langcoreArrayArrayaelm-langcoreArrayArraya toIndexedListelm-langcoreArrayArrayaList_Tuple2IntatoListelm-langcoreArrayArrayaListaBasicsListMaybeNativeArrayArrayaArray -------------------------------------------------------------------------------- /elm-stuff/build-artifacts/0.16.0/elm-lang/core/3.0.0/Array.elmo: -------------------------------------------------------------------------------- 1 | Elm.Array = Elm.Array || {}; 2 | Elm.Array.make = function (_elm) { 3 | "use strict"; 4 | _elm.Array = _elm.Array || {}; 5 | if (_elm.Array.values) return _elm.Array.values; 6 | var _U = Elm.Native.Utils.make(_elm), 7 | $Basics = Elm.Basics.make(_elm), 8 | $List = Elm.List.make(_elm), 9 | $Maybe = Elm.Maybe.make(_elm), 10 | $Native$Array = Elm.Native.Array.make(_elm); 11 | var _op = {}; 12 | var append = $Native$Array.append; 13 | var length = $Native$Array.length; 14 | var isEmpty = function (array) { 15 | return _U.eq(length(array),0); 16 | }; 17 | var slice = $Native$Array.slice; 18 | var set = $Native$Array.set; 19 | var get = F2(function (i,array) { 20 | return _U.cmp(0,i) < 1 && _U.cmp(i, 21 | $Native$Array.length(array)) < 0 ? $Maybe.Just(A2($Native$Array.get, 22 | i, 23 | array)) : $Maybe.Nothing; 24 | }); 25 | var push = $Native$Array.push; 26 | var empty = $Native$Array.empty; 27 | var filter = F2(function (isOkay,arr) { 28 | var update = F2(function (x,xs) { 29 | return isOkay(x) ? A2($Native$Array.push,x,xs) : xs; 30 | }); 31 | return A3($Native$Array.foldl,update,$Native$Array.empty,arr); 32 | }); 33 | var foldr = $Native$Array.foldr; 34 | var foldl = $Native$Array.foldl; 35 | var indexedMap = $Native$Array.indexedMap; 36 | var map = $Native$Array.map; 37 | var toIndexedList = function (array) { 38 | return A3($List.map2, 39 | F2(function (v0,v1) { 40 | return {ctor: "_Tuple2",_0: v0,_1: v1}; 41 | }), 42 | _U.range(0,$Native$Array.length(array) - 1), 43 | $Native$Array.toList(array)); 44 | }; 45 | var toList = $Native$Array.toList; 46 | var fromList = $Native$Array.fromList; 47 | var initialize = $Native$Array.initialize; 48 | var repeat = F2(function (n,e) { 49 | return A2(initialize,n,$Basics.always(e)); 50 | }); 51 | var Array = {ctor: "Array"}; 52 | return _elm.Array.values = {_op: _op 53 | ,empty: empty 54 | ,repeat: repeat 55 | ,initialize: initialize 56 | ,fromList: fromList 57 | ,isEmpty: isEmpty 58 | ,length: length 59 | ,push: push 60 | ,append: append 61 | ,get: get 62 | ,set: set 63 | ,slice: slice 64 | ,toList: toList 65 | ,toIndexedList: toIndexedList 66 | ,map: map 67 | ,indexedMap: indexedMap 68 | ,filter: filter 69 | ,foldl: foldl 70 | ,foldr: foldr}; 71 | }; -------------------------------------------------------------------------------- /elm-stuff/build-artifacts/0.16.0/elm-lang/core/3.0.0/Basics.elmi: -------------------------------------------------------------------------------- 1 | elm-langcore===/=<><=>=maxmincomparenot&&||xor+-*/^//rem%negateabssqrtclamplogBaseepicossintanacosasinatanatan2roundfloorceilingtruncatetoFloatdegreesradiansturnstoPolar fromPolarisNaN 2 | isInfinitetoString++fstsndidentityalways<||><<>>flipcurryuncurryOrderLTEQGT@%IntIntInt&&BoolBoolBool*numbernumbernumber+numbernumbernumber++ 3 | appendable 4 | appendable 5 | appendable-numbernumbernumber/FloatFloatFloat//IntIntInt/=aaBool::aListaLista< 6 | comparable 7 | comparableBool<<abcacb<= 8 | comparable 9 | comparableBool<|abab==aaBool> 10 | comparable 11 | comparableBool>= 12 | comparable 13 | comparableBool>>abbcacEQelm-langcoreBasicsOrderGTelm-langcoreBasicsOrderLTelm-langcoreBasicsOrder^numbernumbernumberabsnumbernumberacosFloatFloatalwaysabaasinFloatFloatatanFloatFloatatan2FloatFloatFloatceilingFloatIntclampnumbernumbernumbernumbercompare 14 | comparable 15 | comparableelm-langcoreBasicsOrdercosFloatFloatcurry_Tuple2abcabcdegreesFloatFloateFloatflipabcbacfloorFloatInt fromPolar_Tuple2FloatFloat_Tuple2FloatFloatfst_Tuple2abaidentityaa 16 | isInfiniteFloatBoolisNaNFloatBoollogBaseFloatFloatFloatmax 17 | comparable 18 | comparable 19 | comparablemin 20 | comparable 21 | comparable 22 | comparablenegatenumbernumbernotBoolBoolpiFloatradiansFloatFloatremIntIntIntroundFloatIntsinFloatFloatsnd_Tuple2abbsqrtFloatFloattanFloatFloattoFloatIntFloattoPolar_Tuple2FloatFloat_Tuple2FloatFloattoStringaStringtruncateFloatIntturnsFloatFloatuncurryabc_Tuple2abcxorBoolBoolBool|>aabb||BoolBoolBoolNativeBasicsNativeUtilsOrderLTEQGT+-*/^//%rem==/=<><=>=&&||++ << >><||> -------------------------------------------------------------------------------- /elm-stuff/build-artifacts/0.16.0/elm-lang/core/3.0.0/Basics.elmo: -------------------------------------------------------------------------------- 1 | Elm.Basics = Elm.Basics || {}; 2 | Elm.Basics.make = function (_elm) { 3 | "use strict"; 4 | _elm.Basics = _elm.Basics || {}; 5 | if (_elm.Basics.values) return _elm.Basics.values; 6 | var _U = Elm.Native.Utils.make(_elm), 7 | $Native$Basics = Elm.Native.Basics.make(_elm), 8 | $Native$Utils = Elm.Native.Utils.make(_elm); 9 | var _op = {}; 10 | var uncurry = F2(function (f,_p0) { 11 | var _p1 = _p0; 12 | return A2(f,_p1._0,_p1._1); 13 | }); 14 | var curry = F3(function (f,a,b) { 15 | return f({ctor: "_Tuple2",_0: a,_1: b}); 16 | }); 17 | var flip = F3(function (f,b,a) { return A2(f,a,b);}); 18 | var snd = function (_p2) { var _p3 = _p2;return _p3._1;}; 19 | var fst = function (_p4) { var _p5 = _p4;return _p5._0;}; 20 | var always = F2(function (a,_p6) { return a;}); 21 | var identity = function (x) { return x;}; 22 | _op["<|"] = F2(function (f,x) { return f(x);}); 23 | _op["|>"] = F2(function (x,f) { return f(x);}); 24 | _op[">>"] = F3(function (f,g,x) { return g(f(x));}); 25 | _op["<<"] = F3(function (g,f,x) { return g(f(x));}); 26 | _op["++"] = $Native$Utils.append; 27 | var toString = $Native$Utils.toString; 28 | var isInfinite = $Native$Basics.isInfinite; 29 | var isNaN = $Native$Basics.isNaN; 30 | var toFloat = $Native$Basics.toFloat; 31 | var ceiling = $Native$Basics.ceiling; 32 | var floor = $Native$Basics.floor; 33 | var truncate = $Native$Basics.truncate; 34 | var round = $Native$Basics.round; 35 | var not = $Native$Basics.not; 36 | var xor = $Native$Basics.xor; 37 | _op["||"] = $Native$Basics.or; 38 | _op["&&"] = $Native$Basics.and; 39 | var max = $Native$Basics.max; 40 | var min = $Native$Basics.min; 41 | var GT = {ctor: "GT"}; 42 | var EQ = {ctor: "EQ"}; 43 | var LT = {ctor: "LT"}; 44 | var compare = $Native$Basics.compare; 45 | _op[">="] = $Native$Basics.ge; 46 | _op["<="] = $Native$Basics.le; 47 | _op[">"] = $Native$Basics.gt; 48 | _op["<"] = $Native$Basics.lt; 49 | _op["/="] = $Native$Basics.neq; 50 | _op["=="] = $Native$Basics.eq; 51 | var e = $Native$Basics.e; 52 | var pi = $Native$Basics.pi; 53 | var clamp = $Native$Basics.clamp; 54 | var logBase = $Native$Basics.logBase; 55 | var abs = $Native$Basics.abs; 56 | var negate = $Native$Basics.negate; 57 | var sqrt = $Native$Basics.sqrt; 58 | var atan2 = $Native$Basics.atan2; 59 | var atan = $Native$Basics.atan; 60 | var asin = $Native$Basics.asin; 61 | var acos = $Native$Basics.acos; 62 | var tan = $Native$Basics.tan; 63 | var sin = $Native$Basics.sin; 64 | var cos = $Native$Basics.cos; 65 | _op["^"] = $Native$Basics.exp; 66 | _op["%"] = $Native$Basics.mod; 67 | var rem = $Native$Basics.rem; 68 | _op["//"] = $Native$Basics.div; 69 | _op["/"] = $Native$Basics.floatDiv; 70 | _op["*"] = $Native$Basics.mul; 71 | _op["-"] = $Native$Basics.sub; 72 | _op["+"] = $Native$Basics.add; 73 | var toPolar = $Native$Basics.toPolar; 74 | var fromPolar = $Native$Basics.fromPolar; 75 | var turns = $Native$Basics.turns; 76 | var degrees = $Native$Basics.degrees; 77 | var radians = function (t) { return t;}; 78 | return _elm.Basics.values = {_op: _op 79 | ,max: max 80 | ,min: min 81 | ,compare: compare 82 | ,not: not 83 | ,xor: xor 84 | ,rem: rem 85 | ,negate: negate 86 | ,abs: abs 87 | ,sqrt: sqrt 88 | ,clamp: clamp 89 | ,logBase: logBase 90 | ,e: e 91 | ,pi: pi 92 | ,cos: cos 93 | ,sin: sin 94 | ,tan: tan 95 | ,acos: acos 96 | ,asin: asin 97 | ,atan: atan 98 | ,atan2: atan2 99 | ,round: round 100 | ,floor: floor 101 | ,ceiling: ceiling 102 | ,truncate: truncate 103 | ,toFloat: toFloat 104 | ,degrees: degrees 105 | ,radians: radians 106 | ,turns: turns 107 | ,toPolar: toPolar 108 | ,fromPolar: fromPolar 109 | ,isNaN: isNaN 110 | ,isInfinite: isInfinite 111 | ,toString: toString 112 | ,fst: fst 113 | ,snd: snd 114 | ,identity: identity 115 | ,always: always 116 | ,flip: flip 117 | ,curry: curry 118 | ,uncurry: uncurry 119 | ,LT: LT 120 | ,EQ: EQ 121 | ,GT: GT}; 122 | }; -------------------------------------------------------------------------------- /elm-stuff/build-artifacts/0.16.0/elm-lang/core/3.0.0/Bitwise.elmi: -------------------------------------------------------------------------------- 1 | elm-langcoreandorxor 2 | complement shiftLeft 3 | shiftRightshiftRightLogical::aListaListaandIntIntInt 4 | complementIntIntorIntIntInt shiftLeftIntIntInt 5 | shiftRightIntIntIntshiftRightLogicalIntIntIntxorIntIntIntNativeBitwise -------------------------------------------------------------------------------- /elm-stuff/build-artifacts/0.16.0/elm-lang/core/3.0.0/Bitwise.elmo: -------------------------------------------------------------------------------- 1 | Elm.Bitwise = Elm.Bitwise || {}; 2 | Elm.Bitwise.make = function (_elm) { 3 | "use strict"; 4 | _elm.Bitwise = _elm.Bitwise || {}; 5 | if (_elm.Bitwise.values) return _elm.Bitwise.values; 6 | var _U = Elm.Native.Utils.make(_elm), 7 | $Native$Bitwise = Elm.Native.Bitwise.make(_elm); 8 | var _op = {}; 9 | var shiftRightLogical = $Native$Bitwise.shiftRightLogical; 10 | var shiftRight = $Native$Bitwise.shiftRightArithmatic; 11 | var shiftLeft = $Native$Bitwise.shiftLeft; 12 | var complement = $Native$Bitwise.complement; 13 | var xor = $Native$Bitwise.xor; 14 | var or = $Native$Bitwise.or; 15 | var and = $Native$Bitwise.and; 16 | return _elm.Bitwise.values = {_op: _op 17 | ,and: and 18 | ,or: or 19 | ,xor: xor 20 | ,complement: complement 21 | ,shiftLeft: shiftLeft 22 | ,shiftRight: shiftRight 23 | ,shiftRightLogical: shiftRightLogical}; 24 | }; -------------------------------------------------------------------------------- /elm-stuff/build-artifacts/0.16.0/elm-lang/core/3.0.0/Char.elmi: -------------------------------------------------------------------------------- 1 | elm-langcore isUpperisLowerisDigit 2 | isOctDigit 3 | isHexDigittoUppertoLower toLocaleUpper toLocaleLowertoCodefromCodeKeyCode ::aListaListafromCodeelm-langcoreCharKeyCodeIntChar isBetweenCharCharCharBoolisDigitCharBool 4 | isHexDigitCharBoolisLowerCharBool 5 | isOctDigitCharBoolisUpperCharBooltoCodeCharelm-langcoreCharKeyCodeInt toLocaleLowerCharChar toLocaleUpperCharChartoLowerCharChartoUpperCharCharBasicsNativeCharKeyCodeInt -------------------------------------------------------------------------------- /elm-stuff/build-artifacts/0.16.0/elm-lang/core/3.0.0/Char.elmo: -------------------------------------------------------------------------------- 1 | Elm.Char = Elm.Char || {}; 2 | Elm.Char.make = function (_elm) { 3 | "use strict"; 4 | _elm.Char = _elm.Char || {}; 5 | if (_elm.Char.values) return _elm.Char.values; 6 | var _U = Elm.Native.Utils.make(_elm), 7 | $Basics = Elm.Basics.make(_elm), 8 | $Native$Char = Elm.Native.Char.make(_elm); 9 | var _op = {}; 10 | var fromCode = $Native$Char.fromCode; 11 | var toCode = $Native$Char.toCode; 12 | var toLocaleLower = $Native$Char.toLocaleLower; 13 | var toLocaleUpper = $Native$Char.toLocaleUpper; 14 | var toLower = $Native$Char.toLower; 15 | var toUpper = $Native$Char.toUpper; 16 | var isBetween = F3(function (low,high,$char) { 17 | var code = toCode($char); 18 | return _U.cmp(code,toCode(low)) > -1 && _U.cmp(code, 19 | toCode(high)) < 1; 20 | }); 21 | var isUpper = A2(isBetween,_U.chr("A"),_U.chr("Z")); 22 | var isLower = A2(isBetween,_U.chr("a"),_U.chr("z")); 23 | var isDigit = A2(isBetween,_U.chr("0"),_U.chr("9")); 24 | var isOctDigit = A2(isBetween,_U.chr("0"),_U.chr("7")); 25 | var isHexDigit = function ($char) { 26 | return isDigit($char) || (A3(isBetween, 27 | _U.chr("a"), 28 | _U.chr("f"), 29 | $char) || A3(isBetween,_U.chr("A"),_U.chr("F"),$char)); 30 | }; 31 | return _elm.Char.values = {_op: _op 32 | ,isUpper: isUpper 33 | ,isLower: isLower 34 | ,isDigit: isDigit 35 | ,isOctDigit: isOctDigit 36 | ,isHexDigit: isHexDigit 37 | ,toUpper: toUpper 38 | ,toLower: toLower 39 | ,toLocaleUpper: toLocaleUpper 40 | ,toLocaleLower: toLocaleLower 41 | ,toCode: toCode 42 | ,fromCode: fromCode}; 43 | }; -------------------------------------------------------------------------------- /elm-stuff/build-artifacts/0.16.0/elm-lang/core/3.0.0/Color.elmi: -------------------------------------------------------------------------------- 1 | elm-langcore-rgbrgbahslhsla greyscale grayscale 2 | complementlinearradialtoRgbtoHslredorangeyellowgreenbluepurplebrownlightRed lightOrange lightYellow 3 | lightGreen lightBlue lightPurple 4 | lightBrowndarkRed 5 | darkOrange 6 | darkYellow darkGreendarkBlue 7 | darkPurple darkBrownwhite lightGreygreydarkGrey lightCharcoalcharcoal darkCharcoalblack lightGraygraydarkGrayColorGradient3::aListaListaHSLAFloatFloatFloatFloatelm-langcoreColorColorLinear_Tuple2FloatFloat_Tuple2FloatFloatList_Tuple2Floatelm-langcoreColorColorelm-langcoreColorGradientRGBAIntIntIntFloatelm-langcoreColorColorRadial_Tuple2FloatFloatFloat_Tuple2FloatFloatFloatList_Tuple2Floatelm-langcoreColorColorelm-langcoreColorGradientblackelm-langcoreColorColorblueelm-langcoreColorColorbrownelm-langcoreColorColorcharcoalelm-langcoreColorColor 8 | complementelm-langcoreColorColorelm-langcoreColorColordarkBlueelm-langcoreColorColor darkBrownelm-langcoreColorColor darkCharcoalelm-langcoreColorColordarkGrayelm-langcoreColorColor darkGreenelm-langcoreColorColordarkGreyelm-langcoreColorColor 9 | darkOrangeelm-langcoreColorColor 10 | darkPurpleelm-langcoreColorColordarkRedelm-langcoreColorColor 11 | darkYellowelm-langcoreColorColorfmodFloatIntFloatgrayelm-langcoreColorColor grayscaleFloatelm-langcoreColorColorgreenelm-langcoreColorColorgreyelm-langcoreColorColor greyscaleFloatelm-langcoreColorColorhslFloatFloatFloatelm-langcoreColorColorhslToRgbFloatFloatFloat_Tuple3FloatFloatFloathslaFloatFloatFloatFloatelm-langcoreColorColor lightBlueelm-langcoreColorColor 12 | lightBrownelm-langcoreColorColor lightCharcoalelm-langcoreColorColor lightGrayelm-langcoreColorColor 13 | lightGreenelm-langcoreColorColor lightGreyelm-langcoreColorColor lightOrangeelm-langcoreColorColor lightPurpleelm-langcoreColorColorlightRedelm-langcoreColorColor lightYellowelm-langcoreColorColorlinear_Tuple2FloatFloat_Tuple2FloatFloatList_Tuple2Floatelm-langcoreColorColorelm-langcoreColorGradientorangeelm-langcoreColorColorpurpleelm-langcoreColorColorradial_Tuple2FloatFloatFloat_Tuple2FloatFloatFloatList_Tuple2Floatelm-langcoreColorColorelm-langcoreColorGradientredelm-langcoreColorColorrgbIntIntIntelm-langcoreColorColorrgbToHslIntIntInt_Tuple3FloatFloatFloatrgbaIntIntIntFloatelm-langcoreColorColortoHslelm-langcoreColorColoralphaFloathueFloat lightnessFloat 14 | saturationFloattoRgbelm-langcoreColorColoralphaFloatblueIntgreenIntredIntwhiteelm-langcoreColorColoryellowelm-langcoreColorColorBasicsColorRGBAIntIntIntFloatHSLAFloatFloatFloatFloatGradientLinear_Tuple2FloatFloat_Tuple2FloatFloatList_Tuple2Floatelm-langcoreColorColorRadial_Tuple2FloatFloatFloat_Tuple2FloatFloatFloatList_Tuple2Floatelm-langcoreColorColor -------------------------------------------------------------------------------- /elm-stuff/build-artifacts/0.16.0/elm-lang/core/3.0.0/Color.elmo: -------------------------------------------------------------------------------- 1 | Elm.Color = Elm.Color || {}; 2 | Elm.Color.make = function (_elm) { 3 | "use strict"; 4 | _elm.Color = _elm.Color || {}; 5 | if (_elm.Color.values) return _elm.Color.values; 6 | var _U = Elm.Native.Utils.make(_elm), 7 | $Basics = Elm.Basics.make(_elm); 8 | var _op = {}; 9 | var Radial = F5(function (a,b,c,d,e) { 10 | return {ctor: "Radial",_0: a,_1: b,_2: c,_3: d,_4: e}; 11 | }); 12 | var radial = Radial; 13 | var Linear = F3(function (a,b,c) { 14 | return {ctor: "Linear",_0: a,_1: b,_2: c}; 15 | }); 16 | var linear = Linear; 17 | var fmod = F2(function (f,n) { 18 | var integer = $Basics.floor(f); 19 | return $Basics.toFloat(A2($Basics._op["%"], 20 | integer, 21 | n)) + f - $Basics.toFloat(integer); 22 | }); 23 | var rgbToHsl = F3(function (red,green,blue) { 24 | var b = $Basics.toFloat(blue) / 255; 25 | var g = $Basics.toFloat(green) / 255; 26 | var r = $Basics.toFloat(red) / 255; 27 | var cMax = A2($Basics.max,A2($Basics.max,r,g),b); 28 | var cMin = A2($Basics.min,A2($Basics.min,r,g),b); 29 | var c = cMax - cMin; 30 | var lightness = (cMax + cMin) / 2; 31 | var saturation = _U.eq(lightness, 32 | 0) ? 0 : c / (1 - $Basics.abs(2 * lightness - 1)); 33 | var hue = $Basics.degrees(60) * (_U.eq(cMax,r) ? A2(fmod, 34 | (g - b) / c, 35 | 6) : _U.eq(cMax,g) ? (b - r) / c + 2 : (r - g) / c + 4); 36 | return {ctor: "_Tuple3",_0: hue,_1: saturation,_2: lightness}; 37 | }); 38 | var hslToRgb = F3(function (hue,saturation,lightness) { 39 | var hue$ = hue / $Basics.degrees(60); 40 | var chroma = (1 - $Basics.abs(2 * lightness - 1)) * saturation; 41 | var x = chroma * (1 - $Basics.abs(A2(fmod,hue$,2) - 1)); 42 | var _p0 = _U.cmp(hue$,0) < 0 ? {ctor: "_Tuple3" 43 | ,_0: 0 44 | ,_1: 0 45 | ,_2: 0} : _U.cmp(hue$,1) < 0 ? {ctor: "_Tuple3" 46 | ,_0: chroma 47 | ,_1: x 48 | ,_2: 0} : _U.cmp(hue$,2) < 0 ? {ctor: "_Tuple3" 49 | ,_0: x 50 | ,_1: chroma 51 | ,_2: 0} : _U.cmp(hue$,3) < 0 ? {ctor: "_Tuple3" 52 | ,_0: 0 53 | ,_1: chroma 54 | ,_2: x} : _U.cmp(hue$, 55 | 4) < 0 ? {ctor: "_Tuple3",_0: 0,_1: x,_2: chroma} : _U.cmp(hue$, 56 | 5) < 0 ? {ctor: "_Tuple3",_0: x,_1: 0,_2: chroma} : _U.cmp(hue$, 57 | 6) < 0 ? {ctor: "_Tuple3" 58 | ,_0: chroma 59 | ,_1: 0 60 | ,_2: x} : {ctor: "_Tuple3",_0: 0,_1: 0,_2: 0}; 61 | var r = _p0._0; 62 | var g = _p0._1; 63 | var b = _p0._2; 64 | var m = lightness - chroma / 2; 65 | return {ctor: "_Tuple3",_0: r + m,_1: g + m,_2: b + m}; 66 | }); 67 | var toRgb = function (color) { 68 | var _p1 = color; 69 | if (_p1.ctor === "RGBA") { 70 | return {red: _p1._0 71 | ,green: _p1._1 72 | ,blue: _p1._2 73 | ,alpha: _p1._3}; 74 | } else { 75 | var _p2 = A3(hslToRgb,_p1._0,_p1._1,_p1._2); 76 | var r = _p2._0; 77 | var g = _p2._1; 78 | var b = _p2._2; 79 | return {red: $Basics.round(255 * r) 80 | ,green: $Basics.round(255 * g) 81 | ,blue: $Basics.round(255 * b) 82 | ,alpha: _p1._3}; 83 | } 84 | }; 85 | var toHsl = function (color) { 86 | var _p3 = color; 87 | if (_p3.ctor === "HSLA") { 88 | return {hue: _p3._0 89 | ,saturation: _p3._1 90 | ,lightness: _p3._2 91 | ,alpha: _p3._3}; 92 | } else { 93 | var _p4 = A3(rgbToHsl,_p3._0,_p3._1,_p3._2); 94 | var h = _p4._0; 95 | var s = _p4._1; 96 | var l = _p4._2; 97 | return {hue: h,saturation: s,lightness: l,alpha: _p3._3}; 98 | } 99 | }; 100 | var HSLA = F4(function (a,b,c,d) { 101 | return {ctor: "HSLA",_0: a,_1: b,_2: c,_3: d}; 102 | }); 103 | var hsla = F4(function (hue,saturation,lightness,alpha) { 104 | return A4(HSLA, 105 | hue - $Basics.turns($Basics.toFloat($Basics.floor(hue / (2 * $Basics.pi)))), 106 | saturation, 107 | lightness, 108 | alpha); 109 | }); 110 | var hsl = F3(function (hue,saturation,lightness) { 111 | return A4(hsla,hue,saturation,lightness,1); 112 | }); 113 | var complement = function (color) { 114 | var _p5 = color; 115 | if (_p5.ctor === "HSLA") { 116 | return A4(hsla, 117 | _p5._0 + $Basics.degrees(180), 118 | _p5._1, 119 | _p5._2, 120 | _p5._3); 121 | } else { 122 | var _p6 = A3(rgbToHsl,_p5._0,_p5._1,_p5._2); 123 | var h = _p6._0; 124 | var s = _p6._1; 125 | var l = _p6._2; 126 | return A4(hsla,h + $Basics.degrees(180),s,l,_p5._3); 127 | } 128 | }; 129 | var grayscale = function (p) { return A4(HSLA,0,0,1 - p,1);}; 130 | var greyscale = function (p) { return A4(HSLA,0,0,1 - p,1);}; 131 | var RGBA = F4(function (a,b,c,d) { 132 | return {ctor: "RGBA",_0: a,_1: b,_2: c,_3: d}; 133 | }); 134 | var rgba = RGBA; 135 | var rgb = F3(function (r,g,b) { return A4(RGBA,r,g,b,1);}); 136 | var lightRed = A4(RGBA,239,41,41,1); 137 | var red = A4(RGBA,204,0,0,1); 138 | var darkRed = A4(RGBA,164,0,0,1); 139 | var lightOrange = A4(RGBA,252,175,62,1); 140 | var orange = A4(RGBA,245,121,0,1); 141 | var darkOrange = A4(RGBA,206,92,0,1); 142 | var lightYellow = A4(RGBA,255,233,79,1); 143 | var yellow = A4(RGBA,237,212,0,1); 144 | var darkYellow = A4(RGBA,196,160,0,1); 145 | var lightGreen = A4(RGBA,138,226,52,1); 146 | var green = A4(RGBA,115,210,22,1); 147 | var darkGreen = A4(RGBA,78,154,6,1); 148 | var lightBlue = A4(RGBA,114,159,207,1); 149 | var blue = A4(RGBA,52,101,164,1); 150 | var darkBlue = A4(RGBA,32,74,135,1); 151 | var lightPurple = A4(RGBA,173,127,168,1); 152 | var purple = A4(RGBA,117,80,123,1); 153 | var darkPurple = A4(RGBA,92,53,102,1); 154 | var lightBrown = A4(RGBA,233,185,110,1); 155 | var brown = A4(RGBA,193,125,17,1); 156 | var darkBrown = A4(RGBA,143,89,2,1); 157 | var black = A4(RGBA,0,0,0,1); 158 | var white = A4(RGBA,255,255,255,1); 159 | var lightGrey = A4(RGBA,238,238,236,1); 160 | var grey = A4(RGBA,211,215,207,1); 161 | var darkGrey = A4(RGBA,186,189,182,1); 162 | var lightGray = A4(RGBA,238,238,236,1); 163 | var gray = A4(RGBA,211,215,207,1); 164 | var darkGray = A4(RGBA,186,189,182,1); 165 | var lightCharcoal = A4(RGBA,136,138,133,1); 166 | var charcoal = A4(RGBA,85,87,83,1); 167 | var darkCharcoal = A4(RGBA,46,52,54,1); 168 | return _elm.Color.values = {_op: _op 169 | ,rgb: rgb 170 | ,rgba: rgba 171 | ,hsl: hsl 172 | ,hsla: hsla 173 | ,greyscale: greyscale 174 | ,grayscale: grayscale 175 | ,complement: complement 176 | ,linear: linear 177 | ,radial: radial 178 | ,toRgb: toRgb 179 | ,toHsl: toHsl 180 | ,red: red 181 | ,orange: orange 182 | ,yellow: yellow 183 | ,green: green 184 | ,blue: blue 185 | ,purple: purple 186 | ,brown: brown 187 | ,lightRed: lightRed 188 | ,lightOrange: lightOrange 189 | ,lightYellow: lightYellow 190 | ,lightGreen: lightGreen 191 | ,lightBlue: lightBlue 192 | ,lightPurple: lightPurple 193 | ,lightBrown: lightBrown 194 | ,darkRed: darkRed 195 | ,darkOrange: darkOrange 196 | ,darkYellow: darkYellow 197 | ,darkGreen: darkGreen 198 | ,darkBlue: darkBlue 199 | ,darkPurple: darkPurple 200 | ,darkBrown: darkBrown 201 | ,white: white 202 | ,lightGrey: lightGrey 203 | ,grey: grey 204 | ,darkGrey: darkGrey 205 | ,lightCharcoal: lightCharcoal 206 | ,charcoal: charcoal 207 | ,darkCharcoal: darkCharcoal 208 | ,black: black 209 | ,lightGray: lightGray 210 | ,gray: gray 211 | ,darkGray: darkGray}; 212 | }; -------------------------------------------------------------------------------- /elm-stuff/build-artifacts/0.16.0/elm-lang/core/3.0.0/Date.elmi: -------------------------------------------------------------------------------- 1 | elm-langcore 2 | fromStringtoTimefromTimeyearmonthday dayOfWeekhourminutesecond millisecondDateMonth JanFebMarAprMayJunJulAugSepOctNovDecDayMonTueWedThuFriSatSun ::aListaListaAprelm-langcoreDateMonthAugelm-langcoreDateMonthDateelm-langcoreDateDateDecelm-langcoreDateMonthFebelm-langcoreDateMonthFrielm-langcoreDateDayJanelm-langcoreDateMonthJulelm-langcoreDateMonthJunelm-langcoreDateMonthMarelm-langcoreDateMonthMayelm-langcoreDateMonthMonelm-langcoreDateDayNovelm-langcoreDateMonthOctelm-langcoreDateMonthSatelm-langcoreDateDaySepelm-langcoreDateMonthSunelm-langcoreDateDayThuelm-langcoreDateDayTueelm-langcoreDateDayWedelm-langcoreDateDaydayelm-langcoreDateDateInt dayOfWeekelm-langcoreDateDateelm-langcoreDateDay 3 | fromStringStringelm-langcoreResultResultStringelm-langcoreDateDatefromTimeelm-langcoreTimeTimeFloatelm-langcoreDateDatehourelm-langcoreDateDateInt millisecondelm-langcoreDateDateIntminuteelm-langcoreDateDateIntmonthelm-langcoreDateDateelm-langcoreDateMonthsecondelm-langcoreDateDateInttoTimeelm-langcoreDateDateelm-langcoreTimeTimeFloatyearelm-langcoreDateDateIntNativeDateResultTimeDateDateDayMonTueWedThuFriSatSunMonth JanFebMarAprMayJunJulAugSepOctNovDec -------------------------------------------------------------------------------- /elm-stuff/build-artifacts/0.16.0/elm-lang/core/3.0.0/Date.elmo: -------------------------------------------------------------------------------- 1 | Elm.Date = Elm.Date || {}; 2 | Elm.Date.make = function (_elm) { 3 | "use strict"; 4 | _elm.Date = _elm.Date || {}; 5 | if (_elm.Date.values) return _elm.Date.values; 6 | var _U = Elm.Native.Utils.make(_elm), 7 | $Native$Date = Elm.Native.Date.make(_elm), 8 | $Result = Elm.Result.make(_elm), 9 | $Time = Elm.Time.make(_elm); 10 | var _op = {}; 11 | var millisecond = $Native$Date.millisecond; 12 | var second = $Native$Date.second; 13 | var minute = $Native$Date.minute; 14 | var hour = $Native$Date.hour; 15 | var dayOfWeek = $Native$Date.dayOfWeek; 16 | var day = $Native$Date.day; 17 | var month = $Native$Date.month; 18 | var year = $Native$Date.year; 19 | var fromTime = $Native$Date.fromTime; 20 | var toTime = $Native$Date.toTime; 21 | var fromString = $Native$Date.read; 22 | var Dec = {ctor: "Dec"}; 23 | var Nov = {ctor: "Nov"}; 24 | var Oct = {ctor: "Oct"}; 25 | var Sep = {ctor: "Sep"}; 26 | var Aug = {ctor: "Aug"}; 27 | var Jul = {ctor: "Jul"}; 28 | var Jun = {ctor: "Jun"}; 29 | var May = {ctor: "May"}; 30 | var Apr = {ctor: "Apr"}; 31 | var Mar = {ctor: "Mar"}; 32 | var Feb = {ctor: "Feb"}; 33 | var Jan = {ctor: "Jan"}; 34 | var Sun = {ctor: "Sun"}; 35 | var Sat = {ctor: "Sat"}; 36 | var Fri = {ctor: "Fri"}; 37 | var Thu = {ctor: "Thu"}; 38 | var Wed = {ctor: "Wed"}; 39 | var Tue = {ctor: "Tue"}; 40 | var Mon = {ctor: "Mon"}; 41 | var Date = {ctor: "Date"}; 42 | return _elm.Date.values = {_op: _op 43 | ,fromString: fromString 44 | ,toTime: toTime 45 | ,fromTime: fromTime 46 | ,year: year 47 | ,month: month 48 | ,day: day 49 | ,dayOfWeek: dayOfWeek 50 | ,hour: hour 51 | ,minute: minute 52 | ,second: second 53 | ,millisecond: millisecond 54 | ,Jan: Jan 55 | ,Feb: Feb 56 | ,Mar: Mar 57 | ,Apr: Apr 58 | ,May: May 59 | ,Jun: Jun 60 | ,Jul: Jul 61 | ,Aug: Aug 62 | ,Sep: Sep 63 | ,Oct: Oct 64 | ,Nov: Nov 65 | ,Dec: Dec 66 | ,Mon: Mon 67 | ,Tue: Tue 68 | ,Wed: Wed 69 | ,Thu: Thu 70 | ,Fri: Fri 71 | ,Sat: Sat 72 | ,Sun: Sun}; 73 | }; -------------------------------------------------------------------------------- /elm-stuff/build-artifacts/0.16.0/elm-lang/core/3.0.0/Debug.elmi: -------------------------------------------------------------------------------- 1 | elm-langcorelogcrashwatch watchSummarytrace::aListaListacrashStringalogStringaatraceStringelm-langcoreGraphicsCollageFormelm-langcoreGraphicsCollageFormwatchStringaa watchSummaryStringabaaGraphicsCollageNativeDebug -------------------------------------------------------------------------------- /elm-stuff/build-artifacts/0.16.0/elm-lang/core/3.0.0/Debug.elmo: -------------------------------------------------------------------------------- 1 | Elm.Debug = Elm.Debug || {}; 2 | Elm.Debug.make = function (_elm) { 3 | "use strict"; 4 | _elm.Debug = _elm.Debug || {}; 5 | if (_elm.Debug.values) return _elm.Debug.values; 6 | var _U = Elm.Native.Utils.make(_elm), 7 | $Graphics$Collage = Elm.Graphics.Collage.make(_elm), 8 | $Native$Debug = Elm.Native.Debug.make(_elm); 9 | var _op = {}; 10 | var trace = $Native$Debug.tracePath; 11 | var watchSummary = $Native$Debug.watchSummary; 12 | var watch = $Native$Debug.watch; 13 | var crash = $Native$Debug.crash; 14 | var log = $Native$Debug.log; 15 | return _elm.Debug.values = {_op: _op 16 | ,log: log 17 | ,crash: crash 18 | ,watch: watch 19 | ,watchSummary: watchSummary 20 | ,trace: trace}; 21 | }; -------------------------------------------------------------------------------- /elm-stuff/build-artifacts/0.16.0/elm-lang/core/3.0.0/Dict.elmi: -------------------------------------------------------------------------------- 1 | elm-langcoreempty singletoninsertupdateisEmptygetremovemembersizefilter partitionfoldlfoldrmapunion intersectdiffkeysvaluestoListfromListDict2::aListaListaBBlackelm-langcoreDictNColorBlackelm-langcoreDictNColorInsertelm-langcoreDictFlagLBBlackelm-langcoreDict LeafColorLBlackelm-langcoreDict LeafColorNBlackelm-langcoreDictNColorRBEmpty_elm_builtinelm-langcoreDict LeafColorelm-langcoreDictDictabRBNode_elm_builtinelm-langcoreDictNColorabelm-langcoreDictDictabelm-langcoreDictDictabelm-langcoreDictDictabRedelm-langcoreDictNColorRemoveelm-langcoreDictFlagSameelm-langcoreDictFlagbalanceelm-langcoreDictNColorabelm-langcoreDictDictabelm-langcoreDictDictabelm-langcoreDictDictab balanceHelpelm-langcoreDictDictabelm-langcoreDictDictab balancedTreeelm-langcoreDictNColorabababelm-langcoreDictDictabelm-langcoreDictDictabelm-langcoreDictDictabelm-langcoreDictDictabelm-langcoreDictDictabblackenelm-langcoreDictDictabelm-langcoreDictDictabblackishelm-langcoreDictDictabBoolbubbleelm-langcoreDictNColorabelm-langcoreDictDictabelm-langcoreDictDictabelm-langcoreDictDictabdiffelm-langcoreDictDict 2 | comparableaelm-langcoreDictDict 3 | comparableaelm-langcoreDictDict 4 | comparableaemptyelm-langcoreDictDictabensureBlackRootelm-langcoreDictDictabelm-langcoreDictDictabfilter 5 | comparableaBoolelm-langcoreDictDict 6 | comparableaelm-langcoreDictDict 7 | comparableafoldl 8 | comparableabbbelm-langcoreDictDict 9 | comparableabfoldr 10 | comparableabbbelm-langcoreDictDict 11 | comparableabfromListList_Tuple2 12 | comparableaelm-langcoreDictDict 13 | comparableaget 14 | comparableelm-langcoreDictDict 15 | comparableaelm-langcoreMaybeMaybeainsert 16 | comparableaelm-langcoreDictDict 17 | comparableaelm-langcoreDictDict 18 | comparablea intersectelm-langcoreDictDict 19 | comparableaelm-langcoreDictDict 20 | comparableaelm-langcoreDictDict 21 | comparableaisBBlackelm-langcoreDictDictabBoolisEmptyelm-langcoreDictDictabBoolkeyselm-langcoreDictDict 22 | comparableaList 23 | comparable lessBlackelm-langcoreDictNColorelm-langcoreDictNColor lessBlackTreeelm-langcoreDictDictabelm-langcoreDictDictabmap 24 | comparableabelm-langcoreDictDict 25 | comparableaelm-langcoreDictDict 26 | comparablebmaxWithDefaultabelm-langcoreDictDictab_Tuple2abmember 27 | comparableelm-langcoreDictDict 28 | comparableaBool moreBlackelm-langcoreDictNColorelm-langcoreDictNColor partition 29 | comparableaBoolelm-langcoreDictDict 30 | comparablea_Tuple2elm-langcoreDictDict 31 | comparableaelm-langcoreDictDict 32 | comparableareddenelm-langcoreDictDictabelm-langcoreDictDictabremelm-langcoreDictNColorelm-langcoreDictDictabelm-langcoreDictDictabelm-langcoreDictDictabremove 33 | comparableelm-langcoreDictDict 34 | comparableaelm-langcoreDictDict 35 | comparablea removeMaxelm-langcoreDictNColorabelm-langcoreDictDictabelm-langcoreDictDictabelm-langcoreDictDictab reportRemBugStringelm-langcoreDictNColorStringStringa singleton 36 | comparableaelm-langcoreDictDict 37 | comparableasizeelm-langcoreDictDictabIntsizeHelpIntelm-langcoreDictDictabInttoListelm-langcoreDictDict 38 | comparableaList_Tuple2 39 | comparableaunionelm-langcoreDictDict 40 | comparableaelm-langcoreDictDict 41 | comparableaelm-langcoreDictDict 42 | comparableaupdate 43 | comparableelm-langcoreMaybeMaybeaelm-langcoreMaybeMaybeaelm-langcoreDictDict 44 | comparableaelm-langcoreDictDict 45 | comparableavalueselm-langcoreDictDict 46 | comparableaListaBasicsListMaybeNativeDebugStringDictkvRBNode_elm_builtinelm-langcoreDictNColorkvelm-langcoreDictDictkvelm-langcoreDictDictkvRBEmpty_elm_builtinelm-langcoreDict LeafColorFlagInsertRemoveSame LeafColorLBlackLBBlackNColorRedBlackBBlackNBlack -------------------------------------------------------------------------------- /elm-stuff/build-artifacts/0.16.0/elm-lang/core/3.0.0/Graphics-Collage.elmo: -------------------------------------------------------------------------------- 1 | Elm.Graphics = Elm.Graphics || {}; 2 | Elm.Graphics.Collage = Elm.Graphics.Collage || {}; 3 | Elm.Graphics.Collage.make = function (_elm) { 4 | "use strict"; 5 | _elm.Graphics = _elm.Graphics || {}; 6 | _elm.Graphics.Collage = _elm.Graphics.Collage || {}; 7 | if (_elm.Graphics.Collage.values) 8 | return _elm.Graphics.Collage.values; 9 | var _U = Elm.Native.Utils.make(_elm), 10 | $Basics = Elm.Basics.make(_elm), 11 | $Color = Elm.Color.make(_elm), 12 | $Graphics$Element = Elm.Graphics.Element.make(_elm), 13 | $List = Elm.List.make(_elm), 14 | $Native$Graphics$Collage = Elm.Native.Graphics.Collage.make(_elm), 15 | $Text = Elm.Text.make(_elm), 16 | $Transform2D = Elm.Transform2D.make(_elm); 17 | var _op = {}; 18 | var Shape = function (a) { return {ctor: "Shape",_0: a};}; 19 | var polygon = function (points) { return Shape(points);}; 20 | var rect = F2(function (w,h) { 21 | var hh = h / 2; 22 | var hw = w / 2; 23 | return Shape(_U.list([{ctor: "_Tuple2",_0: 0 - hw,_1: 0 - hh} 24 | ,{ctor: "_Tuple2",_0: 0 - hw,_1: hh} 25 | ,{ctor: "_Tuple2",_0: hw,_1: hh} 26 | ,{ctor: "_Tuple2",_0: hw,_1: 0 - hh}])); 27 | }); 28 | var square = function (n) { return A2(rect,n,n);}; 29 | var oval = F2(function (w,h) { 30 | var hh = h / 2; 31 | var hw = w / 2; 32 | var n = 50; 33 | var t = 2 * $Basics.pi / n; 34 | var f = function (i) { 35 | return {ctor: "_Tuple2" 36 | ,_0: hw * $Basics.cos(t * i) 37 | ,_1: hh * $Basics.sin(t * i)}; 38 | }; 39 | return Shape(A2($List.map,f,_U.range(0,n - 1))); 40 | }); 41 | var circle = function (r) { return A2(oval,2 * r,2 * r);}; 42 | var ngon = F2(function (n,r) { 43 | var m = $Basics.toFloat(n); 44 | var t = 2 * $Basics.pi / m; 45 | var f = function (i) { 46 | return {ctor: "_Tuple2" 47 | ,_0: r * $Basics.cos(t * i) 48 | ,_1: r * $Basics.sin(t * i)}; 49 | }; 50 | return Shape(A2($List.map,f,_U.range(0,m - 1))); 51 | }); 52 | var Path = function (a) { return {ctor: "Path",_0: a};}; 53 | var path = function (ps) { return Path(ps);}; 54 | var segment = F2(function (p1,p2) { 55 | return Path(_U.list([p1,p2])); 56 | }); 57 | var collage = $Native$Graphics$Collage.collage; 58 | var Fill = function (a) { return {ctor: "Fill",_0: a};}; 59 | var Line = function (a) { return {ctor: "Line",_0: a};}; 60 | var FGroup = F2(function (a,b) { 61 | return {ctor: "FGroup",_0: a,_1: b}; 62 | }); 63 | var FElement = function (a) { 64 | return {ctor: "FElement",_0: a}; 65 | }; 66 | var FImage = F4(function (a,b,c,d) { 67 | return {ctor: "FImage",_0: a,_1: b,_2: c,_3: d}; 68 | }); 69 | var FText = function (a) { return {ctor: "FText",_0: a};}; 70 | var FOutlinedText = F2(function (a,b) { 71 | return {ctor: "FOutlinedText",_0: a,_1: b}; 72 | }); 73 | var FShape = F2(function (a,b) { 74 | return {ctor: "FShape",_0: a,_1: b}; 75 | }); 76 | var FPath = F2(function (a,b) { 77 | return {ctor: "FPath",_0: a,_1: b}; 78 | }); 79 | var LineStyle = F6(function (a,b,c,d,e,f) { 80 | return {color: a 81 | ,width: b 82 | ,cap: c 83 | ,join: d 84 | ,dashing: e 85 | ,dashOffset: f}; 86 | }); 87 | var Clipped = {ctor: "Clipped"}; 88 | var Sharp = function (a) { return {ctor: "Sharp",_0: a};}; 89 | var Smooth = {ctor: "Smooth"}; 90 | var Padded = {ctor: "Padded"}; 91 | var Round = {ctor: "Round"}; 92 | var Flat = {ctor: "Flat"}; 93 | var defaultLine = {color: $Color.black 94 | ,width: 1 95 | ,cap: Flat 96 | ,join: Sharp(10) 97 | ,dashing: _U.list([]) 98 | ,dashOffset: 0}; 99 | var solid = function (clr) { 100 | return _U.update(defaultLine,{color: clr}); 101 | }; 102 | var dashed = function (clr) { 103 | return _U.update(defaultLine, 104 | {color: clr,dashing: _U.list([8,4])}); 105 | }; 106 | var dotted = function (clr) { 107 | return _U.update(defaultLine, 108 | {color: clr,dashing: _U.list([3,3])}); 109 | }; 110 | var Grad = function (a) { return {ctor: "Grad",_0: a};}; 111 | var Texture = function (a) { 112 | return {ctor: "Texture",_0: a}; 113 | }; 114 | var Solid = function (a) { return {ctor: "Solid",_0: a};}; 115 | var Form_elm_builtin = function (a) { 116 | return {ctor: "Form_elm_builtin",_0: a}; 117 | }; 118 | var form = function (f) { 119 | return Form_elm_builtin({theta: 0 120 | ,scale: 1 121 | ,x: 0 122 | ,y: 0 123 | ,alpha: 1 124 | ,form: f}); 125 | }; 126 | var fill = F2(function (style,_p0) { 127 | var _p1 = _p0; 128 | return form(A2(FShape,Fill(style),_p1._0)); 129 | }); 130 | var filled = F2(function (color,shape) { 131 | return A2(fill,Solid(color),shape); 132 | }); 133 | var textured = F2(function (src,shape) { 134 | return A2(fill,Texture(src),shape); 135 | }); 136 | var gradient = F2(function (grad,shape) { 137 | return A2(fill,Grad(grad),shape); 138 | }); 139 | var outlined = F2(function (style,_p2) { 140 | var _p3 = _p2; 141 | return form(A2(FShape,Line(style),_p3._0)); 142 | }); 143 | var traced = F2(function (style,_p4) { 144 | var _p5 = _p4; 145 | return form(A2(FPath,style,_p5._0)); 146 | }); 147 | var sprite = F4(function (w,h,pos,src) { 148 | return form(A4(FImage,w,h,pos,src)); 149 | }); 150 | var toForm = function (e) { return form(FElement(e));}; 151 | var group = function (fs) { 152 | return form(A2(FGroup,$Transform2D.identity,fs)); 153 | }; 154 | var groupTransform = F2(function (matrix,fs) { 155 | return form(A2(FGroup,matrix,fs)); 156 | }); 157 | var text = function (t) { return form(FText(t));}; 158 | var outlinedText = F2(function (ls,t) { 159 | return form(A2(FOutlinedText,ls,t)); 160 | }); 161 | var move = F2(function (_p7,_p6) { 162 | var _p8 = _p7; 163 | var _p9 = _p6; 164 | var _p10 = _p9._0; 165 | return Form_elm_builtin(_U.update(_p10, 166 | {x: _p10.x + _p8._0,y: _p10.y + _p8._1})); 167 | }); 168 | var moveX = F2(function (x,_p11) { 169 | var _p12 = _p11; 170 | var _p13 = _p12._0; 171 | return Form_elm_builtin(_U.update(_p13,{x: _p13.x + x})); 172 | }); 173 | var moveY = F2(function (y,_p14) { 174 | var _p15 = _p14; 175 | var _p16 = _p15._0; 176 | return Form_elm_builtin(_U.update(_p16,{y: _p16.y + y})); 177 | }); 178 | var scale = F2(function (s,_p17) { 179 | var _p18 = _p17; 180 | var _p19 = _p18._0; 181 | return Form_elm_builtin(_U.update(_p19, 182 | {scale: _p19.scale * s})); 183 | }); 184 | var rotate = F2(function (t,_p20) { 185 | var _p21 = _p20; 186 | var _p22 = _p21._0; 187 | return Form_elm_builtin(_U.update(_p22, 188 | {theta: _p22.theta + t})); 189 | }); 190 | var alpha = F2(function (a,_p23) { 191 | var _p24 = _p23; 192 | return Form_elm_builtin(_U.update(_p24._0,{alpha: a})); 193 | }); 194 | return _elm.Graphics.Collage.values = {_op: _op 195 | ,collage: collage 196 | ,toForm: toForm 197 | ,filled: filled 198 | ,textured: textured 199 | ,gradient: gradient 200 | ,outlined: outlined 201 | ,traced: traced 202 | ,text: text 203 | ,outlinedText: outlinedText 204 | ,move: move 205 | ,moveX: moveX 206 | ,moveY: moveY 207 | ,scale: scale 208 | ,rotate: rotate 209 | ,alpha: alpha 210 | ,group: group 211 | ,groupTransform: groupTransform 212 | ,rect: rect 213 | ,oval: oval 214 | ,square: square 215 | ,circle: circle 216 | ,ngon: ngon 217 | ,polygon: polygon 218 | ,segment: segment 219 | ,path: path 220 | ,solid: solid 221 | ,dashed: dashed 222 | ,dotted: dotted 223 | ,defaultLine: defaultLine 224 | ,LineStyle: LineStyle 225 | ,Flat: Flat 226 | ,Round: Round 227 | ,Padded: Padded 228 | ,Smooth: Smooth 229 | ,Sharp: Sharp 230 | ,Clipped: Clipped}; 231 | }; -------------------------------------------------------------------------------- /elm-stuff/build-artifacts/0.16.0/elm-lang/core/3.0.0/Graphics-Input-Field.elmo: -------------------------------------------------------------------------------- 1 | Elm.Graphics = Elm.Graphics || {}; 2 | Elm.Graphics.Input = Elm.Graphics.Input || {}; 3 | Elm.Graphics.Input.Field = Elm.Graphics.Input.Field || {}; 4 | Elm.Graphics.Input.Field.make = function (_elm) { 5 | "use strict"; 6 | _elm.Graphics = _elm.Graphics || {}; 7 | _elm.Graphics.Input = _elm.Graphics.Input || {}; 8 | _elm.Graphics.Input.Field = _elm.Graphics.Input.Field || {}; 9 | if (_elm.Graphics.Input.Field.values) 10 | return _elm.Graphics.Input.Field.values; 11 | var _U = Elm.Native.Utils.make(_elm), 12 | $Color = Elm.Color.make(_elm), 13 | $Graphics$Element = Elm.Graphics.Element.make(_elm), 14 | $Native$Graphics$Input = Elm.Native.Graphics.Input.make(_elm), 15 | $Signal = Elm.Signal.make(_elm), 16 | $Text = Elm.Text.make(_elm); 17 | var _op = {}; 18 | var email = $Native$Graphics$Input.email; 19 | var password = $Native$Graphics$Input.password; 20 | var field = $Native$Graphics$Input.field; 21 | var Backward = {ctor: "Backward"}; 22 | var Forward = {ctor: "Forward"}; 23 | var Selection = F3(function (a,b,c) { 24 | return {start: a,end: b,direction: c}; 25 | }); 26 | var Content = F2(function (a,b) { 27 | return {string: a,selection: b}; 28 | }); 29 | var noContent = A2(Content,"",A3(Selection,0,0,Forward)); 30 | var Style = F4(function (a,b,c,d) { 31 | return {padding: a,outline: b,highlight: c,style: d}; 32 | }); 33 | var Highlight = F2(function (a,b) { 34 | return {color: a,width: b}; 35 | }); 36 | var noHighlight = A2(Highlight,$Color.blue,0); 37 | var Outline = F3(function (a,b,c) { 38 | return {color: a,width: b,radius: c}; 39 | }); 40 | var Dimensions = F4(function (a,b,c,d) { 41 | return {left: a,right: b,top: c,bottom: d}; 42 | }); 43 | var uniformly = function (n) { 44 | return A4(Dimensions,n,n,n,n); 45 | }; 46 | var noOutline = A3(Outline,$Color.grey,uniformly(0),0); 47 | var defaultStyle = {padding: uniformly(4) 48 | ,outline: A3(Outline,$Color.grey,uniformly(1),2) 49 | ,highlight: A2(Highlight,$Color.blue,1) 50 | ,style: $Text.defaultStyle}; 51 | return _elm.Graphics.Input.Field.values = {_op: _op 52 | ,field: field 53 | ,password: password 54 | ,email: email 55 | ,noContent: noContent 56 | ,defaultStyle: defaultStyle 57 | ,noOutline: noOutline 58 | ,noHighlight: noHighlight 59 | ,uniformly: uniformly 60 | ,Content: Content 61 | ,Selection: Selection 62 | ,Style: Style 63 | ,Outline: Outline 64 | ,Highlight: Highlight 65 | ,Dimensions: Dimensions 66 | ,Forward: Forward 67 | ,Backward: Backward}; 68 | }; -------------------------------------------------------------------------------- /elm-stuff/build-artifacts/0.16.0/elm-lang/core/3.0.0/Graphics-Input.elmi: -------------------------------------------------------------------------------- 1 | elm-langcorebutton customButtoncheckboxdropDown hoverable clickable::aListaListabuttonelm-langcoreSignalMessageStringelm-langcoreGraphicsElementElementcheckboxBoolelm-langcoreSignalMessageBoolelm-langcoreGraphicsElementElement clickableelm-langcoreSignalMessageelm-langcoreGraphicsElementElementelm-langcoreGraphicsElementElement customButtonelm-langcoreSignalMessageelm-langcoreGraphicsElementElementelm-langcoreGraphicsElementElementelm-langcoreGraphicsElementElementelm-langcoreGraphicsElementElementdropDownaelm-langcoreSignalMessageList_Tuple2Stringaelm-langcoreGraphicsElementElement hoverableBoolelm-langcoreSignalMessageelm-langcoreGraphicsElementElementelm-langcoreGraphicsElementElementGraphicsElementNativeGraphicsInputSignal -------------------------------------------------------------------------------- /elm-stuff/build-artifacts/0.16.0/elm-lang/core/3.0.0/Graphics-Input.elmo: -------------------------------------------------------------------------------- 1 | Elm.Graphics = Elm.Graphics || {}; 2 | Elm.Graphics.Input = Elm.Graphics.Input || {}; 3 | Elm.Graphics.Input.make = function (_elm) { 4 | "use strict"; 5 | _elm.Graphics = _elm.Graphics || {}; 6 | _elm.Graphics.Input = _elm.Graphics.Input || {}; 7 | if (_elm.Graphics.Input.values) 8 | return _elm.Graphics.Input.values; 9 | var _U = Elm.Native.Utils.make(_elm), 10 | $Graphics$Element = Elm.Graphics.Element.make(_elm), 11 | $Native$Graphics$Input = Elm.Native.Graphics.Input.make(_elm), 12 | $Signal = Elm.Signal.make(_elm); 13 | var _op = {}; 14 | var clickable = $Native$Graphics$Input.clickable; 15 | var hoverable = $Native$Graphics$Input.hoverable; 16 | var dropDown = $Native$Graphics$Input.dropDown; 17 | var checkbox = $Native$Graphics$Input.checkbox; 18 | var customButton = $Native$Graphics$Input.customButton; 19 | var button = $Native$Graphics$Input.button; 20 | return _elm.Graphics.Input.values = {_op: _op 21 | ,button: button 22 | ,customButton: customButton 23 | ,checkbox: checkbox 24 | ,dropDown: dropDown 25 | ,hoverable: hoverable 26 | ,clickable: clickable}; 27 | }; -------------------------------------------------------------------------------- /elm-stuff/build-artifacts/0.16.0/elm-lang/core/3.0.0/Json-Decode.elmo: -------------------------------------------------------------------------------- 1 | Elm.Json = Elm.Json || {}; 2 | Elm.Json.Decode = Elm.Json.Decode || {}; 3 | Elm.Json.Decode.make = function (_elm) { 4 | "use strict"; 5 | _elm.Json = _elm.Json || {}; 6 | _elm.Json.Decode = _elm.Json.Decode || {}; 7 | if (_elm.Json.Decode.values) return _elm.Json.Decode.values; 8 | var _U = Elm.Native.Utils.make(_elm), 9 | $Array = Elm.Array.make(_elm), 10 | $Dict = Elm.Dict.make(_elm), 11 | $Json$Encode = Elm.Json.Encode.make(_elm), 12 | $List = Elm.List.make(_elm), 13 | $Maybe = Elm.Maybe.make(_elm), 14 | $Native$Json = Elm.Native.Json.make(_elm), 15 | $Result = Elm.Result.make(_elm); 16 | var _op = {}; 17 | var tuple8 = $Native$Json.decodeTuple8; 18 | var tuple7 = $Native$Json.decodeTuple7; 19 | var tuple6 = $Native$Json.decodeTuple6; 20 | var tuple5 = $Native$Json.decodeTuple5; 21 | var tuple4 = $Native$Json.decodeTuple4; 22 | var tuple3 = $Native$Json.decodeTuple3; 23 | var tuple2 = $Native$Json.decodeTuple2; 24 | var tuple1 = $Native$Json.decodeTuple1; 25 | var succeed = $Native$Json.succeed; 26 | var fail = $Native$Json.fail; 27 | var andThen = $Native$Json.andThen; 28 | var customDecoder = $Native$Json.customDecoder; 29 | var decodeValue = $Native$Json.runDecoderValue; 30 | var value = $Native$Json.decodeValue; 31 | var maybe = $Native$Json.decodeMaybe; 32 | var $null = $Native$Json.decodeNull; 33 | var array = $Native$Json.decodeArray; 34 | var list = $Native$Json.decodeList; 35 | var bool = $Native$Json.decodeBool; 36 | var $int = $Native$Json.decodeInt; 37 | var $float = $Native$Json.decodeFloat; 38 | var string = $Native$Json.decodeString; 39 | var oneOf = $Native$Json.oneOf; 40 | var keyValuePairs = $Native$Json.decodeKeyValuePairs; 41 | var object8 = $Native$Json.decodeObject8; 42 | var object7 = $Native$Json.decodeObject7; 43 | var object6 = $Native$Json.decodeObject6; 44 | var object5 = $Native$Json.decodeObject5; 45 | var object4 = $Native$Json.decodeObject4; 46 | var object3 = $Native$Json.decodeObject3; 47 | var object2 = $Native$Json.decodeObject2; 48 | var object1 = $Native$Json.decodeObject1; 49 | _op[":="] = $Native$Json.decodeField; 50 | var at = F2(function (fields,decoder) { 51 | return A3($List.foldr, 52 | F2(function (x,y) { return A2(_op[":="],x,y);}), 53 | decoder, 54 | fields); 55 | }); 56 | var decodeString = $Native$Json.runDecoderString; 57 | var map = $Native$Json.decodeObject1; 58 | var dict = function (decoder) { 59 | return A2(map,$Dict.fromList,keyValuePairs(decoder)); 60 | }; 61 | var Decoder = {ctor: "Decoder"}; 62 | return _elm.Json.Decode.values = {_op: _op 63 | ,decodeString: decodeString 64 | ,decodeValue: decodeValue 65 | ,string: string 66 | ,$int: $int 67 | ,$float: $float 68 | ,bool: bool 69 | ,$null: $null 70 | ,list: list 71 | ,array: array 72 | ,tuple1: tuple1 73 | ,tuple2: tuple2 74 | ,tuple3: tuple3 75 | ,tuple4: tuple4 76 | ,tuple5: tuple5 77 | ,tuple6: tuple6 78 | ,tuple7: tuple7 79 | ,tuple8: tuple8 80 | ,at: at 81 | ,object1: object1 82 | ,object2: object2 83 | ,object3: object3 84 | ,object4: object4 85 | ,object5: object5 86 | ,object6: object6 87 | ,object7: object7 88 | ,object8: object8 89 | ,keyValuePairs: keyValuePairs 90 | ,dict: dict 91 | ,maybe: maybe 92 | ,oneOf: oneOf 93 | ,map: map 94 | ,fail: fail 95 | ,succeed: succeed 96 | ,andThen: andThen 97 | ,value: value 98 | ,customDecoder: customDecoder}; 99 | }; -------------------------------------------------------------------------------- /elm-stuff/build-artifacts/0.16.0/elm-lang/core/3.0.0/Json-Encode.elmi: -------------------------------------------------------------------------------- 1 | elm-langcore 2 | encodestringintfloatboolnulllistarrayobjectValue ::aListaListaValueelm-langcoreJsonEncodeValuearrayelm-langcoreArrayArrayelm-langcoreJsonEncodeValueelm-langcoreJsonEncodeValueboolBoolelm-langcoreJsonEncodeValueencodeIntelm-langcoreJsonEncodeValueStringfloatFloatelm-langcoreJsonEncodeValueintIntelm-langcoreJsonEncodeValuelistListelm-langcoreJsonEncodeValueelm-langcoreJsonEncodeValuenullelm-langcoreJsonEncodeValueobjectList_Tuple2Stringelm-langcoreJsonEncodeValueelm-langcoreJsonEncodeValuestringStringelm-langcoreJsonEncodeValueArrayNativeJsonValueValue -------------------------------------------------------------------------------- /elm-stuff/build-artifacts/0.16.0/elm-lang/core/3.0.0/Json-Encode.elmo: -------------------------------------------------------------------------------- 1 | Elm.Json = Elm.Json || {}; 2 | Elm.Json.Encode = Elm.Json.Encode || {}; 3 | Elm.Json.Encode.make = function (_elm) { 4 | "use strict"; 5 | _elm.Json = _elm.Json || {}; 6 | _elm.Json.Encode = _elm.Json.Encode || {}; 7 | if (_elm.Json.Encode.values) return _elm.Json.Encode.values; 8 | var _U = Elm.Native.Utils.make(_elm), 9 | $Array = Elm.Array.make(_elm), 10 | $Native$Json = Elm.Native.Json.make(_elm); 11 | var _op = {}; 12 | var list = $Native$Json.encodeList; 13 | var array = $Native$Json.encodeArray; 14 | var object = $Native$Json.encodeObject; 15 | var $null = $Native$Json.encodeNull; 16 | var bool = $Native$Json.identity; 17 | var $float = $Native$Json.identity; 18 | var $int = $Native$Json.identity; 19 | var string = $Native$Json.identity; 20 | var encode = $Native$Json.encode; 21 | var Value = {ctor: "Value"}; 22 | return _elm.Json.Encode.values = {_op: _op 23 | ,encode: encode 24 | ,string: string 25 | ,$int: $int 26 | ,$float: $float 27 | ,bool: bool 28 | ,$null: $null 29 | ,list: list 30 | ,array: array 31 | ,object: object}; 32 | }; -------------------------------------------------------------------------------- /elm-stuff/build-artifacts/0.16.0/elm-lang/core/3.0.0/Keyboard.elmi: -------------------------------------------------------------------------------- 1 | elm-langcore arrowswasdenterspacectrlshiftaltmetaisDownkeysDownpresses::aListaListaBlurelm-langcoreKeyboardEvent 2 | Directionselm-langcoreCharKeyCodeIntelm-langcoreCharKeyCodeIntelm-langcoreCharKeyCodeIntelm-langcoreCharKeyCodeIntelm-langcoreKeyboard 3 | Directionsdownelm-langcoreCharKeyCodeIntleftelm-langcoreCharKeyCodeIntrightelm-langcoreCharKeyCodeIntupelm-langcoreCharKeyCodeIntDownelm-langcoreKeyboard EventInfoaltBoolkeyCodeelm-langcoreCharKeyCodeIntmetaBoolelm-langcoreKeyboardEvent EventInfoBoolBoolelm-langcoreCharKeyCodeIntelm-langcoreKeyboard EventInfoaltBoolkeyCodeelm-langcoreCharKeyCodeIntmetaBoolModelBoolBoolelm-langcoreSetSetelm-langcoreCharKeyCodeIntelm-langcoreKeyboardModelaltBoolkeyCodeselm-langcoreSetSetelm-langcoreCharKeyCodeIntmetaBoolUpelm-langcoreKeyboard EventInfoaltBoolkeyCodeelm-langcoreCharKeyCodeIntmetaBoolelm-langcoreKeyboardEventaltelm-langcoreSignalSignalBoolarrowselm-langcoreSignalSignalxIntyIntctrlelm-langcoreSignalSignalBooldropMapabelm-langcoreSignalSignalaelm-langcoreSignalSignalbemptyelm-langcoreKeyboardModelaltBoolkeyCodeselm-langcoreSetSetelm-langcoreCharKeyCodeIntmetaBoolenterelm-langcoreSignalSignalBoolisDownelm-langcoreCharKeyCodeIntelm-langcoreSignalSignalBoolkeysDownelm-langcoreSignalSignalelm-langcoreSetSetelm-langcoreCharKeyCodeIntmetaelm-langcoreSignalSignalBoolmodelelm-langcoreSignalSignalelm-langcoreKeyboardModelaltBoolmetaBoolkeyCodeselm-langcoreSetSetelm-langcoreCharKeyCodeIntpresseselm-langcoreSignalSignalelm-langcoreCharKeyCodeInt rawEventselm-langcoreSignalSignalelm-langcoreKeyboardEventshiftelm-langcoreSignalSignalBoolspaceelm-langcoreSignalSignalBooltoXYelm-langcoreKeyboard 4 | Directionsdownelm-langcoreCharKeyCodeIntleftelm-langcoreCharKeyCodeIntrightelm-langcoreCharKeyCodeIntupelm-langcoreCharKeyCodeIntelm-langcoreSetSetelm-langcoreCharKeyCodeIntxIntyIntupdateelm-langcoreKeyboardEventelm-langcoreKeyboardModelaltBoolkeyCodeselm-langcoreSetSetelm-langcoreCharKeyCodeIntmetaBoolelm-langcoreKeyboardModelaltBoolkeyCodeselm-langcoreSetSetelm-langcoreCharKeyCodeIntmetaBoolwasdelm-langcoreSignalSignalxIntyIntBasicsCharNativeKeyboardSetSignalEventUpelm-langcoreKeyboard EventInfoaltBoolmetaBoolkeyCodeelm-langcoreCharKeyCodeIntDownelm-langcoreKeyboard EventInfoaltBoolmetaBoolkeyCodeelm-langcoreCharKeyCodeIntBlur 5 | Directionsupelm-langcoreCharKeyCodeIntdownelm-langcoreCharKeyCodeIntleftelm-langcoreCharKeyCodeIntrightelm-langcoreCharKeyCodeInt EventInfoaltBoolmetaBoolkeyCodeelm-langcoreCharKeyCodeIntModelaltBoolmetaBoolkeyCodeselm-langcoreSetSetelm-langcoreCharKeyCodeInt -------------------------------------------------------------------------------- /elm-stuff/build-artifacts/0.16.0/elm-lang/core/3.0.0/Keyboard.elmo: -------------------------------------------------------------------------------- 1 | Elm.Keyboard = Elm.Keyboard || {}; 2 | Elm.Keyboard.make = function (_elm) { 3 | "use strict"; 4 | _elm.Keyboard = _elm.Keyboard || {}; 5 | if (_elm.Keyboard.values) return _elm.Keyboard.values; 6 | var _U = Elm.Native.Utils.make(_elm), 7 | $Basics = Elm.Basics.make(_elm), 8 | $Char = Elm.Char.make(_elm), 9 | $Native$Keyboard = Elm.Native.Keyboard.make(_elm), 10 | $Set = Elm.Set.make(_elm), 11 | $Signal = Elm.Signal.make(_elm); 12 | var _op = {}; 13 | var presses = A2($Signal.map, 14 | function (_) { 15 | return _.keyCode; 16 | }, 17 | $Native$Keyboard.presses); 18 | var toXY = F2(function (_p0,keyCodes) { 19 | var _p1 = _p0; 20 | var is = function (keyCode) { 21 | return A2($Set.member,keyCode,keyCodes) ? 1 : 0; 22 | }; 23 | return {x: is(_p1.right) - is(_p1.left) 24 | ,y: is(_p1.up) - is(_p1.down)}; 25 | }); 26 | var Directions = F4(function (a,b,c,d) { 27 | return {up: a,down: b,left: c,right: d}; 28 | }); 29 | var dropMap = F2(function (f,signal) { 30 | return $Signal.dropRepeats(A2($Signal.map,f,signal)); 31 | }); 32 | var EventInfo = F3(function (a,b,c) { 33 | return {alt: a,meta: b,keyCode: c}; 34 | }); 35 | var Blur = {ctor: "Blur"}; 36 | var Down = function (a) { return {ctor: "Down",_0: a};}; 37 | var Up = function (a) { return {ctor: "Up",_0: a};}; 38 | var rawEvents = $Signal.mergeMany(_U.list([A2($Signal.map, 39 | Up, 40 | $Native$Keyboard.ups) 41 | ,A2($Signal.map,Down,$Native$Keyboard.downs) 42 | ,A2($Signal.map,$Basics.always(Blur),$Native$Keyboard.blurs)])); 43 | var empty = {alt: false,meta: false,keyCodes: $Set.empty}; 44 | var update = F2(function (event,model) { 45 | var _p2 = event; 46 | switch (_p2.ctor) 47 | {case "Down": var _p3 = _p2._0; 48 | return {alt: _p3.alt 49 | ,meta: _p3.meta 50 | ,keyCodes: A2($Set.insert,_p3.keyCode,model.keyCodes)}; 51 | case "Up": var _p4 = _p2._0; 52 | return {alt: _p4.alt 53 | ,meta: _p4.meta 54 | ,keyCodes: A2($Set.remove,_p4.keyCode,model.keyCodes)}; 55 | default: return empty;} 56 | }); 57 | var model = A3($Signal.foldp,update,empty,rawEvents); 58 | var alt = A2(dropMap,function (_) { return _.alt;},model); 59 | var meta = A2(dropMap,function (_) { return _.meta;},model); 60 | var keysDown = A2(dropMap, 61 | function (_) { 62 | return _.keyCodes; 63 | }, 64 | model); 65 | var arrows = A2(dropMap, 66 | toXY({up: 38,down: 40,left: 37,right: 39}), 67 | keysDown); 68 | var wasd = A2(dropMap, 69 | toXY({up: 87,down: 83,left: 65,right: 68}), 70 | keysDown); 71 | var isDown = function (keyCode) { 72 | return A2(dropMap,$Set.member(keyCode),keysDown); 73 | }; 74 | var ctrl = isDown(17); 75 | var shift = isDown(16); 76 | var space = isDown(32); 77 | var enter = isDown(13); 78 | var Model = F3(function (a,b,c) { 79 | return {alt: a,meta: b,keyCodes: c}; 80 | }); 81 | return _elm.Keyboard.values = {_op: _op 82 | ,arrows: arrows 83 | ,wasd: wasd 84 | ,enter: enter 85 | ,space: space 86 | ,ctrl: ctrl 87 | ,shift: shift 88 | ,alt: alt 89 | ,meta: meta 90 | ,isDown: isDown 91 | ,keysDown: keysDown 92 | ,presses: presses}; 93 | }; -------------------------------------------------------------------------------- /elm-stuff/build-artifacts/0.16.0/elm-lang/core/3.0.0/List.elmi: -------------------------------------------------------------------------------- 1 | elm-langcore$isEmptylengthreversememberheadtailfiltertakedroprepeat::appendconcat intersperse partitionunzipmapmap2map3map4map5 filterMap concatMap 2 | indexedMapfoldrfoldlsumproductmaximumminimumallanyscanlsortsortBysortWith&::aListaListaallaBoolListaBoolanyaBoolListaBoolappendListaListaListaconcatListListaLista concatMapaListbListaListbdropIntListaListafilteraBoolListaLista filterMapaelm-langcoreMaybeMaybebListaListbfoldlabbbListabfoldrabbbListabheadListaelm-langcoreMaybeMaybea 3 | indexedMapIntabListaListb intersperseaListaListaisEmptyListaBoollengthListaIntmapabListaListbmap2abcListaListbListcmap3abcdListaListbListcListdmap4abcdeListaListbListcListdListemap5abcdefListaListbListcListdListeListfmaximumList 4 | comparableelm-langcoreMaybeMaybe 5 | comparable maybeConsaelm-langcoreMaybeMaybebaListbListbmemberaListaBoolminimumList 6 | comparableelm-langcoreMaybeMaybe 7 | comparable partitionaBoolLista_Tuple2ListaListaproductListnumbernumberrepeatIntaLista 8 | repeatHelpListaIntaListareverseListaListascanlabbbListaListbsortList 9 | comparableList 10 | comparablesortBya 11 | comparableListaListasortWithaaelm-langcoreBasicsOrderListaListasumListnumbernumbertailListaelm-langcoreMaybeMaybeListatakeIntListaListaunzipList_Tuple2ab_Tuple2ListaListbBasicsMaybeNativeList:: -------------------------------------------------------------------------------- /elm-stuff/build-artifacts/0.16.0/elm-lang/core/3.0.0/List.elmo: -------------------------------------------------------------------------------- 1 | Elm.List = Elm.List || {}; 2 | Elm.List.make = function (_elm) { 3 | "use strict"; 4 | _elm.List = _elm.List || {}; 5 | if (_elm.List.values) return _elm.List.values; 6 | var _U = Elm.Native.Utils.make(_elm), 7 | $Basics = Elm.Basics.make(_elm), 8 | $Maybe = Elm.Maybe.make(_elm), 9 | $Native$List = Elm.Native.List.make(_elm); 10 | var _op = {}; 11 | var sortWith = $Native$List.sortWith; 12 | var sortBy = $Native$List.sortBy; 13 | var sort = function (xs) { 14 | return A2(sortBy,$Basics.identity,xs); 15 | }; 16 | var drop = F2(function (n,list) { 17 | drop: while (true) if (_U.cmp(n,0) < 1) return list; else { 18 | var _p0 = list; 19 | if (_p0.ctor === "[]") { 20 | return list; 21 | } else { 22 | var _v1 = n - 1,_v2 = _p0._1; 23 | n = _v1; 24 | list = _v2; 25 | continue drop; 26 | } 27 | } 28 | }); 29 | var take = $Native$List.take; 30 | var map5 = $Native$List.map5; 31 | var map4 = $Native$List.map4; 32 | var map3 = $Native$List.map3; 33 | var map2 = $Native$List.map2; 34 | var any = F2(function (isOkay,list) { 35 | any: while (true) { 36 | var _p1 = list; 37 | if (_p1.ctor === "[]") { 38 | return false; 39 | } else { 40 | if (isOkay(_p1._0)) return true; else { 41 | var _v4 = isOkay,_v5 = _p1._1; 42 | isOkay = _v4; 43 | list = _v5; 44 | continue any; 45 | } 46 | } 47 | } 48 | }); 49 | var all = F2(function (isOkay,list) { 50 | return $Basics.not(A2(any, 51 | function (_p2) { 52 | return $Basics.not(isOkay(_p2)); 53 | }, 54 | list)); 55 | }); 56 | var foldr = $Native$List.foldr; 57 | var foldl = $Native$List.foldl; 58 | var length = function (xs) { 59 | return A3(foldl, 60 | F2(function (_p3,i) { return i + 1;}), 61 | 0, 62 | xs); 63 | }; 64 | var sum = function (numbers) { 65 | return A3(foldl, 66 | F2(function (x,y) { return x + y;}), 67 | 0, 68 | numbers); 69 | }; 70 | var product = function (numbers) { 71 | return A3(foldl, 72 | F2(function (x,y) { return x * y;}), 73 | 1, 74 | numbers); 75 | }; 76 | var maximum = function (list) { 77 | var _p4 = list; 78 | if (_p4.ctor === "::") { 79 | return $Maybe.Just(A3(foldl,$Basics.max,_p4._0,_p4._1)); 80 | } else { 81 | return $Maybe.Nothing; 82 | } 83 | }; 84 | var minimum = function (list) { 85 | var _p5 = list; 86 | if (_p5.ctor === "::") { 87 | return $Maybe.Just(A3(foldl,$Basics.min,_p5._0,_p5._1)); 88 | } else { 89 | return $Maybe.Nothing; 90 | } 91 | }; 92 | var indexedMap = F2(function (f,xs) { 93 | return A3(map2,f,_U.range(0,length(xs) - 1),xs); 94 | }); 95 | var member = F2(function (x,xs) { 96 | return A2(any,function (a) { return _U.eq(a,x);},xs); 97 | }); 98 | var isEmpty = function (xs) { 99 | var _p6 = xs; 100 | if (_p6.ctor === "[]") { 101 | return true; 102 | } else { 103 | return false; 104 | } 105 | }; 106 | var tail = function (list) { 107 | var _p7 = list; 108 | if (_p7.ctor === "::") { 109 | return $Maybe.Just(_p7._1); 110 | } else { 111 | return $Maybe.Nothing; 112 | } 113 | }; 114 | var head = function (list) { 115 | var _p8 = list; 116 | if (_p8.ctor === "::") { 117 | return $Maybe.Just(_p8._0); 118 | } else { 119 | return $Maybe.Nothing; 120 | } 121 | }; 122 | _op["::"] = $Native$List.cons; 123 | var map = F2(function (f,xs) { 124 | return A3(foldr, 125 | F2(function (x,acc) { return A2(_op["::"],f(x),acc);}), 126 | _U.list([]), 127 | xs); 128 | }); 129 | var filter = F2(function (pred,xs) { 130 | var conditionalCons = F2(function (x,xs$) { 131 | return pred(x) ? A2(_op["::"],x,xs$) : xs$; 132 | }); 133 | return A3(foldr,conditionalCons,_U.list([]),xs); 134 | }); 135 | var maybeCons = F3(function (f,mx,xs) { 136 | var _p9 = f(mx); 137 | if (_p9.ctor === "Just") { 138 | return A2(_op["::"],_p9._0,xs); 139 | } else { 140 | return xs; 141 | } 142 | }); 143 | var filterMap = F2(function (f,xs) { 144 | return A3(foldr,maybeCons(f),_U.list([]),xs); 145 | }); 146 | var reverse = function (list) { 147 | return A3(foldl, 148 | F2(function (x,y) { return A2(_op["::"],x,y);}), 149 | _U.list([]), 150 | list); 151 | }; 152 | var scanl = F3(function (f,b,xs) { 153 | var scan1 = F2(function (x,accAcc) { 154 | var _p10 = accAcc; 155 | if (_p10.ctor === "::") { 156 | return A2(_op["::"],A2(f,x,_p10._0),accAcc); 157 | } else { 158 | return _U.list([]); 159 | } 160 | }); 161 | return reverse(A3(foldl,scan1,_U.list([b]),xs)); 162 | }); 163 | var append = F2(function (xs,ys) { 164 | var _p11 = ys; 165 | if (_p11.ctor === "[]") { 166 | return xs; 167 | } else { 168 | return A3(foldr, 169 | F2(function (x,y) { return A2(_op["::"],x,y);}), 170 | ys, 171 | xs); 172 | } 173 | }); 174 | var concat = function (lists) { 175 | return A3(foldr,append,_U.list([]),lists); 176 | }; 177 | var concatMap = F2(function (f,list) { 178 | return concat(A2(map,f,list)); 179 | }); 180 | var partition = F2(function (pred,list) { 181 | var step = F2(function (x,_p12) { 182 | var _p13 = _p12; 183 | var _p15 = _p13._0; 184 | var _p14 = _p13._1; 185 | return pred(x) ? {ctor: "_Tuple2" 186 | ,_0: A2(_op["::"],x,_p15) 187 | ,_1: _p14} : {ctor: "_Tuple2" 188 | ,_0: _p15 189 | ,_1: A2(_op["::"],x,_p14)}; 190 | }); 191 | return A3(foldr, 192 | step, 193 | {ctor: "_Tuple2",_0: _U.list([]),_1: _U.list([])}, 194 | list); 195 | }); 196 | var unzip = function (pairs) { 197 | var step = F2(function (_p17,_p16) { 198 | var _p18 = _p17; 199 | var _p19 = _p16; 200 | return {ctor: "_Tuple2" 201 | ,_0: A2(_op["::"],_p18._0,_p19._0) 202 | ,_1: A2(_op["::"],_p18._1,_p19._1)}; 203 | }); 204 | return A3(foldr, 205 | step, 206 | {ctor: "_Tuple2",_0: _U.list([]),_1: _U.list([])}, 207 | pairs); 208 | }; 209 | var intersperse = F2(function (sep,xs) { 210 | var _p20 = xs; 211 | if (_p20.ctor === "[]") { 212 | return _U.list([]); 213 | } else { 214 | var step = F2(function (x,rest) { 215 | return A2(_op["::"],sep,A2(_op["::"],x,rest)); 216 | }); 217 | var spersed = A3(foldr,step,_U.list([]),_p20._1); 218 | return A2(_op["::"],_p20._0,spersed); 219 | } 220 | }); 221 | var repeatHelp = F3(function (result,n,value) { 222 | repeatHelp: while (true) if (_U.cmp(n,0) < 1) return result; 223 | else { 224 | var _v18 = A2(_op["::"],value,result), 225 | _v19 = n - 1, 226 | _v20 = value; 227 | result = _v18; 228 | n = _v19; 229 | value = _v20; 230 | continue repeatHelp; 231 | } 232 | }); 233 | var repeat = F2(function (n,value) { 234 | return A3(repeatHelp,_U.list([]),n,value); 235 | }); 236 | return _elm.List.values = {_op: _op 237 | ,isEmpty: isEmpty 238 | ,length: length 239 | ,reverse: reverse 240 | ,member: member 241 | ,head: head 242 | ,tail: tail 243 | ,filter: filter 244 | ,take: take 245 | ,drop: drop 246 | ,repeat: repeat 247 | ,append: append 248 | ,concat: concat 249 | ,intersperse: intersperse 250 | ,partition: partition 251 | ,unzip: unzip 252 | ,map: map 253 | ,map2: map2 254 | ,map3: map3 255 | ,map4: map4 256 | ,map5: map5 257 | ,filterMap: filterMap 258 | ,concatMap: concatMap 259 | ,indexedMap: indexedMap 260 | ,foldr: foldr 261 | ,foldl: foldl 262 | ,sum: sum 263 | ,product: product 264 | ,maximum: maximum 265 | ,minimum: minimum 266 | ,all: all 267 | ,any: any 268 | ,scanl: scanl 269 | ,sort: sort 270 | ,sortBy: sortBy 271 | ,sortWith: sortWith}; 272 | }; -------------------------------------------------------------------------------- /elm-stuff/build-artifacts/0.16.0/elm-lang/core/3.0.0/Maybe.elmi: -------------------------------------------------------------------------------- 1 | elm-langcore andThenmapmap2map3map4map5 withDefaultoneOfMaybeJustNothing ::aListaListaJustaelm-langcoreMaybeMaybeaNothingelm-langcoreMaybeMaybeaandThenelm-langcoreMaybeMaybeaaelm-langcoreMaybeMaybebelm-langcoreMaybeMaybebmapabelm-langcoreMaybeMaybeaelm-langcoreMaybeMaybebmap2abcelm-langcoreMaybeMaybeaelm-langcoreMaybeMaybebelm-langcoreMaybeMaybecmap3abcdelm-langcoreMaybeMaybeaelm-langcoreMaybeMaybebelm-langcoreMaybeMaybecelm-langcoreMaybeMaybedmap4abcdeelm-langcoreMaybeMaybeaelm-langcoreMaybeMaybebelm-langcoreMaybeMaybecelm-langcoreMaybeMaybedelm-langcoreMaybeMaybeemap5abcdefelm-langcoreMaybeMaybeaelm-langcoreMaybeMaybebelm-langcoreMaybeMaybecelm-langcoreMaybeMaybedelm-langcoreMaybeMaybeeelm-langcoreMaybeMaybefoneOfListelm-langcoreMaybeMaybeaelm-langcoreMaybeMaybea withDefaultaelm-langcoreMaybeMaybeaaMaybeaJustaNothing -------------------------------------------------------------------------------- /elm-stuff/build-artifacts/0.16.0/elm-lang/core/3.0.0/Maybe.elmo: -------------------------------------------------------------------------------- 1 | Elm.Maybe = Elm.Maybe || {}; 2 | Elm.Maybe.make = function (_elm) { 3 | "use strict"; 4 | _elm.Maybe = _elm.Maybe || {}; 5 | if (_elm.Maybe.values) return _elm.Maybe.values; 6 | var _U = Elm.Native.Utils.make(_elm); 7 | var _op = {}; 8 | var withDefault = F2(function ($default,maybe) { 9 | var _p0 = maybe; 10 | if (_p0.ctor === "Just") { 11 | return _p0._0; 12 | } else { 13 | return $default; 14 | } 15 | }); 16 | var Nothing = {ctor: "Nothing"}; 17 | var oneOf = function (maybes) { 18 | oneOf: while (true) { 19 | var _p1 = maybes; 20 | if (_p1.ctor === "[]") { 21 | return Nothing; 22 | } else { 23 | var _p3 = _p1._0; 24 | var _p2 = _p3; 25 | if (_p2.ctor === "Nothing") { 26 | var _v3 = _p1._1; 27 | maybes = _v3; 28 | continue oneOf; 29 | } else { 30 | return _p3; 31 | } 32 | } 33 | } 34 | }; 35 | var andThen = F2(function (maybeValue,callback) { 36 | var _p4 = maybeValue; 37 | if (_p4.ctor === "Just") { 38 | return callback(_p4._0); 39 | } else { 40 | return Nothing; 41 | } 42 | }); 43 | var Just = function (a) { return {ctor: "Just",_0: a};}; 44 | var map = F2(function (f,maybe) { 45 | var _p5 = maybe; 46 | if (_p5.ctor === "Just") { 47 | return Just(f(_p5._0)); 48 | } else { 49 | return Nothing; 50 | } 51 | }); 52 | var map2 = F3(function (func,ma,mb) { 53 | var _p6 = {ctor: "_Tuple2",_0: ma,_1: mb}; 54 | if (_p6.ctor === "_Tuple2" && _p6._0.ctor === "Just" && _p6._1.ctor === "Just") 55 | { 56 | return Just(A2(func,_p6._0._0,_p6._1._0)); 57 | } else { 58 | return Nothing; 59 | } 60 | }); 61 | var map3 = F4(function (func,ma,mb,mc) { 62 | var _p7 = {ctor: "_Tuple3",_0: ma,_1: mb,_2: mc}; 63 | if (_p7.ctor === "_Tuple3" && _p7._0.ctor === "Just" && _p7._1.ctor === "Just" && _p7._2.ctor === "Just") 64 | { 65 | return Just(A3(func,_p7._0._0,_p7._1._0,_p7._2._0)); 66 | } else { 67 | return Nothing; 68 | } 69 | }); 70 | var map4 = F5(function (func,ma,mb,mc,md) { 71 | var _p8 = {ctor: "_Tuple4",_0: ma,_1: mb,_2: mc,_3: md}; 72 | if (_p8.ctor === "_Tuple4" && _p8._0.ctor === "Just" && _p8._1.ctor === "Just" && _p8._2.ctor === "Just" && _p8._3.ctor === "Just") 73 | { 74 | return Just(A4(func, 75 | _p8._0._0, 76 | _p8._1._0, 77 | _p8._2._0, 78 | _p8._3._0)); 79 | } else { 80 | return Nothing; 81 | } 82 | }); 83 | var map5 = F6(function (func,ma,mb,mc,md,me) { 84 | var _p9 = {ctor: "_Tuple5" 85 | ,_0: ma 86 | ,_1: mb 87 | ,_2: mc 88 | ,_3: md 89 | ,_4: me}; 90 | if (_p9.ctor === "_Tuple5" && _p9._0.ctor === "Just" && _p9._1.ctor === "Just" && _p9._2.ctor === "Just" && _p9._3.ctor === "Just" && _p9._4.ctor === "Just") 91 | { 92 | return Just(A5(func, 93 | _p9._0._0, 94 | _p9._1._0, 95 | _p9._2._0, 96 | _p9._3._0, 97 | _p9._4._0)); 98 | } else { 99 | return Nothing; 100 | } 101 | }); 102 | return _elm.Maybe.values = {_op: _op 103 | ,andThen: andThen 104 | ,map: map 105 | ,map2: map2 106 | ,map3: map3 107 | ,map4: map4 108 | ,map5: map5 109 | ,withDefault: withDefault 110 | ,oneOf: oneOf 111 | ,Just: Just 112 | ,Nothing: Nothing}; 113 | }; -------------------------------------------------------------------------------- /elm-stuff/build-artifacts/0.16.0/elm-lang/core/3.0.0/Mouse.elmi: -------------------------------------------------------------------------------- 1 | elm-langcorepositionxyisDownclicks::aListaListaclickselm-langcoreSignalSignal_Tuple0isDownelm-langcoreSignalSignalBoolpositionelm-langcoreSignalSignal_Tuple2IntIntxelm-langcoreSignalSignalIntyelm-langcoreSignalSignalIntBasicsNativeMouseSignal -------------------------------------------------------------------------------- /elm-stuff/build-artifacts/0.16.0/elm-lang/core/3.0.0/Mouse.elmo: -------------------------------------------------------------------------------- 1 | Elm.Mouse = Elm.Mouse || {}; 2 | Elm.Mouse.make = function (_elm) { 3 | "use strict"; 4 | _elm.Mouse = _elm.Mouse || {}; 5 | if (_elm.Mouse.values) return _elm.Mouse.values; 6 | var _U = Elm.Native.Utils.make(_elm), 7 | $Basics = Elm.Basics.make(_elm), 8 | $Native$Mouse = Elm.Native.Mouse.make(_elm), 9 | $Signal = Elm.Signal.make(_elm); 10 | var _op = {}; 11 | var clicks = $Native$Mouse.clicks; 12 | var isDown = $Native$Mouse.isDown; 13 | var position = $Native$Mouse.position; 14 | var x = A2($Signal.map,$Basics.fst,position); 15 | var y = A2($Signal.map,$Basics.snd,position); 16 | return _elm.Mouse.values = {_op: _op 17 | ,position: position 18 | ,x: x 19 | ,y: y 20 | ,isDown: isDown 21 | ,clicks: clicks}; 22 | }; -------------------------------------------------------------------------------- /elm-stuff/build-artifacts/0.16.0/elm-lang/core/3.0.0/Random.elmi: -------------------------------------------------------------------------------- 1 | elm-langcoreboolintfloatlistpairmapmap2map3map4map5andThenminIntmaxIntgenerate initialSeed GeneratorSeed"::aListaLista Generatorelm-langcoreRandomSeed_Tuple2aelm-langcoreRandomSeedelm-langcoreRandom GeneratoraSeednextelm-langcoreRandomState_Tuple2Intelm-langcoreRandomStaterangeelm-langcoreRandomState_Tuple2IntIntsplitelm-langcoreRandomState_Tuple2elm-langcoreRandomStateelm-langcoreRandomStatestateelm-langcoreRandomStateelm-langcoreRandomSeedStateIntIntelm-langcoreRandomStateandThenelm-langcoreRandom Generatoraaelm-langcoreRandom Generatorbelm-langcoreRandom Generatorbboolelm-langcoreRandom GeneratorBoolfloatFloatFloatelm-langcoreRandom GeneratorFloatgenerateelm-langcoreRandom Generatoraelm-langcoreRandomSeed_Tuple2aelm-langcoreRandomSeediLogBaseIntIntInt initStateIntelm-langcoreRandomState initialSeedIntelm-langcoreRandomSeedintIntIntelm-langcoreRandom GeneratorIntlistIntelm-langcoreRandom Generatoraelm-langcoreRandom GeneratorListalistHelpListaIntelm-langcoreRandomSeed_Tuple2aelm-langcoreRandomSeedelm-langcoreRandomSeed_Tuple2Listaelm-langcoreRandomSeed magicNum0number magicNum1number magicNum2number magicNum3number magicNum4number magicNum5number magicNum6number magicNum7number magicNum8numbermapabelm-langcoreRandom Generatoraelm-langcoreRandom Generatorbmap2abcelm-langcoreRandom Generatoraelm-langcoreRandom Generatorbelm-langcoreRandom Generatorcmap3abcdelm-langcoreRandom Generatoraelm-langcoreRandom Generatorbelm-langcoreRandom Generatorcelm-langcoreRandom Generatordmap4abcdeelm-langcoreRandom Generatoraelm-langcoreRandom Generatorbelm-langcoreRandom Generatorcelm-langcoreRandom Generatordelm-langcoreRandom Generatoremap5abcdefelm-langcoreRandom Generatoraelm-langcoreRandom Generatorbelm-langcoreRandom Generatorcelm-langcoreRandom Generatordelm-langcoreRandom Generatoreelm-langcoreRandom GeneratorfmaxIntIntminIntIntnextelm-langcoreRandomState_Tuple2Intelm-langcoreRandomStatepairelm-langcoreRandom Generatoraelm-langcoreRandom Generatorbelm-langcoreRandom Generator_Tuple2abrangeelm-langcoreRandomState_Tuple2IntIntsplitelm-langcoreRandomState_Tuple2elm-langcoreRandomStateelm-langcoreRandomStateBasicsList Generatora Generatorelm-langcoreRandomSeed_Tuple2aelm-langcoreRandomSeedSeedSeedstateelm-langcoreRandomStatenextelm-langcoreRandomState_Tuple2Intelm-langcoreRandomStatesplitelm-langcoreRandomState_Tuple2elm-langcoreRandomStateelm-langcoreRandomStaterangeelm-langcoreRandomState_Tuple2IntIntStateStateIntInt -------------------------------------------------------------------------------- /elm-stuff/build-artifacts/0.16.0/elm-lang/core/3.0.0/Random.elmo: -------------------------------------------------------------------------------- 1 | Elm.Random = Elm.Random || {}; 2 | Elm.Random.make = function (_elm) { 3 | "use strict"; 4 | _elm.Random = _elm.Random || {}; 5 | if (_elm.Random.values) return _elm.Random.values; 6 | var _U = Elm.Native.Utils.make(_elm), 7 | $Basics = Elm.Basics.make(_elm), 8 | $List = Elm.List.make(_elm); 9 | var _op = {}; 10 | var magicNum8 = 2147483562; 11 | var range = function (_p0) { 12 | return {ctor: "_Tuple2",_0: 0,_1: magicNum8}; 13 | }; 14 | var magicNum7 = 2137383399; 15 | var magicNum6 = 2147483563; 16 | var magicNum5 = 3791; 17 | var magicNum4 = 40692; 18 | var magicNum3 = 52774; 19 | var magicNum2 = 12211; 20 | var magicNum1 = 53668; 21 | var magicNum0 = 40014; 22 | var generate = F2(function (_p1,seed) { 23 | var _p2 = _p1; 24 | return _p2._0(seed); 25 | }); 26 | var Seed = function (a) { return {ctor: "Seed",_0: a};}; 27 | var State = F2(function (a,b) { 28 | return {ctor: "State",_0: a,_1: b}; 29 | }); 30 | var initState = function (s$) { 31 | var s = A2($Basics.max,s$,0 - s$); 32 | var q = s / (magicNum6 - 1) | 0; 33 | var s2 = A2($Basics._op["%"],q,magicNum7 - 1); 34 | var s1 = A2($Basics._op["%"],s,magicNum6 - 1); 35 | return A2(State,s1 + 1,s2 + 1); 36 | }; 37 | var next = function (_p3) { 38 | var _p4 = _p3; 39 | var _p6 = _p4._1; 40 | var _p5 = _p4._0; 41 | var k$ = _p6 / magicNum3 | 0; 42 | var s2$ = magicNum4 * (_p6 - k$ * magicNum3) - k$ * magicNum5; 43 | var s2$$ = _U.cmp(s2$,0) < 0 ? s2$ + magicNum7 : s2$; 44 | var k = _p5 / magicNum1 | 0; 45 | var s1$ = magicNum0 * (_p5 - k * magicNum1) - k * magicNum2; 46 | var s1$$ = _U.cmp(s1$,0) < 0 ? s1$ + magicNum6 : s1$; 47 | var z = s1$$ - s2$$; 48 | var z$ = _U.cmp(z,1) < 0 ? z + magicNum8 : z; 49 | return {ctor: "_Tuple2",_0: z$,_1: A2(State,s1$$,s2$$)}; 50 | }; 51 | var split = function (_p7) { 52 | var _p8 = _p7; 53 | var _p11 = _p8._1; 54 | var _p10 = _p8._0; 55 | var _p9 = $Basics.snd(next(_p8)); 56 | var t1 = _p9._0; 57 | var t2 = _p9._1; 58 | var new_s2 = _U.eq(_p11,1) ? magicNum7 - 1 : _p11 - 1; 59 | var new_s1 = _U.eq(_p10,magicNum6 - 1) ? 1 : _p10 + 1; 60 | return {ctor: "_Tuple2" 61 | ,_0: A2(State,new_s1,t2) 62 | ,_1: A2(State,t1,new_s2)}; 63 | }; 64 | var initialSeed = function (n) { 65 | return Seed({state: initState(n) 66 | ,next: next 67 | ,split: split 68 | ,range: range}); 69 | }; 70 | var Generator = function (a) { 71 | return {ctor: "Generator",_0: a}; 72 | }; 73 | var andThen = F2(function (_p12,callback) { 74 | var _p13 = _p12; 75 | return Generator(function (seed) { 76 | var _p14 = _p13._0(seed); 77 | var result = _p14._0; 78 | var newSeed = _p14._1; 79 | var _p15 = callback(result); 80 | var genB = _p15._0; 81 | return genB(newSeed); 82 | }); 83 | }); 84 | var map5 = F6(function (func,_p20,_p19,_p18,_p17,_p16) { 85 | var _p21 = _p20; 86 | var _p22 = _p19; 87 | var _p23 = _p18; 88 | var _p24 = _p17; 89 | var _p25 = _p16; 90 | return Generator(function (seed0) { 91 | var _p26 = _p21._0(seed0); 92 | var a = _p26._0; 93 | var seed1 = _p26._1; 94 | var _p27 = _p22._0(seed1); 95 | var b = _p27._0; 96 | var seed2 = _p27._1; 97 | var _p28 = _p23._0(seed2); 98 | var c = _p28._0; 99 | var seed3 = _p28._1; 100 | var _p29 = _p24._0(seed3); 101 | var d = _p29._0; 102 | var seed4 = _p29._1; 103 | var _p30 = _p25._0(seed4); 104 | var e = _p30._0; 105 | var seed5 = _p30._1; 106 | return {ctor: "_Tuple2",_0: A5(func,a,b,c,d,e),_1: seed5}; 107 | }); 108 | }); 109 | var map4 = F5(function (func,_p34,_p33,_p32,_p31) { 110 | var _p35 = _p34; 111 | var _p36 = _p33; 112 | var _p37 = _p32; 113 | var _p38 = _p31; 114 | return Generator(function (seed0) { 115 | var _p39 = _p35._0(seed0); 116 | var a = _p39._0; 117 | var seed1 = _p39._1; 118 | var _p40 = _p36._0(seed1); 119 | var b = _p40._0; 120 | var seed2 = _p40._1; 121 | var _p41 = _p37._0(seed2); 122 | var c = _p41._0; 123 | var seed3 = _p41._1; 124 | var _p42 = _p38._0(seed3); 125 | var d = _p42._0; 126 | var seed4 = _p42._1; 127 | return {ctor: "_Tuple2",_0: A4(func,a,b,c,d),_1: seed4}; 128 | }); 129 | }); 130 | var map3 = F4(function (func,_p45,_p44,_p43) { 131 | var _p46 = _p45; 132 | var _p47 = _p44; 133 | var _p48 = _p43; 134 | return Generator(function (seed0) { 135 | var _p49 = _p46._0(seed0); 136 | var a = _p49._0; 137 | var seed1 = _p49._1; 138 | var _p50 = _p47._0(seed1); 139 | var b = _p50._0; 140 | var seed2 = _p50._1; 141 | var _p51 = _p48._0(seed2); 142 | var c = _p51._0; 143 | var seed3 = _p51._1; 144 | return {ctor: "_Tuple2",_0: A3(func,a,b,c),_1: seed3}; 145 | }); 146 | }); 147 | var map2 = F3(function (func,_p53,_p52) { 148 | var _p54 = _p53; 149 | var _p55 = _p52; 150 | return Generator(function (seed0) { 151 | var _p56 = _p54._0(seed0); 152 | var a = _p56._0; 153 | var seed1 = _p56._1; 154 | var _p57 = _p55._0(seed1); 155 | var b = _p57._0; 156 | var seed2 = _p57._1; 157 | return {ctor: "_Tuple2",_0: A2(func,a,b),_1: seed2}; 158 | }); 159 | }); 160 | var map = F2(function (func,_p58) { 161 | var _p59 = _p58; 162 | return Generator(function (seed0) { 163 | var _p60 = _p59._0(seed0); 164 | var a = _p60._0; 165 | var seed1 = _p60._1; 166 | return {ctor: "_Tuple2",_0: func(a),_1: seed1}; 167 | }); 168 | }); 169 | var listHelp = F4(function (list,n,generate,seed) { 170 | listHelp: while (true) if (_U.cmp(n,1) < 0) 171 | return {ctor: "_Tuple2",_0: $List.reverse(list),_1: seed}; 172 | else { 173 | var _p61 = generate(seed); 174 | var value = _p61._0; 175 | var newSeed = _p61._1; 176 | var _v19 = A2($List._op["::"],value,list), 177 | _v20 = n - 1, 178 | _v21 = generate, 179 | _v22 = newSeed; 180 | list = _v19; 181 | n = _v20; 182 | generate = _v21; 183 | seed = _v22; 184 | continue listHelp; 185 | } 186 | }); 187 | var list = F2(function (n,_p62) { 188 | var _p63 = _p62; 189 | return Generator(function (seed) { 190 | return A4(listHelp,_U.list([]),n,_p63._0,seed); 191 | }); 192 | }); 193 | var pair = F2(function (genA,genB) { 194 | return A3(map2, 195 | F2(function (v0,v1) { 196 | return {ctor: "_Tuple2",_0: v0,_1: v1}; 197 | }), 198 | genA, 199 | genB); 200 | }); 201 | var minInt = -2147483648; 202 | var maxInt = 2147483647; 203 | var iLogBase = F2(function (b,i) { 204 | return _U.cmp(i,b) < 0 ? 1 : 1 + A2(iLogBase,b,i / b | 0); 205 | }); 206 | var $int = F2(function (a,b) { 207 | return Generator(function (_p64) { 208 | var _p65 = _p64; 209 | var _p70 = _p65._0; 210 | var base = 2147483561; 211 | var f = F3(function (n,acc,state) { 212 | f: while (true) { 213 | var _p66 = n; 214 | if (_p66 === 0) { 215 | return {ctor: "_Tuple2",_0: acc,_1: state}; 216 | } else { 217 | var _p67 = _p70.next(state); 218 | var x = _p67._0; 219 | var state$ = _p67._1; 220 | var _v26 = n - 1,_v27 = x + acc * base,_v28 = state$; 221 | n = _v26; 222 | acc = _v27; 223 | state = _v28; 224 | continue f; 225 | } 226 | } 227 | }); 228 | var _p68 = _U.cmp(a,b) < 0 ? {ctor: "_Tuple2" 229 | ,_0: a 230 | ,_1: b} : {ctor: "_Tuple2",_0: b,_1: a}; 231 | var lo = _p68._0; 232 | var hi = _p68._1; 233 | var k = hi - lo + 1; 234 | var n = A2(iLogBase,base,k); 235 | var _p69 = A3(f,n,1,_p70.state); 236 | var v = _p69._0; 237 | var state$ = _p69._1; 238 | return {ctor: "_Tuple2" 239 | ,_0: lo + A2($Basics._op["%"],v,k) 240 | ,_1: Seed(_U.update(_p70,{state: state$}))}; 241 | }); 242 | }); 243 | var $float = F2(function (a,b) { 244 | return Generator(function (seed) { 245 | var _p71 = A2(generate,A2($int,minInt,maxInt),seed); 246 | var number = _p71._0; 247 | var newSeed = _p71._1; 248 | var negativeOneToOne = $Basics.toFloat(number) / $Basics.toFloat(maxInt - minInt); 249 | var _p72 = _U.cmp(a,b) < 0 ? {ctor: "_Tuple2" 250 | ,_0: a 251 | ,_1: b} : {ctor: "_Tuple2",_0: b,_1: a}; 252 | var lo = _p72._0; 253 | var hi = _p72._1; 254 | var scaled = (lo + hi) / 2 + (hi - lo) * negativeOneToOne; 255 | return {ctor: "_Tuple2",_0: scaled,_1: newSeed}; 256 | }); 257 | }); 258 | var bool = A2(map, 259 | F2(function (x,y) { return _U.eq(x,y);})(1), 260 | A2($int,0,1)); 261 | return _elm.Random.values = {_op: _op 262 | ,bool: bool 263 | ,$int: $int 264 | ,$float: $float 265 | ,list: list 266 | ,pair: pair 267 | ,map: map 268 | ,map2: map2 269 | ,map3: map3 270 | ,map4: map4 271 | ,map5: map5 272 | ,andThen: andThen 273 | ,minInt: minInt 274 | ,maxInt: maxInt 275 | ,generate: generate 276 | ,initialSeed: initialSeed}; 277 | }; -------------------------------------------------------------------------------- /elm-stuff/build-artifacts/0.16.0/elm-lang/core/3.0.0/Regex.elmi: -------------------------------------------------------------------------------- 1 | elm-langcore regexescapecaseInsensitivecontainsfindreplacesplitRegexMatchMatchHowManyAllAtMost ::aListaListaAllelm-langcoreRegexHowManyAtMostIntelm-langcoreRegexHowManyMatchStringListelm-langcoreMaybeMaybeStringIntIntelm-langcoreRegexMatchindexIntmatchStringnumberInt 2 | submatchesListelm-langcoreMaybeMaybeStringRegexelm-langcoreRegexRegexcaseInsensitiveelm-langcoreRegexRegexelm-langcoreRegexRegexcontainselm-langcoreRegexRegexStringBoolescapeStringStringfindelm-langcoreRegexHowManyelm-langcoreRegexRegexStringListelm-langcoreRegexMatchindexIntmatchStringnumberInt 3 | submatchesListelm-langcoreMaybeMaybeStringregexStringelm-langcoreRegexRegexreplaceelm-langcoreRegexHowManyelm-langcoreRegexRegexelm-langcoreRegexMatchindexIntmatchStringnumberInt 4 | submatchesListelm-langcoreMaybeMaybeStringStringStringStringsplitelm-langcoreRegexHowManyelm-langcoreRegexRegexStringListStringMaybeNativeRegexHowManyAllAtMostIntRegexRegexMatchmatchString 5 | submatchesListelm-langcoreMaybeMaybeStringindexIntnumberInt -------------------------------------------------------------------------------- /elm-stuff/build-artifacts/0.16.0/elm-lang/core/3.0.0/Regex.elmo: -------------------------------------------------------------------------------- 1 | Elm.Regex = Elm.Regex || {}; 2 | Elm.Regex.make = function (_elm) { 3 | "use strict"; 4 | _elm.Regex = _elm.Regex || {}; 5 | if (_elm.Regex.values) return _elm.Regex.values; 6 | var _U = Elm.Native.Utils.make(_elm), 7 | $Maybe = Elm.Maybe.make(_elm), 8 | $Native$Regex = Elm.Native.Regex.make(_elm); 9 | var _op = {}; 10 | var split = $Native$Regex.split; 11 | var replace = $Native$Regex.replace; 12 | var find = $Native$Regex.find; 13 | var AtMost = function (a) { return {ctor: "AtMost",_0: a};}; 14 | var All = {ctor: "All"}; 15 | var Match = F4(function (a,b,c,d) { 16 | return {match: a,submatches: b,index: c,number: d}; 17 | }); 18 | var contains = $Native$Regex.contains; 19 | var caseInsensitive = $Native$Regex.caseInsensitive; 20 | var regex = $Native$Regex.regex; 21 | var escape = $Native$Regex.escape; 22 | var Regex = {ctor: "Regex"}; 23 | return _elm.Regex.values = {_op: _op 24 | ,regex: regex 25 | ,escape: escape 26 | ,caseInsensitive: caseInsensitive 27 | ,contains: contains 28 | ,find: find 29 | ,replace: replace 30 | ,split: split 31 | ,Match: Match 32 | ,All: All 33 | ,AtMost: AtMost}; 34 | }; -------------------------------------------------------------------------------- /elm-stuff/build-artifacts/0.16.0/elm-lang/core/3.0.0/Result.elmi: -------------------------------------------------------------------------------- 1 | elm-langcore withDefaultmapmap2map3map4map5andThentoMaybe fromMaybe formatErrorResultOkErr ::aListaListaErraelm-langcoreResultResultabOkaelm-langcoreResultResultbaandThenelm-langcoreResultResultabbelm-langcoreResultResultacelm-langcoreResultResultac formatErrorabelm-langcoreResultResultacelm-langcoreResultResultbc fromMaybeaelm-langcoreMaybeMaybebelm-langcoreResultResultabmapabelm-langcoreResultResultcaelm-langcoreResultResultcbmap2abcelm-langcoreResultResultdaelm-langcoreResultResultdbelm-langcoreResultResultdcmap3abcdelm-langcoreResultResulteaelm-langcoreResultResultebelm-langcoreResultResultecelm-langcoreResultResultedmap4abcdeelm-langcoreResultResultfaelm-langcoreResultResultfbelm-langcoreResultResultfcelm-langcoreResultResultfdelm-langcoreResultResultfemap5abcdefelm-langcoreResultResultgaelm-langcoreResultResultgbelm-langcoreResultResultgcelm-langcoreResultResultgdelm-langcoreResultResultgeelm-langcoreResultResultgftoMaybeelm-langcoreResultResultabelm-langcoreMaybeMaybeb withDefaultaelm-langcoreResultResultbaaMaybeResulterrorvalueOkvalueErrerror -------------------------------------------------------------------------------- /elm-stuff/build-artifacts/0.16.0/elm-lang/core/3.0.0/Result.elmo: -------------------------------------------------------------------------------- 1 | Elm.Result = Elm.Result || {}; 2 | Elm.Result.make = function (_elm) { 3 | "use strict"; 4 | _elm.Result = _elm.Result || {}; 5 | if (_elm.Result.values) return _elm.Result.values; 6 | var _U = Elm.Native.Utils.make(_elm), 7 | $Maybe = Elm.Maybe.make(_elm); 8 | var _op = {}; 9 | var toMaybe = function (result) { 10 | var _p0 = result; 11 | if (_p0.ctor === "Ok") { 12 | return $Maybe.Just(_p0._0); 13 | } else { 14 | return $Maybe.Nothing; 15 | } 16 | }; 17 | var withDefault = F2(function (def,result) { 18 | var _p1 = result; 19 | if (_p1.ctor === "Ok") { 20 | return _p1._0; 21 | } else { 22 | return def; 23 | } 24 | }); 25 | var Err = function (a) { return {ctor: "Err",_0: a};}; 26 | var andThen = F2(function (result,callback) { 27 | var _p2 = result; 28 | if (_p2.ctor === "Ok") { 29 | return callback(_p2._0); 30 | } else { 31 | return Err(_p2._0); 32 | } 33 | }); 34 | var Ok = function (a) { return {ctor: "Ok",_0: a};}; 35 | var map = F2(function (func,ra) { 36 | var _p3 = ra; 37 | if (_p3.ctor === "Ok") { 38 | return Ok(func(_p3._0)); 39 | } else { 40 | return Err(_p3._0); 41 | } 42 | }); 43 | var map2 = F3(function (func,ra,rb) { 44 | var _p4 = {ctor: "_Tuple2",_0: ra,_1: rb}; 45 | if (_p4._0.ctor === "Ok") { 46 | if (_p4._1.ctor === "Ok") { 47 | return Ok(A2(func,_p4._0._0,_p4._1._0)); 48 | } else { 49 | return Err(_p4._1._0); 50 | } 51 | } else { 52 | return Err(_p4._0._0); 53 | } 54 | }); 55 | var map3 = F4(function (func,ra,rb,rc) { 56 | var _p5 = {ctor: "_Tuple3",_0: ra,_1: rb,_2: rc}; 57 | if (_p5._0.ctor === "Ok") { 58 | if (_p5._1.ctor === "Ok") { 59 | if (_p5._2.ctor === "Ok") { 60 | return Ok(A3(func,_p5._0._0,_p5._1._0,_p5._2._0)); 61 | } else { 62 | return Err(_p5._2._0); 63 | } 64 | } else { 65 | return Err(_p5._1._0); 66 | } 67 | } else { 68 | return Err(_p5._0._0); 69 | } 70 | }); 71 | var map4 = F5(function (func,ra,rb,rc,rd) { 72 | var _p6 = {ctor: "_Tuple4",_0: ra,_1: rb,_2: rc,_3: rd}; 73 | if (_p6._0.ctor === "Ok") { 74 | if (_p6._1.ctor === "Ok") { 75 | if (_p6._2.ctor === "Ok") { 76 | if (_p6._3.ctor === "Ok") { 77 | return Ok(A4(func,_p6._0._0,_p6._1._0,_p6._2._0,_p6._3._0)); 78 | } else { 79 | return Err(_p6._3._0); 80 | } 81 | } else { 82 | return Err(_p6._2._0); 83 | } 84 | } else { 85 | return Err(_p6._1._0); 86 | } 87 | } else { 88 | return Err(_p6._0._0); 89 | } 90 | }); 91 | var map5 = F6(function (func,ra,rb,rc,rd,re) { 92 | var _p7 = {ctor: "_Tuple5" 93 | ,_0: ra 94 | ,_1: rb 95 | ,_2: rc 96 | ,_3: rd 97 | ,_4: re}; 98 | if (_p7._0.ctor === "Ok") { 99 | if (_p7._1.ctor === "Ok") { 100 | if (_p7._2.ctor === "Ok") { 101 | if (_p7._3.ctor === "Ok") { 102 | if (_p7._4.ctor === "Ok") { 103 | return Ok(A5(func, 104 | _p7._0._0, 105 | _p7._1._0, 106 | _p7._2._0, 107 | _p7._3._0, 108 | _p7._4._0)); 109 | } else { 110 | return Err(_p7._4._0); 111 | } 112 | } else { 113 | return Err(_p7._3._0); 114 | } 115 | } else { 116 | return Err(_p7._2._0); 117 | } 118 | } else { 119 | return Err(_p7._1._0); 120 | } 121 | } else { 122 | return Err(_p7._0._0); 123 | } 124 | }); 125 | var formatError = F2(function (f,result) { 126 | var _p8 = result; 127 | if (_p8.ctor === "Ok") { 128 | return Ok(_p8._0); 129 | } else { 130 | return Err(f(_p8._0)); 131 | } 132 | }); 133 | var fromMaybe = F2(function (err,maybe) { 134 | var _p9 = maybe; 135 | if (_p9.ctor === "Just") { 136 | return Ok(_p9._0); 137 | } else { 138 | return Err(err); 139 | } 140 | }); 141 | return _elm.Result.values = {_op: _op 142 | ,withDefault: withDefault 143 | ,map: map 144 | ,map2: map2 145 | ,map3: map3 146 | ,map4: map4 147 | ,map5: map5 148 | ,andThen: andThen 149 | ,toMaybe: toMaybe 150 | ,fromMaybe: fromMaybe 151 | ,formatError: formatError 152 | ,Ok: Ok 153 | ,Err: Err}; 154 | }; -------------------------------------------------------------------------------- /elm-stuff/build-artifacts/0.16.0/elm-lang/core/3.0.0/Set.elmi: -------------------------------------------------------------------------------- 1 | elm-langcoreempty singletoninsertremoveisEmptymembersizefoldlfoldrmapfilter partitionunion intersectdifftoListfromListSet::aListaListaSet_elm_builtinelm-langcoreDictDicta_Tuple0elm-langcoreSetSetadiffelm-langcoreSetSet 2 | comparableelm-langcoreSetSet 3 | comparableelm-langcoreSetSet 4 | comparableemptyelm-langcoreSetSetafilter 5 | comparableBoolelm-langcoreSetSet 6 | comparableelm-langcoreSetSet 7 | comparablefoldl 8 | comparableaaaelm-langcoreSetSet 9 | comparableafoldr 10 | comparableaaaelm-langcoreSetSet 11 | comparableafromListList 12 | comparableelm-langcoreSetSet 13 | comparableinsert 14 | comparableelm-langcoreSetSet 15 | comparableelm-langcoreSetSet 16 | comparable intersectelm-langcoreSetSet 17 | comparableelm-langcoreSetSet 18 | comparableelm-langcoreSetSet 19 | comparableisEmptyelm-langcoreSetSetaBoolmap 20 | comparable comparable'elm-langcoreSetSet 21 | comparableelm-langcoreSetSet comparable'member 22 | comparableelm-langcoreSetSet 23 | comparableBool partition 24 | comparableBoolelm-langcoreSetSet 25 | comparable_Tuple2elm-langcoreSetSet 26 | comparableelm-langcoreSetSet 27 | comparableremove 28 | comparableelm-langcoreSetSet 29 | comparableelm-langcoreSetSet 30 | comparable singleton 31 | comparableelm-langcoreSetSet 32 | comparablesizeelm-langcoreSetSetaInttoListelm-langcoreSetSet 33 | comparableList 34 | comparableunionelm-langcoreSetSet 35 | comparableelm-langcoreSetSet 36 | comparableelm-langcoreSetSet 37 | comparableBasicsDictListSettSet_elm_builtinelm-langcoreDictDictt_Tuple0 -------------------------------------------------------------------------------- /elm-stuff/build-artifacts/0.16.0/elm-lang/core/3.0.0/Set.elmo: -------------------------------------------------------------------------------- 1 | Elm.Set = Elm.Set || {}; 2 | Elm.Set.make = function (_elm) { 3 | "use strict"; 4 | _elm.Set = _elm.Set || {}; 5 | if (_elm.Set.values) return _elm.Set.values; 6 | var _U = Elm.Native.Utils.make(_elm), 7 | $Basics = Elm.Basics.make(_elm), 8 | $Dict = Elm.Dict.make(_elm), 9 | $List = Elm.List.make(_elm); 10 | var _op = {}; 11 | var foldr = F3(function (f,b,_p0) { 12 | var _p1 = _p0; 13 | return A3($Dict.foldr, 14 | F3(function (k,_p2,b) { return A2(f,k,b);}), 15 | b, 16 | _p1._0); 17 | }); 18 | var foldl = F3(function (f,b,_p3) { 19 | var _p4 = _p3; 20 | return A3($Dict.foldl, 21 | F3(function (k,_p5,b) { return A2(f,k,b);}), 22 | b, 23 | _p4._0); 24 | }); 25 | var toList = function (_p6) { 26 | var _p7 = _p6; 27 | return $Dict.keys(_p7._0); 28 | }; 29 | var size = function (_p8) { 30 | var _p9 = _p8; 31 | return $Dict.size(_p9._0); 32 | }; 33 | var member = F2(function (k,_p10) { 34 | var _p11 = _p10; 35 | return A2($Dict.member,k,_p11._0); 36 | }); 37 | var isEmpty = function (_p12) { 38 | var _p13 = _p12; 39 | return $Dict.isEmpty(_p13._0); 40 | }; 41 | var Set_elm_builtin = function (a) { 42 | return {ctor: "Set_elm_builtin",_0: a}; 43 | }; 44 | var empty = Set_elm_builtin($Dict.empty); 45 | var singleton = function (k) { 46 | return Set_elm_builtin(A2($Dict.singleton, 47 | k, 48 | {ctor: "_Tuple0"})); 49 | }; 50 | var insert = F2(function (k,_p14) { 51 | var _p15 = _p14; 52 | return Set_elm_builtin(A3($Dict.insert, 53 | k, 54 | {ctor: "_Tuple0"}, 55 | _p15._0)); 56 | }); 57 | var fromList = function (xs) { 58 | return A3($List.foldl,insert,empty,xs); 59 | }; 60 | var map = F2(function (f,s) { 61 | return fromList(A2($List.map,f,toList(s))); 62 | }); 63 | var remove = F2(function (k,_p16) { 64 | var _p17 = _p16; 65 | return Set_elm_builtin(A2($Dict.remove,k,_p17._0)); 66 | }); 67 | var union = F2(function (_p19,_p18) { 68 | var _p20 = _p19; 69 | var _p21 = _p18; 70 | return Set_elm_builtin(A2($Dict.union,_p20._0,_p21._0)); 71 | }); 72 | var intersect = F2(function (_p23,_p22) { 73 | var _p24 = _p23; 74 | var _p25 = _p22; 75 | return Set_elm_builtin(A2($Dict.intersect,_p24._0,_p25._0)); 76 | }); 77 | var diff = F2(function (_p27,_p26) { 78 | var _p28 = _p27; 79 | var _p29 = _p26; 80 | return Set_elm_builtin(A2($Dict.diff,_p28._0,_p29._0)); 81 | }); 82 | var filter = F2(function (p,_p30) { 83 | var _p31 = _p30; 84 | return Set_elm_builtin(A2($Dict.filter, 85 | F2(function (k,_p32) { return p(k);}), 86 | _p31._0)); 87 | }); 88 | var partition = F2(function (p,_p33) { 89 | var _p34 = _p33; 90 | var _p35 = A2($Dict.partition, 91 | F2(function (k,_p36) { return p(k);}), 92 | _p34._0); 93 | var p1 = _p35._0; 94 | var p2 = _p35._1; 95 | return {ctor: "_Tuple2" 96 | ,_0: Set_elm_builtin(p1) 97 | ,_1: Set_elm_builtin(p2)}; 98 | }); 99 | return _elm.Set.values = {_op: _op 100 | ,empty: empty 101 | ,singleton: singleton 102 | ,insert: insert 103 | ,remove: remove 104 | ,isEmpty: isEmpty 105 | ,member: member 106 | ,size: size 107 | ,foldl: foldl 108 | ,foldr: foldr 109 | ,map: map 110 | ,filter: filter 111 | ,partition: partition 112 | ,union: union 113 | ,intersect: intersect 114 | ,diff: diff 115 | ,toList: toList 116 | ,fromList: fromList}; 117 | }; -------------------------------------------------------------------------------- /elm-stuff/build-artifacts/0.16.0/elm-lang/core/3.0.0/Signal.elmi: -------------------------------------------------------------------------------- 1 | elm-langcoremerge mergeManymapmap2map3map4map5constant dropRepeatsfilter filterMapsampleOnfoldpmailboxsendmessage forwardToSignalMailboxMailboxAddressMessage::aListaListaAddressaelm-langcoreTaskTask_Tuple0_Tuple0elm-langcoreSignalAddressaMailboxelm-langcoreSignalAddressbelm-langcoreSignalSignalbelm-langcoreSignalMailboxabaddresselm-langcoreSignalAddressbsignalelm-langcoreSignalSignalbMessageelm-langcoreTaskTask_Tuple0_Tuple0elm-langcoreSignalMessageSignalelm-langcoreSignalSignalaconstantaelm-langcoreSignalSignala dropRepeatselm-langcoreSignalSignalaelm-langcoreSignalSignalafilteraBoolaelm-langcoreSignalSignalaelm-langcoreSignalSignala filterMapaelm-langcoreMaybeMaybebbelm-langcoreSignalSignalaelm-langcoreSignalSignalbfoldpabbbelm-langcoreSignalSignalaelm-langcoreSignalSignalb forwardToelm-langcoreSignalAddressabaelm-langcoreSignalAddressbmailboxbelm-langcoreSignalMailboxabaddresselm-langcoreSignalAddressbsignalelm-langcoreSignalSignalbmapabelm-langcoreSignalSignalaelm-langcoreSignalSignalbmap2abcelm-langcoreSignalSignalaelm-langcoreSignalSignalbelm-langcoreSignalSignalcmap3abcdelm-langcoreSignalSignalaelm-langcoreSignalSignalbelm-langcoreSignalSignalcelm-langcoreSignalSignaldmap4abcdeelm-langcoreSignalSignalaelm-langcoreSignalSignalbelm-langcoreSignalSignalcelm-langcoreSignalSignaldelm-langcoreSignalSignalemap5abcdefelm-langcoreSignalSignalaelm-langcoreSignalSignalbelm-langcoreSignalSignalcelm-langcoreSignalSignaldelm-langcoreSignalSignaleelm-langcoreSignalSignalfmergeelm-langcoreSignalSignalaelm-langcoreSignalSignalaelm-langcoreSignalSignala mergeManyListelm-langcoreSignalSignalaelm-langcoreSignalSignalamessageelm-langcoreSignalAddressaaelm-langcoreSignalMessagesampleOnelm-langcoreSignalSignalaelm-langcoreSignalSignalbelm-langcoreSignalSignalbsendelm-langcoreSignalAddressaaelm-langcoreTaskTaskb_Tuple0BasicsDebugListMaybeNativeSignalTaskAddressaAddressaelm-langcoreTaskTask_Tuple0_Tuple0MessageMessageelm-langcoreTaskTask_Tuple0_Tuple0SignalaSignalMailboxaaddresselm-langcoreSignalAddressasignalelm-langcoreSignalSignala -------------------------------------------------------------------------------- /elm-stuff/build-artifacts/0.16.0/elm-lang/core/3.0.0/Signal.elmo: -------------------------------------------------------------------------------- 1 | Elm.Signal = Elm.Signal || {}; 2 | Elm.Signal.make = function (_elm) { 3 | "use strict"; 4 | _elm.Signal = _elm.Signal || {}; 5 | if (_elm.Signal.values) return _elm.Signal.values; 6 | var _U = Elm.Native.Utils.make(_elm), 7 | $Basics = Elm.Basics.make(_elm), 8 | $Debug = Elm.Debug.make(_elm), 9 | $List = Elm.List.make(_elm), 10 | $Maybe = Elm.Maybe.make(_elm), 11 | $Native$Signal = Elm.Native.Signal.make(_elm), 12 | $Task = Elm.Task.make(_elm); 13 | var _op = {}; 14 | var send = F2(function (_p0,value) { 15 | var _p1 = _p0; 16 | return A2($Task.onError, 17 | _p1._0(value), 18 | function (_p2) { 19 | return $Task.succeed({ctor: "_Tuple0"}); 20 | }); 21 | }); 22 | var Message = function (a) { 23 | return {ctor: "Message",_0: a}; 24 | }; 25 | var message = F2(function (_p3,value) { 26 | var _p4 = _p3; 27 | return Message(_p4._0(value)); 28 | }); 29 | var mailbox = $Native$Signal.mailbox; 30 | var Address = function (a) { 31 | return {ctor: "Address",_0: a}; 32 | }; 33 | var forwardTo = F2(function (_p5,f) { 34 | var _p6 = _p5; 35 | return Address(function (x) { return _p6._0(f(x));}); 36 | }); 37 | var Mailbox = F2(function (a,b) { 38 | return {address: a,signal: b}; 39 | }); 40 | var sampleOn = $Native$Signal.sampleOn; 41 | var dropRepeats = $Native$Signal.dropRepeats; 42 | var filterMap = $Native$Signal.filterMap; 43 | var filter = F3(function (isOk,base,signal) { 44 | return A3(filterMap, 45 | function (value) { 46 | return isOk(value) ? $Maybe.Just(value) : $Maybe.Nothing; 47 | }, 48 | base, 49 | signal); 50 | }); 51 | var merge = F2(function (left,right) { 52 | return A3($Native$Signal.genericMerge, 53 | $Basics.always, 54 | left, 55 | right); 56 | }); 57 | var mergeMany = function (signalList) { 58 | var _p7 = $List.reverse(signalList); 59 | if (_p7.ctor === "[]") { 60 | return _U.crashCase("Signal", 61 | {start: {line: 184,column: 3},end: {line: 189,column: 40}}, 62 | _p7)("mergeMany was given an empty list!"); 63 | } else { 64 | return A3($List.foldl,merge,_p7._0,_p7._1); 65 | } 66 | }; 67 | var foldp = $Native$Signal.foldp; 68 | var map5 = $Native$Signal.map5; 69 | var map4 = $Native$Signal.map4; 70 | var map3 = $Native$Signal.map3; 71 | var map2 = $Native$Signal.map2; 72 | var map = $Native$Signal.map; 73 | var constant = $Native$Signal.constant; 74 | var Signal = {ctor: "Signal"}; 75 | return _elm.Signal.values = {_op: _op 76 | ,merge: merge 77 | ,mergeMany: mergeMany 78 | ,map: map 79 | ,map2: map2 80 | ,map3: map3 81 | ,map4: map4 82 | ,map5: map5 83 | ,constant: constant 84 | ,dropRepeats: dropRepeats 85 | ,filter: filter 86 | ,filterMap: filterMap 87 | ,sampleOn: sampleOn 88 | ,foldp: foldp 89 | ,mailbox: mailbox 90 | ,send: send 91 | ,message: message 92 | ,forwardTo: forwardTo 93 | ,Mailbox: Mailbox}; 94 | }; -------------------------------------------------------------------------------- /elm-stuff/build-artifacts/0.16.0/elm-lang/core/3.0.0/String.elmi: -------------------------------------------------------------------------------- 1 | elm-langcore)isEmptylengthreverserepeatconsunconsfromCharappendconcatsplitjoinwordslinessliceleftrightdropLeft dropRightcontains 2 | startsWithendsWithindexesindicestoInttoFloattoListfromListtoUppertoLowerpadpadLeftpadRighttrimtrimLeft trimRightmapfilterfoldlfoldranyall*::aListaListaallCharBoolStringBoolanyCharBoolStringBoolappendStringStringStringconcatListStringStringconsCharStringStringcontainsStringStringBooldropLeftIntStringString dropRightIntStringStringendsWithStringStringBoolfilterCharBoolStringStringfoldlCharaaaStringafoldrCharaaaStringafromCharCharStringfromListListCharStringindexesStringStringListIntindicesStringStringListIntisEmptyStringBooljoinStringListStringStringleftIntStringStringlengthStringIntlinesStringListStringmapCharCharStringStringpadIntCharStringStringpadLeftIntCharStringStringpadRightIntCharStringStringrepeatIntStringStringreverseStringStringrightIntStringStringsliceIntIntStringStringsplitStringStringListString 3 | startsWithStringStringBooltoFloatStringelm-langcoreResultResultStringFloattoIntStringelm-langcoreResultResultStringInttoListStringListChartoLowerStringStringtoUpperStringStringtrimStringStringtrimLeftStringString trimRightStringStringunconsStringelm-langcoreMaybeMaybe_Tuple2CharStringwordsStringListStringMaybeNativeStringResult -------------------------------------------------------------------------------- /elm-stuff/build-artifacts/0.16.0/elm-lang/core/3.0.0/String.elmo: -------------------------------------------------------------------------------- 1 | Elm.String = Elm.String || {}; 2 | Elm.String.make = function (_elm) { 3 | "use strict"; 4 | _elm.String = _elm.String || {}; 5 | if (_elm.String.values) return _elm.String.values; 6 | var _U = Elm.Native.Utils.make(_elm), 7 | $Maybe = Elm.Maybe.make(_elm), 8 | $Native$String = Elm.Native.String.make(_elm), 9 | $Result = Elm.Result.make(_elm); 10 | var _op = {}; 11 | var fromList = $Native$String.fromList; 12 | var toList = $Native$String.toList; 13 | var toFloat = $Native$String.toFloat; 14 | var toInt = $Native$String.toInt; 15 | var indices = $Native$String.indexes; 16 | var indexes = $Native$String.indexes; 17 | var endsWith = $Native$String.endsWith; 18 | var startsWith = $Native$String.startsWith; 19 | var contains = $Native$String.contains; 20 | var all = $Native$String.all; 21 | var any = $Native$String.any; 22 | var toLower = $Native$String.toLower; 23 | var toUpper = $Native$String.toUpper; 24 | var lines = $Native$String.lines; 25 | var words = $Native$String.words; 26 | var trimRight = $Native$String.trimRight; 27 | var trimLeft = $Native$String.trimLeft; 28 | var trim = $Native$String.trim; 29 | var padRight = $Native$String.padRight; 30 | var padLeft = $Native$String.padLeft; 31 | var pad = $Native$String.pad; 32 | var dropRight = $Native$String.dropRight; 33 | var dropLeft = $Native$String.dropLeft; 34 | var right = $Native$String.right; 35 | var left = $Native$String.left; 36 | var slice = $Native$String.slice; 37 | var repeat = $Native$String.repeat; 38 | var join = $Native$String.join; 39 | var split = $Native$String.split; 40 | var foldr = $Native$String.foldr; 41 | var foldl = $Native$String.foldl; 42 | var reverse = $Native$String.reverse; 43 | var filter = $Native$String.filter; 44 | var map = $Native$String.map; 45 | var length = $Native$String.length; 46 | var concat = $Native$String.concat; 47 | var append = $Native$String.append; 48 | var uncons = $Native$String.uncons; 49 | var cons = $Native$String.cons; 50 | var fromChar = function ($char) { return A2(cons,$char,"");}; 51 | var isEmpty = $Native$String.isEmpty; 52 | return _elm.String.values = {_op: _op 53 | ,isEmpty: isEmpty 54 | ,length: length 55 | ,reverse: reverse 56 | ,repeat: repeat 57 | ,cons: cons 58 | ,uncons: uncons 59 | ,fromChar: fromChar 60 | ,append: append 61 | ,concat: concat 62 | ,split: split 63 | ,join: join 64 | ,words: words 65 | ,lines: lines 66 | ,slice: slice 67 | ,left: left 68 | ,right: right 69 | ,dropLeft: dropLeft 70 | ,dropRight: dropRight 71 | ,contains: contains 72 | ,startsWith: startsWith 73 | ,endsWith: endsWith 74 | ,indexes: indexes 75 | ,indices: indices 76 | ,toInt: toInt 77 | ,toFloat: toFloat 78 | ,toList: toList 79 | ,fromList: fromList 80 | ,toUpper: toUpper 81 | ,toLower: toLower 82 | ,pad: pad 83 | ,padLeft: padLeft 84 | ,padRight: padRight 85 | ,trim: trim 86 | ,trimLeft: trimLeft 87 | ,trimRight: trimRight 88 | ,map: map 89 | ,filter: filter 90 | ,foldl: foldl 91 | ,foldr: foldr 92 | ,any: any 93 | ,all: all}; 94 | }; -------------------------------------------------------------------------------- /elm-stuff/build-artifacts/0.16.0/elm-lang/core/3.0.0/Task.elmi: -------------------------------------------------------------------------------- 1 | elm-langcoresucceedfailmapmap2map3map4map5andMapsequenceandThenonErrormapErrortoMaybe fromMaybetoResult 2 | fromResultspawnsleepTaskThreadID::aListaListaTaskelm-langcoreTaskTaskabThreadIDIntelm-langcoreTaskThreadIDandMapelm-langcoreTaskTaskabcelm-langcoreTaskTaskabelm-langcoreTaskTaskacandThenelm-langcoreTaskTaskabbelm-langcoreTaskTaskacelm-langcoreTaskTaskacfailaelm-langcoreTaskTaskab fromMaybeaelm-langcoreMaybeMaybebelm-langcoreTaskTaskab 3 | fromResultelm-langcoreResultResultabelm-langcoreTaskTaskabmapabelm-langcoreTaskTaskcaelm-langcoreTaskTaskcbmap2abcelm-langcoreTaskTaskdaelm-langcoreTaskTaskdbelm-langcoreTaskTaskdcmap3abcdelm-langcoreTaskTaskeaelm-langcoreTaskTaskebelm-langcoreTaskTaskecelm-langcoreTaskTaskedmap4abcdeelm-langcoreTaskTaskfaelm-langcoreTaskTaskfbelm-langcoreTaskTaskfcelm-langcoreTaskTaskfdelm-langcoreTaskTaskfemap5abcdefelm-langcoreTaskTaskgaelm-langcoreTaskTaskgbelm-langcoreTaskTaskgcelm-langcoreTaskTaskgdelm-langcoreTaskTaskgeelm-langcoreTaskTaskgfmapErrorabelm-langcoreTaskTaskacelm-langcoreTaskTaskbconErrorelm-langcoreTaskTaskabaelm-langcoreTaskTaskcbelm-langcoreTaskTaskcbsequenceListelm-langcoreTaskTaskabelm-langcoreTaskTaskaListbsleepelm-langcoreTaskTimeFloatelm-langcoreTaskTaska_Tuple0spawnelm-langcoreTaskTaskabelm-langcoreTaskTaskcelm-langcoreTaskThreadIDsucceedaelm-langcoreTaskTaskbatoMaybeelm-langcoreTaskTaskabelm-langcoreTaskTaskcelm-langcoreMaybeMaybebtoResultelm-langcoreTaskTaskabelm-langcoreTaskTaskcelm-langcoreResultResultabListMaybeNativeTaskResultTaskxaTaskThreadIDThreadIDIntTimeFloat -------------------------------------------------------------------------------- /elm-stuff/build-artifacts/0.16.0/elm-lang/core/3.0.0/Task.elmo: -------------------------------------------------------------------------------- 1 | Elm.Task = Elm.Task || {}; 2 | Elm.Task.make = function (_elm) { 3 | "use strict"; 4 | _elm.Task = _elm.Task || {}; 5 | if (_elm.Task.values) return _elm.Task.values; 6 | var _U = Elm.Native.Utils.make(_elm), 7 | $List = Elm.List.make(_elm), 8 | $Maybe = Elm.Maybe.make(_elm), 9 | $Native$Task = Elm.Native.Task.make(_elm), 10 | $Result = Elm.Result.make(_elm); 11 | var _op = {}; 12 | var sleep = $Native$Task.sleep; 13 | var spawn = $Native$Task.spawn; 14 | var ThreadID = function (a) { 15 | return {ctor: "ThreadID",_0: a}; 16 | }; 17 | var onError = $Native$Task.catch_; 18 | var andThen = $Native$Task.andThen; 19 | var fail = $Native$Task.fail; 20 | var mapError = F2(function (f,task) { 21 | return A2(onError, 22 | task, 23 | function (err) { 24 | return fail(f(err)); 25 | }); 26 | }); 27 | var succeed = $Native$Task.succeed; 28 | var map = F2(function (func,taskA) { 29 | return A2(andThen, 30 | taskA, 31 | function (a) { 32 | return succeed(func(a)); 33 | }); 34 | }); 35 | var map2 = F3(function (func,taskA,taskB) { 36 | return A2(andThen, 37 | taskA, 38 | function (a) { 39 | return A2(andThen, 40 | taskB, 41 | function (b) { 42 | return succeed(A2(func,a,b)); 43 | }); 44 | }); 45 | }); 46 | var map3 = F4(function (func,taskA,taskB,taskC) { 47 | return A2(andThen, 48 | taskA, 49 | function (a) { 50 | return A2(andThen, 51 | taskB, 52 | function (b) { 53 | return A2(andThen, 54 | taskC, 55 | function (c) { 56 | return succeed(A3(func,a,b,c)); 57 | }); 58 | }); 59 | }); 60 | }); 61 | var map4 = F5(function (func,taskA,taskB,taskC,taskD) { 62 | return A2(andThen, 63 | taskA, 64 | function (a) { 65 | return A2(andThen, 66 | taskB, 67 | function (b) { 68 | return A2(andThen, 69 | taskC, 70 | function (c) { 71 | return A2(andThen, 72 | taskD, 73 | function (d) { 74 | return succeed(A4(func,a,b,c,d)); 75 | }); 76 | }); 77 | }); 78 | }); 79 | }); 80 | var map5 = F6(function (func,taskA,taskB,taskC,taskD,taskE) { 81 | return A2(andThen, 82 | taskA, 83 | function (a) { 84 | return A2(andThen, 85 | taskB, 86 | function (b) { 87 | return A2(andThen, 88 | taskC, 89 | function (c) { 90 | return A2(andThen, 91 | taskD, 92 | function (d) { 93 | return A2(andThen, 94 | taskE, 95 | function (e) { 96 | return succeed(A5(func,a,b,c,d,e)); 97 | }); 98 | }); 99 | }); 100 | }); 101 | }); 102 | }); 103 | var andMap = F2(function (taskFunc,taskValue) { 104 | return A2(andThen, 105 | taskFunc, 106 | function (func) { 107 | return A2(andThen, 108 | taskValue, 109 | function (value) { 110 | return succeed(func(value)); 111 | }); 112 | }); 113 | }); 114 | var sequence = function (tasks) { 115 | var _p0 = tasks; 116 | if (_p0.ctor === "[]") { 117 | return succeed(_U.list([])); 118 | } else { 119 | return A3(map2, 120 | F2(function (x,y) { return A2($List._op["::"],x,y);}), 121 | _p0._0, 122 | sequence(_p0._1)); 123 | } 124 | }; 125 | var toMaybe = function (task) { 126 | return A2(onError, 127 | A2(map,$Maybe.Just,task), 128 | function (_p1) { 129 | return succeed($Maybe.Nothing); 130 | }); 131 | }; 132 | var fromMaybe = F2(function ($default,maybe) { 133 | var _p2 = maybe; 134 | if (_p2.ctor === "Just") { 135 | return succeed(_p2._0); 136 | } else { 137 | return fail($default); 138 | } 139 | }); 140 | var toResult = function (task) { 141 | return A2(onError, 142 | A2(map,$Result.Ok,task), 143 | function (msg) { 144 | return succeed($Result.Err(msg)); 145 | }); 146 | }; 147 | var fromResult = function (result) { 148 | var _p3 = result; 149 | if (_p3.ctor === "Ok") { 150 | return succeed(_p3._0); 151 | } else { 152 | return fail(_p3._0); 153 | } 154 | }; 155 | var Task = {ctor: "Task"}; 156 | return _elm.Task.values = {_op: _op 157 | ,succeed: succeed 158 | ,fail: fail 159 | ,map: map 160 | ,map2: map2 161 | ,map3: map3 162 | ,map4: map4 163 | ,map5: map5 164 | ,andMap: andMap 165 | ,sequence: sequence 166 | ,andThen: andThen 167 | ,onError: onError 168 | ,mapError: mapError 169 | ,toMaybe: toMaybe 170 | ,fromMaybe: fromMaybe 171 | ,toResult: toResult 172 | ,fromResult: fromResult 173 | ,spawn: spawn 174 | ,sleep: sleep}; 175 | }; -------------------------------------------------------------------------------- /elm-stuff/build-artifacts/0.16.0/elm-lang/core/3.0.0/Text.elmi: -------------------------------------------------------------------------------- 1 | elm-langcore 2 | fromStringemptyappendconcatjoinlinkstyle defaultStyletypeface monospaceheightcolorbolditaliclineTextStyleStyleLineUnderOverThrough::aListaListaOverelm-langcoreTextLineStyleListStringelm-langcoreMaybeMaybeFloatelm-langcoreColorColorBoolBoolelm-langcoreMaybeMaybeelm-langcoreTextLineelm-langcoreTextStyleboldBoolcolorelm-langcoreColorColorheightelm-langcoreMaybeMaybeFloatitalicBoollineelm-langcoreMaybeMaybeelm-langcoreTextLinetypefaceListStringTextelm-langcoreTextTextThroughelm-langcoreTextLineUnderelm-langcoreTextLineappendelm-langcoreTextTextelm-langcoreTextTextelm-langcoreTextTextboldelm-langcoreTextTextelm-langcoreTextTextcolorelm-langcoreColorColorelm-langcoreTextTextelm-langcoreTextTextconcatListelm-langcoreTextTextelm-langcoreTextText defaultStyleelm-langcoreTextStyleboldBoolcolorelm-langcoreColorColorheightelm-langcoreMaybeMaybeFloatitalicBoollineelm-langcoreMaybeMaybeelm-langcoreTextLinetypefaceListStringemptyelm-langcoreTextText 3 | fromStringStringelm-langcoreTextTextheightFloatelm-langcoreTextTextelm-langcoreTextTextitalicelm-langcoreTextTextelm-langcoreTextTextjoinelm-langcoreTextTextListelm-langcoreTextTextelm-langcoreTextTextlineelm-langcoreTextLineelm-langcoreTextTextelm-langcoreTextTextlinkStringelm-langcoreTextTextelm-langcoreTextText monospaceelm-langcoreTextTextelm-langcoreTextTextstyleelm-langcoreTextStyleboldBoolcolorelm-langcoreColorColorheightelm-langcoreMaybeMaybeFloatitalicBoollineelm-langcoreMaybeMaybeelm-langcoreTextLinetypefaceListStringelm-langcoreTextTextelm-langcoreTextTexttypefaceListStringelm-langcoreTextTextelm-langcoreTextTextColorListMaybeNativeTextLineUnderOverThroughTextTextStyletypefaceListStringheightelm-langcoreMaybeMaybeFloatcolorelm-langcoreColorColorboldBoolitalicBoollineelm-langcoreMaybeMaybeelm-langcoreTextLine -------------------------------------------------------------------------------- /elm-stuff/build-artifacts/0.16.0/elm-lang/core/3.0.0/Text.elmo: -------------------------------------------------------------------------------- 1 | Elm.Text = Elm.Text || {}; 2 | Elm.Text.make = function (_elm) { 3 | "use strict"; 4 | _elm.Text = _elm.Text || {}; 5 | if (_elm.Text.values) return _elm.Text.values; 6 | var _U = Elm.Native.Utils.make(_elm), 7 | $Color = Elm.Color.make(_elm), 8 | $List = Elm.List.make(_elm), 9 | $Maybe = Elm.Maybe.make(_elm), 10 | $Native$Text = Elm.Native.Text.make(_elm); 11 | var _op = {}; 12 | var line = $Native$Text.line; 13 | var italic = $Native$Text.italic; 14 | var bold = $Native$Text.bold; 15 | var color = $Native$Text.color; 16 | var height = $Native$Text.height; 17 | var link = $Native$Text.link; 18 | var monospace = $Native$Text.monospace; 19 | var typeface = $Native$Text.typeface; 20 | var style = $Native$Text.style; 21 | var append = $Native$Text.append; 22 | var fromString = $Native$Text.fromString; 23 | var empty = fromString(""); 24 | var concat = function (texts) { 25 | return A3($List.foldr,append,empty,texts); 26 | }; 27 | var join = F2(function (seperator,texts) { 28 | return concat(A2($List.intersperse,seperator,texts)); 29 | }); 30 | var defaultStyle = {typeface: _U.list([]) 31 | ,height: $Maybe.Nothing 32 | ,color: $Color.black 33 | ,bold: false 34 | ,italic: false 35 | ,line: $Maybe.Nothing}; 36 | var Style = F6(function (a,b,c,d,e,f) { 37 | return {typeface: a 38 | ,height: b 39 | ,color: c 40 | ,bold: d 41 | ,italic: e 42 | ,line: f}; 43 | }); 44 | var Through = {ctor: "Through"}; 45 | var Over = {ctor: "Over"}; 46 | var Under = {ctor: "Under"}; 47 | var Text = {ctor: "Text"}; 48 | return _elm.Text.values = {_op: _op 49 | ,fromString: fromString 50 | ,empty: empty 51 | ,append: append 52 | ,concat: concat 53 | ,join: join 54 | ,link: link 55 | ,style: style 56 | ,defaultStyle: defaultStyle 57 | ,typeface: typeface 58 | ,monospace: monospace 59 | ,height: height 60 | ,color: color 61 | ,bold: bold 62 | ,italic: italic 63 | ,line: line 64 | ,Style: Style 65 | ,Under: Under 66 | ,Over: Over 67 | ,Through: Through}; 68 | }; -------------------------------------------------------------------------------- /elm-stuff/build-artifacts/0.16.0/elm-lang/core/3.0.0/Time.elmi: -------------------------------------------------------------------------------- 1 | elm-langcore millisecondsecondminutehourinMilliseconds inSeconds inMinutesinHoursfpsfpsWhenevery timestampdelaysinceTime::aListaListadelayelm-langcoreTimeTimeFloatelm-langcoreSignalSignalaelm-langcoreSignalSignalaeveryelm-langcoreTimeTimeFloatelm-langcoreSignalSignalelm-langcoreTimeTimeFloatfpsnumberelm-langcoreSignalSignalelm-langcoreTimeTimeFloatfpsWhennumberelm-langcoreSignalSignalBoolelm-langcoreSignalSignalelm-langcoreTimeTimeFloathourelm-langcoreTimeTimeFloatinHourselm-langcoreTimeTimeFloatFloatinMillisecondselm-langcoreTimeTimeFloatFloat inMinuteselm-langcoreTimeTimeFloatFloat inSecondselm-langcoreTimeTimeFloatFloat millisecondelm-langcoreTimeTimeFloatminuteelm-langcoreTimeTimeFloatsecondelm-langcoreTimeTimeFloatsinceelm-langcoreTimeTimeFloatelm-langcoreSignalSignalaelm-langcoreSignalSignalBool timestampelm-langcoreSignalSignalaelm-langcoreSignalSignal_Tuple2elm-langcoreTimeTimeFloataBasicsNativeSignalNativeTimeSignalTimeFloat -------------------------------------------------------------------------------- /elm-stuff/build-artifacts/0.16.0/elm-lang/core/3.0.0/Time.elmo: -------------------------------------------------------------------------------- 1 | Elm.Time = Elm.Time || {}; 2 | Elm.Time.make = function (_elm) { 3 | "use strict"; 4 | _elm.Time = _elm.Time || {}; 5 | if (_elm.Time.values) return _elm.Time.values; 6 | var _U = Elm.Native.Utils.make(_elm), 7 | $Basics = Elm.Basics.make(_elm), 8 | $Native$Signal = Elm.Native.Signal.make(_elm), 9 | $Native$Time = Elm.Native.Time.make(_elm), 10 | $Signal = Elm.Signal.make(_elm); 11 | var _op = {}; 12 | var delay = $Native$Signal.delay; 13 | var since = F2(function (time,signal) { 14 | var stop = A2($Signal.map, 15 | $Basics.always(-1), 16 | A2(delay,time,signal)); 17 | var start = A2($Signal.map,$Basics.always(1),signal); 18 | var delaydiff = A3($Signal.foldp, 19 | F2(function (x,y) { return x + y;}), 20 | 0, 21 | A2($Signal.merge,start,stop)); 22 | return A2($Signal.map, 23 | F2(function (x,y) { return !_U.eq(x,y);})(0), 24 | delaydiff); 25 | }); 26 | var timestamp = $Native$Signal.timestamp; 27 | var every = $Native$Time.every; 28 | var fpsWhen = $Native$Time.fpsWhen; 29 | var fps = function (targetFrames) { 30 | return A2(fpsWhen,targetFrames,$Signal.constant(true)); 31 | }; 32 | var inMilliseconds = function (t) { return t;}; 33 | var millisecond = 1; 34 | var second = 1000 * millisecond; 35 | var minute = 60 * second; 36 | var hour = 60 * minute; 37 | var inHours = function (t) { return t / hour;}; 38 | var inMinutes = function (t) { return t / minute;}; 39 | var inSeconds = function (t) { return t / second;}; 40 | return _elm.Time.values = {_op: _op 41 | ,millisecond: millisecond 42 | ,second: second 43 | ,minute: minute 44 | ,hour: hour 45 | ,inMilliseconds: inMilliseconds 46 | ,inSeconds: inSeconds 47 | ,inMinutes: inMinutes 48 | ,inHours: inHours 49 | ,fps: fps 50 | ,fpsWhen: fpsWhen 51 | ,every: every 52 | ,timestamp: timestamp 53 | ,delay: delay 54 | ,since: since}; 55 | }; -------------------------------------------------------------------------------- /elm-stuff/build-artifacts/0.16.0/elm-lang/core/3.0.0/Touch.elmi: -------------------------------------------------------------------------------- 1 | elm-langcoretouchestapsTouchTouch::aListaListaTouchIntIntIntIntIntelm-langcoreTimeTimeFloatelm-langcoreTouchTouchidIntt0elm-langcoreTimeTimeFloatxIntx0IntyInty0Inttapselm-langcoreSignalSignalxIntyInttoucheselm-langcoreSignalSignalListelm-langcoreTouchTouchidIntt0elm-langcoreTimeTimeFloatxIntx0IntyInty0IntNativeTouchSignalTimeTouchxIntyIntidIntx0Inty0Intt0elm-langcoreTimeTimeFloat -------------------------------------------------------------------------------- /elm-stuff/build-artifacts/0.16.0/elm-lang/core/3.0.0/Touch.elmo: -------------------------------------------------------------------------------- 1 | Elm.Touch = Elm.Touch || {}; 2 | Elm.Touch.make = function (_elm) { 3 | "use strict"; 4 | _elm.Touch = _elm.Touch || {}; 5 | if (_elm.Touch.values) return _elm.Touch.values; 6 | var _U = Elm.Native.Utils.make(_elm), 7 | $Native$Touch = Elm.Native.Touch.make(_elm), 8 | $Signal = Elm.Signal.make(_elm), 9 | $Time = Elm.Time.make(_elm); 10 | var _op = {}; 11 | var taps = $Native$Touch.taps; 12 | var touches = $Native$Touch.touches; 13 | var Touch = F6(function (a,b,c,d,e,f) { 14 | return {x: a,y: b,id: c,x0: d,y0: e,t0: f}; 15 | }); 16 | return _elm.Touch.values = {_op: _op 17 | ,touches: touches 18 | ,taps: taps 19 | ,Touch: Touch}; 20 | }; -------------------------------------------------------------------------------- /elm-stuff/build-artifacts/0.16.0/elm-lang/core/3.0.0/Trampoline.elmi: -------------------------------------------------------------------------------- 1 | elm-langcore 2 | trampoline 3 | TrampolineDoneContinue::aListaListaContinue_Tuple0elm-langcore 4 | Trampoline 5 | Trampolineaelm-langcore 6 | Trampoline 7 | TrampolineaDoneaelm-langcore 8 | Trampoline 9 | Trampolinea 10 | trampolineelm-langcore 11 | Trampoline 12 | Trampolineaa 13 | TrampolineaDoneaContinue_Tuple0elm-langcore 14 | Trampoline 15 | Trampolinea -------------------------------------------------------------------------------- /elm-stuff/build-artifacts/0.16.0/elm-lang/core/3.0.0/Trampoline.elmo: -------------------------------------------------------------------------------- 1 | Elm.Trampoline = Elm.Trampoline || {}; 2 | Elm.Trampoline.make = function (_elm) { 3 | "use strict"; 4 | _elm.Trampoline = _elm.Trampoline || {}; 5 | if (_elm.Trampoline.values) return _elm.Trampoline.values; 6 | var _U = Elm.Native.Utils.make(_elm); 7 | var _op = {}; 8 | var trampoline = function (tramp) { 9 | trampoline: while (true) { 10 | var _p0 = tramp; 11 | if (_p0.ctor === "Done") { 12 | return _p0._0; 13 | } else { 14 | var _v1 = _p0._0({ctor: "_Tuple0"}); 15 | tramp = _v1; 16 | continue trampoline; 17 | } 18 | } 19 | }; 20 | var Continue = function (a) { 21 | return {ctor: "Continue",_0: a}; 22 | }; 23 | var Done = function (a) { return {ctor: "Done",_0: a};}; 24 | return _elm.Trampoline.values = {_op: _op 25 | ,trampoline: trampoline 26 | ,Done: Done 27 | ,Continue: Continue}; 28 | }; -------------------------------------------------------------------------------- /elm-stuff/build-artifacts/0.16.0/elm-lang/core/3.0.0/Transform2D.elmi: -------------------------------------------------------------------------------- 1 | elm-langcore identitymatrixmultiplyrotation translationscalescaleXscaleY Transform2D 2 | ::aListaLista Transform2Delm-langcore Transform2D Transform2Didentityelm-langcore Transform2D Transform2DmatrixFloatFloatFloatFloatFloatFloatelm-langcore Transform2D Transform2Dmultiplyelm-langcore Transform2D Transform2Delm-langcore Transform2D Transform2Delm-langcore Transform2D Transform2DrotationFloatelm-langcore Transform2D Transform2DscaleFloatelm-langcore Transform2D Transform2DscaleXFloatelm-langcore Transform2D Transform2DscaleYFloatelm-langcore Transform2D Transform2D translationFloatFloatelm-langcore Transform2D Transform2DNative Transform2D Transform2D Transform2D -------------------------------------------------------------------------------- /elm-stuff/build-artifacts/0.16.0/elm-lang/core/3.0.0/Transform2D.elmo: -------------------------------------------------------------------------------- 1 | Elm.Transform2D = Elm.Transform2D || {}; 2 | Elm.Transform2D.make = function (_elm) { 3 | "use strict"; 4 | _elm.Transform2D = _elm.Transform2D || {}; 5 | if (_elm.Transform2D.values) return _elm.Transform2D.values; 6 | var _U = Elm.Native.Utils.make(_elm), 7 | $Native$Transform2D = Elm.Native.Transform2D.make(_elm); 8 | var _op = {}; 9 | var multiply = $Native$Transform2D.multiply; 10 | var rotation = $Native$Transform2D.rotation; 11 | var matrix = $Native$Transform2D.matrix; 12 | var translation = F2(function (x,y) { 13 | return A6(matrix,1,0,0,1,x,y); 14 | }); 15 | var scale = function (s) { return A6(matrix,s,0,0,s,0,0);}; 16 | var scaleX = function (x) { return A6(matrix,x,0,0,1,0,0);}; 17 | var scaleY = function (y) { return A6(matrix,1,0,0,y,0,0);}; 18 | var identity = $Native$Transform2D.identity; 19 | var Transform2D = {ctor: "Transform2D"}; 20 | return _elm.Transform2D.values = {_op: _op 21 | ,identity: identity 22 | ,matrix: matrix 23 | ,multiply: multiply 24 | ,rotation: rotation 25 | ,translation: translation 26 | ,scale: scale 27 | ,scaleX: scaleX 28 | ,scaleY: scaleY}; 29 | }; -------------------------------------------------------------------------------- /elm-stuff/build-artifacts/0.16.0/elm-lang/core/3.0.0/Window.elmi: -------------------------------------------------------------------------------- 1 | elm-langcore 2 | dimensionswidthheight::aListaLista 3 | dimensionselm-langcoreSignalSignal_Tuple2IntIntheightelm-langcoreSignalSignalIntwidthelm-langcoreSignalSignalIntBasicsNativeWindowSignal -------------------------------------------------------------------------------- /elm-stuff/build-artifacts/0.16.0/elm-lang/core/3.0.0/Window.elmo: -------------------------------------------------------------------------------- 1 | Elm.Window = Elm.Window || {}; 2 | Elm.Window.make = function (_elm) { 3 | "use strict"; 4 | _elm.Window = _elm.Window || {}; 5 | if (_elm.Window.values) return _elm.Window.values; 6 | var _U = Elm.Native.Utils.make(_elm), 7 | $Basics = Elm.Basics.make(_elm), 8 | $Native$Window = Elm.Native.Window.make(_elm), 9 | $Signal = Elm.Signal.make(_elm); 10 | var _op = {}; 11 | var dimensions = $Native$Window.dimensions; 12 | var width = A2($Signal.map,$Basics.fst,dimensions); 13 | var height = A2($Signal.map,$Basics.snd,dimensions); 14 | return _elm.Window.values = {_op: _op 15 | ,dimensions: dimensions 16 | ,width: width 17 | ,height: height}; 18 | }; -------------------------------------------------------------------------------- /elm-stuff/exact-dependencies.json: -------------------------------------------------------------------------------- 1 | { 2 | "elm-lang/core": "3.0.0" 3 | } -------------------------------------------------------------------------------- /main.elm: -------------------------------------------------------------------------------- 1 | module MissileCommand where 2 | 3 | import Mouse 4 | import Random 5 | import Text 6 | import Touch 7 | import Window 8 | import List exposing (..) 9 | import Color exposing (..) 10 | import Graphics.Collage exposing (..) 11 | import Graphics.Element exposing (..) 12 | import Time exposing (..) 13 | 14 | type alias Pos = { x:Float, y:Float } 15 | type alias Ms = Float -- milliseconds 16 | 17 | groundH = 30 -- height of the ground 18 | commandH = 40 -- height of the command 19 | missileW = 10 -- width of a missile object 20 | speed = 50 -- speed of missiles per second in a straight line 21 | explosionSpd = 30 -- speed of the explosion per second 22 | blastRadius = 50 -- max radius of an explosion 23 | 24 | type alias Velocity = { vx:Float, vy:Float } 25 | type alias Radius = Float 26 | type GameStatus = NotStarted | Started | Ended 27 | type MissileStatus = Flying Pos Pos Velocity -- the starting, end positions and velocity of flight 28 | | Exploding Radius -- the current radius of the blast 29 | | Exploded 30 | type MissileKind = Friendly | Enemy 31 | type ExplodeReason = ReachedTarget | CaughtInBlast | Collision 32 | 33 | type alias Missile = { x:Float, y:Float, kind:MissileKind, status:MissileStatus } 34 | type alias GameState = { friendlyMissiles: List Missile 35 | , enemyMissiles:List Missile 36 | , score:Int 37 | , hp:Int 38 | , status:GameStatus 39 | , seed:Random.Seed } 40 | 41 | type Input = Time Ms -- time ticker 42 | | UserAction Pos -- user action on the canvas 43 | | EnemyLaunch --List--(Float, Float) -- enemy missile launches 44 | 45 | defaultGame : GameState 46 | defaultGame = { friendlyMissiles=[], enemyMissiles=[], score=0, hp=10, status=NotStarted, seed = Random.initialSeed 1 } 47 | 48 | filterJust : Maybe a -> Bool 49 | filterJust x = 50 | case x of 51 | Just _ -> True 52 | _ -> False 53 | 54 | extractJust : Maybe a -> a 55 | extractJust x = 56 | case x of 57 | Just x' -> x' 58 | _ -> Debug.crash "boom" 59 | 60 | choose : (a -> Maybe b) -> List a -> List b 61 | choose f lst = map f lst |> filter filterJust |> map extractJust 62 | 63 | calcVelocity : Pos -> Pos -> Velocity 64 | calcVelocity start end = 65 | let distH = end.x-start.x 66 | distV = end.y-start.y 67 | angle = atan2 distV distH 68 | in { vx=speed*cos angle, vy=speed*sin angle } 69 | 70 | hitTest : Missile -> Missile -> Bool 71 | hitTest missile1 missile2 = 72 | let isCollision x y centreX centreY radius = 73 | let (minX, maxX, minY, maxY) = (centreX-radius, centreX+radius, centreY-radius, centreY+radius) 74 | in minX <= x 75 | && x <= maxX 76 | && minY <= y 77 | && y <= maxY 78 | in case (missile1.status, missile2.status) of 79 | -- when caught in another missile's blast then it's a 'hit' 80 | (Flying _ _ _, Exploding radius) -> isCollision missile1.x missile1.y missile2.x missile2.y radius 81 | -- when different kinds of missiles collide they 'hit' 82 | (Flying _ _ _, Flying _ _ _) -> 83 | missile1.kind /= missile2.kind 84 | && isCollision missile1.x missile1.y missile2.x missile2.y (missileW/2) 85 | (_, _) -> False 86 | 87 | newMissile : Pos -> Pos -> MissileKind -> Missile 88 | newMissile start end kind = 89 | let velocity = calcVelocity start end 90 | in { x=start.x, y=start.y, kind=kind, status=Flying start end velocity } 91 | 92 | pairWise : List a -> List (a, a) 93 | pairWise lst = 94 | let loop lst acc = 95 | case lst of 96 | a::b::tl -> loop tl ((a, b)::acc) 97 | [] -> acc 98 | _ -> Debug.crash "pair-wise failed" 99 | in loop lst [] 100 | 101 | getEnemyMissile : (Int, Int) -> (Float, Float) -> Missile 102 | getEnemyMissile (windowW, windowH) (start, end) = 103 | let (w, h) = (toFloat windowW, toFloat windowH) 104 | getX x = w*x - w/2 105 | startPos = { x=getX start, y=h/2 } 106 | endPos = { x=getX end, y=groundH - h/2 } 107 | in newMissile startPos endPos Enemy 108 | 109 | stepMissile : Float -> GameState -> Missile -> (Missile, Maybe ExplodeReason) 110 | stepMissile delta { friendlyMissiles, enemyMissiles } missile = 111 | case missile.status of 112 | -- for a flying missile, move its position 113 | Flying _ end { vx, vy } -> 114 | let newX = missile.x + vx*delta 115 | newY = missile.y + vy*delta 116 | inBlastRadius = any (hitTest missile) <| friendlyMissiles++enemyMissiles 117 | reachedEnd = if vy > 0 then newY > end.y else newY < end.y 118 | in if reachedEnd || inBlastRadius 119 | then ({ missile | x=newX, y=newY, status=Exploding 0 } 120 | , Just <| if reachedEnd then ReachedTarget else CaughtInBlast ) 121 | else ({ missile | x=newX, y=newY }, Nothing) 122 | -- for an exploding missile, expand the radius of the explosion 123 | Exploding radius -> 124 | let newRadius = radius + explosionSpd*delta 125 | disappear = newRadius > blastRadius 126 | in if disappear 127 | then ({ missile | status=Exploded }, Nothing) 128 | else ({ missile | status=Exploding newRadius }, Nothing) 129 | _ -> Debug.crash "unexpected status" 130 | 131 | stepGame : (Input, (Int, Int)) -> GameState -> GameState 132 | stepGame (input, (windowW, windowH)) gameState = 133 | case (gameState.status, input) of 134 | (Started, EnemyLaunch) -> 135 | let 136 | (cnt, seed') = Random.generate (Random.int 0 5) gameState.seed 137 | (lst, _) = Random.generate (Random.list cnt (Random.pair (Random.float 0 1) (Random.float 0 1))) gameState.seed 138 | missiles = map (getEnemyMissile (windowW, windowH)) lst 139 | in { gameState | enemyMissiles=missiles++gameState.enemyMissiles 140 | , seed = seed' } 141 | (NotStarted, UserAction _) -> { gameState | status=Started } 142 | (Ended, UserAction _) -> { defaultGame | status=Started } 143 | (Started, UserAction end) -> 144 | let commandTop = { x=0, y=toFloat -windowH/2 + groundH + commandH - 10 } 145 | in { gameState | friendlyMissiles=newMissile commandTop end Friendly::gameState.friendlyMissiles } 146 | (Started, Time delta) -> 147 | let (enemyMissiles, explodeReasons) = unzip <| map (stepMissile delta gameState) gameState.enemyMissiles 148 | (friendlyMissiles, _) = unzip <| map (stepMissile delta gameState) gameState.friendlyMissiles 149 | -- deduct 1 HP for every enemy missile that managed to pass our defense 150 | enemyWins = filter ((==) (Just ReachedTarget)) explodeReasons |> length 151 | -- award 1 score for every enemy missile that were blasted out of the sky! 152 | playerWins = filter ((==) (Just CaughtInBlast)) explodeReasons |> length 153 | newHp = gameState.hp-enemyWins |> max 0 154 | newScore = gameState.score+playerWins 155 | newStatus = if newHp == 0 then Ended else Started 156 | in { gameState | enemyMissiles=filter (((/=) Exploded) << .status) enemyMissiles 157 | , friendlyMissiles=filter (((/=) Exploded) << .status) friendlyMissiles 158 | , hp=newHp 159 | , score=newScore 160 | , status=newStatus} 161 | (_, _) -> gameState 162 | 163 | drawMissile : Missile -> Maybe Form 164 | drawMissile { x, y, kind, status } = 165 | case status of 166 | Flying _ _ _ -> 167 | let color = if kind==Enemy then red else blue 168 | in ngon 4 (missileW/2) |> filled color |> move (x, y) |> Just 169 | _ -> Nothing 170 | 171 | drawTrail : Missile -> Maybe Form 172 | drawTrail { x, y, kind, status } = 173 | case status of 174 | Flying start _ _ -> 175 | let (colour, alphaVal, lineW) = if kind==Enemy then (red, 0.5, 5) else (blue, 0.2, 1) 176 | lineStyle = solid colour 177 | in path [ (x, y), (start.x, start.y) ] 178 | |> traced ({ lineStyle | width=lineW }) 179 | |> alpha alphaVal 180 | |> Just 181 | _ -> Nothing 182 | 183 | drawExplosions : Missile -> Maybe Form 184 | drawExplosions { x, y, status } = 185 | case status of 186 | Exploding radius -> 187 | circle radius 188 | |> filled (rgb 150 170 150) 189 | |> alpha 0.5 190 | |> move (x, y) 191 | |> Just 192 | _ -> Nothing 193 | 194 | drawBackground : (Int, Int) -> Element 195 | drawBackground (windowW, windowH) = 196 | let (w, h) = (toFloat windowW, toFloat windowH) 197 | groundY = -h/2 + groundH/2 198 | centreY = -h/2 + commandH 199 | in collage windowW windowH 200 | <| [ rect w h |> filled (rgb 0 0 0) 201 | , rect w groundH |> filled (rgb 255 255 40) |> move (0, groundY) 202 | , ngon 3 (commandH/2) 203 | |> filled (rgb 255 255 40) 204 | |> rotate (degrees 90) 205 | |> move (0, centreY)] 206 | 207 | drawGameInfo : (Int, Int) -> GameState -> Element 208 | drawGameInfo (windowW, windowH) { hp, score } = 209 | let (w, h) = (toFloat windowW, toFloat windowH) 210 | in collage windowW windowH 211 | <| [ txt (move (-w/3, h/2-10)) ("Score "++ toString score) 212 | , txt (move (w/3, h/2-10)) ("HP "++ toString hp)] 213 | 214 | drawGame : (Int, Int) -> GameState -> Element 215 | drawGame (windowW, windowH) gameState = 216 | let content = 217 | case gameState.status of 218 | NotStarted -> [ txt identity "TAP anywhere to START." ] 219 | Started -> concat [ choose drawExplosions gameState.friendlyMissiles 220 | , choose drawExplosions gameState.enemyMissiles 221 | , choose drawTrail gameState.friendlyMissiles 222 | , choose drawTrail gameState.enemyMissiles 223 | , choose drawMissile gameState.friendlyMissiles 224 | , choose drawMissile gameState.enemyMissiles ] 225 | Ended -> [ txt identity " GAME OVER!\nTAP to RESTART." ] 226 | in collage windowW windowH content 227 | 228 | display : (Int, Int) -> GameState -> Element 229 | display dim gameState = layers [ drawBackground dim 230 | , drawGame dim gameState 231 | , drawGameInfo dim gameState] 232 | 233 | txt : (Form -> Form) -> String -> Form 234 | txt f msg = msg |> Text.fromString |> Text.color white |> Text.monospace |> leftAligned |> toForm |> f 235 | 236 | userInput : Signal Input 237 | userInput = 238 | -- converts the (x, y) coordinates of a mouse click to the coordinate system used by the collage 239 | let convert (w, h) { x, y } = (toFloat x - toFloat w/2, toFloat h/2 - toFloat y) 240 | in Signal.map2 convert Window.dimensions Touch.taps 241 | |> Signal.sampleOn Mouse.clicks 242 | |> Signal.map (\(x, y) -> UserAction { x=x, y=y }) 243 | 244 | enemyLaunch : Signal Input 245 | enemyLaunch = Signal.map (\_ -> EnemyLaunch) (every <| 2*second) 246 | 247 | delta = fps 60 248 | timer : Signal Input 249 | timer = Signal.sampleOn delta <| Signal.map (\n -> Time <| n / 1000) delta 250 | 251 | input : Signal Input 252 | input = Signal.mergeMany 253 | [ timer 254 | , userInput 255 | , enemyLaunch] 256 | 257 | gameState : Signal GameState 258 | gameState = 259 | Signal.map2 (,) input Window.dimensions 260 | |> Signal.foldp stepGame defaultGame 261 | 262 | main = Signal.map2 display Window.dimensions gameState 263 | -------------------------------------------------------------------------------- /run_server.cmd: -------------------------------------------------------------------------------- 1 | elm-server --------------------------------------------------------------------------------