🍴 Meu Garfo é uma visualização em grafo dos CNPJs
cuducos.tngl.io/meu-garfo
1(function(scope){
2'use strict';
3
4function F(arity, fun, wrapper) {
5 wrapper.a = arity;
6 wrapper.f = fun;
7 return wrapper;
8}
9
10function F2(fun) {
11 return F(2, fun, function(a) { return function(b) { return fun(a,b); }; })
12}
13function F3(fun) {
14 return F(3, fun, function(a) {
15 return function(b) { return function(c) { return fun(a, b, c); }; };
16 });
17}
18function F4(fun) {
19 return F(4, fun, function(a) { return function(b) { return function(c) {
20 return function(d) { return fun(a, b, c, d); }; }; };
21 });
22}
23function F5(fun) {
24 return F(5, fun, function(a) { return function(b) { return function(c) {
25 return function(d) { return function(e) { return fun(a, b, c, d, e); }; }; }; };
26 });
27}
28function F6(fun) {
29 return F(6, fun, function(a) { return function(b) { return function(c) {
30 return function(d) { return function(e) { return function(f) {
31 return fun(a, b, c, d, e, f); }; }; }; }; };
32 });
33}
34function F7(fun) {
35 return F(7, fun, function(a) { return function(b) { return function(c) {
36 return function(d) { return function(e) { return function(f) {
37 return function(g) { return fun(a, b, c, d, e, f, g); }; }; }; }; }; };
38 });
39}
40function F8(fun) {
41 return F(8, fun, function(a) { return function(b) { return function(c) {
42 return function(d) { return function(e) { return function(f) {
43 return function(g) { return function(h) {
44 return fun(a, b, c, d, e, f, g, h); }; }; }; }; }; }; };
45 });
46}
47function F9(fun) {
48 return F(9, fun, function(a) { return function(b) { return function(c) {
49 return function(d) { return function(e) { return function(f) {
50 return function(g) { return function(h) { return function(i) {
51 return fun(a, b, c, d, e, f, g, h, i); }; }; }; }; }; }; }; };
52 });
53}
54
55function A2(fun, a, b) {
56 return fun.a === 2 ? fun.f(a, b) : fun(a)(b);
57}
58function A3(fun, a, b, c) {
59 return fun.a === 3 ? fun.f(a, b, c) : fun(a)(b)(c);
60}
61function A4(fun, a, b, c, d) {
62 return fun.a === 4 ? fun.f(a, b, c, d) : fun(a)(b)(c)(d);
63}
64function A5(fun, a, b, c, d, e) {
65 return fun.a === 5 ? fun.f(a, b, c, d, e) : fun(a)(b)(c)(d)(e);
66}
67function A6(fun, a, b, c, d, e, f) {
68 return fun.a === 6 ? fun.f(a, b, c, d, e, f) : fun(a)(b)(c)(d)(e)(f);
69}
70function A7(fun, a, b, c, d, e, f, g) {
71 return fun.a === 7 ? fun.f(a, b, c, d, e, f, g) : fun(a)(b)(c)(d)(e)(f)(g);
72}
73function A8(fun, a, b, c, d, e, f, g, h) {
74 return fun.a === 8 ? fun.f(a, b, c, d, e, f, g, h) : fun(a)(b)(c)(d)(e)(f)(g)(h);
75}
76function A9(fun, a, b, c, d, e, f, g, h, i) {
77 return fun.a === 9 ? fun.f(a, b, c, d, e, f, g, h, i) : fun(a)(b)(c)(d)(e)(f)(g)(h)(i);
78}
79
80console.warn('Compiled in DEV mode. Follow the advice at https://elm-lang.org/0.19.1/optimize for better performance and smaller assets.');
81
82
83var _JsArray_empty = [];
84
85function _JsArray_singleton(value)
86{
87 return [value];
88}
89
90function _JsArray_length(array)
91{
92 return array.length;
93}
94
95var _JsArray_initialize = F3(function(size, offset, func)
96{
97 var result = new Array(size);
98
99 for (var i = 0; i < size; i++)
100 {
101 result[i] = func(offset + i);
102 }
103
104 return result;
105});
106
107var _JsArray_initializeFromList = F2(function (max, ls)
108{
109 var result = new Array(max);
110
111 for (var i = 0; i < max && ls.b; i++)
112 {
113 result[i] = ls.a;
114 ls = ls.b;
115 }
116
117 result.length = i;
118 return _Utils_Tuple2(result, ls);
119});
120
121var _JsArray_unsafeGet = F2(function(index, array)
122{
123 return array[index];
124});
125
126var _JsArray_unsafeSet = F3(function(index, value, array)
127{
128 var length = array.length;
129 var result = new Array(length);
130
131 for (var i = 0; i < length; i++)
132 {
133 result[i] = array[i];
134 }
135
136 result[index] = value;
137 return result;
138});
139
140var _JsArray_push = F2(function(value, array)
141{
142 var length = array.length;
143 var result = new Array(length + 1);
144
145 for (var i = 0; i < length; i++)
146 {
147 result[i] = array[i];
148 }
149
150 result[length] = value;
151 return result;
152});
153
154var _JsArray_foldl = F3(function(func, acc, array)
155{
156 var length = array.length;
157
158 for (var i = 0; i < length; i++)
159 {
160 acc = A2(func, array[i], acc);
161 }
162
163 return acc;
164});
165
166var _JsArray_foldr = F3(function(func, acc, array)
167{
168 for (var i = array.length - 1; i >= 0; i--)
169 {
170 acc = A2(func, array[i], acc);
171 }
172
173 return acc;
174});
175
176var _JsArray_map = F2(function(func, array)
177{
178 var length = array.length;
179 var result = new Array(length);
180
181 for (var i = 0; i < length; i++)
182 {
183 result[i] = func(array[i]);
184 }
185
186 return result;
187});
188
189var _JsArray_indexedMap = F3(function(func, offset, array)
190{
191 var length = array.length;
192 var result = new Array(length);
193
194 for (var i = 0; i < length; i++)
195 {
196 result[i] = A2(func, offset + i, array[i]);
197 }
198
199 return result;
200});
201
202var _JsArray_slice = F3(function(from, to, array)
203{
204 return array.slice(from, to);
205});
206
207var _JsArray_appendN = F3(function(n, dest, source)
208{
209 var destLen = dest.length;
210 var itemsToCopy = n - destLen;
211
212 if (itemsToCopy > source.length)
213 {
214 itemsToCopy = source.length;
215 }
216
217 var size = destLen + itemsToCopy;
218 var result = new Array(size);
219
220 for (var i = 0; i < destLen; i++)
221 {
222 result[i] = dest[i];
223 }
224
225 for (var i = 0; i < itemsToCopy; i++)
226 {
227 result[i + destLen] = source[i];
228 }
229
230 return result;
231});
232
233
234
235// LOG
236
237var _Debug_log_UNUSED = F2(function(tag, value)
238{
239 return value;
240});
241
242var _Debug_log = F2(function(tag, value)
243{
244 console.log(tag + ': ' + _Debug_toString(value));
245 return value;
246});
247
248
249// TODOS
250
251function _Debug_todo(moduleName, region)
252{
253 return function(message) {
254 _Debug_crash(8, moduleName, region, message);
255 };
256}
257
258function _Debug_todoCase(moduleName, region, value)
259{
260 return function(message) {
261 _Debug_crash(9, moduleName, region, value, message);
262 };
263}
264
265
266// TO STRING
267
268function _Debug_toString_UNUSED(value)
269{
270 return '<internals>';
271}
272
273function _Debug_toString(value)
274{
275 return _Debug_toAnsiString(false, value);
276}
277
278function _Debug_toAnsiString(ansi, value)
279{
280 if (typeof value === 'function')
281 {
282 return _Debug_internalColor(ansi, '<function>');
283 }
284
285 if (typeof value === 'boolean')
286 {
287 return _Debug_ctorColor(ansi, value ? 'True' : 'False');
288 }
289
290 if (typeof value === 'number')
291 {
292 return _Debug_numberColor(ansi, value + '');
293 }
294
295 if (value instanceof String)
296 {
297 return _Debug_charColor(ansi, "'" + _Debug_addSlashes(value, true) + "'");
298 }
299
300 if (typeof value === 'string')
301 {
302 return _Debug_stringColor(ansi, '"' + _Debug_addSlashes(value, false) + '"');
303 }
304
305 if (typeof value === 'object' && '$' in value)
306 {
307 var tag = value.$;
308
309 if (typeof tag === 'number')
310 {
311 return _Debug_internalColor(ansi, '<internals>');
312 }
313
314 if (tag[0] === '#')
315 {
316 var output = [];
317 for (var k in value)
318 {
319 if (k === '$') continue;
320 output.push(_Debug_toAnsiString(ansi, value[k]));
321 }
322 return '(' + output.join(',') + ')';
323 }
324
325 if (tag === 'Set_elm_builtin')
326 {
327 return _Debug_ctorColor(ansi, 'Set')
328 + _Debug_fadeColor(ansi, '.fromList') + ' '
329 + _Debug_toAnsiString(ansi, $elm$core$Set$toList(value));
330 }
331
332 if (tag === 'RBNode_elm_builtin' || tag === 'RBEmpty_elm_builtin')
333 {
334 return _Debug_ctorColor(ansi, 'Dict')
335 + _Debug_fadeColor(ansi, '.fromList') + ' '
336 + _Debug_toAnsiString(ansi, $elm$core$Dict$toList(value));
337 }
338
339 if (tag === 'Array_elm_builtin')
340 {
341 return _Debug_ctorColor(ansi, 'Array')
342 + _Debug_fadeColor(ansi, '.fromList') + ' '
343 + _Debug_toAnsiString(ansi, $elm$core$Array$toList(value));
344 }
345
346 if (tag === '::' || tag === '[]')
347 {
348 var output = '[';
349
350 value.b && (output += _Debug_toAnsiString(ansi, value.a), value = value.b)
351
352 for (; value.b; value = value.b) // WHILE_CONS
353 {
354 output += ',' + _Debug_toAnsiString(ansi, value.a);
355 }
356 return output + ']';
357 }
358
359 var output = '';
360 for (var i in value)
361 {
362 if (i === '$') continue;
363 var str = _Debug_toAnsiString(ansi, value[i]);
364 var c0 = str[0];
365 var parenless = c0 === '{' || c0 === '(' || c0 === '[' || c0 === '<' || c0 === '"' || str.indexOf(' ') < 0;
366 output += ' ' + (parenless ? str : '(' + str + ')');
367 }
368 return _Debug_ctorColor(ansi, tag) + output;
369 }
370
371 if (typeof DataView === 'function' && value instanceof DataView)
372 {
373 return _Debug_stringColor(ansi, '<' + value.byteLength + ' bytes>');
374 }
375
376 if (typeof File !== 'undefined' && value instanceof File)
377 {
378 return _Debug_internalColor(ansi, '<' + value.name + '>');
379 }
380
381 if (typeof value === 'object')
382 {
383 var output = [];
384 for (var key in value)
385 {
386 var field = key[0] === '_' ? key.slice(1) : key;
387 output.push(_Debug_fadeColor(ansi, field) + ' = ' + _Debug_toAnsiString(ansi, value[key]));
388 }
389 if (output.length === 0)
390 {
391 return '{}';
392 }
393 return '{ ' + output.join(', ') + ' }';
394 }
395
396 return _Debug_internalColor(ansi, '<internals>');
397}
398
399function _Debug_addSlashes(str, isChar)
400{
401 var s = str
402 .replace(/\\/g, '\\\\')
403 .replace(/\n/g, '\\n')
404 .replace(/\t/g, '\\t')
405 .replace(/\r/g, '\\r')
406 .replace(/\v/g, '\\v')
407 .replace(/\0/g, '\\0');
408
409 if (isChar)
410 {
411 return s.replace(/\'/g, '\\\'');
412 }
413 else
414 {
415 return s.replace(/\"/g, '\\"');
416 }
417}
418
419function _Debug_ctorColor(ansi, string)
420{
421 return ansi ? '\x1b[96m' + string + '\x1b[0m' : string;
422}
423
424function _Debug_numberColor(ansi, string)
425{
426 return ansi ? '\x1b[95m' + string + '\x1b[0m' : string;
427}
428
429function _Debug_stringColor(ansi, string)
430{
431 return ansi ? '\x1b[93m' + string + '\x1b[0m' : string;
432}
433
434function _Debug_charColor(ansi, string)
435{
436 return ansi ? '\x1b[92m' + string + '\x1b[0m' : string;
437}
438
439function _Debug_fadeColor(ansi, string)
440{
441 return ansi ? '\x1b[37m' + string + '\x1b[0m' : string;
442}
443
444function _Debug_internalColor(ansi, string)
445{
446 return ansi ? '\x1b[36m' + string + '\x1b[0m' : string;
447}
448
449function _Debug_toHexDigit(n)
450{
451 return String.fromCharCode(n < 10 ? 48 + n : 55 + n);
452}
453
454
455// CRASH
456
457
458function _Debug_crash_UNUSED(identifier)
459{
460 throw new Error('https://github.com/elm/core/blob/1.0.0/hints/' + identifier + '.md');
461}
462
463
464function _Debug_crash(identifier, fact1, fact2, fact3, fact4)
465{
466 switch(identifier)
467 {
468 case 0:
469 throw new Error('What node should I take over? In JavaScript I need something like:\n\n Elm.Main.init({\n node: document.getElementById("elm-node")\n })\n\nYou need to do this with any Browser.sandbox or Browser.element program.');
470
471 case 1:
472 throw new Error('Browser.application programs cannot handle URLs like this:\n\n ' + document.location.href + '\n\nWhat is the root? The root of your file system? Try looking at this program with `elm reactor` or some other server.');
473
474 case 2:
475 var jsonErrorString = fact1;
476 throw new Error('Problem with the flags given to your Elm program on initialization.\n\n' + jsonErrorString);
477
478 case 3:
479 var portName = fact1;
480 throw new Error('There can only be one port named `' + portName + '`, but your program has multiple.');
481
482 case 4:
483 var portName = fact1;
484 var problem = fact2;
485 throw new Error('Trying to send an unexpected type of value through port `' + portName + '`:\n' + problem);
486
487 case 5:
488 throw new Error('Trying to use `(==)` on functions.\nThere is no way to know if functions are "the same" in the Elm sense.\nRead more about this at https://package.elm-lang.org/packages/elm/core/latest/Basics#== which describes why it is this way and what the better version will look like.');
489
490 case 6:
491 var moduleName = fact1;
492 throw new Error('Your page is loading multiple Elm scripts with a module named ' + moduleName + '. Maybe a duplicate script is getting loaded accidentally? If not, rename one of them so I know which is which!');
493
494 case 8:
495 var moduleName = fact1;
496 var region = fact2;
497 var message = fact3;
498 throw new Error('TODO in module `' + moduleName + '` ' + _Debug_regionToString(region) + '\n\n' + message);
499
500 case 9:
501 var moduleName = fact1;
502 var region = fact2;
503 var value = fact3;
504 var message = fact4;
505 throw new Error(
506 'TODO in module `' + moduleName + '` from the `case` expression '
507 + _Debug_regionToString(region) + '\n\nIt received the following value:\n\n '
508 + _Debug_toString(value).replace('\n', '\n ')
509 + '\n\nBut the branch that handles it says:\n\n ' + message.replace('\n', '\n ')
510 );
511
512 case 10:
513 throw new Error('Bug in https://github.com/elm/virtual-dom/issues');
514
515 case 11:
516 throw new Error('Cannot perform mod 0. Division by zero error.');
517 }
518}
519
520function _Debug_regionToString(region)
521{
522 if (region.start.line === region.end.line)
523 {
524 return 'on line ' + region.start.line;
525 }
526 return 'on lines ' + region.start.line + ' through ' + region.end.line;
527}
528
529
530
531// EQUALITY
532
533function _Utils_eq(x, y)
534{
535 for (
536 var pair, stack = [], isEqual = _Utils_eqHelp(x, y, 0, stack);
537 isEqual && (pair = stack.pop());
538 isEqual = _Utils_eqHelp(pair.a, pair.b, 0, stack)
539 )
540 {}
541
542 return isEqual;
543}
544
545function _Utils_eqHelp(x, y, depth, stack)
546{
547 if (x === y)
548 {
549 return true;
550 }
551
552 if (typeof x !== 'object' || x === null || y === null)
553 {
554 typeof x === 'function' && _Debug_crash(5);
555 return false;
556 }
557
558 if (depth > 100)
559 {
560 stack.push(_Utils_Tuple2(x,y));
561 return true;
562 }
563
564 /**/
565 if (x.$ === 'Set_elm_builtin')
566 {
567 x = $elm$core$Set$toList(x);
568 y = $elm$core$Set$toList(y);
569 }
570 if (x.$ === 'RBNode_elm_builtin' || x.$ === 'RBEmpty_elm_builtin')
571 {
572 x = $elm$core$Dict$toList(x);
573 y = $elm$core$Dict$toList(y);
574 }
575 //*/
576
577 /**_UNUSED/
578 if (x.$ < 0)
579 {
580 x = $elm$core$Dict$toList(x);
581 y = $elm$core$Dict$toList(y);
582 }
583 //*/
584
585 for (var key in x)
586 {
587 if (!_Utils_eqHelp(x[key], y[key], depth + 1, stack))
588 {
589 return false;
590 }
591 }
592 return true;
593}
594
595var _Utils_equal = F2(_Utils_eq);
596var _Utils_notEqual = F2(function(a, b) { return !_Utils_eq(a,b); });
597
598
599
600// COMPARISONS
601
602// Code in Generate/JavaScript.hs, Basics.js, and List.js depends on
603// the particular integer values assigned to LT, EQ, and GT.
604
605function _Utils_cmp(x, y, ord)
606{
607 if (typeof x !== 'object')
608 {
609 return x === y ? /*EQ*/ 0 : x < y ? /*LT*/ -1 : /*GT*/ 1;
610 }
611
612 /**/
613 if (x instanceof String)
614 {
615 var a = x.valueOf();
616 var b = y.valueOf();
617 return a === b ? 0 : a < b ? -1 : 1;
618 }
619 //*/
620
621 /**_UNUSED/
622 if (typeof x.$ === 'undefined')
623 //*/
624 /**/
625 if (x.$[0] === '#')
626 //*/
627 {
628 return (ord = _Utils_cmp(x.a, y.a))
629 ? ord
630 : (ord = _Utils_cmp(x.b, y.b))
631 ? ord
632 : _Utils_cmp(x.c, y.c);
633 }
634
635 // traverse conses until end of a list or a mismatch
636 for (; x.b && y.b && !(ord = _Utils_cmp(x.a, y.a)); x = x.b, y = y.b) {} // WHILE_CONSES
637 return ord || (x.b ? /*GT*/ 1 : y.b ? /*LT*/ -1 : /*EQ*/ 0);
638}
639
640var _Utils_lt = F2(function(a, b) { return _Utils_cmp(a, b) < 0; });
641var _Utils_le = F2(function(a, b) { return _Utils_cmp(a, b) < 1; });
642var _Utils_gt = F2(function(a, b) { return _Utils_cmp(a, b) > 0; });
643var _Utils_ge = F2(function(a, b) { return _Utils_cmp(a, b) >= 0; });
644
645var _Utils_compare = F2(function(x, y)
646{
647 var n = _Utils_cmp(x, y);
648 return n < 0 ? $elm$core$Basics$LT : n ? $elm$core$Basics$GT : $elm$core$Basics$EQ;
649});
650
651
652// COMMON VALUES
653
654var _Utils_Tuple0_UNUSED = 0;
655var _Utils_Tuple0 = { $: '#0' };
656
657function _Utils_Tuple2_UNUSED(a, b) { return { a: a, b: b }; }
658function _Utils_Tuple2(a, b) { return { $: '#2', a: a, b: b }; }
659
660function _Utils_Tuple3_UNUSED(a, b, c) { return { a: a, b: b, c: c }; }
661function _Utils_Tuple3(a, b, c) { return { $: '#3', a: a, b: b, c: c }; }
662
663function _Utils_chr_UNUSED(c) { return c; }
664function _Utils_chr(c) { return new String(c); }
665
666
667// RECORDS
668
669function _Utils_update(oldRecord, updatedFields)
670{
671 var newRecord = {};
672
673 for (var key in oldRecord)
674 {
675 newRecord[key] = oldRecord[key];
676 }
677
678 for (var key in updatedFields)
679 {
680 newRecord[key] = updatedFields[key];
681 }
682
683 return newRecord;
684}
685
686
687// APPEND
688
689var _Utils_append = F2(_Utils_ap);
690
691function _Utils_ap(xs, ys)
692{
693 // append Strings
694 if (typeof xs === 'string')
695 {
696 return xs + ys;
697 }
698
699 // append Lists
700 if (!xs.b)
701 {
702 return ys;
703 }
704 var root = _List_Cons(xs.a, ys);
705 xs = xs.b
706 for (var curr = root; xs.b; xs = xs.b) // WHILE_CONS
707 {
708 curr = curr.b = _List_Cons(xs.a, ys);
709 }
710 return root;
711}
712
713
714
715var _List_Nil_UNUSED = { $: 0 };
716var _List_Nil = { $: '[]' };
717
718function _List_Cons_UNUSED(hd, tl) { return { $: 1, a: hd, b: tl }; }
719function _List_Cons(hd, tl) { return { $: '::', a: hd, b: tl }; }
720
721
722var _List_cons = F2(_List_Cons);
723
724function _List_fromArray(arr)
725{
726 var out = _List_Nil;
727 for (var i = arr.length; i--; )
728 {
729 out = _List_Cons(arr[i], out);
730 }
731 return out;
732}
733
734function _List_toArray(xs)
735{
736 for (var out = []; xs.b; xs = xs.b) // WHILE_CONS
737 {
738 out.push(xs.a);
739 }
740 return out;
741}
742
743var _List_map2 = F3(function(f, xs, ys)
744{
745 for (var arr = []; xs.b && ys.b; xs = xs.b, ys = ys.b) // WHILE_CONSES
746 {
747 arr.push(A2(f, xs.a, ys.a));
748 }
749 return _List_fromArray(arr);
750});
751
752var _List_map3 = F4(function(f, xs, ys, zs)
753{
754 for (var arr = []; xs.b && ys.b && zs.b; xs = xs.b, ys = ys.b, zs = zs.b) // WHILE_CONSES
755 {
756 arr.push(A3(f, xs.a, ys.a, zs.a));
757 }
758 return _List_fromArray(arr);
759});
760
761var _List_map4 = F5(function(f, ws, xs, ys, zs)
762{
763 for (var arr = []; ws.b && xs.b && ys.b && zs.b; ws = ws.b, xs = xs.b, ys = ys.b, zs = zs.b) // WHILE_CONSES
764 {
765 arr.push(A4(f, ws.a, xs.a, ys.a, zs.a));
766 }
767 return _List_fromArray(arr);
768});
769
770var _List_map5 = F6(function(f, vs, ws, xs, ys, zs)
771{
772 for (var arr = []; vs.b && ws.b && xs.b && ys.b && zs.b; vs = vs.b, ws = ws.b, xs = xs.b, ys = ys.b, zs = zs.b) // WHILE_CONSES
773 {
774 arr.push(A5(f, vs.a, ws.a, xs.a, ys.a, zs.a));
775 }
776 return _List_fromArray(arr);
777});
778
779var _List_sortBy = F2(function(f, xs)
780{
781 return _List_fromArray(_List_toArray(xs).sort(function(a, b) {
782 return _Utils_cmp(f(a), f(b));
783 }));
784});
785
786var _List_sortWith = F2(function(f, xs)
787{
788 return _List_fromArray(_List_toArray(xs).sort(function(a, b) {
789 var ord = A2(f, a, b);
790 return ord === $elm$core$Basics$EQ ? 0 : ord === $elm$core$Basics$LT ? -1 : 1;
791 }));
792});
793
794
795
796// MATH
797
798var _Basics_add = F2(function(a, b) { return a + b; });
799var _Basics_sub = F2(function(a, b) { return a - b; });
800var _Basics_mul = F2(function(a, b) { return a * b; });
801var _Basics_fdiv = F2(function(a, b) { return a / b; });
802var _Basics_idiv = F2(function(a, b) { return (a / b) | 0; });
803var _Basics_pow = F2(Math.pow);
804
805var _Basics_remainderBy = F2(function(b, a) { return a % b; });
806
807// https://www.microsoft.com/en-us/research/wp-content/uploads/2016/02/divmodnote-letter.pdf
808var _Basics_modBy = F2(function(modulus, x)
809{
810 var answer = x % modulus;
811 return modulus === 0
812 ? _Debug_crash(11)
813 :
814 ((answer > 0 && modulus < 0) || (answer < 0 && modulus > 0))
815 ? answer + modulus
816 : answer;
817});
818
819
820// TRIGONOMETRY
821
822var _Basics_pi = Math.PI;
823var _Basics_e = Math.E;
824var _Basics_cos = Math.cos;
825var _Basics_sin = Math.sin;
826var _Basics_tan = Math.tan;
827var _Basics_acos = Math.acos;
828var _Basics_asin = Math.asin;
829var _Basics_atan = Math.atan;
830var _Basics_atan2 = F2(Math.atan2);
831
832
833// MORE MATH
834
835function _Basics_toFloat(x) { return x; }
836function _Basics_truncate(n) { return n | 0; }
837function _Basics_isInfinite(n) { return n === Infinity || n === -Infinity; }
838
839var _Basics_ceiling = Math.ceil;
840var _Basics_floor = Math.floor;
841var _Basics_round = Math.round;
842var _Basics_sqrt = Math.sqrt;
843var _Basics_log = Math.log;
844var _Basics_isNaN = isNaN;
845
846
847// BOOLEANS
848
849function _Basics_not(bool) { return !bool; }
850var _Basics_and = F2(function(a, b) { return a && b; });
851var _Basics_or = F2(function(a, b) { return a || b; });
852var _Basics_xor = F2(function(a, b) { return a !== b; });
853
854
855
856var _String_cons = F2(function(chr, str)
857{
858 return chr + str;
859});
860
861function _String_uncons(string)
862{
863 var word = string.charCodeAt(0);
864 return !isNaN(word)
865 ? $elm$core$Maybe$Just(
866 0xD800 <= word && word <= 0xDBFF
867 ? _Utils_Tuple2(_Utils_chr(string[0] + string[1]), string.slice(2))
868 : _Utils_Tuple2(_Utils_chr(string[0]), string.slice(1))
869 )
870 : $elm$core$Maybe$Nothing;
871}
872
873var _String_append = F2(function(a, b)
874{
875 return a + b;
876});
877
878function _String_length(str)
879{
880 return str.length;
881}
882
883var _String_map = F2(function(func, string)
884{
885 var len = string.length;
886 var array = new Array(len);
887 var i = 0;
888 while (i < len)
889 {
890 var word = string.charCodeAt(i);
891 if (0xD800 <= word && word <= 0xDBFF)
892 {
893 array[i] = func(_Utils_chr(string[i] + string[i+1]));
894 i += 2;
895 continue;
896 }
897 array[i] = func(_Utils_chr(string[i]));
898 i++;
899 }
900 return array.join('');
901});
902
903var _String_filter = F2(function(isGood, str)
904{
905 var arr = [];
906 var len = str.length;
907 var i = 0;
908 while (i < len)
909 {
910 var char = str[i];
911 var word = str.charCodeAt(i);
912 i++;
913 if (0xD800 <= word && word <= 0xDBFF)
914 {
915 char += str[i];
916 i++;
917 }
918
919 if (isGood(_Utils_chr(char)))
920 {
921 arr.push(char);
922 }
923 }
924 return arr.join('');
925});
926
927function _String_reverse(str)
928{
929 var len = str.length;
930 var arr = new Array(len);
931 var i = 0;
932 while (i < len)
933 {
934 var word = str.charCodeAt(i);
935 if (0xD800 <= word && word <= 0xDBFF)
936 {
937 arr[len - i] = str[i + 1];
938 i++;
939 arr[len - i] = str[i - 1];
940 i++;
941 }
942 else
943 {
944 arr[len - i] = str[i];
945 i++;
946 }
947 }
948 return arr.join('');
949}
950
951var _String_foldl = F3(function(func, state, string)
952{
953 var len = string.length;
954 var i = 0;
955 while (i < len)
956 {
957 var char = string[i];
958 var word = string.charCodeAt(i);
959 i++;
960 if (0xD800 <= word && word <= 0xDBFF)
961 {
962 char += string[i];
963 i++;
964 }
965 state = A2(func, _Utils_chr(char), state);
966 }
967 return state;
968});
969
970var _String_foldr = F3(function(func, state, string)
971{
972 var i = string.length;
973 while (i--)
974 {
975 var char = string[i];
976 var word = string.charCodeAt(i);
977 if (0xDC00 <= word && word <= 0xDFFF)
978 {
979 i--;
980 char = string[i] + char;
981 }
982 state = A2(func, _Utils_chr(char), state);
983 }
984 return state;
985});
986
987var _String_split = F2(function(sep, str)
988{
989 return str.split(sep);
990});
991
992var _String_join = F2(function(sep, strs)
993{
994 return strs.join(sep);
995});
996
997var _String_slice = F3(function(start, end, str) {
998 return str.slice(start, end);
999});
1000
1001function _String_trim(str)
1002{
1003 return str.trim();
1004}
1005
1006function _String_trimLeft(str)
1007{
1008 return str.replace(/^\s+/, '');
1009}
1010
1011function _String_trimRight(str)
1012{
1013 return str.replace(/\s+$/, '');
1014}
1015
1016function _String_words(str)
1017{
1018 return _List_fromArray(str.trim().split(/\s+/g));
1019}
1020
1021function _String_lines(str)
1022{
1023 return _List_fromArray(str.split(/\r\n|\r|\n/g));
1024}
1025
1026function _String_toUpper(str)
1027{
1028 return str.toUpperCase();
1029}
1030
1031function _String_toLower(str)
1032{
1033 return str.toLowerCase();
1034}
1035
1036var _String_any = F2(function(isGood, string)
1037{
1038 var i = string.length;
1039 while (i--)
1040 {
1041 var char = string[i];
1042 var word = string.charCodeAt(i);
1043 if (0xDC00 <= word && word <= 0xDFFF)
1044 {
1045 i--;
1046 char = string[i] + char;
1047 }
1048 if (isGood(_Utils_chr(char)))
1049 {
1050 return true;
1051 }
1052 }
1053 return false;
1054});
1055
1056var _String_all = F2(function(isGood, string)
1057{
1058 var i = string.length;
1059 while (i--)
1060 {
1061 var char = string[i];
1062 var word = string.charCodeAt(i);
1063 if (0xDC00 <= word && word <= 0xDFFF)
1064 {
1065 i--;
1066 char = string[i] + char;
1067 }
1068 if (!isGood(_Utils_chr(char)))
1069 {
1070 return false;
1071 }
1072 }
1073 return true;
1074});
1075
1076var _String_contains = F2(function(sub, str)
1077{
1078 return str.indexOf(sub) > -1;
1079});
1080
1081var _String_startsWith = F2(function(sub, str)
1082{
1083 return str.indexOf(sub) === 0;
1084});
1085
1086var _String_endsWith = F2(function(sub, str)
1087{
1088 return str.length >= sub.length &&
1089 str.lastIndexOf(sub) === str.length - sub.length;
1090});
1091
1092var _String_indexes = F2(function(sub, str)
1093{
1094 var subLen = sub.length;
1095
1096 if (subLen < 1)
1097 {
1098 return _List_Nil;
1099 }
1100
1101 var i = 0;
1102 var is = [];
1103
1104 while ((i = str.indexOf(sub, i)) > -1)
1105 {
1106 is.push(i);
1107 i = i + subLen;
1108 }
1109
1110 return _List_fromArray(is);
1111});
1112
1113
1114// TO STRING
1115
1116function _String_fromNumber(number)
1117{
1118 return number + '';
1119}
1120
1121
1122// INT CONVERSIONS
1123
1124function _String_toInt(str)
1125{
1126 var total = 0;
1127 var code0 = str.charCodeAt(0);
1128 var start = code0 == 0x2B /* + */ || code0 == 0x2D /* - */ ? 1 : 0;
1129
1130 for (var i = start; i < str.length; ++i)
1131 {
1132 var code = str.charCodeAt(i);
1133 if (code < 0x30 || 0x39 < code)
1134 {
1135 return $elm$core$Maybe$Nothing;
1136 }
1137 total = 10 * total + code - 0x30;
1138 }
1139
1140 return i == start
1141 ? $elm$core$Maybe$Nothing
1142 : $elm$core$Maybe$Just(code0 == 0x2D ? -total : total);
1143}
1144
1145
1146// FLOAT CONVERSIONS
1147
1148function _String_toFloat(s)
1149{
1150 // check if it is a hex, octal, or binary number
1151 if (s.length === 0 || /[\sxbo]/.test(s))
1152 {
1153 return $elm$core$Maybe$Nothing;
1154 }
1155 var n = +s;
1156 // faster isNaN check
1157 return n === n ? $elm$core$Maybe$Just(n) : $elm$core$Maybe$Nothing;
1158}
1159
1160function _String_fromList(chars)
1161{
1162 return _List_toArray(chars).join('');
1163}
1164
1165
1166
1167
1168function _Char_toCode(char)
1169{
1170 var code = char.charCodeAt(0);
1171 if (0xD800 <= code && code <= 0xDBFF)
1172 {
1173 return (code - 0xD800) * 0x400 + char.charCodeAt(1) - 0xDC00 + 0x10000
1174 }
1175 return code;
1176}
1177
1178function _Char_fromCode(code)
1179{
1180 return _Utils_chr(
1181 (code < 0 || 0x10FFFF < code)
1182 ? '\uFFFD'
1183 :
1184 (code <= 0xFFFF)
1185 ? String.fromCharCode(code)
1186 :
1187 (code -= 0x10000,
1188 String.fromCharCode(Math.floor(code / 0x400) + 0xD800, code % 0x400 + 0xDC00)
1189 )
1190 );
1191}
1192
1193function _Char_toUpper(char)
1194{
1195 return _Utils_chr(char.toUpperCase());
1196}
1197
1198function _Char_toLower(char)
1199{
1200 return _Utils_chr(char.toLowerCase());
1201}
1202
1203function _Char_toLocaleUpper(char)
1204{
1205 return _Utils_chr(char.toLocaleUpperCase());
1206}
1207
1208function _Char_toLocaleLower(char)
1209{
1210 return _Utils_chr(char.toLocaleLowerCase());
1211}
1212
1213
1214
1215/**/
1216function _Json_errorToString(error)
1217{
1218 return $elm$json$Json$Decode$errorToString(error);
1219}
1220//*/
1221
1222
1223// CORE DECODERS
1224
1225function _Json_succeed(msg)
1226{
1227 return {
1228 $: 0,
1229 a: msg
1230 };
1231}
1232
1233function _Json_fail(msg)
1234{
1235 return {
1236 $: 1,
1237 a: msg
1238 };
1239}
1240
1241function _Json_decodePrim(decoder)
1242{
1243 return { $: 2, b: decoder };
1244}
1245
1246var _Json_decodeInt = _Json_decodePrim(function(value) {
1247 return (typeof value !== 'number')
1248 ? _Json_expecting('an INT', value)
1249 :
1250 (-2147483647 < value && value < 2147483647 && (value | 0) === value)
1251 ? $elm$core$Result$Ok(value)
1252 :
1253 (isFinite(value) && !(value % 1))
1254 ? $elm$core$Result$Ok(value)
1255 : _Json_expecting('an INT', value);
1256});
1257
1258var _Json_decodeBool = _Json_decodePrim(function(value) {
1259 return (typeof value === 'boolean')
1260 ? $elm$core$Result$Ok(value)
1261 : _Json_expecting('a BOOL', value);
1262});
1263
1264var _Json_decodeFloat = _Json_decodePrim(function(value) {
1265 return (typeof value === 'number')
1266 ? $elm$core$Result$Ok(value)
1267 : _Json_expecting('a FLOAT', value);
1268});
1269
1270var _Json_decodeValue = _Json_decodePrim(function(value) {
1271 return $elm$core$Result$Ok(_Json_wrap(value));
1272});
1273
1274var _Json_decodeString = _Json_decodePrim(function(value) {
1275 return (typeof value === 'string')
1276 ? $elm$core$Result$Ok(value)
1277 : (value instanceof String)
1278 ? $elm$core$Result$Ok(value + '')
1279 : _Json_expecting('a STRING', value);
1280});
1281
1282function _Json_decodeList(decoder) { return { $: 3, b: decoder }; }
1283function _Json_decodeArray(decoder) { return { $: 4, b: decoder }; }
1284
1285function _Json_decodeNull(value) { return { $: 5, c: value }; }
1286
1287var _Json_decodeField = F2(function(field, decoder)
1288{
1289 return {
1290 $: 6,
1291 d: field,
1292 b: decoder
1293 };
1294});
1295
1296var _Json_decodeIndex = F2(function(index, decoder)
1297{
1298 return {
1299 $: 7,
1300 e: index,
1301 b: decoder
1302 };
1303});
1304
1305function _Json_decodeKeyValuePairs(decoder)
1306{
1307 return {
1308 $: 8,
1309 b: decoder
1310 };
1311}
1312
1313function _Json_mapMany(f, decoders)
1314{
1315 return {
1316 $: 9,
1317 f: f,
1318 g: decoders
1319 };
1320}
1321
1322var _Json_andThen = F2(function(callback, decoder)
1323{
1324 return {
1325 $: 10,
1326 b: decoder,
1327 h: callback
1328 };
1329});
1330
1331function _Json_oneOf(decoders)
1332{
1333 return {
1334 $: 11,
1335 g: decoders
1336 };
1337}
1338
1339
1340// DECODING OBJECTS
1341
1342var _Json_map1 = F2(function(f, d1)
1343{
1344 return _Json_mapMany(f, [d1]);
1345});
1346
1347var _Json_map2 = F3(function(f, d1, d2)
1348{
1349 return _Json_mapMany(f, [d1, d2]);
1350});
1351
1352var _Json_map3 = F4(function(f, d1, d2, d3)
1353{
1354 return _Json_mapMany(f, [d1, d2, d3]);
1355});
1356
1357var _Json_map4 = F5(function(f, d1, d2, d3, d4)
1358{
1359 return _Json_mapMany(f, [d1, d2, d3, d4]);
1360});
1361
1362var _Json_map5 = F6(function(f, d1, d2, d3, d4, d5)
1363{
1364 return _Json_mapMany(f, [d1, d2, d3, d4, d5]);
1365});
1366
1367var _Json_map6 = F7(function(f, d1, d2, d3, d4, d5, d6)
1368{
1369 return _Json_mapMany(f, [d1, d2, d3, d4, d5, d6]);
1370});
1371
1372var _Json_map7 = F8(function(f, d1, d2, d3, d4, d5, d6, d7)
1373{
1374 return _Json_mapMany(f, [d1, d2, d3, d4, d5, d6, d7]);
1375});
1376
1377var _Json_map8 = F9(function(f, d1, d2, d3, d4, d5, d6, d7, d8)
1378{
1379 return _Json_mapMany(f, [d1, d2, d3, d4, d5, d6, d7, d8]);
1380});
1381
1382
1383// DECODE
1384
1385var _Json_runOnString = F2(function(decoder, string)
1386{
1387 try
1388 {
1389 var value = JSON.parse(string);
1390 return _Json_runHelp(decoder, value);
1391 }
1392 catch (e)
1393 {
1394 return $elm$core$Result$Err(A2($elm$json$Json$Decode$Failure, 'This is not valid JSON! ' + e.message, _Json_wrap(string)));
1395 }
1396});
1397
1398var _Json_run = F2(function(decoder, value)
1399{
1400 return _Json_runHelp(decoder, _Json_unwrap(value));
1401});
1402
1403function _Json_runHelp(decoder, value)
1404{
1405 switch (decoder.$)
1406 {
1407 case 2:
1408 return decoder.b(value);
1409
1410 case 5:
1411 return (value === null)
1412 ? $elm$core$Result$Ok(decoder.c)
1413 : _Json_expecting('null', value);
1414
1415 case 3:
1416 if (!_Json_isArray(value))
1417 {
1418 return _Json_expecting('a LIST', value);
1419 }
1420 return _Json_runArrayDecoder(decoder.b, value, _List_fromArray);
1421
1422 case 4:
1423 if (!_Json_isArray(value))
1424 {
1425 return _Json_expecting('an ARRAY', value);
1426 }
1427 return _Json_runArrayDecoder(decoder.b, value, _Json_toElmArray);
1428
1429 case 6:
1430 var field = decoder.d;
1431 if (typeof value !== 'object' || value === null || !(field in value))
1432 {
1433 return _Json_expecting('an OBJECT with a field named `' + field + '`', value);
1434 }
1435 var result = _Json_runHelp(decoder.b, value[field]);
1436 return ($elm$core$Result$isOk(result)) ? result : $elm$core$Result$Err(A2($elm$json$Json$Decode$Field, field, result.a));
1437
1438 case 7:
1439 var index = decoder.e;
1440 if (!_Json_isArray(value))
1441 {
1442 return _Json_expecting('an ARRAY', value);
1443 }
1444 if (index >= value.length)
1445 {
1446 return _Json_expecting('a LONGER array. Need index ' + index + ' but only see ' + value.length + ' entries', value);
1447 }
1448 var result = _Json_runHelp(decoder.b, value[index]);
1449 return ($elm$core$Result$isOk(result)) ? result : $elm$core$Result$Err(A2($elm$json$Json$Decode$Index, index, result.a));
1450
1451 case 8:
1452 if (typeof value !== 'object' || value === null || _Json_isArray(value))
1453 {
1454 return _Json_expecting('an OBJECT', value);
1455 }
1456
1457 var keyValuePairs = _List_Nil;
1458 // TODO test perf of Object.keys and switch when support is good enough
1459 for (var key in value)
1460 {
1461 if (Object.prototype.hasOwnProperty.call(value, key))
1462 {
1463 var result = _Json_runHelp(decoder.b, value[key]);
1464 if (!$elm$core$Result$isOk(result))
1465 {
1466 return $elm$core$Result$Err(A2($elm$json$Json$Decode$Field, key, result.a));
1467 }
1468 keyValuePairs = _List_Cons(_Utils_Tuple2(key, result.a), keyValuePairs);
1469 }
1470 }
1471 return $elm$core$Result$Ok($elm$core$List$reverse(keyValuePairs));
1472
1473 case 9:
1474 var answer = decoder.f;
1475 var decoders = decoder.g;
1476 for (var i = 0; i < decoders.length; i++)
1477 {
1478 var result = _Json_runHelp(decoders[i], value);
1479 if (!$elm$core$Result$isOk(result))
1480 {
1481 return result;
1482 }
1483 answer = answer(result.a);
1484 }
1485 return $elm$core$Result$Ok(answer);
1486
1487 case 10:
1488 var result = _Json_runHelp(decoder.b, value);
1489 return (!$elm$core$Result$isOk(result))
1490 ? result
1491 : _Json_runHelp(decoder.h(result.a), value);
1492
1493 case 11:
1494 var errors = _List_Nil;
1495 for (var temp = decoder.g; temp.b; temp = temp.b) // WHILE_CONS
1496 {
1497 var result = _Json_runHelp(temp.a, value);
1498 if ($elm$core$Result$isOk(result))
1499 {
1500 return result;
1501 }
1502 errors = _List_Cons(result.a, errors);
1503 }
1504 return $elm$core$Result$Err($elm$json$Json$Decode$OneOf($elm$core$List$reverse(errors)));
1505
1506 case 1:
1507 return $elm$core$Result$Err(A2($elm$json$Json$Decode$Failure, decoder.a, _Json_wrap(value)));
1508
1509 case 0:
1510 return $elm$core$Result$Ok(decoder.a);
1511 }
1512}
1513
1514function _Json_runArrayDecoder(decoder, value, toElmValue)
1515{
1516 var len = value.length;
1517 var array = new Array(len);
1518 for (var i = 0; i < len; i++)
1519 {
1520 var result = _Json_runHelp(decoder, value[i]);
1521 if (!$elm$core$Result$isOk(result))
1522 {
1523 return $elm$core$Result$Err(A2($elm$json$Json$Decode$Index, i, result.a));
1524 }
1525 array[i] = result.a;
1526 }
1527 return $elm$core$Result$Ok(toElmValue(array));
1528}
1529
1530function _Json_isArray(value)
1531{
1532 return Array.isArray(value) || (typeof FileList !== 'undefined' && value instanceof FileList);
1533}
1534
1535function _Json_toElmArray(array)
1536{
1537 return A2($elm$core$Array$initialize, array.length, function(i) { return array[i]; });
1538}
1539
1540function _Json_expecting(type, value)
1541{
1542 return $elm$core$Result$Err(A2($elm$json$Json$Decode$Failure, 'Expecting ' + type, _Json_wrap(value)));
1543}
1544
1545
1546// EQUALITY
1547
1548function _Json_equality(x, y)
1549{
1550 if (x === y)
1551 {
1552 return true;
1553 }
1554
1555 if (x.$ !== y.$)
1556 {
1557 return false;
1558 }
1559
1560 switch (x.$)
1561 {
1562 case 0:
1563 case 1:
1564 return x.a === y.a;
1565
1566 case 2:
1567 return x.b === y.b;
1568
1569 case 5:
1570 return x.c === y.c;
1571
1572 case 3:
1573 case 4:
1574 case 8:
1575 return _Json_equality(x.b, y.b);
1576
1577 case 6:
1578 return x.d === y.d && _Json_equality(x.b, y.b);
1579
1580 case 7:
1581 return x.e === y.e && _Json_equality(x.b, y.b);
1582
1583 case 9:
1584 return x.f === y.f && _Json_listEquality(x.g, y.g);
1585
1586 case 10:
1587 return x.h === y.h && _Json_equality(x.b, y.b);
1588
1589 case 11:
1590 return _Json_listEquality(x.g, y.g);
1591 }
1592}
1593
1594function _Json_listEquality(aDecoders, bDecoders)
1595{
1596 var len = aDecoders.length;
1597 if (len !== bDecoders.length)
1598 {
1599 return false;
1600 }
1601 for (var i = 0; i < len; i++)
1602 {
1603 if (!_Json_equality(aDecoders[i], bDecoders[i]))
1604 {
1605 return false;
1606 }
1607 }
1608 return true;
1609}
1610
1611
1612// ENCODE
1613
1614var _Json_encode = F2(function(indentLevel, value)
1615{
1616 return JSON.stringify(_Json_unwrap(value), null, indentLevel) + '';
1617});
1618
1619function _Json_wrap(value) { return { $: 0, a: value }; }
1620function _Json_unwrap(value) { return value.a; }
1621
1622function _Json_wrap_UNUSED(value) { return value; }
1623function _Json_unwrap_UNUSED(value) { return value; }
1624
1625function _Json_emptyArray() { return []; }
1626function _Json_emptyObject() { return {}; }
1627
1628var _Json_addField = F3(function(key, value, object)
1629{
1630 var unwrapped = _Json_unwrap(value);
1631 if (!(key === 'toJSON' && typeof unwrapped === 'function'))
1632 {
1633 object[key] = unwrapped;
1634 }
1635 return object;
1636});
1637
1638function _Json_addEntry(func)
1639{
1640 return F2(function(entry, array)
1641 {
1642 array.push(_Json_unwrap(func(entry)));
1643 return array;
1644 });
1645}
1646
1647var _Json_encodeNull = _Json_wrap(null);
1648
1649
1650
1651// TASKS
1652
1653function _Scheduler_succeed(value)
1654{
1655 return {
1656 $: 0,
1657 a: value
1658 };
1659}
1660
1661function _Scheduler_fail(error)
1662{
1663 return {
1664 $: 1,
1665 a: error
1666 };
1667}
1668
1669function _Scheduler_binding(callback)
1670{
1671 return {
1672 $: 2,
1673 b: callback,
1674 c: null
1675 };
1676}
1677
1678var _Scheduler_andThen = F2(function(callback, task)
1679{
1680 return {
1681 $: 3,
1682 b: callback,
1683 d: task
1684 };
1685});
1686
1687var _Scheduler_onError = F2(function(callback, task)
1688{
1689 return {
1690 $: 4,
1691 b: callback,
1692 d: task
1693 };
1694});
1695
1696function _Scheduler_receive(callback)
1697{
1698 return {
1699 $: 5,
1700 b: callback
1701 };
1702}
1703
1704
1705// PROCESSES
1706
1707var _Scheduler_guid = 0;
1708
1709function _Scheduler_rawSpawn(task)
1710{
1711 var proc = {
1712 $: 0,
1713 e: _Scheduler_guid++,
1714 f: task,
1715 g: null,
1716 h: []
1717 };
1718
1719 _Scheduler_enqueue(proc);
1720
1721 return proc;
1722}
1723
1724function _Scheduler_spawn(task)
1725{
1726 return _Scheduler_binding(function(callback) {
1727 callback(_Scheduler_succeed(_Scheduler_rawSpawn(task)));
1728 });
1729}
1730
1731function _Scheduler_rawSend(proc, msg)
1732{
1733 proc.h.push(msg);
1734 _Scheduler_enqueue(proc);
1735}
1736
1737var _Scheduler_send = F2(function(proc, msg)
1738{
1739 return _Scheduler_binding(function(callback) {
1740 _Scheduler_rawSend(proc, msg);
1741 callback(_Scheduler_succeed(_Utils_Tuple0));
1742 });
1743});
1744
1745function _Scheduler_kill(proc)
1746{
1747 return _Scheduler_binding(function(callback) {
1748 var task = proc.f;
1749 if (task.$ === 2 && task.c)
1750 {
1751 task.c();
1752 }
1753
1754 proc.f = null;
1755
1756 callback(_Scheduler_succeed(_Utils_Tuple0));
1757 });
1758}
1759
1760
1761/* STEP PROCESSES
1762
1763type alias Process =
1764 { $ : tag
1765 , id : unique_id
1766 , root : Task
1767 , stack : null | { $: SUCCEED | FAIL, a: callback, b: stack }
1768 , mailbox : [msg]
1769 }
1770
1771*/
1772
1773
1774var _Scheduler_working = false;
1775var _Scheduler_queue = [];
1776
1777
1778function _Scheduler_enqueue(proc)
1779{
1780 _Scheduler_queue.push(proc);
1781 if (_Scheduler_working)
1782 {
1783 return;
1784 }
1785 _Scheduler_working = true;
1786 while (proc = _Scheduler_queue.shift())
1787 {
1788 _Scheduler_step(proc);
1789 }
1790 _Scheduler_working = false;
1791}
1792
1793
1794function _Scheduler_step(proc)
1795{
1796 while (proc.f)
1797 {
1798 var rootTag = proc.f.$;
1799 if (rootTag === 0 || rootTag === 1)
1800 {
1801 while (proc.g && proc.g.$ !== rootTag)
1802 {
1803 proc.g = proc.g.i;
1804 }
1805 if (!proc.g)
1806 {
1807 return;
1808 }
1809 proc.f = proc.g.b(proc.f.a);
1810 proc.g = proc.g.i;
1811 }
1812 else if (rootTag === 2)
1813 {
1814 proc.f.c = proc.f.b(function(newRoot) {
1815 proc.f = newRoot;
1816 _Scheduler_enqueue(proc);
1817 });
1818 return;
1819 }
1820 else if (rootTag === 5)
1821 {
1822 if (proc.h.length === 0)
1823 {
1824 return;
1825 }
1826 proc.f = proc.f.b(proc.h.shift());
1827 }
1828 else // if (rootTag === 3 || rootTag === 4)
1829 {
1830 proc.g = {
1831 $: rootTag === 3 ? 0 : 1,
1832 b: proc.f.b,
1833 i: proc.g
1834 };
1835 proc.f = proc.f.d;
1836 }
1837 }
1838}
1839
1840
1841
1842function _Process_sleep(time)
1843{
1844 return _Scheduler_binding(function(callback) {
1845 var id = setTimeout(function() {
1846 callback(_Scheduler_succeed(_Utils_Tuple0));
1847 }, time);
1848
1849 return function() { clearTimeout(id); };
1850 });
1851}
1852
1853
1854
1855
1856// PROGRAMS
1857
1858
1859var _Platform_worker = F4(function(impl, flagDecoder, debugMetadata, args)
1860{
1861 return _Platform_initialize(
1862 flagDecoder,
1863 args,
1864 impl.init,
1865 impl.update,
1866 impl.subscriptions,
1867 function() { return function() {} }
1868 );
1869});
1870
1871
1872
1873// INITIALIZE A PROGRAM
1874
1875
1876function _Platform_initialize(flagDecoder, args, init, update, subscriptions, stepperBuilder)
1877{
1878 var result = A2(_Json_run, flagDecoder, _Json_wrap(args ? args['flags'] : undefined));
1879 $elm$core$Result$isOk(result) || _Debug_crash(2 /**/, _Json_errorToString(result.a) /**/);
1880 var managers = {};
1881 var initPair = init(result.a);
1882 var model = initPair.a;
1883 var stepper = stepperBuilder(sendToApp, model);
1884 var ports = _Platform_setupEffects(managers, sendToApp);
1885
1886 function sendToApp(msg, viewMetadata)
1887 {
1888 var pair = A2(update, msg, model);
1889 stepper(model = pair.a, viewMetadata);
1890 _Platform_enqueueEffects(managers, pair.b, subscriptions(model));
1891 }
1892
1893 _Platform_enqueueEffects(managers, initPair.b, subscriptions(model));
1894
1895 return ports ? { ports: ports } : {};
1896}
1897
1898
1899
1900// TRACK PRELOADS
1901//
1902// This is used by code in elm/browser and elm/http
1903// to register any HTTP requests that are triggered by init.
1904//
1905
1906
1907var _Platform_preload;
1908
1909
1910function _Platform_registerPreload(url)
1911{
1912 _Platform_preload.add(url);
1913}
1914
1915
1916
1917// EFFECT MANAGERS
1918
1919
1920var _Platform_effectManagers = {};
1921
1922
1923function _Platform_setupEffects(managers, sendToApp)
1924{
1925 var ports;
1926
1927 // setup all necessary effect managers
1928 for (var key in _Platform_effectManagers)
1929 {
1930 var manager = _Platform_effectManagers[key];
1931
1932 if (manager.a)
1933 {
1934 ports = ports || {};
1935 ports[key] = manager.a(key, sendToApp);
1936 }
1937
1938 managers[key] = _Platform_instantiateManager(manager, sendToApp);
1939 }
1940
1941 return ports;
1942}
1943
1944
1945function _Platform_createManager(init, onEffects, onSelfMsg, cmdMap, subMap)
1946{
1947 return {
1948 b: init,
1949 c: onEffects,
1950 d: onSelfMsg,
1951 e: cmdMap,
1952 f: subMap
1953 };
1954}
1955
1956
1957function _Platform_instantiateManager(info, sendToApp)
1958{
1959 var router = {
1960 g: sendToApp,
1961 h: undefined
1962 };
1963
1964 var onEffects = info.c;
1965 var onSelfMsg = info.d;
1966 var cmdMap = info.e;
1967 var subMap = info.f;
1968
1969 function loop(state)
1970 {
1971 return A2(_Scheduler_andThen, loop, _Scheduler_receive(function(msg)
1972 {
1973 var value = msg.a;
1974
1975 if (msg.$ === 0)
1976 {
1977 return A3(onSelfMsg, router, value, state);
1978 }
1979
1980 return cmdMap && subMap
1981 ? A4(onEffects, router, value.i, value.j, state)
1982 : A3(onEffects, router, cmdMap ? value.i : value.j, state);
1983 }));
1984 }
1985
1986 return router.h = _Scheduler_rawSpawn(A2(_Scheduler_andThen, loop, info.b));
1987}
1988
1989
1990
1991// ROUTING
1992
1993
1994var _Platform_sendToApp = F2(function(router, msg)
1995{
1996 return _Scheduler_binding(function(callback)
1997 {
1998 router.g(msg);
1999 callback(_Scheduler_succeed(_Utils_Tuple0));
2000 });
2001});
2002
2003
2004var _Platform_sendToSelf = F2(function(router, msg)
2005{
2006 return A2(_Scheduler_send, router.h, {
2007 $: 0,
2008 a: msg
2009 });
2010});
2011
2012
2013
2014// BAGS
2015
2016
2017function _Platform_leaf(home)
2018{
2019 return function(value)
2020 {
2021 return {
2022 $: 1,
2023 k: home,
2024 l: value
2025 };
2026 };
2027}
2028
2029
2030function _Platform_batch(list)
2031{
2032 return {
2033 $: 2,
2034 m: list
2035 };
2036}
2037
2038
2039var _Platform_map = F2(function(tagger, bag)
2040{
2041 return {
2042 $: 3,
2043 n: tagger,
2044 o: bag
2045 }
2046});
2047
2048
2049
2050// PIPE BAGS INTO EFFECT MANAGERS
2051//
2052// Effects must be queued!
2053//
2054// Say your init contains a synchronous command, like Time.now or Time.here
2055//
2056// - This will produce a batch of effects (FX_1)
2057// - The synchronous task triggers the subsequent `update` call
2058// - This will produce a batch of effects (FX_2)
2059//
2060// If we just start dispatching FX_2, subscriptions from FX_2 can be processed
2061// before subscriptions from FX_1. No good! Earlier versions of this code had
2062// this problem, leading to these reports:
2063//
2064// https://github.com/elm/core/issues/980
2065// https://github.com/elm/core/pull/981
2066// https://github.com/elm/compiler/issues/1776
2067//
2068// The queue is necessary to avoid ordering issues for synchronous commands.
2069
2070
2071// Why use true/false here? Why not just check the length of the queue?
2072// The goal is to detect "are we currently dispatching effects?" If we
2073// are, we need to bail and let the ongoing while loop handle things.
2074//
2075// Now say the queue has 1 element. When we dequeue the final element,
2076// the queue will be empty, but we are still actively dispatching effects.
2077// So you could get queue jumping in a really tricky category of cases.
2078//
2079var _Platform_effectsQueue = [];
2080var _Platform_effectsActive = false;
2081
2082
2083function _Platform_enqueueEffects(managers, cmdBag, subBag)
2084{
2085 _Platform_effectsQueue.push({ p: managers, q: cmdBag, r: subBag });
2086
2087 if (_Platform_effectsActive) return;
2088
2089 _Platform_effectsActive = true;
2090 for (var fx; fx = _Platform_effectsQueue.shift(); )
2091 {
2092 _Platform_dispatchEffects(fx.p, fx.q, fx.r);
2093 }
2094 _Platform_effectsActive = false;
2095}
2096
2097
2098function _Platform_dispatchEffects(managers, cmdBag, subBag)
2099{
2100 var effectsDict = {};
2101 _Platform_gatherEffects(true, cmdBag, effectsDict, null);
2102 _Platform_gatherEffects(false, subBag, effectsDict, null);
2103
2104 for (var home in managers)
2105 {
2106 _Scheduler_rawSend(managers[home], {
2107 $: 'fx',
2108 a: effectsDict[home] || { i: _List_Nil, j: _List_Nil }
2109 });
2110 }
2111}
2112
2113
2114function _Platform_gatherEffects(isCmd, bag, effectsDict, taggers)
2115{
2116 switch (bag.$)
2117 {
2118 case 1:
2119 var home = bag.k;
2120 var effect = _Platform_toEffect(isCmd, home, taggers, bag.l);
2121 effectsDict[home] = _Platform_insert(isCmd, effect, effectsDict[home]);
2122 return;
2123
2124 case 2:
2125 for (var list = bag.m; list.b; list = list.b) // WHILE_CONS
2126 {
2127 _Platform_gatherEffects(isCmd, list.a, effectsDict, taggers);
2128 }
2129 return;
2130
2131 case 3:
2132 _Platform_gatherEffects(isCmd, bag.o, effectsDict, {
2133 s: bag.n,
2134 t: taggers
2135 });
2136 return;
2137 }
2138}
2139
2140
2141function _Platform_toEffect(isCmd, home, taggers, value)
2142{
2143 function applyTaggers(x)
2144 {
2145 for (var temp = taggers; temp; temp = temp.t)
2146 {
2147 x = temp.s(x);
2148 }
2149 return x;
2150 }
2151
2152 var map = isCmd
2153 ? _Platform_effectManagers[home].e
2154 : _Platform_effectManagers[home].f;
2155
2156 return A2(map, applyTaggers, value)
2157}
2158
2159
2160function _Platform_insert(isCmd, newEffect, effects)
2161{
2162 effects = effects || { i: _List_Nil, j: _List_Nil };
2163
2164 isCmd
2165 ? (effects.i = _List_Cons(newEffect, effects.i))
2166 : (effects.j = _List_Cons(newEffect, effects.j));
2167
2168 return effects;
2169}
2170
2171
2172
2173// PORTS
2174
2175
2176function _Platform_checkPortName(name)
2177{
2178 if (_Platform_effectManagers[name])
2179 {
2180 _Debug_crash(3, name)
2181 }
2182}
2183
2184
2185
2186// OUTGOING PORTS
2187
2188
2189function _Platform_outgoingPort(name, converter)
2190{
2191 _Platform_checkPortName(name);
2192 _Platform_effectManagers[name] = {
2193 e: _Platform_outgoingPortMap,
2194 u: converter,
2195 a: _Platform_setupOutgoingPort
2196 };
2197 return _Platform_leaf(name);
2198}
2199
2200
2201var _Platform_outgoingPortMap = F2(function(tagger, value) { return value; });
2202
2203
2204function _Platform_setupOutgoingPort(name)
2205{
2206 var subs = [];
2207 var converter = _Platform_effectManagers[name].u;
2208
2209 // CREATE MANAGER
2210
2211 var init = _Process_sleep(0);
2212
2213 _Platform_effectManagers[name].b = init;
2214 _Platform_effectManagers[name].c = F3(function(router, cmdList, state)
2215 {
2216 for ( ; cmdList.b; cmdList = cmdList.b) // WHILE_CONS
2217 {
2218 // grab a separate reference to subs in case unsubscribe is called
2219 var currentSubs = subs;
2220 var value = _Json_unwrap(converter(cmdList.a));
2221 for (var i = 0; i < currentSubs.length; i++)
2222 {
2223 currentSubs[i](value);
2224 }
2225 }
2226 return init;
2227 });
2228
2229 // PUBLIC API
2230
2231 function subscribe(callback)
2232 {
2233 subs.push(callback);
2234 }
2235
2236 function unsubscribe(callback)
2237 {
2238 // copy subs into a new array in case unsubscribe is called within a
2239 // subscribed callback
2240 subs = subs.slice();
2241 var index = subs.indexOf(callback);
2242 if (index >= 0)
2243 {
2244 subs.splice(index, 1);
2245 }
2246 }
2247
2248 return {
2249 subscribe: subscribe,
2250 unsubscribe: unsubscribe
2251 };
2252}
2253
2254
2255
2256// INCOMING PORTS
2257
2258
2259function _Platform_incomingPort(name, converter)
2260{
2261 _Platform_checkPortName(name);
2262 _Platform_effectManagers[name] = {
2263 f: _Platform_incomingPortMap,
2264 u: converter,
2265 a: _Platform_setupIncomingPort
2266 };
2267 return _Platform_leaf(name);
2268}
2269
2270
2271var _Platform_incomingPortMap = F2(function(tagger, finalTagger)
2272{
2273 return function(value)
2274 {
2275 return tagger(finalTagger(value));
2276 };
2277});
2278
2279
2280function _Platform_setupIncomingPort(name, sendToApp)
2281{
2282 var subs = _List_Nil;
2283 var converter = _Platform_effectManagers[name].u;
2284
2285 // CREATE MANAGER
2286
2287 var init = _Scheduler_succeed(null);
2288
2289 _Platform_effectManagers[name].b = init;
2290 _Platform_effectManagers[name].c = F3(function(router, subList, state)
2291 {
2292 subs = subList;
2293 return init;
2294 });
2295
2296 // PUBLIC API
2297
2298 function send(incomingValue)
2299 {
2300 var result = A2(_Json_run, converter, _Json_wrap(incomingValue));
2301
2302 $elm$core$Result$isOk(result) || _Debug_crash(4, name, result.a);
2303
2304 var value = result.a;
2305 for (var temp = subs; temp.b; temp = temp.b) // WHILE_CONS
2306 {
2307 sendToApp(temp.a(value));
2308 }
2309 }
2310
2311 return { send: send };
2312}
2313
2314
2315
2316// EXPORT ELM MODULES
2317//
2318// Have DEBUG and PROD versions so that we can (1) give nicer errors in
2319// debug mode and (2) not pay for the bits needed for that in prod mode.
2320//
2321
2322
2323function _Platform_export_UNUSED(exports)
2324{
2325 scope['Elm']
2326 ? _Platform_mergeExportsProd(scope['Elm'], exports)
2327 : scope['Elm'] = exports;
2328}
2329
2330
2331function _Platform_mergeExportsProd(obj, exports)
2332{
2333 for (var name in exports)
2334 {
2335 (name in obj)
2336 ? (name == 'init')
2337 ? _Debug_crash(6)
2338 : _Platform_mergeExportsProd(obj[name], exports[name])
2339 : (obj[name] = exports[name]);
2340 }
2341}
2342
2343
2344function _Platform_export(exports)
2345{
2346 scope['Elm']
2347 ? _Platform_mergeExportsDebug('Elm', scope['Elm'], exports)
2348 : scope['Elm'] = exports;
2349}
2350
2351
2352function _Platform_mergeExportsDebug(moduleName, obj, exports)
2353{
2354 for (var name in exports)
2355 {
2356 (name in obj)
2357 ? (name == 'init')
2358 ? _Debug_crash(6, moduleName)
2359 : _Platform_mergeExportsDebug(moduleName + '.' + name, obj[name], exports[name])
2360 : (obj[name] = exports[name]);
2361 }
2362}
2363
2364
2365
2366
2367// HELPERS
2368
2369
2370var _VirtualDom_divertHrefToApp;
2371
2372var _VirtualDom_doc = typeof document !== 'undefined' ? document : {};
2373
2374
2375function _VirtualDom_appendChild(parent, child)
2376{
2377 parent.appendChild(child);
2378}
2379
2380var _VirtualDom_init = F4(function(virtualNode, flagDecoder, debugMetadata, args)
2381{
2382 // NOTE: this function needs _Platform_export available to work
2383
2384 /**_UNUSED/
2385 var node = args['node'];
2386 //*/
2387 /**/
2388 var node = args && args['node'] ? args['node'] : _Debug_crash(0);
2389 //*/
2390
2391 node.parentNode.replaceChild(
2392 _VirtualDom_render(virtualNode, function() {}),
2393 node
2394 );
2395
2396 return {};
2397});
2398
2399
2400
2401// TEXT
2402
2403
2404function _VirtualDom_text(string)
2405{
2406 return {
2407 $: 0,
2408 a: string
2409 };
2410}
2411
2412
2413
2414// NODE
2415
2416
2417var _VirtualDom_nodeNS = F2(function(namespace, tag)
2418{
2419 return F2(function(factList, kidList)
2420 {
2421 for (var kids = [], descendantsCount = 0; kidList.b; kidList = kidList.b) // WHILE_CONS
2422 {
2423 var kid = kidList.a;
2424 descendantsCount += (kid.b || 0);
2425 kids.push(kid);
2426 }
2427 descendantsCount += kids.length;
2428
2429 return {
2430 $: 1,
2431 c: tag,
2432 d: _VirtualDom_organizeFacts(factList),
2433 e: kids,
2434 f: namespace,
2435 b: descendantsCount
2436 };
2437 });
2438});
2439
2440
2441var _VirtualDom_node = _VirtualDom_nodeNS(undefined);
2442
2443
2444
2445// KEYED NODE
2446
2447
2448var _VirtualDom_keyedNodeNS = F2(function(namespace, tag)
2449{
2450 return F2(function(factList, kidList)
2451 {
2452 for (var kids = [], descendantsCount = 0; kidList.b; kidList = kidList.b) // WHILE_CONS
2453 {
2454 var kid = kidList.a;
2455 descendantsCount += (kid.b.b || 0);
2456 kids.push(kid);
2457 }
2458 descendantsCount += kids.length;
2459
2460 return {
2461 $: 2,
2462 c: tag,
2463 d: _VirtualDom_organizeFacts(factList),
2464 e: kids,
2465 f: namespace,
2466 b: descendantsCount
2467 };
2468 });
2469});
2470
2471
2472var _VirtualDom_keyedNode = _VirtualDom_keyedNodeNS(undefined);
2473
2474
2475
2476// CUSTOM
2477
2478
2479function _VirtualDom_custom(factList, model, render, diff)
2480{
2481 return {
2482 $: 3,
2483 d: _VirtualDom_organizeFacts(factList),
2484 g: model,
2485 h: render,
2486 i: diff
2487 };
2488}
2489
2490
2491
2492// MAP
2493
2494
2495var _VirtualDom_map = F2(function(tagger, node)
2496{
2497 return {
2498 $: 4,
2499 j: tagger,
2500 k: node,
2501 b: 1 + (node.b || 0)
2502 };
2503});
2504
2505
2506
2507// LAZY
2508
2509
2510function _VirtualDom_thunk(refs, thunk)
2511{
2512 return {
2513 $: 5,
2514 l: refs,
2515 m: thunk,
2516 k: undefined
2517 };
2518}
2519
2520var _VirtualDom_lazy = F2(function(func, a)
2521{
2522 return _VirtualDom_thunk([func, a], function() {
2523 return func(a);
2524 });
2525});
2526
2527var _VirtualDom_lazy2 = F3(function(func, a, b)
2528{
2529 return _VirtualDom_thunk([func, a, b], function() {
2530 return A2(func, a, b);
2531 });
2532});
2533
2534var _VirtualDom_lazy3 = F4(function(func, a, b, c)
2535{
2536 return _VirtualDom_thunk([func, a, b, c], function() {
2537 return A3(func, a, b, c);
2538 });
2539});
2540
2541var _VirtualDom_lazy4 = F5(function(func, a, b, c, d)
2542{
2543 return _VirtualDom_thunk([func, a, b, c, d], function() {
2544 return A4(func, a, b, c, d);
2545 });
2546});
2547
2548var _VirtualDom_lazy5 = F6(function(func, a, b, c, d, e)
2549{
2550 return _VirtualDom_thunk([func, a, b, c, d, e], function() {
2551 return A5(func, a, b, c, d, e);
2552 });
2553});
2554
2555var _VirtualDom_lazy6 = F7(function(func, a, b, c, d, e, f)
2556{
2557 return _VirtualDom_thunk([func, a, b, c, d, e, f], function() {
2558 return A6(func, a, b, c, d, e, f);
2559 });
2560});
2561
2562var _VirtualDom_lazy7 = F8(function(func, a, b, c, d, e, f, g)
2563{
2564 return _VirtualDom_thunk([func, a, b, c, d, e, f, g], function() {
2565 return A7(func, a, b, c, d, e, f, g);
2566 });
2567});
2568
2569var _VirtualDom_lazy8 = F9(function(func, a, b, c, d, e, f, g, h)
2570{
2571 return _VirtualDom_thunk([func, a, b, c, d, e, f, g, h], function() {
2572 return A8(func, a, b, c, d, e, f, g, h);
2573 });
2574});
2575
2576
2577
2578// FACTS
2579
2580
2581var _VirtualDom_on = F2(function(key, handler)
2582{
2583 return {
2584 $: 'a0',
2585 n: key,
2586 o: handler
2587 };
2588});
2589var _VirtualDom_style = F2(function(key, value)
2590{
2591 return {
2592 $: 'a1',
2593 n: key,
2594 o: value
2595 };
2596});
2597var _VirtualDom_property = F2(function(key, value)
2598{
2599 return {
2600 $: 'a2',
2601 n: key,
2602 o: value
2603 };
2604});
2605var _VirtualDom_attribute = F2(function(key, value)
2606{
2607 return {
2608 $: 'a3',
2609 n: key,
2610 o: value
2611 };
2612});
2613var _VirtualDom_attributeNS = F3(function(namespace, key, value)
2614{
2615 return {
2616 $: 'a4',
2617 n: key,
2618 o: { f: namespace, o: value }
2619 };
2620});
2621
2622
2623
2624// XSS ATTACK VECTOR CHECKS
2625//
2626// For some reason, tabs can appear in href protocols and it still works.
2627// So '\tjava\tSCRIPT:alert("!!!")' and 'javascript:alert("!!!")' are the same
2628// in practice. That is why _VirtualDom_RE_js and _VirtualDom_RE_js_html look
2629// so freaky.
2630//
2631// Pulling the regular expressions out to the top level gives a slight speed
2632// boost in small benchmarks (4-10%) but hoisting values to reduce allocation
2633// can be unpredictable in large programs where JIT may have a harder time with
2634// functions are not fully self-contained. The benefit is more that the js and
2635// js_html ones are so weird that I prefer to see them near each other.
2636
2637
2638var _VirtualDom_RE_script = /^script$/i;
2639var _VirtualDom_RE_on_formAction = /^(on|formAction$)/i;
2640var _VirtualDom_RE_js = /^\s*j\s*a\s*v\s*a\s*s\s*c\s*r\s*i\s*p\s*t\s*:/i;
2641var _VirtualDom_RE_js_html = /^\s*(j\s*a\s*v\s*a\s*s\s*c\s*r\s*i\s*p\s*t\s*:|d\s*a\s*t\s*a\s*:\s*t\s*e\s*x\s*t\s*\/\s*h\s*t\s*m\s*l\s*(,|;))/i;
2642
2643
2644function _VirtualDom_noScript(tag)
2645{
2646 return _VirtualDom_RE_script.test(tag) ? 'p' : tag;
2647}
2648
2649function _VirtualDom_noOnOrFormAction(key)
2650{
2651 return _VirtualDom_RE_on_formAction.test(key) ? 'data-' + key : key;
2652}
2653
2654function _VirtualDom_noInnerHtmlOrFormAction(key)
2655{
2656 return key == 'innerHTML' || key == 'outerHTML' || key == 'formAction' ? 'data-' + key : key;
2657}
2658
2659function _VirtualDom_noJavaScriptUri(value)
2660{
2661 return _VirtualDom_RE_js.test(value)
2662 ? /**_UNUSED/''//*//**/'javascript:alert("This is an XSS vector. Please use ports or web components instead.")'//*/
2663 : value;
2664}
2665
2666function _VirtualDom_noJavaScriptOrHtmlUri(value)
2667{
2668 return _VirtualDom_RE_js_html.test(value)
2669 ? /**_UNUSED/''//*//**/'javascript:alert("This is an XSS vector. Please use ports or web components instead.")'//*/
2670 : value;
2671}
2672
2673function _VirtualDom_noJavaScriptOrHtmlJson(value)
2674{
2675 return (
2676 (typeof _Json_unwrap(value) === 'string' && _VirtualDom_RE_js_html.test(_Json_unwrap(value)))
2677 ||
2678 (Array.isArray(_Json_unwrap(value)) && _VirtualDom_RE_js_html.test(String(_Json_unwrap(value))))
2679 )
2680 ? _Json_wrap(
2681 /**_UNUSED/''//*//**/'javascript:alert("This is an XSS vector. Please use ports or web components instead.")'//*/
2682 ) : value;
2683}
2684
2685
2686
2687// MAP FACTS
2688
2689
2690var _VirtualDom_mapAttribute = F2(function(func, attr)
2691{
2692 return (attr.$ === 'a0')
2693 ? A2(_VirtualDom_on, attr.n, _VirtualDom_mapHandler(func, attr.o))
2694 : attr;
2695});
2696
2697function _VirtualDom_mapHandler(func, handler)
2698{
2699 var tag = $elm$virtual_dom$VirtualDom$toHandlerInt(handler);
2700
2701 // 0 = Normal
2702 // 1 = MayStopPropagation
2703 // 2 = MayPreventDefault
2704 // 3 = Custom
2705
2706 return {
2707 $: handler.$,
2708 a:
2709 !tag
2710 ? A2($elm$json$Json$Decode$map, func, handler.a)
2711 :
2712 A3($elm$json$Json$Decode$map2,
2713 tag < 3
2714 ? _VirtualDom_mapEventTuple
2715 : _VirtualDom_mapEventRecord,
2716 $elm$json$Json$Decode$succeed(func),
2717 handler.a
2718 )
2719 };
2720}
2721
2722var _VirtualDom_mapEventTuple = F2(function(func, tuple)
2723{
2724 return _Utils_Tuple2(func(tuple.a), tuple.b);
2725});
2726
2727var _VirtualDom_mapEventRecord = F2(function(func, record)
2728{
2729 return {
2730 message: func(record.message),
2731 stopPropagation: record.stopPropagation,
2732 preventDefault: record.preventDefault
2733 }
2734});
2735
2736
2737
2738// ORGANIZE FACTS
2739
2740
2741function _VirtualDom_organizeFacts(factList)
2742{
2743 for (var facts = {}; factList.b; factList = factList.b) // WHILE_CONS
2744 {
2745 var entry = factList.a;
2746
2747 var tag = entry.$;
2748 var key = entry.n;
2749 var value = entry.o;
2750
2751 if (tag === 'a2')
2752 {
2753 (key === 'className')
2754 ? _VirtualDom_addClass(facts, key, _Json_unwrap(value))
2755 : facts[key] = _Json_unwrap(value);
2756
2757 continue;
2758 }
2759
2760 var subFacts = facts[tag] || (facts[tag] = {});
2761 (tag === 'a3' && key === 'class')
2762 ? _VirtualDom_addClass(subFacts, key, value)
2763 : subFacts[key] = value;
2764 }
2765
2766 return facts;
2767}
2768
2769function _VirtualDom_addClass(object, key, newClass)
2770{
2771 var classes = object[key];
2772 object[key] = classes ? classes + ' ' + newClass : newClass;
2773}
2774
2775
2776
2777// RENDER
2778
2779
2780function _VirtualDom_render(vNode, eventNode)
2781{
2782 var tag = vNode.$;
2783
2784 if (tag === 5)
2785 {
2786 return _VirtualDom_render(vNode.k || (vNode.k = vNode.m()), eventNode);
2787 }
2788
2789 if (tag === 0)
2790 {
2791 return _VirtualDom_doc.createTextNode(vNode.a);
2792 }
2793
2794 if (tag === 4)
2795 {
2796 var subNode = vNode.k;
2797 var tagger = vNode.j;
2798
2799 while (subNode.$ === 4)
2800 {
2801 typeof tagger !== 'object'
2802 ? tagger = [tagger, subNode.j]
2803 : tagger.push(subNode.j);
2804
2805 subNode = subNode.k;
2806 }
2807
2808 var subEventRoot = { j: tagger, p: eventNode };
2809 var domNode = _VirtualDom_render(subNode, subEventRoot);
2810 domNode.elm_event_node_ref = subEventRoot;
2811 return domNode;
2812 }
2813
2814 if (tag === 3)
2815 {
2816 var domNode = vNode.h(vNode.g);
2817 _VirtualDom_applyFacts(domNode, eventNode, vNode.d);
2818 return domNode;
2819 }
2820
2821 // at this point `tag` must be 1 or 2
2822
2823 var domNode = vNode.f
2824 ? _VirtualDom_doc.createElementNS(vNode.f, vNode.c)
2825 : _VirtualDom_doc.createElement(vNode.c);
2826
2827 if (_VirtualDom_divertHrefToApp && vNode.c == 'a')
2828 {
2829 domNode.addEventListener('click', _VirtualDom_divertHrefToApp(domNode));
2830 }
2831
2832 _VirtualDom_applyFacts(domNode, eventNode, vNode.d);
2833
2834 for (var kids = vNode.e, i = 0; i < kids.length; i++)
2835 {
2836 _VirtualDom_appendChild(domNode, _VirtualDom_render(tag === 1 ? kids[i] : kids[i].b, eventNode));
2837 }
2838
2839 return domNode;
2840}
2841
2842
2843
2844// APPLY FACTS
2845
2846
2847function _VirtualDom_applyFacts(domNode, eventNode, facts)
2848{
2849 for (var key in facts)
2850 {
2851 var value = facts[key];
2852
2853 key === 'a1'
2854 ? _VirtualDom_applyStyles(domNode, value)
2855 :
2856 key === 'a0'
2857 ? _VirtualDom_applyEvents(domNode, eventNode, value)
2858 :
2859 key === 'a3'
2860 ? _VirtualDom_applyAttrs(domNode, value)
2861 :
2862 key === 'a4'
2863 ? _VirtualDom_applyAttrsNS(domNode, value)
2864 :
2865 ((key !== 'value' && key !== 'checked') || domNode[key] !== value) && (domNode[key] = value);
2866 }
2867}
2868
2869
2870
2871// APPLY STYLES
2872
2873
2874function _VirtualDom_applyStyles(domNode, styles)
2875{
2876 var domNodeStyle = domNode.style;
2877
2878 for (var key in styles)
2879 {
2880 domNodeStyle[key] = styles[key];
2881 }
2882}
2883
2884
2885
2886// APPLY ATTRS
2887
2888
2889function _VirtualDom_applyAttrs(domNode, attrs)
2890{
2891 for (var key in attrs)
2892 {
2893 var value = attrs[key];
2894 typeof value !== 'undefined'
2895 ? domNode.setAttribute(key, value)
2896 : domNode.removeAttribute(key);
2897 }
2898}
2899
2900
2901
2902// APPLY NAMESPACED ATTRS
2903
2904
2905function _VirtualDom_applyAttrsNS(domNode, nsAttrs)
2906{
2907 for (var key in nsAttrs)
2908 {
2909 var pair = nsAttrs[key];
2910 var namespace = pair.f;
2911 var value = pair.o;
2912
2913 typeof value !== 'undefined'
2914 ? domNode.setAttributeNS(namespace, key, value)
2915 : domNode.removeAttributeNS(namespace, key);
2916 }
2917}
2918
2919
2920
2921// APPLY EVENTS
2922
2923
2924function _VirtualDom_applyEvents(domNode, eventNode, events)
2925{
2926 var allCallbacks = domNode.elmFs || (domNode.elmFs = {});
2927
2928 for (var key in events)
2929 {
2930 var newHandler = events[key];
2931 var oldCallback = allCallbacks[key];
2932
2933 if (!newHandler)
2934 {
2935 domNode.removeEventListener(key, oldCallback);
2936 allCallbacks[key] = undefined;
2937 continue;
2938 }
2939
2940 if (oldCallback)
2941 {
2942 var oldHandler = oldCallback.q;
2943 if (oldHandler.$ === newHandler.$)
2944 {
2945 oldCallback.q = newHandler;
2946 continue;
2947 }
2948 domNode.removeEventListener(key, oldCallback);
2949 }
2950
2951 oldCallback = _VirtualDom_makeCallback(eventNode, newHandler);
2952 domNode.addEventListener(key, oldCallback,
2953 _VirtualDom_passiveSupported
2954 && { passive: $elm$virtual_dom$VirtualDom$toHandlerInt(newHandler) < 2 }
2955 );
2956 allCallbacks[key] = oldCallback;
2957 }
2958}
2959
2960
2961
2962// PASSIVE EVENTS
2963
2964
2965var _VirtualDom_passiveSupported;
2966
2967try
2968{
2969 window.addEventListener('t', null, Object.defineProperty({}, 'passive', {
2970 get: function() { _VirtualDom_passiveSupported = true; }
2971 }));
2972}
2973catch(e) {}
2974
2975
2976
2977// EVENT HANDLERS
2978
2979
2980function _VirtualDom_makeCallback(eventNode, initialHandler)
2981{
2982 function callback(event)
2983 {
2984 var handler = callback.q;
2985 var result = _Json_runHelp(handler.a, event);
2986
2987 if (!$elm$core$Result$isOk(result))
2988 {
2989 return;
2990 }
2991
2992 var tag = $elm$virtual_dom$VirtualDom$toHandlerInt(handler);
2993
2994 // 0 = Normal
2995 // 1 = MayStopPropagation
2996 // 2 = MayPreventDefault
2997 // 3 = Custom
2998
2999 var value = result.a;
3000 var message = !tag ? value : tag < 3 ? value.a : value.message;
3001 var stopPropagation = tag == 1 ? value.b : tag == 3 && value.stopPropagation;
3002 var currentEventNode = (
3003 stopPropagation && event.stopPropagation(),
3004 (tag == 2 ? value.b : tag == 3 && value.preventDefault) && event.preventDefault(),
3005 eventNode
3006 );
3007 var tagger;
3008 var i;
3009 while (tagger = currentEventNode.j)
3010 {
3011 if (typeof tagger == 'function')
3012 {
3013 message = tagger(message);
3014 }
3015 else
3016 {
3017 for (var i = tagger.length; i--; )
3018 {
3019 message = tagger[i](message);
3020 }
3021 }
3022 currentEventNode = currentEventNode.p;
3023 }
3024 currentEventNode(message, stopPropagation); // stopPropagation implies isSync
3025 }
3026
3027 callback.q = initialHandler;
3028
3029 return callback;
3030}
3031
3032function _VirtualDom_equalEvents(x, y)
3033{
3034 return x.$ == y.$ && _Json_equality(x.a, y.a);
3035}
3036
3037
3038
3039// DIFF
3040
3041
3042// TODO: Should we do patches like in iOS?
3043//
3044// type Patch
3045// = At Int Patch
3046// | Batch (List Patch)
3047// | Change ...
3048//
3049// How could it not be better?
3050//
3051function _VirtualDom_diff(x, y)
3052{
3053 var patches = [];
3054 _VirtualDom_diffHelp(x, y, patches, 0);
3055 return patches;
3056}
3057
3058
3059function _VirtualDom_pushPatch(patches, type, index, data)
3060{
3061 var patch = {
3062 $: type,
3063 r: index,
3064 s: data,
3065 t: undefined,
3066 u: undefined
3067 };
3068 patches.push(patch);
3069 return patch;
3070}
3071
3072
3073function _VirtualDom_diffHelp(x, y, patches, index)
3074{
3075 if (x === y)
3076 {
3077 return;
3078 }
3079
3080 var xType = x.$;
3081 var yType = y.$;
3082
3083 // Bail if you run into different types of nodes. Implies that the
3084 // structure has changed significantly and it's not worth a diff.
3085 if (xType !== yType)
3086 {
3087 if (xType === 1 && yType === 2)
3088 {
3089 y = _VirtualDom_dekey(y);
3090 yType = 1;
3091 }
3092 else
3093 {
3094 _VirtualDom_pushPatch(patches, 0, index, y);
3095 return;
3096 }
3097 }
3098
3099 // Now we know that both nodes are the same $.
3100 switch (yType)
3101 {
3102 case 5:
3103 var xRefs = x.l;
3104 var yRefs = y.l;
3105 var i = xRefs.length;
3106 var same = i === yRefs.length;
3107 while (same && i--)
3108 {
3109 same = xRefs[i] === yRefs[i];
3110 }
3111 if (same)
3112 {
3113 y.k = x.k;
3114 return;
3115 }
3116 y.k = y.m();
3117 var subPatches = [];
3118 _VirtualDom_diffHelp(x.k, y.k, subPatches, 0);
3119 subPatches.length > 0 && _VirtualDom_pushPatch(patches, 1, index, subPatches);
3120 return;
3121
3122 case 4:
3123 // gather nested taggers
3124 var xTaggers = x.j;
3125 var yTaggers = y.j;
3126 var nesting = false;
3127
3128 var xSubNode = x.k;
3129 while (xSubNode.$ === 4)
3130 {
3131 nesting = true;
3132
3133 typeof xTaggers !== 'object'
3134 ? xTaggers = [xTaggers, xSubNode.j]
3135 : xTaggers.push(xSubNode.j);
3136
3137 xSubNode = xSubNode.k;
3138 }
3139
3140 var ySubNode = y.k;
3141 while (ySubNode.$ === 4)
3142 {
3143 nesting = true;
3144
3145 typeof yTaggers !== 'object'
3146 ? yTaggers = [yTaggers, ySubNode.j]
3147 : yTaggers.push(ySubNode.j);
3148
3149 ySubNode = ySubNode.k;
3150 }
3151
3152 // Just bail if different numbers of taggers. This implies the
3153 // structure of the virtual DOM has changed.
3154 if (nesting && xTaggers.length !== yTaggers.length)
3155 {
3156 _VirtualDom_pushPatch(patches, 0, index, y);
3157 return;
3158 }
3159
3160 // check if taggers are "the same"
3161 if (nesting ? !_VirtualDom_pairwiseRefEqual(xTaggers, yTaggers) : xTaggers !== yTaggers)
3162 {
3163 _VirtualDom_pushPatch(patches, 2, index, yTaggers);
3164 }
3165
3166 // diff everything below the taggers
3167 _VirtualDom_diffHelp(xSubNode, ySubNode, patches, index + 1);
3168 return;
3169
3170 case 0:
3171 if (x.a !== y.a)
3172 {
3173 _VirtualDom_pushPatch(patches, 3, index, y.a);
3174 }
3175 return;
3176
3177 case 1:
3178 _VirtualDom_diffNodes(x, y, patches, index, _VirtualDom_diffKids);
3179 return;
3180
3181 case 2:
3182 _VirtualDom_diffNodes(x, y, patches, index, _VirtualDom_diffKeyedKids);
3183 return;
3184
3185 case 3:
3186 if (x.h !== y.h)
3187 {
3188 _VirtualDom_pushPatch(patches, 0, index, y);
3189 return;
3190 }
3191
3192 var factsDiff = _VirtualDom_diffFacts(x.d, y.d);
3193 factsDiff && _VirtualDom_pushPatch(patches, 4, index, factsDiff);
3194
3195 var patch = y.i(x.g, y.g);
3196 patch && _VirtualDom_pushPatch(patches, 5, index, patch);
3197
3198 return;
3199 }
3200}
3201
3202// assumes the incoming arrays are the same length
3203function _VirtualDom_pairwiseRefEqual(as, bs)
3204{
3205 for (var i = 0; i < as.length; i++)
3206 {
3207 if (as[i] !== bs[i])
3208 {
3209 return false;
3210 }
3211 }
3212
3213 return true;
3214}
3215
3216function _VirtualDom_diffNodes(x, y, patches, index, diffKids)
3217{
3218 // Bail if obvious indicators have changed. Implies more serious
3219 // structural changes such that it's not worth it to diff.
3220 if (x.c !== y.c || x.f !== y.f)
3221 {
3222 _VirtualDom_pushPatch(patches, 0, index, y);
3223 return;
3224 }
3225
3226 var factsDiff = _VirtualDom_diffFacts(x.d, y.d);
3227 factsDiff && _VirtualDom_pushPatch(patches, 4, index, factsDiff);
3228
3229 diffKids(x, y, patches, index);
3230}
3231
3232
3233
3234// DIFF FACTS
3235
3236
3237// TODO Instead of creating a new diff object, it's possible to just test if
3238// there *is* a diff. During the actual patch, do the diff again and make the
3239// modifications directly. This way, there's no new allocations. Worth it?
3240function _VirtualDom_diffFacts(x, y, category)
3241{
3242 var diff;
3243
3244 // look for changes and removals
3245 for (var xKey in x)
3246 {
3247 if (xKey === 'a1' || xKey === 'a0' || xKey === 'a3' || xKey === 'a4')
3248 {
3249 var subDiff = _VirtualDom_diffFacts(x[xKey], y[xKey] || {}, xKey);
3250 if (subDiff)
3251 {
3252 diff = diff || {};
3253 diff[xKey] = subDiff;
3254 }
3255 continue;
3256 }
3257
3258 // remove if not in the new facts
3259 if (!(xKey in y))
3260 {
3261 diff = diff || {};
3262 diff[xKey] =
3263 !category
3264 ? (typeof x[xKey] === 'string' ? '' : null)
3265 :
3266 (category === 'a1')
3267 ? ''
3268 :
3269 (category === 'a0' || category === 'a3')
3270 ? undefined
3271 :
3272 { f: x[xKey].f, o: undefined };
3273
3274 continue;
3275 }
3276
3277 var xValue = x[xKey];
3278 var yValue = y[xKey];
3279
3280 // reference equal, so don't worry about it
3281 if (xValue === yValue && xKey !== 'value' && xKey !== 'checked'
3282 || category === 'a0' && _VirtualDom_equalEvents(xValue, yValue))
3283 {
3284 continue;
3285 }
3286
3287 diff = diff || {};
3288 diff[xKey] = yValue;
3289 }
3290
3291 // add new stuff
3292 for (var yKey in y)
3293 {
3294 if (!(yKey in x))
3295 {
3296 diff = diff || {};
3297 diff[yKey] = y[yKey];
3298 }
3299 }
3300
3301 return diff;
3302}
3303
3304
3305
3306// DIFF KIDS
3307
3308
3309function _VirtualDom_diffKids(xParent, yParent, patches, index)
3310{
3311 var xKids = xParent.e;
3312 var yKids = yParent.e;
3313
3314 var xLen = xKids.length;
3315 var yLen = yKids.length;
3316
3317 // FIGURE OUT IF THERE ARE INSERTS OR REMOVALS
3318
3319 if (xLen > yLen)
3320 {
3321 _VirtualDom_pushPatch(patches, 6, index, {
3322 v: yLen,
3323 i: xLen - yLen
3324 });
3325 }
3326 else if (xLen < yLen)
3327 {
3328 _VirtualDom_pushPatch(patches, 7, index, {
3329 v: xLen,
3330 e: yKids
3331 });
3332 }
3333
3334 // PAIRWISE DIFF EVERYTHING ELSE
3335
3336 for (var minLen = xLen < yLen ? xLen : yLen, i = 0; i < minLen; i++)
3337 {
3338 var xKid = xKids[i];
3339 _VirtualDom_diffHelp(xKid, yKids[i], patches, ++index);
3340 index += xKid.b || 0;
3341 }
3342}
3343
3344
3345
3346// KEYED DIFF
3347
3348
3349function _VirtualDom_diffKeyedKids(xParent, yParent, patches, rootIndex)
3350{
3351 var localPatches = [];
3352
3353 var changes = {}; // Dict String Entry
3354 var inserts = []; // Array { index : Int, entry : Entry }
3355 // type Entry = { tag : String, vnode : VNode, index : Int, data : _ }
3356
3357 var xKids = xParent.e;
3358 var yKids = yParent.e;
3359 var xLen = xKids.length;
3360 var yLen = yKids.length;
3361 var xIndex = 0;
3362 var yIndex = 0;
3363
3364 var index = rootIndex;
3365
3366 while (xIndex < xLen && yIndex < yLen)
3367 {
3368 var x = xKids[xIndex];
3369 var y = yKids[yIndex];
3370
3371 var xKey = x.a;
3372 var yKey = y.a;
3373 var xNode = x.b;
3374 var yNode = y.b;
3375
3376 var newMatch = undefined;
3377 var oldMatch = undefined;
3378
3379 // check if keys match
3380
3381 if (xKey === yKey)
3382 {
3383 index++;
3384 _VirtualDom_diffHelp(xNode, yNode, localPatches, index);
3385 index += xNode.b || 0;
3386
3387 xIndex++;
3388 yIndex++;
3389 continue;
3390 }
3391
3392 // look ahead 1 to detect insertions and removals.
3393
3394 var xNext = xKids[xIndex + 1];
3395 var yNext = yKids[yIndex + 1];
3396
3397 if (xNext)
3398 {
3399 var xNextKey = xNext.a;
3400 var xNextNode = xNext.b;
3401 oldMatch = yKey === xNextKey;
3402 }
3403
3404 if (yNext)
3405 {
3406 var yNextKey = yNext.a;
3407 var yNextNode = yNext.b;
3408 newMatch = xKey === yNextKey;
3409 }
3410
3411
3412 // swap x and y
3413 if (newMatch && oldMatch)
3414 {
3415 index++;
3416 _VirtualDom_diffHelp(xNode, yNextNode, localPatches, index);
3417 _VirtualDom_insertNode(changes, localPatches, xKey, yNode, yIndex, inserts);
3418 index += xNode.b || 0;
3419
3420 index++;
3421 _VirtualDom_removeNode(changes, localPatches, xKey, xNextNode, index);
3422 index += xNextNode.b || 0;
3423
3424 xIndex += 2;
3425 yIndex += 2;
3426 continue;
3427 }
3428
3429 // insert y
3430 if (newMatch)
3431 {
3432 index++;
3433 _VirtualDom_insertNode(changes, localPatches, yKey, yNode, yIndex, inserts);
3434 _VirtualDom_diffHelp(xNode, yNextNode, localPatches, index);
3435 index += xNode.b || 0;
3436
3437 xIndex += 1;
3438 yIndex += 2;
3439 continue;
3440 }
3441
3442 // remove x
3443 if (oldMatch)
3444 {
3445 index++;
3446 _VirtualDom_removeNode(changes, localPatches, xKey, xNode, index);
3447 index += xNode.b || 0;
3448
3449 index++;
3450 _VirtualDom_diffHelp(xNextNode, yNode, localPatches, index);
3451 index += xNextNode.b || 0;
3452
3453 xIndex += 2;
3454 yIndex += 1;
3455 continue;
3456 }
3457
3458 // remove x, insert y
3459 if (xNext && xNextKey === yNextKey)
3460 {
3461 index++;
3462 _VirtualDom_removeNode(changes, localPatches, xKey, xNode, index);
3463 _VirtualDom_insertNode(changes, localPatches, yKey, yNode, yIndex, inserts);
3464 index += xNode.b || 0;
3465
3466 index++;
3467 _VirtualDom_diffHelp(xNextNode, yNextNode, localPatches, index);
3468 index += xNextNode.b || 0;
3469
3470 xIndex += 2;
3471 yIndex += 2;
3472 continue;
3473 }
3474
3475 break;
3476 }
3477
3478 // eat up any remaining nodes with removeNode and insertNode
3479
3480 while (xIndex < xLen)
3481 {
3482 index++;
3483 var x = xKids[xIndex];
3484 var xNode = x.b;
3485 _VirtualDom_removeNode(changes, localPatches, x.a, xNode, index);
3486 index += xNode.b || 0;
3487 xIndex++;
3488 }
3489
3490 while (yIndex < yLen)
3491 {
3492 var endInserts = endInserts || [];
3493 var y = yKids[yIndex];
3494 _VirtualDom_insertNode(changes, localPatches, y.a, y.b, undefined, endInserts);
3495 yIndex++;
3496 }
3497
3498 if (localPatches.length > 0 || inserts.length > 0 || endInserts)
3499 {
3500 _VirtualDom_pushPatch(patches, 8, rootIndex, {
3501 w: localPatches,
3502 x: inserts,
3503 y: endInserts
3504 });
3505 }
3506}
3507
3508
3509
3510// CHANGES FROM KEYED DIFF
3511
3512
3513var _VirtualDom_POSTFIX = '_elmW6BL';
3514
3515
3516function _VirtualDom_insertNode(changes, localPatches, key, vnode, yIndex, inserts)
3517{
3518 var entry = changes[key];
3519
3520 // never seen this key before
3521 if (!entry)
3522 {
3523 entry = {
3524 c: 0,
3525 z: vnode,
3526 r: yIndex,
3527 s: undefined
3528 };
3529
3530 inserts.push({ r: yIndex, A: entry });
3531 changes[key] = entry;
3532
3533 return;
3534 }
3535
3536 // this key was removed earlier, a match!
3537 if (entry.c === 1)
3538 {
3539 inserts.push({ r: yIndex, A: entry });
3540
3541 entry.c = 2;
3542 var subPatches = [];
3543 _VirtualDom_diffHelp(entry.z, vnode, subPatches, entry.r);
3544 entry.r = yIndex;
3545 entry.s.s = {
3546 w: subPatches,
3547 A: entry
3548 };
3549
3550 return;
3551 }
3552
3553 // this key has already been inserted or moved, a duplicate!
3554 _VirtualDom_insertNode(changes, localPatches, key + _VirtualDom_POSTFIX, vnode, yIndex, inserts);
3555}
3556
3557
3558function _VirtualDom_removeNode(changes, localPatches, key, vnode, index)
3559{
3560 var entry = changes[key];
3561
3562 // never seen this key before
3563 if (!entry)
3564 {
3565 var patch = _VirtualDom_pushPatch(localPatches, 9, index, undefined);
3566
3567 changes[key] = {
3568 c: 1,
3569 z: vnode,
3570 r: index,
3571 s: patch
3572 };
3573
3574 return;
3575 }
3576
3577 // this key was inserted earlier, a match!
3578 if (entry.c === 0)
3579 {
3580 entry.c = 2;
3581 var subPatches = [];
3582 _VirtualDom_diffHelp(vnode, entry.z, subPatches, index);
3583
3584 _VirtualDom_pushPatch(localPatches, 9, index, {
3585 w: subPatches,
3586 A: entry
3587 });
3588
3589 return;
3590 }
3591
3592 // this key has already been removed or moved, a duplicate!
3593 _VirtualDom_removeNode(changes, localPatches, key + _VirtualDom_POSTFIX, vnode, index);
3594}
3595
3596
3597
3598// ADD DOM NODES
3599//
3600// Each DOM node has an "index" assigned in order of traversal. It is important
3601// to minimize our crawl over the actual DOM, so these indexes (along with the
3602// descendantsCount of virtual nodes) let us skip touching entire subtrees of
3603// the DOM if we know there are no patches there.
3604
3605
3606function _VirtualDom_addDomNodes(domNode, vNode, patches, eventNode)
3607{
3608 _VirtualDom_addDomNodesHelp(domNode, vNode, patches, 0, 0, vNode.b, eventNode);
3609}
3610
3611
3612// assumes `patches` is non-empty and indexes increase monotonically.
3613function _VirtualDom_addDomNodesHelp(domNode, vNode, patches, i, low, high, eventNode)
3614{
3615 var patch = patches[i];
3616 var index = patch.r;
3617
3618 while (index === low)
3619 {
3620 var patchType = patch.$;
3621
3622 if (patchType === 1)
3623 {
3624 _VirtualDom_addDomNodes(domNode, vNode.k, patch.s, eventNode);
3625 }
3626 else if (patchType === 8)
3627 {
3628 patch.t = domNode;
3629 patch.u = eventNode;
3630
3631 var subPatches = patch.s.w;
3632 if (subPatches.length > 0)
3633 {
3634 _VirtualDom_addDomNodesHelp(domNode, vNode, subPatches, 0, low, high, eventNode);
3635 }
3636 }
3637 else if (patchType === 9)
3638 {
3639 patch.t = domNode;
3640 patch.u = eventNode;
3641
3642 var data = patch.s;
3643 if (data)
3644 {
3645 data.A.s = domNode;
3646 var subPatches = data.w;
3647 if (subPatches.length > 0)
3648 {
3649 _VirtualDom_addDomNodesHelp(domNode, vNode, subPatches, 0, low, high, eventNode);
3650 }
3651 }
3652 }
3653 else
3654 {
3655 patch.t = domNode;
3656 patch.u = eventNode;
3657 }
3658
3659 i++;
3660
3661 if (!(patch = patches[i]) || (index = patch.r) > high)
3662 {
3663 return i;
3664 }
3665 }
3666
3667 var tag = vNode.$;
3668
3669 if (tag === 4)
3670 {
3671 var subNode = vNode.k;
3672
3673 while (subNode.$ === 4)
3674 {
3675 subNode = subNode.k;
3676 }
3677
3678 return _VirtualDom_addDomNodesHelp(domNode, subNode, patches, i, low + 1, high, domNode.elm_event_node_ref);
3679 }
3680
3681 // tag must be 1 or 2 at this point
3682
3683 var vKids = vNode.e;
3684 var childNodes = domNode.childNodes;
3685 for (var j = 0; j < vKids.length; j++)
3686 {
3687 low++;
3688 var vKid = tag === 1 ? vKids[j] : vKids[j].b;
3689 var nextLow = low + (vKid.b || 0);
3690 if (low <= index && index <= nextLow)
3691 {
3692 i = _VirtualDom_addDomNodesHelp(childNodes[j], vKid, patches, i, low, nextLow, eventNode);
3693 if (!(patch = patches[i]) || (index = patch.r) > high)
3694 {
3695 return i;
3696 }
3697 }
3698 low = nextLow;
3699 }
3700 return i;
3701}
3702
3703
3704
3705// APPLY PATCHES
3706
3707
3708function _VirtualDom_applyPatches(rootDomNode, oldVirtualNode, patches, eventNode)
3709{
3710 if (patches.length === 0)
3711 {
3712 return rootDomNode;
3713 }
3714
3715 _VirtualDom_addDomNodes(rootDomNode, oldVirtualNode, patches, eventNode);
3716 return _VirtualDom_applyPatchesHelp(rootDomNode, patches);
3717}
3718
3719function _VirtualDom_applyPatchesHelp(rootDomNode, patches)
3720{
3721 for (var i = 0; i < patches.length; i++)
3722 {
3723 var patch = patches[i];
3724 var localDomNode = patch.t
3725 var newNode = _VirtualDom_applyPatch(localDomNode, patch);
3726 if (localDomNode === rootDomNode)
3727 {
3728 rootDomNode = newNode;
3729 }
3730 }
3731 return rootDomNode;
3732}
3733
3734function _VirtualDom_applyPatch(domNode, patch)
3735{
3736 switch (patch.$)
3737 {
3738 case 0:
3739 return _VirtualDom_applyPatchRedraw(domNode, patch.s, patch.u);
3740
3741 case 4:
3742 _VirtualDom_applyFacts(domNode, patch.u, patch.s);
3743 return domNode;
3744
3745 case 3:
3746 domNode.replaceData(0, domNode.length, patch.s);
3747 return domNode;
3748
3749 case 1:
3750 return _VirtualDom_applyPatchesHelp(domNode, patch.s);
3751
3752 case 2:
3753 if (domNode.elm_event_node_ref)
3754 {
3755 domNode.elm_event_node_ref.j = patch.s;
3756 }
3757 else
3758 {
3759 domNode.elm_event_node_ref = { j: patch.s, p: patch.u };
3760 }
3761 return domNode;
3762
3763 case 6:
3764 var data = patch.s;
3765 for (var i = 0; i < data.i; i++)
3766 {
3767 domNode.removeChild(domNode.childNodes[data.v]);
3768 }
3769 return domNode;
3770
3771 case 7:
3772 var data = patch.s;
3773 var kids = data.e;
3774 var i = data.v;
3775 var theEnd = domNode.childNodes[i];
3776 for (; i < kids.length; i++)
3777 {
3778 domNode.insertBefore(_VirtualDom_render(kids[i], patch.u), theEnd);
3779 }
3780 return domNode;
3781
3782 case 9:
3783 var data = patch.s;
3784 if (!data)
3785 {
3786 domNode.parentNode.removeChild(domNode);
3787 return domNode;
3788 }
3789 var entry = data.A;
3790 if (typeof entry.r !== 'undefined')
3791 {
3792 domNode.parentNode.removeChild(domNode);
3793 }
3794 entry.s = _VirtualDom_applyPatchesHelp(domNode, data.w);
3795 return domNode;
3796
3797 case 8:
3798 return _VirtualDom_applyPatchReorder(domNode, patch);
3799
3800 case 5:
3801 return patch.s(domNode);
3802
3803 default:
3804 _Debug_crash(10); // 'Ran into an unknown patch!'
3805 }
3806}
3807
3808
3809function _VirtualDom_applyPatchRedraw(domNode, vNode, eventNode)
3810{
3811 var parentNode = domNode.parentNode;
3812 var newNode = _VirtualDom_render(vNode, eventNode);
3813
3814 if (!newNode.elm_event_node_ref)
3815 {
3816 newNode.elm_event_node_ref = domNode.elm_event_node_ref;
3817 }
3818
3819 if (parentNode && newNode !== domNode)
3820 {
3821 parentNode.replaceChild(newNode, domNode);
3822 }
3823 return newNode;
3824}
3825
3826
3827function _VirtualDom_applyPatchReorder(domNode, patch)
3828{
3829 var data = patch.s;
3830
3831 // remove end inserts
3832 var frag = _VirtualDom_applyPatchReorderEndInsertsHelp(data.y, patch);
3833
3834 // removals
3835 domNode = _VirtualDom_applyPatchesHelp(domNode, data.w);
3836
3837 // inserts
3838 var inserts = data.x;
3839 for (var i = 0; i < inserts.length; i++)
3840 {
3841 var insert = inserts[i];
3842 var entry = insert.A;
3843 var node = entry.c === 2
3844 ? entry.s
3845 : _VirtualDom_render(entry.z, patch.u);
3846 domNode.insertBefore(node, domNode.childNodes[insert.r]);
3847 }
3848
3849 // add end inserts
3850 if (frag)
3851 {
3852 _VirtualDom_appendChild(domNode, frag);
3853 }
3854
3855 return domNode;
3856}
3857
3858
3859function _VirtualDom_applyPatchReorderEndInsertsHelp(endInserts, patch)
3860{
3861 if (!endInserts)
3862 {
3863 return;
3864 }
3865
3866 var frag = _VirtualDom_doc.createDocumentFragment();
3867 for (var i = 0; i < endInserts.length; i++)
3868 {
3869 var insert = endInserts[i];
3870 var entry = insert.A;
3871 _VirtualDom_appendChild(frag, entry.c === 2
3872 ? entry.s
3873 : _VirtualDom_render(entry.z, patch.u)
3874 );
3875 }
3876 return frag;
3877}
3878
3879
3880function _VirtualDom_virtualize(node)
3881{
3882 // TEXT NODES
3883
3884 if (node.nodeType === 3)
3885 {
3886 return _VirtualDom_text(node.textContent);
3887 }
3888
3889
3890 // WEIRD NODES
3891
3892 if (node.nodeType !== 1)
3893 {
3894 return _VirtualDom_text('');
3895 }
3896
3897
3898 // ELEMENT NODES
3899
3900 var attrList = _List_Nil;
3901 var attrs = node.attributes;
3902 for (var i = attrs.length; i--; )
3903 {
3904 var attr = attrs[i];
3905 var name = attr.name;
3906 var value = attr.value;
3907 attrList = _List_Cons( A2(_VirtualDom_attribute, name, value), attrList );
3908 }
3909
3910 var tag = node.tagName.toLowerCase();
3911 var kidList = _List_Nil;
3912 var kids = node.childNodes;
3913
3914 for (var i = kids.length; i--; )
3915 {
3916 kidList = _List_Cons(_VirtualDom_virtualize(kids[i]), kidList);
3917 }
3918 return A3(_VirtualDom_node, tag, attrList, kidList);
3919}
3920
3921function _VirtualDom_dekey(keyedNode)
3922{
3923 var keyedKids = keyedNode.e;
3924 var len = keyedKids.length;
3925 var kids = new Array(len);
3926 for (var i = 0; i < len; i++)
3927 {
3928 kids[i] = keyedKids[i].b;
3929 }
3930
3931 return {
3932 $: 1,
3933 c: keyedNode.c,
3934 d: keyedNode.d,
3935 e: kids,
3936 f: keyedNode.f,
3937 b: keyedNode.b
3938 };
3939}
3940
3941
3942
3943
3944// ELEMENT
3945
3946
3947var _Debugger_element;
3948
3949var _Browser_element = _Debugger_element || F4(function(impl, flagDecoder, debugMetadata, args)
3950{
3951 return _Platform_initialize(
3952 flagDecoder,
3953 args,
3954 impl.init,
3955 impl.update,
3956 impl.subscriptions,
3957 function(sendToApp, initialModel) {
3958 var view = impl.view;
3959 /**_UNUSED/
3960 var domNode = args['node'];
3961 //*/
3962 /**/
3963 var domNode = args && args['node'] ? args['node'] : _Debug_crash(0);
3964 //*/
3965 var currNode = _VirtualDom_virtualize(domNode);
3966
3967 return _Browser_makeAnimator(initialModel, function(model)
3968 {
3969 var nextNode = view(model);
3970 var patches = _VirtualDom_diff(currNode, nextNode);
3971 domNode = _VirtualDom_applyPatches(domNode, currNode, patches, sendToApp);
3972 currNode = nextNode;
3973 });
3974 }
3975 );
3976});
3977
3978
3979
3980// DOCUMENT
3981
3982
3983var _Debugger_document;
3984
3985var _Browser_document = _Debugger_document || F4(function(impl, flagDecoder, debugMetadata, args)
3986{
3987 return _Platform_initialize(
3988 flagDecoder,
3989 args,
3990 impl.init,
3991 impl.update,
3992 impl.subscriptions,
3993 function(sendToApp, initialModel) {
3994 var divertHrefToApp = impl.setup && impl.setup(sendToApp)
3995 var view = impl.view;
3996 var title = _VirtualDom_doc.title;
3997 var bodyNode = _VirtualDom_doc.body;
3998 var currNode = _VirtualDom_virtualize(bodyNode);
3999 return _Browser_makeAnimator(initialModel, function(model)
4000 {
4001 _VirtualDom_divertHrefToApp = divertHrefToApp;
4002 var doc = view(model);
4003 var nextNode = _VirtualDom_node('body')(_List_Nil)(doc.body);
4004 var patches = _VirtualDom_diff(currNode, nextNode);
4005 bodyNode = _VirtualDom_applyPatches(bodyNode, currNode, patches, sendToApp);
4006 currNode = nextNode;
4007 _VirtualDom_divertHrefToApp = 0;
4008 (title !== doc.title) && (_VirtualDom_doc.title = title = doc.title);
4009 });
4010 }
4011 );
4012});
4013
4014
4015
4016// ANIMATION
4017
4018
4019var _Browser_cancelAnimationFrame =
4020 typeof cancelAnimationFrame !== 'undefined'
4021 ? cancelAnimationFrame
4022 : function(id) { clearTimeout(id); };
4023
4024var _Browser_requestAnimationFrame =
4025 typeof requestAnimationFrame !== 'undefined'
4026 ? requestAnimationFrame
4027 : function(callback) { return setTimeout(callback, 1000 / 60); };
4028
4029
4030function _Browser_makeAnimator(model, draw)
4031{
4032 draw(model);
4033
4034 var state = 0;
4035
4036 function updateIfNeeded()
4037 {
4038 state = state === 1
4039 ? 0
4040 : ( _Browser_requestAnimationFrame(updateIfNeeded), draw(model), 1 );
4041 }
4042
4043 return function(nextModel, isSync)
4044 {
4045 model = nextModel;
4046
4047 isSync
4048 ? ( draw(model),
4049 state === 2 && (state = 1)
4050 )
4051 : ( state === 0 && _Browser_requestAnimationFrame(updateIfNeeded),
4052 state = 2
4053 );
4054 };
4055}
4056
4057
4058
4059// APPLICATION
4060
4061
4062function _Browser_application(impl)
4063{
4064 var onUrlChange = impl.onUrlChange;
4065 var onUrlRequest = impl.onUrlRequest;
4066 var key = function() { key.a(onUrlChange(_Browser_getUrl())); };
4067
4068 return _Browser_document({
4069 setup: function(sendToApp)
4070 {
4071 key.a = sendToApp;
4072 _Browser_window.addEventListener('popstate', key);
4073 _Browser_window.navigator.userAgent.indexOf('Trident') < 0 || _Browser_window.addEventListener('hashchange', key);
4074
4075 return F2(function(domNode, event)
4076 {
4077 if (!event.ctrlKey && !event.metaKey && !event.shiftKey && event.button < 1 && !domNode.target && !domNode.hasAttribute('download'))
4078 {
4079 event.preventDefault();
4080 var href = domNode.href;
4081 var curr = _Browser_getUrl();
4082 var next = $elm$url$Url$fromString(href).a;
4083 sendToApp(onUrlRequest(
4084 (next
4085 && curr.protocol === next.protocol
4086 && curr.host === next.host
4087 && curr.port_.a === next.port_.a
4088 )
4089 ? $elm$browser$Browser$Internal(next)
4090 : $elm$browser$Browser$External(href)
4091 ));
4092 }
4093 });
4094 },
4095 init: function(flags)
4096 {
4097 return A3(impl.init, flags, _Browser_getUrl(), key);
4098 },
4099 view: impl.view,
4100 update: impl.update,
4101 subscriptions: impl.subscriptions
4102 });
4103}
4104
4105function _Browser_getUrl()
4106{
4107 return $elm$url$Url$fromString(_VirtualDom_doc.location.href).a || _Debug_crash(1);
4108}
4109
4110var _Browser_go = F2(function(key, n)
4111{
4112 return A2($elm$core$Task$perform, $elm$core$Basics$never, _Scheduler_binding(function() {
4113 n && history.go(n);
4114 key();
4115 }));
4116});
4117
4118var _Browser_pushUrl = F2(function(key, url)
4119{
4120 return A2($elm$core$Task$perform, $elm$core$Basics$never, _Scheduler_binding(function() {
4121 history.pushState({}, '', url);
4122 key();
4123 }));
4124});
4125
4126var _Browser_replaceUrl = F2(function(key, url)
4127{
4128 return A2($elm$core$Task$perform, $elm$core$Basics$never, _Scheduler_binding(function() {
4129 history.replaceState({}, '', url);
4130 key();
4131 }));
4132});
4133
4134
4135
4136// GLOBAL EVENTS
4137
4138
4139var _Browser_fakeNode = { addEventListener: function() {}, removeEventListener: function() {} };
4140var _Browser_doc = typeof document !== 'undefined' ? document : _Browser_fakeNode;
4141var _Browser_window = typeof window !== 'undefined' ? window : _Browser_fakeNode;
4142
4143var _Browser_on = F3(function(node, eventName, sendToSelf)
4144{
4145 return _Scheduler_spawn(_Scheduler_binding(function(callback)
4146 {
4147 function handler(event) { _Scheduler_rawSpawn(sendToSelf(event)); }
4148 node.addEventListener(eventName, handler, _VirtualDom_passiveSupported && { passive: true });
4149 return function() { node.removeEventListener(eventName, handler); };
4150 }));
4151});
4152
4153var _Browser_decodeEvent = F2(function(decoder, event)
4154{
4155 var result = _Json_runHelp(decoder, event);
4156 return $elm$core$Result$isOk(result) ? $elm$core$Maybe$Just(result.a) : $elm$core$Maybe$Nothing;
4157});
4158
4159
4160
4161// PAGE VISIBILITY
4162
4163
4164function _Browser_visibilityInfo()
4165{
4166 return (typeof _VirtualDom_doc.hidden !== 'undefined')
4167 ? { hidden: 'hidden', change: 'visibilitychange' }
4168 :
4169 (typeof _VirtualDom_doc.mozHidden !== 'undefined')
4170 ? { hidden: 'mozHidden', change: 'mozvisibilitychange' }
4171 :
4172 (typeof _VirtualDom_doc.msHidden !== 'undefined')
4173 ? { hidden: 'msHidden', change: 'msvisibilitychange' }
4174 :
4175 (typeof _VirtualDom_doc.webkitHidden !== 'undefined')
4176 ? { hidden: 'webkitHidden', change: 'webkitvisibilitychange' }
4177 : { hidden: 'hidden', change: 'visibilitychange' };
4178}
4179
4180
4181
4182// ANIMATION FRAMES
4183
4184
4185function _Browser_rAF()
4186{
4187 return _Scheduler_binding(function(callback)
4188 {
4189 var id = _Browser_requestAnimationFrame(function() {
4190 callback(_Scheduler_succeed(Date.now()));
4191 });
4192
4193 return function() {
4194 _Browser_cancelAnimationFrame(id);
4195 };
4196 });
4197}
4198
4199
4200function _Browser_now()
4201{
4202 return _Scheduler_binding(function(callback)
4203 {
4204 callback(_Scheduler_succeed(Date.now()));
4205 });
4206}
4207
4208
4209
4210// DOM STUFF
4211
4212
4213function _Browser_withNode(id, doStuff)
4214{
4215 return _Scheduler_binding(function(callback)
4216 {
4217 _Browser_requestAnimationFrame(function() {
4218 var node = document.getElementById(id);
4219 callback(node
4220 ? _Scheduler_succeed(doStuff(node))
4221 : _Scheduler_fail($elm$browser$Browser$Dom$NotFound(id))
4222 );
4223 });
4224 });
4225}
4226
4227
4228function _Browser_withWindow(doStuff)
4229{
4230 return _Scheduler_binding(function(callback)
4231 {
4232 _Browser_requestAnimationFrame(function() {
4233 callback(_Scheduler_succeed(doStuff()));
4234 });
4235 });
4236}
4237
4238
4239// FOCUS and BLUR
4240
4241
4242var _Browser_call = F2(function(functionName, id)
4243{
4244 return _Browser_withNode(id, function(node) {
4245 node[functionName]();
4246 return _Utils_Tuple0;
4247 });
4248});
4249
4250
4251
4252// WINDOW VIEWPORT
4253
4254
4255function _Browser_getViewport()
4256{
4257 return {
4258 scene: _Browser_getScene(),
4259 viewport: {
4260 x: _Browser_window.pageXOffset,
4261 y: _Browser_window.pageYOffset,
4262 width: _Browser_doc.documentElement.clientWidth,
4263 height: _Browser_doc.documentElement.clientHeight
4264 }
4265 };
4266}
4267
4268function _Browser_getScene()
4269{
4270 var body = _Browser_doc.body;
4271 var elem = _Browser_doc.documentElement;
4272 return {
4273 width: Math.max(body.scrollWidth, body.offsetWidth, elem.scrollWidth, elem.offsetWidth, elem.clientWidth),
4274 height: Math.max(body.scrollHeight, body.offsetHeight, elem.scrollHeight, elem.offsetHeight, elem.clientHeight)
4275 };
4276}
4277
4278var _Browser_setViewport = F2(function(x, y)
4279{
4280 return _Browser_withWindow(function()
4281 {
4282 _Browser_window.scroll(x, y);
4283 return _Utils_Tuple0;
4284 });
4285});
4286
4287
4288
4289// ELEMENT VIEWPORT
4290
4291
4292function _Browser_getViewportOf(id)
4293{
4294 return _Browser_withNode(id, function(node)
4295 {
4296 return {
4297 scene: {
4298 width: node.scrollWidth,
4299 height: node.scrollHeight
4300 },
4301 viewport: {
4302 x: node.scrollLeft,
4303 y: node.scrollTop,
4304 width: node.clientWidth,
4305 height: node.clientHeight
4306 }
4307 };
4308 });
4309}
4310
4311
4312var _Browser_setViewportOf = F3(function(id, x, y)
4313{
4314 return _Browser_withNode(id, function(node)
4315 {
4316 node.scrollLeft = x;
4317 node.scrollTop = y;
4318 return _Utils_Tuple0;
4319 });
4320});
4321
4322
4323
4324// ELEMENT
4325
4326
4327function _Browser_getElement(id)
4328{
4329 return _Browser_withNode(id, function(node)
4330 {
4331 var rect = node.getBoundingClientRect();
4332 var x = _Browser_window.pageXOffset;
4333 var y = _Browser_window.pageYOffset;
4334 return {
4335 scene: _Browser_getScene(),
4336 viewport: {
4337 x: x,
4338 y: y,
4339 width: _Browser_doc.documentElement.clientWidth,
4340 height: _Browser_doc.documentElement.clientHeight
4341 },
4342 element: {
4343 x: x + rect.left,
4344 y: y + rect.top,
4345 width: rect.width,
4346 height: rect.height
4347 }
4348 };
4349 });
4350}
4351
4352
4353
4354// LOAD and RELOAD
4355
4356
4357function _Browser_reload(skipCache)
4358{
4359 return A2($elm$core$Task$perform, $elm$core$Basics$never, _Scheduler_binding(function(callback)
4360 {
4361 _VirtualDom_doc.location.reload(skipCache);
4362 }));
4363}
4364
4365function _Browser_load(url)
4366{
4367 return A2($elm$core$Task$perform, $elm$core$Basics$never, _Scheduler_binding(function(callback)
4368 {
4369 try
4370 {
4371 _Browser_window.location = url;
4372 }
4373 catch(err)
4374 {
4375 // Only Firefox can throw a NS_ERROR_MALFORMED_URI exception here.
4376 // Other browsers reload the page, so let's be consistent about that.
4377 _VirtualDom_doc.location.reload(false);
4378 }
4379 }));
4380}
4381
4382
4383
4384// SEND REQUEST
4385
4386var _Http_toTask = F3(function(router, toTask, request)
4387{
4388 return _Scheduler_binding(function(callback)
4389 {
4390 function done(response) {
4391 callback(toTask(request.expect.a(response)));
4392 }
4393
4394 var xhr = new XMLHttpRequest();
4395 xhr.addEventListener('error', function() { done($elm$http$Http$NetworkError_); });
4396 xhr.addEventListener('timeout', function() { done($elm$http$Http$Timeout_); });
4397 xhr.addEventListener('load', function() { done(_Http_toResponse(request.expect.b, xhr)); });
4398 $elm$core$Maybe$isJust(request.tracker) && _Http_track(router, xhr, request.tracker.a);
4399
4400 try {
4401 xhr.open(request.method, request.url, true);
4402 } catch (e) {
4403 return done($elm$http$Http$BadUrl_(request.url));
4404 }
4405
4406 _Http_configureRequest(xhr, request);
4407
4408 request.body.a && xhr.setRequestHeader('Content-Type', request.body.a);
4409 xhr.send(request.body.b);
4410
4411 return function() { xhr.c = true; xhr.abort(); };
4412 });
4413});
4414
4415
4416// CONFIGURE
4417
4418function _Http_configureRequest(xhr, request)
4419{
4420 for (var headers = request.headers; headers.b; headers = headers.b) // WHILE_CONS
4421 {
4422 xhr.setRequestHeader(headers.a.a, headers.a.b);
4423 }
4424 xhr.timeout = request.timeout.a || 0;
4425 xhr.responseType = request.expect.d;
4426 xhr.withCredentials = request.allowCookiesFromOtherDomains;
4427}
4428
4429
4430// RESPONSES
4431
4432function _Http_toResponse(toBody, xhr)
4433{
4434 return A2(
4435 200 <= xhr.status && xhr.status < 300 ? $elm$http$Http$GoodStatus_ : $elm$http$Http$BadStatus_,
4436 _Http_toMetadata(xhr),
4437 toBody(xhr.response)
4438 );
4439}
4440
4441
4442// METADATA
4443
4444function _Http_toMetadata(xhr)
4445{
4446 return {
4447 url: xhr.responseURL,
4448 statusCode: xhr.status,
4449 statusText: xhr.statusText,
4450 headers: _Http_parseHeaders(xhr.getAllResponseHeaders())
4451 };
4452}
4453
4454
4455// HEADERS
4456
4457function _Http_parseHeaders(rawHeaders)
4458{
4459 if (!rawHeaders)
4460 {
4461 return $elm$core$Dict$empty;
4462 }
4463
4464 var headers = $elm$core$Dict$empty;
4465 var headerPairs = rawHeaders.split('\r\n');
4466 for (var i = headerPairs.length; i--; )
4467 {
4468 var headerPair = headerPairs[i];
4469 var index = headerPair.indexOf(': ');
4470 if (index > 0)
4471 {
4472 var key = headerPair.substring(0, index);
4473 var value = headerPair.substring(index + 2);
4474
4475 headers = A3($elm$core$Dict$update, key, function(oldValue) {
4476 return $elm$core$Maybe$Just($elm$core$Maybe$isJust(oldValue)
4477 ? value + ', ' + oldValue.a
4478 : value
4479 );
4480 }, headers);
4481 }
4482 }
4483 return headers;
4484}
4485
4486
4487// EXPECT
4488
4489var _Http_expect = F3(function(type, toBody, toValue)
4490{
4491 return {
4492 $: 0,
4493 d: type,
4494 b: toBody,
4495 a: toValue
4496 };
4497});
4498
4499var _Http_mapExpect = F2(function(func, expect)
4500{
4501 return {
4502 $: 0,
4503 d: expect.d,
4504 b: expect.b,
4505 a: function(x) { return func(expect.a(x)); }
4506 };
4507});
4508
4509function _Http_toDataView(arrayBuffer)
4510{
4511 return new DataView(arrayBuffer);
4512}
4513
4514
4515// BODY and PARTS
4516
4517var _Http_emptyBody = { $: 0 };
4518var _Http_pair = F2(function(a, b) { return { $: 0, a: a, b: b }; });
4519
4520function _Http_toFormData(parts)
4521{
4522 for (var formData = new FormData(); parts.b; parts = parts.b) // WHILE_CONS
4523 {
4524 var part = parts.a;
4525 formData.append(part.a, part.b);
4526 }
4527 return formData;
4528}
4529
4530var _Http_bytesToBlob = F2(function(mime, bytes)
4531{
4532 return new Blob([bytes], { type: mime });
4533});
4534
4535
4536// PROGRESS
4537
4538function _Http_track(router, xhr, tracker)
4539{
4540 // TODO check out lengthComputable on loadstart event
4541
4542 xhr.upload.addEventListener('progress', function(event) {
4543 if (xhr.c) { return; }
4544 _Scheduler_rawSpawn(A2($elm$core$Platform$sendToSelf, router, _Utils_Tuple2(tracker, $elm$http$Http$Sending({
4545 sent: event.loaded,
4546 size: event.total
4547 }))));
4548 });
4549 xhr.addEventListener('progress', function(event) {
4550 if (xhr.c) { return; }
4551 _Scheduler_rawSpawn(A2($elm$core$Platform$sendToSelf, router, _Utils_Tuple2(tracker, $elm$http$Http$Receiving({
4552 received: event.loaded,
4553 size: event.lengthComputable ? $elm$core$Maybe$Just(event.total) : $elm$core$Maybe$Nothing
4554 }))));
4555 });
4556}
4557
4558
4559var _Bitwise_and = F2(function(a, b)
4560{
4561 return a & b;
4562});
4563
4564var _Bitwise_or = F2(function(a, b)
4565{
4566 return a | b;
4567});
4568
4569var _Bitwise_xor = F2(function(a, b)
4570{
4571 return a ^ b;
4572});
4573
4574function _Bitwise_complement(a)
4575{
4576 return ~a;
4577};
4578
4579var _Bitwise_shiftLeftBy = F2(function(offset, a)
4580{
4581 return a << offset;
4582});
4583
4584var _Bitwise_shiftRightBy = F2(function(offset, a)
4585{
4586 return a >> offset;
4587});
4588
4589var _Bitwise_shiftRightZfBy = F2(function(offset, a)
4590{
4591 return a >>> offset;
4592});
4593var $elm$core$List$cons = _List_cons;
4594var $elm$core$Elm$JsArray$foldr = _JsArray_foldr;
4595var $elm$core$Array$foldr = F3(
4596 function (func, baseCase, _v0) {
4597 var tree = _v0.c;
4598 var tail = _v0.d;
4599 var helper = F2(
4600 function (node, acc) {
4601 if (node.$ === 'SubTree') {
4602 var subTree = node.a;
4603 return A3($elm$core$Elm$JsArray$foldr, helper, acc, subTree);
4604 } else {
4605 var values = node.a;
4606 return A3($elm$core$Elm$JsArray$foldr, func, acc, values);
4607 }
4608 });
4609 return A3(
4610 $elm$core$Elm$JsArray$foldr,
4611 helper,
4612 A3($elm$core$Elm$JsArray$foldr, func, baseCase, tail),
4613 tree);
4614 });
4615var $elm$core$Array$toList = function (array) {
4616 return A3($elm$core$Array$foldr, $elm$core$List$cons, _List_Nil, array);
4617};
4618var $elm$core$Dict$foldr = F3(
4619 function (func, acc, t) {
4620 foldr:
4621 while (true) {
4622 if (t.$ === 'RBEmpty_elm_builtin') {
4623 return acc;
4624 } else {
4625 var key = t.b;
4626 var value = t.c;
4627 var left = t.d;
4628 var right = t.e;
4629 var $temp$func = func,
4630 $temp$acc = A3(
4631 func,
4632 key,
4633 value,
4634 A3($elm$core$Dict$foldr, func, acc, right)),
4635 $temp$t = left;
4636 func = $temp$func;
4637 acc = $temp$acc;
4638 t = $temp$t;
4639 continue foldr;
4640 }
4641 }
4642 });
4643var $elm$core$Dict$toList = function (dict) {
4644 return A3(
4645 $elm$core$Dict$foldr,
4646 F3(
4647 function (key, value, list) {
4648 return A2(
4649 $elm$core$List$cons,
4650 _Utils_Tuple2(key, value),
4651 list);
4652 }),
4653 _List_Nil,
4654 dict);
4655};
4656var $elm$core$Dict$keys = function (dict) {
4657 return A3(
4658 $elm$core$Dict$foldr,
4659 F3(
4660 function (key, value, keyList) {
4661 return A2($elm$core$List$cons, key, keyList);
4662 }),
4663 _List_Nil,
4664 dict);
4665};
4666var $elm$core$Set$toList = function (_v0) {
4667 var dict = _v0.a;
4668 return $elm$core$Dict$keys(dict);
4669};
4670var $elm$core$Basics$EQ = {$: 'EQ'};
4671var $elm$core$Basics$GT = {$: 'GT'};
4672var $elm$core$Basics$LT = {$: 'LT'};
4673var $author$project$Types$LinkClicked = function (a) {
4674 return {$: 'LinkClicked', a: a};
4675};
4676var $author$project$Types$UrlChanged = function (a) {
4677 return {$: 'UrlChanged', a: a};
4678};
4679var $elm$core$Result$Err = function (a) {
4680 return {$: 'Err', a: a};
4681};
4682var $elm$json$Json$Decode$Failure = F2(
4683 function (a, b) {
4684 return {$: 'Failure', a: a, b: b};
4685 });
4686var $elm$json$Json$Decode$Field = F2(
4687 function (a, b) {
4688 return {$: 'Field', a: a, b: b};
4689 });
4690var $elm$json$Json$Decode$Index = F2(
4691 function (a, b) {
4692 return {$: 'Index', a: a, b: b};
4693 });
4694var $elm$core$Result$Ok = function (a) {
4695 return {$: 'Ok', a: a};
4696};
4697var $elm$json$Json$Decode$OneOf = function (a) {
4698 return {$: 'OneOf', a: a};
4699};
4700var $elm$core$Basics$False = {$: 'False'};
4701var $elm$core$Basics$add = _Basics_add;
4702var $elm$core$Maybe$Just = function (a) {
4703 return {$: 'Just', a: a};
4704};
4705var $elm$core$Maybe$Nothing = {$: 'Nothing'};
4706var $elm$core$String$all = _String_all;
4707var $elm$core$Basics$and = _Basics_and;
4708var $elm$core$Basics$append = _Utils_append;
4709var $elm$json$Json$Encode$encode = _Json_encode;
4710var $elm$core$String$fromInt = _String_fromNumber;
4711var $elm$core$String$join = F2(
4712 function (sep, chunks) {
4713 return A2(
4714 _String_join,
4715 sep,
4716 _List_toArray(chunks));
4717 });
4718var $elm$core$String$split = F2(
4719 function (sep, string) {
4720 return _List_fromArray(
4721 A2(_String_split, sep, string));
4722 });
4723var $elm$json$Json$Decode$indent = function (str) {
4724 return A2(
4725 $elm$core$String$join,
4726 '\n ',
4727 A2($elm$core$String$split, '\n', str));
4728};
4729var $elm$core$List$foldl = F3(
4730 function (func, acc, list) {
4731 foldl:
4732 while (true) {
4733 if (!list.b) {
4734 return acc;
4735 } else {
4736 var x = list.a;
4737 var xs = list.b;
4738 var $temp$func = func,
4739 $temp$acc = A2(func, x, acc),
4740 $temp$list = xs;
4741 func = $temp$func;
4742 acc = $temp$acc;
4743 list = $temp$list;
4744 continue foldl;
4745 }
4746 }
4747 });
4748var $elm$core$List$length = function (xs) {
4749 return A3(
4750 $elm$core$List$foldl,
4751 F2(
4752 function (_v0, i) {
4753 return i + 1;
4754 }),
4755 0,
4756 xs);
4757};
4758var $elm$core$List$map2 = _List_map2;
4759var $elm$core$Basics$le = _Utils_le;
4760var $elm$core$Basics$sub = _Basics_sub;
4761var $elm$core$List$rangeHelp = F3(
4762 function (lo, hi, list) {
4763 rangeHelp:
4764 while (true) {
4765 if (_Utils_cmp(lo, hi) < 1) {
4766 var $temp$lo = lo,
4767 $temp$hi = hi - 1,
4768 $temp$list = A2($elm$core$List$cons, hi, list);
4769 lo = $temp$lo;
4770 hi = $temp$hi;
4771 list = $temp$list;
4772 continue rangeHelp;
4773 } else {
4774 return list;
4775 }
4776 }
4777 });
4778var $elm$core$List$range = F2(
4779 function (lo, hi) {
4780 return A3($elm$core$List$rangeHelp, lo, hi, _List_Nil);
4781 });
4782var $elm$core$List$indexedMap = F2(
4783 function (f, xs) {
4784 return A3(
4785 $elm$core$List$map2,
4786 f,
4787 A2(
4788 $elm$core$List$range,
4789 0,
4790 $elm$core$List$length(xs) - 1),
4791 xs);
4792 });
4793var $elm$core$Char$toCode = _Char_toCode;
4794var $elm$core$Char$isLower = function (_char) {
4795 var code = $elm$core$Char$toCode(_char);
4796 return (97 <= code) && (code <= 122);
4797};
4798var $elm$core$Char$isUpper = function (_char) {
4799 var code = $elm$core$Char$toCode(_char);
4800 return (code <= 90) && (65 <= code);
4801};
4802var $elm$core$Basics$or = _Basics_or;
4803var $elm$core$Char$isAlpha = function (_char) {
4804 return $elm$core$Char$isLower(_char) || $elm$core$Char$isUpper(_char);
4805};
4806var $elm$core$Char$isDigit = function (_char) {
4807 var code = $elm$core$Char$toCode(_char);
4808 return (code <= 57) && (48 <= code);
4809};
4810var $elm$core$Char$isAlphaNum = function (_char) {
4811 return $elm$core$Char$isLower(_char) || ($elm$core$Char$isUpper(_char) || $elm$core$Char$isDigit(_char));
4812};
4813var $elm$core$List$reverse = function (list) {
4814 return A3($elm$core$List$foldl, $elm$core$List$cons, _List_Nil, list);
4815};
4816var $elm$core$String$uncons = _String_uncons;
4817var $elm$json$Json$Decode$errorOneOf = F2(
4818 function (i, error) {
4819 return '\n\n(' + ($elm$core$String$fromInt(i + 1) + (') ' + $elm$json$Json$Decode$indent(
4820 $elm$json$Json$Decode$errorToString(error))));
4821 });
4822var $elm$json$Json$Decode$errorToString = function (error) {
4823 return A2($elm$json$Json$Decode$errorToStringHelp, error, _List_Nil);
4824};
4825var $elm$json$Json$Decode$errorToStringHelp = F2(
4826 function (error, context) {
4827 errorToStringHelp:
4828 while (true) {
4829 switch (error.$) {
4830 case 'Field':
4831 var f = error.a;
4832 var err = error.b;
4833 var isSimple = function () {
4834 var _v1 = $elm$core$String$uncons(f);
4835 if (_v1.$ === 'Nothing') {
4836 return false;
4837 } else {
4838 var _v2 = _v1.a;
4839 var _char = _v2.a;
4840 var rest = _v2.b;
4841 return $elm$core$Char$isAlpha(_char) && A2($elm$core$String$all, $elm$core$Char$isAlphaNum, rest);
4842 }
4843 }();
4844 var fieldName = isSimple ? ('.' + f) : ('[\'' + (f + '\']'));
4845 var $temp$error = err,
4846 $temp$context = A2($elm$core$List$cons, fieldName, context);
4847 error = $temp$error;
4848 context = $temp$context;
4849 continue errorToStringHelp;
4850 case 'Index':
4851 var i = error.a;
4852 var err = error.b;
4853 var indexName = '[' + ($elm$core$String$fromInt(i) + ']');
4854 var $temp$error = err,
4855 $temp$context = A2($elm$core$List$cons, indexName, context);
4856 error = $temp$error;
4857 context = $temp$context;
4858 continue errorToStringHelp;
4859 case 'OneOf':
4860 var errors = error.a;
4861 if (!errors.b) {
4862 return 'Ran into a Json.Decode.oneOf with no possibilities' + function () {
4863 if (!context.b) {
4864 return '!';
4865 } else {
4866 return ' at json' + A2(
4867 $elm$core$String$join,
4868 '',
4869 $elm$core$List$reverse(context));
4870 }
4871 }();
4872 } else {
4873 if (!errors.b.b) {
4874 var err = errors.a;
4875 var $temp$error = err,
4876 $temp$context = context;
4877 error = $temp$error;
4878 context = $temp$context;
4879 continue errorToStringHelp;
4880 } else {
4881 var starter = function () {
4882 if (!context.b) {
4883 return 'Json.Decode.oneOf';
4884 } else {
4885 return 'The Json.Decode.oneOf at json' + A2(
4886 $elm$core$String$join,
4887 '',
4888 $elm$core$List$reverse(context));
4889 }
4890 }();
4891 var introduction = starter + (' failed in the following ' + ($elm$core$String$fromInt(
4892 $elm$core$List$length(errors)) + ' ways:'));
4893 return A2(
4894 $elm$core$String$join,
4895 '\n\n',
4896 A2(
4897 $elm$core$List$cons,
4898 introduction,
4899 A2($elm$core$List$indexedMap, $elm$json$Json$Decode$errorOneOf, errors)));
4900 }
4901 }
4902 default:
4903 var msg = error.a;
4904 var json = error.b;
4905 var introduction = function () {
4906 if (!context.b) {
4907 return 'Problem with the given value:\n\n';
4908 } else {
4909 return 'Problem with the value at json' + (A2(
4910 $elm$core$String$join,
4911 '',
4912 $elm$core$List$reverse(context)) + ':\n\n ');
4913 }
4914 }();
4915 return introduction + ($elm$json$Json$Decode$indent(
4916 A2($elm$json$Json$Encode$encode, 4, json)) + ('\n\n' + msg));
4917 }
4918 }
4919 });
4920var $elm$core$Array$branchFactor = 32;
4921var $elm$core$Array$Array_elm_builtin = F4(
4922 function (a, b, c, d) {
4923 return {$: 'Array_elm_builtin', a: a, b: b, c: c, d: d};
4924 });
4925var $elm$core$Elm$JsArray$empty = _JsArray_empty;
4926var $elm$core$Basics$ceiling = _Basics_ceiling;
4927var $elm$core$Basics$fdiv = _Basics_fdiv;
4928var $elm$core$Basics$logBase = F2(
4929 function (base, number) {
4930 return _Basics_log(number) / _Basics_log(base);
4931 });
4932var $elm$core$Basics$toFloat = _Basics_toFloat;
4933var $elm$core$Array$shiftStep = $elm$core$Basics$ceiling(
4934 A2($elm$core$Basics$logBase, 2, $elm$core$Array$branchFactor));
4935var $elm$core$Array$empty = A4($elm$core$Array$Array_elm_builtin, 0, $elm$core$Array$shiftStep, $elm$core$Elm$JsArray$empty, $elm$core$Elm$JsArray$empty);
4936var $elm$core$Elm$JsArray$initialize = _JsArray_initialize;
4937var $elm$core$Array$Leaf = function (a) {
4938 return {$: 'Leaf', a: a};
4939};
4940var $elm$core$Basics$apL = F2(
4941 function (f, x) {
4942 return f(x);
4943 });
4944var $elm$core$Basics$apR = F2(
4945 function (x, f) {
4946 return f(x);
4947 });
4948var $elm$core$Basics$eq = _Utils_equal;
4949var $elm$core$Basics$floor = _Basics_floor;
4950var $elm$core$Elm$JsArray$length = _JsArray_length;
4951var $elm$core$Basics$gt = _Utils_gt;
4952var $elm$core$Basics$max = F2(
4953 function (x, y) {
4954 return (_Utils_cmp(x, y) > 0) ? x : y;
4955 });
4956var $elm$core$Basics$mul = _Basics_mul;
4957var $elm$core$Array$SubTree = function (a) {
4958 return {$: 'SubTree', a: a};
4959};
4960var $elm$core$Elm$JsArray$initializeFromList = _JsArray_initializeFromList;
4961var $elm$core$Array$compressNodes = F2(
4962 function (nodes, acc) {
4963 compressNodes:
4964 while (true) {
4965 var _v0 = A2($elm$core$Elm$JsArray$initializeFromList, $elm$core$Array$branchFactor, nodes);
4966 var node = _v0.a;
4967 var remainingNodes = _v0.b;
4968 var newAcc = A2(
4969 $elm$core$List$cons,
4970 $elm$core$Array$SubTree(node),
4971 acc);
4972 if (!remainingNodes.b) {
4973 return $elm$core$List$reverse(newAcc);
4974 } else {
4975 var $temp$nodes = remainingNodes,
4976 $temp$acc = newAcc;
4977 nodes = $temp$nodes;
4978 acc = $temp$acc;
4979 continue compressNodes;
4980 }
4981 }
4982 });
4983var $elm$core$Tuple$first = function (_v0) {
4984 var x = _v0.a;
4985 return x;
4986};
4987var $elm$core$Array$treeFromBuilder = F2(
4988 function (nodeList, nodeListSize) {
4989 treeFromBuilder:
4990 while (true) {
4991 var newNodeSize = $elm$core$Basics$ceiling(nodeListSize / $elm$core$Array$branchFactor);
4992 if (newNodeSize === 1) {
4993 return A2($elm$core$Elm$JsArray$initializeFromList, $elm$core$Array$branchFactor, nodeList).a;
4994 } else {
4995 var $temp$nodeList = A2($elm$core$Array$compressNodes, nodeList, _List_Nil),
4996 $temp$nodeListSize = newNodeSize;
4997 nodeList = $temp$nodeList;
4998 nodeListSize = $temp$nodeListSize;
4999 continue treeFromBuilder;
5000 }
5001 }
5002 });
5003var $elm$core$Array$builderToArray = F2(
5004 function (reverseNodeList, builder) {
5005 if (!builder.nodeListSize) {
5006 return A4(
5007 $elm$core$Array$Array_elm_builtin,
5008 $elm$core$Elm$JsArray$length(builder.tail),
5009 $elm$core$Array$shiftStep,
5010 $elm$core$Elm$JsArray$empty,
5011 builder.tail);
5012 } else {
5013 var treeLen = builder.nodeListSize * $elm$core$Array$branchFactor;
5014 var depth = $elm$core$Basics$floor(
5015 A2($elm$core$Basics$logBase, $elm$core$Array$branchFactor, treeLen - 1));
5016 var correctNodeList = reverseNodeList ? $elm$core$List$reverse(builder.nodeList) : builder.nodeList;
5017 var tree = A2($elm$core$Array$treeFromBuilder, correctNodeList, builder.nodeListSize);
5018 return A4(
5019 $elm$core$Array$Array_elm_builtin,
5020 $elm$core$Elm$JsArray$length(builder.tail) + treeLen,
5021 A2($elm$core$Basics$max, 5, depth * $elm$core$Array$shiftStep),
5022 tree,
5023 builder.tail);
5024 }
5025 });
5026var $elm$core$Basics$idiv = _Basics_idiv;
5027var $elm$core$Basics$lt = _Utils_lt;
5028var $elm$core$Array$initializeHelp = F5(
5029 function (fn, fromIndex, len, nodeList, tail) {
5030 initializeHelp:
5031 while (true) {
5032 if (fromIndex < 0) {
5033 return A2(
5034 $elm$core$Array$builderToArray,
5035 false,
5036 {nodeList: nodeList, nodeListSize: (len / $elm$core$Array$branchFactor) | 0, tail: tail});
5037 } else {
5038 var leaf = $elm$core$Array$Leaf(
5039 A3($elm$core$Elm$JsArray$initialize, $elm$core$Array$branchFactor, fromIndex, fn));
5040 var $temp$fn = fn,
5041 $temp$fromIndex = fromIndex - $elm$core$Array$branchFactor,
5042 $temp$len = len,
5043 $temp$nodeList = A2($elm$core$List$cons, leaf, nodeList),
5044 $temp$tail = tail;
5045 fn = $temp$fn;
5046 fromIndex = $temp$fromIndex;
5047 len = $temp$len;
5048 nodeList = $temp$nodeList;
5049 tail = $temp$tail;
5050 continue initializeHelp;
5051 }
5052 }
5053 });
5054var $elm$core$Basics$remainderBy = _Basics_remainderBy;
5055var $elm$core$Array$initialize = F2(
5056 function (len, fn) {
5057 if (len <= 0) {
5058 return $elm$core$Array$empty;
5059 } else {
5060 var tailLen = len % $elm$core$Array$branchFactor;
5061 var tail = A3($elm$core$Elm$JsArray$initialize, tailLen, len - tailLen, fn);
5062 var initialFromIndex = (len - tailLen) - $elm$core$Array$branchFactor;
5063 return A5($elm$core$Array$initializeHelp, fn, initialFromIndex, len, _List_Nil, tail);
5064 }
5065 });
5066var $elm$core$Basics$True = {$: 'True'};
5067var $elm$core$Result$isOk = function (result) {
5068 if (result.$ === 'Ok') {
5069 return true;
5070 } else {
5071 return false;
5072 }
5073};
5074var $elm$json$Json$Decode$andThen = _Json_andThen;
5075var $elm$json$Json$Decode$map = _Json_map1;
5076var $elm$json$Json$Decode$map2 = _Json_map2;
5077var $elm$json$Json$Decode$succeed = _Json_succeed;
5078var $elm$virtual_dom$VirtualDom$toHandlerInt = function (handler) {
5079 switch (handler.$) {
5080 case 'Normal':
5081 return 0;
5082 case 'MayStopPropagation':
5083 return 1;
5084 case 'MayPreventDefault':
5085 return 2;
5086 default:
5087 return 3;
5088 }
5089};
5090var $elm$browser$Browser$External = function (a) {
5091 return {$: 'External', a: a};
5092};
5093var $elm$browser$Browser$Internal = function (a) {
5094 return {$: 'Internal', a: a};
5095};
5096var $elm$core$Basics$identity = function (x) {
5097 return x;
5098};
5099var $elm$browser$Browser$Dom$NotFound = function (a) {
5100 return {$: 'NotFound', a: a};
5101};
5102var $elm$url$Url$Http = {$: 'Http'};
5103var $elm$url$Url$Https = {$: 'Https'};
5104var $elm$url$Url$Url = F6(
5105 function (protocol, host, port_, path, query, fragment) {
5106 return {fragment: fragment, host: host, path: path, port_: port_, protocol: protocol, query: query};
5107 });
5108var $elm$core$String$contains = _String_contains;
5109var $elm$core$String$length = _String_length;
5110var $elm$core$String$slice = _String_slice;
5111var $elm$core$String$dropLeft = F2(
5112 function (n, string) {
5113 return (n < 1) ? string : A3(
5114 $elm$core$String$slice,
5115 n,
5116 $elm$core$String$length(string),
5117 string);
5118 });
5119var $elm$core$String$indexes = _String_indexes;
5120var $elm$core$String$isEmpty = function (string) {
5121 return string === '';
5122};
5123var $elm$core$String$left = F2(
5124 function (n, string) {
5125 return (n < 1) ? '' : A3($elm$core$String$slice, 0, n, string);
5126 });
5127var $elm$core$String$toInt = _String_toInt;
5128var $elm$url$Url$chompBeforePath = F5(
5129 function (protocol, path, params, frag, str) {
5130 if ($elm$core$String$isEmpty(str) || A2($elm$core$String$contains, '@', str)) {
5131 return $elm$core$Maybe$Nothing;
5132 } else {
5133 var _v0 = A2($elm$core$String$indexes, ':', str);
5134 if (!_v0.b) {
5135 return $elm$core$Maybe$Just(
5136 A6($elm$url$Url$Url, protocol, str, $elm$core$Maybe$Nothing, path, params, frag));
5137 } else {
5138 if (!_v0.b.b) {
5139 var i = _v0.a;
5140 var _v1 = $elm$core$String$toInt(
5141 A2($elm$core$String$dropLeft, i + 1, str));
5142 if (_v1.$ === 'Nothing') {
5143 return $elm$core$Maybe$Nothing;
5144 } else {
5145 var port_ = _v1;
5146 return $elm$core$Maybe$Just(
5147 A6(
5148 $elm$url$Url$Url,
5149 protocol,
5150 A2($elm$core$String$left, i, str),
5151 port_,
5152 path,
5153 params,
5154 frag));
5155 }
5156 } else {
5157 return $elm$core$Maybe$Nothing;
5158 }
5159 }
5160 }
5161 });
5162var $elm$url$Url$chompBeforeQuery = F4(
5163 function (protocol, params, frag, str) {
5164 if ($elm$core$String$isEmpty(str)) {
5165 return $elm$core$Maybe$Nothing;
5166 } else {
5167 var _v0 = A2($elm$core$String$indexes, '/', str);
5168 if (!_v0.b) {
5169 return A5($elm$url$Url$chompBeforePath, protocol, '/', params, frag, str);
5170 } else {
5171 var i = _v0.a;
5172 return A5(
5173 $elm$url$Url$chompBeforePath,
5174 protocol,
5175 A2($elm$core$String$dropLeft, i, str),
5176 params,
5177 frag,
5178 A2($elm$core$String$left, i, str));
5179 }
5180 }
5181 });
5182var $elm$url$Url$chompBeforeFragment = F3(
5183 function (protocol, frag, str) {
5184 if ($elm$core$String$isEmpty(str)) {
5185 return $elm$core$Maybe$Nothing;
5186 } else {
5187 var _v0 = A2($elm$core$String$indexes, '?', str);
5188 if (!_v0.b) {
5189 return A4($elm$url$Url$chompBeforeQuery, protocol, $elm$core$Maybe$Nothing, frag, str);
5190 } else {
5191 var i = _v0.a;
5192 return A4(
5193 $elm$url$Url$chompBeforeQuery,
5194 protocol,
5195 $elm$core$Maybe$Just(
5196 A2($elm$core$String$dropLeft, i + 1, str)),
5197 frag,
5198 A2($elm$core$String$left, i, str));
5199 }
5200 }
5201 });
5202var $elm$url$Url$chompAfterProtocol = F2(
5203 function (protocol, str) {
5204 if ($elm$core$String$isEmpty(str)) {
5205 return $elm$core$Maybe$Nothing;
5206 } else {
5207 var _v0 = A2($elm$core$String$indexes, '#', str);
5208 if (!_v0.b) {
5209 return A3($elm$url$Url$chompBeforeFragment, protocol, $elm$core$Maybe$Nothing, str);
5210 } else {
5211 var i = _v0.a;
5212 return A3(
5213 $elm$url$Url$chompBeforeFragment,
5214 protocol,
5215 $elm$core$Maybe$Just(
5216 A2($elm$core$String$dropLeft, i + 1, str)),
5217 A2($elm$core$String$left, i, str));
5218 }
5219 }
5220 });
5221var $elm$core$String$startsWith = _String_startsWith;
5222var $elm$url$Url$fromString = function (str) {
5223 return A2($elm$core$String$startsWith, 'http://', str) ? A2(
5224 $elm$url$Url$chompAfterProtocol,
5225 $elm$url$Url$Http,
5226 A2($elm$core$String$dropLeft, 7, str)) : (A2($elm$core$String$startsWith, 'https://', str) ? A2(
5227 $elm$url$Url$chompAfterProtocol,
5228 $elm$url$Url$Https,
5229 A2($elm$core$String$dropLeft, 8, str)) : $elm$core$Maybe$Nothing);
5230};
5231var $elm$core$Basics$never = function (_v0) {
5232 never:
5233 while (true) {
5234 var nvr = _v0.a;
5235 var $temp$_v0 = nvr;
5236 _v0 = $temp$_v0;
5237 continue never;
5238 }
5239};
5240var $elm$core$Task$Perform = function (a) {
5241 return {$: 'Perform', a: a};
5242};
5243var $elm$core$Task$succeed = _Scheduler_succeed;
5244var $elm$core$Task$init = $elm$core$Task$succeed(_Utils_Tuple0);
5245var $elm$core$List$foldrHelper = F4(
5246 function (fn, acc, ctr, ls) {
5247 if (!ls.b) {
5248 return acc;
5249 } else {
5250 var a = ls.a;
5251 var r1 = ls.b;
5252 if (!r1.b) {
5253 return A2(fn, a, acc);
5254 } else {
5255 var b = r1.a;
5256 var r2 = r1.b;
5257 if (!r2.b) {
5258 return A2(
5259 fn,
5260 a,
5261 A2(fn, b, acc));
5262 } else {
5263 var c = r2.a;
5264 var r3 = r2.b;
5265 if (!r3.b) {
5266 return A2(
5267 fn,
5268 a,
5269 A2(
5270 fn,
5271 b,
5272 A2(fn, c, acc)));
5273 } else {
5274 var d = r3.a;
5275 var r4 = r3.b;
5276 var res = (ctr > 500) ? A3(
5277 $elm$core$List$foldl,
5278 fn,
5279 acc,
5280 $elm$core$List$reverse(r4)) : A4($elm$core$List$foldrHelper, fn, acc, ctr + 1, r4);
5281 return A2(
5282 fn,
5283 a,
5284 A2(
5285 fn,
5286 b,
5287 A2(
5288 fn,
5289 c,
5290 A2(fn, d, res))));
5291 }
5292 }
5293 }
5294 }
5295 });
5296var $elm$core$List$foldr = F3(
5297 function (fn, acc, ls) {
5298 return A4($elm$core$List$foldrHelper, fn, acc, 0, ls);
5299 });
5300var $elm$core$List$map = F2(
5301 function (f, xs) {
5302 return A3(
5303 $elm$core$List$foldr,
5304 F2(
5305 function (x, acc) {
5306 return A2(
5307 $elm$core$List$cons,
5308 f(x),
5309 acc);
5310 }),
5311 _List_Nil,
5312 xs);
5313 });
5314var $elm$core$Task$andThen = _Scheduler_andThen;
5315var $elm$core$Task$map = F2(
5316 function (func, taskA) {
5317 return A2(
5318 $elm$core$Task$andThen,
5319 function (a) {
5320 return $elm$core$Task$succeed(
5321 func(a));
5322 },
5323 taskA);
5324 });
5325var $elm$core$Task$map2 = F3(
5326 function (func, taskA, taskB) {
5327 return A2(
5328 $elm$core$Task$andThen,
5329 function (a) {
5330 return A2(
5331 $elm$core$Task$andThen,
5332 function (b) {
5333 return $elm$core$Task$succeed(
5334 A2(func, a, b));
5335 },
5336 taskB);
5337 },
5338 taskA);
5339 });
5340var $elm$core$Task$sequence = function (tasks) {
5341 return A3(
5342 $elm$core$List$foldr,
5343 $elm$core$Task$map2($elm$core$List$cons),
5344 $elm$core$Task$succeed(_List_Nil),
5345 tasks);
5346};
5347var $elm$core$Platform$sendToApp = _Platform_sendToApp;
5348var $elm$core$Task$spawnCmd = F2(
5349 function (router, _v0) {
5350 var task = _v0.a;
5351 return _Scheduler_spawn(
5352 A2(
5353 $elm$core$Task$andThen,
5354 $elm$core$Platform$sendToApp(router),
5355 task));
5356 });
5357var $elm$core$Task$onEffects = F3(
5358 function (router, commands, state) {
5359 return A2(
5360 $elm$core$Task$map,
5361 function (_v0) {
5362 return _Utils_Tuple0;
5363 },
5364 $elm$core$Task$sequence(
5365 A2(
5366 $elm$core$List$map,
5367 $elm$core$Task$spawnCmd(router),
5368 commands)));
5369 });
5370var $elm$core$Task$onSelfMsg = F3(
5371 function (_v0, _v1, _v2) {
5372 return $elm$core$Task$succeed(_Utils_Tuple0);
5373 });
5374var $elm$core$Task$cmdMap = F2(
5375 function (tagger, _v0) {
5376 var task = _v0.a;
5377 return $elm$core$Task$Perform(
5378 A2($elm$core$Task$map, tagger, task));
5379 });
5380_Platform_effectManagers['Task'] = _Platform_createManager($elm$core$Task$init, $elm$core$Task$onEffects, $elm$core$Task$onSelfMsg, $elm$core$Task$cmdMap);
5381var $elm$core$Task$command = _Platform_leaf('Task');
5382var $elm$core$Task$perform = F2(
5383 function (toMessage, task) {
5384 return $elm$core$Task$command(
5385 $elm$core$Task$Perform(
5386 A2($elm$core$Task$map, toMessage, task)));
5387 });
5388var $elm$browser$Browser$application = _Browser_application;
5389var $elm$json$Json$Decode$field = _Json_decodeField;
5390var $author$project$Types$ConnectionQuery = F2(
5391 function (a, b) {
5392 return {$: 'ConnectionQuery', a: a, b: b};
5393 });
5394var $author$project$Types$ConnectionTab = {$: 'ConnectionTab'};
5395var $author$project$Types$QueryRequest = F3(
5396 function (term, depth, queryType) {
5397 return {depth: depth, queryType: queryType, term: term};
5398 });
5399var $author$project$Types$Resize = F2(
5400 function (a, b) {
5401 return {$: 'Resize', a: a, b: b};
5402 });
5403var $elm$core$Platform$Cmd$batch = _Platform_batch;
5404var $author$project$Types$CnpjTab = {$: 'CnpjTab'};
5405var $elm$core$Dict$RBEmpty_elm_builtin = {$: 'RBEmpty_elm_builtin'};
5406var $elm$core$Dict$empty = $elm$core$Dict$RBEmpty_elm_builtin;
5407var $elm$core$Set$Set_elm_builtin = function (a) {
5408 return {$: 'Set_elm_builtin', a: a};
5409};
5410var $elm$core$Set$empty = $elm$core$Set$Set_elm_builtin($elm$core$Dict$empty);
5411var $gampleman$elm_visualization$Force$Center = F2(
5412 function (a, b) {
5413 return {$: 'Center', a: a, b: b};
5414 });
5415var $gampleman$elm_visualization$Force$center = $gampleman$elm_visualization$Force$Center;
5416var $gampleman$elm_visualization$Force$Collision = F3(
5417 function (a, b, c) {
5418 return {$: 'Collision', a: a, b: b, c: c};
5419 });
5420var $elm$core$Basics$composeR = F3(
5421 function (f, g, x) {
5422 return g(
5423 f(x));
5424 });
5425var $elm$core$Dict$Black = {$: 'Black'};
5426var $elm$core$Dict$RBNode_elm_builtin = F5(
5427 function (a, b, c, d, e) {
5428 return {$: 'RBNode_elm_builtin', a: a, b: b, c: c, d: d, e: e};
5429 });
5430var $elm$core$Dict$Red = {$: 'Red'};
5431var $elm$core$Dict$balance = F5(
5432 function (color, key, value, left, right) {
5433 if ((right.$ === 'RBNode_elm_builtin') && (right.a.$ === 'Red')) {
5434 var _v1 = right.a;
5435 var rK = right.b;
5436 var rV = right.c;
5437 var rLeft = right.d;
5438 var rRight = right.e;
5439 if ((left.$ === 'RBNode_elm_builtin') && (left.a.$ === 'Red')) {
5440 var _v3 = left.a;
5441 var lK = left.b;
5442 var lV = left.c;
5443 var lLeft = left.d;
5444 var lRight = left.e;
5445 return A5(
5446 $elm$core$Dict$RBNode_elm_builtin,
5447 $elm$core$Dict$Red,
5448 key,
5449 value,
5450 A5($elm$core$Dict$RBNode_elm_builtin, $elm$core$Dict$Black, lK, lV, lLeft, lRight),
5451 A5($elm$core$Dict$RBNode_elm_builtin, $elm$core$Dict$Black, rK, rV, rLeft, rRight));
5452 } else {
5453 return A5(
5454 $elm$core$Dict$RBNode_elm_builtin,
5455 color,
5456 rK,
5457 rV,
5458 A5($elm$core$Dict$RBNode_elm_builtin, $elm$core$Dict$Red, key, value, left, rLeft),
5459 rRight);
5460 }
5461 } else {
5462 if ((((left.$ === 'RBNode_elm_builtin') && (left.a.$ === 'Red')) && (left.d.$ === 'RBNode_elm_builtin')) && (left.d.a.$ === 'Red')) {
5463 var _v5 = left.a;
5464 var lK = left.b;
5465 var lV = left.c;
5466 var _v6 = left.d;
5467 var _v7 = _v6.a;
5468 var llK = _v6.b;
5469 var llV = _v6.c;
5470 var llLeft = _v6.d;
5471 var llRight = _v6.e;
5472 var lRight = left.e;
5473 return A5(
5474 $elm$core$Dict$RBNode_elm_builtin,
5475 $elm$core$Dict$Red,
5476 lK,
5477 lV,
5478 A5($elm$core$Dict$RBNode_elm_builtin, $elm$core$Dict$Black, llK, llV, llLeft, llRight),
5479 A5($elm$core$Dict$RBNode_elm_builtin, $elm$core$Dict$Black, key, value, lRight, right));
5480 } else {
5481 return A5($elm$core$Dict$RBNode_elm_builtin, color, key, value, left, right);
5482 }
5483 }
5484 });
5485var $elm$core$Basics$compare = _Utils_compare;
5486var $elm$core$Dict$insertHelp = F3(
5487 function (key, value, dict) {
5488 if (dict.$ === 'RBEmpty_elm_builtin') {
5489 return A5($elm$core$Dict$RBNode_elm_builtin, $elm$core$Dict$Red, key, value, $elm$core$Dict$RBEmpty_elm_builtin, $elm$core$Dict$RBEmpty_elm_builtin);
5490 } else {
5491 var nColor = dict.a;
5492 var nKey = dict.b;
5493 var nValue = dict.c;
5494 var nLeft = dict.d;
5495 var nRight = dict.e;
5496 var _v1 = A2($elm$core$Basics$compare, key, nKey);
5497 switch (_v1.$) {
5498 case 'LT':
5499 return A5(
5500 $elm$core$Dict$balance,
5501 nColor,
5502 nKey,
5503 nValue,
5504 A3($elm$core$Dict$insertHelp, key, value, nLeft),
5505 nRight);
5506 case 'EQ':
5507 return A5($elm$core$Dict$RBNode_elm_builtin, nColor, nKey, value, nLeft, nRight);
5508 default:
5509 return A5(
5510 $elm$core$Dict$balance,
5511 nColor,
5512 nKey,
5513 nValue,
5514 nLeft,
5515 A3($elm$core$Dict$insertHelp, key, value, nRight));
5516 }
5517 }
5518 });
5519var $elm$core$Dict$insert = F3(
5520 function (key, value, dict) {
5521 var _v0 = A3($elm$core$Dict$insertHelp, key, value, dict);
5522 if ((_v0.$ === 'RBNode_elm_builtin') && (_v0.a.$ === 'Red')) {
5523 var _v1 = _v0.a;
5524 var k = _v0.b;
5525 var v = _v0.c;
5526 var l = _v0.d;
5527 var r = _v0.e;
5528 return A5($elm$core$Dict$RBNode_elm_builtin, $elm$core$Dict$Black, k, v, l, r);
5529 } else {
5530 var x = _v0;
5531 return x;
5532 }
5533 });
5534var $elm$core$Dict$fromList = function (assocs) {
5535 return A3(
5536 $elm$core$List$foldl,
5537 F2(
5538 function (_v0, dict) {
5539 var key = _v0.a;
5540 var value = _v0.b;
5541 return A3($elm$core$Dict$insert, key, value, dict);
5542 }),
5543 $elm$core$Dict$empty,
5544 assocs);
5545};
5546var $gampleman$elm_visualization$Force$collision = function (radius) {
5547 return A2(
5548 $elm$core$Basics$composeR,
5549 $elm$core$List$map(
5550 function (item) {
5551 return _Utils_Tuple2(item, radius);
5552 }),
5553 A2(
5554 $elm$core$Basics$composeR,
5555 $elm$core$Dict$fromList,
5556 A2($gampleman$elm_visualization$Force$Collision, 1, 1)));
5557};
5558var $gampleman$elm_visualization$Force$Links = F2(
5559 function (a, b) {
5560 return {$: 'Links', a: a, b: b};
5561 });
5562var $elm$core$Basics$composeL = F3(
5563 function (g, f, x) {
5564 return g(
5565 f(x));
5566 });
5567var $elm$core$Dict$get = F2(
5568 function (targetKey, dict) {
5569 get:
5570 while (true) {
5571 if (dict.$ === 'RBEmpty_elm_builtin') {
5572 return $elm$core$Maybe$Nothing;
5573 } else {
5574 var key = dict.b;
5575 var value = dict.c;
5576 var left = dict.d;
5577 var right = dict.e;
5578 var _v1 = A2($elm$core$Basics$compare, targetKey, key);
5579 switch (_v1.$) {
5580 case 'LT':
5581 var $temp$targetKey = targetKey,
5582 $temp$dict = left;
5583 targetKey = $temp$targetKey;
5584 dict = $temp$dict;
5585 continue get;
5586 case 'EQ':
5587 return $elm$core$Maybe$Just(value);
5588 default:
5589 var $temp$targetKey = targetKey,
5590 $temp$dict = right;
5591 targetKey = $temp$targetKey;
5592 dict = $temp$dict;
5593 continue get;
5594 }
5595 }
5596 }
5597 });
5598var $elm$core$Maybe$map = F2(
5599 function (f, maybe) {
5600 if (maybe.$ === 'Just') {
5601 var value = maybe.a;
5602 return $elm$core$Maybe$Just(
5603 f(value));
5604 } else {
5605 return $elm$core$Maybe$Nothing;
5606 }
5607 });
5608var $elm$core$Basics$min = F2(
5609 function (x, y) {
5610 return (_Utils_cmp(x, y) < 0) ? x : y;
5611 });
5612var $elm$core$Dict$getMin = function (dict) {
5613 getMin:
5614 while (true) {
5615 if ((dict.$ === 'RBNode_elm_builtin') && (dict.d.$ === 'RBNode_elm_builtin')) {
5616 var left = dict.d;
5617 var $temp$dict = left;
5618 dict = $temp$dict;
5619 continue getMin;
5620 } else {
5621 return dict;
5622 }
5623 }
5624};
5625var $elm$core$Dict$moveRedLeft = function (dict) {
5626 if (((dict.$ === 'RBNode_elm_builtin') && (dict.d.$ === 'RBNode_elm_builtin')) && (dict.e.$ === 'RBNode_elm_builtin')) {
5627 if ((dict.e.d.$ === 'RBNode_elm_builtin') && (dict.e.d.a.$ === 'Red')) {
5628 var clr = dict.a;
5629 var k = dict.b;
5630 var v = dict.c;
5631 var _v1 = dict.d;
5632 var lClr = _v1.a;
5633 var lK = _v1.b;
5634 var lV = _v1.c;
5635 var lLeft = _v1.d;
5636 var lRight = _v1.e;
5637 var _v2 = dict.e;
5638 var rClr = _v2.a;
5639 var rK = _v2.b;
5640 var rV = _v2.c;
5641 var rLeft = _v2.d;
5642 var _v3 = rLeft.a;
5643 var rlK = rLeft.b;
5644 var rlV = rLeft.c;
5645 var rlL = rLeft.d;
5646 var rlR = rLeft.e;
5647 var rRight = _v2.e;
5648 return A5(
5649 $elm$core$Dict$RBNode_elm_builtin,
5650 $elm$core$Dict$Red,
5651 rlK,
5652 rlV,
5653 A5(
5654 $elm$core$Dict$RBNode_elm_builtin,
5655 $elm$core$Dict$Black,
5656 k,
5657 v,
5658 A5($elm$core$Dict$RBNode_elm_builtin, $elm$core$Dict$Red, lK, lV, lLeft, lRight),
5659 rlL),
5660 A5($elm$core$Dict$RBNode_elm_builtin, $elm$core$Dict$Black, rK, rV, rlR, rRight));
5661 } else {
5662 var clr = dict.a;
5663 var k = dict.b;
5664 var v = dict.c;
5665 var _v4 = dict.d;
5666 var lClr = _v4.a;
5667 var lK = _v4.b;
5668 var lV = _v4.c;
5669 var lLeft = _v4.d;
5670 var lRight = _v4.e;
5671 var _v5 = dict.e;
5672 var rClr = _v5.a;
5673 var rK = _v5.b;
5674 var rV = _v5.c;
5675 var rLeft = _v5.d;
5676 var rRight = _v5.e;
5677 if (clr.$ === 'Black') {
5678 return A5(
5679 $elm$core$Dict$RBNode_elm_builtin,
5680 $elm$core$Dict$Black,
5681 k,
5682 v,
5683 A5($elm$core$Dict$RBNode_elm_builtin, $elm$core$Dict$Red, lK, lV, lLeft, lRight),
5684 A5($elm$core$Dict$RBNode_elm_builtin, $elm$core$Dict$Red, rK, rV, rLeft, rRight));
5685 } else {
5686 return A5(
5687 $elm$core$Dict$RBNode_elm_builtin,
5688 $elm$core$Dict$Black,
5689 k,
5690 v,
5691 A5($elm$core$Dict$RBNode_elm_builtin, $elm$core$Dict$Red, lK, lV, lLeft, lRight),
5692 A5($elm$core$Dict$RBNode_elm_builtin, $elm$core$Dict$Red, rK, rV, rLeft, rRight));
5693 }
5694 }
5695 } else {
5696 return dict;
5697 }
5698};
5699var $elm$core$Dict$moveRedRight = function (dict) {
5700 if (((dict.$ === 'RBNode_elm_builtin') && (dict.d.$ === 'RBNode_elm_builtin')) && (dict.e.$ === 'RBNode_elm_builtin')) {
5701 if ((dict.d.d.$ === 'RBNode_elm_builtin') && (dict.d.d.a.$ === 'Red')) {
5702 var clr = dict.a;
5703 var k = dict.b;
5704 var v = dict.c;
5705 var _v1 = dict.d;
5706 var lClr = _v1.a;
5707 var lK = _v1.b;
5708 var lV = _v1.c;
5709 var _v2 = _v1.d;
5710 var _v3 = _v2.a;
5711 var llK = _v2.b;
5712 var llV = _v2.c;
5713 var llLeft = _v2.d;
5714 var llRight = _v2.e;
5715 var lRight = _v1.e;
5716 var _v4 = dict.e;
5717 var rClr = _v4.a;
5718 var rK = _v4.b;
5719 var rV = _v4.c;
5720 var rLeft = _v4.d;
5721 var rRight = _v4.e;
5722 return A5(
5723 $elm$core$Dict$RBNode_elm_builtin,
5724 $elm$core$Dict$Red,
5725 lK,
5726 lV,
5727 A5($elm$core$Dict$RBNode_elm_builtin, $elm$core$Dict$Black, llK, llV, llLeft, llRight),
5728 A5(
5729 $elm$core$Dict$RBNode_elm_builtin,
5730 $elm$core$Dict$Black,
5731 k,
5732 v,
5733 lRight,
5734 A5($elm$core$Dict$RBNode_elm_builtin, $elm$core$Dict$Red, rK, rV, rLeft, rRight)));
5735 } else {
5736 var clr = dict.a;
5737 var k = dict.b;
5738 var v = dict.c;
5739 var _v5 = dict.d;
5740 var lClr = _v5.a;
5741 var lK = _v5.b;
5742 var lV = _v5.c;
5743 var lLeft = _v5.d;
5744 var lRight = _v5.e;
5745 var _v6 = dict.e;
5746 var rClr = _v6.a;
5747 var rK = _v6.b;
5748 var rV = _v6.c;
5749 var rLeft = _v6.d;
5750 var rRight = _v6.e;
5751 if (clr.$ === 'Black') {
5752 return A5(
5753 $elm$core$Dict$RBNode_elm_builtin,
5754 $elm$core$Dict$Black,
5755 k,
5756 v,
5757 A5($elm$core$Dict$RBNode_elm_builtin, $elm$core$Dict$Red, lK, lV, lLeft, lRight),
5758 A5($elm$core$Dict$RBNode_elm_builtin, $elm$core$Dict$Red, rK, rV, rLeft, rRight));
5759 } else {
5760 return A5(
5761 $elm$core$Dict$RBNode_elm_builtin,
5762 $elm$core$Dict$Black,
5763 k,
5764 v,
5765 A5($elm$core$Dict$RBNode_elm_builtin, $elm$core$Dict$Red, lK, lV, lLeft, lRight),
5766 A5($elm$core$Dict$RBNode_elm_builtin, $elm$core$Dict$Red, rK, rV, rLeft, rRight));
5767 }
5768 }
5769 } else {
5770 return dict;
5771 }
5772};
5773var $elm$core$Dict$removeHelpPrepEQGT = F7(
5774 function (targetKey, dict, color, key, value, left, right) {
5775 if ((left.$ === 'RBNode_elm_builtin') && (left.a.$ === 'Red')) {
5776 var _v1 = left.a;
5777 var lK = left.b;
5778 var lV = left.c;
5779 var lLeft = left.d;
5780 var lRight = left.e;
5781 return A5(
5782 $elm$core$Dict$RBNode_elm_builtin,
5783 color,
5784 lK,
5785 lV,
5786 lLeft,
5787 A5($elm$core$Dict$RBNode_elm_builtin, $elm$core$Dict$Red, key, value, lRight, right));
5788 } else {
5789 _v2$2:
5790 while (true) {
5791 if ((right.$ === 'RBNode_elm_builtin') && (right.a.$ === 'Black')) {
5792 if (right.d.$ === 'RBNode_elm_builtin') {
5793 if (right.d.a.$ === 'Black') {
5794 var _v3 = right.a;
5795 var _v4 = right.d;
5796 var _v5 = _v4.a;
5797 return $elm$core$Dict$moveRedRight(dict);
5798 } else {
5799 break _v2$2;
5800 }
5801 } else {
5802 var _v6 = right.a;
5803 var _v7 = right.d;
5804 return $elm$core$Dict$moveRedRight(dict);
5805 }
5806 } else {
5807 break _v2$2;
5808 }
5809 }
5810 return dict;
5811 }
5812 });
5813var $elm$core$Dict$removeMin = function (dict) {
5814 if ((dict.$ === 'RBNode_elm_builtin') && (dict.d.$ === 'RBNode_elm_builtin')) {
5815 var color = dict.a;
5816 var key = dict.b;
5817 var value = dict.c;
5818 var left = dict.d;
5819 var lColor = left.a;
5820 var lLeft = left.d;
5821 var right = dict.e;
5822 if (lColor.$ === 'Black') {
5823 if ((lLeft.$ === 'RBNode_elm_builtin') && (lLeft.a.$ === 'Red')) {
5824 var _v3 = lLeft.a;
5825 return A5(
5826 $elm$core$Dict$RBNode_elm_builtin,
5827 color,
5828 key,
5829 value,
5830 $elm$core$Dict$removeMin(left),
5831 right);
5832 } else {
5833 var _v4 = $elm$core$Dict$moveRedLeft(dict);
5834 if (_v4.$ === 'RBNode_elm_builtin') {
5835 var nColor = _v4.a;
5836 var nKey = _v4.b;
5837 var nValue = _v4.c;
5838 var nLeft = _v4.d;
5839 var nRight = _v4.e;
5840 return A5(
5841 $elm$core$Dict$balance,
5842 nColor,
5843 nKey,
5844 nValue,
5845 $elm$core$Dict$removeMin(nLeft),
5846 nRight);
5847 } else {
5848 return $elm$core$Dict$RBEmpty_elm_builtin;
5849 }
5850 }
5851 } else {
5852 return A5(
5853 $elm$core$Dict$RBNode_elm_builtin,
5854 color,
5855 key,
5856 value,
5857 $elm$core$Dict$removeMin(left),
5858 right);
5859 }
5860 } else {
5861 return $elm$core$Dict$RBEmpty_elm_builtin;
5862 }
5863};
5864var $elm$core$Dict$removeHelp = F2(
5865 function (targetKey, dict) {
5866 if (dict.$ === 'RBEmpty_elm_builtin') {
5867 return $elm$core$Dict$RBEmpty_elm_builtin;
5868 } else {
5869 var color = dict.a;
5870 var key = dict.b;
5871 var value = dict.c;
5872 var left = dict.d;
5873 var right = dict.e;
5874 if (_Utils_cmp(targetKey, key) < 0) {
5875 if ((left.$ === 'RBNode_elm_builtin') && (left.a.$ === 'Black')) {
5876 var _v4 = left.a;
5877 var lLeft = left.d;
5878 if ((lLeft.$ === 'RBNode_elm_builtin') && (lLeft.a.$ === 'Red')) {
5879 var _v6 = lLeft.a;
5880 return A5(
5881 $elm$core$Dict$RBNode_elm_builtin,
5882 color,
5883 key,
5884 value,
5885 A2($elm$core$Dict$removeHelp, targetKey, left),
5886 right);
5887 } else {
5888 var _v7 = $elm$core$Dict$moveRedLeft(dict);
5889 if (_v7.$ === 'RBNode_elm_builtin') {
5890 var nColor = _v7.a;
5891 var nKey = _v7.b;
5892 var nValue = _v7.c;
5893 var nLeft = _v7.d;
5894 var nRight = _v7.e;
5895 return A5(
5896 $elm$core$Dict$balance,
5897 nColor,
5898 nKey,
5899 nValue,
5900 A2($elm$core$Dict$removeHelp, targetKey, nLeft),
5901 nRight);
5902 } else {
5903 return $elm$core$Dict$RBEmpty_elm_builtin;
5904 }
5905 }
5906 } else {
5907 return A5(
5908 $elm$core$Dict$RBNode_elm_builtin,
5909 color,
5910 key,
5911 value,
5912 A2($elm$core$Dict$removeHelp, targetKey, left),
5913 right);
5914 }
5915 } else {
5916 return A2(
5917 $elm$core$Dict$removeHelpEQGT,
5918 targetKey,
5919 A7($elm$core$Dict$removeHelpPrepEQGT, targetKey, dict, color, key, value, left, right));
5920 }
5921 }
5922 });
5923var $elm$core$Dict$removeHelpEQGT = F2(
5924 function (targetKey, dict) {
5925 if (dict.$ === 'RBNode_elm_builtin') {
5926 var color = dict.a;
5927 var key = dict.b;
5928 var value = dict.c;
5929 var left = dict.d;
5930 var right = dict.e;
5931 if (_Utils_eq(targetKey, key)) {
5932 var _v1 = $elm$core$Dict$getMin(right);
5933 if (_v1.$ === 'RBNode_elm_builtin') {
5934 var minKey = _v1.b;
5935 var minValue = _v1.c;
5936 return A5(
5937 $elm$core$Dict$balance,
5938 color,
5939 minKey,
5940 minValue,
5941 left,
5942 $elm$core$Dict$removeMin(right));
5943 } else {
5944 return $elm$core$Dict$RBEmpty_elm_builtin;
5945 }
5946 } else {
5947 return A5(
5948 $elm$core$Dict$balance,
5949 color,
5950 key,
5951 value,
5952 left,
5953 A2($elm$core$Dict$removeHelp, targetKey, right));
5954 }
5955 } else {
5956 return $elm$core$Dict$RBEmpty_elm_builtin;
5957 }
5958 });
5959var $elm$core$Dict$remove = F2(
5960 function (key, dict) {
5961 var _v0 = A2($elm$core$Dict$removeHelp, key, dict);
5962 if ((_v0.$ === 'RBNode_elm_builtin') && (_v0.a.$ === 'Red')) {
5963 var _v1 = _v0.a;
5964 var k = _v0.b;
5965 var v = _v0.c;
5966 var l = _v0.d;
5967 var r = _v0.e;
5968 return A5($elm$core$Dict$RBNode_elm_builtin, $elm$core$Dict$Black, k, v, l, r);
5969 } else {
5970 var x = _v0;
5971 return x;
5972 }
5973 });
5974var $elm$core$Dict$update = F3(
5975 function (targetKey, alter, dictionary) {
5976 var _v0 = alter(
5977 A2($elm$core$Dict$get, targetKey, dictionary));
5978 if (_v0.$ === 'Just') {
5979 var value = _v0.a;
5980 return A3($elm$core$Dict$insert, targetKey, value, dictionary);
5981 } else {
5982 return A2($elm$core$Dict$remove, targetKey, dictionary);
5983 }
5984 });
5985var $elm$core$Maybe$withDefault = F2(
5986 function (_default, maybe) {
5987 if (maybe.$ === 'Just') {
5988 var value = maybe.a;
5989 return value;
5990 } else {
5991 return _default;
5992 }
5993 });
5994var $gampleman$elm_visualization$Force$customLinks = F2(
5995 function (iters, list) {
5996 var counts = A3(
5997 $elm$core$List$foldr,
5998 F2(
5999 function (_v1, d) {
6000 var source = _v1.source;
6001 var target = _v1.target;
6002 return A3(
6003 $elm$core$Dict$update,
6004 target,
6005 A2(
6006 $elm$core$Basics$composeL,
6007 A2(
6008 $elm$core$Basics$composeL,
6009 $elm$core$Maybe$Just,
6010 $elm$core$Maybe$withDefault(1)),
6011 $elm$core$Maybe$map(
6012 $elm$core$Basics$add(1))),
6013 A3(
6014 $elm$core$Dict$update,
6015 source,
6016 A2(
6017 $elm$core$Basics$composeL,
6018 A2(
6019 $elm$core$Basics$composeL,
6020 $elm$core$Maybe$Just,
6021 $elm$core$Maybe$withDefault(1)),
6022 $elm$core$Maybe$map(
6023 $elm$core$Basics$add(1))),
6024 d));
6025 }),
6026 $elm$core$Dict$empty,
6027 list);
6028 var count = function (key) {
6029 return A2(
6030 $elm$core$Maybe$withDefault,
6031 0,
6032 A2($elm$core$Dict$get, key, counts));
6033 };
6034 return A2(
6035 $gampleman$elm_visualization$Force$Links,
6036 iters,
6037 A2(
6038 $elm$core$List$map,
6039 function (_v0) {
6040 var source = _v0.source;
6041 var target = _v0.target;
6042 var distance = _v0.distance;
6043 var strength = _v0.strength;
6044 return {
6045 bias: count(source) / (count(source) + count(target)),
6046 distance: distance,
6047 source: source,
6048 strength: A2(
6049 $elm$core$Maybe$withDefault,
6050 1 / A2(
6051 $elm$core$Basics$min,
6052 count(source),
6053 count(target)),
6054 strength),
6055 target: target
6056 };
6057 },
6058 list));
6059 });
6060var $gampleman$elm_visualization$Force$State = function (a) {
6061 return {$: 'State', a: a};
6062};
6063var $elm$core$Basics$pow = _Basics_pow;
6064var $gampleman$elm_visualization$Force$iterations = F2(
6065 function (iters, _v0) {
6066 var config = _v0.a;
6067 return $gampleman$elm_visualization$Force$State(
6068 _Utils_update(
6069 config,
6070 {
6071 alphaDecay: 1 - A2($elm$core$Basics$pow, config.minAlpha, 1 / iters)
6072 }));
6073 });
6074var $gampleman$elm_visualization$Force$ManyBody = F2(
6075 function (a, b) {
6076 return {$: 'ManyBody', a: a, b: b};
6077 });
6078var $gampleman$elm_visualization$Force$customManyBody = function (theta) {
6079 return A2(
6080 $elm$core$Basics$composeR,
6081 $elm$core$Dict$fromList,
6082 $gampleman$elm_visualization$Force$ManyBody(theta));
6083};
6084var $gampleman$elm_visualization$Force$manyBodyStrength = function (strength) {
6085 return A2(
6086 $elm$core$Basics$composeL,
6087 $gampleman$elm_visualization$Force$customManyBody(0.9),
6088 $elm$core$List$map(
6089 function (key) {
6090 return _Utils_Tuple2(key, strength);
6091 }));
6092};
6093var $gampleman$elm_visualization$Force$simulation = function (forces) {
6094 return $gampleman$elm_visualization$Force$State(
6095 {
6096 alpha: 1.0,
6097 alphaDecay: 1 - A2($elm$core$Basics$pow, 0.001, 1 / 300),
6098 alphaTarget: 0.0,
6099 forces: forces,
6100 minAlpha: 0.001,
6101 velocityDecay: 0.6
6102 });
6103};
6104var $author$project$Graph$makeSim = F7(
6105 function (w, h, manyBody, collisionRadius, linkDistance, nodeIds, links) {
6106 return A2(
6107 $gampleman$elm_visualization$Force$iterations,
6108 200,
6109 $gampleman$elm_visualization$Force$simulation(
6110 _List_fromArray(
6111 [
6112 A2($gampleman$elm_visualization$Force$manyBodyStrength, manyBody, nodeIds),
6113 A2($gampleman$elm_visualization$Force$center, w / 2, h / 2),
6114 A2(
6115 $gampleman$elm_visualization$Force$customLinks,
6116 1,
6117 A2(
6118 $elm$core$List$map,
6119 function (_v0) {
6120 var s = _v0.a;
6121 var t = _v0.b;
6122 return {distance: linkDistance, source: s, strength: $elm$core$Maybe$Nothing, target: t};
6123 },
6124 links)),
6125 A2($gampleman$elm_visualization$Force$collision, collisionRadius, nodeIds)
6126 ])));
6127 });
6128var $elm$core$Basics$negate = function (n) {
6129 return -n;
6130};
6131var $author$project$Graph$initSimulation = F3(
6132 function (w, h, nodeIds) {
6133 return A7($author$project$Graph$makeSim, w, h, -30, 20, 50, nodeIds, _List_Nil);
6134 });
6135var $author$project$Main$blankModel = F6(
6136 function (w, h, graphApi, jsonApi, key, url) {
6137 return {
6138 activeTab: $author$project$Types$CnpjTab,
6139 collisionRadius: 50,
6140 connectionInput1: '',
6141 connectionInput2: '',
6142 currentQueries: _List_Nil,
6143 dragNode: $elm$core$Maybe$Nothing,
6144 edges: $elm$core$Set$empty,
6145 error: $elm$core$Maybe$Nothing,
6146 graphApi: graphApi,
6147 height: h,
6148 input: '',
6149 isInitialSearch: true,
6150 isPanning: false,
6151 jsonApi: jsonApi,
6152 linkDistance: 80,
6153 manyBody: -150,
6154 navKey: key,
6155 nodes: $elm$core$Dict$empty,
6156 pan: {x: 0, y: 0},
6157 pending: $elm$core$Set$empty,
6158 queryQueue: _List_Nil,
6159 simulation: A3($author$project$Graph$initSimulation, w, h, _List_Nil),
6160 startPos: $elm$core$Maybe$Nothing,
6161 url: url,
6162 visited: $elm$core$Set$empty,
6163 width: w,
6164 zoom: 1.0
6165 };
6166 });
6167var $elm$core$Set$insert = F2(
6168 function (key, _v0) {
6169 var dict = _v0.a;
6170 return $elm$core$Set$Set_elm_builtin(
6171 A3($elm$core$Dict$insert, key, _Utils_Tuple0, dict));
6172 });
6173var $elm$core$Dict$member = F2(
6174 function (key, dict) {
6175 var _v0 = A2($elm$core$Dict$get, key, dict);
6176 if (_v0.$ === 'Just') {
6177 return true;
6178 } else {
6179 return false;
6180 }
6181 });
6182var $elm$core$Set$member = F2(
6183 function (key, _v0) {
6184 var dict = _v0.a;
6185 return A2($elm$core$Dict$member, key, dict);
6186 });
6187var $author$project$Main$queryKey = function (qType) {
6188 if (qType.$ === 'EntityQuery') {
6189 var id = qType.a;
6190 return _Utils_Tuple2(id, 'relacoes');
6191 } else {
6192 var id1 = qType.a;
6193 var id2 = qType.b;
6194 return _Utils_Tuple2(id1 + (';' + id2), 'conexao');
6195 }
6196};
6197var $author$project$Main$enqueueQueries = F2(
6198 function (queries, model) {
6199 var accept = F2(
6200 function (q, _v1) {
6201 var accModel = _v1.a;
6202 var accQueue = _v1.b;
6203 var key = $author$project$Main$queryKey(q.queryType);
6204 return (A2($elm$core$Set$member, key, accModel.pending) || A2($elm$core$Set$member, key, accModel.visited)) ? _Utils_Tuple2(accModel, accQueue) : _Utils_Tuple2(
6205 _Utils_update(
6206 accModel,
6207 {
6208 pending: A2($elm$core$Set$insert, key, accModel.pending)
6209 }),
6210 _Utils_ap(
6211 accQueue,
6212 _List_fromArray(
6213 [q])));
6214 });
6215 var _v0 = A3(
6216 $elm$core$List$foldl,
6217 accept,
6218 _Utils_Tuple2(model, _List_Nil),
6219 queries);
6220 var newModel = _v0.a;
6221 var newQueue = _v0.b;
6222 return _Utils_update(
6223 newModel,
6224 {
6225 queryQueue: _Utils_ap(newModel.queryQueue, newQueue)
6226 });
6227 });
6228var $elm$browser$Browser$Dom$getViewport = _Browser_withWindow(_Browser_getViewport);
6229var $elm$core$String$filter = _String_filter;
6230var $elm$core$String$dropRight = F2(
6231 function (n, string) {
6232 return (n < 1) ? string : A3($elm$core$String$slice, 0, -n, string);
6233 });
6234var $elm$core$Basics$ge = _Utils_ge;
6235var $elm$core$String$toUpper = _String_toUpper;
6236var $author$project$Format$maskCnpjInput = F2(
6237 function (previous, raw) {
6238 var rawAlnum = A2($elm$core$String$filter, $elm$core$Char$isAlphaNum, raw);
6239 var previousAlnum = A2($elm$core$String$filter, $elm$core$Char$isAlphaNum, previous);
6240 var deleting = _Utils_cmp(
6241 $elm$core$String$length(raw),
6242 $elm$core$String$length(previous)) < 0;
6243 var insertAt = F2(
6244 function (_v0, s) {
6245 var pos = _v0.a;
6246 var sep = _v0.b;
6247 var threshold = deleting ? (pos + 1) : pos;
6248 return ((_Utils_cmp(
6249 $elm$core$String$length(s),
6250 threshold) > -1) && ($elm$core$String$length(s) > 0)) ? _Utils_ap(
6251 A2($elm$core$String$left, pos, s),
6252 _Utils_ap(
6253 sep,
6254 A2($elm$core$String$dropLeft, pos, s))) : s;
6255 });
6256 var chunks = _List_fromArray(
6257 [
6258 _Utils_Tuple2(2, '.'),
6259 _Utils_Tuple2(5, '.'),
6260 _Utils_Tuple2(8, '/'),
6261 _Utils_Tuple2(12, '-')
6262 ]);
6263 var backspacedSeparator = deleting && _Utils_eq(
6264 $elm$core$String$length(rawAlnum),
6265 $elm$core$String$length(previousAlnum));
6266 var cleaned = backspacedSeparator ? A2(
6267 $elm$core$String$left,
6268 14,
6269 $elm$core$String$toUpper(
6270 A2($elm$core$String$dropRight, 1, rawAlnum))) : A2(
6271 $elm$core$String$left,
6272 14,
6273 $elm$core$String$toUpper(rawAlnum));
6274 return A3($elm$core$List$foldr, insertAt, cleaned, chunks);
6275 });
6276var $author$project$Format$formatCnpj = function (s) {
6277 return A2($author$project$Format$maskCnpjInput, '', s);
6278};
6279var $author$project$Format$formatCpf = function (s) {
6280 return A2($elm$core$String$left, 3, s) + ('.' + (A3($elm$core$String$slice, 3, 6, s) + ('.' + (A3($elm$core$String$slice, 6, 9, s) + ('-' + A3($elm$core$String$slice, 9, 11, s))))));
6281};
6282var $author$project$Format$mask = function (raw) {
6283 var cleaned = A2(
6284 $elm$core$String$filter,
6285 function (c) {
6286 return $elm$core$Char$isAlphaNum(c) || _Utils_eq(
6287 c,
6288 _Utils_chr('*'));
6289 },
6290 raw);
6291 return ($elm$core$String$length(cleaned) === 14) ? $author$project$Format$formatCnpj(cleaned) : (($elm$core$String$length(cleaned) === 11) ? $author$project$Format$formatCpf(cleaned) : raw);
6292};
6293var $elm$core$Platform$Cmd$none = $elm$core$Platform$Cmd$batch(_List_Nil);
6294var $author$project$Main$CnpjRoute = function (a) {
6295 return {$: 'CnpjRoute', a: a};
6296};
6297var $author$project$Main$ConnectionRoute = F2(
6298 function (a, b) {
6299 return {$: 'ConnectionRoute', a: a, b: b};
6300 });
6301var $author$project$Main$HomeRoute = {$: 'HomeRoute'};
6302var $author$project$Main$parseUrl = function (url) {
6303 var _v0 = url.fragment;
6304 if (_v0.$ === 'Just') {
6305 var frag = _v0.a;
6306 var cleanFrag = A2($elm$core$String$startsWith, '/', frag) ? A2($elm$core$String$dropLeft, 1, frag) : frag;
6307 var parts = A2($elm$core$String$split, '/', cleanFrag);
6308 _v1$2:
6309 while (true) {
6310 if (parts.b && parts.b.b) {
6311 if (parts.b.b.b) {
6312 if ((parts.a === 'conexao') && (!parts.b.b.b.b)) {
6313 var _v2 = parts.b;
6314 var id1 = _v2.a;
6315 var _v3 = _v2.b;
6316 var id2 = _v3.a;
6317 return A2($author$project$Main$ConnectionRoute, id1, id2);
6318 } else {
6319 break _v1$2;
6320 }
6321 } else {
6322 if (parts.a === 'grafo') {
6323 var _v4 = parts.b;
6324 var id = _v4.a;
6325 return $author$project$Main$CnpjRoute(id);
6326 } else {
6327 break _v1$2;
6328 }
6329 }
6330 } else {
6331 break _v1$2;
6332 }
6333 }
6334 var semiParts = A2($elm$core$String$split, ';', frag);
6335 _v5$2:
6336 while (true) {
6337 if (semiParts.b) {
6338 if (semiParts.b.b) {
6339 if (!semiParts.b.b.b) {
6340 var id1 = semiParts.a;
6341 var _v6 = semiParts.b;
6342 var id2 = _v6.a;
6343 return A2($author$project$Main$ConnectionRoute, id1, id2);
6344 } else {
6345 break _v5$2;
6346 }
6347 } else {
6348 var id = semiParts.a;
6349 return $elm$core$String$isEmpty(id) ? $author$project$Main$HomeRoute : $author$project$Main$CnpjRoute(id);
6350 }
6351 } else {
6352 break _v5$2;
6353 }
6354 }
6355 return $author$project$Main$HomeRoute;
6356 } else {
6357 return $author$project$Main$HomeRoute;
6358 }
6359};
6360var $author$project$Types$EntityQuery = function (a) {
6361 return {$: 'EntityQuery', a: a};
6362};
6363var $elm$core$List$filter = F2(
6364 function (isGood, list) {
6365 return A3(
6366 $elm$core$List$foldr,
6367 F2(
6368 function (x, xs) {
6369 return isGood(x) ? A2($elm$core$List$cons, x, xs) : xs;
6370 }),
6371 _List_Nil,
6372 list);
6373 });
6374var $elm$core$Basics$not = _Basics_not;
6375var $author$project$Main$queriesFor = F3(
6376 function (id, _v0, depth) {
6377 return A2($elm$core$String$contains, ',', id) ? A2(
6378 $elm$core$List$map,
6379 function (singleId) {
6380 return A3(
6381 $author$project$Types$QueryRequest,
6382 singleId,
6383 depth,
6384 $author$project$Types$EntityQuery(singleId));
6385 },
6386 A2(
6387 $elm$core$List$filter,
6388 A2($elm$core$Basics$composeL, $elm$core$Basics$not, $elm$core$String$isEmpty),
6389 A2(
6390 $elm$core$List$map,
6391 $elm$core$String$filter(
6392 function (c) {
6393 return $elm$core$Char$isAlphaNum(c) || _Utils_eq(
6394 c,
6395 _Utils_chr('*'));
6396 }),
6397 A2($elm$core$String$split, ',', id)))) : _List_fromArray(
6398 [
6399 A3(
6400 $author$project$Types$QueryRequest,
6401 id,
6402 depth,
6403 $author$project$Types$EntityQuery(id))
6404 ]);
6405 });
6406var $elm$core$List$drop = F2(
6407 function (n, list) {
6408 drop:
6409 while (true) {
6410 if (n <= 0) {
6411 return list;
6412 } else {
6413 if (!list.b) {
6414 return list;
6415 } else {
6416 var x = list.a;
6417 var xs = list.b;
6418 var $temp$n = n - 1,
6419 $temp$list = xs;
6420 n = $temp$n;
6421 list = $temp$list;
6422 continue drop;
6423 }
6424 }
6425 }
6426 });
6427var $elm$core$List$isEmpty = function (xs) {
6428 if (!xs.b) {
6429 return true;
6430 } else {
6431 return false;
6432 }
6433};
6434var $author$project$Types$GotResponse = F4(
6435 function (a, b, c, d) {
6436 return {$: 'GotResponse', a: a, b: b, c: c, d: d};
6437 });
6438var $elm$http$Http$BadStatus_ = F2(
6439 function (a, b) {
6440 return {$: 'BadStatus_', a: a, b: b};
6441 });
6442var $elm$http$Http$BadUrl_ = function (a) {
6443 return {$: 'BadUrl_', a: a};
6444};
6445var $elm$http$Http$GoodStatus_ = F2(
6446 function (a, b) {
6447 return {$: 'GoodStatus_', a: a, b: b};
6448 });
6449var $elm$http$Http$NetworkError_ = {$: 'NetworkError_'};
6450var $elm$http$Http$Receiving = function (a) {
6451 return {$: 'Receiving', a: a};
6452};
6453var $elm$http$Http$Sending = function (a) {
6454 return {$: 'Sending', a: a};
6455};
6456var $elm$http$Http$Timeout_ = {$: 'Timeout_'};
6457var $elm$core$Maybe$isJust = function (maybe) {
6458 if (maybe.$ === 'Just') {
6459 return true;
6460 } else {
6461 return false;
6462 }
6463};
6464var $elm$core$Platform$sendToSelf = _Platform_sendToSelf;
6465var $elm$http$Http$expectStringResponse = F2(
6466 function (toMsg, toResult) {
6467 return A3(
6468 _Http_expect,
6469 '',
6470 $elm$core$Basics$identity,
6471 A2($elm$core$Basics$composeR, toResult, toMsg));
6472 });
6473var $elm$http$Http$emptyBody = _Http_emptyBody;
6474var $elm$http$Http$Request = function (a) {
6475 return {$: 'Request', a: a};
6476};
6477var $elm$http$Http$State = F2(
6478 function (reqs, subs) {
6479 return {reqs: reqs, subs: subs};
6480 });
6481var $elm$http$Http$init = $elm$core$Task$succeed(
6482 A2($elm$http$Http$State, $elm$core$Dict$empty, _List_Nil));
6483var $elm$core$Process$kill = _Scheduler_kill;
6484var $elm$core$Process$spawn = _Scheduler_spawn;
6485var $elm$http$Http$updateReqs = F3(
6486 function (router, cmds, reqs) {
6487 updateReqs:
6488 while (true) {
6489 if (!cmds.b) {
6490 return $elm$core$Task$succeed(reqs);
6491 } else {
6492 var cmd = cmds.a;
6493 var otherCmds = cmds.b;
6494 if (cmd.$ === 'Cancel') {
6495 var tracker = cmd.a;
6496 var _v2 = A2($elm$core$Dict$get, tracker, reqs);
6497 if (_v2.$ === 'Nothing') {
6498 var $temp$router = router,
6499 $temp$cmds = otherCmds,
6500 $temp$reqs = reqs;
6501 router = $temp$router;
6502 cmds = $temp$cmds;
6503 reqs = $temp$reqs;
6504 continue updateReqs;
6505 } else {
6506 var pid = _v2.a;
6507 return A2(
6508 $elm$core$Task$andThen,
6509 function (_v3) {
6510 return A3(
6511 $elm$http$Http$updateReqs,
6512 router,
6513 otherCmds,
6514 A2($elm$core$Dict$remove, tracker, reqs));
6515 },
6516 $elm$core$Process$kill(pid));
6517 }
6518 } else {
6519 var req = cmd.a;
6520 return A2(
6521 $elm$core$Task$andThen,
6522 function (pid) {
6523 var _v4 = req.tracker;
6524 if (_v4.$ === 'Nothing') {
6525 return A3($elm$http$Http$updateReqs, router, otherCmds, reqs);
6526 } else {
6527 var tracker = _v4.a;
6528 return A3(
6529 $elm$http$Http$updateReqs,
6530 router,
6531 otherCmds,
6532 A3($elm$core$Dict$insert, tracker, pid, reqs));
6533 }
6534 },
6535 $elm$core$Process$spawn(
6536 A3(
6537 _Http_toTask,
6538 router,
6539 $elm$core$Platform$sendToApp(router),
6540 req)));
6541 }
6542 }
6543 }
6544 });
6545var $elm$http$Http$onEffects = F4(
6546 function (router, cmds, subs, state) {
6547 return A2(
6548 $elm$core$Task$andThen,
6549 function (reqs) {
6550 return $elm$core$Task$succeed(
6551 A2($elm$http$Http$State, reqs, subs));
6552 },
6553 A3($elm$http$Http$updateReqs, router, cmds, state.reqs));
6554 });
6555var $elm$core$List$maybeCons = F3(
6556 function (f, mx, xs) {
6557 var _v0 = f(mx);
6558 if (_v0.$ === 'Just') {
6559 var x = _v0.a;
6560 return A2($elm$core$List$cons, x, xs);
6561 } else {
6562 return xs;
6563 }
6564 });
6565var $elm$core$List$filterMap = F2(
6566 function (f, xs) {
6567 return A3(
6568 $elm$core$List$foldr,
6569 $elm$core$List$maybeCons(f),
6570 _List_Nil,
6571 xs);
6572 });
6573var $elm$http$Http$maybeSend = F4(
6574 function (router, desiredTracker, progress, _v0) {
6575 var actualTracker = _v0.a;
6576 var toMsg = _v0.b;
6577 return _Utils_eq(desiredTracker, actualTracker) ? $elm$core$Maybe$Just(
6578 A2(
6579 $elm$core$Platform$sendToApp,
6580 router,
6581 toMsg(progress))) : $elm$core$Maybe$Nothing;
6582 });
6583var $elm$http$Http$onSelfMsg = F3(
6584 function (router, _v0, state) {
6585 var tracker = _v0.a;
6586 var progress = _v0.b;
6587 return A2(
6588 $elm$core$Task$andThen,
6589 function (_v1) {
6590 return $elm$core$Task$succeed(state);
6591 },
6592 $elm$core$Task$sequence(
6593 A2(
6594 $elm$core$List$filterMap,
6595 A3($elm$http$Http$maybeSend, router, tracker, progress),
6596 state.subs)));
6597 });
6598var $elm$http$Http$Cancel = function (a) {
6599 return {$: 'Cancel', a: a};
6600};
6601var $elm$http$Http$cmdMap = F2(
6602 function (func, cmd) {
6603 if (cmd.$ === 'Cancel') {
6604 var tracker = cmd.a;
6605 return $elm$http$Http$Cancel(tracker);
6606 } else {
6607 var r = cmd.a;
6608 return $elm$http$Http$Request(
6609 {
6610 allowCookiesFromOtherDomains: r.allowCookiesFromOtherDomains,
6611 body: r.body,
6612 expect: A2(_Http_mapExpect, func, r.expect),
6613 headers: r.headers,
6614 method: r.method,
6615 timeout: r.timeout,
6616 tracker: r.tracker,
6617 url: r.url
6618 });
6619 }
6620 });
6621var $elm$http$Http$MySub = F2(
6622 function (a, b) {
6623 return {$: 'MySub', a: a, b: b};
6624 });
6625var $elm$http$Http$subMap = F2(
6626 function (func, _v0) {
6627 var tracker = _v0.a;
6628 var toMsg = _v0.b;
6629 return A2(
6630 $elm$http$Http$MySub,
6631 tracker,
6632 A2($elm$core$Basics$composeR, toMsg, func));
6633 });
6634_Platform_effectManagers['Http'] = _Platform_createManager($elm$http$Http$init, $elm$http$Http$onEffects, $elm$http$Http$onSelfMsg, $elm$http$Http$cmdMap, $elm$http$Http$subMap);
6635var $elm$http$Http$command = _Platform_leaf('Http');
6636var $elm$http$Http$subscription = _Platform_leaf('Http');
6637var $elm$http$Http$request = function (r) {
6638 return $elm$http$Http$command(
6639 $elm$http$Http$Request(
6640 {allowCookiesFromOtherDomains: false, body: r.body, expect: r.expect, headers: r.headers, method: r.method, timeout: r.timeout, tracker: r.tracker, url: r.url}));
6641};
6642var $elm$http$Http$get = function (r) {
6643 return $elm$http$Http$request(
6644 {body: $elm$http$Http$emptyBody, expect: r.expect, headers: _List_Nil, method: 'GET', timeout: $elm$core$Maybe$Nothing, tracker: $elm$core$Maybe$Nothing, url: r.url});
6645};
6646var $elm$core$String$right = F2(
6647 function (n, string) {
6648 return (n < 1) ? '' : A3(
6649 $elm$core$String$slice,
6650 -n,
6651 $elm$core$String$length(string),
6652 string);
6653 });
6654var $elm$http$Http$BadBody = function (a) {
6655 return {$: 'BadBody', a: a};
6656};
6657var $author$project$Types$BadRequest = function (a) {
6658 return {$: 'BadRequest', a: a};
6659};
6660var $elm$http$Http$BadStatus = function (a) {
6661 return {$: 'BadStatus', a: a};
6662};
6663var $elm$http$Http$BadUrl = function (a) {
6664 return {$: 'BadUrl', a: a};
6665};
6666var $author$project$Types$HttpError = function (a) {
6667 return {$: 'HttpError', a: a};
6668};
6669var $elm$http$Http$NetworkError = {$: 'NetworkError'};
6670var $author$project$Types$NotFound = {$: 'NotFound'};
6671var $elm$http$Http$Timeout = {$: 'Timeout'};
6672var $elm$json$Json$Decode$decodeString = _Json_runOnString;
6673var $elm$json$Json$Decode$list = _Json_decodeList;
6674var $author$project$Types$Relation = F5(
6675 function (cnpj, razaoSocial, partnerId, partnerName, partnerCpf) {
6676 return {cnpj: cnpj, partnerCpf: partnerCpf, partnerId: partnerId, partnerName: partnerName, razaoSocial: razaoSocial};
6677 });
6678var $elm$json$Json$Decode$map5 = _Json_map5;
6679var $elm$json$Json$Decode$oneOf = _Json_oneOf;
6680var $elm$json$Json$Decode$maybe = function (decoder) {
6681 return $elm$json$Json$Decode$oneOf(
6682 _List_fromArray(
6683 [
6684 A2($elm$json$Json$Decode$map, $elm$core$Maybe$Just, decoder),
6685 $elm$json$Json$Decode$succeed($elm$core$Maybe$Nothing)
6686 ]));
6687};
6688var $elm$json$Json$Decode$string = _Json_decodeString;
6689var $author$project$Api$relationDecoder = A6(
6690 $elm$json$Json$Decode$map5,
6691 $author$project$Types$Relation,
6692 A2($elm$json$Json$Decode$field, 'cnpj', $elm$json$Json$Decode$string),
6693 A2($elm$json$Json$Decode$field, 'razao_social', $elm$json$Json$Decode$string),
6694 A2($elm$json$Json$Decode$field, 'id', $elm$json$Json$Decode$string),
6695 $elm$json$Json$Decode$maybe(
6696 A2($elm$json$Json$Decode$field, 'nome', $elm$json$Json$Decode$string)),
6697 $elm$json$Json$Decode$maybe(
6698 A2($elm$json$Json$Decode$field, 'cpf', $elm$json$Json$Decode$string)));
6699var $author$project$Api$toApiResult = function (response) {
6700 switch (response.$) {
6701 case 'BadUrl_':
6702 var u = response.a;
6703 return $elm$core$Result$Err(
6704 $author$project$Types$HttpError(
6705 $elm$http$Http$BadUrl(u)));
6706 case 'Timeout_':
6707 return $elm$core$Result$Err(
6708 $author$project$Types$HttpError($elm$http$Http$Timeout));
6709 case 'NetworkError_':
6710 return $elm$core$Result$Err(
6711 $author$project$Types$HttpError($elm$http$Http$NetworkError));
6712 case 'BadStatus_':
6713 var meta = response.a;
6714 var body = response.b;
6715 if (meta.statusCode === 404) {
6716 return $elm$core$Result$Err($author$project$Types$NotFound);
6717 } else {
6718 if (meta.statusCode === 400) {
6719 var _v1 = A2(
6720 $elm$json$Json$Decode$decodeString,
6721 A2($elm$json$Json$Decode$field, 'message', $elm$json$Json$Decode$string),
6722 body);
6723 if (_v1.$ === 'Ok') {
6724 var msg = _v1.a;
6725 return $elm$core$Result$Err(
6726 $author$project$Types$BadRequest(msg));
6727 } else {
6728 return $elm$core$Result$Err(
6729 $author$project$Types$HttpError(
6730 $elm$http$Http$BadStatus(meta.statusCode)));
6731 }
6732 } else {
6733 return $elm$core$Result$Err(
6734 $author$project$Types$HttpError(
6735 $elm$http$Http$BadStatus(meta.statusCode)));
6736 }
6737 }
6738 default:
6739 var body = response.b;
6740 var _v2 = A2(
6741 $elm$json$Json$Decode$decodeString,
6742 $elm$json$Json$Decode$list($author$project$Api$relationDecoder),
6743 body);
6744 if (_v2.$ === 'Ok') {
6745 var value = _v2.a;
6746 return $elm$core$Result$Ok(value);
6747 } else {
6748 var err = _v2.a;
6749 return $elm$core$Result$Err(
6750 $author$project$Types$HttpError(
6751 $elm$http$Http$BadBody(
6752 $elm$json$Json$Decode$errorToString(err))));
6753 }
6754 }
6755};
6756var $author$project$Api$queryEntity = F3(
6757 function (graphApi, qType, depth) {
6758 var base = (A2($elm$core$String$right, 1, graphApi) === '/') ? graphApi : (graphApi + '/');
6759 var _v0 = function () {
6760 if (qType.$ === 'EntityQuery') {
6761 var term = qType.a;
6762 return _Utils_Tuple2(term, base + ('relacoes/' + term));
6763 } else {
6764 var id1 = qType.a;
6765 var id2 = qType.b;
6766 return _Utils_Tuple2(id1 + (';' + id2), base + ('conexao/' + (id1 + ('/' + id2))));
6767 }
6768 }();
6769 var id = _v0.a;
6770 var url = _v0.b;
6771 return $elm$http$Http$get(
6772 {
6773 expect: A2(
6774 $elm$http$Http$expectStringResponse,
6775 A3($author$project$Types$GotResponse, id, url, depth),
6776 $author$project$Api$toApiResult),
6777 url: url
6778 });
6779 });
6780var $elm$core$List$takeReverse = F3(
6781 function (n, list, kept) {
6782 takeReverse:
6783 while (true) {
6784 if (n <= 0) {
6785 return kept;
6786 } else {
6787 if (!list.b) {
6788 return kept;
6789 } else {
6790 var x = list.a;
6791 var xs = list.b;
6792 var $temp$n = n - 1,
6793 $temp$list = xs,
6794 $temp$kept = A2($elm$core$List$cons, x, kept);
6795 n = $temp$n;
6796 list = $temp$list;
6797 kept = $temp$kept;
6798 continue takeReverse;
6799 }
6800 }
6801 }
6802 });
6803var $elm$core$List$takeTailRec = F2(
6804 function (n, list) {
6805 return $elm$core$List$reverse(
6806 A3($elm$core$List$takeReverse, n, list, _List_Nil));
6807 });
6808var $elm$core$List$takeFast = F3(
6809 function (ctr, n, list) {
6810 if (n <= 0) {
6811 return _List_Nil;
6812 } else {
6813 var _v0 = _Utils_Tuple2(n, list);
6814 _v0$1:
6815 while (true) {
6816 _v0$5:
6817 while (true) {
6818 if (!_v0.b.b) {
6819 return list;
6820 } else {
6821 if (_v0.b.b.b) {
6822 switch (_v0.a) {
6823 case 1:
6824 break _v0$1;
6825 case 2:
6826 var _v2 = _v0.b;
6827 var x = _v2.a;
6828 var _v3 = _v2.b;
6829 var y = _v3.a;
6830 return _List_fromArray(
6831 [x, y]);
6832 case 3:
6833 if (_v0.b.b.b.b) {
6834 var _v4 = _v0.b;
6835 var x = _v4.a;
6836 var _v5 = _v4.b;
6837 var y = _v5.a;
6838 var _v6 = _v5.b;
6839 var z = _v6.a;
6840 return _List_fromArray(
6841 [x, y, z]);
6842 } else {
6843 break _v0$5;
6844 }
6845 default:
6846 if (_v0.b.b.b.b && _v0.b.b.b.b.b) {
6847 var _v7 = _v0.b;
6848 var x = _v7.a;
6849 var _v8 = _v7.b;
6850 var y = _v8.a;
6851 var _v9 = _v8.b;
6852 var z = _v9.a;
6853 var _v10 = _v9.b;
6854 var w = _v10.a;
6855 var tl = _v10.b;
6856 return (ctr > 1000) ? A2(
6857 $elm$core$List$cons,
6858 x,
6859 A2(
6860 $elm$core$List$cons,
6861 y,
6862 A2(
6863 $elm$core$List$cons,
6864 z,
6865 A2(
6866 $elm$core$List$cons,
6867 w,
6868 A2($elm$core$List$takeTailRec, n - 4, tl))))) : A2(
6869 $elm$core$List$cons,
6870 x,
6871 A2(
6872 $elm$core$List$cons,
6873 y,
6874 A2(
6875 $elm$core$List$cons,
6876 z,
6877 A2(
6878 $elm$core$List$cons,
6879 w,
6880 A3($elm$core$List$takeFast, ctr + 1, n - 4, tl)))));
6881 } else {
6882 break _v0$5;
6883 }
6884 }
6885 } else {
6886 if (_v0.a === 1) {
6887 break _v0$1;
6888 } else {
6889 break _v0$5;
6890 }
6891 }
6892 }
6893 }
6894 return list;
6895 }
6896 var _v1 = _v0.b;
6897 var x = _v1.a;
6898 return _List_fromArray(
6899 [x]);
6900 }
6901 });
6902var $elm$core$List$take = F2(
6903 function (n, list) {
6904 return A3($elm$core$List$takeFast, 0, n, list);
6905 });
6906var $author$project$Main$triggerNextQuery = function (model) {
6907 var concurrencyLimit = 6;
6908 var activeCount = $elm$core$List$length(model.currentQueries);
6909 var availableSlots = concurrencyLimit - activeCount;
6910 if ((availableSlots > 0) && (!$elm$core$List$isEmpty(model.queryQueue))) {
6911 var toTrigger = A2($elm$core$List$take, availableSlots, model.queryQueue);
6912 var remaining = A2($elm$core$List$drop, availableSlots, model.queryQueue);
6913 var newModel = _Utils_update(
6914 model,
6915 {
6916 currentQueries: _Utils_ap(model.currentQueries, toTrigger),
6917 queryQueue: remaining
6918 });
6919 var cmds = A2(
6920 $elm$core$List$map,
6921 function (q) {
6922 return A3($author$project$Api$queryEntity, model.graphApi, q.queryType, q.depth);
6923 },
6924 toTrigger);
6925 return _Utils_Tuple2(
6926 newModel,
6927 $elm$core$Platform$Cmd$batch(cmds));
6928 } else {
6929 return _Utils_Tuple2(model, $elm$core$Platform$Cmd$none);
6930 }
6931};
6932var $author$project$Main$init = F3(
6933 function (flags, url, key) {
6934 var initialModel = A6($author$project$Main$blankModel, 800, 600, flags.graphApi, flags.jsonApi, key, url);
6935 var _v0 = function () {
6936 var _v1 = $author$project$Main$parseUrl(url);
6937 switch (_v1.$) {
6938 case 'CnpjRoute':
6939 var cnpj = _v1.a;
6940 var seeded = A2(
6941 $author$project$Main$enqueueQueries,
6942 A3($author$project$Main$queriesFor, cnpj, true, 0),
6943 _Utils_update(
6944 initialModel,
6945 {
6946 input: $author$project$Format$mask(cnpj)
6947 }));
6948 return $author$project$Main$triggerNextQuery(seeded);
6949 case 'ConnectionRoute':
6950 var id1 = _v1.a;
6951 var id2 = _v1.b;
6952 var seeded = A2(
6953 $author$project$Main$enqueueQueries,
6954 _List_fromArray(
6955 [
6956 A3(
6957 $author$project$Types$QueryRequest,
6958 id1 + (';' + id2),
6959 0,
6960 A2($author$project$Types$ConnectionQuery, id1, id2))
6961 ]),
6962 _Utils_update(
6963 initialModel,
6964 {
6965 activeTab: $author$project$Types$ConnectionTab,
6966 connectionInput1: $author$project$Format$mask(id1),
6967 connectionInput2: $author$project$Format$mask(id2)
6968 }));
6969 return $author$project$Main$triggerNextQuery(seeded);
6970 default:
6971 return _Utils_Tuple2(initialModel, $elm$core$Platform$Cmd$none);
6972 }
6973 }();
6974 var finalModel = _v0.a;
6975 var initialCmd = _v0.b;
6976 return _Utils_Tuple2(
6977 finalModel,
6978 $elm$core$Platform$Cmd$batch(
6979 _List_fromArray(
6980 [
6981 initialCmd,
6982 A2(
6983 $elm$core$Task$perform,
6984 function (_v2) {
6985 var viewport = _v2.viewport;
6986 return A2($author$project$Types$Resize, viewport.width, viewport.height);
6987 },
6988 $elm$browser$Browser$Dom$getViewport)
6989 ])));
6990 });
6991var $author$project$Types$InteractionEnd = F2(
6992 function (a, b) {
6993 return {$: 'InteractionEnd', a: a, b: b};
6994 });
6995var $author$project$Types$InteractionMove = F2(
6996 function (a, b) {
6997 return {$: 'InteractionMove', a: a, b: b};
6998 });
6999var $author$project$Types$Tick = {$: 'Tick'};
7000var $elm$core$Platform$Sub$batch = _Platform_batch;
7001var $elm$json$Json$Decode$float = _Json_decodeFloat;
7002var $gampleman$elm_visualization$Force$isCompleted = function (_v0) {
7003 var alpha = _v0.a.alpha;
7004 var minAlpha = _v0.a.minAlpha;
7005 return _Utils_cmp(alpha, minAlpha) < 1;
7006};
7007var $elm$core$Dict$isEmpty = function (dict) {
7008 if (dict.$ === 'RBEmpty_elm_builtin') {
7009 return true;
7010 } else {
7011 return false;
7012 }
7013};
7014var $author$project$Graph$isSimulating = function (model) {
7015 return (!$elm$core$Dict$isEmpty(model.nodes)) && (!$gampleman$elm_visualization$Force$isCompleted(model.simulation));
7016};
7017var $elm$core$Basics$neq = _Utils_notEqual;
7018var $elm$browser$Browser$AnimationManager$Time = function (a) {
7019 return {$: 'Time', a: a};
7020};
7021var $elm$browser$Browser$AnimationManager$State = F3(
7022 function (subs, request, oldTime) {
7023 return {oldTime: oldTime, request: request, subs: subs};
7024 });
7025var $elm$browser$Browser$AnimationManager$init = $elm$core$Task$succeed(
7026 A3($elm$browser$Browser$AnimationManager$State, _List_Nil, $elm$core$Maybe$Nothing, 0));
7027var $elm$browser$Browser$AnimationManager$now = _Browser_now(_Utils_Tuple0);
7028var $elm$browser$Browser$AnimationManager$rAF = _Browser_rAF(_Utils_Tuple0);
7029var $elm$browser$Browser$AnimationManager$onEffects = F3(
7030 function (router, subs, _v0) {
7031 var request = _v0.request;
7032 var oldTime = _v0.oldTime;
7033 var _v1 = _Utils_Tuple2(request, subs);
7034 if (_v1.a.$ === 'Nothing') {
7035 if (!_v1.b.b) {
7036 var _v2 = _v1.a;
7037 return $elm$browser$Browser$AnimationManager$init;
7038 } else {
7039 var _v4 = _v1.a;
7040 return A2(
7041 $elm$core$Task$andThen,
7042 function (pid) {
7043 return A2(
7044 $elm$core$Task$andThen,
7045 function (time) {
7046 return $elm$core$Task$succeed(
7047 A3(
7048 $elm$browser$Browser$AnimationManager$State,
7049 subs,
7050 $elm$core$Maybe$Just(pid),
7051 time));
7052 },
7053 $elm$browser$Browser$AnimationManager$now);
7054 },
7055 $elm$core$Process$spawn(
7056 A2(
7057 $elm$core$Task$andThen,
7058 $elm$core$Platform$sendToSelf(router),
7059 $elm$browser$Browser$AnimationManager$rAF)));
7060 }
7061 } else {
7062 if (!_v1.b.b) {
7063 var pid = _v1.a.a;
7064 return A2(
7065 $elm$core$Task$andThen,
7066 function (_v3) {
7067 return $elm$browser$Browser$AnimationManager$init;
7068 },
7069 $elm$core$Process$kill(pid));
7070 } else {
7071 return $elm$core$Task$succeed(
7072 A3($elm$browser$Browser$AnimationManager$State, subs, request, oldTime));
7073 }
7074 }
7075 });
7076var $elm$time$Time$Posix = function (a) {
7077 return {$: 'Posix', a: a};
7078};
7079var $elm$time$Time$millisToPosix = $elm$time$Time$Posix;
7080var $elm$browser$Browser$AnimationManager$onSelfMsg = F3(
7081 function (router, newTime, _v0) {
7082 var subs = _v0.subs;
7083 var oldTime = _v0.oldTime;
7084 var send = function (sub) {
7085 if (sub.$ === 'Time') {
7086 var tagger = sub.a;
7087 return A2(
7088 $elm$core$Platform$sendToApp,
7089 router,
7090 tagger(
7091 $elm$time$Time$millisToPosix(newTime)));
7092 } else {
7093 var tagger = sub.a;
7094 return A2(
7095 $elm$core$Platform$sendToApp,
7096 router,
7097 tagger(newTime - oldTime));
7098 }
7099 };
7100 return A2(
7101 $elm$core$Task$andThen,
7102 function (pid) {
7103 return A2(
7104 $elm$core$Task$andThen,
7105 function (_v1) {
7106 return $elm$core$Task$succeed(
7107 A3(
7108 $elm$browser$Browser$AnimationManager$State,
7109 subs,
7110 $elm$core$Maybe$Just(pid),
7111 newTime));
7112 },
7113 $elm$core$Task$sequence(
7114 A2($elm$core$List$map, send, subs)));
7115 },
7116 $elm$core$Process$spawn(
7117 A2(
7118 $elm$core$Task$andThen,
7119 $elm$core$Platform$sendToSelf(router),
7120 $elm$browser$Browser$AnimationManager$rAF)));
7121 });
7122var $elm$browser$Browser$AnimationManager$Delta = function (a) {
7123 return {$: 'Delta', a: a};
7124};
7125var $elm$browser$Browser$AnimationManager$subMap = F2(
7126 function (func, sub) {
7127 if (sub.$ === 'Time') {
7128 var tagger = sub.a;
7129 return $elm$browser$Browser$AnimationManager$Time(
7130 A2($elm$core$Basics$composeL, func, tagger));
7131 } else {
7132 var tagger = sub.a;
7133 return $elm$browser$Browser$AnimationManager$Delta(
7134 A2($elm$core$Basics$composeL, func, tagger));
7135 }
7136 });
7137_Platform_effectManagers['Browser.AnimationManager'] = _Platform_createManager($elm$browser$Browser$AnimationManager$init, $elm$browser$Browser$AnimationManager$onEffects, $elm$browser$Browser$AnimationManager$onSelfMsg, 0, $elm$browser$Browser$AnimationManager$subMap);
7138var $elm$browser$Browser$AnimationManager$subscription = _Platform_leaf('Browser.AnimationManager');
7139var $elm$browser$Browser$AnimationManager$onAnimationFrame = function (tagger) {
7140 return $elm$browser$Browser$AnimationManager$subscription(
7141 $elm$browser$Browser$AnimationManager$Time(tagger));
7142};
7143var $elm$browser$Browser$Events$onAnimationFrame = $elm$browser$Browser$AnimationManager$onAnimationFrame;
7144var $elm$browser$Browser$Events$Document = {$: 'Document'};
7145var $elm$browser$Browser$Events$MySub = F3(
7146 function (a, b, c) {
7147 return {$: 'MySub', a: a, b: b, c: c};
7148 });
7149var $elm$browser$Browser$Events$State = F2(
7150 function (subs, pids) {
7151 return {pids: pids, subs: subs};
7152 });
7153var $elm$browser$Browser$Events$init = $elm$core$Task$succeed(
7154 A2($elm$browser$Browser$Events$State, _List_Nil, $elm$core$Dict$empty));
7155var $elm$browser$Browser$Events$nodeToKey = function (node) {
7156 if (node.$ === 'Document') {
7157 return 'd_';
7158 } else {
7159 return 'w_';
7160 }
7161};
7162var $elm$browser$Browser$Events$addKey = function (sub) {
7163 var node = sub.a;
7164 var name = sub.b;
7165 return _Utils_Tuple2(
7166 _Utils_ap(
7167 $elm$browser$Browser$Events$nodeToKey(node),
7168 name),
7169 sub);
7170};
7171var $elm$core$Dict$foldl = F3(
7172 function (func, acc, dict) {
7173 foldl:
7174 while (true) {
7175 if (dict.$ === 'RBEmpty_elm_builtin') {
7176 return acc;
7177 } else {
7178 var key = dict.b;
7179 var value = dict.c;
7180 var left = dict.d;
7181 var right = dict.e;
7182 var $temp$func = func,
7183 $temp$acc = A3(
7184 func,
7185 key,
7186 value,
7187 A3($elm$core$Dict$foldl, func, acc, left)),
7188 $temp$dict = right;
7189 func = $temp$func;
7190 acc = $temp$acc;
7191 dict = $temp$dict;
7192 continue foldl;
7193 }
7194 }
7195 });
7196var $elm$core$Dict$merge = F6(
7197 function (leftStep, bothStep, rightStep, leftDict, rightDict, initialResult) {
7198 var stepState = F3(
7199 function (rKey, rValue, _v0) {
7200 stepState:
7201 while (true) {
7202 var list = _v0.a;
7203 var result = _v0.b;
7204 if (!list.b) {
7205 return _Utils_Tuple2(
7206 list,
7207 A3(rightStep, rKey, rValue, result));
7208 } else {
7209 var _v2 = list.a;
7210 var lKey = _v2.a;
7211 var lValue = _v2.b;
7212 var rest = list.b;
7213 if (_Utils_cmp(lKey, rKey) < 0) {
7214 var $temp$rKey = rKey,
7215 $temp$rValue = rValue,
7216 $temp$_v0 = _Utils_Tuple2(
7217 rest,
7218 A3(leftStep, lKey, lValue, result));
7219 rKey = $temp$rKey;
7220 rValue = $temp$rValue;
7221 _v0 = $temp$_v0;
7222 continue stepState;
7223 } else {
7224 if (_Utils_cmp(lKey, rKey) > 0) {
7225 return _Utils_Tuple2(
7226 list,
7227 A3(rightStep, rKey, rValue, result));
7228 } else {
7229 return _Utils_Tuple2(
7230 rest,
7231 A4(bothStep, lKey, lValue, rValue, result));
7232 }
7233 }
7234 }
7235 }
7236 });
7237 var _v3 = A3(
7238 $elm$core$Dict$foldl,
7239 stepState,
7240 _Utils_Tuple2(
7241 $elm$core$Dict$toList(leftDict),
7242 initialResult),
7243 rightDict);
7244 var leftovers = _v3.a;
7245 var intermediateResult = _v3.b;
7246 return A3(
7247 $elm$core$List$foldl,
7248 F2(
7249 function (_v4, result) {
7250 var k = _v4.a;
7251 var v = _v4.b;
7252 return A3(leftStep, k, v, result);
7253 }),
7254 intermediateResult,
7255 leftovers);
7256 });
7257var $elm$browser$Browser$Events$Event = F2(
7258 function (key, event) {
7259 return {event: event, key: key};
7260 });
7261var $elm$browser$Browser$Events$spawn = F3(
7262 function (router, key, _v0) {
7263 var node = _v0.a;
7264 var name = _v0.b;
7265 var actualNode = function () {
7266 if (node.$ === 'Document') {
7267 return _Browser_doc;
7268 } else {
7269 return _Browser_window;
7270 }
7271 }();
7272 return A2(
7273 $elm$core$Task$map,
7274 function (value) {
7275 return _Utils_Tuple2(key, value);
7276 },
7277 A3(
7278 _Browser_on,
7279 actualNode,
7280 name,
7281 function (event) {
7282 return A2(
7283 $elm$core$Platform$sendToSelf,
7284 router,
7285 A2($elm$browser$Browser$Events$Event, key, event));
7286 }));
7287 });
7288var $elm$core$Dict$union = F2(
7289 function (t1, t2) {
7290 return A3($elm$core$Dict$foldl, $elm$core$Dict$insert, t2, t1);
7291 });
7292var $elm$browser$Browser$Events$onEffects = F3(
7293 function (router, subs, state) {
7294 var stepRight = F3(
7295 function (key, sub, _v6) {
7296 var deads = _v6.a;
7297 var lives = _v6.b;
7298 var news = _v6.c;
7299 return _Utils_Tuple3(
7300 deads,
7301 lives,
7302 A2(
7303 $elm$core$List$cons,
7304 A3($elm$browser$Browser$Events$spawn, router, key, sub),
7305 news));
7306 });
7307 var stepLeft = F3(
7308 function (_v4, pid, _v5) {
7309 var deads = _v5.a;
7310 var lives = _v5.b;
7311 var news = _v5.c;
7312 return _Utils_Tuple3(
7313 A2($elm$core$List$cons, pid, deads),
7314 lives,
7315 news);
7316 });
7317 var stepBoth = F4(
7318 function (key, pid, _v2, _v3) {
7319 var deads = _v3.a;
7320 var lives = _v3.b;
7321 var news = _v3.c;
7322 return _Utils_Tuple3(
7323 deads,
7324 A3($elm$core$Dict$insert, key, pid, lives),
7325 news);
7326 });
7327 var newSubs = A2($elm$core$List$map, $elm$browser$Browser$Events$addKey, subs);
7328 var _v0 = A6(
7329 $elm$core$Dict$merge,
7330 stepLeft,
7331 stepBoth,
7332 stepRight,
7333 state.pids,
7334 $elm$core$Dict$fromList(newSubs),
7335 _Utils_Tuple3(_List_Nil, $elm$core$Dict$empty, _List_Nil));
7336 var deadPids = _v0.a;
7337 var livePids = _v0.b;
7338 var makeNewPids = _v0.c;
7339 return A2(
7340 $elm$core$Task$andThen,
7341 function (pids) {
7342 return $elm$core$Task$succeed(
7343 A2(
7344 $elm$browser$Browser$Events$State,
7345 newSubs,
7346 A2(
7347 $elm$core$Dict$union,
7348 livePids,
7349 $elm$core$Dict$fromList(pids))));
7350 },
7351 A2(
7352 $elm$core$Task$andThen,
7353 function (_v1) {
7354 return $elm$core$Task$sequence(makeNewPids);
7355 },
7356 $elm$core$Task$sequence(
7357 A2($elm$core$List$map, $elm$core$Process$kill, deadPids))));
7358 });
7359var $elm$browser$Browser$Events$onSelfMsg = F3(
7360 function (router, _v0, state) {
7361 var key = _v0.key;
7362 var event = _v0.event;
7363 var toMessage = function (_v2) {
7364 var subKey = _v2.a;
7365 var _v3 = _v2.b;
7366 var node = _v3.a;
7367 var name = _v3.b;
7368 var decoder = _v3.c;
7369 return _Utils_eq(subKey, key) ? A2(_Browser_decodeEvent, decoder, event) : $elm$core$Maybe$Nothing;
7370 };
7371 var messages = A2($elm$core$List$filterMap, toMessage, state.subs);
7372 return A2(
7373 $elm$core$Task$andThen,
7374 function (_v1) {
7375 return $elm$core$Task$succeed(state);
7376 },
7377 $elm$core$Task$sequence(
7378 A2(
7379 $elm$core$List$map,
7380 $elm$core$Platform$sendToApp(router),
7381 messages)));
7382 });
7383var $elm$browser$Browser$Events$subMap = F2(
7384 function (func, _v0) {
7385 var node = _v0.a;
7386 var name = _v0.b;
7387 var decoder = _v0.c;
7388 return A3(
7389 $elm$browser$Browser$Events$MySub,
7390 node,
7391 name,
7392 A2($elm$json$Json$Decode$map, func, decoder));
7393 });
7394_Platform_effectManagers['Browser.Events'] = _Platform_createManager($elm$browser$Browser$Events$init, $elm$browser$Browser$Events$onEffects, $elm$browser$Browser$Events$onSelfMsg, 0, $elm$browser$Browser$Events$subMap);
7395var $elm$browser$Browser$Events$subscription = _Platform_leaf('Browser.Events');
7396var $elm$browser$Browser$Events$on = F3(
7397 function (node, name, decoder) {
7398 return $elm$browser$Browser$Events$subscription(
7399 A3($elm$browser$Browser$Events$MySub, node, name, decoder));
7400 });
7401var $elm$browser$Browser$Events$onMouseMove = A2($elm$browser$Browser$Events$on, $elm$browser$Browser$Events$Document, 'mousemove');
7402var $elm$browser$Browser$Events$onMouseUp = A2($elm$browser$Browser$Events$on, $elm$browser$Browser$Events$Document, 'mouseup');
7403var $elm$browser$Browser$Events$Window = {$: 'Window'};
7404var $elm$json$Json$Decode$int = _Json_decodeInt;
7405var $elm$browser$Browser$Events$onResize = function (func) {
7406 return A3(
7407 $elm$browser$Browser$Events$on,
7408 $elm$browser$Browser$Events$Window,
7409 'resize',
7410 A2(
7411 $elm$json$Json$Decode$field,
7412 'target',
7413 A3(
7414 $elm$json$Json$Decode$map2,
7415 func,
7416 A2($elm$json$Json$Decode$field, 'innerWidth', $elm$json$Json$Decode$int),
7417 A2($elm$json$Json$Decode$field, 'innerHeight', $elm$json$Json$Decode$int))));
7418};
7419var $author$project$Main$subscriptions = function (model) {
7420 var interaction = ((!_Utils_eq(model.dragNode, $elm$core$Maybe$Nothing)) || model.isPanning) ? _List_fromArray(
7421 [
7422 $elm$browser$Browser$Events$onMouseMove(
7423 A3(
7424 $elm$json$Json$Decode$map2,
7425 $author$project$Types$InteractionMove,
7426 A2($elm$json$Json$Decode$field, 'movementX', $elm$json$Json$Decode$float),
7427 A2($elm$json$Json$Decode$field, 'movementY', $elm$json$Json$Decode$float)))
7428 ]) : _List_Nil;
7429 var animation = $author$project$Graph$isSimulating(model) ? _List_fromArray(
7430 [
7431 $elm$browser$Browser$Events$onAnimationFrame(
7432 function (_v0) {
7433 return $author$project$Types$Tick;
7434 })
7435 ]) : _List_Nil;
7436 var always = _List_fromArray(
7437 [
7438 $elm$browser$Browser$Events$onMouseUp(
7439 A3(
7440 $elm$json$Json$Decode$map2,
7441 $author$project$Types$InteractionEnd,
7442 A2($elm$json$Json$Decode$field, 'clientX', $elm$json$Json$Decode$float),
7443 A2($elm$json$Json$Decode$field, 'clientY', $elm$json$Json$Decode$float))),
7444 $elm$browser$Browser$Events$onResize(
7445 F2(
7446 function (w, h) {
7447 return A2($author$project$Types$Resize, w, h);
7448 }))
7449 ]);
7450 return $elm$core$Platform$Sub$batch(
7451 _Utils_ap(
7452 interaction,
7453 _Utils_ap(animation, always)));
7454};
7455var $author$project$Types$Company = F3(
7456 function (a, b, c) {
7457 return {$: 'Company', a: a, b: b, c: c};
7458 });
7459var $author$project$Types$NodeClicked = function (a) {
7460 return {$: 'NodeClicked', a: a};
7461};
7462var $author$project$Types$StatusUnknown = {$: 'StatusUnknown'};
7463var $elm$core$Basics$clamp = F3(
7464 function (low, high, number) {
7465 return (_Utils_cmp(number, low) < 0) ? low : ((_Utils_cmp(number, high) > 0) ? high : number);
7466 });
7467var $author$project$Types$StatusActive = {$: 'StatusActive'};
7468var $author$project$Types$StatusInactive = {$: 'StatusInactive'};
7469var $author$project$Main$codeToStatus = function (code) {
7470 if (code.$ === 'Just') {
7471 if (code.a === 2) {
7472 return $author$project$Types$StatusActive;
7473 } else {
7474 return $author$project$Types$StatusInactive;
7475 }
7476 } else {
7477 return $author$project$Types$StatusInactive;
7478 }
7479};
7480var $author$project$Main$httpErrorToString = F2(
7481 function (url, err) {
7482 switch (err.$) {
7483 case 'BadUrl':
7484 var s = err.a;
7485 return 'URL inválida: ' + s;
7486 case 'Timeout':
7487 return 'Tempo esgotado ao buscar ' + url;
7488 case 'NetworkError':
7489 return 'Erro de rede ao buscar ' + (url + ' (o servidor está rodando?)');
7490 case 'BadStatus':
7491 var i = err.a;
7492 return 'Erro do servidor (status ' + ($elm$core$String$fromInt(i) + (') ao buscar ' + url));
7493 default:
7494 var s = err.a;
7495 return 'Resposta inválida de ' + (url + (': ' + s));
7496 }
7497 });
7498var $author$project$Main$markNodeError = F3(
7499 function (id, maybeMsg, model) {
7500 return _Utils_update(
7501 model,
7502 {
7503 nodes: A3(
7504 $elm$core$Dict$update,
7505 id,
7506 $elm$core$Maybe$map(
7507 function (n) {
7508 return _Utils_update(
7509 n,
7510 {error: maybeMsg});
7511 }),
7512 model.nodes)
7513 });
7514 });
7515var $author$project$Main$handleApiError = F5(
7516 function (id, url, _v0, apiErr, model) {
7517 switch (apiErr.$) {
7518 case 'NotFound':
7519 return A3(
7520 $author$project$Main$markNodeError,
7521 id,
7522 $elm$core$Maybe$Just('Não encontrado'),
7523 model);
7524 case 'BadRequest':
7525 var msg = apiErr.a;
7526 var marked = A3(
7527 $author$project$Main$markNodeError,
7528 id,
7529 $elm$core$Maybe$Just(msg),
7530 model);
7531 return A2($elm$core$Dict$member, id, model.nodes) ? marked : _Utils_update(
7532 marked,
7533 {
7534 error: $elm$core$Maybe$Just(msg)
7535 });
7536 default:
7537 var httpErr = apiErr.a;
7538 return _Utils_update(
7539 model,
7540 {
7541 error: $elm$core$Maybe$Just(
7542 A2($author$project$Main$httpErrorToString, url, httpErr))
7543 });
7544 }
7545 });
7546var $elm$core$List$head = function (list) {
7547 if (list.b) {
7548 var x = list.a;
7549 var xs = list.b;
7550 return $elm$core$Maybe$Just(x);
7551 } else {
7552 return $elm$core$Maybe$Nothing;
7553 }
7554};
7555var $elm$core$Set$isEmpty = function (_v0) {
7556 var dict = _v0.a;
7557 return $elm$core$Dict$isEmpty(dict);
7558};
7559var $elm$core$Dict$sizeHelp = F2(
7560 function (n, dict) {
7561 sizeHelp:
7562 while (true) {
7563 if (dict.$ === 'RBEmpty_elm_builtin') {
7564 return n;
7565 } else {
7566 var left = dict.d;
7567 var right = dict.e;
7568 var $temp$n = A2($elm$core$Dict$sizeHelp, n + 1, right),
7569 $temp$dict = left;
7570 n = $temp$n;
7571 dict = $temp$dict;
7572 continue sizeHelp;
7573 }
7574 }
7575 });
7576var $elm$core$Dict$size = function (dict) {
7577 return A2($elm$core$Dict$sizeHelp, 0, dict);
7578};
7579var $author$project$Graph$layout = function (model) {
7580 if (model.isInitialSearch) {
7581 var nodeCount = $elm$core$Dict$size(model.nodes);
7582 var t = A3($elm$core$Basics$clamp, 0.0, 1.0, (nodeCount - 5) / 20);
7583 var manyBody = (-150) + (t * 120);
7584 var linkDistance = 80 - (t * 30);
7585 var collisionRadius = 50 - (t * 30);
7586 return _Utils_update(
7587 model,
7588 {
7589 collisionRadius: collisionRadius,
7590 linkDistance: linkDistance,
7591 manyBody: manyBody,
7592 simulation: A7(
7593 $author$project$Graph$makeSim,
7594 model.width,
7595 model.height,
7596 manyBody,
7597 collisionRadius,
7598 linkDistance,
7599 $elm$core$Dict$keys(model.nodes),
7600 $elm$core$Set$toList(model.edges))
7601 });
7602 } else {
7603 return _Utils_update(
7604 model,
7605 {
7606 simulation: A7(
7607 $author$project$Graph$makeSim,
7608 model.width,
7609 model.height,
7610 model.manyBody,
7611 model.collisionRadius,
7612 model.linkDistance,
7613 $elm$core$Dict$keys(model.nodes),
7614 $elm$core$Set$toList(model.edges))
7615 });
7616 }
7617};
7618var $elm$browser$Browser$Navigation$load = _Browser_load;
7619var $elm$core$String$trim = _String_trim;
7620var $author$project$Format$maskMultiple = function (raw) {
7621 return A2($elm$core$String$contains, ',', raw) ? A2(
7622 $elm$core$String$join,
7623 ', ',
7624 A2(
7625 $elm$core$List$map,
7626 $author$project$Format$mask,
7627 A2(
7628 $elm$core$List$map,
7629 $elm$core$String$trim,
7630 A2($elm$core$String$split, ',', raw)))) : $author$project$Format$mask(raw);
7631};
7632var $elm$core$List$any = F2(
7633 function (isOkay, list) {
7634 any:
7635 while (true) {
7636 if (!list.b) {
7637 return false;
7638 } else {
7639 var x = list.a;
7640 var xs = list.b;
7641 if (isOkay(x)) {
7642 return true;
7643 } else {
7644 var $temp$isOkay = isOkay,
7645 $temp$list = xs;
7646 isOkay = $temp$isOkay;
7647 list = $temp$list;
7648 continue any;
7649 }
7650 }
7651 }
7652 });
7653var $elm$core$List$member = F2(
7654 function (x, xs) {
7655 return A2(
7656 $elm$core$List$any,
7657 function (a) {
7658 return _Utils_eq(a, x);
7659 },
7660 xs);
7661 });
7662var $author$project$Types$Person = F2(
7663 function (a, b) {
7664 return {$: 'Person', a: a, b: b};
7665 });
7666var $author$project$Types$StatusLoading = {$: 'StatusLoading'};
7667var $elm$core$Dict$filter = F2(
7668 function (isGood, dict) {
7669 return A3(
7670 $elm$core$Dict$foldl,
7671 F3(
7672 function (k, v, d) {
7673 return A2(isGood, k, v) ? A3($elm$core$Dict$insert, k, v, d) : d;
7674 }),
7675 $elm$core$Dict$empty,
7676 dict);
7677 });
7678var $elm$core$Set$filter = F2(
7679 function (isGood, _v0) {
7680 var dict = _v0.a;
7681 return $elm$core$Set$Set_elm_builtin(
7682 A2(
7683 $elm$core$Dict$filter,
7684 F2(
7685 function (key, _v1) {
7686 return isGood(key);
7687 }),
7688 dict));
7689 });
7690var $elm$core$Set$foldl = F3(
7691 function (func, initialState, _v0) {
7692 var dict = _v0.a;
7693 return A3(
7694 $elm$core$Dict$foldl,
7695 F3(
7696 function (key, _v1, state) {
7697 return A2(func, key, state);
7698 }),
7699 initialState,
7700 dict);
7701 });
7702var $author$project$Main$maxDepth = 8;
7703var $author$project$Main$softNodeLimit = 32;
7704var $author$project$Main$enqueueChildren = F3(
7705 function (parentId, depth, model) {
7706 if ((_Utils_cmp(depth, $author$project$Main$maxDepth) > -1) || (_Utils_cmp(
7707 $elm$core$Dict$size(model.nodes),
7708 $author$project$Main$softNodeLimit) > -1)) {
7709 return _List_Nil;
7710 } else {
7711 var childEdges = A2(
7712 $elm$core$Set$filter,
7713 function (_v3) {
7714 var s = _v3.a;
7715 var t = _v3.b;
7716 return _Utils_eq(s, parentId) || _Utils_eq(t, parentId);
7717 },
7718 model.edges);
7719 var childIds = A3(
7720 $elm$core$Set$foldl,
7721 F2(
7722 function (_v2, acc) {
7723 var s = _v2.a;
7724 var t = _v2.b;
7725 return _Utils_eq(s, parentId) ? A2($elm$core$Set$insert, t, acc) : A2($elm$core$Set$insert, s, acc);
7726 }),
7727 $elm$core$Set$empty,
7728 childEdges);
7729 var childDepth = depth + 1;
7730 return A3(
7731 $elm$core$Set$foldl,
7732 F2(
7733 function (childId, acc) {
7734 var _v0 = A2($elm$core$Dict$get, childId, model.nodes);
7735 if (_v0.$ === 'Just') {
7736 var node = _v0.a;
7737 var isCompany = function () {
7738 var _v1 = node.entity;
7739 if (_v1.$ === 'Company') {
7740 return true;
7741 } else {
7742 return false;
7743 }
7744 }();
7745 return _Utils_ap(
7746 A3($author$project$Main$queriesFor, childId, isCompany, childDepth),
7747 acc);
7748 } else {
7749 return acc;
7750 }
7751 }),
7752 _List_Nil,
7753 childIds);
7754 }
7755 });
7756var $author$project$Types$GotCompanyName = F3(
7757 function (a, b, c) {
7758 return {$: 'GotCompanyName', a: a, b: b, c: c};
7759 });
7760var $author$project$Types$CompanyInfo = F2(
7761 function (name, situacaoCadastral) {
7762 return {name: name, situacaoCadastral: situacaoCadastral};
7763 });
7764var $author$project$Api$companyInfoDecoder = A3(
7765 $elm$json$Json$Decode$map2,
7766 $author$project$Types$CompanyInfo,
7767 A2($elm$json$Json$Decode$field, 'razao_social', $elm$json$Json$Decode$string),
7768 $elm$json$Json$Decode$maybe(
7769 A2($elm$json$Json$Decode$field, 'situacao_cadastral', $elm$json$Json$Decode$int)));
7770var $author$project$Api$fetchCompanyName = F2(
7771 function (jsonApi, cnpj) {
7772 var url = (A2($elm$core$String$right, 1, jsonApi) === '/') ? _Utils_ap(jsonApi, cnpj) : (jsonApi + ('/' + cnpj));
7773 return $elm$http$Http$get(
7774 {
7775 expect: A2(
7776 $elm$http$Http$expectStringResponse,
7777 A2($author$project$Types$GotCompanyName, cnpj, url),
7778 function (response) {
7779 switch (response.$) {
7780 case 'BadStatus_':
7781 var meta = response.a;
7782 return $elm$core$Result$Err(
7783 $elm$http$Http$BadStatus(meta.statusCode));
7784 case 'GoodStatus_':
7785 var body = response.b;
7786 var _v1 = A2($elm$json$Json$Decode$decodeString, $author$project$Api$companyInfoDecoder, body);
7787 if (_v1.$ === 'Ok') {
7788 var info = _v1.a;
7789 return $elm$core$Result$Ok(info);
7790 } else {
7791 return $elm$core$Result$Err(
7792 $elm$http$Http$BadBody('Could not parse company info'));
7793 }
7794 case 'BadUrl_':
7795 var url_ = response.a;
7796 return $elm$core$Result$Err(
7797 $elm$http$Http$BadUrl(url_));
7798 case 'Timeout_':
7799 return $elm$core$Result$Err($elm$http$Http$Timeout);
7800 default:
7801 return $elm$core$Result$Err($elm$http$Http$NetworkError);
7802 }
7803 }),
7804 url: url
7805 });
7806 });
7807var $author$project$Main$isCnpj = function (s) {
7808 return $elm$core$String$length(
7809 A2($elm$core$String$filter, $elm$core$Char$isAlphaNum, s)) === 14;
7810};
7811var $elm$core$Basics$abs = function (n) {
7812 return (n < 0) ? (-n) : n;
7813};
7814var $elm$core$Basics$cos = _Basics_cos;
7815var $elm$core$String$foldl = _String_foldl;
7816var $elm$core$Basics$modBy = _Basics_modBy;
7817var $elm$core$Basics$sin = _Basics_sin;
7818var $author$project$Main$nodeOffset = F3(
7819 function (id, w, h) {
7820 var hash = A3(
7821 $elm$core$String$foldl,
7822 F2(
7823 function (c, acc) {
7824 return (acc * 31) + $elm$core$Char$toCode(c);
7825 }),
7826 0,
7827 id);
7828 var jitter = A2(
7829 $elm$core$Basics$modBy,
7830 80,
7831 $elm$core$Basics$abs(hash)) - 40;
7832 var baseRadius = A2($elm$core$Basics$min, w, h) / 3;
7833 var angle = hash * 0.6180339887498949;
7834 return _Utils_Tuple2(
7835 (w / 2) + ($elm$core$Basics$cos(angle) * (baseRadius + jitter)),
7836 (h / 2) + ($elm$core$Basics$sin(angle) * (baseRadius + jitter)));
7837 });
7838var $author$project$Main$spawnNear = F3(
7839 function (parentId, childId, model) {
7840 var _v0 = A2($elm$core$Dict$get, parentId, model.nodes);
7841 if (_v0.$ === 'Just') {
7842 var parent = _v0.a;
7843 var hash = A3(
7844 $elm$core$String$foldl,
7845 F2(
7846 function (c, acc) {
7847 return (acc * 31) + $elm$core$Char$toCode(c);
7848 }),
7849 0,
7850 childId);
7851 var radius = 50 + A2(
7852 $elm$core$Basics$modBy,
7853 30,
7854 $elm$core$Basics$abs(hash));
7855 var angle = hash * 0.6180339887498949;
7856 return _Utils_Tuple2(
7857 parent.x + ($elm$core$Basics$cos(angle) * radius),
7858 parent.y + ($elm$core$Basics$sin(angle) * radius));
7859 } else {
7860 return A3($author$project$Main$nodeOffset, childId, model.width, model.height);
7861 }
7862 });
7863var $author$project$Main$processResponse = F4(
7864 function (queriedId, relations, depth, model) {
7865 var processRelation = F2(
7866 function (rel, _v6) {
7867 var accModel = _v6.a;
7868 var accCmds = _v6.b;
7869 var partnerName = A2($elm$core$Maybe$withDefault, rel.partnerId, rel.partnerName);
7870 var partnerCmd = ($author$project$Main$isCnpj(rel.partnerId) && (!A2($elm$core$Dict$member, rel.partnerId, accModel.nodes))) ? A2($author$project$Api$fetchCompanyName, accModel.jsonApi, rel.partnerId) : $elm$core$Platform$Cmd$none;
7871 var edge = _Utils_Tuple2(rel.cnpj, rel.partnerId);
7872 var updatedEdges = A2($elm$core$Set$insert, edge, accModel.edges);
7873 var companyCmd = ($author$project$Main$isCnpj(rel.cnpj) && (!A2($elm$core$Dict$member, rel.cnpj, accModel.nodes))) ? A2($author$project$Api$fetchCompanyName, accModel.jsonApi, rel.cnpj) : $elm$core$Platform$Cmd$none;
7874 var _v1 = A2($elm$core$Dict$member, rel.partnerId, accModel.nodes) ? _Utils_Tuple2(0, 0) : A3($author$project$Main$spawnNear, rel.cnpj, rel.partnerId, accModel);
7875 var p_nx = _v1.a;
7876 var p_ny = _v1.b;
7877 var partnerNode = function () {
7878 var _v4 = A2($elm$core$Dict$get, rel.partnerId, accModel.nodes);
7879 if (_v4.$ === 'Just') {
7880 var existing = _v4.a;
7881 var _v5 = existing.entity;
7882 if (_v5.$ === 'Person') {
7883 return _Utils_update(
7884 existing,
7885 {
7886 entity: A2($author$project$Types$Person, partnerName, rel.partnerCpf)
7887 });
7888 } else {
7889 return existing;
7890 }
7891 } else {
7892 var entity = $author$project$Main$isCnpj(rel.partnerId) ? A3($author$project$Types$Company, partnerName, rel.partnerId, $author$project$Types$StatusLoading) : A2($author$project$Types$Person, partnerName, rel.partnerCpf);
7893 return {depth: depth + 1, entity: entity, error: $elm$core$Maybe$Nothing, id: rel.partnerId, vx: 0, vy: 0, x: p_nx, y: p_ny};
7894 }
7895 }();
7896 var _v2 = A2($elm$core$Dict$member, rel.cnpj, accModel.nodes) ? _Utils_Tuple2(0, 0) : A3($author$project$Main$spawnNear, rel.partnerId, rel.cnpj, accModel);
7897 var c_nx = _v2.a;
7898 var c_ny = _v2.b;
7899 var companyNode = function () {
7900 var _v3 = A2($elm$core$Dict$get, rel.cnpj, accModel.nodes);
7901 if (_v3.$ === 'Just') {
7902 var existing = _v3.a;
7903 return _Utils_update(
7904 existing,
7905 {
7906 entity: A3($author$project$Types$Company, rel.razaoSocial, rel.cnpj, $author$project$Types$StatusLoading)
7907 });
7908 } else {
7909 return {
7910 depth: depth + 1,
7911 entity: A3($author$project$Types$Company, rel.razaoSocial, rel.cnpj, $author$project$Types$StatusLoading),
7912 error: $elm$core$Maybe$Nothing,
7913 id: rel.cnpj,
7914 vx: 0,
7915 vy: 0,
7916 x: c_nx,
7917 y: c_ny
7918 };
7919 }
7920 }();
7921 var updatedNodes = A3(
7922 $elm$core$Dict$insert,
7923 rel.partnerId,
7924 partnerNode,
7925 A3($elm$core$Dict$insert, rel.cnpj, companyNode, accModel.nodes));
7926 return _Utils_Tuple2(
7927 _Utils_update(
7928 accModel,
7929 {edges: updatedEdges, nodes: updatedNodes}),
7930 $elm$core$Platform$Cmd$batch(
7931 _List_fromArray(
7932 [accCmds, companyCmd, partnerCmd])));
7933 });
7934 var _v0 = A3(
7935 $elm$core$List$foldl,
7936 processRelation,
7937 _Utils_Tuple2(model, $elm$core$Platform$Cmd$none),
7938 relations);
7939 var modelWithNodes = _v0.a;
7940 var cmds = _v0.b;
7941 var finalNodes = function () {
7942 var updateDepth = F2(
7943 function (id, dict) {
7944 return A3(
7945 $elm$core$Dict$update,
7946 id,
7947 $elm$core$Maybe$map(
7948 function (n) {
7949 return (_Utils_cmp(n.depth, depth) > 0) ? _Utils_update(
7950 n,
7951 {depth: depth}) : n;
7952 }),
7953 dict);
7954 });
7955 var idsToUpdate = A2($elm$core$String$contains, ';', queriedId) ? A2($elm$core$String$split, ';', queriedId) : _List_fromArray(
7956 [queriedId]);
7957 return A3($elm$core$List$foldl, updateDepth, modelWithNodes.nodes, idsToUpdate);
7958 }();
7959 return _Utils_Tuple3(
7960 _Utils_update(
7961 modelWithNodes,
7962 {nodes: finalNodes}),
7963 A3($author$project$Main$enqueueChildren, queriedId, depth, modelWithNodes),
7964 cmds);
7965 });
7966var $elm$browser$Browser$Navigation$pushUrl = _Browser_pushUrl;
7967var $elm$core$Set$remove = F2(
7968 function (key, _v0) {
7969 var dict = _v0.a;
7970 return $elm$core$Set$Set_elm_builtin(
7971 A2($elm$core$Dict$remove, key, dict));
7972 });
7973var $elm$core$Basics$sqrt = _Basics_sqrt;
7974var $gampleman$elm_visualization$Force$Jiggle$jiggle = function (v) {
7975 return (!v) ? 1.0e-6 : v;
7976};
7977var $elm$core$Dict$map = F2(
7978 function (func, dict) {
7979 if (dict.$ === 'RBEmpty_elm_builtin') {
7980 return $elm$core$Dict$RBEmpty_elm_builtin;
7981 } else {
7982 var color = dict.a;
7983 var key = dict.b;
7984 var value = dict.c;
7985 var left = dict.d;
7986 var right = dict.e;
7987 return A5(
7988 $elm$core$Dict$RBNode_elm_builtin,
7989 color,
7990 key,
7991 A2(func, key, value),
7992 A2($elm$core$Dict$map, func, left),
7993 A2($elm$core$Dict$map, func, right));
7994 }
7995 });
7996var $gampleman$elm_visualization$Force$nTimes = F3(
7997 function (fn, times, input) {
7998 nTimes:
7999 while (true) {
8000 if (times <= 0) {
8001 return input;
8002 } else {
8003 var $temp$fn = fn,
8004 $temp$times = times - 1,
8005 $temp$input = fn(input);
8006 fn = $temp$fn;
8007 times = $temp$times;
8008 input = $temp$input;
8009 continue nTimes;
8010 }
8011 }
8012 });
8013var $elm$core$Bitwise$and = _Bitwise_and;
8014var $elm$core$Bitwise$shiftRightZfBy = _Bitwise_shiftRightZfBy;
8015var $elm$core$Array$bitMask = 4294967295 >>> (32 - $elm$core$Array$shiftStep);
8016var $elm$core$Elm$JsArray$unsafeGet = _JsArray_unsafeGet;
8017var $elm$core$Array$getHelp = F3(
8018 function (shift, index, tree) {
8019 getHelp:
8020 while (true) {
8021 var pos = $elm$core$Array$bitMask & (index >>> shift);
8022 var _v0 = A2($elm$core$Elm$JsArray$unsafeGet, pos, tree);
8023 if (_v0.$ === 'SubTree') {
8024 var subTree = _v0.a;
8025 var $temp$shift = shift - $elm$core$Array$shiftStep,
8026 $temp$index = index,
8027 $temp$tree = subTree;
8028 shift = $temp$shift;
8029 index = $temp$index;
8030 tree = $temp$tree;
8031 continue getHelp;
8032 } else {
8033 var values = _v0.a;
8034 return A2($elm$core$Elm$JsArray$unsafeGet, $elm$core$Array$bitMask & index, values);
8035 }
8036 }
8037 });
8038var $elm$core$Bitwise$shiftLeftBy = _Bitwise_shiftLeftBy;
8039var $elm$core$Array$tailIndex = function (len) {
8040 return (len >>> 5) << 5;
8041};
8042var $elm$core$Array$get = F2(
8043 function (index, _v0) {
8044 var len = _v0.a;
8045 var startShift = _v0.b;
8046 var tree = _v0.c;
8047 var tail = _v0.d;
8048 return ((index < 0) || (_Utils_cmp(index, len) > -1)) ? $elm$core$Maybe$Nothing : ((_Utils_cmp(
8049 index,
8050 $elm$core$Array$tailIndex(len)) > -1) ? $elm$core$Maybe$Just(
8051 A2($elm$core$Elm$JsArray$unsafeGet, $elm$core$Array$bitMask & index, tail)) : $elm$core$Maybe$Just(
8052 A3($elm$core$Array$getHelp, startShift, index, tree)));
8053 });
8054var $elm$core$Elm$JsArray$unsafeSet = _JsArray_unsafeSet;
8055var $elm$core$Array$setHelp = F4(
8056 function (shift, index, value, tree) {
8057 var pos = $elm$core$Array$bitMask & (index >>> shift);
8058 var _v0 = A2($elm$core$Elm$JsArray$unsafeGet, pos, tree);
8059 if (_v0.$ === 'SubTree') {
8060 var subTree = _v0.a;
8061 var newSub = A4($elm$core$Array$setHelp, shift - $elm$core$Array$shiftStep, index, value, subTree);
8062 return A3(
8063 $elm$core$Elm$JsArray$unsafeSet,
8064 pos,
8065 $elm$core$Array$SubTree(newSub),
8066 tree);
8067 } else {
8068 var values = _v0.a;
8069 var newLeaf = A3($elm$core$Elm$JsArray$unsafeSet, $elm$core$Array$bitMask & index, value, values);
8070 return A3(
8071 $elm$core$Elm$JsArray$unsafeSet,
8072 pos,
8073 $elm$core$Array$Leaf(newLeaf),
8074 tree);
8075 }
8076 });
8077var $elm$core$Array$set = F3(
8078 function (index, value, array) {
8079 var len = array.a;
8080 var startShift = array.b;
8081 var tree = array.c;
8082 var tail = array.d;
8083 return ((index < 0) || (_Utils_cmp(index, len) > -1)) ? array : ((_Utils_cmp(
8084 index,
8085 $elm$core$Array$tailIndex(len)) > -1) ? A4(
8086 $elm$core$Array$Array_elm_builtin,
8087 len,
8088 startShift,
8089 tree,
8090 A3($elm$core$Elm$JsArray$unsafeSet, $elm$core$Array$bitMask & index, value, tail)) : A4(
8091 $elm$core$Array$Array_elm_builtin,
8092 len,
8093 startShift,
8094 A4($elm$core$Array$setHelp, startShift, index, value, tree),
8095 tail));
8096 });
8097var $gampleman$elm_visualization$Force$Collision$arrayUpdate = F3(
8098 function (index, fn, arr) {
8099 var _v0 = A2($elm$core$Array$get, index, arr);
8100 if (_v0.$ === 'Just') {
8101 var v = _v0.a;
8102 return A3(
8103 $elm$core$Array$set,
8104 index,
8105 fn(v),
8106 arr);
8107 } else {
8108 return arr;
8109 }
8110 });
8111var $ianmackenzie$elm_geometry$Geometry$Types$Vector2d = function (a) {
8112 return {$: 'Vector2d', a: a};
8113};
8114var $ianmackenzie$elm_geometry$Vector2d$at = F2(
8115 function (_v0, _v1) {
8116 var rate = _v0.a;
8117 var v = _v1.a;
8118 return $ianmackenzie$elm_geometry$Geometry$Types$Vector2d(
8119 {x: rate * v.x, y: rate * v.y});
8120 });
8121var $ianmackenzie$elm_geometry$Circle2d$centerPoint = function (_v0) {
8122 var properties = _v0.a;
8123 return properties.centerPoint;
8124};
8125var $ianmackenzie$elm_geometry$Geometry$Types$BoundingBox2d = function (a) {
8126 return {$: 'BoundingBox2d', a: a};
8127};
8128var $ianmackenzie$elm_geometry$BoundingBox2d$fromExtrema = function (given) {
8129 var _v0 = given.maxY;
8130 var y2 = _v0.a;
8131 var _v1 = given.minY;
8132 var y1 = _v1.a;
8133 var _v2 = given.maxX;
8134 var x2 = _v2.a;
8135 var _v3 = given.minX;
8136 var x1 = _v3.a;
8137 return $ianmackenzie$elm_geometry$Geometry$Types$BoundingBox2d(
8138 {
8139 maxX: A2($elm$core$Basics$max, x1, x2),
8140 maxY: A2($elm$core$Basics$max, y1, y2),
8141 minX: A2($elm$core$Basics$min, x1, x2),
8142 minY: A2($elm$core$Basics$min, y1, y2)
8143 });
8144};
8145var $ianmackenzie$elm_units$Quantity$Quantity = function (a) {
8146 return {$: 'Quantity', a: a};
8147};
8148var $ianmackenzie$elm_units$Quantity$minus = F2(
8149 function (_v0, _v1) {
8150 var y = _v0.a;
8151 var x = _v1.a;
8152 return $ianmackenzie$elm_units$Quantity$Quantity(x - y);
8153 });
8154var $ianmackenzie$elm_units$Quantity$plus = F2(
8155 function (_v0, _v1) {
8156 var y = _v0.a;
8157 var x = _v1.a;
8158 return $ianmackenzie$elm_units$Quantity$Quantity(x + y);
8159 });
8160var $ianmackenzie$elm_geometry$Circle2d$radius = function (_v0) {
8161 var properties = _v0.a;
8162 return properties.radius;
8163};
8164var $ianmackenzie$elm_geometry$Point2d$xCoordinate = function (_v0) {
8165 var p = _v0.a;
8166 return $ianmackenzie$elm_units$Quantity$Quantity(p.x);
8167};
8168var $ianmackenzie$elm_geometry$Point2d$yCoordinate = function (_v0) {
8169 var p = _v0.a;
8170 return $ianmackenzie$elm_units$Quantity$Quantity(p.y);
8171};
8172var $ianmackenzie$elm_geometry$Circle2d$boundingBox = function (circle) {
8173 return $ianmackenzie$elm_geometry$BoundingBox2d$fromExtrema(
8174 {
8175 maxX: A2(
8176 $ianmackenzie$elm_units$Quantity$plus,
8177 $ianmackenzie$elm_geometry$Circle2d$radius(circle),
8178 $ianmackenzie$elm_geometry$Point2d$xCoordinate(
8179 $ianmackenzie$elm_geometry$Circle2d$centerPoint(circle))),
8180 maxY: A2(
8181 $ianmackenzie$elm_units$Quantity$plus,
8182 $ianmackenzie$elm_geometry$Circle2d$radius(circle),
8183 $ianmackenzie$elm_geometry$Point2d$yCoordinate(
8184 $ianmackenzie$elm_geometry$Circle2d$centerPoint(circle))),
8185 minX: A2(
8186 $ianmackenzie$elm_units$Quantity$minus,
8187 $ianmackenzie$elm_geometry$Circle2d$radius(circle),
8188 $ianmackenzie$elm_geometry$Point2d$xCoordinate(
8189 $ianmackenzie$elm_geometry$Circle2d$centerPoint(circle))),
8190 minY: A2(
8191 $ianmackenzie$elm_units$Quantity$minus,
8192 $ianmackenzie$elm_geometry$Circle2d$radius(circle),
8193 $ianmackenzie$elm_geometry$Point2d$yCoordinate(
8194 $ianmackenzie$elm_geometry$Circle2d$centerPoint(circle)))
8195 });
8196};
8197var $ianmackenzie$elm_geometry$Vector2d$from = F2(
8198 function (_v0, _v1) {
8199 var p1 = _v0.a;
8200 var p2 = _v1.a;
8201 return $ianmackenzie$elm_geometry$Geometry$Types$Vector2d(
8202 {x: p2.x - p1.x, y: p2.y - p1.y});
8203 });
8204var $ianmackenzie$elm_geometry$Vector2d$unsafe = function (givenComponents) {
8205 return $ianmackenzie$elm_geometry$Geometry$Types$Vector2d(givenComponents);
8206};
8207var $ianmackenzie$elm_geometry$Vector2d$unwrap = function (_v0) {
8208 var vectorComponents = _v0.a;
8209 return vectorComponents;
8210};
8211var $gampleman$elm_visualization$Force$Jiggle$jiggleVector = function (vec) {
8212 var _v0 = $ianmackenzie$elm_geometry$Vector2d$unwrap(vec);
8213 var x = _v0.x;
8214 var y = _v0.y;
8215 return $ianmackenzie$elm_geometry$Vector2d$unsafe(
8216 {
8217 x: $gampleman$elm_visualization$Force$Jiggle$jiggle(x),
8218 y: $gampleman$elm_visualization$Force$Jiggle$jiggle(y)
8219 });
8220};
8221var $ianmackenzie$elm_units$Quantity$zero = $ianmackenzie$elm_units$Quantity$Quantity(0);
8222var $ianmackenzie$elm_geometry$Vector2d$length = function (_v0) {
8223 var v = _v0.a;
8224 var largestComponent = A2(
8225 $elm$core$Basics$max,
8226 $elm$core$Basics$abs(v.x),
8227 $elm$core$Basics$abs(v.y));
8228 if (!largestComponent) {
8229 return $ianmackenzie$elm_units$Quantity$zero;
8230 } else {
8231 var scaledY = v.y / largestComponent;
8232 var scaledX = v.x / largestComponent;
8233 var scaledLength = $elm$core$Basics$sqrt((scaledX * scaledX) + (scaledY * scaledY));
8234 return $ianmackenzie$elm_units$Quantity$Quantity(scaledLength * largestComponent);
8235 }
8236};
8237var $ianmackenzie$elm_units$Quantity$lessThan = F2(
8238 function (_v0, _v1) {
8239 var y = _v0.a;
8240 var x = _v1.a;
8241 return _Utils_cmp(x, y) < 0;
8242 });
8243var $ianmackenzie$elm_units_prefixed$Units$Quantity$lessThan = $ianmackenzie$elm_units$Quantity$lessThan;
8244var $ianmackenzie$elm_units_prefixed$Units$Quantity$minus = $ianmackenzie$elm_units$Quantity$minus;
8245var $ianmackenzie$elm_geometry$Vector2d$minus = F2(
8246 function (_v0, _v1) {
8247 var v2 = _v0.a;
8248 var v1 = _v1.a;
8249 return $ianmackenzie$elm_geometry$Geometry$Types$Vector2d(
8250 {x: v1.x - v2.x, y: v1.y - v2.y});
8251 });
8252var $ianmackenzie$elm_units$Quantity$multiplyBy = F2(
8253 function (scale, _v0) {
8254 var value = _v0.a;
8255 return $ianmackenzie$elm_units$Quantity$Quantity(scale * value);
8256 });
8257var $ianmackenzie$elm_units_prefixed$Units$Quantity$multiplyBy = $ianmackenzie$elm_units$Quantity$multiplyBy;
8258var $ianmackenzie$elm_units$Quantity$per = F2(
8259 function (_v0, _v1) {
8260 var independentValue = _v0.a;
8261 var dependentValue = _v1.a;
8262 return $ianmackenzie$elm_units$Quantity$Quantity(dependentValue / independentValue);
8263 });
8264var $ianmackenzie$elm_units_prefixed$Units$Quantity$per = $ianmackenzie$elm_units$Quantity$per;
8265var $ianmackenzie$elm_units_prefixed$Units$Quantity$plus = $ianmackenzie$elm_units$Quantity$plus;
8266var $ianmackenzie$elm_geometry$Vector2d$plus = F2(
8267 function (_v0, _v1) {
8268 var v2 = _v0.a;
8269 var v1 = _v1.a;
8270 return $ianmackenzie$elm_geometry$Geometry$Types$Vector2d(
8271 {x: v1.x + v2.x, y: v1.y + v2.y});
8272 });
8273var $ianmackenzie$elm_units$Quantity$ratio = F2(
8274 function (_v0, _v1) {
8275 var x = _v0.a;
8276 var y = _v1.a;
8277 return x / y;
8278 });
8279var $ianmackenzie$elm_units_prefixed$Units$Quantity$ratio = $ianmackenzie$elm_units$Quantity$ratio;
8280var $ianmackenzie$elm_geometry$Vector2d$scaleBy = F2(
8281 function (k, _v0) {
8282 var v = _v0.a;
8283 return $ianmackenzie$elm_geometry$Geometry$Types$Vector2d(
8284 {x: k * v.x, y: k * v.y});
8285 });
8286var $ianmackenzie$elm_geometry$BoundingBox2d$separatedByAtLeast = F3(
8287 function (tolerance, firstBox, secondBox) {
8288 var _v0 = tolerance;
8289 var dGiven = _v0.a;
8290 var d = A2($elm$core$Basics$max, dGiven, 0);
8291 var _v1 = secondBox;
8292 var b2 = _v1.a;
8293 var _v2 = firstBox;
8294 var b1 = _v2.a;
8295 var xSeparation = A2($elm$core$Basics$max, b1.minX, b2.minX) - A2($elm$core$Basics$min, b1.maxX, b2.maxX);
8296 var ySeparation = A2($elm$core$Basics$max, b1.minY, b2.minY) - A2($elm$core$Basics$min, b1.maxY, b2.maxY);
8297 return ((xSeparation > 0) && (ySeparation > 0)) ? (_Utils_cmp((xSeparation * xSeparation) + (ySeparation * ySeparation), d * d) > -1) : ((xSeparation > 0) ? (_Utils_cmp(xSeparation, d) > -1) : ((ySeparation > 0) ? (_Utils_cmp(ySeparation, d) > -1) : (((!xSeparation) && (!ySeparation)) ? (!d) : false)));
8298 });
8299var $ianmackenzie$elm_units$Quantity$squared = function (_v0) {
8300 var value = _v0.a;
8301 return $ianmackenzie$elm_units$Quantity$Quantity(value * value);
8302};
8303var $ianmackenzie$elm_units_prefixed$Units$Quantity$squared = $ianmackenzie$elm_units$Quantity$squared;
8304var $ianmackenzie$elm_geometry$Geometry$Types$Point2d = function (a) {
8305 return {$: 'Point2d', a: a};
8306};
8307var $ianmackenzie$elm_geometry$Point2d$translateBy = F2(
8308 function (_v0, _v1) {
8309 var v = _v0.a;
8310 var p = _v1.a;
8311 return $ianmackenzie$elm_geometry$Geometry$Types$Point2d(
8312 {x: p.x + v.x, y: p.y + v.y});
8313 });
8314var $gampleman$elm_visualization$Force$Collision$updateVelocity = F2(
8315 function (fn, vert) {
8316 return _Utils_update(
8317 vert,
8318 {
8319 velocity: fn(vert.velocity)
8320 });
8321 });
8322var $gampleman$elm_visualization$Force$Collision$applyForce = F4(
8323 function (strength, qtree, velocities, node) {
8324 applyForce:
8325 while (true) {
8326 switch (qtree.$) {
8327 case 'Empty':
8328 return velocities;
8329 case 'Leaf':
8330 var leaf = qtree.a;
8331 var _v1 = leaf.children;
8332 var head = _v1.a;
8333 var tail = _v1.b;
8334 return A3(
8335 $elm$core$List$foldl,
8336 F2(
8337 function (vertex, velos) {
8338 if (_Utils_cmp(vertex.index, node.index) > 0) {
8339 var rj = $ianmackenzie$elm_geometry$Circle2d$radius(vertex.circle);
8340 var ri = $ianmackenzie$elm_geometry$Circle2d$radius(node.circle);
8341 var r = A2($ianmackenzie$elm_units_prefixed$Units$Quantity$plus, rj, ri);
8342 var nodeNextCenterPoint = A2(
8343 $ianmackenzie$elm_geometry$Point2d$translateBy,
8344 node.velocity,
8345 $ianmackenzie$elm_geometry$Circle2d$centerPoint(node.circle));
8346 var xy = $gampleman$elm_visualization$Force$Jiggle$jiggleVector(
8347 A2(
8348 $ianmackenzie$elm_geometry$Vector2d$from,
8349 $ianmackenzie$elm_geometry$Circle2d$centerPoint(vertex.circle),
8350 nodeNextCenterPoint));
8351 var l = $ianmackenzie$elm_geometry$Vector2d$length(xy);
8352 if (A2($ianmackenzie$elm_units_prefixed$Units$Quantity$lessThan, r, l)) {
8353 var rp = A2(
8354 $ianmackenzie$elm_units_prefixed$Units$Quantity$ratio,
8355 $ianmackenzie$elm_units_prefixed$Units$Quantity$squared(rj),
8356 A2(
8357 $ianmackenzie$elm_units_prefixed$Units$Quantity$plus,
8358 $ianmackenzie$elm_units_prefixed$Units$Quantity$squared(rj),
8359 $ianmackenzie$elm_units_prefixed$Units$Quantity$squared(ri)));
8360 var lp = A2(
8361 $ianmackenzie$elm_units_prefixed$Units$Quantity$multiplyBy,
8362 strength,
8363 A2(
8364 $ianmackenzie$elm_units_prefixed$Units$Quantity$per,
8365 l,
8366 A2($ianmackenzie$elm_units_prefixed$Units$Quantity$minus, l, r)));
8367 var repelantVector = A2($ianmackenzie$elm_geometry$Vector2d$at, lp, xy);
8368 return A3(
8369 $gampleman$elm_visualization$Force$Collision$arrayUpdate,
8370 vertex.index,
8371 $gampleman$elm_visualization$Force$Collision$updateVelocity(
8372 $ianmackenzie$elm_geometry$Vector2d$minus(
8373 A2($ianmackenzie$elm_geometry$Vector2d$scaleBy, 1 - rp, repelantVector))),
8374 A3(
8375 $gampleman$elm_visualization$Force$Collision$arrayUpdate,
8376 node.index,
8377 $gampleman$elm_visualization$Force$Collision$updateVelocity(
8378 $ianmackenzie$elm_geometry$Vector2d$plus(
8379 A2($ianmackenzie$elm_geometry$Vector2d$scaleBy, rp, repelantVector))),
8380 velos));
8381 } else {
8382 return velos;
8383 }
8384 } else {
8385 return velos;
8386 }
8387 }),
8388 velocities,
8389 A2($elm$core$List$cons, head, tail));
8390 default:
8391 var box = qtree.a;
8392 if (A3(
8393 $ianmackenzie$elm_geometry$BoundingBox2d$separatedByAtLeast,
8394 box.aggregate,
8395 box.boundingBox,
8396 $ianmackenzie$elm_geometry$Circle2d$boundingBox(node.circle))) {
8397 return velocities;
8398 } else {
8399 var $temp$strength = strength,
8400 $temp$qtree = box.se,
8401 $temp$velocities = A4(
8402 $gampleman$elm_visualization$Force$Collision$applyForce,
8403 strength,
8404 box.sw,
8405 A4(
8406 $gampleman$elm_visualization$Force$Collision$applyForce,
8407 strength,
8408 box.ne,
8409 A4($gampleman$elm_visualization$Force$Collision$applyForce, strength, box.nw, velocities, node),
8410 node),
8411 node),
8412 $temp$node = node;
8413 strength = $temp$strength;
8414 qtree = $temp$qtree;
8415 velocities = $temp$velocities;
8416 node = $temp$node;
8417 continue applyForce;
8418 }
8419 }
8420 }
8421 });
8422var $ianmackenzie$elm_units$Quantity$max = F2(
8423 function (_v0, _v1) {
8424 var x = _v0.a;
8425 var y = _v1.a;
8426 return $ianmackenzie$elm_units$Quantity$Quantity(
8427 A2($elm$core$Basics$max, x, y));
8428 });
8429var $ianmackenzie$elm_units_prefixed$Units$Quantity$max = $ianmackenzie$elm_units$Quantity$max;
8430var $ianmackenzie$elm_units$Quantity$maximum = function (quantities) {
8431 if (!quantities.b) {
8432 return $elm$core$Maybe$Nothing;
8433 } else {
8434 var first = quantities.a;
8435 var rest = quantities.b;
8436 return $elm$core$Maybe$Just(
8437 A3($elm$core$List$foldl, $ianmackenzie$elm_units$Quantity$max, first, rest));
8438 }
8439};
8440var $ianmackenzie$elm_units_prefixed$Units$Quantity$maximum = $ianmackenzie$elm_units$Quantity$maximum;
8441var $gampleman$elm_visualization$Force$Collision$nonEmptyMaximum = F2(
8442 function (head, tail) {
8443 return A2(
8444 $ianmackenzie$elm_units_prefixed$Units$Quantity$max,
8445 head,
8446 A2(
8447 $elm$core$Maybe$withDefault,
8448 head,
8449 $ianmackenzie$elm_units_prefixed$Units$Quantity$maximum(tail)));
8450 });
8451var $gampleman$elm_visualization$Force$Collision$toRadius = A2(
8452 $elm$core$Basics$composeR,
8453 function ($) {
8454 return $.circle;
8455 },
8456 $ianmackenzie$elm_geometry$Circle2d$radius);
8457var $gampleman$elm_visualization$Force$Collision$config = {
8458 combineAggregates: F2(
8459 function (radius, radii) {
8460 return A2($gampleman$elm_visualization$Force$Collision$nonEmptyMaximum, radius, radii);
8461 }),
8462 combineVertices: F2(
8463 function (vertex, vertices) {
8464 return A2(
8465 $gampleman$elm_visualization$Force$Collision$nonEmptyMaximum,
8466 $gampleman$elm_visualization$Force$Collision$toRadius(vertex),
8467 A2($elm$core$List$map, $gampleman$elm_visualization$Force$Collision$toRadius, vertices));
8468 }),
8469 toPoint: A2(
8470 $elm$core$Basics$composeR,
8471 function ($) {
8472 return $.circle;
8473 },
8474 $ianmackenzie$elm_geometry$Circle2d$centerPoint)
8475};
8476var $elm$core$Array$fromListHelp = F3(
8477 function (list, nodeList, nodeListSize) {
8478 fromListHelp:
8479 while (true) {
8480 var _v0 = A2($elm$core$Elm$JsArray$initializeFromList, $elm$core$Array$branchFactor, list);
8481 var jsArray = _v0.a;
8482 var remainingItems = _v0.b;
8483 if (_Utils_cmp(
8484 $elm$core$Elm$JsArray$length(jsArray),
8485 $elm$core$Array$branchFactor) < 0) {
8486 return A2(
8487 $elm$core$Array$builderToArray,
8488 true,
8489 {nodeList: nodeList, nodeListSize: nodeListSize, tail: jsArray});
8490 } else {
8491 var $temp$list = remainingItems,
8492 $temp$nodeList = A2(
8493 $elm$core$List$cons,
8494 $elm$core$Array$Leaf(jsArray),
8495 nodeList),
8496 $temp$nodeListSize = nodeListSize + 1;
8497 list = $temp$list;
8498 nodeList = $temp$nodeList;
8499 nodeListSize = $temp$nodeListSize;
8500 continue fromListHelp;
8501 }
8502 }
8503 });
8504var $elm$core$Array$fromList = function (list) {
8505 if (!list.b) {
8506 return $elm$core$Array$empty;
8507 } else {
8508 return A3($elm$core$Array$fromListHelp, list, _List_Nil, 0);
8509 }
8510};
8511var $gampleman$elm_visualization$Force$QuadTree$Empty = {$: 'Empty'};
8512var $gampleman$elm_visualization$Force$QuadTree$empty = $gampleman$elm_visualization$Force$QuadTree$Empty;
8513var $gampleman$elm_visualization$Force$QuadTree$Leaf = function (a) {
8514 return {$: 'Leaf', a: a};
8515};
8516var $gampleman$elm_visualization$Force$QuadTree$Node = function (a) {
8517 return {$: 'Node', a: a};
8518};
8519var $ianmackenzie$elm_geometry$BoundingBox2d$contains = F2(
8520 function (point, boundingBox) {
8521 var _v0 = point;
8522 var x = _v0.a.x;
8523 var y = _v0.a.y;
8524 var _v1 = boundingBox;
8525 var b = _v1.a;
8526 return (_Utils_cmp(x, b.minX) > -1) && ((_Utils_cmp(x, b.maxX) < 1) && ((_Utils_cmp(y, b.minY) > -1) && (_Utils_cmp(y, b.maxY) < 1)));
8527 });
8528var $ianmackenzie$elm_geometry$BoundingBox2d$maxX = function (_v0) {
8529 var boundingBox = _v0.a;
8530 return $ianmackenzie$elm_units$Quantity$Quantity(boundingBox.maxX);
8531};
8532var $ianmackenzie$elm_geometry$BoundingBox2d$maxY = function (_v0) {
8533 var boundingBox = _v0.a;
8534 return $ianmackenzie$elm_units$Quantity$Quantity(boundingBox.maxY);
8535};
8536var $ianmackenzie$elm_geometry$BoundingBox2d$minX = function (_v0) {
8537 var boundingBox = _v0.a;
8538 return $ianmackenzie$elm_units$Quantity$Quantity(boundingBox.minX);
8539};
8540var $ianmackenzie$elm_geometry$BoundingBox2d$minY = function (_v0) {
8541 var boundingBox = _v0.a;
8542 return $ianmackenzie$elm_units$Quantity$Quantity(boundingBox.minY);
8543};
8544var $ianmackenzie$elm_geometry$BoundingBox2d$dimensions = function (boundingBox) {
8545 return _Utils_Tuple2(
8546 A2(
8547 $ianmackenzie$elm_units$Quantity$minus,
8548 $ianmackenzie$elm_geometry$BoundingBox2d$minX(boundingBox),
8549 $ianmackenzie$elm_geometry$BoundingBox2d$maxX(boundingBox)),
8550 A2(
8551 $ianmackenzie$elm_units$Quantity$minus,
8552 $ianmackenzie$elm_geometry$BoundingBox2d$minY(boundingBox),
8553 $ianmackenzie$elm_geometry$BoundingBox2d$maxY(boundingBox)));
8554};
8555var $ianmackenzie$elm_geometry$BoundingBox2d$extrema = function (boundingBox) {
8556 var _v0 = boundingBox;
8557 var b = _v0.a;
8558 return {
8559 maxX: $ianmackenzie$elm_units$Quantity$Quantity(b.maxX),
8560 maxY: $ianmackenzie$elm_units$Quantity$Quantity(b.maxY),
8561 minX: $ianmackenzie$elm_units$Quantity$Quantity(b.minX),
8562 minY: $ianmackenzie$elm_units$Quantity$Quantity(b.minY)
8563 };
8564};
8565var $gampleman$elm_visualization$Force$QuadTree$NE = {$: 'NE'};
8566var $gampleman$elm_visualization$Force$QuadTree$NW = {$: 'NW'};
8567var $gampleman$elm_visualization$Force$QuadTree$SE = {$: 'SE'};
8568var $gampleman$elm_visualization$Force$QuadTree$SW = {$: 'SW'};
8569var $ianmackenzie$elm_geometry$BoundingBox2d$centerPoint = function (boundingBox) {
8570 var _v0 = boundingBox;
8571 var b = _v0.a;
8572 var x1 = b.minX;
8573 var x2 = b.maxX;
8574 var y1 = b.minY;
8575 var y2 = b.maxY;
8576 return $ianmackenzie$elm_geometry$Geometry$Types$Point2d(
8577 {x: x1 + (0.5 * (x2 - x1)), y: y1 + (0.5 * (y2 - y1))});
8578};
8579var $ianmackenzie$elm_geometry$Point2d$coordinates = function (_v0) {
8580 var p = _v0.a;
8581 return _Utils_Tuple2(
8582 $ianmackenzie$elm_units$Quantity$Quantity(p.x),
8583 $ianmackenzie$elm_units$Quantity$Quantity(p.y));
8584};
8585var $ianmackenzie$elm_units$Quantity$greaterThanOrEqualTo = F2(
8586 function (_v0, _v1) {
8587 var y = _v0.a;
8588 var x = _v1.a;
8589 return _Utils_cmp(x, y) > -1;
8590 });
8591var $ianmackenzie$elm_units_prefixed$Units$Quantity$greaterThanOrEqualTo = $ianmackenzie$elm_units$Quantity$greaterThanOrEqualTo;
8592var $gampleman$elm_visualization$Force$QuadTree$quadrant = F2(
8593 function (boundingBox, point) {
8594 var _v0 = $ianmackenzie$elm_geometry$Point2d$coordinates(point);
8595 var x = _v0.a;
8596 var y = _v0.b;
8597 var _v1 = $ianmackenzie$elm_geometry$Point2d$coordinates(
8598 $ianmackenzie$elm_geometry$BoundingBox2d$centerPoint(boundingBox));
8599 var midX = _v1.a;
8600 var midY = _v1.b;
8601 return A2($ianmackenzie$elm_units_prefixed$Units$Quantity$greaterThanOrEqualTo, midY, y) ? (A2($ianmackenzie$elm_units_prefixed$Units$Quantity$greaterThanOrEqualTo, midX, x) ? $gampleman$elm_visualization$Force$QuadTree$NE : $gampleman$elm_visualization$Force$QuadTree$NW) : (A2($ianmackenzie$elm_units_prefixed$Units$Quantity$greaterThanOrEqualTo, midX, x) ? $gampleman$elm_visualization$Force$QuadTree$SE : $gampleman$elm_visualization$Force$QuadTree$SW);
8602 });
8603var $ianmackenzie$elm_geometry$BoundingBox2d$singleton = function (point) {
8604 var _v0 = point;
8605 var x = _v0.a.x;
8606 var y = _v0.a.y;
8607 return $ianmackenzie$elm_geometry$Geometry$Types$BoundingBox2d(
8608 {maxX: x, maxY: y, minX: x, minY: y});
8609};
8610var $gampleman$elm_visualization$Force$QuadTree$singleton = F2(
8611 function (toPoint, vertex) {
8612 return $gampleman$elm_visualization$Force$QuadTree$Leaf(
8613 {
8614 aggregate: _Utils_Tuple0,
8615 boundingBox: $ianmackenzie$elm_geometry$BoundingBox2d$singleton(
8616 toPoint(vertex)),
8617 children: _Utils_Tuple2(vertex, _List_Nil)
8618 });
8619 });
8620var $ianmackenzie$elm_geometry$BoundingBox2d$union = F2(
8621 function (firstBox, secondBox) {
8622 var _v0 = secondBox;
8623 var b2 = _v0.a;
8624 var _v1 = firstBox;
8625 var b1 = _v1.a;
8626 return $ianmackenzie$elm_geometry$Geometry$Types$BoundingBox2d(
8627 {
8628 maxX: A2($elm$core$Basics$max, b1.maxX, b2.maxX),
8629 maxY: A2($elm$core$Basics$max, b1.maxY, b2.maxY),
8630 minX: A2($elm$core$Basics$min, b1.minX, b2.minX),
8631 minY: A2($elm$core$Basics$min, b1.minY, b2.minY)
8632 });
8633 });
8634var $gampleman$elm_visualization$Force$QuadTree$insertBy = F3(
8635 function (toPoint, vertex, qtree) {
8636 switch (qtree.$) {
8637 case 'Empty':
8638 return $gampleman$elm_visualization$Force$QuadTree$Leaf(
8639 {
8640 aggregate: _Utils_Tuple0,
8641 boundingBox: $ianmackenzie$elm_geometry$BoundingBox2d$singleton(
8642 toPoint(vertex)),
8643 children: _Utils_Tuple2(vertex, _List_Nil)
8644 });
8645 case 'Leaf':
8646 var leaf = qtree.a;
8647 var maxSize = 32;
8648 var _v1 = leaf.children;
8649 var first = _v1.a;
8650 var rest = _v1.b;
8651 var newSize = 2 + $elm$core$List$length(rest);
8652 if (_Utils_cmp(newSize, maxSize) > -1) {
8653 var initial = $gampleman$elm_visualization$Force$QuadTree$Node(
8654 {
8655 aggregate: _Utils_Tuple0,
8656 boundingBox: A2(
8657 $ianmackenzie$elm_geometry$BoundingBox2d$union,
8658 leaf.boundingBox,
8659 $ianmackenzie$elm_geometry$BoundingBox2d$singleton(
8660 toPoint(vertex))),
8661 ne: $gampleman$elm_visualization$Force$QuadTree$Empty,
8662 nw: $gampleman$elm_visualization$Force$QuadTree$Empty,
8663 se: $gampleman$elm_visualization$Force$QuadTree$Empty,
8664 sw: $gampleman$elm_visualization$Force$QuadTree$Empty
8665 });
8666 return A3(
8667 $elm$core$List$foldl,
8668 $gampleman$elm_visualization$Force$QuadTree$insertBy(toPoint),
8669 initial,
8670 A2($elm$core$List$cons, first, rest));
8671 } else {
8672 return $gampleman$elm_visualization$Force$QuadTree$Leaf(
8673 {
8674 aggregate: _Utils_Tuple0,
8675 boundingBox: A2(
8676 $ianmackenzie$elm_geometry$BoundingBox2d$union,
8677 leaf.boundingBox,
8678 $ianmackenzie$elm_geometry$BoundingBox2d$singleton(
8679 toPoint(vertex))),
8680 children: _Utils_Tuple2(
8681 vertex,
8682 A2($elm$core$List$cons, first, rest))
8683 });
8684 }
8685 default:
8686 var node = qtree.a;
8687 var point = toPoint(vertex);
8688 if (A2($ianmackenzie$elm_geometry$BoundingBox2d$contains, point, node.boundingBox)) {
8689 var _v2 = A2($gampleman$elm_visualization$Force$QuadTree$quadrant, node.boundingBox, point);
8690 switch (_v2.$) {
8691 case 'NE':
8692 return $gampleman$elm_visualization$Force$QuadTree$Node(
8693 {
8694 aggregate: node.aggregate,
8695 boundingBox: node.boundingBox,
8696 ne: A3($gampleman$elm_visualization$Force$QuadTree$insertBy, toPoint, vertex, node.ne),
8697 nw: node.nw,
8698 se: node.se,
8699 sw: node.sw
8700 });
8701 case 'SE':
8702 return $gampleman$elm_visualization$Force$QuadTree$Node(
8703 {
8704 aggregate: node.aggregate,
8705 boundingBox: node.boundingBox,
8706 ne: node.ne,
8707 nw: node.nw,
8708 se: A3($gampleman$elm_visualization$Force$QuadTree$insertBy, toPoint, vertex, node.se),
8709 sw: node.sw
8710 });
8711 case 'NW':
8712 return $gampleman$elm_visualization$Force$QuadTree$Node(
8713 {
8714 aggregate: node.aggregate,
8715 boundingBox: node.boundingBox,
8716 ne: node.ne,
8717 nw: A3($gampleman$elm_visualization$Force$QuadTree$insertBy, toPoint, vertex, node.nw),
8718 se: node.se,
8719 sw: node.sw
8720 });
8721 default:
8722 return $gampleman$elm_visualization$Force$QuadTree$Node(
8723 {
8724 aggregate: node.aggregate,
8725 boundingBox: node.boundingBox,
8726 ne: node.ne,
8727 nw: node.nw,
8728 se: node.se,
8729 sw: A3($gampleman$elm_visualization$Force$QuadTree$insertBy, toPoint, vertex, node.sw)
8730 });
8731 }
8732 } else {
8733 var _v3 = $ianmackenzie$elm_geometry$BoundingBox2d$extrema(node.boundingBox);
8734 var minX = _v3.minX;
8735 var minY = _v3.minY;
8736 var maxX = _v3.maxX;
8737 var maxY = _v3.maxY;
8738 var _v4 = $ianmackenzie$elm_geometry$BoundingBox2d$dimensions(node.boundingBox);
8739 var width = _v4.a;
8740 var height = _v4.b;
8741 var _v5 = A2($gampleman$elm_visualization$Force$QuadTree$quadrant, node.boundingBox, point);
8742 switch (_v5.$) {
8743 case 'NE':
8744 return $gampleman$elm_visualization$Force$QuadTree$Node(
8745 {
8746 aggregate: _Utils_Tuple0,
8747 boundingBox: $ianmackenzie$elm_geometry$BoundingBox2d$fromExtrema(
8748 {
8749 maxX: A2($ianmackenzie$elm_units_prefixed$Units$Quantity$plus, width, maxX),
8750 maxY: A2($ianmackenzie$elm_units_prefixed$Units$Quantity$plus, height, maxY),
8751 minX: minX,
8752 minY: minY
8753 }),
8754 ne: A2($gampleman$elm_visualization$Force$QuadTree$singleton, toPoint, vertex),
8755 nw: $gampleman$elm_visualization$Force$QuadTree$Empty,
8756 se: $gampleman$elm_visualization$Force$QuadTree$Empty,
8757 sw: qtree
8758 });
8759 case 'SE':
8760 return $gampleman$elm_visualization$Force$QuadTree$Node(
8761 {
8762 aggregate: _Utils_Tuple0,
8763 boundingBox: $ianmackenzie$elm_geometry$BoundingBox2d$fromExtrema(
8764 {
8765 maxX: A2($ianmackenzie$elm_units_prefixed$Units$Quantity$plus, width, maxX),
8766 maxY: maxY,
8767 minX: minX,
8768 minY: A2($ianmackenzie$elm_units_prefixed$Units$Quantity$minus, height, minY)
8769 }),
8770 ne: $gampleman$elm_visualization$Force$QuadTree$Empty,
8771 nw: qtree,
8772 se: A2($gampleman$elm_visualization$Force$QuadTree$singleton, toPoint, vertex),
8773 sw: $gampleman$elm_visualization$Force$QuadTree$Empty
8774 });
8775 case 'NW':
8776 return $gampleman$elm_visualization$Force$QuadTree$Node(
8777 {
8778 aggregate: _Utils_Tuple0,
8779 boundingBox: $ianmackenzie$elm_geometry$BoundingBox2d$fromExtrema(
8780 {
8781 maxX: maxX,
8782 maxY: A2($ianmackenzie$elm_units_prefixed$Units$Quantity$plus, height, maxY),
8783 minX: A2($ianmackenzie$elm_units_prefixed$Units$Quantity$minus, width, minX),
8784 minY: minY
8785 }),
8786 ne: $gampleman$elm_visualization$Force$QuadTree$Empty,
8787 nw: A2($gampleman$elm_visualization$Force$QuadTree$singleton, toPoint, vertex),
8788 se: qtree,
8789 sw: $gampleman$elm_visualization$Force$QuadTree$Empty
8790 });
8791 default:
8792 return $gampleman$elm_visualization$Force$QuadTree$Node(
8793 {
8794 aggregate: _Utils_Tuple0,
8795 boundingBox: $ianmackenzie$elm_geometry$BoundingBox2d$fromExtrema(
8796 {
8797 maxX: maxX,
8798 maxY: maxY,
8799 minX: A2($ianmackenzie$elm_units_prefixed$Units$Quantity$minus, width, minX),
8800 minY: A2($ianmackenzie$elm_units_prefixed$Units$Quantity$minus, height, minY)
8801 }),
8802 ne: qtree,
8803 nw: $gampleman$elm_visualization$Force$QuadTree$Empty,
8804 se: $gampleman$elm_visualization$Force$QuadTree$Empty,
8805 sw: A2($gampleman$elm_visualization$Force$QuadTree$singleton, toPoint, vertex)
8806 });
8807 }
8808 }
8809 }
8810 });
8811var $gampleman$elm_visualization$Force$QuadTree$fromList = function (toPoint) {
8812 return A2(
8813 $elm$core$List$foldl,
8814 $gampleman$elm_visualization$Force$QuadTree$insertBy(toPoint),
8815 $gampleman$elm_visualization$Force$QuadTree$empty);
8816};
8817var $gampleman$elm_visualization$Force$Collision$nTimes = F3(
8818 function (fn, times, input) {
8819 nTimes:
8820 while (true) {
8821 if (times <= 0) {
8822 return input;
8823 } else {
8824 var $temp$fn = fn,
8825 $temp$times = times - 1,
8826 $temp$input = fn(input);
8827 fn = $temp$fn;
8828 times = $temp$times;
8829 input = $temp$input;
8830 continue nTimes;
8831 }
8832 }
8833 });
8834var $gampleman$elm_visualization$Force$QuadTree$getAggregate = function (qtree) {
8835 switch (qtree.$) {
8836 case 'Empty':
8837 return $elm$core$Maybe$Nothing;
8838 case 'Leaf':
8839 var aggregate = qtree.a.aggregate;
8840 return $elm$core$Maybe$Just(aggregate);
8841 default:
8842 var aggregate = qtree.a.aggregate;
8843 return $elm$core$Maybe$Just(aggregate);
8844 }
8845};
8846var $gampleman$elm_visualization$Force$QuadTree$performAggregate = F2(
8847 function (config, vanillaQuadTree) {
8848 var combineAggregates = config.combineAggregates;
8849 var combineVertices = config.combineVertices;
8850 switch (vanillaQuadTree.$) {
8851 case 'Empty':
8852 return $gampleman$elm_visualization$Force$QuadTree$Empty;
8853 case 'Leaf':
8854 var leaf = vanillaQuadTree.a;
8855 var _v1 = leaf.children;
8856 var first = _v1.a;
8857 var rest = _v1.b;
8858 return $gampleman$elm_visualization$Force$QuadTree$Leaf(
8859 {
8860 aggregate: A2(combineVertices, first, rest),
8861 boundingBox: leaf.boundingBox,
8862 children: _Utils_Tuple2(first, rest)
8863 });
8864 default:
8865 var node = vanillaQuadTree.a;
8866 var newSw = A2($gampleman$elm_visualization$Force$QuadTree$performAggregate, config, node.sw);
8867 var newSe = A2($gampleman$elm_visualization$Force$QuadTree$performAggregate, config, node.se);
8868 var newNw = A2($gampleman$elm_visualization$Force$QuadTree$performAggregate, config, node.nw);
8869 var newNe = A2($gampleman$elm_visualization$Force$QuadTree$performAggregate, config, node.ne);
8870 var subresults = A2(
8871 $elm$core$List$filterMap,
8872 $gampleman$elm_visualization$Force$QuadTree$getAggregate,
8873 _List_fromArray(
8874 [newNw, newSw, newNe, newSe]));
8875 if (!subresults.b) {
8876 return $gampleman$elm_visualization$Force$QuadTree$Empty;
8877 } else {
8878 var x = subresults.a;
8879 var xs = subresults.b;
8880 return $gampleman$elm_visualization$Force$QuadTree$Node(
8881 {
8882 aggregate: A2(combineAggregates, x, xs),
8883 boundingBox: node.boundingBox,
8884 ne: newNe,
8885 nw: newNw,
8886 se: newSe,
8887 sw: newSw
8888 });
8889 }
8890 }
8891 });
8892var $ianmackenzie$elm_geometry$Geometry$Types$Circle2d = function (a) {
8893 return {$: 'Circle2d', a: a};
8894};
8895var $ianmackenzie$elm_units$Quantity$abs = function (_v0) {
8896 var value = _v0.a;
8897 return $ianmackenzie$elm_units$Quantity$Quantity(
8898 $elm$core$Basics$abs(value));
8899};
8900var $ianmackenzie$elm_geometry$Circle2d$withRadius = F2(
8901 function (givenRadius, givenCenterPoint) {
8902 return $ianmackenzie$elm_geometry$Geometry$Types$Circle2d(
8903 {
8904 centerPoint: givenCenterPoint,
8905 radius: $ianmackenzie$elm_units$Quantity$abs(givenRadius)
8906 });
8907 });
8908var $ianmackenzie$elm_geometry$Circle2d$translateBy = F2(
8909 function (displacement, _v0) {
8910 var circle = _v0.a;
8911 return A2(
8912 $ianmackenzie$elm_geometry$Circle2d$withRadius,
8913 circle.radius,
8914 A2($ianmackenzie$elm_geometry$Point2d$translateBy, displacement, circle.centerPoint));
8915 });
8916var $gampleman$elm_visualization$Force$Collision$collision = F3(
8917 function (strength, iters, vertices) {
8918 var withAggregates = A2(
8919 $gampleman$elm_visualization$Force$QuadTree$performAggregate,
8920 $gampleman$elm_visualization$Force$Collision$config,
8921 A2(
8922 $gampleman$elm_visualization$Force$QuadTree$fromList,
8923 A2(
8924 $elm$core$Basics$composeR,
8925 function ($) {
8926 return $.circle;
8927 },
8928 $ianmackenzie$elm_geometry$Circle2d$centerPoint),
8929 vertices));
8930 var apply = F2(
8931 function (vertex, velocities) {
8932 return A4(
8933 $gampleman$elm_visualization$Force$Collision$applyForce,
8934 strength,
8935 withAggregates,
8936 velocities,
8937 _Utils_update(
8938 vertex,
8939 {
8940 circle: A2($ianmackenzie$elm_geometry$Circle2d$translateBy, vertex.velocity, vertex.circle)
8941 }));
8942 });
8943 return A3(
8944 $gampleman$elm_visualization$Force$Collision$nTimes,
8945 function (velocities) {
8946 return A3($elm$core$List$foldl, apply, velocities, vertices);
8947 },
8948 iters,
8949 $elm$core$Array$fromList(vertices));
8950 });
8951var $elm$core$Elm$JsArray$foldl = _JsArray_foldl;
8952var $elm$core$Array$foldl = F3(
8953 function (func, baseCase, _v0) {
8954 var tree = _v0.c;
8955 var tail = _v0.d;
8956 var helper = F2(
8957 function (node, acc) {
8958 if (node.$ === 'SubTree') {
8959 var subTree = node.a;
8960 return A3($elm$core$Elm$JsArray$foldl, helper, acc, subTree);
8961 } else {
8962 var values = node.a;
8963 return A3($elm$core$Elm$JsArray$foldl, func, acc, values);
8964 }
8965 });
8966 return A3(
8967 $elm$core$Elm$JsArray$foldl,
8968 func,
8969 A3($elm$core$Elm$JsArray$foldl, helper, baseCase, tree),
8970 tail);
8971 });
8972var $ianmackenzie$elm_geometry$Point2d$pixels = F2(
8973 function (x, y) {
8974 return $ianmackenzie$elm_geometry$Geometry$Types$Point2d(
8975 {x: x, y: y});
8976 });
8977var $ianmackenzie$elm_units$Pixels$pixels = function (numPixels) {
8978 return $ianmackenzie$elm_units$Quantity$Quantity(numPixels);
8979};
8980var $ianmackenzie$elm_units_prefixed$Units$Pixels$pixels = $ianmackenzie$elm_units$Pixels$pixels;
8981var $ianmackenzie$elm_geometry$Vector2d$pixels = F2(
8982 function (x, y) {
8983 return $ianmackenzie$elm_geometry$Geometry$Types$Vector2d(
8984 {x: x, y: y});
8985 });
8986var $ianmackenzie$elm_geometry$Vector2d$toPixels = function (_v0) {
8987 var vectorComponents = _v0.a;
8988 return vectorComponents;
8989};
8990var $gampleman$elm_visualization$Force$Collision$wrapper = F4(
8991 function (strength, iters, radii, points) {
8992 var vertices = A3(
8993 $gampleman$elm_visualization$Force$Collision$collision,
8994 strength,
8995 iters,
8996 A2(
8997 $elm$core$List$indexedMap,
8998 F2(
8999 function (index, point) {
9000 return _Utils_update(
9001 point,
9002 {index: index});
9003 }),
9004 A2(
9005 $elm$core$List$filterMap,
9006 function (_v0) {
9007 var key = _v0.a;
9008 var x = _v0.b.x;
9009 var y = _v0.b.y;
9010 var vx = _v0.b.vx;
9011 var vy = _v0.b.vy;
9012 return A2(
9013 $elm$core$Maybe$map,
9014 function (radius) {
9015 return {
9016 circle: A2(
9017 $ianmackenzie$elm_geometry$Circle2d$withRadius,
9018 $ianmackenzie$elm_units_prefixed$Units$Pixels$pixels(radius),
9019 A2($ianmackenzie$elm_geometry$Point2d$pixels, x, y)),
9020 index: 0,
9021 key: key,
9022 velocity: A2($ianmackenzie$elm_geometry$Vector2d$pixels, vx, vy)
9023 };
9024 },
9025 A2($elm$core$Dict$get, key, radii));
9026 },
9027 $elm$core$Dict$toList(points))));
9028 var folder = function (newVertex) {
9029 return A2(
9030 $elm$core$Dict$update,
9031 newVertex.key,
9032 $elm$core$Maybe$map(
9033 function (point) {
9034 var dv = $ianmackenzie$elm_geometry$Vector2d$toPixels(newVertex.velocity);
9035 return _Utils_update(
9036 point,
9037 {vx: dv.x, vy: dv.y});
9038 }));
9039 };
9040 return A3($elm$core$Array$foldl, folder, points, vertices);
9041 });
9042var $ianmackenzie$elm_geometry$Point2d$distanceFrom = F2(
9043 function (_v0, _v1) {
9044 var p1 = _v0.a;
9045 var p2 = _v1.a;
9046 var deltaY = p2.y - p1.y;
9047 var deltaX = p2.x - p1.x;
9048 var largestComponent = A2(
9049 $elm$core$Basics$max,
9050 $elm$core$Basics$abs(deltaX),
9051 $elm$core$Basics$abs(deltaY));
9052 if (!largestComponent) {
9053 return $ianmackenzie$elm_units$Quantity$zero;
9054 } else {
9055 var scaledY = deltaY / largestComponent;
9056 var scaledX = deltaX / largestComponent;
9057 var scaledLength = $elm$core$Basics$sqrt((scaledX * scaledX) + (scaledY * scaledY));
9058 return $ianmackenzie$elm_units$Quantity$Quantity(scaledLength * largestComponent);
9059 }
9060 });
9061var $ianmackenzie$elm_units$Pixels$inPixels = function (_v0) {
9062 var numPixels = _v0.a;
9063 return numPixels;
9064};
9065var $ianmackenzie$elm_units_prefixed$Units$Pixels$inPixels = $ianmackenzie$elm_units$Pixels$inPixels;
9066var $elm$core$Basics$isNaN = _Basics_isNaN;
9067var $ianmackenzie$elm_geometry$Vector2d$sumHelp = F3(
9068 function (sumX, sumY, vectors) {
9069 sumHelp:
9070 while (true) {
9071 if (vectors.b) {
9072 var x = vectors.a.a.x;
9073 var y = vectors.a.a.y;
9074 var rest = vectors.b;
9075 var $temp$sumX = sumX + x,
9076 $temp$sumY = sumY + y,
9077 $temp$vectors = rest;
9078 sumX = $temp$sumX;
9079 sumY = $temp$sumY;
9080 vectors = $temp$vectors;
9081 continue sumHelp;
9082 } else {
9083 return $ianmackenzie$elm_geometry$Geometry$Types$Vector2d(
9084 {x: sumX, y: sumY});
9085 }
9086 }
9087 });
9088var $ianmackenzie$elm_geometry$Vector2d$sum = function (vectors) {
9089 return A3($ianmackenzie$elm_geometry$Vector2d$sumHelp, 0, 0, vectors);
9090};
9091var $ianmackenzie$elm_geometry$Vector2d$zero = $ianmackenzie$elm_geometry$Geometry$Types$Vector2d(
9092 {x: 0, y: 0});
9093var $gampleman$elm_visualization$Force$ManyBody$applyForce = F4(
9094 function (alpha, theta, qtree, vertex) {
9095 var isFarAway = function (treePart) {
9096 var distance = A2($ianmackenzie$elm_geometry$Point2d$distanceFrom, vertex.position, treePart.aggregate.position);
9097 var _v2 = $ianmackenzie$elm_geometry$BoundingBox2d$dimensions(treePart.boundingBox);
9098 var width = _v2.a;
9099 return _Utils_cmp(
9100 A2($ianmackenzie$elm_units_prefixed$Units$Quantity$ratio, width, distance),
9101 theta) < 0;
9102 };
9103 var calculateVelocity = F2(
9104 function (target, source) {
9105 var delta = A2($ianmackenzie$elm_geometry$Vector2d$from, target.position, source.position);
9106 var len = $gampleman$elm_visualization$Force$Jiggle$jiggle(
9107 $ianmackenzie$elm_units_prefixed$Units$Pixels$inPixels(
9108 $ianmackenzie$elm_geometry$Vector2d$length(delta)));
9109 var weight = (source.strength * alpha) / A2($elm$core$Basics$pow, len, 2);
9110 return $elm$core$Basics$isNaN(weight) ? $ianmackenzie$elm_geometry$Vector2d$zero : A2($ianmackenzie$elm_geometry$Vector2d$scaleBy, weight, delta);
9111 });
9112 var useAggregate = function (treePart) {
9113 return A2(calculateVelocity, vertex, treePart.aggregate);
9114 };
9115 switch (qtree.$) {
9116 case 'Empty':
9117 return $ianmackenzie$elm_geometry$Vector2d$zero;
9118 case 'Leaf':
9119 var leaf = qtree.a;
9120 if (isFarAway(leaf)) {
9121 return useAggregate(leaf);
9122 } else {
9123 var applyForceFromPoint = F2(
9124 function (point, accum) {
9125 return _Utils_eq(point.key, vertex.key) ? accum : A2(
9126 $ianmackenzie$elm_geometry$Vector2d$plus,
9127 A2(calculateVelocity, vertex, point),
9128 accum);
9129 });
9130 var _v1 = leaf.children;
9131 var first = _v1.a;
9132 var rest = _v1.b;
9133 return A3(
9134 $elm$core$List$foldl,
9135 applyForceFromPoint,
9136 $ianmackenzie$elm_geometry$Vector2d$zero,
9137 A2($elm$core$List$cons, first, rest));
9138 }
9139 default:
9140 var node = qtree.a;
9141 if (isFarAway(node)) {
9142 return useAggregate(node);
9143 } else {
9144 var helper = function (tree) {
9145 return A4($gampleman$elm_visualization$Force$ManyBody$applyForce, alpha, theta, tree, vertex);
9146 };
9147 return $ianmackenzie$elm_geometry$Vector2d$sum(
9148 _List_fromArray(
9149 [
9150 helper(node.nw),
9151 helper(node.ne),
9152 helper(node.se),
9153 helper(node.sw)
9154 ]));
9155 }
9156 }
9157 });
9158var $ianmackenzie$elm_units$Quantity$divideBy = F2(
9159 function (divisor, _v0) {
9160 var value = _v0.a;
9161 return $ianmackenzie$elm_units$Quantity$Quantity(value / divisor);
9162 });
9163var $ianmackenzie$elm_units_prefixed$Units$Quantity$divideBy = $ianmackenzie$elm_units$Quantity$divideBy;
9164var $ianmackenzie$elm_geometry$Point2d$xy = F2(
9165 function (_v0, _v1) {
9166 var x = _v0.a;
9167 var y = _v1.a;
9168 return $ianmackenzie$elm_geometry$Geometry$Types$Point2d(
9169 {x: x, y: y});
9170 });
9171var $gampleman$elm_visualization$Force$ManyBody$constructSuperPoint = F2(
9172 function (first, rest) {
9173 var initialStrength = first.strength;
9174 var initialPoint = $ianmackenzie$elm_geometry$Point2d$coordinates(first.position);
9175 var folder = F2(
9176 function (point, _v3) {
9177 var _v4 = _v3.a;
9178 var accumX = _v4.a;
9179 var accumY = _v4.b;
9180 var strength = _v3.b;
9181 var size = _v3.c;
9182 var _v2 = $ianmackenzie$elm_geometry$Point2d$coordinates(point.position);
9183 var x = _v2.a;
9184 var y = _v2.b;
9185 return _Utils_Tuple3(
9186 _Utils_Tuple2(
9187 A2($ianmackenzie$elm_units_prefixed$Units$Quantity$plus, x, accumX),
9188 A2($ianmackenzie$elm_units_prefixed$Units$Quantity$plus, y, accumY)),
9189 strength + point.strength,
9190 size + 1);
9191 });
9192 var _v0 = A3(
9193 $elm$core$List$foldl,
9194 folder,
9195 _Utils_Tuple3(initialPoint, initialStrength, 1),
9196 rest);
9197 var _v1 = _v0.a;
9198 var totalX = _v1.a;
9199 var totalY = _v1.b;
9200 var totalStrength = _v0.b;
9201 var totalSize = _v0.c;
9202 return {
9203 position: A2(
9204 $ianmackenzie$elm_geometry$Point2d$xy,
9205 A2($ianmackenzie$elm_units_prefixed$Units$Quantity$divideBy, totalSize, totalX),
9206 A2($ianmackenzie$elm_units_prefixed$Units$Quantity$divideBy, totalSize, totalY)),
9207 strength: totalStrength
9208 };
9209 });
9210var $gampleman$elm_visualization$Force$ManyBody$config = {
9211 combineAggregates: $gampleman$elm_visualization$Force$ManyBody$constructSuperPoint,
9212 combineVertices: $gampleman$elm_visualization$Force$ManyBody$constructSuperPoint,
9213 toPoint: function ($) {
9214 return $.position;
9215 }
9216};
9217var $gampleman$elm_visualization$Force$ManyBody$manyBody = F3(
9218 function (alpha, theta, vertices) {
9219 var withAggregates = A2(
9220 $gampleman$elm_visualization$Force$QuadTree$performAggregate,
9221 $gampleman$elm_visualization$Force$ManyBody$config,
9222 A2(
9223 $gampleman$elm_visualization$Force$QuadTree$fromList,
9224 function ($) {
9225 return $.position;
9226 },
9227 vertices));
9228 var updateVertex = function (vertex) {
9229 return _Utils_update(
9230 vertex,
9231 {
9232 velocity: A2(
9233 $ianmackenzie$elm_geometry$Vector2d$plus,
9234 vertex.velocity,
9235 A4($gampleman$elm_visualization$Force$ManyBody$applyForce, alpha, theta, withAggregates, vertex))
9236 });
9237 };
9238 return A2($elm$core$List$map, updateVertex, vertices);
9239 });
9240var $gampleman$elm_visualization$Force$ManyBody$wrapper = F4(
9241 function (alpha, theta, strengths, points) {
9242 var vertices = A2(
9243 $elm$core$List$map,
9244 function (_v0) {
9245 var key = _v0.a;
9246 var x = _v0.b.x;
9247 var y = _v0.b.y;
9248 var strength = A2(
9249 $elm$core$Maybe$withDefault,
9250 0,
9251 A2($elm$core$Dict$get, key, strengths));
9252 return {
9253 key: key,
9254 position: A2($ianmackenzie$elm_geometry$Point2d$pixels, x, y),
9255 strength: strength,
9256 velocity: $ianmackenzie$elm_geometry$Vector2d$zero
9257 };
9258 },
9259 $elm$core$Dict$toList(points));
9260 var updater = function (newVertex) {
9261 return $elm$core$Maybe$map(
9262 function (point) {
9263 var dv = $ianmackenzie$elm_geometry$Vector2d$toPixels(newVertex.velocity);
9264 return _Utils_update(
9265 point,
9266 {vx: point.vx + dv.x, vy: point.vy + dv.y});
9267 });
9268 };
9269 var newVertices = A3($gampleman$elm_visualization$Force$ManyBody$manyBody, alpha, theta, vertices);
9270 var folder = F2(
9271 function (newVertex, pointsDict) {
9272 return A3(
9273 $elm$core$Dict$update,
9274 newVertex.key,
9275 updater(newVertex),
9276 pointsDict);
9277 });
9278 return A3($elm$core$List$foldl, folder, points, newVertices);
9279 });
9280var $gampleman$elm_visualization$Force$applyForce = F3(
9281 function (alpha, force, entities) {
9282 switch (force.$) {
9283 case 'Center':
9284 var x = force.a;
9285 var y = force.b;
9286 var n = $elm$core$Dict$size(entities);
9287 var _v1 = A3(
9288 $elm$core$Dict$foldr,
9289 F3(
9290 function (_v2, ent, _v3) {
9291 var sx0 = _v3.a;
9292 var sy0 = _v3.b;
9293 return _Utils_Tuple2(sx0 + ent.x, sy0 + ent.y);
9294 }),
9295 _Utils_Tuple2(0, 0),
9296 entities);
9297 var sumx = _v1.a;
9298 var sumy = _v1.b;
9299 var sx = (sumx / n) - x;
9300 var sy = (sumy / n) - y;
9301 return A2(
9302 $elm$core$Dict$map,
9303 F2(
9304 function (_v4, ent) {
9305 return _Utils_update(
9306 ent,
9307 {x: ent.x - sx, y: ent.y - sy});
9308 }),
9309 entities);
9310 case 'Collision':
9311 var iters = force.a;
9312 var strength = force.b;
9313 var radii = force.c;
9314 return A4($gampleman$elm_visualization$Force$Collision$wrapper, strength, iters, radii, entities);
9315 case 'Links':
9316 var iters = force.a;
9317 var lnks = force.b;
9318 return A3(
9319 $gampleman$elm_visualization$Force$nTimes,
9320 function (entitiesList) {
9321 return A3(
9322 $elm$core$List$foldl,
9323 F2(
9324 function (_v5, ents) {
9325 var source = _v5.source;
9326 var target = _v5.target;
9327 var distance = _v5.distance;
9328 var strength = _v5.strength;
9329 var bias = _v5.bias;
9330 var _v6 = _Utils_Tuple2(
9331 A2($elm$core$Dict$get, source, ents),
9332 A2($elm$core$Dict$get, target, ents));
9333 if ((_v6.a.$ === 'Just') && (_v6.b.$ === 'Just')) {
9334 var sourceNode = _v6.a.a;
9335 var targetNode = _v6.b.a;
9336 var y = $gampleman$elm_visualization$Force$Jiggle$jiggle(((targetNode.y + targetNode.vy) - sourceNode.y) - sourceNode.vy);
9337 var x = $gampleman$elm_visualization$Force$Jiggle$jiggle(((targetNode.x + targetNode.vx) - sourceNode.x) - sourceNode.vx);
9338 var d = $elm$core$Basics$sqrt(
9339 A2($elm$core$Basics$pow, x, 2) + A2($elm$core$Basics$pow, y, 2));
9340 var l = (((d - distance) / d) * alpha) * strength;
9341 return A3(
9342 $elm$core$Dict$update,
9343 source,
9344 $elm$core$Maybe$map(
9345 function (tn) {
9346 return _Utils_update(
9347 tn,
9348 {vx: tn.vx + ((x * l) * (1 - bias)), vy: tn.vy + ((y * l) * (1 - bias))});
9349 }),
9350 A3(
9351 $elm$core$Dict$update,
9352 target,
9353 $elm$core$Maybe$map(
9354 function (sn) {
9355 return _Utils_update(
9356 sn,
9357 {vx: sn.vx - ((x * l) * bias), vy: sn.vy - ((y * l) * bias)});
9358 }),
9359 ents));
9360 } else {
9361 return ents;
9362 }
9363 }),
9364 entitiesList,
9365 lnks);
9366 },
9367 iters,
9368 entities);
9369 case 'ManyBody':
9370 var theta = force.a;
9371 var entityStrengths = force.b;
9372 return A4($gampleman$elm_visualization$Force$ManyBody$wrapper, alpha, theta, entityStrengths, entities);
9373 case 'X':
9374 var entityConfigs = force.a;
9375 var mapper = F2(
9376 function (id, ent) {
9377 var _v7 = A2($elm$core$Dict$get, id, entityConfigs);
9378 if (_v7.$ === 'Just') {
9379 var strength = _v7.a.strength;
9380 var position = _v7.a.position;
9381 return _Utils_update(
9382 ent,
9383 {vx: ent.vx + (((position - ent.x) * strength) * alpha)});
9384 } else {
9385 return ent;
9386 }
9387 });
9388 return A2($elm$core$Dict$map, mapper, entities);
9389 case 'Y':
9390 var entityConfigs = force.a;
9391 var mapper = F2(
9392 function (id, ent) {
9393 var _v8 = A2($elm$core$Dict$get, id, entityConfigs);
9394 if (_v8.$ === 'Just') {
9395 var strength = _v8.a.strength;
9396 var position = _v8.a.position;
9397 return _Utils_update(
9398 ent,
9399 {vy: ent.vy + (((position - ent.y) * strength) * alpha)});
9400 } else {
9401 return ent;
9402 }
9403 });
9404 return A2($elm$core$Dict$map, mapper, entities);
9405 default:
9406 var entityConfigs = force.a;
9407 var mapper = F2(
9408 function (id, ent) {
9409 var _v9 = A2($elm$core$Dict$get, id, entityConfigs);
9410 if (_v9.$ === 'Just') {
9411 var strength = _v9.a.strength;
9412 var x = _v9.a.x;
9413 var y = _v9.a.y;
9414 var radius = _v9.a.radius;
9415 var dy = $gampleman$elm_visualization$Force$Jiggle$jiggle(ent.y - y);
9416 var dx = $gampleman$elm_visualization$Force$Jiggle$jiggle(ent.x - x);
9417 var r = $elm$core$Basics$sqrt(
9418 A2($elm$core$Basics$pow, dx, 2) + A2($elm$core$Basics$pow, dy, 2));
9419 var k = (((radius - r) * strength) * alpha) / r;
9420 return _Utils_update(
9421 ent,
9422 {vx: ent.vx + (dx * k), vy: ent.vy + (dy * k)});
9423 } else {
9424 return ent;
9425 }
9426 });
9427 return A2($elm$core$Dict$map, mapper, entities);
9428 }
9429 });
9430var $elm$core$Dict$values = function (dict) {
9431 return A3(
9432 $elm$core$Dict$foldr,
9433 F3(
9434 function (key, value, valueList) {
9435 return A2($elm$core$List$cons, value, valueList);
9436 }),
9437 _List_Nil,
9438 dict);
9439};
9440var $gampleman$elm_visualization$Force$tick = F2(
9441 function (_v0, nodes) {
9442 var state = _v0.a;
9443 var updateEntity = function (ent) {
9444 return _Utils_update(
9445 ent,
9446 {vx: ent.vx * state.velocityDecay, vy: ent.vy * state.velocityDecay, x: ent.x + (ent.vx * state.velocityDecay), y: ent.y + (ent.vy * state.velocityDecay)});
9447 };
9448 var dictNodes = A3(
9449 $elm$core$List$foldl,
9450 function (node) {
9451 return A2($elm$core$Dict$insert, node.id, node);
9452 },
9453 $elm$core$Dict$empty,
9454 nodes);
9455 var alpha = state.alpha + ((state.alphaTarget - state.alpha) * state.alphaDecay);
9456 var newNodes = A3(
9457 $elm$core$List$foldl,
9458 $gampleman$elm_visualization$Force$applyForce(alpha),
9459 dictNodes,
9460 state.forces);
9461 return _Utils_Tuple2(
9462 $gampleman$elm_visualization$Force$State(
9463 _Utils_update(
9464 state,
9465 {alpha: alpha})),
9466 A2(
9467 $elm$core$List$map,
9468 updateEntity,
9469 $elm$core$Dict$values(newNodes)));
9470 });
9471var $author$project$Graph$tick = function (model) {
9472 if (!$author$project$Graph$isSimulating(model)) {
9473 return model;
9474 } else {
9475 var _v0 = A2(
9476 $gampleman$elm_visualization$Force$tick,
9477 model.simulation,
9478 $elm$core$Dict$values(model.nodes));
9479 var nextSim = _v0.a;
9480 var nextNodes = _v0.b;
9481 var updatedNodes = A3(
9482 $elm$core$List$foldl,
9483 F2(
9484 function (n, acc) {
9485 return A3($elm$core$Dict$insert, n.id, n, acc);
9486 }),
9487 model.nodes,
9488 nextNodes);
9489 return _Utils_update(
9490 model,
9491 {nodes: updatedNodes, simulation: nextSim});
9492 }
9493};
9494var $elm$url$Url$addPort = F2(
9495 function (maybePort, starter) {
9496 if (maybePort.$ === 'Nothing') {
9497 return starter;
9498 } else {
9499 var port_ = maybePort.a;
9500 return starter + (':' + $elm$core$String$fromInt(port_));
9501 }
9502 });
9503var $elm$url$Url$addPrefixed = F3(
9504 function (prefix, maybeSegment, starter) {
9505 if (maybeSegment.$ === 'Nothing') {
9506 return starter;
9507 } else {
9508 var segment = maybeSegment.a;
9509 return _Utils_ap(
9510 starter,
9511 _Utils_ap(prefix, segment));
9512 }
9513 });
9514var $elm$url$Url$toString = function (url) {
9515 var http = function () {
9516 var _v0 = url.protocol;
9517 if (_v0.$ === 'Http') {
9518 return 'http://';
9519 } else {
9520 return 'https://';
9521 }
9522 }();
9523 return A3(
9524 $elm$url$Url$addPrefixed,
9525 '#',
9526 url.fragment,
9527 A3(
9528 $elm$url$Url$addPrefixed,
9529 '?',
9530 url.query,
9531 _Utils_ap(
9532 A2(
9533 $elm$url$Url$addPort,
9534 url.port_,
9535 _Utils_ap(http, url.host)),
9536 url.path)));
9537};
9538var $author$project$Main$update = F2(
9539 function (msg, model) {
9540 update:
9541 while (true) {
9542 switch (msg.$) {
9543 case 'UpdateInput':
9544 var s = msg.a;
9545 if (A2($elm$core$String$contains, ',', s)) {
9546 var allowed = function (c) {
9547 return $elm$core$Char$isAlphaNum(c) || A2(
9548 $elm$core$List$member,
9549 c,
9550 _List_fromArray(
9551 [
9552 _Utils_chr(','),
9553 _Utils_chr(' '),
9554 _Utils_chr('.'),
9555 _Utils_chr('/'),
9556 _Utils_chr('-'),
9557 _Utils_chr('*')
9558 ]));
9559 };
9560 var filtered = A2($elm$core$String$filter, allowed, s);
9561 return _Utils_Tuple2(
9562 _Utils_update(
9563 model,
9564 {
9565 input: A2($elm$core$String$left, 500, filtered)
9566 }),
9567 $elm$core$Platform$Cmd$none);
9568 } else {
9569 if ($elm$core$String$length(
9570 A2($elm$core$String$filter, $elm$core$Char$isAlphaNum, s)) > 14) {
9571 return _Utils_Tuple2(
9572 _Utils_update(
9573 model,
9574 {
9575 input: A2($elm$core$String$left, 32, s)
9576 }),
9577 $elm$core$Platform$Cmd$none);
9578 } else {
9579 return _Utils_Tuple2(
9580 _Utils_update(
9581 model,
9582 {
9583 input: A2($author$project$Format$maskCnpjInput, model.input, s)
9584 }),
9585 $elm$core$Platform$Cmd$none);
9586 }
9587 }
9588 case 'UpdateConnectionInput1':
9589 var s = msg.a;
9590 return ($elm$core$String$length(
9591 A2($elm$core$String$filter, $elm$core$Char$isAlphaNum, s)) > 14) ? _Utils_Tuple2(
9592 _Utils_update(
9593 model,
9594 {
9595 connectionInput1: A2($elm$core$String$left, 32, s)
9596 }),
9597 $elm$core$Platform$Cmd$none) : _Utils_Tuple2(
9598 _Utils_update(
9599 model,
9600 {
9601 connectionInput1: A2($author$project$Format$maskCnpjInput, model.connectionInput1, s)
9602 }),
9603 $elm$core$Platform$Cmd$none);
9604 case 'UpdateConnectionInput2':
9605 var s = msg.a;
9606 return ($elm$core$String$length(
9607 A2($elm$core$String$filter, $elm$core$Char$isAlphaNum, s)) > 14) ? _Utils_Tuple2(
9608 _Utils_update(
9609 model,
9610 {
9611 connectionInput2: A2($elm$core$String$left, 32, s)
9612 }),
9613 $elm$core$Platform$Cmd$none) : _Utils_Tuple2(
9614 _Utils_update(
9615 model,
9616 {
9617 connectionInput2: A2($author$project$Format$maskCnpjInput, model.connectionInput2, s)
9618 }),
9619 $elm$core$Platform$Cmd$none);
9620 case 'SwitchTab':
9621 var tab = msg.a;
9622 return _Utils_Tuple2(
9623 _Utils_update(
9624 model,
9625 {activeTab: tab}),
9626 $elm$core$Platform$Cmd$none);
9627 case 'Search':
9628 var _v1 = model.activeTab;
9629 if (_v1.$ === 'CnpjTab') {
9630 var currentRoute = $author$project$Main$parseUrl(model.url);
9631 var cnpjs = A2($elm$core$String$contains, ',', model.input) ? A2(
9632 $elm$core$List$filter,
9633 A2($elm$core$Basics$composeL, $elm$core$Basics$not, $elm$core$String$isEmpty),
9634 A2(
9635 $elm$core$List$map,
9636 $elm$core$String$filter(
9637 function (c) {
9638 return $elm$core$Char$isAlphaNum(c) || _Utils_eq(
9639 c,
9640 _Utils_chr('*'));
9641 }),
9642 A2($elm$core$String$split, ',', model.input))) : _List_fromArray(
9643 [
9644 A2(
9645 $elm$core$String$filter,
9646 function (c) {
9647 return $elm$core$Char$isAlphaNum(c) || _Utils_eq(
9648 c,
9649 _Utils_chr('*'));
9650 },
9651 model.input)
9652 ]);
9653 var unmasked = A2($elm$core$String$join, ',', cnpjs);
9654 return $elm$core$List$isEmpty(cnpjs) ? _Utils_Tuple2(
9655 _Utils_update(
9656 model,
9657 {
9658 error: $elm$core$Maybe$Just('Por favor, digite um CNPJ')
9659 }),
9660 $elm$core$Platform$Cmd$none) : (_Utils_eq(
9661 currentRoute,
9662 $author$project$Main$CnpjRoute(unmasked)) ? _Utils_Tuple2(model, $elm$core$Platform$Cmd$none) : _Utils_Tuple2(
9663 _Utils_update(
9664 model,
9665 {
9666 collisionRadius: 50,
9667 currentQueries: _List_Nil,
9668 edges: $elm$core$Set$empty,
9669 error: $elm$core$Maybe$Nothing,
9670 isInitialSearch: true,
9671 linkDistance: 80,
9672 manyBody: -150,
9673 nodes: $elm$core$Dict$empty,
9674 pan: {x: 0, y: 0},
9675 pending: $elm$core$Set$empty,
9676 queryQueue: _List_Nil,
9677 simulation: A3($author$project$Graph$initSimulation, model.width, model.height, _List_Nil),
9678 visited: $elm$core$Set$empty,
9679 zoom: 1.0
9680 }),
9681 A2($elm$browser$Browser$Navigation$pushUrl, model.navKey, '#/grafo/' + unmasked)));
9682 } else {
9683 var id2 = A2($elm$core$String$filter, $elm$core$Char$isAlphaNum, model.connectionInput2);
9684 var id1 = A2($elm$core$String$filter, $elm$core$Char$isAlphaNum, model.connectionInput1);
9685 var currentRoute = $author$project$Main$parseUrl(model.url);
9686 return ($elm$core$String$isEmpty(id1) || $elm$core$String$isEmpty(id2)) ? _Utils_Tuple2(
9687 _Utils_update(
9688 model,
9689 {
9690 error: $elm$core$Maybe$Just('Por favor, digite ambos os campos')
9691 }),
9692 $elm$core$Platform$Cmd$none) : (_Utils_eq(
9693 currentRoute,
9694 A2($author$project$Main$ConnectionRoute, id1, id2)) ? _Utils_Tuple2(model, $elm$core$Platform$Cmd$none) : _Utils_Tuple2(
9695 _Utils_update(
9696 model,
9697 {
9698 collisionRadius: 50,
9699 currentQueries: _List_Nil,
9700 edges: $elm$core$Set$empty,
9701 error: $elm$core$Maybe$Nothing,
9702 isInitialSearch: true,
9703 linkDistance: 80,
9704 manyBody: -150,
9705 nodes: $elm$core$Dict$empty,
9706 pan: {x: 0, y: 0},
9707 pending: $elm$core$Set$empty,
9708 queryQueue: _List_Nil,
9709 simulation: A3($author$project$Graph$initSimulation, model.width, model.height, _List_Nil),
9710 visited: $elm$core$Set$empty,
9711 zoom: 1.0
9712 }),
9713 A2($elm$browser$Browser$Navigation$pushUrl, model.navKey, '#/conexao/' + (id1 + ('/' + id2)))));
9714 }
9715 case 'Clear':
9716 return _Utils_Tuple2(
9717 function (m) {
9718 return _Utils_update(
9719 m,
9720 {activeTab: model.activeTab});
9721 }(
9722 A6($author$project$Main$blankModel, model.width, model.height, model.graphApi, model.jsonApi, model.navKey, model.url)),
9723 A2($elm$browser$Browser$Navigation$pushUrl, model.navKey, '#'));
9724 case 'NodeClicked':
9725 var id = msg.a;
9726 var _v2 = A2($elm$core$Dict$get, id, model.nodes);
9727 if (_v2.$ === 'Just') {
9728 var node = _v2.a;
9729 var queries = A3($author$project$Main$queriesFor, id, false, node.depth);
9730 return $author$project$Main$triggerNextQuery(
9731 A2($author$project$Main$enqueueQueries, queries, model));
9732 } else {
9733 return _Utils_Tuple2(model, $elm$core$Platform$Cmd$none);
9734 }
9735 case 'GotResponse':
9736 var id = msg.a;
9737 var url = msg.b;
9738 var depth = msg.c;
9739 var result = msg.d;
9740 var key = A2($elm$core$String$contains, ';', id) ? _Utils_Tuple2(id, 'conexao') : _Utils_Tuple2(id, 'relacoes');
9741 var isMatchingQuery = function (q) {
9742 return _Utils_eq(
9743 $author$project$Main$queryKey(q.queryType),
9744 key);
9745 };
9746 var updatedCurrentQueries = A2(
9747 $elm$core$List$filter,
9748 function (q) {
9749 return !isMatchingQuery(q);
9750 },
9751 model.currentQueries);
9752 var baseModel = _Utils_update(
9753 model,
9754 {
9755 currentQueries: updatedCurrentQueries,
9756 pending: A2($elm$core$Set$remove, key, model.pending),
9757 visited: A2($elm$core$Set$insert, key, model.visited)
9758 });
9759 var finalBaseModel = (model.isInitialSearch && $elm$core$Set$isEmpty(baseModel.pending)) ? _Utils_update(
9760 baseModel,
9761 {isInitialSearch: false}) : baseModel;
9762 if (result.$ === 'Err') {
9763 var apiErr = result.a;
9764 var failedQuery = $elm$core$List$head(
9765 A2($elm$core$List$filter, isMatchingQuery, model.currentQueries));
9766 return $author$project$Main$triggerNextQuery(
9767 A5($author$project$Main$handleApiError, id, url, failedQuery, apiErr, finalBaseModel));
9768 } else {
9769 var response = result.a;
9770 var _v4 = A4(
9771 $author$project$Main$processResponse,
9772 id,
9773 response,
9774 depth,
9775 _Utils_update(
9776 finalBaseModel,
9777 {error: $elm$core$Maybe$Nothing}));
9778 var updatedModel = _v4.a;
9779 var newQueue = _v4.b;
9780 var extraCmd = _v4.c;
9781 var _v5 = $author$project$Main$triggerNextQuery(
9782 $author$project$Graph$layout(
9783 A2($author$project$Main$enqueueQueries, newQueue, updatedModel)));
9784 var nextModel = _v5.a;
9785 var nextCmd = _v5.b;
9786 return _Utils_Tuple2(
9787 nextModel,
9788 $elm$core$Platform$Cmd$batch(
9789 _List_fromArray(
9790 [extraCmd, nextCmd])));
9791 }
9792 case 'GotCompanyName':
9793 var cnpj = msg.a;
9794 var result = msg.c;
9795 if (result.$ === 'Ok') {
9796 var info = result.a;
9797 var status = $author$project$Main$codeToStatus(info.situacaoCadastral);
9798 var updatedNodes = A3(
9799 $elm$core$Dict$update,
9800 cnpj,
9801 $elm$core$Maybe$map(
9802 function (node) {
9803 return _Utils_update(
9804 node,
9805 {
9806 entity: function () {
9807 var _v7 = node.entity;
9808 if (_v7.$ === 'Company') {
9809 var id = _v7.b;
9810 return A3($author$project$Types$Company, info.name, id, status);
9811 } else {
9812 return A3($author$project$Types$Company, info.name, cnpj, status);
9813 }
9814 }()
9815 });
9816 }),
9817 model.nodes);
9818 return _Utils_Tuple2(
9819 _Utils_update(
9820 model,
9821 {nodes: updatedNodes}),
9822 $elm$core$Platform$Cmd$none);
9823 } else {
9824 var updatedNodes = A3(
9825 $elm$core$Dict$update,
9826 cnpj,
9827 $elm$core$Maybe$map(
9828 function (node) {
9829 return _Utils_update(
9830 node,
9831 {
9832 entity: function () {
9833 var _v8 = node.entity;
9834 if (_v8.$ === 'Company') {
9835 var name = _v8.a;
9836 var id = _v8.b;
9837 return A3($author$project$Types$Company, name, id, $author$project$Types$StatusUnknown);
9838 } else {
9839 return A3($author$project$Types$Company, cnpj, cnpj, $author$project$Types$StatusUnknown);
9840 }
9841 }()
9842 });
9843 }),
9844 model.nodes);
9845 return _Utils_Tuple2(
9846 _Utils_update(
9847 model,
9848 {nodes: updatedNodes}),
9849 $elm$core$Platform$Cmd$none);
9850 }
9851 case 'Tick':
9852 return _Utils_Tuple2(
9853 $author$project$Graph$tick(model),
9854 $elm$core$Platform$Cmd$none);
9855 case 'Resize':
9856 var w = msg.a;
9857 var h = msg.b;
9858 return _Utils_Tuple2(
9859 _Utils_update(
9860 model,
9861 {height: h, width: w}),
9862 $elm$core$Platform$Cmd$none);
9863 case 'InteractionStart':
9864 var id = msg.a;
9865 var x = msg.b;
9866 var y = msg.c;
9867 return _Utils_Tuple2(
9868 _Utils_update(
9869 model,
9870 {
9871 dragNode: $elm$core$Maybe$Just(id),
9872 startPos: $elm$core$Maybe$Just(
9873 {x: x, y: y})
9874 }),
9875 $elm$core$Platform$Cmd$none);
9876 case 'PanStart':
9877 return _Utils_Tuple2(
9878 _Utils_update(
9879 model,
9880 {isPanning: true}),
9881 $elm$core$Platform$Cmd$none);
9882 case 'InteractionMove':
9883 var dx = msg.a;
9884 var dy = msg.b;
9885 var _v9 = model.dragNode;
9886 if (_v9.$ === 'Just') {
9887 var id = _v9.a;
9888 var updatedNodes = A3(
9889 $elm$core$Dict$update,
9890 id,
9891 $elm$core$Maybe$map(
9892 function (n) {
9893 return _Utils_update(
9894 n,
9895 {vx: 0, vy: 0, x: n.x + (dx / model.zoom), y: n.y + (dy / model.zoom)});
9896 }),
9897 model.nodes);
9898 return _Utils_Tuple2(
9899 _Utils_update(
9900 model,
9901 {nodes: updatedNodes}),
9902 $elm$core$Platform$Cmd$none);
9903 } else {
9904 return model.isPanning ? _Utils_Tuple2(
9905 _Utils_update(
9906 model,
9907 {
9908 pan: {x: model.pan.x + dx, y: model.pan.y + dy}
9909 }),
9910 $elm$core$Platform$Cmd$none) : _Utils_Tuple2(model, $elm$core$Platform$Cmd$none);
9911 }
9912 case 'InteractionEnd':
9913 var x = msg.a;
9914 var y = msg.b;
9915 var newModel = _Utils_update(
9916 model,
9917 {dragNode: $elm$core$Maybe$Nothing, isPanning: false, startPos: $elm$core$Maybe$Nothing});
9918 var isClick = function () {
9919 var _v11 = model.startPos;
9920 if (_v11.$ === 'Just') {
9921 var start = _v11.a;
9922 var dy = y - start.y;
9923 var dx = x - start.x;
9924 var dist = $elm$core$Basics$sqrt((dx * dx) + (dy * dy));
9925 return dist < 5;
9926 } else {
9927 return false;
9928 }
9929 }();
9930 var _v10 = _Utils_Tuple2(isClick, model.dragNode);
9931 if (_v10.a && (_v10.b.$ === 'Just')) {
9932 var id = _v10.b.a;
9933 var $temp$msg = $author$project$Types$NodeClicked(id),
9934 $temp$model = newModel;
9935 msg = $temp$msg;
9936 model = $temp$model;
9937 continue update;
9938 } else {
9939 return _Utils_Tuple2(newModel, $elm$core$Platform$Cmd$none);
9940 }
9941 case 'Zoom':
9942 var delta = msg.a;
9943 var newZoom = A3($elm$core$Basics$clamp, 0.1, 5.0, model.zoom - (delta * 0.001));
9944 return _Utils_Tuple2(
9945 _Utils_update(
9946 model,
9947 {zoom: newZoom}),
9948 $elm$core$Platform$Cmd$none);
9949 case 'LinkClicked':
9950 var urlRequest = msg.a;
9951 if (urlRequest.$ === 'Internal') {
9952 var url = urlRequest.a;
9953 return _Utils_Tuple2(
9954 model,
9955 A2(
9956 $elm$browser$Browser$Navigation$pushUrl,
9957 model.navKey,
9958 $elm$url$Url$toString(url)));
9959 } else {
9960 var href = urlRequest.a;
9961 return _Utils_Tuple2(
9962 model,
9963 $elm$browser$Browser$Navigation$load(href));
9964 }
9965 default:
9966 var url = msg.a;
9967 var _v13 = $author$project$Main$parseUrl(url);
9968 switch (_v13.$) {
9969 case 'CnpjRoute':
9970 var cnpj = _v13.a;
9971 var cleanCnpj = function (s) {
9972 return A2(
9973 $elm$core$String$filter,
9974 function (c) {
9975 return $elm$core$Char$isAlphaNum(c) || (_Utils_eq(
9976 c,
9977 _Utils_chr('*')) || _Utils_eq(
9978 c,
9979 _Utils_chr(',')));
9980 },
9981 s);
9982 };
9983 var isSameCnpj = _Utils_eq(
9984 cleanCnpj(cnpj),
9985 cleanCnpj(model.input));
9986 if (isSameCnpj && (!$elm$core$Dict$isEmpty(model.nodes))) {
9987 return _Utils_Tuple2(model, $elm$core$Platform$Cmd$none);
9988 } else {
9989 var reset = _Utils_update(
9990 model,
9991 {
9992 activeTab: $author$project$Types$CnpjTab,
9993 collisionRadius: 50,
9994 currentQueries: _List_Nil,
9995 edges: $elm$core$Set$empty,
9996 input: $author$project$Format$maskMultiple(cnpj),
9997 isInitialSearch: true,
9998 linkDistance: 80,
9999 manyBody: -150,
10000 nodes: $elm$core$Dict$empty,
10001 pending: $elm$core$Set$empty,
10002 queryQueue: _List_Nil,
10003 simulation: A3($author$project$Graph$initSimulation, model.width, model.height, _List_Nil),
10004 url: url,
10005 visited: $elm$core$Set$empty
10006 });
10007 return $author$project$Main$triggerNextQuery(
10008 A2(
10009 $author$project$Main$enqueueQueries,
10010 A3($author$project$Main$queriesFor, cnpj, true, 0),
10011 reset));
10012 }
10013 case 'ConnectionRoute':
10014 var id1 = _v13.a;
10015 var id2 = _v13.b;
10016 var isSame = _Utils_eq(
10017 id1,
10018 A2($elm$core$String$filter, $elm$core$Char$isAlphaNum, model.connectionInput1)) && _Utils_eq(
10019 id2,
10020 A2($elm$core$String$filter, $elm$core$Char$isAlphaNum, model.connectionInput2));
10021 if (isSame && (!$elm$core$Dict$isEmpty(model.nodes))) {
10022 return _Utils_Tuple2(model, $elm$core$Platform$Cmd$none);
10023 } else {
10024 var reset = _Utils_update(
10025 model,
10026 {
10027 activeTab: $author$project$Types$ConnectionTab,
10028 collisionRadius: 50,
10029 connectionInput1: $author$project$Format$mask(id1),
10030 connectionInput2: $author$project$Format$mask(id2),
10031 currentQueries: _List_Nil,
10032 edges: $elm$core$Set$empty,
10033 isInitialSearch: true,
10034 linkDistance: 80,
10035 manyBody: -150,
10036 nodes: $elm$core$Dict$empty,
10037 pending: $elm$core$Set$empty,
10038 queryQueue: _List_Nil,
10039 simulation: A3($author$project$Graph$initSimulation, model.width, model.height, _List_Nil),
10040 url: url,
10041 visited: $elm$core$Set$empty
10042 });
10043 return $author$project$Main$triggerNextQuery(
10044 A2(
10045 $author$project$Main$enqueueQueries,
10046 _List_fromArray(
10047 [
10048 A3(
10049 $author$project$Types$QueryRequest,
10050 id1 + (';' + id2),
10051 0,
10052 A2($author$project$Types$ConnectionQuery, id1, id2))
10053 ]),
10054 reset));
10055 }
10056 default:
10057 return _Utils_Tuple2(
10058 _Utils_update(
10059 model,
10060 {url: url}),
10061 $elm$core$Platform$Cmd$none);
10062 }
10063 }
10064 }
10065 });
10066var $author$project$Types$PanStart = {$: 'PanStart'};
10067var $author$project$Types$Search = {$: 'Search'};
10068var $author$project$Types$SwitchTab = function (a) {
10069 return {$: 'SwitchTab', a: a};
10070};
10071var $author$project$Types$UpdateConnectionInput1 = function (a) {
10072 return {$: 'UpdateConnectionInput1', a: a};
10073};
10074var $author$project$Types$UpdateConnectionInput2 = function (a) {
10075 return {$: 'UpdateConnectionInput2', a: a};
10076};
10077var $author$project$Types$UpdateInput = function (a) {
10078 return {$: 'UpdateInput', a: a};
10079};
10080var $author$project$Types$Zoom = function (a) {
10081 return {$: 'Zoom', a: a};
10082};
10083var $elm$html$Html$a = _VirtualDom_node('a');
10084var $elm$virtual_dom$VirtualDom$attribute = F2(
10085 function (key, value) {
10086 return A2(
10087 _VirtualDom_attribute,
10088 _VirtualDom_noOnOrFormAction(key),
10089 _VirtualDom_noJavaScriptOrHtmlUri(value));
10090 });
10091var $elm$html$Html$Attributes$attribute = $elm$virtual_dom$VirtualDom$attribute;
10092var $elm$html$Html$button = _VirtualDom_node('button');
10093var $elm$json$Json$Encode$string = _Json_wrap;
10094var $elm$html$Html$Attributes$stringProperty = F2(
10095 function (key, string) {
10096 return A2(
10097 _VirtualDom_property,
10098 key,
10099 $elm$json$Json$Encode$string(string));
10100 });
10101var $elm$html$Html$Attributes$class = $elm$html$Html$Attributes$stringProperty('className');
10102var $elm$svg$Svg$Attributes$class = _VirtualDom_attribute('class');
10103var $author$project$Types$Clear = {$: 'Clear'};
10104var $elm$json$Json$Encode$bool = _Json_wrap;
10105var $elm$html$Html$Attributes$boolProperty = F2(
10106 function (key, bool) {
10107 return A2(
10108 _VirtualDom_property,
10109 key,
10110 $elm$json$Json$Encode$bool(bool));
10111 });
10112var $elm$html$Html$Attributes$disabled = $elm$html$Html$Attributes$boolProperty('disabled');
10113var $elm$html$Html$li = _VirtualDom_node('li');
10114var $elm$virtual_dom$VirtualDom$Normal = function (a) {
10115 return {$: 'Normal', a: a};
10116};
10117var $elm$virtual_dom$VirtualDom$on = _VirtualDom_on;
10118var $elm$html$Html$Events$on = F2(
10119 function (event, decoder) {
10120 return A2(
10121 $elm$virtual_dom$VirtualDom$on,
10122 event,
10123 $elm$virtual_dom$VirtualDom$Normal(decoder));
10124 });
10125var $elm$html$Html$Events$onClick = function (msg) {
10126 return A2(
10127 $elm$html$Html$Events$on,
10128 'click',
10129 $elm$json$Json$Decode$succeed(msg));
10130};
10131var $elm$virtual_dom$VirtualDom$text = _VirtualDom_text;
10132var $elm$html$Html$text = $elm$virtual_dom$VirtualDom$text;
10133var $author$project$View$clearButton = function (model) {
10134 return $elm$core$Dict$isEmpty(model.nodes) ? $elm$html$Html$text('') : A2(
10135 $elm$html$Html$li,
10136 _List_Nil,
10137 _List_fromArray(
10138 [
10139 A2(
10140 $elm$html$Html$button,
10141 _List_fromArray(
10142 [
10143 $elm$html$Html$Events$onClick($author$project$Types$Clear),
10144 $elm$html$Html$Attributes$disabled(
10145 !$elm$core$Set$isEmpty(model.pending)),
10146 $elm$html$Html$Attributes$class('secondary')
10147 ]),
10148 _List_fromArray(
10149 [
10150 $elm$html$Html$text('Limpar')
10151 ]))
10152 ]));
10153};
10154var $elm$html$Html$div = _VirtualDom_node('div');
10155var $elm$html$Html$footer = _VirtualDom_node('footer');
10156var $elm$html$Html$Attributes$for = $elm$html$Html$Attributes$stringProperty('htmlFor');
10157var $elm$core$String$fromFloat = _String_fromNumber;
10158var $elm$core$List$all = F2(
10159 function (isOkay, list) {
10160 return !A2(
10161 $elm$core$List$any,
10162 A2($elm$core$Basics$composeL, $elm$core$Basics$not, isOkay),
10163 list);
10164 });
10165var $author$project$View$fullyExplored = function (model) {
10166 return A3(
10167 $elm$core$Dict$foldl,
10168 F3(
10169 function (id, node, acc) {
10170 var needed = function () {
10171 var _v0 = node.entity;
10172 if (_v0.$ === 'Company') {
10173 return _List_fromArray(
10174 [
10175 _Utils_Tuple2(id, 'qsa'),
10176 _Utils_Tuple2(id, 'cnpjs')
10177 ]);
10178 } else {
10179 return _List_fromArray(
10180 [
10181 _Utils_Tuple2(id, 'cnpjs')
10182 ]);
10183 }
10184 }();
10185 var allDone = A2(
10186 $elm$core$List$all,
10187 function (k) {
10188 return A2($elm$core$Set$member, k, model.visited);
10189 },
10190 needed);
10191 return allDone ? A2($elm$core$Set$insert, id, acc) : acc;
10192 }),
10193 $elm$core$Set$empty,
10194 model.nodes);
10195};
10196var $elm$svg$Svg$trustedNode = _VirtualDom_nodeNS('http://www.w3.org/2000/svg');
10197var $elm$svg$Svg$g = $elm$svg$Svg$trustedNode('g');
10198var $elm$html$Html$h1 = _VirtualDom_node('h1');
10199var $elm$html$Html$header = _VirtualDom_node('header');
10200var $elm$svg$Svg$Attributes$height = _VirtualDom_attribute('height');
10201var $elm$html$Html$Attributes$href = function (url) {
10202 return A2(
10203 $elm$html$Html$Attributes$stringProperty,
10204 'href',
10205 _VirtualDom_noJavaScriptUri(url));
10206};
10207var $elm$html$Html$Attributes$id = $elm$html$Html$Attributes$stringProperty('id');
10208var $elm$html$Html$details = _VirtualDom_node('details');
10209var $elm$html$Html$span = _VirtualDom_node('span');
10210var $author$project$View$legend = A2(
10211 $elm$html$Html$div,
10212 _List_fromArray(
10213 [
10214 $elm$html$Html$Attributes$class('legend')
10215 ]),
10216 _List_fromArray(
10217 [
10218 A2(
10219 $elm$html$Html$span,
10220 _List_fromArray(
10221 [
10222 $elm$html$Html$Attributes$class('legend-item')
10223 ]),
10224 _List_fromArray(
10225 [
10226 A2(
10227 $elm$html$Html$span,
10228 _List_fromArray(
10229 [
10230 $elm$html$Html$Attributes$class('legend-dot legend-company-active')
10231 ]),
10232 _List_Nil),
10233 $elm$html$Html$text('Empresa ativa')
10234 ])),
10235 A2(
10236 $elm$html$Html$span,
10237 _List_fromArray(
10238 [
10239 $elm$html$Html$Attributes$class('legend-item')
10240 ]),
10241 _List_fromArray(
10242 [
10243 A2(
10244 $elm$html$Html$span,
10245 _List_fromArray(
10246 [
10247 $elm$html$Html$Attributes$class('legend-dot legend-company-inactive')
10248 ]),
10249 _List_Nil),
10250 $elm$html$Html$text('Empresa inativa')
10251 ])),
10252 A2(
10253 $elm$html$Html$span,
10254 _List_fromArray(
10255 [
10256 $elm$html$Html$Attributes$class('legend-item')
10257 ]),
10258 _List_fromArray(
10259 [
10260 A2(
10261 $elm$html$Html$span,
10262 _List_fromArray(
10263 [
10264 $elm$html$Html$Attributes$class('legend-dot legend-company-unknown')
10265 ]),
10266 _List_Nil),
10267 $elm$html$Html$text('Empresa não encontrada')
10268 ])),
10269 A2(
10270 $elm$html$Html$span,
10271 _List_fromArray(
10272 [
10273 $elm$html$Html$Attributes$class('legend-item')
10274 ]),
10275 _List_fromArray(
10276 [
10277 A2(
10278 $elm$html$Html$span,
10279 _List_fromArray(
10280 [
10281 $elm$html$Html$Attributes$class('legend-dot legend-person')
10282 ]),
10283 _List_Nil),
10284 $elm$html$Html$text('Pessoa física')
10285 ]))
10286 ]));
10287var $elm$html$Html$abbr = _VirtualDom_node('abbr');
10288var $elm$html$Html$em = _VirtualDom_node('em');
10289var $elm$html$Html$small = _VirtualDom_node('small');
10290var $elm$html$Html$Attributes$title = $elm$html$Html$Attributes$stringProperty('title');
10291var $author$project$View$methodologyText = function (tab) {
10292 return A2(
10293 $elm$html$Html$small,
10294 _List_Nil,
10295 _List_fromArray(
10296 [
10297 function () {
10298 if (tab.$ === 'CnpjTab') {
10299 return A2(
10300 $elm$html$Html$div,
10301 _List_Nil,
10302 _List_fromArray(
10303 [
10304 $elm$html$Html$text('A partir do CNPJ informado, o grafo é construído em largura ('),
10305 A2(
10306 $elm$html$Html$abbr,
10307 _List_fromArray(
10308 [
10309 $elm$html$Html$Attributes$title('Busca em largura'),
10310 A2($elm$html$Html$Attributes$attribute, 'aria-label', 'Busca em largura')
10311 ]),
10312 _List_fromArray(
10313 [
10314 A2(
10315 $elm$html$Html$a,
10316 _List_fromArray(
10317 [
10318 $elm$html$Html$Attributes$href('https://pt.wikipedia.org/wiki/Busca_em_largura'),
10319 A2($elm$html$Html$Attributes$attribute, 'target', '_blank'),
10320 A2($elm$html$Html$Attributes$attribute, 'rel', 'noopener noreferrer')
10321 ]),
10322 _List_fromArray(
10323 [
10324 $elm$html$Html$text('BFS')
10325 ]))
10326 ])),
10327 $elm$html$Html$text('): cada empresa traz seus sócios, e cada sócio traz as empresas em que participa. A expansão automática para em '),
10328 A2(
10329 $elm$html$Html$em,
10330 _List_Nil,
10331 _List_fromArray(
10332 [
10333 $elm$html$Html$text('profundidade 8')
10334 ])),
10335 $elm$html$Html$text(' ou '),
10336 A2(
10337 $elm$html$Html$em,
10338 _List_Nil,
10339 _List_fromArray(
10340 [
10341 $elm$html$Html$text('32 nós')
10342 ])),
10343 $elm$html$Html$text(' — o que vier primeiro. A partir daí, clique em qualquer nó com borda destacada para expandi-lo manualmente, um nível por vez, sem novos limites.')
10344 ]));
10345 } else {
10346 return A2(
10347 $elm$html$Html$div,
10348 _List_Nil,
10349 _List_fromArray(
10350 [
10351 $elm$html$Html$text('A API busca o menor caminho de relação entre as duas entidades (sócio-empresa) via busca bidirecional em largura, com limite de 90 segundos. O grafo exibe apenas os nós desse caminho, sem expansão automática. Clique nos nós para explorá-los individualmente. Se não houver caminho, a busca retorna vazia; se ultrapassar 90s, retorna erro de tempo esgotado — o que não significa ausência de conexão, apenas que o cálculo demorou demais.'),
10352 A2(
10353 $elm$html$Html$div,
10354 _List_fromArray(
10355 [
10356 $elm$html$Html$Attributes$class('info-panel-divider')
10357 ]),
10358 _List_Nil),
10359 $elm$html$Html$text('Para pessoas jurídicas, o identificador é o CNPJ. Para pessoas físicas, o identificador é um hash MD5 determinístico do CPF (com os dígitos redactos, tal como divulgados na fonte oficial) e do nome. Para encontrar o ID de uma pessoa, busque primeiro uma empresa da qual ela é sócia (aba CNPJ), clique no nó da pessoa para expandi-lo e copie o ID exibido no rótulo.')
10360 ]));
10361 }
10362 }()
10363 ]));
10364};
10365var $elm$html$Html$summary = _VirtualDom_node('summary');
10366var $author$project$View$infoPanel = F2(
10367 function (tab, isEmpty) {
10368 return A2(
10369 $elm$html$Html$details,
10370 _List_fromArray(
10371 [
10372 $elm$html$Html$Attributes$class('info-panel')
10373 ]),
10374 _List_fromArray(
10375 [
10376 A2(
10377 $elm$html$Html$summary,
10378 _List_Nil,
10379 _List_fromArray(
10380 [
10381 A2(
10382 $elm$html$Html$small,
10383 _List_Nil,
10384 _List_fromArray(
10385 [
10386 $elm$html$Html$text('Como funciona esta busca?')
10387 ]))
10388 ])),
10389 isEmpty ? $author$project$View$methodologyText(tab) : A2(
10390 $elm$html$Html$div,
10391 _List_Nil,
10392 _List_fromArray(
10393 [
10394 $author$project$View$legend,
10395 A2(
10396 $elm$html$Html$div,
10397 _List_fromArray(
10398 [
10399 $elm$html$Html$Attributes$class('info-panel-divider')
10400 ]),
10401 _List_Nil),
10402 $author$project$View$methodologyText(tab)
10403 ]))
10404 ]));
10405 });
10406var $elm$html$Html$input = _VirtualDom_node('input');
10407var $elm$html$Html$label = _VirtualDom_node('label');
10408var $elm$html$Html$main_ = _VirtualDom_node('main');
10409var $elm$html$Html$nav = _VirtualDom_node('nav');
10410var $elm$json$Json$Decode$fail = _Json_fail;
10411var $author$project$View$onEnter = function (msg) {
10412 return A2(
10413 $elm$html$Html$Events$on,
10414 'keydown',
10415 A2(
10416 $elm$json$Json$Decode$andThen,
10417 function (key) {
10418 return (key === 'Enter') ? $elm$json$Json$Decode$succeed(msg) : $elm$json$Json$Decode$fail('not Enter');
10419 },
10420 A2($elm$json$Json$Decode$field, 'key', $elm$json$Json$Decode$string)));
10421};
10422var $elm$html$Html$Events$alwaysStop = function (x) {
10423 return _Utils_Tuple2(x, true);
10424};
10425var $elm$virtual_dom$VirtualDom$MayStopPropagation = function (a) {
10426 return {$: 'MayStopPropagation', a: a};
10427};
10428var $elm$html$Html$Events$stopPropagationOn = F2(
10429 function (event, decoder) {
10430 return A2(
10431 $elm$virtual_dom$VirtualDom$on,
10432 event,
10433 $elm$virtual_dom$VirtualDom$MayStopPropagation(decoder));
10434 });
10435var $elm$json$Json$Decode$at = F2(
10436 function (fields, decoder) {
10437 return A3($elm$core$List$foldr, $elm$json$Json$Decode$field, decoder, fields);
10438 });
10439var $elm$html$Html$Events$targetValue = A2(
10440 $elm$json$Json$Decode$at,
10441 _List_fromArray(
10442 ['target', 'value']),
10443 $elm$json$Json$Decode$string);
10444var $elm$html$Html$Events$onInput = function (tagger) {
10445 return A2(
10446 $elm$html$Html$Events$stopPropagationOn,
10447 'input',
10448 A2(
10449 $elm$json$Json$Decode$map,
10450 $elm$html$Html$Events$alwaysStop,
10451 A2($elm$json$Json$Decode$map, tagger, $elm$html$Html$Events$targetValue)));
10452};
10453var $elm$virtual_dom$VirtualDom$Custom = function (a) {
10454 return {$: 'Custom', a: a};
10455};
10456var $elm$html$Html$Events$custom = F2(
10457 function (event, decoder) {
10458 return A2(
10459 $elm$virtual_dom$VirtualDom$on,
10460 event,
10461 $elm$virtual_dom$VirtualDom$Custom(decoder));
10462 });
10463var $author$project$View$onMouseDown = function (msg) {
10464 return A2(
10465 $elm$html$Html$Events$custom,
10466 'mousedown',
10467 $elm$json$Json$Decode$succeed(
10468 {message: msg, preventDefault: false, stopPropagation: false}));
10469};
10470var $elm$virtual_dom$VirtualDom$MayPreventDefault = function (a) {
10471 return {$: 'MayPreventDefault', a: a};
10472};
10473var $elm$html$Html$Events$preventDefaultOn = F2(
10474 function (event, decoder) {
10475 return A2(
10476 $elm$virtual_dom$VirtualDom$on,
10477 event,
10478 $elm$virtual_dom$VirtualDom$MayPreventDefault(decoder));
10479 });
10480var $author$project$View$onWheel = function (tagger) {
10481 return A2(
10482 $elm$html$Html$Events$preventDefaultOn,
10483 'wheel',
10484 A2(
10485 $elm$json$Json$Decode$map,
10486 function (delta) {
10487 return _Utils_Tuple2(
10488 tagger(delta),
10489 true);
10490 },
10491 A2($elm$json$Json$Decode$field, 'deltaY', $elm$json$Json$Decode$float)));
10492};
10493var $elm$html$Html$Attributes$placeholder = $elm$html$Html$Attributes$stringProperty('placeholder');
10494var $author$project$View$preventDefaultOnClick = function (msg) {
10495 return A2(
10496 $elm$html$Html$Events$preventDefaultOn,
10497 'click',
10498 $elm$json$Json$Decode$succeed(
10499 _Utils_Tuple2(msg, true)));
10500};
10501var $elm$core$Set$size = function (_v0) {
10502 var dict = _v0.a;
10503 return $elm$core$Dict$size(dict);
10504};
10505var $elm$svg$Svg$svg = $elm$svg$Svg$trustedNode('svg');
10506var $elm$svg$Svg$Attributes$transform = _VirtualDom_attribute('transform');
10507var $elm$html$Html$ul = _VirtualDom_node('ul');
10508var $elm$html$Html$Attributes$value = $elm$html$Html$Attributes$stringProperty('value');
10509var $elm$svg$Svg$line = $elm$svg$Svg$trustedNode('line');
10510var $elm$svg$Svg$Events$custom = $elm$html$Html$Events$custom;
10511var $author$project$View$stopPropagationOnMouseDown = A2(
10512 $elm$svg$Svg$Events$custom,
10513 'mousedown',
10514 $elm$json$Json$Decode$succeed(
10515 {
10516 message: A2($author$project$Types$InteractionMove, 0, 0),
10517 preventDefault: false,
10518 stopPropagation: true
10519 }));
10520var $elm$svg$Svg$Attributes$x1 = _VirtualDom_attribute('x1');
10521var $elm$svg$Svg$Attributes$x2 = _VirtualDom_attribute('x2');
10522var $elm$svg$Svg$Attributes$y1 = _VirtualDom_attribute('y1');
10523var $elm$svg$Svg$Attributes$y2 = _VirtualDom_attribute('y2');
10524var $author$project$View$viewEdge = F2(
10525 function (nodes, _v0) {
10526 var s = _v0.a;
10527 var t = _v0.b;
10528 var _v1 = _Utils_Tuple2(
10529 A2($elm$core$Dict$get, s, nodes),
10530 A2($elm$core$Dict$get, t, nodes));
10531 if ((_v1.a.$ === 'Just') && (_v1.b.$ === 'Just')) {
10532 var sn = _v1.a.a;
10533 var tn = _v1.b.a;
10534 return $elm$core$Maybe$Just(
10535 A2(
10536 $elm$svg$Svg$line,
10537 _List_fromArray(
10538 [
10539 $elm$svg$Svg$Attributes$x1(
10540 $elm$core$String$fromFloat(sn.x)),
10541 $elm$svg$Svg$Attributes$y1(
10542 $elm$core$String$fromFloat(sn.y)),
10543 $elm$svg$Svg$Attributes$x2(
10544 $elm$core$String$fromFloat(tn.x)),
10545 $elm$svg$Svg$Attributes$y2(
10546 $elm$core$String$fromFloat(tn.y)),
10547 $elm$svg$Svg$Attributes$class('edge'),
10548 $author$project$View$stopPropagationOnMouseDown
10549 ]),
10550 _List_Nil));
10551 } else {
10552 return $elm$core$Maybe$Nothing;
10553 }
10554 });
10555var $elm$svg$Svg$a = $elm$svg$Svg$trustedNode('a');
10556var $elm$svg$Svg$circle = $elm$svg$Svg$trustedNode('circle');
10557var $author$project$View$companyStatusClass = function (status) {
10558 switch (status.$) {
10559 case 'StatusLoading':
10560 return 'company-active';
10561 case 'StatusActive':
10562 return 'company-active';
10563 case 'StatusInactive':
10564 return 'company-inactive';
10565 default:
10566 return 'company-unknown';
10567 }
10568};
10569var $elm$svg$Svg$Attributes$dy = _VirtualDom_attribute('dy');
10570var $author$project$Types$InteractionStart = F3(
10571 function (a, b, c) {
10572 return {$: 'InteractionStart', a: a, b: b, c: c};
10573 });
10574var $elm$json$Json$Decode$map3 = _Json_map3;
10575var $author$project$View$onNodeMouseDown = function (node) {
10576 return A2(
10577 $elm$svg$Svg$Events$custom,
10578 'mousedown',
10579 A4(
10580 $elm$json$Json$Decode$map3,
10581 F3(
10582 function (id, x, y) {
10583 return {
10584 message: A3($author$project$Types$InteractionStart, id, x, y),
10585 preventDefault: false,
10586 stopPropagation: true
10587 };
10588 }),
10589 $elm$json$Json$Decode$succeed(node.id),
10590 A2($elm$json$Json$Decode$field, 'clientX', $elm$json$Json$Decode$float),
10591 A2($elm$json$Json$Decode$field, 'clientY', $elm$json$Json$Decode$float)));
10592};
10593var $elm$svg$Svg$Attributes$r = _VirtualDom_attribute('r');
10594var $elm$svg$Svg$Attributes$textAnchor = _VirtualDom_attribute('text-anchor');
10595var $elm$svg$Svg$text_ = $elm$svg$Svg$trustedNode('text');
10596var $elm$svg$Svg$Attributes$xlinkHref = function (value) {
10597 return A3(
10598 _VirtualDom_attributeNS,
10599 'http://www.w3.org/1999/xlink',
10600 'xlink:href',
10601 _VirtualDom_noJavaScriptUri(value));
10602};
10603var $author$project$View$viewNode = F3(
10604 function (jsonApi, visited, node) {
10605 var labelStr = function () {
10606 var _v6 = node.entity;
10607 if (_v6.$ === 'Company') {
10608 var name = _v6.a;
10609 var cnpj = _v6.b;
10610 var maskedCnpj = $author$project$Format$mask(cnpj);
10611 return $elm$core$String$isEmpty(cnpj) ? name : ((_Utils_eq(name, cnpj) || $elm$core$String$isEmpty(name)) ? maskedCnpj : (name + (' (' + (maskedCnpj + ')'))));
10612 } else {
10613 var name = _v6.a;
10614 var cpf = _v6.b;
10615 if (cpf.$ === 'Just') {
10616 var c = cpf.a;
10617 var maskedCpf = $author$project$Format$mask(c);
10618 return _Utils_eq(name, maskedCpf) ? maskedCpf : (name + (' (' + (maskedCpf + ')')));
10619 } else {
10620 return name;
10621 }
10622 }
10623 }();
10624 var plainLabel = A2(
10625 $elm$svg$Svg$text_,
10626 _List_fromArray(
10627 [
10628 $elm$svg$Svg$Attributes$dy('18'),
10629 $elm$svg$Svg$Attributes$textAnchor('middle'),
10630 $elm$svg$Svg$Attributes$class('node-label'),
10631 $author$project$View$stopPropagationOnMouseDown
10632 ]),
10633 _List_fromArray(
10634 [
10635 $elm$html$Html$text(labelStr)
10636 ]));
10637 var labelElement = function () {
10638 var _v3 = _Utils_Tuple2(node.entity, node.error);
10639 if ((_v3.a.$ === 'Company') && (_v3.b.$ === 'Nothing')) {
10640 var _v4 = _v3.a;
10641 var cnpj = _v4.b;
10642 var _v5 = _v3.b;
10643 var url = (A2($elm$core$String$right, 1, jsonApi) === '/') ? _Utils_ap(jsonApi, cnpj) : (jsonApi + ('/' + cnpj));
10644 return A2(
10645 $elm$svg$Svg$a,
10646 _List_fromArray(
10647 [
10648 $elm$svg$Svg$Attributes$xlinkHref(url),
10649 A2($elm$html$Html$Attributes$attribute, 'href', url),
10650 A2($elm$html$Html$Attributes$attribute, 'target', '_blank'),
10651 A2($elm$html$Html$Attributes$attribute, 'rel', 'noopener noreferrer')
10652 ]),
10653 _List_fromArray(
10654 [
10655 A2(
10656 $elm$svg$Svg$text_,
10657 _List_fromArray(
10658 [
10659 $elm$svg$Svg$Attributes$dy('18'),
10660 $elm$svg$Svg$Attributes$textAnchor('middle'),
10661 $elm$svg$Svg$Attributes$class('node-label link'),
10662 $author$project$View$stopPropagationOnMouseDown
10663 ]),
10664 _List_fromArray(
10665 [
10666 $elm$html$Html$text(labelStr)
10667 ]))
10668 ]));
10669 } else {
10670 return plainLabel;
10671 }
10672 }();
10673 var isVisited = A2($elm$core$Set$member, node.id, visited);
10674 var isRoot = !node.depth;
10675 var errorElement = function () {
10676 var _v2 = node.error;
10677 if (_v2.$ === 'Just') {
10678 var msg = _v2.a;
10679 return A2(
10680 $elm$svg$Svg$text_,
10681 _List_fromArray(
10682 [
10683 $elm$svg$Svg$Attributes$dy('32'),
10684 $elm$svg$Svg$Attributes$textAnchor('middle'),
10685 $elm$svg$Svg$Attributes$class('node-error'),
10686 $author$project$View$stopPropagationOnMouseDown
10687 ]),
10688 _List_fromArray(
10689 [
10690 $elm$html$Html$text(msg)
10691 ]));
10692 } else {
10693 return $elm$html$Html$text('');
10694 }
10695 }();
10696 var _v0 = function () {
10697 var _v1 = node.entity;
10698 if (_v1.$ === 'Company') {
10699 var situacao = _v1.c;
10700 return _Utils_Tuple2(
10701 'node-company ' + $author$project$View$companyStatusClass(situacao),
10702 8);
10703 } else {
10704 return _Utils_Tuple2('node-person', 5);
10705 }
10706 }();
10707 var nodeClass = _v0.a;
10708 var baseRadius = _v0.b;
10709 var radius = isRoot ? (baseRadius + 6) : (isVisited ? baseRadius : (baseRadius + 2));
10710 return A2(
10711 $elm$svg$Svg$g,
10712 _List_fromArray(
10713 [
10714 $elm$svg$Svg$Attributes$transform(
10715 'translate(' + ($elm$core$String$fromFloat(node.x) + (',' + ($elm$core$String$fromFloat(node.y) + ')')))),
10716 $elm$svg$Svg$Attributes$class(
10717 isRoot ? 'node-group root' : 'node-group')
10718 ]),
10719 _List_fromArray(
10720 [
10721 A2(
10722 $elm$svg$Svg$circle,
10723 _List_fromArray(
10724 [
10725 $elm$svg$Svg$Attributes$r(
10726 $elm$core$String$fromFloat(radius)),
10727 $elm$svg$Svg$Attributes$class(
10728 _Utils_ap(
10729 nodeClass,
10730 _Utils_ap(
10731 isVisited ? ' visited' : ' expandable',
10732 _Utils_ap(
10733 (!_Utils_eq(node.error, $elm$core$Maybe$Nothing)) ? ' errored' : '',
10734 isRoot ? ' root' : '')))),
10735 $author$project$View$onNodeMouseDown(node)
10736 ]),
10737 _List_Nil),
10738 labelElement,
10739 errorElement
10740 ]));
10741 });
10742var $elm$svg$Svg$Attributes$width = _VirtualDom_attribute('width');
10743var $author$project$View$view = function (model) {
10744 var nodeList = $elm$core$Dict$values(model.nodes);
10745 var peopleCount = $elm$core$List$length(
10746 A2(
10747 $elm$core$List$filter,
10748 function (n) {
10749 var _v3 = n.entity;
10750 if (_v3.$ === 'Person') {
10751 return true;
10752 } else {
10753 return false;
10754 }
10755 },
10756 nodeList));
10757 var companiesCount = $elm$core$List$length(
10758 A2(
10759 $elm$core$List$filter,
10760 function (n) {
10761 var _v2 = n.entity;
10762 if (_v2.$ === 'Company') {
10763 return true;
10764 } else {
10765 return false;
10766 }
10767 },
10768 nodeList));
10769 return A2(
10770 $elm$html$Html$div,
10771 _List_fromArray(
10772 [
10773 $elm$html$Html$Attributes$class('app-root')
10774 ]),
10775 _List_fromArray(
10776 [
10777 A2(
10778 $elm$html$Html$header,
10779 _List_fromArray(
10780 [
10781 $elm$html$Html$Attributes$class('app-header')
10782 ]),
10783 _List_fromArray(
10784 [
10785 A2(
10786 $elm$html$Html$nav,
10787 _List_Nil,
10788 _List_fromArray(
10789 [
10790 A2(
10791 $elm$html$Html$ul,
10792 _List_Nil,
10793 _List_fromArray(
10794 [
10795 A2(
10796 $elm$html$Html$li,
10797 _List_Nil,
10798 _List_fromArray(
10799 [
10800 A2(
10801 $elm$html$Html$h1,
10802 _List_Nil,
10803 _List_fromArray(
10804 [
10805 $elm$html$Html$text('Meu Garfo')
10806 ]))
10807 ])),
10808 A2(
10809 $elm$html$Html$li,
10810 _List_Nil,
10811 _List_fromArray(
10812 [
10813 A2(
10814 $elm$html$Html$a,
10815 _List_fromArray(
10816 [
10817 $elm$html$Html$Attributes$href('#'),
10818 $author$project$View$preventDefaultOnClick(
10819 $author$project$Types$SwitchTab($author$project$Types$CnpjTab)),
10820 $elm$html$Html$Attributes$class(
10821 _Utils_eq(model.activeTab, $author$project$Types$CnpjTab) ? '' : 'secondary'),
10822 A2(
10823 $elm$html$Html$Attributes$attribute,
10824 'style',
10825 _Utils_eq(model.activeTab, $author$project$Types$CnpjTab) ? 'font-weight: bold; border-bottom: 2px solid var(--pico-primary); border-radius: 0;' : '')
10826 ]),
10827 _List_fromArray(
10828 [
10829 $elm$html$Html$text('CNPJ')
10830 ]))
10831 ])),
10832 A2(
10833 $elm$html$Html$li,
10834 _List_Nil,
10835 _List_fromArray(
10836 [
10837 A2(
10838 $elm$html$Html$a,
10839 _List_fromArray(
10840 [
10841 $elm$html$Html$Attributes$href('#'),
10842 $author$project$View$preventDefaultOnClick(
10843 $author$project$Types$SwitchTab($author$project$Types$ConnectionTab)),
10844 $elm$html$Html$Attributes$class(
10845 _Utils_eq(model.activeTab, $author$project$Types$ConnectionTab) ? '' : 'secondary'),
10846 A2(
10847 $elm$html$Html$Attributes$attribute,
10848 'style',
10849 _Utils_eq(model.activeTab, $author$project$Types$ConnectionTab) ? 'font-weight: bold; border-bottom: 2px solid var(--pico-primary); border-radius: 0;' : '')
10850 ]),
10851 _List_fromArray(
10852 [
10853 $elm$html$Html$text('Conexões')
10854 ]))
10855 ]))
10856 ])),
10857 A2(
10858 $elm$html$Html$ul,
10859 _List_fromArray(
10860 [
10861 $elm$html$Html$Attributes$class('controls')
10862 ]),
10863 function () {
10864 var _v0 = model.activeTab;
10865 if (_v0.$ === 'CnpjTab') {
10866 return _List_fromArray(
10867 [
10868 A2(
10869 $elm$html$Html$li,
10870 _List_Nil,
10871 _List_fromArray(
10872 [
10873 A2(
10874 $elm$html$Html$label,
10875 _List_fromArray(
10876 [
10877 $elm$html$Html$Attributes$for('cnpj-input')
10878 ]),
10879 _List_fromArray(
10880 [
10881 $elm$html$Html$text('CNPJ')
10882 ])),
10883 A2(
10884 $elm$html$Html$input,
10885 _List_fromArray(
10886 [
10887 $elm$html$Html$Attributes$id('cnpj-input'),
10888 $elm$html$Html$Attributes$class('cnpj-input'),
10889 $elm$html$Html$Attributes$placeholder('00.000.000/0000-00'),
10890 $elm$html$Html$Attributes$value(model.input),
10891 $elm$html$Html$Events$onInput($author$project$Types$UpdateInput),
10892 $author$project$View$onEnter($author$project$Types$Search),
10893 A2($elm$html$Html$Attributes$attribute, 'aria-label', 'CNPJ')
10894 ]),
10895 _List_Nil)
10896 ])),
10897 A2(
10898 $elm$html$Html$li,
10899 _List_Nil,
10900 _List_fromArray(
10901 [
10902 A2(
10903 $elm$html$Html$button,
10904 _List_fromArray(
10905 [
10906 $elm$html$Html$Events$onClick($author$project$Types$Search),
10907 $elm$html$Html$Attributes$disabled(
10908 !$elm$core$Set$isEmpty(model.pending)),
10909 $elm$html$Html$Attributes$class('primary')
10910 ]),
10911 _List_fromArray(
10912 [
10913 $elm$html$Html$text(
10914 (!$elm$core$Set$isEmpty(model.pending)) ? 'Carregando...' : 'Buscar')
10915 ]))
10916 ])),
10917 $author$project$View$clearButton(model)
10918 ]);
10919 } else {
10920 return _List_fromArray(
10921 [
10922 A2(
10923 $elm$html$Html$li,
10924 _List_Nil,
10925 _List_fromArray(
10926 [
10927 A2(
10928 $elm$html$Html$label,
10929 _List_fromArray(
10930 [
10931 $elm$html$Html$Attributes$for('connection-input-1')
10932 ]),
10933 _List_fromArray(
10934 [
10935 $elm$html$Html$text('Origem')
10936 ])),
10937 A2(
10938 $elm$html$Html$input,
10939 _List_fromArray(
10940 [
10941 $elm$html$Html$Attributes$id('connection-input-1'),
10942 $elm$html$Html$Attributes$class('cnpj-input'),
10943 $elm$html$Html$Attributes$placeholder('CNPJ ou ID'),
10944 $elm$html$Html$Attributes$value(model.connectionInput1),
10945 $elm$html$Html$Events$onInput($author$project$Types$UpdateConnectionInput1),
10946 $author$project$View$onEnter($author$project$Types$Search),
10947 A2($elm$html$Html$Attributes$attribute, 'aria-label', 'Origem')
10948 ]),
10949 _List_Nil)
10950 ])),
10951 A2(
10952 $elm$html$Html$li,
10953 _List_Nil,
10954 _List_fromArray(
10955 [
10956 A2(
10957 $elm$html$Html$label,
10958 _List_fromArray(
10959 [
10960 $elm$html$Html$Attributes$for('connection-input-2')
10961 ]),
10962 _List_fromArray(
10963 [
10964 $elm$html$Html$text('Destino')
10965 ])),
10966 A2(
10967 $elm$html$Html$input,
10968 _List_fromArray(
10969 [
10970 $elm$html$Html$Attributes$id('connection-input-2'),
10971 $elm$html$Html$Attributes$class('cnpj-input'),
10972 $elm$html$Html$Attributes$placeholder('CNPJ ou ID'),
10973 $elm$html$Html$Attributes$value(model.connectionInput2),
10974 $elm$html$Html$Events$onInput($author$project$Types$UpdateConnectionInput2),
10975 $author$project$View$onEnter($author$project$Types$Search),
10976 A2($elm$html$Html$Attributes$attribute, 'aria-label', 'Destino')
10977 ]),
10978 _List_Nil)
10979 ])),
10980 A2(
10981 $elm$html$Html$li,
10982 _List_Nil,
10983 _List_fromArray(
10984 [
10985 A2(
10986 $elm$html$Html$button,
10987 _List_fromArray(
10988 [
10989 $elm$html$Html$Events$onClick($author$project$Types$Search),
10990 $elm$html$Html$Attributes$disabled(
10991 !$elm$core$Set$isEmpty(model.pending)),
10992 $elm$html$Html$Attributes$class('primary')
10993 ]),
10994 _List_fromArray(
10995 [
10996 $elm$html$Html$text(
10997 (!$elm$core$Set$isEmpty(model.pending)) ? 'Carregando...' : 'Buscar')
10998 ]))
10999 ])),
11000 $author$project$View$clearButton(model)
11001 ]);
11002 }
11003 }())
11004 ]))
11005 ])),
11006 A2(
11007 $elm$html$Html$main_,
11008 _List_fromArray(
11009 [
11010 $elm$html$Html$Attributes$class('graph-viewport'),
11011 $author$project$View$onWheel($author$project$Types$Zoom)
11012 ]),
11013 _List_fromArray(
11014 [
11015 A2(
11016 $elm$svg$Svg$svg,
11017 _List_fromArray(
11018 [
11019 $elm$svg$Svg$Attributes$class('graph-svg'),
11020 $elm$svg$Svg$Attributes$width(
11021 $elm$core$String$fromFloat(model.width)),
11022 $elm$svg$Svg$Attributes$height(
11023 $elm$core$String$fromFloat(model.height)),
11024 $author$project$View$onMouseDown($author$project$Types$PanStart)
11025 ]),
11026 _List_fromArray(
11027 [
11028 A2(
11029 $elm$svg$Svg$g,
11030 _List_fromArray(
11031 [
11032 $elm$svg$Svg$Attributes$transform(
11033 'translate(' + ($elm$core$String$fromFloat(model.pan.x) + (',' + ($elm$core$String$fromFloat(model.pan.y) + (') scale(' + ($elm$core$String$fromFloat(model.zoom) + ')'))))))
11034 ]),
11035 _List_fromArray(
11036 [
11037 A2(
11038 $elm$svg$Svg$g,
11039 _List_Nil,
11040 A2(
11041 $elm$core$List$filterMap,
11042 $author$project$View$viewEdge(model.nodes),
11043 $elm$core$Set$toList(model.edges))),
11044 A2(
11045 $elm$svg$Svg$g,
11046 _List_Nil,
11047 A2(
11048 $elm$core$List$map,
11049 A2(
11050 $author$project$View$viewNode,
11051 model.jsonApi,
11052 $author$project$View$fullyExplored(model)),
11053 $elm$core$Dict$values(model.nodes)))
11054 ]))
11055 ])),
11056 function () {
11057 var _v1 = model.error;
11058 if (_v1.$ === 'Just') {
11059 var err = _v1.a;
11060 return A2(
11061 $elm$html$Html$div,
11062 _List_fromArray(
11063 [
11064 $elm$html$Html$Attributes$class('error-overlay')
11065 ]),
11066 _List_fromArray(
11067 [
11068 A2(
11069 $elm$html$Html$small,
11070 _List_Nil,
11071 _List_fromArray(
11072 [
11073 $elm$html$Html$text(err)
11074 ]))
11075 ]));
11076 } else {
11077 return $elm$html$Html$text('');
11078 }
11079 }(),
11080 A2(
11081 $elm$html$Html$div,
11082 _List_fromArray(
11083 [
11084 $elm$html$Html$Attributes$class('status-overlay')
11085 ]),
11086 _List_fromArray(
11087 [
11088 A2(
11089 $elm$html$Html$small,
11090 _List_Nil,
11091 _List_fromArray(
11092 [
11093 $elm$html$Html$text(
11094 $elm$core$String$fromInt(companiesCount) + (' pessoas jurídicas, ' + ($elm$core$String$fromInt(peopleCount) + (' pessoas físicas, ' + ($elm$core$String$fromInt(
11095 $elm$core$Set$size(model.edges)) + ' conexões'))))),
11096 (!$elm$core$Set$isEmpty(model.pending)) ? A2(
11097 $elm$html$Html$span,
11098 _List_fromArray(
11099 [
11100 $elm$html$Html$Attributes$class('loading-indicator')
11101 ]),
11102 _List_fromArray(
11103 [
11104 $elm$html$Html$text(
11105 ' (Processando fila: ' + ($elm$core$String$fromInt(
11106 $elm$core$List$length(model.queryQueue)) + ')'))
11107 ])) : $elm$html$Html$text('')
11108 ]))
11109 ])),
11110 A2(
11111 $author$project$View$infoPanel,
11112 model.activeTab,
11113 $elm$core$Dict$isEmpty(model.nodes))
11114 ])),
11115 A2(
11116 $elm$html$Html$footer,
11117 _List_fromArray(
11118 [
11119 $elm$html$Html$Attributes$class('app-footer')
11120 ]),
11121 _List_fromArray(
11122 [
11123 A2(
11124 $elm$html$Html$small,
11125 _List_Nil,
11126 _List_fromArray(
11127 [
11128 A2(
11129 $elm$html$Html$a,
11130 _List_fromArray(
11131 [
11132 $elm$html$Html$Attributes$href('https://tangled.org/cuducos.me/meu-garfo')
11133 ]),
11134 _List_fromArray(
11135 [
11136 $elm$html$Html$text('Código aberto')
11137 ])),
11138 $elm$html$Html$text(' 🩷 '),
11139 $elm$html$Html$text('Parte do '),
11140 A2(
11141 $elm$html$Html$a,
11142 _List_fromArray(
11143 [
11144 $elm$html$Html$Attributes$href('https://apoia.se/minhareceita')
11145 ]),
11146 _List_fromArray(
11147 [
11148 $elm$html$Html$text('Minha Receita')
11149 ]))
11150 ]))
11151 ]))
11152 ]));
11153};
11154var $author$project$Main$main = $elm$browser$Browser$application(
11155 {
11156 init: $author$project$Main$init,
11157 onUrlChange: $author$project$Types$UrlChanged,
11158 onUrlRequest: $author$project$Types$LinkClicked,
11159 subscriptions: $author$project$Main$subscriptions,
11160 update: $author$project$Main$update,
11161 view: function (model) {
11162 return {
11163 body: _List_fromArray(
11164 [
11165 $author$project$View$view(model)
11166 ]),
11167 title: 'Meu Garfo'
11168 };
11169 }
11170 });
11171_Platform_export({'Main':{'init':$author$project$Main$main(
11172 A2(
11173 $elm$json$Json$Decode$andThen,
11174 function (jsonApi) {
11175 return A2(
11176 $elm$json$Json$Decode$andThen,
11177 function (graphApi) {
11178 return $elm$json$Json$Decode$succeed(
11179 {graphApi: graphApi, jsonApi: jsonApi});
11180 },
11181 A2($elm$json$Json$Decode$field, 'graphApi', $elm$json$Json$Decode$string));
11182 },
11183 A2($elm$json$Json$Decode$field, 'jsonApi', $elm$json$Json$Decode$string)))(0)}});}(this));