├── .gitignore ├── README.md ├── elm-package.json ├── example ├── Example.elm ├── example-node-runner └── example.js ├── make-example.sh └── src ├── Console.elm ├── File.elm ├── Http.elm ├── Native ├── Console.js ├── File.js ├── Http.js ├── Path.js ├── Process.js └── Url.js ├── NodeProcess.elm ├── Path.elm └── Url.elm /.gitignore: -------------------------------------------------------------------------------- 1 | elm-stuff 2 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Experimental server side Elm package 2 | 3 | If you have a Main module, you can run the compiled js file with node automatically. 4 | 5 | ``` 6 | node elm.js 7 | ``` 8 | 9 | You can also import the file as a library, setup any ports, and start the program manually. 10 | 11 | ```js 12 | var Elm = require('./elm.js'); 13 | 14 | var app = Elm.Main.worker(); 15 | ``` 16 | 17 | The API is still very experimental. 18 | 19 | For a more in depth example, checkout [elm-oracle](https://github.com/ElmCast/elm-oracle/blob/master/Main.elm). 20 | -------------------------------------------------------------------------------- /elm-package.json: -------------------------------------------------------------------------------- 1 | { 2 | "version": "1.0.0", 3 | "summary": "Elm libraries for server side development.", 4 | "repository": "http://github.com/elmcast/elm-node.git", 5 | "license": "BSD3", 6 | "source-directories": [ 7 | "src" 8 | ], 9 | "exposed-modules": [ 10 | "Console", 11 | "File", 12 | "Http", 13 | "Path", 14 | "NodeProcess", 15 | "Url" 16 | ], 17 | "native-modules": true, 18 | "dependencies": { 19 | "elm-lang/core": "5.0.0 <= v < 6.0.0" 20 | }, 21 | "elm-version": "0.18.0 <= v < 0.19.0" 22 | } 23 | -------------------------------------------------------------------------------- /example/Example.elm: -------------------------------------------------------------------------------- 1 | module Example exposing (main) 2 | 3 | import Platform 4 | import Platform.Cmd as Cmd 5 | import Platform.Sub as Sub 6 | import Task 7 | import Console 8 | import NodeProcess 9 | 10 | 11 | type alias Model = 12 | () 13 | 14 | 15 | type alias Msg = 16 | () 17 | 18 | 19 | main : Program Never Model Msg 20 | main = 21 | Platform.program 22 | { init = 23 | ( () 24 | , Task.perform 25 | (\_ -> ()) 26 | (Console.log <| 27 | "Hello Elm world!\n" 28 | ++ "Args: " 29 | ++ toString NodeProcess.args 30 | ) 31 | ) 32 | , update = update 33 | , subscriptions = subscriptions 34 | } 35 | 36 | 37 | update : Msg -> Model -> ( Model, Cmd Msg ) 38 | update msg model = 39 | () ! [ Cmd.none ] 40 | 41 | 42 | subscriptions : Model -> Sub Msg 43 | subscriptions model = 44 | Sub.none 45 | -------------------------------------------------------------------------------- /example/example-node-runner: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env node 2 | 'use strict'; 3 | 4 | var Elm = require('./example.js'); 5 | 6 | var app = Elm.Example.worker(); 7 | -------------------------------------------------------------------------------- /example/example.js: -------------------------------------------------------------------------------- 1 | 2 | (function() { 3 | 'use strict'; 4 | 5 | function F2(fun) 6 | { 7 | function wrapper(a) { return function(b) { return fun(a,b); }; } 8 | wrapper.arity = 2; 9 | wrapper.func = fun; 10 | return wrapper; 11 | } 12 | 13 | function F3(fun) 14 | { 15 | function wrapper(a) { 16 | return function(b) { return function(c) { return fun(a, b, c); }; }; 17 | } 18 | wrapper.arity = 3; 19 | wrapper.func = fun; 20 | return wrapper; 21 | } 22 | 23 | function F4(fun) 24 | { 25 | function wrapper(a) { return function(b) { return function(c) { 26 | return function(d) { return fun(a, b, c, d); }; }; }; 27 | } 28 | wrapper.arity = 4; 29 | wrapper.func = fun; 30 | return wrapper; 31 | } 32 | 33 | function F5(fun) 34 | { 35 | function wrapper(a) { return function(b) { return function(c) { 36 | return function(d) { return function(e) { return fun(a, b, c, d, e); }; }; }; }; 37 | } 38 | wrapper.arity = 5; 39 | wrapper.func = fun; 40 | return wrapper; 41 | } 42 | 43 | function F6(fun) 44 | { 45 | function wrapper(a) { return function(b) { return function(c) { 46 | return function(d) { return function(e) { return function(f) { 47 | return fun(a, b, c, d, e, f); }; }; }; }; }; 48 | } 49 | wrapper.arity = 6; 50 | wrapper.func = fun; 51 | return wrapper; 52 | } 53 | 54 | function F7(fun) 55 | { 56 | function wrapper(a) { return function(b) { return function(c) { 57 | return function(d) { return function(e) { return function(f) { 58 | return function(g) { return fun(a, b, c, d, e, f, g); }; }; }; }; }; }; 59 | } 60 | wrapper.arity = 7; 61 | wrapper.func = fun; 62 | return wrapper; 63 | } 64 | 65 | function F8(fun) 66 | { 67 | function wrapper(a) { return function(b) { return function(c) { 68 | return function(d) { return function(e) { return function(f) { 69 | return function(g) { return function(h) { 70 | return fun(a, b, c, d, e, f, g, h); }; }; }; }; }; }; }; 71 | } 72 | wrapper.arity = 8; 73 | wrapper.func = fun; 74 | return wrapper; 75 | } 76 | 77 | function F9(fun) 78 | { 79 | function wrapper(a) { return function(b) { return function(c) { 80 | return function(d) { return function(e) { return function(f) { 81 | return function(g) { return function(h) { return function(i) { 82 | return fun(a, b, c, d, e, f, g, h, i); }; }; }; }; }; }; }; }; 83 | } 84 | wrapper.arity = 9; 85 | wrapper.func = fun; 86 | return wrapper; 87 | } 88 | 89 | function A2(fun, a, b) 90 | { 91 | return fun.arity === 2 92 | ? fun.func(a, b) 93 | : fun(a)(b); 94 | } 95 | function A3(fun, a, b, c) 96 | { 97 | return fun.arity === 3 98 | ? fun.func(a, b, c) 99 | : fun(a)(b)(c); 100 | } 101 | function A4(fun, a, b, c, d) 102 | { 103 | return fun.arity === 4 104 | ? fun.func(a, b, c, d) 105 | : fun(a)(b)(c)(d); 106 | } 107 | function A5(fun, a, b, c, d, e) 108 | { 109 | return fun.arity === 5 110 | ? fun.func(a, b, c, d, e) 111 | : fun(a)(b)(c)(d)(e); 112 | } 113 | function A6(fun, a, b, c, d, e, f) 114 | { 115 | return fun.arity === 6 116 | ? fun.func(a, b, c, d, e, f) 117 | : fun(a)(b)(c)(d)(e)(f); 118 | } 119 | function A7(fun, a, b, c, d, e, f, g) 120 | { 121 | return fun.arity === 7 122 | ? fun.func(a, b, c, d, e, f, g) 123 | : fun(a)(b)(c)(d)(e)(f)(g); 124 | } 125 | function A8(fun, a, b, c, d, e, f, g, h) 126 | { 127 | return fun.arity === 8 128 | ? fun.func(a, b, c, d, e, f, g, h) 129 | : fun(a)(b)(c)(d)(e)(f)(g)(h); 130 | } 131 | function A9(fun, a, b, c, d, e, f, g, h, i) 132 | { 133 | return fun.arity === 9 134 | ? fun.func(a, b, c, d, e, f, g, h, i) 135 | : fun(a)(b)(c)(d)(e)(f)(g)(h)(i); 136 | } 137 | 138 | //import Native.Utils // 139 | 140 | var _elm_lang$core$Native_Basics = function() { 141 | 142 | function div(a, b) 143 | { 144 | return (a / b) | 0; 145 | } 146 | function rem(a, b) 147 | { 148 | return a % b; 149 | } 150 | function mod(a, b) 151 | { 152 | if (b === 0) 153 | { 154 | throw new Error('Cannot perform mod 0. Division by zero error.'); 155 | } 156 | var r = a % b; 157 | var m = a === 0 ? 0 : (b > 0 ? (a >= 0 ? r : r + b) : -mod(-a, -b)); 158 | 159 | return m === b ? 0 : m; 160 | } 161 | function logBase(base, n) 162 | { 163 | return Math.log(n) / Math.log(base); 164 | } 165 | function negate(n) 166 | { 167 | return -n; 168 | } 169 | function abs(n) 170 | { 171 | return n < 0 ? -n : n; 172 | } 173 | 174 | function min(a, b) 175 | { 176 | return _elm_lang$core$Native_Utils.cmp(a, b) < 0 ? a : b; 177 | } 178 | function max(a, b) 179 | { 180 | return _elm_lang$core$Native_Utils.cmp(a, b) > 0 ? a : b; 181 | } 182 | function clamp(lo, hi, n) 183 | { 184 | return _elm_lang$core$Native_Utils.cmp(n, lo) < 0 185 | ? lo 186 | : _elm_lang$core$Native_Utils.cmp(n, hi) > 0 187 | ? hi 188 | : n; 189 | } 190 | 191 | var ord = ['LT', 'EQ', 'GT']; 192 | 193 | function compare(x, y) 194 | { 195 | return { ctor: ord[_elm_lang$core$Native_Utils.cmp(x, y) + 1] }; 196 | } 197 | 198 | function xor(a, b) 199 | { 200 | return a !== b; 201 | } 202 | function not(b) 203 | { 204 | return !b; 205 | } 206 | function isInfinite(n) 207 | { 208 | return n === Infinity || n === -Infinity; 209 | } 210 | 211 | function truncate(n) 212 | { 213 | return n | 0; 214 | } 215 | 216 | function degrees(d) 217 | { 218 | return d * Math.PI / 180; 219 | } 220 | function turns(t) 221 | { 222 | return 2 * Math.PI * t; 223 | } 224 | function fromPolar(point) 225 | { 226 | var r = point._0; 227 | var t = point._1; 228 | return _elm_lang$core$Native_Utils.Tuple2(r * Math.cos(t), r * Math.sin(t)); 229 | } 230 | function toPolar(point) 231 | { 232 | var x = point._0; 233 | var y = point._1; 234 | return _elm_lang$core$Native_Utils.Tuple2(Math.sqrt(x * x + y * y), Math.atan2(y, x)); 235 | } 236 | 237 | return { 238 | div: F2(div), 239 | rem: F2(rem), 240 | mod: F2(mod), 241 | 242 | pi: Math.PI, 243 | e: Math.E, 244 | cos: Math.cos, 245 | sin: Math.sin, 246 | tan: Math.tan, 247 | acos: Math.acos, 248 | asin: Math.asin, 249 | atan: Math.atan, 250 | atan2: F2(Math.atan2), 251 | 252 | degrees: degrees, 253 | turns: turns, 254 | fromPolar: fromPolar, 255 | toPolar: toPolar, 256 | 257 | sqrt: Math.sqrt, 258 | logBase: F2(logBase), 259 | negate: negate, 260 | abs: abs, 261 | min: F2(min), 262 | max: F2(max), 263 | clamp: F3(clamp), 264 | compare: F2(compare), 265 | 266 | xor: F2(xor), 267 | not: not, 268 | 269 | truncate: truncate, 270 | ceiling: Math.ceil, 271 | floor: Math.floor, 272 | round: Math.round, 273 | toFloat: function(x) { return x; }, 274 | isNaN: isNaN, 275 | isInfinite: isInfinite 276 | }; 277 | 278 | }(); 279 | //import // 280 | 281 | var _elm_lang$core$Native_Utils = function() { 282 | 283 | // COMPARISONS 284 | 285 | function eq(x, y) 286 | { 287 | var stack = []; 288 | var isEqual = eqHelp(x, y, 0, stack); 289 | var pair; 290 | while (isEqual && (pair = stack.pop())) 291 | { 292 | isEqual = eqHelp(pair.x, pair.y, 0, stack); 293 | } 294 | return isEqual; 295 | } 296 | 297 | 298 | function eqHelp(x, y, depth, stack) 299 | { 300 | if (depth > 100) 301 | { 302 | stack.push({ x: x, y: y }); 303 | return true; 304 | } 305 | 306 | if (x === y) 307 | { 308 | return true; 309 | } 310 | 311 | if (typeof x !== 'object') 312 | { 313 | if (typeof x === 'function') 314 | { 315 | throw new Error( 316 | 'Trying to use `(==)` on functions. There is no way to know if functions are "the same" in the Elm sense.' 317 | + ' Read more about this at http://package.elm-lang.org/packages/elm-lang/core/latest/Basics#==' 318 | + ' which describes why it is this way and what the better version will look like.' 319 | ); 320 | } 321 | return false; 322 | } 323 | 324 | if (x === null || y === null) 325 | { 326 | return false 327 | } 328 | 329 | if (x instanceof Date) 330 | { 331 | return x.getTime() === y.getTime(); 332 | } 333 | 334 | if (!('ctor' in x)) 335 | { 336 | for (var key in x) 337 | { 338 | if (!eqHelp(x[key], y[key], depth + 1, stack)) 339 | { 340 | return false; 341 | } 342 | } 343 | return true; 344 | } 345 | 346 | // convert Dicts and Sets to lists 347 | if (x.ctor === 'RBNode_elm_builtin' || x.ctor === 'RBEmpty_elm_builtin') 348 | { 349 | x = _elm_lang$core$Dict$toList(x); 350 | y = _elm_lang$core$Dict$toList(y); 351 | } 352 | if (x.ctor === 'Set_elm_builtin') 353 | { 354 | x = _elm_lang$core$Set$toList(x); 355 | y = _elm_lang$core$Set$toList(y); 356 | } 357 | 358 | // check if lists are equal without recursion 359 | if (x.ctor === '::') 360 | { 361 | var a = x; 362 | var b = y; 363 | while (a.ctor === '::' && b.ctor === '::') 364 | { 365 | if (!eqHelp(a._0, b._0, depth + 1, stack)) 366 | { 367 | return false; 368 | } 369 | a = a._1; 370 | b = b._1; 371 | } 372 | return a.ctor === b.ctor; 373 | } 374 | 375 | // check if Arrays are equal 376 | if (x.ctor === '_Array') 377 | { 378 | var xs = _elm_lang$core$Native_Array.toJSArray(x); 379 | var ys = _elm_lang$core$Native_Array.toJSArray(y); 380 | if (xs.length !== ys.length) 381 | { 382 | return false; 383 | } 384 | for (var i = 0; i < xs.length; i++) 385 | { 386 | if (!eqHelp(xs[i], ys[i], depth + 1, stack)) 387 | { 388 | return false; 389 | } 390 | } 391 | return true; 392 | } 393 | 394 | if (!eqHelp(x.ctor, y.ctor, depth + 1, stack)) 395 | { 396 | return false; 397 | } 398 | 399 | for (var key in x) 400 | { 401 | if (!eqHelp(x[key], y[key], depth + 1, stack)) 402 | { 403 | return false; 404 | } 405 | } 406 | return true; 407 | } 408 | 409 | // Code in Generate/JavaScript.hs, Basics.js, and List.js depends on 410 | // the particular integer values assigned to LT, EQ, and GT. 411 | 412 | var LT = -1, EQ = 0, GT = 1; 413 | 414 | function cmp(x, y) 415 | { 416 | if (typeof x !== 'object') 417 | { 418 | return x === y ? EQ : x < y ? LT : GT; 419 | } 420 | 421 | if (x instanceof String) 422 | { 423 | var a = x.valueOf(); 424 | var b = y.valueOf(); 425 | return a === b ? EQ : a < b ? LT : GT; 426 | } 427 | 428 | if (x.ctor === '::' || x.ctor === '[]') 429 | { 430 | while (x.ctor === '::' && y.ctor === '::') 431 | { 432 | var ord = cmp(x._0, y._0); 433 | if (ord !== EQ) 434 | { 435 | return ord; 436 | } 437 | x = x._1; 438 | y = y._1; 439 | } 440 | return x.ctor === y.ctor ? EQ : x.ctor === '[]' ? LT : GT; 441 | } 442 | 443 | if (x.ctor.slice(0, 6) === '_Tuple') 444 | { 445 | var ord; 446 | var n = x.ctor.slice(6) - 0; 447 | var err = 'cannot compare tuples with more than 6 elements.'; 448 | if (n === 0) return EQ; 449 | if (n >= 1) { ord = cmp(x._0, y._0); if (ord !== EQ) return ord; 450 | if (n >= 2) { ord = cmp(x._1, y._1); if (ord !== EQ) return ord; 451 | if (n >= 3) { ord = cmp(x._2, y._2); if (ord !== EQ) return ord; 452 | if (n >= 4) { ord = cmp(x._3, y._3); if (ord !== EQ) return ord; 453 | if (n >= 5) { ord = cmp(x._4, y._4); if (ord !== EQ) return ord; 454 | if (n >= 6) { ord = cmp(x._5, y._5); if (ord !== EQ) return ord; 455 | if (n >= 7) throw new Error('Comparison error: ' + err); } } } } } } 456 | return EQ; 457 | } 458 | 459 | throw new Error( 460 | 'Comparison error: comparison is only defined on ints, ' 461 | + 'floats, times, chars, strings, lists of comparable values, ' 462 | + 'and tuples of comparable values.' 463 | ); 464 | } 465 | 466 | 467 | // COMMON VALUES 468 | 469 | var Tuple0 = { 470 | ctor: '_Tuple0' 471 | }; 472 | 473 | function Tuple2(x, y) 474 | { 475 | return { 476 | ctor: '_Tuple2', 477 | _0: x, 478 | _1: y 479 | }; 480 | } 481 | 482 | function chr(c) 483 | { 484 | return new String(c); 485 | } 486 | 487 | 488 | // GUID 489 | 490 | var count = 0; 491 | function guid(_) 492 | { 493 | return count++; 494 | } 495 | 496 | 497 | // RECORDS 498 | 499 | function update(oldRecord, updatedFields) 500 | { 501 | var newRecord = {}; 502 | 503 | for (var key in oldRecord) 504 | { 505 | newRecord[key] = oldRecord[key]; 506 | } 507 | 508 | for (var key in updatedFields) 509 | { 510 | newRecord[key] = updatedFields[key]; 511 | } 512 | 513 | return newRecord; 514 | } 515 | 516 | 517 | //// LIST STUFF //// 518 | 519 | var Nil = { ctor: '[]' }; 520 | 521 | function Cons(hd, tl) 522 | { 523 | return { 524 | ctor: '::', 525 | _0: hd, 526 | _1: tl 527 | }; 528 | } 529 | 530 | function append(xs, ys) 531 | { 532 | // append Strings 533 | if (typeof xs === 'string') 534 | { 535 | return xs + ys; 536 | } 537 | 538 | // append Lists 539 | if (xs.ctor === '[]') 540 | { 541 | return ys; 542 | } 543 | var root = Cons(xs._0, Nil); 544 | var curr = root; 545 | xs = xs._1; 546 | while (xs.ctor !== '[]') 547 | { 548 | curr._1 = Cons(xs._0, Nil); 549 | xs = xs._1; 550 | curr = curr._1; 551 | } 552 | curr._1 = ys; 553 | return root; 554 | } 555 | 556 | 557 | // CRASHES 558 | 559 | function crash(moduleName, region) 560 | { 561 | return function(message) { 562 | throw new Error( 563 | 'Ran into a `Debug.crash` in module `' + moduleName + '` ' + regionToString(region) + '\n' 564 | + 'The message provided by the code author is:\n\n ' 565 | + message 566 | ); 567 | }; 568 | } 569 | 570 | function crashCase(moduleName, region, value) 571 | { 572 | return function(message) { 573 | throw new Error( 574 | 'Ran into a `Debug.crash` in module `' + moduleName + '`\n\n' 575 | + 'This was caused by the `case` expression ' + regionToString(region) + '.\n' 576 | + 'One of the branches ended with a crash and the following value got through:\n\n ' + toString(value) + '\n\n' 577 | + 'The message provided by the code author is:\n\n ' 578 | + message 579 | ); 580 | }; 581 | } 582 | 583 | function regionToString(region) 584 | { 585 | if (region.start.line == region.end.line) 586 | { 587 | return 'on line ' + region.start.line; 588 | } 589 | return 'between lines ' + region.start.line + ' and ' + region.end.line; 590 | } 591 | 592 | 593 | // TO STRING 594 | 595 | function toString(v) 596 | { 597 | var type = typeof v; 598 | if (type === 'function') 599 | { 600 | var name = v.func ? v.func.name : v.name; 601 | return ''; 602 | } 603 | 604 | if (type === 'boolean') 605 | { 606 | return v ? 'True' : 'False'; 607 | } 608 | 609 | if (type === 'number') 610 | { 611 | return v + ''; 612 | } 613 | 614 | if (v instanceof String) 615 | { 616 | return '\'' + addSlashes(v, true) + '\''; 617 | } 618 | 619 | if (type === 'string') 620 | { 621 | return '"' + addSlashes(v, false) + '"'; 622 | } 623 | 624 | if (v === null) 625 | { 626 | return 'null'; 627 | } 628 | 629 | if (type === 'object' && 'ctor' in v) 630 | { 631 | var ctorStarter = v.ctor.substring(0, 5); 632 | 633 | if (ctorStarter === '_Tupl') 634 | { 635 | var output = []; 636 | for (var k in v) 637 | { 638 | if (k === 'ctor') continue; 639 | output.push(toString(v[k])); 640 | } 641 | return '(' + output.join(',') + ')'; 642 | } 643 | 644 | if (ctorStarter === '_Task') 645 | { 646 | return '' 647 | } 648 | 649 | if (v.ctor === '_Array') 650 | { 651 | var list = _elm_lang$core$Array$toList(v); 652 | return 'Array.fromList ' + toString(list); 653 | } 654 | 655 | if (v.ctor === '') 656 | { 657 | return ''; 658 | } 659 | 660 | if (v.ctor === '_Process') 661 | { 662 | return ''; 663 | } 664 | 665 | if (v.ctor === '::') 666 | { 667 | var output = '[' + toString(v._0); 668 | v = v._1; 669 | while (v.ctor === '::') 670 | { 671 | output += ',' + toString(v._0); 672 | v = v._1; 673 | } 674 | return output + ']'; 675 | } 676 | 677 | if (v.ctor === '[]') 678 | { 679 | return '[]'; 680 | } 681 | 682 | if (v.ctor === 'Set_elm_builtin') 683 | { 684 | return 'Set.fromList ' + toString(_elm_lang$core$Set$toList(v)); 685 | } 686 | 687 | if (v.ctor === 'RBNode_elm_builtin' || v.ctor === 'RBEmpty_elm_builtin') 688 | { 689 | return 'Dict.fromList ' + toString(_elm_lang$core$Dict$toList(v)); 690 | } 691 | 692 | var output = ''; 693 | for (var i in v) 694 | { 695 | if (i === 'ctor') continue; 696 | var str = toString(v[i]); 697 | var c0 = str[0]; 698 | var parenless = c0 === '{' || c0 === '(' || c0 === '<' || c0 === '"' || str.indexOf(' ') < 0; 699 | output += ' ' + (parenless ? str : '(' + str + ')'); 700 | } 701 | return v.ctor + output; 702 | } 703 | 704 | if (type === 'object') 705 | { 706 | if (v instanceof Date) 707 | { 708 | return '<' + v.toString() + '>'; 709 | } 710 | 711 | if (v.elm_web_socket) 712 | { 713 | return ''; 714 | } 715 | 716 | var output = []; 717 | for (var k in v) 718 | { 719 | output.push(k + ' = ' + toString(v[k])); 720 | } 721 | if (output.length === 0) 722 | { 723 | return '{}'; 724 | } 725 | return '{ ' + output.join(', ') + ' }'; 726 | } 727 | 728 | return ''; 729 | } 730 | 731 | function addSlashes(str, isChar) 732 | { 733 | var s = str.replace(/\\/g, '\\\\') 734 | .replace(/\n/g, '\\n') 735 | .replace(/\t/g, '\\t') 736 | .replace(/\r/g, '\\r') 737 | .replace(/\v/g, '\\v') 738 | .replace(/\0/g, '\\0'); 739 | if (isChar) 740 | { 741 | return s.replace(/\'/g, '\\\''); 742 | } 743 | else 744 | { 745 | return s.replace(/\"/g, '\\"'); 746 | } 747 | } 748 | 749 | 750 | return { 751 | eq: eq, 752 | cmp: cmp, 753 | Tuple0: Tuple0, 754 | Tuple2: Tuple2, 755 | chr: chr, 756 | update: update, 757 | guid: guid, 758 | 759 | append: F2(append), 760 | 761 | crash: crash, 762 | crashCase: crashCase, 763 | 764 | toString: toString 765 | }; 766 | 767 | }(); 768 | var _elm_lang$core$Basics$never = function (_p0) { 769 | never: 770 | while (true) { 771 | var _p1 = _p0; 772 | var _v1 = _p1._0; 773 | _p0 = _v1; 774 | continue never; 775 | } 776 | }; 777 | var _elm_lang$core$Basics$uncurry = F2( 778 | function (f, _p2) { 779 | var _p3 = _p2; 780 | return A2(f, _p3._0, _p3._1); 781 | }); 782 | var _elm_lang$core$Basics$curry = F3( 783 | function (f, a, b) { 784 | return f( 785 | {ctor: '_Tuple2', _0: a, _1: b}); 786 | }); 787 | var _elm_lang$core$Basics$flip = F3( 788 | function (f, b, a) { 789 | return A2(f, a, b); 790 | }); 791 | var _elm_lang$core$Basics$always = F2( 792 | function (a, _p4) { 793 | return a; 794 | }); 795 | var _elm_lang$core$Basics$identity = function (x) { 796 | return x; 797 | }; 798 | var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {}; 799 | _elm_lang$core$Basics_ops['<|'] = F2( 800 | function (f, x) { 801 | return f(x); 802 | }); 803 | var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {}; 804 | _elm_lang$core$Basics_ops['|>'] = F2( 805 | function (x, f) { 806 | return f(x); 807 | }); 808 | var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {}; 809 | _elm_lang$core$Basics_ops['>>'] = F3( 810 | function (f, g, x) { 811 | return g( 812 | f(x)); 813 | }); 814 | var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {}; 815 | _elm_lang$core$Basics_ops['<<'] = F3( 816 | function (g, f, x) { 817 | return g( 818 | f(x)); 819 | }); 820 | var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {}; 821 | _elm_lang$core$Basics_ops['++'] = _elm_lang$core$Native_Utils.append; 822 | var _elm_lang$core$Basics$toString = _elm_lang$core$Native_Utils.toString; 823 | var _elm_lang$core$Basics$isInfinite = _elm_lang$core$Native_Basics.isInfinite; 824 | var _elm_lang$core$Basics$isNaN = _elm_lang$core$Native_Basics.isNaN; 825 | var _elm_lang$core$Basics$toFloat = _elm_lang$core$Native_Basics.toFloat; 826 | var _elm_lang$core$Basics$ceiling = _elm_lang$core$Native_Basics.ceiling; 827 | var _elm_lang$core$Basics$floor = _elm_lang$core$Native_Basics.floor; 828 | var _elm_lang$core$Basics$truncate = _elm_lang$core$Native_Basics.truncate; 829 | var _elm_lang$core$Basics$round = _elm_lang$core$Native_Basics.round; 830 | var _elm_lang$core$Basics$not = _elm_lang$core$Native_Basics.not; 831 | var _elm_lang$core$Basics$xor = _elm_lang$core$Native_Basics.xor; 832 | var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {}; 833 | _elm_lang$core$Basics_ops['||'] = _elm_lang$core$Native_Basics.or; 834 | var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {}; 835 | _elm_lang$core$Basics_ops['&&'] = _elm_lang$core$Native_Basics.and; 836 | var _elm_lang$core$Basics$max = _elm_lang$core$Native_Basics.max; 837 | var _elm_lang$core$Basics$min = _elm_lang$core$Native_Basics.min; 838 | var _elm_lang$core$Basics$compare = _elm_lang$core$Native_Basics.compare; 839 | var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {}; 840 | _elm_lang$core$Basics_ops['>='] = _elm_lang$core$Native_Basics.ge; 841 | var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {}; 842 | _elm_lang$core$Basics_ops['<='] = _elm_lang$core$Native_Basics.le; 843 | var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {}; 844 | _elm_lang$core$Basics_ops['>'] = _elm_lang$core$Native_Basics.gt; 845 | var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {}; 846 | _elm_lang$core$Basics_ops['<'] = _elm_lang$core$Native_Basics.lt; 847 | var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {}; 848 | _elm_lang$core$Basics_ops['/='] = _elm_lang$core$Native_Basics.neq; 849 | var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {}; 850 | _elm_lang$core$Basics_ops['=='] = _elm_lang$core$Native_Basics.eq; 851 | var _elm_lang$core$Basics$e = _elm_lang$core$Native_Basics.e; 852 | var _elm_lang$core$Basics$pi = _elm_lang$core$Native_Basics.pi; 853 | var _elm_lang$core$Basics$clamp = _elm_lang$core$Native_Basics.clamp; 854 | var _elm_lang$core$Basics$logBase = _elm_lang$core$Native_Basics.logBase; 855 | var _elm_lang$core$Basics$abs = _elm_lang$core$Native_Basics.abs; 856 | var _elm_lang$core$Basics$negate = _elm_lang$core$Native_Basics.negate; 857 | var _elm_lang$core$Basics$sqrt = _elm_lang$core$Native_Basics.sqrt; 858 | var _elm_lang$core$Basics$atan2 = _elm_lang$core$Native_Basics.atan2; 859 | var _elm_lang$core$Basics$atan = _elm_lang$core$Native_Basics.atan; 860 | var _elm_lang$core$Basics$asin = _elm_lang$core$Native_Basics.asin; 861 | var _elm_lang$core$Basics$acos = _elm_lang$core$Native_Basics.acos; 862 | var _elm_lang$core$Basics$tan = _elm_lang$core$Native_Basics.tan; 863 | var _elm_lang$core$Basics$sin = _elm_lang$core$Native_Basics.sin; 864 | var _elm_lang$core$Basics$cos = _elm_lang$core$Native_Basics.cos; 865 | var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {}; 866 | _elm_lang$core$Basics_ops['^'] = _elm_lang$core$Native_Basics.exp; 867 | var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {}; 868 | _elm_lang$core$Basics_ops['%'] = _elm_lang$core$Native_Basics.mod; 869 | var _elm_lang$core$Basics$rem = _elm_lang$core$Native_Basics.rem; 870 | var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {}; 871 | _elm_lang$core$Basics_ops['//'] = _elm_lang$core$Native_Basics.div; 872 | var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {}; 873 | _elm_lang$core$Basics_ops['/'] = _elm_lang$core$Native_Basics.floatDiv; 874 | var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {}; 875 | _elm_lang$core$Basics_ops['*'] = _elm_lang$core$Native_Basics.mul; 876 | var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {}; 877 | _elm_lang$core$Basics_ops['-'] = _elm_lang$core$Native_Basics.sub; 878 | var _elm_lang$core$Basics_ops = _elm_lang$core$Basics_ops || {}; 879 | _elm_lang$core$Basics_ops['+'] = _elm_lang$core$Native_Basics.add; 880 | var _elm_lang$core$Basics$toPolar = _elm_lang$core$Native_Basics.toPolar; 881 | var _elm_lang$core$Basics$fromPolar = _elm_lang$core$Native_Basics.fromPolar; 882 | var _elm_lang$core$Basics$turns = _elm_lang$core$Native_Basics.turns; 883 | var _elm_lang$core$Basics$degrees = _elm_lang$core$Native_Basics.degrees; 884 | var _elm_lang$core$Basics$radians = function (t) { 885 | return t; 886 | }; 887 | var _elm_lang$core$Basics$GT = {ctor: 'GT'}; 888 | var _elm_lang$core$Basics$EQ = {ctor: 'EQ'}; 889 | var _elm_lang$core$Basics$LT = {ctor: 'LT'}; 890 | var _elm_lang$core$Basics$JustOneMore = function (a) { 891 | return {ctor: 'JustOneMore', _0: a}; 892 | }; 893 | 894 | var _elm_lang$core$Maybe$withDefault = F2( 895 | function ($default, maybe) { 896 | var _p0 = maybe; 897 | if (_p0.ctor === 'Just') { 898 | return _p0._0; 899 | } else { 900 | return $default; 901 | } 902 | }); 903 | var _elm_lang$core$Maybe$Nothing = {ctor: 'Nothing'}; 904 | var _elm_lang$core$Maybe$andThen = F2( 905 | function (callback, maybeValue) { 906 | var _p1 = maybeValue; 907 | if (_p1.ctor === 'Just') { 908 | return callback(_p1._0); 909 | } else { 910 | return _elm_lang$core$Maybe$Nothing; 911 | } 912 | }); 913 | var _elm_lang$core$Maybe$Just = function (a) { 914 | return {ctor: 'Just', _0: a}; 915 | }; 916 | var _elm_lang$core$Maybe$map = F2( 917 | function (f, maybe) { 918 | var _p2 = maybe; 919 | if (_p2.ctor === 'Just') { 920 | return _elm_lang$core$Maybe$Just( 921 | f(_p2._0)); 922 | } else { 923 | return _elm_lang$core$Maybe$Nothing; 924 | } 925 | }); 926 | var _elm_lang$core$Maybe$map2 = F3( 927 | function (func, ma, mb) { 928 | var _p3 = {ctor: '_Tuple2', _0: ma, _1: mb}; 929 | if (((_p3.ctor === '_Tuple2') && (_p3._0.ctor === 'Just')) && (_p3._1.ctor === 'Just')) { 930 | return _elm_lang$core$Maybe$Just( 931 | A2(func, _p3._0._0, _p3._1._0)); 932 | } else { 933 | return _elm_lang$core$Maybe$Nothing; 934 | } 935 | }); 936 | var _elm_lang$core$Maybe$map3 = F4( 937 | function (func, ma, mb, mc) { 938 | var _p4 = {ctor: '_Tuple3', _0: ma, _1: mb, _2: mc}; 939 | if ((((_p4.ctor === '_Tuple3') && (_p4._0.ctor === 'Just')) && (_p4._1.ctor === 'Just')) && (_p4._2.ctor === 'Just')) { 940 | return _elm_lang$core$Maybe$Just( 941 | A3(func, _p4._0._0, _p4._1._0, _p4._2._0)); 942 | } else { 943 | return _elm_lang$core$Maybe$Nothing; 944 | } 945 | }); 946 | var _elm_lang$core$Maybe$map4 = F5( 947 | function (func, ma, mb, mc, md) { 948 | var _p5 = {ctor: '_Tuple4', _0: ma, _1: mb, _2: mc, _3: md}; 949 | if (((((_p5.ctor === '_Tuple4') && (_p5._0.ctor === 'Just')) && (_p5._1.ctor === 'Just')) && (_p5._2.ctor === 'Just')) && (_p5._3.ctor === 'Just')) { 950 | return _elm_lang$core$Maybe$Just( 951 | A4(func, _p5._0._0, _p5._1._0, _p5._2._0, _p5._3._0)); 952 | } else { 953 | return _elm_lang$core$Maybe$Nothing; 954 | } 955 | }); 956 | var _elm_lang$core$Maybe$map5 = F6( 957 | function (func, ma, mb, mc, md, me) { 958 | var _p6 = {ctor: '_Tuple5', _0: ma, _1: mb, _2: mc, _3: md, _4: me}; 959 | if ((((((_p6.ctor === '_Tuple5') && (_p6._0.ctor === 'Just')) && (_p6._1.ctor === 'Just')) && (_p6._2.ctor === 'Just')) && (_p6._3.ctor === 'Just')) && (_p6._4.ctor === 'Just')) { 960 | return _elm_lang$core$Maybe$Just( 961 | A5(func, _p6._0._0, _p6._1._0, _p6._2._0, _p6._3._0, _p6._4._0)); 962 | } else { 963 | return _elm_lang$core$Maybe$Nothing; 964 | } 965 | }); 966 | 967 | //import Native.Utils // 968 | 969 | var _elm_lang$core$Native_List = function() { 970 | 971 | var Nil = { ctor: '[]' }; 972 | 973 | function Cons(hd, tl) 974 | { 975 | return { ctor: '::', _0: hd, _1: tl }; 976 | } 977 | 978 | function fromArray(arr) 979 | { 980 | var out = Nil; 981 | for (var i = arr.length; i--; ) 982 | { 983 | out = Cons(arr[i], out); 984 | } 985 | return out; 986 | } 987 | 988 | function toArray(xs) 989 | { 990 | var out = []; 991 | while (xs.ctor !== '[]') 992 | { 993 | out.push(xs._0); 994 | xs = xs._1; 995 | } 996 | return out; 997 | } 998 | 999 | function foldr(f, b, xs) 1000 | { 1001 | var arr = toArray(xs); 1002 | var acc = b; 1003 | for (var i = arr.length; i--; ) 1004 | { 1005 | acc = A2(f, arr[i], acc); 1006 | } 1007 | return acc; 1008 | } 1009 | 1010 | function map2(f, xs, ys) 1011 | { 1012 | var arr = []; 1013 | while (xs.ctor !== '[]' && ys.ctor !== '[]') 1014 | { 1015 | arr.push(A2(f, xs._0, ys._0)); 1016 | xs = xs._1; 1017 | ys = ys._1; 1018 | } 1019 | return fromArray(arr); 1020 | } 1021 | 1022 | function map3(f, xs, ys, zs) 1023 | { 1024 | var arr = []; 1025 | while (xs.ctor !== '[]' && ys.ctor !== '[]' && zs.ctor !== '[]') 1026 | { 1027 | arr.push(A3(f, xs._0, ys._0, zs._0)); 1028 | xs = xs._1; 1029 | ys = ys._1; 1030 | zs = zs._1; 1031 | } 1032 | return fromArray(arr); 1033 | } 1034 | 1035 | function map4(f, ws, xs, ys, zs) 1036 | { 1037 | var arr = []; 1038 | while ( ws.ctor !== '[]' 1039 | && xs.ctor !== '[]' 1040 | && ys.ctor !== '[]' 1041 | && zs.ctor !== '[]') 1042 | { 1043 | arr.push(A4(f, ws._0, xs._0, ys._0, zs._0)); 1044 | ws = ws._1; 1045 | xs = xs._1; 1046 | ys = ys._1; 1047 | zs = zs._1; 1048 | } 1049 | return fromArray(arr); 1050 | } 1051 | 1052 | function map5(f, vs, ws, xs, ys, zs) 1053 | { 1054 | var arr = []; 1055 | while ( vs.ctor !== '[]' 1056 | && ws.ctor !== '[]' 1057 | && xs.ctor !== '[]' 1058 | && ys.ctor !== '[]' 1059 | && zs.ctor !== '[]') 1060 | { 1061 | arr.push(A5(f, vs._0, ws._0, xs._0, ys._0, zs._0)); 1062 | vs = vs._1; 1063 | ws = ws._1; 1064 | xs = xs._1; 1065 | ys = ys._1; 1066 | zs = zs._1; 1067 | } 1068 | return fromArray(arr); 1069 | } 1070 | 1071 | function sortBy(f, xs) 1072 | { 1073 | return fromArray(toArray(xs).sort(function(a, b) { 1074 | return _elm_lang$core$Native_Utils.cmp(f(a), f(b)); 1075 | })); 1076 | } 1077 | 1078 | function sortWith(f, xs) 1079 | { 1080 | return fromArray(toArray(xs).sort(function(a, b) { 1081 | var ord = f(a)(b).ctor; 1082 | return ord === 'EQ' ? 0 : ord === 'LT' ? -1 : 1; 1083 | })); 1084 | } 1085 | 1086 | return { 1087 | Nil: Nil, 1088 | Cons: Cons, 1089 | cons: F2(Cons), 1090 | toArray: toArray, 1091 | fromArray: fromArray, 1092 | 1093 | foldr: F3(foldr), 1094 | 1095 | map2: F3(map2), 1096 | map3: F4(map3), 1097 | map4: F5(map4), 1098 | map5: F6(map5), 1099 | sortBy: F2(sortBy), 1100 | sortWith: F2(sortWith) 1101 | }; 1102 | 1103 | }(); 1104 | var _elm_lang$core$List$sortWith = _elm_lang$core$Native_List.sortWith; 1105 | var _elm_lang$core$List$sortBy = _elm_lang$core$Native_List.sortBy; 1106 | var _elm_lang$core$List$sort = function (xs) { 1107 | return A2(_elm_lang$core$List$sortBy, _elm_lang$core$Basics$identity, xs); 1108 | }; 1109 | var _elm_lang$core$List$drop = F2( 1110 | function (n, list) { 1111 | drop: 1112 | while (true) { 1113 | if (_elm_lang$core$Native_Utils.cmp(n, 0) < 1) { 1114 | return list; 1115 | } else { 1116 | var _p0 = list; 1117 | if (_p0.ctor === '[]') { 1118 | return list; 1119 | } else { 1120 | var _v1 = n - 1, 1121 | _v2 = _p0._1; 1122 | n = _v1; 1123 | list = _v2; 1124 | continue drop; 1125 | } 1126 | } 1127 | } 1128 | }); 1129 | var _elm_lang$core$List$map5 = _elm_lang$core$Native_List.map5; 1130 | var _elm_lang$core$List$map4 = _elm_lang$core$Native_List.map4; 1131 | var _elm_lang$core$List$map3 = _elm_lang$core$Native_List.map3; 1132 | var _elm_lang$core$List$map2 = _elm_lang$core$Native_List.map2; 1133 | var _elm_lang$core$List$any = F2( 1134 | function (isOkay, list) { 1135 | any: 1136 | while (true) { 1137 | var _p1 = list; 1138 | if (_p1.ctor === '[]') { 1139 | return false; 1140 | } else { 1141 | if (isOkay(_p1._0)) { 1142 | return true; 1143 | } else { 1144 | var _v4 = isOkay, 1145 | _v5 = _p1._1; 1146 | isOkay = _v4; 1147 | list = _v5; 1148 | continue any; 1149 | } 1150 | } 1151 | } 1152 | }); 1153 | var _elm_lang$core$List$all = F2( 1154 | function (isOkay, list) { 1155 | return !A2( 1156 | _elm_lang$core$List$any, 1157 | function (_p2) { 1158 | return !isOkay(_p2); 1159 | }, 1160 | list); 1161 | }); 1162 | var _elm_lang$core$List$foldr = _elm_lang$core$Native_List.foldr; 1163 | var _elm_lang$core$List$foldl = F3( 1164 | function (func, acc, list) { 1165 | foldl: 1166 | while (true) { 1167 | var _p3 = list; 1168 | if (_p3.ctor === '[]') { 1169 | return acc; 1170 | } else { 1171 | var _v7 = func, 1172 | _v8 = A2(func, _p3._0, acc), 1173 | _v9 = _p3._1; 1174 | func = _v7; 1175 | acc = _v8; 1176 | list = _v9; 1177 | continue foldl; 1178 | } 1179 | } 1180 | }); 1181 | var _elm_lang$core$List$length = function (xs) { 1182 | return A3( 1183 | _elm_lang$core$List$foldl, 1184 | F2( 1185 | function (_p4, i) { 1186 | return i + 1; 1187 | }), 1188 | 0, 1189 | xs); 1190 | }; 1191 | var _elm_lang$core$List$sum = function (numbers) { 1192 | return A3( 1193 | _elm_lang$core$List$foldl, 1194 | F2( 1195 | function (x, y) { 1196 | return x + y; 1197 | }), 1198 | 0, 1199 | numbers); 1200 | }; 1201 | var _elm_lang$core$List$product = function (numbers) { 1202 | return A3( 1203 | _elm_lang$core$List$foldl, 1204 | F2( 1205 | function (x, y) { 1206 | return x * y; 1207 | }), 1208 | 1, 1209 | numbers); 1210 | }; 1211 | var _elm_lang$core$List$maximum = function (list) { 1212 | var _p5 = list; 1213 | if (_p5.ctor === '::') { 1214 | return _elm_lang$core$Maybe$Just( 1215 | A3(_elm_lang$core$List$foldl, _elm_lang$core$Basics$max, _p5._0, _p5._1)); 1216 | } else { 1217 | return _elm_lang$core$Maybe$Nothing; 1218 | } 1219 | }; 1220 | var _elm_lang$core$List$minimum = function (list) { 1221 | var _p6 = list; 1222 | if (_p6.ctor === '::') { 1223 | return _elm_lang$core$Maybe$Just( 1224 | A3(_elm_lang$core$List$foldl, _elm_lang$core$Basics$min, _p6._0, _p6._1)); 1225 | } else { 1226 | return _elm_lang$core$Maybe$Nothing; 1227 | } 1228 | }; 1229 | var _elm_lang$core$List$member = F2( 1230 | function (x, xs) { 1231 | return A2( 1232 | _elm_lang$core$List$any, 1233 | function (a) { 1234 | return _elm_lang$core$Native_Utils.eq(a, x); 1235 | }, 1236 | xs); 1237 | }); 1238 | var _elm_lang$core$List$isEmpty = function (xs) { 1239 | var _p7 = xs; 1240 | if (_p7.ctor === '[]') { 1241 | return true; 1242 | } else { 1243 | return false; 1244 | } 1245 | }; 1246 | var _elm_lang$core$List$tail = function (list) { 1247 | var _p8 = list; 1248 | if (_p8.ctor === '::') { 1249 | return _elm_lang$core$Maybe$Just(_p8._1); 1250 | } else { 1251 | return _elm_lang$core$Maybe$Nothing; 1252 | } 1253 | }; 1254 | var _elm_lang$core$List$head = function (list) { 1255 | var _p9 = list; 1256 | if (_p9.ctor === '::') { 1257 | return _elm_lang$core$Maybe$Just(_p9._0); 1258 | } else { 1259 | return _elm_lang$core$Maybe$Nothing; 1260 | } 1261 | }; 1262 | var _elm_lang$core$List_ops = _elm_lang$core$List_ops || {}; 1263 | _elm_lang$core$List_ops['::'] = _elm_lang$core$Native_List.cons; 1264 | var _elm_lang$core$List$map = F2( 1265 | function (f, xs) { 1266 | return A3( 1267 | _elm_lang$core$List$foldr, 1268 | F2( 1269 | function (x, acc) { 1270 | return { 1271 | ctor: '::', 1272 | _0: f(x), 1273 | _1: acc 1274 | }; 1275 | }), 1276 | {ctor: '[]'}, 1277 | xs); 1278 | }); 1279 | var _elm_lang$core$List$filter = F2( 1280 | function (pred, xs) { 1281 | var conditionalCons = F2( 1282 | function (front, back) { 1283 | return pred(front) ? {ctor: '::', _0: front, _1: back} : back; 1284 | }); 1285 | return A3( 1286 | _elm_lang$core$List$foldr, 1287 | conditionalCons, 1288 | {ctor: '[]'}, 1289 | xs); 1290 | }); 1291 | var _elm_lang$core$List$maybeCons = F3( 1292 | function (f, mx, xs) { 1293 | var _p10 = f(mx); 1294 | if (_p10.ctor === 'Just') { 1295 | return {ctor: '::', _0: _p10._0, _1: xs}; 1296 | } else { 1297 | return xs; 1298 | } 1299 | }); 1300 | var _elm_lang$core$List$filterMap = F2( 1301 | function (f, xs) { 1302 | return A3( 1303 | _elm_lang$core$List$foldr, 1304 | _elm_lang$core$List$maybeCons(f), 1305 | {ctor: '[]'}, 1306 | xs); 1307 | }); 1308 | var _elm_lang$core$List$reverse = function (list) { 1309 | return A3( 1310 | _elm_lang$core$List$foldl, 1311 | F2( 1312 | function (x, y) { 1313 | return {ctor: '::', _0: x, _1: y}; 1314 | }), 1315 | {ctor: '[]'}, 1316 | list); 1317 | }; 1318 | var _elm_lang$core$List$scanl = F3( 1319 | function (f, b, xs) { 1320 | var scan1 = F2( 1321 | function (x, accAcc) { 1322 | var _p11 = accAcc; 1323 | if (_p11.ctor === '::') { 1324 | return { 1325 | ctor: '::', 1326 | _0: A2(f, x, _p11._0), 1327 | _1: accAcc 1328 | }; 1329 | } else { 1330 | return {ctor: '[]'}; 1331 | } 1332 | }); 1333 | return _elm_lang$core$List$reverse( 1334 | A3( 1335 | _elm_lang$core$List$foldl, 1336 | scan1, 1337 | { 1338 | ctor: '::', 1339 | _0: b, 1340 | _1: {ctor: '[]'} 1341 | }, 1342 | xs)); 1343 | }); 1344 | var _elm_lang$core$List$append = F2( 1345 | function (xs, ys) { 1346 | var _p12 = ys; 1347 | if (_p12.ctor === '[]') { 1348 | return xs; 1349 | } else { 1350 | return A3( 1351 | _elm_lang$core$List$foldr, 1352 | F2( 1353 | function (x, y) { 1354 | return {ctor: '::', _0: x, _1: y}; 1355 | }), 1356 | ys, 1357 | xs); 1358 | } 1359 | }); 1360 | var _elm_lang$core$List$concat = function (lists) { 1361 | return A3( 1362 | _elm_lang$core$List$foldr, 1363 | _elm_lang$core$List$append, 1364 | {ctor: '[]'}, 1365 | lists); 1366 | }; 1367 | var _elm_lang$core$List$concatMap = F2( 1368 | function (f, list) { 1369 | return _elm_lang$core$List$concat( 1370 | A2(_elm_lang$core$List$map, f, list)); 1371 | }); 1372 | var _elm_lang$core$List$partition = F2( 1373 | function (pred, list) { 1374 | var step = F2( 1375 | function (x, _p13) { 1376 | var _p14 = _p13; 1377 | var _p16 = _p14._0; 1378 | var _p15 = _p14._1; 1379 | return pred(x) ? { 1380 | ctor: '_Tuple2', 1381 | _0: {ctor: '::', _0: x, _1: _p16}, 1382 | _1: _p15 1383 | } : { 1384 | ctor: '_Tuple2', 1385 | _0: _p16, 1386 | _1: {ctor: '::', _0: x, _1: _p15} 1387 | }; 1388 | }); 1389 | return A3( 1390 | _elm_lang$core$List$foldr, 1391 | step, 1392 | { 1393 | ctor: '_Tuple2', 1394 | _0: {ctor: '[]'}, 1395 | _1: {ctor: '[]'} 1396 | }, 1397 | list); 1398 | }); 1399 | var _elm_lang$core$List$unzip = function (pairs) { 1400 | var step = F2( 1401 | function (_p18, _p17) { 1402 | var _p19 = _p18; 1403 | var _p20 = _p17; 1404 | return { 1405 | ctor: '_Tuple2', 1406 | _0: {ctor: '::', _0: _p19._0, _1: _p20._0}, 1407 | _1: {ctor: '::', _0: _p19._1, _1: _p20._1} 1408 | }; 1409 | }); 1410 | return A3( 1411 | _elm_lang$core$List$foldr, 1412 | step, 1413 | { 1414 | ctor: '_Tuple2', 1415 | _0: {ctor: '[]'}, 1416 | _1: {ctor: '[]'} 1417 | }, 1418 | pairs); 1419 | }; 1420 | var _elm_lang$core$List$intersperse = F2( 1421 | function (sep, xs) { 1422 | var _p21 = xs; 1423 | if (_p21.ctor === '[]') { 1424 | return {ctor: '[]'}; 1425 | } else { 1426 | var step = F2( 1427 | function (x, rest) { 1428 | return { 1429 | ctor: '::', 1430 | _0: sep, 1431 | _1: {ctor: '::', _0: x, _1: rest} 1432 | }; 1433 | }); 1434 | var spersed = A3( 1435 | _elm_lang$core$List$foldr, 1436 | step, 1437 | {ctor: '[]'}, 1438 | _p21._1); 1439 | return {ctor: '::', _0: _p21._0, _1: spersed}; 1440 | } 1441 | }); 1442 | var _elm_lang$core$List$takeReverse = F3( 1443 | function (n, list, taken) { 1444 | takeReverse: 1445 | while (true) { 1446 | if (_elm_lang$core$Native_Utils.cmp(n, 0) < 1) { 1447 | return taken; 1448 | } else { 1449 | var _p22 = list; 1450 | if (_p22.ctor === '[]') { 1451 | return taken; 1452 | } else { 1453 | var _v23 = n - 1, 1454 | _v24 = _p22._1, 1455 | _v25 = {ctor: '::', _0: _p22._0, _1: taken}; 1456 | n = _v23; 1457 | list = _v24; 1458 | taken = _v25; 1459 | continue takeReverse; 1460 | } 1461 | } 1462 | } 1463 | }); 1464 | var _elm_lang$core$List$takeTailRec = F2( 1465 | function (n, list) { 1466 | return _elm_lang$core$List$reverse( 1467 | A3( 1468 | _elm_lang$core$List$takeReverse, 1469 | n, 1470 | list, 1471 | {ctor: '[]'})); 1472 | }); 1473 | var _elm_lang$core$List$takeFast = F3( 1474 | function (ctr, n, list) { 1475 | if (_elm_lang$core$Native_Utils.cmp(n, 0) < 1) { 1476 | return {ctor: '[]'}; 1477 | } else { 1478 | var _p23 = {ctor: '_Tuple2', _0: n, _1: list}; 1479 | _v26_5: 1480 | do { 1481 | _v26_1: 1482 | do { 1483 | if (_p23.ctor === '_Tuple2') { 1484 | if (_p23._1.ctor === '[]') { 1485 | return list; 1486 | } else { 1487 | if (_p23._1._1.ctor === '::') { 1488 | switch (_p23._0) { 1489 | case 1: 1490 | break _v26_1; 1491 | case 2: 1492 | return { 1493 | ctor: '::', 1494 | _0: _p23._1._0, 1495 | _1: { 1496 | ctor: '::', 1497 | _0: _p23._1._1._0, 1498 | _1: {ctor: '[]'} 1499 | } 1500 | }; 1501 | case 3: 1502 | if (_p23._1._1._1.ctor === '::') { 1503 | return { 1504 | ctor: '::', 1505 | _0: _p23._1._0, 1506 | _1: { 1507 | ctor: '::', 1508 | _0: _p23._1._1._0, 1509 | _1: { 1510 | ctor: '::', 1511 | _0: _p23._1._1._1._0, 1512 | _1: {ctor: '[]'} 1513 | } 1514 | } 1515 | }; 1516 | } else { 1517 | break _v26_5; 1518 | } 1519 | default: 1520 | if ((_p23._1._1._1.ctor === '::') && (_p23._1._1._1._1.ctor === '::')) { 1521 | var _p28 = _p23._1._1._1._0; 1522 | var _p27 = _p23._1._1._0; 1523 | var _p26 = _p23._1._0; 1524 | var _p25 = _p23._1._1._1._1._0; 1525 | var _p24 = _p23._1._1._1._1._1; 1526 | return (_elm_lang$core$Native_Utils.cmp(ctr, 1000) > 0) ? { 1527 | ctor: '::', 1528 | _0: _p26, 1529 | _1: { 1530 | ctor: '::', 1531 | _0: _p27, 1532 | _1: { 1533 | ctor: '::', 1534 | _0: _p28, 1535 | _1: { 1536 | ctor: '::', 1537 | _0: _p25, 1538 | _1: A2(_elm_lang$core$List$takeTailRec, n - 4, _p24) 1539 | } 1540 | } 1541 | } 1542 | } : { 1543 | ctor: '::', 1544 | _0: _p26, 1545 | _1: { 1546 | ctor: '::', 1547 | _0: _p27, 1548 | _1: { 1549 | ctor: '::', 1550 | _0: _p28, 1551 | _1: { 1552 | ctor: '::', 1553 | _0: _p25, 1554 | _1: A3(_elm_lang$core$List$takeFast, ctr + 1, n - 4, _p24) 1555 | } 1556 | } 1557 | } 1558 | }; 1559 | } else { 1560 | break _v26_5; 1561 | } 1562 | } 1563 | } else { 1564 | if (_p23._0 === 1) { 1565 | break _v26_1; 1566 | } else { 1567 | break _v26_5; 1568 | } 1569 | } 1570 | } 1571 | } else { 1572 | break _v26_5; 1573 | } 1574 | } while(false); 1575 | return { 1576 | ctor: '::', 1577 | _0: _p23._1._0, 1578 | _1: {ctor: '[]'} 1579 | }; 1580 | } while(false); 1581 | return list; 1582 | } 1583 | }); 1584 | var _elm_lang$core$List$take = F2( 1585 | function (n, list) { 1586 | return A3(_elm_lang$core$List$takeFast, 0, n, list); 1587 | }); 1588 | var _elm_lang$core$List$repeatHelp = F3( 1589 | function (result, n, value) { 1590 | repeatHelp: 1591 | while (true) { 1592 | if (_elm_lang$core$Native_Utils.cmp(n, 0) < 1) { 1593 | return result; 1594 | } else { 1595 | var _v27 = {ctor: '::', _0: value, _1: result}, 1596 | _v28 = n - 1, 1597 | _v29 = value; 1598 | result = _v27; 1599 | n = _v28; 1600 | value = _v29; 1601 | continue repeatHelp; 1602 | } 1603 | } 1604 | }); 1605 | var _elm_lang$core$List$repeat = F2( 1606 | function (n, value) { 1607 | return A3( 1608 | _elm_lang$core$List$repeatHelp, 1609 | {ctor: '[]'}, 1610 | n, 1611 | value); 1612 | }); 1613 | var _elm_lang$core$List$rangeHelp = F3( 1614 | function (lo, hi, list) { 1615 | rangeHelp: 1616 | while (true) { 1617 | if (_elm_lang$core$Native_Utils.cmp(lo, hi) < 1) { 1618 | var _v30 = lo, 1619 | _v31 = hi - 1, 1620 | _v32 = {ctor: '::', _0: hi, _1: list}; 1621 | lo = _v30; 1622 | hi = _v31; 1623 | list = _v32; 1624 | continue rangeHelp; 1625 | } else { 1626 | return list; 1627 | } 1628 | } 1629 | }); 1630 | var _elm_lang$core$List$range = F2( 1631 | function (lo, hi) { 1632 | return A3( 1633 | _elm_lang$core$List$rangeHelp, 1634 | lo, 1635 | hi, 1636 | {ctor: '[]'}); 1637 | }); 1638 | var _elm_lang$core$List$indexedMap = F2( 1639 | function (f, xs) { 1640 | return A3( 1641 | _elm_lang$core$List$map2, 1642 | f, 1643 | A2( 1644 | _elm_lang$core$List$range, 1645 | 0, 1646 | _elm_lang$core$List$length(xs) - 1), 1647 | xs); 1648 | }); 1649 | 1650 | //import Native.Utils // 1651 | 1652 | var _elm_lang$core$Native_Char = function() { 1653 | 1654 | return { 1655 | fromCode: function(c) { return _elm_lang$core$Native_Utils.chr(String.fromCharCode(c)); }, 1656 | toCode: function(c) { return c.charCodeAt(0); }, 1657 | toUpper: function(c) { return _elm_lang$core$Native_Utils.chr(c.toUpperCase()); }, 1658 | toLower: function(c) { return _elm_lang$core$Native_Utils.chr(c.toLowerCase()); }, 1659 | toLocaleUpper: function(c) { return _elm_lang$core$Native_Utils.chr(c.toLocaleUpperCase()); }, 1660 | toLocaleLower: function(c) { return _elm_lang$core$Native_Utils.chr(c.toLocaleLowerCase()); } 1661 | }; 1662 | 1663 | }(); 1664 | var _elm_lang$core$Char$fromCode = _elm_lang$core$Native_Char.fromCode; 1665 | var _elm_lang$core$Char$toCode = _elm_lang$core$Native_Char.toCode; 1666 | var _elm_lang$core$Char$toLocaleLower = _elm_lang$core$Native_Char.toLocaleLower; 1667 | var _elm_lang$core$Char$toLocaleUpper = _elm_lang$core$Native_Char.toLocaleUpper; 1668 | var _elm_lang$core$Char$toLower = _elm_lang$core$Native_Char.toLower; 1669 | var _elm_lang$core$Char$toUpper = _elm_lang$core$Native_Char.toUpper; 1670 | var _elm_lang$core$Char$isBetween = F3( 1671 | function (low, high, $char) { 1672 | var code = _elm_lang$core$Char$toCode($char); 1673 | return (_elm_lang$core$Native_Utils.cmp( 1674 | code, 1675 | _elm_lang$core$Char$toCode(low)) > -1) && (_elm_lang$core$Native_Utils.cmp( 1676 | code, 1677 | _elm_lang$core$Char$toCode(high)) < 1); 1678 | }); 1679 | var _elm_lang$core$Char$isUpper = A2( 1680 | _elm_lang$core$Char$isBetween, 1681 | _elm_lang$core$Native_Utils.chr('A'), 1682 | _elm_lang$core$Native_Utils.chr('Z')); 1683 | var _elm_lang$core$Char$isLower = A2( 1684 | _elm_lang$core$Char$isBetween, 1685 | _elm_lang$core$Native_Utils.chr('a'), 1686 | _elm_lang$core$Native_Utils.chr('z')); 1687 | var _elm_lang$core$Char$isDigit = A2( 1688 | _elm_lang$core$Char$isBetween, 1689 | _elm_lang$core$Native_Utils.chr('0'), 1690 | _elm_lang$core$Native_Utils.chr('9')); 1691 | var _elm_lang$core$Char$isOctDigit = A2( 1692 | _elm_lang$core$Char$isBetween, 1693 | _elm_lang$core$Native_Utils.chr('0'), 1694 | _elm_lang$core$Native_Utils.chr('7')); 1695 | var _elm_lang$core$Char$isHexDigit = function ($char) { 1696 | return _elm_lang$core$Char$isDigit($char) || (A3( 1697 | _elm_lang$core$Char$isBetween, 1698 | _elm_lang$core$Native_Utils.chr('a'), 1699 | _elm_lang$core$Native_Utils.chr('f'), 1700 | $char) || A3( 1701 | _elm_lang$core$Char$isBetween, 1702 | _elm_lang$core$Native_Utils.chr('A'), 1703 | _elm_lang$core$Native_Utils.chr('F'), 1704 | $char)); 1705 | }; 1706 | 1707 | //import Native.Utils // 1708 | 1709 | var _elm_lang$core$Native_Scheduler = function() { 1710 | 1711 | var MAX_STEPS = 10000; 1712 | 1713 | 1714 | // TASKS 1715 | 1716 | function succeed(value) 1717 | { 1718 | return { 1719 | ctor: '_Task_succeed', 1720 | value: value 1721 | }; 1722 | } 1723 | 1724 | function fail(error) 1725 | { 1726 | return { 1727 | ctor: '_Task_fail', 1728 | value: error 1729 | }; 1730 | } 1731 | 1732 | function nativeBinding(callback) 1733 | { 1734 | return { 1735 | ctor: '_Task_nativeBinding', 1736 | callback: callback, 1737 | cancel: null 1738 | }; 1739 | } 1740 | 1741 | function andThen(callback, task) 1742 | { 1743 | return { 1744 | ctor: '_Task_andThen', 1745 | callback: callback, 1746 | task: task 1747 | }; 1748 | } 1749 | 1750 | function onError(callback, task) 1751 | { 1752 | return { 1753 | ctor: '_Task_onError', 1754 | callback: callback, 1755 | task: task 1756 | }; 1757 | } 1758 | 1759 | function receive(callback) 1760 | { 1761 | return { 1762 | ctor: '_Task_receive', 1763 | callback: callback 1764 | }; 1765 | } 1766 | 1767 | 1768 | // PROCESSES 1769 | 1770 | function rawSpawn(task) 1771 | { 1772 | var process = { 1773 | ctor: '_Process', 1774 | id: _elm_lang$core$Native_Utils.guid(), 1775 | root: task, 1776 | stack: null, 1777 | mailbox: [] 1778 | }; 1779 | 1780 | enqueue(process); 1781 | 1782 | return process; 1783 | } 1784 | 1785 | function spawn(task) 1786 | { 1787 | return nativeBinding(function(callback) { 1788 | var process = rawSpawn(task); 1789 | callback(succeed(process)); 1790 | }); 1791 | } 1792 | 1793 | function rawSend(process, msg) 1794 | { 1795 | process.mailbox.push(msg); 1796 | enqueue(process); 1797 | } 1798 | 1799 | function send(process, msg) 1800 | { 1801 | return nativeBinding(function(callback) { 1802 | rawSend(process, msg); 1803 | callback(succeed(_elm_lang$core$Native_Utils.Tuple0)); 1804 | }); 1805 | } 1806 | 1807 | function kill(process) 1808 | { 1809 | return nativeBinding(function(callback) { 1810 | var root = process.root; 1811 | if (root.ctor === '_Task_nativeBinding' && root.cancel) 1812 | { 1813 | root.cancel(); 1814 | } 1815 | 1816 | process.root = null; 1817 | 1818 | callback(succeed(_elm_lang$core$Native_Utils.Tuple0)); 1819 | }); 1820 | } 1821 | 1822 | function sleep(time) 1823 | { 1824 | return nativeBinding(function(callback) { 1825 | var id = setTimeout(function() { 1826 | callback(succeed(_elm_lang$core$Native_Utils.Tuple0)); 1827 | }, time); 1828 | 1829 | return function() { clearTimeout(id); }; 1830 | }); 1831 | } 1832 | 1833 | 1834 | // STEP PROCESSES 1835 | 1836 | function step(numSteps, process) 1837 | { 1838 | while (numSteps < MAX_STEPS) 1839 | { 1840 | var ctor = process.root.ctor; 1841 | 1842 | if (ctor === '_Task_succeed') 1843 | { 1844 | while (process.stack && process.stack.ctor === '_Task_onError') 1845 | { 1846 | process.stack = process.stack.rest; 1847 | } 1848 | if (process.stack === null) 1849 | { 1850 | break; 1851 | } 1852 | process.root = process.stack.callback(process.root.value); 1853 | process.stack = process.stack.rest; 1854 | ++numSteps; 1855 | continue; 1856 | } 1857 | 1858 | if (ctor === '_Task_fail') 1859 | { 1860 | while (process.stack && process.stack.ctor === '_Task_andThen') 1861 | { 1862 | process.stack = process.stack.rest; 1863 | } 1864 | if (process.stack === null) 1865 | { 1866 | break; 1867 | } 1868 | process.root = process.stack.callback(process.root.value); 1869 | process.stack = process.stack.rest; 1870 | ++numSteps; 1871 | continue; 1872 | } 1873 | 1874 | if (ctor === '_Task_andThen') 1875 | { 1876 | process.stack = { 1877 | ctor: '_Task_andThen', 1878 | callback: process.root.callback, 1879 | rest: process.stack 1880 | }; 1881 | process.root = process.root.task; 1882 | ++numSteps; 1883 | continue; 1884 | } 1885 | 1886 | if (ctor === '_Task_onError') 1887 | { 1888 | process.stack = { 1889 | ctor: '_Task_onError', 1890 | callback: process.root.callback, 1891 | rest: process.stack 1892 | }; 1893 | process.root = process.root.task; 1894 | ++numSteps; 1895 | continue; 1896 | } 1897 | 1898 | if (ctor === '_Task_nativeBinding') 1899 | { 1900 | process.root.cancel = process.root.callback(function(newRoot) { 1901 | process.root = newRoot; 1902 | enqueue(process); 1903 | }); 1904 | 1905 | break; 1906 | } 1907 | 1908 | if (ctor === '_Task_receive') 1909 | { 1910 | var mailbox = process.mailbox; 1911 | if (mailbox.length === 0) 1912 | { 1913 | break; 1914 | } 1915 | 1916 | process.root = process.root.callback(mailbox.shift()); 1917 | ++numSteps; 1918 | continue; 1919 | } 1920 | 1921 | throw new Error(ctor); 1922 | } 1923 | 1924 | if (numSteps < MAX_STEPS) 1925 | { 1926 | return numSteps + 1; 1927 | } 1928 | enqueue(process); 1929 | 1930 | return numSteps; 1931 | } 1932 | 1933 | 1934 | // WORK QUEUE 1935 | 1936 | var working = false; 1937 | var workQueue = []; 1938 | 1939 | function enqueue(process) 1940 | { 1941 | workQueue.push(process); 1942 | 1943 | if (!working) 1944 | { 1945 | setTimeout(work, 0); 1946 | working = true; 1947 | } 1948 | } 1949 | 1950 | function work() 1951 | { 1952 | var numSteps = 0; 1953 | var process; 1954 | while (numSteps < MAX_STEPS && (process = workQueue.shift())) 1955 | { 1956 | if (process.root) 1957 | { 1958 | numSteps = step(numSteps, process); 1959 | } 1960 | } 1961 | if (!process) 1962 | { 1963 | working = false; 1964 | return; 1965 | } 1966 | setTimeout(work, 0); 1967 | } 1968 | 1969 | 1970 | return { 1971 | succeed: succeed, 1972 | fail: fail, 1973 | nativeBinding: nativeBinding, 1974 | andThen: F2(andThen), 1975 | onError: F2(onError), 1976 | receive: receive, 1977 | 1978 | spawn: spawn, 1979 | kill: kill, 1980 | sleep: sleep, 1981 | send: F2(send), 1982 | 1983 | rawSpawn: rawSpawn, 1984 | rawSend: rawSend 1985 | }; 1986 | 1987 | }(); 1988 | //import // 1989 | 1990 | var _elm_lang$core$Native_Platform = function() { 1991 | 1992 | 1993 | // PROGRAMS 1994 | 1995 | function program(impl) 1996 | { 1997 | return function(flagDecoder) 1998 | { 1999 | return function(object, moduleName) 2000 | { 2001 | object['worker'] = function worker(flags) 2002 | { 2003 | if (typeof flags !== 'undefined') 2004 | { 2005 | throw new Error( 2006 | 'The `' + moduleName + '` module does not need flags.\n' 2007 | + 'Call ' + moduleName + '.worker() with no arguments and you should be all set!' 2008 | ); 2009 | } 2010 | 2011 | return initialize( 2012 | impl.init, 2013 | impl.update, 2014 | impl.subscriptions, 2015 | renderer 2016 | ); 2017 | }; 2018 | }; 2019 | }; 2020 | } 2021 | 2022 | function programWithFlags(impl) 2023 | { 2024 | return function(flagDecoder) 2025 | { 2026 | return function(object, moduleName) 2027 | { 2028 | object['worker'] = function worker(flags) 2029 | { 2030 | if (typeof flagDecoder === 'undefined') 2031 | { 2032 | throw new Error( 2033 | 'Are you trying to sneak a Never value into Elm? Trickster!\n' 2034 | + 'It looks like ' + moduleName + '.main is defined with `programWithFlags` but has type `Program Never`.\n' 2035 | + 'Use `program` instead if you do not want flags.' 2036 | ); 2037 | } 2038 | 2039 | var result = A2(_elm_lang$core$Native_Json.run, flagDecoder, flags); 2040 | if (result.ctor === 'Err') 2041 | { 2042 | throw new Error( 2043 | moduleName + '.worker(...) was called with an unexpected argument.\n' 2044 | + 'I tried to convert it to an Elm value, but ran into this problem:\n\n' 2045 | + result._0 2046 | ); 2047 | } 2048 | 2049 | return initialize( 2050 | impl.init(result._0), 2051 | impl.update, 2052 | impl.subscriptions, 2053 | renderer 2054 | ); 2055 | }; 2056 | }; 2057 | }; 2058 | } 2059 | 2060 | function renderer(enqueue, _) 2061 | { 2062 | return function(_) {}; 2063 | } 2064 | 2065 | 2066 | // HTML TO PROGRAM 2067 | 2068 | function htmlToProgram(vnode) 2069 | { 2070 | var emptyBag = batch(_elm_lang$core$Native_List.Nil); 2071 | var noChange = _elm_lang$core$Native_Utils.Tuple2( 2072 | _elm_lang$core$Native_Utils.Tuple0, 2073 | emptyBag 2074 | ); 2075 | 2076 | return _elm_lang$virtual_dom$VirtualDom$program({ 2077 | init: noChange, 2078 | view: function(model) { return main; }, 2079 | update: F2(function(msg, model) { return noChange; }), 2080 | subscriptions: function (model) { return emptyBag; } 2081 | }); 2082 | } 2083 | 2084 | 2085 | // INITIALIZE A PROGRAM 2086 | 2087 | function initialize(init, update, subscriptions, renderer) 2088 | { 2089 | // ambient state 2090 | var managers = {}; 2091 | var updateView; 2092 | 2093 | // init and update state in main process 2094 | var initApp = _elm_lang$core$Native_Scheduler.nativeBinding(function(callback) { 2095 | var model = init._0; 2096 | updateView = renderer(enqueue, model); 2097 | var cmds = init._1; 2098 | var subs = subscriptions(model); 2099 | dispatchEffects(managers, cmds, subs); 2100 | callback(_elm_lang$core$Native_Scheduler.succeed(model)); 2101 | }); 2102 | 2103 | function onMessage(msg, model) 2104 | { 2105 | return _elm_lang$core$Native_Scheduler.nativeBinding(function(callback) { 2106 | var results = A2(update, msg, model); 2107 | model = results._0; 2108 | updateView(model); 2109 | var cmds = results._1; 2110 | var subs = subscriptions(model); 2111 | dispatchEffects(managers, cmds, subs); 2112 | callback(_elm_lang$core$Native_Scheduler.succeed(model)); 2113 | }); 2114 | } 2115 | 2116 | var mainProcess = spawnLoop(initApp, onMessage); 2117 | 2118 | function enqueue(msg) 2119 | { 2120 | _elm_lang$core$Native_Scheduler.rawSend(mainProcess, msg); 2121 | } 2122 | 2123 | var ports = setupEffects(managers, enqueue); 2124 | 2125 | return ports ? { ports: ports } : {}; 2126 | } 2127 | 2128 | 2129 | // EFFECT MANAGERS 2130 | 2131 | var effectManagers = {}; 2132 | 2133 | function setupEffects(managers, callback) 2134 | { 2135 | var ports; 2136 | 2137 | // setup all necessary effect managers 2138 | for (var key in effectManagers) 2139 | { 2140 | var manager = effectManagers[key]; 2141 | 2142 | if (manager.isForeign) 2143 | { 2144 | ports = ports || {}; 2145 | ports[key] = manager.tag === 'cmd' 2146 | ? setupOutgoingPort(key) 2147 | : setupIncomingPort(key, callback); 2148 | } 2149 | 2150 | managers[key] = makeManager(manager, callback); 2151 | } 2152 | 2153 | return ports; 2154 | } 2155 | 2156 | function makeManager(info, callback) 2157 | { 2158 | var router = { 2159 | main: callback, 2160 | self: undefined 2161 | }; 2162 | 2163 | var tag = info.tag; 2164 | var onEffects = info.onEffects; 2165 | var onSelfMsg = info.onSelfMsg; 2166 | 2167 | function onMessage(msg, state) 2168 | { 2169 | if (msg.ctor === 'self') 2170 | { 2171 | return A3(onSelfMsg, router, msg._0, state); 2172 | } 2173 | 2174 | var fx = msg._0; 2175 | switch (tag) 2176 | { 2177 | case 'cmd': 2178 | return A3(onEffects, router, fx.cmds, state); 2179 | 2180 | case 'sub': 2181 | return A3(onEffects, router, fx.subs, state); 2182 | 2183 | case 'fx': 2184 | return A4(onEffects, router, fx.cmds, fx.subs, state); 2185 | } 2186 | } 2187 | 2188 | var process = spawnLoop(info.init, onMessage); 2189 | router.self = process; 2190 | return process; 2191 | } 2192 | 2193 | function sendToApp(router, msg) 2194 | { 2195 | return _elm_lang$core$Native_Scheduler.nativeBinding(function(callback) 2196 | { 2197 | router.main(msg); 2198 | callback(_elm_lang$core$Native_Scheduler.succeed(_elm_lang$core$Native_Utils.Tuple0)); 2199 | }); 2200 | } 2201 | 2202 | function sendToSelf(router, msg) 2203 | { 2204 | return A2(_elm_lang$core$Native_Scheduler.send, router.self, { 2205 | ctor: 'self', 2206 | _0: msg 2207 | }); 2208 | } 2209 | 2210 | 2211 | // HELPER for STATEFUL LOOPS 2212 | 2213 | function spawnLoop(init, onMessage) 2214 | { 2215 | var andThen = _elm_lang$core$Native_Scheduler.andThen; 2216 | 2217 | function loop(state) 2218 | { 2219 | var handleMsg = _elm_lang$core$Native_Scheduler.receive(function(msg) { 2220 | return onMessage(msg, state); 2221 | }); 2222 | return A2(andThen, loop, handleMsg); 2223 | } 2224 | 2225 | var task = A2(andThen, loop, init); 2226 | 2227 | return _elm_lang$core$Native_Scheduler.rawSpawn(task); 2228 | } 2229 | 2230 | 2231 | // BAGS 2232 | 2233 | function leaf(home) 2234 | { 2235 | return function(value) 2236 | { 2237 | return { 2238 | type: 'leaf', 2239 | home: home, 2240 | value: value 2241 | }; 2242 | }; 2243 | } 2244 | 2245 | function batch(list) 2246 | { 2247 | return { 2248 | type: 'node', 2249 | branches: list 2250 | }; 2251 | } 2252 | 2253 | function map(tagger, bag) 2254 | { 2255 | return { 2256 | type: 'map', 2257 | tagger: tagger, 2258 | tree: bag 2259 | } 2260 | } 2261 | 2262 | 2263 | // PIPE BAGS INTO EFFECT MANAGERS 2264 | 2265 | function dispatchEffects(managers, cmdBag, subBag) 2266 | { 2267 | var effectsDict = {}; 2268 | gatherEffects(true, cmdBag, effectsDict, null); 2269 | gatherEffects(false, subBag, effectsDict, null); 2270 | 2271 | for (var home in managers) 2272 | { 2273 | var fx = home in effectsDict 2274 | ? effectsDict[home] 2275 | : { 2276 | cmds: _elm_lang$core$Native_List.Nil, 2277 | subs: _elm_lang$core$Native_List.Nil 2278 | }; 2279 | 2280 | _elm_lang$core$Native_Scheduler.rawSend(managers[home], { ctor: 'fx', _0: fx }); 2281 | } 2282 | } 2283 | 2284 | function gatherEffects(isCmd, bag, effectsDict, taggers) 2285 | { 2286 | switch (bag.type) 2287 | { 2288 | case 'leaf': 2289 | var home = bag.home; 2290 | var effect = toEffect(isCmd, home, taggers, bag.value); 2291 | effectsDict[home] = insert(isCmd, effect, effectsDict[home]); 2292 | return; 2293 | 2294 | case 'node': 2295 | var list = bag.branches; 2296 | while (list.ctor !== '[]') 2297 | { 2298 | gatherEffects(isCmd, list._0, effectsDict, taggers); 2299 | list = list._1; 2300 | } 2301 | return; 2302 | 2303 | case 'map': 2304 | gatherEffects(isCmd, bag.tree, effectsDict, { 2305 | tagger: bag.tagger, 2306 | rest: taggers 2307 | }); 2308 | return; 2309 | } 2310 | } 2311 | 2312 | function toEffect(isCmd, home, taggers, value) 2313 | { 2314 | function applyTaggers(x) 2315 | { 2316 | var temp = taggers; 2317 | while (temp) 2318 | { 2319 | x = temp.tagger(x); 2320 | temp = temp.rest; 2321 | } 2322 | return x; 2323 | } 2324 | 2325 | var map = isCmd 2326 | ? effectManagers[home].cmdMap 2327 | : effectManagers[home].subMap; 2328 | 2329 | return A2(map, applyTaggers, value) 2330 | } 2331 | 2332 | function insert(isCmd, newEffect, effects) 2333 | { 2334 | effects = effects || { 2335 | cmds: _elm_lang$core$Native_List.Nil, 2336 | subs: _elm_lang$core$Native_List.Nil 2337 | }; 2338 | if (isCmd) 2339 | { 2340 | effects.cmds = _elm_lang$core$Native_List.Cons(newEffect, effects.cmds); 2341 | return effects; 2342 | } 2343 | effects.subs = _elm_lang$core$Native_List.Cons(newEffect, effects.subs); 2344 | return effects; 2345 | } 2346 | 2347 | 2348 | // PORTS 2349 | 2350 | function checkPortName(name) 2351 | { 2352 | if (name in effectManagers) 2353 | { 2354 | throw new Error('There can only be one port named `' + name + '`, but your program has multiple.'); 2355 | } 2356 | } 2357 | 2358 | 2359 | // OUTGOING PORTS 2360 | 2361 | function outgoingPort(name, converter) 2362 | { 2363 | checkPortName(name); 2364 | effectManagers[name] = { 2365 | tag: 'cmd', 2366 | cmdMap: outgoingPortMap, 2367 | converter: converter, 2368 | isForeign: true 2369 | }; 2370 | return leaf(name); 2371 | } 2372 | 2373 | var outgoingPortMap = F2(function cmdMap(tagger, value) { 2374 | return value; 2375 | }); 2376 | 2377 | function setupOutgoingPort(name) 2378 | { 2379 | var subs = []; 2380 | var converter = effectManagers[name].converter; 2381 | 2382 | // CREATE MANAGER 2383 | 2384 | var init = _elm_lang$core$Native_Scheduler.succeed(null); 2385 | 2386 | function onEffects(router, cmdList, state) 2387 | { 2388 | while (cmdList.ctor !== '[]') 2389 | { 2390 | // grab a separate reference to subs in case unsubscribe is called 2391 | var currentSubs = subs; 2392 | var value = converter(cmdList._0); 2393 | for (var i = 0; i < currentSubs.length; i++) 2394 | { 2395 | currentSubs[i](value); 2396 | } 2397 | cmdList = cmdList._1; 2398 | } 2399 | return init; 2400 | } 2401 | 2402 | effectManagers[name].init = init; 2403 | effectManagers[name].onEffects = F3(onEffects); 2404 | 2405 | // PUBLIC API 2406 | 2407 | function subscribe(callback) 2408 | { 2409 | subs.push(callback); 2410 | } 2411 | 2412 | function unsubscribe(callback) 2413 | { 2414 | // copy subs into a new array in case unsubscribe is called within a 2415 | // subscribed callback 2416 | subs = subs.slice(); 2417 | var index = subs.indexOf(callback); 2418 | if (index >= 0) 2419 | { 2420 | subs.splice(index, 1); 2421 | } 2422 | } 2423 | 2424 | return { 2425 | subscribe: subscribe, 2426 | unsubscribe: unsubscribe 2427 | }; 2428 | } 2429 | 2430 | 2431 | // INCOMING PORTS 2432 | 2433 | function incomingPort(name, converter) 2434 | { 2435 | checkPortName(name); 2436 | effectManagers[name] = { 2437 | tag: 'sub', 2438 | subMap: incomingPortMap, 2439 | converter: converter, 2440 | isForeign: true 2441 | }; 2442 | return leaf(name); 2443 | } 2444 | 2445 | var incomingPortMap = F2(function subMap(tagger, finalTagger) 2446 | { 2447 | return function(value) 2448 | { 2449 | return tagger(finalTagger(value)); 2450 | }; 2451 | }); 2452 | 2453 | function setupIncomingPort(name, callback) 2454 | { 2455 | var sentBeforeInit = []; 2456 | var subs = _elm_lang$core$Native_List.Nil; 2457 | var converter = effectManagers[name].converter; 2458 | var currentOnEffects = preInitOnEffects; 2459 | var currentSend = preInitSend; 2460 | 2461 | // CREATE MANAGER 2462 | 2463 | var init = _elm_lang$core$Native_Scheduler.succeed(null); 2464 | 2465 | function preInitOnEffects(router, subList, state) 2466 | { 2467 | var postInitResult = postInitOnEffects(router, subList, state); 2468 | 2469 | for(var i = 0; i < sentBeforeInit.length; i++) 2470 | { 2471 | postInitSend(sentBeforeInit[i]); 2472 | } 2473 | 2474 | sentBeforeInit = null; // to release objects held in queue 2475 | currentSend = postInitSend; 2476 | currentOnEffects = postInitOnEffects; 2477 | return postInitResult; 2478 | } 2479 | 2480 | function postInitOnEffects(router, subList, state) 2481 | { 2482 | subs = subList; 2483 | return init; 2484 | } 2485 | 2486 | function onEffects(router, subList, state) 2487 | { 2488 | return currentOnEffects(router, subList, state); 2489 | } 2490 | 2491 | effectManagers[name].init = init; 2492 | effectManagers[name].onEffects = F3(onEffects); 2493 | 2494 | // PUBLIC API 2495 | 2496 | function preInitSend(value) 2497 | { 2498 | sentBeforeInit.push(value); 2499 | } 2500 | 2501 | function postInitSend(incomingValue) 2502 | { 2503 | var result = A2(_elm_lang$core$Json_Decode$decodeValue, converter, incomingValue); 2504 | if (result.ctor === 'Err') 2505 | { 2506 | throw new Error('Trying to send an unexpected type of value through port `' + name + '`:\n' + result._0); 2507 | } 2508 | 2509 | var value = result._0; 2510 | var temp = subs; 2511 | while (temp.ctor !== '[]') 2512 | { 2513 | callback(temp._0(value)); 2514 | temp = temp._1; 2515 | } 2516 | } 2517 | 2518 | function send(incomingValue) 2519 | { 2520 | currentSend(incomingValue); 2521 | } 2522 | 2523 | return { send: send }; 2524 | } 2525 | 2526 | return { 2527 | // routers 2528 | sendToApp: F2(sendToApp), 2529 | sendToSelf: F2(sendToSelf), 2530 | 2531 | // global setup 2532 | effectManagers: effectManagers, 2533 | outgoingPort: outgoingPort, 2534 | incomingPort: incomingPort, 2535 | 2536 | htmlToProgram: htmlToProgram, 2537 | program: program, 2538 | programWithFlags: programWithFlags, 2539 | initialize: initialize, 2540 | 2541 | // effect bags 2542 | leaf: leaf, 2543 | batch: batch, 2544 | map: F2(map) 2545 | }; 2546 | 2547 | }(); 2548 | 2549 | var _elm_lang$core$Platform_Cmd$batch = _elm_lang$core$Native_Platform.batch; 2550 | var _elm_lang$core$Platform_Cmd$none = _elm_lang$core$Platform_Cmd$batch( 2551 | {ctor: '[]'}); 2552 | var _elm_lang$core$Platform_Cmd_ops = _elm_lang$core$Platform_Cmd_ops || {}; 2553 | _elm_lang$core$Platform_Cmd_ops['!'] = F2( 2554 | function (model, commands) { 2555 | return { 2556 | ctor: '_Tuple2', 2557 | _0: model, 2558 | _1: _elm_lang$core$Platform_Cmd$batch(commands) 2559 | }; 2560 | }); 2561 | var _elm_lang$core$Platform_Cmd$map = _elm_lang$core$Native_Platform.map; 2562 | var _elm_lang$core$Platform_Cmd$Cmd = {ctor: 'Cmd'}; 2563 | 2564 | var _elm_lang$core$Platform_Sub$batch = _elm_lang$core$Native_Platform.batch; 2565 | var _elm_lang$core$Platform_Sub$none = _elm_lang$core$Platform_Sub$batch( 2566 | {ctor: '[]'}); 2567 | var _elm_lang$core$Platform_Sub$map = _elm_lang$core$Native_Platform.map; 2568 | var _elm_lang$core$Platform_Sub$Sub = {ctor: 'Sub'}; 2569 | 2570 | var _elm_lang$core$Platform$hack = _elm_lang$core$Native_Scheduler.succeed; 2571 | var _elm_lang$core$Platform$sendToSelf = _elm_lang$core$Native_Platform.sendToSelf; 2572 | var _elm_lang$core$Platform$sendToApp = _elm_lang$core$Native_Platform.sendToApp; 2573 | var _elm_lang$core$Platform$programWithFlags = _elm_lang$core$Native_Platform.programWithFlags; 2574 | var _elm_lang$core$Platform$program = _elm_lang$core$Native_Platform.program; 2575 | var _elm_lang$core$Platform$Program = {ctor: 'Program'}; 2576 | var _elm_lang$core$Platform$Task = {ctor: 'Task'}; 2577 | var _elm_lang$core$Platform$ProcessId = {ctor: 'ProcessId'}; 2578 | var _elm_lang$core$Platform$Router = {ctor: 'Router'}; 2579 | 2580 | var _elm_lang$core$Result$toMaybe = function (result) { 2581 | var _p0 = result; 2582 | if (_p0.ctor === 'Ok') { 2583 | return _elm_lang$core$Maybe$Just(_p0._0); 2584 | } else { 2585 | return _elm_lang$core$Maybe$Nothing; 2586 | } 2587 | }; 2588 | var _elm_lang$core$Result$withDefault = F2( 2589 | function (def, result) { 2590 | var _p1 = result; 2591 | if (_p1.ctor === 'Ok') { 2592 | return _p1._0; 2593 | } else { 2594 | return def; 2595 | } 2596 | }); 2597 | var _elm_lang$core$Result$Err = function (a) { 2598 | return {ctor: 'Err', _0: a}; 2599 | }; 2600 | var _elm_lang$core$Result$andThen = F2( 2601 | function (callback, result) { 2602 | var _p2 = result; 2603 | if (_p2.ctor === 'Ok') { 2604 | return callback(_p2._0); 2605 | } else { 2606 | return _elm_lang$core$Result$Err(_p2._0); 2607 | } 2608 | }); 2609 | var _elm_lang$core$Result$Ok = function (a) { 2610 | return {ctor: 'Ok', _0: a}; 2611 | }; 2612 | var _elm_lang$core$Result$map = F2( 2613 | function (func, ra) { 2614 | var _p3 = ra; 2615 | if (_p3.ctor === 'Ok') { 2616 | return _elm_lang$core$Result$Ok( 2617 | func(_p3._0)); 2618 | } else { 2619 | return _elm_lang$core$Result$Err(_p3._0); 2620 | } 2621 | }); 2622 | var _elm_lang$core$Result$map2 = F3( 2623 | function (func, ra, rb) { 2624 | var _p4 = {ctor: '_Tuple2', _0: ra, _1: rb}; 2625 | if (_p4._0.ctor === 'Ok') { 2626 | if (_p4._1.ctor === 'Ok') { 2627 | return _elm_lang$core$Result$Ok( 2628 | A2(func, _p4._0._0, _p4._1._0)); 2629 | } else { 2630 | return _elm_lang$core$Result$Err(_p4._1._0); 2631 | } 2632 | } else { 2633 | return _elm_lang$core$Result$Err(_p4._0._0); 2634 | } 2635 | }); 2636 | var _elm_lang$core$Result$map3 = F4( 2637 | function (func, ra, rb, rc) { 2638 | var _p5 = {ctor: '_Tuple3', _0: ra, _1: rb, _2: rc}; 2639 | if (_p5._0.ctor === 'Ok') { 2640 | if (_p5._1.ctor === 'Ok') { 2641 | if (_p5._2.ctor === 'Ok') { 2642 | return _elm_lang$core$Result$Ok( 2643 | A3(func, _p5._0._0, _p5._1._0, _p5._2._0)); 2644 | } else { 2645 | return _elm_lang$core$Result$Err(_p5._2._0); 2646 | } 2647 | } else { 2648 | return _elm_lang$core$Result$Err(_p5._1._0); 2649 | } 2650 | } else { 2651 | return _elm_lang$core$Result$Err(_p5._0._0); 2652 | } 2653 | }); 2654 | var _elm_lang$core$Result$map4 = F5( 2655 | function (func, ra, rb, rc, rd) { 2656 | var _p6 = {ctor: '_Tuple4', _0: ra, _1: rb, _2: rc, _3: rd}; 2657 | if (_p6._0.ctor === 'Ok') { 2658 | if (_p6._1.ctor === 'Ok') { 2659 | if (_p6._2.ctor === 'Ok') { 2660 | if (_p6._3.ctor === 'Ok') { 2661 | return _elm_lang$core$Result$Ok( 2662 | A4(func, _p6._0._0, _p6._1._0, _p6._2._0, _p6._3._0)); 2663 | } else { 2664 | return _elm_lang$core$Result$Err(_p6._3._0); 2665 | } 2666 | } else { 2667 | return _elm_lang$core$Result$Err(_p6._2._0); 2668 | } 2669 | } else { 2670 | return _elm_lang$core$Result$Err(_p6._1._0); 2671 | } 2672 | } else { 2673 | return _elm_lang$core$Result$Err(_p6._0._0); 2674 | } 2675 | }); 2676 | var _elm_lang$core$Result$map5 = F6( 2677 | function (func, ra, rb, rc, rd, re) { 2678 | var _p7 = {ctor: '_Tuple5', _0: ra, _1: rb, _2: rc, _3: rd, _4: re}; 2679 | if (_p7._0.ctor === 'Ok') { 2680 | if (_p7._1.ctor === 'Ok') { 2681 | if (_p7._2.ctor === 'Ok') { 2682 | if (_p7._3.ctor === 'Ok') { 2683 | if (_p7._4.ctor === 'Ok') { 2684 | return _elm_lang$core$Result$Ok( 2685 | A5(func, _p7._0._0, _p7._1._0, _p7._2._0, _p7._3._0, _p7._4._0)); 2686 | } else { 2687 | return _elm_lang$core$Result$Err(_p7._4._0); 2688 | } 2689 | } else { 2690 | return _elm_lang$core$Result$Err(_p7._3._0); 2691 | } 2692 | } else { 2693 | return _elm_lang$core$Result$Err(_p7._2._0); 2694 | } 2695 | } else { 2696 | return _elm_lang$core$Result$Err(_p7._1._0); 2697 | } 2698 | } else { 2699 | return _elm_lang$core$Result$Err(_p7._0._0); 2700 | } 2701 | }); 2702 | var _elm_lang$core$Result$mapError = F2( 2703 | function (f, result) { 2704 | var _p8 = result; 2705 | if (_p8.ctor === 'Ok') { 2706 | return _elm_lang$core$Result$Ok(_p8._0); 2707 | } else { 2708 | return _elm_lang$core$Result$Err( 2709 | f(_p8._0)); 2710 | } 2711 | }); 2712 | var _elm_lang$core$Result$fromMaybe = F2( 2713 | function (err, maybe) { 2714 | var _p9 = maybe; 2715 | if (_p9.ctor === 'Just') { 2716 | return _elm_lang$core$Result$Ok(_p9._0); 2717 | } else { 2718 | return _elm_lang$core$Result$Err(err); 2719 | } 2720 | }); 2721 | 2722 | var _elm_lang$core$Task$onError = _elm_lang$core$Native_Scheduler.onError; 2723 | var _elm_lang$core$Task$andThen = _elm_lang$core$Native_Scheduler.andThen; 2724 | var _elm_lang$core$Task$spawnCmd = F2( 2725 | function (router, _p0) { 2726 | var _p1 = _p0; 2727 | return _elm_lang$core$Native_Scheduler.spawn( 2728 | A2( 2729 | _elm_lang$core$Task$andThen, 2730 | _elm_lang$core$Platform$sendToApp(router), 2731 | _p1._0)); 2732 | }); 2733 | var _elm_lang$core$Task$fail = _elm_lang$core$Native_Scheduler.fail; 2734 | var _elm_lang$core$Task$mapError = F2( 2735 | function (convert, task) { 2736 | return A2( 2737 | _elm_lang$core$Task$onError, 2738 | function (_p2) { 2739 | return _elm_lang$core$Task$fail( 2740 | convert(_p2)); 2741 | }, 2742 | task); 2743 | }); 2744 | var _elm_lang$core$Task$succeed = _elm_lang$core$Native_Scheduler.succeed; 2745 | var _elm_lang$core$Task$map = F2( 2746 | function (func, taskA) { 2747 | return A2( 2748 | _elm_lang$core$Task$andThen, 2749 | function (a) { 2750 | return _elm_lang$core$Task$succeed( 2751 | func(a)); 2752 | }, 2753 | taskA); 2754 | }); 2755 | var _elm_lang$core$Task$map2 = F3( 2756 | function (func, taskA, taskB) { 2757 | return A2( 2758 | _elm_lang$core$Task$andThen, 2759 | function (a) { 2760 | return A2( 2761 | _elm_lang$core$Task$andThen, 2762 | function (b) { 2763 | return _elm_lang$core$Task$succeed( 2764 | A2(func, a, b)); 2765 | }, 2766 | taskB); 2767 | }, 2768 | taskA); 2769 | }); 2770 | var _elm_lang$core$Task$map3 = F4( 2771 | function (func, taskA, taskB, taskC) { 2772 | return A2( 2773 | _elm_lang$core$Task$andThen, 2774 | function (a) { 2775 | return A2( 2776 | _elm_lang$core$Task$andThen, 2777 | function (b) { 2778 | return A2( 2779 | _elm_lang$core$Task$andThen, 2780 | function (c) { 2781 | return _elm_lang$core$Task$succeed( 2782 | A3(func, a, b, c)); 2783 | }, 2784 | taskC); 2785 | }, 2786 | taskB); 2787 | }, 2788 | taskA); 2789 | }); 2790 | var _elm_lang$core$Task$map4 = F5( 2791 | function (func, taskA, taskB, taskC, taskD) { 2792 | return A2( 2793 | _elm_lang$core$Task$andThen, 2794 | function (a) { 2795 | return A2( 2796 | _elm_lang$core$Task$andThen, 2797 | function (b) { 2798 | return A2( 2799 | _elm_lang$core$Task$andThen, 2800 | function (c) { 2801 | return A2( 2802 | _elm_lang$core$Task$andThen, 2803 | function (d) { 2804 | return _elm_lang$core$Task$succeed( 2805 | A4(func, a, b, c, d)); 2806 | }, 2807 | taskD); 2808 | }, 2809 | taskC); 2810 | }, 2811 | taskB); 2812 | }, 2813 | taskA); 2814 | }); 2815 | var _elm_lang$core$Task$map5 = F6( 2816 | function (func, taskA, taskB, taskC, taskD, taskE) { 2817 | return A2( 2818 | _elm_lang$core$Task$andThen, 2819 | function (a) { 2820 | return A2( 2821 | _elm_lang$core$Task$andThen, 2822 | function (b) { 2823 | return A2( 2824 | _elm_lang$core$Task$andThen, 2825 | function (c) { 2826 | return A2( 2827 | _elm_lang$core$Task$andThen, 2828 | function (d) { 2829 | return A2( 2830 | _elm_lang$core$Task$andThen, 2831 | function (e) { 2832 | return _elm_lang$core$Task$succeed( 2833 | A5(func, a, b, c, d, e)); 2834 | }, 2835 | taskE); 2836 | }, 2837 | taskD); 2838 | }, 2839 | taskC); 2840 | }, 2841 | taskB); 2842 | }, 2843 | taskA); 2844 | }); 2845 | var _elm_lang$core$Task$sequence = function (tasks) { 2846 | var _p3 = tasks; 2847 | if (_p3.ctor === '[]') { 2848 | return _elm_lang$core$Task$succeed( 2849 | {ctor: '[]'}); 2850 | } else { 2851 | return A3( 2852 | _elm_lang$core$Task$map2, 2853 | F2( 2854 | function (x, y) { 2855 | return {ctor: '::', _0: x, _1: y}; 2856 | }), 2857 | _p3._0, 2858 | _elm_lang$core$Task$sequence(_p3._1)); 2859 | } 2860 | }; 2861 | var _elm_lang$core$Task$onEffects = F3( 2862 | function (router, commands, state) { 2863 | return A2( 2864 | _elm_lang$core$Task$map, 2865 | function (_p4) { 2866 | return {ctor: '_Tuple0'}; 2867 | }, 2868 | _elm_lang$core$Task$sequence( 2869 | A2( 2870 | _elm_lang$core$List$map, 2871 | _elm_lang$core$Task$spawnCmd(router), 2872 | commands))); 2873 | }); 2874 | var _elm_lang$core$Task$init = _elm_lang$core$Task$succeed( 2875 | {ctor: '_Tuple0'}); 2876 | var _elm_lang$core$Task$onSelfMsg = F3( 2877 | function (_p7, _p6, _p5) { 2878 | return _elm_lang$core$Task$succeed( 2879 | {ctor: '_Tuple0'}); 2880 | }); 2881 | var _elm_lang$core$Task$command = _elm_lang$core$Native_Platform.leaf('Task'); 2882 | var _elm_lang$core$Task$Perform = function (a) { 2883 | return {ctor: 'Perform', _0: a}; 2884 | }; 2885 | var _elm_lang$core$Task$perform = F2( 2886 | function (toMessage, task) { 2887 | return _elm_lang$core$Task$command( 2888 | _elm_lang$core$Task$Perform( 2889 | A2(_elm_lang$core$Task$map, toMessage, task))); 2890 | }); 2891 | var _elm_lang$core$Task$attempt = F2( 2892 | function (resultToMessage, task) { 2893 | return _elm_lang$core$Task$command( 2894 | _elm_lang$core$Task$Perform( 2895 | A2( 2896 | _elm_lang$core$Task$onError, 2897 | function (_p8) { 2898 | return _elm_lang$core$Task$succeed( 2899 | resultToMessage( 2900 | _elm_lang$core$Result$Err(_p8))); 2901 | }, 2902 | A2( 2903 | _elm_lang$core$Task$andThen, 2904 | function (_p9) { 2905 | return _elm_lang$core$Task$succeed( 2906 | resultToMessage( 2907 | _elm_lang$core$Result$Ok(_p9))); 2908 | }, 2909 | task)))); 2910 | }); 2911 | var _elm_lang$core$Task$cmdMap = F2( 2912 | function (tagger, _p10) { 2913 | var _p11 = _p10; 2914 | return _elm_lang$core$Task$Perform( 2915 | A2(_elm_lang$core$Task$map, tagger, _p11._0)); 2916 | }); 2917 | _elm_lang$core$Native_Platform.effectManagers['Task'] = {pkg: 'elm-lang/core', init: _elm_lang$core$Task$init, onEffects: _elm_lang$core$Task$onEffects, onSelfMsg: _elm_lang$core$Task$onSelfMsg, tag: 'cmd', cmdMap: _elm_lang$core$Task$cmdMap}; 2918 | 2919 | //import Native.Utils // 2920 | 2921 | var _elm_lang$core$Native_Debug = function() { 2922 | 2923 | function log(tag, value) 2924 | { 2925 | var msg = tag + ': ' + _elm_lang$core$Native_Utils.toString(value); 2926 | var process = process || {}; 2927 | if (process.stdout) 2928 | { 2929 | process.stdout.write(msg); 2930 | } 2931 | else 2932 | { 2933 | console.log(msg); 2934 | } 2935 | return value; 2936 | } 2937 | 2938 | function crash(message) 2939 | { 2940 | throw new Error(message); 2941 | } 2942 | 2943 | return { 2944 | crash: crash, 2945 | log: F2(log) 2946 | }; 2947 | 2948 | }(); 2949 | //import Maybe, Native.List, Native.Utils, Result // 2950 | 2951 | var _elm_lang$core$Native_String = function() { 2952 | 2953 | function isEmpty(str) 2954 | { 2955 | return str.length === 0; 2956 | } 2957 | function cons(chr, str) 2958 | { 2959 | return chr + str; 2960 | } 2961 | function uncons(str) 2962 | { 2963 | var hd = str[0]; 2964 | if (hd) 2965 | { 2966 | return _elm_lang$core$Maybe$Just(_elm_lang$core$Native_Utils.Tuple2(_elm_lang$core$Native_Utils.chr(hd), str.slice(1))); 2967 | } 2968 | return _elm_lang$core$Maybe$Nothing; 2969 | } 2970 | function append(a, b) 2971 | { 2972 | return a + b; 2973 | } 2974 | function concat(strs) 2975 | { 2976 | return _elm_lang$core$Native_List.toArray(strs).join(''); 2977 | } 2978 | function length(str) 2979 | { 2980 | return str.length; 2981 | } 2982 | function map(f, str) 2983 | { 2984 | var out = str.split(''); 2985 | for (var i = out.length; i--; ) 2986 | { 2987 | out[i] = f(_elm_lang$core$Native_Utils.chr(out[i])); 2988 | } 2989 | return out.join(''); 2990 | } 2991 | function filter(pred, str) 2992 | { 2993 | return str.split('').map(_elm_lang$core$Native_Utils.chr).filter(pred).join(''); 2994 | } 2995 | function reverse(str) 2996 | { 2997 | return str.split('').reverse().join(''); 2998 | } 2999 | function foldl(f, b, str) 3000 | { 3001 | var len = str.length; 3002 | for (var i = 0; i < len; ++i) 3003 | { 3004 | b = A2(f, _elm_lang$core$Native_Utils.chr(str[i]), b); 3005 | } 3006 | return b; 3007 | } 3008 | function foldr(f, b, str) 3009 | { 3010 | for (var i = str.length; i--; ) 3011 | { 3012 | b = A2(f, _elm_lang$core$Native_Utils.chr(str[i]), b); 3013 | } 3014 | return b; 3015 | } 3016 | function split(sep, str) 3017 | { 3018 | return _elm_lang$core$Native_List.fromArray(str.split(sep)); 3019 | } 3020 | function join(sep, strs) 3021 | { 3022 | return _elm_lang$core$Native_List.toArray(strs).join(sep); 3023 | } 3024 | function repeat(n, str) 3025 | { 3026 | var result = ''; 3027 | while (n > 0) 3028 | { 3029 | if (n & 1) 3030 | { 3031 | result += str; 3032 | } 3033 | n >>= 1, str += str; 3034 | } 3035 | return result; 3036 | } 3037 | function slice(start, end, str) 3038 | { 3039 | return str.slice(start, end); 3040 | } 3041 | function left(n, str) 3042 | { 3043 | return n < 1 ? '' : str.slice(0, n); 3044 | } 3045 | function right(n, str) 3046 | { 3047 | return n < 1 ? '' : str.slice(-n); 3048 | } 3049 | function dropLeft(n, str) 3050 | { 3051 | return n < 1 ? str : str.slice(n); 3052 | } 3053 | function dropRight(n, str) 3054 | { 3055 | return n < 1 ? str : str.slice(0, -n); 3056 | } 3057 | function pad(n, chr, str) 3058 | { 3059 | var half = (n - str.length) / 2; 3060 | return repeat(Math.ceil(half), chr) + str + repeat(half | 0, chr); 3061 | } 3062 | function padRight(n, chr, str) 3063 | { 3064 | return str + repeat(n - str.length, chr); 3065 | } 3066 | function padLeft(n, chr, str) 3067 | { 3068 | return repeat(n - str.length, chr) + str; 3069 | } 3070 | 3071 | function trim(str) 3072 | { 3073 | return str.trim(); 3074 | } 3075 | function trimLeft(str) 3076 | { 3077 | return str.replace(/^\s+/, ''); 3078 | } 3079 | function trimRight(str) 3080 | { 3081 | return str.replace(/\s+$/, ''); 3082 | } 3083 | 3084 | function words(str) 3085 | { 3086 | return _elm_lang$core$Native_List.fromArray(str.trim().split(/\s+/g)); 3087 | } 3088 | function lines(str) 3089 | { 3090 | return _elm_lang$core$Native_List.fromArray(str.split(/\r\n|\r|\n/g)); 3091 | } 3092 | 3093 | function toUpper(str) 3094 | { 3095 | return str.toUpperCase(); 3096 | } 3097 | function toLower(str) 3098 | { 3099 | return str.toLowerCase(); 3100 | } 3101 | 3102 | function any(pred, str) 3103 | { 3104 | for (var i = str.length; i--; ) 3105 | { 3106 | if (pred(_elm_lang$core$Native_Utils.chr(str[i]))) 3107 | { 3108 | return true; 3109 | } 3110 | } 3111 | return false; 3112 | } 3113 | function all(pred, str) 3114 | { 3115 | for (var i = str.length; i--; ) 3116 | { 3117 | if (!pred(_elm_lang$core$Native_Utils.chr(str[i]))) 3118 | { 3119 | return false; 3120 | } 3121 | } 3122 | return true; 3123 | } 3124 | 3125 | function contains(sub, str) 3126 | { 3127 | return str.indexOf(sub) > -1; 3128 | } 3129 | function startsWith(sub, str) 3130 | { 3131 | return str.indexOf(sub) === 0; 3132 | } 3133 | function endsWith(sub, str) 3134 | { 3135 | return str.length >= sub.length && 3136 | str.lastIndexOf(sub) === str.length - sub.length; 3137 | } 3138 | function indexes(sub, str) 3139 | { 3140 | var subLen = sub.length; 3141 | 3142 | if (subLen < 1) 3143 | { 3144 | return _elm_lang$core$Native_List.Nil; 3145 | } 3146 | 3147 | var i = 0; 3148 | var is = []; 3149 | 3150 | while ((i = str.indexOf(sub, i)) > -1) 3151 | { 3152 | is.push(i); 3153 | i = i + subLen; 3154 | } 3155 | 3156 | return _elm_lang$core$Native_List.fromArray(is); 3157 | } 3158 | 3159 | function toInt(s) 3160 | { 3161 | var len = s.length; 3162 | if (len === 0) 3163 | { 3164 | return _elm_lang$core$Result$Err("could not convert string '" + s + "' to an Int" ); 3165 | } 3166 | var start = 0; 3167 | if (s[0] === '-') 3168 | { 3169 | if (len === 1) 3170 | { 3171 | return _elm_lang$core$Result$Err("could not convert string '" + s + "' to an Int" ); 3172 | } 3173 | start = 1; 3174 | } 3175 | for (var i = start; i < len; ++i) 3176 | { 3177 | var c = s[i]; 3178 | if (c < '0' || '9' < c) 3179 | { 3180 | return _elm_lang$core$Result$Err("could not convert string '" + s + "' to an Int" ); 3181 | } 3182 | } 3183 | return _elm_lang$core$Result$Ok(parseInt(s, 10)); 3184 | } 3185 | 3186 | function toFloat(s) 3187 | { 3188 | var len = s.length; 3189 | if (len === 0) 3190 | { 3191 | return _elm_lang$core$Result$Err("could not convert string '" + s + "' to a Float" ); 3192 | } 3193 | var start = 0; 3194 | if (s[0] === '-') 3195 | { 3196 | if (len === 1) 3197 | { 3198 | return _elm_lang$core$Result$Err("could not convert string '" + s + "' to a Float" ); 3199 | } 3200 | start = 1; 3201 | } 3202 | var dotCount = 0; 3203 | for (var i = start; i < len; ++i) 3204 | { 3205 | var c = s[i]; 3206 | if ('0' <= c && c <= '9') 3207 | { 3208 | continue; 3209 | } 3210 | if (c === '.') 3211 | { 3212 | dotCount += 1; 3213 | if (dotCount <= 1) 3214 | { 3215 | continue; 3216 | } 3217 | } 3218 | return _elm_lang$core$Result$Err("could not convert string '" + s + "' to a Float" ); 3219 | } 3220 | return _elm_lang$core$Result$Ok(parseFloat(s)); 3221 | } 3222 | 3223 | function toList(str) 3224 | { 3225 | return _elm_lang$core$Native_List.fromArray(str.split('').map(_elm_lang$core$Native_Utils.chr)); 3226 | } 3227 | function fromList(chars) 3228 | { 3229 | return _elm_lang$core$Native_List.toArray(chars).join(''); 3230 | } 3231 | 3232 | return { 3233 | isEmpty: isEmpty, 3234 | cons: F2(cons), 3235 | uncons: uncons, 3236 | append: F2(append), 3237 | concat: concat, 3238 | length: length, 3239 | map: F2(map), 3240 | filter: F2(filter), 3241 | reverse: reverse, 3242 | foldl: F3(foldl), 3243 | foldr: F3(foldr), 3244 | 3245 | split: F2(split), 3246 | join: F2(join), 3247 | repeat: F2(repeat), 3248 | 3249 | slice: F3(slice), 3250 | left: F2(left), 3251 | right: F2(right), 3252 | dropLeft: F2(dropLeft), 3253 | dropRight: F2(dropRight), 3254 | 3255 | pad: F3(pad), 3256 | padLeft: F3(padLeft), 3257 | padRight: F3(padRight), 3258 | 3259 | trim: trim, 3260 | trimLeft: trimLeft, 3261 | trimRight: trimRight, 3262 | 3263 | words: words, 3264 | lines: lines, 3265 | 3266 | toUpper: toUpper, 3267 | toLower: toLower, 3268 | 3269 | any: F2(any), 3270 | all: F2(all), 3271 | 3272 | contains: F2(contains), 3273 | startsWith: F2(startsWith), 3274 | endsWith: F2(endsWith), 3275 | indexes: F2(indexes), 3276 | 3277 | toInt: toInt, 3278 | toFloat: toFloat, 3279 | toList: toList, 3280 | fromList: fromList 3281 | }; 3282 | 3283 | }(); 3284 | 3285 | var _elm_lang$core$String$fromList = _elm_lang$core$Native_String.fromList; 3286 | var _elm_lang$core$String$toList = _elm_lang$core$Native_String.toList; 3287 | var _elm_lang$core$String$toFloat = _elm_lang$core$Native_String.toFloat; 3288 | var _elm_lang$core$String$toInt = _elm_lang$core$Native_String.toInt; 3289 | var _elm_lang$core$String$indices = _elm_lang$core$Native_String.indexes; 3290 | var _elm_lang$core$String$indexes = _elm_lang$core$Native_String.indexes; 3291 | var _elm_lang$core$String$endsWith = _elm_lang$core$Native_String.endsWith; 3292 | var _elm_lang$core$String$startsWith = _elm_lang$core$Native_String.startsWith; 3293 | var _elm_lang$core$String$contains = _elm_lang$core$Native_String.contains; 3294 | var _elm_lang$core$String$all = _elm_lang$core$Native_String.all; 3295 | var _elm_lang$core$String$any = _elm_lang$core$Native_String.any; 3296 | var _elm_lang$core$String$toLower = _elm_lang$core$Native_String.toLower; 3297 | var _elm_lang$core$String$toUpper = _elm_lang$core$Native_String.toUpper; 3298 | var _elm_lang$core$String$lines = _elm_lang$core$Native_String.lines; 3299 | var _elm_lang$core$String$words = _elm_lang$core$Native_String.words; 3300 | var _elm_lang$core$String$trimRight = _elm_lang$core$Native_String.trimRight; 3301 | var _elm_lang$core$String$trimLeft = _elm_lang$core$Native_String.trimLeft; 3302 | var _elm_lang$core$String$trim = _elm_lang$core$Native_String.trim; 3303 | var _elm_lang$core$String$padRight = _elm_lang$core$Native_String.padRight; 3304 | var _elm_lang$core$String$padLeft = _elm_lang$core$Native_String.padLeft; 3305 | var _elm_lang$core$String$pad = _elm_lang$core$Native_String.pad; 3306 | var _elm_lang$core$String$dropRight = _elm_lang$core$Native_String.dropRight; 3307 | var _elm_lang$core$String$dropLeft = _elm_lang$core$Native_String.dropLeft; 3308 | var _elm_lang$core$String$right = _elm_lang$core$Native_String.right; 3309 | var _elm_lang$core$String$left = _elm_lang$core$Native_String.left; 3310 | var _elm_lang$core$String$slice = _elm_lang$core$Native_String.slice; 3311 | var _elm_lang$core$String$repeat = _elm_lang$core$Native_String.repeat; 3312 | var _elm_lang$core$String$join = _elm_lang$core$Native_String.join; 3313 | var _elm_lang$core$String$split = _elm_lang$core$Native_String.split; 3314 | var _elm_lang$core$String$foldr = _elm_lang$core$Native_String.foldr; 3315 | var _elm_lang$core$String$foldl = _elm_lang$core$Native_String.foldl; 3316 | var _elm_lang$core$String$reverse = _elm_lang$core$Native_String.reverse; 3317 | var _elm_lang$core$String$filter = _elm_lang$core$Native_String.filter; 3318 | var _elm_lang$core$String$map = _elm_lang$core$Native_String.map; 3319 | var _elm_lang$core$String$length = _elm_lang$core$Native_String.length; 3320 | var _elm_lang$core$String$concat = _elm_lang$core$Native_String.concat; 3321 | var _elm_lang$core$String$append = _elm_lang$core$Native_String.append; 3322 | var _elm_lang$core$String$uncons = _elm_lang$core$Native_String.uncons; 3323 | var _elm_lang$core$String$cons = _elm_lang$core$Native_String.cons; 3324 | var _elm_lang$core$String$fromChar = function ($char) { 3325 | return A2(_elm_lang$core$String$cons, $char, ''); 3326 | }; 3327 | var _elm_lang$core$String$isEmpty = _elm_lang$core$Native_String.isEmpty; 3328 | 3329 | var _elm_lang$core$Debug$crash = _elm_lang$core$Native_Debug.crash; 3330 | var _elm_lang$core$Debug$log = _elm_lang$core$Native_Debug.log; 3331 | 3332 | var _elm_lang$core$Tuple$mapSecond = F2( 3333 | function (func, _p0) { 3334 | var _p1 = _p0; 3335 | return { 3336 | ctor: '_Tuple2', 3337 | _0: _p1._0, 3338 | _1: func(_p1._1) 3339 | }; 3340 | }); 3341 | var _elm_lang$core$Tuple$mapFirst = F2( 3342 | function (func, _p2) { 3343 | var _p3 = _p2; 3344 | return { 3345 | ctor: '_Tuple2', 3346 | _0: func(_p3._0), 3347 | _1: _p3._1 3348 | }; 3349 | }); 3350 | var _elm_lang$core$Tuple$second = function (_p4) { 3351 | var _p5 = _p4; 3352 | return _p5._1; 3353 | }; 3354 | var _elm_lang$core$Tuple$first = function (_p6) { 3355 | var _p7 = _p6; 3356 | return _p7._0; 3357 | }; 3358 | 3359 | //import Native.Console // 3360 | 3361 | var _elmcast$elm_node$Native_Console = function() { 3362 | 3363 | function log(value) { 3364 | return _elm_lang$core$Native_Scheduler.nativeBinding(function(callback) { 3365 | if (typeof value == "string") { 3366 | console.log(value); 3367 | } else { 3368 | console.log(_elm_lang$core$Native_Utils.toString(value)); 3369 | } 3370 | return callback(_elm_lang$core$Native_Scheduler.succeed( 3371 | _elm_lang$core$Native_Utils.Tuple0)); 3372 | }); 3373 | } 3374 | 3375 | function error(value) { 3376 | return _elm_lang$core$Native_Scheduler.nativeBinding(function(callback) { 3377 | if (typeof value == "string") { 3378 | console.error(value); 3379 | } else { 3380 | console.error(_elm_lang$core$Native_Utils.toString(value)); 3381 | } 3382 | return callback(_elm_lang$core$Native_Scheduler.succeed( 3383 | _elm_lang$core$Native_Utils.Tuple0)); 3384 | }); 3385 | } 3386 | 3387 | function fatal(value) { 3388 | return _elm_lang$core$Native_Scheduler.nativeBinding(function(callback) { 3389 | if (typeof value == "string") { 3390 | console.error(value); 3391 | } else { 3392 | console.error(_elm_lang$core$Native_Utils.toString(value)); 3393 | } 3394 | process.exit(1); 3395 | return callback(_elm_lang$core$Native_Scheduler.succeed( 3396 | _elm_lang$core$Native_Utils.Tuple0)); 3397 | }); 3398 | } 3399 | 3400 | return { 3401 | log: log, 3402 | error: error, 3403 | fatal: fatal 3404 | }; 3405 | }(); 3406 | 3407 | 3408 | (function() { 3409 | if (typeof module == 'undefined') { 3410 | throw new Error('You are trying to run a node Elm program in the browser!'); 3411 | } 3412 | })(); 3413 | 3414 | var _elmcast$elm_node$Console$fatal = function (value) { 3415 | return _elmcast$elm_node$Native_Console.fatal(value); 3416 | }; 3417 | var _elmcast$elm_node$Console$error = function (value) { 3418 | return _elmcast$elm_node$Native_Console.error(value); 3419 | }; 3420 | var _elmcast$elm_node$Console$log = function (value) { 3421 | return _elmcast$elm_node$Native_Console.log(value); 3422 | }; 3423 | 3424 | //import Native.Process // 3425 | 3426 | var _elmcast$elm_node$Native_Process = function() { 3427 | 3428 | var child = require('child_process'); 3429 | 3430 | function exec(command) { 3431 | return _elm_lang$core$Native_Scheduler.nativeBinding( 3432 | function(callback) { 3433 | child.exec(command, function(error, stdout, stderr) { 3434 | if (error != null) { 3435 | callback(_elm_lang$core$Native_Scheduler.fail('Exec: ' + error)); 3436 | } else { 3437 | callback(_elm_lang$core$Native_Scheduler.succeed('' + stdout)); 3438 | } 3439 | }); 3440 | }); 3441 | } 3442 | 3443 | function exit(error) { 3444 | return _elm_lang$core$Native_Scheduler.nativeBinding( 3445 | function(callback) { 3446 | process.exit(error); 3447 | return callback(_elm_lang$core$Native_Scheduler.succeed(Utils.Tuple0)); 3448 | }); 3449 | } 3450 | 3451 | return { 3452 | argv: _elm_lang$core$Native_List.fromArray(process.argv), 3453 | execPath: process.execPath, 3454 | execArgv: _elm_lang$core$Native_List.fromArray(process.execArgv), 3455 | exec: exec, 3456 | exit: exit, 3457 | pid: process.pid, 3458 | version: process.version 3459 | }; 3460 | }(); 3461 | 3462 | 3463 | (function() { 3464 | if (typeof module == 'undefined') { 3465 | throw new Error('You are trying to run a node Elm program in the browser!'); 3466 | } 3467 | })(); 3468 | 3469 | var _elmcast$elm_node$NodeProcess$version = _elmcast$elm_node$Native_Process.version; 3470 | var _elmcast$elm_node$NodeProcess$pid = _elmcast$elm_node$Native_Process.pid; 3471 | var _elmcast$elm_node$NodeProcess$exit = function (code) { 3472 | return _elmcast$elm_node$Native_Process.exit(code); 3473 | }; 3474 | var _elmcast$elm_node$NodeProcess$exec = function (command) { 3475 | return _elmcast$elm_node$Native_Process.exec(command); 3476 | }; 3477 | var _elmcast$elm_node$NodeProcess$execArgv = _elmcast$elm_node$Native_Process.execArgv; 3478 | var _elmcast$elm_node$NodeProcess$execPath = _elmcast$elm_node$Native_Process.execPath; 3479 | var _elmcast$elm_node$NodeProcess$args = A2(_elm_lang$core$List$drop, 2, _elmcast$elm_node$Native_Process.argv); 3480 | var _elmcast$elm_node$NodeProcess$argv = _elmcast$elm_node$Native_Process.argv; 3481 | 3482 | var _elmcast$elm_node$Example$subscriptions = function (model) { 3483 | return _elm_lang$core$Platform_Sub$none; 3484 | }; 3485 | var _elmcast$elm_node$Example$update = F2( 3486 | function (msg, model) { 3487 | return A2( 3488 | _elm_lang$core$Platform_Cmd_ops['!'], 3489 | {ctor: '_Tuple0'}, 3490 | { 3491 | ctor: '::', 3492 | _0: _elm_lang$core$Platform_Cmd$none, 3493 | _1: {ctor: '[]'} 3494 | }); 3495 | }); 3496 | var _elmcast$elm_node$Example$main = _elm_lang$core$Platform$program( 3497 | { 3498 | init: { 3499 | ctor: '_Tuple2', 3500 | _0: {ctor: '_Tuple0'}, 3501 | _1: A2( 3502 | _elm_lang$core$Task$perform, 3503 | function (_p0) { 3504 | return {ctor: '_Tuple0'}; 3505 | }, 3506 | _elmcast$elm_node$Console$log( 3507 | A2( 3508 | _elm_lang$core$Basics_ops['++'], 3509 | 'Hello Elm world!\n', 3510 | A2( 3511 | _elm_lang$core$Basics_ops['++'], 3512 | 'Args: ', 3513 | _elm_lang$core$Basics$toString(_elmcast$elm_node$NodeProcess$args))))) 3514 | }, 3515 | update: _elmcast$elm_node$Example$update, 3516 | subscriptions: _elmcast$elm_node$Example$subscriptions 3517 | })(); 3518 | 3519 | var Elm = {}; 3520 | Elm['Example'] = Elm['Example'] || {}; 3521 | if (typeof _elmcast$elm_node$Example$main !== 'undefined') { 3522 | _elmcast$elm_node$Example$main(Elm['Example'], 'Example', undefined); 3523 | } 3524 | 3525 | if (typeof define === "function" && define['amd']) 3526 | { 3527 | define([], function() { return Elm; }); 3528 | return; 3529 | } 3530 | 3531 | if (typeof module === "object") 3532 | { 3533 | module['exports'] = Elm; 3534 | return; 3535 | } 3536 | 3537 | var globalElm = this['Elm']; 3538 | if (typeof globalElm === "undefined") 3539 | { 3540 | this['Elm'] = Elm; 3541 | return; 3542 | } 3543 | 3544 | for (var publicModule in Elm) 3545 | { 3546 | if (publicModule in globalElm) 3547 | { 3548 | throw new Error('There are two Elm modules called `' + publicModule + '` on this page! Rename one of them.'); 3549 | } 3550 | globalElm[publicModule] = Elm[publicModule]; 3551 | } 3552 | 3553 | }).call(this); 3554 | 3555 | -------------------------------------------------------------------------------- /make-example.sh: -------------------------------------------------------------------------------- 1 | elm-make example/Example.elm --output=example/example.js 2 | -------------------------------------------------------------------------------- /src/Console.elm: -------------------------------------------------------------------------------- 1 | module Console 2 | exposing 3 | ( log 4 | , error 5 | , fatal 6 | ) 7 | 8 | {-| Console 9 | 10 | @docs log, error, fatal 11 | 12 | -} 13 | 14 | import Native.Console 15 | import Task exposing (Task) 16 | 17 | 18 | {-| Prints to stdout with a newline. 19 | -} 20 | log : a -> Task x () 21 | log value = 22 | Native.Console.log value 23 | 24 | 25 | {-| Prints to stderr with a newline. 26 | -} 27 | error : a -> Task x () 28 | error value = 29 | Native.Console.error value 30 | 31 | 32 | {-| Prints to stderr with a newline, then exits with an error code of 1. 33 | -} 34 | fatal : a -> Task x () 35 | fatal value = 36 | Native.Console.fatal value 37 | -------------------------------------------------------------------------------- /src/File.elm: -------------------------------------------------------------------------------- 1 | module File 2 | exposing 3 | ( Error(..) 4 | , read 5 | , write 6 | , lstat 7 | ) 8 | 9 | {-| File 10 | 11 | @docs Error 12 | @docs read 13 | @docs lstat 14 | @docs write 15 | 16 | -} 17 | 18 | import Native.File 19 | import Task exposing (Task) 20 | 21 | 22 | {-| Error 23 | -} 24 | type Error 25 | = ReadError String 26 | | WriteError String 27 | 28 | 29 | {-| Read a file. 30 | -} 31 | read : String -> Task Error String 32 | read path = 33 | Native.File.read path 34 | 35 | 36 | {-| Write a file. 37 | -} 38 | write : String -> String -> Task Error () 39 | write path data = 40 | Native.File.write path data 41 | 42 | 43 | {-| Stat 44 | -} 45 | type alias Stat = 46 | {} 47 | 48 | 49 | {-| lstat 50 | -} 51 | lstat : String -> Task Error Stat 52 | lstat path = 53 | Native.File.lstat path 54 | -------------------------------------------------------------------------------- /src/Http.elm: -------------------------------------------------------------------------------- 1 | module Http 2 | exposing 3 | ( Error(..) 4 | , get 5 | , serve 6 | , getURL 7 | , sendResponse 8 | , Request 9 | , Response 10 | ) 11 | 12 | {-| 13 | 14 | @docs Error, Request, Response 15 | @docs get, serve, getURL, sendResponse 16 | 17 | -} 18 | 19 | import Task exposing (Task) 20 | import Native.Http 21 | 22 | 23 | {-| Error 24 | -} 25 | type Error 26 | = NetworkError String 27 | 28 | 29 | {-| Request 30 | -} 31 | type Request 32 | = Request 33 | 34 | 35 | {-| Response 36 | -} 37 | type Response 38 | = Response 39 | 40 | 41 | {-| get 42 | -} 43 | get : String -> Task Error String 44 | get url = 45 | Native.Http.get url 46 | 47 | 48 | {-| serve 49 | -} 50 | serve : Int -> (Request -> Response -> Task x a) -> Task x () 51 | serve prt taskFunction = 52 | Native.Http.serve prt taskFunction 53 | 54 | 55 | {-| getURL 56 | -} 57 | getURL : Request -> String 58 | getURL = 59 | Native.Http.get_url 60 | 61 | 62 | {-| sendResponse 63 | -} 64 | sendResponse : Response -> String -> Task x () 65 | sendResponse response s = 66 | Task.succeed <| Native.Http.response_end response s 67 | -------------------------------------------------------------------------------- /src/Native/Console.js: -------------------------------------------------------------------------------- 1 | //import Native.Console // 2 | 3 | var _elmcast$elm_node$Native_Console = function() { 4 | 5 | function log(value) { 6 | return _elm_lang$core$Native_Scheduler.nativeBinding(function(callback) { 7 | if (typeof value == "string") { 8 | console.log(value); 9 | } else { 10 | console.log(_elm_lang$core$Native_Utils.toString(value)); 11 | } 12 | return callback(_elm_lang$core$Native_Scheduler.succeed( 13 | _elm_lang$core$Native_Utils.Tuple0)); 14 | }); 15 | } 16 | 17 | function error(value) { 18 | return _elm_lang$core$Native_Scheduler.nativeBinding(function(callback) { 19 | if (typeof value == "string") { 20 | console.error(value); 21 | } else { 22 | console.error(_elm_lang$core$Native_Utils.toString(value)); 23 | } 24 | return callback(_elm_lang$core$Native_Scheduler.succeed( 25 | _elm_lang$core$Native_Utils.Tuple0)); 26 | }); 27 | } 28 | 29 | function fatal(value) { 30 | return _elm_lang$core$Native_Scheduler.nativeBinding(function(callback) { 31 | if (typeof value == "string") { 32 | console.error(value); 33 | } else { 34 | console.error(_elm_lang$core$Native_Utils.toString(value)); 35 | } 36 | process.exit(1); 37 | return callback(_elm_lang$core$Native_Scheduler.succeed( 38 | _elm_lang$core$Native_Utils.Tuple0)); 39 | }); 40 | } 41 | 42 | return { 43 | log: log, 44 | error: error, 45 | fatal: fatal 46 | }; 47 | }(); 48 | 49 | 50 | (function() { 51 | if (typeof module == 'undefined') { 52 | throw new Error('You are trying to run a node Elm program in the browser!'); 53 | } 54 | })(); 55 | -------------------------------------------------------------------------------- /src/Native/File.js: -------------------------------------------------------------------------------- 1 | //import Native.File // 2 | 3 | var _elmcast$elm_node$Native_File = function() { 4 | 5 | var fs = require('fs'); 6 | 7 | function read(path) { 8 | return _elm_lang$core$Native_Scheduler.nativeBinding( 9 | function(callback) { 10 | fs.readFile(path, 'utf8', function(err, data) { 11 | if (err) { 12 | return callback(_elm_lang$core$Native_Scheduler.fail({ ctor: 'ReadError', _0: err.path })); 13 | } 14 | return callback(_elm_lang$core$Native_Scheduler.succeed(data)); 15 | }); 16 | }); 17 | } 18 | 19 | function write(path, data) { 20 | return _elm_lang$core$Native_Scheduler.nativeBinding( 21 | function(callback) { 22 | fs.writeFile(path, data, function(err) { 23 | if (err) { 24 | return callback(_elm_lang$core$Native_Scheduler.fail({ ctor: 'WriteError', _0: err.path })); 25 | } 26 | return callback(_elm_lang$core$Native_Scheduler.succeed(_elm_lang$core$Native_Utils.Tuple0)); 27 | }); 28 | }); 29 | } 30 | 31 | function lstat(path) { 32 | return _elm_lang$core$Native_Scheduler.nativeBinding( 33 | function(callback) { 34 | fs.lstat(path, function(err, stat) { 35 | if (err) { 36 | return callback(_elm_lang$core$Native_Scheduler.fail({ ctor: 'ReadError', _0: "" })); 37 | } 38 | stat['_'] = {}; 39 | return callback(_elm_lang$core$Native_Scheduler.succeed(stat)); 40 | }); 41 | }); 42 | } 43 | 44 | return { 45 | read: read, 46 | write: F2(write), 47 | lstat: lstat 48 | }; 49 | }(); 50 | 51 | 52 | (function() { 53 | if (typeof module == 'undefined') { 54 | throw new Error('You are trying to run a node Elm program in the browser!'); 55 | } 56 | })(); 57 | -------------------------------------------------------------------------------- /src/Native/Http.js: -------------------------------------------------------------------------------- 1 | //import Native.Http // 2 | 3 | var _elmcast$elm_node$Native_Http = function() { 4 | 5 | var http = require('http'); 6 | 7 | function get(url) { 8 | return _elm_lang$core$Native_Scheduler.nativeBinding( 9 | function(callback) { 10 | http.get(url, function(res) { 11 | var data = ""; 12 | res.on("data", function (chunk) { 13 | data += chunk.toString(); 14 | }); 15 | res.on("end", function () { 16 | return callback(_elm_lang$core$Native_Scheduler.succeed(data)); 17 | }); 18 | }).on('error', function(err) { 19 | return callback(_elm_lang$core$Native_Scheduler.fail( 20 | { ctor: 'NetworkError', _0: url })); 21 | }); 22 | }); 23 | } 24 | 25 | function serve(port, task_function) { 26 | return _elm_lang$core$Native_Scheduler.nativeBinding( 27 | function(callback) { 28 | http.createServer(function(request, response) { 29 | _elm_lang$core$Native_Scheduler.rawSpawn( 30 | task_function(request)(response)); 31 | }).listen(port); 32 | return callback(_elm_lang$core$Native_Scheduler.succeed(Utils.Tuple0)); 33 | }); 34 | } 35 | 36 | function get_url(request) { 37 | return request.url; 38 | } 39 | 40 | function response_end(response, s) { 41 | response.end(s); 42 | return _elm_lang$core$Native_Utils.Tuple0; 43 | } 44 | 45 | return { 46 | get: get, 47 | serve: F2(serve), 48 | get_url: get_url, 49 | response_end: F2(response_end) 50 | }; 51 | }(); 52 | 53 | 54 | (function() { 55 | if (typeof module == 'undefined') { 56 | throw new Error('You are trying to run a node Elm program in the browser!'); 57 | } 58 | })(); 59 | -------------------------------------------------------------------------------- /src/Native/Path.js: -------------------------------------------------------------------------------- 1 | //import Native.Path // 2 | 3 | var _elmcast$elm_node$Native_Path = function() { 4 | 5 | var path = require('path'); 6 | 7 | function normalize(p) { 8 | return path.normalize(p); 9 | } 10 | 11 | function join(ps) { 12 | return path.join.apply(path.join, 13 | _elm_lang$core$Native_List.toArray(ps)); 14 | } 15 | 16 | function resolve(ps) { 17 | return path.resolve.apply(path.resolve, 18 | _elm_lang$core$Native_List.toArray(ps)); 19 | } 20 | 21 | function isAbsolute(p) { 22 | return path.isAbsolute(p); 23 | } 24 | 25 | function relative(fromP, toP) { 26 | return path.relative(fromP, toP); 27 | } 28 | 29 | function dirname(p) { 30 | return path.dirname(p); 31 | } 32 | 33 | function basename(p, ext) { 34 | return path.basename(p, ext); 35 | } 36 | 37 | function extname(p) { 38 | return path.extname(p); 39 | } 40 | 41 | return { 42 | normalize: normalize, 43 | join: join, 44 | resolve: resolve, 45 | isAbsolute: isAbsolute, 46 | relative: F2(relative), 47 | dirname: dirname, 48 | basename: F2(basename), 49 | extname: extname, 50 | sep: path.sep, 51 | delimiter: path.delimier 52 | }; 53 | }(); 54 | 55 | 56 | (function() { 57 | if (typeof module == 'undefined') { 58 | throw new Error('You are trying to run a node Elm program in the browser!'); 59 | } 60 | })(); 61 | -------------------------------------------------------------------------------- /src/Native/Process.js: -------------------------------------------------------------------------------- 1 | //import Native.Process // 2 | 3 | var _elmcast$elm_node$Native_Process = function() { 4 | 5 | var child = require('child_process'); 6 | 7 | function exec(command) { 8 | return _elm_lang$core$Native_Scheduler.nativeBinding( 9 | function(callback) { 10 | child.exec(command, function(error, stdout, stderr) { 11 | if (error != null) { 12 | callback(_elm_lang$core$Native_Scheduler.fail('Exec: ' + error)); 13 | } else { 14 | callback(_elm_lang$core$Native_Scheduler.succeed('' + stdout)); 15 | } 16 | }); 17 | }); 18 | } 19 | 20 | function exit(error) { 21 | return _elm_lang$core$Native_Scheduler.nativeBinding( 22 | function(callback) { 23 | process.exit(error); 24 | return callback(_elm_lang$core$Native_Scheduler.succeed(Utils.Tuple0)); 25 | }); 26 | } 27 | 28 | return { 29 | argv: _elm_lang$core$Native_List.fromArray(process.argv), 30 | execPath: process.execPath, 31 | execArgv: _elm_lang$core$Native_List.fromArray(process.execArgv), 32 | exec: exec, 33 | exit: exit, 34 | pid: process.pid, 35 | version: process.version 36 | }; 37 | }(); 38 | 39 | 40 | (function() { 41 | if (typeof module == 'undefined') { 42 | throw new Error('You are trying to run a node Elm program in the browser!'); 43 | } 44 | })(); 45 | -------------------------------------------------------------------------------- /src/Native/Url.js: -------------------------------------------------------------------------------- 1 | //import Native.Url // 2 | 3 | var _elmcast$elm_node$Native_Url = function() { 4 | 5 | var url = require('url'); 6 | 7 | function resolve(ps) { 8 | var b = url.resolve.apply(url.resolve, _elm_lang$core$Native_List.toArray(ps)); 9 | console.log(b); 10 | return b; 11 | } 12 | 13 | return { 14 | resolve: resolve 15 | }; 16 | }(); 17 | 18 | 19 | (function() { 20 | if (typeof module == 'undefined') { 21 | throw new Error('You are trying to run a node Elm program in the browser!'); 22 | } 23 | })(); 24 | -------------------------------------------------------------------------------- /src/NodeProcess.elm: -------------------------------------------------------------------------------- 1 | module NodeProcess 2 | exposing 3 | ( args 4 | , argv 5 | , execPath 6 | , execArgv 7 | , exec 8 | , exit 9 | , pid 10 | , version 11 | ) 12 | 13 | {-| NodeProcess 14 | 15 | @docs args, argv, execPath, execArgv 16 | 17 | @docs exec 18 | 19 | @docs exit, pid 20 | 21 | @docs version 22 | 23 | -} 24 | 25 | import Native.Process 26 | import Basics exposing (..) 27 | import Task exposing (Task) 28 | 29 | 30 | {-| A List containing the command line arguments. 31 | The first element will be 'node', the second element will be the name of the JavaScript file. 32 | The next elements will be any additional command line arguments. 33 | -} 34 | argv : List String 35 | argv = 36 | Native.Process.argv 37 | 38 | 39 | {-| A List containing only the additional command line arguments. 40 | -} 41 | args : List String 42 | args = 43 | List.drop 2 Native.Process.argv 44 | 45 | 46 | {-| The absolute pathname of the executable that started the process. 47 | -} 48 | execPath : String 49 | execPath = 50 | Native.Process.execPath 51 | 52 | 53 | {-| The set of node-specific command line options from the executable that started the process. 54 | -} 55 | execArgv : List String 56 | execArgv = 57 | Native.Process.execArgv 58 | 59 | 60 | {-| Run a command in a shell. 61 | -} 62 | exec : String -> Task String String 63 | exec command = 64 | Native.Process.exec command 65 | 66 | 67 | {-| Ends the process with the specified code. 68 | -} 69 | exit : Int -> Task x () 70 | exit code = 71 | Native.Process.exit code 72 | 73 | 74 | {-| The PID of the process. 75 | -} 76 | pid : Int 77 | pid = 78 | Native.Process.pid 79 | 80 | 81 | {-| A compiled-in property that exposes NODE_VERSION. 82 | -} 83 | version : String 84 | version = 85 | Native.Process.version 86 | -------------------------------------------------------------------------------- /src/Path.elm: -------------------------------------------------------------------------------- 1 | module Path 2 | exposing 3 | ( normalize 4 | , join 5 | , resolve 6 | , isAbsolute 7 | , relative 8 | , basename 9 | , extname 10 | , sep 11 | , delimiter 12 | ) 13 | 14 | {-| This module contains utilities for handling and transforming file paths. 15 | Almost all these methods perform only string transformations. 16 | The file system is not consulted to check whether paths are valid. 17 | 18 | @docs normalize, join, resolve, isAbsolute, relative 19 | @docs basename, extname, sep, delimiter 20 | 21 | -} 22 | 23 | import Native.Path 24 | 25 | 26 | {-| Normalize a string path, taking care of '..' and '.' parts. 27 | 28 | normalize "/foo/bar//baz/asdf/quux/.." == "/foo/bar/baz/asdf" 29 | -} 30 | normalize : String -> String 31 | normalize path = 32 | Native.Path.normalize path 33 | 34 | 35 | {-| Join a list of paths together and normalize the resulting path. 36 | 37 | join ["/foo", "bar", "baz/asdf", "quux", ".."] == "/foo/bar/baz/asdf" 38 | -} 39 | join : List String -> String 40 | join paths = 41 | Native.Path.join paths 42 | 43 | 44 | {-| Resolves a list of paths to an absolute path. 45 | 46 | resolve ["foo/bar", "/tmp/file/", "..", "a/../subfile"] == "/tmp/subfile" 47 | 48 | which is similar to 49 | 50 | cd foo/bar 51 | cd /tmp/file/ 52 | cd .. 53 | cd a/../subfile 54 | pwd 55 | -} 56 | resolve : List String -> String 57 | resolve paths = 58 | Native.Path.resolve paths 59 | 60 | 61 | {-| Determines whether a path will always resolve to the same location, 62 | regardless of the working directory. 63 | 64 | isAbsolute "/foo/bar" == true 65 | isAbsolute "/baz/.." == true 66 | isAbsolute "qux/" == false 67 | isAbsolute "." == false 68 | -} 69 | isAbsolute : String -> Bool 70 | isAbsolute path = 71 | Native.Path.isAbsolute path 72 | 73 | 74 | {-| Solve the relative path between two paths. 75 | 76 | relative "/data/orandea/test/aaa" "/data/orandea/impl/bbb" == "../../impl/bbb" 77 | -} 78 | relative : String -> String -> String 79 | relative from to = 80 | Native.Path.relative from to 81 | 82 | 83 | {-| Determine the directory name of a path. 84 | 85 | dirname "/foo/bar/baz/asdf/quux" == "/foo/bar/baz/asdf" 86 | -} 87 | dirname : String -> String 88 | dirname path = 89 | Native.Path.dirname path 90 | 91 | 92 | {-| Determine the last portion of a path. 93 | 94 | basename "/foo/bar/baz/asdf/quux.html" "" == "quux.html" 95 | basename "/foo/bar/baz/asdf/quux.html" ".html" == "quux" 96 | -} 97 | basename : String -> String -> String 98 | basename path ext = 99 | Native.Path.basename path ext 100 | 101 | 102 | {-| Determine the extension of the path. 103 | 104 | extname "index.html" == ".html" 105 | extname "index.coffee.md" == ".md" 106 | extname "index." == "." 107 | extname "index" == "" 108 | -} 109 | extname : String -> String 110 | extname path = 111 | Native.Path.extname path 112 | 113 | 114 | {-| The platform-specific file separator, '\\' or '/'. 115 | -} 116 | sep : String 117 | sep = 118 | Native.Path.sep 119 | 120 | 121 | {-| The platform-specific path delimiter, ; or ':'. 122 | -} 123 | delimiter : String 124 | delimiter = 125 | Native.Path.delimiter 126 | -------------------------------------------------------------------------------- /src/Url.elm: -------------------------------------------------------------------------------- 1 | module Url 2 | exposing 3 | ( resolve 4 | , join 5 | ) 6 | 7 | {-| Url 8 | 9 | @docs resolve, join 10 | 11 | -} 12 | 13 | import Native.Url 14 | import String 15 | 16 | 17 | {-| Resolve 18 | -} 19 | resolve : List String -> String 20 | resolve paths = 21 | Native.Url.resolve paths 22 | 23 | 24 | {-| Join 25 | -} 26 | join : List String -> String 27 | join paths = 28 | String.join "/" paths 29 | --------------------------------------------------------------------------------